diff --git a/Cargo.lock b/Cargo.lock index 80789e6..ea12932 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -132,10 +132,14 @@ version = "0.1.0" dependencies = [ "bigdecimal", "clap", - "gpsl", + "env_logger", + "log", "primitive-types", "rand 0.7.3", "rand_chacha 0.3.1", + "serde", + "serde_json", + "uuid", ] [[package]] @@ -191,15 +195,6 @@ dependencies = [ "wasi 0.11.0+wasi-snapshot-preview1", ] -[[package]] -name = "gpsl" -version = "0.1.0" -dependencies = [ - "env_logger", - "log", - "uuid", -] - [[package]] name = "hashbrown" version = "0.12.2" @@ -263,6 +258,12 @@ dependencies = [ "hashbrown", ] +[[package]] +name = "itoa" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "112c678d4050afce233f4f2852bb2eb519230b3cf12f33585275537d7e41578d" + [[package]] name = "libc" version = "0.2.126" @@ -521,11 +522,42 @@ version = "2.1.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "3e75f6a532d0fd9f7f13144f392b6ad56a32696bfcd9c78f797f16bbb6f072d6" +[[package]] +name = "ryu" +version = "1.0.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f3f6f92acf49d1b98f7a81226834412ada05458b7364277387724a237f062695" + [[package]] name = "serde" version = "1.0.139" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "0171ebb889e45aa68b44aee0859b3eede84c6f5f5c228e6f140c0b2a0a46cad6" +dependencies = [ + "serde_derive", +] + +[[package]] +name = "serde_derive" +version = "1.0.139" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dc1d3230c1de7932af58ad8ffbe1d784bd55efd5a9d84ac24f69c72d83543dfb" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "serde_json" +version = "1.0.82" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "82c2c1fdcd807d1098552c5b9a36e425e42e9fbd7c6a37a8425f390f781f7fa7" +dependencies = [ + "itoa", + "ryu", + "serde", +] [[package]] name = "static_assertions" diff --git a/Cargo.toml b/Cargo.toml index 08c48c0..267034d 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -10,5 +10,9 @@ bigdecimal = "0.3.0" primitive-types = "0.11.1" rand = {version = "0.7.3"} rand_chacha = "*" -gpsl = { path = "./gpsl" } clap = { version = "3.2.8", features = ["derive"] } +uuid = { version = "0.8.1", features = ["serde", "v4"] } +log = "0.4.0" +env_logger = "0.8.4" +serde = { version = "1.0", features = ["derive"] } +serde_json = "*" diff --git a/src/gpsl/bin/gpsl.rs b/src/gpsl/bin/gpsl.rs new file mode 100644 index 0000000..e21b179 --- /dev/null +++ b/src/gpsl/bin/gpsl.rs @@ -0,0 +1,29 @@ +use gpsl::{ + vm::gpsl::GPSL, + source::Source, + external_function::*, + tokenizer::Tokenizer, + parser::Parser +}; +use std::{fs, env, collections::HashMap}; +fn main() { + env::set_var("RUST_LOG", "info"); + env_logger::init(); + + let args: Vec = env::args().collect(); + let mut source = Source::new(fs::read_to_string(&(args.last().unwrap())).expect("Cannot read file.")); + + let mut tokenizer = Tokenizer::new(); + tokenizer.tokenize(&mut source).unwrap(); + + let mut parser = Parser { + tokenizer, + local_vars: HashMap::new() + }; + + let mut gpsl = GPSL::new(source, Some(parser.functions().unwrap()), vec![STD_FUNC]); + let res = gpsl.run("main".to_string(), vec![]); + if let Err(err) = res { + println!("Error: {:?}", err); + } +} diff --git a/src/gpsl/bin/test.rs b/src/gpsl/bin/test.rs new file mode 100644 index 0000000..c6d4b50 --- /dev/null +++ b/src/gpsl/bin/test.rs @@ -0,0 +1,19 @@ + +use std::collections::VecDeque; + +fn main() { + println!("testing binary"); + + let mut queue: VecDeque = VecDeque::new(); + + queue.push_back(1i64); + queue.push_back(2i64); + queue.push_back(3i64); + + for x in 0..queue.len() { + println!("{}", queue[x]); + } + + println!("{:?}", queue); + println!("{:?}", queue.len()); +} \ No newline at end of file diff --git a/src/gpsl/external_function.rs b/src/gpsl/external_function.rs new file mode 100644 index 0000000..33c5172 --- /dev/null +++ b/src/gpsl/external_function.rs @@ -0,0 +1,86 @@ +use serde::Deserializer; + +use crate::gpsl::{permission::Permission, variable::Variable}; +use std::{io::Read, net::TcpStream}; + +#[derive(PartialEq)] +pub enum ExternalFuncStatus { + SUCCESS, + NOTFOUND, + ERROR, + REJECTED, +} + +pub struct ExternalFuncReturn { + pub status: ExternalFuncStatus, + pub value: Option, +} + +pub struct ExternalFuncCallData { + pub stream: Option, +} + +#[allow(dead_code)] +pub const STD_FUNC: fn( + String, + Vec, + Vec, + Vec, + Option, +) -> ExternalFuncReturn = |name, args, accept, reject, data| { + let name = name.as_str(); + match name { + "println" => { + if accept.contains(&Permission::StdIo) && !reject.contains(&Permission::StdIo) { + match &args[0] { + Variable::Text { value } => println!("{}", value), + Variable::Number { value } => println!("{}", value), + _ => {} + } + ExternalFuncReturn { + status: ExternalFuncStatus::SUCCESS, + value: None, + } + } else { + ExternalFuncReturn { + status: ExternalFuncStatus::REJECTED, + value: None, + } + } + } + "print" => { + if accept.contains(&Permission::StdIo) && !reject.contains(&Permission::StdIo) { + match &args[0] { + Variable::Text { value } => print!("{}", value), + Variable::Number { value } => print!("{}", value), + _ => {} + } + ExternalFuncReturn { + status: ExternalFuncStatus::SUCCESS, + value: None, + } + } else { + ExternalFuncReturn { + status: ExternalFuncStatus::REJECTED, + value: None, + } + } + } + "receive" => { + let mut buffer = String::default(); + data.unwrap() + .stream + .unwrap() + .read_to_string(&mut buffer) + .unwrap(); + ExternalFuncReturn { + status: ExternalFuncStatus::SUCCESS, + value: Some(serde_json::from_str(&buffer).unwrap()), + } + } + _ => ExternalFuncReturn { + status: ExternalFuncStatus::NOTFOUND, + value: None, + }, + } +}; diff --git a/src/gpsl/grammar/.antlr/GPSLLexer.interp b/src/gpsl/grammar/.antlr/GPSLLexer.interp new file mode 100644 index 0000000..f3daabb --- /dev/null +++ b/src/gpsl/grammar/.antlr/GPSLLexer.interp @@ -0,0 +1,131 @@ +token literal names: +null +null +'+' +'-' +'*' +'/' +'&&' +'&' +'=' +'==' +'!=' +'>=' +'<=' +'>' +'<' +';' +':' +',' +'.' +'"' +'+=' +'-=' +'*=' +'/=' +'(' +')' +'{' +'}' +'->' +'fn' +'for' +'while' +'if' +'else' +'let' +'return' +null +null +null + +token symbolic names: +null +WS +ADD +SUB +MUL +DIV +CONJ +AND +EQ +EQEQ +NE +BE +LE +BT +LT +SEMICOLON +COLON +COMMA +DOT +QUOTE +ADD_ASSIGNMENT +SUB_ASSIGNMENT +MUL_ASSIGNMENT +DIV_ASSIGNMENT +LPAREN +RPAREN +LCURL +RCURL +ARROW +FN +FOR +WHILE +IF +ELSE +LET +RETURN +NUM +TEXT +IDENT + +rule names: +WS +ADD +SUB +MUL +DIV +CONJ +AND +EQ +EQEQ +NE +BE +LE +BT +LT +SEMICOLON +COLON +COMMA +DOT +QUOTE +ADD_ASSIGNMENT +SUB_ASSIGNMENT +MUL_ASSIGNMENT +DIV_ASSIGNMENT +LPAREN +RPAREN +LCURL +RCURL +ARROW +FN +FOR +WHILE +IF +ELSE +LET +RETURN +NUM +TEXT +IDENT + +channel names: +DEFAULT_TOKEN_CHANNEL +HIDDEN + +mode names: +DEFAULT_MODE + +atn: +[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 2, 40, 200, 8, 1, 4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7, 4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13, 9, 13, 4, 14, 9, 14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4, 18, 9, 18, 4, 19, 9, 19, 4, 20, 9, 20, 4, 21, 9, 21, 4, 22, 9, 22, 4, 23, 9, 23, 4, 24, 9, 24, 4, 25, 9, 25, 4, 26, 9, 26, 4, 27, 9, 27, 4, 28, 9, 28, 4, 29, 9, 29, 4, 30, 9, 30, 4, 31, 9, 31, 4, 32, 9, 32, 4, 33, 9, 33, 4, 34, 9, 34, 4, 35, 9, 35, 4, 36, 9, 36, 4, 37, 9, 37, 4, 38, 9, 38, 4, 39, 9, 39, 3, 2, 3, 2, 3, 2, 3, 2, 3, 3, 3, 3, 3, 4, 3, 4, 3, 5, 3, 5, 3, 6, 3, 6, 3, 7, 3, 7, 3, 7, 3, 8, 3, 8, 3, 9, 3, 9, 3, 10, 3, 10, 3, 10, 3, 11, 3, 11, 3, 11, 3, 12, 3, 12, 3, 12, 3, 13, 3, 13, 3, 13, 3, 14, 3, 14, 3, 15, 3, 15, 3, 16, 3, 16, 3, 17, 3, 17, 3, 18, 3, 18, 3, 19, 3, 19, 3, 20, 3, 20, 3, 21, 3, 21, 3, 21, 3, 22, 3, 22, 3, 22, 3, 23, 3, 23, 3, 23, 3, 24, 3, 24, 3, 24, 3, 25, 3, 25, 3, 26, 3, 26, 3, 27, 3, 27, 3, 28, 3, 28, 3, 29, 3, 29, 3, 29, 3, 30, 3, 30, 3, 30, 3, 31, 3, 31, 3, 31, 3, 31, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 33, 3, 33, 3, 33, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 35, 3, 35, 3, 35, 3, 35, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 37, 3, 37, 7, 37, 182, 10, 37, 12, 37, 14, 37, 185, 11, 37, 3, 38, 3, 38, 7, 38, 189, 10, 38, 12, 38, 14, 38, 192, 11, 38, 3, 38, 3, 38, 3, 39, 6, 39, 197, 10, 39, 13, 39, 14, 39, 198, 2, 2, 40, 3, 3, 5, 4, 7, 5, 9, 6, 11, 7, 13, 8, 15, 9, 17, 10, 19, 11, 21, 12, 23, 13, 25, 14, 27, 15, 29, 16, 31, 17, 33, 18, 35, 19, 37, 20, 39, 21, 41, 22, 43, 23, 45, 24, 47, 25, 49, 26, 51, 27, 53, 28, 55, 29, 57, 30, 59, 31, 61, 32, 63, 33, 65, 34, 67, 35, 69, 36, 71, 37, 73, 38, 75, 39, 77, 40, 3, 2, 7, 5, 2, 11, 12, 15, 15, 34, 34, 3, 2, 51, 59, 3, 2, 50, 59, 7, 2, 47, 47, 50, 59, 67, 92, 97, 97, 99, 124, 5, 2, 67, 92, 97, 97, 99, 124, 2, 202, 2, 3, 3, 2, 2, 2, 2, 5, 3, 2, 2, 2, 2, 7, 3, 2, 2, 2, 2, 9, 3, 2, 2, 2, 2, 11, 3, 2, 2, 2, 2, 13, 3, 2, 2, 2, 2, 15, 3, 2, 2, 2, 2, 17, 3, 2, 2, 2, 2, 19, 3, 2, 2, 2, 2, 21, 3, 2, 2, 2, 2, 23, 3, 2, 2, 2, 2, 25, 3, 2, 2, 2, 2, 27, 3, 2, 2, 2, 2, 29, 3, 2, 2, 2, 2, 31, 3, 2, 2, 2, 2, 33, 3, 2, 2, 2, 2, 35, 3, 2, 2, 2, 2, 37, 3, 2, 2, 2, 2, 39, 3, 2, 2, 2, 2, 41, 3, 2, 2, 2, 2, 43, 3, 2, 2, 2, 2, 45, 3, 2, 2, 2, 2, 47, 3, 2, 2, 2, 2, 49, 3, 2, 2, 2, 2, 51, 3, 2, 2, 2, 2, 53, 3, 2, 2, 2, 2, 55, 3, 2, 2, 2, 2, 57, 3, 2, 2, 2, 2, 59, 3, 2, 2, 2, 2, 61, 3, 2, 2, 2, 2, 63, 3, 2, 2, 2, 2, 65, 3, 2, 2, 2, 2, 67, 3, 2, 2, 2, 2, 69, 3, 2, 2, 2, 2, 71, 3, 2, 2, 2, 2, 73, 3, 2, 2, 2, 2, 75, 3, 2, 2, 2, 2, 77, 3, 2, 2, 2, 3, 79, 3, 2, 2, 2, 5, 83, 3, 2, 2, 2, 7, 85, 3, 2, 2, 2, 9, 87, 3, 2, 2, 2, 11, 89, 3, 2, 2, 2, 13, 91, 3, 2, 2, 2, 15, 94, 3, 2, 2, 2, 17, 96, 3, 2, 2, 2, 19, 98, 3, 2, 2, 2, 21, 101, 3, 2, 2, 2, 23, 104, 3, 2, 2, 2, 25, 107, 3, 2, 2, 2, 27, 110, 3, 2, 2, 2, 29, 112, 3, 2, 2, 2, 31, 114, 3, 2, 2, 2, 33, 116, 3, 2, 2, 2, 35, 118, 3, 2, 2, 2, 37, 120, 3, 2, 2, 2, 39, 122, 3, 2, 2, 2, 41, 124, 3, 2, 2, 2, 43, 127, 3, 2, 2, 2, 45, 130, 3, 2, 2, 2, 47, 133, 3, 2, 2, 2, 49, 136, 3, 2, 2, 2, 51, 138, 3, 2, 2, 2, 53, 140, 3, 2, 2, 2, 55, 142, 3, 2, 2, 2, 57, 144, 3, 2, 2, 2, 59, 147, 3, 2, 2, 2, 61, 150, 3, 2, 2, 2, 63, 154, 3, 2, 2, 2, 65, 160, 3, 2, 2, 2, 67, 163, 3, 2, 2, 2, 69, 168, 3, 2, 2, 2, 71, 172, 3, 2, 2, 2, 73, 179, 3, 2, 2, 2, 75, 186, 3, 2, 2, 2, 77, 196, 3, 2, 2, 2, 79, 80, 9, 2, 2, 2, 80, 81, 3, 2, 2, 2, 81, 82, 8, 2, 2, 2, 82, 4, 3, 2, 2, 2, 83, 84, 7, 45, 2, 2, 84, 6, 3, 2, 2, 2, 85, 86, 7, 47, 2, 2, 86, 8, 3, 2, 2, 2, 87, 88, 7, 44, 2, 2, 88, 10, 3, 2, 2, 2, 89, 90, 7, 49, 2, 2, 90, 12, 3, 2, 2, 2, 91, 92, 7, 40, 2, 2, 92, 93, 7, 40, 2, 2, 93, 14, 3, 2, 2, 2, 94, 95, 7, 40, 2, 2, 95, 16, 3, 2, 2, 2, 96, 97, 7, 63, 2, 2, 97, 18, 3, 2, 2, 2, 98, 99, 7, 63, 2, 2, 99, 100, 7, 63, 2, 2, 100, 20, 3, 2, 2, 2, 101, 102, 7, 35, 2, 2, 102, 103, 7, 63, 2, 2, 103, 22, 3, 2, 2, 2, 104, 105, 7, 64, 2, 2, 105, 106, 7, 63, 2, 2, 106, 24, 3, 2, 2, 2, 107, 108, 7, 62, 2, 2, 108, 109, 7, 63, 2, 2, 109, 26, 3, 2, 2, 2, 110, 111, 7, 64, 2, 2, 111, 28, 3, 2, 2, 2, 112, 113, 7, 62, 2, 2, 113, 30, 3, 2, 2, 2, 114, 115, 7, 61, 2, 2, 115, 32, 3, 2, 2, 2, 116, 117, 7, 60, 2, 2, 117, 34, 3, 2, 2, 2, 118, 119, 7, 46, 2, 2, 119, 36, 3, 2, 2, 2, 120, 121, 7, 48, 2, 2, 121, 38, 3, 2, 2, 2, 122, 123, 7, 36, 2, 2, 123, 40, 3, 2, 2, 2, 124, 125, 7, 45, 2, 2, 125, 126, 7, 63, 2, 2, 126, 42, 3, 2, 2, 2, 127, 128, 7, 47, 2, 2, 128, 129, 7, 63, 2, 2, 129, 44, 3, 2, 2, 2, 130, 131, 7, 44, 2, 2, 131, 132, 7, 63, 2, 2, 132, 46, 3, 2, 2, 2, 133, 134, 7, 49, 2, 2, 134, 135, 7, 63, 2, 2, 135, 48, 3, 2, 2, 2, 136, 137, 7, 42, 2, 2, 137, 50, 3, 2, 2, 2, 138, 139, 7, 43, 2, 2, 139, 52, 3, 2, 2, 2, 140, 141, 7, 125, 2, 2, 141, 54, 3, 2, 2, 2, 142, 143, 7, 127, 2, 2, 143, 56, 3, 2, 2, 2, 144, 145, 7, 47, 2, 2, 145, 146, 7, 64, 2, 2, 146, 58, 3, 2, 2, 2, 147, 148, 7, 104, 2, 2, 148, 149, 7, 112, 2, 2, 149, 60, 3, 2, 2, 2, 150, 151, 7, 104, 2, 2, 151, 152, 7, 113, 2, 2, 152, 153, 7, 116, 2, 2, 153, 62, 3, 2, 2, 2, 154, 155, 7, 121, 2, 2, 155, 156, 7, 106, 2, 2, 156, 157, 7, 107, 2, 2, 157, 158, 7, 110, 2, 2, 158, 159, 7, 103, 2, 2, 159, 64, 3, 2, 2, 2, 160, 161, 7, 107, 2, 2, 161, 162, 7, 104, 2, 2, 162, 66, 3, 2, 2, 2, 163, 164, 7, 103, 2, 2, 164, 165, 7, 110, 2, 2, 165, 166, 7, 117, 2, 2, 166, 167, 7, 103, 2, 2, 167, 68, 3, 2, 2, 2, 168, 169, 7, 110, 2, 2, 169, 170, 7, 103, 2, 2, 170, 171, 7, 118, 2, 2, 171, 70, 3, 2, 2, 2, 172, 173, 7, 116, 2, 2, 173, 174, 7, 103, 2, 2, 174, 175, 7, 118, 2, 2, 175, 176, 7, 119, 2, 2, 176, 177, 7, 116, 2, 2, 177, 178, 7, 112, 2, 2, 178, 72, 3, 2, 2, 2, 179, 183, 9, 3, 2, 2, 180, 182, 9, 4, 2, 2, 181, 180, 3, 2, 2, 2, 182, 185, 3, 2, 2, 2, 183, 181, 3, 2, 2, 2, 183, 184, 3, 2, 2, 2, 184, 74, 3, 2, 2, 2, 185, 183, 3, 2, 2, 2, 186, 190, 5, 39, 20, 2, 187, 189, 9, 5, 2, 2, 188, 187, 3, 2, 2, 2, 189, 192, 3, 2, 2, 2, 190, 188, 3, 2, 2, 2, 190, 191, 3, 2, 2, 2, 191, 193, 3, 2, 2, 2, 192, 190, 3, 2, 2, 2, 193, 194, 5, 39, 20, 2, 194, 76, 3, 2, 2, 2, 195, 197, 9, 6, 2, 2, 196, 195, 3, 2, 2, 2, 197, 198, 3, 2, 2, 2, 198, 196, 3, 2, 2, 2, 198, 199, 3, 2, 2, 2, 199, 78, 3, 2, 2, 2, 6, 2, 183, 190, 198, 3, 8, 2, 2] \ No newline at end of file diff --git a/src/gpsl/grammar/.antlr/GPSLLexer.java b/src/gpsl/grammar/.antlr/GPSLLexer.java new file mode 100644 index 0000000..1c4fe83 --- /dev/null +++ b/src/gpsl/grammar/.antlr/GPSLLexer.java @@ -0,0 +1,186 @@ +// Generated from h:\Git\gpsl\src\grammar\GpslLexer.g4 by ANTLR 4.8 +import org.antlr.v4.runtime.Lexer; +import org.antlr.v4.runtime.CharStream; +import org.antlr.v4.runtime.Token; +import org.antlr.v4.runtime.TokenStream; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.atn.*; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.misc.*; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) +public class GpslLexer extends Lexer { + static { RuntimeMetaData.checkVersion("4.8", RuntimeMetaData.VERSION); } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + WS=1, ADD=2, SUB=3, MUL=4, DIV=5, CONJ=6, AND=7, EQ=8, EQEQ=9, NE=10, + BE=11, LE=12, BT=13, LT=14, SEMICOLON=15, COLON=16, COMMA=17, DOT=18, + QUOTE=19, ADD_ASSIGNMENT=20, SUB_ASSIGNMENT=21, MUL_ASSIGNMENT=22, DIV_ASSIGNMENT=23, + LPAREN=24, RPAREN=25, LCURL=26, RCURL=27, ARROW=28, FN=29, FOR=30, WHILE=31, + IF=32, ELSE=33, LET=34, RETURN=35, NUM=36, TEXT=37, IDENT=38; + public static String[] channelNames = { + "DEFAULT_TOKEN_CHANNEL", "HIDDEN" + }; + + public static String[] modeNames = { + "DEFAULT_MODE" + }; + + private static String[] makeRuleNames() { + return new String[] { + "WS", "ADD", "SUB", "MUL", "DIV", "CONJ", "AND", "EQ", "EQEQ", "NE", + "BE", "LE", "BT", "LT", "SEMICOLON", "COLON", "COMMA", "DOT", "QUOTE", + "ADD_ASSIGNMENT", "SUB_ASSIGNMENT", "MUL_ASSIGNMENT", "DIV_ASSIGNMENT", + "LPAREN", "RPAREN", "LCURL", "RCURL", "ARROW", "FN", "FOR", "WHILE", + "IF", "ELSE", "LET", "RETURN", "NUM", "TEXT", "IDENT" + }; + } + public static final String[] ruleNames = makeRuleNames(); + + private static String[] makeLiteralNames() { + return new String[] { + null, null, "'+'", "'-'", "'*'", "'/'", "'&&'", "'&'", "'='", "'=='", + "'!='", "'>='", "'<='", "'>'", "'<'", "';'", "':'", "','", "'.'", "'\"'", + "'+='", "'-='", "'*='", "'/='", "'('", "')'", "'{'", "'}'", "'->'", "'fn'", + "'for'", "'while'", "'if'", "'else'", "'let'", "'return'" + }; + } + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static String[] makeSymbolicNames() { + return new String[] { + null, "WS", "ADD", "SUB", "MUL", "DIV", "CONJ", "AND", "EQ", "EQEQ", + "NE", "BE", "LE", "BT", "LT", "SEMICOLON", "COLON", "COMMA", "DOT", "QUOTE", + "ADD_ASSIGNMENT", "SUB_ASSIGNMENT", "MUL_ASSIGNMENT", "DIV_ASSIGNMENT", + "LPAREN", "RPAREN", "LCURL", "RCURL", "ARROW", "FN", "FOR", "WHILE", + "IF", "ELSE", "LET", "RETURN", "NUM", "TEXT", "IDENT" + }; + } + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated + public static final String[] tokenNames; + static { + tokenNames = new String[_SYMBOLIC_NAMES.length]; + for (int i = 0; i < tokenNames.length; i++) { + tokenNames[i] = VOCABULARY.getLiteralName(i); + if (tokenNames[i] == null) { + tokenNames[i] = VOCABULARY.getSymbolicName(i); + } + + if (tokenNames[i] == null) { + tokenNames[i] = ""; + } + } + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } + + @Override + + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + + public GpslLexer(CharStream input) { + super(input); + _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); + } + + @Override + public String getGrammarFileName() { return "GpslLexer.g4"; } + + @Override + public String[] getRuleNames() { return ruleNames; } + + @Override + public String getSerializedATN() { return _serializedATN; } + + @Override + public String[] getChannelNames() { return channelNames; } + + @Override + public String[] getModeNames() { return modeNames; } + + @Override + public ATN getATN() { return _ATN; } + + public static final String _serializedATN = + "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2(\u00c8\b\1\4\2\t"+ + "\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+ + "\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+ + "\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+ + "\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+ + "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\3\2\3\2\3\2\3\2\3\3\3\3\3"+ + "\4\3\4\3\5\3\5\3\6\3\6\3\7\3\7\3\7\3\b\3\b\3\t\3\t\3\n\3\n\3\n\3\13\3"+ + "\13\3\13\3\f\3\f\3\f\3\r\3\r\3\r\3\16\3\16\3\17\3\17\3\20\3\20\3\21\3"+ + "\21\3\22\3\22\3\23\3\23\3\24\3\24\3\25\3\25\3\25\3\26\3\26\3\26\3\27\3"+ + "\27\3\27\3\30\3\30\3\30\3\31\3\31\3\32\3\32\3\33\3\33\3\34\3\34\3\35\3"+ + "\35\3\35\3\36\3\36\3\36\3\37\3\37\3\37\3\37\3 \3 \3 \3 \3 \3 \3!\3!\3"+ + "!\3\"\3\"\3\"\3\"\3\"\3#\3#\3#\3#\3$\3$\3$\3$\3$\3$\3$\3%\3%\7%\u00b6"+ + "\n%\f%\16%\u00b9\13%\3&\3&\7&\u00bd\n&\f&\16&\u00c0\13&\3&\3&\3\'\6\'"+ + "\u00c5\n\'\r\'\16\'\u00c6\2\2(\3\3\5\4\7\5\t\6\13\7\r\b\17\t\21\n\23\13"+ + "\25\f\27\r\31\16\33\17\35\20\37\21!\22#\23%\24\'\25)\26+\27-\30/\31\61"+ + "\32\63\33\65\34\67\359\36;\37= ?!A\"C#E$G%I&K\'M(\3\2\7\5\2\13\f\17\17"+ + "\"\"\3\2\63;\3\2\62;\7\2//\62;C\\aac|\5\2C\\aac|\2\u00ca\2\3\3\2\2\2\2"+ + "\5\3\2\2\2\2\7\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2"+ + "\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2"+ + "\33\3\2\2\2\2\35\3\2\2\2\2\37\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2"+ + "\2\'\3\2\2\2\2)\3\2\2\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2\2\2"+ + "\2\63\3\2\2\2\2\65\3\2\2\2\2\67\3\2\2\2\29\3\2\2\2\2;\3\2\2\2\2=\3\2\2"+ + "\2\2?\3\2\2\2\2A\3\2\2\2\2C\3\2\2\2\2E\3\2\2\2\2G\3\2\2\2\2I\3\2\2\2\2"+ + "K\3\2\2\2\2M\3\2\2\2\3O\3\2\2\2\5S\3\2\2\2\7U\3\2\2\2\tW\3\2\2\2\13Y\3"+ + "\2\2\2\r[\3\2\2\2\17^\3\2\2\2\21`\3\2\2\2\23b\3\2\2\2\25e\3\2\2\2\27h"+ + "\3\2\2\2\31k\3\2\2\2\33n\3\2\2\2\35p\3\2\2\2\37r\3\2\2\2!t\3\2\2\2#v\3"+ + "\2\2\2%x\3\2\2\2\'z\3\2\2\2)|\3\2\2\2+\177\3\2\2\2-\u0082\3\2\2\2/\u0085"+ + "\3\2\2\2\61\u0088\3\2\2\2\63\u008a\3\2\2\2\65\u008c\3\2\2\2\67\u008e\3"+ + "\2\2\29\u0090\3\2\2\2;\u0093\3\2\2\2=\u0096\3\2\2\2?\u009a\3\2\2\2A\u00a0"+ + "\3\2\2\2C\u00a3\3\2\2\2E\u00a8\3\2\2\2G\u00ac\3\2\2\2I\u00b3\3\2\2\2K"+ + "\u00ba\3\2\2\2M\u00c4\3\2\2\2OP\t\2\2\2PQ\3\2\2\2QR\b\2\2\2R\4\3\2\2\2"+ + "ST\7-\2\2T\6\3\2\2\2UV\7/\2\2V\b\3\2\2\2WX\7,\2\2X\n\3\2\2\2YZ\7\61\2"+ + "\2Z\f\3\2\2\2[\\\7(\2\2\\]\7(\2\2]\16\3\2\2\2^_\7(\2\2_\20\3\2\2\2`a\7"+ + "?\2\2a\22\3\2\2\2bc\7?\2\2cd\7?\2\2d\24\3\2\2\2ef\7#\2\2fg\7?\2\2g\26"+ + "\3\2\2\2hi\7@\2\2ij\7?\2\2j\30\3\2\2\2kl\7>\2\2lm\7?\2\2m\32\3\2\2\2n"+ + "o\7@\2\2o\34\3\2\2\2pq\7>\2\2q\36\3\2\2\2rs\7=\2\2s \3\2\2\2tu\7<\2\2"+ + "u\"\3\2\2\2vw\7.\2\2w$\3\2\2\2xy\7\60\2\2y&\3\2\2\2z{\7$\2\2{(\3\2\2\2"+ + "|}\7-\2\2}~\7?\2\2~*\3\2\2\2\177\u0080\7/\2\2\u0080\u0081\7?\2\2\u0081"+ + ",\3\2\2\2\u0082\u0083\7,\2\2\u0083\u0084\7?\2\2\u0084.\3\2\2\2\u0085\u0086"+ + "\7\61\2\2\u0086\u0087\7?\2\2\u0087\60\3\2\2\2\u0088\u0089\7*\2\2\u0089"+ + "\62\3\2\2\2\u008a\u008b\7+\2\2\u008b\64\3\2\2\2\u008c\u008d\7}\2\2\u008d"+ + "\66\3\2\2\2\u008e\u008f\7\177\2\2\u008f8\3\2\2\2\u0090\u0091\7/\2\2\u0091"+ + "\u0092\7@\2\2\u0092:\3\2\2\2\u0093\u0094\7h\2\2\u0094\u0095\7p\2\2\u0095"+ + "<\3\2\2\2\u0096\u0097\7h\2\2\u0097\u0098\7q\2\2\u0098\u0099\7t\2\2\u0099"+ + ">\3\2\2\2\u009a\u009b\7y\2\2\u009b\u009c\7j\2\2\u009c\u009d\7k\2\2\u009d"+ + "\u009e\7n\2\2\u009e\u009f\7g\2\2\u009f@\3\2\2\2\u00a0\u00a1\7k\2\2\u00a1"+ + "\u00a2\7h\2\2\u00a2B\3\2\2\2\u00a3\u00a4\7g\2\2\u00a4\u00a5\7n\2\2\u00a5"+ + "\u00a6\7u\2\2\u00a6\u00a7\7g\2\2\u00a7D\3\2\2\2\u00a8\u00a9\7n\2\2\u00a9"+ + "\u00aa\7g\2\2\u00aa\u00ab\7v\2\2\u00abF\3\2\2\2\u00ac\u00ad\7t\2\2\u00ad"+ + "\u00ae\7g\2\2\u00ae\u00af\7v\2\2\u00af\u00b0\7w\2\2\u00b0\u00b1\7t\2\2"+ + "\u00b1\u00b2\7p\2\2\u00b2H\3\2\2\2\u00b3\u00b7\t\3\2\2\u00b4\u00b6\t\4"+ + "\2\2\u00b5\u00b4\3\2\2\2\u00b6\u00b9\3\2\2\2\u00b7\u00b5\3\2\2\2\u00b7"+ + "\u00b8\3\2\2\2\u00b8J\3\2\2\2\u00b9\u00b7\3\2\2\2\u00ba\u00be\5\'\24\2"+ + "\u00bb\u00bd\t\5\2\2\u00bc\u00bb\3\2\2\2\u00bd\u00c0\3\2\2\2\u00be\u00bc"+ + "\3\2\2\2\u00be\u00bf\3\2\2\2\u00bf\u00c1\3\2\2\2\u00c0\u00be\3\2\2\2\u00c1"+ + "\u00c2\5\'\24\2\u00c2L\3\2\2\2\u00c3\u00c5\t\6\2\2\u00c4\u00c3\3\2\2\2"+ + "\u00c5\u00c6\3\2\2\2\u00c6\u00c4\3\2\2\2\u00c6\u00c7\3\2\2\2\u00c7N\3"+ + "\2\2\2\6\2\u00b7\u00be\u00c6\3\b\2\2"; + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} \ No newline at end of file diff --git a/src/gpsl/grammar/.antlr/GPSLLexer.tokens b/src/gpsl/grammar/.antlr/GPSLLexer.tokens new file mode 100644 index 0000000..e919e4e --- /dev/null +++ b/src/gpsl/grammar/.antlr/GPSLLexer.tokens @@ -0,0 +1,72 @@ +WS=1 +ADD=2 +SUB=3 +MUL=4 +DIV=5 +CONJ=6 +AND=7 +EQ=8 +EQEQ=9 +NE=10 +BE=11 +LE=12 +BT=13 +LT=14 +SEMICOLON=15 +COLON=16 +COMMA=17 +DOT=18 +QUOTE=19 +ADD_ASSIGNMENT=20 +SUB_ASSIGNMENT=21 +MUL_ASSIGNMENT=22 +DIV_ASSIGNMENT=23 +LPAREN=24 +RPAREN=25 +LCURL=26 +RCURL=27 +ARROW=28 +FN=29 +FOR=30 +WHILE=31 +IF=32 +ELSE=33 +LET=34 +RETURN=35 +NUM=36 +TEXT=37 +IDENT=38 +'+'=2 +'-'=3 +'*'=4 +'/'=5 +'&&'=6 +'&'=7 +'='=8 +'=='=9 +'!='=10 +'>='=11 +'<='=12 +'>'=13 +'<'=14 +';'=15 +':'=16 +','=17 +'.'=18 +'"'=19 +'+='=20 +'-='=21 +'*='=22 +'/='=23 +'('=24 +')'=25 +'{'=26 +'}'=27 +'->'=28 +'fn'=29 +'for'=30 +'while'=31 +'if'=32 +'else'=33 +'let'=34 +'return'=35 diff --git a/src/gpsl/grammar/.antlr/GpslParser.interp b/src/gpsl/grammar/.antlr/GpslParser.interp new file mode 100644 index 0000000..3256d5d --- /dev/null +++ b/src/gpsl/grammar/.antlr/GpslParser.interp @@ -0,0 +1,106 @@ +token literal names: +null +null +'+' +'-' +'*' +'/' +'&&' +'&' +'=' +'==' +'!=' +'>=' +'<=' +'>' +'<' +';' +':' +',' +'.' +'"' +'+=' +'-=' +'*=' +'/=' +'(' +')' +'{' +'}' +'->' +'fn' +'for' +'while' +'if' +'else' +'let' +'return' +null +null +null + +token symbolic names: +null +WS +ADD +SUB +MUL +DIV +CONJ +AND +EQ +EQEQ +NE +BE +LE +BT +LT +SEMICOLON +COLON +COMMA +DOT +QUOTE +ADD_ASSIGNMENT +SUB_ASSIGNMENT +MUL_ASSIGNMENT +DIV_ASSIGNMENT +LPAREN +RPAREN +LCURL +RCURL +ARROW +FN +FOR +WHILE +IF +ELSE +LET +RETURN +NUM +TEXT +IDENT + +rule names: +gpslFile +function +program +stmt +let +block +return +if +while +for +expr +assign +equality +relational +add +mul +primary +function_call +unary + + +atn: +[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 3, 40, 228, 4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7, 4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13, 9, 13, 4, 14, 9, 14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4, 18, 9, 18, 4, 19, 9, 19, 4, 20, 9, 20, 3, 2, 7, 2, 42, 10, 2, 12, 2, 14, 2, 45, 11, 2, 3, 2, 3, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 3, 56, 10, 3, 7, 3, 58, 10, 3, 12, 3, 14, 3, 61, 11, 3, 3, 3, 3, 3, 3, 3, 5, 3, 66, 10, 3, 3, 3, 3, 3, 3, 4, 7, 4, 71, 10, 4, 12, 4, 14, 4, 74, 11, 4, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 5, 5, 85, 10, 5, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 7, 3, 7, 7, 7, 95, 10, 7, 12, 7, 14, 7, 98, 11, 7, 3, 7, 3, 7, 3, 8, 3, 8, 5, 8, 104, 10, 8, 3, 8, 3, 8, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 5, 9, 115, 10, 9, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 11, 3, 11, 3, 11, 5, 11, 126, 10, 11, 3, 11, 3, 11, 5, 11, 130, 10, 11, 3, 11, 3, 11, 5, 11, 134, 10, 11, 3, 11, 3, 11, 3, 11, 3, 12, 3, 12, 3, 13, 3, 13, 3, 13, 5, 13, 144, 10, 13, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 7, 14, 152, 10, 14, 12, 14, 14, 14, 155, 11, 14, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 7, 15, 166, 10, 15, 12, 15, 14, 15, 169, 11, 15, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 7, 16, 180, 10, 16, 12, 16, 14, 16, 183, 11, 16, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 7, 17, 194, 10, 17, 12, 17, 14, 17, 197, 11, 17, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 5, 18, 206, 10, 18, 3, 19, 3, 19, 3, 19, 3, 19, 5, 19, 212, 10, 19, 7, 19, 214, 10, 19, 12, 19, 14, 19, 217, 11, 19, 3, 19, 3, 19, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 5, 20, 226, 10, 20, 3, 20, 2, 2, 21, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 2, 2, 2, 248, 2, 43, 3, 2, 2, 2, 4, 48, 3, 2, 2, 2, 6, 72, 3, 2, 2, 2, 8, 84, 3, 2, 2, 2, 10, 86, 3, 2, 2, 2, 12, 92, 3, 2, 2, 2, 14, 101, 3, 2, 2, 2, 16, 107, 3, 2, 2, 2, 18, 116, 3, 2, 2, 2, 20, 122, 3, 2, 2, 2, 22, 138, 3, 2, 2, 2, 24, 140, 3, 2, 2, 2, 26, 145, 3, 2, 2, 2, 28, 156, 3, 2, 2, 2, 30, 170, 3, 2, 2, 2, 32, 184, 3, 2, 2, 2, 34, 205, 3, 2, 2, 2, 36, 207, 3, 2, 2, 2, 38, 225, 3, 2, 2, 2, 40, 42, 5, 4, 3, 2, 41, 40, 3, 2, 2, 2, 42, 45, 3, 2, 2, 2, 43, 41, 3, 2, 2, 2, 43, 44, 3, 2, 2, 2, 44, 46, 3, 2, 2, 2, 45, 43, 3, 2, 2, 2, 46, 47, 7, 2, 2, 3, 47, 3, 3, 2, 2, 2, 48, 49, 7, 31, 2, 2, 49, 50, 7, 40, 2, 2, 50, 59, 7, 26, 2, 2, 51, 52, 7, 40, 2, 2, 52, 53, 7, 18, 2, 2, 53, 55, 7, 40, 2, 2, 54, 56, 7, 19, 2, 2, 55, 54, 3, 2, 2, 2, 55, 56, 3, 2, 2, 2, 56, 58, 3, 2, 2, 2, 57, 51, 3, 2, 2, 2, 58, 61, 3, 2, 2, 2, 59, 57, 3, 2, 2, 2, 59, 60, 3, 2, 2, 2, 60, 62, 3, 2, 2, 2, 61, 59, 3, 2, 2, 2, 62, 65, 7, 27, 2, 2, 63, 64, 7, 30, 2, 2, 64, 66, 7, 40, 2, 2, 65, 63, 3, 2, 2, 2, 65, 66, 3, 2, 2, 2, 66, 67, 3, 2, 2, 2, 67, 68, 5, 12, 7, 2, 68, 5, 3, 2, 2, 2, 69, 71, 5, 8, 5, 2, 70, 69, 3, 2, 2, 2, 71, 74, 3, 2, 2, 2, 72, 70, 3, 2, 2, 2, 72, 73, 3, 2, 2, 2, 73, 7, 3, 2, 2, 2, 74, 72, 3, 2, 2, 2, 75, 85, 5, 10, 6, 2, 76, 85, 5, 12, 7, 2, 77, 85, 5, 14, 8, 2, 78, 85, 5, 16, 9, 2, 79, 85, 5, 18, 10, 2, 80, 85, 5, 20, 11, 2, 81, 82, 5, 22, 12, 2, 82, 83, 7, 17, 2, 2, 83, 85, 3, 2, 2, 2, 84, 75, 3, 2, 2, 2, 84, 76, 3, 2, 2, 2, 84, 77, 3, 2, 2, 2, 84, 78, 3, 2, 2, 2, 84, 79, 3, 2, 2, 2, 84, 80, 3, 2, 2, 2, 84, 81, 3, 2, 2, 2, 85, 9, 3, 2, 2, 2, 86, 87, 7, 36, 2, 2, 87, 88, 7, 40, 2, 2, 88, 89, 7, 18, 2, 2, 89, 90, 7, 40, 2, 2, 90, 91, 7, 17, 2, 2, 91, 11, 3, 2, 2, 2, 92, 96, 7, 28, 2, 2, 93, 95, 5, 8, 5, 2, 94, 93, 3, 2, 2, 2, 95, 98, 3, 2, 2, 2, 96, 94, 3, 2, 2, 2, 96, 97, 3, 2, 2, 2, 97, 99, 3, 2, 2, 2, 98, 96, 3, 2, 2, 2, 99, 100, 7, 29, 2, 2, 100, 13, 3, 2, 2, 2, 101, 103, 7, 37, 2, 2, 102, 104, 5, 22, 12, 2, 103, 102, 3, 2, 2, 2, 103, 104, 3, 2, 2, 2, 104, 105, 3, 2, 2, 2, 105, 106, 7, 17, 2, 2, 106, 15, 3, 2, 2, 2, 107, 108, 7, 34, 2, 2, 108, 109, 7, 26, 2, 2, 109, 110, 5, 22, 12, 2, 110, 111, 7, 27, 2, 2, 111, 114, 5, 8, 5, 2, 112, 113, 7, 35, 2, 2, 113, 115, 5, 8, 5, 2, 114, 112, 3, 2, 2, 2, 114, 115, 3, 2, 2, 2, 115, 17, 3, 2, 2, 2, 116, 117, 7, 33, 2, 2, 117, 118, 7, 26, 2, 2, 118, 119, 5, 22, 12, 2, 119, 120, 7, 27, 2, 2, 120, 121, 5, 8, 5, 2, 121, 19, 3, 2, 2, 2, 122, 123, 7, 32, 2, 2, 123, 125, 7, 26, 2, 2, 124, 126, 5, 22, 12, 2, 125, 124, 3, 2, 2, 2, 125, 126, 3, 2, 2, 2, 126, 127, 3, 2, 2, 2, 127, 129, 7, 17, 2, 2, 128, 130, 5, 22, 12, 2, 129, 128, 3, 2, 2, 2, 129, 130, 3, 2, 2, 2, 130, 131, 3, 2, 2, 2, 131, 133, 7, 17, 2, 2, 132, 134, 5, 22, 12, 2, 133, 132, 3, 2, 2, 2, 133, 134, 3, 2, 2, 2, 134, 135, 3, 2, 2, 2, 135, 136, 7, 27, 2, 2, 136, 137, 5, 8, 5, 2, 137, 21, 3, 2, 2, 2, 138, 139, 5, 24, 13, 2, 139, 23, 3, 2, 2, 2, 140, 143, 5, 26, 14, 2, 141, 142, 7, 10, 2, 2, 142, 144, 5, 24, 13, 2, 143, 141, 3, 2, 2, 2, 143, 144, 3, 2, 2, 2, 144, 25, 3, 2, 2, 2, 145, 153, 5, 28, 15, 2, 146, 147, 7, 11, 2, 2, 147, 152, 5, 28, 15, 2, 148, 149, 7, 12, 2, 2, 149, 152, 5, 28, 15, 2, 150, 152, 7, 8, 2, 2, 151, 146, 3, 2, 2, 2, 151, 148, 3, 2, 2, 2, 151, 150, 3, 2, 2, 2, 152, 155, 3, 2, 2, 2, 153, 151, 3, 2, 2, 2, 153, 154, 3, 2, 2, 2, 154, 27, 3, 2, 2, 2, 155, 153, 3, 2, 2, 2, 156, 167, 5, 30, 16, 2, 157, 158, 7, 14, 2, 2, 158, 166, 5, 30, 16, 2, 159, 160, 7, 16, 2, 2, 160, 166, 5, 30, 16, 2, 161, 162, 7, 13, 2, 2, 162, 166, 5, 30, 16, 2, 163, 164, 7, 15, 2, 2, 164, 166, 5, 30, 16, 2, 165, 157, 3, 2, 2, 2, 165, 159, 3, 2, 2, 2, 165, 161, 3, 2, 2, 2, 165, 163, 3, 2, 2, 2, 166, 169, 3, 2, 2, 2, 167, 165, 3, 2, 2, 2, 167, 168, 3, 2, 2, 2, 168, 29, 3, 2, 2, 2, 169, 167, 3, 2, 2, 2, 170, 181, 5, 32, 17, 2, 171, 172, 7, 4, 2, 2, 172, 180, 5, 32, 17, 2, 173, 174, 7, 5, 2, 2, 174, 180, 5, 32, 17, 2, 175, 176, 7, 23, 2, 2, 176, 180, 5, 32, 17, 2, 177, 178, 7, 22, 2, 2, 178, 180, 5, 32, 17, 2, 179, 171, 3, 2, 2, 2, 179, 173, 3, 2, 2, 2, 179, 175, 3, 2, 2, 2, 179, 177, 3, 2, 2, 2, 180, 183, 3, 2, 2, 2, 181, 179, 3, 2, 2, 2, 181, 182, 3, 2, 2, 2, 182, 31, 3, 2, 2, 2, 183, 181, 3, 2, 2, 2, 184, 195, 5, 38, 20, 2, 185, 186, 7, 6, 2, 2, 186, 194, 5, 38, 20, 2, 187, 188, 7, 7, 2, 2, 188, 194, 5, 38, 20, 2, 189, 190, 7, 25, 2, 2, 190, 194, 5, 38, 20, 2, 191, 192, 7, 24, 2, 2, 192, 194, 5, 38, 20, 2, 193, 185, 3, 2, 2, 2, 193, 187, 3, 2, 2, 2, 193, 189, 3, 2, 2, 2, 193, 191, 3, 2, 2, 2, 194, 197, 3, 2, 2, 2, 195, 193, 3, 2, 2, 2, 195, 196, 3, 2, 2, 2, 196, 33, 3, 2, 2, 2, 197, 195, 3, 2, 2, 2, 198, 199, 7, 26, 2, 2, 199, 200, 5, 22, 12, 2, 200, 201, 7, 27, 2, 2, 201, 206, 3, 2, 2, 2, 202, 206, 5, 36, 19, 2, 203, 206, 7, 39, 2, 2, 204, 206, 7, 38, 2, 2, 205, 198, 3, 2, 2, 2, 205, 202, 3, 2, 2, 2, 205, 203, 3, 2, 2, 2, 205, 204, 3, 2, 2, 2, 206, 35, 3, 2, 2, 2, 207, 208, 7, 40, 2, 2, 208, 215, 7, 26, 2, 2, 209, 211, 5, 38, 20, 2, 210, 212, 7, 19, 2, 2, 211, 210, 3, 2, 2, 2, 211, 212, 3, 2, 2, 2, 212, 214, 3, 2, 2, 2, 213, 209, 3, 2, 2, 2, 214, 217, 3, 2, 2, 2, 215, 213, 3, 2, 2, 2, 215, 216, 3, 2, 2, 2, 216, 218, 3, 2, 2, 2, 217, 215, 3, 2, 2, 2, 218, 219, 7, 27, 2, 2, 219, 37, 3, 2, 2, 2, 220, 221, 7, 4, 2, 2, 221, 226, 5, 34, 18, 2, 222, 223, 7, 5, 2, 2, 223, 226, 5, 34, 18, 2, 224, 226, 5, 34, 18, 2, 225, 220, 3, 2, 2, 2, 225, 222, 3, 2, 2, 2, 225, 224, 3, 2, 2, 2, 226, 39, 3, 2, 2, 2, 27, 43, 55, 59, 65, 72, 84, 96, 103, 114, 125, 129, 133, 143, 151, 153, 165, 167, 179, 181, 193, 195, 205, 211, 215, 225] \ No newline at end of file diff --git a/src/gpsl/grammar/.antlr/GpslParser.java b/src/gpsl/grammar/.antlr/GpslParser.java new file mode 100644 index 0000000..494666e --- /dev/null +++ b/src/gpsl/grammar/.antlr/GpslParser.java @@ -0,0 +1,1488 @@ +// Generated from h:\Git\gpsl\src\grammar\GpslParser.g4 by ANTLR 4.8 +import org.antlr.v4.runtime.atn.*; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.misc.*; +import org.antlr.v4.runtime.tree.*; +import java.util.List; +import java.util.Iterator; +import java.util.ArrayList; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) +public class GpslParser extends Parser { + static { RuntimeMetaData.checkVersion("4.8", RuntimeMetaData.VERSION); } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + WS=1, ADD=2, SUB=3, MUL=4, DIV=5, CONJ=6, AND=7, EQ=8, EQEQ=9, NE=10, + BE=11, LE=12, BT=13, LT=14, SEMICOLON=15, COLON=16, COMMA=17, DOT=18, + QUOTE=19, ADD_ASSIGNMENT=20, SUB_ASSIGNMENT=21, MUL_ASSIGNMENT=22, DIV_ASSIGNMENT=23, + LPAREN=24, RPAREN=25, LCURL=26, RCURL=27, ARROW=28, FN=29, FOR=30, WHILE=31, + IF=32, ELSE=33, LET=34, RETURN=35, NUM=36, TEXT=37, IDENT=38; + public static final int + RULE_gpslFile = 0, RULE_function = 1, RULE_program = 2, RULE_stmt = 3, + RULE_let = 4, RULE_block = 5, RULE_return = 6, RULE_if = 7, RULE_while = 8, + RULE_for = 9, RULE_expr = 10, RULE_assign = 11, RULE_equality = 12, RULE_relational = 13, + RULE_add = 14, RULE_mul = 15, RULE_primary = 16, RULE_function_call = 17, + RULE_unary = 18; + private static String[] makeRuleNames() { + return new String[] { + "gpslFile", "function", "program", "stmt", "let", "block", "return", + "if", "while", "for", "expr", "assign", "equality", "relational", "add", + "mul", "primary", "function_call", "unary" + }; + } + public static final String[] ruleNames = makeRuleNames(); + + private static String[] makeLiteralNames() { + return new String[] { + null, null, "'+'", "'-'", "'*'", "'/'", "'&&'", "'&'", "'='", "'=='", + "'!='", "'>='", "'<='", "'>'", "'<'", "';'", "':'", "','", "'.'", "'\"'", + "'+='", "'-='", "'*='", "'/='", "'('", "')'", "'{'", "'}'", "'->'", "'fn'", + "'for'", "'while'", "'if'", "'else'", "'let'", "'return'" + }; + } + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static String[] makeSymbolicNames() { + return new String[] { + null, "WS", "ADD", "SUB", "MUL", "DIV", "CONJ", "AND", "EQ", "EQEQ", + "NE", "BE", "LE", "BT", "LT", "SEMICOLON", "COLON", "COMMA", "DOT", "QUOTE", + "ADD_ASSIGNMENT", "SUB_ASSIGNMENT", "MUL_ASSIGNMENT", "DIV_ASSIGNMENT", + "LPAREN", "RPAREN", "LCURL", "RCURL", "ARROW", "FN", "FOR", "WHILE", + "IF", "ELSE", "LET", "RETURN", "NUM", "TEXT", "IDENT" + }; + } + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated + public static final String[] tokenNames; + static { + tokenNames = new String[_SYMBOLIC_NAMES.length]; + for (int i = 0; i < tokenNames.length; i++) { + tokenNames[i] = VOCABULARY.getLiteralName(i); + if (tokenNames[i] == null) { + tokenNames[i] = VOCABULARY.getSymbolicName(i); + } + + if (tokenNames[i] == null) { + tokenNames[i] = ""; + } + } + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } + + @Override + + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + @Override + public String getGrammarFileName() { return "GpslParser.g4"; } + + @Override + public String[] getRuleNames() { return ruleNames; } + + @Override + public String getSerializedATN() { return _serializedATN; } + + @Override + public ATN getATN() { return _ATN; } + + public GpslParser(TokenStream input) { + super(input); + _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); + } + + public static class GpslFileContext extends ParserRuleContext { + public TerminalNode EOF() { return getToken(GpslParser.EOF, 0); } + public List function() { + return getRuleContexts(FunctionContext.class); + } + public FunctionContext function(int i) { + return getRuleContext(FunctionContext.class,i); + } + public GpslFileContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_gpslFile; } + } + + public final GpslFileContext gpslFile() throws RecognitionException { + GpslFileContext _localctx = new GpslFileContext(_ctx, getState()); + enterRule(_localctx, 0, RULE_gpslFile); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(41); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==FN) { + { + { + setState(38); + function(); + } + } + setState(43); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(44); + match(EOF); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FunctionContext extends ParserRuleContext { + public TerminalNode FN() { return getToken(GpslParser.FN, 0); } + public List IDENT() { return getTokens(GpslParser.IDENT); } + public TerminalNode IDENT(int i) { + return getToken(GpslParser.IDENT, i); + } + public TerminalNode LPAREN() { return getToken(GpslParser.LPAREN, 0); } + public TerminalNode RPAREN() { return getToken(GpslParser.RPAREN, 0); } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public List COLON() { return getTokens(GpslParser.COLON); } + public TerminalNode COLON(int i) { + return getToken(GpslParser.COLON, i); + } + public TerminalNode ARROW() { return getToken(GpslParser.ARROW, 0); } + public List COMMA() { return getTokens(GpslParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(GpslParser.COMMA, i); + } + public FunctionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_function; } + } + + public final FunctionContext function() throws RecognitionException { + FunctionContext _localctx = new FunctionContext(_ctx, getState()); + enterRule(_localctx, 2, RULE_function); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(46); + match(FN); + setState(47); + match(IDENT); + setState(48); + match(LPAREN); + setState(57); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==IDENT) { + { + { + setState(49); + match(IDENT); + setState(50); + match(COLON); + setState(51); + match(IDENT); + setState(53); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(52); + match(COMMA); + } + } + + } + } + setState(59); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(60); + match(RPAREN); + setState(63); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ARROW) { + { + setState(61); + match(ARROW); + setState(62); + match(IDENT); + } + } + + setState(65); + block(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ProgramContext extends ParserRuleContext { + public List stmt() { + return getRuleContexts(StmtContext.class); + } + public StmtContext stmt(int i) { + return getRuleContext(StmtContext.class,i); + } + public ProgramContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_program; } + } + + public final ProgramContext program() throws RecognitionException { + ProgramContext _localctx = new ProgramContext(_ctx, getState()); + enterRule(_localctx, 4, RULE_program); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(70); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << SUB) | (1L << LPAREN) | (1L << LCURL) | (1L << FOR) | (1L << WHILE) | (1L << IF) | (1L << LET) | (1L << RETURN) | (1L << NUM) | (1L << TEXT) | (1L << IDENT))) != 0)) { + { + { + setState(67); + stmt(); + } + } + setState(72); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class StmtContext extends ParserRuleContext { + public LetContext let() { + return getRuleContext(LetContext.class,0); + } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public ReturnContext return() { + return getRuleContext(ReturnContext.class,0); + } + public IfContext if() { + return getRuleContext(IfContext.class,0); + } + public WhileContext while() { + return getRuleContext(WhileContext.class,0); + } + public ForContext for() { + return getRuleContext(ForContext.class,0); + } + public ExprContext expr() { + return getRuleContext(ExprContext.class,0); + } + public TerminalNode SEMICOLON() { return getToken(GpslParser.SEMICOLON, 0); } + public StmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stmt; } + } + + public final StmtContext stmt() throws RecognitionException { + StmtContext _localctx = new StmtContext(_ctx, getState()); + enterRule(_localctx, 6, RULE_stmt); + try { + setState(82); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LET: + enterOuterAlt(_localctx, 1); + { + setState(73); + let(); + } + break; + case LCURL: + enterOuterAlt(_localctx, 2); + { + setState(74); + block(); + } + break; + case RETURN: + enterOuterAlt(_localctx, 3); + { + setState(75); + return(); + } + break; + case IF: + enterOuterAlt(_localctx, 4); + { + setState(76); + if(); + } + break; + case WHILE: + enterOuterAlt(_localctx, 5); + { + setState(77); + while(); + } + break; + case FOR: + enterOuterAlt(_localctx, 6); + { + setState(78); + for(); + } + break; + case ADD: + case SUB: + case LPAREN: + case NUM: + case TEXT: + case IDENT: + enterOuterAlt(_localctx, 7); + { + setState(79); + expr(); + setState(80); + match(SEMICOLON); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LetContext extends ParserRuleContext { + public TerminalNode LET() { return getToken(GpslParser.LET, 0); } + public List IDENT() { return getTokens(GpslParser.IDENT); } + public TerminalNode IDENT(int i) { + return getToken(GpslParser.IDENT, i); + } + public TerminalNode COLON() { return getToken(GpslParser.COLON, 0); } + public TerminalNode SEMICOLON() { return getToken(GpslParser.SEMICOLON, 0); } + public LetContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_let; } + } + + public final LetContext let() throws RecognitionException { + LetContext _localctx = new LetContext(_ctx, getState()); + enterRule(_localctx, 8, RULE_let); + try { + enterOuterAlt(_localctx, 1); + { + setState(84); + match(LET); + setState(85); + match(IDENT); + setState(86); + match(COLON); + setState(87); + match(IDENT); + setState(88); + match(SEMICOLON); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class BlockContext extends ParserRuleContext { + public TerminalNode LCURL() { return getToken(GpslParser.LCURL, 0); } + public TerminalNode RCURL() { return getToken(GpslParser.RCURL, 0); } + public List stmt() { + return getRuleContexts(StmtContext.class); + } + public StmtContext stmt(int i) { + return getRuleContext(StmtContext.class,i); + } + public BlockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_block; } + } + + public final BlockContext block() throws RecognitionException { + BlockContext _localctx = new BlockContext(_ctx, getState()); + enterRule(_localctx, 10, RULE_block); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(90); + match(LCURL); + setState(94); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << SUB) | (1L << LPAREN) | (1L << LCURL) | (1L << FOR) | (1L << WHILE) | (1L << IF) | (1L << LET) | (1L << RETURN) | (1L << NUM) | (1L << TEXT) | (1L << IDENT))) != 0)) { + { + { + setState(91); + stmt(); + } + } + setState(96); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(97); + match(RCURL); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ReturnContext extends ParserRuleContext { + public TerminalNode RETURN() { return getToken(GpslParser.RETURN, 0); } + public TerminalNode SEMICOLON() { return getToken(GpslParser.SEMICOLON, 0); } + public ExprContext expr() { + return getRuleContext(ExprContext.class,0); + } + public ReturnContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_return; } + } + + public final ReturnContext return() throws RecognitionException { + ReturnContext _localctx = new ReturnContext(_ctx, getState()); + enterRule(_localctx, 12, RULE_return); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(99); + match(RETURN); + setState(101); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << SUB) | (1L << LPAREN) | (1L << NUM) | (1L << TEXT) | (1L << IDENT))) != 0)) { + { + setState(100); + expr(); + } + } + + setState(103); + match(SEMICOLON); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class IfContext extends ParserRuleContext { + public TerminalNode IF() { return getToken(GpslParser.IF, 0); } + public TerminalNode LPAREN() { return getToken(GpslParser.LPAREN, 0); } + public ExprContext expr() { + return getRuleContext(ExprContext.class,0); + } + public TerminalNode RPAREN() { return getToken(GpslParser.RPAREN, 0); } + public List stmt() { + return getRuleContexts(StmtContext.class); + } + public StmtContext stmt(int i) { + return getRuleContext(StmtContext.class,i); + } + public TerminalNode ELSE() { return getToken(GpslParser.ELSE, 0); } + public IfContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_if; } + } + + public final IfContext if() throws RecognitionException { + IfContext _localctx = new IfContext(_ctx, getState()); + enterRule(_localctx, 14, RULE_if); + try { + enterOuterAlt(_localctx, 1); + { + setState(105); + match(IF); + setState(106); + match(LPAREN); + setState(107); + expr(); + setState(108); + match(RPAREN); + setState(109); + stmt(); + setState(112); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) { + case 1: + { + setState(110); + match(ELSE); + setState(111); + stmt(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class WhileContext extends ParserRuleContext { + public TerminalNode WHILE() { return getToken(GpslParser.WHILE, 0); } + public TerminalNode LPAREN() { return getToken(GpslParser.LPAREN, 0); } + public ExprContext expr() { + return getRuleContext(ExprContext.class,0); + } + public TerminalNode RPAREN() { return getToken(GpslParser.RPAREN, 0); } + public StmtContext stmt() { + return getRuleContext(StmtContext.class,0); + } + public WhileContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_while; } + } + + public final WhileContext while() throws RecognitionException { + WhileContext _localctx = new WhileContext(_ctx, getState()); + enterRule(_localctx, 16, RULE_while); + try { + enterOuterAlt(_localctx, 1); + { + setState(114); + match(WHILE); + setState(115); + match(LPAREN); + setState(116); + expr(); + setState(117); + match(RPAREN); + setState(118); + stmt(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ForContext extends ParserRuleContext { + public TerminalNode FOR() { return getToken(GpslParser.FOR, 0); } + public TerminalNode LPAREN() { return getToken(GpslParser.LPAREN, 0); } + public List SEMICOLON() { return getTokens(GpslParser.SEMICOLON); } + public TerminalNode SEMICOLON(int i) { + return getToken(GpslParser.SEMICOLON, i); + } + public TerminalNode RPAREN() { return getToken(GpslParser.RPAREN, 0); } + public StmtContext stmt() { + return getRuleContext(StmtContext.class,0); + } + public List expr() { + return getRuleContexts(ExprContext.class); + } + public ExprContext expr(int i) { + return getRuleContext(ExprContext.class,i); + } + public ForContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_for; } + } + + public final ForContext for() throws RecognitionException { + ForContext _localctx = new ForContext(_ctx, getState()); + enterRule(_localctx, 18, RULE_for); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(120); + match(FOR); + setState(121); + match(LPAREN); + setState(123); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << SUB) | (1L << LPAREN) | (1L << NUM) | (1L << TEXT) | (1L << IDENT))) != 0)) { + { + setState(122); + expr(); + } + } + + setState(125); + match(SEMICOLON); + setState(127); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << SUB) | (1L << LPAREN) | (1L << NUM) | (1L << TEXT) | (1L << IDENT))) != 0)) { + { + setState(126); + expr(); + } + } + + setState(129); + match(SEMICOLON); + setState(131); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << SUB) | (1L << LPAREN) | (1L << NUM) | (1L << TEXT) | (1L << IDENT))) != 0)) { + { + setState(130); + expr(); + } + } + + setState(133); + match(RPAREN); + setState(134); + stmt(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ExprContext extends ParserRuleContext { + public AssignContext assign() { + return getRuleContext(AssignContext.class,0); + } + public ExprContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expr; } + } + + public final ExprContext expr() throws RecognitionException { + ExprContext _localctx = new ExprContext(_ctx, getState()); + enterRule(_localctx, 20, RULE_expr); + try { + enterOuterAlt(_localctx, 1); + { + setState(136); + assign(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AssignContext extends ParserRuleContext { + public EqualityContext equality() { + return getRuleContext(EqualityContext.class,0); + } + public TerminalNode EQ() { return getToken(GpslParser.EQ, 0); } + public AssignContext assign() { + return getRuleContext(AssignContext.class,0); + } + public AssignContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assign; } + } + + public final AssignContext assign() throws RecognitionException { + AssignContext _localctx = new AssignContext(_ctx, getState()); + enterRule(_localctx, 22, RULE_assign); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(138); + equality(); + setState(141); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EQ) { + { + setState(139); + match(EQ); + setState(140); + assign(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EqualityContext extends ParserRuleContext { + public List relational() { + return getRuleContexts(RelationalContext.class); + } + public RelationalContext relational(int i) { + return getRuleContext(RelationalContext.class,i); + } + public List EQEQ() { return getTokens(GpslParser.EQEQ); } + public TerminalNode EQEQ(int i) { + return getToken(GpslParser.EQEQ, i); + } + public List NE() { return getTokens(GpslParser.NE); } + public TerminalNode NE(int i) { + return getToken(GpslParser.NE, i); + } + public List CONJ() { return getTokens(GpslParser.CONJ); } + public TerminalNode CONJ(int i) { + return getToken(GpslParser.CONJ, i); + } + public EqualityContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_equality; } + } + + public final EqualityContext equality() throws RecognitionException { + EqualityContext _localctx = new EqualityContext(_ctx, getState()); + enterRule(_localctx, 24, RULE_equality); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(143); + relational(); + setState(151); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << CONJ) | (1L << EQEQ) | (1L << NE))) != 0)) { + { + setState(149); + _errHandler.sync(this); + switch (_input.LA(1)) { + case EQEQ: + { + setState(144); + match(EQEQ); + setState(145); + relational(); + } + break; + case NE: + { + setState(146); + match(NE); + setState(147); + relational(); + } + break; + case CONJ: + { + setState(148); + match(CONJ); + } + break; + default: + throw new NoViableAltException(this); + } + } + setState(153); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class RelationalContext extends ParserRuleContext { + public List add() { + return getRuleContexts(AddContext.class); + } + public AddContext add(int i) { + return getRuleContext(AddContext.class,i); + } + public List LE() { return getTokens(GpslParser.LE); } + public TerminalNode LE(int i) { + return getToken(GpslParser.LE, i); + } + public List LT() { return getTokens(GpslParser.LT); } + public TerminalNode LT(int i) { + return getToken(GpslParser.LT, i); + } + public List BE() { return getTokens(GpslParser.BE); } + public TerminalNode BE(int i) { + return getToken(GpslParser.BE, i); + } + public List BT() { return getTokens(GpslParser.BT); } + public TerminalNode BT(int i) { + return getToken(GpslParser.BT, i); + } + public RelationalContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_relational; } + } + + public final RelationalContext relational() throws RecognitionException { + RelationalContext _localctx = new RelationalContext(_ctx, getState()); + enterRule(_localctx, 26, RULE_relational); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(154); + add(); + setState(165); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BE) | (1L << LE) | (1L << BT) | (1L << LT))) != 0)) { + { + setState(163); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LE: + { + setState(155); + match(LE); + setState(156); + add(); + } + break; + case LT: + { + setState(157); + match(LT); + setState(158); + add(); + } + break; + case BE: + { + setState(159); + match(BE); + setState(160); + add(); + } + break; + case BT: + { + setState(161); + match(BT); + setState(162); + add(); + } + break; + default: + throw new NoViableAltException(this); + } + } + setState(167); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AddContext extends ParserRuleContext { + public List mul() { + return getRuleContexts(MulContext.class); + } + public MulContext mul(int i) { + return getRuleContext(MulContext.class,i); + } + public List ADD() { return getTokens(GpslParser.ADD); } + public TerminalNode ADD(int i) { + return getToken(GpslParser.ADD, i); + } + public List SUB() { return getTokens(GpslParser.SUB); } + public TerminalNode SUB(int i) { + return getToken(GpslParser.SUB, i); + } + public List SUB_ASSIGNMENT() { return getTokens(GpslParser.SUB_ASSIGNMENT); } + public TerminalNode SUB_ASSIGNMENT(int i) { + return getToken(GpslParser.SUB_ASSIGNMENT, i); + } + public List ADD_ASSIGNMENT() { return getTokens(GpslParser.ADD_ASSIGNMENT); } + public TerminalNode ADD_ASSIGNMENT(int i) { + return getToken(GpslParser.ADD_ASSIGNMENT, i); + } + public AddContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_add; } + } + + public final AddContext add() throws RecognitionException { + AddContext _localctx = new AddContext(_ctx, getState()); + enterRule(_localctx, 28, RULE_add); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(168); + mul(); + setState(179); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << SUB) | (1L << ADD_ASSIGNMENT) | (1L << SUB_ASSIGNMENT))) != 0)) { + { + setState(177); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + { + setState(169); + match(ADD); + setState(170); + mul(); + } + break; + case SUB: + { + setState(171); + match(SUB); + setState(172); + mul(); + } + break; + case SUB_ASSIGNMENT: + { + setState(173); + match(SUB_ASSIGNMENT); + setState(174); + mul(); + } + break; + case ADD_ASSIGNMENT: + { + setState(175); + match(ADD_ASSIGNMENT); + setState(176); + mul(); + } + break; + default: + throw new NoViableAltException(this); + } + } + setState(181); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MulContext extends ParserRuleContext { + public List unary() { + return getRuleContexts(UnaryContext.class); + } + public UnaryContext unary(int i) { + return getRuleContext(UnaryContext.class,i); + } + public List MUL() { return getTokens(GpslParser.MUL); } + public TerminalNode MUL(int i) { + return getToken(GpslParser.MUL, i); + } + public List DIV() { return getTokens(GpslParser.DIV); } + public TerminalNode DIV(int i) { + return getToken(GpslParser.DIV, i); + } + public List DIV_ASSIGNMENT() { return getTokens(GpslParser.DIV_ASSIGNMENT); } + public TerminalNode DIV_ASSIGNMENT(int i) { + return getToken(GpslParser.DIV_ASSIGNMENT, i); + } + public List MUL_ASSIGNMENT() { return getTokens(GpslParser.MUL_ASSIGNMENT); } + public TerminalNode MUL_ASSIGNMENT(int i) { + return getToken(GpslParser.MUL_ASSIGNMENT, i); + } + public MulContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_mul; } + } + + public final MulContext mul() throws RecognitionException { + MulContext _localctx = new MulContext(_ctx, getState()); + enterRule(_localctx, 30, RULE_mul); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(182); + unary(); + setState(193); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << MUL) | (1L << DIV) | (1L << MUL_ASSIGNMENT) | (1L << DIV_ASSIGNMENT))) != 0)) { + { + setState(191); + _errHandler.sync(this); + switch (_input.LA(1)) { + case MUL: + { + setState(183); + match(MUL); + setState(184); + unary(); + } + break; + case DIV: + { + setState(185); + match(DIV); + setState(186); + unary(); + } + break; + case DIV_ASSIGNMENT: + { + setState(187); + match(DIV_ASSIGNMENT); + setState(188); + unary(); + } + break; + case MUL_ASSIGNMENT: + { + setState(189); + match(MUL_ASSIGNMENT); + setState(190); + unary(); + } + break; + default: + throw new NoViableAltException(this); + } + } + setState(195); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PrimaryContext extends ParserRuleContext { + public TerminalNode LPAREN() { return getToken(GpslParser.LPAREN, 0); } + public ExprContext expr() { + return getRuleContext(ExprContext.class,0); + } + public TerminalNode RPAREN() { return getToken(GpslParser.RPAREN, 0); } + public Function_callContext function_call() { + return getRuleContext(Function_callContext.class,0); + } + public TerminalNode TEXT() { return getToken(GpslParser.TEXT, 0); } + public TerminalNode NUM() { return getToken(GpslParser.NUM, 0); } + public PrimaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_primary; } + } + + public final PrimaryContext primary() throws RecognitionException { + PrimaryContext _localctx = new PrimaryContext(_ctx, getState()); + enterRule(_localctx, 32, RULE_primary); + try { + setState(203); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LPAREN: + enterOuterAlt(_localctx, 1); + { + setState(196); + match(LPAREN); + setState(197); + expr(); + setState(198); + match(RPAREN); + } + break; + case IDENT: + enterOuterAlt(_localctx, 2); + { + setState(200); + function_call(); + } + break; + case TEXT: + enterOuterAlt(_localctx, 3); + { + setState(201); + match(TEXT); + } + break; + case NUM: + enterOuterAlt(_localctx, 4); + { + setState(202); + match(NUM); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Function_callContext extends ParserRuleContext { + public TerminalNode IDENT() { return getToken(GpslParser.IDENT, 0); } + public TerminalNode LPAREN() { return getToken(GpslParser.LPAREN, 0); } + public TerminalNode RPAREN() { return getToken(GpslParser.RPAREN, 0); } + public List unary() { + return getRuleContexts(UnaryContext.class); + } + public UnaryContext unary(int i) { + return getRuleContext(UnaryContext.class,i); + } + public List COMMA() { return getTokens(GpslParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(GpslParser.COMMA, i); + } + public Function_callContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_function_call; } + } + + public final Function_callContext function_call() throws RecognitionException { + Function_callContext _localctx = new Function_callContext(_ctx, getState()); + enterRule(_localctx, 34, RULE_function_call); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(205); + match(IDENT); + setState(206); + match(LPAREN); + setState(213); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD) | (1L << SUB) | (1L << LPAREN) | (1L << NUM) | (1L << TEXT) | (1L << IDENT))) != 0)) { + { + { + setState(207); + unary(); + setState(209); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(208); + match(COMMA); + } + } + + } + } + setState(215); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(216); + match(RPAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UnaryContext extends ParserRuleContext { + public TerminalNode ADD() { return getToken(GpslParser.ADD, 0); } + public PrimaryContext primary() { + return getRuleContext(PrimaryContext.class,0); + } + public TerminalNode SUB() { return getToken(GpslParser.SUB, 0); } + public UnaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unary; } + } + + public final UnaryContext unary() throws RecognitionException { + UnaryContext _localctx = new UnaryContext(_ctx, getState()); + enterRule(_localctx, 36, RULE_unary); + try { + setState(223); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + enterOuterAlt(_localctx, 1); + { + setState(218); + match(ADD); + setState(219); + primary(); + } + break; + case SUB: + enterOuterAlt(_localctx, 2); + { + setState(220); + match(SUB); + setState(221); + primary(); + } + break; + case LPAREN: + case NUM: + case TEXT: + case IDENT: + enterOuterAlt(_localctx, 3); + { + setState(222); + primary(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static final String _serializedATN = + "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3(\u00e4\4\2\t\2\4"+ + "\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+ + "\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+ + "\4\23\t\23\4\24\t\24\3\2\7\2*\n\2\f\2\16\2-\13\2\3\2\3\2\3\3\3\3\3\3\3"+ + "\3\3\3\3\3\3\3\5\38\n\3\7\3:\n\3\f\3\16\3=\13\3\3\3\3\3\3\3\5\3B\n\3\3"+ + "\3\3\3\3\4\7\4G\n\4\f\4\16\4J\13\4\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5"+ + "\5\5U\n\5\3\6\3\6\3\6\3\6\3\6\3\6\3\7\3\7\7\7_\n\7\f\7\16\7b\13\7\3\7"+ + "\3\7\3\b\3\b\5\bh\n\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\5\ts\n\t\3\n"+ + "\3\n\3\n\3\n\3\n\3\n\3\13\3\13\3\13\5\13~\n\13\3\13\3\13\5\13\u0082\n"+ + "\13\3\13\3\13\5\13\u0086\n\13\3\13\3\13\3\13\3\f\3\f\3\r\3\r\3\r\5\r\u0090"+ + "\n\r\3\16\3\16\3\16\3\16\3\16\3\16\7\16\u0098\n\16\f\16\16\16\u009b\13"+ + "\16\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\7\17\u00a6\n\17\f\17"+ + "\16\17\u00a9\13\17\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\7\20\u00b4"+ + "\n\20\f\20\16\20\u00b7\13\20\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3"+ + "\21\7\21\u00c2\n\21\f\21\16\21\u00c5\13\21\3\22\3\22\3\22\3\22\3\22\3"+ + "\22\3\22\5\22\u00ce\n\22\3\23\3\23\3\23\3\23\5\23\u00d4\n\23\7\23\u00d6"+ + "\n\23\f\23\16\23\u00d9\13\23\3\23\3\23\3\24\3\24\3\24\3\24\3\24\5\24\u00e2"+ + "\n\24\3\24\2\2\25\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&\2\2\2\u00f8"+ + "\2+\3\2\2\2\4\60\3\2\2\2\6H\3\2\2\2\bT\3\2\2\2\nV\3\2\2\2\f\\\3\2\2\2"+ + "\16e\3\2\2\2\20k\3\2\2\2\22t\3\2\2\2\24z\3\2\2\2\26\u008a\3\2\2\2\30\u008c"+ + "\3\2\2\2\32\u0091\3\2\2\2\34\u009c\3\2\2\2\36\u00aa\3\2\2\2 \u00b8\3\2"+ + "\2\2\"\u00cd\3\2\2\2$\u00cf\3\2\2\2&\u00e1\3\2\2\2(*\5\4\3\2)(\3\2\2\2"+ + "*-\3\2\2\2+)\3\2\2\2+,\3\2\2\2,.\3\2\2\2-+\3\2\2\2./\7\2\2\3/\3\3\2\2"+ + "\2\60\61\7\37\2\2\61\62\7(\2\2\62;\7\32\2\2\63\64\7(\2\2\64\65\7\22\2"+ + "\2\65\67\7(\2\2\668\7\23\2\2\67\66\3\2\2\2\678\3\2\2\28:\3\2\2\29\63\3"+ + "\2\2\2:=\3\2\2\2;9\3\2\2\2;<\3\2\2\2<>\3\2\2\2=;\3\2\2\2>A\7\33\2\2?@"+ + "\7\36\2\2@B\7(\2\2A?\3\2\2\2AB\3\2\2\2BC\3\2\2\2CD\5\f\7\2D\5\3\2\2\2"+ + "EG\5\b\5\2FE\3\2\2\2GJ\3\2\2\2HF\3\2\2\2HI\3\2\2\2I\7\3\2\2\2JH\3\2\2"+ + "\2KU\5\n\6\2LU\5\f\7\2MU\5\16\b\2NU\5\20\t\2OU\5\22\n\2PU\5\24\13\2QR"+ + "\5\26\f\2RS\7\21\2\2SU\3\2\2\2TK\3\2\2\2TL\3\2\2\2TM\3\2\2\2TN\3\2\2\2"+ + "TO\3\2\2\2TP\3\2\2\2TQ\3\2\2\2U\t\3\2\2\2VW\7$\2\2WX\7(\2\2XY\7\22\2\2"+ + "YZ\7(\2\2Z[\7\21\2\2[\13\3\2\2\2\\`\7\34\2\2]_\5\b\5\2^]\3\2\2\2_b\3\2"+ + "\2\2`^\3\2\2\2`a\3\2\2\2ac\3\2\2\2b`\3\2\2\2cd\7\35\2\2d\r\3\2\2\2eg\7"+ + "%\2\2fh\5\26\f\2gf\3\2\2\2gh\3\2\2\2hi\3\2\2\2ij\7\21\2\2j\17\3\2\2\2"+ + "kl\7\"\2\2lm\7\32\2\2mn\5\26\f\2no\7\33\2\2or\5\b\5\2pq\7#\2\2qs\5\b\5"+ + "\2rp\3\2\2\2rs\3\2\2\2s\21\3\2\2\2tu\7!\2\2uv\7\32\2\2vw\5\26\f\2wx\7"+ + "\33\2\2xy\5\b\5\2y\23\3\2\2\2z{\7 \2\2{}\7\32\2\2|~\5\26\f\2}|\3\2\2\2"+ + "}~\3\2\2\2~\177\3\2\2\2\177\u0081\7\21\2\2\u0080\u0082\5\26\f\2\u0081"+ + "\u0080\3\2\2\2\u0081\u0082\3\2\2\2\u0082\u0083\3\2\2\2\u0083\u0085\7\21"+ + "\2\2\u0084\u0086\5\26\f\2\u0085\u0084\3\2\2\2\u0085\u0086\3\2\2\2\u0086"+ + "\u0087\3\2\2\2\u0087\u0088\7\33\2\2\u0088\u0089\5\b\5\2\u0089\25\3\2\2"+ + "\2\u008a\u008b\5\30\r\2\u008b\27\3\2\2\2\u008c\u008f\5\32\16\2\u008d\u008e"+ + "\7\n\2\2\u008e\u0090\5\30\r\2\u008f\u008d\3\2\2\2\u008f\u0090\3\2\2\2"+ + "\u0090\31\3\2\2\2\u0091\u0099\5\34\17\2\u0092\u0093\7\13\2\2\u0093\u0098"+ + "\5\34\17\2\u0094\u0095\7\f\2\2\u0095\u0098\5\34\17\2\u0096\u0098\7\b\2"+ + "\2\u0097\u0092\3\2\2\2\u0097\u0094\3\2\2\2\u0097\u0096\3\2\2\2\u0098\u009b"+ + "\3\2\2\2\u0099\u0097\3\2\2\2\u0099\u009a\3\2\2\2\u009a\33\3\2\2\2\u009b"+ + "\u0099\3\2\2\2\u009c\u00a7\5\36\20\2\u009d\u009e\7\16\2\2\u009e\u00a6"+ + "\5\36\20\2\u009f\u00a0\7\20\2\2\u00a0\u00a6\5\36\20\2\u00a1\u00a2\7\r"+ + "\2\2\u00a2\u00a6\5\36\20\2\u00a3\u00a4\7\17\2\2\u00a4\u00a6\5\36\20\2"+ + "\u00a5\u009d\3\2\2\2\u00a5\u009f\3\2\2\2\u00a5\u00a1\3\2\2\2\u00a5\u00a3"+ + "\3\2\2\2\u00a6\u00a9\3\2\2\2\u00a7\u00a5\3\2\2\2\u00a7\u00a8\3\2\2\2\u00a8"+ + "\35\3\2\2\2\u00a9\u00a7\3\2\2\2\u00aa\u00b5\5 \21\2\u00ab\u00ac\7\4\2"+ + "\2\u00ac\u00b4\5 \21\2\u00ad\u00ae\7\5\2\2\u00ae\u00b4\5 \21\2\u00af\u00b0"+ + "\7\27\2\2\u00b0\u00b4\5 \21\2\u00b1\u00b2\7\26\2\2\u00b2\u00b4\5 \21\2"+ + "\u00b3\u00ab\3\2\2\2\u00b3\u00ad\3\2\2\2\u00b3\u00af\3\2\2\2\u00b3\u00b1"+ + "\3\2\2\2\u00b4\u00b7\3\2\2\2\u00b5\u00b3\3\2\2\2\u00b5\u00b6\3\2\2\2\u00b6"+ + "\37\3\2\2\2\u00b7\u00b5\3\2\2\2\u00b8\u00c3\5&\24\2\u00b9\u00ba\7\6\2"+ + "\2\u00ba\u00c2\5&\24\2\u00bb\u00bc\7\7\2\2\u00bc\u00c2\5&\24\2\u00bd\u00be"+ + "\7\31\2\2\u00be\u00c2\5&\24\2\u00bf\u00c0\7\30\2\2\u00c0\u00c2\5&\24\2"+ + "\u00c1\u00b9\3\2\2\2\u00c1\u00bb\3\2\2\2\u00c1\u00bd\3\2\2\2\u00c1\u00bf"+ + "\3\2\2\2\u00c2\u00c5\3\2\2\2\u00c3\u00c1\3\2\2\2\u00c3\u00c4\3\2\2\2\u00c4"+ + "!\3\2\2\2\u00c5\u00c3\3\2\2\2\u00c6\u00c7\7\32\2\2\u00c7\u00c8\5\26\f"+ + "\2\u00c8\u00c9\7\33\2\2\u00c9\u00ce\3\2\2\2\u00ca\u00ce\5$\23\2\u00cb"+ + "\u00ce\7\'\2\2\u00cc\u00ce\7&\2\2\u00cd\u00c6\3\2\2\2\u00cd\u00ca\3\2"+ + "\2\2\u00cd\u00cb\3\2\2\2\u00cd\u00cc\3\2\2\2\u00ce#\3\2\2\2\u00cf\u00d0"+ + "\7(\2\2\u00d0\u00d7\7\32\2\2\u00d1\u00d3\5&\24\2\u00d2\u00d4\7\23\2\2"+ + "\u00d3\u00d2\3\2\2\2\u00d3\u00d4\3\2\2\2\u00d4\u00d6\3\2\2\2\u00d5\u00d1"+ + "\3\2\2\2\u00d6\u00d9\3\2\2\2\u00d7\u00d5\3\2\2\2\u00d7\u00d8\3\2\2\2\u00d8"+ + "\u00da\3\2\2\2\u00d9\u00d7\3\2\2\2\u00da\u00db\7\33\2\2\u00db%\3\2\2\2"+ + "\u00dc\u00dd\7\4\2\2\u00dd\u00e2\5\"\22\2\u00de\u00df\7\5\2\2\u00df\u00e2"+ + "\5\"\22\2\u00e0\u00e2\5\"\22\2\u00e1\u00dc\3\2\2\2\u00e1\u00de\3\2\2\2"+ + "\u00e1\u00e0\3\2\2\2\u00e2\'\3\2\2\2\33+\67;AHT`gr}\u0081\u0085\u008f"+ + "\u0097\u0099\u00a5\u00a7\u00b3\u00b5\u00c1\u00c3\u00cd\u00d3\u00d7\u00e1"; + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} \ No newline at end of file diff --git a/src/gpsl/grammar/.antlr/GpslParser.tokens b/src/gpsl/grammar/.antlr/GpslParser.tokens new file mode 100644 index 0000000..e919e4e --- /dev/null +++ b/src/gpsl/grammar/.antlr/GpslParser.tokens @@ -0,0 +1,72 @@ +WS=1 +ADD=2 +SUB=3 +MUL=4 +DIV=5 +CONJ=6 +AND=7 +EQ=8 +EQEQ=9 +NE=10 +BE=11 +LE=12 +BT=13 +LT=14 +SEMICOLON=15 +COLON=16 +COMMA=17 +DOT=18 +QUOTE=19 +ADD_ASSIGNMENT=20 +SUB_ASSIGNMENT=21 +MUL_ASSIGNMENT=22 +DIV_ASSIGNMENT=23 +LPAREN=24 +RPAREN=25 +LCURL=26 +RCURL=27 +ARROW=28 +FN=29 +FOR=30 +WHILE=31 +IF=32 +ELSE=33 +LET=34 +RETURN=35 +NUM=36 +TEXT=37 +IDENT=38 +'+'=2 +'-'=3 +'*'=4 +'/'=5 +'&&'=6 +'&'=7 +'='=8 +'=='=9 +'!='=10 +'>='=11 +'<='=12 +'>'=13 +'<'=14 +';'=15 +':'=16 +','=17 +'.'=18 +'"'=19 +'+='=20 +'-='=21 +'*='=22 +'/='=23 +'('=24 +')'=25 +'{'=26 +'}'=27 +'->'=28 +'fn'=29 +'for'=30 +'while'=31 +'if'=32 +'else'=33 +'let'=34 +'return'=35 diff --git a/src/gpsl/grammar/.antlr/Python3.interp b/src/gpsl/grammar/.antlr/Python3.interp new file mode 100644 index 0000000..e578363 --- /dev/null +++ b/src/gpsl/grammar/.antlr/Python3.interp @@ -0,0 +1,295 @@ +token literal names: +null +null +null +null +'def' +'return' +'raise' +'from' +'import' +'as' +'global' +'nonlocal' +'assert' +'if' +'elif' +'else' +'while' +'for' +'in' +'try' +'finally' +'with' +'except' +'lambda' +'or' +'and' +'not' +'is' +'None' +'True' +'False' +'class' +'yield' +'del' +'pass' +'continue' +'break' +'async' +'await' +null +null +null +null +null +null +null +null +null +null +'.' +'...' +'*' +'(' +')' +',' +':' +';' +'**' +'=' +'[' +']' +'|' +'^' +'&' +'<<' +'>>' +'+' +'-' +'/' +'%' +'//' +'~' +'{' +'}' +'<' +'>' +'==' +'>=' +'<=' +'<>' +'!=' +'@' +'->' +'+=' +'-=' +'*=' +'@=' +'/=' +'%=' +'&=' +'|=' +'^=' +'<<=' +'>>=' +'**=' +'//=' +null +null +null +null + +token symbolic names: +null +STRING +NUMBER +INTEGER +DEF +RETURN +RAISE +FROM +IMPORT +AS +GLOBAL +NONLOCAL +ASSERT +IF +ELIF +ELSE +WHILE +FOR +IN +TRY +FINALLY +WITH +EXCEPT +LAMBDA +OR +AND +NOT +IS +NONE +TRUE +FALSE +CLASS +YIELD +DEL +PASS +CONTINUE +BREAK +ASYNC +AWAIT +NEWLINE +NAME +STRING_LITERAL +BYTES_LITERAL +DECIMAL_INTEGER +OCT_INTEGER +HEX_INTEGER +BIN_INTEGER +FLOAT_NUMBER +IMAG_NUMBER +DOT +ELLIPSIS +STAR +OPEN_PAREN +CLOSE_PAREN +COMMA +COLON +SEMI_COLON +POWER +ASSIGN +OPEN_BRACK +CLOSE_BRACK +OR_OP +XOR +AND_OP +LEFT_SHIFT +RIGHT_SHIFT +ADD +MINUS +DIV +MOD +IDIV +NOT_OP +OPEN_BRACE +CLOSE_BRACE +LESS_THAN +GREATER_THAN +EQUALS +GT_EQ +LT_EQ +NOT_EQ_1 +NOT_EQ_2 +AT +ARROW +ADD_ASSIGN +SUB_ASSIGN +MULT_ASSIGN +AT_ASSIGN +DIV_ASSIGN +MOD_ASSIGN +AND_ASSIGN +OR_ASSIGN +XOR_ASSIGN +LEFT_SHIFT_ASSIGN +RIGHT_SHIFT_ASSIGN +POWER_ASSIGN +IDIV_ASSIGN +SKIP_ +UNKNOWN_CHAR +INDENT +DEDENT + +rule names: +single_input +file_input +eval_input +decorator +decorators +decorated +async_funcdef +funcdef +parameters +typedargslist +tfpdef +varargslist +vfpdef +stmt +simple_stmt +small_stmt +expr_stmt +annassign +testlist_star_expr +augassign +del_stmt +pass_stmt +flow_stmt +break_stmt +continue_stmt +return_stmt +yield_stmt +raise_stmt +import_stmt +import_name +import_from +import_as_name +dotted_as_name +import_as_names +dotted_as_names +dotted_name +global_stmt +nonlocal_stmt +assert_stmt +compound_stmt +async_stmt +if_stmt +while_stmt +for_stmt +try_stmt +with_stmt +with_item +except_clause +suite +test +test_nocond +lambdef +lambdef_nocond +or_test +and_test +not_test +comparison +comp_op +star_expr +expr +xor_expr +and_expr +shift_expr +arith_expr +term +factor +power +atom_expr +atom +testlist_comp +trailer +subscriptlist +subscript +sliceop +exprlist +testlist +dictorsetmaker +classdef +arglist +argument +comp_iter +comp_for +comp_if +encoding_decl +yield_expr +yield_arg + + +atn: +[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 3, 101, 1106, 4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7, 4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13, 9, 13, 4, 14, 9, 14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4, 18, 9, 18, 4, 19, 9, 19, 4, 20, 9, 20, 4, 21, 9, 21, 4, 22, 9, 22, 4, 23, 9, 23, 4, 24, 9, 24, 4, 25, 9, 25, 4, 26, 9, 26, 4, 27, 9, 27, 4, 28, 9, 28, 4, 29, 9, 29, 4, 30, 9, 30, 4, 31, 9, 31, 4, 32, 9, 32, 4, 33, 9, 33, 4, 34, 9, 34, 4, 35, 9, 35, 4, 36, 9, 36, 4, 37, 9, 37, 4, 38, 9, 38, 4, 39, 9, 39, 4, 40, 9, 40, 4, 41, 9, 41, 4, 42, 9, 42, 4, 43, 9, 43, 4, 44, 9, 44, 4, 45, 9, 45, 4, 46, 9, 46, 4, 47, 9, 47, 4, 48, 9, 48, 4, 49, 9, 49, 4, 50, 9, 50, 4, 51, 9, 51, 4, 52, 9, 52, 4, 53, 9, 53, 4, 54, 9, 54, 4, 55, 9, 55, 4, 56, 9, 56, 4, 57, 9, 57, 4, 58, 9, 58, 4, 59, 9, 59, 4, 60, 9, 60, 4, 61, 9, 61, 4, 62, 9, 62, 4, 63, 9, 63, 4, 64, 9, 64, 4, 65, 9, 65, 4, 66, 9, 66, 4, 67, 9, 67, 4, 68, 9, 68, 4, 69, 9, 69, 4, 70, 9, 70, 4, 71, 9, 71, 4, 72, 9, 72, 4, 73, 9, 73, 4, 74, 9, 74, 4, 75, 9, 75, 4, 76, 9, 76, 4, 77, 9, 77, 4, 78, 9, 78, 4, 79, 9, 79, 4, 80, 9, 80, 4, 81, 9, 81, 4, 82, 9, 82, 4, 83, 9, 83, 4, 84, 9, 84, 4, 85, 9, 85, 4, 86, 9, 86, 4, 87, 9, 87, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 5, 2, 180, 10, 2, 3, 3, 3, 3, 7, 3, 184, 10, 3, 12, 3, 14, 3, 187, 11, 3, 3, 3, 3, 3, 3, 4, 3, 4, 7, 4, 193, 10, 4, 12, 4, 14, 4, 196, 11, 4, 3, 4, 3, 4, 3, 5, 3, 5, 3, 5, 3, 5, 5, 5, 204, 10, 5, 3, 5, 5, 5, 207, 10, 5, 3, 5, 3, 5, 3, 6, 6, 6, 212, 10, 6, 13, 6, 14, 6, 213, 3, 7, 3, 7, 3, 7, 3, 7, 5, 7, 220, 10, 7, 3, 8, 3, 8, 3, 8, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 5, 9, 230, 10, 9, 3, 9, 3, 9, 3, 9, 3, 10, 3, 10, 5, 10, 237, 10, 10, 3, 10, 3, 10, 3, 11, 3, 11, 3, 11, 5, 11, 244, 10, 11, 3, 11, 3, 11, 3, 11, 3, 11, 5, 11, 250, 10, 11, 7, 11, 252, 10, 11, 12, 11, 14, 11, 255, 11, 11, 3, 11, 3, 11, 3, 11, 5, 11, 260, 10, 11, 3, 11, 3, 11, 3, 11, 3, 11, 5, 11, 266, 10, 11, 7, 11, 268, 10, 11, 12, 11, 14, 11, 271, 11, 11, 3, 11, 3, 11, 3, 11, 3, 11, 5, 11, 277, 10, 11, 5, 11, 279, 10, 11, 5, 11, 281, 10, 11, 3, 11, 3, 11, 3, 11, 5, 11, 286, 10, 11, 5, 11, 288, 10, 11, 5, 11, 290, 10, 11, 3, 11, 3, 11, 5, 11, 294, 10, 11, 3, 11, 3, 11, 3, 11, 3, 11, 5, 11, 300, 10, 11, 7, 11, 302, 10, 11, 12, 11, 14, 11, 305, 11, 11, 3, 11, 3, 11, 3, 11, 3, 11, 5, 11, 311, 10, 11, 5, 11, 313, 10, 11, 5, 11, 315, 10, 11, 3, 11, 3, 11, 3, 11, 5, 11, 320, 10, 11, 5, 11, 322, 10, 11, 3, 12, 3, 12, 3, 12, 5, 12, 327, 10, 12, 3, 13, 3, 13, 3, 13, 5, 13, 332, 10, 13, 3, 13, 3, 13, 3, 13, 3, 13, 5, 13, 338, 10, 13, 7, 13, 340, 10, 13, 12, 13, 14, 13, 343, 11, 13, 3, 13, 3, 13, 3, 13, 5, 13, 348, 10, 13, 3, 13, 3, 13, 3, 13, 3, 13, 5, 13, 354, 10, 13, 7, 13, 356, 10, 13, 12, 13, 14, 13, 359, 11, 13, 3, 13, 3, 13, 3, 13, 3, 13, 5, 13, 365, 10, 13, 5, 13, 367, 10, 13, 5, 13, 369, 10, 13, 3, 13, 3, 13, 3, 13, 5, 13, 374, 10, 13, 5, 13, 376, 10, 13, 5, 13, 378, 10, 13, 3, 13, 3, 13, 5, 13, 382, 10, 13, 3, 13, 3, 13, 3, 13, 3, 13, 5, 13, 388, 10, 13, 7, 13, 390, 10, 13, 12, 13, 14, 13, 393, 11, 13, 3, 13, 3, 13, 3, 13, 3, 13, 5, 13, 399, 10, 13, 5, 13, 401, 10, 13, 5, 13, 403, 10, 13, 3, 13, 3, 13, 3, 13, 5, 13, 408, 10, 13, 5, 13, 410, 10, 13, 3, 14, 3, 14, 3, 15, 3, 15, 5, 15, 416, 10, 15, 3, 16, 3, 16, 3, 16, 7, 16, 421, 10, 16, 12, 16, 14, 16, 424, 11, 16, 3, 16, 5, 16, 427, 10, 16, 3, 16, 3, 16, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 5, 17, 439, 10, 17, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 5, 18, 446, 10, 18, 3, 18, 3, 18, 3, 18, 5, 18, 451, 10, 18, 7, 18, 453, 10, 18, 12, 18, 14, 18, 456, 11, 18, 5, 18, 458, 10, 18, 3, 19, 3, 19, 3, 19, 3, 19, 5, 19, 464, 10, 19, 3, 20, 3, 20, 5, 20, 468, 10, 20, 3, 20, 3, 20, 3, 20, 5, 20, 473, 10, 20, 7, 20, 475, 10, 20, 12, 20, 14, 20, 478, 11, 20, 3, 20, 5, 20, 481, 10, 20, 3, 21, 3, 21, 3, 22, 3, 22, 3, 22, 3, 23, 3, 23, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 5, 24, 495, 10, 24, 3, 25, 3, 25, 3, 26, 3, 26, 3, 27, 3, 27, 5, 27, 503, 10, 27, 3, 28, 3, 28, 3, 29, 3, 29, 3, 29, 3, 29, 5, 29, 511, 10, 29, 5, 29, 513, 10, 29, 3, 30, 3, 30, 5, 30, 517, 10, 30, 3, 31, 3, 31, 3, 31, 3, 32, 3, 32, 7, 32, 524, 10, 32, 12, 32, 14, 32, 527, 11, 32, 3, 32, 3, 32, 6, 32, 531, 10, 32, 13, 32, 14, 32, 532, 5, 32, 535, 10, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 5, 32, 544, 10, 32, 3, 33, 3, 33, 3, 33, 5, 33, 549, 10, 33, 3, 34, 3, 34, 3, 34, 5, 34, 554, 10, 34, 3, 35, 3, 35, 3, 35, 7, 35, 559, 10, 35, 12, 35, 14, 35, 562, 11, 35, 3, 35, 5, 35, 565, 10, 35, 3, 36, 3, 36, 3, 36, 7, 36, 570, 10, 36, 12, 36, 14, 36, 573, 11, 36, 3, 37, 3, 37, 3, 37, 7, 37, 578, 10, 37, 12, 37, 14, 37, 581, 11, 37, 3, 38, 3, 38, 3, 38, 3, 38, 7, 38, 587, 10, 38, 12, 38, 14, 38, 590, 11, 38, 3, 39, 3, 39, 3, 39, 3, 39, 7, 39, 596, 10, 39, 12, 39, 14, 39, 599, 11, 39, 3, 40, 3, 40, 3, 40, 3, 40, 5, 40, 605, 10, 40, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 3, 41, 5, 41, 616, 10, 41, 3, 42, 3, 42, 3, 42, 3, 42, 5, 42, 622, 10, 42, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 7, 43, 633, 10, 43, 12, 43, 14, 43, 636, 11, 43, 3, 43, 3, 43, 3, 43, 5, 43, 641, 10, 43, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 5, 44, 650, 10, 44, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 5, 45, 661, 10, 45, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 6, 46, 670, 10, 46, 13, 46, 14, 46, 671, 3, 46, 3, 46, 3, 46, 5, 46, 677, 10, 46, 3, 46, 3, 46, 3, 46, 5, 46, 682, 10, 46, 3, 46, 3, 46, 3, 46, 5, 46, 687, 10, 46, 3, 47, 3, 47, 3, 47, 3, 47, 7, 47, 693, 10, 47, 12, 47, 14, 47, 696, 11, 47, 3, 47, 3, 47, 3, 47, 3, 48, 3, 48, 3, 48, 5, 48, 704, 10, 48, 3, 49, 3, 49, 3, 49, 3, 49, 5, 49, 710, 10, 49, 5, 49, 712, 10, 49, 3, 50, 3, 50, 3, 50, 3, 50, 6, 50, 718, 10, 50, 13, 50, 14, 50, 719, 3, 50, 3, 50, 5, 50, 724, 10, 50, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 5, 51, 732, 10, 51, 3, 51, 5, 51, 735, 10, 51, 3, 52, 3, 52, 5, 52, 739, 10, 52, 3, 53, 3, 53, 5, 53, 743, 10, 53, 3, 53, 3, 53, 3, 53, 3, 54, 3, 54, 5, 54, 750, 10, 54, 3, 54, 3, 54, 3, 54, 3, 55, 3, 55, 3, 55, 7, 55, 758, 10, 55, 12, 55, 14, 55, 761, 11, 55, 3, 56, 3, 56, 3, 56, 7, 56, 766, 10, 56, 12, 56, 14, 56, 769, 11, 56, 3, 57, 3, 57, 3, 57, 5, 57, 774, 10, 57, 3, 58, 3, 58, 3, 58, 3, 58, 7, 58, 780, 10, 58, 12, 58, 14, 58, 783, 11, 58, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 5, 59, 798, 10, 59, 3, 60, 3, 60, 3, 60, 3, 61, 3, 61, 3, 61, 7, 61, 806, 10, 61, 12, 61, 14, 61, 809, 11, 61, 3, 62, 3, 62, 3, 62, 7, 62, 814, 10, 62, 12, 62, 14, 62, 817, 11, 62, 3, 63, 3, 63, 3, 63, 7, 63, 822, 10, 63, 12, 63, 14, 63, 825, 11, 63, 3, 64, 3, 64, 3, 64, 7, 64, 830, 10, 64, 12, 64, 14, 64, 833, 11, 64, 3, 65, 3, 65, 3, 65, 7, 65, 838, 10, 65, 12, 65, 14, 65, 841, 11, 65, 3, 66, 3, 66, 3, 66, 7, 66, 846, 10, 66, 12, 66, 14, 66, 849, 11, 66, 3, 67, 3, 67, 3, 67, 5, 67, 854, 10, 67, 3, 68, 3, 68, 3, 68, 5, 68, 859, 10, 68, 3, 69, 5, 69, 862, 10, 69, 3, 69, 3, 69, 7, 69, 866, 10, 69, 12, 69, 14, 69, 869, 11, 69, 3, 70, 3, 70, 3, 70, 5, 70, 874, 10, 70, 3, 70, 3, 70, 3, 70, 5, 70, 879, 10, 70, 3, 70, 3, 70, 3, 70, 5, 70, 884, 10, 70, 3, 70, 3, 70, 3, 70, 3, 70, 6, 70, 890, 10, 70, 13, 70, 14, 70, 891, 3, 70, 3, 70, 3, 70, 3, 70, 5, 70, 898, 10, 70, 3, 71, 3, 71, 5, 71, 902, 10, 71, 3, 71, 3, 71, 3, 71, 3, 71, 5, 71, 908, 10, 71, 7, 71, 910, 10, 71, 12, 71, 14, 71, 913, 11, 71, 3, 71, 5, 71, 916, 10, 71, 5, 71, 918, 10, 71, 3, 72, 3, 72, 5, 72, 922, 10, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 5, 72, 931, 10, 72, 3, 73, 3, 73, 3, 73, 7, 73, 936, 10, 73, 12, 73, 14, 73, 939, 11, 73, 3, 73, 5, 73, 942, 10, 73, 3, 74, 3, 74, 5, 74, 946, 10, 74, 3, 74, 3, 74, 5, 74, 950, 10, 74, 3, 74, 5, 74, 953, 10, 74, 5, 74, 955, 10, 74, 3, 75, 3, 75, 5, 75, 959, 10, 75, 3, 76, 3, 76, 5, 76, 963, 10, 76, 3, 76, 3, 76, 3, 76, 5, 76, 968, 10, 76, 7, 76, 970, 10, 76, 12, 76, 14, 76, 973, 11, 76, 3, 76, 5, 76, 976, 10, 76, 3, 77, 3, 77, 3, 77, 7, 77, 981, 10, 77, 12, 77, 14, 77, 984, 11, 77, 3, 77, 5, 77, 987, 10, 77, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 5, 78, 995, 10, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 5, 78, 1005, 10, 78, 7, 78, 1007, 10, 78, 12, 78, 14, 78, 1010, 11, 78, 3, 78, 5, 78, 1013, 10, 78, 5, 78, 1015, 10, 78, 3, 78, 3, 78, 5, 78, 1019, 10, 78, 3, 78, 3, 78, 3, 78, 3, 78, 5, 78, 1025, 10, 78, 7, 78, 1027, 10, 78, 12, 78, 14, 78, 1030, 11, 78, 3, 78, 5, 78, 1033, 10, 78, 5, 78, 1035, 10, 78, 5, 78, 1037, 10, 78, 3, 79, 3, 79, 3, 79, 3, 79, 5, 79, 1043, 10, 79, 3, 79, 5, 79, 1046, 10, 79, 3, 79, 3, 79, 3, 79, 3, 80, 3, 80, 3, 80, 7, 80, 1054, 10, 80, 12, 80, 14, 80, 1057, 11, 80, 3, 80, 5, 80, 1060, 10, 80, 3, 81, 3, 81, 5, 81, 1064, 10, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 5, 81, 1074, 10, 81, 3, 82, 3, 82, 5, 82, 1078, 10, 82, 3, 83, 5, 83, 1081, 10, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 5, 83, 1088, 10, 83, 3, 84, 3, 84, 3, 84, 5, 84, 1093, 10, 84, 3, 85, 3, 85, 3, 86, 3, 86, 5, 86, 1099, 10, 86, 3, 87, 3, 87, 3, 87, 5, 87, 1104, 10, 87, 3, 87, 2, 2, 88, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 2, 8, 3, 2, 85, 97, 3, 2, 51, 52, 3, 2, 66, 67, 3, 2, 68, 69, 5, 2, 53, 53, 70, 72, 83, 83, 4, 2, 68, 69, 73, 73, 2, 1231, 2, 179, 3, 2, 2, 2, 4, 185, 3, 2, 2, 2, 6, 190, 3, 2, 2, 2, 8, 199, 3, 2, 2, 2, 10, 211, 3, 2, 2, 2, 12, 215, 3, 2, 2, 2, 14, 221, 3, 2, 2, 2, 16, 224, 3, 2, 2, 2, 18, 234, 3, 2, 2, 2, 20, 321, 3, 2, 2, 2, 22, 323, 3, 2, 2, 2, 24, 409, 3, 2, 2, 2, 26, 411, 3, 2, 2, 2, 28, 415, 3, 2, 2, 2, 30, 417, 3, 2, 2, 2, 32, 438, 3, 2, 2, 2, 34, 440, 3, 2, 2, 2, 36, 459, 3, 2, 2, 2, 38, 467, 3, 2, 2, 2, 40, 482, 3, 2, 2, 2, 42, 484, 3, 2, 2, 2, 44, 487, 3, 2, 2, 2, 46, 494, 3, 2, 2, 2, 48, 496, 3, 2, 2, 2, 50, 498, 3, 2, 2, 2, 52, 500, 3, 2, 2, 2, 54, 504, 3, 2, 2, 2, 56, 506, 3, 2, 2, 2, 58, 516, 3, 2, 2, 2, 60, 518, 3, 2, 2, 2, 62, 521, 3, 2, 2, 2, 64, 545, 3, 2, 2, 2, 66, 550, 3, 2, 2, 2, 68, 555, 3, 2, 2, 2, 70, 566, 3, 2, 2, 2, 72, 574, 3, 2, 2, 2, 74, 582, 3, 2, 2, 2, 76, 591, 3, 2, 2, 2, 78, 600, 3, 2, 2, 2, 80, 615, 3, 2, 2, 2, 82, 617, 3, 2, 2, 2, 84, 623, 3, 2, 2, 2, 86, 642, 3, 2, 2, 2, 88, 651, 3, 2, 2, 2, 90, 662, 3, 2, 2, 2, 92, 688, 3, 2, 2, 2, 94, 700, 3, 2, 2, 2, 96, 705, 3, 2, 2, 2, 98, 723, 3, 2, 2, 2, 100, 734, 3, 2, 2, 2, 102, 738, 3, 2, 2, 2, 104, 740, 3, 2, 2, 2, 106, 747, 3, 2, 2, 2, 108, 754, 3, 2, 2, 2, 110, 762, 3, 2, 2, 2, 112, 773, 3, 2, 2, 2, 114, 775, 3, 2, 2, 2, 116, 797, 3, 2, 2, 2, 118, 799, 3, 2, 2, 2, 120, 802, 3, 2, 2, 2, 122, 810, 3, 2, 2, 2, 124, 818, 3, 2, 2, 2, 126, 826, 3, 2, 2, 2, 128, 834, 3, 2, 2, 2, 130, 842, 3, 2, 2, 2, 132, 853, 3, 2, 2, 2, 134, 855, 3, 2, 2, 2, 136, 861, 3, 2, 2, 2, 138, 897, 3, 2, 2, 2, 140, 901, 3, 2, 2, 2, 142, 930, 3, 2, 2, 2, 144, 932, 3, 2, 2, 2, 146, 954, 3, 2, 2, 2, 148, 956, 3, 2, 2, 2, 150, 962, 3, 2, 2, 2, 152, 977, 3, 2, 2, 2, 154, 1036, 3, 2, 2, 2, 156, 1038, 3, 2, 2, 2, 158, 1050, 3, 2, 2, 2, 160, 1073, 3, 2, 2, 2, 162, 1077, 3, 2, 2, 2, 164, 1080, 3, 2, 2, 2, 166, 1089, 3, 2, 2, 2, 168, 1094, 3, 2, 2, 2, 170, 1096, 3, 2, 2, 2, 172, 1103, 3, 2, 2, 2, 174, 180, 7, 41, 2, 2, 175, 180, 5, 30, 16, 2, 176, 177, 5, 80, 41, 2, 177, 178, 7, 41, 2, 2, 178, 180, 3, 2, 2, 2, 179, 174, 3, 2, 2, 2, 179, 175, 3, 2, 2, 2, 179, 176, 3, 2, 2, 2, 180, 3, 3, 2, 2, 2, 181, 184, 7, 41, 2, 2, 182, 184, 5, 28, 15, 2, 183, 181, 3, 2, 2, 2, 183, 182, 3, 2, 2, 2, 184, 187, 3, 2, 2, 2, 185, 183, 3, 2, 2, 2, 185, 186, 3, 2, 2, 2, 186, 188, 3, 2, 2, 2, 187, 185, 3, 2, 2, 2, 188, 189, 7, 2, 2, 3, 189, 5, 3, 2, 2, 2, 190, 194, 5, 152, 77, 2, 191, 193, 7, 41, 2, 2, 192, 191, 3, 2, 2, 2, 193, 196, 3, 2, 2, 2, 194, 192, 3, 2, 2, 2, 194, 195, 3, 2, 2, 2, 195, 197, 3, 2, 2, 2, 196, 194, 3, 2, 2, 2, 197, 198, 7, 2, 2, 3, 198, 7, 3, 2, 2, 2, 199, 200, 7, 83, 2, 2, 200, 206, 5, 72, 37, 2, 201, 203, 7, 54, 2, 2, 202, 204, 5, 158, 80, 2, 203, 202, 3, 2, 2, 2, 203, 204, 3, 2, 2, 2, 204, 205, 3, 2, 2, 2, 205, 207, 7, 55, 2, 2, 206, 201, 3, 2, 2, 2, 206, 207, 3, 2, 2, 2, 207, 208, 3, 2, 2, 2, 208, 209, 7, 41, 2, 2, 209, 9, 3, 2, 2, 2, 210, 212, 5, 8, 5, 2, 211, 210, 3, 2, 2, 2, 212, 213, 3, 2, 2, 2, 213, 211, 3, 2, 2, 2, 213, 214, 3, 2, 2, 2, 214, 11, 3, 2, 2, 2, 215, 219, 5, 10, 6, 2, 216, 220, 5, 156, 79, 2, 217, 220, 5, 16, 9, 2, 218, 220, 5, 14, 8, 2, 219, 216, 3, 2, 2, 2, 219, 217, 3, 2, 2, 2, 219, 218, 3, 2, 2, 2, 220, 13, 3, 2, 2, 2, 221, 222, 7, 39, 2, 2, 222, 223, 5, 16, 9, 2, 223, 15, 3, 2, 2, 2, 224, 225, 7, 6, 2, 2, 225, 226, 7, 42, 2, 2, 226, 229, 5, 18, 10, 2, 227, 228, 7, 84, 2, 2, 228, 230, 5, 100, 51, 2, 229, 227, 3, 2, 2, 2, 229, 230, 3, 2, 2, 2, 230, 231, 3, 2, 2, 2, 231, 232, 7, 57, 2, 2, 232, 233, 5, 98, 50, 2, 233, 17, 3, 2, 2, 2, 234, 236, 7, 54, 2, 2, 235, 237, 5, 20, 11, 2, 236, 235, 3, 2, 2, 2, 236, 237, 3, 2, 2, 2, 237, 238, 3, 2, 2, 2, 238, 239, 7, 55, 2, 2, 239, 19, 3, 2, 2, 2, 240, 243, 5, 22, 12, 2, 241, 242, 7, 60, 2, 2, 242, 244, 5, 100, 51, 2, 243, 241, 3, 2, 2, 2, 243, 244, 3, 2, 2, 2, 244, 253, 3, 2, 2, 2, 245, 246, 7, 56, 2, 2, 246, 249, 5, 22, 12, 2, 247, 248, 7, 60, 2, 2, 248, 250, 5, 100, 51, 2, 249, 247, 3, 2, 2, 2, 249, 250, 3, 2, 2, 2, 250, 252, 3, 2, 2, 2, 251, 245, 3, 2, 2, 2, 252, 255, 3, 2, 2, 2, 253, 251, 3, 2, 2, 2, 253, 254, 3, 2, 2, 2, 254, 289, 3, 2, 2, 2, 255, 253, 3, 2, 2, 2, 256, 287, 7, 56, 2, 2, 257, 259, 7, 53, 2, 2, 258, 260, 5, 22, 12, 2, 259, 258, 3, 2, 2, 2, 259, 260, 3, 2, 2, 2, 260, 269, 3, 2, 2, 2, 261, 262, 7, 56, 2, 2, 262, 265, 5, 22, 12, 2, 263, 264, 7, 60, 2, 2, 264, 266, 5, 100, 51, 2, 265, 263, 3, 2, 2, 2, 265, 266, 3, 2, 2, 2, 266, 268, 3, 2, 2, 2, 267, 261, 3, 2, 2, 2, 268, 271, 3, 2, 2, 2, 269, 267, 3, 2, 2, 2, 269, 270, 3, 2, 2, 2, 270, 280, 3, 2, 2, 2, 271, 269, 3, 2, 2, 2, 272, 278, 7, 56, 2, 2, 273, 274, 7, 59, 2, 2, 274, 276, 5, 22, 12, 2, 275, 277, 7, 56, 2, 2, 276, 275, 3, 2, 2, 2, 276, 277, 3, 2, 2, 2, 277, 279, 3, 2, 2, 2, 278, 273, 3, 2, 2, 2, 278, 279, 3, 2, 2, 2, 279, 281, 3, 2, 2, 2, 280, 272, 3, 2, 2, 2, 280, 281, 3, 2, 2, 2, 281, 288, 3, 2, 2, 2, 282, 283, 7, 59, 2, 2, 283, 285, 5, 22, 12, 2, 284, 286, 7, 56, 2, 2, 285, 284, 3, 2, 2, 2, 285, 286, 3, 2, 2, 2, 286, 288, 3, 2, 2, 2, 287, 257, 3, 2, 2, 2, 287, 282, 3, 2, 2, 2, 287, 288, 3, 2, 2, 2, 288, 290, 3, 2, 2, 2, 289, 256, 3, 2, 2, 2, 289, 290, 3, 2, 2, 2, 290, 322, 3, 2, 2, 2, 291, 293, 7, 53, 2, 2, 292, 294, 5, 22, 12, 2, 293, 292, 3, 2, 2, 2, 293, 294, 3, 2, 2, 2, 294, 303, 3, 2, 2, 2, 295, 296, 7, 56, 2, 2, 296, 299, 5, 22, 12, 2, 297, 298, 7, 60, 2, 2, 298, 300, 5, 100, 51, 2, 299, 297, 3, 2, 2, 2, 299, 300, 3, 2, 2, 2, 300, 302, 3, 2, 2, 2, 301, 295, 3, 2, 2, 2, 302, 305, 3, 2, 2, 2, 303, 301, 3, 2, 2, 2, 303, 304, 3, 2, 2, 2, 304, 314, 3, 2, 2, 2, 305, 303, 3, 2, 2, 2, 306, 312, 7, 56, 2, 2, 307, 308, 7, 59, 2, 2, 308, 310, 5, 22, 12, 2, 309, 311, 7, 56, 2, 2, 310, 309, 3, 2, 2, 2, 310, 311, 3, 2, 2, 2, 311, 313, 3, 2, 2, 2, 312, 307, 3, 2, 2, 2, 312, 313, 3, 2, 2, 2, 313, 315, 3, 2, 2, 2, 314, 306, 3, 2, 2, 2, 314, 315, 3, 2, 2, 2, 315, 322, 3, 2, 2, 2, 316, 317, 7, 59, 2, 2, 317, 319, 5, 22, 12, 2, 318, 320, 7, 56, 2, 2, 319, 318, 3, 2, 2, 2, 319, 320, 3, 2, 2, 2, 320, 322, 3, 2, 2, 2, 321, 240, 3, 2, 2, 2, 321, 291, 3, 2, 2, 2, 321, 316, 3, 2, 2, 2, 322, 21, 3, 2, 2, 2, 323, 326, 7, 42, 2, 2, 324, 325, 7, 57, 2, 2, 325, 327, 5, 100, 51, 2, 326, 324, 3, 2, 2, 2, 326, 327, 3, 2, 2, 2, 327, 23, 3, 2, 2, 2, 328, 331, 5, 26, 14, 2, 329, 330, 7, 60, 2, 2, 330, 332, 5, 100, 51, 2, 331, 329, 3, 2, 2, 2, 331, 332, 3, 2, 2, 2, 332, 341, 3, 2, 2, 2, 333, 334, 7, 56, 2, 2, 334, 337, 5, 26, 14, 2, 335, 336, 7, 60, 2, 2, 336, 338, 5, 100, 51, 2, 337, 335, 3, 2, 2, 2, 337, 338, 3, 2, 2, 2, 338, 340, 3, 2, 2, 2, 339, 333, 3, 2, 2, 2, 340, 343, 3, 2, 2, 2, 341, 339, 3, 2, 2, 2, 341, 342, 3, 2, 2, 2, 342, 377, 3, 2, 2, 2, 343, 341, 3, 2, 2, 2, 344, 375, 7, 56, 2, 2, 345, 347, 7, 53, 2, 2, 346, 348, 5, 26, 14, 2, 347, 346, 3, 2, 2, 2, 347, 348, 3, 2, 2, 2, 348, 357, 3, 2, 2, 2, 349, 350, 7, 56, 2, 2, 350, 353, 5, 26, 14, 2, 351, 352, 7, 60, 2, 2, 352, 354, 5, 100, 51, 2, 353, 351, 3, 2, 2, 2, 353, 354, 3, 2, 2, 2, 354, 356, 3, 2, 2, 2, 355, 349, 3, 2, 2, 2, 356, 359, 3, 2, 2, 2, 357, 355, 3, 2, 2, 2, 357, 358, 3, 2, 2, 2, 358, 368, 3, 2, 2, 2, 359, 357, 3, 2, 2, 2, 360, 366, 7, 56, 2, 2, 361, 362, 7, 59, 2, 2, 362, 364, 5, 26, 14, 2, 363, 365, 7, 56, 2, 2, 364, 363, 3, 2, 2, 2, 364, 365, 3, 2, 2, 2, 365, 367, 3, 2, 2, 2, 366, 361, 3, 2, 2, 2, 366, 367, 3, 2, 2, 2, 367, 369, 3, 2, 2, 2, 368, 360, 3, 2, 2, 2, 368, 369, 3, 2, 2, 2, 369, 376, 3, 2, 2, 2, 370, 371, 7, 59, 2, 2, 371, 373, 5, 26, 14, 2, 372, 374, 7, 56, 2, 2, 373, 372, 3, 2, 2, 2, 373, 374, 3, 2, 2, 2, 374, 376, 3, 2, 2, 2, 375, 345, 3, 2, 2, 2, 375, 370, 3, 2, 2, 2, 375, 376, 3, 2, 2, 2, 376, 378, 3, 2, 2, 2, 377, 344, 3, 2, 2, 2, 377, 378, 3, 2, 2, 2, 378, 410, 3, 2, 2, 2, 379, 381, 7, 53, 2, 2, 380, 382, 5, 26, 14, 2, 381, 380, 3, 2, 2, 2, 381, 382, 3, 2, 2, 2, 382, 391, 3, 2, 2, 2, 383, 384, 7, 56, 2, 2, 384, 387, 5, 26, 14, 2, 385, 386, 7, 60, 2, 2, 386, 388, 5, 100, 51, 2, 387, 385, 3, 2, 2, 2, 387, 388, 3, 2, 2, 2, 388, 390, 3, 2, 2, 2, 389, 383, 3, 2, 2, 2, 390, 393, 3, 2, 2, 2, 391, 389, 3, 2, 2, 2, 391, 392, 3, 2, 2, 2, 392, 402, 3, 2, 2, 2, 393, 391, 3, 2, 2, 2, 394, 400, 7, 56, 2, 2, 395, 396, 7, 59, 2, 2, 396, 398, 5, 26, 14, 2, 397, 399, 7, 56, 2, 2, 398, 397, 3, 2, 2, 2, 398, 399, 3, 2, 2, 2, 399, 401, 3, 2, 2, 2, 400, 395, 3, 2, 2, 2, 400, 401, 3, 2, 2, 2, 401, 403, 3, 2, 2, 2, 402, 394, 3, 2, 2, 2, 402, 403, 3, 2, 2, 2, 403, 410, 3, 2, 2, 2, 404, 405, 7, 59, 2, 2, 405, 407, 5, 26, 14, 2, 406, 408, 7, 56, 2, 2, 407, 406, 3, 2, 2, 2, 407, 408, 3, 2, 2, 2, 408, 410, 3, 2, 2, 2, 409, 328, 3, 2, 2, 2, 409, 379, 3, 2, 2, 2, 409, 404, 3, 2, 2, 2, 410, 25, 3, 2, 2, 2, 411, 412, 7, 42, 2, 2, 412, 27, 3, 2, 2, 2, 413, 416, 5, 30, 16, 2, 414, 416, 5, 80, 41, 2, 415, 413, 3, 2, 2, 2, 415, 414, 3, 2, 2, 2, 416, 29, 3, 2, 2, 2, 417, 422, 5, 32, 17, 2, 418, 419, 7, 58, 2, 2, 419, 421, 5, 32, 17, 2, 420, 418, 3, 2, 2, 2, 421, 424, 3, 2, 2, 2, 422, 420, 3, 2, 2, 2, 422, 423, 3, 2, 2, 2, 423, 426, 3, 2, 2, 2, 424, 422, 3, 2, 2, 2, 425, 427, 7, 58, 2, 2, 426, 425, 3, 2, 2, 2, 426, 427, 3, 2, 2, 2, 427, 428, 3, 2, 2, 2, 428, 429, 7, 41, 2, 2, 429, 31, 3, 2, 2, 2, 430, 439, 5, 34, 18, 2, 431, 439, 5, 42, 22, 2, 432, 439, 5, 44, 23, 2, 433, 439, 5, 46, 24, 2, 434, 439, 5, 58, 30, 2, 435, 439, 5, 74, 38, 2, 436, 439, 5, 76, 39, 2, 437, 439, 5, 78, 40, 2, 438, 430, 3, 2, 2, 2, 438, 431, 3, 2, 2, 2, 438, 432, 3, 2, 2, 2, 438, 433, 3, 2, 2, 2, 438, 434, 3, 2, 2, 2, 438, 435, 3, 2, 2, 2, 438, 436, 3, 2, 2, 2, 438, 437, 3, 2, 2, 2, 439, 33, 3, 2, 2, 2, 440, 457, 5, 38, 20, 2, 441, 458, 5, 36, 19, 2, 442, 445, 5, 40, 21, 2, 443, 446, 5, 170, 86, 2, 444, 446, 5, 152, 77, 2, 445, 443, 3, 2, 2, 2, 445, 444, 3, 2, 2, 2, 446, 458, 3, 2, 2, 2, 447, 450, 7, 60, 2, 2, 448, 451, 5, 170, 86, 2, 449, 451, 5, 38, 20, 2, 450, 448, 3, 2, 2, 2, 450, 449, 3, 2, 2, 2, 451, 453, 3, 2, 2, 2, 452, 447, 3, 2, 2, 2, 453, 456, 3, 2, 2, 2, 454, 452, 3, 2, 2, 2, 454, 455, 3, 2, 2, 2, 455, 458, 3, 2, 2, 2, 456, 454, 3, 2, 2, 2, 457, 441, 3, 2, 2, 2, 457, 442, 3, 2, 2, 2, 457, 454, 3, 2, 2, 2, 458, 35, 3, 2, 2, 2, 459, 460, 7, 57, 2, 2, 460, 463, 5, 100, 51, 2, 461, 462, 7, 60, 2, 2, 462, 464, 5, 100, 51, 2, 463, 461, 3, 2, 2, 2, 463, 464, 3, 2, 2, 2, 464, 37, 3, 2, 2, 2, 465, 468, 5, 100, 51, 2, 466, 468, 5, 118, 60, 2, 467, 465, 3, 2, 2, 2, 467, 466, 3, 2, 2, 2, 468, 476, 3, 2, 2, 2, 469, 472, 7, 56, 2, 2, 470, 473, 5, 100, 51, 2, 471, 473, 5, 118, 60, 2, 472, 470, 3, 2, 2, 2, 472, 471, 3, 2, 2, 2, 473, 475, 3, 2, 2, 2, 474, 469, 3, 2, 2, 2, 475, 478, 3, 2, 2, 2, 476, 474, 3, 2, 2, 2, 476, 477, 3, 2, 2, 2, 477, 480, 3, 2, 2, 2, 478, 476, 3, 2, 2, 2, 479, 481, 7, 56, 2, 2, 480, 479, 3, 2, 2, 2, 480, 481, 3, 2, 2, 2, 481, 39, 3, 2, 2, 2, 482, 483, 9, 2, 2, 2, 483, 41, 3, 2, 2, 2, 484, 485, 7, 35, 2, 2, 485, 486, 5, 150, 76, 2, 486, 43, 3, 2, 2, 2, 487, 488, 7, 36, 2, 2, 488, 45, 3, 2, 2, 2, 489, 495, 5, 48, 25, 2, 490, 495, 5, 50, 26, 2, 491, 495, 5, 52, 27, 2, 492, 495, 5, 56, 29, 2, 493, 495, 5, 54, 28, 2, 494, 489, 3, 2, 2, 2, 494, 490, 3, 2, 2, 2, 494, 491, 3, 2, 2, 2, 494, 492, 3, 2, 2, 2, 494, 493, 3, 2, 2, 2, 495, 47, 3, 2, 2, 2, 496, 497, 7, 38, 2, 2, 497, 49, 3, 2, 2, 2, 498, 499, 7, 37, 2, 2, 499, 51, 3, 2, 2, 2, 500, 502, 7, 7, 2, 2, 501, 503, 5, 152, 77, 2, 502, 501, 3, 2, 2, 2, 502, 503, 3, 2, 2, 2, 503, 53, 3, 2, 2, 2, 504, 505, 5, 170, 86, 2, 505, 55, 3, 2, 2, 2, 506, 512, 7, 8, 2, 2, 507, 510, 5, 100, 51, 2, 508, 509, 7, 9, 2, 2, 509, 511, 5, 100, 51, 2, 510, 508, 3, 2, 2, 2, 510, 511, 3, 2, 2, 2, 511, 513, 3, 2, 2, 2, 512, 507, 3, 2, 2, 2, 512, 513, 3, 2, 2, 2, 513, 57, 3, 2, 2, 2, 514, 517, 5, 60, 31, 2, 515, 517, 5, 62, 32, 2, 516, 514, 3, 2, 2, 2, 516, 515, 3, 2, 2, 2, 517, 59, 3, 2, 2, 2, 518, 519, 7, 10, 2, 2, 519, 520, 5, 70, 36, 2, 520, 61, 3, 2, 2, 2, 521, 534, 7, 9, 2, 2, 522, 524, 9, 3, 2, 2, 523, 522, 3, 2, 2, 2, 524, 527, 3, 2, 2, 2, 525, 523, 3, 2, 2, 2, 525, 526, 3, 2, 2, 2, 526, 528, 3, 2, 2, 2, 527, 525, 3, 2, 2, 2, 528, 535, 5, 72, 37, 2, 529, 531, 9, 3, 2, 2, 530, 529, 3, 2, 2, 2, 531, 532, 3, 2, 2, 2, 532, 530, 3, 2, 2, 2, 532, 533, 3, 2, 2, 2, 533, 535, 3, 2, 2, 2, 534, 525, 3, 2, 2, 2, 534, 530, 3, 2, 2, 2, 535, 536, 3, 2, 2, 2, 536, 543, 7, 10, 2, 2, 537, 544, 7, 53, 2, 2, 538, 539, 7, 54, 2, 2, 539, 540, 5, 68, 35, 2, 540, 541, 7, 55, 2, 2, 541, 544, 3, 2, 2, 2, 542, 544, 5, 68, 35, 2, 543, 537, 3, 2, 2, 2, 543, 538, 3, 2, 2, 2, 543, 542, 3, 2, 2, 2, 544, 63, 3, 2, 2, 2, 545, 548, 7, 42, 2, 2, 546, 547, 7, 11, 2, 2, 547, 549, 7, 42, 2, 2, 548, 546, 3, 2, 2, 2, 548, 549, 3, 2, 2, 2, 549, 65, 3, 2, 2, 2, 550, 553, 5, 72, 37, 2, 551, 552, 7, 11, 2, 2, 552, 554, 7, 42, 2, 2, 553, 551, 3, 2, 2, 2, 553, 554, 3, 2, 2, 2, 554, 67, 3, 2, 2, 2, 555, 560, 5, 64, 33, 2, 556, 557, 7, 56, 2, 2, 557, 559, 5, 64, 33, 2, 558, 556, 3, 2, 2, 2, 559, 562, 3, 2, 2, 2, 560, 558, 3, 2, 2, 2, 560, 561, 3, 2, 2, 2, 561, 564, 3, 2, 2, 2, 562, 560, 3, 2, 2, 2, 563, 565, 7, 56, 2, 2, 564, 563, 3, 2, 2, 2, 564, 565, 3, 2, 2, 2, 565, 69, 3, 2, 2, 2, 566, 571, 5, 66, 34, 2, 567, 568, 7, 56, 2, 2, 568, 570, 5, 66, 34, 2, 569, 567, 3, 2, 2, 2, 570, 573, 3, 2, 2, 2, 571, 569, 3, 2, 2, 2, 571, 572, 3, 2, 2, 2, 572, 71, 3, 2, 2, 2, 573, 571, 3, 2, 2, 2, 574, 579, 7, 42, 2, 2, 575, 576, 7, 51, 2, 2, 576, 578, 7, 42, 2, 2, 577, 575, 3, 2, 2, 2, 578, 581, 3, 2, 2, 2, 579, 577, 3, 2, 2, 2, 579, 580, 3, 2, 2, 2, 580, 73, 3, 2, 2, 2, 581, 579, 3, 2, 2, 2, 582, 583, 7, 12, 2, 2, 583, 588, 7, 42, 2, 2, 584, 585, 7, 56, 2, 2, 585, 587, 7, 42, 2, 2, 586, 584, 3, 2, 2, 2, 587, 590, 3, 2, 2, 2, 588, 586, 3, 2, 2, 2, 588, 589, 3, 2, 2, 2, 589, 75, 3, 2, 2, 2, 590, 588, 3, 2, 2, 2, 591, 592, 7, 13, 2, 2, 592, 597, 7, 42, 2, 2, 593, 594, 7, 56, 2, 2, 594, 596, 7, 42, 2, 2, 595, 593, 3, 2, 2, 2, 596, 599, 3, 2, 2, 2, 597, 595, 3, 2, 2, 2, 597, 598, 3, 2, 2, 2, 598, 77, 3, 2, 2, 2, 599, 597, 3, 2, 2, 2, 600, 601, 7, 14, 2, 2, 601, 604, 5, 100, 51, 2, 602, 603, 7, 56, 2, 2, 603, 605, 5, 100, 51, 2, 604, 602, 3, 2, 2, 2, 604, 605, 3, 2, 2, 2, 605, 79, 3, 2, 2, 2, 606, 616, 5, 84, 43, 2, 607, 616, 5, 86, 44, 2, 608, 616, 5, 88, 45, 2, 609, 616, 5, 90, 46, 2, 610, 616, 5, 92, 47, 2, 611, 616, 5, 16, 9, 2, 612, 616, 5, 156, 79, 2, 613, 616, 5, 12, 7, 2, 614, 616, 5, 82, 42, 2, 615, 606, 3, 2, 2, 2, 615, 607, 3, 2, 2, 2, 615, 608, 3, 2, 2, 2, 615, 609, 3, 2, 2, 2, 615, 610, 3, 2, 2, 2, 615, 611, 3, 2, 2, 2, 615, 612, 3, 2, 2, 2, 615, 613, 3, 2, 2, 2, 615, 614, 3, 2, 2, 2, 616, 81, 3, 2, 2, 2, 617, 621, 7, 39, 2, 2, 618, 622, 5, 16, 9, 2, 619, 622, 5, 92, 47, 2, 620, 622, 5, 88, 45, 2, 621, 618, 3, 2, 2, 2, 621, 619, 3, 2, 2, 2, 621, 620, 3, 2, 2, 2, 622, 83, 3, 2, 2, 2, 623, 624, 7, 15, 2, 2, 624, 625, 5, 100, 51, 2, 625, 626, 7, 57, 2, 2, 626, 634, 5, 98, 50, 2, 627, 628, 7, 16, 2, 2, 628, 629, 5, 100, 51, 2, 629, 630, 7, 57, 2, 2, 630, 631, 5, 98, 50, 2, 631, 633, 3, 2, 2, 2, 632, 627, 3, 2, 2, 2, 633, 636, 3, 2, 2, 2, 634, 632, 3, 2, 2, 2, 634, 635, 3, 2, 2, 2, 635, 640, 3, 2, 2, 2, 636, 634, 3, 2, 2, 2, 637, 638, 7, 17, 2, 2, 638, 639, 7, 57, 2, 2, 639, 641, 5, 98, 50, 2, 640, 637, 3, 2, 2, 2, 640, 641, 3, 2, 2, 2, 641, 85, 3, 2, 2, 2, 642, 643, 7, 18, 2, 2, 643, 644, 5, 100, 51, 2, 644, 645, 7, 57, 2, 2, 645, 649, 5, 98, 50, 2, 646, 647, 7, 17, 2, 2, 647, 648, 7, 57, 2, 2, 648, 650, 5, 98, 50, 2, 649, 646, 3, 2, 2, 2, 649, 650, 3, 2, 2, 2, 650, 87, 3, 2, 2, 2, 651, 652, 7, 19, 2, 2, 652, 653, 5, 150, 76, 2, 653, 654, 7, 20, 2, 2, 654, 655, 5, 152, 77, 2, 655, 656, 7, 57, 2, 2, 656, 660, 5, 98, 50, 2, 657, 658, 7, 17, 2, 2, 658, 659, 7, 57, 2, 2, 659, 661, 5, 98, 50, 2, 660, 657, 3, 2, 2, 2, 660, 661, 3, 2, 2, 2, 661, 89, 3, 2, 2, 2, 662, 663, 7, 21, 2, 2, 663, 664, 7, 57, 2, 2, 664, 686, 5, 98, 50, 2, 665, 666, 5, 96, 49, 2, 666, 667, 7, 57, 2, 2, 667, 668, 5, 98, 50, 2, 668, 670, 3, 2, 2, 2, 669, 665, 3, 2, 2, 2, 670, 671, 3, 2, 2, 2, 671, 669, 3, 2, 2, 2, 671, 672, 3, 2, 2, 2, 672, 676, 3, 2, 2, 2, 673, 674, 7, 17, 2, 2, 674, 675, 7, 57, 2, 2, 675, 677, 5, 98, 50, 2, 676, 673, 3, 2, 2, 2, 676, 677, 3, 2, 2, 2, 677, 681, 3, 2, 2, 2, 678, 679, 7, 22, 2, 2, 679, 680, 7, 57, 2, 2, 680, 682, 5, 98, 50, 2, 681, 678, 3, 2, 2, 2, 681, 682, 3, 2, 2, 2, 682, 687, 3, 2, 2, 2, 683, 684, 7, 22, 2, 2, 684, 685, 7, 57, 2, 2, 685, 687, 5, 98, 50, 2, 686, 669, 3, 2, 2, 2, 686, 683, 3, 2, 2, 2, 687, 91, 3, 2, 2, 2, 688, 689, 7, 23, 2, 2, 689, 694, 5, 94, 48, 2, 690, 691, 7, 56, 2, 2, 691, 693, 5, 94, 48, 2, 692, 690, 3, 2, 2, 2, 693, 696, 3, 2, 2, 2, 694, 692, 3, 2, 2, 2, 694, 695, 3, 2, 2, 2, 695, 697, 3, 2, 2, 2, 696, 694, 3, 2, 2, 2, 697, 698, 7, 57, 2, 2, 698, 699, 5, 98, 50, 2, 699, 93, 3, 2, 2, 2, 700, 703, 5, 100, 51, 2, 701, 702, 7, 11, 2, 2, 702, 704, 5, 120, 61, 2, 703, 701, 3, 2, 2, 2, 703, 704, 3, 2, 2, 2, 704, 95, 3, 2, 2, 2, 705, 711, 7, 24, 2, 2, 706, 709, 5, 100, 51, 2, 707, 708, 7, 11, 2, 2, 708, 710, 7, 42, 2, 2, 709, 707, 3, 2, 2, 2, 709, 710, 3, 2, 2, 2, 710, 712, 3, 2, 2, 2, 711, 706, 3, 2, 2, 2, 711, 712, 3, 2, 2, 2, 712, 97, 3, 2, 2, 2, 713, 724, 5, 30, 16, 2, 714, 715, 7, 41, 2, 2, 715, 717, 7, 100, 2, 2, 716, 718, 5, 28, 15, 2, 717, 716, 3, 2, 2, 2, 718, 719, 3, 2, 2, 2, 719, 717, 3, 2, 2, 2, 719, 720, 3, 2, 2, 2, 720, 721, 3, 2, 2, 2, 721, 722, 7, 101, 2, 2, 722, 724, 3, 2, 2, 2, 723, 713, 3, 2, 2, 2, 723, 714, 3, 2, 2, 2, 724, 99, 3, 2, 2, 2, 725, 731, 5, 108, 55, 2, 726, 727, 7, 15, 2, 2, 727, 728, 5, 108, 55, 2, 728, 729, 7, 17, 2, 2, 729, 730, 5, 100, 51, 2, 730, 732, 3, 2, 2, 2, 731, 726, 3, 2, 2, 2, 731, 732, 3, 2, 2, 2, 732, 735, 3, 2, 2, 2, 733, 735, 5, 104, 53, 2, 734, 725, 3, 2, 2, 2, 734, 733, 3, 2, 2, 2, 735, 101, 3, 2, 2, 2, 736, 739, 5, 108, 55, 2, 737, 739, 5, 106, 54, 2, 738, 736, 3, 2, 2, 2, 738, 737, 3, 2, 2, 2, 739, 103, 3, 2, 2, 2, 740, 742, 7, 25, 2, 2, 741, 743, 5, 24, 13, 2, 742, 741, 3, 2, 2, 2, 742, 743, 3, 2, 2, 2, 743, 744, 3, 2, 2, 2, 744, 745, 7, 57, 2, 2, 745, 746, 5, 100, 51, 2, 746, 105, 3, 2, 2, 2, 747, 749, 7, 25, 2, 2, 748, 750, 5, 24, 13, 2, 749, 748, 3, 2, 2, 2, 749, 750, 3, 2, 2, 2, 750, 751, 3, 2, 2, 2, 751, 752, 7, 57, 2, 2, 752, 753, 5, 102, 52, 2, 753, 107, 3, 2, 2, 2, 754, 759, 5, 110, 56, 2, 755, 756, 7, 26, 2, 2, 756, 758, 5, 110, 56, 2, 757, 755, 3, 2, 2, 2, 758, 761, 3, 2, 2, 2, 759, 757, 3, 2, 2, 2, 759, 760, 3, 2, 2, 2, 760, 109, 3, 2, 2, 2, 761, 759, 3, 2, 2, 2, 762, 767, 5, 112, 57, 2, 763, 764, 7, 27, 2, 2, 764, 766, 5, 112, 57, 2, 765, 763, 3, 2, 2, 2, 766, 769, 3, 2, 2, 2, 767, 765, 3, 2, 2, 2, 767, 768, 3, 2, 2, 2, 768, 111, 3, 2, 2, 2, 769, 767, 3, 2, 2, 2, 770, 771, 7, 28, 2, 2, 771, 774, 5, 112, 57, 2, 772, 774, 5, 114, 58, 2, 773, 770, 3, 2, 2, 2, 773, 772, 3, 2, 2, 2, 774, 113, 3, 2, 2, 2, 775, 781, 5, 120, 61, 2, 776, 777, 5, 116, 59, 2, 777, 778, 5, 120, 61, 2, 778, 780, 3, 2, 2, 2, 779, 776, 3, 2, 2, 2, 780, 783, 3, 2, 2, 2, 781, 779, 3, 2, 2, 2, 781, 782, 3, 2, 2, 2, 782, 115, 3, 2, 2, 2, 783, 781, 3, 2, 2, 2, 784, 798, 7, 76, 2, 2, 785, 798, 7, 77, 2, 2, 786, 798, 7, 78, 2, 2, 787, 798, 7, 79, 2, 2, 788, 798, 7, 80, 2, 2, 789, 798, 7, 81, 2, 2, 790, 798, 7, 82, 2, 2, 791, 798, 7, 20, 2, 2, 792, 793, 7, 28, 2, 2, 793, 798, 7, 20, 2, 2, 794, 798, 7, 29, 2, 2, 795, 796, 7, 29, 2, 2, 796, 798, 7, 28, 2, 2, 797, 784, 3, 2, 2, 2, 797, 785, 3, 2, 2, 2, 797, 786, 3, 2, 2, 2, 797, 787, 3, 2, 2, 2, 797, 788, 3, 2, 2, 2, 797, 789, 3, 2, 2, 2, 797, 790, 3, 2, 2, 2, 797, 791, 3, 2, 2, 2, 797, 792, 3, 2, 2, 2, 797, 794, 3, 2, 2, 2, 797, 795, 3, 2, 2, 2, 798, 117, 3, 2, 2, 2, 799, 800, 7, 53, 2, 2, 800, 801, 5, 120, 61, 2, 801, 119, 3, 2, 2, 2, 802, 807, 5, 122, 62, 2, 803, 804, 7, 63, 2, 2, 804, 806, 5, 122, 62, 2, 805, 803, 3, 2, 2, 2, 806, 809, 3, 2, 2, 2, 807, 805, 3, 2, 2, 2, 807, 808, 3, 2, 2, 2, 808, 121, 3, 2, 2, 2, 809, 807, 3, 2, 2, 2, 810, 815, 5, 124, 63, 2, 811, 812, 7, 64, 2, 2, 812, 814, 5, 124, 63, 2, 813, 811, 3, 2, 2, 2, 814, 817, 3, 2, 2, 2, 815, 813, 3, 2, 2, 2, 815, 816, 3, 2, 2, 2, 816, 123, 3, 2, 2, 2, 817, 815, 3, 2, 2, 2, 818, 823, 5, 126, 64, 2, 819, 820, 7, 65, 2, 2, 820, 822, 5, 126, 64, 2, 821, 819, 3, 2, 2, 2, 822, 825, 3, 2, 2, 2, 823, 821, 3, 2, 2, 2, 823, 824, 3, 2, 2, 2, 824, 125, 3, 2, 2, 2, 825, 823, 3, 2, 2, 2, 826, 831, 5, 128, 65, 2, 827, 828, 9, 4, 2, 2, 828, 830, 5, 128, 65, 2, 829, 827, 3, 2, 2, 2, 830, 833, 3, 2, 2, 2, 831, 829, 3, 2, 2, 2, 831, 832, 3, 2, 2, 2, 832, 127, 3, 2, 2, 2, 833, 831, 3, 2, 2, 2, 834, 839, 5, 130, 66, 2, 835, 836, 9, 5, 2, 2, 836, 838, 5, 130, 66, 2, 837, 835, 3, 2, 2, 2, 838, 841, 3, 2, 2, 2, 839, 837, 3, 2, 2, 2, 839, 840, 3, 2, 2, 2, 840, 129, 3, 2, 2, 2, 841, 839, 3, 2, 2, 2, 842, 847, 5, 132, 67, 2, 843, 844, 9, 6, 2, 2, 844, 846, 5, 132, 67, 2, 845, 843, 3, 2, 2, 2, 846, 849, 3, 2, 2, 2, 847, 845, 3, 2, 2, 2, 847, 848, 3, 2, 2, 2, 848, 131, 3, 2, 2, 2, 849, 847, 3, 2, 2, 2, 850, 851, 9, 7, 2, 2, 851, 854, 5, 132, 67, 2, 852, 854, 5, 134, 68, 2, 853, 850, 3, 2, 2, 2, 853, 852, 3, 2, 2, 2, 854, 133, 3, 2, 2, 2, 855, 858, 5, 136, 69, 2, 856, 857, 7, 59, 2, 2, 857, 859, 5, 132, 67, 2, 858, 856, 3, 2, 2, 2, 858, 859, 3, 2, 2, 2, 859, 135, 3, 2, 2, 2, 860, 862, 7, 40, 2, 2, 861, 860, 3, 2, 2, 2, 861, 862, 3, 2, 2, 2, 862, 863, 3, 2, 2, 2, 863, 867, 5, 138, 70, 2, 864, 866, 5, 142, 72, 2, 865, 864, 3, 2, 2, 2, 866, 869, 3, 2, 2, 2, 867, 865, 3, 2, 2, 2, 867, 868, 3, 2, 2, 2, 868, 137, 3, 2, 2, 2, 869, 867, 3, 2, 2, 2, 870, 873, 7, 54, 2, 2, 871, 874, 5, 170, 86, 2, 872, 874, 5, 140, 71, 2, 873, 871, 3, 2, 2, 2, 873, 872, 3, 2, 2, 2, 873, 874, 3, 2, 2, 2, 874, 875, 3, 2, 2, 2, 875, 898, 7, 55, 2, 2, 876, 878, 7, 61, 2, 2, 877, 879, 5, 140, 71, 2, 878, 877, 3, 2, 2, 2, 878, 879, 3, 2, 2, 2, 879, 880, 3, 2, 2, 2, 880, 898, 7, 62, 2, 2, 881, 883, 7, 74, 2, 2, 882, 884, 5, 154, 78, 2, 883, 882, 3, 2, 2, 2, 883, 884, 3, 2, 2, 2, 884, 885, 3, 2, 2, 2, 885, 898, 7, 75, 2, 2, 886, 898, 7, 42, 2, 2, 887, 898, 7, 4, 2, 2, 888, 890, 7, 3, 2, 2, 889, 888, 3, 2, 2, 2, 890, 891, 3, 2, 2, 2, 891, 889, 3, 2, 2, 2, 891, 892, 3, 2, 2, 2, 892, 898, 3, 2, 2, 2, 893, 898, 7, 52, 2, 2, 894, 898, 7, 30, 2, 2, 895, 898, 7, 31, 2, 2, 896, 898, 7, 32, 2, 2, 897, 870, 3, 2, 2, 2, 897, 876, 3, 2, 2, 2, 897, 881, 3, 2, 2, 2, 897, 886, 3, 2, 2, 2, 897, 887, 3, 2, 2, 2, 897, 889, 3, 2, 2, 2, 897, 893, 3, 2, 2, 2, 897, 894, 3, 2, 2, 2, 897, 895, 3, 2, 2, 2, 897, 896, 3, 2, 2, 2, 898, 139, 3, 2, 2, 2, 899, 902, 5, 100, 51, 2, 900, 902, 5, 118, 60, 2, 901, 899, 3, 2, 2, 2, 901, 900, 3, 2, 2, 2, 902, 917, 3, 2, 2, 2, 903, 918, 5, 164, 83, 2, 904, 907, 7, 56, 2, 2, 905, 908, 5, 100, 51, 2, 906, 908, 5, 118, 60, 2, 907, 905, 3, 2, 2, 2, 907, 906, 3, 2, 2, 2, 908, 910, 3, 2, 2, 2, 909, 904, 3, 2, 2, 2, 910, 913, 3, 2, 2, 2, 911, 909, 3, 2, 2, 2, 911, 912, 3, 2, 2, 2, 912, 915, 3, 2, 2, 2, 913, 911, 3, 2, 2, 2, 914, 916, 7, 56, 2, 2, 915, 914, 3, 2, 2, 2, 915, 916, 3, 2, 2, 2, 916, 918, 3, 2, 2, 2, 917, 903, 3, 2, 2, 2, 917, 911, 3, 2, 2, 2, 918, 141, 3, 2, 2, 2, 919, 921, 7, 54, 2, 2, 920, 922, 5, 158, 80, 2, 921, 920, 3, 2, 2, 2, 921, 922, 3, 2, 2, 2, 922, 923, 3, 2, 2, 2, 923, 931, 7, 55, 2, 2, 924, 925, 7, 61, 2, 2, 925, 926, 5, 144, 73, 2, 926, 927, 7, 62, 2, 2, 927, 931, 3, 2, 2, 2, 928, 929, 7, 51, 2, 2, 929, 931, 7, 42, 2, 2, 930, 919, 3, 2, 2, 2, 930, 924, 3, 2, 2, 2, 930, 928, 3, 2, 2, 2, 931, 143, 3, 2, 2, 2, 932, 937, 5, 146, 74, 2, 933, 934, 7, 56, 2, 2, 934, 936, 5, 146, 74, 2, 935, 933, 3, 2, 2, 2, 936, 939, 3, 2, 2, 2, 937, 935, 3, 2, 2, 2, 937, 938, 3, 2, 2, 2, 938, 941, 3, 2, 2, 2, 939, 937, 3, 2, 2, 2, 940, 942, 7, 56, 2, 2, 941, 940, 3, 2, 2, 2, 941, 942, 3, 2, 2, 2, 942, 145, 3, 2, 2, 2, 943, 955, 5, 100, 51, 2, 944, 946, 5, 100, 51, 2, 945, 944, 3, 2, 2, 2, 945, 946, 3, 2, 2, 2, 946, 947, 3, 2, 2, 2, 947, 949, 7, 57, 2, 2, 948, 950, 5, 100, 51, 2, 949, 948, 3, 2, 2, 2, 949, 950, 3, 2, 2, 2, 950, 952, 3, 2, 2, 2, 951, 953, 5, 148, 75, 2, 952, 951, 3, 2, 2, 2, 952, 953, 3, 2, 2, 2, 953, 955, 3, 2, 2, 2, 954, 943, 3, 2, 2, 2, 954, 945, 3, 2, 2, 2, 955, 147, 3, 2, 2, 2, 956, 958, 7, 57, 2, 2, 957, 959, 5, 100, 51, 2, 958, 957, 3, 2, 2, 2, 958, 959, 3, 2, 2, 2, 959, 149, 3, 2, 2, 2, 960, 963, 5, 120, 61, 2, 961, 963, 5, 118, 60, 2, 962, 960, 3, 2, 2, 2, 962, 961, 3, 2, 2, 2, 963, 971, 3, 2, 2, 2, 964, 967, 7, 56, 2, 2, 965, 968, 5, 120, 61, 2, 966, 968, 5, 118, 60, 2, 967, 965, 3, 2, 2, 2, 967, 966, 3, 2, 2, 2, 968, 970, 3, 2, 2, 2, 969, 964, 3, 2, 2, 2, 970, 973, 3, 2, 2, 2, 971, 969, 3, 2, 2, 2, 971, 972, 3, 2, 2, 2, 972, 975, 3, 2, 2, 2, 973, 971, 3, 2, 2, 2, 974, 976, 7, 56, 2, 2, 975, 974, 3, 2, 2, 2, 975, 976, 3, 2, 2, 2, 976, 151, 3, 2, 2, 2, 977, 982, 5, 100, 51, 2, 978, 979, 7, 56, 2, 2, 979, 981, 5, 100, 51, 2, 980, 978, 3, 2, 2, 2, 981, 984, 3, 2, 2, 2, 982, 980, 3, 2, 2, 2, 982, 983, 3, 2, 2, 2, 983, 986, 3, 2, 2, 2, 984, 982, 3, 2, 2, 2, 985, 987, 7, 56, 2, 2, 986, 985, 3, 2, 2, 2, 986, 987, 3, 2, 2, 2, 987, 153, 3, 2, 2, 2, 988, 989, 5, 100, 51, 2, 989, 990, 7, 57, 2, 2, 990, 991, 5, 100, 51, 2, 991, 995, 3, 2, 2, 2, 992, 993, 7, 59, 2, 2, 993, 995, 5, 120, 61, 2, 994, 988, 3, 2, 2, 2, 994, 992, 3, 2, 2, 2, 995, 1014, 3, 2, 2, 2, 996, 1015, 5, 164, 83, 2, 997, 1004, 7, 56, 2, 2, 998, 999, 5, 100, 51, 2, 999, 1000, 7, 57, 2, 2, 1000, 1001, 5, 100, 51, 2, 1001, 1005, 3, 2, 2, 2, 1002, 1003, 7, 59, 2, 2, 1003, 1005, 5, 120, 61, 2, 1004, 998, 3, 2, 2, 2, 1004, 1002, 3, 2, 2, 2, 1005, 1007, 3, 2, 2, 2, 1006, 997, 3, 2, 2, 2, 1007, 1010, 3, 2, 2, 2, 1008, 1006, 3, 2, 2, 2, 1008, 1009, 3, 2, 2, 2, 1009, 1012, 3, 2, 2, 2, 1010, 1008, 3, 2, 2, 2, 1011, 1013, 7, 56, 2, 2, 1012, 1011, 3, 2, 2, 2, 1012, 1013, 3, 2, 2, 2, 1013, 1015, 3, 2, 2, 2, 1014, 996, 3, 2, 2, 2, 1014, 1008, 3, 2, 2, 2, 1015, 1037, 3, 2, 2, 2, 1016, 1019, 5, 100, 51, 2, 1017, 1019, 5, 118, 60, 2, 1018, 1016, 3, 2, 2, 2, 1018, 1017, 3, 2, 2, 2, 1019, 1034, 3, 2, 2, 2, 1020, 1035, 5, 164, 83, 2, 1021, 1024, 7, 56, 2, 2, 1022, 1025, 5, 100, 51, 2, 1023, 1025, 5, 118, 60, 2, 1024, 1022, 3, 2, 2, 2, 1024, 1023, 3, 2, 2, 2, 1025, 1027, 3, 2, 2, 2, 1026, 1021, 3, 2, 2, 2, 1027, 1030, 3, 2, 2, 2, 1028, 1026, 3, 2, 2, 2, 1028, 1029, 3, 2, 2, 2, 1029, 1032, 3, 2, 2, 2, 1030, 1028, 3, 2, 2, 2, 1031, 1033, 7, 56, 2, 2, 1032, 1031, 3, 2, 2, 2, 1032, 1033, 3, 2, 2, 2, 1033, 1035, 3, 2, 2, 2, 1034, 1020, 3, 2, 2, 2, 1034, 1028, 3, 2, 2, 2, 1035, 1037, 3, 2, 2, 2, 1036, 994, 3, 2, 2, 2, 1036, 1018, 3, 2, 2, 2, 1037, 155, 3, 2, 2, 2, 1038, 1039, 7, 33, 2, 2, 1039, 1045, 7, 42, 2, 2, 1040, 1042, 7, 54, 2, 2, 1041, 1043, 5, 158, 80, 2, 1042, 1041, 3, 2, 2, 2, 1042, 1043, 3, 2, 2, 2, 1043, 1044, 3, 2, 2, 2, 1044, 1046, 7, 55, 2, 2, 1045, 1040, 3, 2, 2, 2, 1045, 1046, 3, 2, 2, 2, 1046, 1047, 3, 2, 2, 2, 1047, 1048, 7, 57, 2, 2, 1048, 1049, 5, 98, 50, 2, 1049, 157, 3, 2, 2, 2, 1050, 1055, 5, 160, 81, 2, 1051, 1052, 7, 56, 2, 2, 1052, 1054, 5, 160, 81, 2, 1053, 1051, 3, 2, 2, 2, 1054, 1057, 3, 2, 2, 2, 1055, 1053, 3, 2, 2, 2, 1055, 1056, 3, 2, 2, 2, 1056, 1059, 3, 2, 2, 2, 1057, 1055, 3, 2, 2, 2, 1058, 1060, 7, 56, 2, 2, 1059, 1058, 3, 2, 2, 2, 1059, 1060, 3, 2, 2, 2, 1060, 159, 3, 2, 2, 2, 1061, 1063, 5, 100, 51, 2, 1062, 1064, 5, 164, 83, 2, 1063, 1062, 3, 2, 2, 2, 1063, 1064, 3, 2, 2, 2, 1064, 1074, 3, 2, 2, 2, 1065, 1066, 5, 100, 51, 2, 1066, 1067, 7, 60, 2, 2, 1067, 1068, 5, 100, 51, 2, 1068, 1074, 3, 2, 2, 2, 1069, 1070, 7, 59, 2, 2, 1070, 1074, 5, 100, 51, 2, 1071, 1072, 7, 53, 2, 2, 1072, 1074, 5, 100, 51, 2, 1073, 1061, 3, 2, 2, 2, 1073, 1065, 3, 2, 2, 2, 1073, 1069, 3, 2, 2, 2, 1073, 1071, 3, 2, 2, 2, 1074, 161, 3, 2, 2, 2, 1075, 1078, 5, 164, 83, 2, 1076, 1078, 5, 166, 84, 2, 1077, 1075, 3, 2, 2, 2, 1077, 1076, 3, 2, 2, 2, 1078, 163, 3, 2, 2, 2, 1079, 1081, 7, 39, 2, 2, 1080, 1079, 3, 2, 2, 2, 1080, 1081, 3, 2, 2, 2, 1081, 1082, 3, 2, 2, 2, 1082, 1083, 7, 19, 2, 2, 1083, 1084, 5, 150, 76, 2, 1084, 1085, 7, 20, 2, 2, 1085, 1087, 5, 108, 55, 2, 1086, 1088, 5, 162, 82, 2, 1087, 1086, 3, 2, 2, 2, 1087, 1088, 3, 2, 2, 2, 1088, 165, 3, 2, 2, 2, 1089, 1090, 7, 15, 2, 2, 1090, 1092, 5, 102, 52, 2, 1091, 1093, 5, 162, 82, 2, 1092, 1091, 3, 2, 2, 2, 1092, 1093, 3, 2, 2, 2, 1093, 167, 3, 2, 2, 2, 1094, 1095, 7, 42, 2, 2, 1095, 169, 3, 2, 2, 2, 1096, 1098, 7, 34, 2, 2, 1097, 1099, 5, 172, 87, 2, 1098, 1097, 3, 2, 2, 2, 1098, 1099, 3, 2, 2, 2, 1099, 171, 3, 2, 2, 2, 1100, 1101, 7, 9, 2, 2, 1101, 1104, 5, 100, 51, 2, 1102, 1104, 5, 152, 77, 2, 1103, 1100, 3, 2, 2, 2, 1103, 1102, 3, 2, 2, 2, 1104, 173, 3, 2, 2, 2, 168, 179, 183, 185, 194, 203, 206, 213, 219, 229, 236, 243, 249, 253, 259, 265, 269, 276, 278, 280, 285, 287, 289, 293, 299, 303, 310, 312, 314, 319, 321, 326, 331, 337, 341, 347, 353, 357, 364, 366, 368, 373, 375, 377, 381, 387, 391, 398, 400, 402, 407, 409, 415, 422, 426, 438, 445, 450, 454, 457, 463, 467, 472, 476, 480, 494, 502, 510, 512, 516, 525, 532, 534, 543, 548, 553, 560, 564, 571, 579, 588, 597, 604, 615, 621, 634, 640, 649, 660, 671, 676, 681, 686, 694, 703, 709, 711, 719, 723, 731, 734, 738, 742, 749, 759, 767, 773, 781, 797, 807, 815, 823, 831, 839, 847, 853, 858, 861, 867, 873, 878, 883, 891, 897, 901, 907, 911, 915, 917, 921, 930, 937, 941, 945, 949, 952, 954, 958, 962, 967, 971, 975, 982, 986, 994, 1004, 1008, 1012, 1014, 1018, 1024, 1028, 1032, 1034, 1036, 1042, 1045, 1055, 1059, 1063, 1073, 1077, 1080, 1087, 1092, 1098, 1103] \ No newline at end of file diff --git a/src/gpsl/grammar/.antlr/Python3.tokens b/src/gpsl/grammar/.antlr/Python3.tokens new file mode 100644 index 0000000..40925d2 --- /dev/null +++ b/src/gpsl/grammar/.antlr/Python3.tokens @@ -0,0 +1,181 @@ +STRING=1 +NUMBER=2 +INTEGER=3 +DEF=4 +RETURN=5 +RAISE=6 +FROM=7 +IMPORT=8 +AS=9 +GLOBAL=10 +NONLOCAL=11 +ASSERT=12 +IF=13 +ELIF=14 +ELSE=15 +WHILE=16 +FOR=17 +IN=18 +TRY=19 +FINALLY=20 +WITH=21 +EXCEPT=22 +LAMBDA=23 +OR=24 +AND=25 +NOT=26 +IS=27 +NONE=28 +TRUE=29 +FALSE=30 +CLASS=31 +YIELD=32 +DEL=33 +PASS=34 +CONTINUE=35 +BREAK=36 +ASYNC=37 +AWAIT=38 +NEWLINE=39 +NAME=40 +STRING_LITERAL=41 +BYTES_LITERAL=42 +DECIMAL_INTEGER=43 +OCT_INTEGER=44 +HEX_INTEGER=45 +BIN_INTEGER=46 +FLOAT_NUMBER=47 +IMAG_NUMBER=48 +DOT=49 +ELLIPSIS=50 +STAR=51 +OPEN_PAREN=52 +CLOSE_PAREN=53 +COMMA=54 +COLON=55 +SEMI_COLON=56 +POWER=57 +ASSIGN=58 +OPEN_BRACK=59 +CLOSE_BRACK=60 +OR_OP=61 +XOR=62 +AND_OP=63 +LEFT_SHIFT=64 +RIGHT_SHIFT=65 +ADD=66 +MINUS=67 +DIV=68 +MOD=69 +IDIV=70 +NOT_OP=71 +OPEN_BRACE=72 +CLOSE_BRACE=73 +LESS_THAN=74 +GREATER_THAN=75 +EQUALS=76 +GT_EQ=77 +LT_EQ=78 +NOT_EQ_1=79 +NOT_EQ_2=80 +AT=81 +ARROW=82 +ADD_ASSIGN=83 +SUB_ASSIGN=84 +MULT_ASSIGN=85 +AT_ASSIGN=86 +DIV_ASSIGN=87 +MOD_ASSIGN=88 +AND_ASSIGN=89 +OR_ASSIGN=90 +XOR_ASSIGN=91 +LEFT_SHIFT_ASSIGN=92 +RIGHT_SHIFT_ASSIGN=93 +POWER_ASSIGN=94 +IDIV_ASSIGN=95 +SKIP_=96 +UNKNOWN_CHAR=97 +INDENT=98 +DEDENT=99 +'def'=4 +'return'=5 +'raise'=6 +'from'=7 +'import'=8 +'as'=9 +'global'=10 +'nonlocal'=11 +'assert'=12 +'if'=13 +'elif'=14 +'else'=15 +'while'=16 +'for'=17 +'in'=18 +'try'=19 +'finally'=20 +'with'=21 +'except'=22 +'lambda'=23 +'or'=24 +'and'=25 +'not'=26 +'is'=27 +'None'=28 +'True'=29 +'False'=30 +'class'=31 +'yield'=32 +'del'=33 +'pass'=34 +'continue'=35 +'break'=36 +'async'=37 +'await'=38 +'.'=49 +'...'=50 +'*'=51 +'('=52 +')'=53 +','=54 +':'=55 +';'=56 +'**'=57 +'='=58 +'['=59 +']'=60 +'|'=61 +'^'=62 +'&'=63 +'<<'=64 +'>>'=65 +'+'=66 +'-'=67 +'/'=68 +'%'=69 +'//'=70 +'~'=71 +'{'=72 +'}'=73 +'<'=74 +'>'=75 +'=='=76 +'>='=77 +'<='=78 +'<>'=79 +'!='=80 +'@'=81 +'->'=82 +'+='=83 +'-='=84 +'*='=85 +'@='=86 +'/='=87 +'%='=88 +'&='=89 +'|='=90 +'^='=91 +'<<='=92 +'>>='=93 +'**='=94 +'//='=95 diff --git a/src/gpsl/grammar/.antlr/Python3Lexer.interp b/src/gpsl/grammar/.antlr/Python3Lexer.interp new file mode 100644 index 0000000..e0659d8 --- /dev/null +++ b/src/gpsl/grammar/.antlr/Python3Lexer.interp @@ -0,0 +1,335 @@ +token literal names: +null +null +null +null +'def' +'return' +'raise' +'from' +'import' +'as' +'global' +'nonlocal' +'assert' +'if' +'elif' +'else' +'while' +'for' +'in' +'try' +'finally' +'with' +'except' +'lambda' +'or' +'and' +'not' +'is' +'None' +'True' +'False' +'class' +'yield' +'del' +'pass' +'continue' +'break' +'async' +'await' +null +null +null +null +null +null +null +null +null +null +'.' +'...' +'*' +'(' +')' +',' +':' +';' +'**' +'=' +'[' +']' +'|' +'^' +'&' +'<<' +'>>' +'+' +'-' +'/' +'%' +'//' +'~' +'{' +'}' +'<' +'>' +'==' +'>=' +'<=' +'<>' +'!=' +'@' +'->' +'+=' +'-=' +'*=' +'@=' +'/=' +'%=' +'&=' +'|=' +'^=' +'<<=' +'>>=' +'**=' +'//=' +null +null + +token symbolic names: +null +STRING +NUMBER +INTEGER +DEF +RETURN +RAISE +FROM +IMPORT +AS +GLOBAL +NONLOCAL +ASSERT +IF +ELIF +ELSE +WHILE +FOR +IN +TRY +FINALLY +WITH +EXCEPT +LAMBDA +OR +AND +NOT +IS +NONE +TRUE +FALSE +CLASS +YIELD +DEL +PASS +CONTINUE +BREAK +ASYNC +AWAIT +NEWLINE +NAME +STRING_LITERAL +BYTES_LITERAL +DECIMAL_INTEGER +OCT_INTEGER +HEX_INTEGER +BIN_INTEGER +FLOAT_NUMBER +IMAG_NUMBER +DOT +ELLIPSIS +STAR +OPEN_PAREN +CLOSE_PAREN +COMMA +COLON +SEMI_COLON +POWER +ASSIGN +OPEN_BRACK +CLOSE_BRACK +OR_OP +XOR +AND_OP +LEFT_SHIFT +RIGHT_SHIFT +ADD +MINUS +DIV +MOD +IDIV +NOT_OP +OPEN_BRACE +CLOSE_BRACE +LESS_THAN +GREATER_THAN +EQUALS +GT_EQ +LT_EQ +NOT_EQ_1 +NOT_EQ_2 +AT +ARROW +ADD_ASSIGN +SUB_ASSIGN +MULT_ASSIGN +AT_ASSIGN +DIV_ASSIGN +MOD_ASSIGN +AND_ASSIGN +OR_ASSIGN +XOR_ASSIGN +LEFT_SHIFT_ASSIGN +RIGHT_SHIFT_ASSIGN +POWER_ASSIGN +IDIV_ASSIGN +SKIP_ +UNKNOWN_CHAR + +rule names: +STRING +NUMBER +INTEGER +DEF +RETURN +RAISE +FROM +IMPORT +AS +GLOBAL +NONLOCAL +ASSERT +IF +ELIF +ELSE +WHILE +FOR +IN +TRY +FINALLY +WITH +EXCEPT +LAMBDA +OR +AND +NOT +IS +NONE +TRUE +FALSE +CLASS +YIELD +DEL +PASS +CONTINUE +BREAK +ASYNC +AWAIT +NEWLINE +NAME +STRING_LITERAL +BYTES_LITERAL +DECIMAL_INTEGER +OCT_INTEGER +HEX_INTEGER +BIN_INTEGER +FLOAT_NUMBER +IMAG_NUMBER +DOT +ELLIPSIS +STAR +OPEN_PAREN +CLOSE_PAREN +COMMA +COLON +SEMI_COLON +POWER +ASSIGN +OPEN_BRACK +CLOSE_BRACK +OR_OP +XOR +AND_OP +LEFT_SHIFT +RIGHT_SHIFT +ADD +MINUS +DIV +MOD +IDIV +NOT_OP +OPEN_BRACE +CLOSE_BRACE +LESS_THAN +GREATER_THAN +EQUALS +GT_EQ +LT_EQ +NOT_EQ_1 +NOT_EQ_2 +AT +ARROW +ADD_ASSIGN +SUB_ASSIGN +MULT_ASSIGN +AT_ASSIGN +DIV_ASSIGN +MOD_ASSIGN +AND_ASSIGN +OR_ASSIGN +XOR_ASSIGN +LEFT_SHIFT_ASSIGN +RIGHT_SHIFT_ASSIGN +POWER_ASSIGN +IDIV_ASSIGN +SKIP_ +UNKNOWN_CHAR +SHORT_STRING +LONG_STRING +LONG_STRING_ITEM +LONG_STRING_CHAR +STRING_ESCAPE_SEQ +NON_ZERO_DIGIT +DIGIT +OCT_DIGIT +HEX_DIGIT +BIN_DIGIT +POINT_FLOAT +EXPONENT_FLOAT +INT_PART +FRACTION +EXPONENT +SHORT_BYTES +LONG_BYTES +LONG_BYTES_ITEM +SHORT_BYTES_CHAR_NO_SINGLE_QUOTE +SHORT_BYTES_CHAR_NO_DOUBLE_QUOTE +LONG_BYTES_CHAR +BYTES_ESCAPE_SEQ +SPACES +COMMENT +LINE_JOINING +ID_START +ID_CONTINUE + +channel names: +DEFAULT_TOKEN_CHANNEL +HIDDEN + +mode names: +DEFAULT_MODE + +atn: +[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 2, 99, 883, 8, 1, 4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7, 4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13, 9, 13, 4, 14, 9, 14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4, 18, 9, 18, 4, 19, 9, 19, 4, 20, 9, 20, 4, 21, 9, 21, 4, 22, 9, 22, 4, 23, 9, 23, 4, 24, 9, 24, 4, 25, 9, 25, 4, 26, 9, 26, 4, 27, 9, 27, 4, 28, 9, 28, 4, 29, 9, 29, 4, 30, 9, 30, 4, 31, 9, 31, 4, 32, 9, 32, 4, 33, 9, 33, 4, 34, 9, 34, 4, 35, 9, 35, 4, 36, 9, 36, 4, 37, 9, 37, 4, 38, 9, 38, 4, 39, 9, 39, 4, 40, 9, 40, 4, 41, 9, 41, 4, 42, 9, 42, 4, 43, 9, 43, 4, 44, 9, 44, 4, 45, 9, 45, 4, 46, 9, 46, 4, 47, 9, 47, 4, 48, 9, 48, 4, 49, 9, 49, 4, 50, 9, 50, 4, 51, 9, 51, 4, 52, 9, 52, 4, 53, 9, 53, 4, 54, 9, 54, 4, 55, 9, 55, 4, 56, 9, 56, 4, 57, 9, 57, 4, 58, 9, 58, 4, 59, 9, 59, 4, 60, 9, 60, 4, 61, 9, 61, 4, 62, 9, 62, 4, 63, 9, 63, 4, 64, 9, 64, 4, 65, 9, 65, 4, 66, 9, 66, 4, 67, 9, 67, 4, 68, 9, 68, 4, 69, 9, 69, 4, 70, 9, 70, 4, 71, 9, 71, 4, 72, 9, 72, 4, 73, 9, 73, 4, 74, 9, 74, 4, 75, 9, 75, 4, 76, 9, 76, 4, 77, 9, 77, 4, 78, 9, 78, 4, 79, 9, 79, 4, 80, 9, 80, 4, 81, 9, 81, 4, 82, 9, 82, 4, 83, 9, 83, 4, 84, 9, 84, 4, 85, 9, 85, 4, 86, 9, 86, 4, 87, 9, 87, 4, 88, 9, 88, 4, 89, 9, 89, 4, 90, 9, 90, 4, 91, 9, 91, 4, 92, 9, 92, 4, 93, 9, 93, 4, 94, 9, 94, 4, 95, 9, 95, 4, 96, 9, 96, 4, 97, 9, 97, 4, 98, 9, 98, 4, 99, 9, 99, 4, 100, 9, 100, 4, 101, 9, 101, 4, 102, 9, 102, 4, 103, 9, 103, 4, 104, 9, 104, 4, 105, 9, 105, 4, 106, 9, 106, 4, 107, 9, 107, 4, 108, 9, 108, 4, 109, 9, 109, 4, 110, 9, 110, 4, 111, 9, 111, 4, 112, 9, 112, 4, 113, 9, 113, 4, 114, 9, 114, 4, 115, 9, 115, 4, 116, 9, 116, 4, 117, 9, 117, 4, 118, 9, 118, 4, 119, 9, 119, 4, 120, 9, 120, 4, 121, 9, 121, 4, 122, 9, 122, 4, 123, 9, 123, 4, 124, 9, 124, 4, 125, 9, 125, 3, 2, 3, 2, 5, 2, 254, 10, 2, 3, 3, 3, 3, 3, 3, 5, 3, 259, 10, 3, 3, 4, 3, 4, 3, 4, 3, 4, 5, 4, 265, 10, 4, 3, 5, 3, 5, 3, 5, 3, 5, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 10, 3, 10, 3, 10, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 14, 3, 14, 3, 14, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 18, 3, 18, 3, 18, 3, 18, 3, 19, 3, 19, 3, 19, 3, 20, 3, 20, 3, 20, 3, 20, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 22, 3, 22, 3, 22, 3, 22, 3, 22, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 25, 3, 25, 3, 25, 3, 26, 3, 26, 3, 26, 3, 26, 3, 27, 3, 27, 3, 27, 3, 27, 3, 28, 3, 28, 3, 28, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 34, 3, 34, 3, 34, 3, 34, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 40, 3, 40, 3, 40, 5, 40, 460, 10, 40, 3, 40, 3, 40, 5, 40, 464, 10, 40, 3, 40, 5, 40, 467, 10, 40, 5, 40, 469, 10, 40, 3, 40, 3, 40, 3, 41, 3, 41, 7, 41, 475, 10, 41, 12, 41, 14, 41, 478, 11, 41, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 5, 42, 485, 10, 42, 3, 42, 3, 42, 5, 42, 489, 10, 42, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 5, 43, 496, 10, 43, 3, 43, 3, 43, 5, 43, 500, 10, 43, 3, 44, 3, 44, 7, 44, 504, 10, 44, 12, 44, 14, 44, 507, 11, 44, 3, 44, 6, 44, 510, 10, 44, 13, 44, 14, 44, 511, 5, 44, 514, 10, 44, 3, 45, 3, 45, 3, 45, 6, 45, 519, 10, 45, 13, 45, 14, 45, 520, 3, 46, 3, 46, 3, 46, 6, 46, 526, 10, 46, 13, 46, 14, 46, 527, 3, 47, 3, 47, 3, 47, 6, 47, 533, 10, 47, 13, 47, 14, 47, 534, 3, 48, 3, 48, 5, 48, 539, 10, 48, 3, 49, 3, 49, 5, 49, 543, 10, 49, 3, 49, 3, 49, 3, 50, 3, 50, 3, 51, 3, 51, 3, 51, 3, 51, 3, 52, 3, 52, 3, 53, 3, 53, 3, 53, 3, 54, 3, 54, 3, 54, 3, 55, 3, 55, 3, 56, 3, 56, 3, 57, 3, 57, 3, 58, 3, 58, 3, 58, 3, 59, 3, 59, 3, 60, 3, 60, 3, 60, 3, 61, 3, 61, 3, 61, 3, 62, 3, 62, 3, 63, 3, 63, 3, 64, 3, 64, 3, 65, 3, 65, 3, 65, 3, 66, 3, 66, 3, 66, 3, 67, 3, 67, 3, 68, 3, 68, 3, 69, 3, 69, 3, 70, 3, 70, 3, 71, 3, 71, 3, 71, 3, 72, 3, 72, 3, 73, 3, 73, 3, 73, 3, 74, 3, 74, 3, 74, 3, 75, 3, 75, 3, 76, 3, 76, 3, 77, 3, 77, 3, 77, 3, 78, 3, 78, 3, 78, 3, 79, 3, 79, 3, 79, 3, 80, 3, 80, 3, 80, 3, 81, 3, 81, 3, 81, 3, 82, 3, 82, 3, 83, 3, 83, 3, 83, 3, 84, 3, 84, 3, 84, 3, 85, 3, 85, 3, 85, 3, 86, 3, 86, 3, 86, 3, 87, 3, 87, 3, 87, 3, 88, 3, 88, 3, 88, 3, 89, 3, 89, 3, 89, 3, 90, 3, 90, 3, 90, 3, 91, 3, 91, 3, 91, 3, 92, 3, 92, 3, 92, 3, 93, 3, 93, 3, 93, 3, 93, 3, 94, 3, 94, 3, 94, 3, 94, 3, 95, 3, 95, 3, 95, 3, 95, 3, 96, 3, 96, 3, 96, 3, 96, 3, 97, 3, 97, 3, 97, 5, 97, 679, 10, 97, 3, 97, 3, 97, 3, 98, 3, 98, 3, 99, 3, 99, 3, 99, 7, 99, 688, 10, 99, 12, 99, 14, 99, 691, 11, 99, 3, 99, 3, 99, 3, 99, 3, 99, 7, 99, 697, 10, 99, 12, 99, 14, 99, 700, 11, 99, 3, 99, 5, 99, 703, 10, 99, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 7, 100, 710, 10, 100, 12, 100, 14, 100, 713, 11, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 7, 100, 723, 10, 100, 12, 100, 14, 100, 726, 11, 100, 3, 100, 3, 100, 3, 100, 5, 100, 731, 10, 100, 3, 101, 3, 101, 5, 101, 735, 10, 101, 3, 102, 3, 102, 3, 103, 3, 103, 3, 103, 3, 103, 5, 103, 743, 10, 103, 3, 104, 3, 104, 3, 105, 3, 105, 3, 106, 3, 106, 3, 107, 3, 107, 3, 108, 3, 108, 3, 109, 5, 109, 756, 10, 109, 3, 109, 3, 109, 3, 109, 3, 109, 5, 109, 762, 10, 109, 3, 110, 3, 110, 5, 110, 766, 10, 110, 3, 110, 3, 110, 3, 111, 6, 111, 771, 10, 111, 13, 111, 14, 111, 772, 3, 112, 3, 112, 6, 112, 777, 10, 112, 13, 112, 14, 112, 778, 3, 113, 3, 113, 5, 113, 783, 10, 113, 3, 113, 6, 113, 786, 10, 113, 13, 113, 14, 113, 787, 3, 114, 3, 114, 3, 114, 7, 114, 793, 10, 114, 12, 114, 14, 114, 796, 11, 114, 3, 114, 3, 114, 3, 114, 3, 114, 7, 114, 802, 10, 114, 12, 114, 14, 114, 805, 11, 114, 3, 114, 5, 114, 808, 10, 114, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 7, 115, 815, 10, 115, 12, 115, 14, 115, 818, 11, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 7, 115, 828, 10, 115, 12, 115, 14, 115, 831, 11, 115, 3, 115, 3, 115, 3, 115, 5, 115, 836, 10, 115, 3, 116, 3, 116, 5, 116, 840, 10, 116, 3, 117, 5, 117, 843, 10, 117, 3, 118, 5, 118, 846, 10, 118, 3, 119, 5, 119, 849, 10, 119, 3, 120, 3, 120, 3, 120, 3, 121, 6, 121, 855, 10, 121, 13, 121, 14, 121, 856, 3, 122, 3, 122, 7, 122, 861, 10, 122, 12, 122, 14, 122, 864, 11, 122, 3, 123, 3, 123, 5, 123, 868, 10, 123, 3, 123, 5, 123, 871, 10, 123, 3, 123, 3, 123, 5, 123, 875, 10, 123, 3, 124, 5, 124, 878, 10, 124, 3, 125, 3, 125, 5, 125, 882, 10, 125, 6, 711, 724, 816, 829, 2, 126, 3, 3, 5, 4, 7, 5, 9, 6, 11, 7, 13, 8, 15, 9, 17, 10, 19, 11, 21, 12, 23, 13, 25, 14, 27, 15, 29, 16, 31, 17, 33, 18, 35, 19, 37, 20, 39, 21, 41, 22, 43, 23, 45, 24, 47, 25, 49, 26, 51, 27, 53, 28, 55, 29, 57, 30, 59, 31, 61, 32, 63, 33, 65, 34, 67, 35, 69, 36, 71, 37, 73, 38, 75, 39, 77, 40, 79, 41, 81, 42, 83, 43, 85, 44, 87, 45, 89, 46, 91, 47, 93, 48, 95, 49, 97, 50, 99, 51, 101, 52, 103, 53, 105, 54, 107, 55, 109, 56, 111, 57, 113, 58, 115, 59, 117, 60, 119, 61, 121, 62, 123, 63, 125, 64, 127, 65, 129, 66, 131, 67, 133, 68, 135, 69, 137, 70, 139, 71, 141, 72, 143, 73, 145, 74, 147, 75, 149, 76, 151, 77, 153, 78, 155, 79, 157, 80, 159, 81, 161, 82, 163, 83, 165, 84, 167, 85, 169, 86, 171, 87, 173, 88, 175, 89, 177, 90, 179, 91, 181, 92, 183, 93, 185, 94, 187, 95, 189, 96, 191, 97, 193, 98, 195, 99, 197, 2, 199, 2, 201, 2, 203, 2, 205, 2, 207, 2, 209, 2, 211, 2, 213, 2, 215, 2, 217, 2, 219, 2, 221, 2, 223, 2, 225, 2, 227, 2, 229, 2, 231, 2, 233, 2, 235, 2, 237, 2, 239, 2, 241, 2, 243, 2, 245, 2, 247, 2, 249, 2, 3, 2, 27, 8, 2, 72, 72, 84, 84, 87, 87, 104, 104, 116, 116, 119, 119, 4, 2, 72, 72, 104, 104, 4, 2, 84, 84, 116, 116, 4, 2, 68, 68, 100, 100, 4, 2, 81, 81, 113, 113, 4, 2, 90, 90, 122, 122, 4, 2, 76, 76, 108, 108, 6, 2, 12, 12, 14, 15, 41, 41, 94, 94, 6, 2, 12, 12, 14, 15, 36, 36, 94, 94, 3, 2, 94, 94, 3, 2, 51, 59, 3, 2, 50, 59, 3, 2, 50, 57, 5, 2, 50, 59, 67, 72, 99, 104, 3, 2, 50, 51, 4, 2, 71, 71, 103, 103, 4, 2, 45, 45, 47, 47, 7, 2, 2, 11, 13, 14, 16, 40, 42, 93, 95, 129, 7, 2, 2, 11, 13, 14, 16, 35, 37, 93, 95, 129, 4, 2, 2, 93, 95, 129, 3, 2, 2, 129, 4, 2, 11, 11, 34, 34, 4, 2, 12, 12, 14, 15, 297, 2, 67, 92, 97, 97, 99, 124, 172, 172, 183, 183, 188, 188, 194, 216, 218, 248, 250, 579, 594, 707, 712, 723, 738, 742, 752, 752, 892, 892, 904, 904, 906, 908, 910, 910, 912, 931, 933, 976, 978, 1015, 1017, 1155, 1164, 1232, 1234, 1275, 1282, 1297, 1331, 1368, 1371, 1371, 1379, 1417, 1490, 1516, 1522, 1524, 1571, 1596, 1602, 1612, 1648, 1649, 1651, 1749, 1751, 1751, 1767, 1768, 1776, 1777, 1788, 1790, 1793, 1793, 1810, 1810, 1812, 1841, 1871, 1903, 1922, 1959, 1971, 1971, 2310, 2363, 2367, 2367, 2386, 2386, 2394, 2403, 2431, 2431, 2439, 2446, 2449, 2450, 2453, 2474, 2476, 2482, 2484, 2484, 2488, 2491, 2495, 2495, 2512, 2512, 2526, 2527, 2529, 2531, 2546, 2547, 2567, 2572, 2577, 2578, 2581, 2602, 2604, 2610, 2612, 2613, 2615, 2616, 2618, 2619, 2651, 2654, 2656, 2656, 2676, 2678, 2695, 2703, 2705, 2707, 2709, 2730, 2732, 2738, 2740, 2741, 2743, 2747, 2751, 2751, 2770, 2770, 2786, 2787, 2823, 2830, 2833, 2834, 2837, 2858, 2860, 2866, 2868, 2869, 2871, 2875, 2879, 2879, 2910, 2911, 2913, 2915, 2931, 2931, 2949, 2949, 2951, 2956, 2960, 2962, 2964, 2967, 2971, 2972, 2974, 2974, 2976, 2977, 2981, 2982, 2986, 2988, 2992, 3003, 3079, 3086, 3088, 3090, 3092, 3114, 3116, 3125, 3127, 3131, 3170, 3171, 3207, 3214, 3216, 3218, 3220, 3242, 3244, 3253, 3255, 3259, 3263, 3263, 3296, 3296, 3298, 3299, 3335, 3342, 3344, 3346, 3348, 3370, 3372, 3387, 3426, 3427, 3463, 3480, 3484, 3507, 3509, 3517, 3519, 3519, 3522, 3528, 3587, 3634, 3636, 3637, 3650, 3656, 3715, 3716, 3718, 3718, 3721, 3722, 3724, 3724, 3727, 3727, 3734, 3737, 3739, 3745, 3747, 3749, 3751, 3751, 3753, 3753, 3756, 3757, 3759, 3762, 3764, 3765, 3775, 3775, 3778, 3782, 3784, 3784, 3806, 3807, 3842, 3842, 3906, 3913, 3915, 3948, 3978, 3981, 4098, 4131, 4133, 4137, 4139, 4140, 4178, 4183, 4258, 4295, 4306, 4348, 4350, 4350, 4354, 4443, 4449, 4516, 4522, 4603, 4610, 4682, 4684, 4687, 4690, 4696, 4698, 4698, 4700, 4703, 4706, 4746, 4748, 4751, 4754, 4786, 4788, 4791, 4794, 4800, 4802, 4802, 4804, 4807, 4810, 4824, 4826, 4882, 4884, 4887, 4890, 4956, 4994, 5009, 5026, 5110, 5123, 5742, 5745, 5752, 5763, 5788, 5794, 5868, 5872, 5874, 5890, 5902, 5904, 5907, 5922, 5939, 5954, 5971, 5986, 5998, 6000, 6002, 6018, 6069, 6105, 6105, 6110, 6110, 6178, 6265, 6274, 6314, 6402, 6430, 6482, 6511, 6514, 6518, 6530, 6571, 6595, 6601, 6658, 6680, 7426, 7617, 7682, 7837, 7842, 7931, 7938, 7959, 7962, 7967, 7970, 8007, 8010, 8015, 8018, 8025, 8027, 8027, 8029, 8029, 8031, 8031, 8033, 8063, 8066, 8118, 8120, 8126, 8128, 8128, 8132, 8134, 8136, 8142, 8146, 8149, 8152, 8157, 8162, 8174, 8180, 8182, 8184, 8190, 8307, 8307, 8321, 8321, 8338, 8342, 8452, 8452, 8457, 8457, 8460, 8469, 8471, 8471, 8474, 8479, 8486, 8486, 8488, 8488, 8490, 8490, 8492, 8499, 8501, 8507, 8510, 8513, 8519, 8523, 8546, 8581, 11266, 11312, 11314, 11360, 11394, 11494, 11522, 11559, 11570, 11623, 11633, 11633, 11650, 11672, 11682, 11688, 11690, 11696, 11698, 11704, 11706, 11712, 11714, 11720, 11722, 11728, 11730, 11736, 11738, 11744, 12295, 12297, 12323, 12331, 12339, 12343, 12346, 12350, 12355, 12440, 12445, 12449, 12451, 12540, 12542, 12545, 12551, 12590, 12595, 12688, 12706, 12729, 12786, 12801, 13314, 19895, 19970, 40893, 40962, 42126, 43010, 43011, 43013, 43015, 43017, 43020, 43022, 43044, 44034, 55205, 63746, 64047, 64050, 64108, 64114, 64219, 64258, 64264, 64277, 64281, 64287, 64287, 64289, 64298, 64300, 64312, 64314, 64318, 64320, 64320, 64322, 64323, 64325, 64326, 64328, 64435, 64469, 64831, 64850, 64913, 64916, 64969, 65010, 65021, 65138, 65142, 65144, 65278, 65315, 65340, 65347, 65372, 65384, 65472, 65476, 65481, 65484, 65489, 65492, 65497, 65500, 65502, 150, 2, 50, 59, 770, 881, 1157, 1160, 1427, 1467, 1469, 1471, 1473, 1473, 1475, 1476, 1478, 1479, 1481, 1481, 1554, 1559, 1613, 1632, 1634, 1643, 1650, 1650, 1752, 1758, 1761, 1766, 1769, 1770, 1772, 1775, 1778, 1787, 1811, 1811, 1842, 1868, 1960, 1970, 2307, 2309, 2366, 2366, 2368, 2383, 2387, 2390, 2404, 2405, 2408, 2417, 2435, 2437, 2494, 2494, 2496, 2502, 2505, 2506, 2509, 2511, 2521, 2521, 2532, 2533, 2536, 2545, 2563, 2565, 2622, 2622, 2624, 2628, 2633, 2634, 2637, 2639, 2664, 2675, 2691, 2693, 2750, 2750, 2752, 2759, 2761, 2763, 2765, 2767, 2788, 2789, 2792, 2801, 2819, 2821, 2878, 2878, 2880, 2885, 2889, 2890, 2893, 2895, 2904, 2905, 2920, 2929, 2948, 2948, 3008, 3012, 3016, 3018, 3020, 3023, 3033, 3033, 3048, 3057, 3075, 3077, 3136, 3142, 3144, 3146, 3148, 3151, 3159, 3160, 3176, 3185, 3204, 3205, 3262, 3262, 3264, 3270, 3272, 3274, 3276, 3279, 3287, 3288, 3304, 3313, 3332, 3333, 3392, 3397, 3400, 3402, 3404, 3407, 3417, 3417, 3432, 3441, 3460, 3461, 3532, 3532, 3537, 3542, 3544, 3544, 3546, 3553, 3572, 3573, 3635, 3635, 3638, 3644, 3657, 3664, 3666, 3675, 3763, 3763, 3766, 3771, 3773, 3774, 3786, 3791, 3794, 3803, 3866, 3867, 3874, 3883, 3895, 3895, 3897, 3897, 3899, 3899, 3904, 3905, 3955, 3974, 3976, 3977, 3986, 3993, 3995, 4030, 4040, 4040, 4142, 4148, 4152, 4155, 4162, 4171, 4184, 4187, 4961, 4961, 4971, 4979, 5908, 5910, 5940, 5942, 5972, 5973, 6004, 6005, 6072, 6101, 6111, 6111, 6114, 6123, 6157, 6159, 6162, 6171, 6315, 6315, 6434, 6445, 6450, 6461, 6472, 6481, 6578, 6594, 6602, 6603, 6610, 6619, 6681, 6685, 7618, 7621, 8257, 8258, 8278, 8278, 8402, 8414, 8419, 8419, 8423, 8429, 12332, 12337, 12443, 12444, 43012, 43012, 43016, 43016, 43021, 43021, 43045, 43049, 64288, 64288, 65026, 65041, 65058, 65061, 65077, 65078, 65103, 65105, 65298, 65307, 65345, 65345, 2, 915, 2, 3, 3, 2, 2, 2, 2, 5, 3, 2, 2, 2, 2, 7, 3, 2, 2, 2, 2, 9, 3, 2, 2, 2, 2, 11, 3, 2, 2, 2, 2, 13, 3, 2, 2, 2, 2, 15, 3, 2, 2, 2, 2, 17, 3, 2, 2, 2, 2, 19, 3, 2, 2, 2, 2, 21, 3, 2, 2, 2, 2, 23, 3, 2, 2, 2, 2, 25, 3, 2, 2, 2, 2, 27, 3, 2, 2, 2, 2, 29, 3, 2, 2, 2, 2, 31, 3, 2, 2, 2, 2, 33, 3, 2, 2, 2, 2, 35, 3, 2, 2, 2, 2, 37, 3, 2, 2, 2, 2, 39, 3, 2, 2, 2, 2, 41, 3, 2, 2, 2, 2, 43, 3, 2, 2, 2, 2, 45, 3, 2, 2, 2, 2, 47, 3, 2, 2, 2, 2, 49, 3, 2, 2, 2, 2, 51, 3, 2, 2, 2, 2, 53, 3, 2, 2, 2, 2, 55, 3, 2, 2, 2, 2, 57, 3, 2, 2, 2, 2, 59, 3, 2, 2, 2, 2, 61, 3, 2, 2, 2, 2, 63, 3, 2, 2, 2, 2, 65, 3, 2, 2, 2, 2, 67, 3, 2, 2, 2, 2, 69, 3, 2, 2, 2, 2, 71, 3, 2, 2, 2, 2, 73, 3, 2, 2, 2, 2, 75, 3, 2, 2, 2, 2, 77, 3, 2, 2, 2, 2, 79, 3, 2, 2, 2, 2, 81, 3, 2, 2, 2, 2, 83, 3, 2, 2, 2, 2, 85, 3, 2, 2, 2, 2, 87, 3, 2, 2, 2, 2, 89, 3, 2, 2, 2, 2, 91, 3, 2, 2, 2, 2, 93, 3, 2, 2, 2, 2, 95, 3, 2, 2, 2, 2, 97, 3, 2, 2, 2, 2, 99, 3, 2, 2, 2, 2, 101, 3, 2, 2, 2, 2, 103, 3, 2, 2, 2, 2, 105, 3, 2, 2, 2, 2, 107, 3, 2, 2, 2, 2, 109, 3, 2, 2, 2, 2, 111, 3, 2, 2, 2, 2, 113, 3, 2, 2, 2, 2, 115, 3, 2, 2, 2, 2, 117, 3, 2, 2, 2, 2, 119, 3, 2, 2, 2, 2, 121, 3, 2, 2, 2, 2, 123, 3, 2, 2, 2, 2, 125, 3, 2, 2, 2, 2, 127, 3, 2, 2, 2, 2, 129, 3, 2, 2, 2, 2, 131, 3, 2, 2, 2, 2, 133, 3, 2, 2, 2, 2, 135, 3, 2, 2, 2, 2, 137, 3, 2, 2, 2, 2, 139, 3, 2, 2, 2, 2, 141, 3, 2, 2, 2, 2, 143, 3, 2, 2, 2, 2, 145, 3, 2, 2, 2, 2, 147, 3, 2, 2, 2, 2, 149, 3, 2, 2, 2, 2, 151, 3, 2, 2, 2, 2, 153, 3, 2, 2, 2, 2, 155, 3, 2, 2, 2, 2, 157, 3, 2, 2, 2, 2, 159, 3, 2, 2, 2, 2, 161, 3, 2, 2, 2, 2, 163, 3, 2, 2, 2, 2, 165, 3, 2, 2, 2, 2, 167, 3, 2, 2, 2, 2, 169, 3, 2, 2, 2, 2, 171, 3, 2, 2, 2, 2, 173, 3, 2, 2, 2, 2, 175, 3, 2, 2, 2, 2, 177, 3, 2, 2, 2, 2, 179, 3, 2, 2, 2, 2, 181, 3, 2, 2, 2, 2, 183, 3, 2, 2, 2, 2, 185, 3, 2, 2, 2, 2, 187, 3, 2, 2, 2, 2, 189, 3, 2, 2, 2, 2, 191, 3, 2, 2, 2, 2, 193, 3, 2, 2, 2, 2, 195, 3, 2, 2, 2, 3, 253, 3, 2, 2, 2, 5, 258, 3, 2, 2, 2, 7, 264, 3, 2, 2, 2, 9, 266, 3, 2, 2, 2, 11, 270, 3, 2, 2, 2, 13, 277, 3, 2, 2, 2, 15, 283, 3, 2, 2, 2, 17, 288, 3, 2, 2, 2, 19, 295, 3, 2, 2, 2, 21, 298, 3, 2, 2, 2, 23, 305, 3, 2, 2, 2, 25, 314, 3, 2, 2, 2, 27, 321, 3, 2, 2, 2, 29, 324, 3, 2, 2, 2, 31, 329, 3, 2, 2, 2, 33, 334, 3, 2, 2, 2, 35, 340, 3, 2, 2, 2, 37, 344, 3, 2, 2, 2, 39, 347, 3, 2, 2, 2, 41, 351, 3, 2, 2, 2, 43, 359, 3, 2, 2, 2, 45, 364, 3, 2, 2, 2, 47, 371, 3, 2, 2, 2, 49, 378, 3, 2, 2, 2, 51, 381, 3, 2, 2, 2, 53, 385, 3, 2, 2, 2, 55, 389, 3, 2, 2, 2, 57, 392, 3, 2, 2, 2, 59, 397, 3, 2, 2, 2, 61, 402, 3, 2, 2, 2, 63, 408, 3, 2, 2, 2, 65, 414, 3, 2, 2, 2, 67, 420, 3, 2, 2, 2, 69, 424, 3, 2, 2, 2, 71, 429, 3, 2, 2, 2, 73, 438, 3, 2, 2, 2, 75, 444, 3, 2, 2, 2, 77, 450, 3, 2, 2, 2, 79, 468, 3, 2, 2, 2, 81, 472, 3, 2, 2, 2, 83, 484, 3, 2, 2, 2, 85, 495, 3, 2, 2, 2, 87, 513, 3, 2, 2, 2, 89, 515, 3, 2, 2, 2, 91, 522, 3, 2, 2, 2, 93, 529, 3, 2, 2, 2, 95, 538, 3, 2, 2, 2, 97, 542, 3, 2, 2, 2, 99, 546, 3, 2, 2, 2, 101, 548, 3, 2, 2, 2, 103, 552, 3, 2, 2, 2, 105, 554, 3, 2, 2, 2, 107, 557, 3, 2, 2, 2, 109, 560, 3, 2, 2, 2, 111, 562, 3, 2, 2, 2, 113, 564, 3, 2, 2, 2, 115, 566, 3, 2, 2, 2, 117, 569, 3, 2, 2, 2, 119, 571, 3, 2, 2, 2, 121, 574, 3, 2, 2, 2, 123, 577, 3, 2, 2, 2, 125, 579, 3, 2, 2, 2, 127, 581, 3, 2, 2, 2, 129, 583, 3, 2, 2, 2, 131, 586, 3, 2, 2, 2, 133, 589, 3, 2, 2, 2, 135, 591, 3, 2, 2, 2, 137, 593, 3, 2, 2, 2, 139, 595, 3, 2, 2, 2, 141, 597, 3, 2, 2, 2, 143, 600, 3, 2, 2, 2, 145, 602, 3, 2, 2, 2, 147, 605, 3, 2, 2, 2, 149, 608, 3, 2, 2, 2, 151, 610, 3, 2, 2, 2, 153, 612, 3, 2, 2, 2, 155, 615, 3, 2, 2, 2, 157, 618, 3, 2, 2, 2, 159, 621, 3, 2, 2, 2, 161, 624, 3, 2, 2, 2, 163, 627, 3, 2, 2, 2, 165, 629, 3, 2, 2, 2, 167, 632, 3, 2, 2, 2, 169, 635, 3, 2, 2, 2, 171, 638, 3, 2, 2, 2, 173, 641, 3, 2, 2, 2, 175, 644, 3, 2, 2, 2, 177, 647, 3, 2, 2, 2, 179, 650, 3, 2, 2, 2, 181, 653, 3, 2, 2, 2, 183, 656, 3, 2, 2, 2, 185, 659, 3, 2, 2, 2, 187, 663, 3, 2, 2, 2, 189, 667, 3, 2, 2, 2, 191, 671, 3, 2, 2, 2, 193, 678, 3, 2, 2, 2, 195, 682, 3, 2, 2, 2, 197, 702, 3, 2, 2, 2, 199, 730, 3, 2, 2, 2, 201, 734, 3, 2, 2, 2, 203, 736, 3, 2, 2, 2, 205, 742, 3, 2, 2, 2, 207, 744, 3, 2, 2, 2, 209, 746, 3, 2, 2, 2, 211, 748, 3, 2, 2, 2, 213, 750, 3, 2, 2, 2, 215, 752, 3, 2, 2, 2, 217, 761, 3, 2, 2, 2, 219, 765, 3, 2, 2, 2, 221, 770, 3, 2, 2, 2, 223, 774, 3, 2, 2, 2, 225, 780, 3, 2, 2, 2, 227, 807, 3, 2, 2, 2, 229, 835, 3, 2, 2, 2, 231, 839, 3, 2, 2, 2, 233, 842, 3, 2, 2, 2, 235, 845, 3, 2, 2, 2, 237, 848, 3, 2, 2, 2, 239, 850, 3, 2, 2, 2, 241, 854, 3, 2, 2, 2, 243, 858, 3, 2, 2, 2, 245, 865, 3, 2, 2, 2, 247, 877, 3, 2, 2, 2, 249, 881, 3, 2, 2, 2, 251, 254, 5, 83, 42, 2, 252, 254, 5, 85, 43, 2, 253, 251, 3, 2, 2, 2, 253, 252, 3, 2, 2, 2, 254, 4, 3, 2, 2, 2, 255, 259, 5, 7, 4, 2, 256, 259, 5, 95, 48, 2, 257, 259, 5, 97, 49, 2, 258, 255, 3, 2, 2, 2, 258, 256, 3, 2, 2, 2, 258, 257, 3, 2, 2, 2, 259, 6, 3, 2, 2, 2, 260, 265, 5, 87, 44, 2, 261, 265, 5, 89, 45, 2, 262, 265, 5, 91, 46, 2, 263, 265, 5, 93, 47, 2, 264, 260, 3, 2, 2, 2, 264, 261, 3, 2, 2, 2, 264, 262, 3, 2, 2, 2, 264, 263, 3, 2, 2, 2, 265, 8, 3, 2, 2, 2, 266, 267, 7, 102, 2, 2, 267, 268, 7, 103, 2, 2, 268, 269, 7, 104, 2, 2, 269, 10, 3, 2, 2, 2, 270, 271, 7, 116, 2, 2, 271, 272, 7, 103, 2, 2, 272, 273, 7, 118, 2, 2, 273, 274, 7, 119, 2, 2, 274, 275, 7, 116, 2, 2, 275, 276, 7, 112, 2, 2, 276, 12, 3, 2, 2, 2, 277, 278, 7, 116, 2, 2, 278, 279, 7, 99, 2, 2, 279, 280, 7, 107, 2, 2, 280, 281, 7, 117, 2, 2, 281, 282, 7, 103, 2, 2, 282, 14, 3, 2, 2, 2, 283, 284, 7, 104, 2, 2, 284, 285, 7, 116, 2, 2, 285, 286, 7, 113, 2, 2, 286, 287, 7, 111, 2, 2, 287, 16, 3, 2, 2, 2, 288, 289, 7, 107, 2, 2, 289, 290, 7, 111, 2, 2, 290, 291, 7, 114, 2, 2, 291, 292, 7, 113, 2, 2, 292, 293, 7, 116, 2, 2, 293, 294, 7, 118, 2, 2, 294, 18, 3, 2, 2, 2, 295, 296, 7, 99, 2, 2, 296, 297, 7, 117, 2, 2, 297, 20, 3, 2, 2, 2, 298, 299, 7, 105, 2, 2, 299, 300, 7, 110, 2, 2, 300, 301, 7, 113, 2, 2, 301, 302, 7, 100, 2, 2, 302, 303, 7, 99, 2, 2, 303, 304, 7, 110, 2, 2, 304, 22, 3, 2, 2, 2, 305, 306, 7, 112, 2, 2, 306, 307, 7, 113, 2, 2, 307, 308, 7, 112, 2, 2, 308, 309, 7, 110, 2, 2, 309, 310, 7, 113, 2, 2, 310, 311, 7, 101, 2, 2, 311, 312, 7, 99, 2, 2, 312, 313, 7, 110, 2, 2, 313, 24, 3, 2, 2, 2, 314, 315, 7, 99, 2, 2, 315, 316, 7, 117, 2, 2, 316, 317, 7, 117, 2, 2, 317, 318, 7, 103, 2, 2, 318, 319, 7, 116, 2, 2, 319, 320, 7, 118, 2, 2, 320, 26, 3, 2, 2, 2, 321, 322, 7, 107, 2, 2, 322, 323, 7, 104, 2, 2, 323, 28, 3, 2, 2, 2, 324, 325, 7, 103, 2, 2, 325, 326, 7, 110, 2, 2, 326, 327, 7, 107, 2, 2, 327, 328, 7, 104, 2, 2, 328, 30, 3, 2, 2, 2, 329, 330, 7, 103, 2, 2, 330, 331, 7, 110, 2, 2, 331, 332, 7, 117, 2, 2, 332, 333, 7, 103, 2, 2, 333, 32, 3, 2, 2, 2, 334, 335, 7, 121, 2, 2, 335, 336, 7, 106, 2, 2, 336, 337, 7, 107, 2, 2, 337, 338, 7, 110, 2, 2, 338, 339, 7, 103, 2, 2, 339, 34, 3, 2, 2, 2, 340, 341, 7, 104, 2, 2, 341, 342, 7, 113, 2, 2, 342, 343, 7, 116, 2, 2, 343, 36, 3, 2, 2, 2, 344, 345, 7, 107, 2, 2, 345, 346, 7, 112, 2, 2, 346, 38, 3, 2, 2, 2, 347, 348, 7, 118, 2, 2, 348, 349, 7, 116, 2, 2, 349, 350, 7, 123, 2, 2, 350, 40, 3, 2, 2, 2, 351, 352, 7, 104, 2, 2, 352, 353, 7, 107, 2, 2, 353, 354, 7, 112, 2, 2, 354, 355, 7, 99, 2, 2, 355, 356, 7, 110, 2, 2, 356, 357, 7, 110, 2, 2, 357, 358, 7, 123, 2, 2, 358, 42, 3, 2, 2, 2, 359, 360, 7, 121, 2, 2, 360, 361, 7, 107, 2, 2, 361, 362, 7, 118, 2, 2, 362, 363, 7, 106, 2, 2, 363, 44, 3, 2, 2, 2, 364, 365, 7, 103, 2, 2, 365, 366, 7, 122, 2, 2, 366, 367, 7, 101, 2, 2, 367, 368, 7, 103, 2, 2, 368, 369, 7, 114, 2, 2, 369, 370, 7, 118, 2, 2, 370, 46, 3, 2, 2, 2, 371, 372, 7, 110, 2, 2, 372, 373, 7, 99, 2, 2, 373, 374, 7, 111, 2, 2, 374, 375, 7, 100, 2, 2, 375, 376, 7, 102, 2, 2, 376, 377, 7, 99, 2, 2, 377, 48, 3, 2, 2, 2, 378, 379, 7, 113, 2, 2, 379, 380, 7, 116, 2, 2, 380, 50, 3, 2, 2, 2, 381, 382, 7, 99, 2, 2, 382, 383, 7, 112, 2, 2, 383, 384, 7, 102, 2, 2, 384, 52, 3, 2, 2, 2, 385, 386, 7, 112, 2, 2, 386, 387, 7, 113, 2, 2, 387, 388, 7, 118, 2, 2, 388, 54, 3, 2, 2, 2, 389, 390, 7, 107, 2, 2, 390, 391, 7, 117, 2, 2, 391, 56, 3, 2, 2, 2, 392, 393, 7, 80, 2, 2, 393, 394, 7, 113, 2, 2, 394, 395, 7, 112, 2, 2, 395, 396, 7, 103, 2, 2, 396, 58, 3, 2, 2, 2, 397, 398, 7, 86, 2, 2, 398, 399, 7, 116, 2, 2, 399, 400, 7, 119, 2, 2, 400, 401, 7, 103, 2, 2, 401, 60, 3, 2, 2, 2, 402, 403, 7, 72, 2, 2, 403, 404, 7, 99, 2, 2, 404, 405, 7, 110, 2, 2, 405, 406, 7, 117, 2, 2, 406, 407, 7, 103, 2, 2, 407, 62, 3, 2, 2, 2, 408, 409, 7, 101, 2, 2, 409, 410, 7, 110, 2, 2, 410, 411, 7, 99, 2, 2, 411, 412, 7, 117, 2, 2, 412, 413, 7, 117, 2, 2, 413, 64, 3, 2, 2, 2, 414, 415, 7, 123, 2, 2, 415, 416, 7, 107, 2, 2, 416, 417, 7, 103, 2, 2, 417, 418, 7, 110, 2, 2, 418, 419, 7, 102, 2, 2, 419, 66, 3, 2, 2, 2, 420, 421, 7, 102, 2, 2, 421, 422, 7, 103, 2, 2, 422, 423, 7, 110, 2, 2, 423, 68, 3, 2, 2, 2, 424, 425, 7, 114, 2, 2, 425, 426, 7, 99, 2, 2, 426, 427, 7, 117, 2, 2, 427, 428, 7, 117, 2, 2, 428, 70, 3, 2, 2, 2, 429, 430, 7, 101, 2, 2, 430, 431, 7, 113, 2, 2, 431, 432, 7, 112, 2, 2, 432, 433, 7, 118, 2, 2, 433, 434, 7, 107, 2, 2, 434, 435, 7, 112, 2, 2, 435, 436, 7, 119, 2, 2, 436, 437, 7, 103, 2, 2, 437, 72, 3, 2, 2, 2, 438, 439, 7, 100, 2, 2, 439, 440, 7, 116, 2, 2, 440, 441, 7, 103, 2, 2, 441, 442, 7, 99, 2, 2, 442, 443, 7, 109, 2, 2, 443, 74, 3, 2, 2, 2, 444, 445, 7, 99, 2, 2, 445, 446, 7, 117, 2, 2, 446, 447, 7, 123, 2, 2, 447, 448, 7, 112, 2, 2, 448, 449, 7, 101, 2, 2, 449, 76, 3, 2, 2, 2, 450, 451, 7, 99, 2, 2, 451, 452, 7, 121, 2, 2, 452, 453, 7, 99, 2, 2, 453, 454, 7, 107, 2, 2, 454, 455, 7, 118, 2, 2, 455, 78, 3, 2, 2, 2, 456, 457, 6, 40, 2, 2, 457, 469, 5, 241, 121, 2, 458, 460, 7, 15, 2, 2, 459, 458, 3, 2, 2, 2, 459, 460, 3, 2, 2, 2, 460, 461, 3, 2, 2, 2, 461, 464, 7, 12, 2, 2, 462, 464, 4, 14, 15, 2, 463, 459, 3, 2, 2, 2, 463, 462, 3, 2, 2, 2, 464, 466, 3, 2, 2, 2, 465, 467, 5, 241, 121, 2, 466, 465, 3, 2, 2, 2, 466, 467, 3, 2, 2, 2, 467, 469, 3, 2, 2, 2, 468, 456, 3, 2, 2, 2, 468, 463, 3, 2, 2, 2, 469, 470, 3, 2, 2, 2, 470, 471, 8, 40, 2, 2, 471, 80, 3, 2, 2, 2, 472, 476, 5, 247, 124, 2, 473, 475, 5, 249, 125, 2, 474, 473, 3, 2, 2, 2, 475, 478, 3, 2, 2, 2, 476, 474, 3, 2, 2, 2, 476, 477, 3, 2, 2, 2, 477, 82, 3, 2, 2, 2, 478, 476, 3, 2, 2, 2, 479, 485, 9, 2, 2, 2, 480, 481, 9, 3, 2, 2, 481, 485, 9, 4, 2, 2, 482, 483, 9, 4, 2, 2, 483, 485, 9, 3, 2, 2, 484, 479, 3, 2, 2, 2, 484, 480, 3, 2, 2, 2, 484, 482, 3, 2, 2, 2, 484, 485, 3, 2, 2, 2, 485, 488, 3, 2, 2, 2, 486, 489, 5, 197, 99, 2, 487, 489, 5, 199, 100, 2, 488, 486, 3, 2, 2, 2, 488, 487, 3, 2, 2, 2, 489, 84, 3, 2, 2, 2, 490, 496, 9, 5, 2, 2, 491, 492, 9, 5, 2, 2, 492, 496, 9, 4, 2, 2, 493, 494, 9, 4, 2, 2, 494, 496, 9, 5, 2, 2, 495, 490, 3, 2, 2, 2, 495, 491, 3, 2, 2, 2, 495, 493, 3, 2, 2, 2, 496, 499, 3, 2, 2, 2, 497, 500, 5, 227, 114, 2, 498, 500, 5, 229, 115, 2, 499, 497, 3, 2, 2, 2, 499, 498, 3, 2, 2, 2, 500, 86, 3, 2, 2, 2, 501, 505, 5, 207, 104, 2, 502, 504, 5, 209, 105, 2, 503, 502, 3, 2, 2, 2, 504, 507, 3, 2, 2, 2, 505, 503, 3, 2, 2, 2, 505, 506, 3, 2, 2, 2, 506, 514, 3, 2, 2, 2, 507, 505, 3, 2, 2, 2, 508, 510, 7, 50, 2, 2, 509, 508, 3, 2, 2, 2, 510, 511, 3, 2, 2, 2, 511, 509, 3, 2, 2, 2, 511, 512, 3, 2, 2, 2, 512, 514, 3, 2, 2, 2, 513, 501, 3, 2, 2, 2, 513, 509, 3, 2, 2, 2, 514, 88, 3, 2, 2, 2, 515, 516, 7, 50, 2, 2, 516, 518, 9, 6, 2, 2, 517, 519, 5, 211, 106, 2, 518, 517, 3, 2, 2, 2, 519, 520, 3, 2, 2, 2, 520, 518, 3, 2, 2, 2, 520, 521, 3, 2, 2, 2, 521, 90, 3, 2, 2, 2, 522, 523, 7, 50, 2, 2, 523, 525, 9, 7, 2, 2, 524, 526, 5, 213, 107, 2, 525, 524, 3, 2, 2, 2, 526, 527, 3, 2, 2, 2, 527, 525, 3, 2, 2, 2, 527, 528, 3, 2, 2, 2, 528, 92, 3, 2, 2, 2, 529, 530, 7, 50, 2, 2, 530, 532, 9, 5, 2, 2, 531, 533, 5, 215, 108, 2, 532, 531, 3, 2, 2, 2, 533, 534, 3, 2, 2, 2, 534, 532, 3, 2, 2, 2, 534, 535, 3, 2, 2, 2, 535, 94, 3, 2, 2, 2, 536, 539, 5, 217, 109, 2, 537, 539, 5, 219, 110, 2, 538, 536, 3, 2, 2, 2, 538, 537, 3, 2, 2, 2, 539, 96, 3, 2, 2, 2, 540, 543, 5, 95, 48, 2, 541, 543, 5, 221, 111, 2, 542, 540, 3, 2, 2, 2, 542, 541, 3, 2, 2, 2, 543, 544, 3, 2, 2, 2, 544, 545, 9, 8, 2, 2, 545, 98, 3, 2, 2, 2, 546, 547, 7, 48, 2, 2, 547, 100, 3, 2, 2, 2, 548, 549, 7, 48, 2, 2, 549, 550, 7, 48, 2, 2, 550, 551, 7, 48, 2, 2, 551, 102, 3, 2, 2, 2, 552, 553, 7, 44, 2, 2, 553, 104, 3, 2, 2, 2, 554, 555, 7, 42, 2, 2, 555, 556, 8, 53, 3, 2, 556, 106, 3, 2, 2, 2, 557, 558, 7, 43, 2, 2, 558, 559, 8, 54, 4, 2, 559, 108, 3, 2, 2, 2, 560, 561, 7, 46, 2, 2, 561, 110, 3, 2, 2, 2, 562, 563, 7, 60, 2, 2, 563, 112, 3, 2, 2, 2, 564, 565, 7, 61, 2, 2, 565, 114, 3, 2, 2, 2, 566, 567, 7, 44, 2, 2, 567, 568, 7, 44, 2, 2, 568, 116, 3, 2, 2, 2, 569, 570, 7, 63, 2, 2, 570, 118, 3, 2, 2, 2, 571, 572, 7, 93, 2, 2, 572, 573, 8, 60, 5, 2, 573, 120, 3, 2, 2, 2, 574, 575, 7, 95, 2, 2, 575, 576, 8, 61, 6, 2, 576, 122, 3, 2, 2, 2, 577, 578, 7, 126, 2, 2, 578, 124, 3, 2, 2, 2, 579, 580, 7, 96, 2, 2, 580, 126, 3, 2, 2, 2, 581, 582, 7, 40, 2, 2, 582, 128, 3, 2, 2, 2, 583, 584, 7, 62, 2, 2, 584, 585, 7, 62, 2, 2, 585, 130, 3, 2, 2, 2, 586, 587, 7, 64, 2, 2, 587, 588, 7, 64, 2, 2, 588, 132, 3, 2, 2, 2, 589, 590, 7, 45, 2, 2, 590, 134, 3, 2, 2, 2, 591, 592, 7, 47, 2, 2, 592, 136, 3, 2, 2, 2, 593, 594, 7, 49, 2, 2, 594, 138, 3, 2, 2, 2, 595, 596, 7, 39, 2, 2, 596, 140, 3, 2, 2, 2, 597, 598, 7, 49, 2, 2, 598, 599, 7, 49, 2, 2, 599, 142, 3, 2, 2, 2, 600, 601, 7, 128, 2, 2, 601, 144, 3, 2, 2, 2, 602, 603, 7, 125, 2, 2, 603, 604, 8, 73, 7, 2, 604, 146, 3, 2, 2, 2, 605, 606, 7, 127, 2, 2, 606, 607, 8, 74, 8, 2, 607, 148, 3, 2, 2, 2, 608, 609, 7, 62, 2, 2, 609, 150, 3, 2, 2, 2, 610, 611, 7, 64, 2, 2, 611, 152, 3, 2, 2, 2, 612, 613, 7, 63, 2, 2, 613, 614, 7, 63, 2, 2, 614, 154, 3, 2, 2, 2, 615, 616, 7, 64, 2, 2, 616, 617, 7, 63, 2, 2, 617, 156, 3, 2, 2, 2, 618, 619, 7, 62, 2, 2, 619, 620, 7, 63, 2, 2, 620, 158, 3, 2, 2, 2, 621, 622, 7, 62, 2, 2, 622, 623, 7, 64, 2, 2, 623, 160, 3, 2, 2, 2, 624, 625, 7, 35, 2, 2, 625, 626, 7, 63, 2, 2, 626, 162, 3, 2, 2, 2, 627, 628, 7, 66, 2, 2, 628, 164, 3, 2, 2, 2, 629, 630, 7, 47, 2, 2, 630, 631, 7, 64, 2, 2, 631, 166, 3, 2, 2, 2, 632, 633, 7, 45, 2, 2, 633, 634, 7, 63, 2, 2, 634, 168, 3, 2, 2, 2, 635, 636, 7, 47, 2, 2, 636, 637, 7, 63, 2, 2, 637, 170, 3, 2, 2, 2, 638, 639, 7, 44, 2, 2, 639, 640, 7, 63, 2, 2, 640, 172, 3, 2, 2, 2, 641, 642, 7, 66, 2, 2, 642, 643, 7, 63, 2, 2, 643, 174, 3, 2, 2, 2, 644, 645, 7, 49, 2, 2, 645, 646, 7, 63, 2, 2, 646, 176, 3, 2, 2, 2, 647, 648, 7, 39, 2, 2, 648, 649, 7, 63, 2, 2, 649, 178, 3, 2, 2, 2, 650, 651, 7, 40, 2, 2, 651, 652, 7, 63, 2, 2, 652, 180, 3, 2, 2, 2, 653, 654, 7, 126, 2, 2, 654, 655, 7, 63, 2, 2, 655, 182, 3, 2, 2, 2, 656, 657, 7, 96, 2, 2, 657, 658, 7, 63, 2, 2, 658, 184, 3, 2, 2, 2, 659, 660, 7, 62, 2, 2, 660, 661, 7, 62, 2, 2, 661, 662, 7, 63, 2, 2, 662, 186, 3, 2, 2, 2, 663, 664, 7, 64, 2, 2, 664, 665, 7, 64, 2, 2, 665, 666, 7, 63, 2, 2, 666, 188, 3, 2, 2, 2, 667, 668, 7, 44, 2, 2, 668, 669, 7, 44, 2, 2, 669, 670, 7, 63, 2, 2, 670, 190, 3, 2, 2, 2, 671, 672, 7, 49, 2, 2, 672, 673, 7, 49, 2, 2, 673, 674, 7, 63, 2, 2, 674, 192, 3, 2, 2, 2, 675, 679, 5, 241, 121, 2, 676, 679, 5, 243, 122, 2, 677, 679, 5, 245, 123, 2, 678, 675, 3, 2, 2, 2, 678, 676, 3, 2, 2, 2, 678, 677, 3, 2, 2, 2, 679, 680, 3, 2, 2, 2, 680, 681, 8, 97, 9, 2, 681, 194, 3, 2, 2, 2, 682, 683, 11, 2, 2, 2, 683, 196, 3, 2, 2, 2, 684, 689, 7, 41, 2, 2, 685, 688, 5, 205, 103, 2, 686, 688, 10, 9, 2, 2, 687, 685, 3, 2, 2, 2, 687, 686, 3, 2, 2, 2, 688, 691, 3, 2, 2, 2, 689, 687, 3, 2, 2, 2, 689, 690, 3, 2, 2, 2, 690, 692, 3, 2, 2, 2, 691, 689, 3, 2, 2, 2, 692, 703, 7, 41, 2, 2, 693, 698, 7, 36, 2, 2, 694, 697, 5, 205, 103, 2, 695, 697, 10, 10, 2, 2, 696, 694, 3, 2, 2, 2, 696, 695, 3, 2, 2, 2, 697, 700, 3, 2, 2, 2, 698, 696, 3, 2, 2, 2, 698, 699, 3, 2, 2, 2, 699, 701, 3, 2, 2, 2, 700, 698, 3, 2, 2, 2, 701, 703, 7, 36, 2, 2, 702, 684, 3, 2, 2, 2, 702, 693, 3, 2, 2, 2, 703, 198, 3, 2, 2, 2, 704, 705, 7, 41, 2, 2, 705, 706, 7, 41, 2, 2, 706, 707, 7, 41, 2, 2, 707, 711, 3, 2, 2, 2, 708, 710, 5, 201, 101, 2, 709, 708, 3, 2, 2, 2, 710, 713, 3, 2, 2, 2, 711, 712, 3, 2, 2, 2, 711, 709, 3, 2, 2, 2, 712, 714, 3, 2, 2, 2, 713, 711, 3, 2, 2, 2, 714, 715, 7, 41, 2, 2, 715, 716, 7, 41, 2, 2, 716, 731, 7, 41, 2, 2, 717, 718, 7, 36, 2, 2, 718, 719, 7, 36, 2, 2, 719, 720, 7, 36, 2, 2, 720, 724, 3, 2, 2, 2, 721, 723, 5, 201, 101, 2, 722, 721, 3, 2, 2, 2, 723, 726, 3, 2, 2, 2, 724, 725, 3, 2, 2, 2, 724, 722, 3, 2, 2, 2, 725, 727, 3, 2, 2, 2, 726, 724, 3, 2, 2, 2, 727, 728, 7, 36, 2, 2, 728, 729, 7, 36, 2, 2, 729, 731, 7, 36, 2, 2, 730, 704, 3, 2, 2, 2, 730, 717, 3, 2, 2, 2, 731, 200, 3, 2, 2, 2, 732, 735, 5, 203, 102, 2, 733, 735, 5, 205, 103, 2, 734, 732, 3, 2, 2, 2, 734, 733, 3, 2, 2, 2, 735, 202, 3, 2, 2, 2, 736, 737, 10, 11, 2, 2, 737, 204, 3, 2, 2, 2, 738, 739, 7, 94, 2, 2, 739, 743, 11, 2, 2, 2, 740, 741, 7, 94, 2, 2, 741, 743, 5, 79, 40, 2, 742, 738, 3, 2, 2, 2, 742, 740, 3, 2, 2, 2, 743, 206, 3, 2, 2, 2, 744, 745, 9, 12, 2, 2, 745, 208, 3, 2, 2, 2, 746, 747, 9, 13, 2, 2, 747, 210, 3, 2, 2, 2, 748, 749, 9, 14, 2, 2, 749, 212, 3, 2, 2, 2, 750, 751, 9, 15, 2, 2, 751, 214, 3, 2, 2, 2, 752, 753, 9, 16, 2, 2, 753, 216, 3, 2, 2, 2, 754, 756, 5, 221, 111, 2, 755, 754, 3, 2, 2, 2, 755, 756, 3, 2, 2, 2, 756, 757, 3, 2, 2, 2, 757, 762, 5, 223, 112, 2, 758, 759, 5, 221, 111, 2, 759, 760, 7, 48, 2, 2, 760, 762, 3, 2, 2, 2, 761, 755, 3, 2, 2, 2, 761, 758, 3, 2, 2, 2, 762, 218, 3, 2, 2, 2, 763, 766, 5, 221, 111, 2, 764, 766, 5, 217, 109, 2, 765, 763, 3, 2, 2, 2, 765, 764, 3, 2, 2, 2, 766, 767, 3, 2, 2, 2, 767, 768, 5, 225, 113, 2, 768, 220, 3, 2, 2, 2, 769, 771, 5, 209, 105, 2, 770, 769, 3, 2, 2, 2, 771, 772, 3, 2, 2, 2, 772, 770, 3, 2, 2, 2, 772, 773, 3, 2, 2, 2, 773, 222, 3, 2, 2, 2, 774, 776, 7, 48, 2, 2, 775, 777, 5, 209, 105, 2, 776, 775, 3, 2, 2, 2, 777, 778, 3, 2, 2, 2, 778, 776, 3, 2, 2, 2, 778, 779, 3, 2, 2, 2, 779, 224, 3, 2, 2, 2, 780, 782, 9, 17, 2, 2, 781, 783, 9, 18, 2, 2, 782, 781, 3, 2, 2, 2, 782, 783, 3, 2, 2, 2, 783, 785, 3, 2, 2, 2, 784, 786, 5, 209, 105, 2, 785, 784, 3, 2, 2, 2, 786, 787, 3, 2, 2, 2, 787, 785, 3, 2, 2, 2, 787, 788, 3, 2, 2, 2, 788, 226, 3, 2, 2, 2, 789, 794, 7, 41, 2, 2, 790, 793, 5, 233, 117, 2, 791, 793, 5, 239, 120, 2, 792, 790, 3, 2, 2, 2, 792, 791, 3, 2, 2, 2, 793, 796, 3, 2, 2, 2, 794, 792, 3, 2, 2, 2, 794, 795, 3, 2, 2, 2, 795, 797, 3, 2, 2, 2, 796, 794, 3, 2, 2, 2, 797, 808, 7, 41, 2, 2, 798, 803, 7, 36, 2, 2, 799, 802, 5, 235, 118, 2, 800, 802, 5, 239, 120, 2, 801, 799, 3, 2, 2, 2, 801, 800, 3, 2, 2, 2, 802, 805, 3, 2, 2, 2, 803, 801, 3, 2, 2, 2, 803, 804, 3, 2, 2, 2, 804, 806, 3, 2, 2, 2, 805, 803, 3, 2, 2, 2, 806, 808, 7, 36, 2, 2, 807, 789, 3, 2, 2, 2, 807, 798, 3, 2, 2, 2, 808, 228, 3, 2, 2, 2, 809, 810, 7, 41, 2, 2, 810, 811, 7, 41, 2, 2, 811, 812, 7, 41, 2, 2, 812, 816, 3, 2, 2, 2, 813, 815, 5, 231, 116, 2, 814, 813, 3, 2, 2, 2, 815, 818, 3, 2, 2, 2, 816, 817, 3, 2, 2, 2, 816, 814, 3, 2, 2, 2, 817, 819, 3, 2, 2, 2, 818, 816, 3, 2, 2, 2, 819, 820, 7, 41, 2, 2, 820, 821, 7, 41, 2, 2, 821, 836, 7, 41, 2, 2, 822, 823, 7, 36, 2, 2, 823, 824, 7, 36, 2, 2, 824, 825, 7, 36, 2, 2, 825, 829, 3, 2, 2, 2, 826, 828, 5, 231, 116, 2, 827, 826, 3, 2, 2, 2, 828, 831, 3, 2, 2, 2, 829, 830, 3, 2, 2, 2, 829, 827, 3, 2, 2, 2, 830, 832, 3, 2, 2, 2, 831, 829, 3, 2, 2, 2, 832, 833, 7, 36, 2, 2, 833, 834, 7, 36, 2, 2, 834, 836, 7, 36, 2, 2, 835, 809, 3, 2, 2, 2, 835, 822, 3, 2, 2, 2, 836, 230, 3, 2, 2, 2, 837, 840, 5, 237, 119, 2, 838, 840, 5, 239, 120, 2, 839, 837, 3, 2, 2, 2, 839, 838, 3, 2, 2, 2, 840, 232, 3, 2, 2, 2, 841, 843, 9, 19, 2, 2, 842, 841, 3, 2, 2, 2, 843, 234, 3, 2, 2, 2, 844, 846, 9, 20, 2, 2, 845, 844, 3, 2, 2, 2, 846, 236, 3, 2, 2, 2, 847, 849, 9, 21, 2, 2, 848, 847, 3, 2, 2, 2, 849, 238, 3, 2, 2, 2, 850, 851, 7, 94, 2, 2, 851, 852, 9, 22, 2, 2, 852, 240, 3, 2, 2, 2, 853, 855, 9, 23, 2, 2, 854, 853, 3, 2, 2, 2, 855, 856, 3, 2, 2, 2, 856, 854, 3, 2, 2, 2, 856, 857, 3, 2, 2, 2, 857, 242, 3, 2, 2, 2, 858, 862, 7, 37, 2, 2, 859, 861, 10, 24, 2, 2, 860, 859, 3, 2, 2, 2, 861, 864, 3, 2, 2, 2, 862, 860, 3, 2, 2, 2, 862, 863, 3, 2, 2, 2, 863, 244, 3, 2, 2, 2, 864, 862, 3, 2, 2, 2, 865, 867, 7, 94, 2, 2, 866, 868, 5, 241, 121, 2, 867, 866, 3, 2, 2, 2, 867, 868, 3, 2, 2, 2, 868, 874, 3, 2, 2, 2, 869, 871, 7, 15, 2, 2, 870, 869, 3, 2, 2, 2, 870, 871, 3, 2, 2, 2, 871, 872, 3, 2, 2, 2, 872, 875, 7, 12, 2, 2, 873, 875, 4, 14, 15, 2, 874, 870, 3, 2, 2, 2, 874, 873, 3, 2, 2, 2, 875, 246, 3, 2, 2, 2, 876, 878, 9, 25, 2, 2, 877, 876, 3, 2, 2, 2, 878, 248, 3, 2, 2, 2, 879, 882, 5, 247, 124, 2, 880, 882, 9, 26, 2, 2, 881, 879, 3, 2, 2, 2, 881, 880, 3, 2, 2, 2, 882, 250, 3, 2, 2, 2, 60, 2, 253, 258, 264, 459, 463, 466, 468, 476, 484, 488, 495, 499, 505, 511, 513, 520, 527, 534, 538, 542, 678, 687, 689, 696, 698, 702, 711, 724, 730, 734, 742, 755, 761, 765, 772, 778, 782, 787, 792, 794, 801, 803, 807, 816, 829, 835, 839, 842, 845, 848, 856, 862, 867, 870, 874, 877, 881, 10, 3, 40, 2, 3, 53, 3, 3, 54, 4, 3, 60, 5, 3, 61, 6, 3, 73, 7, 3, 74, 8, 8, 2, 2] \ No newline at end of file diff --git a/src/gpsl/grammar/.antlr/Python3Lexer.java b/src/gpsl/grammar/.antlr/Python3Lexer.java new file mode 100644 index 0000000..334d934 --- /dev/null +++ b/src/gpsl/grammar/.antlr/Python3Lexer.java @@ -0,0 +1,770 @@ +// Generated from h:\Git\gpsl\src\grammar\Python3.g4 by ANTLR 4.8 + +from antlr4.Token import CommonToken +import re +import importlib +# Allow languages to extend the lexer and parser, by loading the parser dynamically +module_path = __name__[:-5] +language_name = __name__.split('.')[-1] +language_name = language_name[:-5] # Remove Lexer from name +LanguageParser = getattr(importlib.import_module('{}Parser'.format(module_path)), '{}Parser'.format(language_name)) + +import org.antlr.v4.runtime.Lexer; +import org.antlr.v4.runtime.CharStream; +import org.antlr.v4.runtime.Token; +import org.antlr.v4.runtime.TokenStream; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.atn.*; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.misc.*; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) +public class Python3Lexer extends Lexer { + static { RuntimeMetaData.checkVersion("4.8", RuntimeMetaData.VERSION); } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + STRING=1, NUMBER=2, INTEGER=3, DEF=4, RETURN=5, RAISE=6, FROM=7, IMPORT=8, + AS=9, GLOBAL=10, NONLOCAL=11, ASSERT=12, IF=13, ELIF=14, ELSE=15, WHILE=16, + FOR=17, IN=18, TRY=19, FINALLY=20, WITH=21, EXCEPT=22, LAMBDA=23, OR=24, + AND=25, NOT=26, IS=27, NONE=28, TRUE=29, FALSE=30, CLASS=31, YIELD=32, + DEL=33, PASS=34, CONTINUE=35, BREAK=36, ASYNC=37, AWAIT=38, NEWLINE=39, + NAME=40, STRING_LITERAL=41, BYTES_LITERAL=42, DECIMAL_INTEGER=43, OCT_INTEGER=44, + HEX_INTEGER=45, BIN_INTEGER=46, FLOAT_NUMBER=47, IMAG_NUMBER=48, DOT=49, + ELLIPSIS=50, STAR=51, OPEN_PAREN=52, CLOSE_PAREN=53, COMMA=54, COLON=55, + SEMI_COLON=56, POWER=57, ASSIGN=58, OPEN_BRACK=59, CLOSE_BRACK=60, OR_OP=61, + XOR=62, AND_OP=63, LEFT_SHIFT=64, RIGHT_SHIFT=65, ADD=66, MINUS=67, DIV=68, + MOD=69, IDIV=70, NOT_OP=71, OPEN_BRACE=72, CLOSE_BRACE=73, LESS_THAN=74, + GREATER_THAN=75, EQUALS=76, GT_EQ=77, LT_EQ=78, NOT_EQ_1=79, NOT_EQ_2=80, + AT=81, ARROW=82, ADD_ASSIGN=83, SUB_ASSIGN=84, MULT_ASSIGN=85, AT_ASSIGN=86, + DIV_ASSIGN=87, MOD_ASSIGN=88, AND_ASSIGN=89, OR_ASSIGN=90, XOR_ASSIGN=91, + LEFT_SHIFT_ASSIGN=92, RIGHT_SHIFT_ASSIGN=93, POWER_ASSIGN=94, IDIV_ASSIGN=95, + SKIP_=96, UNKNOWN_CHAR=97; + public static String[] channelNames = { + "DEFAULT_TOKEN_CHANNEL", "HIDDEN" + }; + + public static String[] modeNames = { + "DEFAULT_MODE" + }; + + private static String[] makeRuleNames() { + return new String[] { + "STRING", "NUMBER", "INTEGER", "DEF", "RETURN", "RAISE", "FROM", "IMPORT", + "AS", "GLOBAL", "NONLOCAL", "ASSERT", "IF", "ELIF", "ELSE", "WHILE", + "FOR", "IN", "TRY", "FINALLY", "WITH", "EXCEPT", "LAMBDA", "OR", "AND", + "NOT", "IS", "NONE", "TRUE", "FALSE", "CLASS", "YIELD", "DEL", "PASS", + "CONTINUE", "BREAK", "ASYNC", "AWAIT", "NEWLINE", "NAME", "STRING_LITERAL", + "BYTES_LITERAL", "DECIMAL_INTEGER", "OCT_INTEGER", "HEX_INTEGER", "BIN_INTEGER", + "FLOAT_NUMBER", "IMAG_NUMBER", "DOT", "ELLIPSIS", "STAR", "OPEN_PAREN", + "CLOSE_PAREN", "COMMA", "COLON", "SEMI_COLON", "POWER", "ASSIGN", "OPEN_BRACK", + "CLOSE_BRACK", "OR_OP", "XOR", "AND_OP", "LEFT_SHIFT", "RIGHT_SHIFT", + "ADD", "MINUS", "DIV", "MOD", "IDIV", "NOT_OP", "OPEN_BRACE", "CLOSE_BRACE", + "LESS_THAN", "GREATER_THAN", "EQUALS", "GT_EQ", "LT_EQ", "NOT_EQ_1", + "NOT_EQ_2", "AT", "ARROW", "ADD_ASSIGN", "SUB_ASSIGN", "MULT_ASSIGN", + "AT_ASSIGN", "DIV_ASSIGN", "MOD_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", + "LEFT_SHIFT_ASSIGN", "RIGHT_SHIFT_ASSIGN", "POWER_ASSIGN", "IDIV_ASSIGN", + "SKIP_", "UNKNOWN_CHAR", "SHORT_STRING", "LONG_STRING", "LONG_STRING_ITEM", + "LONG_STRING_CHAR", "STRING_ESCAPE_SEQ", "NON_ZERO_DIGIT", "DIGIT", "OCT_DIGIT", + "HEX_DIGIT", "BIN_DIGIT", "POINT_FLOAT", "EXPONENT_FLOAT", "INT_PART", + "FRACTION", "EXPONENT", "SHORT_BYTES", "LONG_BYTES", "LONG_BYTES_ITEM", + "SHORT_BYTES_CHAR_NO_SINGLE_QUOTE", "SHORT_BYTES_CHAR_NO_DOUBLE_QUOTE", + "LONG_BYTES_CHAR", "BYTES_ESCAPE_SEQ", "SPACES", "COMMENT", "LINE_JOINING", + "ID_START", "ID_CONTINUE" + }; + } + public static final String[] ruleNames = makeRuleNames(); + + private static String[] makeLiteralNames() { + return new String[] { + null, null, null, null, "'def'", "'return'", "'raise'", "'from'", "'import'", + "'as'", "'global'", "'nonlocal'", "'assert'", "'if'", "'elif'", "'else'", + "'while'", "'for'", "'in'", "'try'", "'finally'", "'with'", "'except'", + "'lambda'", "'or'", "'and'", "'not'", "'is'", "'None'", "'True'", "'False'", + "'class'", "'yield'", "'del'", "'pass'", "'continue'", "'break'", "'async'", + "'await'", null, null, null, null, null, null, null, null, null, null, + "'.'", "'...'", "'*'", "'('", "')'", "','", "':'", "';'", "'**'", "'='", + "'['", "']'", "'|'", "'^'", "'&'", "'<<'", "'>>'", "'+'", "'-'", "'/'", + "'%'", "'//'", "'~'", "'{'", "'}'", "'<'", "'>'", "'=='", "'>='", "'<='", + "'<>'", "'!='", "'@'", "'->'", "'+='", "'-='", "'*='", "'@='", "'/='", + "'%='", "'&='", "'|='", "'^='", "'<<='", "'>>='", "'**='", "'//='" + }; + } + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static String[] makeSymbolicNames() { + return new String[] { + null, "STRING", "NUMBER", "INTEGER", "DEF", "RETURN", "RAISE", "FROM", + "IMPORT", "AS", "GLOBAL", "NONLOCAL", "ASSERT", "IF", "ELIF", "ELSE", + "WHILE", "FOR", "IN", "TRY", "FINALLY", "WITH", "EXCEPT", "LAMBDA", "OR", + "AND", "NOT", "IS", "NONE", "TRUE", "FALSE", "CLASS", "YIELD", "DEL", + "PASS", "CONTINUE", "BREAK", "ASYNC", "AWAIT", "NEWLINE", "NAME", "STRING_LITERAL", + "BYTES_LITERAL", "DECIMAL_INTEGER", "OCT_INTEGER", "HEX_INTEGER", "BIN_INTEGER", + "FLOAT_NUMBER", "IMAG_NUMBER", "DOT", "ELLIPSIS", "STAR", "OPEN_PAREN", + "CLOSE_PAREN", "COMMA", "COLON", "SEMI_COLON", "POWER", "ASSIGN", "OPEN_BRACK", + "CLOSE_BRACK", "OR_OP", "XOR", "AND_OP", "LEFT_SHIFT", "RIGHT_SHIFT", + "ADD", "MINUS", "DIV", "MOD", "IDIV", "NOT_OP", "OPEN_BRACE", "CLOSE_BRACE", + "LESS_THAN", "GREATER_THAN", "EQUALS", "GT_EQ", "LT_EQ", "NOT_EQ_1", + "NOT_EQ_2", "AT", "ARROW", "ADD_ASSIGN", "SUB_ASSIGN", "MULT_ASSIGN", + "AT_ASSIGN", "DIV_ASSIGN", "MOD_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", + "LEFT_SHIFT_ASSIGN", "RIGHT_SHIFT_ASSIGN", "POWER_ASSIGN", "IDIV_ASSIGN", + "SKIP_", "UNKNOWN_CHAR" + }; + } + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated + public static final String[] tokenNames; + static { + tokenNames = new String[_SYMBOLIC_NAMES.length]; + for (int i = 0; i < tokenNames.length; i++) { + tokenNames[i] = VOCABULARY.getLiteralName(i); + if (tokenNames[i] == null) { + tokenNames[i] = VOCABULARY.getSymbolicName(i); + } + + if (tokenNames[i] == null) { + tokenNames[i] = ""; + } + } + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } + + @Override + + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + + @property + def tokens(self): + try: + return self._tokens + except AttributeError: + self._tokens = [] + return self._tokens + @property + def indents(self): + try: + return self._indents + except AttributeError: + self._indents = [] + return self._indents + @property + def opened(self): + try: + return self._opened + except AttributeError: + self._opened = 0 + return self._opened + @opened.setter + def opened(self, value): + self._opened = value + @property + def lastToken(self): + try: + return self._lastToken + except AttributeError: + self._lastToken = None + return self._lastToken + @lastToken.setter + def lastToken(self, value): + self._lastToken = value + def reset(self): + super().reset() + self.tokens = [] + self.indents = [] + self.opened = 0 + self.lastToken = None + def emitToken(self, t): + super().emitToken(t) + self.tokens.append(t) + def nextToken(self): + if self._input.LA(1) == Token.EOF and self.indents: + for i in range(len(self.tokens)-1,-1,-1): + if self.tokens[i].type == Token.EOF: + self.tokens.pop(i) + self.emitToken(self.commonToken(LanguageParser.NEWLINE, '\n')) + while self.indents: + self.emitToken(self.createDedent()) + self.indents.pop() + self.emitToken(self.commonToken(LanguageParser.EOF, "")) + next = super().nextToken() + if next.channel == Token.DEFAULT_CHANNEL: + self.lastToken = next + return next if not self.tokens else self.tokens.pop(0) + def createDedent(self): + dedent = self.commonToken(LanguageParser.DEDENT, "") + dedent.line = self.lastToken.line + return dedent + def commonToken(self, type, text, indent=0): + stop = self.getCharIndex()-1-indent + start = (stop - len(text) + 1) if text else stop + return CommonToken(self._tokenFactorySourcePair, type, super().DEFAULT_TOKEN_CHANNEL, start, stop) + @staticmethod + def getIndentationCount(spaces): + count = 0 + for ch in spaces: + if ch == '\t': + count += 8 - (count % 8) + else: + count += 1 + return count + def atStartOfInput(self): + return Lexer.column.fget(self) == 0 and Lexer.line.fget(self) == 1 + + + public Python3Lexer(CharStream input) { + super(input); + _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); + } + + @Override + public String getGrammarFileName() { return "Python3.g4"; } + + @Override + public String[] getRuleNames() { return ruleNames; } + + @Override + public String getSerializedATN() { return _serializedATN; } + + @Override + public String[] getChannelNames() { return channelNames; } + + @Override + public String[] getModeNames() { return modeNames; } + + @Override + public ATN getATN() { return _ATN; } + + @Override + public void action(RuleContext _localctx, int ruleIndex, int actionIndex) { + switch (ruleIndex) { + case 38: + NEWLINE_action((RuleContext)_localctx, actionIndex); + break; + case 51: + OPEN_PAREN_action((RuleContext)_localctx, actionIndex); + break; + case 52: + CLOSE_PAREN_action((RuleContext)_localctx, actionIndex); + break; + case 58: + OPEN_BRACK_action((RuleContext)_localctx, actionIndex); + break; + case 59: + CLOSE_BRACK_action((RuleContext)_localctx, actionIndex); + break; + case 71: + OPEN_BRACE_action((RuleContext)_localctx, actionIndex); + break; + case 72: + CLOSE_BRACE_action((RuleContext)_localctx, actionIndex); + break; + } + } + private void NEWLINE_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 0: + + tempt = Lexer.text.fget(self) + newLine = re.sub("[^\r\n\f]+", "", tempt) + spaces = re.sub("[\r\n\f]+", "", tempt) + la_char = "" + try: + la = self._input.LA(1) + la_char = chr(la) # Python does not compare char to ints directly + except ValueError: # End of file + pass + # Strip newlines inside open clauses except if we are near EOF. We keep NEWLINEs near EOF to + # satisfy the final newline needed by the single_put rule used by the REPL. + try: + nextnext_la = self._input.LA(2) + nextnext_la_char = chr(nextnext_la) + except ValueError: + nextnext_eof = True + else: + nextnext_eof = False + if self.opened > 0 or nextnext_eof is False and (la_char == '\r' or la_char == '\n' or la_char == '\f' or la_char == '#'): + self.skip() + else: + indent = self.getIndentationCount(spaces) + previous = self.indents[-1] if self.indents else 0 + self.emitToken(self.commonToken(self.NEWLINE, newLine, indent=indent)) # NEWLINE is actually the '\n' char + if indent == previous: + self.skip() + elif indent > previous: + self.indents.append(indent) + self.emitToken(self.commonToken(LanguageParser.INDENT, spaces)) + else: + while self.indents and self.indents[-1] > indent: + self.emitToken(self.createDedent()) + self.indents.pop() + + break; + } + } + private void OPEN_PAREN_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 1: + self.opened += 1 + break; + } + } + private void CLOSE_PAREN_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 2: + self.opened -= 1 + break; + } + } + private void OPEN_BRACK_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 3: + self.opened += 1 + break; + } + } + private void CLOSE_BRACK_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 4: + self.opened -= 1 + break; + } + } + private void OPEN_BRACE_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 5: + self.opened += 1 + break; + } + } + private void CLOSE_BRACE_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 6: + self.opened -= 1 + break; + } + } + @Override + public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { + switch (ruleIndex) { + case 38: + return NEWLINE_sempred((RuleContext)_localctx, predIndex); + } + return true; + } + private boolean NEWLINE_sempred(RuleContext _localctx, int predIndex) { + switch (predIndex) { + case 0: + return self.atStartOfInput(); + } + return true; + } + + public static final String _serializedATN = + "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2c\u0373\b\1\4\2\t"+ + "\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+ + "\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+ + "\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+ + "\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+ + "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+ + ",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+ + "\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+ + "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+ + "\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+ + "\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+ + "`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t"+ + "k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4"+ + "w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\3\2\3\2\5\2\u00fe\n\2\3\3\3\3"+ + "\3\3\5\3\u0103\n\3\3\4\3\4\3\4\3\4\5\4\u0109\n\4\3\5\3\5\3\5\3\5\3\6\3"+ + "\6\3\6\3\6\3\6\3\6\3\6\3\7\3\7\3\7\3\7\3\7\3\7\3\b\3\b\3\b\3\b\3\b\3\t"+ + "\3\t\3\t\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\13\3\13\3\13\3\13\3\13\3\13\3\13"+ + "\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\16"+ + "\3\16\3\16\3\17\3\17\3\17\3\17\3\17\3\20\3\20\3\20\3\20\3\20\3\21\3\21"+ + "\3\21\3\21\3\21\3\21\3\22\3\22\3\22\3\22\3\23\3\23\3\23\3\24\3\24\3\24"+ + "\3\24\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\26\3\26\3\26\3\26\3\26"+ + "\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\30\3\30\3\30\3\30\3\30\3\30\3\30"+ + "\3\31\3\31\3\31\3\32\3\32\3\32\3\32\3\33\3\33\3\33\3\33\3\34\3\34\3\34"+ + "\3\35\3\35\3\35\3\35\3\35\3\36\3\36\3\36\3\36\3\36\3\37\3\37\3\37\3\37"+ + "\3\37\3\37\3 \3 \3 \3 \3 \3 \3!\3!\3!\3!\3!\3!\3\"\3\"\3\"\3\"\3#\3#\3"+ + "#\3#\3#\3$\3$\3$\3$\3$\3$\3$\3$\3$\3%\3%\3%\3%\3%\3%\3&\3&\3&\3&\3&\3"+ + "&\3\'\3\'\3\'\3\'\3\'\3\'\3(\3(\3(\5(\u01cc\n(\3(\3(\5(\u01d0\n(\3(\5"+ + "(\u01d3\n(\5(\u01d5\n(\3(\3(\3)\3)\7)\u01db\n)\f)\16)\u01de\13)\3*\3*"+ + "\3*\3*\3*\5*\u01e5\n*\3*\3*\5*\u01e9\n*\3+\3+\3+\3+\3+\5+\u01f0\n+\3+"+ + "\3+\5+\u01f4\n+\3,\3,\7,\u01f8\n,\f,\16,\u01fb\13,\3,\6,\u01fe\n,\r,\16"+ + ",\u01ff\5,\u0202\n,\3-\3-\3-\6-\u0207\n-\r-\16-\u0208\3.\3.\3.\6.\u020e"+ + "\n.\r.\16.\u020f\3/\3/\3/\6/\u0215\n/\r/\16/\u0216\3\60\3\60\5\60\u021b"+ + "\n\60\3\61\3\61\5\61\u021f\n\61\3\61\3\61\3\62\3\62\3\63\3\63\3\63\3\63"+ + "\3\64\3\64\3\65\3\65\3\65\3\66\3\66\3\66\3\67\3\67\38\38\39\39\3:\3:\3"+ + ":\3;\3;\3<\3<\3<\3=\3=\3=\3>\3>\3?\3?\3@\3@\3A\3A\3A\3B\3B\3B\3C\3C\3"+ + "D\3D\3E\3E\3F\3F\3G\3G\3G\3H\3H\3I\3I\3I\3J\3J\3J\3K\3K\3L\3L\3M\3M\3"+ + "M\3N\3N\3N\3O\3O\3O\3P\3P\3P\3Q\3Q\3Q\3R\3R\3S\3S\3S\3T\3T\3T\3U\3U\3"+ + "U\3V\3V\3V\3W\3W\3W\3X\3X\3X\3Y\3Y\3Y\3Z\3Z\3Z\3[\3[\3[\3\\\3\\\3\\\3"+ + "]\3]\3]\3]\3^\3^\3^\3^\3_\3_\3_\3_\3`\3`\3`\3`\3a\3a\3a\5a\u02a7\na\3"+ + "a\3a\3b\3b\3c\3c\3c\7c\u02b0\nc\fc\16c\u02b3\13c\3c\3c\3c\3c\7c\u02b9"+ + "\nc\fc\16c\u02bc\13c\3c\5c\u02bf\nc\3d\3d\3d\3d\3d\7d\u02c6\nd\fd\16d"+ + "\u02c9\13d\3d\3d\3d\3d\3d\3d\3d\3d\7d\u02d3\nd\fd\16d\u02d6\13d\3d\3d"+ + "\3d\5d\u02db\nd\3e\3e\5e\u02df\ne\3f\3f\3g\3g\3g\3g\5g\u02e7\ng\3h\3h"+ + "\3i\3i\3j\3j\3k\3k\3l\3l\3m\5m\u02f4\nm\3m\3m\3m\3m\5m\u02fa\nm\3n\3n"+ + "\5n\u02fe\nn\3n\3n\3o\6o\u0303\no\ro\16o\u0304\3p\3p\6p\u0309\np\rp\16"+ + "p\u030a\3q\3q\5q\u030f\nq\3q\6q\u0312\nq\rq\16q\u0313\3r\3r\3r\7r\u0319"+ + "\nr\fr\16r\u031c\13r\3r\3r\3r\3r\7r\u0322\nr\fr\16r\u0325\13r\3r\5r\u0328"+ + "\nr\3s\3s\3s\3s\3s\7s\u032f\ns\fs\16s\u0332\13s\3s\3s\3s\3s\3s\3s\3s\3"+ + "s\7s\u033c\ns\fs\16s\u033f\13s\3s\3s\3s\5s\u0344\ns\3t\3t\5t\u0348\nt"+ + "\3u\5u\u034b\nu\3v\5v\u034e\nv\3w\5w\u0351\nw\3x\3x\3x\3y\6y\u0357\ny"+ + "\ry\16y\u0358\3z\3z\7z\u035d\nz\fz\16z\u0360\13z\3{\3{\5{\u0364\n{\3{"+ + "\5{\u0367\n{\3{\3{\5{\u036b\n{\3|\5|\u036e\n|\3}\3}\5}\u0372\n}\6\u02c7"+ + "\u02d4\u0330\u033d\2~\3\3\5\4\7\5\t\6\13\7\r\b\17\t\21\n\23\13\25\f\27"+ + "\r\31\16\33\17\35\20\37\21!\22#\23%\24\'\25)\26+\27-\30/\31\61\32\63\33"+ + "\65\34\67\359\36;\37= ?!A\"C#E$G%I&K\'M(O)Q*S+U,W-Y.[/]\60_\61a\62c\63"+ + "e\64g\65i\66k\67m8o9q:s;u{?}@\177A\u0081B\u0083C\u0085D\u0087E\u0089"+ + "F\u008bG\u008dH\u008fI\u0091J\u0093K\u0095L\u0097M\u0099N\u009bO\u009d"+ + "P\u009fQ\u00a1R\u00a3S\u00a5T\u00a7U\u00a9V\u00abW\u00adX\u00afY\u00b1"+ + "Z\u00b3[\u00b5\\\u00b7]\u00b9^\u00bb_\u00bd`\u00bfa\u00c1b\u00c3c\u00c5"+ + "\2\u00c7\2\u00c9\2\u00cb\2\u00cd\2\u00cf\2\u00d1\2\u00d3\2\u00d5\2\u00d7"+ + "\2\u00d9\2\u00db\2\u00dd\2\u00df\2\u00e1\2\u00e3\2\u00e5\2\u00e7\2\u00e9"+ + "\2\u00eb\2\u00ed\2\u00ef\2\u00f1\2\u00f3\2\u00f5\2\u00f7\2\u00f9\2\3\2"+ + "\33\b\2HHTTWWhhttww\4\2HHhh\4\2TTtt\4\2DDdd\4\2QQqq\4\2ZZzz\4\2LLll\6"+ + "\2\f\f\16\17))^^\6\2\f\f\16\17$$^^\3\2^^\3\2\63;\3\2\62;\3\2\629\5\2\62"+ + ";CHch\3\2\62\63\4\2GGgg\4\2--//\7\2\2\13\r\16\20(*]_\u0081\7\2\2\13\r"+ + "\16\20#%]_\u0081\4\2\2]_\u0081\3\2\2\u0081\4\2\13\13\"\"\4\2\f\f\16\17"+ + "\u0129\2C\\aac|\u00ac\u00ac\u00b7\u00b7\u00bc\u00bc\u00c2\u00d8\u00da"+ + "\u00f8\u00fa\u0243\u0252\u02c3\u02c8\u02d3\u02e2\u02e6\u02f0\u02f0\u037c"+ + "\u037c\u0388\u0388\u038a\u038c\u038e\u038e\u0390\u03a3\u03a5\u03d0\u03d2"+ + "\u03f7\u03f9\u0483\u048c\u04d0\u04d2\u04fb\u0502\u0511\u0533\u0558\u055b"+ + "\u055b\u0563\u0589\u05d2\u05ec\u05f2\u05f4\u0623\u063c\u0642\u064c\u0670"+ + "\u0671\u0673\u06d5\u06d7\u06d7\u06e7\u06e8\u06f0\u06f1\u06fc\u06fe\u0701"+ + "\u0701\u0712\u0712\u0714\u0731\u074f\u076f\u0782\u07a7\u07b3\u07b3\u0906"+ + "\u093b\u093f\u093f\u0952\u0952\u095a\u0963\u097f\u097f\u0987\u098e\u0991"+ + "\u0992\u0995\u09aa\u09ac\u09b2\u09b4\u09b4\u09b8\u09bb\u09bf\u09bf\u09d0"+ + "\u09d0\u09de\u09df\u09e1\u09e3\u09f2\u09f3\u0a07\u0a0c\u0a11\u0a12\u0a15"+ + "\u0a2a\u0a2c\u0a32\u0a34\u0a35\u0a37\u0a38\u0a3a\u0a3b\u0a5b\u0a5e\u0a60"+ + "\u0a60\u0a74\u0a76\u0a87\u0a8f\u0a91\u0a93\u0a95\u0aaa\u0aac\u0ab2\u0ab4"+ + "\u0ab5\u0ab7\u0abb\u0abf\u0abf\u0ad2\u0ad2\u0ae2\u0ae3\u0b07\u0b0e\u0b11"+ + "\u0b12\u0b15\u0b2a\u0b2c\u0b32\u0b34\u0b35\u0b37\u0b3b\u0b3f\u0b3f\u0b5e"+ + "\u0b5f\u0b61\u0b63\u0b73\u0b73\u0b85\u0b85\u0b87\u0b8c\u0b90\u0b92\u0b94"+ + "\u0b97\u0b9b\u0b9c\u0b9e\u0b9e\u0ba0\u0ba1\u0ba5\u0ba6\u0baa\u0bac\u0bb0"+ + "\u0bbb\u0c07\u0c0e\u0c10\u0c12\u0c14\u0c2a\u0c2c\u0c35\u0c37\u0c3b\u0c62"+ + "\u0c63\u0c87\u0c8e\u0c90\u0c92\u0c94\u0caa\u0cac\u0cb5\u0cb7\u0cbb\u0cbf"+ + "\u0cbf\u0ce0\u0ce0\u0ce2\u0ce3\u0d07\u0d0e\u0d10\u0d12\u0d14\u0d2a\u0d2c"+ + "\u0d3b\u0d62\u0d63\u0d87\u0d98\u0d9c\u0db3\u0db5\u0dbd\u0dbf\u0dbf\u0dc2"+ + "\u0dc8\u0e03\u0e32\u0e34\u0e35\u0e42\u0e48\u0e83\u0e84\u0e86\u0e86\u0e89"+ + "\u0e8a\u0e8c\u0e8c\u0e8f\u0e8f\u0e96\u0e99\u0e9b\u0ea1\u0ea3\u0ea5\u0ea7"+ + "\u0ea7\u0ea9\u0ea9\u0eac\u0ead\u0eaf\u0eb2\u0eb4\u0eb5\u0ebf\u0ebf\u0ec2"+ + "\u0ec6\u0ec8\u0ec8\u0ede\u0edf\u0f02\u0f02\u0f42\u0f49\u0f4b\u0f6c\u0f8a"+ + "\u0f8d\u1002\u1023\u1025\u1029\u102b\u102c\u1052\u1057\u10a2\u10c7\u10d2"+ + "\u10fc\u10fe\u10fe\u1102\u115b\u1161\u11a4\u11aa\u11fb\u1202\u124a\u124c"+ + "\u124f\u1252\u1258\u125a\u125a\u125c\u125f\u1262\u128a\u128c\u128f\u1292"+ + "\u12b2\u12b4\u12b7\u12ba\u12c0\u12c2\u12c2\u12c4\u12c7\u12ca\u12d8\u12da"+ + "\u1312\u1314\u1317\u131a\u135c\u1382\u1391\u13a2\u13f6\u1403\u166e\u1671"+ + "\u1678\u1683\u169c\u16a2\u16ec\u16f0\u16f2\u1702\u170e\u1710\u1713\u1722"+ + "\u1733\u1742\u1753\u1762\u176e\u1770\u1772\u1782\u17b5\u17d9\u17d9\u17de"+ + "\u17de\u1822\u1879\u1882\u18aa\u1902\u191e\u1952\u196f\u1972\u1976\u1982"+ + "\u19ab\u19c3\u19c9\u1a02\u1a18\u1d02\u1dc1\u1e02\u1e9d\u1ea2\u1efb\u1f02"+ + "\u1f17\u1f1a\u1f1f\u1f22\u1f47\u1f4a\u1f4f\u1f52\u1f59\u1f5b\u1f5b\u1f5d"+ + "\u1f5d\u1f5f\u1f5f\u1f61\u1f7f\u1f82\u1fb6\u1fb8\u1fbe\u1fc0\u1fc0\u1fc4"+ + "\u1fc6\u1fc8\u1fce\u1fd2\u1fd5\u1fd8\u1fdd\u1fe2\u1fee\u1ff4\u1ff6\u1ff8"+ + "\u1ffe\u2073\u2073\u2081\u2081\u2092\u2096\u2104\u2104\u2109\u2109\u210c"+ + "\u2115\u2117\u2117\u211a\u211f\u2126\u2126\u2128\u2128\u212a\u212a\u212c"+ + "\u2133\u2135\u213b\u213e\u2141\u2147\u214b\u2162\u2185\u2c02\u2c30\u2c32"+ + "\u2c60\u2c82\u2ce6\u2d02\u2d27\u2d32\u2d67\u2d71\u2d71\u2d82\u2d98\u2da2"+ + "\u2da8\u2daa\u2db0\u2db2\u2db8\u2dba\u2dc0\u2dc2\u2dc8\u2dca\u2dd0\u2dd2"+ + "\u2dd8\u2dda\u2de0\u3007\u3009\u3023\u302b\u3033\u3037\u303a\u303e\u3043"+ + "\u3098\u309d\u30a1\u30a3\u30fc\u30fe\u3101\u3107\u312e\u3133\u3190\u31a2"+ + "\u31b9\u31f2\u3201\u3402\u4db7\u4e02\u9fbd\ua002\ua48e\ua802\ua803\ua805"+ + "\ua807\ua809\ua80c\ua80e\ua824\uac02\ud7a5\uf902\ufa2f\ufa32\ufa6c\ufa72"+ + "\ufadb\ufb02\ufb08\ufb15\ufb19\ufb1f\ufb1f\ufb21\ufb2a\ufb2c\ufb38\ufb3a"+ + "\ufb3e\ufb40\ufb40\ufb42\ufb43\ufb45\ufb46\ufb48\ufbb3\ufbd5\ufd3f\ufd52"+ + "\ufd91\ufd94\ufdc9\ufdf2\ufdfd\ufe72\ufe76\ufe78\ufefe\uff23\uff3c\uff43"+ + "\uff5c\uff68\uffc0\uffc4\uffc9\uffcc\uffd1\uffd4\uffd9\uffdc\uffde\u0096"+ + "\2\62;\u0302\u0371\u0485\u0488\u0593\u05bb\u05bd\u05bf\u05c1\u05c1\u05c3"+ + "\u05c4\u05c6\u05c7\u05c9\u05c9\u0612\u0617\u064d\u0660\u0662\u066b\u0672"+ + "\u0672\u06d8\u06de\u06e1\u06e6\u06e9\u06ea\u06ec\u06ef\u06f2\u06fb\u0713"+ + "\u0713\u0732\u074c\u07a8\u07b2\u0903\u0905\u093e\u093e\u0940\u094f\u0953"+ + "\u0956\u0964\u0965\u0968\u0971\u0983\u0985\u09be\u09be\u09c0\u09c6\u09c9"+ + "\u09ca\u09cd\u09cf\u09d9\u09d9\u09e4\u09e5\u09e8\u09f1\u0a03\u0a05\u0a3e"+ + "\u0a3e\u0a40\u0a44\u0a49\u0a4a\u0a4d\u0a4f\u0a68\u0a73\u0a83\u0a85\u0abe"+ + "\u0abe\u0ac0\u0ac7\u0ac9\u0acb\u0acd\u0acf\u0ae4\u0ae5\u0ae8\u0af1\u0b03"+ + "\u0b05\u0b3e\u0b3e\u0b40\u0b45\u0b49\u0b4a\u0b4d\u0b4f\u0b58\u0b59\u0b68"+ + "\u0b71\u0b84\u0b84\u0bc0\u0bc4\u0bc8\u0bca\u0bcc\u0bcf\u0bd9\u0bd9\u0be8"+ + "\u0bf1\u0c03\u0c05\u0c40\u0c46\u0c48\u0c4a\u0c4c\u0c4f\u0c57\u0c58\u0c68"+ + "\u0c71\u0c84\u0c85\u0cbe\u0cbe\u0cc0\u0cc6\u0cc8\u0cca\u0ccc\u0ccf\u0cd7"+ + "\u0cd8\u0ce8\u0cf1\u0d04\u0d05\u0d40\u0d45\u0d48\u0d4a\u0d4c\u0d4f\u0d59"+ + "\u0d59\u0d68\u0d71\u0d84\u0d85\u0dcc\u0dcc\u0dd1\u0dd6\u0dd8\u0dd8\u0dda"+ + "\u0de1\u0df4\u0df5\u0e33\u0e33\u0e36\u0e3c\u0e49\u0e50\u0e52\u0e5b\u0eb3"+ + "\u0eb3\u0eb6\u0ebb\u0ebd\u0ebe\u0eca\u0ecf\u0ed2\u0edb\u0f1a\u0f1b\u0f22"+ + "\u0f2b\u0f37\u0f37\u0f39\u0f39\u0f3b\u0f3b\u0f40\u0f41\u0f73\u0f86\u0f88"+ + "\u0f89\u0f92\u0f99\u0f9b\u0fbe\u0fc8\u0fc8\u102e\u1034\u1038\u103b\u1042"+ + "\u104b\u1058\u105b\u1361\u1361\u136b\u1373\u1714\u1716\u1734\u1736\u1754"+ + "\u1755\u1774\u1775\u17b8\u17d5\u17df\u17df\u17e2\u17eb\u180d\u180f\u1812"+ + "\u181b\u18ab\u18ab\u1922\u192d\u1932\u193d\u1948\u1951\u19b2\u19c2\u19ca"+ + "\u19cb\u19d2\u19db\u1a19\u1a1d\u1dc2\u1dc5\u2041\u2042\u2056\u2056\u20d2"+ + "\u20de\u20e3\u20e3\u20e7\u20ed\u302c\u3031\u309b\u309c\ua804\ua804\ua808"+ + "\ua808\ua80d\ua80d\ua825\ua829\ufb20\ufb20\ufe02\ufe11\ufe22\ufe25\ufe35"+ + "\ufe36\ufe4f\ufe51\uff12\uff1b\uff41\uff41\2\u0393\2\3\3\2\2\2\2\5\3\2"+ + "\2\2\2\7\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21"+ + "\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2"+ + "\2\2\2\35\3\2\2\2\2\37\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2\2\'\3"+ + "\2\2\2\2)\3\2\2\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2\2\2\2\63\3"+ + "\2\2\2\2\65\3\2\2\2\2\67\3\2\2\2\29\3\2\2\2\2;\3\2\2\2\2=\3\2\2\2\2?\3"+ + "\2\2\2\2A\3\2\2\2\2C\3\2\2\2\2E\3\2\2\2\2G\3\2\2\2\2I\3\2\2\2\2K\3\2\2"+ + "\2\2M\3\2\2\2\2O\3\2\2\2\2Q\3\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2W\3\2\2\2\2"+ + "Y\3\2\2\2\2[\3\2\2\2\2]\3\2\2\2\2_\3\2\2\2\2a\3\2\2\2\2c\3\2\2\2\2e\3"+ + "\2\2\2\2g\3\2\2\2\2i\3\2\2\2\2k\3\2\2\2\2m\3\2\2\2\2o\3\2\2\2\2q\3\2\2"+ + "\2\2s\3\2\2\2\2u\3\2\2\2\2w\3\2\2\2\2y\3\2\2\2\2{\3\2\2\2\2}\3\2\2\2\2"+ + "\177\3\2\2\2\2\u0081\3\2\2\2\2\u0083\3\2\2\2\2\u0085\3\2\2\2\2\u0087\3"+ + "\2\2\2\2\u0089\3\2\2\2\2\u008b\3\2\2\2\2\u008d\3\2\2\2\2\u008f\3\2\2\2"+ + "\2\u0091\3\2\2\2\2\u0093\3\2\2\2\2\u0095\3\2\2\2\2\u0097\3\2\2\2\2\u0099"+ + "\3\2\2\2\2\u009b\3\2\2\2\2\u009d\3\2\2\2\2\u009f\3\2\2\2\2\u00a1\3\2\2"+ + "\2\2\u00a3\3\2\2\2\2\u00a5\3\2\2\2\2\u00a7\3\2\2\2\2\u00a9\3\2\2\2\2\u00ab"+ + "\3\2\2\2\2\u00ad\3\2\2\2\2\u00af\3\2\2\2\2\u00b1\3\2\2\2\2\u00b3\3\2\2"+ + "\2\2\u00b5\3\2\2\2\2\u00b7\3\2\2\2\2\u00b9\3\2\2\2\2\u00bb\3\2\2\2\2\u00bd"+ + "\3\2\2\2\2\u00bf\3\2\2\2\2\u00c1\3\2\2\2\2\u00c3\3\2\2\2\3\u00fd\3\2\2"+ + "\2\5\u0102\3\2\2\2\7\u0108\3\2\2\2\t\u010a\3\2\2\2\13\u010e\3\2\2\2\r"+ + "\u0115\3\2\2\2\17\u011b\3\2\2\2\21\u0120\3\2\2\2\23\u0127\3\2\2\2\25\u012a"+ + "\3\2\2\2\27\u0131\3\2\2\2\31\u013a\3\2\2\2\33\u0141\3\2\2\2\35\u0144\3"+ + "\2\2\2\37\u0149\3\2\2\2!\u014e\3\2\2\2#\u0154\3\2\2\2%\u0158\3\2\2\2\'"+ + "\u015b\3\2\2\2)\u015f\3\2\2\2+\u0167\3\2\2\2-\u016c\3\2\2\2/\u0173\3\2"+ + "\2\2\61\u017a\3\2\2\2\63\u017d\3\2\2\2\65\u0181\3\2\2\2\67\u0185\3\2\2"+ + "\29\u0188\3\2\2\2;\u018d\3\2\2\2=\u0192\3\2\2\2?\u0198\3\2\2\2A\u019e"+ + "\3\2\2\2C\u01a4\3\2\2\2E\u01a8\3\2\2\2G\u01ad\3\2\2\2I\u01b6\3\2\2\2K"+ + "\u01bc\3\2\2\2M\u01c2\3\2\2\2O\u01d4\3\2\2\2Q\u01d8\3\2\2\2S\u01e4\3\2"+ + "\2\2U\u01ef\3\2\2\2W\u0201\3\2\2\2Y\u0203\3\2\2\2[\u020a\3\2\2\2]\u0211"+ + "\3\2\2\2_\u021a\3\2\2\2a\u021e\3\2\2\2c\u0222\3\2\2\2e\u0224\3\2\2\2g"+ + "\u0228\3\2\2\2i\u022a\3\2\2\2k\u022d\3\2\2\2m\u0230\3\2\2\2o\u0232\3\2"+ + "\2\2q\u0234\3\2\2\2s\u0236\3\2\2\2u\u0239\3\2\2\2w\u023b\3\2\2\2y\u023e"+ + "\3\2\2\2{\u0241\3\2\2\2}\u0243\3\2\2\2\177\u0245\3\2\2\2\u0081\u0247\3"+ + "\2\2\2\u0083\u024a\3\2\2\2\u0085\u024d\3\2\2\2\u0087\u024f\3\2\2\2\u0089"+ + "\u0251\3\2\2\2\u008b\u0253\3\2\2\2\u008d\u0255\3\2\2\2\u008f\u0258\3\2"+ + "\2\2\u0091\u025a\3\2\2\2\u0093\u025d\3\2\2\2\u0095\u0260\3\2\2\2\u0097"+ + "\u0262\3\2\2\2\u0099\u0264\3\2\2\2\u009b\u0267\3\2\2\2\u009d\u026a\3\2"+ + "\2\2\u009f\u026d\3\2\2\2\u00a1\u0270\3\2\2\2\u00a3\u0273\3\2\2\2\u00a5"+ + "\u0275\3\2\2\2\u00a7\u0278\3\2\2\2\u00a9\u027b\3\2\2\2\u00ab\u027e\3\2"+ + "\2\2\u00ad\u0281\3\2\2\2\u00af\u0284\3\2\2\2\u00b1\u0287\3\2\2\2\u00b3"+ + "\u028a\3\2\2\2\u00b5\u028d\3\2\2\2\u00b7\u0290\3\2\2\2\u00b9\u0293\3\2"+ + "\2\2\u00bb\u0297\3\2\2\2\u00bd\u029b\3\2\2\2\u00bf\u029f\3\2\2\2\u00c1"+ + "\u02a6\3\2\2\2\u00c3\u02aa\3\2\2\2\u00c5\u02be\3\2\2\2\u00c7\u02da\3\2"+ + "\2\2\u00c9\u02de\3\2\2\2\u00cb\u02e0\3\2\2\2\u00cd\u02e6\3\2\2\2\u00cf"+ + "\u02e8\3\2\2\2\u00d1\u02ea\3\2\2\2\u00d3\u02ec\3\2\2\2\u00d5\u02ee\3\2"+ + "\2\2\u00d7\u02f0\3\2\2\2\u00d9\u02f9\3\2\2\2\u00db\u02fd\3\2\2\2\u00dd"+ + "\u0302\3\2\2\2\u00df\u0306\3\2\2\2\u00e1\u030c\3\2\2\2\u00e3\u0327\3\2"+ + "\2\2\u00e5\u0343\3\2\2\2\u00e7\u0347\3\2\2\2\u00e9\u034a\3\2\2\2\u00eb"+ + "\u034d\3\2\2\2\u00ed\u0350\3\2\2\2\u00ef\u0352\3\2\2\2\u00f1\u0356\3\2"+ + "\2\2\u00f3\u035a\3\2\2\2\u00f5\u0361\3\2\2\2\u00f7\u036d\3\2\2\2\u00f9"+ + "\u0371\3\2\2\2\u00fb\u00fe\5S*\2\u00fc\u00fe\5U+\2\u00fd\u00fb\3\2\2\2"+ + "\u00fd\u00fc\3\2\2\2\u00fe\4\3\2\2\2\u00ff\u0103\5\7\4\2\u0100\u0103\5"+ + "_\60\2\u0101\u0103\5a\61\2\u0102\u00ff\3\2\2\2\u0102\u0100\3\2\2\2\u0102"+ + "\u0101\3\2\2\2\u0103\6\3\2\2\2\u0104\u0109\5W,\2\u0105\u0109\5Y-\2\u0106"+ + "\u0109\5[.\2\u0107\u0109\5]/\2\u0108\u0104\3\2\2\2\u0108\u0105\3\2\2\2"+ + "\u0108\u0106\3\2\2\2\u0108\u0107\3\2\2\2\u0109\b\3\2\2\2\u010a\u010b\7"+ + "f\2\2\u010b\u010c\7g\2\2\u010c\u010d\7h\2\2\u010d\n\3\2\2\2\u010e\u010f"+ + "\7t\2\2\u010f\u0110\7g\2\2\u0110\u0111\7v\2\2\u0111\u0112\7w\2\2\u0112"+ + "\u0113\7t\2\2\u0113\u0114\7p\2\2\u0114\f\3\2\2\2\u0115\u0116\7t\2\2\u0116"+ + "\u0117\7c\2\2\u0117\u0118\7k\2\2\u0118\u0119\7u\2\2\u0119\u011a\7g\2\2"+ + "\u011a\16\3\2\2\2\u011b\u011c\7h\2\2\u011c\u011d\7t\2\2\u011d\u011e\7"+ + "q\2\2\u011e\u011f\7o\2\2\u011f\20\3\2\2\2\u0120\u0121\7k\2\2\u0121\u0122"+ + "\7o\2\2\u0122\u0123\7r\2\2\u0123\u0124\7q\2\2\u0124\u0125\7t\2\2\u0125"+ + "\u0126\7v\2\2\u0126\22\3\2\2\2\u0127\u0128\7c\2\2\u0128\u0129\7u\2\2\u0129"+ + "\24\3\2\2\2\u012a\u012b\7i\2\2\u012b\u012c\7n\2\2\u012c\u012d\7q\2\2\u012d"+ + "\u012e\7d\2\2\u012e\u012f\7c\2\2\u012f\u0130\7n\2\2\u0130\26\3\2\2\2\u0131"+ + "\u0132\7p\2\2\u0132\u0133\7q\2\2\u0133\u0134\7p\2\2\u0134\u0135\7n\2\2"+ + "\u0135\u0136\7q\2\2\u0136\u0137\7e\2\2\u0137\u0138\7c\2\2\u0138\u0139"+ + "\7n\2\2\u0139\30\3\2\2\2\u013a\u013b\7c\2\2\u013b\u013c\7u\2\2\u013c\u013d"+ + "\7u\2\2\u013d\u013e\7g\2\2\u013e\u013f\7t\2\2\u013f\u0140\7v\2\2\u0140"+ + "\32\3\2\2\2\u0141\u0142\7k\2\2\u0142\u0143\7h\2\2\u0143\34\3\2\2\2\u0144"+ + "\u0145\7g\2\2\u0145\u0146\7n\2\2\u0146\u0147\7k\2\2\u0147\u0148\7h\2\2"+ + "\u0148\36\3\2\2\2\u0149\u014a\7g\2\2\u014a\u014b\7n\2\2\u014b\u014c\7"+ + "u\2\2\u014c\u014d\7g\2\2\u014d \3\2\2\2\u014e\u014f\7y\2\2\u014f\u0150"+ + "\7j\2\2\u0150\u0151\7k\2\2\u0151\u0152\7n\2\2\u0152\u0153\7g\2\2\u0153"+ + "\"\3\2\2\2\u0154\u0155\7h\2\2\u0155\u0156\7q\2\2\u0156\u0157\7t\2\2\u0157"+ + "$\3\2\2\2\u0158\u0159\7k\2\2\u0159\u015a\7p\2\2\u015a&\3\2\2\2\u015b\u015c"+ + "\7v\2\2\u015c\u015d\7t\2\2\u015d\u015e\7{\2\2\u015e(\3\2\2\2\u015f\u0160"+ + "\7h\2\2\u0160\u0161\7k\2\2\u0161\u0162\7p\2\2\u0162\u0163\7c\2\2\u0163"+ + "\u0164\7n\2\2\u0164\u0165\7n\2\2\u0165\u0166\7{\2\2\u0166*\3\2\2\2\u0167"+ + "\u0168\7y\2\2\u0168\u0169\7k\2\2\u0169\u016a\7v\2\2\u016a\u016b\7j\2\2"+ + "\u016b,\3\2\2\2\u016c\u016d\7g\2\2\u016d\u016e\7z\2\2\u016e\u016f\7e\2"+ + "\2\u016f\u0170\7g\2\2\u0170\u0171\7r\2\2\u0171\u0172\7v\2\2\u0172.\3\2"+ + "\2\2\u0173\u0174\7n\2\2\u0174\u0175\7c\2\2\u0175\u0176\7o\2\2\u0176\u0177"+ + "\7d\2\2\u0177\u0178\7f\2\2\u0178\u0179\7c\2\2\u0179\60\3\2\2\2\u017a\u017b"+ + "\7q\2\2\u017b\u017c\7t\2\2\u017c\62\3\2\2\2\u017d\u017e\7c\2\2\u017e\u017f"+ + "\7p\2\2\u017f\u0180\7f\2\2\u0180\64\3\2\2\2\u0181\u0182\7p\2\2\u0182\u0183"+ + "\7q\2\2\u0183\u0184\7v\2\2\u0184\66\3\2\2\2\u0185\u0186\7k\2\2\u0186\u0187"+ + "\7u\2\2\u01878\3\2\2\2\u0188\u0189\7P\2\2\u0189\u018a\7q\2\2\u018a\u018b"+ + "\7p\2\2\u018b\u018c\7g\2\2\u018c:\3\2\2\2\u018d\u018e\7V\2\2\u018e\u018f"+ + "\7t\2\2\u018f\u0190\7w\2\2\u0190\u0191\7g\2\2\u0191<\3\2\2\2\u0192\u0193"+ + "\7H\2\2\u0193\u0194\7c\2\2\u0194\u0195\7n\2\2\u0195\u0196\7u\2\2\u0196"+ + "\u0197\7g\2\2\u0197>\3\2\2\2\u0198\u0199\7e\2\2\u0199\u019a\7n\2\2\u019a"+ + "\u019b\7c\2\2\u019b\u019c\7u\2\2\u019c\u019d\7u\2\2\u019d@\3\2\2\2\u019e"+ + "\u019f\7{\2\2\u019f\u01a0\7k\2\2\u01a0\u01a1\7g\2\2\u01a1\u01a2\7n\2\2"+ + "\u01a2\u01a3\7f\2\2\u01a3B\3\2\2\2\u01a4\u01a5\7f\2\2\u01a5\u01a6\7g\2"+ + "\2\u01a6\u01a7\7n\2\2\u01a7D\3\2\2\2\u01a8\u01a9\7r\2\2\u01a9\u01aa\7"+ + "c\2\2\u01aa\u01ab\7u\2\2\u01ab\u01ac\7u\2\2\u01acF\3\2\2\2\u01ad\u01ae"+ + "\7e\2\2\u01ae\u01af\7q\2\2\u01af\u01b0\7p\2\2\u01b0\u01b1\7v\2\2\u01b1"+ + "\u01b2\7k\2\2\u01b2\u01b3\7p\2\2\u01b3\u01b4\7w\2\2\u01b4\u01b5\7g\2\2"+ + "\u01b5H\3\2\2\2\u01b6\u01b7\7d\2\2\u01b7\u01b8\7t\2\2\u01b8\u01b9\7g\2"+ + "\2\u01b9\u01ba\7c\2\2\u01ba\u01bb\7m\2\2\u01bbJ\3\2\2\2\u01bc\u01bd\7"+ + "c\2\2\u01bd\u01be\7u\2\2\u01be\u01bf\7{\2\2\u01bf\u01c0\7p\2\2\u01c0\u01c1"+ + "\7e\2\2\u01c1L\3\2\2\2\u01c2\u01c3\7c\2\2\u01c3\u01c4\7y\2\2\u01c4\u01c5"+ + "\7c\2\2\u01c5\u01c6\7k\2\2\u01c6\u01c7\7v\2\2\u01c7N\3\2\2\2\u01c8\u01c9"+ + "\6(\2\2\u01c9\u01d5\5\u00f1y\2\u01ca\u01cc\7\17\2\2\u01cb\u01ca\3\2\2"+ + "\2\u01cb\u01cc\3\2\2\2\u01cc\u01cd\3\2\2\2\u01cd\u01d0\7\f\2\2\u01ce\u01d0"+ + "\4\16\17\2\u01cf\u01cb\3\2\2\2\u01cf\u01ce\3\2\2\2\u01d0\u01d2\3\2\2\2"+ + "\u01d1\u01d3\5\u00f1y\2\u01d2\u01d1\3\2\2\2\u01d2\u01d3\3\2\2\2\u01d3"+ + "\u01d5\3\2\2\2\u01d4\u01c8\3\2\2\2\u01d4\u01cf\3\2\2\2\u01d5\u01d6\3\2"+ + "\2\2\u01d6\u01d7\b(\2\2\u01d7P\3\2\2\2\u01d8\u01dc\5\u00f7|\2\u01d9\u01db"+ + "\5\u00f9}\2\u01da\u01d9\3\2\2\2\u01db\u01de\3\2\2\2\u01dc\u01da\3\2\2"+ + "\2\u01dc\u01dd\3\2\2\2\u01ddR\3\2\2\2\u01de\u01dc\3\2\2\2\u01df\u01e5"+ + "\t\2\2\2\u01e0\u01e1\t\3\2\2\u01e1\u01e5\t\4\2\2\u01e2\u01e3\t\4\2\2\u01e3"+ + "\u01e5\t\3\2\2\u01e4\u01df\3\2\2\2\u01e4\u01e0\3\2\2\2\u01e4\u01e2\3\2"+ + "\2\2\u01e4\u01e5\3\2\2\2\u01e5\u01e8\3\2\2\2\u01e6\u01e9\5\u00c5c\2\u01e7"+ + "\u01e9\5\u00c7d\2\u01e8\u01e6\3\2\2\2\u01e8\u01e7\3\2\2\2\u01e9T\3\2\2"+ + "\2\u01ea\u01f0\t\5\2\2\u01eb\u01ec\t\5\2\2\u01ec\u01f0\t\4\2\2\u01ed\u01ee"+ + "\t\4\2\2\u01ee\u01f0\t\5\2\2\u01ef\u01ea\3\2\2\2\u01ef\u01eb\3\2\2\2\u01ef"+ + "\u01ed\3\2\2\2\u01f0\u01f3\3\2\2\2\u01f1\u01f4\5\u00e3r\2\u01f2\u01f4"+ + "\5\u00e5s\2\u01f3\u01f1\3\2\2\2\u01f3\u01f2\3\2\2\2\u01f4V\3\2\2\2\u01f5"+ + "\u01f9\5\u00cfh\2\u01f6\u01f8\5\u00d1i\2\u01f7\u01f6\3\2\2\2\u01f8\u01fb"+ + "\3\2\2\2\u01f9\u01f7\3\2\2\2\u01f9\u01fa\3\2\2\2\u01fa\u0202\3\2\2\2\u01fb"+ + "\u01f9\3\2\2\2\u01fc\u01fe\7\62\2\2\u01fd\u01fc\3\2\2\2\u01fe\u01ff\3"+ + "\2\2\2\u01ff\u01fd\3\2\2\2\u01ff\u0200\3\2\2\2\u0200\u0202\3\2\2\2\u0201"+ + "\u01f5\3\2\2\2\u0201\u01fd\3\2\2\2\u0202X\3\2\2\2\u0203\u0204\7\62\2\2"+ + "\u0204\u0206\t\6\2\2\u0205\u0207\5\u00d3j\2\u0206\u0205\3\2\2\2\u0207"+ + "\u0208\3\2\2\2\u0208\u0206\3\2\2\2\u0208\u0209\3\2\2\2\u0209Z\3\2\2\2"+ + "\u020a\u020b\7\62\2\2\u020b\u020d\t\7\2\2\u020c\u020e\5\u00d5k\2\u020d"+ + "\u020c\3\2\2\2\u020e\u020f\3\2\2\2\u020f\u020d\3\2\2\2\u020f\u0210\3\2"+ + "\2\2\u0210\\\3\2\2\2\u0211\u0212\7\62\2\2\u0212\u0214\t\5\2\2\u0213\u0215"+ + "\5\u00d7l\2\u0214\u0213\3\2\2\2\u0215\u0216\3\2\2\2\u0216\u0214\3\2\2"+ + "\2\u0216\u0217\3\2\2\2\u0217^\3\2\2\2\u0218\u021b\5\u00d9m\2\u0219\u021b"+ + "\5\u00dbn\2\u021a\u0218\3\2\2\2\u021a\u0219\3\2\2\2\u021b`\3\2\2\2\u021c"+ + "\u021f\5_\60\2\u021d\u021f\5\u00ddo\2\u021e\u021c\3\2\2\2\u021e\u021d"+ + "\3\2\2\2\u021f\u0220\3\2\2\2\u0220\u0221\t\b\2\2\u0221b\3\2\2\2\u0222"+ + "\u0223\7\60\2\2\u0223d\3\2\2\2\u0224\u0225\7\60\2\2\u0225\u0226\7\60\2"+ + "\2\u0226\u0227\7\60\2\2\u0227f\3\2\2\2\u0228\u0229\7,\2\2\u0229h\3\2\2"+ + "\2\u022a\u022b\7*\2\2\u022b\u022c\b\65\3\2\u022cj\3\2\2\2\u022d\u022e"+ + "\7+\2\2\u022e\u022f\b\66\4\2\u022fl\3\2\2\2\u0230\u0231\7.\2\2\u0231n"+ + "\3\2\2\2\u0232\u0233\7<\2\2\u0233p\3\2\2\2\u0234\u0235\7=\2\2\u0235r\3"+ + "\2\2\2\u0236\u0237\7,\2\2\u0237\u0238\7,\2\2\u0238t\3\2\2\2\u0239\u023a"+ + "\7?\2\2\u023av\3\2\2\2\u023b\u023c\7]\2\2\u023c\u023d\b<\5\2\u023dx\3"+ + "\2\2\2\u023e\u023f\7_\2\2\u023f\u0240\b=\6\2\u0240z\3\2\2\2\u0241\u0242"+ + "\7~\2\2\u0242|\3\2\2\2\u0243\u0244\7`\2\2\u0244~\3\2\2\2\u0245\u0246\7"+ + "(\2\2\u0246\u0080\3\2\2\2\u0247\u0248\7>\2\2\u0248\u0249\7>\2\2\u0249"+ + "\u0082\3\2\2\2\u024a\u024b\7@\2\2\u024b\u024c\7@\2\2\u024c\u0084\3\2\2"+ + "\2\u024d\u024e\7-\2\2\u024e\u0086\3\2\2\2\u024f\u0250\7/\2\2\u0250\u0088"+ + "\3\2\2\2\u0251\u0252\7\61\2\2\u0252\u008a\3\2\2\2\u0253\u0254\7\'\2\2"+ + "\u0254\u008c\3\2\2\2\u0255\u0256\7\61\2\2\u0256\u0257\7\61\2\2\u0257\u008e"+ + "\3\2\2\2\u0258\u0259\7\u0080\2\2\u0259\u0090\3\2\2\2\u025a\u025b\7}\2"+ + "\2\u025b\u025c\bI\7\2\u025c\u0092\3\2\2\2\u025d\u025e\7\177\2\2\u025e"+ + "\u025f\bJ\b\2\u025f\u0094\3\2\2\2\u0260\u0261\7>\2\2\u0261\u0096\3\2\2"+ + "\2\u0262\u0263\7@\2\2\u0263\u0098\3\2\2\2\u0264\u0265\7?\2\2\u0265\u0266"+ + "\7?\2\2\u0266\u009a\3\2\2\2\u0267\u0268\7@\2\2\u0268\u0269\7?\2\2\u0269"+ + "\u009c\3\2\2\2\u026a\u026b\7>\2\2\u026b\u026c\7?\2\2\u026c\u009e\3\2\2"+ + "\2\u026d\u026e\7>\2\2\u026e\u026f\7@\2\2\u026f\u00a0\3\2\2\2\u0270\u0271"+ + "\7#\2\2\u0271\u0272\7?\2\2\u0272\u00a2\3\2\2\2\u0273\u0274\7B\2\2\u0274"+ + "\u00a4\3\2\2\2\u0275\u0276\7/\2\2\u0276\u0277\7@\2\2\u0277\u00a6\3\2\2"+ + "\2\u0278\u0279\7-\2\2\u0279\u027a\7?\2\2\u027a\u00a8\3\2\2\2\u027b\u027c"+ + "\7/\2\2\u027c\u027d\7?\2\2\u027d\u00aa\3\2\2\2\u027e\u027f\7,\2\2\u027f"+ + "\u0280\7?\2\2\u0280\u00ac\3\2\2\2\u0281\u0282\7B\2\2\u0282\u0283\7?\2"+ + "\2\u0283\u00ae\3\2\2\2\u0284\u0285\7\61\2\2\u0285\u0286\7?\2\2\u0286\u00b0"+ + "\3\2\2\2\u0287\u0288\7\'\2\2\u0288\u0289\7?\2\2\u0289\u00b2\3\2\2\2\u028a"+ + "\u028b\7(\2\2\u028b\u028c\7?\2\2\u028c\u00b4\3\2\2\2\u028d\u028e\7~\2"+ + "\2\u028e\u028f\7?\2\2\u028f\u00b6\3\2\2\2\u0290\u0291\7`\2\2\u0291\u0292"+ + "\7?\2\2\u0292\u00b8\3\2\2\2\u0293\u0294\7>\2\2\u0294\u0295\7>\2\2\u0295"+ + "\u0296\7?\2\2\u0296\u00ba\3\2\2\2\u0297\u0298\7@\2\2\u0298\u0299\7@\2"+ + "\2\u0299\u029a\7?\2\2\u029a\u00bc\3\2\2\2\u029b\u029c\7,\2\2\u029c\u029d"+ + "\7,\2\2\u029d\u029e\7?\2\2\u029e\u00be\3\2\2\2\u029f\u02a0\7\61\2\2\u02a0"+ + "\u02a1\7\61\2\2\u02a1\u02a2\7?\2\2\u02a2\u00c0\3\2\2\2\u02a3\u02a7\5\u00f1"+ + "y\2\u02a4\u02a7\5\u00f3z\2\u02a5\u02a7\5\u00f5{\2\u02a6\u02a3\3\2\2\2"+ + "\u02a6\u02a4\3\2\2\2\u02a6\u02a5\3\2\2\2\u02a7\u02a8\3\2\2\2\u02a8\u02a9"+ + "\ba\t\2\u02a9\u00c2\3\2\2\2\u02aa\u02ab\13\2\2\2\u02ab\u00c4\3\2\2\2\u02ac"+ + "\u02b1\7)\2\2\u02ad\u02b0\5\u00cdg\2\u02ae\u02b0\n\t\2\2\u02af\u02ad\3"+ + "\2\2\2\u02af\u02ae\3\2\2\2\u02b0\u02b3\3\2\2\2\u02b1\u02af\3\2\2\2\u02b1"+ + "\u02b2\3\2\2\2\u02b2\u02b4\3\2\2\2\u02b3\u02b1\3\2\2\2\u02b4\u02bf\7)"+ + "\2\2\u02b5\u02ba\7$\2\2\u02b6\u02b9\5\u00cdg\2\u02b7\u02b9\n\n\2\2\u02b8"+ + "\u02b6\3\2\2\2\u02b8\u02b7\3\2\2\2\u02b9\u02bc\3\2\2\2\u02ba\u02b8\3\2"+ + "\2\2\u02ba\u02bb\3\2\2\2\u02bb\u02bd\3\2\2\2\u02bc\u02ba\3\2\2\2\u02bd"+ + "\u02bf\7$\2\2\u02be\u02ac\3\2\2\2\u02be\u02b5\3\2\2\2\u02bf\u00c6\3\2"+ + "\2\2\u02c0\u02c1\7)\2\2\u02c1\u02c2\7)\2\2\u02c2\u02c3\7)\2\2\u02c3\u02c7"+ + "\3\2\2\2\u02c4\u02c6\5\u00c9e\2\u02c5\u02c4\3\2\2\2\u02c6\u02c9\3\2\2"+ + "\2\u02c7\u02c8\3\2\2\2\u02c7\u02c5\3\2\2\2\u02c8\u02ca\3\2\2\2\u02c9\u02c7"+ + "\3\2\2\2\u02ca\u02cb\7)\2\2\u02cb\u02cc\7)\2\2\u02cc\u02db\7)\2\2\u02cd"+ + "\u02ce\7$\2\2\u02ce\u02cf\7$\2\2\u02cf\u02d0\7$\2\2\u02d0\u02d4\3\2\2"+ + "\2\u02d1\u02d3\5\u00c9e\2\u02d2\u02d1\3\2\2\2\u02d3\u02d6\3\2\2\2\u02d4"+ + "\u02d5\3\2\2\2\u02d4\u02d2\3\2\2\2\u02d5\u02d7\3\2\2\2\u02d6\u02d4\3\2"+ + "\2\2\u02d7\u02d8\7$\2\2\u02d8\u02d9\7$\2\2\u02d9\u02db\7$\2\2\u02da\u02c0"+ + "\3\2\2\2\u02da\u02cd\3\2\2\2\u02db\u00c8\3\2\2\2\u02dc\u02df\5\u00cbf"+ + "\2\u02dd\u02df\5\u00cdg\2\u02de\u02dc\3\2\2\2\u02de\u02dd\3\2\2\2\u02df"+ + "\u00ca\3\2\2\2\u02e0\u02e1\n\13\2\2\u02e1\u00cc\3\2\2\2\u02e2\u02e3\7"+ + "^\2\2\u02e3\u02e7\13\2\2\2\u02e4\u02e5\7^\2\2\u02e5\u02e7\5O(\2\u02e6"+ + "\u02e2\3\2\2\2\u02e6\u02e4\3\2\2\2\u02e7\u00ce\3\2\2\2\u02e8\u02e9\t\f"+ + "\2\2\u02e9\u00d0\3\2\2\2\u02ea\u02eb\t\r\2\2\u02eb\u00d2\3\2\2\2\u02ec"+ + "\u02ed\t\16\2\2\u02ed\u00d4\3\2\2\2\u02ee\u02ef\t\17\2\2\u02ef\u00d6\3"+ + "\2\2\2\u02f0\u02f1\t\20\2\2\u02f1\u00d8\3\2\2\2\u02f2\u02f4\5\u00ddo\2"+ + "\u02f3\u02f2\3\2\2\2\u02f3\u02f4\3\2\2\2\u02f4\u02f5\3\2\2\2\u02f5\u02fa"+ + "\5\u00dfp\2\u02f6\u02f7\5\u00ddo\2\u02f7\u02f8\7\60\2\2\u02f8\u02fa\3"+ + "\2\2\2\u02f9\u02f3\3\2\2\2\u02f9\u02f6\3\2\2\2\u02fa\u00da\3\2\2\2\u02fb"+ + "\u02fe\5\u00ddo\2\u02fc\u02fe\5\u00d9m\2\u02fd\u02fb\3\2\2\2\u02fd\u02fc"+ + "\3\2\2\2\u02fe\u02ff\3\2\2\2\u02ff\u0300\5\u00e1q\2\u0300\u00dc\3\2\2"+ + "\2\u0301\u0303\5\u00d1i\2\u0302\u0301\3\2\2\2\u0303\u0304\3\2\2\2\u0304"+ + "\u0302\3\2\2\2\u0304\u0305\3\2\2\2\u0305\u00de\3\2\2\2\u0306\u0308\7\60"+ + "\2\2\u0307\u0309\5\u00d1i\2\u0308\u0307\3\2\2\2\u0309\u030a\3\2\2\2\u030a"+ + "\u0308\3\2\2\2\u030a\u030b\3\2\2\2\u030b\u00e0\3\2\2\2\u030c\u030e\t\21"+ + "\2\2\u030d\u030f\t\22\2\2\u030e\u030d\3\2\2\2\u030e\u030f\3\2\2\2\u030f"+ + "\u0311\3\2\2\2\u0310\u0312\5\u00d1i\2\u0311\u0310\3\2\2\2\u0312\u0313"+ + "\3\2\2\2\u0313\u0311\3\2\2\2\u0313\u0314\3\2\2\2\u0314\u00e2\3\2\2\2\u0315"+ + "\u031a\7)\2\2\u0316\u0319\5\u00e9u\2\u0317\u0319\5\u00efx\2\u0318\u0316"+ + "\3\2\2\2\u0318\u0317\3\2\2\2\u0319\u031c\3\2\2\2\u031a\u0318\3\2\2\2\u031a"+ + "\u031b\3\2\2\2\u031b\u031d\3\2\2\2\u031c\u031a\3\2\2\2\u031d\u0328\7)"+ + "\2\2\u031e\u0323\7$\2\2\u031f\u0322\5\u00ebv\2\u0320\u0322\5\u00efx\2"+ + "\u0321\u031f\3\2\2\2\u0321\u0320\3\2\2\2\u0322\u0325\3\2\2\2\u0323\u0321"+ + "\3\2\2\2\u0323\u0324\3\2\2\2\u0324\u0326\3\2\2\2\u0325\u0323\3\2\2\2\u0326"+ + "\u0328\7$\2\2\u0327\u0315\3\2\2\2\u0327\u031e\3\2\2\2\u0328\u00e4\3\2"+ + "\2\2\u0329\u032a\7)\2\2\u032a\u032b\7)\2\2\u032b\u032c\7)\2\2\u032c\u0330"+ + "\3\2\2\2\u032d\u032f\5\u00e7t\2\u032e\u032d\3\2\2\2\u032f\u0332\3\2\2"+ + "\2\u0330\u0331\3\2\2\2\u0330\u032e\3\2\2\2\u0331\u0333\3\2\2\2\u0332\u0330"+ + "\3\2\2\2\u0333\u0334\7)\2\2\u0334\u0335\7)\2\2\u0335\u0344\7)\2\2\u0336"+ + "\u0337\7$\2\2\u0337\u0338\7$\2\2\u0338\u0339\7$\2\2\u0339\u033d\3\2\2"+ + "\2\u033a\u033c\5\u00e7t\2\u033b\u033a\3\2\2\2\u033c\u033f\3\2\2\2\u033d"+ + "\u033e\3\2\2\2\u033d\u033b\3\2\2\2\u033e\u0340\3\2\2\2\u033f\u033d\3\2"+ + "\2\2\u0340\u0341\7$\2\2\u0341\u0342\7$\2\2\u0342\u0344\7$\2\2\u0343\u0329"+ + "\3\2\2\2\u0343\u0336\3\2\2\2\u0344\u00e6\3\2\2\2\u0345\u0348\5\u00edw"+ + "\2\u0346\u0348\5\u00efx\2\u0347\u0345\3\2\2\2\u0347\u0346\3\2\2\2\u0348"+ + "\u00e8\3\2\2\2\u0349\u034b\t\23\2\2\u034a\u0349\3\2\2\2\u034b\u00ea\3"+ + "\2\2\2\u034c\u034e\t\24\2\2\u034d\u034c\3\2\2\2\u034e\u00ec\3\2\2\2\u034f"+ + "\u0351\t\25\2\2\u0350\u034f\3\2\2\2\u0351\u00ee\3\2\2\2\u0352\u0353\7"+ + "^\2\2\u0353\u0354\t\26\2\2\u0354\u00f0\3\2\2\2\u0355\u0357\t\27\2\2\u0356"+ + "\u0355\3\2\2\2\u0357\u0358\3\2\2\2\u0358\u0356\3\2\2\2\u0358\u0359\3\2"+ + "\2\2\u0359\u00f2\3\2\2\2\u035a\u035e\7%\2\2\u035b\u035d\n\30\2\2\u035c"+ + "\u035b\3\2\2\2\u035d\u0360\3\2\2\2\u035e\u035c\3\2\2\2\u035e\u035f\3\2"+ + "\2\2\u035f\u00f4\3\2\2\2\u0360\u035e\3\2\2\2\u0361\u0363\7^\2\2\u0362"+ + "\u0364\5\u00f1y\2\u0363\u0362\3\2\2\2\u0363\u0364\3\2\2\2\u0364\u036a"+ + "\3\2\2\2\u0365\u0367\7\17\2\2\u0366\u0365\3\2\2\2\u0366\u0367\3\2\2\2"+ + "\u0367\u0368\3\2\2\2\u0368\u036b\7\f\2\2\u0369\u036b\4\16\17\2\u036a\u0366"+ + "\3\2\2\2\u036a\u0369\3\2\2\2\u036b\u00f6\3\2\2\2\u036c\u036e\t\31\2\2"+ + "\u036d\u036c\3\2\2\2\u036e\u00f8\3\2\2\2\u036f\u0372\5\u00f7|\2\u0370"+ + "\u0372\t\32\2\2\u0371\u036f\3\2\2\2\u0371\u0370\3\2\2\2\u0372\u00fa\3"+ + "\2\2\2<\2\u00fd\u0102\u0108\u01cb\u01cf\u01d2\u01d4\u01dc\u01e4\u01e8"+ + "\u01ef\u01f3\u01f9\u01ff\u0201\u0208\u020f\u0216\u021a\u021e\u02a6\u02af"+ + "\u02b1\u02b8\u02ba\u02be\u02c7\u02d4\u02da\u02de\u02e6\u02f3\u02f9\u02fd"+ + "\u0304\u030a\u030e\u0313\u0318\u031a\u0321\u0323\u0327\u0330\u033d\u0343"+ + "\u0347\u034a\u034d\u0350\u0358\u035e\u0363\u0366\u036a\u036d\u0371\n\3"+ + "(\2\3\65\3\3\66\4\3<\5\3=\6\3I\7\3J\b\b\2\2"; + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} \ No newline at end of file diff --git a/src/gpsl/grammar/.antlr/Python3Lexer.tokens b/src/gpsl/grammar/.antlr/Python3Lexer.tokens new file mode 100644 index 0000000..2ed45ea --- /dev/null +++ b/src/gpsl/grammar/.antlr/Python3Lexer.tokens @@ -0,0 +1,179 @@ +STRING=1 +NUMBER=2 +INTEGER=3 +DEF=4 +RETURN=5 +RAISE=6 +FROM=7 +IMPORT=8 +AS=9 +GLOBAL=10 +NONLOCAL=11 +ASSERT=12 +IF=13 +ELIF=14 +ELSE=15 +WHILE=16 +FOR=17 +IN=18 +TRY=19 +FINALLY=20 +WITH=21 +EXCEPT=22 +LAMBDA=23 +OR=24 +AND=25 +NOT=26 +IS=27 +NONE=28 +TRUE=29 +FALSE=30 +CLASS=31 +YIELD=32 +DEL=33 +PASS=34 +CONTINUE=35 +BREAK=36 +ASYNC=37 +AWAIT=38 +NEWLINE=39 +NAME=40 +STRING_LITERAL=41 +BYTES_LITERAL=42 +DECIMAL_INTEGER=43 +OCT_INTEGER=44 +HEX_INTEGER=45 +BIN_INTEGER=46 +FLOAT_NUMBER=47 +IMAG_NUMBER=48 +DOT=49 +ELLIPSIS=50 +STAR=51 +OPEN_PAREN=52 +CLOSE_PAREN=53 +COMMA=54 +COLON=55 +SEMI_COLON=56 +POWER=57 +ASSIGN=58 +OPEN_BRACK=59 +CLOSE_BRACK=60 +OR_OP=61 +XOR=62 +AND_OP=63 +LEFT_SHIFT=64 +RIGHT_SHIFT=65 +ADD=66 +MINUS=67 +DIV=68 +MOD=69 +IDIV=70 +NOT_OP=71 +OPEN_BRACE=72 +CLOSE_BRACE=73 +LESS_THAN=74 +GREATER_THAN=75 +EQUALS=76 +GT_EQ=77 +LT_EQ=78 +NOT_EQ_1=79 +NOT_EQ_2=80 +AT=81 +ARROW=82 +ADD_ASSIGN=83 +SUB_ASSIGN=84 +MULT_ASSIGN=85 +AT_ASSIGN=86 +DIV_ASSIGN=87 +MOD_ASSIGN=88 +AND_ASSIGN=89 +OR_ASSIGN=90 +XOR_ASSIGN=91 +LEFT_SHIFT_ASSIGN=92 +RIGHT_SHIFT_ASSIGN=93 +POWER_ASSIGN=94 +IDIV_ASSIGN=95 +SKIP_=96 +UNKNOWN_CHAR=97 +'def'=4 +'return'=5 +'raise'=6 +'from'=7 +'import'=8 +'as'=9 +'global'=10 +'nonlocal'=11 +'assert'=12 +'if'=13 +'elif'=14 +'else'=15 +'while'=16 +'for'=17 +'in'=18 +'try'=19 +'finally'=20 +'with'=21 +'except'=22 +'lambda'=23 +'or'=24 +'and'=25 +'not'=26 +'is'=27 +'None'=28 +'True'=29 +'False'=30 +'class'=31 +'yield'=32 +'del'=33 +'pass'=34 +'continue'=35 +'break'=36 +'async'=37 +'await'=38 +'.'=49 +'...'=50 +'*'=51 +'('=52 +')'=53 +','=54 +':'=55 +';'=56 +'**'=57 +'='=58 +'['=59 +']'=60 +'|'=61 +'^'=62 +'&'=63 +'<<'=64 +'>>'=65 +'+'=66 +'-'=67 +'/'=68 +'%'=69 +'//'=70 +'~'=71 +'{'=72 +'}'=73 +'<'=74 +'>'=75 +'=='=76 +'>='=77 +'<='=78 +'<>'=79 +'!='=80 +'@'=81 +'->'=82 +'+='=83 +'-='=84 +'*='=85 +'@='=86 +'/='=87 +'%='=88 +'&='=89 +'|='=90 +'^='=91 +'<<='=92 +'>>='=93 +'**='=94 +'//='=95 diff --git a/src/gpsl/grammar/.antlr/Python3Parser.java b/src/gpsl/grammar/.antlr/Python3Parser.java new file mode 100644 index 0000000..a282ee4 --- /dev/null +++ b/src/gpsl/grammar/.antlr/Python3Parser.java @@ -0,0 +1,7221 @@ +// Generated from h:\Git\gpsl\src\grammar\Python3.g4 by ANTLR 4.8 +import org.antlr.v4.runtime.atn.*; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.misc.*; +import org.antlr.v4.runtime.tree.*; +import java.util.List; +import java.util.Iterator; +import java.util.ArrayList; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) +public class Python3Parser extends Parser { + static { RuntimeMetaData.checkVersion("4.8", RuntimeMetaData.VERSION); } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + STRING=1, NUMBER=2, INTEGER=3, DEF=4, RETURN=5, RAISE=6, FROM=7, IMPORT=8, + AS=9, GLOBAL=10, NONLOCAL=11, ASSERT=12, IF=13, ELIF=14, ELSE=15, WHILE=16, + FOR=17, IN=18, TRY=19, FINALLY=20, WITH=21, EXCEPT=22, LAMBDA=23, OR=24, + AND=25, NOT=26, IS=27, NONE=28, TRUE=29, FALSE=30, CLASS=31, YIELD=32, + DEL=33, PASS=34, CONTINUE=35, BREAK=36, ASYNC=37, AWAIT=38, NEWLINE=39, + NAME=40, STRING_LITERAL=41, BYTES_LITERAL=42, DECIMAL_INTEGER=43, OCT_INTEGER=44, + HEX_INTEGER=45, BIN_INTEGER=46, FLOAT_NUMBER=47, IMAG_NUMBER=48, DOT=49, + ELLIPSIS=50, STAR=51, OPEN_PAREN=52, CLOSE_PAREN=53, COMMA=54, COLON=55, + SEMI_COLON=56, POWER=57, ASSIGN=58, OPEN_BRACK=59, CLOSE_BRACK=60, OR_OP=61, + XOR=62, AND_OP=63, LEFT_SHIFT=64, RIGHT_SHIFT=65, ADD=66, MINUS=67, DIV=68, + MOD=69, IDIV=70, NOT_OP=71, OPEN_BRACE=72, CLOSE_BRACE=73, LESS_THAN=74, + GREATER_THAN=75, EQUALS=76, GT_EQ=77, LT_EQ=78, NOT_EQ_1=79, NOT_EQ_2=80, + AT=81, ARROW=82, ADD_ASSIGN=83, SUB_ASSIGN=84, MULT_ASSIGN=85, AT_ASSIGN=86, + DIV_ASSIGN=87, MOD_ASSIGN=88, AND_ASSIGN=89, OR_ASSIGN=90, XOR_ASSIGN=91, + LEFT_SHIFT_ASSIGN=92, RIGHT_SHIFT_ASSIGN=93, POWER_ASSIGN=94, IDIV_ASSIGN=95, + SKIP_=96, UNKNOWN_CHAR=97, INDENT=98, DEDENT=99; + public static final int + RULE_single_input = 0, RULE_file_input = 1, RULE_eval_input = 2, RULE_decorator = 3, + RULE_decorators = 4, RULE_decorated = 5, RULE_async_funcdef = 6, RULE_funcdef = 7, + RULE_parameters = 8, RULE_typedargslist = 9, RULE_tfpdef = 10, RULE_varargslist = 11, + RULE_vfpdef = 12, RULE_stmt = 13, RULE_simple_stmt = 14, RULE_small_stmt = 15, + RULE_expr_stmt = 16, RULE_annassign = 17, RULE_testlist_star_expr = 18, + RULE_augassign = 19, RULE_del_stmt = 20, RULE_pass_stmt = 21, RULE_flow_stmt = 22, + RULE_break_stmt = 23, RULE_continue_stmt = 24, RULE_return_stmt = 25, + RULE_yield_stmt = 26, RULE_raise_stmt = 27, RULE_import_stmt = 28, RULE_import_name = 29, + RULE_import_from = 30, RULE_import_as_name = 31, RULE_dotted_as_name = 32, + RULE_import_as_names = 33, RULE_dotted_as_names = 34, RULE_dotted_name = 35, + RULE_global_stmt = 36, RULE_nonlocal_stmt = 37, RULE_assert_stmt = 38, + RULE_compound_stmt = 39, RULE_async_stmt = 40, RULE_if_stmt = 41, RULE_while_stmt = 42, + RULE_for_stmt = 43, RULE_try_stmt = 44, RULE_with_stmt = 45, RULE_with_item = 46, + RULE_except_clause = 47, RULE_suite = 48, RULE_test = 49, RULE_test_nocond = 50, + RULE_lambdef = 51, RULE_lambdef_nocond = 52, RULE_or_test = 53, RULE_and_test = 54, + RULE_not_test = 55, RULE_comparison = 56, RULE_comp_op = 57, RULE_star_expr = 58, + RULE_expr = 59, RULE_xor_expr = 60, RULE_and_expr = 61, RULE_shift_expr = 62, + RULE_arith_expr = 63, RULE_term = 64, RULE_factor = 65, RULE_power = 66, + RULE_atom_expr = 67, RULE_atom = 68, RULE_testlist_comp = 69, RULE_trailer = 70, + RULE_subscriptlist = 71, RULE_subscript = 72, RULE_sliceop = 73, RULE_exprlist = 74, + RULE_testlist = 75, RULE_dictorsetmaker = 76, RULE_classdef = 77, RULE_arglist = 78, + RULE_argument = 79, RULE_comp_iter = 80, RULE_comp_for = 81, RULE_comp_if = 82, + RULE_encoding_decl = 83, RULE_yield_expr = 84, RULE_yield_arg = 85; + private static String[] makeRuleNames() { + return new String[] { + "single_input", "file_input", "eval_input", "decorator", "decorators", + "decorated", "async_funcdef", "funcdef", "parameters", "typedargslist", + "tfpdef", "varargslist", "vfpdef", "stmt", "simple_stmt", "small_stmt", + "expr_stmt", "annassign", "testlist_star_expr", "augassign", "del_stmt", + "pass_stmt", "flow_stmt", "break_stmt", "continue_stmt", "return_stmt", + "yield_stmt", "raise_stmt", "import_stmt", "import_name", "import_from", + "import_as_name", "dotted_as_name", "import_as_names", "dotted_as_names", + "dotted_name", "global_stmt", "nonlocal_stmt", "assert_stmt", "compound_stmt", + "async_stmt", "if_stmt", "while_stmt", "for_stmt", "try_stmt", "with_stmt", + "with_item", "except_clause", "suite", "test", "test_nocond", "lambdef", + "lambdef_nocond", "or_test", "and_test", "not_test", "comparison", "comp_op", + "star_expr", "expr", "xor_expr", "and_expr", "shift_expr", "arith_expr", + "term", "factor", "power", "atom_expr", "atom", "testlist_comp", "trailer", + "subscriptlist", "subscript", "sliceop", "exprlist", "testlist", "dictorsetmaker", + "classdef", "arglist", "argument", "comp_iter", "comp_for", "comp_if", + "encoding_decl", "yield_expr", "yield_arg" + }; + } + public static final String[] ruleNames = makeRuleNames(); + + private static String[] makeLiteralNames() { + return new String[] { + null, null, null, null, "'def'", "'return'", "'raise'", "'from'", "'import'", + "'as'", "'global'", "'nonlocal'", "'assert'", "'if'", "'elif'", "'else'", + "'while'", "'for'", "'in'", "'try'", "'finally'", "'with'", "'except'", + "'lambda'", "'or'", "'and'", "'not'", "'is'", "'None'", "'True'", "'False'", + "'class'", "'yield'", "'del'", "'pass'", "'continue'", "'break'", "'async'", + "'await'", null, null, null, null, null, null, null, null, null, null, + "'.'", "'...'", "'*'", "'('", "')'", "','", "':'", "';'", "'**'", "'='", + "'['", "']'", "'|'", "'^'", "'&'", "'<<'", "'>>'", "'+'", "'-'", "'/'", + "'%'", "'//'", "'~'", "'{'", "'}'", "'<'", "'>'", "'=='", "'>='", "'<='", + "'<>'", "'!='", "'@'", "'->'", "'+='", "'-='", "'*='", "'@='", "'/='", + "'%='", "'&='", "'|='", "'^='", "'<<='", "'>>='", "'**='", "'//='" + }; + } + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static String[] makeSymbolicNames() { + return new String[] { + null, "STRING", "NUMBER", "INTEGER", "DEF", "RETURN", "RAISE", "FROM", + "IMPORT", "AS", "GLOBAL", "NONLOCAL", "ASSERT", "IF", "ELIF", "ELSE", + "WHILE", "FOR", "IN", "TRY", "FINALLY", "WITH", "EXCEPT", "LAMBDA", "OR", + "AND", "NOT", "IS", "NONE", "TRUE", "FALSE", "CLASS", "YIELD", "DEL", + "PASS", "CONTINUE", "BREAK", "ASYNC", "AWAIT", "NEWLINE", "NAME", "STRING_LITERAL", + "BYTES_LITERAL", "DECIMAL_INTEGER", "OCT_INTEGER", "HEX_INTEGER", "BIN_INTEGER", + "FLOAT_NUMBER", "IMAG_NUMBER", "DOT", "ELLIPSIS", "STAR", "OPEN_PAREN", + "CLOSE_PAREN", "COMMA", "COLON", "SEMI_COLON", "POWER", "ASSIGN", "OPEN_BRACK", + "CLOSE_BRACK", "OR_OP", "XOR", "AND_OP", "LEFT_SHIFT", "RIGHT_SHIFT", + "ADD", "MINUS", "DIV", "MOD", "IDIV", "NOT_OP", "OPEN_BRACE", "CLOSE_BRACE", + "LESS_THAN", "GREATER_THAN", "EQUALS", "GT_EQ", "LT_EQ", "NOT_EQ_1", + "NOT_EQ_2", "AT", "ARROW", "ADD_ASSIGN", "SUB_ASSIGN", "MULT_ASSIGN", + "AT_ASSIGN", "DIV_ASSIGN", "MOD_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", + "LEFT_SHIFT_ASSIGN", "RIGHT_SHIFT_ASSIGN", "POWER_ASSIGN", "IDIV_ASSIGN", + "SKIP_", "UNKNOWN_CHAR", "INDENT", "DEDENT" + }; + } + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated + public static final String[] tokenNames; + static { + tokenNames = new String[_SYMBOLIC_NAMES.length]; + for (int i = 0; i < tokenNames.length; i++) { + tokenNames[i] = VOCABULARY.getLiteralName(i); + if (tokenNames[i] == null) { + tokenNames[i] = VOCABULARY.getSymbolicName(i); + } + + if (tokenNames[i] == null) { + tokenNames[i] = ""; + } + } + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } + + @Override + + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + @Override + public String getGrammarFileName() { return "Python3.g4"; } + + @Override + public String[] getRuleNames() { return ruleNames; } + + @Override + public String getSerializedATN() { return _serializedATN; } + + @Override + public ATN getATN() { return _ATN; } + + public Python3Parser(TokenStream input) { + super(input); + _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); + } + + public static class Single_inputContext extends ParserRuleContext { + public TerminalNode NEWLINE() { return getToken(Python3Parser.NEWLINE, 0); } + public Simple_stmtContext simple_stmt() { + return getRuleContext(Simple_stmtContext.class,0); + } + public Compound_stmtContext compound_stmt() { + return getRuleContext(Compound_stmtContext.class,0); + } + public Single_inputContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_single_input; } + } + + public final Single_inputContext single_input() throws RecognitionException { + Single_inputContext _localctx = new Single_inputContext(_ctx, getState()); + enterRule(_localctx, 0, RULE_single_input); + try { + setState(177); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NEWLINE: + enterOuterAlt(_localctx, 1); + { + setState(172); + match(NEWLINE); + } + break; + case STRING: + case NUMBER: + case RETURN: + case RAISE: + case FROM: + case IMPORT: + case GLOBAL: + case NONLOCAL: + case ASSERT: + case LAMBDA: + case NOT: + case NONE: + case TRUE: + case FALSE: + case YIELD: + case DEL: + case PASS: + case CONTINUE: + case BREAK: + case AWAIT: + case NAME: + case ELLIPSIS: + case STAR: + case OPEN_PAREN: + case OPEN_BRACK: + case ADD: + case MINUS: + case NOT_OP: + case OPEN_BRACE: + enterOuterAlt(_localctx, 2); + { + setState(173); + simple_stmt(); + } + break; + case DEF: + case IF: + case WHILE: + case FOR: + case TRY: + case WITH: + case CLASS: + case ASYNC: + case AT: + enterOuterAlt(_localctx, 3); + { + setState(174); + compound_stmt(); + setState(175); + match(NEWLINE); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class File_inputContext extends ParserRuleContext { + public TerminalNode EOF() { return getToken(Python3Parser.EOF, 0); } + public List NEWLINE() { return getTokens(Python3Parser.NEWLINE); } + public TerminalNode NEWLINE(int i) { + return getToken(Python3Parser.NEWLINE, i); + } + public List stmt() { + return getRuleContexts(StmtContext.class); + } + public StmtContext stmt(int i) { + return getRuleContext(StmtContext.class,i); + } + public File_inputContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_file_input; } + } + + public final File_inputContext file_input() throws RecognitionException { + File_inputContext _localctx = new File_inputContext(_ctx, getState()); + enterRule(_localctx, 2, RULE_file_input); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(183); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << DEF) | (1L << RETURN) | (1L << RAISE) | (1L << FROM) | (1L << IMPORT) | (1L << GLOBAL) | (1L << NONLOCAL) | (1L << ASSERT) | (1L << IF) | (1L << WHILE) | (1L << FOR) | (1L << TRY) | (1L << WITH) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << CLASS) | (1L << YIELD) | (1L << DEL) | (1L << PASS) | (1L << CONTINUE) | (1L << BREAK) | (1L << ASYNC) | (1L << AWAIT) | (1L << NEWLINE) | (1L << NAME) | (1L << ELLIPSIS) | (1L << STAR) | (1L << OPEN_PAREN) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)) | (1L << (AT - 66)))) != 0)) { + { + setState(181); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NEWLINE: + { + setState(179); + match(NEWLINE); + } + break; + case STRING: + case NUMBER: + case DEF: + case RETURN: + case RAISE: + case FROM: + case IMPORT: + case GLOBAL: + case NONLOCAL: + case ASSERT: + case IF: + case WHILE: + case FOR: + case TRY: + case WITH: + case LAMBDA: + case NOT: + case NONE: + case TRUE: + case FALSE: + case CLASS: + case YIELD: + case DEL: + case PASS: + case CONTINUE: + case BREAK: + case ASYNC: + case AWAIT: + case NAME: + case ELLIPSIS: + case STAR: + case OPEN_PAREN: + case OPEN_BRACK: + case ADD: + case MINUS: + case NOT_OP: + case OPEN_BRACE: + case AT: + { + setState(180); + stmt(); + } + break; + default: + throw new NoViableAltException(this); + } + } + setState(185); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(186); + match(EOF); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Eval_inputContext extends ParserRuleContext { + public TestlistContext testlist() { + return getRuleContext(TestlistContext.class,0); + } + public TerminalNode EOF() { return getToken(Python3Parser.EOF, 0); } + public List NEWLINE() { return getTokens(Python3Parser.NEWLINE); } + public TerminalNode NEWLINE(int i) { + return getToken(Python3Parser.NEWLINE, i); + } + public Eval_inputContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_eval_input; } + } + + public final Eval_inputContext eval_input() throws RecognitionException { + Eval_inputContext _localctx = new Eval_inputContext(_ctx, getState()); + enterRule(_localctx, 4, RULE_eval_input); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(188); + testlist(); + setState(192); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==NEWLINE) { + { + { + setState(189); + match(NEWLINE); + } + } + setState(194); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(195); + match(EOF); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class DecoratorContext extends ParserRuleContext { + public TerminalNode AT() { return getToken(Python3Parser.AT, 0); } + public Dotted_nameContext dotted_name() { + return getRuleContext(Dotted_nameContext.class,0); + } + public TerminalNode NEWLINE() { return getToken(Python3Parser.NEWLINE, 0); } + public TerminalNode OPEN_PAREN() { return getToken(Python3Parser.OPEN_PAREN, 0); } + public TerminalNode CLOSE_PAREN() { return getToken(Python3Parser.CLOSE_PAREN, 0); } + public ArglistContext arglist() { + return getRuleContext(ArglistContext.class,0); + } + public DecoratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_decorator; } + } + + public final DecoratorContext decorator() throws RecognitionException { + DecoratorContext _localctx = new DecoratorContext(_ctx, getState()); + enterRule(_localctx, 6, RULE_decorator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(197); + match(AT); + setState(198); + dotted_name(); + setState(204); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_PAREN) { + { + setState(199); + match(OPEN_PAREN); + setState(201); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << STAR) | (1L << OPEN_PAREN) | (1L << POWER) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) { + { + setState(200); + arglist(); + } + } + + setState(203); + match(CLOSE_PAREN); + } + } + + setState(206); + match(NEWLINE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class DecoratorsContext extends ParserRuleContext { + public List decorator() { + return getRuleContexts(DecoratorContext.class); + } + public DecoratorContext decorator(int i) { + return getRuleContext(DecoratorContext.class,i); + } + public DecoratorsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_decorators; } + } + + public final DecoratorsContext decorators() throws RecognitionException { + DecoratorsContext _localctx = new DecoratorsContext(_ctx, getState()); + enterRule(_localctx, 8, RULE_decorators); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(209); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(208); + decorator(); + } + } + setState(211); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==AT ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class DecoratedContext extends ParserRuleContext { + public DecoratorsContext decorators() { + return getRuleContext(DecoratorsContext.class,0); + } + public ClassdefContext classdef() { + return getRuleContext(ClassdefContext.class,0); + } + public FuncdefContext funcdef() { + return getRuleContext(FuncdefContext.class,0); + } + public Async_funcdefContext async_funcdef() { + return getRuleContext(Async_funcdefContext.class,0); + } + public DecoratedContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_decorated; } + } + + public final DecoratedContext decorated() throws RecognitionException { + DecoratedContext _localctx = new DecoratedContext(_ctx, getState()); + enterRule(_localctx, 10, RULE_decorated); + try { + enterOuterAlt(_localctx, 1); + { + setState(213); + decorators(); + setState(217); + _errHandler.sync(this); + switch (_input.LA(1)) { + case CLASS: + { + setState(214); + classdef(); + } + break; + case DEF: + { + setState(215); + funcdef(); + } + break; + case ASYNC: + { + setState(216); + async_funcdef(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Async_funcdefContext extends ParserRuleContext { + public TerminalNode ASYNC() { return getToken(Python3Parser.ASYNC, 0); } + public FuncdefContext funcdef() { + return getRuleContext(FuncdefContext.class,0); + } + public Async_funcdefContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_async_funcdef; } + } + + public final Async_funcdefContext async_funcdef() throws RecognitionException { + Async_funcdefContext _localctx = new Async_funcdefContext(_ctx, getState()); + enterRule(_localctx, 12, RULE_async_funcdef); + try { + enterOuterAlt(_localctx, 1); + { + setState(219); + match(ASYNC); + setState(220); + funcdef(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FuncdefContext extends ParserRuleContext { + public TerminalNode DEF() { return getToken(Python3Parser.DEF, 0); } + public TerminalNode NAME() { return getToken(Python3Parser.NAME, 0); } + public ParametersContext parameters() { + return getRuleContext(ParametersContext.class,0); + } + public TerminalNode COLON() { return getToken(Python3Parser.COLON, 0); } + public SuiteContext suite() { + return getRuleContext(SuiteContext.class,0); + } + public TerminalNode ARROW() { return getToken(Python3Parser.ARROW, 0); } + public TestContext test() { + return getRuleContext(TestContext.class,0); + } + public FuncdefContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_funcdef; } + } + + public final FuncdefContext funcdef() throws RecognitionException { + FuncdefContext _localctx = new FuncdefContext(_ctx, getState()); + enterRule(_localctx, 14, RULE_funcdef); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(222); + match(DEF); + setState(223); + match(NAME); + setState(224); + parameters(); + setState(227); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ARROW) { + { + setState(225); + match(ARROW); + setState(226); + test(); + } + } + + setState(229); + match(COLON); + setState(230); + suite(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ParametersContext extends ParserRuleContext { + public TerminalNode OPEN_PAREN() { return getToken(Python3Parser.OPEN_PAREN, 0); } + public TerminalNode CLOSE_PAREN() { return getToken(Python3Parser.CLOSE_PAREN, 0); } + public TypedargslistContext typedargslist() { + return getRuleContext(TypedargslistContext.class,0); + } + public ParametersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_parameters; } + } + + public final ParametersContext parameters() throws RecognitionException { + ParametersContext _localctx = new ParametersContext(_ctx, getState()); + enterRule(_localctx, 16, RULE_parameters); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(232); + match(OPEN_PAREN); + setState(234); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NAME) | (1L << STAR) | (1L << POWER))) != 0)) { + { + setState(233); + typedargslist(); + } + } + + setState(236); + match(CLOSE_PAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypedargslistContext extends ParserRuleContext { + public List tfpdef() { + return getRuleContexts(TfpdefContext.class); + } + public TfpdefContext tfpdef(int i) { + return getRuleContext(TfpdefContext.class,i); + } + public TerminalNode STAR() { return getToken(Python3Parser.STAR, 0); } + public TerminalNode POWER() { return getToken(Python3Parser.POWER, 0); } + public List ASSIGN() { return getTokens(Python3Parser.ASSIGN); } + public TerminalNode ASSIGN(int i) { + return getToken(Python3Parser.ASSIGN, i); + } + public List test() { + return getRuleContexts(TestContext.class); + } + public TestContext test(int i) { + return getRuleContext(TestContext.class,i); + } + public List COMMA() { return getTokens(Python3Parser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(Python3Parser.COMMA, i); + } + public TypedargslistContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typedargslist; } + } + + public final TypedargslistContext typedargslist() throws RecognitionException { + TypedargslistContext _localctx = new TypedargslistContext(_ctx, getState()); + enterRule(_localctx, 18, RULE_typedargslist); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(319); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NAME: + { + setState(238); + tfpdef(); + setState(241); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ASSIGN) { + { + setState(239); + match(ASSIGN); + setState(240); + test(); + } + } + + setState(251); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,12,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(243); + match(COMMA); + setState(244); + tfpdef(); + setState(247); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ASSIGN) { + { + setState(245); + match(ASSIGN); + setState(246); + test(); + } + } + + } + } + } + setState(253); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,12,_ctx); + } + setState(287); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(254); + match(COMMA); + setState(285); + _errHandler.sync(this); + switch (_input.LA(1)) { + case STAR: + { + setState(255); + match(STAR); + setState(257); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NAME) { + { + setState(256); + tfpdef(); + } + } + + setState(267); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,15,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(259); + match(COMMA); + setState(260); + tfpdef(); + setState(263); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ASSIGN) { + { + setState(261); + match(ASSIGN); + setState(262); + test(); + } + } + + } + } + } + setState(269); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,15,_ctx); + } + setState(278); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(270); + match(COMMA); + setState(276); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==POWER) { + { + setState(271); + match(POWER); + setState(272); + tfpdef(); + setState(274); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(273); + match(COMMA); + } + } + + } + } + + } + } + + } + break; + case POWER: + { + setState(280); + match(POWER); + setState(281); + tfpdef(); + setState(283); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(282); + match(COMMA); + } + } + + } + break; + case CLOSE_PAREN: + break; + default: + break; + } + } + } + + } + break; + case STAR: + { + setState(289); + match(STAR); + setState(291); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NAME) { + { + setState(290); + tfpdef(); + } + } + + setState(301); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,24,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(293); + match(COMMA); + setState(294); + tfpdef(); + setState(297); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ASSIGN) { + { + setState(295); + match(ASSIGN); + setState(296); + test(); + } + } + + } + } + } + setState(303); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,24,_ctx); + } + setState(312); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(304); + match(COMMA); + setState(310); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==POWER) { + { + setState(305); + match(POWER); + setState(306); + tfpdef(); + setState(308); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(307); + match(COMMA); + } + } + + } + } + + } + } + + } + break; + case POWER: + { + setState(314); + match(POWER); + setState(315); + tfpdef(); + setState(317); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(316); + match(COMMA); + } + } + + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TfpdefContext extends ParserRuleContext { + public TerminalNode NAME() { return getToken(Python3Parser.NAME, 0); } + public TerminalNode COLON() { return getToken(Python3Parser.COLON, 0); } + public TestContext test() { + return getRuleContext(TestContext.class,0); + } + public TfpdefContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tfpdef; } + } + + public final TfpdefContext tfpdef() throws RecognitionException { + TfpdefContext _localctx = new TfpdefContext(_ctx, getState()); + enterRule(_localctx, 20, RULE_tfpdef); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(321); + match(NAME); + setState(324); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLON) { + { + setState(322); + match(COLON); + setState(323); + test(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class VarargslistContext extends ParserRuleContext { + public List vfpdef() { + return getRuleContexts(VfpdefContext.class); + } + public VfpdefContext vfpdef(int i) { + return getRuleContext(VfpdefContext.class,i); + } + public TerminalNode STAR() { return getToken(Python3Parser.STAR, 0); } + public TerminalNode POWER() { return getToken(Python3Parser.POWER, 0); } + public List ASSIGN() { return getTokens(Python3Parser.ASSIGN); } + public TerminalNode ASSIGN(int i) { + return getToken(Python3Parser.ASSIGN, i); + } + public List test() { + return getRuleContexts(TestContext.class); + } + public TestContext test(int i) { + return getRuleContext(TestContext.class,i); + } + public List COMMA() { return getTokens(Python3Parser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(Python3Parser.COMMA, i); + } + public VarargslistContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_varargslist; } + } + + public final VarargslistContext varargslist() throws RecognitionException { + VarargslistContext _localctx = new VarargslistContext(_ctx, getState()); + enterRule(_localctx, 22, RULE_varargslist); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(407); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NAME: + { + setState(326); + vfpdef(); + setState(329); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ASSIGN) { + { + setState(327); + match(ASSIGN); + setState(328); + test(); + } + } + + setState(339); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,33,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(331); + match(COMMA); + setState(332); + vfpdef(); + setState(335); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ASSIGN) { + { + setState(333); + match(ASSIGN); + setState(334); + test(); + } + } + + } + } + } + setState(341); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,33,_ctx); + } + setState(375); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(342); + match(COMMA); + setState(373); + _errHandler.sync(this); + switch (_input.LA(1)) { + case STAR: + { + setState(343); + match(STAR); + setState(345); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NAME) { + { + setState(344); + vfpdef(); + } + } + + setState(355); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,36,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(347); + match(COMMA); + setState(348); + vfpdef(); + setState(351); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ASSIGN) { + { + setState(349); + match(ASSIGN); + setState(350); + test(); + } + } + + } + } + } + setState(357); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,36,_ctx); + } + setState(366); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(358); + match(COMMA); + setState(364); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==POWER) { + { + setState(359); + match(POWER); + setState(360); + vfpdef(); + setState(362); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(361); + match(COMMA); + } + } + + } + } + + } + } + + } + break; + case POWER: + { + setState(368); + match(POWER); + setState(369); + vfpdef(); + setState(371); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(370); + match(COMMA); + } + } + + } + break; + case COLON: + break; + default: + break; + } + } + } + + } + break; + case STAR: + { + setState(377); + match(STAR); + setState(379); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==NAME) { + { + setState(378); + vfpdef(); + } + } + + setState(389); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,45,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(381); + match(COMMA); + setState(382); + vfpdef(); + setState(385); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ASSIGN) { + { + setState(383); + match(ASSIGN); + setState(384); + test(); + } + } + + } + } + } + setState(391); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,45,_ctx); + } + setState(400); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(392); + match(COMMA); + setState(398); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==POWER) { + { + setState(393); + match(POWER); + setState(394); + vfpdef(); + setState(396); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(395); + match(COMMA); + } + } + + } + } + + } + } + + } + break; + case POWER: + { + setState(402); + match(POWER); + setState(403); + vfpdef(); + setState(405); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(404); + match(COMMA); + } + } + + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class VfpdefContext extends ParserRuleContext { + public TerminalNode NAME() { return getToken(Python3Parser.NAME, 0); } + public VfpdefContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_vfpdef; } + } + + public final VfpdefContext vfpdef() throws RecognitionException { + VfpdefContext _localctx = new VfpdefContext(_ctx, getState()); + enterRule(_localctx, 24, RULE_vfpdef); + try { + enterOuterAlt(_localctx, 1); + { + setState(409); + match(NAME); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class StmtContext extends ParserRuleContext { + public Simple_stmtContext simple_stmt() { + return getRuleContext(Simple_stmtContext.class,0); + } + public Compound_stmtContext compound_stmt() { + return getRuleContext(Compound_stmtContext.class,0); + } + public StmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_stmt; } + } + + public final StmtContext stmt() throws RecognitionException { + StmtContext _localctx = new StmtContext(_ctx, getState()); + enterRule(_localctx, 26, RULE_stmt); + try { + setState(413); + _errHandler.sync(this); + switch (_input.LA(1)) { + case STRING: + case NUMBER: + case RETURN: + case RAISE: + case FROM: + case IMPORT: + case GLOBAL: + case NONLOCAL: + case ASSERT: + case LAMBDA: + case NOT: + case NONE: + case TRUE: + case FALSE: + case YIELD: + case DEL: + case PASS: + case CONTINUE: + case BREAK: + case AWAIT: + case NAME: + case ELLIPSIS: + case STAR: + case OPEN_PAREN: + case OPEN_BRACK: + case ADD: + case MINUS: + case NOT_OP: + case OPEN_BRACE: + enterOuterAlt(_localctx, 1); + { + setState(411); + simple_stmt(); + } + break; + case DEF: + case IF: + case WHILE: + case FOR: + case TRY: + case WITH: + case CLASS: + case ASYNC: + case AT: + enterOuterAlt(_localctx, 2); + { + setState(412); + compound_stmt(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Simple_stmtContext extends ParserRuleContext { + public List small_stmt() { + return getRuleContexts(Small_stmtContext.class); + } + public Small_stmtContext small_stmt(int i) { + return getRuleContext(Small_stmtContext.class,i); + } + public TerminalNode NEWLINE() { return getToken(Python3Parser.NEWLINE, 0); } + public List SEMI_COLON() { return getTokens(Python3Parser.SEMI_COLON); } + public TerminalNode SEMI_COLON(int i) { + return getToken(Python3Parser.SEMI_COLON, i); + } + public Simple_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_simple_stmt; } + } + + public final Simple_stmtContext simple_stmt() throws RecognitionException { + Simple_stmtContext _localctx = new Simple_stmtContext(_ctx, getState()); + enterRule(_localctx, 28, RULE_simple_stmt); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(415); + small_stmt(); + setState(420); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,52,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(416); + match(SEMI_COLON); + setState(417); + small_stmt(); + } + } + } + setState(422); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,52,_ctx); + } + setState(424); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==SEMI_COLON) { + { + setState(423); + match(SEMI_COLON); + } + } + + setState(426); + match(NEWLINE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Small_stmtContext extends ParserRuleContext { + public Expr_stmtContext expr_stmt() { + return getRuleContext(Expr_stmtContext.class,0); + } + public Del_stmtContext del_stmt() { + return getRuleContext(Del_stmtContext.class,0); + } + public Pass_stmtContext pass_stmt() { + return getRuleContext(Pass_stmtContext.class,0); + } + public Flow_stmtContext flow_stmt() { + return getRuleContext(Flow_stmtContext.class,0); + } + public Import_stmtContext import_stmt() { + return getRuleContext(Import_stmtContext.class,0); + } + public Global_stmtContext global_stmt() { + return getRuleContext(Global_stmtContext.class,0); + } + public Nonlocal_stmtContext nonlocal_stmt() { + return getRuleContext(Nonlocal_stmtContext.class,0); + } + public Assert_stmtContext assert_stmt() { + return getRuleContext(Assert_stmtContext.class,0); + } + public Small_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_small_stmt; } + } + + public final Small_stmtContext small_stmt() throws RecognitionException { + Small_stmtContext _localctx = new Small_stmtContext(_ctx, getState()); + enterRule(_localctx, 30, RULE_small_stmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(436); + _errHandler.sync(this); + switch (_input.LA(1)) { + case STRING: + case NUMBER: + case LAMBDA: + case NOT: + case NONE: + case TRUE: + case FALSE: + case AWAIT: + case NAME: + case ELLIPSIS: + case STAR: + case OPEN_PAREN: + case OPEN_BRACK: + case ADD: + case MINUS: + case NOT_OP: + case OPEN_BRACE: + { + setState(428); + expr_stmt(); + } + break; + case DEL: + { + setState(429); + del_stmt(); + } + break; + case PASS: + { + setState(430); + pass_stmt(); + } + break; + case RETURN: + case RAISE: + case YIELD: + case CONTINUE: + case BREAK: + { + setState(431); + flow_stmt(); + } + break; + case FROM: + case IMPORT: + { + setState(432); + import_stmt(); + } + break; + case GLOBAL: + { + setState(433); + global_stmt(); + } + break; + case NONLOCAL: + { + setState(434); + nonlocal_stmt(); + } + break; + case ASSERT: + { + setState(435); + assert_stmt(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Expr_stmtContext extends ParserRuleContext { + public List testlist_star_expr() { + return getRuleContexts(Testlist_star_exprContext.class); + } + public Testlist_star_exprContext testlist_star_expr(int i) { + return getRuleContext(Testlist_star_exprContext.class,i); + } + public AnnassignContext annassign() { + return getRuleContext(AnnassignContext.class,0); + } + public AugassignContext augassign() { + return getRuleContext(AugassignContext.class,0); + } + public List yield_expr() { + return getRuleContexts(Yield_exprContext.class); + } + public Yield_exprContext yield_expr(int i) { + return getRuleContext(Yield_exprContext.class,i); + } + public TestlistContext testlist() { + return getRuleContext(TestlistContext.class,0); + } + public List ASSIGN() { return getTokens(Python3Parser.ASSIGN); } + public TerminalNode ASSIGN(int i) { + return getToken(Python3Parser.ASSIGN, i); + } + public Expr_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expr_stmt; } + } + + public final Expr_stmtContext expr_stmt() throws RecognitionException { + Expr_stmtContext _localctx = new Expr_stmtContext(_ctx, getState()); + enterRule(_localctx, 32, RULE_expr_stmt); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(438); + testlist_star_expr(); + setState(455); + _errHandler.sync(this); + switch (_input.LA(1)) { + case COLON: + { + setState(439); + annassign(); + } + break; + case ADD_ASSIGN: + case SUB_ASSIGN: + case MULT_ASSIGN: + case AT_ASSIGN: + case DIV_ASSIGN: + case MOD_ASSIGN: + case AND_ASSIGN: + case OR_ASSIGN: + case XOR_ASSIGN: + case LEFT_SHIFT_ASSIGN: + case RIGHT_SHIFT_ASSIGN: + case POWER_ASSIGN: + case IDIV_ASSIGN: + { + setState(440); + augassign(); + setState(443); + _errHandler.sync(this); + switch (_input.LA(1)) { + case YIELD: + { + setState(441); + yield_expr(); + } + break; + case STRING: + case NUMBER: + case LAMBDA: + case NOT: + case NONE: + case TRUE: + case FALSE: + case AWAIT: + case NAME: + case ELLIPSIS: + case OPEN_PAREN: + case OPEN_BRACK: + case ADD: + case MINUS: + case NOT_OP: + case OPEN_BRACE: + { + setState(442); + testlist(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case NEWLINE: + case SEMI_COLON: + case ASSIGN: + { + setState(452); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==ASSIGN) { + { + { + setState(445); + match(ASSIGN); + setState(448); + _errHandler.sync(this); + switch (_input.LA(1)) { + case YIELD: + { + setState(446); + yield_expr(); + } + break; + case STRING: + case NUMBER: + case LAMBDA: + case NOT: + case NONE: + case TRUE: + case FALSE: + case AWAIT: + case NAME: + case ELLIPSIS: + case STAR: + case OPEN_PAREN: + case OPEN_BRACK: + case ADD: + case MINUS: + case NOT_OP: + case OPEN_BRACE: + { + setState(447); + testlist_star_expr(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + setState(454); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AnnassignContext extends ParserRuleContext { + public TerminalNode COLON() { return getToken(Python3Parser.COLON, 0); } + public List test() { + return getRuleContexts(TestContext.class); + } + public TestContext test(int i) { + return getRuleContext(TestContext.class,i); + } + public TerminalNode ASSIGN() { return getToken(Python3Parser.ASSIGN, 0); } + public AnnassignContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_annassign; } + } + + public final AnnassignContext annassign() throws RecognitionException { + AnnassignContext _localctx = new AnnassignContext(_ctx, getState()); + enterRule(_localctx, 34, RULE_annassign); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(457); + match(COLON); + setState(458); + test(); + setState(461); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ASSIGN) { + { + setState(459); + match(ASSIGN); + setState(460); + test(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Testlist_star_exprContext extends ParserRuleContext { + public List test() { + return getRuleContexts(TestContext.class); + } + public TestContext test(int i) { + return getRuleContext(TestContext.class,i); + } + public List star_expr() { + return getRuleContexts(Star_exprContext.class); + } + public Star_exprContext star_expr(int i) { + return getRuleContext(Star_exprContext.class,i); + } + public List COMMA() { return getTokens(Python3Parser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(Python3Parser.COMMA, i); + } + public Testlist_star_exprContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_testlist_star_expr; } + } + + public final Testlist_star_exprContext testlist_star_expr() throws RecognitionException { + Testlist_star_exprContext _localctx = new Testlist_star_exprContext(_ctx, getState()); + enterRule(_localctx, 36, RULE_testlist_star_expr); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(465); + _errHandler.sync(this); + switch (_input.LA(1)) { + case STRING: + case NUMBER: + case LAMBDA: + case NOT: + case NONE: + case TRUE: + case FALSE: + case AWAIT: + case NAME: + case ELLIPSIS: + case OPEN_PAREN: + case OPEN_BRACK: + case ADD: + case MINUS: + case NOT_OP: + case OPEN_BRACE: + { + setState(463); + test(); + } + break; + case STAR: + { + setState(464); + star_expr(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(474); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,62,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(467); + match(COMMA); + setState(470); + _errHandler.sync(this); + switch (_input.LA(1)) { + case STRING: + case NUMBER: + case LAMBDA: + case NOT: + case NONE: + case TRUE: + case FALSE: + case AWAIT: + case NAME: + case ELLIPSIS: + case OPEN_PAREN: + case OPEN_BRACK: + case ADD: + case MINUS: + case NOT_OP: + case OPEN_BRACE: + { + setState(468); + test(); + } + break; + case STAR: + { + setState(469); + star_expr(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + } + setState(476); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,62,_ctx); + } + setState(478); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(477); + match(COMMA); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AugassignContext extends ParserRuleContext { + public TerminalNode ADD_ASSIGN() { return getToken(Python3Parser.ADD_ASSIGN, 0); } + public TerminalNode SUB_ASSIGN() { return getToken(Python3Parser.SUB_ASSIGN, 0); } + public TerminalNode MULT_ASSIGN() { return getToken(Python3Parser.MULT_ASSIGN, 0); } + public TerminalNode AT_ASSIGN() { return getToken(Python3Parser.AT_ASSIGN, 0); } + public TerminalNode DIV_ASSIGN() { return getToken(Python3Parser.DIV_ASSIGN, 0); } + public TerminalNode MOD_ASSIGN() { return getToken(Python3Parser.MOD_ASSIGN, 0); } + public TerminalNode AND_ASSIGN() { return getToken(Python3Parser.AND_ASSIGN, 0); } + public TerminalNode OR_ASSIGN() { return getToken(Python3Parser.OR_ASSIGN, 0); } + public TerminalNode XOR_ASSIGN() { return getToken(Python3Parser.XOR_ASSIGN, 0); } + public TerminalNode LEFT_SHIFT_ASSIGN() { return getToken(Python3Parser.LEFT_SHIFT_ASSIGN, 0); } + public TerminalNode RIGHT_SHIFT_ASSIGN() { return getToken(Python3Parser.RIGHT_SHIFT_ASSIGN, 0); } + public TerminalNode POWER_ASSIGN() { return getToken(Python3Parser.POWER_ASSIGN, 0); } + public TerminalNode IDIV_ASSIGN() { return getToken(Python3Parser.IDIV_ASSIGN, 0); } + public AugassignContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_augassign; } + } + + public final AugassignContext augassign() throws RecognitionException { + AugassignContext _localctx = new AugassignContext(_ctx, getState()); + enterRule(_localctx, 38, RULE_augassign); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(480); + _la = _input.LA(1); + if ( !(((((_la - 83)) & ~0x3f) == 0 && ((1L << (_la - 83)) & ((1L << (ADD_ASSIGN - 83)) | (1L << (SUB_ASSIGN - 83)) | (1L << (MULT_ASSIGN - 83)) | (1L << (AT_ASSIGN - 83)) | (1L << (DIV_ASSIGN - 83)) | (1L << (MOD_ASSIGN - 83)) | (1L << (AND_ASSIGN - 83)) | (1L << (OR_ASSIGN - 83)) | (1L << (XOR_ASSIGN - 83)) | (1L << (LEFT_SHIFT_ASSIGN - 83)) | (1L << (RIGHT_SHIFT_ASSIGN - 83)) | (1L << (POWER_ASSIGN - 83)) | (1L << (IDIV_ASSIGN - 83)))) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Del_stmtContext extends ParserRuleContext { + public TerminalNode DEL() { return getToken(Python3Parser.DEL, 0); } + public ExprlistContext exprlist() { + return getRuleContext(ExprlistContext.class,0); + } + public Del_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_del_stmt; } + } + + public final Del_stmtContext del_stmt() throws RecognitionException { + Del_stmtContext _localctx = new Del_stmtContext(_ctx, getState()); + enterRule(_localctx, 40, RULE_del_stmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(482); + match(DEL); + setState(483); + exprlist(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Pass_stmtContext extends ParserRuleContext { + public TerminalNode PASS() { return getToken(Python3Parser.PASS, 0); } + public Pass_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_pass_stmt; } + } + + public final Pass_stmtContext pass_stmt() throws RecognitionException { + Pass_stmtContext _localctx = new Pass_stmtContext(_ctx, getState()); + enterRule(_localctx, 42, RULE_pass_stmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(485); + match(PASS); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Flow_stmtContext extends ParserRuleContext { + public Break_stmtContext break_stmt() { + return getRuleContext(Break_stmtContext.class,0); + } + public Continue_stmtContext continue_stmt() { + return getRuleContext(Continue_stmtContext.class,0); + } + public Return_stmtContext return_stmt() { + return getRuleContext(Return_stmtContext.class,0); + } + public Raise_stmtContext raise_stmt() { + return getRuleContext(Raise_stmtContext.class,0); + } + public Yield_stmtContext yield_stmt() { + return getRuleContext(Yield_stmtContext.class,0); + } + public Flow_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_flow_stmt; } + } + + public final Flow_stmtContext flow_stmt() throws RecognitionException { + Flow_stmtContext _localctx = new Flow_stmtContext(_ctx, getState()); + enterRule(_localctx, 44, RULE_flow_stmt); + try { + setState(492); + _errHandler.sync(this); + switch (_input.LA(1)) { + case BREAK: + enterOuterAlt(_localctx, 1); + { + setState(487); + break_stmt(); + } + break; + case CONTINUE: + enterOuterAlt(_localctx, 2); + { + setState(488); + continue_stmt(); + } + break; + case RETURN: + enterOuterAlt(_localctx, 3); + { + setState(489); + return_stmt(); + } + break; + case RAISE: + enterOuterAlt(_localctx, 4); + { + setState(490); + raise_stmt(); + } + break; + case YIELD: + enterOuterAlt(_localctx, 5); + { + setState(491); + yield_stmt(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Break_stmtContext extends ParserRuleContext { + public TerminalNode BREAK() { return getToken(Python3Parser.BREAK, 0); } + public Break_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_break_stmt; } + } + + public final Break_stmtContext break_stmt() throws RecognitionException { + Break_stmtContext _localctx = new Break_stmtContext(_ctx, getState()); + enterRule(_localctx, 46, RULE_break_stmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(494); + match(BREAK); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Continue_stmtContext extends ParserRuleContext { + public TerminalNode CONTINUE() { return getToken(Python3Parser.CONTINUE, 0); } + public Continue_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_continue_stmt; } + } + + public final Continue_stmtContext continue_stmt() throws RecognitionException { + Continue_stmtContext _localctx = new Continue_stmtContext(_ctx, getState()); + enterRule(_localctx, 48, RULE_continue_stmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(496); + match(CONTINUE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Return_stmtContext extends ParserRuleContext { + public TerminalNode RETURN() { return getToken(Python3Parser.RETURN, 0); } + public TestlistContext testlist() { + return getRuleContext(TestlistContext.class,0); + } + public Return_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_return_stmt; } + } + + public final Return_stmtContext return_stmt() throws RecognitionException { + Return_stmtContext _localctx = new Return_stmtContext(_ctx, getState()); + enterRule(_localctx, 50, RULE_return_stmt); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(498); + match(RETURN); + setState(500); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << OPEN_PAREN) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) { + { + setState(499); + testlist(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Yield_stmtContext extends ParserRuleContext { + public Yield_exprContext yield_expr() { + return getRuleContext(Yield_exprContext.class,0); + } + public Yield_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_yield_stmt; } + } + + public final Yield_stmtContext yield_stmt() throws RecognitionException { + Yield_stmtContext _localctx = new Yield_stmtContext(_ctx, getState()); + enterRule(_localctx, 52, RULE_yield_stmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(502); + yield_expr(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Raise_stmtContext extends ParserRuleContext { + public TerminalNode RAISE() { return getToken(Python3Parser.RAISE, 0); } + public List test() { + return getRuleContexts(TestContext.class); + } + public TestContext test(int i) { + return getRuleContext(TestContext.class,i); + } + public TerminalNode FROM() { return getToken(Python3Parser.FROM, 0); } + public Raise_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_raise_stmt; } + } + + public final Raise_stmtContext raise_stmt() throws RecognitionException { + Raise_stmtContext _localctx = new Raise_stmtContext(_ctx, getState()); + enterRule(_localctx, 54, RULE_raise_stmt); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(504); + match(RAISE); + setState(510); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << OPEN_PAREN) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) { + { + setState(505); + test(); + setState(508); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FROM) { + { + setState(506); + match(FROM); + setState(507); + test(); + } + } + + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Import_stmtContext extends ParserRuleContext { + public Import_nameContext import_name() { + return getRuleContext(Import_nameContext.class,0); + } + public Import_fromContext import_from() { + return getRuleContext(Import_fromContext.class,0); + } + public Import_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_import_stmt; } + } + + public final Import_stmtContext import_stmt() throws RecognitionException { + Import_stmtContext _localctx = new Import_stmtContext(_ctx, getState()); + enterRule(_localctx, 56, RULE_import_stmt); + try { + setState(514); + _errHandler.sync(this); + switch (_input.LA(1)) { + case IMPORT: + enterOuterAlt(_localctx, 1); + { + setState(512); + import_name(); + } + break; + case FROM: + enterOuterAlt(_localctx, 2); + { + setState(513); + import_from(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Import_nameContext extends ParserRuleContext { + public TerminalNode IMPORT() { return getToken(Python3Parser.IMPORT, 0); } + public Dotted_as_namesContext dotted_as_names() { + return getRuleContext(Dotted_as_namesContext.class,0); + } + public Import_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_import_name; } + } + + public final Import_nameContext import_name() throws RecognitionException { + Import_nameContext _localctx = new Import_nameContext(_ctx, getState()); + enterRule(_localctx, 58, RULE_import_name); + try { + enterOuterAlt(_localctx, 1); + { + setState(516); + match(IMPORT); + setState(517); + dotted_as_names(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Import_fromContext extends ParserRuleContext { + public TerminalNode FROM() { return getToken(Python3Parser.FROM, 0); } + public TerminalNode IMPORT() { return getToken(Python3Parser.IMPORT, 0); } + public Dotted_nameContext dotted_name() { + return getRuleContext(Dotted_nameContext.class,0); + } + public TerminalNode STAR() { return getToken(Python3Parser.STAR, 0); } + public TerminalNode OPEN_PAREN() { return getToken(Python3Parser.OPEN_PAREN, 0); } + public Import_as_namesContext import_as_names() { + return getRuleContext(Import_as_namesContext.class,0); + } + public TerminalNode CLOSE_PAREN() { return getToken(Python3Parser.CLOSE_PAREN, 0); } + public List DOT() { return getTokens(Python3Parser.DOT); } + public TerminalNode DOT(int i) { + return getToken(Python3Parser.DOT, i); + } + public List ELLIPSIS() { return getTokens(Python3Parser.ELLIPSIS); } + public TerminalNode ELLIPSIS(int i) { + return getToken(Python3Parser.ELLIPSIS, i); + } + public Import_fromContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_import_from; } + } + + public final Import_fromContext import_from() throws RecognitionException { + Import_fromContext _localctx = new Import_fromContext(_ctx, getState()); + enterRule(_localctx, 60, RULE_import_from); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + { + setState(519); + match(FROM); + setState(532); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,71,_ctx) ) { + case 1: + { + setState(523); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==DOT || _la==ELLIPSIS) { + { + { + setState(520); + _la = _input.LA(1); + if ( !(_la==DOT || _la==ELLIPSIS) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + setState(525); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(526); + dotted_name(); + } + break; + case 2: + { + setState(528); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(527); + _la = _input.LA(1); + if ( !(_la==DOT || _la==ELLIPSIS) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + setState(530); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==DOT || _la==ELLIPSIS ); + } + break; + } + setState(534); + match(IMPORT); + setState(541); + _errHandler.sync(this); + switch (_input.LA(1)) { + case STAR: + { + setState(535); + match(STAR); + } + break; + case OPEN_PAREN: + { + setState(536); + match(OPEN_PAREN); + setState(537); + import_as_names(); + setState(538); + match(CLOSE_PAREN); + } + break; + case NAME: + { + setState(540); + import_as_names(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Import_as_nameContext extends ParserRuleContext { + public List NAME() { return getTokens(Python3Parser.NAME); } + public TerminalNode NAME(int i) { + return getToken(Python3Parser.NAME, i); + } + public TerminalNode AS() { return getToken(Python3Parser.AS, 0); } + public Import_as_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_import_as_name; } + } + + public final Import_as_nameContext import_as_name() throws RecognitionException { + Import_as_nameContext _localctx = new Import_as_nameContext(_ctx, getState()); + enterRule(_localctx, 62, RULE_import_as_name); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(543); + match(NAME); + setState(546); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AS) { + { + setState(544); + match(AS); + setState(545); + match(NAME); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Dotted_as_nameContext extends ParserRuleContext { + public Dotted_nameContext dotted_name() { + return getRuleContext(Dotted_nameContext.class,0); + } + public TerminalNode AS() { return getToken(Python3Parser.AS, 0); } + public TerminalNode NAME() { return getToken(Python3Parser.NAME, 0); } + public Dotted_as_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dotted_as_name; } + } + + public final Dotted_as_nameContext dotted_as_name() throws RecognitionException { + Dotted_as_nameContext _localctx = new Dotted_as_nameContext(_ctx, getState()); + enterRule(_localctx, 64, RULE_dotted_as_name); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(548); + dotted_name(); + setState(551); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AS) { + { + setState(549); + match(AS); + setState(550); + match(NAME); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Import_as_namesContext extends ParserRuleContext { + public List import_as_name() { + return getRuleContexts(Import_as_nameContext.class); + } + public Import_as_nameContext import_as_name(int i) { + return getRuleContext(Import_as_nameContext.class,i); + } + public List COMMA() { return getTokens(Python3Parser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(Python3Parser.COMMA, i); + } + public Import_as_namesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_import_as_names; } + } + + public final Import_as_namesContext import_as_names() throws RecognitionException { + Import_as_namesContext _localctx = new Import_as_namesContext(_ctx, getState()); + enterRule(_localctx, 66, RULE_import_as_names); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(553); + import_as_name(); + setState(558); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,75,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(554); + match(COMMA); + setState(555); + import_as_name(); + } + } + } + setState(560); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,75,_ctx); + } + setState(562); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(561); + match(COMMA); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Dotted_as_namesContext extends ParserRuleContext { + public List dotted_as_name() { + return getRuleContexts(Dotted_as_nameContext.class); + } + public Dotted_as_nameContext dotted_as_name(int i) { + return getRuleContext(Dotted_as_nameContext.class,i); + } + public List COMMA() { return getTokens(Python3Parser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(Python3Parser.COMMA, i); + } + public Dotted_as_namesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dotted_as_names; } + } + + public final Dotted_as_namesContext dotted_as_names() throws RecognitionException { + Dotted_as_namesContext _localctx = new Dotted_as_namesContext(_ctx, getState()); + enterRule(_localctx, 68, RULE_dotted_as_names); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(564); + dotted_as_name(); + setState(569); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(565); + match(COMMA); + setState(566); + dotted_as_name(); + } + } + setState(571); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Dotted_nameContext extends ParserRuleContext { + public List NAME() { return getTokens(Python3Parser.NAME); } + public TerminalNode NAME(int i) { + return getToken(Python3Parser.NAME, i); + } + public List DOT() { return getTokens(Python3Parser.DOT); } + public TerminalNode DOT(int i) { + return getToken(Python3Parser.DOT, i); + } + public Dotted_nameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dotted_name; } + } + + public final Dotted_nameContext dotted_name() throws RecognitionException { + Dotted_nameContext _localctx = new Dotted_nameContext(_ctx, getState()); + enterRule(_localctx, 70, RULE_dotted_name); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(572); + match(NAME); + setState(577); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==DOT) { + { + { + setState(573); + match(DOT); + setState(574); + match(NAME); + } + } + setState(579); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Global_stmtContext extends ParserRuleContext { + public TerminalNode GLOBAL() { return getToken(Python3Parser.GLOBAL, 0); } + public List NAME() { return getTokens(Python3Parser.NAME); } + public TerminalNode NAME(int i) { + return getToken(Python3Parser.NAME, i); + } + public List COMMA() { return getTokens(Python3Parser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(Python3Parser.COMMA, i); + } + public Global_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_global_stmt; } + } + + public final Global_stmtContext global_stmt() throws RecognitionException { + Global_stmtContext _localctx = new Global_stmtContext(_ctx, getState()); + enterRule(_localctx, 72, RULE_global_stmt); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(580); + match(GLOBAL); + setState(581); + match(NAME); + setState(586); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(582); + match(COMMA); + setState(583); + match(NAME); + } + } + setState(588); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Nonlocal_stmtContext extends ParserRuleContext { + public TerminalNode NONLOCAL() { return getToken(Python3Parser.NONLOCAL, 0); } + public List NAME() { return getTokens(Python3Parser.NAME); } + public TerminalNode NAME(int i) { + return getToken(Python3Parser.NAME, i); + } + public List COMMA() { return getTokens(Python3Parser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(Python3Parser.COMMA, i); + } + public Nonlocal_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_nonlocal_stmt; } + } + + public final Nonlocal_stmtContext nonlocal_stmt() throws RecognitionException { + Nonlocal_stmtContext _localctx = new Nonlocal_stmtContext(_ctx, getState()); + enterRule(_localctx, 74, RULE_nonlocal_stmt); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(589); + match(NONLOCAL); + setState(590); + match(NAME); + setState(595); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(591); + match(COMMA); + setState(592); + match(NAME); + } + } + setState(597); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Assert_stmtContext extends ParserRuleContext { + public TerminalNode ASSERT() { return getToken(Python3Parser.ASSERT, 0); } + public List test() { + return getRuleContexts(TestContext.class); + } + public TestContext test(int i) { + return getRuleContext(TestContext.class,i); + } + public TerminalNode COMMA() { return getToken(Python3Parser.COMMA, 0); } + public Assert_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assert_stmt; } + } + + public final Assert_stmtContext assert_stmt() throws RecognitionException { + Assert_stmtContext _localctx = new Assert_stmtContext(_ctx, getState()); + enterRule(_localctx, 76, RULE_assert_stmt); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(598); + match(ASSERT); + setState(599); + test(); + setState(602); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(600); + match(COMMA); + setState(601); + test(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Compound_stmtContext extends ParserRuleContext { + public If_stmtContext if_stmt() { + return getRuleContext(If_stmtContext.class,0); + } + public While_stmtContext while_stmt() { + return getRuleContext(While_stmtContext.class,0); + } + public For_stmtContext for_stmt() { + return getRuleContext(For_stmtContext.class,0); + } + public Try_stmtContext try_stmt() { + return getRuleContext(Try_stmtContext.class,0); + } + public With_stmtContext with_stmt() { + return getRuleContext(With_stmtContext.class,0); + } + public FuncdefContext funcdef() { + return getRuleContext(FuncdefContext.class,0); + } + public ClassdefContext classdef() { + return getRuleContext(ClassdefContext.class,0); + } + public DecoratedContext decorated() { + return getRuleContext(DecoratedContext.class,0); + } + public Async_stmtContext async_stmt() { + return getRuleContext(Async_stmtContext.class,0); + } + public Compound_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_compound_stmt; } + } + + public final Compound_stmtContext compound_stmt() throws RecognitionException { + Compound_stmtContext _localctx = new Compound_stmtContext(_ctx, getState()); + enterRule(_localctx, 78, RULE_compound_stmt); + try { + setState(613); + _errHandler.sync(this); + switch (_input.LA(1)) { + case IF: + enterOuterAlt(_localctx, 1); + { + setState(604); + if_stmt(); + } + break; + case WHILE: + enterOuterAlt(_localctx, 2); + { + setState(605); + while_stmt(); + } + break; + case FOR: + enterOuterAlt(_localctx, 3); + { + setState(606); + for_stmt(); + } + break; + case TRY: + enterOuterAlt(_localctx, 4); + { + setState(607); + try_stmt(); + } + break; + case WITH: + enterOuterAlt(_localctx, 5); + { + setState(608); + with_stmt(); + } + break; + case DEF: + enterOuterAlt(_localctx, 6); + { + setState(609); + funcdef(); + } + break; + case CLASS: + enterOuterAlt(_localctx, 7); + { + setState(610); + classdef(); + } + break; + case AT: + enterOuterAlt(_localctx, 8); + { + setState(611); + decorated(); + } + break; + case ASYNC: + enterOuterAlt(_localctx, 9); + { + setState(612); + async_stmt(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Async_stmtContext extends ParserRuleContext { + public TerminalNode ASYNC() { return getToken(Python3Parser.ASYNC, 0); } + public FuncdefContext funcdef() { + return getRuleContext(FuncdefContext.class,0); + } + public With_stmtContext with_stmt() { + return getRuleContext(With_stmtContext.class,0); + } + public For_stmtContext for_stmt() { + return getRuleContext(For_stmtContext.class,0); + } + public Async_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_async_stmt; } + } + + public final Async_stmtContext async_stmt() throws RecognitionException { + Async_stmtContext _localctx = new Async_stmtContext(_ctx, getState()); + enterRule(_localctx, 80, RULE_async_stmt); + try { + enterOuterAlt(_localctx, 1); + { + setState(615); + match(ASYNC); + setState(619); + _errHandler.sync(this); + switch (_input.LA(1)) { + case DEF: + { + setState(616); + funcdef(); + } + break; + case WITH: + { + setState(617); + with_stmt(); + } + break; + case FOR: + { + setState(618); + for_stmt(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class If_stmtContext extends ParserRuleContext { + public TerminalNode IF() { return getToken(Python3Parser.IF, 0); } + public List test() { + return getRuleContexts(TestContext.class); + } + public TestContext test(int i) { + return getRuleContext(TestContext.class,i); + } + public List COLON() { return getTokens(Python3Parser.COLON); } + public TerminalNode COLON(int i) { + return getToken(Python3Parser.COLON, i); + } + public List suite() { + return getRuleContexts(SuiteContext.class); + } + public SuiteContext suite(int i) { + return getRuleContext(SuiteContext.class,i); + } + public List ELIF() { return getTokens(Python3Parser.ELIF); } + public TerminalNode ELIF(int i) { + return getToken(Python3Parser.ELIF, i); + } + public TerminalNode ELSE() { return getToken(Python3Parser.ELSE, 0); } + public If_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_if_stmt; } + } + + public final If_stmtContext if_stmt() throws RecognitionException { + If_stmtContext _localctx = new If_stmtContext(_ctx, getState()); + enterRule(_localctx, 82, RULE_if_stmt); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(621); + match(IF); + setState(622); + test(); + setState(623); + match(COLON); + setState(624); + suite(); + setState(632); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==ELIF) { + { + { + setState(625); + match(ELIF); + setState(626); + test(); + setState(627); + match(COLON); + setState(628); + suite(); + } + } + setState(634); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(638); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ELSE) { + { + setState(635); + match(ELSE); + setState(636); + match(COLON); + setState(637); + suite(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class While_stmtContext extends ParserRuleContext { + public TerminalNode WHILE() { return getToken(Python3Parser.WHILE, 0); } + public TestContext test() { + return getRuleContext(TestContext.class,0); + } + public List COLON() { return getTokens(Python3Parser.COLON); } + public TerminalNode COLON(int i) { + return getToken(Python3Parser.COLON, i); + } + public List suite() { + return getRuleContexts(SuiteContext.class); + } + public SuiteContext suite(int i) { + return getRuleContext(SuiteContext.class,i); + } + public TerminalNode ELSE() { return getToken(Python3Parser.ELSE, 0); } + public While_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_while_stmt; } + } + + public final While_stmtContext while_stmt() throws RecognitionException { + While_stmtContext _localctx = new While_stmtContext(_ctx, getState()); + enterRule(_localctx, 84, RULE_while_stmt); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(640); + match(WHILE); + setState(641); + test(); + setState(642); + match(COLON); + setState(643); + suite(); + setState(647); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ELSE) { + { + setState(644); + match(ELSE); + setState(645); + match(COLON); + setState(646); + suite(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class For_stmtContext extends ParserRuleContext { + public TerminalNode FOR() { return getToken(Python3Parser.FOR, 0); } + public ExprlistContext exprlist() { + return getRuleContext(ExprlistContext.class,0); + } + public TerminalNode IN() { return getToken(Python3Parser.IN, 0); } + public TestlistContext testlist() { + return getRuleContext(TestlistContext.class,0); + } + public List COLON() { return getTokens(Python3Parser.COLON); } + public TerminalNode COLON(int i) { + return getToken(Python3Parser.COLON, i); + } + public List suite() { + return getRuleContexts(SuiteContext.class); + } + public SuiteContext suite(int i) { + return getRuleContext(SuiteContext.class,i); + } + public TerminalNode ELSE() { return getToken(Python3Parser.ELSE, 0); } + public For_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_for_stmt; } + } + + public final For_stmtContext for_stmt() throws RecognitionException { + For_stmtContext _localctx = new For_stmtContext(_ctx, getState()); + enterRule(_localctx, 86, RULE_for_stmt); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(649); + match(FOR); + setState(650); + exprlist(); + setState(651); + match(IN); + setState(652); + testlist(); + setState(653); + match(COLON); + setState(654); + suite(); + setState(658); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ELSE) { + { + setState(655); + match(ELSE); + setState(656); + match(COLON); + setState(657); + suite(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Try_stmtContext extends ParserRuleContext { + public TerminalNode TRY() { return getToken(Python3Parser.TRY, 0); } + public List COLON() { return getTokens(Python3Parser.COLON); } + public TerminalNode COLON(int i) { + return getToken(Python3Parser.COLON, i); + } + public List suite() { + return getRuleContexts(SuiteContext.class); + } + public SuiteContext suite(int i) { + return getRuleContext(SuiteContext.class,i); + } + public TerminalNode FINALLY() { return getToken(Python3Parser.FINALLY, 0); } + public List except_clause() { + return getRuleContexts(Except_clauseContext.class); + } + public Except_clauseContext except_clause(int i) { + return getRuleContext(Except_clauseContext.class,i); + } + public TerminalNode ELSE() { return getToken(Python3Parser.ELSE, 0); } + public Try_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_try_stmt; } + } + + public final Try_stmtContext try_stmt() throws RecognitionException { + Try_stmtContext _localctx = new Try_stmtContext(_ctx, getState()); + enterRule(_localctx, 88, RULE_try_stmt); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + { + setState(660); + match(TRY); + setState(661); + match(COLON); + setState(662); + suite(); + setState(684); + _errHandler.sync(this); + switch (_input.LA(1)) { + case EXCEPT: + { + setState(667); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(663); + except_clause(); + setState(664); + match(COLON); + setState(665); + suite(); + } + } + setState(669); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==EXCEPT ); + setState(674); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ELSE) { + { + setState(671); + match(ELSE); + setState(672); + match(COLON); + setState(673); + suite(); + } + } + + setState(679); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FINALLY) { + { + setState(676); + match(FINALLY); + setState(677); + match(COLON); + setState(678); + suite(); + } + } + + } + break; + case FINALLY: + { + setState(681); + match(FINALLY); + setState(682); + match(COLON); + setState(683); + suite(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class With_stmtContext extends ParserRuleContext { + public TerminalNode WITH() { return getToken(Python3Parser.WITH, 0); } + public List with_item() { + return getRuleContexts(With_itemContext.class); + } + public With_itemContext with_item(int i) { + return getRuleContext(With_itemContext.class,i); + } + public TerminalNode COLON() { return getToken(Python3Parser.COLON, 0); } + public SuiteContext suite() { + return getRuleContext(SuiteContext.class,0); + } + public List COMMA() { return getTokens(Python3Parser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(Python3Parser.COMMA, i); + } + public With_stmtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_with_stmt; } + } + + public final With_stmtContext with_stmt() throws RecognitionException { + With_stmtContext _localctx = new With_stmtContext(_ctx, getState()); + enterRule(_localctx, 90, RULE_with_stmt); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(686); + match(WITH); + setState(687); + with_item(); + setState(692); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(688); + match(COMMA); + setState(689); + with_item(); + } + } + setState(694); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(695); + match(COLON); + setState(696); + suite(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class With_itemContext extends ParserRuleContext { + public TestContext test() { + return getRuleContext(TestContext.class,0); + } + public TerminalNode AS() { return getToken(Python3Parser.AS, 0); } + public ExprContext expr() { + return getRuleContext(ExprContext.class,0); + } + public With_itemContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_with_item; } + } + + public final With_itemContext with_item() throws RecognitionException { + With_itemContext _localctx = new With_itemContext(_ctx, getState()); + enterRule(_localctx, 92, RULE_with_item); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(698); + test(); + setState(701); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AS) { + { + setState(699); + match(AS); + setState(700); + expr(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Except_clauseContext extends ParserRuleContext { + public TerminalNode EXCEPT() { return getToken(Python3Parser.EXCEPT, 0); } + public TestContext test() { + return getRuleContext(TestContext.class,0); + } + public TerminalNode AS() { return getToken(Python3Parser.AS, 0); } + public TerminalNode NAME() { return getToken(Python3Parser.NAME, 0); } + public Except_clauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_except_clause; } + } + + public final Except_clauseContext except_clause() throws RecognitionException { + Except_clauseContext _localctx = new Except_clauseContext(_ctx, getState()); + enterRule(_localctx, 94, RULE_except_clause); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(703); + match(EXCEPT); + setState(709); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << OPEN_PAREN) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) { + { + setState(704); + test(); + setState(707); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AS) { + { + setState(705); + match(AS); + setState(706); + match(NAME); + } + } + + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SuiteContext extends ParserRuleContext { + public Simple_stmtContext simple_stmt() { + return getRuleContext(Simple_stmtContext.class,0); + } + public TerminalNode NEWLINE() { return getToken(Python3Parser.NEWLINE, 0); } + public TerminalNode INDENT() { return getToken(Python3Parser.INDENT, 0); } + public TerminalNode DEDENT() { return getToken(Python3Parser.DEDENT, 0); } + public List stmt() { + return getRuleContexts(StmtContext.class); + } + public StmtContext stmt(int i) { + return getRuleContext(StmtContext.class,i); + } + public SuiteContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_suite; } + } + + public final SuiteContext suite() throws RecognitionException { + SuiteContext _localctx = new SuiteContext(_ctx, getState()); + enterRule(_localctx, 96, RULE_suite); + int _la; + try { + setState(721); + _errHandler.sync(this); + switch (_input.LA(1)) { + case STRING: + case NUMBER: + case RETURN: + case RAISE: + case FROM: + case IMPORT: + case GLOBAL: + case NONLOCAL: + case ASSERT: + case LAMBDA: + case NOT: + case NONE: + case TRUE: + case FALSE: + case YIELD: + case DEL: + case PASS: + case CONTINUE: + case BREAK: + case AWAIT: + case NAME: + case ELLIPSIS: + case STAR: + case OPEN_PAREN: + case OPEN_BRACK: + case ADD: + case MINUS: + case NOT_OP: + case OPEN_BRACE: + enterOuterAlt(_localctx, 1); + { + setState(711); + simple_stmt(); + } + break; + case NEWLINE: + enterOuterAlt(_localctx, 2); + { + setState(712); + match(NEWLINE); + setState(713); + match(INDENT); + setState(715); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(714); + stmt(); + } + } + setState(717); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << DEF) | (1L << RETURN) | (1L << RAISE) | (1L << FROM) | (1L << IMPORT) | (1L << GLOBAL) | (1L << NONLOCAL) | (1L << ASSERT) | (1L << IF) | (1L << WHILE) | (1L << FOR) | (1L << TRY) | (1L << WITH) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << CLASS) | (1L << YIELD) | (1L << DEL) | (1L << PASS) | (1L << CONTINUE) | (1L << BREAK) | (1L << ASYNC) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << STAR) | (1L << OPEN_PAREN) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)) | (1L << (AT - 66)))) != 0) ); + setState(719); + match(DEDENT); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TestContext extends ParserRuleContext { + public List or_test() { + return getRuleContexts(Or_testContext.class); + } + public Or_testContext or_test(int i) { + return getRuleContext(Or_testContext.class,i); + } + public TerminalNode IF() { return getToken(Python3Parser.IF, 0); } + public TerminalNode ELSE() { return getToken(Python3Parser.ELSE, 0); } + public TestContext test() { + return getRuleContext(TestContext.class,0); + } + public LambdefContext lambdef() { + return getRuleContext(LambdefContext.class,0); + } + public TestContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_test; } + } + + public final TestContext test() throws RecognitionException { + TestContext _localctx = new TestContext(_ctx, getState()); + enterRule(_localctx, 98, RULE_test); + int _la; + try { + setState(732); + _errHandler.sync(this); + switch (_input.LA(1)) { + case STRING: + case NUMBER: + case NOT: + case NONE: + case TRUE: + case FALSE: + case AWAIT: + case NAME: + case ELLIPSIS: + case OPEN_PAREN: + case OPEN_BRACK: + case ADD: + case MINUS: + case NOT_OP: + case OPEN_BRACE: + enterOuterAlt(_localctx, 1); + { + setState(723); + or_test(); + setState(729); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IF) { + { + setState(724); + match(IF); + setState(725); + or_test(); + setState(726); + match(ELSE); + setState(727); + test(); + } + } + + } + break; + case LAMBDA: + enterOuterAlt(_localctx, 2); + { + setState(731); + lambdef(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Test_nocondContext extends ParserRuleContext { + public Or_testContext or_test() { + return getRuleContext(Or_testContext.class,0); + } + public Lambdef_nocondContext lambdef_nocond() { + return getRuleContext(Lambdef_nocondContext.class,0); + } + public Test_nocondContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_test_nocond; } + } + + public final Test_nocondContext test_nocond() throws RecognitionException { + Test_nocondContext _localctx = new Test_nocondContext(_ctx, getState()); + enterRule(_localctx, 100, RULE_test_nocond); + try { + setState(736); + _errHandler.sync(this); + switch (_input.LA(1)) { + case STRING: + case NUMBER: + case NOT: + case NONE: + case TRUE: + case FALSE: + case AWAIT: + case NAME: + case ELLIPSIS: + case OPEN_PAREN: + case OPEN_BRACK: + case ADD: + case MINUS: + case NOT_OP: + case OPEN_BRACE: + enterOuterAlt(_localctx, 1); + { + setState(734); + or_test(); + } + break; + case LAMBDA: + enterOuterAlt(_localctx, 2); + { + setState(735); + lambdef_nocond(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LambdefContext extends ParserRuleContext { + public TerminalNode LAMBDA() { return getToken(Python3Parser.LAMBDA, 0); } + public TerminalNode COLON() { return getToken(Python3Parser.COLON, 0); } + public TestContext test() { + return getRuleContext(TestContext.class,0); + } + public VarargslistContext varargslist() { + return getRuleContext(VarargslistContext.class,0); + } + public LambdefContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_lambdef; } + } + + public final LambdefContext lambdef() throws RecognitionException { + LambdefContext _localctx = new LambdefContext(_ctx, getState()); + enterRule(_localctx, 102, RULE_lambdef); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(738); + match(LAMBDA); + setState(740); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NAME) | (1L << STAR) | (1L << POWER))) != 0)) { + { + setState(739); + varargslist(); + } + } + + setState(742); + match(COLON); + setState(743); + test(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Lambdef_nocondContext extends ParserRuleContext { + public TerminalNode LAMBDA() { return getToken(Python3Parser.LAMBDA, 0); } + public TerminalNode COLON() { return getToken(Python3Parser.COLON, 0); } + public Test_nocondContext test_nocond() { + return getRuleContext(Test_nocondContext.class,0); + } + public VarargslistContext varargslist() { + return getRuleContext(VarargslistContext.class,0); + } + public Lambdef_nocondContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_lambdef_nocond; } + } + + public final Lambdef_nocondContext lambdef_nocond() throws RecognitionException { + Lambdef_nocondContext _localctx = new Lambdef_nocondContext(_ctx, getState()); + enterRule(_localctx, 104, RULE_lambdef_nocond); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(745); + match(LAMBDA); + setState(747); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NAME) | (1L << STAR) | (1L << POWER))) != 0)) { + { + setState(746); + varargslist(); + } + } + + setState(749); + match(COLON); + setState(750); + test_nocond(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Or_testContext extends ParserRuleContext { + public List and_test() { + return getRuleContexts(And_testContext.class); + } + public And_testContext and_test(int i) { + return getRuleContext(And_testContext.class,i); + } + public List OR() { return getTokens(Python3Parser.OR); } + public TerminalNode OR(int i) { + return getToken(Python3Parser.OR, i); + } + public Or_testContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_or_test; } + } + + public final Or_testContext or_test() throws RecognitionException { + Or_testContext _localctx = new Or_testContext(_ctx, getState()); + enterRule(_localctx, 106, RULE_or_test); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(752); + and_test(); + setState(757); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==OR) { + { + { + setState(753); + match(OR); + setState(754); + and_test(); + } + } + setState(759); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class And_testContext extends ParserRuleContext { + public List not_test() { + return getRuleContexts(Not_testContext.class); + } + public Not_testContext not_test(int i) { + return getRuleContext(Not_testContext.class,i); + } + public List AND() { return getTokens(Python3Parser.AND); } + public TerminalNode AND(int i) { + return getToken(Python3Parser.AND, i); + } + public And_testContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_and_test; } + } + + public final And_testContext and_test() throws RecognitionException { + And_testContext _localctx = new And_testContext(_ctx, getState()); + enterRule(_localctx, 108, RULE_and_test); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(760); + not_test(); + setState(765); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AND) { + { + { + setState(761); + match(AND); + setState(762); + not_test(); + } + } + setState(767); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Not_testContext extends ParserRuleContext { + public TerminalNode NOT() { return getToken(Python3Parser.NOT, 0); } + public Not_testContext not_test() { + return getRuleContext(Not_testContext.class,0); + } + public ComparisonContext comparison() { + return getRuleContext(ComparisonContext.class,0); + } + public Not_testContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_not_test; } + } + + public final Not_testContext not_test() throws RecognitionException { + Not_testContext _localctx = new Not_testContext(_ctx, getState()); + enterRule(_localctx, 110, RULE_not_test); + try { + setState(771); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NOT: + enterOuterAlt(_localctx, 1); + { + setState(768); + match(NOT); + setState(769); + not_test(); + } + break; + case STRING: + case NUMBER: + case NONE: + case TRUE: + case FALSE: + case AWAIT: + case NAME: + case ELLIPSIS: + case OPEN_PAREN: + case OPEN_BRACK: + case ADD: + case MINUS: + case NOT_OP: + case OPEN_BRACE: + enterOuterAlt(_localctx, 2); + { + setState(770); + comparison(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ComparisonContext extends ParserRuleContext { + public List expr() { + return getRuleContexts(ExprContext.class); + } + public ExprContext expr(int i) { + return getRuleContext(ExprContext.class,i); + } + public List comp_op() { + return getRuleContexts(Comp_opContext.class); + } + public Comp_opContext comp_op(int i) { + return getRuleContext(Comp_opContext.class,i); + } + public ComparisonContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_comparison; } + } + + public final ComparisonContext comparison() throws RecognitionException { + ComparisonContext _localctx = new ComparisonContext(_ctx, getState()); + enterRule(_localctx, 112, RULE_comparison); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(773); + expr(); + setState(779); + _errHandler.sync(this); + _la = _input.LA(1); + while (((((_la - 18)) & ~0x3f) == 0 && ((1L << (_la - 18)) & ((1L << (IN - 18)) | (1L << (NOT - 18)) | (1L << (IS - 18)) | (1L << (LESS_THAN - 18)) | (1L << (GREATER_THAN - 18)) | (1L << (EQUALS - 18)) | (1L << (GT_EQ - 18)) | (1L << (LT_EQ - 18)) | (1L << (NOT_EQ_1 - 18)) | (1L << (NOT_EQ_2 - 18)))) != 0)) { + { + { + setState(774); + comp_op(); + setState(775); + expr(); + } + } + setState(781); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Comp_opContext extends ParserRuleContext { + public TerminalNode LESS_THAN() { return getToken(Python3Parser.LESS_THAN, 0); } + public TerminalNode GREATER_THAN() { return getToken(Python3Parser.GREATER_THAN, 0); } + public TerminalNode EQUALS() { return getToken(Python3Parser.EQUALS, 0); } + public TerminalNode GT_EQ() { return getToken(Python3Parser.GT_EQ, 0); } + public TerminalNode LT_EQ() { return getToken(Python3Parser.LT_EQ, 0); } + public TerminalNode NOT_EQ_1() { return getToken(Python3Parser.NOT_EQ_1, 0); } + public TerminalNode NOT_EQ_2() { return getToken(Python3Parser.NOT_EQ_2, 0); } + public TerminalNode IN() { return getToken(Python3Parser.IN, 0); } + public TerminalNode NOT() { return getToken(Python3Parser.NOT, 0); } + public TerminalNode IS() { return getToken(Python3Parser.IS, 0); } + public Comp_opContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_comp_op; } + } + + public final Comp_opContext comp_op() throws RecognitionException { + Comp_opContext _localctx = new Comp_opContext(_ctx, getState()); + enterRule(_localctx, 114, RULE_comp_op); + try { + setState(795); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,107,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(782); + match(LESS_THAN); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(783); + match(GREATER_THAN); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(784); + match(EQUALS); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(785); + match(GT_EQ); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(786); + match(LT_EQ); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(787); + match(NOT_EQ_1); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(788); + match(NOT_EQ_2); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(789); + match(IN); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(790); + match(NOT); + setState(791); + match(IN); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(792); + match(IS); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(793); + match(IS); + setState(794); + match(NOT); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Star_exprContext extends ParserRuleContext { + public TerminalNode STAR() { return getToken(Python3Parser.STAR, 0); } + public ExprContext expr() { + return getRuleContext(ExprContext.class,0); + } + public Star_exprContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_star_expr; } + } + + public final Star_exprContext star_expr() throws RecognitionException { + Star_exprContext _localctx = new Star_exprContext(_ctx, getState()); + enterRule(_localctx, 116, RULE_star_expr); + try { + enterOuterAlt(_localctx, 1); + { + setState(797); + match(STAR); + setState(798); + expr(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ExprContext extends ParserRuleContext { + public List xor_expr() { + return getRuleContexts(Xor_exprContext.class); + } + public Xor_exprContext xor_expr(int i) { + return getRuleContext(Xor_exprContext.class,i); + } + public List OR_OP() { return getTokens(Python3Parser.OR_OP); } + public TerminalNode OR_OP(int i) { + return getToken(Python3Parser.OR_OP, i); + } + public ExprContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expr; } + } + + public final ExprContext expr() throws RecognitionException { + ExprContext _localctx = new ExprContext(_ctx, getState()); + enterRule(_localctx, 118, RULE_expr); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(800); + xor_expr(); + setState(805); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==OR_OP) { + { + { + setState(801); + match(OR_OP); + setState(802); + xor_expr(); + } + } + setState(807); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Xor_exprContext extends ParserRuleContext { + public List and_expr() { + return getRuleContexts(And_exprContext.class); + } + public And_exprContext and_expr(int i) { + return getRuleContext(And_exprContext.class,i); + } + public List XOR() { return getTokens(Python3Parser.XOR); } + public TerminalNode XOR(int i) { + return getToken(Python3Parser.XOR, i); + } + public Xor_exprContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_xor_expr; } + } + + public final Xor_exprContext xor_expr() throws RecognitionException { + Xor_exprContext _localctx = new Xor_exprContext(_ctx, getState()); + enterRule(_localctx, 120, RULE_xor_expr); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(808); + and_expr(); + setState(813); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==XOR) { + { + { + setState(809); + match(XOR); + setState(810); + and_expr(); + } + } + setState(815); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class And_exprContext extends ParserRuleContext { + public List shift_expr() { + return getRuleContexts(Shift_exprContext.class); + } + public Shift_exprContext shift_expr(int i) { + return getRuleContext(Shift_exprContext.class,i); + } + public List AND_OP() { return getTokens(Python3Parser.AND_OP); } + public TerminalNode AND_OP(int i) { + return getToken(Python3Parser.AND_OP, i); + } + public And_exprContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_and_expr; } + } + + public final And_exprContext and_expr() throws RecognitionException { + And_exprContext _localctx = new And_exprContext(_ctx, getState()); + enterRule(_localctx, 122, RULE_and_expr); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(816); + shift_expr(); + setState(821); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AND_OP) { + { + { + setState(817); + match(AND_OP); + setState(818); + shift_expr(); + } + } + setState(823); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Shift_exprContext extends ParserRuleContext { + public List arith_expr() { + return getRuleContexts(Arith_exprContext.class); + } + public Arith_exprContext arith_expr(int i) { + return getRuleContext(Arith_exprContext.class,i); + } + public List LEFT_SHIFT() { return getTokens(Python3Parser.LEFT_SHIFT); } + public TerminalNode LEFT_SHIFT(int i) { + return getToken(Python3Parser.LEFT_SHIFT, i); + } + public List RIGHT_SHIFT() { return getTokens(Python3Parser.RIGHT_SHIFT); } + public TerminalNode RIGHT_SHIFT(int i) { + return getToken(Python3Parser.RIGHT_SHIFT, i); + } + public Shift_exprContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_shift_expr; } + } + + public final Shift_exprContext shift_expr() throws RecognitionException { + Shift_exprContext _localctx = new Shift_exprContext(_ctx, getState()); + enterRule(_localctx, 124, RULE_shift_expr); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(824); + arith_expr(); + setState(829); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==LEFT_SHIFT || _la==RIGHT_SHIFT) { + { + { + setState(825); + _la = _input.LA(1); + if ( !(_la==LEFT_SHIFT || _la==RIGHT_SHIFT) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(826); + arith_expr(); + } + } + setState(831); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Arith_exprContext extends ParserRuleContext { + public List term() { + return getRuleContexts(TermContext.class); + } + public TermContext term(int i) { + return getRuleContext(TermContext.class,i); + } + public List ADD() { return getTokens(Python3Parser.ADD); } + public TerminalNode ADD(int i) { + return getToken(Python3Parser.ADD, i); + } + public List MINUS() { return getTokens(Python3Parser.MINUS); } + public TerminalNode MINUS(int i) { + return getToken(Python3Parser.MINUS, i); + } + public Arith_exprContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arith_expr; } + } + + public final Arith_exprContext arith_expr() throws RecognitionException { + Arith_exprContext _localctx = new Arith_exprContext(_ctx, getState()); + enterRule(_localctx, 126, RULE_arith_expr); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(832); + term(); + setState(837); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==ADD || _la==MINUS) { + { + { + setState(833); + _la = _input.LA(1); + if ( !(_la==ADD || _la==MINUS) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(834); + term(); + } + } + setState(839); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TermContext extends ParserRuleContext { + public List factor() { + return getRuleContexts(FactorContext.class); + } + public FactorContext factor(int i) { + return getRuleContext(FactorContext.class,i); + } + public List STAR() { return getTokens(Python3Parser.STAR); } + public TerminalNode STAR(int i) { + return getToken(Python3Parser.STAR, i); + } + public List AT() { return getTokens(Python3Parser.AT); } + public TerminalNode AT(int i) { + return getToken(Python3Parser.AT, i); + } + public List DIV() { return getTokens(Python3Parser.DIV); } + public TerminalNode DIV(int i) { + return getToken(Python3Parser.DIV, i); + } + public List MOD() { return getTokens(Python3Parser.MOD); } + public TerminalNode MOD(int i) { + return getToken(Python3Parser.MOD, i); + } + public List IDIV() { return getTokens(Python3Parser.IDIV); } + public TerminalNode IDIV(int i) { + return getToken(Python3Parser.IDIV, i); + } + public TermContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_term; } + } + + public final TermContext term() throws RecognitionException { + TermContext _localctx = new TermContext(_ctx, getState()); + enterRule(_localctx, 128, RULE_term); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(840); + factor(); + setState(845); + _errHandler.sync(this); + _la = _input.LA(1); + while (((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & ((1L << (STAR - 51)) | (1L << (DIV - 51)) | (1L << (MOD - 51)) | (1L << (IDIV - 51)) | (1L << (AT - 51)))) != 0)) { + { + { + setState(841); + _la = _input.LA(1); + if ( !(((((_la - 51)) & ~0x3f) == 0 && ((1L << (_la - 51)) & ((1L << (STAR - 51)) | (1L << (DIV - 51)) | (1L << (MOD - 51)) | (1L << (IDIV - 51)) | (1L << (AT - 51)))) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(842); + factor(); + } + } + setState(847); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FactorContext extends ParserRuleContext { + public FactorContext factor() { + return getRuleContext(FactorContext.class,0); + } + public TerminalNode ADD() { return getToken(Python3Parser.ADD, 0); } + public TerminalNode MINUS() { return getToken(Python3Parser.MINUS, 0); } + public TerminalNode NOT_OP() { return getToken(Python3Parser.NOT_OP, 0); } + public PowerContext power() { + return getRuleContext(PowerContext.class,0); + } + public FactorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_factor; } + } + + public final FactorContext factor() throws RecognitionException { + FactorContext _localctx = new FactorContext(_ctx, getState()); + enterRule(_localctx, 130, RULE_factor); + int _la; + try { + setState(851); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ADD: + case MINUS: + case NOT_OP: + enterOuterAlt(_localctx, 1); + { + setState(848); + _la = _input.LA(1); + if ( !(((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)))) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(849); + factor(); + } + break; + case STRING: + case NUMBER: + case NONE: + case TRUE: + case FALSE: + case AWAIT: + case NAME: + case ELLIPSIS: + case OPEN_PAREN: + case OPEN_BRACK: + case OPEN_BRACE: + enterOuterAlt(_localctx, 2); + { + setState(850); + power(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PowerContext extends ParserRuleContext { + public Atom_exprContext atom_expr() { + return getRuleContext(Atom_exprContext.class,0); + } + public TerminalNode POWER() { return getToken(Python3Parser.POWER, 0); } + public FactorContext factor() { + return getRuleContext(FactorContext.class,0); + } + public PowerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_power; } + } + + public final PowerContext power() throws RecognitionException { + PowerContext _localctx = new PowerContext(_ctx, getState()); + enterRule(_localctx, 132, RULE_power); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(853); + atom_expr(); + setState(856); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==POWER) { + { + setState(854); + match(POWER); + setState(855); + factor(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Atom_exprContext extends ParserRuleContext { + public AtomContext atom() { + return getRuleContext(AtomContext.class,0); + } + public TerminalNode AWAIT() { return getToken(Python3Parser.AWAIT, 0); } + public List trailer() { + return getRuleContexts(TrailerContext.class); + } + public TrailerContext trailer(int i) { + return getRuleContext(TrailerContext.class,i); + } + public Atom_exprContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_atom_expr; } + } + + public final Atom_exprContext atom_expr() throws RecognitionException { + Atom_exprContext _localctx = new Atom_exprContext(_ctx, getState()); + enterRule(_localctx, 134, RULE_atom_expr); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(859); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AWAIT) { + { + setState(858); + match(AWAIT); + } + } + + setState(861); + atom(); + setState(865); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << DOT) | (1L << OPEN_PAREN) | (1L << OPEN_BRACK))) != 0)) { + { + { + setState(862); + trailer(); + } + } + setState(867); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AtomContext extends ParserRuleContext { + public TerminalNode OPEN_PAREN() { return getToken(Python3Parser.OPEN_PAREN, 0); } + public TerminalNode CLOSE_PAREN() { return getToken(Python3Parser.CLOSE_PAREN, 0); } + public TerminalNode OPEN_BRACK() { return getToken(Python3Parser.OPEN_BRACK, 0); } + public TerminalNode CLOSE_BRACK() { return getToken(Python3Parser.CLOSE_BRACK, 0); } + public TerminalNode OPEN_BRACE() { return getToken(Python3Parser.OPEN_BRACE, 0); } + public TerminalNode CLOSE_BRACE() { return getToken(Python3Parser.CLOSE_BRACE, 0); } + public TerminalNode NAME() { return getToken(Python3Parser.NAME, 0); } + public TerminalNode NUMBER() { return getToken(Python3Parser.NUMBER, 0); } + public TerminalNode ELLIPSIS() { return getToken(Python3Parser.ELLIPSIS, 0); } + public TerminalNode NONE() { return getToken(Python3Parser.NONE, 0); } + public TerminalNode TRUE() { return getToken(Python3Parser.TRUE, 0); } + public TerminalNode FALSE() { return getToken(Python3Parser.FALSE, 0); } + public Yield_exprContext yield_expr() { + return getRuleContext(Yield_exprContext.class,0); + } + public Testlist_compContext testlist_comp() { + return getRuleContext(Testlist_compContext.class,0); + } + public DictorsetmakerContext dictorsetmaker() { + return getRuleContext(DictorsetmakerContext.class,0); + } + public List STRING() { return getTokens(Python3Parser.STRING); } + public TerminalNode STRING(int i) { + return getToken(Python3Parser.STRING, i); + } + public AtomContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_atom; } + } + + public final AtomContext atom() throws RecognitionException { + AtomContext _localctx = new AtomContext(_ctx, getState()); + enterRule(_localctx, 136, RULE_atom); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(895); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_PAREN: + { + setState(868); + match(OPEN_PAREN); + setState(871); + _errHandler.sync(this); + switch (_input.LA(1)) { + case YIELD: + { + setState(869); + yield_expr(); + } + break; + case STRING: + case NUMBER: + case LAMBDA: + case NOT: + case NONE: + case TRUE: + case FALSE: + case AWAIT: + case NAME: + case ELLIPSIS: + case STAR: + case OPEN_PAREN: + case OPEN_BRACK: + case ADD: + case MINUS: + case NOT_OP: + case OPEN_BRACE: + { + setState(870); + testlist_comp(); + } + break; + case CLOSE_PAREN: + break; + default: + break; + } + setState(873); + match(CLOSE_PAREN); + } + break; + case OPEN_BRACK: + { + setState(874); + match(OPEN_BRACK); + setState(876); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << STAR) | (1L << OPEN_PAREN) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) { + { + setState(875); + testlist_comp(); + } + } + + setState(878); + match(CLOSE_BRACK); + } + break; + case OPEN_BRACE: + { + setState(879); + match(OPEN_BRACE); + setState(881); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << STAR) | (1L << OPEN_PAREN) | (1L << POWER) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) { + { + setState(880); + dictorsetmaker(); + } + } + + setState(883); + match(CLOSE_BRACE); + } + break; + case NAME: + { + setState(884); + match(NAME); + } + break; + case NUMBER: + { + setState(885); + match(NUMBER); + } + break; + case STRING: + { + setState(887); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(886); + match(STRING); + } + } + setState(889); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==STRING ); + } + break; + case ELLIPSIS: + { + setState(891); + match(ELLIPSIS); + } + break; + case NONE: + { + setState(892); + match(NONE); + } + break; + case TRUE: + { + setState(893); + match(TRUE); + } + break; + case FALSE: + { + setState(894); + match(FALSE); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Testlist_compContext extends ParserRuleContext { + public List test() { + return getRuleContexts(TestContext.class); + } + public TestContext test(int i) { + return getRuleContext(TestContext.class,i); + } + public List star_expr() { + return getRuleContexts(Star_exprContext.class); + } + public Star_exprContext star_expr(int i) { + return getRuleContext(Star_exprContext.class,i); + } + public Comp_forContext comp_for() { + return getRuleContext(Comp_forContext.class,0); + } + public List COMMA() { return getTokens(Python3Parser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(Python3Parser.COMMA, i); + } + public Testlist_compContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_testlist_comp; } + } + + public final Testlist_compContext testlist_comp() throws RecognitionException { + Testlist_compContext _localctx = new Testlist_compContext(_ctx, getState()); + enterRule(_localctx, 138, RULE_testlist_comp); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(899); + _errHandler.sync(this); + switch (_input.LA(1)) { + case STRING: + case NUMBER: + case LAMBDA: + case NOT: + case NONE: + case TRUE: + case FALSE: + case AWAIT: + case NAME: + case ELLIPSIS: + case OPEN_PAREN: + case OPEN_BRACK: + case ADD: + case MINUS: + case NOT_OP: + case OPEN_BRACE: + { + setState(897); + test(); + } + break; + case STAR: + { + setState(898); + star_expr(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(915); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FOR: + case ASYNC: + { + setState(901); + comp_for(); + } + break; + case CLOSE_PAREN: + case COMMA: + case CLOSE_BRACK: + { + setState(909); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,125,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(902); + match(COMMA); + setState(905); + _errHandler.sync(this); + switch (_input.LA(1)) { + case STRING: + case NUMBER: + case LAMBDA: + case NOT: + case NONE: + case TRUE: + case FALSE: + case AWAIT: + case NAME: + case ELLIPSIS: + case OPEN_PAREN: + case OPEN_BRACK: + case ADD: + case MINUS: + case NOT_OP: + case OPEN_BRACE: + { + setState(903); + test(); + } + break; + case STAR: + { + setState(904); + star_expr(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + } + setState(911); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,125,_ctx); + } + setState(913); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(912); + match(COMMA); + } + } + + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TrailerContext extends ParserRuleContext { + public TerminalNode OPEN_PAREN() { return getToken(Python3Parser.OPEN_PAREN, 0); } + public TerminalNode CLOSE_PAREN() { return getToken(Python3Parser.CLOSE_PAREN, 0); } + public ArglistContext arglist() { + return getRuleContext(ArglistContext.class,0); + } + public TerminalNode OPEN_BRACK() { return getToken(Python3Parser.OPEN_BRACK, 0); } + public SubscriptlistContext subscriptlist() { + return getRuleContext(SubscriptlistContext.class,0); + } + public TerminalNode CLOSE_BRACK() { return getToken(Python3Parser.CLOSE_BRACK, 0); } + public TerminalNode DOT() { return getToken(Python3Parser.DOT, 0); } + public TerminalNode NAME() { return getToken(Python3Parser.NAME, 0); } + public TrailerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_trailer; } + } + + public final TrailerContext trailer() throws RecognitionException { + TrailerContext _localctx = new TrailerContext(_ctx, getState()); + enterRule(_localctx, 140, RULE_trailer); + int _la; + try { + setState(928); + _errHandler.sync(this); + switch (_input.LA(1)) { + case OPEN_PAREN: + enterOuterAlt(_localctx, 1); + { + setState(917); + match(OPEN_PAREN); + setState(919); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << STAR) | (1L << OPEN_PAREN) | (1L << POWER) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) { + { + setState(918); + arglist(); + } + } + + setState(921); + match(CLOSE_PAREN); + } + break; + case OPEN_BRACK: + enterOuterAlt(_localctx, 2); + { + setState(922); + match(OPEN_BRACK); + setState(923); + subscriptlist(); + setState(924); + match(CLOSE_BRACK); + } + break; + case DOT: + enterOuterAlt(_localctx, 3); + { + setState(926); + match(DOT); + setState(927); + match(NAME); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SubscriptlistContext extends ParserRuleContext { + public List subscript() { + return getRuleContexts(SubscriptContext.class); + } + public SubscriptContext subscript(int i) { + return getRuleContext(SubscriptContext.class,i); + } + public List COMMA() { return getTokens(Python3Parser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(Python3Parser.COMMA, i); + } + public SubscriptlistContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_subscriptlist; } + } + + public final SubscriptlistContext subscriptlist() throws RecognitionException { + SubscriptlistContext _localctx = new SubscriptlistContext(_ctx, getState()); + enterRule(_localctx, 142, RULE_subscriptlist); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(930); + subscript(); + setState(935); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,130,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(931); + match(COMMA); + setState(932); + subscript(); + } + } + } + setState(937); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,130,_ctx); + } + setState(939); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(938); + match(COMMA); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SubscriptContext extends ParserRuleContext { + public List test() { + return getRuleContexts(TestContext.class); + } + public TestContext test(int i) { + return getRuleContext(TestContext.class,i); + } + public TerminalNode COLON() { return getToken(Python3Parser.COLON, 0); } + public SliceopContext sliceop() { + return getRuleContext(SliceopContext.class,0); + } + public SubscriptContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_subscript; } + } + + public final SubscriptContext subscript() throws RecognitionException { + SubscriptContext _localctx = new SubscriptContext(_ctx, getState()); + enterRule(_localctx, 144, RULE_subscript); + int _la; + try { + setState(952); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,135,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(941); + test(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(943); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << OPEN_PAREN) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) { + { + setState(942); + test(); + } + } + + setState(945); + match(COLON); + setState(947); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << OPEN_PAREN) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) { + { + setState(946); + test(); + } + } + + setState(950); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLON) { + { + setState(949); + sliceop(); + } + } + + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SliceopContext extends ParserRuleContext { + public TerminalNode COLON() { return getToken(Python3Parser.COLON, 0); } + public TestContext test() { + return getRuleContext(TestContext.class,0); + } + public SliceopContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_sliceop; } + } + + public final SliceopContext sliceop() throws RecognitionException { + SliceopContext _localctx = new SliceopContext(_ctx, getState()); + enterRule(_localctx, 146, RULE_sliceop); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(954); + match(COLON); + setState(956); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << OPEN_PAREN) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) { + { + setState(955); + test(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ExprlistContext extends ParserRuleContext { + public List expr() { + return getRuleContexts(ExprContext.class); + } + public ExprContext expr(int i) { + return getRuleContext(ExprContext.class,i); + } + public List star_expr() { + return getRuleContexts(Star_exprContext.class); + } + public Star_exprContext star_expr(int i) { + return getRuleContext(Star_exprContext.class,i); + } + public List COMMA() { return getTokens(Python3Parser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(Python3Parser.COMMA, i); + } + public ExprlistContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_exprlist; } + } + + public final ExprlistContext exprlist() throws RecognitionException { + ExprlistContext _localctx = new ExprlistContext(_ctx, getState()); + enterRule(_localctx, 148, RULE_exprlist); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(960); + _errHandler.sync(this); + switch (_input.LA(1)) { + case STRING: + case NUMBER: + case NONE: + case TRUE: + case FALSE: + case AWAIT: + case NAME: + case ELLIPSIS: + case OPEN_PAREN: + case OPEN_BRACK: + case ADD: + case MINUS: + case NOT_OP: + case OPEN_BRACE: + { + setState(958); + expr(); + } + break; + case STAR: + { + setState(959); + star_expr(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(969); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,139,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(962); + match(COMMA); + setState(965); + _errHandler.sync(this); + switch (_input.LA(1)) { + case STRING: + case NUMBER: + case NONE: + case TRUE: + case FALSE: + case AWAIT: + case NAME: + case ELLIPSIS: + case OPEN_PAREN: + case OPEN_BRACK: + case ADD: + case MINUS: + case NOT_OP: + case OPEN_BRACE: + { + setState(963); + expr(); + } + break; + case STAR: + { + setState(964); + star_expr(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + } + setState(971); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,139,_ctx); + } + setState(973); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(972); + match(COMMA); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TestlistContext extends ParserRuleContext { + public List test() { + return getRuleContexts(TestContext.class); + } + public TestContext test(int i) { + return getRuleContext(TestContext.class,i); + } + public List COMMA() { return getTokens(Python3Parser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(Python3Parser.COMMA, i); + } + public TestlistContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_testlist; } + } + + public final TestlistContext testlist() throws RecognitionException { + TestlistContext _localctx = new TestlistContext(_ctx, getState()); + enterRule(_localctx, 150, RULE_testlist); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(975); + test(); + setState(980); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,141,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(976); + match(COMMA); + setState(977); + test(); + } + } + } + setState(982); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,141,_ctx); + } + setState(984); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(983); + match(COMMA); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class DictorsetmakerContext extends ParserRuleContext { + public List test() { + return getRuleContexts(TestContext.class); + } + public TestContext test(int i) { + return getRuleContext(TestContext.class,i); + } + public List COLON() { return getTokens(Python3Parser.COLON); } + public TerminalNode COLON(int i) { + return getToken(Python3Parser.COLON, i); + } + public List POWER() { return getTokens(Python3Parser.POWER); } + public TerminalNode POWER(int i) { + return getToken(Python3Parser.POWER, i); + } + public List expr() { + return getRuleContexts(ExprContext.class); + } + public ExprContext expr(int i) { + return getRuleContext(ExprContext.class,i); + } + public Comp_forContext comp_for() { + return getRuleContext(Comp_forContext.class,0); + } + public List star_expr() { + return getRuleContexts(Star_exprContext.class); + } + public Star_exprContext star_expr(int i) { + return getRuleContext(Star_exprContext.class,i); + } + public List COMMA() { return getTokens(Python3Parser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(Python3Parser.COMMA, i); + } + public DictorsetmakerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dictorsetmaker; } + } + + public final DictorsetmakerContext dictorsetmaker() throws RecognitionException { + DictorsetmakerContext _localctx = new DictorsetmakerContext(_ctx, getState()); + enterRule(_localctx, 152, RULE_dictorsetmaker); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1034); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,153,_ctx) ) { + case 1: + { + { + setState(992); + _errHandler.sync(this); + switch (_input.LA(1)) { + case STRING: + case NUMBER: + case LAMBDA: + case NOT: + case NONE: + case TRUE: + case FALSE: + case AWAIT: + case NAME: + case ELLIPSIS: + case OPEN_PAREN: + case OPEN_BRACK: + case ADD: + case MINUS: + case NOT_OP: + case OPEN_BRACE: + { + setState(986); + test(); + setState(987); + match(COLON); + setState(988); + test(); + } + break; + case POWER: + { + setState(990); + match(POWER); + setState(991); + expr(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(1012); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FOR: + case ASYNC: + { + setState(994); + comp_for(); + } + break; + case COMMA: + case CLOSE_BRACE: + { + setState(1006); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,145,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(995); + match(COMMA); + setState(1002); + _errHandler.sync(this); + switch (_input.LA(1)) { + case STRING: + case NUMBER: + case LAMBDA: + case NOT: + case NONE: + case TRUE: + case FALSE: + case AWAIT: + case NAME: + case ELLIPSIS: + case OPEN_PAREN: + case OPEN_BRACK: + case ADD: + case MINUS: + case NOT_OP: + case OPEN_BRACE: + { + setState(996); + test(); + setState(997); + match(COLON); + setState(998); + test(); + } + break; + case POWER: + { + setState(1000); + match(POWER); + setState(1001); + expr(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + } + setState(1008); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,145,_ctx); + } + setState(1010); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(1009); + match(COMMA); + } + } + + } + break; + default: + throw new NoViableAltException(this); + } + } + } + break; + case 2: + { + { + setState(1016); + _errHandler.sync(this); + switch (_input.LA(1)) { + case STRING: + case NUMBER: + case LAMBDA: + case NOT: + case NONE: + case TRUE: + case FALSE: + case AWAIT: + case NAME: + case ELLIPSIS: + case OPEN_PAREN: + case OPEN_BRACK: + case ADD: + case MINUS: + case NOT_OP: + case OPEN_BRACE: + { + setState(1014); + test(); + } + break; + case STAR: + { + setState(1015); + star_expr(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(1032); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FOR: + case ASYNC: + { + setState(1018); + comp_for(); + } + break; + case COMMA: + case CLOSE_BRACE: + { + setState(1026); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,150,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1019); + match(COMMA); + setState(1022); + _errHandler.sync(this); + switch (_input.LA(1)) { + case STRING: + case NUMBER: + case LAMBDA: + case NOT: + case NONE: + case TRUE: + case FALSE: + case AWAIT: + case NAME: + case ELLIPSIS: + case OPEN_PAREN: + case OPEN_BRACK: + case ADD: + case MINUS: + case NOT_OP: + case OPEN_BRACE: + { + setState(1020); + test(); + } + break; + case STAR: + { + setState(1021); + star_expr(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + } + setState(1028); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,150,_ctx); + } + setState(1030); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(1029); + match(COMMA); + } + } + + } + break; + default: + throw new NoViableAltException(this); + } + } + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassdefContext extends ParserRuleContext { + public TerminalNode CLASS() { return getToken(Python3Parser.CLASS, 0); } + public TerminalNode NAME() { return getToken(Python3Parser.NAME, 0); } + public TerminalNode COLON() { return getToken(Python3Parser.COLON, 0); } + public SuiteContext suite() { + return getRuleContext(SuiteContext.class,0); + } + public TerminalNode OPEN_PAREN() { return getToken(Python3Parser.OPEN_PAREN, 0); } + public TerminalNode CLOSE_PAREN() { return getToken(Python3Parser.CLOSE_PAREN, 0); } + public ArglistContext arglist() { + return getRuleContext(ArglistContext.class,0); + } + public ClassdefContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classdef; } + } + + public final ClassdefContext classdef() throws RecognitionException { + ClassdefContext _localctx = new ClassdefContext(_ctx, getState()); + enterRule(_localctx, 154, RULE_classdef); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1036); + match(CLASS); + setState(1037); + match(NAME); + setState(1043); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==OPEN_PAREN) { + { + setState(1038); + match(OPEN_PAREN); + setState(1040); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << STAR) | (1L << OPEN_PAREN) | (1L << POWER) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) { + { + setState(1039); + arglist(); + } + } + + setState(1042); + match(CLOSE_PAREN); + } + } + + setState(1045); + match(COLON); + setState(1046); + suite(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ArglistContext extends ParserRuleContext { + public List argument() { + return getRuleContexts(ArgumentContext.class); + } + public ArgumentContext argument(int i) { + return getRuleContext(ArgumentContext.class,i); + } + public List COMMA() { return getTokens(Python3Parser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(Python3Parser.COMMA, i); + } + public ArglistContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arglist; } + } + + public final ArglistContext arglist() throws RecognitionException { + ArglistContext _localctx = new ArglistContext(_ctx, getState()); + enterRule(_localctx, 156, RULE_arglist); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1048); + argument(); + setState(1053); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,156,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1049); + match(COMMA); + setState(1050); + argument(); + } + } + } + setState(1055); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,156,_ctx); + } + setState(1057); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(1056); + match(COMMA); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ArgumentContext extends ParserRuleContext { + public List test() { + return getRuleContexts(TestContext.class); + } + public TestContext test(int i) { + return getRuleContext(TestContext.class,i); + } + public TerminalNode ASSIGN() { return getToken(Python3Parser.ASSIGN, 0); } + public TerminalNode POWER() { return getToken(Python3Parser.POWER, 0); } + public TerminalNode STAR() { return getToken(Python3Parser.STAR, 0); } + public Comp_forContext comp_for() { + return getRuleContext(Comp_forContext.class,0); + } + public ArgumentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_argument; } + } + + public final ArgumentContext argument() throws RecognitionException { + ArgumentContext _localctx = new ArgumentContext(_ctx, getState()); + enterRule(_localctx, 158, RULE_argument); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1071); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) { + case 1: + { + setState(1059); + test(); + setState(1061); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FOR || _la==ASYNC) { + { + setState(1060); + comp_for(); + } + } + + } + break; + case 2: + { + setState(1063); + test(); + setState(1064); + match(ASSIGN); + setState(1065); + test(); + } + break; + case 3: + { + setState(1067); + match(POWER); + setState(1068); + test(); + } + break; + case 4: + { + setState(1069); + match(STAR); + setState(1070); + test(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Comp_iterContext extends ParserRuleContext { + public Comp_forContext comp_for() { + return getRuleContext(Comp_forContext.class,0); + } + public Comp_ifContext comp_if() { + return getRuleContext(Comp_ifContext.class,0); + } + public Comp_iterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_comp_iter; } + } + + public final Comp_iterContext comp_iter() throws RecognitionException { + Comp_iterContext _localctx = new Comp_iterContext(_ctx, getState()); + enterRule(_localctx, 160, RULE_comp_iter); + try { + setState(1075); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FOR: + case ASYNC: + enterOuterAlt(_localctx, 1); + { + setState(1073); + comp_for(); + } + break; + case IF: + enterOuterAlt(_localctx, 2); + { + setState(1074); + comp_if(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Comp_forContext extends ParserRuleContext { + public TerminalNode FOR() { return getToken(Python3Parser.FOR, 0); } + public ExprlistContext exprlist() { + return getRuleContext(ExprlistContext.class,0); + } + public TerminalNode IN() { return getToken(Python3Parser.IN, 0); } + public Or_testContext or_test() { + return getRuleContext(Or_testContext.class,0); + } + public TerminalNode ASYNC() { return getToken(Python3Parser.ASYNC, 0); } + public Comp_iterContext comp_iter() { + return getRuleContext(Comp_iterContext.class,0); + } + public Comp_forContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_comp_for; } + } + + public final Comp_forContext comp_for() throws RecognitionException { + Comp_forContext _localctx = new Comp_forContext(_ctx, getState()); + enterRule(_localctx, 162, RULE_comp_for); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1078); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ASYNC) { + { + setState(1077); + match(ASYNC); + } + } + + setState(1080); + match(FOR); + setState(1081); + exprlist(); + setState(1082); + match(IN); + setState(1083); + or_test(); + setState(1085); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IF) | (1L << FOR) | (1L << ASYNC))) != 0)) { + { + setState(1084); + comp_iter(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Comp_ifContext extends ParserRuleContext { + public TerminalNode IF() { return getToken(Python3Parser.IF, 0); } + public Test_nocondContext test_nocond() { + return getRuleContext(Test_nocondContext.class,0); + } + public Comp_iterContext comp_iter() { + return getRuleContext(Comp_iterContext.class,0); + } + public Comp_ifContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_comp_if; } + } + + public final Comp_ifContext comp_if() throws RecognitionException { + Comp_ifContext _localctx = new Comp_ifContext(_ctx, getState()); + enterRule(_localctx, 164, RULE_comp_if); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1087); + match(IF); + setState(1088); + test_nocond(); + setState(1090); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IF) | (1L << FOR) | (1L << ASYNC))) != 0)) { + { + setState(1089); + comp_iter(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Encoding_declContext extends ParserRuleContext { + public TerminalNode NAME() { return getToken(Python3Parser.NAME, 0); } + public Encoding_declContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_encoding_decl; } + } + + public final Encoding_declContext encoding_decl() throws RecognitionException { + Encoding_declContext _localctx = new Encoding_declContext(_ctx, getState()); + enterRule(_localctx, 166, RULE_encoding_decl); + try { + enterOuterAlt(_localctx, 1); + { + setState(1092); + match(NAME); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Yield_exprContext extends ParserRuleContext { + public TerminalNode YIELD() { return getToken(Python3Parser.YIELD, 0); } + public Yield_argContext yield_arg() { + return getRuleContext(Yield_argContext.class,0); + } + public Yield_exprContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_yield_expr; } + } + + public final Yield_exprContext yield_expr() throws RecognitionException { + Yield_exprContext _localctx = new Yield_exprContext(_ctx, getState()); + enterRule(_localctx, 168, RULE_yield_expr); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1094); + match(YIELD); + setState(1096); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << STRING) | (1L << NUMBER) | (1L << FROM) | (1L << LAMBDA) | (1L << NOT) | (1L << NONE) | (1L << TRUE) | (1L << FALSE) | (1L << AWAIT) | (1L << NAME) | (1L << ELLIPSIS) | (1L << OPEN_PAREN) | (1L << OPEN_BRACK))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (ADD - 66)) | (1L << (MINUS - 66)) | (1L << (NOT_OP - 66)) | (1L << (OPEN_BRACE - 66)))) != 0)) { + { + setState(1095); + yield_arg(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class Yield_argContext extends ParserRuleContext { + public TerminalNode FROM() { return getToken(Python3Parser.FROM, 0); } + public TestContext test() { + return getRuleContext(TestContext.class,0); + } + public TestlistContext testlist() { + return getRuleContext(TestlistContext.class,0); + } + public Yield_argContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_yield_arg; } + } + + public final Yield_argContext yield_arg() throws RecognitionException { + Yield_argContext _localctx = new Yield_argContext(_ctx, getState()); + enterRule(_localctx, 170, RULE_yield_arg); + try { + setState(1101); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FROM: + enterOuterAlt(_localctx, 1); + { + setState(1098); + match(FROM); + setState(1099); + test(); + } + break; + case STRING: + case NUMBER: + case LAMBDA: + case NOT: + case NONE: + case TRUE: + case FALSE: + case AWAIT: + case NAME: + case ELLIPSIS: + case OPEN_PAREN: + case OPEN_BRACK: + case ADD: + case MINUS: + case NOT_OP: + case OPEN_BRACE: + enterOuterAlt(_localctx, 2); + { + setState(1100); + testlist(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static final String _serializedATN = + "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3e\u0452\4\2\t\2\4"+ + "\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+ + "\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+ + "\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+ + "\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+ + "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+ + ",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+ + "\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+ + "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+ + "\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+ + "\4U\tU\4V\tV\4W\tW\3\2\3\2\3\2\3\2\3\2\5\2\u00b4\n\2\3\3\3\3\7\3\u00b8"+ + "\n\3\f\3\16\3\u00bb\13\3\3\3\3\3\3\4\3\4\7\4\u00c1\n\4\f\4\16\4\u00c4"+ + "\13\4\3\4\3\4\3\5\3\5\3\5\3\5\5\5\u00cc\n\5\3\5\5\5\u00cf\n\5\3\5\3\5"+ + "\3\6\6\6\u00d4\n\6\r\6\16\6\u00d5\3\7\3\7\3\7\3\7\5\7\u00dc\n\7\3\b\3"+ + "\b\3\b\3\t\3\t\3\t\3\t\3\t\5\t\u00e6\n\t\3\t\3\t\3\t\3\n\3\n\5\n\u00ed"+ + "\n\n\3\n\3\n\3\13\3\13\3\13\5\13\u00f4\n\13\3\13\3\13\3\13\3\13\5\13\u00fa"+ + "\n\13\7\13\u00fc\n\13\f\13\16\13\u00ff\13\13\3\13\3\13\3\13\5\13\u0104"+ + "\n\13\3\13\3\13\3\13\3\13\5\13\u010a\n\13\7\13\u010c\n\13\f\13\16\13\u010f"+ + "\13\13\3\13\3\13\3\13\3\13\5\13\u0115\n\13\5\13\u0117\n\13\5\13\u0119"+ + "\n\13\3\13\3\13\3\13\5\13\u011e\n\13\5\13\u0120\n\13\5\13\u0122\n\13\3"+ + "\13\3\13\5\13\u0126\n\13\3\13\3\13\3\13\3\13\5\13\u012c\n\13\7\13\u012e"+ + "\n\13\f\13\16\13\u0131\13\13\3\13\3\13\3\13\3\13\5\13\u0137\n\13\5\13"+ + "\u0139\n\13\5\13\u013b\n\13\3\13\3\13\3\13\5\13\u0140\n\13\5\13\u0142"+ + "\n\13\3\f\3\f\3\f\5\f\u0147\n\f\3\r\3\r\3\r\5\r\u014c\n\r\3\r\3\r\3\r"+ + "\3\r\5\r\u0152\n\r\7\r\u0154\n\r\f\r\16\r\u0157\13\r\3\r\3\r\3\r\5\r\u015c"+ + "\n\r\3\r\3\r\3\r\3\r\5\r\u0162\n\r\7\r\u0164\n\r\f\r\16\r\u0167\13\r\3"+ + "\r\3\r\3\r\3\r\5\r\u016d\n\r\5\r\u016f\n\r\5\r\u0171\n\r\3\r\3\r\3\r\5"+ + "\r\u0176\n\r\5\r\u0178\n\r\5\r\u017a\n\r\3\r\3\r\5\r\u017e\n\r\3\r\3\r"+ + "\3\r\3\r\5\r\u0184\n\r\7\r\u0186\n\r\f\r\16\r\u0189\13\r\3\r\3\r\3\r\3"+ + "\r\5\r\u018f\n\r\5\r\u0191\n\r\5\r\u0193\n\r\3\r\3\r\3\r\5\r\u0198\n\r"+ + "\5\r\u019a\n\r\3\16\3\16\3\17\3\17\5\17\u01a0\n\17\3\20\3\20\3\20\7\20"+ + "\u01a5\n\20\f\20\16\20\u01a8\13\20\3\20\5\20\u01ab\n\20\3\20\3\20\3\21"+ + "\3\21\3\21\3\21\3\21\3\21\3\21\3\21\5\21\u01b7\n\21\3\22\3\22\3\22\3\22"+ + "\3\22\5\22\u01be\n\22\3\22\3\22\3\22\5\22\u01c3\n\22\7\22\u01c5\n\22\f"+ + "\22\16\22\u01c8\13\22\5\22\u01ca\n\22\3\23\3\23\3\23\3\23\5\23\u01d0\n"+ + "\23\3\24\3\24\5\24\u01d4\n\24\3\24\3\24\3\24\5\24\u01d9\n\24\7\24\u01db"+ + "\n\24\f\24\16\24\u01de\13\24\3\24\5\24\u01e1\n\24\3\25\3\25\3\26\3\26"+ + "\3\26\3\27\3\27\3\30\3\30\3\30\3\30\3\30\5\30\u01ef\n\30\3\31\3\31\3\32"+ + "\3\32\3\33\3\33\5\33\u01f7\n\33\3\34\3\34\3\35\3\35\3\35\3\35\5\35\u01ff"+ + "\n\35\5\35\u0201\n\35\3\36\3\36\5\36\u0205\n\36\3\37\3\37\3\37\3 \3 \7"+ + " \u020c\n \f \16 \u020f\13 \3 \3 \6 \u0213\n \r \16 \u0214\5 \u0217\n"+ + " \3 \3 \3 \3 \3 \3 \3 \5 \u0220\n \3!\3!\3!\5!\u0225\n!\3\"\3\"\3\"\5"+ + "\"\u022a\n\"\3#\3#\3#\7#\u022f\n#\f#\16#\u0232\13#\3#\5#\u0235\n#\3$\3"+ + "$\3$\7$\u023a\n$\f$\16$\u023d\13$\3%\3%\3%\7%\u0242\n%\f%\16%\u0245\13"+ + "%\3&\3&\3&\3&\7&\u024b\n&\f&\16&\u024e\13&\3\'\3\'\3\'\3\'\7\'\u0254\n"+ + "\'\f\'\16\'\u0257\13\'\3(\3(\3(\3(\5(\u025d\n(\3)\3)\3)\3)\3)\3)\3)\3"+ + ")\3)\5)\u0268\n)\3*\3*\3*\3*\5*\u026e\n*\3+\3+\3+\3+\3+\3+\3+\3+\3+\7"+ + "+\u0279\n+\f+\16+\u027c\13+\3+\3+\3+\5+\u0281\n+\3,\3,\3,\3,\3,\3,\3,"+ + "\5,\u028a\n,\3-\3-\3-\3-\3-\3-\3-\3-\3-\5-\u0295\n-\3.\3.\3.\3.\3.\3."+ + "\3.\6.\u029e\n.\r.\16.\u029f\3.\3.\3.\5.\u02a5\n.\3.\3.\3.\5.\u02aa\n"+ + ".\3.\3.\3.\5.\u02af\n.\3/\3/\3/\3/\7/\u02b5\n/\f/\16/\u02b8\13/\3/\3/"+ + "\3/\3\60\3\60\3\60\5\60\u02c0\n\60\3\61\3\61\3\61\3\61\5\61\u02c6\n\61"+ + "\5\61\u02c8\n\61\3\62\3\62\3\62\3\62\6\62\u02ce\n\62\r\62\16\62\u02cf"+ + "\3\62\3\62\5\62\u02d4\n\62\3\63\3\63\3\63\3\63\3\63\3\63\5\63\u02dc\n"+ + "\63\3\63\5\63\u02df\n\63\3\64\3\64\5\64\u02e3\n\64\3\65\3\65\5\65\u02e7"+ + "\n\65\3\65\3\65\3\65\3\66\3\66\5\66\u02ee\n\66\3\66\3\66\3\66\3\67\3\67"+ + "\3\67\7\67\u02f6\n\67\f\67\16\67\u02f9\13\67\38\38\38\78\u02fe\n8\f8\16"+ + "8\u0301\138\39\39\39\59\u0306\n9\3:\3:\3:\3:\7:\u030c\n:\f:\16:\u030f"+ + "\13:\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;\5;\u031e\n;\3<\3<\3<\3=\3"+ + "=\3=\7=\u0326\n=\f=\16=\u0329\13=\3>\3>\3>\7>\u032e\n>\f>\16>\u0331\13"+ + ">\3?\3?\3?\7?\u0336\n?\f?\16?\u0339\13?\3@\3@\3@\7@\u033e\n@\f@\16@\u0341"+ + "\13@\3A\3A\3A\7A\u0346\nA\fA\16A\u0349\13A\3B\3B\3B\7B\u034e\nB\fB\16"+ + "B\u0351\13B\3C\3C\3C\5C\u0356\nC\3D\3D\3D\5D\u035b\nD\3E\5E\u035e\nE\3"+ + "E\3E\7E\u0362\nE\fE\16E\u0365\13E\3F\3F\3F\5F\u036a\nF\3F\3F\3F\5F\u036f"+ + "\nF\3F\3F\3F\5F\u0374\nF\3F\3F\3F\3F\6F\u037a\nF\rF\16F\u037b\3F\3F\3"+ + "F\3F\5F\u0382\nF\3G\3G\5G\u0386\nG\3G\3G\3G\3G\5G\u038c\nG\7G\u038e\n"+ + "G\fG\16G\u0391\13G\3G\5G\u0394\nG\5G\u0396\nG\3H\3H\5H\u039a\nH\3H\3H"+ + "\3H\3H\3H\3H\3H\5H\u03a3\nH\3I\3I\3I\7I\u03a8\nI\fI\16I\u03ab\13I\3I\5"+ + "I\u03ae\nI\3J\3J\5J\u03b2\nJ\3J\3J\5J\u03b6\nJ\3J\5J\u03b9\nJ\5J\u03bb"+ + "\nJ\3K\3K\5K\u03bf\nK\3L\3L\5L\u03c3\nL\3L\3L\3L\5L\u03c8\nL\7L\u03ca"+ + "\nL\fL\16L\u03cd\13L\3L\5L\u03d0\nL\3M\3M\3M\7M\u03d5\nM\fM\16M\u03d8"+ + "\13M\3M\5M\u03db\nM\3N\3N\3N\3N\3N\3N\5N\u03e3\nN\3N\3N\3N\3N\3N\3N\3"+ + "N\3N\5N\u03ed\nN\7N\u03ef\nN\fN\16N\u03f2\13N\3N\5N\u03f5\nN\5N\u03f7"+ + "\nN\3N\3N\5N\u03fb\nN\3N\3N\3N\3N\5N\u0401\nN\7N\u0403\nN\fN\16N\u0406"+ + "\13N\3N\5N\u0409\nN\5N\u040b\nN\5N\u040d\nN\3O\3O\3O\3O\5O\u0413\nO\3"+ + "O\5O\u0416\nO\3O\3O\3O\3P\3P\3P\7P\u041e\nP\fP\16P\u0421\13P\3P\5P\u0424"+ + "\nP\3Q\3Q\5Q\u0428\nQ\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\5Q\u0432\nQ\3R\3R\5R\u0436"+ + "\nR\3S\5S\u0439\nS\3S\3S\3S\3S\3S\5S\u0440\nS\3T\3T\3T\5T\u0445\nT\3U"+ + "\3U\3V\3V\5V\u044b\nV\3W\3W\3W\5W\u0450\nW\3W\2\2X\2\4\6\b\n\f\16\20\22"+ + "\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnp"+ + "rtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c\u008e\u0090\u0092\u0094"+ + "\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6\u00a8\u00aa\u00ac"+ + "\2\b\3\2Ua\3\2\63\64\3\2BC\3\2DE\5\2\65\65FHSS\4\2DEII\2\u04cf\2\u00b3"+ + "\3\2\2\2\4\u00b9\3\2\2\2\6\u00be\3\2\2\2\b\u00c7\3\2\2\2\n\u00d3\3\2\2"+ + "\2\f\u00d7\3\2\2\2\16\u00dd\3\2\2\2\20\u00e0\3\2\2\2\22\u00ea\3\2\2\2"+ + "\24\u0141\3\2\2\2\26\u0143\3\2\2\2\30\u0199\3\2\2\2\32\u019b\3\2\2\2\34"+ + "\u019f\3\2\2\2\36\u01a1\3\2\2\2 \u01b6\3\2\2\2\"\u01b8\3\2\2\2$\u01cb"+ + "\3\2\2\2&\u01d3\3\2\2\2(\u01e2\3\2\2\2*\u01e4\3\2\2\2,\u01e7\3\2\2\2."+ + "\u01ee\3\2\2\2\60\u01f0\3\2\2\2\62\u01f2\3\2\2\2\64\u01f4\3\2\2\2\66\u01f8"+ + "\3\2\2\28\u01fa\3\2\2\2:\u0204\3\2\2\2<\u0206\3\2\2\2>\u0209\3\2\2\2@"+ + "\u0221\3\2\2\2B\u0226\3\2\2\2D\u022b\3\2\2\2F\u0236\3\2\2\2H\u023e\3\2"+ + "\2\2J\u0246\3\2\2\2L\u024f\3\2\2\2N\u0258\3\2\2\2P\u0267\3\2\2\2R\u0269"+ + "\3\2\2\2T\u026f\3\2\2\2V\u0282\3\2\2\2X\u028b\3\2\2\2Z\u0296\3\2\2\2\\"+ + "\u02b0\3\2\2\2^\u02bc\3\2\2\2`\u02c1\3\2\2\2b\u02d3\3\2\2\2d\u02de\3\2"+ + "\2\2f\u02e2\3\2\2\2h\u02e4\3\2\2\2j\u02eb\3\2\2\2l\u02f2\3\2\2\2n\u02fa"+ + "\3\2\2\2p\u0305\3\2\2\2r\u0307\3\2\2\2t\u031d\3\2\2\2v\u031f\3\2\2\2x"+ + "\u0322\3\2\2\2z\u032a\3\2\2\2|\u0332\3\2\2\2~\u033a\3\2\2\2\u0080\u0342"+ + "\3\2\2\2\u0082\u034a\3\2\2\2\u0084\u0355\3\2\2\2\u0086\u0357\3\2\2\2\u0088"+ + "\u035d\3\2\2\2\u008a\u0381\3\2\2\2\u008c\u0385\3\2\2\2\u008e\u03a2\3\2"+ + "\2\2\u0090\u03a4\3\2\2\2\u0092\u03ba\3\2\2\2\u0094\u03bc\3\2\2\2\u0096"+ + "\u03c2\3\2\2\2\u0098\u03d1\3\2\2\2\u009a\u040c\3\2\2\2\u009c\u040e\3\2"+ + "\2\2\u009e\u041a\3\2\2\2\u00a0\u0431\3\2\2\2\u00a2\u0435\3\2\2\2\u00a4"+ + "\u0438\3\2\2\2\u00a6\u0441\3\2\2\2\u00a8\u0446\3\2\2\2\u00aa\u0448\3\2"+ + "\2\2\u00ac\u044f\3\2\2\2\u00ae\u00b4\7)\2\2\u00af\u00b4\5\36\20\2\u00b0"+ + "\u00b1\5P)\2\u00b1\u00b2\7)\2\2\u00b2\u00b4\3\2\2\2\u00b3\u00ae\3\2\2"+ + "\2\u00b3\u00af\3\2\2\2\u00b3\u00b0\3\2\2\2\u00b4\3\3\2\2\2\u00b5\u00b8"+ + "\7)\2\2\u00b6\u00b8\5\34\17\2\u00b7\u00b5\3\2\2\2\u00b7\u00b6\3\2\2\2"+ + "\u00b8\u00bb\3\2\2\2\u00b9\u00b7\3\2\2\2\u00b9\u00ba\3\2\2\2\u00ba\u00bc"+ + "\3\2\2\2\u00bb\u00b9\3\2\2\2\u00bc\u00bd\7\2\2\3\u00bd\5\3\2\2\2\u00be"+ + "\u00c2\5\u0098M\2\u00bf\u00c1\7)\2\2\u00c0\u00bf\3\2\2\2\u00c1\u00c4\3"+ + "\2\2\2\u00c2\u00c0\3\2\2\2\u00c2\u00c3\3\2\2\2\u00c3\u00c5\3\2\2\2\u00c4"+ + "\u00c2\3\2\2\2\u00c5\u00c6\7\2\2\3\u00c6\7\3\2\2\2\u00c7\u00c8\7S\2\2"+ + "\u00c8\u00ce\5H%\2\u00c9\u00cb\7\66\2\2\u00ca\u00cc\5\u009eP\2\u00cb\u00ca"+ + "\3\2\2\2\u00cb\u00cc\3\2\2\2\u00cc\u00cd\3\2\2\2\u00cd\u00cf\7\67\2\2"+ + "\u00ce\u00c9\3\2\2\2\u00ce\u00cf\3\2\2\2\u00cf\u00d0\3\2\2\2\u00d0\u00d1"+ + "\7)\2\2\u00d1\t\3\2\2\2\u00d2\u00d4\5\b\5\2\u00d3\u00d2\3\2\2\2\u00d4"+ + "\u00d5\3\2\2\2\u00d5\u00d3\3\2\2\2\u00d5\u00d6\3\2\2\2\u00d6\13\3\2\2"+ + "\2\u00d7\u00db\5\n\6\2\u00d8\u00dc\5\u009cO\2\u00d9\u00dc\5\20\t\2\u00da"+ + "\u00dc\5\16\b\2\u00db\u00d8\3\2\2\2\u00db\u00d9\3\2\2\2\u00db\u00da\3"+ + "\2\2\2\u00dc\r\3\2\2\2\u00dd\u00de\7\'\2\2\u00de\u00df\5\20\t\2\u00df"+ + "\17\3\2\2\2\u00e0\u00e1\7\6\2\2\u00e1\u00e2\7*\2\2\u00e2\u00e5\5\22\n"+ + "\2\u00e3\u00e4\7T\2\2\u00e4\u00e6\5d\63\2\u00e5\u00e3\3\2\2\2\u00e5\u00e6"+ + "\3\2\2\2\u00e6\u00e7\3\2\2\2\u00e7\u00e8\79\2\2\u00e8\u00e9\5b\62\2\u00e9"+ + "\21\3\2\2\2\u00ea\u00ec\7\66\2\2\u00eb\u00ed\5\24\13\2\u00ec\u00eb\3\2"+ + "\2\2\u00ec\u00ed\3\2\2\2\u00ed\u00ee\3\2\2\2\u00ee\u00ef\7\67\2\2\u00ef"+ + "\23\3\2\2\2\u00f0\u00f3\5\26\f\2\u00f1\u00f2\7<\2\2\u00f2\u00f4\5d\63"+ + "\2\u00f3\u00f1\3\2\2\2\u00f3\u00f4\3\2\2\2\u00f4\u00fd\3\2\2\2\u00f5\u00f6"+ + "\78\2\2\u00f6\u00f9\5\26\f\2\u00f7\u00f8\7<\2\2\u00f8\u00fa\5d\63\2\u00f9"+ + "\u00f7\3\2\2\2\u00f9\u00fa\3\2\2\2\u00fa\u00fc\3\2\2\2\u00fb\u00f5\3\2"+ + "\2\2\u00fc\u00ff\3\2\2\2\u00fd\u00fb\3\2\2\2\u00fd\u00fe\3\2\2\2\u00fe"+ + "\u0121\3\2\2\2\u00ff\u00fd\3\2\2\2\u0100\u011f\78\2\2\u0101\u0103\7\65"+ + "\2\2\u0102\u0104\5\26\f\2\u0103\u0102\3\2\2\2\u0103\u0104\3\2\2\2\u0104"+ + "\u010d\3\2\2\2\u0105\u0106\78\2\2\u0106\u0109\5\26\f\2\u0107\u0108\7<"+ + "\2\2\u0108\u010a\5d\63\2\u0109\u0107\3\2\2\2\u0109\u010a\3\2\2\2\u010a"+ + "\u010c\3\2\2\2\u010b\u0105\3\2\2\2\u010c\u010f\3\2\2\2\u010d\u010b\3\2"+ + "\2\2\u010d\u010e\3\2\2\2\u010e\u0118\3\2\2\2\u010f\u010d\3\2\2\2\u0110"+ + "\u0116\78\2\2\u0111\u0112\7;\2\2\u0112\u0114\5\26\f\2\u0113\u0115\78\2"+ + "\2\u0114\u0113\3\2\2\2\u0114\u0115\3\2\2\2\u0115\u0117\3\2\2\2\u0116\u0111"+ + "\3\2\2\2\u0116\u0117\3\2\2\2\u0117\u0119\3\2\2\2\u0118\u0110\3\2\2\2\u0118"+ + "\u0119\3\2\2\2\u0119\u0120\3\2\2\2\u011a\u011b\7;\2\2\u011b\u011d\5\26"+ + "\f\2\u011c\u011e\78\2\2\u011d\u011c\3\2\2\2\u011d\u011e\3\2\2\2\u011e"+ + "\u0120\3\2\2\2\u011f\u0101\3\2\2\2\u011f\u011a\3\2\2\2\u011f\u0120\3\2"+ + "\2\2\u0120\u0122\3\2\2\2\u0121\u0100\3\2\2\2\u0121\u0122\3\2\2\2\u0122"+ + "\u0142\3\2\2\2\u0123\u0125\7\65\2\2\u0124\u0126\5\26\f\2\u0125\u0124\3"+ + "\2\2\2\u0125\u0126\3\2\2\2\u0126\u012f\3\2\2\2\u0127\u0128\78\2\2\u0128"+ + "\u012b\5\26\f\2\u0129\u012a\7<\2\2\u012a\u012c\5d\63\2\u012b\u0129\3\2"+ + "\2\2\u012b\u012c\3\2\2\2\u012c\u012e\3\2\2\2\u012d\u0127\3\2\2\2\u012e"+ + "\u0131\3\2\2\2\u012f\u012d\3\2\2\2\u012f\u0130\3\2\2\2\u0130\u013a\3\2"+ + "\2\2\u0131\u012f\3\2\2\2\u0132\u0138\78\2\2\u0133\u0134\7;\2\2\u0134\u0136"+ + "\5\26\f\2\u0135\u0137\78\2\2\u0136\u0135\3\2\2\2\u0136\u0137\3\2\2\2\u0137"+ + "\u0139\3\2\2\2\u0138\u0133\3\2\2\2\u0138\u0139\3\2\2\2\u0139\u013b\3\2"+ + "\2\2\u013a\u0132\3\2\2\2\u013a\u013b\3\2\2\2\u013b\u0142\3\2\2\2\u013c"+ + "\u013d\7;\2\2\u013d\u013f\5\26\f\2\u013e\u0140\78\2\2\u013f\u013e\3\2"+ + "\2\2\u013f\u0140\3\2\2\2\u0140\u0142\3\2\2\2\u0141\u00f0\3\2\2\2\u0141"+ + "\u0123\3\2\2\2\u0141\u013c\3\2\2\2\u0142\25\3\2\2\2\u0143\u0146\7*\2\2"+ + "\u0144\u0145\79\2\2\u0145\u0147\5d\63\2\u0146\u0144\3\2\2\2\u0146\u0147"+ + "\3\2\2\2\u0147\27\3\2\2\2\u0148\u014b\5\32\16\2\u0149\u014a\7<\2\2\u014a"+ + "\u014c\5d\63\2\u014b\u0149\3\2\2\2\u014b\u014c\3\2\2\2\u014c\u0155\3\2"+ + "\2\2\u014d\u014e\78\2\2\u014e\u0151\5\32\16\2\u014f\u0150\7<\2\2\u0150"+ + "\u0152\5d\63\2\u0151\u014f\3\2\2\2\u0151\u0152\3\2\2\2\u0152\u0154\3\2"+ + "\2\2\u0153\u014d\3\2\2\2\u0154\u0157\3\2\2\2\u0155\u0153\3\2\2\2\u0155"+ + "\u0156\3\2\2\2\u0156\u0179\3\2\2\2\u0157\u0155\3\2\2\2\u0158\u0177\78"+ + "\2\2\u0159\u015b\7\65\2\2\u015a\u015c\5\32\16\2\u015b\u015a\3\2\2\2\u015b"+ + "\u015c\3\2\2\2\u015c\u0165\3\2\2\2\u015d\u015e\78\2\2\u015e\u0161\5\32"+ + "\16\2\u015f\u0160\7<\2\2\u0160\u0162\5d\63\2\u0161\u015f\3\2\2\2\u0161"+ + "\u0162\3\2\2\2\u0162\u0164\3\2\2\2\u0163\u015d\3\2\2\2\u0164\u0167\3\2"+ + "\2\2\u0165\u0163\3\2\2\2\u0165\u0166\3\2\2\2\u0166\u0170\3\2\2\2\u0167"+ + "\u0165\3\2\2\2\u0168\u016e\78\2\2\u0169\u016a\7;\2\2\u016a\u016c\5\32"+ + "\16\2\u016b\u016d\78\2\2\u016c\u016b\3\2\2\2\u016c\u016d\3\2\2\2\u016d"+ + "\u016f\3\2\2\2\u016e\u0169\3\2\2\2\u016e\u016f\3\2\2\2\u016f\u0171\3\2"+ + "\2\2\u0170\u0168\3\2\2\2\u0170\u0171\3\2\2\2\u0171\u0178\3\2\2\2\u0172"+ + "\u0173\7;\2\2\u0173\u0175\5\32\16\2\u0174\u0176\78\2\2\u0175\u0174\3\2"+ + "\2\2\u0175\u0176\3\2\2\2\u0176\u0178\3\2\2\2\u0177\u0159\3\2\2\2\u0177"+ + "\u0172\3\2\2\2\u0177\u0178\3\2\2\2\u0178\u017a\3\2\2\2\u0179\u0158\3\2"+ + "\2\2\u0179\u017a\3\2\2\2\u017a\u019a\3\2\2\2\u017b\u017d\7\65\2\2\u017c"+ + "\u017e\5\32\16\2\u017d\u017c\3\2\2\2\u017d\u017e\3\2\2\2\u017e\u0187\3"+ + "\2\2\2\u017f\u0180\78\2\2\u0180\u0183\5\32\16\2\u0181\u0182\7<\2\2\u0182"+ + "\u0184\5d\63\2\u0183\u0181\3\2\2\2\u0183\u0184\3\2\2\2\u0184\u0186\3\2"+ + "\2\2\u0185\u017f\3\2\2\2\u0186\u0189\3\2\2\2\u0187\u0185\3\2\2\2\u0187"+ + "\u0188\3\2\2\2\u0188\u0192\3\2\2\2\u0189\u0187\3\2\2\2\u018a\u0190\78"+ + "\2\2\u018b\u018c\7;\2\2\u018c\u018e\5\32\16\2\u018d\u018f\78\2\2\u018e"+ + "\u018d\3\2\2\2\u018e\u018f\3\2\2\2\u018f\u0191\3\2\2\2\u0190\u018b\3\2"+ + "\2\2\u0190\u0191\3\2\2\2\u0191\u0193\3\2\2\2\u0192\u018a\3\2\2\2\u0192"+ + "\u0193\3\2\2\2\u0193\u019a\3\2\2\2\u0194\u0195\7;\2\2\u0195\u0197\5\32"+ + "\16\2\u0196\u0198\78\2\2\u0197\u0196\3\2\2\2\u0197\u0198\3\2\2\2\u0198"+ + "\u019a\3\2\2\2\u0199\u0148\3\2\2\2\u0199\u017b\3\2\2\2\u0199\u0194\3\2"+ + "\2\2\u019a\31\3\2\2\2\u019b\u019c\7*\2\2\u019c\33\3\2\2\2\u019d\u01a0"+ + "\5\36\20\2\u019e\u01a0\5P)\2\u019f\u019d\3\2\2\2\u019f\u019e\3\2\2\2\u01a0"+ + "\35\3\2\2\2\u01a1\u01a6\5 \21\2\u01a2\u01a3\7:\2\2\u01a3\u01a5\5 \21\2"+ + "\u01a4\u01a2\3\2\2\2\u01a5\u01a8\3\2\2\2\u01a6\u01a4\3\2\2\2\u01a6\u01a7"+ + "\3\2\2\2\u01a7\u01aa\3\2\2\2\u01a8\u01a6\3\2\2\2\u01a9\u01ab\7:\2\2\u01aa"+ + "\u01a9\3\2\2\2\u01aa\u01ab\3\2\2\2\u01ab\u01ac\3\2\2\2\u01ac\u01ad\7)"+ + "\2\2\u01ad\37\3\2\2\2\u01ae\u01b7\5\"\22\2\u01af\u01b7\5*\26\2\u01b0\u01b7"+ + "\5,\27\2\u01b1\u01b7\5.\30\2\u01b2\u01b7\5:\36\2\u01b3\u01b7\5J&\2\u01b4"+ + "\u01b7\5L\'\2\u01b5\u01b7\5N(\2\u01b6\u01ae\3\2\2\2\u01b6\u01af\3\2\2"+ + "\2\u01b6\u01b0\3\2\2\2\u01b6\u01b1\3\2\2\2\u01b6\u01b2\3\2\2\2\u01b6\u01b3"+ + "\3\2\2\2\u01b6\u01b4\3\2\2\2\u01b6\u01b5\3\2\2\2\u01b7!\3\2\2\2\u01b8"+ + "\u01c9\5&\24\2\u01b9\u01ca\5$\23\2\u01ba\u01bd\5(\25\2\u01bb\u01be\5\u00aa"+ + "V\2\u01bc\u01be\5\u0098M\2\u01bd\u01bb\3\2\2\2\u01bd\u01bc\3\2\2\2\u01be"+ + "\u01ca\3\2\2\2\u01bf\u01c2\7<\2\2\u01c0\u01c3\5\u00aaV\2\u01c1\u01c3\5"+ + "&\24\2\u01c2\u01c0\3\2\2\2\u01c2\u01c1\3\2\2\2\u01c3\u01c5\3\2\2\2\u01c4"+ + "\u01bf\3\2\2\2\u01c5\u01c8\3\2\2\2\u01c6\u01c4\3\2\2\2\u01c6\u01c7\3\2"+ + "\2\2\u01c7\u01ca\3\2\2\2\u01c8\u01c6\3\2\2\2\u01c9\u01b9\3\2\2\2\u01c9"+ + "\u01ba\3\2\2\2\u01c9\u01c6\3\2\2\2\u01ca#\3\2\2\2\u01cb\u01cc\79\2\2\u01cc"+ + "\u01cf\5d\63\2\u01cd\u01ce\7<\2\2\u01ce\u01d0\5d\63\2\u01cf\u01cd\3\2"+ + "\2\2\u01cf\u01d0\3\2\2\2\u01d0%\3\2\2\2\u01d1\u01d4\5d\63\2\u01d2\u01d4"+ + "\5v<\2\u01d3\u01d1\3\2\2\2\u01d3\u01d2\3\2\2\2\u01d4\u01dc\3\2\2\2\u01d5"+ + "\u01d8\78\2\2\u01d6\u01d9\5d\63\2\u01d7\u01d9\5v<\2\u01d8\u01d6\3\2\2"+ + "\2\u01d8\u01d7\3\2\2\2\u01d9\u01db\3\2\2\2\u01da\u01d5\3\2\2\2\u01db\u01de"+ + "\3\2\2\2\u01dc\u01da\3\2\2\2\u01dc\u01dd\3\2\2\2\u01dd\u01e0\3\2\2\2\u01de"+ + "\u01dc\3\2\2\2\u01df\u01e1\78\2\2\u01e0\u01df\3\2\2\2\u01e0\u01e1\3\2"+ + "\2\2\u01e1\'\3\2\2\2\u01e2\u01e3\t\2\2\2\u01e3)\3\2\2\2\u01e4\u01e5\7"+ + "#\2\2\u01e5\u01e6\5\u0096L\2\u01e6+\3\2\2\2\u01e7\u01e8\7$\2\2\u01e8-"+ + "\3\2\2\2\u01e9\u01ef\5\60\31\2\u01ea\u01ef\5\62\32\2\u01eb\u01ef\5\64"+ + "\33\2\u01ec\u01ef\58\35\2\u01ed\u01ef\5\66\34\2\u01ee\u01e9\3\2\2\2\u01ee"+ + "\u01ea\3\2\2\2\u01ee\u01eb\3\2\2\2\u01ee\u01ec\3\2\2\2\u01ee\u01ed\3\2"+ + "\2\2\u01ef/\3\2\2\2\u01f0\u01f1\7&\2\2\u01f1\61\3\2\2\2\u01f2\u01f3\7"+ + "%\2\2\u01f3\63\3\2\2\2\u01f4\u01f6\7\7\2\2\u01f5\u01f7\5\u0098M\2\u01f6"+ + "\u01f5\3\2\2\2\u01f6\u01f7\3\2\2\2\u01f7\65\3\2\2\2\u01f8\u01f9\5\u00aa"+ + "V\2\u01f9\67\3\2\2\2\u01fa\u0200\7\b\2\2\u01fb\u01fe\5d\63\2\u01fc\u01fd"+ + "\7\t\2\2\u01fd\u01ff\5d\63\2\u01fe\u01fc\3\2\2\2\u01fe\u01ff\3\2\2\2\u01ff"+ + "\u0201\3\2\2\2\u0200\u01fb\3\2\2\2\u0200\u0201\3\2\2\2\u02019\3\2\2\2"+ + "\u0202\u0205\5<\37\2\u0203\u0205\5> \2\u0204\u0202\3\2\2\2\u0204\u0203"+ + "\3\2\2\2\u0205;\3\2\2\2\u0206\u0207\7\n\2\2\u0207\u0208\5F$\2\u0208=\3"+ + "\2\2\2\u0209\u0216\7\t\2\2\u020a\u020c\t\3\2\2\u020b\u020a\3\2\2\2\u020c"+ + "\u020f\3\2\2\2\u020d\u020b\3\2\2\2\u020d\u020e\3\2\2\2\u020e\u0210\3\2"+ + "\2\2\u020f\u020d\3\2\2\2\u0210\u0217\5H%\2\u0211\u0213\t\3\2\2\u0212\u0211"+ + "\3\2\2\2\u0213\u0214\3\2\2\2\u0214\u0212\3\2\2\2\u0214\u0215\3\2\2\2\u0215"+ + "\u0217\3\2\2\2\u0216\u020d\3\2\2\2\u0216\u0212\3\2\2\2\u0217\u0218\3\2"+ + "\2\2\u0218\u021f\7\n\2\2\u0219\u0220\7\65\2\2\u021a\u021b\7\66\2\2\u021b"+ + "\u021c\5D#\2\u021c\u021d\7\67\2\2\u021d\u0220\3\2\2\2\u021e\u0220\5D#"+ + "\2\u021f\u0219\3\2\2\2\u021f\u021a\3\2\2\2\u021f\u021e\3\2\2\2\u0220?"+ + "\3\2\2\2\u0221\u0224\7*\2\2\u0222\u0223\7\13\2\2\u0223\u0225\7*\2\2\u0224"+ + "\u0222\3\2\2\2\u0224\u0225\3\2\2\2\u0225A\3\2\2\2\u0226\u0229\5H%\2\u0227"+ + "\u0228\7\13\2\2\u0228\u022a\7*\2\2\u0229\u0227\3\2\2\2\u0229\u022a\3\2"+ + "\2\2\u022aC\3\2\2\2\u022b\u0230\5@!\2\u022c\u022d\78\2\2\u022d\u022f\5"+ + "@!\2\u022e\u022c\3\2\2\2\u022f\u0232\3\2\2\2\u0230\u022e\3\2\2\2\u0230"+ + "\u0231\3\2\2\2\u0231\u0234\3\2\2\2\u0232\u0230\3\2\2\2\u0233\u0235\78"+ + "\2\2\u0234\u0233\3\2\2\2\u0234\u0235\3\2\2\2\u0235E\3\2\2\2\u0236\u023b"+ + "\5B\"\2\u0237\u0238\78\2\2\u0238\u023a\5B\"\2\u0239\u0237\3\2\2\2\u023a"+ + "\u023d\3\2\2\2\u023b\u0239\3\2\2\2\u023b\u023c\3\2\2\2\u023cG\3\2\2\2"+ + "\u023d\u023b\3\2\2\2\u023e\u0243\7*\2\2\u023f\u0240\7\63\2\2\u0240\u0242"+ + "\7*\2\2\u0241\u023f\3\2\2\2\u0242\u0245\3\2\2\2\u0243\u0241\3\2\2\2\u0243"+ + "\u0244\3\2\2\2\u0244I\3\2\2\2\u0245\u0243\3\2\2\2\u0246\u0247\7\f\2\2"+ + "\u0247\u024c\7*\2\2\u0248\u0249\78\2\2\u0249\u024b\7*\2\2\u024a\u0248"+ + "\3\2\2\2\u024b\u024e\3\2\2\2\u024c\u024a\3\2\2\2\u024c\u024d\3\2\2\2\u024d"+ + "K\3\2\2\2\u024e\u024c\3\2\2\2\u024f\u0250\7\r\2\2\u0250\u0255\7*\2\2\u0251"+ + "\u0252\78\2\2\u0252\u0254\7*\2\2\u0253\u0251\3\2\2\2\u0254\u0257\3\2\2"+ + "\2\u0255\u0253\3\2\2\2\u0255\u0256\3\2\2\2\u0256M\3\2\2\2\u0257\u0255"+ + "\3\2\2\2\u0258\u0259\7\16\2\2\u0259\u025c\5d\63\2\u025a\u025b\78\2\2\u025b"+ + "\u025d\5d\63\2\u025c\u025a\3\2\2\2\u025c\u025d\3\2\2\2\u025dO\3\2\2\2"+ + "\u025e\u0268\5T+\2\u025f\u0268\5V,\2\u0260\u0268\5X-\2\u0261\u0268\5Z"+ + ".\2\u0262\u0268\5\\/\2\u0263\u0268\5\20\t\2\u0264\u0268\5\u009cO\2\u0265"+ + "\u0268\5\f\7\2\u0266\u0268\5R*\2\u0267\u025e\3\2\2\2\u0267\u025f\3\2\2"+ + "\2\u0267\u0260\3\2\2\2\u0267\u0261\3\2\2\2\u0267\u0262\3\2\2\2\u0267\u0263"+ + "\3\2\2\2\u0267\u0264\3\2\2\2\u0267\u0265\3\2\2\2\u0267\u0266\3\2\2\2\u0268"+ + "Q\3\2\2\2\u0269\u026d\7\'\2\2\u026a\u026e\5\20\t\2\u026b\u026e\5\\/\2"+ + "\u026c\u026e\5X-\2\u026d\u026a\3\2\2\2\u026d\u026b\3\2\2\2\u026d\u026c"+ + "\3\2\2\2\u026eS\3\2\2\2\u026f\u0270\7\17\2\2\u0270\u0271\5d\63\2\u0271"+ + "\u0272\79\2\2\u0272\u027a\5b\62\2\u0273\u0274\7\20\2\2\u0274\u0275\5d"+ + "\63\2\u0275\u0276\79\2\2\u0276\u0277\5b\62\2\u0277\u0279\3\2\2\2\u0278"+ + "\u0273\3\2\2\2\u0279\u027c\3\2\2\2\u027a\u0278\3\2\2\2\u027a\u027b\3\2"+ + "\2\2\u027b\u0280\3\2\2\2\u027c\u027a\3\2\2\2\u027d\u027e\7\21\2\2\u027e"+ + "\u027f\79\2\2\u027f\u0281\5b\62\2\u0280\u027d\3\2\2\2\u0280\u0281\3\2"+ + "\2\2\u0281U\3\2\2\2\u0282\u0283\7\22\2\2\u0283\u0284\5d\63\2\u0284\u0285"+ + "\79\2\2\u0285\u0289\5b\62\2\u0286\u0287\7\21\2\2\u0287\u0288\79\2\2\u0288"+ + "\u028a\5b\62\2\u0289\u0286\3\2\2\2\u0289\u028a\3\2\2\2\u028aW\3\2\2\2"+ + "\u028b\u028c\7\23\2\2\u028c\u028d\5\u0096L\2\u028d\u028e\7\24\2\2\u028e"+ + "\u028f\5\u0098M\2\u028f\u0290\79\2\2\u0290\u0294\5b\62\2\u0291\u0292\7"+ + "\21\2\2\u0292\u0293\79\2\2\u0293\u0295\5b\62\2\u0294\u0291\3\2\2\2\u0294"+ + "\u0295\3\2\2\2\u0295Y\3\2\2\2\u0296\u0297\7\25\2\2\u0297\u0298\79\2\2"+ + "\u0298\u02ae\5b\62\2\u0299\u029a\5`\61\2\u029a\u029b\79\2\2\u029b\u029c"+ + "\5b\62\2\u029c\u029e\3\2\2\2\u029d\u0299\3\2\2\2\u029e\u029f\3\2\2\2\u029f"+ + "\u029d\3\2\2\2\u029f\u02a0\3\2\2\2\u02a0\u02a4\3\2\2\2\u02a1\u02a2\7\21"+ + "\2\2\u02a2\u02a3\79\2\2\u02a3\u02a5\5b\62\2\u02a4\u02a1\3\2\2\2\u02a4"+ + "\u02a5\3\2\2\2\u02a5\u02a9\3\2\2\2\u02a6\u02a7\7\26\2\2\u02a7\u02a8\7"+ + "9\2\2\u02a8\u02aa\5b\62\2\u02a9\u02a6\3\2\2\2\u02a9\u02aa\3\2\2\2\u02aa"+ + "\u02af\3\2\2\2\u02ab\u02ac\7\26\2\2\u02ac\u02ad\79\2\2\u02ad\u02af\5b"+ + "\62\2\u02ae\u029d\3\2\2\2\u02ae\u02ab\3\2\2\2\u02af[\3\2\2\2\u02b0\u02b1"+ + "\7\27\2\2\u02b1\u02b6\5^\60\2\u02b2\u02b3\78\2\2\u02b3\u02b5\5^\60\2\u02b4"+ + "\u02b2\3\2\2\2\u02b5\u02b8\3\2\2\2\u02b6\u02b4\3\2\2\2\u02b6\u02b7\3\2"+ + "\2\2\u02b7\u02b9\3\2\2\2\u02b8\u02b6\3\2\2\2\u02b9\u02ba\79\2\2\u02ba"+ + "\u02bb\5b\62\2\u02bb]\3\2\2\2\u02bc\u02bf\5d\63\2\u02bd\u02be\7\13\2\2"+ + "\u02be\u02c0\5x=\2\u02bf\u02bd\3\2\2\2\u02bf\u02c0\3\2\2\2\u02c0_\3\2"+ + "\2\2\u02c1\u02c7\7\30\2\2\u02c2\u02c5\5d\63\2\u02c3\u02c4\7\13\2\2\u02c4"+ + "\u02c6\7*\2\2\u02c5\u02c3\3\2\2\2\u02c5\u02c6\3\2\2\2\u02c6\u02c8\3\2"+ + "\2\2\u02c7\u02c2\3\2\2\2\u02c7\u02c8\3\2\2\2\u02c8a\3\2\2\2\u02c9\u02d4"+ + "\5\36\20\2\u02ca\u02cb\7)\2\2\u02cb\u02cd\7d\2\2\u02cc\u02ce\5\34\17\2"+ + "\u02cd\u02cc\3\2\2\2\u02ce\u02cf\3\2\2\2\u02cf\u02cd\3\2\2\2\u02cf\u02d0"+ + "\3\2\2\2\u02d0\u02d1\3\2\2\2\u02d1\u02d2\7e\2\2\u02d2\u02d4\3\2\2\2\u02d3"+ + "\u02c9\3\2\2\2\u02d3\u02ca\3\2\2\2\u02d4c\3\2\2\2\u02d5\u02db\5l\67\2"+ + "\u02d6\u02d7\7\17\2\2\u02d7\u02d8\5l\67\2\u02d8\u02d9\7\21\2\2\u02d9\u02da"+ + "\5d\63\2\u02da\u02dc\3\2\2\2\u02db\u02d6\3\2\2\2\u02db\u02dc\3\2\2\2\u02dc"+ + "\u02df\3\2\2\2\u02dd\u02df\5h\65\2\u02de\u02d5\3\2\2\2\u02de\u02dd\3\2"+ + "\2\2\u02dfe\3\2\2\2\u02e0\u02e3\5l\67\2\u02e1\u02e3\5j\66\2\u02e2\u02e0"+ + "\3\2\2\2\u02e2\u02e1\3\2\2\2\u02e3g\3\2\2\2\u02e4\u02e6\7\31\2\2\u02e5"+ + "\u02e7\5\30\r\2\u02e6\u02e5\3\2\2\2\u02e6\u02e7\3\2\2\2\u02e7\u02e8\3"+ + "\2\2\2\u02e8\u02e9\79\2\2\u02e9\u02ea\5d\63\2\u02eai\3\2\2\2\u02eb\u02ed"+ + "\7\31\2\2\u02ec\u02ee\5\30\r\2\u02ed\u02ec\3\2\2\2\u02ed\u02ee\3\2\2\2"+ + "\u02ee\u02ef\3\2\2\2\u02ef\u02f0\79\2\2\u02f0\u02f1\5f\64\2\u02f1k\3\2"+ + "\2\2\u02f2\u02f7\5n8\2\u02f3\u02f4\7\32\2\2\u02f4\u02f6\5n8\2\u02f5\u02f3"+ + "\3\2\2\2\u02f6\u02f9\3\2\2\2\u02f7\u02f5\3\2\2\2\u02f7\u02f8\3\2\2\2\u02f8"+ + "m\3\2\2\2\u02f9\u02f7\3\2\2\2\u02fa\u02ff\5p9\2\u02fb\u02fc\7\33\2\2\u02fc"+ + "\u02fe\5p9\2\u02fd\u02fb\3\2\2\2\u02fe\u0301\3\2\2\2\u02ff\u02fd\3\2\2"+ + "\2\u02ff\u0300\3\2\2\2\u0300o\3\2\2\2\u0301\u02ff\3\2\2\2\u0302\u0303"+ + "\7\34\2\2\u0303\u0306\5p9\2\u0304\u0306\5r:\2\u0305\u0302\3\2\2\2\u0305"+ + "\u0304\3\2\2\2\u0306q\3\2\2\2\u0307\u030d\5x=\2\u0308\u0309\5t;\2\u0309"+ + "\u030a\5x=\2\u030a\u030c\3\2\2\2\u030b\u0308\3\2\2\2\u030c\u030f\3\2\2"+ + "\2\u030d\u030b\3\2\2\2\u030d\u030e\3\2\2\2\u030es\3\2\2\2\u030f\u030d"+ + "\3\2\2\2\u0310\u031e\7L\2\2\u0311\u031e\7M\2\2\u0312\u031e\7N\2\2\u0313"+ + "\u031e\7O\2\2\u0314\u031e\7P\2\2\u0315\u031e\7Q\2\2\u0316\u031e\7R\2\2"+ + "\u0317\u031e\7\24\2\2\u0318\u0319\7\34\2\2\u0319\u031e\7\24\2\2\u031a"+ + "\u031e\7\35\2\2\u031b\u031c\7\35\2\2\u031c\u031e\7\34\2\2\u031d\u0310"+ + "\3\2\2\2\u031d\u0311\3\2\2\2\u031d\u0312\3\2\2\2\u031d\u0313\3\2\2\2\u031d"+ + "\u0314\3\2\2\2\u031d\u0315\3\2\2\2\u031d\u0316\3\2\2\2\u031d\u0317\3\2"+ + "\2\2\u031d\u0318\3\2\2\2\u031d\u031a\3\2\2\2\u031d\u031b\3\2\2\2\u031e"+ + "u\3\2\2\2\u031f\u0320\7\65\2\2\u0320\u0321\5x=\2\u0321w\3\2\2\2\u0322"+ + "\u0327\5z>\2\u0323\u0324\7?\2\2\u0324\u0326\5z>\2\u0325\u0323\3\2\2\2"+ + "\u0326\u0329\3\2\2\2\u0327\u0325\3\2\2\2\u0327\u0328\3\2\2\2\u0328y\3"+ + "\2\2\2\u0329\u0327\3\2\2\2\u032a\u032f\5|?\2\u032b\u032c\7@\2\2\u032c"+ + "\u032e\5|?\2\u032d\u032b\3\2\2\2\u032e\u0331\3\2\2\2\u032f\u032d\3\2\2"+ + "\2\u032f\u0330\3\2\2\2\u0330{\3\2\2\2\u0331\u032f\3\2\2\2\u0332\u0337"+ + "\5~@\2\u0333\u0334\7A\2\2\u0334\u0336\5~@\2\u0335\u0333\3\2\2\2\u0336"+ + "\u0339\3\2\2\2\u0337\u0335\3\2\2\2\u0337\u0338\3\2\2\2\u0338}\3\2\2\2"+ + "\u0339\u0337\3\2\2\2\u033a\u033f\5\u0080A\2\u033b\u033c\t\4\2\2\u033c"+ + "\u033e\5\u0080A\2\u033d\u033b\3\2\2\2\u033e\u0341\3\2\2\2\u033f\u033d"+ + "\3\2\2\2\u033f\u0340\3\2\2\2\u0340\177\3\2\2\2\u0341\u033f\3\2\2\2\u0342"+ + "\u0347\5\u0082B\2\u0343\u0344\t\5\2\2\u0344\u0346\5\u0082B\2\u0345\u0343"+ + "\3\2\2\2\u0346\u0349\3\2\2\2\u0347\u0345\3\2\2\2\u0347\u0348\3\2\2\2\u0348"+ + "\u0081\3\2\2\2\u0349\u0347\3\2\2\2\u034a\u034f\5\u0084C\2\u034b\u034c"+ + "\t\6\2\2\u034c\u034e\5\u0084C\2\u034d\u034b\3\2\2\2\u034e\u0351\3\2\2"+ + "\2\u034f\u034d\3\2\2\2\u034f\u0350\3\2\2\2\u0350\u0083\3\2\2\2\u0351\u034f"+ + "\3\2\2\2\u0352\u0353\t\7\2\2\u0353\u0356\5\u0084C\2\u0354\u0356\5\u0086"+ + "D\2\u0355\u0352\3\2\2\2\u0355\u0354\3\2\2\2\u0356\u0085\3\2\2\2\u0357"+ + "\u035a\5\u0088E\2\u0358\u0359\7;\2\2\u0359\u035b\5\u0084C\2\u035a\u0358"+ + "\3\2\2\2\u035a\u035b\3\2\2\2\u035b\u0087\3\2\2\2\u035c\u035e\7(\2\2\u035d"+ + "\u035c\3\2\2\2\u035d\u035e\3\2\2\2\u035e\u035f\3\2\2\2\u035f\u0363\5\u008a"+ + "F\2\u0360\u0362\5\u008eH\2\u0361\u0360\3\2\2\2\u0362\u0365\3\2\2\2\u0363"+ + "\u0361\3\2\2\2\u0363\u0364\3\2\2\2\u0364\u0089\3\2\2\2\u0365\u0363\3\2"+ + "\2\2\u0366\u0369\7\66\2\2\u0367\u036a\5\u00aaV\2\u0368\u036a\5\u008cG"+ + "\2\u0369\u0367\3\2\2\2\u0369\u0368\3\2\2\2\u0369\u036a\3\2\2\2\u036a\u036b"+ + "\3\2\2\2\u036b\u0382\7\67\2\2\u036c\u036e\7=\2\2\u036d\u036f\5\u008cG"+ + "\2\u036e\u036d\3\2\2\2\u036e\u036f\3\2\2\2\u036f\u0370\3\2\2\2\u0370\u0382"+ + "\7>\2\2\u0371\u0373\7J\2\2\u0372\u0374\5\u009aN\2\u0373\u0372\3\2\2\2"+ + "\u0373\u0374\3\2\2\2\u0374\u0375\3\2\2\2\u0375\u0382\7K\2\2\u0376\u0382"+ + "\7*\2\2\u0377\u0382\7\4\2\2\u0378\u037a\7\3\2\2\u0379\u0378\3\2\2\2\u037a"+ + "\u037b\3\2\2\2\u037b\u0379\3\2\2\2\u037b\u037c\3\2\2\2\u037c\u0382\3\2"+ + "\2\2\u037d\u0382\7\64\2\2\u037e\u0382\7\36\2\2\u037f\u0382\7\37\2\2\u0380"+ + "\u0382\7 \2\2\u0381\u0366\3\2\2\2\u0381\u036c\3\2\2\2\u0381\u0371\3\2"+ + "\2\2\u0381\u0376\3\2\2\2\u0381\u0377\3\2\2\2\u0381\u0379\3\2\2\2\u0381"+ + "\u037d\3\2\2\2\u0381\u037e\3\2\2\2\u0381\u037f\3\2\2\2\u0381\u0380\3\2"+ + "\2\2\u0382\u008b\3\2\2\2\u0383\u0386\5d\63\2\u0384\u0386\5v<\2\u0385\u0383"+ + "\3\2\2\2\u0385\u0384\3\2\2\2\u0386\u0395\3\2\2\2\u0387\u0396\5\u00a4S"+ + "\2\u0388\u038b\78\2\2\u0389\u038c\5d\63\2\u038a\u038c\5v<\2\u038b\u0389"+ + "\3\2\2\2\u038b\u038a\3\2\2\2\u038c\u038e\3\2\2\2\u038d\u0388\3\2\2\2\u038e"+ + "\u0391\3\2\2\2\u038f\u038d\3\2\2\2\u038f\u0390\3\2\2\2\u0390\u0393\3\2"+ + "\2\2\u0391\u038f\3\2\2\2\u0392\u0394\78\2\2\u0393\u0392\3\2\2\2\u0393"+ + "\u0394\3\2\2\2\u0394\u0396\3\2\2\2\u0395\u0387\3\2\2\2\u0395\u038f\3\2"+ + "\2\2\u0396\u008d\3\2\2\2\u0397\u0399\7\66\2\2\u0398\u039a\5\u009eP\2\u0399"+ + "\u0398\3\2\2\2\u0399\u039a\3\2\2\2\u039a\u039b\3\2\2\2\u039b\u03a3\7\67"+ + "\2\2\u039c\u039d\7=\2\2\u039d\u039e\5\u0090I\2\u039e\u039f\7>\2\2\u039f"+ + "\u03a3\3\2\2\2\u03a0\u03a1\7\63\2\2\u03a1\u03a3\7*\2\2\u03a2\u0397\3\2"+ + "\2\2\u03a2\u039c\3\2\2\2\u03a2\u03a0\3\2\2\2\u03a3\u008f\3\2\2\2\u03a4"+ + "\u03a9\5\u0092J\2\u03a5\u03a6\78\2\2\u03a6\u03a8\5\u0092J\2\u03a7\u03a5"+ + "\3\2\2\2\u03a8\u03ab\3\2\2\2\u03a9\u03a7\3\2\2\2\u03a9\u03aa\3\2\2\2\u03aa"+ + "\u03ad\3\2\2\2\u03ab\u03a9\3\2\2\2\u03ac\u03ae\78\2\2\u03ad\u03ac\3\2"+ + "\2\2\u03ad\u03ae\3\2\2\2\u03ae\u0091\3\2\2\2\u03af\u03bb\5d\63\2\u03b0"+ + "\u03b2\5d\63\2\u03b1\u03b0\3\2\2\2\u03b1\u03b2\3\2\2\2\u03b2\u03b3\3\2"+ + "\2\2\u03b3\u03b5\79\2\2\u03b4\u03b6\5d\63\2\u03b5\u03b4\3\2\2\2\u03b5"+ + "\u03b6\3\2\2\2\u03b6\u03b8\3\2\2\2\u03b7\u03b9\5\u0094K\2\u03b8\u03b7"+ + "\3\2\2\2\u03b8\u03b9\3\2\2\2\u03b9\u03bb\3\2\2\2\u03ba\u03af\3\2\2\2\u03ba"+ + "\u03b1\3\2\2\2\u03bb\u0093\3\2\2\2\u03bc\u03be\79\2\2\u03bd\u03bf\5d\63"+ + "\2\u03be\u03bd\3\2\2\2\u03be\u03bf\3\2\2\2\u03bf\u0095\3\2\2\2\u03c0\u03c3"+ + "\5x=\2\u03c1\u03c3\5v<\2\u03c2\u03c0\3\2\2\2\u03c2\u03c1\3\2\2\2\u03c3"+ + "\u03cb\3\2\2\2\u03c4\u03c7\78\2\2\u03c5\u03c8\5x=\2\u03c6\u03c8\5v<\2"+ + "\u03c7\u03c5\3\2\2\2\u03c7\u03c6\3\2\2\2\u03c8\u03ca\3\2\2\2\u03c9\u03c4"+ + "\3\2\2\2\u03ca\u03cd\3\2\2\2\u03cb\u03c9\3\2\2\2\u03cb\u03cc\3\2\2\2\u03cc"+ + "\u03cf\3\2\2\2\u03cd\u03cb\3\2\2\2\u03ce\u03d0\78\2\2\u03cf\u03ce\3\2"+ + "\2\2\u03cf\u03d0\3\2\2\2\u03d0\u0097\3\2\2\2\u03d1\u03d6\5d\63\2\u03d2"+ + "\u03d3\78\2\2\u03d3\u03d5\5d\63\2\u03d4\u03d2\3\2\2\2\u03d5\u03d8\3\2"+ + "\2\2\u03d6\u03d4\3\2\2\2\u03d6\u03d7\3\2\2\2\u03d7\u03da\3\2\2\2\u03d8"+ + "\u03d6\3\2\2\2\u03d9\u03db\78\2\2\u03da\u03d9\3\2\2\2\u03da\u03db\3\2"+ + "\2\2\u03db\u0099\3\2\2\2\u03dc\u03dd\5d\63\2\u03dd\u03de\79\2\2\u03de"+ + "\u03df\5d\63\2\u03df\u03e3\3\2\2\2\u03e0\u03e1\7;\2\2\u03e1\u03e3\5x="+ + "\2\u03e2\u03dc\3\2\2\2\u03e2\u03e0\3\2\2\2\u03e3\u03f6\3\2\2\2\u03e4\u03f7"+ + "\5\u00a4S\2\u03e5\u03ec\78\2\2\u03e6\u03e7\5d\63\2\u03e7\u03e8\79\2\2"+ + "\u03e8\u03e9\5d\63\2\u03e9\u03ed\3\2\2\2\u03ea\u03eb\7;\2\2\u03eb\u03ed"+ + "\5x=\2\u03ec\u03e6\3\2\2\2\u03ec\u03ea\3\2\2\2\u03ed\u03ef\3\2\2\2\u03ee"+ + "\u03e5\3\2\2\2\u03ef\u03f2\3\2\2\2\u03f0\u03ee\3\2\2\2\u03f0\u03f1\3\2"+ + "\2\2\u03f1\u03f4\3\2\2\2\u03f2\u03f0\3\2\2\2\u03f3\u03f5\78\2\2\u03f4"+ + "\u03f3\3\2\2\2\u03f4\u03f5\3\2\2\2\u03f5\u03f7\3\2\2\2\u03f6\u03e4\3\2"+ + "\2\2\u03f6\u03f0\3\2\2\2\u03f7\u040d\3\2\2\2\u03f8\u03fb\5d\63\2\u03f9"+ + "\u03fb\5v<\2\u03fa\u03f8\3\2\2\2\u03fa\u03f9\3\2\2\2\u03fb\u040a\3\2\2"+ + "\2\u03fc\u040b\5\u00a4S\2\u03fd\u0400\78\2\2\u03fe\u0401\5d\63\2\u03ff"+ + "\u0401\5v<\2\u0400\u03fe\3\2\2\2\u0400\u03ff\3\2\2\2\u0401\u0403\3\2\2"+ + "\2\u0402\u03fd\3\2\2\2\u0403\u0406\3\2\2\2\u0404\u0402\3\2\2\2\u0404\u0405"+ + "\3\2\2\2\u0405\u0408\3\2\2\2\u0406\u0404\3\2\2\2\u0407\u0409\78\2\2\u0408"+ + "\u0407\3\2\2\2\u0408\u0409\3\2\2\2\u0409\u040b\3\2\2\2\u040a\u03fc\3\2"+ + "\2\2\u040a\u0404\3\2\2\2\u040b\u040d\3\2\2\2\u040c\u03e2\3\2\2\2\u040c"+ + "\u03fa\3\2\2\2\u040d\u009b\3\2\2\2\u040e\u040f\7!\2\2\u040f\u0415\7*\2"+ + "\2\u0410\u0412\7\66\2\2\u0411\u0413\5\u009eP\2\u0412\u0411\3\2\2\2\u0412"+ + "\u0413\3\2\2\2\u0413\u0414\3\2\2\2\u0414\u0416\7\67\2\2\u0415\u0410\3"+ + "\2\2\2\u0415\u0416\3\2\2\2\u0416\u0417\3\2\2\2\u0417\u0418\79\2\2\u0418"+ + "\u0419\5b\62\2\u0419\u009d\3\2\2\2\u041a\u041f\5\u00a0Q\2\u041b\u041c"+ + "\78\2\2\u041c\u041e\5\u00a0Q\2\u041d\u041b\3\2\2\2\u041e\u0421\3\2\2\2"+ + "\u041f\u041d\3\2\2\2\u041f\u0420\3\2\2\2\u0420\u0423\3\2\2\2\u0421\u041f"+ + "\3\2\2\2\u0422\u0424\78\2\2\u0423\u0422\3\2\2\2\u0423\u0424\3\2\2\2\u0424"+ + "\u009f\3\2\2\2\u0425\u0427\5d\63\2\u0426\u0428\5\u00a4S\2\u0427\u0426"+ + "\3\2\2\2\u0427\u0428\3\2\2\2\u0428\u0432\3\2\2\2\u0429\u042a\5d\63\2\u042a"+ + "\u042b\7<\2\2\u042b\u042c\5d\63\2\u042c\u0432\3\2\2\2\u042d\u042e\7;\2"+ + "\2\u042e\u0432\5d\63\2\u042f\u0430\7\65\2\2\u0430\u0432\5d\63\2\u0431"+ + "\u0425\3\2\2\2\u0431\u0429\3\2\2\2\u0431\u042d\3\2\2\2\u0431\u042f\3\2"+ + "\2\2\u0432\u00a1\3\2\2\2\u0433\u0436\5\u00a4S\2\u0434\u0436\5\u00a6T\2"+ + "\u0435\u0433\3\2\2\2\u0435\u0434\3\2\2\2\u0436\u00a3\3\2\2\2\u0437\u0439"+ + "\7\'\2\2\u0438\u0437\3\2\2\2\u0438\u0439\3\2\2\2\u0439\u043a\3\2\2\2\u043a"+ + "\u043b\7\23\2\2\u043b\u043c\5\u0096L\2\u043c\u043d\7\24\2\2\u043d\u043f"+ + "\5l\67\2\u043e\u0440\5\u00a2R\2\u043f\u043e\3\2\2\2\u043f\u0440\3\2\2"+ + "\2\u0440\u00a5\3\2\2\2\u0441\u0442\7\17\2\2\u0442\u0444\5f\64\2\u0443"+ + "\u0445\5\u00a2R\2\u0444\u0443\3\2\2\2\u0444\u0445\3\2\2\2\u0445\u00a7"+ + "\3\2\2\2\u0446\u0447\7*\2\2\u0447\u00a9\3\2\2\2\u0448\u044a\7\"\2\2\u0449"+ + "\u044b\5\u00acW\2\u044a\u0449\3\2\2\2\u044a\u044b\3\2\2\2\u044b\u00ab"+ + "\3\2\2\2\u044c\u044d\7\t\2\2\u044d\u0450\5d\63\2\u044e\u0450\5\u0098M"+ + "\2\u044f\u044c\3\2\2\2\u044f\u044e\3\2\2\2\u0450\u00ad\3\2\2\2\u00a8\u00b3"+ + "\u00b7\u00b9\u00c2\u00cb\u00ce\u00d5\u00db\u00e5\u00ec\u00f3\u00f9\u00fd"+ + "\u0103\u0109\u010d\u0114\u0116\u0118\u011d\u011f\u0121\u0125\u012b\u012f"+ + "\u0136\u0138\u013a\u013f\u0141\u0146\u014b\u0151\u0155\u015b\u0161\u0165"+ + "\u016c\u016e\u0170\u0175\u0177\u0179\u017d\u0183\u0187\u018e\u0190\u0192"+ + "\u0197\u0199\u019f\u01a6\u01aa\u01b6\u01bd\u01c2\u01c6\u01c9\u01cf\u01d3"+ + "\u01d8\u01dc\u01e0\u01ee\u01f6\u01fe\u0200\u0204\u020d\u0214\u0216\u021f"+ + "\u0224\u0229\u0230\u0234\u023b\u0243\u024c\u0255\u025c\u0267\u026d\u027a"+ + "\u0280\u0289\u0294\u029f\u02a4\u02a9\u02ae\u02b6\u02bf\u02c5\u02c7\u02cf"+ + "\u02d3\u02db\u02de\u02e2\u02e6\u02ed\u02f7\u02ff\u0305\u030d\u031d\u0327"+ + "\u032f\u0337\u033f\u0347\u034f\u0355\u035a\u035d\u0363\u0369\u036e\u0373"+ + "\u037b\u0381\u0385\u038b\u038f\u0393\u0395\u0399\u03a2\u03a9\u03ad\u03b1"+ + "\u03b5\u03b8\u03ba\u03be\u03c2\u03c7\u03cb\u03cf\u03d6\u03da\u03e2\u03ec"+ + "\u03f0\u03f4\u03f6\u03fa\u0400\u0404\u0408\u040a\u040c\u0412\u0415\u041f"+ + "\u0423\u0427\u0431\u0435\u0438\u043f\u0444\u044a\u044f"; + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} \ No newline at end of file diff --git a/src/gpsl/grammar/GpslLexer.g4 b/src/gpsl/grammar/GpslLexer.g4 new file mode 100644 index 0000000..3af6968 --- /dev/null +++ b/src/gpsl/grammar/GpslLexer.g4 @@ -0,0 +1,51 @@ +lexer grammar GpslLexer; + +WS + : [ \t\r\n] + -> skip + ; + +SHARP: '#' ; +DOLLER: '$' ; +ADD: '+' ; +SUB: '-' ; +MUL: '*' ; +DIV: '/' ; +CONJ: '&&' ; +AND: '&' ; +EQ: '=' ; +EQEQ: '==' ; +NE: '!=' ; +BE: '>=' ; +LE: '<=' ; +BT: '>' ; +LT: '<' ; +SEMICOLON: ';' ; +COLON: ':' ; +COMMA: ',' ; +DOT: '.' ; +QUOTE: '"' ; +ADD_ASSIGNMENT: '+=' ; +SUB_ASSIGNMENT: '-=' ; +MUL_ASSIGNMENT: '*=' ; +DIV_ASSIGNMENT: '/=' ; +LPAREN: '(' ; +RPAREN: ')' ; +LCURL: '{' ; +RCURL: '}' ; +LBRACKET: '[' ; +RBRACKET: ']' ; +ARROW: '->' ; + +FN: 'fn' ; +FOR: 'for' ; +WHILE: 'while' ; +IF: 'if' ; +ELSE: 'else' ; +LET: 'let' ; +RETURN: 'return' ; + +NUM: [1-9] [0-9]* ; + +TEXT: QUOTE [a-zA-Z0-9_-]* QUOTE ; +IDENT: [a-zA-Z_]+ ; diff --git a/src/gpsl/grammar/GpslParser.call-graph.svg b/src/gpsl/grammar/GpslParser.call-graph.svg new file mode 100644 index 0000000..3f4bd12 --- /dev/null +++ b/src/gpsl/grammar/GpslParser.call-graph.svg @@ -0,0 +1,4 @@ + + + +gpslFilefunctionprogramstmtletblockreturnifwhileforexprassignequalityrelationaladdmulprimaryfunction_callunaryEOFWSADDSUBMULDIVCONJANDEQEQEQNEBELEBTLTSEMICOLONCOLONCOMMADOTQUOTEADD_ASSIGNMENTSUB_ASSIGNMENTMUL_ASSIGNMENTDIV_ASSIGNMENTLPARENRPARENLCURLRCURLFNFORWHILEIFELSELETRETURNNUMTEXTIDENT \ No newline at end of file diff --git a/src/gpsl/grammar/GpslParser.g4 b/src/gpsl/grammar/GpslParser.g4 new file mode 100644 index 0000000..1c460c0 --- /dev/null +++ b/src/gpsl/grammar/GpslParser.g4 @@ -0,0 +1,42 @@ +parser grammar GpslParser; +options { tokenVocab = GpslLexer; } + +gpslFile: function* EOF ; + +function: FN IDENT LPAREN (IDENT COLON IDENT COMMA?)* RPAREN (ARROW IDENT)? block ; + +program: stmt* ; + +stmt: let + | block + | return + | if + | while + | for + | expr SEMICOLON + ; + +let: LET IDENT COLON IDENT SEMICOLON ; +block: permission? LCURL stmt* RCURL ; +return: RETURN expr? SEMICOLON ; +if: IF LPAREN expr RPAREN stmt (ELSE stmt)? ; +while: WHILE LPAREN expr RPAREN stmt ; +for: FOR LPAREN expr? SEMICOLON expr? SEMICOLON expr? RPAREN stmt ; + +mode: SHARP IDENT ; +permission: DOLLER LPAREN ( IDENT LBRACKET ( IDENT COMMA? )* RBRACKET COMMA? )* RPAREN ; + +expr: assign ; +assign: equality (EQ assign)? ; +equality: relational (EQEQ relational | NE relational | CONJ)* ; +relational: add (LE add | LT add | BE add | BT add)* ; +add: mul (ADD mul | SUB mul | SUB_ASSIGNMENT mul | ADD_ASSIGNMENT mul)* ; +mul: unary (MUL unary | DIV unary | DIV_ASSIGNMENT unary | MUL_ASSIGNMENT unary)* ; + +primary: LPAREN expr RPAREN | function_call | TEXT | NUM ; +function_call: IDENT LPAREN (unary COMMA?)* RPAREN ; + +unary: ADD primary + | SUB primary + | primary + ; diff --git a/src/gpsl/grammar/GpslParser.rrd.html b/src/gpsl/grammar/GpslParser.rrd.html new file mode 100644 index 0000000..a1cf99e --- /dev/null +++ b/src/gpsl/grammar/GpslParser.rrd.html @@ -0,0 +1,155 @@ + + + + + + + + + + + + + + +

gpslFile

+functionEOF + +

function

+FNIDENTLPARENIDENTCOLONIDENTCOMMAIDENTCOLONIDENTRPARENblock + +

program

+stmt + +

stmt

+letblockreturnifwhileforexprSEMICOLON + +

let

+LETIDENTCOLONIDENTSEMICOLON + +

block

+LCURLstmtRCURL + +

return

+RETURNexprSEMICOLON + +

if

+IFLPARENexprRPARENstmtELSEstmt + +

while

+WHILELPARENexprRPARENstmt + +

for

+FORLPARENexprSEMICOLONexprSEMICOLONexprRPARENstmt + +

expr

+assign + +

assign

+equalityEQassign + +

equality

+relationalEQEQrelationalNErelationalCONJ + +

relational

+addLEaddLTaddBEaddBTadd + +

add

+mulADDmulSUBmulSUB_ASSIGNMENTmulADD_ASSIGNMENTmul + +

mul

+unaryMULunaryDIVunaryDIV_ASSIGNMENTunaryMUL_ASSIGNMENTunary + +

primary

+LPARENexprRPARENfunction_callTEXTNUM + +

function_call

+IDENTLPARENunaryCOMMARPAREN + +

unary

+ADDprimarySUBprimaryprimary + +
\ No newline at end of file diff --git a/src/gpsl/grammar/dark.css b/src/gpsl/grammar/dark.css new file mode 100644 index 0000000..9ba3a51 --- /dev/null +++ b/src/gpsl/grammar/dark.css @@ -0,0 +1,242 @@ +/* + * This file contains all default CSS rules for the dark vscode them, used for various diagrams and graphs. + * Use the "antlr4.customcss" setting in vscode to specify your own file, if you like to override some rules. + * + * Usually most of the appearance is defined in light.css and here we only have some adjustments for + * the dark theme. + */ + + body.vscode-dark svg { + background: rgba(255, 255, 255, 0.05); +} + +/* ATN graphs. */ + +body.vscode-dark .marker { + fill: #eee; + stroke: none; +} + +body.vscode-dark .stateLabel { + fill: #202020; +} + +body.vscode-dark .stateTypeLabel { + fill: #404040; +} + +body.vscode-dark .linkLabel { + fill: #ddd; +} + +body.vscode-dark .state { + stroke: white; + filter: url(#white-glow); +} + +/* Railroad diagrams */ + +body.vscode-dark .atn-graph-save-image { + background: rgba(206, 11, 70, 1) url('../misc/save-dark.png'); +} + +body.vscode-dark .rrd-save-image { + background: rgba(10, 188, 80, 1) url('../misc/save-dark.png'); +} + +body.vscode-dark .call-graph-save-image { + background: rgba(255, 191, 15, 1) url('../misc/save-dark.png'); +} + +body.vscode-dark .parse-tree-save-image { + background: rgba(49, 112, 212, 1) url('../misc/save-dark.png'); +} + +body.vscode-dark svg.railroad-diagram path { + /* The connection lines. */ + stroke-width: 2; + stroke: darkgray; + fill: rgba(0, 0, 0, 0); +} + +body.vscode-dark svg.railroad-diagram text { + /* All text except comments. */ + font: bold 12px Hack, "Source Code Pro", monospace; + text-anchor: middle; + fill: #404040; + /* Use fill instead of color for svg text. */ +} + +body.vscode-dark svg.railroad-diagram text.comment { + /* Comment text */ + font: italic 10px Hack, "Source Code Pro", monospace; + fill: #909090; +} + +body.vscode-dark svg.railroad-diagram g.non-terminal rect { + /* The non-terminal boxes. */ + stroke-width: 2; + stroke: #404040; + fill: rgba(255, 255, 255, 1); +} + +body.vscode-dark svg.railroad-diagram g.terminal rect { + /* The terminal boxes. */ + stroke-width: 2; + stroke: #404040; + fill: rgba(255, 255, 255, 0.7); +} + +body.vscode-dark svg.railroad-diagram text.diagram-text { + /* Multiple choice text, not working atm. */ + font-size: 12px Hack, "Source Code Pro", monospace; + fill: red; +} + +body.vscode-dark svg.railroad-diagram path.diagram-text { + /* Multiple choice text, not working atm. */ + stroke-width: 1; + stroke: red; + fill: white; + cursor: help; +} + +body.vscode-dark svg.railroad-diagram g.diagram-text:hover path.diagram-text { + /* Multiple choice text, not working atm. */ + fill: #f00; +} + +/* Call graphs */ + +body.vscode-dark .node-source { + fill: #e6db74; +} + +body.vscode-dark .node-target { + fill: #45aa73; +} + +body.vscode-dark .module-1 { + fill: #0ca9fd; +} + +body.vscode-dark .module-2 { + fill: #63bf8d; +} + +body.vscode-dark .module-3 { + fill: #ff8801; +} + +body.vscode-dark .module-4 { + fill: #b9fc34; +} + +body.vscode-dark .module-5 { + fill: #90e0e0; +} + +body.vscode-dark .module-6 { + fill: #b4a3f5; +} + +body.vscode-dark .module-7 { + fill: #f92672; +} + +body.vscode-dark .module-8 { + fill: #e9e901; +} + +body.vscode-dark .module-9 { + fill: #83be69; +} + +body.vscode-dark .module-10 { + fill: #f1d18c; +} + +body.vscode-dark .node:hover { + fill: #fff; +} + +body.vscode-dark .node-source { + fill: #ff5711; +} + +body.vscode-dark .node-target { + fill: #45aa73; +} + +body.vscode-dark .link-source, +body.vscode-dark .link-target { + stroke-opacity: 1; + stroke-width: 2px; +} + +body.vscode-dark .link { + stroke: #fff; + stroke-opacity: .2; + fill: none; + pointer-events: none; + animation: fadeIn 0.5s ease-out 0.2s 1 normal backwards; +} + +body.vscode-dark .link-source { + stroke-opacity: 1; + stroke-width: 2px; + stroke: #45aa73; + animation: none; +} + +body.vscode-dark .link-target { + stroke-opacity: 1; + stroke-width: 2px; + stroke: #ff5711; + animation: none; +} + +body.vscode-dark .link-dimmed { + stroke-opacity: 0.075; + animation: fadeOut 0.25s ease-out 0s 1 normal backwards; +} + +/* Parse trees */ +body.vscode-dark .tree-node { + stroke-width: 2; + stroke: #404040; + fill: rgba(255, 255, 255, 1); +} + +body.vscode-dark g .tree-root { + stroke-width: 2; + fill: #3a3c37; + stroke: #ffffff; +} + +body.vscode-dark g .tree-leaf { + stroke-width: 2; + fill: #828e66; + stroke: #ffffff; +} + +body.vscode-dark g .tree-error { + stroke-width: 2; + fill: rgb(187, 43, 33); + stroke: #ffffff; +} + +body.vscode-dark g .token-value { + fill: white; + stroke: none; + font: 12pt "Source Code Pro", "Hack", "Consolas", "Andale Mono", monospace; +} + +body.vscode-dark g .token-range { + fill: #bb832c; + stroke: none; + font: 8pt "Source Code Pro", "Hack", "Consolas", "Andale Mono", monospace; +} + +/* Default CSS for internal elements, only visible in vscode */ + diff --git a/src/gpsl/grammar/light.css b/src/gpsl/grammar/light.css new file mode 100644 index 0000000..2d1b00c --- /dev/null +++ b/src/gpsl/grammar/light.css @@ -0,0 +1,484 @@ +/* + * This file contains all default CSS rules for the light vscode them, used for various diagrams and graphs. + * Use the "antlr4.customcss" setting in vscode to specify your own file, if you like to override some rules. + * + * Most of the appearance is defined here, while only some adjustments for the dark theme exist in dark.css. + * This style sheet is also used for exported svg files. + */ + + body { + padding-left: 20px; +} + +svg { + background: rgba(0, 0, 0, 0.03); +} + + +/* ATN graphs */ + +.transition { + fill: none; + stroke: #AAA; + stroke-width: 2px; +} + +.marker { + fill: #999; + stroke: none; +} + +.stateLabel { + font: bold 11pt "Helvetica Neue", Arial, sans-serif; + fill: white; + text-anchor: middle; + pointer-events: none; +} + +.stateTypeLabel { + font: bold 7pt monospace; + fill: #EEE; + text-anchor: middle; + pointer-events: none; +} + +.linkLabel { + font: bold 9pt "Helvetica Neue", Arial, sans-serif; + fill: #606060; + text-anchor: middle; + pointer-events: none; +} + +.state { + stroke: #505050; + stroke-width: 3px; + cursor: move; + pointer-events: all; + /*filter: url(#black-glow);*/ +} + +.state.BASIC { + fill: #AAA; +} + +.state.START { + fill: #36bde0; +} + +.state.BSTART { + fill: #f39900; +} + +.state.PBSTART { + fill: #98c000; +} + +.state.SBSTART { + fill: #607dbd; +} + +.state.TSTART { + fill: #ffd300; +} + +.state.STOP { + fill: #2baa5b; +} + +.state.BEND { + fill: #c2c269; +} + +.state.SLBACK { + fill: #608b4e; +} + +.state.SLENTRY { + fill: #a260cb; +} + +.state.PLBACK { + fill: #517979; +} + +.state.LEND { + fill: #9b90c3; +} + +.state.RULE { + fill: #b73645; +} + +.state.RULE.recursive { + fill: #36bde0; +} + + +/* Railroad diagrams */ + +svg.railroad-diagram path { + /* The connection lines. */ + stroke-width: 2; + stroke: darkgray; + fill: rgba(0, 0, 0, 0); +} + +svg.railroad-diagram text { + /* All text except comments. */ + font: bold 12px Hack, "Source Code Pro", monospace; + text-anchor: middle; + fill: #404040; + /* Use fill instead of color for svg text. */ +} + +svg.railroad-diagram text.comment { + /* Comment text */ + font: italic 10px Hack, "Source Code Pro", monospace; + fill: #404040; +} + +svg.railroad-diagram g.non-terminal rect { + /* The non-terminal boxes. */ + stroke-width: 2; + stroke: #404040; + fill: rgba(255, 255, 255, 1); +} + +svg.railroad-diagram g.terminal rect { + /* The terminal boxes. */ + stroke-width: 2; + stroke: #404040; + fill: rgba(0, 0, 0, 0.1); +} + +svg.railroad-diagram text.diagram-text { + /* Multiple choice text, not working atm. */ + font-size: 12px Hack, "Source Code Pro", monospace; + fill: red; +} + +svg.railroad-diagram path.diagram-text { + /* Multiple choice text, not working atm. */ + stroke-width: 1; + stroke: red; + fill: red; + cursor: help; +} + +svg.railroad-diagram g.diagram-text:hover path.diagram-text { + /* Multiple choice text, not working atm. */ + fill: #f00; +} + + +/* Call graphs */ + +.node { + font: 200 10px "Helvetica Neue", Helvetica, Arial, sans-serif; +} + +.link { + stroke: #000; + stroke-opacity: .2; + fill: none; + pointer-events: none; + animation: fadeIn 0.25s ease-out 0.2s 1 normal backwards; +} + +.module-1 { + fill: #0ca9fd; +} + +.module-2 { + fill: #63bf8d; +} + +.module-3 { + fill: #ff8801; +} + +.module-4 { + fill: #b9fc34; +} + +.module-5 { + fill: #90e0e0; +} + +.module-6 { + fill: #b4a3f5; +} + +.module-7 { + fill: #f92672; +} + +.module-8 { + fill: #e9e901; +} + +.module-9 { + fill: #83be69; +} + +.module-10 { + fill: #f1d18c; +} + +.node:hover { + fill: #000; +} + +.node:hover, +.node-source, +.node-target { + font: 700 12px "Helvetica Neue", Helvetica, Arial, sans-serif; + cursor: pointer; +} + +.node-source { + fill: #ff5711; +} + +.node-target { + fill: #45aa73; +} + +.link-source, +.link-target { + stroke-opacity: 1; + stroke-width: 2px; + animation: none; +} + +.link-source { + stroke: #3dcd92; +} + +.link-target { + stroke: #ff5711; +} + +@keyframes fadeOut { + 0% { + stroke-opacity: 0.2; + } + 100% { + stroke-opacity: 0.075; + } +} + +@keyframes fadeIn { + 0% { + stroke-opacity: 0.075; + } + 100% { + stroke-opacity: 0.2; + } +} + +.link-dimmed { + stroke-opacity: 0.075; + animation: fadeOut 0.25s ease-out 0.1s 1 normal backwards; +} + + +/* Parse trees */ +.tree-node { + stroke-width: 2; + stroke: #C0C0C0; + fill: rgba(255, 255, 255, 1); +} + +.tree-root { + stroke-width: 2; + fill: #7db6dd; + stroke: #7db6dd; +} + +.tree-leaf { + cursor: default; + stroke-width: 2; + fill: rgba(160, 171, 136, 1); + stroke: rgba(117, 119, 91, 1); +} + +.tree-error { + stroke-width: 2; + fill: #dd8f7d; + stroke: rgba(188, 106, 122, 1); +} + +.tree-node text { + cursor: default; + font: 16px "Helvetica Neue", sans-serif; + fill: rgba(41, 41, 41, 1); + stroke: none; +} + +.tree-leaf text, +.tree-root text, +.tree-error text { + font: 16px "Helvetica Neue", sans-serif; + fill: #ffffff; + stroke: none; +} + +.tree-link { + stroke-width: 2px; + fill: none; + stroke: rgba(128, 128, 128, 1); +} + +g .token-value { + fill: #404040; + stroke: none; + font: 14pt "Source Code Pro", "Hack", "Consolas", "Andale Mono", monospace; +} + +g .token-range { + fill: rgba(0, 77, 98, 1); + stroke: none; + font: 8pt "Source Code Pro", "Hack", "Consolas", "Andale Mono", monospace; +} + +/* Internal elements, only used in vscode */ + +.header { + font-size: 12pt; + z-index: 9999; + top: 0; + left: 0; + right: 0; + height: 45px; + background-color: var(--background-color); + cursor: default; + user-select: none; + white-space: nowrap; +} + +.graph-initial { + font-size: 30pt; + font-weight: 600; + vertical-align: middle; +} + +.rule-index { + font-size: 8pt; +} + +#container { + margin-top: 45px; +} + +.action-box { + font: 10pt monospace; + margin-left: 15px; + padding: 5px; + border: dotted 1px #606060; + cursor: default; +} + +.atn-graph-color { + color: rgba(206, 11, 70, 1); +} + +.atn-graph-save-image { + background: rgba(206, 11, 70, 1) url('../misc/save.png'); + vertical-align: middle; + margin-left: 5px; + width: 24px; + height: 24px; + display: inline-block; + cursor: pointer; +} + +.rrd-color { + color: rgba(10, 188, 80, 1); +} + +.rrd-save-image { + background: rgba(10, 188, 80, 1) url('../misc/save.png'); + vertical-align: middle; + margin-left: 5px; + width: 24px; + height: 24px; + display: inline-block; + cursor: pointer; +} + +.call-graph-color { + color: rgba(255, 191, 15, 1); +} + +.call-graph-save-image { + background: rgba(255, 191, 15, 1) url('../misc/save.png'); + vertical-align: middle; + margin-left: 5px; + width: 24px; + height: 24px; + display: inline-block; + cursor: pointer; +} + +.parse-tree-color { + color: rgba(49, 112, 212, 1); +} + +.parse-tree-save-image { + background: rgba(49, 112, 212, 1) url('../misc/save.png'); + vertical-align: middle; + margin-left: 5px; + width: 24px; + height: 24px; + display: inline-block; + cursor: pointer; +} + +.switch label { + width: 100%; + height: 100%; + margin: 0; + padding: 0; + display: block; + position: absolute; + top: 0; + left: 0; + z-index: 10; +} + +.switch input { + display: none; +} + +.switch > span { + display: inline-block; + top: 3px; + transition: left 0.2s; +} + +.switch-border { + height: 12px; + width: 24px; + position: relative; + border: 1px solid rgba(49, 112, 212, 0.75); + background-color: rgba(49, 112, 212, 0.75); + border-radius: 3.5em; +} + +.switch-handle-top { + width: 12px; + height: 12px; + position: absolute; + left: 0px; + top: 0px; + z-index: 4; + background-color: white; + border-radius: 2.5em; + transition: left 0.2s; +} + +.switch input:checked~.switch-handle-top { + top: 0px; + left: 12px; +} diff --git a/src/gpsl/mod.rs b/src/gpsl/mod.rs new file mode 100644 index 0000000..394e03e --- /dev/null +++ b/src/gpsl/mod.rs @@ -0,0 +1,9 @@ +pub mod external_function; +pub mod node; +pub mod parser; +pub mod permission; +pub mod source; +pub mod token; +pub mod tokenizer; +pub mod variable; +pub mod vm; diff --git a/src/gpsl/node.rs b/src/gpsl/node.rs new file mode 100644 index 0000000..e8594f6 --- /dev/null +++ b/src/gpsl/node.rs @@ -0,0 +1,90 @@ +use std::collections::HashMap; + +#[derive(Debug, PartialEq, Clone)] +pub enum NodeKind { + ASSIGN, + ADD, + SUB, + MUL, + DIV, + EQ, // == + NE, // != + LT, // < + LE, // <= +} + +#[derive(Debug, Clone, PartialEq)] +pub enum Node { + Function { + name: String, + args: HashMap, + body: Vec>, + }, + Mode { + mode: String, + }, + Permission { + accept: Vec, + reject: Vec, + }, + Operator { + kind: NodeKind, + lhs: Box, + rhs: Box, + }, + Number { + value: usize, + }, + Text { + value: String, + }, + Lvar { + value: String, + }, + Return { + lhs: Box, + }, + If { + condition: Box, + stmt: Box, + else_stmt: Option>, + }, + While { + condition: Box, + stmt: Box, + }, + For { + init: Option>, + condition: Option>, + update: Option>, + stmt: Box, + }, + Block { + stmts: Vec>, + permission: Option>, + mode: Option>, + }, + Define { + name: String, + var_type: String, + }, + Call { + name: String, + args: Vec>, + }, + None, +} + +impl Node { + pub fn new_node(kind: NodeKind, lhs: Box, rhs: Box) -> Box { + Box::new(Node::Operator { kind, lhs, rhs }) + } + + pub fn new_num_node(value: usize) -> Box { + Box::new(Node::Number { value }) + } + + pub fn new_lvar_node(value: String) -> Box { + Box::new(Node::Lvar { value }) + } +} diff --git a/src/gpsl/parser.rs b/src/gpsl/parser.rs new file mode 100644 index 0000000..a5c017c --- /dev/null +++ b/src/gpsl/parser.rs @@ -0,0 +1,454 @@ +use crate::gpsl::node::*; +use crate::gpsl::token::*; +use crate::gpsl::tokenizer::*; +use log::*; +use std::collections::HashMap; + +#[derive(Clone)] +pub struct Parser { + pub tokenizer: Tokenizer, + pub local_vars: HashMap, +} + +impl Parser { + pub fn functions(&mut self) -> Result>, String> { + let mut nodes: HashMap> = HashMap::new(); + loop { + if self.tokenizer.current_token().kind != TokenKind::EOF { + let function = self.function()?; + if let Node::Function { name, .. } = *function.clone() { + nodes.insert(name, function); + } + } else { + return Ok(nodes); + } + } + } + + /* + function: FN IDENT LPAREN (IDENT COLON IDENT COMMA?)* RPAREN (ARROW IDENT)? block ; + */ + pub fn function(&mut self) -> Result, String> { + if self + .tokenizer + .consume_kind_str(TokenKind::RESERVED, String::from("fn")) + { + debug!("parsing function"); + let func_name = self.tokenizer.current_token().clone(); + self.tokenizer.expect_kind(TokenKind::IDENT)?; + let mut args = HashMap::new(); + self.tokenizer.expect(String::from("("))?; + debug!("parsing args"); + while !self + .tokenizer + .consume_kind_str(TokenKind::RESERVED, String::from(")")) + { + debug!("consume argument"); + let name = self.tokenizer.expect_ident()?; + self.tokenizer + .consume_kind_str(TokenKind::RESERVED, String::from(":")); + let type_str = self.tokenizer.expect_ident()?; + self.tokenizer + .consume_kind_str(TokenKind::RESERVED, String::from(",")); + args.insert(name, type_str); + } + + let mut nodes: Vec> = vec![]; + debug!("parsing body node"); + loop { + nodes.push(self.stmt()?); + debug!("body nodes parsed"); + //self.tokenizer.expect(String::from("}"))?; + return Ok(Box::new(Node::Function { + name: func_name.str, + args, + body: nodes, + })); + } + } else { + println!("{:?}", self.tokenizer.current_token()); + Err(String::from("Unexpected token.")) + } + } + + /* + program: stmt* ; + */ + pub fn program(&mut self) -> Result>, String> { + let mut nodes: Vec> = vec![]; + loop { + if self.tokenizer.current_token().kind != TokenKind::EOF { + nodes.push(self.stmt()?); + } else { + return Ok(nodes); + } + } + } + + /* + stmt: let + | block + | return + | if + | while + | for + | expr SEMICOLON + ; + */ + pub fn stmt(&mut self) -> Result, String> { + if self + .tokenizer + .consume_kind_str(TokenKind::IDENT, String::from("let")) + { + let ident = self.tokenizer.current_token().clone(); + self.tokenizer.expect_kind(TokenKind::IDENT)?; + self.tokenizer.expect(String::from(":"))?; + let var_type = self.tokenizer.current_token().clone(); + self.tokenizer.expect_kind(TokenKind::IDENT)?; + self.tokenizer.expect(String::from(";"))?; + return Ok(Box::new(Node::Define { + name: ident.str, + var_type: var_type.str, + })); + } + + debug!("parsing permission"); + let permission = if self.tokenizer.current_token().str == "$" { + Some(self.permission()?) + } else { + None + }; + + debug!("parsing mode"); + let mode = if self.tokenizer.current_token().str == "#" { + Some(self.mode()?) + } else { + None + }; + + if self + .tokenizer + .consume_kind_str(TokenKind::RESERVED, String::from("{")) + || permission != None + { + let mut stmts: Vec> = vec![]; + loop { + if self + .tokenizer + .consume_kind_str(TokenKind::RESERVED, String::from("}")) + { + return Ok(Box::new(Node::Block { + stmts, + permission: permission, + mode: mode, + })); + } else { + stmts.push(self.stmt()?); + } + } + } + + if self.tokenizer.consume_kind(TokenKind::RETURN) { + let node = Node::Return { lhs: self.expr()? }; + self.tokenizer.expect(String::from(";"))?; + return Ok(Box::new(node)); + } + + if self.tokenizer.current_token().kind == TokenKind::CONTROL { + match &*self.tokenizer.current_token().str { + "if" => { + self.tokenizer.cursor += 1; + self.tokenizer.expect(String::from("("))?; + let condition = self.expr()?; + self.tokenizer.expect(String::from(")"))?; + let stmt = self.stmt()?; + let mut else_stmt: Option> = None; + if self + .tokenizer + .consume_kind_str(TokenKind::CONTROL, String::from("else")) + { + else_stmt = Some(self.stmt()?); + } + return Ok(Box::new(Node::If { + condition, + stmt, + else_stmt, + })); + } + "while" => { + self.tokenizer.cursor += 1; + self.tokenizer.expect(String::from("("))?; + let condition = self.expr()?; + self.tokenizer.expect(String::from(")"))?; + let stmt = self.stmt()?; + return Ok(Box::new(Node::While { condition, stmt })); + } + "for" => { + self.tokenizer.cursor += 1; + self.tokenizer.expect(String::from("("))?; + let init: Option> = + if self.tokenizer.current_token().str != String::from(";") { + Some(self.expr()?) + } else { + None + }; + self.tokenizer.expect(String::from(";"))?; + + let condition: Option> = + if self.tokenizer.current_token().str != String::from(";") { + Some(self.expr()?) + } else { + None + }; + self.tokenizer.expect(String::from(";"))?; + + let update: Option> = + if self.tokenizer.current_token().str != String::from(")") { + Some(self.expr()?) + } else { + None + }; + self.tokenizer.expect(String::from(")"))?; + + let stmt = self.stmt()?; + + return Ok(Box::new(Node::For { + init, + condition, + update, + stmt, + })); + } + _ => {} + } + } + + let node = self.expr(); + self.tokenizer.expect(String::from(";"))?; + return node; + } + + /* + mode: SHARP IDENT ; + */ + pub fn mode(&mut self) -> Result, String> { + self.tokenizer.expect(String::from("#"))?; + let mode = self.tokenizer.current_token().clone(); + self.tokenizer.expect_kind(TokenKind::IDENT)?; + return Ok(Box::new(Node::Mode { mode: mode.str })); + } + + /* + permission: DOLLER LPAREN ( IDENT LBRACKET ( IDENT COMMA? )* RBRACKET COMMA? )* RPAREN ; + */ + pub fn permission(&mut self) -> Result, String> { + self.tokenizer.expect(String::from("$"))?; + self.tokenizer.expect(String::from("("))?; + + let mut accept: Vec = vec![]; + let mut reject: Vec = vec![]; + + while !self + .tokenizer + .consume_kind_str(TokenKind::RESERVED, String::from(")")) + { + let name = self.tokenizer.expect_ident()?; + if name != "accept" && name != "reject" { + return Err(String::from(format!("Unexpected: {}", name))); + } + self.tokenizer + .consume_kind_str(TokenKind::RESERVED, String::from("[")); + while !self + .tokenizer + .consume_kind_str(TokenKind::RESERVED, String::from("]")) + { + let permission = self.tokenizer.expect_ident()?; + self.tokenizer + .consume_kind_str(TokenKind::RESERVED, String::from(",")); + + if name == "accept" { + accept.push(permission); + } else if name == "reject" { + reject.push(permission); + } + } + + self.tokenizer + .consume_kind_str(TokenKind::RESERVED, String::from(",")); + } + + Ok(Box::new(Node::Permission { accept, reject })) + } + + /* + expr: assign ; + */ + pub fn expr(&mut self) -> Result, String> { + Ok(self.assign()?) + } + + /* + assign: equality (EQ assign)? ; + */ + pub fn assign(&mut self) -> Result, String> { + let mut node = self.equality()?; + + if self.tokenizer.consume(String::from("=")) { + node = Node::new_node(NodeKind::ASSIGN, node, self.assign()?); + } + + Ok(node) + } + + /* + equality: relational (EQEQ relational | NE relational | CONJ)* ; + */ + pub fn equality(&mut self) -> Result, String> { + let mut node = self.relational()?; + + loop { + if self.tokenizer.consume(String::from("==")) { + node = Node::new_node(NodeKind::EQ, node, self.relational()?); + } else if self.tokenizer.consume(String::from("!=")) { + node = Node::new_node(NodeKind::NE, node, self.relational()?); + } else { + return Ok(node); + } + } + } + + /* + relational: add (LE add | LT add | BE add | BT add)* ; + */ + pub fn relational(&mut self) -> Result, String> { + let mut node = self.add()?; + + loop { + if self.tokenizer.consume(String::from("<=")) { + node = Node::new_node(NodeKind::LE, node, self.add()?); + } else if self.tokenizer.consume(String::from("<")) { + node = Node::new_node(NodeKind::LT, node, self.add()?); + } else if self.tokenizer.consume(String::from(">=")) { + node = Node::new_node(NodeKind::LE, self.add()?, node); + } else if self.tokenizer.consume(String::from(">")) { + node = Node::new_node(NodeKind::LT, self.add()?, node); + } else { + return Ok(node); + } + } + } + + /* + add: mul (ADD mul | SUB mul | SUB_ASSIGNMENT mul | ADD_ASSIGNMENT mul)* ; + */ + pub fn add(&mut self) -> Result, String> { + let mut node = self.mul()?; + + loop { + if self.tokenizer.consume(String::from("+")) { + node = Node::new_node(NodeKind::ADD, node, self.mul()?); + } else if self.tokenizer.consume(String::from("-")) { + node = Node::new_node(NodeKind::SUB, node, self.mul()?); + } else if self.tokenizer.consume(String::from("+=")) { + node = Node::new_node( + NodeKind::ASSIGN, + Box::new((*node).clone()), + Node::new_node(NodeKind::ADD, node, self.mul()?), + ); + } else if self.tokenizer.consume(String::from("-=")) { + node = Node::new_node( + NodeKind::ASSIGN, + Box::new((*node).clone()), + Node::new_node(NodeKind::SUB, node, self.mul()?), + ); + } else { + return Ok(node); + } + } + } + + /* + mul: unary (MUL unary | DIV unary | DIV_ASSIGNMENT unary | MUL_ASSIGNMENT unary)* ; + */ + pub fn mul(&mut self) -> Result, String> { + let mut node = self.unary()?; + loop { + if self.tokenizer.consume(String::from("*")) { + node = Node::new_node(NodeKind::MUL, node, self.unary()?); + } else if self.tokenizer.consume(String::from("/")) { + node = Node::new_node(NodeKind::DIV, node, self.unary()?); + } else if self.tokenizer.consume(String::from("*=")) { + node = Node::new_node( + NodeKind::ASSIGN, + Box::new((*node).clone()), + Node::new_node(NodeKind::MUL, node, self.unary()?), + ); + } else if self.tokenizer.consume(String::from("/=")) { + node = Node::new_node( + NodeKind::ASSIGN, + Box::new((*node).clone()), + Node::new_node(NodeKind::DIV, node, self.unary()?), + ); + } else { + return Ok(node); + } + } + } + + /* + primary: LPAREN expr RPAREN | function_call | TEXT | NUM ; + */ + pub fn primary(&mut self) -> Result, String> { + if self.tokenizer.consume(String::from("(")) { + let node = self.expr()?; + self.tokenizer.expect(String::from(")"))?; + return Ok(node); + } + + if self.tokenizer.current_token().kind == TokenKind::IDENT { + let node = self.tokenizer.expect_ident()?; + if self.tokenizer.consume(String::from("(")) { + let mut args: Vec> = vec![]; + while self.tokenizer.current_token().str != ")" { + args.push(self.unary()?); + self.tokenizer.consume(String::from(",")); + } + + self.tokenizer.expect(String::from(")"))?; + return Ok(Box::new(Node::Call { + name: node.clone(), + args: args, + })); + } + return Ok(Node::new_lvar_node(node.clone())); + } + + if self.tokenizer.current_token().kind == TokenKind::TEXT { + let text = self.tokenizer.current_token().str.clone(); + self.tokenizer.consume_kind(TokenKind::TEXT); + return Ok(Box::new(Node::Text { value: text })); + } + + return Ok(Node::new_num_node(self.tokenizer.expect_number()?)); + } + + /* + unary: ADD primary + | SUB primary + | primary + ; + */ + pub fn unary(&mut self) -> Result, String> { + if self.tokenizer.consume(String::from("+")) { + return Ok(self.primary()?); + } + if self.tokenizer.consume(String::from("-")) { + return Ok(Node::new_node( + NodeKind::SUB, + Node::new_num_node(0), + self.primary()?, + )); + } + return Ok(self.primary()?); + } +} diff --git a/src/gpsl/permission.rs b/src/gpsl/permission.rs new file mode 100644 index 0000000..7878495 --- /dev/null +++ b/src/gpsl/permission.rs @@ -0,0 +1,16 @@ + +#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)] +pub enum Permission { + Administrator, + StdIo +} + +impl Permission { + pub fn from_string(permission: &str) -> Self { + match permission { + "Administrator" => Self::Administrator, + "StdIo" => Self::StdIo, + _ => panic!("Permission not found.") + } + } +} \ No newline at end of file diff --git a/src/gpsl/source.rs b/src/gpsl/source.rs new file mode 100644 index 0000000..e827619 --- /dev/null +++ b/src/gpsl/source.rs @@ -0,0 +1,91 @@ +#[derive(Clone)] +pub struct Source { + pub src: Vec, + pub pos: usize, +} + +impl Source { + pub fn get_char(&mut self, check: impl Fn(char) -> bool) -> Result { + match self.get_next() { + Ok(c) => { + if check(c) { + Ok(c) + } else { + self.pos -= 1; + Err(String::from("Not found.")) + } + } + + Err(text) => Err(text), + } + } + + pub fn get_string(&mut self, string: String) -> Result { + let first_pos = self.pos; + for i in 0..string.chars().count() { + if self.has_next() { + match self.get_next() { + Ok(c) => { + if c == string.chars().nth(i).unwrap() { + continue; + } else { + self.pos = first_pos; + return Err(String::from("")); + } + } + Err(_) => {} + } + } else { + self.pos = first_pos; + return Err(String::from("")); + } + } + + Ok(string) + } + + pub fn get_chars(&mut self, check: impl Fn(char) -> bool) -> Result { + let mut buffer = String::from(""); + while self.has_next() { + match self.get_next() { + Ok(c) => { + if check(c) { + buffer += &c.to_string(); + } else { + self.pos -= 1; + break; + } + } + Err(_) => { + break; + } + } + } + + if buffer == "" { + Err(String::from("Not found.")) + } else { + Ok(buffer) + } + } + + pub fn get_next(&mut self) -> Result { + self.pos += 1; + if self.src.len() > self.pos - 1 { + Ok(self.src[self.pos - 1]) + } else { + Err(String::from("EOF")) + } + } + + pub fn new(src: String) -> Source { + Source { + src: src.chars().collect(), + pos: 0, + } + } + + pub fn has_next(&self) -> bool { + self.src.len() > self.pos + } +} diff --git a/src/gpsl/token.rs b/src/gpsl/token.rs new file mode 100644 index 0000000..1ddf831 --- /dev/null +++ b/src/gpsl/token.rs @@ -0,0 +1,17 @@ +#[derive(Clone, Copy, Debug, PartialEq)] +pub enum TokenKind { + CONTROL, + RETURN, + RESERVED, + IDENT, + NUMBER, + EOF, + TEXT, +} + +#[derive(Clone, Debug)] +pub struct Token { + pub kind: TokenKind, + pub num: usize, + pub str: String, +} diff --git a/src/gpsl/tokenizer.rs b/src/gpsl/tokenizer.rs new file mode 100644 index 0000000..cb2989b --- /dev/null +++ b/src/gpsl/tokenizer.rs @@ -0,0 +1,270 @@ +use crate::gpsl::source::*; +use crate::gpsl::token::*; +use log::*; + +#[derive(Clone)] +pub struct Tokenizer { + pub tokens: Vec, + pub cursor: usize, +} +impl Tokenizer { + pub fn current_token(&mut self) -> &mut Token { + &mut self.tokens[self.cursor] + } + + pub fn consume(&mut self, op: String) -> bool { + debug!("consume OP {} {:?}", op, self.current_token()); + return if self.current_token().kind != TokenKind::RESERVED || self.current_token().str != op + { + false + } else { + self.cursor += 1; + true + }; + } + + pub fn consume_kind(&mut self, kind: TokenKind) -> bool { + debug!("consume kind {:?} {:?}", kind, self.current_token()); + return if self.current_token().kind != kind { + false + } else { + self.cursor += 1; + true + }; + } + + pub fn consume_kind_str(&mut self, kind: TokenKind, string: String) -> bool { + debug!( + "consume kind str {:?} {:?} {:?}", + kind, + string, + self.current_token() + ); + return if self.current_token().kind == kind && self.current_token().str == string { + self.cursor += 1; + true + } else { + false + }; + } + + pub fn expect(&mut self, op: String) -> Result<(), String> { + debug!("Expect OP {} {:?}", op, self.current_token()); + if self.current_token().str != op { + return Err(format!("Unexpected type : {}", op)); + } + self.cursor += 1; + Ok(()) + } + + pub fn expect_kind(&mut self, kind: TokenKind) -> Result<(), String> { + debug!("expect kind {:?} {:?}", kind, self.current_token()); + if self.current_token().kind != kind { + return Err(format!("Unexpected token: {:?}", self.current_token().kind)); + } + self.cursor += 1; + Ok(()) + } + + pub fn expect_ident(&mut self) -> Result { + debug!("Expect IDENT {:?}", self.current_token()); + if self.current_token().kind != TokenKind::IDENT { + return Err(format!("Unexpected type : {:?}", self.current_token().kind)); + } + let val = self.current_token().str.clone(); + self.cursor += 1; + Ok(val.to_string()) + } + + pub fn expect_number(&mut self) -> Result { + let kind = self.current_token().kind; + debug!("Expect NUM {:?}", self.current_token()); + if kind != TokenKind::NUMBER { + return Err(format!("Unexpected type : {:?}", kind)); + } + let val = self.current_token().num; + self.cursor += 1; + Ok(val) + } + + pub fn new() -> Tokenizer { + Tokenizer { + cursor: 0, + tokens: vec![], + } + } + + pub fn create_reserved(op: String) -> Token { + Token { + kind: TokenKind::RESERVED, + str: op, + num: 0, + } + } + + pub fn create_number(num: usize) -> Token { + Token { + kind: TokenKind::NUMBER, + num: num, + str: String::default(), + } + } + + pub fn tokenize(&mut self, source: &mut Source) -> Result, String> { + let reserved: Vec = vec![ + String::from("+="), + String::from("-="), + String::from("*="), + String::from("/="), + String::from("#"), + String::from("$"), + String::from("+"), + String::from("-"), + String::from("*"), + String::from("/"), + String::from("&&"), + String::from("&"), + String::from("{"), + String::from("}"), + String::from("("), + String::from(")"), + String::from("["), + String::from("]"), + String::from("=="), + String::from("!="), + String::from(">="), + String::from("<="), + String::from("<"), + String::from(">"), + String::from("="), + String::from(";"), + String::from(":"), + String::from(","), + String::from("\""), + String::from("fn"), + String::from("->"), + ]; + + let controls: Vec = vec![ + String::from("for"), + String::from("while"), + String::from("if"), + String::from("else"), + ]; + + while source.has_next() { + match source.get_char(is('"')) { + Ok(_) => { + let text = match source.get_chars(not(is('"'))) { + Ok(t) => t, + Err(_) => String::from(""), + }; + source.get_char(is('"'))?; + self.tokens.push(Token { + kind: TokenKind::TEXT, + str: text, + num: 0, + }); + continue; + } + Err(_) => {} + } + match source.get_char(is_whitespace) { + Ok(_) => { + continue; + } + Err(_) => {} + } + match contains_list_chars(source, reserved.clone()) { + Ok(op) => { + self.tokens + .push(Tokenizer::create_reserved(String::from(op))); + continue; + } + Err(_) => {} + } + match source.get_chars(is_digit) { + Ok(num) => { + self.tokens + .push(Tokenizer::create_number(num.parse().unwrap())); + continue; + } + Err(_) => {} + } + match source.get_chars(or(is_ascii, or(is_digit, is('_')))) { + Ok(c) => { + if c == String::from("return") { + self.tokens.push(Token { + kind: TokenKind::RETURN, + str: String::default(), + num: 0, + }); + continue; + } + + if controls.contains(&c) { + self.tokens.push(Token { + kind: TokenKind::CONTROL, + str: c, + num: 0, + }); + continue; + } + + self.tokens.push(Token { + kind: TokenKind::IDENT, + str: c, + num: 0, + }); + continue; + } + Err(_) => {} + } + return Err(String::from("Failed to tokenize")); + } + + self.tokens.push(Token { + kind: TokenKind::EOF, + str: String::default(), + num: 0, + }); + + Ok(self.tokens.clone()) + } +} + +fn contains_list_chars(source: &mut Source, list: Vec) -> Result { + for target in list { + match source.get_string(target) { + Ok(string) => { + return Ok(string); + } + Err(_) => {} + } + } + return Err(String::from("")); +} + +fn or(f: impl Fn(char) -> bool, g: impl Fn(char) -> bool) -> impl Fn(char) -> bool { + move |c| f(c) || g(c) +} + +fn is(ch: char) -> impl Fn(char) -> bool { + move |c| c == ch +} + +fn not(f: impl Fn(char) -> bool) -> impl Fn(char) -> bool { + move |c| !f(c) +} + +fn is_whitespace(c: char) -> bool { + c.is_whitespace() +} + +fn is_digit(c: char) -> bool { + c.is_digit(10) +} + +fn is_ascii(c: char) -> bool { + c.is_alphabetic() +} diff --git a/src/gpsl/variable.rs b/src/gpsl/variable.rs new file mode 100644 index 0000000..af459e9 --- /dev/null +++ b/src/gpsl/variable.rs @@ -0,0 +1,8 @@ +use serde::{Deserialize, Serialize}; +#[derive(Clone, PartialEq, Debug, Serialize, Deserialize)] +pub enum Variable { + Number { value: usize }, + Text { value: String }, + Return { value: Box }, + None {}, +} diff --git a/src/gpsl/vm/gpsl.rs b/src/gpsl/vm/gpsl.rs new file mode 100644 index 0000000..62f0bac --- /dev/null +++ b/src/gpsl/vm/gpsl.rs @@ -0,0 +1,530 @@ +use crate::gpsl::external_function::{ + ExternalFuncCallData, ExternalFuncReturn, ExternalFuncStatus, +}; +use crate::gpsl::node::*; +use crate::gpsl::permission::Permission; +use crate::gpsl::source::Source; +use crate::gpsl::variable::*; +use log::*; +use std::collections::{HashMap, VecDeque}; +use std::net::TcpStream; +use std::string::*; + +#[derive(Clone, Debug)] +pub struct Block { + pub accept: Vec, + pub reject: Vec, + pub variables: HashMap, + pub is_split: bool, +} + +pub struct GPSL { + pub functions: Option>>, + pub global_variables: Vec, + pub source: Source, + pub blocks: VecDeque, + pub tcp_stream: Option, + pub external_func: Vec< + fn( + String, + Vec, + Vec, + Vec, + Option, + ) -> ExternalFuncReturn, + >, +} + +#[derive(Clone, Debug)] +pub struct LocalVariable { + pub name: String, + pub value: Variable, + pub status: VariableStatus, +} + +#[derive(Clone, Debug)] +pub struct VariableStatus { + pub initialized: bool, +} + +impl VariableStatus { + pub fn default() -> VariableStatus { + VariableStatus { initialized: false } + } +} + +impl GPSL { + pub fn new( + source: Source, + functions: Option>>, + tcp_sream: Option, + external_func: Vec< + fn( + String, + Vec, + Vec, + Vec, + Option, + ) -> ExternalFuncReturn, + >, + ) -> GPSL { + GPSL { + source, + functions, + global_variables: vec![], + blocks: VecDeque::new(), + tcp_stream: tcp_sream, + external_func, + } + } + + pub fn get_local_var_mut(&mut self, name: &String) -> Option<&mut LocalVariable> { + for x in 0..self.blocks.len() { + if self.blocks[x].variables.contains_key(name) { + return self.blocks[x].variables.get_mut(name); + } + + if self.blocks[x].is_split { + break; + } + } + None + } + + pub fn get_local_var(&mut self, name: &String) -> Option { + for x in 0..self.blocks.len() { + if self.blocks[x].variables.contains_key(name) { + if let Some(var) = self.blocks[x].variables.get(name).clone() { + return Some(var.clone()); + } else { + return None; + } + } + + if self.blocks[x].is_split { + break; + } + } + None + } + + pub fn extract_number(node: Variable) -> Result { + match node { + Variable::Number { value } => Ok(value), + _ => Err(String::from("Not a number")), + } + } + + pub fn evaluate(&mut self, node: Box) -> Result, String> { + match *node { + Node::Call { name, args } => { + let function_name = name; + let f = self.external_func.clone(); + let mut args_value: Vec = vec![]; + for arg in args { + if let Some(val) = self.evaluate(arg).expect("Cannot evaluate") { + args_value.push(val); + } + } + + if let Some(functions) = self.functions.clone() { + debug!( + "functions: {:?}", + functions + .iter() + .map(|f| format!("{},", f.0)) + .collect::() + ); + debug!( + "{}: {}", + &function_name, + functions.contains_key(&function_name) + ); + if functions.contains_key(&function_name) { + if let Node::Function { body, .. } = &*(functions[&function_name]) { + for program in body { + let block = { + let blocks = self.blocks.clone(); + blocks.front().unwrap().clone() + }; + + self.blocks.push_front(Block { + accept: block.accept.clone(), + reject: block.reject.clone(), + variables: HashMap::new(), + is_split: true, + }); + + let res = self.evaluate(Box::new(*program.clone())); + + if let Ok(Some(res)) = res { + match res { + Variable::Return { value } => { + return Ok(Some(*value)); + } + _ => {} + } + } else if let Err(err) = res { + return Err(err); + } + + self.blocks.pop_front(); + } + } + return Ok(None); + } + } + + debug!("Searching external: {}, ({:?})", &function_name, args_value); + + for func in f { + let block = self.blocks.front().unwrap(); + let res = func( + function_name.clone(), + args_value.clone(), + block.accept.clone(), + block.reject.clone(), + Some(ExternalFuncCallData { + stream: Some(self.tcp_stream.unwrap().try_clone().unwrap()), + }), + ); + if res.status == ExternalFuncStatus::SUCCESS { + return Ok(res.value); + } + if res.status == ExternalFuncStatus::REJECTED { + return Err("External function rejected.".to_string()); + } + } + + Err(format!("Function not found: {}", function_name)) + } + Node::Text { value } => Ok(Some(Variable::Text { value })), + Node::Number { value } => Ok(Some(Variable::Number { value })), + Node::Operator { kind, lhs, rhs } => { + if kind == NodeKind::ASSIGN { + debug!("Assign: {:?}", self.blocks.front()); + + let rhs = self.evaluate(rhs); + + if let Ok(Some(rhs)) = rhs { + match *(lhs.clone()) { + Node::Lvar { value } => { + self.get_local_var_mut(&value).unwrap().value = rhs; + self.get_local_var_mut(&value).unwrap().status.initialized = true; + } + _ => {} + } + } + + return Ok(None); + } + let lhs = self.evaluate(lhs).expect("Cannot evaluate lhs."); + let rhs = self.evaluate(rhs).expect("Cannot evaluate rhs."); + + if let Some(lhs) = lhs { + if let Some(rhs) = rhs { + match kind { + NodeKind::ADD => match GPSL::extract_number(lhs) { + Ok(lhs) => match GPSL::extract_number(rhs) { + Ok(rhs) => Ok(Some(Variable::Number { value: lhs + rhs })), + Err(err) => Err(err), + }, + Err(err) => Err(err), + }, + NodeKind::DIV => match GPSL::extract_number(lhs) { + Ok(lhs) => match GPSL::extract_number(rhs) { + Ok(rhs) => Ok(Some(Variable::Number { value: lhs / rhs })), + Err(err) => Err(err), + }, + Err(err) => Err(err), + }, + NodeKind::MUL => match GPSL::extract_number(lhs) { + Ok(lhs) => match GPSL::extract_number(rhs) { + Ok(rhs) => Ok(Some(Variable::Number { value: lhs * rhs })), + Err(err) => Err(err), + }, + Err(err) => Err(err), + }, + NodeKind::SUB => match GPSL::extract_number(lhs) { + Ok(lhs) => match GPSL::extract_number(rhs) { + Ok(rhs) => Ok(Some(Variable::Number { value: lhs - rhs })), + Err(err) => Err(err), + }, + Err(err) => Err(err), + }, + + NodeKind::EQ => { + if lhs == rhs { + Ok(Some(Variable::Number { value: 1 })) + } else { + Ok(Some(Variable::Number { value: 0 })) + } + } + NodeKind::NE => { + if lhs != rhs { + Ok(Some(Variable::Number { value: 1 })) + } else { + Ok(Some(Variable::Number { value: 0 })) + } + } + NodeKind::LT => match GPSL::extract_number(lhs) { + Ok(lhs) => match GPSL::extract_number(rhs) { + Ok(rhs) => { + if lhs < rhs { + Ok(Some(Variable::Number { value: 1 })) + } else { + Ok(Some(Variable::Number { value: 0 })) + } + } + Err(err) => Err(err), + }, + Err(err) => Err(err), + }, + NodeKind::LE => match GPSL::extract_number(lhs) { + Ok(lhs) => match GPSL::extract_number(rhs) { + Ok(rhs) => { + if lhs <= rhs { + Ok(Some(Variable::Number { value: 1 })) + } else { + Ok(Some(Variable::Number { value: 0 })) + } + } + Err(err) => Err(err), + }, + Err(err) => Err(err), + }, + _ => Ok(None), + } + } else { + Err(String::from("RHS Variable is null.")) + } + } else { + Err(String::from("LHS Variable is null.")) + } + } + Node::Lvar { value } => { + return Ok(Some(self.get_local_var(&value).unwrap().value.clone())); + } + Node::Return { lhs } => { + if let Ok(Some(lhs)) = self.evaluate(lhs) { + return Ok(Some(Variable::Return { + value: Box::new(lhs), + })); + } else { + return Err(String::from("Cannot evaluate LHS.")); + } + } + Node::If { + condition, + stmt, + else_stmt, + } => { + if let Ok(Some(condition)) = self.evaluate(condition) { + if match condition { + Variable::Number { value } => value == 1, + _ => false, + } { + if let Ok(Some(res)) = self.evaluate(stmt) { + match res.clone() { + Variable::Return { .. } => { + return Ok(Some(res)); + } + _ => {} + } + } + } else { + match else_stmt { + Some(else_stmt) => { + if let Ok(Some(res)) = self.evaluate(else_stmt) { + match res.clone() { + Variable::Return { .. } => { + return Ok(Some(res)); + } + _ => {} + } + } + } + None => {} + } + } + } + + return Ok(None); + } + Node::While { condition, stmt } => { + let mut cond = if let Some(condition) = self.evaluate(condition.clone())? { + condition + } else { + Variable::Number { value: 0 } + }; + + while match cond { + Variable::Number { value } => value == 1, + _ => false, + } { + self.evaluate(stmt.clone())?; + cond = if let Some(condition) = self.evaluate(condition.clone())? { + condition + } else { + Variable::Number { value: 0 } + }; + } + + return Ok(None); + } + Node::For { + init, + condition, + update, + stmt, + } => { + match init { + Some(init) => { + self.evaluate(init)?; + } + None => {} + } + + let mut cond = match condition.clone() { + Some(condition) => { + if let Some(condition) = self.evaluate(condition)? { + condition + } else { + Variable::Number { value: 0 } + } + } + None => Variable::Number { value: 1 }, + }; + + while match cond { + Variable::Number { value } => value == 1, + _ => false, + } { + self.evaluate(stmt.clone())?; + + match update.clone() { + Some(update) => { + self.evaluate(update)?; + } + None => {} + } + + cond = match condition.clone() { + Some(condition) => { + if let Some(condition) = self.evaluate(condition)? { + condition + } else { + Variable::Number { value: 0 } + } + } + None => Variable::Number { value: 1 }, + }; + } + + return Ok(None); + } + Node::Block { + stmts, + permission, + mode, + } => { + let accept = self.blocks.front().unwrap().accept.clone(); + let reject = self.blocks.front().unwrap().reject.clone(); + let (accept, reject) = if let Node::Permission { accept, reject } = + *permission.unwrap_or(Box::new(Node::None)) + { + ( + accept.iter().map(|p| Permission::from_string(p)).collect(), + reject.iter().map(|p| Permission::from_string(p)).collect(), + ) + } else { + (accept, reject) + }; + + let mode = if let Node::Mode { mode } = *mode.unwrap_or(Box::new(Node::None)) { + mode + } else { + "".to_string() + }; + println!("Mode: {}", mode); + + self.blocks.push_front(Block { + accept: accept, + reject: reject, + variables: HashMap::new(), + is_split: false, + }); + + for stmt in stmts { + let ret = self.evaluate(stmt)?; + if let Some(ret) = ret { + match ret.clone() { + Variable::Return { .. } => { + return Ok(Some(ret)); + } + _ => {} + } + } + } + + self.blocks.pop_front(); + + return Ok(None); + } + Node::Define { name, var_type } => { + let value = if var_type == "num" { + Variable::Number { value: 0 } + } else if var_type == "String" { + Variable::Text { + value: String::default(), + } + } else { + return Err(format!("{}: 未知の型です。", var_type)); + }; + self.blocks.front_mut().unwrap().variables.insert( + name.clone(), + LocalVariable { + name, + value, + status: VariableStatus::default(), + }, + ); + + debug!("Define: {:?}", self.blocks.front()); + + return Ok(None); + } + _ => Ok(None), + } + } + + pub fn run(&mut self, function_name: String, _: Vec>) -> Result { + debug!("functions: {:?}", self.functions); + debug!("searching {}", function_name); + self.blocks.push_front(Block { + accept: vec![Permission::Administrator, Permission::StdIo], + reject: vec![], + variables: HashMap::new(), + is_split: true, + }); + if let Some(functions) = self.functions.clone() { + if let Node::Function { body, .. } = &*(functions[&function_name]) { + for program in body { + let res = self.evaluate(Box::new(*program.clone())); + if let Ok(Some(res)) = res { + match res { + Variable::Return { value } => { + return Ok(*value); + } + _ => {} + } + } else if let Err(err) = res { + return Err(err); + } + } + } + } + + Ok(Variable::None {}) + } +} diff --git a/src/gpsl/vm/mod.rs b/src/gpsl/vm/mod.rs new file mode 100644 index 0000000..9b0fcc5 --- /dev/null +++ b/src/gpsl/vm/mod.rs @@ -0,0 +1 @@ +pub mod gpsl; \ No newline at end of file diff --git a/src/lib.rs b/src/lib.rs index 64af232..9ccc515 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,2 +1,5 @@ +pub mod common; pub mod elliptic_curve; -pub mod common; \ No newline at end of file +pub mod gpsl; +#[macro_use] +extern crate log; diff --git a/src/main.rs b/src/main.rs index 23bccdd..117e889 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,16 +1,16 @@ - -use std::{fs, collections::HashMap}; - -use encrypt::{elliptic_curve::elliptic_curve::EllipticCurvePoint, common::finite_field::FiniteFieldElement}; -use gpsl::{source::Source, tokenizer::Tokenizer, vm::gpsl::GPSL, external_function::STD_FUNC}; +mod gpsl; +use gpsl::variable::Variable; +use gpsl::{external_function::STD_FUNC, parser::*, source::*, tokenizer::*, vm::gpsl::*}; use primitive_types::U512; +use std::net::{TcpListener, TcpStream}; +use std::{collections::HashMap, fs}; /* -[6139062701328441600, -[258929920560, 23709360], -[[Mod(3308825380872319861, 6139062703770505681), Mod(4839630718792142583, 6139062703770505681)], +[6139062701328441600, +[258929920560, 23709360], +[[Mod(3308825380872319861, 6139062703770505681), Mod(4839630718792142583, 6139062703770505681)], [Mod(4767914906170010398, 6139062703770505681), Mod(2445476831433994309, 6139062703770505681)]]] */ - /* +/* fn main() { let p = U512::from_str_radix("6717051393902806321", 10).unwrap(); @@ -57,29 +57,52 @@ struct Args { file: String, } +fn listen_tcp_server(port: u16) -> TcpStream { + let listener = TcpListener::bind(format!("localhost:{}", port)).unwrap(); + for stream in listener.incoming() { + match stream { + Ok(stream) => { + println!("New connection: {}", stream.peer_addr().unwrap()); + return stream; + } + Err(e) => { + panic!("Error: {}", e); + } + } + } + panic!("Cannot connect to client"); +} + fn main() { let args = Args::parse(); + let s = serde_json::to_string(&Variable::Number { value: 0 }); + println!("{}", s.unwrap()); match &*args.mode { "gpsl" => { - let mut source = Source::new(fs::read_to_string(&(args.file)).expect("Cannot read file.")); + let mut source = + Source::new(fs::read_to_string(&(args.file)).expect("Cannot read file.")); let mut tokenizer = Tokenizer::new(); tokenizer.tokenize(&mut source).unwrap(); - + let mut parser = gpsl::parser::Parser { tokenizer, - local_vars: HashMap::new() + local_vars: HashMap::new(), }; - - let mut gpsl = GPSL::new(source, Some(parser.functions().unwrap()), vec![STD_FUNC]); + + let stream = listen_tcp_server(8080); + let mut gpsl = GPSL::new( + source, + Some(parser.functions().unwrap()), + Some(stream), + vec![STD_FUNC], + ); let res = gpsl.run("main".to_string(), vec![]); if let Err(err) = res { println!("Error: {:?}", err); } } - _ => { - - } + _ => {} } } diff --git a/test.gpsl b/test.gpsl index 760d8d7..863af1f 100644 --- a/test.gpsl +++ b/test.gpsl @@ -1,3 +1,3 @@ -fn main() { - println("test"); +fn main() #server { + println(receive()); }