@@ -65,11 +65,38 @@
1.8
1.8
1.8
- 1.4.20
+ 1.9.0
UTF-8
+
+
+
+ com.google.cloud
+ libraries-bom
+ 4.3.0
+ pom
+ import
+
+
+
+
+
+ com.theokanning.openai-gpt3-java
+ service
+ 0.18.2
+
+
+ com.google.cloud
+ google-cloud-translate
+
+
+
+ com.deepl.api
+ deepl-java
+ 1.4.0
+
org.springframework.boot
spring-boot-starter
@@ -84,7 +111,7 @@
org.projectlombok
lombok
- 1.18.8
+ 1.18.28
com.fasterxml.jackson.core
@@ -99,7 +126,7 @@
de.poiu.apron
apron
- 2.1.1-FGFIX
+ 2.1.1
@@ -140,7 +167,7 @@
junit
junit
- 4.13.1
+ 4.13
test
@@ -167,9 +194,15 @@
${kotlin.version}
test
+
+ org.antlr
+ antlr4
+ 4.13.1
+
+ babylon
org.apache.maven.plugins
@@ -181,6 +214,7 @@
maven-javadoc-plugin
3.2.0
+ false
none
@@ -205,7 +239,8 @@
true
false
forked-path
- -Dgpg.passphrase=${gpg.passphrase}
+ -Dgpg.passphrase=${gpg.passphrase} -DskipTests=true
+ release-sign-artifacts
@@ -347,38 +382,40 @@
+
-
-
- release-sign-artifacts
-
-
- performRelease
- true
-
-
-
-
-
- org.apache.maven.plugins
- maven-gpg-plugin
- 1.6
-
-
- sign-artifacts
- verify
-
- sign
-
-
-
-
-
-
-
-
+
+
+ release-sign-artifacts
+
+
+
+ org.apache.maven.plugins
+ maven-gpg-plugin
+ 1.6
+
+
+ sign-artifacts
+ verify
+
+ sign
+
+
+
+
+
+
+ --pinentry-mode
+ loopback
+
+
+
+
+
+
+
-
\ No newline at end of file
+
diff --git a/src/main/java/one/edee/babylon/MainService.java b/src/main/java/one/edee/babylon/MainService.java
index bced085..2e2d62e 100644
--- a/src/main/java/one/edee/babylon/MainService.java
+++ b/src/main/java/one/edee/babylon/MainService.java
@@ -29,12 +29,15 @@ public MainService(Exporter exporter,
this.importProcessor = importProcessor;
}
- public void startTranslation(Action action, TranslationConfiguration configuration, String spreadsheetId) throws IOException, GeneralSecurityException, InterruptedException {
+ public void startTranslation(Action action, TranslationConfiguration configuration, String spreadsheetId, boolean combineSheets) throws IOException, GeneralSecurityException, InterruptedException {
long stTime = System.currentTimeMillis();
switch (action) {
case EXPORT:
log.info("Babylon starting...");
- exporter.walkPathsAndWriteSheets(configuration.getPath(), configuration.getMutations(), spreadsheetId, configuration.getSnapshotPath(), configuration.getLockedCellEditor());
+ exporter.walkPathsAndWriteSheets(
+ configuration,
+ spreadsheetId,
+ combineSheets);
break;
case IMPORT:
importProcessor.doImport(spreadsheetId);
diff --git a/src/main/java/one/edee/babylon/SpringBootConsoleApplication.java b/src/main/java/one/edee/babylon/SpringBootConsoleApplication.java
index 848ef83..f768935 100644
--- a/src/main/java/one/edee/babylon/SpringBootConsoleApplication.java
+++ b/src/main/java/one/edee/babylon/SpringBootConsoleApplication.java
@@ -44,7 +44,7 @@ public void run(String... args) {
try {
log.info("Loading config file: '" + arguments.getConfigFileName() + "'");
TranslationConfiguration configuration = configurationReader.readAndCheckConfiguration(arguments.getConfigFileName());
- mainService.startTranslation(arguments.getAction(), configuration, arguments.getGoogleSheetId());
+ mainService.startTranslation(arguments.getAction(), configuration, arguments.getGoogleSheetId(), arguments.isCombineSheets());
} catch (Exception e) {
log.error("BABYLON ERROR: ", e);
System.exit(-1);
@@ -56,8 +56,8 @@ public void run(String... args) {
* @param args
* @return
*/
- private Arguments parseArguments(String... args) {
- if (args.length != 3) {
+ public static Arguments parseArguments(String... args) {
+ if (!(args.length == 3 || args.length == 4 || args.length == 5)) {
log.error("Invalid input arguments, required: ");
printRequiredArguments();
System.exit(-1);
@@ -74,13 +74,17 @@ private Arguments parseArguments(String... args) {
}
arguments.setConfigFileName(args[1]);
arguments.setGoogleSheetId(args[2]);
+ if (args.length > 3){
+ arguments.setCombineSheets(Boolean.parseBoolean(args[3]));
+ }
return arguments;
}
- private void printRequiredArguments() {
+ private static void printRequiredArguments() {
log.info("1 - expected action (import, export)");
log.info("2 - path to translator-config.json file");
log.info("3 - ID of the google sheet (e.g. 1xhnBAOpy8-9KWhl8NP0ZIy6mhlgXKnKcLJwKcIeyjPc)");
+ log.info("4 - arg to specify combineSheets mode");
}
/**
@@ -88,7 +92,7 @@ private void printRequiredArguments() {
* @author Tomas Langer (langer@fg.cz), FG Forrest a.s. (c) 2019
*/
@Data
- static class Arguments {
+ public static class Arguments {
/**
* See {@link Action}
@@ -104,6 +108,12 @@ static class Arguments {
* Id of the target google spreadsheet.
*/
private String googleSheetId;
+
+ /**
+ * Allows writing only to one sheet with name all.
+ * This mode is useful to correct duplicates, etc.
+ */
+ private boolean combineSheets = false;
}
}
diff --git a/src/main/java/one/edee/babylon/config/SupportedTranslators.java b/src/main/java/one/edee/babylon/config/SupportedTranslators.java
new file mode 100644
index 0000000..8115d74
--- /dev/null
+++ b/src/main/java/one/edee/babylon/config/SupportedTranslators.java
@@ -0,0 +1,30 @@
+package one.edee.babylon.config;
+
+/**
+ * I apologize in advance for the lack of documentation in this code.
+ * I had every intention of providing clear and concise explanations
+ * for every line of code, but then I got distracted by a squirrel outside
+ * my window and the next thing I knew it was three weeks later.
+ *
+ * So instead, I've included some helpful comments here and there.
+ * They might not make sense, but hey, at least they're something.
+ *
+ * @author Štěpán Kameník (kamenik@fg.cz), FG Forrest a.s. (c) 2024
+ **/
+public enum SupportedTranslators {
+
+ /**
+ * @see one.edee.babylon.export.translator.GoogleTranslator
+ */
+ GOOGLE,
+
+ /**
+ * @see one.edee.babylon.export.translator.DeeplTranslator
+ */
+ DEEPL,
+
+ /**
+ * @see one.edee.babylon.export.translator.OpenAiTranslator
+ */
+ OPENAI
+}
diff --git a/src/main/java/one/edee/babylon/config/TranslationConfiguration.java b/src/main/java/one/edee/babylon/config/TranslationConfiguration.java
index 930d5eb..fa76723 100644
--- a/src/main/java/one/edee/babylon/config/TranslationConfiguration.java
+++ b/src/main/java/one/edee/babylon/config/TranslationConfiguration.java
@@ -5,6 +5,7 @@
import lombok.NoArgsConstructor;
import lombok.NonNull;
import lombok.RequiredArgsConstructor;
+import org.jetbrains.annotations.Nullable;
import java.io.Serializable;
import java.nio.file.Path;
@@ -41,7 +42,25 @@ public class TranslationConfiguration implements Serializable {
*/
private List mutations = new ArrayList<>();
- private List lockedCellEditor = new ArrayList<>();
+ private List lockedCellEditors = new ArrayList<>();
+
+ /**
+ * Default language of project properties.
+ */
+ @NonNull
+ private String defaultLang;
+
+ /**
+ * Default language of project properties.
+ */
+ @Nullable
+ private SupportedTranslators translator;
+
+ /**
+ * Default language of project properties.
+ */
+ @Nullable
+ private String translatorApiKey;
@JsonIgnore
public Path getSnapshotPath() {
diff --git a/src/main/java/one/edee/babylon/db/SnapshotManager.java b/src/main/java/one/edee/babylon/db/SnapshotManager.java
index 551d887..feba0c8 100644
--- a/src/main/java/one/edee/babylon/db/SnapshotManager.java
+++ b/src/main/java/one/edee/babylon/db/SnapshotManager.java
@@ -89,12 +89,12 @@ private Snapshot getExistingDataFileFromDisk(Path snapshotFile) throws IOExcepti
}
/**
- * This map {@link Snapshot#getDataPropFilesById()} is excluded from Json serialization, so after deserialization of
- * {@link Snapshot} from file is necessary to load this map from loaded {@link Snapshot#getDataPropFiles()}.
+ * This map {@link Snapshot#dataPropFilesById} is excluded from Json serialization, so after deserialization of
+ * {@link Snapshot} from file is necessary to load this map from loaded {@link Snapshot#getProps()}.
* @param df DataFile object with map to load in.
*/
private void loadDataPropFilesIds(Snapshot df) {
- df.getDataPropFiles().forEach((key, value) -> {
+ df.getProps().forEach((key, value) -> {
if (value.getId() != null) {
df.putDataPropFileById(value.getId(), value);
} else {
diff --git a/src/main/java/one/edee/babylon/entity/MessageFileContent.java b/src/main/java/one/edee/babylon/entity/MessageFileContent.java
index d544d3b..80cf21c 100644
--- a/src/main/java/one/edee/babylon/entity/MessageFileContent.java
+++ b/src/main/java/one/edee/babylon/entity/MessageFileContent.java
@@ -2,10 +2,11 @@
import com.fasterxml.jackson.annotation.JsonFilter;
import com.fasterxml.jackson.annotation.JsonIgnore;
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.*;
import one.edee.babylon.enums.PropertyStatus;
import one.edee.babylon.snapshot.Snapshot;
-import lombok.Data;
-import lombok.NoArgsConstructor;
+import org.apache.commons.io.IOUtils;
import java.io.Serializable;
import java.util.LinkedHashMap;
@@ -30,6 +31,9 @@ public class MessageFileContent implements Serializable {
/**
* Properties like {@link PropertiesMap}
*/
+ @Getter(AccessLevel.PRIVATE)
+ @Setter(AccessLevel.PRIVATE)
+ @JsonProperty("properties")
private PropertiesMap properties = new PropertiesMap();
/**
@@ -41,6 +45,12 @@ public class MessageFileContent implements Serializable {
@JsonIgnore
private Map mutationProperties = new LinkedHashMap<>();
+
+ public boolean hasSameValue(String msgKey, String currentMsg) {
+ currentMsg = normalizeContent(currentMsg);
+ return properties.get(msgKey).equals(currentMsg);
+ }
+
/**
* Puts value for property for specified key and set logical working state of property like value of {@link PropertyStatus}:
* - {@link PropertyStatus#NEW} if key not exists
@@ -51,6 +61,7 @@ public class MessageFileContent implements Serializable {
* @return Old value of property or null if no property exists for given key.
*/
public String putProperty(String key, String value) {
+ value = normalizeContent(value);
String result = properties.put(key, value);
if (result == null) {
putPropertyStatus(key, PropertyStatus.NEW);
@@ -68,7 +79,7 @@ public String putProperty(String key, String value) {
* @param value property value
*/
public String putProperty(String key, String value, PropertyStatus propertyStatus) {
- return properties.put(key, value, propertyStatus);
+ return properties.put(key, normalizeContent(value), propertyStatus);
}
public String putMutationProperty(String mutation, String key, String value) {
@@ -77,7 +88,7 @@ public String putMutationProperty(String mutation, String key, String value) {
propertiesMap = new PropertiesMap();
mutationProperties.put(mutation, propertiesMap);
}
- return propertiesMap.put(key, value);
+ return propertiesMap.put(key, normalizeContent(value));
}
public String getPropertyValue(String propertyKey) {
@@ -99,6 +110,22 @@ public PropertiesMap putMutationProperties(String mutation, PropertiesMap proper
public PropertiesMap getMutationProperties(String mutation) {
return mutationProperties.get(mutation);
}
+
+ private String normalizeContent(String value) {
+ String lineSeparator = System.lineSeparator();
+ if (lineSeparator.equals(IOUtils.LINE_SEPARATOR_WINDOWS))
+ return value;
+ return value == null ? null : value.replace(lineSeparator, IOUtils.LINE_SEPARATOR_WINDOWS);
+ }
+
+ public boolean containsKey(String key) {
+ return properties.containsKey(key);
+ }
+
+ @JsonIgnore
+ public Integer getPropertiesSize() {
+ return properties.size();
+ }
}
diff --git a/src/main/java/one/edee/babylon/enums/PropertyType.java b/src/main/java/one/edee/babylon/enums/PropertyType.java
index 85745ba..ad71e34 100644
--- a/src/main/java/one/edee/babylon/enums/PropertyType.java
+++ b/src/main/java/one/edee/babylon/enums/PropertyType.java
@@ -1,9 +1,9 @@
package one.edee.babylon.enums;
-import one.edee.babylon.properties.Property;
+import one.edee.babylon.properties.AbstractProperty;
/**
- * Enum of all types of properties {@link Property}
+ * Enum of all types of properties {@link AbstractProperty}
* @author Tomas Langer (langer@fg.cz), FG Forrest a.s. (c) 2019
*/
public enum PropertyType {
@@ -13,7 +13,7 @@ public enum PropertyType {
VALUE,
/**
* Property value (key=value) with multi line value escaped by '\'. *
- * {@link Property#getValue()} method is overridden to return value as single string separated by '\' + line separator.
+ * {@link AbstractProperty#getValue()} method is overridden to return value as single string separated by '\' + line separator.
*/
MULTILINE,
/**
diff --git a/src/main/java/one/edee/babylon/export/ApronMessageLoader.java b/src/main/java/one/edee/babylon/export/ApronMessageLoader.java
index 55f1401..89c4599 100644
--- a/src/main/java/one/edee/babylon/export/ApronMessageLoader.java
+++ b/src/main/java/one/edee/babylon/export/ApronMessageLoader.java
@@ -2,6 +2,7 @@
import de.poiu.apron.java.util.Properties;
import one.edee.babylon.msgfile.TranslationFileUtils;
+import one.edee.babylon.properties.Property;
import one.edee.babylon.util.FileUtils;
import de.poiu.apron.PropertyFile;
@@ -12,6 +13,12 @@
import java.util.stream.Collectors;
public class ApronMessageLoader implements MessageLoader {
+ public static final String PROPERTIES_FILE_EXTENSION = ".properties";
+
+ @Override
+ public boolean canBeLoaded(String filePath) {
+ return filePath.endsWith(PROPERTIES_FILE_EXTENSION);
+ }
@Override
public Map loadPrimaryMessages(String filePath) {
@@ -63,7 +70,7 @@ private Map dumpPropertyFile(Properties properties) {
}
String cleanPropertyValue(String rawValue) {
- return rawValue.trim();
+ return Property.clearValue(rawValue).trim();
}
private File fileFromPath(String path) {
diff --git a/src/main/java/one/edee/babylon/export/Exporter.java b/src/main/java/one/edee/babylon/export/Exporter.java
index 8967a82..d9607c3 100644
--- a/src/main/java/one/edee/babylon/export/Exporter.java
+++ b/src/main/java/one/edee/babylon/export/Exporter.java
@@ -1,13 +1,22 @@
package one.edee.babylon.export;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.apachecommons.CommonsLog;
+import one.edee.babylon.config.SupportedTranslators;
+import one.edee.babylon.config.TranslationConfiguration;
import one.edee.babylon.db.SnapshotUtils;
import one.edee.babylon.export.dto.ExportResult;
+import one.edee.babylon.export.dto.TranslationSheet;
+import one.edee.babylon.export.translator.Translator;
+import one.edee.babylon.sheets.SheetsException;
import one.edee.babylon.sheets.gsheets.model.ASheet;
import one.edee.babylon.snapshot.TranslationSnapshotWriteContract;
import one.edee.babylon.util.AntPathResourceLoader;
-import one.edee.babylon.sheets.SheetsException;
import one.edee.babylon.util.PathUtils;
-import lombok.extern.apachecommons.CommonsLog;
+import org.jetbrains.annotations.NotNull;
+import org.springframework.context.ApplicationContext;
+import org.springframework.util.Assert;
+import org.springframework.util.StringUtils;
import java.io.File;
import java.io.IOException;
@@ -17,55 +26,35 @@
import java.util.function.Function;
import java.util.stream.Collectors;
+import static java.util.Optional.ofNullable;
+
/**
* Performs the export phase that generates translation sheets.
*/
@CommonsLog
+@RequiredArgsConstructor
public class Exporter {
+ private static final String COMBINING_SHEET_NAME = "ALL";
+
+ private final ApplicationContext applicationContext;
private final TranslationCollector translationCollector;
private final TranslationSnapshotWriteContract snapshot;
private final SheetContract gsc;
private final AntPathResourceLoader resourceLoader;
- private final PathUtils pu;
-
- public Exporter(TranslationCollector translationCollector, TranslationSnapshotWriteContract snapshot, SheetContract gsc, AntPathResourceLoader resourceLoader) {
- this.translationCollector = translationCollector;
- this.snapshot = snapshot;
- this.gsc = gsc;
- this.resourceLoader = resourceLoader;
- this.pu = new PathUtils();
- }
+ private final PathUtils pu = new PathUtils();
- /**
- * Walks message file paths, gathering messages and translations, producing translation sheets in given GSheet spreadsheet.
- *
- * @param patternPaths paths of message files to export
- * @param translationLangs languages to translate messages to
- * @param spreadsheetId id of GSheets spreadsheet, must be empty
- * @param snapshotPath path to the translation snapshot file
- */
- public void walkPathsAndWriteSheets(List patternPaths,
- List translationLangs,
- String spreadsheetId,
- Path snapshotPath) {
- walkPathsAndWriteSheets(patternPaths, translationLangs, spreadsheetId, snapshotPath, Collections.emptyList());
- }
/**
* Walks message file paths, gathering messages and translations, producing translation sheets in given GSheet spreadsheet.
*
- * @param patternPaths paths of message files to export
- * @param translationLangs languages to translate messages to
- * @param spreadsheetId id of GSheets spreadsheet, must be empty
- * @param snapshotPath path to the translation snapshot file
- * @param lockedCellEditors list of Google account emails, these account will have the permission to edit locked cells
+ * @param configuration configuration of translation run
+ * @param spreadsheetId id of GSheets spreadsheet, must be empty
*/
- public void walkPathsAndWriteSheets(List patternPaths,
- List translationLangs,
+ public void walkPathsAndWriteSheets(TranslationConfiguration configuration,
String spreadsheetId,
- Path snapshotPath,
- List lockedCellEditors) {
+ boolean combineSheets) {
+ List patternPaths = configuration.getPath();
warnDuplicatePaths(patternPaths);
List prevSheets = listAllSheets(spreadsheetId);
@@ -76,16 +65,107 @@ public void walkPathsAndWriteSheets(List patternPaths,
throw new IllegalArgumentException("Please fix the message file paths in the configuration file.");
}
- ExportResult result = translationCollector.walkPathsAndCollectTranslationSheets(allUniquePaths, translationLangs);
+ ExportResult result = translationCollector.walkPathsAndCollectTranslationSheets(allUniquePaths, configuration.getMutations());
+
+ if (combineSheets) {
+ // only for translation debugging
+ List original = result.getSheets();
+ List sheets = new ArrayList<>(original);
+ original.clear();
+
+ List> combine = new LinkedList<>();
+ for (int i = 0; i < sheets.size(); i++) {
+ TranslationSheet sheet = sheets.get(i);
+ List> rows = sheet.getRows();
+ if (i != 0){
+ rows.remove(0);
+ }
+ combine.addAll(rows);
+ }
+
+ original.add(new TranslationSheet(COMBINING_SHEET_NAME,combine));
+ }
+
+ Map> changed = translateTextsByExternalTool(configuration, result);
- uploadTranslations(result, spreadsheetId, lockedCellEditors);
+ uploadTranslations(result, spreadsheetId, configuration.getLockedCellEditors(), changed);
- updateSnapshotAndWriteToDisk(this.snapshot, result, snapshotPath);
+ updateSnapshotAndWriteToDisk(this.snapshot, result, configuration.getSnapshotPath());
List prevSheetIds = prevSheets.stream().map(ASheet::getId).collect(Collectors.toList());
deleteOldSheets(prevSheetIds, spreadsheetId);
}
+ @NotNull
+ private Map> translateTextsByExternalTool(TranslationConfiguration configuration, ExportResult result) {
+ Map> changed = new HashMap<>();
+
+ if (configuration.getTranslatorApiKey() != null) {
+ SupportedTranslators translatorType = ofNullable(configuration.getTranslator()).orElse(SupportedTranslators.GOOGLE);
+
+ Translator translator = applicationContext.getBeansOfType(Translator.class)
+ .values()
+ .stream()
+ .filter(i -> i.getSupportedTranslator().equals(translatorType))
+ .findFirst()
+ .orElseThrow(() -> new IllegalArgumentException("Cannot find translator bean for type" + translatorType));
+ translator.init(configuration.getTranslatorApiKey());
+
+ try {
+ for (TranslationSheet sheet : result.getSheets()) {
+
+ List> rows = sheet.getRows();
+ if (rows.size() == 1)
+ continue;
+
+ log.info("Translating sheet " + sheet.getSheetName());
+ List header = rows.get(0);
+ List originals = rows.stream().map(i->i.get(1)).map(i->StringUtils.hasText(i) ? i : "____DUMMY").collect(Collectors.toList());
+ Map> translations = new HashMap<>();
+
+ for (String lang : header.stream().skip(2).collect(Collectors.toList())) {
+ translations.put(lang, translator.translate(configuration.getDefaultLang(), originals, lang));
+ }
+
+ for (int i = 1; i < rows.size(); i++) {
+ Map toChange = new HashMap<>();
+
+ List cells = rows.get(i);
+ String original = cells.get(1);
+ for (int l = 2; l < cells.size(); l++) {
+ if (StringUtils.isEmpty(cells.get(l))) {
+
+ String lang = header.get(l);
+
+ if (StringUtils.hasText(original)) {
+ String transOriginal = originals.get(i);
+ if (!Objects.equals(original, "____DUMMY")){
+ Assert.isTrue(Objects.equals(transOriginal, original), "Originals does not equals!");
+ String translatedText = translations.get(lang).get(i);
+ toChange.put(l, translatedText);
+
+ changed
+ .computeIfAbsent(sheet.getSheetName(), key -> new LinkedList<>())
+ .add(i + "_" + l);
+ }
+ }
+ }
+ }
+
+ for (Entry entry : toChange.entrySet()) {
+ cells.remove((int) entry.getKey());
+ cells.add(entry.getKey(), entry.getValue());
+ }
+
+ }
+ }
+ } catch (Exception e) {
+ log.error(e.getMessage(), e);
+ }
+ }
+ return changed;
+ }
+
private void warnDuplicatePaths(List patternPaths) {
List duplicatePaths = detectDuplicatePatternPaths(patternPaths);
if (!duplicatePaths.isEmpty()) {
@@ -138,13 +218,13 @@ private List listAllSheets(String spreadsheetId) {
}
}
- private void uploadTranslations(ExportResult exportResult, String spreadsheetId, List lockedCellEditors) {
+ private void uploadTranslations(ExportResult exportResult, String spreadsheetId, List lockedCellEditors, Map> changed) {
exportResult.getSheets().stream()
.filter(sheet -> !sheet.getDataRows().isEmpty())
.forEach(sheet -> {
try {
log.info("Writing " + sheet.getDataRows().size() + " rows into sheet '" + sheet.getSheetName() + "'.");
- gsc.createSheet(spreadsheetId, sheet.getSheetName(), sheet.getRows(), lockedCellEditors);
+ gsc.createSheet(spreadsheetId, sheet.getSheetName(), sheet.getRows(), lockedCellEditors, changed);
} catch (SheetsException e) {
String errMsg = "Error when uploading data to spreadsheet '" + spreadsheetId + "'";
throw new RuntimeException(errMsg, e);
@@ -203,10 +283,12 @@ public interface SheetContract {
* @param sheetTitle name to use for the new sheet
* @param sheetRows rows with data cells to fill the sheet with
* @param lockedCellEditors list of email accounts that will be able to edit locked cells
+ * @param changed
* @throws SheetsException when unable to upload sheets
*/
- void createSheet(String spreadsheetId, String sheetTitle, List> sheetRows, List lockedCellEditors) throws SheetsException;
+ void createSheet(String spreadsheetId, String sheetTitle, List> sheetRows, List lockedCellEditors, Map> changed) throws SheetsException;
}
+
}
diff --git a/src/main/java/one/edee/babylon/export/MessageLoader.java b/src/main/java/one/edee/babylon/export/MessageLoader.java
index 00ae16d..2ffc89e 100644
--- a/src/main/java/one/edee/babylon/export/MessageLoader.java
+++ b/src/main/java/one/edee/babylon/export/MessageLoader.java
@@ -5,6 +5,12 @@
public interface MessageLoader {
+
+ /**
+ * Indicates whether file could be loaded by implementation.
+ */
+ boolean canBeLoaded(String filePath);
+
/**
* Loads primary language messages for given message file path.
*
diff --git a/src/main/java/one/edee/babylon/export/TranslationCollector.java b/src/main/java/one/edee/babylon/export/TranslationCollector.java
index 303a7f8..9c911cb 100644
--- a/src/main/java/one/edee/babylon/export/TranslationCollector.java
+++ b/src/main/java/one/edee/babylon/export/TranslationCollector.java
@@ -1,6 +1,8 @@
package one.edee.babylon.export;
+import kotlin.Pair;
import lombok.RequiredArgsConstructor;
+import lombok.extern.apachecommons.CommonsLog;
import one.edee.babylon.export.dto.ExportResult;
import one.edee.babylon.export.dto.MessageFileExportResult;
import one.edee.babylon.export.dto.TranslationSheet;
@@ -8,8 +10,7 @@
import one.edee.babylon.sheets.SheetUtils;
import one.edee.babylon.snapshot.TranslationSnapshotReadContract;
import one.edee.babylon.snapshot.TranslationSnapshotWriteContract;
-import kotlin.Pair;
-import lombok.extern.apachecommons.CommonsLog;
+import org.springframework.util.Assert;
import java.util.*;
import java.util.stream.Collectors;
@@ -20,7 +21,7 @@
@CommonsLog
@RequiredArgsConstructor
public class TranslationCollector {
- private final MessageLoader messageLoader;
+ private final List messageLoaders;
private final MessageFileProcessor messageFileProcessor;
private final TranslationSnapshotReadContract snapshotReadContract;
private final TranslationSnapshotWriteContract snapshotWriteContract;
@@ -78,8 +79,16 @@ private MessageFileExportResult processMsgFile(String msgFilePath, List
}
private Pair computeTranslationSheetRows(String msgFilePath, List translateTo) {
- Map primaryMsgs = messageLoader.loadPrimaryMessages(msgFilePath);
- Map> translations = messageLoader.loadTranslations(msgFilePath, translateTo);
+ Map primaryMsgs = null;
+ Map> translations = null;
+ for (MessageLoader messageLoader : messageLoaders) {
+ if (messageLoader.canBeLoaded(msgFilePath)) {
+ primaryMsgs = messageLoader.loadPrimaryMessages(msgFilePath);
+ translations = messageLoader.loadTranslations(msgFilePath, translateTo);
+ }
+ }
+ Assert.notNull(primaryMsgs, "There is no appropriate message loader for file path with extension: " + msgFilePath);
+ Assert.notNull(translations, "There is no appropriate message loader for file path with extension: " + msgFilePath);
return messageFileProcessor.prepareTranslationSheet(msgFilePath, primaryMsgs, translations, translateTo);
}
diff --git a/src/main/java/one/edee/babylon/export/TsMessageLoader.java b/src/main/java/one/edee/babylon/export/TsMessageLoader.java
new file mode 100644
index 0000000..4bc5aa0
--- /dev/null
+++ b/src/main/java/one/edee/babylon/export/TsMessageLoader.java
@@ -0,0 +1,110 @@
+package one.edee.babylon.export;
+
+import lombok.extern.log4j.Log4j2;
+import one.edee.babylon.export.ts.TypeScriptBabylonParserListener;
+import one.edee.babylon.export.ts.gen.TypeScriptLexer;
+import one.edee.babylon.export.ts.gen.TypeScriptParser;
+import one.edee.babylon.msgfile.TranslationFileUtils;
+import one.edee.babylon.util.FileUtils;
+import org.antlr.v4.runtime.*;
+import org.antlr.v4.runtime.tree.ParseTree;
+import org.antlr.v4.runtime.tree.ParseTreeWalker;
+
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.Reader;
+import java.util.AbstractMap;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import static java.util.Optional.ofNullable;
+
+@Log4j2
+public class TsMessageLoader implements MessageLoader {
+
+ public static final String TS_FILE_EXTENSION = ".ts";
+
+ @Override
+ public boolean canBeLoaded(String filePath) {
+ return filePath.endsWith(TS_FILE_EXTENSION);
+ }
+
+ @Override
+ public Map loadPrimaryMessages(String filePath) {
+ return ofNullable(loadFile(filePath))
+ .map(TypeScriptBabylonParserListener::getPropertyDefinitions)
+ .orElse(Collections.emptyMap());
+ }
+
+ @Override
+ public Map> loadTranslations(String filePath, List languages) {
+ return languages
+ .stream()
+ .map(lang ->
+ new AbstractMap.SimpleEntry<>(
+ lang,
+ loadTranslations(filePath, lang)
+ )
+ ).collect(Collectors.toMap(
+ AbstractMap.SimpleEntry::getKey,
+ AbstractMap.SimpleEntry::getValue)
+ );
+ }
+
+
+ public static Map dumpTsFile(Reader reader) throws IOException {
+ return readTsFile(reader).getPropertyDefinitions();
+ }
+
+ public static TypeScriptBabylonParserListener readTsFile(Reader reader) throws IOException {
+ CharStream input = CharStreams.fromReader(reader);
+
+ TypeScriptLexer lexer = new TypeScriptLexer(input);
+ CommonTokenStream tokens = new CommonTokenStream(lexer);
+ TypeScriptParser parser = new TypeScriptParser(tokens);
+ parser.addErrorListener(new BaseErrorListener() {
+ @Override
+ public void syntaxError(Recognizer, ?> recognizer, Object o, int i, int i1, String s, RecognitionException e) {
+ log.error("Cannot parse: " + s + " at line " + i + " with exception: " + e.getMessage());
+ }
+ });
+ ParseTree tree = parser.program();
+
+ TypeScriptBabylonParserListener listener = new TypeScriptBabylonParserListener();
+ ParseTreeWalker walker = new ParseTreeWalker();
+ walker.walk(listener, tree);
+
+ return listener;
+ }
+
+ private Map loadTranslations(String filePath, String language) {
+ String translationFilePath = TranslationFileUtils.getFileNameForTranslation(filePath, language);
+ return ofNullable(loadFile(translationFilePath))
+ .map(TypeScriptBabylonParserListener::getPropertyDefinitions)
+ .orElse(Collections.emptyMap());
+ }
+
+
+ public static TypeScriptBabylonParserListener loadFile(String filePath) {
+ if (FileUtils.exists(filePath)) {
+
+ log.info("Processing ts file: " + filePath);
+ try (Reader inputStreamReader = new FileReader(fileFromPath(filePath))) {
+ return readTsFile(inputStreamReader);
+ } catch (IOException e) {
+ throw new IllegalArgumentException(e.getMessage(), e);
+ }
+ } else {
+ return null;
+ }
+ }
+
+
+ private static File fileFromPath(String path) {
+ return FileUtils.fileFromPathOrThrow(path);
+ }
+
+}
diff --git a/src/main/java/one/edee/babylon/export/translator/DeeplTranslator.java b/src/main/java/one/edee/babylon/export/translator/DeeplTranslator.java
new file mode 100644
index 0000000..407ef38
--- /dev/null
+++ b/src/main/java/one/edee/babylon/export/translator/DeeplTranslator.java
@@ -0,0 +1,71 @@
+package one.edee.babylon.export.translator;
+
+import com.deepl.api.TextResult;
+import com.deepl.api.TextTranslationOptions;
+import com.deepl.api.Translator;
+import lombok.extern.log4j.Log4j2;
+import one.edee.babylon.config.SupportedTranslators;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.springframework.stereotype.Component;
+import org.springframework.util.Assert;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static java.util.Optional.ofNullable;
+
+/**
+ * I apologize in advance for the lack of documentation in this code.
+ * I had every intention of providing clear and concise explanations
+ * for every line of code, but then I got distracted by a squirrel outside
+ * my window and the next thing I knew it was three weeks later.
+ *
+ * So instead, I've included some helpful comments here and there.
+ * They might not make sense, but hey, at least they're something.
+ *
+ * @author Štěpán Kameník (kamenik@fg.cz), FG Forrest a.s. (c) 2024
+ **/
+@Component
+@Log4j2
+public class DeeplTranslator implements one.edee.babylon.export.translator.Translator {
+
+ Translator service = null;
+
+ @Override
+ public void init(@NotNull String apiKey) {
+ service = new Translator(apiKey);
+
+ }
+
+ @Override
+ public List translate(@Nullable String defaultLang, @NotNull List original, @NotNull String lang) {
+ Assert.notNull(service, "Init method with api key has to be called before translation!");
+
+ if (lang.equals("en")) {
+ lang = "en-GB";
+ }
+
+ String contextMessage = System.getProperty("babylon.deepl.context");
+ try {
+ return service.translateText(
+ original,
+ defaultLang,
+ lang,
+ new TextTranslationOptions()
+ .setContext(ofNullable(contextMessage)
+ .orElse("You are eshop translator. Do not translate text from other languages then source lang, or technical texts.")))
+ .stream()
+ .map(TextResult::getText)
+ .collect(Collectors.toList());
+ } catch (Exception e) {
+ log.error("Cannot translate " + original + " to lang: " + lang);
+ return null;
+ }
+ }
+
+ @Override
+ public SupportedTranslators getSupportedTranslator() {
+ return SupportedTranslators.DEEPL;
+ }
+}
diff --git a/src/main/java/one/edee/babylon/export/translator/GoogleTranslator.java b/src/main/java/one/edee/babylon/export/translator/GoogleTranslator.java
new file mode 100644
index 0000000..a0b75a7
--- /dev/null
+++ b/src/main/java/one/edee/babylon/export/translator/GoogleTranslator.java
@@ -0,0 +1,57 @@
+package one.edee.babylon.export.translator;
+
+import com.google.cloud.translate.Translate;
+import com.google.cloud.translate.TranslateOptions;
+import com.google.cloud.translate.Translation;
+import one.edee.babylon.config.SupportedTranslators;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.springframework.stereotype.Component;
+import org.springframework.util.Assert;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static com.google.cloud.translate.Translate.TranslateOption.sourceLanguage;
+import static com.google.cloud.translate.Translate.TranslateOption.targetLanguage;
+
+/**
+ * I apologize in advance for the lack of documentation in this code.
+ * I had every intention of providing clear and concise explanations
+ * for every line of code, but then I got distracted by a squirrel outside
+ * my window and the next thing I knew it was three weeks later.
+ *
+ * So instead, I've included some helpful comments here and there.
+ * They might not make sense, but hey, at least they're something.
+ *
+ * @author Štěpán Kameník (kamenik@fg.cz), FG Forrest a.s. (c) 2024
+ **/
+@Component
+public class GoogleTranslator implements Translator{
+
+ Translate service = null;
+
+ @Override
+ public void init(@NotNull String apiKey) {
+ service = TranslateOptions.newBuilder().setApiKey(apiKey).build().getService();
+
+ }
+
+ @Override
+ public List translate(@Nullable String defaultLang, @NotNull List original, @NotNull String lang) {
+ Assert.notNull(service, "Init method with api key has to be called before translation!");
+ return service.translate(
+ original,
+ sourceLanguage(defaultLang),
+ targetLanguage(lang)
+ )
+ .stream()
+ .map(Translation::getTranslatedText)
+ .collect(Collectors.toList());
+ }
+
+ @Override
+ public SupportedTranslators getSupportedTranslator() {
+ return SupportedTranslators.GOOGLE;
+ }
+}
diff --git a/src/main/java/one/edee/babylon/export/translator/OpenAiTranslator.java b/src/main/java/one/edee/babylon/export/translator/OpenAiTranslator.java
new file mode 100644
index 0000000..15b8912
--- /dev/null
+++ b/src/main/java/one/edee/babylon/export/translator/OpenAiTranslator.java
@@ -0,0 +1,111 @@
+package one.edee.babylon.export.translator;
+
+import com.theokanning.openai.OpenAiHttpException;
+import com.theokanning.openai.completion.chat.ChatCompletionRequest;
+import com.theokanning.openai.completion.chat.ChatCompletionResult;
+import com.theokanning.openai.completion.chat.ChatMessage;
+import com.theokanning.openai.service.OpenAiService;
+import lombok.SneakyThrows;
+import lombok.extern.log4j.Log4j2;
+import one.edee.babylon.config.SupportedTranslators;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.springframework.stereotype.Component;
+import org.springframework.util.Assert;
+
+import java.time.Duration;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+import static java.util.Optional.ofNullable;
+
+/**
+ * I apologize in advance for the lack of documentation in this code.
+ * I had every intention of providing clear and concise explanations
+ * for every line of code, but then I got distracted by a squirrel outside
+ * my window and the next thing I knew it was three weeks later.
+ *
+ * So instead, I've included some helpful comments here and there.
+ * They might not make sense, but hey, at least they're something.
+ *
+ * @author Štěpán Kameník (kamenik@fg.cz), FG Forrest a.s. (c) 2024
+ **/
+@Component
+@Log4j2
+public class OpenAiTranslator implements Translator {
+
+ OpenAiService service = null;
+
+ @Override
+ public void init(@NotNull String apiKey) {
+ service = new OpenAiService(apiKey, Duration.ofSeconds(60L));
+ }
+
+ @SneakyThrows
+ @Override
+ public List translate(@Nullable String defaultLang, @NotNull List original, @NotNull String lang) {
+ Assert.notNull(service, "Init method with api key has to be called before translation!");
+
+ String systemMessage = System.getProperty("babylon.openai.systemMessage");
+ String formattedSystemMessage = String.format(
+ ofNullable(systemMessage)
+ .orElse("You are translator that translate eshop messages from %s to %s. If you cannot translate it, return original text. Texts to translate are combined by '~'. Split input by comma, translate and return in same format."),
+ defaultLang,
+ lang);
+
+
+ String joined = String.join("~", original);
+ List messages = Arrays.asList(
+ new ChatMessage("system", formattedSystemMessage),
+ new ChatMessage("user", joined)
+ );
+
+ int tries = 5;
+ List output;
+ do {
+ // translator in some cases returns fewer results than expected, try it again 5 times
+ String result = translateInner(messages, original);
+ output = Arrays.stream(result.split("~")).collect(Collectors.toList());
+ if (output.size() != original.size())
+ log.warn("Size not equal " + joined + " " + result);
+ tries--;
+ }while (tries > 0 && output.size() != original.size());
+
+ // if it occurs even after 5 tries, throw exception
+ if (output.size() != original.size())
+ throw new IllegalArgumentException("Size not equal, even after 5 tries!");
+
+ return output;
+ }
+
+ private String translateInner(List messages, @NotNull List original) throws InterruptedException {
+
+ ChatCompletionResult chatCompletion;
+ try{
+ chatCompletion = service.createChatCompletion(
+ ChatCompletionRequest
+ .builder()
+ .model(ofNullable(System.getProperty("babylon.openai.model")).orElse("gpt-3.5-turbo-16k-0613"))
+ .messages(
+ messages
+ )
+ .build()
+ );
+
+ }catch (OpenAiHttpException e){
+ if (e.getMessage().contains("Please try again in 20s")){
+ log.info("Rate limit reached, will try again in 20 secs! Translate in progress " + original);
+ Thread.sleep(20_000);
+ return translateInner(messages, original);
+ }
+ throw e;
+ }
+ return chatCompletion.getChoices().get(0).getMessage().getContent();
+ }
+
+ @Override
+ public SupportedTranslators getSupportedTranslator() {
+ return SupportedTranslators.OPENAI;
+ }
+}
diff --git a/src/main/java/one/edee/babylon/export/translator/Translator.java b/src/main/java/one/edee/babylon/export/translator/Translator.java
new file mode 100644
index 0000000..2ddfd12
--- /dev/null
+++ b/src/main/java/one/edee/babylon/export/translator/Translator.java
@@ -0,0 +1,28 @@
+package one.edee.babylon.export.translator;
+
+import one.edee.babylon.config.SupportedTranslators;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+
+/**
+ * I apologize in advance for the lack of documentation in this code.
+ * I had every intention of providing clear and concise explanations
+ * for every line of code, but then I got distracted by a squirrel outside
+ * my window and the next thing I knew it was three weeks later.
+ *
+ * So instead, I've included some helpful comments here and there.
+ * They might not make sense, but hey, at least they're something.
+ *
+ * @author Štěpán Kameník (kamenik@fg.cz), FG Forrest a.s. (c) 2024
+ **/
+public interface Translator {
+
+ void init(@NotNull String apiKey);
+
+ List translate(@Nullable String defaultLang, @NotNull List originals, @NotNull String lang);
+
+ SupportedTranslators getSupportedTranslator();
+
+}
diff --git a/src/main/java/one/edee/babylon/export/ts/TypeScriptBabylonParserListener.java b/src/main/java/one/edee/babylon/export/ts/TypeScriptBabylonParserListener.java
new file mode 100644
index 0000000..d9dedd0
--- /dev/null
+++ b/src/main/java/one/edee/babylon/export/ts/TypeScriptBabylonParserListener.java
@@ -0,0 +1,76 @@
+package one.edee.babylon.export.ts;
+
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import one.edee.babylon.export.ts.gen.TypeScriptParser;
+import one.edee.babylon.export.ts.gen.TypeScriptParserBaseListener;
+import org.antlr.v4.runtime.ParserRuleContext;
+import org.springframework.util.Assert;
+
+import java.util.*;
+
+
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class TypeScriptBabylonParserListener extends TypeScriptParserBaseListener {
+
+ private static final String APOSTROPHE_CLEANING_REGEX = "['`].*?";
+
+ private final Set propertyListDefName = new HashSet<>();
+ private final Map propertyDefinitions = new LinkedHashMap<>();
+ private final List imports = new LinkedList<>();
+
+ @Override
+ public void enterIdentifierOrKeyWord(TypeScriptParser.IdentifierOrKeyWordContext ctx) {
+ propertyListDefName.add(ctx.getText());
+ }
+
+ @Override
+ public void enterPropertyExpressionAssignment(TypeScriptParser.PropertyExpressionAssignmentContext ctx) {
+ int childCount = ctx.getChildCount();
+ Assert.isTrue(childCount == 3, "There has to be property name, delimiter (:) and value! In: " + ctx.getText());
+ String propertyName = cleanText(ctx.getChild(0).getText());
+ String propertyValue = cleanText(ctx.getChild(2).getText());
+ propertyDefinitions.put(propertyName, propertyValue);
+ }
+
+ @Override
+ public void enterComputedPropertyExpressionAssignment(TypeScriptParser.ComputedPropertyExpressionAssignmentContext ctx) {
+ String[] split = ctx.getText().split(":");
+ Assert.isTrue(split.length == 2, "There has to be property name, delimiter (:) and value! In: " + ctx.getText());
+ String propertyName = cleanText(split[0]);
+ String propertyValue = cleanText(split[1]);
+ propertyDefinitions.put(propertyName, propertyValue);
+ }
+
+ @Override
+ public void enterImportStatement(TypeScriptParser.ImportStatementContext ctx) {
+ imports.add(getNodeText(ctx));
+ }
+
+ private String cleanText(String text) {
+ if (text.matches(APOSTROPHE_CLEANING_REGEX) || (text.contains("\n") || text.contains("\r")))
+ text = text.replaceAll("['`]", "");
+ return text;
+ }
+
+
+ private String getNodeText(ParserRuleContext ctx) {
+ int childCount = ctx.getChildCount();
+ if (childCount == 0) {
+ return "";
+ } else {
+ StringBuilder builder = new StringBuilder();
+
+ for (int i = 0; i < childCount; ++i) {
+ if (i != 0) builder.append(" ");
+ builder.append(ctx.getChild(i).getText());
+
+ }
+ return builder.toString();
+ }
+ }
+
+
+ // OTHER METHODS
+}
diff --git a/src/main/java/one/edee/babylon/export/ts/TypeScriptLexerBase.java b/src/main/java/one/edee/babylon/export/ts/TypeScriptLexerBase.java
new file mode 100644
index 0000000..7bd0de8
--- /dev/null
+++ b/src/main/java/one/edee/babylon/export/ts/TypeScriptLexerBase.java
@@ -0,0 +1,166 @@
+package one.edee.babylon.export.ts;
+
+import one.edee.babylon.export.ts.gen.TypeScriptLexer;
+import org.antlr.v4.runtime.*;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+
+/**
+ * All lexer methods that used in grammar (IsStrictMode)
+ * should start with Upper Case Char similar to Lexer rules.
+ */
+public abstract class TypeScriptLexerBase extends Lexer
+{
+ /**
+ * Stores values of nested modes. By default mode is strict or
+ * defined externally (useStrictDefault)
+ */
+ private final Deque scopeStrictModes = new ArrayDeque<>();
+
+ private Token lastToken = null;
+ /**
+ * Default value of strict mode
+ * Can be defined externally by setUseStrictDefault
+ */
+ private boolean useStrictDefault = false;
+ /**
+ * Current value of strict mode
+ * Can be defined during parsing, see StringFunctions.js and StringGlobal.js samples
+ */
+ private boolean useStrictCurrent = false;
+ /**
+ * Keeps track of the current depth of nested template string backticks.
+ * E.g. after the X in:
+ *
+ * `${a ? `${X
+ *
+ * templateDepth will be 2. This variable is needed to determine if a `}` is a
+ * plain CloseBrace, or one that closes an expression inside a template string.
+ */
+ private int templateDepth = 0;
+
+ /**
+ * Keeps track of the depth of open- and close-braces. Used for expressions like:
+ *
+ * `${[1, 2, 3].map(x => { return x * 2;}).join("")}`
+ *
+ * where the '}' from `return x * 2;}` should not become a `TemplateCloseBrace`
+ * token but rather a `CloseBrace` token.
+ */
+ private int bracesDepth = 0;
+
+ public TypeScriptLexerBase(CharStream input) {
+ super(input);
+ }
+
+ public boolean getStrictDefault() {
+ return useStrictDefault;
+ }
+
+ public void setUseStrictDefault(boolean value) {
+ useStrictDefault = value;
+ useStrictCurrent = value;
+ }
+
+ public boolean IsStrictMode() {
+ return useStrictCurrent;
+ }
+
+ public void StartTemplateString() {
+ this.bracesDepth = 0;
+ }
+
+ public boolean IsInTemplateString() {
+ return this.templateDepth > 0 && this.bracesDepth == 0;
+ }
+
+ /**
+ * Return the next token from the character stream and records this last
+ * token in case it resides on the default channel. This recorded token
+ * is used to determine when the lexer could possibly match a regex
+ * literal. Also changes scopeStrictModes stack if tokenize special
+ * string 'use strict';
+ *
+ * @return the next token from the character stream.
+ */
+ @Override
+ public Token nextToken() {
+ Token next = super.nextToken();
+
+ if (next.getChannel() == Token.DEFAULT_CHANNEL) {
+ // Keep track of the last token on the default channel.
+ this.lastToken = next;
+ }
+
+ return next;
+ }
+
+ protected void ProcessOpenBrace()
+ {
+ bracesDepth++;
+ useStrictCurrent = scopeStrictModes.size() > 0 && scopeStrictModes.peek() ? true : useStrictDefault;
+ scopeStrictModes.push(useStrictCurrent);
+ }
+
+ protected void ProcessCloseBrace()
+ {
+ bracesDepth--;
+ useStrictCurrent = scopeStrictModes.size() > 0 ? scopeStrictModes.pop() : useStrictDefault;
+ }
+
+ protected void ProcessStringLiteral()
+ {
+ if (lastToken == null || lastToken.getType() == TypeScriptLexer.OpenBrace)
+ {
+ String text = getText();
+ if (text.equals("\"use strict\"") || text.equals("'use strict'"))
+ {
+ if (scopeStrictModes.size() > 0)
+ scopeStrictModes.pop();
+ useStrictCurrent = true;
+ scopeStrictModes.push(useStrictCurrent);
+ }
+ }
+ }
+
+ protected void IncreaseTemplateDepth() {
+ this.templateDepth++;
+ }
+
+ protected void DecreaseTemplateDepth() {
+ this.templateDepth--;
+ }
+
+ /**
+ * Returns {@code true} if the lexer can match a regex literal.
+ */
+ protected boolean IsRegexPossible() {
+
+ if (this.lastToken == null) {
+ // No token has been produced yet: at the start of the input,
+ // no division is possible, so a regex literal _is_ possible.
+ return true;
+ }
+
+ switch (this.lastToken.getType()) {
+ case TypeScriptLexer.Identifier:
+ case TypeScriptLexer.NullLiteral:
+ case TypeScriptLexer.BooleanLiteral:
+ case TypeScriptLexer.This:
+ case TypeScriptLexer.CloseBracket:
+ case TypeScriptLexer.CloseParen:
+ case TypeScriptLexer.OctalIntegerLiteral:
+ case TypeScriptLexer.DecimalLiteral:
+ case TypeScriptLexer.HexIntegerLiteral:
+ case TypeScriptLexer.StringLiteral:
+ case TypeScriptLexer.PlusPlus:
+ case TypeScriptLexer.MinusMinus:
+ // After any of the tokens above, no regex literal can follow.
+ return false;
+ default:
+ // In all other cases, a regex literal _is_ possible.
+ return true;
+ }
+ }
+}
diff --git a/src/main/java/one/edee/babylon/export/ts/TypeScriptParserBase.java b/src/main/java/one/edee/babylon/export/ts/TypeScriptParserBase.java
new file mode 100644
index 0000000..a19f44a
--- /dev/null
+++ b/src/main/java/one/edee/babylon/export/ts/TypeScriptParserBase.java
@@ -0,0 +1,122 @@
+package one.edee.babylon.export.ts;
+
+import one.edee.babylon.export.ts.gen.TypeScriptParser;
+import org.antlr.v4.runtime.*;
+
+/**
+ * All parser methods that used in grammar (p, prev, notLineTerminator, etc.)
+ * should start with lower case char similar to parser rules.
+ */
+public abstract class TypeScriptParserBase extends Parser
+{
+ public TypeScriptParserBase(TokenStream input) {
+ super(input);
+ }
+
+ /**
+ * Short form for prev(String str)
+ */
+ protected boolean p(String str) {
+ return prev(str);
+ }
+
+ /**
+ * Whether the previous token value equals to @param str
+ */
+ protected boolean prev(String str) {
+ return _input.LT(-1).getText().equals(str);
+ }
+
+ /**
+ * Short form for next(String str)
+ */
+ protected boolean n(String str) {
+ return next(str);
+ }
+
+ /**
+ * Whether the next token value equals to @param str
+ */
+ protected boolean next(String str) {
+ return _input.LT(1).getText().equals(str);
+ }
+
+ protected boolean notLineTerminator() {
+ return !here(TypeScriptParser.LineTerminator);
+ }
+
+ protected boolean notOpenBraceAndNotFunction() {
+ int nextTokenType = _input.LT(1).getType();
+ return nextTokenType != TypeScriptParser.OpenBrace && nextTokenType != TypeScriptParser.Function_;
+ }
+
+ protected boolean closeBrace() {
+ return _input.LT(1).getType() == TypeScriptParser.CloseBrace;
+ }
+
+ /**
+ * Returns {@code true} iff on the current index of the parser's
+ * token stream a token of the given {@code type} exists on the
+ * {@code HIDDEN} channel.
+ *
+ * @param type
+ * the type of the token on the {@code HIDDEN} channel
+ * to check.
+ *
+ * @return {@code true} iff on the current index of the parser's
+ * token stream a token of the given {@code type} exists on the
+ * {@code HIDDEN} channel.
+ */
+ private boolean here(final int type) {
+
+ // Get the token ahead of the current index.
+ int possibleIndexEosToken = this.getCurrentToken().getTokenIndex() - 1;
+ Token ahead = _input.get(possibleIndexEosToken);
+
+ // Check if the token resides on the HIDDEN channel and if it's of the
+ // provided type.
+ return (ahead.getChannel() == Lexer.HIDDEN) && (ahead.getType() == type);
+ }
+
+ /**
+ * Returns {@code true} iff on the current index of the parser's
+ * token stream a token exists on the {@code HIDDEN} channel which
+ * either is a line terminator, or is a multi line comment that
+ * contains a line terminator.
+ *
+ * @return {@code true} iff on the current index of the parser's
+ * token stream a token exists on the {@code HIDDEN} channel which
+ * either is a line terminator, or is a multi line comment that
+ * contains a line terminator.
+ */
+ protected boolean lineTerminatorAhead() {
+
+ // Get the token ahead of the current index.
+ int possibleIndexEosToken = this.getCurrentToken().getTokenIndex() - 1;
+ Token ahead = _input.get(possibleIndexEosToken);
+
+ if (ahead.getChannel() != Lexer.HIDDEN) {
+ // We're only interested in tokens on the HIDDEN channel.
+ return false;
+ }
+
+ if (ahead.getType() == TypeScriptParser.LineTerminator) {
+ // There is definitely a line terminator ahead.
+ return true;
+ }
+
+ if (ahead.getType() == TypeScriptParser.WhiteSpaces) {
+ // Get the token ahead of the current whitespaces.
+ possibleIndexEosToken = this.getCurrentToken().getTokenIndex() - 2;
+ ahead = _input.get(possibleIndexEosToken);
+ }
+
+ // Get the token's text and type.
+ String text = ahead.getText();
+ int type = ahead.getType();
+
+ // Check if the token is, or contains a line terminator.
+ return (type == TypeScriptParser.MultiLineComment && (text.contains("\r") || text.contains("\n"))) ||
+ (type == TypeScriptParser.LineTerminator);
+ }
+}
diff --git a/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptLexer.g4 b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptLexer.g4
new file mode 100644
index 0000000..78b867e
--- /dev/null
+++ b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptLexer.g4
@@ -0,0 +1,307 @@
+lexer grammar TypeScriptLexer;
+
+channels { ERROR }
+
+options {
+ superClass=TypeScriptLexerBase;
+}
+
+
+MultiLineComment: '/*' .*? '*/' -> channel(HIDDEN);
+SingleLineComment: '//' ~[\r\n\u2028\u2029]* -> channel(HIDDEN);
+RegularExpressionLiteral: '/' RegularExpressionFirstChar RegularExpressionChar* {this.IsRegexPossible()}? '/' IdentifierPart*;
+
+OpenBracket: '[';
+CloseBracket: ']';
+OpenParen: '(';
+CloseParen: ')';
+OpenBrace: '{' {this.ProcessOpenBrace();};
+TemplateCloseBrace: {this.IsInTemplateString()}? '}' -> popMode;
+CloseBrace: '}' {this.ProcessCloseBrace();};
+SemiColon: ';';
+Comma: ',';
+Assign: '=';
+QuestionMark: '?';
+Colon: ':';
+Ellipsis: '...';
+Dot: '.';
+PlusPlus: '++';
+MinusMinus: '--';
+Plus: '+';
+Minus: '-';
+BitNot: '~';
+Not: '!';
+Multiply: '*';
+Divide: '/';
+Modulus: '%';
+RightShiftArithmetic: '>>';
+LeftShiftArithmetic: '<<';
+RightShiftLogical: '>>>';
+LessThan: '<';
+MoreThan: '>';
+LessThanEquals: '<=';
+GreaterThanEquals: '>=';
+Equals_: '==';
+NotEquals: '!=';
+IdentityEquals: '===';
+IdentityNotEquals: '!==';
+BitAnd: '&';
+BitXOr: '^';
+BitOr: '|';
+And: '&&';
+Or: '||';
+MultiplyAssign: '*=';
+DivideAssign: '/=';
+ModulusAssign: '%=';
+PlusAssign: '+=';
+MinusAssign: '-=';
+LeftShiftArithmeticAssign: '<<=';
+RightShiftArithmeticAssign: '>>=';
+RightShiftLogicalAssign: '>>>=';
+BitAndAssign: '&=';
+BitXorAssign: '^=';
+BitOrAssign: '|=';
+ARROW: '=>';
+
+/// Null Literals
+
+NullLiteral: 'null';
+
+/// Boolean Literals
+
+BooleanLiteral: 'true'
+ | 'false';
+
+/// Numeric Literals
+
+DecimalLiteral: DecimalIntegerLiteral '.' [0-9]* ExponentPart?
+ | '.' [0-9]+ ExponentPart?
+ | DecimalIntegerLiteral ExponentPart?
+ ;
+
+/// Numeric Literals
+
+HexIntegerLiteral: '0' [xX] HexDigit+;
+OctalIntegerLiteral: '0' [0-7]+ {!this.IsStrictMode()}?;
+OctalIntegerLiteral2: '0' [oO] [0-7]+;
+BinaryIntegerLiteral: '0' [bB] [01]+;
+
+/// Keywords
+
+Break: 'break';
+Do: 'do';
+Instanceof: 'instanceof';
+Typeof: 'typeof';
+Case: 'case';
+Else: 'else';
+New: 'new';
+Var: 'var';
+Catch: 'catch';
+Finally: 'finally';
+Return: 'return';
+Void: 'void';
+Continue: 'continue';
+For: 'for';
+Switch: 'switch';
+While: 'while';
+Debugger: 'debugger';
+Function_: 'function';
+This: 'this';
+With: 'with';
+Default: 'default';
+If: 'if';
+Throw: 'throw';
+Delete: 'delete';
+In: 'in';
+Try: 'try';
+As: 'as';
+From: 'from';
+ReadOnly: 'readonly';
+Async: 'async';
+
+/// Future Reserved Words
+
+Class: 'class';
+Enum: 'enum';
+Extends: 'extends';
+Super: 'super';
+Const: 'const';
+Export: 'export';
+Import: 'import';
+
+/// The following tokens are also considered to be FutureReservedWords
+/// when parsing strict mode
+
+Implements: 'implements' ;
+Let: 'let' ;
+Private: 'private' ;
+Public: 'public' ;
+Interface: 'interface' ;
+Package: 'package' ;
+Protected: 'protected' ;
+Static: 'static' ;
+Yield: 'yield' ;
+
+//keywords:
+
+Any : 'any';
+Number: 'number';
+Boolean: 'boolean';
+String: 'string';
+Symbol: 'symbol';
+
+
+TypeAlias : 'type';
+
+Get: 'get';
+Set: 'set';
+
+Constructor: 'constructor';
+Namespace: 'namespace';
+Require: 'require';
+Module: 'module';
+Declare: 'declare';
+
+Abstract: 'abstract';
+
+Is: 'is';
+
+//
+// Ext.2 Additions to 1.8: Decorators
+//
+At: '@';
+
+/// Identifier Names and Identifiers
+
+Identifier: IdentifierStart IdentifierPart*;
+
+/// String Literals
+StringLiteral: ('"' DoubleStringCharacter* '"'
+ | '\'' SingleStringCharacter* '\'') {this.ProcessStringLiteral();}
+ ;
+
+BackTick: '`' {this.IncreaseTemplateDepth();} -> pushMode(TEMPLATE);
+
+WhiteSpaces: [\t\u000B\u000C\u0020\u00A0]+ -> channel(HIDDEN);
+
+LineTerminator: [\r\n\u2028\u2029] -> channel(HIDDEN);
+
+/// Comments
+
+
+HtmlComment: '' -> channel(HIDDEN);
+CDataComment: '' -> channel(HIDDEN);
+UnexpectedCharacter: . -> channel(ERROR);
+
+mode TEMPLATE;
+
+TemplateStringEscapeAtom: '\\' .;
+BackTickInside: '`' {this.DecreaseTemplateDepth();} -> type(BackTick), popMode;
+TemplateStringStartExpression: '${' {this.StartTemplateString();} -> pushMode(DEFAULT_MODE);
+TemplateStringAtom: ~[`\\];
+
+// Fragment rules
+
+fragment DoubleStringCharacter
+ : ~["\\\r\n]
+ | '\\' EscapeSequence
+ | LineContinuation
+ ;
+
+fragment SingleStringCharacter
+ : ~['\\\r\n]
+ | '\\' EscapeSequence
+ | LineContinuation
+ ;
+
+fragment EscapeSequence
+ : CharacterEscapeSequence
+ | '0' // no digit ahead! TODO
+ | HexEscapeSequence
+ | UnicodeEscapeSequence
+ | ExtendedUnicodeEscapeSequence
+ ;
+
+fragment CharacterEscapeSequence
+ : SingleEscapeCharacter
+ | NonEscapeCharacter
+ ;
+
+fragment HexEscapeSequence
+ : 'x' HexDigit HexDigit
+ ;
+
+fragment UnicodeEscapeSequence
+ : 'u' HexDigit HexDigit HexDigit HexDigit
+ ;
+
+fragment ExtendedUnicodeEscapeSequence
+ : 'u' '{' HexDigit+ '}'
+ ;
+
+fragment SingleEscapeCharacter
+ : ['"\\bfnrtv]
+ ;
+
+fragment NonEscapeCharacter
+ : ~['"\\bfnrtv0-9xu\r\n]
+ ;
+
+fragment EscapeCharacter
+ : SingleEscapeCharacter
+ | [0-9]
+ | [xu]
+ ;
+
+fragment LineContinuation
+ : '\\' [\r\n\u2028\u2029]
+ ;
+
+fragment HexDigit
+ : [0-9a-fA-F]
+ ;
+
+fragment DecimalIntegerLiteral
+ : '0'
+ | [1-9] [0-9]*
+ ;
+
+fragment ExponentPart
+ : [eE] [+-]? [0-9]+
+ ;
+
+fragment IdentifierPart
+ : IdentifierStart
+ | [\p{Mn}]
+ | [\p{Nd}]
+ | [\p{Pc}]
+ | '\u200C'
+ | '\u200D'
+ ;
+
+fragment IdentifierStart
+ : [\p{L}]
+ | [$_]
+ | '\\' UnicodeEscapeSequence
+ ;
+
+fragment RegularExpressionFirstChar
+ : ~[*\r\n\u2028\u2029\\/[]
+ | RegularExpressionBackslashSequence
+ | '[' RegularExpressionClassChar* ']'
+ ;
+
+fragment RegularExpressionChar
+ : ~[\r\n\u2028\u2029\\/[]
+ | RegularExpressionBackslashSequence
+ | '[' RegularExpressionClassChar* ']'
+ ;
+
+fragment RegularExpressionClassChar
+ : ~[\r\n\u2028\u2029\]\\]
+ | RegularExpressionBackslashSequence
+ ;
+
+fragment RegularExpressionBackslashSequence
+ : '\\' ~[\r\n\u2028\u2029]
+ ;
diff --git a/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptLexer.interp b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptLexer.interp
new file mode 100644
index 0000000..0b64009
--- /dev/null
+++ b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptLexer.interp
@@ -0,0 +1,444 @@
+token literal names:
+null
+null
+null
+null
+'['
+']'
+'('
+')'
+'{'
+null
+'}'
+';'
+','
+'='
+'?'
+':'
+'...'
+'.'
+'++'
+'--'
+'+'
+'-'
+'~'
+'!'
+'*'
+'/'
+'%'
+'>>'
+'<<'
+'>>>'
+'<'
+'>'
+'<='
+'>='
+'=='
+'!='
+'==='
+'!=='
+'&'
+'^'
+'|'
+'&&'
+'||'
+'*='
+'/='
+'%='
+'+='
+'-='
+'<<='
+'>>='
+'>>>='
+'&='
+'^='
+'|='
+'=>'
+'null'
+null
+null
+null
+null
+null
+null
+'break'
+'do'
+'instanceof'
+'typeof'
+'case'
+'else'
+'new'
+'var'
+'catch'
+'finally'
+'return'
+'void'
+'continue'
+'for'
+'switch'
+'while'
+'debugger'
+'function'
+'this'
+'with'
+'default'
+'if'
+'throw'
+'delete'
+'in'
+'try'
+'as'
+'from'
+'readonly'
+'async'
+'class'
+'enum'
+'extends'
+'super'
+'const'
+'export'
+'import'
+'implements'
+'let'
+'private'
+'public'
+'interface'
+'package'
+'protected'
+'static'
+'yield'
+'any'
+'number'
+'boolean'
+'string'
+'symbol'
+'type'
+'get'
+'set'
+'constructor'
+'namespace'
+'require'
+'module'
+'declare'
+'abstract'
+'is'
+'@'
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+
+token symbolic names:
+null
+MultiLineComment
+SingleLineComment
+RegularExpressionLiteral
+OpenBracket
+CloseBracket
+OpenParen
+CloseParen
+OpenBrace
+TemplateCloseBrace
+CloseBrace
+SemiColon
+Comma
+Assign
+QuestionMark
+Colon
+Ellipsis
+Dot
+PlusPlus
+MinusMinus
+Plus
+Minus
+BitNot
+Not
+Multiply
+Divide
+Modulus
+RightShiftArithmetic
+LeftShiftArithmetic
+RightShiftLogical
+LessThan
+MoreThan
+LessThanEquals
+GreaterThanEquals
+Equals_
+NotEquals
+IdentityEquals
+IdentityNotEquals
+BitAnd
+BitXOr
+BitOr
+And
+Or
+MultiplyAssign
+DivideAssign
+ModulusAssign
+PlusAssign
+MinusAssign
+LeftShiftArithmeticAssign
+RightShiftArithmeticAssign
+RightShiftLogicalAssign
+BitAndAssign
+BitXorAssign
+BitOrAssign
+ARROW
+NullLiteral
+BooleanLiteral
+DecimalLiteral
+HexIntegerLiteral
+OctalIntegerLiteral
+OctalIntegerLiteral2
+BinaryIntegerLiteral
+Break
+Do
+Instanceof
+Typeof
+Case
+Else
+New
+Var
+Catch
+Finally
+Return
+Void
+Continue
+For
+Switch
+While
+Debugger
+Function_
+This
+With
+Default
+If
+Throw
+Delete
+In
+Try
+As
+From
+ReadOnly
+Async
+Class
+Enum
+Extends
+Super
+Const
+Export
+Import
+Implements
+Let
+Private
+Public
+Interface
+Package
+Protected
+Static
+Yield
+Any
+Number
+Boolean
+String
+Symbol
+TypeAlias
+Get
+Set
+Constructor
+Namespace
+Require
+Module
+Declare
+Abstract
+Is
+At
+Identifier
+StringLiteral
+BackTick
+WhiteSpaces
+LineTerminator
+HtmlComment
+CDataComment
+UnexpectedCharacter
+TemplateStringEscapeAtom
+TemplateStringStartExpression
+TemplateStringAtom
+
+rule names:
+MultiLineComment
+SingleLineComment
+RegularExpressionLiteral
+OpenBracket
+CloseBracket
+OpenParen
+CloseParen
+OpenBrace
+TemplateCloseBrace
+CloseBrace
+SemiColon
+Comma
+Assign
+QuestionMark
+Colon
+Ellipsis
+Dot
+PlusPlus
+MinusMinus
+Plus
+Minus
+BitNot
+Not
+Multiply
+Divide
+Modulus
+RightShiftArithmetic
+LeftShiftArithmetic
+RightShiftLogical
+LessThan
+MoreThan
+LessThanEquals
+GreaterThanEquals
+Equals_
+NotEquals
+IdentityEquals
+IdentityNotEquals
+BitAnd
+BitXOr
+BitOr
+And
+Or
+MultiplyAssign
+DivideAssign
+ModulusAssign
+PlusAssign
+MinusAssign
+LeftShiftArithmeticAssign
+RightShiftArithmeticAssign
+RightShiftLogicalAssign
+BitAndAssign
+BitXorAssign
+BitOrAssign
+ARROW
+NullLiteral
+BooleanLiteral
+DecimalLiteral
+HexIntegerLiteral
+OctalIntegerLiteral
+OctalIntegerLiteral2
+BinaryIntegerLiteral
+Break
+Do
+Instanceof
+Typeof
+Case
+Else
+New
+Var
+Catch
+Finally
+Return
+Void
+Continue
+For
+Switch
+While
+Debugger
+Function_
+This
+With
+Default
+If
+Throw
+Delete
+In
+Try
+As
+From
+ReadOnly
+Async
+Class
+Enum
+Extends
+Super
+Const
+Export
+Import
+Implements
+Let
+Private
+Public
+Interface
+Package
+Protected
+Static
+Yield
+Any
+Number
+Boolean
+String
+Symbol
+TypeAlias
+Get
+Set
+Constructor
+Namespace
+Require
+Module
+Declare
+Abstract
+Is
+At
+Identifier
+StringLiteral
+BackTick
+WhiteSpaces
+LineTerminator
+HtmlComment
+CDataComment
+UnexpectedCharacter
+TemplateStringEscapeAtom
+BackTickInside
+TemplateStringStartExpression
+TemplateStringAtom
+DoubleStringCharacter
+SingleStringCharacter
+EscapeSequence
+CharacterEscapeSequence
+HexEscapeSequence
+UnicodeEscapeSequence
+ExtendedUnicodeEscapeSequence
+SingleEscapeCharacter
+NonEscapeCharacter
+EscapeCharacter
+LineContinuation
+HexDigit
+DecimalIntegerLiteral
+ExponentPart
+IdentifierPart
+IdentifierStart
+RegularExpressionFirstChar
+RegularExpressionChar
+RegularExpressionClassChar
+RegularExpressionBackslashSequence
+
+channel names:
+DEFAULT_TOKEN_CHANNEL
+HIDDEN
+null
+null
+ERROR
+
+mode names:
+DEFAULT_MODE
+TEMPLATE
+
+atn:
+[4, 0, 134, 1183, 6, -1, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, 7, 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, 2, 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, 126, 7, 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, 130, 2, 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, 135, 7, 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, 139, 2, 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, 144, 7, 144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, 7, 147, 2, 148, 7, 148, 2, 149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, 2, 152, 7, 152, 2, 153, 7, 153, 2, 154, 7, 154, 1, 0, 1, 0, 1, 0, 1, 0, 5, 0, 317, 8, 0, 10, 0, 12, 0, 320, 9, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 5, 1, 331, 8, 1, 10, 1, 12, 1, 334, 9, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 5, 2, 341, 8, 2, 10, 2, 12, 2, 344, 9, 2, 1, 2, 1, 2, 1, 2, 5, 2, 349, 8, 2, 10, 2, 12, 2, 352, 9, 2, 1, 3, 1, 3, 1, 4, 1, 4, 1, 5, 1, 5, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 11, 1, 11, 1, 12, 1, 12, 1, 13, 1, 13, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, 20, 1, 20, 1, 21, 1, 21, 1, 22, 1, 22, 1, 23, 1, 23, 1, 24, 1, 24, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 29, 1, 29, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 38, 1, 38, 1, 39, 1, 39, 1, 40, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 45, 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 3, 55, 509, 8, 55, 1, 56, 1, 56, 1, 56, 5, 56, 514, 8, 56, 10, 56, 12, 56, 517, 9, 56, 1, 56, 3, 56, 520, 8, 56, 1, 56, 1, 56, 4, 56, 524, 8, 56, 11, 56, 12, 56, 525, 1, 56, 3, 56, 529, 8, 56, 1, 56, 1, 56, 3, 56, 533, 8, 56, 3, 56, 535, 8, 56, 1, 57, 1, 57, 1, 57, 4, 57, 540, 8, 57, 11, 57, 12, 57, 541, 1, 58, 1, 58, 4, 58, 546, 8, 58, 11, 58, 12, 58, 547, 1, 58, 1, 58, 1, 59, 1, 59, 1, 59, 4, 59, 555, 8, 59, 11, 59, 12, 59, 556, 1, 60, 1, 60, 1, 60, 4, 60, 562, 8, 60, 11, 60, 12, 60, 563, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86, 1, 86, 1, 87, 1, 87, 1, 87, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 106, 1, 107, 1, 107, 1, 107, 1, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 114, 1, 114, 1, 114, 1, 114, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 121, 1, 122, 1, 122, 1, 123, 1, 123, 5, 123, 968, 8, 123, 10, 123, 12, 123, 971, 9, 123, 1, 124, 1, 124, 5, 124, 975, 8, 124, 10, 124, 12, 124, 978, 9, 124, 1, 124, 1, 124, 1, 124, 5, 124, 983, 8, 124, 10, 124, 12, 124, 986, 9, 124, 1, 124, 3, 124, 989, 8, 124, 1, 124, 1, 124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 126, 4, 126, 999, 8, 126, 11, 126, 12, 126, 1000, 1, 126, 1, 126, 1, 127, 1, 127, 1, 127, 1, 127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 5, 128, 1015, 8, 128, 10, 128, 12, 128, 1018, 9, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 5, 129, 1037, 8, 129, 10, 129, 12, 129, 1040, 9, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 130, 1, 130, 1, 130, 1, 130, 1, 131, 1, 131, 1, 131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 134, 1, 134, 1, 135, 1, 135, 1, 135, 1, 135, 3, 135, 1074, 8, 135, 1, 136, 1, 136, 1, 136, 1, 136, 3, 136, 1080, 8, 136, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 3, 137, 1087, 8, 137, 1, 138, 1, 138, 3, 138, 1091, 8, 138, 1, 139, 1, 139, 1, 139, 1, 139, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 141, 1, 141, 1, 141, 4, 141, 1106, 8, 141, 11, 141, 12, 141, 1107, 1, 141, 1, 141, 1, 142, 1, 142, 1, 143, 1, 143, 1, 144, 1, 144, 3, 144, 1118, 8, 144, 1, 145, 1, 145, 1, 145, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 5, 147, 1128, 8, 147, 10, 147, 12, 147, 1131, 9, 147, 3, 147, 1133, 8, 147, 1, 148, 1, 148, 3, 148, 1137, 8, 148, 1, 148, 4, 148, 1140, 8, 148, 11, 148, 12, 148, 1141, 1, 149, 1, 149, 3, 149, 1146, 8, 149, 1, 150, 1, 150, 1, 150, 3, 150, 1151, 8, 150, 1, 151, 1, 151, 1, 151, 1, 151, 5, 151, 1157, 8, 151, 10, 151, 12, 151, 1160, 9, 151, 1, 151, 3, 151, 1163, 8, 151, 1, 152, 1, 152, 1, 152, 1, 152, 5, 152, 1169, 8, 152, 10, 152, 12, 152, 1172, 9, 152, 1, 152, 3, 152, 1175, 8, 152, 1, 153, 1, 153, 3, 153, 1179, 8, 153, 1, 154, 1, 154, 1, 154, 3, 318, 1016, 1038, 0, 155, 2, 1, 4, 2, 6, 3, 8, 4, 10, 5, 12, 6, 14, 7, 16, 8, 18, 9, 20, 10, 22, 11, 24, 12, 26, 13, 28, 14, 30, 15, 32, 16, 34, 17, 36, 18, 38, 19, 40, 20, 42, 21, 44, 22, 46, 23, 48, 24, 50, 25, 52, 26, 54, 27, 56, 28, 58, 29, 60, 30, 62, 31, 64, 32, 66, 33, 68, 34, 70, 35, 72, 36, 74, 37, 76, 38, 78, 39, 80, 40, 82, 41, 84, 42, 86, 43, 88, 44, 90, 45, 92, 46, 94, 47, 96, 48, 98, 49, 100, 50, 102, 51, 104, 52, 106, 53, 108, 54, 110, 55, 112, 56, 114, 57, 116, 58, 118, 59, 120, 60, 122, 61, 124, 62, 126, 63, 128, 64, 130, 65, 132, 66, 134, 67, 136, 68, 138, 69, 140, 70, 142, 71, 144, 72, 146, 73, 148, 74, 150, 75, 152, 76, 154, 77, 156, 78, 158, 79, 160, 80, 162, 81, 164, 82, 166, 83, 168, 84, 170, 85, 172, 86, 174, 87, 176, 88, 178, 89, 180, 90, 182, 91, 184, 92, 186, 93, 188, 94, 190, 95, 192, 96, 194, 97, 196, 98, 198, 99, 200, 100, 202, 101, 204, 102, 206, 103, 208, 104, 210, 105, 212, 106, 214, 107, 216, 108, 218, 109, 220, 110, 222, 111, 224, 112, 226, 113, 228, 114, 230, 115, 232, 116, 234, 117, 236, 118, 238, 119, 240, 120, 242, 121, 244, 122, 246, 123, 248, 124, 250, 125, 252, 126, 254, 127, 256, 128, 258, 129, 260, 130, 262, 131, 264, 132, 266, 0, 268, 133, 270, 134, 272, 0, 274, 0, 276, 0, 278, 0, 280, 0, 282, 0, 284, 0, 286, 0, 288, 0, 290, 0, 292, 0, 294, 0, 296, 0, 298, 0, 300, 0, 302, 0, 304, 0, 306, 0, 308, 0, 310, 0, 2, 0, 1, 23, 3, 0, 10, 10, 13, 13, 8232, 8233, 1, 0, 48, 57, 2, 0, 88, 88, 120, 120, 1, 0, 48, 55, 2, 0, 79, 79, 111, 111, 2, 0, 66, 66, 98, 98, 1, 0, 48, 49, 4, 0, 9, 9, 11, 12, 32, 32, 160, 160, 2, 0, 92, 92, 96, 96, 4, 0, 10, 10, 13, 13, 34, 34, 92, 92, 4, 0, 10, 10, 13, 13, 39, 39, 92, 92, 9, 0, 34, 34, 39, 39, 92, 92, 98, 98, 102, 102, 110, 110, 114, 114, 116, 116, 118, 118, 12, 0, 10, 10, 13, 13, 34, 34, 39, 39, 48, 57, 92, 92, 98, 98, 102, 102, 110, 110, 114, 114, 116, 118, 120, 120, 3, 0, 48, 57, 117, 117, 120, 120, 3, 0, 48, 57, 65, 70, 97, 102, 1, 0, 49, 57, 2, 0, 69, 69, 101, 101, 2, 0, 43, 43, 45, 45, 408, 0, 48, 57, 95, 95, 768, 879, 1155, 1159, 1425, 1469, 1471, 1471, 1473, 1474, 1476, 1477, 1479, 1479, 1552, 1562, 1611, 1641, 1648, 1648, 1750, 1756, 1759, 1764, 1767, 1768, 1770, 1773, 1776, 1785, 1809, 1809, 1840, 1866, 1958, 1968, 1984, 1993, 2027, 2035, 2045, 2045, 2070, 2073, 2075, 2083, 2085, 2087, 2089, 2093, 2137, 2139, 2200, 2207, 2250, 2273, 2275, 2306, 2362, 2362, 2364, 2364, 2369, 2376, 2381, 2381, 2385, 2391, 2402, 2403, 2406, 2415, 2433, 2433, 2492, 2492, 2497, 2500, 2509, 2509, 2530, 2531, 2534, 2543, 2558, 2558, 2561, 2562, 2620, 2620, 2625, 2626, 2631, 2632, 2635, 2637, 2641, 2641, 2662, 2673, 2677, 2677, 2689, 2690, 2748, 2748, 2753, 2757, 2759, 2760, 2765, 2765, 2786, 2787, 2790, 2799, 2810, 2815, 2817, 2817, 2876, 2876, 2879, 2879, 2881, 2884, 2893, 2893, 2901, 2902, 2914, 2915, 2918, 2927, 2946, 2946, 3008, 3008, 3021, 3021, 3046, 3055, 3072, 3072, 3076, 3076, 3132, 3132, 3134, 3136, 3142, 3144, 3146, 3149, 3157, 3158, 3170, 3171, 3174, 3183, 3201, 3201, 3260, 3260, 3263, 3263, 3270, 3270, 3276, 3277, 3298, 3299, 3302, 3311, 3328, 3329, 3387, 3388, 3393, 3396, 3405, 3405, 3426, 3427, 3430, 3439, 3457, 3457, 3530, 3530, 3538, 3540, 3542, 3542, 3558, 3567, 3633, 3633, 3636, 3642, 3655, 3662, 3664, 3673, 3761, 3761, 3764, 3772, 3784, 3790, 3792, 3801, 3864, 3865, 3872, 3881, 3893, 3893, 3895, 3895, 3897, 3897, 3953, 3966, 3968, 3972, 3974, 3975, 3981, 3991, 3993, 4028, 4038, 4038, 4141, 4144, 4146, 4151, 4153, 4154, 4157, 4158, 4160, 4169, 4184, 4185, 4190, 4192, 4209, 4212, 4226, 4226, 4229, 4230, 4237, 4237, 4240, 4249, 4253, 4253, 4957, 4959, 5906, 5908, 5938, 5939, 5970, 5971, 6002, 6003, 6068, 6069, 6071, 6077, 6086, 6086, 6089, 6099, 6109, 6109, 6112, 6121, 6155, 6157, 6159, 6169, 6277, 6278, 6313, 6313, 6432, 6434, 6439, 6440, 6450, 6450, 6457, 6459, 6470, 6479, 6608, 6617, 6679, 6680, 6683, 6683, 6742, 6742, 6744, 6750, 6752, 6752, 6754, 6754, 6757, 6764, 6771, 6780, 6783, 6793, 6800, 6809, 6832, 6845, 6847, 6862, 6912, 6915, 6964, 6964, 6966, 6970, 6972, 6972, 6978, 6978, 6992, 7001, 7019, 7027, 7040, 7041, 7074, 7077, 7080, 7081, 7083, 7085, 7088, 7097, 7142, 7142, 7144, 7145, 7149, 7149, 7151, 7153, 7212, 7219, 7222, 7223, 7232, 7241, 7248, 7257, 7376, 7378, 7380, 7392, 7394, 7400, 7405, 7405, 7412, 7412, 7416, 7417, 7616, 7679, 8204, 8205, 8255, 8256, 8276, 8276, 8400, 8412, 8417, 8417, 8421, 8432, 11503, 11505, 11647, 11647, 11744, 11775, 12330, 12333, 12441, 12442, 42528, 42537, 42607, 42607, 42612, 42621, 42654, 42655, 42736, 42737, 43010, 43010, 43014, 43014, 43019, 43019, 43045, 43046, 43052, 43052, 43204, 43205, 43216, 43225, 43232, 43249, 43263, 43273, 43302, 43309, 43335, 43345, 43392, 43394, 43443, 43443, 43446, 43449, 43452, 43453, 43472, 43481, 43493, 43493, 43504, 43513, 43561, 43566, 43569, 43570, 43573, 43574, 43587, 43587, 43596, 43596, 43600, 43609, 43644, 43644, 43696, 43696, 43698, 43700, 43703, 43704, 43710, 43711, 43713, 43713, 43756, 43757, 43766, 43766, 44005, 44005, 44008, 44008, 44013, 44013, 44016, 44025, 64286, 64286, 65024, 65039, 65056, 65071, 65075, 65076, 65101, 65103, 65296, 65305, 65343, 65343, 66045, 66045, 66272, 66272, 66422, 66426, 66720, 66729, 68097, 68099, 68101, 68102, 68108, 68111, 68152, 68154, 68159, 68159, 68325, 68326, 68900, 68903, 68912, 68921, 69291, 69292, 69373, 69375, 69446, 69456, 69506, 69509, 69633, 69633, 69688, 69702, 69734, 69744, 69747, 69748, 69759, 69761, 69811, 69814, 69817, 69818, 69826, 69826, 69872, 69881, 69888, 69890, 69927, 69931, 69933, 69940, 69942, 69951, 70003, 70003, 70016, 70017, 70070, 70078, 70089, 70092, 70095, 70105, 70191, 70193, 70196, 70196, 70198, 70199, 70206, 70206, 70209, 70209, 70367, 70367, 70371, 70378, 70384, 70393, 70400, 70401, 70459, 70460, 70464, 70464, 70502, 70508, 70512, 70516, 70712, 70719, 70722, 70724, 70726, 70726, 70736, 70745, 70750, 70750, 70835, 70840, 70842, 70842, 70847, 70848, 70850, 70851, 70864, 70873, 71090, 71093, 71100, 71101, 71103, 71104, 71132, 71133, 71219, 71226, 71229, 71229, 71231, 71232, 71248, 71257, 71339, 71339, 71341, 71341, 71344, 71349, 71351, 71351, 71360, 71369, 71453, 71455, 71458, 71461, 71463, 71467, 71472, 71481, 71727, 71735, 71737, 71738, 71904, 71913, 71995, 71996, 71998, 71998, 72003, 72003, 72016, 72025, 72148, 72151, 72154, 72155, 72160, 72160, 72193, 72202, 72243, 72248, 72251, 72254, 72263, 72263, 72273, 72278, 72281, 72283, 72330, 72342, 72344, 72345, 72752, 72758, 72760, 72765, 72767, 72767, 72784, 72793, 72850, 72871, 72874, 72880, 72882, 72883, 72885, 72886, 73009, 73014, 73018, 73018, 73020, 73021, 73023, 73029, 73031, 73031, 73040, 73049, 73104, 73105, 73109, 73109, 73111, 73111, 73120, 73129, 73459, 73460, 73472, 73473, 73526, 73530, 73536, 73536, 73538, 73538, 73552, 73561, 78912, 78912, 78919, 78933, 92768, 92777, 92864, 92873, 92912, 92916, 92976, 92982, 93008, 93017, 94031, 94031, 94095, 94098, 94180, 94180, 113821, 113822, 118528, 118573, 118576, 118598, 119143, 119145, 119163, 119170, 119173, 119179, 119210, 119213, 119362, 119364, 120782, 120831, 121344, 121398, 121403, 121452, 121461, 121461, 121476, 121476, 121499, 121503, 121505, 121519, 122880, 122886, 122888, 122904, 122907, 122913, 122915, 122916, 122918, 122922, 123023, 123023, 123184, 123190, 123200, 123209, 123566, 123566, 123628, 123641, 124140, 124153, 125136, 125142, 125252, 125258, 125264, 125273, 130032, 130041, 917760, 917999, 661, 0, 36, 36, 65, 90, 95, 95, 97, 122, 170, 170, 181, 181, 186, 186, 192, 214, 216, 246, 248, 705, 710, 721, 736, 740, 748, 748, 750, 750, 880, 884, 886, 887, 890, 893, 895, 895, 902, 902, 904, 906, 908, 908, 910, 929, 931, 1013, 1015, 1153, 1162, 1327, 1329, 1366, 1369, 1369, 1376, 1416, 1488, 1514, 1519, 1522, 1568, 1610, 1646, 1647, 1649, 1747, 1749, 1749, 1765, 1766, 1774, 1775, 1786, 1788, 1791, 1791, 1808, 1808, 1810, 1839, 1869, 1957, 1969, 1969, 1994, 2026, 2036, 2037, 2042, 2042, 2048, 2069, 2074, 2074, 2084, 2084, 2088, 2088, 2112, 2136, 2144, 2154, 2160, 2183, 2185, 2190, 2208, 2249, 2308, 2361, 2365, 2365, 2384, 2384, 2392, 2401, 2417, 2432, 2437, 2444, 2447, 2448, 2451, 2472, 2474, 2480, 2482, 2482, 2486, 2489, 2493, 2493, 2510, 2510, 2524, 2525, 2527, 2529, 2544, 2545, 2556, 2556, 2565, 2570, 2575, 2576, 2579, 2600, 2602, 2608, 2610, 2611, 2613, 2614, 2616, 2617, 2649, 2652, 2654, 2654, 2674, 2676, 2693, 2701, 2703, 2705, 2707, 2728, 2730, 2736, 2738, 2739, 2741, 2745, 2749, 2749, 2768, 2768, 2784, 2785, 2809, 2809, 2821, 2828, 2831, 2832, 2835, 2856, 2858, 2864, 2866, 2867, 2869, 2873, 2877, 2877, 2908, 2909, 2911, 2913, 2929, 2929, 2947, 2947, 2949, 2954, 2958, 2960, 2962, 2965, 2969, 2970, 2972, 2972, 2974, 2975, 2979, 2980, 2984, 2986, 2990, 3001, 3024, 3024, 3077, 3084, 3086, 3088, 3090, 3112, 3114, 3129, 3133, 3133, 3160, 3162, 3165, 3165, 3168, 3169, 3200, 3200, 3205, 3212, 3214, 3216, 3218, 3240, 3242, 3251, 3253, 3257, 3261, 3261, 3293, 3294, 3296, 3297, 3313, 3314, 3332, 3340, 3342, 3344, 3346, 3386, 3389, 3389, 3406, 3406, 3412, 3414, 3423, 3425, 3450, 3455, 3461, 3478, 3482, 3505, 3507, 3515, 3517, 3517, 3520, 3526, 3585, 3632, 3634, 3635, 3648, 3654, 3713, 3714, 3716, 3716, 3718, 3722, 3724, 3747, 3749, 3749, 3751, 3760, 3762, 3763, 3773, 3773, 3776, 3780, 3782, 3782, 3804, 3807, 3840, 3840, 3904, 3911, 3913, 3948, 3976, 3980, 4096, 4138, 4159, 4159, 4176, 4181, 4186, 4189, 4193, 4193, 4197, 4198, 4206, 4208, 4213, 4225, 4238, 4238, 4256, 4293, 4295, 4295, 4301, 4301, 4304, 4346, 4348, 4680, 4682, 4685, 4688, 4694, 4696, 4696, 4698, 4701, 4704, 4744, 4746, 4749, 4752, 4784, 4786, 4789, 4792, 4798, 4800, 4800, 4802, 4805, 4808, 4822, 4824, 4880, 4882, 4885, 4888, 4954, 4992, 5007, 5024, 5109, 5112, 5117, 5121, 5740, 5743, 5759, 5761, 5786, 5792, 5866, 5873, 5880, 5888, 5905, 5919, 5937, 5952, 5969, 5984, 5996, 5998, 6000, 6016, 6067, 6103, 6103, 6108, 6108, 6176, 6264, 6272, 6276, 6279, 6312, 6314, 6314, 6320, 6389, 6400, 6430, 6480, 6509, 6512, 6516, 6528, 6571, 6576, 6601, 6656, 6678, 6688, 6740, 6823, 6823, 6917, 6963, 6981, 6988, 7043, 7072, 7086, 7087, 7098, 7141, 7168, 7203, 7245, 7247, 7258, 7293, 7296, 7304, 7312, 7354, 7357, 7359, 7401, 7404, 7406, 7411, 7413, 7414, 7418, 7418, 7424, 7615, 7680, 7957, 7960, 7965, 7968, 8005, 8008, 8013, 8016, 8023, 8025, 8025, 8027, 8027, 8029, 8029, 8031, 8061, 8064, 8116, 8118, 8124, 8126, 8126, 8130, 8132, 8134, 8140, 8144, 8147, 8150, 8155, 8160, 8172, 8178, 8180, 8182, 8188, 8305, 8305, 8319, 8319, 8336, 8348, 8450, 8450, 8455, 8455, 8458, 8467, 8469, 8469, 8473, 8477, 8484, 8484, 8486, 8486, 8488, 8488, 8490, 8493, 8495, 8505, 8508, 8511, 8517, 8521, 8526, 8526, 8579, 8580, 11264, 11492, 11499, 11502, 11506, 11507, 11520, 11557, 11559, 11559, 11565, 11565, 11568, 11623, 11631, 11631, 11648, 11670, 11680, 11686, 11688, 11694, 11696, 11702, 11704, 11710, 11712, 11718, 11720, 11726, 11728, 11734, 11736, 11742, 11823, 11823, 12293, 12294, 12337, 12341, 12347, 12348, 12353, 12438, 12445, 12447, 12449, 12538, 12540, 12543, 12549, 12591, 12593, 12686, 12704, 12735, 12784, 12799, 13312, 19903, 19968, 42124, 42192, 42237, 42240, 42508, 42512, 42527, 42538, 42539, 42560, 42606, 42623, 42653, 42656, 42725, 42775, 42783, 42786, 42888, 42891, 42954, 42960, 42961, 42963, 42963, 42965, 42969, 42994, 43009, 43011, 43013, 43015, 43018, 43020, 43042, 43072, 43123, 43138, 43187, 43250, 43255, 43259, 43259, 43261, 43262, 43274, 43301, 43312, 43334, 43360, 43388, 43396, 43442, 43471, 43471, 43488, 43492, 43494, 43503, 43514, 43518, 43520, 43560, 43584, 43586, 43588, 43595, 43616, 43638, 43642, 43642, 43646, 43695, 43697, 43697, 43701, 43702, 43705, 43709, 43712, 43712, 43714, 43714, 43739, 43741, 43744, 43754, 43762, 43764, 43777, 43782, 43785, 43790, 43793, 43798, 43808, 43814, 43816, 43822, 43824, 43866, 43868, 43881, 43888, 44002, 44032, 55203, 55216, 55238, 55243, 55291, 63744, 64109, 64112, 64217, 64256, 64262, 64275, 64279, 64285, 64285, 64287, 64296, 64298, 64310, 64312, 64316, 64318, 64318, 64320, 64321, 64323, 64324, 64326, 64433, 64467, 64829, 64848, 64911, 64914, 64967, 65008, 65019, 65136, 65140, 65142, 65276, 65313, 65338, 65345, 65370, 65382, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, 65536, 65547, 65549, 65574, 65576, 65594, 65596, 65597, 65599, 65613, 65616, 65629, 65664, 65786, 66176, 66204, 66208, 66256, 66304, 66335, 66349, 66368, 66370, 66377, 66384, 66421, 66432, 66461, 66464, 66499, 66504, 66511, 66560, 66717, 66736, 66771, 66776, 66811, 66816, 66855, 66864, 66915, 66928, 66938, 66940, 66954, 66956, 66962, 66964, 66965, 66967, 66977, 66979, 66993, 66995, 67001, 67003, 67004, 67072, 67382, 67392, 67413, 67424, 67431, 67456, 67461, 67463, 67504, 67506, 67514, 67584, 67589, 67592, 67592, 67594, 67637, 67639, 67640, 67644, 67644, 67647, 67669, 67680, 67702, 67712, 67742, 67808, 67826, 67828, 67829, 67840, 67861, 67872, 67897, 67968, 68023, 68030, 68031, 68096, 68096, 68112, 68115, 68117, 68119, 68121, 68149, 68192, 68220, 68224, 68252, 68288, 68295, 68297, 68324, 68352, 68405, 68416, 68437, 68448, 68466, 68480, 68497, 68608, 68680, 68736, 68786, 68800, 68850, 68864, 68899, 69248, 69289, 69296, 69297, 69376, 69404, 69415, 69415, 69424, 69445, 69488, 69505, 69552, 69572, 69600, 69622, 69635, 69687, 69745, 69746, 69749, 69749, 69763, 69807, 69840, 69864, 69891, 69926, 69956, 69956, 69959, 69959, 69968, 70002, 70006, 70006, 70019, 70066, 70081, 70084, 70106, 70106, 70108, 70108, 70144, 70161, 70163, 70187, 70207, 70208, 70272, 70278, 70280, 70280, 70282, 70285, 70287, 70301, 70303, 70312, 70320, 70366, 70405, 70412, 70415, 70416, 70419, 70440, 70442, 70448, 70450, 70451, 70453, 70457, 70461, 70461, 70480, 70480, 70493, 70497, 70656, 70708, 70727, 70730, 70751, 70753, 70784, 70831, 70852, 70853, 70855, 70855, 71040, 71086, 71128, 71131, 71168, 71215, 71236, 71236, 71296, 71338, 71352, 71352, 71424, 71450, 71488, 71494, 71680, 71723, 71840, 71903, 71935, 71942, 71945, 71945, 71948, 71955, 71957, 71958, 71960, 71983, 71999, 71999, 72001, 72001, 72096, 72103, 72106, 72144, 72161, 72161, 72163, 72163, 72192, 72192, 72203, 72242, 72250, 72250, 72272, 72272, 72284, 72329, 72349, 72349, 72368, 72440, 72704, 72712, 72714, 72750, 72768, 72768, 72818, 72847, 72960, 72966, 72968, 72969, 72971, 73008, 73030, 73030, 73056, 73061, 73063, 73064, 73066, 73097, 73112, 73112, 73440, 73458, 73474, 73474, 73476, 73488, 73490, 73523, 73648, 73648, 73728, 74649, 74880, 75075, 77712, 77808, 77824, 78895, 78913, 78918, 82944, 83526, 92160, 92728, 92736, 92766, 92784, 92862, 92880, 92909, 92928, 92975, 92992, 92995, 93027, 93047, 93053, 93071, 93760, 93823, 93952, 94026, 94032, 94032, 94099, 94111, 94176, 94177, 94179, 94179, 94208, 100343, 100352, 101589, 101632, 101640, 110576, 110579, 110581, 110587, 110589, 110590, 110592, 110882, 110898, 110898, 110928, 110930, 110933, 110933, 110948, 110951, 110960, 111355, 113664, 113770, 113776, 113788, 113792, 113800, 113808, 113817, 119808, 119892, 119894, 119964, 119966, 119967, 119970, 119970, 119973, 119974, 119977, 119980, 119982, 119993, 119995, 119995, 119997, 120003, 120005, 120069, 120071, 120074, 120077, 120084, 120086, 120092, 120094, 120121, 120123, 120126, 120128, 120132, 120134, 120134, 120138, 120144, 120146, 120485, 120488, 120512, 120514, 120538, 120540, 120570, 120572, 120596, 120598, 120628, 120630, 120654, 120656, 120686, 120688, 120712, 120714, 120744, 120746, 120770, 120772, 120779, 122624, 122654, 122661, 122666, 122928, 122989, 123136, 123180, 123191, 123197, 123214, 123214, 123536, 123565, 123584, 123627, 124112, 124139, 124896, 124902, 124904, 124907, 124909, 124910, 124912, 124926, 124928, 125124, 125184, 125251, 125259, 125259, 126464, 126467, 126469, 126495, 126497, 126498, 126500, 126500, 126503, 126503, 126505, 126514, 126516, 126519, 126521, 126521, 126523, 126523, 126530, 126530, 126535, 126535, 126537, 126537, 126539, 126539, 126541, 126543, 126545, 126546, 126548, 126548, 126551, 126551, 126553, 126553, 126555, 126555, 126557, 126557, 126559, 126559, 126561, 126562, 126564, 126564, 126567, 126570, 126572, 126578, 126580, 126583, 126585, 126588, 126590, 126590, 126592, 126601, 126603, 126619, 126625, 126627, 126629, 126633, 126635, 126651, 131072, 173791, 173824, 177977, 177984, 178205, 178208, 183969, 183984, 191456, 194560, 195101, 196608, 201546, 201552, 205743, 6, 0, 10, 10, 13, 13, 42, 42, 47, 47, 91, 92, 8232, 8233, 5, 0, 10, 10, 13, 13, 47, 47, 91, 92, 8232, 8233, 4, 0, 10, 10, 13, 13, 92, 93, 8232, 8233, 1208, 0, 2, 1, 0, 0, 0, 0, 4, 1, 0, 0, 0, 0, 6, 1, 0, 0, 0, 0, 8, 1, 0, 0, 0, 0, 10, 1, 0, 0, 0, 0, 12, 1, 0, 0, 0, 0, 14, 1, 0, 0, 0, 0, 16, 1, 0, 0, 0, 0, 18, 1, 0, 0, 0, 0, 20, 1, 0, 0, 0, 0, 22, 1, 0, 0, 0, 0, 24, 1, 0, 0, 0, 0, 26, 1, 0, 0, 0, 0, 28, 1, 0, 0, 0, 0, 30, 1, 0, 0, 0, 0, 32, 1, 0, 0, 0, 0, 34, 1, 0, 0, 0, 0, 36, 1, 0, 0, 0, 0, 38, 1, 0, 0, 0, 0, 40, 1, 0, 0, 0, 0, 42, 1, 0, 0, 0, 0, 44, 1, 0, 0, 0, 0, 46, 1, 0, 0, 0, 0, 48, 1, 0, 0, 0, 0, 50, 1, 0, 0, 0, 0, 52, 1, 0, 0, 0, 0, 54, 1, 0, 0, 0, 0, 56, 1, 0, 0, 0, 0, 58, 1, 0, 0, 0, 0, 60, 1, 0, 0, 0, 0, 62, 1, 0, 0, 0, 0, 64, 1, 0, 0, 0, 0, 66, 1, 0, 0, 0, 0, 68, 1, 0, 0, 0, 0, 70, 1, 0, 0, 0, 0, 72, 1, 0, 0, 0, 0, 74, 1, 0, 0, 0, 0, 76, 1, 0, 0, 0, 0, 78, 1, 0, 0, 0, 0, 80, 1, 0, 0, 0, 0, 82, 1, 0, 0, 0, 0, 84, 1, 0, 0, 0, 0, 86, 1, 0, 0, 0, 0, 88, 1, 0, 0, 0, 0, 90, 1, 0, 0, 0, 0, 92, 1, 0, 0, 0, 0, 94, 1, 0, 0, 0, 0, 96, 1, 0, 0, 0, 0, 98, 1, 0, 0, 0, 0, 100, 1, 0, 0, 0, 0, 102, 1, 0, 0, 0, 0, 104, 1, 0, 0, 0, 0, 106, 1, 0, 0, 0, 0, 108, 1, 0, 0, 0, 0, 110, 1, 0, 0, 0, 0, 112, 1, 0, 0, 0, 0, 114, 1, 0, 0, 0, 0, 116, 1, 0, 0, 0, 0, 118, 1, 0, 0, 0, 0, 120, 1, 0, 0, 0, 0, 122, 1, 0, 0, 0, 0, 124, 1, 0, 0, 0, 0, 126, 1, 0, 0, 0, 0, 128, 1, 0, 0, 0, 0, 130, 1, 0, 0, 0, 0, 132, 1, 0, 0, 0, 0, 134, 1, 0, 0, 0, 0, 136, 1, 0, 0, 0, 0, 138, 1, 0, 0, 0, 0, 140, 1, 0, 0, 0, 0, 142, 1, 0, 0, 0, 0, 144, 1, 0, 0, 0, 0, 146, 1, 0, 0, 0, 0, 148, 1, 0, 0, 0, 0, 150, 1, 0, 0, 0, 0, 152, 1, 0, 0, 0, 0, 154, 1, 0, 0, 0, 0, 156, 1, 0, 0, 0, 0, 158, 1, 0, 0, 0, 0, 160, 1, 0, 0, 0, 0, 162, 1, 0, 0, 0, 0, 164, 1, 0, 0, 0, 0, 166, 1, 0, 0, 0, 0, 168, 1, 0, 0, 0, 0, 170, 1, 0, 0, 0, 0, 172, 1, 0, 0, 0, 0, 174, 1, 0, 0, 0, 0, 176, 1, 0, 0, 0, 0, 178, 1, 0, 0, 0, 0, 180, 1, 0, 0, 0, 0, 182, 1, 0, 0, 0, 0, 184, 1, 0, 0, 0, 0, 186, 1, 0, 0, 0, 0, 188, 1, 0, 0, 0, 0, 190, 1, 0, 0, 0, 0, 192, 1, 0, 0, 0, 0, 194, 1, 0, 0, 0, 0, 196, 1, 0, 0, 0, 0, 198, 1, 0, 0, 0, 0, 200, 1, 0, 0, 0, 0, 202, 1, 0, 0, 0, 0, 204, 1, 0, 0, 0, 0, 206, 1, 0, 0, 0, 0, 208, 1, 0, 0, 0, 0, 210, 1, 0, 0, 0, 0, 212, 1, 0, 0, 0, 0, 214, 1, 0, 0, 0, 0, 216, 1, 0, 0, 0, 0, 218, 1, 0, 0, 0, 0, 220, 1, 0, 0, 0, 0, 222, 1, 0, 0, 0, 0, 224, 1, 0, 0, 0, 0, 226, 1, 0, 0, 0, 0, 228, 1, 0, 0, 0, 0, 230, 1, 0, 0, 0, 0, 232, 1, 0, 0, 0, 0, 234, 1, 0, 0, 0, 0, 236, 1, 0, 0, 0, 0, 238, 1, 0, 0, 0, 0, 240, 1, 0, 0, 0, 0, 242, 1, 0, 0, 0, 0, 244, 1, 0, 0, 0, 0, 246, 1, 0, 0, 0, 0, 248, 1, 0, 0, 0, 0, 250, 1, 0, 0, 0, 0, 252, 1, 0, 0, 0, 0, 254, 1, 0, 0, 0, 0, 256, 1, 0, 0, 0, 0, 258, 1, 0, 0, 0, 0, 260, 1, 0, 0, 0, 0, 262, 1, 0, 0, 0, 1, 264, 1, 0, 0, 0, 1, 266, 1, 0, 0, 0, 1, 268, 1, 0, 0, 0, 1, 270, 1, 0, 0, 0, 2, 312, 1, 0, 0, 0, 4, 326, 1, 0, 0, 0, 6, 337, 1, 0, 0, 0, 8, 353, 1, 0, 0, 0, 10, 355, 1, 0, 0, 0, 12, 357, 1, 0, 0, 0, 14, 359, 1, 0, 0, 0, 16, 361, 1, 0, 0, 0, 18, 364, 1, 0, 0, 0, 20, 369, 1, 0, 0, 0, 22, 372, 1, 0, 0, 0, 24, 374, 1, 0, 0, 0, 26, 376, 1, 0, 0, 0, 28, 378, 1, 0, 0, 0, 30, 380, 1, 0, 0, 0, 32, 382, 1, 0, 0, 0, 34, 386, 1, 0, 0, 0, 36, 388, 1, 0, 0, 0, 38, 391, 1, 0, 0, 0, 40, 394, 1, 0, 0, 0, 42, 396, 1, 0, 0, 0, 44, 398, 1, 0, 0, 0, 46, 400, 1, 0, 0, 0, 48, 402, 1, 0, 0, 0, 50, 404, 1, 0, 0, 0, 52, 406, 1, 0, 0, 0, 54, 408, 1, 0, 0, 0, 56, 411, 1, 0, 0, 0, 58, 414, 1, 0, 0, 0, 60, 418, 1, 0, 0, 0, 62, 420, 1, 0, 0, 0, 64, 422, 1, 0, 0, 0, 66, 425, 1, 0, 0, 0, 68, 428, 1, 0, 0, 0, 70, 431, 1, 0, 0, 0, 72, 434, 1, 0, 0, 0, 74, 438, 1, 0, 0, 0, 76, 442, 1, 0, 0, 0, 78, 444, 1, 0, 0, 0, 80, 446, 1, 0, 0, 0, 82, 448, 1, 0, 0, 0, 84, 451, 1, 0, 0, 0, 86, 454, 1, 0, 0, 0, 88, 457, 1, 0, 0, 0, 90, 460, 1, 0, 0, 0, 92, 463, 1, 0, 0, 0, 94, 466, 1, 0, 0, 0, 96, 469, 1, 0, 0, 0, 98, 473, 1, 0, 0, 0, 100, 477, 1, 0, 0, 0, 102, 482, 1, 0, 0, 0, 104, 485, 1, 0, 0, 0, 106, 488, 1, 0, 0, 0, 108, 491, 1, 0, 0, 0, 110, 494, 1, 0, 0, 0, 112, 508, 1, 0, 0, 0, 114, 534, 1, 0, 0, 0, 116, 536, 1, 0, 0, 0, 118, 543, 1, 0, 0, 0, 120, 551, 1, 0, 0, 0, 122, 558, 1, 0, 0, 0, 124, 565, 1, 0, 0, 0, 126, 571, 1, 0, 0, 0, 128, 574, 1, 0, 0, 0, 130, 585, 1, 0, 0, 0, 132, 592, 1, 0, 0, 0, 134, 597, 1, 0, 0, 0, 136, 602, 1, 0, 0, 0, 138, 606, 1, 0, 0, 0, 140, 610, 1, 0, 0, 0, 142, 616, 1, 0, 0, 0, 144, 624, 1, 0, 0, 0, 146, 631, 1, 0, 0, 0, 148, 636, 1, 0, 0, 0, 150, 645, 1, 0, 0, 0, 152, 649, 1, 0, 0, 0, 154, 656, 1, 0, 0, 0, 156, 662, 1, 0, 0, 0, 158, 671, 1, 0, 0, 0, 160, 680, 1, 0, 0, 0, 162, 685, 1, 0, 0, 0, 164, 690, 1, 0, 0, 0, 166, 698, 1, 0, 0, 0, 168, 701, 1, 0, 0, 0, 170, 707, 1, 0, 0, 0, 172, 714, 1, 0, 0, 0, 174, 717, 1, 0, 0, 0, 176, 721, 1, 0, 0, 0, 178, 724, 1, 0, 0, 0, 180, 729, 1, 0, 0, 0, 182, 738, 1, 0, 0, 0, 184, 744, 1, 0, 0, 0, 186, 750, 1, 0, 0, 0, 188, 755, 1, 0, 0, 0, 190, 763, 1, 0, 0, 0, 192, 769, 1, 0, 0, 0, 194, 775, 1, 0, 0, 0, 196, 782, 1, 0, 0, 0, 198, 789, 1, 0, 0, 0, 200, 800, 1, 0, 0, 0, 202, 804, 1, 0, 0, 0, 204, 812, 1, 0, 0, 0, 206, 819, 1, 0, 0, 0, 208, 829, 1, 0, 0, 0, 210, 837, 1, 0, 0, 0, 212, 847, 1, 0, 0, 0, 214, 854, 1, 0, 0, 0, 216, 860, 1, 0, 0, 0, 218, 864, 1, 0, 0, 0, 220, 871, 1, 0, 0, 0, 222, 879, 1, 0, 0, 0, 224, 886, 1, 0, 0, 0, 226, 893, 1, 0, 0, 0, 228, 898, 1, 0, 0, 0, 230, 902, 1, 0, 0, 0, 232, 906, 1, 0, 0, 0, 234, 918, 1, 0, 0, 0, 236, 928, 1, 0, 0, 0, 238, 936, 1, 0, 0, 0, 240, 943, 1, 0, 0, 0, 242, 951, 1, 0, 0, 0, 244, 960, 1, 0, 0, 0, 246, 963, 1, 0, 0, 0, 248, 965, 1, 0, 0, 0, 250, 988, 1, 0, 0, 0, 252, 992, 1, 0, 0, 0, 254, 998, 1, 0, 0, 0, 256, 1004, 1, 0, 0, 0, 258, 1008, 1, 0, 0, 0, 260, 1025, 1, 0, 0, 0, 262, 1047, 1, 0, 0, 0, 264, 1051, 1, 0, 0, 0, 266, 1054, 1, 0, 0, 0, 268, 1060, 1, 0, 0, 0, 270, 1067, 1, 0, 0, 0, 272, 1073, 1, 0, 0, 0, 274, 1079, 1, 0, 0, 0, 276, 1086, 1, 0, 0, 0, 278, 1090, 1, 0, 0, 0, 280, 1092, 1, 0, 0, 0, 282, 1096, 1, 0, 0, 0, 284, 1102, 1, 0, 0, 0, 286, 1111, 1, 0, 0, 0, 288, 1113, 1, 0, 0, 0, 290, 1117, 1, 0, 0, 0, 292, 1119, 1, 0, 0, 0, 294, 1122, 1, 0, 0, 0, 296, 1132, 1, 0, 0, 0, 298, 1134, 1, 0, 0, 0, 300, 1145, 1, 0, 0, 0, 302, 1150, 1, 0, 0, 0, 304, 1162, 1, 0, 0, 0, 306, 1174, 1, 0, 0, 0, 308, 1178, 1, 0, 0, 0, 310, 1180, 1, 0, 0, 0, 312, 313, 5, 47, 0, 0, 313, 314, 5, 42, 0, 0, 314, 318, 1, 0, 0, 0, 315, 317, 9, 0, 0, 0, 316, 315, 1, 0, 0, 0, 317, 320, 1, 0, 0, 0, 318, 319, 1, 0, 0, 0, 318, 316, 1, 0, 0, 0, 319, 321, 1, 0, 0, 0, 320, 318, 1, 0, 0, 0, 321, 322, 5, 42, 0, 0, 322, 323, 5, 47, 0, 0, 323, 324, 1, 0, 0, 0, 324, 325, 6, 0, 0, 0, 325, 3, 1, 0, 0, 0, 326, 327, 5, 47, 0, 0, 327, 328, 5, 47, 0, 0, 328, 332, 1, 0, 0, 0, 329, 331, 8, 0, 0, 0, 330, 329, 1, 0, 0, 0, 331, 334, 1, 0, 0, 0, 332, 330, 1, 0, 0, 0, 332, 333, 1, 0, 0, 0, 333, 335, 1, 0, 0, 0, 334, 332, 1, 0, 0, 0, 335, 336, 6, 1, 0, 0, 336, 5, 1, 0, 0, 0, 337, 338, 5, 47, 0, 0, 338, 342, 3, 304, 151, 0, 339, 341, 3, 306, 152, 0, 340, 339, 1, 0, 0, 0, 341, 344, 1, 0, 0, 0, 342, 340, 1, 0, 0, 0, 342, 343, 1, 0, 0, 0, 343, 345, 1, 0, 0, 0, 344, 342, 1, 0, 0, 0, 345, 346, 4, 2, 0, 0, 346, 350, 5, 47, 0, 0, 347, 349, 3, 300, 149, 0, 348, 347, 1, 0, 0, 0, 349, 352, 1, 0, 0, 0, 350, 348, 1, 0, 0, 0, 350, 351, 1, 0, 0, 0, 351, 7, 1, 0, 0, 0, 352, 350, 1, 0, 0, 0, 353, 354, 5, 91, 0, 0, 354, 9, 1, 0, 0, 0, 355, 356, 5, 93, 0, 0, 356, 11, 1, 0, 0, 0, 357, 358, 5, 40, 0, 0, 358, 13, 1, 0, 0, 0, 359, 360, 5, 41, 0, 0, 360, 15, 1, 0, 0, 0, 361, 362, 5, 123, 0, 0, 362, 363, 6, 7, 1, 0, 363, 17, 1, 0, 0, 0, 364, 365, 4, 8, 1, 0, 365, 366, 5, 125, 0, 0, 366, 367, 1, 0, 0, 0, 367, 368, 6, 8, 2, 0, 368, 19, 1, 0, 0, 0, 369, 370, 5, 125, 0, 0, 370, 371, 6, 9, 3, 0, 371, 21, 1, 0, 0, 0, 372, 373, 5, 59, 0, 0, 373, 23, 1, 0, 0, 0, 374, 375, 5, 44, 0, 0, 375, 25, 1, 0, 0, 0, 376, 377, 5, 61, 0, 0, 377, 27, 1, 0, 0, 0, 378, 379, 5, 63, 0, 0, 379, 29, 1, 0, 0, 0, 380, 381, 5, 58, 0, 0, 381, 31, 1, 0, 0, 0, 382, 383, 5, 46, 0, 0, 383, 384, 5, 46, 0, 0, 384, 385, 5, 46, 0, 0, 385, 33, 1, 0, 0, 0, 386, 387, 5, 46, 0, 0, 387, 35, 1, 0, 0, 0, 388, 389, 5, 43, 0, 0, 389, 390, 5, 43, 0, 0, 390, 37, 1, 0, 0, 0, 391, 392, 5, 45, 0, 0, 392, 393, 5, 45, 0, 0, 393, 39, 1, 0, 0, 0, 394, 395, 5, 43, 0, 0, 395, 41, 1, 0, 0, 0, 396, 397, 5, 45, 0, 0, 397, 43, 1, 0, 0, 0, 398, 399, 5, 126, 0, 0, 399, 45, 1, 0, 0, 0, 400, 401, 5, 33, 0, 0, 401, 47, 1, 0, 0, 0, 402, 403, 5, 42, 0, 0, 403, 49, 1, 0, 0, 0, 404, 405, 5, 47, 0, 0, 405, 51, 1, 0, 0, 0, 406, 407, 5, 37, 0, 0, 407, 53, 1, 0, 0, 0, 408, 409, 5, 62, 0, 0, 409, 410, 5, 62, 0, 0, 410, 55, 1, 0, 0, 0, 411, 412, 5, 60, 0, 0, 412, 413, 5, 60, 0, 0, 413, 57, 1, 0, 0, 0, 414, 415, 5, 62, 0, 0, 415, 416, 5, 62, 0, 0, 416, 417, 5, 62, 0, 0, 417, 59, 1, 0, 0, 0, 418, 419, 5, 60, 0, 0, 419, 61, 1, 0, 0, 0, 420, 421, 5, 62, 0, 0, 421, 63, 1, 0, 0, 0, 422, 423, 5, 60, 0, 0, 423, 424, 5, 61, 0, 0, 424, 65, 1, 0, 0, 0, 425, 426, 5, 62, 0, 0, 426, 427, 5, 61, 0, 0, 427, 67, 1, 0, 0, 0, 428, 429, 5, 61, 0, 0, 429, 430, 5, 61, 0, 0, 430, 69, 1, 0, 0, 0, 431, 432, 5, 33, 0, 0, 432, 433, 5, 61, 0, 0, 433, 71, 1, 0, 0, 0, 434, 435, 5, 61, 0, 0, 435, 436, 5, 61, 0, 0, 436, 437, 5, 61, 0, 0, 437, 73, 1, 0, 0, 0, 438, 439, 5, 33, 0, 0, 439, 440, 5, 61, 0, 0, 440, 441, 5, 61, 0, 0, 441, 75, 1, 0, 0, 0, 442, 443, 5, 38, 0, 0, 443, 77, 1, 0, 0, 0, 444, 445, 5, 94, 0, 0, 445, 79, 1, 0, 0, 0, 446, 447, 5, 124, 0, 0, 447, 81, 1, 0, 0, 0, 448, 449, 5, 38, 0, 0, 449, 450, 5, 38, 0, 0, 450, 83, 1, 0, 0, 0, 451, 452, 5, 124, 0, 0, 452, 453, 5, 124, 0, 0, 453, 85, 1, 0, 0, 0, 454, 455, 5, 42, 0, 0, 455, 456, 5, 61, 0, 0, 456, 87, 1, 0, 0, 0, 457, 458, 5, 47, 0, 0, 458, 459, 5, 61, 0, 0, 459, 89, 1, 0, 0, 0, 460, 461, 5, 37, 0, 0, 461, 462, 5, 61, 0, 0, 462, 91, 1, 0, 0, 0, 463, 464, 5, 43, 0, 0, 464, 465, 5, 61, 0, 0, 465, 93, 1, 0, 0, 0, 466, 467, 5, 45, 0, 0, 467, 468, 5, 61, 0, 0, 468, 95, 1, 0, 0, 0, 469, 470, 5, 60, 0, 0, 470, 471, 5, 60, 0, 0, 471, 472, 5, 61, 0, 0, 472, 97, 1, 0, 0, 0, 473, 474, 5, 62, 0, 0, 474, 475, 5, 62, 0, 0, 475, 476, 5, 61, 0, 0, 476, 99, 1, 0, 0, 0, 477, 478, 5, 62, 0, 0, 478, 479, 5, 62, 0, 0, 479, 480, 5, 62, 0, 0, 480, 481, 5, 61, 0, 0, 481, 101, 1, 0, 0, 0, 482, 483, 5, 38, 0, 0, 483, 484, 5, 61, 0, 0, 484, 103, 1, 0, 0, 0, 485, 486, 5, 94, 0, 0, 486, 487, 5, 61, 0, 0, 487, 105, 1, 0, 0, 0, 488, 489, 5, 124, 0, 0, 489, 490, 5, 61, 0, 0, 490, 107, 1, 0, 0, 0, 491, 492, 5, 61, 0, 0, 492, 493, 5, 62, 0, 0, 493, 109, 1, 0, 0, 0, 494, 495, 5, 110, 0, 0, 495, 496, 5, 117, 0, 0, 496, 497, 5, 108, 0, 0, 497, 498, 5, 108, 0, 0, 498, 111, 1, 0, 0, 0, 499, 500, 5, 116, 0, 0, 500, 501, 5, 114, 0, 0, 501, 502, 5, 117, 0, 0, 502, 509, 5, 101, 0, 0, 503, 504, 5, 102, 0, 0, 504, 505, 5, 97, 0, 0, 505, 506, 5, 108, 0, 0, 506, 507, 5, 115, 0, 0, 507, 509, 5, 101, 0, 0, 508, 499, 1, 0, 0, 0, 508, 503, 1, 0, 0, 0, 509, 113, 1, 0, 0, 0, 510, 511, 3, 296, 147, 0, 511, 515, 5, 46, 0, 0, 512, 514, 7, 1, 0, 0, 513, 512, 1, 0, 0, 0, 514, 517, 1, 0, 0, 0, 515, 513, 1, 0, 0, 0, 515, 516, 1, 0, 0, 0, 516, 519, 1, 0, 0, 0, 517, 515, 1, 0, 0, 0, 518, 520, 3, 298, 148, 0, 519, 518, 1, 0, 0, 0, 519, 520, 1, 0, 0, 0, 520, 535, 1, 0, 0, 0, 521, 523, 5, 46, 0, 0, 522, 524, 7, 1, 0, 0, 523, 522, 1, 0, 0, 0, 524, 525, 1, 0, 0, 0, 525, 523, 1, 0, 0, 0, 525, 526, 1, 0, 0, 0, 526, 528, 1, 0, 0, 0, 527, 529, 3, 298, 148, 0, 528, 527, 1, 0, 0, 0, 528, 529, 1, 0, 0, 0, 529, 535, 1, 0, 0, 0, 530, 532, 3, 296, 147, 0, 531, 533, 3, 298, 148, 0, 532, 531, 1, 0, 0, 0, 532, 533, 1, 0, 0, 0, 533, 535, 1, 0, 0, 0, 534, 510, 1, 0, 0, 0, 534, 521, 1, 0, 0, 0, 534, 530, 1, 0, 0, 0, 535, 115, 1, 0, 0, 0, 536, 537, 5, 48, 0, 0, 537, 539, 7, 2, 0, 0, 538, 540, 3, 294, 146, 0, 539, 538, 1, 0, 0, 0, 540, 541, 1, 0, 0, 0, 541, 539, 1, 0, 0, 0, 541, 542, 1, 0, 0, 0, 542, 117, 1, 0, 0, 0, 543, 545, 5, 48, 0, 0, 544, 546, 7, 3, 0, 0, 545, 544, 1, 0, 0, 0, 546, 547, 1, 0, 0, 0, 547, 545, 1, 0, 0, 0, 547, 548, 1, 0, 0, 0, 548, 549, 1, 0, 0, 0, 549, 550, 4, 58, 2, 0, 550, 119, 1, 0, 0, 0, 551, 552, 5, 48, 0, 0, 552, 554, 7, 4, 0, 0, 553, 555, 7, 3, 0, 0, 554, 553, 1, 0, 0, 0, 555, 556, 1, 0, 0, 0, 556, 554, 1, 0, 0, 0, 556, 557, 1, 0, 0, 0, 557, 121, 1, 0, 0, 0, 558, 559, 5, 48, 0, 0, 559, 561, 7, 5, 0, 0, 560, 562, 7, 6, 0, 0, 561, 560, 1, 0, 0, 0, 562, 563, 1, 0, 0, 0, 563, 561, 1, 0, 0, 0, 563, 564, 1, 0, 0, 0, 564, 123, 1, 0, 0, 0, 565, 566, 5, 98, 0, 0, 566, 567, 5, 114, 0, 0, 567, 568, 5, 101, 0, 0, 568, 569, 5, 97, 0, 0, 569, 570, 5, 107, 0, 0, 570, 125, 1, 0, 0, 0, 571, 572, 5, 100, 0, 0, 572, 573, 5, 111, 0, 0, 573, 127, 1, 0, 0, 0, 574, 575, 5, 105, 0, 0, 575, 576, 5, 110, 0, 0, 576, 577, 5, 115, 0, 0, 577, 578, 5, 116, 0, 0, 578, 579, 5, 97, 0, 0, 579, 580, 5, 110, 0, 0, 580, 581, 5, 99, 0, 0, 581, 582, 5, 101, 0, 0, 582, 583, 5, 111, 0, 0, 583, 584, 5, 102, 0, 0, 584, 129, 1, 0, 0, 0, 585, 586, 5, 116, 0, 0, 586, 587, 5, 121, 0, 0, 587, 588, 5, 112, 0, 0, 588, 589, 5, 101, 0, 0, 589, 590, 5, 111, 0, 0, 590, 591, 5, 102, 0, 0, 591, 131, 1, 0, 0, 0, 592, 593, 5, 99, 0, 0, 593, 594, 5, 97, 0, 0, 594, 595, 5, 115, 0, 0, 595, 596, 5, 101, 0, 0, 596, 133, 1, 0, 0, 0, 597, 598, 5, 101, 0, 0, 598, 599, 5, 108, 0, 0, 599, 600, 5, 115, 0, 0, 600, 601, 5, 101, 0, 0, 601, 135, 1, 0, 0, 0, 602, 603, 5, 110, 0, 0, 603, 604, 5, 101, 0, 0, 604, 605, 5, 119, 0, 0, 605, 137, 1, 0, 0, 0, 606, 607, 5, 118, 0, 0, 607, 608, 5, 97, 0, 0, 608, 609, 5, 114, 0, 0, 609, 139, 1, 0, 0, 0, 610, 611, 5, 99, 0, 0, 611, 612, 5, 97, 0, 0, 612, 613, 5, 116, 0, 0, 613, 614, 5, 99, 0, 0, 614, 615, 5, 104, 0, 0, 615, 141, 1, 0, 0, 0, 616, 617, 5, 102, 0, 0, 617, 618, 5, 105, 0, 0, 618, 619, 5, 110, 0, 0, 619, 620, 5, 97, 0, 0, 620, 621, 5, 108, 0, 0, 621, 622, 5, 108, 0, 0, 622, 623, 5, 121, 0, 0, 623, 143, 1, 0, 0, 0, 624, 625, 5, 114, 0, 0, 625, 626, 5, 101, 0, 0, 626, 627, 5, 116, 0, 0, 627, 628, 5, 117, 0, 0, 628, 629, 5, 114, 0, 0, 629, 630, 5, 110, 0, 0, 630, 145, 1, 0, 0, 0, 631, 632, 5, 118, 0, 0, 632, 633, 5, 111, 0, 0, 633, 634, 5, 105, 0, 0, 634, 635, 5, 100, 0, 0, 635, 147, 1, 0, 0, 0, 636, 637, 5, 99, 0, 0, 637, 638, 5, 111, 0, 0, 638, 639, 5, 110, 0, 0, 639, 640, 5, 116, 0, 0, 640, 641, 5, 105, 0, 0, 641, 642, 5, 110, 0, 0, 642, 643, 5, 117, 0, 0, 643, 644, 5, 101, 0, 0, 644, 149, 1, 0, 0, 0, 645, 646, 5, 102, 0, 0, 646, 647, 5, 111, 0, 0, 647, 648, 5, 114, 0, 0, 648, 151, 1, 0, 0, 0, 649, 650, 5, 115, 0, 0, 650, 651, 5, 119, 0, 0, 651, 652, 5, 105, 0, 0, 652, 653, 5, 116, 0, 0, 653, 654, 5, 99, 0, 0, 654, 655, 5, 104, 0, 0, 655, 153, 1, 0, 0, 0, 656, 657, 5, 119, 0, 0, 657, 658, 5, 104, 0, 0, 658, 659, 5, 105, 0, 0, 659, 660, 5, 108, 0, 0, 660, 661, 5, 101, 0, 0, 661, 155, 1, 0, 0, 0, 662, 663, 5, 100, 0, 0, 663, 664, 5, 101, 0, 0, 664, 665, 5, 98, 0, 0, 665, 666, 5, 117, 0, 0, 666, 667, 5, 103, 0, 0, 667, 668, 5, 103, 0, 0, 668, 669, 5, 101, 0, 0, 669, 670, 5, 114, 0, 0, 670, 157, 1, 0, 0, 0, 671, 672, 5, 102, 0, 0, 672, 673, 5, 117, 0, 0, 673, 674, 5, 110, 0, 0, 674, 675, 5, 99, 0, 0, 675, 676, 5, 116, 0, 0, 676, 677, 5, 105, 0, 0, 677, 678, 5, 111, 0, 0, 678, 679, 5, 110, 0, 0, 679, 159, 1, 0, 0, 0, 680, 681, 5, 116, 0, 0, 681, 682, 5, 104, 0, 0, 682, 683, 5, 105, 0, 0, 683, 684, 5, 115, 0, 0, 684, 161, 1, 0, 0, 0, 685, 686, 5, 119, 0, 0, 686, 687, 5, 105, 0, 0, 687, 688, 5, 116, 0, 0, 688, 689, 5, 104, 0, 0, 689, 163, 1, 0, 0, 0, 690, 691, 5, 100, 0, 0, 691, 692, 5, 101, 0, 0, 692, 693, 5, 102, 0, 0, 693, 694, 5, 97, 0, 0, 694, 695, 5, 117, 0, 0, 695, 696, 5, 108, 0, 0, 696, 697, 5, 116, 0, 0, 697, 165, 1, 0, 0, 0, 698, 699, 5, 105, 0, 0, 699, 700, 5, 102, 0, 0, 700, 167, 1, 0, 0, 0, 701, 702, 5, 116, 0, 0, 702, 703, 5, 104, 0, 0, 703, 704, 5, 114, 0, 0, 704, 705, 5, 111, 0, 0, 705, 706, 5, 119, 0, 0, 706, 169, 1, 0, 0, 0, 707, 708, 5, 100, 0, 0, 708, 709, 5, 101, 0, 0, 709, 710, 5, 108, 0, 0, 710, 711, 5, 101, 0, 0, 711, 712, 5, 116, 0, 0, 712, 713, 5, 101, 0, 0, 713, 171, 1, 0, 0, 0, 714, 715, 5, 105, 0, 0, 715, 716, 5, 110, 0, 0, 716, 173, 1, 0, 0, 0, 717, 718, 5, 116, 0, 0, 718, 719, 5, 114, 0, 0, 719, 720, 5, 121, 0, 0, 720, 175, 1, 0, 0, 0, 721, 722, 5, 97, 0, 0, 722, 723, 5, 115, 0, 0, 723, 177, 1, 0, 0, 0, 724, 725, 5, 102, 0, 0, 725, 726, 5, 114, 0, 0, 726, 727, 5, 111, 0, 0, 727, 728, 5, 109, 0, 0, 728, 179, 1, 0, 0, 0, 729, 730, 5, 114, 0, 0, 730, 731, 5, 101, 0, 0, 731, 732, 5, 97, 0, 0, 732, 733, 5, 100, 0, 0, 733, 734, 5, 111, 0, 0, 734, 735, 5, 110, 0, 0, 735, 736, 5, 108, 0, 0, 736, 737, 5, 121, 0, 0, 737, 181, 1, 0, 0, 0, 738, 739, 5, 97, 0, 0, 739, 740, 5, 115, 0, 0, 740, 741, 5, 121, 0, 0, 741, 742, 5, 110, 0, 0, 742, 743, 5, 99, 0, 0, 743, 183, 1, 0, 0, 0, 744, 745, 5, 99, 0, 0, 745, 746, 5, 108, 0, 0, 746, 747, 5, 97, 0, 0, 747, 748, 5, 115, 0, 0, 748, 749, 5, 115, 0, 0, 749, 185, 1, 0, 0, 0, 750, 751, 5, 101, 0, 0, 751, 752, 5, 110, 0, 0, 752, 753, 5, 117, 0, 0, 753, 754, 5, 109, 0, 0, 754, 187, 1, 0, 0, 0, 755, 756, 5, 101, 0, 0, 756, 757, 5, 120, 0, 0, 757, 758, 5, 116, 0, 0, 758, 759, 5, 101, 0, 0, 759, 760, 5, 110, 0, 0, 760, 761, 5, 100, 0, 0, 761, 762, 5, 115, 0, 0, 762, 189, 1, 0, 0, 0, 763, 764, 5, 115, 0, 0, 764, 765, 5, 117, 0, 0, 765, 766, 5, 112, 0, 0, 766, 767, 5, 101, 0, 0, 767, 768, 5, 114, 0, 0, 768, 191, 1, 0, 0, 0, 769, 770, 5, 99, 0, 0, 770, 771, 5, 111, 0, 0, 771, 772, 5, 110, 0, 0, 772, 773, 5, 115, 0, 0, 773, 774, 5, 116, 0, 0, 774, 193, 1, 0, 0, 0, 775, 776, 5, 101, 0, 0, 776, 777, 5, 120, 0, 0, 777, 778, 5, 112, 0, 0, 778, 779, 5, 111, 0, 0, 779, 780, 5, 114, 0, 0, 780, 781, 5, 116, 0, 0, 781, 195, 1, 0, 0, 0, 782, 783, 5, 105, 0, 0, 783, 784, 5, 109, 0, 0, 784, 785, 5, 112, 0, 0, 785, 786, 5, 111, 0, 0, 786, 787, 5, 114, 0, 0, 787, 788, 5, 116, 0, 0, 788, 197, 1, 0, 0, 0, 789, 790, 5, 105, 0, 0, 790, 791, 5, 109, 0, 0, 791, 792, 5, 112, 0, 0, 792, 793, 5, 108, 0, 0, 793, 794, 5, 101, 0, 0, 794, 795, 5, 109, 0, 0, 795, 796, 5, 101, 0, 0, 796, 797, 5, 110, 0, 0, 797, 798, 5, 116, 0, 0, 798, 799, 5, 115, 0, 0, 799, 199, 1, 0, 0, 0, 800, 801, 5, 108, 0, 0, 801, 802, 5, 101, 0, 0, 802, 803, 5, 116, 0, 0, 803, 201, 1, 0, 0, 0, 804, 805, 5, 112, 0, 0, 805, 806, 5, 114, 0, 0, 806, 807, 5, 105, 0, 0, 807, 808, 5, 118, 0, 0, 808, 809, 5, 97, 0, 0, 809, 810, 5, 116, 0, 0, 810, 811, 5, 101, 0, 0, 811, 203, 1, 0, 0, 0, 812, 813, 5, 112, 0, 0, 813, 814, 5, 117, 0, 0, 814, 815, 5, 98, 0, 0, 815, 816, 5, 108, 0, 0, 816, 817, 5, 105, 0, 0, 817, 818, 5, 99, 0, 0, 818, 205, 1, 0, 0, 0, 819, 820, 5, 105, 0, 0, 820, 821, 5, 110, 0, 0, 821, 822, 5, 116, 0, 0, 822, 823, 5, 101, 0, 0, 823, 824, 5, 114, 0, 0, 824, 825, 5, 102, 0, 0, 825, 826, 5, 97, 0, 0, 826, 827, 5, 99, 0, 0, 827, 828, 5, 101, 0, 0, 828, 207, 1, 0, 0, 0, 829, 830, 5, 112, 0, 0, 830, 831, 5, 97, 0, 0, 831, 832, 5, 99, 0, 0, 832, 833, 5, 107, 0, 0, 833, 834, 5, 97, 0, 0, 834, 835, 5, 103, 0, 0, 835, 836, 5, 101, 0, 0, 836, 209, 1, 0, 0, 0, 837, 838, 5, 112, 0, 0, 838, 839, 5, 114, 0, 0, 839, 840, 5, 111, 0, 0, 840, 841, 5, 116, 0, 0, 841, 842, 5, 101, 0, 0, 842, 843, 5, 99, 0, 0, 843, 844, 5, 116, 0, 0, 844, 845, 5, 101, 0, 0, 845, 846, 5, 100, 0, 0, 846, 211, 1, 0, 0, 0, 847, 848, 5, 115, 0, 0, 848, 849, 5, 116, 0, 0, 849, 850, 5, 97, 0, 0, 850, 851, 5, 116, 0, 0, 851, 852, 5, 105, 0, 0, 852, 853, 5, 99, 0, 0, 853, 213, 1, 0, 0, 0, 854, 855, 5, 121, 0, 0, 855, 856, 5, 105, 0, 0, 856, 857, 5, 101, 0, 0, 857, 858, 5, 108, 0, 0, 858, 859, 5, 100, 0, 0, 859, 215, 1, 0, 0, 0, 860, 861, 5, 97, 0, 0, 861, 862, 5, 110, 0, 0, 862, 863, 5, 121, 0, 0, 863, 217, 1, 0, 0, 0, 864, 865, 5, 110, 0, 0, 865, 866, 5, 117, 0, 0, 866, 867, 5, 109, 0, 0, 867, 868, 5, 98, 0, 0, 868, 869, 5, 101, 0, 0, 869, 870, 5, 114, 0, 0, 870, 219, 1, 0, 0, 0, 871, 872, 5, 98, 0, 0, 872, 873, 5, 111, 0, 0, 873, 874, 5, 111, 0, 0, 874, 875, 5, 108, 0, 0, 875, 876, 5, 101, 0, 0, 876, 877, 5, 97, 0, 0, 877, 878, 5, 110, 0, 0, 878, 221, 1, 0, 0, 0, 879, 880, 5, 115, 0, 0, 880, 881, 5, 116, 0, 0, 881, 882, 5, 114, 0, 0, 882, 883, 5, 105, 0, 0, 883, 884, 5, 110, 0, 0, 884, 885, 5, 103, 0, 0, 885, 223, 1, 0, 0, 0, 886, 887, 5, 115, 0, 0, 887, 888, 5, 121, 0, 0, 888, 889, 5, 109, 0, 0, 889, 890, 5, 98, 0, 0, 890, 891, 5, 111, 0, 0, 891, 892, 5, 108, 0, 0, 892, 225, 1, 0, 0, 0, 893, 894, 5, 116, 0, 0, 894, 895, 5, 121, 0, 0, 895, 896, 5, 112, 0, 0, 896, 897, 5, 101, 0, 0, 897, 227, 1, 0, 0, 0, 898, 899, 5, 103, 0, 0, 899, 900, 5, 101, 0, 0, 900, 901, 5, 116, 0, 0, 901, 229, 1, 0, 0, 0, 902, 903, 5, 115, 0, 0, 903, 904, 5, 101, 0, 0, 904, 905, 5, 116, 0, 0, 905, 231, 1, 0, 0, 0, 906, 907, 5, 99, 0, 0, 907, 908, 5, 111, 0, 0, 908, 909, 5, 110, 0, 0, 909, 910, 5, 115, 0, 0, 910, 911, 5, 116, 0, 0, 911, 912, 5, 114, 0, 0, 912, 913, 5, 117, 0, 0, 913, 914, 5, 99, 0, 0, 914, 915, 5, 116, 0, 0, 915, 916, 5, 111, 0, 0, 916, 917, 5, 114, 0, 0, 917, 233, 1, 0, 0, 0, 918, 919, 5, 110, 0, 0, 919, 920, 5, 97, 0, 0, 920, 921, 5, 109, 0, 0, 921, 922, 5, 101, 0, 0, 922, 923, 5, 115, 0, 0, 923, 924, 5, 112, 0, 0, 924, 925, 5, 97, 0, 0, 925, 926, 5, 99, 0, 0, 926, 927, 5, 101, 0, 0, 927, 235, 1, 0, 0, 0, 928, 929, 5, 114, 0, 0, 929, 930, 5, 101, 0, 0, 930, 931, 5, 113, 0, 0, 931, 932, 5, 117, 0, 0, 932, 933, 5, 105, 0, 0, 933, 934, 5, 114, 0, 0, 934, 935, 5, 101, 0, 0, 935, 237, 1, 0, 0, 0, 936, 937, 5, 109, 0, 0, 937, 938, 5, 111, 0, 0, 938, 939, 5, 100, 0, 0, 939, 940, 5, 117, 0, 0, 940, 941, 5, 108, 0, 0, 941, 942, 5, 101, 0, 0, 942, 239, 1, 0, 0, 0, 943, 944, 5, 100, 0, 0, 944, 945, 5, 101, 0, 0, 945, 946, 5, 99, 0, 0, 946, 947, 5, 108, 0, 0, 947, 948, 5, 97, 0, 0, 948, 949, 5, 114, 0, 0, 949, 950, 5, 101, 0, 0, 950, 241, 1, 0, 0, 0, 951, 952, 5, 97, 0, 0, 952, 953, 5, 98, 0, 0, 953, 954, 5, 115, 0, 0, 954, 955, 5, 116, 0, 0, 955, 956, 5, 114, 0, 0, 956, 957, 5, 97, 0, 0, 957, 958, 5, 99, 0, 0, 958, 959, 5, 116, 0, 0, 959, 243, 1, 0, 0, 0, 960, 961, 5, 105, 0, 0, 961, 962, 5, 115, 0, 0, 962, 245, 1, 0, 0, 0, 963, 964, 5, 64, 0, 0, 964, 247, 1, 0, 0, 0, 965, 969, 3, 302, 150, 0, 966, 968, 3, 300, 149, 0, 967, 966, 1, 0, 0, 0, 968, 971, 1, 0, 0, 0, 969, 967, 1, 0, 0, 0, 969, 970, 1, 0, 0, 0, 970, 249, 1, 0, 0, 0, 971, 969, 1, 0, 0, 0, 972, 976, 5, 34, 0, 0, 973, 975, 3, 272, 135, 0, 974, 973, 1, 0, 0, 0, 975, 978, 1, 0, 0, 0, 976, 974, 1, 0, 0, 0, 976, 977, 1, 0, 0, 0, 977, 979, 1, 0, 0, 0, 978, 976, 1, 0, 0, 0, 979, 989, 5, 34, 0, 0, 980, 984, 5, 39, 0, 0, 981, 983, 3, 274, 136, 0, 982, 981, 1, 0, 0, 0, 983, 986, 1, 0, 0, 0, 984, 982, 1, 0, 0, 0, 984, 985, 1, 0, 0, 0, 985, 987, 1, 0, 0, 0, 986, 984, 1, 0, 0, 0, 987, 989, 5, 39, 0, 0, 988, 972, 1, 0, 0, 0, 988, 980, 1, 0, 0, 0, 989, 990, 1, 0, 0, 0, 990, 991, 6, 124, 4, 0, 991, 251, 1, 0, 0, 0, 992, 993, 5, 96, 0, 0, 993, 994, 6, 125, 5, 0, 994, 995, 1, 0, 0, 0, 995, 996, 6, 125, 6, 0, 996, 253, 1, 0, 0, 0, 997, 999, 7, 7, 0, 0, 998, 997, 1, 0, 0, 0, 999, 1000, 1, 0, 0, 0, 1000, 998, 1, 0, 0, 0, 1000, 1001, 1, 0, 0, 0, 1001, 1002, 1, 0, 0, 0, 1002, 1003, 6, 126, 0, 0, 1003, 255, 1, 0, 0, 0, 1004, 1005, 7, 0, 0, 0, 1005, 1006, 1, 0, 0, 0, 1006, 1007, 6, 127, 0, 0, 1007, 257, 1, 0, 0, 0, 1008, 1009, 5, 60, 0, 0, 1009, 1010, 5, 33, 0, 0, 1010, 1011, 5, 45, 0, 0, 1011, 1012, 5, 45, 0, 0, 1012, 1016, 1, 0, 0, 0, 1013, 1015, 9, 0, 0, 0, 1014, 1013, 1, 0, 0, 0, 1015, 1018, 1, 0, 0, 0, 1016, 1017, 1, 0, 0, 0, 1016, 1014, 1, 0, 0, 0, 1017, 1019, 1, 0, 0, 0, 1018, 1016, 1, 0, 0, 0, 1019, 1020, 5, 45, 0, 0, 1020, 1021, 5, 45, 0, 0, 1021, 1022, 5, 62, 0, 0, 1022, 1023, 1, 0, 0, 0, 1023, 1024, 6, 128, 0, 0, 1024, 259, 1, 0, 0, 0, 1025, 1026, 5, 60, 0, 0, 1026, 1027, 5, 33, 0, 0, 1027, 1028, 5, 91, 0, 0, 1028, 1029, 5, 67, 0, 0, 1029, 1030, 5, 68, 0, 0, 1030, 1031, 5, 65, 0, 0, 1031, 1032, 5, 84, 0, 0, 1032, 1033, 5, 65, 0, 0, 1033, 1034, 5, 91, 0, 0, 1034, 1038, 1, 0, 0, 0, 1035, 1037, 9, 0, 0, 0, 1036, 1035, 1, 0, 0, 0, 1037, 1040, 1, 0, 0, 0, 1038, 1039, 1, 0, 0, 0, 1038, 1036, 1, 0, 0, 0, 1039, 1041, 1, 0, 0, 0, 1040, 1038, 1, 0, 0, 0, 1041, 1042, 5, 93, 0, 0, 1042, 1043, 5, 93, 0, 0, 1043, 1044, 5, 62, 0, 0, 1044, 1045, 1, 0, 0, 0, 1045, 1046, 6, 129, 0, 0, 1046, 261, 1, 0, 0, 0, 1047, 1048, 9, 0, 0, 0, 1048, 1049, 1, 0, 0, 0, 1049, 1050, 6, 130, 7, 0, 1050, 263, 1, 0, 0, 0, 1051, 1052, 5, 92, 0, 0, 1052, 1053, 9, 0, 0, 0, 1053, 265, 1, 0, 0, 0, 1054, 1055, 5, 96, 0, 0, 1055, 1056, 6, 132, 8, 0, 1056, 1057, 1, 0, 0, 0, 1057, 1058, 6, 132, 9, 0, 1058, 1059, 6, 132, 2, 0, 1059, 267, 1, 0, 0, 0, 1060, 1061, 5, 36, 0, 0, 1061, 1062, 5, 123, 0, 0, 1062, 1063, 1, 0, 0, 0, 1063, 1064, 6, 133, 10, 0, 1064, 1065, 1, 0, 0, 0, 1065, 1066, 6, 133, 11, 0, 1066, 269, 1, 0, 0, 0, 1067, 1068, 8, 8, 0, 0, 1068, 271, 1, 0, 0, 0, 1069, 1074, 8, 9, 0, 0, 1070, 1071, 5, 92, 0, 0, 1071, 1074, 3, 276, 137, 0, 1072, 1074, 3, 292, 145, 0, 1073, 1069, 1, 0, 0, 0, 1073, 1070, 1, 0, 0, 0, 1073, 1072, 1, 0, 0, 0, 1074, 273, 1, 0, 0, 0, 1075, 1080, 8, 10, 0, 0, 1076, 1077, 5, 92, 0, 0, 1077, 1080, 3, 276, 137, 0, 1078, 1080, 3, 292, 145, 0, 1079, 1075, 1, 0, 0, 0, 1079, 1076, 1, 0, 0, 0, 1079, 1078, 1, 0, 0, 0, 1080, 275, 1, 0, 0, 0, 1081, 1087, 3, 278, 138, 0, 1082, 1087, 5, 48, 0, 0, 1083, 1087, 3, 280, 139, 0, 1084, 1087, 3, 282, 140, 0, 1085, 1087, 3, 284, 141, 0, 1086, 1081, 1, 0, 0, 0, 1086, 1082, 1, 0, 0, 0, 1086, 1083, 1, 0, 0, 0, 1086, 1084, 1, 0, 0, 0, 1086, 1085, 1, 0, 0, 0, 1087, 277, 1, 0, 0, 0, 1088, 1091, 3, 286, 142, 0, 1089, 1091, 3, 288, 143, 0, 1090, 1088, 1, 0, 0, 0, 1090, 1089, 1, 0, 0, 0, 1091, 279, 1, 0, 0, 0, 1092, 1093, 5, 120, 0, 0, 1093, 1094, 3, 294, 146, 0, 1094, 1095, 3, 294, 146, 0, 1095, 281, 1, 0, 0, 0, 1096, 1097, 5, 117, 0, 0, 1097, 1098, 3, 294, 146, 0, 1098, 1099, 3, 294, 146, 0, 1099, 1100, 3, 294, 146, 0, 1100, 1101, 3, 294, 146, 0, 1101, 283, 1, 0, 0, 0, 1102, 1103, 5, 117, 0, 0, 1103, 1105, 5, 123, 0, 0, 1104, 1106, 3, 294, 146, 0, 1105, 1104, 1, 0, 0, 0, 1106, 1107, 1, 0, 0, 0, 1107, 1105, 1, 0, 0, 0, 1107, 1108, 1, 0, 0, 0, 1108, 1109, 1, 0, 0, 0, 1109, 1110, 5, 125, 0, 0, 1110, 285, 1, 0, 0, 0, 1111, 1112, 7, 11, 0, 0, 1112, 287, 1, 0, 0, 0, 1113, 1114, 8, 12, 0, 0, 1114, 289, 1, 0, 0, 0, 1115, 1118, 3, 286, 142, 0, 1116, 1118, 7, 13, 0, 0, 1117, 1115, 1, 0, 0, 0, 1117, 1116, 1, 0, 0, 0, 1118, 291, 1, 0, 0, 0, 1119, 1120, 5, 92, 0, 0, 1120, 1121, 7, 0, 0, 0, 1121, 293, 1, 0, 0, 0, 1122, 1123, 7, 14, 0, 0, 1123, 295, 1, 0, 0, 0, 1124, 1133, 5, 48, 0, 0, 1125, 1129, 7, 15, 0, 0, 1126, 1128, 7, 1, 0, 0, 1127, 1126, 1, 0, 0, 0, 1128, 1131, 1, 0, 0, 0, 1129, 1127, 1, 0, 0, 0, 1129, 1130, 1, 0, 0, 0, 1130, 1133, 1, 0, 0, 0, 1131, 1129, 1, 0, 0, 0, 1132, 1124, 1, 0, 0, 0, 1132, 1125, 1, 0, 0, 0, 1133, 297, 1, 0, 0, 0, 1134, 1136, 7, 16, 0, 0, 1135, 1137, 7, 17, 0, 0, 1136, 1135, 1, 0, 0, 0, 1136, 1137, 1, 0, 0, 0, 1137, 1139, 1, 0, 0, 0, 1138, 1140, 7, 1, 0, 0, 1139, 1138, 1, 0, 0, 0, 1140, 1141, 1, 0, 0, 0, 1141, 1139, 1, 0, 0, 0, 1141, 1142, 1, 0, 0, 0, 1142, 299, 1, 0, 0, 0, 1143, 1146, 3, 302, 150, 0, 1144, 1146, 7, 18, 0, 0, 1145, 1143, 1, 0, 0, 0, 1145, 1144, 1, 0, 0, 0, 1146, 301, 1, 0, 0, 0, 1147, 1151, 7, 19, 0, 0, 1148, 1149, 5, 92, 0, 0, 1149, 1151, 3, 282, 140, 0, 1150, 1147, 1, 0, 0, 0, 1150, 1148, 1, 0, 0, 0, 1151, 303, 1, 0, 0, 0, 1152, 1163, 8, 20, 0, 0, 1153, 1163, 3, 310, 154, 0, 1154, 1158, 5, 91, 0, 0, 1155, 1157, 3, 308, 153, 0, 1156, 1155, 1, 0, 0, 0, 1157, 1160, 1, 0, 0, 0, 1158, 1156, 1, 0, 0, 0, 1158, 1159, 1, 0, 0, 0, 1159, 1161, 1, 0, 0, 0, 1160, 1158, 1, 0, 0, 0, 1161, 1163, 5, 93, 0, 0, 1162, 1152, 1, 0, 0, 0, 1162, 1153, 1, 0, 0, 0, 1162, 1154, 1, 0, 0, 0, 1163, 305, 1, 0, 0, 0, 1164, 1175, 8, 21, 0, 0, 1165, 1175, 3, 310, 154, 0, 1166, 1170, 5, 91, 0, 0, 1167, 1169, 3, 308, 153, 0, 1168, 1167, 1, 0, 0, 0, 1169, 1172, 1, 0, 0, 0, 1170, 1168, 1, 0, 0, 0, 1170, 1171, 1, 0, 0, 0, 1171, 1173, 1, 0, 0, 0, 1172, 1170, 1, 0, 0, 0, 1173, 1175, 5, 93, 0, 0, 1174, 1164, 1, 0, 0, 0, 1174, 1165, 1, 0, 0, 0, 1174, 1166, 1, 0, 0, 0, 1175, 307, 1, 0, 0, 0, 1176, 1179, 8, 22, 0, 0, 1177, 1179, 3, 310, 154, 0, 1178, 1176, 1, 0, 0, 0, 1178, 1177, 1, 0, 0, 0, 1179, 309, 1, 0, 0, 0, 1180, 1181, 5, 92, 0, 0, 1181, 1182, 8, 0, 0, 0, 1182, 311, 1, 0, 0, 0, 41, 0, 1, 318, 332, 342, 350, 508, 515, 519, 525, 528, 532, 534, 541, 547, 556, 563, 969, 976, 984, 988, 1000, 1016, 1038, 1073, 1079, 1086, 1090, 1107, 1117, 1129, 1132, 1136, 1141, 1145, 1150, 1158, 1162, 1170, 1174, 1178, 12, 0, 1, 0, 1, 7, 0, 4, 0, 0, 1, 9, 1, 1, 124, 2, 1, 125, 3, 5, 1, 0, 0, 2, 0, 1, 132, 4, 7, 126, 0, 1, 133, 5, 5, 0, 0]
\ No newline at end of file
diff --git a/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptLexer.java b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptLexer.java
new file mode 100644
index 0000000..1c8bb39
--- /dev/null
+++ b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptLexer.java
@@ -0,0 +1,1309 @@
+// Generated from /www/p_java/babylon/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptLexer.g4 by ANTLR 4.13.1
+package one.edee.babylon.export.ts.gen;
+import one.edee.babylon.export.ts.TypeScriptLexerBase;
+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", "CheckReturnValue", "this-escape"})
+public class TypeScriptLexer extends TypeScriptLexerBase {
+ static { RuntimeMetaData.checkVersion("4.13.1", RuntimeMetaData.VERSION); }
+
+ protected static final DFA[] _decisionToDFA;
+ protected static final PredictionContextCache _sharedContextCache =
+ new PredictionContextCache();
+ public static final int
+ MultiLineComment=1, SingleLineComment=2, RegularExpressionLiteral=3, OpenBracket=4,
+ CloseBracket=5, OpenParen=6, CloseParen=7, OpenBrace=8, TemplateCloseBrace=9,
+ CloseBrace=10, SemiColon=11, Comma=12, Assign=13, QuestionMark=14, Colon=15,
+ Ellipsis=16, Dot=17, PlusPlus=18, MinusMinus=19, Plus=20, Minus=21, BitNot=22,
+ Not=23, Multiply=24, Divide=25, Modulus=26, RightShiftArithmetic=27, LeftShiftArithmetic=28,
+ RightShiftLogical=29, LessThan=30, MoreThan=31, LessThanEquals=32, GreaterThanEquals=33,
+ Equals_=34, NotEquals=35, IdentityEquals=36, IdentityNotEquals=37, BitAnd=38,
+ BitXOr=39, BitOr=40, And=41, Or=42, MultiplyAssign=43, DivideAssign=44,
+ ModulusAssign=45, PlusAssign=46, MinusAssign=47, LeftShiftArithmeticAssign=48,
+ RightShiftArithmeticAssign=49, RightShiftLogicalAssign=50, BitAndAssign=51,
+ BitXorAssign=52, BitOrAssign=53, ARROW=54, NullLiteral=55, BooleanLiteral=56,
+ DecimalLiteral=57, HexIntegerLiteral=58, OctalIntegerLiteral=59, OctalIntegerLiteral2=60,
+ BinaryIntegerLiteral=61, Break=62, Do=63, Instanceof=64, Typeof=65, Case=66,
+ Else=67, New=68, Var=69, Catch=70, Finally=71, Return=72, Void=73, Continue=74,
+ For=75, Switch=76, While=77, Debugger=78, Function_=79, This=80, With=81,
+ Default=82, If=83, Throw=84, Delete=85, In=86, Try=87, As=88, From=89,
+ ReadOnly=90, Async=91, Class=92, Enum=93, Extends=94, Super=95, Const=96,
+ Export=97, Import=98, Implements=99, Let=100, Private=101, Public=102,
+ Interface=103, Package=104, Protected=105, Static=106, Yield=107, Any=108,
+ Number=109, Boolean=110, String=111, Symbol=112, TypeAlias=113, Get=114,
+ Set=115, Constructor=116, Namespace=117, Require=118, Module=119, Declare=120,
+ Abstract=121, Is=122, At=123, Identifier=124, StringLiteral=125, BackTick=126,
+ WhiteSpaces=127, LineTerminator=128, HtmlComment=129, CDataComment=130,
+ UnexpectedCharacter=131, TemplateStringEscapeAtom=132, TemplateStringStartExpression=133,
+ TemplateStringAtom=134;
+ public static final int
+ ERROR=2;
+ public static final int
+ TEMPLATE=1;
+ public static String[] channelNames = {
+ "DEFAULT_TOKEN_CHANNEL", "HIDDEN", "ERROR"
+ };
+
+ public static String[] modeNames = {
+ "DEFAULT_MODE", "TEMPLATE"
+ };
+
+ private static String[] makeRuleNames() {
+ return new String[] {
+ "MultiLineComment", "SingleLineComment", "RegularExpressionLiteral",
+ "OpenBracket", "CloseBracket", "OpenParen", "CloseParen", "OpenBrace",
+ "TemplateCloseBrace", "CloseBrace", "SemiColon", "Comma", "Assign", "QuestionMark",
+ "Colon", "Ellipsis", "Dot", "PlusPlus", "MinusMinus", "Plus", "Minus",
+ "BitNot", "Not", "Multiply", "Divide", "Modulus", "RightShiftArithmetic",
+ "LeftShiftArithmetic", "RightShiftLogical", "LessThan", "MoreThan", "LessThanEquals",
+ "GreaterThanEquals", "Equals_", "NotEquals", "IdentityEquals", "IdentityNotEquals",
+ "BitAnd", "BitXOr", "BitOr", "And", "Or", "MultiplyAssign", "DivideAssign",
+ "ModulusAssign", "PlusAssign", "MinusAssign", "LeftShiftArithmeticAssign",
+ "RightShiftArithmeticAssign", "RightShiftLogicalAssign", "BitAndAssign",
+ "BitXorAssign", "BitOrAssign", "ARROW", "NullLiteral", "BooleanLiteral",
+ "DecimalLiteral", "HexIntegerLiteral", "OctalIntegerLiteral", "OctalIntegerLiteral2",
+ "BinaryIntegerLiteral", "Break", "Do", "Instanceof", "Typeof", "Case",
+ "Else", "New", "Var", "Catch", "Finally", "Return", "Void", "Continue",
+ "For", "Switch", "While", "Debugger", "Function_", "This", "With", "Default",
+ "If", "Throw", "Delete", "In", "Try", "As", "From", "ReadOnly", "Async",
+ "Class", "Enum", "Extends", "Super", "Const", "Export", "Import", "Implements",
+ "Let", "Private", "Public", "Interface", "Package", "Protected", "Static",
+ "Yield", "Any", "Number", "Boolean", "String", "Symbol", "TypeAlias",
+ "Get", "Set", "Constructor", "Namespace", "Require", "Module", "Declare",
+ "Abstract", "Is", "At", "Identifier", "StringLiteral", "BackTick", "WhiteSpaces",
+ "LineTerminator", "HtmlComment", "CDataComment", "UnexpectedCharacter",
+ "TemplateStringEscapeAtom", "BackTickInside", "TemplateStringStartExpression",
+ "TemplateStringAtom", "DoubleStringCharacter", "SingleStringCharacter",
+ "EscapeSequence", "CharacterEscapeSequence", "HexEscapeSequence", "UnicodeEscapeSequence",
+ "ExtendedUnicodeEscapeSequence", "SingleEscapeCharacter", "NonEscapeCharacter",
+ "EscapeCharacter", "LineContinuation", "HexDigit", "DecimalIntegerLiteral",
+ "ExponentPart", "IdentifierPart", "IdentifierStart", "RegularExpressionFirstChar",
+ "RegularExpressionChar", "RegularExpressionClassChar", "RegularExpressionBackslashSequence"
+ };
+ }
+ public static final String[] ruleNames = makeRuleNames();
+
+ private static String[] makeLiteralNames() {
+ return new String[] {
+ null, null, null, null, "'['", "']'", "'('", "')'", "'{'", null, "'}'",
+ "';'", "','", "'='", "'?'", "':'", "'...'", "'.'", "'++'", "'--'", "'+'",
+ "'-'", "'~'", "'!'", "'*'", "'/'", "'%'", "'>>'", "'<<'", "'>>>'", "'<'",
+ "'>'", "'<='", "'>='", "'=='", "'!='", "'==='", "'!=='", "'&'", "'^'",
+ "'|'", "'&&'", "'||'", "'*='", "'/='", "'%='", "'+='", "'-='", "'<<='",
+ "'>>='", "'>>>='", "'&='", "'^='", "'|='", "'=>'", "'null'", null, null,
+ null, null, null, null, "'break'", "'do'", "'instanceof'", "'typeof'",
+ "'case'", "'else'", "'new'", "'var'", "'catch'", "'finally'", "'return'",
+ "'void'", "'continue'", "'for'", "'switch'", "'while'", "'debugger'",
+ "'function'", "'this'", "'with'", "'default'", "'if'", "'throw'", "'delete'",
+ "'in'", "'try'", "'as'", "'from'", "'readonly'", "'async'", "'class'",
+ "'enum'", "'extends'", "'super'", "'const'", "'export'", "'import'",
+ "'implements'", "'let'", "'private'", "'public'", "'interface'", "'package'",
+ "'protected'", "'static'", "'yield'", "'any'", "'number'", "'boolean'",
+ "'string'", "'symbol'", "'type'", "'get'", "'set'", "'constructor'",
+ "'namespace'", "'require'", "'module'", "'declare'", "'abstract'", "'is'",
+ "'@'"
+ };
+ }
+ private static final String[] _LITERAL_NAMES = makeLiteralNames();
+ private static String[] makeSymbolicNames() {
+ return new String[] {
+ null, "MultiLineComment", "SingleLineComment", "RegularExpressionLiteral",
+ "OpenBracket", "CloseBracket", "OpenParen", "CloseParen", "OpenBrace",
+ "TemplateCloseBrace", "CloseBrace", "SemiColon", "Comma", "Assign", "QuestionMark",
+ "Colon", "Ellipsis", "Dot", "PlusPlus", "MinusMinus", "Plus", "Minus",
+ "BitNot", "Not", "Multiply", "Divide", "Modulus", "RightShiftArithmetic",
+ "LeftShiftArithmetic", "RightShiftLogical", "LessThan", "MoreThan", "LessThanEquals",
+ "GreaterThanEquals", "Equals_", "NotEquals", "IdentityEquals", "IdentityNotEquals",
+ "BitAnd", "BitXOr", "BitOr", "And", "Or", "MultiplyAssign", "DivideAssign",
+ "ModulusAssign", "PlusAssign", "MinusAssign", "LeftShiftArithmeticAssign",
+ "RightShiftArithmeticAssign", "RightShiftLogicalAssign", "BitAndAssign",
+ "BitXorAssign", "BitOrAssign", "ARROW", "NullLiteral", "BooleanLiteral",
+ "DecimalLiteral", "HexIntegerLiteral", "OctalIntegerLiteral", "OctalIntegerLiteral2",
+ "BinaryIntegerLiteral", "Break", "Do", "Instanceof", "Typeof", "Case",
+ "Else", "New", "Var", "Catch", "Finally", "Return", "Void", "Continue",
+ "For", "Switch", "While", "Debugger", "Function_", "This", "With", "Default",
+ "If", "Throw", "Delete", "In", "Try", "As", "From", "ReadOnly", "Async",
+ "Class", "Enum", "Extends", "Super", "Const", "Export", "Import", "Implements",
+ "Let", "Private", "Public", "Interface", "Package", "Protected", "Static",
+ "Yield", "Any", "Number", "Boolean", "String", "Symbol", "TypeAlias",
+ "Get", "Set", "Constructor", "Namespace", "Require", "Module", "Declare",
+ "Abstract", "Is", "At", "Identifier", "StringLiteral", "BackTick", "WhiteSpaces",
+ "LineTerminator", "HtmlComment", "CDataComment", "UnexpectedCharacter",
+ "TemplateStringEscapeAtom", "TemplateStringStartExpression", "TemplateStringAtom"
+ };
+ }
+ 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 TypeScriptLexer(CharStream input) {
+ super(input);
+ _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
+ }
+
+ @Override
+ public String getGrammarFileName() { return "TypeScriptLexer.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 7:
+ OpenBrace_action((RuleContext)_localctx, actionIndex);
+ break;
+ case 9:
+ CloseBrace_action((RuleContext)_localctx, actionIndex);
+ break;
+ case 124:
+ StringLiteral_action((RuleContext)_localctx, actionIndex);
+ break;
+ case 125:
+ BackTick_action((RuleContext)_localctx, actionIndex);
+ break;
+ case 132:
+ BackTickInside_action((RuleContext)_localctx, actionIndex);
+ break;
+ case 133:
+ TemplateStringStartExpression_action((RuleContext)_localctx, actionIndex);
+ break;
+ }
+ }
+ private void OpenBrace_action(RuleContext _localctx, int actionIndex) {
+ switch (actionIndex) {
+ case 0:
+ this.ProcessOpenBrace();
+ break;
+ }
+ }
+ private void CloseBrace_action(RuleContext _localctx, int actionIndex) {
+ switch (actionIndex) {
+ case 1:
+ this.ProcessCloseBrace();
+ break;
+ }
+ }
+ private void StringLiteral_action(RuleContext _localctx, int actionIndex) {
+ switch (actionIndex) {
+ case 2:
+ this.ProcessStringLiteral();
+ break;
+ }
+ }
+ private void BackTick_action(RuleContext _localctx, int actionIndex) {
+ switch (actionIndex) {
+ case 3:
+ this.IncreaseTemplateDepth();
+ break;
+ }
+ }
+ private void BackTickInside_action(RuleContext _localctx, int actionIndex) {
+ switch (actionIndex) {
+ case 4:
+ this.DecreaseTemplateDepth();
+ break;
+ }
+ }
+ private void TemplateStringStartExpression_action(RuleContext _localctx, int actionIndex) {
+ switch (actionIndex) {
+ case 5:
+ this.StartTemplateString();
+ break;
+ }
+ }
+ @Override
+ public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
+ switch (ruleIndex) {
+ case 2:
+ return RegularExpressionLiteral_sempred((RuleContext)_localctx, predIndex);
+ case 8:
+ return TemplateCloseBrace_sempred((RuleContext)_localctx, predIndex);
+ case 58:
+ return OctalIntegerLiteral_sempred((RuleContext)_localctx, predIndex);
+ }
+ return true;
+ }
+ private boolean RegularExpressionLiteral_sempred(RuleContext _localctx, int predIndex) {
+ switch (predIndex) {
+ case 0:
+ return this.IsRegexPossible();
+ }
+ return true;
+ }
+ private boolean TemplateCloseBrace_sempred(RuleContext _localctx, int predIndex) {
+ switch (predIndex) {
+ case 1:
+ return this.IsInTemplateString();
+ }
+ return true;
+ }
+ private boolean OctalIntegerLiteral_sempred(RuleContext _localctx, int predIndex) {
+ switch (predIndex) {
+ case 2:
+ return !this.IsStrictMode();
+ }
+ return true;
+ }
+
+ public static final String _serializedATN =
+ "\u0004\u0000\u0086\u049f\u0006\uffff\uffff\u0006\uffff\uffff\u0002\u0000"+
+ "\u0007\u0000\u0002\u0001\u0007\u0001\u0002\u0002\u0007\u0002\u0002\u0003"+
+ "\u0007\u0003\u0002\u0004\u0007\u0004\u0002\u0005\u0007\u0005\u0002\u0006"+
+ "\u0007\u0006\u0002\u0007\u0007\u0007\u0002\b\u0007\b\u0002\t\u0007\t\u0002"+
+ "\n\u0007\n\u0002\u000b\u0007\u000b\u0002\f\u0007\f\u0002\r\u0007\r\u0002"+
+ "\u000e\u0007\u000e\u0002\u000f\u0007\u000f\u0002\u0010\u0007\u0010\u0002"+
+ "\u0011\u0007\u0011\u0002\u0012\u0007\u0012\u0002\u0013\u0007\u0013\u0002"+
+ "\u0014\u0007\u0014\u0002\u0015\u0007\u0015\u0002\u0016\u0007\u0016\u0002"+
+ "\u0017\u0007\u0017\u0002\u0018\u0007\u0018\u0002\u0019\u0007\u0019\u0002"+
+ "\u001a\u0007\u001a\u0002\u001b\u0007\u001b\u0002\u001c\u0007\u001c\u0002"+
+ "\u001d\u0007\u001d\u0002\u001e\u0007\u001e\u0002\u001f\u0007\u001f\u0002"+
+ " \u0007 \u0002!\u0007!\u0002\"\u0007\"\u0002#\u0007#\u0002$\u0007$\u0002"+
+ "%\u0007%\u0002&\u0007&\u0002\'\u0007\'\u0002(\u0007(\u0002)\u0007)\u0002"+
+ "*\u0007*\u0002+\u0007+\u0002,\u0007,\u0002-\u0007-\u0002.\u0007.\u0002"+
+ "/\u0007/\u00020\u00070\u00021\u00071\u00022\u00072\u00023\u00073\u0002"+
+ "4\u00074\u00025\u00075\u00026\u00076\u00027\u00077\u00028\u00078\u0002"+
+ "9\u00079\u0002:\u0007:\u0002;\u0007;\u0002<\u0007<\u0002=\u0007=\u0002"+
+ ">\u0007>\u0002?\u0007?\u0002@\u0007@\u0002A\u0007A\u0002B\u0007B\u0002"+
+ "C\u0007C\u0002D\u0007D\u0002E\u0007E\u0002F\u0007F\u0002G\u0007G\u0002"+
+ "H\u0007H\u0002I\u0007I\u0002J\u0007J\u0002K\u0007K\u0002L\u0007L\u0002"+
+ "M\u0007M\u0002N\u0007N\u0002O\u0007O\u0002P\u0007P\u0002Q\u0007Q\u0002"+
+ "R\u0007R\u0002S\u0007S\u0002T\u0007T\u0002U\u0007U\u0002V\u0007V\u0002"+
+ "W\u0007W\u0002X\u0007X\u0002Y\u0007Y\u0002Z\u0007Z\u0002[\u0007[\u0002"+
+ "\\\u0007\\\u0002]\u0007]\u0002^\u0007^\u0002_\u0007_\u0002`\u0007`\u0002"+
+ "a\u0007a\u0002b\u0007b\u0002c\u0007c\u0002d\u0007d\u0002e\u0007e\u0002"+
+ "f\u0007f\u0002g\u0007g\u0002h\u0007h\u0002i\u0007i\u0002j\u0007j\u0002"+
+ "k\u0007k\u0002l\u0007l\u0002m\u0007m\u0002n\u0007n\u0002o\u0007o\u0002"+
+ "p\u0007p\u0002q\u0007q\u0002r\u0007r\u0002s\u0007s\u0002t\u0007t\u0002"+
+ "u\u0007u\u0002v\u0007v\u0002w\u0007w\u0002x\u0007x\u0002y\u0007y\u0002"+
+ "z\u0007z\u0002{\u0007{\u0002|\u0007|\u0002}\u0007}\u0002~\u0007~\u0002"+
+ "\u007f\u0007\u007f\u0002\u0080\u0007\u0080\u0002\u0081\u0007\u0081\u0002"+
+ "\u0082\u0007\u0082\u0002\u0083\u0007\u0083\u0002\u0084\u0007\u0084\u0002"+
+ "\u0085\u0007\u0085\u0002\u0086\u0007\u0086\u0002\u0087\u0007\u0087\u0002"+
+ "\u0088\u0007\u0088\u0002\u0089\u0007\u0089\u0002\u008a\u0007\u008a\u0002"+
+ "\u008b\u0007\u008b\u0002\u008c\u0007\u008c\u0002\u008d\u0007\u008d\u0002"+
+ "\u008e\u0007\u008e\u0002\u008f\u0007\u008f\u0002\u0090\u0007\u0090\u0002"+
+ "\u0091\u0007\u0091\u0002\u0092\u0007\u0092\u0002\u0093\u0007\u0093\u0002"+
+ "\u0094\u0007\u0094\u0002\u0095\u0007\u0095\u0002\u0096\u0007\u0096\u0002"+
+ "\u0097\u0007\u0097\u0002\u0098\u0007\u0098\u0002\u0099\u0007\u0099\u0002"+
+ "\u009a\u0007\u009a\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0000\u0005"+
+ "\u0000\u013d\b\u0000\n\u0000\f\u0000\u0140\t\u0000\u0001\u0000\u0001\u0000"+
+ "\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0001\u0001"+
+ "\u0001\u0001\u0005\u0001\u014b\b\u0001\n\u0001\f\u0001\u014e\t\u0001\u0001"+
+ "\u0001\u0001\u0001\u0001\u0002\u0001\u0002\u0001\u0002\u0005\u0002\u0155"+
+ "\b\u0002\n\u0002\f\u0002\u0158\t\u0002\u0001\u0002\u0001\u0002\u0001\u0002"+
+ "\u0005\u0002\u015d\b\u0002\n\u0002\f\u0002\u0160\t\u0002\u0001\u0003\u0001"+
+ "\u0003\u0001\u0004\u0001\u0004\u0001\u0005\u0001\u0005\u0001\u0006\u0001"+
+ "\u0006\u0001\u0007\u0001\u0007\u0001\u0007\u0001\b\u0001\b\u0001\b\u0001"+
+ "\b\u0001\b\u0001\t\u0001\t\u0001\t\u0001\n\u0001\n\u0001\u000b\u0001\u000b"+
+ "\u0001\f\u0001\f\u0001\r\u0001\r\u0001\u000e\u0001\u000e\u0001\u000f\u0001"+
+ "\u000f\u0001\u000f\u0001\u000f\u0001\u0010\u0001\u0010\u0001\u0011\u0001"+
+ "\u0011\u0001\u0011\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0013\u0001"+
+ "\u0013\u0001\u0014\u0001\u0014\u0001\u0015\u0001\u0015\u0001\u0016\u0001"+
+ "\u0016\u0001\u0017\u0001\u0017\u0001\u0018\u0001\u0018\u0001\u0019\u0001"+
+ "\u0019\u0001\u001a\u0001\u001a\u0001\u001a\u0001\u001b\u0001\u001b\u0001"+
+ "\u001b\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001d\u0001"+
+ "\u001d\u0001\u001e\u0001\u001e\u0001\u001f\u0001\u001f\u0001\u001f\u0001"+
+ " \u0001 \u0001 \u0001!\u0001!\u0001!\u0001\"\u0001\"\u0001\"\u0001#\u0001"+
+ "#\u0001#\u0001#\u0001$\u0001$\u0001$\u0001$\u0001%\u0001%\u0001&\u0001"+
+ "&\u0001\'\u0001\'\u0001(\u0001(\u0001(\u0001)\u0001)\u0001)\u0001*\u0001"+
+ "*\u0001*\u0001+\u0001+\u0001+\u0001,\u0001,\u0001,\u0001-\u0001-\u0001"+
+ "-\u0001.\u0001.\u0001.\u0001/\u0001/\u0001/\u0001/\u00010\u00010\u0001"+
+ "0\u00010\u00011\u00011\u00011\u00011\u00011\u00012\u00012\u00012\u0001"+
+ "3\u00013\u00013\u00014\u00014\u00014\u00015\u00015\u00015\u00016\u0001"+
+ "6\u00016\u00016\u00016\u00017\u00017\u00017\u00017\u00017\u00017\u0001"+
+ "7\u00017\u00017\u00037\u01fd\b7\u00018\u00018\u00018\u00058\u0202\b8\n"+
+ "8\f8\u0205\t8\u00018\u00038\u0208\b8\u00018\u00018\u00048\u020c\b8\u000b"+
+ "8\f8\u020d\u00018\u00038\u0211\b8\u00018\u00018\u00038\u0215\b8\u0003"+
+ "8\u0217\b8\u00019\u00019\u00019\u00049\u021c\b9\u000b9\f9\u021d\u0001"+
+ ":\u0001:\u0004:\u0222\b:\u000b:\f:\u0223\u0001:\u0001:\u0001;\u0001;\u0001"+
+ ";\u0004;\u022b\b;\u000b;\f;\u022c\u0001<\u0001<\u0001<\u0004<\u0232\b"+
+ "<\u000b<\f<\u0233\u0001=\u0001=\u0001=\u0001=\u0001=\u0001=\u0001>\u0001"+
+ ">\u0001>\u0001?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001?\u0001"+
+ "?\u0001?\u0001?\u0001@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001@\u0001"+
+ "A\u0001A\u0001A\u0001A\u0001A\u0001B\u0001B\u0001B\u0001B\u0001B\u0001"+
+ "C\u0001C\u0001C\u0001C\u0001D\u0001D\u0001D\u0001D\u0001E\u0001E\u0001"+
+ "E\u0001E\u0001E\u0001E\u0001F\u0001F\u0001F\u0001F\u0001F\u0001F\u0001"+
+ "F\u0001F\u0001G\u0001G\u0001G\u0001G\u0001G\u0001G\u0001G\u0001H\u0001"+
+ "H\u0001H\u0001H\u0001H\u0001I\u0001I\u0001I\u0001I\u0001I\u0001I\u0001"+
+ "I\u0001I\u0001I\u0001J\u0001J\u0001J\u0001J\u0001K\u0001K\u0001K\u0001"+
+ "K\u0001K\u0001K\u0001K\u0001L\u0001L\u0001L\u0001L\u0001L\u0001L\u0001"+
+ "M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001M\u0001N\u0001"+
+ "N\u0001N\u0001N\u0001N\u0001N\u0001N\u0001N\u0001N\u0001O\u0001O\u0001"+
+ "O\u0001O\u0001O\u0001P\u0001P\u0001P\u0001P\u0001P\u0001Q\u0001Q\u0001"+
+ "Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001Q\u0001R\u0001R\u0001R\u0001S\u0001"+
+ "S\u0001S\u0001S\u0001S\u0001S\u0001T\u0001T\u0001T\u0001T\u0001T\u0001"+
+ "T\u0001T\u0001U\u0001U\u0001U\u0001V\u0001V\u0001V\u0001V\u0001W\u0001"+
+ "W\u0001W\u0001X\u0001X\u0001X\u0001X\u0001X\u0001Y\u0001Y\u0001Y\u0001"+
+ "Y\u0001Y\u0001Y\u0001Y\u0001Y\u0001Y\u0001Z\u0001Z\u0001Z\u0001Z\u0001"+
+ "Z\u0001Z\u0001[\u0001[\u0001[\u0001[\u0001[\u0001[\u0001\\\u0001\\\u0001"+
+ "\\\u0001\\\u0001\\\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001]\u0001"+
+ "]\u0001^\u0001^\u0001^\u0001^\u0001^\u0001^\u0001_\u0001_\u0001_\u0001"+
+ "_\u0001_\u0001_\u0001`\u0001`\u0001`\u0001`\u0001`\u0001`\u0001`\u0001"+
+ "a\u0001a\u0001a\u0001a\u0001a\u0001a\u0001a\u0001b\u0001b\u0001b\u0001"+
+ "b\u0001b\u0001b\u0001b\u0001b\u0001b\u0001b\u0001b\u0001c\u0001c\u0001"+
+ "c\u0001c\u0001d\u0001d\u0001d\u0001d\u0001d\u0001d\u0001d\u0001d\u0001"+
+ "e\u0001e\u0001e\u0001e\u0001e\u0001e\u0001e\u0001f\u0001f\u0001f\u0001"+
+ "f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001f\u0001g\u0001g\u0001g\u0001"+
+ "g\u0001g\u0001g\u0001g\u0001g\u0001h\u0001h\u0001h\u0001h\u0001h\u0001"+
+ "h\u0001h\u0001h\u0001h\u0001h\u0001i\u0001i\u0001i\u0001i\u0001i\u0001"+
+ "i\u0001i\u0001j\u0001j\u0001j\u0001j\u0001j\u0001j\u0001k\u0001k\u0001"+
+ "k\u0001k\u0001l\u0001l\u0001l\u0001l\u0001l\u0001l\u0001l\u0001m\u0001"+
+ "m\u0001m\u0001m\u0001m\u0001m\u0001m\u0001m\u0001n\u0001n\u0001n\u0001"+
+ "n\u0001n\u0001n\u0001n\u0001o\u0001o\u0001o\u0001o\u0001o\u0001o\u0001"+
+ "o\u0001p\u0001p\u0001p\u0001p\u0001p\u0001q\u0001q\u0001q\u0001q\u0001"+
+ "r\u0001r\u0001r\u0001r\u0001s\u0001s\u0001s\u0001s\u0001s\u0001s\u0001"+
+ "s\u0001s\u0001s\u0001s\u0001s\u0001s\u0001t\u0001t\u0001t\u0001t\u0001"+
+ "t\u0001t\u0001t\u0001t\u0001t\u0001t\u0001u\u0001u\u0001u\u0001u\u0001"+
+ "u\u0001u\u0001u\u0001u\u0001v\u0001v\u0001v\u0001v\u0001v\u0001v\u0001"+
+ "v\u0001w\u0001w\u0001w\u0001w\u0001w\u0001w\u0001w\u0001w\u0001x\u0001"+
+ "x\u0001x\u0001x\u0001x\u0001x\u0001x\u0001x\u0001x\u0001y\u0001y\u0001"+
+ "y\u0001z\u0001z\u0001{\u0001{\u0005{\u03c8\b{\n{\f{\u03cb\t{\u0001|\u0001"+
+ "|\u0005|\u03cf\b|\n|\f|\u03d2\t|\u0001|\u0001|\u0001|\u0005|\u03d7\b|"+
+ "\n|\f|\u03da\t|\u0001|\u0003|\u03dd\b|\u0001|\u0001|\u0001}\u0001}\u0001"+
+ "}\u0001}\u0001}\u0001~\u0004~\u03e7\b~\u000b~\f~\u03e8\u0001~\u0001~\u0001"+
+ "\u007f\u0001\u007f\u0001\u007f\u0001\u007f\u0001\u0080\u0001\u0080\u0001"+
+ "\u0080\u0001\u0080\u0001\u0080\u0001\u0080\u0005\u0080\u03f7\b\u0080\n"+
+ "\u0080\f\u0080\u03fa\t\u0080\u0001\u0080\u0001\u0080\u0001\u0080\u0001"+
+ "\u0080\u0001\u0080\u0001\u0080\u0001\u0081\u0001\u0081\u0001\u0081\u0001"+
+ "\u0081\u0001\u0081\u0001\u0081\u0001\u0081\u0001\u0081\u0001\u0081\u0001"+
+ "\u0081\u0001\u0081\u0005\u0081\u040d\b\u0081\n\u0081\f\u0081\u0410\t\u0081"+
+ "\u0001\u0081\u0001\u0081\u0001\u0081\u0001\u0081\u0001\u0081\u0001\u0081"+
+ "\u0001\u0082\u0001\u0082\u0001\u0082\u0001\u0082\u0001\u0083\u0001\u0083"+
+ "\u0001\u0083\u0001\u0084\u0001\u0084\u0001\u0084\u0001\u0084\u0001\u0084"+
+ "\u0001\u0084\u0001\u0085\u0001\u0085\u0001\u0085\u0001\u0085\u0001\u0085"+
+ "\u0001\u0085\u0001\u0085\u0001\u0086\u0001\u0086\u0001\u0087\u0001\u0087"+
+ "\u0001\u0087\u0001\u0087\u0003\u0087\u0432\b\u0087\u0001\u0088\u0001\u0088"+
+ "\u0001\u0088\u0001\u0088\u0003\u0088\u0438\b\u0088\u0001\u0089\u0001\u0089"+
+ "\u0001\u0089\u0001\u0089\u0001\u0089\u0003\u0089\u043f\b\u0089\u0001\u008a"+
+ "\u0001\u008a\u0003\u008a\u0443\b\u008a\u0001\u008b\u0001\u008b\u0001\u008b"+
+ "\u0001\u008b\u0001\u008c\u0001\u008c\u0001\u008c\u0001\u008c\u0001\u008c"+
+ "\u0001\u008c\u0001\u008d\u0001\u008d\u0001\u008d\u0004\u008d\u0452\b\u008d"+
+ "\u000b\u008d\f\u008d\u0453\u0001\u008d\u0001\u008d\u0001\u008e\u0001\u008e"+
+ "\u0001\u008f\u0001\u008f\u0001\u0090\u0001\u0090\u0003\u0090\u045e\b\u0090"+
+ "\u0001\u0091\u0001\u0091\u0001\u0091\u0001\u0092\u0001\u0092\u0001\u0093"+
+ "\u0001\u0093\u0001\u0093\u0005\u0093\u0468\b\u0093\n\u0093\f\u0093\u046b"+
+ "\t\u0093\u0003\u0093\u046d\b\u0093\u0001\u0094\u0001\u0094\u0003\u0094"+
+ "\u0471\b\u0094\u0001\u0094\u0004\u0094\u0474\b\u0094\u000b\u0094\f\u0094"+
+ "\u0475\u0001\u0095\u0001\u0095\u0003\u0095\u047a\b\u0095\u0001\u0096\u0001"+
+ "\u0096\u0001\u0096\u0003\u0096\u047f\b\u0096\u0001\u0097\u0001\u0097\u0001"+
+ "\u0097\u0001\u0097\u0005\u0097\u0485\b\u0097\n\u0097\f\u0097\u0488\t\u0097"+
+ "\u0001\u0097\u0003\u0097\u048b\b\u0097\u0001\u0098\u0001\u0098\u0001\u0098"+
+ "\u0001\u0098\u0005\u0098\u0491\b\u0098\n\u0098\f\u0098\u0494\t\u0098\u0001"+
+ "\u0098\u0003\u0098\u0497\b\u0098\u0001\u0099\u0001\u0099\u0003\u0099\u049b"+
+ "\b\u0099\u0001\u009a\u0001\u009a\u0001\u009a\u0003\u013e\u03f8\u040e\u0000"+
+ "\u009b\u0002\u0001\u0004\u0002\u0006\u0003\b\u0004\n\u0005\f\u0006\u000e"+
+ "\u0007\u0010\b\u0012\t\u0014\n\u0016\u000b\u0018\f\u001a\r\u001c\u000e"+
+ "\u001e\u000f \u0010\"\u0011$\u0012&\u0013(\u0014*\u0015,\u0016.\u0017"+
+ "0\u00182\u00194\u001a6\u001b8\u001c:\u001d<\u001e>\u001f@ B!D\"F#H$J%"+
+ "L&N\'P(R)T*V+X,Z-\\.^/`0b1d2f3h4j5l6n7p8r9t:v;x~?\u0080@\u0082A\u0084"+
+ "B\u0086C\u0088D\u008aE\u008cF\u008eG\u0090H\u0092I\u0094J\u0096K\u0098"+
+ "L\u009aM\u009cN\u009eO\u00a0P\u00a2Q\u00a4R\u00a6S\u00a8T\u00aaU\u00ac"+
+ "V\u00aeW\u00b0X\u00b2Y\u00b4Z\u00b6[\u00b8\\\u00ba]\u00bc^\u00be_\u00c0"+
+ "`\u00c2a\u00c4b\u00c6c\u00c8d\u00cae\u00ccf\u00ceg\u00d0h\u00d2i\u00d4"+
+ "j\u00d6k\u00d8l\u00dam\u00dcn\u00deo\u00e0p\u00e2q\u00e4r\u00e6s\u00e8"+
+ "t\u00eau\u00ecv\u00eew\u00f0x\u00f2y\u00f4z\u00f6{\u00f8|\u00fa}\u00fc"+
+ "~\u00fe\u007f\u0100\u0080\u0102\u0081\u0104\u0082\u0106\u0083\u0108\u0084"+
+ "\u010a\u0000\u010c\u0085\u010e\u0086\u0110\u0000\u0112\u0000\u0114\u0000"+
+ "\u0116\u0000\u0118\u0000\u011a\u0000\u011c\u0000\u011e\u0000\u0120\u0000"+
+ "\u0122\u0000\u0124\u0000\u0126\u0000\u0128\u0000\u012a\u0000\u012c\u0000"+
+ "\u012e\u0000\u0130\u0000\u0132\u0000\u0134\u0000\u0136\u0000\u0002\u0000"+
+ "\u0001\u0017\u0003\u0000\n\n\r\r\u2028\u2029\u0001\u000009\u0002\u0000"+
+ "XXxx\u0001\u000007\u0002\u0000OOoo\u0002\u0000BBbb\u0001\u000001\u0004"+
+ "\u0000\t\t\u000b\f \u00a0\u00a0\u0002\u0000\\\\``\u0004\u0000\n\n\r\r"+
+ "\"\"\\\\\u0004\u0000\n\n\r\r\'\'\\\\\t\u0000\"\"\'\'\\\\bbffnnrrttvv\f"+
+ "\u0000\n\n\r\r\"\"\'\'09\\\\bbffnnrrtvxx\u0003\u000009uuxx\u0003\u0000"+
+ "09AFaf\u0001\u000019\u0002\u0000EEee\u0002\u0000++--\u0198\u000009__\u0300"+
+ "\u036f\u0483\u0487\u0591\u05bd\u05bf\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7"+
+ "\u05c7\u0610\u061a\u064b\u0669\u0670\u0670\u06d6\u06dc\u06df\u06e4\u06e7"+
+ "\u06e8\u06ea\u06ed\u06f0\u06f9\u0711\u0711\u0730\u074a\u07a6\u07b0\u07c0"+
+ "\u07c9\u07eb\u07f3\u07fd\u07fd\u0816\u0819\u081b\u0823\u0825\u0827\u0829"+
+ "\u082d\u0859\u085b\u0898\u089f\u08ca\u08e1\u08e3\u0902\u093a\u093a\u093c"+
+ "\u093c\u0941\u0948\u094d\u094d\u0951\u0957\u0962\u0963\u0966\u096f\u0981"+
+ "\u0981\u09bc\u09bc\u09c1\u09c4\u09cd\u09cd\u09e2\u09e3\u09e6\u09ef\u09fe"+
+ "\u09fe\u0a01\u0a02\u0a3c\u0a3c\u0a41\u0a42\u0a47\u0a48\u0a4b\u0a4d\u0a51"+
+ "\u0a51\u0a66\u0a71\u0a75\u0a75\u0a81\u0a82\u0abc\u0abc\u0ac1\u0ac5\u0ac7"+
+ "\u0ac8\u0acd\u0acd\u0ae2\u0ae3\u0ae6\u0aef\u0afa\u0aff\u0b01\u0b01\u0b3c"+
+ "\u0b3c\u0b3f\u0b3f\u0b41\u0b44\u0b4d\u0b4d\u0b55\u0b56\u0b62\u0b63\u0b66"+
+ "\u0b6f\u0b82\u0b82\u0bc0\u0bc0\u0bcd\u0bcd\u0be6\u0bef\u0c00\u0c00\u0c04"+
+ "\u0c04\u0c3c\u0c3c\u0c3e\u0c40\u0c46\u0c48\u0c4a\u0c4d\u0c55\u0c56\u0c62"+
+ "\u0c63\u0c66\u0c6f\u0c81\u0c81\u0cbc\u0cbc\u0cbf\u0cbf\u0cc6\u0cc6\u0ccc"+
+ "\u0ccd\u0ce2\u0ce3\u0ce6\u0cef\u0d00\u0d01\u0d3b\u0d3c\u0d41\u0d44\u0d4d"+
+ "\u0d4d\u0d62\u0d63\u0d66\u0d6f\u0d81\u0d81\u0dca\u0dca\u0dd2\u0dd4\u0dd6"+
+ "\u0dd6\u0de6\u0def\u0e31\u0e31\u0e34\u0e3a\u0e47\u0e4e\u0e50\u0e59\u0eb1"+
+ "\u0eb1\u0eb4\u0ebc\u0ec8\u0ece\u0ed0\u0ed9\u0f18\u0f19\u0f20\u0f29\u0f35"+
+ "\u0f35\u0f37\u0f37\u0f39\u0f39\u0f71\u0f7e\u0f80\u0f84\u0f86\u0f87\u0f8d"+
+ "\u0f97\u0f99\u0fbc\u0fc6\u0fc6\u102d\u1030\u1032\u1037\u1039\u103a\u103d"+
+ "\u103e\u1040\u1049\u1058\u1059\u105e\u1060\u1071\u1074\u1082\u1082\u1085"+
+ "\u1086\u108d\u108d\u1090\u1099\u109d\u109d\u135d\u135f\u1712\u1714\u1732"+
+ "\u1733\u1752\u1753\u1772\u1773\u17b4\u17b5\u17b7\u17bd\u17c6\u17c6\u17c9"+
+ "\u17d3\u17dd\u17dd\u17e0\u17e9\u180b\u180d\u180f\u1819\u1885\u1886\u18a9"+
+ "\u18a9\u1920\u1922\u1927\u1928\u1932\u1932\u1939\u193b\u1946\u194f\u19d0"+
+ "\u19d9\u1a17\u1a18\u1a1b\u1a1b\u1a56\u1a56\u1a58\u1a5e\u1a60\u1a60\u1a62"+
+ "\u1a62\u1a65\u1a6c\u1a73\u1a7c\u1a7f\u1a89\u1a90\u1a99\u1ab0\u1abd\u1abf"+
+ "\u1ace\u1b00\u1b03\u1b34\u1b34\u1b36\u1b3a\u1b3c\u1b3c\u1b42\u1b42\u1b50"+
+ "\u1b59\u1b6b\u1b73\u1b80\u1b81\u1ba2\u1ba5\u1ba8\u1ba9\u1bab\u1bad\u1bb0"+
+ "\u1bb9\u1be6\u1be6\u1be8\u1be9\u1bed\u1bed\u1bef\u1bf1\u1c2c\u1c33\u1c36"+
+ "\u1c37\u1c40\u1c49\u1c50\u1c59\u1cd0\u1cd2\u1cd4\u1ce0\u1ce2\u1ce8\u1ced"+
+ "\u1ced\u1cf4\u1cf4\u1cf8\u1cf9\u1dc0\u1dff\u200c\u200d\u203f\u2040\u2054"+
+ "\u2054\u20d0\u20dc\u20e1\u20e1\u20e5\u20f0\u2cef\u2cf1\u2d7f\u2d7f\u2de0"+
+ "\u2dff\u302a\u302d\u3099\u309a\u8000\ua620\u8000\ua629\u8000\ua66f\u8000"+
+ "\ua66f\u8000\ua674\u8000\ua67d\u8000\ua69e\u8000\ua69f\u8000\ua6f0\u8000"+
+ "\ua6f1\u8000\ua802\u8000\ua802\u8000\ua806\u8000\ua806\u8000\ua80b\u8000"+
+ "\ua80b\u8000\ua825\u8000\ua826\u8000\ua82c\u8000\ua82c\u8000\ua8c4\u8000"+
+ "\ua8c5\u8000\ua8d0\u8000\ua8d9\u8000\ua8e0\u8000\ua8f1\u8000\ua8ff\u8000"+
+ "\ua909\u8000\ua926\u8000\ua92d\u8000\ua947\u8000\ua951\u8000\ua980\u8000"+
+ "\ua982\u8000\ua9b3\u8000\ua9b3\u8000\ua9b6\u8000\ua9b9\u8000\ua9bc\u8000"+
+ "\ua9bd\u8000\ua9d0\u8000\ua9d9\u8000\ua9e5\u8000\ua9e5\u8000\ua9f0\u8000"+
+ "\ua9f9\u8000\uaa29\u8000\uaa2e\u8000\uaa31\u8000\uaa32\u8000\uaa35\u8000"+
+ "\uaa36\u8000\uaa43\u8000\uaa43\u8000\uaa4c\u8000\uaa4c\u8000\uaa50\u8000"+
+ "\uaa59\u8000\uaa7c\u8000\uaa7c\u8000\uaab0\u8000\uaab0\u8000\uaab2\u8000"+
+ "\uaab4\u8000\uaab7\u8000\uaab8\u8000\uaabe\u8000\uaabf\u8000\uaac1\u8000"+
+ "\uaac1\u8000\uaaec\u8000\uaaed\u8000\uaaf6\u8000\uaaf6\u8000\uabe5\u8000"+
+ "\uabe5\u8000\uabe8\u8000\uabe8\u8000\uabed\u8000\uabed\u8000\uabf0\u8000"+
+ "\uabf9\u8000\ufb1e\u8000\ufb1e\u8000\ufe00\u8000\ufe0f\u8000\ufe20\u8000"+
+ "\ufe2f\u8000\ufe33\u8000\ufe34\u8000\ufe4d\u8000\ufe4f\u8000\uff10\u8000"+
+ "\uff19\u8000\uff3f\u8000\uff3f\u8001\u01fd\u8001\u01fd\u8001\u02e0\u8001"+
+ "\u02e0\u8001\u0376\u8001\u037a\u8001\u04a0\u8001\u04a9\u8001\u0a01\u8001"+
+ "\u0a03\u8001\u0a05\u8001\u0a06\u8001\u0a0c\u8001\u0a0f\u8001\u0a38\u8001"+
+ "\u0a3a\u8001\u0a3f\u8001\u0a3f\u8001\u0ae5\u8001\u0ae6\u8001\u0d24\u8001"+
+ "\u0d27\u8001\u0d30\u8001\u0d39\u8001\u0eab\u8001\u0eac\u8001\u0efd\u8001"+
+ "\u0eff\u8001\u0f46\u8001\u0f50\u8001\u0f82\u8001\u0f85\u8001\u1001\u8001"+
+ "\u1001\u8001\u1038\u8001\u1046\u8001\u1066\u8001\u1070\u8001\u1073\u8001"+
+ "\u1074\u8001\u107f\u8001\u1081\u8001\u10b3\u8001\u10b6\u8001\u10b9\u8001"+
+ "\u10ba\u8001\u10c2\u8001\u10c2\u8001\u10f0\u8001\u10f9\u8001\u1100\u8001"+
+ "\u1102\u8001\u1127\u8001\u112b\u8001\u112d\u8001\u1134\u8001\u1136\u8001"+
+ "\u113f\u8001\u1173\u8001\u1173\u8001\u1180\u8001\u1181\u8001\u11b6\u8001"+
+ "\u11be\u8001\u11c9\u8001\u11cc\u8001\u11cf\u8001\u11d9\u8001\u122f\u8001"+
+ "\u1231\u8001\u1234\u8001\u1234\u8001\u1236\u8001\u1237\u8001\u123e\u8001"+
+ "\u123e\u8001\u1241\u8001\u1241\u8001\u12df\u8001\u12df\u8001\u12e3\u8001"+
+ "\u12ea\u8001\u12f0\u8001\u12f9\u8001\u1300\u8001\u1301\u8001\u133b\u8001"+
+ "\u133c\u8001\u1340\u8001\u1340\u8001\u1366\u8001\u136c\u8001\u1370\u8001"+
+ "\u1374\u8001\u1438\u8001\u143f\u8001\u1442\u8001\u1444\u8001\u1446\u8001"+
+ "\u1446\u8001\u1450\u8001\u1459\u8001\u145e\u8001\u145e\u8001\u14b3\u8001"+
+ "\u14b8\u8001\u14ba\u8001\u14ba\u8001\u14bf\u8001\u14c0\u8001\u14c2\u8001"+
+ "\u14c3\u8001\u14d0\u8001\u14d9\u8001\u15b2\u8001\u15b5\u8001\u15bc\u8001"+
+ "\u15bd\u8001\u15bf\u8001\u15c0\u8001\u15dc\u8001\u15dd\u8001\u1633\u8001"+
+ "\u163a\u8001\u163d\u8001\u163d\u8001\u163f\u8001\u1640\u8001\u1650\u8001"+
+ "\u1659\u8001\u16ab\u8001\u16ab\u8001\u16ad\u8001\u16ad\u8001\u16b0\u8001"+
+ "\u16b5\u8001\u16b7\u8001\u16b7\u8001\u16c0\u8001\u16c9\u8001\u171d\u8001"+
+ "\u171f\u8001\u1722\u8001\u1725\u8001\u1727\u8001\u172b\u8001\u1730\u8001"+
+ "\u1739\u8001\u182f\u8001\u1837\u8001\u1839\u8001\u183a\u8001\u18e0\u8001"+
+ "\u18e9\u8001\u193b\u8001\u193c\u8001\u193e\u8001\u193e\u8001\u1943\u8001"+
+ "\u1943\u8001\u1950\u8001\u1959\u8001\u19d4\u8001\u19d7\u8001\u19da\u8001"+
+ "\u19db\u8001\u19e0\u8001\u19e0\u8001\u1a01\u8001\u1a0a\u8001\u1a33\u8001"+
+ "\u1a38\u8001\u1a3b\u8001\u1a3e\u8001\u1a47\u8001\u1a47\u8001\u1a51\u8001"+
+ "\u1a56\u8001\u1a59\u8001\u1a5b\u8001\u1a8a\u8001\u1a96\u8001\u1a98\u8001"+
+ "\u1a99\u8001\u1c30\u8001\u1c36\u8001\u1c38\u8001\u1c3d\u8001\u1c3f\u8001"+
+ "\u1c3f\u8001\u1c50\u8001\u1c59\u8001\u1c92\u8001\u1ca7\u8001\u1caa\u8001"+
+ "\u1cb0\u8001\u1cb2\u8001\u1cb3\u8001\u1cb5\u8001\u1cb6\u8001\u1d31\u8001"+
+ "\u1d36\u8001\u1d3a\u8001\u1d3a\u8001\u1d3c\u8001\u1d3d\u8001\u1d3f\u8001"+
+ "\u1d45\u8001\u1d47\u8001\u1d47\u8001\u1d50\u8001\u1d59\u8001\u1d90\u8001"+
+ "\u1d91\u8001\u1d95\u8001\u1d95\u8001\u1d97\u8001\u1d97\u8001\u1da0\u8001"+
+ "\u1da9\u8001\u1ef3\u8001\u1ef4\u8001\u1f00\u8001\u1f01\u8001\u1f36\u8001"+
+ "\u1f3a\u8001\u1f40\u8001\u1f40\u8001\u1f42\u8001\u1f42\u8001\u1f50\u8001"+
+ "\u1f59\u8001\u3440\u8001\u3440\u8001\u3447\u8001\u3455\u8001\u6a60\u8001"+
+ "\u6a69\u8001\u6ac0\u8001\u6ac9\u8001\u6af0\u8001\u6af4\u8001\u6b30\u8001"+
+ "\u6b36\u8001\u6b50\u8001\u6b59\u8001\u6f4f\u8001\u6f4f\u8001\u6f8f\u8001"+
+ "\u6f92\u8001\u6fe4\u8001\u6fe4\u8001\ubc9d\u8001\ubc9e\u8001\ucf00\u8001"+
+ "\ucf2d\u8001\ucf30\u8001\ucf46\u8001\ud167\u8001\ud169\u8001\ud17b\u8001"+
+ "\ud182\u8001\ud185\u8001\ud18b\u8001\ud1aa\u8001\ud1ad\u8001\ud242\u8001"+
+ "\ud244\u8001\ud7ce\u8001\ud7ff\u8001\uda00\u8001\uda36\u8001\uda3b\u8001"+
+ "\uda6c\u8001\uda75\u8001\uda75\u8001\uda84\u8001\uda84\u8001\uda9b\u8001"+
+ "\uda9f\u8001\udaa1\u8001\udaaf\u8001\ue000\u8001\ue006\u8001\ue008\u8001"+
+ "\ue018\u8001\ue01b\u8001\ue021\u8001\ue023\u8001\ue024\u8001\ue026\u8001"+
+ "\ue02a\u8001\ue08f\u8001\ue08f\u8001\ue130\u8001\ue136\u8001\ue140\u8001"+
+ "\ue149\u8001\ue2ae\u8001\ue2ae\u8001\ue2ec\u8001\ue2f9\u8001\ue4ec\u8001"+
+ "\ue4f9\u8001\ue8d0\u8001\ue8d6\u8001\ue944\u8001\ue94a\u8001\ue950\u8001"+
+ "\ue959\u8001\ufbf0\u8001\ufbf9\u800e\u0100\u800e\u01ef\u0295\u0000$$A"+
+ "Z__az\u00aa\u00aa\u00b5\u00b5\u00ba\u00ba\u00c0\u00d6\u00d8\u00f6\u00f8"+
+ "\u02c1\u02c6\u02d1\u02e0\u02e4\u02ec\u02ec\u02ee\u02ee\u0370\u0374\u0376"+
+ "\u0377\u037a\u037d\u037f\u037f\u0386\u0386\u0388\u038a\u038c\u038c\u038e"+
+ "\u03a1\u03a3\u03f5\u03f7\u0481\u048a\u052f\u0531\u0556\u0559\u0559\u0560"+
+ "\u0588\u05d0\u05ea\u05ef\u05f2\u0620\u064a\u066e\u066f\u0671\u06d3\u06d5"+
+ "\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa\u06fc\u06ff\u06ff\u0710\u0710\u0712"+
+ "\u072f\u074d\u07a5\u07b1\u07b1\u07ca\u07ea\u07f4\u07f5\u07fa\u07fa\u0800"+
+ "\u0815\u081a\u081a\u0824\u0824\u0828\u0828\u0840\u0858\u0860\u086a\u0870"+
+ "\u0887\u0889\u088e\u08a0\u08c9\u0904\u0939\u093d\u093d\u0950\u0950\u0958"+
+ "\u0961\u0971\u0980\u0985\u098c\u098f\u0990\u0993\u09a8\u09aa\u09b0\u09b2"+
+ "\u09b2\u09b6\u09b9\u09bd\u09bd\u09ce\u09ce\u09dc\u09dd\u09df\u09e1\u09f0"+
+ "\u09f1\u09fc\u09fc\u0a05\u0a0a\u0a0f\u0a10\u0a13\u0a28\u0a2a\u0a30\u0a32"+
+ "\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59\u0a5c\u0a5e\u0a5e\u0a72\u0a74\u0a85"+
+ "\u0a8d\u0a8f\u0a91\u0a93\u0aa8\u0aaa\u0ab0\u0ab2\u0ab3\u0ab5\u0ab9\u0abd"+
+ "\u0abd\u0ad0\u0ad0\u0ae0\u0ae1\u0af9\u0af9\u0b05\u0b0c\u0b0f\u0b10\u0b13"+
+ "\u0b28\u0b2a\u0b30\u0b32\u0b33\u0b35\u0b39\u0b3d\u0b3d\u0b5c\u0b5d\u0b5f"+
+ "\u0b61\u0b71\u0b71\u0b83\u0b83\u0b85\u0b8a\u0b8e\u0b90\u0b92\u0b95\u0b99"+
+ "\u0b9a\u0b9c\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8\u0baa\u0bae\u0bb9\u0bd0"+
+ "\u0bd0\u0c05\u0c0c\u0c0e\u0c10\u0c12\u0c28\u0c2a\u0c39\u0c3d\u0c3d\u0c58"+
+ "\u0c5a\u0c5d\u0c5d\u0c60\u0c61\u0c80\u0c80\u0c85\u0c8c\u0c8e\u0c90\u0c92"+
+ "\u0ca8\u0caa\u0cb3\u0cb5\u0cb9\u0cbd\u0cbd\u0cdd\u0cde\u0ce0\u0ce1\u0cf1"+
+ "\u0cf2\u0d04\u0d0c\u0d0e\u0d10\u0d12\u0d3a\u0d3d\u0d3d\u0d4e\u0d4e\u0d54"+
+ "\u0d56\u0d5f\u0d61\u0d7a\u0d7f\u0d85\u0d96\u0d9a\u0db1\u0db3\u0dbb\u0dbd"+
+ "\u0dbd\u0dc0\u0dc6\u0e01\u0e30\u0e32\u0e33\u0e40\u0e46\u0e81\u0e82\u0e84"+
+ "\u0e84\u0e86\u0e8a\u0e8c\u0ea3\u0ea5\u0ea5\u0ea7\u0eb0\u0eb2\u0eb3\u0ebd"+
+ "\u0ebd\u0ec0\u0ec4\u0ec6\u0ec6\u0edc\u0edf\u0f00\u0f00\u0f40\u0f47\u0f49"+
+ "\u0f6c\u0f88\u0f8c\u1000\u102a\u103f\u103f\u1050\u1055\u105a\u105d\u1061"+
+ "\u1061\u1065\u1066\u106e\u1070\u1075\u1081\u108e\u108e\u10a0\u10c5\u10c7"+
+ "\u10c7\u10cd\u10cd\u10d0\u10fa\u10fc\u1248\u124a\u124d\u1250\u1256\u1258"+
+ "\u1258\u125a\u125d\u1260\u1288\u128a\u128d\u1290\u12b0\u12b2\u12b5\u12b8"+
+ "\u12be\u12c0\u12c0\u12c2\u12c5\u12c8\u12d6\u12d8\u1310\u1312\u1315\u1318"+
+ "\u135a\u1380\u138f\u13a0\u13f5\u13f8\u13fd\u1401\u166c\u166f\u167f\u1681"+
+ "\u169a\u16a0\u16ea\u16f1\u16f8\u1700\u1711\u171f\u1731\u1740\u1751\u1760"+
+ "\u176c\u176e\u1770\u1780\u17b3\u17d7\u17d7\u17dc\u17dc\u1820\u1878\u1880"+
+ "\u1884\u1887\u18a8\u18aa\u18aa\u18b0\u18f5\u1900\u191e\u1950\u196d\u1970"+
+ "\u1974\u1980\u19ab\u19b0\u19c9\u1a00\u1a16\u1a20\u1a54\u1aa7\u1aa7\u1b05"+
+ "\u1b33\u1b45\u1b4c\u1b83\u1ba0\u1bae\u1baf\u1bba\u1be5\u1c00\u1c23\u1c4d"+
+ "\u1c4f\u1c5a\u1c7d\u1c80\u1c88\u1c90\u1cba\u1cbd\u1cbf\u1ce9\u1cec\u1cee"+
+ "\u1cf3\u1cf5\u1cf6\u1cfa\u1cfa\u1d00\u1dbf\u1e00\u1f15\u1f18\u1f1d\u1f20"+
+ "\u1f45\u1f48\u1f4d\u1f50\u1f57\u1f59\u1f59\u1f5b\u1f5b\u1f5d\u1f5d\u1f5f"+
+ "\u1f7d\u1f80\u1fb4\u1fb6\u1fbc\u1fbe\u1fbe\u1fc2\u1fc4\u1fc6\u1fcc\u1fd0"+
+ "\u1fd3\u1fd6\u1fdb\u1fe0\u1fec\u1ff2\u1ff4\u1ff6\u1ffc\u2071\u2071\u207f"+
+ "\u207f\u2090\u209c\u2102\u2102\u2107\u2107\u210a\u2113\u2115\u2115\u2119"+
+ "\u211d\u2124\u2124\u2126\u2126\u2128\u2128\u212a\u212d\u212f\u2139\u213c"+
+ "\u213f\u2145\u2149\u214e\u214e\u2183\u2184\u2c00\u2ce4\u2ceb\u2cee\u2cf2"+
+ "\u2cf3\u2d00\u2d25\u2d27\u2d27\u2d2d\u2d2d\u2d30\u2d67\u2d6f\u2d6f\u2d80"+
+ "\u2d96\u2da0\u2da6\u2da8\u2dae\u2db0\u2db6\u2db8\u2dbe\u2dc0\u2dc6\u2dc8"+
+ "\u2dce\u2dd0\u2dd6\u2dd8\u2dde\u2e2f\u2e2f\u3005\u3006\u3031\u3035\u303b"+
+ "\u303c\u3041\u3096\u309d\u309f\u30a1\u30fa\u30fc\u30ff\u3105\u312f\u3131"+
+ "\u318e\u31a0\u31bf\u31f0\u31ff\u3400\u4dbf\u4e00\u8000\ua48c\u8000\ua4d0"+
+ "\u8000\ua4fd\u8000\ua500\u8000\ua60c\u8000\ua610\u8000\ua61f\u8000\ua62a"+
+ "\u8000\ua62b\u8000\ua640\u8000\ua66e\u8000\ua67f\u8000\ua69d\u8000\ua6a0"+
+ "\u8000\ua6e5\u8000\ua717\u8000\ua71f\u8000\ua722\u8000\ua788\u8000\ua78b"+
+ "\u8000\ua7ca\u8000\ua7d0\u8000\ua7d1\u8000\ua7d3\u8000\ua7d3\u8000\ua7d5"+
+ "\u8000\ua7d9\u8000\ua7f2\u8000\ua801\u8000\ua803\u8000\ua805\u8000\ua807"+
+ "\u8000\ua80a\u8000\ua80c\u8000\ua822\u8000\ua840\u8000\ua873\u8000\ua882"+
+ "\u8000\ua8b3\u8000\ua8f2\u8000\ua8f7\u8000\ua8fb\u8000\ua8fb\u8000\ua8fd"+
+ "\u8000\ua8fe\u8000\ua90a\u8000\ua925\u8000\ua930\u8000\ua946\u8000\ua960"+
+ "\u8000\ua97c\u8000\ua984\u8000\ua9b2\u8000\ua9cf\u8000\ua9cf\u8000\ua9e0"+
+ "\u8000\ua9e4\u8000\ua9e6\u8000\ua9ef\u8000\ua9fa\u8000\ua9fe\u8000\uaa00"+
+ "\u8000\uaa28\u8000\uaa40\u8000\uaa42\u8000\uaa44\u8000\uaa4b\u8000\uaa60"+
+ "\u8000\uaa76\u8000\uaa7a\u8000\uaa7a\u8000\uaa7e\u8000\uaaaf\u8000\uaab1"+
+ "\u8000\uaab1\u8000\uaab5\u8000\uaab6\u8000\uaab9\u8000\uaabd\u8000\uaac0"+
+ "\u8000\uaac0\u8000\uaac2\u8000\uaac2\u8000\uaadb\u8000\uaadd\u8000\uaae0"+
+ "\u8000\uaaea\u8000\uaaf2\u8000\uaaf4\u8000\uab01\u8000\uab06\u8000\uab09"+
+ "\u8000\uab0e\u8000\uab11\u8000\uab16\u8000\uab20\u8000\uab26\u8000\uab28"+
+ "\u8000\uab2e\u8000\uab30\u8000\uab5a\u8000\uab5c\u8000\uab69\u8000\uab70"+
+ "\u8000\uabe2\u8000\uac00\u8000\ud7a3\u8000\ud7b0\u8000\ud7c6\u8000\ud7cb"+
+ "\u8000\ud7fb\u8000\uf900\u8000\ufa6d\u8000\ufa70\u8000\ufad9\u8000\ufb00"+
+ "\u8000\ufb06\u8000\ufb13\u8000\ufb17\u8000\ufb1d\u8000\ufb1d\u8000\ufb1f"+
+ "\u8000\ufb28\u8000\ufb2a\u8000\ufb36\u8000\ufb38\u8000\ufb3c\u8000\ufb3e"+
+ "\u8000\ufb3e\u8000\ufb40\u8000\ufb41\u8000\ufb43\u8000\ufb44\u8000\ufb46"+
+ "\u8000\ufbb1\u8000\ufbd3\u8000\ufd3d\u8000\ufd50\u8000\ufd8f\u8000\ufd92"+
+ "\u8000\ufdc7\u8000\ufdf0\u8000\ufdfb\u8000\ufe70\u8000\ufe74\u8000\ufe76"+
+ "\u8000\ufefc\u8000\uff21\u8000\uff3a\u8000\uff41\u8000\uff5a\u8000\uff66"+
+ "\u8000\uffbe\u8000\uffc2\u8000\uffc7\u8000\uffca\u8000\uffcf\u8000\uffd2"+
+ "\u8000\uffd7\u8000\uffda\u8000\uffdc\u8001\u0000\u8001\u000b\u8001\r\u8001"+
+ "&\u8001(\u8001:\u8001<\u8001=\u8001?\u8001M\u8001P\u8001]\u8001\u0080"+
+ "\u8001\u00fa\u8001\u0280\u8001\u029c\u8001\u02a0\u8001\u02d0\u8001\u0300"+
+ "\u8001\u031f\u8001\u032d\u8001\u0340\u8001\u0342\u8001\u0349\u8001\u0350"+
+ "\u8001\u0375\u8001\u0380\u8001\u039d\u8001\u03a0\u8001\u03c3\u8001\u03c8"+
+ "\u8001\u03cf\u8001\u0400\u8001\u049d\u8001\u04b0\u8001\u04d3\u8001\u04d8"+
+ "\u8001\u04fb\u8001\u0500\u8001\u0527\u8001\u0530\u8001\u0563\u8001\u0570"+
+ "\u8001\u057a\u8001\u057c\u8001\u058a\u8001\u058c\u8001\u0592\u8001\u0594"+
+ "\u8001\u0595\u8001\u0597\u8001\u05a1\u8001\u05a3\u8001\u05b1\u8001\u05b3"+
+ "\u8001\u05b9\u8001\u05bb\u8001\u05bc\u8001\u0600\u8001\u0736\u8001\u0740"+
+ "\u8001\u0755\u8001\u0760\u8001\u0767\u8001\u0780\u8001\u0785\u8001\u0787"+
+ "\u8001\u07b0\u8001\u07b2\u8001\u07ba\u8001\u0800\u8001\u0805\u8001\u0808"+
+ "\u8001\u0808\u8001\u080a\u8001\u0835\u8001\u0837\u8001\u0838\u8001\u083c"+
+ "\u8001\u083c\u8001\u083f\u8001\u0855\u8001\u0860\u8001\u0876\u8001\u0880"+
+ "\u8001\u089e\u8001\u08e0\u8001\u08f2\u8001\u08f4\u8001\u08f5\u8001\u0900"+
+ "\u8001\u0915\u8001\u0920\u8001\u0939\u8001\u0980\u8001\u09b7\u8001\u09be"+
+ "\u8001\u09bf\u8001\u0a00\u8001\u0a00\u8001\u0a10\u8001\u0a13\u8001\u0a15"+
+ "\u8001\u0a17\u8001\u0a19\u8001\u0a35\u8001\u0a60\u8001\u0a7c\u8001\u0a80"+
+ "\u8001\u0a9c\u8001\u0ac0\u8001\u0ac7\u8001\u0ac9\u8001\u0ae4\u8001\u0b00"+
+ "\u8001\u0b35\u8001\u0b40\u8001\u0b55\u8001\u0b60\u8001\u0b72\u8001\u0b80"+
+ "\u8001\u0b91\u8001\u0c00\u8001\u0c48\u8001\u0c80\u8001\u0cb2\u8001\u0cc0"+
+ "\u8001\u0cf2\u8001\u0d00\u8001\u0d23\u8001\u0e80\u8001\u0ea9\u8001\u0eb0"+
+ "\u8001\u0eb1\u8001\u0f00\u8001\u0f1c\u8001\u0f27\u8001\u0f27\u8001\u0f30"+
+ "\u8001\u0f45\u8001\u0f70\u8001\u0f81\u8001\u0fb0\u8001\u0fc4\u8001\u0fe0"+
+ "\u8001\u0ff6\u8001\u1003\u8001\u1037\u8001\u1071\u8001\u1072\u8001\u1075"+
+ "\u8001\u1075\u8001\u1083\u8001\u10af\u8001\u10d0\u8001\u10e8\u8001\u1103"+
+ "\u8001\u1126\u8001\u1144\u8001\u1144\u8001\u1147\u8001\u1147\u8001\u1150"+
+ "\u8001\u1172\u8001\u1176\u8001\u1176\u8001\u1183\u8001\u11b2\u8001\u11c1"+
+ "\u8001\u11c4\u8001\u11da\u8001\u11da\u8001\u11dc\u8001\u11dc\u8001\u1200"+
+ "\u8001\u1211\u8001\u1213\u8001\u122b\u8001\u123f\u8001\u1240\u8001\u1280"+
+ "\u8001\u1286\u8001\u1288\u8001\u1288\u8001\u128a\u8001\u128d\u8001\u128f"+
+ "\u8001\u129d\u8001\u129f\u8001\u12a8\u8001\u12b0\u8001\u12de\u8001\u1305"+
+ "\u8001\u130c\u8001\u130f\u8001\u1310\u8001\u1313\u8001\u1328\u8001\u132a"+
+ "\u8001\u1330\u8001\u1332\u8001\u1333\u8001\u1335\u8001\u1339\u8001\u133d"+
+ "\u8001\u133d\u8001\u1350\u8001\u1350\u8001\u135d\u8001\u1361\u8001\u1400"+
+ "\u8001\u1434\u8001\u1447\u8001\u144a\u8001\u145f\u8001\u1461\u8001\u1480"+
+ "\u8001\u14af\u8001\u14c4\u8001\u14c5\u8001\u14c7\u8001\u14c7\u8001\u1580"+
+ "\u8001\u15ae\u8001\u15d8\u8001\u15db\u8001\u1600\u8001\u162f\u8001\u1644"+
+ "\u8001\u1644\u8001\u1680\u8001\u16aa\u8001\u16b8\u8001\u16b8\u8001\u1700"+
+ "\u8001\u171a\u8001\u1740\u8001\u1746\u8001\u1800\u8001\u182b\u8001\u18a0"+
+ "\u8001\u18df\u8001\u18ff\u8001\u1906\u8001\u1909\u8001\u1909\u8001\u190c"+
+ "\u8001\u1913\u8001\u1915\u8001\u1916\u8001\u1918\u8001\u192f\u8001\u193f"+
+ "\u8001\u193f\u8001\u1941\u8001\u1941\u8001\u19a0\u8001\u19a7\u8001\u19aa"+
+ "\u8001\u19d0\u8001\u19e1\u8001\u19e1\u8001\u19e3\u8001\u19e3\u8001\u1a00"+
+ "\u8001\u1a00\u8001\u1a0b\u8001\u1a32\u8001\u1a3a\u8001\u1a3a\u8001\u1a50"+
+ "\u8001\u1a50\u8001\u1a5c\u8001\u1a89\u8001\u1a9d\u8001\u1a9d\u8001\u1ab0"+
+ "\u8001\u1af8\u8001\u1c00\u8001\u1c08\u8001\u1c0a\u8001\u1c2e\u8001\u1c40"+
+ "\u8001\u1c40\u8001\u1c72\u8001\u1c8f\u8001\u1d00\u8001\u1d06\u8001\u1d08"+
+ "\u8001\u1d09\u8001\u1d0b\u8001\u1d30\u8001\u1d46\u8001\u1d46\u8001\u1d60"+
+ "\u8001\u1d65\u8001\u1d67\u8001\u1d68\u8001\u1d6a\u8001\u1d89\u8001\u1d98"+
+ "\u8001\u1d98\u8001\u1ee0\u8001\u1ef2\u8001\u1f02\u8001\u1f02\u8001\u1f04"+
+ "\u8001\u1f10\u8001\u1f12\u8001\u1f33\u8001\u1fb0\u8001\u1fb0\u8001\u2000"+
+ "\u8001\u2399\u8001\u2480\u8001\u2543\u8001\u2f90\u8001\u2ff0\u8001\u3000"+
+ "\u8001\u342f\u8001\u3441\u8001\u3446\u8001\u4400\u8001\u4646\u8001\u6800"+
+ "\u8001\u6a38\u8001\u6a40\u8001\u6a5e\u8001\u6a70\u8001\u6abe\u8001\u6ad0"+
+ "\u8001\u6aed\u8001\u6b00\u8001\u6b2f\u8001\u6b40\u8001\u6b43\u8001\u6b63"+
+ "\u8001\u6b77\u8001\u6b7d\u8001\u6b8f\u8001\u6e40\u8001\u6e7f\u8001\u6f00"+
+ "\u8001\u6f4a\u8001\u6f50\u8001\u6f50\u8001\u6f93\u8001\u6f9f\u8001\u6fe0"+
+ "\u8001\u6fe1\u8001\u6fe3\u8001\u6fe3\u8001\u7000\u8001\u87f7\u8001\u8800"+
+ "\u8001\u8cd5\u8001\u8d00\u8001\u8d08\u8001\uaff0\u8001\uaff3\u8001\uaff5"+
+ "\u8001\uaffb\u8001\uaffd\u8001\uaffe\u8001\ub000\u8001\ub122\u8001\ub132"+
+ "\u8001\ub132\u8001\ub150\u8001\ub152\u8001\ub155\u8001\ub155\u8001\ub164"+
+ "\u8001\ub167\u8001\ub170\u8001\ub2fb\u8001\ubc00\u8001\ubc6a\u8001\ubc70"+
+ "\u8001\ubc7c\u8001\ubc80\u8001\ubc88\u8001\ubc90\u8001\ubc99\u8001\ud400"+
+ "\u8001\ud454\u8001\ud456\u8001\ud49c\u8001\ud49e\u8001\ud49f\u8001\ud4a2"+
+ "\u8001\ud4a2\u8001\ud4a5\u8001\ud4a6\u8001\ud4a9\u8001\ud4ac\u8001\ud4ae"+
+ "\u8001\ud4b9\u8001\ud4bb\u8001\ud4bb\u8001\ud4bd\u8001\ud4c3\u8001\ud4c5"+
+ "\u8001\ud505\u8001\ud507\u8001\ud50a\u8001\ud50d\u8001\ud514\u8001\ud516"+
+ "\u8001\ud51c\u8001\ud51e\u8001\ud539\u8001\ud53b\u8001\ud53e\u8001\ud540"+
+ "\u8001\ud544\u8001\ud546\u8001\ud546\u8001\ud54a\u8001\ud550\u8001\ud552"+
+ "\u8001\ud6a5\u8001\ud6a8\u8001\ud6c0\u8001\ud6c2\u8001\ud6da\u8001\ud6dc"+
+ "\u8001\ud6fa\u8001\ud6fc\u8001\ud714\u8001\ud716\u8001\ud734\u8001\ud736"+
+ "\u8001\ud74e\u8001\ud750\u8001\ud76e\u8001\ud770\u8001\ud788\u8001\ud78a"+
+ "\u8001\ud7a8\u8001\ud7aa\u8001\ud7c2\u8001\ud7c4\u8001\ud7cb\u8001\udf00"+
+ "\u8001\udf1e\u8001\udf25\u8001\udf2a\u8001\ue030\u8001\ue06d\u8001\ue100"+
+ "\u8001\ue12c\u8001\ue137\u8001\ue13d\u8001\ue14e\u8001\ue14e\u8001\ue290"+
+ "\u8001\ue2ad\u8001\ue2c0\u8001\ue2eb\u8001\ue4d0\u8001\ue4eb\u8001\ue7e0"+
+ "\u8001\ue7e6\u8001\ue7e8\u8001\ue7eb\u8001\ue7ed\u8001\ue7ee\u8001\ue7f0"+
+ "\u8001\ue7fe\u8001\ue800\u8001\ue8c4\u8001\ue900\u8001\ue943\u8001\ue94b"+
+ "\u8001\ue94b\u8001\uee00\u8001\uee03\u8001\uee05\u8001\uee1f\u8001\uee21"+
+ "\u8001\uee22\u8001\uee24\u8001\uee24\u8001\uee27\u8001\uee27\u8001\uee29"+
+ "\u8001\uee32\u8001\uee34\u8001\uee37\u8001\uee39\u8001\uee39\u8001\uee3b"+
+ "\u8001\uee3b\u8001\uee42\u8001\uee42\u8001\uee47\u8001\uee47\u8001\uee49"+
+ "\u8001\uee49\u8001\uee4b\u8001\uee4b\u8001\uee4d\u8001\uee4f\u8001\uee51"+
+ "\u8001\uee52\u8001\uee54\u8001\uee54\u8001\uee57\u8001\uee57\u8001\uee59"+
+ "\u8001\uee59\u8001\uee5b\u8001\uee5b\u8001\uee5d\u8001\uee5d\u8001\uee5f"+
+ "\u8001\uee5f\u8001\uee61\u8001\uee62\u8001\uee64\u8001\uee64\u8001\uee67"+
+ "\u8001\uee6a\u8001\uee6c\u8001\uee72\u8001\uee74\u8001\uee77\u8001\uee79"+
+ "\u8001\uee7c\u8001\uee7e\u8001\uee7e\u8001\uee80\u8001\uee89\u8001\uee8b"+
+ "\u8001\uee9b\u8001\ueea1\u8001\ueea3\u8001\ueea5\u8001\ueea9\u8001\ueeab"+
+ "\u8001\ueebb\u8002\u0000\u8002\ua6df\u8002\ua700\u8002\ub739\u8002\ub740"+
+ "\u8002\ub81d\u8002\ub820\u8002\ucea1\u8002\uceb0\u8002\uebe0\u8002\uf800"+
+ "\u8002\ufa1d\u8003\u0000\u8003\u134a\u8003\u1350\u8003\u23af\u0006\u0000"+
+ "\n\n\r\r**//[\\\u2028\u2029\u0005\u0000\n\n\r\r//[\\\u2028\u2029\u0004"+
+ "\u0000\n\n\r\r\\]\u2028\u2029\u04b8\u0000\u0002\u0001\u0000\u0000\u0000"+
+ "\u0000\u0004\u0001\u0000\u0000\u0000\u0000\u0006\u0001\u0000\u0000\u0000"+
+ "\u0000\b\u0001\u0000\u0000\u0000\u0000\n\u0001\u0000\u0000\u0000\u0000"+
+ "\f\u0001\u0000\u0000\u0000\u0000\u000e\u0001\u0000\u0000\u0000\u0000\u0010"+
+ "\u0001\u0000\u0000\u0000\u0000\u0012\u0001\u0000\u0000\u0000\u0000\u0014"+
+ "\u0001\u0000\u0000\u0000\u0000\u0016\u0001\u0000\u0000\u0000\u0000\u0018"+
+ "\u0001\u0000\u0000\u0000\u0000\u001a\u0001\u0000\u0000\u0000\u0000\u001c"+
+ "\u0001\u0000\u0000\u0000\u0000\u001e\u0001\u0000\u0000\u0000\u0000 \u0001"+
+ "\u0000\u0000\u0000\u0000\"\u0001\u0000\u0000\u0000\u0000$\u0001\u0000"+
+ "\u0000\u0000\u0000&\u0001\u0000\u0000\u0000\u0000(\u0001\u0000\u0000\u0000"+
+ "\u0000*\u0001\u0000\u0000\u0000\u0000,\u0001\u0000\u0000\u0000\u0000."+
+ "\u0001\u0000\u0000\u0000\u00000\u0001\u0000\u0000\u0000\u00002\u0001\u0000"+
+ "\u0000\u0000\u00004\u0001\u0000\u0000\u0000\u00006\u0001\u0000\u0000\u0000"+
+ "\u00008\u0001\u0000\u0000\u0000\u0000:\u0001\u0000\u0000\u0000\u0000<"+
+ "\u0001\u0000\u0000\u0000\u0000>\u0001\u0000\u0000\u0000\u0000@\u0001\u0000"+
+ "\u0000\u0000\u0000B\u0001\u0000\u0000\u0000\u0000D\u0001\u0000\u0000\u0000"+
+ "\u0000F\u0001\u0000\u0000\u0000\u0000H\u0001\u0000\u0000\u0000\u0000J"+
+ "\u0001\u0000\u0000\u0000\u0000L\u0001\u0000\u0000\u0000\u0000N\u0001\u0000"+
+ "\u0000\u0000\u0000P\u0001\u0000\u0000\u0000\u0000R\u0001\u0000\u0000\u0000"+
+ "\u0000T\u0001\u0000\u0000\u0000\u0000V\u0001\u0000\u0000\u0000\u0000X"+
+ "\u0001\u0000\u0000\u0000\u0000Z\u0001\u0000\u0000\u0000\u0000\\\u0001"+
+ "\u0000\u0000\u0000\u0000^\u0001\u0000\u0000\u0000\u0000`\u0001\u0000\u0000"+
+ "\u0000\u0000b\u0001\u0000\u0000\u0000\u0000d\u0001\u0000\u0000\u0000\u0000"+
+ "f\u0001\u0000\u0000\u0000\u0000h\u0001\u0000\u0000\u0000\u0000j\u0001"+
+ "\u0000\u0000\u0000\u0000l\u0001\u0000\u0000\u0000\u0000n\u0001\u0000\u0000"+
+ "\u0000\u0000p\u0001\u0000\u0000\u0000\u0000r\u0001\u0000\u0000\u0000\u0000"+
+ "t\u0001\u0000\u0000\u0000\u0000v\u0001\u0000\u0000\u0000\u0000x\u0001"+
+ "\u0000\u0000\u0000\u0000z\u0001\u0000\u0000\u0000\u0000|\u0001\u0000\u0000"+
+ "\u0000\u0000~\u0001\u0000\u0000\u0000\u0000\u0080\u0001\u0000\u0000\u0000"+
+ "\u0000\u0082\u0001\u0000\u0000\u0000\u0000\u0084\u0001\u0000\u0000\u0000"+
+ "\u0000\u0086\u0001\u0000\u0000\u0000\u0000\u0088\u0001\u0000\u0000\u0000"+
+ "\u0000\u008a\u0001\u0000\u0000\u0000\u0000\u008c\u0001\u0000\u0000\u0000"+
+ "\u0000\u008e\u0001\u0000\u0000\u0000\u0000\u0090\u0001\u0000\u0000\u0000"+
+ "\u0000\u0092\u0001\u0000\u0000\u0000\u0000\u0094\u0001\u0000\u0000\u0000"+
+ "\u0000\u0096\u0001\u0000\u0000\u0000\u0000\u0098\u0001\u0000\u0000\u0000"+
+ "\u0000\u009a\u0001\u0000\u0000\u0000\u0000\u009c\u0001\u0000\u0000\u0000"+
+ "\u0000\u009e\u0001\u0000\u0000\u0000\u0000\u00a0\u0001\u0000\u0000\u0000"+
+ "\u0000\u00a2\u0001\u0000\u0000\u0000\u0000\u00a4\u0001\u0000\u0000\u0000"+
+ "\u0000\u00a6\u0001\u0000\u0000\u0000\u0000\u00a8\u0001\u0000\u0000\u0000"+
+ "\u0000\u00aa\u0001\u0000\u0000\u0000\u0000\u00ac\u0001\u0000\u0000\u0000"+
+ "\u0000\u00ae\u0001\u0000\u0000\u0000\u0000\u00b0\u0001\u0000\u0000\u0000"+
+ "\u0000\u00b2\u0001\u0000\u0000\u0000\u0000\u00b4\u0001\u0000\u0000\u0000"+
+ "\u0000\u00b6\u0001\u0000\u0000\u0000\u0000\u00b8\u0001\u0000\u0000\u0000"+
+ "\u0000\u00ba\u0001\u0000\u0000\u0000\u0000\u00bc\u0001\u0000\u0000\u0000"+
+ "\u0000\u00be\u0001\u0000\u0000\u0000\u0000\u00c0\u0001\u0000\u0000\u0000"+
+ "\u0000\u00c2\u0001\u0000\u0000\u0000\u0000\u00c4\u0001\u0000\u0000\u0000"+
+ "\u0000\u00c6\u0001\u0000\u0000\u0000\u0000\u00c8\u0001\u0000\u0000\u0000"+
+ "\u0000\u00ca\u0001\u0000\u0000\u0000\u0000\u00cc\u0001\u0000\u0000\u0000"+
+ "\u0000\u00ce\u0001\u0000\u0000\u0000\u0000\u00d0\u0001\u0000\u0000\u0000"+
+ "\u0000\u00d2\u0001\u0000\u0000\u0000\u0000\u00d4\u0001\u0000\u0000\u0000"+
+ "\u0000\u00d6\u0001\u0000\u0000\u0000\u0000\u00d8\u0001\u0000\u0000\u0000"+
+ "\u0000\u00da\u0001\u0000\u0000\u0000\u0000\u00dc\u0001\u0000\u0000\u0000"+
+ "\u0000\u00de\u0001\u0000\u0000\u0000\u0000\u00e0\u0001\u0000\u0000\u0000"+
+ "\u0000\u00e2\u0001\u0000\u0000\u0000\u0000\u00e4\u0001\u0000\u0000\u0000"+
+ "\u0000\u00e6\u0001\u0000\u0000\u0000\u0000\u00e8\u0001\u0000\u0000\u0000"+
+ "\u0000\u00ea\u0001\u0000\u0000\u0000\u0000\u00ec\u0001\u0000\u0000\u0000"+
+ "\u0000\u00ee\u0001\u0000\u0000\u0000\u0000\u00f0\u0001\u0000\u0000\u0000"+
+ "\u0000\u00f2\u0001\u0000\u0000\u0000\u0000\u00f4\u0001\u0000\u0000\u0000"+
+ "\u0000\u00f6\u0001\u0000\u0000\u0000\u0000\u00f8\u0001\u0000\u0000\u0000"+
+ "\u0000\u00fa\u0001\u0000\u0000\u0000\u0000\u00fc\u0001\u0000\u0000\u0000"+
+ "\u0000\u00fe\u0001\u0000\u0000\u0000\u0000\u0100\u0001\u0000\u0000\u0000"+
+ "\u0000\u0102\u0001\u0000\u0000\u0000\u0000\u0104\u0001\u0000\u0000\u0000"+
+ "\u0000\u0106\u0001\u0000\u0000\u0000\u0001\u0108\u0001\u0000\u0000\u0000"+
+ "\u0001\u010a\u0001\u0000\u0000\u0000\u0001\u010c\u0001\u0000\u0000\u0000"+
+ "\u0001\u010e\u0001\u0000\u0000\u0000\u0002\u0138\u0001\u0000\u0000\u0000"+
+ "\u0004\u0146\u0001\u0000\u0000\u0000\u0006\u0151\u0001\u0000\u0000\u0000"+
+ "\b\u0161\u0001\u0000\u0000\u0000\n\u0163\u0001\u0000\u0000\u0000\f\u0165"+
+ "\u0001\u0000\u0000\u0000\u000e\u0167\u0001\u0000\u0000\u0000\u0010\u0169"+
+ "\u0001\u0000\u0000\u0000\u0012\u016c\u0001\u0000\u0000\u0000\u0014\u0171"+
+ "\u0001\u0000\u0000\u0000\u0016\u0174\u0001\u0000\u0000\u0000\u0018\u0176"+
+ "\u0001\u0000\u0000\u0000\u001a\u0178\u0001\u0000\u0000\u0000\u001c\u017a"+
+ "\u0001\u0000\u0000\u0000\u001e\u017c\u0001\u0000\u0000\u0000 \u017e\u0001"+
+ "\u0000\u0000\u0000\"\u0182\u0001\u0000\u0000\u0000$\u0184\u0001\u0000"+
+ "\u0000\u0000&\u0187\u0001\u0000\u0000\u0000(\u018a\u0001\u0000\u0000\u0000"+
+ "*\u018c\u0001\u0000\u0000\u0000,\u018e\u0001\u0000\u0000\u0000.\u0190"+
+ "\u0001\u0000\u0000\u00000\u0192\u0001\u0000\u0000\u00002\u0194\u0001\u0000"+
+ "\u0000\u00004\u0196\u0001\u0000\u0000\u00006\u0198\u0001\u0000\u0000\u0000"+
+ "8\u019b\u0001\u0000\u0000\u0000:\u019e\u0001\u0000\u0000\u0000<\u01a2"+
+ "\u0001\u0000\u0000\u0000>\u01a4\u0001\u0000\u0000\u0000@\u01a6\u0001\u0000"+
+ "\u0000\u0000B\u01a9\u0001\u0000\u0000\u0000D\u01ac\u0001\u0000\u0000\u0000"+
+ "F\u01af\u0001\u0000\u0000\u0000H\u01b2\u0001\u0000\u0000\u0000J\u01b6"+
+ "\u0001\u0000\u0000\u0000L\u01ba\u0001\u0000\u0000\u0000N\u01bc\u0001\u0000"+
+ "\u0000\u0000P\u01be\u0001\u0000\u0000\u0000R\u01c0\u0001\u0000\u0000\u0000"+
+ "T\u01c3\u0001\u0000\u0000\u0000V\u01c6\u0001\u0000\u0000\u0000X\u01c9"+
+ "\u0001\u0000\u0000\u0000Z\u01cc\u0001\u0000\u0000\u0000\\\u01cf\u0001"+
+ "\u0000\u0000\u0000^\u01d2\u0001\u0000\u0000\u0000`\u01d5\u0001\u0000\u0000"+
+ "\u0000b\u01d9\u0001\u0000\u0000\u0000d\u01dd\u0001\u0000\u0000\u0000f"+
+ "\u01e2\u0001\u0000\u0000\u0000h\u01e5\u0001\u0000\u0000\u0000j\u01e8\u0001"+
+ "\u0000\u0000\u0000l\u01eb\u0001\u0000\u0000\u0000n\u01ee\u0001\u0000\u0000"+
+ "\u0000p\u01fc\u0001\u0000\u0000\u0000r\u0216\u0001\u0000\u0000\u0000t"+
+ "\u0218\u0001\u0000\u0000\u0000v\u021f\u0001\u0000\u0000\u0000x\u0227\u0001"+
+ "\u0000\u0000\u0000z\u022e\u0001\u0000\u0000\u0000|\u0235\u0001\u0000\u0000"+
+ "\u0000~\u023b\u0001\u0000\u0000\u0000\u0080\u023e\u0001\u0000\u0000\u0000"+
+ "\u0082\u0249\u0001\u0000\u0000\u0000\u0084\u0250\u0001\u0000\u0000\u0000"+
+ "\u0086\u0255\u0001\u0000\u0000\u0000\u0088\u025a\u0001\u0000\u0000\u0000"+
+ "\u008a\u025e\u0001\u0000\u0000\u0000\u008c\u0262\u0001\u0000\u0000\u0000"+
+ "\u008e\u0268\u0001\u0000\u0000\u0000\u0090\u0270\u0001\u0000\u0000\u0000"+
+ "\u0092\u0277\u0001\u0000\u0000\u0000\u0094\u027c\u0001\u0000\u0000\u0000"+
+ "\u0096\u0285\u0001\u0000\u0000\u0000\u0098\u0289\u0001\u0000\u0000\u0000"+
+ "\u009a\u0290\u0001\u0000\u0000\u0000\u009c\u0296\u0001\u0000\u0000\u0000"+
+ "\u009e\u029f\u0001\u0000\u0000\u0000\u00a0\u02a8\u0001\u0000\u0000\u0000"+
+ "\u00a2\u02ad\u0001\u0000\u0000\u0000\u00a4\u02b2\u0001\u0000\u0000\u0000"+
+ "\u00a6\u02ba\u0001\u0000\u0000\u0000\u00a8\u02bd\u0001\u0000\u0000\u0000"+
+ "\u00aa\u02c3\u0001\u0000\u0000\u0000\u00ac\u02ca\u0001\u0000\u0000\u0000"+
+ "\u00ae\u02cd\u0001\u0000\u0000\u0000\u00b0\u02d1\u0001\u0000\u0000\u0000"+
+ "\u00b2\u02d4\u0001\u0000\u0000\u0000\u00b4\u02d9\u0001\u0000\u0000\u0000"+
+ "\u00b6\u02e2\u0001\u0000\u0000\u0000\u00b8\u02e8\u0001\u0000\u0000\u0000"+
+ "\u00ba\u02ee\u0001\u0000\u0000\u0000\u00bc\u02f3\u0001\u0000\u0000\u0000"+
+ "\u00be\u02fb\u0001\u0000\u0000\u0000\u00c0\u0301\u0001\u0000\u0000\u0000"+
+ "\u00c2\u0307\u0001\u0000\u0000\u0000\u00c4\u030e\u0001\u0000\u0000\u0000"+
+ "\u00c6\u0315\u0001\u0000\u0000\u0000\u00c8\u0320\u0001\u0000\u0000\u0000"+
+ "\u00ca\u0324\u0001\u0000\u0000\u0000\u00cc\u032c\u0001\u0000\u0000\u0000"+
+ "\u00ce\u0333\u0001\u0000\u0000\u0000\u00d0\u033d\u0001\u0000\u0000\u0000"+
+ "\u00d2\u0345\u0001\u0000\u0000\u0000\u00d4\u034f\u0001\u0000\u0000\u0000"+
+ "\u00d6\u0356\u0001\u0000\u0000\u0000\u00d8\u035c\u0001\u0000\u0000\u0000"+
+ "\u00da\u0360\u0001\u0000\u0000\u0000\u00dc\u0367\u0001\u0000\u0000\u0000"+
+ "\u00de\u036f\u0001\u0000\u0000\u0000\u00e0\u0376\u0001\u0000\u0000\u0000"+
+ "\u00e2\u037d\u0001\u0000\u0000\u0000\u00e4\u0382\u0001\u0000\u0000\u0000"+
+ "\u00e6\u0386\u0001\u0000\u0000\u0000\u00e8\u038a\u0001\u0000\u0000\u0000"+
+ "\u00ea\u0396\u0001\u0000\u0000\u0000\u00ec\u03a0\u0001\u0000\u0000\u0000"+
+ "\u00ee\u03a8\u0001\u0000\u0000\u0000\u00f0\u03af\u0001\u0000\u0000\u0000"+
+ "\u00f2\u03b7\u0001\u0000\u0000\u0000\u00f4\u03c0\u0001\u0000\u0000\u0000"+
+ "\u00f6\u03c3\u0001\u0000\u0000\u0000\u00f8\u03c5\u0001\u0000\u0000\u0000"+
+ "\u00fa\u03dc\u0001\u0000\u0000\u0000\u00fc\u03e0\u0001\u0000\u0000\u0000"+
+ "\u00fe\u03e6\u0001\u0000\u0000\u0000\u0100\u03ec\u0001\u0000\u0000\u0000"+
+ "\u0102\u03f0\u0001\u0000\u0000\u0000\u0104\u0401\u0001\u0000\u0000\u0000"+
+ "\u0106\u0417\u0001\u0000\u0000\u0000\u0108\u041b\u0001\u0000\u0000\u0000"+
+ "\u010a\u041e\u0001\u0000\u0000\u0000\u010c\u0424\u0001\u0000\u0000\u0000"+
+ "\u010e\u042b\u0001\u0000\u0000\u0000\u0110\u0431\u0001\u0000\u0000\u0000"+
+ "\u0112\u0437\u0001\u0000\u0000\u0000\u0114\u043e\u0001\u0000\u0000\u0000"+
+ "\u0116\u0442\u0001\u0000\u0000\u0000\u0118\u0444\u0001\u0000\u0000\u0000"+
+ "\u011a\u0448\u0001\u0000\u0000\u0000\u011c\u044e\u0001\u0000\u0000\u0000"+
+ "\u011e\u0457\u0001\u0000\u0000\u0000\u0120\u0459\u0001\u0000\u0000\u0000"+
+ "\u0122\u045d\u0001\u0000\u0000\u0000\u0124\u045f\u0001\u0000\u0000\u0000"+
+ "\u0126\u0462\u0001\u0000\u0000\u0000\u0128\u046c\u0001\u0000\u0000\u0000"+
+ "\u012a\u046e\u0001\u0000\u0000\u0000\u012c\u0479\u0001\u0000\u0000\u0000"+
+ "\u012e\u047e\u0001\u0000\u0000\u0000\u0130\u048a\u0001\u0000\u0000\u0000"+
+ "\u0132\u0496\u0001\u0000\u0000\u0000\u0134\u049a\u0001\u0000\u0000\u0000"+
+ "\u0136\u049c\u0001\u0000\u0000\u0000\u0138\u0139\u0005/\u0000\u0000\u0139"+
+ "\u013a\u0005*\u0000\u0000\u013a\u013e\u0001\u0000\u0000\u0000\u013b\u013d"+
+ "\t\u0000\u0000\u0000\u013c\u013b\u0001\u0000\u0000\u0000\u013d\u0140\u0001"+
+ "\u0000\u0000\u0000\u013e\u013f\u0001\u0000\u0000\u0000\u013e\u013c\u0001"+
+ "\u0000\u0000\u0000\u013f\u0141\u0001\u0000\u0000\u0000\u0140\u013e\u0001"+
+ "\u0000\u0000\u0000\u0141\u0142\u0005*\u0000\u0000\u0142\u0143\u0005/\u0000"+
+ "\u0000\u0143\u0144\u0001\u0000\u0000\u0000\u0144\u0145\u0006\u0000\u0000"+
+ "\u0000\u0145\u0003\u0001\u0000\u0000\u0000\u0146\u0147\u0005/\u0000\u0000"+
+ "\u0147\u0148\u0005/\u0000\u0000\u0148\u014c\u0001\u0000\u0000\u0000\u0149"+
+ "\u014b\b\u0000\u0000\u0000\u014a\u0149\u0001\u0000\u0000\u0000\u014b\u014e"+
+ "\u0001\u0000\u0000\u0000\u014c\u014a\u0001\u0000\u0000\u0000\u014c\u014d"+
+ "\u0001\u0000\u0000\u0000\u014d\u014f\u0001\u0000\u0000\u0000\u014e\u014c"+
+ "\u0001\u0000\u0000\u0000\u014f\u0150\u0006\u0001\u0000\u0000\u0150\u0005"+
+ "\u0001\u0000\u0000\u0000\u0151\u0152\u0005/\u0000\u0000\u0152\u0156\u0003"+
+ "\u0130\u0097\u0000\u0153\u0155\u0003\u0132\u0098\u0000\u0154\u0153\u0001"+
+ "\u0000\u0000\u0000\u0155\u0158\u0001\u0000\u0000\u0000\u0156\u0154\u0001"+
+ "\u0000\u0000\u0000\u0156\u0157\u0001\u0000\u0000\u0000\u0157\u0159\u0001"+
+ "\u0000\u0000\u0000\u0158\u0156\u0001\u0000\u0000\u0000\u0159\u015a\u0004"+
+ "\u0002\u0000\u0000\u015a\u015e\u0005/\u0000\u0000\u015b\u015d\u0003\u012c"+
+ "\u0095\u0000\u015c\u015b\u0001\u0000\u0000\u0000\u015d\u0160\u0001\u0000"+
+ "\u0000\u0000\u015e\u015c\u0001\u0000\u0000\u0000\u015e\u015f\u0001\u0000"+
+ "\u0000\u0000\u015f\u0007\u0001\u0000\u0000\u0000\u0160\u015e\u0001\u0000"+
+ "\u0000\u0000\u0161\u0162\u0005[\u0000\u0000\u0162\t\u0001\u0000\u0000"+
+ "\u0000\u0163\u0164\u0005]\u0000\u0000\u0164\u000b\u0001\u0000\u0000\u0000"+
+ "\u0165\u0166\u0005(\u0000\u0000\u0166\r\u0001\u0000\u0000\u0000\u0167"+
+ "\u0168\u0005)\u0000\u0000\u0168\u000f\u0001\u0000\u0000\u0000\u0169\u016a"+
+ "\u0005{\u0000\u0000\u016a\u016b\u0006\u0007\u0001\u0000\u016b\u0011\u0001"+
+ "\u0000\u0000\u0000\u016c\u016d\u0004\b\u0001\u0000\u016d\u016e\u0005}"+
+ "\u0000\u0000\u016e\u016f\u0001\u0000\u0000\u0000\u016f\u0170\u0006\b\u0002"+
+ "\u0000\u0170\u0013\u0001\u0000\u0000\u0000\u0171\u0172\u0005}\u0000\u0000"+
+ "\u0172\u0173\u0006\t\u0003\u0000\u0173\u0015\u0001\u0000\u0000\u0000\u0174"+
+ "\u0175\u0005;\u0000\u0000\u0175\u0017\u0001\u0000\u0000\u0000\u0176\u0177"+
+ "\u0005,\u0000\u0000\u0177\u0019\u0001\u0000\u0000\u0000\u0178\u0179\u0005"+
+ "=\u0000\u0000\u0179\u001b\u0001\u0000\u0000\u0000\u017a\u017b\u0005?\u0000"+
+ "\u0000\u017b\u001d\u0001\u0000\u0000\u0000\u017c\u017d\u0005:\u0000\u0000"+
+ "\u017d\u001f\u0001\u0000\u0000\u0000\u017e\u017f\u0005.\u0000\u0000\u017f"+
+ "\u0180\u0005.\u0000\u0000\u0180\u0181\u0005.\u0000\u0000\u0181!\u0001"+
+ "\u0000\u0000\u0000\u0182\u0183\u0005.\u0000\u0000\u0183#\u0001\u0000\u0000"+
+ "\u0000\u0184\u0185\u0005+\u0000\u0000\u0185\u0186\u0005+\u0000\u0000\u0186"+
+ "%\u0001\u0000\u0000\u0000\u0187\u0188\u0005-\u0000\u0000\u0188\u0189\u0005"+
+ "-\u0000\u0000\u0189\'\u0001\u0000\u0000\u0000\u018a\u018b\u0005+\u0000"+
+ "\u0000\u018b)\u0001\u0000\u0000\u0000\u018c\u018d\u0005-\u0000\u0000\u018d"+
+ "+\u0001\u0000\u0000\u0000\u018e\u018f\u0005~\u0000\u0000\u018f-\u0001"+
+ "\u0000\u0000\u0000\u0190\u0191\u0005!\u0000\u0000\u0191/\u0001\u0000\u0000"+
+ "\u0000\u0192\u0193\u0005*\u0000\u0000\u01931\u0001\u0000\u0000\u0000\u0194"+
+ "\u0195\u0005/\u0000\u0000\u01953\u0001\u0000\u0000\u0000\u0196\u0197\u0005"+
+ "%\u0000\u0000\u01975\u0001\u0000\u0000\u0000\u0198\u0199\u0005>\u0000"+
+ "\u0000\u0199\u019a\u0005>\u0000\u0000\u019a7\u0001\u0000\u0000\u0000\u019b"+
+ "\u019c\u0005<\u0000\u0000\u019c\u019d\u0005<\u0000\u0000\u019d9\u0001"+
+ "\u0000\u0000\u0000\u019e\u019f\u0005>\u0000\u0000\u019f\u01a0\u0005>\u0000"+
+ "\u0000\u01a0\u01a1\u0005>\u0000\u0000\u01a1;\u0001\u0000\u0000\u0000\u01a2"+
+ "\u01a3\u0005<\u0000\u0000\u01a3=\u0001\u0000\u0000\u0000\u01a4\u01a5\u0005"+
+ ">\u0000\u0000\u01a5?\u0001\u0000\u0000\u0000\u01a6\u01a7\u0005<\u0000"+
+ "\u0000\u01a7\u01a8\u0005=\u0000\u0000\u01a8A\u0001\u0000\u0000\u0000\u01a9"+
+ "\u01aa\u0005>\u0000\u0000\u01aa\u01ab\u0005=\u0000\u0000\u01abC\u0001"+
+ "\u0000\u0000\u0000\u01ac\u01ad\u0005=\u0000\u0000\u01ad\u01ae\u0005=\u0000"+
+ "\u0000\u01aeE\u0001\u0000\u0000\u0000\u01af\u01b0\u0005!\u0000\u0000\u01b0"+
+ "\u01b1\u0005=\u0000\u0000\u01b1G\u0001\u0000\u0000\u0000\u01b2\u01b3\u0005"+
+ "=\u0000\u0000\u01b3\u01b4\u0005=\u0000\u0000\u01b4\u01b5\u0005=\u0000"+
+ "\u0000\u01b5I\u0001\u0000\u0000\u0000\u01b6\u01b7\u0005!\u0000\u0000\u01b7"+
+ "\u01b8\u0005=\u0000\u0000\u01b8\u01b9\u0005=\u0000\u0000\u01b9K\u0001"+
+ "\u0000\u0000\u0000\u01ba\u01bb\u0005&\u0000\u0000\u01bbM\u0001\u0000\u0000"+
+ "\u0000\u01bc\u01bd\u0005^\u0000\u0000\u01bdO\u0001\u0000\u0000\u0000\u01be"+
+ "\u01bf\u0005|\u0000\u0000\u01bfQ\u0001\u0000\u0000\u0000\u01c0\u01c1\u0005"+
+ "&\u0000\u0000\u01c1\u01c2\u0005&\u0000\u0000\u01c2S\u0001\u0000\u0000"+
+ "\u0000\u01c3\u01c4\u0005|\u0000\u0000\u01c4\u01c5\u0005|\u0000\u0000\u01c5"+
+ "U\u0001\u0000\u0000\u0000\u01c6\u01c7\u0005*\u0000\u0000\u01c7\u01c8\u0005"+
+ "=\u0000\u0000\u01c8W\u0001\u0000\u0000\u0000\u01c9\u01ca\u0005/\u0000"+
+ "\u0000\u01ca\u01cb\u0005=\u0000\u0000\u01cbY\u0001\u0000\u0000\u0000\u01cc"+
+ "\u01cd\u0005%\u0000\u0000\u01cd\u01ce\u0005=\u0000\u0000\u01ce[\u0001"+
+ "\u0000\u0000\u0000\u01cf\u01d0\u0005+\u0000\u0000\u01d0\u01d1\u0005=\u0000"+
+ "\u0000\u01d1]\u0001\u0000\u0000\u0000\u01d2\u01d3\u0005-\u0000\u0000\u01d3"+
+ "\u01d4\u0005=\u0000\u0000\u01d4_\u0001\u0000\u0000\u0000\u01d5\u01d6\u0005"+
+ "<\u0000\u0000\u01d6\u01d7\u0005<\u0000\u0000\u01d7\u01d8\u0005=\u0000"+
+ "\u0000\u01d8a\u0001\u0000\u0000\u0000\u01d9\u01da\u0005>\u0000\u0000\u01da"+
+ "\u01db\u0005>\u0000\u0000\u01db\u01dc\u0005=\u0000\u0000\u01dcc\u0001"+
+ "\u0000\u0000\u0000\u01dd\u01de\u0005>\u0000\u0000\u01de\u01df\u0005>\u0000"+
+ "\u0000\u01df\u01e0\u0005>\u0000\u0000\u01e0\u01e1\u0005=\u0000\u0000\u01e1"+
+ "e\u0001\u0000\u0000\u0000\u01e2\u01e3\u0005&\u0000\u0000\u01e3\u01e4\u0005"+
+ "=\u0000\u0000\u01e4g\u0001\u0000\u0000\u0000\u01e5\u01e6\u0005^\u0000"+
+ "\u0000\u01e6\u01e7\u0005=\u0000\u0000\u01e7i\u0001\u0000\u0000\u0000\u01e8"+
+ "\u01e9\u0005|\u0000\u0000\u01e9\u01ea\u0005=\u0000\u0000\u01eak\u0001"+
+ "\u0000\u0000\u0000\u01eb\u01ec\u0005=\u0000\u0000\u01ec\u01ed\u0005>\u0000"+
+ "\u0000\u01edm\u0001\u0000\u0000\u0000\u01ee\u01ef\u0005n\u0000\u0000\u01ef"+
+ "\u01f0\u0005u\u0000\u0000\u01f0\u01f1\u0005l\u0000\u0000\u01f1\u01f2\u0005"+
+ "l\u0000\u0000\u01f2o\u0001\u0000\u0000\u0000\u01f3\u01f4\u0005t\u0000"+
+ "\u0000\u01f4\u01f5\u0005r\u0000\u0000\u01f5\u01f6\u0005u\u0000\u0000\u01f6"+
+ "\u01fd\u0005e\u0000\u0000\u01f7\u01f8\u0005f\u0000\u0000\u01f8\u01f9\u0005"+
+ "a\u0000\u0000\u01f9\u01fa\u0005l\u0000\u0000\u01fa\u01fb\u0005s\u0000"+
+ "\u0000\u01fb\u01fd\u0005e\u0000\u0000\u01fc\u01f3\u0001\u0000\u0000\u0000"+
+ "\u01fc\u01f7\u0001\u0000\u0000\u0000\u01fdq\u0001\u0000\u0000\u0000\u01fe"+
+ "\u01ff\u0003\u0128\u0093\u0000\u01ff\u0203\u0005.\u0000\u0000\u0200\u0202"+
+ "\u0007\u0001\u0000\u0000\u0201\u0200\u0001\u0000\u0000\u0000\u0202\u0205"+
+ "\u0001\u0000\u0000\u0000\u0203\u0201\u0001\u0000\u0000\u0000\u0203\u0204"+
+ "\u0001\u0000\u0000\u0000\u0204\u0207\u0001\u0000\u0000\u0000\u0205\u0203"+
+ "\u0001\u0000\u0000\u0000\u0206\u0208\u0003\u012a\u0094\u0000\u0207\u0206"+
+ "\u0001\u0000\u0000\u0000\u0207\u0208\u0001\u0000\u0000\u0000\u0208\u0217"+
+ "\u0001\u0000\u0000\u0000\u0209\u020b\u0005.\u0000\u0000\u020a\u020c\u0007"+
+ "\u0001\u0000\u0000\u020b\u020a\u0001\u0000\u0000\u0000\u020c\u020d\u0001"+
+ "\u0000\u0000\u0000\u020d\u020b\u0001\u0000\u0000\u0000\u020d\u020e\u0001"+
+ "\u0000\u0000\u0000\u020e\u0210\u0001\u0000\u0000\u0000\u020f\u0211\u0003"+
+ "\u012a\u0094\u0000\u0210\u020f\u0001\u0000\u0000\u0000\u0210\u0211\u0001"+
+ "\u0000\u0000\u0000\u0211\u0217\u0001\u0000\u0000\u0000\u0212\u0214\u0003"+
+ "\u0128\u0093\u0000\u0213\u0215\u0003\u012a\u0094\u0000\u0214\u0213\u0001"+
+ "\u0000\u0000\u0000\u0214\u0215\u0001\u0000\u0000\u0000\u0215\u0217\u0001"+
+ "\u0000\u0000\u0000\u0216\u01fe\u0001\u0000\u0000\u0000\u0216\u0209\u0001"+
+ "\u0000\u0000\u0000\u0216\u0212\u0001\u0000\u0000\u0000\u0217s\u0001\u0000"+
+ "\u0000\u0000\u0218\u0219\u00050\u0000\u0000\u0219\u021b\u0007\u0002\u0000"+
+ "\u0000\u021a\u021c\u0003\u0126\u0092\u0000\u021b\u021a\u0001\u0000\u0000"+
+ "\u0000\u021c\u021d\u0001\u0000\u0000\u0000\u021d\u021b\u0001\u0000\u0000"+
+ "\u0000\u021d\u021e\u0001\u0000\u0000\u0000\u021eu\u0001\u0000\u0000\u0000"+
+ "\u021f\u0221\u00050\u0000\u0000\u0220\u0222\u0007\u0003\u0000\u0000\u0221"+
+ "\u0220\u0001\u0000\u0000\u0000\u0222\u0223\u0001\u0000\u0000\u0000\u0223"+
+ "\u0221\u0001\u0000\u0000\u0000\u0223\u0224\u0001\u0000\u0000\u0000\u0224"+
+ "\u0225\u0001\u0000\u0000\u0000\u0225\u0226\u0004:\u0002\u0000\u0226w\u0001"+
+ "\u0000\u0000\u0000\u0227\u0228\u00050\u0000\u0000\u0228\u022a\u0007\u0004"+
+ "\u0000\u0000\u0229\u022b\u0007\u0003\u0000\u0000\u022a\u0229\u0001\u0000"+
+ "\u0000\u0000\u022b\u022c\u0001\u0000\u0000\u0000\u022c\u022a\u0001\u0000"+
+ "\u0000\u0000\u022c\u022d\u0001\u0000\u0000\u0000\u022dy\u0001\u0000\u0000"+
+ "\u0000\u022e\u022f\u00050\u0000\u0000\u022f\u0231\u0007\u0005\u0000\u0000"+
+ "\u0230\u0232\u0007\u0006\u0000\u0000\u0231\u0230\u0001\u0000\u0000\u0000"+
+ "\u0232\u0233\u0001\u0000\u0000\u0000\u0233\u0231\u0001\u0000\u0000\u0000"+
+ "\u0233\u0234\u0001\u0000\u0000\u0000\u0234{\u0001\u0000\u0000\u0000\u0235"+
+ "\u0236\u0005b\u0000\u0000\u0236\u0237\u0005r\u0000\u0000\u0237\u0238\u0005"+
+ "e\u0000\u0000\u0238\u0239\u0005a\u0000\u0000\u0239\u023a\u0005k\u0000"+
+ "\u0000\u023a}\u0001\u0000\u0000\u0000\u023b\u023c\u0005d\u0000\u0000\u023c"+
+ "\u023d\u0005o\u0000\u0000\u023d\u007f\u0001\u0000\u0000\u0000\u023e\u023f"+
+ "\u0005i\u0000\u0000\u023f\u0240\u0005n\u0000\u0000\u0240\u0241\u0005s"+
+ "\u0000\u0000\u0241\u0242\u0005t\u0000\u0000\u0242\u0243\u0005a\u0000\u0000"+
+ "\u0243\u0244\u0005n\u0000\u0000\u0244\u0245\u0005c\u0000\u0000\u0245\u0246"+
+ "\u0005e\u0000\u0000\u0246\u0247\u0005o\u0000\u0000\u0247\u0248\u0005f"+
+ "\u0000\u0000\u0248\u0081\u0001\u0000\u0000\u0000\u0249\u024a\u0005t\u0000"+
+ "\u0000\u024a\u024b\u0005y\u0000\u0000\u024b\u024c\u0005p\u0000\u0000\u024c"+
+ "\u024d\u0005e\u0000\u0000\u024d\u024e\u0005o\u0000\u0000\u024e\u024f\u0005"+
+ "f\u0000\u0000\u024f\u0083\u0001\u0000\u0000\u0000\u0250\u0251\u0005c\u0000"+
+ "\u0000\u0251\u0252\u0005a\u0000\u0000\u0252\u0253\u0005s\u0000\u0000\u0253"+
+ "\u0254\u0005e\u0000\u0000\u0254\u0085\u0001\u0000\u0000\u0000\u0255\u0256"+
+ "\u0005e\u0000\u0000\u0256\u0257\u0005l\u0000\u0000\u0257\u0258\u0005s"+
+ "\u0000\u0000\u0258\u0259\u0005e\u0000\u0000\u0259\u0087\u0001\u0000\u0000"+
+ "\u0000\u025a\u025b\u0005n\u0000\u0000\u025b\u025c\u0005e\u0000\u0000\u025c"+
+ "\u025d\u0005w\u0000\u0000\u025d\u0089\u0001\u0000\u0000\u0000\u025e\u025f"+
+ "\u0005v\u0000\u0000\u025f\u0260\u0005a\u0000\u0000\u0260\u0261\u0005r"+
+ "\u0000\u0000\u0261\u008b\u0001\u0000\u0000\u0000\u0262\u0263\u0005c\u0000"+
+ "\u0000\u0263\u0264\u0005a\u0000\u0000\u0264\u0265\u0005t\u0000\u0000\u0265"+
+ "\u0266\u0005c\u0000\u0000\u0266\u0267\u0005h\u0000\u0000\u0267\u008d\u0001"+
+ "\u0000\u0000\u0000\u0268\u0269\u0005f\u0000\u0000\u0269\u026a\u0005i\u0000"+
+ "\u0000\u026a\u026b\u0005n\u0000\u0000\u026b\u026c\u0005a\u0000\u0000\u026c"+
+ "\u026d\u0005l\u0000\u0000\u026d\u026e\u0005l\u0000\u0000\u026e\u026f\u0005"+
+ "y\u0000\u0000\u026f\u008f\u0001\u0000\u0000\u0000\u0270\u0271\u0005r\u0000"+
+ "\u0000\u0271\u0272\u0005e\u0000\u0000\u0272\u0273\u0005t\u0000\u0000\u0273"+
+ "\u0274\u0005u\u0000\u0000\u0274\u0275\u0005r\u0000\u0000\u0275\u0276\u0005"+
+ "n\u0000\u0000\u0276\u0091\u0001\u0000\u0000\u0000\u0277\u0278\u0005v\u0000"+
+ "\u0000\u0278\u0279\u0005o\u0000\u0000\u0279\u027a\u0005i\u0000\u0000\u027a"+
+ "\u027b\u0005d\u0000\u0000\u027b\u0093\u0001\u0000\u0000\u0000\u027c\u027d"+
+ "\u0005c\u0000\u0000\u027d\u027e\u0005o\u0000\u0000\u027e\u027f\u0005n"+
+ "\u0000\u0000\u027f\u0280\u0005t\u0000\u0000\u0280\u0281\u0005i\u0000\u0000"+
+ "\u0281\u0282\u0005n\u0000\u0000\u0282\u0283\u0005u\u0000\u0000\u0283\u0284"+
+ "\u0005e\u0000\u0000\u0284\u0095\u0001\u0000\u0000\u0000\u0285\u0286\u0005"+
+ "f\u0000\u0000\u0286\u0287\u0005o\u0000\u0000\u0287\u0288\u0005r\u0000"+
+ "\u0000\u0288\u0097\u0001\u0000\u0000\u0000\u0289\u028a\u0005s\u0000\u0000"+
+ "\u028a\u028b\u0005w\u0000\u0000\u028b\u028c\u0005i\u0000\u0000\u028c\u028d"+
+ "\u0005t\u0000\u0000\u028d\u028e\u0005c\u0000\u0000\u028e\u028f\u0005h"+
+ "\u0000\u0000\u028f\u0099\u0001\u0000\u0000\u0000\u0290\u0291\u0005w\u0000"+
+ "\u0000\u0291\u0292\u0005h\u0000\u0000\u0292\u0293\u0005i\u0000\u0000\u0293"+
+ "\u0294\u0005l\u0000\u0000\u0294\u0295\u0005e\u0000\u0000\u0295\u009b\u0001"+
+ "\u0000\u0000\u0000\u0296\u0297\u0005d\u0000\u0000\u0297\u0298\u0005e\u0000"+
+ "\u0000\u0298\u0299\u0005b\u0000\u0000\u0299\u029a\u0005u\u0000\u0000\u029a"+
+ "\u029b\u0005g\u0000\u0000\u029b\u029c\u0005g\u0000\u0000\u029c\u029d\u0005"+
+ "e\u0000\u0000\u029d\u029e\u0005r\u0000\u0000\u029e\u009d\u0001\u0000\u0000"+
+ "\u0000\u029f\u02a0\u0005f\u0000\u0000\u02a0\u02a1\u0005u\u0000\u0000\u02a1"+
+ "\u02a2\u0005n\u0000\u0000\u02a2\u02a3\u0005c\u0000\u0000\u02a3\u02a4\u0005"+
+ "t\u0000\u0000\u02a4\u02a5\u0005i\u0000\u0000\u02a5\u02a6\u0005o\u0000"+
+ "\u0000\u02a6\u02a7\u0005n\u0000\u0000\u02a7\u009f\u0001\u0000\u0000\u0000"+
+ "\u02a8\u02a9\u0005t\u0000\u0000\u02a9\u02aa\u0005h\u0000\u0000\u02aa\u02ab"+
+ "\u0005i\u0000\u0000\u02ab\u02ac\u0005s\u0000\u0000\u02ac\u00a1\u0001\u0000"+
+ "\u0000\u0000\u02ad\u02ae\u0005w\u0000\u0000\u02ae\u02af\u0005i\u0000\u0000"+
+ "\u02af\u02b0\u0005t\u0000\u0000\u02b0\u02b1\u0005h\u0000\u0000\u02b1\u00a3"+
+ "\u0001\u0000\u0000\u0000\u02b2\u02b3\u0005d\u0000\u0000\u02b3\u02b4\u0005"+
+ "e\u0000\u0000\u02b4\u02b5\u0005f\u0000\u0000\u02b5\u02b6\u0005a\u0000"+
+ "\u0000\u02b6\u02b7\u0005u\u0000\u0000\u02b7\u02b8\u0005l\u0000\u0000\u02b8"+
+ "\u02b9\u0005t\u0000\u0000\u02b9\u00a5\u0001\u0000\u0000\u0000\u02ba\u02bb"+
+ "\u0005i\u0000\u0000\u02bb\u02bc\u0005f\u0000\u0000\u02bc\u00a7\u0001\u0000"+
+ "\u0000\u0000\u02bd\u02be\u0005t\u0000\u0000\u02be\u02bf\u0005h\u0000\u0000"+
+ "\u02bf\u02c0\u0005r\u0000\u0000\u02c0\u02c1\u0005o\u0000\u0000\u02c1\u02c2"+
+ "\u0005w\u0000\u0000\u02c2\u00a9\u0001\u0000\u0000\u0000\u02c3\u02c4\u0005"+
+ "d\u0000\u0000\u02c4\u02c5\u0005e\u0000\u0000\u02c5\u02c6\u0005l\u0000"+
+ "\u0000\u02c6\u02c7\u0005e\u0000\u0000\u02c7\u02c8\u0005t\u0000\u0000\u02c8"+
+ "\u02c9\u0005e\u0000\u0000\u02c9\u00ab\u0001\u0000\u0000\u0000\u02ca\u02cb"+
+ "\u0005i\u0000\u0000\u02cb\u02cc\u0005n\u0000\u0000\u02cc\u00ad\u0001\u0000"+
+ "\u0000\u0000\u02cd\u02ce\u0005t\u0000\u0000\u02ce\u02cf\u0005r\u0000\u0000"+
+ "\u02cf\u02d0\u0005y\u0000\u0000\u02d0\u00af\u0001\u0000\u0000\u0000\u02d1"+
+ "\u02d2\u0005a\u0000\u0000\u02d2\u02d3\u0005s\u0000\u0000\u02d3\u00b1\u0001"+
+ "\u0000\u0000\u0000\u02d4\u02d5\u0005f\u0000\u0000\u02d5\u02d6\u0005r\u0000"+
+ "\u0000\u02d6\u02d7\u0005o\u0000\u0000\u02d7\u02d8\u0005m\u0000\u0000\u02d8"+
+ "\u00b3\u0001\u0000\u0000\u0000\u02d9\u02da\u0005r\u0000\u0000\u02da\u02db"+
+ "\u0005e\u0000\u0000\u02db\u02dc\u0005a\u0000\u0000\u02dc\u02dd\u0005d"+
+ "\u0000\u0000\u02dd\u02de\u0005o\u0000\u0000\u02de\u02df\u0005n\u0000\u0000"+
+ "\u02df\u02e0\u0005l\u0000\u0000\u02e0\u02e1\u0005y\u0000\u0000\u02e1\u00b5"+
+ "\u0001\u0000\u0000\u0000\u02e2\u02e3\u0005a\u0000\u0000\u02e3\u02e4\u0005"+
+ "s\u0000\u0000\u02e4\u02e5\u0005y\u0000\u0000\u02e5\u02e6\u0005n\u0000"+
+ "\u0000\u02e6\u02e7\u0005c\u0000\u0000\u02e7\u00b7\u0001\u0000\u0000\u0000"+
+ "\u02e8\u02e9\u0005c\u0000\u0000\u02e9\u02ea\u0005l\u0000\u0000\u02ea\u02eb"+
+ "\u0005a\u0000\u0000\u02eb\u02ec\u0005s\u0000\u0000\u02ec\u02ed\u0005s"+
+ "\u0000\u0000\u02ed\u00b9\u0001\u0000\u0000\u0000\u02ee\u02ef\u0005e\u0000"+
+ "\u0000\u02ef\u02f0\u0005n\u0000\u0000\u02f0\u02f1\u0005u\u0000\u0000\u02f1"+
+ "\u02f2\u0005m\u0000\u0000\u02f2\u00bb\u0001\u0000\u0000\u0000\u02f3\u02f4"+
+ "\u0005e\u0000\u0000\u02f4\u02f5\u0005x\u0000\u0000\u02f5\u02f6\u0005t"+
+ "\u0000\u0000\u02f6\u02f7\u0005e\u0000\u0000\u02f7\u02f8\u0005n\u0000\u0000"+
+ "\u02f8\u02f9\u0005d\u0000\u0000\u02f9\u02fa\u0005s\u0000\u0000\u02fa\u00bd"+
+ "\u0001\u0000\u0000\u0000\u02fb\u02fc\u0005s\u0000\u0000\u02fc\u02fd\u0005"+
+ "u\u0000\u0000\u02fd\u02fe\u0005p\u0000\u0000\u02fe\u02ff\u0005e\u0000"+
+ "\u0000\u02ff\u0300\u0005r\u0000\u0000\u0300\u00bf\u0001\u0000\u0000\u0000"+
+ "\u0301\u0302\u0005c\u0000\u0000\u0302\u0303\u0005o\u0000\u0000\u0303\u0304"+
+ "\u0005n\u0000\u0000\u0304\u0305\u0005s\u0000\u0000\u0305\u0306\u0005t"+
+ "\u0000\u0000\u0306\u00c1\u0001\u0000\u0000\u0000\u0307\u0308\u0005e\u0000"+
+ "\u0000\u0308\u0309\u0005x\u0000\u0000\u0309\u030a\u0005p\u0000\u0000\u030a"+
+ "\u030b\u0005o\u0000\u0000\u030b\u030c\u0005r\u0000\u0000\u030c\u030d\u0005"+
+ "t\u0000\u0000\u030d\u00c3\u0001\u0000\u0000\u0000\u030e\u030f\u0005i\u0000"+
+ "\u0000\u030f\u0310\u0005m\u0000\u0000\u0310\u0311\u0005p\u0000\u0000\u0311"+
+ "\u0312\u0005o\u0000\u0000\u0312\u0313\u0005r\u0000\u0000\u0313\u0314\u0005"+
+ "t\u0000\u0000\u0314\u00c5\u0001\u0000\u0000\u0000\u0315\u0316\u0005i\u0000"+
+ "\u0000\u0316\u0317\u0005m\u0000\u0000\u0317\u0318\u0005p\u0000\u0000\u0318"+
+ "\u0319\u0005l\u0000\u0000\u0319\u031a\u0005e\u0000\u0000\u031a\u031b\u0005"+
+ "m\u0000\u0000\u031b\u031c\u0005e\u0000\u0000\u031c\u031d\u0005n\u0000"+
+ "\u0000\u031d\u031e\u0005t\u0000\u0000\u031e\u031f\u0005s\u0000\u0000\u031f"+
+ "\u00c7\u0001\u0000\u0000\u0000\u0320\u0321\u0005l\u0000\u0000\u0321\u0322"+
+ "\u0005e\u0000\u0000\u0322\u0323\u0005t\u0000\u0000\u0323\u00c9\u0001\u0000"+
+ "\u0000\u0000\u0324\u0325\u0005p\u0000\u0000\u0325\u0326\u0005r\u0000\u0000"+
+ "\u0326\u0327\u0005i\u0000\u0000\u0327\u0328\u0005v\u0000\u0000\u0328\u0329"+
+ "\u0005a\u0000\u0000\u0329\u032a\u0005t\u0000\u0000\u032a\u032b\u0005e"+
+ "\u0000\u0000\u032b\u00cb\u0001\u0000\u0000\u0000\u032c\u032d\u0005p\u0000"+
+ "\u0000\u032d\u032e\u0005u\u0000\u0000\u032e\u032f\u0005b\u0000\u0000\u032f"+
+ "\u0330\u0005l\u0000\u0000\u0330\u0331\u0005i\u0000\u0000\u0331\u0332\u0005"+
+ "c\u0000\u0000\u0332\u00cd\u0001\u0000\u0000\u0000\u0333\u0334\u0005i\u0000"+
+ "\u0000\u0334\u0335\u0005n\u0000\u0000\u0335\u0336\u0005t\u0000\u0000\u0336"+
+ "\u0337\u0005e\u0000\u0000\u0337\u0338\u0005r\u0000\u0000\u0338\u0339\u0005"+
+ "f\u0000\u0000\u0339\u033a\u0005a\u0000\u0000\u033a\u033b\u0005c\u0000"+
+ "\u0000\u033b\u033c\u0005e\u0000\u0000\u033c\u00cf\u0001\u0000\u0000\u0000"+
+ "\u033d\u033e\u0005p\u0000\u0000\u033e\u033f\u0005a\u0000\u0000\u033f\u0340"+
+ "\u0005c\u0000\u0000\u0340\u0341\u0005k\u0000\u0000\u0341\u0342\u0005a"+
+ "\u0000\u0000\u0342\u0343\u0005g\u0000\u0000\u0343\u0344\u0005e\u0000\u0000"+
+ "\u0344\u00d1\u0001\u0000\u0000\u0000\u0345\u0346\u0005p\u0000\u0000\u0346"+
+ "\u0347\u0005r\u0000\u0000\u0347\u0348\u0005o\u0000\u0000\u0348\u0349\u0005"+
+ "t\u0000\u0000\u0349\u034a\u0005e\u0000\u0000\u034a\u034b\u0005c\u0000"+
+ "\u0000\u034b\u034c\u0005t\u0000\u0000\u034c\u034d\u0005e\u0000\u0000\u034d"+
+ "\u034e\u0005d\u0000\u0000\u034e\u00d3\u0001\u0000\u0000\u0000\u034f\u0350"+
+ "\u0005s\u0000\u0000\u0350\u0351\u0005t\u0000\u0000\u0351\u0352\u0005a"+
+ "\u0000\u0000\u0352\u0353\u0005t\u0000\u0000\u0353\u0354\u0005i\u0000\u0000"+
+ "\u0354\u0355\u0005c\u0000\u0000\u0355\u00d5\u0001\u0000\u0000\u0000\u0356"+
+ "\u0357\u0005y\u0000\u0000\u0357\u0358\u0005i\u0000\u0000\u0358\u0359\u0005"+
+ "e\u0000\u0000\u0359\u035a\u0005l\u0000\u0000\u035a\u035b\u0005d\u0000"+
+ "\u0000\u035b\u00d7\u0001\u0000\u0000\u0000\u035c\u035d\u0005a\u0000\u0000"+
+ "\u035d\u035e\u0005n\u0000\u0000\u035e\u035f\u0005y\u0000\u0000\u035f\u00d9"+
+ "\u0001\u0000\u0000\u0000\u0360\u0361\u0005n\u0000\u0000\u0361\u0362\u0005"+
+ "u\u0000\u0000\u0362\u0363\u0005m\u0000\u0000\u0363\u0364\u0005b\u0000"+
+ "\u0000\u0364\u0365\u0005e\u0000\u0000\u0365\u0366\u0005r\u0000\u0000\u0366"+
+ "\u00db\u0001\u0000\u0000\u0000\u0367\u0368\u0005b\u0000\u0000\u0368\u0369"+
+ "\u0005o\u0000\u0000\u0369\u036a\u0005o\u0000\u0000\u036a\u036b\u0005l"+
+ "\u0000\u0000\u036b\u036c\u0005e\u0000\u0000\u036c\u036d\u0005a\u0000\u0000"+
+ "\u036d\u036e\u0005n\u0000\u0000\u036e\u00dd\u0001\u0000\u0000\u0000\u036f"+
+ "\u0370\u0005s\u0000\u0000\u0370\u0371\u0005t\u0000\u0000\u0371\u0372\u0005"+
+ "r\u0000\u0000\u0372\u0373\u0005i\u0000\u0000\u0373\u0374\u0005n\u0000"+
+ "\u0000\u0374\u0375\u0005g\u0000\u0000\u0375\u00df\u0001\u0000\u0000\u0000"+
+ "\u0376\u0377\u0005s\u0000\u0000\u0377\u0378\u0005y\u0000\u0000\u0378\u0379"+
+ "\u0005m\u0000\u0000\u0379\u037a\u0005b\u0000\u0000\u037a\u037b\u0005o"+
+ "\u0000\u0000\u037b\u037c\u0005l\u0000\u0000\u037c\u00e1\u0001\u0000\u0000"+
+ "\u0000\u037d\u037e\u0005t\u0000\u0000\u037e\u037f\u0005y\u0000\u0000\u037f"+
+ "\u0380\u0005p\u0000\u0000\u0380\u0381\u0005e\u0000\u0000\u0381\u00e3\u0001"+
+ "\u0000\u0000\u0000\u0382\u0383\u0005g\u0000\u0000\u0383\u0384\u0005e\u0000"+
+ "\u0000\u0384\u0385\u0005t\u0000\u0000\u0385\u00e5\u0001\u0000\u0000\u0000"+
+ "\u0386\u0387\u0005s\u0000\u0000\u0387\u0388\u0005e\u0000\u0000\u0388\u0389"+
+ "\u0005t\u0000\u0000\u0389\u00e7\u0001\u0000\u0000\u0000\u038a\u038b\u0005"+
+ "c\u0000\u0000\u038b\u038c\u0005o\u0000\u0000\u038c\u038d\u0005n\u0000"+
+ "\u0000\u038d\u038e\u0005s\u0000\u0000\u038e\u038f\u0005t\u0000\u0000\u038f"+
+ "\u0390\u0005r\u0000\u0000\u0390\u0391\u0005u\u0000\u0000\u0391\u0392\u0005"+
+ "c\u0000\u0000\u0392\u0393\u0005t\u0000\u0000\u0393\u0394\u0005o\u0000"+
+ "\u0000\u0394\u0395\u0005r\u0000\u0000\u0395\u00e9\u0001\u0000\u0000\u0000"+
+ "\u0396\u0397\u0005n\u0000\u0000\u0397\u0398\u0005a\u0000\u0000\u0398\u0399"+
+ "\u0005m\u0000\u0000\u0399\u039a\u0005e\u0000\u0000\u039a\u039b\u0005s"+
+ "\u0000\u0000\u039b\u039c\u0005p\u0000\u0000\u039c\u039d\u0005a\u0000\u0000"+
+ "\u039d\u039e\u0005c\u0000\u0000\u039e\u039f\u0005e\u0000\u0000\u039f\u00eb"+
+ "\u0001\u0000\u0000\u0000\u03a0\u03a1\u0005r\u0000\u0000\u03a1\u03a2\u0005"+
+ "e\u0000\u0000\u03a2\u03a3\u0005q\u0000\u0000\u03a3\u03a4\u0005u\u0000"+
+ "\u0000\u03a4\u03a5\u0005i\u0000\u0000\u03a5\u03a6\u0005r\u0000\u0000\u03a6"+
+ "\u03a7\u0005e\u0000\u0000\u03a7\u00ed\u0001\u0000\u0000\u0000\u03a8\u03a9"+
+ "\u0005m\u0000\u0000\u03a9\u03aa\u0005o\u0000\u0000\u03aa\u03ab\u0005d"+
+ "\u0000\u0000\u03ab\u03ac\u0005u\u0000\u0000\u03ac\u03ad\u0005l\u0000\u0000"+
+ "\u03ad\u03ae\u0005e\u0000\u0000\u03ae\u00ef\u0001\u0000\u0000\u0000\u03af"+
+ "\u03b0\u0005d\u0000\u0000\u03b0\u03b1\u0005e\u0000\u0000\u03b1\u03b2\u0005"+
+ "c\u0000\u0000\u03b2\u03b3\u0005l\u0000\u0000\u03b3\u03b4\u0005a\u0000"+
+ "\u0000\u03b4\u03b5\u0005r\u0000\u0000\u03b5\u03b6\u0005e\u0000\u0000\u03b6"+
+ "\u00f1\u0001\u0000\u0000\u0000\u03b7\u03b8\u0005a\u0000\u0000\u03b8\u03b9"+
+ "\u0005b\u0000\u0000\u03b9\u03ba\u0005s\u0000\u0000\u03ba\u03bb\u0005t"+
+ "\u0000\u0000\u03bb\u03bc\u0005r\u0000\u0000\u03bc\u03bd\u0005a\u0000\u0000"+
+ "\u03bd\u03be\u0005c\u0000\u0000\u03be\u03bf\u0005t\u0000\u0000\u03bf\u00f3"+
+ "\u0001\u0000\u0000\u0000\u03c0\u03c1\u0005i\u0000\u0000\u03c1\u03c2\u0005"+
+ "s\u0000\u0000\u03c2\u00f5\u0001\u0000\u0000\u0000\u03c3\u03c4\u0005@\u0000"+
+ "\u0000\u03c4\u00f7\u0001\u0000\u0000\u0000\u03c5\u03c9\u0003\u012e\u0096"+
+ "\u0000\u03c6\u03c8\u0003\u012c\u0095\u0000\u03c7\u03c6\u0001\u0000\u0000"+
+ "\u0000\u03c8\u03cb\u0001\u0000\u0000\u0000\u03c9\u03c7\u0001\u0000\u0000"+
+ "\u0000\u03c9\u03ca\u0001\u0000\u0000\u0000\u03ca\u00f9\u0001\u0000\u0000"+
+ "\u0000\u03cb\u03c9\u0001\u0000\u0000\u0000\u03cc\u03d0\u0005\"\u0000\u0000"+
+ "\u03cd\u03cf\u0003\u0110\u0087\u0000\u03ce\u03cd\u0001\u0000\u0000\u0000"+
+ "\u03cf\u03d2\u0001\u0000\u0000\u0000\u03d0\u03ce\u0001\u0000\u0000\u0000"+
+ "\u03d0\u03d1\u0001\u0000\u0000\u0000\u03d1\u03d3\u0001\u0000\u0000\u0000"+
+ "\u03d2\u03d0\u0001\u0000\u0000\u0000\u03d3\u03dd\u0005\"\u0000\u0000\u03d4"+
+ "\u03d8\u0005\'\u0000\u0000\u03d5\u03d7\u0003\u0112\u0088\u0000\u03d6\u03d5"+
+ "\u0001\u0000\u0000\u0000\u03d7\u03da\u0001\u0000\u0000\u0000\u03d8\u03d6"+
+ "\u0001\u0000\u0000\u0000\u03d8\u03d9\u0001\u0000\u0000\u0000\u03d9\u03db"+
+ "\u0001\u0000\u0000\u0000\u03da\u03d8\u0001\u0000\u0000\u0000\u03db\u03dd"+
+ "\u0005\'\u0000\u0000\u03dc\u03cc\u0001\u0000\u0000\u0000\u03dc\u03d4\u0001"+
+ "\u0000\u0000\u0000\u03dd\u03de\u0001\u0000\u0000\u0000\u03de\u03df\u0006"+
+ "|\u0004\u0000\u03df\u00fb\u0001\u0000\u0000\u0000\u03e0\u03e1\u0005`\u0000"+
+ "\u0000\u03e1\u03e2\u0006}\u0005\u0000\u03e2\u03e3\u0001\u0000\u0000\u0000"+
+ "\u03e3\u03e4\u0006}\u0006\u0000\u03e4\u00fd\u0001\u0000\u0000\u0000\u03e5"+
+ "\u03e7\u0007\u0007\u0000\u0000\u03e6\u03e5\u0001\u0000\u0000\u0000\u03e7"+
+ "\u03e8\u0001\u0000\u0000\u0000\u03e8\u03e6\u0001\u0000\u0000\u0000\u03e8"+
+ "\u03e9\u0001\u0000\u0000\u0000\u03e9\u03ea\u0001\u0000\u0000\u0000\u03ea"+
+ "\u03eb\u0006~\u0000\u0000\u03eb\u00ff\u0001\u0000\u0000\u0000\u03ec\u03ed"+
+ "\u0007\u0000\u0000\u0000\u03ed\u03ee\u0001\u0000\u0000\u0000\u03ee\u03ef"+
+ "\u0006\u007f\u0000\u0000\u03ef\u0101\u0001\u0000\u0000\u0000\u03f0\u03f1"+
+ "\u0005<\u0000\u0000\u03f1\u03f2\u0005!\u0000\u0000\u03f2\u03f3\u0005-"+
+ "\u0000\u0000\u03f3\u03f4\u0005-\u0000\u0000\u03f4\u03f8\u0001\u0000\u0000"+
+ "\u0000\u03f5\u03f7\t\u0000\u0000\u0000\u03f6\u03f5\u0001\u0000\u0000\u0000"+
+ "\u03f7\u03fa\u0001\u0000\u0000\u0000\u03f8\u03f9\u0001\u0000\u0000\u0000"+
+ "\u03f8\u03f6\u0001\u0000\u0000\u0000\u03f9\u03fb\u0001\u0000\u0000\u0000"+
+ "\u03fa\u03f8\u0001\u0000\u0000\u0000\u03fb\u03fc\u0005-\u0000\u0000\u03fc"+
+ "\u03fd\u0005-\u0000\u0000\u03fd\u03fe\u0005>\u0000\u0000\u03fe\u03ff\u0001"+
+ "\u0000\u0000\u0000\u03ff\u0400\u0006\u0080\u0000\u0000\u0400\u0103\u0001"+
+ "\u0000\u0000\u0000\u0401\u0402\u0005<\u0000\u0000\u0402\u0403\u0005!\u0000"+
+ "\u0000\u0403\u0404\u0005[\u0000\u0000\u0404\u0405\u0005C\u0000\u0000\u0405"+
+ "\u0406\u0005D\u0000\u0000\u0406\u0407\u0005A\u0000\u0000\u0407\u0408\u0005"+
+ "T\u0000\u0000\u0408\u0409\u0005A\u0000\u0000\u0409\u040a\u0005[\u0000"+
+ "\u0000\u040a\u040e\u0001\u0000\u0000\u0000\u040b\u040d\t\u0000\u0000\u0000"+
+ "\u040c\u040b\u0001\u0000\u0000\u0000\u040d\u0410\u0001\u0000\u0000\u0000"+
+ "\u040e\u040f\u0001\u0000\u0000\u0000\u040e\u040c\u0001\u0000\u0000\u0000"+
+ "\u040f\u0411\u0001\u0000\u0000\u0000\u0410\u040e\u0001\u0000\u0000\u0000"+
+ "\u0411\u0412\u0005]\u0000\u0000\u0412\u0413\u0005]\u0000\u0000\u0413\u0414"+
+ "\u0005>\u0000\u0000\u0414\u0415\u0001\u0000\u0000\u0000\u0415\u0416\u0006"+
+ "\u0081\u0000\u0000\u0416\u0105\u0001\u0000\u0000\u0000\u0417\u0418\t\u0000"+
+ "\u0000\u0000\u0418\u0419\u0001\u0000\u0000\u0000\u0419\u041a\u0006\u0082"+
+ "\u0007\u0000\u041a\u0107\u0001\u0000\u0000\u0000\u041b\u041c\u0005\\\u0000"+
+ "\u0000\u041c\u041d\t\u0000\u0000\u0000\u041d\u0109\u0001\u0000\u0000\u0000"+
+ "\u041e\u041f\u0005`\u0000\u0000\u041f\u0420\u0006\u0084\b\u0000\u0420"+
+ "\u0421\u0001\u0000\u0000\u0000\u0421\u0422\u0006\u0084\t\u0000\u0422\u0423"+
+ "\u0006\u0084\u0002\u0000\u0423\u010b\u0001\u0000\u0000\u0000\u0424\u0425"+
+ "\u0005$\u0000\u0000\u0425\u0426\u0005{\u0000\u0000\u0426\u0427\u0001\u0000"+
+ "\u0000\u0000\u0427\u0428\u0006\u0085\n\u0000\u0428\u0429\u0001\u0000\u0000"+
+ "\u0000\u0429\u042a\u0006\u0085\u000b\u0000\u042a\u010d\u0001\u0000\u0000"+
+ "\u0000\u042b\u042c\b\b\u0000\u0000\u042c\u010f\u0001\u0000\u0000\u0000"+
+ "\u042d\u0432\b\t\u0000\u0000\u042e\u042f\u0005\\\u0000\u0000\u042f\u0432"+
+ "\u0003\u0114\u0089\u0000\u0430\u0432\u0003\u0124\u0091\u0000\u0431\u042d"+
+ "\u0001\u0000\u0000\u0000\u0431\u042e\u0001\u0000\u0000\u0000\u0431\u0430"+
+ "\u0001\u0000\u0000\u0000\u0432\u0111\u0001\u0000\u0000\u0000\u0433\u0438"+
+ "\b\n\u0000\u0000\u0434\u0435\u0005\\\u0000\u0000\u0435\u0438\u0003\u0114"+
+ "\u0089\u0000\u0436\u0438\u0003\u0124\u0091\u0000\u0437\u0433\u0001\u0000"+
+ "\u0000\u0000\u0437\u0434\u0001\u0000\u0000\u0000\u0437\u0436\u0001\u0000"+
+ "\u0000\u0000\u0438\u0113\u0001\u0000\u0000\u0000\u0439\u043f\u0003\u0116"+
+ "\u008a\u0000\u043a\u043f\u00050\u0000\u0000\u043b\u043f\u0003\u0118\u008b"+
+ "\u0000\u043c\u043f\u0003\u011a\u008c\u0000\u043d\u043f\u0003\u011c\u008d"+
+ "\u0000\u043e\u0439\u0001\u0000\u0000\u0000\u043e\u043a\u0001\u0000\u0000"+
+ "\u0000\u043e\u043b\u0001\u0000\u0000\u0000\u043e\u043c\u0001\u0000\u0000"+
+ "\u0000\u043e\u043d\u0001\u0000\u0000\u0000\u043f\u0115\u0001\u0000\u0000"+
+ "\u0000\u0440\u0443\u0003\u011e\u008e\u0000\u0441\u0443\u0003\u0120\u008f"+
+ "\u0000\u0442\u0440\u0001\u0000\u0000\u0000\u0442\u0441\u0001\u0000\u0000"+
+ "\u0000\u0443\u0117\u0001\u0000\u0000\u0000\u0444\u0445\u0005x\u0000\u0000"+
+ "\u0445\u0446\u0003\u0126\u0092\u0000\u0446\u0447\u0003\u0126\u0092\u0000"+
+ "\u0447\u0119\u0001\u0000\u0000\u0000\u0448\u0449\u0005u\u0000\u0000\u0449"+
+ "\u044a\u0003\u0126\u0092\u0000\u044a\u044b\u0003\u0126\u0092\u0000\u044b"+
+ "\u044c\u0003\u0126\u0092\u0000\u044c\u044d\u0003\u0126\u0092\u0000\u044d"+
+ "\u011b\u0001\u0000\u0000\u0000\u044e\u044f\u0005u\u0000\u0000\u044f\u0451"+
+ "\u0005{\u0000\u0000\u0450\u0452\u0003\u0126\u0092\u0000\u0451\u0450\u0001"+
+ "\u0000\u0000\u0000\u0452\u0453\u0001\u0000\u0000\u0000\u0453\u0451\u0001"+
+ "\u0000\u0000\u0000\u0453\u0454\u0001\u0000\u0000\u0000\u0454\u0455\u0001"+
+ "\u0000\u0000\u0000\u0455\u0456\u0005}\u0000\u0000\u0456\u011d\u0001\u0000"+
+ "\u0000\u0000\u0457\u0458\u0007\u000b\u0000\u0000\u0458\u011f\u0001\u0000"+
+ "\u0000\u0000\u0459\u045a\b\f\u0000\u0000\u045a\u0121\u0001\u0000\u0000"+
+ "\u0000\u045b\u045e\u0003\u011e\u008e\u0000\u045c\u045e\u0007\r\u0000\u0000"+
+ "\u045d\u045b\u0001\u0000\u0000\u0000\u045d\u045c\u0001\u0000\u0000\u0000"+
+ "\u045e\u0123\u0001\u0000\u0000\u0000\u045f\u0460\u0005\\\u0000\u0000\u0460"+
+ "\u0461\u0007\u0000\u0000\u0000\u0461\u0125\u0001\u0000\u0000\u0000\u0462"+
+ "\u0463\u0007\u000e\u0000\u0000\u0463\u0127\u0001\u0000\u0000\u0000\u0464"+
+ "\u046d\u00050\u0000\u0000\u0465\u0469\u0007\u000f\u0000\u0000\u0466\u0468"+
+ "\u0007\u0001\u0000\u0000\u0467\u0466\u0001\u0000\u0000\u0000\u0468\u046b"+
+ "\u0001\u0000\u0000\u0000\u0469\u0467\u0001\u0000\u0000\u0000\u0469\u046a"+
+ "\u0001\u0000\u0000\u0000\u046a\u046d\u0001\u0000\u0000\u0000\u046b\u0469"+
+ "\u0001\u0000\u0000\u0000\u046c\u0464\u0001\u0000\u0000\u0000\u046c\u0465"+
+ "\u0001\u0000\u0000\u0000\u046d\u0129\u0001\u0000\u0000\u0000\u046e\u0470"+
+ "\u0007\u0010\u0000\u0000\u046f\u0471\u0007\u0011\u0000\u0000\u0470\u046f"+
+ "\u0001\u0000\u0000\u0000\u0470\u0471\u0001\u0000\u0000\u0000\u0471\u0473"+
+ "\u0001\u0000\u0000\u0000\u0472\u0474\u0007\u0001\u0000\u0000\u0473\u0472"+
+ "\u0001\u0000\u0000\u0000\u0474\u0475\u0001\u0000\u0000\u0000\u0475\u0473"+
+ "\u0001\u0000\u0000\u0000\u0475\u0476\u0001\u0000\u0000\u0000\u0476\u012b"+
+ "\u0001\u0000\u0000\u0000\u0477\u047a\u0003\u012e\u0096\u0000\u0478\u047a"+
+ "\u0007\u0012\u0000\u0000\u0479\u0477\u0001\u0000\u0000\u0000\u0479\u0478"+
+ "\u0001\u0000\u0000\u0000\u047a\u012d\u0001\u0000\u0000\u0000\u047b\u047f"+
+ "\u0007\u0013\u0000\u0000\u047c\u047d\u0005\\\u0000\u0000\u047d\u047f\u0003"+
+ "\u011a\u008c\u0000\u047e\u047b\u0001\u0000\u0000\u0000\u047e\u047c\u0001"+
+ "\u0000\u0000\u0000\u047f\u012f\u0001\u0000\u0000\u0000\u0480\u048b\b\u0014"+
+ "\u0000\u0000\u0481\u048b\u0003\u0136\u009a\u0000\u0482\u0486\u0005[\u0000"+
+ "\u0000\u0483\u0485\u0003\u0134\u0099\u0000\u0484\u0483\u0001\u0000\u0000"+
+ "\u0000\u0485\u0488\u0001\u0000\u0000\u0000\u0486\u0484\u0001\u0000\u0000"+
+ "\u0000\u0486\u0487\u0001\u0000\u0000\u0000\u0487\u0489\u0001\u0000\u0000"+
+ "\u0000\u0488\u0486\u0001\u0000\u0000\u0000\u0489\u048b\u0005]\u0000\u0000"+
+ "\u048a\u0480\u0001\u0000\u0000\u0000\u048a\u0481\u0001\u0000\u0000\u0000"+
+ "\u048a\u0482\u0001\u0000\u0000\u0000\u048b\u0131\u0001\u0000\u0000\u0000"+
+ "\u048c\u0497\b\u0015\u0000\u0000\u048d\u0497\u0003\u0136\u009a\u0000\u048e"+
+ "\u0492\u0005[\u0000\u0000\u048f\u0491\u0003\u0134\u0099\u0000\u0490\u048f"+
+ "\u0001\u0000\u0000\u0000\u0491\u0494\u0001\u0000\u0000\u0000\u0492\u0490"+
+ "\u0001\u0000\u0000\u0000\u0492\u0493\u0001\u0000\u0000\u0000\u0493\u0495"+
+ "\u0001\u0000\u0000\u0000\u0494\u0492\u0001\u0000\u0000\u0000\u0495\u0497"+
+ "\u0005]\u0000\u0000\u0496\u048c\u0001\u0000\u0000\u0000\u0496\u048d\u0001"+
+ "\u0000\u0000\u0000\u0496\u048e\u0001\u0000\u0000\u0000\u0497\u0133\u0001"+
+ "\u0000\u0000\u0000\u0498\u049b\b\u0016\u0000\u0000\u0499\u049b\u0003\u0136"+
+ "\u009a\u0000\u049a\u0498\u0001\u0000\u0000\u0000\u049a\u0499\u0001\u0000"+
+ "\u0000\u0000\u049b\u0135\u0001\u0000\u0000\u0000\u049c\u049d\u0005\\\u0000"+
+ "\u0000\u049d\u049e\b\u0000\u0000\u0000\u049e\u0137\u0001\u0000\u0000\u0000"+
+ ")\u0000\u0001\u013e\u014c\u0156\u015e\u01fc\u0203\u0207\u020d\u0210\u0214"+
+ "\u0216\u021d\u0223\u022c\u0233\u03c9\u03d0\u03d8\u03dc\u03e8\u03f8\u040e"+
+ "\u0431\u0437\u043e\u0442\u0453\u045d\u0469\u046c\u0470\u0475\u0479\u047e"+
+ "\u0486\u048a\u0492\u0496\u049a\f\u0000\u0001\u0000\u0001\u0007\u0000\u0004"+
+ "\u0000\u0000\u0001\t\u0001\u0001|\u0002\u0001}\u0003\u0005\u0001\u0000"+
+ "\u0000\u0002\u0000\u0001\u0084\u0004\u0007~\u0000\u0001\u0085\u0005\u0005"+
+ "\u0000\u0000";
+ 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);
+ }
+ }
+}
diff --git a/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptLexer.tokens b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptLexer.tokens
new file mode 100644
index 0000000..8679637
--- /dev/null
+++ b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptLexer.tokens
@@ -0,0 +1,247 @@
+MultiLineComment=1
+SingleLineComment=2
+RegularExpressionLiteral=3
+OpenBracket=4
+CloseBracket=5
+OpenParen=6
+CloseParen=7
+OpenBrace=8
+TemplateCloseBrace=9
+CloseBrace=10
+SemiColon=11
+Comma=12
+Assign=13
+QuestionMark=14
+Colon=15
+Ellipsis=16
+Dot=17
+PlusPlus=18
+MinusMinus=19
+Plus=20
+Minus=21
+BitNot=22
+Not=23
+Multiply=24
+Divide=25
+Modulus=26
+RightShiftArithmetic=27
+LeftShiftArithmetic=28
+RightShiftLogical=29
+LessThan=30
+MoreThan=31
+LessThanEquals=32
+GreaterThanEquals=33
+Equals_=34
+NotEquals=35
+IdentityEquals=36
+IdentityNotEquals=37
+BitAnd=38
+BitXOr=39
+BitOr=40
+And=41
+Or=42
+MultiplyAssign=43
+DivideAssign=44
+ModulusAssign=45
+PlusAssign=46
+MinusAssign=47
+LeftShiftArithmeticAssign=48
+RightShiftArithmeticAssign=49
+RightShiftLogicalAssign=50
+BitAndAssign=51
+BitXorAssign=52
+BitOrAssign=53
+ARROW=54
+NullLiteral=55
+BooleanLiteral=56
+DecimalLiteral=57
+HexIntegerLiteral=58
+OctalIntegerLiteral=59
+OctalIntegerLiteral2=60
+BinaryIntegerLiteral=61
+Break=62
+Do=63
+Instanceof=64
+Typeof=65
+Case=66
+Else=67
+New=68
+Var=69
+Catch=70
+Finally=71
+Return=72
+Void=73
+Continue=74
+For=75
+Switch=76
+While=77
+Debugger=78
+Function_=79
+This=80
+With=81
+Default=82
+If=83
+Throw=84
+Delete=85
+In=86
+Try=87
+As=88
+From=89
+ReadOnly=90
+Async=91
+Class=92
+Enum=93
+Extends=94
+Super=95
+Const=96
+Export=97
+Import=98
+Implements=99
+Let=100
+Private=101
+Public=102
+Interface=103
+Package=104
+Protected=105
+Static=106
+Yield=107
+Any=108
+Number=109
+Boolean=110
+String=111
+Symbol=112
+TypeAlias=113
+Get=114
+Set=115
+Constructor=116
+Namespace=117
+Require=118
+Module=119
+Declare=120
+Abstract=121
+Is=122
+At=123
+Identifier=124
+StringLiteral=125
+BackTick=126
+WhiteSpaces=127
+LineTerminator=128
+HtmlComment=129
+CDataComment=130
+UnexpectedCharacter=131
+TemplateStringEscapeAtom=132
+TemplateStringStartExpression=133
+TemplateStringAtom=134
+'['=4
+']'=5
+'('=6
+')'=7
+'{'=8
+'}'=10
+';'=11
+','=12
+'='=13
+'?'=14
+':'=15
+'...'=16
+'.'=17
+'++'=18
+'--'=19
+'+'=20
+'-'=21
+'~'=22
+'!'=23
+'*'=24
+'/'=25
+'%'=26
+'>>'=27
+'<<'=28
+'>>>'=29
+'<'=30
+'>'=31
+'<='=32
+'>='=33
+'=='=34
+'!='=35
+'==='=36
+'!=='=37
+'&'=38
+'^'=39
+'|'=40
+'&&'=41
+'||'=42
+'*='=43
+'/='=44
+'%='=45
+'+='=46
+'-='=47
+'<<='=48
+'>>='=49
+'>>>='=50
+'&='=51
+'^='=52
+'|='=53
+'=>'=54
+'null'=55
+'break'=62
+'do'=63
+'instanceof'=64
+'typeof'=65
+'case'=66
+'else'=67
+'new'=68
+'var'=69
+'catch'=70
+'finally'=71
+'return'=72
+'void'=73
+'continue'=74
+'for'=75
+'switch'=76
+'while'=77
+'debugger'=78
+'function'=79
+'this'=80
+'with'=81
+'default'=82
+'if'=83
+'throw'=84
+'delete'=85
+'in'=86
+'try'=87
+'as'=88
+'from'=89
+'readonly'=90
+'async'=91
+'class'=92
+'enum'=93
+'extends'=94
+'super'=95
+'const'=96
+'export'=97
+'import'=98
+'implements'=99
+'let'=100
+'private'=101
+'public'=102
+'interface'=103
+'package'=104
+'protected'=105
+'static'=106
+'yield'=107
+'any'=108
+'number'=109
+'boolean'=110
+'string'=111
+'symbol'=112
+'type'=113
+'get'=114
+'set'=115
+'constructor'=116
+'namespace'=117
+'require'=118
+'module'=119
+'declare'=120
+'abstract'=121
+'is'=122
+'@'=123
diff --git a/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParser.g4 b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParser.g4
new file mode 100644
index 0000000..6e81b63
--- /dev/null
+++ b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParser.g4
@@ -0,0 +1,854 @@
+/*
+ * The MIT License (MIT)
+ *
+ * Copyright (c) 2014 by Bart Kiers (original author) and Alexandre Vitorelli (contributor -> ported to CSharp)
+ * Copyright (c) 2017 by Ivan Kochurkin (Positive Technologies):
+ added ECMAScript 6 support, cleared and transformed to the universal grammar.
+ * Copyright (c) 2018 by Juan Alvarez (contributor -> ported to Go)
+ * Copyright (c) 2019 by Andrii Artiushok (contributor -> added TypeScript support)
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+parser grammar TypeScriptParser;
+
+options {
+ tokenVocab=TypeScriptLexer;
+ superClass=TypeScriptParserBase;
+}
+
+// SupportSyntax
+
+initializer
+ : '=' singleExpression
+ ;
+
+bindingPattern
+ : (arrayLiteral | objectLiteral)
+ ;
+
+// TypeScript SPart
+// A.1 Types
+
+typeParameters
+ : '<' typeParameterList? '>'
+ ;
+
+typeParameterList
+ : typeParameter (',' typeParameter)*
+ ;
+
+typeParameter
+ : Identifier constraint?
+ | typeParameters
+ ;
+
+constraint
+ : 'extends' type_
+ ;
+
+typeArguments
+ : '<' typeArgumentList? '>'
+ ;
+
+typeArgumentList
+ : typeArgument (',' typeArgument)*
+ ;
+
+typeArgument
+ : type_
+ ;
+
+type_
+ : unionOrIntersectionOrPrimaryType
+ | functionType
+ | constructorType
+ | typeGeneric
+ | StringLiteral
+ ;
+
+unionOrIntersectionOrPrimaryType
+ : unionOrIntersectionOrPrimaryType '|' unionOrIntersectionOrPrimaryType #Union
+ | unionOrIntersectionOrPrimaryType '&' unionOrIntersectionOrPrimaryType #Intersection
+ | primaryType #Primary
+ ;
+
+primaryType
+ : '(' type_ ')' #ParenthesizedPrimType
+ | predefinedType #PredefinedPrimType
+ | typeReference #ReferencePrimType
+ | objectType #ObjectPrimType
+ | primaryType {notLineTerminator()}? '[' ']' #ArrayPrimType
+ | '[' tupleElementTypes ']' #TuplePrimType
+ | typeQuery #QueryPrimType
+ | This #ThisPrimType
+ | typeReference Is primaryType #RedefinitionOfType
+ ;
+
+predefinedType
+ : Any
+ | Number
+ | Boolean
+ | String
+ | Symbol
+ | Void
+ ;
+
+typeReference
+ : typeName nestedTypeGeneric?
+ ;
+
+nestedTypeGeneric
+ : typeIncludeGeneric
+ | typeGeneric
+ ;
+
+// I tried recursive include, but it's not working.
+// typeGeneric
+// : '<' typeArgumentList typeGeneric?'>'
+// ;
+//
+// TODO: Fix recursive
+//
+typeGeneric
+ : '<' typeArgumentList '>'
+ ;
+
+typeIncludeGeneric
+ :'<' typeArgumentList '<' typeArgumentList ('>' bindingPattern '>' | '>>')
+ ;
+
+typeName
+ : Identifier
+ | namespaceName
+ ;
+
+objectType
+ : '{' typeBody? '}'
+ ;
+
+typeBody
+ : typeMemberList (SemiColon | ',')?
+ ;
+
+typeMemberList
+ : typeMember ((SemiColon | ',') typeMember)*
+ ;
+
+typeMember
+ : propertySignatur
+ | callSignature
+ | constructSignature
+ | indexSignature
+ | methodSignature ('=>' type_)?
+ ;
+
+arrayType
+ : primaryType {notLineTerminator()}? '[' ']'
+ ;
+
+tupleType
+ : '[' tupleElementTypes ']'
+ ;
+
+tupleElementTypes
+ : type_ (',' type_)*
+ ;
+
+functionType
+ : typeParameters? '(' parameterList? ')' '=>' type_
+ ;
+
+constructorType
+ : 'new' typeParameters? '(' parameterList? ')' '=>' type_
+ ;
+
+typeQuery
+ : 'typeof' typeQueryExpression
+ ;
+
+typeQueryExpression
+ : Identifier
+ | (identifierName '.')+ identifierName
+ ;
+
+propertySignatur
+ : ReadOnly? propertyName '?'? typeAnnotation? ('=>' type_)?
+ ;
+
+typeAnnotation
+ : ':' type_
+ ;
+
+callSignature
+ : typeParameters? '(' parameterList? ')' typeAnnotation?
+ ;
+
+parameterList
+ : restParameter
+ | parameter (',' parameter)* (',' restParameter)?
+ ;
+
+requiredParameterList
+ : requiredParameter (',' requiredParameter)*
+ ;
+
+parameter
+ : requiredParameter
+ | optionalParameter
+ ;
+
+optionalParameter
+ : decoratorList? ( accessibilityModifier? identifierOrPattern ('?' typeAnnotation? | typeAnnotation? initializer))
+ ;
+
+restParameter
+ : '...' singleExpression typeAnnotation?
+ ;
+
+requiredParameter
+ : decoratorList? accessibilityModifier? identifierOrPattern typeAnnotation?
+ ;
+
+accessibilityModifier
+ : Public
+ | Private
+ | Protected
+ ;
+
+identifierOrPattern
+ : identifierName
+ | bindingPattern
+ ;
+
+constructSignature
+ : 'new' typeParameters? '(' parameterList? ')' typeAnnotation?
+ ;
+
+indexSignature
+ : '[' Identifier ':' (Number|String) ']' typeAnnotation
+ ;
+
+methodSignature
+ : propertyName '?'? callSignature
+ ;
+
+typeAliasDeclaration
+ : 'type' Identifier typeParameters? '=' type_ SemiColon
+ ;
+
+constructorDeclaration
+ : accessibilityModifier? Constructor '(' formalParameterList? ')' ( ('{' functionBody '}') | SemiColon)?
+ ;
+
+// A.5 Interface
+
+interfaceDeclaration
+ : Export? Declare? Interface Identifier typeParameters? interfaceExtendsClause? objectType SemiColon?
+ ;
+
+interfaceExtendsClause
+ : Extends classOrInterfaceTypeList
+ ;
+
+classOrInterfaceTypeList
+ : typeReference (',' typeReference)*
+ ;
+
+// A.7 Interface
+
+enumDeclaration
+ : Const? Enum Identifier '{' enumBody? '}'
+ ;
+
+enumBody
+ : enumMemberList ','?
+ ;
+
+enumMemberList
+ : enumMember (',' enumMember)*
+ ;
+
+enumMember
+ : propertyName ('=' singleExpression)?
+ ;
+
+// A.8 Namespaces
+
+namespaceDeclaration
+ : Namespace namespaceName '{' statementList? '}'
+ ;
+
+namespaceName
+ : Identifier ('.'+ Identifier)*
+ ;
+
+importAliasDeclaration
+ : Identifier '=' namespaceName SemiColon
+ ;
+
+// Ext.2 Additions to 1.8: Decorators
+
+decoratorList
+ : decorator+ ;
+
+decorator
+ : '@' (decoratorMemberExpression | decoratorCallExpression)
+ ;
+
+decoratorMemberExpression
+ : Identifier
+ | decoratorMemberExpression '.' identifierName
+ | '(' singleExpression ')'
+ ;
+
+decoratorCallExpression
+ : decoratorMemberExpression arguments;
+
+// ECMAPart
+program
+ : sourceElements? EOF
+ ;
+
+sourceElement
+ : Export? statement
+ ;
+
+statement
+ : block
+ | importStatement
+ | exportStatement
+ | emptyStatement_
+ | abstractDeclaration //ADDED
+ | classDeclaration
+ | interfaceDeclaration //ADDED
+ | namespaceDeclaration //ADDED
+ | ifStatement
+ | iterationStatement
+ | continueStatement
+ | breakStatement
+ | returnStatement
+ | yieldStatement
+ | withStatement
+ | labelledStatement
+ | switchStatement
+ | throwStatement
+ | tryStatement
+ | debuggerStatement
+ | functionDeclaration
+ | arrowFunctionDeclaration
+ | generatorFunctionDeclaration
+ | variableStatement
+ | typeAliasDeclaration //ADDED
+ | enumDeclaration //ADDED
+ | expressionStatement
+ | Export statement
+ ;
+
+block
+ : '{' statementList? '}'
+ ;
+
+statementList
+ : statement+
+ ;
+
+abstractDeclaration
+ : Abstract (Identifier callSignature | variableStatement) eos
+ ;
+
+importStatement
+ : Import (fromBlock | importAliasDeclaration)
+ ;
+
+fromBlock
+ : (Multiply | multipleImportStatement) (As identifierName)? From StringLiteral eos
+ ;
+
+multipleImportStatement
+ : (identifierName ',')? '{' identifierName (',' identifierName)* '}'
+ ;
+
+exportStatement
+ : Export Default? (fromBlock | statement)
+ ;
+
+variableStatement
+ : bindingPattern typeAnnotation? initializer SemiColon?
+ | accessibilityModifier? varModifier? ReadOnly? variableDeclarationList SemiColon?
+ | Declare varModifier? variableDeclarationList SemiColon?
+ ;
+
+variableDeclarationList
+ : variableDeclaration (',' variableDeclaration)*
+ ;
+
+variableDeclaration
+ : ( identifierOrKeyWord | arrayLiteral | objectLiteral) typeAnnotation? singleExpression? ('=' typeParameters? singleExpression)? // ECMAScript 6: Array & Object Matching
+ ;
+
+emptyStatement_
+ : SemiColon
+ ;
+
+expressionStatement
+ : {this.notOpenBraceAndNotFunction()}? expressionSequence SemiColon?
+ ;
+
+ifStatement
+ : If '(' expressionSequence ')' statement (Else statement)?
+ ;
+
+
+iterationStatement
+ : Do statement While '(' expressionSequence ')' eos # DoStatement
+ | While '(' expressionSequence ')' statement # WhileStatement
+ | For '(' expressionSequence? SemiColon expressionSequence? SemiColon expressionSequence? ')' statement # ForStatement
+ | For '(' varModifier variableDeclarationList SemiColon expressionSequence? SemiColon expressionSequence? ')'
+ statement # ForVarStatement
+ | For '(' singleExpression (In | Identifier{this.p("of")}?) expressionSequence ')' statement # ForInStatement
+ | For '(' varModifier variableDeclaration (In | Identifier{this.p("of")}?) expressionSequence ')' statement # ForVarInStatement
+ ;
+
+varModifier
+ : Var
+ | Let
+ | Const
+ ;
+
+continueStatement
+ : Continue ({this.notLineTerminator()}? Identifier)? eos
+ ;
+
+breakStatement
+ : Break ({this.notLineTerminator()}? Identifier)? eos
+ ;
+
+returnStatement
+ : Return ({this.notLineTerminator()}? expressionSequence)? eos
+ ;
+
+yieldStatement
+ : Yield ({this.notLineTerminator()}? expressionSequence)? eos
+ ;
+
+withStatement
+ : With '(' expressionSequence ')' statement
+ ;
+
+switchStatement
+ : Switch '(' expressionSequence ')' caseBlock
+ ;
+
+caseBlock
+ : '{' caseClauses? (defaultClause caseClauses?)? '}'
+ ;
+
+caseClauses
+ : caseClause+
+ ;
+
+caseClause
+ : Case expressionSequence ':' statementList?
+ ;
+
+defaultClause
+ : Default ':' statementList?
+ ;
+
+labelledStatement
+ : Identifier ':' statement
+ ;
+
+throwStatement
+ : Throw {this.notLineTerminator()}? expressionSequence eos
+ ;
+
+tryStatement
+ : Try block (catchProduction finallyProduction? | finallyProduction)
+ ;
+
+catchProduction
+ : Catch '(' Identifier ')' block
+ ;
+
+finallyProduction
+ : Finally block
+ ;
+
+debuggerStatement
+ : Debugger eos
+ ;
+
+functionDeclaration
+ : Function_ Identifier callSignature ( ('{' functionBody '}') | SemiColon)
+ ;
+
+//Ovveride ECMA
+classDeclaration
+ : decoratorList? (Export Default?)? Abstract? Class Identifier typeParameters? classHeritage classTail
+ ;
+
+classHeritage
+ : classExtendsClause? implementsClause?
+ ;
+
+classTail
+ : '{' classElement* '}'
+ ;
+
+classExtendsClause
+ : Extends typeReference
+ ;
+
+implementsClause
+ : Implements classOrInterfaceTypeList
+ ;
+
+// Classes modified
+classElement
+ : constructorDeclaration
+ | decoratorList? propertyMemberDeclaration
+ | indexMemberDeclaration
+ | statement
+ ;
+
+propertyMemberDeclaration
+ : propertyMemberBase propertyName '?'? typeAnnotation? initializer? SemiColon # PropertyDeclarationExpression
+ | propertyMemberBase propertyName callSignature ( ('{' functionBody '}') | SemiColon) # MethodDeclarationExpression
+ | propertyMemberBase (getAccessor | setAccessor) # GetterSetterDeclarationExpression
+ | abstractDeclaration # AbstractMemberDeclaration
+ ;
+
+propertyMemberBase
+ : accessibilityModifier? Async? Static? ReadOnly?
+ ;
+
+indexMemberDeclaration
+ : indexSignature SemiColon
+ ;
+
+generatorMethod
+ : '*'? Identifier '(' formalParameterList? ')' '{' functionBody '}'
+ ;
+
+generatorFunctionDeclaration
+ : Function_ '*' Identifier? '(' formalParameterList? ')' '{' functionBody '}'
+ ;
+
+generatorBlock
+ : '{' generatorDefinition (',' generatorDefinition)* ','? '}'
+ ;
+
+generatorDefinition
+ : '*' iteratorDefinition
+ ;
+
+iteratorBlock
+ : '{' iteratorDefinition (',' iteratorDefinition)* ','? '}'
+ ;
+
+iteratorDefinition
+ : '[' singleExpression ']' '(' formalParameterList? ')' '{' functionBody '}'
+ ;
+
+formalParameterList
+ : formalParameterArg (',' formalParameterArg)* (',' lastFormalParameterArg)?
+ | lastFormalParameterArg
+ | arrayLiteral // ECMAScript 6: Parameter Context Matching
+ | objectLiteral (':' formalParameterList)? // ECMAScript 6: Parameter Context Matching
+ ;
+
+formalParameterArg
+ : decorator? accessibilityModifier? identifierOrKeyWord '?'? typeAnnotation? ('=' singleExpression)? // ECMAScript 6: Initialization
+ ;
+
+lastFormalParameterArg // ECMAScript 6: Rest Parameter
+ : Ellipsis Identifier typeAnnotation?
+ ;
+
+functionBody
+ : sourceElements?
+ ;
+
+sourceElements
+ : sourceElement+
+ ;
+
+arrayLiteral
+ : ('[' elementList? ']')
+ ;
+
+elementList
+ : arrayElement (','+ arrayElement)*
+ ;
+
+arrayElement // ECMAScript 6: Spread Operator
+ : Ellipsis? (singleExpression | Identifier) ','?
+ ;
+
+objectLiteral
+ : '{' (propertyAssignment (',' propertyAssignment)* ','?)? '}'
+ ;
+
+// MODIFIED
+propertyAssignment
+ : propertyName (':' |'=') singleExpression # PropertyExpressionAssignment
+ | '[' singleExpression ']' ':' singleExpression # ComputedPropertyExpressionAssignment
+ | getAccessor # PropertyGetter
+ | setAccessor # PropertySetter
+ | generatorMethod # MethodProperty
+ | identifierOrKeyWord # PropertyShorthand
+ | restParameter # RestParameterInObject
+ ;
+
+getAccessor
+ : getter '(' ')' typeAnnotation? '{' functionBody '}'
+ ;
+
+setAccessor
+ : setter '(' ( Identifier | bindingPattern) typeAnnotation? ')' '{' functionBody '}'
+ ;
+
+propertyName
+ : identifierName
+ | StringLiteral
+ | numericLiteral
+ ;
+
+arguments
+ : '(' (argumentList ','?)? ')'
+ ;
+
+argumentList
+ : argument (',' argument)*
+ ;
+
+argument // ECMAScript 6: Spread Operator
+ : Ellipsis? (singleExpression | Identifier)
+ ;
+
+expressionSequence
+ : singleExpression (',' singleExpression)*
+ ;
+
+functionExpressionDeclaration
+ : Function_ Identifier? '(' formalParameterList? ')' typeAnnotation? '{' functionBody '}'
+ ;
+
+singleExpression
+ : functionExpressionDeclaration # FunctionExpression
+ | arrowFunctionDeclaration # ArrowFunctionExpression // ECMAScript 6
+ | singleExpression '[' expressionSequence ']' # MemberIndexExpression
+ | singleExpression '!'? '.' identifierName nestedTypeGeneric? # MemberDotExpression
+ // Split to try `new Date()` first, then `new Date`.
+ | New singleExpression typeArguments? arguments # NewExpression
+ | New singleExpression typeArguments? # NewExpression
+ | singleExpression arguments # ArgumentsExpression
+ | singleExpression {this.notLineTerminator()}? '++' # PostIncrementExpression
+ | singleExpression {this.notLineTerminator()}? '--' # PostDecreaseExpression
+ | Delete singleExpression # DeleteExpression
+ | Void singleExpression # VoidExpression
+ | Typeof singleExpression # TypeofExpression
+ | '++' singleExpression # PreIncrementExpression
+ | '--' singleExpression # PreDecreaseExpression
+ | '+' singleExpression # UnaryPlusExpression
+ | '-' singleExpression # UnaryMinusExpression
+ | '~' singleExpression # BitNotExpression
+ | '!' singleExpression # NotExpression
+ | singleExpression ('*' | '/' | '%') singleExpression # MultiplicativeExpression
+ | singleExpression ('+' | '-') singleExpression # AdditiveExpression
+ | singleExpression ('<<' | '>>' | '>>>') singleExpression # BitShiftExpression
+ | singleExpression ('<' | '>' | '<=' | '>=') singleExpression # RelationalExpression
+ | singleExpression Instanceof singleExpression # InstanceofExpression
+ | singleExpression In singleExpression # InExpression
+ | singleExpression ('==' | '!=' | '===' | '!==') singleExpression # EqualityExpression
+ | singleExpression '&' singleExpression # BitAndExpression
+ | singleExpression '^' singleExpression # BitXOrExpression
+ | singleExpression '|' singleExpression # BitOrExpression
+ | singleExpression '&&' singleExpression # LogicalAndExpression
+ | singleExpression '||' singleExpression # LogicalOrExpression
+ | singleExpression '?' singleExpression ':' singleExpression # TernaryExpression
+ | singleExpression '=' singleExpression # AssignmentExpression
+ | singleExpression assignmentOperator singleExpression # AssignmentOperatorExpression
+ | singleExpression templateStringLiteral # TemplateStringExpression // ECMAScript 6
+ | iteratorBlock # IteratorsExpression // ECMAScript 6
+ | generatorBlock # GeneratorsExpression // ECMAScript 6
+ | generatorFunctionDeclaration # GeneratorsFunctionExpression // ECMAScript 6
+ | yieldStatement # YieldExpression // ECMAScript 6
+ | This # ThisExpression
+ | identifierName singleExpression? # IdentifierExpression
+ | Super # SuperExpression
+ | literal # LiteralExpression
+ | arrayLiteral # ArrayLiteralExpression
+ | objectLiteral # ObjectLiteralExpression
+ | '(' expressionSequence ')' # ParenthesizedExpression
+ | typeArguments expressionSequence? # GenericTypes
+ | singleExpression As asExpression # CastAsExpression
+ ;
+
+asExpression
+ : predefinedType ('[' ']')?
+ | singleExpression
+ ;
+
+arrowFunctionDeclaration
+ : Async? arrowFunctionParameters typeAnnotation? '=>' arrowFunctionBody
+ ;
+
+arrowFunctionParameters
+ : Identifier
+ | '(' formalParameterList? ')'
+ ;
+
+arrowFunctionBody
+ : singleExpression
+ | '{' functionBody '}'
+ ;
+
+assignmentOperator
+ : '*='
+ | '/='
+ | '%='
+ | '+='
+ | '-='
+ | '<<='
+ | '>>='
+ | '>>>='
+ | '&='
+ | '^='
+ | '|='
+ ;
+
+literal
+ : NullLiteral
+ | BooleanLiteral
+ | StringLiteral
+ | templateStringLiteral
+ | RegularExpressionLiteral
+ | numericLiteral
+ ;
+
+templateStringLiteral
+ : BackTick templateStringAtom* BackTick
+ ;
+
+templateStringAtom
+ : TemplateStringAtom
+ | TemplateStringStartExpression singleExpression TemplateCloseBrace
+ | TemplateStringEscapeAtom
+ ;
+
+numericLiteral
+ : DecimalLiteral
+ | HexIntegerLiteral
+ | OctalIntegerLiteral
+ | OctalIntegerLiteral2
+ | BinaryIntegerLiteral
+ ;
+
+identifierName
+ : Identifier
+ | reservedWord
+ ;
+
+identifierOrKeyWord
+ : Identifier
+ | TypeAlias
+ | Require
+ ;
+
+reservedWord
+ : keyword
+ | NullLiteral
+ | BooleanLiteral
+ ;
+
+keyword
+ : Break
+ | Do
+ | Instanceof
+ | Typeof
+ | Case
+ | Else
+ | New
+ | Var
+ | Catch
+ | Finally
+ | Return
+ | Void
+ | Continue
+ | For
+ | Switch
+ | While
+ | Debugger
+ | Function_
+ | This
+ | With
+ | Default
+ | If
+ | Throw
+ | Delete
+ | In
+ | Try
+ | ReadOnly
+ | Async
+ | From
+ | Class
+ | Enum
+ | Extends
+ | Super
+ | Const
+ | Export
+ | Import
+ | Implements
+ | Let
+ | Private
+ | Public
+ | Interface
+ | Package
+ | Protected
+ | Static
+ | Yield
+ | Get
+ | Set
+ | Require
+ | TypeAlias
+ | String
+ | Boolean
+ | Number
+ | Module
+ ;
+
+getter
+ : Get propertyName
+ ;
+
+setter
+ : Set propertyName
+ ;
+
+eos
+ : SemiColon
+ | EOF
+ | {this.lineTerminatorAhead()}?
+ | {this.closeBrace()}?
+ ;
diff --git a/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParser.interp b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParser.interp
new file mode 100644
index 0000000..1d4d372
--- /dev/null
+++ b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParser.interp
@@ -0,0 +1,423 @@
+token literal names:
+null
+null
+null
+null
+'['
+']'
+'('
+')'
+'{'
+null
+'}'
+';'
+','
+'='
+'?'
+':'
+'...'
+'.'
+'++'
+'--'
+'+'
+'-'
+'~'
+'!'
+'*'
+'/'
+'%'
+'>>'
+'<<'
+'>>>'
+'<'
+'>'
+'<='
+'>='
+'=='
+'!='
+'==='
+'!=='
+'&'
+'^'
+'|'
+'&&'
+'||'
+'*='
+'/='
+'%='
+'+='
+'-='
+'<<='
+'>>='
+'>>>='
+'&='
+'^='
+'|='
+'=>'
+'null'
+null
+null
+null
+null
+null
+null
+'break'
+'do'
+'instanceof'
+'typeof'
+'case'
+'else'
+'new'
+'var'
+'catch'
+'finally'
+'return'
+'void'
+'continue'
+'for'
+'switch'
+'while'
+'debugger'
+'function'
+'this'
+'with'
+'default'
+'if'
+'throw'
+'delete'
+'in'
+'try'
+'as'
+'from'
+'readonly'
+'async'
+'class'
+'enum'
+'extends'
+'super'
+'const'
+'export'
+'import'
+'implements'
+'let'
+'private'
+'public'
+'interface'
+'package'
+'protected'
+'static'
+'yield'
+'any'
+'number'
+'boolean'
+'string'
+'symbol'
+'type'
+'get'
+'set'
+'constructor'
+'namespace'
+'require'
+'module'
+'declare'
+'abstract'
+'is'
+'@'
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+null
+
+token symbolic names:
+null
+MultiLineComment
+SingleLineComment
+RegularExpressionLiteral
+OpenBracket
+CloseBracket
+OpenParen
+CloseParen
+OpenBrace
+TemplateCloseBrace
+CloseBrace
+SemiColon
+Comma
+Assign
+QuestionMark
+Colon
+Ellipsis
+Dot
+PlusPlus
+MinusMinus
+Plus
+Minus
+BitNot
+Not
+Multiply
+Divide
+Modulus
+RightShiftArithmetic
+LeftShiftArithmetic
+RightShiftLogical
+LessThan
+MoreThan
+LessThanEquals
+GreaterThanEquals
+Equals_
+NotEquals
+IdentityEquals
+IdentityNotEquals
+BitAnd
+BitXOr
+BitOr
+And
+Or
+MultiplyAssign
+DivideAssign
+ModulusAssign
+PlusAssign
+MinusAssign
+LeftShiftArithmeticAssign
+RightShiftArithmeticAssign
+RightShiftLogicalAssign
+BitAndAssign
+BitXorAssign
+BitOrAssign
+ARROW
+NullLiteral
+BooleanLiteral
+DecimalLiteral
+HexIntegerLiteral
+OctalIntegerLiteral
+OctalIntegerLiteral2
+BinaryIntegerLiteral
+Break
+Do
+Instanceof
+Typeof
+Case
+Else
+New
+Var
+Catch
+Finally
+Return
+Void
+Continue
+For
+Switch
+While
+Debugger
+Function_
+This
+With
+Default
+If
+Throw
+Delete
+In
+Try
+As
+From
+ReadOnly
+Async
+Class
+Enum
+Extends
+Super
+Const
+Export
+Import
+Implements
+Let
+Private
+Public
+Interface
+Package
+Protected
+Static
+Yield
+Any
+Number
+Boolean
+String
+Symbol
+TypeAlias
+Get
+Set
+Constructor
+Namespace
+Require
+Module
+Declare
+Abstract
+Is
+At
+Identifier
+StringLiteral
+BackTick
+WhiteSpaces
+LineTerminator
+HtmlComment
+CDataComment
+UnexpectedCharacter
+TemplateStringEscapeAtom
+TemplateStringStartExpression
+TemplateStringAtom
+
+rule names:
+initializer
+bindingPattern
+typeParameters
+typeParameterList
+typeParameter
+constraint
+typeArguments
+typeArgumentList
+typeArgument
+type_
+unionOrIntersectionOrPrimaryType
+primaryType
+predefinedType
+typeReference
+nestedTypeGeneric
+typeGeneric
+typeIncludeGeneric
+typeName
+objectType
+typeBody
+typeMemberList
+typeMember
+arrayType
+tupleType
+tupleElementTypes
+functionType
+constructorType
+typeQuery
+typeQueryExpression
+propertySignatur
+typeAnnotation
+callSignature
+parameterList
+requiredParameterList
+parameter
+optionalParameter
+restParameter
+requiredParameter
+accessibilityModifier
+identifierOrPattern
+constructSignature
+indexSignature
+methodSignature
+typeAliasDeclaration
+constructorDeclaration
+interfaceDeclaration
+interfaceExtendsClause
+classOrInterfaceTypeList
+enumDeclaration
+enumBody
+enumMemberList
+enumMember
+namespaceDeclaration
+namespaceName
+importAliasDeclaration
+decoratorList
+decorator
+decoratorMemberExpression
+decoratorCallExpression
+program
+sourceElement
+statement
+block
+statementList
+abstractDeclaration
+importStatement
+fromBlock
+multipleImportStatement
+exportStatement
+variableStatement
+variableDeclarationList
+variableDeclaration
+emptyStatement_
+expressionStatement
+ifStatement
+iterationStatement
+varModifier
+continueStatement
+breakStatement
+returnStatement
+yieldStatement
+withStatement
+switchStatement
+caseBlock
+caseClauses
+caseClause
+defaultClause
+labelledStatement
+throwStatement
+tryStatement
+catchProduction
+finallyProduction
+debuggerStatement
+functionDeclaration
+classDeclaration
+classHeritage
+classTail
+classExtendsClause
+implementsClause
+classElement
+propertyMemberDeclaration
+propertyMemberBase
+indexMemberDeclaration
+generatorMethod
+generatorFunctionDeclaration
+generatorBlock
+generatorDefinition
+iteratorBlock
+iteratorDefinition
+formalParameterList
+formalParameterArg
+lastFormalParameterArg
+functionBody
+sourceElements
+arrayLiteral
+elementList
+arrayElement
+objectLiteral
+propertyAssignment
+getAccessor
+setAccessor
+propertyName
+arguments
+argumentList
+argument
+expressionSequence
+functionExpressionDeclaration
+singleExpression
+asExpression
+arrowFunctionDeclaration
+arrowFunctionParameters
+arrowFunctionBody
+assignmentOperator
+literal
+templateStringLiteral
+templateStringAtom
+numericLiteral
+identifierName
+identifierOrKeyWord
+reservedWord
+keyword
+getter
+setter
+eos
+
+
+atn:
+[4, 1, 134, 1687, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, 7, 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121, 2, 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, 126, 7, 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, 130, 2, 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, 135, 7, 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, 139, 2, 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 3, 1, 294, 8, 1, 1, 2, 1, 2, 3, 2, 298, 8, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 5, 3, 305, 8, 3, 10, 3, 12, 3, 308, 9, 3, 1, 4, 1, 4, 3, 4, 312, 8, 4, 1, 4, 3, 4, 315, 8, 4, 1, 5, 1, 5, 1, 5, 1, 6, 1, 6, 3, 6, 322, 8, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 5, 7, 329, 8, 7, 10, 7, 12, 7, 332, 9, 7, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 3, 9, 341, 8, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 5, 10, 352, 8, 10, 10, 10, 12, 10, 355, 9, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 375, 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 5, 11, 381, 8, 11, 10, 11, 12, 11, 384, 9, 11, 1, 12, 1, 12, 1, 13, 1, 13, 3, 13, 390, 8, 13, 1, 14, 1, 14, 3, 14, 394, 8, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 409, 8, 16, 1, 17, 1, 17, 3, 17, 413, 8, 17, 1, 18, 1, 18, 3, 18, 417, 8, 18, 1, 18, 1, 18, 1, 19, 1, 19, 3, 19, 423, 8, 19, 1, 20, 1, 20, 1, 20, 5, 20, 428, 8, 20, 10, 20, 12, 20, 431, 9, 20, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 440, 8, 21, 3, 21, 442, 8, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 24, 1, 24, 1, 24, 5, 24, 456, 8, 24, 10, 24, 12, 24, 459, 9, 24, 1, 25, 3, 25, 462, 8, 25, 1, 25, 1, 25, 3, 25, 466, 8, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 26, 1, 26, 3, 26, 474, 8, 26, 1, 26, 1, 26, 3, 26, 478, 8, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 1, 28, 4, 28, 491, 8, 28, 11, 28, 12, 28, 492, 1, 28, 1, 28, 3, 28, 497, 8, 28, 1, 29, 3, 29, 500, 8, 29, 1, 29, 1, 29, 3, 29, 504, 8, 29, 1, 29, 3, 29, 507, 8, 29, 1, 29, 1, 29, 3, 29, 511, 8, 29, 1, 30, 1, 30, 1, 30, 1, 31, 3, 31, 517, 8, 31, 1, 31, 1, 31, 3, 31, 521, 8, 31, 1, 31, 1, 31, 3, 31, 525, 8, 31, 1, 32, 1, 32, 1, 32, 1, 32, 5, 32, 531, 8, 32, 10, 32, 12, 32, 534, 9, 32, 1, 32, 1, 32, 3, 32, 538, 8, 32, 3, 32, 540, 8, 32, 1, 33, 1, 33, 1, 33, 5, 33, 545, 8, 33, 10, 33, 12, 33, 548, 9, 33, 1, 34, 1, 34, 3, 34, 552, 8, 34, 1, 35, 3, 35, 555, 8, 35, 1, 35, 3, 35, 558, 8, 35, 1, 35, 1, 35, 1, 35, 3, 35, 563, 8, 35, 1, 35, 3, 35, 566, 8, 35, 1, 35, 3, 35, 569, 8, 35, 1, 36, 1, 36, 1, 36, 3, 36, 574, 8, 36, 1, 37, 3, 37, 577, 8, 37, 1, 37, 3, 37, 580, 8, 37, 1, 37, 1, 37, 3, 37, 584, 8, 37, 1, 38, 1, 38, 1, 39, 1, 39, 3, 39, 590, 8, 39, 1, 40, 1, 40, 3, 40, 594, 8, 40, 1, 40, 1, 40, 3, 40, 598, 8, 40, 1, 40, 1, 40, 3, 40, 602, 8, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 42, 1, 42, 3, 42, 613, 8, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 43, 3, 43, 620, 8, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 44, 3, 44, 627, 8, 44, 1, 44, 1, 44, 1, 44, 3, 44, 632, 8, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 3, 44, 640, 8, 44, 1, 45, 3, 45, 643, 8, 45, 1, 45, 3, 45, 646, 8, 45, 1, 45, 1, 45, 1, 45, 3, 45, 651, 8, 45, 1, 45, 3, 45, 654, 8, 45, 1, 45, 1, 45, 3, 45, 658, 8, 45, 1, 46, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 5, 47, 666, 8, 47, 10, 47, 12, 47, 669, 9, 47, 1, 48, 3, 48, 672, 8, 48, 1, 48, 1, 48, 1, 48, 1, 48, 3, 48, 678, 8, 48, 1, 48, 1, 48, 1, 49, 1, 49, 3, 49, 684, 8, 49, 1, 50, 1, 50, 1, 50, 5, 50, 689, 8, 50, 10, 50, 12, 50, 692, 9, 50, 1, 51, 1, 51, 1, 51, 3, 51, 697, 8, 51, 1, 52, 1, 52, 1, 52, 1, 52, 3, 52, 703, 8, 52, 1, 52, 1, 52, 1, 53, 1, 53, 4, 53, 709, 8, 53, 11, 53, 12, 53, 710, 1, 53, 5, 53, 714, 8, 53, 10, 53, 12, 53, 717, 9, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 55, 4, 55, 725, 8, 55, 11, 55, 12, 55, 726, 1, 56, 1, 56, 1, 56, 3, 56, 732, 8, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 740, 8, 57, 1, 57, 1, 57, 1, 57, 5, 57, 745, 8, 57, 10, 57, 12, 57, 748, 9, 57, 1, 58, 1, 58, 1, 58, 1, 59, 3, 59, 754, 8, 59, 1, 59, 1, 59, 1, 60, 3, 60, 759, 8, 60, 1, 60, 1, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 792, 8, 61, 1, 62, 1, 62, 3, 62, 796, 8, 62, 1, 62, 1, 62, 1, 63, 4, 63, 801, 8, 63, 11, 63, 12, 63, 802, 1, 64, 1, 64, 1, 64, 1, 64, 3, 64, 809, 8, 64, 1, 64, 1, 64, 1, 65, 1, 65, 1, 65, 3, 65, 816, 8, 65, 1, 66, 1, 66, 3, 66, 820, 8, 66, 1, 66, 1, 66, 3, 66, 824, 8, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 67, 1, 67, 1, 67, 3, 67, 833, 8, 67, 1, 67, 1, 67, 1, 67, 1, 67, 5, 67, 839, 8, 67, 10, 67, 12, 67, 842, 9, 67, 1, 67, 1, 67, 1, 68, 1, 68, 3, 68, 848, 8, 68, 1, 68, 1, 68, 3, 68, 852, 8, 68, 1, 69, 1, 69, 3, 69, 856, 8, 69, 1, 69, 1, 69, 3, 69, 860, 8, 69, 1, 69, 3, 69, 863, 8, 69, 1, 69, 3, 69, 866, 8, 69, 1, 69, 3, 69, 869, 8, 69, 1, 69, 1, 69, 3, 69, 873, 8, 69, 1, 69, 1, 69, 3, 69, 877, 8, 69, 1, 69, 1, 69, 3, 69, 881, 8, 69, 3, 69, 883, 8, 69, 1, 70, 1, 70, 1, 70, 5, 70, 888, 8, 70, 10, 70, 12, 70, 891, 9, 70, 1, 71, 1, 71, 1, 71, 3, 71, 896, 8, 71, 1, 71, 3, 71, 899, 8, 71, 1, 71, 3, 71, 902, 8, 71, 1, 71, 1, 71, 3, 71, 906, 8, 71, 1, 71, 3, 71, 909, 8, 71, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 3, 73, 916, 8, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 3, 74, 925, 8, 74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 944, 8, 75, 1, 75, 1, 75, 3, 75, 948, 8, 75, 1, 75, 1, 75, 3, 75, 952, 8, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 962, 8, 75, 1, 75, 1, 75, 3, 75, 966, 8, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 977, 8, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 990, 8, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 996, 8, 75, 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, 3, 77, 1003, 8, 77, 1, 77, 1, 77, 1, 78, 1, 78, 1, 78, 3, 78, 1010, 8, 78, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, 3, 79, 1017, 8, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 3, 80, 1024, 8, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 82, 1, 83, 1, 83, 3, 83, 1042, 8, 83, 1, 83, 1, 83, 3, 83, 1046, 8, 83, 3, 83, 1048, 8, 83, 1, 83, 1, 83, 1, 84, 4, 84, 1053, 8, 84, 11, 84, 12, 84, 1054, 1, 85, 1, 85, 1, 85, 1, 85, 3, 85, 1061, 8, 85, 1, 86, 1, 86, 1, 86, 3, 86, 1066, 8, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, 1081, 8, 89, 1, 89, 3, 89, 1084, 8, 89, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 92, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 3, 93, 1106, 8, 93, 1, 94, 3, 94, 1109, 8, 94, 1, 94, 1, 94, 3, 94, 1113, 8, 94, 3, 94, 1115, 8, 94, 1, 94, 3, 94, 1118, 8, 94, 1, 94, 1, 94, 1, 94, 3, 94, 1123, 8, 94, 1, 94, 1, 94, 1, 94, 1, 95, 3, 95, 1129, 8, 95, 1, 95, 3, 95, 1132, 8, 95, 1, 96, 1, 96, 5, 96, 1136, 8, 96, 10, 96, 12, 96, 1139, 9, 96, 1, 96, 1, 96, 1, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 3, 99, 1151, 8, 99, 1, 99, 1, 99, 1, 99, 3, 99, 1156, 8, 99, 1, 100, 1, 100, 1, 100, 3, 100, 1161, 8, 100, 1, 100, 3, 100, 1164, 8, 100, 1, 100, 3, 100, 1167, 8, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 1, 100, 3, 100, 1179, 8, 100, 1, 100, 1, 100, 1, 100, 3, 100, 1184, 8, 100, 1, 100, 3, 100, 1187, 8, 100, 1, 101, 3, 101, 1190, 8, 101, 1, 101, 3, 101, 1193, 8, 101, 1, 101, 3, 101, 1196, 8, 101, 1, 101, 3, 101, 1199, 8, 101, 1, 102, 1, 102, 1, 102, 1, 103, 3, 103, 1205, 8, 103, 1, 103, 1, 103, 1, 103, 3, 103, 1210, 8, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 104, 1, 104, 1, 104, 3, 104, 1220, 8, 104, 1, 104, 1, 104, 3, 104, 1224, 8, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 104, 1, 105, 1, 105, 1, 105, 1, 105, 5, 105, 1235, 8, 105, 10, 105, 12, 105, 1238, 9, 105, 1, 105, 3, 105, 1241, 8, 105, 1, 105, 1, 105, 1, 106, 1, 106, 1, 106, 1, 107, 1, 107, 1, 107, 1, 107, 5, 107, 1252, 8, 107, 10, 107, 12, 107, 1255, 9, 107, 1, 107, 3, 107, 1258, 8, 107, 1, 107, 1, 107, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 3, 108, 1267, 8, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 109, 1, 109, 1, 109, 5, 109, 1277, 8, 109, 10, 109, 12, 109, 1280, 9, 109, 1, 109, 1, 109, 3, 109, 1284, 8, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 3, 109, 1291, 8, 109, 3, 109, 1293, 8, 109, 1, 110, 3, 110, 1296, 8, 110, 1, 110, 3, 110, 1299, 8, 110, 1, 110, 1, 110, 3, 110, 1303, 8, 110, 1, 110, 3, 110, 1306, 8, 110, 1, 110, 1, 110, 3, 110, 1310, 8, 110, 1, 111, 1, 111, 1, 111, 3, 111, 1315, 8, 111, 1, 112, 3, 112, 1318, 8, 112, 1, 113, 4, 113, 1321, 8, 113, 11, 113, 12, 113, 1322, 1, 114, 1, 114, 3, 114, 1327, 8, 114, 1, 114, 1, 114, 1, 115, 1, 115, 4, 115, 1333, 8, 115, 11, 115, 12, 115, 1334, 1, 115, 5, 115, 1338, 8, 115, 10, 115, 12, 115, 1341, 9, 115, 1, 116, 3, 116, 1344, 8, 116, 1, 116, 1, 116, 3, 116, 1348, 8, 116, 1, 116, 3, 116, 1351, 8, 116, 1, 117, 1, 117, 1, 117, 1, 117, 5, 117, 1357, 8, 117, 10, 117, 12, 117, 1360, 9, 117, 1, 117, 3, 117, 1363, 8, 117, 3, 117, 1365, 8, 117, 1, 117, 1, 117, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 1384, 8, 118, 1, 119, 1, 119, 1, 119, 1, 119, 3, 119, 1390, 8, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 120, 1, 120, 1, 120, 1, 120, 3, 120, 1400, 8, 120, 1, 120, 3, 120, 1403, 8, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 121, 3, 121, 1413, 8, 121, 1, 122, 1, 122, 1, 122, 3, 122, 1418, 8, 122, 3, 122, 1420, 8, 122, 1, 122, 1, 122, 1, 123, 1, 123, 1, 123, 5, 123, 1427, 8, 123, 10, 123, 12, 123, 1430, 9, 123, 1, 124, 3, 124, 1433, 8, 124, 1, 124, 1, 124, 3, 124, 1437, 8, 124, 1, 125, 1, 125, 1, 125, 5, 125, 1442, 8, 125, 10, 125, 12, 125, 1445, 9, 125, 1, 126, 1, 126, 3, 126, 1449, 8, 126, 1, 126, 1, 126, 3, 126, 1453, 8, 126, 1, 126, 1, 126, 3, 126, 1457, 8, 126, 1, 126, 1, 126, 1, 126, 1, 126, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 3, 127, 1469, 8, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 3, 127, 1476, 8, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 3, 127, 1503, 8, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 3, 127, 1515, 8, 127, 3, 127, 1517, 8, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 3, 127, 1575, 8, 127, 1, 127, 1, 127, 1, 127, 3, 127, 1580, 8, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 1, 127, 5, 127, 1595, 8, 127, 10, 127, 12, 127, 1598, 9, 127, 1, 128, 1, 128, 1, 128, 3, 128, 1603, 8, 128, 1, 128, 3, 128, 1606, 8, 128, 1, 129, 3, 129, 1609, 8, 129, 1, 129, 1, 129, 3, 129, 1613, 8, 129, 1, 129, 1, 129, 1, 129, 1, 130, 1, 130, 1, 130, 3, 130, 1621, 8, 130, 1, 130, 3, 130, 1624, 8, 130, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 3, 131, 1631, 8, 131, 1, 132, 1, 132, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 3, 133, 1641, 8, 133, 1, 134, 1, 134, 5, 134, 1645, 8, 134, 10, 134, 12, 134, 1648, 9, 134, 1, 134, 1, 134, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 1, 135, 3, 135, 1658, 8, 135, 1, 136, 1, 136, 1, 137, 1, 137, 3, 137, 1664, 8, 137, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, 3, 139, 1671, 8, 139, 1, 140, 1, 140, 1, 141, 1, 141, 1, 141, 1, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 1, 143, 3, 143, 1685, 8, 143, 1, 143, 0, 4, 20, 22, 114, 254, 144, 0, 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, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, 226, 228, 230, 232, 234, 236, 238, 240, 242, 244, 246, 248, 250, 252, 254, 256, 258, 260, 262, 264, 266, 268, 270, 272, 274, 276, 278, 280, 282, 284, 286, 0, 15, 2, 0, 73, 73, 108, 112, 1, 0, 11, 12, 2, 0, 101, 102, 105, 105, 2, 0, 109, 109, 111, 111, 3, 0, 69, 69, 96, 96, 100, 100, 2, 0, 13, 13, 15, 15, 1, 0, 24, 26, 1, 0, 20, 21, 1, 0, 27, 29, 1, 0, 30, 33, 1, 0, 34, 37, 1, 0, 43, 53, 1, 0, 57, 61, 3, 0, 113, 113, 118, 118, 124, 124, 5, 0, 62, 87, 89, 107, 109, 111, 113, 115, 118, 119, 1863, 0, 288, 1, 0, 0, 0, 2, 293, 1, 0, 0, 0, 4, 295, 1, 0, 0, 0, 6, 301, 1, 0, 0, 0, 8, 314, 1, 0, 0, 0, 10, 316, 1, 0, 0, 0, 12, 319, 1, 0, 0, 0, 14, 325, 1, 0, 0, 0, 16, 333, 1, 0, 0, 0, 18, 340, 1, 0, 0, 0, 20, 342, 1, 0, 0, 0, 22, 374, 1, 0, 0, 0, 24, 385, 1, 0, 0, 0, 26, 387, 1, 0, 0, 0, 28, 393, 1, 0, 0, 0, 30, 395, 1, 0, 0, 0, 32, 399, 1, 0, 0, 0, 34, 412, 1, 0, 0, 0, 36, 414, 1, 0, 0, 0, 38, 420, 1, 0, 0, 0, 40, 424, 1, 0, 0, 0, 42, 441, 1, 0, 0, 0, 44, 443, 1, 0, 0, 0, 46, 448, 1, 0, 0, 0, 48, 452, 1, 0, 0, 0, 50, 461, 1, 0, 0, 0, 52, 471, 1, 0, 0, 0, 54, 483, 1, 0, 0, 0, 56, 496, 1, 0, 0, 0, 58, 499, 1, 0, 0, 0, 60, 512, 1, 0, 0, 0, 62, 516, 1, 0, 0, 0, 64, 539, 1, 0, 0, 0, 66, 541, 1, 0, 0, 0, 68, 551, 1, 0, 0, 0, 70, 554, 1, 0, 0, 0, 72, 570, 1, 0, 0, 0, 74, 576, 1, 0, 0, 0, 76, 585, 1, 0, 0, 0, 78, 589, 1, 0, 0, 0, 80, 591, 1, 0, 0, 0, 82, 603, 1, 0, 0, 0, 84, 610, 1, 0, 0, 0, 86, 616, 1, 0, 0, 0, 88, 626, 1, 0, 0, 0, 90, 642, 1, 0, 0, 0, 92, 659, 1, 0, 0, 0, 94, 662, 1, 0, 0, 0, 96, 671, 1, 0, 0, 0, 98, 681, 1, 0, 0, 0, 100, 685, 1, 0, 0, 0, 102, 693, 1, 0, 0, 0, 104, 698, 1, 0, 0, 0, 106, 706, 1, 0, 0, 0, 108, 718, 1, 0, 0, 0, 110, 724, 1, 0, 0, 0, 112, 728, 1, 0, 0, 0, 114, 739, 1, 0, 0, 0, 116, 749, 1, 0, 0, 0, 118, 753, 1, 0, 0, 0, 120, 758, 1, 0, 0, 0, 122, 791, 1, 0, 0, 0, 124, 793, 1, 0, 0, 0, 126, 800, 1, 0, 0, 0, 128, 804, 1, 0, 0, 0, 130, 812, 1, 0, 0, 0, 132, 819, 1, 0, 0, 0, 134, 832, 1, 0, 0, 0, 136, 845, 1, 0, 0, 0, 138, 882, 1, 0, 0, 0, 140, 884, 1, 0, 0, 0, 142, 895, 1, 0, 0, 0, 144, 910, 1, 0, 0, 0, 146, 912, 1, 0, 0, 0, 148, 917, 1, 0, 0, 0, 150, 995, 1, 0, 0, 0, 152, 997, 1, 0, 0, 0, 154, 999, 1, 0, 0, 0, 156, 1006, 1, 0, 0, 0, 158, 1013, 1, 0, 0, 0, 160, 1020, 1, 0, 0, 0, 162, 1027, 1, 0, 0, 0, 164, 1033, 1, 0, 0, 0, 166, 1039, 1, 0, 0, 0, 168, 1052, 1, 0, 0, 0, 170, 1056, 1, 0, 0, 0, 172, 1062, 1, 0, 0, 0, 174, 1067, 1, 0, 0, 0, 176, 1071, 1, 0, 0, 0, 178, 1076, 1, 0, 0, 0, 180, 1085, 1, 0, 0, 0, 182, 1091, 1, 0, 0, 0, 184, 1094, 1, 0, 0, 0, 186, 1097, 1, 0, 0, 0, 188, 1108, 1, 0, 0, 0, 190, 1128, 1, 0, 0, 0, 192, 1133, 1, 0, 0, 0, 194, 1142, 1, 0, 0, 0, 196, 1145, 1, 0, 0, 0, 198, 1155, 1, 0, 0, 0, 200, 1186, 1, 0, 0, 0, 202, 1189, 1, 0, 0, 0, 204, 1200, 1, 0, 0, 0, 206, 1204, 1, 0, 0, 0, 208, 1216, 1, 0, 0, 0, 210, 1230, 1, 0, 0, 0, 212, 1244, 1, 0, 0, 0, 214, 1247, 1, 0, 0, 0, 216, 1261, 1, 0, 0, 0, 218, 1292, 1, 0, 0, 0, 220, 1295, 1, 0, 0, 0, 222, 1311, 1, 0, 0, 0, 224, 1317, 1, 0, 0, 0, 226, 1320, 1, 0, 0, 0, 228, 1324, 1, 0, 0, 0, 230, 1330, 1, 0, 0, 0, 232, 1343, 1, 0, 0, 0, 234, 1352, 1, 0, 0, 0, 236, 1383, 1, 0, 0, 0, 238, 1385, 1, 0, 0, 0, 240, 1395, 1, 0, 0, 0, 242, 1412, 1, 0, 0, 0, 244, 1414, 1, 0, 0, 0, 246, 1423, 1, 0, 0, 0, 248, 1432, 1, 0, 0, 0, 250, 1438, 1, 0, 0, 0, 252, 1446, 1, 0, 0, 0, 254, 1516, 1, 0, 0, 0, 256, 1605, 1, 0, 0, 0, 258, 1608, 1, 0, 0, 0, 260, 1623, 1, 0, 0, 0, 262, 1630, 1, 0, 0, 0, 264, 1632, 1, 0, 0, 0, 266, 1640, 1, 0, 0, 0, 268, 1642, 1, 0, 0, 0, 270, 1657, 1, 0, 0, 0, 272, 1659, 1, 0, 0, 0, 274, 1663, 1, 0, 0, 0, 276, 1665, 1, 0, 0, 0, 278, 1670, 1, 0, 0, 0, 280, 1672, 1, 0, 0, 0, 282, 1674, 1, 0, 0, 0, 284, 1677, 1, 0, 0, 0, 286, 1684, 1, 0, 0, 0, 288, 289, 5, 13, 0, 0, 289, 290, 3, 254, 127, 0, 290, 1, 1, 0, 0, 0, 291, 294, 3, 228, 114, 0, 292, 294, 3, 234, 117, 0, 293, 291, 1, 0, 0, 0, 293, 292, 1, 0, 0, 0, 294, 3, 1, 0, 0, 0, 295, 297, 5, 30, 0, 0, 296, 298, 3, 6, 3, 0, 297, 296, 1, 0, 0, 0, 297, 298, 1, 0, 0, 0, 298, 299, 1, 0, 0, 0, 299, 300, 5, 31, 0, 0, 300, 5, 1, 0, 0, 0, 301, 306, 3, 8, 4, 0, 302, 303, 5, 12, 0, 0, 303, 305, 3, 8, 4, 0, 304, 302, 1, 0, 0, 0, 305, 308, 1, 0, 0, 0, 306, 304, 1, 0, 0, 0, 306, 307, 1, 0, 0, 0, 307, 7, 1, 0, 0, 0, 308, 306, 1, 0, 0, 0, 309, 311, 5, 124, 0, 0, 310, 312, 3, 10, 5, 0, 311, 310, 1, 0, 0, 0, 311, 312, 1, 0, 0, 0, 312, 315, 1, 0, 0, 0, 313, 315, 3, 4, 2, 0, 314, 309, 1, 0, 0, 0, 314, 313, 1, 0, 0, 0, 315, 9, 1, 0, 0, 0, 316, 317, 5, 94, 0, 0, 317, 318, 3, 18, 9, 0, 318, 11, 1, 0, 0, 0, 319, 321, 5, 30, 0, 0, 320, 322, 3, 14, 7, 0, 321, 320, 1, 0, 0, 0, 321, 322, 1, 0, 0, 0, 322, 323, 1, 0, 0, 0, 323, 324, 5, 31, 0, 0, 324, 13, 1, 0, 0, 0, 325, 330, 3, 16, 8, 0, 326, 327, 5, 12, 0, 0, 327, 329, 3, 16, 8, 0, 328, 326, 1, 0, 0, 0, 329, 332, 1, 0, 0, 0, 330, 328, 1, 0, 0, 0, 330, 331, 1, 0, 0, 0, 331, 15, 1, 0, 0, 0, 332, 330, 1, 0, 0, 0, 333, 334, 3, 18, 9, 0, 334, 17, 1, 0, 0, 0, 335, 341, 3, 20, 10, 0, 336, 341, 3, 50, 25, 0, 337, 341, 3, 52, 26, 0, 338, 341, 3, 30, 15, 0, 339, 341, 5, 125, 0, 0, 340, 335, 1, 0, 0, 0, 340, 336, 1, 0, 0, 0, 340, 337, 1, 0, 0, 0, 340, 338, 1, 0, 0, 0, 340, 339, 1, 0, 0, 0, 341, 19, 1, 0, 0, 0, 342, 343, 6, 10, -1, 0, 343, 344, 3, 22, 11, 0, 344, 353, 1, 0, 0, 0, 345, 346, 10, 3, 0, 0, 346, 347, 5, 40, 0, 0, 347, 352, 3, 20, 10, 4, 348, 349, 10, 2, 0, 0, 349, 350, 5, 38, 0, 0, 350, 352, 3, 20, 10, 3, 351, 345, 1, 0, 0, 0, 351, 348, 1, 0, 0, 0, 352, 355, 1, 0, 0, 0, 353, 351, 1, 0, 0, 0, 353, 354, 1, 0, 0, 0, 354, 21, 1, 0, 0, 0, 355, 353, 1, 0, 0, 0, 356, 357, 6, 11, -1, 0, 357, 358, 5, 6, 0, 0, 358, 359, 3, 18, 9, 0, 359, 360, 5, 7, 0, 0, 360, 375, 1, 0, 0, 0, 361, 375, 3, 24, 12, 0, 362, 375, 3, 26, 13, 0, 363, 375, 3, 36, 18, 0, 364, 365, 5, 4, 0, 0, 365, 366, 3, 48, 24, 0, 366, 367, 5, 5, 0, 0, 367, 375, 1, 0, 0, 0, 368, 375, 3, 54, 27, 0, 369, 375, 5, 80, 0, 0, 370, 371, 3, 26, 13, 0, 371, 372, 5, 122, 0, 0, 372, 373, 3, 22, 11, 1, 373, 375, 1, 0, 0, 0, 374, 356, 1, 0, 0, 0, 374, 361, 1, 0, 0, 0, 374, 362, 1, 0, 0, 0, 374, 363, 1, 0, 0, 0, 374, 364, 1, 0, 0, 0, 374, 368, 1, 0, 0, 0, 374, 369, 1, 0, 0, 0, 374, 370, 1, 0, 0, 0, 375, 382, 1, 0, 0, 0, 376, 377, 10, 5, 0, 0, 377, 378, 4, 11, 3, 0, 378, 379, 5, 4, 0, 0, 379, 381, 5, 5, 0, 0, 380, 376, 1, 0, 0, 0, 381, 384, 1, 0, 0, 0, 382, 380, 1, 0, 0, 0, 382, 383, 1, 0, 0, 0, 383, 23, 1, 0, 0, 0, 384, 382, 1, 0, 0, 0, 385, 386, 7, 0, 0, 0, 386, 25, 1, 0, 0, 0, 387, 389, 3, 34, 17, 0, 388, 390, 3, 28, 14, 0, 389, 388, 1, 0, 0, 0, 389, 390, 1, 0, 0, 0, 390, 27, 1, 0, 0, 0, 391, 394, 3, 32, 16, 0, 392, 394, 3, 30, 15, 0, 393, 391, 1, 0, 0, 0, 393, 392, 1, 0, 0, 0, 394, 29, 1, 0, 0, 0, 395, 396, 5, 30, 0, 0, 396, 397, 3, 14, 7, 0, 397, 398, 5, 31, 0, 0, 398, 31, 1, 0, 0, 0, 399, 400, 5, 30, 0, 0, 400, 401, 3, 14, 7, 0, 401, 402, 5, 30, 0, 0, 402, 408, 3, 14, 7, 0, 403, 404, 5, 31, 0, 0, 404, 405, 3, 2, 1, 0, 405, 406, 5, 31, 0, 0, 406, 409, 1, 0, 0, 0, 407, 409, 5, 27, 0, 0, 408, 403, 1, 0, 0, 0, 408, 407, 1, 0, 0, 0, 409, 33, 1, 0, 0, 0, 410, 413, 5, 124, 0, 0, 411, 413, 3, 106, 53, 0, 412, 410, 1, 0, 0, 0, 412, 411, 1, 0, 0, 0, 413, 35, 1, 0, 0, 0, 414, 416, 5, 8, 0, 0, 415, 417, 3, 38, 19, 0, 416, 415, 1, 0, 0, 0, 416, 417, 1, 0, 0, 0, 417, 418, 1, 0, 0, 0, 418, 419, 5, 10, 0, 0, 419, 37, 1, 0, 0, 0, 420, 422, 3, 40, 20, 0, 421, 423, 7, 1, 0, 0, 422, 421, 1, 0, 0, 0, 422, 423, 1, 0, 0, 0, 423, 39, 1, 0, 0, 0, 424, 429, 3, 42, 21, 0, 425, 426, 7, 1, 0, 0, 426, 428, 3, 42, 21, 0, 427, 425, 1, 0, 0, 0, 428, 431, 1, 0, 0, 0, 429, 427, 1, 0, 0, 0, 429, 430, 1, 0, 0, 0, 430, 41, 1, 0, 0, 0, 431, 429, 1, 0, 0, 0, 432, 442, 3, 58, 29, 0, 433, 442, 3, 62, 31, 0, 434, 442, 3, 80, 40, 0, 435, 442, 3, 82, 41, 0, 436, 439, 3, 84, 42, 0, 437, 438, 5, 54, 0, 0, 438, 440, 3, 18, 9, 0, 439, 437, 1, 0, 0, 0, 439, 440, 1, 0, 0, 0, 440, 442, 1, 0, 0, 0, 441, 432, 1, 0, 0, 0, 441, 433, 1, 0, 0, 0, 441, 434, 1, 0, 0, 0, 441, 435, 1, 0, 0, 0, 441, 436, 1, 0, 0, 0, 442, 43, 1, 0, 0, 0, 443, 444, 3, 22, 11, 0, 444, 445, 4, 22, 4, 0, 445, 446, 5, 4, 0, 0, 446, 447, 5, 5, 0, 0, 447, 45, 1, 0, 0, 0, 448, 449, 5, 4, 0, 0, 449, 450, 3, 48, 24, 0, 450, 451, 5, 5, 0, 0, 451, 47, 1, 0, 0, 0, 452, 457, 3, 18, 9, 0, 453, 454, 5, 12, 0, 0, 454, 456, 3, 18, 9, 0, 455, 453, 1, 0, 0, 0, 456, 459, 1, 0, 0, 0, 457, 455, 1, 0, 0, 0, 457, 458, 1, 0, 0, 0, 458, 49, 1, 0, 0, 0, 459, 457, 1, 0, 0, 0, 460, 462, 3, 4, 2, 0, 461, 460, 1, 0, 0, 0, 461, 462, 1, 0, 0, 0, 462, 463, 1, 0, 0, 0, 463, 465, 5, 6, 0, 0, 464, 466, 3, 64, 32, 0, 465, 464, 1, 0, 0, 0, 465, 466, 1, 0, 0, 0, 466, 467, 1, 0, 0, 0, 467, 468, 5, 7, 0, 0, 468, 469, 5, 54, 0, 0, 469, 470, 3, 18, 9, 0, 470, 51, 1, 0, 0, 0, 471, 473, 5, 68, 0, 0, 472, 474, 3, 4, 2, 0, 473, 472, 1, 0, 0, 0, 473, 474, 1, 0, 0, 0, 474, 475, 1, 0, 0, 0, 475, 477, 5, 6, 0, 0, 476, 478, 3, 64, 32, 0, 477, 476, 1, 0, 0, 0, 477, 478, 1, 0, 0, 0, 478, 479, 1, 0, 0, 0, 479, 480, 5, 7, 0, 0, 480, 481, 5, 54, 0, 0, 481, 482, 3, 18, 9, 0, 482, 53, 1, 0, 0, 0, 483, 484, 5, 65, 0, 0, 484, 485, 3, 56, 28, 0, 485, 55, 1, 0, 0, 0, 486, 497, 5, 124, 0, 0, 487, 488, 3, 274, 137, 0, 488, 489, 5, 17, 0, 0, 489, 491, 1, 0, 0, 0, 490, 487, 1, 0, 0, 0, 491, 492, 1, 0, 0, 0, 492, 490, 1, 0, 0, 0, 492, 493, 1, 0, 0, 0, 493, 494, 1, 0, 0, 0, 494, 495, 3, 274, 137, 0, 495, 497, 1, 0, 0, 0, 496, 486, 1, 0, 0, 0, 496, 490, 1, 0, 0, 0, 497, 57, 1, 0, 0, 0, 498, 500, 5, 90, 0, 0, 499, 498, 1, 0, 0, 0, 499, 500, 1, 0, 0, 0, 500, 501, 1, 0, 0, 0, 501, 503, 3, 242, 121, 0, 502, 504, 5, 14, 0, 0, 503, 502, 1, 0, 0, 0, 503, 504, 1, 0, 0, 0, 504, 506, 1, 0, 0, 0, 505, 507, 3, 60, 30, 0, 506, 505, 1, 0, 0, 0, 506, 507, 1, 0, 0, 0, 507, 510, 1, 0, 0, 0, 508, 509, 5, 54, 0, 0, 509, 511, 3, 18, 9, 0, 510, 508, 1, 0, 0, 0, 510, 511, 1, 0, 0, 0, 511, 59, 1, 0, 0, 0, 512, 513, 5, 15, 0, 0, 513, 514, 3, 18, 9, 0, 514, 61, 1, 0, 0, 0, 515, 517, 3, 4, 2, 0, 516, 515, 1, 0, 0, 0, 516, 517, 1, 0, 0, 0, 517, 518, 1, 0, 0, 0, 518, 520, 5, 6, 0, 0, 519, 521, 3, 64, 32, 0, 520, 519, 1, 0, 0, 0, 520, 521, 1, 0, 0, 0, 521, 522, 1, 0, 0, 0, 522, 524, 5, 7, 0, 0, 523, 525, 3, 60, 30, 0, 524, 523, 1, 0, 0, 0, 524, 525, 1, 0, 0, 0, 525, 63, 1, 0, 0, 0, 526, 540, 3, 72, 36, 0, 527, 532, 3, 68, 34, 0, 528, 529, 5, 12, 0, 0, 529, 531, 3, 68, 34, 0, 530, 528, 1, 0, 0, 0, 531, 534, 1, 0, 0, 0, 532, 530, 1, 0, 0, 0, 532, 533, 1, 0, 0, 0, 533, 537, 1, 0, 0, 0, 534, 532, 1, 0, 0, 0, 535, 536, 5, 12, 0, 0, 536, 538, 3, 72, 36, 0, 537, 535, 1, 0, 0, 0, 537, 538, 1, 0, 0, 0, 538, 540, 1, 0, 0, 0, 539, 526, 1, 0, 0, 0, 539, 527, 1, 0, 0, 0, 540, 65, 1, 0, 0, 0, 541, 546, 3, 74, 37, 0, 542, 543, 5, 12, 0, 0, 543, 545, 3, 74, 37, 0, 544, 542, 1, 0, 0, 0, 545, 548, 1, 0, 0, 0, 546, 544, 1, 0, 0, 0, 546, 547, 1, 0, 0, 0, 547, 67, 1, 0, 0, 0, 548, 546, 1, 0, 0, 0, 549, 552, 3, 74, 37, 0, 550, 552, 3, 70, 35, 0, 551, 549, 1, 0, 0, 0, 551, 550, 1, 0, 0, 0, 552, 69, 1, 0, 0, 0, 553, 555, 3, 110, 55, 0, 554, 553, 1, 0, 0, 0, 554, 555, 1, 0, 0, 0, 555, 557, 1, 0, 0, 0, 556, 558, 3, 76, 38, 0, 557, 556, 1, 0, 0, 0, 557, 558, 1, 0, 0, 0, 558, 559, 1, 0, 0, 0, 559, 568, 3, 78, 39, 0, 560, 562, 5, 14, 0, 0, 561, 563, 3, 60, 30, 0, 562, 561, 1, 0, 0, 0, 562, 563, 1, 0, 0, 0, 563, 569, 1, 0, 0, 0, 564, 566, 3, 60, 30, 0, 565, 564, 1, 0, 0, 0, 565, 566, 1, 0, 0, 0, 566, 567, 1, 0, 0, 0, 567, 569, 3, 0, 0, 0, 568, 560, 1, 0, 0, 0, 568, 565, 1, 0, 0, 0, 569, 71, 1, 0, 0, 0, 570, 571, 5, 16, 0, 0, 571, 573, 3, 254, 127, 0, 572, 574, 3, 60, 30, 0, 573, 572, 1, 0, 0, 0, 573, 574, 1, 0, 0, 0, 574, 73, 1, 0, 0, 0, 575, 577, 3, 110, 55, 0, 576, 575, 1, 0, 0, 0, 576, 577, 1, 0, 0, 0, 577, 579, 1, 0, 0, 0, 578, 580, 3, 76, 38, 0, 579, 578, 1, 0, 0, 0, 579, 580, 1, 0, 0, 0, 580, 581, 1, 0, 0, 0, 581, 583, 3, 78, 39, 0, 582, 584, 3, 60, 30, 0, 583, 582, 1, 0, 0, 0, 583, 584, 1, 0, 0, 0, 584, 75, 1, 0, 0, 0, 585, 586, 7, 2, 0, 0, 586, 77, 1, 0, 0, 0, 587, 590, 3, 274, 137, 0, 588, 590, 3, 2, 1, 0, 589, 587, 1, 0, 0, 0, 589, 588, 1, 0, 0, 0, 590, 79, 1, 0, 0, 0, 591, 593, 5, 68, 0, 0, 592, 594, 3, 4, 2, 0, 593, 592, 1, 0, 0, 0, 593, 594, 1, 0, 0, 0, 594, 595, 1, 0, 0, 0, 595, 597, 5, 6, 0, 0, 596, 598, 3, 64, 32, 0, 597, 596, 1, 0, 0, 0, 597, 598, 1, 0, 0, 0, 598, 599, 1, 0, 0, 0, 599, 601, 5, 7, 0, 0, 600, 602, 3, 60, 30, 0, 601, 600, 1, 0, 0, 0, 601, 602, 1, 0, 0, 0, 602, 81, 1, 0, 0, 0, 603, 604, 5, 4, 0, 0, 604, 605, 5, 124, 0, 0, 605, 606, 5, 15, 0, 0, 606, 607, 7, 3, 0, 0, 607, 608, 5, 5, 0, 0, 608, 609, 3, 60, 30, 0, 609, 83, 1, 0, 0, 0, 610, 612, 3, 242, 121, 0, 611, 613, 5, 14, 0, 0, 612, 611, 1, 0, 0, 0, 612, 613, 1, 0, 0, 0, 613, 614, 1, 0, 0, 0, 614, 615, 3, 62, 31, 0, 615, 85, 1, 0, 0, 0, 616, 617, 5, 113, 0, 0, 617, 619, 5, 124, 0, 0, 618, 620, 3, 4, 2, 0, 619, 618, 1, 0, 0, 0, 619, 620, 1, 0, 0, 0, 620, 621, 1, 0, 0, 0, 621, 622, 5, 13, 0, 0, 622, 623, 3, 18, 9, 0, 623, 624, 5, 11, 0, 0, 624, 87, 1, 0, 0, 0, 625, 627, 3, 76, 38, 0, 626, 625, 1, 0, 0, 0, 626, 627, 1, 0, 0, 0, 627, 628, 1, 0, 0, 0, 628, 629, 5, 116, 0, 0, 629, 631, 5, 6, 0, 0, 630, 632, 3, 218, 109, 0, 631, 630, 1, 0, 0, 0, 631, 632, 1, 0, 0, 0, 632, 633, 1, 0, 0, 0, 633, 639, 5, 7, 0, 0, 634, 635, 5, 8, 0, 0, 635, 636, 3, 224, 112, 0, 636, 637, 5, 10, 0, 0, 637, 640, 1, 0, 0, 0, 638, 640, 5, 11, 0, 0, 639, 634, 1, 0, 0, 0, 639, 638, 1, 0, 0, 0, 639, 640, 1, 0, 0, 0, 640, 89, 1, 0, 0, 0, 641, 643, 5, 97, 0, 0, 642, 641, 1, 0, 0, 0, 642, 643, 1, 0, 0, 0, 643, 645, 1, 0, 0, 0, 644, 646, 5, 120, 0, 0, 645, 644, 1, 0, 0, 0, 645, 646, 1, 0, 0, 0, 646, 647, 1, 0, 0, 0, 647, 648, 5, 103, 0, 0, 648, 650, 5, 124, 0, 0, 649, 651, 3, 4, 2, 0, 650, 649, 1, 0, 0, 0, 650, 651, 1, 0, 0, 0, 651, 653, 1, 0, 0, 0, 652, 654, 3, 92, 46, 0, 653, 652, 1, 0, 0, 0, 653, 654, 1, 0, 0, 0, 654, 655, 1, 0, 0, 0, 655, 657, 3, 36, 18, 0, 656, 658, 5, 11, 0, 0, 657, 656, 1, 0, 0, 0, 657, 658, 1, 0, 0, 0, 658, 91, 1, 0, 0, 0, 659, 660, 5, 94, 0, 0, 660, 661, 3, 94, 47, 0, 661, 93, 1, 0, 0, 0, 662, 667, 3, 26, 13, 0, 663, 664, 5, 12, 0, 0, 664, 666, 3, 26, 13, 0, 665, 663, 1, 0, 0, 0, 666, 669, 1, 0, 0, 0, 667, 665, 1, 0, 0, 0, 667, 668, 1, 0, 0, 0, 668, 95, 1, 0, 0, 0, 669, 667, 1, 0, 0, 0, 670, 672, 5, 96, 0, 0, 671, 670, 1, 0, 0, 0, 671, 672, 1, 0, 0, 0, 672, 673, 1, 0, 0, 0, 673, 674, 5, 93, 0, 0, 674, 675, 5, 124, 0, 0, 675, 677, 5, 8, 0, 0, 676, 678, 3, 98, 49, 0, 677, 676, 1, 0, 0, 0, 677, 678, 1, 0, 0, 0, 678, 679, 1, 0, 0, 0, 679, 680, 5, 10, 0, 0, 680, 97, 1, 0, 0, 0, 681, 683, 3, 100, 50, 0, 682, 684, 5, 12, 0, 0, 683, 682, 1, 0, 0, 0, 683, 684, 1, 0, 0, 0, 684, 99, 1, 0, 0, 0, 685, 690, 3, 102, 51, 0, 686, 687, 5, 12, 0, 0, 687, 689, 3, 102, 51, 0, 688, 686, 1, 0, 0, 0, 689, 692, 1, 0, 0, 0, 690, 688, 1, 0, 0, 0, 690, 691, 1, 0, 0, 0, 691, 101, 1, 0, 0, 0, 692, 690, 1, 0, 0, 0, 693, 696, 3, 242, 121, 0, 694, 695, 5, 13, 0, 0, 695, 697, 3, 254, 127, 0, 696, 694, 1, 0, 0, 0, 696, 697, 1, 0, 0, 0, 697, 103, 1, 0, 0, 0, 698, 699, 5, 117, 0, 0, 699, 700, 3, 106, 53, 0, 700, 702, 5, 8, 0, 0, 701, 703, 3, 126, 63, 0, 702, 701, 1, 0, 0, 0, 702, 703, 1, 0, 0, 0, 703, 704, 1, 0, 0, 0, 704, 705, 5, 10, 0, 0, 705, 105, 1, 0, 0, 0, 706, 715, 5, 124, 0, 0, 707, 709, 5, 17, 0, 0, 708, 707, 1, 0, 0, 0, 709, 710, 1, 0, 0, 0, 710, 708, 1, 0, 0, 0, 710, 711, 1, 0, 0, 0, 711, 712, 1, 0, 0, 0, 712, 714, 5, 124, 0, 0, 713, 708, 1, 0, 0, 0, 714, 717, 1, 0, 0, 0, 715, 713, 1, 0, 0, 0, 715, 716, 1, 0, 0, 0, 716, 107, 1, 0, 0, 0, 717, 715, 1, 0, 0, 0, 718, 719, 5, 124, 0, 0, 719, 720, 5, 13, 0, 0, 720, 721, 3, 106, 53, 0, 721, 722, 5, 11, 0, 0, 722, 109, 1, 0, 0, 0, 723, 725, 3, 112, 56, 0, 724, 723, 1, 0, 0, 0, 725, 726, 1, 0, 0, 0, 726, 724, 1, 0, 0, 0, 726, 727, 1, 0, 0, 0, 727, 111, 1, 0, 0, 0, 728, 731, 5, 123, 0, 0, 729, 732, 3, 114, 57, 0, 730, 732, 3, 116, 58, 0, 731, 729, 1, 0, 0, 0, 731, 730, 1, 0, 0, 0, 732, 113, 1, 0, 0, 0, 733, 734, 6, 57, -1, 0, 734, 740, 5, 124, 0, 0, 735, 736, 5, 6, 0, 0, 736, 737, 3, 254, 127, 0, 737, 738, 5, 7, 0, 0, 738, 740, 1, 0, 0, 0, 739, 733, 1, 0, 0, 0, 739, 735, 1, 0, 0, 0, 740, 746, 1, 0, 0, 0, 741, 742, 10, 2, 0, 0, 742, 743, 5, 17, 0, 0, 743, 745, 3, 274, 137, 0, 744, 741, 1, 0, 0, 0, 745, 748, 1, 0, 0, 0, 746, 744, 1, 0, 0, 0, 746, 747, 1, 0, 0, 0, 747, 115, 1, 0, 0, 0, 748, 746, 1, 0, 0, 0, 749, 750, 3, 114, 57, 0, 750, 751, 3, 244, 122, 0, 751, 117, 1, 0, 0, 0, 752, 754, 3, 226, 113, 0, 753, 752, 1, 0, 0, 0, 753, 754, 1, 0, 0, 0, 754, 755, 1, 0, 0, 0, 755, 756, 5, 0, 0, 1, 756, 119, 1, 0, 0, 0, 757, 759, 5, 97, 0, 0, 758, 757, 1, 0, 0, 0, 758, 759, 1, 0, 0, 0, 759, 760, 1, 0, 0, 0, 760, 761, 3, 122, 61, 0, 761, 121, 1, 0, 0, 0, 762, 792, 3, 124, 62, 0, 763, 792, 3, 130, 65, 0, 764, 792, 3, 136, 68, 0, 765, 792, 3, 144, 72, 0, 766, 792, 3, 128, 64, 0, 767, 792, 3, 188, 94, 0, 768, 792, 3, 90, 45, 0, 769, 792, 3, 104, 52, 0, 770, 792, 3, 148, 74, 0, 771, 792, 3, 150, 75, 0, 772, 792, 3, 154, 77, 0, 773, 792, 3, 156, 78, 0, 774, 792, 3, 158, 79, 0, 775, 792, 3, 160, 80, 0, 776, 792, 3, 162, 81, 0, 777, 792, 3, 174, 87, 0, 778, 792, 3, 164, 82, 0, 779, 792, 3, 176, 88, 0, 780, 792, 3, 178, 89, 0, 781, 792, 3, 184, 92, 0, 782, 792, 3, 186, 93, 0, 783, 792, 3, 258, 129, 0, 784, 792, 3, 208, 104, 0, 785, 792, 3, 138, 69, 0, 786, 792, 3, 86, 43, 0, 787, 792, 3, 96, 48, 0, 788, 792, 3, 146, 73, 0, 789, 790, 5, 97, 0, 0, 790, 792, 3, 122, 61, 0, 791, 762, 1, 0, 0, 0, 791, 763, 1, 0, 0, 0, 791, 764, 1, 0, 0, 0, 791, 765, 1, 0, 0, 0, 791, 766, 1, 0, 0, 0, 791, 767, 1, 0, 0, 0, 791, 768, 1, 0, 0, 0, 791, 769, 1, 0, 0, 0, 791, 770, 1, 0, 0, 0, 791, 771, 1, 0, 0, 0, 791, 772, 1, 0, 0, 0, 791, 773, 1, 0, 0, 0, 791, 774, 1, 0, 0, 0, 791, 775, 1, 0, 0, 0, 791, 776, 1, 0, 0, 0, 791, 777, 1, 0, 0, 0, 791, 778, 1, 0, 0, 0, 791, 779, 1, 0, 0, 0, 791, 780, 1, 0, 0, 0, 791, 781, 1, 0, 0, 0, 791, 782, 1, 0, 0, 0, 791, 783, 1, 0, 0, 0, 791, 784, 1, 0, 0, 0, 791, 785, 1, 0, 0, 0, 791, 786, 1, 0, 0, 0, 791, 787, 1, 0, 0, 0, 791, 788, 1, 0, 0, 0, 791, 789, 1, 0, 0, 0, 792, 123, 1, 0, 0, 0, 793, 795, 5, 8, 0, 0, 794, 796, 3, 126, 63, 0, 795, 794, 1, 0, 0, 0, 795, 796, 1, 0, 0, 0, 796, 797, 1, 0, 0, 0, 797, 798, 5, 10, 0, 0, 798, 125, 1, 0, 0, 0, 799, 801, 3, 122, 61, 0, 800, 799, 1, 0, 0, 0, 801, 802, 1, 0, 0, 0, 802, 800, 1, 0, 0, 0, 802, 803, 1, 0, 0, 0, 803, 127, 1, 0, 0, 0, 804, 808, 5, 121, 0, 0, 805, 806, 5, 124, 0, 0, 806, 809, 3, 62, 31, 0, 807, 809, 3, 138, 69, 0, 808, 805, 1, 0, 0, 0, 808, 807, 1, 0, 0, 0, 809, 810, 1, 0, 0, 0, 810, 811, 3, 286, 143, 0, 811, 129, 1, 0, 0, 0, 812, 815, 5, 98, 0, 0, 813, 816, 3, 132, 66, 0, 814, 816, 3, 108, 54, 0, 815, 813, 1, 0, 0, 0, 815, 814, 1, 0, 0, 0, 816, 131, 1, 0, 0, 0, 817, 820, 5, 24, 0, 0, 818, 820, 3, 134, 67, 0, 819, 817, 1, 0, 0, 0, 819, 818, 1, 0, 0, 0, 820, 823, 1, 0, 0, 0, 821, 822, 5, 88, 0, 0, 822, 824, 3, 274, 137, 0, 823, 821, 1, 0, 0, 0, 823, 824, 1, 0, 0, 0, 824, 825, 1, 0, 0, 0, 825, 826, 5, 89, 0, 0, 826, 827, 5, 125, 0, 0, 827, 828, 3, 286, 143, 0, 828, 133, 1, 0, 0, 0, 829, 830, 3, 274, 137, 0, 830, 831, 5, 12, 0, 0, 831, 833, 1, 0, 0, 0, 832, 829, 1, 0, 0, 0, 832, 833, 1, 0, 0, 0, 833, 834, 1, 0, 0, 0, 834, 835, 5, 8, 0, 0, 835, 840, 3, 274, 137, 0, 836, 837, 5, 12, 0, 0, 837, 839, 3, 274, 137, 0, 838, 836, 1, 0, 0, 0, 839, 842, 1, 0, 0, 0, 840, 838, 1, 0, 0, 0, 840, 841, 1, 0, 0, 0, 841, 843, 1, 0, 0, 0, 842, 840, 1, 0, 0, 0, 843, 844, 5, 10, 0, 0, 844, 135, 1, 0, 0, 0, 845, 847, 5, 97, 0, 0, 846, 848, 5, 82, 0, 0, 847, 846, 1, 0, 0, 0, 847, 848, 1, 0, 0, 0, 848, 851, 1, 0, 0, 0, 849, 852, 3, 132, 66, 0, 850, 852, 3, 122, 61, 0, 851, 849, 1, 0, 0, 0, 851, 850, 1, 0, 0, 0, 852, 137, 1, 0, 0, 0, 853, 855, 3, 2, 1, 0, 854, 856, 3, 60, 30, 0, 855, 854, 1, 0, 0, 0, 855, 856, 1, 0, 0, 0, 856, 857, 1, 0, 0, 0, 857, 859, 3, 0, 0, 0, 858, 860, 5, 11, 0, 0, 859, 858, 1, 0, 0, 0, 859, 860, 1, 0, 0, 0, 860, 883, 1, 0, 0, 0, 861, 863, 3, 76, 38, 0, 862, 861, 1, 0, 0, 0, 862, 863, 1, 0, 0, 0, 863, 865, 1, 0, 0, 0, 864, 866, 3, 152, 76, 0, 865, 864, 1, 0, 0, 0, 865, 866, 1, 0, 0, 0, 866, 868, 1, 0, 0, 0, 867, 869, 5, 90, 0, 0, 868, 867, 1, 0, 0, 0, 868, 869, 1, 0, 0, 0, 869, 870, 1, 0, 0, 0, 870, 872, 3, 140, 70, 0, 871, 873, 5, 11, 0, 0, 872, 871, 1, 0, 0, 0, 872, 873, 1, 0, 0, 0, 873, 883, 1, 0, 0, 0, 874, 876, 5, 120, 0, 0, 875, 877, 3, 152, 76, 0, 876, 875, 1, 0, 0, 0, 876, 877, 1, 0, 0, 0, 877, 878, 1, 0, 0, 0, 878, 880, 3, 140, 70, 0, 879, 881, 5, 11, 0, 0, 880, 879, 1, 0, 0, 0, 880, 881, 1, 0, 0, 0, 881, 883, 1, 0, 0, 0, 882, 853, 1, 0, 0, 0, 882, 862, 1, 0, 0, 0, 882, 874, 1, 0, 0, 0, 883, 139, 1, 0, 0, 0, 884, 889, 3, 142, 71, 0, 885, 886, 5, 12, 0, 0, 886, 888, 3, 142, 71, 0, 887, 885, 1, 0, 0, 0, 888, 891, 1, 0, 0, 0, 889, 887, 1, 0, 0, 0, 889, 890, 1, 0, 0, 0, 890, 141, 1, 0, 0, 0, 891, 889, 1, 0, 0, 0, 892, 896, 3, 276, 138, 0, 893, 896, 3, 228, 114, 0, 894, 896, 3, 234, 117, 0, 895, 892, 1, 0, 0, 0, 895, 893, 1, 0, 0, 0, 895, 894, 1, 0, 0, 0, 896, 898, 1, 0, 0, 0, 897, 899, 3, 60, 30, 0, 898, 897, 1, 0, 0, 0, 898, 899, 1, 0, 0, 0, 899, 901, 1, 0, 0, 0, 900, 902, 3, 254, 127, 0, 901, 900, 1, 0, 0, 0, 901, 902, 1, 0, 0, 0, 902, 908, 1, 0, 0, 0, 903, 905, 5, 13, 0, 0, 904, 906, 3, 4, 2, 0, 905, 904, 1, 0, 0, 0, 905, 906, 1, 0, 0, 0, 906, 907, 1, 0, 0, 0, 907, 909, 3, 254, 127, 0, 908, 903, 1, 0, 0, 0, 908, 909, 1, 0, 0, 0, 909, 143, 1, 0, 0, 0, 910, 911, 5, 11, 0, 0, 911, 145, 1, 0, 0, 0, 912, 913, 4, 73, 6, 0, 913, 915, 3, 250, 125, 0, 914, 916, 5, 11, 0, 0, 915, 914, 1, 0, 0, 0, 915, 916, 1, 0, 0, 0, 916, 147, 1, 0, 0, 0, 917, 918, 5, 83, 0, 0, 918, 919, 5, 6, 0, 0, 919, 920, 3, 250, 125, 0, 920, 921, 5, 7, 0, 0, 921, 924, 3, 122, 61, 0, 922, 923, 5, 67, 0, 0, 923, 925, 3, 122, 61, 0, 924, 922, 1, 0, 0, 0, 924, 925, 1, 0, 0, 0, 925, 149, 1, 0, 0, 0, 926, 927, 5, 63, 0, 0, 927, 928, 3, 122, 61, 0, 928, 929, 5, 77, 0, 0, 929, 930, 5, 6, 0, 0, 930, 931, 3, 250, 125, 0, 931, 932, 5, 7, 0, 0, 932, 933, 3, 286, 143, 0, 933, 996, 1, 0, 0, 0, 934, 935, 5, 77, 0, 0, 935, 936, 5, 6, 0, 0, 936, 937, 3, 250, 125, 0, 937, 938, 5, 7, 0, 0, 938, 939, 3, 122, 61, 0, 939, 996, 1, 0, 0, 0, 940, 941, 5, 75, 0, 0, 941, 943, 5, 6, 0, 0, 942, 944, 3, 250, 125, 0, 943, 942, 1, 0, 0, 0, 943, 944, 1, 0, 0, 0, 944, 945, 1, 0, 0, 0, 945, 947, 5, 11, 0, 0, 946, 948, 3, 250, 125, 0, 947, 946, 1, 0, 0, 0, 947, 948, 1, 0, 0, 0, 948, 949, 1, 0, 0, 0, 949, 951, 5, 11, 0, 0, 950, 952, 3, 250, 125, 0, 951, 950, 1, 0, 0, 0, 951, 952, 1, 0, 0, 0, 952, 953, 1, 0, 0, 0, 953, 954, 5, 7, 0, 0, 954, 996, 3, 122, 61, 0, 955, 956, 5, 75, 0, 0, 956, 957, 5, 6, 0, 0, 957, 958, 3, 152, 76, 0, 958, 959, 3, 140, 70, 0, 959, 961, 5, 11, 0, 0, 960, 962, 3, 250, 125, 0, 961, 960, 1, 0, 0, 0, 961, 962, 1, 0, 0, 0, 962, 963, 1, 0, 0, 0, 963, 965, 5, 11, 0, 0, 964, 966, 3, 250, 125, 0, 965, 964, 1, 0, 0, 0, 965, 966, 1, 0, 0, 0, 966, 967, 1, 0, 0, 0, 967, 968, 5, 7, 0, 0, 968, 969, 3, 122, 61, 0, 969, 996, 1, 0, 0, 0, 970, 971, 5, 75, 0, 0, 971, 972, 5, 6, 0, 0, 972, 976, 3, 254, 127, 0, 973, 977, 5, 86, 0, 0, 974, 975, 5, 124, 0, 0, 975, 977, 4, 75, 7, 0, 976, 973, 1, 0, 0, 0, 976, 974, 1, 0, 0, 0, 977, 978, 1, 0, 0, 0, 978, 979, 3, 250, 125, 0, 979, 980, 5, 7, 0, 0, 980, 981, 3, 122, 61, 0, 981, 996, 1, 0, 0, 0, 982, 983, 5, 75, 0, 0, 983, 984, 5, 6, 0, 0, 984, 985, 3, 152, 76, 0, 985, 989, 3, 142, 71, 0, 986, 990, 5, 86, 0, 0, 987, 988, 5, 124, 0, 0, 988, 990, 4, 75, 8, 0, 989, 986, 1, 0, 0, 0, 989, 987, 1, 0, 0, 0, 990, 991, 1, 0, 0, 0, 991, 992, 3, 250, 125, 0, 992, 993, 5, 7, 0, 0, 993, 994, 3, 122, 61, 0, 994, 996, 1, 0, 0, 0, 995, 926, 1, 0, 0, 0, 995, 934, 1, 0, 0, 0, 995, 940, 1, 0, 0, 0, 995, 955, 1, 0, 0, 0, 995, 970, 1, 0, 0, 0, 995, 982, 1, 0, 0, 0, 996, 151, 1, 0, 0, 0, 997, 998, 7, 4, 0, 0, 998, 153, 1, 0, 0, 0, 999, 1002, 5, 74, 0, 0, 1000, 1001, 4, 77, 9, 0, 1001, 1003, 5, 124, 0, 0, 1002, 1000, 1, 0, 0, 0, 1002, 1003, 1, 0, 0, 0, 1003, 1004, 1, 0, 0, 0, 1004, 1005, 3, 286, 143, 0, 1005, 155, 1, 0, 0, 0, 1006, 1009, 5, 62, 0, 0, 1007, 1008, 4, 78, 10, 0, 1008, 1010, 5, 124, 0, 0, 1009, 1007, 1, 0, 0, 0, 1009, 1010, 1, 0, 0, 0, 1010, 1011, 1, 0, 0, 0, 1011, 1012, 3, 286, 143, 0, 1012, 157, 1, 0, 0, 0, 1013, 1016, 5, 72, 0, 0, 1014, 1015, 4, 79, 11, 0, 1015, 1017, 3, 250, 125, 0, 1016, 1014, 1, 0, 0, 0, 1016, 1017, 1, 0, 0, 0, 1017, 1018, 1, 0, 0, 0, 1018, 1019, 3, 286, 143, 0, 1019, 159, 1, 0, 0, 0, 1020, 1023, 5, 107, 0, 0, 1021, 1022, 4, 80, 12, 0, 1022, 1024, 3, 250, 125, 0, 1023, 1021, 1, 0, 0, 0, 1023, 1024, 1, 0, 0, 0, 1024, 1025, 1, 0, 0, 0, 1025, 1026, 3, 286, 143, 0, 1026, 161, 1, 0, 0, 0, 1027, 1028, 5, 81, 0, 0, 1028, 1029, 5, 6, 0, 0, 1029, 1030, 3, 250, 125, 0, 1030, 1031, 5, 7, 0, 0, 1031, 1032, 3, 122, 61, 0, 1032, 163, 1, 0, 0, 0, 1033, 1034, 5, 76, 0, 0, 1034, 1035, 5, 6, 0, 0, 1035, 1036, 3, 250, 125, 0, 1036, 1037, 5, 7, 0, 0, 1037, 1038, 3, 166, 83, 0, 1038, 165, 1, 0, 0, 0, 1039, 1041, 5, 8, 0, 0, 1040, 1042, 3, 168, 84, 0, 1041, 1040, 1, 0, 0, 0, 1041, 1042, 1, 0, 0, 0, 1042, 1047, 1, 0, 0, 0, 1043, 1045, 3, 172, 86, 0, 1044, 1046, 3, 168, 84, 0, 1045, 1044, 1, 0, 0, 0, 1045, 1046, 1, 0, 0, 0, 1046, 1048, 1, 0, 0, 0, 1047, 1043, 1, 0, 0, 0, 1047, 1048, 1, 0, 0, 0, 1048, 1049, 1, 0, 0, 0, 1049, 1050, 5, 10, 0, 0, 1050, 167, 1, 0, 0, 0, 1051, 1053, 3, 170, 85, 0, 1052, 1051, 1, 0, 0, 0, 1053, 1054, 1, 0, 0, 0, 1054, 1052, 1, 0, 0, 0, 1054, 1055, 1, 0, 0, 0, 1055, 169, 1, 0, 0, 0, 1056, 1057, 5, 66, 0, 0, 1057, 1058, 3, 250, 125, 0, 1058, 1060, 5, 15, 0, 0, 1059, 1061, 3, 126, 63, 0, 1060, 1059, 1, 0, 0, 0, 1060, 1061, 1, 0, 0, 0, 1061, 171, 1, 0, 0, 0, 1062, 1063, 5, 82, 0, 0, 1063, 1065, 5, 15, 0, 0, 1064, 1066, 3, 126, 63, 0, 1065, 1064, 1, 0, 0, 0, 1065, 1066, 1, 0, 0, 0, 1066, 173, 1, 0, 0, 0, 1067, 1068, 5, 124, 0, 0, 1068, 1069, 5, 15, 0, 0, 1069, 1070, 3, 122, 61, 0, 1070, 175, 1, 0, 0, 0, 1071, 1072, 5, 84, 0, 0, 1072, 1073, 4, 88, 13, 0, 1073, 1074, 3, 250, 125, 0, 1074, 1075, 3, 286, 143, 0, 1075, 177, 1, 0, 0, 0, 1076, 1077, 5, 87, 0, 0, 1077, 1083, 3, 124, 62, 0, 1078, 1080, 3, 180, 90, 0, 1079, 1081, 3, 182, 91, 0, 1080, 1079, 1, 0, 0, 0, 1080, 1081, 1, 0, 0, 0, 1081, 1084, 1, 0, 0, 0, 1082, 1084, 3, 182, 91, 0, 1083, 1078, 1, 0, 0, 0, 1083, 1082, 1, 0, 0, 0, 1084, 179, 1, 0, 0, 0, 1085, 1086, 5, 70, 0, 0, 1086, 1087, 5, 6, 0, 0, 1087, 1088, 5, 124, 0, 0, 1088, 1089, 5, 7, 0, 0, 1089, 1090, 3, 124, 62, 0, 1090, 181, 1, 0, 0, 0, 1091, 1092, 5, 71, 0, 0, 1092, 1093, 3, 124, 62, 0, 1093, 183, 1, 0, 0, 0, 1094, 1095, 5, 78, 0, 0, 1095, 1096, 3, 286, 143, 0, 1096, 185, 1, 0, 0, 0, 1097, 1098, 5, 79, 0, 0, 1098, 1099, 5, 124, 0, 0, 1099, 1105, 3, 62, 31, 0, 1100, 1101, 5, 8, 0, 0, 1101, 1102, 3, 224, 112, 0, 1102, 1103, 5, 10, 0, 0, 1103, 1106, 1, 0, 0, 0, 1104, 1106, 5, 11, 0, 0, 1105, 1100, 1, 0, 0, 0, 1105, 1104, 1, 0, 0, 0, 1106, 187, 1, 0, 0, 0, 1107, 1109, 3, 110, 55, 0, 1108, 1107, 1, 0, 0, 0, 1108, 1109, 1, 0, 0, 0, 1109, 1114, 1, 0, 0, 0, 1110, 1112, 5, 97, 0, 0, 1111, 1113, 5, 82, 0, 0, 1112, 1111, 1, 0, 0, 0, 1112, 1113, 1, 0, 0, 0, 1113, 1115, 1, 0, 0, 0, 1114, 1110, 1, 0, 0, 0, 1114, 1115, 1, 0, 0, 0, 1115, 1117, 1, 0, 0, 0, 1116, 1118, 5, 121, 0, 0, 1117, 1116, 1, 0, 0, 0, 1117, 1118, 1, 0, 0, 0, 1118, 1119, 1, 0, 0, 0, 1119, 1120, 5, 92, 0, 0, 1120, 1122, 5, 124, 0, 0, 1121, 1123, 3, 4, 2, 0, 1122, 1121, 1, 0, 0, 0, 1122, 1123, 1, 0, 0, 0, 1123, 1124, 1, 0, 0, 0, 1124, 1125, 3, 190, 95, 0, 1125, 1126, 3, 192, 96, 0, 1126, 189, 1, 0, 0, 0, 1127, 1129, 3, 194, 97, 0, 1128, 1127, 1, 0, 0, 0, 1128, 1129, 1, 0, 0, 0, 1129, 1131, 1, 0, 0, 0, 1130, 1132, 3, 196, 98, 0, 1131, 1130, 1, 0, 0, 0, 1131, 1132, 1, 0, 0, 0, 1132, 191, 1, 0, 0, 0, 1133, 1137, 5, 8, 0, 0, 1134, 1136, 3, 198, 99, 0, 1135, 1134, 1, 0, 0, 0, 1136, 1139, 1, 0, 0, 0, 1137, 1135, 1, 0, 0, 0, 1137, 1138, 1, 0, 0, 0, 1138, 1140, 1, 0, 0, 0, 1139, 1137, 1, 0, 0, 0, 1140, 1141, 5, 10, 0, 0, 1141, 193, 1, 0, 0, 0, 1142, 1143, 5, 94, 0, 0, 1143, 1144, 3, 26, 13, 0, 1144, 195, 1, 0, 0, 0, 1145, 1146, 5, 99, 0, 0, 1146, 1147, 3, 94, 47, 0, 1147, 197, 1, 0, 0, 0, 1148, 1156, 3, 88, 44, 0, 1149, 1151, 3, 110, 55, 0, 1150, 1149, 1, 0, 0, 0, 1150, 1151, 1, 0, 0, 0, 1151, 1152, 1, 0, 0, 0, 1152, 1156, 3, 200, 100, 0, 1153, 1156, 3, 204, 102, 0, 1154, 1156, 3, 122, 61, 0, 1155, 1148, 1, 0, 0, 0, 1155, 1150, 1, 0, 0, 0, 1155, 1153, 1, 0, 0, 0, 1155, 1154, 1, 0, 0, 0, 1156, 199, 1, 0, 0, 0, 1157, 1158, 3, 202, 101, 0, 1158, 1160, 3, 242, 121, 0, 1159, 1161, 5, 14, 0, 0, 1160, 1159, 1, 0, 0, 0, 1160, 1161, 1, 0, 0, 0, 1161, 1163, 1, 0, 0, 0, 1162, 1164, 3, 60, 30, 0, 1163, 1162, 1, 0, 0, 0, 1163, 1164, 1, 0, 0, 0, 1164, 1166, 1, 0, 0, 0, 1165, 1167, 3, 0, 0, 0, 1166, 1165, 1, 0, 0, 0, 1166, 1167, 1, 0, 0, 0, 1167, 1168, 1, 0, 0, 0, 1168, 1169, 5, 11, 0, 0, 1169, 1187, 1, 0, 0, 0, 1170, 1171, 3, 202, 101, 0, 1171, 1172, 3, 242, 121, 0, 1172, 1178, 3, 62, 31, 0, 1173, 1174, 5, 8, 0, 0, 1174, 1175, 3, 224, 112, 0, 1175, 1176, 5, 10, 0, 0, 1176, 1179, 1, 0, 0, 0, 1177, 1179, 5, 11, 0, 0, 1178, 1173, 1, 0, 0, 0, 1178, 1177, 1, 0, 0, 0, 1179, 1187, 1, 0, 0, 0, 1180, 1183, 3, 202, 101, 0, 1181, 1184, 3, 238, 119, 0, 1182, 1184, 3, 240, 120, 0, 1183, 1181, 1, 0, 0, 0, 1183, 1182, 1, 0, 0, 0, 1184, 1187, 1, 0, 0, 0, 1185, 1187, 3, 128, 64, 0, 1186, 1157, 1, 0, 0, 0, 1186, 1170, 1, 0, 0, 0, 1186, 1180, 1, 0, 0, 0, 1186, 1185, 1, 0, 0, 0, 1187, 201, 1, 0, 0, 0, 1188, 1190, 3, 76, 38, 0, 1189, 1188, 1, 0, 0, 0, 1189, 1190, 1, 0, 0, 0, 1190, 1192, 1, 0, 0, 0, 1191, 1193, 5, 91, 0, 0, 1192, 1191, 1, 0, 0, 0, 1192, 1193, 1, 0, 0, 0, 1193, 1195, 1, 0, 0, 0, 1194, 1196, 5, 106, 0, 0, 1195, 1194, 1, 0, 0, 0, 1195, 1196, 1, 0, 0, 0, 1196, 1198, 1, 0, 0, 0, 1197, 1199, 5, 90, 0, 0, 1198, 1197, 1, 0, 0, 0, 1198, 1199, 1, 0, 0, 0, 1199, 203, 1, 0, 0, 0, 1200, 1201, 3, 82, 41, 0, 1201, 1202, 5, 11, 0, 0, 1202, 205, 1, 0, 0, 0, 1203, 1205, 5, 24, 0, 0, 1204, 1203, 1, 0, 0, 0, 1204, 1205, 1, 0, 0, 0, 1205, 1206, 1, 0, 0, 0, 1206, 1207, 5, 124, 0, 0, 1207, 1209, 5, 6, 0, 0, 1208, 1210, 3, 218, 109, 0, 1209, 1208, 1, 0, 0, 0, 1209, 1210, 1, 0, 0, 0, 1210, 1211, 1, 0, 0, 0, 1211, 1212, 5, 7, 0, 0, 1212, 1213, 5, 8, 0, 0, 1213, 1214, 3, 224, 112, 0, 1214, 1215, 5, 10, 0, 0, 1215, 207, 1, 0, 0, 0, 1216, 1217, 5, 79, 0, 0, 1217, 1219, 5, 24, 0, 0, 1218, 1220, 5, 124, 0, 0, 1219, 1218, 1, 0, 0, 0, 1219, 1220, 1, 0, 0, 0, 1220, 1221, 1, 0, 0, 0, 1221, 1223, 5, 6, 0, 0, 1222, 1224, 3, 218, 109, 0, 1223, 1222, 1, 0, 0, 0, 1223, 1224, 1, 0, 0, 0, 1224, 1225, 1, 0, 0, 0, 1225, 1226, 5, 7, 0, 0, 1226, 1227, 5, 8, 0, 0, 1227, 1228, 3, 224, 112, 0, 1228, 1229, 5, 10, 0, 0, 1229, 209, 1, 0, 0, 0, 1230, 1231, 5, 8, 0, 0, 1231, 1236, 3, 212, 106, 0, 1232, 1233, 5, 12, 0, 0, 1233, 1235, 3, 212, 106, 0, 1234, 1232, 1, 0, 0, 0, 1235, 1238, 1, 0, 0, 0, 1236, 1234, 1, 0, 0, 0, 1236, 1237, 1, 0, 0, 0, 1237, 1240, 1, 0, 0, 0, 1238, 1236, 1, 0, 0, 0, 1239, 1241, 5, 12, 0, 0, 1240, 1239, 1, 0, 0, 0, 1240, 1241, 1, 0, 0, 0, 1241, 1242, 1, 0, 0, 0, 1242, 1243, 5, 10, 0, 0, 1243, 211, 1, 0, 0, 0, 1244, 1245, 5, 24, 0, 0, 1245, 1246, 3, 216, 108, 0, 1246, 213, 1, 0, 0, 0, 1247, 1248, 5, 8, 0, 0, 1248, 1253, 3, 216, 108, 0, 1249, 1250, 5, 12, 0, 0, 1250, 1252, 3, 216, 108, 0, 1251, 1249, 1, 0, 0, 0, 1252, 1255, 1, 0, 0, 0, 1253, 1251, 1, 0, 0, 0, 1253, 1254, 1, 0, 0, 0, 1254, 1257, 1, 0, 0, 0, 1255, 1253, 1, 0, 0, 0, 1256, 1258, 5, 12, 0, 0, 1257, 1256, 1, 0, 0, 0, 1257, 1258, 1, 0, 0, 0, 1258, 1259, 1, 0, 0, 0, 1259, 1260, 5, 10, 0, 0, 1260, 215, 1, 0, 0, 0, 1261, 1262, 5, 4, 0, 0, 1262, 1263, 3, 254, 127, 0, 1263, 1264, 5, 5, 0, 0, 1264, 1266, 5, 6, 0, 0, 1265, 1267, 3, 218, 109, 0, 1266, 1265, 1, 0, 0, 0, 1266, 1267, 1, 0, 0, 0, 1267, 1268, 1, 0, 0, 0, 1268, 1269, 5, 7, 0, 0, 1269, 1270, 5, 8, 0, 0, 1270, 1271, 3, 224, 112, 0, 1271, 1272, 5, 10, 0, 0, 1272, 217, 1, 0, 0, 0, 1273, 1278, 3, 220, 110, 0, 1274, 1275, 5, 12, 0, 0, 1275, 1277, 3, 220, 110, 0, 1276, 1274, 1, 0, 0, 0, 1277, 1280, 1, 0, 0, 0, 1278, 1276, 1, 0, 0, 0, 1278, 1279, 1, 0, 0, 0, 1279, 1283, 1, 0, 0, 0, 1280, 1278, 1, 0, 0, 0, 1281, 1282, 5, 12, 0, 0, 1282, 1284, 3, 222, 111, 0, 1283, 1281, 1, 0, 0, 0, 1283, 1284, 1, 0, 0, 0, 1284, 1293, 1, 0, 0, 0, 1285, 1293, 3, 222, 111, 0, 1286, 1293, 3, 228, 114, 0, 1287, 1290, 3, 234, 117, 0, 1288, 1289, 5, 15, 0, 0, 1289, 1291, 3, 218, 109, 0, 1290, 1288, 1, 0, 0, 0, 1290, 1291, 1, 0, 0, 0, 1291, 1293, 1, 0, 0, 0, 1292, 1273, 1, 0, 0, 0, 1292, 1285, 1, 0, 0, 0, 1292, 1286, 1, 0, 0, 0, 1292, 1287, 1, 0, 0, 0, 1293, 219, 1, 0, 0, 0, 1294, 1296, 3, 112, 56, 0, 1295, 1294, 1, 0, 0, 0, 1295, 1296, 1, 0, 0, 0, 1296, 1298, 1, 0, 0, 0, 1297, 1299, 3, 76, 38, 0, 1298, 1297, 1, 0, 0, 0, 1298, 1299, 1, 0, 0, 0, 1299, 1300, 1, 0, 0, 0, 1300, 1302, 3, 276, 138, 0, 1301, 1303, 5, 14, 0, 0, 1302, 1301, 1, 0, 0, 0, 1302, 1303, 1, 0, 0, 0, 1303, 1305, 1, 0, 0, 0, 1304, 1306, 3, 60, 30, 0, 1305, 1304, 1, 0, 0, 0, 1305, 1306, 1, 0, 0, 0, 1306, 1309, 1, 0, 0, 0, 1307, 1308, 5, 13, 0, 0, 1308, 1310, 3, 254, 127, 0, 1309, 1307, 1, 0, 0, 0, 1309, 1310, 1, 0, 0, 0, 1310, 221, 1, 0, 0, 0, 1311, 1312, 5, 16, 0, 0, 1312, 1314, 5, 124, 0, 0, 1313, 1315, 3, 60, 30, 0, 1314, 1313, 1, 0, 0, 0, 1314, 1315, 1, 0, 0, 0, 1315, 223, 1, 0, 0, 0, 1316, 1318, 3, 226, 113, 0, 1317, 1316, 1, 0, 0, 0, 1317, 1318, 1, 0, 0, 0, 1318, 225, 1, 0, 0, 0, 1319, 1321, 3, 120, 60, 0, 1320, 1319, 1, 0, 0, 0, 1321, 1322, 1, 0, 0, 0, 1322, 1320, 1, 0, 0, 0, 1322, 1323, 1, 0, 0, 0, 1323, 227, 1, 0, 0, 0, 1324, 1326, 5, 4, 0, 0, 1325, 1327, 3, 230, 115, 0, 1326, 1325, 1, 0, 0, 0, 1326, 1327, 1, 0, 0, 0, 1327, 1328, 1, 0, 0, 0, 1328, 1329, 5, 5, 0, 0, 1329, 229, 1, 0, 0, 0, 1330, 1339, 3, 232, 116, 0, 1331, 1333, 5, 12, 0, 0, 1332, 1331, 1, 0, 0, 0, 1333, 1334, 1, 0, 0, 0, 1334, 1332, 1, 0, 0, 0, 1334, 1335, 1, 0, 0, 0, 1335, 1336, 1, 0, 0, 0, 1336, 1338, 3, 232, 116, 0, 1337, 1332, 1, 0, 0, 0, 1338, 1341, 1, 0, 0, 0, 1339, 1337, 1, 0, 0, 0, 1339, 1340, 1, 0, 0, 0, 1340, 231, 1, 0, 0, 0, 1341, 1339, 1, 0, 0, 0, 1342, 1344, 5, 16, 0, 0, 1343, 1342, 1, 0, 0, 0, 1343, 1344, 1, 0, 0, 0, 1344, 1347, 1, 0, 0, 0, 1345, 1348, 3, 254, 127, 0, 1346, 1348, 5, 124, 0, 0, 1347, 1345, 1, 0, 0, 0, 1347, 1346, 1, 0, 0, 0, 1348, 1350, 1, 0, 0, 0, 1349, 1351, 5, 12, 0, 0, 1350, 1349, 1, 0, 0, 0, 1350, 1351, 1, 0, 0, 0, 1351, 233, 1, 0, 0, 0, 1352, 1364, 5, 8, 0, 0, 1353, 1358, 3, 236, 118, 0, 1354, 1355, 5, 12, 0, 0, 1355, 1357, 3, 236, 118, 0, 1356, 1354, 1, 0, 0, 0, 1357, 1360, 1, 0, 0, 0, 1358, 1356, 1, 0, 0, 0, 1358, 1359, 1, 0, 0, 0, 1359, 1362, 1, 0, 0, 0, 1360, 1358, 1, 0, 0, 0, 1361, 1363, 5, 12, 0, 0, 1362, 1361, 1, 0, 0, 0, 1362, 1363, 1, 0, 0, 0, 1363, 1365, 1, 0, 0, 0, 1364, 1353, 1, 0, 0, 0, 1364, 1365, 1, 0, 0, 0, 1365, 1366, 1, 0, 0, 0, 1366, 1367, 5, 10, 0, 0, 1367, 235, 1, 0, 0, 0, 1368, 1369, 3, 242, 121, 0, 1369, 1370, 7, 5, 0, 0, 1370, 1371, 3, 254, 127, 0, 1371, 1384, 1, 0, 0, 0, 1372, 1373, 5, 4, 0, 0, 1373, 1374, 3, 254, 127, 0, 1374, 1375, 5, 5, 0, 0, 1375, 1376, 5, 15, 0, 0, 1376, 1377, 3, 254, 127, 0, 1377, 1384, 1, 0, 0, 0, 1378, 1384, 3, 238, 119, 0, 1379, 1384, 3, 240, 120, 0, 1380, 1384, 3, 206, 103, 0, 1381, 1384, 3, 276, 138, 0, 1382, 1384, 3, 72, 36, 0, 1383, 1368, 1, 0, 0, 0, 1383, 1372, 1, 0, 0, 0, 1383, 1378, 1, 0, 0, 0, 1383, 1379, 1, 0, 0, 0, 1383, 1380, 1, 0, 0, 0, 1383, 1381, 1, 0, 0, 0, 1383, 1382, 1, 0, 0, 0, 1384, 237, 1, 0, 0, 0, 1385, 1386, 3, 282, 141, 0, 1386, 1387, 5, 6, 0, 0, 1387, 1389, 5, 7, 0, 0, 1388, 1390, 3, 60, 30, 0, 1389, 1388, 1, 0, 0, 0, 1389, 1390, 1, 0, 0, 0, 1390, 1391, 1, 0, 0, 0, 1391, 1392, 5, 8, 0, 0, 1392, 1393, 3, 224, 112, 0, 1393, 1394, 5, 10, 0, 0, 1394, 239, 1, 0, 0, 0, 1395, 1396, 3, 284, 142, 0, 1396, 1399, 5, 6, 0, 0, 1397, 1400, 5, 124, 0, 0, 1398, 1400, 3, 2, 1, 0, 1399, 1397, 1, 0, 0, 0, 1399, 1398, 1, 0, 0, 0, 1400, 1402, 1, 0, 0, 0, 1401, 1403, 3, 60, 30, 0, 1402, 1401, 1, 0, 0, 0, 1402, 1403, 1, 0, 0, 0, 1403, 1404, 1, 0, 0, 0, 1404, 1405, 5, 7, 0, 0, 1405, 1406, 5, 8, 0, 0, 1406, 1407, 3, 224, 112, 0, 1407, 1408, 5, 10, 0, 0, 1408, 241, 1, 0, 0, 0, 1409, 1413, 3, 274, 137, 0, 1410, 1413, 5, 125, 0, 0, 1411, 1413, 3, 272, 136, 0, 1412, 1409, 1, 0, 0, 0, 1412, 1410, 1, 0, 0, 0, 1412, 1411, 1, 0, 0, 0, 1413, 243, 1, 0, 0, 0, 1414, 1419, 5, 6, 0, 0, 1415, 1417, 3, 246, 123, 0, 1416, 1418, 5, 12, 0, 0, 1417, 1416, 1, 0, 0, 0, 1417, 1418, 1, 0, 0, 0, 1418, 1420, 1, 0, 0, 0, 1419, 1415, 1, 0, 0, 0, 1419, 1420, 1, 0, 0, 0, 1420, 1421, 1, 0, 0, 0, 1421, 1422, 5, 7, 0, 0, 1422, 245, 1, 0, 0, 0, 1423, 1428, 3, 248, 124, 0, 1424, 1425, 5, 12, 0, 0, 1425, 1427, 3, 248, 124, 0, 1426, 1424, 1, 0, 0, 0, 1427, 1430, 1, 0, 0, 0, 1428, 1426, 1, 0, 0, 0, 1428, 1429, 1, 0, 0, 0, 1429, 247, 1, 0, 0, 0, 1430, 1428, 1, 0, 0, 0, 1431, 1433, 5, 16, 0, 0, 1432, 1431, 1, 0, 0, 0, 1432, 1433, 1, 0, 0, 0, 1433, 1436, 1, 0, 0, 0, 1434, 1437, 3, 254, 127, 0, 1435, 1437, 5, 124, 0, 0, 1436, 1434, 1, 0, 0, 0, 1436, 1435, 1, 0, 0, 0, 1437, 249, 1, 0, 0, 0, 1438, 1443, 3, 254, 127, 0, 1439, 1440, 5, 12, 0, 0, 1440, 1442, 3, 254, 127, 0, 1441, 1439, 1, 0, 0, 0, 1442, 1445, 1, 0, 0, 0, 1443, 1441, 1, 0, 0, 0, 1443, 1444, 1, 0, 0, 0, 1444, 251, 1, 0, 0, 0, 1445, 1443, 1, 0, 0, 0, 1446, 1448, 5, 79, 0, 0, 1447, 1449, 5, 124, 0, 0, 1448, 1447, 1, 0, 0, 0, 1448, 1449, 1, 0, 0, 0, 1449, 1450, 1, 0, 0, 0, 1450, 1452, 5, 6, 0, 0, 1451, 1453, 3, 218, 109, 0, 1452, 1451, 1, 0, 0, 0, 1452, 1453, 1, 0, 0, 0, 1453, 1454, 1, 0, 0, 0, 1454, 1456, 5, 7, 0, 0, 1455, 1457, 3, 60, 30, 0, 1456, 1455, 1, 0, 0, 0, 1456, 1457, 1, 0, 0, 0, 1457, 1458, 1, 0, 0, 0, 1458, 1459, 5, 8, 0, 0, 1459, 1460, 3, 224, 112, 0, 1460, 1461, 5, 10, 0, 0, 1461, 253, 1, 0, 0, 0, 1462, 1463, 6, 127, -1, 0, 1463, 1517, 3, 252, 126, 0, 1464, 1517, 3, 258, 129, 0, 1465, 1466, 5, 68, 0, 0, 1466, 1468, 3, 254, 127, 0, 1467, 1469, 3, 12, 6, 0, 1468, 1467, 1, 0, 0, 0, 1468, 1469, 1, 0, 0, 0, 1469, 1470, 1, 0, 0, 0, 1470, 1471, 3, 244, 122, 0, 1471, 1517, 1, 0, 0, 0, 1472, 1473, 5, 68, 0, 0, 1473, 1475, 3, 254, 127, 0, 1474, 1476, 3, 12, 6, 0, 1475, 1474, 1, 0, 0, 0, 1475, 1476, 1, 0, 0, 0, 1476, 1517, 1, 0, 0, 0, 1477, 1478, 5, 85, 0, 0, 1478, 1517, 3, 254, 127, 38, 1479, 1480, 5, 73, 0, 0, 1480, 1517, 3, 254, 127, 37, 1481, 1482, 5, 65, 0, 0, 1482, 1517, 3, 254, 127, 36, 1483, 1484, 5, 18, 0, 0, 1484, 1517, 3, 254, 127, 35, 1485, 1486, 5, 19, 0, 0, 1486, 1517, 3, 254, 127, 34, 1487, 1488, 5, 20, 0, 0, 1488, 1517, 3, 254, 127, 33, 1489, 1490, 5, 21, 0, 0, 1490, 1517, 3, 254, 127, 32, 1491, 1492, 5, 22, 0, 0, 1492, 1517, 3, 254, 127, 31, 1493, 1494, 5, 23, 0, 0, 1494, 1517, 3, 254, 127, 30, 1495, 1517, 3, 214, 107, 0, 1496, 1517, 3, 210, 105, 0, 1497, 1517, 3, 208, 104, 0, 1498, 1517, 3, 160, 80, 0, 1499, 1517, 5, 80, 0, 0, 1500, 1502, 3, 274, 137, 0, 1501, 1503, 3, 254, 127, 0, 1502, 1501, 1, 0, 0, 0, 1502, 1503, 1, 0, 0, 0, 1503, 1517, 1, 0, 0, 0, 1504, 1517, 5, 95, 0, 0, 1505, 1517, 3, 266, 133, 0, 1506, 1517, 3, 228, 114, 0, 1507, 1517, 3, 234, 117, 0, 1508, 1509, 5, 6, 0, 0, 1509, 1510, 3, 250, 125, 0, 1510, 1511, 5, 7, 0, 0, 1511, 1517, 1, 0, 0, 0, 1512, 1514, 3, 12, 6, 0, 1513, 1515, 3, 250, 125, 0, 1514, 1513, 1, 0, 0, 0, 1514, 1515, 1, 0, 0, 0, 1515, 1517, 1, 0, 0, 0, 1516, 1462, 1, 0, 0, 0, 1516, 1464, 1, 0, 0, 0, 1516, 1465, 1, 0, 0, 0, 1516, 1472, 1, 0, 0, 0, 1516, 1477, 1, 0, 0, 0, 1516, 1479, 1, 0, 0, 0, 1516, 1481, 1, 0, 0, 0, 1516, 1483, 1, 0, 0, 0, 1516, 1485, 1, 0, 0, 0, 1516, 1487, 1, 0, 0, 0, 1516, 1489, 1, 0, 0, 0, 1516, 1491, 1, 0, 0, 0, 1516, 1493, 1, 0, 0, 0, 1516, 1495, 1, 0, 0, 0, 1516, 1496, 1, 0, 0, 0, 1516, 1497, 1, 0, 0, 0, 1516, 1498, 1, 0, 0, 0, 1516, 1499, 1, 0, 0, 0, 1516, 1500, 1, 0, 0, 0, 1516, 1504, 1, 0, 0, 0, 1516, 1505, 1, 0, 0, 0, 1516, 1506, 1, 0, 0, 0, 1516, 1507, 1, 0, 0, 0, 1516, 1508, 1, 0, 0, 0, 1516, 1512, 1, 0, 0, 0, 1517, 1596, 1, 0, 0, 0, 1518, 1519, 10, 29, 0, 0, 1519, 1520, 7, 6, 0, 0, 1520, 1595, 3, 254, 127, 30, 1521, 1522, 10, 28, 0, 0, 1522, 1523, 7, 7, 0, 0, 1523, 1595, 3, 254, 127, 29, 1524, 1525, 10, 27, 0, 0, 1525, 1526, 7, 8, 0, 0, 1526, 1595, 3, 254, 127, 28, 1527, 1528, 10, 26, 0, 0, 1528, 1529, 7, 9, 0, 0, 1529, 1595, 3, 254, 127, 27, 1530, 1531, 10, 25, 0, 0, 1531, 1532, 5, 64, 0, 0, 1532, 1595, 3, 254, 127, 26, 1533, 1534, 10, 24, 0, 0, 1534, 1535, 5, 86, 0, 0, 1535, 1595, 3, 254, 127, 25, 1536, 1537, 10, 23, 0, 0, 1537, 1538, 7, 10, 0, 0, 1538, 1595, 3, 254, 127, 24, 1539, 1540, 10, 22, 0, 0, 1540, 1541, 5, 38, 0, 0, 1541, 1595, 3, 254, 127, 23, 1542, 1543, 10, 21, 0, 0, 1543, 1544, 5, 39, 0, 0, 1544, 1595, 3, 254, 127, 22, 1545, 1546, 10, 20, 0, 0, 1546, 1547, 5, 40, 0, 0, 1547, 1595, 3, 254, 127, 21, 1548, 1549, 10, 19, 0, 0, 1549, 1550, 5, 41, 0, 0, 1550, 1595, 3, 254, 127, 20, 1551, 1552, 10, 18, 0, 0, 1552, 1553, 5, 42, 0, 0, 1553, 1595, 3, 254, 127, 19, 1554, 1555, 10, 17, 0, 0, 1555, 1556, 5, 14, 0, 0, 1556, 1557, 3, 254, 127, 0, 1557, 1558, 5, 15, 0, 0, 1558, 1559, 3, 254, 127, 18, 1559, 1595, 1, 0, 0, 0, 1560, 1561, 10, 16, 0, 0, 1561, 1562, 5, 13, 0, 0, 1562, 1595, 3, 254, 127, 17, 1563, 1564, 10, 15, 0, 0, 1564, 1565, 3, 264, 132, 0, 1565, 1566, 3, 254, 127, 16, 1566, 1595, 1, 0, 0, 0, 1567, 1568, 10, 45, 0, 0, 1568, 1569, 5, 4, 0, 0, 1569, 1570, 3, 250, 125, 0, 1570, 1571, 5, 5, 0, 0, 1571, 1595, 1, 0, 0, 0, 1572, 1574, 10, 44, 0, 0, 1573, 1575, 5, 23, 0, 0, 1574, 1573, 1, 0, 0, 0, 1574, 1575, 1, 0, 0, 0, 1575, 1576, 1, 0, 0, 0, 1576, 1577, 5, 17, 0, 0, 1577, 1579, 3, 274, 137, 0, 1578, 1580, 3, 28, 14, 0, 1579, 1578, 1, 0, 0, 0, 1579, 1580, 1, 0, 0, 0, 1580, 1595, 1, 0, 0, 0, 1581, 1582, 10, 41, 0, 0, 1582, 1595, 3, 244, 122, 0, 1583, 1584, 10, 40, 0, 0, 1584, 1585, 4, 127, 33, 0, 1585, 1595, 5, 18, 0, 0, 1586, 1587, 10, 39, 0, 0, 1587, 1588, 4, 127, 35, 0, 1588, 1595, 5, 19, 0, 0, 1589, 1590, 10, 14, 0, 0, 1590, 1595, 3, 268, 134, 0, 1591, 1592, 10, 1, 0, 0, 1592, 1593, 5, 88, 0, 0, 1593, 1595, 3, 256, 128, 0, 1594, 1518, 1, 0, 0, 0, 1594, 1521, 1, 0, 0, 0, 1594, 1524, 1, 0, 0, 0, 1594, 1527, 1, 0, 0, 0, 1594, 1530, 1, 0, 0, 0, 1594, 1533, 1, 0, 0, 0, 1594, 1536, 1, 0, 0, 0, 1594, 1539, 1, 0, 0, 0, 1594, 1542, 1, 0, 0, 0, 1594, 1545, 1, 0, 0, 0, 1594, 1548, 1, 0, 0, 0, 1594, 1551, 1, 0, 0, 0, 1594, 1554, 1, 0, 0, 0, 1594, 1560, 1, 0, 0, 0, 1594, 1563, 1, 0, 0, 0, 1594, 1567, 1, 0, 0, 0, 1594, 1572, 1, 0, 0, 0, 1594, 1581, 1, 0, 0, 0, 1594, 1583, 1, 0, 0, 0, 1594, 1586, 1, 0, 0, 0, 1594, 1589, 1, 0, 0, 0, 1594, 1591, 1, 0, 0, 0, 1595, 1598, 1, 0, 0, 0, 1596, 1594, 1, 0, 0, 0, 1596, 1597, 1, 0, 0, 0, 1597, 255, 1, 0, 0, 0, 1598, 1596, 1, 0, 0, 0, 1599, 1602, 3, 24, 12, 0, 1600, 1601, 5, 4, 0, 0, 1601, 1603, 5, 5, 0, 0, 1602, 1600, 1, 0, 0, 0, 1602, 1603, 1, 0, 0, 0, 1603, 1606, 1, 0, 0, 0, 1604, 1606, 3, 254, 127, 0, 1605, 1599, 1, 0, 0, 0, 1605, 1604, 1, 0, 0, 0, 1606, 257, 1, 0, 0, 0, 1607, 1609, 5, 91, 0, 0, 1608, 1607, 1, 0, 0, 0, 1608, 1609, 1, 0, 0, 0, 1609, 1610, 1, 0, 0, 0, 1610, 1612, 3, 260, 130, 0, 1611, 1613, 3, 60, 30, 0, 1612, 1611, 1, 0, 0, 0, 1612, 1613, 1, 0, 0, 0, 1613, 1614, 1, 0, 0, 0, 1614, 1615, 5, 54, 0, 0, 1615, 1616, 3, 262, 131, 0, 1616, 259, 1, 0, 0, 0, 1617, 1624, 5, 124, 0, 0, 1618, 1620, 5, 6, 0, 0, 1619, 1621, 3, 218, 109, 0, 1620, 1619, 1, 0, 0, 0, 1620, 1621, 1, 0, 0, 0, 1621, 1622, 1, 0, 0, 0, 1622, 1624, 5, 7, 0, 0, 1623, 1617, 1, 0, 0, 0, 1623, 1618, 1, 0, 0, 0, 1624, 261, 1, 0, 0, 0, 1625, 1631, 3, 254, 127, 0, 1626, 1627, 5, 8, 0, 0, 1627, 1628, 3, 224, 112, 0, 1628, 1629, 5, 10, 0, 0, 1629, 1631, 1, 0, 0, 0, 1630, 1625, 1, 0, 0, 0, 1630, 1626, 1, 0, 0, 0, 1631, 263, 1, 0, 0, 0, 1632, 1633, 7, 11, 0, 0, 1633, 265, 1, 0, 0, 0, 1634, 1641, 5, 55, 0, 0, 1635, 1641, 5, 56, 0, 0, 1636, 1641, 5, 125, 0, 0, 1637, 1641, 3, 268, 134, 0, 1638, 1641, 5, 3, 0, 0, 1639, 1641, 3, 272, 136, 0, 1640, 1634, 1, 0, 0, 0, 1640, 1635, 1, 0, 0, 0, 1640, 1636, 1, 0, 0, 0, 1640, 1637, 1, 0, 0, 0, 1640, 1638, 1, 0, 0, 0, 1640, 1639, 1, 0, 0, 0, 1641, 267, 1, 0, 0, 0, 1642, 1646, 5, 126, 0, 0, 1643, 1645, 3, 270, 135, 0, 1644, 1643, 1, 0, 0, 0, 1645, 1648, 1, 0, 0, 0, 1646, 1644, 1, 0, 0, 0, 1646, 1647, 1, 0, 0, 0, 1647, 1649, 1, 0, 0, 0, 1648, 1646, 1, 0, 0, 0, 1649, 1650, 5, 126, 0, 0, 1650, 269, 1, 0, 0, 0, 1651, 1658, 5, 134, 0, 0, 1652, 1653, 5, 133, 0, 0, 1653, 1654, 3, 254, 127, 0, 1654, 1655, 5, 9, 0, 0, 1655, 1658, 1, 0, 0, 0, 1656, 1658, 5, 132, 0, 0, 1657, 1651, 1, 0, 0, 0, 1657, 1652, 1, 0, 0, 0, 1657, 1656, 1, 0, 0, 0, 1658, 271, 1, 0, 0, 0, 1659, 1660, 7, 12, 0, 0, 1660, 273, 1, 0, 0, 0, 1661, 1664, 5, 124, 0, 0, 1662, 1664, 3, 278, 139, 0, 1663, 1661, 1, 0, 0, 0, 1663, 1662, 1, 0, 0, 0, 1664, 275, 1, 0, 0, 0, 1665, 1666, 7, 13, 0, 0, 1666, 277, 1, 0, 0, 0, 1667, 1671, 3, 280, 140, 0, 1668, 1671, 5, 55, 0, 0, 1669, 1671, 5, 56, 0, 0, 1670, 1667, 1, 0, 0, 0, 1670, 1668, 1, 0, 0, 0, 1670, 1669, 1, 0, 0, 0, 1671, 279, 1, 0, 0, 0, 1672, 1673, 7, 14, 0, 0, 1673, 281, 1, 0, 0, 0, 1674, 1675, 5, 114, 0, 0, 1675, 1676, 3, 242, 121, 0, 1676, 283, 1, 0, 0, 0, 1677, 1678, 5, 115, 0, 0, 1678, 1679, 3, 242, 121, 0, 1679, 285, 1, 0, 0, 0, 1680, 1685, 5, 11, 0, 0, 1681, 1685, 5, 0, 0, 1, 1682, 1685, 4, 143, 38, 0, 1683, 1685, 4, 143, 39, 0, 1684, 1680, 1, 0, 0, 0, 1684, 1681, 1, 0, 0, 0, 1684, 1682, 1, 0, 0, 0, 1684, 1683, 1, 0, 0, 0, 1685, 287, 1, 0, 0, 0, 213, 293, 297, 306, 311, 314, 321, 330, 340, 351, 353, 374, 382, 389, 393, 408, 412, 416, 422, 429, 439, 441, 457, 461, 465, 473, 477, 492, 496, 499, 503, 506, 510, 516, 520, 524, 532, 537, 539, 546, 551, 554, 557, 562, 565, 568, 573, 576, 579, 583, 589, 593, 597, 601, 612, 619, 626, 631, 639, 642, 645, 650, 653, 657, 667, 671, 677, 683, 690, 696, 702, 710, 715, 726, 731, 739, 746, 753, 758, 791, 795, 802, 808, 815, 819, 823, 832, 840, 847, 851, 855, 859, 862, 865, 868, 872, 876, 880, 882, 889, 895, 898, 901, 905, 908, 915, 924, 943, 947, 951, 961, 965, 976, 989, 995, 1002, 1009, 1016, 1023, 1041, 1045, 1047, 1054, 1060, 1065, 1080, 1083, 1105, 1108, 1112, 1114, 1117, 1122, 1128, 1131, 1137, 1150, 1155, 1160, 1163, 1166, 1178, 1183, 1186, 1189, 1192, 1195, 1198, 1204, 1209, 1219, 1223, 1236, 1240, 1253, 1257, 1266, 1278, 1283, 1290, 1292, 1295, 1298, 1302, 1305, 1309, 1314, 1317, 1322, 1326, 1334, 1339, 1343, 1347, 1350, 1358, 1362, 1364, 1383, 1389, 1399, 1402, 1412, 1417, 1419, 1428, 1432, 1436, 1443, 1448, 1452, 1456, 1468, 1475, 1502, 1514, 1516, 1574, 1579, 1594, 1596, 1602, 1605, 1608, 1612, 1620, 1623, 1630, 1640, 1646, 1657, 1663, 1670, 1684]
\ No newline at end of file
diff --git a/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParser.java b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParser.java
new file mode 100644
index 0000000..5c767ed
--- /dev/null
+++ b/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParser.java
@@ -0,0 +1,15238 @@
+// Generated from /www/p_java/babylon/src/main/java/one/edee/babylon/export/ts/gen/TypeScriptParser.g4 by ANTLR 4.13.1
+package one.edee.babylon.export.ts.gen;
+import one.edee.babylon.export.ts.TypeScriptParserBase;
+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", "CheckReturnValue"})
+public class TypeScriptParser extends TypeScriptParserBase {
+ static { RuntimeMetaData.checkVersion("4.13.1", RuntimeMetaData.VERSION); }
+
+ protected static final DFA[] _decisionToDFA;
+ protected static final PredictionContextCache _sharedContextCache =
+ new PredictionContextCache();
+ public static final int
+ MultiLineComment=1, SingleLineComment=2, RegularExpressionLiteral=3, OpenBracket=4,
+ CloseBracket=5, OpenParen=6, CloseParen=7, OpenBrace=8, TemplateCloseBrace=9,
+ CloseBrace=10, SemiColon=11, Comma=12, Assign=13, QuestionMark=14, Colon=15,
+ Ellipsis=16, Dot=17, PlusPlus=18, MinusMinus=19, Plus=20, Minus=21, BitNot=22,
+ Not=23, Multiply=24, Divide=25, Modulus=26, RightShiftArithmetic=27, LeftShiftArithmetic=28,
+ RightShiftLogical=29, LessThan=30, MoreThan=31, LessThanEquals=32, GreaterThanEquals=33,
+ Equals_=34, NotEquals=35, IdentityEquals=36, IdentityNotEquals=37, BitAnd=38,
+ BitXOr=39, BitOr=40, And=41, Or=42, MultiplyAssign=43, DivideAssign=44,
+ ModulusAssign=45, PlusAssign=46, MinusAssign=47, LeftShiftArithmeticAssign=48,
+ RightShiftArithmeticAssign=49, RightShiftLogicalAssign=50, BitAndAssign=51,
+ BitXorAssign=52, BitOrAssign=53, ARROW=54, NullLiteral=55, BooleanLiteral=56,
+ DecimalLiteral=57, HexIntegerLiteral=58, OctalIntegerLiteral=59, OctalIntegerLiteral2=60,
+ BinaryIntegerLiteral=61, Break=62, Do=63, Instanceof=64, Typeof=65, Case=66,
+ Else=67, New=68, Var=69, Catch=70, Finally=71, Return=72, Void=73, Continue=74,
+ For=75, Switch=76, While=77, Debugger=78, Function_=79, This=80, With=81,
+ Default=82, If=83, Throw=84, Delete=85, In=86, Try=87, As=88, From=89,
+ ReadOnly=90, Async=91, Class=92, Enum=93, Extends=94, Super=95, Const=96,
+ Export=97, Import=98, Implements=99, Let=100, Private=101, Public=102,
+ Interface=103, Package=104, Protected=105, Static=106, Yield=107, Any=108,
+ Number=109, Boolean=110, String=111, Symbol=112, TypeAlias=113, Get=114,
+ Set=115, Constructor=116, Namespace=117, Require=118, Module=119, Declare=120,
+ Abstract=121, Is=122, At=123, Identifier=124, StringLiteral=125, BackTick=126,
+ WhiteSpaces=127, LineTerminator=128, HtmlComment=129, CDataComment=130,
+ UnexpectedCharacter=131, TemplateStringEscapeAtom=132, TemplateStringStartExpression=133,
+ TemplateStringAtom=134;
+ public static final int
+ RULE_initializer = 0, RULE_bindingPattern = 1, RULE_typeParameters = 2,
+ RULE_typeParameterList = 3, RULE_typeParameter = 4, RULE_constraint = 5,
+ RULE_typeArguments = 6, RULE_typeArgumentList = 7, RULE_typeArgument = 8,
+ RULE_type_ = 9, RULE_unionOrIntersectionOrPrimaryType = 10, RULE_primaryType = 11,
+ RULE_predefinedType = 12, RULE_typeReference = 13, RULE_nestedTypeGeneric = 14,
+ RULE_typeGeneric = 15, RULE_typeIncludeGeneric = 16, RULE_typeName = 17,
+ RULE_objectType = 18, RULE_typeBody = 19, RULE_typeMemberList = 20, RULE_typeMember = 21,
+ RULE_arrayType = 22, RULE_tupleType = 23, RULE_tupleElementTypes = 24,
+ RULE_functionType = 25, RULE_constructorType = 26, RULE_typeQuery = 27,
+ RULE_typeQueryExpression = 28, RULE_propertySignatur = 29, RULE_typeAnnotation = 30,
+ RULE_callSignature = 31, RULE_parameterList = 32, RULE_requiredParameterList = 33,
+ RULE_parameter = 34, RULE_optionalParameter = 35, RULE_restParameter = 36,
+ RULE_requiredParameter = 37, RULE_accessibilityModifier = 38, RULE_identifierOrPattern = 39,
+ RULE_constructSignature = 40, RULE_indexSignature = 41, RULE_methodSignature = 42,
+ RULE_typeAliasDeclaration = 43, RULE_constructorDeclaration = 44, RULE_interfaceDeclaration = 45,
+ RULE_interfaceExtendsClause = 46, RULE_classOrInterfaceTypeList = 47,
+ RULE_enumDeclaration = 48, RULE_enumBody = 49, RULE_enumMemberList = 50,
+ RULE_enumMember = 51, RULE_namespaceDeclaration = 52, RULE_namespaceName = 53,
+ RULE_importAliasDeclaration = 54, RULE_decoratorList = 55, RULE_decorator = 56,
+ RULE_decoratorMemberExpression = 57, RULE_decoratorCallExpression = 58,
+ RULE_program = 59, RULE_sourceElement = 60, RULE_statement = 61, RULE_block = 62,
+ RULE_statementList = 63, RULE_abstractDeclaration = 64, RULE_importStatement = 65,
+ RULE_fromBlock = 66, RULE_multipleImportStatement = 67, RULE_exportStatement = 68,
+ RULE_variableStatement = 69, RULE_variableDeclarationList = 70, RULE_variableDeclaration = 71,
+ RULE_emptyStatement_ = 72, RULE_expressionStatement = 73, RULE_ifStatement = 74,
+ RULE_iterationStatement = 75, RULE_varModifier = 76, RULE_continueStatement = 77,
+ RULE_breakStatement = 78, RULE_returnStatement = 79, RULE_yieldStatement = 80,
+ RULE_withStatement = 81, RULE_switchStatement = 82, RULE_caseBlock = 83,
+ RULE_caseClauses = 84, RULE_caseClause = 85, RULE_defaultClause = 86,
+ RULE_labelledStatement = 87, RULE_throwStatement = 88, RULE_tryStatement = 89,
+ RULE_catchProduction = 90, RULE_finallyProduction = 91, RULE_debuggerStatement = 92,
+ RULE_functionDeclaration = 93, RULE_classDeclaration = 94, RULE_classHeritage = 95,
+ RULE_classTail = 96, RULE_classExtendsClause = 97, RULE_implementsClause = 98,
+ RULE_classElement = 99, RULE_propertyMemberDeclaration = 100, RULE_propertyMemberBase = 101,
+ RULE_indexMemberDeclaration = 102, RULE_generatorMethod = 103, RULE_generatorFunctionDeclaration = 104,
+ RULE_generatorBlock = 105, RULE_generatorDefinition = 106, RULE_iteratorBlock = 107,
+ RULE_iteratorDefinition = 108, RULE_formalParameterList = 109, RULE_formalParameterArg = 110,
+ RULE_lastFormalParameterArg = 111, RULE_functionBody = 112, RULE_sourceElements = 113,
+ RULE_arrayLiteral = 114, RULE_elementList = 115, RULE_arrayElement = 116,
+ RULE_objectLiteral = 117, RULE_propertyAssignment = 118, RULE_getAccessor = 119,
+ RULE_setAccessor = 120, RULE_propertyName = 121, RULE_arguments = 122,
+ RULE_argumentList = 123, RULE_argument = 124, RULE_expressionSequence = 125,
+ RULE_functionExpressionDeclaration = 126, RULE_singleExpression = 127,
+ RULE_asExpression = 128, RULE_arrowFunctionDeclaration = 129, RULE_arrowFunctionParameters = 130,
+ RULE_arrowFunctionBody = 131, RULE_assignmentOperator = 132, RULE_literal = 133,
+ RULE_templateStringLiteral = 134, RULE_templateStringAtom = 135, RULE_numericLiteral = 136,
+ RULE_identifierName = 137, RULE_identifierOrKeyWord = 138, RULE_reservedWord = 139,
+ RULE_keyword = 140, RULE_getter = 141, RULE_setter = 142, RULE_eos = 143;
+ private static String[] makeRuleNames() {
+ return new String[] {
+ "initializer", "bindingPattern", "typeParameters", "typeParameterList",
+ "typeParameter", "constraint", "typeArguments", "typeArgumentList", "typeArgument",
+ "type_", "unionOrIntersectionOrPrimaryType", "primaryType", "predefinedType",
+ "typeReference", "nestedTypeGeneric", "typeGeneric", "typeIncludeGeneric",
+ "typeName", "objectType", "typeBody", "typeMemberList", "typeMember",
+ "arrayType", "tupleType", "tupleElementTypes", "functionType", "constructorType",
+ "typeQuery", "typeQueryExpression", "propertySignatur", "typeAnnotation",
+ "callSignature", "parameterList", "requiredParameterList", "parameter",
+ "optionalParameter", "restParameter", "requiredParameter", "accessibilityModifier",
+ "identifierOrPattern", "constructSignature", "indexSignature", "methodSignature",
+ "typeAliasDeclaration", "constructorDeclaration", "interfaceDeclaration",
+ "interfaceExtendsClause", "classOrInterfaceTypeList", "enumDeclaration",
+ "enumBody", "enumMemberList", "enumMember", "namespaceDeclaration", "namespaceName",
+ "importAliasDeclaration", "decoratorList", "decorator", "decoratorMemberExpression",
+ "decoratorCallExpression", "program", "sourceElement", "statement", "block",
+ "statementList", "abstractDeclaration", "importStatement", "fromBlock",
+ "multipleImportStatement", "exportStatement", "variableStatement", "variableDeclarationList",
+ "variableDeclaration", "emptyStatement_", "expressionStatement", "ifStatement",
+ "iterationStatement", "varModifier", "continueStatement", "breakStatement",
+ "returnStatement", "yieldStatement", "withStatement", "switchStatement",
+ "caseBlock", "caseClauses", "caseClause", "defaultClause", "labelledStatement",
+ "throwStatement", "tryStatement", "catchProduction", "finallyProduction",
+ "debuggerStatement", "functionDeclaration", "classDeclaration", "classHeritage",
+ "classTail", "classExtendsClause", "implementsClause", "classElement",
+ "propertyMemberDeclaration", "propertyMemberBase", "indexMemberDeclaration",
+ "generatorMethod", "generatorFunctionDeclaration", "generatorBlock",
+ "generatorDefinition", "iteratorBlock", "iteratorDefinition", "formalParameterList",
+ "formalParameterArg", "lastFormalParameterArg", "functionBody", "sourceElements",
+ "arrayLiteral", "elementList", "arrayElement", "objectLiteral", "propertyAssignment",
+ "getAccessor", "setAccessor", "propertyName", "arguments", "argumentList",
+ "argument", "expressionSequence", "functionExpressionDeclaration", "singleExpression",
+ "asExpression", "arrowFunctionDeclaration", "arrowFunctionParameters",
+ "arrowFunctionBody", "assignmentOperator", "literal", "templateStringLiteral",
+ "templateStringAtom", "numericLiteral", "identifierName", "identifierOrKeyWord",
+ "reservedWord", "keyword", "getter", "setter", "eos"
+ };
+ }
+ public static final String[] ruleNames = makeRuleNames();
+
+ private static String[] makeLiteralNames() {
+ return new String[] {
+ null, null, null, null, "'['", "']'", "'('", "')'", "'{'", null, "'}'",
+ "';'", "','", "'='", "'?'", "':'", "'...'", "'.'", "'++'", "'--'", "'+'",
+ "'-'", "'~'", "'!'", "'*'", "'/'", "'%'", "'>>'", "'<<'", "'>>>'", "'<'",
+ "'>'", "'<='", "'>='", "'=='", "'!='", "'==='", "'!=='", "'&'", "'^'",
+ "'|'", "'&&'", "'||'", "'*='", "'/='", "'%='", "'+='", "'-='", "'<<='",
+ "'>>='", "'>>>='", "'&='", "'^='", "'|='", "'=>'", "'null'", null, null,
+ null, null, null, null, "'break'", "'do'", "'instanceof'", "'typeof'",
+ "'case'", "'else'", "'new'", "'var'", "'catch'", "'finally'", "'return'",
+ "'void'", "'continue'", "'for'", "'switch'", "'while'", "'debugger'",
+ "'function'", "'this'", "'with'", "'default'", "'if'", "'throw'", "'delete'",
+ "'in'", "'try'", "'as'", "'from'", "'readonly'", "'async'", "'class'",
+ "'enum'", "'extends'", "'super'", "'const'", "'export'", "'import'",
+ "'implements'", "'let'", "'private'", "'public'", "'interface'", "'package'",
+ "'protected'", "'static'", "'yield'", "'any'", "'number'", "'boolean'",
+ "'string'", "'symbol'", "'type'", "'get'", "'set'", "'constructor'",
+ "'namespace'", "'require'", "'module'", "'declare'", "'abstract'", "'is'",
+ "'@'"
+ };
+ }
+ private static final String[] _LITERAL_NAMES = makeLiteralNames();
+ private static String[] makeSymbolicNames() {
+ return new String[] {
+ null, "MultiLineComment", "SingleLineComment", "RegularExpressionLiteral",
+ "OpenBracket", "CloseBracket", "OpenParen", "CloseParen", "OpenBrace",
+ "TemplateCloseBrace", "CloseBrace", "SemiColon", "Comma", "Assign", "QuestionMark",
+ "Colon", "Ellipsis", "Dot", "PlusPlus", "MinusMinus", "Plus", "Minus",
+ "BitNot", "Not", "Multiply", "Divide", "Modulus", "RightShiftArithmetic",
+ "LeftShiftArithmetic", "RightShiftLogical", "LessThan", "MoreThan", "LessThanEquals",
+ "GreaterThanEquals", "Equals_", "NotEquals", "IdentityEquals", "IdentityNotEquals",
+ "BitAnd", "BitXOr", "BitOr", "And", "Or", "MultiplyAssign", "DivideAssign",
+ "ModulusAssign", "PlusAssign", "MinusAssign", "LeftShiftArithmeticAssign",
+ "RightShiftArithmeticAssign", "RightShiftLogicalAssign", "BitAndAssign",
+ "BitXorAssign", "BitOrAssign", "ARROW", "NullLiteral", "BooleanLiteral",
+ "DecimalLiteral", "HexIntegerLiteral", "OctalIntegerLiteral", "OctalIntegerLiteral2",
+ "BinaryIntegerLiteral", "Break", "Do", "Instanceof", "Typeof", "Case",
+ "Else", "New", "Var", "Catch", "Finally", "Return", "Void", "Continue",
+ "For", "Switch", "While", "Debugger", "Function_", "This", "With", "Default",
+ "If", "Throw", "Delete", "In", "Try", "As", "From", "ReadOnly", "Async",
+ "Class", "Enum", "Extends", "Super", "Const", "Export", "Import", "Implements",
+ "Let", "Private", "Public", "Interface", "Package", "Protected", "Static",
+ "Yield", "Any", "Number", "Boolean", "String", "Symbol", "TypeAlias",
+ "Get", "Set", "Constructor", "Namespace", "Require", "Module", "Declare",
+ "Abstract", "Is", "At", "Identifier", "StringLiteral", "BackTick", "WhiteSpaces",
+ "LineTerminator", "HtmlComment", "CDataComment", "UnexpectedCharacter",
+ "TemplateStringEscapeAtom", "TemplateStringStartExpression", "TemplateStringAtom"
+ };
+ }
+ 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 "TypeScriptParser.g4"; }
+
+ @Override
+ public String[] getRuleNames() { return ruleNames; }
+
+ @Override
+ public String getSerializedATN() { return _serializedATN; }
+
+ @Override
+ public ATN getATN() { return _ATN; }
+
+ public TypeScriptParser(TokenStream input) {
+ super(input);
+ _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class InitializerContext extends ParserRuleContext {
+ public TerminalNode Assign() { return getToken(TypeScriptParser.Assign, 0); }
+ public SingleExpressionContext singleExpression() {
+ return getRuleContext(SingleExpressionContext.class,0);
+ }
+ public InitializerContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_initializer; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterInitializer(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitInitializer(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitInitializer(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final InitializerContext initializer() throws RecognitionException {
+ InitializerContext _localctx = new InitializerContext(_ctx, getState());
+ enterRule(_localctx, 0, RULE_initializer);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(288);
+ match(Assign);
+ setState(289);
+ singleExpression(0);
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class BindingPatternContext extends ParserRuleContext {
+ public ArrayLiteralContext arrayLiteral() {
+ return getRuleContext(ArrayLiteralContext.class,0);
+ }
+ public ObjectLiteralContext objectLiteral() {
+ return getRuleContext(ObjectLiteralContext.class,0);
+ }
+ public BindingPatternContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_bindingPattern; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterBindingPattern(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitBindingPattern(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitBindingPattern(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final BindingPatternContext bindingPattern() throws RecognitionException {
+ BindingPatternContext _localctx = new BindingPatternContext(_ctx, getState());
+ enterRule(_localctx, 2, RULE_bindingPattern);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(293);
+ _errHandler.sync(this);
+ switch (_input.LA(1)) {
+ case OpenBracket:
+ {
+ setState(291);
+ arrayLiteral();
+ }
+ break;
+ case OpenBrace:
+ {
+ setState(292);
+ objectLiteral();
+ }
+ break;
+ default:
+ throw new NoViableAltException(this);
+ }
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class TypeParametersContext extends ParserRuleContext {
+ public TerminalNode LessThan() { return getToken(TypeScriptParser.LessThan, 0); }
+ public TerminalNode MoreThan() { return getToken(TypeScriptParser.MoreThan, 0); }
+ public TypeParameterListContext typeParameterList() {
+ return getRuleContext(TypeParameterListContext.class,0);
+ }
+ public TypeParametersContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_typeParameters; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeParameters(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeParameters(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitTypeParameters(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final TypeParametersContext typeParameters() throws RecognitionException {
+ TypeParametersContext _localctx = new TypeParametersContext(_ctx, getState());
+ enterRule(_localctx, 4, RULE_typeParameters);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(295);
+ match(LessThan);
+ setState(297);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==LessThan || _la==Identifier) {
+ {
+ setState(296);
+ typeParameterList();
+ }
+ }
+
+ setState(299);
+ match(MoreThan);
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class TypeParameterListContext extends ParserRuleContext {
+ public List typeParameter() {
+ return getRuleContexts(TypeParameterContext.class);
+ }
+ public TypeParameterContext typeParameter(int i) {
+ return getRuleContext(TypeParameterContext.class,i);
+ }
+ public List Comma() { return getTokens(TypeScriptParser.Comma); }
+ public TerminalNode Comma(int i) {
+ return getToken(TypeScriptParser.Comma, i);
+ }
+ public TypeParameterListContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_typeParameterList; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeParameterList(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeParameterList(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitTypeParameterList(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final TypeParameterListContext typeParameterList() throws RecognitionException {
+ TypeParameterListContext _localctx = new TypeParameterListContext(_ctx, getState());
+ enterRule(_localctx, 6, RULE_typeParameterList);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(301);
+ typeParameter();
+ setState(306);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ while (_la==Comma) {
+ {
+ {
+ setState(302);
+ match(Comma);
+ setState(303);
+ typeParameter();
+ }
+ }
+ setState(308);
+ _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;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class TypeParameterContext extends ParserRuleContext {
+ public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
+ public ConstraintContext constraint() {
+ return getRuleContext(ConstraintContext.class,0);
+ }
+ public TypeParametersContext typeParameters() {
+ return getRuleContext(TypeParametersContext.class,0);
+ }
+ public TypeParameterContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_typeParameter; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeParameter(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeParameter(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitTypeParameter(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final TypeParameterContext typeParameter() throws RecognitionException {
+ TypeParameterContext _localctx = new TypeParameterContext(_ctx, getState());
+ enterRule(_localctx, 8, RULE_typeParameter);
+ int _la;
+ try {
+ setState(314);
+ _errHandler.sync(this);
+ switch (_input.LA(1)) {
+ case Identifier:
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(309);
+ match(Identifier);
+ setState(311);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==Extends) {
+ {
+ setState(310);
+ constraint();
+ }
+ }
+
+ }
+ break;
+ case LessThan:
+ enterOuterAlt(_localctx, 2);
+ {
+ setState(313);
+ typeParameters();
+ }
+ break;
+ default:
+ throw new NoViableAltException(this);
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class ConstraintContext extends ParserRuleContext {
+ public TerminalNode Extends() { return getToken(TypeScriptParser.Extends, 0); }
+ public Type_Context type_() {
+ return getRuleContext(Type_Context.class,0);
+ }
+ public ConstraintContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_constraint; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterConstraint(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitConstraint(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitConstraint(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final ConstraintContext constraint() throws RecognitionException {
+ ConstraintContext _localctx = new ConstraintContext(_ctx, getState());
+ enterRule(_localctx, 10, RULE_constraint);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(316);
+ match(Extends);
+ setState(317);
+ type_();
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class TypeArgumentsContext extends ParserRuleContext {
+ public TerminalNode LessThan() { return getToken(TypeScriptParser.LessThan, 0); }
+ public TerminalNode MoreThan() { return getToken(TypeScriptParser.MoreThan, 0); }
+ public TypeArgumentListContext typeArgumentList() {
+ return getRuleContext(TypeArgumentListContext.class,0);
+ }
+ public TypeArgumentsContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_typeArguments; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeArguments(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeArguments(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitTypeArguments(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final TypeArgumentsContext typeArguments() throws RecognitionException {
+ TypeArgumentsContext _localctx = new TypeArgumentsContext(_ctx, getState());
+ enterRule(_localctx, 12, RULE_typeArguments);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(319);
+ match(LessThan);
+ setState(321);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 1073742160L) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & 1729654935793991945L) != 0)) {
+ {
+ setState(320);
+ typeArgumentList();
+ }
+ }
+
+ setState(323);
+ match(MoreThan);
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class TypeArgumentListContext extends ParserRuleContext {
+ public List typeArgument() {
+ return getRuleContexts(TypeArgumentContext.class);
+ }
+ public TypeArgumentContext typeArgument(int i) {
+ return getRuleContext(TypeArgumentContext.class,i);
+ }
+ public List Comma() { return getTokens(TypeScriptParser.Comma); }
+ public TerminalNode Comma(int i) {
+ return getToken(TypeScriptParser.Comma, i);
+ }
+ public TypeArgumentListContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_typeArgumentList; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeArgumentList(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeArgumentList(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitTypeArgumentList(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final TypeArgumentListContext typeArgumentList() throws RecognitionException {
+ TypeArgumentListContext _localctx = new TypeArgumentListContext(_ctx, getState());
+ enterRule(_localctx, 14, RULE_typeArgumentList);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(325);
+ typeArgument();
+ setState(330);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ while (_la==Comma) {
+ {
+ {
+ setState(326);
+ match(Comma);
+ setState(327);
+ typeArgument();
+ }
+ }
+ setState(332);
+ _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;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class TypeArgumentContext extends ParserRuleContext {
+ public Type_Context type_() {
+ return getRuleContext(Type_Context.class,0);
+ }
+ public TypeArgumentContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_typeArgument; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeArgument(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeArgument(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitTypeArgument(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final TypeArgumentContext typeArgument() throws RecognitionException {
+ TypeArgumentContext _localctx = new TypeArgumentContext(_ctx, getState());
+ enterRule(_localctx, 16, RULE_typeArgument);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(333);
+ type_();
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class Type_Context extends ParserRuleContext {
+ public UnionOrIntersectionOrPrimaryTypeContext unionOrIntersectionOrPrimaryType() {
+ return getRuleContext(UnionOrIntersectionOrPrimaryTypeContext.class,0);
+ }
+ public FunctionTypeContext functionType() {
+ return getRuleContext(FunctionTypeContext.class,0);
+ }
+ public ConstructorTypeContext constructorType() {
+ return getRuleContext(ConstructorTypeContext.class,0);
+ }
+ public TypeGenericContext typeGeneric() {
+ return getRuleContext(TypeGenericContext.class,0);
+ }
+ public TerminalNode StringLiteral() { return getToken(TypeScriptParser.StringLiteral, 0); }
+ public Type_Context(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_type_; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterType_(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitType_(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitType_(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final Type_Context type_() throws RecognitionException {
+ Type_Context _localctx = new Type_Context(_ctx, getState());
+ enterRule(_localctx, 18, RULE_type_);
+ try {
+ setState(340);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) {
+ case 1:
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(335);
+ unionOrIntersectionOrPrimaryType(0);
+ }
+ break;
+ case 2:
+ enterOuterAlt(_localctx, 2);
+ {
+ setState(336);
+ functionType();
+ }
+ break;
+ case 3:
+ enterOuterAlt(_localctx, 3);
+ {
+ setState(337);
+ constructorType();
+ }
+ break;
+ case 4:
+ enterOuterAlt(_localctx, 4);
+ {
+ setState(338);
+ typeGeneric();
+ }
+ break;
+ case 5:
+ enterOuterAlt(_localctx, 5);
+ {
+ setState(339);
+ match(StringLiteral);
+ }
+ break;
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class UnionOrIntersectionOrPrimaryTypeContext extends ParserRuleContext {
+ public UnionOrIntersectionOrPrimaryTypeContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_unionOrIntersectionOrPrimaryType; }
+
+ public UnionOrIntersectionOrPrimaryTypeContext() { }
+ public void copyFrom(UnionOrIntersectionOrPrimaryTypeContext ctx) {
+ super.copyFrom(ctx);
+ }
+ }
+ @SuppressWarnings("CheckReturnValue")
+ public static class IntersectionContext extends UnionOrIntersectionOrPrimaryTypeContext {
+ public List unionOrIntersectionOrPrimaryType() {
+ return getRuleContexts(UnionOrIntersectionOrPrimaryTypeContext.class);
+ }
+ public UnionOrIntersectionOrPrimaryTypeContext unionOrIntersectionOrPrimaryType(int i) {
+ return getRuleContext(UnionOrIntersectionOrPrimaryTypeContext.class,i);
+ }
+ public TerminalNode BitAnd() { return getToken(TypeScriptParser.BitAnd, 0); }
+ public IntersectionContext(UnionOrIntersectionOrPrimaryTypeContext ctx) { copyFrom(ctx); }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterIntersection(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitIntersection(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitIntersection(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+ @SuppressWarnings("CheckReturnValue")
+ public static class PrimaryContext extends UnionOrIntersectionOrPrimaryTypeContext {
+ public PrimaryTypeContext primaryType() {
+ return getRuleContext(PrimaryTypeContext.class,0);
+ }
+ public PrimaryContext(UnionOrIntersectionOrPrimaryTypeContext ctx) { copyFrom(ctx); }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterPrimary(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitPrimary(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitPrimary(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+ @SuppressWarnings("CheckReturnValue")
+ public static class UnionContext extends UnionOrIntersectionOrPrimaryTypeContext {
+ public List unionOrIntersectionOrPrimaryType() {
+ return getRuleContexts(UnionOrIntersectionOrPrimaryTypeContext.class);
+ }
+ public UnionOrIntersectionOrPrimaryTypeContext unionOrIntersectionOrPrimaryType(int i) {
+ return getRuleContext(UnionOrIntersectionOrPrimaryTypeContext.class,i);
+ }
+ public TerminalNode BitOr() { return getToken(TypeScriptParser.BitOr, 0); }
+ public UnionContext(UnionOrIntersectionOrPrimaryTypeContext ctx) { copyFrom(ctx); }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterUnion(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitUnion(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitUnion(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final UnionOrIntersectionOrPrimaryTypeContext unionOrIntersectionOrPrimaryType() throws RecognitionException {
+ return unionOrIntersectionOrPrimaryType(0);
+ }
+
+ private UnionOrIntersectionOrPrimaryTypeContext unionOrIntersectionOrPrimaryType(int _p) throws RecognitionException {
+ ParserRuleContext _parentctx = _ctx;
+ int _parentState = getState();
+ UnionOrIntersectionOrPrimaryTypeContext _localctx = new UnionOrIntersectionOrPrimaryTypeContext(_ctx, _parentState);
+ UnionOrIntersectionOrPrimaryTypeContext _prevctx = _localctx;
+ int _startState = 20;
+ enterRecursionRule(_localctx, 20, RULE_unionOrIntersectionOrPrimaryType, _p);
+ try {
+ int _alt;
+ enterOuterAlt(_localctx, 1);
+ {
+ {
+ _localctx = new PrimaryContext(_localctx);
+ _ctx = _localctx;
+ _prevctx = _localctx;
+
+ setState(343);
+ primaryType(0);
+ }
+ _ctx.stop = _input.LT(-1);
+ setState(353);
+ _errHandler.sync(this);
+ _alt = getInterpreter().adaptivePredict(_input,9,_ctx);
+ while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+ if ( _alt==1 ) {
+ if ( _parseListeners!=null ) triggerExitRuleEvent();
+ _prevctx = _localctx;
+ {
+ setState(351);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) {
+ case 1:
+ {
+ _localctx = new UnionContext(new UnionOrIntersectionOrPrimaryTypeContext(_parentctx, _parentState));
+ pushNewRecursionContext(_localctx, _startState, RULE_unionOrIntersectionOrPrimaryType);
+ setState(345);
+ if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)");
+ setState(346);
+ match(BitOr);
+ setState(347);
+ unionOrIntersectionOrPrimaryType(4);
+ }
+ break;
+ case 2:
+ {
+ _localctx = new IntersectionContext(new UnionOrIntersectionOrPrimaryTypeContext(_parentctx, _parentState));
+ pushNewRecursionContext(_localctx, _startState, RULE_unionOrIntersectionOrPrimaryType);
+ setState(348);
+ if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
+ setState(349);
+ match(BitAnd);
+ setState(350);
+ unionOrIntersectionOrPrimaryType(3);
+ }
+ break;
+ }
+ }
+ }
+ setState(355);
+ _errHandler.sync(this);
+ _alt = getInterpreter().adaptivePredict(_input,9,_ctx);
+ }
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ unrollRecursionContexts(_parentctx);
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class PrimaryTypeContext extends ParserRuleContext {
+ public PrimaryTypeContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_primaryType; }
+
+ public PrimaryTypeContext() { }
+ public void copyFrom(PrimaryTypeContext ctx) {
+ super.copyFrom(ctx);
+ }
+ }
+ @SuppressWarnings("CheckReturnValue")
+ public static class RedefinitionOfTypeContext extends PrimaryTypeContext {
+ public TypeReferenceContext typeReference() {
+ return getRuleContext(TypeReferenceContext.class,0);
+ }
+ public TerminalNode Is() { return getToken(TypeScriptParser.Is, 0); }
+ public PrimaryTypeContext primaryType() {
+ return getRuleContext(PrimaryTypeContext.class,0);
+ }
+ public RedefinitionOfTypeContext(PrimaryTypeContext ctx) { copyFrom(ctx); }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterRedefinitionOfType(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitRedefinitionOfType(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitRedefinitionOfType(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+ @SuppressWarnings("CheckReturnValue")
+ public static class PredefinedPrimTypeContext extends PrimaryTypeContext {
+ public PredefinedTypeContext predefinedType() {
+ return getRuleContext(PredefinedTypeContext.class,0);
+ }
+ public PredefinedPrimTypeContext(PrimaryTypeContext ctx) { copyFrom(ctx); }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterPredefinedPrimType(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitPredefinedPrimType(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitPredefinedPrimType(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+ @SuppressWarnings("CheckReturnValue")
+ public static class ArrayPrimTypeContext extends PrimaryTypeContext {
+ public PrimaryTypeContext primaryType() {
+ return getRuleContext(PrimaryTypeContext.class,0);
+ }
+ public TerminalNode OpenBracket() { return getToken(TypeScriptParser.OpenBracket, 0); }
+ public TerminalNode CloseBracket() { return getToken(TypeScriptParser.CloseBracket, 0); }
+ public ArrayPrimTypeContext(PrimaryTypeContext ctx) { copyFrom(ctx); }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterArrayPrimType(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitArrayPrimType(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitArrayPrimType(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+ @SuppressWarnings("CheckReturnValue")
+ public static class ParenthesizedPrimTypeContext extends PrimaryTypeContext {
+ public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
+ public Type_Context type_() {
+ return getRuleContext(Type_Context.class,0);
+ }
+ public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
+ public ParenthesizedPrimTypeContext(PrimaryTypeContext ctx) { copyFrom(ctx); }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterParenthesizedPrimType(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitParenthesizedPrimType(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitParenthesizedPrimType(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+ @SuppressWarnings("CheckReturnValue")
+ public static class ThisPrimTypeContext extends PrimaryTypeContext {
+ public TerminalNode This() { return getToken(TypeScriptParser.This, 0); }
+ public ThisPrimTypeContext(PrimaryTypeContext ctx) { copyFrom(ctx); }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterThisPrimType(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitThisPrimType(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitThisPrimType(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+ @SuppressWarnings("CheckReturnValue")
+ public static class TuplePrimTypeContext extends PrimaryTypeContext {
+ public TerminalNode OpenBracket() { return getToken(TypeScriptParser.OpenBracket, 0); }
+ public TupleElementTypesContext tupleElementTypes() {
+ return getRuleContext(TupleElementTypesContext.class,0);
+ }
+ public TerminalNode CloseBracket() { return getToken(TypeScriptParser.CloseBracket, 0); }
+ public TuplePrimTypeContext(PrimaryTypeContext ctx) { copyFrom(ctx); }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTuplePrimType(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTuplePrimType(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitTuplePrimType(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+ @SuppressWarnings("CheckReturnValue")
+ public static class ObjectPrimTypeContext extends PrimaryTypeContext {
+ public ObjectTypeContext objectType() {
+ return getRuleContext(ObjectTypeContext.class,0);
+ }
+ public ObjectPrimTypeContext(PrimaryTypeContext ctx) { copyFrom(ctx); }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterObjectPrimType(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitObjectPrimType(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitObjectPrimType(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+ @SuppressWarnings("CheckReturnValue")
+ public static class ReferencePrimTypeContext extends PrimaryTypeContext {
+ public TypeReferenceContext typeReference() {
+ return getRuleContext(TypeReferenceContext.class,0);
+ }
+ public ReferencePrimTypeContext(PrimaryTypeContext ctx) { copyFrom(ctx); }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterReferencePrimType(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitReferencePrimType(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitReferencePrimType(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+ @SuppressWarnings("CheckReturnValue")
+ public static class QueryPrimTypeContext extends PrimaryTypeContext {
+ public TypeQueryContext typeQuery() {
+ return getRuleContext(TypeQueryContext.class,0);
+ }
+ public QueryPrimTypeContext(PrimaryTypeContext ctx) { copyFrom(ctx); }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterQueryPrimType(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitQueryPrimType(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitQueryPrimType(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final PrimaryTypeContext primaryType() throws RecognitionException {
+ return primaryType(0);
+ }
+
+ private PrimaryTypeContext primaryType(int _p) throws RecognitionException {
+ ParserRuleContext _parentctx = _ctx;
+ int _parentState = getState();
+ PrimaryTypeContext _localctx = new PrimaryTypeContext(_ctx, _parentState);
+ PrimaryTypeContext _prevctx = _localctx;
+ int _startState = 22;
+ enterRecursionRule(_localctx, 22, RULE_primaryType, _p);
+ try {
+ int _alt;
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(374);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
+ case 1:
+ {
+ _localctx = new ParenthesizedPrimTypeContext(_localctx);
+ _ctx = _localctx;
+ _prevctx = _localctx;
+
+ setState(357);
+ match(OpenParen);
+ setState(358);
+ type_();
+ setState(359);
+ match(CloseParen);
+ }
+ break;
+ case 2:
+ {
+ _localctx = new PredefinedPrimTypeContext(_localctx);
+ _ctx = _localctx;
+ _prevctx = _localctx;
+ setState(361);
+ predefinedType();
+ }
+ break;
+ case 3:
+ {
+ _localctx = new ReferencePrimTypeContext(_localctx);
+ _ctx = _localctx;
+ _prevctx = _localctx;
+ setState(362);
+ typeReference();
+ }
+ break;
+ case 4:
+ {
+ _localctx = new ObjectPrimTypeContext(_localctx);
+ _ctx = _localctx;
+ _prevctx = _localctx;
+ setState(363);
+ objectType();
+ }
+ break;
+ case 5:
+ {
+ _localctx = new TuplePrimTypeContext(_localctx);
+ _ctx = _localctx;
+ _prevctx = _localctx;
+ setState(364);
+ match(OpenBracket);
+ setState(365);
+ tupleElementTypes();
+ setState(366);
+ match(CloseBracket);
+ }
+ break;
+ case 6:
+ {
+ _localctx = new QueryPrimTypeContext(_localctx);
+ _ctx = _localctx;
+ _prevctx = _localctx;
+ setState(368);
+ typeQuery();
+ }
+ break;
+ case 7:
+ {
+ _localctx = new ThisPrimTypeContext(_localctx);
+ _ctx = _localctx;
+ _prevctx = _localctx;
+ setState(369);
+ match(This);
+ }
+ break;
+ case 8:
+ {
+ _localctx = new RedefinitionOfTypeContext(_localctx);
+ _ctx = _localctx;
+ _prevctx = _localctx;
+ setState(370);
+ typeReference();
+ setState(371);
+ match(Is);
+ setState(372);
+ primaryType(1);
+ }
+ break;
+ }
+ _ctx.stop = _input.LT(-1);
+ setState(382);
+ _errHandler.sync(this);
+ _alt = getInterpreter().adaptivePredict(_input,11,_ctx);
+ while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+ if ( _alt==1 ) {
+ if ( _parseListeners!=null ) triggerExitRuleEvent();
+ _prevctx = _localctx;
+ {
+ {
+ _localctx = new ArrayPrimTypeContext(new PrimaryTypeContext(_parentctx, _parentState));
+ pushNewRecursionContext(_localctx, _startState, RULE_primaryType);
+ setState(376);
+ if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)");
+ setState(377);
+ if (!(notLineTerminator())) throw new FailedPredicateException(this, "notLineTerminator()");
+ setState(378);
+ match(OpenBracket);
+ setState(379);
+ match(CloseBracket);
+ }
+ }
+ }
+ setState(384);
+ _errHandler.sync(this);
+ _alt = getInterpreter().adaptivePredict(_input,11,_ctx);
+ }
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ unrollRecursionContexts(_parentctx);
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class PredefinedTypeContext extends ParserRuleContext {
+ public TerminalNode Any() { return getToken(TypeScriptParser.Any, 0); }
+ public TerminalNode Number() { return getToken(TypeScriptParser.Number, 0); }
+ public TerminalNode Boolean() { return getToken(TypeScriptParser.Boolean, 0); }
+ public TerminalNode String() { return getToken(TypeScriptParser.String, 0); }
+ public TerminalNode Symbol() { return getToken(TypeScriptParser.Symbol, 0); }
+ public TerminalNode Void() { return getToken(TypeScriptParser.Void, 0); }
+ public PredefinedTypeContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_predefinedType; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterPredefinedType(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitPredefinedType(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitPredefinedType(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final PredefinedTypeContext predefinedType() throws RecognitionException {
+ PredefinedTypeContext _localctx = new PredefinedTypeContext(_ctx, getState());
+ enterRule(_localctx, 24, RULE_predefinedType);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(385);
+ _la = _input.LA(1);
+ if ( !(((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & 1065151889409L) != 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;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class TypeReferenceContext extends ParserRuleContext {
+ public TypeNameContext typeName() {
+ return getRuleContext(TypeNameContext.class,0);
+ }
+ public NestedTypeGenericContext nestedTypeGeneric() {
+ return getRuleContext(NestedTypeGenericContext.class,0);
+ }
+ public TypeReferenceContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_typeReference; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeReference(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeReference(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitTypeReference(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final TypeReferenceContext typeReference() throws RecognitionException {
+ TypeReferenceContext _localctx = new TypeReferenceContext(_ctx, getState());
+ enterRule(_localctx, 26, RULE_typeReference);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(387);
+ typeName();
+ setState(389);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
+ case 1:
+ {
+ setState(388);
+ nestedTypeGeneric();
+ }
+ break;
+ }
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class NestedTypeGenericContext extends ParserRuleContext {
+ public TypeIncludeGenericContext typeIncludeGeneric() {
+ return getRuleContext(TypeIncludeGenericContext.class,0);
+ }
+ public TypeGenericContext typeGeneric() {
+ return getRuleContext(TypeGenericContext.class,0);
+ }
+ public NestedTypeGenericContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_nestedTypeGeneric; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterNestedTypeGeneric(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitNestedTypeGeneric(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitNestedTypeGeneric(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final NestedTypeGenericContext nestedTypeGeneric() throws RecognitionException {
+ NestedTypeGenericContext _localctx = new NestedTypeGenericContext(_ctx, getState());
+ enterRule(_localctx, 28, RULE_nestedTypeGeneric);
+ try {
+ setState(393);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) {
+ case 1:
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(391);
+ typeIncludeGeneric();
+ }
+ break;
+ case 2:
+ enterOuterAlt(_localctx, 2);
+ {
+ setState(392);
+ typeGeneric();
+ }
+ break;
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class TypeGenericContext extends ParserRuleContext {
+ public TerminalNode LessThan() { return getToken(TypeScriptParser.LessThan, 0); }
+ public TypeArgumentListContext typeArgumentList() {
+ return getRuleContext(TypeArgumentListContext.class,0);
+ }
+ public TerminalNode MoreThan() { return getToken(TypeScriptParser.MoreThan, 0); }
+ public TypeGenericContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_typeGeneric; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeGeneric(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeGeneric(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitTypeGeneric(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final TypeGenericContext typeGeneric() throws RecognitionException {
+ TypeGenericContext _localctx = new TypeGenericContext(_ctx, getState());
+ enterRule(_localctx, 30, RULE_typeGeneric);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(395);
+ match(LessThan);
+ setState(396);
+ typeArgumentList();
+ setState(397);
+ match(MoreThan);
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class TypeIncludeGenericContext extends ParserRuleContext {
+ public List LessThan() { return getTokens(TypeScriptParser.LessThan); }
+ public TerminalNode LessThan(int i) {
+ return getToken(TypeScriptParser.LessThan, i);
+ }
+ public List typeArgumentList() {
+ return getRuleContexts(TypeArgumentListContext.class);
+ }
+ public TypeArgumentListContext typeArgumentList(int i) {
+ return getRuleContext(TypeArgumentListContext.class,i);
+ }
+ public List MoreThan() { return getTokens(TypeScriptParser.MoreThan); }
+ public TerminalNode MoreThan(int i) {
+ return getToken(TypeScriptParser.MoreThan, i);
+ }
+ public BindingPatternContext bindingPattern() {
+ return getRuleContext(BindingPatternContext.class,0);
+ }
+ public TerminalNode RightShiftArithmetic() { return getToken(TypeScriptParser.RightShiftArithmetic, 0); }
+ public TypeIncludeGenericContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_typeIncludeGeneric; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeIncludeGeneric(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeIncludeGeneric(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitTypeIncludeGeneric(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final TypeIncludeGenericContext typeIncludeGeneric() throws RecognitionException {
+ TypeIncludeGenericContext _localctx = new TypeIncludeGenericContext(_ctx, getState());
+ enterRule(_localctx, 32, RULE_typeIncludeGeneric);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(399);
+ match(LessThan);
+ setState(400);
+ typeArgumentList();
+ setState(401);
+ match(LessThan);
+ setState(402);
+ typeArgumentList();
+ setState(408);
+ _errHandler.sync(this);
+ switch (_input.LA(1)) {
+ case MoreThan:
+ {
+ setState(403);
+ match(MoreThan);
+ setState(404);
+ bindingPattern();
+ setState(405);
+ match(MoreThan);
+ }
+ break;
+ case RightShiftArithmetic:
+ {
+ setState(407);
+ match(RightShiftArithmetic);
+ }
+ break;
+ default:
+ throw new NoViableAltException(this);
+ }
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class TypeNameContext extends ParserRuleContext {
+ public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
+ public NamespaceNameContext namespaceName() {
+ return getRuleContext(NamespaceNameContext.class,0);
+ }
+ public TypeNameContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_typeName; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeName(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeName(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitTypeName(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final TypeNameContext typeName() throws RecognitionException {
+ TypeNameContext _localctx = new TypeNameContext(_ctx, getState());
+ enterRule(_localctx, 34, RULE_typeName);
+ try {
+ setState(412);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
+ case 1:
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(410);
+ match(Identifier);
+ }
+ break;
+ case 2:
+ enterOuterAlt(_localctx, 2);
+ {
+ setState(411);
+ namespaceName();
+ }
+ break;
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class ObjectTypeContext extends ParserRuleContext {
+ public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); }
+ public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); }
+ public TypeBodyContext typeBody() {
+ return getRuleContext(TypeBodyContext.class,0);
+ }
+ public ObjectTypeContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_objectType; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterObjectType(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitObjectType(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitObjectType(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final ObjectTypeContext objectType() throws RecognitionException {
+ ObjectTypeContext _localctx = new ObjectTypeContext(_ctx, getState());
+ enterRule(_localctx, 36, RULE_objectType);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(414);
+ match(OpenBrace);
+ setState(416);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -36028795945222064L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 3517012241796825087L) != 0)) {
+ {
+ setState(415);
+ typeBody();
+ }
+ }
+
+ setState(418);
+ match(CloseBrace);
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class TypeBodyContext extends ParserRuleContext {
+ public TypeMemberListContext typeMemberList() {
+ return getRuleContext(TypeMemberListContext.class,0);
+ }
+ public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); }
+ public TerminalNode Comma() { return getToken(TypeScriptParser.Comma, 0); }
+ public TypeBodyContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_typeBody; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeBody(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeBody(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitTypeBody(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final TypeBodyContext typeBody() throws RecognitionException {
+ TypeBodyContext _localctx = new TypeBodyContext(_ctx, getState());
+ enterRule(_localctx, 38, RULE_typeBody);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(420);
+ typeMemberList();
+ setState(422);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==SemiColon || _la==Comma) {
+ {
+ setState(421);
+ _la = _input.LA(1);
+ if ( !(_la==SemiColon || _la==Comma) ) {
+ _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;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class TypeMemberListContext extends ParserRuleContext {
+ public List typeMember() {
+ return getRuleContexts(TypeMemberContext.class);
+ }
+ public TypeMemberContext typeMember(int i) {
+ return getRuleContext(TypeMemberContext.class,i);
+ }
+ public List SemiColon() { return getTokens(TypeScriptParser.SemiColon); }
+ public TerminalNode SemiColon(int i) {
+ return getToken(TypeScriptParser.SemiColon, i);
+ }
+ public List Comma() { return getTokens(TypeScriptParser.Comma); }
+ public TerminalNode Comma(int i) {
+ return getToken(TypeScriptParser.Comma, i);
+ }
+ public TypeMemberListContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_typeMemberList; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeMemberList(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeMemberList(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitTypeMemberList(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final TypeMemberListContext typeMemberList() throws RecognitionException {
+ TypeMemberListContext _localctx = new TypeMemberListContext(_ctx, getState());
+ enterRule(_localctx, 40, RULE_typeMemberList);
+ int _la;
+ try {
+ int _alt;
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(424);
+ typeMember();
+ setState(429);
+ _errHandler.sync(this);
+ _alt = getInterpreter().adaptivePredict(_input,18,_ctx);
+ while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+ if ( _alt==1 ) {
+ {
+ {
+ setState(425);
+ _la = _input.LA(1);
+ if ( !(_la==SemiColon || _la==Comma) ) {
+ _errHandler.recoverInline(this);
+ }
+ else {
+ if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
+ _errHandler.reportMatch(this);
+ consume();
+ }
+ setState(426);
+ typeMember();
+ }
+ }
+ }
+ setState(431);
+ _errHandler.sync(this);
+ _alt = getInterpreter().adaptivePredict(_input,18,_ctx);
+ }
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class TypeMemberContext extends ParserRuleContext {
+ public PropertySignaturContext propertySignatur() {
+ return getRuleContext(PropertySignaturContext.class,0);
+ }
+ public CallSignatureContext callSignature() {
+ return getRuleContext(CallSignatureContext.class,0);
+ }
+ public ConstructSignatureContext constructSignature() {
+ return getRuleContext(ConstructSignatureContext.class,0);
+ }
+ public IndexSignatureContext indexSignature() {
+ return getRuleContext(IndexSignatureContext.class,0);
+ }
+ public MethodSignatureContext methodSignature() {
+ return getRuleContext(MethodSignatureContext.class,0);
+ }
+ public TerminalNode ARROW() { return getToken(TypeScriptParser.ARROW, 0); }
+ public Type_Context type_() {
+ return getRuleContext(Type_Context.class,0);
+ }
+ public TypeMemberContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_typeMember; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeMember(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeMember(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitTypeMember(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final TypeMemberContext typeMember() throws RecognitionException {
+ TypeMemberContext _localctx = new TypeMemberContext(_ctx, getState());
+ enterRule(_localctx, 42, RULE_typeMember);
+ int _la;
+ try {
+ setState(441);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
+ case 1:
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(432);
+ propertySignatur();
+ }
+ break;
+ case 2:
+ enterOuterAlt(_localctx, 2);
+ {
+ setState(433);
+ callSignature();
+ }
+ break;
+ case 3:
+ enterOuterAlt(_localctx, 3);
+ {
+ setState(434);
+ constructSignature();
+ }
+ break;
+ case 4:
+ enterOuterAlt(_localctx, 4);
+ {
+ setState(435);
+ indexSignature();
+ }
+ break;
+ case 5:
+ enterOuterAlt(_localctx, 5);
+ {
+ setState(436);
+ methodSignature();
+ setState(439);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==ARROW) {
+ {
+ setState(437);
+ match(ARROW);
+ setState(438);
+ type_();
+ }
+ }
+
+ }
+ break;
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class ArrayTypeContext extends ParserRuleContext {
+ public PrimaryTypeContext primaryType() {
+ return getRuleContext(PrimaryTypeContext.class,0);
+ }
+ public TerminalNode OpenBracket() { return getToken(TypeScriptParser.OpenBracket, 0); }
+ public TerminalNode CloseBracket() { return getToken(TypeScriptParser.CloseBracket, 0); }
+ public ArrayTypeContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_arrayType; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterArrayType(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitArrayType(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitArrayType(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final ArrayTypeContext arrayType() throws RecognitionException {
+ ArrayTypeContext _localctx = new ArrayTypeContext(_ctx, getState());
+ enterRule(_localctx, 44, RULE_arrayType);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(443);
+ primaryType(0);
+ setState(444);
+ if (!(notLineTerminator())) throw new FailedPredicateException(this, "notLineTerminator()");
+ setState(445);
+ match(OpenBracket);
+ setState(446);
+ match(CloseBracket);
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class TupleTypeContext extends ParserRuleContext {
+ public TerminalNode OpenBracket() { return getToken(TypeScriptParser.OpenBracket, 0); }
+ public TupleElementTypesContext tupleElementTypes() {
+ return getRuleContext(TupleElementTypesContext.class,0);
+ }
+ public TerminalNode CloseBracket() { return getToken(TypeScriptParser.CloseBracket, 0); }
+ public TupleTypeContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_tupleType; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTupleType(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTupleType(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitTupleType(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final TupleTypeContext tupleType() throws RecognitionException {
+ TupleTypeContext _localctx = new TupleTypeContext(_ctx, getState());
+ enterRule(_localctx, 46, RULE_tupleType);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(448);
+ match(OpenBracket);
+ setState(449);
+ tupleElementTypes();
+ setState(450);
+ match(CloseBracket);
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class TupleElementTypesContext extends ParserRuleContext {
+ public List type_() {
+ return getRuleContexts(Type_Context.class);
+ }
+ public Type_Context type_(int i) {
+ return getRuleContext(Type_Context.class,i);
+ }
+ public List Comma() { return getTokens(TypeScriptParser.Comma); }
+ public TerminalNode Comma(int i) {
+ return getToken(TypeScriptParser.Comma, i);
+ }
+ public TupleElementTypesContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_tupleElementTypes; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTupleElementTypes(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTupleElementTypes(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitTupleElementTypes(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final TupleElementTypesContext tupleElementTypes() throws RecognitionException {
+ TupleElementTypesContext _localctx = new TupleElementTypesContext(_ctx, getState());
+ enterRule(_localctx, 48, RULE_tupleElementTypes);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(452);
+ type_();
+ setState(457);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ while (_la==Comma) {
+ {
+ {
+ setState(453);
+ match(Comma);
+ setState(454);
+ type_();
+ }
+ }
+ setState(459);
+ _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;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class FunctionTypeContext extends ParserRuleContext {
+ public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
+ public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
+ public TerminalNode ARROW() { return getToken(TypeScriptParser.ARROW, 0); }
+ public Type_Context type_() {
+ return getRuleContext(Type_Context.class,0);
+ }
+ public TypeParametersContext typeParameters() {
+ return getRuleContext(TypeParametersContext.class,0);
+ }
+ public ParameterListContext parameterList() {
+ return getRuleContext(ParameterListContext.class,0);
+ }
+ public FunctionTypeContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_functionType; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterFunctionType(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitFunctionType(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitFunctionType(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final FunctionTypeContext functionType() throws RecognitionException {
+ FunctionTypeContext _localctx = new FunctionTypeContext(_ctx, getState());
+ enterRule(_localctx, 50, RULE_functionType);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(461);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==LessThan) {
+ {
+ setState(460);
+ typeParameters();
+ }
+ }
+
+ setState(463);
+ match(OpenParen);
+ setState(465);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -4503599627370430192L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1787629984886554623L) != 0)) {
+ {
+ setState(464);
+ parameterList();
+ }
+ }
+
+ setState(467);
+ match(CloseParen);
+ setState(468);
+ match(ARROW);
+ setState(469);
+ type_();
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class ConstructorTypeContext extends ParserRuleContext {
+ public TerminalNode New() { return getToken(TypeScriptParser.New, 0); }
+ public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
+ public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
+ public TerminalNode ARROW() { return getToken(TypeScriptParser.ARROW, 0); }
+ public Type_Context type_() {
+ return getRuleContext(Type_Context.class,0);
+ }
+ public TypeParametersContext typeParameters() {
+ return getRuleContext(TypeParametersContext.class,0);
+ }
+ public ParameterListContext parameterList() {
+ return getRuleContext(ParameterListContext.class,0);
+ }
+ public ConstructorTypeContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_constructorType; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterConstructorType(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitConstructorType(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitConstructorType(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final ConstructorTypeContext constructorType() throws RecognitionException {
+ ConstructorTypeContext _localctx = new ConstructorTypeContext(_ctx, getState());
+ enterRule(_localctx, 52, RULE_constructorType);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(471);
+ match(New);
+ setState(473);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==LessThan) {
+ {
+ setState(472);
+ typeParameters();
+ }
+ }
+
+ setState(475);
+ match(OpenParen);
+ setState(477);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -4503599627370430192L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1787629984886554623L) != 0)) {
+ {
+ setState(476);
+ parameterList();
+ }
+ }
+
+ setState(479);
+ match(CloseParen);
+ setState(480);
+ match(ARROW);
+ setState(481);
+ type_();
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class TypeQueryContext extends ParserRuleContext {
+ public TerminalNode Typeof() { return getToken(TypeScriptParser.Typeof, 0); }
+ public TypeQueryExpressionContext typeQueryExpression() {
+ return getRuleContext(TypeQueryExpressionContext.class,0);
+ }
+ public TypeQueryContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_typeQuery; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeQuery(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeQuery(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitTypeQuery(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final TypeQueryContext typeQuery() throws RecognitionException {
+ TypeQueryContext _localctx = new TypeQueryContext(_ctx, getState());
+ enterRule(_localctx, 54, RULE_typeQuery);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(483);
+ match(Typeof);
+ setState(484);
+ typeQueryExpression();
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class TypeQueryExpressionContext extends ParserRuleContext {
+ public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
+ public List identifierName() {
+ return getRuleContexts(IdentifierNameContext.class);
+ }
+ public IdentifierNameContext identifierName(int i) {
+ return getRuleContext(IdentifierNameContext.class,i);
+ }
+ public List Dot() { return getTokens(TypeScriptParser.Dot); }
+ public TerminalNode Dot(int i) {
+ return getToken(TypeScriptParser.Dot, i);
+ }
+ public TypeQueryExpressionContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_typeQueryExpression; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeQueryExpression(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeQueryExpression(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitTypeQueryExpression(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final TypeQueryExpressionContext typeQueryExpression() throws RecognitionException {
+ TypeQueryExpressionContext _localctx = new TypeQueryExpressionContext(_ctx, getState());
+ enterRule(_localctx, 56, RULE_typeQueryExpression);
+ try {
+ int _alt;
+ setState(496);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
+ case 1:
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(486);
+ match(Identifier);
+ }
+ break;
+ case 2:
+ enterOuterAlt(_localctx, 2);
+ {
+ setState(490);
+ _errHandler.sync(this);
+ _alt = 1;
+ do {
+ switch (_alt) {
+ case 1:
+ {
+ {
+ setState(487);
+ identifierName();
+ setState(488);
+ match(Dot);
+ }
+ }
+ break;
+ default:
+ throw new NoViableAltException(this);
+ }
+ setState(492);
+ _errHandler.sync(this);
+ _alt = getInterpreter().adaptivePredict(_input,26,_ctx);
+ } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
+ setState(494);
+ identifierName();
+ }
+ break;
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class PropertySignaturContext extends ParserRuleContext {
+ public PropertyNameContext propertyName() {
+ return getRuleContext(PropertyNameContext.class,0);
+ }
+ public TerminalNode ReadOnly() { return getToken(TypeScriptParser.ReadOnly, 0); }
+ public TerminalNode QuestionMark() { return getToken(TypeScriptParser.QuestionMark, 0); }
+ public TypeAnnotationContext typeAnnotation() {
+ return getRuleContext(TypeAnnotationContext.class,0);
+ }
+ public TerminalNode ARROW() { return getToken(TypeScriptParser.ARROW, 0); }
+ public Type_Context type_() {
+ return getRuleContext(Type_Context.class,0);
+ }
+ public PropertySignaturContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_propertySignatur; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterPropertySignatur(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitPropertySignatur(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitPropertySignatur(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final PropertySignaturContext propertySignatur() throws RecognitionException {
+ PropertySignaturContext _localctx = new PropertySignaturContext(_ctx, getState());
+ enterRule(_localctx, 58, RULE_propertySignatur);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(499);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,28,_ctx) ) {
+ case 1:
+ {
+ setState(498);
+ match(ReadOnly);
+ }
+ break;
+ }
+ setState(501);
+ propertyName();
+ setState(503);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==QuestionMark) {
+ {
+ setState(502);
+ match(QuestionMark);
+ }
+ }
+
+ setState(506);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==Colon) {
+ {
+ setState(505);
+ typeAnnotation();
+ }
+ }
+
+ setState(510);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==ARROW) {
+ {
+ setState(508);
+ match(ARROW);
+ setState(509);
+ type_();
+ }
+ }
+
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class TypeAnnotationContext extends ParserRuleContext {
+ public TerminalNode Colon() { return getToken(TypeScriptParser.Colon, 0); }
+ public Type_Context type_() {
+ return getRuleContext(Type_Context.class,0);
+ }
+ public TypeAnnotationContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_typeAnnotation; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeAnnotation(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeAnnotation(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitTypeAnnotation(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final TypeAnnotationContext typeAnnotation() throws RecognitionException {
+ TypeAnnotationContext _localctx = new TypeAnnotationContext(_ctx, getState());
+ enterRule(_localctx, 60, RULE_typeAnnotation);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(512);
+ match(Colon);
+ setState(513);
+ type_();
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class CallSignatureContext extends ParserRuleContext {
+ public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
+ public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
+ public TypeParametersContext typeParameters() {
+ return getRuleContext(TypeParametersContext.class,0);
+ }
+ public ParameterListContext parameterList() {
+ return getRuleContext(ParameterListContext.class,0);
+ }
+ public TypeAnnotationContext typeAnnotation() {
+ return getRuleContext(TypeAnnotationContext.class,0);
+ }
+ public CallSignatureContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_callSignature; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterCallSignature(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitCallSignature(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitCallSignature(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final CallSignatureContext callSignature() throws RecognitionException {
+ CallSignatureContext _localctx = new CallSignatureContext(_ctx, getState());
+ enterRule(_localctx, 62, RULE_callSignature);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(516);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==LessThan) {
+ {
+ setState(515);
+ typeParameters();
+ }
+ }
+
+ setState(518);
+ match(OpenParen);
+ setState(520);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -4503599627370430192L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1787629984886554623L) != 0)) {
+ {
+ setState(519);
+ parameterList();
+ }
+ }
+
+ setState(522);
+ match(CloseParen);
+ setState(524);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,34,_ctx) ) {
+ case 1:
+ {
+ setState(523);
+ typeAnnotation();
+ }
+ break;
+ }
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class ParameterListContext extends ParserRuleContext {
+ public RestParameterContext restParameter() {
+ return getRuleContext(RestParameterContext.class,0);
+ }
+ public List parameter() {
+ return getRuleContexts(ParameterContext.class);
+ }
+ public ParameterContext parameter(int i) {
+ return getRuleContext(ParameterContext.class,i);
+ }
+ public List Comma() { return getTokens(TypeScriptParser.Comma); }
+ public TerminalNode Comma(int i) {
+ return getToken(TypeScriptParser.Comma, i);
+ }
+ public ParameterListContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_parameterList; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterParameterList(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitParameterList(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitParameterList(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final ParameterListContext parameterList() throws RecognitionException {
+ ParameterListContext _localctx = new ParameterListContext(_ctx, getState());
+ enterRule(_localctx, 64, RULE_parameterList);
+ int _la;
+ try {
+ int _alt;
+ setState(539);
+ _errHandler.sync(this);
+ switch (_input.LA(1)) {
+ case Ellipsis:
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(526);
+ restParameter();
+ }
+ break;
+ case OpenBracket:
+ case OpenBrace:
+ case NullLiteral:
+ case BooleanLiteral:
+ case Break:
+ case Do:
+ case Instanceof:
+ case Typeof:
+ case Case:
+ case Else:
+ case New:
+ case Var:
+ case Catch:
+ case Finally:
+ case Return:
+ case Void:
+ case Continue:
+ case For:
+ case Switch:
+ case While:
+ case Debugger:
+ case Function_:
+ case This:
+ case With:
+ case Default:
+ case If:
+ case Throw:
+ case Delete:
+ case In:
+ case Try:
+ case From:
+ case ReadOnly:
+ case Async:
+ case Class:
+ case Enum:
+ case Extends:
+ case Super:
+ case Const:
+ case Export:
+ case Import:
+ case Implements:
+ case Let:
+ case Private:
+ case Public:
+ case Interface:
+ case Package:
+ case Protected:
+ case Static:
+ case Yield:
+ case Number:
+ case Boolean:
+ case String:
+ case TypeAlias:
+ case Get:
+ case Set:
+ case Require:
+ case Module:
+ case At:
+ case Identifier:
+ enterOuterAlt(_localctx, 2);
+ {
+ setState(527);
+ parameter();
+ setState(532);
+ _errHandler.sync(this);
+ _alt = getInterpreter().adaptivePredict(_input,35,_ctx);
+ while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+ if ( _alt==1 ) {
+ {
+ {
+ setState(528);
+ match(Comma);
+ setState(529);
+ parameter();
+ }
+ }
+ }
+ setState(534);
+ _errHandler.sync(this);
+ _alt = getInterpreter().adaptivePredict(_input,35,_ctx);
+ }
+ setState(537);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==Comma) {
+ {
+ setState(535);
+ match(Comma);
+ setState(536);
+ restParameter();
+ }
+ }
+
+ }
+ break;
+ default:
+ throw new NoViableAltException(this);
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class RequiredParameterListContext extends ParserRuleContext {
+ public List requiredParameter() {
+ return getRuleContexts(RequiredParameterContext.class);
+ }
+ public RequiredParameterContext requiredParameter(int i) {
+ return getRuleContext(RequiredParameterContext.class,i);
+ }
+ public List Comma() { return getTokens(TypeScriptParser.Comma); }
+ public TerminalNode Comma(int i) {
+ return getToken(TypeScriptParser.Comma, i);
+ }
+ public RequiredParameterListContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_requiredParameterList; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterRequiredParameterList(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitRequiredParameterList(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitRequiredParameterList(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final RequiredParameterListContext requiredParameterList() throws RecognitionException {
+ RequiredParameterListContext _localctx = new RequiredParameterListContext(_ctx, getState());
+ enterRule(_localctx, 66, RULE_requiredParameterList);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(541);
+ requiredParameter();
+ setState(546);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ while (_la==Comma) {
+ {
+ {
+ setState(542);
+ match(Comma);
+ setState(543);
+ requiredParameter();
+ }
+ }
+ setState(548);
+ _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;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class ParameterContext extends ParserRuleContext {
+ public RequiredParameterContext requiredParameter() {
+ return getRuleContext(RequiredParameterContext.class,0);
+ }
+ public OptionalParameterContext optionalParameter() {
+ return getRuleContext(OptionalParameterContext.class,0);
+ }
+ public ParameterContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_parameter; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterParameter(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitParameter(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitParameter(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final ParameterContext parameter() throws RecognitionException {
+ ParameterContext _localctx = new ParameterContext(_ctx, getState());
+ enterRule(_localctx, 68, RULE_parameter);
+ try {
+ setState(551);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,39,_ctx) ) {
+ case 1:
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(549);
+ requiredParameter();
+ }
+ break;
+ case 2:
+ enterOuterAlt(_localctx, 2);
+ {
+ setState(550);
+ optionalParameter();
+ }
+ break;
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class OptionalParameterContext extends ParserRuleContext {
+ public IdentifierOrPatternContext identifierOrPattern() {
+ return getRuleContext(IdentifierOrPatternContext.class,0);
+ }
+ public DecoratorListContext decoratorList() {
+ return getRuleContext(DecoratorListContext.class,0);
+ }
+ public TerminalNode QuestionMark() { return getToken(TypeScriptParser.QuestionMark, 0); }
+ public InitializerContext initializer() {
+ return getRuleContext(InitializerContext.class,0);
+ }
+ public AccessibilityModifierContext accessibilityModifier() {
+ return getRuleContext(AccessibilityModifierContext.class,0);
+ }
+ public TypeAnnotationContext typeAnnotation() {
+ return getRuleContext(TypeAnnotationContext.class,0);
+ }
+ public OptionalParameterContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_optionalParameter; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterOptionalParameter(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitOptionalParameter(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitOptionalParameter(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final OptionalParameterContext optionalParameter() throws RecognitionException {
+ OptionalParameterContext _localctx = new OptionalParameterContext(_ctx, getState());
+ enterRule(_localctx, 70, RULE_optionalParameter);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(554);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==At) {
+ {
+ setState(553);
+ decoratorList();
+ }
+ }
+
+ {
+ setState(557);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,41,_ctx) ) {
+ case 1:
+ {
+ setState(556);
+ accessibilityModifier();
+ }
+ break;
+ }
+ setState(559);
+ identifierOrPattern();
+ setState(568);
+ _errHandler.sync(this);
+ switch (_input.LA(1)) {
+ case QuestionMark:
+ {
+ setState(560);
+ match(QuestionMark);
+ setState(562);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==Colon) {
+ {
+ setState(561);
+ typeAnnotation();
+ }
+ }
+
+ }
+ break;
+ case Assign:
+ case Colon:
+ {
+ setState(565);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==Colon) {
+ {
+ setState(564);
+ typeAnnotation();
+ }
+ }
+
+ setState(567);
+ initializer();
+ }
+ break;
+ default:
+ throw new NoViableAltException(this);
+ }
+ }
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class RestParameterContext extends ParserRuleContext {
+ public TerminalNode Ellipsis() { return getToken(TypeScriptParser.Ellipsis, 0); }
+ public SingleExpressionContext singleExpression() {
+ return getRuleContext(SingleExpressionContext.class,0);
+ }
+ public TypeAnnotationContext typeAnnotation() {
+ return getRuleContext(TypeAnnotationContext.class,0);
+ }
+ public RestParameterContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_restParameter; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterRestParameter(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitRestParameter(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitRestParameter(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final RestParameterContext restParameter() throws RecognitionException {
+ RestParameterContext _localctx = new RestParameterContext(_ctx, getState());
+ enterRule(_localctx, 72, RULE_restParameter);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(570);
+ match(Ellipsis);
+ setState(571);
+ singleExpression(0);
+ setState(573);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==Colon) {
+ {
+ setState(572);
+ typeAnnotation();
+ }
+ }
+
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class RequiredParameterContext extends ParserRuleContext {
+ public IdentifierOrPatternContext identifierOrPattern() {
+ return getRuleContext(IdentifierOrPatternContext.class,0);
+ }
+ public DecoratorListContext decoratorList() {
+ return getRuleContext(DecoratorListContext.class,0);
+ }
+ public AccessibilityModifierContext accessibilityModifier() {
+ return getRuleContext(AccessibilityModifierContext.class,0);
+ }
+ public TypeAnnotationContext typeAnnotation() {
+ return getRuleContext(TypeAnnotationContext.class,0);
+ }
+ public RequiredParameterContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_requiredParameter; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterRequiredParameter(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitRequiredParameter(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitRequiredParameter(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final RequiredParameterContext requiredParameter() throws RecognitionException {
+ RequiredParameterContext _localctx = new RequiredParameterContext(_ctx, getState());
+ enterRule(_localctx, 74, RULE_requiredParameter);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(576);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==At) {
+ {
+ setState(575);
+ decoratorList();
+ }
+ }
+
+ setState(579);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,47,_ctx) ) {
+ case 1:
+ {
+ setState(578);
+ accessibilityModifier();
+ }
+ break;
+ }
+ setState(581);
+ identifierOrPattern();
+ setState(583);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==Colon) {
+ {
+ setState(582);
+ typeAnnotation();
+ }
+ }
+
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class AccessibilityModifierContext extends ParserRuleContext {
+ public TerminalNode Public() { return getToken(TypeScriptParser.Public, 0); }
+ public TerminalNode Private() { return getToken(TypeScriptParser.Private, 0); }
+ public TerminalNode Protected() { return getToken(TypeScriptParser.Protected, 0); }
+ public AccessibilityModifierContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_accessibilityModifier; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterAccessibilityModifier(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitAccessibilityModifier(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitAccessibilityModifier(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final AccessibilityModifierContext accessibilityModifier() throws RecognitionException {
+ AccessibilityModifierContext _localctx = new AccessibilityModifierContext(_ctx, getState());
+ enterRule(_localctx, 76, RULE_accessibilityModifier);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(585);
+ _la = _input.LA(1);
+ if ( !(((((_la - 101)) & ~0x3f) == 0 && ((1L << (_la - 101)) & 19L) != 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;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class IdentifierOrPatternContext extends ParserRuleContext {
+ public IdentifierNameContext identifierName() {
+ return getRuleContext(IdentifierNameContext.class,0);
+ }
+ public BindingPatternContext bindingPattern() {
+ return getRuleContext(BindingPatternContext.class,0);
+ }
+ public IdentifierOrPatternContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_identifierOrPattern; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterIdentifierOrPattern(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitIdentifierOrPattern(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitIdentifierOrPattern(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final IdentifierOrPatternContext identifierOrPattern() throws RecognitionException {
+ IdentifierOrPatternContext _localctx = new IdentifierOrPatternContext(_ctx, getState());
+ enterRule(_localctx, 78, RULE_identifierOrPattern);
+ try {
+ setState(589);
+ _errHandler.sync(this);
+ switch (_input.LA(1)) {
+ case NullLiteral:
+ case BooleanLiteral:
+ case Break:
+ case Do:
+ case Instanceof:
+ case Typeof:
+ case Case:
+ case Else:
+ case New:
+ case Var:
+ case Catch:
+ case Finally:
+ case Return:
+ case Void:
+ case Continue:
+ case For:
+ case Switch:
+ case While:
+ case Debugger:
+ case Function_:
+ case This:
+ case With:
+ case Default:
+ case If:
+ case Throw:
+ case Delete:
+ case In:
+ case Try:
+ case From:
+ case ReadOnly:
+ case Async:
+ case Class:
+ case Enum:
+ case Extends:
+ case Super:
+ case Const:
+ case Export:
+ case Import:
+ case Implements:
+ case Let:
+ case Private:
+ case Public:
+ case Interface:
+ case Package:
+ case Protected:
+ case Static:
+ case Yield:
+ case Number:
+ case Boolean:
+ case String:
+ case TypeAlias:
+ case Get:
+ case Set:
+ case Require:
+ case Module:
+ case Identifier:
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(587);
+ identifierName();
+ }
+ break;
+ case OpenBracket:
+ case OpenBrace:
+ enterOuterAlt(_localctx, 2);
+ {
+ setState(588);
+ bindingPattern();
+ }
+ break;
+ default:
+ throw new NoViableAltException(this);
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class ConstructSignatureContext extends ParserRuleContext {
+ public TerminalNode New() { return getToken(TypeScriptParser.New, 0); }
+ public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
+ public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
+ public TypeParametersContext typeParameters() {
+ return getRuleContext(TypeParametersContext.class,0);
+ }
+ public ParameterListContext parameterList() {
+ return getRuleContext(ParameterListContext.class,0);
+ }
+ public TypeAnnotationContext typeAnnotation() {
+ return getRuleContext(TypeAnnotationContext.class,0);
+ }
+ public ConstructSignatureContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_constructSignature; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterConstructSignature(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitConstructSignature(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitConstructSignature(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final ConstructSignatureContext constructSignature() throws RecognitionException {
+ ConstructSignatureContext _localctx = new ConstructSignatureContext(_ctx, getState());
+ enterRule(_localctx, 80, RULE_constructSignature);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(591);
+ match(New);
+ setState(593);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==LessThan) {
+ {
+ setState(592);
+ typeParameters();
+ }
+ }
+
+ setState(595);
+ match(OpenParen);
+ setState(597);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -4503599627370430192L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1787629984886554623L) != 0)) {
+ {
+ setState(596);
+ parameterList();
+ }
+ }
+
+ setState(599);
+ match(CloseParen);
+ setState(601);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==Colon) {
+ {
+ setState(600);
+ typeAnnotation();
+ }
+ }
+
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class IndexSignatureContext extends ParserRuleContext {
+ public TerminalNode OpenBracket() { return getToken(TypeScriptParser.OpenBracket, 0); }
+ public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
+ public TerminalNode Colon() { return getToken(TypeScriptParser.Colon, 0); }
+ public TerminalNode CloseBracket() { return getToken(TypeScriptParser.CloseBracket, 0); }
+ public TypeAnnotationContext typeAnnotation() {
+ return getRuleContext(TypeAnnotationContext.class,0);
+ }
+ public TerminalNode Number() { return getToken(TypeScriptParser.Number, 0); }
+ public TerminalNode String() { return getToken(TypeScriptParser.String, 0); }
+ public IndexSignatureContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_indexSignature; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterIndexSignature(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitIndexSignature(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitIndexSignature(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final IndexSignatureContext indexSignature() throws RecognitionException {
+ IndexSignatureContext _localctx = new IndexSignatureContext(_ctx, getState());
+ enterRule(_localctx, 82, RULE_indexSignature);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(603);
+ match(OpenBracket);
+ setState(604);
+ match(Identifier);
+ setState(605);
+ match(Colon);
+ setState(606);
+ _la = _input.LA(1);
+ if ( !(_la==Number || _la==String) ) {
+ _errHandler.recoverInline(this);
+ }
+ else {
+ if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
+ _errHandler.reportMatch(this);
+ consume();
+ }
+ setState(607);
+ match(CloseBracket);
+ setState(608);
+ typeAnnotation();
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class MethodSignatureContext extends ParserRuleContext {
+ public PropertyNameContext propertyName() {
+ return getRuleContext(PropertyNameContext.class,0);
+ }
+ public CallSignatureContext callSignature() {
+ return getRuleContext(CallSignatureContext.class,0);
+ }
+ public TerminalNode QuestionMark() { return getToken(TypeScriptParser.QuestionMark, 0); }
+ public MethodSignatureContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_methodSignature; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterMethodSignature(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitMethodSignature(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitMethodSignature(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final MethodSignatureContext methodSignature() throws RecognitionException {
+ MethodSignatureContext _localctx = new MethodSignatureContext(_ctx, getState());
+ enterRule(_localctx, 84, RULE_methodSignature);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(610);
+ propertyName();
+ setState(612);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==QuestionMark) {
+ {
+ setState(611);
+ match(QuestionMark);
+ }
+ }
+
+ setState(614);
+ callSignature();
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class TypeAliasDeclarationContext extends ParserRuleContext {
+ public TerminalNode TypeAlias() { return getToken(TypeScriptParser.TypeAlias, 0); }
+ public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
+ public TerminalNode Assign() { return getToken(TypeScriptParser.Assign, 0); }
+ public Type_Context type_() {
+ return getRuleContext(Type_Context.class,0);
+ }
+ public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); }
+ public TypeParametersContext typeParameters() {
+ return getRuleContext(TypeParametersContext.class,0);
+ }
+ public TypeAliasDeclarationContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_typeAliasDeclaration; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTypeAliasDeclaration(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTypeAliasDeclaration(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitTypeAliasDeclaration(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final TypeAliasDeclarationContext typeAliasDeclaration() throws RecognitionException {
+ TypeAliasDeclarationContext _localctx = new TypeAliasDeclarationContext(_ctx, getState());
+ enterRule(_localctx, 86, RULE_typeAliasDeclaration);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(616);
+ match(TypeAlias);
+ setState(617);
+ match(Identifier);
+ setState(619);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==LessThan) {
+ {
+ setState(618);
+ typeParameters();
+ }
+ }
+
+ setState(621);
+ match(Assign);
+ setState(622);
+ type_();
+ setState(623);
+ match(SemiColon);
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class ConstructorDeclarationContext extends ParserRuleContext {
+ public TerminalNode Constructor() { return getToken(TypeScriptParser.Constructor, 0); }
+ public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
+ public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
+ public AccessibilityModifierContext accessibilityModifier() {
+ return getRuleContext(AccessibilityModifierContext.class,0);
+ }
+ public FormalParameterListContext formalParameterList() {
+ return getRuleContext(FormalParameterListContext.class,0);
+ }
+ public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); }
+ public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); }
+ public FunctionBodyContext functionBody() {
+ return getRuleContext(FunctionBodyContext.class,0);
+ }
+ public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); }
+ public ConstructorDeclarationContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_constructorDeclaration; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterConstructorDeclaration(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitConstructorDeclaration(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitConstructorDeclaration(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final ConstructorDeclarationContext constructorDeclaration() throws RecognitionException {
+ ConstructorDeclarationContext _localctx = new ConstructorDeclarationContext(_ctx, getState());
+ enterRule(_localctx, 88, RULE_constructorDeclaration);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(626);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (((((_la - 101)) & ~0x3f) == 0 && ((1L << (_la - 101)) & 19L) != 0)) {
+ {
+ setState(625);
+ accessibilityModifier();
+ }
+ }
+
+ setState(628);
+ match(Constructor);
+ setState(629);
+ match(OpenParen);
+ setState(631);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 65808L) != 0) || ((((_la - 101)) & ~0x3f) == 0 && ((1L << (_la - 101)) & 12718099L) != 0)) {
+ {
+ setState(630);
+ formalParameterList();
+ }
+ }
+
+ setState(633);
+ match(CloseParen);
+ setState(639);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) {
+ case 1:
+ {
+ {
+ setState(634);
+ match(OpenBrace);
+ setState(635);
+ functionBody();
+ setState(636);
+ match(CloseBrace);
+ }
+ }
+ break;
+ case 2:
+ {
+ setState(638);
+ match(SemiColon);
+ }
+ break;
+ }
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class InterfaceDeclarationContext extends ParserRuleContext {
+ public TerminalNode Interface() { return getToken(TypeScriptParser.Interface, 0); }
+ public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
+ public ObjectTypeContext objectType() {
+ return getRuleContext(ObjectTypeContext.class,0);
+ }
+ public TerminalNode Export() { return getToken(TypeScriptParser.Export, 0); }
+ public TerminalNode Declare() { return getToken(TypeScriptParser.Declare, 0); }
+ public TypeParametersContext typeParameters() {
+ return getRuleContext(TypeParametersContext.class,0);
+ }
+ public InterfaceExtendsClauseContext interfaceExtendsClause() {
+ return getRuleContext(InterfaceExtendsClauseContext.class,0);
+ }
+ public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); }
+ public InterfaceDeclarationContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_interfaceDeclaration; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterInterfaceDeclaration(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitInterfaceDeclaration(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitInterfaceDeclaration(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final InterfaceDeclarationContext interfaceDeclaration() throws RecognitionException {
+ InterfaceDeclarationContext _localctx = new InterfaceDeclarationContext(_ctx, getState());
+ enterRule(_localctx, 90, RULE_interfaceDeclaration);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(642);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==Export) {
+ {
+ setState(641);
+ match(Export);
+ }
+ }
+
+ setState(645);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==Declare) {
+ {
+ setState(644);
+ match(Declare);
+ }
+ }
+
+ setState(647);
+ match(Interface);
+ setState(648);
+ match(Identifier);
+ setState(650);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==LessThan) {
+ {
+ setState(649);
+ typeParameters();
+ }
+ }
+
+ setState(653);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==Extends) {
+ {
+ setState(652);
+ interfaceExtendsClause();
+ }
+ }
+
+ setState(655);
+ objectType();
+ setState(657);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,62,_ctx) ) {
+ case 1:
+ {
+ setState(656);
+ match(SemiColon);
+ }
+ break;
+ }
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class InterfaceExtendsClauseContext extends ParserRuleContext {
+ public TerminalNode Extends() { return getToken(TypeScriptParser.Extends, 0); }
+ public ClassOrInterfaceTypeListContext classOrInterfaceTypeList() {
+ return getRuleContext(ClassOrInterfaceTypeListContext.class,0);
+ }
+ public InterfaceExtendsClauseContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_interfaceExtendsClause; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterInterfaceExtendsClause(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitInterfaceExtendsClause(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitInterfaceExtendsClause(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final InterfaceExtendsClauseContext interfaceExtendsClause() throws RecognitionException {
+ InterfaceExtendsClauseContext _localctx = new InterfaceExtendsClauseContext(_ctx, getState());
+ enterRule(_localctx, 92, RULE_interfaceExtendsClause);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(659);
+ match(Extends);
+ setState(660);
+ classOrInterfaceTypeList();
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class ClassOrInterfaceTypeListContext extends ParserRuleContext {
+ public List typeReference() {
+ return getRuleContexts(TypeReferenceContext.class);
+ }
+ public TypeReferenceContext typeReference(int i) {
+ return getRuleContext(TypeReferenceContext.class,i);
+ }
+ public List Comma() { return getTokens(TypeScriptParser.Comma); }
+ public TerminalNode Comma(int i) {
+ return getToken(TypeScriptParser.Comma, i);
+ }
+ public ClassOrInterfaceTypeListContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_classOrInterfaceTypeList; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterClassOrInterfaceTypeList(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitClassOrInterfaceTypeList(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitClassOrInterfaceTypeList(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final ClassOrInterfaceTypeListContext classOrInterfaceTypeList() throws RecognitionException {
+ ClassOrInterfaceTypeListContext _localctx = new ClassOrInterfaceTypeListContext(_ctx, getState());
+ enterRule(_localctx, 94, RULE_classOrInterfaceTypeList);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(662);
+ typeReference();
+ setState(667);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ while (_la==Comma) {
+ {
+ {
+ setState(663);
+ match(Comma);
+ setState(664);
+ typeReference();
+ }
+ }
+ setState(669);
+ _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;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class EnumDeclarationContext extends ParserRuleContext {
+ public TerminalNode Enum() { return getToken(TypeScriptParser.Enum, 0); }
+ public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
+ public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); }
+ public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); }
+ public TerminalNode Const() { return getToken(TypeScriptParser.Const, 0); }
+ public EnumBodyContext enumBody() {
+ return getRuleContext(EnumBodyContext.class,0);
+ }
+ public EnumDeclarationContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_enumDeclaration; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterEnumDeclaration(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitEnumDeclaration(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitEnumDeclaration(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final EnumDeclarationContext enumDeclaration() throws RecognitionException {
+ EnumDeclarationContext _localctx = new EnumDeclarationContext(_ctx, getState());
+ enterRule(_localctx, 96, RULE_enumDeclaration);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(671);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==Const) {
+ {
+ setState(670);
+ match(Const);
+ }
+ }
+
+ setState(673);
+ match(Enum);
+ setState(674);
+ match(Identifier);
+ setState(675);
+ match(OpenBrace);
+ setState(677);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -36028797018963968L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 3517012241796825087L) != 0)) {
+ {
+ setState(676);
+ enumBody();
+ }
+ }
+
+ setState(679);
+ match(CloseBrace);
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class EnumBodyContext extends ParserRuleContext {
+ public EnumMemberListContext enumMemberList() {
+ return getRuleContext(EnumMemberListContext.class,0);
+ }
+ public TerminalNode Comma() { return getToken(TypeScriptParser.Comma, 0); }
+ public EnumBodyContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_enumBody; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterEnumBody(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitEnumBody(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitEnumBody(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final EnumBodyContext enumBody() throws RecognitionException {
+ EnumBodyContext _localctx = new EnumBodyContext(_ctx, getState());
+ enterRule(_localctx, 98, RULE_enumBody);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(681);
+ enumMemberList();
+ setState(683);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==Comma) {
+ {
+ setState(682);
+ match(Comma);
+ }
+ }
+
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class EnumMemberListContext extends ParserRuleContext {
+ public List enumMember() {
+ return getRuleContexts(EnumMemberContext.class);
+ }
+ public EnumMemberContext enumMember(int i) {
+ return getRuleContext(EnumMemberContext.class,i);
+ }
+ public List Comma() { return getTokens(TypeScriptParser.Comma); }
+ public TerminalNode Comma(int i) {
+ return getToken(TypeScriptParser.Comma, i);
+ }
+ public EnumMemberListContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_enumMemberList; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterEnumMemberList(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitEnumMemberList(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitEnumMemberList(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final EnumMemberListContext enumMemberList() throws RecognitionException {
+ EnumMemberListContext _localctx = new EnumMemberListContext(_ctx, getState());
+ enterRule(_localctx, 100, RULE_enumMemberList);
+ try {
+ int _alt;
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(685);
+ enumMember();
+ setState(690);
+ _errHandler.sync(this);
+ _alt = getInterpreter().adaptivePredict(_input,67,_ctx);
+ while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+ if ( _alt==1 ) {
+ {
+ {
+ setState(686);
+ match(Comma);
+ setState(687);
+ enumMember();
+ }
+ }
+ }
+ setState(692);
+ _errHandler.sync(this);
+ _alt = getInterpreter().adaptivePredict(_input,67,_ctx);
+ }
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class EnumMemberContext extends ParserRuleContext {
+ public PropertyNameContext propertyName() {
+ return getRuleContext(PropertyNameContext.class,0);
+ }
+ public TerminalNode Assign() { return getToken(TypeScriptParser.Assign, 0); }
+ public SingleExpressionContext singleExpression() {
+ return getRuleContext(SingleExpressionContext.class,0);
+ }
+ public EnumMemberContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_enumMember; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterEnumMember(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitEnumMember(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitEnumMember(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final EnumMemberContext enumMember() throws RecognitionException {
+ EnumMemberContext _localctx = new EnumMemberContext(_ctx, getState());
+ enterRule(_localctx, 102, RULE_enumMember);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(693);
+ propertyName();
+ setState(696);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==Assign) {
+ {
+ setState(694);
+ match(Assign);
+ setState(695);
+ singleExpression(0);
+ }
+ }
+
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class NamespaceDeclarationContext extends ParserRuleContext {
+ public TerminalNode Namespace() { return getToken(TypeScriptParser.Namespace, 0); }
+ public NamespaceNameContext namespaceName() {
+ return getRuleContext(NamespaceNameContext.class,0);
+ }
+ public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); }
+ public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); }
+ public StatementListContext statementList() {
+ return getRuleContext(StatementListContext.class,0);
+ }
+ public NamespaceDeclarationContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_namespaceDeclaration; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterNamespaceDeclaration(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitNamespaceDeclaration(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitNamespaceDeclaration(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final NamespaceDeclarationContext namespaceDeclaration() throws RecognitionException {
+ NamespaceDeclarationContext _localctx = new NamespaceDeclarationContext(_ctx, getState());
+ enterRule(_localctx, 104, RULE_namespaceDeclaration);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(698);
+ match(Namespace);
+ setState(699);
+ namespaceName();
+ setState(700);
+ match(OpenBrace);
+ setState(702);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,69,_ctx) ) {
+ case 1:
+ {
+ setState(701);
+ statementList();
+ }
+ break;
+ }
+ setState(704);
+ match(CloseBrace);
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class NamespaceNameContext extends ParserRuleContext {
+ public List Identifier() { return getTokens(TypeScriptParser.Identifier); }
+ public TerminalNode Identifier(int i) {
+ return getToken(TypeScriptParser.Identifier, i);
+ }
+ public List Dot() { return getTokens(TypeScriptParser.Dot); }
+ public TerminalNode Dot(int i) {
+ return getToken(TypeScriptParser.Dot, i);
+ }
+ public NamespaceNameContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_namespaceName; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterNamespaceName(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitNamespaceName(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitNamespaceName(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final NamespaceNameContext namespaceName() throws RecognitionException {
+ NamespaceNameContext _localctx = new NamespaceNameContext(_ctx, getState());
+ enterRule(_localctx, 106, RULE_namespaceName);
+ int _la;
+ try {
+ int _alt;
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(706);
+ match(Identifier);
+ setState(715);
+ _errHandler.sync(this);
+ _alt = getInterpreter().adaptivePredict(_input,71,_ctx);
+ while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+ if ( _alt==1 ) {
+ {
+ {
+ setState(708);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ do {
+ {
+ {
+ setState(707);
+ match(Dot);
+ }
+ }
+ setState(710);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ } while ( _la==Dot );
+ setState(712);
+ match(Identifier);
+ }
+ }
+ }
+ setState(717);
+ _errHandler.sync(this);
+ _alt = getInterpreter().adaptivePredict(_input,71,_ctx);
+ }
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class ImportAliasDeclarationContext extends ParserRuleContext {
+ public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
+ public TerminalNode Assign() { return getToken(TypeScriptParser.Assign, 0); }
+ public NamespaceNameContext namespaceName() {
+ return getRuleContext(NamespaceNameContext.class,0);
+ }
+ public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); }
+ public ImportAliasDeclarationContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_importAliasDeclaration; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterImportAliasDeclaration(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitImportAliasDeclaration(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitImportAliasDeclaration(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final ImportAliasDeclarationContext importAliasDeclaration() throws RecognitionException {
+ ImportAliasDeclarationContext _localctx = new ImportAliasDeclarationContext(_ctx, getState());
+ enterRule(_localctx, 108, RULE_importAliasDeclaration);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(718);
+ match(Identifier);
+ setState(719);
+ match(Assign);
+ setState(720);
+ namespaceName();
+ setState(721);
+ match(SemiColon);
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class DecoratorListContext extends ParserRuleContext {
+ public List decorator() {
+ return getRuleContexts(DecoratorContext.class);
+ }
+ public DecoratorContext decorator(int i) {
+ return getRuleContext(DecoratorContext.class,i);
+ }
+ public DecoratorListContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_decoratorList; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterDecoratorList(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitDecoratorList(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitDecoratorList(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final DecoratorListContext decoratorList() throws RecognitionException {
+ DecoratorListContext _localctx = new DecoratorListContext(_ctx, getState());
+ enterRule(_localctx, 110, RULE_decoratorList);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(724);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ do {
+ {
+ {
+ setState(723);
+ decorator();
+ }
+ }
+ setState(726);
+ _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;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class DecoratorContext extends ParserRuleContext {
+ public TerminalNode At() { return getToken(TypeScriptParser.At, 0); }
+ public DecoratorMemberExpressionContext decoratorMemberExpression() {
+ return getRuleContext(DecoratorMemberExpressionContext.class,0);
+ }
+ public DecoratorCallExpressionContext decoratorCallExpression() {
+ return getRuleContext(DecoratorCallExpressionContext.class,0);
+ }
+ public DecoratorContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_decorator; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterDecorator(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitDecorator(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitDecorator(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final DecoratorContext decorator() throws RecognitionException {
+ DecoratorContext _localctx = new DecoratorContext(_ctx, getState());
+ enterRule(_localctx, 112, RULE_decorator);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(728);
+ match(At);
+ setState(731);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,73,_ctx) ) {
+ case 1:
+ {
+ setState(729);
+ decoratorMemberExpression(0);
+ }
+ break;
+ case 2:
+ {
+ setState(730);
+ decoratorCallExpression();
+ }
+ break;
+ }
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class DecoratorMemberExpressionContext extends ParserRuleContext {
+ public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
+ public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
+ public SingleExpressionContext singleExpression() {
+ return getRuleContext(SingleExpressionContext.class,0);
+ }
+ public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
+ public DecoratorMemberExpressionContext decoratorMemberExpression() {
+ return getRuleContext(DecoratorMemberExpressionContext.class,0);
+ }
+ public TerminalNode Dot() { return getToken(TypeScriptParser.Dot, 0); }
+ public IdentifierNameContext identifierName() {
+ return getRuleContext(IdentifierNameContext.class,0);
+ }
+ public DecoratorMemberExpressionContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_decoratorMemberExpression; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterDecoratorMemberExpression(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitDecoratorMemberExpression(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitDecoratorMemberExpression(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final DecoratorMemberExpressionContext decoratorMemberExpression() throws RecognitionException {
+ return decoratorMemberExpression(0);
+ }
+
+ private DecoratorMemberExpressionContext decoratorMemberExpression(int _p) throws RecognitionException {
+ ParserRuleContext _parentctx = _ctx;
+ int _parentState = getState();
+ DecoratorMemberExpressionContext _localctx = new DecoratorMemberExpressionContext(_ctx, _parentState);
+ DecoratorMemberExpressionContext _prevctx = _localctx;
+ int _startState = 114;
+ enterRecursionRule(_localctx, 114, RULE_decoratorMemberExpression, _p);
+ try {
+ int _alt;
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(739);
+ _errHandler.sync(this);
+ switch (_input.LA(1)) {
+ case Identifier:
+ {
+ setState(734);
+ match(Identifier);
+ }
+ break;
+ case OpenParen:
+ {
+ setState(735);
+ match(OpenParen);
+ setState(736);
+ singleExpression(0);
+ setState(737);
+ match(CloseParen);
+ }
+ break;
+ default:
+ throw new NoViableAltException(this);
+ }
+ _ctx.stop = _input.LT(-1);
+ setState(746);
+ _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 ) {
+ if ( _parseListeners!=null ) triggerExitRuleEvent();
+ _prevctx = _localctx;
+ {
+ {
+ _localctx = new DecoratorMemberExpressionContext(_parentctx, _parentState);
+ pushNewRecursionContext(_localctx, _startState, RULE_decoratorMemberExpression);
+ setState(741);
+ if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)");
+ setState(742);
+ match(Dot);
+ setState(743);
+ identifierName();
+ }
+ }
+ }
+ setState(748);
+ _errHandler.sync(this);
+ _alt = getInterpreter().adaptivePredict(_input,75,_ctx);
+ }
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ unrollRecursionContexts(_parentctx);
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class DecoratorCallExpressionContext extends ParserRuleContext {
+ public DecoratorMemberExpressionContext decoratorMemberExpression() {
+ return getRuleContext(DecoratorMemberExpressionContext.class,0);
+ }
+ public ArgumentsContext arguments() {
+ return getRuleContext(ArgumentsContext.class,0);
+ }
+ public DecoratorCallExpressionContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_decoratorCallExpression; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterDecoratorCallExpression(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitDecoratorCallExpression(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitDecoratorCallExpression(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final DecoratorCallExpressionContext decoratorCallExpression() throws RecognitionException {
+ DecoratorCallExpressionContext _localctx = new DecoratorCallExpressionContext(_ctx, getState());
+ enterRule(_localctx, 116, RULE_decoratorCallExpression);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(749);
+ decoratorMemberExpression(0);
+ setState(750);
+ arguments();
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class ProgramContext extends ParserRuleContext {
+ public TerminalNode EOF() { return getToken(TypeScriptParser.EOF, 0); }
+ public SourceElementsContext sourceElements() {
+ return getRuleContext(SourceElementsContext.class,0);
+ }
+ public ProgramContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_program; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterProgram(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitProgram(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitProgram(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final ProgramContext program() throws RecognitionException {
+ ProgramContext _localctx = new ProgramContext(_ctx, getState());
+ enterRule(_localctx, 118, RULE_program);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(753);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,76,_ctx) ) {
+ case 1:
+ {
+ setState(752);
+ sourceElements();
+ }
+ break;
+ }
+ setState(755);
+ match(EOF);
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class SourceElementContext extends ParserRuleContext {
+ public StatementContext statement() {
+ return getRuleContext(StatementContext.class,0);
+ }
+ public TerminalNode Export() { return getToken(TypeScriptParser.Export, 0); }
+ public SourceElementContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_sourceElement; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterSourceElement(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitSourceElement(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitSourceElement(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final SourceElementContext sourceElement() throws RecognitionException {
+ SourceElementContext _localctx = new SourceElementContext(_ctx, getState());
+ enterRule(_localctx, 120, RULE_sourceElement);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(758);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) {
+ case 1:
+ {
+ setState(757);
+ match(Export);
+ }
+ break;
+ }
+ setState(760);
+ statement();
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class StatementContext extends ParserRuleContext {
+ public BlockContext block() {
+ return getRuleContext(BlockContext.class,0);
+ }
+ public ImportStatementContext importStatement() {
+ return getRuleContext(ImportStatementContext.class,0);
+ }
+ public ExportStatementContext exportStatement() {
+ return getRuleContext(ExportStatementContext.class,0);
+ }
+ public EmptyStatement_Context emptyStatement_() {
+ return getRuleContext(EmptyStatement_Context.class,0);
+ }
+ public AbstractDeclarationContext abstractDeclaration() {
+ return getRuleContext(AbstractDeclarationContext.class,0);
+ }
+ public ClassDeclarationContext classDeclaration() {
+ return getRuleContext(ClassDeclarationContext.class,0);
+ }
+ public InterfaceDeclarationContext interfaceDeclaration() {
+ return getRuleContext(InterfaceDeclarationContext.class,0);
+ }
+ public NamespaceDeclarationContext namespaceDeclaration() {
+ return getRuleContext(NamespaceDeclarationContext.class,0);
+ }
+ public IfStatementContext ifStatement() {
+ return getRuleContext(IfStatementContext.class,0);
+ }
+ public IterationStatementContext iterationStatement() {
+ return getRuleContext(IterationStatementContext.class,0);
+ }
+ public ContinueStatementContext continueStatement() {
+ return getRuleContext(ContinueStatementContext.class,0);
+ }
+ public BreakStatementContext breakStatement() {
+ return getRuleContext(BreakStatementContext.class,0);
+ }
+ public ReturnStatementContext returnStatement() {
+ return getRuleContext(ReturnStatementContext.class,0);
+ }
+ public YieldStatementContext yieldStatement() {
+ return getRuleContext(YieldStatementContext.class,0);
+ }
+ public WithStatementContext withStatement() {
+ return getRuleContext(WithStatementContext.class,0);
+ }
+ public LabelledStatementContext labelledStatement() {
+ return getRuleContext(LabelledStatementContext.class,0);
+ }
+ public SwitchStatementContext switchStatement() {
+ return getRuleContext(SwitchStatementContext.class,0);
+ }
+ public ThrowStatementContext throwStatement() {
+ return getRuleContext(ThrowStatementContext.class,0);
+ }
+ public TryStatementContext tryStatement() {
+ return getRuleContext(TryStatementContext.class,0);
+ }
+ public DebuggerStatementContext debuggerStatement() {
+ return getRuleContext(DebuggerStatementContext.class,0);
+ }
+ public FunctionDeclarationContext functionDeclaration() {
+ return getRuleContext(FunctionDeclarationContext.class,0);
+ }
+ public ArrowFunctionDeclarationContext arrowFunctionDeclaration() {
+ return getRuleContext(ArrowFunctionDeclarationContext.class,0);
+ }
+ public GeneratorFunctionDeclarationContext generatorFunctionDeclaration() {
+ return getRuleContext(GeneratorFunctionDeclarationContext.class,0);
+ }
+ public VariableStatementContext variableStatement() {
+ return getRuleContext(VariableStatementContext.class,0);
+ }
+ public TypeAliasDeclarationContext typeAliasDeclaration() {
+ return getRuleContext(TypeAliasDeclarationContext.class,0);
+ }
+ public EnumDeclarationContext enumDeclaration() {
+ return getRuleContext(EnumDeclarationContext.class,0);
+ }
+ public ExpressionStatementContext expressionStatement() {
+ return getRuleContext(ExpressionStatementContext.class,0);
+ }
+ public TerminalNode Export() { return getToken(TypeScriptParser.Export, 0); }
+ public StatementContext statement() {
+ return getRuleContext(StatementContext.class,0);
+ }
+ public StatementContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_statement; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterStatement(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitStatement(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitStatement(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final StatementContext statement() throws RecognitionException {
+ StatementContext _localctx = new StatementContext(_ctx, getState());
+ enterRule(_localctx, 122, RULE_statement);
+ try {
+ setState(791);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,78,_ctx) ) {
+ case 1:
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(762);
+ block();
+ }
+ break;
+ case 2:
+ enterOuterAlt(_localctx, 2);
+ {
+ setState(763);
+ importStatement();
+ }
+ break;
+ case 3:
+ enterOuterAlt(_localctx, 3);
+ {
+ setState(764);
+ exportStatement();
+ }
+ break;
+ case 4:
+ enterOuterAlt(_localctx, 4);
+ {
+ setState(765);
+ emptyStatement_();
+ }
+ break;
+ case 5:
+ enterOuterAlt(_localctx, 5);
+ {
+ setState(766);
+ abstractDeclaration();
+ }
+ break;
+ case 6:
+ enterOuterAlt(_localctx, 6);
+ {
+ setState(767);
+ classDeclaration();
+ }
+ break;
+ case 7:
+ enterOuterAlt(_localctx, 7);
+ {
+ setState(768);
+ interfaceDeclaration();
+ }
+ break;
+ case 8:
+ enterOuterAlt(_localctx, 8);
+ {
+ setState(769);
+ namespaceDeclaration();
+ }
+ break;
+ case 9:
+ enterOuterAlt(_localctx, 9);
+ {
+ setState(770);
+ ifStatement();
+ }
+ break;
+ case 10:
+ enterOuterAlt(_localctx, 10);
+ {
+ setState(771);
+ iterationStatement();
+ }
+ break;
+ case 11:
+ enterOuterAlt(_localctx, 11);
+ {
+ setState(772);
+ continueStatement();
+ }
+ break;
+ case 12:
+ enterOuterAlt(_localctx, 12);
+ {
+ setState(773);
+ breakStatement();
+ }
+ break;
+ case 13:
+ enterOuterAlt(_localctx, 13);
+ {
+ setState(774);
+ returnStatement();
+ }
+ break;
+ case 14:
+ enterOuterAlt(_localctx, 14);
+ {
+ setState(775);
+ yieldStatement();
+ }
+ break;
+ case 15:
+ enterOuterAlt(_localctx, 15);
+ {
+ setState(776);
+ withStatement();
+ }
+ break;
+ case 16:
+ enterOuterAlt(_localctx, 16);
+ {
+ setState(777);
+ labelledStatement();
+ }
+ break;
+ case 17:
+ enterOuterAlt(_localctx, 17);
+ {
+ setState(778);
+ switchStatement();
+ }
+ break;
+ case 18:
+ enterOuterAlt(_localctx, 18);
+ {
+ setState(779);
+ throwStatement();
+ }
+ break;
+ case 19:
+ enterOuterAlt(_localctx, 19);
+ {
+ setState(780);
+ tryStatement();
+ }
+ break;
+ case 20:
+ enterOuterAlt(_localctx, 20);
+ {
+ setState(781);
+ debuggerStatement();
+ }
+ break;
+ case 21:
+ enterOuterAlt(_localctx, 21);
+ {
+ setState(782);
+ functionDeclaration();
+ }
+ break;
+ case 22:
+ enterOuterAlt(_localctx, 22);
+ {
+ setState(783);
+ arrowFunctionDeclaration();
+ }
+ break;
+ case 23:
+ enterOuterAlt(_localctx, 23);
+ {
+ setState(784);
+ generatorFunctionDeclaration();
+ }
+ break;
+ case 24:
+ enterOuterAlt(_localctx, 24);
+ {
+ setState(785);
+ variableStatement();
+ }
+ break;
+ case 25:
+ enterOuterAlt(_localctx, 25);
+ {
+ setState(786);
+ typeAliasDeclaration();
+ }
+ break;
+ case 26:
+ enterOuterAlt(_localctx, 26);
+ {
+ setState(787);
+ enumDeclaration();
+ }
+ break;
+ case 27:
+ enterOuterAlt(_localctx, 27);
+ {
+ setState(788);
+ expressionStatement();
+ }
+ break;
+ case 28:
+ enterOuterAlt(_localctx, 28);
+ {
+ setState(789);
+ match(Export);
+ setState(790);
+ statement();
+ }
+ break;
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class BlockContext extends ParserRuleContext {
+ public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); }
+ public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); }
+ public StatementListContext statementList() {
+ return getRuleContext(StatementListContext.class,0);
+ }
+ public BlockContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_block; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterBlock(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitBlock(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitBlock(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final BlockContext block() throws RecognitionException {
+ BlockContext _localctx = new BlockContext(_ctx, getState());
+ enterRule(_localctx, 124, RULE_block);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(793);
+ match(OpenBrace);
+ setState(795);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,79,_ctx) ) {
+ case 1:
+ {
+ setState(794);
+ statementList();
+ }
+ break;
+ }
+ setState(797);
+ match(CloseBrace);
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class StatementListContext extends ParserRuleContext {
+ public List statement() {
+ return getRuleContexts(StatementContext.class);
+ }
+ public StatementContext statement(int i) {
+ return getRuleContext(StatementContext.class,i);
+ }
+ public StatementListContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_statementList; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterStatementList(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitStatementList(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitStatementList(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final StatementListContext statementList() throws RecognitionException {
+ StatementListContext _localctx = new StatementListContext(_ctx, getState());
+ enterRule(_localctx, 126, RULE_statementList);
+ try {
+ int _alt;
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(800);
+ _errHandler.sync(this);
+ _alt = 1;
+ do {
+ switch (_alt) {
+ case 1:
+ {
+ {
+ setState(799);
+ statement();
+ }
+ }
+ break;
+ default:
+ throw new NoViableAltException(this);
+ }
+ setState(802);
+ _errHandler.sync(this);
+ _alt = getInterpreter().adaptivePredict(_input,80,_ctx);
+ } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class AbstractDeclarationContext extends ParserRuleContext {
+ public TerminalNode Abstract() { return getToken(TypeScriptParser.Abstract, 0); }
+ public EosContext eos() {
+ return getRuleContext(EosContext.class,0);
+ }
+ public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
+ public CallSignatureContext callSignature() {
+ return getRuleContext(CallSignatureContext.class,0);
+ }
+ public VariableStatementContext variableStatement() {
+ return getRuleContext(VariableStatementContext.class,0);
+ }
+ public AbstractDeclarationContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_abstractDeclaration; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterAbstractDeclaration(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitAbstractDeclaration(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitAbstractDeclaration(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final AbstractDeclarationContext abstractDeclaration() throws RecognitionException {
+ AbstractDeclarationContext _localctx = new AbstractDeclarationContext(_ctx, getState());
+ enterRule(_localctx, 128, RULE_abstractDeclaration);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(804);
+ match(Abstract);
+ setState(808);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,81,_ctx) ) {
+ case 1:
+ {
+ setState(805);
+ match(Identifier);
+ setState(806);
+ callSignature();
+ }
+ break;
+ case 2:
+ {
+ setState(807);
+ variableStatement();
+ }
+ break;
+ }
+ setState(810);
+ eos();
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class ImportStatementContext extends ParserRuleContext {
+ public TerminalNode Import() { return getToken(TypeScriptParser.Import, 0); }
+ public FromBlockContext fromBlock() {
+ return getRuleContext(FromBlockContext.class,0);
+ }
+ public ImportAliasDeclarationContext importAliasDeclaration() {
+ return getRuleContext(ImportAliasDeclarationContext.class,0);
+ }
+ public ImportStatementContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_importStatement; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterImportStatement(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitImportStatement(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitImportStatement(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final ImportStatementContext importStatement() throws RecognitionException {
+ ImportStatementContext _localctx = new ImportStatementContext(_ctx, getState());
+ enterRule(_localctx, 130, RULE_importStatement);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(812);
+ match(Import);
+ setState(815);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,82,_ctx) ) {
+ case 1:
+ {
+ setState(813);
+ fromBlock();
+ }
+ break;
+ case 2:
+ {
+ setState(814);
+ importAliasDeclaration();
+ }
+ break;
+ }
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class FromBlockContext extends ParserRuleContext {
+ public TerminalNode From() { return getToken(TypeScriptParser.From, 0); }
+ public TerminalNode StringLiteral() { return getToken(TypeScriptParser.StringLiteral, 0); }
+ public EosContext eos() {
+ return getRuleContext(EosContext.class,0);
+ }
+ public TerminalNode Multiply() { return getToken(TypeScriptParser.Multiply, 0); }
+ public MultipleImportStatementContext multipleImportStatement() {
+ return getRuleContext(MultipleImportStatementContext.class,0);
+ }
+ public TerminalNode As() { return getToken(TypeScriptParser.As, 0); }
+ public IdentifierNameContext identifierName() {
+ return getRuleContext(IdentifierNameContext.class,0);
+ }
+ public FromBlockContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_fromBlock; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterFromBlock(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitFromBlock(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitFromBlock(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final FromBlockContext fromBlock() throws RecognitionException {
+ FromBlockContext _localctx = new FromBlockContext(_ctx, getState());
+ enterRule(_localctx, 132, RULE_fromBlock);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(819);
+ _errHandler.sync(this);
+ switch (_input.LA(1)) {
+ case Multiply:
+ {
+ setState(817);
+ match(Multiply);
+ }
+ break;
+ case OpenBrace:
+ case NullLiteral:
+ case BooleanLiteral:
+ case Break:
+ case Do:
+ case Instanceof:
+ case Typeof:
+ case Case:
+ case Else:
+ case New:
+ case Var:
+ case Catch:
+ case Finally:
+ case Return:
+ case Void:
+ case Continue:
+ case For:
+ case Switch:
+ case While:
+ case Debugger:
+ case Function_:
+ case This:
+ case With:
+ case Default:
+ case If:
+ case Throw:
+ case Delete:
+ case In:
+ case Try:
+ case From:
+ case ReadOnly:
+ case Async:
+ case Class:
+ case Enum:
+ case Extends:
+ case Super:
+ case Const:
+ case Export:
+ case Import:
+ case Implements:
+ case Let:
+ case Private:
+ case Public:
+ case Interface:
+ case Package:
+ case Protected:
+ case Static:
+ case Yield:
+ case Number:
+ case Boolean:
+ case String:
+ case TypeAlias:
+ case Get:
+ case Set:
+ case Require:
+ case Module:
+ case Identifier:
+ {
+ setState(818);
+ multipleImportStatement();
+ }
+ break;
+ default:
+ throw new NoViableAltException(this);
+ }
+ setState(823);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==As) {
+ {
+ setState(821);
+ match(As);
+ setState(822);
+ identifierName();
+ }
+ }
+
+ setState(825);
+ match(From);
+ setState(826);
+ match(StringLiteral);
+ setState(827);
+ eos();
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class MultipleImportStatementContext extends ParserRuleContext {
+ public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); }
+ public List identifierName() {
+ return getRuleContexts(IdentifierNameContext.class);
+ }
+ public IdentifierNameContext identifierName(int i) {
+ return getRuleContext(IdentifierNameContext.class,i);
+ }
+ public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); }
+ public List Comma() { return getTokens(TypeScriptParser.Comma); }
+ public TerminalNode Comma(int i) {
+ return getToken(TypeScriptParser.Comma, i);
+ }
+ public MultipleImportStatementContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_multipleImportStatement; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterMultipleImportStatement(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitMultipleImportStatement(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitMultipleImportStatement(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final MultipleImportStatementContext multipleImportStatement() throws RecognitionException {
+ MultipleImportStatementContext _localctx = new MultipleImportStatementContext(_ctx, getState());
+ enterRule(_localctx, 134, RULE_multipleImportStatement);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(832);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -4503599627370496000L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 1211169232583131135L) != 0)) {
+ {
+ setState(829);
+ identifierName();
+ setState(830);
+ match(Comma);
+ }
+ }
+
+ setState(834);
+ match(OpenBrace);
+ setState(835);
+ identifierName();
+ setState(840);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ while (_la==Comma) {
+ {
+ {
+ setState(836);
+ match(Comma);
+ setState(837);
+ identifierName();
+ }
+ }
+ setState(842);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ }
+ setState(843);
+ match(CloseBrace);
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class ExportStatementContext extends ParserRuleContext {
+ public TerminalNode Export() { return getToken(TypeScriptParser.Export, 0); }
+ public FromBlockContext fromBlock() {
+ return getRuleContext(FromBlockContext.class,0);
+ }
+ public StatementContext statement() {
+ return getRuleContext(StatementContext.class,0);
+ }
+ public TerminalNode Default() { return getToken(TypeScriptParser.Default, 0); }
+ public ExportStatementContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_exportStatement; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterExportStatement(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitExportStatement(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitExportStatement(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final ExportStatementContext exportStatement() throws RecognitionException {
+ ExportStatementContext _localctx = new ExportStatementContext(_ctx, getState());
+ enterRule(_localctx, 136, RULE_exportStatement);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(845);
+ match(Export);
+ setState(847);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,87,_ctx) ) {
+ case 1:
+ {
+ setState(846);
+ match(Default);
+ }
+ break;
+ }
+ setState(851);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,88,_ctx) ) {
+ case 1:
+ {
+ setState(849);
+ fromBlock();
+ }
+ break;
+ case 2:
+ {
+ setState(850);
+ statement();
+ }
+ break;
+ }
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class VariableStatementContext extends ParserRuleContext {
+ public BindingPatternContext bindingPattern() {
+ return getRuleContext(BindingPatternContext.class,0);
+ }
+ public InitializerContext initializer() {
+ return getRuleContext(InitializerContext.class,0);
+ }
+ public TypeAnnotationContext typeAnnotation() {
+ return getRuleContext(TypeAnnotationContext.class,0);
+ }
+ public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); }
+ public VariableDeclarationListContext variableDeclarationList() {
+ return getRuleContext(VariableDeclarationListContext.class,0);
+ }
+ public AccessibilityModifierContext accessibilityModifier() {
+ return getRuleContext(AccessibilityModifierContext.class,0);
+ }
+ public VarModifierContext varModifier() {
+ return getRuleContext(VarModifierContext.class,0);
+ }
+ public TerminalNode ReadOnly() { return getToken(TypeScriptParser.ReadOnly, 0); }
+ public TerminalNode Declare() { return getToken(TypeScriptParser.Declare, 0); }
+ public VariableStatementContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_variableStatement; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterVariableStatement(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitVariableStatement(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitVariableStatement(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final VariableStatementContext variableStatement() throws RecognitionException {
+ VariableStatementContext _localctx = new VariableStatementContext(_ctx, getState());
+ enterRule(_localctx, 138, RULE_variableStatement);
+ int _la;
+ try {
+ setState(882);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,97,_ctx) ) {
+ case 1:
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(853);
+ bindingPattern();
+ setState(855);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==Colon) {
+ {
+ setState(854);
+ typeAnnotation();
+ }
+ }
+
+ setState(857);
+ initializer();
+ setState(859);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) {
+ case 1:
+ {
+ setState(858);
+ match(SemiColon);
+ }
+ break;
+ }
+ }
+ break;
+ case 2:
+ enterOuterAlt(_localctx, 2);
+ {
+ setState(862);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (((((_la - 101)) & ~0x3f) == 0 && ((1L << (_la - 101)) & 19L) != 0)) {
+ {
+ setState(861);
+ accessibilityModifier();
+ }
+ }
+
+ setState(865);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 2281701377L) != 0)) {
+ {
+ setState(864);
+ varModifier();
+ }
+ }
+
+ setState(868);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==ReadOnly) {
+ {
+ setState(867);
+ match(ReadOnly);
+ }
+ }
+
+ setState(870);
+ variableDeclarationList();
+ setState(872);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,94,_ctx) ) {
+ case 1:
+ {
+ setState(871);
+ match(SemiColon);
+ }
+ break;
+ }
+ }
+ break;
+ case 3:
+ enterOuterAlt(_localctx, 3);
+ {
+ setState(874);
+ match(Declare);
+ setState(876);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 2281701377L) != 0)) {
+ {
+ setState(875);
+ varModifier();
+ }
+ }
+
+ setState(878);
+ variableDeclarationList();
+ setState(880);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,96,_ctx) ) {
+ case 1:
+ {
+ setState(879);
+ match(SemiColon);
+ }
+ break;
+ }
+ }
+ break;
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class VariableDeclarationListContext extends ParserRuleContext {
+ public List variableDeclaration() {
+ return getRuleContexts(VariableDeclarationContext.class);
+ }
+ public VariableDeclarationContext variableDeclaration(int i) {
+ return getRuleContext(VariableDeclarationContext.class,i);
+ }
+ public List Comma() { return getTokens(TypeScriptParser.Comma); }
+ public TerminalNode Comma(int i) {
+ return getToken(TypeScriptParser.Comma, i);
+ }
+ public VariableDeclarationListContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_variableDeclarationList; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterVariableDeclarationList(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitVariableDeclarationList(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitVariableDeclarationList(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final VariableDeclarationListContext variableDeclarationList() throws RecognitionException {
+ VariableDeclarationListContext _localctx = new VariableDeclarationListContext(_ctx, getState());
+ enterRule(_localctx, 140, RULE_variableDeclarationList);
+ try {
+ int _alt;
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(884);
+ variableDeclaration();
+ setState(889);
+ _errHandler.sync(this);
+ _alt = getInterpreter().adaptivePredict(_input,98,_ctx);
+ while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+ if ( _alt==1 ) {
+ {
+ {
+ setState(885);
+ match(Comma);
+ setState(886);
+ variableDeclaration();
+ }
+ }
+ }
+ setState(891);
+ _errHandler.sync(this);
+ _alt = getInterpreter().adaptivePredict(_input,98,_ctx);
+ }
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class VariableDeclarationContext extends ParserRuleContext {
+ public IdentifierOrKeyWordContext identifierOrKeyWord() {
+ return getRuleContext(IdentifierOrKeyWordContext.class,0);
+ }
+ public ArrayLiteralContext arrayLiteral() {
+ return getRuleContext(ArrayLiteralContext.class,0);
+ }
+ public ObjectLiteralContext objectLiteral() {
+ return getRuleContext(ObjectLiteralContext.class,0);
+ }
+ public TypeAnnotationContext typeAnnotation() {
+ return getRuleContext(TypeAnnotationContext.class,0);
+ }
+ public List singleExpression() {
+ return getRuleContexts(SingleExpressionContext.class);
+ }
+ public SingleExpressionContext singleExpression(int i) {
+ return getRuleContext(SingleExpressionContext.class,i);
+ }
+ public TerminalNode Assign() { return getToken(TypeScriptParser.Assign, 0); }
+ public TypeParametersContext typeParameters() {
+ return getRuleContext(TypeParametersContext.class,0);
+ }
+ public VariableDeclarationContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_variableDeclaration; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterVariableDeclaration(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitVariableDeclaration(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitVariableDeclaration(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final VariableDeclarationContext variableDeclaration() throws RecognitionException {
+ VariableDeclarationContext _localctx = new VariableDeclarationContext(_ctx, getState());
+ enterRule(_localctx, 142, RULE_variableDeclaration);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(895);
+ _errHandler.sync(this);
+ switch (_input.LA(1)) {
+ case TypeAlias:
+ case Require:
+ case Identifier:
+ {
+ setState(892);
+ identifierOrKeyWord();
+ }
+ break;
+ case OpenBracket:
+ {
+ setState(893);
+ arrayLiteral();
+ }
+ break;
+ case OpenBrace:
+ {
+ setState(894);
+ objectLiteral();
+ }
+ break;
+ default:
+ throw new NoViableAltException(this);
+ }
+ setState(898);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,100,_ctx) ) {
+ case 1:
+ {
+ setState(897);
+ typeAnnotation();
+ }
+ break;
+ }
+ setState(901);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,101,_ctx) ) {
+ case 1:
+ {
+ setState(900);
+ singleExpression(0);
+ }
+ break;
+ }
+ setState(908);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,103,_ctx) ) {
+ case 1:
+ {
+ setState(903);
+ match(Assign);
+ setState(905);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,102,_ctx) ) {
+ case 1:
+ {
+ setState(904);
+ typeParameters();
+ }
+ break;
+ }
+ setState(907);
+ singleExpression(0);
+ }
+ break;
+ }
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class EmptyStatement_Context extends ParserRuleContext {
+ public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); }
+ public EmptyStatement_Context(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_emptyStatement_; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterEmptyStatement_(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitEmptyStatement_(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitEmptyStatement_(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final EmptyStatement_Context emptyStatement_() throws RecognitionException {
+ EmptyStatement_Context _localctx = new EmptyStatement_Context(_ctx, getState());
+ enterRule(_localctx, 144, RULE_emptyStatement_);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(910);
+ match(SemiColon);
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class ExpressionStatementContext extends ParserRuleContext {
+ public ExpressionSequenceContext expressionSequence() {
+ return getRuleContext(ExpressionSequenceContext.class,0);
+ }
+ public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); }
+ public ExpressionStatementContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_expressionStatement; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterExpressionStatement(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitExpressionStatement(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitExpressionStatement(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final ExpressionStatementContext expressionStatement() throws RecognitionException {
+ ExpressionStatementContext _localctx = new ExpressionStatementContext(_ctx, getState());
+ enterRule(_localctx, 146, RULE_expressionStatement);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(912);
+ if (!(this.notOpenBraceAndNotFunction())) throw new FailedPredicateException(this, "this.notOpenBraceAndNotFunction()");
+ setState(913);
+ expressionSequence();
+ setState(915);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,104,_ctx) ) {
+ case 1:
+ {
+ setState(914);
+ match(SemiColon);
+ }
+ break;
+ }
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class IfStatementContext extends ParserRuleContext {
+ public TerminalNode If() { return getToken(TypeScriptParser.If, 0); }
+ public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
+ public ExpressionSequenceContext expressionSequence() {
+ return getRuleContext(ExpressionSequenceContext.class,0);
+ }
+ public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
+ public List statement() {
+ return getRuleContexts(StatementContext.class);
+ }
+ public StatementContext statement(int i) {
+ return getRuleContext(StatementContext.class,i);
+ }
+ public TerminalNode Else() { return getToken(TypeScriptParser.Else, 0); }
+ public IfStatementContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_ifStatement; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterIfStatement(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitIfStatement(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitIfStatement(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final IfStatementContext ifStatement() throws RecognitionException {
+ IfStatementContext _localctx = new IfStatementContext(_ctx, getState());
+ enterRule(_localctx, 148, RULE_ifStatement);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(917);
+ match(If);
+ setState(918);
+ match(OpenParen);
+ setState(919);
+ expressionSequence();
+ setState(920);
+ match(CloseParen);
+ setState(921);
+ statement();
+ setState(924);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,105,_ctx) ) {
+ case 1:
+ {
+ setState(922);
+ match(Else);
+ setState(923);
+ statement();
+ }
+ break;
+ }
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class IterationStatementContext extends ParserRuleContext {
+ public IterationStatementContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_iterationStatement; }
+
+ public IterationStatementContext() { }
+ public void copyFrom(IterationStatementContext ctx) {
+ super.copyFrom(ctx);
+ }
+ }
+ @SuppressWarnings("CheckReturnValue")
+ public static class DoStatementContext extends IterationStatementContext {
+ public TerminalNode Do() { return getToken(TypeScriptParser.Do, 0); }
+ public StatementContext statement() {
+ return getRuleContext(StatementContext.class,0);
+ }
+ public TerminalNode While() { return getToken(TypeScriptParser.While, 0); }
+ public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
+ public ExpressionSequenceContext expressionSequence() {
+ return getRuleContext(ExpressionSequenceContext.class,0);
+ }
+ public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
+ public EosContext eos() {
+ return getRuleContext(EosContext.class,0);
+ }
+ public DoStatementContext(IterationStatementContext ctx) { copyFrom(ctx); }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterDoStatement(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitDoStatement(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitDoStatement(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+ @SuppressWarnings("CheckReturnValue")
+ public static class ForVarStatementContext extends IterationStatementContext {
+ public TerminalNode For() { return getToken(TypeScriptParser.For, 0); }
+ public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
+ public VarModifierContext varModifier() {
+ return getRuleContext(VarModifierContext.class,0);
+ }
+ public VariableDeclarationListContext variableDeclarationList() {
+ return getRuleContext(VariableDeclarationListContext.class,0);
+ }
+ public List SemiColon() { return getTokens(TypeScriptParser.SemiColon); }
+ public TerminalNode SemiColon(int i) {
+ return getToken(TypeScriptParser.SemiColon, i);
+ }
+ public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
+ public StatementContext statement() {
+ return getRuleContext(StatementContext.class,0);
+ }
+ public List expressionSequence() {
+ return getRuleContexts(ExpressionSequenceContext.class);
+ }
+ public ExpressionSequenceContext expressionSequence(int i) {
+ return getRuleContext(ExpressionSequenceContext.class,i);
+ }
+ public ForVarStatementContext(IterationStatementContext ctx) { copyFrom(ctx); }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterForVarStatement(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitForVarStatement(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitForVarStatement(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+ @SuppressWarnings("CheckReturnValue")
+ public static class ForVarInStatementContext extends IterationStatementContext {
+ public TerminalNode For() { return getToken(TypeScriptParser.For, 0); }
+ public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
+ public VarModifierContext varModifier() {
+ return getRuleContext(VarModifierContext.class,0);
+ }
+ public VariableDeclarationContext variableDeclaration() {
+ return getRuleContext(VariableDeclarationContext.class,0);
+ }
+ public ExpressionSequenceContext expressionSequence() {
+ return getRuleContext(ExpressionSequenceContext.class,0);
+ }
+ public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
+ public StatementContext statement() {
+ return getRuleContext(StatementContext.class,0);
+ }
+ public TerminalNode In() { return getToken(TypeScriptParser.In, 0); }
+ public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
+ public ForVarInStatementContext(IterationStatementContext ctx) { copyFrom(ctx); }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterForVarInStatement(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitForVarInStatement(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitForVarInStatement(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+ @SuppressWarnings("CheckReturnValue")
+ public static class WhileStatementContext extends IterationStatementContext {
+ public TerminalNode While() { return getToken(TypeScriptParser.While, 0); }
+ public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
+ public ExpressionSequenceContext expressionSequence() {
+ return getRuleContext(ExpressionSequenceContext.class,0);
+ }
+ public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
+ public StatementContext statement() {
+ return getRuleContext(StatementContext.class,0);
+ }
+ public WhileStatementContext(IterationStatementContext ctx) { copyFrom(ctx); }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterWhileStatement(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitWhileStatement(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitWhileStatement(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+ @SuppressWarnings("CheckReturnValue")
+ public static class ForStatementContext extends IterationStatementContext {
+ public TerminalNode For() { return getToken(TypeScriptParser.For, 0); }
+ public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
+ public List SemiColon() { return getTokens(TypeScriptParser.SemiColon); }
+ public TerminalNode SemiColon(int i) {
+ return getToken(TypeScriptParser.SemiColon, i);
+ }
+ public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
+ public StatementContext statement() {
+ return getRuleContext(StatementContext.class,0);
+ }
+ public List expressionSequence() {
+ return getRuleContexts(ExpressionSequenceContext.class);
+ }
+ public ExpressionSequenceContext expressionSequence(int i) {
+ return getRuleContext(ExpressionSequenceContext.class,i);
+ }
+ public ForStatementContext(IterationStatementContext ctx) { copyFrom(ctx); }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterForStatement(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitForStatement(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitForStatement(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+ @SuppressWarnings("CheckReturnValue")
+ public static class ForInStatementContext extends IterationStatementContext {
+ public TerminalNode For() { return getToken(TypeScriptParser.For, 0); }
+ public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
+ public SingleExpressionContext singleExpression() {
+ return getRuleContext(SingleExpressionContext.class,0);
+ }
+ public ExpressionSequenceContext expressionSequence() {
+ return getRuleContext(ExpressionSequenceContext.class,0);
+ }
+ public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
+ public StatementContext statement() {
+ return getRuleContext(StatementContext.class,0);
+ }
+ public TerminalNode In() { return getToken(TypeScriptParser.In, 0); }
+ public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
+ public ForInStatementContext(IterationStatementContext ctx) { copyFrom(ctx); }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterForInStatement(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitForInStatement(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitForInStatement(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final IterationStatementContext iterationStatement() throws RecognitionException {
+ IterationStatementContext _localctx = new IterationStatementContext(_ctx, getState());
+ enterRule(_localctx, 150, RULE_iterationStatement);
+ int _la;
+ try {
+ setState(995);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,113,_ctx) ) {
+ case 1:
+ _localctx = new DoStatementContext(_localctx);
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(926);
+ match(Do);
+ setState(927);
+ statement();
+ setState(928);
+ match(While);
+ setState(929);
+ match(OpenParen);
+ setState(930);
+ expressionSequence();
+ setState(931);
+ match(CloseParen);
+ setState(932);
+ eos();
+ }
+ break;
+ case 2:
+ _localctx = new WhileStatementContext(_localctx);
+ enterOuterAlt(_localctx, 2);
+ {
+ setState(934);
+ match(While);
+ setState(935);
+ match(OpenParen);
+ setState(936);
+ expressionSequence();
+ setState(937);
+ match(CloseParen);
+ setState(938);
+ statement();
+ }
+ break;
+ case 3:
+ _localctx = new ForStatementContext(_localctx);
+ enterOuterAlt(_localctx, 3);
+ {
+ setState(940);
+ match(For);
+ setState(941);
+ match(OpenParen);
+ setState(943);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -36028795928706728L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 8128698260224212991L) != 0)) {
+ {
+ setState(942);
+ expressionSequence();
+ }
+ }
+
+ setState(945);
+ match(SemiColon);
+ setState(947);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -36028795928706728L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 8128698260224212991L) != 0)) {
+ {
+ setState(946);
+ expressionSequence();
+ }
+ }
+
+ setState(949);
+ match(SemiColon);
+ setState(951);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -36028795928706728L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 8128698260224212991L) != 0)) {
+ {
+ setState(950);
+ expressionSequence();
+ }
+ }
+
+ setState(953);
+ match(CloseParen);
+ setState(954);
+ statement();
+ }
+ break;
+ case 4:
+ _localctx = new ForVarStatementContext(_localctx);
+ enterOuterAlt(_localctx, 4);
+ {
+ setState(955);
+ match(For);
+ setState(956);
+ match(OpenParen);
+ setState(957);
+ varModifier();
+ setState(958);
+ variableDeclarationList();
+ setState(959);
+ match(SemiColon);
+ setState(961);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -36028795928706728L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 8128698260224212991L) != 0)) {
+ {
+ setState(960);
+ expressionSequence();
+ }
+ }
+
+ setState(963);
+ match(SemiColon);
+ setState(965);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if ((((_la) & ~0x3f) == 0 && ((1L << _la) & -36028795928706728L) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & 8128698260224212991L) != 0)) {
+ {
+ setState(964);
+ expressionSequence();
+ }
+ }
+
+ setState(967);
+ match(CloseParen);
+ setState(968);
+ statement();
+ }
+ break;
+ case 5:
+ _localctx = new ForInStatementContext(_localctx);
+ enterOuterAlt(_localctx, 5);
+ {
+ setState(970);
+ match(For);
+ setState(971);
+ match(OpenParen);
+ setState(972);
+ singleExpression(0);
+ setState(976);
+ _errHandler.sync(this);
+ switch (_input.LA(1)) {
+ case In:
+ {
+ setState(973);
+ match(In);
+ }
+ break;
+ case Identifier:
+ {
+ setState(974);
+ match(Identifier);
+ setState(975);
+ if (!(this.p("of"))) throw new FailedPredicateException(this, "this.p(\"of\")");
+ }
+ break;
+ default:
+ throw new NoViableAltException(this);
+ }
+ setState(978);
+ expressionSequence();
+ setState(979);
+ match(CloseParen);
+ setState(980);
+ statement();
+ }
+ break;
+ case 6:
+ _localctx = new ForVarInStatementContext(_localctx);
+ enterOuterAlt(_localctx, 6);
+ {
+ setState(982);
+ match(For);
+ setState(983);
+ match(OpenParen);
+ setState(984);
+ varModifier();
+ setState(985);
+ variableDeclaration();
+ setState(989);
+ _errHandler.sync(this);
+ switch (_input.LA(1)) {
+ case In:
+ {
+ setState(986);
+ match(In);
+ }
+ break;
+ case Identifier:
+ {
+ setState(987);
+ match(Identifier);
+ setState(988);
+ if (!(this.p("of"))) throw new FailedPredicateException(this, "this.p(\"of\")");
+ }
+ break;
+ default:
+ throw new NoViableAltException(this);
+ }
+ setState(991);
+ expressionSequence();
+ setState(992);
+ match(CloseParen);
+ setState(993);
+ statement();
+ }
+ break;
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class VarModifierContext extends ParserRuleContext {
+ public TerminalNode Var() { return getToken(TypeScriptParser.Var, 0); }
+ public TerminalNode Let() { return getToken(TypeScriptParser.Let, 0); }
+ public TerminalNode Const() { return getToken(TypeScriptParser.Const, 0); }
+ public VarModifierContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_varModifier; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterVarModifier(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitVarModifier(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitVarModifier(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final VarModifierContext varModifier() throws RecognitionException {
+ VarModifierContext _localctx = new VarModifierContext(_ctx, getState());
+ enterRule(_localctx, 152, RULE_varModifier);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(997);
+ _la = _input.LA(1);
+ if ( !(((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & 2281701377L) != 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;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class ContinueStatementContext extends ParserRuleContext {
+ public TerminalNode Continue() { return getToken(TypeScriptParser.Continue, 0); }
+ public EosContext eos() {
+ return getRuleContext(EosContext.class,0);
+ }
+ public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
+ public ContinueStatementContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_continueStatement; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterContinueStatement(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitContinueStatement(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitContinueStatement(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final ContinueStatementContext continueStatement() throws RecognitionException {
+ ContinueStatementContext _localctx = new ContinueStatementContext(_ctx, getState());
+ enterRule(_localctx, 154, RULE_continueStatement);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(999);
+ match(Continue);
+ setState(1002);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,114,_ctx) ) {
+ case 1:
+ {
+ setState(1000);
+ if (!(this.notLineTerminator())) throw new FailedPredicateException(this, "this.notLineTerminator()");
+ setState(1001);
+ match(Identifier);
+ }
+ break;
+ }
+ setState(1004);
+ eos();
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class BreakStatementContext extends ParserRuleContext {
+ public TerminalNode Break() { return getToken(TypeScriptParser.Break, 0); }
+ public EosContext eos() {
+ return getRuleContext(EosContext.class,0);
+ }
+ public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
+ public BreakStatementContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_breakStatement; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterBreakStatement(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitBreakStatement(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitBreakStatement(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final BreakStatementContext breakStatement() throws RecognitionException {
+ BreakStatementContext _localctx = new BreakStatementContext(_ctx, getState());
+ enterRule(_localctx, 156, RULE_breakStatement);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(1006);
+ match(Break);
+ setState(1009);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,115,_ctx) ) {
+ case 1:
+ {
+ setState(1007);
+ if (!(this.notLineTerminator())) throw new FailedPredicateException(this, "this.notLineTerminator()");
+ setState(1008);
+ match(Identifier);
+ }
+ break;
+ }
+ setState(1011);
+ eos();
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class ReturnStatementContext extends ParserRuleContext {
+ public TerminalNode Return() { return getToken(TypeScriptParser.Return, 0); }
+ public EosContext eos() {
+ return getRuleContext(EosContext.class,0);
+ }
+ public ExpressionSequenceContext expressionSequence() {
+ return getRuleContext(ExpressionSequenceContext.class,0);
+ }
+ public ReturnStatementContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_returnStatement; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterReturnStatement(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitReturnStatement(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitReturnStatement(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final ReturnStatementContext returnStatement() throws RecognitionException {
+ ReturnStatementContext _localctx = new ReturnStatementContext(_ctx, getState());
+ enterRule(_localctx, 158, RULE_returnStatement);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(1013);
+ match(Return);
+ setState(1016);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,116,_ctx) ) {
+ case 1:
+ {
+ setState(1014);
+ if (!(this.notLineTerminator())) throw new FailedPredicateException(this, "this.notLineTerminator()");
+ setState(1015);
+ expressionSequence();
+ }
+ break;
+ }
+ setState(1018);
+ eos();
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class YieldStatementContext extends ParserRuleContext {
+ public TerminalNode Yield() { return getToken(TypeScriptParser.Yield, 0); }
+ public EosContext eos() {
+ return getRuleContext(EosContext.class,0);
+ }
+ public ExpressionSequenceContext expressionSequence() {
+ return getRuleContext(ExpressionSequenceContext.class,0);
+ }
+ public YieldStatementContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_yieldStatement; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterYieldStatement(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitYieldStatement(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitYieldStatement(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final YieldStatementContext yieldStatement() throws RecognitionException {
+ YieldStatementContext _localctx = new YieldStatementContext(_ctx, getState());
+ enterRule(_localctx, 160, RULE_yieldStatement);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(1020);
+ match(Yield);
+ setState(1023);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,117,_ctx) ) {
+ case 1:
+ {
+ setState(1021);
+ if (!(this.notLineTerminator())) throw new FailedPredicateException(this, "this.notLineTerminator()");
+ setState(1022);
+ expressionSequence();
+ }
+ break;
+ }
+ setState(1025);
+ eos();
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class WithStatementContext extends ParserRuleContext {
+ public TerminalNode With() { return getToken(TypeScriptParser.With, 0); }
+ public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
+ public ExpressionSequenceContext expressionSequence() {
+ return getRuleContext(ExpressionSequenceContext.class,0);
+ }
+ public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
+ public StatementContext statement() {
+ return getRuleContext(StatementContext.class,0);
+ }
+ public WithStatementContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_withStatement; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterWithStatement(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitWithStatement(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitWithStatement(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final WithStatementContext withStatement() throws RecognitionException {
+ WithStatementContext _localctx = new WithStatementContext(_ctx, getState());
+ enterRule(_localctx, 162, RULE_withStatement);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(1027);
+ match(With);
+ setState(1028);
+ match(OpenParen);
+ setState(1029);
+ expressionSequence();
+ setState(1030);
+ match(CloseParen);
+ setState(1031);
+ statement();
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class SwitchStatementContext extends ParserRuleContext {
+ public TerminalNode Switch() { return getToken(TypeScriptParser.Switch, 0); }
+ public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
+ public ExpressionSequenceContext expressionSequence() {
+ return getRuleContext(ExpressionSequenceContext.class,0);
+ }
+ public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
+ public CaseBlockContext caseBlock() {
+ return getRuleContext(CaseBlockContext.class,0);
+ }
+ public SwitchStatementContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_switchStatement; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterSwitchStatement(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitSwitchStatement(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitSwitchStatement(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final SwitchStatementContext switchStatement() throws RecognitionException {
+ SwitchStatementContext _localctx = new SwitchStatementContext(_ctx, getState());
+ enterRule(_localctx, 164, RULE_switchStatement);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(1033);
+ match(Switch);
+ setState(1034);
+ match(OpenParen);
+ setState(1035);
+ expressionSequence();
+ setState(1036);
+ match(CloseParen);
+ setState(1037);
+ caseBlock();
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class CaseBlockContext extends ParserRuleContext {
+ public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); }
+ public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); }
+ public List caseClauses() {
+ return getRuleContexts(CaseClausesContext.class);
+ }
+ public CaseClausesContext caseClauses(int i) {
+ return getRuleContext(CaseClausesContext.class,i);
+ }
+ public DefaultClauseContext defaultClause() {
+ return getRuleContext(DefaultClauseContext.class,0);
+ }
+ public CaseBlockContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_caseBlock; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterCaseBlock(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitCaseBlock(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitCaseBlock(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final CaseBlockContext caseBlock() throws RecognitionException {
+ CaseBlockContext _localctx = new CaseBlockContext(_ctx, getState());
+ enterRule(_localctx, 166, RULE_caseBlock);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(1039);
+ match(OpenBrace);
+ setState(1041);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==Case) {
+ {
+ setState(1040);
+ caseClauses();
+ }
+ }
+
+ setState(1047);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==Default) {
+ {
+ setState(1043);
+ defaultClause();
+ setState(1045);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==Case) {
+ {
+ setState(1044);
+ caseClauses();
+ }
+ }
+
+ }
+ }
+
+ setState(1049);
+ match(CloseBrace);
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class CaseClausesContext extends ParserRuleContext {
+ public List caseClause() {
+ return getRuleContexts(CaseClauseContext.class);
+ }
+ public CaseClauseContext caseClause(int i) {
+ return getRuleContext(CaseClauseContext.class,i);
+ }
+ public CaseClausesContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_caseClauses; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterCaseClauses(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitCaseClauses(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitCaseClauses(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final CaseClausesContext caseClauses() throws RecognitionException {
+ CaseClausesContext _localctx = new CaseClausesContext(_ctx, getState());
+ enterRule(_localctx, 168, RULE_caseClauses);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(1052);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ do {
+ {
+ {
+ setState(1051);
+ caseClause();
+ }
+ }
+ setState(1054);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ } while ( _la==Case );
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class CaseClauseContext extends ParserRuleContext {
+ public TerminalNode Case() { return getToken(TypeScriptParser.Case, 0); }
+ public ExpressionSequenceContext expressionSequence() {
+ return getRuleContext(ExpressionSequenceContext.class,0);
+ }
+ public TerminalNode Colon() { return getToken(TypeScriptParser.Colon, 0); }
+ public StatementListContext statementList() {
+ return getRuleContext(StatementListContext.class,0);
+ }
+ public CaseClauseContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_caseClause; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterCaseClause(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitCaseClause(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitCaseClause(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final CaseClauseContext caseClause() throws RecognitionException {
+ CaseClauseContext _localctx = new CaseClauseContext(_ctx, getState());
+ enterRule(_localctx, 170, RULE_caseClause);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(1056);
+ match(Case);
+ setState(1057);
+ expressionSequence();
+ setState(1058);
+ match(Colon);
+ setState(1060);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,122,_ctx) ) {
+ case 1:
+ {
+ setState(1059);
+ statementList();
+ }
+ break;
+ }
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class DefaultClauseContext extends ParserRuleContext {
+ public TerminalNode Default() { return getToken(TypeScriptParser.Default, 0); }
+ public TerminalNode Colon() { return getToken(TypeScriptParser.Colon, 0); }
+ public StatementListContext statementList() {
+ return getRuleContext(StatementListContext.class,0);
+ }
+ public DefaultClauseContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_defaultClause; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterDefaultClause(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitDefaultClause(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitDefaultClause(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final DefaultClauseContext defaultClause() throws RecognitionException {
+ DefaultClauseContext _localctx = new DefaultClauseContext(_ctx, getState());
+ enterRule(_localctx, 172, RULE_defaultClause);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(1062);
+ match(Default);
+ setState(1063);
+ match(Colon);
+ setState(1065);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,123,_ctx) ) {
+ case 1:
+ {
+ setState(1064);
+ statementList();
+ }
+ break;
+ }
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class LabelledStatementContext extends ParserRuleContext {
+ public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
+ public TerminalNode Colon() { return getToken(TypeScriptParser.Colon, 0); }
+ public StatementContext statement() {
+ return getRuleContext(StatementContext.class,0);
+ }
+ public LabelledStatementContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_labelledStatement; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterLabelledStatement(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitLabelledStatement(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitLabelledStatement(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final LabelledStatementContext labelledStatement() throws RecognitionException {
+ LabelledStatementContext _localctx = new LabelledStatementContext(_ctx, getState());
+ enterRule(_localctx, 174, RULE_labelledStatement);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(1067);
+ match(Identifier);
+ setState(1068);
+ match(Colon);
+ setState(1069);
+ statement();
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class ThrowStatementContext extends ParserRuleContext {
+ public TerminalNode Throw() { return getToken(TypeScriptParser.Throw, 0); }
+ public ExpressionSequenceContext expressionSequence() {
+ return getRuleContext(ExpressionSequenceContext.class,0);
+ }
+ public EosContext eos() {
+ return getRuleContext(EosContext.class,0);
+ }
+ public ThrowStatementContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_throwStatement; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterThrowStatement(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitThrowStatement(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitThrowStatement(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final ThrowStatementContext throwStatement() throws RecognitionException {
+ ThrowStatementContext _localctx = new ThrowStatementContext(_ctx, getState());
+ enterRule(_localctx, 176, RULE_throwStatement);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(1071);
+ match(Throw);
+ setState(1072);
+ if (!(this.notLineTerminator())) throw new FailedPredicateException(this, "this.notLineTerminator()");
+ setState(1073);
+ expressionSequence();
+ setState(1074);
+ eos();
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class TryStatementContext extends ParserRuleContext {
+ public TerminalNode Try() { return getToken(TypeScriptParser.Try, 0); }
+ public BlockContext block() {
+ return getRuleContext(BlockContext.class,0);
+ }
+ public CatchProductionContext catchProduction() {
+ return getRuleContext(CatchProductionContext.class,0);
+ }
+ public FinallyProductionContext finallyProduction() {
+ return getRuleContext(FinallyProductionContext.class,0);
+ }
+ public TryStatementContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_tryStatement; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterTryStatement(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitTryStatement(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitTryStatement(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final TryStatementContext tryStatement() throws RecognitionException {
+ TryStatementContext _localctx = new TryStatementContext(_ctx, getState());
+ enterRule(_localctx, 178, RULE_tryStatement);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(1076);
+ match(Try);
+ setState(1077);
+ block();
+ setState(1083);
+ _errHandler.sync(this);
+ switch (_input.LA(1)) {
+ case Catch:
+ {
+ setState(1078);
+ catchProduction();
+ setState(1080);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,124,_ctx) ) {
+ case 1:
+ {
+ setState(1079);
+ finallyProduction();
+ }
+ break;
+ }
+ }
+ break;
+ case Finally:
+ {
+ setState(1082);
+ finallyProduction();
+ }
+ break;
+ default:
+ throw new NoViableAltException(this);
+ }
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class CatchProductionContext extends ParserRuleContext {
+ public TerminalNode Catch() { return getToken(TypeScriptParser.Catch, 0); }
+ public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
+ public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
+ public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
+ public BlockContext block() {
+ return getRuleContext(BlockContext.class,0);
+ }
+ public CatchProductionContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_catchProduction; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterCatchProduction(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitCatchProduction(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitCatchProduction(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final CatchProductionContext catchProduction() throws RecognitionException {
+ CatchProductionContext _localctx = new CatchProductionContext(_ctx, getState());
+ enterRule(_localctx, 180, RULE_catchProduction);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(1085);
+ match(Catch);
+ setState(1086);
+ match(OpenParen);
+ setState(1087);
+ match(Identifier);
+ setState(1088);
+ match(CloseParen);
+ setState(1089);
+ block();
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class FinallyProductionContext extends ParserRuleContext {
+ public TerminalNode Finally() { return getToken(TypeScriptParser.Finally, 0); }
+ public BlockContext block() {
+ return getRuleContext(BlockContext.class,0);
+ }
+ public FinallyProductionContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_finallyProduction; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterFinallyProduction(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitFinallyProduction(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitFinallyProduction(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final FinallyProductionContext finallyProduction() throws RecognitionException {
+ FinallyProductionContext _localctx = new FinallyProductionContext(_ctx, getState());
+ enterRule(_localctx, 182, RULE_finallyProduction);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(1091);
+ match(Finally);
+ setState(1092);
+ block();
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class DebuggerStatementContext extends ParserRuleContext {
+ public TerminalNode Debugger() { return getToken(TypeScriptParser.Debugger, 0); }
+ public EosContext eos() {
+ return getRuleContext(EosContext.class,0);
+ }
+ public DebuggerStatementContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_debuggerStatement; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterDebuggerStatement(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitDebuggerStatement(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitDebuggerStatement(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final DebuggerStatementContext debuggerStatement() throws RecognitionException {
+ DebuggerStatementContext _localctx = new DebuggerStatementContext(_ctx, getState());
+ enterRule(_localctx, 184, RULE_debuggerStatement);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(1094);
+ match(Debugger);
+ setState(1095);
+ eos();
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class FunctionDeclarationContext extends ParserRuleContext {
+ public TerminalNode Function_() { return getToken(TypeScriptParser.Function_, 0); }
+ public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
+ public CallSignatureContext callSignature() {
+ return getRuleContext(CallSignatureContext.class,0);
+ }
+ public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); }
+ public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); }
+ public FunctionBodyContext functionBody() {
+ return getRuleContext(FunctionBodyContext.class,0);
+ }
+ public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); }
+ public FunctionDeclarationContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_functionDeclaration; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterFunctionDeclaration(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitFunctionDeclaration(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitFunctionDeclaration(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final FunctionDeclarationContext functionDeclaration() throws RecognitionException {
+ FunctionDeclarationContext _localctx = new FunctionDeclarationContext(_ctx, getState());
+ enterRule(_localctx, 186, RULE_functionDeclaration);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(1097);
+ match(Function_);
+ setState(1098);
+ match(Identifier);
+ setState(1099);
+ callSignature();
+ setState(1105);
+ _errHandler.sync(this);
+ switch (_input.LA(1)) {
+ case OpenBrace:
+ {
+ {
+ setState(1100);
+ match(OpenBrace);
+ setState(1101);
+ functionBody();
+ setState(1102);
+ match(CloseBrace);
+ }
+ }
+ break;
+ case SemiColon:
+ {
+ setState(1104);
+ 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;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class ClassDeclarationContext extends ParserRuleContext {
+ public TerminalNode Class() { return getToken(TypeScriptParser.Class, 0); }
+ public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
+ public ClassHeritageContext classHeritage() {
+ return getRuleContext(ClassHeritageContext.class,0);
+ }
+ public ClassTailContext classTail() {
+ return getRuleContext(ClassTailContext.class,0);
+ }
+ public DecoratorListContext decoratorList() {
+ return getRuleContext(DecoratorListContext.class,0);
+ }
+ public TerminalNode Export() { return getToken(TypeScriptParser.Export, 0); }
+ public TerminalNode Abstract() { return getToken(TypeScriptParser.Abstract, 0); }
+ public TypeParametersContext typeParameters() {
+ return getRuleContext(TypeParametersContext.class,0);
+ }
+ public TerminalNode Default() { return getToken(TypeScriptParser.Default, 0); }
+ public ClassDeclarationContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_classDeclaration; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterClassDeclaration(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitClassDeclaration(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitClassDeclaration(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final ClassDeclarationContext classDeclaration() throws RecognitionException {
+ ClassDeclarationContext _localctx = new ClassDeclarationContext(_ctx, getState());
+ enterRule(_localctx, 188, RULE_classDeclaration);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(1108);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==At) {
+ {
+ setState(1107);
+ decoratorList();
+ }
+ }
+
+ setState(1114);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==Export) {
+ {
+ setState(1110);
+ match(Export);
+ setState(1112);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==Default) {
+ {
+ setState(1111);
+ match(Default);
+ }
+ }
+
+ }
+ }
+
+ setState(1117);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==Abstract) {
+ {
+ setState(1116);
+ match(Abstract);
+ }
+ }
+
+ setState(1119);
+ match(Class);
+ setState(1120);
+ match(Identifier);
+ setState(1122);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==LessThan) {
+ {
+ setState(1121);
+ typeParameters();
+ }
+ }
+
+ setState(1124);
+ classHeritage();
+ setState(1125);
+ classTail();
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class ClassHeritageContext extends ParserRuleContext {
+ public ClassExtendsClauseContext classExtendsClause() {
+ return getRuleContext(ClassExtendsClauseContext.class,0);
+ }
+ public ImplementsClauseContext implementsClause() {
+ return getRuleContext(ImplementsClauseContext.class,0);
+ }
+ public ClassHeritageContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_classHeritage; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterClassHeritage(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitClassHeritage(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitClassHeritage(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final ClassHeritageContext classHeritage() throws RecognitionException {
+ ClassHeritageContext _localctx = new ClassHeritageContext(_ctx, getState());
+ enterRule(_localctx, 190, RULE_classHeritage);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(1128);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==Extends) {
+ {
+ setState(1127);
+ classExtendsClause();
+ }
+ }
+
+ setState(1131);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==Implements) {
+ {
+ setState(1130);
+ implementsClause();
+ }
+ }
+
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class ClassTailContext extends ParserRuleContext {
+ public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); }
+ public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); }
+ public List classElement() {
+ return getRuleContexts(ClassElementContext.class);
+ }
+ public ClassElementContext classElement(int i) {
+ return getRuleContext(ClassElementContext.class,i);
+ }
+ public ClassTailContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_classTail; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterClassTail(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitClassTail(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitClassTail(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final ClassTailContext classTail() throws RecognitionException {
+ ClassTailContext _localctx = new ClassTailContext(_ctx, getState());
+ enterRule(_localctx, 192, RULE_classTail);
+ try {
+ int _alt;
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(1133);
+ match(OpenBrace);
+ setState(1137);
+ _errHandler.sync(this);
+ _alt = getInterpreter().adaptivePredict(_input,134,_ctx);
+ while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+ if ( _alt==1 ) {
+ {
+ {
+ setState(1134);
+ classElement();
+ }
+ }
+ }
+ setState(1139);
+ _errHandler.sync(this);
+ _alt = getInterpreter().adaptivePredict(_input,134,_ctx);
+ }
+ setState(1140);
+ match(CloseBrace);
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class ClassExtendsClauseContext extends ParserRuleContext {
+ public TerminalNode Extends() { return getToken(TypeScriptParser.Extends, 0); }
+ public TypeReferenceContext typeReference() {
+ return getRuleContext(TypeReferenceContext.class,0);
+ }
+ public ClassExtendsClauseContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_classExtendsClause; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterClassExtendsClause(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitClassExtendsClause(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitClassExtendsClause(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final ClassExtendsClauseContext classExtendsClause() throws RecognitionException {
+ ClassExtendsClauseContext _localctx = new ClassExtendsClauseContext(_ctx, getState());
+ enterRule(_localctx, 194, RULE_classExtendsClause);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(1142);
+ match(Extends);
+ setState(1143);
+ typeReference();
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class ImplementsClauseContext extends ParserRuleContext {
+ public TerminalNode Implements() { return getToken(TypeScriptParser.Implements, 0); }
+ public ClassOrInterfaceTypeListContext classOrInterfaceTypeList() {
+ return getRuleContext(ClassOrInterfaceTypeListContext.class,0);
+ }
+ public ImplementsClauseContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_implementsClause; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterImplementsClause(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitImplementsClause(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitImplementsClause(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final ImplementsClauseContext implementsClause() throws RecognitionException {
+ ImplementsClauseContext _localctx = new ImplementsClauseContext(_ctx, getState());
+ enterRule(_localctx, 196, RULE_implementsClause);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(1145);
+ match(Implements);
+ setState(1146);
+ classOrInterfaceTypeList();
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class ClassElementContext extends ParserRuleContext {
+ public ConstructorDeclarationContext constructorDeclaration() {
+ return getRuleContext(ConstructorDeclarationContext.class,0);
+ }
+ public PropertyMemberDeclarationContext propertyMemberDeclaration() {
+ return getRuleContext(PropertyMemberDeclarationContext.class,0);
+ }
+ public DecoratorListContext decoratorList() {
+ return getRuleContext(DecoratorListContext.class,0);
+ }
+ public IndexMemberDeclarationContext indexMemberDeclaration() {
+ return getRuleContext(IndexMemberDeclarationContext.class,0);
+ }
+ public StatementContext statement() {
+ return getRuleContext(StatementContext.class,0);
+ }
+ public ClassElementContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_classElement; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterClassElement(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitClassElement(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitClassElement(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final ClassElementContext classElement() throws RecognitionException {
+ ClassElementContext _localctx = new ClassElementContext(_ctx, getState());
+ enterRule(_localctx, 198, RULE_classElement);
+ int _la;
+ try {
+ setState(1155);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,136,_ctx) ) {
+ case 1:
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(1148);
+ constructorDeclaration();
+ }
+ break;
+ case 2:
+ enterOuterAlt(_localctx, 2);
+ {
+ setState(1150);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==At) {
+ {
+ setState(1149);
+ decoratorList();
+ }
+ }
+
+ setState(1152);
+ propertyMemberDeclaration();
+ }
+ break;
+ case 3:
+ enterOuterAlt(_localctx, 3);
+ {
+ setState(1153);
+ indexMemberDeclaration();
+ }
+ break;
+ case 4:
+ enterOuterAlt(_localctx, 4);
+ {
+ setState(1154);
+ statement();
+ }
+ break;
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class PropertyMemberDeclarationContext extends ParserRuleContext {
+ public PropertyMemberDeclarationContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_propertyMemberDeclaration; }
+
+ public PropertyMemberDeclarationContext() { }
+ public void copyFrom(PropertyMemberDeclarationContext ctx) {
+ super.copyFrom(ctx);
+ }
+ }
+ @SuppressWarnings("CheckReturnValue")
+ public static class PropertyDeclarationExpressionContext extends PropertyMemberDeclarationContext {
+ public PropertyMemberBaseContext propertyMemberBase() {
+ return getRuleContext(PropertyMemberBaseContext.class,0);
+ }
+ public PropertyNameContext propertyName() {
+ return getRuleContext(PropertyNameContext.class,0);
+ }
+ public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); }
+ public TerminalNode QuestionMark() { return getToken(TypeScriptParser.QuestionMark, 0); }
+ public TypeAnnotationContext typeAnnotation() {
+ return getRuleContext(TypeAnnotationContext.class,0);
+ }
+ public InitializerContext initializer() {
+ return getRuleContext(InitializerContext.class,0);
+ }
+ public PropertyDeclarationExpressionContext(PropertyMemberDeclarationContext ctx) { copyFrom(ctx); }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterPropertyDeclarationExpression(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitPropertyDeclarationExpression(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitPropertyDeclarationExpression(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+ @SuppressWarnings("CheckReturnValue")
+ public static class MethodDeclarationExpressionContext extends PropertyMemberDeclarationContext {
+ public PropertyMemberBaseContext propertyMemberBase() {
+ return getRuleContext(PropertyMemberBaseContext.class,0);
+ }
+ public PropertyNameContext propertyName() {
+ return getRuleContext(PropertyNameContext.class,0);
+ }
+ public CallSignatureContext callSignature() {
+ return getRuleContext(CallSignatureContext.class,0);
+ }
+ public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); }
+ public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); }
+ public FunctionBodyContext functionBody() {
+ return getRuleContext(FunctionBodyContext.class,0);
+ }
+ public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); }
+ public MethodDeclarationExpressionContext(PropertyMemberDeclarationContext ctx) { copyFrom(ctx); }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterMethodDeclarationExpression(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitMethodDeclarationExpression(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitMethodDeclarationExpression(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+ @SuppressWarnings("CheckReturnValue")
+ public static class GetterSetterDeclarationExpressionContext extends PropertyMemberDeclarationContext {
+ public PropertyMemberBaseContext propertyMemberBase() {
+ return getRuleContext(PropertyMemberBaseContext.class,0);
+ }
+ public GetAccessorContext getAccessor() {
+ return getRuleContext(GetAccessorContext.class,0);
+ }
+ public SetAccessorContext setAccessor() {
+ return getRuleContext(SetAccessorContext.class,0);
+ }
+ public GetterSetterDeclarationExpressionContext(PropertyMemberDeclarationContext ctx) { copyFrom(ctx); }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterGetterSetterDeclarationExpression(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitGetterSetterDeclarationExpression(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitGetterSetterDeclarationExpression(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+ @SuppressWarnings("CheckReturnValue")
+ public static class AbstractMemberDeclarationContext extends PropertyMemberDeclarationContext {
+ public AbstractDeclarationContext abstractDeclaration() {
+ return getRuleContext(AbstractDeclarationContext.class,0);
+ }
+ public AbstractMemberDeclarationContext(PropertyMemberDeclarationContext ctx) { copyFrom(ctx); }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterAbstractMemberDeclaration(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitAbstractMemberDeclaration(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitAbstractMemberDeclaration(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final PropertyMemberDeclarationContext propertyMemberDeclaration() throws RecognitionException {
+ PropertyMemberDeclarationContext _localctx = new PropertyMemberDeclarationContext(_ctx, getState());
+ enterRule(_localctx, 200, RULE_propertyMemberDeclaration);
+ int _la;
+ try {
+ setState(1186);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,142,_ctx) ) {
+ case 1:
+ _localctx = new PropertyDeclarationExpressionContext(_localctx);
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(1157);
+ propertyMemberBase();
+ setState(1158);
+ propertyName();
+ setState(1160);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==QuestionMark) {
+ {
+ setState(1159);
+ match(QuestionMark);
+ }
+ }
+
+ setState(1163);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==Colon) {
+ {
+ setState(1162);
+ typeAnnotation();
+ }
+ }
+
+ setState(1166);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==Assign) {
+ {
+ setState(1165);
+ initializer();
+ }
+ }
+
+ setState(1168);
+ match(SemiColon);
+ }
+ break;
+ case 2:
+ _localctx = new MethodDeclarationExpressionContext(_localctx);
+ enterOuterAlt(_localctx, 2);
+ {
+ setState(1170);
+ propertyMemberBase();
+ setState(1171);
+ propertyName();
+ setState(1172);
+ callSignature();
+ setState(1178);
+ _errHandler.sync(this);
+ switch (_input.LA(1)) {
+ case OpenBrace:
+ {
+ {
+ setState(1173);
+ match(OpenBrace);
+ setState(1174);
+ functionBody();
+ setState(1175);
+ match(CloseBrace);
+ }
+ }
+ break;
+ case SemiColon:
+ {
+ setState(1177);
+ match(SemiColon);
+ }
+ break;
+ default:
+ throw new NoViableAltException(this);
+ }
+ }
+ break;
+ case 3:
+ _localctx = new GetterSetterDeclarationExpressionContext(_localctx);
+ enterOuterAlt(_localctx, 3);
+ {
+ setState(1180);
+ propertyMemberBase();
+ setState(1183);
+ _errHandler.sync(this);
+ switch (_input.LA(1)) {
+ case Get:
+ {
+ setState(1181);
+ getAccessor();
+ }
+ break;
+ case Set:
+ {
+ setState(1182);
+ setAccessor();
+ }
+ break;
+ default:
+ throw new NoViableAltException(this);
+ }
+ }
+ break;
+ case 4:
+ _localctx = new AbstractMemberDeclarationContext(_localctx);
+ enterOuterAlt(_localctx, 4);
+ {
+ setState(1185);
+ abstractDeclaration();
+ }
+ break;
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class PropertyMemberBaseContext extends ParserRuleContext {
+ public AccessibilityModifierContext accessibilityModifier() {
+ return getRuleContext(AccessibilityModifierContext.class,0);
+ }
+ public TerminalNode Async() { return getToken(TypeScriptParser.Async, 0); }
+ public TerminalNode Static() { return getToken(TypeScriptParser.Static, 0); }
+ public TerminalNode ReadOnly() { return getToken(TypeScriptParser.ReadOnly, 0); }
+ public PropertyMemberBaseContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_propertyMemberBase; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterPropertyMemberBase(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitPropertyMemberBase(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitPropertyMemberBase(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final PropertyMemberBaseContext propertyMemberBase() throws RecognitionException {
+ PropertyMemberBaseContext _localctx = new PropertyMemberBaseContext(_ctx, getState());
+ enterRule(_localctx, 202, RULE_propertyMemberBase);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(1189);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,143,_ctx) ) {
+ case 1:
+ {
+ setState(1188);
+ accessibilityModifier();
+ }
+ break;
+ }
+ setState(1192);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,144,_ctx) ) {
+ case 1:
+ {
+ setState(1191);
+ match(Async);
+ }
+ break;
+ }
+ setState(1195);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,145,_ctx) ) {
+ case 1:
+ {
+ setState(1194);
+ match(Static);
+ }
+ break;
+ }
+ setState(1198);
+ _errHandler.sync(this);
+ switch ( getInterpreter().adaptivePredict(_input,146,_ctx) ) {
+ case 1:
+ {
+ setState(1197);
+ match(ReadOnly);
+ }
+ break;
+ }
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class IndexMemberDeclarationContext extends ParserRuleContext {
+ public IndexSignatureContext indexSignature() {
+ return getRuleContext(IndexSignatureContext.class,0);
+ }
+ public TerminalNode SemiColon() { return getToken(TypeScriptParser.SemiColon, 0); }
+ public IndexMemberDeclarationContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_indexMemberDeclaration; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterIndexMemberDeclaration(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitIndexMemberDeclaration(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitIndexMemberDeclaration(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final IndexMemberDeclarationContext indexMemberDeclaration() throws RecognitionException {
+ IndexMemberDeclarationContext _localctx = new IndexMemberDeclarationContext(_ctx, getState());
+ enterRule(_localctx, 204, RULE_indexMemberDeclaration);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(1200);
+ indexSignature();
+ setState(1201);
+ match(SemiColon);
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class GeneratorMethodContext extends ParserRuleContext {
+ public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
+ public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
+ public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
+ public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); }
+ public FunctionBodyContext functionBody() {
+ return getRuleContext(FunctionBodyContext.class,0);
+ }
+ public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); }
+ public TerminalNode Multiply() { return getToken(TypeScriptParser.Multiply, 0); }
+ public FormalParameterListContext formalParameterList() {
+ return getRuleContext(FormalParameterListContext.class,0);
+ }
+ public GeneratorMethodContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_generatorMethod; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterGeneratorMethod(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitGeneratorMethod(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitGeneratorMethod(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final GeneratorMethodContext generatorMethod() throws RecognitionException {
+ GeneratorMethodContext _localctx = new GeneratorMethodContext(_ctx, getState());
+ enterRule(_localctx, 206, RULE_generatorMethod);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(1204);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==Multiply) {
+ {
+ setState(1203);
+ match(Multiply);
+ }
+ }
+
+ setState(1206);
+ match(Identifier);
+ setState(1207);
+ match(OpenParen);
+ setState(1209);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 65808L) != 0) || ((((_la - 101)) & ~0x3f) == 0 && ((1L << (_la - 101)) & 12718099L) != 0)) {
+ {
+ setState(1208);
+ formalParameterList();
+ }
+ }
+
+ setState(1211);
+ match(CloseParen);
+ setState(1212);
+ match(OpenBrace);
+ setState(1213);
+ functionBody();
+ setState(1214);
+ match(CloseBrace);
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class GeneratorFunctionDeclarationContext extends ParserRuleContext {
+ public TerminalNode Function_() { return getToken(TypeScriptParser.Function_, 0); }
+ public TerminalNode Multiply() { return getToken(TypeScriptParser.Multiply, 0); }
+ public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
+ public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
+ public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); }
+ public FunctionBodyContext functionBody() {
+ return getRuleContext(FunctionBodyContext.class,0);
+ }
+ public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); }
+ public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
+ public FormalParameterListContext formalParameterList() {
+ return getRuleContext(FormalParameterListContext.class,0);
+ }
+ public GeneratorFunctionDeclarationContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_generatorFunctionDeclaration; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterGeneratorFunctionDeclaration(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitGeneratorFunctionDeclaration(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitGeneratorFunctionDeclaration(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final GeneratorFunctionDeclarationContext generatorFunctionDeclaration() throws RecognitionException {
+ GeneratorFunctionDeclarationContext _localctx = new GeneratorFunctionDeclarationContext(_ctx, getState());
+ enterRule(_localctx, 208, RULE_generatorFunctionDeclaration);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(1216);
+ match(Function_);
+ setState(1217);
+ match(Multiply);
+ setState(1219);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==Identifier) {
+ {
+ setState(1218);
+ match(Identifier);
+ }
+ }
+
+ setState(1221);
+ match(OpenParen);
+ setState(1223);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 65808L) != 0) || ((((_la - 101)) & ~0x3f) == 0 && ((1L << (_la - 101)) & 12718099L) != 0)) {
+ {
+ setState(1222);
+ formalParameterList();
+ }
+ }
+
+ setState(1225);
+ match(CloseParen);
+ setState(1226);
+ match(OpenBrace);
+ setState(1227);
+ functionBody();
+ setState(1228);
+ match(CloseBrace);
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class GeneratorBlockContext extends ParserRuleContext {
+ public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); }
+ public List generatorDefinition() {
+ return getRuleContexts(GeneratorDefinitionContext.class);
+ }
+ public GeneratorDefinitionContext generatorDefinition(int i) {
+ return getRuleContext(GeneratorDefinitionContext.class,i);
+ }
+ public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); }
+ public List Comma() { return getTokens(TypeScriptParser.Comma); }
+ public TerminalNode Comma(int i) {
+ return getToken(TypeScriptParser.Comma, i);
+ }
+ public GeneratorBlockContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_generatorBlock; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterGeneratorBlock(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitGeneratorBlock(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitGeneratorBlock(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final GeneratorBlockContext generatorBlock() throws RecognitionException {
+ GeneratorBlockContext _localctx = new GeneratorBlockContext(_ctx, getState());
+ enterRule(_localctx, 210, RULE_generatorBlock);
+ int _la;
+ try {
+ int _alt;
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(1230);
+ match(OpenBrace);
+ setState(1231);
+ generatorDefinition();
+ setState(1236);
+ _errHandler.sync(this);
+ _alt = getInterpreter().adaptivePredict(_input,151,_ctx);
+ while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+ if ( _alt==1 ) {
+ {
+ {
+ setState(1232);
+ match(Comma);
+ setState(1233);
+ generatorDefinition();
+ }
+ }
+ }
+ setState(1238);
+ _errHandler.sync(this);
+ _alt = getInterpreter().adaptivePredict(_input,151,_ctx);
+ }
+ setState(1240);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==Comma) {
+ {
+ setState(1239);
+ match(Comma);
+ }
+ }
+
+ setState(1242);
+ match(CloseBrace);
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class GeneratorDefinitionContext extends ParserRuleContext {
+ public TerminalNode Multiply() { return getToken(TypeScriptParser.Multiply, 0); }
+ public IteratorDefinitionContext iteratorDefinition() {
+ return getRuleContext(IteratorDefinitionContext.class,0);
+ }
+ public GeneratorDefinitionContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_generatorDefinition; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterGeneratorDefinition(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitGeneratorDefinition(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitGeneratorDefinition(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final GeneratorDefinitionContext generatorDefinition() throws RecognitionException {
+ GeneratorDefinitionContext _localctx = new GeneratorDefinitionContext(_ctx, getState());
+ enterRule(_localctx, 212, RULE_generatorDefinition);
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(1244);
+ match(Multiply);
+ setState(1245);
+ iteratorDefinition();
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class IteratorBlockContext extends ParserRuleContext {
+ public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); }
+ public List iteratorDefinition() {
+ return getRuleContexts(IteratorDefinitionContext.class);
+ }
+ public IteratorDefinitionContext iteratorDefinition(int i) {
+ return getRuleContext(IteratorDefinitionContext.class,i);
+ }
+ public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); }
+ public List Comma() { return getTokens(TypeScriptParser.Comma); }
+ public TerminalNode Comma(int i) {
+ return getToken(TypeScriptParser.Comma, i);
+ }
+ public IteratorBlockContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_iteratorBlock; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterIteratorBlock(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitIteratorBlock(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitIteratorBlock(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final IteratorBlockContext iteratorBlock() throws RecognitionException {
+ IteratorBlockContext _localctx = new IteratorBlockContext(_ctx, getState());
+ enterRule(_localctx, 214, RULE_iteratorBlock);
+ int _la;
+ try {
+ int _alt;
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(1247);
+ match(OpenBrace);
+ setState(1248);
+ iteratorDefinition();
+ setState(1253);
+ _errHandler.sync(this);
+ _alt = getInterpreter().adaptivePredict(_input,153,_ctx);
+ while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+ if ( _alt==1 ) {
+ {
+ {
+ setState(1249);
+ match(Comma);
+ setState(1250);
+ iteratorDefinition();
+ }
+ }
+ }
+ setState(1255);
+ _errHandler.sync(this);
+ _alt = getInterpreter().adaptivePredict(_input,153,_ctx);
+ }
+ setState(1257);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==Comma) {
+ {
+ setState(1256);
+ match(Comma);
+ }
+ }
+
+ setState(1259);
+ match(CloseBrace);
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class IteratorDefinitionContext extends ParserRuleContext {
+ public TerminalNode OpenBracket() { return getToken(TypeScriptParser.OpenBracket, 0); }
+ public SingleExpressionContext singleExpression() {
+ return getRuleContext(SingleExpressionContext.class,0);
+ }
+ public TerminalNode CloseBracket() { return getToken(TypeScriptParser.CloseBracket, 0); }
+ public TerminalNode OpenParen() { return getToken(TypeScriptParser.OpenParen, 0); }
+ public TerminalNode CloseParen() { return getToken(TypeScriptParser.CloseParen, 0); }
+ public TerminalNode OpenBrace() { return getToken(TypeScriptParser.OpenBrace, 0); }
+ public FunctionBodyContext functionBody() {
+ return getRuleContext(FunctionBodyContext.class,0);
+ }
+ public TerminalNode CloseBrace() { return getToken(TypeScriptParser.CloseBrace, 0); }
+ public FormalParameterListContext formalParameterList() {
+ return getRuleContext(FormalParameterListContext.class,0);
+ }
+ public IteratorDefinitionContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_iteratorDefinition; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterIteratorDefinition(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitIteratorDefinition(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitIteratorDefinition(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final IteratorDefinitionContext iteratorDefinition() throws RecognitionException {
+ IteratorDefinitionContext _localctx = new IteratorDefinitionContext(_ctx, getState());
+ enterRule(_localctx, 216, RULE_iteratorDefinition);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(1261);
+ match(OpenBracket);
+ setState(1262);
+ singleExpression(0);
+ setState(1263);
+ match(CloseBracket);
+ setState(1264);
+ match(OpenParen);
+ setState(1266);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if ((((_la) & ~0x3f) == 0 && ((1L << _la) & 65808L) != 0) || ((((_la - 101)) & ~0x3f) == 0 && ((1L << (_la - 101)) & 12718099L) != 0)) {
+ {
+ setState(1265);
+ formalParameterList();
+ }
+ }
+
+ setState(1268);
+ match(CloseParen);
+ setState(1269);
+ match(OpenBrace);
+ setState(1270);
+ functionBody();
+ setState(1271);
+ match(CloseBrace);
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class FormalParameterListContext extends ParserRuleContext {
+ public List formalParameterArg() {
+ return getRuleContexts(FormalParameterArgContext.class);
+ }
+ public FormalParameterArgContext formalParameterArg(int i) {
+ return getRuleContext(FormalParameterArgContext.class,i);
+ }
+ public List Comma() { return getTokens(TypeScriptParser.Comma); }
+ public TerminalNode Comma(int i) {
+ return getToken(TypeScriptParser.Comma, i);
+ }
+ public LastFormalParameterArgContext lastFormalParameterArg() {
+ return getRuleContext(LastFormalParameterArgContext.class,0);
+ }
+ public ArrayLiteralContext arrayLiteral() {
+ return getRuleContext(ArrayLiteralContext.class,0);
+ }
+ public ObjectLiteralContext objectLiteral() {
+ return getRuleContext(ObjectLiteralContext.class,0);
+ }
+ public TerminalNode Colon() { return getToken(TypeScriptParser.Colon, 0); }
+ public FormalParameterListContext formalParameterList() {
+ return getRuleContext(FormalParameterListContext.class,0);
+ }
+ public FormalParameterListContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_formalParameterList; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterFormalParameterList(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitFormalParameterList(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitFormalParameterList(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final FormalParameterListContext formalParameterList() throws RecognitionException {
+ FormalParameterListContext _localctx = new FormalParameterListContext(_ctx, getState());
+ enterRule(_localctx, 218, RULE_formalParameterList);
+ int _la;
+ try {
+ int _alt;
+ setState(1292);
+ _errHandler.sync(this);
+ switch (_input.LA(1)) {
+ case Private:
+ case Public:
+ case Protected:
+ case TypeAlias:
+ case Require:
+ case At:
+ case Identifier:
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(1273);
+ formalParameterArg();
+ setState(1278);
+ _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(1274);
+ match(Comma);
+ setState(1275);
+ formalParameterArg();
+ }
+ }
+ }
+ setState(1280);
+ _errHandler.sync(this);
+ _alt = getInterpreter().adaptivePredict(_input,156,_ctx);
+ }
+ setState(1283);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==Comma) {
+ {
+ setState(1281);
+ match(Comma);
+ setState(1282);
+ lastFormalParameterArg();
+ }
+ }
+
+ }
+ break;
+ case Ellipsis:
+ enterOuterAlt(_localctx, 2);
+ {
+ setState(1285);
+ lastFormalParameterArg();
+ }
+ break;
+ case OpenBracket:
+ enterOuterAlt(_localctx, 3);
+ {
+ setState(1286);
+ arrayLiteral();
+ }
+ break;
+ case OpenBrace:
+ enterOuterAlt(_localctx, 4);
+ {
+ setState(1287);
+ objectLiteral();
+ setState(1290);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==Colon) {
+ {
+ setState(1288);
+ match(Colon);
+ setState(1289);
+ formalParameterList();
+ }
+ }
+
+ }
+ break;
+ default:
+ throw new NoViableAltException(this);
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class FormalParameterArgContext extends ParserRuleContext {
+ public IdentifierOrKeyWordContext identifierOrKeyWord() {
+ return getRuleContext(IdentifierOrKeyWordContext.class,0);
+ }
+ public DecoratorContext decorator() {
+ return getRuleContext(DecoratorContext.class,0);
+ }
+ public AccessibilityModifierContext accessibilityModifier() {
+ return getRuleContext(AccessibilityModifierContext.class,0);
+ }
+ public TerminalNode QuestionMark() { return getToken(TypeScriptParser.QuestionMark, 0); }
+ public TypeAnnotationContext typeAnnotation() {
+ return getRuleContext(TypeAnnotationContext.class,0);
+ }
+ public TerminalNode Assign() { return getToken(TypeScriptParser.Assign, 0); }
+ public SingleExpressionContext singleExpression() {
+ return getRuleContext(SingleExpressionContext.class,0);
+ }
+ public FormalParameterArgContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_formalParameterArg; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterFormalParameterArg(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitFormalParameterArg(this);
+ }
+ @Override
+ public T accept(ParseTreeVisitor extends T> visitor) {
+ if ( visitor instanceof TypeScriptParserVisitor ) return ((TypeScriptParserVisitor extends T>)visitor).visitFormalParameterArg(this);
+ else return visitor.visitChildren(this);
+ }
+ }
+
+ public final FormalParameterArgContext formalParameterArg() throws RecognitionException {
+ FormalParameterArgContext _localctx = new FormalParameterArgContext(_ctx, getState());
+ enterRule(_localctx, 220, RULE_formalParameterArg);
+ int _la;
+ try {
+ enterOuterAlt(_localctx, 1);
+ {
+ setState(1295);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==At) {
+ {
+ setState(1294);
+ decorator();
+ }
+ }
+
+ setState(1298);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (((((_la - 101)) & ~0x3f) == 0 && ((1L << (_la - 101)) & 19L) != 0)) {
+ {
+ setState(1297);
+ accessibilityModifier();
+ }
+ }
+
+ setState(1300);
+ identifierOrKeyWord();
+ setState(1302);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==QuestionMark) {
+ {
+ setState(1301);
+ match(QuestionMark);
+ }
+ }
+
+ setState(1305);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==Colon) {
+ {
+ setState(1304);
+ typeAnnotation();
+ }
+ }
+
+ setState(1309);
+ _errHandler.sync(this);
+ _la = _input.LA(1);
+ if (_la==Assign) {
+ {
+ setState(1307);
+ match(Assign);
+ setState(1308);
+ singleExpression(0);
+ }
+ }
+
+ }
+ }
+ catch (RecognitionException re) {
+ _localctx.exception = re;
+ _errHandler.reportError(this, re);
+ _errHandler.recover(this, re);
+ }
+ finally {
+ exitRule();
+ }
+ return _localctx;
+ }
+
+ @SuppressWarnings("CheckReturnValue")
+ public static class LastFormalParameterArgContext extends ParserRuleContext {
+ public TerminalNode Ellipsis() { return getToken(TypeScriptParser.Ellipsis, 0); }
+ public TerminalNode Identifier() { return getToken(TypeScriptParser.Identifier, 0); }
+ public TypeAnnotationContext typeAnnotation() {
+ return getRuleContext(TypeAnnotationContext.class,0);
+ }
+ public LastFormalParameterArgContext(ParserRuleContext parent, int invokingState) {
+ super(parent, invokingState);
+ }
+ @Override public int getRuleIndex() { return RULE_lastFormalParameterArg; }
+ @Override
+ public void enterRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).enterLastFormalParameterArg(this);
+ }
+ @Override
+ public void exitRule(ParseTreeListener listener) {
+ if ( listener instanceof TypeScriptParserListener ) ((TypeScriptParserListener)listener).exitLastFormalParameterArg(this);
+ }
+ @Override
+ public