From 3c67341b8d514b584ae6aa54f329df3d09005184 Mon Sep 17 00:00:00 2001 From: MrIkso Date: Sun, 29 May 2022 16:17:49 +0300 Subject: [PATCH] Added Cpp/C highlighting --- .../androidide/language/cpp/CppAnalyzer.java | 248 + .../androidide/language/cpp/CppLanguage.java | 167 + .../views/editor/CodeEditorView.java | 701 +- .../androidide/lexers/cpp/CPP14Lexer.g4 | 409 + .../androidide/lexers/cpp/CPP14Lexer.interp | 478 + .../androidide/lexers/cpp/CPP14Lexer.java | 757 + .../androidide/lexers/cpp/CPP14Lexer.tokens | 264 + .../androidide/lexers/cpp/CPP14Parser.g4 | 823 + .../androidide/lexers/cpp/CPP14Parser.interp | 490 + .../androidide/lexers/cpp/CPP14Parser.java | 14438 ++++++++++++++++ .../androidide/lexers/cpp/CPP14Parser.tokens | 264 + 11 files changed, 18705 insertions(+), 334 deletions(-) create mode 100644 app/src/main/java/com/itsaky/androidide/language/cpp/CppAnalyzer.java create mode 100644 app/src/main/java/com/itsaky/androidide/language/cpp/CppLanguage.java create mode 100644 lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Lexer.g4 create mode 100644 lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Lexer.interp create mode 100644 lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Lexer.java create mode 100644 lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Lexer.tokens create mode 100644 lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Parser.g4 create mode 100644 lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Parser.interp create mode 100644 lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Parser.java create mode 100644 lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Parser.tokens diff --git a/app/src/main/java/com/itsaky/androidide/language/cpp/CppAnalyzer.java b/app/src/main/java/com/itsaky/androidide/language/cpp/CppAnalyzer.java new file mode 100644 index 000000000..358c0438e --- /dev/null +++ b/app/src/main/java/com/itsaky/androidide/language/cpp/CppAnalyzer.java @@ -0,0 +1,248 @@ +package com.itsaky.androidide.language.cpp; + +import static com.itsaky.androidide.lexers.cpp.CPP14Lexer.*; +import static com.itsaky.androidide.syntax.colorschemes.SchemeAndroidIDE.LITERAL; +import static com.itsaky.androidide.syntax.colorschemes.SchemeAndroidIDE.OPERATOR; +import static com.itsaky.androidide.syntax.colorschemes.SchemeAndroidIDE.TEXT_NORMAL; +import static com.itsaky.androidide.syntax.colorschemes.SchemeAndroidIDE.TYPE_NAME; +import static com.itsaky.androidide.syntax.colorschemes.SchemeAndroidIDE.forComment; +import static com.itsaky.androidide.syntax.colorschemes.SchemeAndroidIDE.forKeyword; +import static com.itsaky.androidide.syntax.colorschemes.SchemeAndroidIDE.forString; +import static com.itsaky.androidide.syntax.colorschemes.SchemeAndroidIDE.get; + +import com.itsaky.androidide.lexers.cpp.CPP14Lexer; +import com.itsaky.androidide.lexers.cpp.CPP14Parser; +import com.itsaky.androidide.syntax.colorschemes.SchemeAndroidIDE; +import com.itsaky.androidide.utils.CharSequenceReader; +import com.itsaky.androidide.utils.ILogger; + +import io.github.rosemoe.sora.lang.analysis.SimpleAnalyzeManager; +import io.github.rosemoe.sora.lang.styling.CodeBlock; +import io.github.rosemoe.sora.lang.styling.MappedSpans; +import io.github.rosemoe.sora.lang.styling.Styles; + +import org.antlr.v4.runtime.CharStreams; +import org.antlr.v4.runtime.CodePointCharStream; +import org.antlr.v4.runtime.CommonTokenStream; +import org.antlr.v4.runtime.Token; + +import java.io.IOException; +import java.util.Stack; + +public class CppAnalyzer extends SimpleAnalyzeManager { + + private static final ILogger LOG = ILogger.newInstance("CppAnalyzer"); + + @Override + protected Styles analyze(StringBuilder text, Delegate delegate) { + final var styles = new Styles(); + final var colors = new MappedSpans.Builder(); + final CodePointCharStream stream; + try { + stream = CharStreams.fromReader(new CharSequenceReader(text)); + } catch (IOException e) { + LOG.error("Unable to read text to analyze", e); + return styles; + } + + final var lexer = new CPP14Lexer(stream); + // final var parser = new CPP14Parser(new CommonTokenStream(lexer)); + final var stack = new Stack(); + Token token; + int line, column, lastLine = 1, currSwitch = 0, maxSwitch = 0, type, previous = 0; + boolean isFirst = true; + + while (!delegate.isCancelled()) { + token = lexer.nextToken(); + if (token == null) { + break; + } + + line = token.getLine() - 1; + column = token.getCharPositionInLine(); + type = token.getType(); + + if (type == CPP14Lexer.EOF) { + lastLine = line; + break; + } + + switch (type) { + case Whitespace: + if (isFirst) { + colors.addNormalIfNull(); + } + break; + case Alignas: + case Alignof: + case Asm: + case Auto: + case Break: + case Class: + case Const: + case Catch: + case Case: + case Constexpr: + case Const_cast: + case Continue: + case Decltype: + case Default: + case Delete: + case Do: + case Dynamic_cast: + case Else: + case Enum: + case Explicit: + case Export: + case Extern: + case Final: + case For: + case Friend: + case Goto: + case If: + case Inline: + case Mutable: + case Namespace: + case New: + case Noexcept: + case Operator: + case Override: + case Private: + case Protected: + case Public: + case Register: + case Reinterpret_cast: + case Return: + case Sizeof: + case Signed: + case Static: + case Static_cast: + case Static_assert: + case Struct: + case Switch: + case Template: + case This: + case Throw: + case Thread_local: + case Try: + case Typedef: + case Typeid_: + case Typename_: + case Unsigned: + case Union: + case Using: + case Virtual: + case Volatile: + case While: + case Void: + colors.addIfNeeded(line, column, forKeyword()); + break; + case Bool: + case Char: + case Char16: + case Char32: + case Double: + case Float: + case Int: + case Long: + case Short: + case Wchar: + colors.addIfNeeded(line, column, get(TYPE_NAME)); + break; + case LeftParen: + case LeftBracket: + case LeftBrace: + case Dot: + case RightParen: + case RightBracket: + case RightBrace: + case Semi: + case Comma: + colors.addIfNeeded(line, column, get(OPERATOR)); + break; + case Plus: + case Minus: + case Star: + case Div: + case Mod: + case Caret: + case And: + case Or: + case Tilde: + case Not: + case Assign: + case Less: + case Greater: + case PlusAssign: + case MinusAssign: + case StarAssign: + case DivAssign: + case ModAssign: + case XorAssign: + case AndAssign: + case OrAssign: + case RightShiftAssign: + case LeftShiftAssign: + case Equal: + case NotEqual: + case LessEqual: + case GreaterEqual: + case AndAnd: + case OrOr: + case PlusPlus: + case MinusMinus: + case Arrow: + case ArrowStar: + case Question: + case Colon: + case Doublecolon: + case DotStar: + case Ellipsis: + colors.addIfNeeded(line, column, get(OPERATOR)); + break; + case IntegerLiteral: + case DecimalLiteral: + case OctalLiteral: + case HexadecimalLiteral: + case BinaryLiteral: + case Integersuffix: + case CharacterLiteral: + case FloatingLiteral: + case StringLiteral: + case BooleanLiteral: + case Nullptr: + case True_: + case False_: + colors.addIfNeeded(line, column, get(LITERAL)); + break; + case BlockComment: + case LineComment: + colors.addIfNeeded(line, column, get(SchemeAndroidIDE.COMMENT)); + break; + case MultiLineMacro: + case Directive: + colors.addIfNeeded(line, column, forString()); + break; + + default: + colors.addIfNeeded(line, column, get(TEXT_NORMAL)); + break; + } + + isFirst = false; + if (type != Whitespace) { + previous = type; + } + } + + if (stack.isEmpty() && currSwitch > maxSwitch) { + maxSwitch = currSwitch; + } + + colors.determine(lastLine); + styles.setSuppressSwitch(maxSwitch + 10); + styles.spans = colors.build(); + + return styles; + } +} diff --git a/app/src/main/java/com/itsaky/androidide/language/cpp/CppLanguage.java b/app/src/main/java/com/itsaky/androidide/language/cpp/CppLanguage.java new file mode 100644 index 000000000..ebde8b69f --- /dev/null +++ b/app/src/main/java/com/itsaky/androidide/language/cpp/CppLanguage.java @@ -0,0 +1,167 @@ +/************************************************************************************ + * This file is part of AndroidIDE. + * + * AndroidIDE is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * AndroidIDE is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with AndroidIDE. If not, see . + * + **************************************************************************************/ +package com.itsaky.androidide.language.cpp; + +import android.os.Bundle; + +import androidx.annotation.NonNull; + +import com.itsaky.androidide.language.IDELanguage; + +import com.itsaky.androidide.language.java.JavaLanguage; +import com.itsaky.androidide.utils.CharSequenceReader; +import com.itsaky.androidide.utils.ILogger; + +import org.antlr.v4.runtime.CharStreams; +import org.antlr.v4.runtime.Token; + +import java.io.StringReader; +import com.itsaky.androidide.lexers.cpp.CPP14Lexer; + +import io.github.rosemoe.sora.lang.analysis.AnalyzeManager; +import io.github.rosemoe.sora.lang.completion.CompletionCancelledException; +import io.github.rosemoe.sora.lang.completion.CompletionPublisher; +import io.github.rosemoe.sora.lang.smartEnter.NewlineHandleResult; +import io.github.rosemoe.sora.lang.smartEnter.NewlineHandler; +import io.github.rosemoe.sora.text.CharPosition; +import io.github.rosemoe.sora.text.ContentReference; +import io.github.rosemoe.sora.text.TextUtils; +import io.github.rosemoe.sora.widget.SymbolPairMatch; + +public class CppLanguage extends IDELanguage { + + private static final ILogger LOG = ILogger.newInstance("CppLanguage"); + private CppAnalyzer analyzer; + private final NewlineHandler[] newlineHandlers = new NewlineHandler[] {new BraceHandler()}; + + public CppLanguage() { + analyzer = new CppAnalyzer(); + } + + @Override + public int getIndentAdvance(@NonNull String line) { + try { + CPP14Lexer lexer = new CPP14Lexer(CharStreams.fromReader(new StringReader(line))); + Token token; + int advance = 0; + while (((token = lexer.nextToken()) != null && token.getType() != token.EOF)) { + switch (token.getType()) { + case CPP14Lexer.LeftBrace: + advance++; + break; + case CPP14Lexer.RightBrace: + advance--; + break; + } + } + advance = Math.max(0, advance); + return advance * getTabSize(); + } catch (Throwable e) { + LOG.error("Error calculating indent advance", e); + } + return 0; + } + + @Override + public SymbolPairMatch getSymbolPairs() { + return new CppSymbolPairs(); + } + + @NonNull + @Override + public AnalyzeManager getAnalyzeManager() { + return analyzer; + } + + @Override + public int getInterruptionLevel() { + return INTERRUPTION_LEVEL_STRONG; + } + + @Override + public void requireAutoComplete( + @NonNull ContentReference content, + @NonNull CharPosition position, + @NonNull CompletionPublisher publisher, + @NonNull Bundle extraArguments) + throws CompletionCancelledException { + + // completer.complete(content, position, publisher, extraArguments); + } + + @Override + public int getIndentAdvance(@NonNull ContentReference content, int line, int column) { + return getIndentAdvance(content.getLine(line).substring(0, column)); + } + + @Override + public CharSequence format(CharSequence content) { + return content; + } + + @Override + public NewlineHandler[] getNewlineHandlers() { + return newlineHandlers; + } + + @Override + public void destroy() { + analyzer = null; + } + + private static class CppSymbolPairs extends SymbolPairMatch { + public CppSymbolPairs() { + super.putPair('{', new Replacement("{}", 1)); + super.putPair('(', new Replacement("()", 1)); + super.putPair('[', new Replacement("[]", 1)); + super.putPair('"', new Replacement("\"\"", 1)); + super.putPair('\'', new Replacement("''", 1)); + super.putPair('<', new Replacement("<>", 1)); + } + } + + class BraceHandler implements NewlineHandler { + + @Override + public boolean matchesRequirement(String beforeText, String afterText) { + beforeText = beforeText.trim(); + afterText = afterText.trim(); + return beforeText.endsWith("{") && afterText.startsWith("}"); + } + + @Override + public NewlineHandleResult handleNewline(String beforeText, String afterText, int tabSize) { + int count = TextUtils.countLeadingSpaceCount(beforeText, tabSize); + int advanceBefore = getIndentAdvance(beforeText); + int advanceAfter = getIndentAdvance(afterText); + String text; + StringBuilder sb = + new StringBuilder("\n") + .append( + TextUtils.createIndent( + count + advanceBefore, tabSize, useTab())) + .append('\n') + .append( + text = + TextUtils.createIndent( + count + advanceAfter, tabSize, useTab())); + int shiftLeft = text.length() + 1; + return new NewlineHandleResult(sb, shiftLeft); + } + } +} diff --git a/app/src/main/java/com/itsaky/androidide/views/editor/CodeEditorView.java b/app/src/main/java/com/itsaky/androidide/views/editor/CodeEditorView.java index b5be7c305..3336ead66 100644 --- a/app/src/main/java/com/itsaky/androidide/views/editor/CodeEditorView.java +++ b/app/src/main/java/com/itsaky/androidide/views/editor/CodeEditorView.java @@ -44,10 +44,12 @@ import androidx.annotation.NonNull; import androidx.annotation.Nullable; import com.blankj.utilcode.util.FileIOUtils; +import com.blankj.utilcode.util.FileUtils; import com.blankj.utilcode.util.SizeUtils; import com.itsaky.androidide.adapters.CompletionListAdapter; import com.itsaky.androidide.app.StudioApp; import com.itsaky.androidide.databinding.LayoutCodeEditorBinding; +import com.itsaky.androidide.language.cpp.CppLanguage; import com.itsaky.androidide.language.groovy.GroovyLanguage; import com.itsaky.androidide.language.java.JavaLanguage; import com.itsaky.androidide.language.xml.XMLLanguage; @@ -61,8 +63,10 @@ import com.itsaky.androidide.utils.ILogger; import com.itsaky.androidide.utils.LSPUtils; import com.itsaky.androidide.utils.TypefaceUtils; import com.itsaky.inflater.values.ValuesTableFactory; +import com.itsaky.lsp.api.ILanguageServer; import com.itsaky.lsp.models.Range; +import io.github.rosemoe.sora.lang.Language; import org.antlr.v4.runtime.CharStreams; import org.antlr.v4.runtime.Token; @@ -87,357 +91,386 @@ import io.github.rosemoe.sora.widget.component.Magnifier; @SuppressLint("ViewConstructor") // This view is always dynamically created. public class CodeEditorView extends FrameLayout { - private static final ILogger LOG = ILogger.newInstance("CodeEditorView"); - private final File file; - private final LayoutCodeEditorBinding binding; - private boolean isModified; - private boolean isFirstCreate; + private static final ILogger LOG = ILogger.newInstance("CodeEditorView"); + private final File file; + private final LayoutCodeEditorBinding binding; + private boolean isModified; + private boolean isFirstCreate; - public CodeEditorView( - @NonNull Context context, @NonNull File file, final @NonNull Range selection) { - super(context); - this.file = file; - this.isModified = false; - this.isFirstCreate = true; + public CodeEditorView( + @NonNull Context context, @NonNull File file, final @NonNull Range selection) { + super(context); + this.file = file; + this.isModified = false; + this.isFirstCreate = true; - this.binding = LayoutCodeEditorBinding.inflate(LayoutInflater.from(context)); - this.binding.editor.setTypefaceText(TypefaceUtils.jetbrainsMono()); - this.binding.editor.setHighlightCurrentBlock(true); - this.binding.editor.getProps().autoCompletionOnComposing = true; - this.binding.editor.setAutoCompletionItemAdapter(new CompletionListAdapter()); - this.binding.editor.setDividerWidth(SizeUtils.dp2px(1)); - this.binding.editor.setColorScheme(new SchemeAndroidIDE()); - this.binding.editor.subscribeEvent( - ContentChangeEvent.class, ((event, unsubscribe) -> handleContentChange(event))); + this.binding = LayoutCodeEditorBinding.inflate(LayoutInflater.from(context)); + this.binding.editor.setTypefaceText(TypefaceUtils.jetbrainsMono()); + this.binding.editor.setHighlightCurrentBlock(true); + this.binding.editor.getProps().autoCompletionOnComposing = true; + this.binding.editor.setAutoCompletionItemAdapter(new CompletionListAdapter()); + this.binding.editor.setDividerWidth(SizeUtils.dp2px(1)); + this.binding.editor.setColorScheme(new SchemeAndroidIDE()); + this.binding.editor.subscribeEvent( + ContentChangeEvent.class, ((event, unsubscribe) -> handleContentChange(event))); - this.binding.diagnosticTextContainer.setVisibility(GONE); + this.binding.diagnosticTextContainer.setVisibility(GONE); - removeAllViews(); - addView(this.binding.getRoot()); + removeAllViews(); + addView(this.binding.getRoot()); - selection.validate(); - CompletableFuture.runAsync( - () -> { - final var contents = FileIOUtils.readFile2String(file); - binding.editor.post( - () -> { - binding.editor.setText(contents, createEditorArgs()); - postRead(); - if (LSPUtils.isEqual(selection.getStart(), selection.getEnd())) { - getEditor() - .setSelection( - selection.getStart().getLine(), selection.getStart().getColumn()); - } else { - getEditor().setSelection(selection); + selection.validate(); + CompletableFuture.runAsync( + () -> { + final var contents = FileIOUtils.readFile2String(file); + binding.editor.post( + () -> { + binding.editor.setText(contents, createEditorArgs()); + postRead(); + if (LSPUtils.isEqual(selection.getStart(), selection.getEnd())) { + getEditor() + .setSelection( + selection.getStart().getLine(), + selection.getStart().getColumn()); + } else { + getEditor().setSelection(selection); + } + }); + }); + + configureEditorIfNeeded(); + } + + @NonNull + private Bundle createEditorArgs() { + var bundle = new Bundle(); + if (getFile() == null) { + return bundle; + } + + bundle.putString(IDEEditor.KEY_FILE, getFile().getAbsolutePath()); + return bundle; + } + + private void handleContentChange(@NonNull ContentChangeEvent event) { + isModified = true; + + if (event.getAction() == ContentChangeEvent.ACTION_INSERT) { + final var editor = event.getEditor(); + final var content = event.getChangedText(); + final var endLine = event.getChangeEnd().line; + final var endColumn = event.getChangeEnd().column; + if (file.getName().endsWith(".xml")) { + boolean isOpen = false; + try { + isOpen = editor.getText().charAt(editor.getCursor().getLeft() - 2) == '<'; + } catch (Throwable th) { + LOG.error(th); } - }); - }); - configureEditorIfNeeded(); - } - - @NonNull - private Bundle createEditorArgs() { - var bundle = new Bundle(); - if (getFile() == null) { - return bundle; + if (isOpen && "/".contentEquals(content)) { + closeCurrentTag(editor.getText().toString(), endLine, endColumn); + } + } + } } - bundle.putString(IDEEditor.KEY_FILE, getFile().getAbsolutePath()); - return bundle; - } + public boolean save() { + final var file = getFile(); + if (file == null) { + LOG.error("Cannot save file. File instance is null."); + return false; + } - private void handleContentChange(@NonNull ContentChangeEvent event) { - isModified = true; + if (!isModified() && file.exists()) { + LOG.info(file.getName()); + LOG.info("File was not modified. Skipping save operation."); + return false; + } + + final var text = getEditor().getText().toString(); - if (event.getAction() == ContentChangeEvent.ACTION_INSERT) { - final var editor = event.getEditor(); - final var content = event.getChangedText(); - final var endLine = event.getChangeEnd().line; - final var endColumn = event.getChangeEnd().column; - if (file.getName().endsWith(".xml")) { - boolean isOpen = false; try { - isOpen = editor.getText().charAt(editor.getCursor().getLeft() - 2) == '<'; + FileUtil.writeFile(file, text); + notifySaved(); + isModified = false; + return true; + } catch (IOException io) { + LOG.error("Failed to save file", file, io); + return false; + } + } + + @NonNull + private List getLines(Content text) { + final var count = text.getLineCount(); + final var result = new ArrayList(); + + for (int i = 0; i < count; i++) { + result.add(text.getLine(i)); + } + + return result; + } + + public IDEEditor getEditor() { + return binding.editor; + } + + public LayoutCodeEditorBinding getBinding() { + return binding; + } + + @Nullable + public File getFile() { + return file; + } + + public String getText() { + return binding.editor.getText().toString(); + } + + public boolean isModified() { + return isModified; + } + + public void onPause() { + // unimplemented + } + + public void onResume() { + configureEditorIfNeeded(); + } + + public void onEditorSelected() { + final var editor = getEditor(); + if (editor != null) { + editor.onEditorSelected(); + } + } + + public void undo() { + if (binding.editor.canUndo()) { + binding.editor.undo(); + } + } + + public void redo() { + if (binding.editor.canRedo()) { + binding.editor.redo(); + } + } + + public void findDefinition() { + binding.editor.findDefinition(); + } + + public void findReferences() { + binding.editor.findReferences(); + } + + public void commentLine() { + binding.editor.commentLine(); + } + + public void uncommentLine() { + binding.editor.uncommentLine(); + } + + public void beginSearch() { + binding.editor.beginSearchMode(); + } + + protected void postRead() { + binding.editor.setEditorLanguage(createLanguage(file)); + binding.editor.setLanguageServer(createLanguageServer(file)); + // File must be set only after setting the language server + // This will make sure that textDocument/didOpen is sent + binding.editor.setFile(getFile()); + + if (getContext() instanceof Activity) { + ((Activity) getContext()).invalidateOptionsMenu(); + } + } + + private ILanguageServer createLanguageServer(File file) { + if (file.isFile()) { + String ext = FileUtils.getFileExtension(file); + switch (ext) { + case "java": + return StudioApp.getInstance().getJavaLanguageServer(); + case "xml": + return StudioApp.getInstance().getXMLLanguageServer(); + default: + return null; + } + } + return null; + } + + private Language createLanguage(File file) { + if (file.isFile()) { + String ext = FileUtils.getFileExtension(file); + switch (ext) { + case "java": + return new JavaLanguage(); + case "xml": + return new XMLLanguage(); + case "gradle": + return new GroovyLanguage(); + case "kt": + return new KotlinLanguage(); + case "c": + case "h": + case "cc": + case "cpp": + case "cxx": + return new CppLanguage(); + default: + return new EmptyLanguage(); + } + } + return new EmptyLanguage(); + } + + private void configureEditorIfNeeded() { + boolean sizeChanged = isFirstCreate || ConstantsBridge.EDITOR_PREF_SIZE_CHANGED; + boolean ligaturesChanged = isFirstCreate || ConstantsBridge.EDITOR_PREF_LIGATURES_CHANGED; + boolean flagsChanged = isFirstCreate || ConstantsBridge.EDITOR_PREF_FLAGS_CHANGED; + boolean drawHexChanged = isFirstCreate || ConstantsBridge.EDITOR_PREF_DRAW_HEX_CHANGED; + boolean inputFlagsChanged = + isFirstCreate || ConstantsBridge.EDITOR_PREF_VISIBLE_PASSWORD_CHANGED; + boolean wordWrapChanged = isFirstCreate || ConstantsBridge.EDITOR_PREF_WORD_WRAP_CHANGED; + boolean magnifierChanged = + isFirstCreate || ConstantsBridge.EDITOR_PREF_USE_MAGNIFIER_CHANGED; + + final PreferenceManager prefs = StudioApp.getInstance().getPrefManager(); + + if (sizeChanged) { + float textSize = prefs.getFloat(PreferenceManager.KEY_EDITOR_FONT_SIZE); + if (textSize < 6 || textSize > 32) { + textSize = 14; + } + + binding.editor.setTextSize(textSize); + ConstantsBridge.EDITOR_PREF_SIZE_CHANGED = false; + } + + if (ligaturesChanged) { + var enabled = prefs.getBoolean(PreferenceManager.KEY_EDITOR_FONT_LIGATURES, true); + binding.editor.setLigatureEnabled(enabled); + ConstantsBridge.EDITOR_PREF_LIGATURES_CHANGED = false; + } + + if (flagsChanged) { + int flags = 0; + if (prefs.getBoolean(PreferenceManager.KEY_EDITOR_FLAG_WS_LEADING, true)) { + flags |= IDEEditor.FLAG_DRAW_WHITESPACE_LEADING; + } + + if (prefs.getBoolean(PreferenceManager.KEY_EDITOR_FLAG_WS_TRAILING, false)) { + flags |= IDEEditor.FLAG_DRAW_WHITESPACE_TRAILING; + } + + if (prefs.getBoolean(PreferenceManager.KEY_EDITOR_FLAG_WS_INNER, true)) { + flags |= IDEEditor.FLAG_DRAW_WHITESPACE_INNER; + } + + if (prefs.getBoolean(PreferenceManager.KEY_EDITOR_FLAG_WS_EMPTY_LINE, true)) { + flags |= IDEEditor.FLAG_DRAW_WHITESPACE_FOR_EMPTY_LINE; + } + + if (prefs.getBoolean(PreferenceManager.KEY_EDITOR_FLAG_LINE_BREAK, true)) { + flags |= IDEEditor.FLAG_DRAW_LINE_SEPARATOR; + } + + binding.editor.setNonPrintablePaintingFlags(flags); + ConstantsBridge.EDITOR_PREF_FLAGS_CHANGED = false; + } + + if (inputFlagsChanged) { + binding.editor.setInputType(IDEEditor.createInputFlags()); + ConstantsBridge.EDITOR_PREF_VISIBLE_PASSWORD_CHANGED = false; + } + + if (drawHexChanged) { + // TODO Do something about this + // Maybe use spans... + // binding.editor.setLineColorsEnabled (prefs.getBoolean + // (PreferenceManager.KEY_EDITOR_DRAW_HEX, true)); + ConstantsBridge.EDITOR_PREF_DRAW_HEX_CHANGED = false; + } + + if (wordWrapChanged) { + var enabled = prefs.getBoolean(PreferenceManager.KEY_EDITOR_WORD_WRAP, false); + binding.editor.setWordwrap(enabled); + ConstantsBridge.EDITOR_PREF_WORD_WRAP_CHANGED = false; + } + + if (magnifierChanged) { + var enabled = prefs.getBoolean(PreferenceManager.KEY_EDITOR_USE_MAGNIFER, true); + binding.editor.getComponent(Magnifier.class).setEnabled(enabled); + ConstantsBridge.EDITOR_PREF_USE_MAGNIFIER_CHANGED = false; + } + + isFirstCreate = false; + } + + private void closeCurrentTag(String text, int line, int col) { + try { + XMLLexer lexer = new XMLLexer(CharStreams.fromReader(new StringReader(text))); + Token token; + boolean wasSlash = false, wasOpen = false; + ArrayList currentNames = new ArrayList<>(); + while (((token = lexer.nextToken()) != null && token.getType() != token.EOF)) { + final int type = token.getType(); + if (type == XMLLexer.OPEN) { + wasOpen = true; + } else if (type == XMLLexer.Name) { + if (wasOpen && wasSlash && currentNames.size() > 0) { + currentNames.remove(0); + } else if (wasOpen) { + currentNames.add(0, token.getText()); + wasOpen = false; + } + } else if (type == XMLLexer.OPEN_SLASH) { + int l = token.getLine() - 1; + int c = token.getCharPositionInLine(); + if (l == line && c == col) { + break; + } else if (currentNames.size() > 0) { + currentNames.remove(0); + } + } else if (type == XMLLexer.SLASH_CLOSE || type == XMLLexer.SPECIAL_CLOSE) { + if (currentNames.size() > 0 && token.getText().trim().endsWith("/>")) { + currentNames.remove(0); + } + } else if (type == XMLLexer.SLASH) { + wasSlash = true; + } else { + wasOpen = wasSlash = false; + } + } + + if (currentNames.size() > 0) { + binding.editor.getText().insert(line, col + 2, currentNames.get(0)); + } } catch (Throwable th) { - LOG.error(th); + LOG.error("Unable to close current tag", th); } + } - if (isOpen && "/".contentEquals(content)) { - closeCurrentTag(editor.getText().toString(), endLine, endColumn); + private void notifySaved() { + binding.editor.didSave(); + + if (Objects.requireNonNull(getFile()).getName().endsWith(".xml")) { + ValuesTableFactory.syncWithFile(getFile()); } - } - } - } - - public boolean save() { - final var file = getFile(); - if (file == null) { - LOG.error("Cannot save file. File instance is null."); - return false; } - if (!isModified() && file.exists()) { - LOG.info(file.getName()); - LOG.info("File was not modified. Skipping save operation."); - return false; + /** Mark this files as saved. Even if it not saved. */ + public void markAsSaved() { + isModified = false; + notifySaved(); } - - final var text = getEditor().getText().toString(); - - try { - FileUtil.writeFile(file, text); - notifySaved(); - isModified = false; - return true; - } catch (IOException io) { - LOG.error("Failed to save file", file, io); - return false; - } - } - - @NonNull - private List getLines(Content text) { - final var count = text.getLineCount(); - final var result = new ArrayList(); - - for (int i = 0; i < count; i++) { - result.add(text.getLine(i)); - } - - return result; - } - - public IDEEditor getEditor() { - return binding.editor; - } - - public LayoutCodeEditorBinding getBinding() { - return binding; - } - - @Nullable - public File getFile() { - return file; - } - - public String getText() { - return binding.editor.getText().toString(); - } - - public boolean isModified() { - return isModified; - } - - public void onPause() { - // unimplemented - } - - public void onResume() { - configureEditorIfNeeded(); - } - - public void onEditorSelected() { - final var editor = getEditor(); - if (editor != null) { - editor.onEditorSelected(); - } - } - - public void undo() { - if (binding.editor.canUndo()) { - binding.editor.undo(); - } - } - - public void redo() { - if (binding.editor.canRedo()) { - binding.editor.redo(); - } - } - - public void findDefinition() { - binding.editor.findDefinition(); - } - - public void findReferences() { - binding.editor.findReferences(); - } - - public void commentLine() { - binding.editor.commentLine(); - } - - public void uncommentLine() { - binding.editor.uncommentLine(); - } - - public void beginSearch() { - binding.editor.beginSearchMode(); - } - - protected void postRead() { - if (file.isFile() && file.getName().endsWith(".java")) { - binding.editor.setEditorLanguage(new JavaLanguage()); - binding.editor.setLanguageServer(StudioApp.getInstance().getJavaLanguageServer()); - } else if (file.isFile() && file.getName().endsWith(".xml")) { - binding.editor.setEditorLanguage(new XMLLanguage()); - binding.editor.setLanguageServer(StudioApp.getInstance().getXMLLanguageServer()); - } else if (file.isFile() && file.getName().endsWith(".gradle")) { - binding.editor.setEditorLanguage(new GroovyLanguage()); - } else if (file.isFile() && file.getName().endsWith(".kt")) { - binding.editor.setEditorLanguage(new KotlinLanguage()); - } - else { - binding.editor.setEditorLanguage(new EmptyLanguage()); - } - - // File must be set only after setting the language server - // This will make sure that textDocument/didOpen is sent - binding.editor.setFile(getFile()); - - if (getContext() instanceof Activity) { - ((Activity) getContext()).invalidateOptionsMenu(); - } - } - - private void configureEditorIfNeeded() { - boolean sizeChanged = isFirstCreate || ConstantsBridge.EDITOR_PREF_SIZE_CHANGED; - boolean ligaturesChanged = isFirstCreate || ConstantsBridge.EDITOR_PREF_LIGATURES_CHANGED; - boolean flagsChanged = isFirstCreate || ConstantsBridge.EDITOR_PREF_FLAGS_CHANGED; - boolean drawHexChanged = isFirstCreate || ConstantsBridge.EDITOR_PREF_DRAW_HEX_CHANGED; - boolean inputFlagsChanged = - isFirstCreate || ConstantsBridge.EDITOR_PREF_VISIBLE_PASSWORD_CHANGED; - boolean wordWrapChanged = isFirstCreate || ConstantsBridge.EDITOR_PREF_WORD_WRAP_CHANGED; - boolean magnifierChanged = isFirstCreate || ConstantsBridge.EDITOR_PREF_USE_MAGNIFIER_CHANGED; - - final PreferenceManager prefs = StudioApp.getInstance().getPrefManager(); - - if (sizeChanged) { - float textSize = prefs.getFloat(PreferenceManager.KEY_EDITOR_FONT_SIZE); - if (textSize < 6 || textSize > 32) { - textSize = 14; - } - - binding.editor.setTextSize(textSize); - ConstantsBridge.EDITOR_PREF_SIZE_CHANGED = false; - } - - if (ligaturesChanged) { - var enabled = prefs.getBoolean(PreferenceManager.KEY_EDITOR_FONT_LIGATURES, true); - binding.editor.setLigatureEnabled(enabled); - ConstantsBridge.EDITOR_PREF_LIGATURES_CHANGED = false; - } - - if (flagsChanged) { - int flags = 0; - if (prefs.getBoolean(PreferenceManager.KEY_EDITOR_FLAG_WS_LEADING, true)) { - flags |= IDEEditor.FLAG_DRAW_WHITESPACE_LEADING; - } - - if (prefs.getBoolean(PreferenceManager.KEY_EDITOR_FLAG_WS_TRAILING, false)) { - flags |= IDEEditor.FLAG_DRAW_WHITESPACE_TRAILING; - } - - if (prefs.getBoolean(PreferenceManager.KEY_EDITOR_FLAG_WS_INNER, true)) { - flags |= IDEEditor.FLAG_DRAW_WHITESPACE_INNER; - } - - if (prefs.getBoolean(PreferenceManager.KEY_EDITOR_FLAG_WS_EMPTY_LINE, true)) { - flags |= IDEEditor.FLAG_DRAW_WHITESPACE_FOR_EMPTY_LINE; - } - - if (prefs.getBoolean(PreferenceManager.KEY_EDITOR_FLAG_LINE_BREAK, true)) { - flags |= IDEEditor.FLAG_DRAW_LINE_SEPARATOR; - } - - binding.editor.setNonPrintablePaintingFlags(flags); - ConstantsBridge.EDITOR_PREF_FLAGS_CHANGED = false; - } - - if (inputFlagsChanged) { - binding.editor.setInputType(IDEEditor.createInputFlags()); - ConstantsBridge.EDITOR_PREF_VISIBLE_PASSWORD_CHANGED = false; - } - - if (drawHexChanged) { - // TODO Do something about this - // Maybe use spans... - // binding.editor.setLineColorsEnabled (prefs.getBoolean - // (PreferenceManager.KEY_EDITOR_DRAW_HEX, true)); - ConstantsBridge.EDITOR_PREF_DRAW_HEX_CHANGED = false; - } - - if (wordWrapChanged) { - var enabled = prefs.getBoolean(PreferenceManager.KEY_EDITOR_WORD_WRAP, false); - binding.editor.setWordwrap(enabled); - ConstantsBridge.EDITOR_PREF_WORD_WRAP_CHANGED = false; - } - - if (magnifierChanged) { - var enabled = prefs.getBoolean(PreferenceManager.KEY_EDITOR_USE_MAGNIFER, true); - binding.editor.getComponent(Magnifier.class).setEnabled(enabled); - ConstantsBridge.EDITOR_PREF_USE_MAGNIFIER_CHANGED = false; - } - - isFirstCreate = false; - } - - private void closeCurrentTag(String text, int line, int col) { - try { - XMLLexer lexer = new XMLLexer(CharStreams.fromReader(new StringReader(text))); - Token token; - boolean wasSlash = false, wasOpen = false; - ArrayList currentNames = new ArrayList<>(); - while (((token = lexer.nextToken()) != null && token.getType() != token.EOF)) { - final int type = token.getType(); - if (type == XMLLexer.OPEN) { - wasOpen = true; - } else if (type == XMLLexer.Name) { - if (wasOpen && wasSlash && currentNames.size() > 0) { - currentNames.remove(0); - } else if (wasOpen) { - currentNames.add(0, token.getText()); - wasOpen = false; - } - } else if (type == XMLLexer.OPEN_SLASH) { - int l = token.getLine() - 1; - int c = token.getCharPositionInLine(); - if (l == line && c == col) { - break; - } else if (currentNames.size() > 0) { - currentNames.remove(0); - } - } else if (type == XMLLexer.SLASH_CLOSE || type == XMLLexer.SPECIAL_CLOSE) { - if (currentNames.size() > 0 && token.getText().trim().endsWith("/>")) { - currentNames.remove(0); - } - } else if (type == XMLLexer.SLASH) { - wasSlash = true; - } else { - wasOpen = wasSlash = false; - } - } - - if (currentNames.size() > 0) { - binding.editor.getText().insert(line, col + 2, currentNames.get(0)); - } - } catch (Throwable th) { - LOG.error("Unable to close current tag", th); - } - } - - private void notifySaved() { - binding.editor.didSave(); - - if (Objects.requireNonNull(getFile()).getName().endsWith(".xml")) { - ValuesTableFactory.syncWithFile(getFile()); - } - } - - /** Mark this files as saved. Even if it not saved. */ - public void markAsSaved() { - isModified = false; - notifySaved(); - } } diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Lexer.g4 b/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Lexer.g4 new file mode 100644 index 000000000..860e6d20c --- /dev/null +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Lexer.g4 @@ -0,0 +1,409 @@ +lexer grammar CPP14Lexer; + +IntegerLiteral: + DecimalLiteral Integersuffix? + | OctalLiteral Integersuffix? + | HexadecimalLiteral Integersuffix? + | BinaryLiteral Integersuffix?; + +CharacterLiteral: + ('u' | 'U' | 'L')? '\'' Cchar+ '\''; + +FloatingLiteral: + Fractionalconstant Exponentpart? Floatingsuffix? + | Digitsequence Exponentpart Floatingsuffix?; + +StringLiteral: + Encodingprefix? + (Rawstring + |'"' Schar* '"'); + +BooleanLiteral: False_ | True_; + +PointerLiteral: Nullptr; + +UserDefinedLiteral: + UserDefinedIntegerLiteral + | UserDefinedFloatingLiteral + | UserDefinedStringLiteral + | UserDefinedCharacterLiteral; + +MultiLineMacro: + '#' (~[\n]*? '\\' '\r'? '\n')+ ~ [\n]+ -> channel (HIDDEN); + +Directive: '#' ~ [\n]* -> channel (HIDDEN); +/*Keywords*/ + +Alignas: 'alignas'; + +Alignof: 'alignof'; + +Asm: 'asm'; + +Auto: 'auto'; + +Bool: 'bool'; + +Break: 'break'; + +Case: 'case'; + +Catch: 'catch'; + +Char: 'char'; + +Char16: 'char16_t'; + +Char32: 'char32_t'; + +Class: 'class'; + +Const: 'const'; + +Constexpr: 'constexpr'; + +Const_cast: 'const_cast'; + +Continue: 'continue'; + +Decltype: 'decltype'; + +Default: 'default'; + +Delete: 'delete'; + +Do: 'do'; + +Double: 'double'; + +Dynamic_cast: 'dynamic_cast'; + +Else: 'else'; + +Enum: 'enum'; + +Explicit: 'explicit'; + +Export: 'export'; + +Extern: 'extern'; + +//DO NOT RENAME - PYTHON NEEDS True and False +False_: 'false'; + +Final: 'final'; + +Float: 'float'; + +For: 'for'; + +Friend: 'friend'; + +Goto: 'goto'; + +If: 'if'; + +Inline: 'inline'; + +Int: 'int'; + +Long: 'long'; + +Mutable: 'mutable'; + +Namespace: 'namespace'; + +New: 'new'; + +Noexcept: 'noexcept'; + +Nullptr: 'nullptr'; + +Operator: 'operator'; + +Override: 'override'; + +Private: 'private'; + +Protected: 'protected'; + +Public: 'public'; + +Register: 'register'; + +Reinterpret_cast: 'reinterpret_cast'; + +Return: 'return'; + +Short: 'short'; + +Signed: 'signed'; + +Sizeof: 'sizeof'; + +Static: 'static'; + +Static_assert: 'static_assert'; + +Static_cast: 'static_cast'; + +Struct: 'struct'; + +Switch: 'switch'; + +Template: 'template'; + +This: 'this'; + +Thread_local: 'thread_local'; + +Throw: 'throw'; + +//DO NOT RENAME - PYTHON NEEDS True and False +True_: 'true'; + +Try: 'try'; + +Typedef: 'typedef'; + +Typeid_: 'typeid'; + +Typename_: 'typename'; + +Union: 'union'; + +Unsigned: 'unsigned'; + +Using: 'using'; + +Virtual: 'virtual'; + +Void: 'void'; + +Volatile: 'volatile'; + +Wchar: 'wchar_t'; + +While: 'while'; +/*Operators*/ + +LeftParen: '('; + +RightParen: ')'; + +LeftBracket: '['; + +RightBracket: ']'; + +LeftBrace: '{'; + +RightBrace: '}'; + +Plus: '+'; + +Minus: '-'; + +Star: '*'; + +Div: '/'; + +Mod: '%'; + +Caret: '^'; + +And: '&'; + +Or: '|'; + +Tilde: '~'; + +Not: '!' | 'not'; + +Assign: '='; + +Less: '<'; + +Greater: '>'; + +PlusAssign: '+='; + +MinusAssign: '-='; + +StarAssign: '*='; + +DivAssign: '/='; + +ModAssign: '%='; + +XorAssign: '^='; + +AndAssign: '&='; + +OrAssign: '|='; + +LeftShiftAssign: '<<='; + +RightShiftAssign: '>>='; + +Equal: '=='; + +NotEqual: '!='; + +LessEqual: '<='; + +GreaterEqual: '>='; + +AndAnd: '&&' | 'and'; + +OrOr: '||' | 'or'; + +PlusPlus: '++'; + +MinusMinus: '--'; + +Comma: ','; + +ArrowStar: '->*'; + +Arrow: '->'; + +Question: '?'; + +Colon: ':'; + +Doublecolon: '::'; + +Semi: ';'; + +Dot: '.'; + +DotStar: '.*'; + +Ellipsis: '...'; + +fragment Hexquad: + HEXADECIMALDIGIT HEXADECIMALDIGIT HEXADECIMALDIGIT HEXADECIMALDIGIT; + +fragment Universalcharactername: + '\\u' Hexquad + | '\\U' Hexquad Hexquad; + +Identifier: + /* + Identifiernondigit | Identifier Identifiernondigit | Identifier DIGIT + */ + Identifiernondigit (Identifiernondigit | DIGIT)*; + +fragment Identifiernondigit: NONDIGIT | Universalcharactername; + +fragment NONDIGIT: [a-zA-Z_]; + +fragment DIGIT: [0-9]; + +DecimalLiteral: NONZERODIGIT ('\''? DIGIT)*; + +OctalLiteral: '0' ('\''? OCTALDIGIT)*; + +HexadecimalLiteral: ('0x' | '0X') HEXADECIMALDIGIT ( + '\''? HEXADECIMALDIGIT + )*; + +BinaryLiteral: ('0b' | '0B') BINARYDIGIT ('\''? BINARYDIGIT)*; + +fragment NONZERODIGIT: [1-9]; + +fragment OCTALDIGIT: [0-7]; + +fragment HEXADECIMALDIGIT: [0-9a-fA-F]; + +fragment BINARYDIGIT: [01]; + +Integersuffix: + Unsignedsuffix Longsuffix? + | Unsignedsuffix Longlongsuffix? + | Longsuffix Unsignedsuffix? + | Longlongsuffix Unsignedsuffix?; + +fragment Unsignedsuffix: [uU]; + +fragment Longsuffix: [lL]; + +fragment Longlongsuffix: 'll' | 'LL'; + +fragment Cchar: + ~ ['\\\r\n] + | Escapesequence + | Universalcharactername; + +fragment Escapesequence: + Simpleescapesequence + | Octalescapesequence + | Hexadecimalescapesequence; + +fragment Simpleescapesequence: + '\\\'' + | '\\"' + | '\\?' + | '\\\\' + | '\\a' + | '\\b' + | '\\f' + | '\\n' + | '\\r' + | ('\\' ('\r' '\n'? | '\n')) + | '\\t' + | '\\v'; + +fragment Octalescapesequence: + '\\' OCTALDIGIT + | '\\' OCTALDIGIT OCTALDIGIT + | '\\' OCTALDIGIT OCTALDIGIT OCTALDIGIT; + +fragment Hexadecimalescapesequence: '\\x' HEXADECIMALDIGIT+; + +fragment Fractionalconstant: + Digitsequence? '.' Digitsequence + | Digitsequence '.'; + +fragment Exponentpart: + 'e' SIGN? Digitsequence + | 'E' SIGN? Digitsequence; + +fragment SIGN: [+-]; + +fragment Digitsequence: DIGIT ('\''? DIGIT)*; + +fragment Floatingsuffix: [flFL]; + +fragment Encodingprefix: 'u8' | 'u' | 'U' | 'L'; + +fragment Schar: + ~ ["\\\r\n] + | Escapesequence + | Universalcharactername; + +fragment Rawstring: 'R"' (( '\\' ["()] )|~[\r\n (])*? '(' ~[)]*? ')' (( '\\' ["()]) | ~[\r\n "])*? '"'; + +UserDefinedIntegerLiteral: + DecimalLiteral Udsuffix + | OctalLiteral Udsuffix + | HexadecimalLiteral Udsuffix + | BinaryLiteral Udsuffix; + +UserDefinedFloatingLiteral: + Fractionalconstant Exponentpart? Udsuffix + | Digitsequence Exponentpart Udsuffix; + +UserDefinedStringLiteral: StringLiteral Udsuffix; + +UserDefinedCharacterLiteral: CharacterLiteral Udsuffix; + +fragment Udsuffix: Identifier; + +Whitespace: [ \t]+ -> skip; + +Newline: ('\r' '\n'? | '\n') -> skip; + +BlockComment: '/*' .*? '*/' -> skip; + +LineComment: '//' ~ [\r\n]* -> skip; diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Lexer.interp b/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Lexer.interp new file mode 100644 index 000000000..cfd8d38c9 --- /dev/null +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Lexer.interp @@ -0,0 +1,478 @@ +token literal names: +null +null +null +null +null +null +null +null +null +null +'alignas' +'alignof' +'asm' +'auto' +'bool' +'break' +'case' +'catch' +'char' +'char16_t' +'char32_t' +'class' +'const' +'constexpr' +'const_cast' +'continue' +'decltype' +'default' +'delete' +'do' +'double' +'dynamic_cast' +'else' +'enum' +'explicit' +'export' +'extern' +'false' +'final' +'float' +'for' +'friend' +'goto' +'if' +'inline' +'int' +'long' +'mutable' +'namespace' +'new' +'noexcept' +'nullptr' +'operator' +'override' +'private' +'protected' +'public' +'register' +'reinterpret_cast' +'return' +'short' +'signed' +'sizeof' +'static' +'static_assert' +'static_cast' +'struct' +'switch' +'template' +'this' +'thread_local' +'throw' +'true' +'try' +'typedef' +'typeid' +'typename' +'union' +'unsigned' +'using' +'virtual' +'void' +'volatile' +'wchar_t' +'while' +'(' +')' +'[' +']' +'{' +'}' +'+' +'-' +'*' +'/' +'%' +'^' +'&' +'|' +'~' +null +'=' +'<' +'>' +'+=' +'-=' +'*=' +'/=' +'%=' +'^=' +'&=' +'|=' +'<<=' +'>>=' +'==' +'!=' +'<=' +'>=' +null +null +'++' +'--' +',' +'->*' +'->' +'?' +':' +'::' +';' +'.' +'.*' +'...' +null +null +null +null +null +null +null +null +null +null +null +null +null +null + +token symbolic names: +null +IntegerLiteral +CharacterLiteral +FloatingLiteral +StringLiteral +BooleanLiteral +PointerLiteral +UserDefinedLiteral +MultiLineMacro +Directive +Alignas +Alignof +Asm +Auto +Bool +Break +Case +Catch +Char +Char16 +Char32 +Class +Const +Constexpr +Const_cast +Continue +Decltype +Default +Delete +Do +Double +Dynamic_cast +Else +Enum +Explicit +Export +Extern +False_ +Final +Float +For +Friend +Goto +If +Inline +Int +Long +Mutable +Namespace +New +Noexcept +Nullptr +Operator +Override +Private +Protected +Public +Register +Reinterpret_cast +Return +Short +Signed +Sizeof +Static +Static_assert +Static_cast +Struct +Switch +Template +This +Thread_local +Throw +True_ +Try +Typedef +Typeid_ +Typename_ +Union +Unsigned +Using +Virtual +Void +Volatile +Wchar +While +LeftParen +RightParen +LeftBracket +RightBracket +LeftBrace +RightBrace +Plus +Minus +Star +Div +Mod +Caret +And +Or +Tilde +Not +Assign +Less +Greater +PlusAssign +MinusAssign +StarAssign +DivAssign +ModAssign +XorAssign +AndAssign +OrAssign +LeftShiftAssign +RightShiftAssign +Equal +NotEqual +LessEqual +GreaterEqual +AndAnd +OrOr +PlusPlus +MinusMinus +Comma +ArrowStar +Arrow +Question +Colon +Doublecolon +Semi +Dot +DotStar +Ellipsis +Identifier +DecimalLiteral +OctalLiteral +HexadecimalLiteral +BinaryLiteral +Integersuffix +UserDefinedIntegerLiteral +UserDefinedFloatingLiteral +UserDefinedStringLiteral +UserDefinedCharacterLiteral +Whitespace +Newline +BlockComment +LineComment + +rule names: +IntegerLiteral +CharacterLiteral +FloatingLiteral +StringLiteral +BooleanLiteral +PointerLiteral +UserDefinedLiteral +MultiLineMacro +Directive +Alignas +Alignof +Asm +Auto +Bool +Break +Case +Catch +Char +Char16 +Char32 +Class +Const +Constexpr +Const_cast +Continue +Decltype +Default +Delete +Do +Double +Dynamic_cast +Else +Enum +Explicit +Export +Extern +False_ +Final +Float +For +Friend +Goto +If +Inline +Int +Long +Mutable +Namespace +New +Noexcept +Nullptr +Operator +Override +Private +Protected +Public +Register +Reinterpret_cast +Return +Short +Signed +Sizeof +Static +Static_assert +Static_cast +Struct +Switch +Template +This +Thread_local +Throw +True_ +Try +Typedef +Typeid_ +Typename_ +Union +Unsigned +Using +Virtual +Void +Volatile +Wchar +While +LeftParen +RightParen +LeftBracket +RightBracket +LeftBrace +RightBrace +Plus +Minus +Star +Div +Mod +Caret +And +Or +Tilde +Not +Assign +Less +Greater +PlusAssign +MinusAssign +StarAssign +DivAssign +ModAssign +XorAssign +AndAssign +OrAssign +LeftShiftAssign +RightShiftAssign +Equal +NotEqual +LessEqual +GreaterEqual +AndAnd +OrOr +PlusPlus +MinusMinus +Comma +ArrowStar +Arrow +Question +Colon +Doublecolon +Semi +Dot +DotStar +Ellipsis +Hexquad +Universalcharactername +Identifier +Identifiernondigit +NONDIGIT +DIGIT +DecimalLiteral +OctalLiteral +HexadecimalLiteral +BinaryLiteral +NONZERODIGIT +OCTALDIGIT +HEXADECIMALDIGIT +BINARYDIGIT +Integersuffix +Unsignedsuffix +Longsuffix +Longlongsuffix +Cchar +Escapesequence +Simpleescapesequence +Octalescapesequence +Hexadecimalescapesequence +Fractionalconstant +Exponentpart +SIGN +Digitsequence +Floatingsuffix +Encodingprefix +Schar +Rawstring +UserDefinedIntegerLiteral +UserDefinedFloatingLiteral +UserDefinedStringLiteral +UserDefinedCharacterLiteral +Udsuffix +Whitespace +Newline +BlockComment +LineComment + +channel names: +DEFAULT_TOKEN_CHANNEL +HIDDEN + +mode names: +DEFAULT_MODE + +atn: +[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 2, 147, 1460, 8, 1, 4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7, 4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13, 9, 13, 4, 14, 9, 14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4, 18, 9, 18, 4, 19, 9, 19, 4, 20, 9, 20, 4, 21, 9, 21, 4, 22, 9, 22, 4, 23, 9, 23, 4, 24, 9, 24, 4, 25, 9, 25, 4, 26, 9, 26, 4, 27, 9, 27, 4, 28, 9, 28, 4, 29, 9, 29, 4, 30, 9, 30, 4, 31, 9, 31, 4, 32, 9, 32, 4, 33, 9, 33, 4, 34, 9, 34, 4, 35, 9, 35, 4, 36, 9, 36, 4, 37, 9, 37, 4, 38, 9, 38, 4, 39, 9, 39, 4, 40, 9, 40, 4, 41, 9, 41, 4, 42, 9, 42, 4, 43, 9, 43, 4, 44, 9, 44, 4, 45, 9, 45, 4, 46, 9, 46, 4, 47, 9, 47, 4, 48, 9, 48, 4, 49, 9, 49, 4, 50, 9, 50, 4, 51, 9, 51, 4, 52, 9, 52, 4, 53, 9, 53, 4, 54, 9, 54, 4, 55, 9, 55, 4, 56, 9, 56, 4, 57, 9, 57, 4, 58, 9, 58, 4, 59, 9, 59, 4, 60, 9, 60, 4, 61, 9, 61, 4, 62, 9, 62, 4, 63, 9, 63, 4, 64, 9, 64, 4, 65, 9, 65, 4, 66, 9, 66, 4, 67, 9, 67, 4, 68, 9, 68, 4, 69, 9, 69, 4, 70, 9, 70, 4, 71, 9, 71, 4, 72, 9, 72, 4, 73, 9, 73, 4, 74, 9, 74, 4, 75, 9, 75, 4, 76, 9, 76, 4, 77, 9, 77, 4, 78, 9, 78, 4, 79, 9, 79, 4, 80, 9, 80, 4, 81, 9, 81, 4, 82, 9, 82, 4, 83, 9, 83, 4, 84, 9, 84, 4, 85, 9, 85, 4, 86, 9, 86, 4, 87, 9, 87, 4, 88, 9, 88, 4, 89, 9, 89, 4, 90, 9, 90, 4, 91, 9, 91, 4, 92, 9, 92, 4, 93, 9, 93, 4, 94, 9, 94, 4, 95, 9, 95, 4, 96, 9, 96, 4, 97, 9, 97, 4, 98, 9, 98, 4, 99, 9, 99, 4, 100, 9, 100, 4, 101, 9, 101, 4, 102, 9, 102, 4, 103, 9, 103, 4, 104, 9, 104, 4, 105, 9, 105, 4, 106, 9, 106, 4, 107, 9, 107, 4, 108, 9, 108, 4, 109, 9, 109, 4, 110, 9, 110, 4, 111, 9, 111, 4, 112, 9, 112, 4, 113, 9, 113, 4, 114, 9, 114, 4, 115, 9, 115, 4, 116, 9, 116, 4, 117, 9, 117, 4, 118, 9, 118, 4, 119, 9, 119, 4, 120, 9, 120, 4, 121, 9, 121, 4, 122, 9, 122, 4, 123, 9, 123, 4, 124, 9, 124, 4, 125, 9, 125, 4, 126, 9, 126, 4, 127, 9, 127, 4, 128, 9, 128, 4, 129, 9, 129, 4, 130, 9, 130, 4, 131, 9, 131, 4, 132, 9, 132, 4, 133, 9, 133, 4, 134, 9, 134, 4, 135, 9, 135, 4, 136, 9, 136, 4, 137, 9, 137, 4, 138, 9, 138, 4, 139, 9, 139, 4, 140, 9, 140, 4, 141, 9, 141, 4, 142, 9, 142, 4, 143, 9, 143, 4, 144, 9, 144, 4, 145, 9, 145, 4, 146, 9, 146, 4, 147, 9, 147, 4, 148, 9, 148, 4, 149, 9, 149, 4, 150, 9, 150, 4, 151, 9, 151, 4, 152, 9, 152, 4, 153, 9, 153, 4, 154, 9, 154, 4, 155, 9, 155, 4, 156, 9, 156, 4, 157, 9, 157, 4, 158, 9, 158, 4, 159, 9, 159, 4, 160, 9, 160, 4, 161, 9, 161, 4, 162, 9, 162, 4, 163, 9, 163, 4, 164, 9, 164, 4, 165, 9, 165, 4, 166, 9, 166, 4, 167, 9, 167, 4, 168, 9, 168, 4, 169, 9, 169, 4, 170, 9, 170, 4, 171, 9, 171, 4, 172, 9, 172, 3, 2, 3, 2, 5, 2, 348, 10, 2, 3, 2, 3, 2, 5, 2, 352, 10, 2, 3, 2, 3, 2, 5, 2, 356, 10, 2, 3, 2, 3, 2, 5, 2, 360, 10, 2, 5, 2, 362, 10, 2, 3, 3, 5, 3, 365, 10, 3, 3, 3, 3, 3, 6, 3, 369, 10, 3, 13, 3, 14, 3, 370, 3, 3, 3, 3, 3, 4, 3, 4, 5, 4, 377, 10, 4, 3, 4, 5, 4, 380, 10, 4, 3, 4, 3, 4, 3, 4, 5, 4, 385, 10, 4, 5, 4, 387, 10, 4, 3, 5, 5, 5, 390, 10, 5, 3, 5, 3, 5, 7, 5, 394, 10, 5, 12, 5, 14, 5, 397, 11, 5, 3, 5, 3, 5, 5, 5, 401, 10, 5, 3, 5, 3, 5, 5, 5, 405, 10, 5, 3, 6, 3, 6, 5, 6, 409, 10, 6, 3, 7, 3, 7, 3, 8, 3, 8, 3, 8, 3, 8, 5, 8, 417, 10, 8, 3, 9, 3, 9, 7, 9, 421, 10, 9, 12, 9, 14, 9, 424, 11, 9, 3, 9, 3, 9, 5, 9, 428, 10, 9, 3, 9, 6, 9, 431, 10, 9, 13, 9, 14, 9, 432, 3, 9, 6, 9, 436, 10, 9, 13, 9, 14, 9, 437, 3, 9, 3, 9, 3, 10, 3, 10, 7, 10, 444, 10, 10, 12, 10, 14, 10, 447, 11, 10, 3, 10, 3, 10, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 13, 3, 13, 3, 13, 3, 13, 3, 14, 3, 14, 3, 14, 3, 14, 3, 14, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 19, 3, 19, 3, 19, 3, 19, 3, 19, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 22, 3, 22, 3, 22, 3, 22, 3, 22, 3, 22, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 24, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 26, 3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 3, 28, 3, 28, 3, 28, 3, 28, 3, 28, 3, 28, 3, 28, 3, 28, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 30, 3, 30, 3, 30, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 32, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 3, 34, 3, 34, 3, 34, 3, 34, 3, 34, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 36, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 37, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 38, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 41, 3, 41, 3, 41, 3, 41, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 42, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 44, 3, 44, 3, 44, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 46, 3, 46, 3, 46, 3, 46, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 48, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 50, 3, 50, 3, 50, 3, 50, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 52, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 57, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 59, 3, 60, 3, 60, 3, 60, 3, 60, 3, 60, 3, 60, 3, 60, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 61, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 66, 3, 67, 3, 67, 3, 67, 3, 67, 3, 67, 3, 67, 3, 67, 3, 68, 3, 68, 3, 68, 3, 68, 3, 68, 3, 68, 3, 68, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 69, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 71, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 73, 3, 73, 3, 73, 3, 73, 3, 73, 3, 74, 3, 74, 3, 74, 3, 74, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 75, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 77, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 80, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 82, 3, 82, 3, 82, 3, 82, 3, 82, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 83, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 85, 3, 86, 3, 86, 3, 87, 3, 87, 3, 88, 3, 88, 3, 89, 3, 89, 3, 90, 3, 90, 3, 91, 3, 91, 3, 92, 3, 92, 3, 93, 3, 93, 3, 94, 3, 94, 3, 95, 3, 95, 3, 96, 3, 96, 3, 97, 3, 97, 3, 98, 3, 98, 3, 99, 3, 99, 3, 100, 3, 100, 3, 101, 3, 101, 3, 101, 3, 101, 5, 101, 1035, 10, 101, 3, 102, 3, 102, 3, 103, 3, 103, 3, 104, 3, 104, 3, 105, 3, 105, 3, 105, 3, 106, 3, 106, 3, 106, 3, 107, 3, 107, 3, 107, 3, 108, 3, 108, 3, 108, 3, 109, 3, 109, 3, 109, 3, 110, 3, 110, 3, 110, 3, 111, 3, 111, 3, 111, 3, 112, 3, 112, 3, 112, 3, 113, 3, 113, 3, 113, 3, 113, 3, 114, 3, 114, 3, 114, 3, 114, 3, 115, 3, 115, 3, 115, 3, 116, 3, 116, 3, 116, 3, 117, 3, 117, 3, 117, 3, 118, 3, 118, 3, 118, 3, 119, 3, 119, 3, 119, 3, 119, 3, 119, 5, 119, 1092, 10, 119, 3, 120, 3, 120, 3, 120, 3, 120, 5, 120, 1098, 10, 120, 3, 121, 3, 121, 3, 121, 3, 122, 3, 122, 3, 122, 3, 123, 3, 123, 3, 124, 3, 124, 3, 124, 3, 124, 3, 125, 3, 125, 3, 125, 3, 126, 3, 126, 3, 127, 3, 127, 3, 128, 3, 128, 3, 128, 3, 129, 3, 129, 3, 130, 3, 130, 3, 131, 3, 131, 3, 131, 3, 132, 3, 132, 3, 132, 3, 132, 3, 133, 3, 133, 3, 133, 3, 133, 3, 133, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 5, 134, 1148, 10, 134, 3, 135, 3, 135, 3, 135, 7, 135, 1153, 10, 135, 12, 135, 14, 135, 1156, 11, 135, 3, 136, 3, 136, 5, 136, 1160, 10, 136, 3, 137, 3, 137, 3, 138, 3, 138, 3, 139, 3, 139, 5, 139, 1168, 10, 139, 3, 139, 7, 139, 1171, 10, 139, 12, 139, 14, 139, 1174, 11, 139, 3, 140, 3, 140, 5, 140, 1178, 10, 140, 3, 140, 7, 140, 1181, 10, 140, 12, 140, 14, 140, 1184, 11, 140, 3, 141, 3, 141, 3, 141, 3, 141, 5, 141, 1190, 10, 141, 3, 141, 3, 141, 5, 141, 1194, 10, 141, 3, 141, 7, 141, 1197, 10, 141, 12, 141, 14, 141, 1200, 11, 141, 3, 142, 3, 142, 3, 142, 3, 142, 5, 142, 1206, 10, 142, 3, 142, 3, 142, 5, 142, 1210, 10, 142, 3, 142, 7, 142, 1213, 10, 142, 12, 142, 14, 142, 1216, 11, 142, 3, 143, 3, 143, 3, 144, 3, 144, 3, 145, 3, 145, 3, 146, 3, 146, 3, 147, 3, 147, 5, 147, 1228, 10, 147, 3, 147, 3, 147, 5, 147, 1232, 10, 147, 3, 147, 3, 147, 5, 147, 1236, 10, 147, 3, 147, 3, 147, 5, 147, 1240, 10, 147, 5, 147, 1242, 10, 147, 3, 148, 3, 148, 3, 149, 3, 149, 3, 150, 3, 150, 3, 150, 3, 150, 5, 150, 1252, 10, 150, 3, 151, 3, 151, 3, 151, 5, 151, 1257, 10, 151, 3, 152, 3, 152, 3, 152, 5, 152, 1262, 10, 152, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 3, 153, 5, 153, 1285, 10, 153, 3, 153, 5, 153, 1288, 10, 153, 3, 153, 3, 153, 3, 153, 3, 153, 5, 153, 1294, 10, 153, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 3, 154, 5, 154, 1307, 10, 154, 3, 155, 3, 155, 3, 155, 3, 155, 6, 155, 1313, 10, 155, 13, 155, 14, 155, 1314, 3, 156, 5, 156, 1318, 10, 156, 3, 156, 3, 156, 3, 156, 3, 156, 3, 156, 5, 156, 1325, 10, 156, 3, 157, 3, 157, 5, 157, 1329, 10, 157, 3, 157, 3, 157, 3, 157, 5, 157, 1334, 10, 157, 3, 157, 5, 157, 1337, 10, 157, 3, 158, 3, 158, 3, 159, 3, 159, 5, 159, 1343, 10, 159, 3, 159, 7, 159, 1346, 10, 159, 12, 159, 14, 159, 1349, 11, 159, 3, 160, 3, 160, 3, 161, 3, 161, 3, 161, 5, 161, 1356, 10, 161, 3, 162, 3, 162, 3, 162, 5, 162, 1361, 10, 162, 3, 163, 3, 163, 7, 163, 1365, 10, 163, 12, 163, 14, 163, 1368, 11, 163, 3, 163, 3, 163, 7, 163, 1372, 10, 163, 12, 163, 14, 163, 1375, 11, 163, 3, 163, 3, 163, 7, 163, 1379, 10, 163, 12, 163, 14, 163, 1382, 11, 163, 3, 163, 3, 163, 3, 164, 3, 164, 3, 164, 3, 164, 3, 164, 3, 164, 3, 164, 3, 164, 3, 164, 3, 164, 3, 164, 3, 164, 5, 164, 1398, 10, 164, 3, 165, 3, 165, 5, 165, 1402, 10, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 5, 165, 1410, 10, 165, 3, 166, 3, 166, 3, 166, 3, 167, 3, 167, 3, 167, 3, 168, 3, 168, 3, 169, 6, 169, 1421, 10, 169, 13, 169, 14, 169, 1422, 3, 169, 3, 169, 3, 170, 3, 170, 5, 170, 1429, 10, 170, 3, 170, 5, 170, 1432, 10, 170, 3, 170, 3, 170, 3, 171, 3, 171, 3, 171, 3, 171, 7, 171, 1440, 10, 171, 12, 171, 14, 171, 1443, 11, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 172, 3, 172, 3, 172, 3, 172, 7, 172, 1454, 10, 172, 12, 172, 14, 172, 1457, 11, 172, 3, 172, 3, 172, 4, 422, 1441, 2, 173, 3, 3, 5, 4, 7, 5, 9, 6, 11, 7, 13, 8, 15, 9, 17, 10, 19, 11, 21, 12, 23, 13, 25, 14, 27, 15, 29, 16, 31, 17, 33, 18, 35, 19, 37, 20, 39, 21, 41, 22, 43, 23, 45, 24, 47, 25, 49, 26, 51, 27, 53, 28, 55, 29, 57, 30, 59, 31, 61, 32, 63, 33, 65, 34, 67, 35, 69, 36, 71, 37, 73, 38, 75, 39, 77, 40, 79, 41, 81, 42, 83, 43, 85, 44, 87, 45, 89, 46, 91, 47, 93, 48, 95, 49, 97, 50, 99, 51, 101, 52, 103, 53, 105, 54, 107, 55, 109, 56, 111, 57, 113, 58, 115, 59, 117, 60, 119, 61, 121, 62, 123, 63, 125, 64, 127, 65, 129, 66, 131, 67, 133, 68, 135, 69, 137, 70, 139, 71, 141, 72, 143, 73, 145, 74, 147, 75, 149, 76, 151, 77, 153, 78, 155, 79, 157, 80, 159, 81, 161, 82, 163, 83, 165, 84, 167, 85, 169, 86, 171, 87, 173, 88, 175, 89, 177, 90, 179, 91, 181, 92, 183, 93, 185, 94, 187, 95, 189, 96, 191, 97, 193, 98, 195, 99, 197, 100, 199, 101, 201, 102, 203, 103, 205, 104, 207, 105, 209, 106, 211, 107, 213, 108, 215, 109, 217, 110, 219, 111, 221, 112, 223, 113, 225, 114, 227, 115, 229, 116, 231, 117, 233, 118, 235, 119, 237, 120, 239, 121, 241, 122, 243, 123, 245, 124, 247, 125, 249, 126, 251, 127, 253, 128, 255, 129, 257, 130, 259, 131, 261, 132, 263, 133, 265, 2, 267, 2, 269, 134, 271, 2, 273, 2, 275, 2, 277, 135, 279, 136, 281, 137, 283, 138, 285, 2, 287, 2, 289, 2, 291, 2, 293, 139, 295, 2, 297, 2, 299, 2, 301, 2, 303, 2, 305, 2, 307, 2, 309, 2, 311, 2, 313, 2, 315, 2, 317, 2, 319, 2, 321, 2, 323, 2, 325, 2, 327, 140, 329, 141, 331, 142, 333, 143, 335, 2, 337, 144, 339, 145, 341, 146, 343, 147, 3, 2, 21, 5, 2, 78, 78, 87, 87, 119, 119, 3, 2, 12, 12, 5, 2, 67, 92, 97, 97, 99, 124, 3, 2, 50, 59, 3, 2, 51, 59, 3, 2, 50, 57, 5, 2, 50, 59, 67, 72, 99, 104, 3, 2, 50, 51, 4, 2, 87, 87, 119, 119, 4, 2, 78, 78, 110, 110, 6, 2, 12, 12, 15, 15, 41, 41, 94, 94, 4, 2, 45, 45, 47, 47, 6, 2, 72, 72, 78, 78, 104, 104, 110, 110, 6, 2, 12, 12, 15, 15, 36, 36, 94, 94, 5, 2, 12, 12, 15, 15, 42, 42, 5, 2, 12, 12, 15, 15, 43, 43, 5, 2, 12, 12, 15, 15, 36, 36, 4, 2, 11, 11, 34, 34, 4, 2, 12, 12, 15, 15, 2, 1527, 2, 3, 3, 2, 2, 2, 2, 5, 3, 2, 2, 2, 2, 7, 3, 2, 2, 2, 2, 9, 3, 2, 2, 2, 2, 11, 3, 2, 2, 2, 2, 13, 3, 2, 2, 2, 2, 15, 3, 2, 2, 2, 2, 17, 3, 2, 2, 2, 2, 19, 3, 2, 2, 2, 2, 21, 3, 2, 2, 2, 2, 23, 3, 2, 2, 2, 2, 25, 3, 2, 2, 2, 2, 27, 3, 2, 2, 2, 2, 29, 3, 2, 2, 2, 2, 31, 3, 2, 2, 2, 2, 33, 3, 2, 2, 2, 2, 35, 3, 2, 2, 2, 2, 37, 3, 2, 2, 2, 2, 39, 3, 2, 2, 2, 2, 41, 3, 2, 2, 2, 2, 43, 3, 2, 2, 2, 2, 45, 3, 2, 2, 2, 2, 47, 3, 2, 2, 2, 2, 49, 3, 2, 2, 2, 2, 51, 3, 2, 2, 2, 2, 53, 3, 2, 2, 2, 2, 55, 3, 2, 2, 2, 2, 57, 3, 2, 2, 2, 2, 59, 3, 2, 2, 2, 2, 61, 3, 2, 2, 2, 2, 63, 3, 2, 2, 2, 2, 65, 3, 2, 2, 2, 2, 67, 3, 2, 2, 2, 2, 69, 3, 2, 2, 2, 2, 71, 3, 2, 2, 2, 2, 73, 3, 2, 2, 2, 2, 75, 3, 2, 2, 2, 2, 77, 3, 2, 2, 2, 2, 79, 3, 2, 2, 2, 2, 81, 3, 2, 2, 2, 2, 83, 3, 2, 2, 2, 2, 85, 3, 2, 2, 2, 2, 87, 3, 2, 2, 2, 2, 89, 3, 2, 2, 2, 2, 91, 3, 2, 2, 2, 2, 93, 3, 2, 2, 2, 2, 95, 3, 2, 2, 2, 2, 97, 3, 2, 2, 2, 2, 99, 3, 2, 2, 2, 2, 101, 3, 2, 2, 2, 2, 103, 3, 2, 2, 2, 2, 105, 3, 2, 2, 2, 2, 107, 3, 2, 2, 2, 2, 109, 3, 2, 2, 2, 2, 111, 3, 2, 2, 2, 2, 113, 3, 2, 2, 2, 2, 115, 3, 2, 2, 2, 2, 117, 3, 2, 2, 2, 2, 119, 3, 2, 2, 2, 2, 121, 3, 2, 2, 2, 2, 123, 3, 2, 2, 2, 2, 125, 3, 2, 2, 2, 2, 127, 3, 2, 2, 2, 2, 129, 3, 2, 2, 2, 2, 131, 3, 2, 2, 2, 2, 133, 3, 2, 2, 2, 2, 135, 3, 2, 2, 2, 2, 137, 3, 2, 2, 2, 2, 139, 3, 2, 2, 2, 2, 141, 3, 2, 2, 2, 2, 143, 3, 2, 2, 2, 2, 145, 3, 2, 2, 2, 2, 147, 3, 2, 2, 2, 2, 149, 3, 2, 2, 2, 2, 151, 3, 2, 2, 2, 2, 153, 3, 2, 2, 2, 2, 155, 3, 2, 2, 2, 2, 157, 3, 2, 2, 2, 2, 159, 3, 2, 2, 2, 2, 161, 3, 2, 2, 2, 2, 163, 3, 2, 2, 2, 2, 165, 3, 2, 2, 2, 2, 167, 3, 2, 2, 2, 2, 169, 3, 2, 2, 2, 2, 171, 3, 2, 2, 2, 2, 173, 3, 2, 2, 2, 2, 175, 3, 2, 2, 2, 2, 177, 3, 2, 2, 2, 2, 179, 3, 2, 2, 2, 2, 181, 3, 2, 2, 2, 2, 183, 3, 2, 2, 2, 2, 185, 3, 2, 2, 2, 2, 187, 3, 2, 2, 2, 2, 189, 3, 2, 2, 2, 2, 191, 3, 2, 2, 2, 2, 193, 3, 2, 2, 2, 2, 195, 3, 2, 2, 2, 2, 197, 3, 2, 2, 2, 2, 199, 3, 2, 2, 2, 2, 201, 3, 2, 2, 2, 2, 203, 3, 2, 2, 2, 2, 205, 3, 2, 2, 2, 2, 207, 3, 2, 2, 2, 2, 209, 3, 2, 2, 2, 2, 211, 3, 2, 2, 2, 2, 213, 3, 2, 2, 2, 2, 215, 3, 2, 2, 2, 2, 217, 3, 2, 2, 2, 2, 219, 3, 2, 2, 2, 2, 221, 3, 2, 2, 2, 2, 223, 3, 2, 2, 2, 2, 225, 3, 2, 2, 2, 2, 227, 3, 2, 2, 2, 2, 229, 3, 2, 2, 2, 2, 231, 3, 2, 2, 2, 2, 233, 3, 2, 2, 2, 2, 235, 3, 2, 2, 2, 2, 237, 3, 2, 2, 2, 2, 239, 3, 2, 2, 2, 2, 241, 3, 2, 2, 2, 2, 243, 3, 2, 2, 2, 2, 245, 3, 2, 2, 2, 2, 247, 3, 2, 2, 2, 2, 249, 3, 2, 2, 2, 2, 251, 3, 2, 2, 2, 2, 253, 3, 2, 2, 2, 2, 255, 3, 2, 2, 2, 2, 257, 3, 2, 2, 2, 2, 259, 3, 2, 2, 2, 2, 261, 3, 2, 2, 2, 2, 263, 3, 2, 2, 2, 2, 269, 3, 2, 2, 2, 2, 277, 3, 2, 2, 2, 2, 279, 3, 2, 2, 2, 2, 281, 3, 2, 2, 2, 2, 283, 3, 2, 2, 2, 2, 293, 3, 2, 2, 2, 2, 327, 3, 2, 2, 2, 2, 329, 3, 2, 2, 2, 2, 331, 3, 2, 2, 2, 2, 333, 3, 2, 2, 2, 2, 337, 3, 2, 2, 2, 2, 339, 3, 2, 2, 2, 2, 341, 3, 2, 2, 2, 2, 343, 3, 2, 2, 2, 3, 361, 3, 2, 2, 2, 5, 364, 3, 2, 2, 2, 7, 386, 3, 2, 2, 2, 9, 404, 3, 2, 2, 2, 11, 408, 3, 2, 2, 2, 13, 410, 3, 2, 2, 2, 15, 416, 3, 2, 2, 2, 17, 418, 3, 2, 2, 2, 19, 441, 3, 2, 2, 2, 21, 450, 3, 2, 2, 2, 23, 458, 3, 2, 2, 2, 25, 466, 3, 2, 2, 2, 27, 470, 3, 2, 2, 2, 29, 475, 3, 2, 2, 2, 31, 480, 3, 2, 2, 2, 33, 486, 3, 2, 2, 2, 35, 491, 3, 2, 2, 2, 37, 497, 3, 2, 2, 2, 39, 502, 3, 2, 2, 2, 41, 511, 3, 2, 2, 2, 43, 520, 3, 2, 2, 2, 45, 526, 3, 2, 2, 2, 47, 532, 3, 2, 2, 2, 49, 542, 3, 2, 2, 2, 51, 553, 3, 2, 2, 2, 53, 562, 3, 2, 2, 2, 55, 571, 3, 2, 2, 2, 57, 579, 3, 2, 2, 2, 59, 586, 3, 2, 2, 2, 61, 589, 3, 2, 2, 2, 63, 596, 3, 2, 2, 2, 65, 609, 3, 2, 2, 2, 67, 614, 3, 2, 2, 2, 69, 619, 3, 2, 2, 2, 71, 628, 3, 2, 2, 2, 73, 635, 3, 2, 2, 2, 75, 642, 3, 2, 2, 2, 77, 648, 3, 2, 2, 2, 79, 654, 3, 2, 2, 2, 81, 660, 3, 2, 2, 2, 83, 664, 3, 2, 2, 2, 85, 671, 3, 2, 2, 2, 87, 676, 3, 2, 2, 2, 89, 679, 3, 2, 2, 2, 91, 686, 3, 2, 2, 2, 93, 690, 3, 2, 2, 2, 95, 695, 3, 2, 2, 2, 97, 703, 3, 2, 2, 2, 99, 713, 3, 2, 2, 2, 101, 717, 3, 2, 2, 2, 103, 726, 3, 2, 2, 2, 105, 734, 3, 2, 2, 2, 107, 743, 3, 2, 2, 2, 109, 752, 3, 2, 2, 2, 111, 760, 3, 2, 2, 2, 113, 770, 3, 2, 2, 2, 115, 777, 3, 2, 2, 2, 117, 786, 3, 2, 2, 2, 119, 803, 3, 2, 2, 2, 121, 810, 3, 2, 2, 2, 123, 816, 3, 2, 2, 2, 125, 823, 3, 2, 2, 2, 127, 830, 3, 2, 2, 2, 129, 837, 3, 2, 2, 2, 131, 851, 3, 2, 2, 2, 133, 863, 3, 2, 2, 2, 135, 870, 3, 2, 2, 2, 137, 877, 3, 2, 2, 2, 139, 886, 3, 2, 2, 2, 141, 891, 3, 2, 2, 2, 143, 904, 3, 2, 2, 2, 145, 910, 3, 2, 2, 2, 147, 915, 3, 2, 2, 2, 149, 919, 3, 2, 2, 2, 151, 927, 3, 2, 2, 2, 153, 934, 3, 2, 2, 2, 155, 943, 3, 2, 2, 2, 157, 949, 3, 2, 2, 2, 159, 958, 3, 2, 2, 2, 161, 964, 3, 2, 2, 2, 163, 972, 3, 2, 2, 2, 165, 977, 3, 2, 2, 2, 167, 986, 3, 2, 2, 2, 169, 994, 3, 2, 2, 2, 171, 1000, 3, 2, 2, 2, 173, 1002, 3, 2, 2, 2, 175, 1004, 3, 2, 2, 2, 177, 1006, 3, 2, 2, 2, 179, 1008, 3, 2, 2, 2, 181, 1010, 3, 2, 2, 2, 183, 1012, 3, 2, 2, 2, 185, 1014, 3, 2, 2, 2, 187, 1016, 3, 2, 2, 2, 189, 1018, 3, 2, 2, 2, 191, 1020, 3, 2, 2, 2, 193, 1022, 3, 2, 2, 2, 195, 1024, 3, 2, 2, 2, 197, 1026, 3, 2, 2, 2, 199, 1028, 3, 2, 2, 2, 201, 1034, 3, 2, 2, 2, 203, 1036, 3, 2, 2, 2, 205, 1038, 3, 2, 2, 2, 207, 1040, 3, 2, 2, 2, 209, 1042, 3, 2, 2, 2, 211, 1045, 3, 2, 2, 2, 213, 1048, 3, 2, 2, 2, 215, 1051, 3, 2, 2, 2, 217, 1054, 3, 2, 2, 2, 219, 1057, 3, 2, 2, 2, 221, 1060, 3, 2, 2, 2, 223, 1063, 3, 2, 2, 2, 225, 1066, 3, 2, 2, 2, 227, 1070, 3, 2, 2, 2, 229, 1074, 3, 2, 2, 2, 231, 1077, 3, 2, 2, 2, 233, 1080, 3, 2, 2, 2, 235, 1083, 3, 2, 2, 2, 237, 1091, 3, 2, 2, 2, 239, 1097, 3, 2, 2, 2, 241, 1099, 3, 2, 2, 2, 243, 1102, 3, 2, 2, 2, 245, 1105, 3, 2, 2, 2, 247, 1107, 3, 2, 2, 2, 249, 1111, 3, 2, 2, 2, 251, 1114, 3, 2, 2, 2, 253, 1116, 3, 2, 2, 2, 255, 1118, 3, 2, 2, 2, 257, 1121, 3, 2, 2, 2, 259, 1123, 3, 2, 2, 2, 261, 1125, 3, 2, 2, 2, 263, 1128, 3, 2, 2, 2, 265, 1132, 3, 2, 2, 2, 267, 1147, 3, 2, 2, 2, 269, 1149, 3, 2, 2, 2, 271, 1159, 3, 2, 2, 2, 273, 1161, 3, 2, 2, 2, 275, 1163, 3, 2, 2, 2, 277, 1165, 3, 2, 2, 2, 279, 1175, 3, 2, 2, 2, 281, 1189, 3, 2, 2, 2, 283, 1205, 3, 2, 2, 2, 285, 1217, 3, 2, 2, 2, 287, 1219, 3, 2, 2, 2, 289, 1221, 3, 2, 2, 2, 291, 1223, 3, 2, 2, 2, 293, 1241, 3, 2, 2, 2, 295, 1243, 3, 2, 2, 2, 297, 1245, 3, 2, 2, 2, 299, 1251, 3, 2, 2, 2, 301, 1256, 3, 2, 2, 2, 303, 1261, 3, 2, 2, 2, 305, 1293, 3, 2, 2, 2, 307, 1306, 3, 2, 2, 2, 309, 1308, 3, 2, 2, 2, 311, 1324, 3, 2, 2, 2, 313, 1336, 3, 2, 2, 2, 315, 1338, 3, 2, 2, 2, 317, 1340, 3, 2, 2, 2, 319, 1350, 3, 2, 2, 2, 321, 1355, 3, 2, 2, 2, 323, 1360, 3, 2, 2, 2, 325, 1362, 3, 2, 2, 2, 327, 1397, 3, 2, 2, 2, 329, 1409, 3, 2, 2, 2, 331, 1411, 3, 2, 2, 2, 333, 1414, 3, 2, 2, 2, 335, 1417, 3, 2, 2, 2, 337, 1420, 3, 2, 2, 2, 339, 1431, 3, 2, 2, 2, 341, 1435, 3, 2, 2, 2, 343, 1449, 3, 2, 2, 2, 345, 347, 5, 277, 139, 2, 346, 348, 5, 293, 147, 2, 347, 346, 3, 2, 2, 2, 347, 348, 3, 2, 2, 2, 348, 362, 3, 2, 2, 2, 349, 351, 5, 279, 140, 2, 350, 352, 5, 293, 147, 2, 351, 350, 3, 2, 2, 2, 351, 352, 3, 2, 2, 2, 352, 362, 3, 2, 2, 2, 353, 355, 5, 281, 141, 2, 354, 356, 5, 293, 147, 2, 355, 354, 3, 2, 2, 2, 355, 356, 3, 2, 2, 2, 356, 362, 3, 2, 2, 2, 357, 359, 5, 283, 142, 2, 358, 360, 5, 293, 147, 2, 359, 358, 3, 2, 2, 2, 359, 360, 3, 2, 2, 2, 360, 362, 3, 2, 2, 2, 361, 345, 3, 2, 2, 2, 361, 349, 3, 2, 2, 2, 361, 353, 3, 2, 2, 2, 361, 357, 3, 2, 2, 2, 362, 4, 3, 2, 2, 2, 363, 365, 9, 2, 2, 2, 364, 363, 3, 2, 2, 2, 364, 365, 3, 2, 2, 2, 365, 366, 3, 2, 2, 2, 366, 368, 7, 41, 2, 2, 367, 369, 5, 301, 151, 2, 368, 367, 3, 2, 2, 2, 369, 370, 3, 2, 2, 2, 370, 368, 3, 2, 2, 2, 370, 371, 3, 2, 2, 2, 371, 372, 3, 2, 2, 2, 372, 373, 7, 41, 2, 2, 373, 6, 3, 2, 2, 2, 374, 376, 5, 311, 156, 2, 375, 377, 5, 313, 157, 2, 376, 375, 3, 2, 2, 2, 376, 377, 3, 2, 2, 2, 377, 379, 3, 2, 2, 2, 378, 380, 5, 319, 160, 2, 379, 378, 3, 2, 2, 2, 379, 380, 3, 2, 2, 2, 380, 387, 3, 2, 2, 2, 381, 382, 5, 317, 159, 2, 382, 384, 5, 313, 157, 2, 383, 385, 5, 319, 160, 2, 384, 383, 3, 2, 2, 2, 384, 385, 3, 2, 2, 2, 385, 387, 3, 2, 2, 2, 386, 374, 3, 2, 2, 2, 386, 381, 3, 2, 2, 2, 387, 8, 3, 2, 2, 2, 388, 390, 5, 321, 161, 2, 389, 388, 3, 2, 2, 2, 389, 390, 3, 2, 2, 2, 390, 391, 3, 2, 2, 2, 391, 395, 7, 36, 2, 2, 392, 394, 5, 323, 162, 2, 393, 392, 3, 2, 2, 2, 394, 397, 3, 2, 2, 2, 395, 393, 3, 2, 2, 2, 395, 396, 3, 2, 2, 2, 396, 398, 3, 2, 2, 2, 397, 395, 3, 2, 2, 2, 398, 405, 7, 36, 2, 2, 399, 401, 5, 321, 161, 2, 400, 399, 3, 2, 2, 2, 400, 401, 3, 2, 2, 2, 401, 402, 3, 2, 2, 2, 402, 403, 7, 84, 2, 2, 403, 405, 5, 325, 163, 2, 404, 389, 3, 2, 2, 2, 404, 400, 3, 2, 2, 2, 405, 10, 3, 2, 2, 2, 406, 409, 5, 75, 38, 2, 407, 409, 5, 145, 73, 2, 408, 406, 3, 2, 2, 2, 408, 407, 3, 2, 2, 2, 409, 12, 3, 2, 2, 2, 410, 411, 5, 103, 52, 2, 411, 14, 3, 2, 2, 2, 412, 417, 5, 327, 164, 2, 413, 417, 5, 329, 165, 2, 414, 417, 5, 331, 166, 2, 415, 417, 5, 333, 167, 2, 416, 412, 3, 2, 2, 2, 416, 413, 3, 2, 2, 2, 416, 414, 3, 2, 2, 2, 416, 415, 3, 2, 2, 2, 417, 16, 3, 2, 2, 2, 418, 430, 7, 37, 2, 2, 419, 421, 10, 3, 2, 2, 420, 419, 3, 2, 2, 2, 421, 424, 3, 2, 2, 2, 422, 423, 3, 2, 2, 2, 422, 420, 3, 2, 2, 2, 423, 425, 3, 2, 2, 2, 424, 422, 3, 2, 2, 2, 425, 427, 7, 94, 2, 2, 426, 428, 7, 15, 2, 2, 427, 426, 3, 2, 2, 2, 427, 428, 3, 2, 2, 2, 428, 429, 3, 2, 2, 2, 429, 431, 7, 12, 2, 2, 430, 422, 3, 2, 2, 2, 431, 432, 3, 2, 2, 2, 432, 430, 3, 2, 2, 2, 432, 433, 3, 2, 2, 2, 433, 435, 3, 2, 2, 2, 434, 436, 10, 3, 2, 2, 435, 434, 3, 2, 2, 2, 436, 437, 3, 2, 2, 2, 437, 435, 3, 2, 2, 2, 437, 438, 3, 2, 2, 2, 438, 439, 3, 2, 2, 2, 439, 440, 8, 9, 2, 2, 440, 18, 3, 2, 2, 2, 441, 445, 7, 37, 2, 2, 442, 444, 10, 3, 2, 2, 443, 442, 3, 2, 2, 2, 444, 447, 3, 2, 2, 2, 445, 443, 3, 2, 2, 2, 445, 446, 3, 2, 2, 2, 446, 448, 3, 2, 2, 2, 447, 445, 3, 2, 2, 2, 448, 449, 8, 10, 2, 2, 449, 20, 3, 2, 2, 2, 450, 451, 7, 99, 2, 2, 451, 452, 7, 110, 2, 2, 452, 453, 7, 107, 2, 2, 453, 454, 7, 105, 2, 2, 454, 455, 7, 112, 2, 2, 455, 456, 7, 99, 2, 2, 456, 457, 7, 117, 2, 2, 457, 22, 3, 2, 2, 2, 458, 459, 7, 99, 2, 2, 459, 460, 7, 110, 2, 2, 460, 461, 7, 107, 2, 2, 461, 462, 7, 105, 2, 2, 462, 463, 7, 112, 2, 2, 463, 464, 7, 113, 2, 2, 464, 465, 7, 104, 2, 2, 465, 24, 3, 2, 2, 2, 466, 467, 7, 99, 2, 2, 467, 468, 7, 117, 2, 2, 468, 469, 7, 111, 2, 2, 469, 26, 3, 2, 2, 2, 470, 471, 7, 99, 2, 2, 471, 472, 7, 119, 2, 2, 472, 473, 7, 118, 2, 2, 473, 474, 7, 113, 2, 2, 474, 28, 3, 2, 2, 2, 475, 476, 7, 100, 2, 2, 476, 477, 7, 113, 2, 2, 477, 478, 7, 113, 2, 2, 478, 479, 7, 110, 2, 2, 479, 30, 3, 2, 2, 2, 480, 481, 7, 100, 2, 2, 481, 482, 7, 116, 2, 2, 482, 483, 7, 103, 2, 2, 483, 484, 7, 99, 2, 2, 484, 485, 7, 109, 2, 2, 485, 32, 3, 2, 2, 2, 486, 487, 7, 101, 2, 2, 487, 488, 7, 99, 2, 2, 488, 489, 7, 117, 2, 2, 489, 490, 7, 103, 2, 2, 490, 34, 3, 2, 2, 2, 491, 492, 7, 101, 2, 2, 492, 493, 7, 99, 2, 2, 493, 494, 7, 118, 2, 2, 494, 495, 7, 101, 2, 2, 495, 496, 7, 106, 2, 2, 496, 36, 3, 2, 2, 2, 497, 498, 7, 101, 2, 2, 498, 499, 7, 106, 2, 2, 499, 500, 7, 99, 2, 2, 500, 501, 7, 116, 2, 2, 501, 38, 3, 2, 2, 2, 502, 503, 7, 101, 2, 2, 503, 504, 7, 106, 2, 2, 504, 505, 7, 99, 2, 2, 505, 506, 7, 116, 2, 2, 506, 507, 7, 51, 2, 2, 507, 508, 7, 56, 2, 2, 508, 509, 7, 97, 2, 2, 509, 510, 7, 118, 2, 2, 510, 40, 3, 2, 2, 2, 511, 512, 7, 101, 2, 2, 512, 513, 7, 106, 2, 2, 513, 514, 7, 99, 2, 2, 514, 515, 7, 116, 2, 2, 515, 516, 7, 53, 2, 2, 516, 517, 7, 52, 2, 2, 517, 518, 7, 97, 2, 2, 518, 519, 7, 118, 2, 2, 519, 42, 3, 2, 2, 2, 520, 521, 7, 101, 2, 2, 521, 522, 7, 110, 2, 2, 522, 523, 7, 99, 2, 2, 523, 524, 7, 117, 2, 2, 524, 525, 7, 117, 2, 2, 525, 44, 3, 2, 2, 2, 526, 527, 7, 101, 2, 2, 527, 528, 7, 113, 2, 2, 528, 529, 7, 112, 2, 2, 529, 530, 7, 117, 2, 2, 530, 531, 7, 118, 2, 2, 531, 46, 3, 2, 2, 2, 532, 533, 7, 101, 2, 2, 533, 534, 7, 113, 2, 2, 534, 535, 7, 112, 2, 2, 535, 536, 7, 117, 2, 2, 536, 537, 7, 118, 2, 2, 537, 538, 7, 103, 2, 2, 538, 539, 7, 122, 2, 2, 539, 540, 7, 114, 2, 2, 540, 541, 7, 116, 2, 2, 541, 48, 3, 2, 2, 2, 542, 543, 7, 101, 2, 2, 543, 544, 7, 113, 2, 2, 544, 545, 7, 112, 2, 2, 545, 546, 7, 117, 2, 2, 546, 547, 7, 118, 2, 2, 547, 548, 7, 97, 2, 2, 548, 549, 7, 101, 2, 2, 549, 550, 7, 99, 2, 2, 550, 551, 7, 117, 2, 2, 551, 552, 7, 118, 2, 2, 552, 50, 3, 2, 2, 2, 553, 554, 7, 101, 2, 2, 554, 555, 7, 113, 2, 2, 555, 556, 7, 112, 2, 2, 556, 557, 7, 118, 2, 2, 557, 558, 7, 107, 2, 2, 558, 559, 7, 112, 2, 2, 559, 560, 7, 119, 2, 2, 560, 561, 7, 103, 2, 2, 561, 52, 3, 2, 2, 2, 562, 563, 7, 102, 2, 2, 563, 564, 7, 103, 2, 2, 564, 565, 7, 101, 2, 2, 565, 566, 7, 110, 2, 2, 566, 567, 7, 118, 2, 2, 567, 568, 7, 123, 2, 2, 568, 569, 7, 114, 2, 2, 569, 570, 7, 103, 2, 2, 570, 54, 3, 2, 2, 2, 571, 572, 7, 102, 2, 2, 572, 573, 7, 103, 2, 2, 573, 574, 7, 104, 2, 2, 574, 575, 7, 99, 2, 2, 575, 576, 7, 119, 2, 2, 576, 577, 7, 110, 2, 2, 577, 578, 7, 118, 2, 2, 578, 56, 3, 2, 2, 2, 579, 580, 7, 102, 2, 2, 580, 581, 7, 103, 2, 2, 581, 582, 7, 110, 2, 2, 582, 583, 7, 103, 2, 2, 583, 584, 7, 118, 2, 2, 584, 585, 7, 103, 2, 2, 585, 58, 3, 2, 2, 2, 586, 587, 7, 102, 2, 2, 587, 588, 7, 113, 2, 2, 588, 60, 3, 2, 2, 2, 589, 590, 7, 102, 2, 2, 590, 591, 7, 113, 2, 2, 591, 592, 7, 119, 2, 2, 592, 593, 7, 100, 2, 2, 593, 594, 7, 110, 2, 2, 594, 595, 7, 103, 2, 2, 595, 62, 3, 2, 2, 2, 596, 597, 7, 102, 2, 2, 597, 598, 7, 123, 2, 2, 598, 599, 7, 112, 2, 2, 599, 600, 7, 99, 2, 2, 600, 601, 7, 111, 2, 2, 601, 602, 7, 107, 2, 2, 602, 603, 7, 101, 2, 2, 603, 604, 7, 97, 2, 2, 604, 605, 7, 101, 2, 2, 605, 606, 7, 99, 2, 2, 606, 607, 7, 117, 2, 2, 607, 608, 7, 118, 2, 2, 608, 64, 3, 2, 2, 2, 609, 610, 7, 103, 2, 2, 610, 611, 7, 110, 2, 2, 611, 612, 7, 117, 2, 2, 612, 613, 7, 103, 2, 2, 613, 66, 3, 2, 2, 2, 614, 615, 7, 103, 2, 2, 615, 616, 7, 112, 2, 2, 616, 617, 7, 119, 2, 2, 617, 618, 7, 111, 2, 2, 618, 68, 3, 2, 2, 2, 619, 620, 7, 103, 2, 2, 620, 621, 7, 122, 2, 2, 621, 622, 7, 114, 2, 2, 622, 623, 7, 110, 2, 2, 623, 624, 7, 107, 2, 2, 624, 625, 7, 101, 2, 2, 625, 626, 7, 107, 2, 2, 626, 627, 7, 118, 2, 2, 627, 70, 3, 2, 2, 2, 628, 629, 7, 103, 2, 2, 629, 630, 7, 122, 2, 2, 630, 631, 7, 114, 2, 2, 631, 632, 7, 113, 2, 2, 632, 633, 7, 116, 2, 2, 633, 634, 7, 118, 2, 2, 634, 72, 3, 2, 2, 2, 635, 636, 7, 103, 2, 2, 636, 637, 7, 122, 2, 2, 637, 638, 7, 118, 2, 2, 638, 639, 7, 103, 2, 2, 639, 640, 7, 116, 2, 2, 640, 641, 7, 112, 2, 2, 641, 74, 3, 2, 2, 2, 642, 643, 7, 104, 2, 2, 643, 644, 7, 99, 2, 2, 644, 645, 7, 110, 2, 2, 645, 646, 7, 117, 2, 2, 646, 647, 7, 103, 2, 2, 647, 76, 3, 2, 2, 2, 648, 649, 7, 104, 2, 2, 649, 650, 7, 107, 2, 2, 650, 651, 7, 112, 2, 2, 651, 652, 7, 99, 2, 2, 652, 653, 7, 110, 2, 2, 653, 78, 3, 2, 2, 2, 654, 655, 7, 104, 2, 2, 655, 656, 7, 110, 2, 2, 656, 657, 7, 113, 2, 2, 657, 658, 7, 99, 2, 2, 658, 659, 7, 118, 2, 2, 659, 80, 3, 2, 2, 2, 660, 661, 7, 104, 2, 2, 661, 662, 7, 113, 2, 2, 662, 663, 7, 116, 2, 2, 663, 82, 3, 2, 2, 2, 664, 665, 7, 104, 2, 2, 665, 666, 7, 116, 2, 2, 666, 667, 7, 107, 2, 2, 667, 668, 7, 103, 2, 2, 668, 669, 7, 112, 2, 2, 669, 670, 7, 102, 2, 2, 670, 84, 3, 2, 2, 2, 671, 672, 7, 105, 2, 2, 672, 673, 7, 113, 2, 2, 673, 674, 7, 118, 2, 2, 674, 675, 7, 113, 2, 2, 675, 86, 3, 2, 2, 2, 676, 677, 7, 107, 2, 2, 677, 678, 7, 104, 2, 2, 678, 88, 3, 2, 2, 2, 679, 680, 7, 107, 2, 2, 680, 681, 7, 112, 2, 2, 681, 682, 7, 110, 2, 2, 682, 683, 7, 107, 2, 2, 683, 684, 7, 112, 2, 2, 684, 685, 7, 103, 2, 2, 685, 90, 3, 2, 2, 2, 686, 687, 7, 107, 2, 2, 687, 688, 7, 112, 2, 2, 688, 689, 7, 118, 2, 2, 689, 92, 3, 2, 2, 2, 690, 691, 7, 110, 2, 2, 691, 692, 7, 113, 2, 2, 692, 693, 7, 112, 2, 2, 693, 694, 7, 105, 2, 2, 694, 94, 3, 2, 2, 2, 695, 696, 7, 111, 2, 2, 696, 697, 7, 119, 2, 2, 697, 698, 7, 118, 2, 2, 698, 699, 7, 99, 2, 2, 699, 700, 7, 100, 2, 2, 700, 701, 7, 110, 2, 2, 701, 702, 7, 103, 2, 2, 702, 96, 3, 2, 2, 2, 703, 704, 7, 112, 2, 2, 704, 705, 7, 99, 2, 2, 705, 706, 7, 111, 2, 2, 706, 707, 7, 103, 2, 2, 707, 708, 7, 117, 2, 2, 708, 709, 7, 114, 2, 2, 709, 710, 7, 99, 2, 2, 710, 711, 7, 101, 2, 2, 711, 712, 7, 103, 2, 2, 712, 98, 3, 2, 2, 2, 713, 714, 7, 112, 2, 2, 714, 715, 7, 103, 2, 2, 715, 716, 7, 121, 2, 2, 716, 100, 3, 2, 2, 2, 717, 718, 7, 112, 2, 2, 718, 719, 7, 113, 2, 2, 719, 720, 7, 103, 2, 2, 720, 721, 7, 122, 2, 2, 721, 722, 7, 101, 2, 2, 722, 723, 7, 103, 2, 2, 723, 724, 7, 114, 2, 2, 724, 725, 7, 118, 2, 2, 725, 102, 3, 2, 2, 2, 726, 727, 7, 112, 2, 2, 727, 728, 7, 119, 2, 2, 728, 729, 7, 110, 2, 2, 729, 730, 7, 110, 2, 2, 730, 731, 7, 114, 2, 2, 731, 732, 7, 118, 2, 2, 732, 733, 7, 116, 2, 2, 733, 104, 3, 2, 2, 2, 734, 735, 7, 113, 2, 2, 735, 736, 7, 114, 2, 2, 736, 737, 7, 103, 2, 2, 737, 738, 7, 116, 2, 2, 738, 739, 7, 99, 2, 2, 739, 740, 7, 118, 2, 2, 740, 741, 7, 113, 2, 2, 741, 742, 7, 116, 2, 2, 742, 106, 3, 2, 2, 2, 743, 744, 7, 113, 2, 2, 744, 745, 7, 120, 2, 2, 745, 746, 7, 103, 2, 2, 746, 747, 7, 116, 2, 2, 747, 748, 7, 116, 2, 2, 748, 749, 7, 107, 2, 2, 749, 750, 7, 102, 2, 2, 750, 751, 7, 103, 2, 2, 751, 108, 3, 2, 2, 2, 752, 753, 7, 114, 2, 2, 753, 754, 7, 116, 2, 2, 754, 755, 7, 107, 2, 2, 755, 756, 7, 120, 2, 2, 756, 757, 7, 99, 2, 2, 757, 758, 7, 118, 2, 2, 758, 759, 7, 103, 2, 2, 759, 110, 3, 2, 2, 2, 760, 761, 7, 114, 2, 2, 761, 762, 7, 116, 2, 2, 762, 763, 7, 113, 2, 2, 763, 764, 7, 118, 2, 2, 764, 765, 7, 103, 2, 2, 765, 766, 7, 101, 2, 2, 766, 767, 7, 118, 2, 2, 767, 768, 7, 103, 2, 2, 768, 769, 7, 102, 2, 2, 769, 112, 3, 2, 2, 2, 770, 771, 7, 114, 2, 2, 771, 772, 7, 119, 2, 2, 772, 773, 7, 100, 2, 2, 773, 774, 7, 110, 2, 2, 774, 775, 7, 107, 2, 2, 775, 776, 7, 101, 2, 2, 776, 114, 3, 2, 2, 2, 777, 778, 7, 116, 2, 2, 778, 779, 7, 103, 2, 2, 779, 780, 7, 105, 2, 2, 780, 781, 7, 107, 2, 2, 781, 782, 7, 117, 2, 2, 782, 783, 7, 118, 2, 2, 783, 784, 7, 103, 2, 2, 784, 785, 7, 116, 2, 2, 785, 116, 3, 2, 2, 2, 786, 787, 7, 116, 2, 2, 787, 788, 7, 103, 2, 2, 788, 789, 7, 107, 2, 2, 789, 790, 7, 112, 2, 2, 790, 791, 7, 118, 2, 2, 791, 792, 7, 103, 2, 2, 792, 793, 7, 116, 2, 2, 793, 794, 7, 114, 2, 2, 794, 795, 7, 116, 2, 2, 795, 796, 7, 103, 2, 2, 796, 797, 7, 118, 2, 2, 797, 798, 7, 97, 2, 2, 798, 799, 7, 101, 2, 2, 799, 800, 7, 99, 2, 2, 800, 801, 7, 117, 2, 2, 801, 802, 7, 118, 2, 2, 802, 118, 3, 2, 2, 2, 803, 804, 7, 116, 2, 2, 804, 805, 7, 103, 2, 2, 805, 806, 7, 118, 2, 2, 806, 807, 7, 119, 2, 2, 807, 808, 7, 116, 2, 2, 808, 809, 7, 112, 2, 2, 809, 120, 3, 2, 2, 2, 810, 811, 7, 117, 2, 2, 811, 812, 7, 106, 2, 2, 812, 813, 7, 113, 2, 2, 813, 814, 7, 116, 2, 2, 814, 815, 7, 118, 2, 2, 815, 122, 3, 2, 2, 2, 816, 817, 7, 117, 2, 2, 817, 818, 7, 107, 2, 2, 818, 819, 7, 105, 2, 2, 819, 820, 7, 112, 2, 2, 820, 821, 7, 103, 2, 2, 821, 822, 7, 102, 2, 2, 822, 124, 3, 2, 2, 2, 823, 824, 7, 117, 2, 2, 824, 825, 7, 107, 2, 2, 825, 826, 7, 124, 2, 2, 826, 827, 7, 103, 2, 2, 827, 828, 7, 113, 2, 2, 828, 829, 7, 104, 2, 2, 829, 126, 3, 2, 2, 2, 830, 831, 7, 117, 2, 2, 831, 832, 7, 118, 2, 2, 832, 833, 7, 99, 2, 2, 833, 834, 7, 118, 2, 2, 834, 835, 7, 107, 2, 2, 835, 836, 7, 101, 2, 2, 836, 128, 3, 2, 2, 2, 837, 838, 7, 117, 2, 2, 838, 839, 7, 118, 2, 2, 839, 840, 7, 99, 2, 2, 840, 841, 7, 118, 2, 2, 841, 842, 7, 107, 2, 2, 842, 843, 7, 101, 2, 2, 843, 844, 7, 97, 2, 2, 844, 845, 7, 99, 2, 2, 845, 846, 7, 117, 2, 2, 846, 847, 7, 117, 2, 2, 847, 848, 7, 103, 2, 2, 848, 849, 7, 116, 2, 2, 849, 850, 7, 118, 2, 2, 850, 130, 3, 2, 2, 2, 851, 852, 7, 117, 2, 2, 852, 853, 7, 118, 2, 2, 853, 854, 7, 99, 2, 2, 854, 855, 7, 118, 2, 2, 855, 856, 7, 107, 2, 2, 856, 857, 7, 101, 2, 2, 857, 858, 7, 97, 2, 2, 858, 859, 7, 101, 2, 2, 859, 860, 7, 99, 2, 2, 860, 861, 7, 117, 2, 2, 861, 862, 7, 118, 2, 2, 862, 132, 3, 2, 2, 2, 863, 864, 7, 117, 2, 2, 864, 865, 7, 118, 2, 2, 865, 866, 7, 116, 2, 2, 866, 867, 7, 119, 2, 2, 867, 868, 7, 101, 2, 2, 868, 869, 7, 118, 2, 2, 869, 134, 3, 2, 2, 2, 870, 871, 7, 117, 2, 2, 871, 872, 7, 121, 2, 2, 872, 873, 7, 107, 2, 2, 873, 874, 7, 118, 2, 2, 874, 875, 7, 101, 2, 2, 875, 876, 7, 106, 2, 2, 876, 136, 3, 2, 2, 2, 877, 878, 7, 118, 2, 2, 878, 879, 7, 103, 2, 2, 879, 880, 7, 111, 2, 2, 880, 881, 7, 114, 2, 2, 881, 882, 7, 110, 2, 2, 882, 883, 7, 99, 2, 2, 883, 884, 7, 118, 2, 2, 884, 885, 7, 103, 2, 2, 885, 138, 3, 2, 2, 2, 886, 887, 7, 118, 2, 2, 887, 888, 7, 106, 2, 2, 888, 889, 7, 107, 2, 2, 889, 890, 7, 117, 2, 2, 890, 140, 3, 2, 2, 2, 891, 892, 7, 118, 2, 2, 892, 893, 7, 106, 2, 2, 893, 894, 7, 116, 2, 2, 894, 895, 7, 103, 2, 2, 895, 896, 7, 99, 2, 2, 896, 897, 7, 102, 2, 2, 897, 898, 7, 97, 2, 2, 898, 899, 7, 110, 2, 2, 899, 900, 7, 113, 2, 2, 900, 901, 7, 101, 2, 2, 901, 902, 7, 99, 2, 2, 902, 903, 7, 110, 2, 2, 903, 142, 3, 2, 2, 2, 904, 905, 7, 118, 2, 2, 905, 906, 7, 106, 2, 2, 906, 907, 7, 116, 2, 2, 907, 908, 7, 113, 2, 2, 908, 909, 7, 121, 2, 2, 909, 144, 3, 2, 2, 2, 910, 911, 7, 118, 2, 2, 911, 912, 7, 116, 2, 2, 912, 913, 7, 119, 2, 2, 913, 914, 7, 103, 2, 2, 914, 146, 3, 2, 2, 2, 915, 916, 7, 118, 2, 2, 916, 917, 7, 116, 2, 2, 917, 918, 7, 123, 2, 2, 918, 148, 3, 2, 2, 2, 919, 920, 7, 118, 2, 2, 920, 921, 7, 123, 2, 2, 921, 922, 7, 114, 2, 2, 922, 923, 7, 103, 2, 2, 923, 924, 7, 102, 2, 2, 924, 925, 7, 103, 2, 2, 925, 926, 7, 104, 2, 2, 926, 150, 3, 2, 2, 2, 927, 928, 7, 118, 2, 2, 928, 929, 7, 123, 2, 2, 929, 930, 7, 114, 2, 2, 930, 931, 7, 103, 2, 2, 931, 932, 7, 107, 2, 2, 932, 933, 7, 102, 2, 2, 933, 152, 3, 2, 2, 2, 934, 935, 7, 118, 2, 2, 935, 936, 7, 123, 2, 2, 936, 937, 7, 114, 2, 2, 937, 938, 7, 103, 2, 2, 938, 939, 7, 112, 2, 2, 939, 940, 7, 99, 2, 2, 940, 941, 7, 111, 2, 2, 941, 942, 7, 103, 2, 2, 942, 154, 3, 2, 2, 2, 943, 944, 7, 119, 2, 2, 944, 945, 7, 112, 2, 2, 945, 946, 7, 107, 2, 2, 946, 947, 7, 113, 2, 2, 947, 948, 7, 112, 2, 2, 948, 156, 3, 2, 2, 2, 949, 950, 7, 119, 2, 2, 950, 951, 7, 112, 2, 2, 951, 952, 7, 117, 2, 2, 952, 953, 7, 107, 2, 2, 953, 954, 7, 105, 2, 2, 954, 955, 7, 112, 2, 2, 955, 956, 7, 103, 2, 2, 956, 957, 7, 102, 2, 2, 957, 158, 3, 2, 2, 2, 958, 959, 7, 119, 2, 2, 959, 960, 7, 117, 2, 2, 960, 961, 7, 107, 2, 2, 961, 962, 7, 112, 2, 2, 962, 963, 7, 105, 2, 2, 963, 160, 3, 2, 2, 2, 964, 965, 7, 120, 2, 2, 965, 966, 7, 107, 2, 2, 966, 967, 7, 116, 2, 2, 967, 968, 7, 118, 2, 2, 968, 969, 7, 119, 2, 2, 969, 970, 7, 99, 2, 2, 970, 971, 7, 110, 2, 2, 971, 162, 3, 2, 2, 2, 972, 973, 7, 120, 2, 2, 973, 974, 7, 113, 2, 2, 974, 975, 7, 107, 2, 2, 975, 976, 7, 102, 2, 2, 976, 164, 3, 2, 2, 2, 977, 978, 7, 120, 2, 2, 978, 979, 7, 113, 2, 2, 979, 980, 7, 110, 2, 2, 980, 981, 7, 99, 2, 2, 981, 982, 7, 118, 2, 2, 982, 983, 7, 107, 2, 2, 983, 984, 7, 110, 2, 2, 984, 985, 7, 103, 2, 2, 985, 166, 3, 2, 2, 2, 986, 987, 7, 121, 2, 2, 987, 988, 7, 101, 2, 2, 988, 989, 7, 106, 2, 2, 989, 990, 7, 99, 2, 2, 990, 991, 7, 116, 2, 2, 991, 992, 7, 97, 2, 2, 992, 993, 7, 118, 2, 2, 993, 168, 3, 2, 2, 2, 994, 995, 7, 121, 2, 2, 995, 996, 7, 106, 2, 2, 996, 997, 7, 107, 2, 2, 997, 998, 7, 110, 2, 2, 998, 999, 7, 103, 2, 2, 999, 170, 3, 2, 2, 2, 1000, 1001, 7, 42, 2, 2, 1001, 172, 3, 2, 2, 2, 1002, 1003, 7, 43, 2, 2, 1003, 174, 3, 2, 2, 2, 1004, 1005, 7, 93, 2, 2, 1005, 176, 3, 2, 2, 2, 1006, 1007, 7, 95, 2, 2, 1007, 178, 3, 2, 2, 2, 1008, 1009, 7, 125, 2, 2, 1009, 180, 3, 2, 2, 2, 1010, 1011, 7, 127, 2, 2, 1011, 182, 3, 2, 2, 2, 1012, 1013, 7, 45, 2, 2, 1013, 184, 3, 2, 2, 2, 1014, 1015, 7, 47, 2, 2, 1015, 186, 3, 2, 2, 2, 1016, 1017, 7, 44, 2, 2, 1017, 188, 3, 2, 2, 2, 1018, 1019, 7, 49, 2, 2, 1019, 190, 3, 2, 2, 2, 1020, 1021, 7, 39, 2, 2, 1021, 192, 3, 2, 2, 2, 1022, 1023, 7, 96, 2, 2, 1023, 194, 3, 2, 2, 2, 1024, 1025, 7, 40, 2, 2, 1025, 196, 3, 2, 2, 2, 1026, 1027, 7, 126, 2, 2, 1027, 198, 3, 2, 2, 2, 1028, 1029, 7, 128, 2, 2, 1029, 200, 3, 2, 2, 2, 1030, 1035, 7, 35, 2, 2, 1031, 1032, 7, 112, 2, 2, 1032, 1033, 7, 113, 2, 2, 1033, 1035, 7, 118, 2, 2, 1034, 1030, 3, 2, 2, 2, 1034, 1031, 3, 2, 2, 2, 1035, 202, 3, 2, 2, 2, 1036, 1037, 7, 63, 2, 2, 1037, 204, 3, 2, 2, 2, 1038, 1039, 7, 62, 2, 2, 1039, 206, 3, 2, 2, 2, 1040, 1041, 7, 64, 2, 2, 1041, 208, 3, 2, 2, 2, 1042, 1043, 7, 45, 2, 2, 1043, 1044, 7, 63, 2, 2, 1044, 210, 3, 2, 2, 2, 1045, 1046, 7, 47, 2, 2, 1046, 1047, 7, 63, 2, 2, 1047, 212, 3, 2, 2, 2, 1048, 1049, 7, 44, 2, 2, 1049, 1050, 7, 63, 2, 2, 1050, 214, 3, 2, 2, 2, 1051, 1052, 7, 49, 2, 2, 1052, 1053, 7, 63, 2, 2, 1053, 216, 3, 2, 2, 2, 1054, 1055, 7, 39, 2, 2, 1055, 1056, 7, 63, 2, 2, 1056, 218, 3, 2, 2, 2, 1057, 1058, 7, 96, 2, 2, 1058, 1059, 7, 63, 2, 2, 1059, 220, 3, 2, 2, 2, 1060, 1061, 7, 40, 2, 2, 1061, 1062, 7, 63, 2, 2, 1062, 222, 3, 2, 2, 2, 1063, 1064, 7, 126, 2, 2, 1064, 1065, 7, 63, 2, 2, 1065, 224, 3, 2, 2, 2, 1066, 1067, 7, 62, 2, 2, 1067, 1068, 7, 62, 2, 2, 1068, 1069, 7, 63, 2, 2, 1069, 226, 3, 2, 2, 2, 1070, 1071, 7, 64, 2, 2, 1071, 1072, 7, 64, 2, 2, 1072, 1073, 7, 63, 2, 2, 1073, 228, 3, 2, 2, 2, 1074, 1075, 7, 63, 2, 2, 1075, 1076, 7, 63, 2, 2, 1076, 230, 3, 2, 2, 2, 1077, 1078, 7, 35, 2, 2, 1078, 1079, 7, 63, 2, 2, 1079, 232, 3, 2, 2, 2, 1080, 1081, 7, 62, 2, 2, 1081, 1082, 7, 63, 2, 2, 1082, 234, 3, 2, 2, 2, 1083, 1084, 7, 64, 2, 2, 1084, 1085, 7, 63, 2, 2, 1085, 236, 3, 2, 2, 2, 1086, 1087, 7, 40, 2, 2, 1087, 1092, 7, 40, 2, 2, 1088, 1089, 7, 99, 2, 2, 1089, 1090, 7, 112, 2, 2, 1090, 1092, 7, 102, 2, 2, 1091, 1086, 3, 2, 2, 2, 1091, 1088, 3, 2, 2, 2, 1092, 238, 3, 2, 2, 2, 1093, 1094, 7, 126, 2, 2, 1094, 1098, 7, 126, 2, 2, 1095, 1096, 7, 113, 2, 2, 1096, 1098, 7, 116, 2, 2, 1097, 1093, 3, 2, 2, 2, 1097, 1095, 3, 2, 2, 2, 1098, 240, 3, 2, 2, 2, 1099, 1100, 7, 45, 2, 2, 1100, 1101, 7, 45, 2, 2, 1101, 242, 3, 2, 2, 2, 1102, 1103, 7, 47, 2, 2, 1103, 1104, 7, 47, 2, 2, 1104, 244, 3, 2, 2, 2, 1105, 1106, 7, 46, 2, 2, 1106, 246, 3, 2, 2, 2, 1107, 1108, 7, 47, 2, 2, 1108, 1109, 7, 64, 2, 2, 1109, 1110, 7, 44, 2, 2, 1110, 248, 3, 2, 2, 2, 1111, 1112, 7, 47, 2, 2, 1112, 1113, 7, 64, 2, 2, 1113, 250, 3, 2, 2, 2, 1114, 1115, 7, 65, 2, 2, 1115, 252, 3, 2, 2, 2, 1116, 1117, 7, 60, 2, 2, 1117, 254, 3, 2, 2, 2, 1118, 1119, 7, 60, 2, 2, 1119, 1120, 7, 60, 2, 2, 1120, 256, 3, 2, 2, 2, 1121, 1122, 7, 61, 2, 2, 1122, 258, 3, 2, 2, 2, 1123, 1124, 7, 48, 2, 2, 1124, 260, 3, 2, 2, 2, 1125, 1126, 7, 48, 2, 2, 1126, 1127, 7, 44, 2, 2, 1127, 262, 3, 2, 2, 2, 1128, 1129, 7, 48, 2, 2, 1129, 1130, 7, 48, 2, 2, 1130, 1131, 7, 48, 2, 2, 1131, 264, 3, 2, 2, 2, 1132, 1133, 5, 289, 145, 2, 1133, 1134, 5, 289, 145, 2, 1134, 1135, 5, 289, 145, 2, 1135, 1136, 5, 289, 145, 2, 1136, 266, 3, 2, 2, 2, 1137, 1138, 7, 94, 2, 2, 1138, 1139, 7, 119, 2, 2, 1139, 1140, 3, 2, 2, 2, 1140, 1148, 5, 265, 133, 2, 1141, 1142, 7, 94, 2, 2, 1142, 1143, 7, 87, 2, 2, 1143, 1144, 3, 2, 2, 2, 1144, 1145, 5, 265, 133, 2, 1145, 1146, 5, 265, 133, 2, 1146, 1148, 3, 2, 2, 2, 1147, 1137, 3, 2, 2, 2, 1147, 1141, 3, 2, 2, 2, 1148, 268, 3, 2, 2, 2, 1149, 1154, 5, 271, 136, 2, 1150, 1153, 5, 271, 136, 2, 1151, 1153, 5, 275, 138, 2, 1152, 1150, 3, 2, 2, 2, 1152, 1151, 3, 2, 2, 2, 1153, 1156, 3, 2, 2, 2, 1154, 1152, 3, 2, 2, 2, 1154, 1155, 3, 2, 2, 2, 1155, 270, 3, 2, 2, 2, 1156, 1154, 3, 2, 2, 2, 1157, 1160, 5, 273, 137, 2, 1158, 1160, 5, 267, 134, 2, 1159, 1157, 3, 2, 2, 2, 1159, 1158, 3, 2, 2, 2, 1160, 272, 3, 2, 2, 2, 1161, 1162, 9, 4, 2, 2, 1162, 274, 3, 2, 2, 2, 1163, 1164, 9, 5, 2, 2, 1164, 276, 3, 2, 2, 2, 1165, 1172, 5, 285, 143, 2, 1166, 1168, 7, 41, 2, 2, 1167, 1166, 3, 2, 2, 2, 1167, 1168, 3, 2, 2, 2, 1168, 1169, 3, 2, 2, 2, 1169, 1171, 5, 275, 138, 2, 1170, 1167, 3, 2, 2, 2, 1171, 1174, 3, 2, 2, 2, 1172, 1170, 3, 2, 2, 2, 1172, 1173, 3, 2, 2, 2, 1173, 278, 3, 2, 2, 2, 1174, 1172, 3, 2, 2, 2, 1175, 1182, 7, 50, 2, 2, 1176, 1178, 7, 41, 2, 2, 1177, 1176, 3, 2, 2, 2, 1177, 1178, 3, 2, 2, 2, 1178, 1179, 3, 2, 2, 2, 1179, 1181, 5, 287, 144, 2, 1180, 1177, 3, 2, 2, 2, 1181, 1184, 3, 2, 2, 2, 1182, 1180, 3, 2, 2, 2, 1182, 1183, 3, 2, 2, 2, 1183, 280, 3, 2, 2, 2, 1184, 1182, 3, 2, 2, 2, 1185, 1186, 7, 50, 2, 2, 1186, 1190, 7, 122, 2, 2, 1187, 1188, 7, 50, 2, 2, 1188, 1190, 7, 90, 2, 2, 1189, 1185, 3, 2, 2, 2, 1189, 1187, 3, 2, 2, 2, 1190, 1191, 3, 2, 2, 2, 1191, 1198, 5, 289, 145, 2, 1192, 1194, 7, 41, 2, 2, 1193, 1192, 3, 2, 2, 2, 1193, 1194, 3, 2, 2, 2, 1194, 1195, 3, 2, 2, 2, 1195, 1197, 5, 289, 145, 2, 1196, 1193, 3, 2, 2, 2, 1197, 1200, 3, 2, 2, 2, 1198, 1196, 3, 2, 2, 2, 1198, 1199, 3, 2, 2, 2, 1199, 282, 3, 2, 2, 2, 1200, 1198, 3, 2, 2, 2, 1201, 1202, 7, 50, 2, 2, 1202, 1206, 7, 100, 2, 2, 1203, 1204, 7, 50, 2, 2, 1204, 1206, 7, 68, 2, 2, 1205, 1201, 3, 2, 2, 2, 1205, 1203, 3, 2, 2, 2, 1206, 1207, 3, 2, 2, 2, 1207, 1214, 5, 291, 146, 2, 1208, 1210, 7, 41, 2, 2, 1209, 1208, 3, 2, 2, 2, 1209, 1210, 3, 2, 2, 2, 1210, 1211, 3, 2, 2, 2, 1211, 1213, 5, 291, 146, 2, 1212, 1209, 3, 2, 2, 2, 1213, 1216, 3, 2, 2, 2, 1214, 1212, 3, 2, 2, 2, 1214, 1215, 3, 2, 2, 2, 1215, 284, 3, 2, 2, 2, 1216, 1214, 3, 2, 2, 2, 1217, 1218, 9, 6, 2, 2, 1218, 286, 3, 2, 2, 2, 1219, 1220, 9, 7, 2, 2, 1220, 288, 3, 2, 2, 2, 1221, 1222, 9, 8, 2, 2, 1222, 290, 3, 2, 2, 2, 1223, 1224, 9, 9, 2, 2, 1224, 292, 3, 2, 2, 2, 1225, 1227, 5, 295, 148, 2, 1226, 1228, 5, 297, 149, 2, 1227, 1226, 3, 2, 2, 2, 1227, 1228, 3, 2, 2, 2, 1228, 1242, 3, 2, 2, 2, 1229, 1231, 5, 295, 148, 2, 1230, 1232, 5, 299, 150, 2, 1231, 1230, 3, 2, 2, 2, 1231, 1232, 3, 2, 2, 2, 1232, 1242, 3, 2, 2, 2, 1233, 1235, 5, 297, 149, 2, 1234, 1236, 5, 295, 148, 2, 1235, 1234, 3, 2, 2, 2, 1235, 1236, 3, 2, 2, 2, 1236, 1242, 3, 2, 2, 2, 1237, 1239, 5, 299, 150, 2, 1238, 1240, 5, 295, 148, 2, 1239, 1238, 3, 2, 2, 2, 1239, 1240, 3, 2, 2, 2, 1240, 1242, 3, 2, 2, 2, 1241, 1225, 3, 2, 2, 2, 1241, 1229, 3, 2, 2, 2, 1241, 1233, 3, 2, 2, 2, 1241, 1237, 3, 2, 2, 2, 1242, 294, 3, 2, 2, 2, 1243, 1244, 9, 10, 2, 2, 1244, 296, 3, 2, 2, 2, 1245, 1246, 9, 11, 2, 2, 1246, 298, 3, 2, 2, 2, 1247, 1248, 7, 110, 2, 2, 1248, 1252, 7, 110, 2, 2, 1249, 1250, 7, 78, 2, 2, 1250, 1252, 7, 78, 2, 2, 1251, 1247, 3, 2, 2, 2, 1251, 1249, 3, 2, 2, 2, 1252, 300, 3, 2, 2, 2, 1253, 1257, 10, 12, 2, 2, 1254, 1257, 5, 303, 152, 2, 1255, 1257, 5, 267, 134, 2, 1256, 1253, 3, 2, 2, 2, 1256, 1254, 3, 2, 2, 2, 1256, 1255, 3, 2, 2, 2, 1257, 302, 3, 2, 2, 2, 1258, 1262, 5, 305, 153, 2, 1259, 1262, 5, 307, 154, 2, 1260, 1262, 5, 309, 155, 2, 1261, 1258, 3, 2, 2, 2, 1261, 1259, 3, 2, 2, 2, 1261, 1260, 3, 2, 2, 2, 1262, 304, 3, 2, 2, 2, 1263, 1264, 7, 94, 2, 2, 1264, 1294, 7, 41, 2, 2, 1265, 1266, 7, 94, 2, 2, 1266, 1294, 7, 36, 2, 2, 1267, 1268, 7, 94, 2, 2, 1268, 1294, 7, 65, 2, 2, 1269, 1270, 7, 94, 2, 2, 1270, 1294, 7, 94, 2, 2, 1271, 1272, 7, 94, 2, 2, 1272, 1294, 7, 99, 2, 2, 1273, 1274, 7, 94, 2, 2, 1274, 1294, 7, 100, 2, 2, 1275, 1276, 7, 94, 2, 2, 1276, 1294, 7, 104, 2, 2, 1277, 1278, 7, 94, 2, 2, 1278, 1294, 7, 112, 2, 2, 1279, 1280, 7, 94, 2, 2, 1280, 1294, 7, 116, 2, 2, 1281, 1287, 7, 94, 2, 2, 1282, 1284, 7, 15, 2, 2, 1283, 1285, 7, 12, 2, 2, 1284, 1283, 3, 2, 2, 2, 1284, 1285, 3, 2, 2, 2, 1285, 1288, 3, 2, 2, 2, 1286, 1288, 7, 12, 2, 2, 1287, 1282, 3, 2, 2, 2, 1287, 1286, 3, 2, 2, 2, 1288, 1294, 3, 2, 2, 2, 1289, 1290, 7, 94, 2, 2, 1290, 1294, 7, 118, 2, 2, 1291, 1292, 7, 94, 2, 2, 1292, 1294, 7, 120, 2, 2, 1293, 1263, 3, 2, 2, 2, 1293, 1265, 3, 2, 2, 2, 1293, 1267, 3, 2, 2, 2, 1293, 1269, 3, 2, 2, 2, 1293, 1271, 3, 2, 2, 2, 1293, 1273, 3, 2, 2, 2, 1293, 1275, 3, 2, 2, 2, 1293, 1277, 3, 2, 2, 2, 1293, 1279, 3, 2, 2, 2, 1293, 1281, 3, 2, 2, 2, 1293, 1289, 3, 2, 2, 2, 1293, 1291, 3, 2, 2, 2, 1294, 306, 3, 2, 2, 2, 1295, 1296, 7, 94, 2, 2, 1296, 1307, 5, 287, 144, 2, 1297, 1298, 7, 94, 2, 2, 1298, 1299, 5, 287, 144, 2, 1299, 1300, 5, 287, 144, 2, 1300, 1307, 3, 2, 2, 2, 1301, 1302, 7, 94, 2, 2, 1302, 1303, 5, 287, 144, 2, 1303, 1304, 5, 287, 144, 2, 1304, 1305, 5, 287, 144, 2, 1305, 1307, 3, 2, 2, 2, 1306, 1295, 3, 2, 2, 2, 1306, 1297, 3, 2, 2, 2, 1306, 1301, 3, 2, 2, 2, 1307, 308, 3, 2, 2, 2, 1308, 1309, 7, 94, 2, 2, 1309, 1310, 7, 122, 2, 2, 1310, 1312, 3, 2, 2, 2, 1311, 1313, 5, 289, 145, 2, 1312, 1311, 3, 2, 2, 2, 1313, 1314, 3, 2, 2, 2, 1314, 1312, 3, 2, 2, 2, 1314, 1315, 3, 2, 2, 2, 1315, 310, 3, 2, 2, 2, 1316, 1318, 5, 317, 159, 2, 1317, 1316, 3, 2, 2, 2, 1317, 1318, 3, 2, 2, 2, 1318, 1319, 3, 2, 2, 2, 1319, 1320, 7, 48, 2, 2, 1320, 1325, 5, 317, 159, 2, 1321, 1322, 5, 317, 159, 2, 1322, 1323, 7, 48, 2, 2, 1323, 1325, 3, 2, 2, 2, 1324, 1317, 3, 2, 2, 2, 1324, 1321, 3, 2, 2, 2, 1325, 312, 3, 2, 2, 2, 1326, 1328, 7, 103, 2, 2, 1327, 1329, 5, 315, 158, 2, 1328, 1327, 3, 2, 2, 2, 1328, 1329, 3, 2, 2, 2, 1329, 1330, 3, 2, 2, 2, 1330, 1337, 5, 317, 159, 2, 1331, 1333, 7, 71, 2, 2, 1332, 1334, 5, 315, 158, 2, 1333, 1332, 3, 2, 2, 2, 1333, 1334, 3, 2, 2, 2, 1334, 1335, 3, 2, 2, 2, 1335, 1337, 5, 317, 159, 2, 1336, 1326, 3, 2, 2, 2, 1336, 1331, 3, 2, 2, 2, 1337, 314, 3, 2, 2, 2, 1338, 1339, 9, 13, 2, 2, 1339, 316, 3, 2, 2, 2, 1340, 1347, 5, 275, 138, 2, 1341, 1343, 7, 41, 2, 2, 1342, 1341, 3, 2, 2, 2, 1342, 1343, 3, 2, 2, 2, 1343, 1344, 3, 2, 2, 2, 1344, 1346, 5, 275, 138, 2, 1345, 1342, 3, 2, 2, 2, 1346, 1349, 3, 2, 2, 2, 1347, 1345, 3, 2, 2, 2, 1347, 1348, 3, 2, 2, 2, 1348, 318, 3, 2, 2, 2, 1349, 1347, 3, 2, 2, 2, 1350, 1351, 9, 14, 2, 2, 1351, 320, 3, 2, 2, 2, 1352, 1353, 7, 119, 2, 2, 1353, 1356, 7, 58, 2, 2, 1354, 1356, 9, 2, 2, 2, 1355, 1352, 3, 2, 2, 2, 1355, 1354, 3, 2, 2, 2, 1356, 322, 3, 2, 2, 2, 1357, 1361, 10, 15, 2, 2, 1358, 1361, 5, 303, 152, 2, 1359, 1361, 5, 267, 134, 2, 1360, 1357, 3, 2, 2, 2, 1360, 1358, 3, 2, 2, 2, 1360, 1359, 3, 2, 2, 2, 1361, 324, 3, 2, 2, 2, 1362, 1366, 7, 36, 2, 2, 1363, 1365, 10, 16, 2, 2, 1364, 1363, 3, 2, 2, 2, 1365, 1368, 3, 2, 2, 2, 1366, 1364, 3, 2, 2, 2, 1366, 1367, 3, 2, 2, 2, 1367, 1369, 3, 2, 2, 2, 1368, 1366, 3, 2, 2, 2, 1369, 1373, 7, 42, 2, 2, 1370, 1372, 10, 17, 2, 2, 1371, 1370, 3, 2, 2, 2, 1372, 1375, 3, 2, 2, 2, 1373, 1371, 3, 2, 2, 2, 1373, 1374, 3, 2, 2, 2, 1374, 1376, 3, 2, 2, 2, 1375, 1373, 3, 2, 2, 2, 1376, 1380, 7, 43, 2, 2, 1377, 1379, 10, 18, 2, 2, 1378, 1377, 3, 2, 2, 2, 1379, 1382, 3, 2, 2, 2, 1380, 1378, 3, 2, 2, 2, 1380, 1381, 3, 2, 2, 2, 1381, 1383, 3, 2, 2, 2, 1382, 1380, 3, 2, 2, 2, 1383, 1384, 7, 36, 2, 2, 1384, 326, 3, 2, 2, 2, 1385, 1386, 5, 277, 139, 2, 1386, 1387, 5, 335, 168, 2, 1387, 1398, 3, 2, 2, 2, 1388, 1389, 5, 279, 140, 2, 1389, 1390, 5, 335, 168, 2, 1390, 1398, 3, 2, 2, 2, 1391, 1392, 5, 281, 141, 2, 1392, 1393, 5, 335, 168, 2, 1393, 1398, 3, 2, 2, 2, 1394, 1395, 5, 283, 142, 2, 1395, 1396, 5, 335, 168, 2, 1396, 1398, 3, 2, 2, 2, 1397, 1385, 3, 2, 2, 2, 1397, 1388, 3, 2, 2, 2, 1397, 1391, 3, 2, 2, 2, 1397, 1394, 3, 2, 2, 2, 1398, 328, 3, 2, 2, 2, 1399, 1401, 5, 311, 156, 2, 1400, 1402, 5, 313, 157, 2, 1401, 1400, 3, 2, 2, 2, 1401, 1402, 3, 2, 2, 2, 1402, 1403, 3, 2, 2, 2, 1403, 1404, 5, 335, 168, 2, 1404, 1410, 3, 2, 2, 2, 1405, 1406, 5, 317, 159, 2, 1406, 1407, 5, 313, 157, 2, 1407, 1408, 5, 335, 168, 2, 1408, 1410, 3, 2, 2, 2, 1409, 1399, 3, 2, 2, 2, 1409, 1405, 3, 2, 2, 2, 1410, 330, 3, 2, 2, 2, 1411, 1412, 5, 9, 5, 2, 1412, 1413, 5, 335, 168, 2, 1413, 332, 3, 2, 2, 2, 1414, 1415, 5, 5, 3, 2, 1415, 1416, 5, 335, 168, 2, 1416, 334, 3, 2, 2, 2, 1417, 1418, 5, 269, 135, 2, 1418, 336, 3, 2, 2, 2, 1419, 1421, 9, 19, 2, 2, 1420, 1419, 3, 2, 2, 2, 1421, 1422, 3, 2, 2, 2, 1422, 1420, 3, 2, 2, 2, 1422, 1423, 3, 2, 2, 2, 1423, 1424, 3, 2, 2, 2, 1424, 1425, 8, 169, 3, 2, 1425, 338, 3, 2, 2, 2, 1426, 1428, 7, 15, 2, 2, 1427, 1429, 7, 12, 2, 2, 1428, 1427, 3, 2, 2, 2, 1428, 1429, 3, 2, 2, 2, 1429, 1432, 3, 2, 2, 2, 1430, 1432, 7, 12, 2, 2, 1431, 1426, 3, 2, 2, 2, 1431, 1430, 3, 2, 2, 2, 1432, 1433, 3, 2, 2, 2, 1433, 1434, 8, 170, 3, 2, 1434, 340, 3, 2, 2, 2, 1435, 1436, 7, 49, 2, 2, 1436, 1437, 7, 44, 2, 2, 1437, 1441, 3, 2, 2, 2, 1438, 1440, 11, 2, 2, 2, 1439, 1438, 3, 2, 2, 2, 1440, 1443, 3, 2, 2, 2, 1441, 1442, 3, 2, 2, 2, 1441, 1439, 3, 2, 2, 2, 1442, 1444, 3, 2, 2, 2, 1443, 1441, 3, 2, 2, 2, 1444, 1445, 7, 44, 2, 2, 1445, 1446, 7, 49, 2, 2, 1446, 1447, 3, 2, 2, 2, 1447, 1448, 8, 171, 3, 2, 1448, 342, 3, 2, 2, 2, 1449, 1450, 7, 49, 2, 2, 1450, 1451, 7, 49, 2, 2, 1451, 1455, 3, 2, 2, 2, 1452, 1454, 10, 20, 2, 2, 1453, 1452, 3, 2, 2, 2, 1454, 1457, 3, 2, 2, 2, 1455, 1453, 3, 2, 2, 2, 1455, 1456, 3, 2, 2, 2, 1456, 1458, 3, 2, 2, 2, 1457, 1455, 3, 2, 2, 2, 1458, 1459, 8, 172, 3, 2, 1459, 344, 3, 2, 2, 2, 75, 2, 347, 351, 355, 359, 361, 364, 370, 376, 379, 384, 386, 389, 395, 400, 404, 408, 416, 422, 427, 432, 437, 445, 1034, 1091, 1097, 1147, 1152, 1154, 1159, 1167, 1172, 1177, 1182, 1189, 1193, 1198, 1205, 1209, 1214, 1227, 1231, 1235, 1239, 1241, 1251, 1256, 1261, 1284, 1287, 1293, 1306, 1314, 1317, 1324, 1328, 1333, 1336, 1342, 1347, 1355, 1360, 1366, 1373, 1380, 1397, 1401, 1409, 1422, 1428, 1431, 1441, 1455, 4, 2, 3, 2, 8, 2, 2] \ No newline at end of file diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Lexer.java b/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Lexer.java new file mode 100644 index 000000000..c96780836 --- /dev/null +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Lexer.java @@ -0,0 +1,757 @@ +// Generated from /home/syu/workspace/MSCCD_ALL/Project/grammarDefinations/CPP14/CPP14Lexer.g4 by ANTLR 4.8 +package com.itsaky.androidide.lexers.cpp; +import org.antlr.v4.runtime.Lexer; +import org.antlr.v4.runtime.CharStream; +import org.antlr.v4.runtime.Token; +import org.antlr.v4.runtime.TokenStream; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.atn.*; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.misc.*; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) +public class CPP14Lexer extends Lexer { + static { RuntimeMetaData.checkVersion("4.8", RuntimeMetaData.VERSION); } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + IntegerLiteral=1, CharacterLiteral=2, FloatingLiteral=3, StringLiteral=4, + BooleanLiteral=5, PointerLiteral=6, UserDefinedLiteral=7, MultiLineMacro=8, + Directive=9, Alignas=10, Alignof=11, Asm=12, Auto=13, Bool=14, Break=15, + Case=16, Catch=17, Char=18, Char16=19, Char32=20, Class=21, Const=22, + Constexpr=23, Const_cast=24, Continue=25, Decltype=26, Default=27, Delete=28, + Do=29, Double=30, Dynamic_cast=31, Else=32, Enum=33, Explicit=34, Export=35, + Extern=36, False_=37, Final=38, Float=39, For=40, Friend=41, Goto=42, + If=43, Inline=44, Int=45, Long=46, Mutable=47, Namespace=48, New=49, Noexcept=50, + Nullptr=51, Operator=52, Override=53, Private=54, Protected=55, Public=56, + Register=57, Reinterpret_cast=58, Return=59, Short=60, Signed=61, Sizeof=62, + Static=63, Static_assert=64, Static_cast=65, Struct=66, Switch=67, Template=68, + This=69, Thread_local=70, Throw=71, True_=72, Try=73, Typedef=74, Typeid_=75, + Typename_=76, Union=77, Unsigned=78, Using=79, Virtual=80, Void=81, Volatile=82, + Wchar=83, While=84, LeftParen=85, RightParen=86, LeftBracket=87, RightBracket=88, + LeftBrace=89, RightBrace=90, Plus=91, Minus=92, Star=93, Div=94, Mod=95, + Caret=96, And=97, Or=98, Tilde=99, Not=100, Assign=101, Less=102, Greater=103, + PlusAssign=104, MinusAssign=105, StarAssign=106, DivAssign=107, ModAssign=108, + XorAssign=109, AndAssign=110, OrAssign=111, LeftShiftAssign=112, RightShiftAssign=113, + Equal=114, NotEqual=115, LessEqual=116, GreaterEqual=117, AndAnd=118, + OrOr=119, PlusPlus=120, MinusMinus=121, Comma=122, ArrowStar=123, Arrow=124, + Question=125, Colon=126, Doublecolon=127, Semi=128, Dot=129, DotStar=130, + Ellipsis=131, Identifier=132, DecimalLiteral=133, OctalLiteral=134, HexadecimalLiteral=135, + BinaryLiteral=136, Integersuffix=137, UserDefinedIntegerLiteral=138, UserDefinedFloatingLiteral=139, + UserDefinedStringLiteral=140, UserDefinedCharacterLiteral=141, Whitespace=142, + Newline=143, BlockComment=144, LineComment=145; + public static String[] channelNames = { + "DEFAULT_TOKEN_CHANNEL", "HIDDEN" + }; + + public static String[] modeNames = { + "DEFAULT_MODE" + }; + + private static String[] makeRuleNames() { + return new String[] { + "IntegerLiteral", "CharacterLiteral", "FloatingLiteral", "StringLiteral", + "BooleanLiteral", "PointerLiteral", "UserDefinedLiteral", "MultiLineMacro", + "Directive", "Alignas", "Alignof", "Asm", "Auto", "Bool", "Break", "Case", + "Catch", "Char", "Char16", "Char32", "Class", "Const", "Constexpr", "Const_cast", + "Continue", "Decltype", "Default", "Delete", "Do", "Double", "Dynamic_cast", + "Else", "Enum", "Explicit", "Export", "Extern", "False_", "Final", "Float", + "For", "Friend", "Goto", "If", "Inline", "Int", "Long", "Mutable", "Namespace", + "New", "Noexcept", "Nullptr", "Operator", "Override", "Private", "Protected", + "Public", "Register", "Reinterpret_cast", "Return", "Short", "Signed", + "Sizeof", "Static", "Static_assert", "Static_cast", "Struct", "Switch", + "Template", "This", "Thread_local", "Throw", "True_", "Try", "Typedef", + "Typeid_", "Typename_", "Union", "Unsigned", "Using", "Virtual", "Void", + "Volatile", "Wchar", "While", "LeftParen", "RightParen", "LeftBracket", + "RightBracket", "LeftBrace", "RightBrace", "Plus", "Minus", "Star", "Div", + "Mod", "Caret", "And", "Or", "Tilde", "Not", "Assign", "Less", "Greater", + "PlusAssign", "MinusAssign", "StarAssign", "DivAssign", "ModAssign", + "XorAssign", "AndAssign", "OrAssign", "LeftShiftAssign", "RightShiftAssign", + "Equal", "NotEqual", "LessEqual", "GreaterEqual", "AndAnd", "OrOr", "PlusPlus", + "MinusMinus", "Comma", "ArrowStar", "Arrow", "Question", "Colon", "Doublecolon", + "Semi", "Dot", "DotStar", "Ellipsis", "Hexquad", "Universalcharactername", + "Identifier", "Identifiernondigit", "NONDIGIT", "DIGIT", "DecimalLiteral", + "OctalLiteral", "HexadecimalLiteral", "BinaryLiteral", "NONZERODIGIT", + "OCTALDIGIT", "HEXADECIMALDIGIT", "BINARYDIGIT", "Integersuffix", "Unsignedsuffix", + "Longsuffix", "Longlongsuffix", "Cchar", "Escapesequence", "Simpleescapesequence", + "Octalescapesequence", "Hexadecimalescapesequence", "Fractionalconstant", + "Exponentpart", "SIGN", "Digitsequence", "Floatingsuffix", "Encodingprefix", + "Schar", "Rawstring", "UserDefinedIntegerLiteral", "UserDefinedFloatingLiteral", + "UserDefinedStringLiteral", "UserDefinedCharacterLiteral", "Udsuffix", + "Whitespace", "Newline", "BlockComment", "LineComment" + }; + } + public static final String[] ruleNames = makeRuleNames(); + + private static String[] makeLiteralNames() { + return new String[] { + null, null, null, null, null, null, null, null, null, null, "'alignas'", + "'alignof'", "'asm'", "'auto'", "'bool'", "'break'", "'case'", "'catch'", + "'char'", "'char16_t'", "'char32_t'", "'class'", "'const'", "'constexpr'", + "'const_cast'", "'continue'", "'decltype'", "'default'", "'delete'", + "'do'", "'double'", "'dynamic_cast'", "'else'", "'enum'", "'explicit'", + "'export'", "'extern'", "'false'", "'final'", "'float'", "'for'", "'friend'", + "'goto'", "'if'", "'inline'", "'int'", "'long'", "'mutable'", "'namespace'", + "'new'", "'noexcept'", "'nullptr'", "'operator'", "'override'", "'private'", + "'protected'", "'public'", "'register'", "'reinterpret_cast'", "'return'", + "'short'", "'signed'", "'sizeof'", "'static'", "'static_assert'", "'static_cast'", + "'struct'", "'switch'", "'template'", "'this'", "'thread_local'", "'throw'", + "'true'", "'try'", "'typedef'", "'typeid'", "'typename'", "'union'", + "'unsigned'", "'using'", "'virtual'", "'void'", "'volatile'", "'wchar_t'", + "'while'", "'('", "')'", "'['", "']'", "'{'", "'}'", "'+'", "'-'", "'*'", + "'/'", "'%'", "'^'", "'&'", "'|'", "'~'", null, "'='", "'<'", "'>'", + "'+='", "'-='", "'*='", "'/='", "'%='", "'^='", "'&='", "'|='", "'<<='", + "'>>='", "'=='", "'!='", "'<='", "'>='", null, null, "'++'", "'--'", + "','", "'->*'", "'->'", "'?'", "':'", "'::'", "';'", "'.'", "'.*'", "'...'" + }; + } + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static String[] makeSymbolicNames() { + return new String[] { + null, "IntegerLiteral", "CharacterLiteral", "FloatingLiteral", "StringLiteral", + "BooleanLiteral", "PointerLiteral", "UserDefinedLiteral", "MultiLineMacro", + "Directive", "Alignas", "Alignof", "Asm", "Auto", "Bool", "Break", "Case", + "Catch", "Char", "Char16", "Char32", "Class", "Const", "Constexpr", "Const_cast", + "Continue", "Decltype", "Default", "Delete", "Do", "Double", "Dynamic_cast", + "Else", "Enum", "Explicit", "Export", "Extern", "False_", "Final", "Float", + "For", "Friend", "Goto", "If", "Inline", "Int", "Long", "Mutable", "Namespace", + "New", "Noexcept", "Nullptr", "Operator", "Override", "Private", "Protected", + "Public", "Register", "Reinterpret_cast", "Return", "Short", "Signed", + "Sizeof", "Static", "Static_assert", "Static_cast", "Struct", "Switch", + "Template", "This", "Thread_local", "Throw", "True_", "Try", "Typedef", + "Typeid_", "Typename_", "Union", "Unsigned", "Using", "Virtual", "Void", + "Volatile", "Wchar", "While", "LeftParen", "RightParen", "LeftBracket", + "RightBracket", "LeftBrace", "RightBrace", "Plus", "Minus", "Star", "Div", + "Mod", "Caret", "And", "Or", "Tilde", "Not", "Assign", "Less", "Greater", + "PlusAssign", "MinusAssign", "StarAssign", "DivAssign", "ModAssign", + "XorAssign", "AndAssign", "OrAssign", "LeftShiftAssign", "RightShiftAssign", + "Equal", "NotEqual", "LessEqual", "GreaterEqual", "AndAnd", "OrOr", "PlusPlus", + "MinusMinus", "Comma", "ArrowStar", "Arrow", "Question", "Colon", "Doublecolon", + "Semi", "Dot", "DotStar", "Ellipsis", "Identifier", "DecimalLiteral", + "OctalLiteral", "HexadecimalLiteral", "BinaryLiteral", "Integersuffix", + "UserDefinedIntegerLiteral", "UserDefinedFloatingLiteral", "UserDefinedStringLiteral", + "UserDefinedCharacterLiteral", "Whitespace", "Newline", "BlockComment", + "LineComment" + }; + } + 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 CPP14Lexer(CharStream input) { + super(input); + _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); + } + + @Override + public String getGrammarFileName() { return "CPP14Lexer.g4"; } + + @Override + public String[] getRuleNames() { return ruleNames; } + + @Override + public String getSerializedATN() { return _serializedATN; } + + @Override + public String[] getChannelNames() { return channelNames; } + + @Override + public String[] getModeNames() { return modeNames; } + + @Override + public ATN getATN() { return _ATN; } + + public static final String _serializedATN = + "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\u0093\u05b4\b\1\4"+ + "\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n"+ + "\4\13\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22"+ + "\t\22\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31"+ + "\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t"+ + " \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t"+ + "+\4,\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64"+ + "\t\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t"+ + "=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4"+ + "I\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\t"+ + "T\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_"+ + "\4`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k"+ + "\tk\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv"+ + "\4w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t"+ + "\u0080\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084\t\u0084"+ + "\4\u0085\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087\4\u0088\t\u0088\4\u0089"+ + "\t\u0089\4\u008a\t\u008a\4\u008b\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d"+ + "\4\u008e\t\u008e\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092"+ + "\t\u0092\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095\t\u0095\4\u0096\t\u0096"+ + "\4\u0097\t\u0097\4\u0098\t\u0098\4\u0099\t\u0099\4\u009a\t\u009a\4\u009b"+ + "\t\u009b\4\u009c\t\u009c\4\u009d\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f"+ + "\4\u00a0\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3\t\u00a3\4\u00a4"+ + "\t\u00a4\4\u00a5\t\u00a5\4\u00a6\t\u00a6\4\u00a7\t\u00a7\4\u00a8\t\u00a8"+ + "\4\u00a9\t\u00a9\4\u00aa\t\u00aa\4\u00ab\t\u00ab\4\u00ac\t\u00ac\3\2\3"+ + "\2\5\2\u015c\n\2\3\2\3\2\5\2\u0160\n\2\3\2\3\2\5\2\u0164\n\2\3\2\3\2\5"+ + "\2\u0168\n\2\5\2\u016a\n\2\3\3\5\3\u016d\n\3\3\3\3\3\6\3\u0171\n\3\r\3"+ + "\16\3\u0172\3\3\3\3\3\4\3\4\5\4\u0179\n\4\3\4\5\4\u017c\n\4\3\4\3\4\3"+ + "\4\5\4\u0181\n\4\5\4\u0183\n\4\3\5\5\5\u0186\n\5\3\5\3\5\7\5\u018a\n\5"+ + "\f\5\16\5\u018d\13\5\3\5\3\5\5\5\u0191\n\5\3\5\3\5\5\5\u0195\n\5\3\6\3"+ + "\6\5\6\u0199\n\6\3\7\3\7\3\b\3\b\3\b\3\b\5\b\u01a1\n\b\3\t\3\t\7\t\u01a5"+ + "\n\t\f\t\16\t\u01a8\13\t\3\t\3\t\5\t\u01ac\n\t\3\t\6\t\u01af\n\t\r\t\16"+ + "\t\u01b0\3\t\6\t\u01b4\n\t\r\t\16\t\u01b5\3\t\3\t\3\n\3\n\7\n\u01bc\n"+ + "\n\f\n\16\n\u01bf\13\n\3\n\3\n\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13"+ + "\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\r\3\r\3\r\3\r\3\16\3\16\3\16\3\16\3"+ + "\16\3\17\3\17\3\17\3\17\3\17\3\20\3\20\3\20\3\20\3\20\3\20\3\21\3\21\3"+ + "\21\3\21\3\21\3\22\3\22\3\22\3\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3"+ + "\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\25\3\25\3\25\3\25\3\25\3"+ + "\25\3\25\3\25\3\25\3\26\3\26\3\26\3\26\3\26\3\26\3\27\3\27\3\27\3\27\3"+ + "\27\3\27\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\31\3\31\3"+ + "\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\32\3\32\3\32\3\32\3\32\3"+ + "\32\3\32\3\32\3\32\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\34\3"+ + "\34\3\34\3\34\3\34\3\34\3\34\3\34\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3"+ + "\36\3\36\3\36\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3 \3 \3 \3 \3 \3 \3 "+ + "\3 \3 \3 \3 \3 \3 \3!\3!\3!\3!\3!\3\"\3\"\3\"\3\"\3\"\3#\3#\3#\3#\3#\3"+ + "#\3#\3#\3#\3$\3$\3$\3$\3$\3$\3$\3%\3%\3%\3%\3%\3%\3%\3&\3&\3&\3&\3&\3"+ + "&\3\'\3\'\3\'\3\'\3\'\3\'\3(\3(\3(\3(\3(\3(\3)\3)\3)\3)\3*\3*\3*\3*\3"+ + "*\3*\3*\3+\3+\3+\3+\3+\3,\3,\3,\3-\3-\3-\3-\3-\3-\3-\3.\3.\3.\3.\3/\3"+ + "/\3/\3/\3/\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\60\3\61\3\61\3\61\3\61"+ + "\3\61\3\61\3\61\3\61\3\61\3\61\3\62\3\62\3\62\3\62\3\63\3\63\3\63\3\63"+ + "\3\63\3\63\3\63\3\63\3\63\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\65"+ + "\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\66\3\66\3\66\3\66\3\66\3\66"+ + "\3\66\3\66\3\66\3\67\3\67\3\67\3\67\3\67\3\67\3\67\3\67\38\38\38\38\3"+ + "8\38\38\38\38\38\39\39\39\39\39\39\39\3:\3:\3:\3:\3:\3:\3:\3:\3:\3;\3"+ + ";\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;\3;\3<\3<\3<\3<\3<\3<\3<\3"+ + "=\3=\3=\3=\3=\3=\3>\3>\3>\3>\3>\3>\3>\3?\3?\3?\3?\3?\3?\3?\3@\3@\3@\3"+ + "@\3@\3@\3@\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3A\3B\3B\3B\3B\3B\3"+ + "B\3B\3B\3B\3B\3B\3B\3C\3C\3C\3C\3C\3C\3C\3D\3D\3D\3D\3D\3D\3D\3E\3E\3"+ + "E\3E\3E\3E\3E\3E\3E\3F\3F\3F\3F\3F\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3"+ + "G\3G\3H\3H\3H\3H\3H\3H\3I\3I\3I\3I\3I\3J\3J\3J\3J\3K\3K\3K\3K\3K\3K\3"+ + "K\3K\3L\3L\3L\3L\3L\3L\3L\3M\3M\3M\3M\3M\3M\3M\3M\3M\3N\3N\3N\3N\3N\3"+ + "N\3O\3O\3O\3O\3O\3O\3O\3O\3O\3P\3P\3P\3P\3P\3P\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3"+ + "Q\3R\3R\3R\3R\3R\3S\3S\3S\3S\3S\3S\3S\3S\3S\3T\3T\3T\3T\3T\3T\3T\3T\3"+ + "U\3U\3U\3U\3U\3U\3V\3V\3W\3W\3X\3X\3Y\3Y\3Z\3Z\3[\3[\3\\\3\\\3]\3]\3^"+ + "\3^\3_\3_\3`\3`\3a\3a\3b\3b\3c\3c\3d\3d\3e\3e\3e\3e\5e\u040b\ne\3f\3f"+ + "\3g\3g\3h\3h\3i\3i\3i\3j\3j\3j\3k\3k\3k\3l\3l\3l\3m\3m\3m\3n\3n\3n\3o"+ + "\3o\3o\3p\3p\3p\3q\3q\3q\3q\3r\3r\3r\3r\3s\3s\3s\3t\3t\3t\3u\3u\3u\3v"+ + "\3v\3v\3w\3w\3w\3w\3w\5w\u0444\nw\3x\3x\3x\3x\5x\u044a\nx\3y\3y\3y\3z"+ + "\3z\3z\3{\3{\3|\3|\3|\3|\3}\3}\3}\3~\3~\3\177\3\177\3\u0080\3\u0080\3"+ + "\u0080\3\u0081\3\u0081\3\u0082\3\u0082\3\u0083\3\u0083\3\u0083\3\u0084"+ + "\3\u0084\3\u0084\3\u0084\3\u0085\3\u0085\3\u0085\3\u0085\3\u0085\3\u0086"+ + "\3\u0086\3\u0086\3\u0086\3\u0086\3\u0086\3\u0086\3\u0086\3\u0086\3\u0086"+ + "\5\u0086\u047c\n\u0086\3\u0087\3\u0087\3\u0087\7\u0087\u0481\n\u0087\f"+ + "\u0087\16\u0087\u0484\13\u0087\3\u0088\3\u0088\5\u0088\u0488\n\u0088\3"+ + "\u0089\3\u0089\3\u008a\3\u008a\3\u008b\3\u008b\5\u008b\u0490\n\u008b\3"+ + "\u008b\7\u008b\u0493\n\u008b\f\u008b\16\u008b\u0496\13\u008b\3\u008c\3"+ + "\u008c\5\u008c\u049a\n\u008c\3\u008c\7\u008c\u049d\n\u008c\f\u008c\16"+ + "\u008c\u04a0\13\u008c\3\u008d\3\u008d\3\u008d\3\u008d\5\u008d\u04a6\n"+ + "\u008d\3\u008d\3\u008d\5\u008d\u04aa\n\u008d\3\u008d\7\u008d\u04ad\n\u008d"+ + "\f\u008d\16\u008d\u04b0\13\u008d\3\u008e\3\u008e\3\u008e\3\u008e\5\u008e"+ + "\u04b6\n\u008e\3\u008e\3\u008e\5\u008e\u04ba\n\u008e\3\u008e\7\u008e\u04bd"+ + "\n\u008e\f\u008e\16\u008e\u04c0\13\u008e\3\u008f\3\u008f\3\u0090\3\u0090"+ + "\3\u0091\3\u0091\3\u0092\3\u0092\3\u0093\3\u0093\5\u0093\u04cc\n\u0093"+ + "\3\u0093\3\u0093\5\u0093\u04d0\n\u0093\3\u0093\3\u0093\5\u0093\u04d4\n"+ + "\u0093\3\u0093\3\u0093\5\u0093\u04d8\n\u0093\5\u0093\u04da\n\u0093\3\u0094"+ + "\3\u0094\3\u0095\3\u0095\3\u0096\3\u0096\3\u0096\3\u0096\5\u0096\u04e4"+ + "\n\u0096\3\u0097\3\u0097\3\u0097\5\u0097\u04e9\n\u0097\3\u0098\3\u0098"+ + "\3\u0098\5\u0098\u04ee\n\u0098\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099"+ + "\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099"+ + "\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\5\u0099\u0505"+ + "\n\u0099\3\u0099\5\u0099\u0508\n\u0099\3\u0099\3\u0099\3\u0099\3\u0099"+ + "\5\u0099\u050e\n\u0099\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a"+ + "\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\5\u009a\u051b\n\u009a\3\u009b"+ + "\3\u009b\3\u009b\3\u009b\6\u009b\u0521\n\u009b\r\u009b\16\u009b\u0522"+ + "\3\u009c\5\u009c\u0526\n\u009c\3\u009c\3\u009c\3\u009c\3\u009c\3\u009c"+ + "\5\u009c\u052d\n\u009c\3\u009d\3\u009d\5\u009d\u0531\n\u009d\3\u009d\3"+ + "\u009d\3\u009d\5\u009d\u0536\n\u009d\3\u009d\5\u009d\u0539\n\u009d\3\u009e"+ + "\3\u009e\3\u009f\3\u009f\5\u009f\u053f\n\u009f\3\u009f\7\u009f\u0542\n"+ + "\u009f\f\u009f\16\u009f\u0545\13\u009f\3\u00a0\3\u00a0\3\u00a1\3\u00a1"+ + "\3\u00a1\5\u00a1\u054c\n\u00a1\3\u00a2\3\u00a2\3\u00a2\5\u00a2\u0551\n"+ + "\u00a2\3\u00a3\3\u00a3\7\u00a3\u0555\n\u00a3\f\u00a3\16\u00a3\u0558\13"+ + "\u00a3\3\u00a3\3\u00a3\7\u00a3\u055c\n\u00a3\f\u00a3\16\u00a3\u055f\13"+ + "\u00a3\3\u00a3\3\u00a3\7\u00a3\u0563\n\u00a3\f\u00a3\16\u00a3\u0566\13"+ + "\u00a3\3\u00a3\3\u00a3\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4"+ + "\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4\5\u00a4\u0576\n\u00a4"+ + "\3\u00a5\3\u00a5\5\u00a5\u057a\n\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5"+ + "\3\u00a5\3\u00a5\5\u00a5\u0582\n\u00a5\3\u00a6\3\u00a6\3\u00a6\3\u00a7"+ + "\3\u00a7\3\u00a7\3\u00a8\3\u00a8\3\u00a9\6\u00a9\u058d\n\u00a9\r\u00a9"+ + "\16\u00a9\u058e\3\u00a9\3\u00a9\3\u00aa\3\u00aa\5\u00aa\u0595\n\u00aa"+ + "\3\u00aa\5\u00aa\u0598\n\u00aa\3\u00aa\3\u00aa\3\u00ab\3\u00ab\3\u00ab"+ + "\3\u00ab\7\u00ab\u05a0\n\u00ab\f\u00ab\16\u00ab\u05a3\13\u00ab\3\u00ab"+ + "\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ac\3\u00ac\3\u00ac\3\u00ac\7\u00ac"+ + "\u05ae\n\u00ac\f\u00ac\16\u00ac\u05b1\13\u00ac\3\u00ac\3\u00ac\4\u01a6"+ + "\u05a1\2\u00ad\3\3\5\4\7\5\t\6\13\7\r\b\17\t\21\n\23\13\25\f\27\r\31\16"+ + "\33\17\35\20\37\21!\22#\23%\24\'\25)\26+\27-\30/\31\61\32\63\33\65\34"+ + "\67\359\36;\37= ?!A\"C#E$G%I&K\'M(O)Q*S+U,W-Y.[/]\60_\61a\62c\63e\64g"+ + "\65i\66k\67m8o9q:s;u{?}@\177A\u0081B\u0083C\u0085D\u0087E\u0089F"+ + "\u008bG\u008dH\u008fI\u0091J\u0093K\u0095L\u0097M\u0099N\u009bO\u009d"+ + "P\u009fQ\u00a1R\u00a3S\u00a5T\u00a7U\u00a9V\u00abW\u00adX\u00afY\u00b1"+ + "Z\u00b3[\u00b5\\\u00b7]\u00b9^\u00bb_\u00bd`\u00bfa\u00c1b\u00c3c\u00c5"+ + "d\u00c7e\u00c9f\u00cbg\u00cdh\u00cfi\u00d1j\u00d3k\u00d5l\u00d7m\u00d9"+ + "n\u00dbo\u00ddp\u00dfq\u00e1r\u00e3s\u00e5t\u00e7u\u00e9v\u00ebw\u00ed"+ + "x\u00efy\u00f1z\u00f3{\u00f5|\u00f7}\u00f9~\u00fb\177\u00fd\u0080\u00ff"+ + "\u0081\u0101\u0082\u0103\u0083\u0105\u0084\u0107\u0085\u0109\2\u010b\2"+ + "\u010d\u0086\u010f\2\u0111\2\u0113\2\u0115\u0087\u0117\u0088\u0119\u0089"+ + "\u011b\u008a\u011d\2\u011f\2\u0121\2\u0123\2\u0125\u008b\u0127\2\u0129"+ + "\2\u012b\2\u012d\2\u012f\2\u0131\2\u0133\2\u0135\2\u0137\2\u0139\2\u013b"+ + "\2\u013d\2\u013f\2\u0141\2\u0143\2\u0145\2\u0147\u008c\u0149\u008d\u014b"+ + "\u008e\u014d\u008f\u014f\2\u0151\u0090\u0153\u0091\u0155\u0092\u0157\u0093"+ + "\3\2\25\5\2NNWWww\3\2\f\f\5\2C\\aac|\3\2\62;\3\2\63;\3\2\629\5\2\62;C"+ + "Hch\3\2\62\63\4\2WWww\4\2NNnn\6\2\f\f\17\17))^^\4\2--//\6\2HHNNhhnn\6"+ + "\2\f\f\17\17$$^^\5\2\f\f\17\17**\5\2\f\f\17\17++\5\2\f\f\17\17$$\4\2\13"+ + "\13\"\"\4\2\f\f\17\17\2\u05f7\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3\2\2\2\2\t"+ + "\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2"+ + "\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2\2\2\2"+ + "\37\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2\2\'\3\2\2\2\2)\3\2\2\2\2"+ + "+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2\2\2\2\63\3\2\2\2\2\65\3\2\2\2"+ + "\2\67\3\2\2\2\29\3\2\2\2\2;\3\2\2\2\2=\3\2\2\2\2?\3\2\2\2\2A\3\2\2\2\2"+ + "C\3\2\2\2\2E\3\2\2\2\2G\3\2\2\2\2I\3\2\2\2\2K\3\2\2\2\2M\3\2\2\2\2O\3"+ + "\2\2\2\2Q\3\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2W\3\2\2\2\2Y\3\2\2\2\2[\3\2\2"+ + "\2\2]\3\2\2\2\2_\3\2\2\2\2a\3\2\2\2\2c\3\2\2\2\2e\3\2\2\2\2g\3\2\2\2\2"+ + "i\3\2\2\2\2k\3\2\2\2\2m\3\2\2\2\2o\3\2\2\2\2q\3\2\2\2\2s\3\2\2\2\2u\3"+ + "\2\2\2\2w\3\2\2\2\2y\3\2\2\2\2{\3\2\2\2\2}\3\2\2\2\2\177\3\2\2\2\2\u0081"+ + "\3\2\2\2\2\u0083\3\2\2\2\2\u0085\3\2\2\2\2\u0087\3\2\2\2\2\u0089\3\2\2"+ + "\2\2\u008b\3\2\2\2\2\u008d\3\2\2\2\2\u008f\3\2\2\2\2\u0091\3\2\2\2\2\u0093"+ + "\3\2\2\2\2\u0095\3\2\2\2\2\u0097\3\2\2\2\2\u0099\3\2\2\2\2\u009b\3\2\2"+ + "\2\2\u009d\3\2\2\2\2\u009f\3\2\2\2\2\u00a1\3\2\2\2\2\u00a3\3\2\2\2\2\u00a5"+ + "\3\2\2\2\2\u00a7\3\2\2\2\2\u00a9\3\2\2\2\2\u00ab\3\2\2\2\2\u00ad\3\2\2"+ + "\2\2\u00af\3\2\2\2\2\u00b1\3\2\2\2\2\u00b3\3\2\2\2\2\u00b5\3\2\2\2\2\u00b7"+ + "\3\2\2\2\2\u00b9\3\2\2\2\2\u00bb\3\2\2\2\2\u00bd\3\2\2\2\2\u00bf\3\2\2"+ + "\2\2\u00c1\3\2\2\2\2\u00c3\3\2\2\2\2\u00c5\3\2\2\2\2\u00c7\3\2\2\2\2\u00c9"+ + "\3\2\2\2\2\u00cb\3\2\2\2\2\u00cd\3\2\2\2\2\u00cf\3\2\2\2\2\u00d1\3\2\2"+ + "\2\2\u00d3\3\2\2\2\2\u00d5\3\2\2\2\2\u00d7\3\2\2\2\2\u00d9\3\2\2\2\2\u00db"+ + "\3\2\2\2\2\u00dd\3\2\2\2\2\u00df\3\2\2\2\2\u00e1\3\2\2\2\2\u00e3\3\2\2"+ + "\2\2\u00e5\3\2\2\2\2\u00e7\3\2\2\2\2\u00e9\3\2\2\2\2\u00eb\3\2\2\2\2\u00ed"+ + "\3\2\2\2\2\u00ef\3\2\2\2\2\u00f1\3\2\2\2\2\u00f3\3\2\2\2\2\u00f5\3\2\2"+ + "\2\2\u00f7\3\2\2\2\2\u00f9\3\2\2\2\2\u00fb\3\2\2\2\2\u00fd\3\2\2\2\2\u00ff"+ + "\3\2\2\2\2\u0101\3\2\2\2\2\u0103\3\2\2\2\2\u0105\3\2\2\2\2\u0107\3\2\2"+ + "\2\2\u010d\3\2\2\2\2\u0115\3\2\2\2\2\u0117\3\2\2\2\2\u0119\3\2\2\2\2\u011b"+ + "\3\2\2\2\2\u0125\3\2\2\2\2\u0147\3\2\2\2\2\u0149\3\2\2\2\2\u014b\3\2\2"+ + "\2\2\u014d\3\2\2\2\2\u0151\3\2\2\2\2\u0153\3\2\2\2\2\u0155\3\2\2\2\2\u0157"+ + "\3\2\2\2\3\u0169\3\2\2\2\5\u016c\3\2\2\2\7\u0182\3\2\2\2\t\u0194\3\2\2"+ + "\2\13\u0198\3\2\2\2\r\u019a\3\2\2\2\17\u01a0\3\2\2\2\21\u01a2\3\2\2\2"+ + "\23\u01b9\3\2\2\2\25\u01c2\3\2\2\2\27\u01ca\3\2\2\2\31\u01d2\3\2\2\2\33"+ + "\u01d6\3\2\2\2\35\u01db\3\2\2\2\37\u01e0\3\2\2\2!\u01e6\3\2\2\2#\u01eb"+ + "\3\2\2\2%\u01f1\3\2\2\2\'\u01f6\3\2\2\2)\u01ff\3\2\2\2+\u0208\3\2\2\2"+ + "-\u020e\3\2\2\2/\u0214\3\2\2\2\61\u021e\3\2\2\2\63\u0229\3\2\2\2\65\u0232"+ + "\3\2\2\2\67\u023b\3\2\2\29\u0243\3\2\2\2;\u024a\3\2\2\2=\u024d\3\2\2\2"+ + "?\u0254\3\2\2\2A\u0261\3\2\2\2C\u0266\3\2\2\2E\u026b\3\2\2\2G\u0274\3"+ + "\2\2\2I\u027b\3\2\2\2K\u0282\3\2\2\2M\u0288\3\2\2\2O\u028e\3\2\2\2Q\u0294"+ + "\3\2\2\2S\u0298\3\2\2\2U\u029f\3\2\2\2W\u02a4\3\2\2\2Y\u02a7\3\2\2\2["+ + "\u02ae\3\2\2\2]\u02b2\3\2\2\2_\u02b7\3\2\2\2a\u02bf\3\2\2\2c\u02c9\3\2"+ + "\2\2e\u02cd\3\2\2\2g\u02d6\3\2\2\2i\u02de\3\2\2\2k\u02e7\3\2\2\2m\u02f0"+ + "\3\2\2\2o\u02f8\3\2\2\2q\u0302\3\2\2\2s\u0309\3\2\2\2u\u0312\3\2\2\2w"+ + "\u0323\3\2\2\2y\u032a\3\2\2\2{\u0330\3\2\2\2}\u0337\3\2\2\2\177\u033e"+ + "\3\2\2\2\u0081\u0345\3\2\2\2\u0083\u0353\3\2\2\2\u0085\u035f\3\2\2\2\u0087"+ + "\u0366\3\2\2\2\u0089\u036d\3\2\2\2\u008b\u0376\3\2\2\2\u008d\u037b\3\2"+ + "\2\2\u008f\u0388\3\2\2\2\u0091\u038e\3\2\2\2\u0093\u0393\3\2\2\2\u0095"+ + "\u0397\3\2\2\2\u0097\u039f\3\2\2\2\u0099\u03a6\3\2\2\2\u009b\u03af\3\2"+ + "\2\2\u009d\u03b5\3\2\2\2\u009f\u03be\3\2\2\2\u00a1\u03c4\3\2\2\2\u00a3"+ + "\u03cc\3\2\2\2\u00a5\u03d1\3\2\2\2\u00a7\u03da\3\2\2\2\u00a9\u03e2\3\2"+ + "\2\2\u00ab\u03e8\3\2\2\2\u00ad\u03ea\3\2\2\2\u00af\u03ec\3\2\2\2\u00b1"+ + "\u03ee\3\2\2\2\u00b3\u03f0\3\2\2\2\u00b5\u03f2\3\2\2\2\u00b7\u03f4\3\2"+ + "\2\2\u00b9\u03f6\3\2\2\2\u00bb\u03f8\3\2\2\2\u00bd\u03fa\3\2\2\2\u00bf"+ + "\u03fc\3\2\2\2\u00c1\u03fe\3\2\2\2\u00c3\u0400\3\2\2\2\u00c5\u0402\3\2"+ + "\2\2\u00c7\u0404\3\2\2\2\u00c9\u040a\3\2\2\2\u00cb\u040c\3\2\2\2\u00cd"+ + "\u040e\3\2\2\2\u00cf\u0410\3\2\2\2\u00d1\u0412\3\2\2\2\u00d3\u0415\3\2"+ + "\2\2\u00d5\u0418\3\2\2\2\u00d7\u041b\3\2\2\2\u00d9\u041e\3\2\2\2\u00db"+ + "\u0421\3\2\2\2\u00dd\u0424\3\2\2\2\u00df\u0427\3\2\2\2\u00e1\u042a\3\2"+ + "\2\2\u00e3\u042e\3\2\2\2\u00e5\u0432\3\2\2\2\u00e7\u0435\3\2\2\2\u00e9"+ + "\u0438\3\2\2\2\u00eb\u043b\3\2\2\2\u00ed\u0443\3\2\2\2\u00ef\u0449\3\2"+ + "\2\2\u00f1\u044b\3\2\2\2\u00f3\u044e\3\2\2\2\u00f5\u0451\3\2\2\2\u00f7"+ + "\u0453\3\2\2\2\u00f9\u0457\3\2\2\2\u00fb\u045a\3\2\2\2\u00fd\u045c\3\2"+ + "\2\2\u00ff\u045e\3\2\2\2\u0101\u0461\3\2\2\2\u0103\u0463\3\2\2\2\u0105"+ + "\u0465\3\2\2\2\u0107\u0468\3\2\2\2\u0109\u046c\3\2\2\2\u010b\u047b\3\2"+ + "\2\2\u010d\u047d\3\2\2\2\u010f\u0487\3\2\2\2\u0111\u0489\3\2\2\2\u0113"+ + "\u048b\3\2\2\2\u0115\u048d\3\2\2\2\u0117\u0497\3\2\2\2\u0119\u04a5\3\2"+ + "\2\2\u011b\u04b5\3\2\2\2\u011d\u04c1\3\2\2\2\u011f\u04c3\3\2\2\2\u0121"+ + "\u04c5\3\2\2\2\u0123\u04c7\3\2\2\2\u0125\u04d9\3\2\2\2\u0127\u04db\3\2"+ + "\2\2\u0129\u04dd\3\2\2\2\u012b\u04e3\3\2\2\2\u012d\u04e8\3\2\2\2\u012f"+ + "\u04ed\3\2\2\2\u0131\u050d\3\2\2\2\u0133\u051a\3\2\2\2\u0135\u051c\3\2"+ + "\2\2\u0137\u052c\3\2\2\2\u0139\u0538\3\2\2\2\u013b\u053a\3\2\2\2\u013d"+ + "\u053c\3\2\2\2\u013f\u0546\3\2\2\2\u0141\u054b\3\2\2\2\u0143\u0550\3\2"+ + "\2\2\u0145\u0552\3\2\2\2\u0147\u0575\3\2\2\2\u0149\u0581\3\2\2\2\u014b"+ + "\u0583\3\2\2\2\u014d\u0586\3\2\2\2\u014f\u0589\3\2\2\2\u0151\u058c\3\2"+ + "\2\2\u0153\u0597\3\2\2\2\u0155\u059b\3\2\2\2\u0157\u05a9\3\2\2\2\u0159"+ + "\u015b\5\u0115\u008b\2\u015a\u015c\5\u0125\u0093\2\u015b\u015a\3\2\2\2"+ + "\u015b\u015c\3\2\2\2\u015c\u016a\3\2\2\2\u015d\u015f\5\u0117\u008c\2\u015e"+ + "\u0160\5\u0125\u0093\2\u015f\u015e\3\2\2\2\u015f\u0160\3\2\2\2\u0160\u016a"+ + "\3\2\2\2\u0161\u0163\5\u0119\u008d\2\u0162\u0164\5\u0125\u0093\2\u0163"+ + "\u0162\3\2\2\2\u0163\u0164\3\2\2\2\u0164\u016a\3\2\2\2\u0165\u0167\5\u011b"+ + "\u008e\2\u0166\u0168\5\u0125\u0093\2\u0167\u0166\3\2\2\2\u0167\u0168\3"+ + "\2\2\2\u0168\u016a\3\2\2\2\u0169\u0159\3\2\2\2\u0169\u015d\3\2\2\2\u0169"+ + "\u0161\3\2\2\2\u0169\u0165\3\2\2\2\u016a\4\3\2\2\2\u016b\u016d\t\2\2\2"+ + "\u016c\u016b\3\2\2\2\u016c\u016d\3\2\2\2\u016d\u016e\3\2\2\2\u016e\u0170"+ + "\7)\2\2\u016f\u0171\5\u012d\u0097\2\u0170\u016f\3\2\2\2\u0171\u0172\3"+ + "\2\2\2\u0172\u0170\3\2\2\2\u0172\u0173\3\2\2\2\u0173\u0174\3\2\2\2\u0174"+ + "\u0175\7)\2\2\u0175\6\3\2\2\2\u0176\u0178\5\u0137\u009c\2\u0177\u0179"+ + "\5\u0139\u009d\2\u0178\u0177\3\2\2\2\u0178\u0179\3\2\2\2\u0179\u017b\3"+ + "\2\2\2\u017a\u017c\5\u013f\u00a0\2\u017b\u017a\3\2\2\2\u017b\u017c\3\2"+ + "\2\2\u017c\u0183\3\2\2\2\u017d\u017e\5\u013d\u009f\2\u017e\u0180\5\u0139"+ + "\u009d\2\u017f\u0181\5\u013f\u00a0\2\u0180\u017f\3\2\2\2\u0180\u0181\3"+ + "\2\2\2\u0181\u0183\3\2\2\2\u0182\u0176\3\2\2\2\u0182\u017d\3\2\2\2\u0183"+ + "\b\3\2\2\2\u0184\u0186\5\u0141\u00a1\2\u0185\u0184\3\2\2\2\u0185\u0186"+ + "\3\2\2\2\u0186\u0187\3\2\2\2\u0187\u018b\7$\2\2\u0188\u018a\5\u0143\u00a2"+ + "\2\u0189\u0188\3\2\2\2\u018a\u018d\3\2\2\2\u018b\u0189\3\2\2\2\u018b\u018c"+ + "\3\2\2\2\u018c\u018e\3\2\2\2\u018d\u018b\3\2\2\2\u018e\u0195\7$\2\2\u018f"+ + "\u0191\5\u0141\u00a1\2\u0190\u018f\3\2\2\2\u0190\u0191\3\2\2\2\u0191\u0192"+ + "\3\2\2\2\u0192\u0193\7T\2\2\u0193\u0195\5\u0145\u00a3\2\u0194\u0185\3"+ + "\2\2\2\u0194\u0190\3\2\2\2\u0195\n\3\2\2\2\u0196\u0199\5K&\2\u0197\u0199"+ + "\5\u0091I\2\u0198\u0196\3\2\2\2\u0198\u0197\3\2\2\2\u0199\f\3\2\2\2\u019a"+ + "\u019b\5g\64\2\u019b\16\3\2\2\2\u019c\u01a1\5\u0147\u00a4\2\u019d\u01a1"+ + "\5\u0149\u00a5\2\u019e\u01a1\5\u014b\u00a6\2\u019f\u01a1\5\u014d\u00a7"+ + "\2\u01a0\u019c\3\2\2\2\u01a0\u019d\3\2\2\2\u01a0\u019e\3\2\2\2\u01a0\u019f"+ + "\3\2\2\2\u01a1\20\3\2\2\2\u01a2\u01ae\7%\2\2\u01a3\u01a5\n\3\2\2\u01a4"+ + "\u01a3\3\2\2\2\u01a5\u01a8\3\2\2\2\u01a6\u01a7\3\2\2\2\u01a6\u01a4\3\2"+ + "\2\2\u01a7\u01a9\3\2\2\2\u01a8\u01a6\3\2\2\2\u01a9\u01ab\7^\2\2\u01aa"+ + "\u01ac\7\17\2\2\u01ab\u01aa\3\2\2\2\u01ab\u01ac\3\2\2\2\u01ac\u01ad\3"+ + "\2\2\2\u01ad\u01af\7\f\2\2\u01ae\u01a6\3\2\2\2\u01af\u01b0\3\2\2\2\u01b0"+ + "\u01ae\3\2\2\2\u01b0\u01b1\3\2\2\2\u01b1\u01b3\3\2\2\2\u01b2\u01b4\n\3"+ + "\2\2\u01b3\u01b2\3\2\2\2\u01b4\u01b5\3\2\2\2\u01b5\u01b3\3\2\2\2\u01b5"+ + "\u01b6\3\2\2\2\u01b6\u01b7\3\2\2\2\u01b7\u01b8\b\t\2\2\u01b8\22\3\2\2"+ + "\2\u01b9\u01bd\7%\2\2\u01ba\u01bc\n\3\2\2\u01bb\u01ba\3\2\2\2\u01bc\u01bf"+ + "\3\2\2\2\u01bd\u01bb\3\2\2\2\u01bd\u01be\3\2\2\2\u01be\u01c0\3\2\2\2\u01bf"+ + "\u01bd\3\2\2\2\u01c0\u01c1\b\n\2\2\u01c1\24\3\2\2\2\u01c2\u01c3\7c\2\2"+ + "\u01c3\u01c4\7n\2\2\u01c4\u01c5\7k\2\2\u01c5\u01c6\7i\2\2\u01c6\u01c7"+ + "\7p\2\2\u01c7\u01c8\7c\2\2\u01c8\u01c9\7u\2\2\u01c9\26\3\2\2\2\u01ca\u01cb"+ + "\7c\2\2\u01cb\u01cc\7n\2\2\u01cc\u01cd\7k\2\2\u01cd\u01ce\7i\2\2\u01ce"+ + "\u01cf\7p\2\2\u01cf\u01d0\7q\2\2\u01d0\u01d1\7h\2\2\u01d1\30\3\2\2\2\u01d2"+ + "\u01d3\7c\2\2\u01d3\u01d4\7u\2\2\u01d4\u01d5\7o\2\2\u01d5\32\3\2\2\2\u01d6"+ + "\u01d7\7c\2\2\u01d7\u01d8\7w\2\2\u01d8\u01d9\7v\2\2\u01d9\u01da\7q\2\2"+ + "\u01da\34\3\2\2\2\u01db\u01dc\7d\2\2\u01dc\u01dd\7q\2\2\u01dd\u01de\7"+ + "q\2\2\u01de\u01df\7n\2\2\u01df\36\3\2\2\2\u01e0\u01e1\7d\2\2\u01e1\u01e2"+ + "\7t\2\2\u01e2\u01e3\7g\2\2\u01e3\u01e4\7c\2\2\u01e4\u01e5\7m\2\2\u01e5"+ + " \3\2\2\2\u01e6\u01e7\7e\2\2\u01e7\u01e8\7c\2\2\u01e8\u01e9\7u\2\2\u01e9"+ + "\u01ea\7g\2\2\u01ea\"\3\2\2\2\u01eb\u01ec\7e\2\2\u01ec\u01ed\7c\2\2\u01ed"+ + "\u01ee\7v\2\2\u01ee\u01ef\7e\2\2\u01ef\u01f0\7j\2\2\u01f0$\3\2\2\2\u01f1"+ + "\u01f2\7e\2\2\u01f2\u01f3\7j\2\2\u01f3\u01f4\7c\2\2\u01f4\u01f5\7t\2\2"+ + "\u01f5&\3\2\2\2\u01f6\u01f7\7e\2\2\u01f7\u01f8\7j\2\2\u01f8\u01f9\7c\2"+ + "\2\u01f9\u01fa\7t\2\2\u01fa\u01fb\7\63\2\2\u01fb\u01fc\78\2\2\u01fc\u01fd"+ + "\7a\2\2\u01fd\u01fe\7v\2\2\u01fe(\3\2\2\2\u01ff\u0200\7e\2\2\u0200\u0201"+ + "\7j\2\2\u0201\u0202\7c\2\2\u0202\u0203\7t\2\2\u0203\u0204\7\65\2\2\u0204"+ + "\u0205\7\64\2\2\u0205\u0206\7a\2\2\u0206\u0207\7v\2\2\u0207*\3\2\2\2\u0208"+ + "\u0209\7e\2\2\u0209\u020a\7n\2\2\u020a\u020b\7c\2\2\u020b\u020c\7u\2\2"+ + "\u020c\u020d\7u\2\2\u020d,\3\2\2\2\u020e\u020f\7e\2\2\u020f\u0210\7q\2"+ + "\2\u0210\u0211\7p\2\2\u0211\u0212\7u\2\2\u0212\u0213\7v\2\2\u0213.\3\2"+ + "\2\2\u0214\u0215\7e\2\2\u0215\u0216\7q\2\2\u0216\u0217\7p\2\2\u0217\u0218"+ + "\7u\2\2\u0218\u0219\7v\2\2\u0219\u021a\7g\2\2\u021a\u021b\7z\2\2\u021b"+ + "\u021c\7r\2\2\u021c\u021d\7t\2\2\u021d\60\3\2\2\2\u021e\u021f\7e\2\2\u021f"+ + "\u0220\7q\2\2\u0220\u0221\7p\2\2\u0221\u0222\7u\2\2\u0222\u0223\7v\2\2"+ + "\u0223\u0224\7a\2\2\u0224\u0225\7e\2\2\u0225\u0226\7c\2\2\u0226\u0227"+ + "\7u\2\2\u0227\u0228\7v\2\2\u0228\62\3\2\2\2\u0229\u022a\7e\2\2\u022a\u022b"+ + "\7q\2\2\u022b\u022c\7p\2\2\u022c\u022d\7v\2\2\u022d\u022e\7k\2\2\u022e"+ + "\u022f\7p\2\2\u022f\u0230\7w\2\2\u0230\u0231\7g\2\2\u0231\64\3\2\2\2\u0232"+ + "\u0233\7f\2\2\u0233\u0234\7g\2\2\u0234\u0235\7e\2\2\u0235\u0236\7n\2\2"+ + "\u0236\u0237\7v\2\2\u0237\u0238\7{\2\2\u0238\u0239\7r\2\2\u0239\u023a"+ + "\7g\2\2\u023a\66\3\2\2\2\u023b\u023c\7f\2\2\u023c\u023d\7g\2\2\u023d\u023e"+ + "\7h\2\2\u023e\u023f\7c\2\2\u023f\u0240\7w\2\2\u0240\u0241\7n\2\2\u0241"+ + "\u0242\7v\2\2\u02428\3\2\2\2\u0243\u0244\7f\2\2\u0244\u0245\7g\2\2\u0245"+ + "\u0246\7n\2\2\u0246\u0247\7g\2\2\u0247\u0248\7v\2\2\u0248\u0249\7g\2\2"+ + "\u0249:\3\2\2\2\u024a\u024b\7f\2\2\u024b\u024c\7q\2\2\u024c<\3\2\2\2\u024d"+ + "\u024e\7f\2\2\u024e\u024f\7q\2\2\u024f\u0250\7w\2\2\u0250\u0251\7d\2\2"+ + "\u0251\u0252\7n\2\2\u0252\u0253\7g\2\2\u0253>\3\2\2\2\u0254\u0255\7f\2"+ + "\2\u0255\u0256\7{\2\2\u0256\u0257\7p\2\2\u0257\u0258\7c\2\2\u0258\u0259"+ + "\7o\2\2\u0259\u025a\7k\2\2\u025a\u025b\7e\2\2\u025b\u025c\7a\2\2\u025c"+ + "\u025d\7e\2\2\u025d\u025e\7c\2\2\u025e\u025f\7u\2\2\u025f\u0260\7v\2\2"+ + "\u0260@\3\2\2\2\u0261\u0262\7g\2\2\u0262\u0263\7n\2\2\u0263\u0264\7u\2"+ + "\2\u0264\u0265\7g\2\2\u0265B\3\2\2\2\u0266\u0267\7g\2\2\u0267\u0268\7"+ + "p\2\2\u0268\u0269\7w\2\2\u0269\u026a\7o\2\2\u026aD\3\2\2\2\u026b\u026c"+ + "\7g\2\2\u026c\u026d\7z\2\2\u026d\u026e\7r\2\2\u026e\u026f\7n\2\2\u026f"+ + "\u0270\7k\2\2\u0270\u0271\7e\2\2\u0271\u0272\7k\2\2\u0272\u0273\7v\2\2"+ + "\u0273F\3\2\2\2\u0274\u0275\7g\2\2\u0275\u0276\7z\2\2\u0276\u0277\7r\2"+ + "\2\u0277\u0278\7q\2\2\u0278\u0279\7t\2\2\u0279\u027a\7v\2\2\u027aH\3\2"+ + "\2\2\u027b\u027c\7g\2\2\u027c\u027d\7z\2\2\u027d\u027e\7v\2\2\u027e\u027f"+ + "\7g\2\2\u027f\u0280\7t\2\2\u0280\u0281\7p\2\2\u0281J\3\2\2\2\u0282\u0283"+ + "\7h\2\2\u0283\u0284\7c\2\2\u0284\u0285\7n\2\2\u0285\u0286\7u\2\2\u0286"+ + "\u0287\7g\2\2\u0287L\3\2\2\2\u0288\u0289\7h\2\2\u0289\u028a\7k\2\2\u028a"+ + "\u028b\7p\2\2\u028b\u028c\7c\2\2\u028c\u028d\7n\2\2\u028dN\3\2\2\2\u028e"+ + "\u028f\7h\2\2\u028f\u0290\7n\2\2\u0290\u0291\7q\2\2\u0291\u0292\7c\2\2"+ + "\u0292\u0293\7v\2\2\u0293P\3\2\2\2\u0294\u0295\7h\2\2\u0295\u0296\7q\2"+ + "\2\u0296\u0297\7t\2\2\u0297R\3\2\2\2\u0298\u0299\7h\2\2\u0299\u029a\7"+ + "t\2\2\u029a\u029b\7k\2\2\u029b\u029c\7g\2\2\u029c\u029d\7p\2\2\u029d\u029e"+ + "\7f\2\2\u029eT\3\2\2\2\u029f\u02a0\7i\2\2\u02a0\u02a1\7q\2\2\u02a1\u02a2"+ + "\7v\2\2\u02a2\u02a3\7q\2\2\u02a3V\3\2\2\2\u02a4\u02a5\7k\2\2\u02a5\u02a6"+ + "\7h\2\2\u02a6X\3\2\2\2\u02a7\u02a8\7k\2\2\u02a8\u02a9\7p\2\2\u02a9\u02aa"+ + "\7n\2\2\u02aa\u02ab\7k\2\2\u02ab\u02ac\7p\2\2\u02ac\u02ad\7g\2\2\u02ad"+ + "Z\3\2\2\2\u02ae\u02af\7k\2\2\u02af\u02b0\7p\2\2\u02b0\u02b1\7v\2\2\u02b1"+ + "\\\3\2\2\2\u02b2\u02b3\7n\2\2\u02b3\u02b4\7q\2\2\u02b4\u02b5\7p\2\2\u02b5"+ + "\u02b6\7i\2\2\u02b6^\3\2\2\2\u02b7\u02b8\7o\2\2\u02b8\u02b9\7w\2\2\u02b9"+ + "\u02ba\7v\2\2\u02ba\u02bb\7c\2\2\u02bb\u02bc\7d\2\2\u02bc\u02bd\7n\2\2"+ + "\u02bd\u02be\7g\2\2\u02be`\3\2\2\2\u02bf\u02c0\7p\2\2\u02c0\u02c1\7c\2"+ + "\2\u02c1\u02c2\7o\2\2\u02c2\u02c3\7g\2\2\u02c3\u02c4\7u\2\2\u02c4\u02c5"+ + "\7r\2\2\u02c5\u02c6\7c\2\2\u02c6\u02c7\7e\2\2\u02c7\u02c8\7g\2\2\u02c8"+ + "b\3\2\2\2\u02c9\u02ca\7p\2\2\u02ca\u02cb\7g\2\2\u02cb\u02cc\7y\2\2\u02cc"+ + "d\3\2\2\2\u02cd\u02ce\7p\2\2\u02ce\u02cf\7q\2\2\u02cf\u02d0\7g\2\2\u02d0"+ + "\u02d1\7z\2\2\u02d1\u02d2\7e\2\2\u02d2\u02d3\7g\2\2\u02d3\u02d4\7r\2\2"+ + "\u02d4\u02d5\7v\2\2\u02d5f\3\2\2\2\u02d6\u02d7\7p\2\2\u02d7\u02d8\7w\2"+ + "\2\u02d8\u02d9\7n\2\2\u02d9\u02da\7n\2\2\u02da\u02db\7r\2\2\u02db\u02dc"+ + "\7v\2\2\u02dc\u02dd\7t\2\2\u02ddh\3\2\2\2\u02de\u02df\7q\2\2\u02df\u02e0"+ + "\7r\2\2\u02e0\u02e1\7g\2\2\u02e1\u02e2\7t\2\2\u02e2\u02e3\7c\2\2\u02e3"+ + "\u02e4\7v\2\2\u02e4\u02e5\7q\2\2\u02e5\u02e6\7t\2\2\u02e6j\3\2\2\2\u02e7"+ + "\u02e8\7q\2\2\u02e8\u02e9\7x\2\2\u02e9\u02ea\7g\2\2\u02ea\u02eb\7t\2\2"+ + "\u02eb\u02ec\7t\2\2\u02ec\u02ed\7k\2\2\u02ed\u02ee\7f\2\2\u02ee\u02ef"+ + "\7g\2\2\u02efl\3\2\2\2\u02f0\u02f1\7r\2\2\u02f1\u02f2\7t\2\2\u02f2\u02f3"+ + "\7k\2\2\u02f3\u02f4\7x\2\2\u02f4\u02f5\7c\2\2\u02f5\u02f6\7v\2\2\u02f6"+ + "\u02f7\7g\2\2\u02f7n\3\2\2\2\u02f8\u02f9\7r\2\2\u02f9\u02fa\7t\2\2\u02fa"+ + "\u02fb\7q\2\2\u02fb\u02fc\7v\2\2\u02fc\u02fd\7g\2\2\u02fd\u02fe\7e\2\2"+ + "\u02fe\u02ff\7v\2\2\u02ff\u0300\7g\2\2\u0300\u0301\7f\2\2\u0301p\3\2\2"+ + "\2\u0302\u0303\7r\2\2\u0303\u0304\7w\2\2\u0304\u0305\7d\2\2\u0305\u0306"+ + "\7n\2\2\u0306\u0307\7k\2\2\u0307\u0308\7e\2\2\u0308r\3\2\2\2\u0309\u030a"+ + "\7t\2\2\u030a\u030b\7g\2\2\u030b\u030c\7i\2\2\u030c\u030d\7k\2\2\u030d"+ + "\u030e\7u\2\2\u030e\u030f\7v\2\2\u030f\u0310\7g\2\2\u0310\u0311\7t\2\2"+ + "\u0311t\3\2\2\2\u0312\u0313\7t\2\2\u0313\u0314\7g\2\2\u0314\u0315\7k\2"+ + "\2\u0315\u0316\7p\2\2\u0316\u0317\7v\2\2\u0317\u0318\7g\2\2\u0318\u0319"+ + "\7t\2\2\u0319\u031a\7r\2\2\u031a\u031b\7t\2\2\u031b\u031c\7g\2\2\u031c"+ + "\u031d\7v\2\2\u031d\u031e\7a\2\2\u031e\u031f\7e\2\2\u031f\u0320\7c\2\2"+ + "\u0320\u0321\7u\2\2\u0321\u0322\7v\2\2\u0322v\3\2\2\2\u0323\u0324\7t\2"+ + "\2\u0324\u0325\7g\2\2\u0325\u0326\7v\2\2\u0326\u0327\7w\2\2\u0327\u0328"+ + "\7t\2\2\u0328\u0329\7p\2\2\u0329x\3\2\2\2\u032a\u032b\7u\2\2\u032b\u032c"+ + "\7j\2\2\u032c\u032d\7q\2\2\u032d\u032e\7t\2\2\u032e\u032f\7v\2\2\u032f"+ + "z\3\2\2\2\u0330\u0331\7u\2\2\u0331\u0332\7k\2\2\u0332\u0333\7i\2\2\u0333"+ + "\u0334\7p\2\2\u0334\u0335\7g\2\2\u0335\u0336\7f\2\2\u0336|\3\2\2\2\u0337"+ + "\u0338\7u\2\2\u0338\u0339\7k\2\2\u0339\u033a\7|\2\2\u033a\u033b\7g\2\2"+ + "\u033b\u033c\7q\2\2\u033c\u033d\7h\2\2\u033d~\3\2\2\2\u033e\u033f\7u\2"+ + "\2\u033f\u0340\7v\2\2\u0340\u0341\7c\2\2\u0341\u0342\7v\2\2\u0342\u0343"+ + "\7k\2\2\u0343\u0344\7e\2\2\u0344\u0080\3\2\2\2\u0345\u0346\7u\2\2\u0346"+ + "\u0347\7v\2\2\u0347\u0348\7c\2\2\u0348\u0349\7v\2\2\u0349\u034a\7k\2\2"+ + "\u034a\u034b\7e\2\2\u034b\u034c\7a\2\2\u034c\u034d\7c\2\2\u034d\u034e"+ + "\7u\2\2\u034e\u034f\7u\2\2\u034f\u0350\7g\2\2\u0350\u0351\7t\2\2\u0351"+ + "\u0352\7v\2\2\u0352\u0082\3\2\2\2\u0353\u0354\7u\2\2\u0354\u0355\7v\2"+ + "\2\u0355\u0356\7c\2\2\u0356\u0357\7v\2\2\u0357\u0358\7k\2\2\u0358\u0359"+ + "\7e\2\2\u0359\u035a\7a\2\2\u035a\u035b\7e\2\2\u035b\u035c\7c\2\2\u035c"+ + "\u035d\7u\2\2\u035d\u035e\7v\2\2\u035e\u0084\3\2\2\2\u035f\u0360\7u\2"+ + "\2\u0360\u0361\7v\2\2\u0361\u0362\7t\2\2\u0362\u0363\7w\2\2\u0363\u0364"+ + "\7e\2\2\u0364\u0365\7v\2\2\u0365\u0086\3\2\2\2\u0366\u0367\7u\2\2\u0367"+ + "\u0368\7y\2\2\u0368\u0369\7k\2\2\u0369\u036a\7v\2\2\u036a\u036b\7e\2\2"+ + "\u036b\u036c\7j\2\2\u036c\u0088\3\2\2\2\u036d\u036e\7v\2\2\u036e\u036f"+ + "\7g\2\2\u036f\u0370\7o\2\2\u0370\u0371\7r\2\2\u0371\u0372\7n\2\2\u0372"+ + "\u0373\7c\2\2\u0373\u0374\7v\2\2\u0374\u0375\7g\2\2\u0375\u008a\3\2\2"+ + "\2\u0376\u0377\7v\2\2\u0377\u0378\7j\2\2\u0378\u0379\7k\2\2\u0379\u037a"+ + "\7u\2\2\u037a\u008c\3\2\2\2\u037b\u037c\7v\2\2\u037c\u037d\7j\2\2\u037d"+ + "\u037e\7t\2\2\u037e\u037f\7g\2\2\u037f\u0380\7c\2\2\u0380\u0381\7f\2\2"+ + "\u0381\u0382\7a\2\2\u0382\u0383\7n\2\2\u0383\u0384\7q\2\2\u0384\u0385"+ + "\7e\2\2\u0385\u0386\7c\2\2\u0386\u0387\7n\2\2\u0387\u008e\3\2\2\2\u0388"+ + "\u0389\7v\2\2\u0389\u038a\7j\2\2\u038a\u038b\7t\2\2\u038b\u038c\7q\2\2"+ + "\u038c\u038d\7y\2\2\u038d\u0090\3\2\2\2\u038e\u038f\7v\2\2\u038f\u0390"+ + "\7t\2\2\u0390\u0391\7w\2\2\u0391\u0392\7g\2\2\u0392\u0092\3\2\2\2\u0393"+ + "\u0394\7v\2\2\u0394\u0395\7t\2\2\u0395\u0396\7{\2\2\u0396\u0094\3\2\2"+ + "\2\u0397\u0398\7v\2\2\u0398\u0399\7{\2\2\u0399\u039a\7r\2\2\u039a\u039b"+ + "\7g\2\2\u039b\u039c\7f\2\2\u039c\u039d\7g\2\2\u039d\u039e\7h\2\2\u039e"+ + "\u0096\3\2\2\2\u039f\u03a0\7v\2\2\u03a0\u03a1\7{\2\2\u03a1\u03a2\7r\2"+ + "\2\u03a2\u03a3\7g\2\2\u03a3\u03a4\7k\2\2\u03a4\u03a5\7f\2\2\u03a5\u0098"+ + "\3\2\2\2\u03a6\u03a7\7v\2\2\u03a7\u03a8\7{\2\2\u03a8\u03a9\7r\2\2\u03a9"+ + "\u03aa\7g\2\2\u03aa\u03ab\7p\2\2\u03ab\u03ac\7c\2\2\u03ac\u03ad\7o\2\2"+ + "\u03ad\u03ae\7g\2\2\u03ae\u009a\3\2\2\2\u03af\u03b0\7w\2\2\u03b0\u03b1"+ + "\7p\2\2\u03b1\u03b2\7k\2\2\u03b2\u03b3\7q\2\2\u03b3\u03b4\7p\2\2\u03b4"+ + "\u009c\3\2\2\2\u03b5\u03b6\7w\2\2\u03b6\u03b7\7p\2\2\u03b7\u03b8\7u\2"+ + "\2\u03b8\u03b9\7k\2\2\u03b9\u03ba\7i\2\2\u03ba\u03bb\7p\2\2\u03bb\u03bc"+ + "\7g\2\2\u03bc\u03bd\7f\2\2\u03bd\u009e\3\2\2\2\u03be\u03bf\7w\2\2\u03bf"+ + "\u03c0\7u\2\2\u03c0\u03c1\7k\2\2\u03c1\u03c2\7p\2\2\u03c2\u03c3\7i\2\2"+ + "\u03c3\u00a0\3\2\2\2\u03c4\u03c5\7x\2\2\u03c5\u03c6\7k\2\2\u03c6\u03c7"+ + "\7t\2\2\u03c7\u03c8\7v\2\2\u03c8\u03c9\7w\2\2\u03c9\u03ca\7c\2\2\u03ca"+ + "\u03cb\7n\2\2\u03cb\u00a2\3\2\2\2\u03cc\u03cd\7x\2\2\u03cd\u03ce\7q\2"+ + "\2\u03ce\u03cf\7k\2\2\u03cf\u03d0\7f\2\2\u03d0\u00a4\3\2\2\2\u03d1\u03d2"+ + "\7x\2\2\u03d2\u03d3\7q\2\2\u03d3\u03d4\7n\2\2\u03d4\u03d5\7c\2\2\u03d5"+ + "\u03d6\7v\2\2\u03d6\u03d7\7k\2\2\u03d7\u03d8\7n\2\2\u03d8\u03d9\7g\2\2"+ + "\u03d9\u00a6\3\2\2\2\u03da\u03db\7y\2\2\u03db\u03dc\7e\2\2\u03dc\u03dd"+ + "\7j\2\2\u03dd\u03de\7c\2\2\u03de\u03df\7t\2\2\u03df\u03e0\7a\2\2\u03e0"+ + "\u03e1\7v\2\2\u03e1\u00a8\3\2\2\2\u03e2\u03e3\7y\2\2\u03e3\u03e4\7j\2"+ + "\2\u03e4\u03e5\7k\2\2\u03e5\u03e6\7n\2\2\u03e6\u03e7\7g\2\2\u03e7\u00aa"+ + "\3\2\2\2\u03e8\u03e9\7*\2\2\u03e9\u00ac\3\2\2\2\u03ea\u03eb\7+\2\2\u03eb"+ + "\u00ae\3\2\2\2\u03ec\u03ed\7]\2\2\u03ed\u00b0\3\2\2\2\u03ee\u03ef\7_\2"+ + "\2\u03ef\u00b2\3\2\2\2\u03f0\u03f1\7}\2\2\u03f1\u00b4\3\2\2\2\u03f2\u03f3"+ + "\7\177\2\2\u03f3\u00b6\3\2\2\2\u03f4\u03f5\7-\2\2\u03f5\u00b8\3\2\2\2"+ + "\u03f6\u03f7\7/\2\2\u03f7\u00ba\3\2\2\2\u03f8\u03f9\7,\2\2\u03f9\u00bc"+ + "\3\2\2\2\u03fa\u03fb\7\61\2\2\u03fb\u00be\3\2\2\2\u03fc\u03fd\7\'\2\2"+ + "\u03fd\u00c0\3\2\2\2\u03fe\u03ff\7`\2\2\u03ff\u00c2\3\2\2\2\u0400\u0401"+ + "\7(\2\2\u0401\u00c4\3\2\2\2\u0402\u0403\7~\2\2\u0403\u00c6\3\2\2\2\u0404"+ + "\u0405\7\u0080\2\2\u0405\u00c8\3\2\2\2\u0406\u040b\7#\2\2\u0407\u0408"+ + "\7p\2\2\u0408\u0409\7q\2\2\u0409\u040b\7v\2\2\u040a\u0406\3\2\2\2\u040a"+ + "\u0407\3\2\2\2\u040b\u00ca\3\2\2\2\u040c\u040d\7?\2\2\u040d\u00cc\3\2"+ + "\2\2\u040e\u040f\7>\2\2\u040f\u00ce\3\2\2\2\u0410\u0411\7@\2\2\u0411\u00d0"+ + "\3\2\2\2\u0412\u0413\7-\2\2\u0413\u0414\7?\2\2\u0414\u00d2\3\2\2\2\u0415"+ + "\u0416\7/\2\2\u0416\u0417\7?\2\2\u0417\u00d4\3\2\2\2\u0418\u0419\7,\2"+ + "\2\u0419\u041a\7?\2\2\u041a\u00d6\3\2\2\2\u041b\u041c\7\61\2\2\u041c\u041d"+ + "\7?\2\2\u041d\u00d8\3\2\2\2\u041e\u041f\7\'\2\2\u041f\u0420\7?\2\2\u0420"+ + "\u00da\3\2\2\2\u0421\u0422\7`\2\2\u0422\u0423\7?\2\2\u0423\u00dc\3\2\2"+ + "\2\u0424\u0425\7(\2\2\u0425\u0426\7?\2\2\u0426\u00de\3\2\2\2\u0427\u0428"+ + "\7~\2\2\u0428\u0429\7?\2\2\u0429\u00e0\3\2\2\2\u042a\u042b\7>\2\2\u042b"+ + "\u042c\7>\2\2\u042c\u042d\7?\2\2\u042d\u00e2\3\2\2\2\u042e\u042f\7@\2"+ + "\2\u042f\u0430\7@\2\2\u0430\u0431\7?\2\2\u0431\u00e4\3\2\2\2\u0432\u0433"+ + "\7?\2\2\u0433\u0434\7?\2\2\u0434\u00e6\3\2\2\2\u0435\u0436\7#\2\2\u0436"+ + "\u0437\7?\2\2\u0437\u00e8\3\2\2\2\u0438\u0439\7>\2\2\u0439\u043a\7?\2"+ + "\2\u043a\u00ea\3\2\2\2\u043b\u043c\7@\2\2\u043c\u043d\7?\2\2\u043d\u00ec"+ + "\3\2\2\2\u043e\u043f\7(\2\2\u043f\u0444\7(\2\2\u0440\u0441\7c\2\2\u0441"+ + "\u0442\7p\2\2\u0442\u0444\7f\2\2\u0443\u043e\3\2\2\2\u0443\u0440\3\2\2"+ + "\2\u0444\u00ee\3\2\2\2\u0445\u0446\7~\2\2\u0446\u044a\7~\2\2\u0447\u0448"+ + "\7q\2\2\u0448\u044a\7t\2\2\u0449\u0445\3\2\2\2\u0449\u0447\3\2\2\2\u044a"+ + "\u00f0\3\2\2\2\u044b\u044c\7-\2\2\u044c\u044d\7-\2\2\u044d\u00f2\3\2\2"+ + "\2\u044e\u044f\7/\2\2\u044f\u0450\7/\2\2\u0450\u00f4\3\2\2\2\u0451\u0452"+ + "\7.\2\2\u0452\u00f6\3\2\2\2\u0453\u0454\7/\2\2\u0454\u0455\7@\2\2\u0455"+ + "\u0456\7,\2\2\u0456\u00f8\3\2\2\2\u0457\u0458\7/\2\2\u0458\u0459\7@\2"+ + "\2\u0459\u00fa\3\2\2\2\u045a\u045b\7A\2\2\u045b\u00fc\3\2\2\2\u045c\u045d"+ + "\7<\2\2\u045d\u00fe\3\2\2\2\u045e\u045f\7<\2\2\u045f\u0460\7<\2\2\u0460"+ + "\u0100\3\2\2\2\u0461\u0462\7=\2\2\u0462\u0102\3\2\2\2\u0463\u0464\7\60"+ + "\2\2\u0464\u0104\3\2\2\2\u0465\u0466\7\60\2\2\u0466\u0467\7,\2\2\u0467"+ + "\u0106\3\2\2\2\u0468\u0469\7\60\2\2\u0469\u046a\7\60\2\2\u046a\u046b\7"+ + "\60\2\2\u046b\u0108\3\2\2\2\u046c\u046d\5\u0121\u0091\2\u046d\u046e\5"+ + "\u0121\u0091\2\u046e\u046f\5\u0121\u0091\2\u046f\u0470\5\u0121\u0091\2"+ + "\u0470\u010a\3\2\2\2\u0471\u0472\7^\2\2\u0472\u0473\7w\2\2\u0473\u0474"+ + "\3\2\2\2\u0474\u047c\5\u0109\u0085\2\u0475\u0476\7^\2\2\u0476\u0477\7"+ + "W\2\2\u0477\u0478\3\2\2\2\u0478\u0479\5\u0109\u0085\2\u0479\u047a\5\u0109"+ + "\u0085\2\u047a\u047c\3\2\2\2\u047b\u0471\3\2\2\2\u047b\u0475\3\2\2\2\u047c"+ + "\u010c\3\2\2\2\u047d\u0482\5\u010f\u0088\2\u047e\u0481\5\u010f\u0088\2"+ + "\u047f\u0481\5\u0113\u008a\2\u0480\u047e\3\2\2\2\u0480\u047f\3\2\2\2\u0481"+ + "\u0484\3\2\2\2\u0482\u0480\3\2\2\2\u0482\u0483\3\2\2\2\u0483\u010e\3\2"+ + "\2\2\u0484\u0482\3\2\2\2\u0485\u0488\5\u0111\u0089\2\u0486\u0488\5\u010b"+ + "\u0086\2\u0487\u0485\3\2\2\2\u0487\u0486\3\2\2\2\u0488\u0110\3\2\2\2\u0489"+ + "\u048a\t\4\2\2\u048a\u0112\3\2\2\2\u048b\u048c\t\5\2\2\u048c\u0114\3\2"+ + "\2\2\u048d\u0494\5\u011d\u008f\2\u048e\u0490\7)\2\2\u048f\u048e\3\2\2"+ + "\2\u048f\u0490\3\2\2\2\u0490\u0491\3\2\2\2\u0491\u0493\5\u0113\u008a\2"+ + "\u0492\u048f\3\2\2\2\u0493\u0496\3\2\2\2\u0494\u0492\3\2\2\2\u0494\u0495"+ + "\3\2\2\2\u0495\u0116\3\2\2\2\u0496\u0494\3\2\2\2\u0497\u049e\7\62\2\2"+ + "\u0498\u049a\7)\2\2\u0499\u0498\3\2\2\2\u0499\u049a\3\2\2\2\u049a\u049b"+ + "\3\2\2\2\u049b\u049d\5\u011f\u0090\2\u049c\u0499\3\2\2\2\u049d\u04a0\3"+ + "\2\2\2\u049e\u049c\3\2\2\2\u049e\u049f\3\2\2\2\u049f\u0118\3\2\2\2\u04a0"+ + "\u049e\3\2\2\2\u04a1\u04a2\7\62\2\2\u04a2\u04a6\7z\2\2\u04a3\u04a4\7\62"+ + "\2\2\u04a4\u04a6\7Z\2\2\u04a5\u04a1\3\2\2\2\u04a5\u04a3\3\2\2\2\u04a6"+ + "\u04a7\3\2\2\2\u04a7\u04ae\5\u0121\u0091\2\u04a8\u04aa\7)\2\2\u04a9\u04a8"+ + "\3\2\2\2\u04a9\u04aa\3\2\2\2\u04aa\u04ab\3\2\2\2\u04ab\u04ad\5\u0121\u0091"+ + "\2\u04ac\u04a9\3\2\2\2\u04ad\u04b0\3\2\2\2\u04ae\u04ac\3\2\2\2\u04ae\u04af"+ + "\3\2\2\2\u04af\u011a\3\2\2\2\u04b0\u04ae\3\2\2\2\u04b1\u04b2\7\62\2\2"+ + "\u04b2\u04b6\7d\2\2\u04b3\u04b4\7\62\2\2\u04b4\u04b6\7D\2\2\u04b5\u04b1"+ + "\3\2\2\2\u04b5\u04b3\3\2\2\2\u04b6\u04b7\3\2\2\2\u04b7\u04be\5\u0123\u0092"+ + "\2\u04b8\u04ba\7)\2\2\u04b9\u04b8\3\2\2\2\u04b9\u04ba\3\2\2\2\u04ba\u04bb"+ + "\3\2\2\2\u04bb\u04bd\5\u0123\u0092\2\u04bc\u04b9\3\2\2\2\u04bd\u04c0\3"+ + "\2\2\2\u04be\u04bc\3\2\2\2\u04be\u04bf\3\2\2\2\u04bf\u011c\3\2\2\2\u04c0"+ + "\u04be\3\2\2\2\u04c1\u04c2\t\6\2\2\u04c2\u011e\3\2\2\2\u04c3\u04c4\t\7"+ + "\2\2\u04c4\u0120\3\2\2\2\u04c5\u04c6\t\b\2\2\u04c6\u0122\3\2\2\2\u04c7"+ + "\u04c8\t\t\2\2\u04c8\u0124\3\2\2\2\u04c9\u04cb\5\u0127\u0094\2\u04ca\u04cc"+ + "\5\u0129\u0095\2\u04cb\u04ca\3\2\2\2\u04cb\u04cc\3\2\2\2\u04cc\u04da\3"+ + "\2\2\2\u04cd\u04cf\5\u0127\u0094\2\u04ce\u04d0\5\u012b\u0096\2\u04cf\u04ce"+ + "\3\2\2\2\u04cf\u04d0\3\2\2\2\u04d0\u04da\3\2\2\2\u04d1\u04d3\5\u0129\u0095"+ + "\2\u04d2\u04d4\5\u0127\u0094\2\u04d3\u04d2\3\2\2\2\u04d3\u04d4\3\2\2\2"+ + "\u04d4\u04da\3\2\2\2\u04d5\u04d7\5\u012b\u0096\2\u04d6\u04d8\5\u0127\u0094"+ + "\2\u04d7\u04d6\3\2\2\2\u04d7\u04d8\3\2\2\2\u04d8\u04da\3\2\2\2\u04d9\u04c9"+ + "\3\2\2\2\u04d9\u04cd\3\2\2\2\u04d9\u04d1\3\2\2\2\u04d9\u04d5\3\2\2\2\u04da"+ + "\u0126\3\2\2\2\u04db\u04dc\t\n\2\2\u04dc\u0128\3\2\2\2\u04dd\u04de\t\13"+ + "\2\2\u04de\u012a\3\2\2\2\u04df\u04e0\7n\2\2\u04e0\u04e4\7n\2\2\u04e1\u04e2"+ + "\7N\2\2\u04e2\u04e4\7N\2\2\u04e3\u04df\3\2\2\2\u04e3\u04e1\3\2\2\2\u04e4"+ + "\u012c\3\2\2\2\u04e5\u04e9\n\f\2\2\u04e6\u04e9\5\u012f\u0098\2\u04e7\u04e9"+ + "\5\u010b\u0086\2\u04e8\u04e5\3\2\2\2\u04e8\u04e6\3\2\2\2\u04e8\u04e7\3"+ + "\2\2\2\u04e9\u012e\3\2\2\2\u04ea\u04ee\5\u0131\u0099\2\u04eb\u04ee\5\u0133"+ + "\u009a\2\u04ec\u04ee\5\u0135\u009b\2\u04ed\u04ea\3\2\2\2\u04ed\u04eb\3"+ + "\2\2\2\u04ed\u04ec\3\2\2\2\u04ee\u0130\3\2\2\2\u04ef\u04f0\7^\2\2\u04f0"+ + "\u050e\7)\2\2\u04f1\u04f2\7^\2\2\u04f2\u050e\7$\2\2\u04f3\u04f4\7^\2\2"+ + "\u04f4\u050e\7A\2\2\u04f5\u04f6\7^\2\2\u04f6\u050e\7^\2\2\u04f7\u04f8"+ + "\7^\2\2\u04f8\u050e\7c\2\2\u04f9\u04fa\7^\2\2\u04fa\u050e\7d\2\2\u04fb"+ + "\u04fc\7^\2\2\u04fc\u050e\7h\2\2\u04fd\u04fe\7^\2\2\u04fe\u050e\7p\2\2"+ + "\u04ff\u0500\7^\2\2\u0500\u050e\7t\2\2\u0501\u0507\7^\2\2\u0502\u0504"+ + "\7\17\2\2\u0503\u0505\7\f\2\2\u0504\u0503\3\2\2\2\u0504\u0505\3\2\2\2"+ + "\u0505\u0508\3\2\2\2\u0506\u0508\7\f\2\2\u0507\u0502\3\2\2\2\u0507\u0506"+ + "\3\2\2\2\u0508\u050e\3\2\2\2\u0509\u050a\7^\2\2\u050a\u050e\7v\2\2\u050b"+ + "\u050c\7^\2\2\u050c\u050e\7x\2\2\u050d\u04ef\3\2\2\2\u050d\u04f1\3\2\2"+ + "\2\u050d\u04f3\3\2\2\2\u050d\u04f5\3\2\2\2\u050d\u04f7\3\2\2\2\u050d\u04f9"+ + "\3\2\2\2\u050d\u04fb\3\2\2\2\u050d\u04fd\3\2\2\2\u050d\u04ff\3\2\2\2\u050d"+ + "\u0501\3\2\2\2\u050d\u0509\3\2\2\2\u050d\u050b\3\2\2\2\u050e\u0132\3\2"+ + "\2\2\u050f\u0510\7^\2\2\u0510\u051b\5\u011f\u0090\2\u0511\u0512\7^\2\2"+ + "\u0512\u0513\5\u011f\u0090\2\u0513\u0514\5\u011f\u0090\2\u0514\u051b\3"+ + "\2\2\2\u0515\u0516\7^\2\2\u0516\u0517\5\u011f\u0090\2\u0517\u0518\5\u011f"+ + "\u0090\2\u0518\u0519\5\u011f\u0090\2\u0519\u051b\3\2\2\2\u051a\u050f\3"+ + "\2\2\2\u051a\u0511\3\2\2\2\u051a\u0515\3\2\2\2\u051b\u0134\3\2\2\2\u051c"+ + "\u051d\7^\2\2\u051d\u051e\7z\2\2\u051e\u0520\3\2\2\2\u051f\u0521\5\u0121"+ + "\u0091\2\u0520\u051f\3\2\2\2\u0521\u0522\3\2\2\2\u0522\u0520\3\2\2\2\u0522"+ + "\u0523\3\2\2\2\u0523\u0136\3\2\2\2\u0524\u0526\5\u013d\u009f\2\u0525\u0524"+ + "\3\2\2\2\u0525\u0526\3\2\2\2\u0526\u0527\3\2\2\2\u0527\u0528\7\60\2\2"+ + "\u0528\u052d\5\u013d\u009f\2\u0529\u052a\5\u013d\u009f\2\u052a\u052b\7"+ + "\60\2\2\u052b\u052d\3\2\2\2\u052c\u0525\3\2\2\2\u052c\u0529\3\2\2\2\u052d"+ + "\u0138\3\2\2\2\u052e\u0530\7g\2\2\u052f\u0531\5\u013b\u009e\2\u0530\u052f"+ + "\3\2\2\2\u0530\u0531\3\2\2\2\u0531\u0532\3\2\2\2\u0532\u0539\5\u013d\u009f"+ + "\2\u0533\u0535\7G\2\2\u0534\u0536\5\u013b\u009e\2\u0535\u0534\3\2\2\2"+ + "\u0535\u0536\3\2\2\2\u0536\u0537\3\2\2\2\u0537\u0539\5\u013d\u009f\2\u0538"+ + "\u052e\3\2\2\2\u0538\u0533\3\2\2\2\u0539\u013a\3\2\2\2\u053a\u053b\t\r"+ + "\2\2\u053b\u013c\3\2\2\2\u053c\u0543\5\u0113\u008a\2\u053d\u053f\7)\2"+ + "\2\u053e\u053d\3\2\2\2\u053e\u053f\3\2\2\2\u053f\u0540\3\2\2\2\u0540\u0542"+ + "\5\u0113\u008a\2\u0541\u053e\3\2\2\2\u0542\u0545\3\2\2\2\u0543\u0541\3"+ + "\2\2\2\u0543\u0544\3\2\2\2\u0544\u013e\3\2\2\2\u0545\u0543\3\2\2\2\u0546"+ + "\u0547\t\16\2\2\u0547\u0140\3\2\2\2\u0548\u0549\7w\2\2\u0549\u054c\7:"+ + "\2\2\u054a\u054c\t\2\2\2\u054b\u0548\3\2\2\2\u054b\u054a\3\2\2\2\u054c"+ + "\u0142\3\2\2\2\u054d\u0551\n\17\2\2\u054e\u0551\5\u012f\u0098\2\u054f"+ + "\u0551\5\u010b\u0086\2\u0550\u054d\3\2\2\2\u0550\u054e\3\2\2\2\u0550\u054f"+ + "\3\2\2\2\u0551\u0144\3\2\2\2\u0552\u0556\7$\2\2\u0553\u0555\n\20\2\2\u0554"+ + "\u0553\3\2\2\2\u0555\u0558\3\2\2\2\u0556\u0554\3\2\2\2\u0556\u0557\3\2"+ + "\2\2\u0557\u0559\3\2\2\2\u0558\u0556\3\2\2\2\u0559\u055d\7*\2\2\u055a"+ + "\u055c\n\21\2\2\u055b\u055a\3\2\2\2\u055c\u055f\3\2\2\2\u055d\u055b\3"+ + "\2\2\2\u055d\u055e\3\2\2\2\u055e\u0560\3\2\2\2\u055f\u055d\3\2\2\2\u0560"+ + "\u0564\7+\2\2\u0561\u0563\n\22\2\2\u0562\u0561\3\2\2\2\u0563\u0566\3\2"+ + "\2\2\u0564\u0562\3\2\2\2\u0564\u0565\3\2\2\2\u0565\u0567\3\2\2\2\u0566"+ + "\u0564\3\2\2\2\u0567\u0568\7$\2\2\u0568\u0146\3\2\2\2\u0569\u056a\5\u0115"+ + "\u008b\2\u056a\u056b\5\u014f\u00a8\2\u056b\u0576\3\2\2\2\u056c\u056d\5"+ + "\u0117\u008c\2\u056d\u056e\5\u014f\u00a8\2\u056e\u0576\3\2\2\2\u056f\u0570"+ + "\5\u0119\u008d\2\u0570\u0571\5\u014f\u00a8\2\u0571\u0576\3\2\2\2\u0572"+ + "\u0573\5\u011b\u008e\2\u0573\u0574\5\u014f\u00a8\2\u0574\u0576\3\2\2\2"+ + "\u0575\u0569\3\2\2\2\u0575\u056c\3\2\2\2\u0575\u056f\3\2\2\2\u0575\u0572"+ + "\3\2\2\2\u0576\u0148\3\2\2\2\u0577\u0579\5\u0137\u009c\2\u0578\u057a\5"+ + "\u0139\u009d\2\u0579\u0578\3\2\2\2\u0579\u057a\3\2\2\2\u057a\u057b\3\2"+ + "\2\2\u057b\u057c\5\u014f\u00a8\2\u057c\u0582\3\2\2\2\u057d\u057e\5\u013d"+ + "\u009f\2\u057e\u057f\5\u0139\u009d\2\u057f\u0580\5\u014f\u00a8\2\u0580"+ + "\u0582\3\2\2\2\u0581\u0577\3\2\2\2\u0581\u057d\3\2\2\2\u0582\u014a\3\2"+ + "\2\2\u0583\u0584\5\t\5\2\u0584\u0585\5\u014f\u00a8\2\u0585\u014c\3\2\2"+ + "\2\u0586\u0587\5\5\3\2\u0587\u0588\5\u014f\u00a8\2\u0588\u014e\3\2\2\2"+ + "\u0589\u058a\5\u010d\u0087\2\u058a\u0150\3\2\2\2\u058b\u058d\t\23\2\2"+ + "\u058c\u058b\3\2\2\2\u058d\u058e\3\2\2\2\u058e\u058c\3\2\2\2\u058e\u058f"+ + "\3\2\2\2\u058f\u0590\3\2\2\2\u0590\u0591\b\u00a9\3\2\u0591\u0152\3\2\2"+ + "\2\u0592\u0594\7\17\2\2\u0593\u0595\7\f\2\2\u0594\u0593\3\2\2\2\u0594"+ + "\u0595\3\2\2\2\u0595\u0598\3\2\2\2\u0596\u0598\7\f\2\2\u0597\u0592\3\2"+ + "\2\2\u0597\u0596\3\2\2\2\u0598\u0599\3\2\2\2\u0599\u059a\b\u00aa\3\2\u059a"+ + "\u0154\3\2\2\2\u059b\u059c\7\61\2\2\u059c\u059d\7,\2\2\u059d\u05a1\3\2"+ + "\2\2\u059e\u05a0\13\2\2\2\u059f\u059e\3\2\2\2\u05a0\u05a3\3\2\2\2\u05a1"+ + "\u05a2\3\2\2\2\u05a1\u059f\3\2\2\2\u05a2\u05a4\3\2\2\2\u05a3\u05a1\3\2"+ + "\2\2\u05a4\u05a5\7,\2\2\u05a5\u05a6\7\61\2\2\u05a6\u05a7\3\2\2\2\u05a7"+ + "\u05a8\b\u00ab\3\2\u05a8\u0156\3\2\2\2\u05a9\u05aa\7\61\2\2\u05aa\u05ab"+ + "\7\61\2\2\u05ab\u05af\3\2\2\2\u05ac\u05ae\n\24\2\2\u05ad\u05ac\3\2\2\2"+ + "\u05ae\u05b1\3\2\2\2\u05af\u05ad\3\2\2\2\u05af\u05b0\3\2\2\2\u05b0\u05b2"+ + "\3\2\2\2\u05b1\u05af\3\2\2\2\u05b2\u05b3\b\u00ac\3\2\u05b3\u0158\3\2\2"+ + "\2K\2\u015b\u015f\u0163\u0167\u0169\u016c\u0172\u0178\u017b\u0180\u0182"+ + "\u0185\u018b\u0190\u0194\u0198\u01a0\u01a6\u01ab\u01b0\u01b5\u01bd\u040a"+ + "\u0443\u0449\u047b\u0480\u0482\u0487\u048f\u0494\u0499\u049e\u04a5\u04a9"+ + "\u04ae\u04b5\u04b9\u04be\u04cb\u04cf\u04d3\u04d7\u04d9\u04e3\u04e8\u04ed"+ + "\u0504\u0507\u050d\u051a\u0522\u0525\u052c\u0530\u0535\u0538\u053e\u0543"+ + "\u054b\u0550\u0556\u055d\u0564\u0575\u0579\u0581\u058e\u0594\u0597\u05a1"+ + "\u05af\4\2\3\2\b\2\2"; + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} \ No newline at end of file diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Lexer.tokens b/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Lexer.tokens new file mode 100644 index 000000000..97906afe4 --- /dev/null +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Lexer.tokens @@ -0,0 +1,264 @@ +IntegerLiteral=1 +CharacterLiteral=2 +FloatingLiteral=3 +StringLiteral=4 +BooleanLiteral=5 +PointerLiteral=6 +UserDefinedLiteral=7 +MultiLineMacro=8 +Directive=9 +Alignas=10 +Alignof=11 +Asm=12 +Auto=13 +Bool=14 +Break=15 +Case=16 +Catch=17 +Char=18 +Char16=19 +Char32=20 +Class=21 +Const=22 +Constexpr=23 +Const_cast=24 +Continue=25 +Decltype=26 +Default=27 +Delete=28 +Do=29 +Double=30 +Dynamic_cast=31 +Else=32 +Enum=33 +Explicit=34 +Export=35 +Extern=36 +False_=37 +Final=38 +Float=39 +For=40 +Friend=41 +Goto=42 +If=43 +Inline=44 +Int=45 +Long=46 +Mutable=47 +Namespace=48 +New=49 +Noexcept=50 +Nullptr=51 +Operator=52 +Override=53 +Private=54 +Protected=55 +Public=56 +Register=57 +Reinterpret_cast=58 +Return=59 +Short=60 +Signed=61 +Sizeof=62 +Static=63 +Static_assert=64 +Static_cast=65 +Struct=66 +Switch=67 +Template=68 +This=69 +Thread_local=70 +Throw=71 +True_=72 +Try=73 +Typedef=74 +Typeid_=75 +Typename_=76 +Union=77 +Unsigned=78 +Using=79 +Virtual=80 +Void=81 +Volatile=82 +Wchar=83 +While=84 +LeftParen=85 +RightParen=86 +LeftBracket=87 +RightBracket=88 +LeftBrace=89 +RightBrace=90 +Plus=91 +Minus=92 +Star=93 +Div=94 +Mod=95 +Caret=96 +And=97 +Or=98 +Tilde=99 +Not=100 +Assign=101 +Less=102 +Greater=103 +PlusAssign=104 +MinusAssign=105 +StarAssign=106 +DivAssign=107 +ModAssign=108 +XorAssign=109 +AndAssign=110 +OrAssign=111 +LeftShiftAssign=112 +RightShiftAssign=113 +Equal=114 +NotEqual=115 +LessEqual=116 +GreaterEqual=117 +AndAnd=118 +OrOr=119 +PlusPlus=120 +MinusMinus=121 +Comma=122 +ArrowStar=123 +Arrow=124 +Question=125 +Colon=126 +Doublecolon=127 +Semi=128 +Dot=129 +DotStar=130 +Ellipsis=131 +Identifier=132 +DecimalLiteral=133 +OctalLiteral=134 +HexadecimalLiteral=135 +BinaryLiteral=136 +Integersuffix=137 +UserDefinedIntegerLiteral=138 +UserDefinedFloatingLiteral=139 +UserDefinedStringLiteral=140 +UserDefinedCharacterLiteral=141 +Whitespace=142 +Newline=143 +BlockComment=144 +LineComment=145 +'alignas'=10 +'alignof'=11 +'asm'=12 +'auto'=13 +'bool'=14 +'break'=15 +'case'=16 +'catch'=17 +'char'=18 +'char16_t'=19 +'char32_t'=20 +'class'=21 +'const'=22 +'constexpr'=23 +'const_cast'=24 +'continue'=25 +'decltype'=26 +'default'=27 +'delete'=28 +'do'=29 +'double'=30 +'dynamic_cast'=31 +'else'=32 +'enum'=33 +'explicit'=34 +'export'=35 +'extern'=36 +'false'=37 +'final'=38 +'float'=39 +'for'=40 +'friend'=41 +'goto'=42 +'if'=43 +'inline'=44 +'int'=45 +'long'=46 +'mutable'=47 +'namespace'=48 +'new'=49 +'noexcept'=50 +'nullptr'=51 +'operator'=52 +'override'=53 +'private'=54 +'protected'=55 +'public'=56 +'register'=57 +'reinterpret_cast'=58 +'return'=59 +'short'=60 +'signed'=61 +'sizeof'=62 +'static'=63 +'static_assert'=64 +'static_cast'=65 +'struct'=66 +'switch'=67 +'template'=68 +'this'=69 +'thread_local'=70 +'throw'=71 +'true'=72 +'try'=73 +'typedef'=74 +'typeid'=75 +'typename'=76 +'union'=77 +'unsigned'=78 +'using'=79 +'virtual'=80 +'void'=81 +'volatile'=82 +'wchar_t'=83 +'while'=84 +'('=85 +')'=86 +'['=87 +']'=88 +'{'=89 +'}'=90 +'+'=91 +'-'=92 +'*'=93 +'/'=94 +'%'=95 +'^'=96 +'&'=97 +'|'=98 +'~'=99 +'='=101 +'<'=102 +'>'=103 +'+='=104 +'-='=105 +'*='=106 +'/='=107 +'%='=108 +'^='=109 +'&='=110 +'|='=111 +'<<='=112 +'>>='=113 +'=='=114 +'!='=115 +'<='=116 +'>='=117 +'++'=120 +'--'=121 +','=122 +'->*'=123 +'->'=124 +'?'=125 +':'=126 +'::'=127 +';'=128 +'.'=129 +'.*'=130 +'...'=131 diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Parser.g4 b/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Parser.g4 new file mode 100644 index 000000000..6c4d84854 --- /dev/null +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Parser.g4 @@ -0,0 +1,823 @@ +/******************************************************************************* + * The MIT License (MIT) + * + * Copyright (c) 2015 Camilo Sanchez (Camiloasc1) 2020 Martin Mirchev (Marti2203) + * + * 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 CPP14Parser; +options { + tokenVocab = CPP14Lexer; +} +/*Basic concepts*/ + +translationUnit: declarationseq? EOF; +/*Expressions*/ + +primaryExpression: + literal+ + | This + | LeftParen expression RightParen + | idExpression + | lambdaExpression; + +idExpression: unqualifiedId | qualifiedId; + +unqualifiedId: + Identifier + | operatorFunctionId + | conversionFunctionId + | literalOperatorId + | Tilde (className | decltypeSpecifier) + | templateId; + +qualifiedId: nestedNameSpecifier Template? unqualifiedId; + +nestedNameSpecifier: + (theTypeName | namespaceName | decltypeSpecifier)? Doublecolon + | nestedNameSpecifier ( + Identifier + | Template? simpleTemplateId + ) Doublecolon; +lambdaExpression: + lambdaIntroducer lambdaDeclarator? compoundStatement; + +lambdaIntroducer: LeftBracket lambdaCapture? RightBracket; + +lambdaCapture: + captureList + | captureDefault (Comma captureList)?; + +captureDefault: And | Assign; + +captureList: capture (Comma capture)* Ellipsis?; + +capture: simpleCapture | initcapture; + +simpleCapture: And? Identifier | This; + +initcapture: And? Identifier initializer; + +lambdaDeclarator: + LeftParen parameterDeclarationClause? RightParen Mutable? exceptionSpecification? + attributeSpecifierSeq? trailingReturnType?; + +postfixExpression: + primaryExpression + | postfixExpression LeftBracket (expression | bracedInitList) RightBracket + | postfixExpression LeftParen expressionList? RightParen + | (simpleTypeSpecifier | typeNameSpecifier) ( + LeftParen expressionList? RightParen + | bracedInitList + ) + | postfixExpression (Dot | Arrow) ( + Template? idExpression + | pseudoDestructorName + ) + | postfixExpression (PlusPlus | MinusMinus) + | ( + Dynamic_cast + | Static_cast + | Reinterpret_cast + | Const_cast + ) Less theTypeId Greater LeftParen expression RightParen + | typeIdOfTheTypeId LeftParen (expression | theTypeId) RightParen; +/* + add a middle layer to eliminate duplicated function declarations + */ + +typeIdOfTheTypeId: Typeid_; + +expressionList: initializerList; + +pseudoDestructorName: + nestedNameSpecifier? (theTypeName Doublecolon)? Tilde theTypeName + | nestedNameSpecifier Template simpleTemplateId Doublecolon Tilde theTypeName + | Tilde decltypeSpecifier; + +unaryExpression: + postfixExpression + | (PlusPlus | MinusMinus | unaryOperator | Sizeof) unaryExpression + | Sizeof ( + LeftParen theTypeId RightParen + | Ellipsis LeftParen Identifier RightParen + ) + | Alignof LeftParen theTypeId RightParen + | noExceptExpression + | newExpression + | deleteExpression; + +unaryOperator: Or | Star | And | Plus | Tilde | Minus | Not; + +newExpression: + Doublecolon? New newPlacement? ( + newTypeId + | (LeftParen theTypeId RightParen) + ) newInitializer?; + +newPlacement: LeftParen expressionList RightParen; + +newTypeId: typeSpecifierSeq newDeclarator?; + +newDeclarator: + pointerOperator newDeclarator? + | noPointerNewDeclarator; + +noPointerNewDeclarator: + LeftBracket expression RightBracket attributeSpecifierSeq? + | noPointerNewDeclarator LeftBracket constantExpression RightBracket attributeSpecifierSeq?; + +newInitializer: + LeftParen expressionList? RightParen + | bracedInitList; + +deleteExpression: + Doublecolon? Delete (LeftBracket RightBracket)? castExpression; + +noExceptExpression: Noexcept LeftParen expression RightParen; + +castExpression: + unaryExpression + | LeftParen theTypeId RightParen castExpression; + +pointerMemberExpression: + castExpression ((DotStar | ArrowStar) castExpression)*; + +multiplicativeExpression: + pointerMemberExpression ( + (Star | Div | Mod) pointerMemberExpression + )*; + +additiveExpression: + multiplicativeExpression ( + (Plus | Minus) multiplicativeExpression + )*; + +shiftExpression: + additiveExpression (shiftOperator additiveExpression)*; + +shiftOperator: Greater Greater | Less Less; + +relationalExpression: + shiftExpression ( + (Less | Greater | LessEqual | GreaterEqual) shiftExpression + )*; + +equalityExpression: + relationalExpression ( + (Equal | NotEqual) relationalExpression + )*; + +andExpression: equalityExpression (And equalityExpression)*; + +exclusiveOrExpression: andExpression (Caret andExpression)*; + +inclusiveOrExpression: + exclusiveOrExpression (Or exclusiveOrExpression)*; + +logicalAndExpression: + inclusiveOrExpression (AndAnd inclusiveOrExpression)*; + +logicalOrExpression: + logicalAndExpression (OrOr logicalAndExpression)*; + +conditionalExpression: + logicalOrExpression ( + Question expression Colon assignmentExpression + )?; + +assignmentExpression: + conditionalExpression + | logicalOrExpression assignmentOperator initializerClause + | throwExpression; + +assignmentOperator: + Assign + | StarAssign + | DivAssign + | ModAssign + | PlusAssign + | MinusAssign + | RightShiftAssign + | LeftShiftAssign + | AndAssign + | XorAssign + | OrAssign; + +expression: assignmentExpression (Comma assignmentExpression)*; + +constantExpression: conditionalExpression; +/*Statements*/ + +statement: + labeledStatement + | declarationStatement + | attributeSpecifierSeq? ( + expressionStatement + | compoundStatement + | selectionStatement + | iterationStatement + | jumpStatement + | tryBlock + ); + +labeledStatement: + attributeSpecifierSeq? ( + Identifier + | Case constantExpression + | Default + ) Colon statement; + +expressionStatement: expression? Semi; + +compoundStatement: LeftBrace statementSeq? RightBrace; + +statementSeq: statement+; + +selectionStatement: + If LeftParen condition RightParen statement (Else statement)? + | Switch LeftParen condition RightParen statement; + +condition: + expression + | attributeSpecifierSeq? declSpecifierSeq declarator ( + Assign initializerClause + | bracedInitList + ); + +iterationStatement: + While LeftParen condition RightParen statement + | Do statement While LeftParen expression RightParen Semi + | For LeftParen ( + forInitStatement condition? Semi expression? + | forRangeDeclaration Colon forRangeInitializer + ) RightParen statement; + +forInitStatement: expressionStatement | simpleDeclaration; + +forRangeDeclaration: + attributeSpecifierSeq? declSpecifierSeq declarator; + +forRangeInitializer: expression | bracedInitList; + +jumpStatement: + ( + Break + | Continue + | Return (expression | bracedInitList)? + | Goto Identifier + ) Semi; + +declarationStatement: blockDeclaration; +/*Declarations*/ + +declarationseq: declaration+; + +declaration: + blockDeclaration + | functionDefinition + | templateDeclaration + | explicitInstantiation + | explicitSpecialization + | linkageSpecification + | namespaceDefinition + | emptyDeclaration + | attributeDeclaration; + +blockDeclaration: + simpleDeclaration + | asmDefinition + | namespaceAliasDefinition + | usingDeclaration + | usingDirective + | staticAssertDeclaration + | aliasDeclaration + | opaqueEnumDeclaration; + +aliasDeclaration: + Using Identifier attributeSpecifierSeq? Assign theTypeId Semi; + +simpleDeclaration: + declSpecifierSeq? initDeclaratorList? Semi + | attributeSpecifierSeq declSpecifierSeq? initDeclaratorList Semi; + +staticAssertDeclaration: + Static_assert LeftParen constantExpression Comma StringLiteral RightParen Semi; + +emptyDeclaration: Semi; + +attributeDeclaration: attributeSpecifierSeq Semi; + +declSpecifier: + storageClassSpecifier + | typeSpecifier + | functionSpecifier + | Friend + | Typedef + | Constexpr; + +declSpecifierSeq: declSpecifier+? attributeSpecifierSeq?; + +storageClassSpecifier: + Register + | Static + | Thread_local + | Extern + | Mutable; + +functionSpecifier: Inline | Virtual | Explicit; + +typedefName: Identifier; + +typeSpecifier: + trailingTypeSpecifier + | classSpecifier + | enumSpecifier; + +trailingTypeSpecifier: + simpleTypeSpecifier + | elaboratedTypeSpecifier + | typeNameSpecifier + | cvQualifier; + +typeSpecifierSeq: typeSpecifier+ attributeSpecifierSeq?; + +trailingTypeSpecifierSeq: + trailingTypeSpecifier+ attributeSpecifierSeq?; + +simpleTypeLengthModifier: + Short + | Long; + +simpleTypeSignednessModifier: + Unsigned + | Signed; + +simpleTypeSpecifier: + nestedNameSpecifier? theTypeName + | nestedNameSpecifier Template simpleTemplateId + | simpleTypeSignednessModifier + | simpleTypeSignednessModifier? simpleTypeLengthModifier+ + | simpleTypeSignednessModifier? Char + | simpleTypeSignednessModifier? Char16 + | simpleTypeSignednessModifier? Char32 + | simpleTypeSignednessModifier? Wchar + | Bool + | simpleTypeSignednessModifier? simpleTypeLengthModifier* Int + | Float + | simpleTypeLengthModifier? Double + | Void + | Auto + | decltypeSpecifier; + +theTypeName: + className + | enumName + | typedefName + | simpleTemplateId; + +decltypeSpecifier: + Decltype LeftParen (expression | Auto) RightParen; + +elaboratedTypeSpecifier: + classKey ( + attributeSpecifierSeq? nestedNameSpecifier? Identifier + | simpleTemplateId + | nestedNameSpecifier Template? simpleTemplateId + ) + | Enum nestedNameSpecifier? Identifier; + +enumName: Identifier; + +enumSpecifier: + enumHead LeftBrace (enumeratorList Comma?)? RightBrace; + +enumHead: + enumkey attributeSpecifierSeq? ( + nestedNameSpecifier? Identifier + )? enumbase?; + +opaqueEnumDeclaration: + enumkey attributeSpecifierSeq? Identifier enumbase? Semi; + +enumkey: Enum (Class | Struct)?; + +enumbase: Colon typeSpecifierSeq; + +enumeratorList: + enumeratorDefinition (Comma enumeratorDefinition)*; + +enumeratorDefinition: enumerator (Assign constantExpression)?; + +enumerator: Identifier; + +namespaceName: originalNamespaceName | namespaceAlias; + +originalNamespaceName: Identifier; + +namespaceDefinition: + Inline? Namespace (Identifier | originalNamespaceName)? LeftBrace namespaceBody = declarationseq + ? RightBrace; + +namespaceAlias: Identifier; + +namespaceAliasDefinition: + Namespace Identifier Assign qualifiednamespacespecifier Semi; + +qualifiednamespacespecifier: nestedNameSpecifier? namespaceName; + +usingDeclaration: + Using ((Typename_? nestedNameSpecifier) | Doublecolon) unqualifiedId Semi; + +usingDirective: + attributeSpecifierSeq? Using Namespace nestedNameSpecifier? namespaceName Semi; + +asmDefinition: Asm LeftParen StringLiteral RightParen Semi; + +linkageSpecification: + Extern StringLiteral ( + LeftBrace declarationseq? RightBrace + | declaration + ); + +attributeSpecifierSeq: attributeSpecifier+; + +attributeSpecifier: + LeftBracket LeftBracket attributeList? RightBracket RightBracket + | alignmentspecifier; + +alignmentspecifier: + Alignas LeftParen (theTypeId | constantExpression) Ellipsis? RightParen; + +attributeList: attribute (Comma attribute)* Ellipsis?; + +attribute: (attributeNamespace Doublecolon)? Identifier attributeArgumentClause?; + +attributeNamespace: Identifier; + +attributeArgumentClause: LeftParen balancedTokenSeq? RightParen; + +balancedTokenSeq: balancedtoken+; + +balancedtoken: + LeftParen balancedTokenSeq RightParen + | LeftBracket balancedTokenSeq RightBracket + | LeftBrace balancedTokenSeq RightBrace + | ~( + LeftParen + | RightParen + | LeftBrace + | RightBrace + | LeftBracket + | RightBracket + )+; +/*Declarators*/ + +initDeclaratorList: initDeclarator (Comma initDeclarator)*; + +initDeclarator: declarator initializer?; + +declarator: + pointerDeclarator + | noPointerDeclarator parametersAndQualifiers trailingReturnType; + +pointerDeclarator: (pointerOperator Const?)* noPointerDeclarator; + +noPointerDeclarator: + declaratorid attributeSpecifierSeq? + | noPointerDeclarator ( + parametersAndQualifiers + | LeftBracket constantExpression? RightBracket attributeSpecifierSeq? + ) + | LeftParen pointerDeclarator RightParen; + +parametersAndQualifiers: + LeftParen parameterDeclarationClause? RightParen cvqualifierseq? refqualifier? + exceptionSpecification? attributeSpecifierSeq?; + +trailingReturnType: + Arrow trailingTypeSpecifierSeq abstractDeclarator?; + +pointerOperator: + (And | AndAnd) attributeSpecifierSeq? + | nestedNameSpecifier? Star attributeSpecifierSeq? cvqualifierseq?; + +cvqualifierseq: cvQualifier+; + +cvQualifier: Const | Volatile; + +refqualifier: And | AndAnd; + +declaratorid: Ellipsis? idExpression; + +theTypeId: typeSpecifierSeq abstractDeclarator?; + +abstractDeclarator: + pointerAbstractDeclarator + | noPointerAbstractDeclarator? parametersAndQualifiers trailingReturnType + | abstractPackDeclarator; + +pointerAbstractDeclarator: + noPointerAbstractDeclarator + | pointerOperator+ noPointerAbstractDeclarator?; + +noPointerAbstractDeclarator: + noPointerAbstractDeclarator ( + parametersAndQualifiers + | noPointerAbstractDeclarator LeftBracket constantExpression? RightBracket + attributeSpecifierSeq? + ) + | parametersAndQualifiers + | LeftBracket constantExpression? RightBracket attributeSpecifierSeq? + | LeftParen pointerAbstractDeclarator RightParen; + +abstractPackDeclarator: + pointerOperator* noPointerAbstractPackDeclarator; + +noPointerAbstractPackDeclarator: + noPointerAbstractPackDeclarator ( + parametersAndQualifiers + | LeftBracket constantExpression? RightBracket attributeSpecifierSeq? + ) + | Ellipsis; + +parameterDeclarationClause: + parameterDeclarationList (Comma? Ellipsis)?; + +parameterDeclarationList: + parameterDeclaration (Comma parameterDeclaration)*; + +parameterDeclaration: + attributeSpecifierSeq? declSpecifierSeq ( + (declarator | abstractDeclarator?) ( + Assign initializerClause + )? + ); + +functionDefinition: + attributeSpecifierSeq? declSpecifierSeq? declarator virtualSpecifierSeq? functionBody; + +functionBody: + constructorInitializer? compoundStatement + | functionTryBlock + | Assign (Default | Delete) Semi; + +initializer: + braceOrEqualInitializer + | LeftParen expressionList RightParen; + +braceOrEqualInitializer: + Assign initializerClause + | bracedInitList; + +initializerClause: assignmentExpression | bracedInitList; + +initializerList: + initializerClause Ellipsis? ( + Comma initializerClause Ellipsis? + )*; + +bracedInitList: LeftBrace (initializerList Comma?)? RightBrace; +/*Classes*/ + +className: Identifier | simpleTemplateId; + +classSpecifier: + classHead LeftBrace memberSpecification? RightBrace; + +classHead: + classKey attributeSpecifierSeq? ( + classHeadName classVirtSpecifier? + )? baseClause? + | Union attributeSpecifierSeq? ( + classHeadName classVirtSpecifier? + )?; + +classHeadName: nestedNameSpecifier? className; + +classVirtSpecifier: Final; + +classKey: Class | Struct; + +memberSpecification: + (memberdeclaration | accessSpecifier Colon)+; + +memberdeclaration: + attributeSpecifierSeq? declSpecifierSeq? memberDeclaratorList? Semi + | functionDefinition + | usingDeclaration + | staticAssertDeclaration + | templateDeclaration + | aliasDeclaration + | emptyDeclaration; + +memberDeclaratorList: + memberDeclarator (Comma memberDeclarator)*; + +memberDeclarator: + declarator ( + virtualSpecifierSeq? pureSpecifier? + | braceOrEqualInitializer? + ) + | Identifier? attributeSpecifierSeq? Colon constantExpression; + +virtualSpecifierSeq: virtualSpecifier+; + +virtualSpecifier: Override | Final; +/* + purespecifier: Assign '0'//Conflicts with the lexer ; + */ + +pureSpecifier: + Assign val = OctalLiteral {if($val.text.compareTo("0")!=0) throw new InputMismatchException(this); + }; +/*Derived classes*/ + +baseClause: Colon baseSpecifierList; + +baseSpecifierList: + baseSpecifier Ellipsis? (Comma baseSpecifier Ellipsis?)*; + +baseSpecifier: + attributeSpecifierSeq? ( + baseTypeSpecifier + | Virtual accessSpecifier? baseTypeSpecifier + | accessSpecifier Virtual? baseTypeSpecifier + ); + +classOrDeclType: + nestedNameSpecifier? className + | decltypeSpecifier; + +baseTypeSpecifier: classOrDeclType; + +accessSpecifier: Private | Protected | Public; +/*Special member functions*/ + +conversionFunctionId: Operator conversionTypeId; + +conversionTypeId: typeSpecifierSeq conversionDeclarator?; + +conversionDeclarator: pointerOperator conversionDeclarator?; + +constructorInitializer: Colon memInitializerList; + +memInitializerList: + memInitializer Ellipsis? (Comma memInitializer Ellipsis?)*; + +memInitializer: + meminitializerid ( + LeftParen expressionList? RightParen + | bracedInitList + ); + +meminitializerid: classOrDeclType | Identifier; +/*Overloading*/ + +operatorFunctionId: Operator theOperator; + +literalOperatorId: + Operator ( + StringLiteral Identifier + | UserDefinedStringLiteral + ); +/*Templates*/ + +templateDeclaration: + Template Less templateparameterList Greater declaration; + +templateparameterList: + templateParameter (Comma templateParameter)*; + +templateParameter: typeParameter | parameterDeclaration; + +typeParameter: + ( + (Template Less templateparameterList Greater)? Class + | Typename_ + ) ((Ellipsis? Identifier?) | (Identifier? Assign theTypeId)); + +simpleTemplateId: + templateName Less templateArgumentList? Greater; + +templateId: + simpleTemplateId + | (operatorFunctionId | literalOperatorId) Less templateArgumentList? Greater; + +templateName: Identifier; + +templateArgumentList: + templateArgument Ellipsis? (Comma templateArgument Ellipsis?)*; + +templateArgument: theTypeId | constantExpression | idExpression; + +typeNameSpecifier: + Typename_ nestedNameSpecifier ( + Identifier + | Template? simpleTemplateId + ); + +explicitInstantiation: Extern? Template declaration; + +explicitSpecialization: Template Less Greater declaration; +/*Exception handling*/ + +tryBlock: Try compoundStatement handlerSeq; + +functionTryBlock: + Try constructorInitializer? compoundStatement handlerSeq; + +handlerSeq: handler+; + +handler: + Catch LeftParen exceptionDeclaration RightParen compoundStatement; + +exceptionDeclaration: + attributeSpecifierSeq? typeSpecifierSeq ( + declarator + | abstractDeclarator + )? + | Ellipsis; + +throwExpression: Throw assignmentExpression?; + +exceptionSpecification: + dynamicExceptionSpecification + | noeExceptSpecification; + +dynamicExceptionSpecification: + Throw LeftParen typeIdList? RightParen; + +typeIdList: theTypeId Ellipsis? (Comma theTypeId Ellipsis?)*; + +noeExceptSpecification: + Noexcept LeftParen constantExpression RightParen + | Noexcept; +/*Preprocessing directives*/ + +/*Lexer*/ + +theOperator: + New (LeftBracket RightBracket)? + | Delete (LeftBracket RightBracket)? + | Plus + | Minus + | Star + | Div + | Mod + | Caret + | And + | Or + | Tilde + | Not + | Assign + | Greater + | Less + | GreaterEqual + | PlusAssign + | MinusAssign + | StarAssign + | ModAssign + | XorAssign + | AndAssign + | OrAssign + | Less Less + | Greater Greater + | RightShiftAssign + | LeftShiftAssign + | Equal + | NotEqual + | LessEqual + | AndAnd + | OrOr + | PlusPlus + | MinusMinus + | Comma + | ArrowStar + | Arrow + | LeftParen RightParen + | LeftBracket RightBracket; + +literal: + IntegerLiteral + | CharacterLiteral + | FloatingLiteral + | StringLiteral + | BooleanLiteral + | PointerLiteral + | UserDefinedLiteral; + diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Parser.interp b/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Parser.interp new file mode 100644 index 000000000..58bb3437d --- /dev/null +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Parser.interp @@ -0,0 +1,490 @@ +token literal names: +null +null +null +null +null +null +null +null +null +null +'alignas' +'alignof' +'asm' +'auto' +'bool' +'break' +'case' +'catch' +'char' +'char16_t' +'char32_t' +'class' +'const' +'constexpr' +'const_cast' +'continue' +'decltype' +'default' +'delete' +'do' +'double' +'dynamic_cast' +'else' +'enum' +'explicit' +'export' +'extern' +'false' +'final' +'float' +'for' +'friend' +'goto' +'if' +'inline' +'int' +'long' +'mutable' +'namespace' +'new' +'noexcept' +'nullptr' +'operator' +'override' +'private' +'protected' +'public' +'register' +'reinterpret_cast' +'return' +'short' +'signed' +'sizeof' +'static' +'static_assert' +'static_cast' +'struct' +'switch' +'template' +'this' +'thread_local' +'throw' +'true' +'try' +'typedef' +'typeid' +'typename' +'union' +'unsigned' +'using' +'virtual' +'void' +'volatile' +'wchar_t' +'while' +'(' +')' +'[' +']' +'{' +'}' +'+' +'-' +'*' +'/' +'%' +'^' +'&' +'|' +'~' +null +'=' +'<' +'>' +'+=' +'-=' +'*=' +'/=' +'%=' +'^=' +'&=' +'|=' +'<<=' +'>>=' +'==' +'!=' +'<=' +'>=' +null +null +'++' +'--' +',' +'->*' +'->' +'?' +':' +'::' +';' +'.' +'.*' +'...' +null +null +null +null +null +null +null +null +null +null +null +null +null +null + +token symbolic names: +null +IntegerLiteral +CharacterLiteral +FloatingLiteral +StringLiteral +BooleanLiteral +PointerLiteral +UserDefinedLiteral +MultiLineMacro +Directive +Alignas +Alignof +Asm +Auto +Bool +Break +Case +Catch +Char +Char16 +Char32 +Class +Const +Constexpr +Const_cast +Continue +Decltype +Default +Delete +Do +Double +Dynamic_cast +Else +Enum +Explicit +Export +Extern +False_ +Final +Float +For +Friend +Goto +If +Inline +Int +Long +Mutable +Namespace +New +Noexcept +Nullptr +Operator +Override +Private +Protected +Public +Register +Reinterpret_cast +Return +Short +Signed +Sizeof +Static +Static_assert +Static_cast +Struct +Switch +Template +This +Thread_local +Throw +True_ +Try +Typedef +Typeid_ +Typename_ +Union +Unsigned +Using +Virtual +Void +Volatile +Wchar +While +LeftParen +RightParen +LeftBracket +RightBracket +LeftBrace +RightBrace +Plus +Minus +Star +Div +Mod +Caret +And +Or +Tilde +Not +Assign +Less +Greater +PlusAssign +MinusAssign +StarAssign +DivAssign +ModAssign +XorAssign +AndAssign +OrAssign +LeftShiftAssign +RightShiftAssign +Equal +NotEqual +LessEqual +GreaterEqual +AndAnd +OrOr +PlusPlus +MinusMinus +Comma +ArrowStar +Arrow +Question +Colon +Doublecolon +Semi +Dot +DotStar +Ellipsis +Identifier +DecimalLiteral +OctalLiteral +HexadecimalLiteral +BinaryLiteral +Integersuffix +UserDefinedIntegerLiteral +UserDefinedFloatingLiteral +UserDefinedStringLiteral +UserDefinedCharacterLiteral +Whitespace +Newline +BlockComment +LineComment + +rule names: +translationUnit +primaryExpression +idExpression +unqualifiedId +qualifiedId +nestedNameSpecifier +lambdaExpression +lambdaIntroducer +lambdaCapture +captureDefault +captureList +capture +simpleCapture +initcapture +lambdaDeclarator +postfixExpression +typeIdOfTheTypeId +expressionList +pseudoDestructorName +unaryExpression +unaryOperator +newExpression +newPlacement +newTypeId +newDeclarator +noPointerNewDeclarator +newInitializer +deleteExpression +noExceptExpression +castExpression +pointerMemberExpression +multiplicativeExpression +additiveExpression +shiftExpression +shiftOperator +relationalExpression +equalityExpression +andExpression +exclusiveOrExpression +inclusiveOrExpression +logicalAndExpression +logicalOrExpression +conditionalExpression +assignmentExpression +assignmentOperator +expression +constantExpression +statement +labeledStatement +expressionStatement +compoundStatement +statementSeq +selectionStatement +condition +iterationStatement +forInitStatement +forRangeDeclaration +forRangeInitializer +jumpStatement +declarationStatement +declarationseq +declaration +blockDeclaration +aliasDeclaration +simpleDeclaration +staticAssertDeclaration +emptyDeclaration +attributeDeclaration +declSpecifier +declSpecifierSeq +storageClassSpecifier +functionSpecifier +typedefName +typeSpecifier +trailingTypeSpecifier +typeSpecifierSeq +trailingTypeSpecifierSeq +simpleTypeSpecifier +theTypeName +decltypeSpecifier +elaboratedTypeSpecifier +enumName +enumSpecifier +enumHead +opaqueEnumDeclaration +enumkey +enumbase +enumeratorList +enumeratorDefinition +enumerator +namespaceName +originalNamespaceName +namespaceDefinition +namespaceAlias +namespaceAliasDefinition +qualifiednamespacespecifier +usingDeclaration +usingDirective +asmDefinition +linkageSpecification +attributeSpecifierSeq +attributeSpecifier +alignmentspecifier +attributeList +attribute +attributeNamespace +attributeArgumentClause +balancedTokenSeq +balancedtoken +initDeclaratorList +initDeclarator +declarator +pointerDeclarator +noPointerDeclarator +parametersAndQualifiers +trailingReturnType +pointerOperator +cvqualifierseq +cvQualifier +refqualifier +declaratorid +theTypeId +abstractDeclarator +pointerAbstractDeclarator +noPointerAbstractDeclarator +abstractPackDeclarator +noPointerAbstractPackDeclarator +parameterDeclarationClause +parameterDeclarationList +parameterDeclaration +functionDefinition +functionBody +initializer +braceOrEqualInitializer +initializerClause +initializerList +bracedInitList +className +classSpecifier +classHead +classHeadName +classVirtSpecifier +classKey +memberSpecification +memberdeclaration +memberDeclaratorList +memberDeclarator +virtualSpecifierSeq +virtualSpecifier +pureSpecifier +baseClause +baseSpecifierList +baseSpecifier +classOrDeclType +baseTypeSpecifier +accessSpecifier +conversionFunctionId +conversionTypeId +conversionDeclarator +constructorInitializer +memInitializerList +memInitializer +meminitializerid +operatorFunctionId +literalOperatorId +templateDeclaration +templateparameterList +templateParameter +typeParameter +simpleTemplateId +templateId +templateName +templateArgumentList +templateArgument +typeNameSpecifier +explicitInstantiation +explicitSpecialization +tryBlock +functionTryBlock +handlerSeq +handler +exceptionDeclaration +throwExpression +exceptionSpecification +dynamicExceptionSpecification +typeIdList +noeExceptSpecification +theOperator +literal + + +atn: +[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 3, 147, 2077, 4, 2, 9, 2, 4, 3, 9, 3, 4, 4, 9, 4, 4, 5, 9, 5, 4, 6, 9, 6, 4, 7, 9, 7, 4, 8, 9, 8, 4, 9, 9, 9, 4, 10, 9, 10, 4, 11, 9, 11, 4, 12, 9, 12, 4, 13, 9, 13, 4, 14, 9, 14, 4, 15, 9, 15, 4, 16, 9, 16, 4, 17, 9, 17, 4, 18, 9, 18, 4, 19, 9, 19, 4, 20, 9, 20, 4, 21, 9, 21, 4, 22, 9, 22, 4, 23, 9, 23, 4, 24, 9, 24, 4, 25, 9, 25, 4, 26, 9, 26, 4, 27, 9, 27, 4, 28, 9, 28, 4, 29, 9, 29, 4, 30, 9, 30, 4, 31, 9, 31, 4, 32, 9, 32, 4, 33, 9, 33, 4, 34, 9, 34, 4, 35, 9, 35, 4, 36, 9, 36, 4, 37, 9, 37, 4, 38, 9, 38, 4, 39, 9, 39, 4, 40, 9, 40, 4, 41, 9, 41, 4, 42, 9, 42, 4, 43, 9, 43, 4, 44, 9, 44, 4, 45, 9, 45, 4, 46, 9, 46, 4, 47, 9, 47, 4, 48, 9, 48, 4, 49, 9, 49, 4, 50, 9, 50, 4, 51, 9, 51, 4, 52, 9, 52, 4, 53, 9, 53, 4, 54, 9, 54, 4, 55, 9, 55, 4, 56, 9, 56, 4, 57, 9, 57, 4, 58, 9, 58, 4, 59, 9, 59, 4, 60, 9, 60, 4, 61, 9, 61, 4, 62, 9, 62, 4, 63, 9, 63, 4, 64, 9, 64, 4, 65, 9, 65, 4, 66, 9, 66, 4, 67, 9, 67, 4, 68, 9, 68, 4, 69, 9, 69, 4, 70, 9, 70, 4, 71, 9, 71, 4, 72, 9, 72, 4, 73, 9, 73, 4, 74, 9, 74, 4, 75, 9, 75, 4, 76, 9, 76, 4, 77, 9, 77, 4, 78, 9, 78, 4, 79, 9, 79, 4, 80, 9, 80, 4, 81, 9, 81, 4, 82, 9, 82, 4, 83, 9, 83, 4, 84, 9, 84, 4, 85, 9, 85, 4, 86, 9, 86, 4, 87, 9, 87, 4, 88, 9, 88, 4, 89, 9, 89, 4, 90, 9, 90, 4, 91, 9, 91, 4, 92, 9, 92, 4, 93, 9, 93, 4, 94, 9, 94, 4, 95, 9, 95, 4, 96, 9, 96, 4, 97, 9, 97, 4, 98, 9, 98, 4, 99, 9, 99, 4, 100, 9, 100, 4, 101, 9, 101, 4, 102, 9, 102, 4, 103, 9, 103, 4, 104, 9, 104, 4, 105, 9, 105, 4, 106, 9, 106, 4, 107, 9, 107, 4, 108, 9, 108, 4, 109, 9, 109, 4, 110, 9, 110, 4, 111, 9, 111, 4, 112, 9, 112, 4, 113, 9, 113, 4, 114, 9, 114, 4, 115, 9, 115, 4, 116, 9, 116, 4, 117, 9, 117, 4, 118, 9, 118, 4, 119, 9, 119, 4, 120, 9, 120, 4, 121, 9, 121, 4, 122, 9, 122, 4, 123, 9, 123, 4, 124, 9, 124, 4, 125, 9, 125, 4, 126, 9, 126, 4, 127, 9, 127, 4, 128, 9, 128, 4, 129, 9, 129, 4, 130, 9, 130, 4, 131, 9, 131, 4, 132, 9, 132, 4, 133, 9, 133, 4, 134, 9, 134, 4, 135, 9, 135, 4, 136, 9, 136, 4, 137, 9, 137, 4, 138, 9, 138, 4, 139, 9, 139, 4, 140, 9, 140, 4, 141, 9, 141, 4, 142, 9, 142, 4, 143, 9, 143, 4, 144, 9, 144, 4, 145, 9, 145, 4, 146, 9, 146, 4, 147, 9, 147, 4, 148, 9, 148, 4, 149, 9, 149, 4, 150, 9, 150, 4, 151, 9, 151, 4, 152, 9, 152, 4, 153, 9, 153, 4, 154, 9, 154, 4, 155, 9, 155, 4, 156, 9, 156, 4, 157, 9, 157, 4, 158, 9, 158, 4, 159, 9, 159, 4, 160, 9, 160, 4, 161, 9, 161, 4, 162, 9, 162, 4, 163, 9, 163, 4, 164, 9, 164, 4, 165, 9, 165, 4, 166, 9, 166, 4, 167, 9, 167, 4, 168, 9, 168, 4, 169, 9, 169, 4, 170, 9, 170, 4, 171, 9, 171, 4, 172, 9, 172, 4, 173, 9, 173, 4, 174, 9, 174, 4, 175, 9, 175, 4, 176, 9, 176, 4, 177, 9, 177, 4, 178, 9, 178, 4, 179, 9, 179, 4, 180, 9, 180, 4, 181, 9, 181, 4, 182, 9, 182, 4, 183, 9, 183, 4, 184, 9, 184, 4, 185, 9, 185, 4, 186, 9, 186, 4, 187, 9, 187, 4, 188, 9, 188, 4, 189, 9, 189, 4, 190, 9, 190, 3, 2, 5, 2, 382, 10, 2, 3, 2, 3, 2, 3, 3, 6, 3, 387, 10, 3, 13, 3, 14, 3, 388, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 3, 398, 10, 3, 3, 4, 3, 4, 5, 4, 402, 10, 4, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 5, 5, 411, 10, 5, 3, 5, 5, 5, 414, 10, 5, 3, 6, 3, 6, 5, 6, 418, 10, 6, 3, 6, 3, 6, 3, 7, 3, 7, 3, 7, 3, 7, 5, 7, 426, 10, 7, 3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 5, 7, 433, 10, 7, 3, 7, 5, 7, 436, 10, 7, 3, 7, 7, 7, 439, 10, 7, 12, 7, 14, 7, 442, 11, 7, 3, 8, 3, 8, 5, 8, 446, 10, 8, 3, 8, 3, 8, 3, 9, 3, 9, 5, 9, 452, 10, 9, 3, 9, 3, 9, 3, 10, 3, 10, 3, 10, 3, 10, 5, 10, 460, 10, 10, 5, 10, 462, 10, 10, 3, 11, 3, 11, 3, 12, 3, 12, 3, 12, 7, 12, 469, 10, 12, 12, 12, 14, 12, 472, 11, 12, 3, 12, 5, 12, 475, 10, 12, 3, 13, 3, 13, 5, 13, 479, 10, 13, 3, 14, 5, 14, 482, 10, 14, 3, 14, 3, 14, 5, 14, 486, 10, 14, 3, 15, 5, 15, 489, 10, 15, 3, 15, 3, 15, 3, 15, 3, 16, 3, 16, 5, 16, 496, 10, 16, 3, 16, 3, 16, 5, 16, 500, 10, 16, 3, 16, 5, 16, 503, 10, 16, 3, 16, 5, 16, 506, 10, 16, 3, 16, 5, 16, 509, 10, 16, 3, 17, 3, 17, 3, 17, 3, 17, 5, 17, 515, 10, 17, 3, 17, 3, 17, 5, 17, 519, 10, 17, 3, 17, 3, 17, 5, 17, 523, 10, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 5, 17, 537, 10, 17, 3, 17, 3, 17, 5, 17, 541, 10, 17, 3, 17, 3, 17, 3, 17, 3, 17, 5, 17, 547, 10, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 5, 17, 554, 10, 17, 3, 17, 3, 17, 3, 17, 3, 17, 5, 17, 560, 10, 17, 3, 17, 3, 17, 5, 17, 564, 10, 17, 3, 17, 3, 17, 7, 17, 568, 10, 17, 12, 17, 14, 17, 571, 11, 17, 3, 18, 3, 18, 3, 19, 3, 19, 3, 20, 5, 20, 578, 10, 20, 3, 20, 3, 20, 3, 20, 5, 20, 583, 10, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 5, 20, 596, 10, 20, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 5, 21, 603, 10, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 5, 21, 615, 10, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 5, 21, 625, 10, 21, 3, 22, 3, 22, 3, 23, 5, 23, 630, 10, 23, 3, 23, 3, 23, 5, 23, 634, 10, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 5, 23, 641, 10, 23, 3, 23, 5, 23, 644, 10, 23, 3, 24, 3, 24, 3, 24, 3, 24, 3, 25, 3, 25, 5, 25, 652, 10, 25, 3, 26, 3, 26, 5, 26, 656, 10, 26, 3, 26, 5, 26, 659, 10, 26, 3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 5, 27, 666, 10, 27, 3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 5, 27, 673, 10, 27, 7, 27, 675, 10, 27, 12, 27, 14, 27, 678, 11, 27, 3, 28, 3, 28, 5, 28, 682, 10, 28, 3, 28, 3, 28, 5, 28, 686, 10, 28, 3, 29, 5, 29, 689, 10, 29, 3, 29, 3, 29, 3, 29, 5, 29, 694, 10, 29, 3, 29, 3, 29, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 5, 31, 709, 10, 31, 3, 32, 3, 32, 3, 32, 7, 32, 714, 10, 32, 12, 32, 14, 32, 717, 11, 32, 3, 33, 3, 33, 3, 33, 7, 33, 722, 10, 33, 12, 33, 14, 33, 725, 11, 33, 3, 34, 3, 34, 3, 34, 7, 34, 730, 10, 34, 12, 34, 14, 34, 733, 11, 34, 3, 35, 3, 35, 3, 35, 3, 35, 7, 35, 739, 10, 35, 12, 35, 14, 35, 742, 11, 35, 3, 36, 3, 36, 3, 36, 3, 36, 5, 36, 748, 10, 36, 3, 37, 3, 37, 3, 37, 7, 37, 753, 10, 37, 12, 37, 14, 37, 756, 11, 37, 3, 38, 3, 38, 3, 38, 7, 38, 761, 10, 38, 12, 38, 14, 38, 764, 11, 38, 3, 39, 3, 39, 3, 39, 7, 39, 769, 10, 39, 12, 39, 14, 39, 772, 11, 39, 3, 40, 3, 40, 3, 40, 7, 40, 777, 10, 40, 12, 40, 14, 40, 780, 11, 40, 3, 41, 3, 41, 3, 41, 7, 41, 785, 10, 41, 12, 41, 14, 41, 788, 11, 41, 3, 42, 3, 42, 3, 42, 7, 42, 793, 10, 42, 12, 42, 14, 42, 796, 11, 42, 3, 43, 3, 43, 3, 43, 7, 43, 801, 10, 43, 12, 43, 14, 43, 804, 11, 43, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 5, 44, 812, 10, 44, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 5, 45, 820, 10, 45, 3, 46, 3, 46, 3, 47, 3, 47, 3, 47, 7, 47, 827, 10, 47, 12, 47, 14, 47, 830, 11, 47, 3, 48, 3, 48, 3, 49, 3, 49, 5, 49, 836, 10, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 5, 49, 844, 10, 49, 3, 49, 5, 49, 847, 10, 49, 3, 50, 5, 50, 850, 10, 50, 3, 50, 3, 50, 3, 50, 3, 50, 5, 50, 856, 10, 50, 3, 50, 3, 50, 3, 50, 3, 51, 5, 51, 862, 10, 51, 3, 51, 3, 51, 3, 52, 3, 52, 5, 52, 868, 10, 52, 3, 52, 3, 52, 3, 53, 6, 53, 873, 10, 53, 13, 53, 14, 53, 874, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 5, 54, 884, 10, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 5, 54, 892, 10, 54, 3, 55, 3, 55, 5, 55, 896, 10, 55, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 5, 55, 903, 10, 55, 5, 55, 905, 10, 55, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 3, 56, 5, 56, 925, 10, 56, 3, 56, 3, 56, 5, 56, 929, 10, 56, 3, 56, 3, 56, 3, 56, 3, 56, 5, 56, 935, 10, 56, 3, 56, 3, 56, 3, 56, 5, 56, 940, 10, 56, 3, 57, 3, 57, 5, 57, 944, 10, 57, 3, 58, 5, 58, 947, 10, 58, 3, 58, 3, 58, 3, 58, 3, 59, 3, 59, 5, 59, 954, 10, 59, 3, 60, 3, 60, 3, 60, 3, 60, 3, 60, 5, 60, 961, 10, 60, 3, 60, 3, 60, 5, 60, 965, 10, 60, 3, 60, 3, 60, 3, 61, 3, 61, 3, 62, 6, 62, 972, 10, 62, 13, 62, 14, 62, 973, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 5, 63, 985, 10, 63, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 5, 64, 995, 10, 64, 3, 65, 3, 65, 3, 65, 5, 65, 1000, 10, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 66, 5, 66, 1007, 10, 66, 3, 66, 5, 66, 1010, 10, 66, 3, 66, 3, 66, 3, 66, 5, 66, 1015, 10, 66, 3, 66, 3, 66, 3, 66, 5, 66, 1020, 10, 66, 3, 67, 3, 67, 3, 67, 3, 67, 3, 67, 3, 67, 3, 67, 3, 67, 3, 68, 3, 68, 3, 69, 3, 69, 3, 69, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 3, 70, 5, 70, 1041, 10, 70, 3, 71, 6, 71, 1044, 10, 71, 13, 71, 14, 71, 1045, 3, 71, 5, 71, 1049, 10, 71, 3, 72, 3, 72, 3, 73, 3, 73, 3, 74, 3, 74, 3, 75, 3, 75, 3, 75, 5, 75, 1060, 10, 75, 3, 76, 3, 76, 3, 76, 3, 76, 5, 76, 1066, 10, 76, 3, 77, 6, 77, 1069, 10, 77, 13, 77, 14, 77, 1070, 3, 77, 5, 77, 1074, 10, 77, 3, 78, 6, 78, 1077, 10, 78, 13, 78, 14, 78, 1078, 3, 78, 5, 78, 1082, 10, 78, 3, 79, 5, 79, 1085, 10, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 3, 79, 5, 79, 1107, 10, 79, 3, 80, 3, 80, 3, 80, 3, 80, 5, 80, 1113, 10, 80, 3, 81, 3, 81, 3, 81, 3, 81, 5, 81, 1119, 10, 81, 3, 81, 3, 81, 3, 82, 3, 82, 5, 82, 1125, 10, 82, 3, 82, 5, 82, 1128, 10, 82, 3, 82, 3, 82, 3, 82, 3, 82, 5, 82, 1134, 10, 82, 3, 82, 3, 82, 5, 82, 1138, 10, 82, 3, 82, 3, 82, 5, 82, 1142, 10, 82, 3, 82, 5, 82, 1145, 10, 82, 3, 83, 3, 83, 3, 84, 3, 84, 3, 84, 3, 84, 5, 84, 1153, 10, 84, 5, 84, 1155, 10, 84, 3, 84, 3, 84, 3, 85, 3, 85, 5, 85, 1161, 10, 85, 3, 85, 5, 85, 1164, 10, 85, 3, 85, 5, 85, 1167, 10, 85, 3, 85, 5, 85, 1170, 10, 85, 3, 86, 3, 86, 5, 86, 1174, 10, 86, 3, 86, 3, 86, 5, 86, 1178, 10, 86, 3, 86, 3, 86, 3, 87, 3, 87, 5, 87, 1184, 10, 87, 3, 88, 3, 88, 3, 88, 3, 89, 3, 89, 3, 89, 7, 89, 1192, 10, 89, 12, 89, 14, 89, 1195, 11, 89, 3, 90, 3, 90, 3, 90, 5, 90, 1200, 10, 90, 3, 91, 3, 91, 3, 92, 3, 92, 5, 92, 1206, 10, 92, 3, 93, 3, 93, 3, 94, 5, 94, 1211, 10, 94, 3, 94, 3, 94, 3, 94, 5, 94, 1216, 10, 94, 3, 94, 3, 94, 5, 94, 1220, 10, 94, 3, 94, 3, 94, 3, 95, 3, 95, 3, 96, 3, 96, 3, 96, 3, 96, 3, 96, 3, 96, 3, 97, 5, 97, 1233, 10, 97, 3, 97, 3, 97, 3, 98, 3, 98, 5, 98, 1239, 10, 98, 3, 98, 3, 98, 5, 98, 1243, 10, 98, 3, 98, 3, 98, 3, 98, 3, 99, 5, 99, 1249, 10, 99, 3, 99, 3, 99, 3, 99, 5, 99, 1254, 10, 99, 3, 99, 3, 99, 3, 99, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 101, 3, 101, 3, 101, 3, 101, 5, 101, 1269, 10, 101, 3, 101, 3, 101, 5, 101, 1273, 10, 101, 3, 102, 6, 102, 1276, 10, 102, 13, 102, 14, 102, 1277, 3, 103, 3, 103, 3, 103, 5, 103, 1283, 10, 103, 3, 103, 3, 103, 3, 103, 5, 103, 1288, 10, 103, 3, 104, 3, 104, 3, 104, 3, 104, 5, 104, 1294, 10, 104, 3, 104, 5, 104, 1297, 10, 104, 3, 104, 3, 104, 3, 105, 3, 105, 3, 105, 7, 105, 1304, 10, 105, 12, 105, 14, 105, 1307, 11, 105, 3, 105, 5, 105, 1310, 10, 105, 3, 106, 3, 106, 3, 106, 5, 106, 1315, 10, 106, 3, 106, 3, 106, 5, 106, 1319, 10, 106, 3, 107, 3, 107, 3, 108, 3, 108, 5, 108, 1325, 10, 108, 3, 108, 3, 108, 3, 109, 6, 109, 1330, 10, 109, 13, 109, 14, 109, 1331, 3, 110, 3, 110, 3, 110, 3, 110, 3, 110, 3, 110, 3, 110, 3, 110, 3, 110, 3, 110, 3, 110, 3, 110, 3, 110, 6, 110, 1347, 10, 110, 13, 110, 14, 110, 1348, 5, 110, 1351, 10, 110, 3, 111, 3, 111, 3, 111, 7, 111, 1356, 10, 111, 12, 111, 14, 111, 1359, 11, 111, 3, 112, 3, 112, 5, 112, 1363, 10, 112, 3, 113, 3, 113, 3, 113, 3, 113, 3, 113, 5, 113, 1370, 10, 113, 3, 114, 3, 114, 5, 114, 1374, 10, 114, 7, 114, 1376, 10, 114, 12, 114, 14, 114, 1379, 11, 114, 3, 114, 3, 114, 3, 115, 3, 115, 3, 115, 5, 115, 1386, 10, 115, 3, 115, 3, 115, 3, 115, 3, 115, 5, 115, 1392, 10, 115, 3, 115, 3, 115, 3, 115, 3, 115, 5, 115, 1398, 10, 115, 3, 115, 3, 115, 5, 115, 1402, 10, 115, 5, 115, 1404, 10, 115, 7, 115, 1406, 10, 115, 12, 115, 14, 115, 1409, 11, 115, 3, 116, 3, 116, 5, 116, 1413, 10, 116, 3, 116, 3, 116, 5, 116, 1417, 10, 116, 3, 116, 5, 116, 1420, 10, 116, 3, 116, 5, 116, 1423, 10, 116, 3, 116, 5, 116, 1426, 10, 116, 3, 117, 3, 117, 3, 117, 5, 117, 1431, 10, 117, 3, 118, 3, 118, 5, 118, 1435, 10, 118, 3, 118, 5, 118, 1438, 10, 118, 3, 118, 3, 118, 5, 118, 1442, 10, 118, 3, 118, 5, 118, 1445, 10, 118, 5, 118, 1447, 10, 118, 3, 119, 6, 119, 1450, 10, 119, 13, 119, 14, 119, 1451, 3, 120, 3, 120, 3, 121, 3, 121, 3, 122, 5, 122, 1459, 10, 122, 3, 122, 3, 122, 3, 123, 3, 123, 5, 123, 1465, 10, 123, 3, 124, 3, 124, 5, 124, 1469, 10, 124, 3, 124, 3, 124, 3, 124, 3, 124, 5, 124, 1475, 10, 124, 3, 125, 3, 125, 6, 125, 1479, 10, 125, 13, 125, 14, 125, 1480, 3, 125, 5, 125, 1484, 10, 125, 5, 125, 1486, 10, 125, 3, 126, 3, 126, 3, 126, 3, 126, 5, 126, 1492, 10, 126, 3, 126, 3, 126, 5, 126, 1496, 10, 126, 3, 126, 3, 126, 3, 126, 3, 126, 5, 126, 1502, 10, 126, 3, 126, 3, 126, 3, 126, 3, 126, 3, 126, 5, 126, 1509, 10, 126, 3, 126, 3, 126, 5, 126, 1513, 10, 126, 5, 126, 1515, 10, 126, 7, 126, 1517, 10, 126, 12, 126, 14, 126, 1520, 11, 126, 3, 127, 7, 127, 1523, 10, 127, 12, 127, 14, 127, 1526, 11, 127, 3, 127, 3, 127, 3, 128, 3, 128, 3, 128, 3, 128, 3, 128, 3, 128, 3, 128, 5, 128, 1537, 10, 128, 3, 128, 3, 128, 5, 128, 1541, 10, 128, 5, 128, 1543, 10, 128, 7, 128, 1545, 10, 128, 12, 128, 14, 128, 1548, 11, 128, 3, 129, 3, 129, 5, 129, 1552, 10, 129, 3, 129, 5, 129, 1555, 10, 129, 3, 130, 3, 130, 3, 130, 7, 130, 1560, 10, 130, 12, 130, 14, 130, 1563, 11, 130, 3, 131, 5, 131, 1566, 10, 131, 3, 131, 3, 131, 3, 131, 5, 131, 1571, 10, 131, 5, 131, 1573, 10, 131, 3, 131, 3, 131, 5, 131, 1577, 10, 131, 3, 132, 5, 132, 1580, 10, 132, 3, 132, 5, 132, 1583, 10, 132, 3, 132, 3, 132, 5, 132, 1587, 10, 132, 3, 132, 3, 132, 3, 133, 5, 133, 1592, 10, 133, 3, 133, 3, 133, 3, 133, 3, 133, 3, 133, 5, 133, 1599, 10, 133, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 5, 134, 1606, 10, 134, 3, 135, 3, 135, 3, 135, 5, 135, 1611, 10, 135, 3, 136, 3, 136, 5, 136, 1615, 10, 136, 3, 137, 3, 137, 5, 137, 1619, 10, 137, 3, 137, 3, 137, 3, 137, 5, 137, 1624, 10, 137, 7, 137, 1626, 10, 137, 12, 137, 14, 137, 1629, 11, 137, 3, 138, 3, 138, 3, 138, 5, 138, 1634, 10, 138, 5, 138, 1636, 10, 138, 3, 138, 3, 138, 3, 139, 3, 139, 5, 139, 1642, 10, 139, 3, 140, 3, 140, 3, 140, 5, 140, 1647, 10, 140, 3, 140, 3, 140, 3, 141, 3, 141, 5, 141, 1653, 10, 141, 3, 141, 3, 141, 5, 141, 1657, 10, 141, 5, 141, 1659, 10, 141, 3, 141, 5, 141, 1662, 10, 141, 3, 141, 3, 141, 5, 141, 1666, 10, 141, 3, 141, 3, 141, 5, 141, 1670, 10, 141, 5, 141, 1672, 10, 141, 5, 141, 1674, 10, 141, 3, 142, 5, 142, 1677, 10, 142, 3, 142, 3, 142, 3, 143, 3, 143, 3, 144, 3, 144, 3, 145, 3, 145, 3, 145, 3, 145, 6, 145, 1689, 10, 145, 13, 145, 14, 145, 1690, 3, 146, 5, 146, 1694, 10, 146, 3, 146, 5, 146, 1697, 10, 146, 3, 146, 5, 146, 1700, 10, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 3, 146, 5, 146, 1709, 10, 146, 3, 147, 3, 147, 3, 147, 7, 147, 1714, 10, 147, 12, 147, 14, 147, 1717, 11, 147, 3, 148, 3, 148, 5, 148, 1721, 10, 148, 3, 148, 5, 148, 1724, 10, 148, 3, 148, 5, 148, 1727, 10, 148, 5, 148, 1729, 10, 148, 3, 148, 5, 148, 1732, 10, 148, 3, 148, 5, 148, 1735, 10, 148, 3, 148, 3, 148, 5, 148, 1739, 10, 148, 3, 149, 6, 149, 1742, 10, 149, 13, 149, 14, 149, 1743, 3, 150, 3, 150, 3, 151, 3, 151, 3, 151, 3, 151, 3, 152, 3, 152, 3, 152, 3, 153, 3, 153, 5, 153, 1757, 10, 153, 3, 153, 3, 153, 3, 153, 5, 153, 1762, 10, 153, 7, 153, 1764, 10, 153, 12, 153, 14, 153, 1767, 11, 153, 3, 154, 5, 154, 1770, 10, 154, 3, 154, 3, 154, 3, 154, 5, 154, 1775, 10, 154, 3, 154, 3, 154, 3, 154, 5, 154, 1780, 10, 154, 3, 154, 3, 154, 5, 154, 1784, 10, 154, 3, 155, 5, 155, 1787, 10, 155, 3, 155, 3, 155, 5, 155, 1791, 10, 155, 3, 156, 3, 156, 3, 157, 3, 157, 3, 158, 3, 158, 3, 158, 3, 159, 3, 159, 5, 159, 1802, 10, 159, 3, 160, 3, 160, 5, 160, 1806, 10, 160, 3, 161, 3, 161, 3, 161, 3, 162, 3, 162, 5, 162, 1813, 10, 162, 3, 162, 3, 162, 3, 162, 5, 162, 1818, 10, 162, 7, 162, 1820, 10, 162, 12, 162, 14, 162, 1823, 11, 162, 3, 163, 3, 163, 3, 163, 5, 163, 1828, 10, 163, 3, 163, 3, 163, 5, 163, 1832, 10, 163, 3, 164, 3, 164, 5, 164, 1836, 10, 164, 3, 165, 3, 165, 3, 165, 3, 166, 3, 166, 3, 166, 3, 166, 5, 166, 1845, 10, 166, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 168, 3, 168, 3, 168, 7, 168, 1856, 10, 168, 12, 168, 14, 168, 1859, 11, 168, 3, 169, 3, 169, 5, 169, 1863, 10, 169, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 5, 170, 1870, 10, 170, 3, 170, 3, 170, 5, 170, 1874, 10, 170, 3, 170, 5, 170, 1877, 10, 170, 3, 170, 5, 170, 1880, 10, 170, 3, 170, 5, 170, 1883, 10, 170, 3, 170, 3, 170, 5, 170, 1887, 10, 170, 3, 171, 3, 171, 3, 171, 5, 171, 1892, 10, 171, 3, 171, 3, 171, 3, 172, 3, 172, 3, 172, 5, 172, 1899, 10, 172, 3, 172, 3, 172, 5, 172, 1903, 10, 172, 3, 172, 3, 172, 5, 172, 1907, 10, 172, 3, 173, 3, 173, 3, 174, 3, 174, 5, 174, 1913, 10, 174, 3, 174, 3, 174, 3, 174, 5, 174, 1918, 10, 174, 7, 174, 1920, 10, 174, 12, 174, 14, 174, 1923, 11, 174, 3, 175, 3, 175, 3, 175, 5, 175, 1928, 10, 175, 3, 176, 3, 176, 3, 176, 3, 176, 5, 176, 1934, 10, 176, 3, 176, 5, 176, 1937, 10, 176, 3, 177, 5, 177, 1940, 10, 177, 3, 177, 3, 177, 3, 177, 3, 178, 3, 178, 3, 178, 3, 178, 3, 178, 3, 179, 3, 179, 3, 179, 3, 179, 3, 180, 3, 180, 5, 180, 1956, 10, 180, 3, 180, 3, 180, 3, 180, 3, 181, 6, 181, 1962, 10, 181, 13, 181, 14, 181, 1963, 3, 182, 3, 182, 3, 182, 3, 182, 3, 182, 3, 182, 3, 183, 5, 183, 1973, 10, 183, 3, 183, 3, 183, 3, 183, 5, 183, 1978, 10, 183, 3, 183, 5, 183, 1981, 10, 183, 3, 184, 3, 184, 5, 184, 1985, 10, 184, 3, 185, 3, 185, 5, 185, 1989, 10, 185, 3, 186, 3, 186, 3, 186, 5, 186, 1994, 10, 186, 3, 186, 3, 186, 3, 187, 3, 187, 5, 187, 2000, 10, 187, 3, 187, 3, 187, 3, 187, 5, 187, 2005, 10, 187, 7, 187, 2007, 10, 187, 12, 187, 14, 187, 2010, 11, 187, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 5, 188, 2018, 10, 188, 3, 189, 3, 189, 3, 189, 5, 189, 2023, 10, 189, 3, 189, 3, 189, 3, 189, 5, 189, 2028, 10, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 3, 189, 5, 189, 2073, 10, 189, 3, 190, 3, 190, 3, 190, 2, 8, 12, 32, 52, 228, 250, 254, 191, 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, 288, 290, 292, 294, 296, 298, 300, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 332, 334, 336, 338, 340, 342, 344, 346, 348, 350, 352, 354, 356, 358, 360, 362, 364, 366, 368, 370, 372, 374, 376, 378, 2, 23, 4, 2, 99, 99, 103, 103, 6, 2, 26, 26, 33, 33, 60, 60, 67, 67, 4, 2, 126, 126, 131, 131, 3, 2, 122, 123, 4, 2, 93, 95, 99, 102, 4, 2, 125, 125, 132, 132, 3, 2, 95, 97, 3, 2, 93, 94, 4, 2, 104, 105, 118, 119, 3, 2, 116, 117, 4, 2, 103, 103, 106, 115, 7, 2, 38, 38, 49, 49, 59, 59, 65, 65, 72, 72, 5, 2, 36, 36, 46, 46, 82, 82, 4, 2, 23, 23, 68, 68, 3, 2, 87, 92, 4, 2, 99, 99, 120, 120, 4, 2, 24, 24, 84, 84, 3, 2, 29, 30, 4, 2, 40, 40, 55, 55, 3, 2, 56, 58, 3, 2, 3, 9, 2, 2307, 2, 381, 3, 2, 2, 2, 4, 397, 3, 2, 2, 2, 6, 401, 3, 2, 2, 2, 8, 413, 3, 2, 2, 2, 10, 415, 3, 2, 2, 2, 12, 421, 3, 2, 2, 2, 14, 443, 3, 2, 2, 2, 16, 449, 3, 2, 2, 2, 18, 461, 3, 2, 2, 2, 20, 463, 3, 2, 2, 2, 22, 465, 3, 2, 2, 2, 24, 478, 3, 2, 2, 2, 26, 485, 3, 2, 2, 2, 28, 488, 3, 2, 2, 2, 30, 493, 3, 2, 2, 2, 32, 540, 3, 2, 2, 2, 34, 572, 3, 2, 2, 2, 36, 574, 3, 2, 2, 2, 38, 595, 3, 2, 2, 2, 40, 624, 3, 2, 2, 2, 42, 626, 3, 2, 2, 2, 44, 629, 3, 2, 2, 2, 46, 645, 3, 2, 2, 2, 48, 649, 3, 2, 2, 2, 50, 658, 3, 2, 2, 2, 52, 660, 3, 2, 2, 2, 54, 685, 3, 2, 2, 2, 56, 688, 3, 2, 2, 2, 58, 697, 3, 2, 2, 2, 60, 708, 3, 2, 2, 2, 62, 710, 3, 2, 2, 2, 64, 718, 3, 2, 2, 2, 66, 726, 3, 2, 2, 2, 68, 734, 3, 2, 2, 2, 70, 747, 3, 2, 2, 2, 72, 749, 3, 2, 2, 2, 74, 757, 3, 2, 2, 2, 76, 765, 3, 2, 2, 2, 78, 773, 3, 2, 2, 2, 80, 781, 3, 2, 2, 2, 82, 789, 3, 2, 2, 2, 84, 797, 3, 2, 2, 2, 86, 805, 3, 2, 2, 2, 88, 819, 3, 2, 2, 2, 90, 821, 3, 2, 2, 2, 92, 823, 3, 2, 2, 2, 94, 831, 3, 2, 2, 2, 96, 846, 3, 2, 2, 2, 98, 849, 3, 2, 2, 2, 100, 861, 3, 2, 2, 2, 102, 865, 3, 2, 2, 2, 104, 872, 3, 2, 2, 2, 106, 891, 3, 2, 2, 2, 108, 904, 3, 2, 2, 2, 110, 939, 3, 2, 2, 2, 112, 943, 3, 2, 2, 2, 114, 946, 3, 2, 2, 2, 116, 953, 3, 2, 2, 2, 118, 964, 3, 2, 2, 2, 120, 968, 3, 2, 2, 2, 122, 971, 3, 2, 2, 2, 124, 984, 3, 2, 2, 2, 126, 994, 3, 2, 2, 2, 128, 996, 3, 2, 2, 2, 130, 1019, 3, 2, 2, 2, 132, 1021, 3, 2, 2, 2, 134, 1029, 3, 2, 2, 2, 136, 1031, 3, 2, 2, 2, 138, 1040, 3, 2, 2, 2, 140, 1043, 3, 2, 2, 2, 142, 1050, 3, 2, 2, 2, 144, 1052, 3, 2, 2, 2, 146, 1054, 3, 2, 2, 2, 148, 1059, 3, 2, 2, 2, 150, 1065, 3, 2, 2, 2, 152, 1068, 3, 2, 2, 2, 154, 1076, 3, 2, 2, 2, 156, 1106, 3, 2, 2, 2, 158, 1112, 3, 2, 2, 2, 160, 1114, 3, 2, 2, 2, 162, 1144, 3, 2, 2, 2, 164, 1146, 3, 2, 2, 2, 166, 1148, 3, 2, 2, 2, 168, 1158, 3, 2, 2, 2, 170, 1171, 3, 2, 2, 2, 172, 1181, 3, 2, 2, 2, 174, 1185, 3, 2, 2, 2, 176, 1188, 3, 2, 2, 2, 178, 1196, 3, 2, 2, 2, 180, 1201, 3, 2, 2, 2, 182, 1205, 3, 2, 2, 2, 184, 1207, 3, 2, 2, 2, 186, 1210, 3, 2, 2, 2, 188, 1223, 3, 2, 2, 2, 190, 1225, 3, 2, 2, 2, 192, 1232, 3, 2, 2, 2, 194, 1236, 3, 2, 2, 2, 196, 1248, 3, 2, 2, 2, 198, 1258, 3, 2, 2, 2, 200, 1264, 3, 2, 2, 2, 202, 1275, 3, 2, 2, 2, 204, 1287, 3, 2, 2, 2, 206, 1289, 3, 2, 2, 2, 208, 1300, 3, 2, 2, 2, 210, 1314, 3, 2, 2, 2, 212, 1320, 3, 2, 2, 2, 214, 1322, 3, 2, 2, 2, 216, 1329, 3, 2, 2, 2, 218, 1350, 3, 2, 2, 2, 220, 1352, 3, 2, 2, 2, 222, 1360, 3, 2, 2, 2, 224, 1369, 3, 2, 2, 2, 226, 1377, 3, 2, 2, 2, 228, 1391, 3, 2, 2, 2, 230, 1410, 3, 2, 2, 2, 232, 1427, 3, 2, 2, 2, 234, 1446, 3, 2, 2, 2, 236, 1449, 3, 2, 2, 2, 238, 1453, 3, 2, 2, 2, 240, 1455, 3, 2, 2, 2, 242, 1458, 3, 2, 2, 2, 244, 1462, 3, 2, 2, 2, 246, 1474, 3, 2, 2, 2, 248, 1485, 3, 2, 2, 2, 250, 1501, 3, 2, 2, 2, 252, 1524, 3, 2, 2, 2, 254, 1529, 3, 2, 2, 2, 256, 1549, 3, 2, 2, 2, 258, 1556, 3, 2, 2, 2, 260, 1565, 3, 2, 2, 2, 262, 1579, 3, 2, 2, 2, 264, 1598, 3, 2, 2, 2, 266, 1605, 3, 2, 2, 2, 268, 1610, 3, 2, 2, 2, 270, 1614, 3, 2, 2, 2, 272, 1616, 3, 2, 2, 2, 274, 1630, 3, 2, 2, 2, 276, 1641, 3, 2, 2, 2, 278, 1643, 3, 2, 2, 2, 280, 1673, 3, 2, 2, 2, 282, 1676, 3, 2, 2, 2, 284, 1680, 3, 2, 2, 2, 286, 1682, 3, 2, 2, 2, 288, 1688, 3, 2, 2, 2, 290, 1708, 3, 2, 2, 2, 292, 1710, 3, 2, 2, 2, 294, 1738, 3, 2, 2, 2, 296, 1741, 3, 2, 2, 2, 298, 1745, 3, 2, 2, 2, 300, 1747, 3, 2, 2, 2, 302, 1751, 3, 2, 2, 2, 304, 1754, 3, 2, 2, 2, 306, 1769, 3, 2, 2, 2, 308, 1790, 3, 2, 2, 2, 310, 1792, 3, 2, 2, 2, 312, 1794, 3, 2, 2, 2, 314, 1796, 3, 2, 2, 2, 316, 1799, 3, 2, 2, 2, 318, 1803, 3, 2, 2, 2, 320, 1807, 3, 2, 2, 2, 322, 1810, 3, 2, 2, 2, 324, 1824, 3, 2, 2, 2, 326, 1835, 3, 2, 2, 2, 328, 1837, 3, 2, 2, 2, 330, 1840, 3, 2, 2, 2, 332, 1846, 3, 2, 2, 2, 334, 1852, 3, 2, 2, 2, 336, 1862, 3, 2, 2, 2, 338, 1873, 3, 2, 2, 2, 340, 1888, 3, 2, 2, 2, 342, 1906, 3, 2, 2, 2, 344, 1908, 3, 2, 2, 2, 346, 1910, 3, 2, 2, 2, 348, 1927, 3, 2, 2, 2, 350, 1929, 3, 2, 2, 2, 352, 1939, 3, 2, 2, 2, 354, 1944, 3, 2, 2, 2, 356, 1949, 3, 2, 2, 2, 358, 1953, 3, 2, 2, 2, 360, 1961, 3, 2, 2, 2, 362, 1965, 3, 2, 2, 2, 364, 1980, 3, 2, 2, 2, 366, 1982, 3, 2, 2, 2, 368, 1988, 3, 2, 2, 2, 370, 1990, 3, 2, 2, 2, 372, 1997, 3, 2, 2, 2, 374, 2017, 3, 2, 2, 2, 376, 2072, 3, 2, 2, 2, 378, 2074, 3, 2, 2, 2, 380, 382, 5, 122, 62, 2, 381, 380, 3, 2, 2, 2, 381, 382, 3, 2, 2, 2, 382, 383, 3, 2, 2, 2, 383, 384, 7, 2, 2, 3, 384, 3, 3, 2, 2, 2, 385, 387, 5, 378, 190, 2, 386, 385, 3, 2, 2, 2, 387, 388, 3, 2, 2, 2, 388, 386, 3, 2, 2, 2, 388, 389, 3, 2, 2, 2, 389, 398, 3, 2, 2, 2, 390, 398, 7, 71, 2, 2, 391, 392, 7, 87, 2, 2, 392, 393, 5, 92, 47, 2, 393, 394, 7, 88, 2, 2, 394, 398, 3, 2, 2, 2, 395, 398, 5, 6, 4, 2, 396, 398, 5, 14, 8, 2, 397, 386, 3, 2, 2, 2, 397, 390, 3, 2, 2, 2, 397, 391, 3, 2, 2, 2, 397, 395, 3, 2, 2, 2, 397, 396, 3, 2, 2, 2, 398, 5, 3, 2, 2, 2, 399, 402, 5, 8, 5, 2, 400, 402, 5, 10, 6, 2, 401, 399, 3, 2, 2, 2, 401, 400, 3, 2, 2, 2, 402, 7, 3, 2, 2, 2, 403, 414, 7, 134, 2, 2, 404, 414, 5, 328, 165, 2, 405, 414, 5, 314, 158, 2, 406, 414, 5, 330, 166, 2, 407, 410, 7, 101, 2, 2, 408, 411, 5, 276, 139, 2, 409, 411, 5, 160, 81, 2, 410, 408, 3, 2, 2, 2, 410, 409, 3, 2, 2, 2, 411, 414, 3, 2, 2, 2, 412, 414, 5, 342, 172, 2, 413, 403, 3, 2, 2, 2, 413, 404, 3, 2, 2, 2, 413, 405, 3, 2, 2, 2, 413, 406, 3, 2, 2, 2, 413, 407, 3, 2, 2, 2, 413, 412, 3, 2, 2, 2, 414, 9, 3, 2, 2, 2, 415, 417, 5, 12, 7, 2, 416, 418, 7, 70, 2, 2, 417, 416, 3, 2, 2, 2, 417, 418, 3, 2, 2, 2, 418, 419, 3, 2, 2, 2, 419, 420, 5, 8, 5, 2, 420, 11, 3, 2, 2, 2, 421, 425, 8, 7, 1, 2, 422, 426, 5, 158, 80, 2, 423, 426, 5, 182, 92, 2, 424, 426, 5, 160, 81, 2, 425, 422, 3, 2, 2, 2, 425, 423, 3, 2, 2, 2, 425, 424, 3, 2, 2, 2, 425, 426, 3, 2, 2, 2, 426, 427, 3, 2, 2, 2, 427, 428, 7, 129, 2, 2, 428, 440, 3, 2, 2, 2, 429, 435, 12, 3, 2, 2, 430, 436, 7, 134, 2, 2, 431, 433, 7, 70, 2, 2, 432, 431, 3, 2, 2, 2, 432, 433, 3, 2, 2, 2, 433, 434, 3, 2, 2, 2, 434, 436, 5, 340, 171, 2, 435, 430, 3, 2, 2, 2, 435, 432, 3, 2, 2, 2, 436, 437, 3, 2, 2, 2, 437, 439, 7, 129, 2, 2, 438, 429, 3, 2, 2, 2, 439, 442, 3, 2, 2, 2, 440, 438, 3, 2, 2, 2, 440, 441, 3, 2, 2, 2, 441, 13, 3, 2, 2, 2, 442, 440, 3, 2, 2, 2, 443, 445, 5, 16, 9, 2, 444, 446, 5, 30, 16, 2, 445, 444, 3, 2, 2, 2, 445, 446, 3, 2, 2, 2, 446, 447, 3, 2, 2, 2, 447, 448, 5, 102, 52, 2, 448, 15, 3, 2, 2, 2, 449, 451, 7, 89, 2, 2, 450, 452, 5, 18, 10, 2, 451, 450, 3, 2, 2, 2, 451, 452, 3, 2, 2, 2, 452, 453, 3, 2, 2, 2, 453, 454, 7, 90, 2, 2, 454, 17, 3, 2, 2, 2, 455, 462, 5, 22, 12, 2, 456, 459, 5, 20, 11, 2, 457, 458, 7, 124, 2, 2, 458, 460, 5, 22, 12, 2, 459, 457, 3, 2, 2, 2, 459, 460, 3, 2, 2, 2, 460, 462, 3, 2, 2, 2, 461, 455, 3, 2, 2, 2, 461, 456, 3, 2, 2, 2, 462, 19, 3, 2, 2, 2, 463, 464, 9, 2, 2, 2, 464, 21, 3, 2, 2, 2, 465, 470, 5, 24, 13, 2, 466, 467, 7, 124, 2, 2, 467, 469, 5, 24, 13, 2, 468, 466, 3, 2, 2, 2, 469, 472, 3, 2, 2, 2, 470, 468, 3, 2, 2, 2, 470, 471, 3, 2, 2, 2, 471, 474, 3, 2, 2, 2, 472, 470, 3, 2, 2, 2, 473, 475, 7, 133, 2, 2, 474, 473, 3, 2, 2, 2, 474, 475, 3, 2, 2, 2, 475, 23, 3, 2, 2, 2, 476, 479, 5, 26, 14, 2, 477, 479, 5, 28, 15, 2, 478, 476, 3, 2, 2, 2, 478, 477, 3, 2, 2, 2, 479, 25, 3, 2, 2, 2, 480, 482, 7, 99, 2, 2, 481, 480, 3, 2, 2, 2, 481, 482, 3, 2, 2, 2, 482, 483, 3, 2, 2, 2, 483, 486, 7, 134, 2, 2, 484, 486, 7, 71, 2, 2, 485, 481, 3, 2, 2, 2, 485, 484, 3, 2, 2, 2, 486, 27, 3, 2, 2, 2, 487, 489, 7, 99, 2, 2, 488, 487, 3, 2, 2, 2, 488, 489, 3, 2, 2, 2, 489, 490, 3, 2, 2, 2, 490, 491, 7, 134, 2, 2, 491, 492, 5, 266, 134, 2, 492, 29, 3, 2, 2, 2, 493, 495, 7, 87, 2, 2, 494, 496, 5, 256, 129, 2, 495, 494, 3, 2, 2, 2, 495, 496, 3, 2, 2, 2, 496, 497, 3, 2, 2, 2, 497, 499, 7, 88, 2, 2, 498, 500, 7, 49, 2, 2, 499, 498, 3, 2, 2, 2, 499, 500, 3, 2, 2, 2, 500, 502, 3, 2, 2, 2, 501, 503, 5, 368, 185, 2, 502, 501, 3, 2, 2, 2, 502, 503, 3, 2, 2, 2, 503, 505, 3, 2, 2, 2, 504, 506, 5, 202, 102, 2, 505, 504, 3, 2, 2, 2, 505, 506, 3, 2, 2, 2, 506, 508, 3, 2, 2, 2, 507, 509, 5, 232, 117, 2, 508, 507, 3, 2, 2, 2, 508, 509, 3, 2, 2, 2, 509, 31, 3, 2, 2, 2, 510, 511, 8, 17, 1, 2, 511, 541, 5, 4, 3, 2, 512, 515, 5, 156, 79, 2, 513, 515, 5, 350, 176, 2, 514, 512, 3, 2, 2, 2, 514, 513, 3, 2, 2, 2, 515, 522, 3, 2, 2, 2, 516, 518, 7, 87, 2, 2, 517, 519, 5, 36, 19, 2, 518, 517, 3, 2, 2, 2, 518, 519, 3, 2, 2, 2, 519, 520, 3, 2, 2, 2, 520, 523, 7, 88, 2, 2, 521, 523, 5, 274, 138, 2, 522, 516, 3, 2, 2, 2, 522, 521, 3, 2, 2, 2, 523, 541, 3, 2, 2, 2, 524, 525, 9, 3, 2, 2, 525, 526, 7, 104, 2, 2, 526, 527, 5, 244, 123, 2, 527, 528, 7, 105, 2, 2, 528, 529, 7, 87, 2, 2, 529, 530, 5, 92, 47, 2, 530, 531, 7, 88, 2, 2, 531, 541, 3, 2, 2, 2, 532, 533, 5, 34, 18, 2, 533, 536, 7, 87, 2, 2, 534, 537, 5, 92, 47, 2, 535, 537, 5, 244, 123, 2, 536, 534, 3, 2, 2, 2, 536, 535, 3, 2, 2, 2, 537, 538, 3, 2, 2, 2, 538, 539, 7, 88, 2, 2, 539, 541, 3, 2, 2, 2, 540, 510, 3, 2, 2, 2, 540, 514, 3, 2, 2, 2, 540, 524, 3, 2, 2, 2, 540, 532, 3, 2, 2, 2, 541, 569, 3, 2, 2, 2, 542, 543, 12, 9, 2, 2, 543, 546, 7, 89, 2, 2, 544, 547, 5, 92, 47, 2, 545, 547, 5, 274, 138, 2, 546, 544, 3, 2, 2, 2, 546, 545, 3, 2, 2, 2, 547, 548, 3, 2, 2, 2, 548, 549, 7, 90, 2, 2, 549, 568, 3, 2, 2, 2, 550, 551, 12, 8, 2, 2, 551, 553, 7, 87, 2, 2, 552, 554, 5, 36, 19, 2, 553, 552, 3, 2, 2, 2, 553, 554, 3, 2, 2, 2, 554, 555, 3, 2, 2, 2, 555, 568, 7, 88, 2, 2, 556, 557, 12, 6, 2, 2, 557, 563, 9, 4, 2, 2, 558, 560, 7, 70, 2, 2, 559, 558, 3, 2, 2, 2, 559, 560, 3, 2, 2, 2, 560, 561, 3, 2, 2, 2, 561, 564, 5, 6, 4, 2, 562, 564, 5, 38, 20, 2, 563, 559, 3, 2, 2, 2, 563, 562, 3, 2, 2, 2, 564, 568, 3, 2, 2, 2, 565, 566, 12, 5, 2, 2, 566, 568, 9, 5, 2, 2, 567, 542, 3, 2, 2, 2, 567, 550, 3, 2, 2, 2, 567, 556, 3, 2, 2, 2, 567, 565, 3, 2, 2, 2, 568, 571, 3, 2, 2, 2, 569, 567, 3, 2, 2, 2, 569, 570, 3, 2, 2, 2, 570, 33, 3, 2, 2, 2, 571, 569, 3, 2, 2, 2, 572, 573, 7, 77, 2, 2, 573, 35, 3, 2, 2, 2, 574, 575, 5, 272, 137, 2, 575, 37, 3, 2, 2, 2, 576, 578, 5, 12, 7, 2, 577, 576, 3, 2, 2, 2, 577, 578, 3, 2, 2, 2, 578, 582, 3, 2, 2, 2, 579, 580, 5, 158, 80, 2, 580, 581, 7, 129, 2, 2, 581, 583, 3, 2, 2, 2, 582, 579, 3, 2, 2, 2, 582, 583, 3, 2, 2, 2, 583, 584, 3, 2, 2, 2, 584, 585, 7, 101, 2, 2, 585, 596, 5, 158, 80, 2, 586, 587, 5, 12, 7, 2, 587, 588, 7, 70, 2, 2, 588, 589, 5, 340, 171, 2, 589, 590, 7, 129, 2, 2, 590, 591, 7, 101, 2, 2, 591, 592, 5, 158, 80, 2, 592, 596, 3, 2, 2, 2, 593, 594, 7, 101, 2, 2, 594, 596, 5, 160, 81, 2, 595, 577, 3, 2, 2, 2, 595, 586, 3, 2, 2, 2, 595, 593, 3, 2, 2, 2, 596, 39, 3, 2, 2, 2, 597, 625, 5, 32, 17, 2, 598, 603, 7, 122, 2, 2, 599, 603, 7, 123, 2, 2, 600, 603, 5, 42, 22, 2, 601, 603, 7, 64, 2, 2, 602, 598, 3, 2, 2, 2, 602, 599, 3, 2, 2, 2, 602, 600, 3, 2, 2, 2, 602, 601, 3, 2, 2, 2, 603, 604, 3, 2, 2, 2, 604, 625, 5, 40, 21, 2, 605, 614, 7, 64, 2, 2, 606, 607, 7, 87, 2, 2, 607, 608, 5, 244, 123, 2, 608, 609, 7, 88, 2, 2, 609, 615, 3, 2, 2, 2, 610, 611, 7, 133, 2, 2, 611, 612, 7, 87, 2, 2, 612, 613, 7, 134, 2, 2, 613, 615, 7, 88, 2, 2, 614, 606, 3, 2, 2, 2, 614, 610, 3, 2, 2, 2, 615, 625, 3, 2, 2, 2, 616, 617, 7, 13, 2, 2, 617, 618, 7, 87, 2, 2, 618, 619, 5, 244, 123, 2, 619, 620, 7, 88, 2, 2, 620, 625, 3, 2, 2, 2, 621, 625, 5, 58, 30, 2, 622, 625, 5, 44, 23, 2, 623, 625, 5, 56, 29, 2, 624, 597, 3, 2, 2, 2, 624, 602, 3, 2, 2, 2, 624, 605, 3, 2, 2, 2, 624, 616, 3, 2, 2, 2, 624, 621, 3, 2, 2, 2, 624, 622, 3, 2, 2, 2, 624, 623, 3, 2, 2, 2, 625, 41, 3, 2, 2, 2, 626, 627, 9, 6, 2, 2, 627, 43, 3, 2, 2, 2, 628, 630, 7, 129, 2, 2, 629, 628, 3, 2, 2, 2, 629, 630, 3, 2, 2, 2, 630, 631, 3, 2, 2, 2, 631, 633, 7, 51, 2, 2, 632, 634, 5, 46, 24, 2, 633, 632, 3, 2, 2, 2, 633, 634, 3, 2, 2, 2, 634, 640, 3, 2, 2, 2, 635, 641, 5, 48, 25, 2, 636, 637, 7, 87, 2, 2, 637, 638, 5, 244, 123, 2, 638, 639, 7, 88, 2, 2, 639, 641, 3, 2, 2, 2, 640, 635, 3, 2, 2, 2, 640, 636, 3, 2, 2, 2, 641, 643, 3, 2, 2, 2, 642, 644, 5, 54, 28, 2, 643, 642, 3, 2, 2, 2, 643, 644, 3, 2, 2, 2, 644, 45, 3, 2, 2, 2, 645, 646, 7, 87, 2, 2, 646, 647, 5, 36, 19, 2, 647, 648, 7, 88, 2, 2, 648, 47, 3, 2, 2, 2, 649, 651, 5, 152, 77, 2, 650, 652, 5, 50, 26, 2, 651, 650, 3, 2, 2, 2, 651, 652, 3, 2, 2, 2, 652, 49, 3, 2, 2, 2, 653, 655, 5, 234, 118, 2, 654, 656, 5, 50, 26, 2, 655, 654, 3, 2, 2, 2, 655, 656, 3, 2, 2, 2, 656, 659, 3, 2, 2, 2, 657, 659, 5, 52, 27, 2, 658, 653, 3, 2, 2, 2, 658, 657, 3, 2, 2, 2, 659, 51, 3, 2, 2, 2, 660, 661, 8, 27, 1, 2, 661, 662, 7, 89, 2, 2, 662, 663, 5, 92, 47, 2, 663, 665, 7, 90, 2, 2, 664, 666, 5, 202, 102, 2, 665, 664, 3, 2, 2, 2, 665, 666, 3, 2, 2, 2, 666, 676, 3, 2, 2, 2, 667, 668, 12, 3, 2, 2, 668, 669, 7, 89, 2, 2, 669, 670, 5, 94, 48, 2, 670, 672, 7, 90, 2, 2, 671, 673, 5, 202, 102, 2, 672, 671, 3, 2, 2, 2, 672, 673, 3, 2, 2, 2, 673, 675, 3, 2, 2, 2, 674, 667, 3, 2, 2, 2, 675, 678, 3, 2, 2, 2, 676, 674, 3, 2, 2, 2, 676, 677, 3, 2, 2, 2, 677, 53, 3, 2, 2, 2, 678, 676, 3, 2, 2, 2, 679, 681, 7, 87, 2, 2, 680, 682, 5, 36, 19, 2, 681, 680, 3, 2, 2, 2, 681, 682, 3, 2, 2, 2, 682, 683, 3, 2, 2, 2, 683, 686, 7, 88, 2, 2, 684, 686, 5, 274, 138, 2, 685, 679, 3, 2, 2, 2, 685, 684, 3, 2, 2, 2, 686, 55, 3, 2, 2, 2, 687, 689, 7, 129, 2, 2, 688, 687, 3, 2, 2, 2, 688, 689, 3, 2, 2, 2, 689, 690, 3, 2, 2, 2, 690, 693, 7, 30, 2, 2, 691, 692, 7, 89, 2, 2, 692, 694, 7, 90, 2, 2, 693, 691, 3, 2, 2, 2, 693, 694, 3, 2, 2, 2, 694, 695, 3, 2, 2, 2, 695, 696, 5, 60, 31, 2, 696, 57, 3, 2, 2, 2, 697, 698, 7, 52, 2, 2, 698, 699, 7, 87, 2, 2, 699, 700, 5, 92, 47, 2, 700, 701, 7, 88, 2, 2, 701, 59, 3, 2, 2, 2, 702, 709, 5, 40, 21, 2, 703, 704, 7, 87, 2, 2, 704, 705, 5, 244, 123, 2, 705, 706, 7, 88, 2, 2, 706, 707, 5, 60, 31, 2, 707, 709, 3, 2, 2, 2, 708, 702, 3, 2, 2, 2, 708, 703, 3, 2, 2, 2, 709, 61, 3, 2, 2, 2, 710, 715, 5, 60, 31, 2, 711, 712, 9, 7, 2, 2, 712, 714, 5, 60, 31, 2, 713, 711, 3, 2, 2, 2, 714, 717, 3, 2, 2, 2, 715, 713, 3, 2, 2, 2, 715, 716, 3, 2, 2, 2, 716, 63, 3, 2, 2, 2, 717, 715, 3, 2, 2, 2, 718, 723, 5, 62, 32, 2, 719, 720, 9, 8, 2, 2, 720, 722, 5, 62, 32, 2, 721, 719, 3, 2, 2, 2, 722, 725, 3, 2, 2, 2, 723, 721, 3, 2, 2, 2, 723, 724, 3, 2, 2, 2, 724, 65, 3, 2, 2, 2, 725, 723, 3, 2, 2, 2, 726, 731, 5, 64, 33, 2, 727, 728, 9, 9, 2, 2, 728, 730, 5, 64, 33, 2, 729, 727, 3, 2, 2, 2, 730, 733, 3, 2, 2, 2, 731, 729, 3, 2, 2, 2, 731, 732, 3, 2, 2, 2, 732, 67, 3, 2, 2, 2, 733, 731, 3, 2, 2, 2, 734, 740, 5, 66, 34, 2, 735, 736, 5, 70, 36, 2, 736, 737, 5, 66, 34, 2, 737, 739, 3, 2, 2, 2, 738, 735, 3, 2, 2, 2, 739, 742, 3, 2, 2, 2, 740, 738, 3, 2, 2, 2, 740, 741, 3, 2, 2, 2, 741, 69, 3, 2, 2, 2, 742, 740, 3, 2, 2, 2, 743, 744, 7, 105, 2, 2, 744, 748, 7, 105, 2, 2, 745, 746, 7, 104, 2, 2, 746, 748, 7, 104, 2, 2, 747, 743, 3, 2, 2, 2, 747, 745, 3, 2, 2, 2, 748, 71, 3, 2, 2, 2, 749, 754, 5, 68, 35, 2, 750, 751, 9, 10, 2, 2, 751, 753, 5, 68, 35, 2, 752, 750, 3, 2, 2, 2, 753, 756, 3, 2, 2, 2, 754, 752, 3, 2, 2, 2, 754, 755, 3, 2, 2, 2, 755, 73, 3, 2, 2, 2, 756, 754, 3, 2, 2, 2, 757, 762, 5, 72, 37, 2, 758, 759, 9, 11, 2, 2, 759, 761, 5, 72, 37, 2, 760, 758, 3, 2, 2, 2, 761, 764, 3, 2, 2, 2, 762, 760, 3, 2, 2, 2, 762, 763, 3, 2, 2, 2, 763, 75, 3, 2, 2, 2, 764, 762, 3, 2, 2, 2, 765, 770, 5, 74, 38, 2, 766, 767, 7, 99, 2, 2, 767, 769, 5, 74, 38, 2, 768, 766, 3, 2, 2, 2, 769, 772, 3, 2, 2, 2, 770, 768, 3, 2, 2, 2, 770, 771, 3, 2, 2, 2, 771, 77, 3, 2, 2, 2, 772, 770, 3, 2, 2, 2, 773, 778, 5, 76, 39, 2, 774, 775, 7, 98, 2, 2, 775, 777, 5, 76, 39, 2, 776, 774, 3, 2, 2, 2, 777, 780, 3, 2, 2, 2, 778, 776, 3, 2, 2, 2, 778, 779, 3, 2, 2, 2, 779, 79, 3, 2, 2, 2, 780, 778, 3, 2, 2, 2, 781, 786, 5, 78, 40, 2, 782, 783, 7, 100, 2, 2, 783, 785, 5, 78, 40, 2, 784, 782, 3, 2, 2, 2, 785, 788, 3, 2, 2, 2, 786, 784, 3, 2, 2, 2, 786, 787, 3, 2, 2, 2, 787, 81, 3, 2, 2, 2, 788, 786, 3, 2, 2, 2, 789, 794, 5, 80, 41, 2, 790, 791, 7, 120, 2, 2, 791, 793, 5, 80, 41, 2, 792, 790, 3, 2, 2, 2, 793, 796, 3, 2, 2, 2, 794, 792, 3, 2, 2, 2, 794, 795, 3, 2, 2, 2, 795, 83, 3, 2, 2, 2, 796, 794, 3, 2, 2, 2, 797, 802, 5, 82, 42, 2, 798, 799, 7, 121, 2, 2, 799, 801, 5, 82, 42, 2, 800, 798, 3, 2, 2, 2, 801, 804, 3, 2, 2, 2, 802, 800, 3, 2, 2, 2, 802, 803, 3, 2, 2, 2, 803, 85, 3, 2, 2, 2, 804, 802, 3, 2, 2, 2, 805, 811, 5, 84, 43, 2, 806, 807, 7, 127, 2, 2, 807, 808, 5, 92, 47, 2, 808, 809, 7, 128, 2, 2, 809, 810, 5, 88, 45, 2, 810, 812, 3, 2, 2, 2, 811, 806, 3, 2, 2, 2, 811, 812, 3, 2, 2, 2, 812, 87, 3, 2, 2, 2, 813, 820, 5, 86, 44, 2, 814, 815, 5, 84, 43, 2, 815, 816, 5, 90, 46, 2, 816, 817, 5, 270, 136, 2, 817, 820, 3, 2, 2, 2, 818, 820, 5, 366, 184, 2, 819, 813, 3, 2, 2, 2, 819, 814, 3, 2, 2, 2, 819, 818, 3, 2, 2, 2, 820, 89, 3, 2, 2, 2, 821, 822, 9, 12, 2, 2, 822, 91, 3, 2, 2, 2, 823, 828, 5, 88, 45, 2, 824, 825, 7, 124, 2, 2, 825, 827, 5, 88, 45, 2, 826, 824, 3, 2, 2, 2, 827, 830, 3, 2, 2, 2, 828, 826, 3, 2, 2, 2, 828, 829, 3, 2, 2, 2, 829, 93, 3, 2, 2, 2, 830, 828, 3, 2, 2, 2, 831, 832, 5, 86, 44, 2, 832, 95, 3, 2, 2, 2, 833, 847, 5, 98, 50, 2, 834, 836, 5, 202, 102, 2, 835, 834, 3, 2, 2, 2, 835, 836, 3, 2, 2, 2, 836, 843, 3, 2, 2, 2, 837, 844, 5, 100, 51, 2, 838, 844, 5, 102, 52, 2, 839, 844, 5, 106, 54, 2, 840, 844, 5, 110, 56, 2, 841, 844, 5, 118, 60, 2, 842, 844, 5, 356, 179, 2, 843, 837, 3, 2, 2, 2, 843, 838, 3, 2, 2, 2, 843, 839, 3, 2, 2, 2, 843, 840, 3, 2, 2, 2, 843, 841, 3, 2, 2, 2, 843, 842, 3, 2, 2, 2, 844, 847, 3, 2, 2, 2, 845, 847, 5, 120, 61, 2, 846, 833, 3, 2, 2, 2, 846, 835, 3, 2, 2, 2, 846, 845, 3, 2, 2, 2, 847, 97, 3, 2, 2, 2, 848, 850, 5, 202, 102, 2, 849, 848, 3, 2, 2, 2, 849, 850, 3, 2, 2, 2, 850, 855, 3, 2, 2, 2, 851, 856, 7, 134, 2, 2, 852, 853, 7, 18, 2, 2, 853, 856, 5, 94, 48, 2, 854, 856, 7, 29, 2, 2, 855, 851, 3, 2, 2, 2, 855, 852, 3, 2, 2, 2, 855, 854, 3, 2, 2, 2, 856, 857, 3, 2, 2, 2, 857, 858, 7, 128, 2, 2, 858, 859, 5, 96, 49, 2, 859, 99, 3, 2, 2, 2, 860, 862, 5, 92, 47, 2, 861, 860, 3, 2, 2, 2, 861, 862, 3, 2, 2, 2, 862, 863, 3, 2, 2, 2, 863, 864, 7, 130, 2, 2, 864, 101, 3, 2, 2, 2, 865, 867, 7, 91, 2, 2, 866, 868, 5, 104, 53, 2, 867, 866, 3, 2, 2, 2, 867, 868, 3, 2, 2, 2, 868, 869, 3, 2, 2, 2, 869, 870, 7, 92, 2, 2, 870, 103, 3, 2, 2, 2, 871, 873, 5, 96, 49, 2, 872, 871, 3, 2, 2, 2, 873, 874, 3, 2, 2, 2, 874, 872, 3, 2, 2, 2, 874, 875, 3, 2, 2, 2, 875, 105, 3, 2, 2, 2, 876, 877, 7, 45, 2, 2, 877, 878, 7, 87, 2, 2, 878, 879, 5, 108, 55, 2, 879, 880, 7, 88, 2, 2, 880, 883, 5, 96, 49, 2, 881, 882, 7, 34, 2, 2, 882, 884, 5, 96, 49, 2, 883, 881, 3, 2, 2, 2, 883, 884, 3, 2, 2, 2, 884, 892, 3, 2, 2, 2, 885, 886, 7, 69, 2, 2, 886, 887, 7, 87, 2, 2, 887, 888, 5, 108, 55, 2, 888, 889, 7, 88, 2, 2, 889, 890, 5, 96, 49, 2, 890, 892, 3, 2, 2, 2, 891, 876, 3, 2, 2, 2, 891, 885, 3, 2, 2, 2, 892, 107, 3, 2, 2, 2, 893, 905, 5, 92, 47, 2, 894, 896, 5, 202, 102, 2, 895, 894, 3, 2, 2, 2, 895, 896, 3, 2, 2, 2, 896, 897, 3, 2, 2, 2, 897, 898, 5, 140, 71, 2, 898, 902, 5, 224, 113, 2, 899, 900, 7, 103, 2, 2, 900, 903, 5, 270, 136, 2, 901, 903, 5, 274, 138, 2, 902, 899, 3, 2, 2, 2, 902, 901, 3, 2, 2, 2, 903, 905, 3, 2, 2, 2, 904, 893, 3, 2, 2, 2, 904, 895, 3, 2, 2, 2, 905, 109, 3, 2, 2, 2, 906, 907, 7, 86, 2, 2, 907, 908, 7, 87, 2, 2, 908, 909, 5, 108, 55, 2, 909, 910, 7, 88, 2, 2, 910, 911, 5, 96, 49, 2, 911, 940, 3, 2, 2, 2, 912, 913, 7, 31, 2, 2, 913, 914, 5, 96, 49, 2, 914, 915, 7, 86, 2, 2, 915, 916, 7, 87, 2, 2, 916, 917, 5, 92, 47, 2, 917, 918, 7, 88, 2, 2, 918, 919, 7, 130, 2, 2, 919, 940, 3, 2, 2, 2, 920, 921, 7, 42, 2, 2, 921, 934, 7, 87, 2, 2, 922, 924, 5, 112, 57, 2, 923, 925, 5, 108, 55, 2, 924, 923, 3, 2, 2, 2, 924, 925, 3, 2, 2, 2, 925, 926, 3, 2, 2, 2, 926, 928, 7, 130, 2, 2, 927, 929, 5, 92, 47, 2, 928, 927, 3, 2, 2, 2, 928, 929, 3, 2, 2, 2, 929, 935, 3, 2, 2, 2, 930, 931, 5, 114, 58, 2, 931, 932, 7, 128, 2, 2, 932, 933, 5, 116, 59, 2, 933, 935, 3, 2, 2, 2, 934, 922, 3, 2, 2, 2, 934, 930, 3, 2, 2, 2, 935, 936, 3, 2, 2, 2, 936, 937, 7, 88, 2, 2, 937, 938, 5, 96, 49, 2, 938, 940, 3, 2, 2, 2, 939, 906, 3, 2, 2, 2, 939, 912, 3, 2, 2, 2, 939, 920, 3, 2, 2, 2, 940, 111, 3, 2, 2, 2, 941, 944, 5, 100, 51, 2, 942, 944, 5, 130, 66, 2, 943, 941, 3, 2, 2, 2, 943, 942, 3, 2, 2, 2, 944, 113, 3, 2, 2, 2, 945, 947, 5, 202, 102, 2, 946, 945, 3, 2, 2, 2, 946, 947, 3, 2, 2, 2, 947, 948, 3, 2, 2, 2, 948, 949, 5, 140, 71, 2, 949, 950, 5, 224, 113, 2, 950, 115, 3, 2, 2, 2, 951, 954, 5, 92, 47, 2, 952, 954, 5, 274, 138, 2, 953, 951, 3, 2, 2, 2, 953, 952, 3, 2, 2, 2, 954, 117, 3, 2, 2, 2, 955, 965, 7, 17, 2, 2, 956, 965, 7, 27, 2, 2, 957, 960, 7, 61, 2, 2, 958, 961, 5, 92, 47, 2, 959, 961, 5, 274, 138, 2, 960, 958, 3, 2, 2, 2, 960, 959, 3, 2, 2, 2, 960, 961, 3, 2, 2, 2, 961, 965, 3, 2, 2, 2, 962, 963, 7, 44, 2, 2, 963, 965, 7, 134, 2, 2, 964, 955, 3, 2, 2, 2, 964, 956, 3, 2, 2, 2, 964, 957, 3, 2, 2, 2, 964, 962, 3, 2, 2, 2, 965, 966, 3, 2, 2, 2, 966, 967, 7, 130, 2, 2, 967, 119, 3, 2, 2, 2, 968, 969, 5, 126, 64, 2, 969, 121, 3, 2, 2, 2, 970, 972, 5, 124, 63, 2, 971, 970, 3, 2, 2, 2, 972, 973, 3, 2, 2, 2, 973, 971, 3, 2, 2, 2, 973, 974, 3, 2, 2, 2, 974, 123, 3, 2, 2, 2, 975, 985, 5, 126, 64, 2, 976, 985, 5, 262, 132, 2, 977, 985, 5, 332, 167, 2, 978, 985, 5, 352, 177, 2, 979, 985, 5, 354, 178, 2, 980, 985, 5, 200, 101, 2, 981, 985, 5, 186, 94, 2, 982, 985, 5, 134, 68, 2, 983, 985, 5, 136, 69, 2, 984, 975, 3, 2, 2, 2, 984, 976, 3, 2, 2, 2, 984, 977, 3, 2, 2, 2, 984, 978, 3, 2, 2, 2, 984, 979, 3, 2, 2, 2, 984, 980, 3, 2, 2, 2, 984, 981, 3, 2, 2, 2, 984, 982, 3, 2, 2, 2, 984, 983, 3, 2, 2, 2, 985, 125, 3, 2, 2, 2, 986, 995, 5, 130, 66, 2, 987, 995, 5, 198, 100, 2, 988, 995, 5, 190, 96, 2, 989, 995, 5, 194, 98, 2, 990, 995, 5, 196, 99, 2, 991, 995, 5, 132, 67, 2, 992, 995, 5, 128, 65, 2, 993, 995, 5, 170, 86, 2, 994, 986, 3, 2, 2, 2, 994, 987, 3, 2, 2, 2, 994, 988, 3, 2, 2, 2, 994, 989, 3, 2, 2, 2, 994, 990, 3, 2, 2, 2, 994, 991, 3, 2, 2, 2, 994, 992, 3, 2, 2, 2, 994, 993, 3, 2, 2, 2, 995, 127, 3, 2, 2, 2, 996, 997, 7, 81, 2, 2, 997, 999, 7, 134, 2, 2, 998, 1000, 5, 202, 102, 2, 999, 998, 3, 2, 2, 2, 999, 1000, 3, 2, 2, 2, 1000, 1001, 3, 2, 2, 2, 1001, 1002, 7, 103, 2, 2, 1002, 1003, 5, 244, 123, 2, 1003, 1004, 7, 130, 2, 2, 1004, 129, 3, 2, 2, 2, 1005, 1007, 5, 140, 71, 2, 1006, 1005, 3, 2, 2, 2, 1006, 1007, 3, 2, 2, 2, 1007, 1009, 3, 2, 2, 2, 1008, 1010, 5, 220, 111, 2, 1009, 1008, 3, 2, 2, 2, 1009, 1010, 3, 2, 2, 2, 1010, 1011, 3, 2, 2, 2, 1011, 1020, 7, 130, 2, 2, 1012, 1014, 5, 202, 102, 2, 1013, 1015, 5, 140, 71, 2, 1014, 1013, 3, 2, 2, 2, 1014, 1015, 3, 2, 2, 2, 1015, 1016, 3, 2, 2, 2, 1016, 1017, 5, 220, 111, 2, 1017, 1018, 7, 130, 2, 2, 1018, 1020, 3, 2, 2, 2, 1019, 1006, 3, 2, 2, 2, 1019, 1012, 3, 2, 2, 2, 1020, 131, 3, 2, 2, 2, 1021, 1022, 7, 66, 2, 2, 1022, 1023, 7, 87, 2, 2, 1023, 1024, 5, 94, 48, 2, 1024, 1025, 7, 124, 2, 2, 1025, 1026, 7, 6, 2, 2, 1026, 1027, 7, 88, 2, 2, 1027, 1028, 7, 130, 2, 2, 1028, 133, 3, 2, 2, 2, 1029, 1030, 7, 130, 2, 2, 1030, 135, 3, 2, 2, 2, 1031, 1032, 5, 202, 102, 2, 1032, 1033, 7, 130, 2, 2, 1033, 137, 3, 2, 2, 2, 1034, 1041, 5, 142, 72, 2, 1035, 1041, 5, 148, 75, 2, 1036, 1041, 5, 144, 73, 2, 1037, 1041, 7, 43, 2, 2, 1038, 1041, 7, 76, 2, 2, 1039, 1041, 7, 25, 2, 2, 1040, 1034, 3, 2, 2, 2, 1040, 1035, 3, 2, 2, 2, 1040, 1036, 3, 2, 2, 2, 1040, 1037, 3, 2, 2, 2, 1040, 1038, 3, 2, 2, 2, 1040, 1039, 3, 2, 2, 2, 1041, 139, 3, 2, 2, 2, 1042, 1044, 5, 138, 70, 2, 1043, 1042, 3, 2, 2, 2, 1044, 1045, 3, 2, 2, 2, 1045, 1043, 3, 2, 2, 2, 1045, 1046, 3, 2, 2, 2, 1046, 1048, 3, 2, 2, 2, 1047, 1049, 5, 202, 102, 2, 1048, 1047, 3, 2, 2, 2, 1048, 1049, 3, 2, 2, 2, 1049, 141, 3, 2, 2, 2, 1050, 1051, 9, 13, 2, 2, 1051, 143, 3, 2, 2, 2, 1052, 1053, 9, 14, 2, 2, 1053, 145, 3, 2, 2, 2, 1054, 1055, 7, 134, 2, 2, 1055, 147, 3, 2, 2, 2, 1056, 1060, 5, 150, 76, 2, 1057, 1060, 5, 278, 140, 2, 1058, 1060, 5, 166, 84, 2, 1059, 1056, 3, 2, 2, 2, 1059, 1057, 3, 2, 2, 2, 1059, 1058, 3, 2, 2, 2, 1060, 149, 3, 2, 2, 2, 1061, 1066, 5, 156, 79, 2, 1062, 1066, 5, 162, 82, 2, 1063, 1066, 5, 350, 176, 2, 1064, 1066, 5, 238, 120, 2, 1065, 1061, 3, 2, 2, 2, 1065, 1062, 3, 2, 2, 2, 1065, 1063, 3, 2, 2, 2, 1065, 1064, 3, 2, 2, 2, 1066, 151, 3, 2, 2, 2, 1067, 1069, 5, 148, 75, 2, 1068, 1067, 3, 2, 2, 2, 1069, 1070, 3, 2, 2, 2, 1070, 1068, 3, 2, 2, 2, 1070, 1071, 3, 2, 2, 2, 1071, 1073, 3, 2, 2, 2, 1072, 1074, 5, 202, 102, 2, 1073, 1072, 3, 2, 2, 2, 1073, 1074, 3, 2, 2, 2, 1074, 153, 3, 2, 2, 2, 1075, 1077, 5, 150, 76, 2, 1076, 1075, 3, 2, 2, 2, 1077, 1078, 3, 2, 2, 2, 1078, 1076, 3, 2, 2, 2, 1078, 1079, 3, 2, 2, 2, 1079, 1081, 3, 2, 2, 2, 1080, 1082, 5, 202, 102, 2, 1081, 1080, 3, 2, 2, 2, 1081, 1082, 3, 2, 2, 2, 1082, 155, 3, 2, 2, 2, 1083, 1085, 5, 12, 7, 2, 1084, 1083, 3, 2, 2, 2, 1084, 1085, 3, 2, 2, 2, 1085, 1086, 3, 2, 2, 2, 1086, 1107, 5, 158, 80, 2, 1087, 1088, 5, 12, 7, 2, 1088, 1089, 7, 70, 2, 2, 1089, 1090, 5, 340, 171, 2, 1090, 1107, 3, 2, 2, 2, 1091, 1107, 7, 20, 2, 2, 1092, 1107, 7, 21, 2, 2, 1093, 1107, 7, 22, 2, 2, 1094, 1107, 7, 85, 2, 2, 1095, 1107, 7, 16, 2, 2, 1096, 1107, 7, 62, 2, 2, 1097, 1107, 7, 47, 2, 2, 1098, 1107, 7, 48, 2, 2, 1099, 1107, 7, 63, 2, 2, 1100, 1107, 7, 80, 2, 2, 1101, 1107, 7, 41, 2, 2, 1102, 1107, 7, 32, 2, 2, 1103, 1107, 7, 83, 2, 2, 1104, 1107, 7, 15, 2, 2, 1105, 1107, 5, 160, 81, 2, 1106, 1084, 3, 2, 2, 2, 1106, 1087, 3, 2, 2, 2, 1106, 1091, 3, 2, 2, 2, 1106, 1092, 3, 2, 2, 2, 1106, 1093, 3, 2, 2, 2, 1106, 1094, 3, 2, 2, 2, 1106, 1095, 3, 2, 2, 2, 1106, 1096, 3, 2, 2, 2, 1106, 1097, 3, 2, 2, 2, 1106, 1098, 3, 2, 2, 2, 1106, 1099, 3, 2, 2, 2, 1106, 1100, 3, 2, 2, 2, 1106, 1101, 3, 2, 2, 2, 1106, 1102, 3, 2, 2, 2, 1106, 1103, 3, 2, 2, 2, 1106, 1104, 3, 2, 2, 2, 1106, 1105, 3, 2, 2, 2, 1107, 157, 3, 2, 2, 2, 1108, 1113, 5, 276, 139, 2, 1109, 1113, 5, 164, 83, 2, 1110, 1113, 5, 146, 74, 2, 1111, 1113, 5, 340, 171, 2, 1112, 1108, 3, 2, 2, 2, 1112, 1109, 3, 2, 2, 2, 1112, 1110, 3, 2, 2, 2, 1112, 1111, 3, 2, 2, 2, 1113, 159, 3, 2, 2, 2, 1114, 1115, 7, 28, 2, 2, 1115, 1118, 7, 87, 2, 2, 1116, 1119, 5, 92, 47, 2, 1117, 1119, 7, 15, 2, 2, 1118, 1116, 3, 2, 2, 2, 1118, 1117, 3, 2, 2, 2, 1119, 1120, 3, 2, 2, 2, 1120, 1121, 7, 88, 2, 2, 1121, 161, 3, 2, 2, 2, 1122, 1137, 5, 286, 144, 2, 1123, 1125, 5, 202, 102, 2, 1124, 1123, 3, 2, 2, 2, 1124, 1125, 3, 2, 2, 2, 1125, 1127, 3, 2, 2, 2, 1126, 1128, 5, 12, 7, 2, 1127, 1126, 3, 2, 2, 2, 1127, 1128, 3, 2, 2, 2, 1128, 1129, 3, 2, 2, 2, 1129, 1138, 7, 134, 2, 2, 1130, 1138, 5, 340, 171, 2, 1131, 1133, 5, 12, 7, 2, 1132, 1134, 7, 70, 2, 2, 1133, 1132, 3, 2, 2, 2, 1133, 1134, 3, 2, 2, 2, 1134, 1135, 3, 2, 2, 2, 1135, 1136, 5, 340, 171, 2, 1136, 1138, 3, 2, 2, 2, 1137, 1124, 3, 2, 2, 2, 1137, 1130, 3, 2, 2, 2, 1137, 1131, 3, 2, 2, 2, 1138, 1145, 3, 2, 2, 2, 1139, 1141, 7, 35, 2, 2, 1140, 1142, 5, 12, 7, 2, 1141, 1140, 3, 2, 2, 2, 1141, 1142, 3, 2, 2, 2, 1142, 1143, 3, 2, 2, 2, 1143, 1145, 7, 134, 2, 2, 1144, 1122, 3, 2, 2, 2, 1144, 1139, 3, 2, 2, 2, 1145, 163, 3, 2, 2, 2, 1146, 1147, 7, 134, 2, 2, 1147, 165, 3, 2, 2, 2, 1148, 1149, 5, 168, 85, 2, 1149, 1154, 7, 91, 2, 2, 1150, 1152, 5, 176, 89, 2, 1151, 1153, 7, 124, 2, 2, 1152, 1151, 3, 2, 2, 2, 1152, 1153, 3, 2, 2, 2, 1153, 1155, 3, 2, 2, 2, 1154, 1150, 3, 2, 2, 2, 1154, 1155, 3, 2, 2, 2, 1155, 1156, 3, 2, 2, 2, 1156, 1157, 7, 92, 2, 2, 1157, 167, 3, 2, 2, 2, 1158, 1160, 5, 172, 87, 2, 1159, 1161, 5, 202, 102, 2, 1160, 1159, 3, 2, 2, 2, 1160, 1161, 3, 2, 2, 2, 1161, 1166, 3, 2, 2, 2, 1162, 1164, 5, 12, 7, 2, 1163, 1162, 3, 2, 2, 2, 1163, 1164, 3, 2, 2, 2, 1164, 1165, 3, 2, 2, 2, 1165, 1167, 7, 134, 2, 2, 1166, 1163, 3, 2, 2, 2, 1166, 1167, 3, 2, 2, 2, 1167, 1169, 3, 2, 2, 2, 1168, 1170, 5, 174, 88, 2, 1169, 1168, 3, 2, 2, 2, 1169, 1170, 3, 2, 2, 2, 1170, 169, 3, 2, 2, 2, 1171, 1173, 5, 172, 87, 2, 1172, 1174, 5, 202, 102, 2, 1173, 1172, 3, 2, 2, 2, 1173, 1174, 3, 2, 2, 2, 1174, 1175, 3, 2, 2, 2, 1175, 1177, 7, 134, 2, 2, 1176, 1178, 5, 174, 88, 2, 1177, 1176, 3, 2, 2, 2, 1177, 1178, 3, 2, 2, 2, 1178, 1179, 3, 2, 2, 2, 1179, 1180, 7, 130, 2, 2, 1180, 171, 3, 2, 2, 2, 1181, 1183, 7, 35, 2, 2, 1182, 1184, 9, 15, 2, 2, 1183, 1182, 3, 2, 2, 2, 1183, 1184, 3, 2, 2, 2, 1184, 173, 3, 2, 2, 2, 1185, 1186, 7, 128, 2, 2, 1186, 1187, 5, 152, 77, 2, 1187, 175, 3, 2, 2, 2, 1188, 1193, 5, 178, 90, 2, 1189, 1190, 7, 124, 2, 2, 1190, 1192, 5, 178, 90, 2, 1191, 1189, 3, 2, 2, 2, 1192, 1195, 3, 2, 2, 2, 1193, 1191, 3, 2, 2, 2, 1193, 1194, 3, 2, 2, 2, 1194, 177, 3, 2, 2, 2, 1195, 1193, 3, 2, 2, 2, 1196, 1199, 5, 180, 91, 2, 1197, 1198, 7, 103, 2, 2, 1198, 1200, 5, 94, 48, 2, 1199, 1197, 3, 2, 2, 2, 1199, 1200, 3, 2, 2, 2, 1200, 179, 3, 2, 2, 2, 1201, 1202, 7, 134, 2, 2, 1202, 181, 3, 2, 2, 2, 1203, 1206, 5, 184, 93, 2, 1204, 1206, 5, 188, 95, 2, 1205, 1203, 3, 2, 2, 2, 1205, 1204, 3, 2, 2, 2, 1206, 183, 3, 2, 2, 2, 1207, 1208, 7, 134, 2, 2, 1208, 185, 3, 2, 2, 2, 1209, 1211, 7, 46, 2, 2, 1210, 1209, 3, 2, 2, 2, 1210, 1211, 3, 2, 2, 2, 1211, 1212, 3, 2, 2, 2, 1212, 1215, 7, 50, 2, 2, 1213, 1216, 7, 134, 2, 2, 1214, 1216, 5, 184, 93, 2, 1215, 1213, 3, 2, 2, 2, 1215, 1214, 3, 2, 2, 2, 1215, 1216, 3, 2, 2, 2, 1216, 1217, 3, 2, 2, 2, 1217, 1219, 7, 91, 2, 2, 1218, 1220, 5, 122, 62, 2, 1219, 1218, 3, 2, 2, 2, 1219, 1220, 3, 2, 2, 2, 1220, 1221, 3, 2, 2, 2, 1221, 1222, 7, 92, 2, 2, 1222, 187, 3, 2, 2, 2, 1223, 1224, 7, 134, 2, 2, 1224, 189, 3, 2, 2, 2, 1225, 1226, 7, 50, 2, 2, 1226, 1227, 7, 134, 2, 2, 1227, 1228, 7, 103, 2, 2, 1228, 1229, 5, 192, 97, 2, 1229, 1230, 7, 130, 2, 2, 1230, 191, 3, 2, 2, 2, 1231, 1233, 5, 12, 7, 2, 1232, 1231, 3, 2, 2, 2, 1232, 1233, 3, 2, 2, 2, 1233, 1234, 3, 2, 2, 2, 1234, 1235, 5, 182, 92, 2, 1235, 193, 3, 2, 2, 2, 1236, 1242, 7, 81, 2, 2, 1237, 1239, 7, 78, 2, 2, 1238, 1237, 3, 2, 2, 2, 1238, 1239, 3, 2, 2, 2, 1239, 1240, 3, 2, 2, 2, 1240, 1243, 5, 12, 7, 2, 1241, 1243, 7, 129, 2, 2, 1242, 1238, 3, 2, 2, 2, 1242, 1241, 3, 2, 2, 2, 1243, 1244, 3, 2, 2, 2, 1244, 1245, 5, 8, 5, 2, 1245, 1246, 7, 130, 2, 2, 1246, 195, 3, 2, 2, 2, 1247, 1249, 5, 202, 102, 2, 1248, 1247, 3, 2, 2, 2, 1248, 1249, 3, 2, 2, 2, 1249, 1250, 3, 2, 2, 2, 1250, 1251, 7, 81, 2, 2, 1251, 1253, 7, 50, 2, 2, 1252, 1254, 5, 12, 7, 2, 1253, 1252, 3, 2, 2, 2, 1253, 1254, 3, 2, 2, 2, 1254, 1255, 3, 2, 2, 2, 1255, 1256, 5, 182, 92, 2, 1256, 1257, 7, 130, 2, 2, 1257, 197, 3, 2, 2, 2, 1258, 1259, 7, 14, 2, 2, 1259, 1260, 7, 87, 2, 2, 1260, 1261, 7, 6, 2, 2, 1261, 1262, 7, 88, 2, 2, 1262, 1263, 7, 130, 2, 2, 1263, 199, 3, 2, 2, 2, 1264, 1265, 7, 38, 2, 2, 1265, 1272, 7, 6, 2, 2, 1266, 1268, 7, 91, 2, 2, 1267, 1269, 5, 122, 62, 2, 1268, 1267, 3, 2, 2, 2, 1268, 1269, 3, 2, 2, 2, 1269, 1270, 3, 2, 2, 2, 1270, 1273, 7, 92, 2, 2, 1271, 1273, 5, 124, 63, 2, 1272, 1266, 3, 2, 2, 2, 1272, 1271, 3, 2, 2, 2, 1273, 201, 3, 2, 2, 2, 1274, 1276, 5, 204, 103, 2, 1275, 1274, 3, 2, 2, 2, 1276, 1277, 3, 2, 2, 2, 1277, 1275, 3, 2, 2, 2, 1277, 1278, 3, 2, 2, 2, 1278, 203, 3, 2, 2, 2, 1279, 1280, 7, 89, 2, 2, 1280, 1282, 7, 89, 2, 2, 1281, 1283, 5, 208, 105, 2, 1282, 1281, 3, 2, 2, 2, 1282, 1283, 3, 2, 2, 2, 1283, 1284, 3, 2, 2, 2, 1284, 1285, 7, 90, 2, 2, 1285, 1288, 7, 90, 2, 2, 1286, 1288, 5, 206, 104, 2, 1287, 1279, 3, 2, 2, 2, 1287, 1286, 3, 2, 2, 2, 1288, 205, 3, 2, 2, 2, 1289, 1290, 7, 12, 2, 2, 1290, 1293, 7, 87, 2, 2, 1291, 1294, 5, 244, 123, 2, 1292, 1294, 5, 94, 48, 2, 1293, 1291, 3, 2, 2, 2, 1293, 1292, 3, 2, 2, 2, 1294, 1296, 3, 2, 2, 2, 1295, 1297, 7, 133, 2, 2, 1296, 1295, 3, 2, 2, 2, 1296, 1297, 3, 2, 2, 2, 1297, 1298, 3, 2, 2, 2, 1298, 1299, 7, 88, 2, 2, 1299, 207, 3, 2, 2, 2, 1300, 1305, 5, 210, 106, 2, 1301, 1302, 7, 124, 2, 2, 1302, 1304, 5, 210, 106, 2, 1303, 1301, 3, 2, 2, 2, 1304, 1307, 3, 2, 2, 2, 1305, 1303, 3, 2, 2, 2, 1305, 1306, 3, 2, 2, 2, 1306, 1309, 3, 2, 2, 2, 1307, 1305, 3, 2, 2, 2, 1308, 1310, 7, 133, 2, 2, 1309, 1308, 3, 2, 2, 2, 1309, 1310, 3, 2, 2, 2, 1310, 209, 3, 2, 2, 2, 1311, 1312, 5, 212, 107, 2, 1312, 1313, 7, 129, 2, 2, 1313, 1315, 3, 2, 2, 2, 1314, 1311, 3, 2, 2, 2, 1314, 1315, 3, 2, 2, 2, 1315, 1316, 3, 2, 2, 2, 1316, 1318, 7, 134, 2, 2, 1317, 1319, 5, 214, 108, 2, 1318, 1317, 3, 2, 2, 2, 1318, 1319, 3, 2, 2, 2, 1319, 211, 3, 2, 2, 2, 1320, 1321, 7, 134, 2, 2, 1321, 213, 3, 2, 2, 2, 1322, 1324, 7, 87, 2, 2, 1323, 1325, 5, 216, 109, 2, 1324, 1323, 3, 2, 2, 2, 1324, 1325, 3, 2, 2, 2, 1325, 1326, 3, 2, 2, 2, 1326, 1327, 7, 88, 2, 2, 1327, 215, 3, 2, 2, 2, 1328, 1330, 5, 218, 110, 2, 1329, 1328, 3, 2, 2, 2, 1330, 1331, 3, 2, 2, 2, 1331, 1329, 3, 2, 2, 2, 1331, 1332, 3, 2, 2, 2, 1332, 217, 3, 2, 2, 2, 1333, 1334, 7, 87, 2, 2, 1334, 1335, 5, 216, 109, 2, 1335, 1336, 7, 88, 2, 2, 1336, 1351, 3, 2, 2, 2, 1337, 1338, 7, 89, 2, 2, 1338, 1339, 5, 216, 109, 2, 1339, 1340, 7, 90, 2, 2, 1340, 1351, 3, 2, 2, 2, 1341, 1342, 7, 91, 2, 2, 1342, 1343, 5, 216, 109, 2, 1343, 1344, 7, 92, 2, 2, 1344, 1351, 3, 2, 2, 2, 1345, 1347, 10, 16, 2, 2, 1346, 1345, 3, 2, 2, 2, 1347, 1348, 3, 2, 2, 2, 1348, 1346, 3, 2, 2, 2, 1348, 1349, 3, 2, 2, 2, 1349, 1351, 3, 2, 2, 2, 1350, 1333, 3, 2, 2, 2, 1350, 1337, 3, 2, 2, 2, 1350, 1341, 3, 2, 2, 2, 1350, 1346, 3, 2, 2, 2, 1351, 219, 3, 2, 2, 2, 1352, 1357, 5, 222, 112, 2, 1353, 1354, 7, 124, 2, 2, 1354, 1356, 5, 222, 112, 2, 1355, 1353, 3, 2, 2, 2, 1356, 1359, 3, 2, 2, 2, 1357, 1355, 3, 2, 2, 2, 1357, 1358, 3, 2, 2, 2, 1358, 221, 3, 2, 2, 2, 1359, 1357, 3, 2, 2, 2, 1360, 1362, 5, 224, 113, 2, 1361, 1363, 5, 266, 134, 2, 1362, 1361, 3, 2, 2, 2, 1362, 1363, 3, 2, 2, 2, 1363, 223, 3, 2, 2, 2, 1364, 1370, 5, 226, 114, 2, 1365, 1366, 5, 228, 115, 2, 1366, 1367, 5, 230, 116, 2, 1367, 1368, 5, 232, 117, 2, 1368, 1370, 3, 2, 2, 2, 1369, 1364, 3, 2, 2, 2, 1369, 1365, 3, 2, 2, 2, 1370, 225, 3, 2, 2, 2, 1371, 1373, 5, 234, 118, 2, 1372, 1374, 7, 24, 2, 2, 1373, 1372, 3, 2, 2, 2, 1373, 1374, 3, 2, 2, 2, 1374, 1376, 3, 2, 2, 2, 1375, 1371, 3, 2, 2, 2, 1376, 1379, 3, 2, 2, 2, 1377, 1375, 3, 2, 2, 2, 1377, 1378, 3, 2, 2, 2, 1378, 1380, 3, 2, 2, 2, 1379, 1377, 3, 2, 2, 2, 1380, 1381, 5, 228, 115, 2, 1381, 227, 3, 2, 2, 2, 1382, 1383, 8, 115, 1, 2, 1383, 1385, 5, 242, 122, 2, 1384, 1386, 5, 202, 102, 2, 1385, 1384, 3, 2, 2, 2, 1385, 1386, 3, 2, 2, 2, 1386, 1392, 3, 2, 2, 2, 1387, 1388, 7, 87, 2, 2, 1388, 1389, 5, 226, 114, 2, 1389, 1390, 7, 88, 2, 2, 1390, 1392, 3, 2, 2, 2, 1391, 1382, 3, 2, 2, 2, 1391, 1387, 3, 2, 2, 2, 1392, 1407, 3, 2, 2, 2, 1393, 1403, 12, 4, 2, 2, 1394, 1404, 5, 230, 116, 2, 1395, 1397, 7, 89, 2, 2, 1396, 1398, 5, 94, 48, 2, 1397, 1396, 3, 2, 2, 2, 1397, 1398, 3, 2, 2, 2, 1398, 1399, 3, 2, 2, 2, 1399, 1401, 7, 90, 2, 2, 1400, 1402, 5, 202, 102, 2, 1401, 1400, 3, 2, 2, 2, 1401, 1402, 3, 2, 2, 2, 1402, 1404, 3, 2, 2, 2, 1403, 1394, 3, 2, 2, 2, 1403, 1395, 3, 2, 2, 2, 1404, 1406, 3, 2, 2, 2, 1405, 1393, 3, 2, 2, 2, 1406, 1409, 3, 2, 2, 2, 1407, 1405, 3, 2, 2, 2, 1407, 1408, 3, 2, 2, 2, 1408, 229, 3, 2, 2, 2, 1409, 1407, 3, 2, 2, 2, 1410, 1412, 7, 87, 2, 2, 1411, 1413, 5, 256, 129, 2, 1412, 1411, 3, 2, 2, 2, 1412, 1413, 3, 2, 2, 2, 1413, 1414, 3, 2, 2, 2, 1414, 1416, 7, 88, 2, 2, 1415, 1417, 5, 236, 119, 2, 1416, 1415, 3, 2, 2, 2, 1416, 1417, 3, 2, 2, 2, 1417, 1419, 3, 2, 2, 2, 1418, 1420, 5, 240, 121, 2, 1419, 1418, 3, 2, 2, 2, 1419, 1420, 3, 2, 2, 2, 1420, 1422, 3, 2, 2, 2, 1421, 1423, 5, 368, 185, 2, 1422, 1421, 3, 2, 2, 2, 1422, 1423, 3, 2, 2, 2, 1423, 1425, 3, 2, 2, 2, 1424, 1426, 5, 202, 102, 2, 1425, 1424, 3, 2, 2, 2, 1425, 1426, 3, 2, 2, 2, 1426, 231, 3, 2, 2, 2, 1427, 1428, 7, 126, 2, 2, 1428, 1430, 5, 154, 78, 2, 1429, 1431, 5, 246, 124, 2, 1430, 1429, 3, 2, 2, 2, 1430, 1431, 3, 2, 2, 2, 1431, 233, 3, 2, 2, 2, 1432, 1434, 9, 17, 2, 2, 1433, 1435, 5, 202, 102, 2, 1434, 1433, 3, 2, 2, 2, 1434, 1435, 3, 2, 2, 2, 1435, 1447, 3, 2, 2, 2, 1436, 1438, 5, 12, 7, 2, 1437, 1436, 3, 2, 2, 2, 1437, 1438, 3, 2, 2, 2, 1438, 1439, 3, 2, 2, 2, 1439, 1441, 7, 95, 2, 2, 1440, 1442, 5, 202, 102, 2, 1441, 1440, 3, 2, 2, 2, 1441, 1442, 3, 2, 2, 2, 1442, 1444, 3, 2, 2, 2, 1443, 1445, 5, 236, 119, 2, 1444, 1443, 3, 2, 2, 2, 1444, 1445, 3, 2, 2, 2, 1445, 1447, 3, 2, 2, 2, 1446, 1432, 3, 2, 2, 2, 1446, 1437, 3, 2, 2, 2, 1447, 235, 3, 2, 2, 2, 1448, 1450, 5, 238, 120, 2, 1449, 1448, 3, 2, 2, 2, 1450, 1451, 3, 2, 2, 2, 1451, 1449, 3, 2, 2, 2, 1451, 1452, 3, 2, 2, 2, 1452, 237, 3, 2, 2, 2, 1453, 1454, 9, 18, 2, 2, 1454, 239, 3, 2, 2, 2, 1455, 1456, 9, 17, 2, 2, 1456, 241, 3, 2, 2, 2, 1457, 1459, 7, 133, 2, 2, 1458, 1457, 3, 2, 2, 2, 1458, 1459, 3, 2, 2, 2, 1459, 1460, 3, 2, 2, 2, 1460, 1461, 5, 6, 4, 2, 1461, 243, 3, 2, 2, 2, 1462, 1464, 5, 152, 77, 2, 1463, 1465, 5, 246, 124, 2, 1464, 1463, 3, 2, 2, 2, 1464, 1465, 3, 2, 2, 2, 1465, 245, 3, 2, 2, 2, 1466, 1475, 5, 248, 125, 2, 1467, 1469, 5, 250, 126, 2, 1468, 1467, 3, 2, 2, 2, 1468, 1469, 3, 2, 2, 2, 1469, 1470, 3, 2, 2, 2, 1470, 1471, 5, 230, 116, 2, 1471, 1472, 5, 232, 117, 2, 1472, 1475, 3, 2, 2, 2, 1473, 1475, 5, 252, 127, 2, 1474, 1466, 3, 2, 2, 2, 1474, 1468, 3, 2, 2, 2, 1474, 1473, 3, 2, 2, 2, 1475, 247, 3, 2, 2, 2, 1476, 1486, 5, 250, 126, 2, 1477, 1479, 5, 234, 118, 2, 1478, 1477, 3, 2, 2, 2, 1479, 1480, 3, 2, 2, 2, 1480, 1478, 3, 2, 2, 2, 1480, 1481, 3, 2, 2, 2, 1481, 1483, 3, 2, 2, 2, 1482, 1484, 5, 250, 126, 2, 1483, 1482, 3, 2, 2, 2, 1483, 1484, 3, 2, 2, 2, 1484, 1486, 3, 2, 2, 2, 1485, 1476, 3, 2, 2, 2, 1485, 1478, 3, 2, 2, 2, 1486, 249, 3, 2, 2, 2, 1487, 1488, 8, 126, 1, 2, 1488, 1502, 5, 230, 116, 2, 1489, 1491, 7, 89, 2, 2, 1490, 1492, 5, 94, 48, 2, 1491, 1490, 3, 2, 2, 2, 1491, 1492, 3, 2, 2, 2, 1492, 1493, 3, 2, 2, 2, 1493, 1495, 7, 90, 2, 2, 1494, 1496, 5, 202, 102, 2, 1495, 1494, 3, 2, 2, 2, 1495, 1496, 3, 2, 2, 2, 1496, 1502, 3, 2, 2, 2, 1497, 1498, 7, 87, 2, 2, 1498, 1499, 5, 248, 125, 2, 1499, 1500, 7, 88, 2, 2, 1500, 1502, 3, 2, 2, 2, 1501, 1487, 3, 2, 2, 2, 1501, 1489, 3, 2, 2, 2, 1501, 1497, 3, 2, 2, 2, 1502, 1518, 3, 2, 2, 2, 1503, 1514, 12, 6, 2, 2, 1504, 1515, 5, 230, 116, 2, 1505, 1506, 5, 250, 126, 2, 1506, 1508, 7, 89, 2, 2, 1507, 1509, 5, 94, 48, 2, 1508, 1507, 3, 2, 2, 2, 1508, 1509, 3, 2, 2, 2, 1509, 1510, 3, 2, 2, 2, 1510, 1512, 7, 90, 2, 2, 1511, 1513, 5, 202, 102, 2, 1512, 1511, 3, 2, 2, 2, 1512, 1513, 3, 2, 2, 2, 1513, 1515, 3, 2, 2, 2, 1514, 1504, 3, 2, 2, 2, 1514, 1505, 3, 2, 2, 2, 1515, 1517, 3, 2, 2, 2, 1516, 1503, 3, 2, 2, 2, 1517, 1520, 3, 2, 2, 2, 1518, 1516, 3, 2, 2, 2, 1518, 1519, 3, 2, 2, 2, 1519, 251, 3, 2, 2, 2, 1520, 1518, 3, 2, 2, 2, 1521, 1523, 5, 234, 118, 2, 1522, 1521, 3, 2, 2, 2, 1523, 1526, 3, 2, 2, 2, 1524, 1522, 3, 2, 2, 2, 1524, 1525, 3, 2, 2, 2, 1525, 1527, 3, 2, 2, 2, 1526, 1524, 3, 2, 2, 2, 1527, 1528, 5, 254, 128, 2, 1528, 253, 3, 2, 2, 2, 1529, 1530, 8, 128, 1, 2, 1530, 1531, 7, 133, 2, 2, 1531, 1546, 3, 2, 2, 2, 1532, 1542, 12, 4, 2, 2, 1533, 1543, 5, 230, 116, 2, 1534, 1536, 7, 89, 2, 2, 1535, 1537, 5, 94, 48, 2, 1536, 1535, 3, 2, 2, 2, 1536, 1537, 3, 2, 2, 2, 1537, 1538, 3, 2, 2, 2, 1538, 1540, 7, 90, 2, 2, 1539, 1541, 5, 202, 102, 2, 1540, 1539, 3, 2, 2, 2, 1540, 1541, 3, 2, 2, 2, 1541, 1543, 3, 2, 2, 2, 1542, 1533, 3, 2, 2, 2, 1542, 1534, 3, 2, 2, 2, 1543, 1545, 3, 2, 2, 2, 1544, 1532, 3, 2, 2, 2, 1545, 1548, 3, 2, 2, 2, 1546, 1544, 3, 2, 2, 2, 1546, 1547, 3, 2, 2, 2, 1547, 255, 3, 2, 2, 2, 1548, 1546, 3, 2, 2, 2, 1549, 1554, 5, 258, 130, 2, 1550, 1552, 7, 124, 2, 2, 1551, 1550, 3, 2, 2, 2, 1551, 1552, 3, 2, 2, 2, 1552, 1553, 3, 2, 2, 2, 1553, 1555, 7, 133, 2, 2, 1554, 1551, 3, 2, 2, 2, 1554, 1555, 3, 2, 2, 2, 1555, 257, 3, 2, 2, 2, 1556, 1561, 5, 260, 131, 2, 1557, 1558, 7, 124, 2, 2, 1558, 1560, 5, 260, 131, 2, 1559, 1557, 3, 2, 2, 2, 1560, 1563, 3, 2, 2, 2, 1561, 1559, 3, 2, 2, 2, 1561, 1562, 3, 2, 2, 2, 1562, 259, 3, 2, 2, 2, 1563, 1561, 3, 2, 2, 2, 1564, 1566, 5, 202, 102, 2, 1565, 1564, 3, 2, 2, 2, 1565, 1566, 3, 2, 2, 2, 1566, 1567, 3, 2, 2, 2, 1567, 1572, 5, 140, 71, 2, 1568, 1573, 5, 224, 113, 2, 1569, 1571, 5, 246, 124, 2, 1570, 1569, 3, 2, 2, 2, 1570, 1571, 3, 2, 2, 2, 1571, 1573, 3, 2, 2, 2, 1572, 1568, 3, 2, 2, 2, 1572, 1570, 3, 2, 2, 2, 1573, 1576, 3, 2, 2, 2, 1574, 1575, 7, 103, 2, 2, 1575, 1577, 5, 270, 136, 2, 1576, 1574, 3, 2, 2, 2, 1576, 1577, 3, 2, 2, 2, 1577, 261, 3, 2, 2, 2, 1578, 1580, 5, 202, 102, 2, 1579, 1578, 3, 2, 2, 2, 1579, 1580, 3, 2, 2, 2, 1580, 1582, 3, 2, 2, 2, 1581, 1583, 5, 140, 71, 2, 1582, 1581, 3, 2, 2, 2, 1582, 1583, 3, 2, 2, 2, 1583, 1584, 3, 2, 2, 2, 1584, 1586, 5, 224, 113, 2, 1585, 1587, 5, 296, 149, 2, 1586, 1585, 3, 2, 2, 2, 1586, 1587, 3, 2, 2, 2, 1587, 1588, 3, 2, 2, 2, 1588, 1589, 5, 264, 133, 2, 1589, 263, 3, 2, 2, 2, 1590, 1592, 5, 320, 161, 2, 1591, 1590, 3, 2, 2, 2, 1591, 1592, 3, 2, 2, 2, 1592, 1593, 3, 2, 2, 2, 1593, 1599, 5, 102, 52, 2, 1594, 1599, 5, 358, 180, 2, 1595, 1596, 7, 103, 2, 2, 1596, 1597, 9, 19, 2, 2, 1597, 1599, 7, 130, 2, 2, 1598, 1591, 3, 2, 2, 2, 1598, 1594, 3, 2, 2, 2, 1598, 1595, 3, 2, 2, 2, 1599, 265, 3, 2, 2, 2, 1600, 1606, 5, 268, 135, 2, 1601, 1602, 7, 87, 2, 2, 1602, 1603, 5, 36, 19, 2, 1603, 1604, 7, 88, 2, 2, 1604, 1606, 3, 2, 2, 2, 1605, 1600, 3, 2, 2, 2, 1605, 1601, 3, 2, 2, 2, 1606, 267, 3, 2, 2, 2, 1607, 1608, 7, 103, 2, 2, 1608, 1611, 5, 270, 136, 2, 1609, 1611, 5, 274, 138, 2, 1610, 1607, 3, 2, 2, 2, 1610, 1609, 3, 2, 2, 2, 1611, 269, 3, 2, 2, 2, 1612, 1615, 5, 88, 45, 2, 1613, 1615, 5, 274, 138, 2, 1614, 1612, 3, 2, 2, 2, 1614, 1613, 3, 2, 2, 2, 1615, 271, 3, 2, 2, 2, 1616, 1618, 5, 270, 136, 2, 1617, 1619, 7, 133, 2, 2, 1618, 1617, 3, 2, 2, 2, 1618, 1619, 3, 2, 2, 2, 1619, 1627, 3, 2, 2, 2, 1620, 1621, 7, 124, 2, 2, 1621, 1623, 5, 270, 136, 2, 1622, 1624, 7, 133, 2, 2, 1623, 1622, 3, 2, 2, 2, 1623, 1624, 3, 2, 2, 2, 1624, 1626, 3, 2, 2, 2, 1625, 1620, 3, 2, 2, 2, 1626, 1629, 3, 2, 2, 2, 1627, 1625, 3, 2, 2, 2, 1627, 1628, 3, 2, 2, 2, 1628, 273, 3, 2, 2, 2, 1629, 1627, 3, 2, 2, 2, 1630, 1635, 7, 91, 2, 2, 1631, 1633, 5, 272, 137, 2, 1632, 1634, 7, 124, 2, 2, 1633, 1632, 3, 2, 2, 2, 1633, 1634, 3, 2, 2, 2, 1634, 1636, 3, 2, 2, 2, 1635, 1631, 3, 2, 2, 2, 1635, 1636, 3, 2, 2, 2, 1636, 1637, 3, 2, 2, 2, 1637, 1638, 7, 92, 2, 2, 1638, 275, 3, 2, 2, 2, 1639, 1642, 7, 134, 2, 2, 1640, 1642, 5, 340, 171, 2, 1641, 1639, 3, 2, 2, 2, 1641, 1640, 3, 2, 2, 2, 1642, 277, 3, 2, 2, 2, 1643, 1644, 5, 280, 141, 2, 1644, 1646, 7, 91, 2, 2, 1645, 1647, 5, 288, 145, 2, 1646, 1645, 3, 2, 2, 2, 1646, 1647, 3, 2, 2, 2, 1647, 1648, 3, 2, 2, 2, 1648, 1649, 7, 92, 2, 2, 1649, 279, 3, 2, 2, 2, 1650, 1652, 5, 286, 144, 2, 1651, 1653, 5, 202, 102, 2, 1652, 1651, 3, 2, 2, 2, 1652, 1653, 3, 2, 2, 2, 1653, 1658, 3, 2, 2, 2, 1654, 1656, 5, 282, 142, 2, 1655, 1657, 5, 284, 143, 2, 1656, 1655, 3, 2, 2, 2, 1656, 1657, 3, 2, 2, 2, 1657, 1659, 3, 2, 2, 2, 1658, 1654, 3, 2, 2, 2, 1658, 1659, 3, 2, 2, 2, 1659, 1661, 3, 2, 2, 2, 1660, 1662, 5, 302, 152, 2, 1661, 1660, 3, 2, 2, 2, 1661, 1662, 3, 2, 2, 2, 1662, 1674, 3, 2, 2, 2, 1663, 1665, 7, 79, 2, 2, 1664, 1666, 5, 202, 102, 2, 1665, 1664, 3, 2, 2, 2, 1665, 1666, 3, 2, 2, 2, 1666, 1671, 3, 2, 2, 2, 1667, 1669, 5, 282, 142, 2, 1668, 1670, 5, 284, 143, 2, 1669, 1668, 3, 2, 2, 2, 1669, 1670, 3, 2, 2, 2, 1670, 1672, 3, 2, 2, 2, 1671, 1667, 3, 2, 2, 2, 1671, 1672, 3, 2, 2, 2, 1672, 1674, 3, 2, 2, 2, 1673, 1650, 3, 2, 2, 2, 1673, 1663, 3, 2, 2, 2, 1674, 281, 3, 2, 2, 2, 1675, 1677, 5, 12, 7, 2, 1676, 1675, 3, 2, 2, 2, 1676, 1677, 3, 2, 2, 2, 1677, 1678, 3, 2, 2, 2, 1678, 1679, 5, 276, 139, 2, 1679, 283, 3, 2, 2, 2, 1680, 1681, 7, 40, 2, 2, 1681, 285, 3, 2, 2, 2, 1682, 1683, 9, 15, 2, 2, 1683, 287, 3, 2, 2, 2, 1684, 1689, 5, 290, 146, 2, 1685, 1686, 5, 312, 157, 2, 1686, 1687, 7, 128, 2, 2, 1687, 1689, 3, 2, 2, 2, 1688, 1684, 3, 2, 2, 2, 1688, 1685, 3, 2, 2, 2, 1689, 1690, 3, 2, 2, 2, 1690, 1688, 3, 2, 2, 2, 1690, 1691, 3, 2, 2, 2, 1691, 289, 3, 2, 2, 2, 1692, 1694, 5, 202, 102, 2, 1693, 1692, 3, 2, 2, 2, 1693, 1694, 3, 2, 2, 2, 1694, 1696, 3, 2, 2, 2, 1695, 1697, 5, 140, 71, 2, 1696, 1695, 3, 2, 2, 2, 1696, 1697, 3, 2, 2, 2, 1697, 1699, 3, 2, 2, 2, 1698, 1700, 5, 292, 147, 2, 1699, 1698, 3, 2, 2, 2, 1699, 1700, 3, 2, 2, 2, 1700, 1701, 3, 2, 2, 2, 1701, 1709, 7, 130, 2, 2, 1702, 1709, 5, 262, 132, 2, 1703, 1709, 5, 194, 98, 2, 1704, 1709, 5, 132, 67, 2, 1705, 1709, 5, 332, 167, 2, 1706, 1709, 5, 128, 65, 2, 1707, 1709, 5, 134, 68, 2, 1708, 1693, 3, 2, 2, 2, 1708, 1702, 3, 2, 2, 2, 1708, 1703, 3, 2, 2, 2, 1708, 1704, 3, 2, 2, 2, 1708, 1705, 3, 2, 2, 2, 1708, 1706, 3, 2, 2, 2, 1708, 1707, 3, 2, 2, 2, 1709, 291, 3, 2, 2, 2, 1710, 1715, 5, 294, 148, 2, 1711, 1712, 7, 124, 2, 2, 1712, 1714, 5, 294, 148, 2, 1713, 1711, 3, 2, 2, 2, 1714, 1717, 3, 2, 2, 2, 1715, 1713, 3, 2, 2, 2, 1715, 1716, 3, 2, 2, 2, 1716, 293, 3, 2, 2, 2, 1717, 1715, 3, 2, 2, 2, 1718, 1728, 5, 224, 113, 2, 1719, 1721, 5, 296, 149, 2, 1720, 1719, 3, 2, 2, 2, 1720, 1721, 3, 2, 2, 2, 1721, 1723, 3, 2, 2, 2, 1722, 1724, 5, 300, 151, 2, 1723, 1722, 3, 2, 2, 2, 1723, 1724, 3, 2, 2, 2, 1724, 1729, 3, 2, 2, 2, 1725, 1727, 5, 268, 135, 2, 1726, 1725, 3, 2, 2, 2, 1726, 1727, 3, 2, 2, 2, 1727, 1729, 3, 2, 2, 2, 1728, 1720, 3, 2, 2, 2, 1728, 1726, 3, 2, 2, 2, 1729, 1739, 3, 2, 2, 2, 1730, 1732, 7, 134, 2, 2, 1731, 1730, 3, 2, 2, 2, 1731, 1732, 3, 2, 2, 2, 1732, 1734, 3, 2, 2, 2, 1733, 1735, 5, 202, 102, 2, 1734, 1733, 3, 2, 2, 2, 1734, 1735, 3, 2, 2, 2, 1735, 1736, 3, 2, 2, 2, 1736, 1737, 7, 128, 2, 2, 1737, 1739, 5, 94, 48, 2, 1738, 1718, 3, 2, 2, 2, 1738, 1731, 3, 2, 2, 2, 1739, 295, 3, 2, 2, 2, 1740, 1742, 5, 298, 150, 2, 1741, 1740, 3, 2, 2, 2, 1742, 1743, 3, 2, 2, 2, 1743, 1741, 3, 2, 2, 2, 1743, 1744, 3, 2, 2, 2, 1744, 297, 3, 2, 2, 2, 1745, 1746, 9, 20, 2, 2, 1746, 299, 3, 2, 2, 2, 1747, 1748, 7, 103, 2, 2, 1748, 1749, 7, 136, 2, 2, 1749, 1750, 8, 151, 1, 2, 1750, 301, 3, 2, 2, 2, 1751, 1752, 7, 128, 2, 2, 1752, 1753, 5, 304, 153, 2, 1753, 303, 3, 2, 2, 2, 1754, 1756, 5, 306, 154, 2, 1755, 1757, 7, 133, 2, 2, 1756, 1755, 3, 2, 2, 2, 1756, 1757, 3, 2, 2, 2, 1757, 1765, 3, 2, 2, 2, 1758, 1759, 7, 124, 2, 2, 1759, 1761, 5, 306, 154, 2, 1760, 1762, 7, 133, 2, 2, 1761, 1760, 3, 2, 2, 2, 1761, 1762, 3, 2, 2, 2, 1762, 1764, 3, 2, 2, 2, 1763, 1758, 3, 2, 2, 2, 1764, 1767, 3, 2, 2, 2, 1765, 1763, 3, 2, 2, 2, 1765, 1766, 3, 2, 2, 2, 1766, 305, 3, 2, 2, 2, 1767, 1765, 3, 2, 2, 2, 1768, 1770, 5, 202, 102, 2, 1769, 1768, 3, 2, 2, 2, 1769, 1770, 3, 2, 2, 2, 1770, 1783, 3, 2, 2, 2, 1771, 1784, 5, 310, 156, 2, 1772, 1774, 7, 82, 2, 2, 1773, 1775, 5, 312, 157, 2, 1774, 1773, 3, 2, 2, 2, 1774, 1775, 3, 2, 2, 2, 1775, 1776, 3, 2, 2, 2, 1776, 1784, 5, 310, 156, 2, 1777, 1779, 5, 312, 157, 2, 1778, 1780, 7, 82, 2, 2, 1779, 1778, 3, 2, 2, 2, 1779, 1780, 3, 2, 2, 2, 1780, 1781, 3, 2, 2, 2, 1781, 1782, 5, 310, 156, 2, 1782, 1784, 3, 2, 2, 2, 1783, 1771, 3, 2, 2, 2, 1783, 1772, 3, 2, 2, 2, 1783, 1777, 3, 2, 2, 2, 1784, 307, 3, 2, 2, 2, 1785, 1787, 5, 12, 7, 2, 1786, 1785, 3, 2, 2, 2, 1786, 1787, 3, 2, 2, 2, 1787, 1788, 3, 2, 2, 2, 1788, 1791, 5, 276, 139, 2, 1789, 1791, 5, 160, 81, 2, 1790, 1786, 3, 2, 2, 2, 1790, 1789, 3, 2, 2, 2, 1791, 309, 3, 2, 2, 2, 1792, 1793, 5, 308, 155, 2, 1793, 311, 3, 2, 2, 2, 1794, 1795, 9, 21, 2, 2, 1795, 313, 3, 2, 2, 2, 1796, 1797, 7, 54, 2, 2, 1797, 1798, 5, 316, 159, 2, 1798, 315, 3, 2, 2, 2, 1799, 1801, 5, 152, 77, 2, 1800, 1802, 5, 318, 160, 2, 1801, 1800, 3, 2, 2, 2, 1801, 1802, 3, 2, 2, 2, 1802, 317, 3, 2, 2, 2, 1803, 1805, 5, 234, 118, 2, 1804, 1806, 5, 318, 160, 2, 1805, 1804, 3, 2, 2, 2, 1805, 1806, 3, 2, 2, 2, 1806, 319, 3, 2, 2, 2, 1807, 1808, 7, 128, 2, 2, 1808, 1809, 5, 322, 162, 2, 1809, 321, 3, 2, 2, 2, 1810, 1812, 5, 324, 163, 2, 1811, 1813, 7, 133, 2, 2, 1812, 1811, 3, 2, 2, 2, 1812, 1813, 3, 2, 2, 2, 1813, 1821, 3, 2, 2, 2, 1814, 1815, 7, 124, 2, 2, 1815, 1817, 5, 324, 163, 2, 1816, 1818, 7, 133, 2, 2, 1817, 1816, 3, 2, 2, 2, 1817, 1818, 3, 2, 2, 2, 1818, 1820, 3, 2, 2, 2, 1819, 1814, 3, 2, 2, 2, 1820, 1823, 3, 2, 2, 2, 1821, 1819, 3, 2, 2, 2, 1821, 1822, 3, 2, 2, 2, 1822, 323, 3, 2, 2, 2, 1823, 1821, 3, 2, 2, 2, 1824, 1831, 5, 326, 164, 2, 1825, 1827, 7, 87, 2, 2, 1826, 1828, 5, 36, 19, 2, 1827, 1826, 3, 2, 2, 2, 1827, 1828, 3, 2, 2, 2, 1828, 1829, 3, 2, 2, 2, 1829, 1832, 7, 88, 2, 2, 1830, 1832, 5, 274, 138, 2, 1831, 1825, 3, 2, 2, 2, 1831, 1830, 3, 2, 2, 2, 1832, 325, 3, 2, 2, 2, 1833, 1836, 5, 308, 155, 2, 1834, 1836, 7, 134, 2, 2, 1835, 1833, 3, 2, 2, 2, 1835, 1834, 3, 2, 2, 2, 1836, 327, 3, 2, 2, 2, 1837, 1838, 7, 54, 2, 2, 1838, 1839, 5, 376, 189, 2, 1839, 329, 3, 2, 2, 2, 1840, 1844, 7, 54, 2, 2, 1841, 1842, 7, 6, 2, 2, 1842, 1845, 7, 134, 2, 2, 1843, 1845, 7, 142, 2, 2, 1844, 1841, 3, 2, 2, 2, 1844, 1843, 3, 2, 2, 2, 1845, 331, 3, 2, 2, 2, 1846, 1847, 7, 70, 2, 2, 1847, 1848, 7, 104, 2, 2, 1848, 1849, 5, 334, 168, 2, 1849, 1850, 7, 105, 2, 2, 1850, 1851, 5, 124, 63, 2, 1851, 333, 3, 2, 2, 2, 1852, 1857, 5, 336, 169, 2, 1853, 1854, 7, 124, 2, 2, 1854, 1856, 5, 336, 169, 2, 1855, 1853, 3, 2, 2, 2, 1856, 1859, 3, 2, 2, 2, 1857, 1855, 3, 2, 2, 2, 1857, 1858, 3, 2, 2, 2, 1858, 335, 3, 2, 2, 2, 1859, 1857, 3, 2, 2, 2, 1860, 1863, 5, 338, 170, 2, 1861, 1863, 5, 260, 131, 2, 1862, 1860, 3, 2, 2, 2, 1862, 1861, 3, 2, 2, 2, 1863, 337, 3, 2, 2, 2, 1864, 1865, 7, 70, 2, 2, 1865, 1866, 7, 104, 2, 2, 1866, 1867, 5, 334, 168, 2, 1867, 1868, 7, 105, 2, 2, 1868, 1870, 3, 2, 2, 2, 1869, 1864, 3, 2, 2, 2, 1869, 1870, 3, 2, 2, 2, 1870, 1871, 3, 2, 2, 2, 1871, 1874, 7, 23, 2, 2, 1872, 1874, 7, 78, 2, 2, 1873, 1869, 3, 2, 2, 2, 1873, 1872, 3, 2, 2, 2, 1874, 1886, 3, 2, 2, 2, 1875, 1877, 7, 133, 2, 2, 1876, 1875, 3, 2, 2, 2, 1876, 1877, 3, 2, 2, 2, 1877, 1879, 3, 2, 2, 2, 1878, 1880, 7, 134, 2, 2, 1879, 1878, 3, 2, 2, 2, 1879, 1880, 3, 2, 2, 2, 1880, 1887, 3, 2, 2, 2, 1881, 1883, 7, 134, 2, 2, 1882, 1881, 3, 2, 2, 2, 1882, 1883, 3, 2, 2, 2, 1883, 1884, 3, 2, 2, 2, 1884, 1885, 7, 103, 2, 2, 1885, 1887, 5, 244, 123, 2, 1886, 1876, 3, 2, 2, 2, 1886, 1882, 3, 2, 2, 2, 1887, 339, 3, 2, 2, 2, 1888, 1889, 5, 344, 173, 2, 1889, 1891, 7, 104, 2, 2, 1890, 1892, 5, 346, 174, 2, 1891, 1890, 3, 2, 2, 2, 1891, 1892, 3, 2, 2, 2, 1892, 1893, 3, 2, 2, 2, 1893, 1894, 7, 105, 2, 2, 1894, 341, 3, 2, 2, 2, 1895, 1907, 5, 340, 171, 2, 1896, 1899, 5, 328, 165, 2, 1897, 1899, 5, 330, 166, 2, 1898, 1896, 3, 2, 2, 2, 1898, 1897, 3, 2, 2, 2, 1899, 1900, 3, 2, 2, 2, 1900, 1902, 7, 104, 2, 2, 1901, 1903, 5, 346, 174, 2, 1902, 1901, 3, 2, 2, 2, 1902, 1903, 3, 2, 2, 2, 1903, 1904, 3, 2, 2, 2, 1904, 1905, 7, 105, 2, 2, 1905, 1907, 3, 2, 2, 2, 1906, 1895, 3, 2, 2, 2, 1906, 1898, 3, 2, 2, 2, 1907, 343, 3, 2, 2, 2, 1908, 1909, 7, 134, 2, 2, 1909, 345, 3, 2, 2, 2, 1910, 1912, 5, 348, 175, 2, 1911, 1913, 7, 133, 2, 2, 1912, 1911, 3, 2, 2, 2, 1912, 1913, 3, 2, 2, 2, 1913, 1921, 3, 2, 2, 2, 1914, 1915, 7, 124, 2, 2, 1915, 1917, 5, 348, 175, 2, 1916, 1918, 7, 133, 2, 2, 1917, 1916, 3, 2, 2, 2, 1917, 1918, 3, 2, 2, 2, 1918, 1920, 3, 2, 2, 2, 1919, 1914, 3, 2, 2, 2, 1920, 1923, 3, 2, 2, 2, 1921, 1919, 3, 2, 2, 2, 1921, 1922, 3, 2, 2, 2, 1922, 347, 3, 2, 2, 2, 1923, 1921, 3, 2, 2, 2, 1924, 1928, 5, 244, 123, 2, 1925, 1928, 5, 94, 48, 2, 1926, 1928, 5, 6, 4, 2, 1927, 1924, 3, 2, 2, 2, 1927, 1925, 3, 2, 2, 2, 1927, 1926, 3, 2, 2, 2, 1928, 349, 3, 2, 2, 2, 1929, 1930, 7, 78, 2, 2, 1930, 1936, 5, 12, 7, 2, 1931, 1937, 7, 134, 2, 2, 1932, 1934, 7, 70, 2, 2, 1933, 1932, 3, 2, 2, 2, 1933, 1934, 3, 2, 2, 2, 1934, 1935, 3, 2, 2, 2, 1935, 1937, 5, 340, 171, 2, 1936, 1931, 3, 2, 2, 2, 1936, 1933, 3, 2, 2, 2, 1937, 351, 3, 2, 2, 2, 1938, 1940, 7, 38, 2, 2, 1939, 1938, 3, 2, 2, 2, 1939, 1940, 3, 2, 2, 2, 1940, 1941, 3, 2, 2, 2, 1941, 1942, 7, 70, 2, 2, 1942, 1943, 5, 124, 63, 2, 1943, 353, 3, 2, 2, 2, 1944, 1945, 7, 70, 2, 2, 1945, 1946, 7, 104, 2, 2, 1946, 1947, 7, 105, 2, 2, 1947, 1948, 5, 124, 63, 2, 1948, 355, 3, 2, 2, 2, 1949, 1950, 7, 75, 2, 2, 1950, 1951, 5, 102, 52, 2, 1951, 1952, 5, 360, 181, 2, 1952, 357, 3, 2, 2, 2, 1953, 1955, 7, 75, 2, 2, 1954, 1956, 5, 320, 161, 2, 1955, 1954, 3, 2, 2, 2, 1955, 1956, 3, 2, 2, 2, 1956, 1957, 3, 2, 2, 2, 1957, 1958, 5, 102, 52, 2, 1958, 1959, 5, 360, 181, 2, 1959, 359, 3, 2, 2, 2, 1960, 1962, 5, 362, 182, 2, 1961, 1960, 3, 2, 2, 2, 1962, 1963, 3, 2, 2, 2, 1963, 1961, 3, 2, 2, 2, 1963, 1964, 3, 2, 2, 2, 1964, 361, 3, 2, 2, 2, 1965, 1966, 7, 19, 2, 2, 1966, 1967, 7, 87, 2, 2, 1967, 1968, 5, 364, 183, 2, 1968, 1969, 7, 88, 2, 2, 1969, 1970, 5, 102, 52, 2, 1970, 363, 3, 2, 2, 2, 1971, 1973, 5, 202, 102, 2, 1972, 1971, 3, 2, 2, 2, 1972, 1973, 3, 2, 2, 2, 1973, 1974, 3, 2, 2, 2, 1974, 1977, 5, 152, 77, 2, 1975, 1978, 5, 224, 113, 2, 1976, 1978, 5, 246, 124, 2, 1977, 1975, 3, 2, 2, 2, 1977, 1976, 3, 2, 2, 2, 1977, 1978, 3, 2, 2, 2, 1978, 1981, 3, 2, 2, 2, 1979, 1981, 7, 133, 2, 2, 1980, 1972, 3, 2, 2, 2, 1980, 1979, 3, 2, 2, 2, 1981, 365, 3, 2, 2, 2, 1982, 1984, 7, 73, 2, 2, 1983, 1985, 5, 88, 45, 2, 1984, 1983, 3, 2, 2, 2, 1984, 1985, 3, 2, 2, 2, 1985, 367, 3, 2, 2, 2, 1986, 1989, 5, 370, 186, 2, 1987, 1989, 5, 374, 188, 2, 1988, 1986, 3, 2, 2, 2, 1988, 1987, 3, 2, 2, 2, 1989, 369, 3, 2, 2, 2, 1990, 1991, 7, 73, 2, 2, 1991, 1993, 7, 87, 2, 2, 1992, 1994, 5, 372, 187, 2, 1993, 1992, 3, 2, 2, 2, 1993, 1994, 3, 2, 2, 2, 1994, 1995, 3, 2, 2, 2, 1995, 1996, 7, 88, 2, 2, 1996, 371, 3, 2, 2, 2, 1997, 1999, 5, 244, 123, 2, 1998, 2000, 7, 133, 2, 2, 1999, 1998, 3, 2, 2, 2, 1999, 2000, 3, 2, 2, 2, 2000, 2008, 3, 2, 2, 2, 2001, 2002, 7, 124, 2, 2, 2002, 2004, 5, 244, 123, 2, 2003, 2005, 7, 133, 2, 2, 2004, 2003, 3, 2, 2, 2, 2004, 2005, 3, 2, 2, 2, 2005, 2007, 3, 2, 2, 2, 2006, 2001, 3, 2, 2, 2, 2007, 2010, 3, 2, 2, 2, 2008, 2006, 3, 2, 2, 2, 2008, 2009, 3, 2, 2, 2, 2009, 373, 3, 2, 2, 2, 2010, 2008, 3, 2, 2, 2, 2011, 2012, 7, 52, 2, 2, 2012, 2013, 7, 87, 2, 2, 2013, 2014, 5, 94, 48, 2, 2014, 2015, 7, 88, 2, 2, 2015, 2018, 3, 2, 2, 2, 2016, 2018, 7, 52, 2, 2, 2017, 2011, 3, 2, 2, 2, 2017, 2016, 3, 2, 2, 2, 2018, 375, 3, 2, 2, 2, 2019, 2022, 7, 51, 2, 2, 2020, 2021, 7, 89, 2, 2, 2021, 2023, 7, 90, 2, 2, 2022, 2020, 3, 2, 2, 2, 2022, 2023, 3, 2, 2, 2, 2023, 2073, 3, 2, 2, 2, 2024, 2027, 7, 30, 2, 2, 2025, 2026, 7, 89, 2, 2, 2026, 2028, 7, 90, 2, 2, 2027, 2025, 3, 2, 2, 2, 2027, 2028, 3, 2, 2, 2, 2028, 2073, 3, 2, 2, 2, 2029, 2073, 7, 93, 2, 2, 2030, 2073, 7, 94, 2, 2, 2031, 2073, 7, 95, 2, 2, 2032, 2073, 7, 96, 2, 2, 2033, 2073, 7, 97, 2, 2, 2034, 2073, 7, 98, 2, 2, 2035, 2073, 7, 99, 2, 2, 2036, 2073, 7, 100, 2, 2, 2037, 2073, 7, 101, 2, 2, 2038, 2073, 7, 102, 2, 2, 2039, 2073, 7, 103, 2, 2, 2040, 2073, 7, 105, 2, 2, 2041, 2073, 7, 104, 2, 2, 2042, 2073, 7, 119, 2, 2, 2043, 2073, 7, 106, 2, 2, 2044, 2073, 7, 107, 2, 2, 2045, 2073, 7, 108, 2, 2, 2046, 2073, 7, 103, 2, 2, 2047, 2073, 7, 110, 2, 2, 2048, 2073, 7, 111, 2, 2, 2049, 2073, 7, 112, 2, 2, 2050, 2073, 7, 113, 2, 2, 2051, 2052, 7, 104, 2, 2, 2052, 2073, 7, 104, 2, 2, 2053, 2054, 7, 105, 2, 2, 2054, 2073, 7, 105, 2, 2, 2055, 2073, 7, 115, 2, 2, 2056, 2073, 7, 114, 2, 2, 2057, 2073, 7, 116, 2, 2, 2058, 2073, 7, 117, 2, 2, 2059, 2073, 7, 118, 2, 2, 2060, 2073, 7, 119, 2, 2, 2061, 2073, 7, 120, 2, 2, 2062, 2073, 7, 121, 2, 2, 2063, 2073, 7, 122, 2, 2, 2064, 2073, 7, 123, 2, 2, 2065, 2073, 7, 124, 2, 2, 2066, 2073, 7, 125, 2, 2, 2067, 2073, 7, 126, 2, 2, 2068, 2069, 7, 87, 2, 2, 2069, 2073, 7, 88, 2, 2, 2070, 2071, 7, 89, 2, 2, 2071, 2073, 7, 90, 2, 2, 2072, 2019, 3, 2, 2, 2, 2072, 2024, 3, 2, 2, 2, 2072, 2029, 3, 2, 2, 2, 2072, 2030, 3, 2, 2, 2, 2072, 2031, 3, 2, 2, 2, 2072, 2032, 3, 2, 2, 2, 2072, 2033, 3, 2, 2, 2, 2072, 2034, 3, 2, 2, 2, 2072, 2035, 3, 2, 2, 2, 2072, 2036, 3, 2, 2, 2, 2072, 2037, 3, 2, 2, 2, 2072, 2038, 3, 2, 2, 2, 2072, 2039, 3, 2, 2, 2, 2072, 2040, 3, 2, 2, 2, 2072, 2041, 3, 2, 2, 2, 2072, 2042, 3, 2, 2, 2, 2072, 2043, 3, 2, 2, 2, 2072, 2044, 3, 2, 2, 2, 2072, 2045, 3, 2, 2, 2, 2072, 2046, 3, 2, 2, 2, 2072, 2047, 3, 2, 2, 2, 2072, 2048, 3, 2, 2, 2, 2072, 2049, 3, 2, 2, 2, 2072, 2050, 3, 2, 2, 2, 2072, 2051, 3, 2, 2, 2, 2072, 2053, 3, 2, 2, 2, 2072, 2055, 3, 2, 2, 2, 2072, 2056, 3, 2, 2, 2, 2072, 2057, 3, 2, 2, 2, 2072, 2058, 3, 2, 2, 2, 2072, 2059, 3, 2, 2, 2, 2072, 2060, 3, 2, 2, 2, 2072, 2061, 3, 2, 2, 2, 2072, 2062, 3, 2, 2, 2, 2072, 2063, 3, 2, 2, 2, 2072, 2064, 3, 2, 2, 2, 2072, 2065, 3, 2, 2, 2, 2072, 2066, 3, 2, 2, 2, 2072, 2067, 3, 2, 2, 2, 2072, 2068, 3, 2, 2, 2, 2072, 2070, 3, 2, 2, 2, 2073, 377, 3, 2, 2, 2, 2074, 2075, 9, 22, 2, 2, 2075, 379, 3, 2, 2, 2, 299, 381, 388, 397, 401, 410, 413, 417, 425, 432, 435, 440, 445, 451, 459, 461, 470, 474, 478, 481, 485, 488, 495, 499, 502, 505, 508, 514, 518, 522, 536, 540, 546, 553, 559, 563, 567, 569, 577, 582, 595, 602, 614, 624, 629, 633, 640, 643, 651, 655, 658, 665, 672, 676, 681, 685, 688, 693, 708, 715, 723, 731, 740, 747, 754, 762, 770, 778, 786, 794, 802, 811, 819, 828, 835, 843, 846, 849, 855, 861, 867, 874, 883, 891, 895, 902, 904, 924, 928, 934, 939, 943, 946, 953, 960, 964, 973, 984, 994, 999, 1006, 1009, 1014, 1019, 1040, 1045, 1048, 1059, 1065, 1070, 1073, 1078, 1081, 1084, 1106, 1112, 1118, 1124, 1127, 1133, 1137, 1141, 1144, 1152, 1154, 1160, 1163, 1166, 1169, 1173, 1177, 1183, 1193, 1199, 1205, 1210, 1215, 1219, 1232, 1238, 1242, 1248, 1253, 1268, 1272, 1277, 1282, 1287, 1293, 1296, 1305, 1309, 1314, 1318, 1324, 1331, 1348, 1350, 1357, 1362, 1369, 1373, 1377, 1385, 1391, 1397, 1401, 1403, 1407, 1412, 1416, 1419, 1422, 1425, 1430, 1434, 1437, 1441, 1444, 1446, 1451, 1458, 1464, 1468, 1474, 1480, 1483, 1485, 1491, 1495, 1501, 1508, 1512, 1514, 1518, 1524, 1536, 1540, 1542, 1546, 1551, 1554, 1561, 1565, 1570, 1572, 1576, 1579, 1582, 1586, 1591, 1598, 1605, 1610, 1614, 1618, 1623, 1627, 1633, 1635, 1641, 1646, 1652, 1656, 1658, 1661, 1665, 1669, 1671, 1673, 1676, 1688, 1690, 1693, 1696, 1699, 1708, 1715, 1720, 1723, 1726, 1728, 1731, 1734, 1738, 1743, 1756, 1761, 1765, 1769, 1774, 1779, 1783, 1786, 1790, 1801, 1805, 1812, 1817, 1821, 1827, 1831, 1835, 1844, 1857, 1862, 1869, 1873, 1876, 1879, 1882, 1886, 1891, 1898, 1902, 1906, 1912, 1917, 1921, 1927, 1933, 1936, 1939, 1955, 1963, 1972, 1977, 1980, 1984, 1988, 1993, 1999, 2004, 2008, 2017, 2022, 2027, 2072] \ No newline at end of file diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Parser.java b/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Parser.java new file mode 100644 index 000000000..c6a2ac3a2 --- /dev/null +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Parser.java @@ -0,0 +1,14438 @@ +// Generated from /home/syu/workspace/MSCCD_ALL/Project/grammarDefinations/CPP14/CPP14Parser.g4 by ANTLR 4.8 +package com.itsaky.androidide.lexers.cpp; +import org.antlr.v4.runtime.atn.*; +import org.antlr.v4.runtime.dfa.DFA; +import org.antlr.v4.runtime.*; +import org.antlr.v4.runtime.misc.*; +import org.antlr.v4.runtime.tree.*; +import java.util.List; +import java.util.Iterator; +import java.util.ArrayList; + +@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) +public class CPP14Parser extends Parser { + static { RuntimeMetaData.checkVersion("4.8", RuntimeMetaData.VERSION); } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + IntegerLiteral=1, CharacterLiteral=2, FloatingLiteral=3, StringLiteral=4, + BooleanLiteral=5, PointerLiteral=6, UserDefinedLiteral=7, MultiLineMacro=8, + Directive=9, Alignas=10, Alignof=11, Asm=12, Auto=13, Bool=14, Break=15, + Case=16, Catch=17, Char=18, Char16=19, Char32=20, Class=21, Const=22, + Constexpr=23, Const_cast=24, Continue=25, Decltype=26, Default=27, Delete=28, + Do=29, Double=30, Dynamic_cast=31, Else=32, Enum=33, Explicit=34, Export=35, + Extern=36, False_=37, Final=38, Float=39, For=40, Friend=41, Goto=42, + If=43, Inline=44, Int=45, Long=46, Mutable=47, Namespace=48, New=49, Noexcept=50, + Nullptr=51, Operator=52, Override=53, Private=54, Protected=55, Public=56, + Register=57, Reinterpret_cast=58, Return=59, Short=60, Signed=61, Sizeof=62, + Static=63, Static_assert=64, Static_cast=65, Struct=66, Switch=67, Template=68, + This=69, Thread_local=70, Throw=71, True_=72, Try=73, Typedef=74, Typeid_=75, + Typename_=76, Union=77, Unsigned=78, Using=79, Virtual=80, Void=81, Volatile=82, + Wchar=83, While=84, LeftParen=85, RightParen=86, LeftBracket=87, RightBracket=88, + LeftBrace=89, RightBrace=90, Plus=91, Minus=92, Star=93, Div=94, Mod=95, + Caret=96, And=97, Or=98, Tilde=99, Not=100, Assign=101, Less=102, Greater=103, + PlusAssign=104, MinusAssign=105, StarAssign=106, DivAssign=107, ModAssign=108, + XorAssign=109, AndAssign=110, OrAssign=111, LeftShiftAssign=112, RightShiftAssign=113, + Equal=114, NotEqual=115, LessEqual=116, GreaterEqual=117, AndAnd=118, + OrOr=119, PlusPlus=120, MinusMinus=121, Comma=122, ArrowStar=123, Arrow=124, + Question=125, Colon=126, Doublecolon=127, Semi=128, Dot=129, DotStar=130, + Ellipsis=131, Identifier=132, DecimalLiteral=133, OctalLiteral=134, HexadecimalLiteral=135, + BinaryLiteral=136, Integersuffix=137, UserDefinedIntegerLiteral=138, UserDefinedFloatingLiteral=139, + UserDefinedStringLiteral=140, UserDefinedCharacterLiteral=141, Whitespace=142, + Newline=143, BlockComment=144, LineComment=145; + public static final int + RULE_translationUnit = 0, RULE_primaryExpression = 1, RULE_idExpression = 2, + RULE_unqualifiedId = 3, RULE_qualifiedId = 4, RULE_nestedNameSpecifier = 5, + RULE_lambdaExpression = 6, RULE_lambdaIntroducer = 7, RULE_lambdaCapture = 8, + RULE_captureDefault = 9, RULE_captureList = 10, RULE_capture = 11, RULE_simpleCapture = 12, + RULE_initcapture = 13, RULE_lambdaDeclarator = 14, RULE_postfixExpression = 15, + RULE_typeIdOfTheTypeId = 16, RULE_expressionList = 17, RULE_pseudoDestructorName = 18, + RULE_unaryExpression = 19, RULE_unaryOperator = 20, RULE_newExpression = 21, + RULE_newPlacement = 22, RULE_newTypeId = 23, RULE_newDeclarator = 24, + RULE_noPointerNewDeclarator = 25, RULE_newInitializer = 26, RULE_deleteExpression = 27, + RULE_noExceptExpression = 28, RULE_castExpression = 29, RULE_pointerMemberExpression = 30, + RULE_multiplicativeExpression = 31, RULE_additiveExpression = 32, RULE_shiftExpression = 33, + RULE_shiftOperator = 34, RULE_relationalExpression = 35, RULE_equalityExpression = 36, + RULE_andExpression = 37, RULE_exclusiveOrExpression = 38, RULE_inclusiveOrExpression = 39, + RULE_logicalAndExpression = 40, RULE_logicalOrExpression = 41, RULE_conditionalExpression = 42, + RULE_assignmentExpression = 43, RULE_assignmentOperator = 44, RULE_expression = 45, + RULE_constantExpression = 46, RULE_statement = 47, RULE_labeledStatement = 48, + RULE_expressionStatement = 49, RULE_compoundStatement = 50, RULE_statementSeq = 51, + RULE_selectionStatement = 52, RULE_condition = 53, RULE_iterationStatement = 54, + RULE_forInitStatement = 55, RULE_forRangeDeclaration = 56, RULE_forRangeInitializer = 57, + RULE_jumpStatement = 58, RULE_declarationStatement = 59, RULE_declarationseq = 60, + RULE_declaration = 61, RULE_blockDeclaration = 62, RULE_aliasDeclaration = 63, + RULE_simpleDeclaration = 64, RULE_staticAssertDeclaration = 65, RULE_emptyDeclaration = 66, + RULE_attributeDeclaration = 67, RULE_declSpecifier = 68, RULE_declSpecifierSeq = 69, + RULE_storageClassSpecifier = 70, RULE_functionSpecifier = 71, RULE_typedefName = 72, + RULE_typeSpecifier = 73, RULE_trailingTypeSpecifier = 74, RULE_typeSpecifierSeq = 75, + RULE_trailingTypeSpecifierSeq = 76, RULE_simpleTypeSpecifier = 77, RULE_theTypeName = 78, + RULE_decltypeSpecifier = 79, RULE_elaboratedTypeSpecifier = 80, RULE_enumName = 81, + RULE_enumSpecifier = 82, RULE_enumHead = 83, RULE_opaqueEnumDeclaration = 84, + RULE_enumkey = 85, RULE_enumbase = 86, RULE_enumeratorList = 87, RULE_enumeratorDefinition = 88, + RULE_enumerator = 89, RULE_namespaceName = 90, RULE_originalNamespaceName = 91, + RULE_namespaceDefinition = 92, RULE_namespaceAlias = 93, RULE_namespaceAliasDefinition = 94, + RULE_qualifiednamespacespecifier = 95, RULE_usingDeclaration = 96, RULE_usingDirective = 97, + RULE_asmDefinition = 98, RULE_linkageSpecification = 99, RULE_attributeSpecifierSeq = 100, + RULE_attributeSpecifier = 101, RULE_alignmentspecifier = 102, RULE_attributeList = 103, + RULE_attribute = 104, RULE_attributeNamespace = 105, RULE_attributeArgumentClause = 106, + RULE_balancedTokenSeq = 107, RULE_balancedtoken = 108, RULE_initDeclaratorList = 109, + RULE_initDeclarator = 110, RULE_declarator = 111, RULE_pointerDeclarator = 112, + RULE_noPointerDeclarator = 113, RULE_parametersAndQualifiers = 114, RULE_trailingReturnType = 115, + RULE_pointerOperator = 116, RULE_cvqualifierseq = 117, RULE_cvQualifier = 118, + RULE_refqualifier = 119, RULE_declaratorid = 120, RULE_theTypeId = 121, + RULE_abstractDeclarator = 122, RULE_pointerAbstractDeclarator = 123, RULE_noPointerAbstractDeclarator = 124, + RULE_abstractPackDeclarator = 125, RULE_noPointerAbstractPackDeclarator = 126, + RULE_parameterDeclarationClause = 127, RULE_parameterDeclarationList = 128, + RULE_parameterDeclaration = 129, RULE_functionDefinition = 130, RULE_functionBody = 131, + RULE_initializer = 132, RULE_braceOrEqualInitializer = 133, RULE_initializerClause = 134, + RULE_initializerList = 135, RULE_bracedInitList = 136, RULE_className = 137, + RULE_classSpecifier = 138, RULE_classHead = 139, RULE_classHeadName = 140, + RULE_classVirtSpecifier = 141, RULE_classKey = 142, RULE_memberSpecification = 143, + RULE_memberdeclaration = 144, RULE_memberDeclaratorList = 145, RULE_memberDeclarator = 146, + RULE_virtualSpecifierSeq = 147, RULE_virtualSpecifier = 148, RULE_pureSpecifier = 149, + RULE_baseClause = 150, RULE_baseSpecifierList = 151, RULE_baseSpecifier = 152, + RULE_classOrDeclType = 153, RULE_baseTypeSpecifier = 154, RULE_accessSpecifier = 155, + RULE_conversionFunctionId = 156, RULE_conversionTypeId = 157, RULE_conversionDeclarator = 158, + RULE_constructorInitializer = 159, RULE_memInitializerList = 160, RULE_memInitializer = 161, + RULE_meminitializerid = 162, RULE_operatorFunctionId = 163, RULE_literalOperatorId = 164, + RULE_templateDeclaration = 165, RULE_templateparameterList = 166, RULE_templateParameter = 167, + RULE_typeParameter = 168, RULE_simpleTemplateId = 169, RULE_templateId = 170, + RULE_templateName = 171, RULE_templateArgumentList = 172, RULE_templateArgument = 173, + RULE_typeNameSpecifier = 174, RULE_explicitInstantiation = 175, RULE_explicitSpecialization = 176, + RULE_tryBlock = 177, RULE_functionTryBlock = 178, RULE_handlerSeq = 179, + RULE_handler = 180, RULE_exceptionDeclaration = 181, RULE_throwExpression = 182, + RULE_exceptionSpecification = 183, RULE_dynamicExceptionSpecification = 184, + RULE_typeIdList = 185, RULE_noeExceptSpecification = 186, RULE_theOperator = 187, + RULE_literal = 188; + private static String[] makeRuleNames() { + return new String[] { + "translationUnit", "primaryExpression", "idExpression", "unqualifiedId", + "qualifiedId", "nestedNameSpecifier", "lambdaExpression", "lambdaIntroducer", + "lambdaCapture", "captureDefault", "captureList", "capture", "simpleCapture", + "initcapture", "lambdaDeclarator", "postfixExpression", "typeIdOfTheTypeId", + "expressionList", "pseudoDestructorName", "unaryExpression", "unaryOperator", + "newExpression", "newPlacement", "newTypeId", "newDeclarator", "noPointerNewDeclarator", + "newInitializer", "deleteExpression", "noExceptExpression", "castExpression", + "pointerMemberExpression", "multiplicativeExpression", "additiveExpression", + "shiftExpression", "shiftOperator", "relationalExpression", "equalityExpression", + "andExpression", "exclusiveOrExpression", "inclusiveOrExpression", "logicalAndExpression", + "logicalOrExpression", "conditionalExpression", "assignmentExpression", + "assignmentOperator", "expression", "constantExpression", "statement", + "labeledStatement", "expressionStatement", "compoundStatement", "statementSeq", + "selectionStatement", "condition", "iterationStatement", "forInitStatement", + "forRangeDeclaration", "forRangeInitializer", "jumpStatement", "declarationStatement", + "declarationseq", "declaration", "blockDeclaration", "aliasDeclaration", + "simpleDeclaration", "staticAssertDeclaration", "emptyDeclaration", "attributeDeclaration", + "declSpecifier", "declSpecifierSeq", "storageClassSpecifier", "functionSpecifier", + "typedefName", "typeSpecifier", "trailingTypeSpecifier", "typeSpecifierSeq", + "trailingTypeSpecifierSeq", "simpleTypeSpecifier", "theTypeName", "decltypeSpecifier", + "elaboratedTypeSpecifier", "enumName", "enumSpecifier", "enumHead", "opaqueEnumDeclaration", + "enumkey", "enumbase", "enumeratorList", "enumeratorDefinition", "enumerator", + "namespaceName", "originalNamespaceName", "namespaceDefinition", "namespaceAlias", + "namespaceAliasDefinition", "qualifiednamespacespecifier", "usingDeclaration", + "usingDirective", "asmDefinition", "linkageSpecification", "attributeSpecifierSeq", + "attributeSpecifier", "alignmentspecifier", "attributeList", "attribute", + "attributeNamespace", "attributeArgumentClause", "balancedTokenSeq", + "balancedtoken", "initDeclaratorList", "initDeclarator", "declarator", + "pointerDeclarator", "noPointerDeclarator", "parametersAndQualifiers", + "trailingReturnType", "pointerOperator", "cvqualifierseq", "cvQualifier", + "refqualifier", "declaratorid", "theTypeId", "abstractDeclarator", "pointerAbstractDeclarator", + "noPointerAbstractDeclarator", "abstractPackDeclarator", "noPointerAbstractPackDeclarator", + "parameterDeclarationClause", "parameterDeclarationList", "parameterDeclaration", + "functionDefinition", "functionBody", "initializer", "braceOrEqualInitializer", + "initializerClause", "initializerList", "bracedInitList", "className", + "classSpecifier", "classHead", "classHeadName", "classVirtSpecifier", + "classKey", "memberSpecification", "memberdeclaration", "memberDeclaratorList", + "memberDeclarator", "virtualSpecifierSeq", "virtualSpecifier", "pureSpecifier", + "baseClause", "baseSpecifierList", "baseSpecifier", "classOrDeclType", + "baseTypeSpecifier", "accessSpecifier", "conversionFunctionId", "conversionTypeId", + "conversionDeclarator", "constructorInitializer", "memInitializerList", + "memInitializer", "meminitializerid", "operatorFunctionId", "literalOperatorId", + "templateDeclaration", "templateparameterList", "templateParameter", + "typeParameter", "simpleTemplateId", "templateId", "templateName", "templateArgumentList", + "templateArgument", "typeNameSpecifier", "explicitInstantiation", "explicitSpecialization", + "tryBlock", "functionTryBlock", "handlerSeq", "handler", "exceptionDeclaration", + "throwExpression", "exceptionSpecification", "dynamicExceptionSpecification", + "typeIdList", "noeExceptSpecification", "theOperator", "literal" + }; + } + public static final String[] ruleNames = makeRuleNames(); + + private static String[] makeLiteralNames() { + return new String[] { + null, null, null, null, null, null, null, null, null, null, "'alignas'", + "'alignof'", "'asm'", "'auto'", "'bool'", "'break'", "'case'", "'catch'", + "'char'", "'char16_t'", "'char32_t'", "'class'", "'const'", "'constexpr'", + "'const_cast'", "'continue'", "'decltype'", "'default'", "'delete'", + "'do'", "'double'", "'dynamic_cast'", "'else'", "'enum'", "'explicit'", + "'export'", "'extern'", "'false'", "'final'", "'float'", "'for'", "'friend'", + "'goto'", "'if'", "'inline'", "'int'", "'long'", "'mutable'", "'namespace'", + "'new'", "'noexcept'", "'nullptr'", "'operator'", "'override'", "'private'", + "'protected'", "'public'", "'register'", "'reinterpret_cast'", "'return'", + "'short'", "'signed'", "'sizeof'", "'static'", "'static_assert'", "'static_cast'", + "'struct'", "'switch'", "'template'", "'this'", "'thread_local'", "'throw'", + "'true'", "'try'", "'typedef'", "'typeid'", "'typename'", "'union'", + "'unsigned'", "'using'", "'virtual'", "'void'", "'volatile'", "'wchar_t'", + "'while'", "'('", "')'", "'['", "']'", "'{'", "'}'", "'+'", "'-'", "'*'", + "'/'", "'%'", "'^'", "'&'", "'|'", "'~'", null, "'='", "'<'", "'>'", + "'+='", "'-='", "'*='", "'/='", "'%='", "'^='", "'&='", "'|='", "'<<='", + "'>>='", "'=='", "'!='", "'<='", "'>='", null, null, "'++'", "'--'", + "','", "'->*'", "'->'", "'?'", "':'", "'::'", "';'", "'.'", "'.*'", "'...'" + }; + } + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static String[] makeSymbolicNames() { + return new String[] { + null, "IntegerLiteral", "CharacterLiteral", "FloatingLiteral", "StringLiteral", + "BooleanLiteral", "PointerLiteral", "UserDefinedLiteral", "MultiLineMacro", + "Directive", "Alignas", "Alignof", "Asm", "Auto", "Bool", "Break", "Case", + "Catch", "Char", "Char16", "Char32", "Class", "Const", "Constexpr", "Const_cast", + "Continue", "Decltype", "Default", "Delete", "Do", "Double", "Dynamic_cast", + "Else", "Enum", "Explicit", "Export", "Extern", "False_", "Final", "Float", + "For", "Friend", "Goto", "If", "Inline", "Int", "Long", "Mutable", "Namespace", + "New", "Noexcept", "Nullptr", "Operator", "Override", "Private", "Protected", + "Public", "Register", "Reinterpret_cast", "Return", "Short", "Signed", + "Sizeof", "Static", "Static_assert", "Static_cast", "Struct", "Switch", + "Template", "This", "Thread_local", "Throw", "True_", "Try", "Typedef", + "Typeid_", "Typename_", "Union", "Unsigned", "Using", "Virtual", "Void", + "Volatile", "Wchar", "While", "LeftParen", "RightParen", "LeftBracket", + "RightBracket", "LeftBrace", "RightBrace", "Plus", "Minus", "Star", "Div", + "Mod", "Caret", "And", "Or", "Tilde", "Not", "Assign", "Less", "Greater", + "PlusAssign", "MinusAssign", "StarAssign", "DivAssign", "ModAssign", + "XorAssign", "AndAssign", "OrAssign", "LeftShiftAssign", "RightShiftAssign", + "Equal", "NotEqual", "LessEqual", "GreaterEqual", "AndAnd", "OrOr", "PlusPlus", + "MinusMinus", "Comma", "ArrowStar", "Arrow", "Question", "Colon", "Doublecolon", + "Semi", "Dot", "DotStar", "Ellipsis", "Identifier", "DecimalLiteral", + "OctalLiteral", "HexadecimalLiteral", "BinaryLiteral", "Integersuffix", + "UserDefinedIntegerLiteral", "UserDefinedFloatingLiteral", "UserDefinedStringLiteral", + "UserDefinedCharacterLiteral", "Whitespace", "Newline", "BlockComment", + "LineComment" + }; + } + 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 "CPP14Parser.g4"; } + + @Override + public String[] getRuleNames() { return ruleNames; } + + @Override + public String getSerializedATN() { return _serializedATN; } + + @Override + public ATN getATN() { return _ATN; } + + public CPP14Parser(TokenStream input) { + super(input); + _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); + } + + public static class TranslationUnitContext extends ParserRuleContext { + public TerminalNode EOF() { return getToken(CPP14Parser.EOF, 0); } + public DeclarationseqContext declarationseq() { + return getRuleContext(DeclarationseqContext.class,0); + } + public TranslationUnitContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_translationUnit; } + } + + public final TranslationUnitContext translationUnit() throws RecognitionException { + TranslationUnitContext _localctx = new TranslationUnitContext(_ctx, getState()); + enterRule(_localctx, 0, RULE_translationUnit); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(379); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (Alignas - 10)) | (1L << (Asm - 10)) | (1L << (Auto - 10)) | (1L << (Bool - 10)) | (1L << (Char - 10)) | (1L << (Char16 - 10)) | (1L << (Char32 - 10)) | (1L << (Class - 10)) | (1L << (Const - 10)) | (1L << (Constexpr - 10)) | (1L << (Decltype - 10)) | (1L << (Double - 10)) | (1L << (Enum - 10)) | (1L << (Explicit - 10)) | (1L << (Extern - 10)) | (1L << (Float - 10)) | (1L << (Friend - 10)) | (1L << (Inline - 10)) | (1L << (Int - 10)) | (1L << (Long - 10)) | (1L << (Mutable - 10)) | (1L << (Namespace - 10)) | (1L << (Operator - 10)) | (1L << (Register - 10)) | (1L << (Short - 10)) | (1L << (Signed - 10)) | (1L << (Static - 10)) | (1L << (Static_assert - 10)) | (1L << (Struct - 10)) | (1L << (Template - 10)) | (1L << (Thread_local - 10)))) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (Typedef - 74)) | (1L << (Typename_ - 74)) | (1L << (Union - 74)) | (1L << (Unsigned - 74)) | (1L << (Using - 74)) | (1L << (Virtual - 74)) | (1L << (Void - 74)) | (1L << (Volatile - 74)) | (1L << (Wchar - 74)) | (1L << (LeftParen - 74)) | (1L << (LeftBracket - 74)) | (1L << (Star - 74)) | (1L << (And - 74)) | (1L << (Tilde - 74)) | (1L << (AndAnd - 74)) | (1L << (Doublecolon - 74)) | (1L << (Semi - 74)) | (1L << (Ellipsis - 74)) | (1L << (Identifier - 74)))) != 0)) { + { + setState(378); + declarationseq(); + } + } + + setState(381); + match(EOF); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PrimaryExpressionContext extends ParserRuleContext { + public List literal() { + return getRuleContexts(LiteralContext.class); + } + public LiteralContext literal(int i) { + return getRuleContext(LiteralContext.class,i); + } + public TerminalNode This() { return getToken(CPP14Parser.This, 0); } + public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); } + public IdExpressionContext idExpression() { + return getRuleContext(IdExpressionContext.class,0); + } + public LambdaExpressionContext lambdaExpression() { + return getRuleContext(LambdaExpressionContext.class,0); + } + public PrimaryExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_primaryExpression; } + } + + public final PrimaryExpressionContext primaryExpression() throws RecognitionException { + PrimaryExpressionContext _localctx = new PrimaryExpressionContext(_ctx, getState()); + enterRule(_localctx, 2, RULE_primaryExpression); + try { + int _alt; + setState(395); + _errHandler.sync(this); + switch (_input.LA(1)) { + case IntegerLiteral: + case CharacterLiteral: + case FloatingLiteral: + case StringLiteral: + case BooleanLiteral: + case PointerLiteral: + case UserDefinedLiteral: + enterOuterAlt(_localctx, 1); + { + setState(384); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(383); + literal(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(386); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,1,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + } + break; + case This: + enterOuterAlt(_localctx, 2); + { + setState(388); + match(This); + } + break; + case LeftParen: + enterOuterAlt(_localctx, 3); + { + setState(389); + match(LeftParen); + setState(390); + expression(); + setState(391); + match(RightParen); + } + break; + case Decltype: + case Operator: + case Tilde: + case Doublecolon: + case Identifier: + enterOuterAlt(_localctx, 4); + { + setState(393); + idExpression(); + } + break; + case LeftBracket: + enterOuterAlt(_localctx, 5); + { + setState(394); + lambdaExpression(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class IdExpressionContext extends ParserRuleContext { + public UnqualifiedIdContext unqualifiedId() { + return getRuleContext(UnqualifiedIdContext.class,0); + } + public QualifiedIdContext qualifiedId() { + return getRuleContext(QualifiedIdContext.class,0); + } + public IdExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_idExpression; } + } + + public final IdExpressionContext idExpression() throws RecognitionException { + IdExpressionContext _localctx = new IdExpressionContext(_ctx, getState()); + enterRule(_localctx, 4, RULE_idExpression); + try { + setState(399); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,3,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(397); + unqualifiedId(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(398); + qualifiedId(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UnqualifiedIdContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); } + public OperatorFunctionIdContext operatorFunctionId() { + return getRuleContext(OperatorFunctionIdContext.class,0); + } + public ConversionFunctionIdContext conversionFunctionId() { + return getRuleContext(ConversionFunctionIdContext.class,0); + } + public LiteralOperatorIdContext literalOperatorId() { + return getRuleContext(LiteralOperatorIdContext.class,0); + } + public TerminalNode Tilde() { return getToken(CPP14Parser.Tilde, 0); } + public ClassNameContext className() { + return getRuleContext(ClassNameContext.class,0); + } + public DecltypeSpecifierContext decltypeSpecifier() { + return getRuleContext(DecltypeSpecifierContext.class,0); + } + public TemplateIdContext templateId() { + return getRuleContext(TemplateIdContext.class,0); + } + public UnqualifiedIdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unqualifiedId; } + } + + public final UnqualifiedIdContext unqualifiedId() throws RecognitionException { + UnqualifiedIdContext _localctx = new UnqualifiedIdContext(_ctx, getState()); + enterRule(_localctx, 6, RULE_unqualifiedId); + try { + setState(411); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(401); + match(Identifier); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(402); + operatorFunctionId(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(403); + conversionFunctionId(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(404); + literalOperatorId(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(405); + match(Tilde); + setState(408); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Identifier: + { + setState(406); + className(); + } + break; + case Decltype: + { + setState(407); + decltypeSpecifier(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(410); + templateId(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class QualifiedIdContext extends ParserRuleContext { + public NestedNameSpecifierContext nestedNameSpecifier() { + return getRuleContext(NestedNameSpecifierContext.class,0); + } + public UnqualifiedIdContext unqualifiedId() { + return getRuleContext(UnqualifiedIdContext.class,0); + } + public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); } + public QualifiedIdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_qualifiedId; } + } + + public final QualifiedIdContext qualifiedId() throws RecognitionException { + QualifiedIdContext _localctx = new QualifiedIdContext(_ctx, getState()); + enterRule(_localctx, 8, RULE_qualifiedId); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(413); + nestedNameSpecifier(0); + setState(415); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Template) { + { + setState(414); + match(Template); + } + } + + setState(417); + unqualifiedId(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class NestedNameSpecifierContext extends ParserRuleContext { + public TerminalNode Doublecolon() { return getToken(CPP14Parser.Doublecolon, 0); } + public TheTypeNameContext theTypeName() { + return getRuleContext(TheTypeNameContext.class,0); + } + public NamespaceNameContext namespaceName() { + return getRuleContext(NamespaceNameContext.class,0); + } + public DecltypeSpecifierContext decltypeSpecifier() { + return getRuleContext(DecltypeSpecifierContext.class,0); + } + public NestedNameSpecifierContext nestedNameSpecifier() { + return getRuleContext(NestedNameSpecifierContext.class,0); + } + public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); } + public SimpleTemplateIdContext simpleTemplateId() { + return getRuleContext(SimpleTemplateIdContext.class,0); + } + public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); } + public NestedNameSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_nestedNameSpecifier; } + } + + public final NestedNameSpecifierContext nestedNameSpecifier() throws RecognitionException { + return nestedNameSpecifier(0); + } + + private NestedNameSpecifierContext nestedNameSpecifier(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + NestedNameSpecifierContext _localctx = new NestedNameSpecifierContext(_ctx, _parentState); + NestedNameSpecifierContext _prevctx = _localctx; + int _startState = 10; + enterRecursionRule(_localctx, 10, RULE_nestedNameSpecifier, _p); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(423); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,7,_ctx) ) { + case 1: + { + setState(420); + theTypeName(); + } + break; + case 2: + { + setState(421); + namespaceName(); + } + break; + case 3: + { + setState(422); + decltypeSpecifier(); + } + break; + } + setState(425); + match(Doublecolon); + } + _ctx.stop = _input.LT(-1); + setState(438); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,10,_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 NestedNameSpecifierContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_nestedNameSpecifier); + setState(427); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(433); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,9,_ctx) ) { + case 1: + { + setState(428); + match(Identifier); + } + break; + case 2: + { + setState(430); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Template) { + { + setState(429); + match(Template); + } + } + + setState(432); + simpleTemplateId(); + } + break; + } + setState(435); + match(Doublecolon); + } + } + } + setState(440); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,10,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class LambdaExpressionContext extends ParserRuleContext { + public LambdaIntroducerContext lambdaIntroducer() { + return getRuleContext(LambdaIntroducerContext.class,0); + } + public CompoundStatementContext compoundStatement() { + return getRuleContext(CompoundStatementContext.class,0); + } + public LambdaDeclaratorContext lambdaDeclarator() { + return getRuleContext(LambdaDeclaratorContext.class,0); + } + public LambdaExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_lambdaExpression; } + } + + public final LambdaExpressionContext lambdaExpression() throws RecognitionException { + LambdaExpressionContext _localctx = new LambdaExpressionContext(_ctx, getState()); + enterRule(_localctx, 12, RULE_lambdaExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(441); + lambdaIntroducer(); + setState(443); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LeftParen) { + { + setState(442); + lambdaDeclarator(); + } + } + + setState(445); + compoundStatement(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LambdaIntroducerContext extends ParserRuleContext { + public TerminalNode LeftBracket() { return getToken(CPP14Parser.LeftBracket, 0); } + public TerminalNode RightBracket() { return getToken(CPP14Parser.RightBracket, 0); } + public LambdaCaptureContext lambdaCapture() { + return getRuleContext(LambdaCaptureContext.class,0); + } + public LambdaIntroducerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_lambdaIntroducer; } + } + + public final LambdaIntroducerContext lambdaIntroducer() throws RecognitionException { + LambdaIntroducerContext _localctx = new LambdaIntroducerContext(_ctx, getState()); + enterRule(_localctx, 14, RULE_lambdaIntroducer); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(447); + match(LeftBracket); + setState(449); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 69)) & ~0x3f) == 0 && ((1L << (_la - 69)) & ((1L << (This - 69)) | (1L << (And - 69)) | (1L << (Assign - 69)) | (1L << (Identifier - 69)))) != 0)) { + { + setState(448); + lambdaCapture(); + } + } + + setState(451); + match(RightBracket); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LambdaCaptureContext extends ParserRuleContext { + public CaptureListContext captureList() { + return getRuleContext(CaptureListContext.class,0); + } + public CaptureDefaultContext captureDefault() { + return getRuleContext(CaptureDefaultContext.class,0); + } + public TerminalNode Comma() { return getToken(CPP14Parser.Comma, 0); } + public LambdaCaptureContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_lambdaCapture; } + } + + public final LambdaCaptureContext lambdaCapture() throws RecognitionException { + LambdaCaptureContext _localctx = new LambdaCaptureContext(_ctx, getState()); + enterRule(_localctx, 16, RULE_lambdaCapture); + int _la; + try { + setState(459); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(453); + captureList(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(454); + captureDefault(); + setState(457); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Comma) { + { + setState(455); + match(Comma); + setState(456); + captureList(); + } + } + + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class CaptureDefaultContext extends ParserRuleContext { + public TerminalNode And() { return getToken(CPP14Parser.And, 0); } + public TerminalNode Assign() { return getToken(CPP14Parser.Assign, 0); } + public CaptureDefaultContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_captureDefault; } + } + + public final CaptureDefaultContext captureDefault() throws RecognitionException { + CaptureDefaultContext _localctx = new CaptureDefaultContext(_ctx, getState()); + enterRule(_localctx, 18, RULE_captureDefault); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(461); + _la = _input.LA(1); + if ( !(_la==And || _la==Assign) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class CaptureListContext extends ParserRuleContext { + public List capture() { + return getRuleContexts(CaptureContext.class); + } + public CaptureContext capture(int i) { + return getRuleContext(CaptureContext.class,i); + } + public List Comma() { return getTokens(CPP14Parser.Comma); } + public TerminalNode Comma(int i) { + return getToken(CPP14Parser.Comma, i); + } + public TerminalNode Ellipsis() { return getToken(CPP14Parser.Ellipsis, 0); } + public CaptureListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_captureList; } + } + + public final CaptureListContext captureList() throws RecognitionException { + CaptureListContext _localctx = new CaptureListContext(_ctx, getState()); + enterRule(_localctx, 20, RULE_captureList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(463); + capture(); + setState(468); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(464); + match(Comma); + setState(465); + capture(); + } + } + setState(470); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(472); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Ellipsis) { + { + setState(471); + match(Ellipsis); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class CaptureContext extends ParserRuleContext { + public SimpleCaptureContext simpleCapture() { + return getRuleContext(SimpleCaptureContext.class,0); + } + public InitcaptureContext initcapture() { + return getRuleContext(InitcaptureContext.class,0); + } + public CaptureContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_capture; } + } + + public final CaptureContext capture() throws RecognitionException { + CaptureContext _localctx = new CaptureContext(_ctx, getState()); + enterRule(_localctx, 22, RULE_capture); + try { + setState(476); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(474); + simpleCapture(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(475); + initcapture(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SimpleCaptureContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); } + public TerminalNode And() { return getToken(CPP14Parser.And, 0); } + public TerminalNode This() { return getToken(CPP14Parser.This, 0); } + public SimpleCaptureContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_simpleCapture; } + } + + public final SimpleCaptureContext simpleCapture() throws RecognitionException { + SimpleCaptureContext _localctx = new SimpleCaptureContext(_ctx, getState()); + enterRule(_localctx, 24, RULE_simpleCapture); + int _la; + try { + setState(483); + _errHandler.sync(this); + switch (_input.LA(1)) { + case And: + case Identifier: + enterOuterAlt(_localctx, 1); + { + setState(479); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==And) { + { + setState(478); + match(And); + } + } + + setState(481); + match(Identifier); + } + break; + case This: + enterOuterAlt(_localctx, 2); + { + setState(482); + match(This); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InitcaptureContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); } + public InitializerContext initializer() { + return getRuleContext(InitializerContext.class,0); + } + public TerminalNode And() { return getToken(CPP14Parser.And, 0); } + public InitcaptureContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_initcapture; } + } + + public final InitcaptureContext initcapture() throws RecognitionException { + InitcaptureContext _localctx = new InitcaptureContext(_ctx, getState()); + enterRule(_localctx, 26, RULE_initcapture); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(486); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==And) { + { + setState(485); + match(And); + } + } + + setState(488); + match(Identifier); + setState(489); + initializer(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LambdaDeclaratorContext extends ParserRuleContext { + public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); } + public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); } + public ParameterDeclarationClauseContext parameterDeclarationClause() { + return getRuleContext(ParameterDeclarationClauseContext.class,0); + } + public TerminalNode Mutable() { return getToken(CPP14Parser.Mutable, 0); } + public ExceptionSpecificationContext exceptionSpecification() { + return getRuleContext(ExceptionSpecificationContext.class,0); + } + public AttributeSpecifierSeqContext attributeSpecifierSeq() { + return getRuleContext(AttributeSpecifierSeqContext.class,0); + } + public TrailingReturnTypeContext trailingReturnType() { + return getRuleContext(TrailingReturnTypeContext.class,0); + } + public LambdaDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_lambdaDeclarator; } + } + + public final LambdaDeclaratorContext lambdaDeclarator() throws RecognitionException { + LambdaDeclaratorContext _localctx = new LambdaDeclaratorContext(_ctx, getState()); + enterRule(_localctx, 28, RULE_lambdaDeclarator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(491); + match(LeftParen); + setState(493); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (Alignas - 10)) | (1L << (Auto - 10)) | (1L << (Bool - 10)) | (1L << (Char - 10)) | (1L << (Char16 - 10)) | (1L << (Char32 - 10)) | (1L << (Class - 10)) | (1L << (Const - 10)) | (1L << (Constexpr - 10)) | (1L << (Decltype - 10)) | (1L << (Double - 10)) | (1L << (Enum - 10)) | (1L << (Explicit - 10)) | (1L << (Extern - 10)) | (1L << (Float - 10)) | (1L << (Friend - 10)) | (1L << (Inline - 10)) | (1L << (Int - 10)) | (1L << (Long - 10)) | (1L << (Mutable - 10)) | (1L << (Register - 10)) | (1L << (Short - 10)) | (1L << (Signed - 10)) | (1L << (Static - 10)) | (1L << (Struct - 10)) | (1L << (Thread_local - 10)))) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (Typedef - 74)) | (1L << (Typename_ - 74)) | (1L << (Union - 74)) | (1L << (Unsigned - 74)) | (1L << (Virtual - 74)) | (1L << (Void - 74)) | (1L << (Volatile - 74)) | (1L << (Wchar - 74)) | (1L << (LeftBracket - 74)) | (1L << (Doublecolon - 74)) | (1L << (Identifier - 74)))) != 0)) { + { + setState(492); + parameterDeclarationClause(); + } + } + + setState(495); + match(RightParen); + setState(497); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Mutable) { + { + setState(496); + match(Mutable); + } + } + + setState(500); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Noexcept || _la==Throw) { + { + setState(499); + exceptionSpecification(); + } + } + + setState(503); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Alignas || _la==LeftBracket) { + { + setState(502); + attributeSpecifierSeq(); + } + } + + setState(506); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Arrow) { + { + setState(505); + trailingReturnType(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PostfixExpressionContext extends ParserRuleContext { + public PrimaryExpressionContext primaryExpression() { + return getRuleContext(PrimaryExpressionContext.class,0); + } + public SimpleTypeSpecifierContext simpleTypeSpecifier() { + return getRuleContext(SimpleTypeSpecifierContext.class,0); + } + public TypeNameSpecifierContext typeNameSpecifier() { + return getRuleContext(TypeNameSpecifierContext.class,0); + } + public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); } + public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); } + public BracedInitListContext bracedInitList() { + return getRuleContext(BracedInitListContext.class,0); + } + public ExpressionListContext expressionList() { + return getRuleContext(ExpressionListContext.class,0); + } + public TerminalNode Less() { return getToken(CPP14Parser.Less, 0); } + public TheTypeIdContext theTypeId() { + return getRuleContext(TheTypeIdContext.class,0); + } + public TerminalNode Greater() { return getToken(CPP14Parser.Greater, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode Dynamic_cast() { return getToken(CPP14Parser.Dynamic_cast, 0); } + public TerminalNode Static_cast() { return getToken(CPP14Parser.Static_cast, 0); } + public TerminalNode Reinterpret_cast() { return getToken(CPP14Parser.Reinterpret_cast, 0); } + public TerminalNode Const_cast() { return getToken(CPP14Parser.Const_cast, 0); } + public TypeIdOfTheTypeIdContext typeIdOfTheTypeId() { + return getRuleContext(TypeIdOfTheTypeIdContext.class,0); + } + public PostfixExpressionContext postfixExpression() { + return getRuleContext(PostfixExpressionContext.class,0); + } + public TerminalNode LeftBracket() { return getToken(CPP14Parser.LeftBracket, 0); } + public TerminalNode RightBracket() { return getToken(CPP14Parser.RightBracket, 0); } + public TerminalNode Dot() { return getToken(CPP14Parser.Dot, 0); } + public TerminalNode Arrow() { return getToken(CPP14Parser.Arrow, 0); } + public IdExpressionContext idExpression() { + return getRuleContext(IdExpressionContext.class,0); + } + public PseudoDestructorNameContext pseudoDestructorName() { + return getRuleContext(PseudoDestructorNameContext.class,0); + } + public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); } + public TerminalNode PlusPlus() { return getToken(CPP14Parser.PlusPlus, 0); } + public TerminalNode MinusMinus() { return getToken(CPP14Parser.MinusMinus, 0); } + public PostfixExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_postfixExpression; } + } + + public final PostfixExpressionContext postfixExpression() throws RecognitionException { + return postfixExpression(0); + } + + private PostfixExpressionContext postfixExpression(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + PostfixExpressionContext _localctx = new PostfixExpressionContext(_ctx, _parentState); + PostfixExpressionContext _prevctx = _localctx; + int _startState = 30; + enterRecursionRule(_localctx, 30, RULE_postfixExpression, _p); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(538); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) { + case 1: + { + setState(509); + primaryExpression(); + } + break; + case 2: + { + setState(512); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Auto: + case Bool: + case Char: + case Char16: + case Char32: + case Decltype: + case Double: + case Float: + case Int: + case Long: + case Short: + case Signed: + case Unsigned: + case Void: + case Wchar: + case Doublecolon: + case Identifier: + { + setState(510); + simpleTypeSpecifier(); + } + break; + case Typename_: + { + setState(511); + typeNameSpecifier(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(520); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LeftParen: + { + setState(514); + match(LeftParen); + setState(516); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (Static_cast - 65)) | (1L << (This - 65)) | (1L << (Throw - 65)) | (1L << (Typeid_ - 65)) | (1L << (Typename_ - 65)) | (1L << (Unsigned - 65)) | (1L << (Void - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (LeftBrace - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)))) != 0) || _la==Identifier) { + { + setState(515); + expressionList(); + } + } + + setState(518); + match(RightParen); + } + break; + case LeftBrace: + { + setState(519); + bracedInitList(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 3: + { + setState(522); + _la = _input.LA(1); + if ( !(((((_la - 24)) & ~0x3f) == 0 && ((1L << (_la - 24)) & ((1L << (Const_cast - 24)) | (1L << (Dynamic_cast - 24)) | (1L << (Reinterpret_cast - 24)) | (1L << (Static_cast - 24)))) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(523); + match(Less); + setState(524); + theTypeId(); + setState(525); + match(Greater); + setState(526); + match(LeftParen); + setState(527); + expression(); + setState(528); + match(RightParen); + } + break; + case 4: + { + setState(530); + typeIdOfTheTypeId(); + setState(531); + match(LeftParen); + setState(534); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,29,_ctx) ) { + case 1: + { + setState(532); + expression(); + } + break; + case 2: + { + setState(533); + theTypeId(); + } + break; + } + setState(536); + match(RightParen); + } + break; + } + _ctx.stop = _input.LT(-1); + setState(567); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,36,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + setState(565); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) { + case 1: + { + _localctx = new PostfixExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_postfixExpression); + setState(540); + if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)"); + setState(541); + match(LeftBracket); + setState(544); + _errHandler.sync(this); + switch (_input.LA(1)) { + case IntegerLiteral: + case CharacterLiteral: + case FloatingLiteral: + case StringLiteral: + case BooleanLiteral: + case PointerLiteral: + case UserDefinedLiteral: + case Alignof: + case Auto: + case Bool: + case Char: + case Char16: + case Char32: + case Const_cast: + case Decltype: + case Delete: + case Double: + case Dynamic_cast: + case Float: + case Int: + case Long: + case New: + case Noexcept: + case Operator: + case Reinterpret_cast: + case Short: + case Signed: + case Sizeof: + case Static_cast: + case This: + case Throw: + case Typeid_: + case Typename_: + case Unsigned: + case Void: + case Wchar: + case LeftParen: + case LeftBracket: + case Plus: + case Minus: + case Star: + case And: + case Or: + case Tilde: + case Not: + case PlusPlus: + case MinusMinus: + case Doublecolon: + case Identifier: + { + setState(542); + expression(); + } + break; + case LeftBrace: + { + setState(543); + bracedInitList(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(546); + match(RightBracket); + } + break; + case 2: + { + _localctx = new PostfixExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_postfixExpression); + setState(548); + if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)"); + setState(549); + match(LeftParen); + setState(551); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (Static_cast - 65)) | (1L << (This - 65)) | (1L << (Throw - 65)) | (1L << (Typeid_ - 65)) | (1L << (Typename_ - 65)) | (1L << (Unsigned - 65)) | (1L << (Void - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (LeftBrace - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)))) != 0) || _la==Identifier) { + { + setState(550); + expressionList(); + } + } + + setState(553); + match(RightParen); + } + break; + case 3: + { + _localctx = new PostfixExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_postfixExpression); + setState(554); + if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)"); + setState(555); + _la = _input.LA(1); + if ( !(_la==Arrow || _la==Dot) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(561); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,34,_ctx) ) { + case 1: + { + setState(557); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Template) { + { + setState(556); + match(Template); + } + } + + setState(559); + idExpression(); + } + break; + case 2: + { + setState(560); + pseudoDestructorName(); + } + break; + } + } + break; + case 4: + { + _localctx = new PostfixExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_postfixExpression); + setState(563); + if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)"); + setState(564); + _la = _input.LA(1); + if ( !(_la==PlusPlus || _la==MinusMinus) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + } + } + } + setState(569); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,36,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class TypeIdOfTheTypeIdContext extends ParserRuleContext { + public TerminalNode Typeid_() { return getToken(CPP14Parser.Typeid_, 0); } + public TypeIdOfTheTypeIdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeIdOfTheTypeId; } + } + + public final TypeIdOfTheTypeIdContext typeIdOfTheTypeId() throws RecognitionException { + TypeIdOfTheTypeIdContext _localctx = new TypeIdOfTheTypeIdContext(_ctx, getState()); + enterRule(_localctx, 32, RULE_typeIdOfTheTypeId); + try { + enterOuterAlt(_localctx, 1); + { + setState(570); + match(Typeid_); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ExpressionListContext extends ParserRuleContext { + public InitializerListContext initializerList() { + return getRuleContext(InitializerListContext.class,0); + } + public ExpressionListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expressionList; } + } + + public final ExpressionListContext expressionList() throws RecognitionException { + ExpressionListContext _localctx = new ExpressionListContext(_ctx, getState()); + enterRule(_localctx, 34, RULE_expressionList); + try { + enterOuterAlt(_localctx, 1); + { + setState(572); + initializerList(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PseudoDestructorNameContext extends ParserRuleContext { + public TerminalNode Tilde() { return getToken(CPP14Parser.Tilde, 0); } + public List theTypeName() { + return getRuleContexts(TheTypeNameContext.class); + } + public TheTypeNameContext theTypeName(int i) { + return getRuleContext(TheTypeNameContext.class,i); + } + public NestedNameSpecifierContext nestedNameSpecifier() { + return getRuleContext(NestedNameSpecifierContext.class,0); + } + public TerminalNode Doublecolon() { return getToken(CPP14Parser.Doublecolon, 0); } + public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); } + public SimpleTemplateIdContext simpleTemplateId() { + return getRuleContext(SimpleTemplateIdContext.class,0); + } + public DecltypeSpecifierContext decltypeSpecifier() { + return getRuleContext(DecltypeSpecifierContext.class,0); + } + public PseudoDestructorNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_pseudoDestructorName; } + } + + public final PseudoDestructorNameContext pseudoDestructorName() throws RecognitionException { + PseudoDestructorNameContext _localctx = new PseudoDestructorNameContext(_ctx, getState()); + enterRule(_localctx, 36, RULE_pseudoDestructorName); + int _la; + try { + setState(593); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,39,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(575); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) { + case 1: + { + setState(574); + nestedNameSpecifier(0); + } + break; + } + setState(580); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Identifier) { + { + setState(577); + theTypeName(); + setState(578); + match(Doublecolon); + } + } + + setState(582); + match(Tilde); + setState(583); + theTypeName(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(584); + nestedNameSpecifier(0); + setState(585); + match(Template); + setState(586); + simpleTemplateId(); + setState(587); + match(Doublecolon); + setState(588); + match(Tilde); + setState(589); + theTypeName(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(591); + match(Tilde); + setState(592); + decltypeSpecifier(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UnaryExpressionContext extends ParserRuleContext { + public PostfixExpressionContext postfixExpression() { + return getRuleContext(PostfixExpressionContext.class,0); + } + public UnaryExpressionContext unaryExpression() { + return getRuleContext(UnaryExpressionContext.class,0); + } + public TerminalNode PlusPlus() { return getToken(CPP14Parser.PlusPlus, 0); } + public TerminalNode MinusMinus() { return getToken(CPP14Parser.MinusMinus, 0); } + public UnaryOperatorContext unaryOperator() { + return getRuleContext(UnaryOperatorContext.class,0); + } + public TerminalNode Sizeof() { return getToken(CPP14Parser.Sizeof, 0); } + public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); } + public TheTypeIdContext theTypeId() { + return getRuleContext(TheTypeIdContext.class,0); + } + public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); } + public TerminalNode Ellipsis() { return getToken(CPP14Parser.Ellipsis, 0); } + public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); } + public TerminalNode Alignof() { return getToken(CPP14Parser.Alignof, 0); } + public NoExceptExpressionContext noExceptExpression() { + return getRuleContext(NoExceptExpressionContext.class,0); + } + public NewExpressionContext newExpression() { + return getRuleContext(NewExpressionContext.class,0); + } + public DeleteExpressionContext deleteExpression() { + return getRuleContext(DeleteExpressionContext.class,0); + } + public UnaryExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unaryExpression; } + } + + public final UnaryExpressionContext unaryExpression() throws RecognitionException { + UnaryExpressionContext _localctx = new UnaryExpressionContext(_ctx, getState()); + enterRule(_localctx, 38, RULE_unaryExpression); + try { + setState(622); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,42,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(595); + postfixExpression(0); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(600); + _errHandler.sync(this); + switch (_input.LA(1)) { + case PlusPlus: + { + setState(596); + match(PlusPlus); + } + break; + case MinusMinus: + { + setState(597); + match(MinusMinus); + } + break; + case Plus: + case Minus: + case Star: + case And: + case Or: + case Tilde: + case Not: + { + setState(598); + unaryOperator(); + } + break; + case Sizeof: + { + setState(599); + match(Sizeof); + } + break; + default: + throw new NoViableAltException(this); + } + setState(602); + unaryExpression(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(603); + match(Sizeof); + setState(612); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LeftParen: + { + setState(604); + match(LeftParen); + setState(605); + theTypeId(); + setState(606); + match(RightParen); + } + break; + case Ellipsis: + { + setState(608); + match(Ellipsis); + setState(609); + match(LeftParen); + setState(610); + match(Identifier); + setState(611); + match(RightParen); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(614); + match(Alignof); + setState(615); + match(LeftParen); + setState(616); + theTypeId(); + setState(617); + match(RightParen); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(619); + noExceptExpression(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(620); + newExpression(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(621); + deleteExpression(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UnaryOperatorContext extends ParserRuleContext { + public TerminalNode Or() { return getToken(CPP14Parser.Or, 0); } + public TerminalNode Star() { return getToken(CPP14Parser.Star, 0); } + public TerminalNode And() { return getToken(CPP14Parser.And, 0); } + public TerminalNode Plus() { return getToken(CPP14Parser.Plus, 0); } + public TerminalNode Tilde() { return getToken(CPP14Parser.Tilde, 0); } + public TerminalNode Minus() { return getToken(CPP14Parser.Minus, 0); } + public TerminalNode Not() { return getToken(CPP14Parser.Not, 0); } + public UnaryOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_unaryOperator; } + } + + public final UnaryOperatorContext unaryOperator() throws RecognitionException { + UnaryOperatorContext _localctx = new UnaryOperatorContext(_ctx, getState()); + enterRule(_localctx, 40, RULE_unaryOperator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(624); + _la = _input.LA(1); + if ( !(((((_la - 91)) & ~0x3f) == 0 && ((1L << (_la - 91)) & ((1L << (Plus - 91)) | (1L << (Minus - 91)) | (1L << (Star - 91)) | (1L << (And - 91)) | (1L << (Or - 91)) | (1L << (Tilde - 91)) | (1L << (Not - 91)))) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class NewExpressionContext extends ParserRuleContext { + public TerminalNode New() { return getToken(CPP14Parser.New, 0); } + public NewTypeIdContext newTypeId() { + return getRuleContext(NewTypeIdContext.class,0); + } + public TerminalNode Doublecolon() { return getToken(CPP14Parser.Doublecolon, 0); } + public NewPlacementContext newPlacement() { + return getRuleContext(NewPlacementContext.class,0); + } + public NewInitializerContext newInitializer() { + return getRuleContext(NewInitializerContext.class,0); + } + public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); } + public TheTypeIdContext theTypeId() { + return getRuleContext(TheTypeIdContext.class,0); + } + public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); } + public NewExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_newExpression; } + } + + public final NewExpressionContext newExpression() throws RecognitionException { + NewExpressionContext _localctx = new NewExpressionContext(_ctx, getState()); + enterRule(_localctx, 42, RULE_newExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(627); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Doublecolon) { + { + setState(626); + match(Doublecolon); + } + } + + setState(629); + match(New); + setState(631); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) { + case 1: + { + setState(630); + newPlacement(); + } + break; + } + setState(638); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Auto: + case Bool: + case Char: + case Char16: + case Char32: + case Class: + case Const: + case Decltype: + case Double: + case Enum: + case Float: + case Int: + case Long: + case Short: + case Signed: + case Struct: + case Typename_: + case Union: + case Unsigned: + case Void: + case Volatile: + case Wchar: + case Doublecolon: + case Identifier: + { + setState(633); + newTypeId(); + } + break; + case LeftParen: + { + { + setState(634); + match(LeftParen); + setState(635); + theTypeId(); + setState(636); + match(RightParen); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(641); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LeftParen || _la==LeftBrace) { + { + setState(640); + newInitializer(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class NewPlacementContext extends ParserRuleContext { + public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); } + public ExpressionListContext expressionList() { + return getRuleContext(ExpressionListContext.class,0); + } + public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); } + public NewPlacementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_newPlacement; } + } + + public final NewPlacementContext newPlacement() throws RecognitionException { + NewPlacementContext _localctx = new NewPlacementContext(_ctx, getState()); + enterRule(_localctx, 44, RULE_newPlacement); + try { + enterOuterAlt(_localctx, 1); + { + setState(643); + match(LeftParen); + setState(644); + expressionList(); + setState(645); + match(RightParen); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class NewTypeIdContext extends ParserRuleContext { + public TypeSpecifierSeqContext typeSpecifierSeq() { + return getRuleContext(TypeSpecifierSeqContext.class,0); + } + public NewDeclaratorContext newDeclarator() { + return getRuleContext(NewDeclaratorContext.class,0); + } + public NewTypeIdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_newTypeId; } + } + + public final NewTypeIdContext newTypeId() throws RecognitionException { + NewTypeIdContext _localctx = new NewTypeIdContext(_ctx, getState()); + enterRule(_localctx, 46, RULE_newTypeId); + try { + enterOuterAlt(_localctx, 1); + { + setState(647); + typeSpecifierSeq(); + setState(649); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,47,_ctx) ) { + case 1: + { + setState(648); + newDeclarator(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class NewDeclaratorContext extends ParserRuleContext { + public PointerOperatorContext pointerOperator() { + return getRuleContext(PointerOperatorContext.class,0); + } + public NewDeclaratorContext newDeclarator() { + return getRuleContext(NewDeclaratorContext.class,0); + } + public NoPointerNewDeclaratorContext noPointerNewDeclarator() { + return getRuleContext(NoPointerNewDeclaratorContext.class,0); + } + public NewDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_newDeclarator; } + } + + public final NewDeclaratorContext newDeclarator() throws RecognitionException { + NewDeclaratorContext _localctx = new NewDeclaratorContext(_ctx, getState()); + enterRule(_localctx, 48, RULE_newDeclarator); + try { + setState(656); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Decltype: + case Star: + case And: + case AndAnd: + case Doublecolon: + case Identifier: + enterOuterAlt(_localctx, 1); + { + setState(651); + pointerOperator(); + setState(653); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,48,_ctx) ) { + case 1: + { + setState(652); + newDeclarator(); + } + break; + } + } + break; + case LeftBracket: + enterOuterAlt(_localctx, 2); + { + setState(655); + noPointerNewDeclarator(0); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class NoPointerNewDeclaratorContext extends ParserRuleContext { + public TerminalNode LeftBracket() { return getToken(CPP14Parser.LeftBracket, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode RightBracket() { return getToken(CPP14Parser.RightBracket, 0); } + public AttributeSpecifierSeqContext attributeSpecifierSeq() { + return getRuleContext(AttributeSpecifierSeqContext.class,0); + } + public NoPointerNewDeclaratorContext noPointerNewDeclarator() { + return getRuleContext(NoPointerNewDeclaratorContext.class,0); + } + public ConstantExpressionContext constantExpression() { + return getRuleContext(ConstantExpressionContext.class,0); + } + public NoPointerNewDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_noPointerNewDeclarator; } + } + + public final NoPointerNewDeclaratorContext noPointerNewDeclarator() throws RecognitionException { + return noPointerNewDeclarator(0); + } + + private NoPointerNewDeclaratorContext noPointerNewDeclarator(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + NoPointerNewDeclaratorContext _localctx = new NoPointerNewDeclaratorContext(_ctx, _parentState); + NoPointerNewDeclaratorContext _prevctx = _localctx; + int _startState = 50; + enterRecursionRule(_localctx, 50, RULE_noPointerNewDeclarator, _p); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(659); + match(LeftBracket); + setState(660); + expression(); + setState(661); + match(RightBracket); + setState(663); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,50,_ctx) ) { + case 1: + { + setState(662); + attributeSpecifierSeq(); + } + break; + } + } + _ctx.stop = _input.LT(-1); + setState(674); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,52,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + { + _localctx = new NoPointerNewDeclaratorContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_noPointerNewDeclarator); + setState(665); + if (!(precpred(_ctx, 1))) throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(666); + match(LeftBracket); + setState(667); + constantExpression(); + setState(668); + match(RightBracket); + setState(670); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,51,_ctx) ) { + case 1: + { + setState(669); + attributeSpecifierSeq(); + } + break; + } + } + } + } + setState(676); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,52,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class NewInitializerContext extends ParserRuleContext { + public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); } + public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); } + public ExpressionListContext expressionList() { + return getRuleContext(ExpressionListContext.class,0); + } + public BracedInitListContext bracedInitList() { + return getRuleContext(BracedInitListContext.class,0); + } + public NewInitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_newInitializer; } + } + + public final NewInitializerContext newInitializer() throws RecognitionException { + NewInitializerContext _localctx = new NewInitializerContext(_ctx, getState()); + enterRule(_localctx, 52, RULE_newInitializer); + int _la; + try { + setState(683); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LeftParen: + enterOuterAlt(_localctx, 1); + { + setState(677); + match(LeftParen); + setState(679); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (Static_cast - 65)) | (1L << (This - 65)) | (1L << (Throw - 65)) | (1L << (Typeid_ - 65)) | (1L << (Typename_ - 65)) | (1L << (Unsigned - 65)) | (1L << (Void - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (LeftBrace - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)))) != 0) || _la==Identifier) { + { + setState(678); + expressionList(); + } + } + + setState(681); + match(RightParen); + } + break; + case LeftBrace: + enterOuterAlt(_localctx, 2); + { + setState(682); + bracedInitList(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class DeleteExpressionContext extends ParserRuleContext { + public TerminalNode Delete() { return getToken(CPP14Parser.Delete, 0); } + public CastExpressionContext castExpression() { + return getRuleContext(CastExpressionContext.class,0); + } + public TerminalNode Doublecolon() { return getToken(CPP14Parser.Doublecolon, 0); } + public TerminalNode LeftBracket() { return getToken(CPP14Parser.LeftBracket, 0); } + public TerminalNode RightBracket() { return getToken(CPP14Parser.RightBracket, 0); } + public DeleteExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_deleteExpression; } + } + + public final DeleteExpressionContext deleteExpression() throws RecognitionException { + DeleteExpressionContext _localctx = new DeleteExpressionContext(_ctx, getState()); + enterRule(_localctx, 54, RULE_deleteExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(686); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Doublecolon) { + { + setState(685); + match(Doublecolon); + } + } + + setState(688); + match(Delete); + setState(691); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,56,_ctx) ) { + case 1: + { + setState(689); + match(LeftBracket); + setState(690); + match(RightBracket); + } + break; + } + setState(693); + castExpression(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class NoExceptExpressionContext extends ParserRuleContext { + public TerminalNode Noexcept() { return getToken(CPP14Parser.Noexcept, 0); } + public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); } + public NoExceptExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_noExceptExpression; } + } + + public final NoExceptExpressionContext noExceptExpression() throws RecognitionException { + NoExceptExpressionContext _localctx = new NoExceptExpressionContext(_ctx, getState()); + enterRule(_localctx, 56, RULE_noExceptExpression); + try { + enterOuterAlt(_localctx, 1); + { + setState(695); + match(Noexcept); + setState(696); + match(LeftParen); + setState(697); + expression(); + setState(698); + match(RightParen); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class CastExpressionContext extends ParserRuleContext { + public UnaryExpressionContext unaryExpression() { + return getRuleContext(UnaryExpressionContext.class,0); + } + public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); } + public TheTypeIdContext theTypeId() { + return getRuleContext(TheTypeIdContext.class,0); + } + public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); } + public CastExpressionContext castExpression() { + return getRuleContext(CastExpressionContext.class,0); + } + public CastExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_castExpression; } + } + + public final CastExpressionContext castExpression() throws RecognitionException { + CastExpressionContext _localctx = new CastExpressionContext(_ctx, getState()); + enterRule(_localctx, 58, RULE_castExpression); + try { + setState(706); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(700); + unaryExpression(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(701); + match(LeftParen); + setState(702); + theTypeId(); + setState(703); + match(RightParen); + setState(704); + castExpression(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PointerMemberExpressionContext extends ParserRuleContext { + public List castExpression() { + return getRuleContexts(CastExpressionContext.class); + } + public CastExpressionContext castExpression(int i) { + return getRuleContext(CastExpressionContext.class,i); + } + public List DotStar() { return getTokens(CPP14Parser.DotStar); } + public TerminalNode DotStar(int i) { + return getToken(CPP14Parser.DotStar, i); + } + public List ArrowStar() { return getTokens(CPP14Parser.ArrowStar); } + public TerminalNode ArrowStar(int i) { + return getToken(CPP14Parser.ArrowStar, i); + } + public PointerMemberExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_pointerMemberExpression; } + } + + public final PointerMemberExpressionContext pointerMemberExpression() throws RecognitionException { + PointerMemberExpressionContext _localctx = new PointerMemberExpressionContext(_ctx, getState()); + enterRule(_localctx, 60, RULE_pointerMemberExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(708); + castExpression(); + setState(713); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==ArrowStar || _la==DotStar) { + { + { + setState(709); + _la = _input.LA(1); + if ( !(_la==ArrowStar || _la==DotStar) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(710); + castExpression(); + } + } + setState(715); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MultiplicativeExpressionContext extends ParserRuleContext { + public List pointerMemberExpression() { + return getRuleContexts(PointerMemberExpressionContext.class); + } + public PointerMemberExpressionContext pointerMemberExpression(int i) { + return getRuleContext(PointerMemberExpressionContext.class,i); + } + public List Star() { return getTokens(CPP14Parser.Star); } + public TerminalNode Star(int i) { + return getToken(CPP14Parser.Star, i); + } + public List Div() { return getTokens(CPP14Parser.Div); } + public TerminalNode Div(int i) { + return getToken(CPP14Parser.Div, i); + } + public List Mod() { return getTokens(CPP14Parser.Mod); } + public TerminalNode Mod(int i) { + return getToken(CPP14Parser.Mod, i); + } + public MultiplicativeExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_multiplicativeExpression; } + } + + public final MultiplicativeExpressionContext multiplicativeExpression() throws RecognitionException { + MultiplicativeExpressionContext _localctx = new MultiplicativeExpressionContext(_ctx, getState()); + enterRule(_localctx, 62, RULE_multiplicativeExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(716); + pointerMemberExpression(); + setState(721); + _errHandler.sync(this); + _la = _input.LA(1); + while (((((_la - 93)) & ~0x3f) == 0 && ((1L << (_la - 93)) & ((1L << (Star - 93)) | (1L << (Div - 93)) | (1L << (Mod - 93)))) != 0)) { + { + { + setState(717); + _la = _input.LA(1); + if ( !(((((_la - 93)) & ~0x3f) == 0 && ((1L << (_la - 93)) & ((1L << (Star - 93)) | (1L << (Div - 93)) | (1L << (Mod - 93)))) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(718); + pointerMemberExpression(); + } + } + setState(723); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AdditiveExpressionContext extends ParserRuleContext { + public List multiplicativeExpression() { + return getRuleContexts(MultiplicativeExpressionContext.class); + } + public MultiplicativeExpressionContext multiplicativeExpression(int i) { + return getRuleContext(MultiplicativeExpressionContext.class,i); + } + public List Plus() { return getTokens(CPP14Parser.Plus); } + public TerminalNode Plus(int i) { + return getToken(CPP14Parser.Plus, i); + } + public List Minus() { return getTokens(CPP14Parser.Minus); } + public TerminalNode Minus(int i) { + return getToken(CPP14Parser.Minus, i); + } + public AdditiveExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_additiveExpression; } + } + + public final AdditiveExpressionContext additiveExpression() throws RecognitionException { + AdditiveExpressionContext _localctx = new AdditiveExpressionContext(_ctx, getState()); + enterRule(_localctx, 64, RULE_additiveExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(724); + multiplicativeExpression(); + setState(729); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Plus || _la==Minus) { + { + { + setState(725); + _la = _input.LA(1); + if ( !(_la==Plus || _la==Minus) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(726); + multiplicativeExpression(); + } + } + setState(731); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ShiftExpressionContext extends ParserRuleContext { + public List additiveExpression() { + return getRuleContexts(AdditiveExpressionContext.class); + } + public AdditiveExpressionContext additiveExpression(int i) { + return getRuleContext(AdditiveExpressionContext.class,i); + } + public List shiftOperator() { + return getRuleContexts(ShiftOperatorContext.class); + } + public ShiftOperatorContext shiftOperator(int i) { + return getRuleContext(ShiftOperatorContext.class,i); + } + public ShiftExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_shiftExpression; } + } + + public final ShiftExpressionContext shiftExpression() throws RecognitionException { + ShiftExpressionContext _localctx = new ShiftExpressionContext(_ctx, getState()); + enterRule(_localctx, 66, RULE_shiftExpression); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(732); + additiveExpression(); + setState(738); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,61,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(733); + shiftOperator(); + setState(734); + additiveExpression(); + } + } + } + setState(740); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,61,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ShiftOperatorContext extends ParserRuleContext { + public List Greater() { return getTokens(CPP14Parser.Greater); } + public TerminalNode Greater(int i) { + return getToken(CPP14Parser.Greater, i); + } + public List Less() { return getTokens(CPP14Parser.Less); } + public TerminalNode Less(int i) { + return getToken(CPP14Parser.Less, i); + } + public ShiftOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_shiftOperator; } + } + + public final ShiftOperatorContext shiftOperator() throws RecognitionException { + ShiftOperatorContext _localctx = new ShiftOperatorContext(_ctx, getState()); + enterRule(_localctx, 68, RULE_shiftOperator); + try { + setState(745); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Greater: + enterOuterAlt(_localctx, 1); + { + setState(741); + match(Greater); + setState(742); + match(Greater); + } + break; + case Less: + enterOuterAlt(_localctx, 2); + { + setState(743); + match(Less); + setState(744); + match(Less); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class RelationalExpressionContext extends ParserRuleContext { + public List shiftExpression() { + return getRuleContexts(ShiftExpressionContext.class); + } + public ShiftExpressionContext shiftExpression(int i) { + return getRuleContext(ShiftExpressionContext.class,i); + } + public List Less() { return getTokens(CPP14Parser.Less); } + public TerminalNode Less(int i) { + return getToken(CPP14Parser.Less, i); + } + public List Greater() { return getTokens(CPP14Parser.Greater); } + public TerminalNode Greater(int i) { + return getToken(CPP14Parser.Greater, i); + } + public List LessEqual() { return getTokens(CPP14Parser.LessEqual); } + public TerminalNode LessEqual(int i) { + return getToken(CPP14Parser.LessEqual, i); + } + public List GreaterEqual() { return getTokens(CPP14Parser.GreaterEqual); } + public TerminalNode GreaterEqual(int i) { + return getToken(CPP14Parser.GreaterEqual, i); + } + public RelationalExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_relationalExpression; } + } + + public final RelationalExpressionContext relationalExpression() throws RecognitionException { + RelationalExpressionContext _localctx = new RelationalExpressionContext(_ctx, getState()); + enterRule(_localctx, 70, RULE_relationalExpression); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(747); + shiftExpression(); + setState(752); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,63,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(748); + _la = _input.LA(1); + if ( !(((((_la - 102)) & ~0x3f) == 0 && ((1L << (_la - 102)) & ((1L << (Less - 102)) | (1L << (Greater - 102)) | (1L << (LessEqual - 102)) | (1L << (GreaterEqual - 102)))) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(749); + shiftExpression(); + } + } + } + setState(754); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,63,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EqualityExpressionContext extends ParserRuleContext { + public List relationalExpression() { + return getRuleContexts(RelationalExpressionContext.class); + } + public RelationalExpressionContext relationalExpression(int i) { + return getRuleContext(RelationalExpressionContext.class,i); + } + public List Equal() { return getTokens(CPP14Parser.Equal); } + public TerminalNode Equal(int i) { + return getToken(CPP14Parser.Equal, i); + } + public List NotEqual() { return getTokens(CPP14Parser.NotEqual); } + public TerminalNode NotEqual(int i) { + return getToken(CPP14Parser.NotEqual, i); + } + public EqualityExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_equalityExpression; } + } + + public final EqualityExpressionContext equalityExpression() throws RecognitionException { + EqualityExpressionContext _localctx = new EqualityExpressionContext(_ctx, getState()); + enterRule(_localctx, 72, RULE_equalityExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(755); + relationalExpression(); + setState(760); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Equal || _la==NotEqual) { + { + { + setState(756); + _la = _input.LA(1); + if ( !(_la==Equal || _la==NotEqual) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(757); + relationalExpression(); + } + } + setState(762); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AndExpressionContext extends ParserRuleContext { + public List equalityExpression() { + return getRuleContexts(EqualityExpressionContext.class); + } + public EqualityExpressionContext equalityExpression(int i) { + return getRuleContext(EqualityExpressionContext.class,i); + } + public List And() { return getTokens(CPP14Parser.And); } + public TerminalNode And(int i) { + return getToken(CPP14Parser.And, i); + } + public AndExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_andExpression; } + } + + public final AndExpressionContext andExpression() throws RecognitionException { + AndExpressionContext _localctx = new AndExpressionContext(_ctx, getState()); + enterRule(_localctx, 74, RULE_andExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(763); + equalityExpression(); + setState(768); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==And) { + { + { + setState(764); + match(And); + setState(765); + equalityExpression(); + } + } + setState(770); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ExclusiveOrExpressionContext extends ParserRuleContext { + public List andExpression() { + return getRuleContexts(AndExpressionContext.class); + } + public AndExpressionContext andExpression(int i) { + return getRuleContext(AndExpressionContext.class,i); + } + public List Caret() { return getTokens(CPP14Parser.Caret); } + public TerminalNode Caret(int i) { + return getToken(CPP14Parser.Caret, i); + } + public ExclusiveOrExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_exclusiveOrExpression; } + } + + public final ExclusiveOrExpressionContext exclusiveOrExpression() throws RecognitionException { + ExclusiveOrExpressionContext _localctx = new ExclusiveOrExpressionContext(_ctx, getState()); + enterRule(_localctx, 76, RULE_exclusiveOrExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(771); + andExpression(); + setState(776); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Caret) { + { + { + setState(772); + match(Caret); + setState(773); + andExpression(); + } + } + setState(778); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InclusiveOrExpressionContext extends ParserRuleContext { + public List exclusiveOrExpression() { + return getRuleContexts(ExclusiveOrExpressionContext.class); + } + public ExclusiveOrExpressionContext exclusiveOrExpression(int i) { + return getRuleContext(ExclusiveOrExpressionContext.class,i); + } + public List Or() { return getTokens(CPP14Parser.Or); } + public TerminalNode Or(int i) { + return getToken(CPP14Parser.Or, i); + } + public InclusiveOrExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_inclusiveOrExpression; } + } + + public final InclusiveOrExpressionContext inclusiveOrExpression() throws RecognitionException { + InclusiveOrExpressionContext _localctx = new InclusiveOrExpressionContext(_ctx, getState()); + enterRule(_localctx, 78, RULE_inclusiveOrExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(779); + exclusiveOrExpression(); + setState(784); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Or) { + { + { + setState(780); + match(Or); + setState(781); + exclusiveOrExpression(); + } + } + setState(786); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LogicalAndExpressionContext extends ParserRuleContext { + public List inclusiveOrExpression() { + return getRuleContexts(InclusiveOrExpressionContext.class); + } + public InclusiveOrExpressionContext inclusiveOrExpression(int i) { + return getRuleContext(InclusiveOrExpressionContext.class,i); + } + public List AndAnd() { return getTokens(CPP14Parser.AndAnd); } + public TerminalNode AndAnd(int i) { + return getToken(CPP14Parser.AndAnd, i); + } + public LogicalAndExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_logicalAndExpression; } + } + + public final LogicalAndExpressionContext logicalAndExpression() throws RecognitionException { + LogicalAndExpressionContext _localctx = new LogicalAndExpressionContext(_ctx, getState()); + enterRule(_localctx, 80, RULE_logicalAndExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(787); + inclusiveOrExpression(); + setState(792); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AndAnd) { + { + { + setState(788); + match(AndAnd); + setState(789); + inclusiveOrExpression(); + } + } + setState(794); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LogicalOrExpressionContext extends ParserRuleContext { + public List logicalAndExpression() { + return getRuleContexts(LogicalAndExpressionContext.class); + } + public LogicalAndExpressionContext logicalAndExpression(int i) { + return getRuleContext(LogicalAndExpressionContext.class,i); + } + public List OrOr() { return getTokens(CPP14Parser.OrOr); } + public TerminalNode OrOr(int i) { + return getToken(CPP14Parser.OrOr, i); + } + public LogicalOrExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_logicalOrExpression; } + } + + public final LogicalOrExpressionContext logicalOrExpression() throws RecognitionException { + LogicalOrExpressionContext _localctx = new LogicalOrExpressionContext(_ctx, getState()); + enterRule(_localctx, 82, RULE_logicalOrExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(795); + logicalAndExpression(); + setState(800); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==OrOr) { + { + { + setState(796); + match(OrOr); + setState(797); + logicalAndExpression(); + } + } + setState(802); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ConditionalExpressionContext extends ParserRuleContext { + public LogicalOrExpressionContext logicalOrExpression() { + return getRuleContext(LogicalOrExpressionContext.class,0); + } + public TerminalNode Question() { return getToken(CPP14Parser.Question, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode Colon() { return getToken(CPP14Parser.Colon, 0); } + public AssignmentExpressionContext assignmentExpression() { + return getRuleContext(AssignmentExpressionContext.class,0); + } + public ConditionalExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_conditionalExpression; } + } + + public final ConditionalExpressionContext conditionalExpression() throws RecognitionException { + ConditionalExpressionContext _localctx = new ConditionalExpressionContext(_ctx, getState()); + enterRule(_localctx, 84, RULE_conditionalExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(803); + logicalOrExpression(); + setState(809); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Question) { + { + setState(804); + match(Question); + setState(805); + expression(); + setState(806); + match(Colon); + setState(807); + assignmentExpression(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AssignmentExpressionContext extends ParserRuleContext { + public ConditionalExpressionContext conditionalExpression() { + return getRuleContext(ConditionalExpressionContext.class,0); + } + public LogicalOrExpressionContext logicalOrExpression() { + return getRuleContext(LogicalOrExpressionContext.class,0); + } + public AssignmentOperatorContext assignmentOperator() { + return getRuleContext(AssignmentOperatorContext.class,0); + } + public InitializerClauseContext initializerClause() { + return getRuleContext(InitializerClauseContext.class,0); + } + public ThrowExpressionContext throwExpression() { + return getRuleContext(ThrowExpressionContext.class,0); + } + public AssignmentExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assignmentExpression; } + } + + public final AssignmentExpressionContext assignmentExpression() throws RecognitionException { + AssignmentExpressionContext _localctx = new AssignmentExpressionContext(_ctx, getState()); + enterRule(_localctx, 86, RULE_assignmentExpression); + try { + setState(817); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,71,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(811); + conditionalExpression(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(812); + logicalOrExpression(); + setState(813); + assignmentOperator(); + setState(814); + initializerClause(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(816); + throwExpression(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AssignmentOperatorContext extends ParserRuleContext { + public TerminalNode Assign() { return getToken(CPP14Parser.Assign, 0); } + public TerminalNode StarAssign() { return getToken(CPP14Parser.StarAssign, 0); } + public TerminalNode DivAssign() { return getToken(CPP14Parser.DivAssign, 0); } + public TerminalNode ModAssign() { return getToken(CPP14Parser.ModAssign, 0); } + public TerminalNode PlusAssign() { return getToken(CPP14Parser.PlusAssign, 0); } + public TerminalNode MinusAssign() { return getToken(CPP14Parser.MinusAssign, 0); } + public TerminalNode RightShiftAssign() { return getToken(CPP14Parser.RightShiftAssign, 0); } + public TerminalNode LeftShiftAssign() { return getToken(CPP14Parser.LeftShiftAssign, 0); } + public TerminalNode AndAssign() { return getToken(CPP14Parser.AndAssign, 0); } + public TerminalNode XorAssign() { return getToken(CPP14Parser.XorAssign, 0); } + public TerminalNode OrAssign() { return getToken(CPP14Parser.OrAssign, 0); } + public AssignmentOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_assignmentOperator; } + } + + public final AssignmentOperatorContext assignmentOperator() throws RecognitionException { + AssignmentOperatorContext _localctx = new AssignmentOperatorContext(_ctx, getState()); + enterRule(_localctx, 88, RULE_assignmentOperator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(819); + _la = _input.LA(1); + if ( !(((((_la - 101)) & ~0x3f) == 0 && ((1L << (_la - 101)) & ((1L << (Assign - 101)) | (1L << (PlusAssign - 101)) | (1L << (MinusAssign - 101)) | (1L << (StarAssign - 101)) | (1L << (DivAssign - 101)) | (1L << (ModAssign - 101)) | (1L << (XorAssign - 101)) | (1L << (AndAssign - 101)) | (1L << (OrAssign - 101)) | (1L << (LeftShiftAssign - 101)) | (1L << (RightShiftAssign - 101)))) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ExpressionContext extends ParserRuleContext { + public List assignmentExpression() { + return getRuleContexts(AssignmentExpressionContext.class); + } + public AssignmentExpressionContext assignmentExpression(int i) { + return getRuleContext(AssignmentExpressionContext.class,i); + } + public List Comma() { return getTokens(CPP14Parser.Comma); } + public TerminalNode Comma(int i) { + return getToken(CPP14Parser.Comma, i); + } + public ExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expression; } + } + + public final ExpressionContext expression() throws RecognitionException { + ExpressionContext _localctx = new ExpressionContext(_ctx, getState()); + enterRule(_localctx, 90, RULE_expression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(821); + assignmentExpression(); + setState(826); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(822); + match(Comma); + setState(823); + assignmentExpression(); + } + } + setState(828); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ConstantExpressionContext extends ParserRuleContext { + public ConditionalExpressionContext conditionalExpression() { + return getRuleContext(ConditionalExpressionContext.class,0); + } + public ConstantExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constantExpression; } + } + + public final ConstantExpressionContext constantExpression() throws RecognitionException { + ConstantExpressionContext _localctx = new ConstantExpressionContext(_ctx, getState()); + enterRule(_localctx, 92, RULE_constantExpression); + try { + enterOuterAlt(_localctx, 1); + { + setState(829); + conditionalExpression(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class StatementContext extends ParserRuleContext { + public LabeledStatementContext labeledStatement() { + return getRuleContext(LabeledStatementContext.class,0); + } + public ExpressionStatementContext expressionStatement() { + return getRuleContext(ExpressionStatementContext.class,0); + } + public CompoundStatementContext compoundStatement() { + return getRuleContext(CompoundStatementContext.class,0); + } + public SelectionStatementContext selectionStatement() { + return getRuleContext(SelectionStatementContext.class,0); + } + public IterationStatementContext iterationStatement() { + return getRuleContext(IterationStatementContext.class,0); + } + public JumpStatementContext jumpStatement() { + return getRuleContext(JumpStatementContext.class,0); + } + public TryBlockContext tryBlock() { + return getRuleContext(TryBlockContext.class,0); + } + public AttributeSpecifierSeqContext attributeSpecifierSeq() { + return getRuleContext(AttributeSpecifierSeqContext.class,0); + } + public DeclarationStatementContext declarationStatement() { + return getRuleContext(DeclarationStatementContext.class,0); + } + public StatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_statement; } + } + + public final StatementContext statement() throws RecognitionException { + StatementContext _localctx = new StatementContext(_ctx, getState()); + enterRule(_localctx, 94, RULE_statement); + try { + setState(844); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(831); + labeledStatement(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(833); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,73,_ctx) ) { + case 1: + { + setState(832); + attributeSpecifierSeq(); + } + break; + } + setState(841); + _errHandler.sync(this); + switch (_input.LA(1)) { + case IntegerLiteral: + case CharacterLiteral: + case FloatingLiteral: + case StringLiteral: + case BooleanLiteral: + case PointerLiteral: + case UserDefinedLiteral: + case Alignof: + case Auto: + case Bool: + case Char: + case Char16: + case Char32: + case Const_cast: + case Decltype: + case Delete: + case Double: + case Dynamic_cast: + case Float: + case Int: + case Long: + case New: + case Noexcept: + case Operator: + case Reinterpret_cast: + case Short: + case Signed: + case Sizeof: + case Static_cast: + case This: + case Throw: + case Typeid_: + case Typename_: + case Unsigned: + case Void: + case Wchar: + case LeftParen: + case LeftBracket: + case Plus: + case Minus: + case Star: + case And: + case Or: + case Tilde: + case Not: + case PlusPlus: + case MinusMinus: + case Doublecolon: + case Semi: + case Identifier: + { + setState(835); + expressionStatement(); + } + break; + case LeftBrace: + { + setState(836); + compoundStatement(); + } + break; + case If: + case Switch: + { + setState(837); + selectionStatement(); + } + break; + case Do: + case For: + case While: + { + setState(838); + iterationStatement(); + } + break; + case Break: + case Continue: + case Goto: + case Return: + { + setState(839); + jumpStatement(); + } + break; + case Try: + { + setState(840); + tryBlock(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(843); + declarationStatement(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LabeledStatementContext extends ParserRuleContext { + public TerminalNode Colon() { return getToken(CPP14Parser.Colon, 0); } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); } + public TerminalNode Case() { return getToken(CPP14Parser.Case, 0); } + public ConstantExpressionContext constantExpression() { + return getRuleContext(ConstantExpressionContext.class,0); + } + public TerminalNode Default() { return getToken(CPP14Parser.Default, 0); } + public AttributeSpecifierSeqContext attributeSpecifierSeq() { + return getRuleContext(AttributeSpecifierSeqContext.class,0); + } + public LabeledStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_labeledStatement; } + } + + public final LabeledStatementContext labeledStatement() throws RecognitionException { + LabeledStatementContext _localctx = new LabeledStatementContext(_ctx, getState()); + enterRule(_localctx, 96, RULE_labeledStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(847); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Alignas || _la==LeftBracket) { + { + setState(846); + attributeSpecifierSeq(); + } + } + + setState(853); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Identifier: + { + setState(849); + match(Identifier); + } + break; + case Case: + { + setState(850); + match(Case); + setState(851); + constantExpression(); + } + break; + case Default: + { + setState(852); + match(Default); + } + break; + default: + throw new NoViableAltException(this); + } + setState(855); + match(Colon); + setState(856); + statement(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ExpressionStatementContext extends ParserRuleContext { + public TerminalNode Semi() { return getToken(CPP14Parser.Semi, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ExpressionStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expressionStatement; } + } + + public final ExpressionStatementContext expressionStatement() throws RecognitionException { + ExpressionStatementContext _localctx = new ExpressionStatementContext(_ctx, getState()); + enterRule(_localctx, 98, RULE_expressionStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(859); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (Static_cast - 65)) | (1L << (This - 65)) | (1L << (Throw - 65)) | (1L << (Typeid_ - 65)) | (1L << (Typename_ - 65)) | (1L << (Unsigned - 65)) | (1L << (Void - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)))) != 0) || _la==Identifier) { + { + setState(858); + expression(); + } + } + + setState(861); + match(Semi); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class CompoundStatementContext extends ParserRuleContext { + public TerminalNode LeftBrace() { return getToken(CPP14Parser.LeftBrace, 0); } + public TerminalNode RightBrace() { return getToken(CPP14Parser.RightBrace, 0); } + public StatementSeqContext statementSeq() { + return getRuleContext(StatementSeqContext.class,0); + } + public CompoundStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_compoundStatement; } + } + + public final CompoundStatementContext compoundStatement() throws RecognitionException { + CompoundStatementContext _localctx = new CompoundStatementContext(_ctx, getState()); + enterRule(_localctx, 100, RULE_compoundStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(863); + match(LeftBrace); + setState(865); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << Alignas) | (1L << Alignof) | (1L << Asm) | (1L << Auto) | (1L << Bool) | (1L << Break) | (1L << Case) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Class) | (1L << Const) | (1L << Constexpr) | (1L << Const_cast) | (1L << Continue) | (1L << Decltype) | (1L << Default) | (1L << Delete) | (1L << Do) | (1L << Double) | (1L << Dynamic_cast) | (1L << Enum) | (1L << Explicit) | (1L << Extern) | (1L << Float) | (1L << For) | (1L << Friend) | (1L << Goto) | (1L << If) | (1L << Inline) | (1L << Int) | (1L << Long) | (1L << Mutable) | (1L << Namespace) | (1L << New) | (1L << Noexcept) | (1L << Operator) | (1L << Register) | (1L << Reinterpret_cast) | (1L << Return) | (1L << Short) | (1L << Signed) | (1L << Sizeof) | (1L << Static))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (Static_assert - 64)) | (1L << (Static_cast - 64)) | (1L << (Struct - 64)) | (1L << (Switch - 64)) | (1L << (This - 64)) | (1L << (Thread_local - 64)) | (1L << (Throw - 64)) | (1L << (Try - 64)) | (1L << (Typedef - 64)) | (1L << (Typeid_ - 64)) | (1L << (Typename_ - 64)) | (1L << (Union - 64)) | (1L << (Unsigned - 64)) | (1L << (Using - 64)) | (1L << (Virtual - 64)) | (1L << (Void - 64)) | (1L << (Volatile - 64)) | (1L << (Wchar - 64)) | (1L << (While - 64)) | (1L << (LeftParen - 64)) | (1L << (LeftBracket - 64)) | (1L << (LeftBrace - 64)) | (1L << (Plus - 64)) | (1L << (Minus - 64)) | (1L << (Star - 64)) | (1L << (And - 64)) | (1L << (Or - 64)) | (1L << (Tilde - 64)) | (1L << (Not - 64)) | (1L << (AndAnd - 64)) | (1L << (PlusPlus - 64)) | (1L << (MinusMinus - 64)) | (1L << (Doublecolon - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (Semi - 128)) | (1L << (Ellipsis - 128)) | (1L << (Identifier - 128)))) != 0)) { + { + setState(864); + statementSeq(); + } + } + + setState(867); + match(RightBrace); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class StatementSeqContext extends ParserRuleContext { + public List statement() { + return getRuleContexts(StatementContext.class); + } + public StatementContext statement(int i) { + return getRuleContext(StatementContext.class,i); + } + public StatementSeqContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_statementSeq; } + } + + public final StatementSeqContext statementSeq() throws RecognitionException { + StatementSeqContext _localctx = new StatementSeqContext(_ctx, getState()); + enterRule(_localctx, 102, RULE_statementSeq); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(870); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(869); + statement(); + } + } + setState(872); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << Alignas) | (1L << Alignof) | (1L << Asm) | (1L << Auto) | (1L << Bool) | (1L << Break) | (1L << Case) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Class) | (1L << Const) | (1L << Constexpr) | (1L << Const_cast) | (1L << Continue) | (1L << Decltype) | (1L << Default) | (1L << Delete) | (1L << Do) | (1L << Double) | (1L << Dynamic_cast) | (1L << Enum) | (1L << Explicit) | (1L << Extern) | (1L << Float) | (1L << For) | (1L << Friend) | (1L << Goto) | (1L << If) | (1L << Inline) | (1L << Int) | (1L << Long) | (1L << Mutable) | (1L << Namespace) | (1L << New) | (1L << Noexcept) | (1L << Operator) | (1L << Register) | (1L << Reinterpret_cast) | (1L << Return) | (1L << Short) | (1L << Signed) | (1L << Sizeof) | (1L << Static))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (Static_assert - 64)) | (1L << (Static_cast - 64)) | (1L << (Struct - 64)) | (1L << (Switch - 64)) | (1L << (This - 64)) | (1L << (Thread_local - 64)) | (1L << (Throw - 64)) | (1L << (Try - 64)) | (1L << (Typedef - 64)) | (1L << (Typeid_ - 64)) | (1L << (Typename_ - 64)) | (1L << (Union - 64)) | (1L << (Unsigned - 64)) | (1L << (Using - 64)) | (1L << (Virtual - 64)) | (1L << (Void - 64)) | (1L << (Volatile - 64)) | (1L << (Wchar - 64)) | (1L << (While - 64)) | (1L << (LeftParen - 64)) | (1L << (LeftBracket - 64)) | (1L << (LeftBrace - 64)) | (1L << (Plus - 64)) | (1L << (Minus - 64)) | (1L << (Star - 64)) | (1L << (And - 64)) | (1L << (Or - 64)) | (1L << (Tilde - 64)) | (1L << (Not - 64)) | (1L << (AndAnd - 64)) | (1L << (PlusPlus - 64)) | (1L << (MinusMinus - 64)) | (1L << (Doublecolon - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (Semi - 128)) | (1L << (Ellipsis - 128)) | (1L << (Identifier - 128)))) != 0) ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SelectionStatementContext extends ParserRuleContext { + public TerminalNode If() { return getToken(CPP14Parser.If, 0); } + public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); } + public ConditionContext condition() { + return getRuleContext(ConditionContext.class,0); + } + public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); } + public List statement() { + return getRuleContexts(StatementContext.class); + } + public StatementContext statement(int i) { + return getRuleContext(StatementContext.class,i); + } + public TerminalNode Else() { return getToken(CPP14Parser.Else, 0); } + public TerminalNode Switch() { return getToken(CPP14Parser.Switch, 0); } + public SelectionStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_selectionStatement; } + } + + public final SelectionStatementContext selectionStatement() throws RecognitionException { + SelectionStatementContext _localctx = new SelectionStatementContext(_ctx, getState()); + enterRule(_localctx, 104, RULE_selectionStatement); + try { + setState(889); + _errHandler.sync(this); + switch (_input.LA(1)) { + case If: + enterOuterAlt(_localctx, 1); + { + setState(874); + match(If); + setState(875); + match(LeftParen); + setState(876); + condition(); + setState(877); + match(RightParen); + setState(878); + statement(); + setState(881); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,81,_ctx) ) { + case 1: + { + setState(879); + match(Else); + setState(880); + statement(); + } + break; + } + } + break; + case Switch: + enterOuterAlt(_localctx, 2); + { + setState(883); + match(Switch); + setState(884); + match(LeftParen); + setState(885); + condition(); + setState(886); + match(RightParen); + setState(887); + statement(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ConditionContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public DeclSpecifierSeqContext declSpecifierSeq() { + return getRuleContext(DeclSpecifierSeqContext.class,0); + } + public DeclaratorContext declarator() { + return getRuleContext(DeclaratorContext.class,0); + } + public TerminalNode Assign() { return getToken(CPP14Parser.Assign, 0); } + public InitializerClauseContext initializerClause() { + return getRuleContext(InitializerClauseContext.class,0); + } + public BracedInitListContext bracedInitList() { + return getRuleContext(BracedInitListContext.class,0); + } + public AttributeSpecifierSeqContext attributeSpecifierSeq() { + return getRuleContext(AttributeSpecifierSeqContext.class,0); + } + public ConditionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_condition; } + } + + public final ConditionContext condition() throws RecognitionException { + ConditionContext _localctx = new ConditionContext(_ctx, getState()); + enterRule(_localctx, 106, RULE_condition); + int _la; + try { + setState(902); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,85,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(891); + expression(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(893); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Alignas || _la==LeftBracket) { + { + setState(892); + attributeSpecifierSeq(); + } + } + + setState(895); + declSpecifierSeq(); + setState(896); + declarator(); + setState(900); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Assign: + { + setState(897); + match(Assign); + setState(898); + initializerClause(); + } + break; + case LeftBrace: + { + setState(899); + bracedInitList(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class IterationStatementContext extends ParserRuleContext { + public TerminalNode While() { return getToken(CPP14Parser.While, 0); } + public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); } + public ConditionContext condition() { + return getRuleContext(ConditionContext.class,0); + } + public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public TerminalNode Do() { return getToken(CPP14Parser.Do, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode Semi() { return getToken(CPP14Parser.Semi, 0); } + public TerminalNode For() { return getToken(CPP14Parser.For, 0); } + public ForInitStatementContext forInitStatement() { + return getRuleContext(ForInitStatementContext.class,0); + } + public ForRangeDeclarationContext forRangeDeclaration() { + return getRuleContext(ForRangeDeclarationContext.class,0); + } + public TerminalNode Colon() { return getToken(CPP14Parser.Colon, 0); } + public ForRangeInitializerContext forRangeInitializer() { + return getRuleContext(ForRangeInitializerContext.class,0); + } + public IterationStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_iterationStatement; } + } + + public final IterationStatementContext iterationStatement() throws RecognitionException { + IterationStatementContext _localctx = new IterationStatementContext(_ctx, getState()); + enterRule(_localctx, 108, RULE_iterationStatement); + int _la; + try { + setState(937); + _errHandler.sync(this); + switch (_input.LA(1)) { + case While: + enterOuterAlt(_localctx, 1); + { + setState(904); + match(While); + setState(905); + match(LeftParen); + setState(906); + condition(); + setState(907); + match(RightParen); + setState(908); + statement(); + } + break; + case Do: + enterOuterAlt(_localctx, 2); + { + setState(910); + match(Do); + setState(911); + statement(); + setState(912); + match(While); + setState(913); + match(LeftParen); + setState(914); + expression(); + setState(915); + match(RightParen); + setState(916); + match(Semi); + } + break; + case For: + enterOuterAlt(_localctx, 3); + { + setState(918); + match(For); + setState(919); + match(LeftParen); + setState(932); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,88,_ctx) ) { + case 1: + { + setState(920); + forInitStatement(); + setState(922); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << Alignas) | (1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Class) | (1L << Const) | (1L << Constexpr) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << Enum) | (1L << Explicit) | (1L << Extern) | (1L << Float) | (1L << Friend) | (1L << Inline) | (1L << Int) | (1L << Long) | (1L << Mutable) | (1L << New) | (1L << Noexcept) | (1L << Operator) | (1L << Register) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof) | (1L << Static))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (Static_cast - 65)) | (1L << (Struct - 65)) | (1L << (This - 65)) | (1L << (Thread_local - 65)) | (1L << (Throw - 65)) | (1L << (Typedef - 65)) | (1L << (Typeid_ - 65)) | (1L << (Typename_ - 65)) | (1L << (Union - 65)) | (1L << (Unsigned - 65)) | (1L << (Virtual - 65)) | (1L << (Void - 65)) | (1L << (Volatile - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)))) != 0) || _la==Identifier) { + { + setState(921); + condition(); + } + } + + setState(924); + match(Semi); + setState(926); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (Static_cast - 65)) | (1L << (This - 65)) | (1L << (Throw - 65)) | (1L << (Typeid_ - 65)) | (1L << (Typename_ - 65)) | (1L << (Unsigned - 65)) | (1L << (Void - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)))) != 0) || _la==Identifier) { + { + setState(925); + expression(); + } + } + + } + break; + case 2: + { + setState(928); + forRangeDeclaration(); + setState(929); + match(Colon); + setState(930); + forRangeInitializer(); + } + break; + } + setState(934); + match(RightParen); + setState(935); + statement(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ForInitStatementContext extends ParserRuleContext { + public ExpressionStatementContext expressionStatement() { + return getRuleContext(ExpressionStatementContext.class,0); + } + public SimpleDeclarationContext simpleDeclaration() { + return getRuleContext(SimpleDeclarationContext.class,0); + } + public ForInitStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_forInitStatement; } + } + + public final ForInitStatementContext forInitStatement() throws RecognitionException { + ForInitStatementContext _localctx = new ForInitStatementContext(_ctx, getState()); + enterRule(_localctx, 110, RULE_forInitStatement); + try { + setState(941); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(939); + expressionStatement(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(940); + simpleDeclaration(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ForRangeDeclarationContext extends ParserRuleContext { + public DeclSpecifierSeqContext declSpecifierSeq() { + return getRuleContext(DeclSpecifierSeqContext.class,0); + } + public DeclaratorContext declarator() { + return getRuleContext(DeclaratorContext.class,0); + } + public AttributeSpecifierSeqContext attributeSpecifierSeq() { + return getRuleContext(AttributeSpecifierSeqContext.class,0); + } + public ForRangeDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_forRangeDeclaration; } + } + + public final ForRangeDeclarationContext forRangeDeclaration() throws RecognitionException { + ForRangeDeclarationContext _localctx = new ForRangeDeclarationContext(_ctx, getState()); + enterRule(_localctx, 112, RULE_forRangeDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(944); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Alignas || _la==LeftBracket) { + { + setState(943); + attributeSpecifierSeq(); + } + } + + setState(946); + declSpecifierSeq(); + setState(947); + declarator(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ForRangeInitializerContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public BracedInitListContext bracedInitList() { + return getRuleContext(BracedInitListContext.class,0); + } + public ForRangeInitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_forRangeInitializer; } + } + + public final ForRangeInitializerContext forRangeInitializer() throws RecognitionException { + ForRangeInitializerContext _localctx = new ForRangeInitializerContext(_ctx, getState()); + enterRule(_localctx, 114, RULE_forRangeInitializer); + try { + setState(951); + _errHandler.sync(this); + switch (_input.LA(1)) { + case IntegerLiteral: + case CharacterLiteral: + case FloatingLiteral: + case StringLiteral: + case BooleanLiteral: + case PointerLiteral: + case UserDefinedLiteral: + case Alignof: + case Auto: + case Bool: + case Char: + case Char16: + case Char32: + case Const_cast: + case Decltype: + case Delete: + case Double: + case Dynamic_cast: + case Float: + case Int: + case Long: + case New: + case Noexcept: + case Operator: + case Reinterpret_cast: + case Short: + case Signed: + case Sizeof: + case Static_cast: + case This: + case Throw: + case Typeid_: + case Typename_: + case Unsigned: + case Void: + case Wchar: + case LeftParen: + case LeftBracket: + case Plus: + case Minus: + case Star: + case And: + case Or: + case Tilde: + case Not: + case PlusPlus: + case MinusMinus: + case Doublecolon: + case Identifier: + enterOuterAlt(_localctx, 1); + { + setState(949); + expression(); + } + break; + case LeftBrace: + enterOuterAlt(_localctx, 2); + { + setState(950); + bracedInitList(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class JumpStatementContext extends ParserRuleContext { + public TerminalNode Semi() { return getToken(CPP14Parser.Semi, 0); } + public TerminalNode Break() { return getToken(CPP14Parser.Break, 0); } + public TerminalNode Continue() { return getToken(CPP14Parser.Continue, 0); } + public TerminalNode Return() { return getToken(CPP14Parser.Return, 0); } + public TerminalNode Goto() { return getToken(CPP14Parser.Goto, 0); } + public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public BracedInitListContext bracedInitList() { + return getRuleContext(BracedInitListContext.class,0); + } + public JumpStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_jumpStatement; } + } + + public final JumpStatementContext jumpStatement() throws RecognitionException { + JumpStatementContext _localctx = new JumpStatementContext(_ctx, getState()); + enterRule(_localctx, 116, RULE_jumpStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(962); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Break: + { + setState(953); + match(Break); + } + break; + case Continue: + { + setState(954); + match(Continue); + } + break; + case Return: + { + setState(955); + match(Return); + setState(958); + _errHandler.sync(this); + switch (_input.LA(1)) { + case IntegerLiteral: + case CharacterLiteral: + case FloatingLiteral: + case StringLiteral: + case BooleanLiteral: + case PointerLiteral: + case UserDefinedLiteral: + case Alignof: + case Auto: + case Bool: + case Char: + case Char16: + case Char32: + case Const_cast: + case Decltype: + case Delete: + case Double: + case Dynamic_cast: + case Float: + case Int: + case Long: + case New: + case Noexcept: + case Operator: + case Reinterpret_cast: + case Short: + case Signed: + case Sizeof: + case Static_cast: + case This: + case Throw: + case Typeid_: + case Typename_: + case Unsigned: + case Void: + case Wchar: + case LeftParen: + case LeftBracket: + case Plus: + case Minus: + case Star: + case And: + case Or: + case Tilde: + case Not: + case PlusPlus: + case MinusMinus: + case Doublecolon: + case Identifier: + { + setState(956); + expression(); + } + break; + case LeftBrace: + { + setState(957); + bracedInitList(); + } + break; + case Semi: + break; + default: + break; + } + } + break; + case Goto: + { + setState(960); + match(Goto); + setState(961); + match(Identifier); + } + break; + default: + throw new NoViableAltException(this); + } + setState(964); + match(Semi); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class DeclarationStatementContext extends ParserRuleContext { + public BlockDeclarationContext blockDeclaration() { + return getRuleContext(BlockDeclarationContext.class,0); + } + public DeclarationStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_declarationStatement; } + } + + public final DeclarationStatementContext declarationStatement() throws RecognitionException { + DeclarationStatementContext _localctx = new DeclarationStatementContext(_ctx, getState()); + enterRule(_localctx, 118, RULE_declarationStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(966); + blockDeclaration(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class DeclarationseqContext extends ParserRuleContext { + public List declaration() { + return getRuleContexts(DeclarationContext.class); + } + public DeclarationContext declaration(int i) { + return getRuleContext(DeclarationContext.class,i); + } + public DeclarationseqContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_declarationseq; } + } + + public final DeclarationseqContext declarationseq() throws RecognitionException { + DeclarationseqContext _localctx = new DeclarationseqContext(_ctx, getState()); + enterRule(_localctx, 120, RULE_declarationseq); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(969); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(968); + declaration(); + } + } + setState(971); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( ((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (Alignas - 10)) | (1L << (Asm - 10)) | (1L << (Auto - 10)) | (1L << (Bool - 10)) | (1L << (Char - 10)) | (1L << (Char16 - 10)) | (1L << (Char32 - 10)) | (1L << (Class - 10)) | (1L << (Const - 10)) | (1L << (Constexpr - 10)) | (1L << (Decltype - 10)) | (1L << (Double - 10)) | (1L << (Enum - 10)) | (1L << (Explicit - 10)) | (1L << (Extern - 10)) | (1L << (Float - 10)) | (1L << (Friend - 10)) | (1L << (Inline - 10)) | (1L << (Int - 10)) | (1L << (Long - 10)) | (1L << (Mutable - 10)) | (1L << (Namespace - 10)) | (1L << (Operator - 10)) | (1L << (Register - 10)) | (1L << (Short - 10)) | (1L << (Signed - 10)) | (1L << (Static - 10)) | (1L << (Static_assert - 10)) | (1L << (Struct - 10)) | (1L << (Template - 10)) | (1L << (Thread_local - 10)))) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (Typedef - 74)) | (1L << (Typename_ - 74)) | (1L << (Union - 74)) | (1L << (Unsigned - 74)) | (1L << (Using - 74)) | (1L << (Virtual - 74)) | (1L << (Void - 74)) | (1L << (Volatile - 74)) | (1L << (Wchar - 74)) | (1L << (LeftParen - 74)) | (1L << (LeftBracket - 74)) | (1L << (Star - 74)) | (1L << (And - 74)) | (1L << (Tilde - 74)) | (1L << (AndAnd - 74)) | (1L << (Doublecolon - 74)) | (1L << (Semi - 74)) | (1L << (Ellipsis - 74)) | (1L << (Identifier - 74)))) != 0) ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class DeclarationContext extends ParserRuleContext { + public BlockDeclarationContext blockDeclaration() { + return getRuleContext(BlockDeclarationContext.class,0); + } + public FunctionDefinitionContext functionDefinition() { + return getRuleContext(FunctionDefinitionContext.class,0); + } + public TemplateDeclarationContext templateDeclaration() { + return getRuleContext(TemplateDeclarationContext.class,0); + } + public ExplicitInstantiationContext explicitInstantiation() { + return getRuleContext(ExplicitInstantiationContext.class,0); + } + public ExplicitSpecializationContext explicitSpecialization() { + return getRuleContext(ExplicitSpecializationContext.class,0); + } + public LinkageSpecificationContext linkageSpecification() { + return getRuleContext(LinkageSpecificationContext.class,0); + } + public NamespaceDefinitionContext namespaceDefinition() { + return getRuleContext(NamespaceDefinitionContext.class,0); + } + public EmptyDeclarationContext emptyDeclaration() { + return getRuleContext(EmptyDeclarationContext.class,0); + } + public AttributeDeclarationContext attributeDeclaration() { + return getRuleContext(AttributeDeclarationContext.class,0); + } + public DeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_declaration; } + } + + public final DeclarationContext declaration() throws RecognitionException { + DeclarationContext _localctx = new DeclarationContext(_ctx, getState()); + enterRule(_localctx, 122, RULE_declaration); + try { + setState(982); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,96,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(973); + blockDeclaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(974); + functionDefinition(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(975); + templateDeclaration(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(976); + explicitInstantiation(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(977); + explicitSpecialization(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(978); + linkageSpecification(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(979); + namespaceDefinition(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(980); + emptyDeclaration(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(981); + attributeDeclaration(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class BlockDeclarationContext extends ParserRuleContext { + public SimpleDeclarationContext simpleDeclaration() { + return getRuleContext(SimpleDeclarationContext.class,0); + } + public AsmDefinitionContext asmDefinition() { + return getRuleContext(AsmDefinitionContext.class,0); + } + public NamespaceAliasDefinitionContext namespaceAliasDefinition() { + return getRuleContext(NamespaceAliasDefinitionContext.class,0); + } + public UsingDeclarationContext usingDeclaration() { + return getRuleContext(UsingDeclarationContext.class,0); + } + public UsingDirectiveContext usingDirective() { + return getRuleContext(UsingDirectiveContext.class,0); + } + public StaticAssertDeclarationContext staticAssertDeclaration() { + return getRuleContext(StaticAssertDeclarationContext.class,0); + } + public AliasDeclarationContext aliasDeclaration() { + return getRuleContext(AliasDeclarationContext.class,0); + } + public OpaqueEnumDeclarationContext opaqueEnumDeclaration() { + return getRuleContext(OpaqueEnumDeclarationContext.class,0); + } + public BlockDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_blockDeclaration; } + } + + public final BlockDeclarationContext blockDeclaration() throws RecognitionException { + BlockDeclarationContext _localctx = new BlockDeclarationContext(_ctx, getState()); + enterRule(_localctx, 124, RULE_blockDeclaration); + try { + setState(992); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,97,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(984); + simpleDeclaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(985); + asmDefinition(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(986); + namespaceAliasDefinition(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(987); + usingDeclaration(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(988); + usingDirective(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(989); + staticAssertDeclaration(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(990); + aliasDeclaration(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(991); + opaqueEnumDeclaration(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AliasDeclarationContext extends ParserRuleContext { + public TerminalNode Using() { return getToken(CPP14Parser.Using, 0); } + public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); } + public TerminalNode Assign() { return getToken(CPP14Parser.Assign, 0); } + public TheTypeIdContext theTypeId() { + return getRuleContext(TheTypeIdContext.class,0); + } + public TerminalNode Semi() { return getToken(CPP14Parser.Semi, 0); } + public AttributeSpecifierSeqContext attributeSpecifierSeq() { + return getRuleContext(AttributeSpecifierSeqContext.class,0); + } + public AliasDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_aliasDeclaration; } + } + + public final AliasDeclarationContext aliasDeclaration() throws RecognitionException { + AliasDeclarationContext _localctx = new AliasDeclarationContext(_ctx, getState()); + enterRule(_localctx, 126, RULE_aliasDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(994); + match(Using); + setState(995); + match(Identifier); + setState(997); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Alignas || _la==LeftBracket) { + { + setState(996); + attributeSpecifierSeq(); + } + } + + setState(999); + match(Assign); + setState(1000); + theTypeId(); + setState(1001); + match(Semi); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SimpleDeclarationContext extends ParserRuleContext { + public TerminalNode Semi() { return getToken(CPP14Parser.Semi, 0); } + public DeclSpecifierSeqContext declSpecifierSeq() { + return getRuleContext(DeclSpecifierSeqContext.class,0); + } + public InitDeclaratorListContext initDeclaratorList() { + return getRuleContext(InitDeclaratorListContext.class,0); + } + public AttributeSpecifierSeqContext attributeSpecifierSeq() { + return getRuleContext(AttributeSpecifierSeqContext.class,0); + } + public SimpleDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_simpleDeclaration; } + } + + public final SimpleDeclarationContext simpleDeclaration() throws RecognitionException { + SimpleDeclarationContext _localctx = new SimpleDeclarationContext(_ctx, getState()); + enterRule(_localctx, 128, RULE_simpleDeclaration); + int _la; + try { + setState(1017); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Auto: + case Bool: + case Char: + case Char16: + case Char32: + case Class: + case Const: + case Constexpr: + case Decltype: + case Double: + case Enum: + case Explicit: + case Extern: + case Float: + case Friend: + case Inline: + case Int: + case Long: + case Mutable: + case Operator: + case Register: + case Short: + case Signed: + case Static: + case Struct: + case Thread_local: + case Typedef: + case Typename_: + case Union: + case Unsigned: + case Virtual: + case Void: + case Volatile: + case Wchar: + case LeftParen: + case Star: + case And: + case Tilde: + case AndAnd: + case Doublecolon: + case Semi: + case Ellipsis: + case Identifier: + enterOuterAlt(_localctx, 1); + { + setState(1004); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,99,_ctx) ) { + case 1: + { + setState(1003); + declSpecifierSeq(); + } + break; + } + setState(1007); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Decltype || _la==Operator || ((((_la - 85)) & ~0x3f) == 0 && ((1L << (_la - 85)) & ((1L << (LeftParen - 85)) | (1L << (Star - 85)) | (1L << (And - 85)) | (1L << (Tilde - 85)) | (1L << (AndAnd - 85)) | (1L << (Doublecolon - 85)) | (1L << (Ellipsis - 85)) | (1L << (Identifier - 85)))) != 0)) { + { + setState(1006); + initDeclaratorList(); + } + } + + setState(1009); + match(Semi); + } + break; + case Alignas: + case LeftBracket: + enterOuterAlt(_localctx, 2); + { + setState(1010); + attributeSpecifierSeq(); + setState(1012); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,101,_ctx) ) { + case 1: + { + setState(1011); + declSpecifierSeq(); + } + break; + } + setState(1014); + initDeclaratorList(); + setState(1015); + match(Semi); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class StaticAssertDeclarationContext extends ParserRuleContext { + public TerminalNode Static_assert() { return getToken(CPP14Parser.Static_assert, 0); } + public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); } + public ConstantExpressionContext constantExpression() { + return getRuleContext(ConstantExpressionContext.class,0); + } + public TerminalNode Comma() { return getToken(CPP14Parser.Comma, 0); } + public TerminalNode StringLiteral() { return getToken(CPP14Parser.StringLiteral, 0); } + public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); } + public TerminalNode Semi() { return getToken(CPP14Parser.Semi, 0); } + public StaticAssertDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_staticAssertDeclaration; } + } + + public final StaticAssertDeclarationContext staticAssertDeclaration() throws RecognitionException { + StaticAssertDeclarationContext _localctx = new StaticAssertDeclarationContext(_ctx, getState()); + enterRule(_localctx, 130, RULE_staticAssertDeclaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(1019); + match(Static_assert); + setState(1020); + match(LeftParen); + setState(1021); + constantExpression(); + setState(1022); + match(Comma); + setState(1023); + match(StringLiteral); + setState(1024); + match(RightParen); + setState(1025); + match(Semi); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EmptyDeclarationContext extends ParserRuleContext { + public TerminalNode Semi() { return getToken(CPP14Parser.Semi, 0); } + public EmptyDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_emptyDeclaration; } + } + + public final EmptyDeclarationContext emptyDeclaration() throws RecognitionException { + EmptyDeclarationContext _localctx = new EmptyDeclarationContext(_ctx, getState()); + enterRule(_localctx, 132, RULE_emptyDeclaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(1027); + match(Semi); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AttributeDeclarationContext extends ParserRuleContext { + public AttributeSpecifierSeqContext attributeSpecifierSeq() { + return getRuleContext(AttributeSpecifierSeqContext.class,0); + } + public TerminalNode Semi() { return getToken(CPP14Parser.Semi, 0); } + public AttributeDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_attributeDeclaration; } + } + + public final AttributeDeclarationContext attributeDeclaration() throws RecognitionException { + AttributeDeclarationContext _localctx = new AttributeDeclarationContext(_ctx, getState()); + enterRule(_localctx, 134, RULE_attributeDeclaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(1029); + attributeSpecifierSeq(); + setState(1030); + match(Semi); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class DeclSpecifierContext extends ParserRuleContext { + public StorageClassSpecifierContext storageClassSpecifier() { + return getRuleContext(StorageClassSpecifierContext.class,0); + } + public TypeSpecifierContext typeSpecifier() { + return getRuleContext(TypeSpecifierContext.class,0); + } + public FunctionSpecifierContext functionSpecifier() { + return getRuleContext(FunctionSpecifierContext.class,0); + } + public TerminalNode Friend() { return getToken(CPP14Parser.Friend, 0); } + public TerminalNode Typedef() { return getToken(CPP14Parser.Typedef, 0); } + public TerminalNode Constexpr() { return getToken(CPP14Parser.Constexpr, 0); } + public DeclSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_declSpecifier; } + } + + public final DeclSpecifierContext declSpecifier() throws RecognitionException { + DeclSpecifierContext _localctx = new DeclSpecifierContext(_ctx, getState()); + enterRule(_localctx, 136, RULE_declSpecifier); + try { + setState(1038); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Extern: + case Mutable: + case Register: + case Static: + case Thread_local: + enterOuterAlt(_localctx, 1); + { + setState(1032); + storageClassSpecifier(); + } + break; + case Auto: + case Bool: + case Char: + case Char16: + case Char32: + case Class: + case Const: + case Decltype: + case Double: + case Enum: + case Float: + case Int: + case Long: + case Short: + case Signed: + case Struct: + case Typename_: + case Union: + case Unsigned: + case Void: + case Volatile: + case Wchar: + case Doublecolon: + case Identifier: + enterOuterAlt(_localctx, 2); + { + setState(1033); + typeSpecifier(); + } + break; + case Explicit: + case Inline: + case Virtual: + enterOuterAlt(_localctx, 3); + { + setState(1034); + functionSpecifier(); + } + break; + case Friend: + enterOuterAlt(_localctx, 4); + { + setState(1035); + match(Friend); + } + break; + case Typedef: + enterOuterAlt(_localctx, 5); + { + setState(1036); + match(Typedef); + } + break; + case Constexpr: + enterOuterAlt(_localctx, 6); + { + setState(1037); + match(Constexpr); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class DeclSpecifierSeqContext extends ParserRuleContext { + public List declSpecifier() { + return getRuleContexts(DeclSpecifierContext.class); + } + public DeclSpecifierContext declSpecifier(int i) { + return getRuleContext(DeclSpecifierContext.class,i); + } + public AttributeSpecifierSeqContext attributeSpecifierSeq() { + return getRuleContext(AttributeSpecifierSeqContext.class,0); + } + public DeclSpecifierSeqContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_declSpecifierSeq; } + } + + public final DeclSpecifierSeqContext declSpecifierSeq() throws RecognitionException { + DeclSpecifierSeqContext _localctx = new DeclSpecifierSeqContext(_ctx, getState()); + enterRule(_localctx, 138, RULE_declSpecifierSeq); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1041); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(1040); + declSpecifier(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1043); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,104,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + setState(1046); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,105,_ctx) ) { + case 1: + { + setState(1045); + attributeSpecifierSeq(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class StorageClassSpecifierContext extends ParserRuleContext { + public TerminalNode Register() { return getToken(CPP14Parser.Register, 0); } + public TerminalNode Static() { return getToken(CPP14Parser.Static, 0); } + public TerminalNode Thread_local() { return getToken(CPP14Parser.Thread_local, 0); } + public TerminalNode Extern() { return getToken(CPP14Parser.Extern, 0); } + public TerminalNode Mutable() { return getToken(CPP14Parser.Mutable, 0); } + public StorageClassSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_storageClassSpecifier; } + } + + public final StorageClassSpecifierContext storageClassSpecifier() throws RecognitionException { + StorageClassSpecifierContext _localctx = new StorageClassSpecifierContext(_ctx, getState()); + enterRule(_localctx, 140, RULE_storageClassSpecifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1048); + _la = _input.LA(1); + if ( !(((((_la - 36)) & ~0x3f) == 0 && ((1L << (_la - 36)) & ((1L << (Extern - 36)) | (1L << (Mutable - 36)) | (1L << (Register - 36)) | (1L << (Static - 36)) | (1L << (Thread_local - 36)))) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FunctionSpecifierContext extends ParserRuleContext { + public TerminalNode Inline() { return getToken(CPP14Parser.Inline, 0); } + public TerminalNode Virtual() { return getToken(CPP14Parser.Virtual, 0); } + public TerminalNode Explicit() { return getToken(CPP14Parser.Explicit, 0); } + public FunctionSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_functionSpecifier; } + } + + public final FunctionSpecifierContext functionSpecifier() throws RecognitionException { + FunctionSpecifierContext _localctx = new FunctionSpecifierContext(_ctx, getState()); + enterRule(_localctx, 142, RULE_functionSpecifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1050); + _la = _input.LA(1); + if ( !(((((_la - 34)) & ~0x3f) == 0 && ((1L << (_la - 34)) & ((1L << (Explicit - 34)) | (1L << (Inline - 34)) | (1L << (Virtual - 34)))) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypedefNameContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); } + public TypedefNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typedefName; } + } + + public final TypedefNameContext typedefName() throws RecognitionException { + TypedefNameContext _localctx = new TypedefNameContext(_ctx, getState()); + enterRule(_localctx, 144, RULE_typedefName); + try { + enterOuterAlt(_localctx, 1); + { + setState(1052); + match(Identifier); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeSpecifierContext extends ParserRuleContext { + public TrailingTypeSpecifierContext trailingTypeSpecifier() { + return getRuleContext(TrailingTypeSpecifierContext.class,0); + } + public ClassSpecifierContext classSpecifier() { + return getRuleContext(ClassSpecifierContext.class,0); + } + public EnumSpecifierContext enumSpecifier() { + return getRuleContext(EnumSpecifierContext.class,0); + } + public TypeSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeSpecifier; } + } + + public final TypeSpecifierContext typeSpecifier() throws RecognitionException { + TypeSpecifierContext _localctx = new TypeSpecifierContext(_ctx, getState()); + enterRule(_localctx, 146, RULE_typeSpecifier); + try { + setState(1057); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,106,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1054); + trailingTypeSpecifier(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1055); + classSpecifier(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1056); + enumSpecifier(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TrailingTypeSpecifierContext extends ParserRuleContext { + public SimpleTypeSpecifierContext simpleTypeSpecifier() { + return getRuleContext(SimpleTypeSpecifierContext.class,0); + } + public ElaboratedTypeSpecifierContext elaboratedTypeSpecifier() { + return getRuleContext(ElaboratedTypeSpecifierContext.class,0); + } + public TypeNameSpecifierContext typeNameSpecifier() { + return getRuleContext(TypeNameSpecifierContext.class,0); + } + public CvQualifierContext cvQualifier() { + return getRuleContext(CvQualifierContext.class,0); + } + public TrailingTypeSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_trailingTypeSpecifier; } + } + + public final TrailingTypeSpecifierContext trailingTypeSpecifier() throws RecognitionException { + TrailingTypeSpecifierContext _localctx = new TrailingTypeSpecifierContext(_ctx, getState()); + enterRule(_localctx, 148, RULE_trailingTypeSpecifier); + try { + setState(1063); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Auto: + case Bool: + case Char: + case Char16: + case Char32: + case Decltype: + case Double: + case Float: + case Int: + case Long: + case Short: + case Signed: + case Unsigned: + case Void: + case Wchar: + case Doublecolon: + case Identifier: + enterOuterAlt(_localctx, 1); + { + setState(1059); + simpleTypeSpecifier(); + } + break; + case Class: + case Enum: + case Struct: + enterOuterAlt(_localctx, 2); + { + setState(1060); + elaboratedTypeSpecifier(); + } + break; + case Typename_: + enterOuterAlt(_localctx, 3); + { + setState(1061); + typeNameSpecifier(); + } + break; + case Const: + case Volatile: + enterOuterAlt(_localctx, 4); + { + setState(1062); + cvQualifier(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeSpecifierSeqContext extends ParserRuleContext { + public List typeSpecifier() { + return getRuleContexts(TypeSpecifierContext.class); + } + public TypeSpecifierContext typeSpecifier(int i) { + return getRuleContext(TypeSpecifierContext.class,i); + } + public AttributeSpecifierSeqContext attributeSpecifierSeq() { + return getRuleContext(AttributeSpecifierSeqContext.class,0); + } + public TypeSpecifierSeqContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeSpecifierSeq; } + } + + public final TypeSpecifierSeqContext typeSpecifierSeq() throws RecognitionException { + TypeSpecifierSeqContext _localctx = new TypeSpecifierSeqContext(_ctx, getState()); + enterRule(_localctx, 150, RULE_typeSpecifierSeq); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1066); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(1065); + typeSpecifier(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1068); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,108,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + setState(1071); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,109,_ctx) ) { + case 1: + { + setState(1070); + attributeSpecifierSeq(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TrailingTypeSpecifierSeqContext extends ParserRuleContext { + public List trailingTypeSpecifier() { + return getRuleContexts(TrailingTypeSpecifierContext.class); + } + public TrailingTypeSpecifierContext trailingTypeSpecifier(int i) { + return getRuleContext(TrailingTypeSpecifierContext.class,i); + } + public AttributeSpecifierSeqContext attributeSpecifierSeq() { + return getRuleContext(AttributeSpecifierSeqContext.class,0); + } + public TrailingTypeSpecifierSeqContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_trailingTypeSpecifierSeq; } + } + + public final TrailingTypeSpecifierSeqContext trailingTypeSpecifierSeq() throws RecognitionException { + TrailingTypeSpecifierSeqContext _localctx = new TrailingTypeSpecifierSeqContext(_ctx, getState()); + enterRule(_localctx, 152, RULE_trailingTypeSpecifierSeq); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1074); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(1073); + trailingTypeSpecifier(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1076); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,110,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + setState(1079); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,111,_ctx) ) { + case 1: + { + setState(1078); + attributeSpecifierSeq(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SimpleTypeSpecifierContext extends ParserRuleContext { + public TheTypeNameContext theTypeName() { + return getRuleContext(TheTypeNameContext.class,0); + } + public NestedNameSpecifierContext nestedNameSpecifier() { + return getRuleContext(NestedNameSpecifierContext.class,0); + } + public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); } + public SimpleTemplateIdContext simpleTemplateId() { + return getRuleContext(SimpleTemplateIdContext.class,0); + } + public TerminalNode Char() { return getToken(CPP14Parser.Char, 0); } + public TerminalNode Char16() { return getToken(CPP14Parser.Char16, 0); } + public TerminalNode Char32() { return getToken(CPP14Parser.Char32, 0); } + public TerminalNode Wchar() { return getToken(CPP14Parser.Wchar, 0); } + public TerminalNode Bool() { return getToken(CPP14Parser.Bool, 0); } + public TerminalNode Short() { return getToken(CPP14Parser.Short, 0); } + public TerminalNode Int() { return getToken(CPP14Parser.Int, 0); } + public TerminalNode Long() { return getToken(CPP14Parser.Long, 0); } + public TerminalNode Signed() { return getToken(CPP14Parser.Signed, 0); } + public TerminalNode Unsigned() { return getToken(CPP14Parser.Unsigned, 0); } + public TerminalNode Float() { return getToken(CPP14Parser.Float, 0); } + public TerminalNode Double() { return getToken(CPP14Parser.Double, 0); } + public TerminalNode Void() { return getToken(CPP14Parser.Void, 0); } + public TerminalNode Auto() { return getToken(CPP14Parser.Auto, 0); } + public DecltypeSpecifierContext decltypeSpecifier() { + return getRuleContext(DecltypeSpecifierContext.class,0); + } + public SimpleTypeSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_simpleTypeSpecifier; } + } + + public final SimpleTypeSpecifierContext simpleTypeSpecifier() throws RecognitionException { + SimpleTypeSpecifierContext _localctx = new SimpleTypeSpecifierContext(_ctx, getState()); + enterRule(_localctx, 154, RULE_simpleTypeSpecifier); + try { + setState(1104); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,113,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1082); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,112,_ctx) ) { + case 1: + { + setState(1081); + nestedNameSpecifier(0); + } + break; + } + setState(1084); + theTypeName(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1085); + nestedNameSpecifier(0); + setState(1086); + match(Template); + setState(1087); + simpleTemplateId(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1089); + match(Char); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1090); + match(Char16); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1091); + match(Char32); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1092); + match(Wchar); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(1093); + match(Bool); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(1094); + match(Short); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(1095); + match(Int); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(1096); + match(Long); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(1097); + match(Signed); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(1098); + match(Unsigned); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(1099); + match(Float); + } + break; + case 14: + enterOuterAlt(_localctx, 14); + { + setState(1100); + match(Double); + } + break; + case 15: + enterOuterAlt(_localctx, 15); + { + setState(1101); + match(Void); + } + break; + case 16: + enterOuterAlt(_localctx, 16); + { + setState(1102); + match(Auto); + } + break; + case 17: + enterOuterAlt(_localctx, 17); + { + setState(1103); + decltypeSpecifier(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TheTypeNameContext extends ParserRuleContext { + public ClassNameContext className() { + return getRuleContext(ClassNameContext.class,0); + } + public EnumNameContext enumName() { + return getRuleContext(EnumNameContext.class,0); + } + public TypedefNameContext typedefName() { + return getRuleContext(TypedefNameContext.class,0); + } + public SimpleTemplateIdContext simpleTemplateId() { + return getRuleContext(SimpleTemplateIdContext.class,0); + } + public TheTypeNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_theTypeName; } + } + + public final TheTypeNameContext theTypeName() throws RecognitionException { + TheTypeNameContext _localctx = new TheTypeNameContext(_ctx, getState()); + enterRule(_localctx, 156, RULE_theTypeName); + try { + setState(1110); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,114,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1106); + className(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1107); + enumName(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1108); + typedefName(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1109); + simpleTemplateId(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class DecltypeSpecifierContext extends ParserRuleContext { + public TerminalNode Decltype() { return getToken(CPP14Parser.Decltype, 0); } + public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); } + public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode Auto() { return getToken(CPP14Parser.Auto, 0); } + public DecltypeSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_decltypeSpecifier; } + } + + public final DecltypeSpecifierContext decltypeSpecifier() throws RecognitionException { + DecltypeSpecifierContext _localctx = new DecltypeSpecifierContext(_ctx, getState()); + enterRule(_localctx, 158, RULE_decltypeSpecifier); + try { + enterOuterAlt(_localctx, 1); + { + setState(1112); + match(Decltype); + setState(1113); + match(LeftParen); + setState(1116); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,115,_ctx) ) { + case 1: + { + setState(1114); + expression(); + } + break; + case 2: + { + setState(1115); + match(Auto); + } + break; + } + setState(1118); + match(RightParen); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ElaboratedTypeSpecifierContext extends ParserRuleContext { + public ClassKeyContext classKey() { + return getRuleContext(ClassKeyContext.class,0); + } + public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); } + public SimpleTemplateIdContext simpleTemplateId() { + return getRuleContext(SimpleTemplateIdContext.class,0); + } + public NestedNameSpecifierContext nestedNameSpecifier() { + return getRuleContext(NestedNameSpecifierContext.class,0); + } + public AttributeSpecifierSeqContext attributeSpecifierSeq() { + return getRuleContext(AttributeSpecifierSeqContext.class,0); + } + public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); } + public TerminalNode Enum() { return getToken(CPP14Parser.Enum, 0); } + public ElaboratedTypeSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_elaboratedTypeSpecifier; } + } + + public final ElaboratedTypeSpecifierContext elaboratedTypeSpecifier() throws RecognitionException { + ElaboratedTypeSpecifierContext _localctx = new ElaboratedTypeSpecifierContext(_ctx, getState()); + enterRule(_localctx, 160, RULE_elaboratedTypeSpecifier); + int _la; + try { + setState(1142); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Class: + case Struct: + enterOuterAlt(_localctx, 1); + { + setState(1120); + classKey(); + setState(1135); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,119,_ctx) ) { + case 1: + { + setState(1122); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Alignas || _la==LeftBracket) { + { + setState(1121); + attributeSpecifierSeq(); + } + } + + setState(1125); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,117,_ctx) ) { + case 1: + { + setState(1124); + nestedNameSpecifier(0); + } + break; + } + setState(1127); + match(Identifier); + } + break; + case 2: + { + setState(1128); + simpleTemplateId(); + } + break; + case 3: + { + setState(1129); + nestedNameSpecifier(0); + setState(1131); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Template) { + { + setState(1130); + match(Template); + } + } + + setState(1133); + simpleTemplateId(); + } + break; + } + } + break; + case Enum: + enterOuterAlt(_localctx, 2); + { + setState(1137); + match(Enum); + setState(1139); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,120,_ctx) ) { + case 1: + { + setState(1138); + nestedNameSpecifier(0); + } + break; + } + setState(1141); + match(Identifier); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EnumNameContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); } + public EnumNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enumName; } + } + + public final EnumNameContext enumName() throws RecognitionException { + EnumNameContext _localctx = new EnumNameContext(_ctx, getState()); + enterRule(_localctx, 162, RULE_enumName); + try { + enterOuterAlt(_localctx, 1); + { + setState(1144); + match(Identifier); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EnumSpecifierContext extends ParserRuleContext { + public EnumHeadContext enumHead() { + return getRuleContext(EnumHeadContext.class,0); + } + public TerminalNode LeftBrace() { return getToken(CPP14Parser.LeftBrace, 0); } + public TerminalNode RightBrace() { return getToken(CPP14Parser.RightBrace, 0); } + public EnumeratorListContext enumeratorList() { + return getRuleContext(EnumeratorListContext.class,0); + } + public TerminalNode Comma() { return getToken(CPP14Parser.Comma, 0); } + public EnumSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enumSpecifier; } + } + + public final EnumSpecifierContext enumSpecifier() throws RecognitionException { + EnumSpecifierContext _localctx = new EnumSpecifierContext(_ctx, getState()); + enterRule(_localctx, 164, RULE_enumSpecifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1146); + enumHead(); + setState(1147); + match(LeftBrace); + setState(1152); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Identifier) { + { + setState(1148); + enumeratorList(); + setState(1150); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Comma) { + { + setState(1149); + match(Comma); + } + } + + } + } + + setState(1154); + match(RightBrace); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EnumHeadContext extends ParserRuleContext { + public EnumkeyContext enumkey() { + return getRuleContext(EnumkeyContext.class,0); + } + public AttributeSpecifierSeqContext attributeSpecifierSeq() { + return getRuleContext(AttributeSpecifierSeqContext.class,0); + } + public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); } + public EnumbaseContext enumbase() { + return getRuleContext(EnumbaseContext.class,0); + } + public NestedNameSpecifierContext nestedNameSpecifier() { + return getRuleContext(NestedNameSpecifierContext.class,0); + } + public EnumHeadContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enumHead; } + } + + public final EnumHeadContext enumHead() throws RecognitionException { + EnumHeadContext _localctx = new EnumHeadContext(_ctx, getState()); + enterRule(_localctx, 166, RULE_enumHead); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1156); + enumkey(); + setState(1158); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Alignas || _la==LeftBracket) { + { + setState(1157); + attributeSpecifierSeq(); + } + } + + setState(1164); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Decltype || _la==Doublecolon || _la==Identifier) { + { + setState(1161); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,125,_ctx) ) { + case 1: + { + setState(1160); + nestedNameSpecifier(0); + } + break; + } + setState(1163); + match(Identifier); + } + } + + setState(1167); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Colon) { + { + setState(1166); + enumbase(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class OpaqueEnumDeclarationContext extends ParserRuleContext { + public EnumkeyContext enumkey() { + return getRuleContext(EnumkeyContext.class,0); + } + public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); } + public TerminalNode Semi() { return getToken(CPP14Parser.Semi, 0); } + public AttributeSpecifierSeqContext attributeSpecifierSeq() { + return getRuleContext(AttributeSpecifierSeqContext.class,0); + } + public EnumbaseContext enumbase() { + return getRuleContext(EnumbaseContext.class,0); + } + public OpaqueEnumDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_opaqueEnumDeclaration; } + } + + public final OpaqueEnumDeclarationContext opaqueEnumDeclaration() throws RecognitionException { + OpaqueEnumDeclarationContext _localctx = new OpaqueEnumDeclarationContext(_ctx, getState()); + enterRule(_localctx, 168, RULE_opaqueEnumDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1169); + enumkey(); + setState(1171); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Alignas || _la==LeftBracket) { + { + setState(1170); + attributeSpecifierSeq(); + } + } + + setState(1173); + match(Identifier); + setState(1175); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Colon) { + { + setState(1174); + enumbase(); + } + } + + setState(1177); + match(Semi); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EnumkeyContext extends ParserRuleContext { + public TerminalNode Enum() { return getToken(CPP14Parser.Enum, 0); } + public TerminalNode Class() { return getToken(CPP14Parser.Class, 0); } + public TerminalNode Struct() { return getToken(CPP14Parser.Struct, 0); } + public EnumkeyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enumkey; } + } + + public final EnumkeyContext enumkey() throws RecognitionException { + EnumkeyContext _localctx = new EnumkeyContext(_ctx, getState()); + enterRule(_localctx, 170, RULE_enumkey); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1179); + match(Enum); + setState(1181); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Class || _la==Struct) { + { + setState(1180); + _la = _input.LA(1); + if ( !(_la==Class || _la==Struct) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EnumbaseContext extends ParserRuleContext { + public TerminalNode Colon() { return getToken(CPP14Parser.Colon, 0); } + public TypeSpecifierSeqContext typeSpecifierSeq() { + return getRuleContext(TypeSpecifierSeqContext.class,0); + } + public EnumbaseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enumbase; } + } + + public final EnumbaseContext enumbase() throws RecognitionException { + EnumbaseContext _localctx = new EnumbaseContext(_ctx, getState()); + enterRule(_localctx, 172, RULE_enumbase); + try { + enterOuterAlt(_localctx, 1); + { + setState(1183); + match(Colon); + setState(1184); + typeSpecifierSeq(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EnumeratorListContext extends ParserRuleContext { + public List enumeratorDefinition() { + return getRuleContexts(EnumeratorDefinitionContext.class); + } + public EnumeratorDefinitionContext enumeratorDefinition(int i) { + return getRuleContext(EnumeratorDefinitionContext.class,i); + } + public List Comma() { return getTokens(CPP14Parser.Comma); } + public TerminalNode Comma(int i) { + return getToken(CPP14Parser.Comma, i); + } + public EnumeratorListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enumeratorList; } + } + + public final EnumeratorListContext enumeratorList() throws RecognitionException { + EnumeratorListContext _localctx = new EnumeratorListContext(_ctx, getState()); + enterRule(_localctx, 174, RULE_enumeratorList); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1186); + enumeratorDefinition(); + setState(1191); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,131,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1187); + match(Comma); + setState(1188); + enumeratorDefinition(); + } + } + } + setState(1193); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,131,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EnumeratorDefinitionContext extends ParserRuleContext { + public EnumeratorContext enumerator() { + return getRuleContext(EnumeratorContext.class,0); + } + public TerminalNode Assign() { return getToken(CPP14Parser.Assign, 0); } + public ConstantExpressionContext constantExpression() { + return getRuleContext(ConstantExpressionContext.class,0); + } + public EnumeratorDefinitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enumeratorDefinition; } + } + + public final EnumeratorDefinitionContext enumeratorDefinition() throws RecognitionException { + EnumeratorDefinitionContext _localctx = new EnumeratorDefinitionContext(_ctx, getState()); + enterRule(_localctx, 176, RULE_enumeratorDefinition); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1194); + enumerator(); + setState(1197); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Assign) { + { + setState(1195); + match(Assign); + setState(1196); + constantExpression(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EnumeratorContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); } + public EnumeratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enumerator; } + } + + public final EnumeratorContext enumerator() throws RecognitionException { + EnumeratorContext _localctx = new EnumeratorContext(_ctx, getState()); + enterRule(_localctx, 178, RULE_enumerator); + try { + enterOuterAlt(_localctx, 1); + { + setState(1199); + match(Identifier); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class NamespaceNameContext extends ParserRuleContext { + public OriginalNamespaceNameContext originalNamespaceName() { + return getRuleContext(OriginalNamespaceNameContext.class,0); + } + public NamespaceAliasContext namespaceAlias() { + return getRuleContext(NamespaceAliasContext.class,0); + } + public NamespaceNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_namespaceName; } + } + + public final NamespaceNameContext namespaceName() throws RecognitionException { + NamespaceNameContext _localctx = new NamespaceNameContext(_ctx, getState()); + enterRule(_localctx, 180, RULE_namespaceName); + try { + setState(1203); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,133,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1201); + originalNamespaceName(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1202); + namespaceAlias(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class OriginalNamespaceNameContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); } + public OriginalNamespaceNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_originalNamespaceName; } + } + + public final OriginalNamespaceNameContext originalNamespaceName() throws RecognitionException { + OriginalNamespaceNameContext _localctx = new OriginalNamespaceNameContext(_ctx, getState()); + enterRule(_localctx, 182, RULE_originalNamespaceName); + try { + enterOuterAlt(_localctx, 1); + { + setState(1205); + match(Identifier); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class NamespaceDefinitionContext extends ParserRuleContext { + public DeclarationseqContext namespaceBody; + public TerminalNode Namespace() { return getToken(CPP14Parser.Namespace, 0); } + public TerminalNode LeftBrace() { return getToken(CPP14Parser.LeftBrace, 0); } + public TerminalNode RightBrace() { return getToken(CPP14Parser.RightBrace, 0); } + public TerminalNode Inline() { return getToken(CPP14Parser.Inline, 0); } + public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); } + public OriginalNamespaceNameContext originalNamespaceName() { + return getRuleContext(OriginalNamespaceNameContext.class,0); + } + public DeclarationseqContext declarationseq() { + return getRuleContext(DeclarationseqContext.class,0); + } + public NamespaceDefinitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_namespaceDefinition; } + } + + public final NamespaceDefinitionContext namespaceDefinition() throws RecognitionException { + NamespaceDefinitionContext _localctx = new NamespaceDefinitionContext(_ctx, getState()); + enterRule(_localctx, 184, RULE_namespaceDefinition); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1208); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Inline) { + { + setState(1207); + match(Inline); + } + } + + setState(1210); + match(Namespace); + setState(1213); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,135,_ctx) ) { + case 1: + { + setState(1211); + match(Identifier); + } + break; + case 2: + { + setState(1212); + originalNamespaceName(); + } + break; + } + setState(1215); + match(LeftBrace); + setState(1217); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (Alignas - 10)) | (1L << (Asm - 10)) | (1L << (Auto - 10)) | (1L << (Bool - 10)) | (1L << (Char - 10)) | (1L << (Char16 - 10)) | (1L << (Char32 - 10)) | (1L << (Class - 10)) | (1L << (Const - 10)) | (1L << (Constexpr - 10)) | (1L << (Decltype - 10)) | (1L << (Double - 10)) | (1L << (Enum - 10)) | (1L << (Explicit - 10)) | (1L << (Extern - 10)) | (1L << (Float - 10)) | (1L << (Friend - 10)) | (1L << (Inline - 10)) | (1L << (Int - 10)) | (1L << (Long - 10)) | (1L << (Mutable - 10)) | (1L << (Namespace - 10)) | (1L << (Operator - 10)) | (1L << (Register - 10)) | (1L << (Short - 10)) | (1L << (Signed - 10)) | (1L << (Static - 10)) | (1L << (Static_assert - 10)) | (1L << (Struct - 10)) | (1L << (Template - 10)) | (1L << (Thread_local - 10)))) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (Typedef - 74)) | (1L << (Typename_ - 74)) | (1L << (Union - 74)) | (1L << (Unsigned - 74)) | (1L << (Using - 74)) | (1L << (Virtual - 74)) | (1L << (Void - 74)) | (1L << (Volatile - 74)) | (1L << (Wchar - 74)) | (1L << (LeftParen - 74)) | (1L << (LeftBracket - 74)) | (1L << (Star - 74)) | (1L << (And - 74)) | (1L << (Tilde - 74)) | (1L << (AndAnd - 74)) | (1L << (Doublecolon - 74)) | (1L << (Semi - 74)) | (1L << (Ellipsis - 74)) | (1L << (Identifier - 74)))) != 0)) { + { + setState(1216); + ((NamespaceDefinitionContext)_localctx).namespaceBody = declarationseq(); + } + } + + setState(1219); + match(RightBrace); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class NamespaceAliasContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); } + public NamespaceAliasContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_namespaceAlias; } + } + + public final NamespaceAliasContext namespaceAlias() throws RecognitionException { + NamespaceAliasContext _localctx = new NamespaceAliasContext(_ctx, getState()); + enterRule(_localctx, 186, RULE_namespaceAlias); + try { + enterOuterAlt(_localctx, 1); + { + setState(1221); + match(Identifier); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class NamespaceAliasDefinitionContext extends ParserRuleContext { + public TerminalNode Namespace() { return getToken(CPP14Parser.Namespace, 0); } + public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); } + public TerminalNode Assign() { return getToken(CPP14Parser.Assign, 0); } + public QualifiednamespacespecifierContext qualifiednamespacespecifier() { + return getRuleContext(QualifiednamespacespecifierContext.class,0); + } + public TerminalNode Semi() { return getToken(CPP14Parser.Semi, 0); } + public NamespaceAliasDefinitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_namespaceAliasDefinition; } + } + + public final NamespaceAliasDefinitionContext namespaceAliasDefinition() throws RecognitionException { + NamespaceAliasDefinitionContext _localctx = new NamespaceAliasDefinitionContext(_ctx, getState()); + enterRule(_localctx, 188, RULE_namespaceAliasDefinition); + try { + enterOuterAlt(_localctx, 1); + { + setState(1223); + match(Namespace); + setState(1224); + match(Identifier); + setState(1225); + match(Assign); + setState(1226); + qualifiednamespacespecifier(); + setState(1227); + match(Semi); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class QualifiednamespacespecifierContext extends ParserRuleContext { + public NamespaceNameContext namespaceName() { + return getRuleContext(NamespaceNameContext.class,0); + } + public NestedNameSpecifierContext nestedNameSpecifier() { + return getRuleContext(NestedNameSpecifierContext.class,0); + } + public QualifiednamespacespecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_qualifiednamespacespecifier; } + } + + public final QualifiednamespacespecifierContext qualifiednamespacespecifier() throws RecognitionException { + QualifiednamespacespecifierContext _localctx = new QualifiednamespacespecifierContext(_ctx, getState()); + enterRule(_localctx, 190, RULE_qualifiednamespacespecifier); + try { + enterOuterAlt(_localctx, 1); + { + setState(1230); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,137,_ctx) ) { + case 1: + { + setState(1229); + nestedNameSpecifier(0); + } + break; + } + setState(1232); + namespaceName(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UsingDeclarationContext extends ParserRuleContext { + public TerminalNode Using() { return getToken(CPP14Parser.Using, 0); } + public UnqualifiedIdContext unqualifiedId() { + return getRuleContext(UnqualifiedIdContext.class,0); + } + public TerminalNode Semi() { return getToken(CPP14Parser.Semi, 0); } + public TerminalNode Doublecolon() { return getToken(CPP14Parser.Doublecolon, 0); } + public NestedNameSpecifierContext nestedNameSpecifier() { + return getRuleContext(NestedNameSpecifierContext.class,0); + } + public TerminalNode Typename_() { return getToken(CPP14Parser.Typename_, 0); } + public UsingDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_usingDeclaration; } + } + + public final UsingDeclarationContext usingDeclaration() throws RecognitionException { + UsingDeclarationContext _localctx = new UsingDeclarationContext(_ctx, getState()); + enterRule(_localctx, 192, RULE_usingDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1234); + match(Using); + setState(1240); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,139,_ctx) ) { + case 1: + { + { + setState(1236); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Typename_) { + { + setState(1235); + match(Typename_); + } + } + + setState(1238); + nestedNameSpecifier(0); + } + } + break; + case 2: + { + setState(1239); + match(Doublecolon); + } + break; + } + setState(1242); + unqualifiedId(); + setState(1243); + match(Semi); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class UsingDirectiveContext extends ParserRuleContext { + public TerminalNode Using() { return getToken(CPP14Parser.Using, 0); } + public TerminalNode Namespace() { return getToken(CPP14Parser.Namespace, 0); } + public NamespaceNameContext namespaceName() { + return getRuleContext(NamespaceNameContext.class,0); + } + public TerminalNode Semi() { return getToken(CPP14Parser.Semi, 0); } + public AttributeSpecifierSeqContext attributeSpecifierSeq() { + return getRuleContext(AttributeSpecifierSeqContext.class,0); + } + public NestedNameSpecifierContext nestedNameSpecifier() { + return getRuleContext(NestedNameSpecifierContext.class,0); + } + public UsingDirectiveContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_usingDirective; } + } + + public final UsingDirectiveContext usingDirective() throws RecognitionException { + UsingDirectiveContext _localctx = new UsingDirectiveContext(_ctx, getState()); + enterRule(_localctx, 194, RULE_usingDirective); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1246); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Alignas || _la==LeftBracket) { + { + setState(1245); + attributeSpecifierSeq(); + } + } + + setState(1248); + match(Using); + setState(1249); + match(Namespace); + setState(1251); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,141,_ctx) ) { + case 1: + { + setState(1250); + nestedNameSpecifier(0); + } + break; + } + setState(1253); + namespaceName(); + setState(1254); + match(Semi); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AsmDefinitionContext extends ParserRuleContext { + public TerminalNode Asm() { return getToken(CPP14Parser.Asm, 0); } + public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); } + public TerminalNode StringLiteral() { return getToken(CPP14Parser.StringLiteral, 0); } + public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); } + public TerminalNode Semi() { return getToken(CPP14Parser.Semi, 0); } + public AsmDefinitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_asmDefinition; } + } + + public final AsmDefinitionContext asmDefinition() throws RecognitionException { + AsmDefinitionContext _localctx = new AsmDefinitionContext(_ctx, getState()); + enterRule(_localctx, 196, RULE_asmDefinition); + try { + enterOuterAlt(_localctx, 1); + { + setState(1256); + match(Asm); + setState(1257); + match(LeftParen); + setState(1258); + match(StringLiteral); + setState(1259); + match(RightParen); + setState(1260); + match(Semi); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LinkageSpecificationContext extends ParserRuleContext { + public TerminalNode Extern() { return getToken(CPP14Parser.Extern, 0); } + public TerminalNode StringLiteral() { return getToken(CPP14Parser.StringLiteral, 0); } + public TerminalNode LeftBrace() { return getToken(CPP14Parser.LeftBrace, 0); } + public TerminalNode RightBrace() { return getToken(CPP14Parser.RightBrace, 0); } + public DeclarationContext declaration() { + return getRuleContext(DeclarationContext.class,0); + } + public DeclarationseqContext declarationseq() { + return getRuleContext(DeclarationseqContext.class,0); + } + public LinkageSpecificationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_linkageSpecification; } + } + + public final LinkageSpecificationContext linkageSpecification() throws RecognitionException { + LinkageSpecificationContext _localctx = new LinkageSpecificationContext(_ctx, getState()); + enterRule(_localctx, 198, RULE_linkageSpecification); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1262); + match(Extern); + setState(1263); + match(StringLiteral); + setState(1270); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LeftBrace: + { + setState(1264); + match(LeftBrace); + setState(1266); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (Alignas - 10)) | (1L << (Asm - 10)) | (1L << (Auto - 10)) | (1L << (Bool - 10)) | (1L << (Char - 10)) | (1L << (Char16 - 10)) | (1L << (Char32 - 10)) | (1L << (Class - 10)) | (1L << (Const - 10)) | (1L << (Constexpr - 10)) | (1L << (Decltype - 10)) | (1L << (Double - 10)) | (1L << (Enum - 10)) | (1L << (Explicit - 10)) | (1L << (Extern - 10)) | (1L << (Float - 10)) | (1L << (Friend - 10)) | (1L << (Inline - 10)) | (1L << (Int - 10)) | (1L << (Long - 10)) | (1L << (Mutable - 10)) | (1L << (Namespace - 10)) | (1L << (Operator - 10)) | (1L << (Register - 10)) | (1L << (Short - 10)) | (1L << (Signed - 10)) | (1L << (Static - 10)) | (1L << (Static_assert - 10)) | (1L << (Struct - 10)) | (1L << (Template - 10)) | (1L << (Thread_local - 10)))) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (Typedef - 74)) | (1L << (Typename_ - 74)) | (1L << (Union - 74)) | (1L << (Unsigned - 74)) | (1L << (Using - 74)) | (1L << (Virtual - 74)) | (1L << (Void - 74)) | (1L << (Volatile - 74)) | (1L << (Wchar - 74)) | (1L << (LeftParen - 74)) | (1L << (LeftBracket - 74)) | (1L << (Star - 74)) | (1L << (And - 74)) | (1L << (Tilde - 74)) | (1L << (AndAnd - 74)) | (1L << (Doublecolon - 74)) | (1L << (Semi - 74)) | (1L << (Ellipsis - 74)) | (1L << (Identifier - 74)))) != 0)) { + { + setState(1265); + declarationseq(); + } + } + + setState(1268); + match(RightBrace); + } + break; + case Alignas: + case Asm: + case Auto: + case Bool: + case Char: + case Char16: + case Char32: + case Class: + case Const: + case Constexpr: + case Decltype: + case Double: + case Enum: + case Explicit: + case Extern: + case Float: + case Friend: + case Inline: + case Int: + case Long: + case Mutable: + case Namespace: + case Operator: + case Register: + case Short: + case Signed: + case Static: + case Static_assert: + case Struct: + case Template: + case Thread_local: + case Typedef: + case Typename_: + case Union: + case Unsigned: + case Using: + case Virtual: + case Void: + case Volatile: + case Wchar: + case LeftParen: + case LeftBracket: + case Star: + case And: + case Tilde: + case AndAnd: + case Doublecolon: + case Semi: + case Ellipsis: + case Identifier: + { + setState(1269); + declaration(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AttributeSpecifierSeqContext extends ParserRuleContext { + public List attributeSpecifier() { + return getRuleContexts(AttributeSpecifierContext.class); + } + public AttributeSpecifierContext attributeSpecifier(int i) { + return getRuleContext(AttributeSpecifierContext.class,i); + } + public AttributeSpecifierSeqContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_attributeSpecifierSeq; } + } + + public final AttributeSpecifierSeqContext attributeSpecifierSeq() throws RecognitionException { + AttributeSpecifierSeqContext _localctx = new AttributeSpecifierSeqContext(_ctx, getState()); + enterRule(_localctx, 200, RULE_attributeSpecifierSeq); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1273); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(1272); + attributeSpecifier(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1275); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,144,_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; + } + + public static class AttributeSpecifierContext extends ParserRuleContext { + public List LeftBracket() { return getTokens(CPP14Parser.LeftBracket); } + public TerminalNode LeftBracket(int i) { + return getToken(CPP14Parser.LeftBracket, i); + } + public List RightBracket() { return getTokens(CPP14Parser.RightBracket); } + public TerminalNode RightBracket(int i) { + return getToken(CPP14Parser.RightBracket, i); + } + public AttributeListContext attributeList() { + return getRuleContext(AttributeListContext.class,0); + } + public AlignmentspecifierContext alignmentspecifier() { + return getRuleContext(AlignmentspecifierContext.class,0); + } + public AttributeSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_attributeSpecifier; } + } + + public final AttributeSpecifierContext attributeSpecifier() throws RecognitionException { + AttributeSpecifierContext _localctx = new AttributeSpecifierContext(_ctx, getState()); + enterRule(_localctx, 202, RULE_attributeSpecifier); + int _la; + try { + setState(1285); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LeftBracket: + enterOuterAlt(_localctx, 1); + { + setState(1277); + match(LeftBracket); + setState(1278); + match(LeftBracket); + setState(1280); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Identifier) { + { + setState(1279); + attributeList(); + } + } + + setState(1282); + match(RightBracket); + setState(1283); + match(RightBracket); + } + break; + case Alignas: + enterOuterAlt(_localctx, 2); + { + setState(1284); + alignmentspecifier(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AlignmentspecifierContext extends ParserRuleContext { + public TerminalNode Alignas() { return getToken(CPP14Parser.Alignas, 0); } + public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); } + public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); } + public TheTypeIdContext theTypeId() { + return getRuleContext(TheTypeIdContext.class,0); + } + public ConstantExpressionContext constantExpression() { + return getRuleContext(ConstantExpressionContext.class,0); + } + public TerminalNode Ellipsis() { return getToken(CPP14Parser.Ellipsis, 0); } + public AlignmentspecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_alignmentspecifier; } + } + + public final AlignmentspecifierContext alignmentspecifier() throws RecognitionException { + AlignmentspecifierContext _localctx = new AlignmentspecifierContext(_ctx, getState()); + enterRule(_localctx, 204, RULE_alignmentspecifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1287); + match(Alignas); + setState(1288); + match(LeftParen); + setState(1291); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,147,_ctx) ) { + case 1: + { + setState(1289); + theTypeId(); + } + break; + case 2: + { + setState(1290); + constantExpression(); + } + break; + } + setState(1294); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Ellipsis) { + { + setState(1293); + match(Ellipsis); + } + } + + setState(1296); + match(RightParen); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AttributeListContext extends ParserRuleContext { + public List attribute() { + return getRuleContexts(AttributeContext.class); + } + public AttributeContext attribute(int i) { + return getRuleContext(AttributeContext.class,i); + } + public List Comma() { return getTokens(CPP14Parser.Comma); } + public TerminalNode Comma(int i) { + return getToken(CPP14Parser.Comma, i); + } + public TerminalNode Ellipsis() { return getToken(CPP14Parser.Ellipsis, 0); } + public AttributeListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_attributeList; } + } + + public final AttributeListContext attributeList() throws RecognitionException { + AttributeListContext _localctx = new AttributeListContext(_ctx, getState()); + enterRule(_localctx, 206, RULE_attributeList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1298); + attribute(); + setState(1303); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(1299); + match(Comma); + setState(1300); + attribute(); + } + } + setState(1305); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1307); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Ellipsis) { + { + setState(1306); + match(Ellipsis); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AttributeContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); } + public AttributeNamespaceContext attributeNamespace() { + return getRuleContext(AttributeNamespaceContext.class,0); + } + public TerminalNode Doublecolon() { return getToken(CPP14Parser.Doublecolon, 0); } + public AttributeArgumentClauseContext attributeArgumentClause() { + return getRuleContext(AttributeArgumentClauseContext.class,0); + } + public AttributeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_attribute; } + } + + public final AttributeContext attribute() throws RecognitionException { + AttributeContext _localctx = new AttributeContext(_ctx, getState()); + enterRule(_localctx, 208, RULE_attribute); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1312); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,151,_ctx) ) { + case 1: + { + setState(1309); + attributeNamespace(); + setState(1310); + match(Doublecolon); + } + break; + } + setState(1314); + match(Identifier); + setState(1316); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LeftParen) { + { + setState(1315); + attributeArgumentClause(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AttributeNamespaceContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); } + public AttributeNamespaceContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_attributeNamespace; } + } + + public final AttributeNamespaceContext attributeNamespace() throws RecognitionException { + AttributeNamespaceContext _localctx = new AttributeNamespaceContext(_ctx, getState()); + enterRule(_localctx, 210, RULE_attributeNamespace); + try { + enterOuterAlt(_localctx, 1); + { + setState(1318); + match(Identifier); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AttributeArgumentClauseContext extends ParserRuleContext { + public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); } + public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); } + public BalancedTokenSeqContext balancedTokenSeq() { + return getRuleContext(BalancedTokenSeqContext.class,0); + } + public AttributeArgumentClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_attributeArgumentClause; } + } + + public final AttributeArgumentClauseContext attributeArgumentClause() throws RecognitionException { + AttributeArgumentClauseContext _localctx = new AttributeArgumentClauseContext(_ctx, getState()); + enterRule(_localctx, 212, RULE_attributeArgumentClause); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1320); + match(LeftParen); + setState(1322); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << MultiLineMacro) | (1L << Directive) | (1L << Alignas) | (1L << Alignof) | (1L << Asm) | (1L << Auto) | (1L << Bool) | (1L << Break) | (1L << Case) | (1L << Catch) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Class) | (1L << Const) | (1L << Constexpr) | (1L << Const_cast) | (1L << Continue) | (1L << Decltype) | (1L << Default) | (1L << Delete) | (1L << Do) | (1L << Double) | (1L << Dynamic_cast) | (1L << Else) | (1L << Enum) | (1L << Explicit) | (1L << Export) | (1L << Extern) | (1L << False_) | (1L << Final) | (1L << Float) | (1L << For) | (1L << Friend) | (1L << Goto) | (1L << If) | (1L << Inline) | (1L << Int) | (1L << Long) | (1L << Mutable) | (1L << Namespace) | (1L << New) | (1L << Noexcept) | (1L << Nullptr) | (1L << Operator) | (1L << Override) | (1L << Private) | (1L << Protected) | (1L << Public) | (1L << Register) | (1L << Reinterpret_cast) | (1L << Return) | (1L << Short) | (1L << Signed) | (1L << Sizeof) | (1L << Static))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (Static_assert - 64)) | (1L << (Static_cast - 64)) | (1L << (Struct - 64)) | (1L << (Switch - 64)) | (1L << (Template - 64)) | (1L << (This - 64)) | (1L << (Thread_local - 64)) | (1L << (Throw - 64)) | (1L << (True_ - 64)) | (1L << (Try - 64)) | (1L << (Typedef - 64)) | (1L << (Typeid_ - 64)) | (1L << (Typename_ - 64)) | (1L << (Union - 64)) | (1L << (Unsigned - 64)) | (1L << (Using - 64)) | (1L << (Virtual - 64)) | (1L << (Void - 64)) | (1L << (Volatile - 64)) | (1L << (Wchar - 64)) | (1L << (While - 64)) | (1L << (LeftParen - 64)) | (1L << (LeftBracket - 64)) | (1L << (LeftBrace - 64)) | (1L << (Plus - 64)) | (1L << (Minus - 64)) | (1L << (Star - 64)) | (1L << (Div - 64)) | (1L << (Mod - 64)) | (1L << (Caret - 64)) | (1L << (And - 64)) | (1L << (Or - 64)) | (1L << (Tilde - 64)) | (1L << (Not - 64)) | (1L << (Assign - 64)) | (1L << (Less - 64)) | (1L << (Greater - 64)) | (1L << (PlusAssign - 64)) | (1L << (MinusAssign - 64)) | (1L << (StarAssign - 64)) | (1L << (DivAssign - 64)) | (1L << (ModAssign - 64)) | (1L << (XorAssign - 64)) | (1L << (AndAssign - 64)) | (1L << (OrAssign - 64)) | (1L << (LeftShiftAssign - 64)) | (1L << (RightShiftAssign - 64)) | (1L << (Equal - 64)) | (1L << (NotEqual - 64)) | (1L << (LessEqual - 64)) | (1L << (GreaterEqual - 64)) | (1L << (AndAnd - 64)) | (1L << (OrOr - 64)) | (1L << (PlusPlus - 64)) | (1L << (MinusMinus - 64)) | (1L << (Comma - 64)) | (1L << (ArrowStar - 64)) | (1L << (Arrow - 64)) | (1L << (Question - 64)) | (1L << (Colon - 64)) | (1L << (Doublecolon - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (Semi - 128)) | (1L << (Dot - 128)) | (1L << (DotStar - 128)) | (1L << (Ellipsis - 128)) | (1L << (Identifier - 128)) | (1L << (DecimalLiteral - 128)) | (1L << (OctalLiteral - 128)) | (1L << (HexadecimalLiteral - 128)) | (1L << (BinaryLiteral - 128)) | (1L << (Integersuffix - 128)) | (1L << (UserDefinedIntegerLiteral - 128)) | (1L << (UserDefinedFloatingLiteral - 128)) | (1L << (UserDefinedStringLiteral - 128)) | (1L << (UserDefinedCharacterLiteral - 128)) | (1L << (Whitespace - 128)) | (1L << (Newline - 128)) | (1L << (BlockComment - 128)) | (1L << (LineComment - 128)))) != 0)) { + { + setState(1321); + balancedTokenSeq(); + } + } + + setState(1324); + match(RightParen); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class BalancedTokenSeqContext extends ParserRuleContext { + public List balancedtoken() { + return getRuleContexts(BalancedtokenContext.class); + } + public BalancedtokenContext balancedtoken(int i) { + return getRuleContext(BalancedtokenContext.class,i); + } + public BalancedTokenSeqContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_balancedTokenSeq; } + } + + public final BalancedTokenSeqContext balancedTokenSeq() throws RecognitionException { + BalancedTokenSeqContext _localctx = new BalancedTokenSeqContext(_ctx, getState()); + enterRule(_localctx, 214, RULE_balancedTokenSeq); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1327); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1326); + balancedtoken(); + } + } + setState(1329); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << MultiLineMacro) | (1L << Directive) | (1L << Alignas) | (1L << Alignof) | (1L << Asm) | (1L << Auto) | (1L << Bool) | (1L << Break) | (1L << Case) | (1L << Catch) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Class) | (1L << Const) | (1L << Constexpr) | (1L << Const_cast) | (1L << Continue) | (1L << Decltype) | (1L << Default) | (1L << Delete) | (1L << Do) | (1L << Double) | (1L << Dynamic_cast) | (1L << Else) | (1L << Enum) | (1L << Explicit) | (1L << Export) | (1L << Extern) | (1L << False_) | (1L << Final) | (1L << Float) | (1L << For) | (1L << Friend) | (1L << Goto) | (1L << If) | (1L << Inline) | (1L << Int) | (1L << Long) | (1L << Mutable) | (1L << Namespace) | (1L << New) | (1L << Noexcept) | (1L << Nullptr) | (1L << Operator) | (1L << Override) | (1L << Private) | (1L << Protected) | (1L << Public) | (1L << Register) | (1L << Reinterpret_cast) | (1L << Return) | (1L << Short) | (1L << Signed) | (1L << Sizeof) | (1L << Static))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (Static_assert - 64)) | (1L << (Static_cast - 64)) | (1L << (Struct - 64)) | (1L << (Switch - 64)) | (1L << (Template - 64)) | (1L << (This - 64)) | (1L << (Thread_local - 64)) | (1L << (Throw - 64)) | (1L << (True_ - 64)) | (1L << (Try - 64)) | (1L << (Typedef - 64)) | (1L << (Typeid_ - 64)) | (1L << (Typename_ - 64)) | (1L << (Union - 64)) | (1L << (Unsigned - 64)) | (1L << (Using - 64)) | (1L << (Virtual - 64)) | (1L << (Void - 64)) | (1L << (Volatile - 64)) | (1L << (Wchar - 64)) | (1L << (While - 64)) | (1L << (LeftParen - 64)) | (1L << (LeftBracket - 64)) | (1L << (LeftBrace - 64)) | (1L << (Plus - 64)) | (1L << (Minus - 64)) | (1L << (Star - 64)) | (1L << (Div - 64)) | (1L << (Mod - 64)) | (1L << (Caret - 64)) | (1L << (And - 64)) | (1L << (Or - 64)) | (1L << (Tilde - 64)) | (1L << (Not - 64)) | (1L << (Assign - 64)) | (1L << (Less - 64)) | (1L << (Greater - 64)) | (1L << (PlusAssign - 64)) | (1L << (MinusAssign - 64)) | (1L << (StarAssign - 64)) | (1L << (DivAssign - 64)) | (1L << (ModAssign - 64)) | (1L << (XorAssign - 64)) | (1L << (AndAssign - 64)) | (1L << (OrAssign - 64)) | (1L << (LeftShiftAssign - 64)) | (1L << (RightShiftAssign - 64)) | (1L << (Equal - 64)) | (1L << (NotEqual - 64)) | (1L << (LessEqual - 64)) | (1L << (GreaterEqual - 64)) | (1L << (AndAnd - 64)) | (1L << (OrOr - 64)) | (1L << (PlusPlus - 64)) | (1L << (MinusMinus - 64)) | (1L << (Comma - 64)) | (1L << (ArrowStar - 64)) | (1L << (Arrow - 64)) | (1L << (Question - 64)) | (1L << (Colon - 64)) | (1L << (Doublecolon - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (Semi - 128)) | (1L << (Dot - 128)) | (1L << (DotStar - 128)) | (1L << (Ellipsis - 128)) | (1L << (Identifier - 128)) | (1L << (DecimalLiteral - 128)) | (1L << (OctalLiteral - 128)) | (1L << (HexadecimalLiteral - 128)) | (1L << (BinaryLiteral - 128)) | (1L << (Integersuffix - 128)) | (1L << (UserDefinedIntegerLiteral - 128)) | (1L << (UserDefinedFloatingLiteral - 128)) | (1L << (UserDefinedStringLiteral - 128)) | (1L << (UserDefinedCharacterLiteral - 128)) | (1L << (Whitespace - 128)) | (1L << (Newline - 128)) | (1L << (BlockComment - 128)) | (1L << (LineComment - 128)))) != 0) ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class BalancedtokenContext extends ParserRuleContext { + public List LeftParen() { return getTokens(CPP14Parser.LeftParen); } + public TerminalNode LeftParen(int i) { + return getToken(CPP14Parser.LeftParen, i); + } + public BalancedTokenSeqContext balancedTokenSeq() { + return getRuleContext(BalancedTokenSeqContext.class,0); + } + public List RightParen() { return getTokens(CPP14Parser.RightParen); } + public TerminalNode RightParen(int i) { + return getToken(CPP14Parser.RightParen, i); + } + public List LeftBracket() { return getTokens(CPP14Parser.LeftBracket); } + public TerminalNode LeftBracket(int i) { + return getToken(CPP14Parser.LeftBracket, i); + } + public List RightBracket() { return getTokens(CPP14Parser.RightBracket); } + public TerminalNode RightBracket(int i) { + return getToken(CPP14Parser.RightBracket, i); + } + public List LeftBrace() { return getTokens(CPP14Parser.LeftBrace); } + public TerminalNode LeftBrace(int i) { + return getToken(CPP14Parser.LeftBrace, i); + } + public List RightBrace() { return getTokens(CPP14Parser.RightBrace); } + public TerminalNode RightBrace(int i) { + return getToken(CPP14Parser.RightBrace, i); + } + public BalancedtokenContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_balancedtoken; } + } + + public final BalancedtokenContext balancedtoken() throws RecognitionException { + BalancedtokenContext _localctx = new BalancedtokenContext(_ctx, getState()); + enterRule(_localctx, 216, RULE_balancedtoken); + int _la; + try { + int _alt; + setState(1348); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LeftParen: + enterOuterAlt(_localctx, 1); + { + setState(1331); + match(LeftParen); + setState(1332); + balancedTokenSeq(); + setState(1333); + match(RightParen); + } + break; + case LeftBracket: + enterOuterAlt(_localctx, 2); + { + setState(1335); + match(LeftBracket); + setState(1336); + balancedTokenSeq(); + setState(1337); + match(RightBracket); + } + break; + case LeftBrace: + enterOuterAlt(_localctx, 3); + { + setState(1339); + match(LeftBrace); + setState(1340); + balancedTokenSeq(); + setState(1341); + match(RightBrace); + } + break; + case IntegerLiteral: + case CharacterLiteral: + case FloatingLiteral: + case StringLiteral: + case BooleanLiteral: + case PointerLiteral: + case UserDefinedLiteral: + case MultiLineMacro: + case Directive: + case Alignas: + case Alignof: + case Asm: + case Auto: + case Bool: + case Break: + case Case: + case Catch: + case Char: + case Char16: + case Char32: + case Class: + case Const: + case Constexpr: + case Const_cast: + case Continue: + case Decltype: + case Default: + case Delete: + case Do: + case Double: + case Dynamic_cast: + case Else: + case Enum: + case Explicit: + case Export: + case Extern: + case False_: + case Final: + case Float: + case For: + case Friend: + case Goto: + case If: + case Inline: + case Int: + case Long: + case Mutable: + case Namespace: + case New: + case Noexcept: + case Nullptr: + case Operator: + case Override: + case Private: + case Protected: + case Public: + case Register: + case Reinterpret_cast: + case Return: + case Short: + case Signed: + case Sizeof: + case Static: + case Static_assert: + case Static_cast: + case Struct: + case Switch: + case Template: + case This: + case Thread_local: + case Throw: + case True_: + case Try: + case Typedef: + case Typeid_: + case Typename_: + case Union: + case Unsigned: + case Using: + case Virtual: + case Void: + case Volatile: + case Wchar: + case While: + case Plus: + case Minus: + case Star: + case Div: + case Mod: + case Caret: + case And: + case Or: + case Tilde: + case Not: + case Assign: + case Less: + case Greater: + case PlusAssign: + case MinusAssign: + case StarAssign: + case DivAssign: + case ModAssign: + case XorAssign: + case AndAssign: + case OrAssign: + case LeftShiftAssign: + case RightShiftAssign: + case Equal: + case NotEqual: + case LessEqual: + case GreaterEqual: + case AndAnd: + case OrOr: + case PlusPlus: + case MinusMinus: + case Comma: + case ArrowStar: + case Arrow: + case Question: + case Colon: + case Doublecolon: + case Semi: + case Dot: + case DotStar: + case Ellipsis: + case Identifier: + case DecimalLiteral: + case OctalLiteral: + case HexadecimalLiteral: + case BinaryLiteral: + case Integersuffix: + case UserDefinedIntegerLiteral: + case UserDefinedFloatingLiteral: + case UserDefinedStringLiteral: + case UserDefinedCharacterLiteral: + case Whitespace: + case Newline: + case BlockComment: + case LineComment: + enterOuterAlt(_localctx, 4); + { + setState(1344); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(1343); + _la = _input.LA(1); + if ( _la <= 0 || (((((_la - 85)) & ~0x3f) == 0 && ((1L << (_la - 85)) & ((1L << (LeftParen - 85)) | (1L << (RightParen - 85)) | (1L << (LeftBracket - 85)) | (1L << (RightBracket - 85)) | (1L << (LeftBrace - 85)) | (1L << (RightBrace - 85)))) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1346); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,155,_ctx); + } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InitDeclaratorListContext extends ParserRuleContext { + public List initDeclarator() { + return getRuleContexts(InitDeclaratorContext.class); + } + public InitDeclaratorContext initDeclarator(int i) { + return getRuleContext(InitDeclaratorContext.class,i); + } + public List Comma() { return getTokens(CPP14Parser.Comma); } + public TerminalNode Comma(int i) { + return getToken(CPP14Parser.Comma, i); + } + public InitDeclaratorListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_initDeclaratorList; } + } + + public final InitDeclaratorListContext initDeclaratorList() throws RecognitionException { + InitDeclaratorListContext _localctx = new InitDeclaratorListContext(_ctx, getState()); + enterRule(_localctx, 218, RULE_initDeclaratorList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1350); + initDeclarator(); + setState(1355); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(1351); + match(Comma); + setState(1352); + initDeclarator(); + } + } + setState(1357); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InitDeclaratorContext extends ParserRuleContext { + public DeclaratorContext declarator() { + return getRuleContext(DeclaratorContext.class,0); + } + public InitializerContext initializer() { + return getRuleContext(InitializerContext.class,0); + } + public InitDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_initDeclarator; } + } + + public final InitDeclaratorContext initDeclarator() throws RecognitionException { + InitDeclaratorContext _localctx = new InitDeclaratorContext(_ctx, getState()); + enterRule(_localctx, 220, RULE_initDeclarator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1358); + declarator(); + setState(1360); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 85)) & ~0x3f) == 0 && ((1L << (_la - 85)) & ((1L << (LeftParen - 85)) | (1L << (LeftBrace - 85)) | (1L << (Assign - 85)))) != 0)) { + { + setState(1359); + initializer(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class DeclaratorContext extends ParserRuleContext { + public PointerDeclaratorContext pointerDeclarator() { + return getRuleContext(PointerDeclaratorContext.class,0); + } + public NoPointerDeclaratorContext noPointerDeclarator() { + return getRuleContext(NoPointerDeclaratorContext.class,0); + } + public ParametersAndQualifiersContext parametersAndQualifiers() { + return getRuleContext(ParametersAndQualifiersContext.class,0); + } + public TrailingReturnTypeContext trailingReturnType() { + return getRuleContext(TrailingReturnTypeContext.class,0); + } + public DeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_declarator; } + } + + public final DeclaratorContext declarator() throws RecognitionException { + DeclaratorContext _localctx = new DeclaratorContext(_ctx, getState()); + enterRule(_localctx, 222, RULE_declarator); + try { + setState(1367); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1362); + pointerDeclarator(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1363); + noPointerDeclarator(0); + setState(1364); + parametersAndQualifiers(); + setState(1365); + trailingReturnType(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PointerDeclaratorContext extends ParserRuleContext { + public NoPointerDeclaratorContext noPointerDeclarator() { + return getRuleContext(NoPointerDeclaratorContext.class,0); + } + public List pointerOperator() { + return getRuleContexts(PointerOperatorContext.class); + } + public PointerOperatorContext pointerOperator(int i) { + return getRuleContext(PointerOperatorContext.class,i); + } + public List Const() { return getTokens(CPP14Parser.Const); } + public TerminalNode Const(int i) { + return getToken(CPP14Parser.Const, i); + } + public PointerDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_pointerDeclarator; } + } + + public final PointerDeclaratorContext pointerDeclarator() throws RecognitionException { + PointerDeclaratorContext _localctx = new PointerDeclaratorContext(_ctx, getState()); + enterRule(_localctx, 224, RULE_pointerDeclarator); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1375); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,161,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1369); + pointerOperator(); + setState(1371); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Const) { + { + setState(1370); + match(Const); + } + } + + } + } + } + setState(1377); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,161,_ctx); + } + setState(1378); + noPointerDeclarator(0); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class NoPointerDeclaratorContext extends ParserRuleContext { + public DeclaratoridContext declaratorid() { + return getRuleContext(DeclaratoridContext.class,0); + } + public AttributeSpecifierSeqContext attributeSpecifierSeq() { + return getRuleContext(AttributeSpecifierSeqContext.class,0); + } + public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); } + public PointerDeclaratorContext pointerDeclarator() { + return getRuleContext(PointerDeclaratorContext.class,0); + } + public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); } + public NoPointerDeclaratorContext noPointerDeclarator() { + return getRuleContext(NoPointerDeclaratorContext.class,0); + } + public ParametersAndQualifiersContext parametersAndQualifiers() { + return getRuleContext(ParametersAndQualifiersContext.class,0); + } + public TerminalNode LeftBracket() { return getToken(CPP14Parser.LeftBracket, 0); } + public TerminalNode RightBracket() { return getToken(CPP14Parser.RightBracket, 0); } + public ConstantExpressionContext constantExpression() { + return getRuleContext(ConstantExpressionContext.class,0); + } + public NoPointerDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_noPointerDeclarator; } + } + + public final NoPointerDeclaratorContext noPointerDeclarator() throws RecognitionException { + return noPointerDeclarator(0); + } + + private NoPointerDeclaratorContext noPointerDeclarator(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + NoPointerDeclaratorContext _localctx = new NoPointerDeclaratorContext(_ctx, _parentState); + NoPointerDeclaratorContext _prevctx = _localctx; + int _startState = 226; + enterRecursionRule(_localctx, 226, RULE_noPointerDeclarator, _p); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1389); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Decltype: + case Operator: + case Tilde: + case Doublecolon: + case Ellipsis: + case Identifier: + { + setState(1381); + declaratorid(); + setState(1383); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,162,_ctx) ) { + case 1: + { + setState(1382); + attributeSpecifierSeq(); + } + break; + } + } + break; + case LeftParen: + { + setState(1385); + match(LeftParen); + setState(1386); + pointerDeclarator(); + setState(1387); + match(RightParen); + } + break; + default: + throw new NoViableAltException(this); + } + _ctx.stop = _input.LT(-1); + setState(1405); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,167,_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 NoPointerDeclaratorContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_noPointerDeclarator); + setState(1391); + if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(1401); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LeftParen: + { + setState(1392); + parametersAndQualifiers(); + } + break; + case LeftBracket: + { + setState(1393); + match(LeftBracket); + setState(1395); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (Static_cast - 65)) | (1L << (This - 65)) | (1L << (Typeid_ - 65)) | (1L << (Typename_ - 65)) | (1L << (Unsigned - 65)) | (1L << (Void - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)))) != 0) || _la==Identifier) { + { + setState(1394); + constantExpression(); + } + } + + setState(1397); + match(RightBracket); + setState(1399); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,165,_ctx) ) { + case 1: + { + setState(1398); + attributeSpecifierSeq(); + } + break; + } + } + break; + default: + throw new NoViableAltException(this); + } + } + } + } + setState(1407); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,167,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class ParametersAndQualifiersContext extends ParserRuleContext { + public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); } + public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); } + public ParameterDeclarationClauseContext parameterDeclarationClause() { + return getRuleContext(ParameterDeclarationClauseContext.class,0); + } + public CvqualifierseqContext cvqualifierseq() { + return getRuleContext(CvqualifierseqContext.class,0); + } + public RefqualifierContext refqualifier() { + return getRuleContext(RefqualifierContext.class,0); + } + public ExceptionSpecificationContext exceptionSpecification() { + return getRuleContext(ExceptionSpecificationContext.class,0); + } + public AttributeSpecifierSeqContext attributeSpecifierSeq() { + return getRuleContext(AttributeSpecifierSeqContext.class,0); + } + public ParametersAndQualifiersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_parametersAndQualifiers; } + } + + public final ParametersAndQualifiersContext parametersAndQualifiers() throws RecognitionException { + ParametersAndQualifiersContext _localctx = new ParametersAndQualifiersContext(_ctx, getState()); + enterRule(_localctx, 228, RULE_parametersAndQualifiers); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1408); + match(LeftParen); + setState(1410); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (Alignas - 10)) | (1L << (Auto - 10)) | (1L << (Bool - 10)) | (1L << (Char - 10)) | (1L << (Char16 - 10)) | (1L << (Char32 - 10)) | (1L << (Class - 10)) | (1L << (Const - 10)) | (1L << (Constexpr - 10)) | (1L << (Decltype - 10)) | (1L << (Double - 10)) | (1L << (Enum - 10)) | (1L << (Explicit - 10)) | (1L << (Extern - 10)) | (1L << (Float - 10)) | (1L << (Friend - 10)) | (1L << (Inline - 10)) | (1L << (Int - 10)) | (1L << (Long - 10)) | (1L << (Mutable - 10)) | (1L << (Register - 10)) | (1L << (Short - 10)) | (1L << (Signed - 10)) | (1L << (Static - 10)) | (1L << (Struct - 10)) | (1L << (Thread_local - 10)))) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (Typedef - 74)) | (1L << (Typename_ - 74)) | (1L << (Union - 74)) | (1L << (Unsigned - 74)) | (1L << (Virtual - 74)) | (1L << (Void - 74)) | (1L << (Volatile - 74)) | (1L << (Wchar - 74)) | (1L << (LeftBracket - 74)) | (1L << (Doublecolon - 74)) | (1L << (Identifier - 74)))) != 0)) { + { + setState(1409); + parameterDeclarationClause(); + } + } + + setState(1412); + match(RightParen); + setState(1414); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,169,_ctx) ) { + case 1: + { + setState(1413); + cvqualifierseq(); + } + break; + } + setState(1417); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,170,_ctx) ) { + case 1: + { + setState(1416); + refqualifier(); + } + break; + } + setState(1420); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,171,_ctx) ) { + case 1: + { + setState(1419); + exceptionSpecification(); + } + break; + } + setState(1423); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,172,_ctx) ) { + case 1: + { + setState(1422); + attributeSpecifierSeq(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TrailingReturnTypeContext extends ParserRuleContext { + public TerminalNode Arrow() { return getToken(CPP14Parser.Arrow, 0); } + public TrailingTypeSpecifierSeqContext trailingTypeSpecifierSeq() { + return getRuleContext(TrailingTypeSpecifierSeqContext.class,0); + } + public AbstractDeclaratorContext abstractDeclarator() { + return getRuleContext(AbstractDeclaratorContext.class,0); + } + public TrailingReturnTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_trailingReturnType; } + } + + public final TrailingReturnTypeContext trailingReturnType() throws RecognitionException { + TrailingReturnTypeContext _localctx = new TrailingReturnTypeContext(_ctx, getState()); + enterRule(_localctx, 230, RULE_trailingReturnType); + try { + enterOuterAlt(_localctx, 1); + { + setState(1425); + match(Arrow); + setState(1426); + trailingTypeSpecifierSeq(); + setState(1428); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,173,_ctx) ) { + case 1: + { + setState(1427); + abstractDeclarator(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PointerOperatorContext extends ParserRuleContext { + public TerminalNode And() { return getToken(CPP14Parser.And, 0); } + public TerminalNode AndAnd() { return getToken(CPP14Parser.AndAnd, 0); } + public AttributeSpecifierSeqContext attributeSpecifierSeq() { + return getRuleContext(AttributeSpecifierSeqContext.class,0); + } + public TerminalNode Star() { return getToken(CPP14Parser.Star, 0); } + public NestedNameSpecifierContext nestedNameSpecifier() { + return getRuleContext(NestedNameSpecifierContext.class,0); + } + public CvqualifierseqContext cvqualifierseq() { + return getRuleContext(CvqualifierseqContext.class,0); + } + public PointerOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_pointerOperator; } + } + + public final PointerOperatorContext pointerOperator() throws RecognitionException { + PointerOperatorContext _localctx = new PointerOperatorContext(_ctx, getState()); + enterRule(_localctx, 232, RULE_pointerOperator); + int _la; + try { + setState(1444); + _errHandler.sync(this); + switch (_input.LA(1)) { + case And: + case AndAnd: + enterOuterAlt(_localctx, 1); + { + setState(1430); + _la = _input.LA(1); + if ( !(_la==And || _la==AndAnd) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1432); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,174,_ctx) ) { + case 1: + { + setState(1431); + attributeSpecifierSeq(); + } + break; + } + } + break; + case Decltype: + case Star: + case Doublecolon: + case Identifier: + enterOuterAlt(_localctx, 2); + { + setState(1435); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Decltype || _la==Doublecolon || _la==Identifier) { + { + setState(1434); + nestedNameSpecifier(0); + } + } + + setState(1437); + match(Star); + setState(1439); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,176,_ctx) ) { + case 1: + { + setState(1438); + attributeSpecifierSeq(); + } + break; + } + setState(1442); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,177,_ctx) ) { + case 1: + { + setState(1441); + cvqualifierseq(); + } + break; + } + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class CvqualifierseqContext extends ParserRuleContext { + public List cvQualifier() { + return getRuleContexts(CvQualifierContext.class); + } + public CvQualifierContext cvQualifier(int i) { + return getRuleContext(CvQualifierContext.class,i); + } + public CvqualifierseqContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_cvqualifierseq; } + } + + public final CvqualifierseqContext cvqualifierseq() throws RecognitionException { + CvqualifierseqContext _localctx = new CvqualifierseqContext(_ctx, getState()); + enterRule(_localctx, 234, RULE_cvqualifierseq); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1447); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(1446); + cvQualifier(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1449); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,179,_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; + } + + public static class CvQualifierContext extends ParserRuleContext { + public TerminalNode Const() { return getToken(CPP14Parser.Const, 0); } + public TerminalNode Volatile() { return getToken(CPP14Parser.Volatile, 0); } + public CvQualifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_cvQualifier; } + } + + public final CvQualifierContext cvQualifier() throws RecognitionException { + CvQualifierContext _localctx = new CvQualifierContext(_ctx, getState()); + enterRule(_localctx, 236, RULE_cvQualifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1451); + _la = _input.LA(1); + if ( !(_la==Const || _la==Volatile) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class RefqualifierContext extends ParserRuleContext { + public TerminalNode And() { return getToken(CPP14Parser.And, 0); } + public TerminalNode AndAnd() { return getToken(CPP14Parser.AndAnd, 0); } + public RefqualifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_refqualifier; } + } + + public final RefqualifierContext refqualifier() throws RecognitionException { + RefqualifierContext _localctx = new RefqualifierContext(_ctx, getState()); + enterRule(_localctx, 238, RULE_refqualifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1453); + _la = _input.LA(1); + if ( !(_la==And || _la==AndAnd) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class DeclaratoridContext extends ParserRuleContext { + public IdExpressionContext idExpression() { + return getRuleContext(IdExpressionContext.class,0); + } + public TerminalNode Ellipsis() { return getToken(CPP14Parser.Ellipsis, 0); } + public DeclaratoridContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_declaratorid; } + } + + public final DeclaratoridContext declaratorid() throws RecognitionException { + DeclaratoridContext _localctx = new DeclaratoridContext(_ctx, getState()); + enterRule(_localctx, 240, RULE_declaratorid); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1456); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Ellipsis) { + { + setState(1455); + match(Ellipsis); + } + } + + setState(1458); + idExpression(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TheTypeIdContext extends ParserRuleContext { + public TypeSpecifierSeqContext typeSpecifierSeq() { + return getRuleContext(TypeSpecifierSeqContext.class,0); + } + public AbstractDeclaratorContext abstractDeclarator() { + return getRuleContext(AbstractDeclaratorContext.class,0); + } + public TheTypeIdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_theTypeId; } + } + + public final TheTypeIdContext theTypeId() throws RecognitionException { + TheTypeIdContext _localctx = new TheTypeIdContext(_ctx, getState()); + enterRule(_localctx, 242, RULE_theTypeId); + try { + enterOuterAlt(_localctx, 1); + { + setState(1460); + typeSpecifierSeq(); + setState(1462); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,181,_ctx) ) { + case 1: + { + setState(1461); + abstractDeclarator(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AbstractDeclaratorContext extends ParserRuleContext { + public PointerAbstractDeclaratorContext pointerAbstractDeclarator() { + return getRuleContext(PointerAbstractDeclaratorContext.class,0); + } + public ParametersAndQualifiersContext parametersAndQualifiers() { + return getRuleContext(ParametersAndQualifiersContext.class,0); + } + public TrailingReturnTypeContext trailingReturnType() { + return getRuleContext(TrailingReturnTypeContext.class,0); + } + public NoPointerAbstractDeclaratorContext noPointerAbstractDeclarator() { + return getRuleContext(NoPointerAbstractDeclaratorContext.class,0); + } + public AbstractPackDeclaratorContext abstractPackDeclarator() { + return getRuleContext(AbstractPackDeclaratorContext.class,0); + } + public AbstractDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_abstractDeclarator; } + } + + public final AbstractDeclaratorContext abstractDeclarator() throws RecognitionException { + AbstractDeclaratorContext _localctx = new AbstractDeclaratorContext(_ctx, getState()); + enterRule(_localctx, 244, RULE_abstractDeclarator); + try { + setState(1472); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,183,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1464); + pointerAbstractDeclarator(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1466); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,182,_ctx) ) { + case 1: + { + setState(1465); + noPointerAbstractDeclarator(0); + } + break; + } + setState(1468); + parametersAndQualifiers(); + setState(1469); + trailingReturnType(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1471); + abstractPackDeclarator(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PointerAbstractDeclaratorContext extends ParserRuleContext { + public NoPointerAbstractDeclaratorContext noPointerAbstractDeclarator() { + return getRuleContext(NoPointerAbstractDeclaratorContext.class,0); + } + public List pointerOperator() { + return getRuleContexts(PointerOperatorContext.class); + } + public PointerOperatorContext pointerOperator(int i) { + return getRuleContext(PointerOperatorContext.class,i); + } + public PointerAbstractDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_pointerAbstractDeclarator; } + } + + public final PointerAbstractDeclaratorContext pointerAbstractDeclarator() throws RecognitionException { + PointerAbstractDeclaratorContext _localctx = new PointerAbstractDeclaratorContext(_ctx, getState()); + enterRule(_localctx, 246, RULE_pointerAbstractDeclarator); + int _la; + try { + setState(1483); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LeftParen: + case LeftBracket: + enterOuterAlt(_localctx, 1); + { + setState(1474); + noPointerAbstractDeclarator(0); + } + break; + case Decltype: + case Star: + case And: + case AndAnd: + case Doublecolon: + case Identifier: + enterOuterAlt(_localctx, 2); + { + setState(1476); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1475); + pointerOperator(); + } + } + setState(1478); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==Decltype || ((((_la - 93)) & ~0x3f) == 0 && ((1L << (_la - 93)) & ((1L << (Star - 93)) | (1L << (And - 93)) | (1L << (AndAnd - 93)) | (1L << (Doublecolon - 93)) | (1L << (Identifier - 93)))) != 0) ); + setState(1481); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,185,_ctx) ) { + case 1: + { + setState(1480); + noPointerAbstractDeclarator(0); + } + break; + } + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class NoPointerAbstractDeclaratorContext extends ParserRuleContext { + public ParametersAndQualifiersContext parametersAndQualifiers() { + return getRuleContext(ParametersAndQualifiersContext.class,0); + } + public TerminalNode LeftBracket() { return getToken(CPP14Parser.LeftBracket, 0); } + public TerminalNode RightBracket() { return getToken(CPP14Parser.RightBracket, 0); } + public ConstantExpressionContext constantExpression() { + return getRuleContext(ConstantExpressionContext.class,0); + } + public AttributeSpecifierSeqContext attributeSpecifierSeq() { + return getRuleContext(AttributeSpecifierSeqContext.class,0); + } + public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); } + public PointerAbstractDeclaratorContext pointerAbstractDeclarator() { + return getRuleContext(PointerAbstractDeclaratorContext.class,0); + } + public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); } + public List noPointerAbstractDeclarator() { + return getRuleContexts(NoPointerAbstractDeclaratorContext.class); + } + public NoPointerAbstractDeclaratorContext noPointerAbstractDeclarator(int i) { + return getRuleContext(NoPointerAbstractDeclaratorContext.class,i); + } + public NoPointerAbstractDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_noPointerAbstractDeclarator; } + } + + public final NoPointerAbstractDeclaratorContext noPointerAbstractDeclarator() throws RecognitionException { + return noPointerAbstractDeclarator(0); + } + + private NoPointerAbstractDeclaratorContext noPointerAbstractDeclarator(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + NoPointerAbstractDeclaratorContext _localctx = new NoPointerAbstractDeclaratorContext(_ctx, _parentState); + NoPointerAbstractDeclaratorContext _prevctx = _localctx; + int _startState = 248; + enterRecursionRule(_localctx, 248, RULE_noPointerAbstractDeclarator, _p); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1499); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,189,_ctx) ) { + case 1: + { + setState(1486); + parametersAndQualifiers(); + } + break; + case 2: + { + setState(1487); + match(LeftBracket); + setState(1489); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (Static_cast - 65)) | (1L << (This - 65)) | (1L << (Typeid_ - 65)) | (1L << (Typename_ - 65)) | (1L << (Unsigned - 65)) | (1L << (Void - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)))) != 0) || _la==Identifier) { + { + setState(1488); + constantExpression(); + } + } + + setState(1491); + match(RightBracket); + setState(1493); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,188,_ctx) ) { + case 1: + { + setState(1492); + attributeSpecifierSeq(); + } + break; + } + } + break; + case 3: + { + setState(1495); + match(LeftParen); + setState(1496); + pointerAbstractDeclarator(); + setState(1497); + match(RightParen); + } + break; + } + _ctx.stop = _input.LT(-1); + setState(1516); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,193,_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 NoPointerAbstractDeclaratorContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_noPointerAbstractDeclarator); + setState(1501); + if (!(precpred(_ctx, 4))) throw new FailedPredicateException(this, "precpred(_ctx, 4)"); + setState(1512); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,192,_ctx) ) { + case 1: + { + setState(1502); + parametersAndQualifiers(); + } + break; + case 2: + { + setState(1503); + noPointerAbstractDeclarator(0); + setState(1504); + match(LeftBracket); + setState(1506); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (Static_cast - 65)) | (1L << (This - 65)) | (1L << (Typeid_ - 65)) | (1L << (Typename_ - 65)) | (1L << (Unsigned - 65)) | (1L << (Void - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)))) != 0) || _la==Identifier) { + { + setState(1505); + constantExpression(); + } + } + + setState(1508); + match(RightBracket); + setState(1510); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,191,_ctx) ) { + case 1: + { + setState(1509); + attributeSpecifierSeq(); + } + break; + } + } + break; + } + } + } + } + setState(1518); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,193,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class AbstractPackDeclaratorContext extends ParserRuleContext { + public NoPointerAbstractPackDeclaratorContext noPointerAbstractPackDeclarator() { + return getRuleContext(NoPointerAbstractPackDeclaratorContext.class,0); + } + public List pointerOperator() { + return getRuleContexts(PointerOperatorContext.class); + } + public PointerOperatorContext pointerOperator(int i) { + return getRuleContext(PointerOperatorContext.class,i); + } + public AbstractPackDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_abstractPackDeclarator; } + } + + public final AbstractPackDeclaratorContext abstractPackDeclarator() throws RecognitionException { + AbstractPackDeclaratorContext _localctx = new AbstractPackDeclaratorContext(_ctx, getState()); + enterRule(_localctx, 250, RULE_abstractPackDeclarator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1522); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Decltype || ((((_la - 93)) & ~0x3f) == 0 && ((1L << (_la - 93)) & ((1L << (Star - 93)) | (1L << (And - 93)) | (1L << (AndAnd - 93)) | (1L << (Doublecolon - 93)) | (1L << (Identifier - 93)))) != 0)) { + { + { + setState(1519); + pointerOperator(); + } + } + setState(1524); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1525); + noPointerAbstractPackDeclarator(0); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class NoPointerAbstractPackDeclaratorContext extends ParserRuleContext { + public TerminalNode Ellipsis() { return getToken(CPP14Parser.Ellipsis, 0); } + public NoPointerAbstractPackDeclaratorContext noPointerAbstractPackDeclarator() { + return getRuleContext(NoPointerAbstractPackDeclaratorContext.class,0); + } + public ParametersAndQualifiersContext parametersAndQualifiers() { + return getRuleContext(ParametersAndQualifiersContext.class,0); + } + public TerminalNode LeftBracket() { return getToken(CPP14Parser.LeftBracket, 0); } + public TerminalNode RightBracket() { return getToken(CPP14Parser.RightBracket, 0); } + public ConstantExpressionContext constantExpression() { + return getRuleContext(ConstantExpressionContext.class,0); + } + public AttributeSpecifierSeqContext attributeSpecifierSeq() { + return getRuleContext(AttributeSpecifierSeqContext.class,0); + } + public NoPointerAbstractPackDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_noPointerAbstractPackDeclarator; } + } + + public final NoPointerAbstractPackDeclaratorContext noPointerAbstractPackDeclarator() throws RecognitionException { + return noPointerAbstractPackDeclarator(0); + } + + private NoPointerAbstractPackDeclaratorContext noPointerAbstractPackDeclarator(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + NoPointerAbstractPackDeclaratorContext _localctx = new NoPointerAbstractPackDeclaratorContext(_ctx, _parentState); + NoPointerAbstractPackDeclaratorContext _prevctx = _localctx; + int _startState = 252; + enterRecursionRule(_localctx, 252, RULE_noPointerAbstractPackDeclarator, _p); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(1528); + match(Ellipsis); + } + _ctx.stop = _input.LT(-1); + setState(1544); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,198,_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 NoPointerAbstractPackDeclaratorContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_noPointerAbstractPackDeclarator); + setState(1530); + if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(1540); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LeftParen: + { + setState(1531); + parametersAndQualifiers(); + } + break; + case LeftBracket: + { + setState(1532); + match(LeftBracket); + setState(1534); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (Static_cast - 65)) | (1L << (This - 65)) | (1L << (Typeid_ - 65)) | (1L << (Typename_ - 65)) | (1L << (Unsigned - 65)) | (1L << (Void - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)))) != 0) || _la==Identifier) { + { + setState(1533); + constantExpression(); + } + } + + setState(1536); + match(RightBracket); + setState(1538); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,196,_ctx) ) { + case 1: + { + setState(1537); + attributeSpecifierSeq(); + } + break; + } + } + break; + default: + throw new NoViableAltException(this); + } + } + } + } + setState(1546); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,198,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class ParameterDeclarationClauseContext extends ParserRuleContext { + public ParameterDeclarationListContext parameterDeclarationList() { + return getRuleContext(ParameterDeclarationListContext.class,0); + } + public TerminalNode Ellipsis() { return getToken(CPP14Parser.Ellipsis, 0); } + public TerminalNode Comma() { return getToken(CPP14Parser.Comma, 0); } + public ParameterDeclarationClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_parameterDeclarationClause; } + } + + public final ParameterDeclarationClauseContext parameterDeclarationClause() throws RecognitionException { + ParameterDeclarationClauseContext _localctx = new ParameterDeclarationClauseContext(_ctx, getState()); + enterRule(_localctx, 254, RULE_parameterDeclarationClause); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1547); + parameterDeclarationList(); + setState(1552); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Comma || _la==Ellipsis) { + { + setState(1549); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Comma) { + { + setState(1548); + match(Comma); + } + } + + setState(1551); + match(Ellipsis); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ParameterDeclarationListContext extends ParserRuleContext { + public List parameterDeclaration() { + return getRuleContexts(ParameterDeclarationContext.class); + } + public ParameterDeclarationContext parameterDeclaration(int i) { + return getRuleContext(ParameterDeclarationContext.class,i); + } + public List Comma() { return getTokens(CPP14Parser.Comma); } + public TerminalNode Comma(int i) { + return getToken(CPP14Parser.Comma, i); + } + public ParameterDeclarationListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_parameterDeclarationList; } + } + + public final ParameterDeclarationListContext parameterDeclarationList() throws RecognitionException { + ParameterDeclarationListContext _localctx = new ParameterDeclarationListContext(_ctx, getState()); + enterRule(_localctx, 256, RULE_parameterDeclarationList); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1554); + parameterDeclaration(); + setState(1559); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,201,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1555); + match(Comma); + setState(1556); + parameterDeclaration(); + } + } + } + setState(1561); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,201,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ParameterDeclarationContext extends ParserRuleContext { + public DeclSpecifierSeqContext declSpecifierSeq() { + return getRuleContext(DeclSpecifierSeqContext.class,0); + } + public AttributeSpecifierSeqContext attributeSpecifierSeq() { + return getRuleContext(AttributeSpecifierSeqContext.class,0); + } + public DeclaratorContext declarator() { + return getRuleContext(DeclaratorContext.class,0); + } + public TerminalNode Assign() { return getToken(CPP14Parser.Assign, 0); } + public InitializerClauseContext initializerClause() { + return getRuleContext(InitializerClauseContext.class,0); + } + public AbstractDeclaratorContext abstractDeclarator() { + return getRuleContext(AbstractDeclaratorContext.class,0); + } + public ParameterDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_parameterDeclaration; } + } + + public final ParameterDeclarationContext parameterDeclaration() throws RecognitionException { + ParameterDeclarationContext _localctx = new ParameterDeclarationContext(_ctx, getState()); + enterRule(_localctx, 258, RULE_parameterDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1563); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Alignas || _la==LeftBracket) { + { + setState(1562); + attributeSpecifierSeq(); + } + } + + setState(1565); + declSpecifierSeq(); + { + setState(1570); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,204,_ctx) ) { + case 1: + { + setState(1566); + declarator(); + } + break; + case 2: + { + setState(1568); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,203,_ctx) ) { + case 1: + { + setState(1567); + abstractDeclarator(); + } + break; + } + } + break; + } + setState(1574); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Assign) { + { + setState(1572); + match(Assign); + setState(1573); + initializerClause(); + } + } + + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FunctionDefinitionContext extends ParserRuleContext { + public DeclaratorContext declarator() { + return getRuleContext(DeclaratorContext.class,0); + } + public FunctionBodyContext functionBody() { + return getRuleContext(FunctionBodyContext.class,0); + } + public AttributeSpecifierSeqContext attributeSpecifierSeq() { + return getRuleContext(AttributeSpecifierSeqContext.class,0); + } + public DeclSpecifierSeqContext declSpecifierSeq() { + return getRuleContext(DeclSpecifierSeqContext.class,0); + } + public VirtualSpecifierSeqContext virtualSpecifierSeq() { + return getRuleContext(VirtualSpecifierSeqContext.class,0); + } + public FunctionDefinitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_functionDefinition; } + } + + public final FunctionDefinitionContext functionDefinition() throws RecognitionException { + FunctionDefinitionContext _localctx = new FunctionDefinitionContext(_ctx, getState()); + enterRule(_localctx, 260, RULE_functionDefinition); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1577); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Alignas || _la==LeftBracket) { + { + setState(1576); + attributeSpecifierSeq(); + } + } + + setState(1580); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,207,_ctx) ) { + case 1: + { + setState(1579); + declSpecifierSeq(); + } + break; + } + setState(1582); + declarator(); + setState(1584); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Final || _la==Override) { + { + setState(1583); + virtualSpecifierSeq(); + } + } + + setState(1586); + functionBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FunctionBodyContext extends ParserRuleContext { + public CompoundStatementContext compoundStatement() { + return getRuleContext(CompoundStatementContext.class,0); + } + public ConstructorInitializerContext constructorInitializer() { + return getRuleContext(ConstructorInitializerContext.class,0); + } + public FunctionTryBlockContext functionTryBlock() { + return getRuleContext(FunctionTryBlockContext.class,0); + } + public TerminalNode Assign() { return getToken(CPP14Parser.Assign, 0); } + public TerminalNode Semi() { return getToken(CPP14Parser.Semi, 0); } + public TerminalNode Default() { return getToken(CPP14Parser.Default, 0); } + public TerminalNode Delete() { return getToken(CPP14Parser.Delete, 0); } + public FunctionBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_functionBody; } + } + + public final FunctionBodyContext functionBody() throws RecognitionException { + FunctionBodyContext _localctx = new FunctionBodyContext(_ctx, getState()); + enterRule(_localctx, 262, RULE_functionBody); + int _la; + try { + setState(1596); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LeftBrace: + case Colon: + enterOuterAlt(_localctx, 1); + { + setState(1589); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Colon) { + { + setState(1588); + constructorInitializer(); + } + } + + setState(1591); + compoundStatement(); + } + break; + case Try: + enterOuterAlt(_localctx, 2); + { + setState(1592); + functionTryBlock(); + } + break; + case Assign: + enterOuterAlt(_localctx, 3); + { + setState(1593); + match(Assign); + setState(1594); + _la = _input.LA(1); + if ( !(_la==Default || _la==Delete) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1595); + match(Semi); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InitializerContext extends ParserRuleContext { + public BraceOrEqualInitializerContext braceOrEqualInitializer() { + return getRuleContext(BraceOrEqualInitializerContext.class,0); + } + public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); } + public ExpressionListContext expressionList() { + return getRuleContext(ExpressionListContext.class,0); + } + public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); } + public InitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_initializer; } + } + + public final InitializerContext initializer() throws RecognitionException { + InitializerContext _localctx = new InitializerContext(_ctx, getState()); + enterRule(_localctx, 264, RULE_initializer); + try { + setState(1603); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LeftBrace: + case Assign: + enterOuterAlt(_localctx, 1); + { + setState(1598); + braceOrEqualInitializer(); + } + break; + case LeftParen: + enterOuterAlt(_localctx, 2); + { + setState(1599); + match(LeftParen); + setState(1600); + expressionList(); + setState(1601); + match(RightParen); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class BraceOrEqualInitializerContext extends ParserRuleContext { + public TerminalNode Assign() { return getToken(CPP14Parser.Assign, 0); } + public InitializerClauseContext initializerClause() { + return getRuleContext(InitializerClauseContext.class,0); + } + public BracedInitListContext bracedInitList() { + return getRuleContext(BracedInitListContext.class,0); + } + public BraceOrEqualInitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_braceOrEqualInitializer; } + } + + public final BraceOrEqualInitializerContext braceOrEqualInitializer() throws RecognitionException { + BraceOrEqualInitializerContext _localctx = new BraceOrEqualInitializerContext(_ctx, getState()); + enterRule(_localctx, 266, RULE_braceOrEqualInitializer); + try { + setState(1608); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Assign: + enterOuterAlt(_localctx, 1); + { + setState(1605); + match(Assign); + setState(1606); + initializerClause(); + } + break; + case LeftBrace: + enterOuterAlt(_localctx, 2); + { + setState(1607); + bracedInitList(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InitializerClauseContext extends ParserRuleContext { + public AssignmentExpressionContext assignmentExpression() { + return getRuleContext(AssignmentExpressionContext.class,0); + } + public BracedInitListContext bracedInitList() { + return getRuleContext(BracedInitListContext.class,0); + } + public InitializerClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_initializerClause; } + } + + public final InitializerClauseContext initializerClause() throws RecognitionException { + InitializerClauseContext _localctx = new InitializerClauseContext(_ctx, getState()); + enterRule(_localctx, 268, RULE_initializerClause); + try { + setState(1612); + _errHandler.sync(this); + switch (_input.LA(1)) { + case IntegerLiteral: + case CharacterLiteral: + case FloatingLiteral: + case StringLiteral: + case BooleanLiteral: + case PointerLiteral: + case UserDefinedLiteral: + case Alignof: + case Auto: + case Bool: + case Char: + case Char16: + case Char32: + case Const_cast: + case Decltype: + case Delete: + case Double: + case Dynamic_cast: + case Float: + case Int: + case Long: + case New: + case Noexcept: + case Operator: + case Reinterpret_cast: + case Short: + case Signed: + case Sizeof: + case Static_cast: + case This: + case Throw: + case Typeid_: + case Typename_: + case Unsigned: + case Void: + case Wchar: + case LeftParen: + case LeftBracket: + case Plus: + case Minus: + case Star: + case And: + case Or: + case Tilde: + case Not: + case PlusPlus: + case MinusMinus: + case Doublecolon: + case Identifier: + enterOuterAlt(_localctx, 1); + { + setState(1610); + assignmentExpression(); + } + break; + case LeftBrace: + enterOuterAlt(_localctx, 2); + { + setState(1611); + bracedInitList(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InitializerListContext extends ParserRuleContext { + public List initializerClause() { + return getRuleContexts(InitializerClauseContext.class); + } + public InitializerClauseContext initializerClause(int i) { + return getRuleContext(InitializerClauseContext.class,i); + } + public List Ellipsis() { return getTokens(CPP14Parser.Ellipsis); } + public TerminalNode Ellipsis(int i) { + return getToken(CPP14Parser.Ellipsis, i); + } + public List Comma() { return getTokens(CPP14Parser.Comma); } + public TerminalNode Comma(int i) { + return getToken(CPP14Parser.Comma, i); + } + public InitializerListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_initializerList; } + } + + public final InitializerListContext initializerList() throws RecognitionException { + InitializerListContext _localctx = new InitializerListContext(_ctx, getState()); + enterRule(_localctx, 270, RULE_initializerList); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1614); + initializerClause(); + setState(1616); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Ellipsis) { + { + setState(1615); + match(Ellipsis); + } + } + + setState(1625); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,216,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1618); + match(Comma); + setState(1619); + initializerClause(); + setState(1621); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Ellipsis) { + { + setState(1620); + match(Ellipsis); + } + } + + } + } + } + setState(1627); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,216,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class BracedInitListContext extends ParserRuleContext { + public TerminalNode LeftBrace() { return getToken(CPP14Parser.LeftBrace, 0); } + public TerminalNode RightBrace() { return getToken(CPP14Parser.RightBrace, 0); } + public InitializerListContext initializerList() { + return getRuleContext(InitializerListContext.class,0); + } + public TerminalNode Comma() { return getToken(CPP14Parser.Comma, 0); } + public BracedInitListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_bracedInitList; } + } + + public final BracedInitListContext bracedInitList() throws RecognitionException { + BracedInitListContext _localctx = new BracedInitListContext(_ctx, getState()); + enterRule(_localctx, 272, RULE_bracedInitList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1628); + match(LeftBrace); + setState(1633); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (Static_cast - 65)) | (1L << (This - 65)) | (1L << (Throw - 65)) | (1L << (Typeid_ - 65)) | (1L << (Typename_ - 65)) | (1L << (Unsigned - 65)) | (1L << (Void - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (LeftBrace - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)))) != 0) || _la==Identifier) { + { + setState(1629); + initializerList(); + setState(1631); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Comma) { + { + setState(1630); + match(Comma); + } + } + + } + } + + setState(1635); + match(RightBrace); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassNameContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); } + public SimpleTemplateIdContext simpleTemplateId() { + return getRuleContext(SimpleTemplateIdContext.class,0); + } + public ClassNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_className; } + } + + public final ClassNameContext className() throws RecognitionException { + ClassNameContext _localctx = new ClassNameContext(_ctx, getState()); + enterRule(_localctx, 274, RULE_className); + try { + setState(1639); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,219,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1637); + match(Identifier); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1638); + simpleTemplateId(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassSpecifierContext extends ParserRuleContext { + public ClassHeadContext classHead() { + return getRuleContext(ClassHeadContext.class,0); + } + public TerminalNode LeftBrace() { return getToken(CPP14Parser.LeftBrace, 0); } + public TerminalNode RightBrace() { return getToken(CPP14Parser.RightBrace, 0); } + public MemberSpecificationContext memberSpecification() { + return getRuleContext(MemberSpecificationContext.class,0); + } + public ClassSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classSpecifier; } + } + + public final ClassSpecifierContext classSpecifier() throws RecognitionException { + ClassSpecifierContext _localctx = new ClassSpecifierContext(_ctx, getState()); + enterRule(_localctx, 276, RULE_classSpecifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1641); + classHead(); + setState(1642); + match(LeftBrace); + setState(1644); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (Alignas - 10)) | (1L << (Auto - 10)) | (1L << (Bool - 10)) | (1L << (Char - 10)) | (1L << (Char16 - 10)) | (1L << (Char32 - 10)) | (1L << (Class - 10)) | (1L << (Const - 10)) | (1L << (Constexpr - 10)) | (1L << (Decltype - 10)) | (1L << (Double - 10)) | (1L << (Enum - 10)) | (1L << (Explicit - 10)) | (1L << (Extern - 10)) | (1L << (Float - 10)) | (1L << (Friend - 10)) | (1L << (Inline - 10)) | (1L << (Int - 10)) | (1L << (Long - 10)) | (1L << (Mutable - 10)) | (1L << (Operator - 10)) | (1L << (Private - 10)) | (1L << (Protected - 10)) | (1L << (Public - 10)) | (1L << (Register - 10)) | (1L << (Short - 10)) | (1L << (Signed - 10)) | (1L << (Static - 10)) | (1L << (Static_assert - 10)) | (1L << (Struct - 10)) | (1L << (Template - 10)) | (1L << (Thread_local - 10)))) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (Typedef - 74)) | (1L << (Typename_ - 74)) | (1L << (Union - 74)) | (1L << (Unsigned - 74)) | (1L << (Using - 74)) | (1L << (Virtual - 74)) | (1L << (Void - 74)) | (1L << (Volatile - 74)) | (1L << (Wchar - 74)) | (1L << (LeftParen - 74)) | (1L << (LeftBracket - 74)) | (1L << (Star - 74)) | (1L << (And - 74)) | (1L << (Tilde - 74)) | (1L << (AndAnd - 74)) | (1L << (Colon - 74)) | (1L << (Doublecolon - 74)) | (1L << (Semi - 74)) | (1L << (Ellipsis - 74)) | (1L << (Identifier - 74)))) != 0)) { + { + setState(1643); + memberSpecification(); + } + } + + setState(1646); + match(RightBrace); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassHeadContext extends ParserRuleContext { + public ClassKeyContext classKey() { + return getRuleContext(ClassKeyContext.class,0); + } + public AttributeSpecifierSeqContext attributeSpecifierSeq() { + return getRuleContext(AttributeSpecifierSeqContext.class,0); + } + public ClassHeadNameContext classHeadName() { + return getRuleContext(ClassHeadNameContext.class,0); + } + public BaseClauseContext baseClause() { + return getRuleContext(BaseClauseContext.class,0); + } + public ClassVirtSpecifierContext classVirtSpecifier() { + return getRuleContext(ClassVirtSpecifierContext.class,0); + } + public TerminalNode Union() { return getToken(CPP14Parser.Union, 0); } + public ClassHeadContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classHead; } + } + + public final ClassHeadContext classHead() throws RecognitionException { + ClassHeadContext _localctx = new ClassHeadContext(_ctx, getState()); + enterRule(_localctx, 278, RULE_classHead); + int _la; + try { + setState(1671); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Class: + case Struct: + enterOuterAlt(_localctx, 1); + { + setState(1648); + classKey(); + setState(1650); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Alignas || _la==LeftBracket) { + { + setState(1649); + attributeSpecifierSeq(); + } + } + + setState(1656); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Decltype || _la==Doublecolon || _la==Identifier) { + { + setState(1652); + classHeadName(); + setState(1654); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Final) { + { + setState(1653); + classVirtSpecifier(); + } + } + + } + } + + setState(1659); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Colon) { + { + setState(1658); + baseClause(); + } + } + + } + break; + case Union: + enterOuterAlt(_localctx, 2); + { + setState(1661); + match(Union); + setState(1663); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Alignas || _la==LeftBracket) { + { + setState(1662); + attributeSpecifierSeq(); + } + } + + setState(1669); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Decltype || _la==Doublecolon || _la==Identifier) { + { + setState(1665); + classHeadName(); + setState(1667); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Final) { + { + setState(1666); + classVirtSpecifier(); + } + } + + } + } + + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassHeadNameContext extends ParserRuleContext { + public ClassNameContext className() { + return getRuleContext(ClassNameContext.class,0); + } + public NestedNameSpecifierContext nestedNameSpecifier() { + return getRuleContext(NestedNameSpecifierContext.class,0); + } + public ClassHeadNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classHeadName; } + } + + public final ClassHeadNameContext classHeadName() throws RecognitionException { + ClassHeadNameContext _localctx = new ClassHeadNameContext(_ctx, getState()); + enterRule(_localctx, 280, RULE_classHeadName); + try { + enterOuterAlt(_localctx, 1); + { + setState(1674); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,229,_ctx) ) { + case 1: + { + setState(1673); + nestedNameSpecifier(0); + } + break; + } + setState(1676); + className(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassVirtSpecifierContext extends ParserRuleContext { + public TerminalNode Final() { return getToken(CPP14Parser.Final, 0); } + public ClassVirtSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classVirtSpecifier; } + } + + public final ClassVirtSpecifierContext classVirtSpecifier() throws RecognitionException { + ClassVirtSpecifierContext _localctx = new ClassVirtSpecifierContext(_ctx, getState()); + enterRule(_localctx, 282, RULE_classVirtSpecifier); + try { + enterOuterAlt(_localctx, 1); + { + setState(1678); + match(Final); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassKeyContext extends ParserRuleContext { + public TerminalNode Class() { return getToken(CPP14Parser.Class, 0); } + public TerminalNode Struct() { return getToken(CPP14Parser.Struct, 0); } + public ClassKeyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classKey; } + } + + public final ClassKeyContext classKey() throws RecognitionException { + ClassKeyContext _localctx = new ClassKeyContext(_ctx, getState()); + enterRule(_localctx, 284, RULE_classKey); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1680); + _la = _input.LA(1); + if ( !(_la==Class || _la==Struct) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MemberSpecificationContext extends ParserRuleContext { + public List memberdeclaration() { + return getRuleContexts(MemberdeclarationContext.class); + } + public MemberdeclarationContext memberdeclaration(int i) { + return getRuleContext(MemberdeclarationContext.class,i); + } + public List accessSpecifier() { + return getRuleContexts(AccessSpecifierContext.class); + } + public AccessSpecifierContext accessSpecifier(int i) { + return getRuleContext(AccessSpecifierContext.class,i); + } + public List Colon() { return getTokens(CPP14Parser.Colon); } + public TerminalNode Colon(int i) { + return getToken(CPP14Parser.Colon, i); + } + public MemberSpecificationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_memberSpecification; } + } + + public final MemberSpecificationContext memberSpecification() throws RecognitionException { + MemberSpecificationContext _localctx = new MemberSpecificationContext(_ctx, getState()); + enterRule(_localctx, 286, RULE_memberSpecification); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1686); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + setState(1686); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Alignas: + case Auto: + case Bool: + case Char: + case Char16: + case Char32: + case Class: + case Const: + case Constexpr: + case Decltype: + case Double: + case Enum: + case Explicit: + case Extern: + case Float: + case Friend: + case Inline: + case Int: + case Long: + case Mutable: + case Operator: + case Register: + case Short: + case Signed: + case Static: + case Static_assert: + case Struct: + case Template: + case Thread_local: + case Typedef: + case Typename_: + case Union: + case Unsigned: + case Using: + case Virtual: + case Void: + case Volatile: + case Wchar: + case LeftParen: + case LeftBracket: + case Star: + case And: + case Tilde: + case AndAnd: + case Colon: + case Doublecolon: + case Semi: + case Ellipsis: + case Identifier: + { + setState(1682); + memberdeclaration(); + } + break; + case Private: + case Protected: + case Public: + { + setState(1683); + accessSpecifier(); + setState(1684); + match(Colon); + } + break; + default: + throw new NoViableAltException(this); + } + } + setState(1688); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( ((((_la - 10)) & ~0x3f) == 0 && ((1L << (_la - 10)) & ((1L << (Alignas - 10)) | (1L << (Auto - 10)) | (1L << (Bool - 10)) | (1L << (Char - 10)) | (1L << (Char16 - 10)) | (1L << (Char32 - 10)) | (1L << (Class - 10)) | (1L << (Const - 10)) | (1L << (Constexpr - 10)) | (1L << (Decltype - 10)) | (1L << (Double - 10)) | (1L << (Enum - 10)) | (1L << (Explicit - 10)) | (1L << (Extern - 10)) | (1L << (Float - 10)) | (1L << (Friend - 10)) | (1L << (Inline - 10)) | (1L << (Int - 10)) | (1L << (Long - 10)) | (1L << (Mutable - 10)) | (1L << (Operator - 10)) | (1L << (Private - 10)) | (1L << (Protected - 10)) | (1L << (Public - 10)) | (1L << (Register - 10)) | (1L << (Short - 10)) | (1L << (Signed - 10)) | (1L << (Static - 10)) | (1L << (Static_assert - 10)) | (1L << (Struct - 10)) | (1L << (Template - 10)) | (1L << (Thread_local - 10)))) != 0) || ((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (Typedef - 74)) | (1L << (Typename_ - 74)) | (1L << (Union - 74)) | (1L << (Unsigned - 74)) | (1L << (Using - 74)) | (1L << (Virtual - 74)) | (1L << (Void - 74)) | (1L << (Volatile - 74)) | (1L << (Wchar - 74)) | (1L << (LeftParen - 74)) | (1L << (LeftBracket - 74)) | (1L << (Star - 74)) | (1L << (And - 74)) | (1L << (Tilde - 74)) | (1L << (AndAnd - 74)) | (1L << (Colon - 74)) | (1L << (Doublecolon - 74)) | (1L << (Semi - 74)) | (1L << (Ellipsis - 74)) | (1L << (Identifier - 74)))) != 0) ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MemberdeclarationContext extends ParserRuleContext { + public TerminalNode Semi() { return getToken(CPP14Parser.Semi, 0); } + public AttributeSpecifierSeqContext attributeSpecifierSeq() { + return getRuleContext(AttributeSpecifierSeqContext.class,0); + } + public DeclSpecifierSeqContext declSpecifierSeq() { + return getRuleContext(DeclSpecifierSeqContext.class,0); + } + public MemberDeclaratorListContext memberDeclaratorList() { + return getRuleContext(MemberDeclaratorListContext.class,0); + } + public FunctionDefinitionContext functionDefinition() { + return getRuleContext(FunctionDefinitionContext.class,0); + } + public UsingDeclarationContext usingDeclaration() { + return getRuleContext(UsingDeclarationContext.class,0); + } + public StaticAssertDeclarationContext staticAssertDeclaration() { + return getRuleContext(StaticAssertDeclarationContext.class,0); + } + public TemplateDeclarationContext templateDeclaration() { + return getRuleContext(TemplateDeclarationContext.class,0); + } + public AliasDeclarationContext aliasDeclaration() { + return getRuleContext(AliasDeclarationContext.class,0); + } + public EmptyDeclarationContext emptyDeclaration() { + return getRuleContext(EmptyDeclarationContext.class,0); + } + public MemberdeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_memberdeclaration; } + } + + public final MemberdeclarationContext memberdeclaration() throws RecognitionException { + MemberdeclarationContext _localctx = new MemberdeclarationContext(_ctx, getState()); + enterRule(_localctx, 288, RULE_memberdeclaration); + int _la; + try { + setState(1706); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,235,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1691); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,232,_ctx) ) { + case 1: + { + setState(1690); + attributeSpecifierSeq(); + } + break; + } + setState(1694); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,233,_ctx) ) { + case 1: + { + setState(1693); + declSpecifierSeq(); + } + break; + } + setState(1697); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Alignas) | (1L << Decltype) | (1L << Operator))) != 0) || ((((_la - 85)) & ~0x3f) == 0 && ((1L << (_la - 85)) & ((1L << (LeftParen - 85)) | (1L << (LeftBracket - 85)) | (1L << (Star - 85)) | (1L << (And - 85)) | (1L << (Tilde - 85)) | (1L << (AndAnd - 85)) | (1L << (Colon - 85)) | (1L << (Doublecolon - 85)) | (1L << (Ellipsis - 85)) | (1L << (Identifier - 85)))) != 0)) { + { + setState(1696); + memberDeclaratorList(); + } + } + + setState(1699); + match(Semi); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1700); + functionDefinition(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1701); + usingDeclaration(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1702); + staticAssertDeclaration(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1703); + templateDeclaration(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1704); + aliasDeclaration(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(1705); + emptyDeclaration(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MemberDeclaratorListContext extends ParserRuleContext { + public List memberDeclarator() { + return getRuleContexts(MemberDeclaratorContext.class); + } + public MemberDeclaratorContext memberDeclarator(int i) { + return getRuleContext(MemberDeclaratorContext.class,i); + } + public List Comma() { return getTokens(CPP14Parser.Comma); } + public TerminalNode Comma(int i) { + return getToken(CPP14Parser.Comma, i); + } + public MemberDeclaratorListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_memberDeclaratorList; } + } + + public final MemberDeclaratorListContext memberDeclaratorList() throws RecognitionException { + MemberDeclaratorListContext _localctx = new MemberDeclaratorListContext(_ctx, getState()); + enterRule(_localctx, 290, RULE_memberDeclaratorList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1708); + memberDeclarator(); + setState(1713); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(1709); + match(Comma); + setState(1710); + memberDeclarator(); + } + } + setState(1715); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MemberDeclaratorContext extends ParserRuleContext { + public DeclaratorContext declarator() { + return getRuleContext(DeclaratorContext.class,0); + } + public VirtualSpecifierSeqContext virtualSpecifierSeq() { + return getRuleContext(VirtualSpecifierSeqContext.class,0); + } + public PureSpecifierContext pureSpecifier() { + return getRuleContext(PureSpecifierContext.class,0); + } + public BraceOrEqualInitializerContext braceOrEqualInitializer() { + return getRuleContext(BraceOrEqualInitializerContext.class,0); + } + public TerminalNode Colon() { return getToken(CPP14Parser.Colon, 0); } + public ConstantExpressionContext constantExpression() { + return getRuleContext(ConstantExpressionContext.class,0); + } + public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); } + public AttributeSpecifierSeqContext attributeSpecifierSeq() { + return getRuleContext(AttributeSpecifierSeqContext.class,0); + } + public MemberDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_memberDeclarator; } + } + + public final MemberDeclaratorContext memberDeclarator() throws RecognitionException { + MemberDeclaratorContext _localctx = new MemberDeclaratorContext(_ctx, getState()); + enterRule(_localctx, 292, RULE_memberDeclarator); + int _la; + try { + setState(1736); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,243,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1716); + declarator(); + setState(1726); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,240,_ctx) ) { + case 1: + { + setState(1718); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Final || _la==Override) { + { + setState(1717); + virtualSpecifierSeq(); + } + } + + setState(1721); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Assign) { + { + setState(1720); + pureSpecifier(); + } + } + + } + break; + case 2: + { + setState(1724); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LeftBrace || _la==Assign) { + { + setState(1723); + braceOrEqualInitializer(); + } + } + + } + break; + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1729); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Identifier) { + { + setState(1728); + match(Identifier); + } + } + + setState(1732); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Alignas || _la==LeftBracket) { + { + setState(1731); + attributeSpecifierSeq(); + } + } + + setState(1734); + match(Colon); + setState(1735); + constantExpression(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class VirtualSpecifierSeqContext extends ParserRuleContext { + public List virtualSpecifier() { + return getRuleContexts(VirtualSpecifierContext.class); + } + public VirtualSpecifierContext virtualSpecifier(int i) { + return getRuleContext(VirtualSpecifierContext.class,i); + } + public VirtualSpecifierSeqContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_virtualSpecifierSeq; } + } + + public final VirtualSpecifierSeqContext virtualSpecifierSeq() throws RecognitionException { + VirtualSpecifierSeqContext _localctx = new VirtualSpecifierSeqContext(_ctx, getState()); + enterRule(_localctx, 294, RULE_virtualSpecifierSeq); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1739); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1738); + virtualSpecifier(); + } + } + setState(1741); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==Final || _la==Override ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class VirtualSpecifierContext extends ParserRuleContext { + public TerminalNode Override() { return getToken(CPP14Parser.Override, 0); } + public TerminalNode Final() { return getToken(CPP14Parser.Final, 0); } + public VirtualSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_virtualSpecifier; } + } + + public final VirtualSpecifierContext virtualSpecifier() throws RecognitionException { + VirtualSpecifierContext _localctx = new VirtualSpecifierContext(_ctx, getState()); + enterRule(_localctx, 296, RULE_virtualSpecifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1743); + _la = _input.LA(1); + if ( !(_la==Final || _la==Override) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PureSpecifierContext extends ParserRuleContext { + public Token val; + public TerminalNode Assign() { return getToken(CPP14Parser.Assign, 0); } + public TerminalNode OctalLiteral() { return getToken(CPP14Parser.OctalLiteral, 0); } + public PureSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_pureSpecifier; } + } + + public final PureSpecifierContext pureSpecifier() throws RecognitionException { + PureSpecifierContext _localctx = new PureSpecifierContext(_ctx, getState()); + enterRule(_localctx, 298, RULE_pureSpecifier); + try { + enterOuterAlt(_localctx, 1); + { + setState(1745); + match(Assign); + setState(1746); + ((PureSpecifierContext)_localctx).val = match(OctalLiteral); + if((((PureSpecifierContext)_localctx).val!=null?((PureSpecifierContext)_localctx).val.getText():null).compareTo("0")!=0) throw new InputMismatchException(this); + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class BaseClauseContext extends ParserRuleContext { + public TerminalNode Colon() { return getToken(CPP14Parser.Colon, 0); } + public BaseSpecifierListContext baseSpecifierList() { + return getRuleContext(BaseSpecifierListContext.class,0); + } + public BaseClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_baseClause; } + } + + public final BaseClauseContext baseClause() throws RecognitionException { + BaseClauseContext _localctx = new BaseClauseContext(_ctx, getState()); + enterRule(_localctx, 300, RULE_baseClause); + try { + enterOuterAlt(_localctx, 1); + { + setState(1749); + match(Colon); + setState(1750); + baseSpecifierList(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class BaseSpecifierListContext extends ParserRuleContext { + public List baseSpecifier() { + return getRuleContexts(BaseSpecifierContext.class); + } + public BaseSpecifierContext baseSpecifier(int i) { + return getRuleContext(BaseSpecifierContext.class,i); + } + public List Ellipsis() { return getTokens(CPP14Parser.Ellipsis); } + public TerminalNode Ellipsis(int i) { + return getToken(CPP14Parser.Ellipsis, i); + } + public List Comma() { return getTokens(CPP14Parser.Comma); } + public TerminalNode Comma(int i) { + return getToken(CPP14Parser.Comma, i); + } + public BaseSpecifierListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_baseSpecifierList; } + } + + public final BaseSpecifierListContext baseSpecifierList() throws RecognitionException { + BaseSpecifierListContext _localctx = new BaseSpecifierListContext(_ctx, getState()); + enterRule(_localctx, 302, RULE_baseSpecifierList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1752); + baseSpecifier(); + setState(1754); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Ellipsis) { + { + setState(1753); + match(Ellipsis); + } + } + + setState(1763); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(1756); + match(Comma); + setState(1757); + baseSpecifier(); + setState(1759); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Ellipsis) { + { + setState(1758); + match(Ellipsis); + } + } + + } + } + setState(1765); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class BaseSpecifierContext extends ParserRuleContext { + public BaseTypeSpecifierContext baseTypeSpecifier() { + return getRuleContext(BaseTypeSpecifierContext.class,0); + } + public TerminalNode Virtual() { return getToken(CPP14Parser.Virtual, 0); } + public AccessSpecifierContext accessSpecifier() { + return getRuleContext(AccessSpecifierContext.class,0); + } + public AttributeSpecifierSeqContext attributeSpecifierSeq() { + return getRuleContext(AttributeSpecifierSeqContext.class,0); + } + public BaseSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_baseSpecifier; } + } + + public final BaseSpecifierContext baseSpecifier() throws RecognitionException { + BaseSpecifierContext _localctx = new BaseSpecifierContext(_ctx, getState()); + enterRule(_localctx, 304, RULE_baseSpecifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1767); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Alignas || _la==LeftBracket) { + { + setState(1766); + attributeSpecifierSeq(); + } + } + + setState(1781); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Decltype: + case Doublecolon: + case Identifier: + { + setState(1769); + baseTypeSpecifier(); + } + break; + case Virtual: + { + setState(1770); + match(Virtual); + setState(1772); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Private) | (1L << Protected) | (1L << Public))) != 0)) { + { + setState(1771); + accessSpecifier(); + } + } + + setState(1774); + baseTypeSpecifier(); + } + break; + case Private: + case Protected: + case Public: + { + setState(1775); + accessSpecifier(); + setState(1777); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Virtual) { + { + setState(1776); + match(Virtual); + } + } + + setState(1779); + baseTypeSpecifier(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassOrDeclTypeContext extends ParserRuleContext { + public ClassNameContext className() { + return getRuleContext(ClassNameContext.class,0); + } + public NestedNameSpecifierContext nestedNameSpecifier() { + return getRuleContext(NestedNameSpecifierContext.class,0); + } + public DecltypeSpecifierContext decltypeSpecifier() { + return getRuleContext(DecltypeSpecifierContext.class,0); + } + public ClassOrDeclTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classOrDeclType; } + } + + public final ClassOrDeclTypeContext classOrDeclType() throws RecognitionException { + ClassOrDeclTypeContext _localctx = new ClassOrDeclTypeContext(_ctx, getState()); + enterRule(_localctx, 306, RULE_classOrDeclType); + try { + setState(1788); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,253,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1784); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,252,_ctx) ) { + case 1: + { + setState(1783); + nestedNameSpecifier(0); + } + break; + } + setState(1786); + className(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1787); + decltypeSpecifier(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class BaseTypeSpecifierContext extends ParserRuleContext { + public ClassOrDeclTypeContext classOrDeclType() { + return getRuleContext(ClassOrDeclTypeContext.class,0); + } + public BaseTypeSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_baseTypeSpecifier; } + } + + public final BaseTypeSpecifierContext baseTypeSpecifier() throws RecognitionException { + BaseTypeSpecifierContext _localctx = new BaseTypeSpecifierContext(_ctx, getState()); + enterRule(_localctx, 308, RULE_baseTypeSpecifier); + try { + enterOuterAlt(_localctx, 1); + { + setState(1790); + classOrDeclType(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AccessSpecifierContext extends ParserRuleContext { + public TerminalNode Private() { return getToken(CPP14Parser.Private, 0); } + public TerminalNode Protected() { return getToken(CPP14Parser.Protected, 0); } + public TerminalNode Public() { return getToken(CPP14Parser.Public, 0); } + public AccessSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_accessSpecifier; } + } + + public final AccessSpecifierContext accessSpecifier() throws RecognitionException { + AccessSpecifierContext _localctx = new AccessSpecifierContext(_ctx, getState()); + enterRule(_localctx, 310, RULE_accessSpecifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1792); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << Private) | (1L << Protected) | (1L << Public))) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ConversionFunctionIdContext extends ParserRuleContext { + public TerminalNode Operator() { return getToken(CPP14Parser.Operator, 0); } + public ConversionTypeIdContext conversionTypeId() { + return getRuleContext(ConversionTypeIdContext.class,0); + } + public ConversionFunctionIdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_conversionFunctionId; } + } + + public final ConversionFunctionIdContext conversionFunctionId() throws RecognitionException { + ConversionFunctionIdContext _localctx = new ConversionFunctionIdContext(_ctx, getState()); + enterRule(_localctx, 312, RULE_conversionFunctionId); + try { + enterOuterAlt(_localctx, 1); + { + setState(1794); + match(Operator); + setState(1795); + conversionTypeId(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ConversionTypeIdContext extends ParserRuleContext { + public TypeSpecifierSeqContext typeSpecifierSeq() { + return getRuleContext(TypeSpecifierSeqContext.class,0); + } + public ConversionDeclaratorContext conversionDeclarator() { + return getRuleContext(ConversionDeclaratorContext.class,0); + } + public ConversionTypeIdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_conversionTypeId; } + } + + public final ConversionTypeIdContext conversionTypeId() throws RecognitionException { + ConversionTypeIdContext _localctx = new ConversionTypeIdContext(_ctx, getState()); + enterRule(_localctx, 314, RULE_conversionTypeId); + try { + enterOuterAlt(_localctx, 1); + { + setState(1797); + typeSpecifierSeq(); + setState(1799); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,254,_ctx) ) { + case 1: + { + setState(1798); + conversionDeclarator(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ConversionDeclaratorContext extends ParserRuleContext { + public PointerOperatorContext pointerOperator() { + return getRuleContext(PointerOperatorContext.class,0); + } + public ConversionDeclaratorContext conversionDeclarator() { + return getRuleContext(ConversionDeclaratorContext.class,0); + } + public ConversionDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_conversionDeclarator; } + } + + public final ConversionDeclaratorContext conversionDeclarator() throws RecognitionException { + ConversionDeclaratorContext _localctx = new ConversionDeclaratorContext(_ctx, getState()); + enterRule(_localctx, 316, RULE_conversionDeclarator); + try { + enterOuterAlt(_localctx, 1); + { + setState(1801); + pointerOperator(); + setState(1803); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,255,_ctx) ) { + case 1: + { + setState(1802); + conversionDeclarator(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ConstructorInitializerContext extends ParserRuleContext { + public TerminalNode Colon() { return getToken(CPP14Parser.Colon, 0); } + public MemInitializerListContext memInitializerList() { + return getRuleContext(MemInitializerListContext.class,0); + } + public ConstructorInitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constructorInitializer; } + } + + public final ConstructorInitializerContext constructorInitializer() throws RecognitionException { + ConstructorInitializerContext _localctx = new ConstructorInitializerContext(_ctx, getState()); + enterRule(_localctx, 318, RULE_constructorInitializer); + try { + enterOuterAlt(_localctx, 1); + { + setState(1805); + match(Colon); + setState(1806); + memInitializerList(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MemInitializerListContext extends ParserRuleContext { + public List memInitializer() { + return getRuleContexts(MemInitializerContext.class); + } + public MemInitializerContext memInitializer(int i) { + return getRuleContext(MemInitializerContext.class,i); + } + public List Ellipsis() { return getTokens(CPP14Parser.Ellipsis); } + public TerminalNode Ellipsis(int i) { + return getToken(CPP14Parser.Ellipsis, i); + } + public List Comma() { return getTokens(CPP14Parser.Comma); } + public TerminalNode Comma(int i) { + return getToken(CPP14Parser.Comma, i); + } + public MemInitializerListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_memInitializerList; } + } + + public final MemInitializerListContext memInitializerList() throws RecognitionException { + MemInitializerListContext _localctx = new MemInitializerListContext(_ctx, getState()); + enterRule(_localctx, 320, RULE_memInitializerList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1808); + memInitializer(); + setState(1810); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Ellipsis) { + { + setState(1809); + match(Ellipsis); + } + } + + setState(1819); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(1812); + match(Comma); + setState(1813); + memInitializer(); + setState(1815); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Ellipsis) { + { + setState(1814); + match(Ellipsis); + } + } + + } + } + setState(1821); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MemInitializerContext extends ParserRuleContext { + public MeminitializeridContext meminitializerid() { + return getRuleContext(MeminitializeridContext.class,0); + } + public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); } + public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); } + public BracedInitListContext bracedInitList() { + return getRuleContext(BracedInitListContext.class,0); + } + public ExpressionListContext expressionList() { + return getRuleContext(ExpressionListContext.class,0); + } + public MemInitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_memInitializer; } + } + + public final MemInitializerContext memInitializer() throws RecognitionException { + MemInitializerContext _localctx = new MemInitializerContext(_ctx, getState()); + enterRule(_localctx, 322, RULE_memInitializer); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1822); + meminitializerid(); + setState(1829); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LeftParen: + { + setState(1823); + match(LeftParen); + setState(1825); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (Static_cast - 65)) | (1L << (This - 65)) | (1L << (Throw - 65)) | (1L << (Typeid_ - 65)) | (1L << (Typename_ - 65)) | (1L << (Unsigned - 65)) | (1L << (Void - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (LeftBrace - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)))) != 0) || _la==Identifier) { + { + setState(1824); + expressionList(); + } + } + + setState(1827); + match(RightParen); + } + break; + case LeftBrace: + { + setState(1828); + bracedInitList(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MeminitializeridContext extends ParserRuleContext { + public ClassOrDeclTypeContext classOrDeclType() { + return getRuleContext(ClassOrDeclTypeContext.class,0); + } + public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); } + public MeminitializeridContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_meminitializerid; } + } + + public final MeminitializeridContext meminitializerid() throws RecognitionException { + MeminitializeridContext _localctx = new MeminitializeridContext(_ctx, getState()); + enterRule(_localctx, 324, RULE_meminitializerid); + try { + setState(1833); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,261,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1831); + classOrDeclType(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1832); + match(Identifier); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class OperatorFunctionIdContext extends ParserRuleContext { + public TerminalNode Operator() { return getToken(CPP14Parser.Operator, 0); } + public TheOperatorContext theOperator() { + return getRuleContext(TheOperatorContext.class,0); + } + public OperatorFunctionIdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_operatorFunctionId; } + } + + public final OperatorFunctionIdContext operatorFunctionId() throws RecognitionException { + OperatorFunctionIdContext _localctx = new OperatorFunctionIdContext(_ctx, getState()); + enterRule(_localctx, 326, RULE_operatorFunctionId); + try { + enterOuterAlt(_localctx, 1); + { + setState(1835); + match(Operator); + setState(1836); + theOperator(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LiteralOperatorIdContext extends ParserRuleContext { + public TerminalNode Operator() { return getToken(CPP14Parser.Operator, 0); } + public TerminalNode StringLiteral() { return getToken(CPP14Parser.StringLiteral, 0); } + public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); } + public TerminalNode UserDefinedStringLiteral() { return getToken(CPP14Parser.UserDefinedStringLiteral, 0); } + public LiteralOperatorIdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_literalOperatorId; } + } + + public final LiteralOperatorIdContext literalOperatorId() throws RecognitionException { + LiteralOperatorIdContext _localctx = new LiteralOperatorIdContext(_ctx, getState()); + enterRule(_localctx, 328, RULE_literalOperatorId); + try { + enterOuterAlt(_localctx, 1); + { + setState(1838); + match(Operator); + setState(1842); + _errHandler.sync(this); + switch (_input.LA(1)) { + case StringLiteral: + { + setState(1839); + match(StringLiteral); + setState(1840); + match(Identifier); + } + break; + case UserDefinedStringLiteral: + { + setState(1841); + match(UserDefinedStringLiteral); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TemplateDeclarationContext extends ParserRuleContext { + public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); } + public TerminalNode Less() { return getToken(CPP14Parser.Less, 0); } + public TemplateparameterListContext templateparameterList() { + return getRuleContext(TemplateparameterListContext.class,0); + } + public TerminalNode Greater() { return getToken(CPP14Parser.Greater, 0); } + public DeclarationContext declaration() { + return getRuleContext(DeclarationContext.class,0); + } + public TemplateDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_templateDeclaration; } + } + + public final TemplateDeclarationContext templateDeclaration() throws RecognitionException { + TemplateDeclarationContext _localctx = new TemplateDeclarationContext(_ctx, getState()); + enterRule(_localctx, 330, RULE_templateDeclaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(1844); + match(Template); + setState(1845); + match(Less); + setState(1846); + templateparameterList(); + setState(1847); + match(Greater); + setState(1848); + declaration(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TemplateparameterListContext extends ParserRuleContext { + public List templateParameter() { + return getRuleContexts(TemplateParameterContext.class); + } + public TemplateParameterContext templateParameter(int i) { + return getRuleContext(TemplateParameterContext.class,i); + } + public List Comma() { return getTokens(CPP14Parser.Comma); } + public TerminalNode Comma(int i) { + return getToken(CPP14Parser.Comma, i); + } + public TemplateparameterListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_templateparameterList; } + } + + public final TemplateparameterListContext templateparameterList() throws RecognitionException { + TemplateparameterListContext _localctx = new TemplateparameterListContext(_ctx, getState()); + enterRule(_localctx, 332, RULE_templateparameterList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1850); + templateParameter(); + setState(1855); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(1851); + match(Comma); + setState(1852); + templateParameter(); + } + } + setState(1857); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TemplateParameterContext extends ParserRuleContext { + public TypeParameterContext typeParameter() { + return getRuleContext(TypeParameterContext.class,0); + } + public ParameterDeclarationContext parameterDeclaration() { + return getRuleContext(ParameterDeclarationContext.class,0); + } + public TemplateParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_templateParameter; } + } + + public final TemplateParameterContext templateParameter() throws RecognitionException { + TemplateParameterContext _localctx = new TemplateParameterContext(_ctx, getState()); + enterRule(_localctx, 334, RULE_templateParameter); + try { + setState(1860); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,264,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1858); + typeParameter(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1859); + parameterDeclaration(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeParameterContext extends ParserRuleContext { + public TerminalNode Class() { return getToken(CPP14Parser.Class, 0); } + public TerminalNode Typename_() { return getToken(CPP14Parser.Typename_, 0); } + public TerminalNode Assign() { return getToken(CPP14Parser.Assign, 0); } + public TheTypeIdContext theTypeId() { + return getRuleContext(TheTypeIdContext.class,0); + } + public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); } + public TerminalNode Less() { return getToken(CPP14Parser.Less, 0); } + public TemplateparameterListContext templateparameterList() { + return getRuleContext(TemplateparameterListContext.class,0); + } + public TerminalNode Greater() { return getToken(CPP14Parser.Greater, 0); } + public TerminalNode Ellipsis() { return getToken(CPP14Parser.Ellipsis, 0); } + public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); } + public TypeParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeParameter; } + } + + public final TypeParameterContext typeParameter() throws RecognitionException { + TypeParameterContext _localctx = new TypeParameterContext(_ctx, getState()); + enterRule(_localctx, 336, RULE_typeParameter); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1871); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Class: + case Template: + { + setState(1867); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Template) { + { + setState(1862); + match(Template); + setState(1863); + match(Less); + setState(1864); + templateparameterList(); + setState(1865); + match(Greater); + } + } + + setState(1869); + match(Class); + } + break; + case Typename_: + { + setState(1870); + match(Typename_); + } + break; + default: + throw new NoViableAltException(this); + } + setState(1884); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,270,_ctx) ) { + case 1: + { + { + setState(1874); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Ellipsis) { + { + setState(1873); + match(Ellipsis); + } + } + + setState(1877); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Identifier) { + { + setState(1876); + match(Identifier); + } + } + + } + } + break; + case 2: + { + { + setState(1880); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Identifier) { + { + setState(1879); + match(Identifier); + } + } + + setState(1882); + match(Assign); + setState(1883); + theTypeId(); + } + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SimpleTemplateIdContext extends ParserRuleContext { + public TemplateNameContext templateName() { + return getRuleContext(TemplateNameContext.class,0); + } + public TerminalNode Less() { return getToken(CPP14Parser.Less, 0); } + public TerminalNode Greater() { return getToken(CPP14Parser.Greater, 0); } + public TemplateArgumentListContext templateArgumentList() { + return getRuleContext(TemplateArgumentListContext.class,0); + } + public SimpleTemplateIdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_simpleTemplateId; } + } + + public final SimpleTemplateIdContext simpleTemplateId() throws RecognitionException { + SimpleTemplateIdContext _localctx = new SimpleTemplateIdContext(_ctx, getState()); + enterRule(_localctx, 338, RULE_simpleTemplateId); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1886); + templateName(); + setState(1887); + match(Less); + setState(1889); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Class) | (1L << Const) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << Enum) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (Static_cast - 65)) | (1L << (Struct - 65)) | (1L << (This - 65)) | (1L << (Typeid_ - 65)) | (1L << (Typename_ - 65)) | (1L << (Union - 65)) | (1L << (Unsigned - 65)) | (1L << (Void - 65)) | (1L << (Volatile - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)))) != 0) || _la==Identifier) { + { + setState(1888); + templateArgumentList(); + } + } + + setState(1891); + match(Greater); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TemplateIdContext extends ParserRuleContext { + public SimpleTemplateIdContext simpleTemplateId() { + return getRuleContext(SimpleTemplateIdContext.class,0); + } + public TerminalNode Less() { return getToken(CPP14Parser.Less, 0); } + public TerminalNode Greater() { return getToken(CPP14Parser.Greater, 0); } + public OperatorFunctionIdContext operatorFunctionId() { + return getRuleContext(OperatorFunctionIdContext.class,0); + } + public LiteralOperatorIdContext literalOperatorId() { + return getRuleContext(LiteralOperatorIdContext.class,0); + } + public TemplateArgumentListContext templateArgumentList() { + return getRuleContext(TemplateArgumentListContext.class,0); + } + public TemplateIdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_templateId; } + } + + public final TemplateIdContext templateId() throws RecognitionException { + TemplateIdContext _localctx = new TemplateIdContext(_ctx, getState()); + enterRule(_localctx, 340, RULE_templateId); + int _la; + try { + setState(1904); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Identifier: + enterOuterAlt(_localctx, 1); + { + setState(1893); + simpleTemplateId(); + } + break; + case Operator: + enterOuterAlt(_localctx, 2); + { + setState(1896); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,272,_ctx) ) { + case 1: + { + setState(1894); + operatorFunctionId(); + } + break; + case 2: + { + setState(1895); + literalOperatorId(); + } + break; + } + setState(1898); + match(Less); + setState(1900); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Class) | (1L << Const) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << Enum) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (Static_cast - 65)) | (1L << (Struct - 65)) | (1L << (This - 65)) | (1L << (Typeid_ - 65)) | (1L << (Typename_ - 65)) | (1L << (Union - 65)) | (1L << (Unsigned - 65)) | (1L << (Void - 65)) | (1L << (Volatile - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)))) != 0) || _la==Identifier) { + { + setState(1899); + templateArgumentList(); + } + } + + setState(1902); + match(Greater); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TemplateNameContext extends ParserRuleContext { + public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); } + public TemplateNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_templateName; } + } + + public final TemplateNameContext templateName() throws RecognitionException { + TemplateNameContext _localctx = new TemplateNameContext(_ctx, getState()); + enterRule(_localctx, 342, RULE_templateName); + try { + enterOuterAlt(_localctx, 1); + { + setState(1906); + match(Identifier); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TemplateArgumentListContext extends ParserRuleContext { + public List templateArgument() { + return getRuleContexts(TemplateArgumentContext.class); + } + public TemplateArgumentContext templateArgument(int i) { + return getRuleContext(TemplateArgumentContext.class,i); + } + public List Ellipsis() { return getTokens(CPP14Parser.Ellipsis); } + public TerminalNode Ellipsis(int i) { + return getToken(CPP14Parser.Ellipsis, i); + } + public List Comma() { return getTokens(CPP14Parser.Comma); } + public TerminalNode Comma(int i) { + return getToken(CPP14Parser.Comma, i); + } + public TemplateArgumentListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_templateArgumentList; } + } + + public final TemplateArgumentListContext templateArgumentList() throws RecognitionException { + TemplateArgumentListContext _localctx = new TemplateArgumentListContext(_ctx, getState()); + enterRule(_localctx, 344, RULE_templateArgumentList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1908); + templateArgument(); + setState(1910); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Ellipsis) { + { + setState(1909); + match(Ellipsis); + } + } + + setState(1919); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(1912); + match(Comma); + setState(1913); + templateArgument(); + setState(1915); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Ellipsis) { + { + setState(1914); + match(Ellipsis); + } + } + + } + } + setState(1921); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TemplateArgumentContext extends ParserRuleContext { + public TheTypeIdContext theTypeId() { + return getRuleContext(TheTypeIdContext.class,0); + } + public ConstantExpressionContext constantExpression() { + return getRuleContext(ConstantExpressionContext.class,0); + } + public IdExpressionContext idExpression() { + return getRuleContext(IdExpressionContext.class,0); + } + public TemplateArgumentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_templateArgument; } + } + + public final TemplateArgumentContext templateArgument() throws RecognitionException { + TemplateArgumentContext _localctx = new TemplateArgumentContext(_ctx, getState()); + enterRule(_localctx, 346, RULE_templateArgument); + try { + setState(1925); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,278,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1922); + theTypeId(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1923); + constantExpression(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1924); + idExpression(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeNameSpecifierContext extends ParserRuleContext { + public TerminalNode Typename_() { return getToken(CPP14Parser.Typename_, 0); } + public NestedNameSpecifierContext nestedNameSpecifier() { + return getRuleContext(NestedNameSpecifierContext.class,0); + } + public TerminalNode Identifier() { return getToken(CPP14Parser.Identifier, 0); } + public SimpleTemplateIdContext simpleTemplateId() { + return getRuleContext(SimpleTemplateIdContext.class,0); + } + public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); } + public TypeNameSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeNameSpecifier; } + } + + public final TypeNameSpecifierContext typeNameSpecifier() throws RecognitionException { + TypeNameSpecifierContext _localctx = new TypeNameSpecifierContext(_ctx, getState()); + enterRule(_localctx, 348, RULE_typeNameSpecifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1927); + match(Typename_); + setState(1928); + nestedNameSpecifier(0); + setState(1934); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,280,_ctx) ) { + case 1: + { + setState(1929); + match(Identifier); + } + break; + case 2: + { + setState(1931); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Template) { + { + setState(1930); + match(Template); + } + } + + setState(1933); + simpleTemplateId(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ExplicitInstantiationContext extends ParserRuleContext { + public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); } + public DeclarationContext declaration() { + return getRuleContext(DeclarationContext.class,0); + } + public TerminalNode Extern() { return getToken(CPP14Parser.Extern, 0); } + public ExplicitInstantiationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_explicitInstantiation; } + } + + public final ExplicitInstantiationContext explicitInstantiation() throws RecognitionException { + ExplicitInstantiationContext _localctx = new ExplicitInstantiationContext(_ctx, getState()); + enterRule(_localctx, 350, RULE_explicitInstantiation); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1937); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Extern) { + { + setState(1936); + match(Extern); + } + } + + setState(1939); + match(Template); + setState(1940); + declaration(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ExplicitSpecializationContext extends ParserRuleContext { + public TerminalNode Template() { return getToken(CPP14Parser.Template, 0); } + public TerminalNode Less() { return getToken(CPP14Parser.Less, 0); } + public TerminalNode Greater() { return getToken(CPP14Parser.Greater, 0); } + public DeclarationContext declaration() { + return getRuleContext(DeclarationContext.class,0); + } + public ExplicitSpecializationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_explicitSpecialization; } + } + + public final ExplicitSpecializationContext explicitSpecialization() throws RecognitionException { + ExplicitSpecializationContext _localctx = new ExplicitSpecializationContext(_ctx, getState()); + enterRule(_localctx, 352, RULE_explicitSpecialization); + try { + enterOuterAlt(_localctx, 1); + { + setState(1942); + match(Template); + setState(1943); + match(Less); + setState(1944); + match(Greater); + setState(1945); + declaration(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TryBlockContext extends ParserRuleContext { + public TerminalNode Try() { return getToken(CPP14Parser.Try, 0); } + public CompoundStatementContext compoundStatement() { + return getRuleContext(CompoundStatementContext.class,0); + } + public HandlerSeqContext handlerSeq() { + return getRuleContext(HandlerSeqContext.class,0); + } + public TryBlockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_tryBlock; } + } + + public final TryBlockContext tryBlock() throws RecognitionException { + TryBlockContext _localctx = new TryBlockContext(_ctx, getState()); + enterRule(_localctx, 354, RULE_tryBlock); + try { + enterOuterAlt(_localctx, 1); + { + setState(1947); + match(Try); + setState(1948); + compoundStatement(); + setState(1949); + handlerSeq(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FunctionTryBlockContext extends ParserRuleContext { + public TerminalNode Try() { return getToken(CPP14Parser.Try, 0); } + public CompoundStatementContext compoundStatement() { + return getRuleContext(CompoundStatementContext.class,0); + } + public HandlerSeqContext handlerSeq() { + return getRuleContext(HandlerSeqContext.class,0); + } + public ConstructorInitializerContext constructorInitializer() { + return getRuleContext(ConstructorInitializerContext.class,0); + } + public FunctionTryBlockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_functionTryBlock; } + } + + public final FunctionTryBlockContext functionTryBlock() throws RecognitionException { + FunctionTryBlockContext _localctx = new FunctionTryBlockContext(_ctx, getState()); + enterRule(_localctx, 356, RULE_functionTryBlock); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1951); + match(Try); + setState(1953); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Colon) { + { + setState(1952); + constructorInitializer(); + } + } + + setState(1955); + compoundStatement(); + setState(1956); + handlerSeq(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class HandlerSeqContext extends ParserRuleContext { + public List handler() { + return getRuleContexts(HandlerContext.class); + } + public HandlerContext handler(int i) { + return getRuleContext(HandlerContext.class,i); + } + public HandlerSeqContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_handlerSeq; } + } + + public final HandlerSeqContext handlerSeq() throws RecognitionException { + HandlerSeqContext _localctx = new HandlerSeqContext(_ctx, getState()); + enterRule(_localctx, 358, RULE_handlerSeq); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1959); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1958); + handler(); + } + } + setState(1961); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==Catch ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class HandlerContext extends ParserRuleContext { + public TerminalNode Catch() { return getToken(CPP14Parser.Catch, 0); } + public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); } + public ExceptionDeclarationContext exceptionDeclaration() { + return getRuleContext(ExceptionDeclarationContext.class,0); + } + public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); } + public CompoundStatementContext compoundStatement() { + return getRuleContext(CompoundStatementContext.class,0); + } + public HandlerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_handler; } + } + + public final HandlerContext handler() throws RecognitionException { + HandlerContext _localctx = new HandlerContext(_ctx, getState()); + enterRule(_localctx, 360, RULE_handler); + try { + enterOuterAlt(_localctx, 1); + { + setState(1963); + match(Catch); + setState(1964); + match(LeftParen); + setState(1965); + exceptionDeclaration(); + setState(1966); + match(RightParen); + setState(1967); + compoundStatement(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ExceptionDeclarationContext extends ParserRuleContext { + public TypeSpecifierSeqContext typeSpecifierSeq() { + return getRuleContext(TypeSpecifierSeqContext.class,0); + } + public AttributeSpecifierSeqContext attributeSpecifierSeq() { + return getRuleContext(AttributeSpecifierSeqContext.class,0); + } + public DeclaratorContext declarator() { + return getRuleContext(DeclaratorContext.class,0); + } + public AbstractDeclaratorContext abstractDeclarator() { + return getRuleContext(AbstractDeclaratorContext.class,0); + } + public TerminalNode Ellipsis() { return getToken(CPP14Parser.Ellipsis, 0); } + public ExceptionDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_exceptionDeclaration; } + } + + public final ExceptionDeclarationContext exceptionDeclaration() throws RecognitionException { + ExceptionDeclarationContext _localctx = new ExceptionDeclarationContext(_ctx, getState()); + enterRule(_localctx, 362, RULE_exceptionDeclaration); + int _la; + try { + setState(1978); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Alignas: + case Auto: + case Bool: + case Char: + case Char16: + case Char32: + case Class: + case Const: + case Decltype: + case Double: + case Enum: + case Float: + case Int: + case Long: + case Short: + case Signed: + case Struct: + case Typename_: + case Union: + case Unsigned: + case Void: + case Volatile: + case Wchar: + case LeftBracket: + case Doublecolon: + case Identifier: + enterOuterAlt(_localctx, 1); + { + setState(1970); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Alignas || _la==LeftBracket) { + { + setState(1969); + attributeSpecifierSeq(); + } + } + + setState(1972); + typeSpecifierSeq(); + setState(1975); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,285,_ctx) ) { + case 1: + { + setState(1973); + declarator(); + } + break; + case 2: + { + setState(1974); + abstractDeclarator(); + } + break; + } + } + break; + case Ellipsis: + enterOuterAlt(_localctx, 2); + { + setState(1977); + match(Ellipsis); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ThrowExpressionContext extends ParserRuleContext { + public TerminalNode Throw() { return getToken(CPP14Parser.Throw, 0); } + public AssignmentExpressionContext assignmentExpression() { + return getRuleContext(AssignmentExpressionContext.class,0); + } + public ThrowExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_throwExpression; } + } + + public final ThrowExpressionContext throwExpression() throws RecognitionException { + ThrowExpressionContext _localctx = new ThrowExpressionContext(_ctx, getState()); + enterRule(_localctx, 364, RULE_throwExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1980); + match(Throw); + setState(1982); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral) | (1L << Alignof) | (1L << Auto) | (1L << Bool) | (1L << Char) | (1L << Char16) | (1L << Char32) | (1L << Const_cast) | (1L << Decltype) | (1L << Delete) | (1L << Double) | (1L << Dynamic_cast) | (1L << Float) | (1L << Int) | (1L << Long) | (1L << New) | (1L << Noexcept) | (1L << Operator) | (1L << Reinterpret_cast) | (1L << Short) | (1L << Signed) | (1L << Sizeof))) != 0) || ((((_la - 65)) & ~0x3f) == 0 && ((1L << (_la - 65)) & ((1L << (Static_cast - 65)) | (1L << (This - 65)) | (1L << (Throw - 65)) | (1L << (Typeid_ - 65)) | (1L << (Typename_ - 65)) | (1L << (Unsigned - 65)) | (1L << (Void - 65)) | (1L << (Wchar - 65)) | (1L << (LeftParen - 65)) | (1L << (LeftBracket - 65)) | (1L << (Plus - 65)) | (1L << (Minus - 65)) | (1L << (Star - 65)) | (1L << (And - 65)) | (1L << (Or - 65)) | (1L << (Tilde - 65)) | (1L << (Not - 65)) | (1L << (PlusPlus - 65)) | (1L << (MinusMinus - 65)) | (1L << (Doublecolon - 65)))) != 0) || _la==Identifier) { + { + setState(1981); + assignmentExpression(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ExceptionSpecificationContext extends ParserRuleContext { + public DynamicExceptionSpecificationContext dynamicExceptionSpecification() { + return getRuleContext(DynamicExceptionSpecificationContext.class,0); + } + public NoeExceptSpecificationContext noeExceptSpecification() { + return getRuleContext(NoeExceptSpecificationContext.class,0); + } + public ExceptionSpecificationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_exceptionSpecification; } + } + + public final ExceptionSpecificationContext exceptionSpecification() throws RecognitionException { + ExceptionSpecificationContext _localctx = new ExceptionSpecificationContext(_ctx, getState()); + enterRule(_localctx, 366, RULE_exceptionSpecification); + try { + setState(1986); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Throw: + enterOuterAlt(_localctx, 1); + { + setState(1984); + dynamicExceptionSpecification(); + } + break; + case Noexcept: + enterOuterAlt(_localctx, 2); + { + setState(1985); + noeExceptSpecification(); + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class DynamicExceptionSpecificationContext extends ParserRuleContext { + public TerminalNode Throw() { return getToken(CPP14Parser.Throw, 0); } + public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); } + public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); } + public TypeIdListContext typeIdList() { + return getRuleContext(TypeIdListContext.class,0); + } + public DynamicExceptionSpecificationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_dynamicExceptionSpecification; } + } + + public final DynamicExceptionSpecificationContext dynamicExceptionSpecification() throws RecognitionException { + DynamicExceptionSpecificationContext _localctx = new DynamicExceptionSpecificationContext(_ctx, getState()); + enterRule(_localctx, 368, RULE_dynamicExceptionSpecification); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1988); + match(Throw); + setState(1989); + match(LeftParen); + setState(1991); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 13)) & ~0x3f) == 0 && ((1L << (_la - 13)) & ((1L << (Auto - 13)) | (1L << (Bool - 13)) | (1L << (Char - 13)) | (1L << (Char16 - 13)) | (1L << (Char32 - 13)) | (1L << (Class - 13)) | (1L << (Const - 13)) | (1L << (Decltype - 13)) | (1L << (Double - 13)) | (1L << (Enum - 13)) | (1L << (Float - 13)) | (1L << (Int - 13)) | (1L << (Long - 13)) | (1L << (Short - 13)) | (1L << (Signed - 13)) | (1L << (Struct - 13)) | (1L << (Typename_ - 13)))) != 0) || ((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & ((1L << (Union - 77)) | (1L << (Unsigned - 77)) | (1L << (Void - 77)) | (1L << (Volatile - 77)) | (1L << (Wchar - 77)) | (1L << (Doublecolon - 77)) | (1L << (Identifier - 77)))) != 0)) { + { + setState(1990); + typeIdList(); + } + } + + setState(1993); + match(RightParen); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeIdListContext extends ParserRuleContext { + public List theTypeId() { + return getRuleContexts(TheTypeIdContext.class); + } + public TheTypeIdContext theTypeId(int i) { + return getRuleContext(TheTypeIdContext.class,i); + } + public List Ellipsis() { return getTokens(CPP14Parser.Ellipsis); } + public TerminalNode Ellipsis(int i) { + return getToken(CPP14Parser.Ellipsis, i); + } + public List Comma() { return getTokens(CPP14Parser.Comma); } + public TerminalNode Comma(int i) { + return getToken(CPP14Parser.Comma, i); + } + public TypeIdListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeIdList; } + } + + public final TypeIdListContext typeIdList() throws RecognitionException { + TypeIdListContext _localctx = new TypeIdListContext(_ctx, getState()); + enterRule(_localctx, 370, RULE_typeIdList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1995); + theTypeId(); + setState(1997); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Ellipsis) { + { + setState(1996); + match(Ellipsis); + } + } + + setState(2006); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==Comma) { + { + { + setState(1999); + match(Comma); + setState(2000); + theTypeId(); + setState(2002); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==Ellipsis) { + { + setState(2001); + match(Ellipsis); + } + } + + } + } + setState(2008); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class NoeExceptSpecificationContext extends ParserRuleContext { + public TerminalNode Noexcept() { return getToken(CPP14Parser.Noexcept, 0); } + public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); } + public ConstantExpressionContext constantExpression() { + return getRuleContext(ConstantExpressionContext.class,0); + } + public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); } + public NoeExceptSpecificationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_noeExceptSpecification; } + } + + public final NoeExceptSpecificationContext noeExceptSpecification() throws RecognitionException { + NoeExceptSpecificationContext _localctx = new NoeExceptSpecificationContext(_ctx, getState()); + enterRule(_localctx, 372, RULE_noeExceptSpecification); + try { + setState(2015); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,293,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2009); + match(Noexcept); + setState(2010); + match(LeftParen); + setState(2011); + constantExpression(); + setState(2012); + match(RightParen); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2014); + match(Noexcept); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TheOperatorContext extends ParserRuleContext { + public TerminalNode New() { return getToken(CPP14Parser.New, 0); } + public TerminalNode LeftBracket() { return getToken(CPP14Parser.LeftBracket, 0); } + public TerminalNode RightBracket() { return getToken(CPP14Parser.RightBracket, 0); } + public TerminalNode Delete() { return getToken(CPP14Parser.Delete, 0); } + public TerminalNode Plus() { return getToken(CPP14Parser.Plus, 0); } + public TerminalNode Minus() { return getToken(CPP14Parser.Minus, 0); } + public TerminalNode Star() { return getToken(CPP14Parser.Star, 0); } + public TerminalNode Div() { return getToken(CPP14Parser.Div, 0); } + public TerminalNode Mod() { return getToken(CPP14Parser.Mod, 0); } + public TerminalNode Caret() { return getToken(CPP14Parser.Caret, 0); } + public TerminalNode And() { return getToken(CPP14Parser.And, 0); } + public TerminalNode Or() { return getToken(CPP14Parser.Or, 0); } + public TerminalNode Tilde() { return getToken(CPP14Parser.Tilde, 0); } + public TerminalNode Not() { return getToken(CPP14Parser.Not, 0); } + public TerminalNode Assign() { return getToken(CPP14Parser.Assign, 0); } + public List Greater() { return getTokens(CPP14Parser.Greater); } + public TerminalNode Greater(int i) { + return getToken(CPP14Parser.Greater, i); + } + public List Less() { return getTokens(CPP14Parser.Less); } + public TerminalNode Less(int i) { + return getToken(CPP14Parser.Less, i); + } + public TerminalNode GreaterEqual() { return getToken(CPP14Parser.GreaterEqual, 0); } + public TerminalNode PlusAssign() { return getToken(CPP14Parser.PlusAssign, 0); } + public TerminalNode MinusAssign() { return getToken(CPP14Parser.MinusAssign, 0); } + public TerminalNode StarAssign() { return getToken(CPP14Parser.StarAssign, 0); } + public TerminalNode ModAssign() { return getToken(CPP14Parser.ModAssign, 0); } + public TerminalNode XorAssign() { return getToken(CPP14Parser.XorAssign, 0); } + public TerminalNode AndAssign() { return getToken(CPP14Parser.AndAssign, 0); } + public TerminalNode OrAssign() { return getToken(CPP14Parser.OrAssign, 0); } + public TerminalNode RightShiftAssign() { return getToken(CPP14Parser.RightShiftAssign, 0); } + public TerminalNode LeftShiftAssign() { return getToken(CPP14Parser.LeftShiftAssign, 0); } + public TerminalNode Equal() { return getToken(CPP14Parser.Equal, 0); } + public TerminalNode NotEqual() { return getToken(CPP14Parser.NotEqual, 0); } + public TerminalNode LessEqual() { return getToken(CPP14Parser.LessEqual, 0); } + public TerminalNode AndAnd() { return getToken(CPP14Parser.AndAnd, 0); } + public TerminalNode OrOr() { return getToken(CPP14Parser.OrOr, 0); } + public TerminalNode PlusPlus() { return getToken(CPP14Parser.PlusPlus, 0); } + public TerminalNode MinusMinus() { return getToken(CPP14Parser.MinusMinus, 0); } + public TerminalNode Comma() { return getToken(CPP14Parser.Comma, 0); } + public TerminalNode ArrowStar() { return getToken(CPP14Parser.ArrowStar, 0); } + public TerminalNode Arrow() { return getToken(CPP14Parser.Arrow, 0); } + public TerminalNode LeftParen() { return getToken(CPP14Parser.LeftParen, 0); } + public TerminalNode RightParen() { return getToken(CPP14Parser.RightParen, 0); } + public TheOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_theOperator; } + } + + public final TheOperatorContext theOperator() throws RecognitionException { + TheOperatorContext _localctx = new TheOperatorContext(_ctx, getState()); + enterRule(_localctx, 374, RULE_theOperator); + try { + setState(2070); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,296,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2017); + match(New); + setState(2020); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,294,_ctx) ) { + case 1: + { + setState(2018); + match(LeftBracket); + setState(2019); + match(RightBracket); + } + break; + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2022); + match(Delete); + setState(2025); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,295,_ctx) ) { + case 1: + { + setState(2023); + match(LeftBracket); + setState(2024); + match(RightBracket); + } + break; + } + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2027); + match(Plus); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(2028); + match(Minus); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(2029); + match(Star); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(2030); + match(Div); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(2031); + match(Mod); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(2032); + match(Caret); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(2033); + match(And); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(2034); + match(Or); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(2035); + match(Tilde); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(2036); + match(Not); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(2037); + match(Assign); + } + break; + case 14: + enterOuterAlt(_localctx, 14); + { + setState(2038); + match(Greater); + } + break; + case 15: + enterOuterAlt(_localctx, 15); + { + setState(2039); + match(Less); + } + break; + case 16: + enterOuterAlt(_localctx, 16); + { + setState(2040); + match(GreaterEqual); + } + break; + case 17: + enterOuterAlt(_localctx, 17); + { + setState(2041); + match(PlusAssign); + } + break; + case 18: + enterOuterAlt(_localctx, 18); + { + setState(2042); + match(MinusAssign); + } + break; + case 19: + enterOuterAlt(_localctx, 19); + { + setState(2043); + match(StarAssign); + } + break; + case 20: + enterOuterAlt(_localctx, 20); + { + setState(2044); + match(Assign); + } + break; + case 21: + enterOuterAlt(_localctx, 21); + { + setState(2045); + match(ModAssign); + } + break; + case 22: + enterOuterAlt(_localctx, 22); + { + setState(2046); + match(XorAssign); + } + break; + case 23: + enterOuterAlt(_localctx, 23); + { + setState(2047); + match(AndAssign); + } + break; + case 24: + enterOuterAlt(_localctx, 24); + { + setState(2048); + match(OrAssign); + } + break; + case 25: + enterOuterAlt(_localctx, 25); + { + setState(2049); + match(Less); + setState(2050); + match(Less); + } + break; + case 26: + enterOuterAlt(_localctx, 26); + { + setState(2051); + match(Greater); + setState(2052); + match(Greater); + } + break; + case 27: + enterOuterAlt(_localctx, 27); + { + setState(2053); + match(RightShiftAssign); + } + break; + case 28: + enterOuterAlt(_localctx, 28); + { + setState(2054); + match(LeftShiftAssign); + } + break; + case 29: + enterOuterAlt(_localctx, 29); + { + setState(2055); + match(Equal); + } + break; + case 30: + enterOuterAlt(_localctx, 30); + { + setState(2056); + match(NotEqual); + } + break; + case 31: + enterOuterAlt(_localctx, 31); + { + setState(2057); + match(LessEqual); + } + break; + case 32: + enterOuterAlt(_localctx, 32); + { + setState(2058); + match(GreaterEqual); + } + break; + case 33: + enterOuterAlt(_localctx, 33); + { + setState(2059); + match(AndAnd); + } + break; + case 34: + enterOuterAlt(_localctx, 34); + { + setState(2060); + match(OrOr); + } + break; + case 35: + enterOuterAlt(_localctx, 35); + { + setState(2061); + match(PlusPlus); + } + break; + case 36: + enterOuterAlt(_localctx, 36); + { + setState(2062); + match(MinusMinus); + } + break; + case 37: + enterOuterAlt(_localctx, 37); + { + setState(2063); + match(Comma); + } + break; + case 38: + enterOuterAlt(_localctx, 38); + { + setState(2064); + match(ArrowStar); + } + break; + case 39: + enterOuterAlt(_localctx, 39); + { + setState(2065); + match(Arrow); + } + break; + case 40: + enterOuterAlt(_localctx, 40); + { + setState(2066); + match(LeftParen); + setState(2067); + match(RightParen); + } + break; + case 41: + enterOuterAlt(_localctx, 41); + { + setState(2068); + match(LeftBracket); + setState(2069); + match(RightBracket); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LiteralContext extends ParserRuleContext { + public TerminalNode IntegerLiteral() { return getToken(CPP14Parser.IntegerLiteral, 0); } + public TerminalNode CharacterLiteral() { return getToken(CPP14Parser.CharacterLiteral, 0); } + public TerminalNode FloatingLiteral() { return getToken(CPP14Parser.FloatingLiteral, 0); } + public TerminalNode StringLiteral() { return getToken(CPP14Parser.StringLiteral, 0); } + public TerminalNode BooleanLiteral() { return getToken(CPP14Parser.BooleanLiteral, 0); } + public TerminalNode PointerLiteral() { return getToken(CPP14Parser.PointerLiteral, 0); } + public TerminalNode UserDefinedLiteral() { return getToken(CPP14Parser.UserDefinedLiteral, 0); } + public LiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_literal; } + } + + public final LiteralContext literal() throws RecognitionException { + LiteralContext _localctx = new LiteralContext(_ctx, getState()); + enterRule(_localctx, 376, RULE_literal); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2072); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << IntegerLiteral) | (1L << CharacterLiteral) | (1L << FloatingLiteral) | (1L << StringLiteral) | (1L << BooleanLiteral) | (1L << PointerLiteral) | (1L << UserDefinedLiteral))) != 0)) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { + switch (ruleIndex) { + case 5: + return nestedNameSpecifier_sempred((NestedNameSpecifierContext)_localctx, predIndex); + case 15: + return postfixExpression_sempred((PostfixExpressionContext)_localctx, predIndex); + case 25: + return noPointerNewDeclarator_sempred((NoPointerNewDeclaratorContext)_localctx, predIndex); + case 113: + return noPointerDeclarator_sempred((NoPointerDeclaratorContext)_localctx, predIndex); + case 124: + return noPointerAbstractDeclarator_sempred((NoPointerAbstractDeclaratorContext)_localctx, predIndex); + case 126: + return noPointerAbstractPackDeclarator_sempred((NoPointerAbstractPackDeclaratorContext)_localctx, predIndex); + } + return true; + } + private boolean nestedNameSpecifier_sempred(NestedNameSpecifierContext _localctx, int predIndex) { + switch (predIndex) { + case 0: + return precpred(_ctx, 1); + } + return true; + } + private boolean postfixExpression_sempred(PostfixExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 1: + return precpred(_ctx, 7); + case 2: + return precpred(_ctx, 6); + case 3: + return precpred(_ctx, 4); + case 4: + return precpred(_ctx, 3); + } + return true; + } + private boolean noPointerNewDeclarator_sempred(NoPointerNewDeclaratorContext _localctx, int predIndex) { + switch (predIndex) { + case 5: + return precpred(_ctx, 1); + } + return true; + } + private boolean noPointerDeclarator_sempred(NoPointerDeclaratorContext _localctx, int predIndex) { + switch (predIndex) { + case 6: + return precpred(_ctx, 2); + } + return true; + } + private boolean noPointerAbstractDeclarator_sempred(NoPointerAbstractDeclaratorContext _localctx, int predIndex) { + switch (predIndex) { + case 7: + return precpred(_ctx, 4); + } + return true; + } + private boolean noPointerAbstractPackDeclarator_sempred(NoPointerAbstractPackDeclaratorContext _localctx, int predIndex) { + switch (predIndex) { + case 8: + return precpred(_ctx, 2); + } + return true; + } + + public static final String _serializedATN = + "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u0093\u081d\4\2\t"+ + "\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+ + "\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+ + "\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+ + "\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+ + "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+ + ",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+ + "\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+ + "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+ + "\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+ + "\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+ + "`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t"+ + "k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4"+ + "w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t\u0080"+ + "\4\u0081\t\u0081\4\u0082\t\u0082\4\u0083\t\u0083\4\u0084\t\u0084\4\u0085"+ + "\t\u0085\4\u0086\t\u0086\4\u0087\t\u0087\4\u0088\t\u0088\4\u0089\t\u0089"+ + "\4\u008a\t\u008a\4\u008b\t\u008b\4\u008c\t\u008c\4\u008d\t\u008d\4\u008e"+ + "\t\u008e\4\u008f\t\u008f\4\u0090\t\u0090\4\u0091\t\u0091\4\u0092\t\u0092"+ + "\4\u0093\t\u0093\4\u0094\t\u0094\4\u0095\t\u0095\4\u0096\t\u0096\4\u0097"+ + "\t\u0097\4\u0098\t\u0098\4\u0099\t\u0099\4\u009a\t\u009a\4\u009b\t\u009b"+ + "\4\u009c\t\u009c\4\u009d\t\u009d\4\u009e\t\u009e\4\u009f\t\u009f\4\u00a0"+ + "\t\u00a0\4\u00a1\t\u00a1\4\u00a2\t\u00a2\4\u00a3\t\u00a3\4\u00a4\t\u00a4"+ + "\4\u00a5\t\u00a5\4\u00a6\t\u00a6\4\u00a7\t\u00a7\4\u00a8\t\u00a8\4\u00a9"+ + "\t\u00a9\4\u00aa\t\u00aa\4\u00ab\t\u00ab\4\u00ac\t\u00ac\4\u00ad\t\u00ad"+ + "\4\u00ae\t\u00ae\4\u00af\t\u00af\4\u00b0\t\u00b0\4\u00b1\t\u00b1\4\u00b2"+ + "\t\u00b2\4\u00b3\t\u00b3\4\u00b4\t\u00b4\4\u00b5\t\u00b5\4\u00b6\t\u00b6"+ + "\4\u00b7\t\u00b7\4\u00b8\t\u00b8\4\u00b9\t\u00b9\4\u00ba\t\u00ba\4\u00bb"+ + "\t\u00bb\4\u00bc\t\u00bc\4\u00bd\t\u00bd\4\u00be\t\u00be\3\2\5\2\u017e"+ + "\n\2\3\2\3\2\3\3\6\3\u0183\n\3\r\3\16\3\u0184\3\3\3\3\3\3\3\3\3\3\3\3"+ + "\3\3\5\3\u018e\n\3\3\4\3\4\5\4\u0192\n\4\3\5\3\5\3\5\3\5\3\5\3\5\3\5\5"+ + "\5\u019b\n\5\3\5\5\5\u019e\n\5\3\6\3\6\5\6\u01a2\n\6\3\6\3\6\3\7\3\7\3"+ + "\7\3\7\5\7\u01aa\n\7\3\7\3\7\3\7\3\7\3\7\5\7\u01b1\n\7\3\7\5\7\u01b4\n"+ + "\7\3\7\7\7\u01b7\n\7\f\7\16\7\u01ba\13\7\3\b\3\b\5\b\u01be\n\b\3\b\3\b"+ + "\3\t\3\t\5\t\u01c4\n\t\3\t\3\t\3\n\3\n\3\n\3\n\5\n\u01cc\n\n\5\n\u01ce"+ + "\n\n\3\13\3\13\3\f\3\f\3\f\7\f\u01d5\n\f\f\f\16\f\u01d8\13\f\3\f\5\f\u01db"+ + "\n\f\3\r\3\r\5\r\u01df\n\r\3\16\5\16\u01e2\n\16\3\16\3\16\5\16\u01e6\n"+ + "\16\3\17\5\17\u01e9\n\17\3\17\3\17\3\17\3\20\3\20\5\20\u01f0\n\20\3\20"+ + "\3\20\5\20\u01f4\n\20\3\20\5\20\u01f7\n\20\3\20\5\20\u01fa\n\20\3\20\5"+ + "\20\u01fd\n\20\3\21\3\21\3\21\3\21\5\21\u0203\n\21\3\21\3\21\5\21\u0207"+ + "\n\21\3\21\3\21\5\21\u020b\n\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21"+ + "\3\21\3\21\3\21\3\21\5\21\u0219\n\21\3\21\3\21\5\21\u021d\n\21\3\21\3"+ + "\21\3\21\3\21\5\21\u0223\n\21\3\21\3\21\3\21\3\21\3\21\5\21\u022a\n\21"+ + "\3\21\3\21\3\21\3\21\5\21\u0230\n\21\3\21\3\21\5\21\u0234\n\21\3\21\3"+ + "\21\7\21\u0238\n\21\f\21\16\21\u023b\13\21\3\22\3\22\3\23\3\23\3\24\5"+ + "\24\u0242\n\24\3\24\3\24\3\24\5\24\u0247\n\24\3\24\3\24\3\24\3\24\3\24"+ + "\3\24\3\24\3\24\3\24\3\24\3\24\5\24\u0254\n\24\3\25\3\25\3\25\3\25\3\25"+ + "\5\25\u025b\n\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\5\25"+ + "\u0267\n\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\5\25\u0271\n\25\3"+ + "\26\3\26\3\27\5\27\u0276\n\27\3\27\3\27\5\27\u027a\n\27\3\27\3\27\3\27"+ + "\3\27\3\27\5\27\u0281\n\27\3\27\5\27\u0284\n\27\3\30\3\30\3\30\3\30\3"+ + "\31\3\31\5\31\u028c\n\31\3\32\3\32\5\32\u0290\n\32\3\32\5\32\u0293\n\32"+ + "\3\33\3\33\3\33\3\33\3\33\5\33\u029a\n\33\3\33\3\33\3\33\3\33\3\33\5\33"+ + "\u02a1\n\33\7\33\u02a3\n\33\f\33\16\33\u02a6\13\33\3\34\3\34\5\34\u02aa"+ + "\n\34\3\34\3\34\5\34\u02ae\n\34\3\35\5\35\u02b1\n\35\3\35\3\35\3\35\5"+ + "\35\u02b6\n\35\3\35\3\35\3\36\3\36\3\36\3\36\3\36\3\37\3\37\3\37\3\37"+ + "\3\37\3\37\5\37\u02c5\n\37\3 \3 \3 \7 \u02ca\n \f \16 \u02cd\13 \3!\3"+ + "!\3!\7!\u02d2\n!\f!\16!\u02d5\13!\3\"\3\"\3\"\7\"\u02da\n\"\f\"\16\"\u02dd"+ + "\13\"\3#\3#\3#\3#\7#\u02e3\n#\f#\16#\u02e6\13#\3$\3$\3$\3$\5$\u02ec\n"+ + "$\3%\3%\3%\7%\u02f1\n%\f%\16%\u02f4\13%\3&\3&\3&\7&\u02f9\n&\f&\16&\u02fc"+ + "\13&\3\'\3\'\3\'\7\'\u0301\n\'\f\'\16\'\u0304\13\'\3(\3(\3(\7(\u0309\n"+ + "(\f(\16(\u030c\13(\3)\3)\3)\7)\u0311\n)\f)\16)\u0314\13)\3*\3*\3*\7*\u0319"+ + "\n*\f*\16*\u031c\13*\3+\3+\3+\7+\u0321\n+\f+\16+\u0324\13+\3,\3,\3,\3"+ + ",\3,\3,\5,\u032c\n,\3-\3-\3-\3-\3-\3-\5-\u0334\n-\3.\3.\3/\3/\3/\7/\u033b"+ + "\n/\f/\16/\u033e\13/\3\60\3\60\3\61\3\61\5\61\u0344\n\61\3\61\3\61\3\61"+ + "\3\61\3\61\3\61\5\61\u034c\n\61\3\61\5\61\u034f\n\61\3\62\5\62\u0352\n"+ + "\62\3\62\3\62\3\62\3\62\5\62\u0358\n\62\3\62\3\62\3\62\3\63\5\63\u035e"+ + "\n\63\3\63\3\63\3\64\3\64\5\64\u0364\n\64\3\64\3\64\3\65\6\65\u0369\n"+ + "\65\r\65\16\65\u036a\3\66\3\66\3\66\3\66\3\66\3\66\3\66\5\66\u0374\n\66"+ + "\3\66\3\66\3\66\3\66\3\66\3\66\5\66\u037c\n\66\3\67\3\67\5\67\u0380\n"+ + "\67\3\67\3\67\3\67\3\67\3\67\5\67\u0387\n\67\5\67\u0389\n\67\38\38\38"+ + "\38\38\38\38\38\38\38\38\38\38\38\38\38\38\38\58\u039d\n8\38\38\58\u03a1"+ + "\n8\38\38\38\38\58\u03a7\n8\38\38\38\58\u03ac\n8\39\39\59\u03b0\n9\3:"+ + "\5:\u03b3\n:\3:\3:\3:\3;\3;\5;\u03ba\n;\3<\3<\3<\3<\3<\5<\u03c1\n<\3<"+ + "\3<\5<\u03c5\n<\3<\3<\3=\3=\3>\6>\u03cc\n>\r>\16>\u03cd\3?\3?\3?\3?\3"+ + "?\3?\3?\3?\3?\5?\u03d9\n?\3@\3@\3@\3@\3@\3@\3@\3@\5@\u03e3\n@\3A\3A\3"+ + "A\5A\u03e8\nA\3A\3A\3A\3A\3B\5B\u03ef\nB\3B\5B\u03f2\nB\3B\3B\3B\5B\u03f7"+ + "\nB\3B\3B\3B\5B\u03fc\nB\3C\3C\3C\3C\3C\3C\3C\3C\3D\3D\3E\3E\3E\3F\3F"+ + "\3F\3F\3F\3F\5F\u0411\nF\3G\6G\u0414\nG\rG\16G\u0415\3G\5G\u0419\nG\3"+ + "H\3H\3I\3I\3J\3J\3K\3K\3K\5K\u0424\nK\3L\3L\3L\3L\5L\u042a\nL\3M\6M\u042d"+ + "\nM\rM\16M\u042e\3M\5M\u0432\nM\3N\6N\u0435\nN\rN\16N\u0436\3N\5N\u043a"+ + "\nN\3O\5O\u043d\nO\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O\3O"+ + "\3O\3O\3O\5O\u0453\nO\3P\3P\3P\3P\5P\u0459\nP\3Q\3Q\3Q\3Q\5Q\u045f\nQ"+ + "\3Q\3Q\3R\3R\5R\u0465\nR\3R\5R\u0468\nR\3R\3R\3R\3R\5R\u046e\nR\3R\3R"+ + "\5R\u0472\nR\3R\3R\5R\u0476\nR\3R\5R\u0479\nR\3S\3S\3T\3T\3T\3T\5T\u0481"+ + "\nT\5T\u0483\nT\3T\3T\3U\3U\5U\u0489\nU\3U\5U\u048c\nU\3U\5U\u048f\nU"+ + "\3U\5U\u0492\nU\3V\3V\5V\u0496\nV\3V\3V\5V\u049a\nV\3V\3V\3W\3W\5W\u04a0"+ + "\nW\3X\3X\3X\3Y\3Y\3Y\7Y\u04a8\nY\fY\16Y\u04ab\13Y\3Z\3Z\3Z\5Z\u04b0\n"+ + "Z\3[\3[\3\\\3\\\5\\\u04b6\n\\\3]\3]\3^\5^\u04bb\n^\3^\3^\3^\5^\u04c0\n"+ + "^\3^\3^\5^\u04c4\n^\3^\3^\3_\3_\3`\3`\3`\3`\3`\3`\3a\5a\u04d1\na\3a\3"+ + "a\3b\3b\5b\u04d7\nb\3b\3b\5b\u04db\nb\3b\3b\3b\3c\5c\u04e1\nc\3c\3c\3"+ + "c\5c\u04e6\nc\3c\3c\3c\3d\3d\3d\3d\3d\3d\3e\3e\3e\3e\5e\u04f5\ne\3e\3"+ + "e\5e\u04f9\ne\3f\6f\u04fc\nf\rf\16f\u04fd\3g\3g\3g\5g\u0503\ng\3g\3g\3"+ + "g\5g\u0508\ng\3h\3h\3h\3h\5h\u050e\nh\3h\5h\u0511\nh\3h\3h\3i\3i\3i\7"+ + "i\u0518\ni\fi\16i\u051b\13i\3i\5i\u051e\ni\3j\3j\3j\5j\u0523\nj\3j\3j"+ + "\5j\u0527\nj\3k\3k\3l\3l\5l\u052d\nl\3l\3l\3m\6m\u0532\nm\rm\16m\u0533"+ + "\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\3n\6n\u0543\nn\rn\16n\u0544\5n\u0547"+ + "\nn\3o\3o\3o\7o\u054c\no\fo\16o\u054f\13o\3p\3p\5p\u0553\np\3q\3q\3q\3"+ + "q\3q\5q\u055a\nq\3r\3r\5r\u055e\nr\7r\u0560\nr\fr\16r\u0563\13r\3r\3r"+ + "\3s\3s\3s\5s\u056a\ns\3s\3s\3s\3s\5s\u0570\ns\3s\3s\3s\3s\5s\u0576\ns"+ + "\3s\3s\5s\u057a\ns\5s\u057c\ns\7s\u057e\ns\fs\16s\u0581\13s\3t\3t\5t\u0585"+ + "\nt\3t\3t\5t\u0589\nt\3t\5t\u058c\nt\3t\5t\u058f\nt\3t\5t\u0592\nt\3u"+ + "\3u\3u\5u\u0597\nu\3v\3v\5v\u059b\nv\3v\5v\u059e\nv\3v\3v\5v\u05a2\nv"+ + "\3v\5v\u05a5\nv\5v\u05a7\nv\3w\6w\u05aa\nw\rw\16w\u05ab\3x\3x\3y\3y\3"+ + "z\5z\u05b3\nz\3z\3z\3{\3{\5{\u05b9\n{\3|\3|\5|\u05bd\n|\3|\3|\3|\3|\5"+ + "|\u05c3\n|\3}\3}\6}\u05c7\n}\r}\16}\u05c8\3}\5}\u05cc\n}\5}\u05ce\n}\3"+ + "~\3~\3~\3~\5~\u05d4\n~\3~\3~\5~\u05d8\n~\3~\3~\3~\3~\5~\u05de\n~\3~\3"+ + "~\3~\3~\3~\5~\u05e5\n~\3~\3~\5~\u05e9\n~\5~\u05eb\n~\7~\u05ed\n~\f~\16"+ + "~\u05f0\13~\3\177\7\177\u05f3\n\177\f\177\16\177\u05f6\13\177\3\177\3"+ + "\177\3\u0080\3\u0080\3\u0080\3\u0080\3\u0080\3\u0080\3\u0080\5\u0080\u0601"+ + "\n\u0080\3\u0080\3\u0080\5\u0080\u0605\n\u0080\5\u0080\u0607\n\u0080\7"+ + "\u0080\u0609\n\u0080\f\u0080\16\u0080\u060c\13\u0080\3\u0081\3\u0081\5"+ + "\u0081\u0610\n\u0081\3\u0081\5\u0081\u0613\n\u0081\3\u0082\3\u0082\3\u0082"+ + "\7\u0082\u0618\n\u0082\f\u0082\16\u0082\u061b\13\u0082\3\u0083\5\u0083"+ + "\u061e\n\u0083\3\u0083\3\u0083\3\u0083\5\u0083\u0623\n\u0083\5\u0083\u0625"+ + "\n\u0083\3\u0083\3\u0083\5\u0083\u0629\n\u0083\3\u0084\5\u0084\u062c\n"+ + "\u0084\3\u0084\5\u0084\u062f\n\u0084\3\u0084\3\u0084\5\u0084\u0633\n\u0084"+ + "\3\u0084\3\u0084\3\u0085\5\u0085\u0638\n\u0085\3\u0085\3\u0085\3\u0085"+ + "\3\u0085\3\u0085\5\u0085\u063f\n\u0085\3\u0086\3\u0086\3\u0086\3\u0086"+ + "\3\u0086\5\u0086\u0646\n\u0086\3\u0087\3\u0087\3\u0087\5\u0087\u064b\n"+ + "\u0087\3\u0088\3\u0088\5\u0088\u064f\n\u0088\3\u0089\3\u0089\5\u0089\u0653"+ + "\n\u0089\3\u0089\3\u0089\3\u0089\5\u0089\u0658\n\u0089\7\u0089\u065a\n"+ + "\u0089\f\u0089\16\u0089\u065d\13\u0089\3\u008a\3\u008a\3\u008a\5\u008a"+ + "\u0662\n\u008a\5\u008a\u0664\n\u008a\3\u008a\3\u008a\3\u008b\3\u008b\5"+ + "\u008b\u066a\n\u008b\3\u008c\3\u008c\3\u008c\5\u008c\u066f\n\u008c\3\u008c"+ + "\3\u008c\3\u008d\3\u008d\5\u008d\u0675\n\u008d\3\u008d\3\u008d\5\u008d"+ + "\u0679\n\u008d\5\u008d\u067b\n\u008d\3\u008d\5\u008d\u067e\n\u008d\3\u008d"+ + "\3\u008d\5\u008d\u0682\n\u008d\3\u008d\3\u008d\5\u008d\u0686\n\u008d\5"+ + "\u008d\u0688\n\u008d\5\u008d\u068a\n\u008d\3\u008e\5\u008e\u068d\n\u008e"+ + "\3\u008e\3\u008e\3\u008f\3\u008f\3\u0090\3\u0090\3\u0091\3\u0091\3\u0091"+ + "\3\u0091\6\u0091\u0699\n\u0091\r\u0091\16\u0091\u069a\3\u0092\5\u0092"+ + "\u069e\n\u0092\3\u0092\5\u0092\u06a1\n\u0092\3\u0092\5\u0092\u06a4\n\u0092"+ + "\3\u0092\3\u0092\3\u0092\3\u0092\3\u0092\3\u0092\3\u0092\5\u0092\u06ad"+ + "\n\u0092\3\u0093\3\u0093\3\u0093\7\u0093\u06b2\n\u0093\f\u0093\16\u0093"+ + "\u06b5\13\u0093\3\u0094\3\u0094\5\u0094\u06b9\n\u0094\3\u0094\5\u0094"+ + "\u06bc\n\u0094\3\u0094\5\u0094\u06bf\n\u0094\5\u0094\u06c1\n\u0094\3\u0094"+ + "\5\u0094\u06c4\n\u0094\3\u0094\5\u0094\u06c7\n\u0094\3\u0094\3\u0094\5"+ + "\u0094\u06cb\n\u0094\3\u0095\6\u0095\u06ce\n\u0095\r\u0095\16\u0095\u06cf"+ + "\3\u0096\3\u0096\3\u0097\3\u0097\3\u0097\3\u0097\3\u0098\3\u0098\3\u0098"+ + "\3\u0099\3\u0099\5\u0099\u06dd\n\u0099\3\u0099\3\u0099\3\u0099\5\u0099"+ + "\u06e2\n\u0099\7\u0099\u06e4\n\u0099\f\u0099\16\u0099\u06e7\13\u0099\3"+ + "\u009a\5\u009a\u06ea\n\u009a\3\u009a\3\u009a\3\u009a\5\u009a\u06ef\n\u009a"+ + "\3\u009a\3\u009a\3\u009a\5\u009a\u06f4\n\u009a\3\u009a\3\u009a\5\u009a"+ + "\u06f8\n\u009a\3\u009b\5\u009b\u06fb\n\u009b\3\u009b\3\u009b\5\u009b\u06ff"+ + "\n\u009b\3\u009c\3\u009c\3\u009d\3\u009d\3\u009e\3\u009e\3\u009e\3\u009f"+ + "\3\u009f\5\u009f\u070a\n\u009f\3\u00a0\3\u00a0\5\u00a0\u070e\n\u00a0\3"+ + "\u00a1\3\u00a1\3\u00a1\3\u00a2\3\u00a2\5\u00a2\u0715\n\u00a2\3\u00a2\3"+ + "\u00a2\3\u00a2\5\u00a2\u071a\n\u00a2\7\u00a2\u071c\n\u00a2\f\u00a2\16"+ + "\u00a2\u071f\13\u00a2\3\u00a3\3\u00a3\3\u00a3\5\u00a3\u0724\n\u00a3\3"+ + "\u00a3\3\u00a3\5\u00a3\u0728\n\u00a3\3\u00a4\3\u00a4\5\u00a4\u072c\n\u00a4"+ + "\3\u00a5\3\u00a5\3\u00a5\3\u00a6\3\u00a6\3\u00a6\3\u00a6\5\u00a6\u0735"+ + "\n\u00a6\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a7\3\u00a8\3\u00a8"+ + "\3\u00a8\7\u00a8\u0740\n\u00a8\f\u00a8\16\u00a8\u0743\13\u00a8\3\u00a9"+ + "\3\u00a9\5\u00a9\u0747\n\u00a9\3\u00aa\3\u00aa\3\u00aa\3\u00aa\3\u00aa"+ + "\5\u00aa\u074e\n\u00aa\3\u00aa\3\u00aa\5\u00aa\u0752\n\u00aa\3\u00aa\5"+ + "\u00aa\u0755\n\u00aa\3\u00aa\5\u00aa\u0758\n\u00aa\3\u00aa\5\u00aa\u075b"+ + "\n\u00aa\3\u00aa\3\u00aa\5\u00aa\u075f\n\u00aa\3\u00ab\3\u00ab\3\u00ab"+ + "\5\u00ab\u0764\n\u00ab\3\u00ab\3\u00ab\3\u00ac\3\u00ac\3\u00ac\5\u00ac"+ + "\u076b\n\u00ac\3\u00ac\3\u00ac\5\u00ac\u076f\n\u00ac\3\u00ac\3\u00ac\5"+ + "\u00ac\u0773\n\u00ac\3\u00ad\3\u00ad\3\u00ae\3\u00ae\5\u00ae\u0779\n\u00ae"+ + "\3\u00ae\3\u00ae\3\u00ae\5\u00ae\u077e\n\u00ae\7\u00ae\u0780\n\u00ae\f"+ + "\u00ae\16\u00ae\u0783\13\u00ae\3\u00af\3\u00af\3\u00af\5\u00af\u0788\n"+ + "\u00af\3\u00b0\3\u00b0\3\u00b0\3\u00b0\5\u00b0\u078e\n\u00b0\3\u00b0\5"+ + "\u00b0\u0791\n\u00b0\3\u00b1\5\u00b1\u0794\n\u00b1\3\u00b1\3\u00b1\3\u00b1"+ + "\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b3\3\u00b3\3\u00b3\3\u00b3"+ + "\3\u00b4\3\u00b4\5\u00b4\u07a4\n\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b5"+ + "\6\u00b5\u07aa\n\u00b5\r\u00b5\16\u00b5\u07ab\3\u00b6\3\u00b6\3\u00b6"+ + "\3\u00b6\3\u00b6\3\u00b6\3\u00b7\5\u00b7\u07b5\n\u00b7\3\u00b7\3\u00b7"+ + "\3\u00b7\5\u00b7\u07ba\n\u00b7\3\u00b7\5\u00b7\u07bd\n\u00b7\3\u00b8\3"+ + "\u00b8\5\u00b8\u07c1\n\u00b8\3\u00b9\3\u00b9\5\u00b9\u07c5\n\u00b9\3\u00ba"+ + "\3\u00ba\3\u00ba\5\u00ba\u07ca\n\u00ba\3\u00ba\3\u00ba\3\u00bb\3\u00bb"+ + "\5\u00bb\u07d0\n\u00bb\3\u00bb\3\u00bb\3\u00bb\5\u00bb\u07d5\n\u00bb\7"+ + "\u00bb\u07d7\n\u00bb\f\u00bb\16\u00bb\u07da\13\u00bb\3\u00bc\3\u00bc\3"+ + "\u00bc\3\u00bc\3\u00bc\3\u00bc\5\u00bc\u07e2\n\u00bc\3\u00bd\3\u00bd\3"+ + "\u00bd\5\u00bd\u07e7\n\u00bd\3\u00bd\3\u00bd\3\u00bd\5\u00bd\u07ec\n\u00bd"+ + "\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd"+ + "\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd"+ + "\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd"+ + "\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd"+ + "\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\5\u00bd\u0819"+ + "\n\u00bd\3\u00be\3\u00be\3\u00be\2\b\f \64\u00e4\u00fa\u00fe\u00bf\2\4"+ + "\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNP"+ + "RTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c\u008e"+ + "\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e\u00a0\u00a2\u00a4\u00a6"+ + "\u00a8\u00aa\u00ac\u00ae\u00b0\u00b2\u00b4\u00b6\u00b8\u00ba\u00bc\u00be"+ + "\u00c0\u00c2\u00c4\u00c6\u00c8\u00ca\u00cc\u00ce\u00d0\u00d2\u00d4\u00d6"+ + "\u00d8\u00da\u00dc\u00de\u00e0\u00e2\u00e4\u00e6\u00e8\u00ea\u00ec\u00ee"+ + "\u00f0\u00f2\u00f4\u00f6\u00f8\u00fa\u00fc\u00fe\u0100\u0102\u0104\u0106"+ + "\u0108\u010a\u010c\u010e\u0110\u0112\u0114\u0116\u0118\u011a\u011c\u011e"+ + "\u0120\u0122\u0124\u0126\u0128\u012a\u012c\u012e\u0130\u0132\u0134\u0136"+ + "\u0138\u013a\u013c\u013e\u0140\u0142\u0144\u0146\u0148\u014a\u014c\u014e"+ + "\u0150\u0152\u0154\u0156\u0158\u015a\u015c\u015e\u0160\u0162\u0164\u0166"+ + "\u0168\u016a\u016c\u016e\u0170\u0172\u0174\u0176\u0178\u017a\2\27\4\2"+ + "ccgg\6\2\32\32!!<\u02c6"+ + "\3\2\2\2@\u02ce\3\2\2\2B\u02d6\3\2\2\2D\u02de\3\2\2\2F\u02eb\3\2\2\2H"+ + "\u02ed\3\2\2\2J\u02f5\3\2\2\2L\u02fd\3\2\2\2N\u0305\3\2\2\2P\u030d\3\2"+ + "\2\2R\u0315\3\2\2\2T\u031d\3\2\2\2V\u0325\3\2\2\2X\u0333\3\2\2\2Z\u0335"+ + "\3\2\2\2\\\u0337\3\2\2\2^\u033f\3\2\2\2`\u034e\3\2\2\2b\u0351\3\2\2\2"+ + "d\u035d\3\2\2\2f\u0361\3\2\2\2h\u0368\3\2\2\2j\u037b\3\2\2\2l\u0388\3"+ + "\2\2\2n\u03ab\3\2\2\2p\u03af\3\2\2\2r\u03b2\3\2\2\2t\u03b9\3\2\2\2v\u03c4"+ + "\3\2\2\2x\u03c8\3\2\2\2z\u03cb\3\2\2\2|\u03d8\3\2\2\2~\u03e2\3\2\2\2\u0080"+ + "\u03e4\3\2\2\2\u0082\u03fb\3\2\2\2\u0084\u03fd\3\2\2\2\u0086\u0405\3\2"+ + "\2\2\u0088\u0407\3\2\2\2\u008a\u0410\3\2\2\2\u008c\u0413\3\2\2\2\u008e"+ + "\u041a\3\2\2\2\u0090\u041c\3\2\2\2\u0092\u041e\3\2\2\2\u0094\u0423\3\2"+ + "\2\2\u0096\u0429\3\2\2\2\u0098\u042c\3\2\2\2\u009a\u0434\3\2\2\2\u009c"+ + "\u0452\3\2\2\2\u009e\u0458\3\2\2\2\u00a0\u045a\3\2\2\2\u00a2\u0478\3\2"+ + "\2\2\u00a4\u047a\3\2\2\2\u00a6\u047c\3\2\2\2\u00a8\u0486\3\2\2\2\u00aa"+ + "\u0493\3\2\2\2\u00ac\u049d\3\2\2\2\u00ae\u04a1\3\2\2\2\u00b0\u04a4\3\2"+ + "\2\2\u00b2\u04ac\3\2\2\2\u00b4\u04b1\3\2\2\2\u00b6\u04b5\3\2\2\2\u00b8"+ + "\u04b7\3\2\2\2\u00ba\u04ba\3\2\2\2\u00bc\u04c7\3\2\2\2\u00be\u04c9\3\2"+ + "\2\2\u00c0\u04d0\3\2\2\2\u00c2\u04d4\3\2\2\2\u00c4\u04e0\3\2\2\2\u00c6"+ + "\u04ea\3\2\2\2\u00c8\u04f0\3\2\2\2\u00ca\u04fb\3\2\2\2\u00cc\u0507\3\2"+ + "\2\2\u00ce\u0509\3\2\2\2\u00d0\u0514\3\2\2\2\u00d2\u0522\3\2\2\2\u00d4"+ + "\u0528\3\2\2\2\u00d6\u052a\3\2\2\2\u00d8\u0531\3\2\2\2\u00da\u0546\3\2"+ + "\2\2\u00dc\u0548\3\2\2\2\u00de\u0550\3\2\2\2\u00e0\u0559\3\2\2\2\u00e2"+ + "\u0561\3\2\2\2\u00e4\u056f\3\2\2\2\u00e6\u0582\3\2\2\2\u00e8\u0593\3\2"+ + "\2\2\u00ea\u05a6\3\2\2\2\u00ec\u05a9\3\2\2\2\u00ee\u05ad\3\2\2\2\u00f0"+ + "\u05af\3\2\2\2\u00f2\u05b2\3\2\2\2\u00f4\u05b6\3\2\2\2\u00f6\u05c2\3\2"+ + "\2\2\u00f8\u05cd\3\2\2\2\u00fa\u05dd\3\2\2\2\u00fc\u05f4\3\2\2\2\u00fe"+ + "\u05f9\3\2\2\2\u0100\u060d\3\2\2\2\u0102\u0614\3\2\2\2\u0104\u061d\3\2"+ + "\2\2\u0106\u062b\3\2\2\2\u0108\u063e\3\2\2\2\u010a\u0645\3\2\2\2\u010c"+ + "\u064a\3\2\2\2\u010e\u064e\3\2\2\2\u0110\u0650\3\2\2\2\u0112\u065e\3\2"+ + "\2\2\u0114\u0669\3\2\2\2\u0116\u066b\3\2\2\2\u0118\u0689\3\2\2\2\u011a"+ + "\u068c\3\2\2\2\u011c\u0690\3\2\2\2\u011e\u0692\3\2\2\2\u0120\u0698\3\2"+ + "\2\2\u0122\u06ac\3\2\2\2\u0124\u06ae\3\2\2\2\u0126\u06ca\3\2\2\2\u0128"+ + "\u06cd\3\2\2\2\u012a\u06d1\3\2\2\2\u012c\u06d3\3\2\2\2\u012e\u06d7\3\2"+ + "\2\2\u0130\u06da\3\2\2\2\u0132\u06e9\3\2\2\2\u0134\u06fe\3\2\2\2\u0136"+ + "\u0700\3\2\2\2\u0138\u0702\3\2\2\2\u013a\u0704\3\2\2\2\u013c\u0707\3\2"+ + "\2\2\u013e\u070b\3\2\2\2\u0140\u070f\3\2\2\2\u0142\u0712\3\2\2\2\u0144"+ + "\u0720\3\2\2\2\u0146\u072b\3\2\2\2\u0148\u072d\3\2\2\2\u014a\u0730\3\2"+ + "\2\2\u014c\u0736\3\2\2\2\u014e\u073c\3\2\2\2\u0150\u0746\3\2\2\2\u0152"+ + "\u0751\3\2\2\2\u0154\u0760\3\2\2\2\u0156\u0772\3\2\2\2\u0158\u0774\3\2"+ + "\2\2\u015a\u0776\3\2\2\2\u015c\u0787\3\2\2\2\u015e\u0789\3\2\2\2\u0160"+ + "\u0793\3\2\2\2\u0162\u0798\3\2\2\2\u0164\u079d\3\2\2\2\u0166\u07a1\3\2"+ + "\2\2\u0168\u07a9\3\2\2\2\u016a\u07ad\3\2\2\2\u016c\u07bc\3\2\2\2\u016e"+ + "\u07be\3\2\2\2\u0170\u07c4\3\2\2\2\u0172\u07c6\3\2\2\2\u0174\u07cd\3\2"+ + "\2\2\u0176\u07e1\3\2\2\2\u0178\u0818\3\2\2\2\u017a\u081a\3\2\2\2\u017c"+ + "\u017e\5z>\2\u017d\u017c\3\2\2\2\u017d\u017e\3\2\2\2\u017e\u017f\3\2\2"+ + "\2\u017f\u0180\7\2\2\3\u0180\3\3\2\2\2\u0181\u0183\5\u017a\u00be\2\u0182"+ + "\u0181\3\2\2\2\u0183\u0184\3\2\2\2\u0184\u0182\3\2\2\2\u0184\u0185\3\2"+ + "\2\2\u0185\u018e\3\2\2\2\u0186\u018e\7G\2\2\u0187\u0188\7W\2\2\u0188\u0189"+ + "\5\\/\2\u0189\u018a\7X\2\2\u018a\u018e\3\2\2\2\u018b\u018e\5\6\4\2\u018c"+ + "\u018e\5\16\b\2\u018d\u0182\3\2\2\2\u018d\u0186\3\2\2\2\u018d\u0187\3"+ + "\2\2\2\u018d\u018b\3\2\2\2\u018d\u018c\3\2\2\2\u018e\5\3\2\2\2\u018f\u0192"+ + "\5\b\5\2\u0190\u0192\5\n\6\2\u0191\u018f\3\2\2\2\u0191\u0190\3\2\2\2\u0192"+ + "\7\3\2\2\2\u0193\u019e\7\u0086\2\2\u0194\u019e\5\u0148\u00a5\2\u0195\u019e"+ + "\5\u013a\u009e\2\u0196\u019e\5\u014a\u00a6\2\u0197\u019a\7e\2\2\u0198"+ + "\u019b\5\u0114\u008b\2\u0199\u019b\5\u00a0Q\2\u019a\u0198\3\2\2\2\u019a"+ + "\u0199\3\2\2\2\u019b\u019e\3\2\2\2\u019c\u019e\5\u0156\u00ac\2\u019d\u0193"+ + "\3\2\2\2\u019d\u0194\3\2\2\2\u019d\u0195\3\2\2\2\u019d\u0196\3\2\2\2\u019d"+ + "\u0197\3\2\2\2\u019d\u019c\3\2\2\2\u019e\t\3\2\2\2\u019f\u01a1\5\f\7\2"+ + "\u01a0\u01a2\7F\2\2\u01a1\u01a0\3\2\2\2\u01a1\u01a2\3\2\2\2\u01a2\u01a3"+ + "\3\2\2\2\u01a3\u01a4\5\b\5\2\u01a4\13\3\2\2\2\u01a5\u01a9\b\7\1\2\u01a6"+ + "\u01aa\5\u009eP\2\u01a7\u01aa\5\u00b6\\\2\u01a8\u01aa\5\u00a0Q\2\u01a9"+ + "\u01a6\3\2\2\2\u01a9\u01a7\3\2\2\2\u01a9\u01a8\3\2\2\2\u01a9\u01aa\3\2"+ + "\2\2\u01aa\u01ab\3\2\2\2\u01ab\u01ac\7\u0081\2\2\u01ac\u01b8\3\2\2\2\u01ad"+ + "\u01b3\f\3\2\2\u01ae\u01b4\7\u0086\2\2\u01af\u01b1\7F\2\2\u01b0\u01af"+ + "\3\2\2\2\u01b0\u01b1\3\2\2\2\u01b1\u01b2\3\2\2\2\u01b2\u01b4\5\u0154\u00ab"+ + "\2\u01b3\u01ae\3\2\2\2\u01b3\u01b0\3\2\2\2\u01b4\u01b5\3\2\2\2\u01b5\u01b7"+ + "\7\u0081\2\2\u01b6\u01ad\3\2\2\2\u01b7\u01ba\3\2\2\2\u01b8\u01b6\3\2\2"+ + "\2\u01b8\u01b9\3\2\2\2\u01b9\r\3\2\2\2\u01ba\u01b8\3\2\2\2\u01bb\u01bd"+ + "\5\20\t\2\u01bc\u01be\5\36\20\2\u01bd\u01bc\3\2\2\2\u01bd\u01be\3\2\2"+ + "\2\u01be\u01bf\3\2\2\2\u01bf\u01c0\5f\64\2\u01c0\17\3\2\2\2\u01c1\u01c3"+ + "\7Y\2\2\u01c2\u01c4\5\22\n\2\u01c3\u01c2\3\2\2\2\u01c3\u01c4\3\2\2\2\u01c4"+ + "\u01c5\3\2\2\2\u01c5\u01c6\7Z\2\2\u01c6\21\3\2\2\2\u01c7\u01ce\5\26\f"+ + "\2\u01c8\u01cb\5\24\13\2\u01c9\u01ca\7|\2\2\u01ca\u01cc\5\26\f\2\u01cb"+ + "\u01c9\3\2\2\2\u01cb\u01cc\3\2\2\2\u01cc\u01ce\3\2\2\2\u01cd\u01c7\3\2"+ + "\2\2\u01cd\u01c8\3\2\2\2\u01ce\23\3\2\2\2\u01cf\u01d0\t\2\2\2\u01d0\25"+ + "\3\2\2\2\u01d1\u01d6\5\30\r\2\u01d2\u01d3\7|\2\2\u01d3\u01d5\5\30\r\2"+ + "\u01d4\u01d2\3\2\2\2\u01d5\u01d8\3\2\2\2\u01d6\u01d4\3\2\2\2\u01d6\u01d7"+ + "\3\2\2\2\u01d7\u01da\3\2\2\2\u01d8\u01d6\3\2\2\2\u01d9\u01db\7\u0085\2"+ + "\2\u01da\u01d9\3\2\2\2\u01da\u01db\3\2\2\2\u01db\27\3\2\2\2\u01dc\u01df"+ + "\5\32\16\2\u01dd\u01df\5\34\17\2\u01de\u01dc\3\2\2\2\u01de\u01dd\3\2\2"+ + "\2\u01df\31\3\2\2\2\u01e0\u01e2\7c\2\2\u01e1\u01e0\3\2\2\2\u01e1\u01e2"+ + "\3\2\2\2\u01e2\u01e3\3\2\2\2\u01e3\u01e6\7\u0086\2\2\u01e4\u01e6\7G\2"+ + "\2\u01e5\u01e1\3\2\2\2\u01e5\u01e4\3\2\2\2\u01e6\33\3\2\2\2\u01e7\u01e9"+ + "\7c\2\2\u01e8\u01e7\3\2\2\2\u01e8\u01e9\3\2\2\2\u01e9\u01ea\3\2\2\2\u01ea"+ + "\u01eb\7\u0086\2\2\u01eb\u01ec\5\u010a\u0086\2\u01ec\35\3\2\2\2\u01ed"+ + "\u01ef\7W\2\2\u01ee\u01f0\5\u0100\u0081\2\u01ef\u01ee\3\2\2\2\u01ef\u01f0"+ + "\3\2\2\2\u01f0\u01f1\3\2\2\2\u01f1\u01f3\7X\2\2\u01f2\u01f4\7\61\2\2\u01f3"+ + "\u01f2\3\2\2\2\u01f3\u01f4\3\2\2\2\u01f4\u01f6\3\2\2\2\u01f5\u01f7\5\u0170"+ + "\u00b9\2\u01f6\u01f5\3\2\2\2\u01f6\u01f7\3\2\2\2\u01f7\u01f9\3\2\2\2\u01f8"+ + "\u01fa\5\u00caf\2\u01f9\u01f8\3\2\2\2\u01f9\u01fa\3\2\2\2\u01fa\u01fc"+ + "\3\2\2\2\u01fb\u01fd\5\u00e8u\2\u01fc\u01fb\3\2\2\2\u01fc\u01fd\3\2\2"+ + "\2\u01fd\37\3\2\2\2\u01fe\u01ff\b\21\1\2\u01ff\u021d\5\4\3\2\u0200\u0203"+ + "\5\u009cO\2\u0201\u0203\5\u015e\u00b0\2\u0202\u0200\3\2\2\2\u0202\u0201"+ + "\3\2\2\2\u0203\u020a\3\2\2\2\u0204\u0206\7W\2\2\u0205\u0207\5$\23\2\u0206"+ + "\u0205\3\2\2\2\u0206\u0207\3\2\2\2\u0207\u0208\3\2\2\2\u0208\u020b\7X"+ + "\2\2\u0209\u020b\5\u0112\u008a\2\u020a\u0204\3\2\2\2\u020a\u0209\3\2\2"+ + "\2\u020b\u021d\3\2\2\2\u020c\u020d\t\3\2\2\u020d\u020e\7h\2\2\u020e\u020f"+ + "\5\u00f4{\2\u020f\u0210\7i\2\2\u0210\u0211\7W\2\2\u0211\u0212\5\\/\2\u0212"+ + "\u0213\7X\2\2\u0213\u021d\3\2\2\2\u0214\u0215\5\"\22\2\u0215\u0218\7W"+ + "\2\2\u0216\u0219\5\\/\2\u0217\u0219\5\u00f4{\2\u0218\u0216\3\2\2\2\u0218"+ + "\u0217\3\2\2\2\u0219\u021a\3\2\2\2\u021a\u021b\7X\2\2\u021b\u021d\3\2"+ + "\2\2\u021c\u01fe\3\2\2\2\u021c\u0202\3\2\2\2\u021c\u020c\3\2\2\2\u021c"+ + "\u0214\3\2\2\2\u021d\u0239\3\2\2\2\u021e\u021f\f\t\2\2\u021f\u0222\7Y"+ + "\2\2\u0220\u0223\5\\/\2\u0221\u0223\5\u0112\u008a\2\u0222\u0220\3\2\2"+ + "\2\u0222\u0221\3\2\2\2\u0223\u0224\3\2\2\2\u0224\u0225\7Z\2\2\u0225\u0238"+ + "\3\2\2\2\u0226\u0227\f\b\2\2\u0227\u0229\7W\2\2\u0228\u022a\5$\23\2\u0229"+ + "\u0228\3\2\2\2\u0229\u022a\3\2\2\2\u022a\u022b\3\2\2\2\u022b\u0238\7X"+ + "\2\2\u022c\u022d\f\6\2\2\u022d\u0233\t\4\2\2\u022e\u0230\7F\2\2\u022f"+ + "\u022e\3\2\2\2\u022f\u0230\3\2\2\2\u0230\u0231\3\2\2\2\u0231\u0234\5\6"+ + "\4\2\u0232\u0234\5&\24\2\u0233\u022f\3\2\2\2\u0233\u0232\3\2\2\2\u0234"+ + "\u0238\3\2\2\2\u0235\u0236\f\5\2\2\u0236\u0238\t\5\2\2\u0237\u021e\3\2"+ + "\2\2\u0237\u0226\3\2\2\2\u0237\u022c\3\2\2\2\u0237\u0235\3\2\2\2\u0238"+ + "\u023b\3\2\2\2\u0239\u0237\3\2\2\2\u0239\u023a\3\2\2\2\u023a!\3\2\2\2"+ + "\u023b\u0239\3\2\2\2\u023c\u023d\7M\2\2\u023d#\3\2\2\2\u023e\u023f\5\u0110"+ + "\u0089\2\u023f%\3\2\2\2\u0240\u0242\5\f\7\2\u0241\u0240\3\2\2\2\u0241"+ + "\u0242\3\2\2\2\u0242\u0246\3\2\2\2\u0243\u0244\5\u009eP\2\u0244\u0245"+ + "\7\u0081\2\2\u0245\u0247\3\2\2\2\u0246\u0243\3\2\2\2\u0246\u0247\3\2\2"+ + "\2\u0247\u0248\3\2\2\2\u0248\u0249\7e\2\2\u0249\u0254\5\u009eP\2\u024a"+ + "\u024b\5\f\7\2\u024b\u024c\7F\2\2\u024c\u024d\5\u0154\u00ab\2\u024d\u024e"+ + "\7\u0081\2\2\u024e\u024f\7e\2\2\u024f\u0250\5\u009eP\2\u0250\u0254\3\2"+ + "\2\2\u0251\u0252\7e\2\2\u0252\u0254\5\u00a0Q\2\u0253\u0241\3\2\2\2\u0253"+ + "\u024a\3\2\2\2\u0253\u0251\3\2\2\2\u0254\'\3\2\2\2\u0255\u0271\5 \21\2"+ + "\u0256\u025b\7z\2\2\u0257\u025b\7{\2\2\u0258\u025b\5*\26\2\u0259\u025b"+ + "\7@\2\2\u025a\u0256\3\2\2\2\u025a\u0257\3\2\2\2\u025a\u0258\3\2\2\2\u025a"+ + "\u0259\3\2\2\2\u025b\u025c\3\2\2\2\u025c\u0271\5(\25\2\u025d\u0266\7@"+ + "\2\2\u025e\u025f\7W\2\2\u025f\u0260\5\u00f4{\2\u0260\u0261\7X\2\2\u0261"+ + "\u0267\3\2\2\2\u0262\u0263\7\u0085\2\2\u0263\u0264\7W\2\2\u0264\u0265"+ + "\7\u0086\2\2\u0265\u0267\7X\2\2\u0266\u025e\3\2\2\2\u0266\u0262\3\2\2"+ + "\2\u0267\u0271\3\2\2\2\u0268\u0269\7\r\2\2\u0269\u026a\7W\2\2\u026a\u026b"+ + "\5\u00f4{\2\u026b\u026c\7X\2\2\u026c\u0271\3\2\2\2\u026d\u0271\5:\36\2"+ + "\u026e\u0271\5,\27\2\u026f\u0271\58\35\2\u0270\u0255\3\2\2\2\u0270\u025a"+ + "\3\2\2\2\u0270\u025d\3\2\2\2\u0270\u0268\3\2\2\2\u0270\u026d\3\2\2\2\u0270"+ + "\u026e\3\2\2\2\u0270\u026f\3\2\2\2\u0271)\3\2\2\2\u0272\u0273\t\6\2\2"+ + "\u0273+\3\2\2\2\u0274\u0276\7\u0081\2\2\u0275\u0274\3\2\2\2\u0275\u0276"+ + "\3\2\2\2\u0276\u0277\3\2\2\2\u0277\u0279\7\63\2\2\u0278\u027a\5.\30\2"+ + "\u0279\u0278\3\2\2\2\u0279\u027a\3\2\2\2\u027a\u0280\3\2\2\2\u027b\u0281"+ + "\5\60\31\2\u027c\u027d\7W\2\2\u027d\u027e\5\u00f4{\2\u027e\u027f\7X\2"+ + "\2\u027f\u0281\3\2\2\2\u0280\u027b\3\2\2\2\u0280\u027c\3\2\2\2\u0281\u0283"+ + "\3\2\2\2\u0282\u0284\5\66\34\2\u0283\u0282\3\2\2\2\u0283\u0284\3\2\2\2"+ + "\u0284-\3\2\2\2\u0285\u0286\7W\2\2\u0286\u0287\5$\23\2\u0287\u0288\7X"+ + "\2\2\u0288/\3\2\2\2\u0289\u028b\5\u0098M\2\u028a\u028c\5\62\32\2\u028b"+ + "\u028a\3\2\2\2\u028b\u028c\3\2\2\2\u028c\61\3\2\2\2\u028d\u028f\5\u00ea"+ + "v\2\u028e\u0290\5\62\32\2\u028f\u028e\3\2\2\2\u028f\u0290\3\2\2\2\u0290"+ + "\u0293\3\2\2\2\u0291\u0293\5\64\33\2\u0292\u028d\3\2\2\2\u0292\u0291\3"+ + "\2\2\2\u0293\63\3\2\2\2\u0294\u0295\b\33\1\2\u0295\u0296\7Y\2\2\u0296"+ + "\u0297\5\\/\2\u0297\u0299\7Z\2\2\u0298\u029a\5\u00caf\2\u0299\u0298\3"+ + "\2\2\2\u0299\u029a\3\2\2\2\u029a\u02a4\3\2\2\2\u029b\u029c\f\3\2\2\u029c"+ + "\u029d\7Y\2\2\u029d\u029e\5^\60\2\u029e\u02a0\7Z\2\2\u029f\u02a1\5\u00ca"+ + "f\2\u02a0\u029f\3\2\2\2\u02a0\u02a1\3\2\2\2\u02a1\u02a3\3\2\2\2\u02a2"+ + "\u029b\3\2\2\2\u02a3\u02a6\3\2\2\2\u02a4\u02a2\3\2\2\2\u02a4\u02a5\3\2"+ + "\2\2\u02a5\65\3\2\2\2\u02a6\u02a4\3\2\2\2\u02a7\u02a9\7W\2\2\u02a8\u02aa"+ + "\5$\23\2\u02a9\u02a8\3\2\2\2\u02a9\u02aa\3\2\2\2\u02aa\u02ab\3\2\2\2\u02ab"+ + "\u02ae\7X\2\2\u02ac\u02ae\5\u0112\u008a\2\u02ad\u02a7\3\2\2\2\u02ad\u02ac"+ + "\3\2\2\2\u02ae\67\3\2\2\2\u02af\u02b1\7\u0081\2\2\u02b0\u02af\3\2\2\2"+ + "\u02b0\u02b1\3\2\2\2\u02b1\u02b2\3\2\2\2\u02b2\u02b5\7\36\2\2\u02b3\u02b4"+ + "\7Y\2\2\u02b4\u02b6\7Z\2\2\u02b5\u02b3\3\2\2\2\u02b5\u02b6\3\2\2\2\u02b6"+ + "\u02b7\3\2\2\2\u02b7\u02b8\5<\37\2\u02b89\3\2\2\2\u02b9\u02ba\7\64\2\2"+ + "\u02ba\u02bb\7W\2\2\u02bb\u02bc\5\\/\2\u02bc\u02bd\7X\2\2\u02bd;\3\2\2"+ + "\2\u02be\u02c5\5(\25\2\u02bf\u02c0\7W\2\2\u02c0\u02c1\5\u00f4{\2\u02c1"+ + "\u02c2\7X\2\2\u02c2\u02c3\5<\37\2\u02c3\u02c5\3\2\2\2\u02c4\u02be\3\2"+ + "\2\2\u02c4\u02bf\3\2\2\2\u02c5=\3\2\2\2\u02c6\u02cb\5<\37\2\u02c7\u02c8"+ + "\t\7\2\2\u02c8\u02ca\5<\37\2\u02c9\u02c7\3\2\2\2\u02ca\u02cd\3\2\2\2\u02cb"+ + "\u02c9\3\2\2\2\u02cb\u02cc\3\2\2\2\u02cc?\3\2\2\2\u02cd\u02cb\3\2\2\2"+ + "\u02ce\u02d3\5> \2\u02cf\u02d0\t\b\2\2\u02d0\u02d2\5> \2\u02d1\u02cf\3"+ + "\2\2\2\u02d2\u02d5\3\2\2\2\u02d3\u02d1\3\2\2\2\u02d3\u02d4\3\2\2\2\u02d4"+ + "A\3\2\2\2\u02d5\u02d3\3\2\2\2\u02d6\u02db\5@!\2\u02d7\u02d8\t\t\2\2\u02d8"+ + "\u02da\5@!\2\u02d9\u02d7\3\2\2\2\u02da\u02dd\3\2\2\2\u02db\u02d9\3\2\2"+ + "\2\u02db\u02dc\3\2\2\2\u02dcC\3\2\2\2\u02dd\u02db\3\2\2\2\u02de\u02e4"+ + "\5B\"\2\u02df\u02e0\5F$\2\u02e0\u02e1\5B\"\2\u02e1\u02e3\3\2\2\2\u02e2"+ + "\u02df\3\2\2\2\u02e3\u02e6\3\2\2\2\u02e4\u02e2\3\2\2\2\u02e4\u02e5\3\2"+ + "\2\2\u02e5E\3\2\2\2\u02e6\u02e4\3\2\2\2\u02e7\u02e8\7i\2\2\u02e8\u02ec"+ + "\7i\2\2\u02e9\u02ea\7h\2\2\u02ea\u02ec\7h\2\2\u02eb\u02e7\3\2\2\2\u02eb"+ + "\u02e9\3\2\2\2\u02ecG\3\2\2\2\u02ed\u02f2\5D#\2\u02ee\u02ef\t\n\2\2\u02ef"+ + "\u02f1\5D#\2\u02f0\u02ee\3\2\2\2\u02f1\u02f4\3\2\2\2\u02f2\u02f0\3\2\2"+ + "\2\u02f2\u02f3\3\2\2\2\u02f3I\3\2\2\2\u02f4\u02f2\3\2\2\2\u02f5\u02fa"+ + "\5H%\2\u02f6\u02f7\t\13\2\2\u02f7\u02f9\5H%\2\u02f8\u02f6\3\2\2\2\u02f9"+ + "\u02fc\3\2\2\2\u02fa\u02f8\3\2\2\2\u02fa\u02fb\3\2\2\2\u02fbK\3\2\2\2"+ + "\u02fc\u02fa\3\2\2\2\u02fd\u0302\5J&\2\u02fe\u02ff\7c\2\2\u02ff\u0301"+ + "\5J&\2\u0300\u02fe\3\2\2\2\u0301\u0304\3\2\2\2\u0302\u0300\3\2\2\2\u0302"+ + "\u0303\3\2\2\2\u0303M\3\2\2\2\u0304\u0302\3\2\2\2\u0305\u030a\5L\'\2\u0306"+ + "\u0307\7b\2\2\u0307\u0309\5L\'\2\u0308\u0306\3\2\2\2\u0309\u030c\3\2\2"+ + "\2\u030a\u0308\3\2\2\2\u030a\u030b\3\2\2\2\u030bO\3\2\2\2\u030c\u030a"+ + "\3\2\2\2\u030d\u0312\5N(\2\u030e\u030f\7d\2\2\u030f\u0311\5N(\2\u0310"+ + "\u030e\3\2\2\2\u0311\u0314\3\2\2\2\u0312\u0310\3\2\2\2\u0312\u0313\3\2"+ + "\2\2\u0313Q\3\2\2\2\u0314\u0312\3\2\2\2\u0315\u031a\5P)\2\u0316\u0317"+ + "\7x\2\2\u0317\u0319\5P)\2\u0318\u0316\3\2\2\2\u0319\u031c\3\2\2\2\u031a"+ + "\u0318\3\2\2\2\u031a\u031b\3\2\2\2\u031bS\3\2\2\2\u031c\u031a\3\2\2\2"+ + "\u031d\u0322\5R*\2\u031e\u031f\7y\2\2\u031f\u0321\5R*\2\u0320\u031e\3"+ + "\2\2\2\u0321\u0324\3\2\2\2\u0322\u0320\3\2\2\2\u0322\u0323\3\2\2\2\u0323"+ + "U\3\2\2\2\u0324\u0322\3\2\2\2\u0325\u032b\5T+\2\u0326\u0327\7\177\2\2"+ + "\u0327\u0328\5\\/\2\u0328\u0329\7\u0080\2\2\u0329\u032a\5X-\2\u032a\u032c"+ + "\3\2\2\2\u032b\u0326\3\2\2\2\u032b\u032c\3\2\2\2\u032cW\3\2\2\2\u032d"+ + "\u0334\5V,\2\u032e\u032f\5T+\2\u032f\u0330\5Z.\2\u0330\u0331\5\u010e\u0088"+ + "\2\u0331\u0334\3\2\2\2\u0332\u0334\5\u016e\u00b8\2\u0333\u032d\3\2\2\2"+ + "\u0333\u032e\3\2\2\2\u0333\u0332\3\2\2\2\u0334Y\3\2\2\2\u0335\u0336\t"+ + "\f\2\2\u0336[\3\2\2\2\u0337\u033c\5X-\2\u0338\u0339\7|\2\2\u0339\u033b"+ + "\5X-\2\u033a\u0338\3\2\2\2\u033b\u033e\3\2\2\2\u033c\u033a\3\2\2\2\u033c"+ + "\u033d\3\2\2\2\u033d]\3\2\2\2\u033e\u033c\3\2\2\2\u033f\u0340\5V,\2\u0340"+ + "_\3\2\2\2\u0341\u034f\5b\62\2\u0342\u0344\5\u00caf\2\u0343\u0342\3\2\2"+ + "\2\u0343\u0344\3\2\2\2\u0344\u034b\3\2\2\2\u0345\u034c\5d\63\2\u0346\u034c"+ + "\5f\64\2\u0347\u034c\5j\66\2\u0348\u034c\5n8\2\u0349\u034c\5v<\2\u034a"+ + "\u034c\5\u0164\u00b3\2\u034b\u0345\3\2\2\2\u034b\u0346\3\2\2\2\u034b\u0347"+ + "\3\2\2\2\u034b\u0348\3\2\2\2\u034b\u0349\3\2\2\2\u034b\u034a\3\2\2\2\u034c"+ + "\u034f\3\2\2\2\u034d\u034f\5x=\2\u034e\u0341\3\2\2\2\u034e\u0343\3\2\2"+ + "\2\u034e\u034d\3\2\2\2\u034fa\3\2\2\2\u0350\u0352\5\u00caf\2\u0351\u0350"+ + "\3\2\2\2\u0351\u0352\3\2\2\2\u0352\u0357\3\2\2\2\u0353\u0358\7\u0086\2"+ + "\2\u0354\u0355\7\22\2\2\u0355\u0358\5^\60\2\u0356\u0358\7\35\2\2\u0357"+ + "\u0353\3\2\2\2\u0357\u0354\3\2\2\2\u0357\u0356\3\2\2\2\u0358\u0359\3\2"+ + "\2\2\u0359\u035a\7\u0080\2\2\u035a\u035b\5`\61\2\u035bc\3\2\2\2\u035c"+ + "\u035e\5\\/\2\u035d\u035c\3\2\2\2\u035d\u035e\3\2\2\2\u035e\u035f\3\2"+ + "\2\2\u035f\u0360\7\u0082\2\2\u0360e\3\2\2\2\u0361\u0363\7[\2\2\u0362\u0364"+ + "\5h\65\2\u0363\u0362\3\2\2\2\u0363\u0364\3\2\2\2\u0364\u0365\3\2\2\2\u0365"+ + "\u0366\7\\\2\2\u0366g\3\2\2\2\u0367\u0369\5`\61\2\u0368\u0367\3\2\2\2"+ + "\u0369\u036a\3\2\2\2\u036a\u0368\3\2\2\2\u036a\u036b\3\2\2\2\u036bi\3"+ + "\2\2\2\u036c\u036d\7-\2\2\u036d\u036e\7W\2\2\u036e\u036f\5l\67\2\u036f"+ + "\u0370\7X\2\2\u0370\u0373\5`\61\2\u0371\u0372\7\"\2\2\u0372\u0374\5`\61"+ + "\2\u0373\u0371\3\2\2\2\u0373\u0374\3\2\2\2\u0374\u037c\3\2\2\2\u0375\u0376"+ + "\7E\2\2\u0376\u0377\7W\2\2\u0377\u0378\5l\67\2\u0378\u0379\7X\2\2\u0379"+ + "\u037a\5`\61\2\u037a\u037c\3\2\2\2\u037b\u036c\3\2\2\2\u037b\u0375\3\2"+ + "\2\2\u037ck\3\2\2\2\u037d\u0389\5\\/\2\u037e\u0380\5\u00caf\2\u037f\u037e"+ + "\3\2\2\2\u037f\u0380\3\2\2\2\u0380\u0381\3\2\2\2\u0381\u0382\5\u008cG"+ + "\2\u0382\u0386\5\u00e0q\2\u0383\u0384\7g\2\2\u0384\u0387\5\u010e\u0088"+ + "\2\u0385\u0387\5\u0112\u008a\2\u0386\u0383\3\2\2\2\u0386\u0385\3\2\2\2"+ + "\u0387\u0389\3\2\2\2\u0388\u037d\3\2\2\2\u0388\u037f\3\2\2\2\u0389m\3"+ + "\2\2\2\u038a\u038b\7V\2\2\u038b\u038c\7W\2\2\u038c\u038d\5l\67\2\u038d"+ + "\u038e\7X\2\2\u038e\u038f\5`\61\2\u038f\u03ac\3\2\2\2\u0390\u0391\7\37"+ + "\2\2\u0391\u0392\5`\61\2\u0392\u0393\7V\2\2\u0393\u0394\7W\2\2\u0394\u0395"+ + "\5\\/\2\u0395\u0396\7X\2\2\u0396\u0397\7\u0082\2\2\u0397\u03ac\3\2\2\2"+ + "\u0398\u0399\7*\2\2\u0399\u03a6\7W\2\2\u039a\u039c\5p9\2\u039b\u039d\5"+ + "l\67\2\u039c\u039b\3\2\2\2\u039c\u039d\3\2\2\2\u039d\u039e\3\2\2\2\u039e"+ + "\u03a0\7\u0082\2\2\u039f\u03a1\5\\/\2\u03a0\u039f\3\2\2\2\u03a0\u03a1"+ + "\3\2\2\2\u03a1\u03a7\3\2\2\2\u03a2\u03a3\5r:\2\u03a3\u03a4\7\u0080\2\2"+ + "\u03a4\u03a5\5t;\2\u03a5\u03a7\3\2\2\2\u03a6\u039a\3\2\2\2\u03a6\u03a2"+ + "\3\2\2\2\u03a7\u03a8\3\2\2\2\u03a8\u03a9\7X\2\2\u03a9\u03aa\5`\61\2\u03aa"+ + "\u03ac\3\2\2\2\u03ab\u038a\3\2\2\2\u03ab\u0390\3\2\2\2\u03ab\u0398\3\2"+ + "\2\2\u03aco\3\2\2\2\u03ad\u03b0\5d\63\2\u03ae\u03b0\5\u0082B\2\u03af\u03ad"+ + "\3\2\2\2\u03af\u03ae\3\2\2\2\u03b0q\3\2\2\2\u03b1\u03b3\5\u00caf\2\u03b2"+ + "\u03b1\3\2\2\2\u03b2\u03b3\3\2\2\2\u03b3\u03b4\3\2\2\2\u03b4\u03b5\5\u008c"+ + "G\2\u03b5\u03b6\5\u00e0q\2\u03b6s\3\2\2\2\u03b7\u03ba\5\\/\2\u03b8\u03ba"+ + "\5\u0112\u008a\2\u03b9\u03b7\3\2\2\2\u03b9\u03b8\3\2\2\2\u03bau\3\2\2"+ + "\2\u03bb\u03c5\7\21\2\2\u03bc\u03c5\7\33\2\2\u03bd\u03c0\7=\2\2\u03be"+ + "\u03c1\5\\/\2\u03bf\u03c1\5\u0112\u008a\2\u03c0\u03be\3\2\2\2\u03c0\u03bf"+ + "\3\2\2\2\u03c0\u03c1\3\2\2\2\u03c1\u03c5\3\2\2\2\u03c2\u03c3\7,\2\2\u03c3"+ + "\u03c5\7\u0086\2\2\u03c4\u03bb\3\2\2\2\u03c4\u03bc\3\2\2\2\u03c4\u03bd"+ + "\3\2\2\2\u03c4\u03c2\3\2\2\2\u03c5\u03c6\3\2\2\2\u03c6\u03c7\7\u0082\2"+ + "\2\u03c7w\3\2\2\2\u03c8\u03c9\5~@\2\u03c9y\3\2\2\2\u03ca\u03cc\5|?\2\u03cb"+ + "\u03ca\3\2\2\2\u03cc\u03cd\3\2\2\2\u03cd\u03cb\3\2\2\2\u03cd\u03ce\3\2"+ + "\2\2\u03ce{\3\2\2\2\u03cf\u03d9\5~@\2\u03d0\u03d9\5\u0106\u0084\2\u03d1"+ + "\u03d9\5\u014c\u00a7\2\u03d2\u03d9\5\u0160\u00b1\2\u03d3\u03d9\5\u0162"+ + "\u00b2\2\u03d4\u03d9\5\u00c8e\2\u03d5\u03d9\5\u00ba^\2\u03d6\u03d9\5\u0086"+ + "D\2\u03d7\u03d9\5\u0088E\2\u03d8\u03cf\3\2\2\2\u03d8\u03d0\3\2\2\2\u03d8"+ + "\u03d1\3\2\2\2\u03d8\u03d2\3\2\2\2\u03d8\u03d3\3\2\2\2\u03d8\u03d4\3\2"+ + "\2\2\u03d8\u03d5\3\2\2\2\u03d8\u03d6\3\2\2\2\u03d8\u03d7\3\2\2\2\u03d9"+ + "}\3\2\2\2\u03da\u03e3\5\u0082B\2\u03db\u03e3\5\u00c6d\2\u03dc\u03e3\5"+ + "\u00be`\2\u03dd\u03e3\5\u00c2b\2\u03de\u03e3\5\u00c4c\2\u03df\u03e3\5"+ + "\u0084C\2\u03e0\u03e3\5\u0080A\2\u03e1\u03e3\5\u00aaV\2\u03e2\u03da\3"+ + "\2\2\2\u03e2\u03db\3\2\2\2\u03e2\u03dc\3\2\2\2\u03e2\u03dd\3\2\2\2\u03e2"+ + "\u03de\3\2\2\2\u03e2\u03df\3\2\2\2\u03e2\u03e0\3\2\2\2\u03e2\u03e1\3\2"+ + "\2\2\u03e3\177\3\2\2\2\u03e4\u03e5\7Q\2\2\u03e5\u03e7\7\u0086\2\2\u03e6"+ + "\u03e8\5\u00caf\2\u03e7\u03e6\3\2\2\2\u03e7\u03e8\3\2\2\2\u03e8\u03e9"+ + "\3\2\2\2\u03e9\u03ea\7g\2\2\u03ea\u03eb\5\u00f4{\2\u03eb\u03ec\7\u0082"+ + "\2\2\u03ec\u0081\3\2\2\2\u03ed\u03ef\5\u008cG\2\u03ee\u03ed\3\2\2\2\u03ee"+ + "\u03ef\3\2\2\2\u03ef\u03f1\3\2\2\2\u03f0\u03f2\5\u00dco\2\u03f1\u03f0"+ + "\3\2\2\2\u03f1\u03f2\3\2\2\2\u03f2\u03f3\3\2\2\2\u03f3\u03fc\7\u0082\2"+ + "\2\u03f4\u03f6\5\u00caf\2\u03f5\u03f7\5\u008cG\2\u03f6\u03f5\3\2\2\2\u03f6"+ + "\u03f7\3\2\2\2\u03f7\u03f8\3\2\2\2\u03f8\u03f9\5\u00dco\2\u03f9\u03fa"+ + "\7\u0082\2\2\u03fa\u03fc\3\2\2\2\u03fb\u03ee\3\2\2\2\u03fb\u03f4\3\2\2"+ + "\2\u03fc\u0083\3\2\2\2\u03fd\u03fe\7B\2\2\u03fe\u03ff\7W\2\2\u03ff\u0400"+ + "\5^\60\2\u0400\u0401\7|\2\2\u0401\u0402\7\6\2\2\u0402\u0403\7X\2\2\u0403"+ + "\u0404\7\u0082\2\2\u0404\u0085\3\2\2\2\u0405\u0406\7\u0082\2\2\u0406\u0087"+ + "\3\2\2\2\u0407\u0408\5\u00caf\2\u0408\u0409\7\u0082\2\2\u0409\u0089\3"+ + "\2\2\2\u040a\u0411\5\u008eH\2\u040b\u0411\5\u0094K\2\u040c\u0411\5\u0090"+ + "I\2\u040d\u0411\7+\2\2\u040e\u0411\7L\2\2\u040f\u0411\7\31\2\2\u0410\u040a"+ + "\3\2\2\2\u0410\u040b\3\2\2\2\u0410\u040c\3\2\2\2\u0410\u040d\3\2\2\2\u0410"+ + "\u040e\3\2\2\2\u0410\u040f\3\2\2\2\u0411\u008b\3\2\2\2\u0412\u0414\5\u008a"+ + "F\2\u0413\u0412\3\2\2\2\u0414\u0415\3\2\2\2\u0415\u0413\3\2\2\2\u0415"+ + "\u0416\3\2\2\2\u0416\u0418\3\2\2\2\u0417\u0419\5\u00caf\2\u0418\u0417"+ + "\3\2\2\2\u0418\u0419\3\2\2\2\u0419\u008d\3\2\2\2\u041a\u041b\t\r\2\2\u041b"+ + "\u008f\3\2\2\2\u041c\u041d\t\16\2\2\u041d\u0091\3\2\2\2\u041e\u041f\7"+ + "\u0086\2\2\u041f\u0093\3\2\2\2\u0420\u0424\5\u0096L\2\u0421\u0424\5\u0116"+ + "\u008c\2\u0422\u0424\5\u00a6T\2\u0423\u0420\3\2\2\2\u0423\u0421\3\2\2"+ + "\2\u0423\u0422\3\2\2\2\u0424\u0095\3\2\2\2\u0425\u042a\5\u009cO\2\u0426"+ + "\u042a\5\u00a2R\2\u0427\u042a\5\u015e\u00b0\2\u0428\u042a\5\u00eex\2\u0429"+ + "\u0425\3\2\2\2\u0429\u0426\3\2\2\2\u0429\u0427\3\2\2\2\u0429\u0428\3\2"+ + "\2\2\u042a\u0097\3\2\2\2\u042b\u042d\5\u0094K\2\u042c\u042b\3\2\2\2\u042d"+ + "\u042e\3\2\2\2\u042e\u042c\3\2\2\2\u042e\u042f\3\2\2\2\u042f\u0431\3\2"+ + "\2\2\u0430\u0432\5\u00caf\2\u0431\u0430\3\2\2\2\u0431\u0432\3\2\2\2\u0432"+ + "\u0099\3\2\2\2\u0433\u0435\5\u0096L\2\u0434\u0433\3\2\2\2\u0435\u0436"+ + "\3\2\2\2\u0436\u0434\3\2\2\2\u0436\u0437\3\2\2\2\u0437\u0439\3\2\2\2\u0438"+ + "\u043a\5\u00caf\2\u0439\u0438\3\2\2\2\u0439\u043a\3\2\2\2\u043a\u009b"+ + "\3\2\2\2\u043b\u043d\5\f\7\2\u043c\u043b\3\2\2\2\u043c\u043d\3\2\2\2\u043d"+ + "\u043e\3\2\2\2\u043e\u0453\5\u009eP\2\u043f\u0440\5\f\7\2\u0440\u0441"+ + "\7F\2\2\u0441\u0442\5\u0154\u00ab\2\u0442\u0453\3\2\2\2\u0443\u0453\7"+ + "\24\2\2\u0444\u0453\7\25\2\2\u0445\u0453\7\26\2\2\u0446\u0453\7U\2\2\u0447"+ + "\u0453\7\20\2\2\u0448\u0453\7>\2\2\u0449\u0453\7/\2\2\u044a\u0453\7\60"+ + "\2\2\u044b\u0453\7?\2\2\u044c\u0453\7P\2\2\u044d\u0453\7)\2\2\u044e\u0453"+ + "\7 \2\2\u044f\u0453\7S\2\2\u0450\u0453\7\17\2\2\u0451\u0453\5\u00a0Q\2"+ + "\u0452\u043c\3\2\2\2\u0452\u043f\3\2\2\2\u0452\u0443\3\2\2\2\u0452\u0444"+ + "\3\2\2\2\u0452\u0445\3\2\2\2\u0452\u0446\3\2\2\2\u0452\u0447\3\2\2\2\u0452"+ + "\u0448\3\2\2\2\u0452\u0449\3\2\2\2\u0452\u044a\3\2\2\2\u0452\u044b\3\2"+ + "\2\2\u0452\u044c\3\2\2\2\u0452\u044d\3\2\2\2\u0452\u044e\3\2\2\2\u0452"+ + "\u044f\3\2\2\2\u0452\u0450\3\2\2\2\u0452\u0451\3\2\2\2\u0453\u009d\3\2"+ + "\2\2\u0454\u0459\5\u0114\u008b\2\u0455\u0459\5\u00a4S\2\u0456\u0459\5"+ + "\u0092J\2\u0457\u0459\5\u0154\u00ab\2\u0458\u0454\3\2\2\2\u0458\u0455"+ + "\3\2\2\2\u0458\u0456\3\2\2\2\u0458\u0457\3\2\2\2\u0459\u009f\3\2\2\2\u045a"+ + "\u045b\7\34\2\2\u045b\u045e\7W\2\2\u045c\u045f\5\\/\2\u045d\u045f\7\17"+ + "\2\2\u045e\u045c\3\2\2\2\u045e\u045d\3\2\2\2\u045f\u0460\3\2\2\2\u0460"+ + "\u0461\7X\2\2\u0461\u00a1\3\2\2\2\u0462\u0471\5\u011e\u0090\2\u0463\u0465"+ + "\5\u00caf\2\u0464\u0463\3\2\2\2\u0464\u0465\3\2\2\2\u0465\u0467\3\2\2"+ + "\2\u0466\u0468\5\f\7\2\u0467\u0466\3\2\2\2\u0467\u0468\3\2\2\2\u0468\u0469"+ + "\3\2\2\2\u0469\u0472\7\u0086\2\2\u046a\u0472\5\u0154\u00ab\2\u046b\u046d"+ + "\5\f\7\2\u046c\u046e\7F\2\2\u046d\u046c\3\2\2\2\u046d\u046e\3\2\2\2\u046e"+ + "\u046f\3\2\2\2\u046f\u0470\5\u0154\u00ab\2\u0470\u0472\3\2\2\2\u0471\u0464"+ + "\3\2\2\2\u0471\u046a\3\2\2\2\u0471\u046b\3\2\2\2\u0472\u0479\3\2\2\2\u0473"+ + "\u0475\7#\2\2\u0474\u0476\5\f\7\2\u0475\u0474\3\2\2\2\u0475\u0476\3\2"+ + "\2\2\u0476\u0477\3\2\2\2\u0477\u0479\7\u0086\2\2\u0478\u0462\3\2\2\2\u0478"+ + "\u0473\3\2\2\2\u0479\u00a3\3\2\2\2\u047a\u047b\7\u0086\2\2\u047b\u00a5"+ + "\3\2\2\2\u047c\u047d\5\u00a8U\2\u047d\u0482\7[\2\2\u047e\u0480\5\u00b0"+ + "Y\2\u047f\u0481\7|\2\2\u0480\u047f\3\2\2\2\u0480\u0481\3\2\2\2\u0481\u0483"+ + "\3\2\2\2\u0482\u047e\3\2\2\2\u0482\u0483\3\2\2\2\u0483\u0484\3\2\2\2\u0484"+ + "\u0485\7\\\2\2\u0485\u00a7\3\2\2\2\u0486\u0488\5\u00acW\2\u0487\u0489"+ + "\5\u00caf\2\u0488\u0487\3\2\2\2\u0488\u0489\3\2\2\2\u0489\u048e\3\2\2"+ + "\2\u048a\u048c\5\f\7\2\u048b\u048a\3\2\2\2\u048b\u048c\3\2\2\2\u048c\u048d"+ + "\3\2\2\2\u048d\u048f\7\u0086\2\2\u048e\u048b\3\2\2\2\u048e\u048f\3\2\2"+ + "\2\u048f\u0491\3\2\2\2\u0490\u0492\5\u00aeX\2\u0491\u0490\3\2\2\2\u0491"+ + "\u0492\3\2\2\2\u0492\u00a9\3\2\2\2\u0493\u0495\5\u00acW\2\u0494\u0496"+ + "\5\u00caf\2\u0495\u0494\3\2\2\2\u0495\u0496\3\2\2\2\u0496\u0497\3\2\2"+ + "\2\u0497\u0499\7\u0086\2\2\u0498\u049a\5\u00aeX\2\u0499\u0498\3\2\2\2"+ + "\u0499\u049a\3\2\2\2\u049a\u049b\3\2\2\2\u049b\u049c\7\u0082\2\2\u049c"+ + "\u00ab\3\2\2\2\u049d\u049f\7#\2\2\u049e\u04a0\t\17\2\2\u049f\u049e\3\2"+ + "\2\2\u049f\u04a0\3\2\2\2\u04a0\u00ad\3\2\2\2\u04a1\u04a2\7\u0080\2\2\u04a2"+ + "\u04a3\5\u0098M\2\u04a3\u00af\3\2\2\2\u04a4\u04a9\5\u00b2Z\2\u04a5\u04a6"+ + "\7|\2\2\u04a6\u04a8\5\u00b2Z\2\u04a7\u04a5\3\2\2\2\u04a8\u04ab\3\2\2\2"+ + "\u04a9\u04a7\3\2\2\2\u04a9\u04aa\3\2\2\2\u04aa\u00b1\3\2\2\2\u04ab\u04a9"+ + "\3\2\2\2\u04ac\u04af\5\u00b4[\2\u04ad\u04ae\7g\2\2\u04ae\u04b0\5^\60\2"+ + "\u04af\u04ad\3\2\2\2\u04af\u04b0\3\2\2\2\u04b0\u00b3\3\2\2\2\u04b1\u04b2"+ + "\7\u0086\2\2\u04b2\u00b5\3\2\2\2\u04b3\u04b6\5\u00b8]\2\u04b4\u04b6\5"+ + "\u00bc_\2\u04b5\u04b3\3\2\2\2\u04b5\u04b4\3\2\2\2\u04b6\u00b7\3\2\2\2"+ + "\u04b7\u04b8\7\u0086\2\2\u04b8\u00b9\3\2\2\2\u04b9\u04bb\7.\2\2\u04ba"+ + "\u04b9\3\2\2\2\u04ba\u04bb\3\2\2\2\u04bb\u04bc\3\2\2\2\u04bc\u04bf\7\62"+ + "\2\2\u04bd\u04c0\7\u0086\2\2\u04be\u04c0\5\u00b8]\2\u04bf\u04bd\3\2\2"+ + "\2\u04bf\u04be\3\2\2\2\u04bf\u04c0\3\2\2\2\u04c0\u04c1\3\2\2\2\u04c1\u04c3"+ + "\7[\2\2\u04c2\u04c4\5z>\2\u04c3\u04c2\3\2\2\2\u04c3\u04c4\3\2\2\2\u04c4"+ + "\u04c5\3\2\2\2\u04c5\u04c6\7\\\2\2\u04c6\u00bb\3\2\2\2\u04c7\u04c8\7\u0086"+ + "\2\2\u04c8\u00bd\3\2\2\2\u04c9\u04ca\7\62\2\2\u04ca\u04cb\7\u0086\2\2"+ + "\u04cb\u04cc\7g\2\2\u04cc\u04cd\5\u00c0a\2\u04cd\u04ce\7\u0082\2\2\u04ce"+ + "\u00bf\3\2\2\2\u04cf\u04d1\5\f\7\2\u04d0\u04cf\3\2\2\2\u04d0\u04d1\3\2"+ + "\2\2\u04d1\u04d2\3\2\2\2\u04d2\u04d3\5\u00b6\\\2\u04d3\u00c1\3\2\2\2\u04d4"+ + "\u04da\7Q\2\2\u04d5\u04d7\7N\2\2\u04d6\u04d5\3\2\2\2\u04d6\u04d7\3\2\2"+ + "\2\u04d7\u04d8\3\2\2\2\u04d8\u04db\5\f\7\2\u04d9\u04db\7\u0081\2\2\u04da"+ + "\u04d6\3\2\2\2\u04da\u04d9\3\2\2\2\u04db\u04dc\3\2\2\2\u04dc\u04dd\5\b"+ + "\5\2\u04dd\u04de\7\u0082\2\2\u04de\u00c3\3\2\2\2\u04df\u04e1\5\u00caf"+ + "\2\u04e0\u04df\3\2\2\2\u04e0\u04e1\3\2\2\2\u04e1\u04e2\3\2\2\2\u04e2\u04e3"+ + "\7Q\2\2\u04e3\u04e5\7\62\2\2\u04e4\u04e6\5\f\7\2\u04e5\u04e4\3\2\2\2\u04e5"+ + "\u04e6\3\2\2\2\u04e6\u04e7\3\2\2\2\u04e7\u04e8\5\u00b6\\\2\u04e8\u04e9"+ + "\7\u0082\2\2\u04e9\u00c5\3\2\2\2\u04ea\u04eb\7\16\2\2\u04eb\u04ec\7W\2"+ + "\2\u04ec\u04ed\7\6\2\2\u04ed\u04ee\7X\2\2\u04ee\u04ef\7\u0082\2\2\u04ef"+ + "\u00c7\3\2\2\2\u04f0\u04f1\7&\2\2\u04f1\u04f8\7\6\2\2\u04f2\u04f4\7[\2"+ + "\2\u04f3\u04f5\5z>\2\u04f4\u04f3\3\2\2\2\u04f4\u04f5\3\2\2\2\u04f5\u04f6"+ + "\3\2\2\2\u04f6\u04f9\7\\\2\2\u04f7\u04f9\5|?\2\u04f8\u04f2\3\2\2\2\u04f8"+ + "\u04f7\3\2\2\2\u04f9\u00c9\3\2\2\2\u04fa\u04fc\5\u00ccg\2\u04fb\u04fa"+ + "\3\2\2\2\u04fc\u04fd\3\2\2\2\u04fd\u04fb\3\2\2\2\u04fd\u04fe\3\2\2\2\u04fe"+ + "\u00cb\3\2\2\2\u04ff\u0500\7Y\2\2\u0500\u0502\7Y\2\2\u0501\u0503\5\u00d0"+ + "i\2\u0502\u0501\3\2\2\2\u0502\u0503\3\2\2\2\u0503\u0504\3\2\2\2\u0504"+ + "\u0505\7Z\2\2\u0505\u0508\7Z\2\2\u0506\u0508\5\u00ceh\2\u0507\u04ff\3"+ + "\2\2\2\u0507\u0506\3\2\2\2\u0508\u00cd\3\2\2\2\u0509\u050a\7\f\2\2\u050a"+ + "\u050d\7W\2\2\u050b\u050e\5\u00f4{\2\u050c\u050e\5^\60\2\u050d\u050b\3"+ + "\2\2\2\u050d\u050c\3\2\2\2\u050e\u0510\3\2\2\2\u050f\u0511\7\u0085\2\2"+ + "\u0510\u050f\3\2\2\2\u0510\u0511\3\2\2\2\u0511\u0512\3\2\2\2\u0512\u0513"+ + "\7X\2\2\u0513\u00cf\3\2\2\2\u0514\u0519\5\u00d2j\2\u0515\u0516\7|\2\2"+ + "\u0516\u0518\5\u00d2j\2\u0517\u0515\3\2\2\2\u0518\u051b\3\2\2\2\u0519"+ + "\u0517\3\2\2\2\u0519\u051a\3\2\2\2\u051a\u051d\3\2\2\2\u051b\u0519\3\2"+ + "\2\2\u051c\u051e\7\u0085\2\2\u051d\u051c\3\2\2\2\u051d\u051e\3\2\2\2\u051e"+ + "\u00d1\3\2\2\2\u051f\u0520\5\u00d4k\2\u0520\u0521\7\u0081\2\2\u0521\u0523"+ + "\3\2\2\2\u0522\u051f\3\2\2\2\u0522\u0523\3\2\2\2\u0523\u0524\3\2\2\2\u0524"+ + "\u0526\7\u0086\2\2\u0525\u0527\5\u00d6l\2\u0526\u0525\3\2\2\2\u0526\u0527"+ + "\3\2\2\2\u0527\u00d3\3\2\2\2\u0528\u0529\7\u0086\2\2\u0529\u00d5\3\2\2"+ + "\2\u052a\u052c\7W\2\2\u052b\u052d\5\u00d8m\2\u052c\u052b\3\2\2\2\u052c"+ + "\u052d\3\2\2\2\u052d\u052e\3\2\2\2\u052e\u052f\7X\2\2\u052f\u00d7\3\2"+ + "\2\2\u0530\u0532\5\u00dan\2\u0531\u0530\3\2\2\2\u0532\u0533\3\2\2\2\u0533"+ + "\u0531\3\2\2\2\u0533\u0534\3\2\2\2\u0534\u00d9\3\2\2\2\u0535\u0536\7W"+ + "\2\2\u0536\u0537\5\u00d8m\2\u0537\u0538\7X\2\2\u0538\u0547\3\2\2\2\u0539"+ + "\u053a\7Y\2\2\u053a\u053b\5\u00d8m\2\u053b\u053c\7Z\2\2\u053c\u0547\3"+ + "\2\2\2\u053d\u053e\7[\2\2\u053e\u053f\5\u00d8m\2\u053f\u0540\7\\\2\2\u0540"+ + "\u0547\3\2\2\2\u0541\u0543\n\20\2\2\u0542\u0541\3\2\2\2\u0543\u0544\3"+ + "\2\2\2\u0544\u0542\3\2\2\2\u0544\u0545\3\2\2\2\u0545\u0547\3\2\2\2\u0546"+ + "\u0535\3\2\2\2\u0546\u0539\3\2\2\2\u0546\u053d\3\2\2\2\u0546\u0542\3\2"+ + "\2\2\u0547\u00db\3\2\2\2\u0548\u054d\5\u00dep\2\u0549\u054a\7|\2\2\u054a"+ + "\u054c\5\u00dep\2\u054b\u0549\3\2\2\2\u054c\u054f\3\2\2\2\u054d\u054b"+ + "\3\2\2\2\u054d\u054e\3\2\2\2\u054e\u00dd\3\2\2\2\u054f\u054d\3\2\2\2\u0550"+ + "\u0552\5\u00e0q\2\u0551\u0553\5\u010a\u0086\2\u0552\u0551\3\2\2\2\u0552"+ + "\u0553\3\2\2\2\u0553\u00df\3\2\2\2\u0554\u055a\5\u00e2r\2\u0555\u0556"+ + "\5\u00e4s\2\u0556\u0557\5\u00e6t\2\u0557\u0558\5\u00e8u\2\u0558\u055a"+ + "\3\2\2\2\u0559\u0554\3\2\2\2\u0559\u0555\3\2\2\2\u055a\u00e1\3\2\2\2\u055b"+ + "\u055d\5\u00eav\2\u055c\u055e\7\30\2\2\u055d\u055c\3\2\2\2\u055d\u055e"+ + "\3\2\2\2\u055e\u0560\3\2\2\2\u055f\u055b\3\2\2\2\u0560\u0563\3\2\2\2\u0561"+ + "\u055f\3\2\2\2\u0561\u0562\3\2\2\2\u0562\u0564\3\2\2\2\u0563\u0561\3\2"+ + "\2\2\u0564\u0565\5\u00e4s\2\u0565\u00e3\3\2\2\2\u0566\u0567\bs\1\2\u0567"+ + "\u0569\5\u00f2z\2\u0568\u056a\5\u00caf\2\u0569\u0568\3\2\2\2\u0569\u056a"+ + "\3\2\2\2\u056a\u0570\3\2\2\2\u056b\u056c\7W\2\2\u056c\u056d\5\u00e2r\2"+ + "\u056d\u056e\7X\2\2\u056e\u0570\3\2\2\2\u056f\u0566\3\2\2\2\u056f\u056b"+ + "\3\2\2\2\u0570\u057f\3\2\2\2\u0571\u057b\f\4\2\2\u0572\u057c\5\u00e6t"+ + "\2\u0573\u0575\7Y\2\2\u0574\u0576\5^\60\2\u0575\u0574\3\2\2\2\u0575\u0576"+ + "\3\2\2\2\u0576\u0577\3\2\2\2\u0577\u0579\7Z\2\2\u0578\u057a\5\u00caf\2"+ + "\u0579\u0578\3\2\2\2\u0579\u057a\3\2\2\2\u057a\u057c\3\2\2\2\u057b\u0572"+ + "\3\2\2\2\u057b\u0573\3\2\2\2\u057c\u057e\3\2\2\2\u057d\u0571\3\2\2\2\u057e"+ + "\u0581\3\2\2\2\u057f\u057d\3\2\2\2\u057f\u0580\3\2\2\2\u0580\u00e5\3\2"+ + "\2\2\u0581\u057f\3\2\2\2\u0582\u0584\7W\2\2\u0583\u0585\5\u0100\u0081"+ + "\2\u0584\u0583\3\2\2\2\u0584\u0585\3\2\2\2\u0585\u0586\3\2\2\2\u0586\u0588"+ + "\7X\2\2\u0587\u0589\5\u00ecw\2\u0588\u0587\3\2\2\2\u0588\u0589\3\2\2\2"+ + "\u0589\u058b\3\2\2\2\u058a\u058c\5\u00f0y\2\u058b\u058a\3\2\2\2\u058b"+ + "\u058c\3\2\2\2\u058c\u058e\3\2\2\2\u058d\u058f\5\u0170\u00b9\2\u058e\u058d"+ + "\3\2\2\2\u058e\u058f\3\2\2\2\u058f\u0591\3\2\2\2\u0590\u0592\5\u00caf"+ + "\2\u0591\u0590\3\2\2\2\u0591\u0592\3\2\2\2\u0592\u00e7\3\2\2\2\u0593\u0594"+ + "\7~\2\2\u0594\u0596\5\u009aN\2\u0595\u0597\5\u00f6|\2\u0596\u0595\3\2"+ + "\2\2\u0596\u0597\3\2\2\2\u0597\u00e9\3\2\2\2\u0598\u059a\t\21\2\2\u0599"+ + "\u059b\5\u00caf\2\u059a\u0599\3\2\2\2\u059a\u059b\3\2\2\2\u059b\u05a7"+ + "\3\2\2\2\u059c\u059e\5\f\7\2\u059d\u059c\3\2\2\2\u059d\u059e\3\2\2\2\u059e"+ + "\u059f\3\2\2\2\u059f\u05a1\7_\2\2\u05a0\u05a2\5\u00caf\2\u05a1\u05a0\3"+ + "\2\2\2\u05a1\u05a2\3\2\2\2\u05a2\u05a4\3\2\2\2\u05a3\u05a5\5\u00ecw\2"+ + "\u05a4\u05a3\3\2\2\2\u05a4\u05a5\3\2\2\2\u05a5\u05a7\3\2\2\2\u05a6\u0598"+ + "\3\2\2\2\u05a6\u059d\3\2\2\2\u05a7\u00eb\3\2\2\2\u05a8\u05aa\5\u00eex"+ + "\2\u05a9\u05a8\3\2\2\2\u05aa\u05ab\3\2\2\2\u05ab\u05a9\3\2\2\2\u05ab\u05ac"+ + "\3\2\2\2\u05ac\u00ed\3\2\2\2\u05ad\u05ae\t\22\2\2\u05ae\u00ef\3\2\2\2"+ + "\u05af\u05b0\t\21\2\2\u05b0\u00f1\3\2\2\2\u05b1\u05b3\7\u0085\2\2\u05b2"+ + "\u05b1\3\2\2\2\u05b2\u05b3\3\2\2\2\u05b3\u05b4\3\2\2\2\u05b4\u05b5\5\6"+ + "\4\2\u05b5\u00f3\3\2\2\2\u05b6\u05b8\5\u0098M\2\u05b7\u05b9\5\u00f6|\2"+ + "\u05b8\u05b7\3\2\2\2\u05b8\u05b9\3\2\2\2\u05b9\u00f5\3\2\2\2\u05ba\u05c3"+ + "\5\u00f8}\2\u05bb\u05bd\5\u00fa~\2\u05bc\u05bb\3\2\2\2\u05bc\u05bd\3\2"+ + "\2\2\u05bd\u05be\3\2\2\2\u05be\u05bf\5\u00e6t\2\u05bf\u05c0\5\u00e8u\2"+ + "\u05c0\u05c3\3\2\2\2\u05c1\u05c3\5\u00fc\177\2\u05c2\u05ba\3\2\2\2\u05c2"+ + "\u05bc\3\2\2\2\u05c2\u05c1\3\2\2\2\u05c3\u00f7\3\2\2\2\u05c4\u05ce\5\u00fa"+ + "~\2\u05c5\u05c7\5\u00eav\2\u05c6\u05c5\3\2\2\2\u05c7\u05c8\3\2\2\2\u05c8"+ + "\u05c6\3\2\2\2\u05c8\u05c9\3\2\2\2\u05c9\u05cb\3\2\2\2\u05ca\u05cc\5\u00fa"+ + "~\2\u05cb\u05ca\3\2\2\2\u05cb\u05cc\3\2\2\2\u05cc\u05ce\3\2\2\2\u05cd"+ + "\u05c4\3\2\2\2\u05cd\u05c6\3\2\2\2\u05ce\u00f9\3\2\2\2\u05cf\u05d0\b~"+ + "\1\2\u05d0\u05de\5\u00e6t\2\u05d1\u05d3\7Y\2\2\u05d2\u05d4\5^\60\2\u05d3"+ + "\u05d2\3\2\2\2\u05d3\u05d4\3\2\2\2\u05d4\u05d5\3\2\2\2\u05d5\u05d7\7Z"+ + "\2\2\u05d6\u05d8\5\u00caf\2\u05d7\u05d6\3\2\2\2\u05d7\u05d8\3\2\2\2\u05d8"+ + "\u05de\3\2\2\2\u05d9\u05da\7W\2\2\u05da\u05db\5\u00f8}\2\u05db\u05dc\7"+ + "X\2\2\u05dc\u05de\3\2\2\2\u05dd\u05cf\3\2\2\2\u05dd\u05d1\3\2\2\2\u05dd"+ + "\u05d9\3\2\2\2\u05de\u05ee\3\2\2\2\u05df\u05ea\f\6\2\2\u05e0\u05eb\5\u00e6"+ + "t\2\u05e1\u05e2\5\u00fa~\2\u05e2\u05e4\7Y\2\2\u05e3\u05e5\5^\60\2\u05e4"+ + "\u05e3\3\2\2\2\u05e4\u05e5\3\2\2\2\u05e5\u05e6\3\2\2\2\u05e6\u05e8\7Z"+ + "\2\2\u05e7\u05e9\5\u00caf\2\u05e8\u05e7\3\2\2\2\u05e8\u05e9\3\2\2\2\u05e9"+ + "\u05eb\3\2\2\2\u05ea\u05e0\3\2\2\2\u05ea\u05e1\3\2\2\2\u05eb\u05ed\3\2"+ + "\2\2\u05ec\u05df\3\2\2\2\u05ed\u05f0\3\2\2\2\u05ee\u05ec\3\2\2\2\u05ee"+ + "\u05ef\3\2\2\2\u05ef\u00fb\3\2\2\2\u05f0\u05ee\3\2\2\2\u05f1\u05f3\5\u00ea"+ + "v\2\u05f2\u05f1\3\2\2\2\u05f3\u05f6\3\2\2\2\u05f4\u05f2\3\2\2\2\u05f4"+ + "\u05f5\3\2\2\2\u05f5\u05f7\3\2\2\2\u05f6\u05f4\3\2\2\2\u05f7\u05f8\5\u00fe"+ + "\u0080\2\u05f8\u00fd\3\2\2\2\u05f9\u05fa\b\u0080\1\2\u05fa\u05fb\7\u0085"+ + "\2\2\u05fb\u060a\3\2\2\2\u05fc\u0606\f\4\2\2\u05fd\u0607\5\u00e6t\2\u05fe"+ + "\u0600\7Y\2\2\u05ff\u0601\5^\60\2\u0600\u05ff\3\2\2\2\u0600\u0601\3\2"+ + "\2\2\u0601\u0602\3\2\2\2\u0602\u0604\7Z\2\2\u0603\u0605\5\u00caf\2\u0604"+ + "\u0603\3\2\2\2\u0604\u0605\3\2\2\2\u0605\u0607\3\2\2\2\u0606\u05fd\3\2"+ + "\2\2\u0606\u05fe\3\2\2\2\u0607\u0609\3\2\2\2\u0608\u05fc\3\2\2\2\u0609"+ + "\u060c\3\2\2\2\u060a\u0608\3\2\2\2\u060a\u060b\3\2\2\2\u060b\u00ff\3\2"+ + "\2\2\u060c\u060a\3\2\2\2\u060d\u0612\5\u0102\u0082\2\u060e\u0610\7|\2"+ + "\2\u060f\u060e\3\2\2\2\u060f\u0610\3\2\2\2\u0610\u0611\3\2\2\2\u0611\u0613"+ + "\7\u0085\2\2\u0612\u060f\3\2\2\2\u0612\u0613\3\2\2\2\u0613\u0101\3\2\2"+ + "\2\u0614\u0619\5\u0104\u0083\2\u0615\u0616\7|\2\2\u0616\u0618\5\u0104"+ + "\u0083\2\u0617\u0615\3\2\2\2\u0618\u061b\3\2\2\2\u0619\u0617\3\2\2\2\u0619"+ + "\u061a\3\2\2\2\u061a\u0103\3\2\2\2\u061b\u0619\3\2\2\2\u061c\u061e\5\u00ca"+ + "f\2\u061d\u061c\3\2\2\2\u061d\u061e\3\2\2\2\u061e\u061f\3\2\2\2\u061f"+ + "\u0624\5\u008cG\2\u0620\u0625\5\u00e0q\2\u0621\u0623\5\u00f6|\2\u0622"+ + "\u0621\3\2\2\2\u0622\u0623\3\2\2\2\u0623\u0625\3\2\2\2\u0624\u0620\3\2"+ + "\2\2\u0624\u0622\3\2\2\2\u0625\u0628\3\2\2\2\u0626\u0627\7g\2\2\u0627"+ + "\u0629\5\u010e\u0088\2\u0628\u0626\3\2\2\2\u0628\u0629\3\2\2\2\u0629\u0105"+ + "\3\2\2\2\u062a\u062c\5\u00caf\2\u062b\u062a\3\2\2\2\u062b\u062c\3\2\2"+ + "\2\u062c\u062e\3\2\2\2\u062d\u062f\5\u008cG\2\u062e\u062d\3\2\2\2\u062e"+ + "\u062f\3\2\2\2\u062f\u0630\3\2\2\2\u0630\u0632\5\u00e0q\2\u0631\u0633"+ + "\5\u0128\u0095\2\u0632\u0631\3\2\2\2\u0632\u0633\3\2\2\2\u0633\u0634\3"+ + "\2\2\2\u0634\u0635\5\u0108\u0085\2\u0635\u0107\3\2\2\2\u0636\u0638\5\u0140"+ + "\u00a1\2\u0637\u0636\3\2\2\2\u0637\u0638\3\2\2\2\u0638\u0639\3\2\2\2\u0639"+ + "\u063f\5f\64\2\u063a\u063f\5\u0166\u00b4\2\u063b\u063c\7g\2\2\u063c\u063d"+ + "\t\23\2\2\u063d\u063f\7\u0082\2\2\u063e\u0637\3\2\2\2\u063e\u063a\3\2"+ + "\2\2\u063e\u063b\3\2\2\2\u063f\u0109\3\2\2\2\u0640\u0646\5\u010c\u0087"+ + "\2\u0641\u0642\7W\2\2\u0642\u0643\5$\23\2\u0643\u0644\7X\2\2\u0644\u0646"+ + "\3\2\2\2\u0645\u0640\3\2\2\2\u0645\u0641\3\2\2\2\u0646\u010b\3\2\2\2\u0647"+ + "\u0648\7g\2\2\u0648\u064b\5\u010e\u0088\2\u0649\u064b\5\u0112\u008a\2"+ + "\u064a\u0647\3\2\2\2\u064a\u0649\3\2\2\2\u064b\u010d\3\2\2\2\u064c\u064f"+ + "\5X-\2\u064d\u064f\5\u0112\u008a\2\u064e\u064c\3\2\2\2\u064e\u064d\3\2"+ + "\2\2\u064f\u010f\3\2\2\2\u0650\u0652\5\u010e\u0088\2\u0651\u0653\7\u0085"+ + "\2\2\u0652\u0651\3\2\2\2\u0652\u0653\3\2\2\2\u0653\u065b\3\2\2\2\u0654"+ + "\u0655\7|\2\2\u0655\u0657\5\u010e\u0088\2\u0656\u0658\7\u0085\2\2\u0657"+ + "\u0656\3\2\2\2\u0657\u0658\3\2\2\2\u0658\u065a\3\2\2\2\u0659\u0654\3\2"+ + "\2\2\u065a\u065d\3\2\2\2\u065b\u0659\3\2\2\2\u065b\u065c\3\2\2\2\u065c"+ + "\u0111\3\2\2\2\u065d\u065b\3\2\2\2\u065e\u0663\7[\2\2\u065f\u0661\5\u0110"+ + "\u0089\2\u0660\u0662\7|\2\2\u0661\u0660\3\2\2\2\u0661\u0662\3\2\2\2\u0662"+ + "\u0664\3\2\2\2\u0663\u065f\3\2\2\2\u0663\u0664\3\2\2\2\u0664\u0665\3\2"+ + "\2\2\u0665\u0666\7\\\2\2\u0666\u0113\3\2\2\2\u0667\u066a\7\u0086\2\2\u0668"+ + "\u066a\5\u0154\u00ab\2\u0669\u0667\3\2\2\2\u0669\u0668\3\2\2\2\u066a\u0115"+ + "\3\2\2\2\u066b\u066c\5\u0118\u008d\2\u066c\u066e\7[\2\2\u066d\u066f\5"+ + "\u0120\u0091\2\u066e\u066d\3\2\2\2\u066e\u066f\3\2\2\2\u066f\u0670\3\2"+ + "\2\2\u0670\u0671\7\\\2\2\u0671\u0117\3\2\2\2\u0672\u0674\5\u011e\u0090"+ + "\2\u0673\u0675\5\u00caf\2\u0674\u0673\3\2\2\2\u0674\u0675\3\2\2\2\u0675"+ + "\u067a\3\2\2\2\u0676\u0678\5\u011a\u008e\2\u0677\u0679\5\u011c\u008f\2"+ + "\u0678\u0677\3\2\2\2\u0678\u0679\3\2\2\2\u0679\u067b\3\2\2\2\u067a\u0676"+ + "\3\2\2\2\u067a\u067b\3\2\2\2\u067b\u067d\3\2\2\2\u067c\u067e\5\u012e\u0098"+ + "\2\u067d\u067c\3\2\2\2\u067d\u067e\3\2\2\2\u067e\u068a\3\2\2\2\u067f\u0681"+ + "\7O\2\2\u0680\u0682\5\u00caf\2\u0681\u0680\3\2\2\2\u0681\u0682\3\2\2\2"+ + "\u0682\u0687\3\2\2\2\u0683\u0685\5\u011a\u008e\2\u0684\u0686\5\u011c\u008f"+ + "\2\u0685\u0684\3\2\2\2\u0685\u0686\3\2\2\2\u0686\u0688\3\2\2\2\u0687\u0683"+ + "\3\2\2\2\u0687\u0688\3\2\2\2\u0688\u068a\3\2\2\2\u0689\u0672\3\2\2\2\u0689"+ + "\u067f\3\2\2\2\u068a\u0119\3\2\2\2\u068b\u068d\5\f\7\2\u068c\u068b\3\2"+ + "\2\2\u068c\u068d\3\2\2\2\u068d\u068e\3\2\2\2\u068e\u068f\5\u0114\u008b"+ + "\2\u068f\u011b\3\2\2\2\u0690\u0691\7(\2\2\u0691\u011d\3\2\2\2\u0692\u0693"+ + "\t\17\2\2\u0693\u011f\3\2\2\2\u0694\u0699\5\u0122\u0092\2\u0695\u0696"+ + "\5\u0138\u009d\2\u0696\u0697\7\u0080\2\2\u0697\u0699\3\2\2\2\u0698\u0694"+ + "\3\2\2\2\u0698\u0695\3\2\2\2\u0699\u069a\3\2\2\2\u069a\u0698\3\2\2\2\u069a"+ + "\u069b\3\2\2\2\u069b\u0121\3\2\2\2\u069c\u069e\5\u00caf\2\u069d\u069c"+ + "\3\2\2\2\u069d\u069e\3\2\2\2\u069e\u06a0\3\2\2\2\u069f\u06a1\5\u008cG"+ + "\2\u06a0\u069f\3\2\2\2\u06a0\u06a1\3\2\2\2\u06a1\u06a3\3\2\2\2\u06a2\u06a4"+ + "\5\u0124\u0093\2\u06a3\u06a2\3\2\2\2\u06a3\u06a4\3\2\2\2\u06a4\u06a5\3"+ + "\2\2\2\u06a5\u06ad\7\u0082\2\2\u06a6\u06ad\5\u0106\u0084\2\u06a7\u06ad"+ + "\5\u00c2b\2\u06a8\u06ad\5\u0084C\2\u06a9\u06ad\5\u014c\u00a7\2\u06aa\u06ad"+ + "\5\u0080A\2\u06ab\u06ad\5\u0086D\2\u06ac\u069d\3\2\2\2\u06ac\u06a6\3\2"+ + "\2\2\u06ac\u06a7\3\2\2\2\u06ac\u06a8\3\2\2\2\u06ac\u06a9\3\2\2\2\u06ac"+ + "\u06aa\3\2\2\2\u06ac\u06ab\3\2\2\2\u06ad\u0123\3\2\2\2\u06ae\u06b3\5\u0126"+ + "\u0094\2\u06af\u06b0\7|\2\2\u06b0\u06b2\5\u0126\u0094\2\u06b1\u06af\3"+ + "\2\2\2\u06b2\u06b5\3\2\2\2\u06b3\u06b1\3\2\2\2\u06b3\u06b4\3\2\2\2\u06b4"+ + "\u0125\3\2\2\2\u06b5\u06b3\3\2\2\2\u06b6\u06c0\5\u00e0q\2\u06b7\u06b9"+ + "\5\u0128\u0095\2\u06b8\u06b7\3\2\2\2\u06b8\u06b9\3\2\2\2\u06b9\u06bb\3"+ + "\2\2\2\u06ba\u06bc\5\u012c\u0097\2\u06bb\u06ba\3\2\2\2\u06bb\u06bc\3\2"+ + "\2\2\u06bc\u06c1\3\2\2\2\u06bd\u06bf\5\u010c\u0087\2\u06be\u06bd\3\2\2"+ + "\2\u06be\u06bf\3\2\2\2\u06bf\u06c1\3\2\2\2\u06c0\u06b8\3\2\2\2\u06c0\u06be"+ + "\3\2\2\2\u06c1\u06cb\3\2\2\2\u06c2\u06c4\7\u0086\2\2\u06c3\u06c2\3\2\2"+ + "\2\u06c3\u06c4\3\2\2\2\u06c4\u06c6\3\2\2\2\u06c5\u06c7\5\u00caf\2\u06c6"+ + "\u06c5\3\2\2\2\u06c6\u06c7\3\2\2\2\u06c7\u06c8\3\2\2\2\u06c8\u06c9\7\u0080"+ + "\2\2\u06c9\u06cb\5^\60\2\u06ca\u06b6\3\2\2\2\u06ca\u06c3\3\2\2\2\u06cb"+ + "\u0127\3\2\2\2\u06cc\u06ce\5\u012a\u0096\2\u06cd\u06cc\3\2\2\2\u06ce\u06cf"+ + "\3\2\2\2\u06cf\u06cd\3\2\2\2\u06cf\u06d0\3\2\2\2\u06d0\u0129\3\2\2\2\u06d1"+ + "\u06d2\t\24\2\2\u06d2\u012b\3\2\2\2\u06d3\u06d4\7g\2\2\u06d4\u06d5\7\u0088"+ + "\2\2\u06d5\u06d6\b\u0097\1\2\u06d6\u012d\3\2\2\2\u06d7\u06d8\7\u0080\2"+ + "\2\u06d8\u06d9\5\u0130\u0099\2\u06d9\u012f\3\2\2\2\u06da\u06dc\5\u0132"+ + "\u009a\2\u06db\u06dd\7\u0085\2\2\u06dc\u06db\3\2\2\2\u06dc\u06dd\3\2\2"+ + "\2\u06dd\u06e5\3\2\2\2\u06de\u06df\7|\2\2\u06df\u06e1\5\u0132\u009a\2"+ + "\u06e0\u06e2\7\u0085\2\2\u06e1\u06e0\3\2\2\2\u06e1\u06e2\3\2\2\2\u06e2"+ + "\u06e4\3\2\2\2\u06e3\u06de\3\2\2\2\u06e4\u06e7\3\2\2\2\u06e5\u06e3\3\2"+ + "\2\2\u06e5\u06e6\3\2\2\2\u06e6\u0131\3\2\2\2\u06e7\u06e5\3\2\2\2\u06e8"+ + "\u06ea\5\u00caf\2\u06e9\u06e8\3\2\2\2\u06e9\u06ea\3\2\2\2\u06ea\u06f7"+ + "\3\2\2\2\u06eb\u06f8\5\u0136\u009c\2\u06ec\u06ee\7R\2\2\u06ed\u06ef\5"+ + "\u0138\u009d\2\u06ee\u06ed\3\2\2\2\u06ee\u06ef\3\2\2\2\u06ef\u06f0\3\2"+ + "\2\2\u06f0\u06f8\5\u0136\u009c\2\u06f1\u06f3\5\u0138\u009d\2\u06f2\u06f4"+ + "\7R\2\2\u06f3\u06f2\3\2\2\2\u06f3\u06f4\3\2\2\2\u06f4\u06f5\3\2\2\2\u06f5"+ + "\u06f6\5\u0136\u009c\2\u06f6\u06f8\3\2\2\2\u06f7\u06eb\3\2\2\2\u06f7\u06ec"+ + "\3\2\2\2\u06f7\u06f1\3\2\2\2\u06f8\u0133\3\2\2\2\u06f9\u06fb\5\f\7\2\u06fa"+ + "\u06f9\3\2\2\2\u06fa\u06fb\3\2\2\2\u06fb\u06fc\3\2\2\2\u06fc\u06ff\5\u0114"+ + "\u008b\2\u06fd\u06ff\5\u00a0Q\2\u06fe\u06fa\3\2\2\2\u06fe\u06fd\3\2\2"+ + "\2\u06ff\u0135\3\2\2\2\u0700\u0701\5\u0134\u009b\2\u0701\u0137\3\2\2\2"+ + "\u0702\u0703\t\25\2\2\u0703\u0139\3\2\2\2\u0704\u0705\7\66\2\2\u0705\u0706"+ + "\5\u013c\u009f\2\u0706\u013b\3\2\2\2\u0707\u0709\5\u0098M\2\u0708\u070a"+ + "\5\u013e\u00a0\2\u0709\u0708\3\2\2\2\u0709\u070a\3\2\2\2\u070a\u013d\3"+ + "\2\2\2\u070b\u070d\5\u00eav\2\u070c\u070e\5\u013e\u00a0\2\u070d\u070c"+ + "\3\2\2\2\u070d\u070e\3\2\2\2\u070e\u013f\3\2\2\2\u070f\u0710\7\u0080\2"+ + "\2\u0710\u0711\5\u0142\u00a2\2\u0711\u0141\3\2\2\2\u0712\u0714\5\u0144"+ + "\u00a3\2\u0713\u0715\7\u0085\2\2\u0714\u0713\3\2\2\2\u0714\u0715\3\2\2"+ + "\2\u0715\u071d\3\2\2\2\u0716\u0717\7|\2\2\u0717\u0719\5\u0144\u00a3\2"+ + "\u0718\u071a\7\u0085\2\2\u0719\u0718\3\2\2\2\u0719\u071a\3\2\2\2\u071a"+ + "\u071c\3\2\2\2\u071b\u0716\3\2\2\2\u071c\u071f\3\2\2\2\u071d\u071b\3\2"+ + "\2\2\u071d\u071e\3\2\2\2\u071e\u0143\3\2\2\2\u071f\u071d\3\2\2\2\u0720"+ + "\u0727\5\u0146\u00a4\2\u0721\u0723\7W\2\2\u0722\u0724\5$\23\2\u0723\u0722"+ + "\3\2\2\2\u0723\u0724\3\2\2\2\u0724\u0725\3\2\2\2\u0725\u0728\7X\2\2\u0726"+ + "\u0728\5\u0112\u008a\2\u0727\u0721\3\2\2\2\u0727\u0726\3\2\2\2\u0728\u0145"+ + "\3\2\2\2\u0729\u072c\5\u0134\u009b\2\u072a\u072c\7\u0086\2\2\u072b\u0729"+ + "\3\2\2\2\u072b\u072a\3\2\2\2\u072c\u0147\3\2\2\2\u072d\u072e\7\66\2\2"+ + "\u072e\u072f\5\u0178\u00bd\2\u072f\u0149\3\2\2\2\u0730\u0734\7\66\2\2"+ + "\u0731\u0732\7\6\2\2\u0732\u0735\7\u0086\2\2\u0733\u0735\7\u008e\2\2\u0734"+ + "\u0731\3\2\2\2\u0734\u0733\3\2\2\2\u0735\u014b\3\2\2\2\u0736\u0737\7F"+ + "\2\2\u0737\u0738\7h\2\2\u0738\u0739\5\u014e\u00a8\2\u0739\u073a\7i\2\2"+ + "\u073a\u073b\5|?\2\u073b\u014d\3\2\2\2\u073c\u0741\5\u0150\u00a9\2\u073d"+ + "\u073e\7|\2\2\u073e\u0740\5\u0150\u00a9\2\u073f\u073d\3\2\2\2\u0740\u0743"+ + "\3\2\2\2\u0741\u073f\3\2\2\2\u0741\u0742\3\2\2\2\u0742\u014f\3\2\2\2\u0743"+ + "\u0741\3\2\2\2\u0744\u0747\5\u0152\u00aa\2\u0745\u0747\5\u0104\u0083\2"+ + "\u0746\u0744\3\2\2\2\u0746\u0745\3\2\2\2\u0747\u0151\3\2\2\2\u0748\u0749"+ + "\7F\2\2\u0749\u074a\7h\2\2\u074a\u074b\5\u014e\u00a8\2\u074b\u074c\7i"+ + "\2\2\u074c\u074e\3\2\2\2\u074d\u0748\3\2\2\2\u074d\u074e\3\2\2\2\u074e"+ + "\u074f\3\2\2\2\u074f\u0752\7\27\2\2\u0750\u0752\7N\2\2\u0751\u074d\3\2"+ + "\2\2\u0751\u0750\3\2\2\2\u0752\u075e\3\2\2\2\u0753\u0755\7\u0085\2\2\u0754"+ + "\u0753\3\2\2\2\u0754\u0755\3\2\2\2\u0755\u0757\3\2\2\2\u0756\u0758\7\u0086"+ + "\2\2\u0757\u0756\3\2\2\2\u0757\u0758\3\2\2\2\u0758\u075f\3\2\2\2\u0759"+ + "\u075b\7\u0086\2\2\u075a\u0759\3\2\2\2\u075a\u075b\3\2\2\2\u075b\u075c"+ + "\3\2\2\2\u075c\u075d\7g\2\2\u075d\u075f\5\u00f4{\2\u075e\u0754\3\2\2\2"+ + "\u075e\u075a\3\2\2\2\u075f\u0153\3\2\2\2\u0760\u0761\5\u0158\u00ad\2\u0761"+ + "\u0763\7h\2\2\u0762\u0764\5\u015a\u00ae\2\u0763\u0762\3\2\2\2\u0763\u0764"+ + "\3\2\2\2\u0764\u0765\3\2\2\2\u0765\u0766\7i\2\2\u0766\u0155\3\2\2\2\u0767"+ + "\u0773\5\u0154\u00ab\2\u0768\u076b\5\u0148\u00a5\2\u0769\u076b\5\u014a"+ + "\u00a6\2\u076a\u0768\3\2\2\2\u076a\u0769\3\2\2\2\u076b\u076c\3\2\2\2\u076c"+ + "\u076e\7h\2\2\u076d\u076f\5\u015a\u00ae\2\u076e\u076d\3\2\2\2\u076e\u076f"+ + "\3\2\2\2\u076f\u0770\3\2\2\2\u0770\u0771\7i\2\2\u0771\u0773\3\2\2\2\u0772"+ + "\u0767\3\2\2\2\u0772\u076a\3\2\2\2\u0773\u0157\3\2\2\2\u0774\u0775\7\u0086"+ + "\2\2\u0775\u0159\3\2\2\2\u0776\u0778\5\u015c\u00af\2\u0777\u0779\7\u0085"+ + "\2\2\u0778\u0777\3\2\2\2\u0778\u0779\3\2\2\2\u0779\u0781\3\2\2\2\u077a"+ + "\u077b\7|\2\2\u077b\u077d\5\u015c\u00af\2\u077c\u077e\7\u0085\2\2\u077d"+ + "\u077c\3\2\2\2\u077d\u077e\3\2\2\2\u077e\u0780\3\2\2\2\u077f\u077a\3\2"+ + "\2\2\u0780\u0783\3\2\2\2\u0781\u077f\3\2\2\2\u0781\u0782\3\2\2\2\u0782"+ + "\u015b\3\2\2\2\u0783\u0781\3\2\2\2\u0784\u0788\5\u00f4{\2\u0785\u0788"+ + "\5^\60\2\u0786\u0788\5\6\4\2\u0787\u0784\3\2\2\2\u0787\u0785\3\2\2\2\u0787"+ + "\u0786\3\2\2\2\u0788\u015d\3\2\2\2\u0789\u078a\7N\2\2\u078a\u0790\5\f"+ + "\7\2\u078b\u0791\7\u0086\2\2\u078c\u078e\7F\2\2\u078d\u078c\3\2\2\2\u078d"+ + "\u078e\3\2\2\2\u078e\u078f\3\2\2\2\u078f\u0791\5\u0154\u00ab\2\u0790\u078b"+ + "\3\2\2\2\u0790\u078d\3\2\2\2\u0791\u015f\3\2\2\2\u0792\u0794\7&\2\2\u0793"+ + "\u0792\3\2\2\2\u0793\u0794\3\2\2\2\u0794\u0795\3\2\2\2\u0795\u0796\7F"+ + "\2\2\u0796\u0797\5|?\2\u0797\u0161\3\2\2\2\u0798\u0799\7F\2\2\u0799\u079a"+ + "\7h\2\2\u079a\u079b\7i\2\2\u079b\u079c\5|?\2\u079c\u0163\3\2\2\2\u079d"+ + "\u079e\7K\2\2\u079e\u079f\5f\64\2\u079f\u07a0\5\u0168\u00b5\2\u07a0\u0165"+ + "\3\2\2\2\u07a1\u07a3\7K\2\2\u07a2\u07a4\5\u0140\u00a1\2\u07a3\u07a2\3"+ + "\2\2\2\u07a3\u07a4\3\2\2\2\u07a4\u07a5\3\2\2\2\u07a5\u07a6\5f\64\2\u07a6"+ + "\u07a7\5\u0168\u00b5\2\u07a7\u0167\3\2\2\2\u07a8\u07aa\5\u016a\u00b6\2"+ + "\u07a9\u07a8\3\2\2\2\u07aa\u07ab\3\2\2\2\u07ab\u07a9\3\2\2\2\u07ab\u07ac"+ + "\3\2\2\2\u07ac\u0169\3\2\2\2\u07ad\u07ae\7\23\2\2\u07ae\u07af\7W\2\2\u07af"+ + "\u07b0\5\u016c\u00b7\2\u07b0\u07b1\7X\2\2\u07b1\u07b2\5f\64\2\u07b2\u016b"+ + "\3\2\2\2\u07b3\u07b5\5\u00caf\2\u07b4\u07b3\3\2\2\2\u07b4\u07b5\3\2\2"+ + "\2\u07b5\u07b6\3\2\2\2\u07b6\u07b9\5\u0098M\2\u07b7\u07ba\5\u00e0q\2\u07b8"+ + "\u07ba\5\u00f6|\2\u07b9\u07b7\3\2\2\2\u07b9\u07b8\3\2\2\2\u07b9\u07ba"+ + "\3\2\2\2\u07ba\u07bd\3\2\2\2\u07bb\u07bd\7\u0085\2\2\u07bc\u07b4\3\2\2"+ + "\2\u07bc\u07bb\3\2\2\2\u07bd\u016d\3\2\2\2\u07be\u07c0\7I\2\2\u07bf\u07c1"+ + "\5X-\2\u07c0\u07bf\3\2\2\2\u07c0\u07c1\3\2\2\2\u07c1\u016f\3\2\2\2\u07c2"+ + "\u07c5\5\u0172\u00ba\2\u07c3\u07c5\5\u0176\u00bc\2\u07c4\u07c2\3\2\2\2"+ + "\u07c4\u07c3\3\2\2\2\u07c5\u0171\3\2\2\2\u07c6\u07c7\7I\2\2\u07c7\u07c9"+ + "\7W\2\2\u07c8\u07ca\5\u0174\u00bb\2\u07c9\u07c8\3\2\2\2\u07c9\u07ca\3"+ + "\2\2\2\u07ca\u07cb\3\2\2\2\u07cb\u07cc\7X\2\2\u07cc\u0173\3\2\2\2\u07cd"+ + "\u07cf\5\u00f4{\2\u07ce\u07d0\7\u0085\2\2\u07cf\u07ce\3\2\2\2\u07cf\u07d0"+ + "\3\2\2\2\u07d0\u07d8\3\2\2\2\u07d1\u07d2\7|\2\2\u07d2\u07d4\5\u00f4{\2"+ + "\u07d3\u07d5\7\u0085\2\2\u07d4\u07d3\3\2\2\2\u07d4\u07d5\3\2\2\2\u07d5"+ + "\u07d7\3\2\2\2\u07d6\u07d1\3\2\2\2\u07d7\u07da\3\2\2\2\u07d8\u07d6\3\2"+ + "\2\2\u07d8\u07d9\3\2\2\2\u07d9\u0175\3\2\2\2\u07da\u07d8\3\2\2\2\u07db"+ + "\u07dc\7\64\2\2\u07dc\u07dd\7W\2\2\u07dd\u07de\5^\60\2\u07de\u07df\7X"+ + "\2\2\u07df\u07e2\3\2\2\2\u07e0\u07e2\7\64\2\2\u07e1\u07db\3\2\2\2\u07e1"+ + "\u07e0\3\2\2\2\u07e2\u0177\3\2\2\2\u07e3\u07e6\7\63\2\2\u07e4\u07e5\7"+ + "Y\2\2\u07e5\u07e7\7Z\2\2\u07e6\u07e4\3\2\2\2\u07e6\u07e7\3\2\2\2\u07e7"+ + "\u0819\3\2\2\2\u07e8\u07eb\7\36\2\2\u07e9\u07ea\7Y\2\2\u07ea\u07ec\7Z"+ + "\2\2\u07eb\u07e9\3\2\2\2\u07eb\u07ec\3\2\2\2\u07ec\u0819\3\2\2\2\u07ed"+ + "\u0819\7]\2\2\u07ee\u0819\7^\2\2\u07ef\u0819\7_\2\2\u07f0\u0819\7`\2\2"+ + "\u07f1\u0819\7a\2\2\u07f2\u0819\7b\2\2\u07f3\u0819\7c\2\2\u07f4\u0819"+ + "\7d\2\2\u07f5\u0819\7e\2\2\u07f6\u0819\7f\2\2\u07f7\u0819\7g\2\2\u07f8"+ + "\u0819\7i\2\2\u07f9\u0819\7h\2\2\u07fa\u0819\7w\2\2\u07fb\u0819\7j\2\2"+ + "\u07fc\u0819\7k\2\2\u07fd\u0819\7l\2\2\u07fe\u0819\7g\2\2\u07ff\u0819"+ + "\7n\2\2\u0800\u0819\7o\2\2\u0801\u0819\7p\2\2\u0802\u0819\7q\2\2\u0803"+ + "\u0804\7h\2\2\u0804\u0819\7h\2\2\u0805\u0806\7i\2\2\u0806\u0819\7i\2\2"+ + "\u0807\u0819\7s\2\2\u0808\u0819\7r\2\2\u0809\u0819\7t\2\2\u080a\u0819"+ + "\7u\2\2\u080b\u0819\7v\2\2\u080c\u0819\7w\2\2\u080d\u0819\7x\2\2\u080e"+ + "\u0819\7y\2\2\u080f\u0819\7z\2\2\u0810\u0819\7{\2\2\u0811\u0819\7|\2\2"+ + "\u0812\u0819\7}\2\2\u0813\u0819\7~\2\2\u0814\u0815\7W\2\2\u0815\u0819"+ + "\7X\2\2\u0816\u0817\7Y\2\2\u0817\u0819\7Z\2\2\u0818\u07e3\3\2\2\2\u0818"+ + "\u07e8\3\2\2\2\u0818\u07ed\3\2\2\2\u0818\u07ee\3\2\2\2\u0818\u07ef\3\2"+ + "\2\2\u0818\u07f0\3\2\2\2\u0818\u07f1\3\2\2\2\u0818\u07f2\3\2\2\2\u0818"+ + "\u07f3\3\2\2\2\u0818\u07f4\3\2\2\2\u0818\u07f5\3\2\2\2\u0818\u07f6\3\2"+ + "\2\2\u0818\u07f7\3\2\2\2\u0818\u07f8\3\2\2\2\u0818\u07f9\3\2\2\2\u0818"+ + "\u07fa\3\2\2\2\u0818\u07fb\3\2\2\2\u0818\u07fc\3\2\2\2\u0818\u07fd\3\2"+ + "\2\2\u0818\u07fe\3\2\2\2\u0818\u07ff\3\2\2\2\u0818\u0800\3\2\2\2\u0818"+ + "\u0801\3\2\2\2\u0818\u0802\3\2\2\2\u0818\u0803\3\2\2\2\u0818\u0805\3\2"+ + "\2\2\u0818\u0807\3\2\2\2\u0818\u0808\3\2\2\2\u0818\u0809\3\2\2\2\u0818"+ + "\u080a\3\2\2\2\u0818\u080b\3\2\2\2\u0818\u080c\3\2\2\2\u0818\u080d\3\2"+ + "\2\2\u0818\u080e\3\2\2\2\u0818\u080f\3\2\2\2\u0818\u0810\3\2\2\2\u0818"+ + "\u0811\3\2\2\2\u0818\u0812\3\2\2\2\u0818\u0813\3\2\2\2\u0818\u0814\3\2"+ + "\2\2\u0818\u0816\3\2\2\2\u0819\u0179\3\2\2\2\u081a\u081b\t\26\2\2\u081b"+ + "\u017b\3\2\2\2\u012b\u017d\u0184\u018d\u0191\u019a\u019d\u01a1\u01a9\u01b0"+ + "\u01b3\u01b8\u01bd\u01c3\u01cb\u01cd\u01d6\u01da\u01de\u01e1\u01e5\u01e8"+ + "\u01ef\u01f3\u01f6\u01f9\u01fc\u0202\u0206\u020a\u0218\u021c\u0222\u0229"+ + "\u022f\u0233\u0237\u0239\u0241\u0246\u0253\u025a\u0266\u0270\u0275\u0279"+ + "\u0280\u0283\u028b\u028f\u0292\u0299\u02a0\u02a4\u02a9\u02ad\u02b0\u02b5"+ + "\u02c4\u02cb\u02d3\u02db\u02e4\u02eb\u02f2\u02fa\u0302\u030a\u0312\u031a"+ + "\u0322\u032b\u0333\u033c\u0343\u034b\u034e\u0351\u0357\u035d\u0363\u036a"+ + "\u0373\u037b\u037f\u0386\u0388\u039c\u03a0\u03a6\u03ab\u03af\u03b2\u03b9"+ + "\u03c0\u03c4\u03cd\u03d8\u03e2\u03e7\u03ee\u03f1\u03f6\u03fb\u0410\u0415"+ + "\u0418\u0423\u0429\u042e\u0431\u0436\u0439\u043c\u0452\u0458\u045e\u0464"+ + "\u0467\u046d\u0471\u0475\u0478\u0480\u0482\u0488\u048b\u048e\u0491\u0495"+ + "\u0499\u049f\u04a9\u04af\u04b5\u04ba\u04bf\u04c3\u04d0\u04d6\u04da\u04e0"+ + "\u04e5\u04f4\u04f8\u04fd\u0502\u0507\u050d\u0510\u0519\u051d\u0522\u0526"+ + "\u052c\u0533\u0544\u0546\u054d\u0552\u0559\u055d\u0561\u0569\u056f\u0575"+ + "\u0579\u057b\u057f\u0584\u0588\u058b\u058e\u0591\u0596\u059a\u059d\u05a1"+ + "\u05a4\u05a6\u05ab\u05b2\u05b8\u05bc\u05c2\u05c8\u05cb\u05cd\u05d3\u05d7"+ + "\u05dd\u05e4\u05e8\u05ea\u05ee\u05f4\u0600\u0604\u0606\u060a\u060f\u0612"+ + "\u0619\u061d\u0622\u0624\u0628\u062b\u062e\u0632\u0637\u063e\u0645\u064a"+ + "\u064e\u0652\u0657\u065b\u0661\u0663\u0669\u066e\u0674\u0678\u067a\u067d"+ + "\u0681\u0685\u0687\u0689\u068c\u0698\u069a\u069d\u06a0\u06a3\u06ac\u06b3"+ + "\u06b8\u06bb\u06be\u06c0\u06c3\u06c6\u06ca\u06cf\u06dc\u06e1\u06e5\u06e9"+ + "\u06ee\u06f3\u06f7\u06fa\u06fe\u0709\u070d\u0714\u0719\u071d\u0723\u0727"+ + "\u072b\u0734\u0741\u0746\u074d\u0751\u0754\u0757\u075a\u075e\u0763\u076a"+ + "\u076e\u0772\u0778\u077d\u0781\u0787\u078d\u0790\u0793\u07a3\u07ab\u07b4"+ + "\u07b9\u07bc\u07c0\u07c4\u07c9\u07cf\u07d4\u07d8\u07e1\u07e6\u07eb\u0818"; + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} \ No newline at end of file diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Parser.tokens b/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Parser.tokens new file mode 100644 index 000000000..97906afe4 --- /dev/null +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Parser.tokens @@ -0,0 +1,264 @@ +IntegerLiteral=1 +CharacterLiteral=2 +FloatingLiteral=3 +StringLiteral=4 +BooleanLiteral=5 +PointerLiteral=6 +UserDefinedLiteral=7 +MultiLineMacro=8 +Directive=9 +Alignas=10 +Alignof=11 +Asm=12 +Auto=13 +Bool=14 +Break=15 +Case=16 +Catch=17 +Char=18 +Char16=19 +Char32=20 +Class=21 +Const=22 +Constexpr=23 +Const_cast=24 +Continue=25 +Decltype=26 +Default=27 +Delete=28 +Do=29 +Double=30 +Dynamic_cast=31 +Else=32 +Enum=33 +Explicit=34 +Export=35 +Extern=36 +False_=37 +Final=38 +Float=39 +For=40 +Friend=41 +Goto=42 +If=43 +Inline=44 +Int=45 +Long=46 +Mutable=47 +Namespace=48 +New=49 +Noexcept=50 +Nullptr=51 +Operator=52 +Override=53 +Private=54 +Protected=55 +Public=56 +Register=57 +Reinterpret_cast=58 +Return=59 +Short=60 +Signed=61 +Sizeof=62 +Static=63 +Static_assert=64 +Static_cast=65 +Struct=66 +Switch=67 +Template=68 +This=69 +Thread_local=70 +Throw=71 +True_=72 +Try=73 +Typedef=74 +Typeid_=75 +Typename_=76 +Union=77 +Unsigned=78 +Using=79 +Virtual=80 +Void=81 +Volatile=82 +Wchar=83 +While=84 +LeftParen=85 +RightParen=86 +LeftBracket=87 +RightBracket=88 +LeftBrace=89 +RightBrace=90 +Plus=91 +Minus=92 +Star=93 +Div=94 +Mod=95 +Caret=96 +And=97 +Or=98 +Tilde=99 +Not=100 +Assign=101 +Less=102 +Greater=103 +PlusAssign=104 +MinusAssign=105 +StarAssign=106 +DivAssign=107 +ModAssign=108 +XorAssign=109 +AndAssign=110 +OrAssign=111 +LeftShiftAssign=112 +RightShiftAssign=113 +Equal=114 +NotEqual=115 +LessEqual=116 +GreaterEqual=117 +AndAnd=118 +OrOr=119 +PlusPlus=120 +MinusMinus=121 +Comma=122 +ArrowStar=123 +Arrow=124 +Question=125 +Colon=126 +Doublecolon=127 +Semi=128 +Dot=129 +DotStar=130 +Ellipsis=131 +Identifier=132 +DecimalLiteral=133 +OctalLiteral=134 +HexadecimalLiteral=135 +BinaryLiteral=136 +Integersuffix=137 +UserDefinedIntegerLiteral=138 +UserDefinedFloatingLiteral=139 +UserDefinedStringLiteral=140 +UserDefinedCharacterLiteral=141 +Whitespace=142 +Newline=143 +BlockComment=144 +LineComment=145 +'alignas'=10 +'alignof'=11 +'asm'=12 +'auto'=13 +'bool'=14 +'break'=15 +'case'=16 +'catch'=17 +'char'=18 +'char16_t'=19 +'char32_t'=20 +'class'=21 +'const'=22 +'constexpr'=23 +'const_cast'=24 +'continue'=25 +'decltype'=26 +'default'=27 +'delete'=28 +'do'=29 +'double'=30 +'dynamic_cast'=31 +'else'=32 +'enum'=33 +'explicit'=34 +'export'=35 +'extern'=36 +'false'=37 +'final'=38 +'float'=39 +'for'=40 +'friend'=41 +'goto'=42 +'if'=43 +'inline'=44 +'int'=45 +'long'=46 +'mutable'=47 +'namespace'=48 +'new'=49 +'noexcept'=50 +'nullptr'=51 +'operator'=52 +'override'=53 +'private'=54 +'protected'=55 +'public'=56 +'register'=57 +'reinterpret_cast'=58 +'return'=59 +'short'=60 +'signed'=61 +'sizeof'=62 +'static'=63 +'static_assert'=64 +'static_cast'=65 +'struct'=66 +'switch'=67 +'template'=68 +'this'=69 +'thread_local'=70 +'throw'=71 +'true'=72 +'try'=73 +'typedef'=74 +'typeid'=75 +'typename'=76 +'union'=77 +'unsigned'=78 +'using'=79 +'virtual'=80 +'void'=81 +'volatile'=82 +'wchar_t'=83 +'while'=84 +'('=85 +')'=86 +'['=87 +']'=88 +'{'=89 +'}'=90 +'+'=91 +'-'=92 +'*'=93 +'/'=94 +'%'=95 +'^'=96 +'&'=97 +'|'=98 +'~'=99 +'='=101 +'<'=102 +'>'=103 +'+='=104 +'-='=105 +'*='=106 +'/='=107 +'%='=108 +'^='=109 +'&='=110 +'|='=111 +'<<='=112 +'>>='=113 +'=='=114 +'!='=115 +'<='=116 +'>='=117 +'++'=120 +'--'=121 +','=122 +'->*'=123 +'->'=124 +'?'=125 +':'=126 +'::'=127 +';'=128 +'.'=129 +'.*'=130 +'...'=131