diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml index 2175dbb2f..e58d9fd89 100644 --- a/.idea/codeStyles/Project.xml +++ b/.idea/codeStyles/Project.xml @@ -641,6 +641,9 @@ diff --git a/app/build.gradle b/app/build.gradle index f96cea90a..833c77e86 100755 --- a/app/build.gradle +++ b/app/build.gradle @@ -138,4 +138,12 @@ dependencies { // This is to build the tooling-api-impl project before the app is built // So we always copy the latest JAR file to assets compileOnly project (path: ':build-tools:tooling-api-impl') + + testImplementation common.editor + testImplementation tests.junit + testImplementation tests.google_truth + testImplementation tests.robolectric + androidTestImplementation tests.androidx_junit + androidTestImplementation tests.androidx_espresso + androidTestImplementation tests.google_truth } \ No newline at end of file diff --git a/app/src/main/java/com/itsaky/androidide/language/incremental/AsyncIncrementalAnalyzeManager.java b/app/src/main/java/com/itsaky/androidide/language/incremental/AsyncIncrementalAnalyzeManager.java new file mode 100644 index 000000000..d413ac324 --- /dev/null +++ b/app/src/main/java/com/itsaky/androidide/language/incremental/AsyncIncrementalAnalyzeManager.java @@ -0,0 +1,641 @@ +/* + * 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.incremental; + +import android.os.Bundle; +import android.os.Handler; +import android.os.Looper; +import android.os.Message; +import android.util.Log; + +import androidx.annotation.NonNull; +import androidx.annotation.Nullable; + +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.locks.Lock; +import java.util.concurrent.locks.ReentrantLock; + +import io.github.rosemoe.sora.lang.analysis.IncrementalAnalyzeManager; +import io.github.rosemoe.sora.lang.analysis.StyleReceiver; +import io.github.rosemoe.sora.lang.styling.CodeBlock; +import io.github.rosemoe.sora.lang.styling.Span; +import io.github.rosemoe.sora.lang.styling.Spans; +import io.github.rosemoe.sora.lang.styling.Styles; +import io.github.rosemoe.sora.text.CharPosition; +import io.github.rosemoe.sora.text.Content; +import io.github.rosemoe.sora.text.ContentReference; +import io.github.rosemoe.sora.util.IntPair; +import io.github.rosemoe.sora.widget.schemes.EditorColorScheme; + +/** + * TODO: Remove this class as soon as our needs are implemented in sora-editor's + * AsyncIncrementalAnalyzeManager. + * + * @author Rose + * @author Akash Yadav + * @see AsyncIncrementalAnalyzeManager + * in sora-editor. + */ +public abstract class AsyncIncrementalAnalyzeManager + implements IncrementalAnalyzeManager { + + private StyleReceiver receiver; + private ContentReference ref; + private Bundle extraArguments; + private LooperThread thread; + private volatile long runCount; + private static int sThreadId = 0; + private static final int MSG_BASE = 11451400; + private static final int MSG_INIT = MSG_BASE + 1; + private static final int MSG_MOD = MSG_BASE + 2; + private static final int MSG_EXIT = MSG_BASE + 3; + + @NonNull private static final Method clearSpansMethod; + + static { + try { + final var klass = IncrementalAnalyzeManager.LineTokenizeResult.class; + clearSpansMethod = klass.getDeclaredMethod("clearSpans"); + if (!clearSpansMethod.isAccessible()) { + clearSpansMethod.setAccessible(true); + } + } catch (Throwable err) { + throw new RuntimeException( + "Cannot access clearSpans() method of LineTokenizeResult. Maybe implementation changed?", + err); + } + } + + private static LineTokenizeResult clearSpans(LineTokenizeResult result) { + try { + return (LineTokenizeResult) clearSpansMethod.invoke(result); + } catch (Throwable error) { + throw new RuntimeException("Cannot invoke clearSpans() method", error); + } + } + + @Override + public void setReceiver(StyleReceiver receiver) { + this.receiver = receiver; + } + + @Override + public void reset(@NonNull ContentReference content, @NonNull Bundle extraArguments) { + this.ref = content; + this.extraArguments = extraArguments; + rerun(); + } + + @Override + public void insert(CharPosition start, CharPosition end, CharSequence insertedText) { + if (thread != null) { + increaseRunCount(); + thread.handler.sendMessage( + thread.handler.obtainMessage( + MSG_MOD, + new TextModification( + IntPair.pack(start.line, start.column), + IntPair.pack(end.line, end.column), + insertedText))); + sendUpdate(thread.styles); + } + } + + @Override + public void delete(CharPosition start, CharPosition end, CharSequence deletedText) { + if (thread != null) { + increaseRunCount(); + thread.handler.sendMessage( + thread.handler.obtainMessage( + MSG_MOD, + new TextModification( + IntPair.pack(start.line, start.column), + IntPair.pack(end.line, end.column), + null))); + sendUpdate(thread.styles); + } + } + + @Override + public void rerun() { + if (thread != null) { + thread.callback = + () -> { + throw new CancelledException(); + }; + if (thread.isAlive()) { + final var handler = thread.handler; + if (handler != null) { + handler.sendMessage(Message.obtain(thread.handler, MSG_EXIT)); + } + thread.abort = true; + } + } + final var text = ref.getReference().copyText(false); + text.setUndoEnabled(false); + thread = + new LooperThread( + () -> thread.handler.sendMessage(thread.handler.obtainMessage(MSG_INIT, text))); + thread.setName("AsyncAnalyzer-" + nextThreadId()); + increaseRunCount(); + thread.start(); + sendUpdate(null); + } + + @Override + public LineTokenizeResult getState(int line) { + final var thread = this.thread; + if (thread == Thread.currentThread()) { + return thread.states.get(line); + } + throw new SecurityException("Can not get state from non-analytical or abandoned thread"); + } + + @Override + public AsyncLineTokenizeResult tokenizeLine(final CharSequence line, final S state) { + throw new UnsupportedOperationException("Use tokenizeLine(CharSequence, int, S) instead."); + } + + @Override + public List generateSpansForLine(final LineTokenizeResult tokens) { + throw new UnsupportedOperationException( + "Use generateSpansForLine(AsyncLineTokenizeResult) instead."); + } + + /** + * Generate spans for the given tokenization result. + * + * @param tokens The tokenization result. + * @return The spans for the tokens. + */ + public abstract List generateSpansForLine(final AsyncLineTokenizeResult tokens); + + private synchronized void increaseRunCount() { + runCount++; + } + + private static synchronized int nextThreadId() { + sThreadId++; + return sThreadId; + } + + @Override + public void destroy() { + if (thread != null) { + thread.callback = + () -> { + throw new CancelledException(); + }; + if (thread.isAlive()) { + thread.handler.sendMessage(Message.obtain(thread.handler, MSG_EXIT)); + thread.abort = true; + } + } + receiver = null; + ref = null; + extraArguments = null; + thread = null; + } + + private void sendUpdate(Styles styles) { + final var r = receiver; + if (r != null) { + r.setStyles(this, styles); + } + } + + /** + * Compute code blocks + * + * @param text The text. can be safely accessed. + */ + public abstract List computeBlocks(Content text, CodeBlockAnalyzeDelegate delegate); + + public Bundle getExtraArguments() { + return extraArguments; + } + + /** Helper class for analyzing code block */ + public class CodeBlockAnalyzeDelegate { + + private final LooperThread thread; + int suppressSwitch; + + CodeBlockAnalyzeDelegate(@NonNull LooperThread lp) { + thread = lp; + } + + public void setSuppressSwitch(int suppressSwitch) { + this.suppressSwitch = suppressSwitch; + } + + void reset() { + suppressSwitch = Integer.MAX_VALUE; + } + + public boolean isCancelled() { + return thread.myRunCount != runCount; + } + + public boolean isNotCancelled() { + return thread.myRunCount == runCount; + } + } + + private class LooperThread extends Thread { + + volatile boolean abort; + Looper looper; + Handler handler; + Content shadowed; + long myRunCount; + + List> states = new ArrayList<>(); + Styles styles; + LockedSpans spans; + Runnable callback; + CodeBlockAnalyzeDelegate delegate = new CodeBlockAnalyzeDelegate(this); + + public LooperThread(Runnable callback) { + this.callback = callback; + } + + private void tryUpdate() { + if (!abort) sendUpdate(styles); + } + + private void initialize() { + styles = new Styles(spans = new LockedSpans()); + S state = getInitialState(); + var mdf = spans.modify(); + for (int i = 0; i < shadowed.getLineCount(); i++) { + var line = shadowed.getLine(i); + var result = tokenizeLine(line, state); + result.line = i; + state = result.state; + var spans = result.spans != null ? result.spans : generateSpansForLine(result); + states.add(clearSpans(result)); + mdf.addLineAt(i, spans); + } + styles.blocks = computeBlocks(shadowed, delegate); + styles.setSuppressSwitch(delegate.suppressSwitch); + tryUpdate(); + } + + @Override + public void run() { + Looper.prepare(); + looper = Looper.myLooper(); + handler = + new Handler(looper) { + + @Override + public void handleMessage(@NonNull Message msg) { + super.handleMessage(msg); + try { + myRunCount = runCount; + delegate.reset(); + switch (msg.what) { + case MSG_INIT: + shadowed = (Content) msg.obj; + if (!abort) { + initialize(); + } + break; + case MSG_MOD: + if (!abort) { + var mod = (TextModification) msg.obj; + int startLine = IntPair.getFirst(mod.start); + int endLine = IntPair.getFirst(mod.end); + if (mod.changedText == null) { + shadowed.delete( + IntPair.getFirst(mod.start), + IntPair.getSecond(mod.start), + IntPair.getFirst(mod.end), + IntPair.getSecond(mod.end)); + S state = + startLine == 0 ? getInitialState() : states.get(startLine - 1).state; + // Remove states + if (endLine >= startLine + 1) { + states.subList(startLine + 1, endLine + 1).clear(); + } + var mdf = spans.modify(); + for (int i = startLine + 1; i <= endLine; i++) { + mdf.deleteLineAt(startLine + 1); + } + int line = startLine; + while (line < shadowed.getLineCount()) { + var res = tokenizeLine(shadowed.getLine(line), state); + res.line = line; + mdf.setSpansOnLine( + line, res.spans != null ? res.spans : generateSpansForLine(res)); + var old = states.set(line, clearSpans(res)); + if (stateEquals(old.state, res.state)) { + break; + } + state = res.state; + line++; + } + } else { + shadowed.insert( + IntPair.getFirst(mod.start), + IntPair.getSecond(mod.start), + mod.changedText); + S state = + startLine == 0 ? getInitialState() : states.get(startLine - 1).state; + int line = startLine; + var spans = styles.spans.modify(); + // Add Lines + while (line <= endLine) { + var res = tokenizeLine(shadowed.getLine(line), state); + res.line = line; + if (line == startLine) { + spans.setSpansOnLine( + line, res.spans != null ? res.spans : generateSpansForLine(res)); + states.set(line, clearSpans(res)); + } else { + spans.addLineAt( + line, res.spans != null ? res.spans : generateSpansForLine(res)); + states.add(line, clearSpans(res)); + } + state = res.state; + line++; + } + // line = end.line + 1, check whether the state equals + while (line < shadowed.getLineCount()) { + var res = tokenizeLine(shadowed.getLine(line), state); + res.line = line; + if (stateEquals(res.state, states.get(line).state)) { + break; + } else { + spans.setSpansOnLine( + line, res.spans != null ? res.spans : generateSpansForLine(res)); + states.set(line, clearSpans(res)); + } + line++; + } + } + } + styles.blocks = computeBlocks(shadowed, delegate); + styles.setSuppressSwitch(delegate.suppressSwitch); + tryUpdate(); + break; + case MSG_EXIT: + looper.quit(); + break; + } + } catch (Exception e) { + Log.w("AsyncAnalysis", "Thread " + Thread.currentThread().getName() + " failed", e); + } + } + }; + + try { + callback.run(); + Looper.loop(); + } catch (CancelledException e) { + // ignored + } + } + } + + private static class LockedSpans implements Spans { + + private final Lock lock; + private final List lines; + + public LockedSpans() { + lines = new ArrayList<>(128); + lock = new ReentrantLock(); + } + + @Override + public void adjustOnDelete(CharPosition start, CharPosition end) {} + + @Override + public void adjustOnInsert(CharPosition start, CharPosition end) {} + + @Override + public int getLineCount() { + return lines.size(); + } + + @Override + public Reader read() { + return new ReaderImpl(); + } + + @Override + public Modifier modify() { + return new ModifierImpl(); + } + + @Override + public boolean supportsModify() { + return true; + } + + private static class Line { + + public Lock lock = new ReentrantLock(); + + public List spans; + + public Line() { + this(null); + } + + public Line(List s) { + spans = s; + } + } + + private class ReaderImpl implements Spans.Reader { + + private Line line; + + public void moveToLine(int line) { + if (line < 0) { + if (this.line != null) { + this.line.lock.unlock(); + } + this.line = null; + } else if (line >= lines.size()) { + if (this.line != null) { + this.line.lock.unlock(); + } + this.line = null; + } else { + if (this.line != null) { + this.line.lock.unlock(); + } + var locked = false; + try { + locked = lock.tryLock(100, TimeUnit.MICROSECONDS); + } catch (InterruptedException e) { + e.printStackTrace(); + } + if (locked) { + try { + var obj = lines.get(line); + if (obj.lock.tryLock()) { + this.line = obj; + } else { + this.line = null; + } + } finally { + lock.unlock(); + } + } else { + this.line = null; + } + } + } + + @Override + public int getSpanCount() { + return line == null ? 1 : line.spans.size(); + } + + @Override + public Span getSpanAt(int index) { + return line == null ? Span.obtain(0, EditorColorScheme.TEXT_NORMAL) : line.spans.get(index); + } + + @Override + public List getSpansOnLine(int line) { + var spans = new ArrayList(); + var locked = false; + try { + locked = lock.tryLock(1, TimeUnit.MILLISECONDS); + } catch (InterruptedException e) { + e.printStackTrace(); + } + if (locked) { + Line obj = null; + try { + if (line < lines.size()) { + obj = lines.get(line); + } + } finally { + lock.unlock(); + } + if (obj != null && obj.lock.tryLock()) { + try { + return Collections.unmodifiableList(obj.spans); + } finally { + obj.lock.unlock(); + } + } else { + spans.add(getSpanAt(0)); + } + } else { + spans.add(getSpanAt(0)); + } + return spans; + } + } + + private class ModifierImpl implements Modifier { + + @Override + public void setSpansOnLine(int line, List spans) { + lock.lock(); + try { + while (lines.size() <= line) { + var list = new ArrayList(); + list.add(Span.obtain(0, EditorColorScheme.TEXT_NORMAL)); + lines.add(new Line(list)); + } + var obj = lines.get(line); + obj.lock.lock(); + try { + obj.spans = spans; + } finally { + obj.lock.unlock(); + } + } finally { + lock.unlock(); + } + } + + @Override + public void addLineAt(int line, List spans) { + lock.lock(); + try { + lines.add(line, new Line(spans)); + } finally { + lock.unlock(); + } + } + + @Override + public void deleteLineAt(int line) { + lock.lock(); + try { + var obj = lines.get(line); + obj.lock.lock(); + try { + lines.remove(line); + } finally { + obj.lock.unlock(); + } + } finally { + lock.unlock(); + } + } + } + } + + public static class AsyncLineTokenizeResult extends LineTokenizeResult { + + public int line = -1; + + public AsyncLineTokenizeResult(@NonNull final S_ state, @Nullable final List tokens) { + super(state, tokens); + } + + public AsyncLineTokenizeResult( + @NonNull final S_ state, + @Nullable final List tokens, + @Nullable final List spans) { + super(state, tokens, spans); + } + } + + private static class TextModification { + + private final long start; + private final long end; + /** null for deletion */ + private final CharSequence changedText; + + TextModification(long start, long end, CharSequence text) { + this.start = start; + this.end = end; + changedText = text; + } + } + + private static class CancelledException extends RuntimeException {} +} diff --git a/app/src/main/java/com/itsaky/androidide/language/incremental/BaseIncrementalAnalyzeManager.java b/app/src/main/java/com/itsaky/androidide/language/incremental/BaseIncrementalAnalyzeManager.java new file mode 100644 index 000000000..97d6294db --- /dev/null +++ b/app/src/main/java/com/itsaky/androidide/language/incremental/BaseIncrementalAnalyzeManager.java @@ -0,0 +1,393 @@ +/* + * 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.incremental; + +import static com.itsaky.androidide.language.incremental.LineState.INCOMPLETE; +import static com.itsaky.androidide.language.incremental.LineState.NORMAL; + +import androidx.annotation.NonNull; + +import com.google.common.base.Preconditions; +import com.google.common.collect.EvictingQueue; +import com.itsaky.androidide.language.IAnalyzeManager; +import com.itsaky.androidide.language.java.JavaIncrementalAnalyzeManager; +import com.itsaky.androidide.lexers.java.JavaLexer; +import com.itsaky.androidide.syntax.colorschemes.SchemeAndroidIDE; +import com.itsaky.androidide.utils.CharSequenceReader; +import com.itsaky.androidide.utils.ILogger; +import com.itsaky.lsp.models.DiagnosticItem; +import com.itsaky.lsp.models.DiagnosticSeverity; + +import org.antlr.v4.runtime.CharStream; +import org.antlr.v4.runtime.CharStreams; +import org.antlr.v4.runtime.Lexer; +import org.antlr.v4.runtime.Token; +import org.jetbrains.annotations.Contract; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; +import java.util.stream.Collectors; + +import io.github.rosemoe.sora.lang.styling.MappedSpans; +import io.github.rosemoe.sora.lang.styling.Span; +import io.github.rosemoe.sora.lang.styling.TextStyle; +import io.github.rosemoe.sora.util.IntPair; +import kotlin.Pair; + +/** + * Base class for implementing an {@link AsyncIncrementalAnalyzeManager} in AndroidIDE. + * + * @author Akash Yadav + */ +public abstract class BaseIncrementalAnalyzeManager + extends AsyncIncrementalAnalyzeManager implements IAnalyzeManager { + + protected final Lexer lexer; + protected final List ideDiagnostics = new ArrayList<>(); + protected List diagnostics = new ArrayList<>(); + private final int[] multilineStartTypes; + private final int[] multilineEndTypes; + private static final ILogger LOG = ILogger.newInstance("BaseIncrementalAnalyzeManager"); + + public BaseIncrementalAnalyzeManager(final Lexer lexer) { + Objects.requireNonNull(lexer, "Cannot create analyzer manager for null lexer"); + this.lexer = lexer; + + var multilineTokenTypes = getMultilineTokenStartEndTypes(); + verifyMultilineTypes(multilineTokenTypes); + + this.multilineStartTypes = multilineTokenTypes[0]; + this.multilineEndTypes = multilineTokenTypes[1]; + } + + private void verifyMultilineTypes(@NonNull final int[][] types) { + Preconditions.checkState( + types.length == 2, "There must be exact two inner int[] in multiline token types"); + + final var start = types[0]; + final var end = types[1]; + Preconditions.checkState(start.length > 0, "Invalid start token types"); + Preconditions.checkState(end.length > 0, "Invalid end token types"); + } + + @SuppressWarnings("UnstableApiUsage") + @NonNull + private Pair, EvictingQueue> + createEvictingQueueForTokens() { + return new Pair<>( + EvictingQueue.create(multilineStartTypes.length), + EvictingQueue.create(multilineEndTypes.length)); + } + + @SuppressWarnings("UnstableApiUsage") + private boolean isIncompleteTokenStart(EvictingQueue q) { + return matchTokenTypes(this.multilineStartTypes, q); + } + + @SuppressWarnings("UnstableApiUsage") + private boolean isIncompleteTokenEnd(EvictingQueue q) { + return matchTokenTypes(this.multilineEndTypes, q); + } + + @SuppressWarnings("UnstableApiUsage") + private boolean matchTokenTypes( + @NonNull int[] types, @NonNull EvictingQueue tokens) { + final var arr = tokens.toArray(new IncrementalToken[0]); + for (int i = 0; i < types.length; i++) { + if (types[i] != arr[i].getType()) { + return false; + } + } + return true; + } + + /** + * Returns the token types which start and end a multiline token. + * + * @return A 2xn matrix where int[] at index 0 specifies token types which start a + * multiline token and int[] 1 specifies tokens which end the multiline token. For example, + *

[['/', '*'], ['*', '/']]. + *

But instead of characters, there must be token types. + * @see JavaIncrementalAnalyzeManager + */ + protected abstract int[][] getMultilineTokenStartEndTypes(); + + /** + * Generate spans for the given {@link LineTokenizeResult}. + * + * @param tokens The tokenization result. + * @return The spans for the tokens. + */ + protected abstract MappedSpans.Builder generateSpans( + final AsyncLineTokenizeResult tokens); + + /** + * Called when the analyzer finds an incomplete token in a lne. + * + * @param token The incomplete token. + */ + protected abstract void handleIncompleteToken(IncrementalToken token); + + /** + * Gets the next token from lexer and return an {@link IncrementalToken}. + * + * @return The next {@link IncrementalToken}. + */ + protected IncrementalToken nextToken() { + return new IncrementalToken(lexer.nextToken()); + } + + @NonNull + protected CharStream createStream(@NonNull CharSequence source) { + Objects.requireNonNull(source); + try { + return CharStreams.fromReader(new CharSequenceReader(source)); + } catch (IOException e) { + throw new RuntimeException("Cannot create CharStream for source", e); + } + } + + protected void markDiagnostics(MappedSpans.Builder spans, List diagnostics) { + diagnostics.sort(DiagnosticItem.START_COMPARATOR); + for (var d : diagnostics) { + if (d == null) { + continue; + } + + var start = d.getRange().getStart(); + var end = d.getRange().getEnd(); + + try { + spans.markProblemRegion( + convertToSpanFlag(d.getSeverity()), + start.getLine(), + start.getColumn(), + end.getLine(), + end.getColumn()); + } catch (Throwable e) { + // Might happen frequently if user types faster + } + } + } + + @Contract(pure = true) + private int convertToSpanFlag(@NonNull DiagnosticSeverity severity) { + switch (severity) { + case WARNING: + return Span.FLAG_WARNING; + case ERROR: + return Span.FLAG_ERROR; + case HINT: + case INFO: + default: + return Span.FLAG_TYPO; + } + } + + @Override + public void updateDiagnostics(@NonNull final List diagnostics) { + this.diagnostics = diagnostics; + } + + @NonNull + @Override + public List getDiagnostics() { + final var result = new ArrayList<>(ideDiagnostics); + if (diagnostics != null && !diagnostics.isEmpty()) { + result.addAll(diagnostics); + } + result.sort(DiagnosticItem.START_COMPARATOR); + return result; + } + + @Override + public LineState getInitialState() { + return new LineState(); + } + + @Override + public boolean stateEquals(final LineState state, final LineState another) { + return state.equals(another); + } + + @Override + public AsyncLineTokenizeResult tokenizeLine( + final CharSequence line, final LineState state) { + LOG.debug("Tokenize lines:", line); + final var tokens = new ArrayList(); + var newState = 0; + var stateObj = new LineState(); + if (state.state == NORMAL) { + newState = tokenizeNormal(line, 0, tokens, stateObj); + } else if (state.state == INCOMPLETE) { + final var result = fillIncomplete(line, tokens); + newState = IntPair.getFirst(result); + if (newState == NORMAL) { + newState = tokenizeNormal(line, IntPair.getSecond(result), tokens, stateObj); + } else { + newState = INCOMPLETE; + } + } + stateObj.state = newState; + return new AsyncLineTokenizeResult<>(stateObj, tokens); + } + + /** + * Called when the state in {@link #tokenizeLine(CharSequence, LineState)} is {@link + * LineState#NORMAL}. + * + * @param line The line source. + * @param column The column in line. + * @param tokens The list of tokens that must be updated as the line is scanned. + * @param st The state object whose state must be after after the line has been + * scanned. + * @return The new state. + */ + @SuppressWarnings("UnstableApiUsage") + protected int tokenizeNormal( + final CharSequence line, + final int column, + final List tokens, + final LineState st) { + lexer.setInputStream(createStream(line)); + final var queues = createEvictingQueueForTokens(); + final var start = queues.getFirst(); + final var end = queues.getSecond(); + var isInIncompleteToken = false; + var state = NORMAL; + IncrementalToken token; + IncrementalToken incompleteToken = null; + + while ((token = nextToken()) != null) { + if (token.getType() == IncrementalToken.EOF) { + break; + } + + // Skip to the token just after 'column' + if (token.getStartIndex() < column) { + continue; + } + + if (!isInIncompleteToken) { + if (token.getStartIndex() == column && !tokens.isEmpty()) { + token.type = tokens.get(tokens.size() - 1).getType(); + } + + tokens.add(token); + } + start.add(token); + end.add(token); + final var type = token.getType(); + if (type == JavaLexer.LBRACE || type == JavaLexer.RBRACE) { + st.hasBraces = true; + } + + if (start.remainingCapacity() == 0 && isIncompleteTokenStart(start)) { + isInIncompleteToken = true; + incompleteToken = start.poll(); + + // Comment starts from the '/' token + // So we have to remove the '*' token after '/' + tokens.remove(tokens.size() - 1); + } else if (end.remainingCapacity() == 0 && isIncompleteTokenEnd(end)) { + // This should most probably not happen because, if a comment starts and ends on the same + // line, the lexer will create a token for the whole comment + // But still we handle this case... + isInIncompleteToken = false; + incompleteToken = null; + } + + if (isInIncompleteToken) { + state = INCOMPLETE; + } + } + + if (incompleteToken != null) { + incompleteToken.incomplete = true; + handleIncompleteToken(incompleteToken); + } + + return state; + } + + /** + * Called when the state in {@link #tokenizeLine(CharSequence, LineState)} is {@link + * LineState#INCOMPLETE}. + * + * @param line The line source. + * @param tokens The list of tokens that must be updated as the line is scanned. + * @return The state and offset. + */ + @SuppressWarnings("UnstableApiUsage") + protected long fillIncomplete(CharSequence line, final List tokens) { + lexer.setInputStream(createStream(line)); + final var queue = createEvictingQueueForTokens(); + final var end = queue.getSecond(); + final var allTokens = + lexer.getAllTokens().stream().map(IncrementalToken::new).collect(Collectors.toList()); + var completed = false; + var index = 0; + for (index = 0; index < allTokens.size(); index++) { + final IncrementalToken token = allTokens.get(index); + if (token.getType() == Token.EOF) { + break; + } + + end.add(token); + if (end.remainingCapacity() == 0 && isIncompleteTokenEnd(end)) { + completed = true; + break; + } + } + + final var first = allTokens.get(0); + final int offset = allTokens.get(completed ? index : index - 1).getStartIndex(); + first.startIndex = 0; + handleIncompleteToken(first); + tokens.add(first); + if (completed) { + return IntPair.pack(NORMAL, offset); + } else { + return IntPair.pack(INCOMPLETE, offset); + } + } + + @Override + public List generateSpansForLine( + final AsyncLineTokenizeResult tokens) { + var spans = generateSpans(tokens); + spans.determine(tokens.line); + + List result; + try { + result = new ArrayList<>(spans.build().read().getSpansOnLine(tokens.line)); + } catch (Throwable err) { + result = new ArrayList<>(); + } + + if (result.isEmpty()) { + result.add(Span.obtain(0, TextStyle.makeStyle(SchemeAndroidIDE.TEXT_NORMAL))); + } + + // TODO Mark diagnostics in spans. + + return result; + } +} diff --git a/app/src/main/java/com/itsaky/androidide/language/incremental/IncrementalToken.kt b/app/src/main/java/com/itsaky/androidide/language/incremental/IncrementalToken.kt new file mode 100644 index 000000000..380070f74 --- /dev/null +++ b/app/src/main/java/com/itsaky/androidide/language/incremental/IncrementalToken.kt @@ -0,0 +1,48 @@ +/* + * 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.incremental + +import org.antlr.v4.runtime.CharStream +import org.antlr.v4.runtime.Token +import org.antlr.v4.runtime.TokenSource + +/** + * Token used for incremental lexing tasks. Allows us to store other information to tokens. + * + * @author Akash Yadav + */ +class IncrementalToken(val token: Token) : Token { + + @JvmField var type = token.type + @JvmField var startIndex = token.startIndex + @JvmField var incomplete = false + + override fun getText(): String = token.text + override fun getType() = type + override fun getLine() = token.line + override fun getCharPositionInLine() = token.charPositionInLine + override fun getChannel() = token.channel + override fun getTokenIndex() = token.tokenIndex + override fun getStartIndex() = startIndex + override fun getStopIndex() = token.stopIndex + override fun getTokenSource(): TokenSource = token.tokenSource + override fun getInputStream(): CharStream = token.inputStream + override fun equals(other: Any?) = token == other + override fun hashCode() = token.hashCode() + override fun toString() = token.toString() +} diff --git a/app/src/main/java/com/itsaky/androidide/language/incremental/LineState.kt b/app/src/main/java/com/itsaky/androidide/language/incremental/LineState.kt new file mode 100644 index 000000000..496432095 --- /dev/null +++ b/app/src/main/java/com/itsaky/androidide/language/incremental/LineState.kt @@ -0,0 +1,66 @@ +/* + * 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.incremental + +import com.itsaky.lsp.models.DiagnosticItem + +/** + * Tokenization state of a line. + * + * @author Akash Yadav + */ +class LineState { + + companion object { + const val NORMAL = 0 + const val INCOMPLETE = 1 + } + + @JvmField var state = NORMAL + @JvmField var hasBraces = false + @JvmField var diagnostics: DiagnosticsState? = null + + override fun equals(other: Any?): Boolean { + if (this === other) return true + if (javaClass != other?.javaClass) return false + + other as LineState + + if (state != other.state) return false + if (hasBraces != other.hasBraces) return false + if (diagnostics != other.diagnostics) return false + + return true + } + + override fun hashCode(): Int { + var result = state + result = 31 * result + hasBraces.hashCode() + result = 31 * result + (diagnostics?.hashCode() ?: 0) + return result + } + + override fun toString(): String { + return "LineState(state=$state, hasBraces=$hasBraces, diagnostics=$diagnostics)" + } +} + +data class DiagnosticsState( + val continueDiagnostic: Boolean = false, + val diagnostic: DiagnosticItem? = null +) diff --git a/app/src/main/java/com/itsaky/androidide/language/java/JavaIncrementalAnalyzeManager.kt b/app/src/main/java/com/itsaky/androidide/language/java/JavaIncrementalAnalyzeManager.kt new file mode 100644 index 000000000..15fd80c72 --- /dev/null +++ b/app/src/main/java/com/itsaky/androidide/language/java/JavaIncrementalAnalyzeManager.kt @@ -0,0 +1,239 @@ +/* + * 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.java + +import com.itsaky.androidide.language.incremental.BaseIncrementalAnalyzeManager +import com.itsaky.androidide.language.incremental.IncrementalToken +import com.itsaky.androidide.language.incremental.LineState +import com.itsaky.androidide.lexers.java.JavaLexer +import com.itsaky.androidide.syntax.colorschemes.SchemeAndroidIDE.ANNOTATION +import com.itsaky.androidide.syntax.colorschemes.SchemeAndroidIDE.COMMENT +import com.itsaky.androidide.syntax.colorschemes.SchemeAndroidIDE.FIXME_COMMENT +import com.itsaky.androidide.syntax.colorschemes.SchemeAndroidIDE.LITERAL +import com.itsaky.androidide.syntax.colorschemes.SchemeAndroidIDE.OPERATOR +import com.itsaky.androidide.syntax.colorschemes.SchemeAndroidIDE.TEXT_NORMAL +import com.itsaky.androidide.syntax.colorschemes.SchemeAndroidIDE.TODO_COMMENT +import com.itsaky.androidide.syntax.colorschemes.SchemeAndroidIDE.TYPE_NAME +import com.itsaky.androidide.syntax.colorschemes.SchemeAndroidIDE.forComment +import com.itsaky.androidide.syntax.colorschemes.SchemeAndroidIDE.forKeyword +import com.itsaky.androidide.syntax.colorschemes.SchemeAndroidIDE.forString +import com.itsaky.androidide.syntax.colorschemes.SchemeAndroidIDE.withoutCompletion +import com.itsaky.androidide.utils.ILogger +import com.itsaky.lsp.models.DiagnosticItem +import com.itsaky.lsp.models.DiagnosticSeverity.WARNING +import com.itsaky.lsp.models.Position +import com.itsaky.lsp.models.Range +import io.github.rosemoe.sora.lang.styling.CodeBlock +import io.github.rosemoe.sora.lang.styling.MappedSpans +import io.github.rosemoe.sora.lang.styling.Span +import io.github.rosemoe.sora.lang.styling.TextStyle.makeStyle +import io.github.rosemoe.sora.text.Content +import org.antlr.v4.runtime.CharStreams + +/** @author Akash Yadav */ +class JavaIncrementalAnalyzeManager : + BaseIncrementalAnalyzeManager(JavaLexer(CharStreams.fromString(""))) { + + private val log = ILogger.newInstance(javaClass.simpleName) + + override fun computeBlocks(text: Content, delegate: CodeBlockAnalyzeDelegate): List { + return emptyList() + } + + override fun generateSpans( + tokens: AsyncLineTokenizeResult, + ): MappedSpans.Builder { + val line = tokens.line + val spans = MappedSpans.Builder(1) + var previous = JavaLexer.WS + var first = true + for (token in tokens.tokens) { + val type = token.type + val offset = token.startIndex + val tokenLength = token.text.length + when (type) { + JavaLexer.WS -> { + if (first) { + spans.addIfNeeded(line, offset, makeStyle(TEXT_NORMAL)) + first = false + } + } + JavaLexer.ABSTRACT, + JavaLexer.ASSERT, + JavaLexer.BREAK, + JavaLexer.CASE, + JavaLexer.CATCH, + JavaLexer.CLASS, + JavaLexer.CONST, + JavaLexer.CONTINUE, + JavaLexer.DEFAULT, + JavaLexer.DO, + JavaLexer.ELSE, + JavaLexer.EXTENDS, + JavaLexer.FINAL, + JavaLexer.FINALLY, + JavaLexer.FOR, + JavaLexer.IF, + JavaLexer.GOTO, + JavaLexer.IMPLEMENTS, + JavaLexer.IMPORT, + JavaLexer.INSTANCEOF, + JavaLexer.INTERFACE, + JavaLexer.NATIVE, + JavaLexer.NEW, + JavaLexer.PACKAGE, + JavaLexer.PRIVATE, + JavaLexer.PROTECTED, + JavaLexer.PUBLIC, + JavaLexer.RETURN, + JavaLexer.STATIC, + JavaLexer.STRICTFP, + JavaLexer.SUPER, + JavaLexer.SWITCH, + JavaLexer.SYNCHRONIZED, + JavaLexer.THIS, + JavaLexer.THROW, + JavaLexer.THROWS, + JavaLexer.TRANSIENT, + JavaLexer.TRY, + JavaLexer.VOID, + JavaLexer.VOLATILE, + JavaLexer.WHILE, + JavaLexer.VAR, -> spans.addIfNeeded(line, offset, forKeyword()) + JavaLexer.DECIMAL_LITERAL, + JavaLexer.HEX_LITERAL, + JavaLexer.OCT_LITERAL, + JavaLexer.BINARY_LITERAL, + JavaLexer.FLOAT_LITERAL, + JavaLexer.HEX_FLOAT_LITERAL, + JavaLexer.BOOL_LITERAL, + JavaLexer.CHAR_LITERAL, + JavaLexer.NULL_LITERAL, -> spans.addIfNeeded(line, offset, makeStyle(LITERAL)) + JavaLexer.STRING_LITERAL -> spans.addIfNeeded(line, offset, forString()) + JavaLexer.LPAREN, + JavaLexer.RPAREN, + JavaLexer.LBRACK, + JavaLexer.RBRACK, + JavaLexer.SEMI, + JavaLexer.COMMA, + JavaLexer.ASSIGN, + JavaLexer.GT, + JavaLexer.LT, + JavaLexer.BANG, + JavaLexer.TILDE, + JavaLexer.QUESTION, + JavaLexer.COLON, + JavaLexer.EQUAL, + JavaLexer.GE, + JavaLexer.LE, + JavaLexer.NOTEQUAL, + JavaLexer.AND, + JavaLexer.OR, + JavaLexer.INC, + JavaLexer.DEC, + JavaLexer.ADD, + JavaLexer.SUB, + JavaLexer.MUL, + JavaLexer.DIV, + JavaLexer.BITAND, + JavaLexer.BITOR, + JavaLexer.CARET, + JavaLexer.MOD, + JavaLexer.ADD_ASSIGN, + JavaLexer.SUB_ASSIGN, + JavaLexer.MUL_ASSIGN, + JavaLexer.DIV_ASSIGN, + JavaLexer.AND_ASSIGN, + JavaLexer.OR_ASSIGN, + JavaLexer.XOR_ASSIGN, + JavaLexer.MOD_ASSIGN, + JavaLexer.LSHIFT_ASSIGN, + JavaLexer.RSHIFT_ASSIGN, + JavaLexer.URSHIFT_ASSIGN, + JavaLexer.ARROW, + JavaLexer.COLONCOLON, + JavaLexer.ELLIPSIS, + JavaLexer.LBRACE, + JavaLexer.RBRACE, + JavaLexer.DOT, -> spans.addIfNeeded(line, offset, makeStyle(OPERATOR)) + JavaLexer.BOOLEAN, + JavaLexer.BYTE, + JavaLexer.CHAR, + JavaLexer.DOUBLE, + JavaLexer.ENUM, + JavaLexer.FLOAT, + JavaLexer.INT, + JavaLexer.LONG, + JavaLexer.SHORT, -> spans.addIfNeeded(line, offset, makeStyle(TYPE_NAME)) + JavaLexer.BLOCK_COMMENT -> spans.addIfNeeded(line, offset, forComment()) + JavaLexer.LINE_COMMENT -> { + var commentType = COMMENT + + // highlight special line comments + var commentText = token.text + if (commentText.length > 2) { + commentText = commentText.substring(2) + commentText = commentText.trim { it <= ' ' } + var mark = true + if ("todo".equals(commentText.substring(0, 4), ignoreCase = true)) { + commentType = TODO_COMMENT + } else if ("fixme".equals(commentText.substring(0, 5), ignoreCase = true)) { + commentType = FIXME_COMMENT + } else { + mark = false + } + if (mark) { + if (diagnostics == null) { + diagnostics = ArrayList() + } + val diagnostic = DiagnosticItem() + diagnostic.severity = WARNING + diagnostic.message = commentText + diagnostic.code = "special.comment" + diagnostic.range = Range(Position(0, offset), Position(0, offset + tokenLength)) + diagnostic.source = commentText + ideDiagnostics.add(diagnostic) + } + } + spans.addIfNeeded(line, offset, withoutCompletion(commentType)) + } + JavaLexer.AT -> spans.addIfNeeded(line, offset, makeStyle(ANNOTATION)) + JavaLexer.IDENTIFIER -> { + var colorId = TEXT_NORMAL + if (previous == JavaLexer.AT) { + colorId = ANNOTATION + } + spans.addIfNeeded(line, offset, makeStyle(colorId)) + } + else -> spans.addIfNeeded(line, offset, makeStyle(TEXT_NORMAL)) + } + previous = type + } + + return spans; + } + + override fun getMultilineTokenStartEndTypes(): Array { + val start = intArrayOf(JavaLexer.DIV, JavaLexer.MUL) + val end = intArrayOf(JavaLexer.MUL, JavaLexer.DIV) + return arrayOf(start, end) + } + + override fun handleIncompleteToken(token: IncrementalToken) { + token.type = JavaLexer.BLOCK_COMMENT + } +} diff --git a/app/src/main/java/com/itsaky/androidide/language/java/JavaLanguage.java b/app/src/main/java/com/itsaky/androidide/language/java/JavaLanguage.java index 3d7c22946..80cf11342 100755 --- a/app/src/main/java/com/itsaky/androidide/language/java/JavaLanguage.java +++ b/app/src/main/java/com/itsaky/androidide/language/java/JavaLanguage.java @@ -54,12 +54,12 @@ public class JavaLanguage extends IDELanguage { private static final ILogger LOG = ILogger.newInstance("JavaLanguage"); private final NewlineHandler[] newlineHandlers; - private JavaAnalyzer analyzer; + private JavaIncrementalAnalyzeManager analyzer; private CommonCompletionProvider completer; public JavaLanguage() { final var server = getLanguageServer(); - this.analyzer = new JavaAnalyzer(); + this.analyzer = new JavaIncrementalAnalyzeManager(); this.completer = new CommonCompletionProvider(server); this.newlineHandlers = new NewlineHandler[1]; diff --git a/app/src/test/java/com/itsaky/androidide/language/incremental/BaseIncrementalAnalyzeManagerTest.kt b/app/src/test/java/com/itsaky/androidide/language/incremental/BaseIncrementalAnalyzeManagerTest.kt new file mode 100644 index 000000000..7653dc0c8 --- /dev/null +++ b/app/src/test/java/com/itsaky/androidide/language/incremental/BaseIncrementalAnalyzeManagerTest.kt @@ -0,0 +1,137 @@ +/* + * 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.incremental + +import com.google.common.truth.Truth.assertThat +import com.itsaky.androidide.language.java.JavaIncrementalAnalyzeManager +import com.itsaky.androidide.lexers.java.JavaLexer +import io.github.rosemoe.sora.lang.analysis.IncrementalAnalyzeManager.LineTokenizeResult +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +@Config(manifest = Config.NONE) +internal class BaseIncrementalAnalyzeManagerTest { + + @Test + fun testSimpleTokenization() { + val analyzer = JavaIncrementalAnalyzeManager() + val result = + analyzer.tokenizeLine( + "public static final String THIS_IS_A_STRING = \"This is a string...!\";", + analyzer.initialState + ) + println("New state: ${result.state}") + ensureTokenSequence( + result, + listOf( + JavaLexer.PUBLIC, + JavaLexer.WS, + JavaLexer.STATIC, + JavaLexer.WS, + JavaLexer.FINAL, + JavaLexer.WS, + JavaLexer.IDENTIFIER, + JavaLexer.WS, + JavaLexer.IDENTIFIER, + JavaLexer.WS, + JavaLexer.ASSIGN, + JavaLexer.WS, + JavaLexer.STRING_LITERAL, + JavaLexer.SEMI + ) + ) + } + + @Test + fun testCompleteCommentTokenization() { + val analyzer = JavaIncrementalAnalyzeManager() + val result = + analyzer.tokenizeLine("/*This is a */complete multiline comment", analyzer.initialState) + assertThat(result.state.state).isEqualTo(LineState.NORMAL) + ensureTokenSequence( + result, + listOf( + JavaLexer.BLOCK_COMMENT, + JavaLexer.IDENTIFIER, + JavaLexer.WS, + JavaLexer.IDENTIFIER, + JavaLexer.WS, + JavaLexer.IDENTIFIER + ) + ) + } + + @Test + fun testIncompleteCommentTokenization() { + val analyzer = JavaIncrementalAnalyzeManager() + var result = + analyzer.tokenizeLine("/*This is an incomplete multiline comment", analyzer.initialState) + println(result.state) + assertThat(result.state.state).isEqualTo(LineState.INCOMPLETE) + + result = + analyzer.tokenizeLine("/*This is an incomplete*//* multiline comment", analyzer.initialState) + println(result.state) + assertThat(result.state.state).isEqualTo(LineState.INCOMPLETE) + + result = + analyzer.tokenizeLine("This is an incomplete multiline comment/*", analyzer.initialState) + println(result.state) + assertThat(result.state.state).isEqualTo(LineState.INCOMPLETE) + } + + @Test + fun testMultilineCommentTokenization() { + val analyzer = JavaIncrementalAnalyzeManager() + + // Test a simple multiline comment + run { + var result = analyzer.tokenizeLine("/** This is an", analyzer.initialState) + assertThat(result.state.state).isEqualTo(LineState.INCOMPLETE) + + result = analyzer.tokenizeLine(" incomplete comment*/", result.state) + assertThat(result.state.state).isEqualTo(LineState.NORMAL) + } + + // Test a multiline comment which is directly followed by tokens of other types. + run { + var result = analyzer.tokenizeLine("/** This is an", analyzer.initialState) + assertThat(result.state.state).isEqualTo(LineState.INCOMPLETE) + assertThat(result.tokens.last()).isNotNull() + assertThat(result.tokens.last().type).isEqualTo(JavaLexer.IDENTIFIER) + + result = analyzer.tokenizeLine(" incomplete comment*/ public static void", result.state) + assertThat(result.state.state).isEqualTo(LineState.NORMAL) + assertThat(result.tokens.last().type).isEqualTo(JavaLexer.VOID) + assertThat(result.tokens[result.tokens.lastIndex - 1].type).isEqualTo(JavaLexer.WS) + assertThat(result.tokens[result.tokens.lastIndex - 2].type).isEqualTo(JavaLexer.STATIC) + } + } + + private fun ensureTokenSequence( + result: LineTokenizeResult, + types: List + ) { + for (index in types.indices) { + assertThat(result.tokens[index].type).isEqualTo(types[index]) + } + } +} diff --git a/gradle/dependencies.gradle b/gradle/dependencies.gradle index 54a8af558..c326bdda0 100755 --- a/gradle/dependencies.gradle +++ b/gradle/dependencies.gradle @@ -12,7 +12,7 @@ ext { bll: 'com.github.Rosemoe:BlockLinkedList:1.0.0', xml2json: 'com.github.smart-fun:XmlToJson:1.5.1', jsoup: 'org.jsoup:jsoup:1.14.2', - antlr4: 'org.antlr:antlr4-runtime:4.9.2', + antlr4: 'org.antlr:antlr4-runtime:4.9.3', javaparser: 'com.github.javaparser:javaparser-symbol-solver-core:3.24.2', jsonrpc: 'org.eclipse.lsp4j:org.eclipse.lsp4j.jsonrpc:0.12.0', lang3:'org.apache.commons:commons-lang3:3.12.0', diff --git a/lexers/src/main/gen/com/itsaky/androidide/lexers/java/JavaLexer.interp b/lexers/src/main/gen/com/itsaky/androidide/lexers/java/JavaLexer.interp new file mode 100644 index 000000000..8b34be36c --- /dev/null +++ b/lexers/src/main/gen/com/itsaky/androidide/lexers/java/JavaLexer.interp @@ -0,0 +1,360 @@ +token literal names: +null +'abstract' +'assert' +'boolean' +'break' +'byte' +'case' +'catch' +'char' +'class' +'const' +'continue' +'default' +'do' +'double' +'else' +'enum' +'extends' +'final' +'finally' +'float' +'for' +'if' +'goto' +'implements' +'import' +'instanceof' +'int' +'interface' +'long' +'native' +'new' +'package' +'private' +'protected' +'public' +'return' +'short' +'static' +'strictfp' +'super' +'switch' +'synchronized' +'this' +'throw' +'throws' +'transient' +'try' +'var' +'void' +'volatile' +'while' +null +null +null +null +null +null +null +null +null +'null' +'(' +')' +'{' +'}' +'[' +']' +';' +',' +'.' +'=' +'>' +'<' +'!' +'~' +'?' +':' +'==' +'<=' +'>=' +'!=' +'&&' +'||' +'++' +'--' +'+' +'-' +'*' +'/' +'&' +'|' +'^' +'%' +'+=' +'-=' +'*=' +'/=' +'&=' +'|=' +'^=' +'%=' +'<<=' +'>>=' +'>>>=' +'->' +'::' +'@' +'...' +null +null +null +null + +token symbolic names: +null +ABSTRACT +ASSERT +BOOLEAN +BREAK +BYTE +CASE +CATCH +CHAR +CLASS +CONST +CONTINUE +DEFAULT +DO +DOUBLE +ELSE +ENUM +EXTENDS +FINAL +FINALLY +FLOAT +FOR +IF +GOTO +IMPLEMENTS +IMPORT +INSTANCEOF +INT +INTERFACE +LONG +NATIVE +NEW +PACKAGE +PRIVATE +PROTECTED +PUBLIC +RETURN +SHORT +STATIC +STRICTFP +SUPER +SWITCH +SYNCHRONIZED +THIS +THROW +THROWS +TRANSIENT +TRY +VAR +VOID +VOLATILE +WHILE +DECIMAL_LITERAL +HEX_LITERAL +OCT_LITERAL +BINARY_LITERAL +FLOAT_LITERAL +HEX_FLOAT_LITERAL +BOOL_LITERAL +CHAR_LITERAL +STRING_LITERAL +NULL_LITERAL +LPAREN +RPAREN +LBRACE +RBRACE +LBRACK +RBRACK +SEMI +COMMA +DOT +ASSIGN +GT +LT +BANG +TILDE +QUESTION +COLON +EQUAL +LE +GE +NOTEQUAL +AND +OR +INC +DEC +ADD +SUB +MUL +DIV +BITAND +BITOR +CARET +MOD +ADD_ASSIGN +SUB_ASSIGN +MUL_ASSIGN +DIV_ASSIGN +AND_ASSIGN +OR_ASSIGN +XOR_ASSIGN +MOD_ASSIGN +LSHIFT_ASSIGN +RSHIFT_ASSIGN +URSHIFT_ASSIGN +ARROW +COLONCOLON +AT +ELLIPSIS +WS +BLOCK_COMMENT +LINE_COMMENT +IDENTIFIER + +rule names: +ABSTRACT +ASSERT +BOOLEAN +BREAK +BYTE +CASE +CATCH +CHAR +CLASS +CONST +CONTINUE +DEFAULT +DO +DOUBLE +ELSE +ENUM +EXTENDS +FINAL +FINALLY +FLOAT +FOR +IF +GOTO +IMPLEMENTS +IMPORT +INSTANCEOF +INT +INTERFACE +LONG +NATIVE +NEW +PACKAGE +PRIVATE +PROTECTED +PUBLIC +RETURN +SHORT +STATIC +STRICTFP +SUPER +SWITCH +SYNCHRONIZED +THIS +THROW +THROWS +TRANSIENT +TRY +VAR +VOID +VOLATILE +WHILE +DECIMAL_LITERAL +HEX_LITERAL +OCT_LITERAL +BINARY_LITERAL +FLOAT_LITERAL +HEX_FLOAT_LITERAL +BOOL_LITERAL +CHAR_LITERAL +STRING_LITERAL +NULL_LITERAL +LPAREN +RPAREN +LBRACE +RBRACE +LBRACK +RBRACK +SEMI +COMMA +DOT +ASSIGN +GT +LT +BANG +TILDE +QUESTION +COLON +EQUAL +LE +GE +NOTEQUAL +AND +OR +INC +DEC +ADD +SUB +MUL +DIV +BITAND +BITOR +CARET +MOD +ADD_ASSIGN +SUB_ASSIGN +MUL_ASSIGN +DIV_ASSIGN +AND_ASSIGN +OR_ASSIGN +XOR_ASSIGN +MOD_ASSIGN +LSHIFT_ASSIGN +RSHIFT_ASSIGN +URSHIFT_ASSIGN +ARROW +COLONCOLON +AT +ELLIPSIS +WS +BLOCK_COMMENT +LINE_COMMENT +IDENTIFIER +ExponentPart +EscapeSequence +HexDigits +HexDigit +Digits +LetterOrDigit +Letter + +channel names: +DEFAULT_TOKEN_CHANNEL +HIDDEN + +mode names: +DEFAULT_MODE + +atn: +[4, 0, 112, 951, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117, 7, 117, 2, 118, 7, 118, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 7, 1, 7, 1, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 9, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 10, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 1, 14, 1, 14, 1, 14, 1, 14, 1, 14, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 1, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, 3, 51, 586, 8, 51, 1, 51, 4, 51, 589, 8, 51, 11, 51, 12, 51, 590, 1, 51, 3, 51, 594, 8, 51, 3, 51, 596, 8, 51, 1, 51, 3, 51, 599, 8, 51, 1, 52, 1, 52, 1, 52, 1, 52, 5, 52, 605, 8, 52, 10, 52, 12, 52, 608, 9, 52, 1, 52, 3, 52, 611, 8, 52, 1, 52, 3, 52, 614, 8, 52, 1, 53, 1, 53, 5, 53, 618, 8, 53, 10, 53, 12, 53, 621, 9, 53, 1, 53, 1, 53, 5, 53, 625, 8, 53, 10, 53, 12, 53, 628, 9, 53, 1, 53, 3, 53, 631, 8, 53, 1, 53, 3, 53, 634, 8, 53, 1, 54, 1, 54, 1, 54, 1, 54, 5, 54, 640, 8, 54, 10, 54, 12, 54, 643, 9, 54, 1, 54, 3, 54, 646, 8, 54, 1, 54, 3, 54, 649, 8, 54, 1, 55, 1, 55, 1, 55, 3, 55, 654, 8, 55, 1, 55, 1, 55, 3, 55, 658, 8, 55, 1, 55, 3, 55, 661, 8, 55, 1, 55, 3, 55, 664, 8, 55, 1, 55, 1, 55, 1, 55, 3, 55, 669, 8, 55, 1, 55, 3, 55, 672, 8, 55, 3, 55, 674, 8, 55, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 680, 8, 56, 1, 56, 3, 56, 683, 8, 56, 1, 56, 1, 56, 3, 56, 687, 8, 56, 1, 56, 1, 56, 3, 56, 691, 8, 56, 1, 56, 1, 56, 3, 56, 695, 8, 56, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 3, 57, 706, 8, 57, 1, 58, 1, 58, 1, 58, 3, 58, 711, 8, 58, 1, 58, 1, 58, 1, 59, 1, 59, 1, 59, 5, 59, 718, 8, 59, 10, 59, 12, 59, 721, 9, 59, 1, 59, 1, 59, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 61, 1, 61, 1, 62, 1, 62, 1, 63, 1, 63, 1, 64, 1, 64, 1, 65, 1, 65, 1, 66, 1, 66, 1, 67, 1, 67, 1, 68, 1, 68, 1, 69, 1, 69, 1, 70, 1, 70, 1, 71, 1, 71, 1, 72, 1, 72, 1, 73, 1, 73, 1, 74, 1, 74, 1, 75, 1, 75, 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, 1, 78, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 83, 1, 83, 1, 83, 1, 84, 1, 84, 1, 84, 1, 85, 1, 85, 1, 86, 1, 86, 1, 87, 1, 87, 1, 88, 1, 88, 1, 89, 1, 89, 1, 90, 1, 90, 1, 91, 1, 91, 1, 92, 1, 92, 1, 93, 1, 93, 1, 93, 1, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 99, 1, 99, 1, 99, 1, 100, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 102, 1, 102, 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1, 103, 1, 104, 1, 104, 1, 104, 1, 105, 1, 105, 1, 105, 1, 106, 1, 106, 1, 107, 1, 107, 1, 107, 1, 107, 1, 108, 4, 108, 852, 8, 108, 11, 108, 12, 108, 853, 1, 108, 1, 108, 1, 109, 1, 109, 1, 109, 1, 109, 5, 109, 862, 8, 109, 10, 109, 12, 109, 865, 9, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 109, 1, 110, 1, 110, 1, 110, 1, 110, 5, 110, 876, 8, 110, 10, 110, 12, 110, 879, 9, 110, 1, 110, 1, 110, 1, 111, 1, 111, 5, 111, 885, 8, 111, 10, 111, 12, 111, 888, 9, 111, 1, 112, 1, 112, 3, 112, 892, 8, 112, 1, 112, 1, 112, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 900, 8, 113, 1, 113, 3, 113, 903, 8, 113, 1, 113, 1, 113, 1, 113, 4, 113, 908, 8, 113, 11, 113, 12, 113, 909, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 3, 113, 917, 8, 113, 1, 114, 1, 114, 1, 114, 5, 114, 922, 8, 114, 10, 114, 12, 114, 925, 9, 114, 1, 114, 3, 114, 928, 8, 114, 1, 115, 1, 115, 1, 116, 1, 116, 5, 116, 934, 8, 116, 10, 116, 12, 116, 937, 9, 116, 1, 116, 3, 116, 940, 8, 116, 1, 117, 1, 117, 3, 117, 944, 8, 117, 1, 118, 1, 118, 1, 118, 1, 118, 3, 118, 950, 8, 118, 1, 863, 0, 119, 1, 1, 3, 2, 5, 3, 7, 4, 9, 5, 11, 6, 13, 7, 15, 8, 17, 9, 19, 10, 21, 11, 23, 12, 25, 13, 27, 14, 29, 15, 31, 16, 33, 17, 35, 18, 37, 19, 39, 20, 41, 21, 43, 22, 45, 23, 47, 24, 49, 25, 51, 26, 53, 27, 55, 28, 57, 29, 59, 30, 61, 31, 63, 32, 65, 33, 67, 34, 69, 35, 71, 36, 73, 37, 75, 38, 77, 39, 79, 40, 81, 41, 83, 42, 85, 43, 87, 44, 89, 45, 91, 46, 93, 47, 95, 48, 97, 49, 99, 50, 101, 51, 103, 52, 105, 53, 107, 54, 109, 55, 111, 56, 113, 57, 115, 58, 117, 59, 119, 60, 121, 61, 123, 62, 125, 63, 127, 64, 129, 65, 131, 66, 133, 67, 135, 68, 137, 69, 139, 70, 141, 71, 143, 72, 145, 73, 147, 74, 149, 75, 151, 76, 153, 77, 155, 78, 157, 79, 159, 80, 161, 81, 163, 82, 165, 83, 167, 84, 169, 85, 171, 86, 173, 87, 175, 88, 177, 89, 179, 90, 181, 91, 183, 92, 185, 93, 187, 94, 189, 95, 191, 96, 193, 97, 195, 98, 197, 99, 199, 100, 201, 101, 203, 102, 205, 103, 207, 104, 209, 105, 211, 106, 213, 107, 215, 108, 217, 109, 219, 110, 221, 111, 223, 112, 225, 0, 227, 0, 229, 0, 231, 0, 233, 0, 235, 0, 237, 0, 1, 0, 26, 1, 0, 49, 57, 2, 0, 76, 76, 108, 108, 2, 0, 88, 88, 120, 120, 3, 0, 48, 57, 65, 70, 97, 102, 4, 0, 48, 57, 65, 70, 95, 95, 97, 102, 1, 0, 48, 55, 2, 0, 48, 55, 95, 95, 2, 0, 66, 66, 98, 98, 1, 0, 48, 49, 2, 0, 48, 49, 95, 95, 4, 0, 68, 68, 70, 70, 100, 100, 102, 102, 2, 0, 80, 80, 112, 112, 2, 0, 43, 43, 45, 45, 4, 0, 10, 10, 13, 13, 39, 39, 92, 92, 4, 0, 10, 10, 13, 13, 34, 34, 92, 92, 3, 0, 9, 10, 12, 13, 32, 32, 2, 0, 10, 10, 13, 13, 2, 0, 69, 69, 101, 101, 8, 0, 34, 34, 39, 39, 92, 92, 98, 98, 102, 102, 110, 110, 114, 114, 116, 116, 1, 0, 48, 51, 1, 0, 48, 57, 2, 0, 48, 57, 95, 95, 4, 0, 36, 36, 65, 90, 95, 95, 97, 122, 2, 0, 0, 127, 55296, 56319, 1, 0, 55296, 56319, 1, 0, 56320, 57343, 992, 0, 1, 1, 0, 0, 0, 0, 3, 1, 0, 0, 0, 0, 5, 1, 0, 0, 0, 0, 7, 1, 0, 0, 0, 0, 9, 1, 0, 0, 0, 0, 11, 1, 0, 0, 0, 0, 13, 1, 0, 0, 0, 0, 15, 1, 0, 0, 0, 0, 17, 1, 0, 0, 0, 0, 19, 1, 0, 0, 0, 0, 21, 1, 0, 0, 0, 0, 23, 1, 0, 0, 0, 0, 25, 1, 0, 0, 0, 0, 27, 1, 0, 0, 0, 0, 29, 1, 0, 0, 0, 0, 31, 1, 0, 0, 0, 0, 33, 1, 0, 0, 0, 0, 35, 1, 0, 0, 0, 0, 37, 1, 0, 0, 0, 0, 39, 1, 0, 0, 0, 0, 41, 1, 0, 0, 0, 0, 43, 1, 0, 0, 0, 0, 45, 1, 0, 0, 0, 0, 47, 1, 0, 0, 0, 0, 49, 1, 0, 0, 0, 0, 51, 1, 0, 0, 0, 0, 53, 1, 0, 0, 0, 0, 55, 1, 0, 0, 0, 0, 57, 1, 0, 0, 0, 0, 59, 1, 0, 0, 0, 0, 61, 1, 0, 0, 0, 0, 63, 1, 0, 0, 0, 0, 65, 1, 0, 0, 0, 0, 67, 1, 0, 0, 0, 0, 69, 1, 0, 0, 0, 0, 71, 1, 0, 0, 0, 0, 73, 1, 0, 0, 0, 0, 75, 1, 0, 0, 0, 0, 77, 1, 0, 0, 0, 0, 79, 1, 0, 0, 0, 0, 81, 1, 0, 0, 0, 0, 83, 1, 0, 0, 0, 0, 85, 1, 0, 0, 0, 0, 87, 1, 0, 0, 0, 0, 89, 1, 0, 0, 0, 0, 91, 1, 0, 0, 0, 0, 93, 1, 0, 0, 0, 0, 95, 1, 0, 0, 0, 0, 97, 1, 0, 0, 0, 0, 99, 1, 0, 0, 0, 0, 101, 1, 0, 0, 0, 0, 103, 1, 0, 0, 0, 0, 105, 1, 0, 0, 0, 0, 107, 1, 0, 0, 0, 0, 109, 1, 0, 0, 0, 0, 111, 1, 0, 0, 0, 0, 113, 1, 0, 0, 0, 0, 115, 1, 0, 0, 0, 0, 117, 1, 0, 0, 0, 0, 119, 1, 0, 0, 0, 0, 121, 1, 0, 0, 0, 0, 123, 1, 0, 0, 0, 0, 125, 1, 0, 0, 0, 0, 127, 1, 0, 0, 0, 0, 129, 1, 0, 0, 0, 0, 131, 1, 0, 0, 0, 0, 133, 1, 0, 0, 0, 0, 135, 1, 0, 0, 0, 0, 137, 1, 0, 0, 0, 0, 139, 1, 0, 0, 0, 0, 141, 1, 0, 0, 0, 0, 143, 1, 0, 0, 0, 0, 145, 1, 0, 0, 0, 0, 147, 1, 0, 0, 0, 0, 149, 1, 0, 0, 0, 0, 151, 1, 0, 0, 0, 0, 153, 1, 0, 0, 0, 0, 155, 1, 0, 0, 0, 0, 157, 1, 0, 0, 0, 0, 159, 1, 0, 0, 0, 0, 161, 1, 0, 0, 0, 0, 163, 1, 0, 0, 0, 0, 165, 1, 0, 0, 0, 0, 167, 1, 0, 0, 0, 0, 169, 1, 0, 0, 0, 0, 171, 1, 0, 0, 0, 0, 173, 1, 0, 0, 0, 0, 175, 1, 0, 0, 0, 0, 177, 1, 0, 0, 0, 0, 179, 1, 0, 0, 0, 0, 181, 1, 0, 0, 0, 0, 183, 1, 0, 0, 0, 0, 185, 1, 0, 0, 0, 0, 187, 1, 0, 0, 0, 0, 189, 1, 0, 0, 0, 0, 191, 1, 0, 0, 0, 0, 193, 1, 0, 0, 0, 0, 195, 1, 0, 0, 0, 0, 197, 1, 0, 0, 0, 0, 199, 1, 0, 0, 0, 0, 201, 1, 0, 0, 0, 0, 203, 1, 0, 0, 0, 0, 205, 1, 0, 0, 0, 0, 207, 1, 0, 0, 0, 0, 209, 1, 0, 0, 0, 0, 211, 1, 0, 0, 0, 0, 213, 1, 0, 0, 0, 0, 215, 1, 0, 0, 0, 0, 217, 1, 0, 0, 0, 0, 219, 1, 0, 0, 0, 0, 221, 1, 0, 0, 0, 0, 223, 1, 0, 0, 0, 1, 239, 1, 0, 0, 0, 3, 248, 1, 0, 0, 0, 5, 255, 1, 0, 0, 0, 7, 263, 1, 0, 0, 0, 9, 269, 1, 0, 0, 0, 11, 274, 1, 0, 0, 0, 13, 279, 1, 0, 0, 0, 15, 285, 1, 0, 0, 0, 17, 290, 1, 0, 0, 0, 19, 296, 1, 0, 0, 0, 21, 302, 1, 0, 0, 0, 23, 311, 1, 0, 0, 0, 25, 319, 1, 0, 0, 0, 27, 322, 1, 0, 0, 0, 29, 329, 1, 0, 0, 0, 31, 334, 1, 0, 0, 0, 33, 339, 1, 0, 0, 0, 35, 347, 1, 0, 0, 0, 37, 353, 1, 0, 0, 0, 39, 361, 1, 0, 0, 0, 41, 367, 1, 0, 0, 0, 43, 371, 1, 0, 0, 0, 45, 374, 1, 0, 0, 0, 47, 379, 1, 0, 0, 0, 49, 390, 1, 0, 0, 0, 51, 397, 1, 0, 0, 0, 53, 408, 1, 0, 0, 0, 55, 412, 1, 0, 0, 0, 57, 422, 1, 0, 0, 0, 59, 427, 1, 0, 0, 0, 61, 434, 1, 0, 0, 0, 63, 438, 1, 0, 0, 0, 65, 446, 1, 0, 0, 0, 67, 454, 1, 0, 0, 0, 69, 464, 1, 0, 0, 0, 71, 471, 1, 0, 0, 0, 73, 478, 1, 0, 0, 0, 75, 484, 1, 0, 0, 0, 77, 491, 1, 0, 0, 0, 79, 500, 1, 0, 0, 0, 81, 506, 1, 0, 0, 0, 83, 513, 1, 0, 0, 0, 85, 526, 1, 0, 0, 0, 87, 531, 1, 0, 0, 0, 89, 537, 1, 0, 0, 0, 91, 544, 1, 0, 0, 0, 93, 554, 1, 0, 0, 0, 95, 558, 1, 0, 0, 0, 97, 562, 1, 0, 0, 0, 99, 567, 1, 0, 0, 0, 101, 576, 1, 0, 0, 0, 103, 595, 1, 0, 0, 0, 105, 600, 1, 0, 0, 0, 107, 615, 1, 0, 0, 0, 109, 635, 1, 0, 0, 0, 111, 673, 1, 0, 0, 0, 113, 675, 1, 0, 0, 0, 115, 705, 1, 0, 0, 0, 117, 707, 1, 0, 0, 0, 119, 714, 1, 0, 0, 0, 121, 724, 1, 0, 0, 0, 123, 729, 1, 0, 0, 0, 125, 731, 1, 0, 0, 0, 127, 733, 1, 0, 0, 0, 129, 735, 1, 0, 0, 0, 131, 737, 1, 0, 0, 0, 133, 739, 1, 0, 0, 0, 135, 741, 1, 0, 0, 0, 137, 743, 1, 0, 0, 0, 139, 745, 1, 0, 0, 0, 141, 747, 1, 0, 0, 0, 143, 749, 1, 0, 0, 0, 145, 751, 1, 0, 0, 0, 147, 753, 1, 0, 0, 0, 149, 755, 1, 0, 0, 0, 151, 757, 1, 0, 0, 0, 153, 759, 1, 0, 0, 0, 155, 761, 1, 0, 0, 0, 157, 764, 1, 0, 0, 0, 159, 767, 1, 0, 0, 0, 161, 770, 1, 0, 0, 0, 163, 773, 1, 0, 0, 0, 165, 776, 1, 0, 0, 0, 167, 779, 1, 0, 0, 0, 169, 782, 1, 0, 0, 0, 171, 785, 1, 0, 0, 0, 173, 787, 1, 0, 0, 0, 175, 789, 1, 0, 0, 0, 177, 791, 1, 0, 0, 0, 179, 793, 1, 0, 0, 0, 181, 795, 1, 0, 0, 0, 183, 797, 1, 0, 0, 0, 185, 799, 1, 0, 0, 0, 187, 801, 1, 0, 0, 0, 189, 804, 1, 0, 0, 0, 191, 807, 1, 0, 0, 0, 193, 810, 1, 0, 0, 0, 195, 813, 1, 0, 0, 0, 197, 816, 1, 0, 0, 0, 199, 819, 1, 0, 0, 0, 201, 822, 1, 0, 0, 0, 203, 825, 1, 0, 0, 0, 205, 829, 1, 0, 0, 0, 207, 833, 1, 0, 0, 0, 209, 838, 1, 0, 0, 0, 211, 841, 1, 0, 0, 0, 213, 844, 1, 0, 0, 0, 215, 846, 1, 0, 0, 0, 217, 851, 1, 0, 0, 0, 219, 857, 1, 0, 0, 0, 221, 871, 1, 0, 0, 0, 223, 882, 1, 0, 0, 0, 225, 889, 1, 0, 0, 0, 227, 916, 1, 0, 0, 0, 229, 918, 1, 0, 0, 0, 231, 929, 1, 0, 0, 0, 233, 931, 1, 0, 0, 0, 235, 943, 1, 0, 0, 0, 237, 949, 1, 0, 0, 0, 239, 240, 5, 97, 0, 0, 240, 241, 5, 98, 0, 0, 241, 242, 5, 115, 0, 0, 242, 243, 5, 116, 0, 0, 243, 244, 5, 114, 0, 0, 244, 245, 5, 97, 0, 0, 245, 246, 5, 99, 0, 0, 246, 247, 5, 116, 0, 0, 247, 2, 1, 0, 0, 0, 248, 249, 5, 97, 0, 0, 249, 250, 5, 115, 0, 0, 250, 251, 5, 115, 0, 0, 251, 252, 5, 101, 0, 0, 252, 253, 5, 114, 0, 0, 253, 254, 5, 116, 0, 0, 254, 4, 1, 0, 0, 0, 255, 256, 5, 98, 0, 0, 256, 257, 5, 111, 0, 0, 257, 258, 5, 111, 0, 0, 258, 259, 5, 108, 0, 0, 259, 260, 5, 101, 0, 0, 260, 261, 5, 97, 0, 0, 261, 262, 5, 110, 0, 0, 262, 6, 1, 0, 0, 0, 263, 264, 5, 98, 0, 0, 264, 265, 5, 114, 0, 0, 265, 266, 5, 101, 0, 0, 266, 267, 5, 97, 0, 0, 267, 268, 5, 107, 0, 0, 268, 8, 1, 0, 0, 0, 269, 270, 5, 98, 0, 0, 270, 271, 5, 121, 0, 0, 271, 272, 5, 116, 0, 0, 272, 273, 5, 101, 0, 0, 273, 10, 1, 0, 0, 0, 274, 275, 5, 99, 0, 0, 275, 276, 5, 97, 0, 0, 276, 277, 5, 115, 0, 0, 277, 278, 5, 101, 0, 0, 278, 12, 1, 0, 0, 0, 279, 280, 5, 99, 0, 0, 280, 281, 5, 97, 0, 0, 281, 282, 5, 116, 0, 0, 282, 283, 5, 99, 0, 0, 283, 284, 5, 104, 0, 0, 284, 14, 1, 0, 0, 0, 285, 286, 5, 99, 0, 0, 286, 287, 5, 104, 0, 0, 287, 288, 5, 97, 0, 0, 288, 289, 5, 114, 0, 0, 289, 16, 1, 0, 0, 0, 290, 291, 5, 99, 0, 0, 291, 292, 5, 108, 0, 0, 292, 293, 5, 97, 0, 0, 293, 294, 5, 115, 0, 0, 294, 295, 5, 115, 0, 0, 295, 18, 1, 0, 0, 0, 296, 297, 5, 99, 0, 0, 297, 298, 5, 111, 0, 0, 298, 299, 5, 110, 0, 0, 299, 300, 5, 115, 0, 0, 300, 301, 5, 116, 0, 0, 301, 20, 1, 0, 0, 0, 302, 303, 5, 99, 0, 0, 303, 304, 5, 111, 0, 0, 304, 305, 5, 110, 0, 0, 305, 306, 5, 116, 0, 0, 306, 307, 5, 105, 0, 0, 307, 308, 5, 110, 0, 0, 308, 309, 5, 117, 0, 0, 309, 310, 5, 101, 0, 0, 310, 22, 1, 0, 0, 0, 311, 312, 5, 100, 0, 0, 312, 313, 5, 101, 0, 0, 313, 314, 5, 102, 0, 0, 314, 315, 5, 97, 0, 0, 315, 316, 5, 117, 0, 0, 316, 317, 5, 108, 0, 0, 317, 318, 5, 116, 0, 0, 318, 24, 1, 0, 0, 0, 319, 320, 5, 100, 0, 0, 320, 321, 5, 111, 0, 0, 321, 26, 1, 0, 0, 0, 322, 323, 5, 100, 0, 0, 323, 324, 5, 111, 0, 0, 324, 325, 5, 117, 0, 0, 325, 326, 5, 98, 0, 0, 326, 327, 5, 108, 0, 0, 327, 328, 5, 101, 0, 0, 328, 28, 1, 0, 0, 0, 329, 330, 5, 101, 0, 0, 330, 331, 5, 108, 0, 0, 331, 332, 5, 115, 0, 0, 332, 333, 5, 101, 0, 0, 333, 30, 1, 0, 0, 0, 334, 335, 5, 101, 0, 0, 335, 336, 5, 110, 0, 0, 336, 337, 5, 117, 0, 0, 337, 338, 5, 109, 0, 0, 338, 32, 1, 0, 0, 0, 339, 340, 5, 101, 0, 0, 340, 341, 5, 120, 0, 0, 341, 342, 5, 116, 0, 0, 342, 343, 5, 101, 0, 0, 343, 344, 5, 110, 0, 0, 344, 345, 5, 100, 0, 0, 345, 346, 5, 115, 0, 0, 346, 34, 1, 0, 0, 0, 347, 348, 5, 102, 0, 0, 348, 349, 5, 105, 0, 0, 349, 350, 5, 110, 0, 0, 350, 351, 5, 97, 0, 0, 351, 352, 5, 108, 0, 0, 352, 36, 1, 0, 0, 0, 353, 354, 5, 102, 0, 0, 354, 355, 5, 105, 0, 0, 355, 356, 5, 110, 0, 0, 356, 357, 5, 97, 0, 0, 357, 358, 5, 108, 0, 0, 358, 359, 5, 108, 0, 0, 359, 360, 5, 121, 0, 0, 360, 38, 1, 0, 0, 0, 361, 362, 5, 102, 0, 0, 362, 363, 5, 108, 0, 0, 363, 364, 5, 111, 0, 0, 364, 365, 5, 97, 0, 0, 365, 366, 5, 116, 0, 0, 366, 40, 1, 0, 0, 0, 367, 368, 5, 102, 0, 0, 368, 369, 5, 111, 0, 0, 369, 370, 5, 114, 0, 0, 370, 42, 1, 0, 0, 0, 371, 372, 5, 105, 0, 0, 372, 373, 5, 102, 0, 0, 373, 44, 1, 0, 0, 0, 374, 375, 5, 103, 0, 0, 375, 376, 5, 111, 0, 0, 376, 377, 5, 116, 0, 0, 377, 378, 5, 111, 0, 0, 378, 46, 1, 0, 0, 0, 379, 380, 5, 105, 0, 0, 380, 381, 5, 109, 0, 0, 381, 382, 5, 112, 0, 0, 382, 383, 5, 108, 0, 0, 383, 384, 5, 101, 0, 0, 384, 385, 5, 109, 0, 0, 385, 386, 5, 101, 0, 0, 386, 387, 5, 110, 0, 0, 387, 388, 5, 116, 0, 0, 388, 389, 5, 115, 0, 0, 389, 48, 1, 0, 0, 0, 390, 391, 5, 105, 0, 0, 391, 392, 5, 109, 0, 0, 392, 393, 5, 112, 0, 0, 393, 394, 5, 111, 0, 0, 394, 395, 5, 114, 0, 0, 395, 396, 5, 116, 0, 0, 396, 50, 1, 0, 0, 0, 397, 398, 5, 105, 0, 0, 398, 399, 5, 110, 0, 0, 399, 400, 5, 115, 0, 0, 400, 401, 5, 116, 0, 0, 401, 402, 5, 97, 0, 0, 402, 403, 5, 110, 0, 0, 403, 404, 5, 99, 0, 0, 404, 405, 5, 101, 0, 0, 405, 406, 5, 111, 0, 0, 406, 407, 5, 102, 0, 0, 407, 52, 1, 0, 0, 0, 408, 409, 5, 105, 0, 0, 409, 410, 5, 110, 0, 0, 410, 411, 5, 116, 0, 0, 411, 54, 1, 0, 0, 0, 412, 413, 5, 105, 0, 0, 413, 414, 5, 110, 0, 0, 414, 415, 5, 116, 0, 0, 415, 416, 5, 101, 0, 0, 416, 417, 5, 114, 0, 0, 417, 418, 5, 102, 0, 0, 418, 419, 5, 97, 0, 0, 419, 420, 5, 99, 0, 0, 420, 421, 5, 101, 0, 0, 421, 56, 1, 0, 0, 0, 422, 423, 5, 108, 0, 0, 423, 424, 5, 111, 0, 0, 424, 425, 5, 110, 0, 0, 425, 426, 5, 103, 0, 0, 426, 58, 1, 0, 0, 0, 427, 428, 5, 110, 0, 0, 428, 429, 5, 97, 0, 0, 429, 430, 5, 116, 0, 0, 430, 431, 5, 105, 0, 0, 431, 432, 5, 118, 0, 0, 432, 433, 5, 101, 0, 0, 433, 60, 1, 0, 0, 0, 434, 435, 5, 110, 0, 0, 435, 436, 5, 101, 0, 0, 436, 437, 5, 119, 0, 0, 437, 62, 1, 0, 0, 0, 438, 439, 5, 112, 0, 0, 439, 440, 5, 97, 0, 0, 440, 441, 5, 99, 0, 0, 441, 442, 5, 107, 0, 0, 442, 443, 5, 97, 0, 0, 443, 444, 5, 103, 0, 0, 444, 445, 5, 101, 0, 0, 445, 64, 1, 0, 0, 0, 446, 447, 5, 112, 0, 0, 447, 448, 5, 114, 0, 0, 448, 449, 5, 105, 0, 0, 449, 450, 5, 118, 0, 0, 450, 451, 5, 97, 0, 0, 451, 452, 5, 116, 0, 0, 452, 453, 5, 101, 0, 0, 453, 66, 1, 0, 0, 0, 454, 455, 5, 112, 0, 0, 455, 456, 5, 114, 0, 0, 456, 457, 5, 111, 0, 0, 457, 458, 5, 116, 0, 0, 458, 459, 5, 101, 0, 0, 459, 460, 5, 99, 0, 0, 460, 461, 5, 116, 0, 0, 461, 462, 5, 101, 0, 0, 462, 463, 5, 100, 0, 0, 463, 68, 1, 0, 0, 0, 464, 465, 5, 112, 0, 0, 465, 466, 5, 117, 0, 0, 466, 467, 5, 98, 0, 0, 467, 468, 5, 108, 0, 0, 468, 469, 5, 105, 0, 0, 469, 470, 5, 99, 0, 0, 470, 70, 1, 0, 0, 0, 471, 472, 5, 114, 0, 0, 472, 473, 5, 101, 0, 0, 473, 474, 5, 116, 0, 0, 474, 475, 5, 117, 0, 0, 475, 476, 5, 114, 0, 0, 476, 477, 5, 110, 0, 0, 477, 72, 1, 0, 0, 0, 478, 479, 5, 115, 0, 0, 479, 480, 5, 104, 0, 0, 480, 481, 5, 111, 0, 0, 481, 482, 5, 114, 0, 0, 482, 483, 5, 116, 0, 0, 483, 74, 1, 0, 0, 0, 484, 485, 5, 115, 0, 0, 485, 486, 5, 116, 0, 0, 486, 487, 5, 97, 0, 0, 487, 488, 5, 116, 0, 0, 488, 489, 5, 105, 0, 0, 489, 490, 5, 99, 0, 0, 490, 76, 1, 0, 0, 0, 491, 492, 5, 115, 0, 0, 492, 493, 5, 116, 0, 0, 493, 494, 5, 114, 0, 0, 494, 495, 5, 105, 0, 0, 495, 496, 5, 99, 0, 0, 496, 497, 5, 116, 0, 0, 497, 498, 5, 102, 0, 0, 498, 499, 5, 112, 0, 0, 499, 78, 1, 0, 0, 0, 500, 501, 5, 115, 0, 0, 501, 502, 5, 117, 0, 0, 502, 503, 5, 112, 0, 0, 503, 504, 5, 101, 0, 0, 504, 505, 5, 114, 0, 0, 505, 80, 1, 0, 0, 0, 506, 507, 5, 115, 0, 0, 507, 508, 5, 119, 0, 0, 508, 509, 5, 105, 0, 0, 509, 510, 5, 116, 0, 0, 510, 511, 5, 99, 0, 0, 511, 512, 5, 104, 0, 0, 512, 82, 1, 0, 0, 0, 513, 514, 5, 115, 0, 0, 514, 515, 5, 121, 0, 0, 515, 516, 5, 110, 0, 0, 516, 517, 5, 99, 0, 0, 517, 518, 5, 104, 0, 0, 518, 519, 5, 114, 0, 0, 519, 520, 5, 111, 0, 0, 520, 521, 5, 110, 0, 0, 521, 522, 5, 105, 0, 0, 522, 523, 5, 122, 0, 0, 523, 524, 5, 101, 0, 0, 524, 525, 5, 100, 0, 0, 525, 84, 1, 0, 0, 0, 526, 527, 5, 116, 0, 0, 527, 528, 5, 104, 0, 0, 528, 529, 5, 105, 0, 0, 529, 530, 5, 115, 0, 0, 530, 86, 1, 0, 0, 0, 531, 532, 5, 116, 0, 0, 532, 533, 5, 104, 0, 0, 533, 534, 5, 114, 0, 0, 534, 535, 5, 111, 0, 0, 535, 536, 5, 119, 0, 0, 536, 88, 1, 0, 0, 0, 537, 538, 5, 116, 0, 0, 538, 539, 5, 104, 0, 0, 539, 540, 5, 114, 0, 0, 540, 541, 5, 111, 0, 0, 541, 542, 5, 119, 0, 0, 542, 543, 5, 115, 0, 0, 543, 90, 1, 0, 0, 0, 544, 545, 5, 116, 0, 0, 545, 546, 5, 114, 0, 0, 546, 547, 5, 97, 0, 0, 547, 548, 5, 110, 0, 0, 548, 549, 5, 115, 0, 0, 549, 550, 5, 105, 0, 0, 550, 551, 5, 101, 0, 0, 551, 552, 5, 110, 0, 0, 552, 553, 5, 116, 0, 0, 553, 92, 1, 0, 0, 0, 554, 555, 5, 116, 0, 0, 555, 556, 5, 114, 0, 0, 556, 557, 5, 121, 0, 0, 557, 94, 1, 0, 0, 0, 558, 559, 5, 118, 0, 0, 559, 560, 5, 97, 0, 0, 560, 561, 5, 114, 0, 0, 561, 96, 1, 0, 0, 0, 562, 563, 5, 118, 0, 0, 563, 564, 5, 111, 0, 0, 564, 565, 5, 105, 0, 0, 565, 566, 5, 100, 0, 0, 566, 98, 1, 0, 0, 0, 567, 568, 5, 118, 0, 0, 568, 569, 5, 111, 0, 0, 569, 570, 5, 108, 0, 0, 570, 571, 5, 97, 0, 0, 571, 572, 5, 116, 0, 0, 572, 573, 5, 105, 0, 0, 573, 574, 5, 108, 0, 0, 574, 575, 5, 101, 0, 0, 575, 100, 1, 0, 0, 0, 576, 577, 5, 119, 0, 0, 577, 578, 5, 104, 0, 0, 578, 579, 5, 105, 0, 0, 579, 580, 5, 108, 0, 0, 580, 581, 5, 101, 0, 0, 581, 102, 1, 0, 0, 0, 582, 596, 5, 48, 0, 0, 583, 593, 7, 0, 0, 0, 584, 586, 3, 233, 116, 0, 585, 584, 1, 0, 0, 0, 585, 586, 1, 0, 0, 0, 586, 594, 1, 0, 0, 0, 587, 589, 5, 95, 0, 0, 588, 587, 1, 0, 0, 0, 589, 590, 1, 0, 0, 0, 590, 588, 1, 0, 0, 0, 590, 591, 1, 0, 0, 0, 591, 592, 1, 0, 0, 0, 592, 594, 3, 233, 116, 0, 593, 585, 1, 0, 0, 0, 593, 588, 1, 0, 0, 0, 594, 596, 1, 0, 0, 0, 595, 582, 1, 0, 0, 0, 595, 583, 1, 0, 0, 0, 596, 598, 1, 0, 0, 0, 597, 599, 7, 1, 0, 0, 598, 597, 1, 0, 0, 0, 598, 599, 1, 0, 0, 0, 599, 104, 1, 0, 0, 0, 600, 601, 5, 48, 0, 0, 601, 602, 7, 2, 0, 0, 602, 610, 7, 3, 0, 0, 603, 605, 7, 4, 0, 0, 604, 603, 1, 0, 0, 0, 605, 608, 1, 0, 0, 0, 606, 604, 1, 0, 0, 0, 606, 607, 1, 0, 0, 0, 607, 609, 1, 0, 0, 0, 608, 606, 1, 0, 0, 0, 609, 611, 7, 3, 0, 0, 610, 606, 1, 0, 0, 0, 610, 611, 1, 0, 0, 0, 611, 613, 1, 0, 0, 0, 612, 614, 7, 1, 0, 0, 613, 612, 1, 0, 0, 0, 613, 614, 1, 0, 0, 0, 614, 106, 1, 0, 0, 0, 615, 619, 5, 48, 0, 0, 616, 618, 5, 95, 0, 0, 617, 616, 1, 0, 0, 0, 618, 621, 1, 0, 0, 0, 619, 617, 1, 0, 0, 0, 619, 620, 1, 0, 0, 0, 620, 622, 1, 0, 0, 0, 621, 619, 1, 0, 0, 0, 622, 630, 7, 5, 0, 0, 623, 625, 7, 6, 0, 0, 624, 623, 1, 0, 0, 0, 625, 628, 1, 0, 0, 0, 626, 624, 1, 0, 0, 0, 626, 627, 1, 0, 0, 0, 627, 629, 1, 0, 0, 0, 628, 626, 1, 0, 0, 0, 629, 631, 7, 5, 0, 0, 630, 626, 1, 0, 0, 0, 630, 631, 1, 0, 0, 0, 631, 633, 1, 0, 0, 0, 632, 634, 7, 1, 0, 0, 633, 632, 1, 0, 0, 0, 633, 634, 1, 0, 0, 0, 634, 108, 1, 0, 0, 0, 635, 636, 5, 48, 0, 0, 636, 637, 7, 7, 0, 0, 637, 645, 7, 8, 0, 0, 638, 640, 7, 9, 0, 0, 639, 638, 1, 0, 0, 0, 640, 643, 1, 0, 0, 0, 641, 639, 1, 0, 0, 0, 641, 642, 1, 0, 0, 0, 642, 644, 1, 0, 0, 0, 643, 641, 1, 0, 0, 0, 644, 646, 7, 8, 0, 0, 645, 641, 1, 0, 0, 0, 645, 646, 1, 0, 0, 0, 646, 648, 1, 0, 0, 0, 647, 649, 7, 1, 0, 0, 648, 647, 1, 0, 0, 0, 648, 649, 1, 0, 0, 0, 649, 110, 1, 0, 0, 0, 650, 651, 3, 233, 116, 0, 651, 653, 5, 46, 0, 0, 652, 654, 3, 233, 116, 0, 653, 652, 1, 0, 0, 0, 653, 654, 1, 0, 0, 0, 654, 658, 1, 0, 0, 0, 655, 656, 5, 46, 0, 0, 656, 658, 3, 233, 116, 0, 657, 650, 1, 0, 0, 0, 657, 655, 1, 0, 0, 0, 658, 660, 1, 0, 0, 0, 659, 661, 3, 225, 112, 0, 660, 659, 1, 0, 0, 0, 660, 661, 1, 0, 0, 0, 661, 663, 1, 0, 0, 0, 662, 664, 7, 10, 0, 0, 663, 662, 1, 0, 0, 0, 663, 664, 1, 0, 0, 0, 664, 674, 1, 0, 0, 0, 665, 671, 3, 233, 116, 0, 666, 668, 3, 225, 112, 0, 667, 669, 7, 10, 0, 0, 668, 667, 1, 0, 0, 0, 668, 669, 1, 0, 0, 0, 669, 672, 1, 0, 0, 0, 670, 672, 7, 10, 0, 0, 671, 666, 1, 0, 0, 0, 671, 670, 1, 0, 0, 0, 672, 674, 1, 0, 0, 0, 673, 657, 1, 0, 0, 0, 673, 665, 1, 0, 0, 0, 674, 112, 1, 0, 0, 0, 675, 676, 5, 48, 0, 0, 676, 686, 7, 2, 0, 0, 677, 679, 3, 229, 114, 0, 678, 680, 5, 46, 0, 0, 679, 678, 1, 0, 0, 0, 679, 680, 1, 0, 0, 0, 680, 687, 1, 0, 0, 0, 681, 683, 3, 229, 114, 0, 682, 681, 1, 0, 0, 0, 682, 683, 1, 0, 0, 0, 683, 684, 1, 0, 0, 0, 684, 685, 5, 46, 0, 0, 685, 687, 3, 229, 114, 0, 686, 677, 1, 0, 0, 0, 686, 682, 1, 0, 0, 0, 687, 688, 1, 0, 0, 0, 688, 690, 7, 11, 0, 0, 689, 691, 7, 12, 0, 0, 690, 689, 1, 0, 0, 0, 690, 691, 1, 0, 0, 0, 691, 692, 1, 0, 0, 0, 692, 694, 3, 233, 116, 0, 693, 695, 7, 10, 0, 0, 694, 693, 1, 0, 0, 0, 694, 695, 1, 0, 0, 0, 695, 114, 1, 0, 0, 0, 696, 697, 5, 116, 0, 0, 697, 698, 5, 114, 0, 0, 698, 699, 5, 117, 0, 0, 699, 706, 5, 101, 0, 0, 700, 701, 5, 102, 0, 0, 701, 702, 5, 97, 0, 0, 702, 703, 5, 108, 0, 0, 703, 704, 5, 115, 0, 0, 704, 706, 5, 101, 0, 0, 705, 696, 1, 0, 0, 0, 705, 700, 1, 0, 0, 0, 706, 116, 1, 0, 0, 0, 707, 710, 5, 39, 0, 0, 708, 711, 8, 13, 0, 0, 709, 711, 3, 227, 113, 0, 710, 708, 1, 0, 0, 0, 710, 709, 1, 0, 0, 0, 711, 712, 1, 0, 0, 0, 712, 713, 5, 39, 0, 0, 713, 118, 1, 0, 0, 0, 714, 719, 5, 34, 0, 0, 715, 718, 8, 14, 0, 0, 716, 718, 3, 227, 113, 0, 717, 715, 1, 0, 0, 0, 717, 716, 1, 0, 0, 0, 718, 721, 1, 0, 0, 0, 719, 717, 1, 0, 0, 0, 719, 720, 1, 0, 0, 0, 720, 722, 1, 0, 0, 0, 721, 719, 1, 0, 0, 0, 722, 723, 5, 34, 0, 0, 723, 120, 1, 0, 0, 0, 724, 725, 5, 110, 0, 0, 725, 726, 5, 117, 0, 0, 726, 727, 5, 108, 0, 0, 727, 728, 5, 108, 0, 0, 728, 122, 1, 0, 0, 0, 729, 730, 5, 40, 0, 0, 730, 124, 1, 0, 0, 0, 731, 732, 5, 41, 0, 0, 732, 126, 1, 0, 0, 0, 733, 734, 5, 123, 0, 0, 734, 128, 1, 0, 0, 0, 735, 736, 5, 125, 0, 0, 736, 130, 1, 0, 0, 0, 737, 738, 5, 91, 0, 0, 738, 132, 1, 0, 0, 0, 739, 740, 5, 93, 0, 0, 740, 134, 1, 0, 0, 0, 741, 742, 5, 59, 0, 0, 742, 136, 1, 0, 0, 0, 743, 744, 5, 44, 0, 0, 744, 138, 1, 0, 0, 0, 745, 746, 5, 46, 0, 0, 746, 140, 1, 0, 0, 0, 747, 748, 5, 61, 0, 0, 748, 142, 1, 0, 0, 0, 749, 750, 5, 62, 0, 0, 750, 144, 1, 0, 0, 0, 751, 752, 5, 60, 0, 0, 752, 146, 1, 0, 0, 0, 753, 754, 5, 33, 0, 0, 754, 148, 1, 0, 0, 0, 755, 756, 5, 126, 0, 0, 756, 150, 1, 0, 0, 0, 757, 758, 5, 63, 0, 0, 758, 152, 1, 0, 0, 0, 759, 760, 5, 58, 0, 0, 760, 154, 1, 0, 0, 0, 761, 762, 5, 61, 0, 0, 762, 763, 5, 61, 0, 0, 763, 156, 1, 0, 0, 0, 764, 765, 5, 60, 0, 0, 765, 766, 5, 61, 0, 0, 766, 158, 1, 0, 0, 0, 767, 768, 5, 62, 0, 0, 768, 769, 5, 61, 0, 0, 769, 160, 1, 0, 0, 0, 770, 771, 5, 33, 0, 0, 771, 772, 5, 61, 0, 0, 772, 162, 1, 0, 0, 0, 773, 774, 5, 38, 0, 0, 774, 775, 5, 38, 0, 0, 775, 164, 1, 0, 0, 0, 776, 777, 5, 124, 0, 0, 777, 778, 5, 124, 0, 0, 778, 166, 1, 0, 0, 0, 779, 780, 5, 43, 0, 0, 780, 781, 5, 43, 0, 0, 781, 168, 1, 0, 0, 0, 782, 783, 5, 45, 0, 0, 783, 784, 5, 45, 0, 0, 784, 170, 1, 0, 0, 0, 785, 786, 5, 43, 0, 0, 786, 172, 1, 0, 0, 0, 787, 788, 5, 45, 0, 0, 788, 174, 1, 0, 0, 0, 789, 790, 5, 42, 0, 0, 790, 176, 1, 0, 0, 0, 791, 792, 5, 47, 0, 0, 792, 178, 1, 0, 0, 0, 793, 794, 5, 38, 0, 0, 794, 180, 1, 0, 0, 0, 795, 796, 5, 124, 0, 0, 796, 182, 1, 0, 0, 0, 797, 798, 5, 94, 0, 0, 798, 184, 1, 0, 0, 0, 799, 800, 5, 37, 0, 0, 800, 186, 1, 0, 0, 0, 801, 802, 5, 43, 0, 0, 802, 803, 5, 61, 0, 0, 803, 188, 1, 0, 0, 0, 804, 805, 5, 45, 0, 0, 805, 806, 5, 61, 0, 0, 806, 190, 1, 0, 0, 0, 807, 808, 5, 42, 0, 0, 808, 809, 5, 61, 0, 0, 809, 192, 1, 0, 0, 0, 810, 811, 5, 47, 0, 0, 811, 812, 5, 61, 0, 0, 812, 194, 1, 0, 0, 0, 813, 814, 5, 38, 0, 0, 814, 815, 5, 61, 0, 0, 815, 196, 1, 0, 0, 0, 816, 817, 5, 124, 0, 0, 817, 818, 5, 61, 0, 0, 818, 198, 1, 0, 0, 0, 819, 820, 5, 94, 0, 0, 820, 821, 5, 61, 0, 0, 821, 200, 1, 0, 0, 0, 822, 823, 5, 37, 0, 0, 823, 824, 5, 61, 0, 0, 824, 202, 1, 0, 0, 0, 825, 826, 5, 60, 0, 0, 826, 827, 5, 60, 0, 0, 827, 828, 5, 61, 0, 0, 828, 204, 1, 0, 0, 0, 829, 830, 5, 62, 0, 0, 830, 831, 5, 62, 0, 0, 831, 832, 5, 61, 0, 0, 832, 206, 1, 0, 0, 0, 833, 834, 5, 62, 0, 0, 834, 835, 5, 62, 0, 0, 835, 836, 5, 62, 0, 0, 836, 837, 5, 61, 0, 0, 837, 208, 1, 0, 0, 0, 838, 839, 5, 45, 0, 0, 839, 840, 5, 62, 0, 0, 840, 210, 1, 0, 0, 0, 841, 842, 5, 58, 0, 0, 842, 843, 5, 58, 0, 0, 843, 212, 1, 0, 0, 0, 844, 845, 5, 64, 0, 0, 845, 214, 1, 0, 0, 0, 846, 847, 5, 46, 0, 0, 847, 848, 5, 46, 0, 0, 848, 849, 5, 46, 0, 0, 849, 216, 1, 0, 0, 0, 850, 852, 7, 15, 0, 0, 851, 850, 1, 0, 0, 0, 852, 853, 1, 0, 0, 0, 853, 851, 1, 0, 0, 0, 853, 854, 1, 0, 0, 0, 854, 855, 1, 0, 0, 0, 855, 856, 6, 108, 0, 0, 856, 218, 1, 0, 0, 0, 857, 858, 5, 47, 0, 0, 858, 859, 5, 42, 0, 0, 859, 863, 1, 0, 0, 0, 860, 862, 9, 0, 0, 0, 861, 860, 1, 0, 0, 0, 862, 865, 1, 0, 0, 0, 863, 864, 1, 0, 0, 0, 863, 861, 1, 0, 0, 0, 864, 866, 1, 0, 0, 0, 865, 863, 1, 0, 0, 0, 866, 867, 5, 42, 0, 0, 867, 868, 5, 47, 0, 0, 868, 869, 1, 0, 0, 0, 869, 870, 6, 109, 0, 0, 870, 220, 1, 0, 0, 0, 871, 872, 5, 47, 0, 0, 872, 873, 5, 47, 0, 0, 873, 877, 1, 0, 0, 0, 874, 876, 8, 16, 0, 0, 875, 874, 1, 0, 0, 0, 876, 879, 1, 0, 0, 0, 877, 875, 1, 0, 0, 0, 877, 878, 1, 0, 0, 0, 878, 880, 1, 0, 0, 0, 879, 877, 1, 0, 0, 0, 880, 881, 6, 110, 0, 0, 881, 222, 1, 0, 0, 0, 882, 886, 3, 237, 118, 0, 883, 885, 3, 235, 117, 0, 884, 883, 1, 0, 0, 0, 885, 888, 1, 0, 0, 0, 886, 884, 1, 0, 0, 0, 886, 887, 1, 0, 0, 0, 887, 224, 1, 0, 0, 0, 888, 886, 1, 0, 0, 0, 889, 891, 7, 17, 0, 0, 890, 892, 7, 12, 0, 0, 891, 890, 1, 0, 0, 0, 891, 892, 1, 0, 0, 0, 892, 893, 1, 0, 0, 0, 893, 894, 3, 233, 116, 0, 894, 226, 1, 0, 0, 0, 895, 896, 5, 92, 0, 0, 896, 917, 7, 18, 0, 0, 897, 902, 5, 92, 0, 0, 898, 900, 7, 19, 0, 0, 899, 898, 1, 0, 0, 0, 899, 900, 1, 0, 0, 0, 900, 901, 1, 0, 0, 0, 901, 903, 7, 5, 0, 0, 902, 899, 1, 0, 0, 0, 902, 903, 1, 0, 0, 0, 903, 904, 1, 0, 0, 0, 904, 917, 7, 5, 0, 0, 905, 907, 5, 92, 0, 0, 906, 908, 5, 117, 0, 0, 907, 906, 1, 0, 0, 0, 908, 909, 1, 0, 0, 0, 909, 907, 1, 0, 0, 0, 909, 910, 1, 0, 0, 0, 910, 911, 1, 0, 0, 0, 911, 912, 3, 231, 115, 0, 912, 913, 3, 231, 115, 0, 913, 914, 3, 231, 115, 0, 914, 915, 3, 231, 115, 0, 915, 917, 1, 0, 0, 0, 916, 895, 1, 0, 0, 0, 916, 897, 1, 0, 0, 0, 916, 905, 1, 0, 0, 0, 917, 228, 1, 0, 0, 0, 918, 927, 3, 231, 115, 0, 919, 922, 3, 231, 115, 0, 920, 922, 5, 95, 0, 0, 921, 919, 1, 0, 0, 0, 921, 920, 1, 0, 0, 0, 922, 925, 1, 0, 0, 0, 923, 921, 1, 0, 0, 0, 923, 924, 1, 0, 0, 0, 924, 926, 1, 0, 0, 0, 925, 923, 1, 0, 0, 0, 926, 928, 3, 231, 115, 0, 927, 923, 1, 0, 0, 0, 927, 928, 1, 0, 0, 0, 928, 230, 1, 0, 0, 0, 929, 930, 7, 3, 0, 0, 930, 232, 1, 0, 0, 0, 931, 939, 7, 20, 0, 0, 932, 934, 7, 21, 0, 0, 933, 932, 1, 0, 0, 0, 934, 937, 1, 0, 0, 0, 935, 933, 1, 0, 0, 0, 935, 936, 1, 0, 0, 0, 936, 938, 1, 0, 0, 0, 937, 935, 1, 0, 0, 0, 938, 940, 7, 20, 0, 0, 939, 935, 1, 0, 0, 0, 939, 940, 1, 0, 0, 0, 940, 234, 1, 0, 0, 0, 941, 944, 3, 237, 118, 0, 942, 944, 7, 20, 0, 0, 943, 941, 1, 0, 0, 0, 943, 942, 1, 0, 0, 0, 944, 236, 1, 0, 0, 0, 945, 950, 7, 22, 0, 0, 946, 950, 8, 23, 0, 0, 947, 948, 7, 24, 0, 0, 948, 950, 7, 25, 0, 0, 949, 945, 1, 0, 0, 0, 949, 946, 1, 0, 0, 0, 949, 947, 1, 0, 0, 0, 950, 238, 1, 0, 0, 0, 48, 0, 585, 590, 593, 595, 598, 606, 610, 613, 619, 626, 630, 633, 641, 645, 648, 653, 657, 660, 663, 668, 671, 673, 679, 682, 686, 690, 694, 705, 710, 717, 719, 853, 863, 877, 886, 891, 899, 902, 909, 916, 921, 923, 927, 935, 939, 943, 949, 1, 0, 1, 0] \ No newline at end of file diff --git a/lexers/src/main/gen/com/itsaky/androidide/lexers/java/JavaLexer.java b/lexers/src/main/gen/com/itsaky/androidide/lexers/java/JavaLexer.java new file mode 100644 index 000000000..0a2d2a9d4 --- /dev/null +++ b/lexers/src/main/gen/com/itsaky/androidide/lexers/java/JavaLexer.java @@ -0,0 +1,763 @@ +// Generated from /home/itsaky/Projects/Android/AndroidIDE/lexers/src/main/java/com/itsaky/androidide/lexers/java/JavaLexer.g4 by ANTLR 4.10.1 +package com.itsaky.androidide.lexers.java; +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 JavaLexer extends Lexer { + static { RuntimeMetaData.checkVersion("4.10.1", RuntimeMetaData.VERSION); } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + ABSTRACT=1, ASSERT=2, BOOLEAN=3, BREAK=4, BYTE=5, CASE=6, CATCH=7, CHAR=8, + CLASS=9, CONST=10, CONTINUE=11, DEFAULT=12, DO=13, DOUBLE=14, ELSE=15, + ENUM=16, EXTENDS=17, FINAL=18, FINALLY=19, FLOAT=20, FOR=21, IF=22, GOTO=23, + IMPLEMENTS=24, IMPORT=25, INSTANCEOF=26, INT=27, INTERFACE=28, LONG=29, + NATIVE=30, NEW=31, PACKAGE=32, PRIVATE=33, PROTECTED=34, PUBLIC=35, RETURN=36, + SHORT=37, STATIC=38, STRICTFP=39, SUPER=40, SWITCH=41, SYNCHRONIZED=42, + THIS=43, THROW=44, THROWS=45, TRANSIENT=46, TRY=47, VAR=48, VOID=49, VOLATILE=50, + WHILE=51, DECIMAL_LITERAL=52, HEX_LITERAL=53, OCT_LITERAL=54, BINARY_LITERAL=55, + FLOAT_LITERAL=56, HEX_FLOAT_LITERAL=57, BOOL_LITERAL=58, CHAR_LITERAL=59, + STRING_LITERAL=60, NULL_LITERAL=61, LPAREN=62, RPAREN=63, LBRACE=64, RBRACE=65, + LBRACK=66, RBRACK=67, SEMI=68, COMMA=69, DOT=70, ASSIGN=71, GT=72, LT=73, + BANG=74, TILDE=75, QUESTION=76, COLON=77, EQUAL=78, LE=79, GE=80, NOTEQUAL=81, + AND=82, OR=83, INC=84, DEC=85, ADD=86, SUB=87, MUL=88, DIV=89, BITAND=90, + BITOR=91, CARET=92, MOD=93, ADD_ASSIGN=94, SUB_ASSIGN=95, MUL_ASSIGN=96, + DIV_ASSIGN=97, AND_ASSIGN=98, OR_ASSIGN=99, XOR_ASSIGN=100, MOD_ASSIGN=101, + LSHIFT_ASSIGN=102, RSHIFT_ASSIGN=103, URSHIFT_ASSIGN=104, ARROW=105, COLONCOLON=106, + AT=107, ELLIPSIS=108, WS=109, BLOCK_COMMENT=110, LINE_COMMENT=111, IDENTIFIER=112; + public static String[] channelNames = { + "DEFAULT_TOKEN_CHANNEL", "HIDDEN" + }; + + public static String[] modeNames = { + "DEFAULT_MODE" + }; + + private static String[] makeRuleNames() { + return new String[] { + "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", "CHAR", + "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", "ENUM", + "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", "GOTO", "IMPLEMENTS", + "IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", "NATIVE", "NEW", + "PACKAGE", "PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", "STATIC", + "STRICTFP", "SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", "THROWS", + "TRANSIENT", "TRY", "VAR", "VOID", "VOLATILE", "WHILE", "DECIMAL_LITERAL", + "HEX_LITERAL", "OCT_LITERAL", "BINARY_LITERAL", "FLOAT_LITERAL", "HEX_FLOAT_LITERAL", + "BOOL_LITERAL", "CHAR_LITERAL", "STRING_LITERAL", "NULL_LITERAL", "LPAREN", + "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", "SEMI", "COMMA", "DOT", + "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTION", "COLON", "EQUAL", + "LE", "GE", "NOTEQUAL", "AND", "OR", "INC", "DEC", "ADD", "SUB", "MUL", + "DIV", "BITAND", "BITOR", "CARET", "MOD", "ADD_ASSIGN", "SUB_ASSIGN", + "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", + "MOD_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN", "URSHIFT_ASSIGN", "ARROW", + "COLONCOLON", "AT", "ELLIPSIS", "WS", "BLOCK_COMMENT", "LINE_COMMENT", + "IDENTIFIER", "ExponentPart", "EscapeSequence", "HexDigits", "HexDigit", + "Digits", "LetterOrDigit", "Letter" + }; + } + public static final String[] ruleNames = makeRuleNames(); + + private static String[] makeLiteralNames() { + return new String[] { + null, "'abstract'", "'assert'", "'boolean'", "'break'", "'byte'", "'case'", + "'catch'", "'char'", "'class'", "'const'", "'continue'", "'default'", + "'do'", "'double'", "'else'", "'enum'", "'extends'", "'final'", "'finally'", + "'float'", "'for'", "'if'", "'goto'", "'implements'", "'import'", "'instanceof'", + "'int'", "'interface'", "'long'", "'native'", "'new'", "'package'", "'private'", + "'protected'", "'public'", "'return'", "'short'", "'static'", "'strictfp'", + "'super'", "'switch'", "'synchronized'", "'this'", "'throw'", "'throws'", + "'transient'", "'try'", "'var'", "'void'", "'volatile'", "'while'", null, + null, null, null, null, null, null, null, null, "'null'", "'('", "')'", + "'{'", "'}'", "'['", "']'", "';'", "','", "'.'", "'='", "'>'", "'<'", + "'!'", "'~'", "'?'", "':'", "'=='", "'<='", "'>='", "'!='", "'&&'", "'||'", + "'++'", "'--'", "'+'", "'-'", "'*'", "'/'", "'&'", "'|'", "'^'", "'%'", + "'+='", "'-='", "'*='", "'/='", "'&='", "'|='", "'^='", "'%='", "'<<='", + "'>>='", "'>>>='", "'->'", "'::'", "'@'", "'...'" + }; + } + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static String[] makeSymbolicNames() { + return new String[] { + null, "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", + "CHAR", "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", + "ENUM", "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", "GOTO", + "IMPLEMENTS", "IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", "NATIVE", + "NEW", "PACKAGE", "PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", + "STATIC", "STRICTFP", "SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", + "THROWS", "TRANSIENT", "TRY", "VAR", "VOID", "VOLATILE", "WHILE", "DECIMAL_LITERAL", + "HEX_LITERAL", "OCT_LITERAL", "BINARY_LITERAL", "FLOAT_LITERAL", "HEX_FLOAT_LITERAL", + "BOOL_LITERAL", "CHAR_LITERAL", "STRING_LITERAL", "NULL_LITERAL", "LPAREN", + "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", "SEMI", "COMMA", "DOT", + "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTION", "COLON", "EQUAL", + "LE", "GE", "NOTEQUAL", "AND", "OR", "INC", "DEC", "ADD", "SUB", "MUL", + "DIV", "BITAND", "BITOR", "CARET", "MOD", "ADD_ASSIGN", "SUB_ASSIGN", + "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", + "MOD_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN", "URSHIFT_ASSIGN", "ARROW", + "COLONCOLON", "AT", "ELLIPSIS", "WS", "BLOCK_COMMENT", "LINE_COMMENT", + "IDENTIFIER" + }; + } + 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 JavaLexer(CharStream input) { + super(input); + _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); + } + + @Override + public String getGrammarFileName() { return "JavaLexer.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 = + "\u0004\u0000p\u03b7\u0006\uffff\uffff\u0002\u0000\u0007\u0000\u0002\u0001"+ + "\u0007\u0001\u0002\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004"+ + "\u0007\u0004\u0002\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007"+ + "\u0007\u0007\u0002\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b"+ + "\u0007\u000b\u0002\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002"+ + "\u000f\u0007\u000f\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002"+ + "\u0012\u0007\u0012\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002"+ + "\u0015\u0007\u0015\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002"+ + "\u0018\u0007\u0018\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0002"+ + "\u001b\u0007\u001b\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d\u0002"+ + "\u001e\u0007\u001e\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!\u0007"+ + "!\u0002\"\u0007\"\u0002#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002&\u0007"+ + "&\u0002\'\u0007\'\u0002(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002+\u0007"+ + "+\u0002,\u0007,\u0002-\u0007-\u0002.\u0007.\u0002/\u0007/\u00020\u0007"+ + "0\u00021\u00071\u00022\u00072\u00023\u00073\u00024\u00074\u00025\u0007"+ + "5\u00026\u00076\u00027\u00077\u00028\u00078\u00029\u00079\u0002:\u0007"+ + ":\u0002;\u0007;\u0002<\u0007<\u0002=\u0007=\u0002>\u0007>\u0002?\u0007"+ + "?\u0002@\u0007@\u0002A\u0007A\u0002B\u0007B\u0002C\u0007C\u0002D\u0007"+ + "D\u0002E\u0007E\u0002F\u0007F\u0002G\u0007G\u0002H\u0007H\u0002I\u0007"+ + "I\u0002J\u0007J\u0002K\u0007K\u0002L\u0007L\u0002M\u0007M\u0002N\u0007"+ + "N\u0002O\u0007O\u0002P\u0007P\u0002Q\u0007Q\u0002R\u0007R\u0002S\u0007"+ + "S\u0002T\u0007T\u0002U\u0007U\u0002V\u0007V\u0002W\u0007W\u0002X\u0007"+ + "X\u0002Y\u0007Y\u0002Z\u0007Z\u0002[\u0007[\u0002\\\u0007\\\u0002]\u0007"+ + "]\u0002^\u0007^\u0002_\u0007_\u0002`\u0007`\u0002a\u0007a\u0002b\u0007"+ + "b\u0002c\u0007c\u0002d\u0007d\u0002e\u0007e\u0002f\u0007f\u0002g\u0007"+ + "g\u0002h\u0007h\u0002i\u0007i\u0002j\u0007j\u0002k\u0007k\u0002l\u0007"+ + "l\u0002m\u0007m\u0002n\u0007n\u0002o\u0007o\u0002p\u0007p\u0002q\u0007"+ + "q\u0002r\u0007r\u0002s\u0007s\u0002t\u0007t\u0002u\u0007u\u0002v\u0007"+ + "v\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0000"+ + "\u0001\u0000\u0001\u0000\u0001\u0000\u0001\u0001\u0001\u0001\u0001\u0001"+ + "\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0001\u0002\u0001\u0002"+ + "\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002\u0001\u0002"+ + "\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003"+ + "\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0004\u0001\u0005"+ + "\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0006\u0001\u0006"+ + "\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0006\u0001\u0007\u0001\u0007"+ + "\u0001\u0007\u0001\u0007\u0001\u0007\u0001\b\u0001\b\u0001\b\u0001\b\u0001"+ + "\b\u0001\b\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\t\u0001\n\u0001"+ + "\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\n\u0001\u000b"+ + "\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b\u0001\u000b"+ + "\u0001\u000b\u0001\f\u0001\f\u0001\f\u0001\r\u0001\r\u0001\r\u0001\r\u0001"+ + "\r\u0001\r\u0001\r\u0001\u000e\u0001\u000e\u0001\u000e\u0001\u000e\u0001"+ + "\u000e\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001\u000f\u0001"+ + "\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001\u0010\u0001"+ + "\u0010\u0001\u0010\u0001\u0011\u0001\u0011\u0001\u0011\u0001\u0011\u0001"+ + "\u0011\u0001\u0011\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001"+ + "\u0012\u0001\u0012\u0001\u0012\u0001\u0012\u0001\u0013\u0001\u0013\u0001"+ + "\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0014\u0001\u0014\u0001"+ + "\u0014\u0001\u0014\u0001\u0015\u0001\u0015\u0001\u0015\u0001\u0016\u0001"+ + "\u0016\u0001\u0016\u0001\u0016\u0001\u0016\u0001\u0017\u0001\u0017\u0001"+ + "\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0017\u0001"+ + "\u0017\u0001\u0017\u0001\u0017\u0001\u0018\u0001\u0018\u0001\u0018\u0001"+ + "\u0018\u0001\u0018\u0001\u0018\u0001\u0018\u0001\u0019\u0001\u0019\u0001"+ + "\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0001"+ + "\u0019\u0001\u0019\u0001\u0019\u0001\u001a\u0001\u001a\u0001\u001a\u0001"+ + "\u001a\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001"+ + "\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001b\u0001\u001c\u0001"+ + "\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001d\u0001\u001d\u0001"+ + "\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001e\u0001"+ + "\u001e\u0001\u001e\u0001\u001e\u0001\u001f\u0001\u001f\u0001\u001f\u0001"+ + "\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0001\u001f\u0001 \u0001 \u0001"+ + " \u0001 \u0001 \u0001 \u0001 \u0001 \u0001!\u0001!\u0001!\u0001!\u0001"+ + "!\u0001!\u0001!\u0001!\u0001!\u0001!\u0001\"\u0001\"\u0001\"\u0001\"\u0001"+ + "\"\u0001\"\u0001\"\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001#\u0001"+ + "$\u0001$\u0001$\u0001$\u0001$\u0001$\u0001%\u0001%\u0001%\u0001%\u0001"+ + "%\u0001%\u0001%\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001&\u0001"+ + "&\u0001&\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001\'\u0001(\u0001"+ + "(\u0001(\u0001(\u0001(\u0001(\u0001(\u0001)\u0001)\u0001)\u0001)\u0001"+ + ")\u0001)\u0001)\u0001)\u0001)\u0001)\u0001)\u0001)\u0001)\u0001*\u0001"+ + "*\u0001*\u0001*\u0001*\u0001+\u0001+\u0001+\u0001+\u0001+\u0001+\u0001"+ + ",\u0001,\u0001,\u0001,\u0001,\u0001,\u0001,\u0001-\u0001-\u0001-\u0001"+ + "-\u0001-\u0001-\u0001-\u0001-\u0001-\u0001-\u0001.\u0001.\u0001.\u0001"+ + ".\u0001/\u0001/\u0001/\u0001/\u00010\u00010\u00010\u00010\u00010\u0001"+ + "1\u00011\u00011\u00011\u00011\u00011\u00011\u00011\u00011\u00012\u0001"+ + "2\u00012\u00012\u00012\u00012\u00013\u00013\u00013\u00033\u024a\b3\u0001"+ + "3\u00043\u024d\b3\u000b3\f3\u024e\u00013\u00033\u0252\b3\u00033\u0254"+ + "\b3\u00013\u00033\u0257\b3\u00014\u00014\u00014\u00014\u00054\u025d\b"+ + "4\n4\f4\u0260\t4\u00014\u00034\u0263\b4\u00014\u00034\u0266\b4\u00015"+ + "\u00015\u00055\u026a\b5\n5\f5\u026d\t5\u00015\u00015\u00055\u0271\b5\n"+ + "5\f5\u0274\t5\u00015\u00035\u0277\b5\u00015\u00035\u027a\b5\u00016\u0001"+ + "6\u00016\u00016\u00056\u0280\b6\n6\f6\u0283\t6\u00016\u00036\u0286\b6"+ + "\u00016\u00036\u0289\b6\u00017\u00017\u00017\u00037\u028e\b7\u00017\u0001"+ + "7\u00037\u0292\b7\u00017\u00037\u0295\b7\u00017\u00037\u0298\b7\u0001"+ + "7\u00017\u00017\u00037\u029d\b7\u00017\u00037\u02a0\b7\u00037\u02a2\b"+ + "7\u00018\u00018\u00018\u00018\u00038\u02a8\b8\u00018\u00038\u02ab\b8\u0001"+ + "8\u00018\u00038\u02af\b8\u00018\u00018\u00038\u02b3\b8\u00018\u00018\u0003"+ + "8\u02b7\b8\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u00019\u0001"+ + "9\u00039\u02c2\b9\u0001:\u0001:\u0001:\u0003:\u02c7\b:\u0001:\u0001:\u0001"+ + ";\u0001;\u0001;\u0005;\u02ce\b;\n;\f;\u02d1\t;\u0001;\u0001;\u0001<\u0001"+ + "<\u0001<\u0001<\u0001<\u0001=\u0001=\u0001>\u0001>\u0001?\u0001?\u0001"+ + "@\u0001@\u0001A\u0001A\u0001B\u0001B\u0001C\u0001C\u0001D\u0001D\u0001"+ + "E\u0001E\u0001F\u0001F\u0001G\u0001G\u0001H\u0001H\u0001I\u0001I\u0001"+ + "J\u0001J\u0001K\u0001K\u0001L\u0001L\u0001M\u0001M\u0001M\u0001N\u0001"+ + "N\u0001N\u0001O\u0001O\u0001O\u0001P\u0001P\u0001P\u0001Q\u0001Q\u0001"+ + "Q\u0001R\u0001R\u0001R\u0001S\u0001S\u0001S\u0001T\u0001T\u0001T\u0001"+ + "U\u0001U\u0001V\u0001V\u0001W\u0001W\u0001X\u0001X\u0001Y\u0001Y\u0001"+ + "Z\u0001Z\u0001[\u0001[\u0001\\\u0001\\\u0001]\u0001]\u0001]\u0001^\u0001"+ + "^\u0001^\u0001_\u0001_\u0001_\u0001`\u0001`\u0001`\u0001a\u0001a\u0001"+ + "a\u0001b\u0001b\u0001b\u0001c\u0001c\u0001c\u0001d\u0001d\u0001d\u0001"+ + "e\u0001e\u0001e\u0001e\u0001f\u0001f\u0001f\u0001f\u0001g\u0001g\u0001"+ + "g\u0001g\u0001g\u0001h\u0001h\u0001h\u0001i\u0001i\u0001i\u0001j\u0001"+ + "j\u0001k\u0001k\u0001k\u0001k\u0001l\u0004l\u0354\bl\u000bl\fl\u0355\u0001"+ + "l\u0001l\u0001m\u0001m\u0001m\u0001m\u0005m\u035e\bm\nm\fm\u0361\tm\u0001"+ + "m\u0001m\u0001m\u0001m\u0001m\u0001n\u0001n\u0001n\u0001n\u0005n\u036c"+ + "\bn\nn\fn\u036f\tn\u0001n\u0001n\u0001o\u0001o\u0005o\u0375\bo\no\fo\u0378"+ + "\to\u0001p\u0001p\u0003p\u037c\bp\u0001p\u0001p\u0001q\u0001q\u0001q\u0001"+ + "q\u0003q\u0384\bq\u0001q\u0003q\u0387\bq\u0001q\u0001q\u0001q\u0004q\u038c"+ + "\bq\u000bq\fq\u038d\u0001q\u0001q\u0001q\u0001q\u0001q\u0003q\u0395\b"+ + "q\u0001r\u0001r\u0001r\u0005r\u039a\br\nr\fr\u039d\tr\u0001r\u0003r\u03a0"+ + "\br\u0001s\u0001s\u0001t\u0001t\u0005t\u03a6\bt\nt\ft\u03a9\tt\u0001t"+ + "\u0003t\u03ac\bt\u0001u\u0001u\u0003u\u03b0\bu\u0001v\u0001v\u0001v\u0001"+ + "v\u0003v\u03b6\bv\u0001\u035f\u0000w\u0001\u0001\u0003\u0002\u0005\u0003"+ + "\u0007\u0004\t\u0005\u000b\u0006\r\u0007\u000f\b\u0011\t\u0013\n\u0015"+ + "\u000b\u0017\f\u0019\r\u001b\u000e\u001d\u000f\u001f\u0010!\u0011#\u0012"+ + "%\u0013\'\u0014)\u0015+\u0016-\u0017/\u00181\u00193\u001a5\u001b7\u001c"+ + "9\u001d;\u001e=\u001f? A!C\"E#G$I%K&M\'O(Q)S*U+W,Y-[.]/_0a1c2e3g4i5k6"+ + "m7o8q9s:u;w}?\u007f@\u0081A\u0083B\u0085C\u0087D\u0089E\u008bF\u008d"+ + "G\u008fH\u0091I\u0093J\u0095K\u0097L\u0099M\u009bN\u009dO\u009fP\u00a1"+ + "Q\u00a3R\u00a5S\u00a7T\u00a9U\u00abV\u00adW\u00afX\u00b1Y\u00b3Z\u00b5"+ + "[\u00b7\\\u00b9]\u00bb^\u00bd_\u00bf`\u00c1a\u00c3b\u00c5c\u00c7d\u00c9"+ + "e\u00cbf\u00cdg\u00cfh\u00d1i\u00d3j\u00d5k\u00d7l\u00d9m\u00dbn\u00dd"+ + "o\u00dfp\u00e1\u0000\u00e3\u0000\u00e5\u0000\u00e7\u0000\u00e9\u0000\u00eb"+ + "\u0000\u00ed\u0000\u0001\u0000\u001a\u0001\u000019\u0002\u0000LLll\u0002"+ + "\u0000XXxx\u0003\u000009AFaf\u0004\u000009AF__af\u0001\u000007\u0002\u0000"+ + "07__\u0002\u0000BBbb\u0001\u000001\u0002\u000001__\u0004\u0000DDFFddf"+ + "f\u0002\u0000PPpp\u0002\u0000++--\u0004\u0000\n\n\r\r\'\'\\\\\u0004\u0000"+ + "\n\n\r\r\"\"\\\\\u0003\u0000\t\n\f\r \u0002\u0000\n\n\r\r\u0002\u0000"+ + "EEee\b\u0000\"\"\'\'\\\\bbffnnrrtt\u0001\u000003\u0001\u000009\u0002\u0000"+ + "09__\u0004\u0000$$AZ__az\u0002\u0000\u0000\u007f\u8000\ud800\u8000\udbff"+ + "\u0001\u0000\u8000\ud800\u8000\udbff\u0001\u0000\u8000\udc00\u8000\udfff"+ + "\u03e0\u0000\u0001\u0001\u0000\u0000\u0000\u0000\u0003\u0001\u0000\u0000"+ + "\u0000\u0000\u0005\u0001\u0000\u0000\u0000\u0000\u0007\u0001\u0000\u0000"+ + "\u0000\u0000\t\u0001\u0000\u0000\u0000\u0000\u000b\u0001\u0000\u0000\u0000"+ + "\u0000\r\u0001\u0000\u0000\u0000\u0000\u000f\u0001\u0000\u0000\u0000\u0000"+ + "\u0011\u0001\u0000\u0000\u0000\u0000\u0013\u0001\u0000\u0000\u0000\u0000"+ + "\u0015\u0001\u0000\u0000\u0000\u0000\u0017\u0001\u0000\u0000\u0000\u0000"+ + "\u0019\u0001\u0000\u0000\u0000\u0000\u001b\u0001\u0000\u0000\u0000\u0000"+ + "\u001d\u0001\u0000\u0000\u0000\u0000\u001f\u0001\u0000\u0000\u0000\u0000"+ + "!\u0001\u0000\u0000\u0000\u0000#\u0001\u0000\u0000\u0000\u0000%\u0001"+ + "\u0000\u0000\u0000\u0000\'\u0001\u0000\u0000\u0000\u0000)\u0001\u0000"+ + "\u0000\u0000\u0000+\u0001\u0000\u0000\u0000\u0000-\u0001\u0000\u0000\u0000"+ + "\u0000/\u0001\u0000\u0000\u0000\u00001\u0001\u0000\u0000\u0000\u00003"+ + "\u0001\u0000\u0000\u0000\u00005\u0001\u0000\u0000\u0000\u00007\u0001\u0000"+ + "\u0000\u0000\u00009\u0001\u0000\u0000\u0000\u0000;\u0001\u0000\u0000\u0000"+ + "\u0000=\u0001\u0000\u0000\u0000\u0000?\u0001\u0000\u0000\u0000\u0000A"+ + "\u0001\u0000\u0000\u0000\u0000C\u0001\u0000\u0000\u0000\u0000E\u0001\u0000"+ + "\u0000\u0000\u0000G\u0001\u0000\u0000\u0000\u0000I\u0001\u0000\u0000\u0000"+ + "\u0000K\u0001\u0000\u0000\u0000\u0000M\u0001\u0000\u0000\u0000\u0000O"+ + "\u0001\u0000\u0000\u0000\u0000Q\u0001\u0000\u0000\u0000\u0000S\u0001\u0000"+ + "\u0000\u0000\u0000U\u0001\u0000\u0000\u0000\u0000W\u0001\u0000\u0000\u0000"+ + "\u0000Y\u0001\u0000\u0000\u0000\u0000[\u0001\u0000\u0000\u0000\u0000]"+ + "\u0001\u0000\u0000\u0000\u0000_\u0001\u0000\u0000\u0000\u0000a\u0001\u0000"+ + "\u0000\u0000\u0000c\u0001\u0000\u0000\u0000\u0000e\u0001\u0000\u0000\u0000"+ + "\u0000g\u0001\u0000\u0000\u0000\u0000i\u0001\u0000\u0000\u0000\u0000k"+ + "\u0001\u0000\u0000\u0000\u0000m\u0001\u0000\u0000\u0000\u0000o\u0001\u0000"+ + "\u0000\u0000\u0000q\u0001\u0000\u0000\u0000\u0000s\u0001\u0000\u0000\u0000"+ + "\u0000u\u0001\u0000\u0000\u0000\u0000w\u0001\u0000\u0000\u0000\u0000y"+ + "\u0001\u0000\u0000\u0000\u0000{\u0001\u0000\u0000\u0000\u0000}\u0001\u0000"+ + "\u0000\u0000\u0000\u007f\u0001\u0000\u0000\u0000\u0000\u0081\u0001\u0000"+ + "\u0000\u0000\u0000\u0083\u0001\u0000\u0000\u0000\u0000\u0085\u0001\u0000"+ + "\u0000\u0000\u0000\u0087\u0001\u0000\u0000\u0000\u0000\u0089\u0001\u0000"+ + "\u0000\u0000\u0000\u008b\u0001\u0000\u0000\u0000\u0000\u008d\u0001\u0000"+ + "\u0000\u0000\u0000\u008f\u0001\u0000\u0000\u0000\u0000\u0091\u0001\u0000"+ + "\u0000\u0000\u0000\u0093\u0001\u0000\u0000\u0000\u0000\u0095\u0001\u0000"+ + "\u0000\u0000\u0000\u0097\u0001\u0000\u0000\u0000\u0000\u0099\u0001\u0000"+ + "\u0000\u0000\u0000\u009b\u0001\u0000\u0000\u0000\u0000\u009d\u0001\u0000"+ + "\u0000\u0000\u0000\u009f\u0001\u0000\u0000\u0000\u0000\u00a1\u0001\u0000"+ + "\u0000\u0000\u0000\u00a3\u0001\u0000\u0000\u0000\u0000\u00a5\u0001\u0000"+ + "\u0000\u0000\u0000\u00a7\u0001\u0000\u0000\u0000\u0000\u00a9\u0001\u0000"+ + "\u0000\u0000\u0000\u00ab\u0001\u0000\u0000\u0000\u0000\u00ad\u0001\u0000"+ + "\u0000\u0000\u0000\u00af\u0001\u0000\u0000\u0000\u0000\u00b1\u0001\u0000"+ + "\u0000\u0000\u0000\u00b3\u0001\u0000\u0000\u0000\u0000\u00b5\u0001\u0000"+ + "\u0000\u0000\u0000\u00b7\u0001\u0000\u0000\u0000\u0000\u00b9\u0001\u0000"+ + "\u0000\u0000\u0000\u00bb\u0001\u0000\u0000\u0000\u0000\u00bd\u0001\u0000"+ + "\u0000\u0000\u0000\u00bf\u0001\u0000\u0000\u0000\u0000\u00c1\u0001\u0000"+ + "\u0000\u0000\u0000\u00c3\u0001\u0000\u0000\u0000\u0000\u00c5\u0001\u0000"+ + "\u0000\u0000\u0000\u00c7\u0001\u0000\u0000\u0000\u0000\u00c9\u0001\u0000"+ + "\u0000\u0000\u0000\u00cb\u0001\u0000\u0000\u0000\u0000\u00cd\u0001\u0000"+ + "\u0000\u0000\u0000\u00cf\u0001\u0000\u0000\u0000\u0000\u00d1\u0001\u0000"+ + "\u0000\u0000\u0000\u00d3\u0001\u0000\u0000\u0000\u0000\u00d5\u0001\u0000"+ + "\u0000\u0000\u0000\u00d7\u0001\u0000\u0000\u0000\u0000\u00d9\u0001\u0000"+ + "\u0000\u0000\u0000\u00db\u0001\u0000\u0000\u0000\u0000\u00dd\u0001\u0000"+ + "\u0000\u0000\u0000\u00df\u0001\u0000\u0000\u0000\u0001\u00ef\u0001\u0000"+ + "\u0000\u0000\u0003\u00f8\u0001\u0000\u0000\u0000\u0005\u00ff\u0001\u0000"+ + "\u0000\u0000\u0007\u0107\u0001\u0000\u0000\u0000\t\u010d\u0001\u0000\u0000"+ + "\u0000\u000b\u0112\u0001\u0000\u0000\u0000\r\u0117\u0001\u0000\u0000\u0000"+ + "\u000f\u011d\u0001\u0000\u0000\u0000\u0011\u0122\u0001\u0000\u0000\u0000"+ + "\u0013\u0128\u0001\u0000\u0000\u0000\u0015\u012e\u0001\u0000\u0000\u0000"+ + "\u0017\u0137\u0001\u0000\u0000\u0000\u0019\u013f\u0001\u0000\u0000\u0000"+ + "\u001b\u0142\u0001\u0000\u0000\u0000\u001d\u0149\u0001\u0000\u0000\u0000"+ + "\u001f\u014e\u0001\u0000\u0000\u0000!\u0153\u0001\u0000\u0000\u0000#\u015b"+ + "\u0001\u0000\u0000\u0000%\u0161\u0001\u0000\u0000\u0000\'\u0169\u0001"+ + "\u0000\u0000\u0000)\u016f\u0001\u0000\u0000\u0000+\u0173\u0001\u0000\u0000"+ + "\u0000-\u0176\u0001\u0000\u0000\u0000/\u017b\u0001\u0000\u0000\u00001"+ + "\u0186\u0001\u0000\u0000\u00003\u018d\u0001\u0000\u0000\u00005\u0198\u0001"+ + "\u0000\u0000\u00007\u019c\u0001\u0000\u0000\u00009\u01a6\u0001\u0000\u0000"+ + "\u0000;\u01ab\u0001\u0000\u0000\u0000=\u01b2\u0001\u0000\u0000\u0000?"+ + "\u01b6\u0001\u0000\u0000\u0000A\u01be\u0001\u0000\u0000\u0000C\u01c6\u0001"+ + "\u0000\u0000\u0000E\u01d0\u0001\u0000\u0000\u0000G\u01d7\u0001\u0000\u0000"+ + "\u0000I\u01de\u0001\u0000\u0000\u0000K\u01e4\u0001\u0000\u0000\u0000M"+ + "\u01eb\u0001\u0000\u0000\u0000O\u01f4\u0001\u0000\u0000\u0000Q\u01fa\u0001"+ + "\u0000\u0000\u0000S\u0201\u0001\u0000\u0000\u0000U\u020e\u0001\u0000\u0000"+ + "\u0000W\u0213\u0001\u0000\u0000\u0000Y\u0219\u0001\u0000\u0000\u0000["+ + "\u0220\u0001\u0000\u0000\u0000]\u022a\u0001\u0000\u0000\u0000_\u022e\u0001"+ + "\u0000\u0000\u0000a\u0232\u0001\u0000\u0000\u0000c\u0237\u0001\u0000\u0000"+ + "\u0000e\u0240\u0001\u0000\u0000\u0000g\u0253\u0001\u0000\u0000\u0000i"+ + "\u0258\u0001\u0000\u0000\u0000k\u0267\u0001\u0000\u0000\u0000m\u027b\u0001"+ + "\u0000\u0000\u0000o\u02a1\u0001\u0000\u0000\u0000q\u02a3\u0001\u0000\u0000"+ + "\u0000s\u02c1\u0001\u0000\u0000\u0000u\u02c3\u0001\u0000\u0000\u0000w"+ + "\u02ca\u0001\u0000\u0000\u0000y\u02d4\u0001\u0000\u0000\u0000{\u02d9\u0001"+ + "\u0000\u0000\u0000}\u02db\u0001\u0000\u0000\u0000\u007f\u02dd\u0001\u0000"+ + "\u0000\u0000\u0081\u02df\u0001\u0000\u0000\u0000\u0083\u02e1\u0001\u0000"+ + "\u0000\u0000\u0085\u02e3\u0001\u0000\u0000\u0000\u0087\u02e5\u0001\u0000"+ + "\u0000\u0000\u0089\u02e7\u0001\u0000\u0000\u0000\u008b\u02e9\u0001\u0000"+ + "\u0000\u0000\u008d\u02eb\u0001\u0000\u0000\u0000\u008f\u02ed\u0001\u0000"+ + "\u0000\u0000\u0091\u02ef\u0001\u0000\u0000\u0000\u0093\u02f1\u0001\u0000"+ + "\u0000\u0000\u0095\u02f3\u0001\u0000\u0000\u0000\u0097\u02f5\u0001\u0000"+ + "\u0000\u0000\u0099\u02f7\u0001\u0000\u0000\u0000\u009b\u02f9\u0001\u0000"+ + "\u0000\u0000\u009d\u02fc\u0001\u0000\u0000\u0000\u009f\u02ff\u0001\u0000"+ + "\u0000\u0000\u00a1\u0302\u0001\u0000\u0000\u0000\u00a3\u0305\u0001\u0000"+ + "\u0000\u0000\u00a5\u0308\u0001\u0000\u0000\u0000\u00a7\u030b\u0001\u0000"+ + "\u0000\u0000\u00a9\u030e\u0001\u0000\u0000\u0000\u00ab\u0311\u0001\u0000"+ + "\u0000\u0000\u00ad\u0313\u0001\u0000\u0000\u0000\u00af\u0315\u0001\u0000"+ + "\u0000\u0000\u00b1\u0317\u0001\u0000\u0000\u0000\u00b3\u0319\u0001\u0000"+ + "\u0000\u0000\u00b5\u031b\u0001\u0000\u0000\u0000\u00b7\u031d\u0001\u0000"+ + "\u0000\u0000\u00b9\u031f\u0001\u0000\u0000\u0000\u00bb\u0321\u0001\u0000"+ + "\u0000\u0000\u00bd\u0324\u0001\u0000\u0000\u0000\u00bf\u0327\u0001\u0000"+ + "\u0000\u0000\u00c1\u032a\u0001\u0000\u0000\u0000\u00c3\u032d\u0001\u0000"+ + "\u0000\u0000\u00c5\u0330\u0001\u0000\u0000\u0000\u00c7\u0333\u0001\u0000"+ + "\u0000\u0000\u00c9\u0336\u0001\u0000\u0000\u0000\u00cb\u0339\u0001\u0000"+ + "\u0000\u0000\u00cd\u033d\u0001\u0000\u0000\u0000\u00cf\u0341\u0001\u0000"+ + "\u0000\u0000\u00d1\u0346\u0001\u0000\u0000\u0000\u00d3\u0349\u0001\u0000"+ + "\u0000\u0000\u00d5\u034c\u0001\u0000\u0000\u0000\u00d7\u034e\u0001\u0000"+ + "\u0000\u0000\u00d9\u0353\u0001\u0000\u0000\u0000\u00db\u0359\u0001\u0000"+ + "\u0000\u0000\u00dd\u0367\u0001\u0000\u0000\u0000\u00df\u0372\u0001\u0000"+ + "\u0000\u0000\u00e1\u0379\u0001\u0000\u0000\u0000\u00e3\u0394\u0001\u0000"+ + "\u0000\u0000\u00e5\u0396\u0001\u0000\u0000\u0000\u00e7\u03a1\u0001\u0000"+ + "\u0000\u0000\u00e9\u03a3\u0001\u0000\u0000\u0000\u00eb\u03af\u0001\u0000"+ + "\u0000\u0000\u00ed\u03b5\u0001\u0000\u0000\u0000\u00ef\u00f0\u0005a\u0000"+ + "\u0000\u00f0\u00f1\u0005b\u0000\u0000\u00f1\u00f2\u0005s\u0000\u0000\u00f2"+ + "\u00f3\u0005t\u0000\u0000\u00f3\u00f4\u0005r\u0000\u0000\u00f4\u00f5\u0005"+ + "a\u0000\u0000\u00f5\u00f6\u0005c\u0000\u0000\u00f6\u00f7\u0005t\u0000"+ + "\u0000\u00f7\u0002\u0001\u0000\u0000\u0000\u00f8\u00f9\u0005a\u0000\u0000"+ + "\u00f9\u00fa\u0005s\u0000\u0000\u00fa\u00fb\u0005s\u0000\u0000\u00fb\u00fc"+ + "\u0005e\u0000\u0000\u00fc\u00fd\u0005r\u0000\u0000\u00fd\u00fe\u0005t"+ + "\u0000\u0000\u00fe\u0004\u0001\u0000\u0000\u0000\u00ff\u0100\u0005b\u0000"+ + "\u0000\u0100\u0101\u0005o\u0000\u0000\u0101\u0102\u0005o\u0000\u0000\u0102"+ + "\u0103\u0005l\u0000\u0000\u0103\u0104\u0005e\u0000\u0000\u0104\u0105\u0005"+ + "a\u0000\u0000\u0105\u0106\u0005n\u0000\u0000\u0106\u0006\u0001\u0000\u0000"+ + "\u0000\u0107\u0108\u0005b\u0000\u0000\u0108\u0109\u0005r\u0000\u0000\u0109"+ + "\u010a\u0005e\u0000\u0000\u010a\u010b\u0005a\u0000\u0000\u010b\u010c\u0005"+ + "k\u0000\u0000\u010c\b\u0001\u0000\u0000\u0000\u010d\u010e\u0005b\u0000"+ + "\u0000\u010e\u010f\u0005y\u0000\u0000\u010f\u0110\u0005t\u0000\u0000\u0110"+ + "\u0111\u0005e\u0000\u0000\u0111\n\u0001\u0000\u0000\u0000\u0112\u0113"+ + "\u0005c\u0000\u0000\u0113\u0114\u0005a\u0000\u0000\u0114\u0115\u0005s"+ + "\u0000\u0000\u0115\u0116\u0005e\u0000\u0000\u0116\f\u0001\u0000\u0000"+ + "\u0000\u0117\u0118\u0005c\u0000\u0000\u0118\u0119\u0005a\u0000\u0000\u0119"+ + "\u011a\u0005t\u0000\u0000\u011a\u011b\u0005c\u0000\u0000\u011b\u011c\u0005"+ + "h\u0000\u0000\u011c\u000e\u0001\u0000\u0000\u0000\u011d\u011e\u0005c\u0000"+ + "\u0000\u011e\u011f\u0005h\u0000\u0000\u011f\u0120\u0005a\u0000\u0000\u0120"+ + "\u0121\u0005r\u0000\u0000\u0121\u0010\u0001\u0000\u0000\u0000\u0122\u0123"+ + "\u0005c\u0000\u0000\u0123\u0124\u0005l\u0000\u0000\u0124\u0125\u0005a"+ + "\u0000\u0000\u0125\u0126\u0005s\u0000\u0000\u0126\u0127\u0005s\u0000\u0000"+ + "\u0127\u0012\u0001\u0000\u0000\u0000\u0128\u0129\u0005c\u0000\u0000\u0129"+ + "\u012a\u0005o\u0000\u0000\u012a\u012b\u0005n\u0000\u0000\u012b\u012c\u0005"+ + "s\u0000\u0000\u012c\u012d\u0005t\u0000\u0000\u012d\u0014\u0001\u0000\u0000"+ + "\u0000\u012e\u012f\u0005c\u0000\u0000\u012f\u0130\u0005o\u0000\u0000\u0130"+ + "\u0131\u0005n\u0000\u0000\u0131\u0132\u0005t\u0000\u0000\u0132\u0133\u0005"+ + "i\u0000\u0000\u0133\u0134\u0005n\u0000\u0000\u0134\u0135\u0005u\u0000"+ + "\u0000\u0135\u0136\u0005e\u0000\u0000\u0136\u0016\u0001\u0000\u0000\u0000"+ + "\u0137\u0138\u0005d\u0000\u0000\u0138\u0139\u0005e\u0000\u0000\u0139\u013a"+ + "\u0005f\u0000\u0000\u013a\u013b\u0005a\u0000\u0000\u013b\u013c\u0005u"+ + "\u0000\u0000\u013c\u013d\u0005l\u0000\u0000\u013d\u013e\u0005t\u0000\u0000"+ + "\u013e\u0018\u0001\u0000\u0000\u0000\u013f\u0140\u0005d\u0000\u0000\u0140"+ + "\u0141\u0005o\u0000\u0000\u0141\u001a\u0001\u0000\u0000\u0000\u0142\u0143"+ + "\u0005d\u0000\u0000\u0143\u0144\u0005o\u0000\u0000\u0144\u0145\u0005u"+ + "\u0000\u0000\u0145\u0146\u0005b\u0000\u0000\u0146\u0147\u0005l\u0000\u0000"+ + "\u0147\u0148\u0005e\u0000\u0000\u0148\u001c\u0001\u0000\u0000\u0000\u0149"+ + "\u014a\u0005e\u0000\u0000\u014a\u014b\u0005l\u0000\u0000\u014b\u014c\u0005"+ + "s\u0000\u0000\u014c\u014d\u0005e\u0000\u0000\u014d\u001e\u0001\u0000\u0000"+ + "\u0000\u014e\u014f\u0005e\u0000\u0000\u014f\u0150\u0005n\u0000\u0000\u0150"+ + "\u0151\u0005u\u0000\u0000\u0151\u0152\u0005m\u0000\u0000\u0152 \u0001"+ + "\u0000\u0000\u0000\u0153\u0154\u0005e\u0000\u0000\u0154\u0155\u0005x\u0000"+ + "\u0000\u0155\u0156\u0005t\u0000\u0000\u0156\u0157\u0005e\u0000\u0000\u0157"+ + "\u0158\u0005n\u0000\u0000\u0158\u0159\u0005d\u0000\u0000\u0159\u015a\u0005"+ + "s\u0000\u0000\u015a\"\u0001\u0000\u0000\u0000\u015b\u015c\u0005f\u0000"+ + "\u0000\u015c\u015d\u0005i\u0000\u0000\u015d\u015e\u0005n\u0000\u0000\u015e"+ + "\u015f\u0005a\u0000\u0000\u015f\u0160\u0005l\u0000\u0000\u0160$\u0001"+ + "\u0000\u0000\u0000\u0161\u0162\u0005f\u0000\u0000\u0162\u0163\u0005i\u0000"+ + "\u0000\u0163\u0164\u0005n\u0000\u0000\u0164\u0165\u0005a\u0000\u0000\u0165"+ + "\u0166\u0005l\u0000\u0000\u0166\u0167\u0005l\u0000\u0000\u0167\u0168\u0005"+ + "y\u0000\u0000\u0168&\u0001\u0000\u0000\u0000\u0169\u016a\u0005f\u0000"+ + "\u0000\u016a\u016b\u0005l\u0000\u0000\u016b\u016c\u0005o\u0000\u0000\u016c"+ + "\u016d\u0005a\u0000\u0000\u016d\u016e\u0005t\u0000\u0000\u016e(\u0001"+ + "\u0000\u0000\u0000\u016f\u0170\u0005f\u0000\u0000\u0170\u0171\u0005o\u0000"+ + "\u0000\u0171\u0172\u0005r\u0000\u0000\u0172*\u0001\u0000\u0000\u0000\u0173"+ + "\u0174\u0005i\u0000\u0000\u0174\u0175\u0005f\u0000\u0000\u0175,\u0001"+ + "\u0000\u0000\u0000\u0176\u0177\u0005g\u0000\u0000\u0177\u0178\u0005o\u0000"+ + "\u0000\u0178\u0179\u0005t\u0000\u0000\u0179\u017a\u0005o\u0000\u0000\u017a"+ + ".\u0001\u0000\u0000\u0000\u017b\u017c\u0005i\u0000\u0000\u017c\u017d\u0005"+ + "m\u0000\u0000\u017d\u017e\u0005p\u0000\u0000\u017e\u017f\u0005l\u0000"+ + "\u0000\u017f\u0180\u0005e\u0000\u0000\u0180\u0181\u0005m\u0000\u0000\u0181"+ + "\u0182\u0005e\u0000\u0000\u0182\u0183\u0005n\u0000\u0000\u0183\u0184\u0005"+ + "t\u0000\u0000\u0184\u0185\u0005s\u0000\u0000\u01850\u0001\u0000\u0000"+ + "\u0000\u0186\u0187\u0005i\u0000\u0000\u0187\u0188\u0005m\u0000\u0000\u0188"+ + "\u0189\u0005p\u0000\u0000\u0189\u018a\u0005o\u0000\u0000\u018a\u018b\u0005"+ + "r\u0000\u0000\u018b\u018c\u0005t\u0000\u0000\u018c2\u0001\u0000\u0000"+ + "\u0000\u018d\u018e\u0005i\u0000\u0000\u018e\u018f\u0005n\u0000\u0000\u018f"+ + "\u0190\u0005s\u0000\u0000\u0190\u0191\u0005t\u0000\u0000\u0191\u0192\u0005"+ + "a\u0000\u0000\u0192\u0193\u0005n\u0000\u0000\u0193\u0194\u0005c\u0000"+ + "\u0000\u0194\u0195\u0005e\u0000\u0000\u0195\u0196\u0005o\u0000\u0000\u0196"+ + "\u0197\u0005f\u0000\u0000\u01974\u0001\u0000\u0000\u0000\u0198\u0199\u0005"+ + "i\u0000\u0000\u0199\u019a\u0005n\u0000\u0000\u019a\u019b\u0005t\u0000"+ + "\u0000\u019b6\u0001\u0000\u0000\u0000\u019c\u019d\u0005i\u0000\u0000\u019d"+ + "\u019e\u0005n\u0000\u0000\u019e\u019f\u0005t\u0000\u0000\u019f\u01a0\u0005"+ + "e\u0000\u0000\u01a0\u01a1\u0005r\u0000\u0000\u01a1\u01a2\u0005f\u0000"+ + "\u0000\u01a2\u01a3\u0005a\u0000\u0000\u01a3\u01a4\u0005c\u0000\u0000\u01a4"+ + "\u01a5\u0005e\u0000\u0000\u01a58\u0001\u0000\u0000\u0000\u01a6\u01a7\u0005"+ + "l\u0000\u0000\u01a7\u01a8\u0005o\u0000\u0000\u01a8\u01a9\u0005n\u0000"+ + "\u0000\u01a9\u01aa\u0005g\u0000\u0000\u01aa:\u0001\u0000\u0000\u0000\u01ab"+ + "\u01ac\u0005n\u0000\u0000\u01ac\u01ad\u0005a\u0000\u0000\u01ad\u01ae\u0005"+ + "t\u0000\u0000\u01ae\u01af\u0005i\u0000\u0000\u01af\u01b0\u0005v\u0000"+ + "\u0000\u01b0\u01b1\u0005e\u0000\u0000\u01b1<\u0001\u0000\u0000\u0000\u01b2"+ + "\u01b3\u0005n\u0000\u0000\u01b3\u01b4\u0005e\u0000\u0000\u01b4\u01b5\u0005"+ + "w\u0000\u0000\u01b5>\u0001\u0000\u0000\u0000\u01b6\u01b7\u0005p\u0000"+ + "\u0000\u01b7\u01b8\u0005a\u0000\u0000\u01b8\u01b9\u0005c\u0000\u0000\u01b9"+ + "\u01ba\u0005k\u0000\u0000\u01ba\u01bb\u0005a\u0000\u0000\u01bb\u01bc\u0005"+ + "g\u0000\u0000\u01bc\u01bd\u0005e\u0000\u0000\u01bd@\u0001\u0000\u0000"+ + "\u0000\u01be\u01bf\u0005p\u0000\u0000\u01bf\u01c0\u0005r\u0000\u0000\u01c0"+ + "\u01c1\u0005i\u0000\u0000\u01c1\u01c2\u0005v\u0000\u0000\u01c2\u01c3\u0005"+ + "a\u0000\u0000\u01c3\u01c4\u0005t\u0000\u0000\u01c4\u01c5\u0005e\u0000"+ + "\u0000\u01c5B\u0001\u0000\u0000\u0000\u01c6\u01c7\u0005p\u0000\u0000\u01c7"+ + "\u01c8\u0005r\u0000\u0000\u01c8\u01c9\u0005o\u0000\u0000\u01c9\u01ca\u0005"+ + "t\u0000\u0000\u01ca\u01cb\u0005e\u0000\u0000\u01cb\u01cc\u0005c\u0000"+ + "\u0000\u01cc\u01cd\u0005t\u0000\u0000\u01cd\u01ce\u0005e\u0000\u0000\u01ce"+ + "\u01cf\u0005d\u0000\u0000\u01cfD\u0001\u0000\u0000\u0000\u01d0\u01d1\u0005"+ + "p\u0000\u0000\u01d1\u01d2\u0005u\u0000\u0000\u01d2\u01d3\u0005b\u0000"+ + "\u0000\u01d3\u01d4\u0005l\u0000\u0000\u01d4\u01d5\u0005i\u0000\u0000\u01d5"+ + "\u01d6\u0005c\u0000\u0000\u01d6F\u0001\u0000\u0000\u0000\u01d7\u01d8\u0005"+ + "r\u0000\u0000\u01d8\u01d9\u0005e\u0000\u0000\u01d9\u01da\u0005t\u0000"+ + "\u0000\u01da\u01db\u0005u\u0000\u0000\u01db\u01dc\u0005r\u0000\u0000\u01dc"+ + "\u01dd\u0005n\u0000\u0000\u01ddH\u0001\u0000\u0000\u0000\u01de\u01df\u0005"+ + "s\u0000\u0000\u01df\u01e0\u0005h\u0000\u0000\u01e0\u01e1\u0005o\u0000"+ + "\u0000\u01e1\u01e2\u0005r\u0000\u0000\u01e2\u01e3\u0005t\u0000\u0000\u01e3"+ + "J\u0001\u0000\u0000\u0000\u01e4\u01e5\u0005s\u0000\u0000\u01e5\u01e6\u0005"+ + "t\u0000\u0000\u01e6\u01e7\u0005a\u0000\u0000\u01e7\u01e8\u0005t\u0000"+ + "\u0000\u01e8\u01e9\u0005i\u0000\u0000\u01e9\u01ea\u0005c\u0000\u0000\u01ea"+ + "L\u0001\u0000\u0000\u0000\u01eb\u01ec\u0005s\u0000\u0000\u01ec\u01ed\u0005"+ + "t\u0000\u0000\u01ed\u01ee\u0005r\u0000\u0000\u01ee\u01ef\u0005i\u0000"+ + "\u0000\u01ef\u01f0\u0005c\u0000\u0000\u01f0\u01f1\u0005t\u0000\u0000\u01f1"+ + "\u01f2\u0005f\u0000\u0000\u01f2\u01f3\u0005p\u0000\u0000\u01f3N\u0001"+ + "\u0000\u0000\u0000\u01f4\u01f5\u0005s\u0000\u0000\u01f5\u01f6\u0005u\u0000"+ + "\u0000\u01f6\u01f7\u0005p\u0000\u0000\u01f7\u01f8\u0005e\u0000\u0000\u01f8"+ + "\u01f9\u0005r\u0000\u0000\u01f9P\u0001\u0000\u0000\u0000\u01fa\u01fb\u0005"+ + "s\u0000\u0000\u01fb\u01fc\u0005w\u0000\u0000\u01fc\u01fd\u0005i\u0000"+ + "\u0000\u01fd\u01fe\u0005t\u0000\u0000\u01fe\u01ff\u0005c\u0000\u0000\u01ff"+ + "\u0200\u0005h\u0000\u0000\u0200R\u0001\u0000\u0000\u0000\u0201\u0202\u0005"+ + "s\u0000\u0000\u0202\u0203\u0005y\u0000\u0000\u0203\u0204\u0005n\u0000"+ + "\u0000\u0204\u0205\u0005c\u0000\u0000\u0205\u0206\u0005h\u0000\u0000\u0206"+ + "\u0207\u0005r\u0000\u0000\u0207\u0208\u0005o\u0000\u0000\u0208\u0209\u0005"+ + "n\u0000\u0000\u0209\u020a\u0005i\u0000\u0000\u020a\u020b\u0005z\u0000"+ + "\u0000\u020b\u020c\u0005e\u0000\u0000\u020c\u020d\u0005d\u0000\u0000\u020d"+ + "T\u0001\u0000\u0000\u0000\u020e\u020f\u0005t\u0000\u0000\u020f\u0210\u0005"+ + "h\u0000\u0000\u0210\u0211\u0005i\u0000\u0000\u0211\u0212\u0005s\u0000"+ + "\u0000\u0212V\u0001\u0000\u0000\u0000\u0213\u0214\u0005t\u0000\u0000\u0214"+ + "\u0215\u0005h\u0000\u0000\u0215\u0216\u0005r\u0000\u0000\u0216\u0217\u0005"+ + "o\u0000\u0000\u0217\u0218\u0005w\u0000\u0000\u0218X\u0001\u0000\u0000"+ + "\u0000\u0219\u021a\u0005t\u0000\u0000\u021a\u021b\u0005h\u0000\u0000\u021b"+ + "\u021c\u0005r\u0000\u0000\u021c\u021d\u0005o\u0000\u0000\u021d\u021e\u0005"+ + "w\u0000\u0000\u021e\u021f\u0005s\u0000\u0000\u021fZ\u0001\u0000\u0000"+ + "\u0000\u0220\u0221\u0005t\u0000\u0000\u0221\u0222\u0005r\u0000\u0000\u0222"+ + "\u0223\u0005a\u0000\u0000\u0223\u0224\u0005n\u0000\u0000\u0224\u0225\u0005"+ + "s\u0000\u0000\u0225\u0226\u0005i\u0000\u0000\u0226\u0227\u0005e\u0000"+ + "\u0000\u0227\u0228\u0005n\u0000\u0000\u0228\u0229\u0005t\u0000\u0000\u0229"+ + "\\\u0001\u0000\u0000\u0000\u022a\u022b\u0005t\u0000\u0000\u022b\u022c"+ + "\u0005r\u0000\u0000\u022c\u022d\u0005y\u0000\u0000\u022d^\u0001\u0000"+ + "\u0000\u0000\u022e\u022f\u0005v\u0000\u0000\u022f\u0230\u0005a\u0000\u0000"+ + "\u0230\u0231\u0005r\u0000\u0000\u0231`\u0001\u0000\u0000\u0000\u0232\u0233"+ + "\u0005v\u0000\u0000\u0233\u0234\u0005o\u0000\u0000\u0234\u0235\u0005i"+ + "\u0000\u0000\u0235\u0236\u0005d\u0000\u0000\u0236b\u0001\u0000\u0000\u0000"+ + "\u0237\u0238\u0005v\u0000\u0000\u0238\u0239\u0005o\u0000\u0000\u0239\u023a"+ + "\u0005l\u0000\u0000\u023a\u023b\u0005a\u0000\u0000\u023b\u023c\u0005t"+ + "\u0000\u0000\u023c\u023d\u0005i\u0000\u0000\u023d\u023e\u0005l\u0000\u0000"+ + "\u023e\u023f\u0005e\u0000\u0000\u023fd\u0001\u0000\u0000\u0000\u0240\u0241"+ + "\u0005w\u0000\u0000\u0241\u0242\u0005h\u0000\u0000\u0242\u0243\u0005i"+ + "\u0000\u0000\u0243\u0244\u0005l\u0000\u0000\u0244\u0245\u0005e\u0000\u0000"+ + "\u0245f\u0001\u0000\u0000\u0000\u0246\u0254\u00050\u0000\u0000\u0247\u0251"+ + "\u0007\u0000\u0000\u0000\u0248\u024a\u0003\u00e9t\u0000\u0249\u0248\u0001"+ + "\u0000\u0000\u0000\u0249\u024a\u0001\u0000\u0000\u0000\u024a\u0252\u0001"+ + "\u0000\u0000\u0000\u024b\u024d\u0005_\u0000\u0000\u024c\u024b\u0001\u0000"+ + "\u0000\u0000\u024d\u024e\u0001\u0000\u0000\u0000\u024e\u024c\u0001\u0000"+ + "\u0000\u0000\u024e\u024f\u0001\u0000\u0000\u0000\u024f\u0250\u0001\u0000"+ + "\u0000\u0000\u0250\u0252\u0003\u00e9t\u0000\u0251\u0249\u0001\u0000\u0000"+ + "\u0000\u0251\u024c\u0001\u0000\u0000\u0000\u0252\u0254\u0001\u0000\u0000"+ + "\u0000\u0253\u0246\u0001\u0000\u0000\u0000\u0253\u0247\u0001\u0000\u0000"+ + "\u0000\u0254\u0256\u0001\u0000\u0000\u0000\u0255\u0257\u0007\u0001\u0000"+ + "\u0000\u0256\u0255\u0001\u0000\u0000\u0000\u0256\u0257\u0001\u0000\u0000"+ + "\u0000\u0257h\u0001\u0000\u0000\u0000\u0258\u0259\u00050\u0000\u0000\u0259"+ + "\u025a\u0007\u0002\u0000\u0000\u025a\u0262\u0007\u0003\u0000\u0000\u025b"+ + "\u025d\u0007\u0004\u0000\u0000\u025c\u025b\u0001\u0000\u0000\u0000\u025d"+ + "\u0260\u0001\u0000\u0000\u0000\u025e\u025c\u0001\u0000\u0000\u0000\u025e"+ + "\u025f\u0001\u0000\u0000\u0000\u025f\u0261\u0001\u0000\u0000\u0000\u0260"+ + "\u025e\u0001\u0000\u0000\u0000\u0261\u0263\u0007\u0003\u0000\u0000\u0262"+ + "\u025e\u0001\u0000\u0000\u0000\u0262\u0263\u0001\u0000\u0000\u0000\u0263"+ + "\u0265\u0001\u0000\u0000\u0000\u0264\u0266\u0007\u0001\u0000\u0000\u0265"+ + "\u0264\u0001\u0000\u0000\u0000\u0265\u0266\u0001\u0000\u0000\u0000\u0266"+ + "j\u0001\u0000\u0000\u0000\u0267\u026b\u00050\u0000\u0000\u0268\u026a\u0005"+ + "_\u0000\u0000\u0269\u0268\u0001\u0000\u0000\u0000\u026a\u026d\u0001\u0000"+ + "\u0000\u0000\u026b\u0269\u0001\u0000\u0000\u0000\u026b\u026c\u0001\u0000"+ + "\u0000\u0000\u026c\u026e\u0001\u0000\u0000\u0000\u026d\u026b\u0001\u0000"+ + "\u0000\u0000\u026e\u0276\u0007\u0005\u0000\u0000\u026f\u0271\u0007\u0006"+ + "\u0000\u0000\u0270\u026f\u0001\u0000\u0000\u0000\u0271\u0274\u0001\u0000"+ + "\u0000\u0000\u0272\u0270\u0001\u0000\u0000\u0000\u0272\u0273\u0001\u0000"+ + "\u0000\u0000\u0273\u0275\u0001\u0000\u0000\u0000\u0274\u0272\u0001\u0000"+ + "\u0000\u0000\u0275\u0277\u0007\u0005\u0000\u0000\u0276\u0272\u0001\u0000"+ + "\u0000\u0000\u0276\u0277\u0001\u0000\u0000\u0000\u0277\u0279\u0001\u0000"+ + "\u0000\u0000\u0278\u027a\u0007\u0001\u0000\u0000\u0279\u0278\u0001\u0000"+ + "\u0000\u0000\u0279\u027a\u0001\u0000\u0000\u0000\u027al\u0001\u0000\u0000"+ + "\u0000\u027b\u027c\u00050\u0000\u0000\u027c\u027d\u0007\u0007\u0000\u0000"+ + "\u027d\u0285\u0007\b\u0000\u0000\u027e\u0280\u0007\t\u0000\u0000\u027f"+ + "\u027e\u0001\u0000\u0000\u0000\u0280\u0283\u0001\u0000\u0000\u0000\u0281"+ + "\u027f\u0001\u0000\u0000\u0000\u0281\u0282\u0001\u0000\u0000\u0000\u0282"+ + "\u0284\u0001\u0000\u0000\u0000\u0283\u0281\u0001\u0000\u0000\u0000\u0284"+ + "\u0286\u0007\b\u0000\u0000\u0285\u0281\u0001\u0000\u0000\u0000\u0285\u0286"+ + "\u0001\u0000\u0000\u0000\u0286\u0288\u0001\u0000\u0000\u0000\u0287\u0289"+ + "\u0007\u0001\u0000\u0000\u0288\u0287\u0001\u0000\u0000\u0000\u0288\u0289"+ + "\u0001\u0000\u0000\u0000\u0289n\u0001\u0000\u0000\u0000\u028a\u028b\u0003"+ + "\u00e9t\u0000\u028b\u028d\u0005.\u0000\u0000\u028c\u028e\u0003\u00e9t"+ + "\u0000\u028d\u028c\u0001\u0000\u0000\u0000\u028d\u028e\u0001\u0000\u0000"+ + "\u0000\u028e\u0292\u0001\u0000\u0000\u0000\u028f\u0290\u0005.\u0000\u0000"+ + "\u0290\u0292\u0003\u00e9t\u0000\u0291\u028a\u0001\u0000\u0000\u0000\u0291"+ + "\u028f\u0001\u0000\u0000\u0000\u0292\u0294\u0001\u0000\u0000\u0000\u0293"+ + "\u0295\u0003\u00e1p\u0000\u0294\u0293\u0001\u0000\u0000\u0000\u0294\u0295"+ + "\u0001\u0000\u0000\u0000\u0295\u0297\u0001\u0000\u0000\u0000\u0296\u0298"+ + "\u0007\n\u0000\u0000\u0297\u0296\u0001\u0000\u0000\u0000\u0297\u0298\u0001"+ + "\u0000\u0000\u0000\u0298\u02a2\u0001\u0000\u0000\u0000\u0299\u029f\u0003"+ + "\u00e9t\u0000\u029a\u029c\u0003\u00e1p\u0000\u029b\u029d\u0007\n\u0000"+ + "\u0000\u029c\u029b\u0001\u0000\u0000\u0000\u029c\u029d\u0001\u0000\u0000"+ + "\u0000\u029d\u02a0\u0001\u0000\u0000\u0000\u029e\u02a0\u0007\n\u0000\u0000"+ + "\u029f\u029a\u0001\u0000\u0000\u0000\u029f\u029e\u0001\u0000\u0000\u0000"+ + "\u02a0\u02a2\u0001\u0000\u0000\u0000\u02a1\u0291\u0001\u0000\u0000\u0000"+ + "\u02a1\u0299\u0001\u0000\u0000\u0000\u02a2p\u0001\u0000\u0000\u0000\u02a3"+ + "\u02a4\u00050\u0000\u0000\u02a4\u02ae\u0007\u0002\u0000\u0000\u02a5\u02a7"+ + "\u0003\u00e5r\u0000\u02a6\u02a8\u0005.\u0000\u0000\u02a7\u02a6\u0001\u0000"+ + "\u0000\u0000\u02a7\u02a8\u0001\u0000\u0000\u0000\u02a8\u02af\u0001\u0000"+ + "\u0000\u0000\u02a9\u02ab\u0003\u00e5r\u0000\u02aa\u02a9\u0001\u0000\u0000"+ + "\u0000\u02aa\u02ab\u0001\u0000\u0000\u0000\u02ab\u02ac\u0001\u0000\u0000"+ + "\u0000\u02ac\u02ad\u0005.\u0000\u0000\u02ad\u02af\u0003\u00e5r\u0000\u02ae"+ + "\u02a5\u0001\u0000\u0000\u0000\u02ae\u02aa\u0001\u0000\u0000\u0000\u02af"+ + "\u02b0\u0001\u0000\u0000\u0000\u02b0\u02b2\u0007\u000b\u0000\u0000\u02b1"+ + "\u02b3\u0007\f\u0000\u0000\u02b2\u02b1\u0001\u0000\u0000\u0000\u02b2\u02b3"+ + "\u0001\u0000\u0000\u0000\u02b3\u02b4\u0001\u0000\u0000\u0000\u02b4\u02b6"+ + "\u0003\u00e9t\u0000\u02b5\u02b7\u0007\n\u0000\u0000\u02b6\u02b5\u0001"+ + "\u0000\u0000\u0000\u02b6\u02b7\u0001\u0000\u0000\u0000\u02b7r\u0001\u0000"+ + "\u0000\u0000\u02b8\u02b9\u0005t\u0000\u0000\u02b9\u02ba\u0005r\u0000\u0000"+ + "\u02ba\u02bb\u0005u\u0000\u0000\u02bb\u02c2\u0005e\u0000\u0000\u02bc\u02bd"+ + "\u0005f\u0000\u0000\u02bd\u02be\u0005a\u0000\u0000\u02be\u02bf\u0005l"+ + "\u0000\u0000\u02bf\u02c0\u0005s\u0000\u0000\u02c0\u02c2\u0005e\u0000\u0000"+ + "\u02c1\u02b8\u0001\u0000\u0000\u0000\u02c1\u02bc\u0001\u0000\u0000\u0000"+ + "\u02c2t\u0001\u0000\u0000\u0000\u02c3\u02c6\u0005\'\u0000\u0000\u02c4"+ + "\u02c7\b\r\u0000\u0000\u02c5\u02c7\u0003\u00e3q\u0000\u02c6\u02c4\u0001"+ + "\u0000\u0000\u0000\u02c6\u02c5\u0001\u0000\u0000\u0000\u02c7\u02c8\u0001"+ + "\u0000\u0000\u0000\u02c8\u02c9\u0005\'\u0000\u0000\u02c9v\u0001\u0000"+ + "\u0000\u0000\u02ca\u02cf\u0005\"\u0000\u0000\u02cb\u02ce\b\u000e\u0000"+ + "\u0000\u02cc\u02ce\u0003\u00e3q\u0000\u02cd\u02cb\u0001\u0000\u0000\u0000"+ + "\u02cd\u02cc\u0001\u0000\u0000\u0000\u02ce\u02d1\u0001\u0000\u0000\u0000"+ + "\u02cf\u02cd\u0001\u0000\u0000\u0000\u02cf\u02d0\u0001\u0000\u0000\u0000"+ + "\u02d0\u02d2\u0001\u0000\u0000\u0000\u02d1\u02cf\u0001\u0000\u0000\u0000"+ + "\u02d2\u02d3\u0005\"\u0000\u0000\u02d3x\u0001\u0000\u0000\u0000\u02d4"+ + "\u02d5\u0005n\u0000\u0000\u02d5\u02d6\u0005u\u0000\u0000\u02d6\u02d7\u0005"+ + "l\u0000\u0000\u02d7\u02d8\u0005l\u0000\u0000\u02d8z\u0001\u0000\u0000"+ + "\u0000\u02d9\u02da\u0005(\u0000\u0000\u02da|\u0001\u0000\u0000\u0000\u02db"+ + "\u02dc\u0005)\u0000\u0000\u02dc~\u0001\u0000\u0000\u0000\u02dd\u02de\u0005"+ + "{\u0000\u0000\u02de\u0080\u0001\u0000\u0000\u0000\u02df\u02e0\u0005}\u0000"+ + "\u0000\u02e0\u0082\u0001\u0000\u0000\u0000\u02e1\u02e2\u0005[\u0000\u0000"+ + "\u02e2\u0084\u0001\u0000\u0000\u0000\u02e3\u02e4\u0005]\u0000\u0000\u02e4"+ + "\u0086\u0001\u0000\u0000\u0000\u02e5\u02e6\u0005;\u0000\u0000\u02e6\u0088"+ + "\u0001\u0000\u0000\u0000\u02e7\u02e8\u0005,\u0000\u0000\u02e8\u008a\u0001"+ + "\u0000\u0000\u0000\u02e9\u02ea\u0005.\u0000\u0000\u02ea\u008c\u0001\u0000"+ + "\u0000\u0000\u02eb\u02ec\u0005=\u0000\u0000\u02ec\u008e\u0001\u0000\u0000"+ + "\u0000\u02ed\u02ee\u0005>\u0000\u0000\u02ee\u0090\u0001\u0000\u0000\u0000"+ + "\u02ef\u02f0\u0005<\u0000\u0000\u02f0\u0092\u0001\u0000\u0000\u0000\u02f1"+ + "\u02f2\u0005!\u0000\u0000\u02f2\u0094\u0001\u0000\u0000\u0000\u02f3\u02f4"+ + "\u0005~\u0000\u0000\u02f4\u0096\u0001\u0000\u0000\u0000\u02f5\u02f6\u0005"+ + "?\u0000\u0000\u02f6\u0098\u0001\u0000\u0000\u0000\u02f7\u02f8\u0005:\u0000"+ + "\u0000\u02f8\u009a\u0001\u0000\u0000\u0000\u02f9\u02fa\u0005=\u0000\u0000"+ + "\u02fa\u02fb\u0005=\u0000\u0000\u02fb\u009c\u0001\u0000\u0000\u0000\u02fc"+ + "\u02fd\u0005<\u0000\u0000\u02fd\u02fe\u0005=\u0000\u0000\u02fe\u009e\u0001"+ + "\u0000\u0000\u0000\u02ff\u0300\u0005>\u0000\u0000\u0300\u0301\u0005=\u0000"+ + "\u0000\u0301\u00a0\u0001\u0000\u0000\u0000\u0302\u0303\u0005!\u0000\u0000"+ + "\u0303\u0304\u0005=\u0000\u0000\u0304\u00a2\u0001\u0000\u0000\u0000\u0305"+ + "\u0306\u0005&\u0000\u0000\u0306\u0307\u0005&\u0000\u0000\u0307\u00a4\u0001"+ + "\u0000\u0000\u0000\u0308\u0309\u0005|\u0000\u0000\u0309\u030a\u0005|\u0000"+ + "\u0000\u030a\u00a6\u0001\u0000\u0000\u0000\u030b\u030c\u0005+\u0000\u0000"+ + "\u030c\u030d\u0005+\u0000\u0000\u030d\u00a8\u0001\u0000\u0000\u0000\u030e"+ + "\u030f\u0005-\u0000\u0000\u030f\u0310\u0005-\u0000\u0000\u0310\u00aa\u0001"+ + "\u0000\u0000\u0000\u0311\u0312\u0005+\u0000\u0000\u0312\u00ac\u0001\u0000"+ + "\u0000\u0000\u0313\u0314\u0005-\u0000\u0000\u0314\u00ae\u0001\u0000\u0000"+ + "\u0000\u0315\u0316\u0005*\u0000\u0000\u0316\u00b0\u0001\u0000\u0000\u0000"+ + "\u0317\u0318\u0005/\u0000\u0000\u0318\u00b2\u0001\u0000\u0000\u0000\u0319"+ + "\u031a\u0005&\u0000\u0000\u031a\u00b4\u0001\u0000\u0000\u0000\u031b\u031c"+ + "\u0005|\u0000\u0000\u031c\u00b6\u0001\u0000\u0000\u0000\u031d\u031e\u0005"+ + "^\u0000\u0000\u031e\u00b8\u0001\u0000\u0000\u0000\u031f\u0320\u0005%\u0000"+ + "\u0000\u0320\u00ba\u0001\u0000\u0000\u0000\u0321\u0322\u0005+\u0000\u0000"+ + "\u0322\u0323\u0005=\u0000\u0000\u0323\u00bc\u0001\u0000\u0000\u0000\u0324"+ + "\u0325\u0005-\u0000\u0000\u0325\u0326\u0005=\u0000\u0000\u0326\u00be\u0001"+ + "\u0000\u0000\u0000\u0327\u0328\u0005*\u0000\u0000\u0328\u0329\u0005=\u0000"+ + "\u0000\u0329\u00c0\u0001\u0000\u0000\u0000\u032a\u032b\u0005/\u0000\u0000"+ + "\u032b\u032c\u0005=\u0000\u0000\u032c\u00c2\u0001\u0000\u0000\u0000\u032d"+ + "\u032e\u0005&\u0000\u0000\u032e\u032f\u0005=\u0000\u0000\u032f\u00c4\u0001"+ + "\u0000\u0000\u0000\u0330\u0331\u0005|\u0000\u0000\u0331\u0332\u0005=\u0000"+ + "\u0000\u0332\u00c6\u0001\u0000\u0000\u0000\u0333\u0334\u0005^\u0000\u0000"+ + "\u0334\u0335\u0005=\u0000\u0000\u0335\u00c8\u0001\u0000\u0000\u0000\u0336"+ + "\u0337\u0005%\u0000\u0000\u0337\u0338\u0005=\u0000\u0000\u0338\u00ca\u0001"+ + "\u0000\u0000\u0000\u0339\u033a\u0005<\u0000\u0000\u033a\u033b\u0005<\u0000"+ + "\u0000\u033b\u033c\u0005=\u0000\u0000\u033c\u00cc\u0001\u0000\u0000\u0000"+ + "\u033d\u033e\u0005>\u0000\u0000\u033e\u033f\u0005>\u0000\u0000\u033f\u0340"+ + "\u0005=\u0000\u0000\u0340\u00ce\u0001\u0000\u0000\u0000\u0341\u0342\u0005"+ + ">\u0000\u0000\u0342\u0343\u0005>\u0000\u0000\u0343\u0344\u0005>\u0000"+ + "\u0000\u0344\u0345\u0005=\u0000\u0000\u0345\u00d0\u0001\u0000\u0000\u0000"+ + "\u0346\u0347\u0005-\u0000\u0000\u0347\u0348\u0005>\u0000\u0000\u0348\u00d2"+ + "\u0001\u0000\u0000\u0000\u0349\u034a\u0005:\u0000\u0000\u034a\u034b\u0005"+ + ":\u0000\u0000\u034b\u00d4\u0001\u0000\u0000\u0000\u034c\u034d\u0005@\u0000"+ + "\u0000\u034d\u00d6\u0001\u0000\u0000\u0000\u034e\u034f\u0005.\u0000\u0000"+ + "\u034f\u0350\u0005.\u0000\u0000\u0350\u0351\u0005.\u0000\u0000\u0351\u00d8"+ + "\u0001\u0000\u0000\u0000\u0352\u0354\u0007\u000f\u0000\u0000\u0353\u0352"+ + "\u0001\u0000\u0000\u0000\u0354\u0355\u0001\u0000\u0000\u0000\u0355\u0353"+ + "\u0001\u0000\u0000\u0000\u0355\u0356\u0001\u0000\u0000\u0000\u0356\u0357"+ + "\u0001\u0000\u0000\u0000\u0357\u0358\u0006l\u0000\u0000\u0358\u00da\u0001"+ + "\u0000\u0000\u0000\u0359\u035a\u0005/\u0000\u0000\u035a\u035b\u0005*\u0000"+ + "\u0000\u035b\u035f\u0001\u0000\u0000\u0000\u035c\u035e\t\u0000\u0000\u0000"+ + "\u035d\u035c\u0001\u0000\u0000\u0000\u035e\u0361\u0001\u0000\u0000\u0000"+ + "\u035f\u0360\u0001\u0000\u0000\u0000\u035f\u035d\u0001\u0000\u0000\u0000"+ + "\u0360\u0362\u0001\u0000\u0000\u0000\u0361\u035f\u0001\u0000\u0000\u0000"+ + "\u0362\u0363\u0005*\u0000\u0000\u0363\u0364\u0005/\u0000\u0000\u0364\u0365"+ + "\u0001\u0000\u0000\u0000\u0365\u0366\u0006m\u0000\u0000\u0366\u00dc\u0001"+ + "\u0000\u0000\u0000\u0367\u0368\u0005/\u0000\u0000\u0368\u0369\u0005/\u0000"+ + "\u0000\u0369\u036d\u0001\u0000\u0000\u0000\u036a\u036c\b\u0010\u0000\u0000"+ + "\u036b\u036a\u0001\u0000\u0000\u0000\u036c\u036f\u0001\u0000\u0000\u0000"+ + "\u036d\u036b\u0001\u0000\u0000\u0000\u036d\u036e\u0001\u0000\u0000\u0000"+ + "\u036e\u0370\u0001\u0000\u0000\u0000\u036f\u036d\u0001\u0000\u0000\u0000"+ + "\u0370\u0371\u0006n\u0000\u0000\u0371\u00de\u0001\u0000\u0000\u0000\u0372"+ + "\u0376\u0003\u00edv\u0000\u0373\u0375\u0003\u00ebu\u0000\u0374\u0373\u0001"+ + "\u0000\u0000\u0000\u0375\u0378\u0001\u0000\u0000\u0000\u0376\u0374\u0001"+ + "\u0000\u0000\u0000\u0376\u0377\u0001\u0000\u0000\u0000\u0377\u00e0\u0001"+ + "\u0000\u0000\u0000\u0378\u0376\u0001\u0000\u0000\u0000\u0379\u037b\u0007"+ + "\u0011\u0000\u0000\u037a\u037c\u0007\f\u0000\u0000\u037b\u037a\u0001\u0000"+ + "\u0000\u0000\u037b\u037c\u0001\u0000\u0000\u0000\u037c\u037d\u0001\u0000"+ + "\u0000\u0000\u037d\u037e\u0003\u00e9t\u0000\u037e\u00e2\u0001\u0000\u0000"+ + "\u0000\u037f\u0380\u0005\\\u0000\u0000\u0380\u0395\u0007\u0012\u0000\u0000"+ + "\u0381\u0386\u0005\\\u0000\u0000\u0382\u0384\u0007\u0013\u0000\u0000\u0383"+ + "\u0382\u0001\u0000\u0000\u0000\u0383\u0384\u0001\u0000\u0000\u0000\u0384"+ + "\u0385\u0001\u0000\u0000\u0000\u0385\u0387\u0007\u0005\u0000\u0000\u0386"+ + "\u0383\u0001\u0000\u0000\u0000\u0386\u0387\u0001\u0000\u0000\u0000\u0387"+ + "\u0388\u0001\u0000\u0000\u0000\u0388\u0395\u0007\u0005\u0000\u0000\u0389"+ + "\u038b\u0005\\\u0000\u0000\u038a\u038c\u0005u\u0000\u0000\u038b\u038a"+ + "\u0001\u0000\u0000\u0000\u038c\u038d\u0001\u0000\u0000\u0000\u038d\u038b"+ + "\u0001\u0000\u0000\u0000\u038d\u038e\u0001\u0000\u0000\u0000\u038e\u038f"+ + "\u0001\u0000\u0000\u0000\u038f\u0390\u0003\u00e7s\u0000\u0390\u0391\u0003"+ + "\u00e7s\u0000\u0391\u0392\u0003\u00e7s\u0000\u0392\u0393\u0003\u00e7s"+ + "\u0000\u0393\u0395\u0001\u0000\u0000\u0000\u0394\u037f\u0001\u0000\u0000"+ + "\u0000\u0394\u0381\u0001\u0000\u0000\u0000\u0394\u0389\u0001\u0000\u0000"+ + "\u0000\u0395\u00e4\u0001\u0000\u0000\u0000\u0396\u039f\u0003\u00e7s\u0000"+ + "\u0397\u039a\u0003\u00e7s\u0000\u0398\u039a\u0005_\u0000\u0000\u0399\u0397"+ + "\u0001\u0000\u0000\u0000\u0399\u0398\u0001\u0000\u0000\u0000\u039a\u039d"+ + "\u0001\u0000\u0000\u0000\u039b\u0399\u0001\u0000\u0000\u0000\u039b\u039c"+ + "\u0001\u0000\u0000\u0000\u039c\u039e\u0001\u0000\u0000\u0000\u039d\u039b"+ + "\u0001\u0000\u0000\u0000\u039e\u03a0\u0003\u00e7s\u0000\u039f\u039b\u0001"+ + "\u0000\u0000\u0000\u039f\u03a0\u0001\u0000\u0000\u0000\u03a0\u00e6\u0001"+ + "\u0000\u0000\u0000\u03a1\u03a2\u0007\u0003\u0000\u0000\u03a2\u00e8\u0001"+ + "\u0000\u0000\u0000\u03a3\u03ab\u0007\u0014\u0000\u0000\u03a4\u03a6\u0007"+ + "\u0015\u0000\u0000\u03a5\u03a4\u0001\u0000\u0000\u0000\u03a6\u03a9\u0001"+ + "\u0000\u0000\u0000\u03a7\u03a5\u0001\u0000\u0000\u0000\u03a7\u03a8\u0001"+ + "\u0000\u0000\u0000\u03a8\u03aa\u0001\u0000\u0000\u0000\u03a9\u03a7\u0001"+ + "\u0000\u0000\u0000\u03aa\u03ac\u0007\u0014\u0000\u0000\u03ab\u03a7\u0001"+ + "\u0000\u0000\u0000\u03ab\u03ac\u0001\u0000\u0000\u0000\u03ac\u00ea\u0001"+ + "\u0000\u0000\u0000\u03ad\u03b0\u0003\u00edv\u0000\u03ae\u03b0\u0007\u0014"+ + "\u0000\u0000\u03af\u03ad\u0001\u0000\u0000\u0000\u03af\u03ae\u0001\u0000"+ + "\u0000\u0000\u03b0\u00ec\u0001\u0000\u0000\u0000\u03b1\u03b6\u0007\u0016"+ + "\u0000\u0000\u03b2\u03b6\b\u0017\u0000\u0000\u03b3\u03b4\u0007\u0018\u0000"+ + "\u0000\u03b4\u03b6\u0007\u0019\u0000\u0000\u03b5\u03b1\u0001\u0000\u0000"+ + "\u0000\u03b5\u03b2\u0001\u0000\u0000\u0000\u03b5\u03b3\u0001\u0000\u0000"+ + "\u0000\u03b6\u00ee\u0001\u0000\u0000\u00000\u0000\u0249\u024e\u0251\u0253"+ + "\u0256\u025e\u0262\u0265\u026b\u0272\u0276\u0279\u0281\u0285\u0288\u028d"+ + "\u0291\u0294\u0297\u029c\u029f\u02a1\u02a7\u02aa\u02ae\u02b2\u02b6\u02c1"+ + "\u02c6\u02cd\u02cf\u0355\u035f\u036d\u0376\u037b\u0383\u0386\u038d\u0394"+ + "\u0399\u039b\u039f\u03a7\u03ab\u03af\u03b5\u0001\u0000\u0001\u0000"; + public static final ATN _ATN = + new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } +} \ No newline at end of file diff --git a/lexers/src/main/gen/com/itsaky/androidide/lexers/java/JavaLexer.tokens b/lexers/src/main/gen/com/itsaky/androidide/lexers/java/JavaLexer.tokens new file mode 100644 index 000000000..e94649840 --- /dev/null +++ b/lexers/src/main/gen/com/itsaky/androidide/lexers/java/JavaLexer.tokens @@ -0,0 +1,211 @@ +ABSTRACT=1 +ASSERT=2 +BOOLEAN=3 +BREAK=4 +BYTE=5 +CASE=6 +CATCH=7 +CHAR=8 +CLASS=9 +CONST=10 +CONTINUE=11 +DEFAULT=12 +DO=13 +DOUBLE=14 +ELSE=15 +ENUM=16 +EXTENDS=17 +FINAL=18 +FINALLY=19 +FLOAT=20 +FOR=21 +IF=22 +GOTO=23 +IMPLEMENTS=24 +IMPORT=25 +INSTANCEOF=26 +INT=27 +INTERFACE=28 +LONG=29 +NATIVE=30 +NEW=31 +PACKAGE=32 +PRIVATE=33 +PROTECTED=34 +PUBLIC=35 +RETURN=36 +SHORT=37 +STATIC=38 +STRICTFP=39 +SUPER=40 +SWITCH=41 +SYNCHRONIZED=42 +THIS=43 +THROW=44 +THROWS=45 +TRANSIENT=46 +TRY=47 +VAR=48 +VOID=49 +VOLATILE=50 +WHILE=51 +DECIMAL_LITERAL=52 +HEX_LITERAL=53 +OCT_LITERAL=54 +BINARY_LITERAL=55 +FLOAT_LITERAL=56 +HEX_FLOAT_LITERAL=57 +BOOL_LITERAL=58 +CHAR_LITERAL=59 +STRING_LITERAL=60 +NULL_LITERAL=61 +LPAREN=62 +RPAREN=63 +LBRACE=64 +RBRACE=65 +LBRACK=66 +RBRACK=67 +SEMI=68 +COMMA=69 +DOT=70 +ASSIGN=71 +GT=72 +LT=73 +BANG=74 +TILDE=75 +QUESTION=76 +COLON=77 +EQUAL=78 +LE=79 +GE=80 +NOTEQUAL=81 +AND=82 +OR=83 +INC=84 +DEC=85 +ADD=86 +SUB=87 +MUL=88 +DIV=89 +BITAND=90 +BITOR=91 +CARET=92 +MOD=93 +ADD_ASSIGN=94 +SUB_ASSIGN=95 +MUL_ASSIGN=96 +DIV_ASSIGN=97 +AND_ASSIGN=98 +OR_ASSIGN=99 +XOR_ASSIGN=100 +MOD_ASSIGN=101 +LSHIFT_ASSIGN=102 +RSHIFT_ASSIGN=103 +URSHIFT_ASSIGN=104 +ARROW=105 +COLONCOLON=106 +AT=107 +ELLIPSIS=108 +WS=109 +BLOCK_COMMENT=110 +LINE_COMMENT=111 +IDENTIFIER=112 +'abstract'=1 +'assert'=2 +'boolean'=3 +'break'=4 +'byte'=5 +'case'=6 +'catch'=7 +'char'=8 +'class'=9 +'const'=10 +'continue'=11 +'default'=12 +'do'=13 +'double'=14 +'else'=15 +'enum'=16 +'extends'=17 +'final'=18 +'finally'=19 +'float'=20 +'for'=21 +'if'=22 +'goto'=23 +'implements'=24 +'import'=25 +'instanceof'=26 +'int'=27 +'interface'=28 +'long'=29 +'native'=30 +'new'=31 +'package'=32 +'private'=33 +'protected'=34 +'public'=35 +'return'=36 +'short'=37 +'static'=38 +'strictfp'=39 +'super'=40 +'switch'=41 +'synchronized'=42 +'this'=43 +'throw'=44 +'throws'=45 +'transient'=46 +'try'=47 +'var'=48 +'void'=49 +'volatile'=50 +'while'=51 +'null'=61 +'('=62 +')'=63 +'{'=64 +'}'=65 +'['=66 +']'=67 +';'=68 +','=69 +'.'=70 +'='=71 +'>'=72 +'<'=73 +'!'=74 +'~'=75 +'?'=76 +':'=77 +'=='=78 +'<='=79 +'>='=80 +'!='=81 +'&&'=82 +'||'=83 +'++'=84 +'--'=85 +'+'=86 +'-'=87 +'*'=88 +'/'=89 +'&'=90 +'|'=91 +'^'=92 +'%'=93 +'+='=94 +'-='=95 +'*='=96 +'/='=97 +'&='=98 +'|='=99 +'^='=100 +'%='=101 +'<<='=102 +'>>='=103 +'>>>='=104 +'->'=105 +'::'=106 +'@'=107 +'...'=108 diff --git a/lexers/src/main/gen/com/itsaky/androidide/lexers/java/JavaParser.interp b/lexers/src/main/gen/com/itsaky/androidide/lexers/java/JavaParser.interp new file mode 100644 index 000000000..5c8d47046 --- /dev/null +++ b/lexers/src/main/gen/com/itsaky/androidide/lexers/java/JavaParser.interp @@ -0,0 +1,340 @@ +token literal names: +null +'abstract' +'assert' +'boolean' +'break' +'byte' +'case' +'catch' +'char' +'class' +'const' +'continue' +'default' +'do' +'double' +'else' +'enum' +'extends' +'final' +'finally' +'float' +'for' +'if' +'goto' +'implements' +'import' +'instanceof' +'int' +'interface' +'long' +'native' +'new' +'package' +'private' +'protected' +'public' +'return' +'short' +'static' +'strictfp' +'super' +'switch' +'synchronized' +'this' +'throw' +'throws' +'transient' +'try' +'var' +'void' +'volatile' +'while' +null +null +null +null +null +null +null +null +null +'null' +'(' +')' +'{' +'}' +'[' +']' +';' +',' +'.' +'=' +'>' +'<' +'!' +'~' +'?' +':' +'==' +'<=' +'>=' +'!=' +'&&' +'||' +'++' +'--' +'+' +'-' +'*' +'/' +'&' +'|' +'^' +'%' +'+=' +'-=' +'*=' +'/=' +'&=' +'|=' +'^=' +'%=' +'<<=' +'>>=' +'>>>=' +'->' +'::' +'@' +'...' +null +null +null +null + +token symbolic names: +null +ABSTRACT +ASSERT +BOOLEAN +BREAK +BYTE +CASE +CATCH +CHAR +CLASS +CONST +CONTINUE +DEFAULT +DO +DOUBLE +ELSE +ENUM +EXTENDS +FINAL +FINALLY +FLOAT +FOR +IF +GOTO +IMPLEMENTS +IMPORT +INSTANCEOF +INT +INTERFACE +LONG +NATIVE +NEW +PACKAGE +PRIVATE +PROTECTED +PUBLIC +RETURN +SHORT +STATIC +STRICTFP +SUPER +SWITCH +SYNCHRONIZED +THIS +THROW +THROWS +TRANSIENT +TRY +VAR +VOID +VOLATILE +WHILE +DECIMAL_LITERAL +HEX_LITERAL +OCT_LITERAL +BINARY_LITERAL +FLOAT_LITERAL +HEX_FLOAT_LITERAL +BOOL_LITERAL +CHAR_LITERAL +STRING_LITERAL +NULL_LITERAL +LPAREN +RPAREN +LBRACE +RBRACE +LBRACK +RBRACK +SEMI +COMMA +DOT +ASSIGN +GT +LT +BANG +TILDE +QUESTION +COLON +EQUAL +LE +GE +NOTEQUAL +AND +OR +INC +DEC +ADD +SUB +MUL +DIV +BITAND +BITOR +CARET +MOD +ADD_ASSIGN +SUB_ASSIGN +MUL_ASSIGN +DIV_ASSIGN +AND_ASSIGN +OR_ASSIGN +XOR_ASSIGN +MOD_ASSIGN +LSHIFT_ASSIGN +RSHIFT_ASSIGN +URSHIFT_ASSIGN +ARROW +COLONCOLON +AT +ELLIPSIS +WS +BLOCK_COMMENT +LINE_COMMENT +IDENTIFIER + +rule names: +compilationUnit +packageDeclaration +importDeclaration +typeDeclaration +modifier +classOrInterfaceModifier +variableModifier +classDeclaration +typeParameters +typeParameter +typeBound +enumDeclaration +enumConstants +enumConstant +enumBodyDeclarations +interfaceDeclaration +classBody +interfaceBody +classBodyDeclaration +memberDeclaration +methodDeclaration +methodBody +typeTypeOrVoid +genericMethodDeclaration +genericConstructorDeclaration +constructorDeclaration +fieldDeclaration +interfaceBodyDeclaration +interfaceMemberDeclaration +constDeclaration +constantDeclarator +interfaceMethodDeclaration +interfaceMethodModifier +genericInterfaceMethodDeclaration +variableDeclarators +variableDeclarator +variableDeclaratorId +variableInitializer +arrayInitializer +classOrInterfaceType +typeArgument +qualifiedNameList +formalParameters +formalParameterList +formalParameter +lastFormalParameter +qualifiedName +literal +integerLiteral +floatLiteral +altAnnotationQualifiedName +annotation +elementValuePairs +elementValuePair +elementValue +elementValueArrayInitializer +annotationTypeDeclaration +annotationTypeBody +annotationTypeElementDeclaration +annotationTypeElementRest +annotationMethodOrConstantRest +annotationMethodRest +annotationConstantRest +defaultValue +block +blockStatement +localVariableDeclaration +localTypeDeclaration +statement +catchClause +catchType +finallyBlock +resourceSpecification +resources +resource +switchBlockStatementGroup +switchLabel +forControl +forInit +enhancedForControl +parExpression +expressionList +methodCall +expression +lambdaExpression +lambdaParameters +lambdaBody +primary +classType +creator +createdName +innerCreator +arrayCreatorRest +classCreatorRest +explicitGenericInvocation +typeArgumentsOrDiamond +nonWildcardTypeArgumentsOrDiamond +nonWildcardTypeArguments +typeList +typeType +primitiveType +typeArguments +superSuffix +explicitGenericInvocationSuffix +arguments + + +atn: +[4, 1, 112, 1437, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2, 104, 7, 104, 1, 0, 3, 0, 212, 8, 0, 1, 0, 5, 0, 215, 8, 0, 10, 0, 12, 0, 218, 9, 0, 1, 0, 5, 0, 221, 8, 0, 10, 0, 12, 0, 224, 9, 0, 1, 0, 1, 0, 1, 1, 5, 1, 229, 8, 1, 10, 1, 12, 1, 232, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 2, 3, 2, 240, 8, 2, 1, 2, 1, 2, 1, 2, 3, 2, 245, 8, 2, 1, 2, 1, 2, 1, 3, 5, 3, 250, 8, 3, 10, 3, 12, 3, 253, 9, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, 3, 259, 8, 3, 1, 3, 3, 3, 262, 8, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 3, 4, 269, 8, 4, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 3, 5, 279, 8, 5, 1, 6, 1, 6, 3, 6, 283, 8, 6, 1, 7, 1, 7, 1, 7, 3, 7, 288, 8, 7, 1, 7, 1, 7, 3, 7, 292, 8, 7, 1, 7, 1, 7, 3, 7, 296, 8, 7, 1, 7, 1, 7, 1, 8, 1, 8, 1, 8, 1, 8, 5, 8, 304, 8, 8, 10, 8, 12, 8, 307, 9, 8, 1, 8, 1, 8, 1, 9, 5, 9, 312, 8, 9, 10, 9, 12, 9, 315, 9, 9, 1, 9, 1, 9, 1, 9, 5, 9, 320, 8, 9, 10, 9, 12, 9, 323, 9, 9, 1, 9, 3, 9, 326, 8, 9, 1, 10, 1, 10, 1, 10, 5, 10, 331, 8, 10, 10, 10, 12, 10, 334, 9, 10, 1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 340, 8, 11, 1, 11, 1, 11, 3, 11, 344, 8, 11, 1, 11, 3, 11, 347, 8, 11, 1, 11, 3, 11, 350, 8, 11, 1, 11, 1, 11, 1, 12, 1, 12, 1, 12, 5, 12, 357, 8, 12, 10, 12, 12, 12, 360, 9, 12, 1, 13, 5, 13, 363, 8, 13, 10, 13, 12, 13, 366, 9, 13, 1, 13, 1, 13, 3, 13, 370, 8, 13, 1, 13, 3, 13, 373, 8, 13, 1, 14, 1, 14, 5, 14, 377, 8, 14, 10, 14, 12, 14, 380, 9, 14, 1, 15, 1, 15, 1, 15, 3, 15, 385, 8, 15, 1, 15, 1, 15, 3, 15, 389, 8, 15, 1, 15, 1, 15, 1, 16, 1, 16, 5, 16, 395, 8, 16, 10, 16, 12, 16, 398, 9, 16, 1, 16, 1, 16, 1, 17, 1, 17, 5, 17, 404, 8, 17, 10, 17, 12, 17, 407, 9, 17, 1, 17, 1, 17, 1, 18, 1, 18, 3, 18, 413, 8, 18, 1, 18, 1, 18, 5, 18, 417, 8, 18, 10, 18, 12, 18, 420, 9, 18, 1, 18, 3, 18, 423, 8, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 3, 19, 434, 8, 19, 1, 20, 1, 20, 1, 20, 1, 20, 1, 20, 5, 20, 441, 8, 20, 10, 20, 12, 20, 444, 9, 20, 1, 20, 1, 20, 3, 20, 448, 8, 20, 1, 20, 1, 20, 1, 21, 1, 21, 3, 21, 454, 8, 21, 1, 22, 1, 22, 3, 22, 458, 8, 22, 1, 23, 1, 23, 1, 23, 1, 24, 1, 24, 1, 24, 1, 25, 1, 25, 1, 25, 1, 25, 3, 25, 470, 8, 25, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 27, 5, 27, 479, 8, 27, 10, 27, 12, 27, 482, 9, 27, 1, 27, 1, 27, 3, 27, 486, 8, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1, 28, 3, 28, 495, 8, 28, 1, 29, 1, 29, 1, 29, 1, 29, 5, 29, 501, 8, 29, 10, 29, 12, 29, 504, 9, 29, 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, 5, 30, 511, 8, 30, 10, 30, 12, 30, 514, 9, 30, 1, 30, 1, 30, 1, 30, 1, 31, 5, 31, 520, 8, 31, 10, 31, 12, 31, 523, 9, 31, 1, 31, 1, 31, 1, 31, 5, 31, 528, 8, 31, 10, 31, 12, 31, 531, 9, 31, 1, 31, 1, 31, 3, 31, 535, 8, 31, 1, 31, 1, 31, 1, 31, 1, 31, 5, 31, 541, 8, 31, 10, 31, 12, 31, 544, 9, 31, 1, 31, 1, 31, 3, 31, 548, 8, 31, 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 558, 8, 32, 1, 33, 1, 33, 1, 33, 1, 34, 1, 34, 1, 34, 5, 34, 566, 8, 34, 10, 34, 12, 34, 569, 9, 34, 1, 35, 1, 35, 1, 35, 3, 35, 574, 8, 35, 1, 36, 1, 36, 1, 36, 5, 36, 579, 8, 36, 10, 36, 12, 36, 582, 9, 36, 1, 37, 1, 37, 3, 37, 586, 8, 37, 1, 38, 1, 38, 1, 38, 1, 38, 5, 38, 592, 8, 38, 10, 38, 12, 38, 595, 9, 38, 1, 38, 3, 38, 598, 8, 38, 3, 38, 600, 8, 38, 1, 38, 1, 38, 1, 39, 1, 39, 3, 39, 606, 8, 39, 1, 39, 1, 39, 1, 39, 3, 39, 611, 8, 39, 5, 39, 613, 8, 39, 10, 39, 12, 39, 616, 9, 39, 1, 40, 1, 40, 5, 40, 620, 8, 40, 10, 40, 12, 40, 623, 9, 40, 1, 40, 1, 40, 1, 40, 3, 40, 628, 8, 40, 3, 40, 630, 8, 40, 1, 41, 1, 41, 1, 41, 5, 41, 635, 8, 41, 10, 41, 12, 41, 638, 9, 41, 1, 42, 1, 42, 3, 42, 642, 8, 42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 43, 5, 43, 649, 8, 43, 10, 43, 12, 43, 652, 9, 43, 1, 43, 1, 43, 3, 43, 656, 8, 43, 1, 43, 3, 43, 659, 8, 43, 1, 44, 5, 44, 662, 8, 44, 10, 44, 12, 44, 665, 9, 44, 1, 44, 1, 44, 1, 44, 1, 45, 5, 45, 671, 8, 45, 10, 45, 12, 45, 674, 9, 45, 1, 45, 1, 45, 5, 45, 678, 8, 45, 10, 45, 12, 45, 681, 9, 45, 1, 45, 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 5, 46, 689, 8, 46, 10, 46, 12, 46, 692, 9, 46, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 3, 47, 700, 8, 47, 1, 48, 1, 48, 1, 49, 1, 49, 1, 50, 1, 50, 5, 50, 708, 8, 50, 10, 50, 12, 50, 711, 9, 50, 1, 50, 1, 50, 1, 50, 1, 51, 1, 51, 1, 51, 3, 51, 719, 8, 51, 1, 51, 1, 51, 1, 51, 3, 51, 724, 8, 51, 1, 51, 3, 51, 727, 8, 51, 1, 52, 1, 52, 1, 52, 5, 52, 732, 8, 52, 10, 52, 12, 52, 735, 9, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 54, 1, 54, 1, 54, 3, 54, 744, 8, 54, 1, 55, 1, 55, 1, 55, 1, 55, 5, 55, 750, 8, 55, 10, 55, 12, 55, 753, 9, 55, 3, 55, 755, 8, 55, 1, 55, 3, 55, 758, 8, 55, 1, 55, 1, 55, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 57, 1, 57, 5, 57, 769, 8, 57, 10, 57, 12, 57, 772, 9, 57, 1, 57, 1, 57, 1, 58, 5, 58, 777, 8, 58, 10, 58, 12, 58, 780, 9, 58, 1, 58, 1, 58, 3, 58, 784, 8, 58, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 3, 59, 792, 8, 59, 1, 59, 1, 59, 3, 59, 796, 8, 59, 1, 59, 1, 59, 3, 59, 800, 8, 59, 1, 59, 1, 59, 3, 59, 804, 8, 59, 3, 59, 806, 8, 59, 1, 60, 1, 60, 3, 60, 810, 8, 60, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 816, 8, 61, 1, 62, 1, 62, 1, 63, 1, 63, 1, 63, 1, 64, 1, 64, 5, 64, 825, 8, 64, 10, 64, 12, 64, 828, 9, 64, 1, 64, 1, 64, 1, 65, 1, 65, 1, 65, 1, 65, 1, 65, 3, 65, 837, 8, 65, 1, 66, 5, 66, 840, 8, 66, 10, 66, 12, 66, 843, 9, 66, 1, 66, 1, 66, 1, 66, 1, 67, 5, 67, 849, 8, 67, 10, 67, 12, 67, 852, 9, 67, 1, 67, 1, 67, 3, 67, 856, 8, 67, 1, 67, 3, 67, 859, 8, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 866, 8, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 875, 8, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 4, 68, 896, 8, 68, 11, 68, 12, 68, 897, 1, 68, 3, 68, 901, 8, 68, 1, 68, 3, 68, 904, 8, 68, 1, 68, 1, 68, 1, 68, 1, 68, 5, 68, 910, 8, 68, 10, 68, 12, 68, 913, 9, 68, 1, 68, 3, 68, 916, 8, 68, 1, 68, 1, 68, 1, 68, 1, 68, 5, 68, 922, 8, 68, 10, 68, 12, 68, 925, 9, 68, 1, 68, 5, 68, 928, 8, 68, 10, 68, 12, 68, 931, 9, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 941, 8, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 950, 8, 68, 1, 68, 1, 68, 1, 68, 3, 68, 955, 8, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 3, 68, 965, 8, 68, 1, 69, 1, 69, 1, 69, 5, 69, 970, 8, 69, 10, 69, 12, 69, 973, 9, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69, 1, 70, 1, 70, 1, 70, 5, 70, 983, 8, 70, 10, 70, 12, 70, 986, 9, 70, 1, 71, 1, 71, 1, 71, 1, 72, 1, 72, 1, 72, 3, 72, 994, 8, 72, 1, 72, 1, 72, 1, 73, 1, 73, 1, 73, 5, 73, 1001, 8, 73, 10, 73, 12, 73, 1004, 9, 73, 1, 74, 5, 74, 1007, 8, 74, 10, 74, 12, 74, 1010, 9, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 74, 1, 75, 4, 75, 1018, 8, 75, 11, 75, 12, 75, 1019, 1, 75, 4, 75, 1023, 8, 75, 11, 75, 12, 75, 1024, 1, 76, 1, 76, 1, 76, 3, 76, 1030, 8, 76, 1, 76, 1, 76, 1, 76, 3, 76, 1035, 8, 76, 1, 77, 1, 77, 3, 77, 1039, 8, 77, 1, 77, 1, 77, 3, 77, 1043, 8, 77, 1, 77, 1, 77, 3, 77, 1047, 8, 77, 3, 77, 1049, 8, 77, 1, 78, 1, 78, 3, 78, 1053, 8, 78, 1, 79, 5, 79, 1056, 8, 79, 10, 79, 12, 79, 1059, 9, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 5, 81, 1073, 8, 81, 10, 81, 12, 81, 1076, 9, 81, 1, 82, 1, 82, 1, 82, 3, 82, 1081, 8, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 1087, 8, 82, 1, 82, 1, 82, 1, 82, 1, 82, 3, 82, 1093, 8, 82, 1, 82, 3, 82, 1096, 8, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 5, 83, 1105, 8, 83, 10, 83, 12, 83, 1108, 9, 83, 1, 83, 1, 83, 1, 83, 5, 83, 1113, 8, 83, 10, 83, 12, 83, 1116, 9, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 3, 83, 1129, 8, 83, 1, 83, 1, 83, 3, 83, 1133, 8, 83, 1, 83, 1, 83, 1, 83, 3, 83, 1138, 8, 83, 1, 83, 1, 83, 3, 83, 1142, 8, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 3, 83, 1158, 8, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 3, 83, 1198, 8, 83, 1, 83, 1, 83, 1, 83, 1, 83, 3, 83, 1204, 8, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 3, 83, 1219, 8, 83, 1, 83, 5, 83, 1222, 8, 83, 10, 83, 12, 83, 1225, 9, 83, 1, 84, 1, 84, 1, 84, 1, 84, 1, 85, 1, 85, 1, 85, 3, 85, 1234, 8, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 5, 85, 1241, 8, 85, 10, 85, 12, 85, 1244, 9, 85, 1, 85, 3, 85, 1247, 8, 85, 1, 86, 1, 86, 3, 86, 1251, 8, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 3, 87, 1269, 8, 87, 3, 87, 1271, 8, 87, 1, 88, 1, 88, 1, 88, 3, 88, 1276, 8, 88, 1, 88, 5, 88, 1279, 8, 88, 10, 88, 12, 88, 1282, 9, 88, 1, 88, 1, 88, 3, 88, 1286, 8, 88, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 3, 89, 1295, 8, 89, 3, 89, 1297, 8, 89, 1, 90, 1, 90, 3, 90, 1301, 8, 90, 1, 90, 1, 90, 1, 90, 3, 90, 1306, 8, 90, 5, 90, 1308, 8, 90, 10, 90, 12, 90, 1311, 9, 90, 1, 90, 3, 90, 1314, 8, 90, 1, 91, 1, 91, 3, 91, 1318, 8, 91, 1, 91, 1, 91, 1, 92, 1, 92, 1, 92, 1, 92, 5, 92, 1326, 8, 92, 10, 92, 12, 92, 1329, 9, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 5, 92, 1338, 8, 92, 10, 92, 12, 92, 1341, 9, 92, 1, 92, 1, 92, 5, 92, 1345, 8, 92, 10, 92, 12, 92, 1348, 9, 92, 3, 92, 1350, 8, 92, 1, 93, 1, 93, 3, 93, 1354, 8, 93, 1, 94, 1, 94, 1, 94, 1, 95, 1, 95, 1, 95, 3, 95, 1362, 8, 95, 1, 96, 1, 96, 1, 96, 3, 96, 1367, 8, 96, 1, 97, 1, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 5, 98, 1376, 8, 98, 10, 98, 12, 98, 1379, 9, 98, 1, 99, 5, 99, 1382, 8, 99, 10, 99, 12, 99, 1385, 9, 99, 1, 99, 1, 99, 3, 99, 1389, 8, 99, 1, 99, 5, 99, 1392, 8, 99, 10, 99, 12, 99, 1395, 9, 99, 1, 99, 1, 99, 5, 99, 1399, 8, 99, 10, 99, 12, 99, 1402, 9, 99, 1, 100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 5, 101, 1410, 8, 101, 10, 101, 12, 101, 1413, 9, 101, 1, 101, 1, 101, 1, 102, 1, 102, 1, 102, 1, 102, 3, 102, 1421, 8, 102, 3, 102, 1423, 8, 102, 1, 103, 1, 103, 1, 103, 1, 103, 3, 103, 1429, 8, 103, 1, 104, 1, 104, 3, 104, 1433, 8, 104, 1, 104, 1, 104, 1, 104, 0, 1, 166, 105, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 206, 208, 0, 12, 2, 0, 17, 17, 40, 40, 1, 0, 52, 55, 1, 0, 56, 57, 1, 0, 84, 87, 1, 0, 74, 75, 2, 0, 88, 89, 93, 93, 1, 0, 86, 87, 2, 0, 72, 73, 79, 80, 2, 0, 78, 78, 81, 81, 2, 0, 71, 71, 94, 104, 1, 0, 84, 85, 8, 0, 3, 3, 5, 5, 8, 8, 14, 14, 20, 20, 27, 27, 29, 29, 37, 37, 1597, 0, 211, 1, 0, 0, 0, 2, 230, 1, 0, 0, 0, 4, 237, 1, 0, 0, 0, 6, 261, 1, 0, 0, 0, 8, 268, 1, 0, 0, 0, 10, 278, 1, 0, 0, 0, 12, 282, 1, 0, 0, 0, 14, 284, 1, 0, 0, 0, 16, 299, 1, 0, 0, 0, 18, 313, 1, 0, 0, 0, 20, 327, 1, 0, 0, 0, 22, 335, 1, 0, 0, 0, 24, 353, 1, 0, 0, 0, 26, 364, 1, 0, 0, 0, 28, 374, 1, 0, 0, 0, 30, 381, 1, 0, 0, 0, 32, 392, 1, 0, 0, 0, 34, 401, 1, 0, 0, 0, 36, 422, 1, 0, 0, 0, 38, 433, 1, 0, 0, 0, 40, 435, 1, 0, 0, 0, 42, 453, 1, 0, 0, 0, 44, 457, 1, 0, 0, 0, 46, 459, 1, 0, 0, 0, 48, 462, 1, 0, 0, 0, 50, 465, 1, 0, 0, 0, 52, 473, 1, 0, 0, 0, 54, 485, 1, 0, 0, 0, 56, 494, 1, 0, 0, 0, 58, 496, 1, 0, 0, 0, 60, 507, 1, 0, 0, 0, 62, 521, 1, 0, 0, 0, 64, 557, 1, 0, 0, 0, 66, 559, 1, 0, 0, 0, 68, 562, 1, 0, 0, 0, 70, 570, 1, 0, 0, 0, 72, 575, 1, 0, 0, 0, 74, 585, 1, 0, 0, 0, 76, 587, 1, 0, 0, 0, 78, 603, 1, 0, 0, 0, 80, 629, 1, 0, 0, 0, 82, 631, 1, 0, 0, 0, 84, 639, 1, 0, 0, 0, 86, 658, 1, 0, 0, 0, 88, 663, 1, 0, 0, 0, 90, 672, 1, 0, 0, 0, 92, 685, 1, 0, 0, 0, 94, 699, 1, 0, 0, 0, 96, 701, 1, 0, 0, 0, 98, 703, 1, 0, 0, 0, 100, 709, 1, 0, 0, 0, 102, 718, 1, 0, 0, 0, 104, 728, 1, 0, 0, 0, 106, 736, 1, 0, 0, 0, 108, 743, 1, 0, 0, 0, 110, 745, 1, 0, 0, 0, 112, 761, 1, 0, 0, 0, 114, 766, 1, 0, 0, 0, 116, 783, 1, 0, 0, 0, 118, 805, 1, 0, 0, 0, 120, 809, 1, 0, 0, 0, 122, 811, 1, 0, 0, 0, 124, 817, 1, 0, 0, 0, 126, 819, 1, 0, 0, 0, 128, 822, 1, 0, 0, 0, 130, 836, 1, 0, 0, 0, 132, 841, 1, 0, 0, 0, 134, 858, 1, 0, 0, 0, 136, 964, 1, 0, 0, 0, 138, 966, 1, 0, 0, 0, 140, 979, 1, 0, 0, 0, 142, 987, 1, 0, 0, 0, 144, 990, 1, 0, 0, 0, 146, 997, 1, 0, 0, 0, 148, 1008, 1, 0, 0, 0, 150, 1017, 1, 0, 0, 0, 152, 1034, 1, 0, 0, 0, 154, 1048, 1, 0, 0, 0, 156, 1052, 1, 0, 0, 0, 158, 1057, 1, 0, 0, 0, 160, 1065, 1, 0, 0, 0, 162, 1069, 1, 0, 0, 0, 164, 1095, 1, 0, 0, 0, 166, 1141, 1, 0, 0, 0, 168, 1226, 1, 0, 0, 0, 170, 1246, 1, 0, 0, 0, 172, 1250, 1, 0, 0, 0, 174, 1270, 1, 0, 0, 0, 176, 1275, 1, 0, 0, 0, 178, 1296, 1, 0, 0, 0, 180, 1313, 1, 0, 0, 0, 182, 1315, 1, 0, 0, 0, 184, 1321, 1, 0, 0, 0, 186, 1351, 1, 0, 0, 0, 188, 1355, 1, 0, 0, 0, 190, 1361, 1, 0, 0, 0, 192, 1366, 1, 0, 0, 0, 194, 1368, 1, 0, 0, 0, 196, 1372, 1, 0, 0, 0, 198, 1383, 1, 0, 0, 0, 200, 1403, 1, 0, 0, 0, 202, 1405, 1, 0, 0, 0, 204, 1422, 1, 0, 0, 0, 206, 1428, 1, 0, 0, 0, 208, 1430, 1, 0, 0, 0, 210, 212, 3, 2, 1, 0, 211, 210, 1, 0, 0, 0, 211, 212, 1, 0, 0, 0, 212, 216, 1, 0, 0, 0, 213, 215, 3, 4, 2, 0, 214, 213, 1, 0, 0, 0, 215, 218, 1, 0, 0, 0, 216, 214, 1, 0, 0, 0, 216, 217, 1, 0, 0, 0, 217, 222, 1, 0, 0, 0, 218, 216, 1, 0, 0, 0, 219, 221, 3, 6, 3, 0, 220, 219, 1, 0, 0, 0, 221, 224, 1, 0, 0, 0, 222, 220, 1, 0, 0, 0, 222, 223, 1, 0, 0, 0, 223, 225, 1, 0, 0, 0, 224, 222, 1, 0, 0, 0, 225, 226, 5, 0, 0, 1, 226, 1, 1, 0, 0, 0, 227, 229, 3, 102, 51, 0, 228, 227, 1, 0, 0, 0, 229, 232, 1, 0, 0, 0, 230, 228, 1, 0, 0, 0, 230, 231, 1, 0, 0, 0, 231, 233, 1, 0, 0, 0, 232, 230, 1, 0, 0, 0, 233, 234, 5, 32, 0, 0, 234, 235, 3, 92, 46, 0, 235, 236, 5, 68, 0, 0, 236, 3, 1, 0, 0, 0, 237, 239, 5, 25, 0, 0, 238, 240, 5, 38, 0, 0, 239, 238, 1, 0, 0, 0, 239, 240, 1, 0, 0, 0, 240, 241, 1, 0, 0, 0, 241, 244, 3, 92, 46, 0, 242, 243, 5, 70, 0, 0, 243, 245, 5, 88, 0, 0, 244, 242, 1, 0, 0, 0, 244, 245, 1, 0, 0, 0, 245, 246, 1, 0, 0, 0, 246, 247, 5, 68, 0, 0, 247, 5, 1, 0, 0, 0, 248, 250, 3, 10, 5, 0, 249, 248, 1, 0, 0, 0, 250, 253, 1, 0, 0, 0, 251, 249, 1, 0, 0, 0, 251, 252, 1, 0, 0, 0, 252, 258, 1, 0, 0, 0, 253, 251, 1, 0, 0, 0, 254, 259, 3, 14, 7, 0, 255, 259, 3, 22, 11, 0, 256, 259, 3, 30, 15, 0, 257, 259, 3, 112, 56, 0, 258, 254, 1, 0, 0, 0, 258, 255, 1, 0, 0, 0, 258, 256, 1, 0, 0, 0, 258, 257, 1, 0, 0, 0, 259, 262, 1, 0, 0, 0, 260, 262, 5, 68, 0, 0, 261, 251, 1, 0, 0, 0, 261, 260, 1, 0, 0, 0, 262, 7, 1, 0, 0, 0, 263, 269, 3, 10, 5, 0, 264, 269, 5, 30, 0, 0, 265, 269, 5, 42, 0, 0, 266, 269, 5, 46, 0, 0, 267, 269, 5, 50, 0, 0, 268, 263, 1, 0, 0, 0, 268, 264, 1, 0, 0, 0, 268, 265, 1, 0, 0, 0, 268, 266, 1, 0, 0, 0, 268, 267, 1, 0, 0, 0, 269, 9, 1, 0, 0, 0, 270, 279, 3, 102, 51, 0, 271, 279, 5, 35, 0, 0, 272, 279, 5, 34, 0, 0, 273, 279, 5, 33, 0, 0, 274, 279, 5, 38, 0, 0, 275, 279, 5, 1, 0, 0, 276, 279, 5, 18, 0, 0, 277, 279, 5, 39, 0, 0, 278, 270, 1, 0, 0, 0, 278, 271, 1, 0, 0, 0, 278, 272, 1, 0, 0, 0, 278, 273, 1, 0, 0, 0, 278, 274, 1, 0, 0, 0, 278, 275, 1, 0, 0, 0, 278, 276, 1, 0, 0, 0, 278, 277, 1, 0, 0, 0, 279, 11, 1, 0, 0, 0, 280, 283, 5, 18, 0, 0, 281, 283, 3, 102, 51, 0, 282, 280, 1, 0, 0, 0, 282, 281, 1, 0, 0, 0, 283, 13, 1, 0, 0, 0, 284, 285, 5, 9, 0, 0, 285, 287, 5, 112, 0, 0, 286, 288, 3, 16, 8, 0, 287, 286, 1, 0, 0, 0, 287, 288, 1, 0, 0, 0, 288, 291, 1, 0, 0, 0, 289, 290, 5, 17, 0, 0, 290, 292, 3, 198, 99, 0, 291, 289, 1, 0, 0, 0, 291, 292, 1, 0, 0, 0, 292, 295, 1, 0, 0, 0, 293, 294, 5, 24, 0, 0, 294, 296, 3, 196, 98, 0, 295, 293, 1, 0, 0, 0, 295, 296, 1, 0, 0, 0, 296, 297, 1, 0, 0, 0, 297, 298, 3, 32, 16, 0, 298, 15, 1, 0, 0, 0, 299, 300, 5, 73, 0, 0, 300, 305, 3, 18, 9, 0, 301, 302, 5, 69, 0, 0, 302, 304, 3, 18, 9, 0, 303, 301, 1, 0, 0, 0, 304, 307, 1, 0, 0, 0, 305, 303, 1, 0, 0, 0, 305, 306, 1, 0, 0, 0, 306, 308, 1, 0, 0, 0, 307, 305, 1, 0, 0, 0, 308, 309, 5, 72, 0, 0, 309, 17, 1, 0, 0, 0, 310, 312, 3, 102, 51, 0, 311, 310, 1, 0, 0, 0, 312, 315, 1, 0, 0, 0, 313, 311, 1, 0, 0, 0, 313, 314, 1, 0, 0, 0, 314, 316, 1, 0, 0, 0, 315, 313, 1, 0, 0, 0, 316, 325, 5, 112, 0, 0, 317, 321, 5, 17, 0, 0, 318, 320, 3, 102, 51, 0, 319, 318, 1, 0, 0, 0, 320, 323, 1, 0, 0, 0, 321, 319, 1, 0, 0, 0, 321, 322, 1, 0, 0, 0, 322, 324, 1, 0, 0, 0, 323, 321, 1, 0, 0, 0, 324, 326, 3, 20, 10, 0, 325, 317, 1, 0, 0, 0, 325, 326, 1, 0, 0, 0, 326, 19, 1, 0, 0, 0, 327, 332, 3, 198, 99, 0, 328, 329, 5, 90, 0, 0, 329, 331, 3, 198, 99, 0, 330, 328, 1, 0, 0, 0, 331, 334, 1, 0, 0, 0, 332, 330, 1, 0, 0, 0, 332, 333, 1, 0, 0, 0, 333, 21, 1, 0, 0, 0, 334, 332, 1, 0, 0, 0, 335, 336, 5, 16, 0, 0, 336, 339, 5, 112, 0, 0, 337, 338, 5, 24, 0, 0, 338, 340, 3, 196, 98, 0, 339, 337, 1, 0, 0, 0, 339, 340, 1, 0, 0, 0, 340, 341, 1, 0, 0, 0, 341, 343, 5, 64, 0, 0, 342, 344, 3, 24, 12, 0, 343, 342, 1, 0, 0, 0, 343, 344, 1, 0, 0, 0, 344, 346, 1, 0, 0, 0, 345, 347, 5, 69, 0, 0, 346, 345, 1, 0, 0, 0, 346, 347, 1, 0, 0, 0, 347, 349, 1, 0, 0, 0, 348, 350, 3, 28, 14, 0, 349, 348, 1, 0, 0, 0, 349, 350, 1, 0, 0, 0, 350, 351, 1, 0, 0, 0, 351, 352, 5, 65, 0, 0, 352, 23, 1, 0, 0, 0, 353, 358, 3, 26, 13, 0, 354, 355, 5, 69, 0, 0, 355, 357, 3, 26, 13, 0, 356, 354, 1, 0, 0, 0, 357, 360, 1, 0, 0, 0, 358, 356, 1, 0, 0, 0, 358, 359, 1, 0, 0, 0, 359, 25, 1, 0, 0, 0, 360, 358, 1, 0, 0, 0, 361, 363, 3, 102, 51, 0, 362, 361, 1, 0, 0, 0, 363, 366, 1, 0, 0, 0, 364, 362, 1, 0, 0, 0, 364, 365, 1, 0, 0, 0, 365, 367, 1, 0, 0, 0, 366, 364, 1, 0, 0, 0, 367, 369, 5, 112, 0, 0, 368, 370, 3, 208, 104, 0, 369, 368, 1, 0, 0, 0, 369, 370, 1, 0, 0, 0, 370, 372, 1, 0, 0, 0, 371, 373, 3, 32, 16, 0, 372, 371, 1, 0, 0, 0, 372, 373, 1, 0, 0, 0, 373, 27, 1, 0, 0, 0, 374, 378, 5, 68, 0, 0, 375, 377, 3, 36, 18, 0, 376, 375, 1, 0, 0, 0, 377, 380, 1, 0, 0, 0, 378, 376, 1, 0, 0, 0, 378, 379, 1, 0, 0, 0, 379, 29, 1, 0, 0, 0, 380, 378, 1, 0, 0, 0, 381, 382, 5, 28, 0, 0, 382, 384, 5, 112, 0, 0, 383, 385, 3, 16, 8, 0, 384, 383, 1, 0, 0, 0, 384, 385, 1, 0, 0, 0, 385, 388, 1, 0, 0, 0, 386, 387, 5, 17, 0, 0, 387, 389, 3, 196, 98, 0, 388, 386, 1, 0, 0, 0, 388, 389, 1, 0, 0, 0, 389, 390, 1, 0, 0, 0, 390, 391, 3, 34, 17, 0, 391, 31, 1, 0, 0, 0, 392, 396, 5, 64, 0, 0, 393, 395, 3, 36, 18, 0, 394, 393, 1, 0, 0, 0, 395, 398, 1, 0, 0, 0, 396, 394, 1, 0, 0, 0, 396, 397, 1, 0, 0, 0, 397, 399, 1, 0, 0, 0, 398, 396, 1, 0, 0, 0, 399, 400, 5, 65, 0, 0, 400, 33, 1, 0, 0, 0, 401, 405, 5, 64, 0, 0, 402, 404, 3, 54, 27, 0, 403, 402, 1, 0, 0, 0, 404, 407, 1, 0, 0, 0, 405, 403, 1, 0, 0, 0, 405, 406, 1, 0, 0, 0, 406, 408, 1, 0, 0, 0, 407, 405, 1, 0, 0, 0, 408, 409, 5, 65, 0, 0, 409, 35, 1, 0, 0, 0, 410, 423, 5, 68, 0, 0, 411, 413, 5, 38, 0, 0, 412, 411, 1, 0, 0, 0, 412, 413, 1, 0, 0, 0, 413, 414, 1, 0, 0, 0, 414, 423, 3, 128, 64, 0, 415, 417, 3, 8, 4, 0, 416, 415, 1, 0, 0, 0, 417, 420, 1, 0, 0, 0, 418, 416, 1, 0, 0, 0, 418, 419, 1, 0, 0, 0, 419, 421, 1, 0, 0, 0, 420, 418, 1, 0, 0, 0, 421, 423, 3, 38, 19, 0, 422, 410, 1, 0, 0, 0, 422, 412, 1, 0, 0, 0, 422, 418, 1, 0, 0, 0, 423, 37, 1, 0, 0, 0, 424, 434, 3, 40, 20, 0, 425, 434, 3, 46, 23, 0, 426, 434, 3, 52, 26, 0, 427, 434, 3, 50, 25, 0, 428, 434, 3, 48, 24, 0, 429, 434, 3, 30, 15, 0, 430, 434, 3, 112, 56, 0, 431, 434, 3, 14, 7, 0, 432, 434, 3, 22, 11, 0, 433, 424, 1, 0, 0, 0, 433, 425, 1, 0, 0, 0, 433, 426, 1, 0, 0, 0, 433, 427, 1, 0, 0, 0, 433, 428, 1, 0, 0, 0, 433, 429, 1, 0, 0, 0, 433, 430, 1, 0, 0, 0, 433, 431, 1, 0, 0, 0, 433, 432, 1, 0, 0, 0, 434, 39, 1, 0, 0, 0, 435, 436, 3, 44, 22, 0, 436, 437, 5, 112, 0, 0, 437, 442, 3, 84, 42, 0, 438, 439, 5, 66, 0, 0, 439, 441, 5, 67, 0, 0, 440, 438, 1, 0, 0, 0, 441, 444, 1, 0, 0, 0, 442, 440, 1, 0, 0, 0, 442, 443, 1, 0, 0, 0, 443, 447, 1, 0, 0, 0, 444, 442, 1, 0, 0, 0, 445, 446, 5, 45, 0, 0, 446, 448, 3, 82, 41, 0, 447, 445, 1, 0, 0, 0, 447, 448, 1, 0, 0, 0, 448, 449, 1, 0, 0, 0, 449, 450, 3, 42, 21, 0, 450, 41, 1, 0, 0, 0, 451, 454, 3, 128, 64, 0, 452, 454, 5, 68, 0, 0, 453, 451, 1, 0, 0, 0, 453, 452, 1, 0, 0, 0, 454, 43, 1, 0, 0, 0, 455, 458, 3, 198, 99, 0, 456, 458, 5, 49, 0, 0, 457, 455, 1, 0, 0, 0, 457, 456, 1, 0, 0, 0, 458, 45, 1, 0, 0, 0, 459, 460, 3, 16, 8, 0, 460, 461, 3, 40, 20, 0, 461, 47, 1, 0, 0, 0, 462, 463, 3, 16, 8, 0, 463, 464, 3, 50, 25, 0, 464, 49, 1, 0, 0, 0, 465, 466, 5, 112, 0, 0, 466, 469, 3, 84, 42, 0, 467, 468, 5, 45, 0, 0, 468, 470, 3, 82, 41, 0, 469, 467, 1, 0, 0, 0, 469, 470, 1, 0, 0, 0, 470, 471, 1, 0, 0, 0, 471, 472, 3, 128, 64, 0, 472, 51, 1, 0, 0, 0, 473, 474, 3, 198, 99, 0, 474, 475, 3, 68, 34, 0, 475, 476, 5, 68, 0, 0, 476, 53, 1, 0, 0, 0, 477, 479, 3, 8, 4, 0, 478, 477, 1, 0, 0, 0, 479, 482, 1, 0, 0, 0, 480, 478, 1, 0, 0, 0, 480, 481, 1, 0, 0, 0, 481, 483, 1, 0, 0, 0, 482, 480, 1, 0, 0, 0, 483, 486, 3, 56, 28, 0, 484, 486, 5, 68, 0, 0, 485, 480, 1, 0, 0, 0, 485, 484, 1, 0, 0, 0, 486, 55, 1, 0, 0, 0, 487, 495, 3, 58, 29, 0, 488, 495, 3, 62, 31, 0, 489, 495, 3, 66, 33, 0, 490, 495, 3, 30, 15, 0, 491, 495, 3, 112, 56, 0, 492, 495, 3, 14, 7, 0, 493, 495, 3, 22, 11, 0, 494, 487, 1, 0, 0, 0, 494, 488, 1, 0, 0, 0, 494, 489, 1, 0, 0, 0, 494, 490, 1, 0, 0, 0, 494, 491, 1, 0, 0, 0, 494, 492, 1, 0, 0, 0, 494, 493, 1, 0, 0, 0, 495, 57, 1, 0, 0, 0, 496, 497, 3, 198, 99, 0, 497, 502, 3, 60, 30, 0, 498, 499, 5, 69, 0, 0, 499, 501, 3, 60, 30, 0, 500, 498, 1, 0, 0, 0, 501, 504, 1, 0, 0, 0, 502, 500, 1, 0, 0, 0, 502, 503, 1, 0, 0, 0, 503, 505, 1, 0, 0, 0, 504, 502, 1, 0, 0, 0, 505, 506, 5, 68, 0, 0, 506, 59, 1, 0, 0, 0, 507, 512, 5, 112, 0, 0, 508, 509, 5, 66, 0, 0, 509, 511, 5, 67, 0, 0, 510, 508, 1, 0, 0, 0, 511, 514, 1, 0, 0, 0, 512, 510, 1, 0, 0, 0, 512, 513, 1, 0, 0, 0, 513, 515, 1, 0, 0, 0, 514, 512, 1, 0, 0, 0, 515, 516, 5, 71, 0, 0, 516, 517, 3, 74, 37, 0, 517, 61, 1, 0, 0, 0, 518, 520, 3, 64, 32, 0, 519, 518, 1, 0, 0, 0, 520, 523, 1, 0, 0, 0, 521, 519, 1, 0, 0, 0, 521, 522, 1, 0, 0, 0, 522, 534, 1, 0, 0, 0, 523, 521, 1, 0, 0, 0, 524, 535, 3, 44, 22, 0, 525, 529, 3, 16, 8, 0, 526, 528, 3, 102, 51, 0, 527, 526, 1, 0, 0, 0, 528, 531, 1, 0, 0, 0, 529, 527, 1, 0, 0, 0, 529, 530, 1, 0, 0, 0, 530, 532, 1, 0, 0, 0, 531, 529, 1, 0, 0, 0, 532, 533, 3, 44, 22, 0, 533, 535, 1, 0, 0, 0, 534, 524, 1, 0, 0, 0, 534, 525, 1, 0, 0, 0, 535, 536, 1, 0, 0, 0, 536, 537, 5, 112, 0, 0, 537, 542, 3, 84, 42, 0, 538, 539, 5, 66, 0, 0, 539, 541, 5, 67, 0, 0, 540, 538, 1, 0, 0, 0, 541, 544, 1, 0, 0, 0, 542, 540, 1, 0, 0, 0, 542, 543, 1, 0, 0, 0, 543, 547, 1, 0, 0, 0, 544, 542, 1, 0, 0, 0, 545, 546, 5, 45, 0, 0, 546, 548, 3, 82, 41, 0, 547, 545, 1, 0, 0, 0, 547, 548, 1, 0, 0, 0, 548, 549, 1, 0, 0, 0, 549, 550, 3, 42, 21, 0, 550, 63, 1, 0, 0, 0, 551, 558, 3, 102, 51, 0, 552, 558, 5, 35, 0, 0, 553, 558, 5, 1, 0, 0, 554, 558, 5, 12, 0, 0, 555, 558, 5, 38, 0, 0, 556, 558, 5, 39, 0, 0, 557, 551, 1, 0, 0, 0, 557, 552, 1, 0, 0, 0, 557, 553, 1, 0, 0, 0, 557, 554, 1, 0, 0, 0, 557, 555, 1, 0, 0, 0, 557, 556, 1, 0, 0, 0, 558, 65, 1, 0, 0, 0, 559, 560, 3, 16, 8, 0, 560, 561, 3, 62, 31, 0, 561, 67, 1, 0, 0, 0, 562, 567, 3, 70, 35, 0, 563, 564, 5, 69, 0, 0, 564, 566, 3, 70, 35, 0, 565, 563, 1, 0, 0, 0, 566, 569, 1, 0, 0, 0, 567, 565, 1, 0, 0, 0, 567, 568, 1, 0, 0, 0, 568, 69, 1, 0, 0, 0, 569, 567, 1, 0, 0, 0, 570, 573, 3, 72, 36, 0, 571, 572, 5, 71, 0, 0, 572, 574, 3, 74, 37, 0, 573, 571, 1, 0, 0, 0, 573, 574, 1, 0, 0, 0, 574, 71, 1, 0, 0, 0, 575, 580, 5, 112, 0, 0, 576, 577, 5, 66, 0, 0, 577, 579, 5, 67, 0, 0, 578, 576, 1, 0, 0, 0, 579, 582, 1, 0, 0, 0, 580, 578, 1, 0, 0, 0, 580, 581, 1, 0, 0, 0, 581, 73, 1, 0, 0, 0, 582, 580, 1, 0, 0, 0, 583, 586, 3, 76, 38, 0, 584, 586, 3, 166, 83, 0, 585, 583, 1, 0, 0, 0, 585, 584, 1, 0, 0, 0, 586, 75, 1, 0, 0, 0, 587, 599, 5, 64, 0, 0, 588, 593, 3, 74, 37, 0, 589, 590, 5, 69, 0, 0, 590, 592, 3, 74, 37, 0, 591, 589, 1, 0, 0, 0, 592, 595, 1, 0, 0, 0, 593, 591, 1, 0, 0, 0, 593, 594, 1, 0, 0, 0, 594, 597, 1, 0, 0, 0, 595, 593, 1, 0, 0, 0, 596, 598, 5, 69, 0, 0, 597, 596, 1, 0, 0, 0, 597, 598, 1, 0, 0, 0, 598, 600, 1, 0, 0, 0, 599, 588, 1, 0, 0, 0, 599, 600, 1, 0, 0, 0, 600, 601, 1, 0, 0, 0, 601, 602, 5, 65, 0, 0, 602, 77, 1, 0, 0, 0, 603, 605, 5, 112, 0, 0, 604, 606, 3, 202, 101, 0, 605, 604, 1, 0, 0, 0, 605, 606, 1, 0, 0, 0, 606, 614, 1, 0, 0, 0, 607, 608, 5, 70, 0, 0, 608, 610, 5, 112, 0, 0, 609, 611, 3, 202, 101, 0, 610, 609, 1, 0, 0, 0, 610, 611, 1, 0, 0, 0, 611, 613, 1, 0, 0, 0, 612, 607, 1, 0, 0, 0, 613, 616, 1, 0, 0, 0, 614, 612, 1, 0, 0, 0, 614, 615, 1, 0, 0, 0, 615, 79, 1, 0, 0, 0, 616, 614, 1, 0, 0, 0, 617, 630, 3, 198, 99, 0, 618, 620, 3, 102, 51, 0, 619, 618, 1, 0, 0, 0, 620, 623, 1, 0, 0, 0, 621, 619, 1, 0, 0, 0, 621, 622, 1, 0, 0, 0, 622, 624, 1, 0, 0, 0, 623, 621, 1, 0, 0, 0, 624, 627, 5, 76, 0, 0, 625, 626, 7, 0, 0, 0, 626, 628, 3, 198, 99, 0, 627, 625, 1, 0, 0, 0, 627, 628, 1, 0, 0, 0, 628, 630, 1, 0, 0, 0, 629, 617, 1, 0, 0, 0, 629, 621, 1, 0, 0, 0, 630, 81, 1, 0, 0, 0, 631, 636, 3, 92, 46, 0, 632, 633, 5, 69, 0, 0, 633, 635, 3, 92, 46, 0, 634, 632, 1, 0, 0, 0, 635, 638, 1, 0, 0, 0, 636, 634, 1, 0, 0, 0, 636, 637, 1, 0, 0, 0, 637, 83, 1, 0, 0, 0, 638, 636, 1, 0, 0, 0, 639, 641, 5, 62, 0, 0, 640, 642, 3, 86, 43, 0, 641, 640, 1, 0, 0, 0, 641, 642, 1, 0, 0, 0, 642, 643, 1, 0, 0, 0, 643, 644, 5, 63, 0, 0, 644, 85, 1, 0, 0, 0, 645, 650, 3, 88, 44, 0, 646, 647, 5, 69, 0, 0, 647, 649, 3, 88, 44, 0, 648, 646, 1, 0, 0, 0, 649, 652, 1, 0, 0, 0, 650, 648, 1, 0, 0, 0, 650, 651, 1, 0, 0, 0, 651, 655, 1, 0, 0, 0, 652, 650, 1, 0, 0, 0, 653, 654, 5, 69, 0, 0, 654, 656, 3, 90, 45, 0, 655, 653, 1, 0, 0, 0, 655, 656, 1, 0, 0, 0, 656, 659, 1, 0, 0, 0, 657, 659, 3, 90, 45, 0, 658, 645, 1, 0, 0, 0, 658, 657, 1, 0, 0, 0, 659, 87, 1, 0, 0, 0, 660, 662, 3, 12, 6, 0, 661, 660, 1, 0, 0, 0, 662, 665, 1, 0, 0, 0, 663, 661, 1, 0, 0, 0, 663, 664, 1, 0, 0, 0, 664, 666, 1, 0, 0, 0, 665, 663, 1, 0, 0, 0, 666, 667, 3, 198, 99, 0, 667, 668, 3, 72, 36, 0, 668, 89, 1, 0, 0, 0, 669, 671, 3, 12, 6, 0, 670, 669, 1, 0, 0, 0, 671, 674, 1, 0, 0, 0, 672, 670, 1, 0, 0, 0, 672, 673, 1, 0, 0, 0, 673, 675, 1, 0, 0, 0, 674, 672, 1, 0, 0, 0, 675, 679, 3, 198, 99, 0, 676, 678, 3, 102, 51, 0, 677, 676, 1, 0, 0, 0, 678, 681, 1, 0, 0, 0, 679, 677, 1, 0, 0, 0, 679, 680, 1, 0, 0, 0, 680, 682, 1, 0, 0, 0, 681, 679, 1, 0, 0, 0, 682, 683, 5, 108, 0, 0, 683, 684, 3, 72, 36, 0, 684, 91, 1, 0, 0, 0, 685, 690, 5, 112, 0, 0, 686, 687, 5, 70, 0, 0, 687, 689, 5, 112, 0, 0, 688, 686, 1, 0, 0, 0, 689, 692, 1, 0, 0, 0, 690, 688, 1, 0, 0, 0, 690, 691, 1, 0, 0, 0, 691, 93, 1, 0, 0, 0, 692, 690, 1, 0, 0, 0, 693, 700, 3, 96, 48, 0, 694, 700, 3, 98, 49, 0, 695, 700, 5, 59, 0, 0, 696, 700, 5, 60, 0, 0, 697, 700, 5, 58, 0, 0, 698, 700, 5, 61, 0, 0, 699, 693, 1, 0, 0, 0, 699, 694, 1, 0, 0, 0, 699, 695, 1, 0, 0, 0, 699, 696, 1, 0, 0, 0, 699, 697, 1, 0, 0, 0, 699, 698, 1, 0, 0, 0, 700, 95, 1, 0, 0, 0, 701, 702, 7, 1, 0, 0, 702, 97, 1, 0, 0, 0, 703, 704, 7, 2, 0, 0, 704, 99, 1, 0, 0, 0, 705, 706, 5, 112, 0, 0, 706, 708, 5, 70, 0, 0, 707, 705, 1, 0, 0, 0, 708, 711, 1, 0, 0, 0, 709, 707, 1, 0, 0, 0, 709, 710, 1, 0, 0, 0, 710, 712, 1, 0, 0, 0, 711, 709, 1, 0, 0, 0, 712, 713, 5, 107, 0, 0, 713, 714, 5, 112, 0, 0, 714, 101, 1, 0, 0, 0, 715, 716, 5, 107, 0, 0, 716, 719, 3, 92, 46, 0, 717, 719, 3, 100, 50, 0, 718, 715, 1, 0, 0, 0, 718, 717, 1, 0, 0, 0, 719, 726, 1, 0, 0, 0, 720, 723, 5, 62, 0, 0, 721, 724, 3, 104, 52, 0, 722, 724, 3, 108, 54, 0, 723, 721, 1, 0, 0, 0, 723, 722, 1, 0, 0, 0, 723, 724, 1, 0, 0, 0, 724, 725, 1, 0, 0, 0, 725, 727, 5, 63, 0, 0, 726, 720, 1, 0, 0, 0, 726, 727, 1, 0, 0, 0, 727, 103, 1, 0, 0, 0, 728, 733, 3, 106, 53, 0, 729, 730, 5, 69, 0, 0, 730, 732, 3, 106, 53, 0, 731, 729, 1, 0, 0, 0, 732, 735, 1, 0, 0, 0, 733, 731, 1, 0, 0, 0, 733, 734, 1, 0, 0, 0, 734, 105, 1, 0, 0, 0, 735, 733, 1, 0, 0, 0, 736, 737, 5, 112, 0, 0, 737, 738, 5, 71, 0, 0, 738, 739, 3, 108, 54, 0, 739, 107, 1, 0, 0, 0, 740, 744, 3, 166, 83, 0, 741, 744, 3, 102, 51, 0, 742, 744, 3, 110, 55, 0, 743, 740, 1, 0, 0, 0, 743, 741, 1, 0, 0, 0, 743, 742, 1, 0, 0, 0, 744, 109, 1, 0, 0, 0, 745, 754, 5, 64, 0, 0, 746, 751, 3, 108, 54, 0, 747, 748, 5, 69, 0, 0, 748, 750, 3, 108, 54, 0, 749, 747, 1, 0, 0, 0, 750, 753, 1, 0, 0, 0, 751, 749, 1, 0, 0, 0, 751, 752, 1, 0, 0, 0, 752, 755, 1, 0, 0, 0, 753, 751, 1, 0, 0, 0, 754, 746, 1, 0, 0, 0, 754, 755, 1, 0, 0, 0, 755, 757, 1, 0, 0, 0, 756, 758, 5, 69, 0, 0, 757, 756, 1, 0, 0, 0, 757, 758, 1, 0, 0, 0, 758, 759, 1, 0, 0, 0, 759, 760, 5, 65, 0, 0, 760, 111, 1, 0, 0, 0, 761, 762, 5, 107, 0, 0, 762, 763, 5, 28, 0, 0, 763, 764, 5, 112, 0, 0, 764, 765, 3, 114, 57, 0, 765, 113, 1, 0, 0, 0, 766, 770, 5, 64, 0, 0, 767, 769, 3, 116, 58, 0, 768, 767, 1, 0, 0, 0, 769, 772, 1, 0, 0, 0, 770, 768, 1, 0, 0, 0, 770, 771, 1, 0, 0, 0, 771, 773, 1, 0, 0, 0, 772, 770, 1, 0, 0, 0, 773, 774, 5, 65, 0, 0, 774, 115, 1, 0, 0, 0, 775, 777, 3, 8, 4, 0, 776, 775, 1, 0, 0, 0, 777, 780, 1, 0, 0, 0, 778, 776, 1, 0, 0, 0, 778, 779, 1, 0, 0, 0, 779, 781, 1, 0, 0, 0, 780, 778, 1, 0, 0, 0, 781, 784, 3, 118, 59, 0, 782, 784, 5, 68, 0, 0, 783, 778, 1, 0, 0, 0, 783, 782, 1, 0, 0, 0, 784, 117, 1, 0, 0, 0, 785, 786, 3, 198, 99, 0, 786, 787, 3, 120, 60, 0, 787, 788, 5, 68, 0, 0, 788, 806, 1, 0, 0, 0, 789, 791, 3, 14, 7, 0, 790, 792, 5, 68, 0, 0, 791, 790, 1, 0, 0, 0, 791, 792, 1, 0, 0, 0, 792, 806, 1, 0, 0, 0, 793, 795, 3, 30, 15, 0, 794, 796, 5, 68, 0, 0, 795, 794, 1, 0, 0, 0, 795, 796, 1, 0, 0, 0, 796, 806, 1, 0, 0, 0, 797, 799, 3, 22, 11, 0, 798, 800, 5, 68, 0, 0, 799, 798, 1, 0, 0, 0, 799, 800, 1, 0, 0, 0, 800, 806, 1, 0, 0, 0, 801, 803, 3, 112, 56, 0, 802, 804, 5, 68, 0, 0, 803, 802, 1, 0, 0, 0, 803, 804, 1, 0, 0, 0, 804, 806, 1, 0, 0, 0, 805, 785, 1, 0, 0, 0, 805, 789, 1, 0, 0, 0, 805, 793, 1, 0, 0, 0, 805, 797, 1, 0, 0, 0, 805, 801, 1, 0, 0, 0, 806, 119, 1, 0, 0, 0, 807, 810, 3, 122, 61, 0, 808, 810, 3, 124, 62, 0, 809, 807, 1, 0, 0, 0, 809, 808, 1, 0, 0, 0, 810, 121, 1, 0, 0, 0, 811, 812, 5, 112, 0, 0, 812, 813, 5, 62, 0, 0, 813, 815, 5, 63, 0, 0, 814, 816, 3, 126, 63, 0, 815, 814, 1, 0, 0, 0, 815, 816, 1, 0, 0, 0, 816, 123, 1, 0, 0, 0, 817, 818, 3, 68, 34, 0, 818, 125, 1, 0, 0, 0, 819, 820, 5, 12, 0, 0, 820, 821, 3, 108, 54, 0, 821, 127, 1, 0, 0, 0, 822, 826, 5, 64, 0, 0, 823, 825, 3, 130, 65, 0, 824, 823, 1, 0, 0, 0, 825, 828, 1, 0, 0, 0, 826, 824, 1, 0, 0, 0, 826, 827, 1, 0, 0, 0, 827, 829, 1, 0, 0, 0, 828, 826, 1, 0, 0, 0, 829, 830, 5, 65, 0, 0, 830, 129, 1, 0, 0, 0, 831, 832, 3, 132, 66, 0, 832, 833, 5, 68, 0, 0, 833, 837, 1, 0, 0, 0, 834, 837, 3, 136, 68, 0, 835, 837, 3, 134, 67, 0, 836, 831, 1, 0, 0, 0, 836, 834, 1, 0, 0, 0, 836, 835, 1, 0, 0, 0, 837, 131, 1, 0, 0, 0, 838, 840, 3, 12, 6, 0, 839, 838, 1, 0, 0, 0, 840, 843, 1, 0, 0, 0, 841, 839, 1, 0, 0, 0, 841, 842, 1, 0, 0, 0, 842, 844, 1, 0, 0, 0, 843, 841, 1, 0, 0, 0, 844, 845, 3, 198, 99, 0, 845, 846, 3, 68, 34, 0, 846, 133, 1, 0, 0, 0, 847, 849, 3, 10, 5, 0, 848, 847, 1, 0, 0, 0, 849, 852, 1, 0, 0, 0, 850, 848, 1, 0, 0, 0, 850, 851, 1, 0, 0, 0, 851, 855, 1, 0, 0, 0, 852, 850, 1, 0, 0, 0, 853, 856, 3, 14, 7, 0, 854, 856, 3, 30, 15, 0, 855, 853, 1, 0, 0, 0, 855, 854, 1, 0, 0, 0, 856, 859, 1, 0, 0, 0, 857, 859, 5, 68, 0, 0, 858, 850, 1, 0, 0, 0, 858, 857, 1, 0, 0, 0, 859, 135, 1, 0, 0, 0, 860, 965, 3, 128, 64, 0, 861, 862, 5, 2, 0, 0, 862, 865, 3, 166, 83, 0, 863, 864, 5, 77, 0, 0, 864, 866, 3, 166, 83, 0, 865, 863, 1, 0, 0, 0, 865, 866, 1, 0, 0, 0, 866, 867, 1, 0, 0, 0, 867, 868, 5, 68, 0, 0, 868, 965, 1, 0, 0, 0, 869, 870, 5, 22, 0, 0, 870, 871, 3, 160, 80, 0, 871, 874, 3, 136, 68, 0, 872, 873, 5, 15, 0, 0, 873, 875, 3, 136, 68, 0, 874, 872, 1, 0, 0, 0, 874, 875, 1, 0, 0, 0, 875, 965, 1, 0, 0, 0, 876, 877, 5, 21, 0, 0, 877, 878, 5, 62, 0, 0, 878, 879, 3, 154, 77, 0, 879, 880, 5, 63, 0, 0, 880, 881, 3, 136, 68, 0, 881, 965, 1, 0, 0, 0, 882, 883, 5, 51, 0, 0, 883, 884, 3, 160, 80, 0, 884, 885, 3, 136, 68, 0, 885, 965, 1, 0, 0, 0, 886, 887, 5, 13, 0, 0, 887, 888, 3, 136, 68, 0, 888, 889, 5, 51, 0, 0, 889, 890, 3, 160, 80, 0, 890, 891, 5, 68, 0, 0, 891, 965, 1, 0, 0, 0, 892, 893, 5, 47, 0, 0, 893, 903, 3, 128, 64, 0, 894, 896, 3, 138, 69, 0, 895, 894, 1, 0, 0, 0, 896, 897, 1, 0, 0, 0, 897, 895, 1, 0, 0, 0, 897, 898, 1, 0, 0, 0, 898, 900, 1, 0, 0, 0, 899, 901, 3, 142, 71, 0, 900, 899, 1, 0, 0, 0, 900, 901, 1, 0, 0, 0, 901, 904, 1, 0, 0, 0, 902, 904, 3, 142, 71, 0, 903, 895, 1, 0, 0, 0, 903, 902, 1, 0, 0, 0, 904, 965, 1, 0, 0, 0, 905, 906, 5, 47, 0, 0, 906, 907, 3, 144, 72, 0, 907, 911, 3, 128, 64, 0, 908, 910, 3, 138, 69, 0, 909, 908, 1, 0, 0, 0, 910, 913, 1, 0, 0, 0, 911, 909, 1, 0, 0, 0, 911, 912, 1, 0, 0, 0, 912, 915, 1, 0, 0, 0, 913, 911, 1, 0, 0, 0, 914, 916, 3, 142, 71, 0, 915, 914, 1, 0, 0, 0, 915, 916, 1, 0, 0, 0, 916, 965, 1, 0, 0, 0, 917, 918, 5, 41, 0, 0, 918, 919, 3, 160, 80, 0, 919, 923, 5, 64, 0, 0, 920, 922, 3, 150, 75, 0, 921, 920, 1, 0, 0, 0, 922, 925, 1, 0, 0, 0, 923, 921, 1, 0, 0, 0, 923, 924, 1, 0, 0, 0, 924, 929, 1, 0, 0, 0, 925, 923, 1, 0, 0, 0, 926, 928, 3, 152, 76, 0, 927, 926, 1, 0, 0, 0, 928, 931, 1, 0, 0, 0, 929, 927, 1, 0, 0, 0, 929, 930, 1, 0, 0, 0, 930, 932, 1, 0, 0, 0, 931, 929, 1, 0, 0, 0, 932, 933, 5, 65, 0, 0, 933, 965, 1, 0, 0, 0, 934, 935, 5, 42, 0, 0, 935, 936, 3, 160, 80, 0, 936, 937, 3, 128, 64, 0, 937, 965, 1, 0, 0, 0, 938, 940, 5, 36, 0, 0, 939, 941, 3, 166, 83, 0, 940, 939, 1, 0, 0, 0, 940, 941, 1, 0, 0, 0, 941, 942, 1, 0, 0, 0, 942, 965, 5, 68, 0, 0, 943, 944, 5, 44, 0, 0, 944, 945, 3, 166, 83, 0, 945, 946, 5, 68, 0, 0, 946, 965, 1, 0, 0, 0, 947, 949, 5, 4, 0, 0, 948, 950, 5, 112, 0, 0, 949, 948, 1, 0, 0, 0, 949, 950, 1, 0, 0, 0, 950, 951, 1, 0, 0, 0, 951, 965, 5, 68, 0, 0, 952, 954, 5, 11, 0, 0, 953, 955, 5, 112, 0, 0, 954, 953, 1, 0, 0, 0, 954, 955, 1, 0, 0, 0, 955, 956, 1, 0, 0, 0, 956, 965, 5, 68, 0, 0, 957, 965, 5, 68, 0, 0, 958, 959, 3, 166, 83, 0, 959, 960, 5, 68, 0, 0, 960, 965, 1, 0, 0, 0, 961, 962, 5, 112, 0, 0, 962, 963, 5, 77, 0, 0, 963, 965, 3, 136, 68, 0, 964, 860, 1, 0, 0, 0, 964, 861, 1, 0, 0, 0, 964, 869, 1, 0, 0, 0, 964, 876, 1, 0, 0, 0, 964, 882, 1, 0, 0, 0, 964, 886, 1, 0, 0, 0, 964, 892, 1, 0, 0, 0, 964, 905, 1, 0, 0, 0, 964, 917, 1, 0, 0, 0, 964, 934, 1, 0, 0, 0, 964, 938, 1, 0, 0, 0, 964, 943, 1, 0, 0, 0, 964, 947, 1, 0, 0, 0, 964, 952, 1, 0, 0, 0, 964, 957, 1, 0, 0, 0, 964, 958, 1, 0, 0, 0, 964, 961, 1, 0, 0, 0, 965, 137, 1, 0, 0, 0, 966, 967, 5, 7, 0, 0, 967, 971, 5, 62, 0, 0, 968, 970, 3, 12, 6, 0, 969, 968, 1, 0, 0, 0, 970, 973, 1, 0, 0, 0, 971, 969, 1, 0, 0, 0, 971, 972, 1, 0, 0, 0, 972, 974, 1, 0, 0, 0, 973, 971, 1, 0, 0, 0, 974, 975, 3, 140, 70, 0, 975, 976, 5, 112, 0, 0, 976, 977, 5, 63, 0, 0, 977, 978, 3, 128, 64, 0, 978, 139, 1, 0, 0, 0, 979, 984, 3, 92, 46, 0, 980, 981, 5, 91, 0, 0, 981, 983, 3, 92, 46, 0, 982, 980, 1, 0, 0, 0, 983, 986, 1, 0, 0, 0, 984, 982, 1, 0, 0, 0, 984, 985, 1, 0, 0, 0, 985, 141, 1, 0, 0, 0, 986, 984, 1, 0, 0, 0, 987, 988, 5, 19, 0, 0, 988, 989, 3, 128, 64, 0, 989, 143, 1, 0, 0, 0, 990, 991, 5, 62, 0, 0, 991, 993, 3, 146, 73, 0, 992, 994, 5, 68, 0, 0, 993, 992, 1, 0, 0, 0, 993, 994, 1, 0, 0, 0, 994, 995, 1, 0, 0, 0, 995, 996, 5, 63, 0, 0, 996, 145, 1, 0, 0, 0, 997, 1002, 3, 148, 74, 0, 998, 999, 5, 68, 0, 0, 999, 1001, 3, 148, 74, 0, 1000, 998, 1, 0, 0, 0, 1001, 1004, 1, 0, 0, 0, 1002, 1000, 1, 0, 0, 0, 1002, 1003, 1, 0, 0, 0, 1003, 147, 1, 0, 0, 0, 1004, 1002, 1, 0, 0, 0, 1005, 1007, 3, 12, 6, 0, 1006, 1005, 1, 0, 0, 0, 1007, 1010, 1, 0, 0, 0, 1008, 1006, 1, 0, 0, 0, 1008, 1009, 1, 0, 0, 0, 1009, 1011, 1, 0, 0, 0, 1010, 1008, 1, 0, 0, 0, 1011, 1012, 3, 78, 39, 0, 1012, 1013, 3, 72, 36, 0, 1013, 1014, 5, 71, 0, 0, 1014, 1015, 3, 166, 83, 0, 1015, 149, 1, 0, 0, 0, 1016, 1018, 3, 152, 76, 0, 1017, 1016, 1, 0, 0, 0, 1018, 1019, 1, 0, 0, 0, 1019, 1017, 1, 0, 0, 0, 1019, 1020, 1, 0, 0, 0, 1020, 1022, 1, 0, 0, 0, 1021, 1023, 3, 130, 65, 0, 1022, 1021, 1, 0, 0, 0, 1023, 1024, 1, 0, 0, 0, 1024, 1022, 1, 0, 0, 0, 1024, 1025, 1, 0, 0, 0, 1025, 151, 1, 0, 0, 0, 1026, 1029, 5, 6, 0, 0, 1027, 1030, 3, 166, 83, 0, 1028, 1030, 5, 112, 0, 0, 1029, 1027, 1, 0, 0, 0, 1029, 1028, 1, 0, 0, 0, 1030, 1031, 1, 0, 0, 0, 1031, 1035, 5, 77, 0, 0, 1032, 1033, 5, 12, 0, 0, 1033, 1035, 5, 77, 0, 0, 1034, 1026, 1, 0, 0, 0, 1034, 1032, 1, 0, 0, 0, 1035, 153, 1, 0, 0, 0, 1036, 1049, 3, 158, 79, 0, 1037, 1039, 3, 156, 78, 0, 1038, 1037, 1, 0, 0, 0, 1038, 1039, 1, 0, 0, 0, 1039, 1040, 1, 0, 0, 0, 1040, 1042, 5, 68, 0, 0, 1041, 1043, 3, 166, 83, 0, 1042, 1041, 1, 0, 0, 0, 1042, 1043, 1, 0, 0, 0, 1043, 1044, 1, 0, 0, 0, 1044, 1046, 5, 68, 0, 0, 1045, 1047, 3, 162, 81, 0, 1046, 1045, 1, 0, 0, 0, 1046, 1047, 1, 0, 0, 0, 1047, 1049, 1, 0, 0, 0, 1048, 1036, 1, 0, 0, 0, 1048, 1038, 1, 0, 0, 0, 1049, 155, 1, 0, 0, 0, 1050, 1053, 3, 132, 66, 0, 1051, 1053, 3, 162, 81, 0, 1052, 1050, 1, 0, 0, 0, 1052, 1051, 1, 0, 0, 0, 1053, 157, 1, 0, 0, 0, 1054, 1056, 3, 12, 6, 0, 1055, 1054, 1, 0, 0, 0, 1056, 1059, 1, 0, 0, 0, 1057, 1055, 1, 0, 0, 0, 1057, 1058, 1, 0, 0, 0, 1058, 1060, 1, 0, 0, 0, 1059, 1057, 1, 0, 0, 0, 1060, 1061, 3, 198, 99, 0, 1061, 1062, 3, 72, 36, 0, 1062, 1063, 5, 77, 0, 0, 1063, 1064, 3, 166, 83, 0, 1064, 159, 1, 0, 0, 0, 1065, 1066, 5, 62, 0, 0, 1066, 1067, 3, 166, 83, 0, 1067, 1068, 5, 63, 0, 0, 1068, 161, 1, 0, 0, 0, 1069, 1074, 3, 166, 83, 0, 1070, 1071, 5, 69, 0, 0, 1071, 1073, 3, 166, 83, 0, 1072, 1070, 1, 0, 0, 0, 1073, 1076, 1, 0, 0, 0, 1074, 1072, 1, 0, 0, 0, 1074, 1075, 1, 0, 0, 0, 1075, 163, 1, 0, 0, 0, 1076, 1074, 1, 0, 0, 0, 1077, 1078, 5, 112, 0, 0, 1078, 1080, 5, 62, 0, 0, 1079, 1081, 3, 162, 81, 0, 1080, 1079, 1, 0, 0, 0, 1080, 1081, 1, 0, 0, 0, 1081, 1082, 1, 0, 0, 0, 1082, 1096, 5, 63, 0, 0, 1083, 1084, 5, 43, 0, 0, 1084, 1086, 5, 62, 0, 0, 1085, 1087, 3, 162, 81, 0, 1086, 1085, 1, 0, 0, 0, 1086, 1087, 1, 0, 0, 0, 1087, 1088, 1, 0, 0, 0, 1088, 1096, 5, 63, 0, 0, 1089, 1090, 5, 40, 0, 0, 1090, 1092, 5, 62, 0, 0, 1091, 1093, 3, 162, 81, 0, 1092, 1091, 1, 0, 0, 0, 1092, 1093, 1, 0, 0, 0, 1093, 1094, 1, 0, 0, 0, 1094, 1096, 5, 63, 0, 0, 1095, 1077, 1, 0, 0, 0, 1095, 1083, 1, 0, 0, 0, 1095, 1089, 1, 0, 0, 0, 1096, 165, 1, 0, 0, 0, 1097, 1098, 6, 83, -1, 0, 1098, 1142, 3, 174, 87, 0, 1099, 1142, 3, 164, 82, 0, 1100, 1101, 5, 31, 0, 0, 1101, 1142, 3, 178, 89, 0, 1102, 1106, 5, 62, 0, 0, 1103, 1105, 3, 102, 51, 0, 1104, 1103, 1, 0, 0, 0, 1105, 1108, 1, 0, 0, 0, 1106, 1104, 1, 0, 0, 0, 1106, 1107, 1, 0, 0, 0, 1107, 1109, 1, 0, 0, 0, 1108, 1106, 1, 0, 0, 0, 1109, 1114, 3, 198, 99, 0, 1110, 1111, 5, 90, 0, 0, 1111, 1113, 3, 198, 99, 0, 1112, 1110, 1, 0, 0, 0, 1113, 1116, 1, 0, 0, 0, 1114, 1112, 1, 0, 0, 0, 1114, 1115, 1, 0, 0, 0, 1115, 1117, 1, 0, 0, 0, 1116, 1114, 1, 0, 0, 0, 1117, 1118, 5, 63, 0, 0, 1118, 1119, 3, 166, 83, 21, 1119, 1142, 1, 0, 0, 0, 1120, 1121, 7, 3, 0, 0, 1121, 1142, 3, 166, 83, 19, 1122, 1123, 7, 4, 0, 0, 1123, 1142, 3, 166, 83, 18, 1124, 1142, 3, 168, 84, 0, 1125, 1126, 3, 198, 99, 0, 1126, 1132, 5, 106, 0, 0, 1127, 1129, 3, 202, 101, 0, 1128, 1127, 1, 0, 0, 0, 1128, 1129, 1, 0, 0, 0, 1129, 1130, 1, 0, 0, 0, 1130, 1133, 5, 112, 0, 0, 1131, 1133, 5, 31, 0, 0, 1132, 1128, 1, 0, 0, 0, 1132, 1131, 1, 0, 0, 0, 1133, 1142, 1, 0, 0, 0, 1134, 1135, 3, 176, 88, 0, 1135, 1137, 5, 106, 0, 0, 1136, 1138, 3, 202, 101, 0, 1137, 1136, 1, 0, 0, 0, 1137, 1138, 1, 0, 0, 0, 1138, 1139, 1, 0, 0, 0, 1139, 1140, 5, 31, 0, 0, 1140, 1142, 1, 0, 0, 0, 1141, 1097, 1, 0, 0, 0, 1141, 1099, 1, 0, 0, 0, 1141, 1100, 1, 0, 0, 0, 1141, 1102, 1, 0, 0, 0, 1141, 1120, 1, 0, 0, 0, 1141, 1122, 1, 0, 0, 0, 1141, 1124, 1, 0, 0, 0, 1141, 1125, 1, 0, 0, 0, 1141, 1134, 1, 0, 0, 0, 1142, 1223, 1, 0, 0, 0, 1143, 1144, 10, 17, 0, 0, 1144, 1145, 7, 5, 0, 0, 1145, 1222, 3, 166, 83, 18, 1146, 1147, 10, 16, 0, 0, 1147, 1148, 7, 6, 0, 0, 1148, 1222, 3, 166, 83, 17, 1149, 1157, 10, 15, 0, 0, 1150, 1151, 5, 73, 0, 0, 1151, 1158, 5, 73, 0, 0, 1152, 1153, 5, 72, 0, 0, 1153, 1154, 5, 72, 0, 0, 1154, 1158, 5, 72, 0, 0, 1155, 1156, 5, 72, 0, 0, 1156, 1158, 5, 72, 0, 0, 1157, 1150, 1, 0, 0, 0, 1157, 1152, 1, 0, 0, 0, 1157, 1155, 1, 0, 0, 0, 1158, 1159, 1, 0, 0, 0, 1159, 1222, 3, 166, 83, 16, 1160, 1161, 10, 14, 0, 0, 1161, 1162, 7, 7, 0, 0, 1162, 1222, 3, 166, 83, 15, 1163, 1164, 10, 12, 0, 0, 1164, 1165, 7, 8, 0, 0, 1165, 1222, 3, 166, 83, 13, 1166, 1167, 10, 11, 0, 0, 1167, 1168, 5, 90, 0, 0, 1168, 1222, 3, 166, 83, 12, 1169, 1170, 10, 10, 0, 0, 1170, 1171, 5, 92, 0, 0, 1171, 1222, 3, 166, 83, 11, 1172, 1173, 10, 9, 0, 0, 1173, 1174, 5, 91, 0, 0, 1174, 1222, 3, 166, 83, 10, 1175, 1176, 10, 8, 0, 0, 1176, 1177, 5, 82, 0, 0, 1177, 1222, 3, 166, 83, 9, 1178, 1179, 10, 7, 0, 0, 1179, 1180, 5, 83, 0, 0, 1180, 1222, 3, 166, 83, 8, 1181, 1182, 10, 6, 0, 0, 1182, 1183, 5, 76, 0, 0, 1183, 1184, 3, 166, 83, 0, 1184, 1185, 5, 77, 0, 0, 1185, 1186, 3, 166, 83, 6, 1186, 1222, 1, 0, 0, 0, 1187, 1188, 10, 5, 0, 0, 1188, 1189, 7, 9, 0, 0, 1189, 1222, 3, 166, 83, 5, 1190, 1191, 10, 25, 0, 0, 1191, 1203, 5, 70, 0, 0, 1192, 1204, 5, 112, 0, 0, 1193, 1204, 3, 164, 82, 0, 1194, 1204, 5, 43, 0, 0, 1195, 1197, 5, 31, 0, 0, 1196, 1198, 3, 194, 97, 0, 1197, 1196, 1, 0, 0, 0, 1197, 1198, 1, 0, 0, 0, 1198, 1199, 1, 0, 0, 0, 1199, 1204, 3, 182, 91, 0, 1200, 1201, 5, 40, 0, 0, 1201, 1204, 3, 204, 102, 0, 1202, 1204, 3, 188, 94, 0, 1203, 1192, 1, 0, 0, 0, 1203, 1193, 1, 0, 0, 0, 1203, 1194, 1, 0, 0, 0, 1203, 1195, 1, 0, 0, 0, 1203, 1200, 1, 0, 0, 0, 1203, 1202, 1, 0, 0, 0, 1204, 1222, 1, 0, 0, 0, 1205, 1206, 10, 24, 0, 0, 1206, 1207, 5, 66, 0, 0, 1207, 1208, 3, 166, 83, 0, 1208, 1209, 5, 67, 0, 0, 1209, 1222, 1, 0, 0, 0, 1210, 1211, 10, 20, 0, 0, 1211, 1222, 7, 10, 0, 0, 1212, 1213, 10, 13, 0, 0, 1213, 1214, 5, 26, 0, 0, 1214, 1222, 3, 198, 99, 0, 1215, 1216, 10, 3, 0, 0, 1216, 1218, 5, 106, 0, 0, 1217, 1219, 3, 202, 101, 0, 1218, 1217, 1, 0, 0, 0, 1218, 1219, 1, 0, 0, 0, 1219, 1220, 1, 0, 0, 0, 1220, 1222, 5, 112, 0, 0, 1221, 1143, 1, 0, 0, 0, 1221, 1146, 1, 0, 0, 0, 1221, 1149, 1, 0, 0, 0, 1221, 1160, 1, 0, 0, 0, 1221, 1163, 1, 0, 0, 0, 1221, 1166, 1, 0, 0, 0, 1221, 1169, 1, 0, 0, 0, 1221, 1172, 1, 0, 0, 0, 1221, 1175, 1, 0, 0, 0, 1221, 1178, 1, 0, 0, 0, 1221, 1181, 1, 0, 0, 0, 1221, 1187, 1, 0, 0, 0, 1221, 1190, 1, 0, 0, 0, 1221, 1205, 1, 0, 0, 0, 1221, 1210, 1, 0, 0, 0, 1221, 1212, 1, 0, 0, 0, 1221, 1215, 1, 0, 0, 0, 1222, 1225, 1, 0, 0, 0, 1223, 1221, 1, 0, 0, 0, 1223, 1224, 1, 0, 0, 0, 1224, 167, 1, 0, 0, 0, 1225, 1223, 1, 0, 0, 0, 1226, 1227, 3, 170, 85, 0, 1227, 1228, 5, 105, 0, 0, 1228, 1229, 3, 172, 86, 0, 1229, 169, 1, 0, 0, 0, 1230, 1247, 5, 112, 0, 0, 1231, 1233, 5, 62, 0, 0, 1232, 1234, 3, 86, 43, 0, 1233, 1232, 1, 0, 0, 0, 1233, 1234, 1, 0, 0, 0, 1234, 1235, 1, 0, 0, 0, 1235, 1247, 5, 63, 0, 0, 1236, 1237, 5, 62, 0, 0, 1237, 1242, 5, 112, 0, 0, 1238, 1239, 5, 69, 0, 0, 1239, 1241, 5, 112, 0, 0, 1240, 1238, 1, 0, 0, 0, 1241, 1244, 1, 0, 0, 0, 1242, 1240, 1, 0, 0, 0, 1242, 1243, 1, 0, 0, 0, 1243, 1245, 1, 0, 0, 0, 1244, 1242, 1, 0, 0, 0, 1245, 1247, 5, 63, 0, 0, 1246, 1230, 1, 0, 0, 0, 1246, 1231, 1, 0, 0, 0, 1246, 1236, 1, 0, 0, 0, 1247, 171, 1, 0, 0, 0, 1248, 1251, 3, 166, 83, 0, 1249, 1251, 3, 128, 64, 0, 1250, 1248, 1, 0, 0, 0, 1250, 1249, 1, 0, 0, 0, 1251, 173, 1, 0, 0, 0, 1252, 1253, 5, 62, 0, 0, 1253, 1254, 3, 166, 83, 0, 1254, 1255, 5, 63, 0, 0, 1255, 1271, 1, 0, 0, 0, 1256, 1271, 5, 43, 0, 0, 1257, 1271, 5, 40, 0, 0, 1258, 1271, 3, 94, 47, 0, 1259, 1271, 5, 112, 0, 0, 1260, 1261, 3, 44, 22, 0, 1261, 1262, 5, 70, 0, 0, 1262, 1263, 5, 9, 0, 0, 1263, 1271, 1, 0, 0, 0, 1264, 1268, 3, 194, 97, 0, 1265, 1269, 3, 206, 103, 0, 1266, 1267, 5, 43, 0, 0, 1267, 1269, 3, 208, 104, 0, 1268, 1265, 1, 0, 0, 0, 1268, 1266, 1, 0, 0, 0, 1269, 1271, 1, 0, 0, 0, 1270, 1252, 1, 0, 0, 0, 1270, 1256, 1, 0, 0, 0, 1270, 1257, 1, 0, 0, 0, 1270, 1258, 1, 0, 0, 0, 1270, 1259, 1, 0, 0, 0, 1270, 1260, 1, 0, 0, 0, 1270, 1264, 1, 0, 0, 0, 1271, 175, 1, 0, 0, 0, 1272, 1273, 3, 78, 39, 0, 1273, 1274, 5, 70, 0, 0, 1274, 1276, 1, 0, 0, 0, 1275, 1272, 1, 0, 0, 0, 1275, 1276, 1, 0, 0, 0, 1276, 1280, 1, 0, 0, 0, 1277, 1279, 3, 102, 51, 0, 1278, 1277, 1, 0, 0, 0, 1279, 1282, 1, 0, 0, 0, 1280, 1278, 1, 0, 0, 0, 1280, 1281, 1, 0, 0, 0, 1281, 1283, 1, 0, 0, 0, 1282, 1280, 1, 0, 0, 0, 1283, 1285, 5, 112, 0, 0, 1284, 1286, 3, 202, 101, 0, 1285, 1284, 1, 0, 0, 0, 1285, 1286, 1, 0, 0, 0, 1286, 177, 1, 0, 0, 0, 1287, 1288, 3, 194, 97, 0, 1288, 1289, 3, 180, 90, 0, 1289, 1290, 3, 186, 93, 0, 1290, 1297, 1, 0, 0, 0, 1291, 1294, 3, 180, 90, 0, 1292, 1295, 3, 184, 92, 0, 1293, 1295, 3, 186, 93, 0, 1294, 1292, 1, 0, 0, 0, 1294, 1293, 1, 0, 0, 0, 1295, 1297, 1, 0, 0, 0, 1296, 1287, 1, 0, 0, 0, 1296, 1291, 1, 0, 0, 0, 1297, 179, 1, 0, 0, 0, 1298, 1300, 5, 112, 0, 0, 1299, 1301, 3, 190, 95, 0, 1300, 1299, 1, 0, 0, 0, 1300, 1301, 1, 0, 0, 0, 1301, 1309, 1, 0, 0, 0, 1302, 1303, 5, 70, 0, 0, 1303, 1305, 5, 112, 0, 0, 1304, 1306, 3, 190, 95, 0, 1305, 1304, 1, 0, 0, 0, 1305, 1306, 1, 0, 0, 0, 1306, 1308, 1, 0, 0, 0, 1307, 1302, 1, 0, 0, 0, 1308, 1311, 1, 0, 0, 0, 1309, 1307, 1, 0, 0, 0, 1309, 1310, 1, 0, 0, 0, 1310, 1314, 1, 0, 0, 0, 1311, 1309, 1, 0, 0, 0, 1312, 1314, 3, 200, 100, 0, 1313, 1298, 1, 0, 0, 0, 1313, 1312, 1, 0, 0, 0, 1314, 181, 1, 0, 0, 0, 1315, 1317, 5, 112, 0, 0, 1316, 1318, 3, 192, 96, 0, 1317, 1316, 1, 0, 0, 0, 1317, 1318, 1, 0, 0, 0, 1318, 1319, 1, 0, 0, 0, 1319, 1320, 3, 186, 93, 0, 1320, 183, 1, 0, 0, 0, 1321, 1349, 5, 66, 0, 0, 1322, 1327, 5, 67, 0, 0, 1323, 1324, 5, 66, 0, 0, 1324, 1326, 5, 67, 0, 0, 1325, 1323, 1, 0, 0, 0, 1326, 1329, 1, 0, 0, 0, 1327, 1325, 1, 0, 0, 0, 1327, 1328, 1, 0, 0, 0, 1328, 1330, 1, 0, 0, 0, 1329, 1327, 1, 0, 0, 0, 1330, 1350, 3, 76, 38, 0, 1331, 1332, 3, 166, 83, 0, 1332, 1339, 5, 67, 0, 0, 1333, 1334, 5, 66, 0, 0, 1334, 1335, 3, 166, 83, 0, 1335, 1336, 5, 67, 0, 0, 1336, 1338, 1, 0, 0, 0, 1337, 1333, 1, 0, 0, 0, 1338, 1341, 1, 0, 0, 0, 1339, 1337, 1, 0, 0, 0, 1339, 1340, 1, 0, 0, 0, 1340, 1346, 1, 0, 0, 0, 1341, 1339, 1, 0, 0, 0, 1342, 1343, 5, 66, 0, 0, 1343, 1345, 5, 67, 0, 0, 1344, 1342, 1, 0, 0, 0, 1345, 1348, 1, 0, 0, 0, 1346, 1344, 1, 0, 0, 0, 1346, 1347, 1, 0, 0, 0, 1347, 1350, 1, 0, 0, 0, 1348, 1346, 1, 0, 0, 0, 1349, 1322, 1, 0, 0, 0, 1349, 1331, 1, 0, 0, 0, 1350, 185, 1, 0, 0, 0, 1351, 1353, 3, 208, 104, 0, 1352, 1354, 3, 32, 16, 0, 1353, 1352, 1, 0, 0, 0, 1353, 1354, 1, 0, 0, 0, 1354, 187, 1, 0, 0, 0, 1355, 1356, 3, 194, 97, 0, 1356, 1357, 3, 206, 103, 0, 1357, 189, 1, 0, 0, 0, 1358, 1359, 5, 73, 0, 0, 1359, 1362, 5, 72, 0, 0, 1360, 1362, 3, 202, 101, 0, 1361, 1358, 1, 0, 0, 0, 1361, 1360, 1, 0, 0, 0, 1362, 191, 1, 0, 0, 0, 1363, 1364, 5, 73, 0, 0, 1364, 1367, 5, 72, 0, 0, 1365, 1367, 3, 194, 97, 0, 1366, 1363, 1, 0, 0, 0, 1366, 1365, 1, 0, 0, 0, 1367, 193, 1, 0, 0, 0, 1368, 1369, 5, 73, 0, 0, 1369, 1370, 3, 196, 98, 0, 1370, 1371, 5, 72, 0, 0, 1371, 195, 1, 0, 0, 0, 1372, 1377, 3, 198, 99, 0, 1373, 1374, 5, 69, 0, 0, 1374, 1376, 3, 198, 99, 0, 1375, 1373, 1, 0, 0, 0, 1376, 1379, 1, 0, 0, 0, 1377, 1375, 1, 0, 0, 0, 1377, 1378, 1, 0, 0, 0, 1378, 197, 1, 0, 0, 0, 1379, 1377, 1, 0, 0, 0, 1380, 1382, 3, 102, 51, 0, 1381, 1380, 1, 0, 0, 0, 1382, 1385, 1, 0, 0, 0, 1383, 1381, 1, 0, 0, 0, 1383, 1384, 1, 0, 0, 0, 1384, 1388, 1, 0, 0, 0, 1385, 1383, 1, 0, 0, 0, 1386, 1389, 3, 78, 39, 0, 1387, 1389, 3, 200, 100, 0, 1388, 1386, 1, 0, 0, 0, 1388, 1387, 1, 0, 0, 0, 1389, 1400, 1, 0, 0, 0, 1390, 1392, 3, 102, 51, 0, 1391, 1390, 1, 0, 0, 0, 1392, 1395, 1, 0, 0, 0, 1393, 1391, 1, 0, 0, 0, 1393, 1394, 1, 0, 0, 0, 1394, 1396, 1, 0, 0, 0, 1395, 1393, 1, 0, 0, 0, 1396, 1397, 5, 66, 0, 0, 1397, 1399, 5, 67, 0, 0, 1398, 1393, 1, 0, 0, 0, 1399, 1402, 1, 0, 0, 0, 1400, 1398, 1, 0, 0, 0, 1400, 1401, 1, 0, 0, 0, 1401, 199, 1, 0, 0, 0, 1402, 1400, 1, 0, 0, 0, 1403, 1404, 7, 11, 0, 0, 1404, 201, 1, 0, 0, 0, 1405, 1406, 5, 73, 0, 0, 1406, 1411, 3, 80, 40, 0, 1407, 1408, 5, 69, 0, 0, 1408, 1410, 3, 80, 40, 0, 1409, 1407, 1, 0, 0, 0, 1410, 1413, 1, 0, 0, 0, 1411, 1409, 1, 0, 0, 0, 1411, 1412, 1, 0, 0, 0, 1412, 1414, 1, 0, 0, 0, 1413, 1411, 1, 0, 0, 0, 1414, 1415, 5, 72, 0, 0, 1415, 203, 1, 0, 0, 0, 1416, 1423, 3, 208, 104, 0, 1417, 1418, 5, 70, 0, 0, 1418, 1420, 5, 112, 0, 0, 1419, 1421, 3, 208, 104, 0, 1420, 1419, 1, 0, 0, 0, 1420, 1421, 1, 0, 0, 0, 1421, 1423, 1, 0, 0, 0, 1422, 1416, 1, 0, 0, 0, 1422, 1417, 1, 0, 0, 0, 1423, 205, 1, 0, 0, 0, 1424, 1425, 5, 40, 0, 0, 1425, 1429, 3, 204, 102, 0, 1426, 1427, 5, 112, 0, 0, 1427, 1429, 3, 208, 104, 0, 1428, 1424, 1, 0, 0, 0, 1428, 1426, 1, 0, 0, 0, 1429, 207, 1, 0, 0, 0, 1430, 1432, 5, 62, 0, 0, 1431, 1433, 3, 162, 81, 0, 1432, 1431, 1, 0, 0, 0, 1432, 1433, 1, 0, 0, 0, 1433, 1434, 1, 0, 0, 0, 1434, 1435, 5, 63, 0, 0, 1435, 209, 1, 0, 0, 0, 179, 211, 216, 222, 230, 239, 244, 251, 258, 261, 268, 278, 282, 287, 291, 295, 305, 313, 321, 325, 332, 339, 343, 346, 349, 358, 364, 369, 372, 378, 384, 388, 396, 405, 412, 418, 422, 433, 442, 447, 453, 457, 469, 480, 485, 494, 502, 512, 521, 529, 534, 542, 547, 557, 567, 573, 580, 585, 593, 597, 599, 605, 610, 614, 621, 627, 629, 636, 641, 650, 655, 658, 663, 672, 679, 690, 699, 709, 718, 723, 726, 733, 743, 751, 754, 757, 770, 778, 783, 791, 795, 799, 803, 805, 809, 815, 826, 836, 841, 850, 855, 858, 865, 874, 897, 900, 903, 911, 915, 923, 929, 940, 949, 954, 964, 971, 984, 993, 1002, 1008, 1019, 1024, 1029, 1034, 1038, 1042, 1046, 1048, 1052, 1057, 1074, 1080, 1086, 1092, 1095, 1106, 1114, 1128, 1132, 1137, 1141, 1157, 1197, 1203, 1218, 1221, 1223, 1233, 1242, 1246, 1250, 1268, 1270, 1275, 1280, 1285, 1294, 1296, 1300, 1305, 1309, 1313, 1317, 1327, 1339, 1346, 1349, 1353, 1361, 1366, 1377, 1383, 1388, 1393, 1400, 1411, 1420, 1422, 1428, 1432] \ No newline at end of file diff --git a/lexers/src/main/gen/com/itsaky/androidide/lexers/java/JavaParser.java b/lexers/src/main/gen/com/itsaky/androidide/lexers/java/JavaParser.java new file mode 100644 index 000000000..107415e7b --- /dev/null +++ b/lexers/src/main/gen/com/itsaky/androidide/lexers/java/JavaParser.java @@ -0,0 +1,10589 @@ +// Generated from /home/itsaky/Projects/Android/AndroidIDE/lexers/src/main/java/com/itsaky/androidide/lexers/java/JavaParser.g4 by ANTLR 4.10.1 +package com.itsaky.androidide.lexers.java; +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 JavaParser extends Parser { + static { RuntimeMetaData.checkVersion("4.10.1", RuntimeMetaData.VERSION); } + + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = + new PredictionContextCache(); + public static final int + ABSTRACT=1, ASSERT=2, BOOLEAN=3, BREAK=4, BYTE=5, CASE=6, CATCH=7, CHAR=8, + CLASS=9, CONST=10, CONTINUE=11, DEFAULT=12, DO=13, DOUBLE=14, ELSE=15, + ENUM=16, EXTENDS=17, FINAL=18, FINALLY=19, FLOAT=20, FOR=21, IF=22, GOTO=23, + IMPLEMENTS=24, IMPORT=25, INSTANCEOF=26, INT=27, INTERFACE=28, LONG=29, + NATIVE=30, NEW=31, PACKAGE=32, PRIVATE=33, PROTECTED=34, PUBLIC=35, RETURN=36, + SHORT=37, STATIC=38, STRICTFP=39, SUPER=40, SWITCH=41, SYNCHRONIZED=42, + THIS=43, THROW=44, THROWS=45, TRANSIENT=46, TRY=47, VAR=48, VOID=49, VOLATILE=50, + WHILE=51, DECIMAL_LITERAL=52, HEX_LITERAL=53, OCT_LITERAL=54, BINARY_LITERAL=55, + FLOAT_LITERAL=56, HEX_FLOAT_LITERAL=57, BOOL_LITERAL=58, CHAR_LITERAL=59, + STRING_LITERAL=60, NULL_LITERAL=61, LPAREN=62, RPAREN=63, LBRACE=64, RBRACE=65, + LBRACK=66, RBRACK=67, SEMI=68, COMMA=69, DOT=70, ASSIGN=71, GT=72, LT=73, + BANG=74, TILDE=75, QUESTION=76, COLON=77, EQUAL=78, LE=79, GE=80, NOTEQUAL=81, + AND=82, OR=83, INC=84, DEC=85, ADD=86, SUB=87, MUL=88, DIV=89, BITAND=90, + BITOR=91, CARET=92, MOD=93, ADD_ASSIGN=94, SUB_ASSIGN=95, MUL_ASSIGN=96, + DIV_ASSIGN=97, AND_ASSIGN=98, OR_ASSIGN=99, XOR_ASSIGN=100, MOD_ASSIGN=101, + LSHIFT_ASSIGN=102, RSHIFT_ASSIGN=103, URSHIFT_ASSIGN=104, ARROW=105, COLONCOLON=106, + AT=107, ELLIPSIS=108, WS=109, BLOCK_COMMENT=110, LINE_COMMENT=111, IDENTIFIER=112; + public static final int + RULE_compilationUnit = 0, RULE_packageDeclaration = 1, RULE_importDeclaration = 2, + RULE_typeDeclaration = 3, RULE_modifier = 4, RULE_classOrInterfaceModifier = 5, + RULE_variableModifier = 6, RULE_classDeclaration = 7, RULE_typeParameters = 8, + RULE_typeParameter = 9, RULE_typeBound = 10, RULE_enumDeclaration = 11, + RULE_enumConstants = 12, RULE_enumConstant = 13, RULE_enumBodyDeclarations = 14, + RULE_interfaceDeclaration = 15, RULE_classBody = 16, RULE_interfaceBody = 17, + RULE_classBodyDeclaration = 18, RULE_memberDeclaration = 19, RULE_methodDeclaration = 20, + RULE_methodBody = 21, RULE_typeTypeOrVoid = 22, RULE_genericMethodDeclaration = 23, + RULE_genericConstructorDeclaration = 24, RULE_constructorDeclaration = 25, + RULE_fieldDeclaration = 26, RULE_interfaceBodyDeclaration = 27, RULE_interfaceMemberDeclaration = 28, + RULE_constDeclaration = 29, RULE_constantDeclarator = 30, RULE_interfaceMethodDeclaration = 31, + RULE_interfaceMethodModifier = 32, RULE_genericInterfaceMethodDeclaration = 33, + RULE_variableDeclarators = 34, RULE_variableDeclarator = 35, RULE_variableDeclaratorId = 36, + RULE_variableInitializer = 37, RULE_arrayInitializer = 38, RULE_classOrInterfaceType = 39, + RULE_typeArgument = 40, RULE_qualifiedNameList = 41, RULE_formalParameters = 42, + RULE_formalParameterList = 43, RULE_formalParameter = 44, RULE_lastFormalParameter = 45, + RULE_qualifiedName = 46, RULE_literal = 47, RULE_integerLiteral = 48, + RULE_floatLiteral = 49, RULE_altAnnotationQualifiedName = 50, RULE_annotation = 51, + RULE_elementValuePairs = 52, RULE_elementValuePair = 53, RULE_elementValue = 54, + RULE_elementValueArrayInitializer = 55, RULE_annotationTypeDeclaration = 56, + RULE_annotationTypeBody = 57, RULE_annotationTypeElementDeclaration = 58, + RULE_annotationTypeElementRest = 59, RULE_annotationMethodOrConstantRest = 60, + RULE_annotationMethodRest = 61, RULE_annotationConstantRest = 62, RULE_defaultValue = 63, + RULE_block = 64, RULE_blockStatement = 65, RULE_localVariableDeclaration = 66, + RULE_localTypeDeclaration = 67, RULE_statement = 68, RULE_catchClause = 69, + RULE_catchType = 70, RULE_finallyBlock = 71, RULE_resourceSpecification = 72, + RULE_resources = 73, RULE_resource = 74, RULE_switchBlockStatementGroup = 75, + RULE_switchLabel = 76, RULE_forControl = 77, RULE_forInit = 78, RULE_enhancedForControl = 79, + RULE_parExpression = 80, RULE_expressionList = 81, RULE_methodCall = 82, + RULE_expression = 83, RULE_lambdaExpression = 84, RULE_lambdaParameters = 85, + RULE_lambdaBody = 86, RULE_primary = 87, RULE_classType = 88, RULE_creator = 89, + RULE_createdName = 90, RULE_innerCreator = 91, RULE_arrayCreatorRest = 92, + RULE_classCreatorRest = 93, RULE_explicitGenericInvocation = 94, RULE_typeArgumentsOrDiamond = 95, + RULE_nonWildcardTypeArgumentsOrDiamond = 96, RULE_nonWildcardTypeArguments = 97, + RULE_typeList = 98, RULE_typeType = 99, RULE_primitiveType = 100, RULE_typeArguments = 101, + RULE_superSuffix = 102, RULE_explicitGenericInvocationSuffix = 103, RULE_arguments = 104; + private static String[] makeRuleNames() { + return new String[] { + "compilationUnit", "packageDeclaration", "importDeclaration", "typeDeclaration", + "modifier", "classOrInterfaceModifier", "variableModifier", "classDeclaration", + "typeParameters", "typeParameter", "typeBound", "enumDeclaration", "enumConstants", + "enumConstant", "enumBodyDeclarations", "interfaceDeclaration", "classBody", + "interfaceBody", "classBodyDeclaration", "memberDeclaration", "methodDeclaration", + "methodBody", "typeTypeOrVoid", "genericMethodDeclaration", "genericConstructorDeclaration", + "constructorDeclaration", "fieldDeclaration", "interfaceBodyDeclaration", + "interfaceMemberDeclaration", "constDeclaration", "constantDeclarator", + "interfaceMethodDeclaration", "interfaceMethodModifier", "genericInterfaceMethodDeclaration", + "variableDeclarators", "variableDeclarator", "variableDeclaratorId", + "variableInitializer", "arrayInitializer", "classOrInterfaceType", "typeArgument", + "qualifiedNameList", "formalParameters", "formalParameterList", "formalParameter", + "lastFormalParameter", "qualifiedName", "literal", "integerLiteral", + "floatLiteral", "altAnnotationQualifiedName", "annotation", "elementValuePairs", + "elementValuePair", "elementValue", "elementValueArrayInitializer", "annotationTypeDeclaration", + "annotationTypeBody", "annotationTypeElementDeclaration", "annotationTypeElementRest", + "annotationMethodOrConstantRest", "annotationMethodRest", "annotationConstantRest", + "defaultValue", "block", "blockStatement", "localVariableDeclaration", + "localTypeDeclaration", "statement", "catchClause", "catchType", "finallyBlock", + "resourceSpecification", "resources", "resource", "switchBlockStatementGroup", + "switchLabel", "forControl", "forInit", "enhancedForControl", "parExpression", + "expressionList", "methodCall", "expression", "lambdaExpression", "lambdaParameters", + "lambdaBody", "primary", "classType", "creator", "createdName", "innerCreator", + "arrayCreatorRest", "classCreatorRest", "explicitGenericInvocation", + "typeArgumentsOrDiamond", "nonWildcardTypeArgumentsOrDiamond", "nonWildcardTypeArguments", + "typeList", "typeType", "primitiveType", "typeArguments", "superSuffix", + "explicitGenericInvocationSuffix", "arguments" + }; + } + public static final String[] ruleNames = makeRuleNames(); + + private static String[] makeLiteralNames() { + return new String[] { + null, "'abstract'", "'assert'", "'boolean'", "'break'", "'byte'", "'case'", + "'catch'", "'char'", "'class'", "'const'", "'continue'", "'default'", + "'do'", "'double'", "'else'", "'enum'", "'extends'", "'final'", "'finally'", + "'float'", "'for'", "'if'", "'goto'", "'implements'", "'import'", "'instanceof'", + "'int'", "'interface'", "'long'", "'native'", "'new'", "'package'", "'private'", + "'protected'", "'public'", "'return'", "'short'", "'static'", "'strictfp'", + "'super'", "'switch'", "'synchronized'", "'this'", "'throw'", "'throws'", + "'transient'", "'try'", "'var'", "'void'", "'volatile'", "'while'", null, + null, null, null, null, null, null, null, null, "'null'", "'('", "')'", + "'{'", "'}'", "'['", "']'", "';'", "','", "'.'", "'='", "'>'", "'<'", + "'!'", "'~'", "'?'", "':'", "'=='", "'<='", "'>='", "'!='", "'&&'", "'||'", + "'++'", "'--'", "'+'", "'-'", "'*'", "'/'", "'&'", "'|'", "'^'", "'%'", + "'+='", "'-='", "'*='", "'/='", "'&='", "'|='", "'^='", "'%='", "'<<='", + "'>>='", "'>>>='", "'->'", "'::'", "'@'", "'...'" + }; + } + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static String[] makeSymbolicNames() { + return new String[] { + null, "ABSTRACT", "ASSERT", "BOOLEAN", "BREAK", "BYTE", "CASE", "CATCH", + "CHAR", "CLASS", "CONST", "CONTINUE", "DEFAULT", "DO", "DOUBLE", "ELSE", + "ENUM", "EXTENDS", "FINAL", "FINALLY", "FLOAT", "FOR", "IF", "GOTO", + "IMPLEMENTS", "IMPORT", "INSTANCEOF", "INT", "INTERFACE", "LONG", "NATIVE", + "NEW", "PACKAGE", "PRIVATE", "PROTECTED", "PUBLIC", "RETURN", "SHORT", + "STATIC", "STRICTFP", "SUPER", "SWITCH", "SYNCHRONIZED", "THIS", "THROW", + "THROWS", "TRANSIENT", "TRY", "VAR", "VOID", "VOLATILE", "WHILE", "DECIMAL_LITERAL", + "HEX_LITERAL", "OCT_LITERAL", "BINARY_LITERAL", "FLOAT_LITERAL", "HEX_FLOAT_LITERAL", + "BOOL_LITERAL", "CHAR_LITERAL", "STRING_LITERAL", "NULL_LITERAL", "LPAREN", + "RPAREN", "LBRACE", "RBRACE", "LBRACK", "RBRACK", "SEMI", "COMMA", "DOT", + "ASSIGN", "GT", "LT", "BANG", "TILDE", "QUESTION", "COLON", "EQUAL", + "LE", "GE", "NOTEQUAL", "AND", "OR", "INC", "DEC", "ADD", "SUB", "MUL", + "DIV", "BITAND", "BITOR", "CARET", "MOD", "ADD_ASSIGN", "SUB_ASSIGN", + "MUL_ASSIGN", "DIV_ASSIGN", "AND_ASSIGN", "OR_ASSIGN", "XOR_ASSIGN", + "MOD_ASSIGN", "LSHIFT_ASSIGN", "RSHIFT_ASSIGN", "URSHIFT_ASSIGN", "ARROW", + "COLONCOLON", "AT", "ELLIPSIS", "WS", "BLOCK_COMMENT", "LINE_COMMENT", + "IDENTIFIER" + }; + } + 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 "JavaParser.g4"; } + + @Override + public String[] getRuleNames() { return ruleNames; } + + @Override + public String getSerializedATN() { return _serializedATN; } + + @Override + public ATN getATN() { return _ATN; } + + public JavaParser(TokenStream input) { + super(input); + _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); + } + + public static class CompilationUnitContext extends ParserRuleContext { + public TerminalNode EOF() { return getToken(JavaParser.EOF, 0); } + public PackageDeclarationContext packageDeclaration() { + return getRuleContext(PackageDeclarationContext.class,0); + } + public List importDeclaration() { + return getRuleContexts(ImportDeclarationContext.class); + } + public ImportDeclarationContext importDeclaration(int i) { + return getRuleContext(ImportDeclarationContext.class,i); + } + public List typeDeclaration() { + return getRuleContexts(TypeDeclarationContext.class); + } + public TypeDeclarationContext typeDeclaration(int i) { + return getRuleContext(TypeDeclarationContext.class,i); + } + public CompilationUnitContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_compilationUnit; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterCompilationUnit(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitCompilationUnit(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitCompilationUnit(this); + else return visitor.visitChildren(this); + } + } + + public final CompilationUnitContext compilationUnit() throws RecognitionException { + CompilationUnitContext _localctx = new CompilationUnitContext(_ctx, getState()); + enterRule(_localctx, 0, RULE_compilationUnit); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(211); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,0,_ctx) ) { + case 1: + { + setState(210); + packageDeclaration(); + } + break; + } + setState(216); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==IMPORT) { + { + { + setState(213); + importDeclaration(); + } + } + setState(218); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(222); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << CLASS) | (1L << ENUM) | (1L << FINAL) | (1L << INTERFACE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << (SEMI - 68)) | (1L << (AT - 68)) | (1L << (IDENTIFIER - 68)))) != 0)) { + { + { + setState(219); + typeDeclaration(); + } + } + setState(224); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(225); + match(EOF); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PackageDeclarationContext extends ParserRuleContext { + public TerminalNode PACKAGE() { return getToken(JavaParser.PACKAGE, 0); } + public QualifiedNameContext qualifiedName() { + return getRuleContext(QualifiedNameContext.class,0); + } + public TerminalNode SEMI() { return getToken(JavaParser.SEMI, 0); } + public List annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public PackageDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_packageDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterPackageDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitPackageDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitPackageDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final PackageDeclarationContext packageDeclaration() throws RecognitionException { + PackageDeclarationContext _localctx = new PackageDeclarationContext(_ctx, getState()); + enterRule(_localctx, 2, RULE_packageDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(230); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT || _la==IDENTIFIER) { + { + { + setState(227); + annotation(); + } + } + setState(232); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(233); + match(PACKAGE); + setState(234); + qualifiedName(); + setState(235); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ImportDeclarationContext extends ParserRuleContext { + public TerminalNode IMPORT() { return getToken(JavaParser.IMPORT, 0); } + public QualifiedNameContext qualifiedName() { + return getRuleContext(QualifiedNameContext.class,0); + } + public TerminalNode SEMI() { return getToken(JavaParser.SEMI, 0); } + public TerminalNode STATIC() { return getToken(JavaParser.STATIC, 0); } + public TerminalNode DOT() { return getToken(JavaParser.DOT, 0); } + public TerminalNode MUL() { return getToken(JavaParser.MUL, 0); } + public ImportDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_importDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterImportDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitImportDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitImportDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final ImportDeclarationContext importDeclaration() throws RecognitionException { + ImportDeclarationContext _localctx = new ImportDeclarationContext(_ctx, getState()); + enterRule(_localctx, 4, RULE_importDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(237); + match(IMPORT); + setState(239); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==STATIC) { + { + setState(238); + match(STATIC); + } + } + + setState(241); + qualifiedName(); + setState(244); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==DOT) { + { + setState(242); + match(DOT); + setState(243); + match(MUL); + } + } + + setState(246); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeDeclarationContext extends ParserRuleContext { + public ClassDeclarationContext classDeclaration() { + return getRuleContext(ClassDeclarationContext.class,0); + } + public EnumDeclarationContext enumDeclaration() { + return getRuleContext(EnumDeclarationContext.class,0); + } + public InterfaceDeclarationContext interfaceDeclaration() { + return getRuleContext(InterfaceDeclarationContext.class,0); + } + public AnnotationTypeDeclarationContext annotationTypeDeclaration() { + return getRuleContext(AnnotationTypeDeclarationContext.class,0); + } + public List classOrInterfaceModifier() { + return getRuleContexts(ClassOrInterfaceModifierContext.class); + } + public ClassOrInterfaceModifierContext classOrInterfaceModifier(int i) { + return getRuleContext(ClassOrInterfaceModifierContext.class,i); + } + public TerminalNode SEMI() { return getToken(JavaParser.SEMI, 0); } + public TypeDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterTypeDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitTypeDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitTypeDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final TypeDeclarationContext typeDeclaration() throws RecognitionException { + TypeDeclarationContext _localctx = new TypeDeclarationContext(_ctx, getState()); + enterRule(_localctx, 6, RULE_typeDeclaration); + try { + int _alt; + setState(261); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ABSTRACT: + case CLASS: + case ENUM: + case FINAL: + case INTERFACE: + case PRIVATE: + case PROTECTED: + case PUBLIC: + case STATIC: + case STRICTFP: + case AT: + case IDENTIFIER: + enterOuterAlt(_localctx, 1); + { + setState(251); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,6,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(248); + classOrInterfaceModifier(); + } + } + } + setState(253); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,6,_ctx); + } + setState(258); + _errHandler.sync(this); + switch (_input.LA(1)) { + case CLASS: + { + setState(254); + classDeclaration(); + } + break; + case ENUM: + { + setState(255); + enumDeclaration(); + } + break; + case INTERFACE: + { + setState(256); + interfaceDeclaration(); + } + break; + case AT: + { + setState(257); + annotationTypeDeclaration(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case SEMI: + enterOuterAlt(_localctx, 2); + { + setState(260); + 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 ModifierContext extends ParserRuleContext { + public ClassOrInterfaceModifierContext classOrInterfaceModifier() { + return getRuleContext(ClassOrInterfaceModifierContext.class,0); + } + public TerminalNode NATIVE() { return getToken(JavaParser.NATIVE, 0); } + public TerminalNode SYNCHRONIZED() { return getToken(JavaParser.SYNCHRONIZED, 0); } + public TerminalNode TRANSIENT() { return getToken(JavaParser.TRANSIENT, 0); } + public TerminalNode VOLATILE() { return getToken(JavaParser.VOLATILE, 0); } + public ModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_modifier; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterModifier(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitModifier(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitModifier(this); + else return visitor.visitChildren(this); + } + } + + public final ModifierContext modifier() throws RecognitionException { + ModifierContext _localctx = new ModifierContext(_ctx, getState()); + enterRule(_localctx, 8, RULE_modifier); + try { + setState(268); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ABSTRACT: + case FINAL: + case PRIVATE: + case PROTECTED: + case PUBLIC: + case STATIC: + case STRICTFP: + case AT: + case IDENTIFIER: + enterOuterAlt(_localctx, 1); + { + setState(263); + classOrInterfaceModifier(); + } + break; + case NATIVE: + enterOuterAlt(_localctx, 2); + { + setState(264); + match(NATIVE); + } + break; + case SYNCHRONIZED: + enterOuterAlt(_localctx, 3); + { + setState(265); + match(SYNCHRONIZED); + } + break; + case TRANSIENT: + enterOuterAlt(_localctx, 4); + { + setState(266); + match(TRANSIENT); + } + break; + case VOLATILE: + enterOuterAlt(_localctx, 5); + { + setState(267); + match(VOLATILE); + } + 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 ClassOrInterfaceModifierContext extends ParserRuleContext { + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class,0); + } + public TerminalNode PUBLIC() { return getToken(JavaParser.PUBLIC, 0); } + public TerminalNode PROTECTED() { return getToken(JavaParser.PROTECTED, 0); } + public TerminalNode PRIVATE() { return getToken(JavaParser.PRIVATE, 0); } + public TerminalNode STATIC() { return getToken(JavaParser.STATIC, 0); } + public TerminalNode ABSTRACT() { return getToken(JavaParser.ABSTRACT, 0); } + public TerminalNode FINAL() { return getToken(JavaParser.FINAL, 0); } + public TerminalNode STRICTFP() { return getToken(JavaParser.STRICTFP, 0); } + public ClassOrInterfaceModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classOrInterfaceModifier; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterClassOrInterfaceModifier(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitClassOrInterfaceModifier(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitClassOrInterfaceModifier(this); + else return visitor.visitChildren(this); + } + } + + public final ClassOrInterfaceModifierContext classOrInterfaceModifier() throws RecognitionException { + ClassOrInterfaceModifierContext _localctx = new ClassOrInterfaceModifierContext(_ctx, getState()); + enterRule(_localctx, 10, RULE_classOrInterfaceModifier); + try { + setState(278); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AT: + case IDENTIFIER: + enterOuterAlt(_localctx, 1); + { + setState(270); + annotation(); + } + break; + case PUBLIC: + enterOuterAlt(_localctx, 2); + { + setState(271); + match(PUBLIC); + } + break; + case PROTECTED: + enterOuterAlt(_localctx, 3); + { + setState(272); + match(PROTECTED); + } + break; + case PRIVATE: + enterOuterAlt(_localctx, 4); + { + setState(273); + match(PRIVATE); + } + break; + case STATIC: + enterOuterAlt(_localctx, 5); + { + setState(274); + match(STATIC); + } + break; + case ABSTRACT: + enterOuterAlt(_localctx, 6); + { + setState(275); + match(ABSTRACT); + } + break; + case FINAL: + enterOuterAlt(_localctx, 7); + { + setState(276); + match(FINAL); + } + break; + case STRICTFP: + enterOuterAlt(_localctx, 8); + { + setState(277); + match(STRICTFP); + } + 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 VariableModifierContext extends ParserRuleContext { + public TerminalNode FINAL() { return getToken(JavaParser.FINAL, 0); } + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class,0); + } + public VariableModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variableModifier; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterVariableModifier(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitVariableModifier(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitVariableModifier(this); + else return visitor.visitChildren(this); + } + } + + public final VariableModifierContext variableModifier() throws RecognitionException { + VariableModifierContext _localctx = new VariableModifierContext(_ctx, getState()); + enterRule(_localctx, 12, RULE_variableModifier); + try { + setState(282); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FINAL: + enterOuterAlt(_localctx, 1); + { + setState(280); + match(FINAL); + } + break; + case AT: + case IDENTIFIER: + enterOuterAlt(_localctx, 2); + { + setState(281); + annotation(); + } + 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 ClassDeclarationContext extends ParserRuleContext { + public TerminalNode CLASS() { return getToken(JavaParser.CLASS, 0); } + public TerminalNode IDENTIFIER() { return getToken(JavaParser.IDENTIFIER, 0); } + public ClassBodyContext classBody() { + return getRuleContext(ClassBodyContext.class,0); + } + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class,0); + } + public TerminalNode EXTENDS() { return getToken(JavaParser.EXTENDS, 0); } + public TypeTypeContext typeType() { + return getRuleContext(TypeTypeContext.class,0); + } + public TerminalNode IMPLEMENTS() { return getToken(JavaParser.IMPLEMENTS, 0); } + public TypeListContext typeList() { + return getRuleContext(TypeListContext.class,0); + } + public ClassDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterClassDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitClassDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitClassDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final ClassDeclarationContext classDeclaration() throws RecognitionException { + ClassDeclarationContext _localctx = new ClassDeclarationContext(_ctx, getState()); + enterRule(_localctx, 14, RULE_classDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(284); + match(CLASS); + setState(285); + match(IDENTIFIER); + setState(287); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LT) { + { + setState(286); + typeParameters(); + } + } + + setState(291); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EXTENDS) { + { + setState(289); + match(EXTENDS); + setState(290); + typeType(); + } + } + + setState(295); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IMPLEMENTS) { + { + setState(293); + match(IMPLEMENTS); + setState(294); + typeList(); + } + } + + setState(297); + classBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeParametersContext extends ParserRuleContext { + public TerminalNode LT() { return getToken(JavaParser.LT, 0); } + public List typeParameter() { + return getRuleContexts(TypeParameterContext.class); + } + public TypeParameterContext typeParameter(int i) { + return getRuleContext(TypeParameterContext.class,i); + } + public TerminalNode GT() { return getToken(JavaParser.GT, 0); } + public List COMMA() { return getTokens(JavaParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(JavaParser.COMMA, i); + } + public TypeParametersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeParameters; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterTypeParameters(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitTypeParameters(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitTypeParameters(this); + else return visitor.visitChildren(this); + } + } + + public final TypeParametersContext typeParameters() throws RecognitionException { + TypeParametersContext _localctx = new TypeParametersContext(_ctx, getState()); + enterRule(_localctx, 16, RULE_typeParameters); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(299); + match(LT); + setState(300); + typeParameter(); + setState(305); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(301); + match(COMMA); + setState(302); + typeParameter(); + } + } + setState(307); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(308); + match(GT); + } + } + 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 IDENTIFIER() { return getToken(JavaParser.IDENTIFIER, 0); } + public List annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public TerminalNode EXTENDS() { return getToken(JavaParser.EXTENDS, 0); } + public TypeBoundContext typeBound() { + return getRuleContext(TypeBoundContext.class,0); + } + public TypeParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeParameter; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterTypeParameter(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitTypeParameter(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitTypeParameter(this); + else return visitor.visitChildren(this); + } + } + + public final TypeParameterContext typeParameter() throws RecognitionException { + TypeParameterContext _localctx = new TypeParameterContext(_ctx, getState()); + enterRule(_localctx, 18, RULE_typeParameter); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(313); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,16,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(310); + annotation(); + } + } + } + setState(315); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,16,_ctx); + } + setState(316); + match(IDENTIFIER); + setState(325); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EXTENDS) { + { + setState(317); + match(EXTENDS); + setState(321); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,17,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(318); + annotation(); + } + } + } + setState(323); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,17,_ctx); + } + setState(324); + typeBound(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeBoundContext extends ParserRuleContext { + public List typeType() { + return getRuleContexts(TypeTypeContext.class); + } + public TypeTypeContext typeType(int i) { + return getRuleContext(TypeTypeContext.class,i); + } + public List BITAND() { return getTokens(JavaParser.BITAND); } + public TerminalNode BITAND(int i) { + return getToken(JavaParser.BITAND, i); + } + public TypeBoundContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeBound; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterTypeBound(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitTypeBound(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitTypeBound(this); + else return visitor.visitChildren(this); + } + } + + public final TypeBoundContext typeBound() throws RecognitionException { + TypeBoundContext _localctx = new TypeBoundContext(_ctx, getState()); + enterRule(_localctx, 20, RULE_typeBound); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(327); + typeType(); + setState(332); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==BITAND) { + { + { + setState(328); + match(BITAND); + setState(329); + typeType(); + } + } + setState(334); + _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 EnumDeclarationContext extends ParserRuleContext { + public TerminalNode ENUM() { return getToken(JavaParser.ENUM, 0); } + public TerminalNode IDENTIFIER() { return getToken(JavaParser.IDENTIFIER, 0); } + public TerminalNode LBRACE() { return getToken(JavaParser.LBRACE, 0); } + public TerminalNode RBRACE() { return getToken(JavaParser.RBRACE, 0); } + public TerminalNode IMPLEMENTS() { return getToken(JavaParser.IMPLEMENTS, 0); } + public TypeListContext typeList() { + return getRuleContext(TypeListContext.class,0); + } + public EnumConstantsContext enumConstants() { + return getRuleContext(EnumConstantsContext.class,0); + } + public TerminalNode COMMA() { return getToken(JavaParser.COMMA, 0); } + public EnumBodyDeclarationsContext enumBodyDeclarations() { + return getRuleContext(EnumBodyDeclarationsContext.class,0); + } + public EnumDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enumDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterEnumDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitEnumDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitEnumDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final EnumDeclarationContext enumDeclaration() throws RecognitionException { + EnumDeclarationContext _localctx = new EnumDeclarationContext(_ctx, getState()); + enterRule(_localctx, 22, RULE_enumDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(335); + match(ENUM); + setState(336); + match(IDENTIFIER); + setState(339); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IMPLEMENTS) { + { + setState(337); + match(IMPLEMENTS); + setState(338); + typeList(); + } + } + + setState(341); + match(LBRACE); + setState(343); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==AT || _la==IDENTIFIER) { + { + setState(342); + enumConstants(); + } + } + + setState(346); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(345); + match(COMMA); + } + } + + setState(349); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==SEMI) { + { + setState(348); + enumBodyDeclarations(); + } + } + + setState(351); + match(RBRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EnumConstantsContext extends ParserRuleContext { + public List enumConstant() { + return getRuleContexts(EnumConstantContext.class); + } + public EnumConstantContext enumConstant(int i) { + return getRuleContext(EnumConstantContext.class,i); + } + public List COMMA() { return getTokens(JavaParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(JavaParser.COMMA, i); + } + public EnumConstantsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enumConstants; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterEnumConstants(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitEnumConstants(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitEnumConstants(this); + else return visitor.visitChildren(this); + } + } + + public final EnumConstantsContext enumConstants() throws RecognitionException { + EnumConstantsContext _localctx = new EnumConstantsContext(_ctx, getState()); + enterRule(_localctx, 24, RULE_enumConstants); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(353); + enumConstant(); + setState(358); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,24,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(354); + match(COMMA); + setState(355); + enumConstant(); + } + } + } + setState(360); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,24,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EnumConstantContext extends ParserRuleContext { + public TerminalNode IDENTIFIER() { return getToken(JavaParser.IDENTIFIER, 0); } + public List annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public ArgumentsContext arguments() { + return getRuleContext(ArgumentsContext.class,0); + } + public ClassBodyContext classBody() { + return getRuleContext(ClassBodyContext.class,0); + } + public EnumConstantContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enumConstant; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterEnumConstant(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitEnumConstant(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitEnumConstant(this); + else return visitor.visitChildren(this); + } + } + + public final EnumConstantContext enumConstant() throws RecognitionException { + EnumConstantContext _localctx = new EnumConstantContext(_ctx, getState()); + enterRule(_localctx, 26, RULE_enumConstant); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(364); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,25,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(361); + annotation(); + } + } + } + setState(366); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,25,_ctx); + } + setState(367); + match(IDENTIFIER); + setState(369); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LPAREN) { + { + setState(368); + arguments(); + } + } + + setState(372); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LBRACE) { + { + setState(371); + classBody(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EnumBodyDeclarationsContext extends ParserRuleContext { + public TerminalNode SEMI() { return getToken(JavaParser.SEMI, 0); } + public List classBodyDeclaration() { + return getRuleContexts(ClassBodyDeclarationContext.class); + } + public ClassBodyDeclarationContext classBodyDeclaration(int i) { + return getRuleContext(ClassBodyDeclarationContext.class,i); + } + public EnumBodyDeclarationsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enumBodyDeclarations; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterEnumBodyDeclarations(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitEnumBodyDeclarations(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitEnumBodyDeclarations(this); + else return visitor.visitChildren(this); + } + } + + public final EnumBodyDeclarationsContext enumBodyDeclarations() throws RecognitionException { + EnumBodyDeclarationsContext _localctx = new EnumBodyDeclarationsContext(_ctx, getState()); + enterRule(_localctx, 28, RULE_enumBodyDeclarations); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(374); + match(SEMI); + setState(378); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << NATIVE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SYNCHRONIZED) | (1L << TRANSIENT) | (1L << VOID) | (1L << VOLATILE))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (LBRACE - 64)) | (1L << (SEMI - 64)) | (1L << (LT - 64)) | (1L << (AT - 64)) | (1L << (IDENTIFIER - 64)))) != 0)) { + { + { + setState(375); + classBodyDeclaration(); + } + } + setState(380); + _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 InterfaceDeclarationContext extends ParserRuleContext { + public TerminalNode INTERFACE() { return getToken(JavaParser.INTERFACE, 0); } + public TerminalNode IDENTIFIER() { return getToken(JavaParser.IDENTIFIER, 0); } + public InterfaceBodyContext interfaceBody() { + return getRuleContext(InterfaceBodyContext.class,0); + } + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class,0); + } + public TerminalNode EXTENDS() { return getToken(JavaParser.EXTENDS, 0); } + public TypeListContext typeList() { + return getRuleContext(TypeListContext.class,0); + } + public InterfaceDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interfaceDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterInterfaceDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitInterfaceDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitInterfaceDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final InterfaceDeclarationContext interfaceDeclaration() throws RecognitionException { + InterfaceDeclarationContext _localctx = new InterfaceDeclarationContext(_ctx, getState()); + enterRule(_localctx, 30, RULE_interfaceDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(381); + match(INTERFACE); + setState(382); + match(IDENTIFIER); + setState(384); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LT) { + { + setState(383); + typeParameters(); + } + } + + setState(388); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EXTENDS) { + { + setState(386); + match(EXTENDS); + setState(387); + typeList(); + } + } + + setState(390); + interfaceBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassBodyContext extends ParserRuleContext { + public TerminalNode LBRACE() { return getToken(JavaParser.LBRACE, 0); } + public TerminalNode RBRACE() { return getToken(JavaParser.RBRACE, 0); } + public List classBodyDeclaration() { + return getRuleContexts(ClassBodyDeclarationContext.class); + } + public ClassBodyDeclarationContext classBodyDeclaration(int i) { + return getRuleContext(ClassBodyDeclarationContext.class,i); + } + public ClassBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classBody; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterClassBody(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitClassBody(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitClassBody(this); + else return visitor.visitChildren(this); + } + } + + public final ClassBodyContext classBody() throws RecognitionException { + ClassBodyContext _localctx = new ClassBodyContext(_ctx, getState()); + enterRule(_localctx, 32, RULE_classBody); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(392); + match(LBRACE); + setState(396); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << NATIVE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SYNCHRONIZED) | (1L << TRANSIENT) | (1L << VOID) | (1L << VOLATILE))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (LBRACE - 64)) | (1L << (SEMI - 64)) | (1L << (LT - 64)) | (1L << (AT - 64)) | (1L << (IDENTIFIER - 64)))) != 0)) { + { + { + setState(393); + classBodyDeclaration(); + } + } + setState(398); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(399); + match(RBRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InterfaceBodyContext extends ParserRuleContext { + public TerminalNode LBRACE() { return getToken(JavaParser.LBRACE, 0); } + public TerminalNode RBRACE() { return getToken(JavaParser.RBRACE, 0); } + public List interfaceBodyDeclaration() { + return getRuleContexts(InterfaceBodyDeclarationContext.class); + } + public InterfaceBodyDeclarationContext interfaceBodyDeclaration(int i) { + return getRuleContext(InterfaceBodyDeclarationContext.class,i); + } + public InterfaceBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interfaceBody; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterInterfaceBody(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitInterfaceBody(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitInterfaceBody(this); + else return visitor.visitChildren(this); + } + } + + public final InterfaceBodyContext interfaceBody() throws RecognitionException { + InterfaceBodyContext _localctx = new InterfaceBodyContext(_ctx, getState()); + enterRule(_localctx, 34, RULE_interfaceBody); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(401); + match(LBRACE); + setState(405); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DEFAULT) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << NATIVE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SYNCHRONIZED) | (1L << TRANSIENT) | (1L << VOID) | (1L << VOLATILE))) != 0) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << (SEMI - 68)) | (1L << (LT - 68)) | (1L << (AT - 68)) | (1L << (IDENTIFIER - 68)))) != 0)) { + { + { + setState(402); + interfaceBodyDeclaration(); + } + } + setState(407); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(408); + match(RBRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassBodyDeclarationContext extends ParserRuleContext { + public TerminalNode SEMI() { return getToken(JavaParser.SEMI, 0); } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public TerminalNode STATIC() { return getToken(JavaParser.STATIC, 0); } + public MemberDeclarationContext memberDeclaration() { + return getRuleContext(MemberDeclarationContext.class,0); + } + public List modifier() { + return getRuleContexts(ModifierContext.class); + } + public ModifierContext modifier(int i) { + return getRuleContext(ModifierContext.class,i); + } + public ClassBodyDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classBodyDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterClassBodyDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitClassBodyDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitClassBodyDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final ClassBodyDeclarationContext classBodyDeclaration() throws RecognitionException { + ClassBodyDeclarationContext _localctx = new ClassBodyDeclarationContext(_ctx, getState()); + enterRule(_localctx, 36, RULE_classBodyDeclaration); + int _la; + try { + int _alt; + setState(422); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(410); + match(SEMI); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(412); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==STATIC) { + { + setState(411); + match(STATIC); + } + } + + setState(414); + block(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(418); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,34,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(415); + modifier(); + } + } + } + setState(420); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,34,_ctx); + } + setState(421); + memberDeclaration(); + } + break; + } + } + 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 MethodDeclarationContext methodDeclaration() { + return getRuleContext(MethodDeclarationContext.class,0); + } + public GenericMethodDeclarationContext genericMethodDeclaration() { + return getRuleContext(GenericMethodDeclarationContext.class,0); + } + public FieldDeclarationContext fieldDeclaration() { + return getRuleContext(FieldDeclarationContext.class,0); + } + public ConstructorDeclarationContext constructorDeclaration() { + return getRuleContext(ConstructorDeclarationContext.class,0); + } + public GenericConstructorDeclarationContext genericConstructorDeclaration() { + return getRuleContext(GenericConstructorDeclarationContext.class,0); + } + public InterfaceDeclarationContext interfaceDeclaration() { + return getRuleContext(InterfaceDeclarationContext.class,0); + } + public AnnotationTypeDeclarationContext annotationTypeDeclaration() { + return getRuleContext(AnnotationTypeDeclarationContext.class,0); + } + public ClassDeclarationContext classDeclaration() { + return getRuleContext(ClassDeclarationContext.class,0); + } + public EnumDeclarationContext enumDeclaration() { + return getRuleContext(EnumDeclarationContext.class,0); + } + public MemberDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_memberDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterMemberDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitMemberDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitMemberDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final MemberDeclarationContext memberDeclaration() throws RecognitionException { + MemberDeclarationContext _localctx = new MemberDeclarationContext(_ctx, getState()); + enterRule(_localctx, 38, RULE_memberDeclaration); + try { + setState(433); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,36,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(424); + methodDeclaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(425); + genericMethodDeclaration(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(426); + fieldDeclaration(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(427); + constructorDeclaration(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(428); + genericConstructorDeclaration(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(429); + interfaceDeclaration(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(430); + annotationTypeDeclaration(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(431); + classDeclaration(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(432); + enumDeclaration(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MethodDeclarationContext extends ParserRuleContext { + public TypeTypeOrVoidContext typeTypeOrVoid() { + return getRuleContext(TypeTypeOrVoidContext.class,0); + } + public TerminalNode IDENTIFIER() { return getToken(JavaParser.IDENTIFIER, 0); } + public FormalParametersContext formalParameters() { + return getRuleContext(FormalParametersContext.class,0); + } + public MethodBodyContext methodBody() { + return getRuleContext(MethodBodyContext.class,0); + } + public List LBRACK() { return getTokens(JavaParser.LBRACK); } + public TerminalNode LBRACK(int i) { + return getToken(JavaParser.LBRACK, i); + } + public List RBRACK() { return getTokens(JavaParser.RBRACK); } + public TerminalNode RBRACK(int i) { + return getToken(JavaParser.RBRACK, i); + } + public TerminalNode THROWS() { return getToken(JavaParser.THROWS, 0); } + public QualifiedNameListContext qualifiedNameList() { + return getRuleContext(QualifiedNameListContext.class,0); + } + public MethodDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_methodDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterMethodDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitMethodDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitMethodDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final MethodDeclarationContext methodDeclaration() throws RecognitionException { + MethodDeclarationContext _localctx = new MethodDeclarationContext(_ctx, getState()); + enterRule(_localctx, 40, RULE_methodDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(435); + typeTypeOrVoid(); + setState(436); + match(IDENTIFIER); + setState(437); + formalParameters(); + setState(442); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==LBRACK) { + { + { + setState(438); + match(LBRACK); + setState(439); + match(RBRACK); + } + } + setState(444); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(447); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==THROWS) { + { + setState(445); + match(THROWS); + setState(446); + qualifiedNameList(); + } + } + + setState(449); + methodBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class MethodBodyContext extends ParserRuleContext { + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public TerminalNode SEMI() { return getToken(JavaParser.SEMI, 0); } + public MethodBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_methodBody; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterMethodBody(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitMethodBody(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitMethodBody(this); + else return visitor.visitChildren(this); + } + } + + public final MethodBodyContext methodBody() throws RecognitionException { + MethodBodyContext _localctx = new MethodBodyContext(_ctx, getState()); + enterRule(_localctx, 42, RULE_methodBody); + try { + setState(453); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LBRACE: + enterOuterAlt(_localctx, 1); + { + setState(451); + block(); + } + break; + case SEMI: + enterOuterAlt(_localctx, 2); + { + setState(452); + 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 TypeTypeOrVoidContext extends ParserRuleContext { + public TypeTypeContext typeType() { + return getRuleContext(TypeTypeContext.class,0); + } + public TerminalNode VOID() { return getToken(JavaParser.VOID, 0); } + public TypeTypeOrVoidContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeTypeOrVoid; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterTypeTypeOrVoid(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitTypeTypeOrVoid(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitTypeTypeOrVoid(this); + else return visitor.visitChildren(this); + } + } + + public final TypeTypeOrVoidContext typeTypeOrVoid() throws RecognitionException { + TypeTypeOrVoidContext _localctx = new TypeTypeOrVoidContext(_ctx, getState()); + enterRule(_localctx, 44, RULE_typeTypeOrVoid); + try { + setState(457); + _errHandler.sync(this); + switch (_input.LA(1)) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case SHORT: + case AT: + case IDENTIFIER: + enterOuterAlt(_localctx, 1); + { + setState(455); + typeType(); + } + break; + case VOID: + enterOuterAlt(_localctx, 2); + { + setState(456); + match(VOID); + } + 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 GenericMethodDeclarationContext extends ParserRuleContext { + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class,0); + } + public MethodDeclarationContext methodDeclaration() { + return getRuleContext(MethodDeclarationContext.class,0); + } + public GenericMethodDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_genericMethodDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterGenericMethodDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitGenericMethodDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitGenericMethodDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final GenericMethodDeclarationContext genericMethodDeclaration() throws RecognitionException { + GenericMethodDeclarationContext _localctx = new GenericMethodDeclarationContext(_ctx, getState()); + enterRule(_localctx, 46, RULE_genericMethodDeclaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(459); + typeParameters(); + setState(460); + methodDeclaration(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class GenericConstructorDeclarationContext extends ParserRuleContext { + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class,0); + } + public ConstructorDeclarationContext constructorDeclaration() { + return getRuleContext(ConstructorDeclarationContext.class,0); + } + public GenericConstructorDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_genericConstructorDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterGenericConstructorDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitGenericConstructorDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitGenericConstructorDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final GenericConstructorDeclarationContext genericConstructorDeclaration() throws RecognitionException { + GenericConstructorDeclarationContext _localctx = new GenericConstructorDeclarationContext(_ctx, getState()); + enterRule(_localctx, 48, RULE_genericConstructorDeclaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(462); + typeParameters(); + setState(463); + constructorDeclaration(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ConstructorDeclarationContext extends ParserRuleContext { + public BlockContext constructorBody; + public TerminalNode IDENTIFIER() { return getToken(JavaParser.IDENTIFIER, 0); } + public FormalParametersContext formalParameters() { + return getRuleContext(FormalParametersContext.class,0); + } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public TerminalNode THROWS() { return getToken(JavaParser.THROWS, 0); } + public QualifiedNameListContext qualifiedNameList() { + return getRuleContext(QualifiedNameListContext.class,0); + } + public ConstructorDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constructorDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterConstructorDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitConstructorDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitConstructorDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final ConstructorDeclarationContext constructorDeclaration() throws RecognitionException { + ConstructorDeclarationContext _localctx = new ConstructorDeclarationContext(_ctx, getState()); + enterRule(_localctx, 50, RULE_constructorDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(465); + match(IDENTIFIER); + setState(466); + formalParameters(); + setState(469); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==THROWS) { + { + setState(467); + match(THROWS); + setState(468); + qualifiedNameList(); + } + } + + setState(471); + ((ConstructorDeclarationContext)_localctx).constructorBody = block(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FieldDeclarationContext extends ParserRuleContext { + public TypeTypeContext typeType() { + return getRuleContext(TypeTypeContext.class,0); + } + public VariableDeclaratorsContext variableDeclarators() { + return getRuleContext(VariableDeclaratorsContext.class,0); + } + public TerminalNode SEMI() { return getToken(JavaParser.SEMI, 0); } + public FieldDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_fieldDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterFieldDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitFieldDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitFieldDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final FieldDeclarationContext fieldDeclaration() throws RecognitionException { + FieldDeclarationContext _localctx = new FieldDeclarationContext(_ctx, getState()); + enterRule(_localctx, 52, RULE_fieldDeclaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(473); + typeType(); + setState(474); + variableDeclarators(); + setState(475); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InterfaceBodyDeclarationContext extends ParserRuleContext { + public InterfaceMemberDeclarationContext interfaceMemberDeclaration() { + return getRuleContext(InterfaceMemberDeclarationContext.class,0); + } + public List modifier() { + return getRuleContexts(ModifierContext.class); + } + public ModifierContext modifier(int i) { + return getRuleContext(ModifierContext.class,i); + } + public TerminalNode SEMI() { return getToken(JavaParser.SEMI, 0); } + public InterfaceBodyDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interfaceBodyDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterInterfaceBodyDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitInterfaceBodyDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitInterfaceBodyDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final InterfaceBodyDeclarationContext interfaceBodyDeclaration() throws RecognitionException { + InterfaceBodyDeclarationContext _localctx = new InterfaceBodyDeclarationContext(_ctx, getState()); + enterRule(_localctx, 54, RULE_interfaceBodyDeclaration); + try { + int _alt; + setState(485); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ABSTRACT: + case BOOLEAN: + case BYTE: + case CHAR: + case CLASS: + case DEFAULT: + case DOUBLE: + case ENUM: + case FINAL: + case FLOAT: + case INT: + case INTERFACE: + case LONG: + case NATIVE: + case PRIVATE: + case PROTECTED: + case PUBLIC: + case SHORT: + case STATIC: + case STRICTFP: + case SYNCHRONIZED: + case TRANSIENT: + case VOID: + case VOLATILE: + case LT: + case AT: + case IDENTIFIER: + enterOuterAlt(_localctx, 1); + { + setState(480); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,42,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(477); + modifier(); + } + } + } + setState(482); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,42,_ctx); + } + setState(483); + interfaceMemberDeclaration(); + } + break; + case SEMI: + enterOuterAlt(_localctx, 2); + { + setState(484); + 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 InterfaceMemberDeclarationContext extends ParserRuleContext { + public ConstDeclarationContext constDeclaration() { + return getRuleContext(ConstDeclarationContext.class,0); + } + public InterfaceMethodDeclarationContext interfaceMethodDeclaration() { + return getRuleContext(InterfaceMethodDeclarationContext.class,0); + } + public GenericInterfaceMethodDeclarationContext genericInterfaceMethodDeclaration() { + return getRuleContext(GenericInterfaceMethodDeclarationContext.class,0); + } + public InterfaceDeclarationContext interfaceDeclaration() { + return getRuleContext(InterfaceDeclarationContext.class,0); + } + public AnnotationTypeDeclarationContext annotationTypeDeclaration() { + return getRuleContext(AnnotationTypeDeclarationContext.class,0); + } + public ClassDeclarationContext classDeclaration() { + return getRuleContext(ClassDeclarationContext.class,0); + } + public EnumDeclarationContext enumDeclaration() { + return getRuleContext(EnumDeclarationContext.class,0); + } + public InterfaceMemberDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interfaceMemberDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterInterfaceMemberDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitInterfaceMemberDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitInterfaceMemberDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final InterfaceMemberDeclarationContext interfaceMemberDeclaration() throws RecognitionException { + InterfaceMemberDeclarationContext _localctx = new InterfaceMemberDeclarationContext(_ctx, getState()); + enterRule(_localctx, 56, RULE_interfaceMemberDeclaration); + try { + setState(494); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,44,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(487); + constDeclaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(488); + interfaceMethodDeclaration(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(489); + genericInterfaceMethodDeclaration(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(490); + interfaceDeclaration(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(491); + annotationTypeDeclaration(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(492); + classDeclaration(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(493); + enumDeclaration(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ConstDeclarationContext extends ParserRuleContext { + public TypeTypeContext typeType() { + return getRuleContext(TypeTypeContext.class,0); + } + public List constantDeclarator() { + return getRuleContexts(ConstantDeclaratorContext.class); + } + public ConstantDeclaratorContext constantDeclarator(int i) { + return getRuleContext(ConstantDeclaratorContext.class,i); + } + public TerminalNode SEMI() { return getToken(JavaParser.SEMI, 0); } + public List COMMA() { return getTokens(JavaParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(JavaParser.COMMA, i); + } + public ConstDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterConstDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitConstDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitConstDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final ConstDeclarationContext constDeclaration() throws RecognitionException { + ConstDeclarationContext _localctx = new ConstDeclarationContext(_ctx, getState()); + enterRule(_localctx, 58, RULE_constDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(496); + typeType(); + setState(497); + constantDeclarator(); + setState(502); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(498); + match(COMMA); + setState(499); + constantDeclarator(); + } + } + setState(504); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(505); + match(SEMI); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ConstantDeclaratorContext extends ParserRuleContext { + public TerminalNode IDENTIFIER() { return getToken(JavaParser.IDENTIFIER, 0); } + public TerminalNode ASSIGN() { return getToken(JavaParser.ASSIGN, 0); } + public VariableInitializerContext variableInitializer() { + return getRuleContext(VariableInitializerContext.class,0); + } + public List LBRACK() { return getTokens(JavaParser.LBRACK); } + public TerminalNode LBRACK(int i) { + return getToken(JavaParser.LBRACK, i); + } + public List RBRACK() { return getTokens(JavaParser.RBRACK); } + public TerminalNode RBRACK(int i) { + return getToken(JavaParser.RBRACK, i); + } + public ConstantDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_constantDeclarator; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterConstantDeclarator(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitConstantDeclarator(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitConstantDeclarator(this); + else return visitor.visitChildren(this); + } + } + + public final ConstantDeclaratorContext constantDeclarator() throws RecognitionException { + ConstantDeclaratorContext _localctx = new ConstantDeclaratorContext(_ctx, getState()); + enterRule(_localctx, 60, RULE_constantDeclarator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(507); + match(IDENTIFIER); + setState(512); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==LBRACK) { + { + { + setState(508); + match(LBRACK); + setState(509); + match(RBRACK); + } + } + setState(514); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(515); + match(ASSIGN); + setState(516); + variableInitializer(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InterfaceMethodDeclarationContext extends ParserRuleContext { + public TerminalNode IDENTIFIER() { return getToken(JavaParser.IDENTIFIER, 0); } + public FormalParametersContext formalParameters() { + return getRuleContext(FormalParametersContext.class,0); + } + public MethodBodyContext methodBody() { + return getRuleContext(MethodBodyContext.class,0); + } + public TypeTypeOrVoidContext typeTypeOrVoid() { + return getRuleContext(TypeTypeOrVoidContext.class,0); + } + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class,0); + } + public List interfaceMethodModifier() { + return getRuleContexts(InterfaceMethodModifierContext.class); + } + public InterfaceMethodModifierContext interfaceMethodModifier(int i) { + return getRuleContext(InterfaceMethodModifierContext.class,i); + } + public List LBRACK() { return getTokens(JavaParser.LBRACK); } + public TerminalNode LBRACK(int i) { + return getToken(JavaParser.LBRACK, i); + } + public List RBRACK() { return getTokens(JavaParser.RBRACK); } + public TerminalNode RBRACK(int i) { + return getToken(JavaParser.RBRACK, i); + } + public TerminalNode THROWS() { return getToken(JavaParser.THROWS, 0); } + public QualifiedNameListContext qualifiedNameList() { + return getRuleContext(QualifiedNameListContext.class,0); + } + public List annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public InterfaceMethodDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interfaceMethodDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterInterfaceMethodDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitInterfaceMethodDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitInterfaceMethodDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final InterfaceMethodDeclarationContext interfaceMethodDeclaration() throws RecognitionException { + InterfaceMethodDeclarationContext _localctx = new InterfaceMethodDeclarationContext(_ctx, getState()); + enterRule(_localctx, 62, RULE_interfaceMethodDeclaration); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(521); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,47,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(518); + interfaceMethodModifier(); + } + } + } + setState(523); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,47,_ctx); + } + setState(534); + _errHandler.sync(this); + switch (_input.LA(1)) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case SHORT: + case VOID: + case AT: + case IDENTIFIER: + { + setState(524); + typeTypeOrVoid(); + } + break; + case LT: + { + setState(525); + typeParameters(); + setState(529); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,48,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(526); + annotation(); + } + } + } + setState(531); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,48,_ctx); + } + setState(532); + typeTypeOrVoid(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(536); + match(IDENTIFIER); + setState(537); + formalParameters(); + setState(542); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==LBRACK) { + { + { + setState(538); + match(LBRACK); + setState(539); + match(RBRACK); + } + } + setState(544); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(547); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==THROWS) { + { + setState(545); + match(THROWS); + setState(546); + qualifiedNameList(); + } + } + + setState(549); + methodBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class InterfaceMethodModifierContext extends ParserRuleContext { + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class,0); + } + public TerminalNode PUBLIC() { return getToken(JavaParser.PUBLIC, 0); } + public TerminalNode ABSTRACT() { return getToken(JavaParser.ABSTRACT, 0); } + public TerminalNode DEFAULT() { return getToken(JavaParser.DEFAULT, 0); } + public TerminalNode STATIC() { return getToken(JavaParser.STATIC, 0); } + public TerminalNode STRICTFP() { return getToken(JavaParser.STRICTFP, 0); } + public InterfaceMethodModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_interfaceMethodModifier; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterInterfaceMethodModifier(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitInterfaceMethodModifier(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitInterfaceMethodModifier(this); + else return visitor.visitChildren(this); + } + } + + public final InterfaceMethodModifierContext interfaceMethodModifier() throws RecognitionException { + InterfaceMethodModifierContext _localctx = new InterfaceMethodModifierContext(_ctx, getState()); + enterRule(_localctx, 64, RULE_interfaceMethodModifier); + try { + setState(557); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AT: + case IDENTIFIER: + enterOuterAlt(_localctx, 1); + { + setState(551); + annotation(); + } + break; + case PUBLIC: + enterOuterAlt(_localctx, 2); + { + setState(552); + match(PUBLIC); + } + break; + case ABSTRACT: + enterOuterAlt(_localctx, 3); + { + setState(553); + match(ABSTRACT); + } + break; + case DEFAULT: + enterOuterAlt(_localctx, 4); + { + setState(554); + match(DEFAULT); + } + break; + case STATIC: + enterOuterAlt(_localctx, 5); + { + setState(555); + match(STATIC); + } + break; + case STRICTFP: + enterOuterAlt(_localctx, 6); + { + setState(556); + match(STRICTFP); + } + 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 GenericInterfaceMethodDeclarationContext extends ParserRuleContext { + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class,0); + } + public InterfaceMethodDeclarationContext interfaceMethodDeclaration() { + return getRuleContext(InterfaceMethodDeclarationContext.class,0); + } + public GenericInterfaceMethodDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_genericInterfaceMethodDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterGenericInterfaceMethodDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitGenericInterfaceMethodDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitGenericInterfaceMethodDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final GenericInterfaceMethodDeclarationContext genericInterfaceMethodDeclaration() throws RecognitionException { + GenericInterfaceMethodDeclarationContext _localctx = new GenericInterfaceMethodDeclarationContext(_ctx, getState()); + enterRule(_localctx, 66, RULE_genericInterfaceMethodDeclaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(559); + typeParameters(); + setState(560); + interfaceMethodDeclaration(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class VariableDeclaratorsContext extends ParserRuleContext { + public List variableDeclarator() { + return getRuleContexts(VariableDeclaratorContext.class); + } + public VariableDeclaratorContext variableDeclarator(int i) { + return getRuleContext(VariableDeclaratorContext.class,i); + } + public List COMMA() { return getTokens(JavaParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(JavaParser.COMMA, i); + } + public VariableDeclaratorsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variableDeclarators; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterVariableDeclarators(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitVariableDeclarators(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitVariableDeclarators(this); + else return visitor.visitChildren(this); + } + } + + public final VariableDeclaratorsContext variableDeclarators() throws RecognitionException { + VariableDeclaratorsContext _localctx = new VariableDeclaratorsContext(_ctx, getState()); + enterRule(_localctx, 68, RULE_variableDeclarators); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(562); + variableDeclarator(); + setState(567); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(563); + match(COMMA); + setState(564); + variableDeclarator(); + } + } + setState(569); + _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 VariableDeclaratorContext extends ParserRuleContext { + public VariableDeclaratorIdContext variableDeclaratorId() { + return getRuleContext(VariableDeclaratorIdContext.class,0); + } + public TerminalNode ASSIGN() { return getToken(JavaParser.ASSIGN, 0); } + public VariableInitializerContext variableInitializer() { + return getRuleContext(VariableInitializerContext.class,0); + } + public VariableDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variableDeclarator; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterVariableDeclarator(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitVariableDeclarator(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitVariableDeclarator(this); + else return visitor.visitChildren(this); + } + } + + public final VariableDeclaratorContext variableDeclarator() throws RecognitionException { + VariableDeclaratorContext _localctx = new VariableDeclaratorContext(_ctx, getState()); + enterRule(_localctx, 70, RULE_variableDeclarator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(570); + variableDeclaratorId(); + setState(573); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==ASSIGN) { + { + setState(571); + match(ASSIGN); + setState(572); + variableInitializer(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class VariableDeclaratorIdContext extends ParserRuleContext { + public TerminalNode IDENTIFIER() { return getToken(JavaParser.IDENTIFIER, 0); } + public List LBRACK() { return getTokens(JavaParser.LBRACK); } + public TerminalNode LBRACK(int i) { + return getToken(JavaParser.LBRACK, i); + } + public List RBRACK() { return getTokens(JavaParser.RBRACK); } + public TerminalNode RBRACK(int i) { + return getToken(JavaParser.RBRACK, i); + } + public VariableDeclaratorIdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variableDeclaratorId; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterVariableDeclaratorId(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitVariableDeclaratorId(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitVariableDeclaratorId(this); + else return visitor.visitChildren(this); + } + } + + public final VariableDeclaratorIdContext variableDeclaratorId() throws RecognitionException { + VariableDeclaratorIdContext _localctx = new VariableDeclaratorIdContext(_ctx, getState()); + enterRule(_localctx, 72, RULE_variableDeclaratorId); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(575); + match(IDENTIFIER); + setState(580); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==LBRACK) { + { + { + setState(576); + match(LBRACK); + setState(577); + match(RBRACK); + } + } + setState(582); + _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 VariableInitializerContext extends ParserRuleContext { + public ArrayInitializerContext arrayInitializer() { + return getRuleContext(ArrayInitializerContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public VariableInitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_variableInitializer; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterVariableInitializer(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitVariableInitializer(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitVariableInitializer(this); + else return visitor.visitChildren(this); + } + } + + public final VariableInitializerContext variableInitializer() throws RecognitionException { + VariableInitializerContext _localctx = new VariableInitializerContext(_ctx, getState()); + enterRule(_localctx, 74, RULE_variableInitializer); + try { + setState(585); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LBRACE: + enterOuterAlt(_localctx, 1); + { + setState(583); + arrayInitializer(); + } + break; + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case NEW: + case SHORT: + case SUPER: + case THIS: + case VOID: + case DECIMAL_LITERAL: + case HEX_LITERAL: + case OCT_LITERAL: + case BINARY_LITERAL: + case FLOAT_LITERAL: + case HEX_FLOAT_LITERAL: + case BOOL_LITERAL: + case CHAR_LITERAL: + case STRING_LITERAL: + case NULL_LITERAL: + case LPAREN: + case LT: + case BANG: + case TILDE: + case INC: + case DEC: + case ADD: + case SUB: + case AT: + case IDENTIFIER: + enterOuterAlt(_localctx, 2); + { + setState(584); + expression(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 ArrayInitializerContext extends ParserRuleContext { + public TerminalNode LBRACE() { return getToken(JavaParser.LBRACE, 0); } + public TerminalNode RBRACE() { return getToken(JavaParser.RBRACE, 0); } + public List variableInitializer() { + return getRuleContexts(VariableInitializerContext.class); + } + public VariableInitializerContext variableInitializer(int i) { + return getRuleContext(VariableInitializerContext.class,i); + } + public List COMMA() { return getTokens(JavaParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(JavaParser.COMMA, i); + } + public ArrayInitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arrayInitializer; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterArrayInitializer(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitArrayInitializer(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitArrayInitializer(this); + else return visitor.visitChildren(this); + } + } + + public final ArrayInitializerContext arrayInitializer() throws RecognitionException { + ArrayInitializerContext _localctx = new ArrayInitializerContext(_ctx, getState()); + enterRule(_localctx, 76, RULE_arrayInitializer); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(587); + match(LBRACE); + setState(599); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << DECIMAL_LITERAL) | (1L << HEX_LITERAL) | (1L << OCT_LITERAL) | (1L << BINARY_LITERAL) | (1L << FLOAT_LITERAL) | (1L << HEX_FLOAT_LITERAL) | (1L << BOOL_LITERAL) | (1L << CHAR_LITERAL) | (1L << STRING_LITERAL) | (1L << NULL_LITERAL) | (1L << LPAREN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (LBRACE - 64)) | (1L << (LT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (AT - 64)) | (1L << (IDENTIFIER - 64)))) != 0)) { + { + setState(588); + variableInitializer(); + setState(593); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,57,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(589); + match(COMMA); + setState(590); + variableInitializer(); + } + } + } + setState(595); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,57,_ctx); + } + setState(597); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(596); + match(COMMA); + } + } + + } + } + + setState(601); + match(RBRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ClassOrInterfaceTypeContext extends ParserRuleContext { + public List IDENTIFIER() { return getTokens(JavaParser.IDENTIFIER); } + public TerminalNode IDENTIFIER(int i) { + return getToken(JavaParser.IDENTIFIER, i); + } + public List typeArguments() { + return getRuleContexts(TypeArgumentsContext.class); + } + public TypeArgumentsContext typeArguments(int i) { + return getRuleContext(TypeArgumentsContext.class,i); + } + public List DOT() { return getTokens(JavaParser.DOT); } + public TerminalNode DOT(int i) { + return getToken(JavaParser.DOT, i); + } + public ClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classOrInterfaceType; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterClassOrInterfaceType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitClassOrInterfaceType(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitClassOrInterfaceType(this); + else return visitor.visitChildren(this); + } + } + + public final ClassOrInterfaceTypeContext classOrInterfaceType() throws RecognitionException { + ClassOrInterfaceTypeContext _localctx = new ClassOrInterfaceTypeContext(_ctx, getState()); + enterRule(_localctx, 78, RULE_classOrInterfaceType); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(603); + match(IDENTIFIER); + setState(605); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) { + case 1: + { + setState(604); + typeArguments(); + } + break; + } + setState(614); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,62,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(607); + match(DOT); + setState(608); + match(IDENTIFIER); + setState(610); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,61,_ctx) ) { + case 1: + { + setState(609); + typeArguments(); + } + break; + } + } + } + } + setState(616); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,62,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeArgumentContext extends ParserRuleContext { + public TypeTypeContext typeType() { + return getRuleContext(TypeTypeContext.class,0); + } + public TerminalNode QUESTION() { return getToken(JavaParser.QUESTION, 0); } + public List annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public TerminalNode EXTENDS() { return getToken(JavaParser.EXTENDS, 0); } + public TerminalNode SUPER() { return getToken(JavaParser.SUPER, 0); } + public TypeArgumentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeArgument; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterTypeArgument(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitTypeArgument(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitTypeArgument(this); + else return visitor.visitChildren(this); + } + } + + public final TypeArgumentContext typeArgument() throws RecognitionException { + TypeArgumentContext _localctx = new TypeArgumentContext(_ctx, getState()); + enterRule(_localctx, 80, RULE_typeArgument); + int _la; + try { + setState(629); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,65,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(617); + typeType(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(621); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT || _la==IDENTIFIER) { + { + { + setState(618); + annotation(); + } + } + setState(623); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(624); + match(QUESTION); + setState(627); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==EXTENDS || _la==SUPER) { + { + setState(625); + _la = _input.LA(1); + if ( !(_la==EXTENDS || _la==SUPER) ) { + _errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(626); + typeType(); + } + } + + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class QualifiedNameListContext extends ParserRuleContext { + public List qualifiedName() { + return getRuleContexts(QualifiedNameContext.class); + } + public QualifiedNameContext qualifiedName(int i) { + return getRuleContext(QualifiedNameContext.class,i); + } + public List COMMA() { return getTokens(JavaParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(JavaParser.COMMA, i); + } + public QualifiedNameListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_qualifiedNameList; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterQualifiedNameList(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitQualifiedNameList(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitQualifiedNameList(this); + else return visitor.visitChildren(this); + } + } + + public final QualifiedNameListContext qualifiedNameList() throws RecognitionException { + QualifiedNameListContext _localctx = new QualifiedNameListContext(_ctx, getState()); + enterRule(_localctx, 82, RULE_qualifiedNameList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(631); + qualifiedName(); + setState(636); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(632); + match(COMMA); + setState(633); + qualifiedName(); + } + } + setState(638); + _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 FormalParametersContext extends ParserRuleContext { + public TerminalNode LPAREN() { return getToken(JavaParser.LPAREN, 0); } + public TerminalNode RPAREN() { return getToken(JavaParser.RPAREN, 0); } + public FormalParameterListContext formalParameterList() { + return getRuleContext(FormalParameterListContext.class,0); + } + public FormalParametersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_formalParameters; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterFormalParameters(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitFormalParameters(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitFormalParameters(this); + else return visitor.visitChildren(this); + } + } + + public final FormalParametersContext formalParameters() throws RecognitionException { + FormalParametersContext _localctx = new FormalParametersContext(_ctx, getState()); + enterRule(_localctx, 84, RULE_formalParameters); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(639); + match(LPAREN); + setState(641); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << SHORT))) != 0) || _la==AT || _la==IDENTIFIER) { + { + setState(640); + formalParameterList(); + } + } + + setState(643); + match(RPAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FormalParameterListContext extends ParserRuleContext { + public List formalParameter() { + return getRuleContexts(FormalParameterContext.class); + } + public FormalParameterContext formalParameter(int i) { + return getRuleContext(FormalParameterContext.class,i); + } + public List COMMA() { return getTokens(JavaParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(JavaParser.COMMA, i); + } + public LastFormalParameterContext lastFormalParameter() { + return getRuleContext(LastFormalParameterContext.class,0); + } + public FormalParameterListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_formalParameterList; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterFormalParameterList(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitFormalParameterList(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitFormalParameterList(this); + else return visitor.visitChildren(this); + } + } + + public final FormalParameterListContext formalParameterList() throws RecognitionException { + FormalParameterListContext _localctx = new FormalParameterListContext(_ctx, getState()); + enterRule(_localctx, 86, RULE_formalParameterList); + int _la; + try { + int _alt; + setState(658); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(645); + formalParameter(); + setState(650); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,68,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(646); + match(COMMA); + setState(647); + formalParameter(); + } + } + } + setState(652); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,68,_ctx); + } + setState(655); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(653); + match(COMMA); + setState(654); + lastFormalParameter(); + } + } + + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(657); + lastFormalParameter(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class FormalParameterContext extends ParserRuleContext { + public TypeTypeContext typeType() { + return getRuleContext(TypeTypeContext.class,0); + } + public VariableDeclaratorIdContext variableDeclaratorId() { + return getRuleContext(VariableDeclaratorIdContext.class,0); + } + public List variableModifier() { + return getRuleContexts(VariableModifierContext.class); + } + public VariableModifierContext variableModifier(int i) { + return getRuleContext(VariableModifierContext.class,i); + } + public FormalParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_formalParameter; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterFormalParameter(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitFormalParameter(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitFormalParameter(this); + else return visitor.visitChildren(this); + } + } + + public final FormalParameterContext formalParameter() throws RecognitionException { + FormalParameterContext _localctx = new FormalParameterContext(_ctx, getState()); + enterRule(_localctx, 88, RULE_formalParameter); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(663); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,71,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(660); + variableModifier(); + } + } + } + setState(665); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,71,_ctx); + } + setState(666); + typeType(); + setState(667); + variableDeclaratorId(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LastFormalParameterContext extends ParserRuleContext { + public TypeTypeContext typeType() { + return getRuleContext(TypeTypeContext.class,0); + } + public TerminalNode ELLIPSIS() { return getToken(JavaParser.ELLIPSIS, 0); } + public VariableDeclaratorIdContext variableDeclaratorId() { + return getRuleContext(VariableDeclaratorIdContext.class,0); + } + public List variableModifier() { + return getRuleContexts(VariableModifierContext.class); + } + public VariableModifierContext variableModifier(int i) { + return getRuleContext(VariableModifierContext.class,i); + } + public List annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public LastFormalParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_lastFormalParameter; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterLastFormalParameter(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitLastFormalParameter(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitLastFormalParameter(this); + else return visitor.visitChildren(this); + } + } + + public final LastFormalParameterContext lastFormalParameter() throws RecognitionException { + LastFormalParameterContext _localctx = new LastFormalParameterContext(_ctx, getState()); + enterRule(_localctx, 90, RULE_lastFormalParameter); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(672); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,72,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(669); + variableModifier(); + } + } + } + setState(674); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,72,_ctx); + } + setState(675); + typeType(); + setState(679); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT || _la==IDENTIFIER) { + { + { + setState(676); + annotation(); + } + } + setState(681); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(682); + match(ELLIPSIS); + setState(683); + variableDeclaratorId(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class QualifiedNameContext extends ParserRuleContext { + public List IDENTIFIER() { return getTokens(JavaParser.IDENTIFIER); } + public TerminalNode IDENTIFIER(int i) { + return getToken(JavaParser.IDENTIFIER, i); + } + public List DOT() { return getTokens(JavaParser.DOT); } + public TerminalNode DOT(int i) { + return getToken(JavaParser.DOT, i); + } + public QualifiedNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_qualifiedName; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterQualifiedName(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitQualifiedName(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitQualifiedName(this); + else return visitor.visitChildren(this); + } + } + + public final QualifiedNameContext qualifiedName() throws RecognitionException { + QualifiedNameContext _localctx = new QualifiedNameContext(_ctx, getState()); + enterRule(_localctx, 92, RULE_qualifiedName); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(685); + match(IDENTIFIER); + setState(690); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,74,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(686); + match(DOT); + setState(687); + match(IDENTIFIER); + } + } + } + setState(692); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,74,_ctx); + } + } + } + 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 IntegerLiteralContext integerLiteral() { + return getRuleContext(IntegerLiteralContext.class,0); + } + public FloatLiteralContext floatLiteral() { + return getRuleContext(FloatLiteralContext.class,0); + } + public TerminalNode CHAR_LITERAL() { return getToken(JavaParser.CHAR_LITERAL, 0); } + public TerminalNode STRING_LITERAL() { return getToken(JavaParser.STRING_LITERAL, 0); } + public TerminalNode BOOL_LITERAL() { return getToken(JavaParser.BOOL_LITERAL, 0); } + public TerminalNode NULL_LITERAL() { return getToken(JavaParser.NULL_LITERAL, 0); } + public LiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_literal; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterLiteral(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitLiteral(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitLiteral(this); + else return visitor.visitChildren(this); + } + } + + public final LiteralContext literal() throws RecognitionException { + LiteralContext _localctx = new LiteralContext(_ctx, getState()); + enterRule(_localctx, 94, RULE_literal); + try { + setState(699); + _errHandler.sync(this); + switch (_input.LA(1)) { + case DECIMAL_LITERAL: + case HEX_LITERAL: + case OCT_LITERAL: + case BINARY_LITERAL: + enterOuterAlt(_localctx, 1); + { + setState(693); + integerLiteral(); + } + break; + case FLOAT_LITERAL: + case HEX_FLOAT_LITERAL: + enterOuterAlt(_localctx, 2); + { + setState(694); + floatLiteral(); + } + break; + case CHAR_LITERAL: + enterOuterAlt(_localctx, 3); + { + setState(695); + match(CHAR_LITERAL); + } + break; + case STRING_LITERAL: + enterOuterAlt(_localctx, 4); + { + setState(696); + match(STRING_LITERAL); + } + break; + case BOOL_LITERAL: + enterOuterAlt(_localctx, 5); + { + setState(697); + match(BOOL_LITERAL); + } + break; + case NULL_LITERAL: + enterOuterAlt(_localctx, 6); + { + setState(698); + match(NULL_LITERAL); + } + 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 IntegerLiteralContext extends ParserRuleContext { + public TerminalNode DECIMAL_LITERAL() { return getToken(JavaParser.DECIMAL_LITERAL, 0); } + public TerminalNode HEX_LITERAL() { return getToken(JavaParser.HEX_LITERAL, 0); } + public TerminalNode OCT_LITERAL() { return getToken(JavaParser.OCT_LITERAL, 0); } + public TerminalNode BINARY_LITERAL() { return getToken(JavaParser.BINARY_LITERAL, 0); } + public IntegerLiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_integerLiteral; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterIntegerLiteral(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitIntegerLiteral(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitIntegerLiteral(this); + else return visitor.visitChildren(this); + } + } + + public final IntegerLiteralContext integerLiteral() throws RecognitionException { + IntegerLiteralContext _localctx = new IntegerLiteralContext(_ctx, getState()); + enterRule(_localctx, 96, RULE_integerLiteral); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(701); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << DECIMAL_LITERAL) | (1L << HEX_LITERAL) | (1L << OCT_LITERAL) | (1L << BINARY_LITERAL))) != 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 FloatLiteralContext extends ParserRuleContext { + public TerminalNode FLOAT_LITERAL() { return getToken(JavaParser.FLOAT_LITERAL, 0); } + public TerminalNode HEX_FLOAT_LITERAL() { return getToken(JavaParser.HEX_FLOAT_LITERAL, 0); } + public FloatLiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_floatLiteral; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterFloatLiteral(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitFloatLiteral(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitFloatLiteral(this); + else return visitor.visitChildren(this); + } + } + + public final FloatLiteralContext floatLiteral() throws RecognitionException { + FloatLiteralContext _localctx = new FloatLiteralContext(_ctx, getState()); + enterRule(_localctx, 98, RULE_floatLiteral); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(703); + _la = _input.LA(1); + if ( !(_la==FLOAT_LITERAL || _la==HEX_FLOAT_LITERAL) ) { + _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 AltAnnotationQualifiedNameContext extends ParserRuleContext { + public TerminalNode AT() { return getToken(JavaParser.AT, 0); } + public List IDENTIFIER() { return getTokens(JavaParser.IDENTIFIER); } + public TerminalNode IDENTIFIER(int i) { + return getToken(JavaParser.IDENTIFIER, i); + } + public List DOT() { return getTokens(JavaParser.DOT); } + public TerminalNode DOT(int i) { + return getToken(JavaParser.DOT, i); + } + public AltAnnotationQualifiedNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_altAnnotationQualifiedName; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterAltAnnotationQualifiedName(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitAltAnnotationQualifiedName(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitAltAnnotationQualifiedName(this); + else return visitor.visitChildren(this); + } + } + + public final AltAnnotationQualifiedNameContext altAnnotationQualifiedName() throws RecognitionException { + AltAnnotationQualifiedNameContext _localctx = new AltAnnotationQualifiedNameContext(_ctx, getState()); + enterRule(_localctx, 100, RULE_altAnnotationQualifiedName); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(709); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==IDENTIFIER) { + { + { + setState(705); + match(IDENTIFIER); + setState(706); + match(DOT); + } + } + setState(711); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(712); + match(AT); + setState(713); + match(IDENTIFIER); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AnnotationContext extends ParserRuleContext { + public TerminalNode AT() { return getToken(JavaParser.AT, 0); } + public QualifiedNameContext qualifiedName() { + return getRuleContext(QualifiedNameContext.class,0); + } + public AltAnnotationQualifiedNameContext altAnnotationQualifiedName() { + return getRuleContext(AltAnnotationQualifiedNameContext.class,0); + } + public TerminalNode LPAREN() { return getToken(JavaParser.LPAREN, 0); } + public TerminalNode RPAREN() { return getToken(JavaParser.RPAREN, 0); } + public ElementValuePairsContext elementValuePairs() { + return getRuleContext(ElementValuePairsContext.class,0); + } + public ElementValueContext elementValue() { + return getRuleContext(ElementValueContext.class,0); + } + public AnnotationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_annotation; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterAnnotation(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitAnnotation(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitAnnotation(this); + else return visitor.visitChildren(this); + } + } + + public final AnnotationContext annotation() throws RecognitionException { + AnnotationContext _localctx = new AnnotationContext(_ctx, getState()); + enterRule(_localctx, 102, RULE_annotation); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(718); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,77,_ctx) ) { + case 1: + { + setState(715); + match(AT); + setState(716); + qualifiedName(); + } + break; + case 2: + { + setState(717); + altAnnotationQualifiedName(); + } + break; + } + setState(726); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LPAREN) { + { + setState(720); + match(LPAREN); + setState(723); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,78,_ctx) ) { + case 1: + { + setState(721); + elementValuePairs(); + } + break; + case 2: + { + setState(722); + elementValue(); + } + break; + } + setState(725); + match(RPAREN); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ElementValuePairsContext extends ParserRuleContext { + public List elementValuePair() { + return getRuleContexts(ElementValuePairContext.class); + } + public ElementValuePairContext elementValuePair(int i) { + return getRuleContext(ElementValuePairContext.class,i); + } + public List COMMA() { return getTokens(JavaParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(JavaParser.COMMA, i); + } + public ElementValuePairsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_elementValuePairs; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterElementValuePairs(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitElementValuePairs(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitElementValuePairs(this); + else return visitor.visitChildren(this); + } + } + + public final ElementValuePairsContext elementValuePairs() throws RecognitionException { + ElementValuePairsContext _localctx = new ElementValuePairsContext(_ctx, getState()); + enterRule(_localctx, 104, RULE_elementValuePairs); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(728); + elementValuePair(); + setState(733); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(729); + match(COMMA); + setState(730); + elementValuePair(); + } + } + setState(735); + _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 ElementValuePairContext extends ParserRuleContext { + public TerminalNode IDENTIFIER() { return getToken(JavaParser.IDENTIFIER, 0); } + public TerminalNode ASSIGN() { return getToken(JavaParser.ASSIGN, 0); } + public ElementValueContext elementValue() { + return getRuleContext(ElementValueContext.class,0); + } + public ElementValuePairContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_elementValuePair; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterElementValuePair(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitElementValuePair(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitElementValuePair(this); + else return visitor.visitChildren(this); + } + } + + public final ElementValuePairContext elementValuePair() throws RecognitionException { + ElementValuePairContext _localctx = new ElementValuePairContext(_ctx, getState()); + enterRule(_localctx, 106, RULE_elementValuePair); + try { + enterOuterAlt(_localctx, 1); + { + setState(736); + match(IDENTIFIER); + setState(737); + match(ASSIGN); + setState(738); + elementValue(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ElementValueContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class,0); + } + public ElementValueArrayInitializerContext elementValueArrayInitializer() { + return getRuleContext(ElementValueArrayInitializerContext.class,0); + } + public ElementValueContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_elementValue; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterElementValue(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitElementValue(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitElementValue(this); + else return visitor.visitChildren(this); + } + } + + public final ElementValueContext elementValue() throws RecognitionException { + ElementValueContext _localctx = new ElementValueContext(_ctx, getState()); + enterRule(_localctx, 108, RULE_elementValue); + try { + setState(743); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,81,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(740); + expression(0); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(741); + annotation(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(742); + elementValueArrayInitializer(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ElementValueArrayInitializerContext extends ParserRuleContext { + public TerminalNode LBRACE() { return getToken(JavaParser.LBRACE, 0); } + public TerminalNode RBRACE() { return getToken(JavaParser.RBRACE, 0); } + public List elementValue() { + return getRuleContexts(ElementValueContext.class); + } + public ElementValueContext elementValue(int i) { + return getRuleContext(ElementValueContext.class,i); + } + public List COMMA() { return getTokens(JavaParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(JavaParser.COMMA, i); + } + public ElementValueArrayInitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_elementValueArrayInitializer; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterElementValueArrayInitializer(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitElementValueArrayInitializer(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitElementValueArrayInitializer(this); + else return visitor.visitChildren(this); + } + } + + public final ElementValueArrayInitializerContext elementValueArrayInitializer() throws RecognitionException { + ElementValueArrayInitializerContext _localctx = new ElementValueArrayInitializerContext(_ctx, getState()); + enterRule(_localctx, 110, RULE_elementValueArrayInitializer); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(745); + match(LBRACE); + setState(754); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << DECIMAL_LITERAL) | (1L << HEX_LITERAL) | (1L << OCT_LITERAL) | (1L << BINARY_LITERAL) | (1L << FLOAT_LITERAL) | (1L << HEX_FLOAT_LITERAL) | (1L << BOOL_LITERAL) | (1L << CHAR_LITERAL) | (1L << STRING_LITERAL) | (1L << NULL_LITERAL) | (1L << LPAREN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (LBRACE - 64)) | (1L << (LT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (AT - 64)) | (1L << (IDENTIFIER - 64)))) != 0)) { + { + setState(746); + elementValue(); + setState(751); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,82,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(747); + match(COMMA); + setState(748); + elementValue(); + } + } + } + setState(753); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,82,_ctx); + } + } + } + + setState(757); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COMMA) { + { + setState(756); + match(COMMA); + } + } + + setState(759); + match(RBRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AnnotationTypeDeclarationContext extends ParserRuleContext { + public TerminalNode AT() { return getToken(JavaParser.AT, 0); } + public TerminalNode INTERFACE() { return getToken(JavaParser.INTERFACE, 0); } + public TerminalNode IDENTIFIER() { return getToken(JavaParser.IDENTIFIER, 0); } + public AnnotationTypeBodyContext annotationTypeBody() { + return getRuleContext(AnnotationTypeBodyContext.class,0); + } + public AnnotationTypeDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_annotationTypeDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterAnnotationTypeDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitAnnotationTypeDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitAnnotationTypeDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final AnnotationTypeDeclarationContext annotationTypeDeclaration() throws RecognitionException { + AnnotationTypeDeclarationContext _localctx = new AnnotationTypeDeclarationContext(_ctx, getState()); + enterRule(_localctx, 112, RULE_annotationTypeDeclaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(761); + match(AT); + setState(762); + match(INTERFACE); + setState(763); + match(IDENTIFIER); + setState(764); + annotationTypeBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AnnotationTypeBodyContext extends ParserRuleContext { + public TerminalNode LBRACE() { return getToken(JavaParser.LBRACE, 0); } + public TerminalNode RBRACE() { return getToken(JavaParser.RBRACE, 0); } + public List annotationTypeElementDeclaration() { + return getRuleContexts(AnnotationTypeElementDeclarationContext.class); + } + public AnnotationTypeElementDeclarationContext annotationTypeElementDeclaration(int i) { + return getRuleContext(AnnotationTypeElementDeclarationContext.class,i); + } + public AnnotationTypeBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_annotationTypeBody; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterAnnotationTypeBody(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitAnnotationTypeBody(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitAnnotationTypeBody(this); + else return visitor.visitChildren(this); + } + } + + public final AnnotationTypeBodyContext annotationTypeBody() throws RecognitionException { + AnnotationTypeBodyContext _localctx = new AnnotationTypeBodyContext(_ctx, getState()); + enterRule(_localctx, 114, RULE_annotationTypeBody); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(766); + match(LBRACE); + setState(770); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << DOUBLE) | (1L << ENUM) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << NATIVE) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SYNCHRONIZED) | (1L << TRANSIENT) | (1L << VOLATILE))) != 0) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << (SEMI - 68)) | (1L << (AT - 68)) | (1L << (IDENTIFIER - 68)))) != 0)) { + { + { + setState(767); + annotationTypeElementDeclaration(); + } + } + setState(772); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(773); + match(RBRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AnnotationTypeElementDeclarationContext extends ParserRuleContext { + public AnnotationTypeElementRestContext annotationTypeElementRest() { + return getRuleContext(AnnotationTypeElementRestContext.class,0); + } + public List modifier() { + return getRuleContexts(ModifierContext.class); + } + public ModifierContext modifier(int i) { + return getRuleContext(ModifierContext.class,i); + } + public TerminalNode SEMI() { return getToken(JavaParser.SEMI, 0); } + public AnnotationTypeElementDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_annotationTypeElementDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterAnnotationTypeElementDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitAnnotationTypeElementDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitAnnotationTypeElementDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final AnnotationTypeElementDeclarationContext annotationTypeElementDeclaration() throws RecognitionException { + AnnotationTypeElementDeclarationContext _localctx = new AnnotationTypeElementDeclarationContext(_ctx, getState()); + enterRule(_localctx, 116, RULE_annotationTypeElementDeclaration); + try { + int _alt; + setState(783); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ABSTRACT: + case BOOLEAN: + case BYTE: + case CHAR: + case CLASS: + case DOUBLE: + case ENUM: + case FINAL: + case FLOAT: + case INT: + case INTERFACE: + case LONG: + case NATIVE: + case PRIVATE: + case PROTECTED: + case PUBLIC: + case SHORT: + case STATIC: + case STRICTFP: + case SYNCHRONIZED: + case TRANSIENT: + case VOLATILE: + case AT: + case IDENTIFIER: + enterOuterAlt(_localctx, 1); + { + setState(778); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,86,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(775); + modifier(); + } + } + } + setState(780); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,86,_ctx); + } + setState(781); + annotationTypeElementRest(); + } + break; + case SEMI: + enterOuterAlt(_localctx, 2); + { + setState(782); + 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 AnnotationTypeElementRestContext extends ParserRuleContext { + public TypeTypeContext typeType() { + return getRuleContext(TypeTypeContext.class,0); + } + public AnnotationMethodOrConstantRestContext annotationMethodOrConstantRest() { + return getRuleContext(AnnotationMethodOrConstantRestContext.class,0); + } + public TerminalNode SEMI() { return getToken(JavaParser.SEMI, 0); } + public ClassDeclarationContext classDeclaration() { + return getRuleContext(ClassDeclarationContext.class,0); + } + public InterfaceDeclarationContext interfaceDeclaration() { + return getRuleContext(InterfaceDeclarationContext.class,0); + } + public EnumDeclarationContext enumDeclaration() { + return getRuleContext(EnumDeclarationContext.class,0); + } + public AnnotationTypeDeclarationContext annotationTypeDeclaration() { + return getRuleContext(AnnotationTypeDeclarationContext.class,0); + } + public AnnotationTypeElementRestContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_annotationTypeElementRest; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterAnnotationTypeElementRest(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitAnnotationTypeElementRest(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitAnnotationTypeElementRest(this); + else return visitor.visitChildren(this); + } + } + + public final AnnotationTypeElementRestContext annotationTypeElementRest() throws RecognitionException { + AnnotationTypeElementRestContext _localctx = new AnnotationTypeElementRestContext(_ctx, getState()); + enterRule(_localctx, 118, RULE_annotationTypeElementRest); + try { + setState(805); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,92,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(785); + typeType(); + setState(786); + annotationMethodOrConstantRest(); + setState(787); + match(SEMI); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(789); + classDeclaration(); + setState(791); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,88,_ctx) ) { + case 1: + { + setState(790); + match(SEMI); + } + break; + } + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(793); + interfaceDeclaration(); + setState(795); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,89,_ctx) ) { + case 1: + { + setState(794); + match(SEMI); + } + break; + } + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(797); + enumDeclaration(); + setState(799); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,90,_ctx) ) { + case 1: + { + setState(798); + match(SEMI); + } + break; + } + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(801); + annotationTypeDeclaration(); + setState(803); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,91,_ctx) ) { + case 1: + { + setState(802); + match(SEMI); + } + break; + } + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AnnotationMethodOrConstantRestContext extends ParserRuleContext { + public AnnotationMethodRestContext annotationMethodRest() { + return getRuleContext(AnnotationMethodRestContext.class,0); + } + public AnnotationConstantRestContext annotationConstantRest() { + return getRuleContext(AnnotationConstantRestContext.class,0); + } + public AnnotationMethodOrConstantRestContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_annotationMethodOrConstantRest; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterAnnotationMethodOrConstantRest(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitAnnotationMethodOrConstantRest(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitAnnotationMethodOrConstantRest(this); + else return visitor.visitChildren(this); + } + } + + public final AnnotationMethodOrConstantRestContext annotationMethodOrConstantRest() throws RecognitionException { + AnnotationMethodOrConstantRestContext _localctx = new AnnotationMethodOrConstantRestContext(_ctx, getState()); + enterRule(_localctx, 120, RULE_annotationMethodOrConstantRest); + try { + setState(809); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,93,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(807); + annotationMethodRest(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(808); + annotationConstantRest(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AnnotationMethodRestContext extends ParserRuleContext { + public TerminalNode IDENTIFIER() { return getToken(JavaParser.IDENTIFIER, 0); } + public TerminalNode LPAREN() { return getToken(JavaParser.LPAREN, 0); } + public TerminalNode RPAREN() { return getToken(JavaParser.RPAREN, 0); } + public DefaultValueContext defaultValue() { + return getRuleContext(DefaultValueContext.class,0); + } + public AnnotationMethodRestContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_annotationMethodRest; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterAnnotationMethodRest(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitAnnotationMethodRest(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitAnnotationMethodRest(this); + else return visitor.visitChildren(this); + } + } + + public final AnnotationMethodRestContext annotationMethodRest() throws RecognitionException { + AnnotationMethodRestContext _localctx = new AnnotationMethodRestContext(_ctx, getState()); + enterRule(_localctx, 122, RULE_annotationMethodRest); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(811); + match(IDENTIFIER); + setState(812); + match(LPAREN); + setState(813); + match(RPAREN); + setState(815); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==DEFAULT) { + { + setState(814); + defaultValue(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class AnnotationConstantRestContext extends ParserRuleContext { + public VariableDeclaratorsContext variableDeclarators() { + return getRuleContext(VariableDeclaratorsContext.class,0); + } + public AnnotationConstantRestContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_annotationConstantRest; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterAnnotationConstantRest(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitAnnotationConstantRest(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitAnnotationConstantRest(this); + else return visitor.visitChildren(this); + } + } + + public final AnnotationConstantRestContext annotationConstantRest() throws RecognitionException { + AnnotationConstantRestContext _localctx = new AnnotationConstantRestContext(_ctx, getState()); + enterRule(_localctx, 124, RULE_annotationConstantRest); + try { + enterOuterAlt(_localctx, 1); + { + setState(817); + variableDeclarators(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class DefaultValueContext extends ParserRuleContext { + public TerminalNode DEFAULT() { return getToken(JavaParser.DEFAULT, 0); } + public ElementValueContext elementValue() { + return getRuleContext(ElementValueContext.class,0); + } + public DefaultValueContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_defaultValue; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterDefaultValue(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitDefaultValue(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitDefaultValue(this); + else return visitor.visitChildren(this); + } + } + + public final DefaultValueContext defaultValue() throws RecognitionException { + DefaultValueContext _localctx = new DefaultValueContext(_ctx, getState()); + enterRule(_localctx, 126, RULE_defaultValue); + try { + enterOuterAlt(_localctx, 1); + { + setState(819); + match(DEFAULT); + setState(820); + elementValue(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class BlockContext extends ParserRuleContext { + public TerminalNode LBRACE() { return getToken(JavaParser.LBRACE, 0); } + public TerminalNode RBRACE() { return getToken(JavaParser.RBRACE, 0); } + public List blockStatement() { + return getRuleContexts(BlockStatementContext.class); + } + public BlockStatementContext blockStatement(int i) { + return getRuleContext(BlockStatementContext.class,i); + } + public BlockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_block; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterBlock(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitBlock(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitBlock(this); + else return visitor.visitChildren(this); + } + } + + public final BlockContext block() throws RecognitionException { + BlockContext _localctx = new BlockContext(_ctx, getState()); + enterRule(_localctx, 128, RULE_block); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(822); + match(LBRACE); + setState(826); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << ASSERT) | (1L << BOOLEAN) | (1L << BREAK) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << CONTINUE) | (1L << DO) | (1L << DOUBLE) | (1L << FINAL) | (1L << FLOAT) | (1L << FOR) | (1L << IF) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << NEW) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << RETURN) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SUPER) | (1L << SWITCH) | (1L << SYNCHRONIZED) | (1L << THIS) | (1L << THROW) | (1L << TRY) | (1L << VOID) | (1L << WHILE) | (1L << DECIMAL_LITERAL) | (1L << HEX_LITERAL) | (1L << OCT_LITERAL) | (1L << BINARY_LITERAL) | (1L << FLOAT_LITERAL) | (1L << HEX_FLOAT_LITERAL) | (1L << BOOL_LITERAL) | (1L << CHAR_LITERAL) | (1L << STRING_LITERAL) | (1L << NULL_LITERAL) | (1L << LPAREN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (LBRACE - 64)) | (1L << (SEMI - 64)) | (1L << (LT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (AT - 64)) | (1L << (IDENTIFIER - 64)))) != 0)) { + { + { + setState(823); + blockStatement(); + } + } + setState(828); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(829); + match(RBRACE); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class BlockStatementContext extends ParserRuleContext { + public LocalVariableDeclarationContext localVariableDeclaration() { + return getRuleContext(LocalVariableDeclarationContext.class,0); + } + public TerminalNode SEMI() { return getToken(JavaParser.SEMI, 0); } + public StatementContext statement() { + return getRuleContext(StatementContext.class,0); + } + public LocalTypeDeclarationContext localTypeDeclaration() { + return getRuleContext(LocalTypeDeclarationContext.class,0); + } + public BlockStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_blockStatement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterBlockStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitBlockStatement(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitBlockStatement(this); + else return visitor.visitChildren(this); + } + } + + public final BlockStatementContext blockStatement() throws RecognitionException { + BlockStatementContext _localctx = new BlockStatementContext(_ctx, getState()); + enterRule(_localctx, 130, RULE_blockStatement); + try { + setState(836); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,96,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(831); + localVariableDeclaration(); + setState(832); + match(SEMI); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(834); + statement(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(835); + localTypeDeclaration(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LocalVariableDeclarationContext extends ParserRuleContext { + public TypeTypeContext typeType() { + return getRuleContext(TypeTypeContext.class,0); + } + public VariableDeclaratorsContext variableDeclarators() { + return getRuleContext(VariableDeclaratorsContext.class,0); + } + public List variableModifier() { + return getRuleContexts(VariableModifierContext.class); + } + public VariableModifierContext variableModifier(int i) { + return getRuleContext(VariableModifierContext.class,i); + } + public LocalVariableDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_localVariableDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterLocalVariableDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitLocalVariableDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitLocalVariableDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final LocalVariableDeclarationContext localVariableDeclaration() throws RecognitionException { + LocalVariableDeclarationContext _localctx = new LocalVariableDeclarationContext(_ctx, getState()); + enterRule(_localctx, 132, RULE_localVariableDeclaration); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(841); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,97,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(838); + variableModifier(); + } + } + } + setState(843); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,97,_ctx); + } + setState(844); + typeType(); + setState(845); + variableDeclarators(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LocalTypeDeclarationContext extends ParserRuleContext { + public ClassDeclarationContext classDeclaration() { + return getRuleContext(ClassDeclarationContext.class,0); + } + public InterfaceDeclarationContext interfaceDeclaration() { + return getRuleContext(InterfaceDeclarationContext.class,0); + } + public List classOrInterfaceModifier() { + return getRuleContexts(ClassOrInterfaceModifierContext.class); + } + public ClassOrInterfaceModifierContext classOrInterfaceModifier(int i) { + return getRuleContext(ClassOrInterfaceModifierContext.class,i); + } + public TerminalNode SEMI() { return getToken(JavaParser.SEMI, 0); } + public LocalTypeDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_localTypeDeclaration; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterLocalTypeDeclaration(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitLocalTypeDeclaration(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitLocalTypeDeclaration(this); + else return visitor.visitChildren(this); + } + } + + public final LocalTypeDeclarationContext localTypeDeclaration() throws RecognitionException { + LocalTypeDeclarationContext _localctx = new LocalTypeDeclarationContext(_ctx, getState()); + enterRule(_localctx, 134, RULE_localTypeDeclaration); + int _la; + try { + setState(858); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ABSTRACT: + case CLASS: + case FINAL: + case INTERFACE: + case PRIVATE: + case PROTECTED: + case PUBLIC: + case STATIC: + case STRICTFP: + case AT: + case IDENTIFIER: + enterOuterAlt(_localctx, 1); + { + setState(850); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << FINAL) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << STATIC) | (1L << STRICTFP))) != 0) || _la==AT || _la==IDENTIFIER) { + { + { + setState(847); + classOrInterfaceModifier(); + } + } + setState(852); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(855); + _errHandler.sync(this); + switch (_input.LA(1)) { + case CLASS: + { + setState(853); + classDeclaration(); + } + break; + case INTERFACE: + { + setState(854); + interfaceDeclaration(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case SEMI: + enterOuterAlt(_localctx, 2); + { + setState(857); + 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 StatementContext extends ParserRuleContext { + public BlockContext blockLabel; + public ExpressionContext statementExpression; + public Token identifierLabel; + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public TerminalNode ASSERT() { return getToken(JavaParser.ASSERT, 0); } + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public TerminalNode SEMI() { return getToken(JavaParser.SEMI, 0); } + public TerminalNode COLON() { return getToken(JavaParser.COLON, 0); } + public TerminalNode IF() { return getToken(JavaParser.IF, 0); } + public ParExpressionContext parExpression() { + return getRuleContext(ParExpressionContext.class,0); + } + public List statement() { + return getRuleContexts(StatementContext.class); + } + public StatementContext statement(int i) { + return getRuleContext(StatementContext.class,i); + } + public TerminalNode ELSE() { return getToken(JavaParser.ELSE, 0); } + public TerminalNode FOR() { return getToken(JavaParser.FOR, 0); } + public TerminalNode LPAREN() { return getToken(JavaParser.LPAREN, 0); } + public ForControlContext forControl() { + return getRuleContext(ForControlContext.class,0); + } + public TerminalNode RPAREN() { return getToken(JavaParser.RPAREN, 0); } + public TerminalNode WHILE() { return getToken(JavaParser.WHILE, 0); } + public TerminalNode DO() { return getToken(JavaParser.DO, 0); } + public TerminalNode TRY() { return getToken(JavaParser.TRY, 0); } + public FinallyBlockContext finallyBlock() { + return getRuleContext(FinallyBlockContext.class,0); + } + public List catchClause() { + return getRuleContexts(CatchClauseContext.class); + } + public CatchClauseContext catchClause(int i) { + return getRuleContext(CatchClauseContext.class,i); + } + public ResourceSpecificationContext resourceSpecification() { + return getRuleContext(ResourceSpecificationContext.class,0); + } + public TerminalNode SWITCH() { return getToken(JavaParser.SWITCH, 0); } + public TerminalNode LBRACE() { return getToken(JavaParser.LBRACE, 0); } + public TerminalNode RBRACE() { return getToken(JavaParser.RBRACE, 0); } + public List switchBlockStatementGroup() { + return getRuleContexts(SwitchBlockStatementGroupContext.class); + } + public SwitchBlockStatementGroupContext switchBlockStatementGroup(int i) { + return getRuleContext(SwitchBlockStatementGroupContext.class,i); + } + public List switchLabel() { + return getRuleContexts(SwitchLabelContext.class); + } + public SwitchLabelContext switchLabel(int i) { + return getRuleContext(SwitchLabelContext.class,i); + } + public TerminalNode SYNCHRONIZED() { return getToken(JavaParser.SYNCHRONIZED, 0); } + public TerminalNode RETURN() { return getToken(JavaParser.RETURN, 0); } + public TerminalNode THROW() { return getToken(JavaParser.THROW, 0); } + public TerminalNode BREAK() { return getToken(JavaParser.BREAK, 0); } + public TerminalNode IDENTIFIER() { return getToken(JavaParser.IDENTIFIER, 0); } + public TerminalNode CONTINUE() { return getToken(JavaParser.CONTINUE, 0); } + public StatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_statement; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterStatement(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitStatement(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitStatement(this); + else return visitor.visitChildren(this); + } + } + + public final StatementContext statement() throws RecognitionException { + StatementContext _localctx = new StatementContext(_ctx, getState()); + enterRule(_localctx, 136, RULE_statement); + int _la; + try { + int _alt; + setState(964); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,113,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(860); + ((StatementContext)_localctx).blockLabel = block(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(861); + match(ASSERT); + setState(862); + expression(0); + setState(865); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==COLON) { + { + setState(863); + match(COLON); + setState(864); + expression(0); + } + } + + setState(867); + match(SEMI); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(869); + match(IF); + setState(870); + parExpression(); + setState(871); + statement(); + setState(874); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,102,_ctx) ) { + case 1: + { + setState(872); + match(ELSE); + setState(873); + statement(); + } + break; + } + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(876); + match(FOR); + setState(877); + match(LPAREN); + setState(878); + forControl(); + setState(879); + match(RPAREN); + setState(880); + statement(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(882); + match(WHILE); + setState(883); + parExpression(); + setState(884); + statement(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(886); + match(DO); + setState(887); + statement(); + setState(888); + match(WHILE); + setState(889); + parExpression(); + setState(890); + match(SEMI); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(892); + match(TRY); + setState(893); + block(); + setState(903); + _errHandler.sync(this); + switch (_input.LA(1)) { + case CATCH: + { + setState(895); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(894); + catchClause(); + } + } + setState(897); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==CATCH ); + setState(900); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FINALLY) { + { + setState(899); + finallyBlock(); + } + } + + } + break; + case FINALLY: + { + setState(902); + finallyBlock(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(905); + match(TRY); + setState(906); + resourceSpecification(); + setState(907); + block(); + setState(911); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CATCH) { + { + { + setState(908); + catchClause(); + } + } + setState(913); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(915); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==FINALLY) { + { + setState(914); + finallyBlock(); + } + } + + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(917); + match(SWITCH); + setState(918); + parExpression(); + setState(919); + match(LBRACE); + setState(923); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,108,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(920); + switchBlockStatementGroup(); + } + } + } + setState(925); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,108,_ctx); + } + setState(929); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==CASE || _la==DEFAULT) { + { + { + setState(926); + switchLabel(); + } + } + setState(931); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(932); + match(RBRACE); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(934); + match(SYNCHRONIZED); + setState(935); + parExpression(); + setState(936); + block(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(938); + match(RETURN); + setState(940); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << DECIMAL_LITERAL) | (1L << HEX_LITERAL) | (1L << OCT_LITERAL) | (1L << BINARY_LITERAL) | (1L << FLOAT_LITERAL) | (1L << HEX_FLOAT_LITERAL) | (1L << BOOL_LITERAL) | (1L << CHAR_LITERAL) | (1L << STRING_LITERAL) | (1L << NULL_LITERAL) | (1L << LPAREN))) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & ((1L << (LT - 73)) | (1L << (BANG - 73)) | (1L << (TILDE - 73)) | (1L << (INC - 73)) | (1L << (DEC - 73)) | (1L << (ADD - 73)) | (1L << (SUB - 73)) | (1L << (AT - 73)) | (1L << (IDENTIFIER - 73)))) != 0)) { + { + setState(939); + expression(0); + } + } + + setState(942); + match(SEMI); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(943); + match(THROW); + setState(944); + expression(0); + setState(945); + match(SEMI); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(947); + match(BREAK); + setState(949); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IDENTIFIER) { + { + setState(948); + match(IDENTIFIER); + } + } + + setState(951); + match(SEMI); + } + break; + case 14: + enterOuterAlt(_localctx, 14); + { + setState(952); + match(CONTINUE); + setState(954); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==IDENTIFIER) { + { + setState(953); + match(IDENTIFIER); + } + } + + setState(956); + match(SEMI); + } + break; + case 15: + enterOuterAlt(_localctx, 15); + { + setState(957); + match(SEMI); + } + break; + case 16: + enterOuterAlt(_localctx, 16); + { + setState(958); + ((StatementContext)_localctx).statementExpression = expression(0); + setState(959); + match(SEMI); + } + break; + case 17: + enterOuterAlt(_localctx, 17); + { + setState(961); + ((StatementContext)_localctx).identifierLabel = match(IDENTIFIER); + setState(962); + match(COLON); + setState(963); + statement(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class CatchClauseContext extends ParserRuleContext { + public TerminalNode CATCH() { return getToken(JavaParser.CATCH, 0); } + public TerminalNode LPAREN() { return getToken(JavaParser.LPAREN, 0); } + public CatchTypeContext catchType() { + return getRuleContext(CatchTypeContext.class,0); + } + public TerminalNode IDENTIFIER() { return getToken(JavaParser.IDENTIFIER, 0); } + public TerminalNode RPAREN() { return getToken(JavaParser.RPAREN, 0); } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public List variableModifier() { + return getRuleContexts(VariableModifierContext.class); + } + public VariableModifierContext variableModifier(int i) { + return getRuleContext(VariableModifierContext.class,i); + } + public CatchClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_catchClause; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterCatchClause(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitCatchClause(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitCatchClause(this); + else return visitor.visitChildren(this); + } + } + + public final CatchClauseContext catchClause() throws RecognitionException { + CatchClauseContext _localctx = new CatchClauseContext(_ctx, getState()); + enterRule(_localctx, 138, RULE_catchClause); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(966); + match(CATCH); + setState(967); + match(LPAREN); + setState(971); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,114,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(968); + variableModifier(); + } + } + } + setState(973); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,114,_ctx); + } + setState(974); + catchType(); + setState(975); + match(IDENTIFIER); + setState(976); + match(RPAREN); + setState(977); + block(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class CatchTypeContext extends ParserRuleContext { + public List qualifiedName() { + return getRuleContexts(QualifiedNameContext.class); + } + public QualifiedNameContext qualifiedName(int i) { + return getRuleContext(QualifiedNameContext.class,i); + } + public List BITOR() { return getTokens(JavaParser.BITOR); } + public TerminalNode BITOR(int i) { + return getToken(JavaParser.BITOR, i); + } + public CatchTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_catchType; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterCatchType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitCatchType(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitCatchType(this); + else return visitor.visitChildren(this); + } + } + + public final CatchTypeContext catchType() throws RecognitionException { + CatchTypeContext _localctx = new CatchTypeContext(_ctx, getState()); + enterRule(_localctx, 140, RULE_catchType); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(979); + qualifiedName(); + setState(984); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==BITOR) { + { + { + setState(980); + match(BITOR); + setState(981); + qualifiedName(); + } + } + setState(986); + _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 FinallyBlockContext extends ParserRuleContext { + public TerminalNode FINALLY() { return getToken(JavaParser.FINALLY, 0); } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public FinallyBlockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_finallyBlock; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterFinallyBlock(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitFinallyBlock(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitFinallyBlock(this); + else return visitor.visitChildren(this); + } + } + + public final FinallyBlockContext finallyBlock() throws RecognitionException { + FinallyBlockContext _localctx = new FinallyBlockContext(_ctx, getState()); + enterRule(_localctx, 142, RULE_finallyBlock); + try { + enterOuterAlt(_localctx, 1); + { + setState(987); + match(FINALLY); + setState(988); + block(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ResourceSpecificationContext extends ParserRuleContext { + public TerminalNode LPAREN() { return getToken(JavaParser.LPAREN, 0); } + public ResourcesContext resources() { + return getRuleContext(ResourcesContext.class,0); + } + public TerminalNode RPAREN() { return getToken(JavaParser.RPAREN, 0); } + public TerminalNode SEMI() { return getToken(JavaParser.SEMI, 0); } + public ResourceSpecificationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_resourceSpecification; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterResourceSpecification(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitResourceSpecification(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitResourceSpecification(this); + else return visitor.visitChildren(this); + } + } + + public final ResourceSpecificationContext resourceSpecification() throws RecognitionException { + ResourceSpecificationContext _localctx = new ResourceSpecificationContext(_ctx, getState()); + enterRule(_localctx, 144, RULE_resourceSpecification); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(990); + match(LPAREN); + setState(991); + resources(); + setState(993); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==SEMI) { + { + setState(992); + match(SEMI); + } + } + + setState(995); + match(RPAREN); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ResourcesContext extends ParserRuleContext { + public List resource() { + return getRuleContexts(ResourceContext.class); + } + public ResourceContext resource(int i) { + return getRuleContext(ResourceContext.class,i); + } + public List SEMI() { return getTokens(JavaParser.SEMI); } + public TerminalNode SEMI(int i) { + return getToken(JavaParser.SEMI, i); + } + public ResourcesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_resources; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterResources(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitResources(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitResources(this); + else return visitor.visitChildren(this); + } + } + + public final ResourcesContext resources() throws RecognitionException { + ResourcesContext _localctx = new ResourcesContext(_ctx, getState()); + enterRule(_localctx, 146, RULE_resources); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(997); + resource(); + setState(1002); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,117,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(998); + match(SEMI); + setState(999); + resource(); + } + } + } + setState(1004); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,117,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ResourceContext extends ParserRuleContext { + public ClassOrInterfaceTypeContext classOrInterfaceType() { + return getRuleContext(ClassOrInterfaceTypeContext.class,0); + } + public VariableDeclaratorIdContext variableDeclaratorId() { + return getRuleContext(VariableDeclaratorIdContext.class,0); + } + public TerminalNode ASSIGN() { return getToken(JavaParser.ASSIGN, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public List variableModifier() { + return getRuleContexts(VariableModifierContext.class); + } + public VariableModifierContext variableModifier(int i) { + return getRuleContext(VariableModifierContext.class,i); + } + public ResourceContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_resource; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterResource(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitResource(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitResource(this); + else return visitor.visitChildren(this); + } + } + + public final ResourceContext resource() throws RecognitionException { + ResourceContext _localctx = new ResourceContext(_ctx, getState()); + enterRule(_localctx, 148, RULE_resource); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1008); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,118,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1005); + variableModifier(); + } + } + } + setState(1010); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,118,_ctx); + } + setState(1011); + classOrInterfaceType(); + setState(1012); + variableDeclaratorId(); + setState(1013); + match(ASSIGN); + setState(1014); + expression(0); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SwitchBlockStatementGroupContext extends ParserRuleContext { + public List switchLabel() { + return getRuleContexts(SwitchLabelContext.class); + } + public SwitchLabelContext switchLabel(int i) { + return getRuleContext(SwitchLabelContext.class,i); + } + public List blockStatement() { + return getRuleContexts(BlockStatementContext.class); + } + public BlockStatementContext blockStatement(int i) { + return getRuleContext(BlockStatementContext.class,i); + } + public SwitchBlockStatementGroupContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_switchBlockStatementGroup; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterSwitchBlockStatementGroup(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitSwitchBlockStatementGroup(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitSwitchBlockStatementGroup(this); + else return visitor.visitChildren(this); + } + } + + public final SwitchBlockStatementGroupContext switchBlockStatementGroup() throws RecognitionException { + SwitchBlockStatementGroupContext _localctx = new SwitchBlockStatementGroupContext(_ctx, getState()); + enterRule(_localctx, 150, RULE_switchBlockStatementGroup); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1017); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1016); + switchLabel(); + } + } + setState(1019); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( _la==CASE || _la==DEFAULT ); + setState(1022); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1021); + blockStatement(); + } + } + setState(1024); + _errHandler.sync(this); + _la = _input.LA(1); + } while ( (((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ABSTRACT) | (1L << ASSERT) | (1L << BOOLEAN) | (1L << BREAK) | (1L << BYTE) | (1L << CHAR) | (1L << CLASS) | (1L << CONTINUE) | (1L << DO) | (1L << DOUBLE) | (1L << FINAL) | (1L << FLOAT) | (1L << FOR) | (1L << IF) | (1L << INT) | (1L << INTERFACE) | (1L << LONG) | (1L << NEW) | (1L << PRIVATE) | (1L << PROTECTED) | (1L << PUBLIC) | (1L << RETURN) | (1L << SHORT) | (1L << STATIC) | (1L << STRICTFP) | (1L << SUPER) | (1L << SWITCH) | (1L << SYNCHRONIZED) | (1L << THIS) | (1L << THROW) | (1L << TRY) | (1L << VOID) | (1L << WHILE) | (1L << DECIMAL_LITERAL) | (1L << HEX_LITERAL) | (1L << OCT_LITERAL) | (1L << BINARY_LITERAL) | (1L << FLOAT_LITERAL) | (1L << HEX_FLOAT_LITERAL) | (1L << BOOL_LITERAL) | (1L << CHAR_LITERAL) | (1L << STRING_LITERAL) | (1L << NULL_LITERAL) | (1L << LPAREN))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (LBRACE - 64)) | (1L << (SEMI - 64)) | (1L << (LT - 64)) | (1L << (BANG - 64)) | (1L << (TILDE - 64)) | (1L << (INC - 64)) | (1L << (DEC - 64)) | (1L << (ADD - 64)) | (1L << (SUB - 64)) | (1L << (AT - 64)) | (1L << (IDENTIFIER - 64)))) != 0) ); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SwitchLabelContext extends ParserRuleContext { + public ExpressionContext constantExpression; + public Token enumConstantName; + public TerminalNode CASE() { return getToken(JavaParser.CASE, 0); } + public TerminalNode COLON() { return getToken(JavaParser.COLON, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode IDENTIFIER() { return getToken(JavaParser.IDENTIFIER, 0); } + public TerminalNode DEFAULT() { return getToken(JavaParser.DEFAULT, 0); } + public SwitchLabelContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_switchLabel; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterSwitchLabel(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitSwitchLabel(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitSwitchLabel(this); + else return visitor.visitChildren(this); + } + } + + public final SwitchLabelContext switchLabel() throws RecognitionException { + SwitchLabelContext _localctx = new SwitchLabelContext(_ctx, getState()); + enterRule(_localctx, 152, RULE_switchLabel); + try { + setState(1034); + _errHandler.sync(this); + switch (_input.LA(1)) { + case CASE: + enterOuterAlt(_localctx, 1); + { + setState(1026); + match(CASE); + setState(1029); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,121,_ctx) ) { + case 1: + { + setState(1027); + ((SwitchLabelContext)_localctx).constantExpression = expression(0); + } + break; + case 2: + { + setState(1028); + ((SwitchLabelContext)_localctx).enumConstantName = match(IDENTIFIER); + } + break; + } + setState(1031); + match(COLON); + } + break; + case DEFAULT: + enterOuterAlt(_localctx, 2); + { + setState(1032); + match(DEFAULT); + setState(1033); + match(COLON); + } + 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 ForControlContext extends ParserRuleContext { + public ExpressionListContext forUpdate; + public EnhancedForControlContext enhancedForControl() { + return getRuleContext(EnhancedForControlContext.class,0); + } + public List SEMI() { return getTokens(JavaParser.SEMI); } + public TerminalNode SEMI(int i) { + return getToken(JavaParser.SEMI, i); + } + public ForInitContext forInit() { + return getRuleContext(ForInitContext.class,0); + } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public ExpressionListContext expressionList() { + return getRuleContext(ExpressionListContext.class,0); + } + public ForControlContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_forControl; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterForControl(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitForControl(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitForControl(this); + else return visitor.visitChildren(this); + } + } + + public final ForControlContext forControl() throws RecognitionException { + ForControlContext _localctx = new ForControlContext(_ctx, getState()); + enterRule(_localctx, 154, RULE_forControl); + int _la; + try { + setState(1048); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,126,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1036); + enhancedForControl(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1038); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << DECIMAL_LITERAL) | (1L << HEX_LITERAL) | (1L << OCT_LITERAL) | (1L << BINARY_LITERAL) | (1L << FLOAT_LITERAL) | (1L << HEX_FLOAT_LITERAL) | (1L << BOOL_LITERAL) | (1L << CHAR_LITERAL) | (1L << STRING_LITERAL) | (1L << NULL_LITERAL) | (1L << LPAREN))) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & ((1L << (LT - 73)) | (1L << (BANG - 73)) | (1L << (TILDE - 73)) | (1L << (INC - 73)) | (1L << (DEC - 73)) | (1L << (ADD - 73)) | (1L << (SUB - 73)) | (1L << (AT - 73)) | (1L << (IDENTIFIER - 73)))) != 0)) { + { + setState(1037); + forInit(); + } + } + + setState(1040); + match(SEMI); + setState(1042); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << DECIMAL_LITERAL) | (1L << HEX_LITERAL) | (1L << OCT_LITERAL) | (1L << BINARY_LITERAL) | (1L << FLOAT_LITERAL) | (1L << HEX_FLOAT_LITERAL) | (1L << BOOL_LITERAL) | (1L << CHAR_LITERAL) | (1L << STRING_LITERAL) | (1L << NULL_LITERAL) | (1L << LPAREN))) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & ((1L << (LT - 73)) | (1L << (BANG - 73)) | (1L << (TILDE - 73)) | (1L << (INC - 73)) | (1L << (DEC - 73)) | (1L << (ADD - 73)) | (1L << (SUB - 73)) | (1L << (AT - 73)) | (1L << (IDENTIFIER - 73)))) != 0)) { + { + setState(1041); + expression(0); + } + } + + setState(1044); + match(SEMI); + setState(1046); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << DECIMAL_LITERAL) | (1L << HEX_LITERAL) | (1L << OCT_LITERAL) | (1L << BINARY_LITERAL) | (1L << FLOAT_LITERAL) | (1L << HEX_FLOAT_LITERAL) | (1L << BOOL_LITERAL) | (1L << CHAR_LITERAL) | (1L << STRING_LITERAL) | (1L << NULL_LITERAL) | (1L << LPAREN))) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & ((1L << (LT - 73)) | (1L << (BANG - 73)) | (1L << (TILDE - 73)) | (1L << (INC - 73)) | (1L << (DEC - 73)) | (1L << (ADD - 73)) | (1L << (SUB - 73)) | (1L << (AT - 73)) | (1L << (IDENTIFIER - 73)))) != 0)) { + { + setState(1045); + ((ForControlContext)_localctx).forUpdate = expressionList(); + } + } + + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ForInitContext extends ParserRuleContext { + public LocalVariableDeclarationContext localVariableDeclaration() { + return getRuleContext(LocalVariableDeclarationContext.class,0); + } + public ExpressionListContext expressionList() { + return getRuleContext(ExpressionListContext.class,0); + } + public ForInitContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_forInit; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterForInit(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitForInit(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitForInit(this); + else return visitor.visitChildren(this); + } + } + + public final ForInitContext forInit() throws RecognitionException { + ForInitContext _localctx = new ForInitContext(_ctx, getState()); + enterRule(_localctx, 156, RULE_forInit); + try { + setState(1052); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,127,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1050); + localVariableDeclaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1051); + expressionList(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class EnhancedForControlContext extends ParserRuleContext { + public TypeTypeContext typeType() { + return getRuleContext(TypeTypeContext.class,0); + } + public VariableDeclaratorIdContext variableDeclaratorId() { + return getRuleContext(VariableDeclaratorIdContext.class,0); + } + public TerminalNode COLON() { return getToken(JavaParser.COLON, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public List variableModifier() { + return getRuleContexts(VariableModifierContext.class); + } + public VariableModifierContext variableModifier(int i) { + return getRuleContext(VariableModifierContext.class,i); + } + public EnhancedForControlContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_enhancedForControl; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterEnhancedForControl(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitEnhancedForControl(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitEnhancedForControl(this); + else return visitor.visitChildren(this); + } + } + + public final EnhancedForControlContext enhancedForControl() throws RecognitionException { + EnhancedForControlContext _localctx = new EnhancedForControlContext(_ctx, getState()); + enterRule(_localctx, 158, RULE_enhancedForControl); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1057); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,128,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1054); + variableModifier(); + } + } + } + setState(1059); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,128,_ctx); + } + setState(1060); + typeType(); + setState(1061); + variableDeclaratorId(); + setState(1062); + match(COLON); + setState(1063); + expression(0); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ParExpressionContext extends ParserRuleContext { + public TerminalNode LPAREN() { return getToken(JavaParser.LPAREN, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode RPAREN() { return getToken(JavaParser.RPAREN, 0); } + public ParExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_parExpression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterParExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitParExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitParExpression(this); + else return visitor.visitChildren(this); + } + } + + public final ParExpressionContext parExpression() throws RecognitionException { + ParExpressionContext _localctx = new ParExpressionContext(_ctx, getState()); + enterRule(_localctx, 160, RULE_parExpression); + try { + enterOuterAlt(_localctx, 1); + { + setState(1065); + match(LPAREN); + setState(1066); + expression(0); + setState(1067); + match(RPAREN); + } + } + 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 List expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public List COMMA() { return getTokens(JavaParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(JavaParser.COMMA, i); + } + public ExpressionListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expressionList; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterExpressionList(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitExpressionList(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitExpressionList(this); + else return visitor.visitChildren(this); + } + } + + public final ExpressionListContext expressionList() throws RecognitionException { + ExpressionListContext _localctx = new ExpressionListContext(_ctx, getState()); + enterRule(_localctx, 162, RULE_expressionList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1069); + expression(0); + setState(1074); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(1070); + match(COMMA); + setState(1071); + expression(0); + } + } + setState(1076); + _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 MethodCallContext extends ParserRuleContext { + public TerminalNode IDENTIFIER() { return getToken(JavaParser.IDENTIFIER, 0); } + public TerminalNode LPAREN() { return getToken(JavaParser.LPAREN, 0); } + public TerminalNode RPAREN() { return getToken(JavaParser.RPAREN, 0); } + public ExpressionListContext expressionList() { + return getRuleContext(ExpressionListContext.class,0); + } + public TerminalNode THIS() { return getToken(JavaParser.THIS, 0); } + public TerminalNode SUPER() { return getToken(JavaParser.SUPER, 0); } + public MethodCallContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_methodCall; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterMethodCall(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitMethodCall(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitMethodCall(this); + else return visitor.visitChildren(this); + } + } + + public final MethodCallContext methodCall() throws RecognitionException { + MethodCallContext _localctx = new MethodCallContext(_ctx, getState()); + enterRule(_localctx, 164, RULE_methodCall); + int _la; + try { + setState(1095); + _errHandler.sync(this); + switch (_input.LA(1)) { + case IDENTIFIER: + enterOuterAlt(_localctx, 1); + { + setState(1077); + match(IDENTIFIER); + setState(1078); + match(LPAREN); + setState(1080); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << DECIMAL_LITERAL) | (1L << HEX_LITERAL) | (1L << OCT_LITERAL) | (1L << BINARY_LITERAL) | (1L << FLOAT_LITERAL) | (1L << HEX_FLOAT_LITERAL) | (1L << BOOL_LITERAL) | (1L << CHAR_LITERAL) | (1L << STRING_LITERAL) | (1L << NULL_LITERAL) | (1L << LPAREN))) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & ((1L << (LT - 73)) | (1L << (BANG - 73)) | (1L << (TILDE - 73)) | (1L << (INC - 73)) | (1L << (DEC - 73)) | (1L << (ADD - 73)) | (1L << (SUB - 73)) | (1L << (AT - 73)) | (1L << (IDENTIFIER - 73)))) != 0)) { + { + setState(1079); + expressionList(); + } + } + + setState(1082); + match(RPAREN); + } + break; + case THIS: + enterOuterAlt(_localctx, 2); + { + setState(1083); + match(THIS); + setState(1084); + match(LPAREN); + setState(1086); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << DECIMAL_LITERAL) | (1L << HEX_LITERAL) | (1L << OCT_LITERAL) | (1L << BINARY_LITERAL) | (1L << FLOAT_LITERAL) | (1L << HEX_FLOAT_LITERAL) | (1L << BOOL_LITERAL) | (1L << CHAR_LITERAL) | (1L << STRING_LITERAL) | (1L << NULL_LITERAL) | (1L << LPAREN))) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & ((1L << (LT - 73)) | (1L << (BANG - 73)) | (1L << (TILDE - 73)) | (1L << (INC - 73)) | (1L << (DEC - 73)) | (1L << (ADD - 73)) | (1L << (SUB - 73)) | (1L << (AT - 73)) | (1L << (IDENTIFIER - 73)))) != 0)) { + { + setState(1085); + expressionList(); + } + } + + setState(1088); + match(RPAREN); + } + break; + case SUPER: + enterOuterAlt(_localctx, 3); + { + setState(1089); + match(SUPER); + setState(1090); + match(LPAREN); + setState(1092); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << DECIMAL_LITERAL) | (1L << HEX_LITERAL) | (1L << OCT_LITERAL) | (1L << BINARY_LITERAL) | (1L << FLOAT_LITERAL) | (1L << HEX_FLOAT_LITERAL) | (1L << BOOL_LITERAL) | (1L << CHAR_LITERAL) | (1L << STRING_LITERAL) | (1L << NULL_LITERAL) | (1L << LPAREN))) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & ((1L << (LT - 73)) | (1L << (BANG - 73)) | (1L << (TILDE - 73)) | (1L << (INC - 73)) | (1L << (DEC - 73)) | (1L << (ADD - 73)) | (1L << (SUB - 73)) | (1L << (AT - 73)) | (1L << (IDENTIFIER - 73)))) != 0)) { + { + setState(1091); + expressionList(); + } + } + + setState(1094); + match(RPAREN); + } + 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 ExpressionContext extends ParserRuleContext { + public Token prefix; + public Token bop; + public Token postfix; + public PrimaryContext primary() { + return getRuleContext(PrimaryContext.class,0); + } + public MethodCallContext methodCall() { + return getRuleContext(MethodCallContext.class,0); + } + public TerminalNode NEW() { return getToken(JavaParser.NEW, 0); } + public CreatorContext creator() { + return getRuleContext(CreatorContext.class,0); + } + public TerminalNode LPAREN() { return getToken(JavaParser.LPAREN, 0); } + public List typeType() { + return getRuleContexts(TypeTypeContext.class); + } + public TypeTypeContext typeType(int i) { + return getRuleContext(TypeTypeContext.class,i); + } + public TerminalNode RPAREN() { return getToken(JavaParser.RPAREN, 0); } + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public List annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public List BITAND() { return getTokens(JavaParser.BITAND); } + public TerminalNode BITAND(int i) { + return getToken(JavaParser.BITAND, i); + } + public TerminalNode ADD() { return getToken(JavaParser.ADD, 0); } + public TerminalNode SUB() { return getToken(JavaParser.SUB, 0); } + public TerminalNode INC() { return getToken(JavaParser.INC, 0); } + public TerminalNode DEC() { return getToken(JavaParser.DEC, 0); } + public TerminalNode TILDE() { return getToken(JavaParser.TILDE, 0); } + public TerminalNode BANG() { return getToken(JavaParser.BANG, 0); } + public LambdaExpressionContext lambdaExpression() { + return getRuleContext(LambdaExpressionContext.class,0); + } + public TerminalNode COLONCOLON() { return getToken(JavaParser.COLONCOLON, 0); } + public TerminalNode IDENTIFIER() { return getToken(JavaParser.IDENTIFIER, 0); } + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public ClassTypeContext classType() { + return getRuleContext(ClassTypeContext.class,0); + } + public TerminalNode MUL() { return getToken(JavaParser.MUL, 0); } + public TerminalNode DIV() { return getToken(JavaParser.DIV, 0); } + public TerminalNode MOD() { return getToken(JavaParser.MOD, 0); } + public List LT() { return getTokens(JavaParser.LT); } + public TerminalNode LT(int i) { + return getToken(JavaParser.LT, i); + } + public List GT() { return getTokens(JavaParser.GT); } + public TerminalNode GT(int i) { + return getToken(JavaParser.GT, i); + } + public TerminalNode LE() { return getToken(JavaParser.LE, 0); } + public TerminalNode GE() { return getToken(JavaParser.GE, 0); } + public TerminalNode EQUAL() { return getToken(JavaParser.EQUAL, 0); } + public TerminalNode NOTEQUAL() { return getToken(JavaParser.NOTEQUAL, 0); } + public TerminalNode CARET() { return getToken(JavaParser.CARET, 0); } + public TerminalNode BITOR() { return getToken(JavaParser.BITOR, 0); } + public TerminalNode AND() { return getToken(JavaParser.AND, 0); } + public TerminalNode OR() { return getToken(JavaParser.OR, 0); } + public TerminalNode COLON() { return getToken(JavaParser.COLON, 0); } + public TerminalNode QUESTION() { return getToken(JavaParser.QUESTION, 0); } + public TerminalNode ASSIGN() { return getToken(JavaParser.ASSIGN, 0); } + public TerminalNode ADD_ASSIGN() { return getToken(JavaParser.ADD_ASSIGN, 0); } + public TerminalNode SUB_ASSIGN() { return getToken(JavaParser.SUB_ASSIGN, 0); } + public TerminalNode MUL_ASSIGN() { return getToken(JavaParser.MUL_ASSIGN, 0); } + public TerminalNode DIV_ASSIGN() { return getToken(JavaParser.DIV_ASSIGN, 0); } + public TerminalNode AND_ASSIGN() { return getToken(JavaParser.AND_ASSIGN, 0); } + public TerminalNode OR_ASSIGN() { return getToken(JavaParser.OR_ASSIGN, 0); } + public TerminalNode XOR_ASSIGN() { return getToken(JavaParser.XOR_ASSIGN, 0); } + public TerminalNode RSHIFT_ASSIGN() { return getToken(JavaParser.RSHIFT_ASSIGN, 0); } + public TerminalNode URSHIFT_ASSIGN() { return getToken(JavaParser.URSHIFT_ASSIGN, 0); } + public TerminalNode LSHIFT_ASSIGN() { return getToken(JavaParser.LSHIFT_ASSIGN, 0); } + public TerminalNode MOD_ASSIGN() { return getToken(JavaParser.MOD_ASSIGN, 0); } + public TerminalNode DOT() { return getToken(JavaParser.DOT, 0); } + public TerminalNode THIS() { return getToken(JavaParser.THIS, 0); } + public InnerCreatorContext innerCreator() { + return getRuleContext(InnerCreatorContext.class,0); + } + public TerminalNode SUPER() { return getToken(JavaParser.SUPER, 0); } + public SuperSuffixContext superSuffix() { + return getRuleContext(SuperSuffixContext.class,0); + } + public ExplicitGenericInvocationContext explicitGenericInvocation() { + return getRuleContext(ExplicitGenericInvocationContext.class,0); + } + public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() { + return getRuleContext(NonWildcardTypeArgumentsContext.class,0); + } + public TerminalNode LBRACK() { return getToken(JavaParser.LBRACK, 0); } + public TerminalNode RBRACK() { return getToken(JavaParser.RBRACK, 0); } + public TerminalNode INSTANCEOF() { return getToken(JavaParser.INSTANCEOF, 0); } + public ExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_expression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitExpression(this); + else return visitor.visitChildren(this); + } + } + + public final ExpressionContext expression() throws RecognitionException { + return expression(0); + } + + private ExpressionContext expression(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState); + ExpressionContext _prevctx = _localctx; + int _startState = 166; + enterRecursionRule(_localctx, 166, RULE_expression, _p); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1141); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,139,_ctx) ) { + case 1: + { + setState(1098); + primary(); + } + break; + case 2: + { + setState(1099); + methodCall(); + } + break; + case 3: + { + setState(1100); + match(NEW); + setState(1101); + creator(); + } + break; + case 4: + { + setState(1102); + match(LPAREN); + setState(1106); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,134,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1103); + annotation(); + } + } + } + setState(1108); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,134,_ctx); + } + setState(1109); + typeType(); + setState(1114); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==BITAND) { + { + { + setState(1110); + match(BITAND); + setState(1111); + typeType(); + } + } + setState(1116); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1117); + match(RPAREN); + setState(1118); + expression(21); + } + break; + case 5: + { + setState(1120); + ((ExpressionContext)_localctx).prefix = _input.LT(1); + _la = _input.LA(1); + if ( !(((((_la - 84)) & ~0x3f) == 0 && ((1L << (_la - 84)) & ((1L << (INC - 84)) | (1L << (DEC - 84)) | (1L << (ADD - 84)) | (1L << (SUB - 84)))) != 0)) ) { + ((ExpressionContext)_localctx).prefix = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1121); + expression(19); + } + break; + case 6: + { + setState(1122); + ((ExpressionContext)_localctx).prefix = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==BANG || _la==TILDE) ) { + ((ExpressionContext)_localctx).prefix = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1123); + expression(18); + } + break; + case 7: + { + setState(1124); + lambdaExpression(); + } + break; + case 8: + { + setState(1125); + typeType(); + setState(1126); + match(COLONCOLON); + setState(1132); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LT: + case IDENTIFIER: + { + setState(1128); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LT) { + { + setState(1127); + typeArguments(); + } + } + + setState(1130); + match(IDENTIFIER); + } + break; + case NEW: + { + setState(1131); + match(NEW); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 9: + { + setState(1134); + classType(); + setState(1135); + match(COLONCOLON); + setState(1137); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LT) { + { + setState(1136); + typeArguments(); + } + } + + setState(1139); + match(NEW); + } + break; + } + _ctx.stop = _input.LT(-1); + setState(1223); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,145,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + if ( _parseListeners!=null ) triggerExitRuleEvent(); + _prevctx = _localctx; + { + setState(1221); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,144,_ctx) ) { + case 1: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1143); + if (!(precpred(_ctx, 17))) throw new FailedPredicateException(this, "precpred(_ctx, 17)"); + setState(1144); + ((ExpressionContext)_localctx).bop = _input.LT(1); + _la = _input.LA(1); + if ( !(((((_la - 88)) & ~0x3f) == 0 && ((1L << (_la - 88)) & ((1L << (MUL - 88)) | (1L << (DIV - 88)) | (1L << (MOD - 88)))) != 0)) ) { + ((ExpressionContext)_localctx).bop = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1145); + expression(18); + } + break; + case 2: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1146); + if (!(precpred(_ctx, 16))) throw new FailedPredicateException(this, "precpred(_ctx, 16)"); + setState(1147); + ((ExpressionContext)_localctx).bop = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==ADD || _la==SUB) ) { + ((ExpressionContext)_localctx).bop = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1148); + expression(17); + } + break; + case 3: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1149); + if (!(precpred(_ctx, 15))) throw new FailedPredicateException(this, "precpred(_ctx, 15)"); + setState(1157); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,140,_ctx) ) { + case 1: + { + setState(1150); + match(LT); + setState(1151); + match(LT); + } + break; + case 2: + { + setState(1152); + match(GT); + setState(1153); + match(GT); + setState(1154); + match(GT); + } + break; + case 3: + { + setState(1155); + match(GT); + setState(1156); + match(GT); + } + break; + } + setState(1159); + expression(16); + } + break; + case 4: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1160); + if (!(precpred(_ctx, 14))) throw new FailedPredicateException(this, "precpred(_ctx, 14)"); + setState(1161); + ((ExpressionContext)_localctx).bop = _input.LT(1); + _la = _input.LA(1); + if ( !(((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & ((1L << (GT - 72)) | (1L << (LT - 72)) | (1L << (LE - 72)) | (1L << (GE - 72)))) != 0)) ) { + ((ExpressionContext)_localctx).bop = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1162); + expression(15); + } + break; + case 5: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1163); + if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)"); + setState(1164); + ((ExpressionContext)_localctx).bop = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==EQUAL || _la==NOTEQUAL) ) { + ((ExpressionContext)_localctx).bop = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1165); + expression(13); + } + break; + case 6: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1166); + if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)"); + setState(1167); + ((ExpressionContext)_localctx).bop = match(BITAND); + setState(1168); + expression(12); + } + break; + case 7: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1169); + if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)"); + setState(1170); + ((ExpressionContext)_localctx).bop = match(CARET); + setState(1171); + expression(11); + } + break; + case 8: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1172); + if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)"); + setState(1173); + ((ExpressionContext)_localctx).bop = match(BITOR); + setState(1174); + expression(10); + } + break; + case 9: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1175); + if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)"); + setState(1176); + ((ExpressionContext)_localctx).bop = match(AND); + setState(1177); + expression(9); + } + break; + case 10: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1178); + if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)"); + setState(1179); + ((ExpressionContext)_localctx).bop = match(OR); + setState(1180); + expression(8); + } + break; + case 11: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1181); + if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)"); + setState(1182); + ((ExpressionContext)_localctx).bop = match(QUESTION); + setState(1183); + expression(0); + setState(1184); + match(COLON); + setState(1185); + expression(6); + } + break; + case 12: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1187); + if (!(precpred(_ctx, 5))) throw new FailedPredicateException(this, "precpred(_ctx, 5)"); + setState(1188); + ((ExpressionContext)_localctx).bop = _input.LT(1); + _la = _input.LA(1); + if ( !(((((_la - 71)) & ~0x3f) == 0 && ((1L << (_la - 71)) & ((1L << (ASSIGN - 71)) | (1L << (ADD_ASSIGN - 71)) | (1L << (SUB_ASSIGN - 71)) | (1L << (MUL_ASSIGN - 71)) | (1L << (DIV_ASSIGN - 71)) | (1L << (AND_ASSIGN - 71)) | (1L << (OR_ASSIGN - 71)) | (1L << (XOR_ASSIGN - 71)) | (1L << (MOD_ASSIGN - 71)) | (1L << (LSHIFT_ASSIGN - 71)) | (1L << (RSHIFT_ASSIGN - 71)) | (1L << (URSHIFT_ASSIGN - 71)))) != 0)) ) { + ((ExpressionContext)_localctx).bop = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1189); + expression(5); + } + break; + case 13: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1190); + if (!(precpred(_ctx, 25))) throw new FailedPredicateException(this, "precpred(_ctx, 25)"); + setState(1191); + ((ExpressionContext)_localctx).bop = match(DOT); + setState(1203); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,142,_ctx) ) { + case 1: + { + setState(1192); + match(IDENTIFIER); + } + break; + case 2: + { + setState(1193); + methodCall(); + } + break; + case 3: + { + setState(1194); + match(THIS); + } + break; + case 4: + { + setState(1195); + match(NEW); + setState(1197); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LT) { + { + setState(1196); + nonWildcardTypeArguments(); + } + } + + setState(1199); + innerCreator(); + } + break; + case 5: + { + setState(1200); + match(SUPER); + setState(1201); + superSuffix(); + } + break; + case 6: + { + setState(1202); + explicitGenericInvocation(); + } + break; + } + } + break; + case 14: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1205); + if (!(precpred(_ctx, 24))) throw new FailedPredicateException(this, "precpred(_ctx, 24)"); + setState(1206); + match(LBRACK); + setState(1207); + expression(0); + setState(1208); + match(RBRACK); + } + break; + case 15: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1210); + if (!(precpred(_ctx, 20))) throw new FailedPredicateException(this, "precpred(_ctx, 20)"); + setState(1211); + ((ExpressionContext)_localctx).postfix = _input.LT(1); + _la = _input.LA(1); + if ( !(_la==INC || _la==DEC) ) { + ((ExpressionContext)_localctx).postfix = (Token)_errHandler.recoverInline(this); + } + else { + if ( _input.LA(1)==Token.EOF ) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + break; + case 16: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1212); + if (!(precpred(_ctx, 13))) throw new FailedPredicateException(this, "precpred(_ctx, 13)"); + setState(1213); + ((ExpressionContext)_localctx).bop = match(INSTANCEOF); + setState(1214); + typeType(); + } + break; + case 17: + { + _localctx = new ExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_expression); + setState(1215); + if (!(precpred(_ctx, 3))) throw new FailedPredicateException(this, "precpred(_ctx, 3)"); + setState(1216); + match(COLONCOLON); + setState(1218); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LT) { + { + setState(1217); + typeArguments(); + } + } + + setState(1220); + match(IDENTIFIER); + } + break; + } + } + } + setState(1225); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,145,_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 LambdaParametersContext lambdaParameters() { + return getRuleContext(LambdaParametersContext.class,0); + } + public TerminalNode ARROW() { return getToken(JavaParser.ARROW, 0); } + public LambdaBodyContext lambdaBody() { + return getRuleContext(LambdaBodyContext.class,0); + } + public LambdaExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_lambdaExpression; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterLambdaExpression(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitLambdaExpression(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitLambdaExpression(this); + else return visitor.visitChildren(this); + } + } + + public final LambdaExpressionContext lambdaExpression() throws RecognitionException { + LambdaExpressionContext _localctx = new LambdaExpressionContext(_ctx, getState()); + enterRule(_localctx, 168, RULE_lambdaExpression); + try { + enterOuterAlt(_localctx, 1); + { + setState(1226); + lambdaParameters(); + setState(1227); + match(ARROW); + setState(1228); + lambdaBody(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LambdaParametersContext extends ParserRuleContext { + public List IDENTIFIER() { return getTokens(JavaParser.IDENTIFIER); } + public TerminalNode IDENTIFIER(int i) { + return getToken(JavaParser.IDENTIFIER, i); + } + public TerminalNode LPAREN() { return getToken(JavaParser.LPAREN, 0); } + public TerminalNode RPAREN() { return getToken(JavaParser.RPAREN, 0); } + public FormalParameterListContext formalParameterList() { + return getRuleContext(FormalParameterListContext.class,0); + } + public List COMMA() { return getTokens(JavaParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(JavaParser.COMMA, i); + } + public LambdaParametersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_lambdaParameters; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterLambdaParameters(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitLambdaParameters(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitLambdaParameters(this); + else return visitor.visitChildren(this); + } + } + + public final LambdaParametersContext lambdaParameters() throws RecognitionException { + LambdaParametersContext _localctx = new LambdaParametersContext(_ctx, getState()); + enterRule(_localctx, 170, RULE_lambdaParameters); + int _la; + try { + setState(1246); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1230); + match(IDENTIFIER); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1231); + match(LPAREN); + setState(1233); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FINAL) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << SHORT))) != 0) || _la==AT || _la==IDENTIFIER) { + { + setState(1232); + formalParameterList(); + } + } + + setState(1235); + match(RPAREN); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1236); + match(LPAREN); + setState(1237); + match(IDENTIFIER); + setState(1242); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(1238); + match(COMMA); + setState(1239); + match(IDENTIFIER); + } + } + setState(1244); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1245); + match(RPAREN); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class LambdaBodyContext extends ParserRuleContext { + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public BlockContext block() { + return getRuleContext(BlockContext.class,0); + } + public LambdaBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_lambdaBody; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterLambdaBody(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitLambdaBody(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitLambdaBody(this); + else return visitor.visitChildren(this); + } + } + + public final LambdaBodyContext lambdaBody() throws RecognitionException { + LambdaBodyContext _localctx = new LambdaBodyContext(_ctx, getState()); + enterRule(_localctx, 172, RULE_lambdaBody); + try { + setState(1250); + _errHandler.sync(this); + switch (_input.LA(1)) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case NEW: + case SHORT: + case SUPER: + case THIS: + case VOID: + case DECIMAL_LITERAL: + case HEX_LITERAL: + case OCT_LITERAL: + case BINARY_LITERAL: + case FLOAT_LITERAL: + case HEX_FLOAT_LITERAL: + case BOOL_LITERAL: + case CHAR_LITERAL: + case STRING_LITERAL: + case NULL_LITERAL: + case LPAREN: + case LT: + case BANG: + case TILDE: + case INC: + case DEC: + case ADD: + case SUB: + case AT: + case IDENTIFIER: + enterOuterAlt(_localctx, 1); + { + setState(1248); + expression(0); + } + break; + case LBRACE: + enterOuterAlt(_localctx, 2); + { + setState(1249); + block(); + } + 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 PrimaryContext extends ParserRuleContext { + public TerminalNode LPAREN() { return getToken(JavaParser.LPAREN, 0); } + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class,0); + } + public TerminalNode RPAREN() { return getToken(JavaParser.RPAREN, 0); } + public TerminalNode THIS() { return getToken(JavaParser.THIS, 0); } + public TerminalNode SUPER() { return getToken(JavaParser.SUPER, 0); } + public LiteralContext literal() { + return getRuleContext(LiteralContext.class,0); + } + public TerminalNode IDENTIFIER() { return getToken(JavaParser.IDENTIFIER, 0); } + public TypeTypeOrVoidContext typeTypeOrVoid() { + return getRuleContext(TypeTypeOrVoidContext.class,0); + } + public TerminalNode DOT() { return getToken(JavaParser.DOT, 0); } + public TerminalNode CLASS() { return getToken(JavaParser.CLASS, 0); } + public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() { + return getRuleContext(NonWildcardTypeArgumentsContext.class,0); + } + public ExplicitGenericInvocationSuffixContext explicitGenericInvocationSuffix() { + return getRuleContext(ExplicitGenericInvocationSuffixContext.class,0); + } + public ArgumentsContext arguments() { + return getRuleContext(ArgumentsContext.class,0); + } + public PrimaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_primary; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterPrimary(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitPrimary(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitPrimary(this); + else return visitor.visitChildren(this); + } + } + + public final PrimaryContext primary() throws RecognitionException { + PrimaryContext _localctx = new PrimaryContext(_ctx, getState()); + enterRule(_localctx, 174, RULE_primary); + try { + setState(1270); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,151,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1252); + match(LPAREN); + setState(1253); + expression(0); + setState(1254); + match(RPAREN); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1256); + match(THIS); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1257); + match(SUPER); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1258); + literal(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1259); + match(IDENTIFIER); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1260); + typeTypeOrVoid(); + setState(1261); + match(DOT); + setState(1262); + match(CLASS); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(1264); + nonWildcardTypeArguments(); + setState(1268); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SUPER: + case IDENTIFIER: + { + setState(1265); + explicitGenericInvocationSuffix(); + } + break; + case THIS: + { + setState(1266); + match(THIS); + setState(1267); + arguments(); + } + 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 ClassTypeContext extends ParserRuleContext { + public TerminalNode IDENTIFIER() { return getToken(JavaParser.IDENTIFIER, 0); } + public ClassOrInterfaceTypeContext classOrInterfaceType() { + return getRuleContext(ClassOrInterfaceTypeContext.class,0); + } + public TerminalNode DOT() { return getToken(JavaParser.DOT, 0); } + public List annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public ClassTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classType; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterClassType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitClassType(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitClassType(this); + else return visitor.visitChildren(this); + } + } + + public final ClassTypeContext classType() throws RecognitionException { + ClassTypeContext _localctx = new ClassTypeContext(_ctx, getState()); + enterRule(_localctx, 176, RULE_classType); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1275); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,152,_ctx) ) { + case 1: + { + setState(1272); + classOrInterfaceType(); + setState(1273); + match(DOT); + } + break; + } + setState(1280); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,153,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1277); + annotation(); + } + } + } + setState(1282); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,153,_ctx); + } + setState(1283); + match(IDENTIFIER); + setState(1285); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LT) { + { + setState(1284); + typeArguments(); + } + } + + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class CreatorContext extends ParserRuleContext { + public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() { + return getRuleContext(NonWildcardTypeArgumentsContext.class,0); + } + public CreatedNameContext createdName() { + return getRuleContext(CreatedNameContext.class,0); + } + public ClassCreatorRestContext classCreatorRest() { + return getRuleContext(ClassCreatorRestContext.class,0); + } + public ArrayCreatorRestContext arrayCreatorRest() { + return getRuleContext(ArrayCreatorRestContext.class,0); + } + public CreatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_creator; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterCreator(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitCreator(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitCreator(this); + else return visitor.visitChildren(this); + } + } + + public final CreatorContext creator() throws RecognitionException { + CreatorContext _localctx = new CreatorContext(_ctx, getState()); + enterRule(_localctx, 178, RULE_creator); + try { + setState(1296); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LT: + enterOuterAlt(_localctx, 1); + { + setState(1287); + nonWildcardTypeArguments(); + setState(1288); + createdName(); + setState(1289); + classCreatorRest(); + } + break; + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case SHORT: + case IDENTIFIER: + enterOuterAlt(_localctx, 2); + { + setState(1291); + createdName(); + setState(1294); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LBRACK: + { + setState(1292); + arrayCreatorRest(); + } + break; + case LPAREN: + { + setState(1293); + classCreatorRest(); + } + break; + default: + throw new NoViableAltException(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 CreatedNameContext extends ParserRuleContext { + public List IDENTIFIER() { return getTokens(JavaParser.IDENTIFIER); } + public TerminalNode IDENTIFIER(int i) { + return getToken(JavaParser.IDENTIFIER, i); + } + public List typeArgumentsOrDiamond() { + return getRuleContexts(TypeArgumentsOrDiamondContext.class); + } + public TypeArgumentsOrDiamondContext typeArgumentsOrDiamond(int i) { + return getRuleContext(TypeArgumentsOrDiamondContext.class,i); + } + public List DOT() { return getTokens(JavaParser.DOT); } + public TerminalNode DOT(int i) { + return getToken(JavaParser.DOT, i); + } + public PrimitiveTypeContext primitiveType() { + return getRuleContext(PrimitiveTypeContext.class,0); + } + public CreatedNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_createdName; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterCreatedName(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitCreatedName(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitCreatedName(this); + else return visitor.visitChildren(this); + } + } + + public final CreatedNameContext createdName() throws RecognitionException { + CreatedNameContext _localctx = new CreatedNameContext(_ctx, getState()); + enterRule(_localctx, 180, RULE_createdName); + int _la; + try { + setState(1313); + _errHandler.sync(this); + switch (_input.LA(1)) { + case IDENTIFIER: + enterOuterAlt(_localctx, 1); + { + setState(1298); + match(IDENTIFIER); + setState(1300); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LT) { + { + setState(1299); + typeArgumentsOrDiamond(); + } + } + + setState(1309); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==DOT) { + { + { + setState(1302); + match(DOT); + setState(1303); + match(IDENTIFIER); + setState(1305); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LT) { + { + setState(1304); + typeArgumentsOrDiamond(); + } + } + + } + } + setState(1311); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case SHORT: + enterOuterAlt(_localctx, 2); + { + setState(1312); + primitiveType(); + } + 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 InnerCreatorContext extends ParserRuleContext { + public TerminalNode IDENTIFIER() { return getToken(JavaParser.IDENTIFIER, 0); } + public ClassCreatorRestContext classCreatorRest() { + return getRuleContext(ClassCreatorRestContext.class,0); + } + public NonWildcardTypeArgumentsOrDiamondContext nonWildcardTypeArgumentsOrDiamond() { + return getRuleContext(NonWildcardTypeArgumentsOrDiamondContext.class,0); + } + public InnerCreatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_innerCreator; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterInnerCreator(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitInnerCreator(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitInnerCreator(this); + else return visitor.visitChildren(this); + } + } + + public final InnerCreatorContext innerCreator() throws RecognitionException { + InnerCreatorContext _localctx = new InnerCreatorContext(_ctx, getState()); + enterRule(_localctx, 182, RULE_innerCreator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1315); + match(IDENTIFIER); + setState(1317); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la==LT) { + { + setState(1316); + nonWildcardTypeArgumentsOrDiamond(); + } + } + + setState(1319); + classCreatorRest(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ArrayCreatorRestContext extends ParserRuleContext { + public List LBRACK() { return getTokens(JavaParser.LBRACK); } + public TerminalNode LBRACK(int i) { + return getToken(JavaParser.LBRACK, i); + } + public List RBRACK() { return getTokens(JavaParser.RBRACK); } + public TerminalNode RBRACK(int i) { + return getToken(JavaParser.RBRACK, i); + } + public ArrayInitializerContext arrayInitializer() { + return getRuleContext(ArrayInitializerContext.class,0); + } + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class,i); + } + public ArrayCreatorRestContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arrayCreatorRest; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterArrayCreatorRest(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitArrayCreatorRest(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitArrayCreatorRest(this); + else return visitor.visitChildren(this); + } + } + + public final ArrayCreatorRestContext arrayCreatorRest() throws RecognitionException { + ArrayCreatorRestContext _localctx = new ArrayCreatorRestContext(_ctx, getState()); + enterRule(_localctx, 184, RULE_arrayCreatorRest); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1321); + match(LBRACK); + setState(1349); + _errHandler.sync(this); + switch (_input.LA(1)) { + case RBRACK: + { + setState(1322); + match(RBRACK); + setState(1327); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==LBRACK) { + { + { + setState(1323); + match(LBRACK); + setState(1324); + match(RBRACK); + } + } + setState(1329); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1330); + arrayInitializer(); + } + break; + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case NEW: + case SHORT: + case SUPER: + case THIS: + case VOID: + case DECIMAL_LITERAL: + case HEX_LITERAL: + case OCT_LITERAL: + case BINARY_LITERAL: + case FLOAT_LITERAL: + case HEX_FLOAT_LITERAL: + case BOOL_LITERAL: + case CHAR_LITERAL: + case STRING_LITERAL: + case NULL_LITERAL: + case LPAREN: + case LT: + case BANG: + case TILDE: + case INC: + case DEC: + case ADD: + case SUB: + case AT: + case IDENTIFIER: + { + setState(1331); + expression(0); + setState(1332); + match(RBRACK); + setState(1339); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,163,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1333); + match(LBRACK); + setState(1334); + expression(0); + setState(1335); + match(RBRACK); + } + } + } + setState(1341); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,163,_ctx); + } + setState(1346); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,164,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1342); + match(LBRACK); + setState(1343); + match(RBRACK); + } + } + } + setState(1348); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,164,_ctx); + } + } + 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 ClassCreatorRestContext extends ParserRuleContext { + public ArgumentsContext arguments() { + return getRuleContext(ArgumentsContext.class,0); + } + public ClassBodyContext classBody() { + return getRuleContext(ClassBodyContext.class,0); + } + public ClassCreatorRestContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_classCreatorRest; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterClassCreatorRest(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitClassCreatorRest(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitClassCreatorRest(this); + else return visitor.visitChildren(this); + } + } + + public final ClassCreatorRestContext classCreatorRest() throws RecognitionException { + ClassCreatorRestContext _localctx = new ClassCreatorRestContext(_ctx, getState()); + enterRule(_localctx, 186, RULE_classCreatorRest); + try { + enterOuterAlt(_localctx, 1); + { + setState(1351); + arguments(); + setState(1353); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,166,_ctx) ) { + case 1: + { + setState(1352); + classBody(); + } + break; + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class ExplicitGenericInvocationContext extends ParserRuleContext { + public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() { + return getRuleContext(NonWildcardTypeArgumentsContext.class,0); + } + public ExplicitGenericInvocationSuffixContext explicitGenericInvocationSuffix() { + return getRuleContext(ExplicitGenericInvocationSuffixContext.class,0); + } + public ExplicitGenericInvocationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_explicitGenericInvocation; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterExplicitGenericInvocation(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitExplicitGenericInvocation(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitExplicitGenericInvocation(this); + else return visitor.visitChildren(this); + } + } + + public final ExplicitGenericInvocationContext explicitGenericInvocation() throws RecognitionException { + ExplicitGenericInvocationContext _localctx = new ExplicitGenericInvocationContext(_ctx, getState()); + enterRule(_localctx, 188, RULE_explicitGenericInvocation); + try { + enterOuterAlt(_localctx, 1); + { + setState(1355); + nonWildcardTypeArguments(); + setState(1356); + explicitGenericInvocationSuffix(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeArgumentsOrDiamondContext extends ParserRuleContext { + public TerminalNode LT() { return getToken(JavaParser.LT, 0); } + public TerminalNode GT() { return getToken(JavaParser.GT, 0); } + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class,0); + } + public TypeArgumentsOrDiamondContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeArgumentsOrDiamond; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterTypeArgumentsOrDiamond(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitTypeArgumentsOrDiamond(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitTypeArgumentsOrDiamond(this); + else return visitor.visitChildren(this); + } + } + + public final TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() throws RecognitionException { + TypeArgumentsOrDiamondContext _localctx = new TypeArgumentsOrDiamondContext(_ctx, getState()); + enterRule(_localctx, 190, RULE_typeArgumentsOrDiamond); + try { + setState(1361); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,167,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1358); + match(LT); + setState(1359); + match(GT); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1360); + typeArguments(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class NonWildcardTypeArgumentsOrDiamondContext extends ParserRuleContext { + public TerminalNode LT() { return getToken(JavaParser.LT, 0); } + public TerminalNode GT() { return getToken(JavaParser.GT, 0); } + public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() { + return getRuleContext(NonWildcardTypeArgumentsContext.class,0); + } + public NonWildcardTypeArgumentsOrDiamondContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_nonWildcardTypeArgumentsOrDiamond; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterNonWildcardTypeArgumentsOrDiamond(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitNonWildcardTypeArgumentsOrDiamond(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitNonWildcardTypeArgumentsOrDiamond(this); + else return visitor.visitChildren(this); + } + } + + public final NonWildcardTypeArgumentsOrDiamondContext nonWildcardTypeArgumentsOrDiamond() throws RecognitionException { + NonWildcardTypeArgumentsOrDiamondContext _localctx = new NonWildcardTypeArgumentsOrDiamondContext(_ctx, getState()); + enterRule(_localctx, 192, RULE_nonWildcardTypeArgumentsOrDiamond); + try { + setState(1366); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,168,_ctx) ) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1363); + match(LT); + setState(1364); + match(GT); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1365); + nonWildcardTypeArguments(); + } + break; + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class NonWildcardTypeArgumentsContext extends ParserRuleContext { + public TerminalNode LT() { return getToken(JavaParser.LT, 0); } + public TypeListContext typeList() { + return getRuleContext(TypeListContext.class,0); + } + public TerminalNode GT() { return getToken(JavaParser.GT, 0); } + public NonWildcardTypeArgumentsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_nonWildcardTypeArguments; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterNonWildcardTypeArguments(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitNonWildcardTypeArguments(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitNonWildcardTypeArguments(this); + else return visitor.visitChildren(this); + } + } + + public final NonWildcardTypeArgumentsContext nonWildcardTypeArguments() throws RecognitionException { + NonWildcardTypeArgumentsContext _localctx = new NonWildcardTypeArgumentsContext(_ctx, getState()); + enterRule(_localctx, 194, RULE_nonWildcardTypeArguments); + try { + enterOuterAlt(_localctx, 1); + { + setState(1368); + match(LT); + setState(1369); + typeList(); + setState(1370); + match(GT); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class TypeListContext extends ParserRuleContext { + public List typeType() { + return getRuleContexts(TypeTypeContext.class); + } + public TypeTypeContext typeType(int i) { + return getRuleContext(TypeTypeContext.class,i); + } + public List COMMA() { return getTokens(JavaParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(JavaParser.COMMA, i); + } + public TypeListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeList; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterTypeList(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitTypeList(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitTypeList(this); + else return visitor.visitChildren(this); + } + } + + public final TypeListContext typeList() throws RecognitionException { + TypeListContext _localctx = new TypeListContext(_ctx, getState()); + enterRule(_localctx, 196, RULE_typeList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1372); + typeType(); + setState(1377); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(1373); + match(COMMA); + setState(1374); + typeType(); + } + } + setState(1379); + _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 TypeTypeContext extends ParserRuleContext { + public ClassOrInterfaceTypeContext classOrInterfaceType() { + return getRuleContext(ClassOrInterfaceTypeContext.class,0); + } + public PrimitiveTypeContext primitiveType() { + return getRuleContext(PrimitiveTypeContext.class,0); + } + public List annotation() { + return getRuleContexts(AnnotationContext.class); + } + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class,i); + } + public List LBRACK() { return getTokens(JavaParser.LBRACK); } + public TerminalNode LBRACK(int i) { + return getToken(JavaParser.LBRACK, i); + } + public List RBRACK() { return getTokens(JavaParser.RBRACK); } + public TerminalNode RBRACK(int i) { + return getToken(JavaParser.RBRACK, i); + } + public TypeTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeType; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterTypeType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitTypeType(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitTypeType(this); + else return visitor.visitChildren(this); + } + } + + public final TypeTypeContext typeType() throws RecognitionException { + TypeTypeContext _localctx = new TypeTypeContext(_ctx, getState()); + enterRule(_localctx, 198, RULE_typeType); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1383); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,170,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1380); + annotation(); + } + } + } + setState(1385); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,170,_ctx); + } + setState(1388); + _errHandler.sync(this); + switch (_input.LA(1)) { + case IDENTIFIER: + { + setState(1386); + classOrInterfaceType(); + } + break; + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case SHORT: + { + setState(1387); + primitiveType(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(1400); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,173,_ctx); + while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { + if ( _alt==1 ) { + { + { + setState(1393); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==AT || _la==IDENTIFIER) { + { + { + setState(1390); + annotation(); + } + } + setState(1395); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1396); + match(LBRACK); + setState(1397); + match(RBRACK); + } + } + } + setState(1402); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input,173,_ctx); + } + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class PrimitiveTypeContext extends ParserRuleContext { + public TerminalNode BOOLEAN() { return getToken(JavaParser.BOOLEAN, 0); } + public TerminalNode CHAR() { return getToken(JavaParser.CHAR, 0); } + public TerminalNode BYTE() { return getToken(JavaParser.BYTE, 0); } + public TerminalNode SHORT() { return getToken(JavaParser.SHORT, 0); } + public TerminalNode INT() { return getToken(JavaParser.INT, 0); } + public TerminalNode LONG() { return getToken(JavaParser.LONG, 0); } + public TerminalNode FLOAT() { return getToken(JavaParser.FLOAT, 0); } + public TerminalNode DOUBLE() { return getToken(JavaParser.DOUBLE, 0); } + public PrimitiveTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_primitiveType; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterPrimitiveType(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitPrimitiveType(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitPrimitiveType(this); + else return visitor.visitChildren(this); + } + } + + public final PrimitiveTypeContext primitiveType() throws RecognitionException { + PrimitiveTypeContext _localctx = new PrimitiveTypeContext(_ctx, getState()); + enterRule(_localctx, 200, RULE_primitiveType); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1403); + _la = _input.LA(1); + if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << SHORT))) != 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 TypeArgumentsContext extends ParserRuleContext { + public TerminalNode LT() { return getToken(JavaParser.LT, 0); } + public List typeArgument() { + return getRuleContexts(TypeArgumentContext.class); + } + public TypeArgumentContext typeArgument(int i) { + return getRuleContext(TypeArgumentContext.class,i); + } + public TerminalNode GT() { return getToken(JavaParser.GT, 0); } + public List COMMA() { return getTokens(JavaParser.COMMA); } + public TerminalNode COMMA(int i) { + return getToken(JavaParser.COMMA, i); + } + public TypeArgumentsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_typeArguments; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterTypeArguments(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitTypeArguments(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitTypeArguments(this); + else return visitor.visitChildren(this); + } + } + + public final TypeArgumentsContext typeArguments() throws RecognitionException { + TypeArgumentsContext _localctx = new TypeArgumentsContext(_ctx, getState()); + enterRule(_localctx, 202, RULE_typeArguments); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1405); + match(LT); + setState(1406); + typeArgument(); + setState(1411); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la==COMMA) { + { + { + setState(1407); + match(COMMA); + setState(1408); + typeArgument(); + } + } + setState(1413); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1414); + match(GT); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + + public static class SuperSuffixContext extends ParserRuleContext { + public ArgumentsContext arguments() { + return getRuleContext(ArgumentsContext.class,0); + } + public TerminalNode DOT() { return getToken(JavaParser.DOT, 0); } + public TerminalNode IDENTIFIER() { return getToken(JavaParser.IDENTIFIER, 0); } + public SuperSuffixContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_superSuffix; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterSuperSuffix(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitSuperSuffix(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitSuperSuffix(this); + else return visitor.visitChildren(this); + } + } + + public final SuperSuffixContext superSuffix() throws RecognitionException { + SuperSuffixContext _localctx = new SuperSuffixContext(_ctx, getState()); + enterRule(_localctx, 204, RULE_superSuffix); + try { + setState(1422); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LPAREN: + enterOuterAlt(_localctx, 1); + { + setState(1416); + arguments(); + } + break; + case DOT: + enterOuterAlt(_localctx, 2); + { + setState(1417); + match(DOT); + setState(1418); + match(IDENTIFIER); + setState(1420); + _errHandler.sync(this); + switch ( getInterpreter().adaptivePredict(_input,175,_ctx) ) { + case 1: + { + setState(1419); + arguments(); + } + 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 ExplicitGenericInvocationSuffixContext extends ParserRuleContext { + public TerminalNode SUPER() { return getToken(JavaParser.SUPER, 0); } + public SuperSuffixContext superSuffix() { + return getRuleContext(SuperSuffixContext.class,0); + } + public TerminalNode IDENTIFIER() { return getToken(JavaParser.IDENTIFIER, 0); } + public ArgumentsContext arguments() { + return getRuleContext(ArgumentsContext.class,0); + } + public ExplicitGenericInvocationSuffixContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_explicitGenericInvocationSuffix; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterExplicitGenericInvocationSuffix(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitExplicitGenericInvocationSuffix(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitExplicitGenericInvocationSuffix(this); + else return visitor.visitChildren(this); + } + } + + public final ExplicitGenericInvocationSuffixContext explicitGenericInvocationSuffix() throws RecognitionException { + ExplicitGenericInvocationSuffixContext _localctx = new ExplicitGenericInvocationSuffixContext(_ctx, getState()); + enterRule(_localctx, 206, RULE_explicitGenericInvocationSuffix); + try { + setState(1428); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SUPER: + enterOuterAlt(_localctx, 1); + { + setState(1424); + match(SUPER); + setState(1425); + superSuffix(); + } + break; + case IDENTIFIER: + enterOuterAlt(_localctx, 2); + { + setState(1426); + match(IDENTIFIER); + setState(1427); + arguments(); + } + 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 ArgumentsContext extends ParserRuleContext { + public TerminalNode LPAREN() { return getToken(JavaParser.LPAREN, 0); } + public TerminalNode RPAREN() { return getToken(JavaParser.RPAREN, 0); } + public ExpressionListContext expressionList() { + return getRuleContext(ExpressionListContext.class,0); + } + public ArgumentsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_arguments; } + @Override + public void enterRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).enterArguments(this); + } + @Override + public void exitRule(ParseTreeListener listener) { + if ( listener instanceof JavaParserListener ) ((JavaParserListener)listener).exitArguments(this); + } + @Override + public T accept(ParseTreeVisitor visitor) { + if ( visitor instanceof JavaParserVisitor ) return ((JavaParserVisitor)visitor).visitArguments(this); + else return visitor.visitChildren(this); + } + } + + public final ArgumentsContext arguments() throws RecognitionException { + ArgumentsContext _localctx = new ArgumentsContext(_ctx, getState()); + enterRule(_localctx, 208, RULE_arguments); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1430); + match(LPAREN); + setState(1432); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << BOOLEAN) | (1L << BYTE) | (1L << CHAR) | (1L << DOUBLE) | (1L << FLOAT) | (1L << INT) | (1L << LONG) | (1L << NEW) | (1L << SHORT) | (1L << SUPER) | (1L << THIS) | (1L << VOID) | (1L << DECIMAL_LITERAL) | (1L << HEX_LITERAL) | (1L << OCT_LITERAL) | (1L << BINARY_LITERAL) | (1L << FLOAT_LITERAL) | (1L << HEX_FLOAT_LITERAL) | (1L << BOOL_LITERAL) | (1L << CHAR_LITERAL) | (1L << STRING_LITERAL) | (1L << NULL_LITERAL) | (1L << LPAREN))) != 0) || ((((_la - 73)) & ~0x3f) == 0 && ((1L << (_la - 73)) & ((1L << (LT - 73)) | (1L << (BANG - 73)) | (1L << (TILDE - 73)) | (1L << (INC - 73)) | (1L << (DEC - 73)) | (1L << (ADD - 73)) | (1L << (SUB - 73)) | (1L << (AT - 73)) | (1L << (IDENTIFIER - 73)))) != 0)) { + { + setState(1431); + expressionList(); + } + } + + setState(1434); + match(RPAREN); + } + } + 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 83: + return expression_sempred((ExpressionContext)_localctx, predIndex); + } + return true; + } + private boolean expression_sempred(ExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 0: + return precpred(_ctx, 17); + case 1: + return precpred(_ctx, 16); + case 2: + return precpred(_ctx, 15); + case 3: + return precpred(_ctx, 14); + case 4: + return precpred(_ctx, 12); + case 5: + return precpred(_ctx, 11); + case 6: + return precpred(_ctx, 10); + case 7: + return precpred(_ctx, 9); + case 8: + return precpred(_ctx, 8); + case 9: + return precpred(_ctx, 7); + case 10: + return precpred(_ctx, 6); + case 11: + return precpred(_ctx, 5); + case 12: + return precpred(_ctx, 25); + case 13: + return precpred(_ctx, 24); + case 14: + return precpred(_ctx, 20); + case 15: + return precpred(_ctx, 13); + case 16: + return precpred(_ctx, 3); + } + return true; + } + + public static final String _serializedATN = + "\u0004\u0001p\u059d\u0002\u0000\u0007\u0000\u0002\u0001\u0007\u0001\u0002"+ + "\u0002\u0007\u0002\u0002\u0003\u0007\u0003\u0002\u0004\u0007\u0004\u0002"+ + "\u0005\u0007\u0005\u0002\u0006\u0007\u0006\u0002\u0007\u0007\u0007\u0002"+ + "\b\u0007\b\u0002\t\u0007\t\u0002\n\u0007\n\u0002\u000b\u0007\u000b\u0002"+ + "\f\u0007\f\u0002\r\u0007\r\u0002\u000e\u0007\u000e\u0002\u000f\u0007\u000f"+ + "\u0002\u0010\u0007\u0010\u0002\u0011\u0007\u0011\u0002\u0012\u0007\u0012"+ + "\u0002\u0013\u0007\u0013\u0002\u0014\u0007\u0014\u0002\u0015\u0007\u0015"+ + "\u0002\u0016\u0007\u0016\u0002\u0017\u0007\u0017\u0002\u0018\u0007\u0018"+ + "\u0002\u0019\u0007\u0019\u0002\u001a\u0007\u001a\u0002\u001b\u0007\u001b"+ + "\u0002\u001c\u0007\u001c\u0002\u001d\u0007\u001d\u0002\u001e\u0007\u001e"+ + "\u0002\u001f\u0007\u001f\u0002 \u0007 \u0002!\u0007!\u0002\"\u0007\"\u0002"+ + "#\u0007#\u0002$\u0007$\u0002%\u0007%\u0002&\u0007&\u0002\'\u0007\'\u0002"+ + "(\u0007(\u0002)\u0007)\u0002*\u0007*\u0002+\u0007+\u0002,\u0007,\u0002"+ + "-\u0007-\u0002.\u0007.\u0002/\u0007/\u00020\u00070\u00021\u00071\u0002"+ + "2\u00072\u00023\u00073\u00024\u00074\u00025\u00075\u00026\u00076\u0002"+ + "7\u00077\u00028\u00078\u00029\u00079\u0002:\u0007:\u0002;\u0007;\u0002"+ + "<\u0007<\u0002=\u0007=\u0002>\u0007>\u0002?\u0007?\u0002@\u0007@\u0002"+ + "A\u0007A\u0002B\u0007B\u0002C\u0007C\u0002D\u0007D\u0002E\u0007E\u0002"+ + "F\u0007F\u0002G\u0007G\u0002H\u0007H\u0002I\u0007I\u0002J\u0007J\u0002"+ + "K\u0007K\u0002L\u0007L\u0002M\u0007M\u0002N\u0007N\u0002O\u0007O\u0002"+ + "P\u0007P\u0002Q\u0007Q\u0002R\u0007R\u0002S\u0007S\u0002T\u0007T\u0002"+ + "U\u0007U\u0002V\u0007V\u0002W\u0007W\u0002X\u0007X\u0002Y\u0007Y\u0002"+ + "Z\u0007Z\u0002[\u0007[\u0002\\\u0007\\\u0002]\u0007]\u0002^\u0007^\u0002"+ + "_\u0007_\u0002`\u0007`\u0002a\u0007a\u0002b\u0007b\u0002c\u0007c\u0002"+ + "d\u0007d\u0002e\u0007e\u0002f\u0007f\u0002g\u0007g\u0002h\u0007h\u0001"+ + "\u0000\u0003\u0000\u00d4\b\u0000\u0001\u0000\u0005\u0000\u00d7\b\u0000"+ + "\n\u0000\f\u0000\u00da\t\u0000\u0001\u0000\u0005\u0000\u00dd\b\u0000\n"+ + "\u0000\f\u0000\u00e0\t\u0000\u0001\u0000\u0001\u0000\u0001\u0001\u0005"+ + "\u0001\u00e5\b\u0001\n\u0001\f\u0001\u00e8\t\u0001\u0001\u0001\u0001\u0001"+ + "\u0001\u0001\u0001\u0001\u0001\u0002\u0001\u0002\u0003\u0002\u00f0\b\u0002"+ + "\u0001\u0002\u0001\u0002\u0001\u0002\u0003\u0002\u00f5\b\u0002\u0001\u0002"+ + "\u0001\u0002\u0001\u0003\u0005\u0003\u00fa\b\u0003\n\u0003\f\u0003\u00fd"+ + "\t\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0001\u0003\u0003\u0003\u0103"+ + "\b\u0003\u0001\u0003\u0003\u0003\u0106\b\u0003\u0001\u0004\u0001\u0004"+ + "\u0001\u0004\u0001\u0004\u0001\u0004\u0003\u0004\u010d\b\u0004\u0001\u0005"+ + "\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005\u0001\u0005"+ + "\u0001\u0005\u0003\u0005\u0117\b\u0005\u0001\u0006\u0001\u0006\u0003\u0006"+ + "\u011b\b\u0006\u0001\u0007\u0001\u0007\u0001\u0007\u0003\u0007\u0120\b"+ + "\u0007\u0001\u0007\u0001\u0007\u0003\u0007\u0124\b\u0007\u0001\u0007\u0001"+ + "\u0007\u0003\u0007\u0128\b\u0007\u0001\u0007\u0001\u0007\u0001\b\u0001"+ + "\b\u0001\b\u0001\b\u0005\b\u0130\b\b\n\b\f\b\u0133\t\b\u0001\b\u0001\b"+ + "\u0001\t\u0005\t\u0138\b\t\n\t\f\t\u013b\t\t\u0001\t\u0001\t\u0001\t\u0005"+ + "\t\u0140\b\t\n\t\f\t\u0143\t\t\u0001\t\u0003\t\u0146\b\t\u0001\n\u0001"+ + "\n\u0001\n\u0005\n\u014b\b\n\n\n\f\n\u014e\t\n\u0001\u000b\u0001\u000b"+ + "\u0001\u000b\u0001\u000b\u0003\u000b\u0154\b\u000b\u0001\u000b\u0001\u000b"+ + "\u0003\u000b\u0158\b\u000b\u0001\u000b\u0003\u000b\u015b\b\u000b\u0001"+ + "\u000b\u0003\u000b\u015e\b\u000b\u0001\u000b\u0001\u000b\u0001\f\u0001"+ + "\f\u0001\f\u0005\f\u0165\b\f\n\f\f\f\u0168\t\f\u0001\r\u0005\r\u016b\b"+ + "\r\n\r\f\r\u016e\t\r\u0001\r\u0001\r\u0003\r\u0172\b\r\u0001\r\u0003\r"+ + "\u0175\b\r\u0001\u000e\u0001\u000e\u0005\u000e\u0179\b\u000e\n\u000e\f"+ + "\u000e\u017c\t\u000e\u0001\u000f\u0001\u000f\u0001\u000f\u0003\u000f\u0181"+ + "\b\u000f\u0001\u000f\u0001\u000f\u0003\u000f\u0185\b\u000f\u0001\u000f"+ + "\u0001\u000f\u0001\u0010\u0001\u0010\u0005\u0010\u018b\b\u0010\n\u0010"+ + "\f\u0010\u018e\t\u0010\u0001\u0010\u0001\u0010\u0001\u0011\u0001\u0011"+ + "\u0005\u0011\u0194\b\u0011\n\u0011\f\u0011\u0197\t\u0011\u0001\u0011\u0001"+ + "\u0011\u0001\u0012\u0001\u0012\u0003\u0012\u019d\b\u0012\u0001\u0012\u0001"+ + "\u0012\u0005\u0012\u01a1\b\u0012\n\u0012\f\u0012\u01a4\t\u0012\u0001\u0012"+ + "\u0003\u0012\u01a7\b\u0012\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013"+ + "\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0001\u0013\u0003\u0013"+ + "\u01b2\b\u0013\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014\u0001\u0014"+ + "\u0005\u0014\u01b9\b\u0014\n\u0014\f\u0014\u01bc\t\u0014\u0001\u0014\u0001"+ + "\u0014\u0003\u0014\u01c0\b\u0014\u0001\u0014\u0001\u0014\u0001\u0015\u0001"+ + "\u0015\u0003\u0015\u01c6\b\u0015\u0001\u0016\u0001\u0016\u0003\u0016\u01ca"+ + "\b\u0016\u0001\u0017\u0001\u0017\u0001\u0017\u0001\u0018\u0001\u0018\u0001"+ + "\u0018\u0001\u0019\u0001\u0019\u0001\u0019\u0001\u0019\u0003\u0019\u01d6"+ + "\b\u0019\u0001\u0019\u0001\u0019\u0001\u001a\u0001\u001a\u0001\u001a\u0001"+ + "\u001a\u0001\u001b\u0005\u001b\u01df\b\u001b\n\u001b\f\u001b\u01e2\t\u001b"+ + "\u0001\u001b\u0001\u001b\u0003\u001b\u01e6\b\u001b\u0001\u001c\u0001\u001c"+ + "\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0001\u001c\u0003\u001c"+ + "\u01ef\b\u001c\u0001\u001d\u0001\u001d\u0001\u001d\u0001\u001d\u0005\u001d"+ + "\u01f5\b\u001d\n\u001d\f\u001d\u01f8\t\u001d\u0001\u001d\u0001\u001d\u0001"+ + "\u001e\u0001\u001e\u0001\u001e\u0005\u001e\u01ff\b\u001e\n\u001e\f\u001e"+ + "\u0202\t\u001e\u0001\u001e\u0001\u001e\u0001\u001e\u0001\u001f\u0005\u001f"+ + "\u0208\b\u001f\n\u001f\f\u001f\u020b\t\u001f\u0001\u001f\u0001\u001f\u0001"+ + "\u001f\u0005\u001f\u0210\b\u001f\n\u001f\f\u001f\u0213\t\u001f\u0001\u001f"+ + "\u0001\u001f\u0003\u001f\u0217\b\u001f\u0001\u001f\u0001\u001f\u0001\u001f"+ + "\u0001\u001f\u0005\u001f\u021d\b\u001f\n\u001f\f\u001f\u0220\t\u001f\u0001"+ + "\u001f\u0001\u001f\u0003\u001f\u0224\b\u001f\u0001\u001f\u0001\u001f\u0001"+ + " \u0001 \u0001 \u0001 \u0001 \u0001 \u0003 \u022e\b \u0001!\u0001!\u0001"+ + "!\u0001\"\u0001\"\u0001\"\u0005\"\u0236\b\"\n\"\f\"\u0239\t\"\u0001#\u0001"+ + "#\u0001#\u0003#\u023e\b#\u0001$\u0001$\u0001$\u0005$\u0243\b$\n$\f$\u0246"+ + "\t$\u0001%\u0001%\u0003%\u024a\b%\u0001&\u0001&\u0001&\u0001&\u0005&\u0250"+ + "\b&\n&\f&\u0253\t&\u0001&\u0003&\u0256\b&\u0003&\u0258\b&\u0001&\u0001"+ + "&\u0001\'\u0001\'\u0003\'\u025e\b\'\u0001\'\u0001\'\u0001\'\u0003\'\u0263"+ + "\b\'\u0005\'\u0265\b\'\n\'\f\'\u0268\t\'\u0001(\u0001(\u0005(\u026c\b"+ + "(\n(\f(\u026f\t(\u0001(\u0001(\u0001(\u0003(\u0274\b(\u0003(\u0276\b("+ + "\u0001)\u0001)\u0001)\u0005)\u027b\b)\n)\f)\u027e\t)\u0001*\u0001*\u0003"+ + "*\u0282\b*\u0001*\u0001*\u0001+\u0001+\u0001+\u0005+\u0289\b+\n+\f+\u028c"+ + "\t+\u0001+\u0001+\u0003+\u0290\b+\u0001+\u0003+\u0293\b+\u0001,\u0005"+ + ",\u0296\b,\n,\f,\u0299\t,\u0001,\u0001,\u0001,\u0001-\u0005-\u029f\b-"+ + "\n-\f-\u02a2\t-\u0001-\u0001-\u0005-\u02a6\b-\n-\f-\u02a9\t-\u0001-\u0001"+ + "-\u0001-\u0001.\u0001.\u0001.\u0005.\u02b1\b.\n.\f.\u02b4\t.\u0001/\u0001"+ + "/\u0001/\u0001/\u0001/\u0001/\u0003/\u02bc\b/\u00010\u00010\u00011\u0001"+ + "1\u00012\u00012\u00052\u02c4\b2\n2\f2\u02c7\t2\u00012\u00012\u00012\u0001"+ + "3\u00013\u00013\u00033\u02cf\b3\u00013\u00013\u00013\u00033\u02d4\b3\u0001"+ + "3\u00033\u02d7\b3\u00014\u00014\u00014\u00054\u02dc\b4\n4\f4\u02df\t4"+ + "\u00015\u00015\u00015\u00015\u00016\u00016\u00016\u00036\u02e8\b6\u0001"+ + "7\u00017\u00017\u00017\u00057\u02ee\b7\n7\f7\u02f1\t7\u00037\u02f3\b7"+ + "\u00017\u00037\u02f6\b7\u00017\u00017\u00018\u00018\u00018\u00018\u0001"+ + "8\u00019\u00019\u00059\u0301\b9\n9\f9\u0304\t9\u00019\u00019\u0001:\u0005"+ + ":\u0309\b:\n:\f:\u030c\t:\u0001:\u0001:\u0003:\u0310\b:\u0001;\u0001;"+ + "\u0001;\u0001;\u0001;\u0001;\u0003;\u0318\b;\u0001;\u0001;\u0003;\u031c"+ + "\b;\u0001;\u0001;\u0003;\u0320\b;\u0001;\u0001;\u0003;\u0324\b;\u0003"+ + ";\u0326\b;\u0001<\u0001<\u0003<\u032a\b<\u0001=\u0001=\u0001=\u0001=\u0003"+ + "=\u0330\b=\u0001>\u0001>\u0001?\u0001?\u0001?\u0001@\u0001@\u0005@\u0339"+ + "\b@\n@\f@\u033c\t@\u0001@\u0001@\u0001A\u0001A\u0001A\u0001A\u0001A\u0003"+ + "A\u0345\bA\u0001B\u0005B\u0348\bB\nB\fB\u034b\tB\u0001B\u0001B\u0001B"+ + "\u0001C\u0005C\u0351\bC\nC\fC\u0354\tC\u0001C\u0001C\u0003C\u0358\bC\u0001"+ + "C\u0003C\u035b\bC\u0001D\u0001D\u0001D\u0001D\u0001D\u0003D\u0362\bD\u0001"+ + "D\u0001D\u0001D\u0001D\u0001D\u0001D\u0001D\u0003D\u036b\bD\u0001D\u0001"+ + "D\u0001D\u0001D\u0001D\u0001D\u0001D\u0001D\u0001D\u0001D\u0001D\u0001"+ + "D\u0001D\u0001D\u0001D\u0001D\u0001D\u0001D\u0001D\u0004D\u0380\bD\u000b"+ + "D\fD\u0381\u0001D\u0003D\u0385\bD\u0001D\u0003D\u0388\bD\u0001D\u0001"+ + "D\u0001D\u0001D\u0005D\u038e\bD\nD\fD\u0391\tD\u0001D\u0003D\u0394\bD"+ + "\u0001D\u0001D\u0001D\u0001D\u0005D\u039a\bD\nD\fD\u039d\tD\u0001D\u0005"+ + "D\u03a0\bD\nD\fD\u03a3\tD\u0001D\u0001D\u0001D\u0001D\u0001D\u0001D\u0001"+ + "D\u0001D\u0003D\u03ad\bD\u0001D\u0001D\u0001D\u0001D\u0001D\u0001D\u0001"+ + "D\u0003D\u03b6\bD\u0001D\u0001D\u0001D\u0003D\u03bb\bD\u0001D\u0001D\u0001"+ + "D\u0001D\u0001D\u0001D\u0001D\u0001D\u0003D\u03c5\bD\u0001E\u0001E\u0001"+ + "E\u0005E\u03ca\bE\nE\fE\u03cd\tE\u0001E\u0001E\u0001E\u0001E\u0001E\u0001"+ + "F\u0001F\u0001F\u0005F\u03d7\bF\nF\fF\u03da\tF\u0001G\u0001G\u0001G\u0001"+ + "H\u0001H\u0001H\u0003H\u03e2\bH\u0001H\u0001H\u0001I\u0001I\u0001I\u0005"+ + "I\u03e9\bI\nI\fI\u03ec\tI\u0001J\u0005J\u03ef\bJ\nJ\fJ\u03f2\tJ\u0001"+ + "J\u0001J\u0001J\u0001J\u0001J\u0001K\u0004K\u03fa\bK\u000bK\fK\u03fb\u0001"+ + "K\u0004K\u03ff\bK\u000bK\fK\u0400\u0001L\u0001L\u0001L\u0003L\u0406\b"+ + "L\u0001L\u0001L\u0001L\u0003L\u040b\bL\u0001M\u0001M\u0003M\u040f\bM\u0001"+ + "M\u0001M\u0003M\u0413\bM\u0001M\u0001M\u0003M\u0417\bM\u0003M\u0419\b"+ + "M\u0001N\u0001N\u0003N\u041d\bN\u0001O\u0005O\u0420\bO\nO\fO\u0423\tO"+ + "\u0001O\u0001O\u0001O\u0001O\u0001O\u0001P\u0001P\u0001P\u0001P\u0001"+ + "Q\u0001Q\u0001Q\u0005Q\u0431\bQ\nQ\fQ\u0434\tQ\u0001R\u0001R\u0001R\u0003"+ + "R\u0439\bR\u0001R\u0001R\u0001R\u0001R\u0003R\u043f\bR\u0001R\u0001R\u0001"+ + "R\u0001R\u0003R\u0445\bR\u0001R\u0003R\u0448\bR\u0001S\u0001S\u0001S\u0001"+ + "S\u0001S\u0001S\u0001S\u0005S\u0451\bS\nS\fS\u0454\tS\u0001S\u0001S\u0001"+ + "S\u0005S\u0459\bS\nS\fS\u045c\tS\u0001S\u0001S\u0001S\u0001S\u0001S\u0001"+ + "S\u0001S\u0001S\u0001S\u0001S\u0001S\u0003S\u0469\bS\u0001S\u0001S\u0003"+ + "S\u046d\bS\u0001S\u0001S\u0001S\u0003S\u0472\bS\u0001S\u0001S\u0003S\u0476"+ + "\bS\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001"+ + "S\u0001S\u0001S\u0001S\u0001S\u0003S\u0486\bS\u0001S\u0001S\u0001S\u0001"+ + "S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001"+ + "S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001"+ + "S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001"+ + "S\u0001S\u0001S\u0001S\u0001S\u0003S\u04ae\bS\u0001S\u0001S\u0001S\u0001"+ + "S\u0003S\u04b4\bS\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001S\u0001"+ + "S\u0001S\u0001S\u0001S\u0001S\u0001S\u0003S\u04c3\bS\u0001S\u0005S\u04c6"+ + "\bS\nS\fS\u04c9\tS\u0001T\u0001T\u0001T\u0001T\u0001U\u0001U\u0001U\u0003"+ + "U\u04d2\bU\u0001U\u0001U\u0001U\u0001U\u0001U\u0005U\u04d9\bU\nU\fU\u04dc"+ + "\tU\u0001U\u0003U\u04df\bU\u0001V\u0001V\u0003V\u04e3\bV\u0001W\u0001"+ + "W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001W\u0001"+ + "W\u0001W\u0001W\u0001W\u0001W\u0003W\u04f5\bW\u0003W\u04f7\bW\u0001X\u0001"+ + "X\u0001X\u0003X\u04fc\bX\u0001X\u0005X\u04ff\bX\nX\fX\u0502\tX\u0001X"+ + "\u0001X\u0003X\u0506\bX\u0001Y\u0001Y\u0001Y\u0001Y\u0001Y\u0001Y\u0001"+ + "Y\u0003Y\u050f\bY\u0003Y\u0511\bY\u0001Z\u0001Z\u0003Z\u0515\bZ\u0001"+ + "Z\u0001Z\u0001Z\u0003Z\u051a\bZ\u0005Z\u051c\bZ\nZ\fZ\u051f\tZ\u0001Z"+ + "\u0003Z\u0522\bZ\u0001[\u0001[\u0003[\u0526\b[\u0001[\u0001[\u0001\\\u0001"+ + "\\\u0001\\\u0001\\\u0005\\\u052e\b\\\n\\\f\\\u0531\t\\\u0001\\\u0001\\"+ + "\u0001\\\u0001\\\u0001\\\u0001\\\u0001\\\u0005\\\u053a\b\\\n\\\f\\\u053d"+ + "\t\\\u0001\\\u0001\\\u0005\\\u0541\b\\\n\\\f\\\u0544\t\\\u0003\\\u0546"+ + "\b\\\u0001]\u0001]\u0003]\u054a\b]\u0001^\u0001^\u0001^\u0001_\u0001_"+ + "\u0001_\u0003_\u0552\b_\u0001`\u0001`\u0001`\u0003`\u0557\b`\u0001a\u0001"+ + "a\u0001a\u0001a\u0001b\u0001b\u0001b\u0005b\u0560\bb\nb\fb\u0563\tb\u0001"+ + "c\u0005c\u0566\bc\nc\fc\u0569\tc\u0001c\u0001c\u0003c\u056d\bc\u0001c"+ + "\u0005c\u0570\bc\nc\fc\u0573\tc\u0001c\u0001c\u0005c\u0577\bc\nc\fc\u057a"+ + "\tc\u0001d\u0001d\u0001e\u0001e\u0001e\u0001e\u0005e\u0582\be\ne\fe\u0585"+ + "\te\u0001e\u0001e\u0001f\u0001f\u0001f\u0001f\u0003f\u058d\bf\u0003f\u058f"+ + "\bf\u0001g\u0001g\u0001g\u0001g\u0003g\u0595\bg\u0001h\u0001h\u0003h\u0599"+ + "\bh\u0001h\u0001h\u0001h\u0000\u0001\u00a6i\u0000\u0002\u0004\u0006\b"+ + "\n\f\u000e\u0010\u0012\u0014\u0016\u0018\u001a\u001c\u001e \"$&(*,.02"+ + "468:<>@BDFHJLNPRTVXZ\\^`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"+ + "\u0000\f\u0002\u0000\u0011\u0011((\u0001\u000047\u0001\u000089\u0001\u0000"+ + "TW\u0001\u0000JK\u0002\u0000XY]]\u0001\u0000VW\u0002\u0000HIOP\u0002\u0000"+ + "NNQQ\u0002\u0000GG^h\u0001\u0000TU\b\u0000\u0003\u0003\u0005\u0005\b\b"+ + "\u000e\u000e\u0014\u0014\u001b\u001b\u001d\u001d%%\u063d\u0000\u00d3\u0001"+ + "\u0000\u0000\u0000\u0002\u00e6\u0001\u0000\u0000\u0000\u0004\u00ed\u0001"+ + "\u0000\u0000\u0000\u0006\u0105\u0001\u0000\u0000\u0000\b\u010c\u0001\u0000"+ + "\u0000\u0000\n\u0116\u0001\u0000\u0000\u0000\f\u011a\u0001\u0000\u0000"+ + "\u0000\u000e\u011c\u0001\u0000\u0000\u0000\u0010\u012b\u0001\u0000\u0000"+ + "\u0000\u0012\u0139\u0001\u0000\u0000\u0000\u0014\u0147\u0001\u0000\u0000"+ + "\u0000\u0016\u014f\u0001\u0000\u0000\u0000\u0018\u0161\u0001\u0000\u0000"+ + "\u0000\u001a\u016c\u0001\u0000\u0000\u0000\u001c\u0176\u0001\u0000\u0000"+ + "\u0000\u001e\u017d\u0001\u0000\u0000\u0000 \u0188\u0001\u0000\u0000\u0000"+ + "\"\u0191\u0001\u0000\u0000\u0000$\u01a6\u0001\u0000\u0000\u0000&\u01b1"+ + "\u0001\u0000\u0000\u0000(\u01b3\u0001\u0000\u0000\u0000*\u01c5\u0001\u0000"+ + "\u0000\u0000,\u01c9\u0001\u0000\u0000\u0000.\u01cb\u0001\u0000\u0000\u0000"+ + "0\u01ce\u0001\u0000\u0000\u00002\u01d1\u0001\u0000\u0000\u00004\u01d9"+ + "\u0001\u0000\u0000\u00006\u01e5\u0001\u0000\u0000\u00008\u01ee\u0001\u0000"+ + "\u0000\u0000:\u01f0\u0001\u0000\u0000\u0000<\u01fb\u0001\u0000\u0000\u0000"+ + ">\u0209\u0001\u0000\u0000\u0000@\u022d\u0001\u0000\u0000\u0000B\u022f"+ + "\u0001\u0000\u0000\u0000D\u0232\u0001\u0000\u0000\u0000F\u023a\u0001\u0000"+ + "\u0000\u0000H\u023f\u0001\u0000\u0000\u0000J\u0249\u0001\u0000\u0000\u0000"+ + "L\u024b\u0001\u0000\u0000\u0000N\u025b\u0001\u0000\u0000\u0000P\u0275"+ + "\u0001\u0000\u0000\u0000R\u0277\u0001\u0000\u0000\u0000T\u027f\u0001\u0000"+ + "\u0000\u0000V\u0292\u0001\u0000\u0000\u0000X\u0297\u0001\u0000\u0000\u0000"+ + "Z\u02a0\u0001\u0000\u0000\u0000\\\u02ad\u0001\u0000\u0000\u0000^\u02bb"+ + "\u0001\u0000\u0000\u0000`\u02bd\u0001\u0000\u0000\u0000b\u02bf\u0001\u0000"+ + "\u0000\u0000d\u02c5\u0001\u0000\u0000\u0000f\u02ce\u0001\u0000\u0000\u0000"+ + "h\u02d8\u0001\u0000\u0000\u0000j\u02e0\u0001\u0000\u0000\u0000l\u02e7"+ + "\u0001\u0000\u0000\u0000n\u02e9\u0001\u0000\u0000\u0000p\u02f9\u0001\u0000"+ + "\u0000\u0000r\u02fe\u0001\u0000\u0000\u0000t\u030f\u0001\u0000\u0000\u0000"+ + "v\u0325\u0001\u0000\u0000\u0000x\u0329\u0001\u0000\u0000\u0000z\u032b"+ + "\u0001\u0000\u0000\u0000|\u0331\u0001\u0000\u0000\u0000~\u0333\u0001\u0000"+ + "\u0000\u0000\u0080\u0336\u0001\u0000\u0000\u0000\u0082\u0344\u0001\u0000"+ + "\u0000\u0000\u0084\u0349\u0001\u0000\u0000\u0000\u0086\u035a\u0001\u0000"+ + "\u0000\u0000\u0088\u03c4\u0001\u0000\u0000\u0000\u008a\u03c6\u0001\u0000"+ + "\u0000\u0000\u008c\u03d3\u0001\u0000\u0000\u0000\u008e\u03db\u0001\u0000"+ + "\u0000\u0000\u0090\u03de\u0001\u0000\u0000\u0000\u0092\u03e5\u0001\u0000"+ + "\u0000\u0000\u0094\u03f0\u0001\u0000\u0000\u0000\u0096\u03f9\u0001\u0000"+ + "\u0000\u0000\u0098\u040a\u0001\u0000\u0000\u0000\u009a\u0418\u0001\u0000"+ + "\u0000\u0000\u009c\u041c\u0001\u0000\u0000\u0000\u009e\u0421\u0001\u0000"+ + "\u0000\u0000\u00a0\u0429\u0001\u0000\u0000\u0000\u00a2\u042d\u0001\u0000"+ + "\u0000\u0000\u00a4\u0447\u0001\u0000\u0000\u0000\u00a6\u0475\u0001\u0000"+ + "\u0000\u0000\u00a8\u04ca\u0001\u0000\u0000\u0000\u00aa\u04de\u0001\u0000"+ + "\u0000\u0000\u00ac\u04e2\u0001\u0000\u0000\u0000\u00ae\u04f6\u0001\u0000"+ + "\u0000\u0000\u00b0\u04fb\u0001\u0000\u0000\u0000\u00b2\u0510\u0001\u0000"+ + "\u0000\u0000\u00b4\u0521\u0001\u0000\u0000\u0000\u00b6\u0523\u0001\u0000"+ + "\u0000\u0000\u00b8\u0529\u0001\u0000\u0000\u0000\u00ba\u0547\u0001\u0000"+ + "\u0000\u0000\u00bc\u054b\u0001\u0000\u0000\u0000\u00be\u0551\u0001\u0000"+ + "\u0000\u0000\u00c0\u0556\u0001\u0000\u0000\u0000\u00c2\u0558\u0001\u0000"+ + "\u0000\u0000\u00c4\u055c\u0001\u0000\u0000\u0000\u00c6\u0567\u0001\u0000"+ + "\u0000\u0000\u00c8\u057b\u0001\u0000\u0000\u0000\u00ca\u057d\u0001\u0000"+ + "\u0000\u0000\u00cc\u058e\u0001\u0000\u0000\u0000\u00ce\u0594\u0001\u0000"+ + "\u0000\u0000\u00d0\u0596\u0001\u0000\u0000\u0000\u00d2\u00d4\u0003\u0002"+ + "\u0001\u0000\u00d3\u00d2\u0001\u0000\u0000\u0000\u00d3\u00d4\u0001\u0000"+ + "\u0000\u0000\u00d4\u00d8\u0001\u0000\u0000\u0000\u00d5\u00d7\u0003\u0004"+ + "\u0002\u0000\u00d6\u00d5\u0001\u0000\u0000\u0000\u00d7\u00da\u0001\u0000"+ + "\u0000\u0000\u00d8\u00d6\u0001\u0000\u0000\u0000\u00d8\u00d9\u0001\u0000"+ + "\u0000\u0000\u00d9\u00de\u0001\u0000\u0000\u0000\u00da\u00d8\u0001\u0000"+ + "\u0000\u0000\u00db\u00dd\u0003\u0006\u0003\u0000\u00dc\u00db\u0001\u0000"+ + "\u0000\u0000\u00dd\u00e0\u0001\u0000\u0000\u0000\u00de\u00dc\u0001\u0000"+ + "\u0000\u0000\u00de\u00df\u0001\u0000\u0000\u0000\u00df\u00e1\u0001\u0000"+ + "\u0000\u0000\u00e0\u00de\u0001\u0000\u0000\u0000\u00e1\u00e2\u0005\u0000"+ + "\u0000\u0001\u00e2\u0001\u0001\u0000\u0000\u0000\u00e3\u00e5\u0003f3\u0000"+ + "\u00e4\u00e3\u0001\u0000\u0000\u0000\u00e5\u00e8\u0001\u0000\u0000\u0000"+ + "\u00e6\u00e4\u0001\u0000\u0000\u0000\u00e6\u00e7\u0001\u0000\u0000\u0000"+ + "\u00e7\u00e9\u0001\u0000\u0000\u0000\u00e8\u00e6\u0001\u0000\u0000\u0000"+ + "\u00e9\u00ea\u0005 \u0000\u0000\u00ea\u00eb\u0003\\.\u0000\u00eb\u00ec"+ + "\u0005D\u0000\u0000\u00ec\u0003\u0001\u0000\u0000\u0000\u00ed\u00ef\u0005"+ + "\u0019\u0000\u0000\u00ee\u00f0\u0005&\u0000\u0000\u00ef\u00ee\u0001\u0000"+ + "\u0000\u0000\u00ef\u00f0\u0001\u0000\u0000\u0000\u00f0\u00f1\u0001\u0000"+ + "\u0000\u0000\u00f1\u00f4\u0003\\.\u0000\u00f2\u00f3\u0005F\u0000\u0000"+ + "\u00f3\u00f5\u0005X\u0000\u0000\u00f4\u00f2\u0001\u0000\u0000\u0000\u00f4"+ + "\u00f5\u0001\u0000\u0000\u0000\u00f5\u00f6\u0001\u0000\u0000\u0000\u00f6"+ + "\u00f7\u0005D\u0000\u0000\u00f7\u0005\u0001\u0000\u0000\u0000\u00f8\u00fa"+ + "\u0003\n\u0005\u0000\u00f9\u00f8\u0001\u0000\u0000\u0000\u00fa\u00fd\u0001"+ + "\u0000\u0000\u0000\u00fb\u00f9\u0001\u0000\u0000\u0000\u00fb\u00fc\u0001"+ + "\u0000\u0000\u0000\u00fc\u0102\u0001\u0000\u0000\u0000\u00fd\u00fb\u0001"+ + "\u0000\u0000\u0000\u00fe\u0103\u0003\u000e\u0007\u0000\u00ff\u0103\u0003"+ + "\u0016\u000b\u0000\u0100\u0103\u0003\u001e\u000f\u0000\u0101\u0103\u0003"+ + "p8\u0000\u0102\u00fe\u0001\u0000\u0000\u0000\u0102\u00ff\u0001\u0000\u0000"+ + "\u0000\u0102\u0100\u0001\u0000\u0000\u0000\u0102\u0101\u0001\u0000\u0000"+ + "\u0000\u0103\u0106\u0001\u0000\u0000\u0000\u0104\u0106\u0005D\u0000\u0000"+ + "\u0105\u00fb\u0001\u0000\u0000\u0000\u0105\u0104\u0001\u0000\u0000\u0000"+ + "\u0106\u0007\u0001\u0000\u0000\u0000\u0107\u010d\u0003\n\u0005\u0000\u0108"+ + "\u010d\u0005\u001e\u0000\u0000\u0109\u010d\u0005*\u0000\u0000\u010a\u010d"+ + "\u0005.\u0000\u0000\u010b\u010d\u00052\u0000\u0000\u010c\u0107\u0001\u0000"+ + "\u0000\u0000\u010c\u0108\u0001\u0000\u0000\u0000\u010c\u0109\u0001\u0000"+ + "\u0000\u0000\u010c\u010a\u0001\u0000\u0000\u0000\u010c\u010b\u0001\u0000"+ + "\u0000\u0000\u010d\t\u0001\u0000\u0000\u0000\u010e\u0117\u0003f3\u0000"+ + "\u010f\u0117\u0005#\u0000\u0000\u0110\u0117\u0005\"\u0000\u0000\u0111"+ + "\u0117\u0005!\u0000\u0000\u0112\u0117\u0005&\u0000\u0000\u0113\u0117\u0005"+ + "\u0001\u0000\u0000\u0114\u0117\u0005\u0012\u0000\u0000\u0115\u0117\u0005"+ + "\'\u0000\u0000\u0116\u010e\u0001\u0000\u0000\u0000\u0116\u010f\u0001\u0000"+ + "\u0000\u0000\u0116\u0110\u0001\u0000\u0000\u0000\u0116\u0111\u0001\u0000"+ + "\u0000\u0000\u0116\u0112\u0001\u0000\u0000\u0000\u0116\u0113\u0001\u0000"+ + "\u0000\u0000\u0116\u0114\u0001\u0000\u0000\u0000\u0116\u0115\u0001\u0000"+ + "\u0000\u0000\u0117\u000b\u0001\u0000\u0000\u0000\u0118\u011b\u0005\u0012"+ + "\u0000\u0000\u0119\u011b\u0003f3\u0000\u011a\u0118\u0001\u0000\u0000\u0000"+ + "\u011a\u0119\u0001\u0000\u0000\u0000\u011b\r\u0001\u0000\u0000\u0000\u011c"+ + "\u011d\u0005\t\u0000\u0000\u011d\u011f\u0005p\u0000\u0000\u011e\u0120"+ + "\u0003\u0010\b\u0000\u011f\u011e\u0001\u0000\u0000\u0000\u011f\u0120\u0001"+ + "\u0000\u0000\u0000\u0120\u0123\u0001\u0000\u0000\u0000\u0121\u0122\u0005"+ + "\u0011\u0000\u0000\u0122\u0124\u0003\u00c6c\u0000\u0123\u0121\u0001\u0000"+ + "\u0000\u0000\u0123\u0124\u0001\u0000\u0000\u0000\u0124\u0127\u0001\u0000"+ + "\u0000\u0000\u0125\u0126\u0005\u0018\u0000\u0000\u0126\u0128\u0003\u00c4"+ + "b\u0000\u0127\u0125\u0001\u0000\u0000\u0000\u0127\u0128\u0001\u0000\u0000"+ + "\u0000\u0128\u0129\u0001\u0000\u0000\u0000\u0129\u012a\u0003 \u0010\u0000"+ + "\u012a\u000f\u0001\u0000\u0000\u0000\u012b\u012c\u0005I\u0000\u0000\u012c"+ + "\u0131\u0003\u0012\t\u0000\u012d\u012e\u0005E\u0000\u0000\u012e\u0130"+ + "\u0003\u0012\t\u0000\u012f\u012d\u0001\u0000\u0000\u0000\u0130\u0133\u0001"+ + "\u0000\u0000\u0000\u0131\u012f\u0001\u0000\u0000\u0000\u0131\u0132\u0001"+ + "\u0000\u0000\u0000\u0132\u0134\u0001\u0000\u0000\u0000\u0133\u0131\u0001"+ + "\u0000\u0000\u0000\u0134\u0135\u0005H\u0000\u0000\u0135\u0011\u0001\u0000"+ + "\u0000\u0000\u0136\u0138\u0003f3\u0000\u0137\u0136\u0001\u0000\u0000\u0000"+ + "\u0138\u013b\u0001\u0000\u0000\u0000\u0139\u0137\u0001\u0000\u0000\u0000"+ + "\u0139\u013a\u0001\u0000\u0000\u0000\u013a\u013c\u0001\u0000\u0000\u0000"+ + "\u013b\u0139\u0001\u0000\u0000\u0000\u013c\u0145\u0005p\u0000\u0000\u013d"+ + "\u0141\u0005\u0011\u0000\u0000\u013e\u0140\u0003f3\u0000\u013f\u013e\u0001"+ + "\u0000\u0000\u0000\u0140\u0143\u0001\u0000\u0000\u0000\u0141\u013f\u0001"+ + "\u0000\u0000\u0000\u0141\u0142\u0001\u0000\u0000\u0000\u0142\u0144\u0001"+ + "\u0000\u0000\u0000\u0143\u0141\u0001\u0000\u0000\u0000\u0144\u0146\u0003"+ + "\u0014\n\u0000\u0145\u013d\u0001\u0000\u0000\u0000\u0145\u0146\u0001\u0000"+ + "\u0000\u0000\u0146\u0013\u0001\u0000\u0000\u0000\u0147\u014c\u0003\u00c6"+ + "c\u0000\u0148\u0149\u0005Z\u0000\u0000\u0149\u014b\u0003\u00c6c\u0000"+ + "\u014a\u0148\u0001\u0000\u0000\u0000\u014b\u014e\u0001\u0000\u0000\u0000"+ + "\u014c\u014a\u0001\u0000\u0000\u0000\u014c\u014d\u0001\u0000\u0000\u0000"+ + "\u014d\u0015\u0001\u0000\u0000\u0000\u014e\u014c\u0001\u0000\u0000\u0000"+ + "\u014f\u0150\u0005\u0010\u0000\u0000\u0150\u0153\u0005p\u0000\u0000\u0151"+ + "\u0152\u0005\u0018\u0000\u0000\u0152\u0154\u0003\u00c4b\u0000\u0153\u0151"+ + "\u0001\u0000\u0000\u0000\u0153\u0154\u0001\u0000\u0000\u0000\u0154\u0155"+ + "\u0001\u0000\u0000\u0000\u0155\u0157\u0005@\u0000\u0000\u0156\u0158\u0003"+ + "\u0018\f\u0000\u0157\u0156\u0001\u0000\u0000\u0000\u0157\u0158\u0001\u0000"+ + "\u0000\u0000\u0158\u015a\u0001\u0000\u0000\u0000\u0159\u015b\u0005E\u0000"+ + "\u0000\u015a\u0159\u0001\u0000\u0000\u0000\u015a\u015b\u0001\u0000\u0000"+ + "\u0000\u015b\u015d\u0001\u0000\u0000\u0000\u015c\u015e\u0003\u001c\u000e"+ + "\u0000\u015d\u015c\u0001\u0000\u0000\u0000\u015d\u015e\u0001\u0000\u0000"+ + "\u0000\u015e\u015f\u0001\u0000\u0000\u0000\u015f\u0160\u0005A\u0000\u0000"+ + "\u0160\u0017\u0001\u0000\u0000\u0000\u0161\u0166\u0003\u001a\r\u0000\u0162"+ + "\u0163\u0005E\u0000\u0000\u0163\u0165\u0003\u001a\r\u0000\u0164\u0162"+ + "\u0001\u0000\u0000\u0000\u0165\u0168\u0001\u0000\u0000\u0000\u0166\u0164"+ + "\u0001\u0000\u0000\u0000\u0166\u0167\u0001\u0000\u0000\u0000\u0167\u0019"+ + "\u0001\u0000\u0000\u0000\u0168\u0166\u0001\u0000\u0000\u0000\u0169\u016b"+ + "\u0003f3\u0000\u016a\u0169\u0001\u0000\u0000\u0000\u016b\u016e\u0001\u0000"+ + "\u0000\u0000\u016c\u016a\u0001\u0000\u0000\u0000\u016c\u016d\u0001\u0000"+ + "\u0000\u0000\u016d\u016f\u0001\u0000\u0000\u0000\u016e\u016c\u0001\u0000"+ + "\u0000\u0000\u016f\u0171\u0005p\u0000\u0000\u0170\u0172\u0003\u00d0h\u0000"+ + "\u0171\u0170\u0001\u0000\u0000\u0000\u0171\u0172\u0001\u0000\u0000\u0000"+ + "\u0172\u0174\u0001\u0000\u0000\u0000\u0173\u0175\u0003 \u0010\u0000\u0174"+ + "\u0173\u0001\u0000\u0000\u0000\u0174\u0175\u0001\u0000\u0000\u0000\u0175"+ + "\u001b\u0001\u0000\u0000\u0000\u0176\u017a\u0005D\u0000\u0000\u0177\u0179"+ + "\u0003$\u0012\u0000\u0178\u0177\u0001\u0000\u0000\u0000\u0179\u017c\u0001"+ + "\u0000\u0000\u0000\u017a\u0178\u0001\u0000\u0000\u0000\u017a\u017b\u0001"+ + "\u0000\u0000\u0000\u017b\u001d\u0001\u0000\u0000\u0000\u017c\u017a\u0001"+ + "\u0000\u0000\u0000\u017d\u017e\u0005\u001c\u0000\u0000\u017e\u0180\u0005"+ + "p\u0000\u0000\u017f\u0181\u0003\u0010\b\u0000\u0180\u017f\u0001\u0000"+ + "\u0000\u0000\u0180\u0181\u0001\u0000\u0000\u0000\u0181\u0184\u0001\u0000"+ + "\u0000\u0000\u0182\u0183\u0005\u0011\u0000\u0000\u0183\u0185\u0003\u00c4"+ + "b\u0000\u0184\u0182\u0001\u0000\u0000\u0000\u0184\u0185\u0001\u0000\u0000"+ + "\u0000\u0185\u0186\u0001\u0000\u0000\u0000\u0186\u0187\u0003\"\u0011\u0000"+ + "\u0187\u001f\u0001\u0000\u0000\u0000\u0188\u018c\u0005@\u0000\u0000\u0189"+ + "\u018b\u0003$\u0012\u0000\u018a\u0189\u0001\u0000\u0000\u0000\u018b\u018e"+ + "\u0001\u0000\u0000\u0000\u018c\u018a\u0001\u0000\u0000\u0000\u018c\u018d"+ + "\u0001\u0000\u0000\u0000\u018d\u018f\u0001\u0000\u0000\u0000\u018e\u018c"+ + "\u0001\u0000\u0000\u0000\u018f\u0190\u0005A\u0000\u0000\u0190!\u0001\u0000"+ + "\u0000\u0000\u0191\u0195\u0005@\u0000\u0000\u0192\u0194\u00036\u001b\u0000"+ + "\u0193\u0192\u0001\u0000\u0000\u0000\u0194\u0197\u0001\u0000\u0000\u0000"+ + "\u0195\u0193\u0001\u0000\u0000\u0000\u0195\u0196\u0001\u0000\u0000\u0000"+ + "\u0196\u0198\u0001\u0000\u0000\u0000\u0197\u0195\u0001\u0000\u0000\u0000"+ + "\u0198\u0199\u0005A\u0000\u0000\u0199#\u0001\u0000\u0000\u0000\u019a\u01a7"+ + "\u0005D\u0000\u0000\u019b\u019d\u0005&\u0000\u0000\u019c\u019b\u0001\u0000"+ + "\u0000\u0000\u019c\u019d\u0001\u0000\u0000\u0000\u019d\u019e\u0001\u0000"+ + "\u0000\u0000\u019e\u01a7\u0003\u0080@\u0000\u019f\u01a1\u0003\b\u0004"+ + "\u0000\u01a0\u019f\u0001\u0000\u0000\u0000\u01a1\u01a4\u0001\u0000\u0000"+ + "\u0000\u01a2\u01a0\u0001\u0000\u0000\u0000\u01a2\u01a3\u0001\u0000\u0000"+ + "\u0000\u01a3\u01a5\u0001\u0000\u0000\u0000\u01a4\u01a2\u0001\u0000\u0000"+ + "\u0000\u01a5\u01a7\u0003&\u0013\u0000\u01a6\u019a\u0001\u0000\u0000\u0000"+ + "\u01a6\u019c\u0001\u0000\u0000\u0000\u01a6\u01a2\u0001\u0000\u0000\u0000"+ + "\u01a7%\u0001\u0000\u0000\u0000\u01a8\u01b2\u0003(\u0014\u0000\u01a9\u01b2"+ + "\u0003.\u0017\u0000\u01aa\u01b2\u00034\u001a\u0000\u01ab\u01b2\u00032"+ + "\u0019\u0000\u01ac\u01b2\u00030\u0018\u0000\u01ad\u01b2\u0003\u001e\u000f"+ + "\u0000\u01ae\u01b2\u0003p8\u0000\u01af\u01b2\u0003\u000e\u0007\u0000\u01b0"+ + "\u01b2\u0003\u0016\u000b\u0000\u01b1\u01a8\u0001\u0000\u0000\u0000\u01b1"+ + "\u01a9\u0001\u0000\u0000\u0000\u01b1\u01aa\u0001\u0000\u0000\u0000\u01b1"+ + "\u01ab\u0001\u0000\u0000\u0000\u01b1\u01ac\u0001\u0000\u0000\u0000\u01b1"+ + "\u01ad\u0001\u0000\u0000\u0000\u01b1\u01ae\u0001\u0000\u0000\u0000\u01b1"+ + "\u01af\u0001\u0000\u0000\u0000\u01b1\u01b0\u0001\u0000\u0000\u0000\u01b2"+ + "\'\u0001\u0000\u0000\u0000\u01b3\u01b4\u0003,\u0016\u0000\u01b4\u01b5"+ + "\u0005p\u0000\u0000\u01b5\u01ba\u0003T*\u0000\u01b6\u01b7\u0005B\u0000"+ + "\u0000\u01b7\u01b9\u0005C\u0000\u0000\u01b8\u01b6\u0001\u0000\u0000\u0000"+ + "\u01b9\u01bc\u0001\u0000\u0000\u0000\u01ba\u01b8\u0001\u0000\u0000\u0000"+ + "\u01ba\u01bb\u0001\u0000\u0000\u0000\u01bb\u01bf\u0001\u0000\u0000\u0000"+ + "\u01bc\u01ba\u0001\u0000\u0000\u0000\u01bd\u01be\u0005-\u0000\u0000\u01be"+ + "\u01c0\u0003R)\u0000\u01bf\u01bd\u0001\u0000\u0000\u0000\u01bf\u01c0\u0001"+ + "\u0000\u0000\u0000\u01c0\u01c1\u0001\u0000\u0000\u0000\u01c1\u01c2\u0003"+ + "*\u0015\u0000\u01c2)\u0001\u0000\u0000\u0000\u01c3\u01c6\u0003\u0080@"+ + "\u0000\u01c4\u01c6\u0005D\u0000\u0000\u01c5\u01c3\u0001\u0000\u0000\u0000"+ + "\u01c5\u01c4\u0001\u0000\u0000\u0000\u01c6+\u0001\u0000\u0000\u0000\u01c7"+ + "\u01ca\u0003\u00c6c\u0000\u01c8\u01ca\u00051\u0000\u0000\u01c9\u01c7\u0001"+ + "\u0000\u0000\u0000\u01c9\u01c8\u0001\u0000\u0000\u0000\u01ca-\u0001\u0000"+ + "\u0000\u0000\u01cb\u01cc\u0003\u0010\b\u0000\u01cc\u01cd\u0003(\u0014"+ + "\u0000\u01cd/\u0001\u0000\u0000\u0000\u01ce\u01cf\u0003\u0010\b\u0000"+ + "\u01cf\u01d0\u00032\u0019\u0000\u01d01\u0001\u0000\u0000\u0000\u01d1\u01d2"+ + "\u0005p\u0000\u0000\u01d2\u01d5\u0003T*\u0000\u01d3\u01d4\u0005-\u0000"+ + "\u0000\u01d4\u01d6\u0003R)\u0000\u01d5\u01d3\u0001\u0000\u0000\u0000\u01d5"+ + "\u01d6\u0001\u0000\u0000\u0000\u01d6\u01d7\u0001\u0000\u0000\u0000\u01d7"+ + "\u01d8\u0003\u0080@\u0000\u01d83\u0001\u0000\u0000\u0000\u01d9\u01da\u0003"+ + "\u00c6c\u0000\u01da\u01db\u0003D\"\u0000\u01db\u01dc\u0005D\u0000\u0000"+ + "\u01dc5\u0001\u0000\u0000\u0000\u01dd\u01df\u0003\b\u0004\u0000\u01de"+ + "\u01dd\u0001\u0000\u0000\u0000\u01df\u01e2\u0001\u0000\u0000\u0000\u01e0"+ + "\u01de\u0001\u0000\u0000\u0000\u01e0\u01e1\u0001\u0000\u0000\u0000\u01e1"+ + "\u01e3\u0001\u0000\u0000\u0000\u01e2\u01e0\u0001\u0000\u0000\u0000\u01e3"+ + "\u01e6\u00038\u001c\u0000\u01e4\u01e6\u0005D\u0000\u0000\u01e5\u01e0\u0001"+ + "\u0000\u0000\u0000\u01e5\u01e4\u0001\u0000\u0000\u0000\u01e67\u0001\u0000"+ + "\u0000\u0000\u01e7\u01ef\u0003:\u001d\u0000\u01e8\u01ef\u0003>\u001f\u0000"+ + "\u01e9\u01ef\u0003B!\u0000\u01ea\u01ef\u0003\u001e\u000f\u0000\u01eb\u01ef"+ + "\u0003p8\u0000\u01ec\u01ef\u0003\u000e\u0007\u0000\u01ed\u01ef\u0003\u0016"+ + "\u000b\u0000\u01ee\u01e7\u0001\u0000\u0000\u0000\u01ee\u01e8\u0001\u0000"+ + "\u0000\u0000\u01ee\u01e9\u0001\u0000\u0000\u0000\u01ee\u01ea\u0001\u0000"+ + "\u0000\u0000\u01ee\u01eb\u0001\u0000\u0000\u0000\u01ee\u01ec\u0001\u0000"+ + "\u0000\u0000\u01ee\u01ed\u0001\u0000\u0000\u0000\u01ef9\u0001\u0000\u0000"+ + "\u0000\u01f0\u01f1\u0003\u00c6c\u0000\u01f1\u01f6\u0003<\u001e\u0000\u01f2"+ + "\u01f3\u0005E\u0000\u0000\u01f3\u01f5\u0003<\u001e\u0000\u01f4\u01f2\u0001"+ + "\u0000\u0000\u0000\u01f5\u01f8\u0001\u0000\u0000\u0000\u01f6\u01f4\u0001"+ + "\u0000\u0000\u0000\u01f6\u01f7\u0001\u0000\u0000\u0000\u01f7\u01f9\u0001"+ + "\u0000\u0000\u0000\u01f8\u01f6\u0001\u0000\u0000\u0000\u01f9\u01fa\u0005"+ + "D\u0000\u0000\u01fa;\u0001\u0000\u0000\u0000\u01fb\u0200\u0005p\u0000"+ + "\u0000\u01fc\u01fd\u0005B\u0000\u0000\u01fd\u01ff\u0005C\u0000\u0000\u01fe"+ + "\u01fc\u0001\u0000\u0000\u0000\u01ff\u0202\u0001\u0000\u0000\u0000\u0200"+ + "\u01fe\u0001\u0000\u0000\u0000\u0200\u0201\u0001\u0000\u0000\u0000\u0201"+ + "\u0203\u0001\u0000\u0000\u0000\u0202\u0200\u0001\u0000\u0000\u0000\u0203"+ + "\u0204\u0005G\u0000\u0000\u0204\u0205\u0003J%\u0000\u0205=\u0001\u0000"+ + "\u0000\u0000\u0206\u0208\u0003@ \u0000\u0207\u0206\u0001\u0000\u0000\u0000"+ + "\u0208\u020b\u0001\u0000\u0000\u0000\u0209\u0207\u0001\u0000\u0000\u0000"+ + "\u0209\u020a\u0001\u0000\u0000\u0000\u020a\u0216\u0001\u0000\u0000\u0000"+ + "\u020b\u0209\u0001\u0000\u0000\u0000\u020c\u0217\u0003,\u0016\u0000\u020d"+ + "\u0211\u0003\u0010\b\u0000\u020e\u0210\u0003f3\u0000\u020f\u020e\u0001"+ + "\u0000\u0000\u0000\u0210\u0213\u0001\u0000\u0000\u0000\u0211\u020f\u0001"+ + "\u0000\u0000\u0000\u0211\u0212\u0001\u0000\u0000\u0000\u0212\u0214\u0001"+ + "\u0000\u0000\u0000\u0213\u0211\u0001\u0000\u0000\u0000\u0214\u0215\u0003"+ + ",\u0016\u0000\u0215\u0217\u0001\u0000\u0000\u0000\u0216\u020c\u0001\u0000"+ + "\u0000\u0000\u0216\u020d\u0001\u0000\u0000\u0000\u0217\u0218\u0001\u0000"+ + "\u0000\u0000\u0218\u0219\u0005p\u0000\u0000\u0219\u021e\u0003T*\u0000"+ + "\u021a\u021b\u0005B\u0000\u0000\u021b\u021d\u0005C\u0000\u0000\u021c\u021a"+ + "\u0001\u0000\u0000\u0000\u021d\u0220\u0001\u0000\u0000\u0000\u021e\u021c"+ + "\u0001\u0000\u0000\u0000\u021e\u021f\u0001\u0000\u0000\u0000\u021f\u0223"+ + "\u0001\u0000\u0000\u0000\u0220\u021e\u0001\u0000\u0000\u0000\u0221\u0222"+ + "\u0005-\u0000\u0000\u0222\u0224\u0003R)\u0000\u0223\u0221\u0001\u0000"+ + "\u0000\u0000\u0223\u0224\u0001\u0000\u0000\u0000\u0224\u0225\u0001\u0000"+ + "\u0000\u0000\u0225\u0226\u0003*\u0015\u0000\u0226?\u0001\u0000\u0000\u0000"+ + "\u0227\u022e\u0003f3\u0000\u0228\u022e\u0005#\u0000\u0000\u0229\u022e"+ + "\u0005\u0001\u0000\u0000\u022a\u022e\u0005\f\u0000\u0000\u022b\u022e\u0005"+ + "&\u0000\u0000\u022c\u022e\u0005\'\u0000\u0000\u022d\u0227\u0001\u0000"+ + "\u0000\u0000\u022d\u0228\u0001\u0000\u0000\u0000\u022d\u0229\u0001\u0000"+ + "\u0000\u0000\u022d\u022a\u0001\u0000\u0000\u0000\u022d\u022b\u0001\u0000"+ + "\u0000\u0000\u022d\u022c\u0001\u0000\u0000\u0000\u022eA\u0001\u0000\u0000"+ + "\u0000\u022f\u0230\u0003\u0010\b\u0000\u0230\u0231\u0003>\u001f\u0000"+ + "\u0231C\u0001\u0000\u0000\u0000\u0232\u0237\u0003F#\u0000\u0233\u0234"+ + "\u0005E\u0000\u0000\u0234\u0236\u0003F#\u0000\u0235\u0233\u0001\u0000"+ + "\u0000\u0000\u0236\u0239\u0001\u0000\u0000\u0000\u0237\u0235\u0001\u0000"+ + "\u0000\u0000\u0237\u0238\u0001\u0000\u0000\u0000\u0238E\u0001\u0000\u0000"+ + "\u0000\u0239\u0237\u0001\u0000\u0000\u0000\u023a\u023d\u0003H$\u0000\u023b"+ + "\u023c\u0005G\u0000\u0000\u023c\u023e\u0003J%\u0000\u023d\u023b\u0001"+ + "\u0000\u0000\u0000\u023d\u023e\u0001\u0000\u0000\u0000\u023eG\u0001\u0000"+ + "\u0000\u0000\u023f\u0244\u0005p\u0000\u0000\u0240\u0241\u0005B\u0000\u0000"+ + "\u0241\u0243\u0005C\u0000\u0000\u0242\u0240\u0001\u0000\u0000\u0000\u0243"+ + "\u0246\u0001\u0000\u0000\u0000\u0244\u0242\u0001\u0000\u0000\u0000\u0244"+ + "\u0245\u0001\u0000\u0000\u0000\u0245I\u0001\u0000\u0000\u0000\u0246\u0244"+ + "\u0001\u0000\u0000\u0000\u0247\u024a\u0003L&\u0000\u0248\u024a\u0003\u00a6"+ + "S\u0000\u0249\u0247\u0001\u0000\u0000\u0000\u0249\u0248\u0001\u0000\u0000"+ + "\u0000\u024aK\u0001\u0000\u0000\u0000\u024b\u0257\u0005@\u0000\u0000\u024c"+ + "\u0251\u0003J%\u0000\u024d\u024e\u0005E\u0000\u0000\u024e\u0250\u0003"+ + "J%\u0000\u024f\u024d\u0001\u0000\u0000\u0000\u0250\u0253\u0001\u0000\u0000"+ + "\u0000\u0251\u024f\u0001\u0000\u0000\u0000\u0251\u0252\u0001\u0000\u0000"+ + "\u0000\u0252\u0255\u0001\u0000\u0000\u0000\u0253\u0251\u0001\u0000\u0000"+ + "\u0000\u0254\u0256\u0005E\u0000\u0000\u0255\u0254\u0001\u0000\u0000\u0000"+ + "\u0255\u0256\u0001\u0000\u0000\u0000\u0256\u0258\u0001\u0000\u0000\u0000"+ + "\u0257\u024c\u0001\u0000\u0000\u0000\u0257\u0258\u0001\u0000\u0000\u0000"+ + "\u0258\u0259\u0001\u0000\u0000\u0000\u0259\u025a\u0005A\u0000\u0000\u025a"+ + "M\u0001\u0000\u0000\u0000\u025b\u025d\u0005p\u0000\u0000\u025c\u025e\u0003"+ + "\u00cae\u0000\u025d\u025c\u0001\u0000\u0000\u0000\u025d\u025e\u0001\u0000"+ + "\u0000\u0000\u025e\u0266\u0001\u0000\u0000\u0000\u025f\u0260\u0005F\u0000"+ + "\u0000\u0260\u0262\u0005p\u0000\u0000\u0261\u0263\u0003\u00cae\u0000\u0262"+ + "\u0261\u0001\u0000\u0000\u0000\u0262\u0263\u0001\u0000\u0000\u0000\u0263"+ + "\u0265\u0001\u0000\u0000\u0000\u0264\u025f\u0001\u0000\u0000\u0000\u0265"+ + "\u0268\u0001\u0000\u0000\u0000\u0266\u0264\u0001\u0000\u0000\u0000\u0266"+ + "\u0267\u0001\u0000\u0000\u0000\u0267O\u0001\u0000\u0000\u0000\u0268\u0266"+ + "\u0001\u0000\u0000\u0000\u0269\u0276\u0003\u00c6c\u0000\u026a\u026c\u0003"+ + "f3\u0000\u026b\u026a\u0001\u0000\u0000\u0000\u026c\u026f\u0001\u0000\u0000"+ + "\u0000\u026d\u026b\u0001\u0000\u0000\u0000\u026d\u026e\u0001\u0000\u0000"+ + "\u0000\u026e\u0270\u0001\u0000\u0000\u0000\u026f\u026d\u0001\u0000\u0000"+ + "\u0000\u0270\u0273\u0005L\u0000\u0000\u0271\u0272\u0007\u0000\u0000\u0000"+ + "\u0272\u0274\u0003\u00c6c\u0000\u0273\u0271\u0001\u0000\u0000\u0000\u0273"+ + "\u0274\u0001\u0000\u0000\u0000\u0274\u0276\u0001\u0000\u0000\u0000\u0275"+ + "\u0269\u0001\u0000\u0000\u0000\u0275\u026d\u0001\u0000\u0000\u0000\u0276"+ + "Q\u0001\u0000\u0000\u0000\u0277\u027c\u0003\\.\u0000\u0278\u0279\u0005"+ + "E\u0000\u0000\u0279\u027b\u0003\\.\u0000\u027a\u0278\u0001\u0000\u0000"+ + "\u0000\u027b\u027e\u0001\u0000\u0000\u0000\u027c\u027a\u0001\u0000\u0000"+ + "\u0000\u027c\u027d\u0001\u0000\u0000\u0000\u027dS\u0001\u0000\u0000\u0000"+ + "\u027e\u027c\u0001\u0000\u0000\u0000\u027f\u0281\u0005>\u0000\u0000\u0280"+ + "\u0282\u0003V+\u0000\u0281\u0280\u0001\u0000\u0000\u0000\u0281\u0282\u0001"+ + "\u0000\u0000\u0000\u0282\u0283\u0001\u0000\u0000\u0000\u0283\u0284\u0005"+ + "?\u0000\u0000\u0284U\u0001\u0000\u0000\u0000\u0285\u028a\u0003X,\u0000"+ + "\u0286\u0287\u0005E\u0000\u0000\u0287\u0289\u0003X,\u0000\u0288\u0286"+ + "\u0001\u0000\u0000\u0000\u0289\u028c\u0001\u0000\u0000\u0000\u028a\u0288"+ + "\u0001\u0000\u0000\u0000\u028a\u028b\u0001\u0000\u0000\u0000\u028b\u028f"+ + "\u0001\u0000\u0000\u0000\u028c\u028a\u0001\u0000\u0000\u0000\u028d\u028e"+ + "\u0005E\u0000\u0000\u028e\u0290\u0003Z-\u0000\u028f\u028d\u0001\u0000"+ + "\u0000\u0000\u028f\u0290\u0001\u0000\u0000\u0000\u0290\u0293\u0001\u0000"+ + "\u0000\u0000\u0291\u0293\u0003Z-\u0000\u0292\u0285\u0001\u0000\u0000\u0000"+ + "\u0292\u0291\u0001\u0000\u0000\u0000\u0293W\u0001\u0000\u0000\u0000\u0294"+ + "\u0296\u0003\f\u0006\u0000\u0295\u0294\u0001\u0000\u0000\u0000\u0296\u0299"+ + "\u0001\u0000\u0000\u0000\u0297\u0295\u0001\u0000\u0000\u0000\u0297\u0298"+ + "\u0001\u0000\u0000\u0000\u0298\u029a\u0001\u0000\u0000\u0000\u0299\u0297"+ + "\u0001\u0000\u0000\u0000\u029a\u029b\u0003\u00c6c\u0000\u029b\u029c\u0003"+ + "H$\u0000\u029cY\u0001\u0000\u0000\u0000\u029d\u029f\u0003\f\u0006\u0000"+ + "\u029e\u029d\u0001\u0000\u0000\u0000\u029f\u02a2\u0001\u0000\u0000\u0000"+ + "\u02a0\u029e\u0001\u0000\u0000\u0000\u02a0\u02a1\u0001\u0000\u0000\u0000"+ + "\u02a1\u02a3\u0001\u0000\u0000\u0000\u02a2\u02a0\u0001\u0000\u0000\u0000"+ + "\u02a3\u02a7\u0003\u00c6c\u0000\u02a4\u02a6\u0003f3\u0000\u02a5\u02a4"+ + "\u0001\u0000\u0000\u0000\u02a6\u02a9\u0001\u0000\u0000\u0000\u02a7\u02a5"+ + "\u0001\u0000\u0000\u0000\u02a7\u02a8\u0001\u0000\u0000\u0000\u02a8\u02aa"+ + "\u0001\u0000\u0000\u0000\u02a9\u02a7\u0001\u0000\u0000\u0000\u02aa\u02ab"+ + "\u0005l\u0000\u0000\u02ab\u02ac\u0003H$\u0000\u02ac[\u0001\u0000\u0000"+ + "\u0000\u02ad\u02b2\u0005p\u0000\u0000\u02ae\u02af\u0005F\u0000\u0000\u02af"+ + "\u02b1\u0005p\u0000\u0000\u02b0\u02ae\u0001\u0000\u0000\u0000\u02b1\u02b4"+ + "\u0001\u0000\u0000\u0000\u02b2\u02b0\u0001\u0000\u0000\u0000\u02b2\u02b3"+ + "\u0001\u0000\u0000\u0000\u02b3]\u0001\u0000\u0000\u0000\u02b4\u02b2\u0001"+ + "\u0000\u0000\u0000\u02b5\u02bc\u0003`0\u0000\u02b6\u02bc\u0003b1\u0000"+ + "\u02b7\u02bc\u0005;\u0000\u0000\u02b8\u02bc\u0005<\u0000\u0000\u02b9\u02bc"+ + "\u0005:\u0000\u0000\u02ba\u02bc\u0005=\u0000\u0000\u02bb\u02b5\u0001\u0000"+ + "\u0000\u0000\u02bb\u02b6\u0001\u0000\u0000\u0000\u02bb\u02b7\u0001\u0000"+ + "\u0000\u0000\u02bb\u02b8\u0001\u0000\u0000\u0000\u02bb\u02b9\u0001\u0000"+ + "\u0000\u0000\u02bb\u02ba\u0001\u0000\u0000\u0000\u02bc_\u0001\u0000\u0000"+ + "\u0000\u02bd\u02be\u0007\u0001\u0000\u0000\u02bea\u0001\u0000\u0000\u0000"+ + "\u02bf\u02c0\u0007\u0002\u0000\u0000\u02c0c\u0001\u0000\u0000\u0000\u02c1"+ + "\u02c2\u0005p\u0000\u0000\u02c2\u02c4\u0005F\u0000\u0000\u02c3\u02c1\u0001"+ + "\u0000\u0000\u0000\u02c4\u02c7\u0001\u0000\u0000\u0000\u02c5\u02c3\u0001"+ + "\u0000\u0000\u0000\u02c5\u02c6\u0001\u0000\u0000\u0000\u02c6\u02c8\u0001"+ + "\u0000\u0000\u0000\u02c7\u02c5\u0001\u0000\u0000\u0000\u02c8\u02c9\u0005"+ + "k\u0000\u0000\u02c9\u02ca\u0005p\u0000\u0000\u02cae\u0001\u0000\u0000"+ + "\u0000\u02cb\u02cc\u0005k\u0000\u0000\u02cc\u02cf\u0003\\.\u0000\u02cd"+ + "\u02cf\u0003d2\u0000\u02ce\u02cb\u0001\u0000\u0000\u0000\u02ce\u02cd\u0001"+ + "\u0000\u0000\u0000\u02cf\u02d6\u0001\u0000\u0000\u0000\u02d0\u02d3\u0005"+ + ">\u0000\u0000\u02d1\u02d4\u0003h4\u0000\u02d2\u02d4\u0003l6\u0000\u02d3"+ + "\u02d1\u0001\u0000\u0000\u0000\u02d3\u02d2\u0001\u0000\u0000\u0000\u02d3"+ + "\u02d4\u0001\u0000\u0000\u0000\u02d4\u02d5\u0001\u0000\u0000\u0000\u02d5"+ + "\u02d7\u0005?\u0000\u0000\u02d6\u02d0\u0001\u0000\u0000\u0000\u02d6\u02d7"+ + "\u0001\u0000\u0000\u0000\u02d7g\u0001\u0000\u0000\u0000\u02d8\u02dd\u0003"+ + "j5\u0000\u02d9\u02da\u0005E\u0000\u0000\u02da\u02dc\u0003j5\u0000\u02db"+ + "\u02d9\u0001\u0000\u0000\u0000\u02dc\u02df\u0001\u0000\u0000\u0000\u02dd"+ + "\u02db\u0001\u0000\u0000\u0000\u02dd\u02de\u0001\u0000\u0000\u0000\u02de"+ + "i\u0001\u0000\u0000\u0000\u02df\u02dd\u0001\u0000\u0000\u0000\u02e0\u02e1"+ + "\u0005p\u0000\u0000\u02e1\u02e2\u0005G\u0000\u0000\u02e2\u02e3\u0003l"+ + "6\u0000\u02e3k\u0001\u0000\u0000\u0000\u02e4\u02e8\u0003\u00a6S\u0000"+ + "\u02e5\u02e8\u0003f3\u0000\u02e6\u02e8\u0003n7\u0000\u02e7\u02e4\u0001"+ + "\u0000\u0000\u0000\u02e7\u02e5\u0001\u0000\u0000\u0000\u02e7\u02e6\u0001"+ + "\u0000\u0000\u0000\u02e8m\u0001\u0000\u0000\u0000\u02e9\u02f2\u0005@\u0000"+ + "\u0000\u02ea\u02ef\u0003l6\u0000\u02eb\u02ec\u0005E\u0000\u0000\u02ec"+ + "\u02ee\u0003l6\u0000\u02ed\u02eb\u0001\u0000\u0000\u0000\u02ee\u02f1\u0001"+ + "\u0000\u0000\u0000\u02ef\u02ed\u0001\u0000\u0000\u0000\u02ef\u02f0\u0001"+ + "\u0000\u0000\u0000\u02f0\u02f3\u0001\u0000\u0000\u0000\u02f1\u02ef\u0001"+ + "\u0000\u0000\u0000\u02f2\u02ea\u0001\u0000\u0000\u0000\u02f2\u02f3\u0001"+ + "\u0000\u0000\u0000\u02f3\u02f5\u0001\u0000\u0000\u0000\u02f4\u02f6\u0005"+ + "E\u0000\u0000\u02f5\u02f4\u0001\u0000\u0000\u0000\u02f5\u02f6\u0001\u0000"+ + "\u0000\u0000\u02f6\u02f7\u0001\u0000\u0000\u0000\u02f7\u02f8\u0005A\u0000"+ + "\u0000\u02f8o\u0001\u0000\u0000\u0000\u02f9\u02fa\u0005k\u0000\u0000\u02fa"+ + "\u02fb\u0005\u001c\u0000\u0000\u02fb\u02fc\u0005p\u0000\u0000\u02fc\u02fd"+ + "\u0003r9\u0000\u02fdq\u0001\u0000\u0000\u0000\u02fe\u0302\u0005@\u0000"+ + "\u0000\u02ff\u0301\u0003t:\u0000\u0300\u02ff\u0001\u0000\u0000\u0000\u0301"+ + "\u0304\u0001\u0000\u0000\u0000\u0302\u0300\u0001\u0000\u0000\u0000\u0302"+ + "\u0303\u0001\u0000\u0000\u0000\u0303\u0305\u0001\u0000\u0000\u0000\u0304"+ + "\u0302\u0001\u0000\u0000\u0000\u0305\u0306\u0005A\u0000\u0000\u0306s\u0001"+ + "\u0000\u0000\u0000\u0307\u0309\u0003\b\u0004\u0000\u0308\u0307\u0001\u0000"+ + "\u0000\u0000\u0309\u030c\u0001\u0000\u0000\u0000\u030a\u0308\u0001\u0000"+ + "\u0000\u0000\u030a\u030b\u0001\u0000\u0000\u0000\u030b\u030d\u0001\u0000"+ + "\u0000\u0000\u030c\u030a\u0001\u0000\u0000\u0000\u030d\u0310\u0003v;\u0000"+ + "\u030e\u0310\u0005D\u0000\u0000\u030f\u030a\u0001\u0000\u0000\u0000\u030f"+ + "\u030e\u0001\u0000\u0000\u0000\u0310u\u0001\u0000\u0000\u0000\u0311\u0312"+ + "\u0003\u00c6c\u0000\u0312\u0313\u0003x<\u0000\u0313\u0314\u0005D\u0000"+ + "\u0000\u0314\u0326\u0001\u0000\u0000\u0000\u0315\u0317\u0003\u000e\u0007"+ + "\u0000\u0316\u0318\u0005D\u0000\u0000\u0317\u0316\u0001\u0000\u0000\u0000"+ + "\u0317\u0318\u0001\u0000\u0000\u0000\u0318\u0326\u0001\u0000\u0000\u0000"+ + "\u0319\u031b\u0003\u001e\u000f\u0000\u031a\u031c\u0005D\u0000\u0000\u031b"+ + "\u031a\u0001\u0000\u0000\u0000\u031b\u031c\u0001\u0000\u0000\u0000\u031c"+ + "\u0326\u0001\u0000\u0000\u0000\u031d\u031f\u0003\u0016\u000b\u0000\u031e"+ + "\u0320\u0005D\u0000\u0000\u031f\u031e\u0001\u0000\u0000\u0000\u031f\u0320"+ + "\u0001\u0000\u0000\u0000\u0320\u0326\u0001\u0000\u0000\u0000\u0321\u0323"+ + "\u0003p8\u0000\u0322\u0324\u0005D\u0000\u0000\u0323\u0322\u0001\u0000"+ + "\u0000\u0000\u0323\u0324\u0001\u0000\u0000\u0000\u0324\u0326\u0001\u0000"+ + "\u0000\u0000\u0325\u0311\u0001\u0000\u0000\u0000\u0325\u0315\u0001\u0000"+ + "\u0000\u0000\u0325\u0319\u0001\u0000\u0000\u0000\u0325\u031d\u0001\u0000"+ + "\u0000\u0000\u0325\u0321\u0001\u0000\u0000\u0000\u0326w\u0001\u0000\u0000"+ + "\u0000\u0327\u032a\u0003z=\u0000\u0328\u032a\u0003|>\u0000\u0329\u0327"+ + "\u0001\u0000\u0000\u0000\u0329\u0328\u0001\u0000\u0000\u0000\u032ay\u0001"+ + "\u0000\u0000\u0000\u032b\u032c\u0005p\u0000\u0000\u032c\u032d\u0005>\u0000"+ + "\u0000\u032d\u032f\u0005?\u0000\u0000\u032e\u0330\u0003~?\u0000\u032f"+ + "\u032e\u0001\u0000\u0000\u0000\u032f\u0330\u0001\u0000\u0000\u0000\u0330"+ + "{\u0001\u0000\u0000\u0000\u0331\u0332\u0003D\"\u0000\u0332}\u0001\u0000"+ + "\u0000\u0000\u0333\u0334\u0005\f\u0000\u0000\u0334\u0335\u0003l6\u0000"+ + "\u0335\u007f\u0001\u0000\u0000\u0000\u0336\u033a\u0005@\u0000\u0000\u0337"+ + "\u0339\u0003\u0082A\u0000\u0338\u0337\u0001\u0000\u0000\u0000\u0339\u033c"+ + "\u0001\u0000\u0000\u0000\u033a\u0338\u0001\u0000\u0000\u0000\u033a\u033b"+ + "\u0001\u0000\u0000\u0000\u033b\u033d\u0001\u0000\u0000\u0000\u033c\u033a"+ + "\u0001\u0000\u0000\u0000\u033d\u033e\u0005A\u0000\u0000\u033e\u0081\u0001"+ + "\u0000\u0000\u0000\u033f\u0340\u0003\u0084B\u0000\u0340\u0341\u0005D\u0000"+ + "\u0000\u0341\u0345\u0001\u0000\u0000\u0000\u0342\u0345\u0003\u0088D\u0000"+ + "\u0343\u0345\u0003\u0086C\u0000\u0344\u033f\u0001\u0000\u0000\u0000\u0344"+ + "\u0342\u0001\u0000\u0000\u0000\u0344\u0343\u0001\u0000\u0000\u0000\u0345"+ + "\u0083\u0001\u0000\u0000\u0000\u0346\u0348\u0003\f\u0006\u0000\u0347\u0346"+ + "\u0001\u0000\u0000\u0000\u0348\u034b\u0001\u0000\u0000\u0000\u0349\u0347"+ + "\u0001\u0000\u0000\u0000\u0349\u034a\u0001\u0000\u0000\u0000\u034a\u034c"+ + "\u0001\u0000\u0000\u0000\u034b\u0349\u0001\u0000\u0000\u0000\u034c\u034d"+ + "\u0003\u00c6c\u0000\u034d\u034e\u0003D\"\u0000\u034e\u0085\u0001\u0000"+ + "\u0000\u0000\u034f\u0351\u0003\n\u0005\u0000\u0350\u034f\u0001\u0000\u0000"+ + "\u0000\u0351\u0354\u0001\u0000\u0000\u0000\u0352\u0350\u0001\u0000\u0000"+ + "\u0000\u0352\u0353\u0001\u0000\u0000\u0000\u0353\u0357\u0001\u0000\u0000"+ + "\u0000\u0354\u0352\u0001\u0000\u0000\u0000\u0355\u0358\u0003\u000e\u0007"+ + "\u0000\u0356\u0358\u0003\u001e\u000f\u0000\u0357\u0355\u0001\u0000\u0000"+ + "\u0000\u0357\u0356\u0001\u0000\u0000\u0000\u0358\u035b\u0001\u0000\u0000"+ + "\u0000\u0359\u035b\u0005D\u0000\u0000\u035a\u0352\u0001\u0000\u0000\u0000"+ + "\u035a\u0359\u0001\u0000\u0000\u0000\u035b\u0087\u0001\u0000\u0000\u0000"+ + "\u035c\u03c5\u0003\u0080@\u0000\u035d\u035e\u0005\u0002\u0000\u0000\u035e"+ + "\u0361\u0003\u00a6S\u0000\u035f\u0360\u0005M\u0000\u0000\u0360\u0362\u0003"+ + "\u00a6S\u0000\u0361\u035f\u0001\u0000\u0000\u0000\u0361\u0362\u0001\u0000"+ + "\u0000\u0000\u0362\u0363\u0001\u0000\u0000\u0000\u0363\u0364\u0005D\u0000"+ + "\u0000\u0364\u03c5\u0001\u0000\u0000\u0000\u0365\u0366\u0005\u0016\u0000"+ + "\u0000\u0366\u0367\u0003\u00a0P\u0000\u0367\u036a\u0003\u0088D\u0000\u0368"+ + "\u0369\u0005\u000f\u0000\u0000\u0369\u036b\u0003\u0088D\u0000\u036a\u0368"+ + "\u0001\u0000\u0000\u0000\u036a\u036b\u0001\u0000\u0000\u0000\u036b\u03c5"+ + "\u0001\u0000\u0000\u0000\u036c\u036d\u0005\u0015\u0000\u0000\u036d\u036e"+ + "\u0005>\u0000\u0000\u036e\u036f\u0003\u009aM\u0000\u036f\u0370\u0005?"+ + "\u0000\u0000\u0370\u0371\u0003\u0088D\u0000\u0371\u03c5\u0001\u0000\u0000"+ + "\u0000\u0372\u0373\u00053\u0000\u0000\u0373\u0374\u0003\u00a0P\u0000\u0374"+ + "\u0375\u0003\u0088D\u0000\u0375\u03c5\u0001\u0000\u0000\u0000\u0376\u0377"+ + "\u0005\r\u0000\u0000\u0377\u0378\u0003\u0088D\u0000\u0378\u0379\u0005"+ + "3\u0000\u0000\u0379\u037a\u0003\u00a0P\u0000\u037a\u037b\u0005D\u0000"+ + "\u0000\u037b\u03c5\u0001\u0000\u0000\u0000\u037c\u037d\u0005/\u0000\u0000"+ + "\u037d\u0387\u0003\u0080@\u0000\u037e\u0380\u0003\u008aE\u0000\u037f\u037e"+ + "\u0001\u0000\u0000\u0000\u0380\u0381\u0001\u0000\u0000\u0000\u0381\u037f"+ + "\u0001\u0000\u0000\u0000\u0381\u0382\u0001\u0000\u0000\u0000\u0382\u0384"+ + "\u0001\u0000\u0000\u0000\u0383\u0385\u0003\u008eG\u0000\u0384\u0383\u0001"+ + "\u0000\u0000\u0000\u0384\u0385\u0001\u0000\u0000\u0000\u0385\u0388\u0001"+ + "\u0000\u0000\u0000\u0386\u0388\u0003\u008eG\u0000\u0387\u037f\u0001\u0000"+ + "\u0000\u0000\u0387\u0386\u0001\u0000\u0000\u0000\u0388\u03c5\u0001\u0000"+ + "\u0000\u0000\u0389\u038a\u0005/\u0000\u0000\u038a\u038b\u0003\u0090H\u0000"+ + "\u038b\u038f\u0003\u0080@\u0000\u038c\u038e\u0003\u008aE\u0000\u038d\u038c"+ + "\u0001\u0000\u0000\u0000\u038e\u0391\u0001\u0000\u0000\u0000\u038f\u038d"+ + "\u0001\u0000\u0000\u0000\u038f\u0390\u0001\u0000\u0000\u0000\u0390\u0393"+ + "\u0001\u0000\u0000\u0000\u0391\u038f\u0001\u0000\u0000\u0000\u0392\u0394"+ + "\u0003\u008eG\u0000\u0393\u0392\u0001\u0000\u0000\u0000\u0393\u0394\u0001"+ + "\u0000\u0000\u0000\u0394\u03c5\u0001\u0000\u0000\u0000\u0395\u0396\u0005"+ + ")\u0000\u0000\u0396\u0397\u0003\u00a0P\u0000\u0397\u039b\u0005@\u0000"+ + "\u0000\u0398\u039a\u0003\u0096K\u0000\u0399\u0398\u0001\u0000\u0000\u0000"+ + "\u039a\u039d\u0001\u0000\u0000\u0000\u039b\u0399\u0001\u0000\u0000\u0000"+ + "\u039b\u039c\u0001\u0000\u0000\u0000\u039c\u03a1\u0001\u0000\u0000\u0000"+ + "\u039d\u039b\u0001\u0000\u0000\u0000\u039e\u03a0\u0003\u0098L\u0000\u039f"+ + "\u039e\u0001\u0000\u0000\u0000\u03a0\u03a3\u0001\u0000\u0000\u0000\u03a1"+ + "\u039f\u0001\u0000\u0000\u0000\u03a1\u03a2\u0001\u0000\u0000\u0000\u03a2"+ + "\u03a4\u0001\u0000\u0000\u0000\u03a3\u03a1\u0001\u0000\u0000\u0000\u03a4"+ + "\u03a5\u0005A\u0000\u0000\u03a5\u03c5\u0001\u0000\u0000\u0000\u03a6\u03a7"+ + "\u0005*\u0000\u0000\u03a7\u03a8\u0003\u00a0P\u0000\u03a8\u03a9\u0003\u0080"+ + "@\u0000\u03a9\u03c5\u0001\u0000\u0000\u0000\u03aa\u03ac\u0005$\u0000\u0000"+ + "\u03ab\u03ad\u0003\u00a6S\u0000\u03ac\u03ab\u0001\u0000\u0000\u0000\u03ac"+ + "\u03ad\u0001\u0000\u0000\u0000\u03ad\u03ae\u0001\u0000\u0000\u0000\u03ae"+ + "\u03c5\u0005D\u0000\u0000\u03af\u03b0\u0005,\u0000\u0000\u03b0\u03b1\u0003"+ + "\u00a6S\u0000\u03b1\u03b2\u0005D\u0000\u0000\u03b2\u03c5\u0001\u0000\u0000"+ + "\u0000\u03b3\u03b5\u0005\u0004\u0000\u0000\u03b4\u03b6\u0005p\u0000\u0000"+ + "\u03b5\u03b4\u0001\u0000\u0000\u0000\u03b5\u03b6\u0001\u0000\u0000\u0000"+ + "\u03b6\u03b7\u0001\u0000\u0000\u0000\u03b7\u03c5\u0005D\u0000\u0000\u03b8"+ + "\u03ba\u0005\u000b\u0000\u0000\u03b9\u03bb\u0005p\u0000\u0000\u03ba\u03b9"+ + "\u0001\u0000\u0000\u0000\u03ba\u03bb\u0001\u0000\u0000\u0000\u03bb\u03bc"+ + "\u0001\u0000\u0000\u0000\u03bc\u03c5\u0005D\u0000\u0000\u03bd\u03c5\u0005"+ + "D\u0000\u0000\u03be\u03bf\u0003\u00a6S\u0000\u03bf\u03c0\u0005D\u0000"+ + "\u0000\u03c0\u03c5\u0001\u0000\u0000\u0000\u03c1\u03c2\u0005p\u0000\u0000"+ + "\u03c2\u03c3\u0005M\u0000\u0000\u03c3\u03c5\u0003\u0088D\u0000\u03c4\u035c"+ + "\u0001\u0000\u0000\u0000\u03c4\u035d\u0001\u0000\u0000\u0000\u03c4\u0365"+ + "\u0001\u0000\u0000\u0000\u03c4\u036c\u0001\u0000\u0000\u0000\u03c4\u0372"+ + "\u0001\u0000\u0000\u0000\u03c4\u0376\u0001\u0000\u0000\u0000\u03c4\u037c"+ + "\u0001\u0000\u0000\u0000\u03c4\u0389\u0001\u0000\u0000\u0000\u03c4\u0395"+ + "\u0001\u0000\u0000\u0000\u03c4\u03a6\u0001\u0000\u0000\u0000\u03c4\u03aa"+ + "\u0001\u0000\u0000\u0000\u03c4\u03af\u0001\u0000\u0000\u0000\u03c4\u03b3"+ + "\u0001\u0000\u0000\u0000\u03c4\u03b8\u0001\u0000\u0000\u0000\u03c4\u03bd"+ + "\u0001\u0000\u0000\u0000\u03c4\u03be\u0001\u0000\u0000\u0000\u03c4\u03c1"+ + "\u0001\u0000\u0000\u0000\u03c5\u0089\u0001\u0000\u0000\u0000\u03c6\u03c7"+ + "\u0005\u0007\u0000\u0000\u03c7\u03cb\u0005>\u0000\u0000\u03c8\u03ca\u0003"+ + "\f\u0006\u0000\u03c9\u03c8\u0001\u0000\u0000\u0000\u03ca\u03cd\u0001\u0000"+ + "\u0000\u0000\u03cb\u03c9\u0001\u0000\u0000\u0000\u03cb\u03cc\u0001\u0000"+ + "\u0000\u0000\u03cc\u03ce\u0001\u0000\u0000\u0000\u03cd\u03cb\u0001\u0000"+ + "\u0000\u0000\u03ce\u03cf\u0003\u008cF\u0000\u03cf\u03d0\u0005p\u0000\u0000"+ + "\u03d0\u03d1\u0005?\u0000\u0000\u03d1\u03d2\u0003\u0080@\u0000\u03d2\u008b"+ + "\u0001\u0000\u0000\u0000\u03d3\u03d8\u0003\\.\u0000\u03d4\u03d5\u0005"+ + "[\u0000\u0000\u03d5\u03d7\u0003\\.\u0000\u03d6\u03d4\u0001\u0000\u0000"+ + "\u0000\u03d7\u03da\u0001\u0000\u0000\u0000\u03d8\u03d6\u0001\u0000\u0000"+ + "\u0000\u03d8\u03d9\u0001\u0000\u0000\u0000\u03d9\u008d\u0001\u0000\u0000"+ + "\u0000\u03da\u03d8\u0001\u0000\u0000\u0000\u03db\u03dc\u0005\u0013\u0000"+ + "\u0000\u03dc\u03dd\u0003\u0080@\u0000\u03dd\u008f\u0001\u0000\u0000\u0000"+ + "\u03de\u03df\u0005>\u0000\u0000\u03df\u03e1\u0003\u0092I\u0000\u03e0\u03e2"+ + "\u0005D\u0000\u0000\u03e1\u03e0\u0001\u0000\u0000\u0000\u03e1\u03e2\u0001"+ + "\u0000\u0000\u0000\u03e2\u03e3\u0001\u0000\u0000\u0000\u03e3\u03e4\u0005"+ + "?\u0000\u0000\u03e4\u0091\u0001\u0000\u0000\u0000\u03e5\u03ea\u0003\u0094"+ + "J\u0000\u03e6\u03e7\u0005D\u0000\u0000\u03e7\u03e9\u0003\u0094J\u0000"+ + "\u03e8\u03e6\u0001\u0000\u0000\u0000\u03e9\u03ec\u0001\u0000\u0000\u0000"+ + "\u03ea\u03e8\u0001\u0000\u0000\u0000\u03ea\u03eb\u0001\u0000\u0000\u0000"+ + "\u03eb\u0093\u0001\u0000\u0000\u0000\u03ec\u03ea\u0001\u0000\u0000\u0000"+ + "\u03ed\u03ef\u0003\f\u0006\u0000\u03ee\u03ed\u0001\u0000\u0000\u0000\u03ef"+ + "\u03f2\u0001\u0000\u0000\u0000\u03f0\u03ee\u0001\u0000\u0000\u0000\u03f0"+ + "\u03f1\u0001\u0000\u0000\u0000\u03f1\u03f3\u0001\u0000\u0000\u0000\u03f2"+ + "\u03f0\u0001\u0000\u0000\u0000\u03f3\u03f4\u0003N\'\u0000\u03f4\u03f5"+ + "\u0003H$\u0000\u03f5\u03f6\u0005G\u0000\u0000\u03f6\u03f7\u0003\u00a6"+ + "S\u0000\u03f7\u0095\u0001\u0000\u0000\u0000\u03f8\u03fa\u0003\u0098L\u0000"+ + "\u03f9\u03f8\u0001\u0000\u0000\u0000\u03fa\u03fb\u0001\u0000\u0000\u0000"+ + "\u03fb\u03f9\u0001\u0000\u0000\u0000\u03fb\u03fc\u0001\u0000\u0000\u0000"+ + "\u03fc\u03fe\u0001\u0000\u0000\u0000\u03fd\u03ff\u0003\u0082A\u0000\u03fe"+ + "\u03fd\u0001\u0000\u0000\u0000\u03ff\u0400\u0001\u0000\u0000\u0000\u0400"+ + "\u03fe\u0001\u0000\u0000\u0000\u0400\u0401\u0001\u0000\u0000\u0000\u0401"+ + "\u0097\u0001\u0000\u0000\u0000\u0402\u0405\u0005\u0006\u0000\u0000\u0403"+ + "\u0406\u0003\u00a6S\u0000\u0404\u0406\u0005p\u0000\u0000\u0405\u0403\u0001"+ + "\u0000\u0000\u0000\u0405\u0404\u0001\u0000\u0000\u0000\u0406\u0407\u0001"+ + "\u0000\u0000\u0000\u0407\u040b\u0005M\u0000\u0000\u0408\u0409\u0005\f"+ + "\u0000\u0000\u0409\u040b\u0005M\u0000\u0000\u040a\u0402\u0001\u0000\u0000"+ + "\u0000\u040a\u0408\u0001\u0000\u0000\u0000\u040b\u0099\u0001\u0000\u0000"+ + "\u0000\u040c\u0419\u0003\u009eO\u0000\u040d\u040f\u0003\u009cN\u0000\u040e"+ + "\u040d\u0001\u0000\u0000\u0000\u040e\u040f\u0001\u0000\u0000\u0000\u040f"+ + "\u0410\u0001\u0000\u0000\u0000\u0410\u0412\u0005D\u0000\u0000\u0411\u0413"+ + "\u0003\u00a6S\u0000\u0412\u0411\u0001\u0000\u0000\u0000\u0412\u0413\u0001"+ + "\u0000\u0000\u0000\u0413\u0414\u0001\u0000\u0000\u0000\u0414\u0416\u0005"+ + "D\u0000\u0000\u0415\u0417\u0003\u00a2Q\u0000\u0416\u0415\u0001\u0000\u0000"+ + "\u0000\u0416\u0417\u0001\u0000\u0000\u0000\u0417\u0419\u0001\u0000\u0000"+ + "\u0000\u0418\u040c\u0001\u0000\u0000\u0000\u0418\u040e\u0001\u0000\u0000"+ + "\u0000\u0419\u009b\u0001\u0000\u0000\u0000\u041a\u041d\u0003\u0084B\u0000"+ + "\u041b\u041d\u0003\u00a2Q\u0000\u041c\u041a\u0001\u0000\u0000\u0000\u041c"+ + "\u041b\u0001\u0000\u0000\u0000\u041d\u009d\u0001\u0000\u0000\u0000\u041e"+ + "\u0420\u0003\f\u0006\u0000\u041f\u041e\u0001\u0000\u0000\u0000\u0420\u0423"+ + "\u0001\u0000\u0000\u0000\u0421\u041f\u0001\u0000\u0000\u0000\u0421\u0422"+ + "\u0001\u0000\u0000\u0000\u0422\u0424\u0001\u0000\u0000\u0000\u0423\u0421"+ + "\u0001\u0000\u0000\u0000\u0424\u0425\u0003\u00c6c\u0000\u0425\u0426\u0003"+ + "H$\u0000\u0426\u0427\u0005M\u0000\u0000\u0427\u0428\u0003\u00a6S\u0000"+ + "\u0428\u009f\u0001\u0000\u0000\u0000\u0429\u042a\u0005>\u0000\u0000\u042a"+ + "\u042b\u0003\u00a6S\u0000\u042b\u042c\u0005?\u0000\u0000\u042c\u00a1\u0001"+ + "\u0000\u0000\u0000\u042d\u0432\u0003\u00a6S\u0000\u042e\u042f\u0005E\u0000"+ + "\u0000\u042f\u0431\u0003\u00a6S\u0000\u0430\u042e\u0001\u0000\u0000\u0000"+ + "\u0431\u0434\u0001\u0000\u0000\u0000\u0432\u0430\u0001\u0000\u0000\u0000"+ + "\u0432\u0433\u0001\u0000\u0000\u0000\u0433\u00a3\u0001\u0000\u0000\u0000"+ + "\u0434\u0432\u0001\u0000\u0000\u0000\u0435\u0436\u0005p\u0000\u0000\u0436"+ + "\u0438\u0005>\u0000\u0000\u0437\u0439\u0003\u00a2Q\u0000\u0438\u0437\u0001"+ + "\u0000\u0000\u0000\u0438\u0439\u0001\u0000\u0000\u0000\u0439\u043a\u0001"+ + "\u0000\u0000\u0000\u043a\u0448\u0005?\u0000\u0000\u043b\u043c\u0005+\u0000"+ + "\u0000\u043c\u043e\u0005>\u0000\u0000\u043d\u043f\u0003\u00a2Q\u0000\u043e"+ + "\u043d\u0001\u0000\u0000\u0000\u043e\u043f\u0001\u0000\u0000\u0000\u043f"+ + "\u0440\u0001\u0000\u0000\u0000\u0440\u0448\u0005?\u0000\u0000\u0441\u0442"+ + "\u0005(\u0000\u0000\u0442\u0444\u0005>\u0000\u0000\u0443\u0445\u0003\u00a2"+ + "Q\u0000\u0444\u0443\u0001\u0000\u0000\u0000\u0444\u0445\u0001\u0000\u0000"+ + "\u0000\u0445\u0446\u0001\u0000\u0000\u0000\u0446\u0448\u0005?\u0000\u0000"+ + "\u0447\u0435\u0001\u0000\u0000\u0000\u0447\u043b\u0001\u0000\u0000\u0000"+ + "\u0447\u0441\u0001\u0000\u0000\u0000\u0448\u00a5\u0001\u0000\u0000\u0000"+ + "\u0449\u044a\u0006S\uffff\uffff\u0000\u044a\u0476\u0003\u00aeW\u0000\u044b"+ + "\u0476\u0003\u00a4R\u0000\u044c\u044d\u0005\u001f\u0000\u0000\u044d\u0476"+ + "\u0003\u00b2Y\u0000\u044e\u0452\u0005>\u0000\u0000\u044f\u0451\u0003f"+ + "3\u0000\u0450\u044f\u0001\u0000\u0000\u0000\u0451\u0454\u0001\u0000\u0000"+ + "\u0000\u0452\u0450\u0001\u0000\u0000\u0000\u0452\u0453\u0001\u0000\u0000"+ + "\u0000\u0453\u0455\u0001\u0000\u0000\u0000\u0454\u0452\u0001\u0000\u0000"+ + "\u0000\u0455\u045a\u0003\u00c6c\u0000\u0456\u0457\u0005Z\u0000\u0000\u0457"+ + "\u0459\u0003\u00c6c\u0000\u0458\u0456\u0001\u0000\u0000\u0000\u0459\u045c"+ + "\u0001\u0000\u0000\u0000\u045a\u0458\u0001\u0000\u0000\u0000\u045a\u045b"+ + "\u0001\u0000\u0000\u0000\u045b\u045d\u0001\u0000\u0000\u0000\u045c\u045a"+ + "\u0001\u0000\u0000\u0000\u045d\u045e\u0005?\u0000\u0000\u045e\u045f\u0003"+ + "\u00a6S\u0015\u045f\u0476\u0001\u0000\u0000\u0000\u0460\u0461\u0007\u0003"+ + "\u0000\u0000\u0461\u0476\u0003\u00a6S\u0013\u0462\u0463\u0007\u0004\u0000"+ + "\u0000\u0463\u0476\u0003\u00a6S\u0012\u0464\u0476\u0003\u00a8T\u0000\u0465"+ + "\u0466\u0003\u00c6c\u0000\u0466\u046c\u0005j\u0000\u0000\u0467\u0469\u0003"+ + "\u00cae\u0000\u0468\u0467\u0001\u0000\u0000\u0000\u0468\u0469\u0001\u0000"+ + "\u0000\u0000\u0469\u046a\u0001\u0000\u0000\u0000\u046a\u046d\u0005p\u0000"+ + "\u0000\u046b\u046d\u0005\u001f\u0000\u0000\u046c\u0468\u0001\u0000\u0000"+ + "\u0000\u046c\u046b\u0001\u0000\u0000\u0000\u046d\u0476\u0001\u0000\u0000"+ + "\u0000\u046e\u046f\u0003\u00b0X\u0000\u046f\u0471\u0005j\u0000\u0000\u0470"+ + "\u0472\u0003\u00cae\u0000\u0471\u0470\u0001\u0000\u0000\u0000\u0471\u0472"+ + "\u0001\u0000\u0000\u0000\u0472\u0473\u0001\u0000\u0000\u0000\u0473\u0474"+ + "\u0005\u001f\u0000\u0000\u0474\u0476\u0001\u0000\u0000\u0000\u0475\u0449"+ + "\u0001\u0000\u0000\u0000\u0475\u044b\u0001\u0000\u0000\u0000\u0475\u044c"+ + "\u0001\u0000\u0000\u0000\u0475\u044e\u0001\u0000\u0000\u0000\u0475\u0460"+ + "\u0001\u0000\u0000\u0000\u0475\u0462\u0001\u0000\u0000\u0000\u0475\u0464"+ + "\u0001\u0000\u0000\u0000\u0475\u0465\u0001\u0000\u0000\u0000\u0475\u046e"+ + "\u0001\u0000\u0000\u0000\u0476\u04c7\u0001\u0000\u0000\u0000\u0477\u0478"+ + "\n\u0011\u0000\u0000\u0478\u0479\u0007\u0005\u0000\u0000\u0479\u04c6\u0003"+ + "\u00a6S\u0012\u047a\u047b\n\u0010\u0000\u0000\u047b\u047c\u0007\u0006"+ + "\u0000\u0000\u047c\u04c6\u0003\u00a6S\u0011\u047d\u0485\n\u000f\u0000"+ + "\u0000\u047e\u047f\u0005I\u0000\u0000\u047f\u0486\u0005I\u0000\u0000\u0480"+ + "\u0481\u0005H\u0000\u0000\u0481\u0482\u0005H\u0000\u0000\u0482\u0486\u0005"+ + "H\u0000\u0000\u0483\u0484\u0005H\u0000\u0000\u0484\u0486\u0005H\u0000"+ + "\u0000\u0485\u047e\u0001\u0000\u0000\u0000\u0485\u0480\u0001\u0000\u0000"+ + "\u0000\u0485\u0483\u0001\u0000\u0000\u0000\u0486\u0487\u0001\u0000\u0000"+ + "\u0000\u0487\u04c6\u0003\u00a6S\u0010\u0488\u0489\n\u000e\u0000\u0000"+ + "\u0489\u048a\u0007\u0007\u0000\u0000\u048a\u04c6\u0003\u00a6S\u000f\u048b"+ + "\u048c\n\f\u0000\u0000\u048c\u048d\u0007\b\u0000\u0000\u048d\u04c6\u0003"+ + "\u00a6S\r\u048e\u048f\n\u000b\u0000\u0000\u048f\u0490\u0005Z\u0000\u0000"+ + "\u0490\u04c6\u0003\u00a6S\f\u0491\u0492\n\n\u0000\u0000\u0492\u0493\u0005"+ + "\\\u0000\u0000\u0493\u04c6\u0003\u00a6S\u000b\u0494\u0495\n\t\u0000\u0000"+ + "\u0495\u0496\u0005[\u0000\u0000\u0496\u04c6\u0003\u00a6S\n\u0497\u0498"+ + "\n\b\u0000\u0000\u0498\u0499\u0005R\u0000\u0000\u0499\u04c6\u0003\u00a6"+ + "S\t\u049a\u049b\n\u0007\u0000\u0000\u049b\u049c\u0005S\u0000\u0000\u049c"+ + "\u04c6\u0003\u00a6S\b\u049d\u049e\n\u0006\u0000\u0000\u049e\u049f\u0005"+ + "L\u0000\u0000\u049f\u04a0\u0003\u00a6S\u0000\u04a0\u04a1\u0005M\u0000"+ + "\u0000\u04a1\u04a2\u0003\u00a6S\u0006\u04a2\u04c6\u0001\u0000\u0000\u0000"+ + "\u04a3\u04a4\n\u0005\u0000\u0000\u04a4\u04a5\u0007\t\u0000\u0000\u04a5"+ + "\u04c6\u0003\u00a6S\u0005\u04a6\u04a7\n\u0019\u0000\u0000\u04a7\u04b3"+ + "\u0005F\u0000\u0000\u04a8\u04b4\u0005p\u0000\u0000\u04a9\u04b4\u0003\u00a4"+ + "R\u0000\u04aa\u04b4\u0005+\u0000\u0000\u04ab\u04ad\u0005\u001f\u0000\u0000"+ + "\u04ac\u04ae\u0003\u00c2a\u0000\u04ad\u04ac\u0001\u0000\u0000\u0000\u04ad"+ + "\u04ae\u0001\u0000\u0000\u0000\u04ae\u04af\u0001\u0000\u0000\u0000\u04af"+ + "\u04b4\u0003\u00b6[\u0000\u04b0\u04b1\u0005(\u0000\u0000\u04b1\u04b4\u0003"+ + "\u00ccf\u0000\u04b2\u04b4\u0003\u00bc^\u0000\u04b3\u04a8\u0001\u0000\u0000"+ + "\u0000\u04b3\u04a9\u0001\u0000\u0000\u0000\u04b3\u04aa\u0001\u0000\u0000"+ + "\u0000\u04b3\u04ab\u0001\u0000\u0000\u0000\u04b3\u04b0\u0001\u0000\u0000"+ + "\u0000\u04b3\u04b2\u0001\u0000\u0000\u0000\u04b4\u04c6\u0001\u0000\u0000"+ + "\u0000\u04b5\u04b6\n\u0018\u0000\u0000\u04b6\u04b7\u0005B\u0000\u0000"+ + "\u04b7\u04b8\u0003\u00a6S\u0000\u04b8\u04b9\u0005C\u0000\u0000\u04b9\u04c6"+ + "\u0001\u0000\u0000\u0000\u04ba\u04bb\n\u0014\u0000\u0000\u04bb\u04c6\u0007"+ + "\n\u0000\u0000\u04bc\u04bd\n\r\u0000\u0000\u04bd\u04be\u0005\u001a\u0000"+ + "\u0000\u04be\u04c6\u0003\u00c6c\u0000\u04bf\u04c0\n\u0003\u0000\u0000"+ + "\u04c0\u04c2\u0005j\u0000\u0000\u04c1\u04c3\u0003\u00cae\u0000\u04c2\u04c1"+ + "\u0001\u0000\u0000\u0000\u04c2\u04c3\u0001\u0000\u0000\u0000\u04c3\u04c4"+ + "\u0001\u0000\u0000\u0000\u04c4\u04c6\u0005p\u0000\u0000\u04c5\u0477\u0001"+ + "\u0000\u0000\u0000\u04c5\u047a\u0001\u0000\u0000\u0000\u04c5\u047d\u0001"+ + "\u0000\u0000\u0000\u04c5\u0488\u0001\u0000\u0000\u0000\u04c5\u048b\u0001"+ + "\u0000\u0000\u0000\u04c5\u048e\u0001\u0000\u0000\u0000\u04c5\u0491\u0001"+ + "\u0000\u0000\u0000\u04c5\u0494\u0001\u0000\u0000\u0000\u04c5\u0497\u0001"+ + "\u0000\u0000\u0000\u04c5\u049a\u0001\u0000\u0000\u0000\u04c5\u049d\u0001"+ + "\u0000\u0000\u0000\u04c5\u04a3\u0001\u0000\u0000\u0000\u04c5\u04a6\u0001"+ + "\u0000\u0000\u0000\u04c5\u04b5\u0001\u0000\u0000\u0000\u04c5\u04ba\u0001"+ + "\u0000\u0000\u0000\u04c5\u04bc\u0001\u0000\u0000\u0000\u04c5\u04bf\u0001"+ + "\u0000\u0000\u0000\u04c6\u04c9\u0001\u0000\u0000\u0000\u04c7\u04c5\u0001"+ + "\u0000\u0000\u0000\u04c7\u04c8\u0001\u0000\u0000\u0000\u04c8\u00a7\u0001"+ + "\u0000\u0000\u0000\u04c9\u04c7\u0001\u0000\u0000\u0000\u04ca\u04cb\u0003"+ + "\u00aaU\u0000\u04cb\u04cc\u0005i\u0000\u0000\u04cc\u04cd\u0003\u00acV"+ + "\u0000\u04cd\u00a9\u0001\u0000\u0000\u0000\u04ce\u04df\u0005p\u0000\u0000"+ + "\u04cf\u04d1\u0005>\u0000\u0000\u04d0\u04d2\u0003V+\u0000\u04d1\u04d0"+ + "\u0001\u0000\u0000\u0000\u04d1\u04d2\u0001\u0000\u0000\u0000\u04d2\u04d3"+ + "\u0001\u0000\u0000\u0000\u04d3\u04df\u0005?\u0000\u0000\u04d4\u04d5\u0005"+ + ">\u0000\u0000\u04d5\u04da\u0005p\u0000\u0000\u04d6\u04d7\u0005E\u0000"+ + "\u0000\u04d7\u04d9\u0005p\u0000\u0000\u04d8\u04d6\u0001\u0000\u0000\u0000"+ + "\u04d9\u04dc\u0001\u0000\u0000\u0000\u04da\u04d8\u0001\u0000\u0000\u0000"+ + "\u04da\u04db\u0001\u0000\u0000\u0000\u04db\u04dd\u0001\u0000\u0000\u0000"+ + "\u04dc\u04da\u0001\u0000\u0000\u0000\u04dd\u04df\u0005?\u0000\u0000\u04de"+ + "\u04ce\u0001\u0000\u0000\u0000\u04de\u04cf\u0001\u0000\u0000\u0000\u04de"+ + "\u04d4\u0001\u0000\u0000\u0000\u04df\u00ab\u0001\u0000\u0000\u0000\u04e0"+ + "\u04e3\u0003\u00a6S\u0000\u04e1\u04e3\u0003\u0080@\u0000\u04e2\u04e0\u0001"+ + "\u0000\u0000\u0000\u04e2\u04e1\u0001\u0000\u0000\u0000\u04e3\u00ad\u0001"+ + "\u0000\u0000\u0000\u04e4\u04e5\u0005>\u0000\u0000\u04e5\u04e6\u0003\u00a6"+ + "S\u0000\u04e6\u04e7\u0005?\u0000\u0000\u04e7\u04f7\u0001\u0000\u0000\u0000"+ + "\u04e8\u04f7\u0005+\u0000\u0000\u04e9\u04f7\u0005(\u0000\u0000\u04ea\u04f7"+ + "\u0003^/\u0000\u04eb\u04f7\u0005p\u0000\u0000\u04ec\u04ed\u0003,\u0016"+ + "\u0000\u04ed\u04ee\u0005F\u0000\u0000\u04ee\u04ef\u0005\t\u0000\u0000"+ + "\u04ef\u04f7\u0001\u0000\u0000\u0000\u04f0\u04f4\u0003\u00c2a\u0000\u04f1"+ + "\u04f5\u0003\u00ceg\u0000\u04f2\u04f3\u0005+\u0000\u0000\u04f3\u04f5\u0003"+ + "\u00d0h\u0000\u04f4\u04f1\u0001\u0000\u0000\u0000\u04f4\u04f2\u0001\u0000"+ + "\u0000\u0000\u04f5\u04f7\u0001\u0000\u0000\u0000\u04f6\u04e4\u0001\u0000"+ + "\u0000\u0000\u04f6\u04e8\u0001\u0000\u0000\u0000\u04f6\u04e9\u0001\u0000"+ + "\u0000\u0000\u04f6\u04ea\u0001\u0000\u0000\u0000\u04f6\u04eb\u0001\u0000"+ + "\u0000\u0000\u04f6\u04ec\u0001\u0000\u0000\u0000\u04f6\u04f0\u0001\u0000"+ + "\u0000\u0000\u04f7\u00af\u0001\u0000\u0000\u0000\u04f8\u04f9\u0003N\'"+ + "\u0000\u04f9\u04fa\u0005F\u0000\u0000\u04fa\u04fc\u0001\u0000\u0000\u0000"+ + "\u04fb\u04f8\u0001\u0000\u0000\u0000\u04fb\u04fc\u0001\u0000\u0000\u0000"+ + "\u04fc\u0500\u0001\u0000\u0000\u0000\u04fd\u04ff\u0003f3\u0000\u04fe\u04fd"+ + "\u0001\u0000\u0000\u0000\u04ff\u0502\u0001\u0000\u0000\u0000\u0500\u04fe"+ + "\u0001\u0000\u0000\u0000\u0500\u0501\u0001\u0000\u0000\u0000\u0501\u0503"+ + "\u0001\u0000\u0000\u0000\u0502\u0500\u0001\u0000\u0000\u0000\u0503\u0505"+ + "\u0005p\u0000\u0000\u0504\u0506\u0003\u00cae\u0000\u0505\u0504\u0001\u0000"+ + "\u0000\u0000\u0505\u0506\u0001\u0000\u0000\u0000\u0506\u00b1\u0001\u0000"+ + "\u0000\u0000\u0507\u0508\u0003\u00c2a\u0000\u0508\u0509\u0003\u00b4Z\u0000"+ + "\u0509\u050a\u0003\u00ba]\u0000\u050a\u0511\u0001\u0000\u0000\u0000\u050b"+ + "\u050e\u0003\u00b4Z\u0000\u050c\u050f\u0003\u00b8\\\u0000\u050d\u050f"+ + "\u0003\u00ba]\u0000\u050e\u050c\u0001\u0000\u0000\u0000\u050e\u050d\u0001"+ + "\u0000\u0000\u0000\u050f\u0511\u0001\u0000\u0000\u0000\u0510\u0507\u0001"+ + "\u0000\u0000\u0000\u0510\u050b\u0001\u0000\u0000\u0000\u0511\u00b3\u0001"+ + "\u0000\u0000\u0000\u0512\u0514\u0005p\u0000\u0000\u0513\u0515\u0003\u00be"+ + "_\u0000\u0514\u0513\u0001\u0000\u0000\u0000\u0514\u0515\u0001\u0000\u0000"+ + "\u0000\u0515\u051d\u0001\u0000\u0000\u0000\u0516\u0517\u0005F\u0000\u0000"+ + "\u0517\u0519\u0005p\u0000\u0000\u0518\u051a\u0003\u00be_\u0000\u0519\u0518"+ + "\u0001\u0000\u0000\u0000\u0519\u051a\u0001\u0000\u0000\u0000\u051a\u051c"+ + "\u0001\u0000\u0000\u0000\u051b\u0516\u0001\u0000\u0000\u0000\u051c\u051f"+ + "\u0001\u0000\u0000\u0000\u051d\u051b\u0001\u0000\u0000\u0000\u051d\u051e"+ + "\u0001\u0000\u0000\u0000\u051e\u0522\u0001\u0000\u0000\u0000\u051f\u051d"+ + "\u0001\u0000\u0000\u0000\u0520\u0522\u0003\u00c8d\u0000\u0521\u0512\u0001"+ + "\u0000\u0000\u0000\u0521\u0520\u0001\u0000\u0000\u0000\u0522\u00b5\u0001"+ + "\u0000\u0000\u0000\u0523\u0525\u0005p\u0000\u0000\u0524\u0526\u0003\u00c0"+ + "`\u0000\u0525\u0524\u0001\u0000\u0000\u0000\u0525\u0526\u0001\u0000\u0000"+ + "\u0000\u0526\u0527\u0001\u0000\u0000\u0000\u0527\u0528\u0003\u00ba]\u0000"+ + "\u0528\u00b7\u0001\u0000\u0000\u0000\u0529\u0545\u0005B\u0000\u0000\u052a"+ + "\u052f\u0005C\u0000\u0000\u052b\u052c\u0005B\u0000\u0000\u052c\u052e\u0005"+ + "C\u0000\u0000\u052d\u052b\u0001\u0000\u0000\u0000\u052e\u0531\u0001\u0000"+ + "\u0000\u0000\u052f\u052d\u0001\u0000\u0000\u0000\u052f\u0530\u0001\u0000"+ + "\u0000\u0000\u0530\u0532\u0001\u0000\u0000\u0000\u0531\u052f\u0001\u0000"+ + "\u0000\u0000\u0532\u0546\u0003L&\u0000\u0533\u0534\u0003\u00a6S\u0000"+ + "\u0534\u053b\u0005C\u0000\u0000\u0535\u0536\u0005B\u0000\u0000\u0536\u0537"+ + "\u0003\u00a6S\u0000\u0537\u0538\u0005C\u0000\u0000\u0538\u053a\u0001\u0000"+ + "\u0000\u0000\u0539\u0535\u0001\u0000\u0000\u0000\u053a\u053d\u0001\u0000"+ + "\u0000\u0000\u053b\u0539\u0001\u0000\u0000\u0000\u053b\u053c\u0001\u0000"+ + "\u0000\u0000\u053c\u0542\u0001\u0000\u0000\u0000\u053d\u053b\u0001\u0000"+ + "\u0000\u0000\u053e\u053f\u0005B\u0000\u0000\u053f\u0541\u0005C\u0000\u0000"+ + "\u0540\u053e\u0001\u0000\u0000\u0000\u0541\u0544\u0001\u0000\u0000\u0000"+ + "\u0542\u0540\u0001\u0000\u0000\u0000\u0542\u0543\u0001\u0000\u0000\u0000"+ + "\u0543\u0546\u0001\u0000\u0000\u0000\u0544\u0542\u0001\u0000\u0000\u0000"+ + "\u0545\u052a\u0001\u0000\u0000\u0000\u0545\u0533\u0001\u0000\u0000\u0000"+ + "\u0546\u00b9\u0001\u0000\u0000\u0000\u0547\u0549\u0003\u00d0h\u0000\u0548"+ + "\u054a\u0003 \u0010\u0000\u0549\u0548\u0001\u0000\u0000\u0000\u0549\u054a"+ + "\u0001\u0000\u0000\u0000\u054a\u00bb\u0001\u0000\u0000\u0000\u054b\u054c"+ + "\u0003\u00c2a\u0000\u054c\u054d\u0003\u00ceg\u0000\u054d\u00bd\u0001\u0000"+ + "\u0000\u0000\u054e\u054f\u0005I\u0000\u0000\u054f\u0552\u0005H\u0000\u0000"+ + "\u0550\u0552\u0003\u00cae\u0000\u0551\u054e\u0001\u0000\u0000\u0000\u0551"+ + "\u0550\u0001\u0000\u0000\u0000\u0552\u00bf\u0001\u0000\u0000\u0000\u0553"+ + "\u0554\u0005I\u0000\u0000\u0554\u0557\u0005H\u0000\u0000\u0555\u0557\u0003"+ + "\u00c2a\u0000\u0556\u0553\u0001\u0000\u0000\u0000\u0556\u0555\u0001\u0000"+ + "\u0000\u0000\u0557\u00c1\u0001\u0000\u0000\u0000\u0558\u0559\u0005I\u0000"+ + "\u0000\u0559\u055a\u0003\u00c4b\u0000\u055a\u055b\u0005H\u0000\u0000\u055b"+ + "\u00c3\u0001\u0000\u0000\u0000\u055c\u0561\u0003\u00c6c\u0000\u055d\u055e"+ + "\u0005E\u0000\u0000\u055e\u0560\u0003\u00c6c\u0000\u055f\u055d\u0001\u0000"+ + "\u0000\u0000\u0560\u0563\u0001\u0000\u0000\u0000\u0561\u055f\u0001\u0000"+ + "\u0000\u0000\u0561\u0562\u0001\u0000\u0000\u0000\u0562\u00c5\u0001\u0000"+ + "\u0000\u0000\u0563\u0561\u0001\u0000\u0000\u0000\u0564\u0566\u0003f3\u0000"+ + "\u0565\u0564\u0001\u0000\u0000\u0000\u0566\u0569\u0001\u0000\u0000\u0000"+ + "\u0567\u0565\u0001\u0000\u0000\u0000\u0567\u0568\u0001\u0000\u0000\u0000"+ + "\u0568\u056c\u0001\u0000\u0000\u0000\u0569\u0567\u0001\u0000\u0000\u0000"+ + "\u056a\u056d\u0003N\'\u0000\u056b\u056d\u0003\u00c8d\u0000\u056c\u056a"+ + "\u0001\u0000\u0000\u0000\u056c\u056b\u0001\u0000\u0000\u0000\u056d\u0578"+ + "\u0001\u0000\u0000\u0000\u056e\u0570\u0003f3\u0000\u056f\u056e\u0001\u0000"+ + "\u0000\u0000\u0570\u0573\u0001\u0000\u0000\u0000\u0571\u056f\u0001\u0000"+ + "\u0000\u0000\u0571\u0572\u0001\u0000\u0000\u0000\u0572\u0574\u0001\u0000"+ + "\u0000\u0000\u0573\u0571\u0001\u0000\u0000\u0000\u0574\u0575\u0005B\u0000"+ + "\u0000\u0575\u0577\u0005C\u0000\u0000\u0576\u0571\u0001\u0000\u0000\u0000"+ + "\u0577\u057a\u0001\u0000\u0000\u0000\u0578\u0576\u0001\u0000\u0000\u0000"+ + "\u0578\u0579\u0001\u0000\u0000\u0000\u0579\u00c7\u0001\u0000\u0000\u0000"+ + "\u057a\u0578\u0001\u0000\u0000\u0000\u057b\u057c\u0007\u000b\u0000\u0000"+ + "\u057c\u00c9\u0001\u0000\u0000\u0000\u057d\u057e\u0005I\u0000\u0000\u057e"+ + "\u0583\u0003P(\u0000\u057f\u0580\u0005E\u0000\u0000\u0580\u0582\u0003"+ + "P(\u0000\u0581\u057f\u0001\u0000\u0000\u0000\u0582\u0585\u0001\u0000\u0000"+ + "\u0000\u0583\u0581\u0001\u0000\u0000\u0000\u0583\u0584\u0001\u0000\u0000"+ + "\u0000\u0584\u0586\u0001\u0000\u0000\u0000\u0585\u0583\u0001\u0000\u0000"+ + "\u0000\u0586\u0587\u0005H\u0000\u0000\u0587\u00cb\u0001\u0000\u0000\u0000"+ + "\u0588\u058f\u0003\u00d0h\u0000\u0589\u058a\u0005F\u0000\u0000\u058a\u058c"+ + "\u0005p\u0000\u0000\u058b\u058d\u0003\u00d0h\u0000\u058c\u058b\u0001\u0000"+ + "\u0000\u0000\u058c\u058d\u0001\u0000\u0000\u0000\u058d\u058f\u0001\u0000"+ + "\u0000\u0000\u058e\u0588\u0001\u0000\u0000\u0000\u058e\u0589\u0001\u0000"+ + "\u0000\u0000\u058f\u00cd\u0001\u0000\u0000\u0000\u0590\u0591\u0005(\u0000"+ + "\u0000\u0591\u0595\u0003\u00ccf\u0000\u0592\u0593\u0005p\u0000\u0000\u0593"+ + "\u0595\u0003\u00d0h\u0000\u0594\u0590\u0001\u0000\u0000\u0000\u0594\u0592"+ + "\u0001\u0000\u0000\u0000\u0595\u00cf\u0001\u0000\u0000\u0000\u0596\u0598"+ + "\u0005>\u0000\u0000\u0597\u0599\u0003\u00a2Q\u0000\u0598\u0597\u0001\u0000"+ + "\u0000\u0000\u0598\u0599\u0001\u0000\u0000\u0000\u0599\u059a\u0001\u0000"+ + "\u0000\u0000\u059a\u059b\u0005?\u0000\u0000\u059b\u00d1\u0001\u0000\u0000"+ + "\u0000\u00b3\u00d3\u00d8\u00de\u00e6\u00ef\u00f4\u00fb\u0102\u0105\u010c"+ + "\u0116\u011a\u011f\u0123\u0127\u0131\u0139\u0141\u0145\u014c\u0153\u0157"+ + "\u015a\u015d\u0166\u016c\u0171\u0174\u017a\u0180\u0184\u018c\u0195\u019c"+ + "\u01a2\u01a6\u01b1\u01ba\u01bf\u01c5\u01c9\u01d5\u01e0\u01e5\u01ee\u01f6"+ + "\u0200\u0209\u0211\u0216\u021e\u0223\u022d\u0237\u023d\u0244\u0249\u0251"+ + "\u0255\u0257\u025d\u0262\u0266\u026d\u0273\u0275\u027c\u0281\u028a\u028f"+ + "\u0292\u0297\u02a0\u02a7\u02b2\u02bb\u02c5\u02ce\u02d3\u02d6\u02dd\u02e7"+ + "\u02ef\u02f2\u02f5\u0302\u030a\u030f\u0317\u031b\u031f\u0323\u0325\u0329"+ + "\u032f\u033a\u0344\u0349\u0352\u0357\u035a\u0361\u036a\u0381\u0384\u0387"+ + "\u038f\u0393\u039b\u03a1\u03ac\u03b5\u03ba\u03c4\u03cb\u03d8\u03e1\u03ea"+ + "\u03f0\u03fb\u0400\u0405\u040a\u040e\u0412\u0416\u0418\u041c\u0421\u0432"+ + "\u0438\u043e\u0444\u0447\u0452\u045a\u0468\u046c\u0471\u0475\u0485\u04ad"+ + "\u04b3\u04c2\u04c5\u04c7\u04d1\u04da\u04de\u04e2\u04f4\u04f6\u04fb\u0500"+ + "\u0505\u050e\u0510\u0514\u0519\u051d\u0521\u0525\u052f\u053b\u0542\u0545"+ + "\u0549\u0551\u0556\u0561\u0567\u056c\u0571\u0578\u0583\u058c\u058e\u0594"+ + "\u0598"; + 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/gen/com/itsaky/androidide/lexers/java/JavaParser.tokens b/lexers/src/main/gen/com/itsaky/androidide/lexers/java/JavaParser.tokens new file mode 100644 index 000000000..e94649840 --- /dev/null +++ b/lexers/src/main/gen/com/itsaky/androidide/lexers/java/JavaParser.tokens @@ -0,0 +1,211 @@ +ABSTRACT=1 +ASSERT=2 +BOOLEAN=3 +BREAK=4 +BYTE=5 +CASE=6 +CATCH=7 +CHAR=8 +CLASS=9 +CONST=10 +CONTINUE=11 +DEFAULT=12 +DO=13 +DOUBLE=14 +ELSE=15 +ENUM=16 +EXTENDS=17 +FINAL=18 +FINALLY=19 +FLOAT=20 +FOR=21 +IF=22 +GOTO=23 +IMPLEMENTS=24 +IMPORT=25 +INSTANCEOF=26 +INT=27 +INTERFACE=28 +LONG=29 +NATIVE=30 +NEW=31 +PACKAGE=32 +PRIVATE=33 +PROTECTED=34 +PUBLIC=35 +RETURN=36 +SHORT=37 +STATIC=38 +STRICTFP=39 +SUPER=40 +SWITCH=41 +SYNCHRONIZED=42 +THIS=43 +THROW=44 +THROWS=45 +TRANSIENT=46 +TRY=47 +VAR=48 +VOID=49 +VOLATILE=50 +WHILE=51 +DECIMAL_LITERAL=52 +HEX_LITERAL=53 +OCT_LITERAL=54 +BINARY_LITERAL=55 +FLOAT_LITERAL=56 +HEX_FLOAT_LITERAL=57 +BOOL_LITERAL=58 +CHAR_LITERAL=59 +STRING_LITERAL=60 +NULL_LITERAL=61 +LPAREN=62 +RPAREN=63 +LBRACE=64 +RBRACE=65 +LBRACK=66 +RBRACK=67 +SEMI=68 +COMMA=69 +DOT=70 +ASSIGN=71 +GT=72 +LT=73 +BANG=74 +TILDE=75 +QUESTION=76 +COLON=77 +EQUAL=78 +LE=79 +GE=80 +NOTEQUAL=81 +AND=82 +OR=83 +INC=84 +DEC=85 +ADD=86 +SUB=87 +MUL=88 +DIV=89 +BITAND=90 +BITOR=91 +CARET=92 +MOD=93 +ADD_ASSIGN=94 +SUB_ASSIGN=95 +MUL_ASSIGN=96 +DIV_ASSIGN=97 +AND_ASSIGN=98 +OR_ASSIGN=99 +XOR_ASSIGN=100 +MOD_ASSIGN=101 +LSHIFT_ASSIGN=102 +RSHIFT_ASSIGN=103 +URSHIFT_ASSIGN=104 +ARROW=105 +COLONCOLON=106 +AT=107 +ELLIPSIS=108 +WS=109 +BLOCK_COMMENT=110 +LINE_COMMENT=111 +IDENTIFIER=112 +'abstract'=1 +'assert'=2 +'boolean'=3 +'break'=4 +'byte'=5 +'case'=6 +'catch'=7 +'char'=8 +'class'=9 +'const'=10 +'continue'=11 +'default'=12 +'do'=13 +'double'=14 +'else'=15 +'enum'=16 +'extends'=17 +'final'=18 +'finally'=19 +'float'=20 +'for'=21 +'if'=22 +'goto'=23 +'implements'=24 +'import'=25 +'instanceof'=26 +'int'=27 +'interface'=28 +'long'=29 +'native'=30 +'new'=31 +'package'=32 +'private'=33 +'protected'=34 +'public'=35 +'return'=36 +'short'=37 +'static'=38 +'strictfp'=39 +'super'=40 +'switch'=41 +'synchronized'=42 +'this'=43 +'throw'=44 +'throws'=45 +'transient'=46 +'try'=47 +'var'=48 +'void'=49 +'volatile'=50 +'while'=51 +'null'=61 +'('=62 +')'=63 +'{'=64 +'}'=65 +'['=66 +']'=67 +';'=68 +','=69 +'.'=70 +'='=71 +'>'=72 +'<'=73 +'!'=74 +'~'=75 +'?'=76 +':'=77 +'=='=78 +'<='=79 +'>='=80 +'!='=81 +'&&'=82 +'||'=83 +'++'=84 +'--'=85 +'+'=86 +'-'=87 +'*'=88 +'/'=89 +'&'=90 +'|'=91 +'^'=92 +'%'=93 +'+='=94 +'-='=95 +'*='=96 +'/='=97 +'&='=98 +'|='=99 +'^='=100 +'%='=101 +'<<='=102 +'>>='=103 +'>>>='=104 +'->'=105 +'::'=106 +'@'=107 +'...'=108 diff --git a/lexers/src/main/gen/com/itsaky/androidide/lexers/java/JavaParserBaseListener.java b/lexers/src/main/gen/com/itsaky/androidide/lexers/java/JavaParserBaseListener.java new file mode 100644 index 000000000..74ed1e54e --- /dev/null +++ b/lexers/src/main/gen/com/itsaky/androidide/lexers/java/JavaParserBaseListener.java @@ -0,0 +1,1299 @@ +// Generated from /home/itsaky/Projects/Android/AndroidIDE/lexers/src/main/java/com/itsaky/androidide/lexers/java/JavaParser.g4 by ANTLR 4.10.1 +package com.itsaky.androidide.lexers.java; + +import org.antlr.v4.runtime.ParserRuleContext; +import org.antlr.v4.runtime.tree.ErrorNode; +import org.antlr.v4.runtime.tree.TerminalNode; + +/** + * This class provides an empty implementation of {@link JavaParserListener}, + * which can be extended to create a listener which only needs to handle a subset + * of the available methods. + */ +public class JavaParserBaseListener implements JavaParserListener { + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCompilationUnit(JavaParser.CompilationUnitContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCompilationUnit(JavaParser.CompilationUnitContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPackageDeclaration(JavaParser.PackageDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPackageDeclaration(JavaParser.PackageDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterImportDeclaration(JavaParser.ImportDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitImportDeclaration(JavaParser.ImportDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTypeDeclaration(JavaParser.TypeDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTypeDeclaration(JavaParser.TypeDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterModifier(JavaParser.ModifierContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitModifier(JavaParser.ModifierContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterClassOrInterfaceModifier(JavaParser.ClassOrInterfaceModifierContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitClassOrInterfaceModifier(JavaParser.ClassOrInterfaceModifierContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterVariableModifier(JavaParser.VariableModifierContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitVariableModifier(JavaParser.VariableModifierContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterClassDeclaration(JavaParser.ClassDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitClassDeclaration(JavaParser.ClassDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTypeParameters(JavaParser.TypeParametersContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTypeParameters(JavaParser.TypeParametersContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTypeParameter(JavaParser.TypeParameterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTypeParameter(JavaParser.TypeParameterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTypeBound(JavaParser.TypeBoundContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTypeBound(JavaParser.TypeBoundContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEnumDeclaration(JavaParser.EnumDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEnumDeclaration(JavaParser.EnumDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEnumConstants(JavaParser.EnumConstantsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEnumConstants(JavaParser.EnumConstantsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEnumConstant(JavaParser.EnumConstantContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEnumConstant(JavaParser.EnumConstantContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEnumBodyDeclarations(JavaParser.EnumBodyDeclarationsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEnumBodyDeclarations(JavaParser.EnumBodyDeclarationsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInterfaceDeclaration(JavaParser.InterfaceDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInterfaceDeclaration(JavaParser.InterfaceDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterClassBody(JavaParser.ClassBodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitClassBody(JavaParser.ClassBodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInterfaceBody(JavaParser.InterfaceBodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInterfaceBody(JavaParser.InterfaceBodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterClassBodyDeclaration(JavaParser.ClassBodyDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitClassBodyDeclaration(JavaParser.ClassBodyDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMemberDeclaration(JavaParser.MemberDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMemberDeclaration(JavaParser.MemberDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMethodDeclaration(JavaParser.MethodDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMethodDeclaration(JavaParser.MethodDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMethodBody(JavaParser.MethodBodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMethodBody(JavaParser.MethodBodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTypeTypeOrVoid(JavaParser.TypeTypeOrVoidContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTypeTypeOrVoid(JavaParser.TypeTypeOrVoidContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGenericMethodDeclaration(JavaParser.GenericMethodDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGenericMethodDeclaration(JavaParser.GenericMethodDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGenericConstructorDeclaration(JavaParser.GenericConstructorDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGenericConstructorDeclaration(JavaParser.GenericConstructorDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterConstructorDeclaration(JavaParser.ConstructorDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitConstructorDeclaration(JavaParser.ConstructorDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFieldDeclaration(JavaParser.FieldDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFieldDeclaration(JavaParser.FieldDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInterfaceBodyDeclaration(JavaParser.InterfaceBodyDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInterfaceBodyDeclaration(JavaParser.InterfaceBodyDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInterfaceMemberDeclaration(JavaParser.InterfaceMemberDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInterfaceMemberDeclaration(JavaParser.InterfaceMemberDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterConstDeclaration(JavaParser.ConstDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitConstDeclaration(JavaParser.ConstDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterConstantDeclarator(JavaParser.ConstantDeclaratorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitConstantDeclarator(JavaParser.ConstantDeclaratorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInterfaceMethodDeclaration(JavaParser.InterfaceMethodDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInterfaceMethodDeclaration(JavaParser.InterfaceMethodDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInterfaceMethodModifier(JavaParser.InterfaceMethodModifierContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInterfaceMethodModifier(JavaParser.InterfaceMethodModifierContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterGenericInterfaceMethodDeclaration(JavaParser.GenericInterfaceMethodDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitGenericInterfaceMethodDeclaration(JavaParser.GenericInterfaceMethodDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterVariableDeclarators(JavaParser.VariableDeclaratorsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitVariableDeclarators(JavaParser.VariableDeclaratorsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterVariableDeclarator(JavaParser.VariableDeclaratorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitVariableDeclarator(JavaParser.VariableDeclaratorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterVariableDeclaratorId(JavaParser.VariableDeclaratorIdContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitVariableDeclaratorId(JavaParser.VariableDeclaratorIdContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterVariableInitializer(JavaParser.VariableInitializerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitVariableInitializer(JavaParser.VariableInitializerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterArrayInitializer(JavaParser.ArrayInitializerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitArrayInitializer(JavaParser.ArrayInitializerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterClassOrInterfaceType(JavaParser.ClassOrInterfaceTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitClassOrInterfaceType(JavaParser.ClassOrInterfaceTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTypeArgument(JavaParser.TypeArgumentContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTypeArgument(JavaParser.TypeArgumentContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterQualifiedNameList(JavaParser.QualifiedNameListContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitQualifiedNameList(JavaParser.QualifiedNameListContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFormalParameters(JavaParser.FormalParametersContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFormalParameters(JavaParser.FormalParametersContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFormalParameterList(JavaParser.FormalParameterListContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFormalParameterList(JavaParser.FormalParameterListContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFormalParameter(JavaParser.FormalParameterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFormalParameter(JavaParser.FormalParameterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLastFormalParameter(JavaParser.LastFormalParameterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLastFormalParameter(JavaParser.LastFormalParameterContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterQualifiedName(JavaParser.QualifiedNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitQualifiedName(JavaParser.QualifiedNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLiteral(JavaParser.LiteralContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLiteral(JavaParser.LiteralContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterIntegerLiteral(JavaParser.IntegerLiteralContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitIntegerLiteral(JavaParser.IntegerLiteralContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFloatLiteral(JavaParser.FloatLiteralContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFloatLiteral(JavaParser.FloatLiteralContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAltAnnotationQualifiedName(JavaParser.AltAnnotationQualifiedNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAltAnnotationQualifiedName(JavaParser.AltAnnotationQualifiedNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAnnotation(JavaParser.AnnotationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAnnotation(JavaParser.AnnotationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterElementValuePairs(JavaParser.ElementValuePairsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitElementValuePairs(JavaParser.ElementValuePairsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterElementValuePair(JavaParser.ElementValuePairContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitElementValuePair(JavaParser.ElementValuePairContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterElementValue(JavaParser.ElementValueContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitElementValue(JavaParser.ElementValueContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterElementValueArrayInitializer(JavaParser.ElementValueArrayInitializerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitElementValueArrayInitializer(JavaParser.ElementValueArrayInitializerContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAnnotationTypeDeclaration(JavaParser.AnnotationTypeDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAnnotationTypeDeclaration(JavaParser.AnnotationTypeDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAnnotationTypeBody(JavaParser.AnnotationTypeBodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAnnotationTypeBody(JavaParser.AnnotationTypeBodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAnnotationTypeElementDeclaration(JavaParser.AnnotationTypeElementDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAnnotationTypeElementDeclaration(JavaParser.AnnotationTypeElementDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAnnotationTypeElementRest(JavaParser.AnnotationTypeElementRestContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAnnotationTypeElementRest(JavaParser.AnnotationTypeElementRestContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAnnotationMethodOrConstantRest(JavaParser.AnnotationMethodOrConstantRestContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAnnotationMethodOrConstantRest(JavaParser.AnnotationMethodOrConstantRestContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAnnotationMethodRest(JavaParser.AnnotationMethodRestContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAnnotationMethodRest(JavaParser.AnnotationMethodRestContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterAnnotationConstantRest(JavaParser.AnnotationConstantRestContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitAnnotationConstantRest(JavaParser.AnnotationConstantRestContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterDefaultValue(JavaParser.DefaultValueContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitDefaultValue(JavaParser.DefaultValueContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterBlock(JavaParser.BlockContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitBlock(JavaParser.BlockContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterBlockStatement(JavaParser.BlockStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitBlockStatement(JavaParser.BlockStatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLocalVariableDeclaration(JavaParser.LocalVariableDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLocalVariableDeclaration(JavaParser.LocalVariableDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLocalTypeDeclaration(JavaParser.LocalTypeDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLocalTypeDeclaration(JavaParser.LocalTypeDeclarationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterStatement(JavaParser.StatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitStatement(JavaParser.StatementContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCatchClause(JavaParser.CatchClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCatchClause(JavaParser.CatchClauseContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCatchType(JavaParser.CatchTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCatchType(JavaParser.CatchTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterFinallyBlock(JavaParser.FinallyBlockContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitFinallyBlock(JavaParser.FinallyBlockContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterResourceSpecification(JavaParser.ResourceSpecificationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitResourceSpecification(JavaParser.ResourceSpecificationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterResources(JavaParser.ResourcesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitResources(JavaParser.ResourcesContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterResource(JavaParser.ResourceContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitResource(JavaParser.ResourceContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSwitchBlockStatementGroup(JavaParser.SwitchBlockStatementGroupContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSwitchBlockStatementGroup(JavaParser.SwitchBlockStatementGroupContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSwitchLabel(JavaParser.SwitchLabelContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSwitchLabel(JavaParser.SwitchLabelContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterForControl(JavaParser.ForControlContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitForControl(JavaParser.ForControlContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterForInit(JavaParser.ForInitContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitForInit(JavaParser.ForInitContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEnhancedForControl(JavaParser.EnhancedForControlContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEnhancedForControl(JavaParser.EnhancedForControlContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterParExpression(JavaParser.ParExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitParExpression(JavaParser.ParExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExpressionList(JavaParser.ExpressionListContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExpressionList(JavaParser.ExpressionListContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterMethodCall(JavaParser.MethodCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitMethodCall(JavaParser.MethodCallContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExpression(JavaParser.ExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExpression(JavaParser.ExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLambdaExpression(JavaParser.LambdaExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLambdaExpression(JavaParser.LambdaExpressionContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLambdaParameters(JavaParser.LambdaParametersContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLambdaParameters(JavaParser.LambdaParametersContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterLambdaBody(JavaParser.LambdaBodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitLambdaBody(JavaParser.LambdaBodyContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPrimary(JavaParser.PrimaryContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPrimary(JavaParser.PrimaryContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterClassType(JavaParser.ClassTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitClassType(JavaParser.ClassTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCreator(JavaParser.CreatorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCreator(JavaParser.CreatorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterCreatedName(JavaParser.CreatedNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitCreatedName(JavaParser.CreatedNameContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterInnerCreator(JavaParser.InnerCreatorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitInnerCreator(JavaParser.InnerCreatorContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterArrayCreatorRest(JavaParser.ArrayCreatorRestContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitArrayCreatorRest(JavaParser.ArrayCreatorRestContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterClassCreatorRest(JavaParser.ClassCreatorRestContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitClassCreatorRest(JavaParser.ClassCreatorRestContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExplicitGenericInvocation(JavaParser.ExplicitGenericInvocationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExplicitGenericInvocation(JavaParser.ExplicitGenericInvocationContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTypeArgumentsOrDiamond(JavaParser.TypeArgumentsOrDiamondContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTypeArgumentsOrDiamond(JavaParser.TypeArgumentsOrDiamondContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterNonWildcardTypeArgumentsOrDiamond(JavaParser.NonWildcardTypeArgumentsOrDiamondContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitNonWildcardTypeArgumentsOrDiamond(JavaParser.NonWildcardTypeArgumentsOrDiamondContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterNonWildcardTypeArguments(JavaParser.NonWildcardTypeArgumentsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitNonWildcardTypeArguments(JavaParser.NonWildcardTypeArgumentsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTypeList(JavaParser.TypeListContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTypeList(JavaParser.TypeListContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTypeType(JavaParser.TypeTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTypeType(JavaParser.TypeTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterPrimitiveType(JavaParser.PrimitiveTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitPrimitiveType(JavaParser.PrimitiveTypeContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterTypeArguments(JavaParser.TypeArgumentsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitTypeArguments(JavaParser.TypeArgumentsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterSuperSuffix(JavaParser.SuperSuffixContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitSuperSuffix(JavaParser.SuperSuffixContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterExplicitGenericInvocationSuffix(JavaParser.ExplicitGenericInvocationSuffixContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitExplicitGenericInvocationSuffix(JavaParser.ExplicitGenericInvocationSuffixContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterArguments(JavaParser.ArgumentsContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitArguments(JavaParser.ArgumentsContext ctx) { } + + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void enterEveryRule(ParserRuleContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void exitEveryRule(ParserRuleContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void visitTerminal(TerminalNode node) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing.

+ */ + @Override public void visitErrorNode(ErrorNode node) { } +} \ No newline at end of file diff --git a/lexers/src/main/gen/com/itsaky/androidide/lexers/java/JavaParserBaseVisitor.java b/lexers/src/main/gen/com/itsaky/androidide/lexers/java/JavaParserBaseVisitor.java new file mode 100644 index 000000000..8a822825f --- /dev/null +++ b/lexers/src/main/gen/com/itsaky/androidide/lexers/java/JavaParserBaseVisitor.java @@ -0,0 +1,749 @@ +// Generated from /home/itsaky/Projects/Android/AndroidIDE/lexers/src/main/java/com/itsaky/androidide/lexers/java/JavaParser.g4 by ANTLR 4.10.1 +package com.itsaky.androidide.lexers.java; +import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor; + +/** + * This class provides an empty implementation of {@link JavaParserVisitor}, + * which can be extended to create a visitor which only needs to handle a subset + * of the available methods. + * + * @param The return type of the visit operation. Use {@link Void} for + * operations with no return type. + */ +public class JavaParserBaseVisitor extends AbstractParseTreeVisitor implements JavaParserVisitor { + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitCompilationUnit(JavaParser.CompilationUnitContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitPackageDeclaration(JavaParser.PackageDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitImportDeclaration(JavaParser.ImportDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeDeclaration(JavaParser.TypeDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitModifier(JavaParser.ModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitClassOrInterfaceModifier(JavaParser.ClassOrInterfaceModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitVariableModifier(JavaParser.VariableModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitClassDeclaration(JavaParser.ClassDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeParameters(JavaParser.TypeParametersContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeParameter(JavaParser.TypeParameterContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeBound(JavaParser.TypeBoundContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitEnumDeclaration(JavaParser.EnumDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitEnumConstants(JavaParser.EnumConstantsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitEnumConstant(JavaParser.EnumConstantContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitEnumBodyDeclarations(JavaParser.EnumBodyDeclarationsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitInterfaceDeclaration(JavaParser.InterfaceDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitClassBody(JavaParser.ClassBodyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitInterfaceBody(JavaParser.InterfaceBodyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitClassBodyDeclaration(JavaParser.ClassBodyDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitMemberDeclaration(JavaParser.MemberDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitMethodDeclaration(JavaParser.MethodDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitMethodBody(JavaParser.MethodBodyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeTypeOrVoid(JavaParser.TypeTypeOrVoidContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitGenericMethodDeclaration(JavaParser.GenericMethodDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitGenericConstructorDeclaration(JavaParser.GenericConstructorDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitConstructorDeclaration(JavaParser.ConstructorDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitFieldDeclaration(JavaParser.FieldDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitInterfaceBodyDeclaration(JavaParser.InterfaceBodyDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitInterfaceMemberDeclaration(JavaParser.InterfaceMemberDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitConstDeclaration(JavaParser.ConstDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitConstantDeclarator(JavaParser.ConstantDeclaratorContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitInterfaceMethodDeclaration(JavaParser.InterfaceMethodDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitInterfaceMethodModifier(JavaParser.InterfaceMethodModifierContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitGenericInterfaceMethodDeclaration(JavaParser.GenericInterfaceMethodDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitVariableDeclarators(JavaParser.VariableDeclaratorsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitVariableDeclarator(JavaParser.VariableDeclaratorContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitVariableDeclaratorId(JavaParser.VariableDeclaratorIdContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitVariableInitializer(JavaParser.VariableInitializerContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitArrayInitializer(JavaParser.ArrayInitializerContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitClassOrInterfaceType(JavaParser.ClassOrInterfaceTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeArgument(JavaParser.TypeArgumentContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitQualifiedNameList(JavaParser.QualifiedNameListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitFormalParameters(JavaParser.FormalParametersContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitFormalParameterList(JavaParser.FormalParameterListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitFormalParameter(JavaParser.FormalParameterContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitLastFormalParameter(JavaParser.LastFormalParameterContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitQualifiedName(JavaParser.QualifiedNameContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitLiteral(JavaParser.LiteralContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitIntegerLiteral(JavaParser.IntegerLiteralContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitFloatLiteral(JavaParser.FloatLiteralContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitAltAnnotationQualifiedName(JavaParser.AltAnnotationQualifiedNameContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitAnnotation(JavaParser.AnnotationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitElementValuePairs(JavaParser.ElementValuePairsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitElementValuePair(JavaParser.ElementValuePairContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitElementValue(JavaParser.ElementValueContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitElementValueArrayInitializer(JavaParser.ElementValueArrayInitializerContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitAnnotationTypeDeclaration(JavaParser.AnnotationTypeDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitAnnotationTypeBody(JavaParser.AnnotationTypeBodyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitAnnotationTypeElementDeclaration(JavaParser.AnnotationTypeElementDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitAnnotationTypeElementRest(JavaParser.AnnotationTypeElementRestContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitAnnotationMethodOrConstantRest(JavaParser.AnnotationMethodOrConstantRestContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitAnnotationMethodRest(JavaParser.AnnotationMethodRestContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitAnnotationConstantRest(JavaParser.AnnotationConstantRestContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitDefaultValue(JavaParser.DefaultValueContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitBlock(JavaParser.BlockContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitBlockStatement(JavaParser.BlockStatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitLocalVariableDeclaration(JavaParser.LocalVariableDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitLocalTypeDeclaration(JavaParser.LocalTypeDeclarationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitStatement(JavaParser.StatementContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitCatchClause(JavaParser.CatchClauseContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitCatchType(JavaParser.CatchTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitFinallyBlock(JavaParser.FinallyBlockContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitResourceSpecification(JavaParser.ResourceSpecificationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitResources(JavaParser.ResourcesContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitResource(JavaParser.ResourceContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitSwitchBlockStatementGroup(JavaParser.SwitchBlockStatementGroupContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitSwitchLabel(JavaParser.SwitchLabelContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitForControl(JavaParser.ForControlContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitForInit(JavaParser.ForInitContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitEnhancedForControl(JavaParser.EnhancedForControlContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitParExpression(JavaParser.ParExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitExpressionList(JavaParser.ExpressionListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitMethodCall(JavaParser.MethodCallContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitExpression(JavaParser.ExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitLambdaExpression(JavaParser.LambdaExpressionContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitLambdaParameters(JavaParser.LambdaParametersContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitLambdaBody(JavaParser.LambdaBodyContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitPrimary(JavaParser.PrimaryContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitClassType(JavaParser.ClassTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitCreator(JavaParser.CreatorContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitCreatedName(JavaParser.CreatedNameContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitInnerCreator(JavaParser.InnerCreatorContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitArrayCreatorRest(JavaParser.ArrayCreatorRestContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitClassCreatorRest(JavaParser.ClassCreatorRestContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitExplicitGenericInvocation(JavaParser.ExplicitGenericInvocationContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeArgumentsOrDiamond(JavaParser.TypeArgumentsOrDiamondContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitNonWildcardTypeArgumentsOrDiamond(JavaParser.NonWildcardTypeArgumentsOrDiamondContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitNonWildcardTypeArguments(JavaParser.NonWildcardTypeArgumentsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeList(JavaParser.TypeListContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeType(JavaParser.TypeTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitPrimitiveType(JavaParser.PrimitiveTypeContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitTypeArguments(JavaParser.TypeArgumentsContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitSuperSuffix(JavaParser.SuperSuffixContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitExplicitGenericInvocationSuffix(JavaParser.ExplicitGenericInvocationSuffixContext ctx) { return visitChildren(ctx); } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling + * {@link #visitChildren} on {@code ctx}.

+ */ + @Override public T visitArguments(JavaParser.ArgumentsContext ctx) { return visitChildren(ctx); } +} \ No newline at end of file diff --git a/lexers/src/main/gen/com/itsaky/androidide/lexers/java/JavaParserListener.java b/lexers/src/main/gen/com/itsaky/androidide/lexers/java/JavaParserListener.java new file mode 100644 index 000000000..6afd1ee16 --- /dev/null +++ b/lexers/src/main/gen/com/itsaky/androidide/lexers/java/JavaParserListener.java @@ -0,0 +1,1060 @@ +// Generated from /home/itsaky/Projects/Android/AndroidIDE/lexers/src/main/java/com/itsaky/androidide/lexers/java/JavaParser.g4 by ANTLR 4.10.1 +package com.itsaky.androidide.lexers.java; +import org.antlr.v4.runtime.tree.ParseTreeListener; + +/** + * This interface defines a complete listener for a parse tree produced by + * {@link JavaParser}. + */ +public interface JavaParserListener extends ParseTreeListener { + /** + * Enter a parse tree produced by {@link JavaParser#compilationUnit}. + * @param ctx the parse tree + */ + void enterCompilationUnit(JavaParser.CompilationUnitContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#compilationUnit}. + * @param ctx the parse tree + */ + void exitCompilationUnit(JavaParser.CompilationUnitContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#packageDeclaration}. + * @param ctx the parse tree + */ + void enterPackageDeclaration(JavaParser.PackageDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#packageDeclaration}. + * @param ctx the parse tree + */ + void exitPackageDeclaration(JavaParser.PackageDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#importDeclaration}. + * @param ctx the parse tree + */ + void enterImportDeclaration(JavaParser.ImportDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#importDeclaration}. + * @param ctx the parse tree + */ + void exitImportDeclaration(JavaParser.ImportDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#typeDeclaration}. + * @param ctx the parse tree + */ + void enterTypeDeclaration(JavaParser.TypeDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#typeDeclaration}. + * @param ctx the parse tree + */ + void exitTypeDeclaration(JavaParser.TypeDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#modifier}. + * @param ctx the parse tree + */ + void enterModifier(JavaParser.ModifierContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#modifier}. + * @param ctx the parse tree + */ + void exitModifier(JavaParser.ModifierContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#classOrInterfaceModifier}. + * @param ctx the parse tree + */ + void enterClassOrInterfaceModifier(JavaParser.ClassOrInterfaceModifierContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#classOrInterfaceModifier}. + * @param ctx the parse tree + */ + void exitClassOrInterfaceModifier(JavaParser.ClassOrInterfaceModifierContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#variableModifier}. + * @param ctx the parse tree + */ + void enterVariableModifier(JavaParser.VariableModifierContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#variableModifier}. + * @param ctx the parse tree + */ + void exitVariableModifier(JavaParser.VariableModifierContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#classDeclaration}. + * @param ctx the parse tree + */ + void enterClassDeclaration(JavaParser.ClassDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#classDeclaration}. + * @param ctx the parse tree + */ + void exitClassDeclaration(JavaParser.ClassDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#typeParameters}. + * @param ctx the parse tree + */ + void enterTypeParameters(JavaParser.TypeParametersContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#typeParameters}. + * @param ctx the parse tree + */ + void exitTypeParameters(JavaParser.TypeParametersContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#typeParameter}. + * @param ctx the parse tree + */ + void enterTypeParameter(JavaParser.TypeParameterContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#typeParameter}. + * @param ctx the parse tree + */ + void exitTypeParameter(JavaParser.TypeParameterContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#typeBound}. + * @param ctx the parse tree + */ + void enterTypeBound(JavaParser.TypeBoundContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#typeBound}. + * @param ctx the parse tree + */ + void exitTypeBound(JavaParser.TypeBoundContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#enumDeclaration}. + * @param ctx the parse tree + */ + void enterEnumDeclaration(JavaParser.EnumDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#enumDeclaration}. + * @param ctx the parse tree + */ + void exitEnumDeclaration(JavaParser.EnumDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#enumConstants}. + * @param ctx the parse tree + */ + void enterEnumConstants(JavaParser.EnumConstantsContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#enumConstants}. + * @param ctx the parse tree + */ + void exitEnumConstants(JavaParser.EnumConstantsContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#enumConstant}. + * @param ctx the parse tree + */ + void enterEnumConstant(JavaParser.EnumConstantContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#enumConstant}. + * @param ctx the parse tree + */ + void exitEnumConstant(JavaParser.EnumConstantContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#enumBodyDeclarations}. + * @param ctx the parse tree + */ + void enterEnumBodyDeclarations(JavaParser.EnumBodyDeclarationsContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#enumBodyDeclarations}. + * @param ctx the parse tree + */ + void exitEnumBodyDeclarations(JavaParser.EnumBodyDeclarationsContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#interfaceDeclaration}. + * @param ctx the parse tree + */ + void enterInterfaceDeclaration(JavaParser.InterfaceDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#interfaceDeclaration}. + * @param ctx the parse tree + */ + void exitInterfaceDeclaration(JavaParser.InterfaceDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#classBody}. + * @param ctx the parse tree + */ + void enterClassBody(JavaParser.ClassBodyContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#classBody}. + * @param ctx the parse tree + */ + void exitClassBody(JavaParser.ClassBodyContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#interfaceBody}. + * @param ctx the parse tree + */ + void enterInterfaceBody(JavaParser.InterfaceBodyContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#interfaceBody}. + * @param ctx the parse tree + */ + void exitInterfaceBody(JavaParser.InterfaceBodyContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#classBodyDeclaration}. + * @param ctx the parse tree + */ + void enterClassBodyDeclaration(JavaParser.ClassBodyDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#classBodyDeclaration}. + * @param ctx the parse tree + */ + void exitClassBodyDeclaration(JavaParser.ClassBodyDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#memberDeclaration}. + * @param ctx the parse tree + */ + void enterMemberDeclaration(JavaParser.MemberDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#memberDeclaration}. + * @param ctx the parse tree + */ + void exitMemberDeclaration(JavaParser.MemberDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#methodDeclaration}. + * @param ctx the parse tree + */ + void enterMethodDeclaration(JavaParser.MethodDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#methodDeclaration}. + * @param ctx the parse tree + */ + void exitMethodDeclaration(JavaParser.MethodDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#methodBody}. + * @param ctx the parse tree + */ + void enterMethodBody(JavaParser.MethodBodyContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#methodBody}. + * @param ctx the parse tree + */ + void exitMethodBody(JavaParser.MethodBodyContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#typeTypeOrVoid}. + * @param ctx the parse tree + */ + void enterTypeTypeOrVoid(JavaParser.TypeTypeOrVoidContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#typeTypeOrVoid}. + * @param ctx the parse tree + */ + void exitTypeTypeOrVoid(JavaParser.TypeTypeOrVoidContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#genericMethodDeclaration}. + * @param ctx the parse tree + */ + void enterGenericMethodDeclaration(JavaParser.GenericMethodDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#genericMethodDeclaration}. + * @param ctx the parse tree + */ + void exitGenericMethodDeclaration(JavaParser.GenericMethodDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#genericConstructorDeclaration}. + * @param ctx the parse tree + */ + void enterGenericConstructorDeclaration(JavaParser.GenericConstructorDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#genericConstructorDeclaration}. + * @param ctx the parse tree + */ + void exitGenericConstructorDeclaration(JavaParser.GenericConstructorDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#constructorDeclaration}. + * @param ctx the parse tree + */ + void enterConstructorDeclaration(JavaParser.ConstructorDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#constructorDeclaration}. + * @param ctx the parse tree + */ + void exitConstructorDeclaration(JavaParser.ConstructorDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#fieldDeclaration}. + * @param ctx the parse tree + */ + void enterFieldDeclaration(JavaParser.FieldDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#fieldDeclaration}. + * @param ctx the parse tree + */ + void exitFieldDeclaration(JavaParser.FieldDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#interfaceBodyDeclaration}. + * @param ctx the parse tree + */ + void enterInterfaceBodyDeclaration(JavaParser.InterfaceBodyDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#interfaceBodyDeclaration}. + * @param ctx the parse tree + */ + void exitInterfaceBodyDeclaration(JavaParser.InterfaceBodyDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#interfaceMemberDeclaration}. + * @param ctx the parse tree + */ + void enterInterfaceMemberDeclaration(JavaParser.InterfaceMemberDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#interfaceMemberDeclaration}. + * @param ctx the parse tree + */ + void exitInterfaceMemberDeclaration(JavaParser.InterfaceMemberDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#constDeclaration}. + * @param ctx the parse tree + */ + void enterConstDeclaration(JavaParser.ConstDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#constDeclaration}. + * @param ctx the parse tree + */ + void exitConstDeclaration(JavaParser.ConstDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#constantDeclarator}. + * @param ctx the parse tree + */ + void enterConstantDeclarator(JavaParser.ConstantDeclaratorContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#constantDeclarator}. + * @param ctx the parse tree + */ + void exitConstantDeclarator(JavaParser.ConstantDeclaratorContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#interfaceMethodDeclaration}. + * @param ctx the parse tree + */ + void enterInterfaceMethodDeclaration(JavaParser.InterfaceMethodDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#interfaceMethodDeclaration}. + * @param ctx the parse tree + */ + void exitInterfaceMethodDeclaration(JavaParser.InterfaceMethodDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#interfaceMethodModifier}. + * @param ctx the parse tree + */ + void enterInterfaceMethodModifier(JavaParser.InterfaceMethodModifierContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#interfaceMethodModifier}. + * @param ctx the parse tree + */ + void exitInterfaceMethodModifier(JavaParser.InterfaceMethodModifierContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#genericInterfaceMethodDeclaration}. + * @param ctx the parse tree + */ + void enterGenericInterfaceMethodDeclaration(JavaParser.GenericInterfaceMethodDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#genericInterfaceMethodDeclaration}. + * @param ctx the parse tree + */ + void exitGenericInterfaceMethodDeclaration(JavaParser.GenericInterfaceMethodDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#variableDeclarators}. + * @param ctx the parse tree + */ + void enterVariableDeclarators(JavaParser.VariableDeclaratorsContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#variableDeclarators}. + * @param ctx the parse tree + */ + void exitVariableDeclarators(JavaParser.VariableDeclaratorsContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#variableDeclarator}. + * @param ctx the parse tree + */ + void enterVariableDeclarator(JavaParser.VariableDeclaratorContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#variableDeclarator}. + * @param ctx the parse tree + */ + void exitVariableDeclarator(JavaParser.VariableDeclaratorContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#variableDeclaratorId}. + * @param ctx the parse tree + */ + void enterVariableDeclaratorId(JavaParser.VariableDeclaratorIdContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#variableDeclaratorId}. + * @param ctx the parse tree + */ + void exitVariableDeclaratorId(JavaParser.VariableDeclaratorIdContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#variableInitializer}. + * @param ctx the parse tree + */ + void enterVariableInitializer(JavaParser.VariableInitializerContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#variableInitializer}. + * @param ctx the parse tree + */ + void exitVariableInitializer(JavaParser.VariableInitializerContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#arrayInitializer}. + * @param ctx the parse tree + */ + void enterArrayInitializer(JavaParser.ArrayInitializerContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#arrayInitializer}. + * @param ctx the parse tree + */ + void exitArrayInitializer(JavaParser.ArrayInitializerContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#classOrInterfaceType}. + * @param ctx the parse tree + */ + void enterClassOrInterfaceType(JavaParser.ClassOrInterfaceTypeContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#classOrInterfaceType}. + * @param ctx the parse tree + */ + void exitClassOrInterfaceType(JavaParser.ClassOrInterfaceTypeContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#typeArgument}. + * @param ctx the parse tree + */ + void enterTypeArgument(JavaParser.TypeArgumentContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#typeArgument}. + * @param ctx the parse tree + */ + void exitTypeArgument(JavaParser.TypeArgumentContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#qualifiedNameList}. + * @param ctx the parse tree + */ + void enterQualifiedNameList(JavaParser.QualifiedNameListContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#qualifiedNameList}. + * @param ctx the parse tree + */ + void exitQualifiedNameList(JavaParser.QualifiedNameListContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#formalParameters}. + * @param ctx the parse tree + */ + void enterFormalParameters(JavaParser.FormalParametersContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#formalParameters}. + * @param ctx the parse tree + */ + void exitFormalParameters(JavaParser.FormalParametersContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#formalParameterList}. + * @param ctx the parse tree + */ + void enterFormalParameterList(JavaParser.FormalParameterListContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#formalParameterList}. + * @param ctx the parse tree + */ + void exitFormalParameterList(JavaParser.FormalParameterListContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#formalParameter}. + * @param ctx the parse tree + */ + void enterFormalParameter(JavaParser.FormalParameterContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#formalParameter}. + * @param ctx the parse tree + */ + void exitFormalParameter(JavaParser.FormalParameterContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#lastFormalParameter}. + * @param ctx the parse tree + */ + void enterLastFormalParameter(JavaParser.LastFormalParameterContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#lastFormalParameter}. + * @param ctx the parse tree + */ + void exitLastFormalParameter(JavaParser.LastFormalParameterContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#qualifiedName}. + * @param ctx the parse tree + */ + void enterQualifiedName(JavaParser.QualifiedNameContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#qualifiedName}. + * @param ctx the parse tree + */ + void exitQualifiedName(JavaParser.QualifiedNameContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#literal}. + * @param ctx the parse tree + */ + void enterLiteral(JavaParser.LiteralContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#literal}. + * @param ctx the parse tree + */ + void exitLiteral(JavaParser.LiteralContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#integerLiteral}. + * @param ctx the parse tree + */ + void enterIntegerLiteral(JavaParser.IntegerLiteralContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#integerLiteral}. + * @param ctx the parse tree + */ + void exitIntegerLiteral(JavaParser.IntegerLiteralContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#floatLiteral}. + * @param ctx the parse tree + */ + void enterFloatLiteral(JavaParser.FloatLiteralContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#floatLiteral}. + * @param ctx the parse tree + */ + void exitFloatLiteral(JavaParser.FloatLiteralContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#altAnnotationQualifiedName}. + * @param ctx the parse tree + */ + void enterAltAnnotationQualifiedName(JavaParser.AltAnnotationQualifiedNameContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#altAnnotationQualifiedName}. + * @param ctx the parse tree + */ + void exitAltAnnotationQualifiedName(JavaParser.AltAnnotationQualifiedNameContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#annotation}. + * @param ctx the parse tree + */ + void enterAnnotation(JavaParser.AnnotationContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#annotation}. + * @param ctx the parse tree + */ + void exitAnnotation(JavaParser.AnnotationContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#elementValuePairs}. + * @param ctx the parse tree + */ + void enterElementValuePairs(JavaParser.ElementValuePairsContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#elementValuePairs}. + * @param ctx the parse tree + */ + void exitElementValuePairs(JavaParser.ElementValuePairsContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#elementValuePair}. + * @param ctx the parse tree + */ + void enterElementValuePair(JavaParser.ElementValuePairContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#elementValuePair}. + * @param ctx the parse tree + */ + void exitElementValuePair(JavaParser.ElementValuePairContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#elementValue}. + * @param ctx the parse tree + */ + void enterElementValue(JavaParser.ElementValueContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#elementValue}. + * @param ctx the parse tree + */ + void exitElementValue(JavaParser.ElementValueContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#elementValueArrayInitializer}. + * @param ctx the parse tree + */ + void enterElementValueArrayInitializer(JavaParser.ElementValueArrayInitializerContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#elementValueArrayInitializer}. + * @param ctx the parse tree + */ + void exitElementValueArrayInitializer(JavaParser.ElementValueArrayInitializerContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#annotationTypeDeclaration}. + * @param ctx the parse tree + */ + void enterAnnotationTypeDeclaration(JavaParser.AnnotationTypeDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#annotationTypeDeclaration}. + * @param ctx the parse tree + */ + void exitAnnotationTypeDeclaration(JavaParser.AnnotationTypeDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#annotationTypeBody}. + * @param ctx the parse tree + */ + void enterAnnotationTypeBody(JavaParser.AnnotationTypeBodyContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#annotationTypeBody}. + * @param ctx the parse tree + */ + void exitAnnotationTypeBody(JavaParser.AnnotationTypeBodyContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#annotationTypeElementDeclaration}. + * @param ctx the parse tree + */ + void enterAnnotationTypeElementDeclaration(JavaParser.AnnotationTypeElementDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#annotationTypeElementDeclaration}. + * @param ctx the parse tree + */ + void exitAnnotationTypeElementDeclaration(JavaParser.AnnotationTypeElementDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#annotationTypeElementRest}. + * @param ctx the parse tree + */ + void enterAnnotationTypeElementRest(JavaParser.AnnotationTypeElementRestContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#annotationTypeElementRest}. + * @param ctx the parse tree + */ + void exitAnnotationTypeElementRest(JavaParser.AnnotationTypeElementRestContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#annotationMethodOrConstantRest}. + * @param ctx the parse tree + */ + void enterAnnotationMethodOrConstantRest(JavaParser.AnnotationMethodOrConstantRestContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#annotationMethodOrConstantRest}. + * @param ctx the parse tree + */ + void exitAnnotationMethodOrConstantRest(JavaParser.AnnotationMethodOrConstantRestContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#annotationMethodRest}. + * @param ctx the parse tree + */ + void enterAnnotationMethodRest(JavaParser.AnnotationMethodRestContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#annotationMethodRest}. + * @param ctx the parse tree + */ + void exitAnnotationMethodRest(JavaParser.AnnotationMethodRestContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#annotationConstantRest}. + * @param ctx the parse tree + */ + void enterAnnotationConstantRest(JavaParser.AnnotationConstantRestContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#annotationConstantRest}. + * @param ctx the parse tree + */ + void exitAnnotationConstantRest(JavaParser.AnnotationConstantRestContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#defaultValue}. + * @param ctx the parse tree + */ + void enterDefaultValue(JavaParser.DefaultValueContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#defaultValue}. + * @param ctx the parse tree + */ + void exitDefaultValue(JavaParser.DefaultValueContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#block}. + * @param ctx the parse tree + */ + void enterBlock(JavaParser.BlockContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#block}. + * @param ctx the parse tree + */ + void exitBlock(JavaParser.BlockContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#blockStatement}. + * @param ctx the parse tree + */ + void enterBlockStatement(JavaParser.BlockStatementContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#blockStatement}. + * @param ctx the parse tree + */ + void exitBlockStatement(JavaParser.BlockStatementContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#localVariableDeclaration}. + * @param ctx the parse tree + */ + void enterLocalVariableDeclaration(JavaParser.LocalVariableDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#localVariableDeclaration}. + * @param ctx the parse tree + */ + void exitLocalVariableDeclaration(JavaParser.LocalVariableDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#localTypeDeclaration}. + * @param ctx the parse tree + */ + void enterLocalTypeDeclaration(JavaParser.LocalTypeDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#localTypeDeclaration}. + * @param ctx the parse tree + */ + void exitLocalTypeDeclaration(JavaParser.LocalTypeDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#statement}. + * @param ctx the parse tree + */ + void enterStatement(JavaParser.StatementContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#statement}. + * @param ctx the parse tree + */ + void exitStatement(JavaParser.StatementContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#catchClause}. + * @param ctx the parse tree + */ + void enterCatchClause(JavaParser.CatchClauseContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#catchClause}. + * @param ctx the parse tree + */ + void exitCatchClause(JavaParser.CatchClauseContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#catchType}. + * @param ctx the parse tree + */ + void enterCatchType(JavaParser.CatchTypeContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#catchType}. + * @param ctx the parse tree + */ + void exitCatchType(JavaParser.CatchTypeContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#finallyBlock}. + * @param ctx the parse tree + */ + void enterFinallyBlock(JavaParser.FinallyBlockContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#finallyBlock}. + * @param ctx the parse tree + */ + void exitFinallyBlock(JavaParser.FinallyBlockContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#resourceSpecification}. + * @param ctx the parse tree + */ + void enterResourceSpecification(JavaParser.ResourceSpecificationContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#resourceSpecification}. + * @param ctx the parse tree + */ + void exitResourceSpecification(JavaParser.ResourceSpecificationContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#resources}. + * @param ctx the parse tree + */ + void enterResources(JavaParser.ResourcesContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#resources}. + * @param ctx the parse tree + */ + void exitResources(JavaParser.ResourcesContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#resource}. + * @param ctx the parse tree + */ + void enterResource(JavaParser.ResourceContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#resource}. + * @param ctx the parse tree + */ + void exitResource(JavaParser.ResourceContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#switchBlockStatementGroup}. + * @param ctx the parse tree + */ + void enterSwitchBlockStatementGroup(JavaParser.SwitchBlockStatementGroupContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#switchBlockStatementGroup}. + * @param ctx the parse tree + */ + void exitSwitchBlockStatementGroup(JavaParser.SwitchBlockStatementGroupContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#switchLabel}. + * @param ctx the parse tree + */ + void enterSwitchLabel(JavaParser.SwitchLabelContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#switchLabel}. + * @param ctx the parse tree + */ + void exitSwitchLabel(JavaParser.SwitchLabelContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#forControl}. + * @param ctx the parse tree + */ + void enterForControl(JavaParser.ForControlContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#forControl}. + * @param ctx the parse tree + */ + void exitForControl(JavaParser.ForControlContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#forInit}. + * @param ctx the parse tree + */ + void enterForInit(JavaParser.ForInitContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#forInit}. + * @param ctx the parse tree + */ + void exitForInit(JavaParser.ForInitContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#enhancedForControl}. + * @param ctx the parse tree + */ + void enterEnhancedForControl(JavaParser.EnhancedForControlContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#enhancedForControl}. + * @param ctx the parse tree + */ + void exitEnhancedForControl(JavaParser.EnhancedForControlContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#parExpression}. + * @param ctx the parse tree + */ + void enterParExpression(JavaParser.ParExpressionContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#parExpression}. + * @param ctx the parse tree + */ + void exitParExpression(JavaParser.ParExpressionContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#expressionList}. + * @param ctx the parse tree + */ + void enterExpressionList(JavaParser.ExpressionListContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#expressionList}. + * @param ctx the parse tree + */ + void exitExpressionList(JavaParser.ExpressionListContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#methodCall}. + * @param ctx the parse tree + */ + void enterMethodCall(JavaParser.MethodCallContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#methodCall}. + * @param ctx the parse tree + */ + void exitMethodCall(JavaParser.MethodCallContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#expression}. + * @param ctx the parse tree + */ + void enterExpression(JavaParser.ExpressionContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#expression}. + * @param ctx the parse tree + */ + void exitExpression(JavaParser.ExpressionContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#lambdaExpression}. + * @param ctx the parse tree + */ + void enterLambdaExpression(JavaParser.LambdaExpressionContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#lambdaExpression}. + * @param ctx the parse tree + */ + void exitLambdaExpression(JavaParser.LambdaExpressionContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#lambdaParameters}. + * @param ctx the parse tree + */ + void enterLambdaParameters(JavaParser.LambdaParametersContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#lambdaParameters}. + * @param ctx the parse tree + */ + void exitLambdaParameters(JavaParser.LambdaParametersContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#lambdaBody}. + * @param ctx the parse tree + */ + void enterLambdaBody(JavaParser.LambdaBodyContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#lambdaBody}. + * @param ctx the parse tree + */ + void exitLambdaBody(JavaParser.LambdaBodyContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#primary}. + * @param ctx the parse tree + */ + void enterPrimary(JavaParser.PrimaryContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#primary}. + * @param ctx the parse tree + */ + void exitPrimary(JavaParser.PrimaryContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#classType}. + * @param ctx the parse tree + */ + void enterClassType(JavaParser.ClassTypeContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#classType}. + * @param ctx the parse tree + */ + void exitClassType(JavaParser.ClassTypeContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#creator}. + * @param ctx the parse tree + */ + void enterCreator(JavaParser.CreatorContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#creator}. + * @param ctx the parse tree + */ + void exitCreator(JavaParser.CreatorContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#createdName}. + * @param ctx the parse tree + */ + void enterCreatedName(JavaParser.CreatedNameContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#createdName}. + * @param ctx the parse tree + */ + void exitCreatedName(JavaParser.CreatedNameContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#innerCreator}. + * @param ctx the parse tree + */ + void enterInnerCreator(JavaParser.InnerCreatorContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#innerCreator}. + * @param ctx the parse tree + */ + void exitInnerCreator(JavaParser.InnerCreatorContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#arrayCreatorRest}. + * @param ctx the parse tree + */ + void enterArrayCreatorRest(JavaParser.ArrayCreatorRestContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#arrayCreatorRest}. + * @param ctx the parse tree + */ + void exitArrayCreatorRest(JavaParser.ArrayCreatorRestContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#classCreatorRest}. + * @param ctx the parse tree + */ + void enterClassCreatorRest(JavaParser.ClassCreatorRestContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#classCreatorRest}. + * @param ctx the parse tree + */ + void exitClassCreatorRest(JavaParser.ClassCreatorRestContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#explicitGenericInvocation}. + * @param ctx the parse tree + */ + void enterExplicitGenericInvocation(JavaParser.ExplicitGenericInvocationContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#explicitGenericInvocation}. + * @param ctx the parse tree + */ + void exitExplicitGenericInvocation(JavaParser.ExplicitGenericInvocationContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#typeArgumentsOrDiamond}. + * @param ctx the parse tree + */ + void enterTypeArgumentsOrDiamond(JavaParser.TypeArgumentsOrDiamondContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#typeArgumentsOrDiamond}. + * @param ctx the parse tree + */ + void exitTypeArgumentsOrDiamond(JavaParser.TypeArgumentsOrDiamondContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#nonWildcardTypeArgumentsOrDiamond}. + * @param ctx the parse tree + */ + void enterNonWildcardTypeArgumentsOrDiamond(JavaParser.NonWildcardTypeArgumentsOrDiamondContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#nonWildcardTypeArgumentsOrDiamond}. + * @param ctx the parse tree + */ + void exitNonWildcardTypeArgumentsOrDiamond(JavaParser.NonWildcardTypeArgumentsOrDiamondContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#nonWildcardTypeArguments}. + * @param ctx the parse tree + */ + void enterNonWildcardTypeArguments(JavaParser.NonWildcardTypeArgumentsContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#nonWildcardTypeArguments}. + * @param ctx the parse tree + */ + void exitNonWildcardTypeArguments(JavaParser.NonWildcardTypeArgumentsContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#typeList}. + * @param ctx the parse tree + */ + void enterTypeList(JavaParser.TypeListContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#typeList}. + * @param ctx the parse tree + */ + void exitTypeList(JavaParser.TypeListContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#typeType}. + * @param ctx the parse tree + */ + void enterTypeType(JavaParser.TypeTypeContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#typeType}. + * @param ctx the parse tree + */ + void exitTypeType(JavaParser.TypeTypeContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#primitiveType}. + * @param ctx the parse tree + */ + void enterPrimitiveType(JavaParser.PrimitiveTypeContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#primitiveType}. + * @param ctx the parse tree + */ + void exitPrimitiveType(JavaParser.PrimitiveTypeContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#typeArguments}. + * @param ctx the parse tree + */ + void enterTypeArguments(JavaParser.TypeArgumentsContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#typeArguments}. + * @param ctx the parse tree + */ + void exitTypeArguments(JavaParser.TypeArgumentsContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#superSuffix}. + * @param ctx the parse tree + */ + void enterSuperSuffix(JavaParser.SuperSuffixContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#superSuffix}. + * @param ctx the parse tree + */ + void exitSuperSuffix(JavaParser.SuperSuffixContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#explicitGenericInvocationSuffix}. + * @param ctx the parse tree + */ + void enterExplicitGenericInvocationSuffix(JavaParser.ExplicitGenericInvocationSuffixContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#explicitGenericInvocationSuffix}. + * @param ctx the parse tree + */ + void exitExplicitGenericInvocationSuffix(JavaParser.ExplicitGenericInvocationSuffixContext ctx); + /** + * Enter a parse tree produced by {@link JavaParser#arguments}. + * @param ctx the parse tree + */ + void enterArguments(JavaParser.ArgumentsContext ctx); + /** + * Exit a parse tree produced by {@link JavaParser#arguments}. + * @param ctx the parse tree + */ + void exitArguments(JavaParser.ArgumentsContext ctx); +} \ No newline at end of file diff --git a/lexers/src/main/gen/com/itsaky/androidide/lexers/java/JavaParserVisitor.java b/lexers/src/main/gen/com/itsaky/androidide/lexers/java/JavaParserVisitor.java new file mode 100644 index 000000000..ca0d0a676 --- /dev/null +++ b/lexers/src/main/gen/com/itsaky/androidide/lexers/java/JavaParserVisitor.java @@ -0,0 +1,643 @@ +// Generated from /home/itsaky/Projects/Android/AndroidIDE/lexers/src/main/java/com/itsaky/androidide/lexers/java/JavaParser.g4 by ANTLR 4.10.1 +package com.itsaky.androidide.lexers.java; +import org.antlr.v4.runtime.tree.ParseTreeVisitor; + +/** + * This interface defines a complete generic visitor for a parse tree produced + * by {@link JavaParser}. + * + * @param The return type of the visit operation. Use {@link Void} for + * operations with no return type. + */ +public interface JavaParserVisitor extends ParseTreeVisitor { + /** + * Visit a parse tree produced by {@link JavaParser#compilationUnit}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitCompilationUnit(JavaParser.CompilationUnitContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#packageDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPackageDeclaration(JavaParser.PackageDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#importDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitImportDeclaration(JavaParser.ImportDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#typeDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeDeclaration(JavaParser.TypeDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#modifier}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitModifier(JavaParser.ModifierContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#classOrInterfaceModifier}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassOrInterfaceModifier(JavaParser.ClassOrInterfaceModifierContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#variableModifier}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitVariableModifier(JavaParser.VariableModifierContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#classDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassDeclaration(JavaParser.ClassDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#typeParameters}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeParameters(JavaParser.TypeParametersContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#typeParameter}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeParameter(JavaParser.TypeParameterContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#typeBound}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeBound(JavaParser.TypeBoundContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#enumDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumDeclaration(JavaParser.EnumDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#enumConstants}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumConstants(JavaParser.EnumConstantsContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#enumConstant}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumConstant(JavaParser.EnumConstantContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#enumBodyDeclarations}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumBodyDeclarations(JavaParser.EnumBodyDeclarationsContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#interfaceDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInterfaceDeclaration(JavaParser.InterfaceDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#classBody}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassBody(JavaParser.ClassBodyContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#interfaceBody}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInterfaceBody(JavaParser.InterfaceBodyContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#classBodyDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassBodyDeclaration(JavaParser.ClassBodyDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#memberDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMemberDeclaration(JavaParser.MemberDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#methodDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMethodDeclaration(JavaParser.MethodDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#methodBody}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMethodBody(JavaParser.MethodBodyContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#typeTypeOrVoid}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeTypeOrVoid(JavaParser.TypeTypeOrVoidContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#genericMethodDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitGenericMethodDeclaration(JavaParser.GenericMethodDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#genericConstructorDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitGenericConstructorDeclaration(JavaParser.GenericConstructorDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#constructorDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitConstructorDeclaration(JavaParser.ConstructorDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#fieldDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFieldDeclaration(JavaParser.FieldDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#interfaceBodyDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInterfaceBodyDeclaration(JavaParser.InterfaceBodyDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#interfaceMemberDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInterfaceMemberDeclaration(JavaParser.InterfaceMemberDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#constDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitConstDeclaration(JavaParser.ConstDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#constantDeclarator}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitConstantDeclarator(JavaParser.ConstantDeclaratorContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#interfaceMethodDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInterfaceMethodDeclaration(JavaParser.InterfaceMethodDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#interfaceMethodModifier}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInterfaceMethodModifier(JavaParser.InterfaceMethodModifierContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#genericInterfaceMethodDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitGenericInterfaceMethodDeclaration(JavaParser.GenericInterfaceMethodDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#variableDeclarators}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitVariableDeclarators(JavaParser.VariableDeclaratorsContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#variableDeclarator}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitVariableDeclarator(JavaParser.VariableDeclaratorContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#variableDeclaratorId}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitVariableDeclaratorId(JavaParser.VariableDeclaratorIdContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#variableInitializer}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitVariableInitializer(JavaParser.VariableInitializerContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#arrayInitializer}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitArrayInitializer(JavaParser.ArrayInitializerContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#classOrInterfaceType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassOrInterfaceType(JavaParser.ClassOrInterfaceTypeContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#typeArgument}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeArgument(JavaParser.TypeArgumentContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#qualifiedNameList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitQualifiedNameList(JavaParser.QualifiedNameListContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#formalParameters}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFormalParameters(JavaParser.FormalParametersContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#formalParameterList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFormalParameterList(JavaParser.FormalParameterListContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#formalParameter}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFormalParameter(JavaParser.FormalParameterContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#lastFormalParameter}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLastFormalParameter(JavaParser.LastFormalParameterContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#qualifiedName}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitQualifiedName(JavaParser.QualifiedNameContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#literal}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLiteral(JavaParser.LiteralContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#integerLiteral}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitIntegerLiteral(JavaParser.IntegerLiteralContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#floatLiteral}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFloatLiteral(JavaParser.FloatLiteralContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#altAnnotationQualifiedName}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAltAnnotationQualifiedName(JavaParser.AltAnnotationQualifiedNameContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#annotation}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAnnotation(JavaParser.AnnotationContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#elementValuePairs}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitElementValuePairs(JavaParser.ElementValuePairsContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#elementValuePair}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitElementValuePair(JavaParser.ElementValuePairContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#elementValue}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitElementValue(JavaParser.ElementValueContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#elementValueArrayInitializer}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitElementValueArrayInitializer(JavaParser.ElementValueArrayInitializerContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#annotationTypeDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAnnotationTypeDeclaration(JavaParser.AnnotationTypeDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#annotationTypeBody}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAnnotationTypeBody(JavaParser.AnnotationTypeBodyContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#annotationTypeElementDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAnnotationTypeElementDeclaration(JavaParser.AnnotationTypeElementDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#annotationTypeElementRest}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAnnotationTypeElementRest(JavaParser.AnnotationTypeElementRestContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#annotationMethodOrConstantRest}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAnnotationMethodOrConstantRest(JavaParser.AnnotationMethodOrConstantRestContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#annotationMethodRest}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAnnotationMethodRest(JavaParser.AnnotationMethodRestContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#annotationConstantRest}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitAnnotationConstantRest(JavaParser.AnnotationConstantRestContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#defaultValue}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitDefaultValue(JavaParser.DefaultValueContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#block}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitBlock(JavaParser.BlockContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#blockStatement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitBlockStatement(JavaParser.BlockStatementContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#localVariableDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLocalVariableDeclaration(JavaParser.LocalVariableDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#localTypeDeclaration}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLocalTypeDeclaration(JavaParser.LocalTypeDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#statement}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitStatement(JavaParser.StatementContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#catchClause}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitCatchClause(JavaParser.CatchClauseContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#catchType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitCatchType(JavaParser.CatchTypeContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#finallyBlock}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitFinallyBlock(JavaParser.FinallyBlockContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#resourceSpecification}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitResourceSpecification(JavaParser.ResourceSpecificationContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#resources}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitResources(JavaParser.ResourcesContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#resource}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitResource(JavaParser.ResourceContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#switchBlockStatementGroup}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSwitchBlockStatementGroup(JavaParser.SwitchBlockStatementGroupContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#switchLabel}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSwitchLabel(JavaParser.SwitchLabelContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#forControl}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitForControl(JavaParser.ForControlContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#forInit}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitForInit(JavaParser.ForInitContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#enhancedForControl}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnhancedForControl(JavaParser.EnhancedForControlContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#parExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitParExpression(JavaParser.ParExpressionContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#expressionList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitExpressionList(JavaParser.ExpressionListContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#methodCall}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitMethodCall(JavaParser.MethodCallContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#expression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitExpression(JavaParser.ExpressionContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#lambdaExpression}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLambdaExpression(JavaParser.LambdaExpressionContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#lambdaParameters}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLambdaParameters(JavaParser.LambdaParametersContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#lambdaBody}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitLambdaBody(JavaParser.LambdaBodyContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#primary}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPrimary(JavaParser.PrimaryContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#classType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassType(JavaParser.ClassTypeContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#creator}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitCreator(JavaParser.CreatorContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#createdName}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitCreatedName(JavaParser.CreatedNameContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#innerCreator}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitInnerCreator(JavaParser.InnerCreatorContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#arrayCreatorRest}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitArrayCreatorRest(JavaParser.ArrayCreatorRestContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#classCreatorRest}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassCreatorRest(JavaParser.ClassCreatorRestContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#explicitGenericInvocation}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitExplicitGenericInvocation(JavaParser.ExplicitGenericInvocationContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#typeArgumentsOrDiamond}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeArgumentsOrDiamond(JavaParser.TypeArgumentsOrDiamondContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#nonWildcardTypeArgumentsOrDiamond}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitNonWildcardTypeArgumentsOrDiamond(JavaParser.NonWildcardTypeArgumentsOrDiamondContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#nonWildcardTypeArguments}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitNonWildcardTypeArguments(JavaParser.NonWildcardTypeArgumentsContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#typeList}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeList(JavaParser.TypeListContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#typeType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeType(JavaParser.TypeTypeContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#primitiveType}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitPrimitiveType(JavaParser.PrimitiveTypeContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#typeArguments}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeArguments(JavaParser.TypeArgumentsContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#superSuffix}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitSuperSuffix(JavaParser.SuperSuffixContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#explicitGenericInvocationSuffix}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitExplicitGenericInvocationSuffix(JavaParser.ExplicitGenericInvocationSuffixContext ctx); + /** + * Visit a parse tree produced by {@link JavaParser#arguments}. + * @param ctx the parse tree + * @return the visitor result + */ + T visitArguments(JavaParser.ArgumentsContext ctx); +} \ No newline at end of file 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 index cfd8d38c9..ba162d7c0 100644 --- a/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Lexer.interp +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Lexer.interp @@ -475,4 +475,4 @@ 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 +[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 2, 147, 1462, 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, 3, 5, 7, 5, 395, 10, 5, 12, 5, 14, 5, 398, 11, 5, 3, 5, 5, 5, 401, 10, 5, 3, 6, 3, 6, 5, 6, 405, 10, 6, 3, 7, 3, 7, 3, 8, 3, 8, 3, 8, 3, 8, 5, 8, 413, 10, 8, 3, 9, 3, 9, 7, 9, 417, 10, 9, 12, 9, 14, 9, 420, 11, 9, 3, 9, 3, 9, 5, 9, 424, 10, 9, 3, 9, 6, 9, 427, 10, 9, 13, 9, 14, 9, 428, 3, 9, 6, 9, 432, 10, 9, 13, 9, 14, 9, 433, 3, 9, 3, 9, 3, 10, 3, 10, 7, 10, 440, 10, 10, 12, 10, 14, 10, 443, 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, 1031, 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, 1088, 10, 119, 3, 120, 3, 120, 3, 120, 3, 120, 5, 120, 1094, 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, 1144, 10, 134, 3, 135, 3, 135, 3, 135, 7, 135, 1149, 10, 135, 12, 135, 14, 135, 1152, 11, 135, 3, 136, 3, 136, 5, 136, 1156, 10, 136, 3, 137, 3, 137, 3, 138, 3, 138, 3, 139, 3, 139, 5, 139, 1164, 10, 139, 3, 139, 7, 139, 1167, 10, 139, 12, 139, 14, 139, 1170, 11, 139, 3, 140, 3, 140, 5, 140, 1174, 10, 140, 3, 140, 7, 140, 1177, 10, 140, 12, 140, 14, 140, 1180, 11, 140, 3, 141, 3, 141, 3, 141, 3, 141, 5, 141, 1186, 10, 141, 3, 141, 3, 141, 5, 141, 1190, 10, 141, 3, 141, 7, 141, 1193, 10, 141, 12, 141, 14, 141, 1196, 11, 141, 3, 142, 3, 142, 3, 142, 3, 142, 5, 142, 1202, 10, 142, 3, 142, 3, 142, 5, 142, 1206, 10, 142, 3, 142, 7, 142, 1209, 10, 142, 12, 142, 14, 142, 1212, 11, 142, 3, 143, 3, 143, 3, 144, 3, 144, 3, 145, 3, 145, 3, 146, 3, 146, 3, 147, 3, 147, 5, 147, 1224, 10, 147, 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, 5, 147, 1238, 10, 147, 3, 148, 3, 148, 3, 149, 3, 149, 3, 150, 3, 150, 3, 150, 3, 150, 5, 150, 1248, 10, 150, 3, 151, 3, 151, 3, 151, 5, 151, 1253, 10, 151, 3, 152, 3, 152, 3, 152, 5, 152, 1258, 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, 1281, 10, 153, 3, 153, 5, 153, 1284, 10, 153, 3, 153, 3, 153, 3, 153, 3, 153, 5, 153, 1290, 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, 1303, 10, 154, 3, 155, 3, 155, 3, 155, 3, 155, 6, 155, 1309, 10, 155, 13, 155, 14, 155, 1310, 3, 156, 5, 156, 1314, 10, 156, 3, 156, 3, 156, 3, 156, 3, 156, 3, 156, 5, 156, 1321, 10, 156, 3, 157, 3, 157, 5, 157, 1325, 10, 157, 3, 157, 3, 157, 3, 157, 5, 157, 1330, 10, 157, 3, 157, 5, 157, 1333, 10, 157, 3, 158, 3, 158, 3, 159, 3, 159, 5, 159, 1339, 10, 159, 3, 159, 7, 159, 1342, 10, 159, 12, 159, 14, 159, 1345, 11, 159, 3, 160, 3, 160, 3, 161, 3, 161, 3, 161, 5, 161, 1352, 10, 161, 3, 162, 3, 162, 3, 162, 5, 162, 1357, 10, 162, 3, 163, 3, 163, 3, 163, 3, 163, 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, 3, 163, 3, 163, 7, 163, 1381, 10, 163, 12, 163, 14, 163, 1384, 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, 1400, 10, 164, 3, 165, 3, 165, 5, 165, 1404, 10, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 5, 165, 1412, 10, 165, 3, 166, 3, 166, 3, 166, 3, 167, 3, 167, 3, 167, 3, 168, 3, 168, 3, 169, 6, 169, 1423, 10, 169, 13, 169, 14, 169, 1424, 3, 169, 3, 169, 3, 170, 3, 170, 5, 170, 1431, 10, 170, 3, 170, 5, 170, 1434, 10, 170, 3, 170, 3, 170, 3, 171, 3, 171, 3, 171, 3, 171, 7, 171, 1442, 10, 171, 12, 171, 14, 171, 1445, 11, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 172, 3, 172, 3, 172, 3, 172, 7, 172, 1456, 10, 172, 12, 172, 14, 172, 1459, 11, 172, 3, 172, 3, 172, 7, 418, 1366, 1373, 1382, 1443, 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, 22, 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, 4, 2, 36, 36, 42, 43, 6, 2, 12, 12, 15, 15, 34, 34, 42, 42, 3, 2, 43, 43, 6, 2, 12, 12, 15, 15, 34, 34, 36, 36, 4, 2, 11, 11, 34, 34, 4, 2, 12, 12, 15, 15, 2, 1530, 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, 389, 3, 2, 2, 2, 11, 404, 3, 2, 2, 2, 13, 406, 3, 2, 2, 2, 15, 412, 3, 2, 2, 2, 17, 414, 3, 2, 2, 2, 19, 437, 3, 2, 2, 2, 21, 446, 3, 2, 2, 2, 23, 454, 3, 2, 2, 2, 25, 462, 3, 2, 2, 2, 27, 466, 3, 2, 2, 2, 29, 471, 3, 2, 2, 2, 31, 476, 3, 2, 2, 2, 33, 482, 3, 2, 2, 2, 35, 487, 3, 2, 2, 2, 37, 493, 3, 2, 2, 2, 39, 498, 3, 2, 2, 2, 41, 507, 3, 2, 2, 2, 43, 516, 3, 2, 2, 2, 45, 522, 3, 2, 2, 2, 47, 528, 3, 2, 2, 2, 49, 538, 3, 2, 2, 2, 51, 549, 3, 2, 2, 2, 53, 558, 3, 2, 2, 2, 55, 567, 3, 2, 2, 2, 57, 575, 3, 2, 2, 2, 59, 582, 3, 2, 2, 2, 61, 585, 3, 2, 2, 2, 63, 592, 3, 2, 2, 2, 65, 605, 3, 2, 2, 2, 67, 610, 3, 2, 2, 2, 69, 615, 3, 2, 2, 2, 71, 624, 3, 2, 2, 2, 73, 631, 3, 2, 2, 2, 75, 638, 3, 2, 2, 2, 77, 644, 3, 2, 2, 2, 79, 650, 3, 2, 2, 2, 81, 656, 3, 2, 2, 2, 83, 660, 3, 2, 2, 2, 85, 667, 3, 2, 2, 2, 87, 672, 3, 2, 2, 2, 89, 675, 3, 2, 2, 2, 91, 682, 3, 2, 2, 2, 93, 686, 3, 2, 2, 2, 95, 691, 3, 2, 2, 2, 97, 699, 3, 2, 2, 2, 99, 709, 3, 2, 2, 2, 101, 713, 3, 2, 2, 2, 103, 722, 3, 2, 2, 2, 105, 730, 3, 2, 2, 2, 107, 739, 3, 2, 2, 2, 109, 748, 3, 2, 2, 2, 111, 756, 3, 2, 2, 2, 113, 766, 3, 2, 2, 2, 115, 773, 3, 2, 2, 2, 117, 782, 3, 2, 2, 2, 119, 799, 3, 2, 2, 2, 121, 806, 3, 2, 2, 2, 123, 812, 3, 2, 2, 2, 125, 819, 3, 2, 2, 2, 127, 826, 3, 2, 2, 2, 129, 833, 3, 2, 2, 2, 131, 847, 3, 2, 2, 2, 133, 859, 3, 2, 2, 2, 135, 866, 3, 2, 2, 2, 137, 873, 3, 2, 2, 2, 139, 882, 3, 2, 2, 2, 141, 887, 3, 2, 2, 2, 143, 900, 3, 2, 2, 2, 145, 906, 3, 2, 2, 2, 147, 911, 3, 2, 2, 2, 149, 915, 3, 2, 2, 2, 151, 923, 3, 2, 2, 2, 153, 930, 3, 2, 2, 2, 155, 939, 3, 2, 2, 2, 157, 945, 3, 2, 2, 2, 159, 954, 3, 2, 2, 2, 161, 960, 3, 2, 2, 2, 163, 968, 3, 2, 2, 2, 165, 973, 3, 2, 2, 2, 167, 982, 3, 2, 2, 2, 169, 990, 3, 2, 2, 2, 171, 996, 3, 2, 2, 2, 173, 998, 3, 2, 2, 2, 175, 1000, 3, 2, 2, 2, 177, 1002, 3, 2, 2, 2, 179, 1004, 3, 2, 2, 2, 181, 1006, 3, 2, 2, 2, 183, 1008, 3, 2, 2, 2, 185, 1010, 3, 2, 2, 2, 187, 1012, 3, 2, 2, 2, 189, 1014, 3, 2, 2, 2, 191, 1016, 3, 2, 2, 2, 193, 1018, 3, 2, 2, 2, 195, 1020, 3, 2, 2, 2, 197, 1022, 3, 2, 2, 2, 199, 1024, 3, 2, 2, 2, 201, 1030, 3, 2, 2, 2, 203, 1032, 3, 2, 2, 2, 205, 1034, 3, 2, 2, 2, 207, 1036, 3, 2, 2, 2, 209, 1038, 3, 2, 2, 2, 211, 1041, 3, 2, 2, 2, 213, 1044, 3, 2, 2, 2, 215, 1047, 3, 2, 2, 2, 217, 1050, 3, 2, 2, 2, 219, 1053, 3, 2, 2, 2, 221, 1056, 3, 2, 2, 2, 223, 1059, 3, 2, 2, 2, 225, 1062, 3, 2, 2, 2, 227, 1066, 3, 2, 2, 2, 229, 1070, 3, 2, 2, 2, 231, 1073, 3, 2, 2, 2, 233, 1076, 3, 2, 2, 2, 235, 1079, 3, 2, 2, 2, 237, 1087, 3, 2, 2, 2, 239, 1093, 3, 2, 2, 2, 241, 1095, 3, 2, 2, 2, 243, 1098, 3, 2, 2, 2, 245, 1101, 3, 2, 2, 2, 247, 1103, 3, 2, 2, 2, 249, 1107, 3, 2, 2, 2, 251, 1110, 3, 2, 2, 2, 253, 1112, 3, 2, 2, 2, 255, 1114, 3, 2, 2, 2, 257, 1117, 3, 2, 2, 2, 259, 1119, 3, 2, 2, 2, 261, 1121, 3, 2, 2, 2, 263, 1124, 3, 2, 2, 2, 265, 1128, 3, 2, 2, 2, 267, 1143, 3, 2, 2, 2, 269, 1145, 3, 2, 2, 2, 271, 1155, 3, 2, 2, 2, 273, 1157, 3, 2, 2, 2, 275, 1159, 3, 2, 2, 2, 277, 1161, 3, 2, 2, 2, 279, 1171, 3, 2, 2, 2, 281, 1185, 3, 2, 2, 2, 283, 1201, 3, 2, 2, 2, 285, 1213, 3, 2, 2, 2, 287, 1215, 3, 2, 2, 2, 289, 1217, 3, 2, 2, 2, 291, 1219, 3, 2, 2, 2, 293, 1237, 3, 2, 2, 2, 295, 1239, 3, 2, 2, 2, 297, 1241, 3, 2, 2, 2, 299, 1247, 3, 2, 2, 2, 301, 1252, 3, 2, 2, 2, 303, 1257, 3, 2, 2, 2, 305, 1289, 3, 2, 2, 2, 307, 1302, 3, 2, 2, 2, 309, 1304, 3, 2, 2, 2, 311, 1320, 3, 2, 2, 2, 313, 1332, 3, 2, 2, 2, 315, 1334, 3, 2, 2, 2, 317, 1336, 3, 2, 2, 2, 319, 1346, 3, 2, 2, 2, 321, 1351, 3, 2, 2, 2, 323, 1356, 3, 2, 2, 2, 325, 1358, 3, 2, 2, 2, 327, 1399, 3, 2, 2, 2, 329, 1411, 3, 2, 2, 2, 331, 1413, 3, 2, 2, 2, 333, 1416, 3, 2, 2, 2, 335, 1419, 3, 2, 2, 2, 337, 1422, 3, 2, 2, 2, 339, 1433, 3, 2, 2, 2, 341, 1437, 3, 2, 2, 2, 343, 1451, 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, 400, 3, 2, 2, 2, 391, 401, 5, 325, 163, 2, 392, 396, 7, 36, 2, 2, 393, 395, 5, 323, 162, 2, 394, 393, 3, 2, 2, 2, 395, 398, 3, 2, 2, 2, 396, 394, 3, 2, 2, 2, 396, 397, 3, 2, 2, 2, 397, 399, 3, 2, 2, 2, 398, 396, 3, 2, 2, 2, 399, 401, 7, 36, 2, 2, 400, 391, 3, 2, 2, 2, 400, 392, 3, 2, 2, 2, 401, 10, 3, 2, 2, 2, 402, 405, 5, 75, 38, 2, 403, 405, 5, 145, 73, 2, 404, 402, 3, 2, 2, 2, 404, 403, 3, 2, 2, 2, 405, 12, 3, 2, 2, 2, 406, 407, 5, 103, 52, 2, 407, 14, 3, 2, 2, 2, 408, 413, 5, 327, 164, 2, 409, 413, 5, 329, 165, 2, 410, 413, 5, 331, 166, 2, 411, 413, 5, 333, 167, 2, 412, 408, 3, 2, 2, 2, 412, 409, 3, 2, 2, 2, 412, 410, 3, 2, 2, 2, 412, 411, 3, 2, 2, 2, 413, 16, 3, 2, 2, 2, 414, 426, 7, 37, 2, 2, 415, 417, 10, 3, 2, 2, 416, 415, 3, 2, 2, 2, 417, 420, 3, 2, 2, 2, 418, 419, 3, 2, 2, 2, 418, 416, 3, 2, 2, 2, 419, 421, 3, 2, 2, 2, 420, 418, 3, 2, 2, 2, 421, 423, 7, 94, 2, 2, 422, 424, 7, 15, 2, 2, 423, 422, 3, 2, 2, 2, 423, 424, 3, 2, 2, 2, 424, 425, 3, 2, 2, 2, 425, 427, 7, 12, 2, 2, 426, 418, 3, 2, 2, 2, 427, 428, 3, 2, 2, 2, 428, 426, 3, 2, 2, 2, 428, 429, 3, 2, 2, 2, 429, 431, 3, 2, 2, 2, 430, 432, 10, 3, 2, 2, 431, 430, 3, 2, 2, 2, 432, 433, 3, 2, 2, 2, 433, 431, 3, 2, 2, 2, 433, 434, 3, 2, 2, 2, 434, 435, 3, 2, 2, 2, 435, 436, 8, 9, 2, 2, 436, 18, 3, 2, 2, 2, 437, 441, 7, 37, 2, 2, 438, 440, 10, 3, 2, 2, 439, 438, 3, 2, 2, 2, 440, 443, 3, 2, 2, 2, 441, 439, 3, 2, 2, 2, 441, 442, 3, 2, 2, 2, 442, 444, 3, 2, 2, 2, 443, 441, 3, 2, 2, 2, 444, 445, 8, 10, 2, 2, 445, 20, 3, 2, 2, 2, 446, 447, 7, 99, 2, 2, 447, 448, 7, 110, 2, 2, 448, 449, 7, 107, 2, 2, 449, 450, 7, 105, 2, 2, 450, 451, 7, 112, 2, 2, 451, 452, 7, 99, 2, 2, 452, 453, 7, 117, 2, 2, 453, 22, 3, 2, 2, 2, 454, 455, 7, 99, 2, 2, 455, 456, 7, 110, 2, 2, 456, 457, 7, 107, 2, 2, 457, 458, 7, 105, 2, 2, 458, 459, 7, 112, 2, 2, 459, 460, 7, 113, 2, 2, 460, 461, 7, 104, 2, 2, 461, 24, 3, 2, 2, 2, 462, 463, 7, 99, 2, 2, 463, 464, 7, 117, 2, 2, 464, 465, 7, 111, 2, 2, 465, 26, 3, 2, 2, 2, 466, 467, 7, 99, 2, 2, 467, 468, 7, 119, 2, 2, 468, 469, 7, 118, 2, 2, 469, 470, 7, 113, 2, 2, 470, 28, 3, 2, 2, 2, 471, 472, 7, 100, 2, 2, 472, 473, 7, 113, 2, 2, 473, 474, 7, 113, 2, 2, 474, 475, 7, 110, 2, 2, 475, 30, 3, 2, 2, 2, 476, 477, 7, 100, 2, 2, 477, 478, 7, 116, 2, 2, 478, 479, 7, 103, 2, 2, 479, 480, 7, 99, 2, 2, 480, 481, 7, 109, 2, 2, 481, 32, 3, 2, 2, 2, 482, 483, 7, 101, 2, 2, 483, 484, 7, 99, 2, 2, 484, 485, 7, 117, 2, 2, 485, 486, 7, 103, 2, 2, 486, 34, 3, 2, 2, 2, 487, 488, 7, 101, 2, 2, 488, 489, 7, 99, 2, 2, 489, 490, 7, 118, 2, 2, 490, 491, 7, 101, 2, 2, 491, 492, 7, 106, 2, 2, 492, 36, 3, 2, 2, 2, 493, 494, 7, 101, 2, 2, 494, 495, 7, 106, 2, 2, 495, 496, 7, 99, 2, 2, 496, 497, 7, 116, 2, 2, 497, 38, 3, 2, 2, 2, 498, 499, 7, 101, 2, 2, 499, 500, 7, 106, 2, 2, 500, 501, 7, 99, 2, 2, 501, 502, 7, 116, 2, 2, 502, 503, 7, 51, 2, 2, 503, 504, 7, 56, 2, 2, 504, 505, 7, 97, 2, 2, 505, 506, 7, 118, 2, 2, 506, 40, 3, 2, 2, 2, 507, 508, 7, 101, 2, 2, 508, 509, 7, 106, 2, 2, 509, 510, 7, 99, 2, 2, 510, 511, 7, 116, 2, 2, 511, 512, 7, 53, 2, 2, 512, 513, 7, 52, 2, 2, 513, 514, 7, 97, 2, 2, 514, 515, 7, 118, 2, 2, 515, 42, 3, 2, 2, 2, 516, 517, 7, 101, 2, 2, 517, 518, 7, 110, 2, 2, 518, 519, 7, 99, 2, 2, 519, 520, 7, 117, 2, 2, 520, 521, 7, 117, 2, 2, 521, 44, 3, 2, 2, 2, 522, 523, 7, 101, 2, 2, 523, 524, 7, 113, 2, 2, 524, 525, 7, 112, 2, 2, 525, 526, 7, 117, 2, 2, 526, 527, 7, 118, 2, 2, 527, 46, 3, 2, 2, 2, 528, 529, 7, 101, 2, 2, 529, 530, 7, 113, 2, 2, 530, 531, 7, 112, 2, 2, 531, 532, 7, 117, 2, 2, 532, 533, 7, 118, 2, 2, 533, 534, 7, 103, 2, 2, 534, 535, 7, 122, 2, 2, 535, 536, 7, 114, 2, 2, 536, 537, 7, 116, 2, 2, 537, 48, 3, 2, 2, 2, 538, 539, 7, 101, 2, 2, 539, 540, 7, 113, 2, 2, 540, 541, 7, 112, 2, 2, 541, 542, 7, 117, 2, 2, 542, 543, 7, 118, 2, 2, 543, 544, 7, 97, 2, 2, 544, 545, 7, 101, 2, 2, 545, 546, 7, 99, 2, 2, 546, 547, 7, 117, 2, 2, 547, 548, 7, 118, 2, 2, 548, 50, 3, 2, 2, 2, 549, 550, 7, 101, 2, 2, 550, 551, 7, 113, 2, 2, 551, 552, 7, 112, 2, 2, 552, 553, 7, 118, 2, 2, 553, 554, 7, 107, 2, 2, 554, 555, 7, 112, 2, 2, 555, 556, 7, 119, 2, 2, 556, 557, 7, 103, 2, 2, 557, 52, 3, 2, 2, 2, 558, 559, 7, 102, 2, 2, 559, 560, 7, 103, 2, 2, 560, 561, 7, 101, 2, 2, 561, 562, 7, 110, 2, 2, 562, 563, 7, 118, 2, 2, 563, 564, 7, 123, 2, 2, 564, 565, 7, 114, 2, 2, 565, 566, 7, 103, 2, 2, 566, 54, 3, 2, 2, 2, 567, 568, 7, 102, 2, 2, 568, 569, 7, 103, 2, 2, 569, 570, 7, 104, 2, 2, 570, 571, 7, 99, 2, 2, 571, 572, 7, 119, 2, 2, 572, 573, 7, 110, 2, 2, 573, 574, 7, 118, 2, 2, 574, 56, 3, 2, 2, 2, 575, 576, 7, 102, 2, 2, 576, 577, 7, 103, 2, 2, 577, 578, 7, 110, 2, 2, 578, 579, 7, 103, 2, 2, 579, 580, 7, 118, 2, 2, 580, 581, 7, 103, 2, 2, 581, 58, 3, 2, 2, 2, 582, 583, 7, 102, 2, 2, 583, 584, 7, 113, 2, 2, 584, 60, 3, 2, 2, 2, 585, 586, 7, 102, 2, 2, 586, 587, 7, 113, 2, 2, 587, 588, 7, 119, 2, 2, 588, 589, 7, 100, 2, 2, 589, 590, 7, 110, 2, 2, 590, 591, 7, 103, 2, 2, 591, 62, 3, 2, 2, 2, 592, 593, 7, 102, 2, 2, 593, 594, 7, 123, 2, 2, 594, 595, 7, 112, 2, 2, 595, 596, 7, 99, 2, 2, 596, 597, 7, 111, 2, 2, 597, 598, 7, 107, 2, 2, 598, 599, 7, 101, 2, 2, 599, 600, 7, 97, 2, 2, 600, 601, 7, 101, 2, 2, 601, 602, 7, 99, 2, 2, 602, 603, 7, 117, 2, 2, 603, 604, 7, 118, 2, 2, 604, 64, 3, 2, 2, 2, 605, 606, 7, 103, 2, 2, 606, 607, 7, 110, 2, 2, 607, 608, 7, 117, 2, 2, 608, 609, 7, 103, 2, 2, 609, 66, 3, 2, 2, 2, 610, 611, 7, 103, 2, 2, 611, 612, 7, 112, 2, 2, 612, 613, 7, 119, 2, 2, 613, 614, 7, 111, 2, 2, 614, 68, 3, 2, 2, 2, 615, 616, 7, 103, 2, 2, 616, 617, 7, 122, 2, 2, 617, 618, 7, 114, 2, 2, 618, 619, 7, 110, 2, 2, 619, 620, 7, 107, 2, 2, 620, 621, 7, 101, 2, 2, 621, 622, 7, 107, 2, 2, 622, 623, 7, 118, 2, 2, 623, 70, 3, 2, 2, 2, 624, 625, 7, 103, 2, 2, 625, 626, 7, 122, 2, 2, 626, 627, 7, 114, 2, 2, 627, 628, 7, 113, 2, 2, 628, 629, 7, 116, 2, 2, 629, 630, 7, 118, 2, 2, 630, 72, 3, 2, 2, 2, 631, 632, 7, 103, 2, 2, 632, 633, 7, 122, 2, 2, 633, 634, 7, 118, 2, 2, 634, 635, 7, 103, 2, 2, 635, 636, 7, 116, 2, 2, 636, 637, 7, 112, 2, 2, 637, 74, 3, 2, 2, 2, 638, 639, 7, 104, 2, 2, 639, 640, 7, 99, 2, 2, 640, 641, 7, 110, 2, 2, 641, 642, 7, 117, 2, 2, 642, 643, 7, 103, 2, 2, 643, 76, 3, 2, 2, 2, 644, 645, 7, 104, 2, 2, 645, 646, 7, 107, 2, 2, 646, 647, 7, 112, 2, 2, 647, 648, 7, 99, 2, 2, 648, 649, 7, 110, 2, 2, 649, 78, 3, 2, 2, 2, 650, 651, 7, 104, 2, 2, 651, 652, 7, 110, 2, 2, 652, 653, 7, 113, 2, 2, 653, 654, 7, 99, 2, 2, 654, 655, 7, 118, 2, 2, 655, 80, 3, 2, 2, 2, 656, 657, 7, 104, 2, 2, 657, 658, 7, 113, 2, 2, 658, 659, 7, 116, 2, 2, 659, 82, 3, 2, 2, 2, 660, 661, 7, 104, 2, 2, 661, 662, 7, 116, 2, 2, 662, 663, 7, 107, 2, 2, 663, 664, 7, 103, 2, 2, 664, 665, 7, 112, 2, 2, 665, 666, 7, 102, 2, 2, 666, 84, 3, 2, 2, 2, 667, 668, 7, 105, 2, 2, 668, 669, 7, 113, 2, 2, 669, 670, 7, 118, 2, 2, 670, 671, 7, 113, 2, 2, 671, 86, 3, 2, 2, 2, 672, 673, 7, 107, 2, 2, 673, 674, 7, 104, 2, 2, 674, 88, 3, 2, 2, 2, 675, 676, 7, 107, 2, 2, 676, 677, 7, 112, 2, 2, 677, 678, 7, 110, 2, 2, 678, 679, 7, 107, 2, 2, 679, 680, 7, 112, 2, 2, 680, 681, 7, 103, 2, 2, 681, 90, 3, 2, 2, 2, 682, 683, 7, 107, 2, 2, 683, 684, 7, 112, 2, 2, 684, 685, 7, 118, 2, 2, 685, 92, 3, 2, 2, 2, 686, 687, 7, 110, 2, 2, 687, 688, 7, 113, 2, 2, 688, 689, 7, 112, 2, 2, 689, 690, 7, 105, 2, 2, 690, 94, 3, 2, 2, 2, 691, 692, 7, 111, 2, 2, 692, 693, 7, 119, 2, 2, 693, 694, 7, 118, 2, 2, 694, 695, 7, 99, 2, 2, 695, 696, 7, 100, 2, 2, 696, 697, 7, 110, 2, 2, 697, 698, 7, 103, 2, 2, 698, 96, 3, 2, 2, 2, 699, 700, 7, 112, 2, 2, 700, 701, 7, 99, 2, 2, 701, 702, 7, 111, 2, 2, 702, 703, 7, 103, 2, 2, 703, 704, 7, 117, 2, 2, 704, 705, 7, 114, 2, 2, 705, 706, 7, 99, 2, 2, 706, 707, 7, 101, 2, 2, 707, 708, 7, 103, 2, 2, 708, 98, 3, 2, 2, 2, 709, 710, 7, 112, 2, 2, 710, 711, 7, 103, 2, 2, 711, 712, 7, 121, 2, 2, 712, 100, 3, 2, 2, 2, 713, 714, 7, 112, 2, 2, 714, 715, 7, 113, 2, 2, 715, 716, 7, 103, 2, 2, 716, 717, 7, 122, 2, 2, 717, 718, 7, 101, 2, 2, 718, 719, 7, 103, 2, 2, 719, 720, 7, 114, 2, 2, 720, 721, 7, 118, 2, 2, 721, 102, 3, 2, 2, 2, 722, 723, 7, 112, 2, 2, 723, 724, 7, 119, 2, 2, 724, 725, 7, 110, 2, 2, 725, 726, 7, 110, 2, 2, 726, 727, 7, 114, 2, 2, 727, 728, 7, 118, 2, 2, 728, 729, 7, 116, 2, 2, 729, 104, 3, 2, 2, 2, 730, 731, 7, 113, 2, 2, 731, 732, 7, 114, 2, 2, 732, 733, 7, 103, 2, 2, 733, 734, 7, 116, 2, 2, 734, 735, 7, 99, 2, 2, 735, 736, 7, 118, 2, 2, 736, 737, 7, 113, 2, 2, 737, 738, 7, 116, 2, 2, 738, 106, 3, 2, 2, 2, 739, 740, 7, 113, 2, 2, 740, 741, 7, 120, 2, 2, 741, 742, 7, 103, 2, 2, 742, 743, 7, 116, 2, 2, 743, 744, 7, 116, 2, 2, 744, 745, 7, 107, 2, 2, 745, 746, 7, 102, 2, 2, 746, 747, 7, 103, 2, 2, 747, 108, 3, 2, 2, 2, 748, 749, 7, 114, 2, 2, 749, 750, 7, 116, 2, 2, 750, 751, 7, 107, 2, 2, 751, 752, 7, 120, 2, 2, 752, 753, 7, 99, 2, 2, 753, 754, 7, 118, 2, 2, 754, 755, 7, 103, 2, 2, 755, 110, 3, 2, 2, 2, 756, 757, 7, 114, 2, 2, 757, 758, 7, 116, 2, 2, 758, 759, 7, 113, 2, 2, 759, 760, 7, 118, 2, 2, 760, 761, 7, 103, 2, 2, 761, 762, 7, 101, 2, 2, 762, 763, 7, 118, 2, 2, 763, 764, 7, 103, 2, 2, 764, 765, 7, 102, 2, 2, 765, 112, 3, 2, 2, 2, 766, 767, 7, 114, 2, 2, 767, 768, 7, 119, 2, 2, 768, 769, 7, 100, 2, 2, 769, 770, 7, 110, 2, 2, 770, 771, 7, 107, 2, 2, 771, 772, 7, 101, 2, 2, 772, 114, 3, 2, 2, 2, 773, 774, 7, 116, 2, 2, 774, 775, 7, 103, 2, 2, 775, 776, 7, 105, 2, 2, 776, 777, 7, 107, 2, 2, 777, 778, 7, 117, 2, 2, 778, 779, 7, 118, 2, 2, 779, 780, 7, 103, 2, 2, 780, 781, 7, 116, 2, 2, 781, 116, 3, 2, 2, 2, 782, 783, 7, 116, 2, 2, 783, 784, 7, 103, 2, 2, 784, 785, 7, 107, 2, 2, 785, 786, 7, 112, 2, 2, 786, 787, 7, 118, 2, 2, 787, 788, 7, 103, 2, 2, 788, 789, 7, 116, 2, 2, 789, 790, 7, 114, 2, 2, 790, 791, 7, 116, 2, 2, 791, 792, 7, 103, 2, 2, 792, 793, 7, 118, 2, 2, 793, 794, 7, 97, 2, 2, 794, 795, 7, 101, 2, 2, 795, 796, 7, 99, 2, 2, 796, 797, 7, 117, 2, 2, 797, 798, 7, 118, 2, 2, 798, 118, 3, 2, 2, 2, 799, 800, 7, 116, 2, 2, 800, 801, 7, 103, 2, 2, 801, 802, 7, 118, 2, 2, 802, 803, 7, 119, 2, 2, 803, 804, 7, 116, 2, 2, 804, 805, 7, 112, 2, 2, 805, 120, 3, 2, 2, 2, 806, 807, 7, 117, 2, 2, 807, 808, 7, 106, 2, 2, 808, 809, 7, 113, 2, 2, 809, 810, 7, 116, 2, 2, 810, 811, 7, 118, 2, 2, 811, 122, 3, 2, 2, 2, 812, 813, 7, 117, 2, 2, 813, 814, 7, 107, 2, 2, 814, 815, 7, 105, 2, 2, 815, 816, 7, 112, 2, 2, 816, 817, 7, 103, 2, 2, 817, 818, 7, 102, 2, 2, 818, 124, 3, 2, 2, 2, 819, 820, 7, 117, 2, 2, 820, 821, 7, 107, 2, 2, 821, 822, 7, 124, 2, 2, 822, 823, 7, 103, 2, 2, 823, 824, 7, 113, 2, 2, 824, 825, 7, 104, 2, 2, 825, 126, 3, 2, 2, 2, 826, 827, 7, 117, 2, 2, 827, 828, 7, 118, 2, 2, 828, 829, 7, 99, 2, 2, 829, 830, 7, 118, 2, 2, 830, 831, 7, 107, 2, 2, 831, 832, 7, 101, 2, 2, 832, 128, 3, 2, 2, 2, 833, 834, 7, 117, 2, 2, 834, 835, 7, 118, 2, 2, 835, 836, 7, 99, 2, 2, 836, 837, 7, 118, 2, 2, 837, 838, 7, 107, 2, 2, 838, 839, 7, 101, 2, 2, 839, 840, 7, 97, 2, 2, 840, 841, 7, 99, 2, 2, 841, 842, 7, 117, 2, 2, 842, 843, 7, 117, 2, 2, 843, 844, 7, 103, 2, 2, 844, 845, 7, 116, 2, 2, 845, 846, 7, 118, 2, 2, 846, 130, 3, 2, 2, 2, 847, 848, 7, 117, 2, 2, 848, 849, 7, 118, 2, 2, 849, 850, 7, 99, 2, 2, 850, 851, 7, 118, 2, 2, 851, 852, 7, 107, 2, 2, 852, 853, 7, 101, 2, 2, 853, 854, 7, 97, 2, 2, 854, 855, 7, 101, 2, 2, 855, 856, 7, 99, 2, 2, 856, 857, 7, 117, 2, 2, 857, 858, 7, 118, 2, 2, 858, 132, 3, 2, 2, 2, 859, 860, 7, 117, 2, 2, 860, 861, 7, 118, 2, 2, 861, 862, 7, 116, 2, 2, 862, 863, 7, 119, 2, 2, 863, 864, 7, 101, 2, 2, 864, 865, 7, 118, 2, 2, 865, 134, 3, 2, 2, 2, 866, 867, 7, 117, 2, 2, 867, 868, 7, 121, 2, 2, 868, 869, 7, 107, 2, 2, 869, 870, 7, 118, 2, 2, 870, 871, 7, 101, 2, 2, 871, 872, 7, 106, 2, 2, 872, 136, 3, 2, 2, 2, 873, 874, 7, 118, 2, 2, 874, 875, 7, 103, 2, 2, 875, 876, 7, 111, 2, 2, 876, 877, 7, 114, 2, 2, 877, 878, 7, 110, 2, 2, 878, 879, 7, 99, 2, 2, 879, 880, 7, 118, 2, 2, 880, 881, 7, 103, 2, 2, 881, 138, 3, 2, 2, 2, 882, 883, 7, 118, 2, 2, 883, 884, 7, 106, 2, 2, 884, 885, 7, 107, 2, 2, 885, 886, 7, 117, 2, 2, 886, 140, 3, 2, 2, 2, 887, 888, 7, 118, 2, 2, 888, 889, 7, 106, 2, 2, 889, 890, 7, 116, 2, 2, 890, 891, 7, 103, 2, 2, 891, 892, 7, 99, 2, 2, 892, 893, 7, 102, 2, 2, 893, 894, 7, 97, 2, 2, 894, 895, 7, 110, 2, 2, 895, 896, 7, 113, 2, 2, 896, 897, 7, 101, 2, 2, 897, 898, 7, 99, 2, 2, 898, 899, 7, 110, 2, 2, 899, 142, 3, 2, 2, 2, 900, 901, 7, 118, 2, 2, 901, 902, 7, 106, 2, 2, 902, 903, 7, 116, 2, 2, 903, 904, 7, 113, 2, 2, 904, 905, 7, 121, 2, 2, 905, 144, 3, 2, 2, 2, 906, 907, 7, 118, 2, 2, 907, 908, 7, 116, 2, 2, 908, 909, 7, 119, 2, 2, 909, 910, 7, 103, 2, 2, 910, 146, 3, 2, 2, 2, 911, 912, 7, 118, 2, 2, 912, 913, 7, 116, 2, 2, 913, 914, 7, 123, 2, 2, 914, 148, 3, 2, 2, 2, 915, 916, 7, 118, 2, 2, 916, 917, 7, 123, 2, 2, 917, 918, 7, 114, 2, 2, 918, 919, 7, 103, 2, 2, 919, 920, 7, 102, 2, 2, 920, 921, 7, 103, 2, 2, 921, 922, 7, 104, 2, 2, 922, 150, 3, 2, 2, 2, 923, 924, 7, 118, 2, 2, 924, 925, 7, 123, 2, 2, 925, 926, 7, 114, 2, 2, 926, 927, 7, 103, 2, 2, 927, 928, 7, 107, 2, 2, 928, 929, 7, 102, 2, 2, 929, 152, 3, 2, 2, 2, 930, 931, 7, 118, 2, 2, 931, 932, 7, 123, 2, 2, 932, 933, 7, 114, 2, 2, 933, 934, 7, 103, 2, 2, 934, 935, 7, 112, 2, 2, 935, 936, 7, 99, 2, 2, 936, 937, 7, 111, 2, 2, 937, 938, 7, 103, 2, 2, 938, 154, 3, 2, 2, 2, 939, 940, 7, 119, 2, 2, 940, 941, 7, 112, 2, 2, 941, 942, 7, 107, 2, 2, 942, 943, 7, 113, 2, 2, 943, 944, 7, 112, 2, 2, 944, 156, 3, 2, 2, 2, 945, 946, 7, 119, 2, 2, 946, 947, 7, 112, 2, 2, 947, 948, 7, 117, 2, 2, 948, 949, 7, 107, 2, 2, 949, 950, 7, 105, 2, 2, 950, 951, 7, 112, 2, 2, 951, 952, 7, 103, 2, 2, 952, 953, 7, 102, 2, 2, 953, 158, 3, 2, 2, 2, 954, 955, 7, 119, 2, 2, 955, 956, 7, 117, 2, 2, 956, 957, 7, 107, 2, 2, 957, 958, 7, 112, 2, 2, 958, 959, 7, 105, 2, 2, 959, 160, 3, 2, 2, 2, 960, 961, 7, 120, 2, 2, 961, 962, 7, 107, 2, 2, 962, 963, 7, 116, 2, 2, 963, 964, 7, 118, 2, 2, 964, 965, 7, 119, 2, 2, 965, 966, 7, 99, 2, 2, 966, 967, 7, 110, 2, 2, 967, 162, 3, 2, 2, 2, 968, 969, 7, 120, 2, 2, 969, 970, 7, 113, 2, 2, 970, 971, 7, 107, 2, 2, 971, 972, 7, 102, 2, 2, 972, 164, 3, 2, 2, 2, 973, 974, 7, 120, 2, 2, 974, 975, 7, 113, 2, 2, 975, 976, 7, 110, 2, 2, 976, 977, 7, 99, 2, 2, 977, 978, 7, 118, 2, 2, 978, 979, 7, 107, 2, 2, 979, 980, 7, 110, 2, 2, 980, 981, 7, 103, 2, 2, 981, 166, 3, 2, 2, 2, 982, 983, 7, 121, 2, 2, 983, 984, 7, 101, 2, 2, 984, 985, 7, 106, 2, 2, 985, 986, 7, 99, 2, 2, 986, 987, 7, 116, 2, 2, 987, 988, 7, 97, 2, 2, 988, 989, 7, 118, 2, 2, 989, 168, 3, 2, 2, 2, 990, 991, 7, 121, 2, 2, 991, 992, 7, 106, 2, 2, 992, 993, 7, 107, 2, 2, 993, 994, 7, 110, 2, 2, 994, 995, 7, 103, 2, 2, 995, 170, 3, 2, 2, 2, 996, 997, 7, 42, 2, 2, 997, 172, 3, 2, 2, 2, 998, 999, 7, 43, 2, 2, 999, 174, 3, 2, 2, 2, 1000, 1001, 7, 93, 2, 2, 1001, 176, 3, 2, 2, 2, 1002, 1003, 7, 95, 2, 2, 1003, 178, 3, 2, 2, 2, 1004, 1005, 7, 125, 2, 2, 1005, 180, 3, 2, 2, 2, 1006, 1007, 7, 127, 2, 2, 1007, 182, 3, 2, 2, 2, 1008, 1009, 7, 45, 2, 2, 1009, 184, 3, 2, 2, 2, 1010, 1011, 7, 47, 2, 2, 1011, 186, 3, 2, 2, 2, 1012, 1013, 7, 44, 2, 2, 1013, 188, 3, 2, 2, 2, 1014, 1015, 7, 49, 2, 2, 1015, 190, 3, 2, 2, 2, 1016, 1017, 7, 39, 2, 2, 1017, 192, 3, 2, 2, 2, 1018, 1019, 7, 96, 2, 2, 1019, 194, 3, 2, 2, 2, 1020, 1021, 7, 40, 2, 2, 1021, 196, 3, 2, 2, 2, 1022, 1023, 7, 126, 2, 2, 1023, 198, 3, 2, 2, 2, 1024, 1025, 7, 128, 2, 2, 1025, 200, 3, 2, 2, 2, 1026, 1031, 7, 35, 2, 2, 1027, 1028, 7, 112, 2, 2, 1028, 1029, 7, 113, 2, 2, 1029, 1031, 7, 118, 2, 2, 1030, 1026, 3, 2, 2, 2, 1030, 1027, 3, 2, 2, 2, 1031, 202, 3, 2, 2, 2, 1032, 1033, 7, 63, 2, 2, 1033, 204, 3, 2, 2, 2, 1034, 1035, 7, 62, 2, 2, 1035, 206, 3, 2, 2, 2, 1036, 1037, 7, 64, 2, 2, 1037, 208, 3, 2, 2, 2, 1038, 1039, 7, 45, 2, 2, 1039, 1040, 7, 63, 2, 2, 1040, 210, 3, 2, 2, 2, 1041, 1042, 7, 47, 2, 2, 1042, 1043, 7, 63, 2, 2, 1043, 212, 3, 2, 2, 2, 1044, 1045, 7, 44, 2, 2, 1045, 1046, 7, 63, 2, 2, 1046, 214, 3, 2, 2, 2, 1047, 1048, 7, 49, 2, 2, 1048, 1049, 7, 63, 2, 2, 1049, 216, 3, 2, 2, 2, 1050, 1051, 7, 39, 2, 2, 1051, 1052, 7, 63, 2, 2, 1052, 218, 3, 2, 2, 2, 1053, 1054, 7, 96, 2, 2, 1054, 1055, 7, 63, 2, 2, 1055, 220, 3, 2, 2, 2, 1056, 1057, 7, 40, 2, 2, 1057, 1058, 7, 63, 2, 2, 1058, 222, 3, 2, 2, 2, 1059, 1060, 7, 126, 2, 2, 1060, 1061, 7, 63, 2, 2, 1061, 224, 3, 2, 2, 2, 1062, 1063, 7, 62, 2, 2, 1063, 1064, 7, 62, 2, 2, 1064, 1065, 7, 63, 2, 2, 1065, 226, 3, 2, 2, 2, 1066, 1067, 7, 64, 2, 2, 1067, 1068, 7, 64, 2, 2, 1068, 1069, 7, 63, 2, 2, 1069, 228, 3, 2, 2, 2, 1070, 1071, 7, 63, 2, 2, 1071, 1072, 7, 63, 2, 2, 1072, 230, 3, 2, 2, 2, 1073, 1074, 7, 35, 2, 2, 1074, 1075, 7, 63, 2, 2, 1075, 232, 3, 2, 2, 2, 1076, 1077, 7, 62, 2, 2, 1077, 1078, 7, 63, 2, 2, 1078, 234, 3, 2, 2, 2, 1079, 1080, 7, 64, 2, 2, 1080, 1081, 7, 63, 2, 2, 1081, 236, 3, 2, 2, 2, 1082, 1083, 7, 40, 2, 2, 1083, 1088, 7, 40, 2, 2, 1084, 1085, 7, 99, 2, 2, 1085, 1086, 7, 112, 2, 2, 1086, 1088, 7, 102, 2, 2, 1087, 1082, 3, 2, 2, 2, 1087, 1084, 3, 2, 2, 2, 1088, 238, 3, 2, 2, 2, 1089, 1090, 7, 126, 2, 2, 1090, 1094, 7, 126, 2, 2, 1091, 1092, 7, 113, 2, 2, 1092, 1094, 7, 116, 2, 2, 1093, 1089, 3, 2, 2, 2, 1093, 1091, 3, 2, 2, 2, 1094, 240, 3, 2, 2, 2, 1095, 1096, 7, 45, 2, 2, 1096, 1097, 7, 45, 2, 2, 1097, 242, 3, 2, 2, 2, 1098, 1099, 7, 47, 2, 2, 1099, 1100, 7, 47, 2, 2, 1100, 244, 3, 2, 2, 2, 1101, 1102, 7, 46, 2, 2, 1102, 246, 3, 2, 2, 2, 1103, 1104, 7, 47, 2, 2, 1104, 1105, 7, 64, 2, 2, 1105, 1106, 7, 44, 2, 2, 1106, 248, 3, 2, 2, 2, 1107, 1108, 7, 47, 2, 2, 1108, 1109, 7, 64, 2, 2, 1109, 250, 3, 2, 2, 2, 1110, 1111, 7, 65, 2, 2, 1111, 252, 3, 2, 2, 2, 1112, 1113, 7, 60, 2, 2, 1113, 254, 3, 2, 2, 2, 1114, 1115, 7, 60, 2, 2, 1115, 1116, 7, 60, 2, 2, 1116, 256, 3, 2, 2, 2, 1117, 1118, 7, 61, 2, 2, 1118, 258, 3, 2, 2, 2, 1119, 1120, 7, 48, 2, 2, 1120, 260, 3, 2, 2, 2, 1121, 1122, 7, 48, 2, 2, 1122, 1123, 7, 44, 2, 2, 1123, 262, 3, 2, 2, 2, 1124, 1125, 7, 48, 2, 2, 1125, 1126, 7, 48, 2, 2, 1126, 1127, 7, 48, 2, 2, 1127, 264, 3, 2, 2, 2, 1128, 1129, 5, 289, 145, 2, 1129, 1130, 5, 289, 145, 2, 1130, 1131, 5, 289, 145, 2, 1131, 1132, 5, 289, 145, 2, 1132, 266, 3, 2, 2, 2, 1133, 1134, 7, 94, 2, 2, 1134, 1135, 7, 119, 2, 2, 1135, 1136, 3, 2, 2, 2, 1136, 1144, 5, 265, 133, 2, 1137, 1138, 7, 94, 2, 2, 1138, 1139, 7, 87, 2, 2, 1139, 1140, 3, 2, 2, 2, 1140, 1141, 5, 265, 133, 2, 1141, 1142, 5, 265, 133, 2, 1142, 1144, 3, 2, 2, 2, 1143, 1133, 3, 2, 2, 2, 1143, 1137, 3, 2, 2, 2, 1144, 268, 3, 2, 2, 2, 1145, 1150, 5, 271, 136, 2, 1146, 1149, 5, 271, 136, 2, 1147, 1149, 5, 275, 138, 2, 1148, 1146, 3, 2, 2, 2, 1148, 1147, 3, 2, 2, 2, 1149, 1152, 3, 2, 2, 2, 1150, 1148, 3, 2, 2, 2, 1150, 1151, 3, 2, 2, 2, 1151, 270, 3, 2, 2, 2, 1152, 1150, 3, 2, 2, 2, 1153, 1156, 5, 273, 137, 2, 1154, 1156, 5, 267, 134, 2, 1155, 1153, 3, 2, 2, 2, 1155, 1154, 3, 2, 2, 2, 1156, 272, 3, 2, 2, 2, 1157, 1158, 9, 4, 2, 2, 1158, 274, 3, 2, 2, 2, 1159, 1160, 9, 5, 2, 2, 1160, 276, 3, 2, 2, 2, 1161, 1168, 5, 285, 143, 2, 1162, 1164, 7, 41, 2, 2, 1163, 1162, 3, 2, 2, 2, 1163, 1164, 3, 2, 2, 2, 1164, 1165, 3, 2, 2, 2, 1165, 1167, 5, 275, 138, 2, 1166, 1163, 3, 2, 2, 2, 1167, 1170, 3, 2, 2, 2, 1168, 1166, 3, 2, 2, 2, 1168, 1169, 3, 2, 2, 2, 1169, 278, 3, 2, 2, 2, 1170, 1168, 3, 2, 2, 2, 1171, 1178, 7, 50, 2, 2, 1172, 1174, 7, 41, 2, 2, 1173, 1172, 3, 2, 2, 2, 1173, 1174, 3, 2, 2, 2, 1174, 1175, 3, 2, 2, 2, 1175, 1177, 5, 287, 144, 2, 1176, 1173, 3, 2, 2, 2, 1177, 1180, 3, 2, 2, 2, 1178, 1176, 3, 2, 2, 2, 1178, 1179, 3, 2, 2, 2, 1179, 280, 3, 2, 2, 2, 1180, 1178, 3, 2, 2, 2, 1181, 1182, 7, 50, 2, 2, 1182, 1186, 7, 122, 2, 2, 1183, 1184, 7, 50, 2, 2, 1184, 1186, 7, 90, 2, 2, 1185, 1181, 3, 2, 2, 2, 1185, 1183, 3, 2, 2, 2, 1186, 1187, 3, 2, 2, 2, 1187, 1194, 5, 289, 145, 2, 1188, 1190, 7, 41, 2, 2, 1189, 1188, 3, 2, 2, 2, 1189, 1190, 3, 2, 2, 2, 1190, 1191, 3, 2, 2, 2, 1191, 1193, 5, 289, 145, 2, 1192, 1189, 3, 2, 2, 2, 1193, 1196, 3, 2, 2, 2, 1194, 1192, 3, 2, 2, 2, 1194, 1195, 3, 2, 2, 2, 1195, 282, 3, 2, 2, 2, 1196, 1194, 3, 2, 2, 2, 1197, 1198, 7, 50, 2, 2, 1198, 1202, 7, 100, 2, 2, 1199, 1200, 7, 50, 2, 2, 1200, 1202, 7, 68, 2, 2, 1201, 1197, 3, 2, 2, 2, 1201, 1199, 3, 2, 2, 2, 1202, 1203, 3, 2, 2, 2, 1203, 1210, 5, 291, 146, 2, 1204, 1206, 7, 41, 2, 2, 1205, 1204, 3, 2, 2, 2, 1205, 1206, 3, 2, 2, 2, 1206, 1207, 3, 2, 2, 2, 1207, 1209, 5, 291, 146, 2, 1208, 1205, 3, 2, 2, 2, 1209, 1212, 3, 2, 2, 2, 1210, 1208, 3, 2, 2, 2, 1210, 1211, 3, 2, 2, 2, 1211, 284, 3, 2, 2, 2, 1212, 1210, 3, 2, 2, 2, 1213, 1214, 9, 6, 2, 2, 1214, 286, 3, 2, 2, 2, 1215, 1216, 9, 7, 2, 2, 1216, 288, 3, 2, 2, 2, 1217, 1218, 9, 8, 2, 2, 1218, 290, 3, 2, 2, 2, 1219, 1220, 9, 9, 2, 2, 1220, 292, 3, 2, 2, 2, 1221, 1223, 5, 295, 148, 2, 1222, 1224, 5, 297, 149, 2, 1223, 1222, 3, 2, 2, 2, 1223, 1224, 3, 2, 2, 2, 1224, 1238, 3, 2, 2, 2, 1225, 1227, 5, 295, 148, 2, 1226, 1228, 5, 299, 150, 2, 1227, 1226, 3, 2, 2, 2, 1227, 1228, 3, 2, 2, 2, 1228, 1238, 3, 2, 2, 2, 1229, 1231, 5, 297, 149, 2, 1230, 1232, 5, 295, 148, 2, 1231, 1230, 3, 2, 2, 2, 1231, 1232, 3, 2, 2, 2, 1232, 1238, 3, 2, 2, 2, 1233, 1235, 5, 299, 150, 2, 1234, 1236, 5, 295, 148, 2, 1235, 1234, 3, 2, 2, 2, 1235, 1236, 3, 2, 2, 2, 1236, 1238, 3, 2, 2, 2, 1237, 1221, 3, 2, 2, 2, 1237, 1225, 3, 2, 2, 2, 1237, 1229, 3, 2, 2, 2, 1237, 1233, 3, 2, 2, 2, 1238, 294, 3, 2, 2, 2, 1239, 1240, 9, 10, 2, 2, 1240, 296, 3, 2, 2, 2, 1241, 1242, 9, 11, 2, 2, 1242, 298, 3, 2, 2, 2, 1243, 1244, 7, 110, 2, 2, 1244, 1248, 7, 110, 2, 2, 1245, 1246, 7, 78, 2, 2, 1246, 1248, 7, 78, 2, 2, 1247, 1243, 3, 2, 2, 2, 1247, 1245, 3, 2, 2, 2, 1248, 300, 3, 2, 2, 2, 1249, 1253, 10, 12, 2, 2, 1250, 1253, 5, 303, 152, 2, 1251, 1253, 5, 267, 134, 2, 1252, 1249, 3, 2, 2, 2, 1252, 1250, 3, 2, 2, 2, 1252, 1251, 3, 2, 2, 2, 1253, 302, 3, 2, 2, 2, 1254, 1258, 5, 305, 153, 2, 1255, 1258, 5, 307, 154, 2, 1256, 1258, 5, 309, 155, 2, 1257, 1254, 3, 2, 2, 2, 1257, 1255, 3, 2, 2, 2, 1257, 1256, 3, 2, 2, 2, 1258, 304, 3, 2, 2, 2, 1259, 1260, 7, 94, 2, 2, 1260, 1290, 7, 41, 2, 2, 1261, 1262, 7, 94, 2, 2, 1262, 1290, 7, 36, 2, 2, 1263, 1264, 7, 94, 2, 2, 1264, 1290, 7, 65, 2, 2, 1265, 1266, 7, 94, 2, 2, 1266, 1290, 7, 94, 2, 2, 1267, 1268, 7, 94, 2, 2, 1268, 1290, 7, 99, 2, 2, 1269, 1270, 7, 94, 2, 2, 1270, 1290, 7, 100, 2, 2, 1271, 1272, 7, 94, 2, 2, 1272, 1290, 7, 104, 2, 2, 1273, 1274, 7, 94, 2, 2, 1274, 1290, 7, 112, 2, 2, 1275, 1276, 7, 94, 2, 2, 1276, 1290, 7, 116, 2, 2, 1277, 1283, 7, 94, 2, 2, 1278, 1280, 7, 15, 2, 2, 1279, 1281, 7, 12, 2, 2, 1280, 1279, 3, 2, 2, 2, 1280, 1281, 3, 2, 2, 2, 1281, 1284, 3, 2, 2, 2, 1282, 1284, 7, 12, 2, 2, 1283, 1278, 3, 2, 2, 2, 1283, 1282, 3, 2, 2, 2, 1284, 1290, 3, 2, 2, 2, 1285, 1286, 7, 94, 2, 2, 1286, 1290, 7, 118, 2, 2, 1287, 1288, 7, 94, 2, 2, 1288, 1290, 7, 120, 2, 2, 1289, 1259, 3, 2, 2, 2, 1289, 1261, 3, 2, 2, 2, 1289, 1263, 3, 2, 2, 2, 1289, 1265, 3, 2, 2, 2, 1289, 1267, 3, 2, 2, 2, 1289, 1269, 3, 2, 2, 2, 1289, 1271, 3, 2, 2, 2, 1289, 1273, 3, 2, 2, 2, 1289, 1275, 3, 2, 2, 2, 1289, 1277, 3, 2, 2, 2, 1289, 1285, 3, 2, 2, 2, 1289, 1287, 3, 2, 2, 2, 1290, 306, 3, 2, 2, 2, 1291, 1292, 7, 94, 2, 2, 1292, 1303, 5, 287, 144, 2, 1293, 1294, 7, 94, 2, 2, 1294, 1295, 5, 287, 144, 2, 1295, 1296, 5, 287, 144, 2, 1296, 1303, 3, 2, 2, 2, 1297, 1298, 7, 94, 2, 2, 1298, 1299, 5, 287, 144, 2, 1299, 1300, 5, 287, 144, 2, 1300, 1301, 5, 287, 144, 2, 1301, 1303, 3, 2, 2, 2, 1302, 1291, 3, 2, 2, 2, 1302, 1293, 3, 2, 2, 2, 1302, 1297, 3, 2, 2, 2, 1303, 308, 3, 2, 2, 2, 1304, 1305, 7, 94, 2, 2, 1305, 1306, 7, 122, 2, 2, 1306, 1308, 3, 2, 2, 2, 1307, 1309, 5, 289, 145, 2, 1308, 1307, 3, 2, 2, 2, 1309, 1310, 3, 2, 2, 2, 1310, 1308, 3, 2, 2, 2, 1310, 1311, 3, 2, 2, 2, 1311, 310, 3, 2, 2, 2, 1312, 1314, 5, 317, 159, 2, 1313, 1312, 3, 2, 2, 2, 1313, 1314, 3, 2, 2, 2, 1314, 1315, 3, 2, 2, 2, 1315, 1316, 7, 48, 2, 2, 1316, 1321, 5, 317, 159, 2, 1317, 1318, 5, 317, 159, 2, 1318, 1319, 7, 48, 2, 2, 1319, 1321, 3, 2, 2, 2, 1320, 1313, 3, 2, 2, 2, 1320, 1317, 3, 2, 2, 2, 1321, 312, 3, 2, 2, 2, 1322, 1324, 7, 103, 2, 2, 1323, 1325, 5, 315, 158, 2, 1324, 1323, 3, 2, 2, 2, 1324, 1325, 3, 2, 2, 2, 1325, 1326, 3, 2, 2, 2, 1326, 1333, 5, 317, 159, 2, 1327, 1329, 7, 71, 2, 2, 1328, 1330, 5, 315, 158, 2, 1329, 1328, 3, 2, 2, 2, 1329, 1330, 3, 2, 2, 2, 1330, 1331, 3, 2, 2, 2, 1331, 1333, 5, 317, 159, 2, 1332, 1322, 3, 2, 2, 2, 1332, 1327, 3, 2, 2, 2, 1333, 314, 3, 2, 2, 2, 1334, 1335, 9, 13, 2, 2, 1335, 316, 3, 2, 2, 2, 1336, 1343, 5, 275, 138, 2, 1337, 1339, 7, 41, 2, 2, 1338, 1337, 3, 2, 2, 2, 1338, 1339, 3, 2, 2, 2, 1339, 1340, 3, 2, 2, 2, 1340, 1342, 5, 275, 138, 2, 1341, 1338, 3, 2, 2, 2, 1342, 1345, 3, 2, 2, 2, 1343, 1341, 3, 2, 2, 2, 1343, 1344, 3, 2, 2, 2, 1344, 318, 3, 2, 2, 2, 1345, 1343, 3, 2, 2, 2, 1346, 1347, 9, 14, 2, 2, 1347, 320, 3, 2, 2, 2, 1348, 1349, 7, 119, 2, 2, 1349, 1352, 7, 58, 2, 2, 1350, 1352, 9, 2, 2, 2, 1351, 1348, 3, 2, 2, 2, 1351, 1350, 3, 2, 2, 2, 1352, 322, 3, 2, 2, 2, 1353, 1357, 10, 15, 2, 2, 1354, 1357, 5, 303, 152, 2, 1355, 1357, 5, 267, 134, 2, 1356, 1353, 3, 2, 2, 2, 1356, 1354, 3, 2, 2, 2, 1356, 1355, 3, 2, 2, 2, 1357, 324, 3, 2, 2, 2, 1358, 1359, 7, 84, 2, 2, 1359, 1360, 7, 36, 2, 2, 1360, 1366, 3, 2, 2, 2, 1361, 1362, 7, 94, 2, 2, 1362, 1365, 9, 16, 2, 2, 1363, 1365, 10, 17, 2, 2, 1364, 1361, 3, 2, 2, 2, 1364, 1363, 3, 2, 2, 2, 1365, 1368, 3, 2, 2, 2, 1366, 1367, 3, 2, 2, 2, 1366, 1364, 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, 18, 2, 2, 1371, 1370, 3, 2, 2, 2, 1372, 1375, 3, 2, 2, 2, 1373, 1374, 3, 2, 2, 2, 1373, 1371, 3, 2, 2, 2, 1374, 1376, 3, 2, 2, 2, 1375, 1373, 3, 2, 2, 2, 1376, 1382, 7, 43, 2, 2, 1377, 1378, 7, 94, 2, 2, 1378, 1381, 9, 16, 2, 2, 1379, 1381, 10, 19, 2, 2, 1380, 1377, 3, 2, 2, 2, 1380, 1379, 3, 2, 2, 2, 1381, 1384, 3, 2, 2, 2, 1382, 1383, 3, 2, 2, 2, 1382, 1380, 3, 2, 2, 2, 1383, 1385, 3, 2, 2, 2, 1384, 1382, 3, 2, 2, 2, 1385, 1386, 7, 36, 2, 2, 1386, 326, 3, 2, 2, 2, 1387, 1388, 5, 277, 139, 2, 1388, 1389, 5, 335, 168, 2, 1389, 1400, 3, 2, 2, 2, 1390, 1391, 5, 279, 140, 2, 1391, 1392, 5, 335, 168, 2, 1392, 1400, 3, 2, 2, 2, 1393, 1394, 5, 281, 141, 2, 1394, 1395, 5, 335, 168, 2, 1395, 1400, 3, 2, 2, 2, 1396, 1397, 5, 283, 142, 2, 1397, 1398, 5, 335, 168, 2, 1398, 1400, 3, 2, 2, 2, 1399, 1387, 3, 2, 2, 2, 1399, 1390, 3, 2, 2, 2, 1399, 1393, 3, 2, 2, 2, 1399, 1396, 3, 2, 2, 2, 1400, 328, 3, 2, 2, 2, 1401, 1403, 5, 311, 156, 2, 1402, 1404, 5, 313, 157, 2, 1403, 1402, 3, 2, 2, 2, 1403, 1404, 3, 2, 2, 2, 1404, 1405, 3, 2, 2, 2, 1405, 1406, 5, 335, 168, 2, 1406, 1412, 3, 2, 2, 2, 1407, 1408, 5, 317, 159, 2, 1408, 1409, 5, 313, 157, 2, 1409, 1410, 5, 335, 168, 2, 1410, 1412, 3, 2, 2, 2, 1411, 1401, 3, 2, 2, 2, 1411, 1407, 3, 2, 2, 2, 1412, 330, 3, 2, 2, 2, 1413, 1414, 5, 9, 5, 2, 1414, 1415, 5, 335, 168, 2, 1415, 332, 3, 2, 2, 2, 1416, 1417, 5, 5, 3, 2, 1417, 1418, 5, 335, 168, 2, 1418, 334, 3, 2, 2, 2, 1419, 1420, 5, 269, 135, 2, 1420, 336, 3, 2, 2, 2, 1421, 1423, 9, 20, 2, 2, 1422, 1421, 3, 2, 2, 2, 1423, 1424, 3, 2, 2, 2, 1424, 1422, 3, 2, 2, 2, 1424, 1425, 3, 2, 2, 2, 1425, 1426, 3, 2, 2, 2, 1426, 1427, 8, 169, 3, 2, 1427, 338, 3, 2, 2, 2, 1428, 1430, 7, 15, 2, 2, 1429, 1431, 7, 12, 2, 2, 1430, 1429, 3, 2, 2, 2, 1430, 1431, 3, 2, 2, 2, 1431, 1434, 3, 2, 2, 2, 1432, 1434, 7, 12, 2, 2, 1433, 1428, 3, 2, 2, 2, 1433, 1432, 3, 2, 2, 2, 1434, 1435, 3, 2, 2, 2, 1435, 1436, 8, 170, 3, 2, 1436, 340, 3, 2, 2, 2, 1437, 1438, 7, 49, 2, 2, 1438, 1439, 7, 44, 2, 2, 1439, 1443, 3, 2, 2, 2, 1440, 1442, 11, 2, 2, 2, 1441, 1440, 3, 2, 2, 2, 1442, 1445, 3, 2, 2, 2, 1443, 1444, 3, 2, 2, 2, 1443, 1441, 3, 2, 2, 2, 1444, 1446, 3, 2, 2, 2, 1445, 1443, 3, 2, 2, 2, 1446, 1447, 7, 44, 2, 2, 1447, 1448, 7, 49, 2, 2, 1448, 1449, 3, 2, 2, 2, 1449, 1450, 8, 171, 3, 2, 1450, 342, 3, 2, 2, 2, 1451, 1452, 7, 49, 2, 2, 1452, 1453, 7, 49, 2, 2, 1453, 1457, 3, 2, 2, 2, 1454, 1456, 10, 21, 2, 2, 1455, 1454, 3, 2, 2, 2, 1456, 1459, 3, 2, 2, 2, 1457, 1455, 3, 2, 2, 2, 1457, 1458, 3, 2, 2, 2, 1458, 1460, 3, 2, 2, 2, 1459, 1457, 3, 2, 2, 2, 1460, 1461, 8, 172, 3, 2, 1461, 344, 3, 2, 2, 2, 76, 2, 347, 351, 355, 359, 361, 364, 370, 376, 379, 384, 386, 389, 396, 400, 404, 412, 418, 423, 428, 433, 441, 1030, 1087, 1093, 1143, 1148, 1150, 1155, 1163, 1168, 1173, 1178, 1185, 1189, 1194, 1201, 1205, 1210, 1223, 1227, 1231, 1235, 1237, 1247, 1252, 1257, 1280, 1283, 1289, 1302, 1310, 1313, 1320, 1324, 1329, 1332, 1338, 1343, 1351, 1356, 1364, 1366, 1373, 1380, 1382, 1399, 1403, 1411, 1424, 1430, 1433, 1443, 1457, 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 index c96780836..b418155e5 100644 --- a/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Lexer.java +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Lexer.java @@ -1,757 +1,1264 @@ -// Generated from /home/syu/workspace/MSCCD_ALL/Project/grammarDefinations/CPP14/CPP14Lexer.g4 by ANTLR 4.8 +// Generated from CPP14Lexer.g4 by ANTLR 4.9.3 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.Lexer; +import org.antlr.v4.runtime.RuntimeMetaData; +import org.antlr.v4.runtime.Vocabulary; +import org.antlr.v4.runtime.VocabularyImpl; +import org.antlr.v4.runtime.atn.ATN; +import org.antlr.v4.runtime.atn.ATNDeserializer; +import org.antlr.v4.runtime.atn.LexerATNSimulator; +import org.antlr.v4.runtime.atn.PredictionContextCache; 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); } + 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 String[] ruleNames = makeRuleNames(); + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated public static final String[] tokenNames; + public static final String _serializedATN = + "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\u0093\u05b6\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\3\5\7\5\u018b" + + "\n\5\f\5\16\5\u018e\13\5\3\5\5\5\u0191\n\5\3\6\3\6\5\6\u0195\n\6\3\7\3" + + "\7\3\b\3\b\3\b\3\b\5\b\u019d\n\b\3\t\3\t\7\t\u01a1\n\t\f\t\16\t\u01a4" + + "\13\t\3\t\3\t\5\t\u01a8\n\t\3\t\6\t\u01ab\n\t\r\t\16\t\u01ac\3\t\6\t\u01b0" + + "\n\t\r\t\16\t\u01b1\3\t\3\t\3\n\3\n\7\n\u01b8\n\n\f\n\16\n\u01bb\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\38\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\3B\3B\3B\3B\3B\3B\3B\3C\3C" + + "\3C\3C\3C\3C\3C\3D\3D\3D\3D\3D\3D\3D\3E\3E\3E\3E\3E\3E\3E\3E\3E\3F\3F" + + "\3F\3F\3F\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3G\3H\3H\3H\3H\3H\3H\3I" + + "\3I\3I\3I\3I\3J\3J\3J\3J\3K\3K\3K\3K\3K\3K\3K\3K\3L\3L\3L\3L\3L\3L\3L" + + "\3M\3M\3M\3M\3M\3M\3M\3M\3M\3N\3N\3N\3N\3N\3N\3O\3O\3O\3O\3O\3O\3O\3O" + + "\3O\3P\3P\3P\3P\3P\3P\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3Q\3R\3R\3R\3R\3R\3S\3S\3S" + + "\3S\3S\3S\3S\3S\3S\3T\3T\3T\3T\3T\3T\3T\3T\3U\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\3" + + "b\3c\3c\3d\3d\3e\3e\3e\3e\5e\u0407\ne\3f\3f\3g\3g\3h\3h\3i\3i\3i\3j\3" + + "j\3j\3k\3k\3k\3l\3l\3l\3m\3m\3m\3n\3n\3n\3o\3o\3o\3p\3p\3p\3q\3q\3q\3" + + "q\3r\3r\3r\3r\3s\3s\3s\3t\3t\3t\3u\3u\3u\3v\3v\3v\3w\3w\3w\3w\3w\5w\u0440" + + "\nw\3x\3x\3x\3x\5x\u0446\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\u0478\n\u0086\3\u0087" + + "\3\u0087\3\u0087\7\u0087\u047d\n\u0087\f\u0087\16\u0087\u0480\13\u0087" + + "\3\u0088\3\u0088\5\u0088\u0484\n\u0088\3\u0089\3\u0089\3\u008a\3\u008a" + + "\3\u008b\3\u008b\5\u008b\u048c\n\u008b\3\u008b\7\u008b\u048f\n\u008b\f" + + "\u008b\16\u008b\u0492\13\u008b\3\u008c\3\u008c\5\u008c\u0496\n\u008c\3" + + "\u008c\7\u008c\u0499\n\u008c\f\u008c\16\u008c\u049c\13\u008c\3\u008d\3" + + "\u008d\3\u008d\3\u008d\5\u008d\u04a2\n\u008d\3\u008d\3\u008d\5\u008d\u04a6" + + "\n\u008d\3\u008d\7\u008d\u04a9\n\u008d\f\u008d\16\u008d\u04ac\13\u008d" + + "\3\u008e\3\u008e\3\u008e\3\u008e\5\u008e\u04b2\n\u008e\3\u008e\3\u008e" + + "\5\u008e\u04b6\n\u008e\3\u008e\7\u008e\u04b9\n\u008e\f\u008e\16\u008e" + + "\u04bc\13\u008e\3\u008f\3\u008f\3\u0090\3\u0090\3\u0091\3\u0091\3\u0092" + + "\3\u0092\3\u0093\3\u0093\5\u0093\u04c8\n\u0093\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\5\u0093\u04d6\n\u0093\3\u0094\3\u0094\3\u0095\3\u0095" + + "\3\u0096\3\u0096\3\u0096\3\u0096\5\u0096\u04e0\n\u0096\3\u0097\3\u0097" + + "\3\u0097\5\u0097\u04e5\n\u0097\3\u0098\3\u0098\3\u0098\5\u0098\u04ea\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\u0501\n\u0099\3\u0099\5\u0099" + + "\u0504\n\u0099\3\u0099\3\u0099\3\u0099\3\u0099\5\u0099\u050a\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\u0517\n\u009a\3\u009b\3\u009b\3\u009b\3\u009b" + + "\6\u009b\u051d\n\u009b\r\u009b\16\u009b\u051e\3\u009c\5\u009c\u0522\n" + + "\u009c\3\u009c\3\u009c\3\u009c\3\u009c\3\u009c\5\u009c\u0529\n\u009c\3" + + "\u009d\3\u009d\5\u009d\u052d\n\u009d\3\u009d\3\u009d\3\u009d\5\u009d\u0532" + + "\n\u009d\3\u009d\5\u009d\u0535\n\u009d\3\u009e\3\u009e\3\u009f\3\u009f" + + "\5\u009f\u053b\n\u009f\3\u009f\7\u009f\u053e\n\u009f\f\u009f\16\u009f" + + "\u0541\13\u009f\3\u00a0\3\u00a0\3\u00a1\3\u00a1\3\u00a1\5\u00a1\u0548" + + "\n\u00a1\3\u00a2\3\u00a2\3\u00a2\5\u00a2\u054d\n\u00a2\3\u00a3\3\u00a3" + + "\3\u00a3\3\u00a3\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\3\u00a3\3\u00a3\7\u00a3\u0565\n\u00a3" + + "\f\u00a3\16\u00a3\u0568\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\u0578\n\u00a4\3\u00a5\3\u00a5\5\u00a5\u057c\n\u00a5\3\u00a5\3" + + "\u00a5\3\u00a5\3\u00a5\3\u00a5\3\u00a5\5\u00a5\u0584\n\u00a5\3\u00a6\3" + + "\u00a6\3\u00a6\3\u00a7\3\u00a7\3\u00a7\3\u00a8\3\u00a8\3\u00a9\6\u00a9" + + "\u058f\n\u00a9\r\u00a9\16\u00a9\u0590\3\u00a9\3\u00a9\3\u00aa\3\u00aa" + + "\5\u00aa\u0597\n\u00aa\3\u00aa\5\u00aa\u059a\n\u00aa\3\u00aa\3\u00aa\3" + + "\u00ab\3\u00ab\3\u00ab\3\u00ab\7\u00ab\u05a2\n\u00ab\f\u00ab\16\u00ab" + + "\u05a5\13\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ab\3\u00ac\3\u00ac" + + "\3\u00ac\3\u00ac\7\u00ac\u05b0\n\u00ac\f\u00ac\16\u00ac\u05b3\13\u00ac" + + "\3\u00ac\3\u00ac\7\u01a2\u0556\u055d\u0566\u05a3\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\u0091" + + "J\u0093K\u0095L\u0097M\u0099N\u009bO\u009dP\u009fQ\u00a1R\u00a3S\u00a5" + + "T\u00a7U\u00a9V\u00abW\u00adX\u00afY\u00b1Z\u00b3[\u00b5\\\u00b7]\u00b9" + + "^\u00bb_\u00bd`\u00bfa\u00c1b\u00c3c\u00c5d\u00c7e\u00c9f\u00cbg\u00cd" + + "h\u00cfi\u00d1j\u00d3k\u00d5l\u00d7m\u00d9n\u00dbo\u00ddp\u00dfq\u00e1" + + "r\u00e3s\u00e5t\u00e7u\u00e9v\u00ebw\u00edx\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\26\5\2NNWWww\3\2\f\f\5" + + "\2C\\aac|\3\2\62;\3\2\63;\3\2\629\5\2\62;CHch\3\2\62\63\4\2WWww\4\2NN" + + "nn\6\2\f\f\17\17))^^\4\2--//\6\2HHNNhhnn\6\2\f\f\17\17$$^^\4\2$$*+\6\2" + + "\f\f\17\17\"\"**\3\2++\6\2\f\f\17\17\"\"$$\4\2\13\13\"\"\4\2\f\f\17\17" + + "\2\u05fa\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2" + + "\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2\27" + + "\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2\2\2\2\37\3\2\2\2\2!\3\2\2" + + "\2\2#\3\2\2\2\2%\3\2\2\2\2\'\3\2\2\2\2)\3\2\2\2\2+\3\2\2\2\2-\3\2\2\2" + + "\2/\3\2\2\2\2\61\3\2\2\2\2\63\3\2\2\2\2\65\3\2\2\2\2\67\3\2\2\2\29\3\2" + + "\2\2\2;\3\2\2\2\2=\3\2\2\2\2?\3\2\2\2\2A\3\2\2\2\2C\3\2\2\2\2E\3\2\2\2" + + "\2G\3\2\2\2\2I\3\2\2\2\2K\3\2\2\2\2M\3\2\2\2\2O\3\2\2\2\2Q\3\2\2\2\2S" + + "\3\2\2\2\2U\3\2\2\2\2W\3\2\2\2\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\2i\3\2\2\2\2k\3\2\2\2" + + "\2m\3\2\2\2\2o\3\2\2\2\2q\3\2\2\2\2s\3\2\2\2\2u\3\2\2\2\2w\3\2\2\2\2y" + + "\3\2\2\2\2{\3\2\2\2\2}\3\2\2\2\2\177\3\2\2\2\2\u0081\3\2\2\2\2\u0083\3" + + "\2\2\2\2\u0085\3\2\2\2\2\u0087\3\2\2\2\2\u0089\3\2\2\2\2\u008b\3\2\2\2" + + "\2\u008d\3\2\2\2\2\u008f\3\2\2\2\2\u0091\3\2\2\2\2\u0093\3\2\2\2\2\u0095" + + "\3\2\2\2\2\u0097\3\2\2\2\2\u0099\3\2\2\2\2\u009b\3\2\2\2\2\u009d\3\2\2" + + "\2\2\u009f\3\2\2\2\2\u00a1\3\2\2\2\2\u00a3\3\2\2\2\2\u00a5\3\2\2\2\2\u00a7" + + "\3\2\2\2\2\u00a9\3\2\2\2\2\u00ab\3\2\2\2\2\u00ad\3\2\2\2\2\u00af\3\2\2" + + "\2\2\u00b1\3\2\2\2\2\u00b3\3\2\2\2\2\u00b5\3\2\2\2\2\u00b7\3\2\2\2\2\u00b9" + + "\3\2\2\2\2\u00bb\3\2\2\2\2\u00bd\3\2\2\2\2\u00bf\3\2\2\2\2\u00c1\3\2\2" + + "\2\2\u00c3\3\2\2\2\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\u0185\3\2\2\2\13\u0194\3\2" + + "\2\2\r\u0196\3\2\2\2\17\u019c\3\2\2\2\21\u019e\3\2\2\2\23\u01b5\3\2\2" + + "\2\25\u01be\3\2\2\2\27\u01c6\3\2\2\2\31\u01ce\3\2\2\2\33\u01d2\3\2\2\2" + + "\35\u01d7\3\2\2\2\37\u01dc\3\2\2\2!\u01e2\3\2\2\2#\u01e7\3\2\2\2%\u01ed" + + "\3\2\2\2\'\u01f2\3\2\2\2)\u01fb\3\2\2\2+\u0204\3\2\2\2-\u020a\3\2\2\2" + + "/\u0210\3\2\2\2\61\u021a\3\2\2\2\63\u0225\3\2\2\2\65\u022e\3\2\2\2\67" + + "\u0237\3\2\2\29\u023f\3\2\2\2;\u0246\3\2\2\2=\u0249\3\2\2\2?\u0250\3\2" + + "\2\2A\u025d\3\2\2\2C\u0262\3\2\2\2E\u0267\3\2\2\2G\u0270\3\2\2\2I\u0277" + + "\3\2\2\2K\u027e\3\2\2\2M\u0284\3\2\2\2O\u028a\3\2\2\2Q\u0290\3\2\2\2S" + + "\u0294\3\2\2\2U\u029b\3\2\2\2W\u02a0\3\2\2\2Y\u02a3\3\2\2\2[\u02aa\3\2" + + "\2\2]\u02ae\3\2\2\2_\u02b3\3\2\2\2a\u02bb\3\2\2\2c\u02c5\3\2\2\2e\u02c9" + + "\3\2\2\2g\u02d2\3\2\2\2i\u02da\3\2\2\2k\u02e3\3\2\2\2m\u02ec\3\2\2\2o" + + "\u02f4\3\2\2\2q\u02fe\3\2\2\2s\u0305\3\2\2\2u\u030e\3\2\2\2w\u031f\3\2" + + "\2\2y\u0326\3\2\2\2{\u032c\3\2\2\2}\u0333\3\2\2\2\177\u033a\3\2\2\2\u0081" + + "\u0341\3\2\2\2\u0083\u034f\3\2\2\2\u0085\u035b\3\2\2\2\u0087\u0362\3\2" + + "\2\2\u0089\u0369\3\2\2\2\u008b\u0372\3\2\2\2\u008d\u0377\3\2\2\2\u008f" + + "\u0384\3\2\2\2\u0091\u038a\3\2\2\2\u0093\u038f\3\2\2\2\u0095\u0393\3\2" + + "\2\2\u0097\u039b\3\2\2\2\u0099\u03a2\3\2\2\2\u009b\u03ab\3\2\2\2\u009d" + + "\u03b1\3\2\2\2\u009f\u03ba\3\2\2\2\u00a1\u03c0\3\2\2\2\u00a3\u03c8\3\2" + + "\2\2\u00a5\u03cd\3\2\2\2\u00a7\u03d6\3\2\2\2\u00a9\u03de\3\2\2\2\u00ab" + + "\u03e4\3\2\2\2\u00ad\u03e6\3\2\2\2\u00af\u03e8\3\2\2\2\u00b1\u03ea\3\2" + + "\2\2\u00b3\u03ec\3\2\2\2\u00b5\u03ee\3\2\2\2\u00b7\u03f0\3\2\2\2\u00b9" + + "\u03f2\3\2\2\2\u00bb\u03f4\3\2\2\2\u00bd\u03f6\3\2\2\2\u00bf\u03f8\3\2" + + "\2\2\u00c1\u03fa\3\2\2\2\u00c3\u03fc\3\2\2\2\u00c5\u03fe\3\2\2\2\u00c7" + + "\u0400\3\2\2\2\u00c9\u0406\3\2\2\2\u00cb\u0408\3\2\2\2\u00cd\u040a\3\2" + + "\2\2\u00cf\u040c\3\2\2\2\u00d1\u040e\3\2\2\2\u00d3\u0411\3\2\2\2\u00d5" + + "\u0414\3\2\2\2\u00d7\u0417\3\2\2\2\u00d9\u041a\3\2\2\2\u00db\u041d\3\2" + + "\2\2\u00dd\u0420\3\2\2\2\u00df\u0423\3\2\2\2\u00e1\u0426\3\2\2\2\u00e3" + + "\u042a\3\2\2\2\u00e5\u042e\3\2\2\2\u00e7\u0431\3\2\2\2\u00e9\u0434\3\2" + + "\2\2\u00eb\u0437\3\2\2\2\u00ed\u043f\3\2\2\2\u00ef\u0445\3\2\2\2\u00f1" + + "\u0447\3\2\2\2\u00f3\u044a\3\2\2\2\u00f5\u044d\3\2\2\2\u00f7\u044f\3\2" + + "\2\2\u00f9\u0453\3\2\2\2\u00fb\u0456\3\2\2\2\u00fd\u0458\3\2\2\2\u00ff" + + "\u045a\3\2\2\2\u0101\u045d\3\2\2\2\u0103\u045f\3\2\2\2\u0105\u0461\3\2" + + "\2\2\u0107\u0464\3\2\2\2\u0109\u0468\3\2\2\2\u010b\u0477\3\2\2\2\u010d" + + "\u0479\3\2\2\2\u010f\u0483\3\2\2\2\u0111\u0485\3\2\2\2\u0113\u0487\3\2" + + "\2\2\u0115\u0489\3\2\2\2\u0117\u0493\3\2\2\2\u0119\u04a1\3\2\2\2\u011b" + + "\u04b1\3\2\2\2\u011d\u04bd\3\2\2\2\u011f\u04bf\3\2\2\2\u0121\u04c1\3\2" + + "\2\2\u0123\u04c3\3\2\2\2\u0125\u04d5\3\2\2\2\u0127\u04d7\3\2\2\2\u0129" + + "\u04d9\3\2\2\2\u012b\u04df\3\2\2\2\u012d\u04e4\3\2\2\2\u012f\u04e9\3\2" + + "\2\2\u0131\u0509\3\2\2\2\u0133\u0516\3\2\2\2\u0135\u0518\3\2\2\2\u0137" + + "\u0528\3\2\2\2\u0139\u0534\3\2\2\2\u013b\u0536\3\2\2\2\u013d\u0538\3\2" + + "\2\2\u013f\u0542\3\2\2\2\u0141\u0547\3\2\2\2\u0143\u054c\3\2\2\2\u0145" + + "\u054e\3\2\2\2\u0147\u0577\3\2\2\2\u0149\u0583\3\2\2\2\u014b\u0585\3\2" + + "\2\2\u014d\u0588\3\2\2\2\u014f\u058b\3\2\2\2\u0151\u058e\3\2\2\2\u0153" + + "\u0599\3\2\2\2\u0155\u059d\3\2\2\2\u0157\u05ab\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\u0190\3\2\2\2\u0187" + + "\u0191\5\u0145\u00a3\2\u0188\u018c\7$\2\2\u0189\u018b\5\u0143\u00a2\2" + + "\u018a\u0189\3\2\2\2\u018b\u018e\3\2\2\2\u018c\u018a\3\2\2\2\u018c\u018d" + + "\3\2\2\2\u018d\u018f\3\2\2\2\u018e\u018c\3\2\2\2\u018f\u0191\7$\2\2\u0190" + + "\u0187\3\2\2\2\u0190\u0188\3\2\2\2\u0191\n\3\2\2\2\u0192\u0195\5K&\2\u0193" + + "\u0195\5\u0091I\2\u0194\u0192\3\2\2\2\u0194\u0193\3\2\2\2\u0195\f\3\2" + + "\2\2\u0196\u0197\5g\64\2\u0197\16\3\2\2\2\u0198\u019d\5\u0147\u00a4\2" + + "\u0199\u019d\5\u0149\u00a5\2\u019a\u019d\5\u014b\u00a6\2\u019b\u019d\5" + + "\u014d\u00a7\2\u019c\u0198\3\2\2\2\u019c\u0199\3\2\2\2\u019c\u019a\3\2" + + "\2\2\u019c\u019b\3\2\2\2\u019d\20\3\2\2\2\u019e\u01aa\7%\2\2\u019f\u01a1" + + "\n\3\2\2\u01a0\u019f\3\2\2\2\u01a1\u01a4\3\2\2\2\u01a2\u01a3\3\2\2\2\u01a2" + + "\u01a0\3\2\2\2\u01a3\u01a5\3\2\2\2\u01a4\u01a2\3\2\2\2\u01a5\u01a7\7^" + + "\2\2\u01a6\u01a8\7\17\2\2\u01a7\u01a6\3\2\2\2\u01a7\u01a8\3\2\2\2\u01a8" + + "\u01a9\3\2\2\2\u01a9\u01ab\7\f\2\2\u01aa\u01a2\3\2\2\2\u01ab\u01ac\3\2" + + "\2\2\u01ac\u01aa\3\2\2\2\u01ac\u01ad\3\2\2\2\u01ad\u01af\3\2\2\2\u01ae" + + "\u01b0\n\3\2\2\u01af\u01ae\3\2\2\2\u01b0\u01b1\3\2\2\2\u01b1\u01af\3\2" + + "\2\2\u01b1\u01b2\3\2\2\2\u01b2\u01b3\3\2\2\2\u01b3\u01b4\b\t\2\2\u01b4" + + "\22\3\2\2\2\u01b5\u01b9\7%\2\2\u01b6\u01b8\n\3\2\2\u01b7\u01b6\3\2\2\2" + + "\u01b8\u01bb\3\2\2\2\u01b9\u01b7\3\2\2\2\u01b9\u01ba\3\2\2\2\u01ba\u01bc" + + "\3\2\2\2\u01bb\u01b9\3\2\2\2\u01bc\u01bd\b\n\2\2\u01bd\24\3\2\2\2\u01be" + + "\u01bf\7c\2\2\u01bf\u01c0\7n\2\2\u01c0\u01c1\7k\2\2\u01c1\u01c2\7i\2\2" + + "\u01c2\u01c3\7p\2\2\u01c3\u01c4\7c\2\2\u01c4\u01c5\7u\2\2\u01c5\26\3\2" + + "\2\2\u01c6\u01c7\7c\2\2\u01c7\u01c8\7n\2\2\u01c8\u01c9\7k\2\2\u01c9\u01ca" + + "\7i\2\2\u01ca\u01cb\7p\2\2\u01cb\u01cc\7q\2\2\u01cc\u01cd\7h\2\2\u01cd" + + "\30\3\2\2\2\u01ce\u01cf\7c\2\2\u01cf\u01d0\7u\2\2\u01d0\u01d1\7o\2\2\u01d1" + + "\32\3\2\2\2\u01d2\u01d3\7c\2\2\u01d3\u01d4\7w\2\2\u01d4\u01d5\7v\2\2\u01d5" + + "\u01d6\7q\2\2\u01d6\34\3\2\2\2\u01d7\u01d8\7d\2\2\u01d8\u01d9\7q\2\2\u01d9" + + "\u01da\7q\2\2\u01da\u01db\7n\2\2\u01db\36\3\2\2\2\u01dc\u01dd\7d\2\2\u01dd" + + "\u01de\7t\2\2\u01de\u01df\7g\2\2\u01df\u01e0\7c\2\2\u01e0\u01e1\7m\2\2" + + "\u01e1 \3\2\2\2\u01e2\u01e3\7e\2\2\u01e3\u01e4\7c\2\2\u01e4\u01e5\7u\2" + + "\2\u01e5\u01e6\7g\2\2\u01e6\"\3\2\2\2\u01e7\u01e8\7e\2\2\u01e8\u01e9\7" + + "c\2\2\u01e9\u01ea\7v\2\2\u01ea\u01eb\7e\2\2\u01eb\u01ec\7j\2\2\u01ec$" + + "\3\2\2\2\u01ed\u01ee\7e\2\2\u01ee\u01ef\7j\2\2\u01ef\u01f0\7c\2\2\u01f0" + + "\u01f1\7t\2\2\u01f1&\3\2\2\2\u01f2\u01f3\7e\2\2\u01f3\u01f4\7j\2\2\u01f4" + + "\u01f5\7c\2\2\u01f5\u01f6\7t\2\2\u01f6\u01f7\7\63\2\2\u01f7\u01f8\78\2" + + "\2\u01f8\u01f9\7a\2\2\u01f9\u01fa\7v\2\2\u01fa(\3\2\2\2\u01fb\u01fc\7" + + "e\2\2\u01fc\u01fd\7j\2\2\u01fd\u01fe\7c\2\2\u01fe\u01ff\7t\2\2\u01ff\u0200" + + "\7\65\2\2\u0200\u0201\7\64\2\2\u0201\u0202\7a\2\2\u0202\u0203\7v\2\2\u0203" + + "*\3\2\2\2\u0204\u0205\7e\2\2\u0205\u0206\7n\2\2\u0206\u0207\7c\2\2\u0207" + + "\u0208\7u\2\2\u0208\u0209\7u\2\2\u0209,\3\2\2\2\u020a\u020b\7e\2\2\u020b" + + "\u020c\7q\2\2\u020c\u020d\7p\2\2\u020d\u020e\7u\2\2\u020e\u020f\7v\2\2" + + "\u020f.\3\2\2\2\u0210\u0211\7e\2\2\u0211\u0212\7q\2\2\u0212\u0213\7p\2" + + "\2\u0213\u0214\7u\2\2\u0214\u0215\7v\2\2\u0215\u0216\7g\2\2\u0216\u0217" + + "\7z\2\2\u0217\u0218\7r\2\2\u0218\u0219\7t\2\2\u0219\60\3\2\2\2\u021a\u021b" + + "\7e\2\2\u021b\u021c\7q\2\2\u021c\u021d\7p\2\2\u021d\u021e\7u\2\2\u021e" + + "\u021f\7v\2\2\u021f\u0220\7a\2\2\u0220\u0221\7e\2\2\u0221\u0222\7c\2\2" + + "\u0222\u0223\7u\2\2\u0223\u0224\7v\2\2\u0224\62\3\2\2\2\u0225\u0226\7" + + "e\2\2\u0226\u0227\7q\2\2\u0227\u0228\7p\2\2\u0228\u0229\7v\2\2\u0229\u022a" + + "\7k\2\2\u022a\u022b\7p\2\2\u022b\u022c\7w\2\2\u022c\u022d\7g\2\2\u022d" + + "\64\3\2\2\2\u022e\u022f\7f\2\2\u022f\u0230\7g\2\2\u0230\u0231\7e\2\2\u0231" + + "\u0232\7n\2\2\u0232\u0233\7v\2\2\u0233\u0234\7{\2\2\u0234\u0235\7r\2\2" + + "\u0235\u0236\7g\2\2\u0236\66\3\2\2\2\u0237\u0238\7f\2\2\u0238\u0239\7" + + "g\2\2\u0239\u023a\7h\2\2\u023a\u023b\7c\2\2\u023b\u023c\7w\2\2\u023c\u023d" + + "\7n\2\2\u023d\u023e\7v\2\2\u023e8\3\2\2\2\u023f\u0240\7f\2\2\u0240\u0241" + + "\7g\2\2\u0241\u0242\7n\2\2\u0242\u0243\7g\2\2\u0243\u0244\7v\2\2\u0244" + + "\u0245\7g\2\2\u0245:\3\2\2\2\u0246\u0247\7f\2\2\u0247\u0248\7q\2\2\u0248" + + "<\3\2\2\2\u0249\u024a\7f\2\2\u024a\u024b\7q\2\2\u024b\u024c\7w\2\2\u024c" + + "\u024d\7d\2\2\u024d\u024e\7n\2\2\u024e\u024f\7g\2\2\u024f>\3\2\2\2\u0250" + + "\u0251\7f\2\2\u0251\u0252\7{\2\2\u0252\u0253\7p\2\2\u0253\u0254\7c\2\2" + + "\u0254\u0255\7o\2\2\u0255\u0256\7k\2\2\u0256\u0257\7e\2\2\u0257\u0258" + + "\7a\2\2\u0258\u0259\7e\2\2\u0259\u025a\7c\2\2\u025a\u025b\7u\2\2\u025b" + + "\u025c\7v\2\2\u025c@\3\2\2\2\u025d\u025e\7g\2\2\u025e\u025f\7n\2\2\u025f" + + "\u0260\7u\2\2\u0260\u0261\7g\2\2\u0261B\3\2\2\2\u0262\u0263\7g\2\2\u0263" + + "\u0264\7p\2\2\u0264\u0265\7w\2\2\u0265\u0266\7o\2\2\u0266D\3\2\2\2\u0267" + + "\u0268\7g\2\2\u0268\u0269\7z\2\2\u0269\u026a\7r\2\2\u026a\u026b\7n\2\2" + + "\u026b\u026c\7k\2\2\u026c\u026d\7e\2\2\u026d\u026e\7k\2\2\u026e\u026f" + + "\7v\2\2\u026fF\3\2\2\2\u0270\u0271\7g\2\2\u0271\u0272\7z\2\2\u0272\u0273" + + "\7r\2\2\u0273\u0274\7q\2\2\u0274\u0275\7t\2\2\u0275\u0276\7v\2\2\u0276" + + "H\3\2\2\2\u0277\u0278\7g\2\2\u0278\u0279\7z\2\2\u0279\u027a\7v\2\2\u027a" + + "\u027b\7g\2\2\u027b\u027c\7t\2\2\u027c\u027d\7p\2\2\u027dJ\3\2\2\2\u027e" + + "\u027f\7h\2\2\u027f\u0280\7c\2\2\u0280\u0281\7n\2\2\u0281\u0282\7u\2\2" + + "\u0282\u0283\7g\2\2\u0283L\3\2\2\2\u0284\u0285\7h\2\2\u0285\u0286\7k\2" + + "\2\u0286\u0287\7p\2\2\u0287\u0288\7c\2\2\u0288\u0289\7n\2\2\u0289N\3\2" + + "\2\2\u028a\u028b\7h\2\2\u028b\u028c\7n\2\2\u028c\u028d\7q\2\2\u028d\u028e" + + "\7c\2\2\u028e\u028f\7v\2\2\u028fP\3\2\2\2\u0290\u0291\7h\2\2\u0291\u0292" + + "\7q\2\2\u0292\u0293\7t\2\2\u0293R\3\2\2\2\u0294\u0295\7h\2\2\u0295\u0296" + + "\7t\2\2\u0296\u0297\7k\2\2\u0297\u0298\7g\2\2\u0298\u0299\7p\2\2\u0299" + + "\u029a\7f\2\2\u029aT\3\2\2\2\u029b\u029c\7i\2\2\u029c\u029d\7q\2\2\u029d" + + "\u029e\7v\2\2\u029e\u029f\7q\2\2\u029fV\3\2\2\2\u02a0\u02a1\7k\2\2\u02a1" + + "\u02a2\7h\2\2\u02a2X\3\2\2\2\u02a3\u02a4\7k\2\2\u02a4\u02a5\7p\2\2\u02a5" + + "\u02a6\7n\2\2\u02a6\u02a7\7k\2\2\u02a7\u02a8\7p\2\2\u02a8\u02a9\7g\2\2" + + "\u02a9Z\3\2\2\2\u02aa\u02ab\7k\2\2\u02ab\u02ac\7p\2\2\u02ac\u02ad\7v\2" + + "\2\u02ad\\\3\2\2\2\u02ae\u02af\7n\2\2\u02af\u02b0\7q\2\2\u02b0\u02b1\7" + + "p\2\2\u02b1\u02b2\7i\2\2\u02b2^\3\2\2\2\u02b3\u02b4\7o\2\2\u02b4\u02b5" + + "\7w\2\2\u02b5\u02b6\7v\2\2\u02b6\u02b7\7c\2\2\u02b7\u02b8\7d\2\2\u02b8" + + "\u02b9\7n\2\2\u02b9\u02ba\7g\2\2\u02ba`\3\2\2\2\u02bb\u02bc\7p\2\2\u02bc" + + "\u02bd\7c\2\2\u02bd\u02be\7o\2\2\u02be\u02bf\7g\2\2\u02bf\u02c0\7u\2\2" + + "\u02c0\u02c1\7r\2\2\u02c1\u02c2\7c\2\2\u02c2\u02c3\7e\2\2\u02c3\u02c4" + + "\7g\2\2\u02c4b\3\2\2\2\u02c5\u02c6\7p\2\2\u02c6\u02c7\7g\2\2\u02c7\u02c8" + + "\7y\2\2\u02c8d\3\2\2\2\u02c9\u02ca\7p\2\2\u02ca\u02cb\7q\2\2\u02cb\u02cc" + + "\7g\2\2\u02cc\u02cd\7z\2\2\u02cd\u02ce\7e\2\2\u02ce\u02cf\7g\2\2\u02cf" + + "\u02d0\7r\2\2\u02d0\u02d1\7v\2\2\u02d1f\3\2\2\2\u02d2\u02d3\7p\2\2\u02d3" + + "\u02d4\7w\2\2\u02d4\u02d5\7n\2\2\u02d5\u02d6\7n\2\2\u02d6\u02d7\7r\2\2" + + "\u02d7\u02d8\7v\2\2\u02d8\u02d9\7t\2\2\u02d9h\3\2\2\2\u02da\u02db\7q\2" + + "\2\u02db\u02dc\7r\2\2\u02dc\u02dd\7g\2\2\u02dd\u02de\7t\2\2\u02de\u02df" + + "\7c\2\2\u02df\u02e0\7v\2\2\u02e0\u02e1\7q\2\2\u02e1\u02e2\7t\2\2\u02e2" + + "j\3\2\2\2\u02e3\u02e4\7q\2\2\u02e4\u02e5\7x\2\2\u02e5\u02e6\7g\2\2\u02e6" + + "\u02e7\7t\2\2\u02e7\u02e8\7t\2\2\u02e8\u02e9\7k\2\2\u02e9\u02ea\7f\2\2" + + "\u02ea\u02eb\7g\2\2\u02ebl\3\2\2\2\u02ec\u02ed\7r\2\2\u02ed\u02ee\7t\2" + + "\2\u02ee\u02ef\7k\2\2\u02ef\u02f0\7x\2\2\u02f0\u02f1\7c\2\2\u02f1\u02f2" + + "\7v\2\2\u02f2\u02f3\7g\2\2\u02f3n\3\2\2\2\u02f4\u02f5\7r\2\2\u02f5\u02f6" + + "\7t\2\2\u02f6\u02f7\7q\2\2\u02f7\u02f8\7v\2\2\u02f8\u02f9\7g\2\2\u02f9" + + "\u02fa\7e\2\2\u02fa\u02fb\7v\2\2\u02fb\u02fc\7g\2\2\u02fc\u02fd\7f\2\2" + + "\u02fdp\3\2\2\2\u02fe\u02ff\7r\2\2\u02ff\u0300\7w\2\2\u0300\u0301\7d\2" + + "\2\u0301\u0302\7n\2\2\u0302\u0303\7k\2\2\u0303\u0304\7e\2\2\u0304r\3\2" + + "\2\2\u0305\u0306\7t\2\2\u0306\u0307\7g\2\2\u0307\u0308\7i\2\2\u0308\u0309" + + "\7k\2\2\u0309\u030a\7u\2\2\u030a\u030b\7v\2\2\u030b\u030c\7g\2\2\u030c" + + "\u030d\7t\2\2\u030dt\3\2\2\2\u030e\u030f\7t\2\2\u030f\u0310\7g\2\2\u0310" + + "\u0311\7k\2\2\u0311\u0312\7p\2\2\u0312\u0313\7v\2\2\u0313\u0314\7g\2\2" + + "\u0314\u0315\7t\2\2\u0315\u0316\7r\2\2\u0316\u0317\7t\2\2\u0317\u0318" + + "\7g\2\2\u0318\u0319\7v\2\2\u0319\u031a\7a\2\2\u031a\u031b\7e\2\2\u031b" + + "\u031c\7c\2\2\u031c\u031d\7u\2\2\u031d\u031e\7v\2\2\u031ev\3\2\2\2\u031f" + + "\u0320\7t\2\2\u0320\u0321\7g\2\2\u0321\u0322\7v\2\2\u0322\u0323\7w\2\2" + + "\u0323\u0324\7t\2\2\u0324\u0325\7p\2\2\u0325x\3\2\2\2\u0326\u0327\7u\2" + + "\2\u0327\u0328\7j\2\2\u0328\u0329\7q\2\2\u0329\u032a\7t\2\2\u032a\u032b" + + "\7v\2\2\u032bz\3\2\2\2\u032c\u032d\7u\2\2\u032d\u032e\7k\2\2\u032e\u032f" + + "\7i\2\2\u032f\u0330\7p\2\2\u0330\u0331\7g\2\2\u0331\u0332\7f\2\2\u0332" + + "|\3\2\2\2\u0333\u0334\7u\2\2\u0334\u0335\7k\2\2\u0335\u0336\7|\2\2\u0336" + + "\u0337\7g\2\2\u0337\u0338\7q\2\2\u0338\u0339\7h\2\2\u0339~\3\2\2\2\u033a" + + "\u033b\7u\2\2\u033b\u033c\7v\2\2\u033c\u033d\7c\2\2\u033d\u033e\7v\2\2" + + "\u033e\u033f\7k\2\2\u033f\u0340\7e\2\2\u0340\u0080\3\2\2\2\u0341\u0342" + + "\7u\2\2\u0342\u0343\7v\2\2\u0343\u0344\7c\2\2\u0344\u0345\7v\2\2\u0345" + + "\u0346\7k\2\2\u0346\u0347\7e\2\2\u0347\u0348\7a\2\2\u0348\u0349\7c\2\2" + + "\u0349\u034a\7u\2\2\u034a\u034b\7u\2\2\u034b\u034c\7g\2\2\u034c\u034d" + + "\7t\2\2\u034d\u034e\7v\2\2\u034e\u0082\3\2\2\2\u034f\u0350\7u\2\2\u0350" + + "\u0351\7v\2\2\u0351\u0352\7c\2\2\u0352\u0353\7v\2\2\u0353\u0354\7k\2\2" + + "\u0354\u0355\7e\2\2\u0355\u0356\7a\2\2\u0356\u0357\7e\2\2\u0357\u0358" + + "\7c\2\2\u0358\u0359\7u\2\2\u0359\u035a\7v\2\2\u035a\u0084\3\2\2\2\u035b" + + "\u035c\7u\2\2\u035c\u035d\7v\2\2\u035d\u035e\7t\2\2\u035e\u035f\7w\2\2" + + "\u035f\u0360\7e\2\2\u0360\u0361\7v\2\2\u0361\u0086\3\2\2\2\u0362\u0363" + + "\7u\2\2\u0363\u0364\7y\2\2\u0364\u0365\7k\2\2\u0365\u0366\7v\2\2\u0366" + + "\u0367\7e\2\2\u0367\u0368\7j\2\2\u0368\u0088\3\2\2\2\u0369\u036a\7v\2" + + "\2\u036a\u036b\7g\2\2\u036b\u036c\7o\2\2\u036c\u036d\7r\2\2\u036d\u036e" + + "\7n\2\2\u036e\u036f\7c\2\2\u036f\u0370\7v\2\2\u0370\u0371\7g\2\2\u0371" + + "\u008a\3\2\2\2\u0372\u0373\7v\2\2\u0373\u0374\7j\2\2\u0374\u0375\7k\2" + + "\2\u0375\u0376\7u\2\2\u0376\u008c\3\2\2\2\u0377\u0378\7v\2\2\u0378\u0379" + + "\7j\2\2\u0379\u037a\7t\2\2\u037a\u037b\7g\2\2\u037b\u037c\7c\2\2\u037c" + + "\u037d\7f\2\2\u037d\u037e\7a\2\2\u037e\u037f\7n\2\2\u037f\u0380\7q\2\2" + + "\u0380\u0381\7e\2\2\u0381\u0382\7c\2\2\u0382\u0383\7n\2\2\u0383\u008e" + + "\3\2\2\2\u0384\u0385\7v\2\2\u0385\u0386\7j\2\2\u0386\u0387\7t\2\2\u0387" + + "\u0388\7q\2\2\u0388\u0389\7y\2\2\u0389\u0090\3\2\2\2\u038a\u038b\7v\2" + + "\2\u038b\u038c\7t\2\2\u038c\u038d\7w\2\2\u038d\u038e\7g\2\2\u038e\u0092" + + "\3\2\2\2\u038f\u0390\7v\2\2\u0390\u0391\7t\2\2\u0391\u0392\7{\2\2\u0392" + + "\u0094\3\2\2\2\u0393\u0394\7v\2\2\u0394\u0395\7{\2\2\u0395\u0396\7r\2" + + "\2\u0396\u0397\7g\2\2\u0397\u0398\7f\2\2\u0398\u0399\7g\2\2\u0399\u039a" + + "\7h\2\2\u039a\u0096\3\2\2\2\u039b\u039c\7v\2\2\u039c\u039d\7{\2\2\u039d" + + "\u039e\7r\2\2\u039e\u039f\7g\2\2\u039f\u03a0\7k\2\2\u03a0\u03a1\7f\2\2" + + "\u03a1\u0098\3\2\2\2\u03a2\u03a3\7v\2\2\u03a3\u03a4\7{\2\2\u03a4\u03a5" + + "\7r\2\2\u03a5\u03a6\7g\2\2\u03a6\u03a7\7p\2\2\u03a7\u03a8\7c\2\2\u03a8" + + "\u03a9\7o\2\2\u03a9\u03aa\7g\2\2\u03aa\u009a\3\2\2\2\u03ab\u03ac\7w\2" + + "\2\u03ac\u03ad\7p\2\2\u03ad\u03ae\7k\2\2\u03ae\u03af\7q\2\2\u03af\u03b0" + + "\7p\2\2\u03b0\u009c\3\2\2\2\u03b1\u03b2\7w\2\2\u03b2\u03b3\7p\2\2\u03b3" + + "\u03b4\7u\2\2\u03b4\u03b5\7k\2\2\u03b5\u03b6\7i\2\2\u03b6\u03b7\7p\2\2" + + "\u03b7\u03b8\7g\2\2\u03b8\u03b9\7f\2\2\u03b9\u009e\3\2\2\2\u03ba\u03bb" + + "\7w\2\2\u03bb\u03bc\7u\2\2\u03bc\u03bd\7k\2\2\u03bd\u03be\7p\2\2\u03be" + + "\u03bf\7i\2\2\u03bf\u00a0\3\2\2\2\u03c0\u03c1\7x\2\2\u03c1\u03c2\7k\2" + + "\2\u03c2\u03c3\7t\2\2\u03c3\u03c4\7v\2\2\u03c4\u03c5\7w\2\2\u03c5\u03c6" + + "\7c\2\2\u03c6\u03c7\7n\2\2\u03c7\u00a2\3\2\2\2\u03c8\u03c9\7x\2\2\u03c9" + + "\u03ca\7q\2\2\u03ca\u03cb\7k\2\2\u03cb\u03cc\7f\2\2\u03cc\u00a4\3\2\2" + + "\2\u03cd\u03ce\7x\2\2\u03ce\u03cf\7q\2\2\u03cf\u03d0\7n\2\2\u03d0\u03d1" + + "\7c\2\2\u03d1\u03d2\7v\2\2\u03d2\u03d3\7k\2\2\u03d3\u03d4\7n\2\2\u03d4" + + "\u03d5\7g\2\2\u03d5\u00a6\3\2\2\2\u03d6\u03d7\7y\2\2\u03d7\u03d8\7e\2" + + "\2\u03d8\u03d9\7j\2\2\u03d9\u03da\7c\2\2\u03da\u03db\7t\2\2\u03db\u03dc" + + "\7a\2\2\u03dc\u03dd\7v\2\2\u03dd\u00a8\3\2\2\2\u03de\u03df\7y\2\2\u03df" + + "\u03e0\7j\2\2\u03e0\u03e1\7k\2\2\u03e1\u03e2\7n\2\2\u03e2\u03e3\7g\2\2" + + "\u03e3\u00aa\3\2\2\2\u03e4\u03e5\7*\2\2\u03e5\u00ac\3\2\2\2\u03e6\u03e7" + + "\7+\2\2\u03e7\u00ae\3\2\2\2\u03e8\u03e9\7]\2\2\u03e9\u00b0\3\2\2\2\u03ea" + + "\u03eb\7_\2\2\u03eb\u00b2\3\2\2\2\u03ec\u03ed\7}\2\2\u03ed\u00b4\3\2\2" + + "\2\u03ee\u03ef\7\177\2\2\u03ef\u00b6\3\2\2\2\u03f0\u03f1\7-\2\2\u03f1" + + "\u00b8\3\2\2\2\u03f2\u03f3\7/\2\2\u03f3\u00ba\3\2\2\2\u03f4\u03f5\7,\2" + + "\2\u03f5\u00bc\3\2\2\2\u03f6\u03f7\7\61\2\2\u03f7\u00be\3\2\2\2\u03f8" + + "\u03f9\7\'\2\2\u03f9\u00c0\3\2\2\2\u03fa\u03fb\7`\2\2\u03fb\u00c2\3\2" + + "\2\2\u03fc\u03fd\7(\2\2\u03fd\u00c4\3\2\2\2\u03fe\u03ff\7~\2\2\u03ff\u00c6" + + "\3\2\2\2\u0400\u0401\7\u0080\2\2\u0401\u00c8\3\2\2\2\u0402\u0407\7#\2" + + "\2\u0403\u0404\7p\2\2\u0404\u0405\7q\2\2\u0405\u0407\7v\2\2\u0406\u0402" + + "\3\2\2\2\u0406\u0403\3\2\2\2\u0407\u00ca\3\2\2\2\u0408\u0409\7?\2\2\u0409" + + "\u00cc\3\2\2\2\u040a\u040b\7>\2\2\u040b\u00ce\3\2\2\2\u040c\u040d\7@\2" + + "\2\u040d\u00d0\3\2\2\2\u040e\u040f\7-\2\2\u040f\u0410\7?\2\2\u0410\u00d2" + + "\3\2\2\2\u0411\u0412\7/\2\2\u0412\u0413\7?\2\2\u0413\u00d4\3\2\2\2\u0414" + + "\u0415\7,\2\2\u0415\u0416\7?\2\2\u0416\u00d6\3\2\2\2\u0417\u0418\7\61" + + "\2\2\u0418\u0419\7?\2\2\u0419\u00d8\3\2\2\2\u041a\u041b\7\'\2\2\u041b" + + "\u041c\7?\2\2\u041c\u00da\3\2\2\2\u041d\u041e\7`\2\2\u041e\u041f\7?\2" + + "\2\u041f\u00dc\3\2\2\2\u0420\u0421\7(\2\2\u0421\u0422\7?\2\2\u0422\u00de" + + "\3\2\2\2\u0423\u0424\7~\2\2\u0424\u0425\7?\2\2\u0425\u00e0\3\2\2\2\u0426" + + "\u0427\7>\2\2\u0427\u0428\7>\2\2\u0428\u0429\7?\2\2\u0429\u00e2\3\2\2" + + "\2\u042a\u042b\7@\2\2\u042b\u042c\7@\2\2\u042c\u042d\7?\2\2\u042d\u00e4" + + "\3\2\2\2\u042e\u042f\7?\2\2\u042f\u0430\7?\2\2\u0430\u00e6\3\2\2\2\u0431" + + "\u0432\7#\2\2\u0432\u0433\7?\2\2\u0433\u00e8\3\2\2\2\u0434\u0435\7>\2" + + "\2\u0435\u0436\7?\2\2\u0436\u00ea\3\2\2\2\u0437\u0438\7@\2\2\u0438\u0439" + + "\7?\2\2\u0439\u00ec\3\2\2\2\u043a\u043b\7(\2\2\u043b\u0440\7(\2\2\u043c" + + "\u043d\7c\2\2\u043d\u043e\7p\2\2\u043e\u0440\7f\2\2\u043f\u043a\3\2\2" + + "\2\u043f\u043c\3\2\2\2\u0440\u00ee\3\2\2\2\u0441\u0442\7~\2\2\u0442\u0446" + + "\7~\2\2\u0443\u0444\7q\2\2\u0444\u0446\7t\2\2\u0445\u0441\3\2\2\2\u0445" + + "\u0443\3\2\2\2\u0446\u00f0\3\2\2\2\u0447\u0448\7-\2\2\u0448\u0449\7-\2" + + "\2\u0449\u00f2\3\2\2\2\u044a\u044b\7/\2\2\u044b\u044c\7/\2\2\u044c\u00f4" + + "\3\2\2\2\u044d\u044e\7.\2\2\u044e\u00f6\3\2\2\2\u044f\u0450\7/\2\2\u0450" + + "\u0451\7@\2\2\u0451\u0452\7,\2\2\u0452\u00f8\3\2\2\2\u0453\u0454\7/\2" + + "\2\u0454\u0455\7@\2\2\u0455\u00fa\3\2\2\2\u0456\u0457\7A\2\2\u0457\u00fc" + + "\3\2\2\2\u0458\u0459\7<\2\2\u0459\u00fe\3\2\2\2\u045a\u045b\7<\2\2\u045b" + + "\u045c\7<\2\2\u045c\u0100\3\2\2\2\u045d\u045e\7=\2\2\u045e\u0102\3\2\2" + + "\2\u045f\u0460\7\60\2\2\u0460\u0104\3\2\2\2\u0461\u0462\7\60\2\2\u0462" + + "\u0463\7,\2\2\u0463\u0106\3\2\2\2\u0464\u0465\7\60\2\2\u0465\u0466\7\60" + + "\2\2\u0466\u0467\7\60\2\2\u0467\u0108\3\2\2\2\u0468\u0469\5\u0121\u0091" + + "\2\u0469\u046a\5\u0121\u0091\2\u046a\u046b\5\u0121\u0091\2\u046b\u046c" + + "\5\u0121\u0091\2\u046c\u010a\3\2\2\2\u046d\u046e\7^\2\2\u046e\u046f\7" + + "w\2\2\u046f\u0470\3\2\2\2\u0470\u0478\5\u0109\u0085\2\u0471\u0472\7^\2" + + "\2\u0472\u0473\7W\2\2\u0473\u0474\3\2\2\2\u0474\u0475\5\u0109\u0085\2" + + "\u0475\u0476\5\u0109\u0085\2\u0476\u0478\3\2\2\2\u0477\u046d\3\2\2\2\u0477" + + "\u0471\3\2\2\2\u0478\u010c\3\2\2\2\u0479\u047e\5\u010f\u0088\2\u047a\u047d" + + "\5\u010f\u0088\2\u047b\u047d\5\u0113\u008a\2\u047c\u047a\3\2\2\2\u047c" + + "\u047b\3\2\2\2\u047d\u0480\3\2\2\2\u047e\u047c\3\2\2\2\u047e\u047f\3\2" + + "\2\2\u047f\u010e\3\2\2\2\u0480\u047e\3\2\2\2\u0481\u0484\5\u0111\u0089" + + "\2\u0482\u0484\5\u010b\u0086\2\u0483\u0481\3\2\2\2\u0483\u0482\3\2\2\2" + + "\u0484\u0110\3\2\2\2\u0485\u0486\t\4\2\2\u0486\u0112\3\2\2\2\u0487\u0488" + + "\t\5\2\2\u0488\u0114\3\2\2\2\u0489\u0490\5\u011d\u008f\2\u048a\u048c\7" + + ")\2\2\u048b\u048a\3\2\2\2\u048b\u048c\3\2\2\2\u048c\u048d\3\2\2\2\u048d" + + "\u048f\5\u0113\u008a\2\u048e\u048b\3\2\2\2\u048f\u0492\3\2\2\2\u0490\u048e" + + "\3\2\2\2\u0490\u0491\3\2\2\2\u0491\u0116\3\2\2\2\u0492\u0490\3\2\2\2\u0493" + + "\u049a\7\62\2\2\u0494\u0496\7)\2\2\u0495\u0494\3\2\2\2\u0495\u0496\3\2" + + "\2\2\u0496\u0497\3\2\2\2\u0497\u0499\5\u011f\u0090\2\u0498\u0495\3\2\2" + + "\2\u0499\u049c\3\2\2\2\u049a\u0498\3\2\2\2\u049a\u049b\3\2\2\2\u049b\u0118" + + "\3\2\2\2\u049c\u049a\3\2\2\2\u049d\u049e\7\62\2\2\u049e\u04a2\7z\2\2\u049f" + + "\u04a0\7\62\2\2\u04a0\u04a2\7Z\2\2\u04a1\u049d\3\2\2\2\u04a1\u049f\3\2" + + "\2\2\u04a2\u04a3\3\2\2\2\u04a3\u04aa\5\u0121\u0091\2\u04a4\u04a6\7)\2" + + "\2\u04a5\u04a4\3\2\2\2\u04a5\u04a6\3\2\2\2\u04a6\u04a7\3\2\2\2\u04a7\u04a9" + + "\5\u0121\u0091\2\u04a8\u04a5\3\2\2\2\u04a9\u04ac\3\2\2\2\u04aa\u04a8\3" + + "\2\2\2\u04aa\u04ab\3\2\2\2\u04ab\u011a\3\2\2\2\u04ac\u04aa\3\2\2\2\u04ad" + + "\u04ae\7\62\2\2\u04ae\u04b2\7d\2\2\u04af\u04b0\7\62\2\2\u04b0\u04b2\7" + + "D\2\2\u04b1\u04ad\3\2\2\2\u04b1\u04af\3\2\2\2\u04b2\u04b3\3\2\2\2\u04b3" + + "\u04ba\5\u0123\u0092\2\u04b4\u04b6\7)\2\2\u04b5\u04b4\3\2\2\2\u04b5\u04b6" + + "\3\2\2\2\u04b6\u04b7\3\2\2\2\u04b7\u04b9\5\u0123\u0092\2\u04b8\u04b5\3" + + "\2\2\2\u04b9\u04bc\3\2\2\2\u04ba\u04b8\3\2\2\2\u04ba\u04bb\3\2\2\2\u04bb" + + "\u011c\3\2\2\2\u04bc\u04ba\3\2\2\2\u04bd\u04be\t\6\2\2\u04be\u011e\3\2" + + "\2\2\u04bf\u04c0\t\7\2\2\u04c0\u0120\3\2\2\2\u04c1\u04c2\t\b\2\2\u04c2" + + "\u0122\3\2\2\2\u04c3\u04c4\t\t\2\2\u04c4\u0124\3\2\2\2\u04c5\u04c7\5\u0127" + + "\u0094\2\u04c6\u04c8\5\u0129\u0095\2\u04c7\u04c6\3\2\2\2\u04c7\u04c8\3" + + "\2\2\2\u04c8\u04d6\3\2\2\2\u04c9\u04cb\5\u0127\u0094\2\u04ca\u04cc\5\u012b" + + "\u0096\2\u04cb\u04ca\3\2\2\2\u04cb\u04cc\3\2\2\2\u04cc\u04d6\3\2\2\2\u04cd" + + "\u04cf\5\u0129\u0095\2\u04ce\u04d0\5\u0127\u0094\2\u04cf\u04ce\3\2\2\2" + + "\u04cf\u04d0\3\2\2\2\u04d0\u04d6\3\2\2\2\u04d1\u04d3\5\u012b\u0096\2\u04d2" + + "\u04d4\5\u0127\u0094\2\u04d3\u04d2\3\2\2\2\u04d3\u04d4\3\2\2\2\u04d4\u04d6" + + "\3\2\2\2\u04d5\u04c5\3\2\2\2\u04d5\u04c9\3\2\2\2\u04d5\u04cd\3\2\2\2\u04d5" + + "\u04d1\3\2\2\2\u04d6\u0126\3\2\2\2\u04d7\u04d8\t\n\2\2\u04d8\u0128\3\2" + + "\2\2\u04d9\u04da\t\13\2\2\u04da\u012a\3\2\2\2\u04db\u04dc\7n\2\2\u04dc" + + "\u04e0\7n\2\2\u04dd\u04de\7N\2\2\u04de\u04e0\7N\2\2\u04df\u04db\3\2\2" + + "\2\u04df\u04dd\3\2\2\2\u04e0\u012c\3\2\2\2\u04e1\u04e5\n\f\2\2\u04e2\u04e5" + + "\5\u012f\u0098\2\u04e3\u04e5\5\u010b\u0086\2\u04e4\u04e1\3\2\2\2\u04e4" + + "\u04e2\3\2\2\2\u04e4\u04e3\3\2\2\2\u04e5\u012e\3\2\2\2\u04e6\u04ea\5\u0131" + + "\u0099\2\u04e7\u04ea\5\u0133\u009a\2\u04e8\u04ea\5\u0135\u009b\2\u04e9" + + "\u04e6\3\2\2\2\u04e9\u04e7\3\2\2\2\u04e9\u04e8\3\2\2\2\u04ea\u0130\3\2" + + "\2\2\u04eb\u04ec\7^\2\2\u04ec\u050a\7)\2\2\u04ed\u04ee\7^\2\2\u04ee\u050a" + + "\7$\2\2\u04ef\u04f0\7^\2\2\u04f0\u050a\7A\2\2\u04f1\u04f2\7^\2\2\u04f2" + + "\u050a\7^\2\2\u04f3\u04f4\7^\2\2\u04f4\u050a\7c\2\2\u04f5\u04f6\7^\2\2" + + "\u04f6\u050a\7d\2\2\u04f7\u04f8\7^\2\2\u04f8\u050a\7h\2\2\u04f9\u04fa" + + "\7^\2\2\u04fa\u050a\7p\2\2\u04fb\u04fc\7^\2\2\u04fc\u050a\7t\2\2\u04fd" + + "\u0503\7^\2\2\u04fe\u0500\7\17\2\2\u04ff\u0501\7\f\2\2\u0500\u04ff\3\2" + + "\2\2\u0500\u0501\3\2\2\2\u0501\u0504\3\2\2\2\u0502\u0504\7\f\2\2\u0503" + + "\u04fe\3\2\2\2\u0503\u0502\3\2\2\2\u0504\u050a\3\2\2\2\u0505\u0506\7^" + + "\2\2\u0506\u050a\7v\2\2\u0507\u0508\7^\2\2\u0508\u050a\7x\2\2\u0509\u04eb" + + "\3\2\2\2\u0509\u04ed\3\2\2\2\u0509\u04ef\3\2\2\2\u0509\u04f1\3\2\2\2\u0509" + + "\u04f3\3\2\2\2\u0509\u04f5\3\2\2\2\u0509\u04f7\3\2\2\2\u0509\u04f9\3\2" + + "\2\2\u0509\u04fb\3\2\2\2\u0509\u04fd\3\2\2\2\u0509\u0505\3\2\2\2\u0509" + + "\u0507\3\2\2\2\u050a\u0132\3\2\2\2\u050b\u050c\7^\2\2\u050c\u0517\5\u011f" + + "\u0090\2\u050d\u050e\7^\2\2\u050e\u050f\5\u011f\u0090\2\u050f\u0510\5" + + "\u011f\u0090\2\u0510\u0517\3\2\2\2\u0511\u0512\7^\2\2\u0512\u0513\5\u011f" + + "\u0090\2\u0513\u0514\5\u011f\u0090\2\u0514\u0515\5\u011f\u0090\2\u0515" + + "\u0517\3\2\2\2\u0516\u050b\3\2\2\2\u0516\u050d\3\2\2\2\u0516\u0511\3\2" + + "\2\2\u0517\u0134\3\2\2\2\u0518\u0519\7^\2\2\u0519\u051a\7z\2\2\u051a\u051c" + + "\3\2\2\2\u051b\u051d\5\u0121\u0091\2\u051c\u051b\3\2\2\2\u051d\u051e\3" + + "\2\2\2\u051e\u051c\3\2\2\2\u051e\u051f\3\2\2\2\u051f\u0136\3\2\2\2\u0520" + + "\u0522\5\u013d\u009f\2\u0521\u0520\3\2\2\2\u0521\u0522\3\2\2\2\u0522\u0523" + + "\3\2\2\2\u0523\u0524\7\60\2\2\u0524\u0529\5\u013d\u009f\2\u0525\u0526" + + "\5\u013d\u009f\2\u0526\u0527\7\60\2\2\u0527\u0529\3\2\2\2\u0528\u0521" + + "\3\2\2\2\u0528\u0525\3\2\2\2\u0529\u0138\3\2\2\2\u052a\u052c\7g\2\2\u052b" + + "\u052d\5\u013b\u009e\2\u052c\u052b\3\2\2\2\u052c\u052d\3\2\2\2\u052d\u052e" + + "\3\2\2\2\u052e\u0535\5\u013d\u009f\2\u052f\u0531\7G\2\2\u0530\u0532\5" + + "\u013b\u009e\2\u0531\u0530\3\2\2\2\u0531\u0532\3\2\2\2\u0532\u0533\3\2" + + "\2\2\u0533\u0535\5\u013d\u009f\2\u0534\u052a\3\2\2\2\u0534\u052f\3\2\2" + + "\2\u0535\u013a\3\2\2\2\u0536\u0537\t\r\2\2\u0537\u013c\3\2\2\2\u0538\u053f" + + "\5\u0113\u008a\2\u0539\u053b\7)\2\2\u053a\u0539\3\2\2\2\u053a\u053b\3" + + "\2\2\2\u053b\u053c\3\2\2\2\u053c\u053e\5\u0113\u008a\2\u053d\u053a\3\2" + + "\2\2\u053e\u0541\3\2\2\2\u053f\u053d\3\2\2\2\u053f\u0540\3\2\2\2\u0540" + + "\u013e\3\2\2\2\u0541\u053f\3\2\2\2\u0542\u0543\t\16\2\2\u0543\u0140\3" + + "\2\2\2\u0544\u0545\7w\2\2\u0545\u0548\7:\2\2\u0546\u0548\t\2\2\2\u0547" + + "\u0544\3\2\2\2\u0547\u0546\3\2\2\2\u0548\u0142\3\2\2\2\u0549\u054d\n\17" + + "\2\2\u054a\u054d\5\u012f\u0098\2\u054b\u054d\5\u010b\u0086\2\u054c\u0549" + + "\3\2\2\2\u054c\u054a\3\2\2\2\u054c\u054b\3\2\2\2\u054d\u0144\3\2\2\2\u054e" + + "\u054f\7T\2\2\u054f\u0550\7$\2\2\u0550\u0556\3\2\2\2\u0551\u0552\7^\2" + + "\2\u0552\u0555\t\20\2\2\u0553\u0555\n\21\2\2\u0554\u0551\3\2\2\2\u0554" + + "\u0553\3\2\2\2\u0555\u0558\3\2\2\2\u0556\u0557\3\2\2\2\u0556\u0554\3\2" + + "\2\2\u0557\u0559\3\2\2\2\u0558\u0556\3\2\2\2\u0559\u055d\7*\2\2\u055a" + + "\u055c\n\22\2\2\u055b\u055a\3\2\2\2\u055c\u055f\3\2\2\2\u055d\u055e\3" + + "\2\2\2\u055d\u055b\3\2\2\2\u055e\u0560\3\2\2\2\u055f\u055d\3\2\2\2\u0560" + + "\u0566\7+\2\2\u0561\u0562\7^\2\2\u0562\u0565\t\20\2\2\u0563\u0565\n\23" + + "\2\2\u0564\u0561\3\2\2\2\u0564\u0563\3\2\2\2\u0565\u0568\3\2\2\2\u0566" + + "\u0567\3\2\2\2\u0566\u0564\3\2\2\2\u0567\u0569\3\2\2\2\u0568\u0566\3\2" + + "\2\2\u0569\u056a\7$\2\2\u056a\u0146\3\2\2\2\u056b\u056c\5\u0115\u008b" + + "\2\u056c\u056d\5\u014f\u00a8\2\u056d\u0578\3\2\2\2\u056e\u056f\5\u0117" + + "\u008c\2\u056f\u0570\5\u014f\u00a8\2\u0570\u0578\3\2\2\2\u0571\u0572\5" + + "\u0119\u008d\2\u0572\u0573\5\u014f\u00a8\2\u0573\u0578\3\2\2\2\u0574\u0575" + + "\5\u011b\u008e\2\u0575\u0576\5\u014f\u00a8\2\u0576\u0578\3\2\2\2\u0577" + + "\u056b\3\2\2\2\u0577\u056e\3\2\2\2\u0577\u0571\3\2\2\2\u0577\u0574\3\2" + + "\2\2\u0578\u0148\3\2\2\2\u0579\u057b\5\u0137\u009c\2\u057a\u057c\5\u0139" + + "\u009d\2\u057b\u057a\3\2\2\2\u057b\u057c\3\2\2\2\u057c\u057d\3\2\2\2\u057d" + + "\u057e\5\u014f\u00a8\2\u057e\u0584\3\2\2\2\u057f\u0580\5\u013d\u009f\2" + + "\u0580\u0581\5\u0139\u009d\2\u0581\u0582\5\u014f\u00a8\2\u0582\u0584\3" + + "\2\2\2\u0583\u0579\3\2\2\2\u0583\u057f\3\2\2\2\u0584\u014a\3\2\2\2\u0585" + + "\u0586\5\t\5\2\u0586\u0587\5\u014f\u00a8\2\u0587\u014c\3\2\2\2\u0588\u0589" + + "\5\5\3\2\u0589\u058a\5\u014f\u00a8\2\u058a\u014e\3\2\2\2\u058b\u058c\5" + + "\u010d\u0087\2\u058c\u0150\3\2\2\2\u058d\u058f\t\24\2\2\u058e\u058d\3" + + "\2\2\2\u058f\u0590\3\2\2\2\u0590\u058e\3\2\2\2\u0590\u0591\3\2\2\2\u0591" + + "\u0592\3\2\2\2\u0592\u0593\b\u00a9\3\2\u0593\u0152\3\2\2\2\u0594\u0596" + + "\7\17\2\2\u0595\u0597\7\f\2\2\u0596\u0595\3\2\2\2\u0596\u0597\3\2\2\2" + + "\u0597\u059a\3\2\2\2\u0598\u059a\7\f\2\2\u0599\u0594\3\2\2\2\u0599\u0598" + + "\3\2\2\2\u059a\u059b\3\2\2\2\u059b\u059c\b\u00aa\3\2\u059c\u0154\3\2\2" + + "\2\u059d\u059e\7\61\2\2\u059e\u059f\7,\2\2\u059f\u05a3\3\2\2\2\u05a0\u05a2" + + "\13\2\2\2\u05a1\u05a0\3\2\2\2\u05a2\u05a5\3\2\2\2\u05a3\u05a4\3\2\2\2" + + "\u05a3\u05a1\3\2\2\2\u05a4\u05a6\3\2\2\2\u05a5\u05a3\3\2\2\2\u05a6\u05a7" + + "\7,\2\2\u05a7\u05a8\7\61\2\2\u05a8\u05a9\3\2\2\2\u05a9\u05aa\b\u00ab\3" + + "\2\u05aa\u0156\3\2\2\2\u05ab\u05ac\7\61\2\2\u05ac\u05ad\7\61\2\2\u05ad" + + "\u05b1\3\2\2\2\u05ae\u05b0\n\25\2\2\u05af\u05ae\3\2\2\2\u05b0\u05b3\3" + + "\2\2\2\u05b1\u05af\3\2\2\2\u05b1\u05b2\3\2\2\2\u05b2\u05b4\3\2\2\2\u05b3" + + "\u05b1\3\2\2\2\u05b4\u05b5\b\u00ac\3\2\u05b5\u0158\3\2\2\2L\2\u015b\u015f" + + "\u0163\u0167\u0169\u016c\u0172\u0178\u017b\u0180\u0182\u0185\u018c\u0190" + + "\u0194\u019c\u01a2\u01a7\u01ac\u01b1\u01b9\u0406\u043f\u0445\u0477\u047c" + + "\u047e\u0483\u048b\u0490\u0495\u049a\u04a1\u04a5\u04aa\u04b1\u04b5\u04ba" + + "\u04c7\u04cb\u04cf\u04d3\u04d5\u04df\u04e4\u04e9\u0500\u0503\u0509\u0516" + + "\u051e\u0521\u0528\u052c\u0531\u0534\u053a\u053f\u0547\u054c\u0554\u0556" + + "\u055d\u0564\u0566\u0577\u057b\u0583\u0590\u0596\u0599\u05a3\u05b1\4\2" + + "\3\2\b\2\2"; + public static final ATN _ATN = new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache(); + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + public static String[] channelNames = {"DEFAULT_TOKEN_CHANNEL", "HIDDEN"}; + public static String[] modeNames = {"DEFAULT_MODE"}; - 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" - }; + static { + RuntimeMetaData.checkVersion("4.9.3", RuntimeMetaData.VERSION); + } - public static String[] modeNames = { - "DEFAULT_MODE" - }; + 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); + } - 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(); + if (tokenNames[i] == null) { + tokenNames[i] = ""; + } + } + } - 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); + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } - /** - * @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); - } + public CPP14Lexer(CharStream input) { + super(input); + _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache); + } - if (tokenNames[i] == null) { - tokenNames[i] = ""; - } - } - } + 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" + }; + } - @Override - @Deprecated - public String[] getTokenNames() { - return tokenNames; - } + 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, + "'++'", + "'--'", + "','", + "'->*'", + "'->'", + "'?'", + "':'", + "'::'", + "';'", + "'.'", + "'.*'", + "'...'" + }; + } - @Override + 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" + }; + } - public Vocabulary getVocabulary() { - return VOCABULARY; - } + @Override + public String[] getRuleNames() { + return ruleNames; + } + @Override + public Vocabulary getVocabulary() { + return VOCABULARY; + } - public CPP14Lexer(CharStream input) { - super(input); - _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); - } + @Override + public String getSerializedATN() { + return _serializedATN; + } - @Override - public String getGrammarFileName() { return "CPP14Lexer.g4"; } + @Override + public String getGrammarFileName() { + return "CPP14Lexer.g4"; + } - @Override - public String[] getRuleNames() { return ruleNames; } + @Override + public ATN getATN() { + return _ATN; + } - @Override - public String getSerializedATN() { return _serializedATN; } + @Override + public String[] getChannelNames() { + return channelNames; + } - @Override - public String[] getChannelNames() { return channelNames; } + @Override + public String[] getModeNames() { + return modeNames; + } - @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 + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } +} 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 index 58bb3437d..6bcd51703 100644 --- a/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Parser.interp +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Parser.interp @@ -372,6 +372,8 @@ typeSpecifier trailingTypeSpecifier typeSpecifierSeq trailingTypeSpecifierSeq +simpleTypeLengthModifier +simpleTypeSignednessModifier simpleTypeSpecifier theTypeName decltypeSpecifier @@ -487,4 +489,4 @@ 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 +[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 3, 147, 2112, 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, 4, 191, 9, 191, 4, 192, 9, 192, 3, 2, 5, 2, 386, 10, 2, 3, 2, 3, 2, 3, 3, 6, 3, 391, 10, 3, 13, 3, 14, 3, 392, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 5, 3, 402, 10, 3, 3, 4, 3, 4, 5, 4, 406, 10, 4, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 5, 5, 415, 10, 5, 3, 5, 5, 5, 418, 10, 5, 3, 6, 3, 6, 5, 6, 422, 10, 6, 3, 6, 3, 6, 3, 7, 3, 7, 3, 7, 3, 7, 5, 7, 430, 10, 7, 3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 5, 7, 437, 10, 7, 3, 7, 5, 7, 440, 10, 7, 3, 7, 7, 7, 443, 10, 7, 12, 7, 14, 7, 446, 11, 7, 3, 8, 3, 8, 5, 8, 450, 10, 8, 3, 8, 3, 8, 3, 9, 3, 9, 5, 9, 456, 10, 9, 3, 9, 3, 9, 3, 10, 3, 10, 3, 10, 3, 10, 5, 10, 464, 10, 10, 5, 10, 466, 10, 10, 3, 11, 3, 11, 3, 12, 3, 12, 3, 12, 7, 12, 473, 10, 12, 12, 12, 14, 12, 476, 11, 12, 3, 12, 5, 12, 479, 10, 12, 3, 13, 3, 13, 5, 13, 483, 10, 13, 3, 14, 5, 14, 486, 10, 14, 3, 14, 3, 14, 5, 14, 490, 10, 14, 3, 15, 5, 15, 493, 10, 15, 3, 15, 3, 15, 3, 15, 3, 16, 3, 16, 5, 16, 500, 10, 16, 3, 16, 3, 16, 5, 16, 504, 10, 16, 3, 16, 5, 16, 507, 10, 16, 3, 16, 5, 16, 510, 10, 16, 3, 16, 5, 16, 513, 10, 16, 3, 17, 3, 17, 3, 17, 3, 17, 5, 17, 519, 10, 17, 3, 17, 3, 17, 5, 17, 523, 10, 17, 3, 17, 3, 17, 5, 17, 527, 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, 541, 10, 17, 3, 17, 3, 17, 5, 17, 545, 10, 17, 3, 17, 3, 17, 3, 17, 3, 17, 5, 17, 551, 10, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 5, 17, 558, 10, 17, 3, 17, 3, 17, 3, 17, 3, 17, 5, 17, 564, 10, 17, 3, 17, 3, 17, 5, 17, 568, 10, 17, 3, 17, 3, 17, 7, 17, 572, 10, 17, 12, 17, 14, 17, 575, 11, 17, 3, 18, 3, 18, 3, 19, 3, 19, 3, 20, 5, 20, 582, 10, 20, 3, 20, 3, 20, 3, 20, 5, 20, 587, 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, 600, 10, 20, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 5, 21, 607, 10, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 5, 21, 619, 10, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 5, 21, 629, 10, 21, 3, 22, 3, 22, 3, 23, 5, 23, 634, 10, 23, 3, 23, 3, 23, 5, 23, 638, 10, 23, 3, 23, 3, 23, 3, 23, 3, 23, 3, 23, 5, 23, 645, 10, 23, 3, 23, 5, 23, 648, 10, 23, 3, 24, 3, 24, 3, 24, 3, 24, 3, 25, 3, 25, 5, 25, 656, 10, 25, 3, 26, 3, 26, 5, 26, 660, 10, 26, 3, 26, 5, 26, 663, 10, 26, 3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 5, 27, 670, 10, 27, 3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 5, 27, 677, 10, 27, 7, 27, 679, 10, 27, 12, 27, 14, 27, 682, 11, 27, 3, 28, 3, 28, 5, 28, 686, 10, 28, 3, 28, 3, 28, 5, 28, 690, 10, 28, 3, 29, 5, 29, 693, 10, 29, 3, 29, 3, 29, 3, 29, 5, 29, 698, 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, 713, 10, 31, 3, 32, 3, 32, 3, 32, 7, 32, 718, 10, 32, 12, 32, 14, 32, 721, 11, 32, 3, 33, 3, 33, 3, 33, 7, 33, 726, 10, 33, 12, 33, 14, 33, 729, 11, 33, 3, 34, 3, 34, 3, 34, 7, 34, 734, 10, 34, 12, 34, 14, 34, 737, 11, 34, 3, 35, 3, 35, 3, 35, 3, 35, 7, 35, 743, 10, 35, 12, 35, 14, 35, 746, 11, 35, 3, 36, 3, 36, 3, 36, 3, 36, 5, 36, 752, 10, 36, 3, 37, 3, 37, 3, 37, 7, 37, 757, 10, 37, 12, 37, 14, 37, 760, 11, 37, 3, 38, 3, 38, 3, 38, 7, 38, 765, 10, 38, 12, 38, 14, 38, 768, 11, 38, 3, 39, 3, 39, 3, 39, 7, 39, 773, 10, 39, 12, 39, 14, 39, 776, 11, 39, 3, 40, 3, 40, 3, 40, 7, 40, 781, 10, 40, 12, 40, 14, 40, 784, 11, 40, 3, 41, 3, 41, 3, 41, 7, 41, 789, 10, 41, 12, 41, 14, 41, 792, 11, 41, 3, 42, 3, 42, 3, 42, 7, 42, 797, 10, 42, 12, 42, 14, 42, 800, 11, 42, 3, 43, 3, 43, 3, 43, 7, 43, 805, 10, 43, 12, 43, 14, 43, 808, 11, 43, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 5, 44, 816, 10, 44, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 5, 45, 824, 10, 45, 3, 46, 3, 46, 3, 47, 3, 47, 3, 47, 7, 47, 831, 10, 47, 12, 47, 14, 47, 834, 11, 47, 3, 48, 3, 48, 3, 49, 3, 49, 3, 49, 5, 49, 841, 10, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 5, 49, 849, 10, 49, 5, 49, 851, 10, 49, 3, 50, 5, 50, 854, 10, 50, 3, 50, 3, 50, 3, 50, 3, 50, 5, 50, 860, 10, 50, 3, 50, 3, 50, 3, 50, 3, 51, 5, 51, 866, 10, 51, 3, 51, 3, 51, 3, 52, 3, 52, 5, 52, 872, 10, 52, 3, 52, 3, 52, 3, 53, 6, 53, 877, 10, 53, 13, 53, 14, 53, 878, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 5, 54, 888, 10, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 5, 54, 896, 10, 54, 3, 55, 3, 55, 5, 55, 900, 10, 55, 3, 55, 3, 55, 3, 55, 3, 55, 3, 55, 5, 55, 907, 10, 55, 5, 55, 909, 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, 929, 10, 56, 3, 56, 3, 56, 5, 56, 933, 10, 56, 3, 56, 3, 56, 3, 56, 3, 56, 5, 56, 939, 10, 56, 3, 56, 3, 56, 3, 56, 5, 56, 944, 10, 56, 3, 57, 3, 57, 5, 57, 948, 10, 57, 3, 58, 5, 58, 951, 10, 58, 3, 58, 3, 58, 3, 58, 3, 59, 3, 59, 5, 59, 958, 10, 59, 3, 60, 3, 60, 3, 60, 3, 60, 3, 60, 5, 60, 965, 10, 60, 3, 60, 3, 60, 5, 60, 969, 10, 60, 3, 60, 3, 60, 3, 61, 3, 61, 3, 62, 6, 62, 976, 10, 62, 13, 62, 14, 62, 977, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 3, 63, 5, 63, 989, 10, 63, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 3, 64, 5, 64, 999, 10, 64, 3, 65, 3, 65, 3, 65, 5, 65, 1004, 10, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 66, 5, 66, 1011, 10, 66, 3, 66, 5, 66, 1014, 10, 66, 3, 66, 3, 66, 3, 66, 5, 66, 1019, 10, 66, 3, 66, 3, 66, 3, 66, 5, 66, 1024, 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, 1045, 10, 70, 3, 71, 6, 71, 1048, 10, 71, 13, 71, 14, 71, 1049, 3, 71, 5, 71, 1053, 10, 71, 3, 72, 3, 72, 3, 73, 3, 73, 3, 74, 3, 74, 3, 75, 3, 75, 3, 75, 5, 75, 1064, 10, 75, 3, 76, 3, 76, 3, 76, 3, 76, 5, 76, 1070, 10, 76, 3, 77, 6, 77, 1073, 10, 77, 13, 77, 14, 77, 1074, 3, 77, 5, 77, 1078, 10, 77, 3, 78, 6, 78, 1081, 10, 78, 13, 78, 14, 78, 1082, 3, 78, 5, 78, 1086, 10, 78, 3, 79, 3, 79, 3, 80, 3, 80, 3, 81, 5, 81, 1093, 10, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 3, 81, 5, 81, 1102, 10, 81, 3, 81, 6, 81, 1105, 10, 81, 13, 81, 14, 81, 1106, 3, 81, 5, 81, 1110, 10, 81, 3, 81, 3, 81, 5, 81, 1114, 10, 81, 3, 81, 3, 81, 5, 81, 1118, 10, 81, 3, 81, 3, 81, 5, 81, 1122, 10, 81, 3, 81, 3, 81, 3, 81, 5, 81, 1127, 10, 81, 3, 81, 7, 81, 1130, 10, 81, 12, 81, 14, 81, 1133, 11, 81, 3, 81, 3, 81, 3, 81, 5, 81, 1138, 10, 81, 3, 81, 3, 81, 3, 81, 3, 81, 5, 81, 1144, 10, 81, 3, 82, 3, 82, 3, 82, 3, 82, 5, 82, 1150, 10, 82, 3, 83, 3, 83, 3, 83, 3, 83, 5, 83, 1156, 10, 83, 3, 83, 3, 83, 3, 84, 3, 84, 5, 84, 1162, 10, 84, 3, 84, 5, 84, 1165, 10, 84, 3, 84, 3, 84, 3, 84, 3, 84, 5, 84, 1171, 10, 84, 3, 84, 3, 84, 5, 84, 1175, 10, 84, 3, 84, 3, 84, 5, 84, 1179, 10, 84, 3, 84, 5, 84, 1182, 10, 84, 3, 85, 3, 85, 3, 86, 3, 86, 3, 86, 3, 86, 5, 86, 1190, 10, 86, 5, 86, 1192, 10, 86, 3, 86, 3, 86, 3, 87, 3, 87, 5, 87, 1198, 10, 87, 3, 87, 5, 87, 1201, 10, 87, 3, 87, 5, 87, 1204, 10, 87, 3, 87, 5, 87, 1207, 10, 87, 3, 88, 3, 88, 5, 88, 1211, 10, 88, 3, 88, 3, 88, 5, 88, 1215, 10, 88, 3, 88, 3, 88, 3, 89, 3, 89, 5, 89, 1221, 10, 89, 3, 90, 3, 90, 3, 90, 3, 91, 3, 91, 3, 91, 7, 91, 1229, 10, 91, 12, 91, 14, 91, 1232, 11, 91, 3, 92, 3, 92, 3, 92, 5, 92, 1237, 10, 92, 3, 93, 3, 93, 3, 94, 3, 94, 5, 94, 1243, 10, 94, 3, 95, 3, 95, 3, 96, 5, 96, 1248, 10, 96, 3, 96, 3, 96, 3, 96, 5, 96, 1253, 10, 96, 3, 96, 3, 96, 5, 96, 1257, 10, 96, 3, 96, 3, 96, 3, 97, 3, 97, 3, 98, 3, 98, 3, 98, 3, 98, 3, 98, 3, 98, 3, 99, 5, 99, 1270, 10, 99, 3, 99, 3, 99, 3, 100, 3, 100, 5, 100, 1276, 10, 100, 3, 100, 3, 100, 5, 100, 1280, 10, 100, 3, 100, 3, 100, 3, 100, 3, 101, 5, 101, 1286, 10, 101, 3, 101, 3, 101, 3, 101, 5, 101, 1291, 10, 101, 3, 101, 3, 101, 3, 101, 3, 102, 3, 102, 3, 102, 3, 102, 3, 102, 3, 102, 3, 103, 3, 103, 3, 103, 3, 103, 5, 103, 1306, 10, 103, 3, 103, 3, 103, 5, 103, 1310, 10, 103, 3, 104, 6, 104, 1313, 10, 104, 13, 104, 14, 104, 1314, 3, 105, 3, 105, 3, 105, 5, 105, 1320, 10, 105, 3, 105, 3, 105, 3, 105, 5, 105, 1325, 10, 105, 3, 106, 3, 106, 3, 106, 3, 106, 5, 106, 1331, 10, 106, 3, 106, 5, 106, 1334, 10, 106, 3, 106, 3, 106, 3, 107, 3, 107, 3, 107, 7, 107, 1341, 10, 107, 12, 107, 14, 107, 1344, 11, 107, 3, 107, 5, 107, 1347, 10, 107, 3, 108, 3, 108, 3, 108, 5, 108, 1352, 10, 108, 3, 108, 3, 108, 5, 108, 1356, 10, 108, 3, 109, 3, 109, 3, 110, 3, 110, 5, 110, 1362, 10, 110, 3, 110, 3, 110, 3, 111, 6, 111, 1367, 10, 111, 13, 111, 14, 111, 1368, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 3, 112, 6, 112, 1384, 10, 112, 13, 112, 14, 112, 1385, 5, 112, 1388, 10, 112, 3, 113, 3, 113, 3, 113, 7, 113, 1393, 10, 113, 12, 113, 14, 113, 1396, 11, 113, 3, 114, 3, 114, 5, 114, 1400, 10, 114, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 5, 115, 1407, 10, 115, 3, 116, 3, 116, 5, 116, 1411, 10, 116, 7, 116, 1413, 10, 116, 12, 116, 14, 116, 1416, 11, 116, 3, 116, 3, 116, 3, 117, 3, 117, 3, 117, 5, 117, 1423, 10, 117, 3, 117, 3, 117, 3, 117, 3, 117, 5, 117, 1429, 10, 117, 3, 117, 3, 117, 3, 117, 3, 117, 5, 117, 1435, 10, 117, 3, 117, 3, 117, 5, 117, 1439, 10, 117, 5, 117, 1441, 10, 117, 7, 117, 1443, 10, 117, 12, 117, 14, 117, 1446, 11, 117, 3, 118, 3, 118, 5, 118, 1450, 10, 118, 3, 118, 3, 118, 5, 118, 1454, 10, 118, 3, 118, 5, 118, 1457, 10, 118, 3, 118, 5, 118, 1460, 10, 118, 3, 118, 5, 118, 1463, 10, 118, 3, 119, 3, 119, 3, 119, 5, 119, 1468, 10, 119, 3, 120, 3, 120, 5, 120, 1472, 10, 120, 3, 120, 5, 120, 1475, 10, 120, 3, 120, 3, 120, 5, 120, 1479, 10, 120, 3, 120, 5, 120, 1482, 10, 120, 5, 120, 1484, 10, 120, 3, 121, 6, 121, 1487, 10, 121, 13, 121, 14, 121, 1488, 3, 122, 3, 122, 3, 123, 3, 123, 3, 124, 5, 124, 1496, 10, 124, 3, 124, 3, 124, 3, 125, 3, 125, 5, 125, 1502, 10, 125, 3, 126, 3, 126, 5, 126, 1506, 10, 126, 3, 126, 3, 126, 3, 126, 3, 126, 5, 126, 1512, 10, 126, 3, 127, 3, 127, 6, 127, 1516, 10, 127, 13, 127, 14, 127, 1517, 3, 127, 5, 127, 1521, 10, 127, 5, 127, 1523, 10, 127, 3, 128, 3, 128, 3, 128, 3, 128, 5, 128, 1529, 10, 128, 3, 128, 3, 128, 5, 128, 1533, 10, 128, 3, 128, 3, 128, 3, 128, 3, 128, 5, 128, 1539, 10, 128, 3, 128, 3, 128, 3, 128, 3, 128, 3, 128, 5, 128, 1546, 10, 128, 3, 128, 3, 128, 5, 128, 1550, 10, 128, 5, 128, 1552, 10, 128, 7, 128, 1554, 10, 128, 12, 128, 14, 128, 1557, 11, 128, 3, 129, 7, 129, 1560, 10, 129, 12, 129, 14, 129, 1563, 11, 129, 3, 129, 3, 129, 3, 130, 3, 130, 3, 130, 3, 130, 3, 130, 3, 130, 3, 130, 5, 130, 1574, 10, 130, 3, 130, 3, 130, 5, 130, 1578, 10, 130, 5, 130, 1580, 10, 130, 7, 130, 1582, 10, 130, 12, 130, 14, 130, 1585, 11, 130, 3, 131, 3, 131, 5, 131, 1589, 10, 131, 3, 131, 5, 131, 1592, 10, 131, 3, 132, 3, 132, 3, 132, 7, 132, 1597, 10, 132, 12, 132, 14, 132, 1600, 11, 132, 3, 133, 5, 133, 1603, 10, 133, 3, 133, 3, 133, 3, 133, 5, 133, 1608, 10, 133, 5, 133, 1610, 10, 133, 3, 133, 3, 133, 5, 133, 1614, 10, 133, 3, 134, 5, 134, 1617, 10, 134, 3, 134, 5, 134, 1620, 10, 134, 3, 134, 3, 134, 5, 134, 1624, 10, 134, 3, 134, 3, 134, 3, 135, 5, 135, 1629, 10, 135, 3, 135, 3, 135, 3, 135, 3, 135, 3, 135, 5, 135, 1636, 10, 135, 3, 136, 3, 136, 3, 136, 3, 136, 3, 136, 5, 136, 1643, 10, 136, 3, 137, 3, 137, 3, 137, 5, 137, 1648, 10, 137, 3, 138, 3, 138, 5, 138, 1652, 10, 138, 3, 139, 3, 139, 5, 139, 1656, 10, 139, 3, 139, 3, 139, 3, 139, 5, 139, 1661, 10, 139, 7, 139, 1663, 10, 139, 12, 139, 14, 139, 1666, 11, 139, 3, 140, 3, 140, 3, 140, 5, 140, 1671, 10, 140, 5, 140, 1673, 10, 140, 3, 140, 3, 140, 3, 141, 3, 141, 5, 141, 1679, 10, 141, 3, 142, 3, 142, 3, 142, 5, 142, 1684, 10, 142, 3, 142, 3, 142, 3, 143, 3, 143, 5, 143, 1690, 10, 143, 3, 143, 3, 143, 5, 143, 1694, 10, 143, 5, 143, 1696, 10, 143, 3, 143, 5, 143, 1699, 10, 143, 3, 143, 3, 143, 5, 143, 1703, 10, 143, 3, 143, 3, 143, 5, 143, 1707, 10, 143, 5, 143, 1709, 10, 143, 5, 143, 1711, 10, 143, 3, 144, 5, 144, 1714, 10, 144, 3, 144, 3, 144, 3, 145, 3, 145, 3, 146, 3, 146, 3, 147, 3, 147, 3, 147, 3, 147, 6, 147, 1726, 10, 147, 13, 147, 14, 147, 1727, 3, 148, 5, 148, 1731, 10, 148, 3, 148, 5, 148, 1734, 10, 148, 3, 148, 5, 148, 1737, 10, 148, 3, 148, 3, 148, 3, 148, 3, 148, 3, 148, 3, 148, 3, 148, 5, 148, 1746, 10, 148, 3, 149, 3, 149, 3, 149, 7, 149, 1751, 10, 149, 12, 149, 14, 149, 1754, 11, 149, 3, 150, 3, 150, 5, 150, 1758, 10, 150, 3, 150, 5, 150, 1761, 10, 150, 3, 150, 5, 150, 1764, 10, 150, 5, 150, 1766, 10, 150, 3, 150, 5, 150, 1769, 10, 150, 3, 150, 5, 150, 1772, 10, 150, 3, 150, 3, 150, 5, 150, 1776, 10, 150, 3, 151, 6, 151, 1779, 10, 151, 13, 151, 14, 151, 1780, 3, 152, 3, 152, 3, 153, 3, 153, 3, 153, 3, 153, 3, 154, 3, 154, 3, 154, 3, 155, 3, 155, 5, 155, 1794, 10, 155, 3, 155, 3, 155, 3, 155, 5, 155, 1799, 10, 155, 7, 155, 1801, 10, 155, 12, 155, 14, 155, 1804, 11, 155, 3, 156, 5, 156, 1807, 10, 156, 3, 156, 3, 156, 3, 156, 5, 156, 1812, 10, 156, 3, 156, 3, 156, 3, 156, 5, 156, 1817, 10, 156, 3, 156, 3, 156, 5, 156, 1821, 10, 156, 3, 157, 5, 157, 1824, 10, 157, 3, 157, 3, 157, 5, 157, 1828, 10, 157, 3, 158, 3, 158, 3, 159, 3, 159, 3, 160, 3, 160, 3, 160, 3, 161, 3, 161, 5, 161, 1839, 10, 161, 3, 162, 3, 162, 5, 162, 1843, 10, 162, 3, 163, 3, 163, 3, 163, 3, 164, 3, 164, 5, 164, 1850, 10, 164, 3, 164, 3, 164, 3, 164, 5, 164, 1855, 10, 164, 7, 164, 1857, 10, 164, 12, 164, 14, 164, 1860, 11, 164, 3, 165, 3, 165, 3, 165, 5, 165, 1865, 10, 165, 3, 165, 3, 165, 5, 165, 1869, 10, 165, 3, 166, 3, 166, 5, 166, 1873, 10, 166, 3, 167, 3, 167, 3, 167, 3, 168, 3, 168, 3, 168, 3, 168, 5, 168, 1882, 10, 168, 3, 169, 3, 169, 3, 169, 3, 169, 3, 169, 3, 169, 3, 170, 3, 170, 3, 170, 7, 170, 1893, 10, 170, 12, 170, 14, 170, 1896, 11, 170, 3, 171, 3, 171, 5, 171, 1900, 10, 171, 3, 172, 3, 172, 3, 172, 3, 172, 3, 172, 5, 172, 1907, 10, 172, 3, 172, 3, 172, 5, 172, 1911, 10, 172, 3, 172, 5, 172, 1914, 10, 172, 3, 172, 5, 172, 1917, 10, 172, 3, 172, 5, 172, 1920, 10, 172, 3, 172, 3, 172, 5, 172, 1924, 10, 172, 3, 173, 3, 173, 3, 173, 5, 173, 1929, 10, 173, 3, 173, 3, 173, 3, 174, 3, 174, 3, 174, 5, 174, 1936, 10, 174, 3, 174, 3, 174, 5, 174, 1940, 10, 174, 3, 174, 3, 174, 5, 174, 1944, 10, 174, 3, 175, 3, 175, 3, 176, 3, 176, 5, 176, 1950, 10, 176, 3, 176, 3, 176, 3, 176, 5, 176, 1955, 10, 176, 7, 176, 1957, 10, 176, 12, 176, 14, 176, 1960, 11, 176, 3, 177, 3, 177, 3, 177, 5, 177, 1965, 10, 177, 3, 178, 3, 178, 3, 178, 3, 178, 5, 178, 1971, 10, 178, 3, 178, 5, 178, 1974, 10, 178, 3, 179, 5, 179, 1977, 10, 179, 3, 179, 3, 179, 3, 179, 3, 180, 3, 180, 3, 180, 3, 180, 3, 180, 3, 181, 3, 181, 3, 181, 3, 181, 3, 182, 3, 182, 5, 182, 1993, 10, 182, 3, 182, 3, 182, 3, 182, 3, 183, 6, 183, 1999, 10, 183, 13, 183, 14, 183, 2000, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 185, 5, 185, 2010, 10, 185, 3, 185, 3, 185, 3, 185, 5, 185, 2015, 10, 185, 3, 185, 5, 185, 2018, 10, 185, 3, 186, 3, 186, 5, 186, 2022, 10, 186, 3, 187, 3, 187, 5, 187, 2026, 10, 187, 3, 188, 3, 188, 3, 188, 5, 188, 2031, 10, 188, 3, 188, 3, 188, 3, 189, 3, 189, 5, 189, 2037, 10, 189, 3, 189, 3, 189, 3, 189, 5, 189, 2042, 10, 189, 7, 189, 2044, 10, 189, 12, 189, 14, 189, 2047, 11, 189, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 5, 190, 2055, 10, 190, 3, 191, 3, 191, 3, 191, 5, 191, 2060, 10, 191, 3, 191, 3, 191, 3, 191, 5, 191, 2065, 10, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 3, 191, 5, 191, 2108, 10, 191, 3, 192, 3, 192, 3, 192, 3, 1049, 8, 12, 32, 52, 232, 254, 258, 193, 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, 380, 382, 2, 25, 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, 48, 48, 62, 62, 4, 2, 63, 63, 80, 80, 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, 2345, 2, 385, 3, 2, 2, 2, 4, 401, 3, 2, 2, 2, 6, 405, 3, 2, 2, 2, 8, 417, 3, 2, 2, 2, 10, 419, 3, 2, 2, 2, 12, 425, 3, 2, 2, 2, 14, 447, 3, 2, 2, 2, 16, 453, 3, 2, 2, 2, 18, 465, 3, 2, 2, 2, 20, 467, 3, 2, 2, 2, 22, 469, 3, 2, 2, 2, 24, 482, 3, 2, 2, 2, 26, 489, 3, 2, 2, 2, 28, 492, 3, 2, 2, 2, 30, 497, 3, 2, 2, 2, 32, 544, 3, 2, 2, 2, 34, 576, 3, 2, 2, 2, 36, 578, 3, 2, 2, 2, 38, 599, 3, 2, 2, 2, 40, 628, 3, 2, 2, 2, 42, 630, 3, 2, 2, 2, 44, 633, 3, 2, 2, 2, 46, 649, 3, 2, 2, 2, 48, 653, 3, 2, 2, 2, 50, 662, 3, 2, 2, 2, 52, 664, 3, 2, 2, 2, 54, 689, 3, 2, 2, 2, 56, 692, 3, 2, 2, 2, 58, 701, 3, 2, 2, 2, 60, 712, 3, 2, 2, 2, 62, 714, 3, 2, 2, 2, 64, 722, 3, 2, 2, 2, 66, 730, 3, 2, 2, 2, 68, 738, 3, 2, 2, 2, 70, 751, 3, 2, 2, 2, 72, 753, 3, 2, 2, 2, 74, 761, 3, 2, 2, 2, 76, 769, 3, 2, 2, 2, 78, 777, 3, 2, 2, 2, 80, 785, 3, 2, 2, 2, 82, 793, 3, 2, 2, 2, 84, 801, 3, 2, 2, 2, 86, 809, 3, 2, 2, 2, 88, 823, 3, 2, 2, 2, 90, 825, 3, 2, 2, 2, 92, 827, 3, 2, 2, 2, 94, 835, 3, 2, 2, 2, 96, 850, 3, 2, 2, 2, 98, 853, 3, 2, 2, 2, 100, 865, 3, 2, 2, 2, 102, 869, 3, 2, 2, 2, 104, 876, 3, 2, 2, 2, 106, 895, 3, 2, 2, 2, 108, 908, 3, 2, 2, 2, 110, 943, 3, 2, 2, 2, 112, 947, 3, 2, 2, 2, 114, 950, 3, 2, 2, 2, 116, 957, 3, 2, 2, 2, 118, 968, 3, 2, 2, 2, 120, 972, 3, 2, 2, 2, 122, 975, 3, 2, 2, 2, 124, 988, 3, 2, 2, 2, 126, 998, 3, 2, 2, 2, 128, 1000, 3, 2, 2, 2, 130, 1023, 3, 2, 2, 2, 132, 1025, 3, 2, 2, 2, 134, 1033, 3, 2, 2, 2, 136, 1035, 3, 2, 2, 2, 138, 1044, 3, 2, 2, 2, 140, 1047, 3, 2, 2, 2, 142, 1054, 3, 2, 2, 2, 144, 1056, 3, 2, 2, 2, 146, 1058, 3, 2, 2, 2, 148, 1063, 3, 2, 2, 2, 150, 1069, 3, 2, 2, 2, 152, 1072, 3, 2, 2, 2, 154, 1080, 3, 2, 2, 2, 156, 1087, 3, 2, 2, 2, 158, 1089, 3, 2, 2, 2, 160, 1143, 3, 2, 2, 2, 162, 1149, 3, 2, 2, 2, 164, 1151, 3, 2, 2, 2, 166, 1181, 3, 2, 2, 2, 168, 1183, 3, 2, 2, 2, 170, 1185, 3, 2, 2, 2, 172, 1195, 3, 2, 2, 2, 174, 1208, 3, 2, 2, 2, 176, 1218, 3, 2, 2, 2, 178, 1222, 3, 2, 2, 2, 180, 1225, 3, 2, 2, 2, 182, 1233, 3, 2, 2, 2, 184, 1238, 3, 2, 2, 2, 186, 1242, 3, 2, 2, 2, 188, 1244, 3, 2, 2, 2, 190, 1247, 3, 2, 2, 2, 192, 1260, 3, 2, 2, 2, 194, 1262, 3, 2, 2, 2, 196, 1269, 3, 2, 2, 2, 198, 1273, 3, 2, 2, 2, 200, 1285, 3, 2, 2, 2, 202, 1295, 3, 2, 2, 2, 204, 1301, 3, 2, 2, 2, 206, 1312, 3, 2, 2, 2, 208, 1324, 3, 2, 2, 2, 210, 1326, 3, 2, 2, 2, 212, 1337, 3, 2, 2, 2, 214, 1351, 3, 2, 2, 2, 216, 1357, 3, 2, 2, 2, 218, 1359, 3, 2, 2, 2, 220, 1366, 3, 2, 2, 2, 222, 1387, 3, 2, 2, 2, 224, 1389, 3, 2, 2, 2, 226, 1397, 3, 2, 2, 2, 228, 1406, 3, 2, 2, 2, 230, 1414, 3, 2, 2, 2, 232, 1428, 3, 2, 2, 2, 234, 1447, 3, 2, 2, 2, 236, 1464, 3, 2, 2, 2, 238, 1483, 3, 2, 2, 2, 240, 1486, 3, 2, 2, 2, 242, 1490, 3, 2, 2, 2, 244, 1492, 3, 2, 2, 2, 246, 1495, 3, 2, 2, 2, 248, 1499, 3, 2, 2, 2, 250, 1511, 3, 2, 2, 2, 252, 1522, 3, 2, 2, 2, 254, 1538, 3, 2, 2, 2, 256, 1561, 3, 2, 2, 2, 258, 1566, 3, 2, 2, 2, 260, 1586, 3, 2, 2, 2, 262, 1593, 3, 2, 2, 2, 264, 1602, 3, 2, 2, 2, 266, 1616, 3, 2, 2, 2, 268, 1635, 3, 2, 2, 2, 270, 1642, 3, 2, 2, 2, 272, 1647, 3, 2, 2, 2, 274, 1651, 3, 2, 2, 2, 276, 1653, 3, 2, 2, 2, 278, 1667, 3, 2, 2, 2, 280, 1678, 3, 2, 2, 2, 282, 1680, 3, 2, 2, 2, 284, 1710, 3, 2, 2, 2, 286, 1713, 3, 2, 2, 2, 288, 1717, 3, 2, 2, 2, 290, 1719, 3, 2, 2, 2, 292, 1725, 3, 2, 2, 2, 294, 1745, 3, 2, 2, 2, 296, 1747, 3, 2, 2, 2, 298, 1775, 3, 2, 2, 2, 300, 1778, 3, 2, 2, 2, 302, 1782, 3, 2, 2, 2, 304, 1784, 3, 2, 2, 2, 306, 1788, 3, 2, 2, 2, 308, 1791, 3, 2, 2, 2, 310, 1806, 3, 2, 2, 2, 312, 1827, 3, 2, 2, 2, 314, 1829, 3, 2, 2, 2, 316, 1831, 3, 2, 2, 2, 318, 1833, 3, 2, 2, 2, 320, 1836, 3, 2, 2, 2, 322, 1840, 3, 2, 2, 2, 324, 1844, 3, 2, 2, 2, 326, 1847, 3, 2, 2, 2, 328, 1861, 3, 2, 2, 2, 330, 1872, 3, 2, 2, 2, 332, 1874, 3, 2, 2, 2, 334, 1877, 3, 2, 2, 2, 336, 1883, 3, 2, 2, 2, 338, 1889, 3, 2, 2, 2, 340, 1899, 3, 2, 2, 2, 342, 1910, 3, 2, 2, 2, 344, 1925, 3, 2, 2, 2, 346, 1943, 3, 2, 2, 2, 348, 1945, 3, 2, 2, 2, 350, 1947, 3, 2, 2, 2, 352, 1964, 3, 2, 2, 2, 354, 1966, 3, 2, 2, 2, 356, 1976, 3, 2, 2, 2, 358, 1981, 3, 2, 2, 2, 360, 1986, 3, 2, 2, 2, 362, 1990, 3, 2, 2, 2, 364, 1998, 3, 2, 2, 2, 366, 2002, 3, 2, 2, 2, 368, 2017, 3, 2, 2, 2, 370, 2019, 3, 2, 2, 2, 372, 2025, 3, 2, 2, 2, 374, 2027, 3, 2, 2, 2, 376, 2034, 3, 2, 2, 2, 378, 2054, 3, 2, 2, 2, 380, 2107, 3, 2, 2, 2, 382, 2109, 3, 2, 2, 2, 384, 386, 5, 122, 62, 2, 385, 384, 3, 2, 2, 2, 385, 386, 3, 2, 2, 2, 386, 387, 3, 2, 2, 2, 387, 388, 7, 2, 2, 3, 388, 3, 3, 2, 2, 2, 389, 391, 5, 382, 192, 2, 390, 389, 3, 2, 2, 2, 391, 392, 3, 2, 2, 2, 392, 390, 3, 2, 2, 2, 392, 393, 3, 2, 2, 2, 393, 402, 3, 2, 2, 2, 394, 402, 7, 71, 2, 2, 395, 396, 7, 87, 2, 2, 396, 397, 5, 92, 47, 2, 397, 398, 7, 88, 2, 2, 398, 402, 3, 2, 2, 2, 399, 402, 5, 6, 4, 2, 400, 402, 5, 14, 8, 2, 401, 390, 3, 2, 2, 2, 401, 394, 3, 2, 2, 2, 401, 395, 3, 2, 2, 2, 401, 399, 3, 2, 2, 2, 401, 400, 3, 2, 2, 2, 402, 5, 3, 2, 2, 2, 403, 406, 5, 8, 5, 2, 404, 406, 5, 10, 6, 2, 405, 403, 3, 2, 2, 2, 405, 404, 3, 2, 2, 2, 406, 7, 3, 2, 2, 2, 407, 418, 7, 134, 2, 2, 408, 418, 5, 332, 167, 2, 409, 418, 5, 318, 160, 2, 410, 418, 5, 334, 168, 2, 411, 414, 7, 101, 2, 2, 412, 415, 5, 280, 141, 2, 413, 415, 5, 164, 83, 2, 414, 412, 3, 2, 2, 2, 414, 413, 3, 2, 2, 2, 415, 418, 3, 2, 2, 2, 416, 418, 5, 346, 174, 2, 417, 407, 3, 2, 2, 2, 417, 408, 3, 2, 2, 2, 417, 409, 3, 2, 2, 2, 417, 410, 3, 2, 2, 2, 417, 411, 3, 2, 2, 2, 417, 416, 3, 2, 2, 2, 418, 9, 3, 2, 2, 2, 419, 421, 5, 12, 7, 2, 420, 422, 7, 70, 2, 2, 421, 420, 3, 2, 2, 2, 421, 422, 3, 2, 2, 2, 422, 423, 3, 2, 2, 2, 423, 424, 5, 8, 5, 2, 424, 11, 3, 2, 2, 2, 425, 429, 8, 7, 1, 2, 426, 430, 5, 162, 82, 2, 427, 430, 5, 186, 94, 2, 428, 430, 5, 164, 83, 2, 429, 426, 3, 2, 2, 2, 429, 427, 3, 2, 2, 2, 429, 428, 3, 2, 2, 2, 429, 430, 3, 2, 2, 2, 430, 431, 3, 2, 2, 2, 431, 432, 7, 129, 2, 2, 432, 444, 3, 2, 2, 2, 433, 439, 12, 3, 2, 2, 434, 440, 7, 134, 2, 2, 435, 437, 7, 70, 2, 2, 436, 435, 3, 2, 2, 2, 436, 437, 3, 2, 2, 2, 437, 438, 3, 2, 2, 2, 438, 440, 5, 344, 173, 2, 439, 434, 3, 2, 2, 2, 439, 436, 3, 2, 2, 2, 440, 441, 3, 2, 2, 2, 441, 443, 7, 129, 2, 2, 442, 433, 3, 2, 2, 2, 443, 446, 3, 2, 2, 2, 444, 442, 3, 2, 2, 2, 444, 445, 3, 2, 2, 2, 445, 13, 3, 2, 2, 2, 446, 444, 3, 2, 2, 2, 447, 449, 5, 16, 9, 2, 448, 450, 5, 30, 16, 2, 449, 448, 3, 2, 2, 2, 449, 450, 3, 2, 2, 2, 450, 451, 3, 2, 2, 2, 451, 452, 5, 102, 52, 2, 452, 15, 3, 2, 2, 2, 453, 455, 7, 89, 2, 2, 454, 456, 5, 18, 10, 2, 455, 454, 3, 2, 2, 2, 455, 456, 3, 2, 2, 2, 456, 457, 3, 2, 2, 2, 457, 458, 7, 90, 2, 2, 458, 17, 3, 2, 2, 2, 459, 466, 5, 22, 12, 2, 460, 463, 5, 20, 11, 2, 461, 462, 7, 124, 2, 2, 462, 464, 5, 22, 12, 2, 463, 461, 3, 2, 2, 2, 463, 464, 3, 2, 2, 2, 464, 466, 3, 2, 2, 2, 465, 459, 3, 2, 2, 2, 465, 460, 3, 2, 2, 2, 466, 19, 3, 2, 2, 2, 467, 468, 9, 2, 2, 2, 468, 21, 3, 2, 2, 2, 469, 474, 5, 24, 13, 2, 470, 471, 7, 124, 2, 2, 471, 473, 5, 24, 13, 2, 472, 470, 3, 2, 2, 2, 473, 476, 3, 2, 2, 2, 474, 472, 3, 2, 2, 2, 474, 475, 3, 2, 2, 2, 475, 478, 3, 2, 2, 2, 476, 474, 3, 2, 2, 2, 477, 479, 7, 133, 2, 2, 478, 477, 3, 2, 2, 2, 478, 479, 3, 2, 2, 2, 479, 23, 3, 2, 2, 2, 480, 483, 5, 26, 14, 2, 481, 483, 5, 28, 15, 2, 482, 480, 3, 2, 2, 2, 482, 481, 3, 2, 2, 2, 483, 25, 3, 2, 2, 2, 484, 486, 7, 99, 2, 2, 485, 484, 3, 2, 2, 2, 485, 486, 3, 2, 2, 2, 486, 487, 3, 2, 2, 2, 487, 490, 7, 134, 2, 2, 488, 490, 7, 71, 2, 2, 489, 485, 3, 2, 2, 2, 489, 488, 3, 2, 2, 2, 490, 27, 3, 2, 2, 2, 491, 493, 7, 99, 2, 2, 492, 491, 3, 2, 2, 2, 492, 493, 3, 2, 2, 2, 493, 494, 3, 2, 2, 2, 494, 495, 7, 134, 2, 2, 495, 496, 5, 270, 136, 2, 496, 29, 3, 2, 2, 2, 497, 499, 7, 87, 2, 2, 498, 500, 5, 260, 131, 2, 499, 498, 3, 2, 2, 2, 499, 500, 3, 2, 2, 2, 500, 501, 3, 2, 2, 2, 501, 503, 7, 88, 2, 2, 502, 504, 7, 49, 2, 2, 503, 502, 3, 2, 2, 2, 503, 504, 3, 2, 2, 2, 504, 506, 3, 2, 2, 2, 505, 507, 5, 372, 187, 2, 506, 505, 3, 2, 2, 2, 506, 507, 3, 2, 2, 2, 507, 509, 3, 2, 2, 2, 508, 510, 5, 206, 104, 2, 509, 508, 3, 2, 2, 2, 509, 510, 3, 2, 2, 2, 510, 512, 3, 2, 2, 2, 511, 513, 5, 236, 119, 2, 512, 511, 3, 2, 2, 2, 512, 513, 3, 2, 2, 2, 513, 31, 3, 2, 2, 2, 514, 515, 8, 17, 1, 2, 515, 545, 5, 4, 3, 2, 516, 519, 5, 160, 81, 2, 517, 519, 5, 354, 178, 2, 518, 516, 3, 2, 2, 2, 518, 517, 3, 2, 2, 2, 519, 526, 3, 2, 2, 2, 520, 522, 7, 87, 2, 2, 521, 523, 5, 36, 19, 2, 522, 521, 3, 2, 2, 2, 522, 523, 3, 2, 2, 2, 523, 524, 3, 2, 2, 2, 524, 527, 7, 88, 2, 2, 525, 527, 5, 278, 140, 2, 526, 520, 3, 2, 2, 2, 526, 525, 3, 2, 2, 2, 527, 545, 3, 2, 2, 2, 528, 529, 9, 3, 2, 2, 529, 530, 7, 104, 2, 2, 530, 531, 5, 248, 125, 2, 531, 532, 7, 105, 2, 2, 532, 533, 7, 87, 2, 2, 533, 534, 5, 92, 47, 2, 534, 535, 7, 88, 2, 2, 535, 545, 3, 2, 2, 2, 536, 537, 5, 34, 18, 2, 537, 540, 7, 87, 2, 2, 538, 541, 5, 92, 47, 2, 539, 541, 5, 248, 125, 2, 540, 538, 3, 2, 2, 2, 540, 539, 3, 2, 2, 2, 541, 542, 3, 2, 2, 2, 542, 543, 7, 88, 2, 2, 543, 545, 3, 2, 2, 2, 544, 514, 3, 2, 2, 2, 544, 518, 3, 2, 2, 2, 544, 528, 3, 2, 2, 2, 544, 536, 3, 2, 2, 2, 545, 573, 3, 2, 2, 2, 546, 547, 12, 9, 2, 2, 547, 550, 7, 89, 2, 2, 548, 551, 5, 92, 47, 2, 549, 551, 5, 278, 140, 2, 550, 548, 3, 2, 2, 2, 550, 549, 3, 2, 2, 2, 551, 552, 3, 2, 2, 2, 552, 553, 7, 90, 2, 2, 553, 572, 3, 2, 2, 2, 554, 555, 12, 8, 2, 2, 555, 557, 7, 87, 2, 2, 556, 558, 5, 36, 19, 2, 557, 556, 3, 2, 2, 2, 557, 558, 3, 2, 2, 2, 558, 559, 3, 2, 2, 2, 559, 572, 7, 88, 2, 2, 560, 561, 12, 6, 2, 2, 561, 567, 9, 4, 2, 2, 562, 564, 7, 70, 2, 2, 563, 562, 3, 2, 2, 2, 563, 564, 3, 2, 2, 2, 564, 565, 3, 2, 2, 2, 565, 568, 5, 6, 4, 2, 566, 568, 5, 38, 20, 2, 567, 563, 3, 2, 2, 2, 567, 566, 3, 2, 2, 2, 568, 572, 3, 2, 2, 2, 569, 570, 12, 5, 2, 2, 570, 572, 9, 5, 2, 2, 571, 546, 3, 2, 2, 2, 571, 554, 3, 2, 2, 2, 571, 560, 3, 2, 2, 2, 571, 569, 3, 2, 2, 2, 572, 575, 3, 2, 2, 2, 573, 571, 3, 2, 2, 2, 573, 574, 3, 2, 2, 2, 574, 33, 3, 2, 2, 2, 575, 573, 3, 2, 2, 2, 576, 577, 7, 77, 2, 2, 577, 35, 3, 2, 2, 2, 578, 579, 5, 276, 139, 2, 579, 37, 3, 2, 2, 2, 580, 582, 5, 12, 7, 2, 581, 580, 3, 2, 2, 2, 581, 582, 3, 2, 2, 2, 582, 586, 3, 2, 2, 2, 583, 584, 5, 162, 82, 2, 584, 585, 7, 129, 2, 2, 585, 587, 3, 2, 2, 2, 586, 583, 3, 2, 2, 2, 586, 587, 3, 2, 2, 2, 587, 588, 3, 2, 2, 2, 588, 589, 7, 101, 2, 2, 589, 600, 5, 162, 82, 2, 590, 591, 5, 12, 7, 2, 591, 592, 7, 70, 2, 2, 592, 593, 5, 344, 173, 2, 593, 594, 7, 129, 2, 2, 594, 595, 7, 101, 2, 2, 595, 596, 5, 162, 82, 2, 596, 600, 3, 2, 2, 2, 597, 598, 7, 101, 2, 2, 598, 600, 5, 164, 83, 2, 599, 581, 3, 2, 2, 2, 599, 590, 3, 2, 2, 2, 599, 597, 3, 2, 2, 2, 600, 39, 3, 2, 2, 2, 601, 629, 5, 32, 17, 2, 602, 607, 7, 122, 2, 2, 603, 607, 7, 123, 2, 2, 604, 607, 5, 42, 22, 2, 605, 607, 7, 64, 2, 2, 606, 602, 3, 2, 2, 2, 606, 603, 3, 2, 2, 2, 606, 604, 3, 2, 2, 2, 606, 605, 3, 2, 2, 2, 607, 608, 3, 2, 2, 2, 608, 629, 5, 40, 21, 2, 609, 618, 7, 64, 2, 2, 610, 611, 7, 87, 2, 2, 611, 612, 5, 248, 125, 2, 612, 613, 7, 88, 2, 2, 613, 619, 3, 2, 2, 2, 614, 615, 7, 133, 2, 2, 615, 616, 7, 87, 2, 2, 616, 617, 7, 134, 2, 2, 617, 619, 7, 88, 2, 2, 618, 610, 3, 2, 2, 2, 618, 614, 3, 2, 2, 2, 619, 629, 3, 2, 2, 2, 620, 621, 7, 13, 2, 2, 621, 622, 7, 87, 2, 2, 622, 623, 5, 248, 125, 2, 623, 624, 7, 88, 2, 2, 624, 629, 3, 2, 2, 2, 625, 629, 5, 58, 30, 2, 626, 629, 5, 44, 23, 2, 627, 629, 5, 56, 29, 2, 628, 601, 3, 2, 2, 2, 628, 606, 3, 2, 2, 2, 628, 609, 3, 2, 2, 2, 628, 620, 3, 2, 2, 2, 628, 625, 3, 2, 2, 2, 628, 626, 3, 2, 2, 2, 628, 627, 3, 2, 2, 2, 629, 41, 3, 2, 2, 2, 630, 631, 9, 6, 2, 2, 631, 43, 3, 2, 2, 2, 632, 634, 7, 129, 2, 2, 633, 632, 3, 2, 2, 2, 633, 634, 3, 2, 2, 2, 634, 635, 3, 2, 2, 2, 635, 637, 7, 51, 2, 2, 636, 638, 5, 46, 24, 2, 637, 636, 3, 2, 2, 2, 637, 638, 3, 2, 2, 2, 638, 644, 3, 2, 2, 2, 639, 645, 5, 48, 25, 2, 640, 641, 7, 87, 2, 2, 641, 642, 5, 248, 125, 2, 642, 643, 7, 88, 2, 2, 643, 645, 3, 2, 2, 2, 644, 639, 3, 2, 2, 2, 644, 640, 3, 2, 2, 2, 645, 647, 3, 2, 2, 2, 646, 648, 5, 54, 28, 2, 647, 646, 3, 2, 2, 2, 647, 648, 3, 2, 2, 2, 648, 45, 3, 2, 2, 2, 649, 650, 7, 87, 2, 2, 650, 651, 5, 36, 19, 2, 651, 652, 7, 88, 2, 2, 652, 47, 3, 2, 2, 2, 653, 655, 5, 152, 77, 2, 654, 656, 5, 50, 26, 2, 655, 654, 3, 2, 2, 2, 655, 656, 3, 2, 2, 2, 656, 49, 3, 2, 2, 2, 657, 659, 5, 238, 120, 2, 658, 660, 5, 50, 26, 2, 659, 658, 3, 2, 2, 2, 659, 660, 3, 2, 2, 2, 660, 663, 3, 2, 2, 2, 661, 663, 5, 52, 27, 2, 662, 657, 3, 2, 2, 2, 662, 661, 3, 2, 2, 2, 663, 51, 3, 2, 2, 2, 664, 665, 8, 27, 1, 2, 665, 666, 7, 89, 2, 2, 666, 667, 5, 92, 47, 2, 667, 669, 7, 90, 2, 2, 668, 670, 5, 206, 104, 2, 669, 668, 3, 2, 2, 2, 669, 670, 3, 2, 2, 2, 670, 680, 3, 2, 2, 2, 671, 672, 12, 3, 2, 2, 672, 673, 7, 89, 2, 2, 673, 674, 5, 94, 48, 2, 674, 676, 7, 90, 2, 2, 675, 677, 5, 206, 104, 2, 676, 675, 3, 2, 2, 2, 676, 677, 3, 2, 2, 2, 677, 679, 3, 2, 2, 2, 678, 671, 3, 2, 2, 2, 679, 682, 3, 2, 2, 2, 680, 678, 3, 2, 2, 2, 680, 681, 3, 2, 2, 2, 681, 53, 3, 2, 2, 2, 682, 680, 3, 2, 2, 2, 683, 685, 7, 87, 2, 2, 684, 686, 5, 36, 19, 2, 685, 684, 3, 2, 2, 2, 685, 686, 3, 2, 2, 2, 686, 687, 3, 2, 2, 2, 687, 690, 7, 88, 2, 2, 688, 690, 5, 278, 140, 2, 689, 683, 3, 2, 2, 2, 689, 688, 3, 2, 2, 2, 690, 55, 3, 2, 2, 2, 691, 693, 7, 129, 2, 2, 692, 691, 3, 2, 2, 2, 692, 693, 3, 2, 2, 2, 693, 694, 3, 2, 2, 2, 694, 697, 7, 30, 2, 2, 695, 696, 7, 89, 2, 2, 696, 698, 7, 90, 2, 2, 697, 695, 3, 2, 2, 2, 697, 698, 3, 2, 2, 2, 698, 699, 3, 2, 2, 2, 699, 700, 5, 60, 31, 2, 700, 57, 3, 2, 2, 2, 701, 702, 7, 52, 2, 2, 702, 703, 7, 87, 2, 2, 703, 704, 5, 92, 47, 2, 704, 705, 7, 88, 2, 2, 705, 59, 3, 2, 2, 2, 706, 713, 5, 40, 21, 2, 707, 708, 7, 87, 2, 2, 708, 709, 5, 248, 125, 2, 709, 710, 7, 88, 2, 2, 710, 711, 5, 60, 31, 2, 711, 713, 3, 2, 2, 2, 712, 706, 3, 2, 2, 2, 712, 707, 3, 2, 2, 2, 713, 61, 3, 2, 2, 2, 714, 719, 5, 60, 31, 2, 715, 716, 9, 7, 2, 2, 716, 718, 5, 60, 31, 2, 717, 715, 3, 2, 2, 2, 718, 721, 3, 2, 2, 2, 719, 717, 3, 2, 2, 2, 719, 720, 3, 2, 2, 2, 720, 63, 3, 2, 2, 2, 721, 719, 3, 2, 2, 2, 722, 727, 5, 62, 32, 2, 723, 724, 9, 8, 2, 2, 724, 726, 5, 62, 32, 2, 725, 723, 3, 2, 2, 2, 726, 729, 3, 2, 2, 2, 727, 725, 3, 2, 2, 2, 727, 728, 3, 2, 2, 2, 728, 65, 3, 2, 2, 2, 729, 727, 3, 2, 2, 2, 730, 735, 5, 64, 33, 2, 731, 732, 9, 9, 2, 2, 732, 734, 5, 64, 33, 2, 733, 731, 3, 2, 2, 2, 734, 737, 3, 2, 2, 2, 735, 733, 3, 2, 2, 2, 735, 736, 3, 2, 2, 2, 736, 67, 3, 2, 2, 2, 737, 735, 3, 2, 2, 2, 738, 744, 5, 66, 34, 2, 739, 740, 5, 70, 36, 2, 740, 741, 5, 66, 34, 2, 741, 743, 3, 2, 2, 2, 742, 739, 3, 2, 2, 2, 743, 746, 3, 2, 2, 2, 744, 742, 3, 2, 2, 2, 744, 745, 3, 2, 2, 2, 745, 69, 3, 2, 2, 2, 746, 744, 3, 2, 2, 2, 747, 748, 7, 105, 2, 2, 748, 752, 7, 105, 2, 2, 749, 750, 7, 104, 2, 2, 750, 752, 7, 104, 2, 2, 751, 747, 3, 2, 2, 2, 751, 749, 3, 2, 2, 2, 752, 71, 3, 2, 2, 2, 753, 758, 5, 68, 35, 2, 754, 755, 9, 10, 2, 2, 755, 757, 5, 68, 35, 2, 756, 754, 3, 2, 2, 2, 757, 760, 3, 2, 2, 2, 758, 756, 3, 2, 2, 2, 758, 759, 3, 2, 2, 2, 759, 73, 3, 2, 2, 2, 760, 758, 3, 2, 2, 2, 761, 766, 5, 72, 37, 2, 762, 763, 9, 11, 2, 2, 763, 765, 5, 72, 37, 2, 764, 762, 3, 2, 2, 2, 765, 768, 3, 2, 2, 2, 766, 764, 3, 2, 2, 2, 766, 767, 3, 2, 2, 2, 767, 75, 3, 2, 2, 2, 768, 766, 3, 2, 2, 2, 769, 774, 5, 74, 38, 2, 770, 771, 7, 99, 2, 2, 771, 773, 5, 74, 38, 2, 772, 770, 3, 2, 2, 2, 773, 776, 3, 2, 2, 2, 774, 772, 3, 2, 2, 2, 774, 775, 3, 2, 2, 2, 775, 77, 3, 2, 2, 2, 776, 774, 3, 2, 2, 2, 777, 782, 5, 76, 39, 2, 778, 779, 7, 98, 2, 2, 779, 781, 5, 76, 39, 2, 780, 778, 3, 2, 2, 2, 781, 784, 3, 2, 2, 2, 782, 780, 3, 2, 2, 2, 782, 783, 3, 2, 2, 2, 783, 79, 3, 2, 2, 2, 784, 782, 3, 2, 2, 2, 785, 790, 5, 78, 40, 2, 786, 787, 7, 100, 2, 2, 787, 789, 5, 78, 40, 2, 788, 786, 3, 2, 2, 2, 789, 792, 3, 2, 2, 2, 790, 788, 3, 2, 2, 2, 790, 791, 3, 2, 2, 2, 791, 81, 3, 2, 2, 2, 792, 790, 3, 2, 2, 2, 793, 798, 5, 80, 41, 2, 794, 795, 7, 120, 2, 2, 795, 797, 5, 80, 41, 2, 796, 794, 3, 2, 2, 2, 797, 800, 3, 2, 2, 2, 798, 796, 3, 2, 2, 2, 798, 799, 3, 2, 2, 2, 799, 83, 3, 2, 2, 2, 800, 798, 3, 2, 2, 2, 801, 806, 5, 82, 42, 2, 802, 803, 7, 121, 2, 2, 803, 805, 5, 82, 42, 2, 804, 802, 3, 2, 2, 2, 805, 808, 3, 2, 2, 2, 806, 804, 3, 2, 2, 2, 806, 807, 3, 2, 2, 2, 807, 85, 3, 2, 2, 2, 808, 806, 3, 2, 2, 2, 809, 815, 5, 84, 43, 2, 810, 811, 7, 127, 2, 2, 811, 812, 5, 92, 47, 2, 812, 813, 7, 128, 2, 2, 813, 814, 5, 88, 45, 2, 814, 816, 3, 2, 2, 2, 815, 810, 3, 2, 2, 2, 815, 816, 3, 2, 2, 2, 816, 87, 3, 2, 2, 2, 817, 824, 5, 86, 44, 2, 818, 819, 5, 84, 43, 2, 819, 820, 5, 90, 46, 2, 820, 821, 5, 274, 138, 2, 821, 824, 3, 2, 2, 2, 822, 824, 5, 370, 186, 2, 823, 817, 3, 2, 2, 2, 823, 818, 3, 2, 2, 2, 823, 822, 3, 2, 2, 2, 824, 89, 3, 2, 2, 2, 825, 826, 9, 12, 2, 2, 826, 91, 3, 2, 2, 2, 827, 832, 5, 88, 45, 2, 828, 829, 7, 124, 2, 2, 829, 831, 5, 88, 45, 2, 830, 828, 3, 2, 2, 2, 831, 834, 3, 2, 2, 2, 832, 830, 3, 2, 2, 2, 832, 833, 3, 2, 2, 2, 833, 93, 3, 2, 2, 2, 834, 832, 3, 2, 2, 2, 835, 836, 5, 86, 44, 2, 836, 95, 3, 2, 2, 2, 837, 851, 5, 98, 50, 2, 838, 851, 5, 120, 61, 2, 839, 841, 5, 206, 104, 2, 840, 839, 3, 2, 2, 2, 840, 841, 3, 2, 2, 2, 841, 848, 3, 2, 2, 2, 842, 849, 5, 100, 51, 2, 843, 849, 5, 102, 52, 2, 844, 849, 5, 106, 54, 2, 845, 849, 5, 110, 56, 2, 846, 849, 5, 118, 60, 2, 847, 849, 5, 360, 181, 2, 848, 842, 3, 2, 2, 2, 848, 843, 3, 2, 2, 2, 848, 844, 3, 2, 2, 2, 848, 845, 3, 2, 2, 2, 848, 846, 3, 2, 2, 2, 848, 847, 3, 2, 2, 2, 849, 851, 3, 2, 2, 2, 850, 837, 3, 2, 2, 2, 850, 838, 3, 2, 2, 2, 850, 840, 3, 2, 2, 2, 851, 97, 3, 2, 2, 2, 852, 854, 5, 206, 104, 2, 853, 852, 3, 2, 2, 2, 853, 854, 3, 2, 2, 2, 854, 859, 3, 2, 2, 2, 855, 860, 7, 134, 2, 2, 856, 857, 7, 18, 2, 2, 857, 860, 5, 94, 48, 2, 858, 860, 7, 29, 2, 2, 859, 855, 3, 2, 2, 2, 859, 856, 3, 2, 2, 2, 859, 858, 3, 2, 2, 2, 860, 861, 3, 2, 2, 2, 861, 862, 7, 128, 2, 2, 862, 863, 5, 96, 49, 2, 863, 99, 3, 2, 2, 2, 864, 866, 5, 92, 47, 2, 865, 864, 3, 2, 2, 2, 865, 866, 3, 2, 2, 2, 866, 867, 3, 2, 2, 2, 867, 868, 7, 130, 2, 2, 868, 101, 3, 2, 2, 2, 869, 871, 7, 91, 2, 2, 870, 872, 5, 104, 53, 2, 871, 870, 3, 2, 2, 2, 871, 872, 3, 2, 2, 2, 872, 873, 3, 2, 2, 2, 873, 874, 7, 92, 2, 2, 874, 103, 3, 2, 2, 2, 875, 877, 5, 96, 49, 2, 876, 875, 3, 2, 2, 2, 877, 878, 3, 2, 2, 2, 878, 876, 3, 2, 2, 2, 878, 879, 3, 2, 2, 2, 879, 105, 3, 2, 2, 2, 880, 881, 7, 45, 2, 2, 881, 882, 7, 87, 2, 2, 882, 883, 5, 108, 55, 2, 883, 884, 7, 88, 2, 2, 884, 887, 5, 96, 49, 2, 885, 886, 7, 34, 2, 2, 886, 888, 5, 96, 49, 2, 887, 885, 3, 2, 2, 2, 887, 888, 3, 2, 2, 2, 888, 896, 3, 2, 2, 2, 889, 890, 7, 69, 2, 2, 890, 891, 7, 87, 2, 2, 891, 892, 5, 108, 55, 2, 892, 893, 7, 88, 2, 2, 893, 894, 5, 96, 49, 2, 894, 896, 3, 2, 2, 2, 895, 880, 3, 2, 2, 2, 895, 889, 3, 2, 2, 2, 896, 107, 3, 2, 2, 2, 897, 909, 5, 92, 47, 2, 898, 900, 5, 206, 104, 2, 899, 898, 3, 2, 2, 2, 899, 900, 3, 2, 2, 2, 900, 901, 3, 2, 2, 2, 901, 902, 5, 140, 71, 2, 902, 906, 5, 228, 115, 2, 903, 904, 7, 103, 2, 2, 904, 907, 5, 274, 138, 2, 905, 907, 5, 278, 140, 2, 906, 903, 3, 2, 2, 2, 906, 905, 3, 2, 2, 2, 907, 909, 3, 2, 2, 2, 908, 897, 3, 2, 2, 2, 908, 899, 3, 2, 2, 2, 909, 109, 3, 2, 2, 2, 910, 911, 7, 86, 2, 2, 911, 912, 7, 87, 2, 2, 912, 913, 5, 108, 55, 2, 913, 914, 7, 88, 2, 2, 914, 915, 5, 96, 49, 2, 915, 944, 3, 2, 2, 2, 916, 917, 7, 31, 2, 2, 917, 918, 5, 96, 49, 2, 918, 919, 7, 86, 2, 2, 919, 920, 7, 87, 2, 2, 920, 921, 5, 92, 47, 2, 921, 922, 7, 88, 2, 2, 922, 923, 7, 130, 2, 2, 923, 944, 3, 2, 2, 2, 924, 925, 7, 42, 2, 2, 925, 938, 7, 87, 2, 2, 926, 928, 5, 112, 57, 2, 927, 929, 5, 108, 55, 2, 928, 927, 3, 2, 2, 2, 928, 929, 3, 2, 2, 2, 929, 930, 3, 2, 2, 2, 930, 932, 7, 130, 2, 2, 931, 933, 5, 92, 47, 2, 932, 931, 3, 2, 2, 2, 932, 933, 3, 2, 2, 2, 933, 939, 3, 2, 2, 2, 934, 935, 5, 114, 58, 2, 935, 936, 7, 128, 2, 2, 936, 937, 5, 116, 59, 2, 937, 939, 3, 2, 2, 2, 938, 926, 3, 2, 2, 2, 938, 934, 3, 2, 2, 2, 939, 940, 3, 2, 2, 2, 940, 941, 7, 88, 2, 2, 941, 942, 5, 96, 49, 2, 942, 944, 3, 2, 2, 2, 943, 910, 3, 2, 2, 2, 943, 916, 3, 2, 2, 2, 943, 924, 3, 2, 2, 2, 944, 111, 3, 2, 2, 2, 945, 948, 5, 100, 51, 2, 946, 948, 5, 130, 66, 2, 947, 945, 3, 2, 2, 2, 947, 946, 3, 2, 2, 2, 948, 113, 3, 2, 2, 2, 949, 951, 5, 206, 104, 2, 950, 949, 3, 2, 2, 2, 950, 951, 3, 2, 2, 2, 951, 952, 3, 2, 2, 2, 952, 953, 5, 140, 71, 2, 953, 954, 5, 228, 115, 2, 954, 115, 3, 2, 2, 2, 955, 958, 5, 92, 47, 2, 956, 958, 5, 278, 140, 2, 957, 955, 3, 2, 2, 2, 957, 956, 3, 2, 2, 2, 958, 117, 3, 2, 2, 2, 959, 969, 7, 17, 2, 2, 960, 969, 7, 27, 2, 2, 961, 964, 7, 61, 2, 2, 962, 965, 5, 92, 47, 2, 963, 965, 5, 278, 140, 2, 964, 962, 3, 2, 2, 2, 964, 963, 3, 2, 2, 2, 964, 965, 3, 2, 2, 2, 965, 969, 3, 2, 2, 2, 966, 967, 7, 44, 2, 2, 967, 969, 7, 134, 2, 2, 968, 959, 3, 2, 2, 2, 968, 960, 3, 2, 2, 2, 968, 961, 3, 2, 2, 2, 968, 966, 3, 2, 2, 2, 969, 970, 3, 2, 2, 2, 970, 971, 7, 130, 2, 2, 971, 119, 3, 2, 2, 2, 972, 973, 5, 126, 64, 2, 973, 121, 3, 2, 2, 2, 974, 976, 5, 124, 63, 2, 975, 974, 3, 2, 2, 2, 976, 977, 3, 2, 2, 2, 977, 975, 3, 2, 2, 2, 977, 978, 3, 2, 2, 2, 978, 123, 3, 2, 2, 2, 979, 989, 5, 126, 64, 2, 980, 989, 5, 266, 134, 2, 981, 989, 5, 336, 169, 2, 982, 989, 5, 356, 179, 2, 983, 989, 5, 358, 180, 2, 984, 989, 5, 204, 103, 2, 985, 989, 5, 190, 96, 2, 986, 989, 5, 134, 68, 2, 987, 989, 5, 136, 69, 2, 988, 979, 3, 2, 2, 2, 988, 980, 3, 2, 2, 2, 988, 981, 3, 2, 2, 2, 988, 982, 3, 2, 2, 2, 988, 983, 3, 2, 2, 2, 988, 984, 3, 2, 2, 2, 988, 985, 3, 2, 2, 2, 988, 986, 3, 2, 2, 2, 988, 987, 3, 2, 2, 2, 989, 125, 3, 2, 2, 2, 990, 999, 5, 130, 66, 2, 991, 999, 5, 202, 102, 2, 992, 999, 5, 194, 98, 2, 993, 999, 5, 198, 100, 2, 994, 999, 5, 200, 101, 2, 995, 999, 5, 132, 67, 2, 996, 999, 5, 128, 65, 2, 997, 999, 5, 174, 88, 2, 998, 990, 3, 2, 2, 2, 998, 991, 3, 2, 2, 2, 998, 992, 3, 2, 2, 2, 998, 993, 3, 2, 2, 2, 998, 994, 3, 2, 2, 2, 998, 995, 3, 2, 2, 2, 998, 996, 3, 2, 2, 2, 998, 997, 3, 2, 2, 2, 999, 127, 3, 2, 2, 2, 1000, 1001, 7, 81, 2, 2, 1001, 1003, 7, 134, 2, 2, 1002, 1004, 5, 206, 104, 2, 1003, 1002, 3, 2, 2, 2, 1003, 1004, 3, 2, 2, 2, 1004, 1005, 3, 2, 2, 2, 1005, 1006, 7, 103, 2, 2, 1006, 1007, 5, 248, 125, 2, 1007, 1008, 7, 130, 2, 2, 1008, 129, 3, 2, 2, 2, 1009, 1011, 5, 140, 71, 2, 1010, 1009, 3, 2, 2, 2, 1010, 1011, 3, 2, 2, 2, 1011, 1013, 3, 2, 2, 2, 1012, 1014, 5, 224, 113, 2, 1013, 1012, 3, 2, 2, 2, 1013, 1014, 3, 2, 2, 2, 1014, 1015, 3, 2, 2, 2, 1015, 1024, 7, 130, 2, 2, 1016, 1018, 5, 206, 104, 2, 1017, 1019, 5, 140, 71, 2, 1018, 1017, 3, 2, 2, 2, 1018, 1019, 3, 2, 2, 2, 1019, 1020, 3, 2, 2, 2, 1020, 1021, 5, 224, 113, 2, 1021, 1022, 7, 130, 2, 2, 1022, 1024, 3, 2, 2, 2, 1023, 1010, 3, 2, 2, 2, 1023, 1016, 3, 2, 2, 2, 1024, 131, 3, 2, 2, 2, 1025, 1026, 7, 66, 2, 2, 1026, 1027, 7, 87, 2, 2, 1027, 1028, 5, 94, 48, 2, 1028, 1029, 7, 124, 2, 2, 1029, 1030, 7, 6, 2, 2, 1030, 1031, 7, 88, 2, 2, 1031, 1032, 7, 130, 2, 2, 1032, 133, 3, 2, 2, 2, 1033, 1034, 7, 130, 2, 2, 1034, 135, 3, 2, 2, 2, 1035, 1036, 5, 206, 104, 2, 1036, 1037, 7, 130, 2, 2, 1037, 137, 3, 2, 2, 2, 1038, 1045, 5, 142, 72, 2, 1039, 1045, 5, 148, 75, 2, 1040, 1045, 5, 144, 73, 2, 1041, 1045, 7, 43, 2, 2, 1042, 1045, 7, 76, 2, 2, 1043, 1045, 7, 25, 2, 2, 1044, 1038, 3, 2, 2, 2, 1044, 1039, 3, 2, 2, 2, 1044, 1040, 3, 2, 2, 2, 1044, 1041, 3, 2, 2, 2, 1044, 1042, 3, 2, 2, 2, 1044, 1043, 3, 2, 2, 2, 1045, 139, 3, 2, 2, 2, 1046, 1048, 5, 138, 70, 2, 1047, 1046, 3, 2, 2, 2, 1048, 1049, 3, 2, 2, 2, 1049, 1050, 3, 2, 2, 2, 1049, 1047, 3, 2, 2, 2, 1050, 1052, 3, 2, 2, 2, 1051, 1053, 5, 206, 104, 2, 1052, 1051, 3, 2, 2, 2, 1052, 1053, 3, 2, 2, 2, 1053, 141, 3, 2, 2, 2, 1054, 1055, 9, 13, 2, 2, 1055, 143, 3, 2, 2, 2, 1056, 1057, 9, 14, 2, 2, 1057, 145, 3, 2, 2, 2, 1058, 1059, 7, 134, 2, 2, 1059, 147, 3, 2, 2, 2, 1060, 1064, 5, 150, 76, 2, 1061, 1064, 5, 282, 142, 2, 1062, 1064, 5, 170, 86, 2, 1063, 1060, 3, 2, 2, 2, 1063, 1061, 3, 2, 2, 2, 1063, 1062, 3, 2, 2, 2, 1064, 149, 3, 2, 2, 2, 1065, 1070, 5, 160, 81, 2, 1066, 1070, 5, 166, 84, 2, 1067, 1070, 5, 354, 178, 2, 1068, 1070, 5, 242, 122, 2, 1069, 1065, 3, 2, 2, 2, 1069, 1066, 3, 2, 2, 2, 1069, 1067, 3, 2, 2, 2, 1069, 1068, 3, 2, 2, 2, 1070, 151, 3, 2, 2, 2, 1071, 1073, 5, 148, 75, 2, 1072, 1071, 3, 2, 2, 2, 1073, 1074, 3, 2, 2, 2, 1074, 1072, 3, 2, 2, 2, 1074, 1075, 3, 2, 2, 2, 1075, 1077, 3, 2, 2, 2, 1076, 1078, 5, 206, 104, 2, 1077, 1076, 3, 2, 2, 2, 1077, 1078, 3, 2, 2, 2, 1078, 153, 3, 2, 2, 2, 1079, 1081, 5, 150, 76, 2, 1080, 1079, 3, 2, 2, 2, 1081, 1082, 3, 2, 2, 2, 1082, 1080, 3, 2, 2, 2, 1082, 1083, 3, 2, 2, 2, 1083, 1085, 3, 2, 2, 2, 1084, 1086, 5, 206, 104, 2, 1085, 1084, 3, 2, 2, 2, 1085, 1086, 3, 2, 2, 2, 1086, 155, 3, 2, 2, 2, 1087, 1088, 9, 15, 2, 2, 1088, 157, 3, 2, 2, 2, 1089, 1090, 9, 16, 2, 2, 1090, 159, 3, 2, 2, 2, 1091, 1093, 5, 12, 7, 2, 1092, 1091, 3, 2, 2, 2, 1092, 1093, 3, 2, 2, 2, 1093, 1094, 3, 2, 2, 2, 1094, 1144, 5, 162, 82, 2, 1095, 1096, 5, 12, 7, 2, 1096, 1097, 7, 70, 2, 2, 1097, 1098, 5, 344, 173, 2, 1098, 1144, 3, 2, 2, 2, 1099, 1144, 5, 158, 80, 2, 1100, 1102, 5, 158, 80, 2, 1101, 1100, 3, 2, 2, 2, 1101, 1102, 3, 2, 2, 2, 1102, 1104, 3, 2, 2, 2, 1103, 1105, 5, 156, 79, 2, 1104, 1103, 3, 2, 2, 2, 1105, 1106, 3, 2, 2, 2, 1106, 1104, 3, 2, 2, 2, 1106, 1107, 3, 2, 2, 2, 1107, 1144, 3, 2, 2, 2, 1108, 1110, 5, 158, 80, 2, 1109, 1108, 3, 2, 2, 2, 1109, 1110, 3, 2, 2, 2, 1110, 1111, 3, 2, 2, 2, 1111, 1144, 7, 20, 2, 2, 1112, 1114, 5, 158, 80, 2, 1113, 1112, 3, 2, 2, 2, 1113, 1114, 3, 2, 2, 2, 1114, 1115, 3, 2, 2, 2, 1115, 1144, 7, 21, 2, 2, 1116, 1118, 5, 158, 80, 2, 1117, 1116, 3, 2, 2, 2, 1117, 1118, 3, 2, 2, 2, 1118, 1119, 3, 2, 2, 2, 1119, 1144, 7, 22, 2, 2, 1120, 1122, 5, 158, 80, 2, 1121, 1120, 3, 2, 2, 2, 1121, 1122, 3, 2, 2, 2, 1122, 1123, 3, 2, 2, 2, 1123, 1144, 7, 85, 2, 2, 1124, 1144, 7, 16, 2, 2, 1125, 1127, 5, 158, 80, 2, 1126, 1125, 3, 2, 2, 2, 1126, 1127, 3, 2, 2, 2, 1127, 1131, 3, 2, 2, 2, 1128, 1130, 5, 156, 79, 2, 1129, 1128, 3, 2, 2, 2, 1130, 1133, 3, 2, 2, 2, 1131, 1129, 3, 2, 2, 2, 1131, 1132, 3, 2, 2, 2, 1132, 1134, 3, 2, 2, 2, 1133, 1131, 3, 2, 2, 2, 1134, 1144, 7, 47, 2, 2, 1135, 1144, 7, 41, 2, 2, 1136, 1138, 5, 156, 79, 2, 1137, 1136, 3, 2, 2, 2, 1137, 1138, 3, 2, 2, 2, 1138, 1139, 3, 2, 2, 2, 1139, 1144, 7, 32, 2, 2, 1140, 1144, 7, 83, 2, 2, 1141, 1144, 7, 15, 2, 2, 1142, 1144, 5, 164, 83, 2, 1143, 1092, 3, 2, 2, 2, 1143, 1095, 3, 2, 2, 2, 1143, 1099, 3, 2, 2, 2, 1143, 1101, 3, 2, 2, 2, 1143, 1109, 3, 2, 2, 2, 1143, 1113, 3, 2, 2, 2, 1143, 1117, 3, 2, 2, 2, 1143, 1121, 3, 2, 2, 2, 1143, 1124, 3, 2, 2, 2, 1143, 1126, 3, 2, 2, 2, 1143, 1135, 3, 2, 2, 2, 1143, 1137, 3, 2, 2, 2, 1143, 1140, 3, 2, 2, 2, 1143, 1141, 3, 2, 2, 2, 1143, 1142, 3, 2, 2, 2, 1144, 161, 3, 2, 2, 2, 1145, 1150, 5, 280, 141, 2, 1146, 1150, 5, 168, 85, 2, 1147, 1150, 5, 146, 74, 2, 1148, 1150, 5, 344, 173, 2, 1149, 1145, 3, 2, 2, 2, 1149, 1146, 3, 2, 2, 2, 1149, 1147, 3, 2, 2, 2, 1149, 1148, 3, 2, 2, 2, 1150, 163, 3, 2, 2, 2, 1151, 1152, 7, 28, 2, 2, 1152, 1155, 7, 87, 2, 2, 1153, 1156, 5, 92, 47, 2, 1154, 1156, 7, 15, 2, 2, 1155, 1153, 3, 2, 2, 2, 1155, 1154, 3, 2, 2, 2, 1156, 1157, 3, 2, 2, 2, 1157, 1158, 7, 88, 2, 2, 1158, 165, 3, 2, 2, 2, 1159, 1174, 5, 290, 146, 2, 1160, 1162, 5, 206, 104, 2, 1161, 1160, 3, 2, 2, 2, 1161, 1162, 3, 2, 2, 2, 1162, 1164, 3, 2, 2, 2, 1163, 1165, 5, 12, 7, 2, 1164, 1163, 3, 2, 2, 2, 1164, 1165, 3, 2, 2, 2, 1165, 1166, 3, 2, 2, 2, 1166, 1175, 7, 134, 2, 2, 1167, 1175, 5, 344, 173, 2, 1168, 1170, 5, 12, 7, 2, 1169, 1171, 7, 70, 2, 2, 1170, 1169, 3, 2, 2, 2, 1170, 1171, 3, 2, 2, 2, 1171, 1172, 3, 2, 2, 2, 1172, 1173, 5, 344, 173, 2, 1173, 1175, 3, 2, 2, 2, 1174, 1161, 3, 2, 2, 2, 1174, 1167, 3, 2, 2, 2, 1174, 1168, 3, 2, 2, 2, 1175, 1182, 3, 2, 2, 2, 1176, 1178, 7, 35, 2, 2, 1177, 1179, 5, 12, 7, 2, 1178, 1177, 3, 2, 2, 2, 1178, 1179, 3, 2, 2, 2, 1179, 1180, 3, 2, 2, 2, 1180, 1182, 7, 134, 2, 2, 1181, 1159, 3, 2, 2, 2, 1181, 1176, 3, 2, 2, 2, 1182, 167, 3, 2, 2, 2, 1183, 1184, 7, 134, 2, 2, 1184, 169, 3, 2, 2, 2, 1185, 1186, 5, 172, 87, 2, 1186, 1191, 7, 91, 2, 2, 1187, 1189, 5, 180, 91, 2, 1188, 1190, 7, 124, 2, 2, 1189, 1188, 3, 2, 2, 2, 1189, 1190, 3, 2, 2, 2, 1190, 1192, 3, 2, 2, 2, 1191, 1187, 3, 2, 2, 2, 1191, 1192, 3, 2, 2, 2, 1192, 1193, 3, 2, 2, 2, 1193, 1194, 7, 92, 2, 2, 1194, 171, 3, 2, 2, 2, 1195, 1197, 5, 176, 89, 2, 1196, 1198, 5, 206, 104, 2, 1197, 1196, 3, 2, 2, 2, 1197, 1198, 3, 2, 2, 2, 1198, 1203, 3, 2, 2, 2, 1199, 1201, 5, 12, 7, 2, 1200, 1199, 3, 2, 2, 2, 1200, 1201, 3, 2, 2, 2, 1201, 1202, 3, 2, 2, 2, 1202, 1204, 7, 134, 2, 2, 1203, 1200, 3, 2, 2, 2, 1203, 1204, 3, 2, 2, 2, 1204, 1206, 3, 2, 2, 2, 1205, 1207, 5, 178, 90, 2, 1206, 1205, 3, 2, 2, 2, 1206, 1207, 3, 2, 2, 2, 1207, 173, 3, 2, 2, 2, 1208, 1210, 5, 176, 89, 2, 1209, 1211, 5, 206, 104, 2, 1210, 1209, 3, 2, 2, 2, 1210, 1211, 3, 2, 2, 2, 1211, 1212, 3, 2, 2, 2, 1212, 1214, 7, 134, 2, 2, 1213, 1215, 5, 178, 90, 2, 1214, 1213, 3, 2, 2, 2, 1214, 1215, 3, 2, 2, 2, 1215, 1216, 3, 2, 2, 2, 1216, 1217, 7, 130, 2, 2, 1217, 175, 3, 2, 2, 2, 1218, 1220, 7, 35, 2, 2, 1219, 1221, 9, 17, 2, 2, 1220, 1219, 3, 2, 2, 2, 1220, 1221, 3, 2, 2, 2, 1221, 177, 3, 2, 2, 2, 1222, 1223, 7, 128, 2, 2, 1223, 1224, 5, 152, 77, 2, 1224, 179, 3, 2, 2, 2, 1225, 1230, 5, 182, 92, 2, 1226, 1227, 7, 124, 2, 2, 1227, 1229, 5, 182, 92, 2, 1228, 1226, 3, 2, 2, 2, 1229, 1232, 3, 2, 2, 2, 1230, 1228, 3, 2, 2, 2, 1230, 1231, 3, 2, 2, 2, 1231, 181, 3, 2, 2, 2, 1232, 1230, 3, 2, 2, 2, 1233, 1236, 5, 184, 93, 2, 1234, 1235, 7, 103, 2, 2, 1235, 1237, 5, 94, 48, 2, 1236, 1234, 3, 2, 2, 2, 1236, 1237, 3, 2, 2, 2, 1237, 183, 3, 2, 2, 2, 1238, 1239, 7, 134, 2, 2, 1239, 185, 3, 2, 2, 2, 1240, 1243, 5, 188, 95, 2, 1241, 1243, 5, 192, 97, 2, 1242, 1240, 3, 2, 2, 2, 1242, 1241, 3, 2, 2, 2, 1243, 187, 3, 2, 2, 2, 1244, 1245, 7, 134, 2, 2, 1245, 189, 3, 2, 2, 2, 1246, 1248, 7, 46, 2, 2, 1247, 1246, 3, 2, 2, 2, 1247, 1248, 3, 2, 2, 2, 1248, 1249, 3, 2, 2, 2, 1249, 1252, 7, 50, 2, 2, 1250, 1253, 7, 134, 2, 2, 1251, 1253, 5, 188, 95, 2, 1252, 1250, 3, 2, 2, 2, 1252, 1251, 3, 2, 2, 2, 1252, 1253, 3, 2, 2, 2, 1253, 1254, 3, 2, 2, 2, 1254, 1256, 7, 91, 2, 2, 1255, 1257, 5, 122, 62, 2, 1256, 1255, 3, 2, 2, 2, 1256, 1257, 3, 2, 2, 2, 1257, 1258, 3, 2, 2, 2, 1258, 1259, 7, 92, 2, 2, 1259, 191, 3, 2, 2, 2, 1260, 1261, 7, 134, 2, 2, 1261, 193, 3, 2, 2, 2, 1262, 1263, 7, 50, 2, 2, 1263, 1264, 7, 134, 2, 2, 1264, 1265, 7, 103, 2, 2, 1265, 1266, 5, 196, 99, 2, 1266, 1267, 7, 130, 2, 2, 1267, 195, 3, 2, 2, 2, 1268, 1270, 5, 12, 7, 2, 1269, 1268, 3, 2, 2, 2, 1269, 1270, 3, 2, 2, 2, 1270, 1271, 3, 2, 2, 2, 1271, 1272, 5, 186, 94, 2, 1272, 197, 3, 2, 2, 2, 1273, 1279, 7, 81, 2, 2, 1274, 1276, 7, 78, 2, 2, 1275, 1274, 3, 2, 2, 2, 1275, 1276, 3, 2, 2, 2, 1276, 1277, 3, 2, 2, 2, 1277, 1280, 5, 12, 7, 2, 1278, 1280, 7, 129, 2, 2, 1279, 1275, 3, 2, 2, 2, 1279, 1278, 3, 2, 2, 2, 1280, 1281, 3, 2, 2, 2, 1281, 1282, 5, 8, 5, 2, 1282, 1283, 7, 130, 2, 2, 1283, 199, 3, 2, 2, 2, 1284, 1286, 5, 206, 104, 2, 1285, 1284, 3, 2, 2, 2, 1285, 1286, 3, 2, 2, 2, 1286, 1287, 3, 2, 2, 2, 1287, 1288, 7, 81, 2, 2, 1288, 1290, 7, 50, 2, 2, 1289, 1291, 5, 12, 7, 2, 1290, 1289, 3, 2, 2, 2, 1290, 1291, 3, 2, 2, 2, 1291, 1292, 3, 2, 2, 2, 1292, 1293, 5, 186, 94, 2, 1293, 1294, 7, 130, 2, 2, 1294, 201, 3, 2, 2, 2, 1295, 1296, 7, 14, 2, 2, 1296, 1297, 7, 87, 2, 2, 1297, 1298, 7, 6, 2, 2, 1298, 1299, 7, 88, 2, 2, 1299, 1300, 7, 130, 2, 2, 1300, 203, 3, 2, 2, 2, 1301, 1302, 7, 38, 2, 2, 1302, 1309, 7, 6, 2, 2, 1303, 1305, 7, 91, 2, 2, 1304, 1306, 5, 122, 62, 2, 1305, 1304, 3, 2, 2, 2, 1305, 1306, 3, 2, 2, 2, 1306, 1307, 3, 2, 2, 2, 1307, 1310, 7, 92, 2, 2, 1308, 1310, 5, 124, 63, 2, 1309, 1303, 3, 2, 2, 2, 1309, 1308, 3, 2, 2, 2, 1310, 205, 3, 2, 2, 2, 1311, 1313, 5, 208, 105, 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, 207, 3, 2, 2, 2, 1316, 1317, 7, 89, 2, 2, 1317, 1319, 7, 89, 2, 2, 1318, 1320, 5, 212, 107, 2, 1319, 1318, 3, 2, 2, 2, 1319, 1320, 3, 2, 2, 2, 1320, 1321, 3, 2, 2, 2, 1321, 1322, 7, 90, 2, 2, 1322, 1325, 7, 90, 2, 2, 1323, 1325, 5, 210, 106, 2, 1324, 1316, 3, 2, 2, 2, 1324, 1323, 3, 2, 2, 2, 1325, 209, 3, 2, 2, 2, 1326, 1327, 7, 12, 2, 2, 1327, 1330, 7, 87, 2, 2, 1328, 1331, 5, 248, 125, 2, 1329, 1331, 5, 94, 48, 2, 1330, 1328, 3, 2, 2, 2, 1330, 1329, 3, 2, 2, 2, 1331, 1333, 3, 2, 2, 2, 1332, 1334, 7, 133, 2, 2, 1333, 1332, 3, 2, 2, 2, 1333, 1334, 3, 2, 2, 2, 1334, 1335, 3, 2, 2, 2, 1335, 1336, 7, 88, 2, 2, 1336, 211, 3, 2, 2, 2, 1337, 1342, 5, 214, 108, 2, 1338, 1339, 7, 124, 2, 2, 1339, 1341, 5, 214, 108, 2, 1340, 1338, 3, 2, 2, 2, 1341, 1344, 3, 2, 2, 2, 1342, 1340, 3, 2, 2, 2, 1342, 1343, 3, 2, 2, 2, 1343, 1346, 3, 2, 2, 2, 1344, 1342, 3, 2, 2, 2, 1345, 1347, 7, 133, 2, 2, 1346, 1345, 3, 2, 2, 2, 1346, 1347, 3, 2, 2, 2, 1347, 213, 3, 2, 2, 2, 1348, 1349, 5, 216, 109, 2, 1349, 1350, 7, 129, 2, 2, 1350, 1352, 3, 2, 2, 2, 1351, 1348, 3, 2, 2, 2, 1351, 1352, 3, 2, 2, 2, 1352, 1353, 3, 2, 2, 2, 1353, 1355, 7, 134, 2, 2, 1354, 1356, 5, 218, 110, 2, 1355, 1354, 3, 2, 2, 2, 1355, 1356, 3, 2, 2, 2, 1356, 215, 3, 2, 2, 2, 1357, 1358, 7, 134, 2, 2, 1358, 217, 3, 2, 2, 2, 1359, 1361, 7, 87, 2, 2, 1360, 1362, 5, 220, 111, 2, 1361, 1360, 3, 2, 2, 2, 1361, 1362, 3, 2, 2, 2, 1362, 1363, 3, 2, 2, 2, 1363, 1364, 7, 88, 2, 2, 1364, 219, 3, 2, 2, 2, 1365, 1367, 5, 222, 112, 2, 1366, 1365, 3, 2, 2, 2, 1367, 1368, 3, 2, 2, 2, 1368, 1366, 3, 2, 2, 2, 1368, 1369, 3, 2, 2, 2, 1369, 221, 3, 2, 2, 2, 1370, 1371, 7, 87, 2, 2, 1371, 1372, 5, 220, 111, 2, 1372, 1373, 7, 88, 2, 2, 1373, 1388, 3, 2, 2, 2, 1374, 1375, 7, 89, 2, 2, 1375, 1376, 5, 220, 111, 2, 1376, 1377, 7, 90, 2, 2, 1377, 1388, 3, 2, 2, 2, 1378, 1379, 7, 91, 2, 2, 1379, 1380, 5, 220, 111, 2, 1380, 1381, 7, 92, 2, 2, 1381, 1388, 3, 2, 2, 2, 1382, 1384, 10, 18, 2, 2, 1383, 1382, 3, 2, 2, 2, 1384, 1385, 3, 2, 2, 2, 1385, 1383, 3, 2, 2, 2, 1385, 1386, 3, 2, 2, 2, 1386, 1388, 3, 2, 2, 2, 1387, 1370, 3, 2, 2, 2, 1387, 1374, 3, 2, 2, 2, 1387, 1378, 3, 2, 2, 2, 1387, 1383, 3, 2, 2, 2, 1388, 223, 3, 2, 2, 2, 1389, 1394, 5, 226, 114, 2, 1390, 1391, 7, 124, 2, 2, 1391, 1393, 5, 226, 114, 2, 1392, 1390, 3, 2, 2, 2, 1393, 1396, 3, 2, 2, 2, 1394, 1392, 3, 2, 2, 2, 1394, 1395, 3, 2, 2, 2, 1395, 225, 3, 2, 2, 2, 1396, 1394, 3, 2, 2, 2, 1397, 1399, 5, 228, 115, 2, 1398, 1400, 5, 270, 136, 2, 1399, 1398, 3, 2, 2, 2, 1399, 1400, 3, 2, 2, 2, 1400, 227, 3, 2, 2, 2, 1401, 1407, 5, 230, 116, 2, 1402, 1403, 5, 232, 117, 2, 1403, 1404, 5, 234, 118, 2, 1404, 1405, 5, 236, 119, 2, 1405, 1407, 3, 2, 2, 2, 1406, 1401, 3, 2, 2, 2, 1406, 1402, 3, 2, 2, 2, 1407, 229, 3, 2, 2, 2, 1408, 1410, 5, 238, 120, 2, 1409, 1411, 7, 24, 2, 2, 1410, 1409, 3, 2, 2, 2, 1410, 1411, 3, 2, 2, 2, 1411, 1413, 3, 2, 2, 2, 1412, 1408, 3, 2, 2, 2, 1413, 1416, 3, 2, 2, 2, 1414, 1412, 3, 2, 2, 2, 1414, 1415, 3, 2, 2, 2, 1415, 1417, 3, 2, 2, 2, 1416, 1414, 3, 2, 2, 2, 1417, 1418, 5, 232, 117, 2, 1418, 231, 3, 2, 2, 2, 1419, 1420, 8, 117, 1, 2, 1420, 1422, 5, 246, 124, 2, 1421, 1423, 5, 206, 104, 2, 1422, 1421, 3, 2, 2, 2, 1422, 1423, 3, 2, 2, 2, 1423, 1429, 3, 2, 2, 2, 1424, 1425, 7, 87, 2, 2, 1425, 1426, 5, 230, 116, 2, 1426, 1427, 7, 88, 2, 2, 1427, 1429, 3, 2, 2, 2, 1428, 1419, 3, 2, 2, 2, 1428, 1424, 3, 2, 2, 2, 1429, 1444, 3, 2, 2, 2, 1430, 1440, 12, 4, 2, 2, 1431, 1441, 5, 234, 118, 2, 1432, 1434, 7, 89, 2, 2, 1433, 1435, 5, 94, 48, 2, 1434, 1433, 3, 2, 2, 2, 1434, 1435, 3, 2, 2, 2, 1435, 1436, 3, 2, 2, 2, 1436, 1438, 7, 90, 2, 2, 1437, 1439, 5, 206, 104, 2, 1438, 1437, 3, 2, 2, 2, 1438, 1439, 3, 2, 2, 2, 1439, 1441, 3, 2, 2, 2, 1440, 1431, 3, 2, 2, 2, 1440, 1432, 3, 2, 2, 2, 1441, 1443, 3, 2, 2, 2, 1442, 1430, 3, 2, 2, 2, 1443, 1446, 3, 2, 2, 2, 1444, 1442, 3, 2, 2, 2, 1444, 1445, 3, 2, 2, 2, 1445, 233, 3, 2, 2, 2, 1446, 1444, 3, 2, 2, 2, 1447, 1449, 7, 87, 2, 2, 1448, 1450, 5, 260, 131, 2, 1449, 1448, 3, 2, 2, 2, 1449, 1450, 3, 2, 2, 2, 1450, 1451, 3, 2, 2, 2, 1451, 1453, 7, 88, 2, 2, 1452, 1454, 5, 240, 121, 2, 1453, 1452, 3, 2, 2, 2, 1453, 1454, 3, 2, 2, 2, 1454, 1456, 3, 2, 2, 2, 1455, 1457, 5, 244, 123, 2, 1456, 1455, 3, 2, 2, 2, 1456, 1457, 3, 2, 2, 2, 1457, 1459, 3, 2, 2, 2, 1458, 1460, 5, 372, 187, 2, 1459, 1458, 3, 2, 2, 2, 1459, 1460, 3, 2, 2, 2, 1460, 1462, 3, 2, 2, 2, 1461, 1463, 5, 206, 104, 2, 1462, 1461, 3, 2, 2, 2, 1462, 1463, 3, 2, 2, 2, 1463, 235, 3, 2, 2, 2, 1464, 1465, 7, 126, 2, 2, 1465, 1467, 5, 154, 78, 2, 1466, 1468, 5, 250, 126, 2, 1467, 1466, 3, 2, 2, 2, 1467, 1468, 3, 2, 2, 2, 1468, 237, 3, 2, 2, 2, 1469, 1471, 9, 19, 2, 2, 1470, 1472, 5, 206, 104, 2, 1471, 1470, 3, 2, 2, 2, 1471, 1472, 3, 2, 2, 2, 1472, 1484, 3, 2, 2, 2, 1473, 1475, 5, 12, 7, 2, 1474, 1473, 3, 2, 2, 2, 1474, 1475, 3, 2, 2, 2, 1475, 1476, 3, 2, 2, 2, 1476, 1478, 7, 95, 2, 2, 1477, 1479, 5, 206, 104, 2, 1478, 1477, 3, 2, 2, 2, 1478, 1479, 3, 2, 2, 2, 1479, 1481, 3, 2, 2, 2, 1480, 1482, 5, 240, 121, 2, 1481, 1480, 3, 2, 2, 2, 1481, 1482, 3, 2, 2, 2, 1482, 1484, 3, 2, 2, 2, 1483, 1469, 3, 2, 2, 2, 1483, 1474, 3, 2, 2, 2, 1484, 239, 3, 2, 2, 2, 1485, 1487, 5, 242, 122, 2, 1486, 1485, 3, 2, 2, 2, 1487, 1488, 3, 2, 2, 2, 1488, 1486, 3, 2, 2, 2, 1488, 1489, 3, 2, 2, 2, 1489, 241, 3, 2, 2, 2, 1490, 1491, 9, 20, 2, 2, 1491, 243, 3, 2, 2, 2, 1492, 1493, 9, 19, 2, 2, 1493, 245, 3, 2, 2, 2, 1494, 1496, 7, 133, 2, 2, 1495, 1494, 3, 2, 2, 2, 1495, 1496, 3, 2, 2, 2, 1496, 1497, 3, 2, 2, 2, 1497, 1498, 5, 6, 4, 2, 1498, 247, 3, 2, 2, 2, 1499, 1501, 5, 152, 77, 2, 1500, 1502, 5, 250, 126, 2, 1501, 1500, 3, 2, 2, 2, 1501, 1502, 3, 2, 2, 2, 1502, 249, 3, 2, 2, 2, 1503, 1512, 5, 252, 127, 2, 1504, 1506, 5, 254, 128, 2, 1505, 1504, 3, 2, 2, 2, 1505, 1506, 3, 2, 2, 2, 1506, 1507, 3, 2, 2, 2, 1507, 1508, 5, 234, 118, 2, 1508, 1509, 5, 236, 119, 2, 1509, 1512, 3, 2, 2, 2, 1510, 1512, 5, 256, 129, 2, 1511, 1503, 3, 2, 2, 2, 1511, 1505, 3, 2, 2, 2, 1511, 1510, 3, 2, 2, 2, 1512, 251, 3, 2, 2, 2, 1513, 1523, 5, 254, 128, 2, 1514, 1516, 5, 238, 120, 2, 1515, 1514, 3, 2, 2, 2, 1516, 1517, 3, 2, 2, 2, 1517, 1515, 3, 2, 2, 2, 1517, 1518, 3, 2, 2, 2, 1518, 1520, 3, 2, 2, 2, 1519, 1521, 5, 254, 128, 2, 1520, 1519, 3, 2, 2, 2, 1520, 1521, 3, 2, 2, 2, 1521, 1523, 3, 2, 2, 2, 1522, 1513, 3, 2, 2, 2, 1522, 1515, 3, 2, 2, 2, 1523, 253, 3, 2, 2, 2, 1524, 1525, 8, 128, 1, 2, 1525, 1539, 5, 234, 118, 2, 1526, 1528, 7, 89, 2, 2, 1527, 1529, 5, 94, 48, 2, 1528, 1527, 3, 2, 2, 2, 1528, 1529, 3, 2, 2, 2, 1529, 1530, 3, 2, 2, 2, 1530, 1532, 7, 90, 2, 2, 1531, 1533, 5, 206, 104, 2, 1532, 1531, 3, 2, 2, 2, 1532, 1533, 3, 2, 2, 2, 1533, 1539, 3, 2, 2, 2, 1534, 1535, 7, 87, 2, 2, 1535, 1536, 5, 252, 127, 2, 1536, 1537, 7, 88, 2, 2, 1537, 1539, 3, 2, 2, 2, 1538, 1524, 3, 2, 2, 2, 1538, 1526, 3, 2, 2, 2, 1538, 1534, 3, 2, 2, 2, 1539, 1555, 3, 2, 2, 2, 1540, 1551, 12, 6, 2, 2, 1541, 1552, 5, 234, 118, 2, 1542, 1543, 5, 254, 128, 2, 1543, 1545, 7, 89, 2, 2, 1544, 1546, 5, 94, 48, 2, 1545, 1544, 3, 2, 2, 2, 1545, 1546, 3, 2, 2, 2, 1546, 1547, 3, 2, 2, 2, 1547, 1549, 7, 90, 2, 2, 1548, 1550, 5, 206, 104, 2, 1549, 1548, 3, 2, 2, 2, 1549, 1550, 3, 2, 2, 2, 1550, 1552, 3, 2, 2, 2, 1551, 1541, 3, 2, 2, 2, 1551, 1542, 3, 2, 2, 2, 1552, 1554, 3, 2, 2, 2, 1553, 1540, 3, 2, 2, 2, 1554, 1557, 3, 2, 2, 2, 1555, 1553, 3, 2, 2, 2, 1555, 1556, 3, 2, 2, 2, 1556, 255, 3, 2, 2, 2, 1557, 1555, 3, 2, 2, 2, 1558, 1560, 5, 238, 120, 2, 1559, 1558, 3, 2, 2, 2, 1560, 1563, 3, 2, 2, 2, 1561, 1559, 3, 2, 2, 2, 1561, 1562, 3, 2, 2, 2, 1562, 1564, 3, 2, 2, 2, 1563, 1561, 3, 2, 2, 2, 1564, 1565, 5, 258, 130, 2, 1565, 257, 3, 2, 2, 2, 1566, 1567, 8, 130, 1, 2, 1567, 1568, 7, 133, 2, 2, 1568, 1583, 3, 2, 2, 2, 1569, 1579, 12, 4, 2, 2, 1570, 1580, 5, 234, 118, 2, 1571, 1573, 7, 89, 2, 2, 1572, 1574, 5, 94, 48, 2, 1573, 1572, 3, 2, 2, 2, 1573, 1574, 3, 2, 2, 2, 1574, 1575, 3, 2, 2, 2, 1575, 1577, 7, 90, 2, 2, 1576, 1578, 5, 206, 104, 2, 1577, 1576, 3, 2, 2, 2, 1577, 1578, 3, 2, 2, 2, 1578, 1580, 3, 2, 2, 2, 1579, 1570, 3, 2, 2, 2, 1579, 1571, 3, 2, 2, 2, 1580, 1582, 3, 2, 2, 2, 1581, 1569, 3, 2, 2, 2, 1582, 1585, 3, 2, 2, 2, 1583, 1581, 3, 2, 2, 2, 1583, 1584, 3, 2, 2, 2, 1584, 259, 3, 2, 2, 2, 1585, 1583, 3, 2, 2, 2, 1586, 1591, 5, 262, 132, 2, 1587, 1589, 7, 124, 2, 2, 1588, 1587, 3, 2, 2, 2, 1588, 1589, 3, 2, 2, 2, 1589, 1590, 3, 2, 2, 2, 1590, 1592, 7, 133, 2, 2, 1591, 1588, 3, 2, 2, 2, 1591, 1592, 3, 2, 2, 2, 1592, 261, 3, 2, 2, 2, 1593, 1598, 5, 264, 133, 2, 1594, 1595, 7, 124, 2, 2, 1595, 1597, 5, 264, 133, 2, 1596, 1594, 3, 2, 2, 2, 1597, 1600, 3, 2, 2, 2, 1598, 1596, 3, 2, 2, 2, 1598, 1599, 3, 2, 2, 2, 1599, 263, 3, 2, 2, 2, 1600, 1598, 3, 2, 2, 2, 1601, 1603, 5, 206, 104, 2, 1602, 1601, 3, 2, 2, 2, 1602, 1603, 3, 2, 2, 2, 1603, 1604, 3, 2, 2, 2, 1604, 1609, 5, 140, 71, 2, 1605, 1610, 5, 228, 115, 2, 1606, 1608, 5, 250, 126, 2, 1607, 1606, 3, 2, 2, 2, 1607, 1608, 3, 2, 2, 2, 1608, 1610, 3, 2, 2, 2, 1609, 1605, 3, 2, 2, 2, 1609, 1607, 3, 2, 2, 2, 1610, 1613, 3, 2, 2, 2, 1611, 1612, 7, 103, 2, 2, 1612, 1614, 5, 274, 138, 2, 1613, 1611, 3, 2, 2, 2, 1613, 1614, 3, 2, 2, 2, 1614, 265, 3, 2, 2, 2, 1615, 1617, 5, 206, 104, 2, 1616, 1615, 3, 2, 2, 2, 1616, 1617, 3, 2, 2, 2, 1617, 1619, 3, 2, 2, 2, 1618, 1620, 5, 140, 71, 2, 1619, 1618, 3, 2, 2, 2, 1619, 1620, 3, 2, 2, 2, 1620, 1621, 3, 2, 2, 2, 1621, 1623, 5, 228, 115, 2, 1622, 1624, 5, 300, 151, 2, 1623, 1622, 3, 2, 2, 2, 1623, 1624, 3, 2, 2, 2, 1624, 1625, 3, 2, 2, 2, 1625, 1626, 5, 268, 135, 2, 1626, 267, 3, 2, 2, 2, 1627, 1629, 5, 324, 163, 2, 1628, 1627, 3, 2, 2, 2, 1628, 1629, 3, 2, 2, 2, 1629, 1630, 3, 2, 2, 2, 1630, 1636, 5, 102, 52, 2, 1631, 1636, 5, 362, 182, 2, 1632, 1633, 7, 103, 2, 2, 1633, 1634, 9, 21, 2, 2, 1634, 1636, 7, 130, 2, 2, 1635, 1628, 3, 2, 2, 2, 1635, 1631, 3, 2, 2, 2, 1635, 1632, 3, 2, 2, 2, 1636, 269, 3, 2, 2, 2, 1637, 1643, 5, 272, 137, 2, 1638, 1639, 7, 87, 2, 2, 1639, 1640, 5, 36, 19, 2, 1640, 1641, 7, 88, 2, 2, 1641, 1643, 3, 2, 2, 2, 1642, 1637, 3, 2, 2, 2, 1642, 1638, 3, 2, 2, 2, 1643, 271, 3, 2, 2, 2, 1644, 1645, 7, 103, 2, 2, 1645, 1648, 5, 274, 138, 2, 1646, 1648, 5, 278, 140, 2, 1647, 1644, 3, 2, 2, 2, 1647, 1646, 3, 2, 2, 2, 1648, 273, 3, 2, 2, 2, 1649, 1652, 5, 88, 45, 2, 1650, 1652, 5, 278, 140, 2, 1651, 1649, 3, 2, 2, 2, 1651, 1650, 3, 2, 2, 2, 1652, 275, 3, 2, 2, 2, 1653, 1655, 5, 274, 138, 2, 1654, 1656, 7, 133, 2, 2, 1655, 1654, 3, 2, 2, 2, 1655, 1656, 3, 2, 2, 2, 1656, 1664, 3, 2, 2, 2, 1657, 1658, 7, 124, 2, 2, 1658, 1660, 5, 274, 138, 2, 1659, 1661, 7, 133, 2, 2, 1660, 1659, 3, 2, 2, 2, 1660, 1661, 3, 2, 2, 2, 1661, 1663, 3, 2, 2, 2, 1662, 1657, 3, 2, 2, 2, 1663, 1666, 3, 2, 2, 2, 1664, 1662, 3, 2, 2, 2, 1664, 1665, 3, 2, 2, 2, 1665, 277, 3, 2, 2, 2, 1666, 1664, 3, 2, 2, 2, 1667, 1672, 7, 91, 2, 2, 1668, 1670, 5, 276, 139, 2, 1669, 1671, 7, 124, 2, 2, 1670, 1669, 3, 2, 2, 2, 1670, 1671, 3, 2, 2, 2, 1671, 1673, 3, 2, 2, 2, 1672, 1668, 3, 2, 2, 2, 1672, 1673, 3, 2, 2, 2, 1673, 1674, 3, 2, 2, 2, 1674, 1675, 7, 92, 2, 2, 1675, 279, 3, 2, 2, 2, 1676, 1679, 7, 134, 2, 2, 1677, 1679, 5, 344, 173, 2, 1678, 1676, 3, 2, 2, 2, 1678, 1677, 3, 2, 2, 2, 1679, 281, 3, 2, 2, 2, 1680, 1681, 5, 284, 143, 2, 1681, 1683, 7, 91, 2, 2, 1682, 1684, 5, 292, 147, 2, 1683, 1682, 3, 2, 2, 2, 1683, 1684, 3, 2, 2, 2, 1684, 1685, 3, 2, 2, 2, 1685, 1686, 7, 92, 2, 2, 1686, 283, 3, 2, 2, 2, 1687, 1689, 5, 290, 146, 2, 1688, 1690, 5, 206, 104, 2, 1689, 1688, 3, 2, 2, 2, 1689, 1690, 3, 2, 2, 2, 1690, 1695, 3, 2, 2, 2, 1691, 1693, 5, 286, 144, 2, 1692, 1694, 5, 288, 145, 2, 1693, 1692, 3, 2, 2, 2, 1693, 1694, 3, 2, 2, 2, 1694, 1696, 3, 2, 2, 2, 1695, 1691, 3, 2, 2, 2, 1695, 1696, 3, 2, 2, 2, 1696, 1698, 3, 2, 2, 2, 1697, 1699, 5, 306, 154, 2, 1698, 1697, 3, 2, 2, 2, 1698, 1699, 3, 2, 2, 2, 1699, 1711, 3, 2, 2, 2, 1700, 1702, 7, 79, 2, 2, 1701, 1703, 5, 206, 104, 2, 1702, 1701, 3, 2, 2, 2, 1702, 1703, 3, 2, 2, 2, 1703, 1708, 3, 2, 2, 2, 1704, 1706, 5, 286, 144, 2, 1705, 1707, 5, 288, 145, 2, 1706, 1705, 3, 2, 2, 2, 1706, 1707, 3, 2, 2, 2, 1707, 1709, 3, 2, 2, 2, 1708, 1704, 3, 2, 2, 2, 1708, 1709, 3, 2, 2, 2, 1709, 1711, 3, 2, 2, 2, 1710, 1687, 3, 2, 2, 2, 1710, 1700, 3, 2, 2, 2, 1711, 285, 3, 2, 2, 2, 1712, 1714, 5, 12, 7, 2, 1713, 1712, 3, 2, 2, 2, 1713, 1714, 3, 2, 2, 2, 1714, 1715, 3, 2, 2, 2, 1715, 1716, 5, 280, 141, 2, 1716, 287, 3, 2, 2, 2, 1717, 1718, 7, 40, 2, 2, 1718, 289, 3, 2, 2, 2, 1719, 1720, 9, 17, 2, 2, 1720, 291, 3, 2, 2, 2, 1721, 1726, 5, 294, 148, 2, 1722, 1723, 5, 316, 159, 2, 1723, 1724, 7, 128, 2, 2, 1724, 1726, 3, 2, 2, 2, 1725, 1721, 3, 2, 2, 2, 1725, 1722, 3, 2, 2, 2, 1726, 1727, 3, 2, 2, 2, 1727, 1725, 3, 2, 2, 2, 1727, 1728, 3, 2, 2, 2, 1728, 293, 3, 2, 2, 2, 1729, 1731, 5, 206, 104, 2, 1730, 1729, 3, 2, 2, 2, 1730, 1731, 3, 2, 2, 2, 1731, 1733, 3, 2, 2, 2, 1732, 1734, 5, 140, 71, 2, 1733, 1732, 3, 2, 2, 2, 1733, 1734, 3, 2, 2, 2, 1734, 1736, 3, 2, 2, 2, 1735, 1737, 5, 296, 149, 2, 1736, 1735, 3, 2, 2, 2, 1736, 1737, 3, 2, 2, 2, 1737, 1738, 3, 2, 2, 2, 1738, 1746, 7, 130, 2, 2, 1739, 1746, 5, 266, 134, 2, 1740, 1746, 5, 198, 100, 2, 1741, 1746, 5, 132, 67, 2, 1742, 1746, 5, 336, 169, 2, 1743, 1746, 5, 128, 65, 2, 1744, 1746, 5, 134, 68, 2, 1745, 1730, 3, 2, 2, 2, 1745, 1739, 3, 2, 2, 2, 1745, 1740, 3, 2, 2, 2, 1745, 1741, 3, 2, 2, 2, 1745, 1742, 3, 2, 2, 2, 1745, 1743, 3, 2, 2, 2, 1745, 1744, 3, 2, 2, 2, 1746, 295, 3, 2, 2, 2, 1747, 1752, 5, 298, 150, 2, 1748, 1749, 7, 124, 2, 2, 1749, 1751, 5, 298, 150, 2, 1750, 1748, 3, 2, 2, 2, 1751, 1754, 3, 2, 2, 2, 1752, 1750, 3, 2, 2, 2, 1752, 1753, 3, 2, 2, 2, 1753, 297, 3, 2, 2, 2, 1754, 1752, 3, 2, 2, 2, 1755, 1765, 5, 228, 115, 2, 1756, 1758, 5, 300, 151, 2, 1757, 1756, 3, 2, 2, 2, 1757, 1758, 3, 2, 2, 2, 1758, 1760, 3, 2, 2, 2, 1759, 1761, 5, 304, 153, 2, 1760, 1759, 3, 2, 2, 2, 1760, 1761, 3, 2, 2, 2, 1761, 1766, 3, 2, 2, 2, 1762, 1764, 5, 272, 137, 2, 1763, 1762, 3, 2, 2, 2, 1763, 1764, 3, 2, 2, 2, 1764, 1766, 3, 2, 2, 2, 1765, 1757, 3, 2, 2, 2, 1765, 1763, 3, 2, 2, 2, 1766, 1776, 3, 2, 2, 2, 1767, 1769, 7, 134, 2, 2, 1768, 1767, 3, 2, 2, 2, 1768, 1769, 3, 2, 2, 2, 1769, 1771, 3, 2, 2, 2, 1770, 1772, 5, 206, 104, 2, 1771, 1770, 3, 2, 2, 2, 1771, 1772, 3, 2, 2, 2, 1772, 1773, 3, 2, 2, 2, 1773, 1774, 7, 128, 2, 2, 1774, 1776, 5, 94, 48, 2, 1775, 1755, 3, 2, 2, 2, 1775, 1768, 3, 2, 2, 2, 1776, 299, 3, 2, 2, 2, 1777, 1779, 5, 302, 152, 2, 1778, 1777, 3, 2, 2, 2, 1779, 1780, 3, 2, 2, 2, 1780, 1778, 3, 2, 2, 2, 1780, 1781, 3, 2, 2, 2, 1781, 301, 3, 2, 2, 2, 1782, 1783, 9, 22, 2, 2, 1783, 303, 3, 2, 2, 2, 1784, 1785, 7, 103, 2, 2, 1785, 1786, 7, 136, 2, 2, 1786, 1787, 8, 153, 1, 2, 1787, 305, 3, 2, 2, 2, 1788, 1789, 7, 128, 2, 2, 1789, 1790, 5, 308, 155, 2, 1790, 307, 3, 2, 2, 2, 1791, 1793, 5, 310, 156, 2, 1792, 1794, 7, 133, 2, 2, 1793, 1792, 3, 2, 2, 2, 1793, 1794, 3, 2, 2, 2, 1794, 1802, 3, 2, 2, 2, 1795, 1796, 7, 124, 2, 2, 1796, 1798, 5, 310, 156, 2, 1797, 1799, 7, 133, 2, 2, 1798, 1797, 3, 2, 2, 2, 1798, 1799, 3, 2, 2, 2, 1799, 1801, 3, 2, 2, 2, 1800, 1795, 3, 2, 2, 2, 1801, 1804, 3, 2, 2, 2, 1802, 1800, 3, 2, 2, 2, 1802, 1803, 3, 2, 2, 2, 1803, 309, 3, 2, 2, 2, 1804, 1802, 3, 2, 2, 2, 1805, 1807, 5, 206, 104, 2, 1806, 1805, 3, 2, 2, 2, 1806, 1807, 3, 2, 2, 2, 1807, 1820, 3, 2, 2, 2, 1808, 1821, 5, 314, 158, 2, 1809, 1811, 7, 82, 2, 2, 1810, 1812, 5, 316, 159, 2, 1811, 1810, 3, 2, 2, 2, 1811, 1812, 3, 2, 2, 2, 1812, 1813, 3, 2, 2, 2, 1813, 1821, 5, 314, 158, 2, 1814, 1816, 5, 316, 159, 2, 1815, 1817, 7, 82, 2, 2, 1816, 1815, 3, 2, 2, 2, 1816, 1817, 3, 2, 2, 2, 1817, 1818, 3, 2, 2, 2, 1818, 1819, 5, 314, 158, 2, 1819, 1821, 3, 2, 2, 2, 1820, 1808, 3, 2, 2, 2, 1820, 1809, 3, 2, 2, 2, 1820, 1814, 3, 2, 2, 2, 1821, 311, 3, 2, 2, 2, 1822, 1824, 5, 12, 7, 2, 1823, 1822, 3, 2, 2, 2, 1823, 1824, 3, 2, 2, 2, 1824, 1825, 3, 2, 2, 2, 1825, 1828, 5, 280, 141, 2, 1826, 1828, 5, 164, 83, 2, 1827, 1823, 3, 2, 2, 2, 1827, 1826, 3, 2, 2, 2, 1828, 313, 3, 2, 2, 2, 1829, 1830, 5, 312, 157, 2, 1830, 315, 3, 2, 2, 2, 1831, 1832, 9, 23, 2, 2, 1832, 317, 3, 2, 2, 2, 1833, 1834, 7, 54, 2, 2, 1834, 1835, 5, 320, 161, 2, 1835, 319, 3, 2, 2, 2, 1836, 1838, 5, 152, 77, 2, 1837, 1839, 5, 322, 162, 2, 1838, 1837, 3, 2, 2, 2, 1838, 1839, 3, 2, 2, 2, 1839, 321, 3, 2, 2, 2, 1840, 1842, 5, 238, 120, 2, 1841, 1843, 5, 322, 162, 2, 1842, 1841, 3, 2, 2, 2, 1842, 1843, 3, 2, 2, 2, 1843, 323, 3, 2, 2, 2, 1844, 1845, 7, 128, 2, 2, 1845, 1846, 5, 326, 164, 2, 1846, 325, 3, 2, 2, 2, 1847, 1849, 5, 328, 165, 2, 1848, 1850, 7, 133, 2, 2, 1849, 1848, 3, 2, 2, 2, 1849, 1850, 3, 2, 2, 2, 1850, 1858, 3, 2, 2, 2, 1851, 1852, 7, 124, 2, 2, 1852, 1854, 5, 328, 165, 2, 1853, 1855, 7, 133, 2, 2, 1854, 1853, 3, 2, 2, 2, 1854, 1855, 3, 2, 2, 2, 1855, 1857, 3, 2, 2, 2, 1856, 1851, 3, 2, 2, 2, 1857, 1860, 3, 2, 2, 2, 1858, 1856, 3, 2, 2, 2, 1858, 1859, 3, 2, 2, 2, 1859, 327, 3, 2, 2, 2, 1860, 1858, 3, 2, 2, 2, 1861, 1868, 5, 330, 166, 2, 1862, 1864, 7, 87, 2, 2, 1863, 1865, 5, 36, 19, 2, 1864, 1863, 3, 2, 2, 2, 1864, 1865, 3, 2, 2, 2, 1865, 1866, 3, 2, 2, 2, 1866, 1869, 7, 88, 2, 2, 1867, 1869, 5, 278, 140, 2, 1868, 1862, 3, 2, 2, 2, 1868, 1867, 3, 2, 2, 2, 1869, 329, 3, 2, 2, 2, 1870, 1873, 5, 312, 157, 2, 1871, 1873, 7, 134, 2, 2, 1872, 1870, 3, 2, 2, 2, 1872, 1871, 3, 2, 2, 2, 1873, 331, 3, 2, 2, 2, 1874, 1875, 7, 54, 2, 2, 1875, 1876, 5, 380, 191, 2, 1876, 333, 3, 2, 2, 2, 1877, 1881, 7, 54, 2, 2, 1878, 1879, 7, 6, 2, 2, 1879, 1882, 7, 134, 2, 2, 1880, 1882, 7, 142, 2, 2, 1881, 1878, 3, 2, 2, 2, 1881, 1880, 3, 2, 2, 2, 1882, 335, 3, 2, 2, 2, 1883, 1884, 7, 70, 2, 2, 1884, 1885, 7, 104, 2, 2, 1885, 1886, 5, 338, 170, 2, 1886, 1887, 7, 105, 2, 2, 1887, 1888, 5, 124, 63, 2, 1888, 337, 3, 2, 2, 2, 1889, 1894, 5, 340, 171, 2, 1890, 1891, 7, 124, 2, 2, 1891, 1893, 5, 340, 171, 2, 1892, 1890, 3, 2, 2, 2, 1893, 1896, 3, 2, 2, 2, 1894, 1892, 3, 2, 2, 2, 1894, 1895, 3, 2, 2, 2, 1895, 339, 3, 2, 2, 2, 1896, 1894, 3, 2, 2, 2, 1897, 1900, 5, 342, 172, 2, 1898, 1900, 5, 264, 133, 2, 1899, 1897, 3, 2, 2, 2, 1899, 1898, 3, 2, 2, 2, 1900, 341, 3, 2, 2, 2, 1901, 1902, 7, 70, 2, 2, 1902, 1903, 7, 104, 2, 2, 1903, 1904, 5, 338, 170, 2, 1904, 1905, 7, 105, 2, 2, 1905, 1907, 3, 2, 2, 2, 1906, 1901, 3, 2, 2, 2, 1906, 1907, 3, 2, 2, 2, 1907, 1908, 3, 2, 2, 2, 1908, 1911, 7, 23, 2, 2, 1909, 1911, 7, 78, 2, 2, 1910, 1906, 3, 2, 2, 2, 1910, 1909, 3, 2, 2, 2, 1911, 1923, 3, 2, 2, 2, 1912, 1914, 7, 133, 2, 2, 1913, 1912, 3, 2, 2, 2, 1913, 1914, 3, 2, 2, 2, 1914, 1916, 3, 2, 2, 2, 1915, 1917, 7, 134, 2, 2, 1916, 1915, 3, 2, 2, 2, 1916, 1917, 3, 2, 2, 2, 1917, 1924, 3, 2, 2, 2, 1918, 1920, 7, 134, 2, 2, 1919, 1918, 3, 2, 2, 2, 1919, 1920, 3, 2, 2, 2, 1920, 1921, 3, 2, 2, 2, 1921, 1922, 7, 103, 2, 2, 1922, 1924, 5, 248, 125, 2, 1923, 1913, 3, 2, 2, 2, 1923, 1919, 3, 2, 2, 2, 1924, 343, 3, 2, 2, 2, 1925, 1926, 5, 348, 175, 2, 1926, 1928, 7, 104, 2, 2, 1927, 1929, 5, 350, 176, 2, 1928, 1927, 3, 2, 2, 2, 1928, 1929, 3, 2, 2, 2, 1929, 1930, 3, 2, 2, 2, 1930, 1931, 7, 105, 2, 2, 1931, 345, 3, 2, 2, 2, 1932, 1944, 5, 344, 173, 2, 1933, 1936, 5, 332, 167, 2, 1934, 1936, 5, 334, 168, 2, 1935, 1933, 3, 2, 2, 2, 1935, 1934, 3, 2, 2, 2, 1936, 1937, 3, 2, 2, 2, 1937, 1939, 7, 104, 2, 2, 1938, 1940, 5, 350, 176, 2, 1939, 1938, 3, 2, 2, 2, 1939, 1940, 3, 2, 2, 2, 1940, 1941, 3, 2, 2, 2, 1941, 1942, 7, 105, 2, 2, 1942, 1944, 3, 2, 2, 2, 1943, 1932, 3, 2, 2, 2, 1943, 1935, 3, 2, 2, 2, 1944, 347, 3, 2, 2, 2, 1945, 1946, 7, 134, 2, 2, 1946, 349, 3, 2, 2, 2, 1947, 1949, 5, 352, 177, 2, 1948, 1950, 7, 133, 2, 2, 1949, 1948, 3, 2, 2, 2, 1949, 1950, 3, 2, 2, 2, 1950, 1958, 3, 2, 2, 2, 1951, 1952, 7, 124, 2, 2, 1952, 1954, 5, 352, 177, 2, 1953, 1955, 7, 133, 2, 2, 1954, 1953, 3, 2, 2, 2, 1954, 1955, 3, 2, 2, 2, 1955, 1957, 3, 2, 2, 2, 1956, 1951, 3, 2, 2, 2, 1957, 1960, 3, 2, 2, 2, 1958, 1956, 3, 2, 2, 2, 1958, 1959, 3, 2, 2, 2, 1959, 351, 3, 2, 2, 2, 1960, 1958, 3, 2, 2, 2, 1961, 1965, 5, 248, 125, 2, 1962, 1965, 5, 94, 48, 2, 1963, 1965, 5, 6, 4, 2, 1964, 1961, 3, 2, 2, 2, 1964, 1962, 3, 2, 2, 2, 1964, 1963, 3, 2, 2, 2, 1965, 353, 3, 2, 2, 2, 1966, 1967, 7, 78, 2, 2, 1967, 1973, 5, 12, 7, 2, 1968, 1974, 7, 134, 2, 2, 1969, 1971, 7, 70, 2, 2, 1970, 1969, 3, 2, 2, 2, 1970, 1971, 3, 2, 2, 2, 1971, 1972, 3, 2, 2, 2, 1972, 1974, 5, 344, 173, 2, 1973, 1968, 3, 2, 2, 2, 1973, 1970, 3, 2, 2, 2, 1974, 355, 3, 2, 2, 2, 1975, 1977, 7, 38, 2, 2, 1976, 1975, 3, 2, 2, 2, 1976, 1977, 3, 2, 2, 2, 1977, 1978, 3, 2, 2, 2, 1978, 1979, 7, 70, 2, 2, 1979, 1980, 5, 124, 63, 2, 1980, 357, 3, 2, 2, 2, 1981, 1982, 7, 70, 2, 2, 1982, 1983, 7, 104, 2, 2, 1983, 1984, 7, 105, 2, 2, 1984, 1985, 5, 124, 63, 2, 1985, 359, 3, 2, 2, 2, 1986, 1987, 7, 75, 2, 2, 1987, 1988, 5, 102, 52, 2, 1988, 1989, 5, 364, 183, 2, 1989, 361, 3, 2, 2, 2, 1990, 1992, 7, 75, 2, 2, 1991, 1993, 5, 324, 163, 2, 1992, 1991, 3, 2, 2, 2, 1992, 1993, 3, 2, 2, 2, 1993, 1994, 3, 2, 2, 2, 1994, 1995, 5, 102, 52, 2, 1995, 1996, 5, 364, 183, 2, 1996, 363, 3, 2, 2, 2, 1997, 1999, 5, 366, 184, 2, 1998, 1997, 3, 2, 2, 2, 1999, 2000, 3, 2, 2, 2, 2000, 1998, 3, 2, 2, 2, 2000, 2001, 3, 2, 2, 2, 2001, 365, 3, 2, 2, 2, 2002, 2003, 7, 19, 2, 2, 2003, 2004, 7, 87, 2, 2, 2004, 2005, 5, 368, 185, 2, 2005, 2006, 7, 88, 2, 2, 2006, 2007, 5, 102, 52, 2, 2007, 367, 3, 2, 2, 2, 2008, 2010, 5, 206, 104, 2, 2009, 2008, 3, 2, 2, 2, 2009, 2010, 3, 2, 2, 2, 2010, 2011, 3, 2, 2, 2, 2011, 2014, 5, 152, 77, 2, 2012, 2015, 5, 228, 115, 2, 2013, 2015, 5, 250, 126, 2, 2014, 2012, 3, 2, 2, 2, 2014, 2013, 3, 2, 2, 2, 2014, 2015, 3, 2, 2, 2, 2015, 2018, 3, 2, 2, 2, 2016, 2018, 7, 133, 2, 2, 2017, 2009, 3, 2, 2, 2, 2017, 2016, 3, 2, 2, 2, 2018, 369, 3, 2, 2, 2, 2019, 2021, 7, 73, 2, 2, 2020, 2022, 5, 88, 45, 2, 2021, 2020, 3, 2, 2, 2, 2021, 2022, 3, 2, 2, 2, 2022, 371, 3, 2, 2, 2, 2023, 2026, 5, 374, 188, 2, 2024, 2026, 5, 378, 190, 2, 2025, 2023, 3, 2, 2, 2, 2025, 2024, 3, 2, 2, 2, 2026, 373, 3, 2, 2, 2, 2027, 2028, 7, 73, 2, 2, 2028, 2030, 7, 87, 2, 2, 2029, 2031, 5, 376, 189, 2, 2030, 2029, 3, 2, 2, 2, 2030, 2031, 3, 2, 2, 2, 2031, 2032, 3, 2, 2, 2, 2032, 2033, 7, 88, 2, 2, 2033, 375, 3, 2, 2, 2, 2034, 2036, 5, 248, 125, 2, 2035, 2037, 7, 133, 2, 2, 2036, 2035, 3, 2, 2, 2, 2036, 2037, 3, 2, 2, 2, 2037, 2045, 3, 2, 2, 2, 2038, 2039, 7, 124, 2, 2, 2039, 2041, 5, 248, 125, 2, 2040, 2042, 7, 133, 2, 2, 2041, 2040, 3, 2, 2, 2, 2041, 2042, 3, 2, 2, 2, 2042, 2044, 3, 2, 2, 2, 2043, 2038, 3, 2, 2, 2, 2044, 2047, 3, 2, 2, 2, 2045, 2043, 3, 2, 2, 2, 2045, 2046, 3, 2, 2, 2, 2046, 377, 3, 2, 2, 2, 2047, 2045, 3, 2, 2, 2, 2048, 2049, 7, 52, 2, 2, 2049, 2050, 7, 87, 2, 2, 2050, 2051, 5, 94, 48, 2, 2051, 2052, 7, 88, 2, 2, 2052, 2055, 3, 2, 2, 2, 2053, 2055, 7, 52, 2, 2, 2054, 2048, 3, 2, 2, 2, 2054, 2053, 3, 2, 2, 2, 2055, 379, 3, 2, 2, 2, 2056, 2059, 7, 51, 2, 2, 2057, 2058, 7, 89, 2, 2, 2058, 2060, 7, 90, 2, 2, 2059, 2057, 3, 2, 2, 2, 2059, 2060, 3, 2, 2, 2, 2060, 2108, 3, 2, 2, 2, 2061, 2064, 7, 30, 2, 2, 2062, 2063, 7, 89, 2, 2, 2063, 2065, 7, 90, 2, 2, 2064, 2062, 3, 2, 2, 2, 2064, 2065, 3, 2, 2, 2, 2065, 2108, 3, 2, 2, 2, 2066, 2108, 7, 93, 2, 2, 2067, 2108, 7, 94, 2, 2, 2068, 2108, 7, 95, 2, 2, 2069, 2108, 7, 96, 2, 2, 2070, 2108, 7, 97, 2, 2, 2071, 2108, 7, 98, 2, 2, 2072, 2108, 7, 99, 2, 2, 2073, 2108, 7, 100, 2, 2, 2074, 2108, 7, 101, 2, 2, 2075, 2108, 7, 102, 2, 2, 2076, 2108, 7, 103, 2, 2, 2077, 2108, 7, 105, 2, 2, 2078, 2108, 7, 104, 2, 2, 2079, 2108, 7, 119, 2, 2, 2080, 2108, 7, 106, 2, 2, 2081, 2108, 7, 107, 2, 2, 2082, 2108, 7, 108, 2, 2, 2083, 2108, 7, 110, 2, 2, 2084, 2108, 7, 111, 2, 2, 2085, 2108, 7, 112, 2, 2, 2086, 2108, 7, 113, 2, 2, 2087, 2088, 7, 104, 2, 2, 2088, 2108, 7, 104, 2, 2, 2089, 2090, 7, 105, 2, 2, 2090, 2108, 7, 105, 2, 2, 2091, 2108, 7, 115, 2, 2, 2092, 2108, 7, 114, 2, 2, 2093, 2108, 7, 116, 2, 2, 2094, 2108, 7, 117, 2, 2, 2095, 2108, 7, 118, 2, 2, 2096, 2108, 7, 120, 2, 2, 2097, 2108, 7, 121, 2, 2, 2098, 2108, 7, 122, 2, 2, 2099, 2108, 7, 123, 2, 2, 2100, 2108, 7, 124, 2, 2, 2101, 2108, 7, 125, 2, 2, 2102, 2108, 7, 126, 2, 2, 2103, 2104, 7, 87, 2, 2, 2104, 2108, 7, 88, 2, 2, 2105, 2106, 7, 89, 2, 2, 2106, 2108, 7, 90, 2, 2, 2107, 2056, 3, 2, 2, 2, 2107, 2061, 3, 2, 2, 2, 2107, 2066, 3, 2, 2, 2, 2107, 2067, 3, 2, 2, 2, 2107, 2068, 3, 2, 2, 2, 2107, 2069, 3, 2, 2, 2, 2107, 2070, 3, 2, 2, 2, 2107, 2071, 3, 2, 2, 2, 2107, 2072, 3, 2, 2, 2, 2107, 2073, 3, 2, 2, 2, 2107, 2074, 3, 2, 2, 2, 2107, 2075, 3, 2, 2, 2, 2107, 2076, 3, 2, 2, 2, 2107, 2077, 3, 2, 2, 2, 2107, 2078, 3, 2, 2, 2, 2107, 2079, 3, 2, 2, 2, 2107, 2080, 3, 2, 2, 2, 2107, 2081, 3, 2, 2, 2, 2107, 2082, 3, 2, 2, 2, 2107, 2083, 3, 2, 2, 2, 2107, 2084, 3, 2, 2, 2, 2107, 2085, 3, 2, 2, 2, 2107, 2086, 3, 2, 2, 2, 2107, 2087, 3, 2, 2, 2, 2107, 2089, 3, 2, 2, 2, 2107, 2091, 3, 2, 2, 2, 2107, 2092, 3, 2, 2, 2, 2107, 2093, 3, 2, 2, 2, 2107, 2094, 3, 2, 2, 2, 2107, 2095, 3, 2, 2, 2, 2107, 2096, 3, 2, 2, 2, 2107, 2097, 3, 2, 2, 2, 2107, 2098, 3, 2, 2, 2, 2107, 2099, 3, 2, 2, 2, 2107, 2100, 3, 2, 2, 2, 2107, 2101, 3, 2, 2, 2, 2107, 2102, 3, 2, 2, 2, 2107, 2103, 3, 2, 2, 2, 2107, 2105, 3, 2, 2, 2, 2108, 381, 3, 2, 2, 2, 2109, 2110, 9, 24, 2, 2, 2110, 383, 3, 2, 2, 2, 308, 385, 392, 401, 405, 414, 417, 421, 429, 436, 439, 444, 449, 455, 463, 465, 474, 478, 482, 485, 489, 492, 499, 503, 506, 509, 512, 518, 522, 526, 540, 544, 550, 557, 563, 567, 571, 573, 581, 586, 599, 606, 618, 628, 633, 637, 644, 647, 655, 659, 662, 669, 676, 680, 685, 689, 692, 697, 712, 719, 727, 735, 744, 751, 758, 766, 774, 782, 790, 798, 806, 815, 823, 832, 840, 848, 850, 853, 859, 865, 871, 878, 887, 895, 899, 906, 908, 928, 932, 938, 943, 947, 950, 957, 964, 968, 977, 988, 998, 1003, 1010, 1013, 1018, 1023, 1044, 1049, 1052, 1063, 1069, 1074, 1077, 1082, 1085, 1092, 1101, 1106, 1109, 1113, 1117, 1121, 1126, 1131, 1137, 1143, 1149, 1155, 1161, 1164, 1170, 1174, 1178, 1181, 1189, 1191, 1197, 1200, 1203, 1206, 1210, 1214, 1220, 1230, 1236, 1242, 1247, 1252, 1256, 1269, 1275, 1279, 1285, 1290, 1305, 1309, 1314, 1319, 1324, 1330, 1333, 1342, 1346, 1351, 1355, 1361, 1368, 1385, 1387, 1394, 1399, 1406, 1410, 1414, 1422, 1428, 1434, 1438, 1440, 1444, 1449, 1453, 1456, 1459, 1462, 1467, 1471, 1474, 1478, 1481, 1483, 1488, 1495, 1501, 1505, 1511, 1517, 1520, 1522, 1528, 1532, 1538, 1545, 1549, 1551, 1555, 1561, 1573, 1577, 1579, 1583, 1588, 1591, 1598, 1602, 1607, 1609, 1613, 1616, 1619, 1623, 1628, 1635, 1642, 1647, 1651, 1655, 1660, 1664, 1670, 1672, 1678, 1683, 1689, 1693, 1695, 1698, 1702, 1706, 1708, 1710, 1713, 1725, 1727, 1730, 1733, 1736, 1745, 1752, 1757, 1760, 1763, 1765, 1768, 1771, 1775, 1780, 1793, 1798, 1802, 1806, 1811, 1816, 1820, 1823, 1827, 1838, 1842, 1849, 1854, 1858, 1864, 1868, 1872, 1881, 1894, 1899, 1906, 1910, 1913, 1916, 1919, 1923, 1928, 1935, 1939, 1943, 1949, 1954, 1958, 1964, 1970, 1973, 1976, 1992, 2000, 2009, 2014, 2017, 2021, 2025, 2030, 2036, 2041, 2045, 2054, 2059, 2064, 2107] \ 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 index c6a2ac3a2..2d90e02c0 100644 --- a/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Parser.java +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14Parser.java @@ -1,14438 +1,22886 @@ -// Generated from /home/syu/workspace/MSCCD_ALL/Project/grammarDefinations/CPP14/CPP14Parser.g4 by ANTLR 4.8 +// Generated from CPP14Parser.g4 by ANTLR 4.9.3 package com.itsaky.androidide.lexers.cpp; -import org.antlr.v4.runtime.atn.*; + +import org.antlr.v4.runtime.FailedPredicateException; +import org.antlr.v4.runtime.InputMismatchException; +import org.antlr.v4.runtime.NoViableAltException; +import org.antlr.v4.runtime.Parser; +import org.antlr.v4.runtime.ParserRuleContext; +import org.antlr.v4.runtime.RecognitionException; +import org.antlr.v4.runtime.RuleContext; +import org.antlr.v4.runtime.RuntimeMetaData; +import org.antlr.v4.runtime.Token; +import org.antlr.v4.runtime.TokenStream; +import org.antlr.v4.runtime.Vocabulary; +import org.antlr.v4.runtime.VocabularyImpl; +import org.antlr.v4.runtime.atn.ATN; +import org.antlr.v4.runtime.atn.ATNDeserializer; +import org.antlr.v4.runtime.atn.ParserATNSimulator; +import org.antlr.v4.runtime.atn.PredictionContextCache; 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 org.antlr.v4.runtime.tree.ParseTreeListener; +import org.antlr.v4.runtime.tree.ParseTreeVisitor; +import org.antlr.v4.runtime.tree.TerminalNode; + 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 + 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_simpleTypeLengthModifier = 77, + RULE_simpleTypeSignednessModifier = 78, + RULE_simpleTypeSpecifier = 79, + RULE_theTypeName = 80, + RULE_decltypeSpecifier = 81, + RULE_elaboratedTypeSpecifier = 82, + RULE_enumName = 83, + RULE_enumSpecifier = 84, + RULE_enumHead = 85, + RULE_opaqueEnumDeclaration = 86, + RULE_enumkey = 87, + RULE_enumbase = 88, + RULE_enumeratorList = 89, + RULE_enumeratorDefinition = 90, + RULE_enumerator = 91, + RULE_namespaceName = 92, + RULE_originalNamespaceName = 93, + RULE_namespaceDefinition = 94, + RULE_namespaceAlias = 95, + RULE_namespaceAliasDefinition = 96, + RULE_qualifiednamespacespecifier = 97, + RULE_usingDeclaration = 98, + RULE_usingDirective = 99, + RULE_asmDefinition = 100, + RULE_linkageSpecification = 101, + RULE_attributeSpecifierSeq = 102, + RULE_attributeSpecifier = 103, + RULE_alignmentspecifier = 104, + RULE_attributeList = 105, + RULE_attribute = 106, + RULE_attributeNamespace = 107, + RULE_attributeArgumentClause = 108, + RULE_balancedTokenSeq = 109, + RULE_balancedtoken = 110, + RULE_initDeclaratorList = 111, + RULE_initDeclarator = 112, + RULE_declarator = 113, + RULE_pointerDeclarator = 114, + RULE_noPointerDeclarator = 115, + RULE_parametersAndQualifiers = 116, + RULE_trailingReturnType = 117, + RULE_pointerOperator = 118, + RULE_cvqualifierseq = 119, + RULE_cvQualifier = 120, + RULE_refqualifier = 121, + RULE_declaratorid = 122, + RULE_theTypeId = 123, + RULE_abstractDeclarator = 124, + RULE_pointerAbstractDeclarator = 125, + RULE_noPointerAbstractDeclarator = 126, + RULE_abstractPackDeclarator = 127, + RULE_noPointerAbstractPackDeclarator = 128, + RULE_parameterDeclarationClause = 129, + RULE_parameterDeclarationList = 130, + RULE_parameterDeclaration = 131, + RULE_functionDefinition = 132, + RULE_functionBody = 133, + RULE_initializer = 134, + RULE_braceOrEqualInitializer = 135, + RULE_initializerClause = 136, + RULE_initializerList = 137, + RULE_bracedInitList = 138, + RULE_className = 139, + RULE_classSpecifier = 140, + RULE_classHead = 141, + RULE_classHeadName = 142, + RULE_classVirtSpecifier = 143, + RULE_classKey = 144, + RULE_memberSpecification = 145, + RULE_memberdeclaration = 146, + RULE_memberDeclaratorList = 147, + RULE_memberDeclarator = 148, + RULE_virtualSpecifierSeq = 149, + RULE_virtualSpecifier = 150, + RULE_pureSpecifier = 151, + RULE_baseClause = 152, + RULE_baseSpecifierList = 153, + RULE_baseSpecifier = 154, + RULE_classOrDeclType = 155, + RULE_baseTypeSpecifier = 156, + RULE_accessSpecifier = 157, + RULE_conversionFunctionId = 158, + RULE_conversionTypeId = 159, + RULE_conversionDeclarator = 160, + RULE_constructorInitializer = 161, + RULE_memInitializerList = 162, + RULE_memInitializer = 163, + RULE_meminitializerid = 164, + RULE_operatorFunctionId = 165, + RULE_literalOperatorId = 166, + RULE_templateDeclaration = 167, + RULE_templateparameterList = 168, + RULE_templateParameter = 169, + RULE_typeParameter = 170, + RULE_simpleTemplateId = 171, + RULE_templateId = 172, + RULE_templateName = 173, + RULE_templateArgumentList = 174, + RULE_templateArgument = 175, + RULE_typeNameSpecifier = 176, + RULE_explicitInstantiation = 177, + RULE_explicitSpecialization = 178, + RULE_tryBlock = 179, + RULE_functionTryBlock = 180, + RULE_handlerSeq = 181, + RULE_handler = 182, + RULE_exceptionDeclaration = 183, + RULE_throwExpression = 184, + RULE_exceptionSpecification = 185, + RULE_dynamicExceptionSpecification = 186, + RULE_typeIdList = 187, + RULE_noeExceptSpecification = 188, + RULE_theOperator = 189, + RULE_literal = 190; + public static final String[] ruleNames = makeRuleNames(); + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated public static final String[] tokenNames; + public static final String _serializedATN = + "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u0093\u0840\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\4\u00bf\t\u00bf" + + "\4\u00c0\t\u00c0\3\2\5\2\u0182\n\2\3\2\3\2\3\3\6\3\u0187\n\3\r\3\16\3" + + "\u0188\3\3\3\3\3\3\3\3\3\3\3\3\3\3\5\3\u0192\n\3\3\4\3\4\5\4\u0196\n\4" + + "\3\5\3\5\3\5\3\5\3\5\3\5\3\5\5\5\u019f\n\5\3\5\5\5\u01a2\n\5\3\6\3\6\5" + + "\6\u01a6\n\6\3\6\3\6\3\7\3\7\3\7\3\7\5\7\u01ae\n\7\3\7\3\7\3\7\3\7\3\7" + + "\5\7\u01b5\n\7\3\7\5\7\u01b8\n\7\3\7\7\7\u01bb\n\7\f\7\16\7\u01be\13\7" + + "\3\b\3\b\5\b\u01c2\n\b\3\b\3\b\3\t\3\t\5\t\u01c8\n\t\3\t\3\t\3\n\3\n\3" + + "\n\3\n\5\n\u01d0\n\n\5\n\u01d2\n\n\3\13\3\13\3\f\3\f\3\f\7\f\u01d9\n\f" + + "\f\f\16\f\u01dc\13\f\3\f\5\f\u01df\n\f\3\r\3\r\5\r\u01e3\n\r\3\16\5\16" + + "\u01e6\n\16\3\16\3\16\5\16\u01ea\n\16\3\17\5\17\u01ed\n\17\3\17\3\17\3" + + "\17\3\20\3\20\5\20\u01f4\n\20\3\20\3\20\5\20\u01f8\n\20\3\20\5\20\u01fb" + + "\n\20\3\20\5\20\u01fe\n\20\3\20\5\20\u0201\n\20\3\21\3\21\3\21\3\21\5" + + "\21\u0207\n\21\3\21\3\21\5\21\u020b\n\21\3\21\3\21\5\21\u020f\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\u021d\n\21" + + "\3\21\3\21\5\21\u0221\n\21\3\21\3\21\3\21\3\21\5\21\u0227\n\21\3\21\3" + + "\21\3\21\3\21\3\21\5\21\u022e\n\21\3\21\3\21\3\21\3\21\5\21\u0234\n\21" + + "\3\21\3\21\5\21\u0238\n\21\3\21\3\21\7\21\u023c\n\21\f\21\16\21\u023f" + + "\13\21\3\22\3\22\3\23\3\23\3\24\5\24\u0246\n\24\3\24\3\24\3\24\5\24\u024b" + + "\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\u0258" + + "\n\24\3\25\3\25\3\25\3\25\3\25\5\25\u025f\n\25\3\25\3\25\3\25\3\25\3\25" + + "\3\25\3\25\3\25\3\25\3\25\5\25\u026b\n\25\3\25\3\25\3\25\3\25\3\25\3\25" + + "\3\25\3\25\5\25\u0275\n\25\3\26\3\26\3\27\5\27\u027a\n\27\3\27\3\27\5" + + "\27\u027e\n\27\3\27\3\27\3\27\3\27\3\27\5\27\u0285\n\27\3\27\5\27\u0288" + + "\n\27\3\30\3\30\3\30\3\30\3\31\3\31\5\31\u0290\n\31\3\32\3\32\5\32\u0294" + + "\n\32\3\32\5\32\u0297\n\32\3\33\3\33\3\33\3\33\3\33\5\33\u029e\n\33\3" + + "\33\3\33\3\33\3\33\3\33\5\33\u02a5\n\33\7\33\u02a7\n\33\f\33\16\33\u02aa" + + "\13\33\3\34\3\34\5\34\u02ae\n\34\3\34\3\34\5\34\u02b2\n\34\3\35\5\35\u02b5" + + "\n\35\3\35\3\35\3\35\5\35\u02ba\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\u02c9\n\37\3 \3 \3 \7 \u02ce\n \f" + + " \16 \u02d1\13 \3!\3!\3!\7!\u02d6\n!\f!\16!\u02d9\13!\3\"\3\"\3\"\7\"" + + "\u02de\n\"\f\"\16\"\u02e1\13\"\3#\3#\3#\3#\7#\u02e7\n#\f#\16#\u02ea\13" + + "#\3$\3$\3$\3$\5$\u02f0\n$\3%\3%\3%\7%\u02f5\n%\f%\16%\u02f8\13%\3&\3&" + + "\3&\7&\u02fd\n&\f&\16&\u0300\13&\3\'\3\'\3\'\7\'\u0305\n\'\f\'\16\'\u0308" + + "\13\'\3(\3(\3(\7(\u030d\n(\f(\16(\u0310\13(\3)\3)\3)\7)\u0315\n)\f)\16" + + ")\u0318\13)\3*\3*\3*\7*\u031d\n*\f*\16*\u0320\13*\3+\3+\3+\7+\u0325\n" + + "+\f+\16+\u0328\13+\3,\3,\3,\3,\3,\3,\5,\u0330\n,\3-\3-\3-\3-\3-\3-\5-" + + "\u0338\n-\3.\3.\3/\3/\3/\7/\u033f\n/\f/\16/\u0342\13/\3\60\3\60\3\61\3" + + "\61\3\61\5\61\u0349\n\61\3\61\3\61\3\61\3\61\3\61\3\61\5\61\u0351\n\61" + + "\5\61\u0353\n\61\3\62\5\62\u0356\n\62\3\62\3\62\3\62\3\62\5\62\u035c\n" + + "\62\3\62\3\62\3\62\3\63\5\63\u0362\n\63\3\63\3\63\3\64\3\64\5\64\u0368" + + "\n\64\3\64\3\64\3\65\6\65\u036d\n\65\r\65\16\65\u036e\3\66\3\66\3\66\3" + + "\66\3\66\3\66\3\66\5\66\u0378\n\66\3\66\3\66\3\66\3\66\3\66\3\66\5\66" + + "\u0380\n\66\3\67\3\67\5\67\u0384\n\67\3\67\3\67\3\67\3\67\3\67\5\67\u038b" + + "\n\67\5\67\u038d\n\67\38\38\38\38\38\38\38\38\38\38\38\38\38\38\38\38" + + "\38\38\58\u03a1\n8\38\38\58\u03a5\n8\38\38\38\38\58\u03ab\n8\38\38\38" + + "\58\u03b0\n8\39\39\59\u03b4\n9\3:\5:\u03b7\n:\3:\3:\3:\3;\3;\5;\u03be" + + "\n;\3<\3<\3<\3<\3<\5<\u03c5\n<\3<\3<\5<\u03c9\n<\3<\3<\3=\3=\3>\6>\u03d0" + + "\n>\r>\16>\u03d1\3?\3?\3?\3?\3?\3?\3?\3?\3?\5?\u03dd\n?\3@\3@\3@\3@\3" + + "@\3@\3@\3@\5@\u03e7\n@\3A\3A\3A\5A\u03ec\nA\3A\3A\3A\3A\3B\5B\u03f3\n" + + "B\3B\5B\u03f6\nB\3B\3B\3B\5B\u03fb\nB\3B\3B\3B\5B\u0400\nB\3C\3C\3C\3" + + "C\3C\3C\3C\3C\3D\3D\3E\3E\3E\3F\3F\3F\3F\3F\3F\5F\u0415\nF\3G\6G\u0418" + + "\nG\rG\16G\u0419\3G\5G\u041d\nG\3H\3H\3I\3I\3J\3J\3K\3K\3K\5K\u0428\n" + + "K\3L\3L\3L\3L\5L\u042e\nL\3M\6M\u0431\nM\rM\16M\u0432\3M\5M\u0436\nM\3" + + "N\6N\u0439\nN\rN\16N\u043a\3N\5N\u043e\nN\3O\3O\3P\3P\3Q\5Q\u0445\nQ\3" + + "Q\3Q\3Q\3Q\3Q\3Q\3Q\5Q\u044e\nQ\3Q\6Q\u0451\nQ\rQ\16Q\u0452\3Q\5Q\u0456" + + "\nQ\3Q\3Q\5Q\u045a\nQ\3Q\3Q\5Q\u045e\nQ\3Q\3Q\5Q\u0462\nQ\3Q\3Q\3Q\5Q" + + "\u0467\nQ\3Q\7Q\u046a\nQ\fQ\16Q\u046d\13Q\3Q\3Q\3Q\5Q\u0472\nQ\3Q\3Q\3" + + "Q\3Q\5Q\u0478\nQ\3R\3R\3R\3R\5R\u047e\nR\3S\3S\3S\3S\5S\u0484\nS\3S\3" + + "S\3T\3T\5T\u048a\nT\3T\5T\u048d\nT\3T\3T\3T\3T\5T\u0493\nT\3T\3T\5T\u0497" + + "\nT\3T\3T\5T\u049b\nT\3T\5T\u049e\nT\3U\3U\3V\3V\3V\3V\5V\u04a6\nV\5V" + + "\u04a8\nV\3V\3V\3W\3W\5W\u04ae\nW\3W\5W\u04b1\nW\3W\5W\u04b4\nW\3W\5W" + + "\u04b7\nW\3X\3X\5X\u04bb\nX\3X\3X\5X\u04bf\nX\3X\3X\3Y\3Y\5Y\u04c5\nY" + + "\3Z\3Z\3Z\3[\3[\3[\7[\u04cd\n[\f[\16[\u04d0\13[\3\\\3\\\3\\\5\\\u04d5" + + "\n\\\3]\3]\3^\3^\5^\u04db\n^\3_\3_\3`\5`\u04e0\n`\3`\3`\3`\5`\u04e5\n" + + "`\3`\3`\5`\u04e9\n`\3`\3`\3a\3a\3b\3b\3b\3b\3b\3b\3c\5c\u04f6\nc\3c\3" + + "c\3d\3d\5d\u04fc\nd\3d\3d\5d\u0500\nd\3d\3d\3d\3e\5e\u0506\ne\3e\3e\3" + + "e\5e\u050b\ne\3e\3e\3e\3f\3f\3f\3f\3f\3f\3g\3g\3g\3g\5g\u051a\ng\3g\3" + + "g\5g\u051e\ng\3h\6h\u0521\nh\rh\16h\u0522\3i\3i\3i\5i\u0528\ni\3i\3i\3" + + "i\5i\u052d\ni\3j\3j\3j\3j\5j\u0533\nj\3j\5j\u0536\nj\3j\3j\3k\3k\3k\7" + + "k\u053d\nk\fk\16k\u0540\13k\3k\5k\u0543\nk\3l\3l\3l\5l\u0548\nl\3l\3l" + + "\5l\u054c\nl\3m\3m\3n\3n\5n\u0552\nn\3n\3n\3o\6o\u0557\no\ro\16o\u0558" + + "\3p\3p\3p\3p\3p\3p\3p\3p\3p\3p\3p\3p\3p\6p\u0568\np\rp\16p\u0569\5p\u056c" + + "\np\3q\3q\3q\7q\u0571\nq\fq\16q\u0574\13q\3r\3r\5r\u0578\nr\3s\3s\3s\3" + + "s\3s\5s\u057f\ns\3t\3t\5t\u0583\nt\7t\u0585\nt\ft\16t\u0588\13t\3t\3t" + + "\3u\3u\3u\5u\u058f\nu\3u\3u\3u\3u\5u\u0595\nu\3u\3u\3u\3u\5u\u059b\nu" + + "\3u\3u\5u\u059f\nu\5u\u05a1\nu\7u\u05a3\nu\fu\16u\u05a6\13u\3v\3v\5v\u05aa" + + "\nv\3v\3v\5v\u05ae\nv\3v\5v\u05b1\nv\3v\5v\u05b4\nv\3v\5v\u05b7\nv\3w" + + "\3w\3w\5w\u05bc\nw\3x\3x\5x\u05c0\nx\3x\5x\u05c3\nx\3x\3x\5x\u05c7\nx" + + "\3x\5x\u05ca\nx\5x\u05cc\nx\3y\6y\u05cf\ny\ry\16y\u05d0\3z\3z\3{\3{\3" + + "|\5|\u05d8\n|\3|\3|\3}\3}\5}\u05de\n}\3~\3~\5~\u05e2\n~\3~\3~\3~\3~\5" + + "~\u05e8\n~\3\177\3\177\6\177\u05ec\n\177\r\177\16\177\u05ed\3\177\5\177" + + "\u05f1\n\177\5\177\u05f3\n\177\3\u0080\3\u0080\3\u0080\3\u0080\5\u0080" + + "\u05f9\n\u0080\3\u0080\3\u0080\5\u0080\u05fd\n\u0080\3\u0080\3\u0080\3" + + "\u0080\3\u0080\5\u0080\u0603\n\u0080\3\u0080\3\u0080\3\u0080\3\u0080\3" + + "\u0080\5\u0080\u060a\n\u0080\3\u0080\3\u0080\5\u0080\u060e\n\u0080\5\u0080" + + "\u0610\n\u0080\7\u0080\u0612\n\u0080\f\u0080\16\u0080\u0615\13\u0080\3" + + "\u0081\7\u0081\u0618\n\u0081\f\u0081\16\u0081\u061b\13\u0081\3\u0081\3" + + "\u0081\3\u0082\3\u0082\3\u0082\3\u0082\3\u0082\3\u0082\3\u0082\5\u0082" + + "\u0626\n\u0082\3\u0082\3\u0082\5\u0082\u062a\n\u0082\5\u0082\u062c\n\u0082" + + "\7\u0082\u062e\n\u0082\f\u0082\16\u0082\u0631\13\u0082\3\u0083\3\u0083" + + "\5\u0083\u0635\n\u0083\3\u0083\5\u0083\u0638\n\u0083\3\u0084\3\u0084\3" + + "\u0084\7\u0084\u063d\n\u0084\f\u0084\16\u0084\u0640\13\u0084\3\u0085\5" + + "\u0085\u0643\n\u0085\3\u0085\3\u0085\3\u0085\5\u0085\u0648\n\u0085\5\u0085" + + "\u064a\n\u0085\3\u0085\3\u0085\5\u0085\u064e\n\u0085\3\u0086\5\u0086\u0651" + + "\n\u0086\3\u0086\5\u0086\u0654\n\u0086\3\u0086\3\u0086\5\u0086\u0658\n" + + "\u0086\3\u0086\3\u0086\3\u0087\5\u0087\u065d\n\u0087\3\u0087\3\u0087\3" + + "\u0087\3\u0087\3\u0087\5\u0087\u0664\n\u0087\3\u0088\3\u0088\3\u0088\3" + + "\u0088\3\u0088\5\u0088\u066b\n\u0088\3\u0089\3\u0089\3\u0089\5\u0089\u0670" + + "\n\u0089\3\u008a\3\u008a\5\u008a\u0674\n\u008a\3\u008b\3\u008b\5\u008b" + + "\u0678\n\u008b\3\u008b\3\u008b\3\u008b\5\u008b\u067d\n\u008b\7\u008b\u067f" + + "\n\u008b\f\u008b\16\u008b\u0682\13\u008b\3\u008c\3\u008c\3\u008c\5\u008c" + + "\u0687\n\u008c\5\u008c\u0689\n\u008c\3\u008c\3\u008c\3\u008d\3\u008d\5" + + "\u008d\u068f\n\u008d\3\u008e\3\u008e\3\u008e\5\u008e\u0694\n\u008e\3\u008e" + + "\3\u008e\3\u008f\3\u008f\5\u008f\u069a\n\u008f\3\u008f\3\u008f\5\u008f" + + "\u069e\n\u008f\5\u008f\u06a0\n\u008f\3\u008f\5\u008f\u06a3\n\u008f\3\u008f" + + "\3\u008f\5\u008f\u06a7\n\u008f\3\u008f\3\u008f\5\u008f\u06ab\n\u008f\5" + + "\u008f\u06ad\n\u008f\5\u008f\u06af\n\u008f\3\u0090\5\u0090\u06b2\n\u0090" + + "\3\u0090\3\u0090\3\u0091\3\u0091\3\u0092\3\u0092\3\u0093\3\u0093\3\u0093" + + "\3\u0093\6\u0093\u06be\n\u0093\r\u0093\16\u0093\u06bf\3\u0094\5\u0094" + + "\u06c3\n\u0094\3\u0094\5\u0094\u06c6\n\u0094\3\u0094\5\u0094\u06c9\n\u0094" + + "\3\u0094\3\u0094\3\u0094\3\u0094\3\u0094\3\u0094\3\u0094\5\u0094\u06d2" + + "\n\u0094\3\u0095\3\u0095\3\u0095\7\u0095\u06d7\n\u0095\f\u0095\16\u0095" + + "\u06da\13\u0095\3\u0096\3\u0096\5\u0096\u06de\n\u0096\3\u0096\5\u0096" + + "\u06e1\n\u0096\3\u0096\5\u0096\u06e4\n\u0096\5\u0096\u06e6\n\u0096\3\u0096" + + "\5\u0096\u06e9\n\u0096\3\u0096\5\u0096\u06ec\n\u0096\3\u0096\3\u0096\5" + + "\u0096\u06f0\n\u0096\3\u0097\6\u0097\u06f3\n\u0097\r\u0097\16\u0097\u06f4" + + "\3\u0098\3\u0098\3\u0099\3\u0099\3\u0099\3\u0099\3\u009a\3\u009a\3\u009a" + + "\3\u009b\3\u009b\5\u009b\u0702\n\u009b\3\u009b\3\u009b\3\u009b\5\u009b" + + "\u0707\n\u009b\7\u009b\u0709\n\u009b\f\u009b\16\u009b\u070c\13\u009b\3" + + "\u009c\5\u009c\u070f\n\u009c\3\u009c\3\u009c\3\u009c\5\u009c\u0714\n\u009c" + + "\3\u009c\3\u009c\3\u009c\5\u009c\u0719\n\u009c\3\u009c\3\u009c\5\u009c" + + "\u071d\n\u009c\3\u009d\5\u009d\u0720\n\u009d\3\u009d\3\u009d\5\u009d\u0724" + + "\n\u009d\3\u009e\3\u009e\3\u009f\3\u009f\3\u00a0\3\u00a0\3\u00a0\3\u00a1" + + "\3\u00a1\5\u00a1\u072f\n\u00a1\3\u00a2\3\u00a2\5\u00a2\u0733\n\u00a2\3" + + "\u00a3\3\u00a3\3\u00a3\3\u00a4\3\u00a4\5\u00a4\u073a\n\u00a4\3\u00a4\3" + + "\u00a4\3\u00a4\5\u00a4\u073f\n\u00a4\7\u00a4\u0741\n\u00a4\f\u00a4\16" + + "\u00a4\u0744\13\u00a4\3\u00a5\3\u00a5\3\u00a5\5\u00a5\u0749\n\u00a5\3" + + "\u00a5\3\u00a5\5\u00a5\u074d\n\u00a5\3\u00a6\3\u00a6\5\u00a6\u0751\n\u00a6" + + "\3\u00a7\3\u00a7\3\u00a7\3\u00a8\3\u00a8\3\u00a8\3\u00a8\5\u00a8\u075a" + + "\n\u00a8\3\u00a9\3\u00a9\3\u00a9\3\u00a9\3\u00a9\3\u00a9\3\u00aa\3\u00aa" + + "\3\u00aa\7\u00aa\u0765\n\u00aa\f\u00aa\16\u00aa\u0768\13\u00aa\3\u00ab" + + "\3\u00ab\5\u00ab\u076c\n\u00ab\3\u00ac\3\u00ac\3\u00ac\3\u00ac\3\u00ac" + + "\5\u00ac\u0773\n\u00ac\3\u00ac\3\u00ac\5\u00ac\u0777\n\u00ac\3\u00ac\5" + + "\u00ac\u077a\n\u00ac\3\u00ac\5\u00ac\u077d\n\u00ac\3\u00ac\5\u00ac\u0780" + + "\n\u00ac\3\u00ac\3\u00ac\5\u00ac\u0784\n\u00ac\3\u00ad\3\u00ad\3\u00ad" + + "\5\u00ad\u0789\n\u00ad\3\u00ad\3\u00ad\3\u00ae\3\u00ae\3\u00ae\5\u00ae" + + "\u0790\n\u00ae\3\u00ae\3\u00ae\5\u00ae\u0794\n\u00ae\3\u00ae\3\u00ae\5" + + "\u00ae\u0798\n\u00ae\3\u00af\3\u00af\3\u00b0\3\u00b0\5\u00b0\u079e\n\u00b0" + + "\3\u00b0\3\u00b0\3\u00b0\5\u00b0\u07a3\n\u00b0\7\u00b0\u07a5\n\u00b0\f" + + "\u00b0\16\u00b0\u07a8\13\u00b0\3\u00b1\3\u00b1\3\u00b1\5\u00b1\u07ad\n" + + "\u00b1\3\u00b2\3\u00b2\3\u00b2\3\u00b2\5\u00b2\u07b3\n\u00b2\3\u00b2\5" + + "\u00b2\u07b6\n\u00b2\3\u00b3\5\u00b3\u07b9\n\u00b3\3\u00b3\3\u00b3\3\u00b3" + + "\3\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b4\3\u00b5\3\u00b5\3\u00b5\3\u00b5" + + "\3\u00b6\3\u00b6\5\u00b6\u07c9\n\u00b6\3\u00b6\3\u00b6\3\u00b6\3\u00b7" + + "\6\u00b7\u07cf\n\u00b7\r\u00b7\16\u00b7\u07d0\3\u00b8\3\u00b8\3\u00b8" + + "\3\u00b8\3\u00b8\3\u00b8\3\u00b9\5\u00b9\u07da\n\u00b9\3\u00b9\3\u00b9" + + "\3\u00b9\5\u00b9\u07df\n\u00b9\3\u00b9\5\u00b9\u07e2\n\u00b9\3\u00ba\3" + + "\u00ba\5\u00ba\u07e6\n\u00ba\3\u00bb\3\u00bb\5\u00bb\u07ea\n\u00bb\3\u00bc" + + "\3\u00bc\3\u00bc\5\u00bc\u07ef\n\u00bc\3\u00bc\3\u00bc\3\u00bd\3\u00bd" + + "\5\u00bd\u07f5\n\u00bd\3\u00bd\3\u00bd\3\u00bd\5\u00bd\u07fa\n\u00bd\7" + + "\u00bd\u07fc\n\u00bd\f\u00bd\16\u00bd\u07ff\13\u00bd\3\u00be\3\u00be\3" + + "\u00be\3\u00be\3\u00be\3\u00be\5\u00be\u0807\n\u00be\3\u00bf\3\u00bf\3" + + "\u00bf\5\u00bf\u080c\n\u00bf\3\u00bf\3\u00bf\3\u00bf\5\u00bf\u0811\n\u00bf" + + "\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf" + + "\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf" + + "\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf" + + "\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf" + + "\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00bf\5\u00bf\u083c\n\u00bf\3\u00c0" + + "\3\u00c0\3\u00c0\3\u0419\b\f \64\u00e8\u00fe\u0102\u00c1\2\4\6\b\n\f\16" + + "\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bd" + + "fhjlnprtvxz|~\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\u017c\u017e\2\31\4\2" + + "ccgg\6\2\32\32!!<>\4\2??PP\4\2\27\27DD\3\2W\\\4\2ccxx\4\2\30\30TT\3\2\35\36\4\2((\67" + + "\67\3\28:\3\2\3\t\2\u0929\2\u0181\3\2\2\2\4\u0191\3\2\2\2\6\u0195\3\2" + + "\2\2\b\u01a1\3\2\2\2\n\u01a3\3\2\2\2\f\u01a9\3\2\2\2\16\u01bf\3\2\2\2" + + "\20\u01c5\3\2\2\2\22\u01d1\3\2\2\2\24\u01d3\3\2\2\2\26\u01d5\3\2\2\2\30" + + "\u01e2\3\2\2\2\32\u01e9\3\2\2\2\34\u01ec\3\2\2\2\36\u01f1\3\2\2\2 \u0220" + + "\3\2\2\2\"\u0240\3\2\2\2$\u0242\3\2\2\2&\u0257\3\2\2\2(\u0274\3\2\2\2" + + "*\u0276\3\2\2\2,\u0279\3\2\2\2.\u0289\3\2\2\2\60\u028d\3\2\2\2\62\u0296" + + "\3\2\2\2\64\u0298\3\2\2\2\66\u02b1\3\2\2\28\u02b4\3\2\2\2:\u02bd\3\2\2" + + "\2<\u02c8\3\2\2\2>\u02ca\3\2\2\2@\u02d2\3\2\2\2B\u02da\3\2\2\2D\u02e2" + + "\3\2\2\2F\u02ef\3\2\2\2H\u02f1\3\2\2\2J\u02f9\3\2\2\2L\u0301\3\2\2\2N" + + "\u0309\3\2\2\2P\u0311\3\2\2\2R\u0319\3\2\2\2T\u0321\3\2\2\2V\u0329\3\2" + + "\2\2X\u0337\3\2\2\2Z\u0339\3\2\2\2\\\u033b\3\2\2\2^\u0343\3\2\2\2`\u0352" + + "\3\2\2\2b\u0355\3\2\2\2d\u0361\3\2\2\2f\u0365\3\2\2\2h\u036c\3\2\2\2j" + + "\u037f\3\2\2\2l\u038c\3\2\2\2n\u03af\3\2\2\2p\u03b3\3\2\2\2r\u03b6\3\2" + + "\2\2t\u03bd\3\2\2\2v\u03c8\3\2\2\2x\u03cc\3\2\2\2z\u03cf\3\2\2\2|\u03dc" + + "\3\2\2\2~\u03e6\3\2\2\2\u0080\u03e8\3\2\2\2\u0082\u03ff\3\2\2\2\u0084" + + "\u0401\3\2\2\2\u0086\u0409\3\2\2\2\u0088\u040b\3\2\2\2\u008a\u0414\3\2" + + "\2\2\u008c\u0417\3\2\2\2\u008e\u041e\3\2\2\2\u0090\u0420\3\2\2\2\u0092" + + "\u0422\3\2\2\2\u0094\u0427\3\2\2\2\u0096\u042d\3\2\2\2\u0098\u0430\3\2" + + "\2\2\u009a\u0438\3\2\2\2\u009c\u043f\3\2\2\2\u009e\u0441\3\2\2\2\u00a0" + + "\u0477\3\2\2\2\u00a2\u047d\3\2\2\2\u00a4\u047f\3\2\2\2\u00a6\u049d\3\2" + + "\2\2\u00a8\u049f\3\2\2\2\u00aa\u04a1\3\2\2\2\u00ac\u04ab\3\2\2\2\u00ae" + + "\u04b8\3\2\2\2\u00b0\u04c2\3\2\2\2\u00b2\u04c6\3\2\2\2\u00b4\u04c9\3\2" + + "\2\2\u00b6\u04d1\3\2\2\2\u00b8\u04d6\3\2\2\2\u00ba\u04da\3\2\2\2\u00bc" + + "\u04dc\3\2\2\2\u00be\u04df\3\2\2\2\u00c0\u04ec\3\2\2\2\u00c2\u04ee\3\2" + + "\2\2\u00c4\u04f5\3\2\2\2\u00c6\u04f9\3\2\2\2\u00c8\u0505\3\2\2\2\u00ca" + + "\u050f\3\2\2\2\u00cc\u0515\3\2\2\2\u00ce\u0520\3\2\2\2\u00d0\u052c\3\2" + + "\2\2\u00d2\u052e\3\2\2\2\u00d4\u0539\3\2\2\2\u00d6\u0547\3\2\2\2\u00d8" + + "\u054d\3\2\2\2\u00da\u054f\3\2\2\2\u00dc\u0556\3\2\2\2\u00de\u056b\3\2" + + "\2\2\u00e0\u056d\3\2\2\2\u00e2\u0575\3\2\2\2\u00e4\u057e\3\2\2\2\u00e6" + + "\u0586\3\2\2\2\u00e8\u0594\3\2\2\2\u00ea\u05a7\3\2\2\2\u00ec\u05b8\3\2" + + "\2\2\u00ee\u05cb\3\2\2\2\u00f0\u05ce\3\2\2\2\u00f2\u05d2\3\2\2\2\u00f4" + + "\u05d4\3\2\2\2\u00f6\u05d7\3\2\2\2\u00f8\u05db\3\2\2\2\u00fa\u05e7\3\2" + + "\2\2\u00fc\u05f2\3\2\2\2\u00fe\u0602\3\2\2\2\u0100\u0619\3\2\2\2\u0102" + + "\u061e\3\2\2\2\u0104\u0632\3\2\2\2\u0106\u0639\3\2\2\2\u0108\u0642\3\2" + + "\2\2\u010a\u0650\3\2\2\2\u010c\u0663\3\2\2\2\u010e\u066a\3\2\2\2\u0110" + + "\u066f\3\2\2\2\u0112\u0673\3\2\2\2\u0114\u0675\3\2\2\2\u0116\u0683\3\2" + + "\2\2\u0118\u068e\3\2\2\2\u011a\u0690\3\2\2\2\u011c\u06ae\3\2\2\2\u011e" + + "\u06b1\3\2\2\2\u0120\u06b5\3\2\2\2\u0122\u06b7\3\2\2\2\u0124\u06bd\3\2" + + "\2\2\u0126\u06d1\3\2\2\2\u0128\u06d3\3\2\2\2\u012a\u06ef\3\2\2\2\u012c" + + "\u06f2\3\2\2\2\u012e\u06f6\3\2\2\2\u0130\u06f8\3\2\2\2\u0132\u06fc\3\2" + + "\2\2\u0134\u06ff\3\2\2\2\u0136\u070e\3\2\2\2\u0138\u0723\3\2\2\2\u013a" + + "\u0725\3\2\2\2\u013c\u0727\3\2\2\2\u013e\u0729\3\2\2\2\u0140\u072c\3\2" + + "\2\2\u0142\u0730\3\2\2\2\u0144\u0734\3\2\2\2\u0146\u0737\3\2\2\2\u0148" + + "\u0745\3\2\2\2\u014a\u0750\3\2\2\2\u014c\u0752\3\2\2\2\u014e\u0755\3\2" + + "\2\2\u0150\u075b\3\2\2\2\u0152\u0761\3\2\2\2\u0154\u076b\3\2\2\2\u0156" + + "\u0776\3\2\2\2\u0158\u0785\3\2\2\2\u015a\u0797\3\2\2\2\u015c\u0799\3\2" + + "\2\2\u015e\u079b\3\2\2\2\u0160\u07ac\3\2\2\2\u0162\u07ae\3\2\2\2\u0164" + + "\u07b8\3\2\2\2\u0166\u07bd\3\2\2\2\u0168\u07c2\3\2\2\2\u016a\u07c6\3\2" + + "\2\2\u016c\u07ce\3\2\2\2\u016e\u07d2\3\2\2\2\u0170\u07e1\3\2\2\2\u0172" + + "\u07e3\3\2\2\2\u0174\u07e9\3\2\2\2\u0176\u07eb\3\2\2\2\u0178\u07f2\3\2" + + "\2\2\u017a\u0806\3\2\2\2\u017c\u083b\3\2\2\2\u017e\u083d\3\2\2\2\u0180" + + "\u0182\5z>\2\u0181\u0180\3\2\2\2\u0181\u0182\3\2\2\2\u0182\u0183\3\2\2" + + "\2\u0183\u0184\7\2\2\3\u0184\3\3\2\2\2\u0185\u0187\5\u017e\u00c0\2\u0186" + + "\u0185\3\2\2\2\u0187\u0188\3\2\2\2\u0188\u0186\3\2\2\2\u0188\u0189\3\2" + + "\2\2\u0189\u0192\3\2\2\2\u018a\u0192\7G\2\2\u018b\u018c\7W\2\2\u018c\u018d" + + "\5\\/\2\u018d\u018e\7X\2\2\u018e\u0192\3\2\2\2\u018f\u0192\5\6\4\2\u0190" + + "\u0192\5\16\b\2\u0191\u0186\3\2\2\2\u0191\u018a\3\2\2\2\u0191\u018b\3" + + "\2\2\2\u0191\u018f\3\2\2\2\u0191\u0190\3\2\2\2\u0192\5\3\2\2\2\u0193\u0196" + + "\5\b\5\2\u0194\u0196\5\n\6\2\u0195\u0193\3\2\2\2\u0195\u0194\3\2\2\2\u0196" + + "\7\3\2\2\2\u0197\u01a2\7\u0086\2\2\u0198\u01a2\5\u014c\u00a7\2\u0199\u01a2" + + "\5\u013e\u00a0\2\u019a\u01a2\5\u014e\u00a8\2\u019b\u019e\7e\2\2\u019c" + + "\u019f\5\u0118\u008d\2\u019d\u019f\5\u00a4S\2\u019e\u019c\3\2\2\2\u019e" + + "\u019d\3\2\2\2\u019f\u01a2\3\2\2\2\u01a0\u01a2\5\u015a\u00ae\2\u01a1\u0197" + + "\3\2\2\2\u01a1\u0198\3\2\2\2\u01a1\u0199\3\2\2\2\u01a1\u019a\3\2\2\2\u01a1" + + "\u019b\3\2\2\2\u01a1\u01a0\3\2\2\2\u01a2\t\3\2\2\2\u01a3\u01a5\5\f\7\2" + + "\u01a4\u01a6\7F\2\2\u01a5\u01a4\3\2\2\2\u01a5\u01a6\3\2\2\2\u01a6\u01a7" + + "\3\2\2\2\u01a7\u01a8\5\b\5\2\u01a8\13\3\2\2\2\u01a9\u01ad\b\7\1\2\u01aa" + + "\u01ae\5\u00a2R\2\u01ab\u01ae\5\u00ba^\2\u01ac\u01ae\5\u00a4S\2\u01ad" + + "\u01aa\3\2\2\2\u01ad\u01ab\3\2\2\2\u01ad\u01ac\3\2\2\2\u01ad\u01ae\3\2" + + "\2\2\u01ae\u01af\3\2\2\2\u01af\u01b0\7\u0081\2\2\u01b0\u01bc\3\2\2\2\u01b1" + + "\u01b7\f\3\2\2\u01b2\u01b8\7\u0086\2\2\u01b3\u01b5\7F\2\2\u01b4\u01b3" + + "\3\2\2\2\u01b4\u01b5\3\2\2\2\u01b5\u01b6\3\2\2\2\u01b6\u01b8\5\u0158\u00ad" + + "\2\u01b7\u01b2\3\2\2\2\u01b7\u01b4\3\2\2\2\u01b8\u01b9\3\2\2\2\u01b9\u01bb" + + "\7\u0081\2\2\u01ba\u01b1\3\2\2\2\u01bb\u01be\3\2\2\2\u01bc\u01ba\3\2\2" + + "\2\u01bc\u01bd\3\2\2\2\u01bd\r\3\2\2\2\u01be\u01bc\3\2\2\2\u01bf\u01c1" + + "\5\20\t\2\u01c0\u01c2\5\36\20\2\u01c1\u01c0\3\2\2\2\u01c1\u01c2\3\2\2" + + "\2\u01c2\u01c3\3\2\2\2\u01c3\u01c4\5f\64\2\u01c4\17\3\2\2\2\u01c5\u01c7" + + "\7Y\2\2\u01c6\u01c8\5\22\n\2\u01c7\u01c6\3\2\2\2\u01c7\u01c8\3\2\2\2\u01c8" + + "\u01c9\3\2\2\2\u01c9\u01ca\7Z\2\2\u01ca\21\3\2\2\2\u01cb\u01d2\5\26\f" + + "\2\u01cc\u01cf\5\24\13\2\u01cd\u01ce\7|\2\2\u01ce\u01d0\5\26\f\2\u01cf" + + "\u01cd\3\2\2\2\u01cf\u01d0\3\2\2\2\u01d0\u01d2\3\2\2\2\u01d1\u01cb\3\2" + + "\2\2\u01d1\u01cc\3\2\2\2\u01d2\23\3\2\2\2\u01d3\u01d4\t\2\2\2\u01d4\25" + + "\3\2\2\2\u01d5\u01da\5\30\r\2\u01d6\u01d7\7|\2\2\u01d7\u01d9\5\30\r\2" + + "\u01d8\u01d6\3\2\2\2\u01d9\u01dc\3\2\2\2\u01da\u01d8\3\2\2\2\u01da\u01db" + + "\3\2\2\2\u01db\u01de\3\2\2\2\u01dc\u01da\3\2\2\2\u01dd\u01df\7\u0085\2" + + "\2\u01de\u01dd\3\2\2\2\u01de\u01df\3\2\2\2\u01df\27\3\2\2\2\u01e0\u01e3" + + "\5\32\16\2\u01e1\u01e3\5\34\17\2\u01e2\u01e0\3\2\2\2\u01e2\u01e1\3\2\2" + + "\2\u01e3\31\3\2\2\2\u01e4\u01e6\7c\2\2\u01e5\u01e4\3\2\2\2\u01e5\u01e6" + + "\3\2\2\2\u01e6\u01e7\3\2\2\2\u01e7\u01ea\7\u0086\2\2\u01e8\u01ea\7G\2" + + "\2\u01e9\u01e5\3\2\2\2\u01e9\u01e8\3\2\2\2\u01ea\33\3\2\2\2\u01eb\u01ed" + + "\7c\2\2\u01ec\u01eb\3\2\2\2\u01ec\u01ed\3\2\2\2\u01ed\u01ee\3\2\2\2\u01ee" + + "\u01ef\7\u0086\2\2\u01ef\u01f0\5\u010e\u0088\2\u01f0\35\3\2\2\2\u01f1" + + "\u01f3\7W\2\2\u01f2\u01f4\5\u0104\u0083\2\u01f3\u01f2\3\2\2\2\u01f3\u01f4" + + "\3\2\2\2\u01f4\u01f5\3\2\2\2\u01f5\u01f7\7X\2\2\u01f6\u01f8\7\61\2\2\u01f7" + + "\u01f6\3\2\2\2\u01f7\u01f8\3\2\2\2\u01f8\u01fa\3\2\2\2\u01f9\u01fb\5\u0174" + + "\u00bb\2\u01fa\u01f9\3\2\2\2\u01fa\u01fb\3\2\2\2\u01fb\u01fd\3\2\2\2\u01fc" + + "\u01fe\5\u00ceh\2\u01fd\u01fc\3\2\2\2\u01fd\u01fe\3\2\2\2\u01fe\u0200" + + "\3\2\2\2\u01ff\u0201\5\u00ecw\2\u0200\u01ff\3\2\2\2\u0200\u0201\3\2\2" + + "\2\u0201\37\3\2\2\2\u0202\u0203\b\21\1\2\u0203\u0221\5\4\3\2\u0204\u0207" + + "\5\u00a0Q\2\u0205\u0207\5\u0162\u00b2\2\u0206\u0204\3\2\2\2\u0206\u0205" + + "\3\2\2\2\u0207\u020e\3\2\2\2\u0208\u020a\7W\2\2\u0209\u020b\5$\23\2\u020a" + + "\u0209\3\2\2\2\u020a\u020b\3\2\2\2\u020b\u020c\3\2\2\2\u020c\u020f\7X" + + "\2\2\u020d\u020f\5\u0116\u008c\2\u020e\u0208\3\2\2\2\u020e\u020d\3\2\2" + + "\2\u020f\u0221\3\2\2\2\u0210\u0211\t\3\2\2\u0211\u0212\7h\2\2\u0212\u0213" + + "\5\u00f8}\2\u0213\u0214\7i\2\2\u0214\u0215\7W\2\2\u0215\u0216\5\\/\2\u0216" + + "\u0217\7X\2\2\u0217\u0221\3\2\2\2\u0218\u0219\5\"\22\2\u0219\u021c\7W" + + "\2\2\u021a\u021d\5\\/\2\u021b\u021d\5\u00f8}\2\u021c\u021a\3\2\2\2\u021c" + + "\u021b\3\2\2\2\u021d\u021e\3\2\2\2\u021e\u021f\7X\2\2\u021f\u0221\3\2" + + "\2\2\u0220\u0202\3\2\2\2\u0220\u0206\3\2\2\2\u0220\u0210\3\2\2\2\u0220" + + "\u0218\3\2\2\2\u0221\u023d\3\2\2\2\u0222\u0223\f\t\2\2\u0223\u0226\7Y" + + "\2\2\u0224\u0227\5\\/\2\u0225\u0227\5\u0116\u008c\2\u0226\u0224\3\2\2" + + "\2\u0226\u0225\3\2\2\2\u0227\u0228\3\2\2\2\u0228\u0229\7Z\2\2\u0229\u023c" + + "\3\2\2\2\u022a\u022b\f\b\2\2\u022b\u022d\7W\2\2\u022c\u022e\5$\23\2\u022d" + + "\u022c\3\2\2\2\u022d\u022e\3\2\2\2\u022e\u022f\3\2\2\2\u022f\u023c\7X" + + "\2\2\u0230\u0231\f\6\2\2\u0231\u0237\t\4\2\2\u0232\u0234\7F\2\2\u0233" + + "\u0232\3\2\2\2\u0233\u0234\3\2\2\2\u0234\u0235\3\2\2\2\u0235\u0238\5\6" + + "\4\2\u0236\u0238\5&\24\2\u0237\u0233\3\2\2\2\u0237\u0236\3\2\2\2\u0238" + + "\u023c\3\2\2\2\u0239\u023a\f\5\2\2\u023a\u023c\t\5\2\2\u023b\u0222\3\2" + + "\2\2\u023b\u022a\3\2\2\2\u023b\u0230\3\2\2\2\u023b\u0239\3\2\2\2\u023c" + + "\u023f\3\2\2\2\u023d\u023b\3\2\2\2\u023d\u023e\3\2\2\2\u023e!\3\2\2\2" + + "\u023f\u023d\3\2\2\2\u0240\u0241\7M\2\2\u0241#\3\2\2\2\u0242\u0243\5\u0114" + + "\u008b\2\u0243%\3\2\2\2\u0244\u0246\5\f\7\2\u0245\u0244\3\2\2\2\u0245" + + "\u0246\3\2\2\2\u0246\u024a\3\2\2\2\u0247\u0248\5\u00a2R\2\u0248\u0249" + + "\7\u0081\2\2\u0249\u024b\3\2\2\2\u024a\u0247\3\2\2\2\u024a\u024b\3\2\2" + + "\2\u024b\u024c\3\2\2\2\u024c\u024d\7e\2\2\u024d\u0258\5\u00a2R\2\u024e" + + "\u024f\5\f\7\2\u024f\u0250\7F\2\2\u0250\u0251\5\u0158\u00ad\2\u0251\u0252" + + "\7\u0081\2\2\u0252\u0253\7e\2\2\u0253\u0254\5\u00a2R\2\u0254\u0258\3\2" + + "\2\2\u0255\u0256\7e\2\2\u0256\u0258\5\u00a4S\2\u0257\u0245\3\2\2\2\u0257" + + "\u024e\3\2\2\2\u0257\u0255\3\2\2\2\u0258\'\3\2\2\2\u0259\u0275\5 \21\2" + + "\u025a\u025f\7z\2\2\u025b\u025f\7{\2\2\u025c\u025f\5*\26\2\u025d\u025f" + + "\7@\2\2\u025e\u025a\3\2\2\2\u025e\u025b\3\2\2\2\u025e\u025c\3\2\2\2\u025e" + + "\u025d\3\2\2\2\u025f\u0260\3\2\2\2\u0260\u0275\5(\25\2\u0261\u026a\7@" + + "\2\2\u0262\u0263\7W\2\2\u0263\u0264\5\u00f8}\2\u0264\u0265\7X\2\2\u0265" + + "\u026b\3\2\2\2\u0266\u0267\7\u0085\2\2\u0267\u0268\7W\2\2\u0268\u0269" + + "\7\u0086\2\2\u0269\u026b\7X\2\2\u026a\u0262\3\2\2\2\u026a\u0266\3\2\2" + + "\2\u026b\u0275\3\2\2\2\u026c\u026d\7\r\2\2\u026d\u026e\7W\2\2\u026e\u026f" + + "\5\u00f8}\2\u026f\u0270\7X\2\2\u0270\u0275\3\2\2\2\u0271\u0275\5:\36\2" + + "\u0272\u0275\5,\27\2\u0273\u0275\58\35\2\u0274\u0259\3\2\2\2\u0274\u025e" + + "\3\2\2\2\u0274\u0261\3\2\2\2\u0274\u026c\3\2\2\2\u0274\u0271\3\2\2\2\u0274" + + "\u0272\3\2\2\2\u0274\u0273\3\2\2\2\u0275)\3\2\2\2\u0276\u0277\t\6\2\2" + + "\u0277+\3\2\2\2\u0278\u027a\7\u0081\2\2\u0279\u0278\3\2\2\2\u0279\u027a" + + "\3\2\2\2\u027a\u027b\3\2\2\2\u027b\u027d\7\63\2\2\u027c\u027e\5.\30\2" + + "\u027d\u027c\3\2\2\2\u027d\u027e\3\2\2\2\u027e\u0284\3\2\2\2\u027f\u0285" + + "\5\60\31\2\u0280\u0281\7W\2\2\u0281\u0282\5\u00f8}\2\u0282\u0283\7X\2" + + "\2\u0283\u0285\3\2\2\2\u0284\u027f\3\2\2\2\u0284\u0280\3\2\2\2\u0285\u0287" + + "\3\2\2\2\u0286\u0288\5\66\34\2\u0287\u0286\3\2\2\2\u0287\u0288\3\2\2\2" + + "\u0288-\3\2\2\2\u0289\u028a\7W\2\2\u028a\u028b\5$\23\2\u028b\u028c\7X" + + "\2\2\u028c/\3\2\2\2\u028d\u028f\5\u0098M\2\u028e\u0290\5\62\32\2\u028f" + + "\u028e\3\2\2\2\u028f\u0290\3\2\2\2\u0290\61\3\2\2\2\u0291\u0293\5\u00ee" + + "x\2\u0292\u0294\5\62\32\2\u0293\u0292\3\2\2\2\u0293\u0294\3\2\2\2\u0294" + + "\u0297\3\2\2\2\u0295\u0297\5\64\33\2\u0296\u0291\3\2\2\2\u0296\u0295\3" + + "\2\2\2\u0297\63\3\2\2\2\u0298\u0299\b\33\1\2\u0299\u029a\7Y\2\2\u029a" + + "\u029b\5\\/\2\u029b\u029d\7Z\2\2\u029c\u029e\5\u00ceh\2\u029d\u029c\3" + + "\2\2\2\u029d\u029e\3\2\2\2\u029e\u02a8\3\2\2\2\u029f\u02a0\f\3\2\2\u02a0" + + "\u02a1\7Y\2\2\u02a1\u02a2\5^\60\2\u02a2\u02a4\7Z\2\2\u02a3\u02a5\5\u00ce" + + "h\2\u02a4\u02a3\3\2\2\2\u02a4\u02a5\3\2\2\2\u02a5\u02a7\3\2\2\2\u02a6" + + "\u029f\3\2\2\2\u02a7\u02aa\3\2\2\2\u02a8\u02a6\3\2\2\2\u02a8\u02a9\3\2" + + "\2\2\u02a9\65\3\2\2\2\u02aa\u02a8\3\2\2\2\u02ab\u02ad\7W\2\2\u02ac\u02ae" + + "\5$\23\2\u02ad\u02ac\3\2\2\2\u02ad\u02ae\3\2\2\2\u02ae\u02af\3\2\2\2\u02af" + + "\u02b2\7X\2\2\u02b0\u02b2\5\u0116\u008c\2\u02b1\u02ab\3\2\2\2\u02b1\u02b0" + + "\3\2\2\2\u02b2\67\3\2\2\2\u02b3\u02b5\7\u0081\2\2\u02b4\u02b3\3\2\2\2" + + "\u02b4\u02b5\3\2\2\2\u02b5\u02b6\3\2\2\2\u02b6\u02b9\7\36\2\2\u02b7\u02b8" + + "\7Y\2\2\u02b8\u02ba\7Z\2\2\u02b9\u02b7\3\2\2\2\u02b9\u02ba\3\2\2\2\u02ba" + + "\u02bb\3\2\2\2\u02bb\u02bc\5<\37\2\u02bc9\3\2\2\2\u02bd\u02be\7\64\2\2" + + "\u02be\u02bf\7W\2\2\u02bf\u02c0\5\\/\2\u02c0\u02c1\7X\2\2\u02c1;\3\2\2" + + "\2\u02c2\u02c9\5(\25\2\u02c3\u02c4\7W\2\2\u02c4\u02c5\5\u00f8}\2\u02c5" + + "\u02c6\7X\2\2\u02c6\u02c7\5<\37\2\u02c7\u02c9\3\2\2\2\u02c8\u02c2\3\2" + + "\2\2\u02c8\u02c3\3\2\2\2\u02c9=\3\2\2\2\u02ca\u02cf\5<\37\2\u02cb\u02cc" + + "\t\7\2\2\u02cc\u02ce\5<\37\2\u02cd\u02cb\3\2\2\2\u02ce\u02d1\3\2\2\2\u02cf" + + "\u02cd\3\2\2\2\u02cf\u02d0\3\2\2\2\u02d0?\3\2\2\2\u02d1\u02cf\3\2\2\2" + + "\u02d2\u02d7\5> \2\u02d3\u02d4\t\b\2\2\u02d4\u02d6\5> \2\u02d5\u02d3\3" + + "\2\2\2\u02d6\u02d9\3\2\2\2\u02d7\u02d5\3\2\2\2\u02d7\u02d8\3\2\2\2\u02d8" + + "A\3\2\2\2\u02d9\u02d7\3\2\2\2\u02da\u02df\5@!\2\u02db\u02dc\t\t\2\2\u02dc" + + "\u02de\5@!\2\u02dd\u02db\3\2\2\2\u02de\u02e1\3\2\2\2\u02df\u02dd\3\2\2" + + "\2\u02df\u02e0\3\2\2\2\u02e0C\3\2\2\2\u02e1\u02df\3\2\2\2\u02e2\u02e8" + + "\5B\"\2\u02e3\u02e4\5F$\2\u02e4\u02e5\5B\"\2\u02e5\u02e7\3\2\2\2\u02e6" + + "\u02e3\3\2\2\2\u02e7\u02ea\3\2\2\2\u02e8\u02e6\3\2\2\2\u02e8\u02e9\3\2" + + "\2\2\u02e9E\3\2\2\2\u02ea\u02e8\3\2\2\2\u02eb\u02ec\7i\2\2\u02ec\u02f0" + + "\7i\2\2\u02ed\u02ee\7h\2\2\u02ee\u02f0\7h\2\2\u02ef\u02eb\3\2\2\2\u02ef" + + "\u02ed\3\2\2\2\u02f0G\3\2\2\2\u02f1\u02f6\5D#\2\u02f2\u02f3\t\n\2\2\u02f3" + + "\u02f5\5D#\2\u02f4\u02f2\3\2\2\2\u02f5\u02f8\3\2\2\2\u02f6\u02f4\3\2\2" + + "\2\u02f6\u02f7\3\2\2\2\u02f7I\3\2\2\2\u02f8\u02f6\3\2\2\2\u02f9\u02fe" + + "\5H%\2\u02fa\u02fb\t\13\2\2\u02fb\u02fd\5H%\2\u02fc\u02fa\3\2\2\2\u02fd" + + "\u0300\3\2\2\2\u02fe\u02fc\3\2\2\2\u02fe\u02ff\3\2\2\2\u02ffK\3\2\2\2" + + "\u0300\u02fe\3\2\2\2\u0301\u0306\5J&\2\u0302\u0303\7c\2\2\u0303\u0305" + + "\5J&\2\u0304\u0302\3\2\2\2\u0305\u0308\3\2\2\2\u0306\u0304\3\2\2\2\u0306" + + "\u0307\3\2\2\2\u0307M\3\2\2\2\u0308\u0306\3\2\2\2\u0309\u030e\5L\'\2\u030a" + + "\u030b\7b\2\2\u030b\u030d\5L\'\2\u030c\u030a\3\2\2\2\u030d\u0310\3\2\2" + + "\2\u030e\u030c\3\2\2\2\u030e\u030f\3\2\2\2\u030fO\3\2\2\2\u0310\u030e" + + "\3\2\2\2\u0311\u0316\5N(\2\u0312\u0313\7d\2\2\u0313\u0315\5N(\2\u0314" + + "\u0312\3\2\2\2\u0315\u0318\3\2\2\2\u0316\u0314\3\2\2\2\u0316\u0317\3\2" + + "\2\2\u0317Q\3\2\2\2\u0318\u0316\3\2\2\2\u0319\u031e\5P)\2\u031a\u031b" + + "\7x\2\2\u031b\u031d\5P)\2\u031c\u031a\3\2\2\2\u031d\u0320\3\2\2\2\u031e" + + "\u031c\3\2\2\2\u031e\u031f\3\2\2\2\u031fS\3\2\2\2\u0320\u031e\3\2\2\2" + + "\u0321\u0326\5R*\2\u0322\u0323\7y\2\2\u0323\u0325\5R*\2\u0324\u0322\3" + + "\2\2\2\u0325\u0328\3\2\2\2\u0326\u0324\3\2\2\2\u0326\u0327\3\2\2\2\u0327" + + "U\3\2\2\2\u0328\u0326\3\2\2\2\u0329\u032f\5T+\2\u032a\u032b\7\177\2\2" + + "\u032b\u032c\5\\/\2\u032c\u032d\7\u0080\2\2\u032d\u032e\5X-\2\u032e\u0330" + + "\3\2\2\2\u032f\u032a\3\2\2\2\u032f\u0330\3\2\2\2\u0330W\3\2\2\2\u0331" + + "\u0338\5V,\2\u0332\u0333\5T+\2\u0333\u0334\5Z.\2\u0334\u0335\5\u0112\u008a" + + "\2\u0335\u0338\3\2\2\2\u0336\u0338\5\u0172\u00ba\2\u0337\u0331\3\2\2\2" + + "\u0337\u0332\3\2\2\2\u0337\u0336\3\2\2\2\u0338Y\3\2\2\2\u0339\u033a\t" + + "\f\2\2\u033a[\3\2\2\2\u033b\u0340\5X-\2\u033c\u033d\7|\2\2\u033d\u033f" + + "\5X-\2\u033e\u033c\3\2\2\2\u033f\u0342\3\2\2\2\u0340\u033e\3\2\2\2\u0340" + + "\u0341\3\2\2\2\u0341]\3\2\2\2\u0342\u0340\3\2\2\2\u0343\u0344\5V,\2\u0344" + + "_\3\2\2\2\u0345\u0353\5b\62\2\u0346\u0353\5x=\2\u0347\u0349\5\u00ceh\2" + + "\u0348\u0347\3\2\2\2\u0348\u0349\3\2\2\2\u0349\u0350\3\2\2\2\u034a\u0351" + + "\5d\63\2\u034b\u0351\5f\64\2\u034c\u0351\5j\66\2\u034d\u0351\5n8\2\u034e" + + "\u0351\5v<\2\u034f\u0351\5\u0168\u00b5\2\u0350\u034a\3\2\2\2\u0350\u034b" + + "\3\2\2\2\u0350\u034c\3\2\2\2\u0350\u034d\3\2\2\2\u0350\u034e\3\2\2\2\u0350" + + "\u034f\3\2\2\2\u0351\u0353\3\2\2\2\u0352\u0345\3\2\2\2\u0352\u0346\3\2" + + "\2\2\u0352\u0348\3\2\2\2\u0353a\3\2\2\2\u0354\u0356\5\u00ceh\2\u0355\u0354" + + "\3\2\2\2\u0355\u0356\3\2\2\2\u0356\u035b\3\2\2\2\u0357\u035c\7\u0086\2" + + "\2\u0358\u0359\7\22\2\2\u0359\u035c\5^\60\2\u035a\u035c\7\35\2\2\u035b" + + "\u0357\3\2\2\2\u035b\u0358\3\2\2\2\u035b\u035a\3\2\2\2\u035c\u035d\3\2" + + "\2\2\u035d\u035e\7\u0080\2\2\u035e\u035f\5`\61\2\u035fc\3\2\2\2\u0360" + + "\u0362\5\\/\2\u0361\u0360\3\2\2\2\u0361\u0362\3\2\2\2\u0362\u0363\3\2" + + "\2\2\u0363\u0364\7\u0082\2\2\u0364e\3\2\2\2\u0365\u0367\7[\2\2\u0366\u0368" + + "\5h\65\2\u0367\u0366\3\2\2\2\u0367\u0368\3\2\2\2\u0368\u0369\3\2\2\2\u0369" + + "\u036a\7\\\2\2\u036ag\3\2\2\2\u036b\u036d\5`\61\2\u036c\u036b\3\2\2\2" + + "\u036d\u036e\3\2\2\2\u036e\u036c\3\2\2\2\u036e\u036f\3\2\2\2\u036fi\3" + + "\2\2\2\u0370\u0371\7-\2\2\u0371\u0372\7W\2\2\u0372\u0373\5l\67\2\u0373" + + "\u0374\7X\2\2\u0374\u0377\5`\61\2\u0375\u0376\7\"\2\2\u0376\u0378\5`\61" + + "\2\u0377\u0375\3\2\2\2\u0377\u0378\3\2\2\2\u0378\u0380\3\2\2\2\u0379\u037a" + + "\7E\2\2\u037a\u037b\7W\2\2\u037b\u037c\5l\67\2\u037c\u037d\7X\2\2\u037d" + + "\u037e\5`\61\2\u037e\u0380\3\2\2\2\u037f\u0370\3\2\2\2\u037f\u0379\3\2" + + "\2\2\u0380k\3\2\2\2\u0381\u038d\5\\/\2\u0382\u0384\5\u00ceh\2\u0383\u0382" + + "\3\2\2\2\u0383\u0384\3\2\2\2\u0384\u0385\3\2\2\2\u0385\u0386\5\u008cG" + + "\2\u0386\u038a\5\u00e4s\2\u0387\u0388\7g\2\2\u0388\u038b\5\u0112\u008a" + + "\2\u0389\u038b\5\u0116\u008c\2\u038a\u0387\3\2\2\2\u038a\u0389\3\2\2\2" + + "\u038b\u038d\3\2\2\2\u038c\u0381\3\2\2\2\u038c\u0383\3\2\2\2\u038dm\3" + + "\2\2\2\u038e\u038f\7V\2\2\u038f\u0390\7W\2\2\u0390\u0391\5l\67\2\u0391" + + "\u0392\7X\2\2\u0392\u0393\5`\61\2\u0393\u03b0\3\2\2\2\u0394\u0395\7\37" + + "\2\2\u0395\u0396\5`\61\2\u0396\u0397\7V\2\2\u0397\u0398\7W\2\2\u0398\u0399" + + "\5\\/\2\u0399\u039a\7X\2\2\u039a\u039b\7\u0082\2\2\u039b\u03b0\3\2\2\2" + + "\u039c\u039d\7*\2\2\u039d\u03aa\7W\2\2\u039e\u03a0\5p9\2\u039f\u03a1\5" + + "l\67\2\u03a0\u039f\3\2\2\2\u03a0\u03a1\3\2\2\2\u03a1\u03a2\3\2\2\2\u03a2" + + "\u03a4\7\u0082\2\2\u03a3\u03a5\5\\/\2\u03a4\u03a3\3\2\2\2\u03a4\u03a5" + + "\3\2\2\2\u03a5\u03ab\3\2\2\2\u03a6\u03a7\5r:\2\u03a7\u03a8\7\u0080\2\2" + + "\u03a8\u03a9\5t;\2\u03a9\u03ab\3\2\2\2\u03aa\u039e\3\2\2\2\u03aa\u03a6" + + "\3\2\2\2\u03ab\u03ac\3\2\2\2\u03ac\u03ad\7X\2\2\u03ad\u03ae\5`\61\2\u03ae" + + "\u03b0\3\2\2\2\u03af\u038e\3\2\2\2\u03af\u0394\3\2\2\2\u03af\u039c\3\2" + + "\2\2\u03b0o\3\2\2\2\u03b1\u03b4\5d\63\2\u03b2\u03b4\5\u0082B\2\u03b3\u03b1" + + "\3\2\2\2\u03b3\u03b2\3\2\2\2\u03b4q\3\2\2\2\u03b5\u03b7\5\u00ceh\2\u03b6" + + "\u03b5\3\2\2\2\u03b6\u03b7\3\2\2\2\u03b7\u03b8\3\2\2\2\u03b8\u03b9\5\u008c" + + "G\2\u03b9\u03ba\5\u00e4s\2\u03bas\3\2\2\2\u03bb\u03be\5\\/\2\u03bc\u03be" + + "\5\u0116\u008c\2\u03bd\u03bb\3\2\2\2\u03bd\u03bc\3\2\2\2\u03beu\3\2\2" + + "\2\u03bf\u03c9\7\21\2\2\u03c0\u03c9\7\33\2\2\u03c1\u03c4\7=\2\2\u03c2" + + "\u03c5\5\\/\2\u03c3\u03c5\5\u0116\u008c\2\u03c4\u03c2\3\2\2\2\u03c4\u03c3" + + "\3\2\2\2\u03c4\u03c5\3\2\2\2\u03c5\u03c9\3\2\2\2\u03c6\u03c7\7,\2\2\u03c7" + + "\u03c9\7\u0086\2\2\u03c8\u03bf\3\2\2\2\u03c8\u03c0\3\2\2\2\u03c8\u03c1" + + "\3\2\2\2\u03c8\u03c6\3\2\2\2\u03c9\u03ca\3\2\2\2\u03ca\u03cb\7\u0082\2" + + "\2\u03cbw\3\2\2\2\u03cc\u03cd\5~@\2\u03cdy\3\2\2\2\u03ce\u03d0\5|?\2\u03cf" + + "\u03ce\3\2\2\2\u03d0\u03d1\3\2\2\2\u03d1\u03cf\3\2\2\2\u03d1\u03d2\3\2" + + "\2\2\u03d2{\3\2\2\2\u03d3\u03dd\5~@\2\u03d4\u03dd\5\u010a\u0086\2\u03d5" + + "\u03dd\5\u0150\u00a9\2\u03d6\u03dd\5\u0164\u00b3\2\u03d7\u03dd\5\u0166" + + "\u00b4\2\u03d8\u03dd\5\u00ccg\2\u03d9\u03dd\5\u00be`\2\u03da\u03dd\5\u0086" + + "D\2\u03db\u03dd\5\u0088E\2\u03dc\u03d3\3\2\2\2\u03dc\u03d4\3\2\2\2\u03dc" + + "\u03d5\3\2\2\2\u03dc\u03d6\3\2\2\2\u03dc\u03d7\3\2\2\2\u03dc\u03d8\3\2" + + "\2\2\u03dc\u03d9\3\2\2\2\u03dc\u03da\3\2\2\2\u03dc\u03db\3\2\2\2\u03dd" + + "}\3\2\2\2\u03de\u03e7\5\u0082B\2\u03df\u03e7\5\u00caf\2\u03e0\u03e7\5" + + "\u00c2b\2\u03e1\u03e7\5\u00c6d\2\u03e2\u03e7\5\u00c8e\2\u03e3\u03e7\5" + + "\u0084C\2\u03e4\u03e7\5\u0080A\2\u03e5\u03e7\5\u00aeX\2\u03e6\u03de\3" + + "\2\2\2\u03e6\u03df\3\2\2\2\u03e6\u03e0\3\2\2\2\u03e6\u03e1\3\2\2\2\u03e6" + + "\u03e2\3\2\2\2\u03e6\u03e3\3\2\2\2\u03e6\u03e4\3\2\2\2\u03e6\u03e5\3\2" + + "\2\2\u03e7\177\3\2\2\2\u03e8\u03e9\7Q\2\2\u03e9\u03eb\7\u0086\2\2\u03ea" + + "\u03ec\5\u00ceh\2\u03eb\u03ea\3\2\2\2\u03eb\u03ec\3\2\2\2\u03ec\u03ed" + + "\3\2\2\2\u03ed\u03ee\7g\2\2\u03ee\u03ef\5\u00f8}\2\u03ef\u03f0\7\u0082" + + "\2\2\u03f0\u0081\3\2\2\2\u03f1\u03f3\5\u008cG\2\u03f2\u03f1\3\2\2\2\u03f2" + + "\u03f3\3\2\2\2\u03f3\u03f5\3\2\2\2\u03f4\u03f6\5\u00e0q\2\u03f5\u03f4" + + "\3\2\2\2\u03f5\u03f6\3\2\2\2\u03f6\u03f7\3\2\2\2\u03f7\u0400\7\u0082\2" + + "\2\u03f8\u03fa\5\u00ceh\2\u03f9\u03fb\5\u008cG\2\u03fa\u03f9\3\2\2\2\u03fa" + + "\u03fb\3\2\2\2\u03fb\u03fc\3\2\2\2\u03fc\u03fd\5\u00e0q\2\u03fd\u03fe" + + "\7\u0082\2\2\u03fe\u0400\3\2\2\2\u03ff\u03f2\3\2\2\2\u03ff\u03f8\3\2\2" + + "\2\u0400\u0083\3\2\2\2\u0401\u0402\7B\2\2\u0402\u0403\7W\2\2\u0403\u0404" + + "\5^\60\2\u0404\u0405\7|\2\2\u0405\u0406\7\6\2\2\u0406\u0407\7X\2\2\u0407" + + "\u0408\7\u0082\2\2\u0408\u0085\3\2\2\2\u0409\u040a\7\u0082\2\2\u040a\u0087" + + "\3\2\2\2\u040b\u040c\5\u00ceh\2\u040c\u040d\7\u0082\2\2\u040d\u0089\3" + + "\2\2\2\u040e\u0415\5\u008eH\2\u040f\u0415\5\u0094K\2\u0410\u0415\5\u0090" + + "I\2\u0411\u0415\7+\2\2\u0412\u0415\7L\2\2\u0413\u0415\7\31\2\2\u0414\u040e" + + "\3\2\2\2\u0414\u040f\3\2\2\2\u0414\u0410\3\2\2\2\u0414\u0411\3\2\2\2\u0414" + + "\u0412\3\2\2\2\u0414\u0413\3\2\2\2\u0415\u008b\3\2\2\2\u0416\u0418\5\u008a" + + "F\2\u0417\u0416\3\2\2\2\u0418\u0419\3\2\2\2\u0419\u041a\3\2\2\2\u0419" + + "\u0417\3\2\2\2\u041a\u041c\3\2\2\2\u041b\u041d\5\u00ceh\2\u041c\u041b" + + "\3\2\2\2\u041c\u041d\3\2\2\2\u041d\u008d\3\2\2\2\u041e\u041f\t\r\2\2\u041f" + + "\u008f\3\2\2\2\u0420\u0421\t\16\2\2\u0421\u0091\3\2\2\2\u0422\u0423\7" + + "\u0086\2\2\u0423\u0093\3\2\2\2\u0424\u0428\5\u0096L\2\u0425\u0428\5\u011a" + + "\u008e\2\u0426\u0428\5\u00aaV\2\u0427\u0424\3\2\2\2\u0427\u0425\3\2\2" + + "\2\u0427\u0426\3\2\2\2\u0428\u0095\3\2\2\2\u0429\u042e\5\u00a0Q\2\u042a" + + "\u042e\5\u00a6T\2\u042b\u042e\5\u0162\u00b2\2\u042c\u042e\5\u00f2z\2\u042d" + + "\u0429\3\2\2\2\u042d\u042a\3\2\2\2\u042d\u042b\3\2\2\2\u042d\u042c\3\2" + + "\2\2\u042e\u0097\3\2\2\2\u042f\u0431\5\u0094K\2\u0430\u042f\3\2\2\2\u0431" + + "\u0432\3\2\2\2\u0432\u0430\3\2\2\2\u0432\u0433\3\2\2\2\u0433\u0435\3\2" + + "\2\2\u0434\u0436\5\u00ceh\2\u0435\u0434\3\2\2\2\u0435\u0436\3\2\2\2\u0436" + + "\u0099\3\2\2\2\u0437\u0439\5\u0096L\2\u0438\u0437\3\2\2\2\u0439\u043a" + + "\3\2\2\2\u043a\u0438\3\2\2\2\u043a\u043b\3\2\2\2\u043b\u043d\3\2\2\2\u043c" + + "\u043e\5\u00ceh\2\u043d\u043c\3\2\2\2\u043d\u043e\3\2\2\2\u043e\u009b" + + "\3\2\2\2\u043f\u0440\t\17\2\2\u0440\u009d\3\2\2\2\u0441\u0442\t\20\2\2" + + "\u0442\u009f\3\2\2\2\u0443\u0445\5\f\7\2\u0444\u0443\3\2\2\2\u0444\u0445" + + "\3\2\2\2\u0445\u0446\3\2\2\2\u0446\u0478\5\u00a2R\2\u0447\u0448\5\f\7" + + "\2\u0448\u0449\7F\2\2\u0449\u044a\5\u0158\u00ad\2\u044a\u0478\3\2\2\2" + + "\u044b\u0478\5\u009eP\2\u044c\u044e\5\u009eP\2\u044d\u044c\3\2\2\2\u044d" + + "\u044e\3\2\2\2\u044e\u0450\3\2\2\2\u044f\u0451\5\u009cO\2\u0450\u044f" + + "\3\2\2\2\u0451\u0452\3\2\2\2\u0452\u0450\3\2\2\2\u0452\u0453\3\2\2\2\u0453" + + "\u0478\3\2\2\2\u0454\u0456\5\u009eP\2\u0455\u0454\3\2\2\2\u0455\u0456" + + "\3\2\2\2\u0456\u0457\3\2\2\2\u0457\u0478\7\24\2\2\u0458\u045a\5\u009e" + + "P\2\u0459\u0458\3\2\2\2\u0459\u045a\3\2\2\2\u045a\u045b\3\2\2\2\u045b" + + "\u0478\7\25\2\2\u045c\u045e\5\u009eP\2\u045d\u045c\3\2\2\2\u045d\u045e" + + "\3\2\2\2\u045e\u045f\3\2\2\2\u045f\u0478\7\26\2\2\u0460\u0462\5\u009e" + + "P\2\u0461\u0460\3\2\2\2\u0461\u0462\3\2\2\2\u0462\u0463\3\2\2\2\u0463" + + "\u0478\7U\2\2\u0464\u0478\7\20\2\2\u0465\u0467\5\u009eP\2\u0466\u0465" + + "\3\2\2\2\u0466\u0467\3\2\2\2\u0467\u046b\3\2\2\2\u0468\u046a\5\u009cO" + + "\2\u0469\u0468\3\2\2\2\u046a\u046d\3\2\2\2\u046b\u0469\3\2\2\2\u046b\u046c" + + "\3\2\2\2\u046c\u046e\3\2\2\2\u046d\u046b\3\2\2\2\u046e\u0478\7/\2\2\u046f" + + "\u0478\7)\2\2\u0470\u0472\5\u009cO\2\u0471\u0470\3\2\2\2\u0471\u0472\3" + + "\2\2\2\u0472\u0473\3\2\2\2\u0473\u0478\7 \2\2\u0474\u0478\7S\2\2\u0475" + + "\u0478\7\17\2\2\u0476\u0478\5\u00a4S\2\u0477\u0444\3\2\2\2\u0477\u0447" + + "\3\2\2\2\u0477\u044b\3\2\2\2\u0477\u044d\3\2\2\2\u0477\u0455\3\2\2\2\u0477" + + "\u0459\3\2\2\2\u0477\u045d\3\2\2\2\u0477\u0461\3\2\2\2\u0477\u0464\3\2" + + "\2\2\u0477\u0466\3\2\2\2\u0477\u046f\3\2\2\2\u0477\u0471\3\2\2\2\u0477" + + "\u0474\3\2\2\2\u0477\u0475\3\2\2\2\u0477\u0476\3\2\2\2\u0478\u00a1\3\2" + + "\2\2\u0479\u047e\5\u0118\u008d\2\u047a\u047e\5\u00a8U\2\u047b\u047e\5" + + "\u0092J\2\u047c\u047e\5\u0158\u00ad\2\u047d\u0479\3\2\2\2\u047d\u047a" + + "\3\2\2\2\u047d\u047b\3\2\2\2\u047d\u047c\3\2\2\2\u047e\u00a3\3\2\2\2\u047f" + + "\u0480\7\34\2\2\u0480\u0483\7W\2\2\u0481\u0484\5\\/\2\u0482\u0484\7\17" + + "\2\2\u0483\u0481\3\2\2\2\u0483\u0482\3\2\2\2\u0484\u0485\3\2\2\2\u0485" + + "\u0486\7X\2\2\u0486\u00a5\3\2\2\2\u0487\u0496\5\u0122\u0092\2\u0488\u048a" + + "\5\u00ceh\2\u0489\u0488\3\2\2\2\u0489\u048a\3\2\2\2\u048a\u048c\3\2\2" + + "\2\u048b\u048d\5\f\7\2\u048c\u048b\3\2\2\2\u048c\u048d\3\2\2\2\u048d\u048e" + + "\3\2\2\2\u048e\u0497\7\u0086\2\2\u048f\u0497\5\u0158\u00ad\2\u0490\u0492" + + "\5\f\7\2\u0491\u0493\7F\2\2\u0492\u0491\3\2\2\2\u0492\u0493\3\2\2\2\u0493" + + "\u0494\3\2\2\2\u0494\u0495\5\u0158\u00ad\2\u0495\u0497\3\2\2\2\u0496\u0489" + + "\3\2\2\2\u0496\u048f\3\2\2\2\u0496\u0490\3\2\2\2\u0497\u049e\3\2\2\2\u0498" + + "\u049a\7#\2\2\u0499\u049b\5\f\7\2\u049a\u0499\3\2\2\2\u049a\u049b\3\2" + + "\2\2\u049b\u049c\3\2\2\2\u049c\u049e\7\u0086\2\2\u049d\u0487\3\2\2\2\u049d" + + "\u0498\3\2\2\2\u049e\u00a7\3\2\2\2\u049f\u04a0\7\u0086\2\2\u04a0\u00a9" + + "\3\2\2\2\u04a1\u04a2\5\u00acW\2\u04a2\u04a7\7[\2\2\u04a3\u04a5\5\u00b4" + + "[\2\u04a4\u04a6\7|\2\2\u04a5\u04a4\3\2\2\2\u04a5\u04a6\3\2\2\2\u04a6\u04a8" + + "\3\2\2\2\u04a7\u04a3\3\2\2\2\u04a7\u04a8\3\2\2\2\u04a8\u04a9\3\2\2\2\u04a9" + + "\u04aa\7\\\2\2\u04aa\u00ab\3\2\2\2\u04ab\u04ad\5\u00b0Y\2\u04ac\u04ae" + + "\5\u00ceh\2\u04ad\u04ac\3\2\2\2\u04ad\u04ae\3\2\2\2\u04ae\u04b3\3\2\2" + + "\2\u04af\u04b1\5\f\7\2\u04b0\u04af\3\2\2\2\u04b0\u04b1\3\2\2\2\u04b1\u04b2" + + "\3\2\2\2\u04b2\u04b4\7\u0086\2\2\u04b3\u04b0\3\2\2\2\u04b3\u04b4\3\2\2" + + "\2\u04b4\u04b6\3\2\2\2\u04b5\u04b7\5\u00b2Z\2\u04b6\u04b5\3\2\2\2\u04b6" + + "\u04b7\3\2\2\2\u04b7\u00ad\3\2\2\2\u04b8\u04ba\5\u00b0Y\2\u04b9\u04bb" + + "\5\u00ceh\2\u04ba\u04b9\3\2\2\2\u04ba\u04bb\3\2\2\2\u04bb\u04bc\3\2\2" + + "\2\u04bc\u04be\7\u0086\2\2\u04bd\u04bf\5\u00b2Z\2\u04be\u04bd\3\2\2\2" + + "\u04be\u04bf\3\2\2\2\u04bf\u04c0\3\2\2\2\u04c0\u04c1\7\u0082\2\2\u04c1" + + "\u00af\3\2\2\2\u04c2\u04c4\7#\2\2\u04c3\u04c5\t\21\2\2\u04c4\u04c3\3\2" + + "\2\2\u04c4\u04c5\3\2\2\2\u04c5\u00b1\3\2\2\2\u04c6\u04c7\7\u0080\2\2\u04c7" + + "\u04c8\5\u0098M\2\u04c8\u00b3\3\2\2\2\u04c9\u04ce\5\u00b6\\\2\u04ca\u04cb" + + "\7|\2\2\u04cb\u04cd\5\u00b6\\\2\u04cc\u04ca\3\2\2\2\u04cd\u04d0\3\2\2" + + "\2\u04ce\u04cc\3\2\2\2\u04ce\u04cf\3\2\2\2\u04cf\u00b5\3\2\2\2\u04d0\u04ce" + + "\3\2\2\2\u04d1\u04d4\5\u00b8]\2\u04d2\u04d3\7g\2\2\u04d3\u04d5\5^\60\2" + + "\u04d4\u04d2\3\2\2\2\u04d4\u04d5\3\2\2\2\u04d5\u00b7\3\2\2\2\u04d6\u04d7" + + "\7\u0086\2\2\u04d7\u00b9\3\2\2\2\u04d8\u04db\5\u00bc_\2\u04d9\u04db\5" + + "\u00c0a\2\u04da\u04d8\3\2\2\2\u04da\u04d9\3\2\2\2\u04db\u00bb\3\2\2\2" + + "\u04dc\u04dd\7\u0086\2\2\u04dd\u00bd\3\2\2\2\u04de\u04e0\7.\2\2\u04df" + + "\u04de\3\2\2\2\u04df\u04e0\3\2\2\2\u04e0\u04e1\3\2\2\2\u04e1\u04e4\7\62" + + "\2\2\u04e2\u04e5\7\u0086\2\2\u04e3\u04e5\5\u00bc_\2\u04e4\u04e2\3\2\2" + + "\2\u04e4\u04e3\3\2\2\2\u04e4\u04e5\3\2\2\2\u04e5\u04e6\3\2\2\2\u04e6\u04e8" + + "\7[\2\2\u04e7\u04e9\5z>\2\u04e8\u04e7\3\2\2\2\u04e8\u04e9\3\2\2\2\u04e9" + + "\u04ea\3\2\2\2\u04ea\u04eb\7\\\2\2\u04eb\u00bf\3\2\2\2\u04ec\u04ed\7\u0086" + + "\2\2\u04ed\u00c1\3\2\2\2\u04ee\u04ef\7\62\2\2\u04ef\u04f0\7\u0086\2\2" + + "\u04f0\u04f1\7g\2\2\u04f1\u04f2\5\u00c4c\2\u04f2\u04f3\7\u0082\2\2\u04f3" + + "\u00c3\3\2\2\2\u04f4\u04f6\5\f\7\2\u04f5\u04f4\3\2\2\2\u04f5\u04f6\3\2" + + "\2\2\u04f6\u04f7\3\2\2\2\u04f7\u04f8\5\u00ba^\2\u04f8\u00c5\3\2\2\2\u04f9" + + "\u04ff\7Q\2\2\u04fa\u04fc\7N\2\2\u04fb\u04fa\3\2\2\2\u04fb\u04fc\3\2\2" + + "\2\u04fc\u04fd\3\2\2\2\u04fd\u0500\5\f\7\2\u04fe\u0500\7\u0081\2\2\u04ff" + + "\u04fb\3\2\2\2\u04ff\u04fe\3\2\2\2\u0500\u0501\3\2\2\2\u0501\u0502\5\b" + + "\5\2\u0502\u0503\7\u0082\2\2\u0503\u00c7\3\2\2\2\u0504\u0506\5\u00ceh" + + "\2\u0505\u0504\3\2\2\2\u0505\u0506\3\2\2\2\u0506\u0507\3\2\2\2\u0507\u0508" + + "\7Q\2\2\u0508\u050a\7\62\2\2\u0509\u050b\5\f\7\2\u050a\u0509\3\2\2\2\u050a" + + "\u050b\3\2\2\2\u050b\u050c\3\2\2\2\u050c\u050d\5\u00ba^\2\u050d\u050e" + + "\7\u0082\2\2\u050e\u00c9\3\2\2\2\u050f\u0510\7\16\2\2\u0510\u0511\7W\2" + + "\2\u0511\u0512\7\6\2\2\u0512\u0513\7X\2\2\u0513\u0514\7\u0082\2\2\u0514" + + "\u00cb\3\2\2\2\u0515\u0516\7&\2\2\u0516\u051d\7\6\2\2\u0517\u0519\7[\2" + + "\2\u0518\u051a\5z>\2\u0519\u0518\3\2\2\2\u0519\u051a\3\2\2\2\u051a\u051b" + + "\3\2\2\2\u051b\u051e\7\\\2\2\u051c\u051e\5|?\2\u051d\u0517\3\2\2\2\u051d" + + "\u051c\3\2\2\2\u051e\u00cd\3\2\2\2\u051f\u0521\5\u00d0i\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" + + "\u00cf\3\2\2\2\u0524\u0525\7Y\2\2\u0525\u0527\7Y\2\2\u0526\u0528\5\u00d4" + + "k\2\u0527\u0526\3\2\2\2\u0527\u0528\3\2\2\2\u0528\u0529\3\2\2\2\u0529" + + "\u052a\7Z\2\2\u052a\u052d\7Z\2\2\u052b\u052d\5\u00d2j\2\u052c\u0524\3" + + "\2\2\2\u052c\u052b\3\2\2\2\u052d\u00d1\3\2\2\2\u052e\u052f\7\f\2\2\u052f" + + "\u0532\7W\2\2\u0530\u0533\5\u00f8}\2\u0531\u0533\5^\60\2\u0532\u0530\3" + + "\2\2\2\u0532\u0531\3\2\2\2\u0533\u0535\3\2\2\2\u0534\u0536\7\u0085\2\2" + + "\u0535\u0534\3\2\2\2\u0535\u0536\3\2\2\2\u0536\u0537\3\2\2\2\u0537\u0538" + + "\7X\2\2\u0538\u00d3\3\2\2\2\u0539\u053e\5\u00d6l\2\u053a\u053b\7|\2\2" + + "\u053b\u053d\5\u00d6l\2\u053c\u053a\3\2\2\2\u053d\u0540\3\2\2\2\u053e" + + "\u053c\3\2\2\2\u053e\u053f\3\2\2\2\u053f\u0542\3\2\2\2\u0540\u053e\3\2" + + "\2\2\u0541\u0543\7\u0085\2\2\u0542\u0541\3\2\2\2\u0542\u0543\3\2\2\2\u0543" + + "\u00d5\3\2\2\2\u0544\u0545\5\u00d8m\2\u0545\u0546\7\u0081\2\2\u0546\u0548" + + "\3\2\2\2\u0547\u0544\3\2\2\2\u0547\u0548\3\2\2\2\u0548\u0549\3\2\2\2\u0549" + + "\u054b\7\u0086\2\2\u054a\u054c\5\u00dan\2\u054b\u054a\3\2\2\2\u054b\u054c" + + "\3\2\2\2\u054c\u00d7\3\2\2\2\u054d\u054e\7\u0086\2\2\u054e\u00d9\3\2\2" + + "\2\u054f\u0551\7W\2\2\u0550\u0552\5\u00dco\2\u0551\u0550\3\2\2\2\u0551" + + "\u0552\3\2\2\2\u0552\u0553\3\2\2\2\u0553\u0554\7X\2\2\u0554\u00db\3\2" + + "\2\2\u0555\u0557\5\u00dep\2\u0556\u0555\3\2\2\2\u0557\u0558\3\2\2\2\u0558" + + "\u0556\3\2\2\2\u0558\u0559\3\2\2\2\u0559\u00dd\3\2\2\2\u055a\u055b\7W" + + "\2\2\u055b\u055c\5\u00dco\2\u055c\u055d\7X\2\2\u055d\u056c\3\2\2\2\u055e" + + "\u055f\7Y\2\2\u055f\u0560\5\u00dco\2\u0560\u0561\7Z\2\2\u0561\u056c\3" + + "\2\2\2\u0562\u0563\7[\2\2\u0563\u0564\5\u00dco\2\u0564\u0565\7\\\2\2\u0565" + + "\u056c\3\2\2\2\u0566\u0568\n\22\2\2\u0567\u0566\3\2\2\2\u0568\u0569\3" + + "\2\2\2\u0569\u0567\3\2\2\2\u0569\u056a\3\2\2\2\u056a\u056c\3\2\2\2\u056b" + + "\u055a\3\2\2\2\u056b\u055e\3\2\2\2\u056b\u0562\3\2\2\2\u056b\u0567\3\2" + + "\2\2\u056c\u00df\3\2\2\2\u056d\u0572\5\u00e2r\2\u056e\u056f\7|\2\2\u056f" + + "\u0571\5\u00e2r\2\u0570\u056e\3\2\2\2\u0571\u0574\3\2\2\2\u0572\u0570" + + "\3\2\2\2\u0572\u0573\3\2\2\2\u0573\u00e1\3\2\2\2\u0574\u0572\3\2\2\2\u0575" + + "\u0577\5\u00e4s\2\u0576\u0578\5\u010e\u0088\2\u0577\u0576\3\2\2\2\u0577" + + "\u0578\3\2\2\2\u0578\u00e3\3\2\2\2\u0579\u057f\5\u00e6t\2\u057a\u057b" + + "\5\u00e8u\2\u057b\u057c\5\u00eav\2\u057c\u057d\5\u00ecw\2\u057d\u057f" + + "\3\2\2\2\u057e\u0579\3\2\2\2\u057e\u057a\3\2\2\2\u057f\u00e5\3\2\2\2\u0580" + + "\u0582\5\u00eex\2\u0581\u0583\7\30\2\2\u0582\u0581\3\2\2\2\u0582\u0583" + + "\3\2\2\2\u0583\u0585\3\2\2\2\u0584\u0580\3\2\2\2\u0585\u0588\3\2\2\2\u0586" + + "\u0584\3\2\2\2\u0586\u0587\3\2\2\2\u0587\u0589\3\2\2\2\u0588\u0586\3\2" + + "\2\2\u0589\u058a\5\u00e8u\2\u058a\u00e7\3\2\2\2\u058b\u058c\bu\1\2\u058c" + + "\u058e\5\u00f6|\2\u058d\u058f\5\u00ceh\2\u058e\u058d\3\2\2\2\u058e\u058f" + + "\3\2\2\2\u058f\u0595\3\2\2\2\u0590\u0591\7W\2\2\u0591\u0592\5\u00e6t\2" + + "\u0592\u0593\7X\2\2\u0593\u0595\3\2\2\2\u0594\u058b\3\2\2\2\u0594\u0590" + + "\3\2\2\2\u0595\u05a4\3\2\2\2\u0596\u05a0\f\4\2\2\u0597\u05a1\5\u00eav" + + "\2\u0598\u059a\7Y\2\2\u0599\u059b\5^\60\2\u059a\u0599\3\2\2\2\u059a\u059b" + + "\3\2\2\2\u059b\u059c\3\2\2\2\u059c\u059e\7Z\2\2\u059d\u059f\5\u00ceh\2" + + "\u059e\u059d\3\2\2\2\u059e\u059f\3\2\2\2\u059f\u05a1\3\2\2\2\u05a0\u0597" + + "\3\2\2\2\u05a0\u0598\3\2\2\2\u05a1\u05a3\3\2\2\2\u05a2\u0596\3\2\2\2\u05a3" + + "\u05a6\3\2\2\2\u05a4\u05a2\3\2\2\2\u05a4\u05a5\3\2\2\2\u05a5\u00e9\3\2" + + "\2\2\u05a6\u05a4\3\2\2\2\u05a7\u05a9\7W\2\2\u05a8\u05aa\5\u0104\u0083" + + "\2\u05a9\u05a8\3\2\2\2\u05a9\u05aa\3\2\2\2\u05aa\u05ab\3\2\2\2\u05ab\u05ad" + + "\7X\2\2\u05ac\u05ae\5\u00f0y\2\u05ad\u05ac\3\2\2\2\u05ad\u05ae\3\2\2\2" + + "\u05ae\u05b0\3\2\2\2\u05af\u05b1\5\u00f4{\2\u05b0\u05af\3\2\2\2\u05b0" + + "\u05b1\3\2\2\2\u05b1\u05b3\3\2\2\2\u05b2\u05b4\5\u0174\u00bb\2\u05b3\u05b2" + + "\3\2\2\2\u05b3\u05b4\3\2\2\2\u05b4\u05b6\3\2\2\2\u05b5\u05b7\5\u00ceh" + + "\2\u05b6\u05b5\3\2\2\2\u05b6\u05b7\3\2\2\2\u05b7\u00eb\3\2\2\2\u05b8\u05b9" + + "\7~\2\2\u05b9\u05bb\5\u009aN\2\u05ba\u05bc\5\u00fa~\2\u05bb\u05ba\3\2" + + "\2\2\u05bb\u05bc\3\2\2\2\u05bc\u00ed\3\2\2\2\u05bd\u05bf\t\23\2\2\u05be" + + "\u05c0\5\u00ceh\2\u05bf\u05be\3\2\2\2\u05bf\u05c0\3\2\2\2\u05c0\u05cc" + + "\3\2\2\2\u05c1\u05c3\5\f\7\2\u05c2\u05c1\3\2\2\2\u05c2\u05c3\3\2\2\2\u05c3" + + "\u05c4\3\2\2\2\u05c4\u05c6\7_\2\2\u05c5\u05c7\5\u00ceh\2\u05c6\u05c5\3" + + "\2\2\2\u05c6\u05c7\3\2\2\2\u05c7\u05c9\3\2\2\2\u05c8\u05ca\5\u00f0y\2" + + "\u05c9\u05c8\3\2\2\2\u05c9\u05ca\3\2\2\2\u05ca\u05cc\3\2\2\2\u05cb\u05bd" + + "\3\2\2\2\u05cb\u05c2\3\2\2\2\u05cc\u00ef\3\2\2\2\u05cd\u05cf\5\u00f2z" + + "\2\u05ce\u05cd\3\2\2\2\u05cf\u05d0\3\2\2\2\u05d0\u05ce\3\2\2\2\u05d0\u05d1" + + "\3\2\2\2\u05d1\u00f1\3\2\2\2\u05d2\u05d3\t\24\2\2\u05d3\u00f3\3\2\2\2" + + "\u05d4\u05d5\t\23\2\2\u05d5\u00f5\3\2\2\2\u05d6\u05d8\7\u0085\2\2\u05d7" + + "\u05d6\3\2\2\2\u05d7\u05d8\3\2\2\2\u05d8\u05d9\3\2\2\2\u05d9\u05da\5\6" + + "\4\2\u05da\u00f7\3\2\2\2\u05db\u05dd\5\u0098M\2\u05dc\u05de\5\u00fa~\2" + + "\u05dd\u05dc\3\2\2\2\u05dd\u05de\3\2\2\2\u05de\u00f9\3\2\2\2\u05df\u05e8" + + "\5\u00fc\177\2\u05e0\u05e2\5\u00fe\u0080\2\u05e1\u05e0\3\2\2\2\u05e1\u05e2" + + "\3\2\2\2\u05e2\u05e3\3\2\2\2\u05e3\u05e4\5\u00eav\2\u05e4\u05e5\5\u00ec" + + "w\2\u05e5\u05e8\3\2\2\2\u05e6\u05e8\5\u0100\u0081\2\u05e7\u05df\3\2\2" + + "\2\u05e7\u05e1\3\2\2\2\u05e7\u05e6\3\2\2\2\u05e8\u00fb\3\2\2\2\u05e9\u05f3" + + "\5\u00fe\u0080\2\u05ea\u05ec\5\u00eex\2\u05eb\u05ea\3\2\2\2\u05ec\u05ed" + + "\3\2\2\2\u05ed\u05eb\3\2\2\2\u05ed\u05ee\3\2\2\2\u05ee\u05f0\3\2\2\2\u05ef" + + "\u05f1\5\u00fe\u0080\2\u05f0\u05ef\3\2\2\2\u05f0\u05f1\3\2\2\2\u05f1\u05f3" + + "\3\2\2\2\u05f2\u05e9\3\2\2\2\u05f2\u05eb\3\2\2\2\u05f3\u00fd\3\2\2\2\u05f4" + + "\u05f5\b\u0080\1\2\u05f5\u0603\5\u00eav\2\u05f6\u05f8\7Y\2\2\u05f7\u05f9" + + "\5^\60\2\u05f8\u05f7\3\2\2\2\u05f8\u05f9\3\2\2\2\u05f9\u05fa\3\2\2\2\u05fa" + + "\u05fc\7Z\2\2\u05fb\u05fd\5\u00ceh\2\u05fc\u05fb\3\2\2\2\u05fc\u05fd\3" + + "\2\2\2\u05fd\u0603\3\2\2\2\u05fe\u05ff\7W\2\2\u05ff\u0600\5\u00fc\177" + + "\2\u0600\u0601\7X\2\2\u0601\u0603\3\2\2\2\u0602\u05f4\3\2\2\2\u0602\u05f6" + + "\3\2\2\2\u0602\u05fe\3\2\2\2\u0603\u0613\3\2\2\2\u0604\u060f\f\6\2\2\u0605" + + "\u0610\5\u00eav\2\u0606\u0607\5\u00fe\u0080\2\u0607\u0609\7Y\2\2\u0608" + + "\u060a\5^\60\2\u0609\u0608\3\2\2\2\u0609\u060a\3\2\2\2\u060a\u060b\3\2" + + "\2\2\u060b\u060d\7Z\2\2\u060c\u060e\5\u00ceh\2\u060d\u060c\3\2\2\2\u060d" + + "\u060e\3\2\2\2\u060e\u0610\3\2\2\2\u060f\u0605\3\2\2\2\u060f\u0606\3\2" + + "\2\2\u0610\u0612\3\2\2\2\u0611\u0604\3\2\2\2\u0612\u0615\3\2\2\2\u0613" + + "\u0611\3\2\2\2\u0613\u0614\3\2\2\2\u0614\u00ff\3\2\2\2\u0615\u0613\3\2" + + "\2\2\u0616\u0618\5\u00eex\2\u0617\u0616\3\2\2\2\u0618\u061b\3\2\2\2\u0619" + + "\u0617\3\2\2\2\u0619\u061a\3\2\2\2\u061a\u061c\3\2\2\2\u061b\u0619\3\2" + + "\2\2\u061c\u061d\5\u0102\u0082\2\u061d\u0101\3\2\2\2\u061e\u061f\b\u0082" + + "\1\2\u061f\u0620\7\u0085\2\2\u0620\u062f\3\2\2\2\u0621\u062b\f\4\2\2\u0622" + + "\u062c\5\u00eav\2\u0623\u0625\7Y\2\2\u0624\u0626\5^\60\2\u0625\u0624\3" + + "\2\2\2\u0625\u0626\3\2\2\2\u0626\u0627\3\2\2\2\u0627\u0629\7Z\2\2\u0628" + + "\u062a\5\u00ceh\2\u0629\u0628\3\2\2\2\u0629\u062a\3\2\2\2\u062a\u062c" + + "\3\2\2\2\u062b\u0622\3\2\2\2\u062b\u0623\3\2\2\2\u062c\u062e\3\2\2\2\u062d" + + "\u0621\3\2\2\2\u062e\u0631\3\2\2\2\u062f\u062d\3\2\2\2\u062f\u0630\3\2" + + "\2\2\u0630\u0103\3\2\2\2\u0631\u062f\3\2\2\2\u0632\u0637\5\u0106\u0084" + + "\2\u0633\u0635\7|\2\2\u0634\u0633\3\2\2\2\u0634\u0635\3\2\2\2\u0635\u0636" + + "\3\2\2\2\u0636\u0638\7\u0085\2\2\u0637\u0634\3\2\2\2\u0637\u0638\3\2\2" + + "\2\u0638\u0105\3\2\2\2\u0639\u063e\5\u0108\u0085\2\u063a\u063b\7|\2\2" + + "\u063b\u063d\5\u0108\u0085\2\u063c\u063a\3\2\2\2\u063d\u0640\3\2\2\2\u063e" + + "\u063c\3\2\2\2\u063e\u063f\3\2\2\2\u063f\u0107\3\2\2\2\u0640\u063e\3\2" + + "\2\2\u0641\u0643\5\u00ceh\2\u0642\u0641\3\2\2\2\u0642\u0643\3\2\2\2\u0643" + + "\u0644\3\2\2\2\u0644\u0649\5\u008cG\2\u0645\u064a\5\u00e4s\2\u0646\u0648" + + "\5\u00fa~\2\u0647\u0646\3\2\2\2\u0647\u0648\3\2\2\2\u0648\u064a\3\2\2" + + "\2\u0649\u0645\3\2\2\2\u0649\u0647\3\2\2\2\u064a\u064d\3\2\2\2\u064b\u064c" + + "\7g\2\2\u064c\u064e\5\u0112\u008a\2\u064d\u064b\3\2\2\2\u064d\u064e\3" + + "\2\2\2\u064e\u0109\3\2\2\2\u064f\u0651\5\u00ceh\2\u0650\u064f\3\2\2\2" + + "\u0650\u0651\3\2\2\2\u0651\u0653\3\2\2\2\u0652\u0654\5\u008cG\2\u0653" + + "\u0652\3\2\2\2\u0653\u0654\3\2\2\2\u0654\u0655\3\2\2\2\u0655\u0657\5\u00e4" + + "s\2\u0656\u0658\5\u012c\u0097\2\u0657\u0656\3\2\2\2\u0657\u0658\3\2\2" + + "\2\u0658\u0659\3\2\2\2\u0659\u065a\5\u010c\u0087\2\u065a\u010b\3\2\2\2" + + "\u065b\u065d\5\u0144\u00a3\2\u065c\u065b\3\2\2\2\u065c\u065d\3\2\2\2\u065d" + + "\u065e\3\2\2\2\u065e\u0664\5f\64\2\u065f\u0664\5\u016a\u00b6\2\u0660\u0661" + + "\7g\2\2\u0661\u0662\t\25\2\2\u0662\u0664\7\u0082\2\2\u0663\u065c\3\2\2" + + "\2\u0663\u065f\3\2\2\2\u0663\u0660\3\2\2\2\u0664\u010d\3\2\2\2\u0665\u066b" + + "\5\u0110\u0089\2\u0666\u0667\7W\2\2\u0667\u0668\5$\23\2\u0668\u0669\7" + + "X\2\2\u0669\u066b\3\2\2\2\u066a\u0665\3\2\2\2\u066a\u0666\3\2\2\2\u066b" + + "\u010f\3\2\2\2\u066c\u066d\7g\2\2\u066d\u0670\5\u0112\u008a\2\u066e\u0670" + + "\5\u0116\u008c\2\u066f\u066c\3\2\2\2\u066f\u066e\3\2\2\2\u0670\u0111\3" + + "\2\2\2\u0671\u0674\5X-\2\u0672\u0674\5\u0116\u008c\2\u0673\u0671\3\2\2" + + "\2\u0673\u0672\3\2\2\2\u0674\u0113\3\2\2\2\u0675\u0677\5\u0112\u008a\2" + + "\u0676\u0678\7\u0085\2\2\u0677\u0676\3\2\2\2\u0677\u0678\3\2\2\2\u0678" + + "\u0680\3\2\2\2\u0679\u067a\7|\2\2\u067a\u067c\5\u0112\u008a\2\u067b\u067d" + + "\7\u0085\2\2\u067c\u067b\3\2\2\2\u067c\u067d\3\2\2\2\u067d\u067f\3\2\2" + + "\2\u067e\u0679\3\2\2\2\u067f\u0682\3\2\2\2\u0680\u067e\3\2\2\2\u0680\u0681" + + "\3\2\2\2\u0681\u0115\3\2\2\2\u0682\u0680\3\2\2\2\u0683\u0688\7[\2\2\u0684" + + "\u0686\5\u0114\u008b\2\u0685\u0687\7|\2\2\u0686\u0685\3\2\2\2\u0686\u0687" + + "\3\2\2\2\u0687\u0689\3\2\2\2\u0688\u0684\3\2\2\2\u0688\u0689\3\2\2\2\u0689" + + "\u068a\3\2\2\2\u068a\u068b\7\\\2\2\u068b\u0117\3\2\2\2\u068c\u068f\7\u0086" + + "\2\2\u068d\u068f\5\u0158\u00ad\2\u068e\u068c\3\2\2\2\u068e\u068d\3\2\2" + + "\2\u068f\u0119\3\2\2\2\u0690\u0691\5\u011c\u008f\2\u0691\u0693\7[\2\2" + + "\u0692\u0694\5\u0124\u0093\2\u0693\u0692\3\2\2\2\u0693\u0694\3\2\2\2\u0694" + + "\u0695\3\2\2\2\u0695\u0696\7\\\2\2\u0696\u011b\3\2\2\2\u0697\u0699\5\u0122" + + "\u0092\2\u0698\u069a\5\u00ceh\2\u0699\u0698\3\2\2\2\u0699\u069a\3\2\2" + + "\2\u069a\u069f\3\2\2\2\u069b\u069d\5\u011e\u0090\2\u069c\u069e\5\u0120" + + "\u0091\2\u069d\u069c\3\2\2\2\u069d\u069e\3\2\2\2\u069e\u06a0\3\2\2\2\u069f" + + "\u069b\3\2\2\2\u069f\u06a0\3\2\2\2\u06a0\u06a2\3\2\2\2\u06a1\u06a3\5\u0132" + + "\u009a\2\u06a2\u06a1\3\2\2\2\u06a2\u06a3\3\2\2\2\u06a3\u06af\3\2\2\2\u06a4" + + "\u06a6\7O\2\2\u06a5\u06a7\5\u00ceh\2\u06a6\u06a5\3\2\2\2\u06a6\u06a7\3" + + "\2\2\2\u06a7\u06ac\3\2\2\2\u06a8\u06aa\5\u011e\u0090\2\u06a9\u06ab\5\u0120" + + "\u0091\2\u06aa\u06a9\3\2\2\2\u06aa\u06ab\3\2\2\2\u06ab\u06ad\3\2\2\2\u06ac" + + "\u06a8\3\2\2\2\u06ac\u06ad\3\2\2\2\u06ad\u06af\3\2\2\2\u06ae\u0697\3\2" + + "\2\2\u06ae\u06a4\3\2\2\2\u06af\u011d\3\2\2\2\u06b0\u06b2\5\f\7\2\u06b1" + + "\u06b0\3\2\2\2\u06b1\u06b2\3\2\2\2\u06b2\u06b3\3\2\2\2\u06b3\u06b4\5\u0118" + + "\u008d\2\u06b4\u011f\3\2\2\2\u06b5\u06b6\7(\2\2\u06b6\u0121\3\2\2\2\u06b7" + + "\u06b8\t\21\2\2\u06b8\u0123\3\2\2\2\u06b9\u06be\5\u0126\u0094\2\u06ba" + + "\u06bb\5\u013c\u009f\2\u06bb\u06bc\7\u0080\2\2\u06bc\u06be\3\2\2\2\u06bd" + + "\u06b9\3\2\2\2\u06bd\u06ba\3\2\2\2\u06be\u06bf\3\2\2\2\u06bf\u06bd\3\2" + + "\2\2\u06bf\u06c0\3\2\2\2\u06c0\u0125\3\2\2\2\u06c1\u06c3\5\u00ceh\2\u06c2" + + "\u06c1\3\2\2\2\u06c2\u06c3\3\2\2\2\u06c3\u06c5\3\2\2\2\u06c4\u06c6\5\u008c" + + "G\2\u06c5\u06c4\3\2\2\2\u06c5\u06c6\3\2\2\2\u06c6\u06c8\3\2\2\2\u06c7" + + "\u06c9\5\u0128\u0095\2\u06c8\u06c7\3\2\2\2\u06c8\u06c9\3\2\2\2\u06c9\u06ca" + + "\3\2\2\2\u06ca\u06d2\7\u0082\2\2\u06cb\u06d2\5\u010a\u0086\2\u06cc\u06d2" + + "\5\u00c6d\2\u06cd\u06d2\5\u0084C\2\u06ce\u06d2\5\u0150\u00a9\2\u06cf\u06d2" + + "\5\u0080A\2\u06d0\u06d2\5\u0086D\2\u06d1\u06c2\3\2\2\2\u06d1\u06cb\3\2" + + "\2\2\u06d1\u06cc\3\2\2\2\u06d1\u06cd\3\2\2\2\u06d1\u06ce\3\2\2\2\u06d1" + + "\u06cf\3\2\2\2\u06d1\u06d0\3\2\2\2\u06d2\u0127\3\2\2\2\u06d3\u06d8\5\u012a" + + "\u0096\2\u06d4\u06d5\7|\2\2\u06d5\u06d7\5\u012a\u0096\2\u06d6\u06d4\3" + + "\2\2\2\u06d7\u06da\3\2\2\2\u06d8\u06d6\3\2\2\2\u06d8\u06d9\3\2\2\2\u06d9" + + "\u0129\3\2\2\2\u06da\u06d8\3\2\2\2\u06db\u06e5\5\u00e4s\2\u06dc\u06de" + + "\5\u012c\u0097\2\u06dd\u06dc\3\2\2\2\u06dd\u06de\3\2\2\2\u06de\u06e0\3" + + "\2\2\2\u06df\u06e1\5\u0130\u0099\2\u06e0\u06df\3\2\2\2\u06e0\u06e1\3\2" + + "\2\2\u06e1\u06e6\3\2\2\2\u06e2\u06e4\5\u0110\u0089\2\u06e3\u06e2\3\2\2" + + "\2\u06e3\u06e4\3\2\2\2\u06e4\u06e6\3\2\2\2\u06e5\u06dd\3\2\2\2\u06e5\u06e3" + + "\3\2\2\2\u06e6\u06f0\3\2\2\2\u06e7\u06e9\7\u0086\2\2\u06e8\u06e7\3\2\2" + + "\2\u06e8\u06e9\3\2\2\2\u06e9\u06eb\3\2\2\2\u06ea\u06ec\5\u00ceh\2\u06eb" + + "\u06ea\3\2\2\2\u06eb\u06ec\3\2\2\2\u06ec\u06ed\3\2\2\2\u06ed\u06ee\7\u0080" + + "\2\2\u06ee\u06f0\5^\60\2\u06ef\u06db\3\2\2\2\u06ef\u06e8\3\2\2\2\u06f0" + + "\u012b\3\2\2\2\u06f1\u06f3\5\u012e\u0098\2\u06f2\u06f1\3\2\2\2\u06f3\u06f4" + + "\3\2\2\2\u06f4\u06f2\3\2\2\2\u06f4\u06f5\3\2\2\2\u06f5\u012d\3\2\2\2\u06f6" + + "\u06f7\t\26\2\2\u06f7\u012f\3\2\2\2\u06f8\u06f9\7g\2\2\u06f9\u06fa\7\u0088" + + "\2\2\u06fa\u06fb\b\u0099\1\2\u06fb\u0131\3\2\2\2\u06fc\u06fd\7\u0080\2" + + "\2\u06fd\u06fe\5\u0134\u009b\2\u06fe\u0133\3\2\2\2\u06ff\u0701\5\u0136" + + "\u009c\2\u0700\u0702\7\u0085\2\2\u0701\u0700\3\2\2\2\u0701\u0702\3\2\2" + + "\2\u0702\u070a\3\2\2\2\u0703\u0704\7|\2\2\u0704\u0706\5\u0136\u009c\2" + + "\u0705\u0707\7\u0085\2\2\u0706\u0705\3\2\2\2\u0706\u0707\3\2\2\2\u0707" + + "\u0709\3\2\2\2\u0708\u0703\3\2\2\2\u0709\u070c\3\2\2\2\u070a\u0708\3\2" + + "\2\2\u070a\u070b\3\2\2\2\u070b\u0135\3\2\2\2\u070c\u070a\3\2\2\2\u070d" + + "\u070f\5\u00ceh\2\u070e\u070d\3\2\2\2\u070e\u070f\3\2\2\2\u070f\u071c" + + "\3\2\2\2\u0710\u071d\5\u013a\u009e\2\u0711\u0713\7R\2\2\u0712\u0714\5" + + "\u013c\u009f\2\u0713\u0712\3\2\2\2\u0713\u0714\3\2\2\2\u0714\u0715\3\2" + + "\2\2\u0715\u071d\5\u013a\u009e\2\u0716\u0718\5\u013c\u009f\2\u0717\u0719" + + "\7R\2\2\u0718\u0717\3\2\2\2\u0718\u0719\3\2\2\2\u0719\u071a\3\2\2\2\u071a" + + "\u071b\5\u013a\u009e\2\u071b\u071d\3\2\2\2\u071c\u0710\3\2\2\2\u071c\u0711" + + "\3\2\2\2\u071c\u0716\3\2\2\2\u071d\u0137\3\2\2\2\u071e\u0720\5\f\7\2\u071f" + + "\u071e\3\2\2\2\u071f\u0720\3\2\2\2\u0720\u0721\3\2\2\2\u0721\u0724\5\u0118" + + "\u008d\2\u0722\u0724\5\u00a4S\2\u0723\u071f\3\2\2\2\u0723\u0722\3\2\2" + + "\2\u0724\u0139\3\2\2\2\u0725\u0726\5\u0138\u009d\2\u0726\u013b\3\2\2\2" + + "\u0727\u0728\t\27\2\2\u0728\u013d\3\2\2\2\u0729\u072a\7\66\2\2\u072a\u072b" + + "\5\u0140\u00a1\2\u072b\u013f\3\2\2\2\u072c\u072e\5\u0098M\2\u072d\u072f" + + "\5\u0142\u00a2\2\u072e\u072d\3\2\2\2\u072e\u072f\3\2\2\2\u072f\u0141\3" + + "\2\2\2\u0730\u0732\5\u00eex\2\u0731\u0733\5\u0142\u00a2\2\u0732\u0731" + + "\3\2\2\2\u0732\u0733\3\2\2\2\u0733\u0143\3\2\2\2\u0734\u0735\7\u0080\2" + + "\2\u0735\u0736\5\u0146\u00a4\2\u0736\u0145\3\2\2\2\u0737\u0739\5\u0148" + + "\u00a5\2\u0738\u073a\7\u0085\2\2\u0739\u0738\3\2\2\2\u0739\u073a\3\2\2" + + "\2\u073a\u0742\3\2\2\2\u073b\u073c\7|\2\2\u073c\u073e\5\u0148\u00a5\2" + + "\u073d\u073f\7\u0085\2\2\u073e\u073d\3\2\2\2\u073e\u073f\3\2\2\2\u073f" + + "\u0741\3\2\2\2\u0740\u073b\3\2\2\2\u0741\u0744\3\2\2\2\u0742\u0740\3\2" + + "\2\2\u0742\u0743\3\2\2\2\u0743\u0147\3\2\2\2\u0744\u0742\3\2\2\2\u0745" + + "\u074c\5\u014a\u00a6\2\u0746\u0748\7W\2\2\u0747\u0749\5$\23\2\u0748\u0747" + + "\3\2\2\2\u0748\u0749\3\2\2\2\u0749\u074a\3\2\2\2\u074a\u074d\7X\2\2\u074b" + + "\u074d\5\u0116\u008c\2\u074c\u0746\3\2\2\2\u074c\u074b\3\2\2\2\u074d\u0149" + + "\3\2\2\2\u074e\u0751\5\u0138\u009d\2\u074f\u0751\7\u0086\2\2\u0750\u074e" + + "\3\2\2\2\u0750\u074f\3\2\2\2\u0751\u014b\3\2\2\2\u0752\u0753\7\66\2\2" + + "\u0753\u0754\5\u017c\u00bf\2\u0754\u014d\3\2\2\2\u0755\u0759\7\66\2\2" + + "\u0756\u0757\7\6\2\2\u0757\u075a\7\u0086\2\2\u0758\u075a\7\u008e\2\2\u0759" + + "\u0756\3\2\2\2\u0759\u0758\3\2\2\2\u075a\u014f\3\2\2\2\u075b\u075c\7F" + + "\2\2\u075c\u075d\7h\2\2\u075d\u075e\5\u0152\u00aa\2\u075e\u075f\7i\2\2" + + "\u075f\u0760\5|?\2\u0760\u0151\3\2\2\2\u0761\u0766\5\u0154\u00ab\2\u0762" + + "\u0763\7|\2\2\u0763\u0765\5\u0154\u00ab\2\u0764\u0762\3\2\2\2\u0765\u0768" + + "\3\2\2\2\u0766\u0764\3\2\2\2\u0766\u0767\3\2\2\2\u0767\u0153\3\2\2\2\u0768" + + "\u0766\3\2\2\2\u0769\u076c\5\u0156\u00ac\2\u076a\u076c\5\u0108\u0085\2" + + "\u076b\u0769\3\2\2\2\u076b\u076a\3\2\2\2\u076c\u0155\3\2\2\2\u076d\u076e" + + "\7F\2\2\u076e\u076f\7h\2\2\u076f\u0770\5\u0152\u00aa\2\u0770\u0771\7i" + + "\2\2\u0771\u0773\3\2\2\2\u0772\u076d\3\2\2\2\u0772\u0773\3\2\2\2\u0773" + + "\u0774\3\2\2\2\u0774\u0777\7\27\2\2\u0775\u0777\7N\2\2\u0776\u0772\3\2" + + "\2\2\u0776\u0775\3\2\2\2\u0777\u0783\3\2\2\2\u0778\u077a\7\u0085\2\2\u0779" + + "\u0778\3\2\2\2\u0779\u077a\3\2\2\2\u077a\u077c\3\2\2\2\u077b\u077d\7\u0086" + + "\2\2\u077c\u077b\3\2\2\2\u077c\u077d\3\2\2\2\u077d\u0784\3\2\2\2\u077e" + + "\u0780\7\u0086\2\2\u077f\u077e\3\2\2\2\u077f\u0780\3\2\2\2\u0780\u0781" + + "\3\2\2\2\u0781\u0782\7g\2\2\u0782\u0784\5\u00f8}\2\u0783\u0779\3\2\2\2" + + "\u0783\u077f\3\2\2\2\u0784\u0157\3\2\2\2\u0785\u0786\5\u015c\u00af\2\u0786" + + "\u0788\7h\2\2\u0787\u0789\5\u015e\u00b0\2\u0788\u0787\3\2\2\2\u0788\u0789" + + "\3\2\2\2\u0789\u078a\3\2\2\2\u078a\u078b\7i\2\2\u078b\u0159\3\2\2\2\u078c" + + "\u0798\5\u0158\u00ad\2\u078d\u0790\5\u014c\u00a7\2\u078e\u0790\5\u014e" + + "\u00a8\2\u078f\u078d\3\2\2\2\u078f\u078e\3\2\2\2\u0790\u0791\3\2\2\2\u0791" + + "\u0793\7h\2\2\u0792\u0794\5\u015e\u00b0\2\u0793\u0792\3\2\2\2\u0793\u0794" + + "\3\2\2\2\u0794\u0795\3\2\2\2\u0795\u0796\7i\2\2\u0796\u0798\3\2\2\2\u0797" + + "\u078c\3\2\2\2\u0797\u078f\3\2\2\2\u0798\u015b\3\2\2\2\u0799\u079a\7\u0086" + + "\2\2\u079a\u015d\3\2\2\2\u079b\u079d\5\u0160\u00b1\2\u079c\u079e\7\u0085" + + "\2\2\u079d\u079c\3\2\2\2\u079d\u079e\3\2\2\2\u079e\u07a6\3\2\2\2\u079f" + + "\u07a0\7|\2\2\u07a0\u07a2\5\u0160\u00b1\2\u07a1\u07a3\7\u0085\2\2\u07a2" + + "\u07a1\3\2\2\2\u07a2\u07a3\3\2\2\2\u07a3\u07a5\3\2\2\2\u07a4\u079f\3\2" + + "\2\2\u07a5\u07a8\3\2\2\2\u07a6\u07a4\3\2\2\2\u07a6\u07a7\3\2\2\2\u07a7" + + "\u015f\3\2\2\2\u07a8\u07a6\3\2\2\2\u07a9\u07ad\5\u00f8}\2\u07aa\u07ad" + + "\5^\60\2\u07ab\u07ad\5\6\4\2\u07ac\u07a9\3\2\2\2\u07ac\u07aa\3\2\2\2\u07ac" + + "\u07ab\3\2\2\2\u07ad\u0161\3\2\2\2\u07ae\u07af\7N\2\2\u07af\u07b5\5\f" + + "\7\2\u07b0\u07b6\7\u0086\2\2\u07b1\u07b3\7F\2\2\u07b2\u07b1\3\2\2\2\u07b2" + + "\u07b3\3\2\2\2\u07b3\u07b4\3\2\2\2\u07b4\u07b6\5\u0158\u00ad\2\u07b5\u07b0" + + "\3\2\2\2\u07b5\u07b2\3\2\2\2\u07b6\u0163\3\2\2\2\u07b7\u07b9\7&\2\2\u07b8" + + "\u07b7\3\2\2\2\u07b8\u07b9\3\2\2\2\u07b9\u07ba\3\2\2\2\u07ba\u07bb\7F" + + "\2\2\u07bb\u07bc\5|?\2\u07bc\u0165\3\2\2\2\u07bd\u07be\7F\2\2\u07be\u07bf" + + "\7h\2\2\u07bf\u07c0\7i\2\2\u07c0\u07c1\5|?\2\u07c1\u0167\3\2\2\2\u07c2" + + "\u07c3\7K\2\2\u07c3\u07c4\5f\64\2\u07c4\u07c5\5\u016c\u00b7\2\u07c5\u0169" + + "\3\2\2\2\u07c6\u07c8\7K\2\2\u07c7\u07c9\5\u0144\u00a3\2\u07c8\u07c7\3" + + "\2\2\2\u07c8\u07c9\3\2\2\2\u07c9\u07ca\3\2\2\2\u07ca\u07cb\5f\64\2\u07cb" + + "\u07cc\5\u016c\u00b7\2\u07cc\u016b\3\2\2\2\u07cd\u07cf\5\u016e\u00b8\2" + + "\u07ce\u07cd\3\2\2\2\u07cf\u07d0\3\2\2\2\u07d0\u07ce\3\2\2\2\u07d0\u07d1" + + "\3\2\2\2\u07d1\u016d\3\2\2\2\u07d2\u07d3\7\23\2\2\u07d3\u07d4\7W\2\2\u07d4" + + "\u07d5\5\u0170\u00b9\2\u07d5\u07d6\7X\2\2\u07d6\u07d7\5f\64\2\u07d7\u016f" + + "\3\2\2\2\u07d8\u07da\5\u00ceh\2\u07d9\u07d8\3\2\2\2\u07d9\u07da\3\2\2" + + "\2\u07da\u07db\3\2\2\2\u07db\u07de\5\u0098M\2\u07dc\u07df\5\u00e4s\2\u07dd" + + "\u07df\5\u00fa~\2\u07de\u07dc\3\2\2\2\u07de\u07dd\3\2\2\2\u07de\u07df" + + "\3\2\2\2\u07df\u07e2\3\2\2\2\u07e0\u07e2\7\u0085\2\2\u07e1\u07d9\3\2\2" + + "\2\u07e1\u07e0\3\2\2\2\u07e2\u0171\3\2\2\2\u07e3\u07e5\7I\2\2\u07e4\u07e6" + + "\5X-\2\u07e5\u07e4\3\2\2\2\u07e5\u07e6\3\2\2\2\u07e6\u0173\3\2\2\2\u07e7" + + "\u07ea\5\u0176\u00bc\2\u07e8\u07ea\5\u017a\u00be\2\u07e9\u07e7\3\2\2\2" + + "\u07e9\u07e8\3\2\2\2\u07ea\u0175\3\2\2\2\u07eb\u07ec\7I\2\2\u07ec\u07ee" + + "\7W\2\2\u07ed\u07ef\5\u0178\u00bd\2\u07ee\u07ed\3\2\2\2\u07ee\u07ef\3" + + "\2\2\2\u07ef\u07f0\3\2\2\2\u07f0\u07f1\7X\2\2\u07f1\u0177\3\2\2\2\u07f2" + + "\u07f4\5\u00f8}\2\u07f3\u07f5\7\u0085\2\2\u07f4\u07f3\3\2\2\2\u07f4\u07f5" + + "\3\2\2\2\u07f5\u07fd\3\2\2\2\u07f6\u07f7\7|\2\2\u07f7\u07f9\5\u00f8}\2" + + "\u07f8\u07fa\7\u0085\2\2\u07f9\u07f8\3\2\2\2\u07f9\u07fa\3\2\2\2\u07fa" + + "\u07fc\3\2\2\2\u07fb\u07f6\3\2\2\2\u07fc\u07ff\3\2\2\2\u07fd\u07fb\3\2" + + "\2\2\u07fd\u07fe\3\2\2\2\u07fe\u0179\3\2\2\2\u07ff\u07fd\3\2\2\2\u0800" + + "\u0801\7\64\2\2\u0801\u0802\7W\2\2\u0802\u0803\5^\60\2\u0803\u0804\7X" + + "\2\2\u0804\u0807\3\2\2\2\u0805\u0807\7\64\2\2\u0806\u0800\3\2\2\2\u0806" + + "\u0805\3\2\2\2\u0807\u017b\3\2\2\2\u0808\u080b\7\63\2\2\u0809\u080a\7" + + "Y\2\2\u080a\u080c\7Z\2\2\u080b\u0809\3\2\2\2\u080b\u080c\3\2\2\2\u080c" + + "\u083c\3\2\2\2\u080d\u0810\7\36\2\2\u080e\u080f\7Y\2\2\u080f\u0811\7Z" + + "\2\2\u0810\u080e\3\2\2\2\u0810\u0811\3\2\2\2\u0811\u083c\3\2\2\2\u0812" + + "\u083c\7]\2\2\u0813\u083c\7^\2\2\u0814\u083c\7_\2\2\u0815\u083c\7`\2\2" + + "\u0816\u083c\7a\2\2\u0817\u083c\7b\2\2\u0818\u083c\7c\2\2\u0819\u083c" + + "\7d\2\2\u081a\u083c\7e\2\2\u081b\u083c\7f\2\2\u081c\u083c\7g\2\2\u081d" + + "\u083c\7i\2\2\u081e\u083c\7h\2\2\u081f\u083c\7w\2\2\u0820\u083c\7j\2\2" + + "\u0821\u083c\7k\2\2\u0822\u083c\7l\2\2\u0823\u083c\7n\2\2\u0824\u083c" + + "\7o\2\2\u0825\u083c\7p\2\2\u0826\u083c\7q\2\2\u0827\u0828\7h\2\2\u0828" + + "\u083c\7h\2\2\u0829\u082a\7i\2\2\u082a\u083c\7i\2\2\u082b\u083c\7s\2\2" + + "\u082c\u083c\7r\2\2\u082d\u083c\7t\2\2\u082e\u083c\7u\2\2\u082f\u083c" + + "\7v\2\2\u0830\u083c\7x\2\2\u0831\u083c\7y\2\2\u0832\u083c\7z\2\2\u0833" + + "\u083c\7{\2\2\u0834\u083c\7|\2\2\u0835\u083c\7}\2\2\u0836\u083c\7~\2\2" + + "\u0837\u0838\7W\2\2\u0838\u083c\7X\2\2\u0839\u083a\7Y\2\2\u083a\u083c" + + "\7Z\2\2\u083b\u0808\3\2\2\2\u083b\u080d\3\2\2\2\u083b\u0812\3\2\2\2\u083b" + + "\u0813\3\2\2\2\u083b\u0814\3\2\2\2\u083b\u0815\3\2\2\2\u083b\u0816\3\2" + + "\2\2\u083b\u0817\3\2\2\2\u083b\u0818\3\2\2\2\u083b\u0819\3\2\2\2\u083b" + + "\u081a\3\2\2\2\u083b\u081b\3\2\2\2\u083b\u081c\3\2\2\2\u083b\u081d\3\2" + + "\2\2\u083b\u081e\3\2\2\2\u083b\u081f\3\2\2\2\u083b\u0820\3\2\2\2\u083b" + + "\u0821\3\2\2\2\u083b\u0822\3\2\2\2\u083b\u0823\3\2\2\2\u083b\u0824\3\2" + + "\2\2\u083b\u0825\3\2\2\2\u083b\u0826\3\2\2\2\u083b\u0827\3\2\2\2\u083b" + + "\u0829\3\2\2\2\u083b\u082b\3\2\2\2\u083b\u082c\3\2\2\2\u083b\u082d\3\2" + + "\2\2\u083b\u082e\3\2\2\2\u083b\u082f\3\2\2\2\u083b\u0830\3\2\2\2\u083b" + + "\u0831\3\2\2\2\u083b\u0832\3\2\2\2\u083b\u0833\3\2\2\2\u083b\u0834\3\2" + + "\2\2\u083b\u0835\3\2\2\2\u083b\u0836\3\2\2\2\u083b\u0837\3\2\2\2\u083b" + + "\u0839\3\2\2\2\u083c\u017d\3\2\2\2\u083d\u083e\t\30\2\2\u083e\u017f\3" + + "\2\2\2\u0134\u0181\u0188\u0191\u0195\u019e\u01a1\u01a5\u01ad\u01b4\u01b7" + + "\u01bc\u01c1\u01c7\u01cf\u01d1\u01da\u01de\u01e2\u01e5\u01e9\u01ec\u01f3" + + "\u01f7\u01fa\u01fd\u0200\u0206\u020a\u020e\u021c\u0220\u0226\u022d\u0233" + + "\u0237\u023b\u023d\u0245\u024a\u0257\u025e\u026a\u0274\u0279\u027d\u0284" + + "\u0287\u028f\u0293\u0296\u029d\u02a4\u02a8\u02ad\u02b1\u02b4\u02b9\u02c8" + + "\u02cf\u02d7\u02df\u02e8\u02ef\u02f6\u02fe\u0306\u030e\u0316\u031e\u0326" + + "\u032f\u0337\u0340\u0348\u0350\u0352\u0355\u035b\u0361\u0367\u036e\u0377" + + "\u037f\u0383\u038a\u038c\u03a0\u03a4\u03aa\u03af\u03b3\u03b6\u03bd\u03c4" + + "\u03c8\u03d1\u03dc\u03e6\u03eb\u03f2\u03f5\u03fa\u03ff\u0414\u0419\u041c" + + "\u0427\u042d\u0432\u0435\u043a\u043d\u0444\u044d\u0452\u0455\u0459\u045d" + + "\u0461\u0466\u046b\u0471\u0477\u047d\u0483\u0489\u048c\u0492\u0496\u049a" + + "\u049d\u04a5\u04a7\u04ad\u04b0\u04b3\u04b6\u04ba\u04be\u04c4\u04ce\u04d4" + + "\u04da\u04df\u04e4\u04e8\u04f5\u04fb\u04ff\u0505\u050a\u0519\u051d\u0522" + + "\u0527\u052c\u0532\u0535\u053e\u0542\u0547\u054b\u0551\u0558\u0569\u056b" + + "\u0572\u0577\u057e\u0582\u0586\u058e\u0594\u059a\u059e\u05a0\u05a4\u05a9" + + "\u05ad\u05b0\u05b3\u05b6\u05bb\u05bf\u05c2\u05c6\u05c9\u05cb\u05d0\u05d7" + + "\u05dd\u05e1\u05e7\u05ed\u05f0\u05f2\u05f8\u05fc\u0602\u0609\u060d\u060f" + + "\u0613\u0619\u0625\u0629\u062b\u062f\u0634\u0637\u063e\u0642\u0647\u0649" + + "\u064d\u0650\u0653\u0657\u065c\u0663\u066a\u066f\u0673\u0677\u067c\u0680" + + "\u0686\u0688\u068e\u0693\u0699\u069d\u069f\u06a2\u06a6\u06aa\u06ac\u06ae" + + "\u06b1\u06bd\u06bf\u06c2\u06c5\u06c8\u06d1\u06d8\u06dd\u06e0\u06e3\u06e5" + + "\u06e8\u06eb\u06ef\u06f4\u0701\u0706\u070a\u070e\u0713\u0718\u071c\u071f" + + "\u0723\u072e\u0732\u0739\u073e\u0742\u0748\u074c\u0750\u0759\u0766\u076b" + + "\u0772\u0776\u0779\u077c\u077f\u0783\u0788\u078f\u0793\u0797\u079d\u07a2" + + "\u07a6\u07ac\u07b2\u07b5\u07b8\u07c8\u07d0\u07d9\u07de\u07e1\u07e5\u07e9" + + "\u07ee\u07f4\u07f9\u07fd\u0806\u080b\u0810\u083b"; + public static final ATN _ATN = new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache(); + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + + static { + RuntimeMetaData.checkVersion("4.9.3", RuntimeMetaData.VERSION); + } + + 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] = ""; + } + } + } + + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } + + public CPP14Parser(TokenStream input) { + super(input); + _interp = new ParserATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache); + } + + 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", + "simpleTypeLengthModifier", + "simpleTypeSignednessModifier", + "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" + }; + } + + 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 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" + }; + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } + + @Override + public String[] getRuleNames() { + return ruleNames; + } + + @Override + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + @Override + public String getSerializedATN() { + return _serializedATN; + } + + @Override + public String getGrammarFileName() { + return "CPP14Parser.g4"; + } + + @Override + public ATN getATN() { + return _ATN; + } + + 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 115: + return noPointerDeclarator_sempred((NoPointerDeclaratorContext) _localctx, predIndex); + case 126: + return noPointerAbstractDeclarator_sempred( + (NoPointerAbstractDeclaratorContext) _localctx, predIndex); + case 128: + 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 final TranslationUnitContext translationUnit() throws RecognitionException { + TranslationUnitContext _localctx = new TranslationUnitContext(_ctx, getState()); + enterRule(_localctx, 0, RULE_translationUnit); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(383); + _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(382); + declarationseq(); + } + } + + setState(385); + match(EOF); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final PrimaryExpressionContext primaryExpression() throws RecognitionException { + PrimaryExpressionContext _localctx = new PrimaryExpressionContext(_ctx, getState()); + enterRule(_localctx, 2, RULE_primaryExpression); + try { + int _alt; + setState(399); + _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(388); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(387); + literal(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(390); + _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(392); + match(This); + } + break; + case LeftParen: + enterOuterAlt(_localctx, 3); + { + setState(393); + match(LeftParen); + setState(394); + expression(); + setState(395); + match(RightParen); + } + break; + case Decltype: + case Operator: + case Tilde: + case Doublecolon: + case Identifier: + enterOuterAlt(_localctx, 4); + { + setState(397); + idExpression(); + } + break; + case LeftBracket: + enterOuterAlt(_localctx, 5); + { + setState(398); + 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 final IdExpressionContext idExpression() throws RecognitionException { + IdExpressionContext _localctx = new IdExpressionContext(_ctx, getState()); + enterRule(_localctx, 4, RULE_idExpression); + try { + setState(403); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 3, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(401); + unqualifiedId(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(402); + qualifiedId(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final UnqualifiedIdContext unqualifiedId() throws RecognitionException { + UnqualifiedIdContext _localctx = new UnqualifiedIdContext(_ctx, getState()); + enterRule(_localctx, 6, RULE_unqualifiedId); + try { + setState(415); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 5, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(405); + match(Identifier); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(406); + operatorFunctionId(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(407); + conversionFunctionId(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(408); + literalOperatorId(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(409); + match(Tilde); + setState(412); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Identifier: + { + setState(410); + className(); + } + break; + case Decltype: + { + setState(411); + decltypeSpecifier(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(414); + templateId(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final QualifiedIdContext qualifiedId() throws RecognitionException { + QualifiedIdContext _localctx = new QualifiedIdContext(_ctx, getState()); + enterRule(_localctx, 8, RULE_qualifiedId); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(417); + nestedNameSpecifier(0); + setState(419); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Template) { + { + setState(418); + match(Template); + } + } + + setState(421); + unqualifiedId(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final NestedNameSpecifierContext nestedNameSpecifier() throws RecognitionException { + return nestedNameSpecifier(0); + } + + public final LambdaExpressionContext lambdaExpression() throws RecognitionException { + LambdaExpressionContext _localctx = new LambdaExpressionContext(_ctx, getState()); + enterRule(_localctx, 12, RULE_lambdaExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(445); + lambdaIntroducer(); + setState(447); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == LeftParen) { + { + setState(446); + lambdaDeclarator(); + } + } + + setState(449); + compoundStatement(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final LambdaIntroducerContext lambdaIntroducer() throws RecognitionException { + LambdaIntroducerContext _localctx = new LambdaIntroducerContext(_ctx, getState()); + enterRule(_localctx, 14, RULE_lambdaIntroducer); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(451); + match(LeftBracket); + setState(453); + _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(452); + lambdaCapture(); + } + } + + setState(455); + match(RightBracket); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final LambdaCaptureContext lambdaCapture() throws RecognitionException { + LambdaCaptureContext _localctx = new LambdaCaptureContext(_ctx, getState()); + enterRule(_localctx, 16, RULE_lambdaCapture); + int _la; + try { + setState(463); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 14, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(457); + captureList(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(458); + captureDefault(); + setState(461); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Comma) { + { + setState(459); + match(Comma); + setState(460); + captureList(); + } + } + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final CaptureDefaultContext captureDefault() throws RecognitionException { + CaptureDefaultContext _localctx = new CaptureDefaultContext(_ctx, getState()); + enterRule(_localctx, 18, RULE_captureDefault); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(465); + _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 final CaptureListContext captureList() throws RecognitionException { + CaptureListContext _localctx = new CaptureListContext(_ctx, getState()); + enterRule(_localctx, 20, RULE_captureList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(467); + capture(); + setState(472); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == Comma) { + { + { + setState(468); + match(Comma); + setState(469); + capture(); + } + } + setState(474); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(476); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Ellipsis) { + { + setState(475); + match(Ellipsis); + } + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final CaptureContext capture() throws RecognitionException { + CaptureContext _localctx = new CaptureContext(_ctx, getState()); + enterRule(_localctx, 22, RULE_capture); + try { + setState(480); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 17, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(478); + simpleCapture(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(479); + initcapture(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final SimpleCaptureContext simpleCapture() throws RecognitionException { + SimpleCaptureContext _localctx = new SimpleCaptureContext(_ctx, getState()); + enterRule(_localctx, 24, RULE_simpleCapture); + int _la; + try { + setState(487); + _errHandler.sync(this); + switch (_input.LA(1)) { + case And: + case Identifier: + enterOuterAlt(_localctx, 1); + { + setState(483); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == And) { + { + setState(482); + match(And); + } + } + + setState(485); + match(Identifier); + } + break; + case This: + enterOuterAlt(_localctx, 2); + { + setState(486); + 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 final InitcaptureContext initcapture() throws RecognitionException { + InitcaptureContext _localctx = new InitcaptureContext(_ctx, getState()); + enterRule(_localctx, 26, RULE_initcapture); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(490); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == And) { + { + setState(489); + match(And); + } + } + + setState(492); + match(Identifier); + setState(493); + initializer(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final LambdaDeclaratorContext lambdaDeclarator() throws RecognitionException { + LambdaDeclaratorContext _localctx = new LambdaDeclaratorContext(_ctx, getState()); + enterRule(_localctx, 28, RULE_lambdaDeclarator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(495); + match(LeftParen); + setState(497); + _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(496); + parameterDeclarationClause(); + } + } + + setState(499); + match(RightParen); + setState(501); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Mutable) { + { + setState(500); + match(Mutable); + } + } + + setState(504); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Noexcept || _la == Throw) { + { + setState(503); + exceptionSpecification(); + } + } + + setState(507); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Alignas || _la == LeftBracket) { + { + setState(506); + attributeSpecifierSeq(); + } + } + + setState(510); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Arrow) { + { + setState(509); + trailingReturnType(); + } + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final PostfixExpressionContext postfixExpression() throws RecognitionException { + return postfixExpression(0); + } + + public final TypeIdOfTheTypeIdContext typeIdOfTheTypeId() throws RecognitionException { + TypeIdOfTheTypeIdContext _localctx = new TypeIdOfTheTypeIdContext(_ctx, getState()); + enterRule(_localctx, 32, RULE_typeIdOfTheTypeId); + try { + enterOuterAlt(_localctx, 1); + { + setState(574); + match(Typeid_); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ExpressionListContext expressionList() throws RecognitionException { + ExpressionListContext _localctx = new ExpressionListContext(_ctx, getState()); + enterRule(_localctx, 34, RULE_expressionList); + try { + enterOuterAlt(_localctx, 1); + { + setState(576); + initializerList(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final PseudoDestructorNameContext pseudoDestructorName() throws RecognitionException { + PseudoDestructorNameContext _localctx = new PseudoDestructorNameContext(_ctx, getState()); + enterRule(_localctx, 36, RULE_pseudoDestructorName); + int _la; + try { + setState(597); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 39, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(579); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 37, _ctx)) { + case 1: + { + setState(578); + nestedNameSpecifier(0); + } + break; + } + setState(584); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Identifier) { + { + setState(581); + theTypeName(); + setState(582); + match(Doublecolon); + } + } + + setState(586); + match(Tilde); + setState(587); + theTypeName(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(588); + nestedNameSpecifier(0); + setState(589); + match(Template); + setState(590); + simpleTemplateId(); + setState(591); + match(Doublecolon); + setState(592); + match(Tilde); + setState(593); + theTypeName(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(595); + match(Tilde); + setState(596); + decltypeSpecifier(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final UnaryExpressionContext unaryExpression() throws RecognitionException { + UnaryExpressionContext _localctx = new UnaryExpressionContext(_ctx, getState()); + enterRule(_localctx, 38, RULE_unaryExpression); + try { + setState(626); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 42, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(599); + postfixExpression(0); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(604); + _errHandler.sync(this); + switch (_input.LA(1)) { + case PlusPlus: + { + setState(600); + match(PlusPlus); + } + break; + case MinusMinus: + { + setState(601); + match(MinusMinus); + } + break; + case Plus: + case Minus: + case Star: + case And: + case Or: + case Tilde: + case Not: + { + setState(602); + unaryOperator(); + } + break; + case Sizeof: + { + setState(603); + match(Sizeof); + } + break; + default: + throw new NoViableAltException(this); + } + setState(606); + unaryExpression(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(607); + match(Sizeof); + setState(616); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LeftParen: + { + setState(608); + match(LeftParen); + setState(609); + theTypeId(); + setState(610); + match(RightParen); + } + break; + case Ellipsis: + { + setState(612); + match(Ellipsis); + setState(613); + match(LeftParen); + setState(614); + match(Identifier); + setState(615); + match(RightParen); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(618); + match(Alignof); + setState(619); + match(LeftParen); + setState(620); + theTypeId(); + setState(621); + match(RightParen); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(623); + noExceptExpression(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(624); + newExpression(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(625); + deleteExpression(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final UnaryOperatorContext unaryOperator() throws RecognitionException { + UnaryOperatorContext _localctx = new UnaryOperatorContext(_ctx, getState()); + enterRule(_localctx, 40, RULE_unaryOperator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(628); + _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 final NewExpressionContext newExpression() throws RecognitionException { + NewExpressionContext _localctx = new NewExpressionContext(_ctx, getState()); + enterRule(_localctx, 42, RULE_newExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(631); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Doublecolon) { + { + setState(630); + match(Doublecolon); + } + } + + setState(633); + match(New); + setState(635); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 44, _ctx)) { + case 1: + { + setState(634); + newPlacement(); + } + break; + } + setState(642); + _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(637); + newTypeId(); + } + break; + case LeftParen: + { + { + setState(638); + match(LeftParen); + setState(639); + theTypeId(); + setState(640); + match(RightParen); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(645); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == LeftParen || _la == LeftBrace) { + { + setState(644); + newInitializer(); + } + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final NewPlacementContext newPlacement() throws RecognitionException { + NewPlacementContext _localctx = new NewPlacementContext(_ctx, getState()); + enterRule(_localctx, 44, RULE_newPlacement); + try { + enterOuterAlt(_localctx, 1); + { + setState(647); + match(LeftParen); + setState(648); + expressionList(); + setState(649); + match(RightParen); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final NewTypeIdContext newTypeId() throws RecognitionException { + NewTypeIdContext _localctx = new NewTypeIdContext(_ctx, getState()); + enterRule(_localctx, 46, RULE_newTypeId); + try { + enterOuterAlt(_localctx, 1); + { + setState(651); + typeSpecifierSeq(); + setState(653); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 47, _ctx)) { + case 1: + { + setState(652); + newDeclarator(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final NewDeclaratorContext newDeclarator() throws RecognitionException { + NewDeclaratorContext _localctx = new NewDeclaratorContext(_ctx, getState()); + enterRule(_localctx, 48, RULE_newDeclarator); + try { + setState(660); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Decltype: + case Star: + case And: + case AndAnd: + case Doublecolon: + case Identifier: + enterOuterAlt(_localctx, 1); + { + setState(655); + pointerOperator(); + setState(657); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 48, _ctx)) { + case 1: + { + setState(656); + newDeclarator(); + } + break; + } + } + break; + case LeftBracket: + enterOuterAlt(_localctx, 2); + { + setState(659); + 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 final NoPointerNewDeclaratorContext noPointerNewDeclarator() throws RecognitionException { + return noPointerNewDeclarator(0); + } + + public final NewInitializerContext newInitializer() throws RecognitionException { + NewInitializerContext _localctx = new NewInitializerContext(_ctx, getState()); + enterRule(_localctx, 52, RULE_newInitializer); + int _la; + try { + setState(687); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LeftParen: + enterOuterAlt(_localctx, 1); + { + setState(681); + match(LeftParen); + setState(683); + _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(682); + expressionList(); + } + } + + setState(685); + match(RightParen); + } + break; + case LeftBrace: + enterOuterAlt(_localctx, 2); + { + setState(686); + 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 final DeleteExpressionContext deleteExpression() throws RecognitionException { + DeleteExpressionContext _localctx = new DeleteExpressionContext(_ctx, getState()); + enterRule(_localctx, 54, RULE_deleteExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(690); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Doublecolon) { + { + setState(689); + match(Doublecolon); + } + } + + setState(692); + match(Delete); + setState(695); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 56, _ctx)) { + case 1: + { + setState(693); + match(LeftBracket); + setState(694); + match(RightBracket); + } + break; + } + setState(697); + castExpression(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final NoExceptExpressionContext noExceptExpression() throws RecognitionException { + NoExceptExpressionContext _localctx = new NoExceptExpressionContext(_ctx, getState()); + enterRule(_localctx, 56, RULE_noExceptExpression); + try { + enterOuterAlt(_localctx, 1); + { + setState(699); + match(Noexcept); + setState(700); + match(LeftParen); + setState(701); + expression(); + setState(702); + match(RightParen); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final CastExpressionContext castExpression() throws RecognitionException { + CastExpressionContext _localctx = new CastExpressionContext(_ctx, getState()); + enterRule(_localctx, 58, RULE_castExpression); + try { + setState(710); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 57, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(704); + unaryExpression(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(705); + match(LeftParen); + setState(706); + theTypeId(); + setState(707); + match(RightParen); + setState(708); + castExpression(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final PointerMemberExpressionContext pointerMemberExpression() + throws RecognitionException { + PointerMemberExpressionContext _localctx = new PointerMemberExpressionContext(_ctx, getState()); + enterRule(_localctx, 60, RULE_pointerMemberExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(712); + castExpression(); + setState(717); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == ArrowStar || _la == DotStar) { + { + { + setState(713); + _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(714); + castExpression(); + } + } + setState(719); + _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 final MultiplicativeExpressionContext multiplicativeExpression() + throws RecognitionException { + MultiplicativeExpressionContext _localctx = + new MultiplicativeExpressionContext(_ctx, getState()); + enterRule(_localctx, 62, RULE_multiplicativeExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(720); + pointerMemberExpression(); + setState(725); + _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(721); + _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(722); + pointerMemberExpression(); + } + } + setState(727); + _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 final AdditiveExpressionContext additiveExpression() throws RecognitionException { + AdditiveExpressionContext _localctx = new AdditiveExpressionContext(_ctx, getState()); + enterRule(_localctx, 64, RULE_additiveExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(728); + multiplicativeExpression(); + setState(733); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == Plus || _la == Minus) { + { + { + setState(729); + _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(730); + multiplicativeExpression(); + } + } + setState(735); + _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 final ShiftExpressionContext shiftExpression() throws RecognitionException { + ShiftExpressionContext _localctx = new ShiftExpressionContext(_ctx, getState()); + enterRule(_localctx, 66, RULE_shiftExpression); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(736); + additiveExpression(); + setState(742); + _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(737); + shiftOperator(); + setState(738); + additiveExpression(); + } + } + } + setState(744); + _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 final ShiftOperatorContext shiftOperator() throws RecognitionException { + ShiftOperatorContext _localctx = new ShiftOperatorContext(_ctx, getState()); + enterRule(_localctx, 68, RULE_shiftOperator); + try { + setState(749); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Greater: + enterOuterAlt(_localctx, 1); + { + setState(745); + match(Greater); + setState(746); + match(Greater); + } + break; + case Less: + enterOuterAlt(_localctx, 2); + { + setState(747); + match(Less); + setState(748); + 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 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(751); + shiftExpression(); + setState(756); + _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(752); + _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(753); + shiftExpression(); + } + } + } + setState(758); + _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 final EqualityExpressionContext equalityExpression() throws RecognitionException { + EqualityExpressionContext _localctx = new EqualityExpressionContext(_ctx, getState()); + enterRule(_localctx, 72, RULE_equalityExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(759); + relationalExpression(); + setState(764); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == Equal || _la == NotEqual) { + { + { + setState(760); + _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(761); + relationalExpression(); + } + } + setState(766); + _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 final AndExpressionContext andExpression() throws RecognitionException { + AndExpressionContext _localctx = new AndExpressionContext(_ctx, getState()); + enterRule(_localctx, 74, RULE_andExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(767); + equalityExpression(); + setState(772); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == And) { + { + { + setState(768); + match(And); + setState(769); + equalityExpression(); + } + } + setState(774); + _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 final ExclusiveOrExpressionContext exclusiveOrExpression() throws RecognitionException { + ExclusiveOrExpressionContext _localctx = new ExclusiveOrExpressionContext(_ctx, getState()); + enterRule(_localctx, 76, RULE_exclusiveOrExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(775); + andExpression(); + setState(780); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == Caret) { + { + { + setState(776); + match(Caret); + setState(777); + andExpression(); + } + } + setState(782); + _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 final InclusiveOrExpressionContext inclusiveOrExpression() throws RecognitionException { + InclusiveOrExpressionContext _localctx = new InclusiveOrExpressionContext(_ctx, getState()); + enterRule(_localctx, 78, RULE_inclusiveOrExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(783); + exclusiveOrExpression(); + setState(788); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == Or) { + { + { + setState(784); + match(Or); + setState(785); + exclusiveOrExpression(); + } + } + setState(790); + _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 final LogicalAndExpressionContext logicalAndExpression() throws RecognitionException { + LogicalAndExpressionContext _localctx = new LogicalAndExpressionContext(_ctx, getState()); + enterRule(_localctx, 80, RULE_logicalAndExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(791); + inclusiveOrExpression(); + setState(796); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == AndAnd) { + { + { + setState(792); + match(AndAnd); + setState(793); + inclusiveOrExpression(); + } + } + setState(798); + _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 final LogicalOrExpressionContext logicalOrExpression() throws RecognitionException { + LogicalOrExpressionContext _localctx = new LogicalOrExpressionContext(_ctx, getState()); + enterRule(_localctx, 82, RULE_logicalOrExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(799); + logicalAndExpression(); + setState(804); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == OrOr) { + { + { + setState(800); + match(OrOr); + setState(801); + logicalAndExpression(); + } + } + setState(806); + _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 final ConditionalExpressionContext conditionalExpression() throws RecognitionException { + ConditionalExpressionContext _localctx = new ConditionalExpressionContext(_ctx, getState()); + enterRule(_localctx, 84, RULE_conditionalExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(807); + logicalOrExpression(); + setState(813); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Question) { + { + setState(808); + match(Question); + setState(809); + expression(); + setState(810); + match(Colon); + setState(811); + assignmentExpression(); + } + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final AssignmentExpressionContext assignmentExpression() throws RecognitionException { + AssignmentExpressionContext _localctx = new AssignmentExpressionContext(_ctx, getState()); + enterRule(_localctx, 86, RULE_assignmentExpression); + try { + setState(821); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 71, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(815); + conditionalExpression(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(816); + logicalOrExpression(); + setState(817); + assignmentOperator(); + setState(818); + initializerClause(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(820); + throwExpression(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final AssignmentOperatorContext assignmentOperator() throws RecognitionException { + AssignmentOperatorContext _localctx = new AssignmentOperatorContext(_ctx, getState()); + enterRule(_localctx, 88, RULE_assignmentOperator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(823); + _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 final ExpressionContext expression() throws RecognitionException { + ExpressionContext _localctx = new ExpressionContext(_ctx, getState()); + enterRule(_localctx, 90, RULE_expression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(825); + assignmentExpression(); + setState(830); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == Comma) { + { + { + setState(826); + match(Comma); + setState(827); + assignmentExpression(); + } + } + setState(832); + _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 final ConstantExpressionContext constantExpression() throws RecognitionException { + ConstantExpressionContext _localctx = new ConstantExpressionContext(_ctx, getState()); + enterRule(_localctx, 92, RULE_constantExpression); + try { + enterOuterAlt(_localctx, 1); + { + setState(833); + conditionalExpression(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final StatementContext statement() throws RecognitionException { + StatementContext _localctx = new StatementContext(_ctx, getState()); + enterRule(_localctx, 94, RULE_statement); + try { + setState(848); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 75, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(835); + labeledStatement(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(836); + declarationStatement(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(838); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 73, _ctx)) { + case 1: + { + setState(837); + attributeSpecifierSeq(); + } + break; + } + setState(846); + _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(840); + expressionStatement(); + } + break; + case LeftBrace: + { + setState(841); + compoundStatement(); + } + break; + case If: + case Switch: + { + setState(842); + selectionStatement(); + } + break; + case Do: + case For: + case While: + { + setState(843); + iterationStatement(); + } + break; + case Break: + case Continue: + case Goto: + case Return: + { + setState(844); + jumpStatement(); + } + break; + case Try: + { + setState(845); + tryBlock(); + } + 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 final LabeledStatementContext labeledStatement() throws RecognitionException { + LabeledStatementContext _localctx = new LabeledStatementContext(_ctx, getState()); + enterRule(_localctx, 96, RULE_labeledStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(851); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Alignas || _la == LeftBracket) { + { + setState(850); + attributeSpecifierSeq(); + } + } + + setState(857); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Identifier: + { + setState(853); + match(Identifier); + } + break; + case Case: + { + setState(854); + match(Case); + setState(855); + constantExpression(); + } + break; + case Default: + { + setState(856); + match(Default); + } + break; + default: + throw new NoViableAltException(this); + } + setState(859); + match(Colon); + setState(860); + statement(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ExpressionStatementContext expressionStatement() throws RecognitionException { + ExpressionStatementContext _localctx = new ExpressionStatementContext(_ctx, getState()); + enterRule(_localctx, 98, RULE_expressionStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(863); + _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(862); + expression(); + } + } + + setState(865); + match(Semi); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final CompoundStatementContext compoundStatement() throws RecognitionException { + CompoundStatementContext _localctx = new CompoundStatementContext(_ctx, getState()); + enterRule(_localctx, 100, RULE_compoundStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(867); + match(LeftBrace); + setState(869); + _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(868); + statementSeq(); + } + } + + setState(871); + match(RightBrace); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final StatementSeqContext statementSeq() throws RecognitionException { + StatementSeqContext _localctx = new StatementSeqContext(_ctx, getState()); + enterRule(_localctx, 102, RULE_statementSeq); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(874); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(873); + statement(); + } + } + setState(876); + _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 final SelectionStatementContext selectionStatement() throws RecognitionException { + SelectionStatementContext _localctx = new SelectionStatementContext(_ctx, getState()); + enterRule(_localctx, 104, RULE_selectionStatement); + try { + setState(893); + _errHandler.sync(this); + switch (_input.LA(1)) { + case If: + enterOuterAlt(_localctx, 1); + { + setState(878); + match(If); + setState(879); + match(LeftParen); + setState(880); + condition(); + setState(881); + match(RightParen); + setState(882); + statement(); + setState(885); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 81, _ctx)) { + case 1: + { + setState(883); + match(Else); + setState(884); + statement(); + } + break; + } + } + break; + case Switch: + enterOuterAlt(_localctx, 2); + { + setState(887); + match(Switch); + setState(888); + match(LeftParen); + setState(889); + condition(); + setState(890); + match(RightParen); + setState(891); + 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 final ConditionContext condition() throws RecognitionException { + ConditionContext _localctx = new ConditionContext(_ctx, getState()); + enterRule(_localctx, 106, RULE_condition); + int _la; + try { + setState(906); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 85, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(895); + expression(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(897); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Alignas || _la == LeftBracket) { + { + setState(896); + attributeSpecifierSeq(); + } + } + + setState(899); + declSpecifierSeq(); + setState(900); + declarator(); + setState(904); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Assign: + { + setState(901); + match(Assign); + setState(902); + initializerClause(); + } + break; + case LeftBrace: + { + setState(903); + 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 final IterationStatementContext iterationStatement() throws RecognitionException { + IterationStatementContext _localctx = new IterationStatementContext(_ctx, getState()); + enterRule(_localctx, 108, RULE_iterationStatement); + int _la; + try { + setState(941); + _errHandler.sync(this); + switch (_input.LA(1)) { + case While: + enterOuterAlt(_localctx, 1); + { + setState(908); + match(While); + setState(909); + match(LeftParen); + setState(910); + condition(); + setState(911); + match(RightParen); + setState(912); + statement(); + } + break; + case Do: + enterOuterAlt(_localctx, 2); + { + setState(914); + match(Do); + setState(915); + statement(); + setState(916); + match(While); + setState(917); + match(LeftParen); + setState(918); + expression(); + setState(919); + match(RightParen); + setState(920); + match(Semi); + } + break; + case For: + enterOuterAlt(_localctx, 3); + { + setState(922); + match(For); + setState(923); + match(LeftParen); + setState(936); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 88, _ctx)) { + case 1: + { + setState(924); + forInitStatement(); + 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 << 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(925); + condition(); + } + } + + setState(928); + match(Semi); + setState(930); + _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(929); + expression(); + } + } + } + break; + case 2: + { + setState(932); + forRangeDeclaration(); + setState(933); + match(Colon); + setState(934); + forRangeInitializer(); + } + break; + } + setState(938); + match(RightParen); + setState(939); + 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 final ForInitStatementContext forInitStatement() throws RecognitionException { + ForInitStatementContext _localctx = new ForInitStatementContext(_ctx, getState()); + enterRule(_localctx, 110, RULE_forInitStatement); + try { + setState(945); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 90, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(943); + expressionStatement(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(944); + simpleDeclaration(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ForRangeDeclarationContext forRangeDeclaration() throws RecognitionException { + ForRangeDeclarationContext _localctx = new ForRangeDeclarationContext(_ctx, getState()); + enterRule(_localctx, 112, RULE_forRangeDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(948); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Alignas || _la == LeftBracket) { + { + setState(947); + attributeSpecifierSeq(); + } + } + + setState(950); + declSpecifierSeq(); + setState(951); + declarator(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ForRangeInitializerContext forRangeInitializer() throws RecognitionException { + ForRangeInitializerContext _localctx = new ForRangeInitializerContext(_ctx, getState()); + enterRule(_localctx, 114, RULE_forRangeInitializer); + try { + setState(955); + _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(953); + expression(); + } + break; + case LeftBrace: + enterOuterAlt(_localctx, 2); + { + setState(954); + 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 final JumpStatementContext jumpStatement() throws RecognitionException { + JumpStatementContext _localctx = new JumpStatementContext(_ctx, getState()); + enterRule(_localctx, 116, RULE_jumpStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(966); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Break: + { + setState(957); + match(Break); + } + break; + case Continue: + { + setState(958); + match(Continue); + } + break; + case Return: + { + setState(959); + match(Return); + setState(962); + _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(960); + expression(); + } + break; + case LeftBrace: + { + setState(961); + bracedInitList(); + } + break; + case Semi: + break; + default: + break; + } + } + break; + case Goto: + { + setState(964); + match(Goto); + setState(965); + match(Identifier); + } + break; + default: + throw new NoViableAltException(this); + } + setState(968); + match(Semi); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final DeclarationStatementContext declarationStatement() throws RecognitionException { + DeclarationStatementContext _localctx = new DeclarationStatementContext(_ctx, getState()); + enterRule(_localctx, 118, RULE_declarationStatement); + try { + enterOuterAlt(_localctx, 1); + { + setState(970); + blockDeclaration(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final DeclarationseqContext declarationseq() throws RecognitionException { + DeclarationseqContext _localctx = new DeclarationseqContext(_ctx, getState()); + enterRule(_localctx, 120, RULE_declarationseq); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(973); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(972); + declaration(); + } + } + setState(975); + _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 final DeclarationContext declaration() throws RecognitionException { + DeclarationContext _localctx = new DeclarationContext(_ctx, getState()); + enterRule(_localctx, 122, RULE_declaration); + try { + setState(986); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 96, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(977); + blockDeclaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(978); + functionDefinition(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(979); + templateDeclaration(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(980); + explicitInstantiation(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(981); + explicitSpecialization(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(982); + linkageSpecification(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(983); + namespaceDefinition(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(984); + emptyDeclaration(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(985); + attributeDeclaration(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final BlockDeclarationContext blockDeclaration() throws RecognitionException { + BlockDeclarationContext _localctx = new BlockDeclarationContext(_ctx, getState()); + enterRule(_localctx, 124, RULE_blockDeclaration); + try { + setState(996); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 97, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(988); + simpleDeclaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(989); + asmDefinition(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(990); + namespaceAliasDefinition(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(991); + usingDeclaration(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(992); + usingDirective(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(993); + staticAssertDeclaration(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(994); + aliasDeclaration(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(995); + opaqueEnumDeclaration(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final AliasDeclarationContext aliasDeclaration() throws RecognitionException { + AliasDeclarationContext _localctx = new AliasDeclarationContext(_ctx, getState()); + enterRule(_localctx, 126, RULE_aliasDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(998); + match(Using); + setState(999); + match(Identifier); + setState(1001); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Alignas || _la == LeftBracket) { + { + setState(1000); + attributeSpecifierSeq(); + } + } + + setState(1003); + match(Assign); + setState(1004); + theTypeId(); + setState(1005); + match(Semi); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final SimpleDeclarationContext simpleDeclaration() throws RecognitionException { + SimpleDeclarationContext _localctx = new SimpleDeclarationContext(_ctx, getState()); + enterRule(_localctx, 128, RULE_simpleDeclaration); + int _la; + try { + setState(1021); + _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(1008); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 99, _ctx)) { + case 1: + { + setState(1007); + declSpecifierSeq(); + } + break; + } + setState(1011); + _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(1010); + initDeclaratorList(); + } + } + + setState(1013); + match(Semi); + } + break; + case Alignas: + case LeftBracket: + enterOuterAlt(_localctx, 2); + { + setState(1014); + attributeSpecifierSeq(); + setState(1016); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 101, _ctx)) { + case 1: + { + setState(1015); + declSpecifierSeq(); + } + break; + } + setState(1018); + initDeclaratorList(); + setState(1019); + 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 final StaticAssertDeclarationContext staticAssertDeclaration() + throws RecognitionException { + StaticAssertDeclarationContext _localctx = new StaticAssertDeclarationContext(_ctx, getState()); + enterRule(_localctx, 130, RULE_staticAssertDeclaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(1023); + match(Static_assert); + setState(1024); + match(LeftParen); + setState(1025); + constantExpression(); + setState(1026); + match(Comma); + setState(1027); + match(StringLiteral); + setState(1028); + match(RightParen); + setState(1029); + match(Semi); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final EmptyDeclarationContext emptyDeclaration() throws RecognitionException { + EmptyDeclarationContext _localctx = new EmptyDeclarationContext(_ctx, getState()); + enterRule(_localctx, 132, RULE_emptyDeclaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(1031); + match(Semi); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final AttributeDeclarationContext attributeDeclaration() throws RecognitionException { + AttributeDeclarationContext _localctx = new AttributeDeclarationContext(_ctx, getState()); + enterRule(_localctx, 134, RULE_attributeDeclaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(1033); + attributeSpecifierSeq(); + setState(1034); + match(Semi); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final DeclSpecifierContext declSpecifier() throws RecognitionException { + DeclSpecifierContext _localctx = new DeclSpecifierContext(_ctx, getState()); + enterRule(_localctx, 136, RULE_declSpecifier); + try { + setState(1042); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Extern: + case Mutable: + case Register: + case Static: + case Thread_local: + enterOuterAlt(_localctx, 1); + { + setState(1036); + 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(1037); + typeSpecifier(); + } + break; + case Explicit: + case Inline: + case Virtual: + enterOuterAlt(_localctx, 3); + { + setState(1038); + functionSpecifier(); + } + break; + case Friend: + enterOuterAlt(_localctx, 4); + { + setState(1039); + match(Friend); + } + break; + case Typedef: + enterOuterAlt(_localctx, 5); + { + setState(1040); + match(Typedef); + } + break; + case Constexpr: + enterOuterAlt(_localctx, 6); + { + setState(1041); + 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 final DeclSpecifierSeqContext declSpecifierSeq() throws RecognitionException { + DeclSpecifierSeqContext _localctx = new DeclSpecifierSeqContext(_ctx, getState()); + enterRule(_localctx, 138, RULE_declSpecifierSeq); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1045); + _errHandler.sync(this); + _alt = 1 + 1; + do { + switch (_alt) { + case 1 + 1: + { + { + setState(1044); + declSpecifier(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1047); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 104, _ctx); + } while (_alt != 1 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER); + setState(1050); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 105, _ctx)) { + case 1: + { + setState(1049); + attributeSpecifierSeq(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final StorageClassSpecifierContext storageClassSpecifier() throws RecognitionException { + StorageClassSpecifierContext _localctx = new StorageClassSpecifierContext(_ctx, getState()); + enterRule(_localctx, 140, RULE_storageClassSpecifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1052); + _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 final FunctionSpecifierContext functionSpecifier() throws RecognitionException { + FunctionSpecifierContext _localctx = new FunctionSpecifierContext(_ctx, getState()); + enterRule(_localctx, 142, RULE_functionSpecifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1054); + _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 final TypedefNameContext typedefName() throws RecognitionException { + TypedefNameContext _localctx = new TypedefNameContext(_ctx, getState()); + enterRule(_localctx, 144, RULE_typedefName); + try { + enterOuterAlt(_localctx, 1); + { + setState(1056); + match(Identifier); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final TypeSpecifierContext typeSpecifier() throws RecognitionException { + TypeSpecifierContext _localctx = new TypeSpecifierContext(_ctx, getState()); + enterRule(_localctx, 146, RULE_typeSpecifier); + try { + setState(1061); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 106, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1058); + trailingTypeSpecifier(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1059); + classSpecifier(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1060); + enumSpecifier(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final TrailingTypeSpecifierContext trailingTypeSpecifier() throws RecognitionException { + TrailingTypeSpecifierContext _localctx = new TrailingTypeSpecifierContext(_ctx, getState()); + enterRule(_localctx, 148, RULE_trailingTypeSpecifier); + try { + setState(1067); + _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(1063); + simpleTypeSpecifier(); + } + break; + case Class: + case Enum: + case Struct: + enterOuterAlt(_localctx, 2); + { + setState(1064); + elaboratedTypeSpecifier(); + } + break; + case Typename_: + enterOuterAlt(_localctx, 3); + { + setState(1065); + typeNameSpecifier(); + } + break; + case Const: + case Volatile: + enterOuterAlt(_localctx, 4); + { + setState(1066); + 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 final TypeSpecifierSeqContext typeSpecifierSeq() throws RecognitionException { + TypeSpecifierSeqContext _localctx = new TypeSpecifierSeqContext(_ctx, getState()); + enterRule(_localctx, 150, RULE_typeSpecifierSeq); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1070); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(1069); + typeSpecifier(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1072); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 108, _ctx); + } while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER); + setState(1075); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 109, _ctx)) { + case 1: + { + setState(1074); + attributeSpecifierSeq(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final TrailingTypeSpecifierSeqContext trailingTypeSpecifierSeq() + throws RecognitionException { + TrailingTypeSpecifierSeqContext _localctx = + new TrailingTypeSpecifierSeqContext(_ctx, getState()); + enterRule(_localctx, 152, RULE_trailingTypeSpecifierSeq); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1078); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(1077); + trailingTypeSpecifier(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1080); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 110, _ctx); + } while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER); + setState(1083); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 111, _ctx)) { + case 1: + { + setState(1082); + attributeSpecifierSeq(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final SimpleTypeLengthModifierContext simpleTypeLengthModifier() + throws RecognitionException { + SimpleTypeLengthModifierContext _localctx = + new SimpleTypeLengthModifierContext(_ctx, getState()); + enterRule(_localctx, 154, RULE_simpleTypeLengthModifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1085); + _la = _input.LA(1); + if (!(_la == Long || _la == Short)) { + _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 final SimpleTypeSignednessModifierContext simpleTypeSignednessModifier() + throws RecognitionException { + SimpleTypeSignednessModifierContext _localctx = + new SimpleTypeSignednessModifierContext(_ctx, getState()); + enterRule(_localctx, 156, RULE_simpleTypeSignednessModifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1087); + _la = _input.LA(1); + if (!(_la == Signed || _la == Unsigned)) { + _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 final SimpleTypeSpecifierContext simpleTypeSpecifier() throws RecognitionException { + SimpleTypeSpecifierContext _localctx = new SimpleTypeSpecifierContext(_ctx, getState()); + enterRule(_localctx, 158, RULE_simpleTypeSpecifier); + int _la; + try { + int _alt; + setState(1141); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 122, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1090); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 112, _ctx)) { + case 1: + { + setState(1089); + nestedNameSpecifier(0); + } + break; + } + setState(1092); + theTypeName(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1093); + nestedNameSpecifier(0); + setState(1094); + match(Template); + setState(1095); + simpleTemplateId(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1097); + simpleTypeSignednessModifier(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1099); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Signed || _la == Unsigned) { + { + setState(1098); + simpleTypeSignednessModifier(); + } + } + + setState(1102); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(1101); + simpleTypeLengthModifier(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1104); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 114, _ctx); + } while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1107); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Signed || _la == Unsigned) { + { + setState(1106); + simpleTypeSignednessModifier(); + } + } + + setState(1109); + match(Char); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1111); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Signed || _la == Unsigned) { + { + setState(1110); + simpleTypeSignednessModifier(); + } + } + + setState(1113); + match(Char16); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(1115); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Signed || _la == Unsigned) { + { + setState(1114); + simpleTypeSignednessModifier(); + } + } + + setState(1117); + match(Char32); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(1119); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Signed || _la == Unsigned) { + { + setState(1118); + simpleTypeSignednessModifier(); + } + } + + setState(1121); + match(Wchar); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(1122); + match(Bool); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(1124); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Signed || _la == Unsigned) { + { + setState(1123); + simpleTypeSignednessModifier(); + } + } + + setState(1129); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == Long || _la == Short) { + { + { + setState(1126); + simpleTypeLengthModifier(); + } + } + setState(1131); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1132); + match(Int); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(1133); + match(Float); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(1135); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Long || _la == Short) { + { + setState(1134); + simpleTypeLengthModifier(); + } + } + + setState(1137); + match(Double); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(1138); + match(Void); + } + break; + case 14: + enterOuterAlt(_localctx, 14); + { + setState(1139); + match(Auto); + } + break; + case 15: + enterOuterAlt(_localctx, 15); + { + setState(1140); + decltypeSpecifier(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final TheTypeNameContext theTypeName() throws RecognitionException { + TheTypeNameContext _localctx = new TheTypeNameContext(_ctx, getState()); + enterRule(_localctx, 160, RULE_theTypeName); + try { + setState(1147); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 123, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1143); + className(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1144); + enumName(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1145); + typedefName(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1146); + simpleTemplateId(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final DecltypeSpecifierContext decltypeSpecifier() throws RecognitionException { + DecltypeSpecifierContext _localctx = new DecltypeSpecifierContext(_ctx, getState()); + enterRule(_localctx, 162, RULE_decltypeSpecifier); + try { + enterOuterAlt(_localctx, 1); + { + setState(1149); + match(Decltype); + setState(1150); + match(LeftParen); + setState(1153); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 124, _ctx)) { + case 1: + { + setState(1151); + expression(); + } + break; + case 2: + { + setState(1152); + match(Auto); + } + break; + } + setState(1155); + match(RightParen); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ElaboratedTypeSpecifierContext elaboratedTypeSpecifier() + throws RecognitionException { + ElaboratedTypeSpecifierContext _localctx = new ElaboratedTypeSpecifierContext(_ctx, getState()); + enterRule(_localctx, 164, RULE_elaboratedTypeSpecifier); + int _la; + try { + setState(1179); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Class: + case Struct: + enterOuterAlt(_localctx, 1); + { + setState(1157); + classKey(); + setState(1172); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 128, _ctx)) { + case 1: + { + setState(1159); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Alignas || _la == LeftBracket) { + { + setState(1158); + attributeSpecifierSeq(); + } + } + + setState(1162); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 126, _ctx)) { + case 1: + { + setState(1161); + nestedNameSpecifier(0); + } + break; + } + setState(1164); + match(Identifier); + } + break; + case 2: + { + setState(1165); + simpleTemplateId(); + } + break; + case 3: + { + setState(1166); + nestedNameSpecifier(0); + setState(1168); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Template) { + { + setState(1167); + match(Template); + } + } + + setState(1170); + simpleTemplateId(); + } + break; + } + } + break; + case Enum: + enterOuterAlt(_localctx, 2); + { + setState(1174); + match(Enum); + setState(1176); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 129, _ctx)) { + case 1: + { + setState(1175); + nestedNameSpecifier(0); + } + break; + } + setState(1178); + 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 final EnumNameContext enumName() throws RecognitionException { + EnumNameContext _localctx = new EnumNameContext(_ctx, getState()); + enterRule(_localctx, 166, RULE_enumName); + try { + enterOuterAlt(_localctx, 1); + { + setState(1181); + match(Identifier); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final EnumSpecifierContext enumSpecifier() throws RecognitionException { + EnumSpecifierContext _localctx = new EnumSpecifierContext(_ctx, getState()); + enterRule(_localctx, 168, RULE_enumSpecifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1183); + enumHead(); + setState(1184); + match(LeftBrace); + setState(1189); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Identifier) { + { + setState(1185); + enumeratorList(); + setState(1187); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Comma) { + { + setState(1186); + match(Comma); + } + } + } + } + + setState(1191); + match(RightBrace); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final EnumHeadContext enumHead() throws RecognitionException { + EnumHeadContext _localctx = new EnumHeadContext(_ctx, getState()); + enterRule(_localctx, 170, RULE_enumHead); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1193); + enumkey(); + setState(1195); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Alignas || _la == LeftBracket) { + { + setState(1194); + attributeSpecifierSeq(); + } + } + + setState(1201); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Decltype || _la == Doublecolon || _la == Identifier) { + { + setState(1198); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 134, _ctx)) { + case 1: + { + setState(1197); + nestedNameSpecifier(0); + } + break; + } + setState(1200); + match(Identifier); + } + } + + setState(1204); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Colon) { + { + setState(1203); + enumbase(); + } + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final OpaqueEnumDeclarationContext opaqueEnumDeclaration() throws RecognitionException { + OpaqueEnumDeclarationContext _localctx = new OpaqueEnumDeclarationContext(_ctx, getState()); + enterRule(_localctx, 172, RULE_opaqueEnumDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1206); + enumkey(); + setState(1208); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Alignas || _la == LeftBracket) { + { + setState(1207); + attributeSpecifierSeq(); + } + } + + setState(1210); + match(Identifier); + setState(1212); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Colon) { + { + setState(1211); + enumbase(); + } + } + + setState(1214); + match(Semi); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final EnumkeyContext enumkey() throws RecognitionException { + EnumkeyContext _localctx = new EnumkeyContext(_ctx, getState()); + enterRule(_localctx, 174, RULE_enumkey); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1216); + match(Enum); + setState(1218); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Class || _la == Struct) { + { + setState(1217); + _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 final EnumbaseContext enumbase() throws RecognitionException { + EnumbaseContext _localctx = new EnumbaseContext(_ctx, getState()); + enterRule(_localctx, 176, RULE_enumbase); + try { + enterOuterAlt(_localctx, 1); + { + setState(1220); + match(Colon); + setState(1221); + typeSpecifierSeq(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final EnumeratorListContext enumeratorList() throws RecognitionException { + EnumeratorListContext _localctx = new EnumeratorListContext(_ctx, getState()); + enterRule(_localctx, 178, RULE_enumeratorList); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1223); + enumeratorDefinition(); + setState(1228); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 140, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1224); + match(Comma); + setState(1225); + enumeratorDefinition(); + } + } + } + setState(1230); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 140, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final EnumeratorDefinitionContext enumeratorDefinition() throws RecognitionException { + EnumeratorDefinitionContext _localctx = new EnumeratorDefinitionContext(_ctx, getState()); + enterRule(_localctx, 180, RULE_enumeratorDefinition); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1231); + enumerator(); + setState(1234); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Assign) { + { + setState(1232); + match(Assign); + setState(1233); + constantExpression(); + } + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final EnumeratorContext enumerator() throws RecognitionException { + EnumeratorContext _localctx = new EnumeratorContext(_ctx, getState()); + enterRule(_localctx, 182, RULE_enumerator); + try { + enterOuterAlt(_localctx, 1); + { + setState(1236); + match(Identifier); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final NamespaceNameContext namespaceName() throws RecognitionException { + NamespaceNameContext _localctx = new NamespaceNameContext(_ctx, getState()); + enterRule(_localctx, 184, RULE_namespaceName); + try { + setState(1240); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 142, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1238); + originalNamespaceName(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1239); + namespaceAlias(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final OriginalNamespaceNameContext originalNamespaceName() throws RecognitionException { + OriginalNamespaceNameContext _localctx = new OriginalNamespaceNameContext(_ctx, getState()); + enterRule(_localctx, 186, RULE_originalNamespaceName); + try { + enterOuterAlt(_localctx, 1); + { + setState(1242); + match(Identifier); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final NamespaceDefinitionContext namespaceDefinition() throws RecognitionException { + NamespaceDefinitionContext _localctx = new NamespaceDefinitionContext(_ctx, getState()); + enterRule(_localctx, 188, RULE_namespaceDefinition); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1245); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Inline) { + { + setState(1244); + match(Inline); + } + } + + setState(1247); + match(Namespace); + setState(1250); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 144, _ctx)) { + case 1: + { + setState(1248); + match(Identifier); + } + break; + case 2: + { + setState(1249); + originalNamespaceName(); + } + break; + } + setState(1252); + match(LeftBrace); + setState(1254); + _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(1253); + ((NamespaceDefinitionContext) _localctx).namespaceBody = declarationseq(); + } + } + + setState(1256); + match(RightBrace); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final NamespaceAliasContext namespaceAlias() throws RecognitionException { + NamespaceAliasContext _localctx = new NamespaceAliasContext(_ctx, getState()); + enterRule(_localctx, 190, RULE_namespaceAlias); + try { + enterOuterAlt(_localctx, 1); + { + setState(1258); + match(Identifier); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final NamespaceAliasDefinitionContext namespaceAliasDefinition() + throws RecognitionException { + NamespaceAliasDefinitionContext _localctx = + new NamespaceAliasDefinitionContext(_ctx, getState()); + enterRule(_localctx, 192, RULE_namespaceAliasDefinition); + try { + enterOuterAlt(_localctx, 1); + { + setState(1260); + match(Namespace); + setState(1261); + match(Identifier); + setState(1262); + match(Assign); + setState(1263); + qualifiednamespacespecifier(); + setState(1264); + match(Semi); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final QualifiednamespacespecifierContext qualifiednamespacespecifier() + throws RecognitionException { + QualifiednamespacespecifierContext _localctx = + new QualifiednamespacespecifierContext(_ctx, getState()); + enterRule(_localctx, 194, RULE_qualifiednamespacespecifier); + try { + enterOuterAlt(_localctx, 1); + { + setState(1267); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 146, _ctx)) { + case 1: + { + setState(1266); + nestedNameSpecifier(0); + } + break; + } + setState(1269); + namespaceName(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final UsingDeclarationContext usingDeclaration() throws RecognitionException { + UsingDeclarationContext _localctx = new UsingDeclarationContext(_ctx, getState()); + enterRule(_localctx, 196, RULE_usingDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1271); + match(Using); + setState(1277); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 148, _ctx)) { + case 1: + { + { + setState(1273); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Typename_) { + { + setState(1272); + match(Typename_); + } + } + + setState(1275); + nestedNameSpecifier(0); + } + } + break; + case 2: + { + setState(1276); + match(Doublecolon); + } + break; + } + setState(1279); + unqualifiedId(); + setState(1280); + match(Semi); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final UsingDirectiveContext usingDirective() throws RecognitionException { + UsingDirectiveContext _localctx = new UsingDirectiveContext(_ctx, getState()); + enterRule(_localctx, 198, RULE_usingDirective); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1283); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Alignas || _la == LeftBracket) { + { + setState(1282); + attributeSpecifierSeq(); + } + } + + setState(1285); + match(Using); + setState(1286); + match(Namespace); + setState(1288); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 150, _ctx)) { + case 1: + { + setState(1287); + nestedNameSpecifier(0); + } + break; + } + setState(1290); + namespaceName(); + setState(1291); + match(Semi); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final AsmDefinitionContext asmDefinition() throws RecognitionException { + AsmDefinitionContext _localctx = new AsmDefinitionContext(_ctx, getState()); + enterRule(_localctx, 200, RULE_asmDefinition); + try { + enterOuterAlt(_localctx, 1); + { + setState(1293); + match(Asm); + setState(1294); + match(LeftParen); + setState(1295); + match(StringLiteral); + setState(1296); + match(RightParen); + setState(1297); + match(Semi); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final LinkageSpecificationContext linkageSpecification() throws RecognitionException { + LinkageSpecificationContext _localctx = new LinkageSpecificationContext(_ctx, getState()); + enterRule(_localctx, 202, RULE_linkageSpecification); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1299); + match(Extern); + setState(1300); + match(StringLiteral); + setState(1307); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LeftBrace: + { + setState(1301); + match(LeftBrace); + setState(1303); + _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(1302); + declarationseq(); + } + } + + setState(1305); + 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(1306); + 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 final AttributeSpecifierSeqContext attributeSpecifierSeq() throws RecognitionException { + AttributeSpecifierSeqContext _localctx = new AttributeSpecifierSeqContext(_ctx, getState()); + enterRule(_localctx, 204, RULE_attributeSpecifierSeq); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1310); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(1309); + attributeSpecifier(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1312); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 153, _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 final AttributeSpecifierContext attributeSpecifier() throws RecognitionException { + AttributeSpecifierContext _localctx = new AttributeSpecifierContext(_ctx, getState()); + enterRule(_localctx, 206, RULE_attributeSpecifier); + int _la; + try { + setState(1322); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LeftBracket: + enterOuterAlt(_localctx, 1); + { + setState(1314); + match(LeftBracket); + setState(1315); + match(LeftBracket); + setState(1317); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Identifier) { + { + setState(1316); + attributeList(); + } + } + + setState(1319); + match(RightBracket); + setState(1320); + match(RightBracket); + } + break; + case Alignas: + enterOuterAlt(_localctx, 2); + { + setState(1321); + 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 final AlignmentspecifierContext alignmentspecifier() throws RecognitionException { + AlignmentspecifierContext _localctx = new AlignmentspecifierContext(_ctx, getState()); + enterRule(_localctx, 208, RULE_alignmentspecifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1324); + match(Alignas); + setState(1325); + match(LeftParen); + setState(1328); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 156, _ctx)) { + case 1: + { + setState(1326); + theTypeId(); + } + break; + case 2: + { + setState(1327); + constantExpression(); + } + break; + } + setState(1331); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Ellipsis) { + { + setState(1330); + match(Ellipsis); + } + } + + setState(1333); + match(RightParen); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final AttributeListContext attributeList() throws RecognitionException { + AttributeListContext _localctx = new AttributeListContext(_ctx, getState()); + enterRule(_localctx, 210, RULE_attributeList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1335); + attribute(); + setState(1340); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == Comma) { + { + { + setState(1336); + match(Comma); + setState(1337); + attribute(); + } + } + setState(1342); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1344); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Ellipsis) { + { + setState(1343); + match(Ellipsis); + } + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final AttributeContext attribute() throws RecognitionException { + AttributeContext _localctx = new AttributeContext(_ctx, getState()); + enterRule(_localctx, 212, RULE_attribute); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1349); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 160, _ctx)) { + case 1: + { + setState(1346); + attributeNamespace(); + setState(1347); + match(Doublecolon); + } + break; + } + setState(1351); + match(Identifier); + setState(1353); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == LeftParen) { + { + setState(1352); + attributeArgumentClause(); + } + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final AttributeNamespaceContext attributeNamespace() throws RecognitionException { + AttributeNamespaceContext _localctx = new AttributeNamespaceContext(_ctx, getState()); + enterRule(_localctx, 214, RULE_attributeNamespace); + try { + enterOuterAlt(_localctx, 1); + { + setState(1355); + match(Identifier); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final AttributeArgumentClauseContext attributeArgumentClause() + throws RecognitionException { + AttributeArgumentClauseContext _localctx = new AttributeArgumentClauseContext(_ctx, getState()); + enterRule(_localctx, 216, RULE_attributeArgumentClause); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1357); + match(LeftParen); + setState(1359); + _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(1358); + balancedTokenSeq(); + } + } + + setState(1361); + match(RightParen); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final BalancedTokenSeqContext balancedTokenSeq() throws RecognitionException { + BalancedTokenSeqContext _localctx = new BalancedTokenSeqContext(_ctx, getState()); + enterRule(_localctx, 218, RULE_balancedTokenSeq); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1364); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1363); + balancedtoken(); + } + } + setState(1366); + _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 final BalancedtokenContext balancedtoken() throws RecognitionException { + BalancedtokenContext _localctx = new BalancedtokenContext(_ctx, getState()); + enterRule(_localctx, 220, RULE_balancedtoken); + int _la; + try { + int _alt; + setState(1385); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LeftParen: + enterOuterAlt(_localctx, 1); + { + setState(1368); + match(LeftParen); + setState(1369); + balancedTokenSeq(); + setState(1370); + match(RightParen); + } + break; + case LeftBracket: + enterOuterAlt(_localctx, 2); + { + setState(1372); + match(LeftBracket); + setState(1373); + balancedTokenSeq(); + setState(1374); + match(RightBracket); + } + break; + case LeftBrace: + enterOuterAlt(_localctx, 3); + { + setState(1376); + match(LeftBrace); + setState(1377); + balancedTokenSeq(); + setState(1378); + 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(1381); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(1380); + _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(1383); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 164, _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 final InitDeclaratorListContext initDeclaratorList() throws RecognitionException { + InitDeclaratorListContext _localctx = new InitDeclaratorListContext(_ctx, getState()); + enterRule(_localctx, 222, RULE_initDeclaratorList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1387); + initDeclarator(); + setState(1392); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == Comma) { + { + { + setState(1388); + match(Comma); + setState(1389); + initDeclarator(); + } + } + setState(1394); + _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 final InitDeclaratorContext initDeclarator() throws RecognitionException { + InitDeclaratorContext _localctx = new InitDeclaratorContext(_ctx, getState()); + enterRule(_localctx, 224, RULE_initDeclarator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1395); + declarator(); + setState(1397); + _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(1396); + initializer(); + } + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final DeclaratorContext declarator() throws RecognitionException { + DeclaratorContext _localctx = new DeclaratorContext(_ctx, getState()); + enterRule(_localctx, 226, RULE_declarator); + try { + setState(1404); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 168, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1399); + pointerDeclarator(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1400); + noPointerDeclarator(0); + setState(1401); + parametersAndQualifiers(); + setState(1402); + trailingReturnType(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final PointerDeclaratorContext pointerDeclarator() throws RecognitionException { + PointerDeclaratorContext _localctx = new PointerDeclaratorContext(_ctx, getState()); + enterRule(_localctx, 228, RULE_pointerDeclarator); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1412); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 170, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1406); + pointerOperator(); + setState(1408); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Const) { + { + setState(1407); + match(Const); + } + } + } + } + } + setState(1414); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 170, _ctx); + } + setState(1415); + noPointerDeclarator(0); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final NoPointerDeclaratorContext noPointerDeclarator() throws RecognitionException { + return noPointerDeclarator(0); + } + + public final ParametersAndQualifiersContext parametersAndQualifiers() + throws RecognitionException { + ParametersAndQualifiersContext _localctx = new ParametersAndQualifiersContext(_ctx, getState()); + enterRule(_localctx, 232, RULE_parametersAndQualifiers); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1445); + match(LeftParen); + setState(1447); + _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(1446); + parameterDeclarationClause(); + } + } + + setState(1449); + match(RightParen); + setState(1451); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 178, _ctx)) { + case 1: + { + setState(1450); + cvqualifierseq(); + } + break; + } + setState(1454); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 179, _ctx)) { + case 1: + { + setState(1453); + refqualifier(); + } + break; + } + setState(1457); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 180, _ctx)) { + case 1: + { + setState(1456); + exceptionSpecification(); + } + break; + } + setState(1460); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 181, _ctx)) { + case 1: + { + setState(1459); + attributeSpecifierSeq(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final TrailingReturnTypeContext trailingReturnType() throws RecognitionException { + TrailingReturnTypeContext _localctx = new TrailingReturnTypeContext(_ctx, getState()); + enterRule(_localctx, 234, RULE_trailingReturnType); + try { + enterOuterAlt(_localctx, 1); + { + setState(1462); + match(Arrow); + setState(1463); + trailingTypeSpecifierSeq(); + setState(1465); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 182, _ctx)) { + case 1: + { + setState(1464); + abstractDeclarator(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final PointerOperatorContext pointerOperator() throws RecognitionException { + PointerOperatorContext _localctx = new PointerOperatorContext(_ctx, getState()); + enterRule(_localctx, 236, RULE_pointerOperator); + int _la; + try { + setState(1481); + _errHandler.sync(this); + switch (_input.LA(1)) { + case And: + case AndAnd: + enterOuterAlt(_localctx, 1); + { + setState(1467); + _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(1469); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 183, _ctx)) { + case 1: + { + setState(1468); + attributeSpecifierSeq(); + } + break; + } + } + break; + case Decltype: + case Star: + case Doublecolon: + case Identifier: + enterOuterAlt(_localctx, 2); + { + setState(1472); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Decltype || _la == Doublecolon || _la == Identifier) { + { + setState(1471); + nestedNameSpecifier(0); + } + } + + setState(1474); + match(Star); + setState(1476); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 185, _ctx)) { + case 1: + { + setState(1475); + attributeSpecifierSeq(); + } + break; + } + setState(1479); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 186, _ctx)) { + case 1: + { + setState(1478); + 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 final CvqualifierseqContext cvqualifierseq() throws RecognitionException { + CvqualifierseqContext _localctx = new CvqualifierseqContext(_ctx, getState()); + enterRule(_localctx, 238, RULE_cvqualifierseq); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1484); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(1483); + cvQualifier(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1486); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 188, _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 final CvQualifierContext cvQualifier() throws RecognitionException { + CvQualifierContext _localctx = new CvQualifierContext(_ctx, getState()); + enterRule(_localctx, 240, RULE_cvQualifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1488); + _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 final RefqualifierContext refqualifier() throws RecognitionException { + RefqualifierContext _localctx = new RefqualifierContext(_ctx, getState()); + enterRule(_localctx, 242, RULE_refqualifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1490); + _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 final DeclaratoridContext declaratorid() throws RecognitionException { + DeclaratoridContext _localctx = new DeclaratoridContext(_ctx, getState()); + enterRule(_localctx, 244, RULE_declaratorid); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1493); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Ellipsis) { + { + setState(1492); + match(Ellipsis); + } + } + + setState(1495); + idExpression(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final TheTypeIdContext theTypeId() throws RecognitionException { + TheTypeIdContext _localctx = new TheTypeIdContext(_ctx, getState()); + enterRule(_localctx, 246, RULE_theTypeId); + try { + enterOuterAlt(_localctx, 1); + { + setState(1497); + typeSpecifierSeq(); + setState(1499); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 190, _ctx)) { + case 1: + { + setState(1498); + abstractDeclarator(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final AbstractDeclaratorContext abstractDeclarator() throws RecognitionException { + AbstractDeclaratorContext _localctx = new AbstractDeclaratorContext(_ctx, getState()); + enterRule(_localctx, 248, RULE_abstractDeclarator); + try { + setState(1509); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 192, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1501); + pointerAbstractDeclarator(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1503); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 191, _ctx)) { + case 1: + { + setState(1502); + noPointerAbstractDeclarator(0); + } + break; + } + setState(1505); + parametersAndQualifiers(); + setState(1506); + trailingReturnType(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1508); + abstractPackDeclarator(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final PointerAbstractDeclaratorContext pointerAbstractDeclarator() + throws RecognitionException { + PointerAbstractDeclaratorContext _localctx = + new PointerAbstractDeclaratorContext(_ctx, getState()); + enterRule(_localctx, 250, RULE_pointerAbstractDeclarator); + int _la; + try { + setState(1520); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LeftParen: + case LeftBracket: + enterOuterAlt(_localctx, 1); + { + setState(1511); + noPointerAbstractDeclarator(0); + } + break; + case Decltype: + case Star: + case And: + case AndAnd: + case Doublecolon: + case Identifier: + enterOuterAlt(_localctx, 2); + { + setState(1513); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1512); + pointerOperator(); + } + } + setState(1515); + _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(1518); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 194, _ctx)) { + case 1: + { + setState(1517); + 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 final NoPointerAbstractDeclaratorContext noPointerAbstractDeclarator() + throws RecognitionException { + return noPointerAbstractDeclarator(0); + } + + public final AbstractPackDeclaratorContext abstractPackDeclarator() throws RecognitionException { + AbstractPackDeclaratorContext _localctx = new AbstractPackDeclaratorContext(_ctx, getState()); + enterRule(_localctx, 254, RULE_abstractPackDeclarator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1559); + _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(1556); + pointerOperator(); + } + } + setState(1561); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1562); + noPointerAbstractPackDeclarator(0); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final NoPointerAbstractPackDeclaratorContext noPointerAbstractPackDeclarator() + throws RecognitionException { + return noPointerAbstractPackDeclarator(0); + } + + public final ParameterDeclarationClauseContext parameterDeclarationClause() + throws RecognitionException { + ParameterDeclarationClauseContext _localctx = + new ParameterDeclarationClauseContext(_ctx, getState()); + enterRule(_localctx, 258, RULE_parameterDeclarationClause); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1584); + parameterDeclarationList(); + setState(1589); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Comma || _la == Ellipsis) { + { + setState(1586); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Comma) { + { + setState(1585); + match(Comma); + } + } + + setState(1588); + match(Ellipsis); + } + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ParameterDeclarationListContext parameterDeclarationList() + throws RecognitionException { + ParameterDeclarationListContext _localctx = + new ParameterDeclarationListContext(_ctx, getState()); + enterRule(_localctx, 260, RULE_parameterDeclarationList); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1591); + parameterDeclaration(); + setState(1596); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 210, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1592); + match(Comma); + setState(1593); + parameterDeclaration(); + } + } + } + setState(1598); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 210, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ParameterDeclarationContext parameterDeclaration() throws RecognitionException { + ParameterDeclarationContext _localctx = new ParameterDeclarationContext(_ctx, getState()); + enterRule(_localctx, 262, RULE_parameterDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1600); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Alignas || _la == LeftBracket) { + { + setState(1599); + attributeSpecifierSeq(); + } + } + + setState(1602); + declSpecifierSeq(); + { + setState(1607); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 213, _ctx)) { + case 1: + { + setState(1603); + declarator(); + } + break; + case 2: + { + setState(1605); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 212, _ctx)) { + case 1: + { + setState(1604); + abstractDeclarator(); + } + break; + } + } + break; + } + setState(1611); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Assign) { + { + setState(1609); + match(Assign); + setState(1610); + initializerClause(); + } + } + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final FunctionDefinitionContext functionDefinition() throws RecognitionException { + FunctionDefinitionContext _localctx = new FunctionDefinitionContext(_ctx, getState()); + enterRule(_localctx, 264, RULE_functionDefinition); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1614); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Alignas || _la == LeftBracket) { + { + setState(1613); + attributeSpecifierSeq(); + } + } + + setState(1617); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 216, _ctx)) { + case 1: + { + setState(1616); + declSpecifierSeq(); + } + break; + } + setState(1619); + declarator(); + setState(1621); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Final || _la == Override) { + { + setState(1620); + virtualSpecifierSeq(); + } + } + + setState(1623); + functionBody(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final FunctionBodyContext functionBody() throws RecognitionException { + FunctionBodyContext _localctx = new FunctionBodyContext(_ctx, getState()); + enterRule(_localctx, 266, RULE_functionBody); + int _la; + try { + setState(1633); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LeftBrace: + case Colon: + enterOuterAlt(_localctx, 1); + { + setState(1626); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Colon) { + { + setState(1625); + constructorInitializer(); + } + } + + setState(1628); + compoundStatement(); + } + break; + case Try: + enterOuterAlt(_localctx, 2); + { + setState(1629); + functionTryBlock(); + } + break; + case Assign: + enterOuterAlt(_localctx, 3); + { + setState(1630); + match(Assign); + setState(1631); + _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(1632); + 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 final InitializerContext initializer() throws RecognitionException { + InitializerContext _localctx = new InitializerContext(_ctx, getState()); + enterRule(_localctx, 268, RULE_initializer); + try { + setState(1640); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LeftBrace: + case Assign: + enterOuterAlt(_localctx, 1); + { + setState(1635); + braceOrEqualInitializer(); + } + break; + case LeftParen: + enterOuterAlt(_localctx, 2); + { + setState(1636); + match(LeftParen); + setState(1637); + expressionList(); + setState(1638); + 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 final BraceOrEqualInitializerContext braceOrEqualInitializer() + throws RecognitionException { + BraceOrEqualInitializerContext _localctx = new BraceOrEqualInitializerContext(_ctx, getState()); + enterRule(_localctx, 270, RULE_braceOrEqualInitializer); + try { + setState(1645); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Assign: + enterOuterAlt(_localctx, 1); + { + setState(1642); + match(Assign); + setState(1643); + initializerClause(); + } + break; + case LeftBrace: + enterOuterAlt(_localctx, 2); + { + setState(1644); + 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 final InitializerClauseContext initializerClause() throws RecognitionException { + InitializerClauseContext _localctx = new InitializerClauseContext(_ctx, getState()); + enterRule(_localctx, 272, RULE_initializerClause); + try { + setState(1649); + _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(1647); + assignmentExpression(); + } + break; + case LeftBrace: + enterOuterAlt(_localctx, 2); + { + setState(1648); + 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 final InitializerListContext initializerList() throws RecognitionException { + InitializerListContext _localctx = new InitializerListContext(_ctx, getState()); + enterRule(_localctx, 274, RULE_initializerList); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1651); + initializerClause(); + setState(1653); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Ellipsis) { + { + setState(1652); + match(Ellipsis); + } + } + + setState(1662); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 225, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1655); + match(Comma); + setState(1656); + initializerClause(); + setState(1658); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Ellipsis) { + { + setState(1657); + match(Ellipsis); + } + } + } + } + } + setState(1664); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 225, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final BracedInitListContext bracedInitList() throws RecognitionException { + BracedInitListContext _localctx = new BracedInitListContext(_ctx, getState()); + enterRule(_localctx, 276, RULE_bracedInitList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1665); + match(LeftBrace); + setState(1670); + _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(1666); + initializerList(); + setState(1668); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Comma) { + { + setState(1667); + match(Comma); + } + } + } + } + + setState(1672); + match(RightBrace); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ClassNameContext className() throws RecognitionException { + ClassNameContext _localctx = new ClassNameContext(_ctx, getState()); + enterRule(_localctx, 278, RULE_className); + try { + setState(1676); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 228, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1674); + match(Identifier); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1675); + simpleTemplateId(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ClassSpecifierContext classSpecifier() throws RecognitionException { + ClassSpecifierContext _localctx = new ClassSpecifierContext(_ctx, getState()); + enterRule(_localctx, 280, RULE_classSpecifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1678); + classHead(); + setState(1679); + match(LeftBrace); + setState(1681); + _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(1680); + memberSpecification(); + } + } + + setState(1683); + match(RightBrace); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ClassHeadContext classHead() throws RecognitionException { + ClassHeadContext _localctx = new ClassHeadContext(_ctx, getState()); + enterRule(_localctx, 282, RULE_classHead); + int _la; + try { + setState(1708); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Class: + case Struct: + enterOuterAlt(_localctx, 1); + { + setState(1685); + classKey(); + setState(1687); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Alignas || _la == LeftBracket) { + { + setState(1686); + attributeSpecifierSeq(); + } + } + + setState(1693); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Decltype || _la == Doublecolon || _la == Identifier) { + { + setState(1689); + classHeadName(); + setState(1691); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Final) { + { + setState(1690); + classVirtSpecifier(); + } + } + } + } + + setState(1696); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Colon) { + { + setState(1695); + baseClause(); + } + } + } + break; + case Union: + enterOuterAlt(_localctx, 2); + { + setState(1698); + match(Union); + setState(1700); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Alignas || _la == LeftBracket) { + { + setState(1699); + attributeSpecifierSeq(); + } + } + + setState(1706); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Decltype || _la == Doublecolon || _la == Identifier) { + { + setState(1702); + classHeadName(); + setState(1704); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Final) { + { + setState(1703); + 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 final ClassHeadNameContext classHeadName() throws RecognitionException { + ClassHeadNameContext _localctx = new ClassHeadNameContext(_ctx, getState()); + enterRule(_localctx, 284, RULE_classHeadName); + try { + enterOuterAlt(_localctx, 1); + { + setState(1711); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 238, _ctx)) { + case 1: + { + setState(1710); + nestedNameSpecifier(0); + } + break; + } + setState(1713); + className(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ClassVirtSpecifierContext classVirtSpecifier() throws RecognitionException { + ClassVirtSpecifierContext _localctx = new ClassVirtSpecifierContext(_ctx, getState()); + enterRule(_localctx, 286, RULE_classVirtSpecifier); + try { + enterOuterAlt(_localctx, 1); + { + setState(1715); + match(Final); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ClassKeyContext classKey() throws RecognitionException { + ClassKeyContext _localctx = new ClassKeyContext(_ctx, getState()); + enterRule(_localctx, 288, RULE_classKey); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1717); + _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 final MemberSpecificationContext memberSpecification() throws RecognitionException { + MemberSpecificationContext _localctx = new MemberSpecificationContext(_ctx, getState()); + enterRule(_localctx, 290, RULE_memberSpecification); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1723); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + setState(1723); + _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(1719); + memberdeclaration(); + } + break; + case Private: + case Protected: + case Public: + { + setState(1720); + accessSpecifier(); + setState(1721); + match(Colon); + } + break; + default: + throw new NoViableAltException(this); + } + } + setState(1725); + _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 final MemberdeclarationContext memberdeclaration() throws RecognitionException { + MemberdeclarationContext _localctx = new MemberdeclarationContext(_ctx, getState()); + enterRule(_localctx, 292, RULE_memberdeclaration); + int _la; + try { + setState(1743); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 244, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1728); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 241, _ctx)) { + case 1: + { + setState(1727); + attributeSpecifierSeq(); + } + break; + } + setState(1731); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 242, _ctx)) { + case 1: + { + setState(1730); + declSpecifierSeq(); + } + break; + } + setState(1734); + _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(1733); + memberDeclaratorList(); + } + } + + setState(1736); + match(Semi); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1737); + functionDefinition(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1738); + usingDeclaration(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1739); + staticAssertDeclaration(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1740); + templateDeclaration(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1741); + aliasDeclaration(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(1742); + emptyDeclaration(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final MemberDeclaratorListContext memberDeclaratorList() throws RecognitionException { + MemberDeclaratorListContext _localctx = new MemberDeclaratorListContext(_ctx, getState()); + enterRule(_localctx, 294, RULE_memberDeclaratorList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1745); + memberDeclarator(); + setState(1750); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == Comma) { + { + { + setState(1746); + match(Comma); + setState(1747); + memberDeclarator(); + } + } + setState(1752); + _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 final MemberDeclaratorContext memberDeclarator() throws RecognitionException { + MemberDeclaratorContext _localctx = new MemberDeclaratorContext(_ctx, getState()); + enterRule(_localctx, 296, RULE_memberDeclarator); + int _la; + try { + setState(1773); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 252, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1753); + declarator(); + setState(1763); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 249, _ctx)) { + case 1: + { + setState(1755); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Final || _la == Override) { + { + setState(1754); + virtualSpecifierSeq(); + } + } + + setState(1758); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Assign) { + { + setState(1757); + pureSpecifier(); + } + } + } + break; + case 2: + { + setState(1761); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == LeftBrace || _la == Assign) { + { + setState(1760); + braceOrEqualInitializer(); + } + } + } + break; + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1766); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Identifier) { + { + setState(1765); + match(Identifier); + } + } + + setState(1769); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Alignas || _la == LeftBracket) { + { + setState(1768); + attributeSpecifierSeq(); + } + } + + setState(1771); + match(Colon); + setState(1772); + constantExpression(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final VirtualSpecifierSeqContext virtualSpecifierSeq() throws RecognitionException { + VirtualSpecifierSeqContext _localctx = new VirtualSpecifierSeqContext(_ctx, getState()); + enterRule(_localctx, 298, RULE_virtualSpecifierSeq); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1776); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1775); + virtualSpecifier(); + } + } + setState(1778); + _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 final VirtualSpecifierContext virtualSpecifier() throws RecognitionException { + VirtualSpecifierContext _localctx = new VirtualSpecifierContext(_ctx, getState()); + enterRule(_localctx, 300, RULE_virtualSpecifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1780); + _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 final PureSpecifierContext pureSpecifier() throws RecognitionException { + PureSpecifierContext _localctx = new PureSpecifierContext(_ctx, getState()); + enterRule(_localctx, 302, RULE_pureSpecifier); + try { + enterOuterAlt(_localctx, 1); + { + setState(1782); + match(Assign); + setState(1783); + ((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 final BaseClauseContext baseClause() throws RecognitionException { + BaseClauseContext _localctx = new BaseClauseContext(_ctx, getState()); + enterRule(_localctx, 304, RULE_baseClause); + try { + enterOuterAlt(_localctx, 1); + { + setState(1786); + match(Colon); + setState(1787); + baseSpecifierList(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final BaseSpecifierListContext baseSpecifierList() throws RecognitionException { + BaseSpecifierListContext _localctx = new BaseSpecifierListContext(_ctx, getState()); + enterRule(_localctx, 306, RULE_baseSpecifierList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1789); + baseSpecifier(); + setState(1791); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Ellipsis) { + { + setState(1790); + match(Ellipsis); + } + } + + setState(1800); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == Comma) { + { + { + setState(1793); + match(Comma); + setState(1794); + baseSpecifier(); + setState(1796); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Ellipsis) { + { + setState(1795); + match(Ellipsis); + } + } + } + } + setState(1802); + _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 final BaseSpecifierContext baseSpecifier() throws RecognitionException { + BaseSpecifierContext _localctx = new BaseSpecifierContext(_ctx, getState()); + enterRule(_localctx, 308, RULE_baseSpecifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1804); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Alignas || _la == LeftBracket) { + { + setState(1803); + attributeSpecifierSeq(); + } + } + + setState(1818); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Decltype: + case Doublecolon: + case Identifier: + { + setState(1806); + baseTypeSpecifier(); + } + break; + case Virtual: + { + setState(1807); + match(Virtual); + setState(1809); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 + && ((1L << _la) & ((1L << Private) | (1L << Protected) | (1L << Public))) != 0)) { + { + setState(1808); + accessSpecifier(); + } + } + + setState(1811); + baseTypeSpecifier(); + } + break; + case Private: + case Protected: + case Public: + { + setState(1812); + accessSpecifier(); + setState(1814); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Virtual) { + { + setState(1813); + match(Virtual); + } + } + + setState(1816); + 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 final ClassOrDeclTypeContext classOrDeclType() throws RecognitionException { + ClassOrDeclTypeContext _localctx = new ClassOrDeclTypeContext(_ctx, getState()); + enterRule(_localctx, 310, RULE_classOrDeclType); + try { + setState(1825); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 262, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1821); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 261, _ctx)) { + case 1: + { + setState(1820); + nestedNameSpecifier(0); + } + break; + } + setState(1823); + className(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1824); + decltypeSpecifier(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final BaseTypeSpecifierContext baseTypeSpecifier() throws RecognitionException { + BaseTypeSpecifierContext _localctx = new BaseTypeSpecifierContext(_ctx, getState()); + enterRule(_localctx, 312, RULE_baseTypeSpecifier); + try { + enterOuterAlt(_localctx, 1); + { + setState(1827); + classOrDeclType(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final AccessSpecifierContext accessSpecifier() throws RecognitionException { + AccessSpecifierContext _localctx = new AccessSpecifierContext(_ctx, getState()); + enterRule(_localctx, 314, RULE_accessSpecifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1829); + _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 final ConversionFunctionIdContext conversionFunctionId() throws RecognitionException { + ConversionFunctionIdContext _localctx = new ConversionFunctionIdContext(_ctx, getState()); + enterRule(_localctx, 316, RULE_conversionFunctionId); + try { + enterOuterAlt(_localctx, 1); + { + setState(1831); + match(Operator); + setState(1832); + conversionTypeId(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ConversionTypeIdContext conversionTypeId() throws RecognitionException { + ConversionTypeIdContext _localctx = new ConversionTypeIdContext(_ctx, getState()); + enterRule(_localctx, 318, RULE_conversionTypeId); + try { + enterOuterAlt(_localctx, 1); + { + setState(1834); + typeSpecifierSeq(); + setState(1836); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 263, _ctx)) { + case 1: + { + setState(1835); + conversionDeclarator(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ConversionDeclaratorContext conversionDeclarator() throws RecognitionException { + ConversionDeclaratorContext _localctx = new ConversionDeclaratorContext(_ctx, getState()); + enterRule(_localctx, 320, RULE_conversionDeclarator); + try { + enterOuterAlt(_localctx, 1); + { + setState(1838); + pointerOperator(); + setState(1840); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 264, _ctx)) { + case 1: + { + setState(1839); + conversionDeclarator(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ConstructorInitializerContext constructorInitializer() throws RecognitionException { + ConstructorInitializerContext _localctx = new ConstructorInitializerContext(_ctx, getState()); + enterRule(_localctx, 322, RULE_constructorInitializer); + try { + enterOuterAlt(_localctx, 1); + { + setState(1842); + match(Colon); + setState(1843); + memInitializerList(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final MemInitializerListContext memInitializerList() throws RecognitionException { + MemInitializerListContext _localctx = new MemInitializerListContext(_ctx, getState()); + enterRule(_localctx, 324, RULE_memInitializerList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1845); + memInitializer(); + setState(1847); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Ellipsis) { + { + setState(1846); + match(Ellipsis); + } + } + + setState(1856); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == Comma) { + { + { + setState(1849); + match(Comma); + setState(1850); + memInitializer(); + setState(1852); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Ellipsis) { + { + setState(1851); + match(Ellipsis); + } + } + } + } + setState(1858); + _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 final MemInitializerContext memInitializer() throws RecognitionException { + MemInitializerContext _localctx = new MemInitializerContext(_ctx, getState()); + enterRule(_localctx, 326, RULE_memInitializer); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1859); + meminitializerid(); + setState(1866); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LeftParen: + { + setState(1860); + match(LeftParen); + setState(1862); + _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(1861); + expressionList(); + } + } + + setState(1864); + match(RightParen); + } + break; + case LeftBrace: + { + setState(1865); + 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 final MeminitializeridContext meminitializerid() throws RecognitionException { + MeminitializeridContext _localctx = new MeminitializeridContext(_ctx, getState()); + enterRule(_localctx, 328, RULE_meminitializerid); + try { + setState(1870); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 270, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1868); + classOrDeclType(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1869); + match(Identifier); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final OperatorFunctionIdContext operatorFunctionId() throws RecognitionException { + OperatorFunctionIdContext _localctx = new OperatorFunctionIdContext(_ctx, getState()); + enterRule(_localctx, 330, RULE_operatorFunctionId); + try { + enterOuterAlt(_localctx, 1); + { + setState(1872); + match(Operator); + setState(1873); + theOperator(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final LiteralOperatorIdContext literalOperatorId() throws RecognitionException { + LiteralOperatorIdContext _localctx = new LiteralOperatorIdContext(_ctx, getState()); + enterRule(_localctx, 332, RULE_literalOperatorId); + try { + enterOuterAlt(_localctx, 1); + { + setState(1875); + match(Operator); + setState(1879); + _errHandler.sync(this); + switch (_input.LA(1)) { + case StringLiteral: + { + setState(1876); + match(StringLiteral); + setState(1877); + match(Identifier); + } + break; + case UserDefinedStringLiteral: + { + setState(1878); + 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 final TemplateDeclarationContext templateDeclaration() throws RecognitionException { + TemplateDeclarationContext _localctx = new TemplateDeclarationContext(_ctx, getState()); + enterRule(_localctx, 334, RULE_templateDeclaration); + try { + enterOuterAlt(_localctx, 1); + { + setState(1881); + match(Template); + setState(1882); + match(Less); + setState(1883); + templateparameterList(); + setState(1884); + match(Greater); + setState(1885); + declaration(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final TemplateparameterListContext templateparameterList() throws RecognitionException { + TemplateparameterListContext _localctx = new TemplateparameterListContext(_ctx, getState()); + enterRule(_localctx, 336, RULE_templateparameterList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1887); + templateParameter(); + setState(1892); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == Comma) { + { + { + setState(1888); + match(Comma); + setState(1889); + templateParameter(); + } + } + setState(1894); + _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 final TemplateParameterContext templateParameter() throws RecognitionException { + TemplateParameterContext _localctx = new TemplateParameterContext(_ctx, getState()); + enterRule(_localctx, 338, RULE_templateParameter); + try { + setState(1897); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 273, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1895); + typeParameter(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1896); + parameterDeclaration(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final TypeParameterContext typeParameter() throws RecognitionException { + TypeParameterContext _localctx = new TypeParameterContext(_ctx, getState()); + enterRule(_localctx, 340, RULE_typeParameter); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1908); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Class: + case Template: + { + setState(1904); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Template) { + { + setState(1899); + match(Template); + setState(1900); + match(Less); + setState(1901); + templateparameterList(); + setState(1902); + match(Greater); + } + } + + setState(1906); + match(Class); + } + break; + case Typename_: + { + setState(1907); + match(Typename_); + } + break; + default: + throw new NoViableAltException(this); + } + setState(1921); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 279, _ctx)) { + case 1: + { + { + setState(1911); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Ellipsis) { + { + setState(1910); + match(Ellipsis); + } + } + + setState(1914); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Identifier) { + { + setState(1913); + match(Identifier); + } + } + } + } + break; + case 2: + { + { + setState(1917); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Identifier) { + { + setState(1916); + match(Identifier); + } + } + + setState(1919); + match(Assign); + setState(1920); + theTypeId(); + } + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final SimpleTemplateIdContext simpleTemplateId() throws RecognitionException { + SimpleTemplateIdContext _localctx = new SimpleTemplateIdContext(_ctx, getState()); + enterRule(_localctx, 342, RULE_simpleTemplateId); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1923); + templateName(); + setState(1924); + match(Less); + setState(1926); + _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(1925); + templateArgumentList(); + } + } + + setState(1928); + match(Greater); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final TemplateIdContext templateId() throws RecognitionException { + TemplateIdContext _localctx = new TemplateIdContext(_ctx, getState()); + enterRule(_localctx, 344, RULE_templateId); + int _la; + try { + setState(1941); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Identifier: + enterOuterAlt(_localctx, 1); + { + setState(1930); + simpleTemplateId(); + } + break; + case Operator: + enterOuterAlt(_localctx, 2); + { + setState(1933); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 281, _ctx)) { + case 1: + { + setState(1931); + operatorFunctionId(); + } + break; + case 2: + { + setState(1932); + literalOperatorId(); + } + break; + } + setState(1935); + match(Less); + setState(1937); + _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(1936); + templateArgumentList(); + } + } + + setState(1939); + 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 final TemplateNameContext templateName() throws RecognitionException { + TemplateNameContext _localctx = new TemplateNameContext(_ctx, getState()); + enterRule(_localctx, 346, RULE_templateName); + try { + enterOuterAlt(_localctx, 1); + { + setState(1943); + match(Identifier); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final TemplateArgumentListContext templateArgumentList() throws RecognitionException { + TemplateArgumentListContext _localctx = new TemplateArgumentListContext(_ctx, getState()); + enterRule(_localctx, 348, RULE_templateArgumentList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1945); + templateArgument(); + setState(1947); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Ellipsis) { + { + setState(1946); + match(Ellipsis); + } + } + + setState(1956); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == Comma) { + { + { + setState(1949); + match(Comma); + setState(1950); + templateArgument(); + setState(1952); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Ellipsis) { + { + setState(1951); + match(Ellipsis); + } + } + } + } + setState(1958); + _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 final TemplateArgumentContext templateArgument() throws RecognitionException { + TemplateArgumentContext _localctx = new TemplateArgumentContext(_ctx, getState()); + enterRule(_localctx, 350, RULE_templateArgument); + try { + setState(1962); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 287, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1959); + theTypeId(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1960); + constantExpression(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1961); + idExpression(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final TypeNameSpecifierContext typeNameSpecifier() throws RecognitionException { + TypeNameSpecifierContext _localctx = new TypeNameSpecifierContext(_ctx, getState()); + enterRule(_localctx, 352, RULE_typeNameSpecifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1964); + match(Typename_); + setState(1965); + nestedNameSpecifier(0); + setState(1971); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 289, _ctx)) { + case 1: + { + setState(1966); + match(Identifier); + } + break; + case 2: + { + setState(1968); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Template) { + { + setState(1967); + match(Template); + } + } + + setState(1970); + simpleTemplateId(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ExplicitInstantiationContext explicitInstantiation() throws RecognitionException { + ExplicitInstantiationContext _localctx = new ExplicitInstantiationContext(_ctx, getState()); + enterRule(_localctx, 354, RULE_explicitInstantiation); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1974); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Extern) { + { + setState(1973); + match(Extern); + } + } + + setState(1976); + match(Template); + setState(1977); + declaration(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ExplicitSpecializationContext explicitSpecialization() throws RecognitionException { + ExplicitSpecializationContext _localctx = new ExplicitSpecializationContext(_ctx, getState()); + enterRule(_localctx, 356, RULE_explicitSpecialization); + try { + enterOuterAlt(_localctx, 1); + { + setState(1979); + match(Template); + setState(1980); + match(Less); + setState(1981); + match(Greater); + setState(1982); + declaration(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final TryBlockContext tryBlock() throws RecognitionException { + TryBlockContext _localctx = new TryBlockContext(_ctx, getState()); + enterRule(_localctx, 358, RULE_tryBlock); + try { + enterOuterAlt(_localctx, 1); + { + setState(1984); + match(Try); + setState(1985); + compoundStatement(); + setState(1986); + handlerSeq(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final FunctionTryBlockContext functionTryBlock() throws RecognitionException { + FunctionTryBlockContext _localctx = new FunctionTryBlockContext(_ctx, getState()); + enterRule(_localctx, 360, RULE_functionTryBlock); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1988); + match(Try); + setState(1990); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Colon) { + { + setState(1989); + constructorInitializer(); + } + } + + setState(1992); + compoundStatement(); + setState(1993); + handlerSeq(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final HandlerSeqContext handlerSeq() throws RecognitionException { + HandlerSeqContext _localctx = new HandlerSeqContext(_ctx, getState()); + enterRule(_localctx, 362, RULE_handlerSeq); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1996); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1995); + handler(); + } + } + setState(1998); + _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 final HandlerContext handler() throws RecognitionException { + HandlerContext _localctx = new HandlerContext(_ctx, getState()); + enterRule(_localctx, 364, RULE_handler); + try { + enterOuterAlt(_localctx, 1); + { + setState(2000); + match(Catch); + setState(2001); + match(LeftParen); + setState(2002); + exceptionDeclaration(); + setState(2003); + match(RightParen); + setState(2004); + compoundStatement(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ExceptionDeclarationContext exceptionDeclaration() throws RecognitionException { + ExceptionDeclarationContext _localctx = new ExceptionDeclarationContext(_ctx, getState()); + enterRule(_localctx, 366, RULE_exceptionDeclaration); + int _la; + try { + setState(2015); + _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(2007); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Alignas || _la == LeftBracket) { + { + setState(2006); + attributeSpecifierSeq(); + } + } + + setState(2009); + typeSpecifierSeq(); + setState(2012); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 294, _ctx)) { + case 1: + { + setState(2010); + declarator(); + } + break; + case 2: + { + setState(2011); + abstractDeclarator(); + } + break; + } + } + break; + case Ellipsis: + enterOuterAlt(_localctx, 2); + { + setState(2014); + 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 final ThrowExpressionContext throwExpression() throws RecognitionException { + ThrowExpressionContext _localctx = new ThrowExpressionContext(_ctx, getState()); + enterRule(_localctx, 368, RULE_throwExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2017); + match(Throw); + setState(2019); + _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(2018); + assignmentExpression(); + } + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ExceptionSpecificationContext exceptionSpecification() throws RecognitionException { + ExceptionSpecificationContext _localctx = new ExceptionSpecificationContext(_ctx, getState()); + enterRule(_localctx, 370, RULE_exceptionSpecification); + try { + setState(2023); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Throw: + enterOuterAlt(_localctx, 1); + { + setState(2021); + dynamicExceptionSpecification(); + } + break; + case Noexcept: + enterOuterAlt(_localctx, 2); + { + setState(2022); + 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 final DynamicExceptionSpecificationContext dynamicExceptionSpecification() + throws RecognitionException { + DynamicExceptionSpecificationContext _localctx = + new DynamicExceptionSpecificationContext(_ctx, getState()); + enterRule(_localctx, 372, RULE_dynamicExceptionSpecification); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2025); + match(Throw); + setState(2026); + match(LeftParen); + setState(2028); + _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(2027); + typeIdList(); + } + } + + setState(2030); + match(RightParen); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final TypeIdListContext typeIdList() throws RecognitionException { + TypeIdListContext _localctx = new TypeIdListContext(_ctx, getState()); + enterRule(_localctx, 374, RULE_typeIdList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2032); + theTypeId(); + setState(2034); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Ellipsis) { + { + setState(2033); + match(Ellipsis); + } + } + + setState(2043); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == Comma) { + { + { + setState(2036); + match(Comma); + setState(2037); + theTypeId(); + setState(2039); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Ellipsis) { + { + setState(2038); + match(Ellipsis); + } + } + } + } + setState(2045); + _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 final NoeExceptSpecificationContext noeExceptSpecification() throws RecognitionException { + NoeExceptSpecificationContext _localctx = new NoeExceptSpecificationContext(_ctx, getState()); + enterRule(_localctx, 376, RULE_noeExceptSpecification); + try { + setState(2052); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 302, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2046); + match(Noexcept); + setState(2047); + match(LeftParen); + setState(2048); + constantExpression(); + setState(2049); + match(RightParen); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2051); + match(Noexcept); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final TheOperatorContext theOperator() throws RecognitionException { + TheOperatorContext _localctx = new TheOperatorContext(_ctx, getState()); + enterRule(_localctx, 378, RULE_theOperator); + try { + setState(2105); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 305, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2054); + match(New); + setState(2057); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 303, _ctx)) { + case 1: + { + setState(2055); + match(LeftBracket); + setState(2056); + match(RightBracket); + } + break; + } + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2059); + match(Delete); + setState(2062); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 304, _ctx)) { + case 1: + { + setState(2060); + match(LeftBracket); + setState(2061); + match(RightBracket); + } + break; + } + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2064); + match(Plus); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(2065); + match(Minus); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(2066); + match(Star); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(2067); + match(Div); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(2068); + match(Mod); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(2069); + match(Caret); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(2070); + match(And); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(2071); + match(Or); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(2072); + match(Tilde); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(2073); + match(Not); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(2074); + match(Assign); + } + break; + case 14: + enterOuterAlt(_localctx, 14); + { + setState(2075); + match(Greater); + } + break; + case 15: + enterOuterAlt(_localctx, 15); + { + setState(2076); + match(Less); + } + break; + case 16: + enterOuterAlt(_localctx, 16); + { + setState(2077); + match(GreaterEqual); + } + break; + case 17: + enterOuterAlt(_localctx, 17); + { + setState(2078); + match(PlusAssign); + } + break; + case 18: + enterOuterAlt(_localctx, 18); + { + setState(2079); + match(MinusAssign); + } + break; + case 19: + enterOuterAlt(_localctx, 19); + { + setState(2080); + match(StarAssign); + } + break; + case 20: + enterOuterAlt(_localctx, 20); + { + setState(2081); + match(ModAssign); + } + break; + case 21: + enterOuterAlt(_localctx, 21); + { + setState(2082); + match(XorAssign); + } + break; + case 22: + enterOuterAlt(_localctx, 22); + { + setState(2083); + match(AndAssign); + } + break; + case 23: + enterOuterAlt(_localctx, 23); + { + setState(2084); + match(OrAssign); + } + break; + case 24: + enterOuterAlt(_localctx, 24); + { + setState(2085); + match(Less); + setState(2086); + match(Less); + } + break; + case 25: + enterOuterAlt(_localctx, 25); + { + setState(2087); + match(Greater); + setState(2088); + match(Greater); + } + break; + case 26: + enterOuterAlt(_localctx, 26); + { + setState(2089); + match(RightShiftAssign); + } + break; + case 27: + enterOuterAlt(_localctx, 27); + { + setState(2090); + match(LeftShiftAssign); + } + break; + case 28: + enterOuterAlt(_localctx, 28); + { + setState(2091); + match(Equal); + } + break; + case 29: + enterOuterAlt(_localctx, 29); + { + setState(2092); + match(NotEqual); + } + break; + case 30: + enterOuterAlt(_localctx, 30); + { + setState(2093); + match(LessEqual); + } + break; + case 31: + enterOuterAlt(_localctx, 31); + { + setState(2094); + match(AndAnd); + } + break; + case 32: + enterOuterAlt(_localctx, 32); + { + setState(2095); + match(OrOr); + } + break; + case 33: + enterOuterAlt(_localctx, 33); + { + setState(2096); + match(PlusPlus); + } + break; + case 34: + enterOuterAlt(_localctx, 34); + { + setState(2097); + match(MinusMinus); + } + break; + case 35: + enterOuterAlt(_localctx, 35); + { + setState(2098); + match(Comma); + } + break; + case 36: + enterOuterAlt(_localctx, 36); + { + setState(2099); + match(ArrowStar); + } + break; + case 37: + enterOuterAlt(_localctx, 37); + { + setState(2100); + match(Arrow); + } + break; + case 38: + enterOuterAlt(_localctx, 38); + { + setState(2101); + match(LeftParen); + setState(2102); + match(RightParen); + } + break; + case 39: + enterOuterAlt(_localctx, 39); + { + setState(2103); + match(LeftBracket); + setState(2104); + match(RightBracket); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final LiteralContext literal() throws RecognitionException { + LiteralContext _localctx = new LiteralContext(_ctx, getState()); + enterRule(_localctx, 380, RULE_literal); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2107); + _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; + } + + 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(427); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 7, _ctx)) { + case 1: + { + setState(424); + theTypeName(); + } + break; + case 2: + { + setState(425); + namespaceName(); + } + break; + case 3: + { + setState(426); + decltypeSpecifier(); + } + break; + } + setState(429); + match(Doublecolon); + } + _ctx.stop = _input.LT(-1); + setState(442); + _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(431); + if (!(precpred(_ctx, 1))) + throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(437); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 9, _ctx)) { + case 1: + { + setState(432); + match(Identifier); + } + break; + case 2: + { + setState(434); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Template) { + { + setState(433); + match(Template); + } + } + + setState(436); + simpleTemplateId(); + } + break; + } + setState(439); + match(Doublecolon); + } + } + } + setState(444); + _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; + } + + 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(542); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 30, _ctx)) { + case 1: + { + setState(513); + primaryExpression(); + } + break; + case 2: + { + setState(516); + _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(514); + simpleTypeSpecifier(); + } + break; + case Typename_: + { + setState(515); + typeNameSpecifier(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(524); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LeftParen: + { + setState(518); + match(LeftParen); + setState(520); + _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(519); + expressionList(); + } + } + + setState(522); + match(RightParen); + } + break; + case LeftBrace: + { + setState(523); + bracedInitList(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 3: + { + setState(526); + _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(527); + match(Less); + setState(528); + theTypeId(); + setState(529); + match(Greater); + setState(530); + match(LeftParen); + setState(531); + expression(); + setState(532); + match(RightParen); + } + break; + case 4: + { + setState(534); + typeIdOfTheTypeId(); + setState(535); + match(LeftParen); + setState(538); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 29, _ctx)) { + case 1: + { + setState(536); + expression(); + } + break; + case 2: + { + setState(537); + theTypeId(); + } + break; + } + setState(540); + match(RightParen); + } + break; + } + _ctx.stop = _input.LT(-1); + setState(571); + _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(569); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 35, _ctx)) { + case 1: + { + _localctx = new PostfixExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_postfixExpression); + setState(544); + if (!(precpred(_ctx, 7))) + throw new FailedPredicateException(this, "precpred(_ctx, 7)"); + setState(545); + match(LeftBracket); + setState(548); + _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(546); + expression(); + } + break; + case LeftBrace: + { + setState(547); + bracedInitList(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(550); + match(RightBracket); + } + break; + case 2: + { + _localctx = new PostfixExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_postfixExpression); + setState(552); + if (!(precpred(_ctx, 6))) + throw new FailedPredicateException(this, "precpred(_ctx, 6)"); + setState(553); + match(LeftParen); + setState(555); + _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(554); + expressionList(); + } + } + + setState(557); + match(RightParen); + } + break; + case 3: + { + _localctx = new PostfixExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_postfixExpression); + setState(558); + if (!(precpred(_ctx, 4))) + throw new FailedPredicateException(this, "precpred(_ctx, 4)"); + setState(559); + _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(565); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 34, _ctx)) { + case 1: + { + setState(561); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == Template) { + { + setState(560); + match(Template); + } + } + + setState(563); + idExpression(); + } + break; + case 2: + { + setState(564); + pseudoDestructorName(); + } + break; + } + } + break; + case 4: + { + _localctx = new PostfixExpressionContext(_parentctx, _parentState); + pushNewRecursionContext(_localctx, _startState, RULE_postfixExpression); + setState(567); + if (!(precpred(_ctx, 3))) + throw new FailedPredicateException(this, "precpred(_ctx, 3)"); + setState(568); + _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(573); + _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; + } + + 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(663); + match(LeftBracket); + setState(664); + expression(); + setState(665); + match(RightBracket); + setState(667); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 50, _ctx)) { + case 1: + { + setState(666); + attributeSpecifierSeq(); + } + break; + } + } + _ctx.stop = _input.LT(-1); + setState(678); + _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(669); + if (!(precpred(_ctx, 1))) + throw new FailedPredicateException(this, "precpred(_ctx, 1)"); + setState(670); + match(LeftBracket); + setState(671); + constantExpression(); + setState(672); + match(RightBracket); + setState(674); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 51, _ctx)) { + case 1: + { + setState(673); + attributeSpecifierSeq(); + } + break; + } + } + } + } + setState(680); + _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; + } + + private NoPointerDeclaratorContext noPointerDeclarator(int _p) throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + NoPointerDeclaratorContext _localctx = new NoPointerDeclaratorContext(_ctx, _parentState); + NoPointerDeclaratorContext _prevctx = _localctx; + int _startState = 230; + enterRecursionRule(_localctx, 230, RULE_noPointerDeclarator, _p); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1426); + _errHandler.sync(this); + switch (_input.LA(1)) { + case Decltype: + case Operator: + case Tilde: + case Doublecolon: + case Ellipsis: + case Identifier: + { + setState(1418); + declaratorid(); + setState(1420); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 171, _ctx)) { + case 1: + { + setState(1419); + attributeSpecifierSeq(); + } + break; + } + } + break; + case LeftParen: + { + setState(1422); + match(LeftParen); + setState(1423); + pointerDeclarator(); + setState(1424); + match(RightParen); + } + break; + default: + throw new NoViableAltException(this); + } + _ctx.stop = _input.LT(-1); + setState(1442); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 176, _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(1428); + if (!(precpred(_ctx, 2))) + throw new FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(1438); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LeftParen: + { + setState(1429); + parametersAndQualifiers(); + } + break; + case LeftBracket: + { + setState(1430); + match(LeftBracket); + setState(1432); + _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(1431); + constantExpression(); + } + } + + setState(1434); + match(RightBracket); + setState(1436); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 174, _ctx)) { + case 1: + { + setState(1435); + attributeSpecifierSeq(); + } + break; + } + } + break; + default: + throw new NoViableAltException(this); + } + } + } + } + setState(1444); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 176, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + private NoPointerAbstractDeclaratorContext noPointerAbstractDeclarator(int _p) + throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + NoPointerAbstractDeclaratorContext _localctx = + new NoPointerAbstractDeclaratorContext(_ctx, _parentState); + NoPointerAbstractDeclaratorContext _prevctx = _localctx; + int _startState = 252; + enterRecursionRule(_localctx, 252, RULE_noPointerAbstractDeclarator, _p); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1536); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 198, _ctx)) { + case 1: + { + setState(1523); + parametersAndQualifiers(); + } + break; + case 2: + { + setState(1524); + match(LeftBracket); + setState(1526); + _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(1525); + constantExpression(); + } + } + + setState(1528); + match(RightBracket); + setState(1530); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 197, _ctx)) { + case 1: + { + setState(1529); + attributeSpecifierSeq(); + } + break; + } + } + break; + case 3: + { + setState(1532); + match(LeftParen); + setState(1533); + pointerAbstractDeclarator(); + setState(1534); + match(RightParen); + } + break; + } + _ctx.stop = _input.LT(-1); + setState(1553); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 202, _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(1538); + if (!(precpred(_ctx, 4))) + throw new FailedPredicateException(this, "precpred(_ctx, 4)"); + setState(1549); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 201, _ctx)) { + case 1: + { + setState(1539); + parametersAndQualifiers(); + } + break; + case 2: + { + setState(1540); + noPointerAbstractDeclarator(0); + setState(1541); + match(LeftBracket); + setState(1543); + _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(1542); + constantExpression(); + } + } + + setState(1545); + match(RightBracket); + setState(1547); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 200, _ctx)) { + case 1: + { + setState(1546); + attributeSpecifierSeq(); + } + break; + } + } + break; + } + } + } + } + setState(1555); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 202, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + private NoPointerAbstractPackDeclaratorContext noPointerAbstractPackDeclarator(int _p) + throws RecognitionException { + ParserRuleContext _parentctx = _ctx; + int _parentState = getState(); + NoPointerAbstractPackDeclaratorContext _localctx = + new NoPointerAbstractPackDeclaratorContext(_ctx, _parentState); + NoPointerAbstractPackDeclaratorContext _prevctx = _localctx; + int _startState = 256; + enterRecursionRule(_localctx, 256, RULE_noPointerAbstractPackDeclarator, _p); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + { + setState(1565); + match(Ellipsis); + } + _ctx.stop = _input.LT(-1); + setState(1581); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 207, _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(1567); + if (!(precpred(_ctx, 2))) + throw new FailedPredicateException(this, "precpred(_ctx, 2)"); + setState(1577); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LeftParen: + { + setState(1568); + parametersAndQualifiers(); + } + break; + case LeftBracket: + { + setState(1569); + match(LeftBracket); + setState(1571); + _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(1570); + constantExpression(); + } + } + + setState(1573); + match(RightBracket); + setState(1575); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 205, _ctx)) { + case 1: + { + setState(1574); + attributeSpecifierSeq(); + } + break; + } + } + break; + default: + throw new NoViableAltException(this); + } + } + } + } + setState(1583); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 207, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + unrollRecursionContexts(_parentctx); + } + return _localctx; + } + + public static class TranslationUnitContext extends ParserRuleContext { + public TranslationUnitContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode EOF() { + return getToken(CPP14Parser.EOF, 0); + } + + public DeclarationseqContext declarationseq() { + return getRuleContext(DeclarationseqContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_translationUnit; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitTranslationUnit(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterTranslationUnit(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitTranslationUnit(this); + } + } + + public static class PrimaryExpressionContext extends ParserRuleContext { + public PrimaryExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_primaryExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitPrimaryExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterPrimaryExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitPrimaryExpression(this); + } + } + + public static class IdExpressionContext extends ParserRuleContext { + public IdExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public UnqualifiedIdContext unqualifiedId() { + return getRuleContext(UnqualifiedIdContext.class, 0); + } + + public QualifiedIdContext qualifiedId() { + return getRuleContext(QualifiedIdContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_idExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitIdExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterIdExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitIdExpression(this); + } + } + + public static class UnqualifiedIdContext extends ParserRuleContext { + public UnqualifiedIdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_unqualifiedId; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitUnqualifiedId(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterUnqualifiedId(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitUnqualifiedId(this); + } + } + + public static class QualifiedIdContext extends ParserRuleContext { + public QualifiedIdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public NestedNameSpecifierContext nestedNameSpecifier() { + return getRuleContext(NestedNameSpecifierContext.class, 0); + } + + public UnqualifiedIdContext unqualifiedId() { + return getRuleContext(UnqualifiedIdContext.class, 0); + } + + public TerminalNode Template() { + return getToken(CPP14Parser.Template, 0); + } + + @Override + public int getRuleIndex() { + return RULE_qualifiedId; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitQualifiedId(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterQualifiedId(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitQualifiedId(this); + } + } + + public static class NestedNameSpecifierContext extends ParserRuleContext { + public NestedNameSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_nestedNameSpecifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitNestedNameSpecifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterNestedNameSpecifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitNestedNameSpecifier(this); + } + } + + public static class LambdaExpressionContext extends ParserRuleContext { + public LambdaExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public LambdaIntroducerContext lambdaIntroducer() { + return getRuleContext(LambdaIntroducerContext.class, 0); + } + + public CompoundStatementContext compoundStatement() { + return getRuleContext(CompoundStatementContext.class, 0); + } + + public LambdaDeclaratorContext lambdaDeclarator() { + return getRuleContext(LambdaDeclaratorContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_lambdaExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitLambdaExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterLambdaExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitLambdaExpression(this); + } + } + + public static class LambdaIntroducerContext extends ParserRuleContext { + public LambdaIntroducerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LeftBracket() { + return getToken(CPP14Parser.LeftBracket, 0); + } + + public TerminalNode RightBracket() { + return getToken(CPP14Parser.RightBracket, 0); + } + + public LambdaCaptureContext lambdaCapture() { + return getRuleContext(LambdaCaptureContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_lambdaIntroducer; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitLambdaIntroducer(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterLambdaIntroducer(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitLambdaIntroducer(this); + } + } + + public static class LambdaCaptureContext extends ParserRuleContext { + public LambdaCaptureContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public CaptureListContext captureList() { + return getRuleContext(CaptureListContext.class, 0); + } + + public CaptureDefaultContext captureDefault() { + return getRuleContext(CaptureDefaultContext.class, 0); + } + + public TerminalNode Comma() { + return getToken(CPP14Parser.Comma, 0); + } + + @Override + public int getRuleIndex() { + return RULE_lambdaCapture; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitLambdaCapture(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterLambdaCapture(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitLambdaCapture(this); + } + } + + public static class CaptureDefaultContext extends ParserRuleContext { + public CaptureDefaultContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode And() { + return getToken(CPP14Parser.And, 0); + } + + public TerminalNode Assign() { + return getToken(CPP14Parser.Assign, 0); + } + + @Override + public int getRuleIndex() { + return RULE_captureDefault; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitCaptureDefault(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterCaptureDefault(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitCaptureDefault(this); + } + } + + public static class CaptureListContext extends ParserRuleContext { + public CaptureListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_captureList; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitCaptureList(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterCaptureList(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitCaptureList(this); + } + } + + public static class CaptureContext extends ParserRuleContext { + public CaptureContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public SimpleCaptureContext simpleCapture() { + return getRuleContext(SimpleCaptureContext.class, 0); + } + + public InitcaptureContext initcapture() { + return getRuleContext(InitcaptureContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_capture; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitCapture(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterCapture(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitCapture(this); + } + } + + public static class SimpleCaptureContext extends ParserRuleContext { + public SimpleCaptureContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Identifier() { + return getToken(CPP14Parser.Identifier, 0); + } + + public TerminalNode And() { + return getToken(CPP14Parser.And, 0); + } + + public TerminalNode This() { + return getToken(CPP14Parser.This, 0); + } + + @Override + public int getRuleIndex() { + return RULE_simpleCapture; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitSimpleCapture(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterSimpleCapture(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitSimpleCapture(this); + } + } + + public static class InitcaptureContext extends ParserRuleContext { + public InitcaptureContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Identifier() { + return getToken(CPP14Parser.Identifier, 0); + } + + public InitializerContext initializer() { + return getRuleContext(InitializerContext.class, 0); + } + + public TerminalNode And() { + return getToken(CPP14Parser.And, 0); + } + + @Override + public int getRuleIndex() { + return RULE_initcapture; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitInitcapture(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterInitcapture(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitInitcapture(this); + } + } + + public static class LambdaDeclaratorContext extends ParserRuleContext { + public LambdaDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_lambdaDeclarator; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitLambdaDeclarator(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterLambdaDeclarator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitLambdaDeclarator(this); + } + } + + public static class PostfixExpressionContext extends ParserRuleContext { + public PostfixExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_postfixExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitPostfixExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterPostfixExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitPostfixExpression(this); + } + } + + public static class TypeIdOfTheTypeIdContext extends ParserRuleContext { + public TypeIdOfTheTypeIdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Typeid_() { + return getToken(CPP14Parser.Typeid_, 0); + } + + @Override + public int getRuleIndex() { + return RULE_typeIdOfTheTypeId; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitTypeIdOfTheTypeId(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterTypeIdOfTheTypeId(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitTypeIdOfTheTypeId(this); + } + } + + public static class ExpressionListContext extends ParserRuleContext { + public ExpressionListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public InitializerListContext initializerList() { + return getRuleContext(InitializerListContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_expressionList; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitExpressionList(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterExpressionList(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitExpressionList(this); + } + } + + public static class PseudoDestructorNameContext extends ParserRuleContext { + public PseudoDestructorNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_pseudoDestructorName; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitPseudoDestructorName(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterPseudoDestructorName(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitPseudoDestructorName(this); + } + } + + public static class UnaryExpressionContext extends ParserRuleContext { + public UnaryExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_unaryExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitUnaryExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterUnaryExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitUnaryExpression(this); + } + } + + public static class UnaryOperatorContext extends ParserRuleContext { + public UnaryOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_unaryOperator; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitUnaryOperator(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterUnaryOperator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitUnaryOperator(this); + } + } + + public static class NewExpressionContext extends ParserRuleContext { + public NewExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_newExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitNewExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterNewExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitNewExpression(this); + } + } + + public static class NewPlacementContext extends ParserRuleContext { + public NewPlacementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LeftParen() { + return getToken(CPP14Parser.LeftParen, 0); + } + + public ExpressionListContext expressionList() { + return getRuleContext(ExpressionListContext.class, 0); + } + + public TerminalNode RightParen() { + return getToken(CPP14Parser.RightParen, 0); + } + + @Override + public int getRuleIndex() { + return RULE_newPlacement; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitNewPlacement(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterNewPlacement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitNewPlacement(this); + } + } + + public static class NewTypeIdContext extends ParserRuleContext { + public NewTypeIdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TypeSpecifierSeqContext typeSpecifierSeq() { + return getRuleContext(TypeSpecifierSeqContext.class, 0); + } + + public NewDeclaratorContext newDeclarator() { + return getRuleContext(NewDeclaratorContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_newTypeId; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitNewTypeId(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterNewTypeId(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitNewTypeId(this); + } + } + + public static class NewDeclaratorContext extends ParserRuleContext { + public NewDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public PointerOperatorContext pointerOperator() { + return getRuleContext(PointerOperatorContext.class, 0); + } + + public NewDeclaratorContext newDeclarator() { + return getRuleContext(NewDeclaratorContext.class, 0); + } + + public NoPointerNewDeclaratorContext noPointerNewDeclarator() { + return getRuleContext(NoPointerNewDeclaratorContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_newDeclarator; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitNewDeclarator(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterNewDeclarator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitNewDeclarator(this); + } + } + + public static class NoPointerNewDeclaratorContext extends ParserRuleContext { + public NoPointerNewDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_noPointerNewDeclarator; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitNoPointerNewDeclarator(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterNoPointerNewDeclarator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitNoPointerNewDeclarator(this); + } + } + + public static class NewInitializerContext extends ParserRuleContext { + public NewInitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_newInitializer; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitNewInitializer(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterNewInitializer(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitNewInitializer(this); + } + } + + public static class DeleteExpressionContext extends ParserRuleContext { + public DeleteExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_deleteExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitDeleteExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterDeleteExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitDeleteExpression(this); + } + } + + public static class NoExceptExpressionContext extends ParserRuleContext { + public NoExceptExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_noExceptExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitNoExceptExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterNoExceptExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitNoExceptExpression(this); + } + } + + public static class CastExpressionContext extends ParserRuleContext { + public CastExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_castExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitCastExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterCastExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitCastExpression(this); + } + } + + public static class PointerMemberExpressionContext extends ParserRuleContext { + public PointerMemberExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_pointerMemberExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitPointerMemberExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterPointerMemberExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitPointerMemberExpression(this); + } + } + + public static class MultiplicativeExpressionContext extends ParserRuleContext { + public MultiplicativeExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_multiplicativeExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitMultiplicativeExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterMultiplicativeExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitMultiplicativeExpression(this); + } + } + + public static class AdditiveExpressionContext extends ParserRuleContext { + public AdditiveExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_additiveExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitAdditiveExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterAdditiveExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitAdditiveExpression(this); + } + } + + public static class ShiftExpressionContext extends ParserRuleContext { + public ShiftExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_shiftExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitShiftExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterShiftExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitShiftExpression(this); + } + } + + public static class ShiftOperatorContext extends ParserRuleContext { + public ShiftOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_shiftOperator; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitShiftOperator(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterShiftOperator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitShiftOperator(this); + } + } + + public static class RelationalExpressionContext extends ParserRuleContext { + public RelationalExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_relationalExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitRelationalExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterRelationalExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitRelationalExpression(this); + } + } + + public static class EqualityExpressionContext extends ParserRuleContext { + public EqualityExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_equalityExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitEqualityExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterEqualityExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitEqualityExpression(this); + } + } + + public static class AndExpressionContext extends ParserRuleContext { + public AndExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_andExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitAndExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterAndExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitAndExpression(this); + } + } + + public static class ExclusiveOrExpressionContext extends ParserRuleContext { + public ExclusiveOrExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_exclusiveOrExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitExclusiveOrExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterExclusiveOrExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitExclusiveOrExpression(this); + } + } + + public static class InclusiveOrExpressionContext extends ParserRuleContext { + public InclusiveOrExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_inclusiveOrExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitInclusiveOrExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterInclusiveOrExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitInclusiveOrExpression(this); + } + } + + public static class LogicalAndExpressionContext extends ParserRuleContext { + public LogicalAndExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_logicalAndExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitLogicalAndExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterLogicalAndExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitLogicalAndExpression(this); + } + } + + public static class LogicalOrExpressionContext extends ParserRuleContext { + public LogicalOrExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_logicalOrExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitLogicalOrExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterLogicalOrExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitLogicalOrExpression(this); + } + } + + public static class ConditionalExpressionContext extends ParserRuleContext { + public ConditionalExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_conditionalExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitConditionalExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterConditionalExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitConditionalExpression(this); + } + } + + public static class AssignmentExpressionContext extends ParserRuleContext { + public AssignmentExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_assignmentExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitAssignmentExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterAssignmentExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitAssignmentExpression(this); + } + } + + public static class AssignmentOperatorContext extends ParserRuleContext { + public AssignmentOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_assignmentOperator; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitAssignmentOperator(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterAssignmentOperator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitAssignmentOperator(this); + } + } + + public static class ExpressionContext extends ParserRuleContext { + public ExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_expression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitExpression(this); + } + } + + public static class ConstantExpressionContext extends ParserRuleContext { + public ConstantExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public ConditionalExpressionContext conditionalExpression() { + return getRuleContext(ConditionalExpressionContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_constantExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitConstantExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterConstantExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitConstantExpression(this); + } + } + + public static class StatementContext extends ParserRuleContext { + public StatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public LabeledStatementContext labeledStatement() { + return getRuleContext(LabeledStatementContext.class, 0); + } + + public DeclarationStatementContext declarationStatement() { + return getRuleContext(DeclarationStatementContext.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); + } + + @Override + public int getRuleIndex() { + return RULE_statement; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitStatement(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitStatement(this); + } + } + + public static class LabeledStatementContext extends ParserRuleContext { + public LabeledStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_labeledStatement; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitLabeledStatement(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterLabeledStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitLabeledStatement(this); + } + } + + public static class ExpressionStatementContext extends ParserRuleContext { + public ExpressionStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Semi() { + return getToken(CPP14Parser.Semi, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_expressionStatement; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitExpressionStatement(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterExpressionStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitExpressionStatement(this); + } + } + + public static class CompoundStatementContext extends ParserRuleContext { + public CompoundStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LeftBrace() { + return getToken(CPP14Parser.LeftBrace, 0); + } + + public TerminalNode RightBrace() { + return getToken(CPP14Parser.RightBrace, 0); + } + + public StatementSeqContext statementSeq() { + return getRuleContext(StatementSeqContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_compoundStatement; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitCompoundStatement(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterCompoundStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitCompoundStatement(this); + } + } + + public static class StatementSeqContext extends ParserRuleContext { + public StatementSeqContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List statement() { + return getRuleContexts(StatementContext.class); + } + + public StatementContext statement(int i) { + return getRuleContext(StatementContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_statementSeq; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitStatementSeq(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterStatementSeq(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitStatementSeq(this); + } + } + + public static class SelectionStatementContext extends ParserRuleContext { + public SelectionStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_selectionStatement; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitSelectionStatement(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterSelectionStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitSelectionStatement(this); + } + } + + public static class ConditionContext extends ParserRuleContext { + public ConditionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_condition; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitCondition(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterCondition(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitCondition(this); + } + } + + public static class IterationStatementContext extends ParserRuleContext { + public IterationStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_iterationStatement; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitIterationStatement(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterIterationStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitIterationStatement(this); + } + } + + public static class ForInitStatementContext extends ParserRuleContext { + public ForInitStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public ExpressionStatementContext expressionStatement() { + return getRuleContext(ExpressionStatementContext.class, 0); + } + + public SimpleDeclarationContext simpleDeclaration() { + return getRuleContext(SimpleDeclarationContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_forInitStatement; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitForInitStatement(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterForInitStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitForInitStatement(this); + } + } + + public static class ForRangeDeclarationContext extends ParserRuleContext { + public ForRangeDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public DeclSpecifierSeqContext declSpecifierSeq() { + return getRuleContext(DeclSpecifierSeqContext.class, 0); + } + + public DeclaratorContext declarator() { + return getRuleContext(DeclaratorContext.class, 0); + } + + public AttributeSpecifierSeqContext attributeSpecifierSeq() { + return getRuleContext(AttributeSpecifierSeqContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_forRangeDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitForRangeDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterForRangeDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitForRangeDeclaration(this); + } + } + + public static class ForRangeInitializerContext extends ParserRuleContext { + public ForRangeInitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public BracedInitListContext bracedInitList() { + return getRuleContext(BracedInitListContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_forRangeInitializer; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitForRangeInitializer(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterForRangeInitializer(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitForRangeInitializer(this); + } + } + + public static class JumpStatementContext extends ParserRuleContext { + public JumpStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_jumpStatement; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitJumpStatement(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterJumpStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitJumpStatement(this); + } + } + + public static class DeclarationStatementContext extends ParserRuleContext { + public DeclarationStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public BlockDeclarationContext blockDeclaration() { + return getRuleContext(BlockDeclarationContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_declarationStatement; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitDeclarationStatement(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterDeclarationStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitDeclarationStatement(this); + } + } + + public static class DeclarationseqContext extends ParserRuleContext { + public DeclarationseqContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List declaration() { + return getRuleContexts(DeclarationContext.class); + } + + public DeclarationContext declaration(int i) { + return getRuleContext(DeclarationContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_declarationseq; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitDeclarationseq(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterDeclarationseq(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitDeclarationseq(this); + } + } + + public static class DeclarationContext extends ParserRuleContext { + public DeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_declaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitDeclaration(this); + } + } + + public static class BlockDeclarationContext extends ParserRuleContext { + public BlockDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_blockDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitBlockDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterBlockDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitBlockDeclaration(this); + } + } + + public static class AliasDeclarationContext extends ParserRuleContext { + public AliasDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_aliasDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitAliasDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterAliasDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitAliasDeclaration(this); + } + } + + public static class SimpleDeclarationContext extends ParserRuleContext { + public SimpleDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_simpleDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitSimpleDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterSimpleDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitSimpleDeclaration(this); + } + } + + public static class StaticAssertDeclarationContext extends ParserRuleContext { + public StaticAssertDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_staticAssertDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitStaticAssertDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterStaticAssertDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitStaticAssertDeclaration(this); + } + } + + public static class EmptyDeclarationContext extends ParserRuleContext { + public EmptyDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Semi() { + return getToken(CPP14Parser.Semi, 0); + } + + @Override + public int getRuleIndex() { + return RULE_emptyDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitEmptyDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterEmptyDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitEmptyDeclaration(this); + } + } + + public static class AttributeDeclarationContext extends ParserRuleContext { + public AttributeDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public AttributeSpecifierSeqContext attributeSpecifierSeq() { + return getRuleContext(AttributeSpecifierSeqContext.class, 0); + } + + public TerminalNode Semi() { + return getToken(CPP14Parser.Semi, 0); + } + + @Override + public int getRuleIndex() { + return RULE_attributeDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitAttributeDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterAttributeDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitAttributeDeclaration(this); + } + } + + public static class DeclSpecifierContext extends ParserRuleContext { + public DeclSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_declSpecifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitDeclSpecifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterDeclSpecifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitDeclSpecifier(this); + } + } + + public static class DeclSpecifierSeqContext extends ParserRuleContext { + public DeclSpecifierSeqContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_declSpecifierSeq; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitDeclSpecifierSeq(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterDeclSpecifierSeq(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitDeclSpecifierSeq(this); + } + } + + public static class StorageClassSpecifierContext extends ParserRuleContext { + public StorageClassSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_storageClassSpecifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitStorageClassSpecifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterStorageClassSpecifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitStorageClassSpecifier(this); + } + } + + public static class FunctionSpecifierContext extends ParserRuleContext { + public FunctionSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Inline() { + return getToken(CPP14Parser.Inline, 0); + } + + public TerminalNode Virtual() { + return getToken(CPP14Parser.Virtual, 0); + } + + public TerminalNode Explicit() { + return getToken(CPP14Parser.Explicit, 0); + } + + @Override + public int getRuleIndex() { + return RULE_functionSpecifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitFunctionSpecifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterFunctionSpecifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitFunctionSpecifier(this); + } + } + + public static class TypedefNameContext extends ParserRuleContext { + public TypedefNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Identifier() { + return getToken(CPP14Parser.Identifier, 0); + } + + @Override + public int getRuleIndex() { + return RULE_typedefName; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitTypedefName(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterTypedefName(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitTypedefName(this); + } + } + + public static class TypeSpecifierContext extends ParserRuleContext { + public TypeSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TrailingTypeSpecifierContext trailingTypeSpecifier() { + return getRuleContext(TrailingTypeSpecifierContext.class, 0); + } + + public ClassSpecifierContext classSpecifier() { + return getRuleContext(ClassSpecifierContext.class, 0); + } + + public EnumSpecifierContext enumSpecifier() { + return getRuleContext(EnumSpecifierContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_typeSpecifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitTypeSpecifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterTypeSpecifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitTypeSpecifier(this); + } + } + + public static class TrailingTypeSpecifierContext extends ParserRuleContext { + public TrailingTypeSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_trailingTypeSpecifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitTrailingTypeSpecifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterTrailingTypeSpecifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitTrailingTypeSpecifier(this); + } + } + + public static class TypeSpecifierSeqContext extends ParserRuleContext { + public TypeSpecifierSeqContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_typeSpecifierSeq; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitTypeSpecifierSeq(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterTypeSpecifierSeq(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitTypeSpecifierSeq(this); + } + } + + public static class TrailingTypeSpecifierSeqContext extends ParserRuleContext { + public TrailingTypeSpecifierSeqContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_trailingTypeSpecifierSeq; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitTrailingTypeSpecifierSeq(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterTrailingTypeSpecifierSeq(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitTrailingTypeSpecifierSeq(this); + } + } + + public static class SimpleTypeLengthModifierContext extends ParserRuleContext { + public SimpleTypeLengthModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Short() { + return getToken(CPP14Parser.Short, 0); + } + + public TerminalNode Long() { + return getToken(CPP14Parser.Long, 0); + } + + @Override + public int getRuleIndex() { + return RULE_simpleTypeLengthModifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitSimpleTypeLengthModifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterSimpleTypeLengthModifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitSimpleTypeLengthModifier(this); + } + } + + public static class SimpleTypeSignednessModifierContext extends ParserRuleContext { + public SimpleTypeSignednessModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Unsigned() { + return getToken(CPP14Parser.Unsigned, 0); + } + + public TerminalNode Signed() { + return getToken(CPP14Parser.Signed, 0); + } + + @Override + public int getRuleIndex() { + return RULE_simpleTypeSignednessModifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitSimpleTypeSignednessModifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterSimpleTypeSignednessModifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitSimpleTypeSignednessModifier(this); + } + } + + public static class SimpleTypeSpecifierContext extends ParserRuleContext { + public SimpleTypeSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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 SimpleTypeSignednessModifierContext simpleTypeSignednessModifier() { + return getRuleContext(SimpleTypeSignednessModifierContext.class, 0); + } + + public List simpleTypeLengthModifier() { + return getRuleContexts(SimpleTypeLengthModifierContext.class); + } + + public SimpleTypeLengthModifierContext simpleTypeLengthModifier(int i) { + return getRuleContext(SimpleTypeLengthModifierContext.class, i); + } + + 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 Int() { + return getToken(CPP14Parser.Int, 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); + } + + @Override + public int getRuleIndex() { + return RULE_simpleTypeSpecifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitSimpleTypeSpecifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterSimpleTypeSpecifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitSimpleTypeSpecifier(this); + } + } + + public static class TheTypeNameContext extends ParserRuleContext { + public TheTypeNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_theTypeName; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitTheTypeName(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterTheTypeName(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitTheTypeName(this); + } + } + + public static class DecltypeSpecifierContext extends ParserRuleContext { + public DecltypeSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_decltypeSpecifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitDecltypeSpecifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterDecltypeSpecifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitDecltypeSpecifier(this); + } + } + + public static class ElaboratedTypeSpecifierContext extends ParserRuleContext { + public ElaboratedTypeSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_elaboratedTypeSpecifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitElaboratedTypeSpecifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterElaboratedTypeSpecifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitElaboratedTypeSpecifier(this); + } + } + + public static class EnumNameContext extends ParserRuleContext { + public EnumNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Identifier() { + return getToken(CPP14Parser.Identifier, 0); + } + + @Override + public int getRuleIndex() { + return RULE_enumName; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitEnumName(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterEnumName(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitEnumName(this); + } + } + + public static class EnumSpecifierContext extends ParserRuleContext { + public EnumSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_enumSpecifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitEnumSpecifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterEnumSpecifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitEnumSpecifier(this); + } + } + + public static class EnumHeadContext extends ParserRuleContext { + public EnumHeadContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_enumHead; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitEnumHead(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterEnumHead(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitEnumHead(this); + } + } + + public static class OpaqueEnumDeclarationContext extends ParserRuleContext { + public OpaqueEnumDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_opaqueEnumDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitOpaqueEnumDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterOpaqueEnumDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitOpaqueEnumDeclaration(this); + } + } + + public static class EnumkeyContext extends ParserRuleContext { + public EnumkeyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Enum() { + return getToken(CPP14Parser.Enum, 0); + } + + public TerminalNode Class() { + return getToken(CPP14Parser.Class, 0); + } + + public TerminalNode Struct() { + return getToken(CPP14Parser.Struct, 0); + } + + @Override + public int getRuleIndex() { + return RULE_enumkey; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitEnumkey(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterEnumkey(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitEnumkey(this); + } + } + + public static class EnumbaseContext extends ParserRuleContext { + public EnumbaseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Colon() { + return getToken(CPP14Parser.Colon, 0); + } + + public TypeSpecifierSeqContext typeSpecifierSeq() { + return getRuleContext(TypeSpecifierSeqContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_enumbase; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitEnumbase(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterEnumbase(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitEnumbase(this); + } + } + + public static class EnumeratorListContext extends ParserRuleContext { + public EnumeratorListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_enumeratorList; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitEnumeratorList(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterEnumeratorList(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitEnumeratorList(this); + } + } + + public static class EnumeratorDefinitionContext extends ParserRuleContext { + public EnumeratorDefinitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public EnumeratorContext enumerator() { + return getRuleContext(EnumeratorContext.class, 0); + } + + public TerminalNode Assign() { + return getToken(CPP14Parser.Assign, 0); + } + + public ConstantExpressionContext constantExpression() { + return getRuleContext(ConstantExpressionContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_enumeratorDefinition; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitEnumeratorDefinition(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterEnumeratorDefinition(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitEnumeratorDefinition(this); + } + } + + public static class EnumeratorContext extends ParserRuleContext { + public EnumeratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Identifier() { + return getToken(CPP14Parser.Identifier, 0); + } + + @Override + public int getRuleIndex() { + return RULE_enumerator; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitEnumerator(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterEnumerator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitEnumerator(this); + } + } + + public static class NamespaceNameContext extends ParserRuleContext { + public NamespaceNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public OriginalNamespaceNameContext originalNamespaceName() { + return getRuleContext(OriginalNamespaceNameContext.class, 0); + } + + public NamespaceAliasContext namespaceAlias() { + return getRuleContext(NamespaceAliasContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_namespaceName; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitNamespaceName(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterNamespaceName(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitNamespaceName(this); + } + } + + public static class OriginalNamespaceNameContext extends ParserRuleContext { + public OriginalNamespaceNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Identifier() { + return getToken(CPP14Parser.Identifier, 0); + } + + @Override + public int getRuleIndex() { + return RULE_originalNamespaceName; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitOriginalNamespaceName(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterOriginalNamespaceName(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitOriginalNamespaceName(this); + } + } + + public static class NamespaceDefinitionContext extends ParserRuleContext { + public DeclarationseqContext namespaceBody; + + public NamespaceDefinitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_namespaceDefinition; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitNamespaceDefinition(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterNamespaceDefinition(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitNamespaceDefinition(this); + } + } + + public static class NamespaceAliasContext extends ParserRuleContext { + public NamespaceAliasContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Identifier() { + return getToken(CPP14Parser.Identifier, 0); + } + + @Override + public int getRuleIndex() { + return RULE_namespaceAlias; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitNamespaceAlias(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterNamespaceAlias(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitNamespaceAlias(this); + } + } + + public static class NamespaceAliasDefinitionContext extends ParserRuleContext { + public NamespaceAliasDefinitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_namespaceAliasDefinition; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitNamespaceAliasDefinition(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterNamespaceAliasDefinition(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitNamespaceAliasDefinition(this); + } + } + + public static class QualifiednamespacespecifierContext extends ParserRuleContext { + public QualifiednamespacespecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public NamespaceNameContext namespaceName() { + return getRuleContext(NamespaceNameContext.class, 0); + } + + public NestedNameSpecifierContext nestedNameSpecifier() { + return getRuleContext(NestedNameSpecifierContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_qualifiednamespacespecifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitQualifiednamespacespecifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterQualifiednamespacespecifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitQualifiednamespacespecifier(this); + } + } + + public static class UsingDeclarationContext extends ParserRuleContext { + public UsingDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_usingDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitUsingDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterUsingDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitUsingDeclaration(this); + } + } + + public static class UsingDirectiveContext extends ParserRuleContext { + public UsingDirectiveContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_usingDirective; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitUsingDirective(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterUsingDirective(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitUsingDirective(this); + } + } + + public static class AsmDefinitionContext extends ParserRuleContext { + public AsmDefinitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_asmDefinition; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitAsmDefinition(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterAsmDefinition(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitAsmDefinition(this); + } + } + + public static class LinkageSpecificationContext extends ParserRuleContext { + public LinkageSpecificationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_linkageSpecification; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitLinkageSpecification(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterLinkageSpecification(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitLinkageSpecification(this); + } + } + + public static class AttributeSpecifierSeqContext extends ParserRuleContext { + public AttributeSpecifierSeqContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List attributeSpecifier() { + return getRuleContexts(AttributeSpecifierContext.class); + } + + public AttributeSpecifierContext attributeSpecifier(int i) { + return getRuleContext(AttributeSpecifierContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_attributeSpecifierSeq; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitAttributeSpecifierSeq(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterAttributeSpecifierSeq(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitAttributeSpecifierSeq(this); + } + } + + public static class AttributeSpecifierContext extends ParserRuleContext { + public AttributeSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_attributeSpecifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitAttributeSpecifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterAttributeSpecifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitAttributeSpecifier(this); + } + } + + public static class AlignmentspecifierContext extends ParserRuleContext { + public AlignmentspecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_alignmentspecifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitAlignmentspecifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterAlignmentspecifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitAlignmentspecifier(this); + } + } + + public static class AttributeListContext extends ParserRuleContext { + public AttributeListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_attributeList; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitAttributeList(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterAttributeList(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitAttributeList(this); + } + } + + public static class AttributeContext extends ParserRuleContext { + public AttributeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_attribute; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitAttribute(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterAttribute(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitAttribute(this); + } + } + + public static class AttributeNamespaceContext extends ParserRuleContext { + public AttributeNamespaceContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Identifier() { + return getToken(CPP14Parser.Identifier, 0); + } + + @Override + public int getRuleIndex() { + return RULE_attributeNamespace; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitAttributeNamespace(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterAttributeNamespace(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitAttributeNamespace(this); + } + } + + public static class AttributeArgumentClauseContext extends ParserRuleContext { + public AttributeArgumentClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LeftParen() { + return getToken(CPP14Parser.LeftParen, 0); + } + + public TerminalNode RightParen() { + return getToken(CPP14Parser.RightParen, 0); + } + + public BalancedTokenSeqContext balancedTokenSeq() { + return getRuleContext(BalancedTokenSeqContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_attributeArgumentClause; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitAttributeArgumentClause(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterAttributeArgumentClause(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitAttributeArgumentClause(this); + } + } + + public static class BalancedTokenSeqContext extends ParserRuleContext { + public BalancedTokenSeqContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List balancedtoken() { + return getRuleContexts(BalancedtokenContext.class); + } + + public BalancedtokenContext balancedtoken(int i) { + return getRuleContext(BalancedtokenContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_balancedTokenSeq; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitBalancedTokenSeq(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterBalancedTokenSeq(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitBalancedTokenSeq(this); + } + } + + public static class BalancedtokenContext extends ParserRuleContext { + public BalancedtokenContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_balancedtoken; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitBalancedtoken(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterBalancedtoken(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitBalancedtoken(this); + } + } + + public static class InitDeclaratorListContext extends ParserRuleContext { + public InitDeclaratorListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_initDeclaratorList; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitInitDeclaratorList(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterInitDeclaratorList(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitInitDeclaratorList(this); + } + } + + public static class InitDeclaratorContext extends ParserRuleContext { + public InitDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public DeclaratorContext declarator() { + return getRuleContext(DeclaratorContext.class, 0); + } + + public InitializerContext initializer() { + return getRuleContext(InitializerContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_initDeclarator; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitInitDeclarator(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterInitDeclarator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitInitDeclarator(this); + } + } + + public static class DeclaratorContext extends ParserRuleContext { + public DeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_declarator; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitDeclarator(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterDeclarator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitDeclarator(this); + } + } + + public static class PointerDeclaratorContext extends ParserRuleContext { + public PointerDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_pointerDeclarator; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitPointerDeclarator(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterPointerDeclarator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitPointerDeclarator(this); + } + } + + public static class NoPointerDeclaratorContext extends ParserRuleContext { + public NoPointerDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_noPointerDeclarator; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitNoPointerDeclarator(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterNoPointerDeclarator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitNoPointerDeclarator(this); + } + } + + public static class ParametersAndQualifiersContext extends ParserRuleContext { + public ParametersAndQualifiersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_parametersAndQualifiers; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitParametersAndQualifiers(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterParametersAndQualifiers(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitParametersAndQualifiers(this); + } + } + + public static class TrailingReturnTypeContext extends ParserRuleContext { + public TrailingReturnTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Arrow() { + return getToken(CPP14Parser.Arrow, 0); + } + + public TrailingTypeSpecifierSeqContext trailingTypeSpecifierSeq() { + return getRuleContext(TrailingTypeSpecifierSeqContext.class, 0); + } + + public AbstractDeclaratorContext abstractDeclarator() { + return getRuleContext(AbstractDeclaratorContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_trailingReturnType; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitTrailingReturnType(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterTrailingReturnType(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitTrailingReturnType(this); + } + } + + public static class PointerOperatorContext extends ParserRuleContext { + public PointerOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_pointerOperator; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitPointerOperator(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterPointerOperator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitPointerOperator(this); + } + } + + public static class CvqualifierseqContext extends ParserRuleContext { + public CvqualifierseqContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List cvQualifier() { + return getRuleContexts(CvQualifierContext.class); + } + + public CvQualifierContext cvQualifier(int i) { + return getRuleContext(CvQualifierContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_cvqualifierseq; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitCvqualifierseq(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterCvqualifierseq(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitCvqualifierseq(this); + } + } + + public static class CvQualifierContext extends ParserRuleContext { + public CvQualifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Const() { + return getToken(CPP14Parser.Const, 0); + } + + public TerminalNode Volatile() { + return getToken(CPP14Parser.Volatile, 0); + } + + @Override + public int getRuleIndex() { + return RULE_cvQualifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitCvQualifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterCvQualifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitCvQualifier(this); + } + } + + public static class RefqualifierContext extends ParserRuleContext { + public RefqualifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode And() { + return getToken(CPP14Parser.And, 0); + } + + public TerminalNode AndAnd() { + return getToken(CPP14Parser.AndAnd, 0); + } + + @Override + public int getRuleIndex() { + return RULE_refqualifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitRefqualifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterRefqualifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitRefqualifier(this); + } + } + + public static class DeclaratoridContext extends ParserRuleContext { + public DeclaratoridContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public IdExpressionContext idExpression() { + return getRuleContext(IdExpressionContext.class, 0); + } + + public TerminalNode Ellipsis() { + return getToken(CPP14Parser.Ellipsis, 0); + } + + @Override + public int getRuleIndex() { + return RULE_declaratorid; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitDeclaratorid(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterDeclaratorid(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitDeclaratorid(this); + } + } + + public static class TheTypeIdContext extends ParserRuleContext { + public TheTypeIdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TypeSpecifierSeqContext typeSpecifierSeq() { + return getRuleContext(TypeSpecifierSeqContext.class, 0); + } + + public AbstractDeclaratorContext abstractDeclarator() { + return getRuleContext(AbstractDeclaratorContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_theTypeId; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitTheTypeId(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterTheTypeId(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitTheTypeId(this); + } + } + + public static class AbstractDeclaratorContext extends ParserRuleContext { + public AbstractDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_abstractDeclarator; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitAbstractDeclarator(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterAbstractDeclarator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitAbstractDeclarator(this); + } + } + + public static class PointerAbstractDeclaratorContext extends ParserRuleContext { + public PointerAbstractDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_pointerAbstractDeclarator; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitPointerAbstractDeclarator(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterPointerAbstractDeclarator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitPointerAbstractDeclarator(this); + } + } + + public static class NoPointerAbstractDeclaratorContext extends ParserRuleContext { + public NoPointerAbstractDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_noPointerAbstractDeclarator; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitNoPointerAbstractDeclarator(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterNoPointerAbstractDeclarator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitNoPointerAbstractDeclarator(this); + } + } + + public static class AbstractPackDeclaratorContext extends ParserRuleContext { + public AbstractPackDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_abstractPackDeclarator; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitAbstractPackDeclarator(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterAbstractPackDeclarator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitAbstractPackDeclarator(this); + } + } + + public static class NoPointerAbstractPackDeclaratorContext extends ParserRuleContext { + public NoPointerAbstractPackDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_noPointerAbstractPackDeclarator; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor) + .visitNoPointerAbstractPackDeclarator(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterNoPointerAbstractPackDeclarator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitNoPointerAbstractPackDeclarator(this); + } + } + + public static class ParameterDeclarationClauseContext extends ParserRuleContext { + public ParameterDeclarationClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public ParameterDeclarationListContext parameterDeclarationList() { + return getRuleContext(ParameterDeclarationListContext.class, 0); + } + + public TerminalNode Ellipsis() { + return getToken(CPP14Parser.Ellipsis, 0); + } + + public TerminalNode Comma() { + return getToken(CPP14Parser.Comma, 0); + } + + @Override + public int getRuleIndex() { + return RULE_parameterDeclarationClause; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitParameterDeclarationClause(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterParameterDeclarationClause(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitParameterDeclarationClause(this); + } + } + + public static class ParameterDeclarationListContext extends ParserRuleContext { + public ParameterDeclarationListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_parameterDeclarationList; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitParameterDeclarationList(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterParameterDeclarationList(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitParameterDeclarationList(this); + } + } + + public static class ParameterDeclarationContext extends ParserRuleContext { + public ParameterDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_parameterDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitParameterDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterParameterDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitParameterDeclaration(this); + } + } + + public static class FunctionDefinitionContext extends ParserRuleContext { + public FunctionDefinitionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_functionDefinition; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitFunctionDefinition(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterFunctionDefinition(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitFunctionDefinition(this); + } + } + + public static class FunctionBodyContext extends ParserRuleContext { + public FunctionBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_functionBody; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitFunctionBody(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterFunctionBody(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitFunctionBody(this); + } + } + + public static class InitializerContext extends ParserRuleContext { + public InitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_initializer; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitInitializer(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterInitializer(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitInitializer(this); + } + } + + public static class BraceOrEqualInitializerContext extends ParserRuleContext { + public BraceOrEqualInitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Assign() { + return getToken(CPP14Parser.Assign, 0); + } + + public InitializerClauseContext initializerClause() { + return getRuleContext(InitializerClauseContext.class, 0); + } + + public BracedInitListContext bracedInitList() { + return getRuleContext(BracedInitListContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_braceOrEqualInitializer; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitBraceOrEqualInitializer(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterBraceOrEqualInitializer(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitBraceOrEqualInitializer(this); + } + } + + public static class InitializerClauseContext extends ParserRuleContext { + public InitializerClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public AssignmentExpressionContext assignmentExpression() { + return getRuleContext(AssignmentExpressionContext.class, 0); + } + + public BracedInitListContext bracedInitList() { + return getRuleContext(BracedInitListContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_initializerClause; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitInitializerClause(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterInitializerClause(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitInitializerClause(this); + } + } + + public static class InitializerListContext extends ParserRuleContext { + public InitializerListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_initializerList; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitInitializerList(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterInitializerList(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitInitializerList(this); + } + } + + public static class BracedInitListContext extends ParserRuleContext { + public BracedInitListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_bracedInitList; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitBracedInitList(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterBracedInitList(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitBracedInitList(this); + } + } + + public static class ClassNameContext extends ParserRuleContext { + public ClassNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Identifier() { + return getToken(CPP14Parser.Identifier, 0); + } + + public SimpleTemplateIdContext simpleTemplateId() { + return getRuleContext(SimpleTemplateIdContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_className; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitClassName(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterClassName(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitClassName(this); + } + } + + public static class ClassSpecifierContext extends ParserRuleContext { + public ClassSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_classSpecifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitClassSpecifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterClassSpecifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitClassSpecifier(this); + } + } + + public static class ClassHeadContext extends ParserRuleContext { + public ClassHeadContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_classHead; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitClassHead(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterClassHead(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitClassHead(this); + } + } + + public static class ClassHeadNameContext extends ParserRuleContext { + public ClassHeadNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public ClassNameContext className() { + return getRuleContext(ClassNameContext.class, 0); + } + + public NestedNameSpecifierContext nestedNameSpecifier() { + return getRuleContext(NestedNameSpecifierContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_classHeadName; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitClassHeadName(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterClassHeadName(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitClassHeadName(this); + } + } + + public static class ClassVirtSpecifierContext extends ParserRuleContext { + public ClassVirtSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Final() { + return getToken(CPP14Parser.Final, 0); + } + + @Override + public int getRuleIndex() { + return RULE_classVirtSpecifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitClassVirtSpecifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterClassVirtSpecifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitClassVirtSpecifier(this); + } + } + + public static class ClassKeyContext extends ParserRuleContext { + public ClassKeyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Class() { + return getToken(CPP14Parser.Class, 0); + } + + public TerminalNode Struct() { + return getToken(CPP14Parser.Struct, 0); + } + + @Override + public int getRuleIndex() { + return RULE_classKey; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitClassKey(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterClassKey(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitClassKey(this); + } + } + + public static class MemberSpecificationContext extends ParserRuleContext { + public MemberSpecificationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_memberSpecification; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitMemberSpecification(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterMemberSpecification(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitMemberSpecification(this); + } + } + + public static class MemberdeclarationContext extends ParserRuleContext { + public MemberdeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_memberdeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitMemberdeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterMemberdeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitMemberdeclaration(this); + } + } + + public static class MemberDeclaratorListContext extends ParserRuleContext { + public MemberDeclaratorListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_memberDeclaratorList; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitMemberDeclaratorList(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterMemberDeclaratorList(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitMemberDeclaratorList(this); + } + } + + public static class MemberDeclaratorContext extends ParserRuleContext { + public MemberDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_memberDeclarator; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitMemberDeclarator(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterMemberDeclarator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitMemberDeclarator(this); + } + } + + public static class VirtualSpecifierSeqContext extends ParserRuleContext { + public VirtualSpecifierSeqContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List virtualSpecifier() { + return getRuleContexts(VirtualSpecifierContext.class); + } + + public VirtualSpecifierContext virtualSpecifier(int i) { + return getRuleContext(VirtualSpecifierContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_virtualSpecifierSeq; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitVirtualSpecifierSeq(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterVirtualSpecifierSeq(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitVirtualSpecifierSeq(this); + } + } + + public static class VirtualSpecifierContext extends ParserRuleContext { + public VirtualSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Override() { + return getToken(CPP14Parser.Override, 0); + } + + public TerminalNode Final() { + return getToken(CPP14Parser.Final, 0); + } + + @Override + public int getRuleIndex() { + return RULE_virtualSpecifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitVirtualSpecifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterVirtualSpecifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitVirtualSpecifier(this); + } + } + + public static class PureSpecifierContext extends ParserRuleContext { + public Token val; + + public PureSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Assign() { + return getToken(CPP14Parser.Assign, 0); + } + + public TerminalNode OctalLiteral() { + return getToken(CPP14Parser.OctalLiteral, 0); + } + + @Override + public int getRuleIndex() { + return RULE_pureSpecifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitPureSpecifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterPureSpecifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitPureSpecifier(this); + } + } + + public static class BaseClauseContext extends ParserRuleContext { + public BaseClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Colon() { + return getToken(CPP14Parser.Colon, 0); + } + + public BaseSpecifierListContext baseSpecifierList() { + return getRuleContext(BaseSpecifierListContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_baseClause; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitBaseClause(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterBaseClause(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitBaseClause(this); + } + } + + public static class BaseSpecifierListContext extends ParserRuleContext { + public BaseSpecifierListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_baseSpecifierList; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitBaseSpecifierList(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterBaseSpecifierList(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitBaseSpecifierList(this); + } + } + + public static class BaseSpecifierContext extends ParserRuleContext { + public BaseSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_baseSpecifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitBaseSpecifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterBaseSpecifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitBaseSpecifier(this); + } + } + + public static class ClassOrDeclTypeContext extends ParserRuleContext { + public ClassOrDeclTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public ClassNameContext className() { + return getRuleContext(ClassNameContext.class, 0); + } + + public NestedNameSpecifierContext nestedNameSpecifier() { + return getRuleContext(NestedNameSpecifierContext.class, 0); + } + + public DecltypeSpecifierContext decltypeSpecifier() { + return getRuleContext(DecltypeSpecifierContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_classOrDeclType; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitClassOrDeclType(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterClassOrDeclType(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitClassOrDeclType(this); + } + } + + public static class BaseTypeSpecifierContext extends ParserRuleContext { + public BaseTypeSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public ClassOrDeclTypeContext classOrDeclType() { + return getRuleContext(ClassOrDeclTypeContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_baseTypeSpecifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitBaseTypeSpecifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterBaseTypeSpecifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitBaseTypeSpecifier(this); + } + } + + public static class AccessSpecifierContext extends ParserRuleContext { + public AccessSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Private() { + return getToken(CPP14Parser.Private, 0); + } + + public TerminalNode Protected() { + return getToken(CPP14Parser.Protected, 0); + } + + public TerminalNode Public() { + return getToken(CPP14Parser.Public, 0); + } + + @Override + public int getRuleIndex() { + return RULE_accessSpecifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitAccessSpecifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterAccessSpecifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitAccessSpecifier(this); + } + } + + public static class ConversionFunctionIdContext extends ParserRuleContext { + public ConversionFunctionIdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Operator() { + return getToken(CPP14Parser.Operator, 0); + } + + public ConversionTypeIdContext conversionTypeId() { + return getRuleContext(ConversionTypeIdContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_conversionFunctionId; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitConversionFunctionId(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterConversionFunctionId(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitConversionFunctionId(this); + } + } + + public static class ConversionTypeIdContext extends ParserRuleContext { + public ConversionTypeIdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TypeSpecifierSeqContext typeSpecifierSeq() { + return getRuleContext(TypeSpecifierSeqContext.class, 0); + } + + public ConversionDeclaratorContext conversionDeclarator() { + return getRuleContext(ConversionDeclaratorContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_conversionTypeId; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitConversionTypeId(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterConversionTypeId(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitConversionTypeId(this); + } + } + + public static class ConversionDeclaratorContext extends ParserRuleContext { + public ConversionDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public PointerOperatorContext pointerOperator() { + return getRuleContext(PointerOperatorContext.class, 0); + } + + public ConversionDeclaratorContext conversionDeclarator() { + return getRuleContext(ConversionDeclaratorContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_conversionDeclarator; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitConversionDeclarator(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterConversionDeclarator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitConversionDeclarator(this); + } + } + + public static class ConstructorInitializerContext extends ParserRuleContext { + public ConstructorInitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Colon() { + return getToken(CPP14Parser.Colon, 0); + } + + public MemInitializerListContext memInitializerList() { + return getRuleContext(MemInitializerListContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_constructorInitializer; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitConstructorInitializer(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterConstructorInitializer(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitConstructorInitializer(this); + } + } + + public static class MemInitializerListContext extends ParserRuleContext { + public MemInitializerListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_memInitializerList; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitMemInitializerList(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterMemInitializerList(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitMemInitializerList(this); + } + } + + public static class MemInitializerContext extends ParserRuleContext { + public MemInitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_memInitializer; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitMemInitializer(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterMemInitializer(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitMemInitializer(this); + } + } + + public static class MeminitializeridContext extends ParserRuleContext { + public MeminitializeridContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public ClassOrDeclTypeContext classOrDeclType() { + return getRuleContext(ClassOrDeclTypeContext.class, 0); + } + + public TerminalNode Identifier() { + return getToken(CPP14Parser.Identifier, 0); + } + + @Override + public int getRuleIndex() { + return RULE_meminitializerid; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitMeminitializerid(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterMeminitializerid(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitMeminitializerid(this); + } + } + + public static class OperatorFunctionIdContext extends ParserRuleContext { + public OperatorFunctionIdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Operator() { + return getToken(CPP14Parser.Operator, 0); + } + + public TheOperatorContext theOperator() { + return getRuleContext(TheOperatorContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_operatorFunctionId; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitOperatorFunctionId(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterOperatorFunctionId(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitOperatorFunctionId(this); + } + } + + public static class LiteralOperatorIdContext extends ParserRuleContext { + public LiteralOperatorIdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_literalOperatorId; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitLiteralOperatorId(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterLiteralOperatorId(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitLiteralOperatorId(this); + } + } + + public static class TemplateDeclarationContext extends ParserRuleContext { + public TemplateDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_templateDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitTemplateDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterTemplateDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitTemplateDeclaration(this); + } + } + + public static class TemplateparameterListContext extends ParserRuleContext { + public TemplateparameterListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_templateparameterList; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitTemplateparameterList(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterTemplateparameterList(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitTemplateparameterList(this); + } + } + + public static class TemplateParameterContext extends ParserRuleContext { + public TemplateParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TypeParameterContext typeParameter() { + return getRuleContext(TypeParameterContext.class, 0); + } + + public ParameterDeclarationContext parameterDeclaration() { + return getRuleContext(ParameterDeclarationContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_templateParameter; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitTemplateParameter(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterTemplateParameter(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitTemplateParameter(this); + } + } + + public static class TypeParameterContext extends ParserRuleContext { + public TypeParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_typeParameter; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitTypeParameter(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterTypeParameter(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitTypeParameter(this); + } + } + + public static class SimpleTemplateIdContext extends ParserRuleContext { + public SimpleTemplateIdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_simpleTemplateId; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitSimpleTemplateId(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterSimpleTemplateId(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitSimpleTemplateId(this); + } + } + + public static class TemplateIdContext extends ParserRuleContext { + public TemplateIdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_templateId; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitTemplateId(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterTemplateId(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitTemplateId(this); + } + } + + public static class TemplateNameContext extends ParserRuleContext { + public TemplateNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Identifier() { + return getToken(CPP14Parser.Identifier, 0); + } + + @Override + public int getRuleIndex() { + return RULE_templateName; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitTemplateName(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterTemplateName(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitTemplateName(this); + } + } + + public static class TemplateArgumentListContext extends ParserRuleContext { + public TemplateArgumentListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_templateArgumentList; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitTemplateArgumentList(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterTemplateArgumentList(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitTemplateArgumentList(this); + } + } + + public static class TemplateArgumentContext extends ParserRuleContext { + public TemplateArgumentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TheTypeIdContext theTypeId() { + return getRuleContext(TheTypeIdContext.class, 0); + } + + public ConstantExpressionContext constantExpression() { + return getRuleContext(ConstantExpressionContext.class, 0); + } + + public IdExpressionContext idExpression() { + return getRuleContext(IdExpressionContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_templateArgument; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitTemplateArgument(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterTemplateArgument(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitTemplateArgument(this); + } + } + + public static class TypeNameSpecifierContext extends ParserRuleContext { + public TypeNameSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_typeNameSpecifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitTypeNameSpecifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterTypeNameSpecifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitTypeNameSpecifier(this); + } + } + + public static class ExplicitInstantiationContext extends ParserRuleContext { + public ExplicitInstantiationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Template() { + return getToken(CPP14Parser.Template, 0); + } + + public DeclarationContext declaration() { + return getRuleContext(DeclarationContext.class, 0); + } + + public TerminalNode Extern() { + return getToken(CPP14Parser.Extern, 0); + } + + @Override + public int getRuleIndex() { + return RULE_explicitInstantiation; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitExplicitInstantiation(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterExplicitInstantiation(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitExplicitInstantiation(this); + } + } + + public static class ExplicitSpecializationContext extends ParserRuleContext { + public ExplicitSpecializationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_explicitSpecialization; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitExplicitSpecialization(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterExplicitSpecialization(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitExplicitSpecialization(this); + } + } + + public static class TryBlockContext extends ParserRuleContext { + public TryBlockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Try() { + return getToken(CPP14Parser.Try, 0); + } + + public CompoundStatementContext compoundStatement() { + return getRuleContext(CompoundStatementContext.class, 0); + } + + public HandlerSeqContext handlerSeq() { + return getRuleContext(HandlerSeqContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_tryBlock; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitTryBlock(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterTryBlock(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitTryBlock(this); + } + } + + public static class FunctionTryBlockContext extends ParserRuleContext { + public FunctionTryBlockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_functionTryBlock; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitFunctionTryBlock(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterFunctionTryBlock(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitFunctionTryBlock(this); + } + } + + public static class HandlerSeqContext extends ParserRuleContext { + public HandlerSeqContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List handler() { + return getRuleContexts(HandlerContext.class); + } + + public HandlerContext handler(int i) { + return getRuleContext(HandlerContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_handlerSeq; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitHandlerSeq(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterHandlerSeq(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitHandlerSeq(this); + } + } + + public static class HandlerContext extends ParserRuleContext { + public HandlerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_handler; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitHandler(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterHandler(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitHandler(this); + } + } + + public static class ExceptionDeclarationContext extends ParserRuleContext { + public ExceptionDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_exceptionDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitExceptionDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterExceptionDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitExceptionDeclaration(this); + } + } + + public static class ThrowExpressionContext extends ParserRuleContext { + public ThrowExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Throw() { + return getToken(CPP14Parser.Throw, 0); + } + + public AssignmentExpressionContext assignmentExpression() { + return getRuleContext(AssignmentExpressionContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_throwExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitThrowExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterThrowExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitThrowExpression(this); + } + } + + public static class ExceptionSpecificationContext extends ParserRuleContext { + public ExceptionSpecificationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public DynamicExceptionSpecificationContext dynamicExceptionSpecification() { + return getRuleContext(DynamicExceptionSpecificationContext.class, 0); + } + + public NoeExceptSpecificationContext noeExceptSpecification() { + return getRuleContext(NoeExceptSpecificationContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_exceptionSpecification; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitExceptionSpecification(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterExceptionSpecification(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitExceptionSpecification(this); + } + } + + public static class DynamicExceptionSpecificationContext extends ParserRuleContext { + public DynamicExceptionSpecificationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_dynamicExceptionSpecification; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitDynamicExceptionSpecification(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterDynamicExceptionSpecification(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitDynamicExceptionSpecification(this); + } + } + + public static class TypeIdListContext extends ParserRuleContext { + public TypeIdListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_typeIdList; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitTypeIdList(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterTypeIdList(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitTypeIdList(this); + } + } + + public static class NoeExceptSpecificationContext extends ParserRuleContext { + public NoeExceptSpecificationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_noeExceptSpecification; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitNoeExceptSpecification(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterNoeExceptSpecification(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitNoeExceptSpecification(this); + } + } + + public static class TheOperatorContext extends ParserRuleContext { + public TheOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_theOperator; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitTheOperator(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterTheOperator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitTheOperator(this); + } + } + + public static class LiteralContext extends ParserRuleContext { + public LiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + 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); + } + + @Override + public int getRuleIndex() { + return RULE_literal; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof CPP14ParserVisitor) + return ((CPP14ParserVisitor) visitor).visitLiteral(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).enterLiteral(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof CPP14ParserListener) + ((CPP14ParserListener) listener).exitLiteral(this); + } + } +} diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14ParserBaseListener.java b/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14ParserBaseListener.java new file mode 100644 index 000000000..42e0b4e91 --- /dev/null +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14ParserBaseListener.java @@ -0,0 +1,2727 @@ +// Generated from CPP14Parser.g4 by ANTLR 4.9.3 +package com.itsaky.androidide.lexers.cpp; + +import org.antlr.v4.runtime.ParserRuleContext; +import org.antlr.v4.runtime.tree.ErrorNode; +import org.antlr.v4.runtime.tree.TerminalNode; + +/** + * This class provides an empty implementation of {@link CPP14ParserListener}, which can be extended + * to create a listener which only needs to handle a subset of the available methods. + */ +public class CPP14ParserBaseListener implements CPP14ParserListener { + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTranslationUnit(CPP14Parser.TranslationUnitContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTranslationUnit(CPP14Parser.TranslationUnitContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterPrimaryExpression(CPP14Parser.PrimaryExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitPrimaryExpression(CPP14Parser.PrimaryExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterIdExpression(CPP14Parser.IdExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitIdExpression(CPP14Parser.IdExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterUnqualifiedId(CPP14Parser.UnqualifiedIdContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitUnqualifiedId(CPP14Parser.UnqualifiedIdContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterQualifiedId(CPP14Parser.QualifiedIdContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitQualifiedId(CPP14Parser.QualifiedIdContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterNestedNameSpecifier(CPP14Parser.NestedNameSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitNestedNameSpecifier(CPP14Parser.NestedNameSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterLambdaExpression(CPP14Parser.LambdaExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitLambdaExpression(CPP14Parser.LambdaExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterLambdaIntroducer(CPP14Parser.LambdaIntroducerContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitLambdaIntroducer(CPP14Parser.LambdaIntroducerContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterLambdaCapture(CPP14Parser.LambdaCaptureContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitLambdaCapture(CPP14Parser.LambdaCaptureContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterCaptureDefault(CPP14Parser.CaptureDefaultContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitCaptureDefault(CPP14Parser.CaptureDefaultContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterCaptureList(CPP14Parser.CaptureListContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitCaptureList(CPP14Parser.CaptureListContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterCapture(CPP14Parser.CaptureContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitCapture(CPP14Parser.CaptureContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterSimpleCapture(CPP14Parser.SimpleCaptureContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitSimpleCapture(CPP14Parser.SimpleCaptureContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterInitcapture(CPP14Parser.InitcaptureContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitInitcapture(CPP14Parser.InitcaptureContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterLambdaDeclarator(CPP14Parser.LambdaDeclaratorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitLambdaDeclarator(CPP14Parser.LambdaDeclaratorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterPostfixExpression(CPP14Parser.PostfixExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitPostfixExpression(CPP14Parser.PostfixExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTypeIdOfTheTypeId(CPP14Parser.TypeIdOfTheTypeIdContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTypeIdOfTheTypeId(CPP14Parser.TypeIdOfTheTypeIdContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterExpressionList(CPP14Parser.ExpressionListContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitExpressionList(CPP14Parser.ExpressionListContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterPseudoDestructorName(CPP14Parser.PseudoDestructorNameContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitPseudoDestructorName(CPP14Parser.PseudoDestructorNameContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterUnaryExpression(CPP14Parser.UnaryExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitUnaryExpression(CPP14Parser.UnaryExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterUnaryOperator(CPP14Parser.UnaryOperatorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitUnaryOperator(CPP14Parser.UnaryOperatorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterNewExpression(CPP14Parser.NewExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitNewExpression(CPP14Parser.NewExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterNewPlacement(CPP14Parser.NewPlacementContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitNewPlacement(CPP14Parser.NewPlacementContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterNewTypeId(CPP14Parser.NewTypeIdContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitNewTypeId(CPP14Parser.NewTypeIdContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterNewDeclarator(CPP14Parser.NewDeclaratorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitNewDeclarator(CPP14Parser.NewDeclaratorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterNoPointerNewDeclarator(CPP14Parser.NoPointerNewDeclaratorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitNoPointerNewDeclarator(CPP14Parser.NoPointerNewDeclaratorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterNewInitializer(CPP14Parser.NewInitializerContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitNewInitializer(CPP14Parser.NewInitializerContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterDeleteExpression(CPP14Parser.DeleteExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitDeleteExpression(CPP14Parser.DeleteExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterNoExceptExpression(CPP14Parser.NoExceptExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitNoExceptExpression(CPP14Parser.NoExceptExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterCastExpression(CPP14Parser.CastExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitCastExpression(CPP14Parser.CastExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterPointerMemberExpression(CPP14Parser.PointerMemberExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitPointerMemberExpression(CPP14Parser.PointerMemberExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterMultiplicativeExpression(CPP14Parser.MultiplicativeExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitMultiplicativeExpression(CPP14Parser.MultiplicativeExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterAdditiveExpression(CPP14Parser.AdditiveExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitAdditiveExpression(CPP14Parser.AdditiveExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterShiftExpression(CPP14Parser.ShiftExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitShiftExpression(CPP14Parser.ShiftExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterShiftOperator(CPP14Parser.ShiftOperatorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitShiftOperator(CPP14Parser.ShiftOperatorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterRelationalExpression(CPP14Parser.RelationalExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitRelationalExpression(CPP14Parser.RelationalExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterEqualityExpression(CPP14Parser.EqualityExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitEqualityExpression(CPP14Parser.EqualityExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterAndExpression(CPP14Parser.AndExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitAndExpression(CPP14Parser.AndExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterExclusiveOrExpression(CPP14Parser.ExclusiveOrExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitExclusiveOrExpression(CPP14Parser.ExclusiveOrExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterInclusiveOrExpression(CPP14Parser.InclusiveOrExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitInclusiveOrExpression(CPP14Parser.InclusiveOrExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterLogicalAndExpression(CPP14Parser.LogicalAndExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitLogicalAndExpression(CPP14Parser.LogicalAndExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterLogicalOrExpression(CPP14Parser.LogicalOrExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitLogicalOrExpression(CPP14Parser.LogicalOrExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterConditionalExpression(CPP14Parser.ConditionalExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitConditionalExpression(CPP14Parser.ConditionalExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterAssignmentExpression(CPP14Parser.AssignmentExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitAssignmentExpression(CPP14Parser.AssignmentExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterAssignmentOperator(CPP14Parser.AssignmentOperatorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitAssignmentOperator(CPP14Parser.AssignmentOperatorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterExpression(CPP14Parser.ExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitExpression(CPP14Parser.ExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterConstantExpression(CPP14Parser.ConstantExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitConstantExpression(CPP14Parser.ConstantExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterStatement(CPP14Parser.StatementContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitStatement(CPP14Parser.StatementContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterLabeledStatement(CPP14Parser.LabeledStatementContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitLabeledStatement(CPP14Parser.LabeledStatementContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterExpressionStatement(CPP14Parser.ExpressionStatementContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitExpressionStatement(CPP14Parser.ExpressionStatementContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterCompoundStatement(CPP14Parser.CompoundStatementContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitCompoundStatement(CPP14Parser.CompoundStatementContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterStatementSeq(CPP14Parser.StatementSeqContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitStatementSeq(CPP14Parser.StatementSeqContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterSelectionStatement(CPP14Parser.SelectionStatementContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitSelectionStatement(CPP14Parser.SelectionStatementContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterCondition(CPP14Parser.ConditionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitCondition(CPP14Parser.ConditionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterIterationStatement(CPP14Parser.IterationStatementContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitIterationStatement(CPP14Parser.IterationStatementContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterForInitStatement(CPP14Parser.ForInitStatementContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitForInitStatement(CPP14Parser.ForInitStatementContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterForRangeDeclaration(CPP14Parser.ForRangeDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitForRangeDeclaration(CPP14Parser.ForRangeDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterForRangeInitializer(CPP14Parser.ForRangeInitializerContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitForRangeInitializer(CPP14Parser.ForRangeInitializerContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterJumpStatement(CPP14Parser.JumpStatementContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitJumpStatement(CPP14Parser.JumpStatementContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterDeclarationStatement(CPP14Parser.DeclarationStatementContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitDeclarationStatement(CPP14Parser.DeclarationStatementContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterDeclarationseq(CPP14Parser.DeclarationseqContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitDeclarationseq(CPP14Parser.DeclarationseqContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterDeclaration(CPP14Parser.DeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitDeclaration(CPP14Parser.DeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterBlockDeclaration(CPP14Parser.BlockDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitBlockDeclaration(CPP14Parser.BlockDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterAliasDeclaration(CPP14Parser.AliasDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitAliasDeclaration(CPP14Parser.AliasDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterSimpleDeclaration(CPP14Parser.SimpleDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitSimpleDeclaration(CPP14Parser.SimpleDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterStaticAssertDeclaration(CPP14Parser.StaticAssertDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitStaticAssertDeclaration(CPP14Parser.StaticAssertDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterEmptyDeclaration(CPP14Parser.EmptyDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitEmptyDeclaration(CPP14Parser.EmptyDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterAttributeDeclaration(CPP14Parser.AttributeDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitAttributeDeclaration(CPP14Parser.AttributeDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterDeclSpecifier(CPP14Parser.DeclSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitDeclSpecifier(CPP14Parser.DeclSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterDeclSpecifierSeq(CPP14Parser.DeclSpecifierSeqContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitDeclSpecifierSeq(CPP14Parser.DeclSpecifierSeqContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterStorageClassSpecifier(CPP14Parser.StorageClassSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitStorageClassSpecifier(CPP14Parser.StorageClassSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterFunctionSpecifier(CPP14Parser.FunctionSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitFunctionSpecifier(CPP14Parser.FunctionSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTypedefName(CPP14Parser.TypedefNameContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTypedefName(CPP14Parser.TypedefNameContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTypeSpecifier(CPP14Parser.TypeSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTypeSpecifier(CPP14Parser.TypeSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTrailingTypeSpecifier(CPP14Parser.TrailingTypeSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTrailingTypeSpecifier(CPP14Parser.TrailingTypeSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTypeSpecifierSeq(CPP14Parser.TypeSpecifierSeqContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTypeSpecifierSeq(CPP14Parser.TypeSpecifierSeqContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTrailingTypeSpecifierSeq(CPP14Parser.TrailingTypeSpecifierSeqContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTrailingTypeSpecifierSeq(CPP14Parser.TrailingTypeSpecifierSeqContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterSimpleTypeLengthModifier(CPP14Parser.SimpleTypeLengthModifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitSimpleTypeLengthModifier(CPP14Parser.SimpleTypeLengthModifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterSimpleTypeSignednessModifier( + CPP14Parser.SimpleTypeSignednessModifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitSimpleTypeSignednessModifier( + CPP14Parser.SimpleTypeSignednessModifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterSimpleTypeSpecifier(CPP14Parser.SimpleTypeSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitSimpleTypeSpecifier(CPP14Parser.SimpleTypeSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTheTypeName(CPP14Parser.TheTypeNameContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTheTypeName(CPP14Parser.TheTypeNameContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterDecltypeSpecifier(CPP14Parser.DecltypeSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitDecltypeSpecifier(CPP14Parser.DecltypeSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterElaboratedTypeSpecifier(CPP14Parser.ElaboratedTypeSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitElaboratedTypeSpecifier(CPP14Parser.ElaboratedTypeSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterEnumName(CPP14Parser.EnumNameContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitEnumName(CPP14Parser.EnumNameContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterEnumSpecifier(CPP14Parser.EnumSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitEnumSpecifier(CPP14Parser.EnumSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterEnumHead(CPP14Parser.EnumHeadContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitEnumHead(CPP14Parser.EnumHeadContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterOpaqueEnumDeclaration(CPP14Parser.OpaqueEnumDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitOpaqueEnumDeclaration(CPP14Parser.OpaqueEnumDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterEnumkey(CPP14Parser.EnumkeyContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitEnumkey(CPP14Parser.EnumkeyContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterEnumbase(CPP14Parser.EnumbaseContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitEnumbase(CPP14Parser.EnumbaseContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterEnumeratorList(CPP14Parser.EnumeratorListContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitEnumeratorList(CPP14Parser.EnumeratorListContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterEnumeratorDefinition(CPP14Parser.EnumeratorDefinitionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitEnumeratorDefinition(CPP14Parser.EnumeratorDefinitionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterEnumerator(CPP14Parser.EnumeratorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitEnumerator(CPP14Parser.EnumeratorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterNamespaceName(CPP14Parser.NamespaceNameContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitNamespaceName(CPP14Parser.NamespaceNameContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterOriginalNamespaceName(CPP14Parser.OriginalNamespaceNameContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitOriginalNamespaceName(CPP14Parser.OriginalNamespaceNameContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterNamespaceDefinition(CPP14Parser.NamespaceDefinitionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitNamespaceDefinition(CPP14Parser.NamespaceDefinitionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterNamespaceAlias(CPP14Parser.NamespaceAliasContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitNamespaceAlias(CPP14Parser.NamespaceAliasContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterNamespaceAliasDefinition(CPP14Parser.NamespaceAliasDefinitionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitNamespaceAliasDefinition(CPP14Parser.NamespaceAliasDefinitionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterQualifiednamespacespecifier( + CPP14Parser.QualifiednamespacespecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitQualifiednamespacespecifier(CPP14Parser.QualifiednamespacespecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterUsingDeclaration(CPP14Parser.UsingDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitUsingDeclaration(CPP14Parser.UsingDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterUsingDirective(CPP14Parser.UsingDirectiveContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitUsingDirective(CPP14Parser.UsingDirectiveContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterAsmDefinition(CPP14Parser.AsmDefinitionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitAsmDefinition(CPP14Parser.AsmDefinitionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterLinkageSpecification(CPP14Parser.LinkageSpecificationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitLinkageSpecification(CPP14Parser.LinkageSpecificationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterAttributeSpecifierSeq(CPP14Parser.AttributeSpecifierSeqContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitAttributeSpecifierSeq(CPP14Parser.AttributeSpecifierSeqContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterAttributeSpecifier(CPP14Parser.AttributeSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitAttributeSpecifier(CPP14Parser.AttributeSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterAlignmentspecifier(CPP14Parser.AlignmentspecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitAlignmentspecifier(CPP14Parser.AlignmentspecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterAttributeList(CPP14Parser.AttributeListContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitAttributeList(CPP14Parser.AttributeListContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterAttribute(CPP14Parser.AttributeContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitAttribute(CPP14Parser.AttributeContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterAttributeNamespace(CPP14Parser.AttributeNamespaceContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitAttributeNamespace(CPP14Parser.AttributeNamespaceContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterAttributeArgumentClause(CPP14Parser.AttributeArgumentClauseContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitAttributeArgumentClause(CPP14Parser.AttributeArgumentClauseContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterBalancedTokenSeq(CPP14Parser.BalancedTokenSeqContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitBalancedTokenSeq(CPP14Parser.BalancedTokenSeqContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterBalancedtoken(CPP14Parser.BalancedtokenContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitBalancedtoken(CPP14Parser.BalancedtokenContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterInitDeclaratorList(CPP14Parser.InitDeclaratorListContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitInitDeclaratorList(CPP14Parser.InitDeclaratorListContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterInitDeclarator(CPP14Parser.InitDeclaratorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitInitDeclarator(CPP14Parser.InitDeclaratorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterDeclarator(CPP14Parser.DeclaratorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitDeclarator(CPP14Parser.DeclaratorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterPointerDeclarator(CPP14Parser.PointerDeclaratorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitPointerDeclarator(CPP14Parser.PointerDeclaratorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterNoPointerDeclarator(CPP14Parser.NoPointerDeclaratorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitNoPointerDeclarator(CPP14Parser.NoPointerDeclaratorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterParametersAndQualifiers(CPP14Parser.ParametersAndQualifiersContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitParametersAndQualifiers(CPP14Parser.ParametersAndQualifiersContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTrailingReturnType(CPP14Parser.TrailingReturnTypeContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTrailingReturnType(CPP14Parser.TrailingReturnTypeContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterPointerOperator(CPP14Parser.PointerOperatorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitPointerOperator(CPP14Parser.PointerOperatorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterCvqualifierseq(CPP14Parser.CvqualifierseqContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitCvqualifierseq(CPP14Parser.CvqualifierseqContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterCvQualifier(CPP14Parser.CvQualifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitCvQualifier(CPP14Parser.CvQualifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterRefqualifier(CPP14Parser.RefqualifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitRefqualifier(CPP14Parser.RefqualifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterDeclaratorid(CPP14Parser.DeclaratoridContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitDeclaratorid(CPP14Parser.DeclaratoridContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTheTypeId(CPP14Parser.TheTypeIdContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTheTypeId(CPP14Parser.TheTypeIdContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterAbstractDeclarator(CPP14Parser.AbstractDeclaratorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitAbstractDeclarator(CPP14Parser.AbstractDeclaratorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterPointerAbstractDeclarator(CPP14Parser.PointerAbstractDeclaratorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitPointerAbstractDeclarator(CPP14Parser.PointerAbstractDeclaratorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterNoPointerAbstractDeclarator( + CPP14Parser.NoPointerAbstractDeclaratorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitNoPointerAbstractDeclarator(CPP14Parser.NoPointerAbstractDeclaratorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterAbstractPackDeclarator(CPP14Parser.AbstractPackDeclaratorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitAbstractPackDeclarator(CPP14Parser.AbstractPackDeclaratorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterNoPointerAbstractPackDeclarator( + CPP14Parser.NoPointerAbstractPackDeclaratorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitNoPointerAbstractPackDeclarator( + CPP14Parser.NoPointerAbstractPackDeclaratorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterParameterDeclarationClause(CPP14Parser.ParameterDeclarationClauseContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitParameterDeclarationClause(CPP14Parser.ParameterDeclarationClauseContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterParameterDeclarationList(CPP14Parser.ParameterDeclarationListContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitParameterDeclarationList(CPP14Parser.ParameterDeclarationListContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterParameterDeclaration(CPP14Parser.ParameterDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitParameterDeclaration(CPP14Parser.ParameterDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterFunctionDefinition(CPP14Parser.FunctionDefinitionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitFunctionDefinition(CPP14Parser.FunctionDefinitionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterFunctionBody(CPP14Parser.FunctionBodyContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitFunctionBody(CPP14Parser.FunctionBodyContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterInitializer(CPP14Parser.InitializerContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitInitializer(CPP14Parser.InitializerContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterBraceOrEqualInitializer(CPP14Parser.BraceOrEqualInitializerContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitBraceOrEqualInitializer(CPP14Parser.BraceOrEqualInitializerContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterInitializerClause(CPP14Parser.InitializerClauseContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitInitializerClause(CPP14Parser.InitializerClauseContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterInitializerList(CPP14Parser.InitializerListContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitInitializerList(CPP14Parser.InitializerListContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterBracedInitList(CPP14Parser.BracedInitListContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitBracedInitList(CPP14Parser.BracedInitListContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterClassName(CPP14Parser.ClassNameContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitClassName(CPP14Parser.ClassNameContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterClassSpecifier(CPP14Parser.ClassSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitClassSpecifier(CPP14Parser.ClassSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterClassHead(CPP14Parser.ClassHeadContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitClassHead(CPP14Parser.ClassHeadContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterClassHeadName(CPP14Parser.ClassHeadNameContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitClassHeadName(CPP14Parser.ClassHeadNameContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterClassVirtSpecifier(CPP14Parser.ClassVirtSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitClassVirtSpecifier(CPP14Parser.ClassVirtSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterClassKey(CPP14Parser.ClassKeyContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitClassKey(CPP14Parser.ClassKeyContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterMemberSpecification(CPP14Parser.MemberSpecificationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitMemberSpecification(CPP14Parser.MemberSpecificationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterMemberdeclaration(CPP14Parser.MemberdeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitMemberdeclaration(CPP14Parser.MemberdeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterMemberDeclaratorList(CPP14Parser.MemberDeclaratorListContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitMemberDeclaratorList(CPP14Parser.MemberDeclaratorListContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterMemberDeclarator(CPP14Parser.MemberDeclaratorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitMemberDeclarator(CPP14Parser.MemberDeclaratorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterVirtualSpecifierSeq(CPP14Parser.VirtualSpecifierSeqContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitVirtualSpecifierSeq(CPP14Parser.VirtualSpecifierSeqContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterVirtualSpecifier(CPP14Parser.VirtualSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitVirtualSpecifier(CPP14Parser.VirtualSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterPureSpecifier(CPP14Parser.PureSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitPureSpecifier(CPP14Parser.PureSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterBaseClause(CPP14Parser.BaseClauseContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitBaseClause(CPP14Parser.BaseClauseContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterBaseSpecifierList(CPP14Parser.BaseSpecifierListContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitBaseSpecifierList(CPP14Parser.BaseSpecifierListContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterBaseSpecifier(CPP14Parser.BaseSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitBaseSpecifier(CPP14Parser.BaseSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterClassOrDeclType(CPP14Parser.ClassOrDeclTypeContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitClassOrDeclType(CPP14Parser.ClassOrDeclTypeContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterBaseTypeSpecifier(CPP14Parser.BaseTypeSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitBaseTypeSpecifier(CPP14Parser.BaseTypeSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterAccessSpecifier(CPP14Parser.AccessSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitAccessSpecifier(CPP14Parser.AccessSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterConversionFunctionId(CPP14Parser.ConversionFunctionIdContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitConversionFunctionId(CPP14Parser.ConversionFunctionIdContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterConversionTypeId(CPP14Parser.ConversionTypeIdContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitConversionTypeId(CPP14Parser.ConversionTypeIdContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterConversionDeclarator(CPP14Parser.ConversionDeclaratorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitConversionDeclarator(CPP14Parser.ConversionDeclaratorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterConstructorInitializer(CPP14Parser.ConstructorInitializerContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitConstructorInitializer(CPP14Parser.ConstructorInitializerContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterMemInitializerList(CPP14Parser.MemInitializerListContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitMemInitializerList(CPP14Parser.MemInitializerListContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterMemInitializer(CPP14Parser.MemInitializerContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitMemInitializer(CPP14Parser.MemInitializerContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterMeminitializerid(CPP14Parser.MeminitializeridContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitMeminitializerid(CPP14Parser.MeminitializeridContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterOperatorFunctionId(CPP14Parser.OperatorFunctionIdContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitOperatorFunctionId(CPP14Parser.OperatorFunctionIdContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterLiteralOperatorId(CPP14Parser.LiteralOperatorIdContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitLiteralOperatorId(CPP14Parser.LiteralOperatorIdContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTemplateDeclaration(CPP14Parser.TemplateDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTemplateDeclaration(CPP14Parser.TemplateDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTemplateparameterList(CPP14Parser.TemplateparameterListContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTemplateparameterList(CPP14Parser.TemplateparameterListContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTemplateParameter(CPP14Parser.TemplateParameterContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTemplateParameter(CPP14Parser.TemplateParameterContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTypeParameter(CPP14Parser.TypeParameterContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTypeParameter(CPP14Parser.TypeParameterContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterSimpleTemplateId(CPP14Parser.SimpleTemplateIdContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitSimpleTemplateId(CPP14Parser.SimpleTemplateIdContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTemplateId(CPP14Parser.TemplateIdContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTemplateId(CPP14Parser.TemplateIdContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTemplateName(CPP14Parser.TemplateNameContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTemplateName(CPP14Parser.TemplateNameContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTemplateArgumentList(CPP14Parser.TemplateArgumentListContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTemplateArgumentList(CPP14Parser.TemplateArgumentListContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTemplateArgument(CPP14Parser.TemplateArgumentContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTemplateArgument(CPP14Parser.TemplateArgumentContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTypeNameSpecifier(CPP14Parser.TypeNameSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTypeNameSpecifier(CPP14Parser.TypeNameSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterExplicitInstantiation(CPP14Parser.ExplicitInstantiationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitExplicitInstantiation(CPP14Parser.ExplicitInstantiationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterExplicitSpecialization(CPP14Parser.ExplicitSpecializationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitExplicitSpecialization(CPP14Parser.ExplicitSpecializationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTryBlock(CPP14Parser.TryBlockContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTryBlock(CPP14Parser.TryBlockContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterFunctionTryBlock(CPP14Parser.FunctionTryBlockContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitFunctionTryBlock(CPP14Parser.FunctionTryBlockContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterHandlerSeq(CPP14Parser.HandlerSeqContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitHandlerSeq(CPP14Parser.HandlerSeqContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterHandler(CPP14Parser.HandlerContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitHandler(CPP14Parser.HandlerContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterExceptionDeclaration(CPP14Parser.ExceptionDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitExceptionDeclaration(CPP14Parser.ExceptionDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterThrowExpression(CPP14Parser.ThrowExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitThrowExpression(CPP14Parser.ThrowExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterExceptionSpecification(CPP14Parser.ExceptionSpecificationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitExceptionSpecification(CPP14Parser.ExceptionSpecificationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterDynamicExceptionSpecification( + CPP14Parser.DynamicExceptionSpecificationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitDynamicExceptionSpecification( + CPP14Parser.DynamicExceptionSpecificationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTypeIdList(CPP14Parser.TypeIdListContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTypeIdList(CPP14Parser.TypeIdListContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterNoeExceptSpecification(CPP14Parser.NoeExceptSpecificationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitNoeExceptSpecification(CPP14Parser.NoeExceptSpecificationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTheOperator(CPP14Parser.TheOperatorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTheOperator(CPP14Parser.TheOperatorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterLiteral(CPP14Parser.LiteralContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitLiteral(CPP14Parser.LiteralContext ctx) {} + + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void visitTerminal(TerminalNode node) {} + + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void visitErrorNode(ErrorNode node) {} + + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterEveryRule(ParserRuleContext ctx) {} + + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitEveryRule(ParserRuleContext ctx) {} +} diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14ParserBaseVisitor.java b/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14ParserBaseVisitor.java new file mode 100644 index 000000000..2ea0129bc --- /dev/null +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14ParserBaseVisitor.java @@ -0,0 +1,1927 @@ +// Generated from CPP14Parser.g4 by ANTLR 4.9.3 +package com.itsaky.androidide.lexers.cpp; + +import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor; + +/** + * This class provides an empty implementation of {@link CPP14ParserVisitor}, which can be extended + * to create a visitor which only needs to handle a subset of the available methods. + * + * @param The return type of the visit operation. Use {@link Void} for operations with no return + * type. + */ +public class CPP14ParserBaseVisitor extends AbstractParseTreeVisitor + implements CPP14ParserVisitor { + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTranslationUnit(CPP14Parser.TranslationUnitContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitPrimaryExpression(CPP14Parser.PrimaryExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitIdExpression(CPP14Parser.IdExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitUnqualifiedId(CPP14Parser.UnqualifiedIdContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitQualifiedId(CPP14Parser.QualifiedIdContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitNestedNameSpecifier(CPP14Parser.NestedNameSpecifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitLambdaExpression(CPP14Parser.LambdaExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitLambdaIntroducer(CPP14Parser.LambdaIntroducerContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitLambdaCapture(CPP14Parser.LambdaCaptureContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitCaptureDefault(CPP14Parser.CaptureDefaultContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitCaptureList(CPP14Parser.CaptureListContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitCapture(CPP14Parser.CaptureContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitSimpleCapture(CPP14Parser.SimpleCaptureContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitInitcapture(CPP14Parser.InitcaptureContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitLambdaDeclarator(CPP14Parser.LambdaDeclaratorContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitPostfixExpression(CPP14Parser.PostfixExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTypeIdOfTheTypeId(CPP14Parser.TypeIdOfTheTypeIdContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitExpressionList(CPP14Parser.ExpressionListContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitPseudoDestructorName(CPP14Parser.PseudoDestructorNameContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitUnaryExpression(CPP14Parser.UnaryExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitUnaryOperator(CPP14Parser.UnaryOperatorContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitNewExpression(CPP14Parser.NewExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitNewPlacement(CPP14Parser.NewPlacementContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitNewTypeId(CPP14Parser.NewTypeIdContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitNewDeclarator(CPP14Parser.NewDeclaratorContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitNoPointerNewDeclarator(CPP14Parser.NoPointerNewDeclaratorContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitNewInitializer(CPP14Parser.NewInitializerContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitDeleteExpression(CPP14Parser.DeleteExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitNoExceptExpression(CPP14Parser.NoExceptExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitCastExpression(CPP14Parser.CastExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitPointerMemberExpression(CPP14Parser.PointerMemberExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitMultiplicativeExpression(CPP14Parser.MultiplicativeExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitAdditiveExpression(CPP14Parser.AdditiveExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitShiftExpression(CPP14Parser.ShiftExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitShiftOperator(CPP14Parser.ShiftOperatorContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitRelationalExpression(CPP14Parser.RelationalExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitEqualityExpression(CPP14Parser.EqualityExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitAndExpression(CPP14Parser.AndExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitExclusiveOrExpression(CPP14Parser.ExclusiveOrExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitInclusiveOrExpression(CPP14Parser.InclusiveOrExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitLogicalAndExpression(CPP14Parser.LogicalAndExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitLogicalOrExpression(CPP14Parser.LogicalOrExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitConditionalExpression(CPP14Parser.ConditionalExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitAssignmentExpression(CPP14Parser.AssignmentExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitAssignmentOperator(CPP14Parser.AssignmentOperatorContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitExpression(CPP14Parser.ExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitConstantExpression(CPP14Parser.ConstantExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitStatement(CPP14Parser.StatementContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitLabeledStatement(CPP14Parser.LabeledStatementContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitExpressionStatement(CPP14Parser.ExpressionStatementContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitCompoundStatement(CPP14Parser.CompoundStatementContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitStatementSeq(CPP14Parser.StatementSeqContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitSelectionStatement(CPP14Parser.SelectionStatementContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitCondition(CPP14Parser.ConditionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitIterationStatement(CPP14Parser.IterationStatementContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitForInitStatement(CPP14Parser.ForInitStatementContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitForRangeDeclaration(CPP14Parser.ForRangeDeclarationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitForRangeInitializer(CPP14Parser.ForRangeInitializerContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitJumpStatement(CPP14Parser.JumpStatementContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitDeclarationStatement(CPP14Parser.DeclarationStatementContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitDeclarationseq(CPP14Parser.DeclarationseqContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitDeclaration(CPP14Parser.DeclarationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitBlockDeclaration(CPP14Parser.BlockDeclarationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitAliasDeclaration(CPP14Parser.AliasDeclarationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitSimpleDeclaration(CPP14Parser.SimpleDeclarationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitStaticAssertDeclaration(CPP14Parser.StaticAssertDeclarationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitEmptyDeclaration(CPP14Parser.EmptyDeclarationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitAttributeDeclaration(CPP14Parser.AttributeDeclarationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitDeclSpecifier(CPP14Parser.DeclSpecifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitDeclSpecifierSeq(CPP14Parser.DeclSpecifierSeqContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitStorageClassSpecifier(CPP14Parser.StorageClassSpecifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitFunctionSpecifier(CPP14Parser.FunctionSpecifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTypedefName(CPP14Parser.TypedefNameContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTypeSpecifier(CPP14Parser.TypeSpecifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTrailingTypeSpecifier(CPP14Parser.TrailingTypeSpecifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTypeSpecifierSeq(CPP14Parser.TypeSpecifierSeqContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTrailingTypeSpecifierSeq(CPP14Parser.TrailingTypeSpecifierSeqContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitSimpleTypeLengthModifier(CPP14Parser.SimpleTypeLengthModifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitSimpleTypeSignednessModifier(CPP14Parser.SimpleTypeSignednessModifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitSimpleTypeSpecifier(CPP14Parser.SimpleTypeSpecifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTheTypeName(CPP14Parser.TheTypeNameContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitDecltypeSpecifier(CPP14Parser.DecltypeSpecifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitElaboratedTypeSpecifier(CPP14Parser.ElaboratedTypeSpecifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitEnumName(CPP14Parser.EnumNameContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitEnumSpecifier(CPP14Parser.EnumSpecifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitEnumHead(CPP14Parser.EnumHeadContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitOpaqueEnumDeclaration(CPP14Parser.OpaqueEnumDeclarationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitEnumkey(CPP14Parser.EnumkeyContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitEnumbase(CPP14Parser.EnumbaseContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitEnumeratorList(CPP14Parser.EnumeratorListContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitEnumeratorDefinition(CPP14Parser.EnumeratorDefinitionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitEnumerator(CPP14Parser.EnumeratorContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitNamespaceName(CPP14Parser.NamespaceNameContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitOriginalNamespaceName(CPP14Parser.OriginalNamespaceNameContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitNamespaceDefinition(CPP14Parser.NamespaceDefinitionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitNamespaceAlias(CPP14Parser.NamespaceAliasContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitNamespaceAliasDefinition(CPP14Parser.NamespaceAliasDefinitionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitQualifiednamespacespecifier(CPP14Parser.QualifiednamespacespecifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitUsingDeclaration(CPP14Parser.UsingDeclarationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitUsingDirective(CPP14Parser.UsingDirectiveContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitAsmDefinition(CPP14Parser.AsmDefinitionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitLinkageSpecification(CPP14Parser.LinkageSpecificationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitAttributeSpecifierSeq(CPP14Parser.AttributeSpecifierSeqContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitAttributeSpecifier(CPP14Parser.AttributeSpecifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitAlignmentspecifier(CPP14Parser.AlignmentspecifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitAttributeList(CPP14Parser.AttributeListContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitAttribute(CPP14Parser.AttributeContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitAttributeNamespace(CPP14Parser.AttributeNamespaceContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitAttributeArgumentClause(CPP14Parser.AttributeArgumentClauseContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitBalancedTokenSeq(CPP14Parser.BalancedTokenSeqContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitBalancedtoken(CPP14Parser.BalancedtokenContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitInitDeclaratorList(CPP14Parser.InitDeclaratorListContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitInitDeclarator(CPP14Parser.InitDeclaratorContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitDeclarator(CPP14Parser.DeclaratorContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitPointerDeclarator(CPP14Parser.PointerDeclaratorContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitNoPointerDeclarator(CPP14Parser.NoPointerDeclaratorContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitParametersAndQualifiers(CPP14Parser.ParametersAndQualifiersContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTrailingReturnType(CPP14Parser.TrailingReturnTypeContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitPointerOperator(CPP14Parser.PointerOperatorContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitCvqualifierseq(CPP14Parser.CvqualifierseqContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitCvQualifier(CPP14Parser.CvQualifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitRefqualifier(CPP14Parser.RefqualifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitDeclaratorid(CPP14Parser.DeclaratoridContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTheTypeId(CPP14Parser.TheTypeIdContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitAbstractDeclarator(CPP14Parser.AbstractDeclaratorContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitPointerAbstractDeclarator(CPP14Parser.PointerAbstractDeclaratorContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitNoPointerAbstractDeclarator(CPP14Parser.NoPointerAbstractDeclaratorContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitAbstractPackDeclarator(CPP14Parser.AbstractPackDeclaratorContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitNoPointerAbstractPackDeclarator( + CPP14Parser.NoPointerAbstractPackDeclaratorContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitParameterDeclarationClause(CPP14Parser.ParameterDeclarationClauseContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitParameterDeclarationList(CPP14Parser.ParameterDeclarationListContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitParameterDeclaration(CPP14Parser.ParameterDeclarationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitFunctionDefinition(CPP14Parser.FunctionDefinitionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitFunctionBody(CPP14Parser.FunctionBodyContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitInitializer(CPP14Parser.InitializerContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitBraceOrEqualInitializer(CPP14Parser.BraceOrEqualInitializerContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitInitializerClause(CPP14Parser.InitializerClauseContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitInitializerList(CPP14Parser.InitializerListContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitBracedInitList(CPP14Parser.BracedInitListContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitClassName(CPP14Parser.ClassNameContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitClassSpecifier(CPP14Parser.ClassSpecifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitClassHead(CPP14Parser.ClassHeadContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitClassHeadName(CPP14Parser.ClassHeadNameContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitClassVirtSpecifier(CPP14Parser.ClassVirtSpecifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitClassKey(CPP14Parser.ClassKeyContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitMemberSpecification(CPP14Parser.MemberSpecificationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitMemberdeclaration(CPP14Parser.MemberdeclarationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitMemberDeclaratorList(CPP14Parser.MemberDeclaratorListContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitMemberDeclarator(CPP14Parser.MemberDeclaratorContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitVirtualSpecifierSeq(CPP14Parser.VirtualSpecifierSeqContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitVirtualSpecifier(CPP14Parser.VirtualSpecifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitPureSpecifier(CPP14Parser.PureSpecifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitBaseClause(CPP14Parser.BaseClauseContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitBaseSpecifierList(CPP14Parser.BaseSpecifierListContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitBaseSpecifier(CPP14Parser.BaseSpecifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitClassOrDeclType(CPP14Parser.ClassOrDeclTypeContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitBaseTypeSpecifier(CPP14Parser.BaseTypeSpecifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitAccessSpecifier(CPP14Parser.AccessSpecifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitConversionFunctionId(CPP14Parser.ConversionFunctionIdContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitConversionTypeId(CPP14Parser.ConversionTypeIdContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitConversionDeclarator(CPP14Parser.ConversionDeclaratorContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitConstructorInitializer(CPP14Parser.ConstructorInitializerContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitMemInitializerList(CPP14Parser.MemInitializerListContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitMemInitializer(CPP14Parser.MemInitializerContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitMeminitializerid(CPP14Parser.MeminitializeridContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitOperatorFunctionId(CPP14Parser.OperatorFunctionIdContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitLiteralOperatorId(CPP14Parser.LiteralOperatorIdContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTemplateDeclaration(CPP14Parser.TemplateDeclarationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTemplateparameterList(CPP14Parser.TemplateparameterListContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTemplateParameter(CPP14Parser.TemplateParameterContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTypeParameter(CPP14Parser.TypeParameterContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitSimpleTemplateId(CPP14Parser.SimpleTemplateIdContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTemplateId(CPP14Parser.TemplateIdContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTemplateName(CPP14Parser.TemplateNameContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTemplateArgumentList(CPP14Parser.TemplateArgumentListContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTemplateArgument(CPP14Parser.TemplateArgumentContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTypeNameSpecifier(CPP14Parser.TypeNameSpecifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitExplicitInstantiation(CPP14Parser.ExplicitInstantiationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitExplicitSpecialization(CPP14Parser.ExplicitSpecializationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTryBlock(CPP14Parser.TryBlockContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitFunctionTryBlock(CPP14Parser.FunctionTryBlockContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitHandlerSeq(CPP14Parser.HandlerSeqContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitHandler(CPP14Parser.HandlerContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitExceptionDeclaration(CPP14Parser.ExceptionDeclarationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitThrowExpression(CPP14Parser.ThrowExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitExceptionSpecification(CPP14Parser.ExceptionSpecificationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitDynamicExceptionSpecification( + CPP14Parser.DynamicExceptionSpecificationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTypeIdList(CPP14Parser.TypeIdListContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitNoeExceptSpecification(CPP14Parser.NoeExceptSpecificationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTheOperator(CPP14Parser.TheOperatorContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitLiteral(CPP14Parser.LiteralContext ctx) { + return visitChildren(ctx); + } +} diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14ParserListener.java b/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14ParserListener.java new file mode 100644 index 000000000..5f38537d5 --- /dev/null +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14ParserListener.java @@ -0,0 +1,2300 @@ +// Generated from CPP14Parser.g4 by ANTLR 4.9.3 +package com.itsaky.androidide.lexers.cpp; + +import org.antlr.v4.runtime.tree.ParseTreeListener; + +/** This interface defines a complete listener for a parse tree produced by {@link CPP14Parser}. */ +public interface CPP14ParserListener extends ParseTreeListener { + /** + * Enter a parse tree produced by {@link CPP14Parser#translationUnit}. + * + * @param ctx the parse tree + */ + void enterTranslationUnit(CPP14Parser.TranslationUnitContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#translationUnit}. + * + * @param ctx the parse tree + */ + void exitTranslationUnit(CPP14Parser.TranslationUnitContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#primaryExpression}. + * + * @param ctx the parse tree + */ + void enterPrimaryExpression(CPP14Parser.PrimaryExpressionContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#primaryExpression}. + * + * @param ctx the parse tree + */ + void exitPrimaryExpression(CPP14Parser.PrimaryExpressionContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#idExpression}. + * + * @param ctx the parse tree + */ + void enterIdExpression(CPP14Parser.IdExpressionContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#idExpression}. + * + * @param ctx the parse tree + */ + void exitIdExpression(CPP14Parser.IdExpressionContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#unqualifiedId}. + * + * @param ctx the parse tree + */ + void enterUnqualifiedId(CPP14Parser.UnqualifiedIdContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#unqualifiedId}. + * + * @param ctx the parse tree + */ + void exitUnqualifiedId(CPP14Parser.UnqualifiedIdContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#qualifiedId}. + * + * @param ctx the parse tree + */ + void enterQualifiedId(CPP14Parser.QualifiedIdContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#qualifiedId}. + * + * @param ctx the parse tree + */ + void exitQualifiedId(CPP14Parser.QualifiedIdContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#nestedNameSpecifier}. + * + * @param ctx the parse tree + */ + void enterNestedNameSpecifier(CPP14Parser.NestedNameSpecifierContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#nestedNameSpecifier}. + * + * @param ctx the parse tree + */ + void exitNestedNameSpecifier(CPP14Parser.NestedNameSpecifierContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#lambdaExpression}. + * + * @param ctx the parse tree + */ + void enterLambdaExpression(CPP14Parser.LambdaExpressionContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#lambdaExpression}. + * + * @param ctx the parse tree + */ + void exitLambdaExpression(CPP14Parser.LambdaExpressionContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#lambdaIntroducer}. + * + * @param ctx the parse tree + */ + void enterLambdaIntroducer(CPP14Parser.LambdaIntroducerContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#lambdaIntroducer}. + * + * @param ctx the parse tree + */ + void exitLambdaIntroducer(CPP14Parser.LambdaIntroducerContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#lambdaCapture}. + * + * @param ctx the parse tree + */ + void enterLambdaCapture(CPP14Parser.LambdaCaptureContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#lambdaCapture}. + * + * @param ctx the parse tree + */ + void exitLambdaCapture(CPP14Parser.LambdaCaptureContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#captureDefault}. + * + * @param ctx the parse tree + */ + void enterCaptureDefault(CPP14Parser.CaptureDefaultContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#captureDefault}. + * + * @param ctx the parse tree + */ + void exitCaptureDefault(CPP14Parser.CaptureDefaultContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#captureList}. + * + * @param ctx the parse tree + */ + void enterCaptureList(CPP14Parser.CaptureListContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#captureList}. + * + * @param ctx the parse tree + */ + void exitCaptureList(CPP14Parser.CaptureListContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#capture}. + * + * @param ctx the parse tree + */ + void enterCapture(CPP14Parser.CaptureContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#capture}. + * + * @param ctx the parse tree + */ + void exitCapture(CPP14Parser.CaptureContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#simpleCapture}. + * + * @param ctx the parse tree + */ + void enterSimpleCapture(CPP14Parser.SimpleCaptureContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#simpleCapture}. + * + * @param ctx the parse tree + */ + void exitSimpleCapture(CPP14Parser.SimpleCaptureContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#initcapture}. + * + * @param ctx the parse tree + */ + void enterInitcapture(CPP14Parser.InitcaptureContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#initcapture}. + * + * @param ctx the parse tree + */ + void exitInitcapture(CPP14Parser.InitcaptureContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#lambdaDeclarator}. + * + * @param ctx the parse tree + */ + void enterLambdaDeclarator(CPP14Parser.LambdaDeclaratorContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#lambdaDeclarator}. + * + * @param ctx the parse tree + */ + void exitLambdaDeclarator(CPP14Parser.LambdaDeclaratorContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#postfixExpression}. + * + * @param ctx the parse tree + */ + void enterPostfixExpression(CPP14Parser.PostfixExpressionContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#postfixExpression}. + * + * @param ctx the parse tree + */ + void exitPostfixExpression(CPP14Parser.PostfixExpressionContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#typeIdOfTheTypeId}. + * + * @param ctx the parse tree + */ + void enterTypeIdOfTheTypeId(CPP14Parser.TypeIdOfTheTypeIdContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#typeIdOfTheTypeId}. + * + * @param ctx the parse tree + */ + void exitTypeIdOfTheTypeId(CPP14Parser.TypeIdOfTheTypeIdContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#expressionList}. + * + * @param ctx the parse tree + */ + void enterExpressionList(CPP14Parser.ExpressionListContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#expressionList}. + * + * @param ctx the parse tree + */ + void exitExpressionList(CPP14Parser.ExpressionListContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#pseudoDestructorName}. + * + * @param ctx the parse tree + */ + void enterPseudoDestructorName(CPP14Parser.PseudoDestructorNameContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#pseudoDestructorName}. + * + * @param ctx the parse tree + */ + void exitPseudoDestructorName(CPP14Parser.PseudoDestructorNameContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#unaryExpression}. + * + * @param ctx the parse tree + */ + void enterUnaryExpression(CPP14Parser.UnaryExpressionContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#unaryExpression}. + * + * @param ctx the parse tree + */ + void exitUnaryExpression(CPP14Parser.UnaryExpressionContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#unaryOperator}. + * + * @param ctx the parse tree + */ + void enterUnaryOperator(CPP14Parser.UnaryOperatorContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#unaryOperator}. + * + * @param ctx the parse tree + */ + void exitUnaryOperator(CPP14Parser.UnaryOperatorContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#newExpression}. + * + * @param ctx the parse tree + */ + void enterNewExpression(CPP14Parser.NewExpressionContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#newExpression}. + * + * @param ctx the parse tree + */ + void exitNewExpression(CPP14Parser.NewExpressionContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#newPlacement}. + * + * @param ctx the parse tree + */ + void enterNewPlacement(CPP14Parser.NewPlacementContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#newPlacement}. + * + * @param ctx the parse tree + */ + void exitNewPlacement(CPP14Parser.NewPlacementContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#newTypeId}. + * + * @param ctx the parse tree + */ + void enterNewTypeId(CPP14Parser.NewTypeIdContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#newTypeId}. + * + * @param ctx the parse tree + */ + void exitNewTypeId(CPP14Parser.NewTypeIdContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#newDeclarator}. + * + * @param ctx the parse tree + */ + void enterNewDeclarator(CPP14Parser.NewDeclaratorContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#newDeclarator}. + * + * @param ctx the parse tree + */ + void exitNewDeclarator(CPP14Parser.NewDeclaratorContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#noPointerNewDeclarator}. + * + * @param ctx the parse tree + */ + void enterNoPointerNewDeclarator(CPP14Parser.NoPointerNewDeclaratorContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#noPointerNewDeclarator}. + * + * @param ctx the parse tree + */ + void exitNoPointerNewDeclarator(CPP14Parser.NoPointerNewDeclaratorContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#newInitializer}. + * + * @param ctx the parse tree + */ + void enterNewInitializer(CPP14Parser.NewInitializerContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#newInitializer}. + * + * @param ctx the parse tree + */ + void exitNewInitializer(CPP14Parser.NewInitializerContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#deleteExpression}. + * + * @param ctx the parse tree + */ + void enterDeleteExpression(CPP14Parser.DeleteExpressionContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#deleteExpression}. + * + * @param ctx the parse tree + */ + void exitDeleteExpression(CPP14Parser.DeleteExpressionContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#noExceptExpression}. + * + * @param ctx the parse tree + */ + void enterNoExceptExpression(CPP14Parser.NoExceptExpressionContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#noExceptExpression}. + * + * @param ctx the parse tree + */ + void exitNoExceptExpression(CPP14Parser.NoExceptExpressionContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#castExpression}. + * + * @param ctx the parse tree + */ + void enterCastExpression(CPP14Parser.CastExpressionContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#castExpression}. + * + * @param ctx the parse tree + */ + void exitCastExpression(CPP14Parser.CastExpressionContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#pointerMemberExpression}. + * + * @param ctx the parse tree + */ + void enterPointerMemberExpression(CPP14Parser.PointerMemberExpressionContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#pointerMemberExpression}. + * + * @param ctx the parse tree + */ + void exitPointerMemberExpression(CPP14Parser.PointerMemberExpressionContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#multiplicativeExpression}. + * + * @param ctx the parse tree + */ + void enterMultiplicativeExpression(CPP14Parser.MultiplicativeExpressionContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#multiplicativeExpression}. + * + * @param ctx the parse tree + */ + void exitMultiplicativeExpression(CPP14Parser.MultiplicativeExpressionContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#additiveExpression}. + * + * @param ctx the parse tree + */ + void enterAdditiveExpression(CPP14Parser.AdditiveExpressionContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#additiveExpression}. + * + * @param ctx the parse tree + */ + void exitAdditiveExpression(CPP14Parser.AdditiveExpressionContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#shiftExpression}. + * + * @param ctx the parse tree + */ + void enterShiftExpression(CPP14Parser.ShiftExpressionContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#shiftExpression}. + * + * @param ctx the parse tree + */ + void exitShiftExpression(CPP14Parser.ShiftExpressionContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#shiftOperator}. + * + * @param ctx the parse tree + */ + void enterShiftOperator(CPP14Parser.ShiftOperatorContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#shiftOperator}. + * + * @param ctx the parse tree + */ + void exitShiftOperator(CPP14Parser.ShiftOperatorContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#relationalExpression}. + * + * @param ctx the parse tree + */ + void enterRelationalExpression(CPP14Parser.RelationalExpressionContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#relationalExpression}. + * + * @param ctx the parse tree + */ + void exitRelationalExpression(CPP14Parser.RelationalExpressionContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#equalityExpression}. + * + * @param ctx the parse tree + */ + void enterEqualityExpression(CPP14Parser.EqualityExpressionContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#equalityExpression}. + * + * @param ctx the parse tree + */ + void exitEqualityExpression(CPP14Parser.EqualityExpressionContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#andExpression}. + * + * @param ctx the parse tree + */ + void enterAndExpression(CPP14Parser.AndExpressionContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#andExpression}. + * + * @param ctx the parse tree + */ + void exitAndExpression(CPP14Parser.AndExpressionContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#exclusiveOrExpression}. + * + * @param ctx the parse tree + */ + void enterExclusiveOrExpression(CPP14Parser.ExclusiveOrExpressionContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#exclusiveOrExpression}. + * + * @param ctx the parse tree + */ + void exitExclusiveOrExpression(CPP14Parser.ExclusiveOrExpressionContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#inclusiveOrExpression}. + * + * @param ctx the parse tree + */ + void enterInclusiveOrExpression(CPP14Parser.InclusiveOrExpressionContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#inclusiveOrExpression}. + * + * @param ctx the parse tree + */ + void exitInclusiveOrExpression(CPP14Parser.InclusiveOrExpressionContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#logicalAndExpression}. + * + * @param ctx the parse tree + */ + void enterLogicalAndExpression(CPP14Parser.LogicalAndExpressionContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#logicalAndExpression}. + * + * @param ctx the parse tree + */ + void exitLogicalAndExpression(CPP14Parser.LogicalAndExpressionContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#logicalOrExpression}. + * + * @param ctx the parse tree + */ + void enterLogicalOrExpression(CPP14Parser.LogicalOrExpressionContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#logicalOrExpression}. + * + * @param ctx the parse tree + */ + void exitLogicalOrExpression(CPP14Parser.LogicalOrExpressionContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#conditionalExpression}. + * + * @param ctx the parse tree + */ + void enterConditionalExpression(CPP14Parser.ConditionalExpressionContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#conditionalExpression}. + * + * @param ctx the parse tree + */ + void exitConditionalExpression(CPP14Parser.ConditionalExpressionContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#assignmentExpression}. + * + * @param ctx the parse tree + */ + void enterAssignmentExpression(CPP14Parser.AssignmentExpressionContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#assignmentExpression}. + * + * @param ctx the parse tree + */ + void exitAssignmentExpression(CPP14Parser.AssignmentExpressionContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#assignmentOperator}. + * + * @param ctx the parse tree + */ + void enterAssignmentOperator(CPP14Parser.AssignmentOperatorContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#assignmentOperator}. + * + * @param ctx the parse tree + */ + void exitAssignmentOperator(CPP14Parser.AssignmentOperatorContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#expression}. + * + * @param ctx the parse tree + */ + void enterExpression(CPP14Parser.ExpressionContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#expression}. + * + * @param ctx the parse tree + */ + void exitExpression(CPP14Parser.ExpressionContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#constantExpression}. + * + * @param ctx the parse tree + */ + void enterConstantExpression(CPP14Parser.ConstantExpressionContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#constantExpression}. + * + * @param ctx the parse tree + */ + void exitConstantExpression(CPP14Parser.ConstantExpressionContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#statement}. + * + * @param ctx the parse tree + */ + void enterStatement(CPP14Parser.StatementContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#statement}. + * + * @param ctx the parse tree + */ + void exitStatement(CPP14Parser.StatementContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#labeledStatement}. + * + * @param ctx the parse tree + */ + void enterLabeledStatement(CPP14Parser.LabeledStatementContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#labeledStatement}. + * + * @param ctx the parse tree + */ + void exitLabeledStatement(CPP14Parser.LabeledStatementContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#expressionStatement}. + * + * @param ctx the parse tree + */ + void enterExpressionStatement(CPP14Parser.ExpressionStatementContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#expressionStatement}. + * + * @param ctx the parse tree + */ + void exitExpressionStatement(CPP14Parser.ExpressionStatementContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#compoundStatement}. + * + * @param ctx the parse tree + */ + void enterCompoundStatement(CPP14Parser.CompoundStatementContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#compoundStatement}. + * + * @param ctx the parse tree + */ + void exitCompoundStatement(CPP14Parser.CompoundStatementContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#statementSeq}. + * + * @param ctx the parse tree + */ + void enterStatementSeq(CPP14Parser.StatementSeqContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#statementSeq}. + * + * @param ctx the parse tree + */ + void exitStatementSeq(CPP14Parser.StatementSeqContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#selectionStatement}. + * + * @param ctx the parse tree + */ + void enterSelectionStatement(CPP14Parser.SelectionStatementContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#selectionStatement}. + * + * @param ctx the parse tree + */ + void exitSelectionStatement(CPP14Parser.SelectionStatementContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#condition}. + * + * @param ctx the parse tree + */ + void enterCondition(CPP14Parser.ConditionContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#condition}. + * + * @param ctx the parse tree + */ + void exitCondition(CPP14Parser.ConditionContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#iterationStatement}. + * + * @param ctx the parse tree + */ + void enterIterationStatement(CPP14Parser.IterationStatementContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#iterationStatement}. + * + * @param ctx the parse tree + */ + void exitIterationStatement(CPP14Parser.IterationStatementContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#forInitStatement}. + * + * @param ctx the parse tree + */ + void enterForInitStatement(CPP14Parser.ForInitStatementContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#forInitStatement}. + * + * @param ctx the parse tree + */ + void exitForInitStatement(CPP14Parser.ForInitStatementContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#forRangeDeclaration}. + * + * @param ctx the parse tree + */ + void enterForRangeDeclaration(CPP14Parser.ForRangeDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#forRangeDeclaration}. + * + * @param ctx the parse tree + */ + void exitForRangeDeclaration(CPP14Parser.ForRangeDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#forRangeInitializer}. + * + * @param ctx the parse tree + */ + void enterForRangeInitializer(CPP14Parser.ForRangeInitializerContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#forRangeInitializer}. + * + * @param ctx the parse tree + */ + void exitForRangeInitializer(CPP14Parser.ForRangeInitializerContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#jumpStatement}. + * + * @param ctx the parse tree + */ + void enterJumpStatement(CPP14Parser.JumpStatementContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#jumpStatement}. + * + * @param ctx the parse tree + */ + void exitJumpStatement(CPP14Parser.JumpStatementContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#declarationStatement}. + * + * @param ctx the parse tree + */ + void enterDeclarationStatement(CPP14Parser.DeclarationStatementContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#declarationStatement}. + * + * @param ctx the parse tree + */ + void exitDeclarationStatement(CPP14Parser.DeclarationStatementContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#declarationseq}. + * + * @param ctx the parse tree + */ + void enterDeclarationseq(CPP14Parser.DeclarationseqContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#declarationseq}. + * + * @param ctx the parse tree + */ + void exitDeclarationseq(CPP14Parser.DeclarationseqContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#declaration}. + * + * @param ctx the parse tree + */ + void enterDeclaration(CPP14Parser.DeclarationContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#declaration}. + * + * @param ctx the parse tree + */ + void exitDeclaration(CPP14Parser.DeclarationContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#blockDeclaration}. + * + * @param ctx the parse tree + */ + void enterBlockDeclaration(CPP14Parser.BlockDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#blockDeclaration}. + * + * @param ctx the parse tree + */ + void exitBlockDeclaration(CPP14Parser.BlockDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#aliasDeclaration}. + * + * @param ctx the parse tree + */ + void enterAliasDeclaration(CPP14Parser.AliasDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#aliasDeclaration}. + * + * @param ctx the parse tree + */ + void exitAliasDeclaration(CPP14Parser.AliasDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#simpleDeclaration}. + * + * @param ctx the parse tree + */ + void enterSimpleDeclaration(CPP14Parser.SimpleDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#simpleDeclaration}. + * + * @param ctx the parse tree + */ + void exitSimpleDeclaration(CPP14Parser.SimpleDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#staticAssertDeclaration}. + * + * @param ctx the parse tree + */ + void enterStaticAssertDeclaration(CPP14Parser.StaticAssertDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#staticAssertDeclaration}. + * + * @param ctx the parse tree + */ + void exitStaticAssertDeclaration(CPP14Parser.StaticAssertDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#emptyDeclaration}. + * + * @param ctx the parse tree + */ + void enterEmptyDeclaration(CPP14Parser.EmptyDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#emptyDeclaration}. + * + * @param ctx the parse tree + */ + void exitEmptyDeclaration(CPP14Parser.EmptyDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#attributeDeclaration}. + * + * @param ctx the parse tree + */ + void enterAttributeDeclaration(CPP14Parser.AttributeDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#attributeDeclaration}. + * + * @param ctx the parse tree + */ + void exitAttributeDeclaration(CPP14Parser.AttributeDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#declSpecifier}. + * + * @param ctx the parse tree + */ + void enterDeclSpecifier(CPP14Parser.DeclSpecifierContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#declSpecifier}. + * + * @param ctx the parse tree + */ + void exitDeclSpecifier(CPP14Parser.DeclSpecifierContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#declSpecifierSeq}. + * + * @param ctx the parse tree + */ + void enterDeclSpecifierSeq(CPP14Parser.DeclSpecifierSeqContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#declSpecifierSeq}. + * + * @param ctx the parse tree + */ + void exitDeclSpecifierSeq(CPP14Parser.DeclSpecifierSeqContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#storageClassSpecifier}. + * + * @param ctx the parse tree + */ + void enterStorageClassSpecifier(CPP14Parser.StorageClassSpecifierContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#storageClassSpecifier}. + * + * @param ctx the parse tree + */ + void exitStorageClassSpecifier(CPP14Parser.StorageClassSpecifierContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#functionSpecifier}. + * + * @param ctx the parse tree + */ + void enterFunctionSpecifier(CPP14Parser.FunctionSpecifierContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#functionSpecifier}. + * + * @param ctx the parse tree + */ + void exitFunctionSpecifier(CPP14Parser.FunctionSpecifierContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#typedefName}. + * + * @param ctx the parse tree + */ + void enterTypedefName(CPP14Parser.TypedefNameContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#typedefName}. + * + * @param ctx the parse tree + */ + void exitTypedefName(CPP14Parser.TypedefNameContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#typeSpecifier}. + * + * @param ctx the parse tree + */ + void enterTypeSpecifier(CPP14Parser.TypeSpecifierContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#typeSpecifier}. + * + * @param ctx the parse tree + */ + void exitTypeSpecifier(CPP14Parser.TypeSpecifierContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#trailingTypeSpecifier}. + * + * @param ctx the parse tree + */ + void enterTrailingTypeSpecifier(CPP14Parser.TrailingTypeSpecifierContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#trailingTypeSpecifier}. + * + * @param ctx the parse tree + */ + void exitTrailingTypeSpecifier(CPP14Parser.TrailingTypeSpecifierContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#typeSpecifierSeq}. + * + * @param ctx the parse tree + */ + void enterTypeSpecifierSeq(CPP14Parser.TypeSpecifierSeqContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#typeSpecifierSeq}. + * + * @param ctx the parse tree + */ + void exitTypeSpecifierSeq(CPP14Parser.TypeSpecifierSeqContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#trailingTypeSpecifierSeq}. + * + * @param ctx the parse tree + */ + void enterTrailingTypeSpecifierSeq(CPP14Parser.TrailingTypeSpecifierSeqContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#trailingTypeSpecifierSeq}. + * + * @param ctx the parse tree + */ + void exitTrailingTypeSpecifierSeq(CPP14Parser.TrailingTypeSpecifierSeqContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#simpleTypeLengthModifier}. + * + * @param ctx the parse tree + */ + void enterSimpleTypeLengthModifier(CPP14Parser.SimpleTypeLengthModifierContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#simpleTypeLengthModifier}. + * + * @param ctx the parse tree + */ + void exitSimpleTypeLengthModifier(CPP14Parser.SimpleTypeLengthModifierContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#simpleTypeSignednessModifier}. + * + * @param ctx the parse tree + */ + void enterSimpleTypeSignednessModifier(CPP14Parser.SimpleTypeSignednessModifierContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#simpleTypeSignednessModifier}. + * + * @param ctx the parse tree + */ + void exitSimpleTypeSignednessModifier(CPP14Parser.SimpleTypeSignednessModifierContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#simpleTypeSpecifier}. + * + * @param ctx the parse tree + */ + void enterSimpleTypeSpecifier(CPP14Parser.SimpleTypeSpecifierContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#simpleTypeSpecifier}. + * + * @param ctx the parse tree + */ + void exitSimpleTypeSpecifier(CPP14Parser.SimpleTypeSpecifierContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#theTypeName}. + * + * @param ctx the parse tree + */ + void enterTheTypeName(CPP14Parser.TheTypeNameContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#theTypeName}. + * + * @param ctx the parse tree + */ + void exitTheTypeName(CPP14Parser.TheTypeNameContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#decltypeSpecifier}. + * + * @param ctx the parse tree + */ + void enterDecltypeSpecifier(CPP14Parser.DecltypeSpecifierContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#decltypeSpecifier}. + * + * @param ctx the parse tree + */ + void exitDecltypeSpecifier(CPP14Parser.DecltypeSpecifierContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#elaboratedTypeSpecifier}. + * + * @param ctx the parse tree + */ + void enterElaboratedTypeSpecifier(CPP14Parser.ElaboratedTypeSpecifierContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#elaboratedTypeSpecifier}. + * + * @param ctx the parse tree + */ + void exitElaboratedTypeSpecifier(CPP14Parser.ElaboratedTypeSpecifierContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#enumName}. + * + * @param ctx the parse tree + */ + void enterEnumName(CPP14Parser.EnumNameContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#enumName}. + * + * @param ctx the parse tree + */ + void exitEnumName(CPP14Parser.EnumNameContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#enumSpecifier}. + * + * @param ctx the parse tree + */ + void enterEnumSpecifier(CPP14Parser.EnumSpecifierContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#enumSpecifier}. + * + * @param ctx the parse tree + */ + void exitEnumSpecifier(CPP14Parser.EnumSpecifierContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#enumHead}. + * + * @param ctx the parse tree + */ + void enterEnumHead(CPP14Parser.EnumHeadContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#enumHead}. + * + * @param ctx the parse tree + */ + void exitEnumHead(CPP14Parser.EnumHeadContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#opaqueEnumDeclaration}. + * + * @param ctx the parse tree + */ + void enterOpaqueEnumDeclaration(CPP14Parser.OpaqueEnumDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#opaqueEnumDeclaration}. + * + * @param ctx the parse tree + */ + void exitOpaqueEnumDeclaration(CPP14Parser.OpaqueEnumDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#enumkey}. + * + * @param ctx the parse tree + */ + void enterEnumkey(CPP14Parser.EnumkeyContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#enumkey}. + * + * @param ctx the parse tree + */ + void exitEnumkey(CPP14Parser.EnumkeyContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#enumbase}. + * + * @param ctx the parse tree + */ + void enterEnumbase(CPP14Parser.EnumbaseContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#enumbase}. + * + * @param ctx the parse tree + */ + void exitEnumbase(CPP14Parser.EnumbaseContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#enumeratorList}. + * + * @param ctx the parse tree + */ + void enterEnumeratorList(CPP14Parser.EnumeratorListContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#enumeratorList}. + * + * @param ctx the parse tree + */ + void exitEnumeratorList(CPP14Parser.EnumeratorListContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#enumeratorDefinition}. + * + * @param ctx the parse tree + */ + void enterEnumeratorDefinition(CPP14Parser.EnumeratorDefinitionContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#enumeratorDefinition}. + * + * @param ctx the parse tree + */ + void exitEnumeratorDefinition(CPP14Parser.EnumeratorDefinitionContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#enumerator}. + * + * @param ctx the parse tree + */ + void enterEnumerator(CPP14Parser.EnumeratorContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#enumerator}. + * + * @param ctx the parse tree + */ + void exitEnumerator(CPP14Parser.EnumeratorContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#namespaceName}. + * + * @param ctx the parse tree + */ + void enterNamespaceName(CPP14Parser.NamespaceNameContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#namespaceName}. + * + * @param ctx the parse tree + */ + void exitNamespaceName(CPP14Parser.NamespaceNameContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#originalNamespaceName}. + * + * @param ctx the parse tree + */ + void enterOriginalNamespaceName(CPP14Parser.OriginalNamespaceNameContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#originalNamespaceName}. + * + * @param ctx the parse tree + */ + void exitOriginalNamespaceName(CPP14Parser.OriginalNamespaceNameContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#namespaceDefinition}. + * + * @param ctx the parse tree + */ + void enterNamespaceDefinition(CPP14Parser.NamespaceDefinitionContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#namespaceDefinition}. + * + * @param ctx the parse tree + */ + void exitNamespaceDefinition(CPP14Parser.NamespaceDefinitionContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#namespaceAlias}. + * + * @param ctx the parse tree + */ + void enterNamespaceAlias(CPP14Parser.NamespaceAliasContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#namespaceAlias}. + * + * @param ctx the parse tree + */ + void exitNamespaceAlias(CPP14Parser.NamespaceAliasContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#namespaceAliasDefinition}. + * + * @param ctx the parse tree + */ + void enterNamespaceAliasDefinition(CPP14Parser.NamespaceAliasDefinitionContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#namespaceAliasDefinition}. + * + * @param ctx the parse tree + */ + void exitNamespaceAliasDefinition(CPP14Parser.NamespaceAliasDefinitionContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#qualifiednamespacespecifier}. + * + * @param ctx the parse tree + */ + void enterQualifiednamespacespecifier(CPP14Parser.QualifiednamespacespecifierContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#qualifiednamespacespecifier}. + * + * @param ctx the parse tree + */ + void exitQualifiednamespacespecifier(CPP14Parser.QualifiednamespacespecifierContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#usingDeclaration}. + * + * @param ctx the parse tree + */ + void enterUsingDeclaration(CPP14Parser.UsingDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#usingDeclaration}. + * + * @param ctx the parse tree + */ + void exitUsingDeclaration(CPP14Parser.UsingDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#usingDirective}. + * + * @param ctx the parse tree + */ + void enterUsingDirective(CPP14Parser.UsingDirectiveContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#usingDirective}. + * + * @param ctx the parse tree + */ + void exitUsingDirective(CPP14Parser.UsingDirectiveContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#asmDefinition}. + * + * @param ctx the parse tree + */ + void enterAsmDefinition(CPP14Parser.AsmDefinitionContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#asmDefinition}. + * + * @param ctx the parse tree + */ + void exitAsmDefinition(CPP14Parser.AsmDefinitionContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#linkageSpecification}. + * + * @param ctx the parse tree + */ + void enterLinkageSpecification(CPP14Parser.LinkageSpecificationContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#linkageSpecification}. + * + * @param ctx the parse tree + */ + void exitLinkageSpecification(CPP14Parser.LinkageSpecificationContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#attributeSpecifierSeq}. + * + * @param ctx the parse tree + */ + void enterAttributeSpecifierSeq(CPP14Parser.AttributeSpecifierSeqContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#attributeSpecifierSeq}. + * + * @param ctx the parse tree + */ + void exitAttributeSpecifierSeq(CPP14Parser.AttributeSpecifierSeqContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#attributeSpecifier}. + * + * @param ctx the parse tree + */ + void enterAttributeSpecifier(CPP14Parser.AttributeSpecifierContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#attributeSpecifier}. + * + * @param ctx the parse tree + */ + void exitAttributeSpecifier(CPP14Parser.AttributeSpecifierContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#alignmentspecifier}. + * + * @param ctx the parse tree + */ + void enterAlignmentspecifier(CPP14Parser.AlignmentspecifierContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#alignmentspecifier}. + * + * @param ctx the parse tree + */ + void exitAlignmentspecifier(CPP14Parser.AlignmentspecifierContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#attributeList}. + * + * @param ctx the parse tree + */ + void enterAttributeList(CPP14Parser.AttributeListContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#attributeList}. + * + * @param ctx the parse tree + */ + void exitAttributeList(CPP14Parser.AttributeListContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#attribute}. + * + * @param ctx the parse tree + */ + void enterAttribute(CPP14Parser.AttributeContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#attribute}. + * + * @param ctx the parse tree + */ + void exitAttribute(CPP14Parser.AttributeContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#attributeNamespace}. + * + * @param ctx the parse tree + */ + void enterAttributeNamespace(CPP14Parser.AttributeNamespaceContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#attributeNamespace}. + * + * @param ctx the parse tree + */ + void exitAttributeNamespace(CPP14Parser.AttributeNamespaceContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#attributeArgumentClause}. + * + * @param ctx the parse tree + */ + void enterAttributeArgumentClause(CPP14Parser.AttributeArgumentClauseContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#attributeArgumentClause}. + * + * @param ctx the parse tree + */ + void exitAttributeArgumentClause(CPP14Parser.AttributeArgumentClauseContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#balancedTokenSeq}. + * + * @param ctx the parse tree + */ + void enterBalancedTokenSeq(CPP14Parser.BalancedTokenSeqContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#balancedTokenSeq}. + * + * @param ctx the parse tree + */ + void exitBalancedTokenSeq(CPP14Parser.BalancedTokenSeqContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#balancedtoken}. + * + * @param ctx the parse tree + */ + void enterBalancedtoken(CPP14Parser.BalancedtokenContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#balancedtoken}. + * + * @param ctx the parse tree + */ + void exitBalancedtoken(CPP14Parser.BalancedtokenContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#initDeclaratorList}. + * + * @param ctx the parse tree + */ + void enterInitDeclaratorList(CPP14Parser.InitDeclaratorListContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#initDeclaratorList}. + * + * @param ctx the parse tree + */ + void exitInitDeclaratorList(CPP14Parser.InitDeclaratorListContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#initDeclarator}. + * + * @param ctx the parse tree + */ + void enterInitDeclarator(CPP14Parser.InitDeclaratorContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#initDeclarator}. + * + * @param ctx the parse tree + */ + void exitInitDeclarator(CPP14Parser.InitDeclaratorContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#declarator}. + * + * @param ctx the parse tree + */ + void enterDeclarator(CPP14Parser.DeclaratorContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#declarator}. + * + * @param ctx the parse tree + */ + void exitDeclarator(CPP14Parser.DeclaratorContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#pointerDeclarator}. + * + * @param ctx the parse tree + */ + void enterPointerDeclarator(CPP14Parser.PointerDeclaratorContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#pointerDeclarator}. + * + * @param ctx the parse tree + */ + void exitPointerDeclarator(CPP14Parser.PointerDeclaratorContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#noPointerDeclarator}. + * + * @param ctx the parse tree + */ + void enterNoPointerDeclarator(CPP14Parser.NoPointerDeclaratorContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#noPointerDeclarator}. + * + * @param ctx the parse tree + */ + void exitNoPointerDeclarator(CPP14Parser.NoPointerDeclaratorContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#parametersAndQualifiers}. + * + * @param ctx the parse tree + */ + void enterParametersAndQualifiers(CPP14Parser.ParametersAndQualifiersContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#parametersAndQualifiers}. + * + * @param ctx the parse tree + */ + void exitParametersAndQualifiers(CPP14Parser.ParametersAndQualifiersContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#trailingReturnType}. + * + * @param ctx the parse tree + */ + void enterTrailingReturnType(CPP14Parser.TrailingReturnTypeContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#trailingReturnType}. + * + * @param ctx the parse tree + */ + void exitTrailingReturnType(CPP14Parser.TrailingReturnTypeContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#pointerOperator}. + * + * @param ctx the parse tree + */ + void enterPointerOperator(CPP14Parser.PointerOperatorContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#pointerOperator}. + * + * @param ctx the parse tree + */ + void exitPointerOperator(CPP14Parser.PointerOperatorContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#cvqualifierseq}. + * + * @param ctx the parse tree + */ + void enterCvqualifierseq(CPP14Parser.CvqualifierseqContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#cvqualifierseq}. + * + * @param ctx the parse tree + */ + void exitCvqualifierseq(CPP14Parser.CvqualifierseqContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#cvQualifier}. + * + * @param ctx the parse tree + */ + void enterCvQualifier(CPP14Parser.CvQualifierContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#cvQualifier}. + * + * @param ctx the parse tree + */ + void exitCvQualifier(CPP14Parser.CvQualifierContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#refqualifier}. + * + * @param ctx the parse tree + */ + void enterRefqualifier(CPP14Parser.RefqualifierContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#refqualifier}. + * + * @param ctx the parse tree + */ + void exitRefqualifier(CPP14Parser.RefqualifierContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#declaratorid}. + * + * @param ctx the parse tree + */ + void enterDeclaratorid(CPP14Parser.DeclaratoridContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#declaratorid}. + * + * @param ctx the parse tree + */ + void exitDeclaratorid(CPP14Parser.DeclaratoridContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#theTypeId}. + * + * @param ctx the parse tree + */ + void enterTheTypeId(CPP14Parser.TheTypeIdContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#theTypeId}. + * + * @param ctx the parse tree + */ + void exitTheTypeId(CPP14Parser.TheTypeIdContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#abstractDeclarator}. + * + * @param ctx the parse tree + */ + void enterAbstractDeclarator(CPP14Parser.AbstractDeclaratorContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#abstractDeclarator}. + * + * @param ctx the parse tree + */ + void exitAbstractDeclarator(CPP14Parser.AbstractDeclaratorContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#pointerAbstractDeclarator}. + * + * @param ctx the parse tree + */ + void enterPointerAbstractDeclarator(CPP14Parser.PointerAbstractDeclaratorContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#pointerAbstractDeclarator}. + * + * @param ctx the parse tree + */ + void exitPointerAbstractDeclarator(CPP14Parser.PointerAbstractDeclaratorContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#noPointerAbstractDeclarator}. + * + * @param ctx the parse tree + */ + void enterNoPointerAbstractDeclarator(CPP14Parser.NoPointerAbstractDeclaratorContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#noPointerAbstractDeclarator}. + * + * @param ctx the parse tree + */ + void exitNoPointerAbstractDeclarator(CPP14Parser.NoPointerAbstractDeclaratorContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#abstractPackDeclarator}. + * + * @param ctx the parse tree + */ + void enterAbstractPackDeclarator(CPP14Parser.AbstractPackDeclaratorContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#abstractPackDeclarator}. + * + * @param ctx the parse tree + */ + void exitAbstractPackDeclarator(CPP14Parser.AbstractPackDeclaratorContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#noPointerAbstractPackDeclarator}. + * + * @param ctx the parse tree + */ + void enterNoPointerAbstractPackDeclarator(CPP14Parser.NoPointerAbstractPackDeclaratorContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#noPointerAbstractPackDeclarator}. + * + * @param ctx the parse tree + */ + void exitNoPointerAbstractPackDeclarator(CPP14Parser.NoPointerAbstractPackDeclaratorContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#parameterDeclarationClause}. + * + * @param ctx the parse tree + */ + void enterParameterDeclarationClause(CPP14Parser.ParameterDeclarationClauseContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#parameterDeclarationClause}. + * + * @param ctx the parse tree + */ + void exitParameterDeclarationClause(CPP14Parser.ParameterDeclarationClauseContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#parameterDeclarationList}. + * + * @param ctx the parse tree + */ + void enterParameterDeclarationList(CPP14Parser.ParameterDeclarationListContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#parameterDeclarationList}. + * + * @param ctx the parse tree + */ + void exitParameterDeclarationList(CPP14Parser.ParameterDeclarationListContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#parameterDeclaration}. + * + * @param ctx the parse tree + */ + void enterParameterDeclaration(CPP14Parser.ParameterDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#parameterDeclaration}. + * + * @param ctx the parse tree + */ + void exitParameterDeclaration(CPP14Parser.ParameterDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#functionDefinition}. + * + * @param ctx the parse tree + */ + void enterFunctionDefinition(CPP14Parser.FunctionDefinitionContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#functionDefinition}. + * + * @param ctx the parse tree + */ + void exitFunctionDefinition(CPP14Parser.FunctionDefinitionContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#functionBody}. + * + * @param ctx the parse tree + */ + void enterFunctionBody(CPP14Parser.FunctionBodyContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#functionBody}. + * + * @param ctx the parse tree + */ + void exitFunctionBody(CPP14Parser.FunctionBodyContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#initializer}. + * + * @param ctx the parse tree + */ + void enterInitializer(CPP14Parser.InitializerContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#initializer}. + * + * @param ctx the parse tree + */ + void exitInitializer(CPP14Parser.InitializerContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#braceOrEqualInitializer}. + * + * @param ctx the parse tree + */ + void enterBraceOrEqualInitializer(CPP14Parser.BraceOrEqualInitializerContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#braceOrEqualInitializer}. + * + * @param ctx the parse tree + */ + void exitBraceOrEqualInitializer(CPP14Parser.BraceOrEqualInitializerContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#initializerClause}. + * + * @param ctx the parse tree + */ + void enterInitializerClause(CPP14Parser.InitializerClauseContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#initializerClause}. + * + * @param ctx the parse tree + */ + void exitInitializerClause(CPP14Parser.InitializerClauseContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#initializerList}. + * + * @param ctx the parse tree + */ + void enterInitializerList(CPP14Parser.InitializerListContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#initializerList}. + * + * @param ctx the parse tree + */ + void exitInitializerList(CPP14Parser.InitializerListContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#bracedInitList}. + * + * @param ctx the parse tree + */ + void enterBracedInitList(CPP14Parser.BracedInitListContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#bracedInitList}. + * + * @param ctx the parse tree + */ + void exitBracedInitList(CPP14Parser.BracedInitListContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#className}. + * + * @param ctx the parse tree + */ + void enterClassName(CPP14Parser.ClassNameContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#className}. + * + * @param ctx the parse tree + */ + void exitClassName(CPP14Parser.ClassNameContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#classSpecifier}. + * + * @param ctx the parse tree + */ + void enterClassSpecifier(CPP14Parser.ClassSpecifierContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#classSpecifier}. + * + * @param ctx the parse tree + */ + void exitClassSpecifier(CPP14Parser.ClassSpecifierContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#classHead}. + * + * @param ctx the parse tree + */ + void enterClassHead(CPP14Parser.ClassHeadContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#classHead}. + * + * @param ctx the parse tree + */ + void exitClassHead(CPP14Parser.ClassHeadContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#classHeadName}. + * + * @param ctx the parse tree + */ + void enterClassHeadName(CPP14Parser.ClassHeadNameContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#classHeadName}. + * + * @param ctx the parse tree + */ + void exitClassHeadName(CPP14Parser.ClassHeadNameContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#classVirtSpecifier}. + * + * @param ctx the parse tree + */ + void enterClassVirtSpecifier(CPP14Parser.ClassVirtSpecifierContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#classVirtSpecifier}. + * + * @param ctx the parse tree + */ + void exitClassVirtSpecifier(CPP14Parser.ClassVirtSpecifierContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#classKey}. + * + * @param ctx the parse tree + */ + void enterClassKey(CPP14Parser.ClassKeyContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#classKey}. + * + * @param ctx the parse tree + */ + void exitClassKey(CPP14Parser.ClassKeyContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#memberSpecification}. + * + * @param ctx the parse tree + */ + void enterMemberSpecification(CPP14Parser.MemberSpecificationContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#memberSpecification}. + * + * @param ctx the parse tree + */ + void exitMemberSpecification(CPP14Parser.MemberSpecificationContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#memberdeclaration}. + * + * @param ctx the parse tree + */ + void enterMemberdeclaration(CPP14Parser.MemberdeclarationContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#memberdeclaration}. + * + * @param ctx the parse tree + */ + void exitMemberdeclaration(CPP14Parser.MemberdeclarationContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#memberDeclaratorList}. + * + * @param ctx the parse tree + */ + void enterMemberDeclaratorList(CPP14Parser.MemberDeclaratorListContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#memberDeclaratorList}. + * + * @param ctx the parse tree + */ + void exitMemberDeclaratorList(CPP14Parser.MemberDeclaratorListContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#memberDeclarator}. + * + * @param ctx the parse tree + */ + void enterMemberDeclarator(CPP14Parser.MemberDeclaratorContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#memberDeclarator}. + * + * @param ctx the parse tree + */ + void exitMemberDeclarator(CPP14Parser.MemberDeclaratorContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#virtualSpecifierSeq}. + * + * @param ctx the parse tree + */ + void enterVirtualSpecifierSeq(CPP14Parser.VirtualSpecifierSeqContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#virtualSpecifierSeq}. + * + * @param ctx the parse tree + */ + void exitVirtualSpecifierSeq(CPP14Parser.VirtualSpecifierSeqContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#virtualSpecifier}. + * + * @param ctx the parse tree + */ + void enterVirtualSpecifier(CPP14Parser.VirtualSpecifierContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#virtualSpecifier}. + * + * @param ctx the parse tree + */ + void exitVirtualSpecifier(CPP14Parser.VirtualSpecifierContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#pureSpecifier}. + * + * @param ctx the parse tree + */ + void enterPureSpecifier(CPP14Parser.PureSpecifierContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#pureSpecifier}. + * + * @param ctx the parse tree + */ + void exitPureSpecifier(CPP14Parser.PureSpecifierContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#baseClause}. + * + * @param ctx the parse tree + */ + void enterBaseClause(CPP14Parser.BaseClauseContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#baseClause}. + * + * @param ctx the parse tree + */ + void exitBaseClause(CPP14Parser.BaseClauseContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#baseSpecifierList}. + * + * @param ctx the parse tree + */ + void enterBaseSpecifierList(CPP14Parser.BaseSpecifierListContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#baseSpecifierList}. + * + * @param ctx the parse tree + */ + void exitBaseSpecifierList(CPP14Parser.BaseSpecifierListContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#baseSpecifier}. + * + * @param ctx the parse tree + */ + void enterBaseSpecifier(CPP14Parser.BaseSpecifierContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#baseSpecifier}. + * + * @param ctx the parse tree + */ + void exitBaseSpecifier(CPP14Parser.BaseSpecifierContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#classOrDeclType}. + * + * @param ctx the parse tree + */ + void enterClassOrDeclType(CPP14Parser.ClassOrDeclTypeContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#classOrDeclType}. + * + * @param ctx the parse tree + */ + void exitClassOrDeclType(CPP14Parser.ClassOrDeclTypeContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#baseTypeSpecifier}. + * + * @param ctx the parse tree + */ + void enterBaseTypeSpecifier(CPP14Parser.BaseTypeSpecifierContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#baseTypeSpecifier}. + * + * @param ctx the parse tree + */ + void exitBaseTypeSpecifier(CPP14Parser.BaseTypeSpecifierContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#accessSpecifier}. + * + * @param ctx the parse tree + */ + void enterAccessSpecifier(CPP14Parser.AccessSpecifierContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#accessSpecifier}. + * + * @param ctx the parse tree + */ + void exitAccessSpecifier(CPP14Parser.AccessSpecifierContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#conversionFunctionId}. + * + * @param ctx the parse tree + */ + void enterConversionFunctionId(CPP14Parser.ConversionFunctionIdContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#conversionFunctionId}. + * + * @param ctx the parse tree + */ + void exitConversionFunctionId(CPP14Parser.ConversionFunctionIdContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#conversionTypeId}. + * + * @param ctx the parse tree + */ + void enterConversionTypeId(CPP14Parser.ConversionTypeIdContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#conversionTypeId}. + * + * @param ctx the parse tree + */ + void exitConversionTypeId(CPP14Parser.ConversionTypeIdContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#conversionDeclarator}. + * + * @param ctx the parse tree + */ + void enterConversionDeclarator(CPP14Parser.ConversionDeclaratorContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#conversionDeclarator}. + * + * @param ctx the parse tree + */ + void exitConversionDeclarator(CPP14Parser.ConversionDeclaratorContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#constructorInitializer}. + * + * @param ctx the parse tree + */ + void enterConstructorInitializer(CPP14Parser.ConstructorInitializerContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#constructorInitializer}. + * + * @param ctx the parse tree + */ + void exitConstructorInitializer(CPP14Parser.ConstructorInitializerContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#memInitializerList}. + * + * @param ctx the parse tree + */ + void enterMemInitializerList(CPP14Parser.MemInitializerListContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#memInitializerList}. + * + * @param ctx the parse tree + */ + void exitMemInitializerList(CPP14Parser.MemInitializerListContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#memInitializer}. + * + * @param ctx the parse tree + */ + void enterMemInitializer(CPP14Parser.MemInitializerContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#memInitializer}. + * + * @param ctx the parse tree + */ + void exitMemInitializer(CPP14Parser.MemInitializerContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#meminitializerid}. + * + * @param ctx the parse tree + */ + void enterMeminitializerid(CPP14Parser.MeminitializeridContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#meminitializerid}. + * + * @param ctx the parse tree + */ + void exitMeminitializerid(CPP14Parser.MeminitializeridContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#operatorFunctionId}. + * + * @param ctx the parse tree + */ + void enterOperatorFunctionId(CPP14Parser.OperatorFunctionIdContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#operatorFunctionId}. + * + * @param ctx the parse tree + */ + void exitOperatorFunctionId(CPP14Parser.OperatorFunctionIdContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#literalOperatorId}. + * + * @param ctx the parse tree + */ + void enterLiteralOperatorId(CPP14Parser.LiteralOperatorIdContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#literalOperatorId}. + * + * @param ctx the parse tree + */ + void exitLiteralOperatorId(CPP14Parser.LiteralOperatorIdContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#templateDeclaration}. + * + * @param ctx the parse tree + */ + void enterTemplateDeclaration(CPP14Parser.TemplateDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#templateDeclaration}. + * + * @param ctx the parse tree + */ + void exitTemplateDeclaration(CPP14Parser.TemplateDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#templateparameterList}. + * + * @param ctx the parse tree + */ + void enterTemplateparameterList(CPP14Parser.TemplateparameterListContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#templateparameterList}. + * + * @param ctx the parse tree + */ + void exitTemplateparameterList(CPP14Parser.TemplateparameterListContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#templateParameter}. + * + * @param ctx the parse tree + */ + void enterTemplateParameter(CPP14Parser.TemplateParameterContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#templateParameter}. + * + * @param ctx the parse tree + */ + void exitTemplateParameter(CPP14Parser.TemplateParameterContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#typeParameter}. + * + * @param ctx the parse tree + */ + void enterTypeParameter(CPP14Parser.TypeParameterContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#typeParameter}. + * + * @param ctx the parse tree + */ + void exitTypeParameter(CPP14Parser.TypeParameterContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#simpleTemplateId}. + * + * @param ctx the parse tree + */ + void enterSimpleTemplateId(CPP14Parser.SimpleTemplateIdContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#simpleTemplateId}. + * + * @param ctx the parse tree + */ + void exitSimpleTemplateId(CPP14Parser.SimpleTemplateIdContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#templateId}. + * + * @param ctx the parse tree + */ + void enterTemplateId(CPP14Parser.TemplateIdContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#templateId}. + * + * @param ctx the parse tree + */ + void exitTemplateId(CPP14Parser.TemplateIdContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#templateName}. + * + * @param ctx the parse tree + */ + void enterTemplateName(CPP14Parser.TemplateNameContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#templateName}. + * + * @param ctx the parse tree + */ + void exitTemplateName(CPP14Parser.TemplateNameContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#templateArgumentList}. + * + * @param ctx the parse tree + */ + void enterTemplateArgumentList(CPP14Parser.TemplateArgumentListContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#templateArgumentList}. + * + * @param ctx the parse tree + */ + void exitTemplateArgumentList(CPP14Parser.TemplateArgumentListContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#templateArgument}. + * + * @param ctx the parse tree + */ + void enterTemplateArgument(CPP14Parser.TemplateArgumentContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#templateArgument}. + * + * @param ctx the parse tree + */ + void exitTemplateArgument(CPP14Parser.TemplateArgumentContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#typeNameSpecifier}. + * + * @param ctx the parse tree + */ + void enterTypeNameSpecifier(CPP14Parser.TypeNameSpecifierContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#typeNameSpecifier}. + * + * @param ctx the parse tree + */ + void exitTypeNameSpecifier(CPP14Parser.TypeNameSpecifierContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#explicitInstantiation}. + * + * @param ctx the parse tree + */ + void enterExplicitInstantiation(CPP14Parser.ExplicitInstantiationContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#explicitInstantiation}. + * + * @param ctx the parse tree + */ + void exitExplicitInstantiation(CPP14Parser.ExplicitInstantiationContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#explicitSpecialization}. + * + * @param ctx the parse tree + */ + void enterExplicitSpecialization(CPP14Parser.ExplicitSpecializationContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#explicitSpecialization}. + * + * @param ctx the parse tree + */ + void exitExplicitSpecialization(CPP14Parser.ExplicitSpecializationContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#tryBlock}. + * + * @param ctx the parse tree + */ + void enterTryBlock(CPP14Parser.TryBlockContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#tryBlock}. + * + * @param ctx the parse tree + */ + void exitTryBlock(CPP14Parser.TryBlockContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#functionTryBlock}. + * + * @param ctx the parse tree + */ + void enterFunctionTryBlock(CPP14Parser.FunctionTryBlockContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#functionTryBlock}. + * + * @param ctx the parse tree + */ + void exitFunctionTryBlock(CPP14Parser.FunctionTryBlockContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#handlerSeq}. + * + * @param ctx the parse tree + */ + void enterHandlerSeq(CPP14Parser.HandlerSeqContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#handlerSeq}. + * + * @param ctx the parse tree + */ + void exitHandlerSeq(CPP14Parser.HandlerSeqContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#handler}. + * + * @param ctx the parse tree + */ + void enterHandler(CPP14Parser.HandlerContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#handler}. + * + * @param ctx the parse tree + */ + void exitHandler(CPP14Parser.HandlerContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#exceptionDeclaration}. + * + * @param ctx the parse tree + */ + void enterExceptionDeclaration(CPP14Parser.ExceptionDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#exceptionDeclaration}. + * + * @param ctx the parse tree + */ + void exitExceptionDeclaration(CPP14Parser.ExceptionDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#throwExpression}. + * + * @param ctx the parse tree + */ + void enterThrowExpression(CPP14Parser.ThrowExpressionContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#throwExpression}. + * + * @param ctx the parse tree + */ + void exitThrowExpression(CPP14Parser.ThrowExpressionContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#exceptionSpecification}. + * + * @param ctx the parse tree + */ + void enterExceptionSpecification(CPP14Parser.ExceptionSpecificationContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#exceptionSpecification}. + * + * @param ctx the parse tree + */ + void exitExceptionSpecification(CPP14Parser.ExceptionSpecificationContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#dynamicExceptionSpecification}. + * + * @param ctx the parse tree + */ + void enterDynamicExceptionSpecification(CPP14Parser.DynamicExceptionSpecificationContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#dynamicExceptionSpecification}. + * + * @param ctx the parse tree + */ + void exitDynamicExceptionSpecification(CPP14Parser.DynamicExceptionSpecificationContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#typeIdList}. + * + * @param ctx the parse tree + */ + void enterTypeIdList(CPP14Parser.TypeIdListContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#typeIdList}. + * + * @param ctx the parse tree + */ + void exitTypeIdList(CPP14Parser.TypeIdListContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#noeExceptSpecification}. + * + * @param ctx the parse tree + */ + void enterNoeExceptSpecification(CPP14Parser.NoeExceptSpecificationContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#noeExceptSpecification}. + * + * @param ctx the parse tree + */ + void exitNoeExceptSpecification(CPP14Parser.NoeExceptSpecificationContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#theOperator}. + * + * @param ctx the parse tree + */ + void enterTheOperator(CPP14Parser.TheOperatorContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#theOperator}. + * + * @param ctx the parse tree + */ + void exitTheOperator(CPP14Parser.TheOperatorContext ctx); + /** + * Enter a parse tree produced by {@link CPP14Parser#literal}. + * + * @param ctx the parse tree + */ + void enterLiteral(CPP14Parser.LiteralContext ctx); + /** + * Exit a parse tree produced by {@link CPP14Parser#literal}. + * + * @param ctx the parse tree + */ + void exitLiteral(CPP14Parser.LiteralContext ctx); +} diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14ParserVisitor.java b/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14ParserVisitor.java new file mode 100644 index 000000000..717ca71d8 --- /dev/null +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/cpp/CPP14ParserVisitor.java @@ -0,0 +1,1351 @@ +// Generated from CPP14Parser.g4 by ANTLR 4.9.3 +package com.itsaky.androidide.lexers.cpp; + +import org.antlr.v4.runtime.tree.ParseTreeVisitor; + +/** + * This interface defines a complete generic visitor for a parse tree produced by {@link + * CPP14Parser}. + * + * @param The return type of the visit operation. Use {@link Void} for operations with no return + * type. + */ +public interface CPP14ParserVisitor extends ParseTreeVisitor { + /** + * Visit a parse tree produced by {@link CPP14Parser#translationUnit}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTranslationUnit(CPP14Parser.TranslationUnitContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#primaryExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitPrimaryExpression(CPP14Parser.PrimaryExpressionContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#idExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitIdExpression(CPP14Parser.IdExpressionContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#unqualifiedId}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnqualifiedId(CPP14Parser.UnqualifiedIdContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#qualifiedId}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitQualifiedId(CPP14Parser.QualifiedIdContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#nestedNameSpecifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitNestedNameSpecifier(CPP14Parser.NestedNameSpecifierContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#lambdaExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitLambdaExpression(CPP14Parser.LambdaExpressionContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#lambdaIntroducer}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitLambdaIntroducer(CPP14Parser.LambdaIntroducerContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#lambdaCapture}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitLambdaCapture(CPP14Parser.LambdaCaptureContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#captureDefault}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitCaptureDefault(CPP14Parser.CaptureDefaultContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#captureList}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitCaptureList(CPP14Parser.CaptureListContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#capture}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitCapture(CPP14Parser.CaptureContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#simpleCapture}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitSimpleCapture(CPP14Parser.SimpleCaptureContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#initcapture}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitInitcapture(CPP14Parser.InitcaptureContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#lambdaDeclarator}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitLambdaDeclarator(CPP14Parser.LambdaDeclaratorContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#postfixExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitPostfixExpression(CPP14Parser.PostfixExpressionContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#typeIdOfTheTypeId}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeIdOfTheTypeId(CPP14Parser.TypeIdOfTheTypeIdContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#expressionList}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitExpressionList(CPP14Parser.ExpressionListContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#pseudoDestructorName}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitPseudoDestructorName(CPP14Parser.PseudoDestructorNameContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#unaryExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnaryExpression(CPP14Parser.UnaryExpressionContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#unaryOperator}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnaryOperator(CPP14Parser.UnaryOperatorContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#newExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitNewExpression(CPP14Parser.NewExpressionContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#newPlacement}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitNewPlacement(CPP14Parser.NewPlacementContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#newTypeId}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitNewTypeId(CPP14Parser.NewTypeIdContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#newDeclarator}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitNewDeclarator(CPP14Parser.NewDeclaratorContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#noPointerNewDeclarator}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitNoPointerNewDeclarator(CPP14Parser.NoPointerNewDeclaratorContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#newInitializer}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitNewInitializer(CPP14Parser.NewInitializerContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#deleteExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitDeleteExpression(CPP14Parser.DeleteExpressionContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#noExceptExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitNoExceptExpression(CPP14Parser.NoExceptExpressionContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#castExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitCastExpression(CPP14Parser.CastExpressionContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#pointerMemberExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitPointerMemberExpression(CPP14Parser.PointerMemberExpressionContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#multiplicativeExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitMultiplicativeExpression(CPP14Parser.MultiplicativeExpressionContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#additiveExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitAdditiveExpression(CPP14Parser.AdditiveExpressionContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#shiftExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitShiftExpression(CPP14Parser.ShiftExpressionContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#shiftOperator}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitShiftOperator(CPP14Parser.ShiftOperatorContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#relationalExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitRelationalExpression(CPP14Parser.RelationalExpressionContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#equalityExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitEqualityExpression(CPP14Parser.EqualityExpressionContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#andExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitAndExpression(CPP14Parser.AndExpressionContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#exclusiveOrExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitExclusiveOrExpression(CPP14Parser.ExclusiveOrExpressionContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#inclusiveOrExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitInclusiveOrExpression(CPP14Parser.InclusiveOrExpressionContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#logicalAndExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitLogicalAndExpression(CPP14Parser.LogicalAndExpressionContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#logicalOrExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitLogicalOrExpression(CPP14Parser.LogicalOrExpressionContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#conditionalExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitConditionalExpression(CPP14Parser.ConditionalExpressionContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#assignmentExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitAssignmentExpression(CPP14Parser.AssignmentExpressionContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#assignmentOperator}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitAssignmentOperator(CPP14Parser.AssignmentOperatorContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#expression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitExpression(CPP14Parser.ExpressionContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#constantExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitConstantExpression(CPP14Parser.ConstantExpressionContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#statement}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitStatement(CPP14Parser.StatementContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#labeledStatement}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitLabeledStatement(CPP14Parser.LabeledStatementContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#expressionStatement}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitExpressionStatement(CPP14Parser.ExpressionStatementContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#compoundStatement}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitCompoundStatement(CPP14Parser.CompoundStatementContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#statementSeq}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitStatementSeq(CPP14Parser.StatementSeqContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#selectionStatement}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitSelectionStatement(CPP14Parser.SelectionStatementContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#condition}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitCondition(CPP14Parser.ConditionContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#iterationStatement}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitIterationStatement(CPP14Parser.IterationStatementContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#forInitStatement}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitForInitStatement(CPP14Parser.ForInitStatementContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#forRangeDeclaration}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitForRangeDeclaration(CPP14Parser.ForRangeDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#forRangeInitializer}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitForRangeInitializer(CPP14Parser.ForRangeInitializerContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#jumpStatement}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitJumpStatement(CPP14Parser.JumpStatementContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#declarationStatement}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitDeclarationStatement(CPP14Parser.DeclarationStatementContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#declarationseq}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitDeclarationseq(CPP14Parser.DeclarationseqContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#declaration}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitDeclaration(CPP14Parser.DeclarationContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#blockDeclaration}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitBlockDeclaration(CPP14Parser.BlockDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#aliasDeclaration}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitAliasDeclaration(CPP14Parser.AliasDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#simpleDeclaration}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitSimpleDeclaration(CPP14Parser.SimpleDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#staticAssertDeclaration}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitStaticAssertDeclaration(CPP14Parser.StaticAssertDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#emptyDeclaration}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitEmptyDeclaration(CPP14Parser.EmptyDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#attributeDeclaration}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitAttributeDeclaration(CPP14Parser.AttributeDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#declSpecifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitDeclSpecifier(CPP14Parser.DeclSpecifierContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#declSpecifierSeq}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitDeclSpecifierSeq(CPP14Parser.DeclSpecifierSeqContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#storageClassSpecifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitStorageClassSpecifier(CPP14Parser.StorageClassSpecifierContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#functionSpecifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitFunctionSpecifier(CPP14Parser.FunctionSpecifierContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#typedefName}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypedefName(CPP14Parser.TypedefNameContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#typeSpecifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeSpecifier(CPP14Parser.TypeSpecifierContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#trailingTypeSpecifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTrailingTypeSpecifier(CPP14Parser.TrailingTypeSpecifierContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#typeSpecifierSeq}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeSpecifierSeq(CPP14Parser.TypeSpecifierSeqContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#trailingTypeSpecifierSeq}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTrailingTypeSpecifierSeq(CPP14Parser.TrailingTypeSpecifierSeqContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#simpleTypeLengthModifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitSimpleTypeLengthModifier(CPP14Parser.SimpleTypeLengthModifierContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#simpleTypeSignednessModifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitSimpleTypeSignednessModifier(CPP14Parser.SimpleTypeSignednessModifierContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#simpleTypeSpecifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitSimpleTypeSpecifier(CPP14Parser.SimpleTypeSpecifierContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#theTypeName}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTheTypeName(CPP14Parser.TheTypeNameContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#decltypeSpecifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitDecltypeSpecifier(CPP14Parser.DecltypeSpecifierContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#elaboratedTypeSpecifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitElaboratedTypeSpecifier(CPP14Parser.ElaboratedTypeSpecifierContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#enumName}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumName(CPP14Parser.EnumNameContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#enumSpecifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumSpecifier(CPP14Parser.EnumSpecifierContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#enumHead}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumHead(CPP14Parser.EnumHeadContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#opaqueEnumDeclaration}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitOpaqueEnumDeclaration(CPP14Parser.OpaqueEnumDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#enumkey}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumkey(CPP14Parser.EnumkeyContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#enumbase}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumbase(CPP14Parser.EnumbaseContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#enumeratorList}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumeratorList(CPP14Parser.EnumeratorListContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#enumeratorDefinition}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumeratorDefinition(CPP14Parser.EnumeratorDefinitionContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#enumerator}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumerator(CPP14Parser.EnumeratorContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#namespaceName}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitNamespaceName(CPP14Parser.NamespaceNameContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#originalNamespaceName}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitOriginalNamespaceName(CPP14Parser.OriginalNamespaceNameContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#namespaceDefinition}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitNamespaceDefinition(CPP14Parser.NamespaceDefinitionContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#namespaceAlias}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitNamespaceAlias(CPP14Parser.NamespaceAliasContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#namespaceAliasDefinition}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitNamespaceAliasDefinition(CPP14Parser.NamespaceAliasDefinitionContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#qualifiednamespacespecifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitQualifiednamespacespecifier(CPP14Parser.QualifiednamespacespecifierContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#usingDeclaration}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitUsingDeclaration(CPP14Parser.UsingDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#usingDirective}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitUsingDirective(CPP14Parser.UsingDirectiveContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#asmDefinition}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitAsmDefinition(CPP14Parser.AsmDefinitionContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#linkageSpecification}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitLinkageSpecification(CPP14Parser.LinkageSpecificationContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#attributeSpecifierSeq}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitAttributeSpecifierSeq(CPP14Parser.AttributeSpecifierSeqContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#attributeSpecifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitAttributeSpecifier(CPP14Parser.AttributeSpecifierContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#alignmentspecifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitAlignmentspecifier(CPP14Parser.AlignmentspecifierContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#attributeList}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitAttributeList(CPP14Parser.AttributeListContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#attribute}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitAttribute(CPP14Parser.AttributeContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#attributeNamespace}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitAttributeNamespace(CPP14Parser.AttributeNamespaceContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#attributeArgumentClause}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitAttributeArgumentClause(CPP14Parser.AttributeArgumentClauseContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#balancedTokenSeq}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitBalancedTokenSeq(CPP14Parser.BalancedTokenSeqContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#balancedtoken}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitBalancedtoken(CPP14Parser.BalancedtokenContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#initDeclaratorList}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitInitDeclaratorList(CPP14Parser.InitDeclaratorListContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#initDeclarator}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitInitDeclarator(CPP14Parser.InitDeclaratorContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#declarator}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitDeclarator(CPP14Parser.DeclaratorContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#pointerDeclarator}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitPointerDeclarator(CPP14Parser.PointerDeclaratorContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#noPointerDeclarator}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitNoPointerDeclarator(CPP14Parser.NoPointerDeclaratorContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#parametersAndQualifiers}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitParametersAndQualifiers(CPP14Parser.ParametersAndQualifiersContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#trailingReturnType}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTrailingReturnType(CPP14Parser.TrailingReturnTypeContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#pointerOperator}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitPointerOperator(CPP14Parser.PointerOperatorContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#cvqualifierseq}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitCvqualifierseq(CPP14Parser.CvqualifierseqContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#cvQualifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitCvQualifier(CPP14Parser.CvQualifierContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#refqualifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitRefqualifier(CPP14Parser.RefqualifierContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#declaratorid}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitDeclaratorid(CPP14Parser.DeclaratoridContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#theTypeId}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTheTypeId(CPP14Parser.TheTypeIdContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#abstractDeclarator}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitAbstractDeclarator(CPP14Parser.AbstractDeclaratorContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#pointerAbstractDeclarator}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitPointerAbstractDeclarator(CPP14Parser.PointerAbstractDeclaratorContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#noPointerAbstractDeclarator}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitNoPointerAbstractDeclarator(CPP14Parser.NoPointerAbstractDeclaratorContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#abstractPackDeclarator}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitAbstractPackDeclarator(CPP14Parser.AbstractPackDeclaratorContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#noPointerAbstractPackDeclarator}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitNoPointerAbstractPackDeclarator(CPP14Parser.NoPointerAbstractPackDeclaratorContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#parameterDeclarationClause}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitParameterDeclarationClause(CPP14Parser.ParameterDeclarationClauseContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#parameterDeclarationList}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitParameterDeclarationList(CPP14Parser.ParameterDeclarationListContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#parameterDeclaration}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitParameterDeclaration(CPP14Parser.ParameterDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#functionDefinition}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitFunctionDefinition(CPP14Parser.FunctionDefinitionContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#functionBody}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitFunctionBody(CPP14Parser.FunctionBodyContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#initializer}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitInitializer(CPP14Parser.InitializerContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#braceOrEqualInitializer}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitBraceOrEqualInitializer(CPP14Parser.BraceOrEqualInitializerContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#initializerClause}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitInitializerClause(CPP14Parser.InitializerClauseContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#initializerList}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitInitializerList(CPP14Parser.InitializerListContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#bracedInitList}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitBracedInitList(CPP14Parser.BracedInitListContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#className}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassName(CPP14Parser.ClassNameContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#classSpecifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassSpecifier(CPP14Parser.ClassSpecifierContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#classHead}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassHead(CPP14Parser.ClassHeadContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#classHeadName}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassHeadName(CPP14Parser.ClassHeadNameContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#classVirtSpecifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassVirtSpecifier(CPP14Parser.ClassVirtSpecifierContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#classKey}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassKey(CPP14Parser.ClassKeyContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#memberSpecification}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitMemberSpecification(CPP14Parser.MemberSpecificationContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#memberdeclaration}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitMemberdeclaration(CPP14Parser.MemberdeclarationContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#memberDeclaratorList}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitMemberDeclaratorList(CPP14Parser.MemberDeclaratorListContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#memberDeclarator}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitMemberDeclarator(CPP14Parser.MemberDeclaratorContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#virtualSpecifierSeq}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitVirtualSpecifierSeq(CPP14Parser.VirtualSpecifierSeqContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#virtualSpecifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitVirtualSpecifier(CPP14Parser.VirtualSpecifierContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#pureSpecifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitPureSpecifier(CPP14Parser.PureSpecifierContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#baseClause}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitBaseClause(CPP14Parser.BaseClauseContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#baseSpecifierList}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitBaseSpecifierList(CPP14Parser.BaseSpecifierListContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#baseSpecifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitBaseSpecifier(CPP14Parser.BaseSpecifierContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#classOrDeclType}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassOrDeclType(CPP14Parser.ClassOrDeclTypeContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#baseTypeSpecifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitBaseTypeSpecifier(CPP14Parser.BaseTypeSpecifierContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#accessSpecifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitAccessSpecifier(CPP14Parser.AccessSpecifierContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#conversionFunctionId}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitConversionFunctionId(CPP14Parser.ConversionFunctionIdContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#conversionTypeId}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitConversionTypeId(CPP14Parser.ConversionTypeIdContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#conversionDeclarator}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitConversionDeclarator(CPP14Parser.ConversionDeclaratorContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#constructorInitializer}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitConstructorInitializer(CPP14Parser.ConstructorInitializerContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#memInitializerList}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitMemInitializerList(CPP14Parser.MemInitializerListContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#memInitializer}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitMemInitializer(CPP14Parser.MemInitializerContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#meminitializerid}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitMeminitializerid(CPP14Parser.MeminitializeridContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#operatorFunctionId}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitOperatorFunctionId(CPP14Parser.OperatorFunctionIdContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#literalOperatorId}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitLiteralOperatorId(CPP14Parser.LiteralOperatorIdContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#templateDeclaration}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTemplateDeclaration(CPP14Parser.TemplateDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#templateparameterList}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTemplateparameterList(CPP14Parser.TemplateparameterListContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#templateParameter}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTemplateParameter(CPP14Parser.TemplateParameterContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#typeParameter}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeParameter(CPP14Parser.TypeParameterContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#simpleTemplateId}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitSimpleTemplateId(CPP14Parser.SimpleTemplateIdContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#templateId}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTemplateId(CPP14Parser.TemplateIdContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#templateName}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTemplateName(CPP14Parser.TemplateNameContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#templateArgumentList}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTemplateArgumentList(CPP14Parser.TemplateArgumentListContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#templateArgument}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTemplateArgument(CPP14Parser.TemplateArgumentContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#typeNameSpecifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeNameSpecifier(CPP14Parser.TypeNameSpecifierContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#explicitInstantiation}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitExplicitInstantiation(CPP14Parser.ExplicitInstantiationContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#explicitSpecialization}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitExplicitSpecialization(CPP14Parser.ExplicitSpecializationContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#tryBlock}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTryBlock(CPP14Parser.TryBlockContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#functionTryBlock}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitFunctionTryBlock(CPP14Parser.FunctionTryBlockContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#handlerSeq}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitHandlerSeq(CPP14Parser.HandlerSeqContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#handler}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitHandler(CPP14Parser.HandlerContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#exceptionDeclaration}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitExceptionDeclaration(CPP14Parser.ExceptionDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#throwExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitThrowExpression(CPP14Parser.ThrowExpressionContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#exceptionSpecification}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitExceptionSpecification(CPP14Parser.ExceptionSpecificationContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#dynamicExceptionSpecification}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitDynamicExceptionSpecification(CPP14Parser.DynamicExceptionSpecificationContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#typeIdList}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeIdList(CPP14Parser.TypeIdListContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#noeExceptSpecification}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitNoeExceptSpecification(CPP14Parser.NoeExceptSpecificationContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#theOperator}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTheOperator(CPP14Parser.TheOperatorContext ctx); + /** + * Visit a parse tree produced by {@link CPP14Parser#literal}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitLiteral(CPP14Parser.LiteralContext ctx); +} diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/gen.sh b/lexers/src/main/java/com/itsaky/androidide/lexers/gen.sh new file mode 100755 index 000000000..d1d0e4db7 --- /dev/null +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/gen.sh @@ -0,0 +1,12 @@ +#!/bin/bash + +set -eu + +# Usage: +# find * -type d -exec ./gen.sh {} \; + +cd $1 +dir_name=$(basename $(pwd)) +echo "Generating lexer and parser for $dir_name..." +antlr4 -o . -lib . -listener -visitor -package com.itsaky.androidide.lexers.$dir_name *.g4 +cd - >/dev/null 2>&1 diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/groovy/GroovyLexer.interp b/lexers/src/main/java/com/itsaky/androidide/lexers/groovy/GroovyLexer.interp new file mode 100644 index 000000000..91f07c5fb --- /dev/null +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/groovy/GroovyLexer.interp @@ -0,0 +1,360 @@ +token literal names: +null +'abstract' +'assert' +'boolean' +'break' +'byte' +'case' +'catch' +'char' +'class' +'const' +'continue' +'default' +'do' +'double' +'else' +'enum' +'extends' +'final' +'finally' +'float' +'for' +'if' +'goto' +'implements' +'import' +'instanceof' +'int' +'interface' +'long' +'native' +'new' +'package' +'private' +'protected' +'public' +'return' +'short' +'static' +'strictfp' +'super' +'switch' +'synchronized' +'this' +'throw' +'throws' +'transient' +'try' +'void' +'volatile' +'while' +null +null +null +null +null +null +null +null +null +null +'null' +'(' +')' +'{' +'}' +'[' +']' +';' +',' +'.' +'=' +'>' +'<' +'!' +'~' +'?' +':' +'==' +'<=' +'>=' +'!=' +'&&' +'||' +'++' +'--' +'+' +'-' +'*' +'/' +'&' +'|' +'^' +'%' +'+=' +'-=' +'*=' +'/=' +'&=' +'|=' +'^=' +'%=' +'<<=' +'>>=' +'>>>=' +'->' +'::' +'@' +'...' +null +null +null +null + +token symbolic names: +null +ABSTRACT +ASSERT +BOOLEAN +BREAK +BYTE +CASE +CATCH +CHAR +CLASS +CONST +CONTINUE +DEFAULT +DO +DOUBLE +ELSE +ENUM +EXTENDS +FINAL +FINALLY +FLOAT +FOR +IF +GOTO +IMPLEMENTS +IMPORT +INSTANCEOF +INT +INTERFACE +LONG +NATIVE +NEW +PACKAGE +PRIVATE +PROTECTED +PUBLIC +RETURN +SHORT +STATIC +STRICTFP +SUPER +SWITCH +SYNCHRONIZED +THIS +THROW +THROWS +TRANSIENT +TRY +VOID +VOLATILE +WHILE +DECIMAL_LITERAL +HEX_LITERAL +OCT_LITERAL +BINARY_LITERAL +FLOAT_LITERAL +HEX_FLOAT_LITERAL +BOOL_LITERAL +CHAR_LITERAL +SINGLE_QUOTE_STRING +STRING_LITERAL +NULL_LITERAL +LPAREN +RPAREN +LBRACE +RBRACE +LBRACK +RBRACK +SEMI +COMMA +DOT +ASSIGN +GT +LT +BANG +TILDE +QUESTION +COLON +EQUAL +LE +GE +NOTEQUAL +AND +OR +INC +DEC +ADD +SUB +MUL +DIV +BITAND +BITOR +CARET +MOD +ADD_ASSIGN +SUB_ASSIGN +MUL_ASSIGN +DIV_ASSIGN +AND_ASSIGN +OR_ASSIGN +XOR_ASSIGN +MOD_ASSIGN +LSHIFT_ASSIGN +RSHIFT_ASSIGN +URSHIFT_ASSIGN +ARROW +COLONCOLON +AT +ELLIPSIS +WS +COMMENT +LINE_COMMENT +IDENTIFIER + +rule names: +ABSTRACT +ASSERT +BOOLEAN +BREAK +BYTE +CASE +CATCH +CHAR +CLASS +CONST +CONTINUE +DEFAULT +DO +DOUBLE +ELSE +ENUM +EXTENDS +FINAL +FINALLY +FLOAT +FOR +IF +GOTO +IMPLEMENTS +IMPORT +INSTANCEOF +INT +INTERFACE +LONG +NATIVE +NEW +PACKAGE +PRIVATE +PROTECTED +PUBLIC +RETURN +SHORT +STATIC +STRICTFP +SUPER +SWITCH +SYNCHRONIZED +THIS +THROW +THROWS +TRANSIENT +TRY +VOID +VOLATILE +WHILE +DECIMAL_LITERAL +HEX_LITERAL +OCT_LITERAL +BINARY_LITERAL +FLOAT_LITERAL +HEX_FLOAT_LITERAL +BOOL_LITERAL +CHAR_LITERAL +SINGLE_QUOTE_STRING +STRING_LITERAL +NULL_LITERAL +LPAREN +RPAREN +LBRACE +RBRACE +LBRACK +RBRACK +SEMI +COMMA +DOT +ASSIGN +GT +LT +BANG +TILDE +QUESTION +COLON +EQUAL +LE +GE +NOTEQUAL +AND +OR +INC +DEC +ADD +SUB +MUL +DIV +BITAND +BITOR +CARET +MOD +ADD_ASSIGN +SUB_ASSIGN +MUL_ASSIGN +DIV_ASSIGN +AND_ASSIGN +OR_ASSIGN +XOR_ASSIGN +MOD_ASSIGN +LSHIFT_ASSIGN +RSHIFT_ASSIGN +URSHIFT_ASSIGN +ARROW +COLONCOLON +AT +ELLIPSIS +WS +COMMENT +LINE_COMMENT +IDENTIFIER +ExponentPart +EscapeSequence +HexDigits +HexDigit +Digits +LetterOrDigit +Letter + +channel names: +DEFAULT_TOKEN_CHANNEL +HIDDEN + +mode names: +DEFAULT_MODE + +atn: +[3, 24715, 42794, 33075, 47597, 16764, 15335, 30598, 22884, 2, 114, 959, 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, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 6, 3, 6, 3, 6, 3, 6, 3, 6, 3, 7, 3, 7, 3, 7, 3, 7, 3, 7, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 3, 8, 3, 9, 3, 9, 3, 9, 3, 9, 3, 9, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 10, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 11, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 14, 3, 14, 3, 14, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 15, 3, 16, 3, 16, 3, 16, 3, 16, 3, 16, 3, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 18, 3, 19, 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, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 21, 3, 22, 3, 22, 3, 22, 3, 22, 3, 23, 3, 23, 3, 23, 3, 24, 3, 24, 3, 24, 3, 24, 3, 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, 27, 3, 27, 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, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 30, 3, 30, 3, 30, 3, 30, 3, 30, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 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, 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, 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, 39, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 40, 3, 41, 3, 41, 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, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 45, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 46, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 47, 3, 48, 3, 48, 3, 48, 3, 48, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 50, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 52, 3, 52, 3, 52, 5, 52, 584, 10, 52, 3, 52, 6, 52, 587, 10, 52, 13, 52, 14, 52, 588, 3, 52, 5, 52, 592, 10, 52, 5, 52, 594, 10, 52, 3, 52, 5, 52, 597, 10, 52, 3, 53, 3, 53, 3, 53, 3, 53, 7, 53, 603, 10, 53, 12, 53, 14, 53, 606, 11, 53, 3, 53, 5, 53, 609, 10, 53, 3, 53, 5, 53, 612, 10, 53, 3, 54, 3, 54, 7, 54, 616, 10, 54, 12, 54, 14, 54, 619, 11, 54, 3, 54, 3, 54, 7, 54, 623, 10, 54, 12, 54, 14, 54, 626, 11, 54, 3, 54, 5, 54, 629, 10, 54, 3, 54, 5, 54, 632, 10, 54, 3, 55, 3, 55, 3, 55, 3, 55, 7, 55, 638, 10, 55, 12, 55, 14, 55, 641, 11, 55, 3, 55, 5, 55, 644, 10, 55, 3, 55, 5, 55, 647, 10, 55, 3, 56, 3, 56, 3, 56, 5, 56, 652, 10, 56, 3, 56, 3, 56, 5, 56, 656, 10, 56, 3, 56, 5, 56, 659, 10, 56, 3, 56, 5, 56, 662, 10, 56, 3, 56, 3, 56, 3, 56, 5, 56, 667, 10, 56, 3, 56, 5, 56, 670, 10, 56, 5, 56, 672, 10, 56, 3, 57, 3, 57, 3, 57, 3, 57, 5, 57, 678, 10, 57, 3, 57, 5, 57, 681, 10, 57, 3, 57, 3, 57, 5, 57, 685, 10, 57, 3, 57, 3, 57, 5, 57, 689, 10, 57, 3, 57, 3, 57, 5, 57, 693, 10, 57, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 5, 58, 704, 10, 58, 3, 59, 3, 59, 3, 59, 5, 59, 709, 10, 59, 3, 59, 3, 59, 3, 60, 3, 60, 3, 60, 7, 60, 716, 10, 60, 12, 60, 14, 60, 719, 11, 60, 3, 60, 3, 60, 3, 61, 3, 61, 3, 61, 7, 61, 726, 10, 61, 12, 61, 14, 61, 729, 11, 61, 3, 61, 3, 61, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 63, 3, 63, 3, 64, 3, 64, 3, 65, 3, 65, 3, 66, 3, 66, 3, 67, 3, 67, 3, 68, 3, 68, 3, 69, 3, 69, 3, 70, 3, 70, 3, 71, 3, 71, 3, 72, 3, 72, 3, 73, 3, 73, 3, 74, 3, 74, 3, 75, 3, 75, 3, 76, 3, 76, 3, 77, 3, 77, 3, 78, 3, 78, 3, 79, 3, 79, 3, 79, 3, 80, 3, 80, 3, 80, 3, 81, 3, 81, 3, 81, 3, 82, 3, 82, 3, 82, 3, 83, 3, 83, 3, 83, 3, 84, 3, 84, 3, 84, 3, 85, 3, 85, 3, 85, 3, 86, 3, 86, 3, 86, 3, 87, 3, 87, 3, 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, 95, 3, 96, 3, 96, 3, 96, 3, 97, 3, 97, 3, 97, 3, 98, 3, 98, 3, 98, 3, 99, 3, 99, 3, 99, 3, 100, 3, 100, 3, 100, 3, 101, 3, 101, 3, 101, 3, 102, 3, 102, 3, 102, 3, 103, 3, 103, 3, 103, 3, 103, 3, 104, 3, 104, 3, 104, 3, 104, 3, 105, 3, 105, 3, 105, 3, 105, 3, 105, 3, 106, 3, 106, 3, 106, 3, 107, 3, 107, 3, 107, 3, 108, 3, 108, 3, 109, 3, 109, 3, 109, 3, 109, 3, 110, 6, 110, 860, 10, 110, 13, 110, 14, 110, 861, 3, 110, 3, 110, 3, 111, 3, 111, 3, 111, 3, 111, 7, 111, 870, 10, 111, 12, 111, 14, 111, 873, 11, 111, 3, 111, 3, 111, 3, 111, 3, 111, 3, 111, 3, 112, 3, 112, 3, 112, 3, 112, 7, 112, 884, 10, 112, 12, 112, 14, 112, 887, 11, 112, 3, 112, 3, 112, 3, 113, 3, 113, 7, 113, 893, 10, 113, 12, 113, 14, 113, 896, 11, 113, 3, 114, 3, 114, 5, 114, 900, 10, 114, 3, 114, 3, 114, 3, 115, 3, 115, 3, 115, 3, 115, 5, 115, 908, 10, 115, 3, 115, 5, 115, 911, 10, 115, 3, 115, 3, 115, 3, 115, 6, 115, 916, 10, 115, 13, 115, 14, 115, 917, 3, 115, 3, 115, 3, 115, 3, 115, 3, 115, 5, 115, 925, 10, 115, 3, 116, 3, 116, 3, 116, 7, 116, 930, 10, 116, 12, 116, 14, 116, 933, 11, 116, 3, 116, 5, 116, 936, 10, 116, 3, 117, 3, 117, 3, 118, 3, 118, 7, 118, 942, 10, 118, 12, 118, 14, 118, 945, 11, 118, 3, 118, 5, 118, 948, 10, 118, 3, 119, 3, 119, 5, 119, 952, 10, 119, 3, 120, 3, 120, 3, 120, 3, 120, 5, 120, 958, 10, 120, 3, 871, 2, 121, 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, 2, 229, 2, 231, 2, 233, 2, 235, 2, 237, 2, 239, 2, 3, 2, 28, 3, 2, 51, 59, 4, 2, 78, 78, 110, 110, 4, 2, 90, 90, 122, 122, 5, 2, 50, 59, 67, 72, 99, 104, 6, 2, 50, 59, 67, 72, 97, 97, 99, 104, 3, 2, 50, 57, 4, 2, 50, 57, 97, 97, 4, 2, 68, 68, 100, 100, 3, 2, 50, 51, 4, 2, 50, 51, 97, 97, 6, 2, 70, 70, 72, 72, 102, 102, 104, 104, 4, 2, 82, 82, 114, 114, 4, 2, 45, 45, 47, 47, 6, 2, 12, 12, 15, 15, 41, 41, 94, 94, 6, 2, 12, 12, 15, 15, 36, 36, 94, 94, 5, 2, 11, 12, 14, 15, 34, 34, 4, 2, 12, 12, 15, 15, 4, 2, 71, 71, 103, 103, 10, 2, 36, 36, 41, 41, 94, 94, 100, 100, 104, 104, 112, 112, 116, 116, 118, 118, 3, 2, 50, 53, 3, 2, 50, 59, 4, 2, 50, 59, 97, 97, 6, 2, 38, 38, 67, 92, 97, 97, 99, 124, 4, 2, 2, 129, 55298, 56321, 3, 2, 55298, 56321, 3, 2, 56322, 57345, 2, 1002, 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, 3, 241, 3, 2, 2, 2, 5, 250, 3, 2, 2, 2, 7, 257, 3, 2, 2, 2, 9, 265, 3, 2, 2, 2, 11, 271, 3, 2, 2, 2, 13, 276, 3, 2, 2, 2, 15, 281, 3, 2, 2, 2, 17, 287, 3, 2, 2, 2, 19, 292, 3, 2, 2, 2, 21, 298, 3, 2, 2, 2, 23, 304, 3, 2, 2, 2, 25, 313, 3, 2, 2, 2, 27, 321, 3, 2, 2, 2, 29, 324, 3, 2, 2, 2, 31, 331, 3, 2, 2, 2, 33, 336, 3, 2, 2, 2, 35, 341, 3, 2, 2, 2, 37, 349, 3, 2, 2, 2, 39, 355, 3, 2, 2, 2, 41, 363, 3, 2, 2, 2, 43, 369, 3, 2, 2, 2, 45, 373, 3, 2, 2, 2, 47, 376, 3, 2, 2, 2, 49, 381, 3, 2, 2, 2, 51, 392, 3, 2, 2, 2, 53, 399, 3, 2, 2, 2, 55, 410, 3, 2, 2, 2, 57, 414, 3, 2, 2, 2, 59, 424, 3, 2, 2, 2, 61, 429, 3, 2, 2, 2, 63, 436, 3, 2, 2, 2, 65, 440, 3, 2, 2, 2, 67, 448, 3, 2, 2, 2, 69, 456, 3, 2, 2, 2, 71, 466, 3, 2, 2, 2, 73, 473, 3, 2, 2, 2, 75, 480, 3, 2, 2, 2, 77, 486, 3, 2, 2, 2, 79, 493, 3, 2, 2, 2, 81, 502, 3, 2, 2, 2, 83, 508, 3, 2, 2, 2, 85, 515, 3, 2, 2, 2, 87, 528, 3, 2, 2, 2, 89, 533, 3, 2, 2, 2, 91, 539, 3, 2, 2, 2, 93, 546, 3, 2, 2, 2, 95, 556, 3, 2, 2, 2, 97, 560, 3, 2, 2, 2, 99, 565, 3, 2, 2, 2, 101, 574, 3, 2, 2, 2, 103, 593, 3, 2, 2, 2, 105, 598, 3, 2, 2, 2, 107, 613, 3, 2, 2, 2, 109, 633, 3, 2, 2, 2, 111, 671, 3, 2, 2, 2, 113, 673, 3, 2, 2, 2, 115, 703, 3, 2, 2, 2, 117, 705, 3, 2, 2, 2, 119, 712, 3, 2, 2, 2, 121, 722, 3, 2, 2, 2, 123, 732, 3, 2, 2, 2, 125, 737, 3, 2, 2, 2, 127, 739, 3, 2, 2, 2, 129, 741, 3, 2, 2, 2, 131, 743, 3, 2, 2, 2, 133, 745, 3, 2, 2, 2, 135, 747, 3, 2, 2, 2, 137, 749, 3, 2, 2, 2, 139, 751, 3, 2, 2, 2, 141, 753, 3, 2, 2, 2, 143, 755, 3, 2, 2, 2, 145, 757, 3, 2, 2, 2, 147, 759, 3, 2, 2, 2, 149, 761, 3, 2, 2, 2, 151, 763, 3, 2, 2, 2, 153, 765, 3, 2, 2, 2, 155, 767, 3, 2, 2, 2, 157, 769, 3, 2, 2, 2, 159, 772, 3, 2, 2, 2, 161, 775, 3, 2, 2, 2, 163, 778, 3, 2, 2, 2, 165, 781, 3, 2, 2, 2, 167, 784, 3, 2, 2, 2, 169, 787, 3, 2, 2, 2, 171, 790, 3, 2, 2, 2, 173, 793, 3, 2, 2, 2, 175, 795, 3, 2, 2, 2, 177, 797, 3, 2, 2, 2, 179, 799, 3, 2, 2, 2, 181, 801, 3, 2, 2, 2, 183, 803, 3, 2, 2, 2, 185, 805, 3, 2, 2, 2, 187, 807, 3, 2, 2, 2, 189, 809, 3, 2, 2, 2, 191, 812, 3, 2, 2, 2, 193, 815, 3, 2, 2, 2, 195, 818, 3, 2, 2, 2, 197, 821, 3, 2, 2, 2, 199, 824, 3, 2, 2, 2, 201, 827, 3, 2, 2, 2, 203, 830, 3, 2, 2, 2, 205, 833, 3, 2, 2, 2, 207, 837, 3, 2, 2, 2, 209, 841, 3, 2, 2, 2, 211, 846, 3, 2, 2, 2, 213, 849, 3, 2, 2, 2, 215, 852, 3, 2, 2, 2, 217, 854, 3, 2, 2, 2, 219, 859, 3, 2, 2, 2, 221, 865, 3, 2, 2, 2, 223, 879, 3, 2, 2, 2, 225, 890, 3, 2, 2, 2, 227, 897, 3, 2, 2, 2, 229, 924, 3, 2, 2, 2, 231, 926, 3, 2, 2, 2, 233, 937, 3, 2, 2, 2, 235, 939, 3, 2, 2, 2, 237, 951, 3, 2, 2, 2, 239, 957, 3, 2, 2, 2, 241, 242, 7, 99, 2, 2, 242, 243, 7, 100, 2, 2, 243, 244, 7, 117, 2, 2, 244, 245, 7, 118, 2, 2, 245, 246, 7, 116, 2, 2, 246, 247, 7, 99, 2, 2, 247, 248, 7, 101, 2, 2, 248, 249, 7, 118, 2, 2, 249, 4, 3, 2, 2, 2, 250, 251, 7, 99, 2, 2, 251, 252, 7, 117, 2, 2, 252, 253, 7, 117, 2, 2, 253, 254, 7, 103, 2, 2, 254, 255, 7, 116, 2, 2, 255, 256, 7, 118, 2, 2, 256, 6, 3, 2, 2, 2, 257, 258, 7, 100, 2, 2, 258, 259, 7, 113, 2, 2, 259, 260, 7, 113, 2, 2, 260, 261, 7, 110, 2, 2, 261, 262, 7, 103, 2, 2, 262, 263, 7, 99, 2, 2, 263, 264, 7, 112, 2, 2, 264, 8, 3, 2, 2, 2, 265, 266, 7, 100, 2, 2, 266, 267, 7, 116, 2, 2, 267, 268, 7, 103, 2, 2, 268, 269, 7, 99, 2, 2, 269, 270, 7, 109, 2, 2, 270, 10, 3, 2, 2, 2, 271, 272, 7, 100, 2, 2, 272, 273, 7, 123, 2, 2, 273, 274, 7, 118, 2, 2, 274, 275, 7, 103, 2, 2, 275, 12, 3, 2, 2, 2, 276, 277, 7, 101, 2, 2, 277, 278, 7, 99, 2, 2, 278, 279, 7, 117, 2, 2, 279, 280, 7, 103, 2, 2, 280, 14, 3, 2, 2, 2, 281, 282, 7, 101, 2, 2, 282, 283, 7, 99, 2, 2, 283, 284, 7, 118, 2, 2, 284, 285, 7, 101, 2, 2, 285, 286, 7, 106, 2, 2, 286, 16, 3, 2, 2, 2, 287, 288, 7, 101, 2, 2, 288, 289, 7, 106, 2, 2, 289, 290, 7, 99, 2, 2, 290, 291, 7, 116, 2, 2, 291, 18, 3, 2, 2, 2, 292, 293, 7, 101, 2, 2, 293, 294, 7, 110, 2, 2, 294, 295, 7, 99, 2, 2, 295, 296, 7, 117, 2, 2, 296, 297, 7, 117, 2, 2, 297, 20, 3, 2, 2, 2, 298, 299, 7, 101, 2, 2, 299, 300, 7, 113, 2, 2, 300, 301, 7, 112, 2, 2, 301, 302, 7, 117, 2, 2, 302, 303, 7, 118, 2, 2, 303, 22, 3, 2, 2, 2, 304, 305, 7, 101, 2, 2, 305, 306, 7, 113, 2, 2, 306, 307, 7, 112, 2, 2, 307, 308, 7, 118, 2, 2, 308, 309, 7, 107, 2, 2, 309, 310, 7, 112, 2, 2, 310, 311, 7, 119, 2, 2, 311, 312, 7, 103, 2, 2, 312, 24, 3, 2, 2, 2, 313, 314, 7, 102, 2, 2, 314, 315, 7, 103, 2, 2, 315, 316, 7, 104, 2, 2, 316, 317, 7, 99, 2, 2, 317, 318, 7, 119, 2, 2, 318, 319, 7, 110, 2, 2, 319, 320, 7, 118, 2, 2, 320, 26, 3, 2, 2, 2, 321, 322, 7, 102, 2, 2, 322, 323, 7, 113, 2, 2, 323, 28, 3, 2, 2, 2, 324, 325, 7, 102, 2, 2, 325, 326, 7, 113, 2, 2, 326, 327, 7, 119, 2, 2, 327, 328, 7, 100, 2, 2, 328, 329, 7, 110, 2, 2, 329, 330, 7, 103, 2, 2, 330, 30, 3, 2, 2, 2, 331, 332, 7, 103, 2, 2, 332, 333, 7, 110, 2, 2, 333, 334, 7, 117, 2, 2, 334, 335, 7, 103, 2, 2, 335, 32, 3, 2, 2, 2, 336, 337, 7, 103, 2, 2, 337, 338, 7, 112, 2, 2, 338, 339, 7, 119, 2, 2, 339, 340, 7, 111, 2, 2, 340, 34, 3, 2, 2, 2, 341, 342, 7, 103, 2, 2, 342, 343, 7, 122, 2, 2, 343, 344, 7, 118, 2, 2, 344, 345, 7, 103, 2, 2, 345, 346, 7, 112, 2, 2, 346, 347, 7, 102, 2, 2, 347, 348, 7, 117, 2, 2, 348, 36, 3, 2, 2, 2, 349, 350, 7, 104, 2, 2, 350, 351, 7, 107, 2, 2, 351, 352, 7, 112, 2, 2, 352, 353, 7, 99, 2, 2, 353, 354, 7, 110, 2, 2, 354, 38, 3, 2, 2, 2, 355, 356, 7, 104, 2, 2, 356, 357, 7, 107, 2, 2, 357, 358, 7, 112, 2, 2, 358, 359, 7, 99, 2, 2, 359, 360, 7, 110, 2, 2, 360, 361, 7, 110, 2, 2, 361, 362, 7, 123, 2, 2, 362, 40, 3, 2, 2, 2, 363, 364, 7, 104, 2, 2, 364, 365, 7, 110, 2, 2, 365, 366, 7, 113, 2, 2, 366, 367, 7, 99, 2, 2, 367, 368, 7, 118, 2, 2, 368, 42, 3, 2, 2, 2, 369, 370, 7, 104, 2, 2, 370, 371, 7, 113, 2, 2, 371, 372, 7, 116, 2, 2, 372, 44, 3, 2, 2, 2, 373, 374, 7, 107, 2, 2, 374, 375, 7, 104, 2, 2, 375, 46, 3, 2, 2, 2, 376, 377, 7, 105, 2, 2, 377, 378, 7, 113, 2, 2, 378, 379, 7, 118, 2, 2, 379, 380, 7, 113, 2, 2, 380, 48, 3, 2, 2, 2, 381, 382, 7, 107, 2, 2, 382, 383, 7, 111, 2, 2, 383, 384, 7, 114, 2, 2, 384, 385, 7, 110, 2, 2, 385, 386, 7, 103, 2, 2, 386, 387, 7, 111, 2, 2, 387, 388, 7, 103, 2, 2, 388, 389, 7, 112, 2, 2, 389, 390, 7, 118, 2, 2, 390, 391, 7, 117, 2, 2, 391, 50, 3, 2, 2, 2, 392, 393, 7, 107, 2, 2, 393, 394, 7, 111, 2, 2, 394, 395, 7, 114, 2, 2, 395, 396, 7, 113, 2, 2, 396, 397, 7, 116, 2, 2, 397, 398, 7, 118, 2, 2, 398, 52, 3, 2, 2, 2, 399, 400, 7, 107, 2, 2, 400, 401, 7, 112, 2, 2, 401, 402, 7, 117, 2, 2, 402, 403, 7, 118, 2, 2, 403, 404, 7, 99, 2, 2, 404, 405, 7, 112, 2, 2, 405, 406, 7, 101, 2, 2, 406, 407, 7, 103, 2, 2, 407, 408, 7, 113, 2, 2, 408, 409, 7, 104, 2, 2, 409, 54, 3, 2, 2, 2, 410, 411, 7, 107, 2, 2, 411, 412, 7, 112, 2, 2, 412, 413, 7, 118, 2, 2, 413, 56, 3, 2, 2, 2, 414, 415, 7, 107, 2, 2, 415, 416, 7, 112, 2, 2, 416, 417, 7, 118, 2, 2, 417, 418, 7, 103, 2, 2, 418, 419, 7, 116, 2, 2, 419, 420, 7, 104, 2, 2, 420, 421, 7, 99, 2, 2, 421, 422, 7, 101, 2, 2, 422, 423, 7, 103, 2, 2, 423, 58, 3, 2, 2, 2, 424, 425, 7, 110, 2, 2, 425, 426, 7, 113, 2, 2, 426, 427, 7, 112, 2, 2, 427, 428, 7, 105, 2, 2, 428, 60, 3, 2, 2, 2, 429, 430, 7, 112, 2, 2, 430, 431, 7, 99, 2, 2, 431, 432, 7, 118, 2, 2, 432, 433, 7, 107, 2, 2, 433, 434, 7, 120, 2, 2, 434, 435, 7, 103, 2, 2, 435, 62, 3, 2, 2, 2, 436, 437, 7, 112, 2, 2, 437, 438, 7, 103, 2, 2, 438, 439, 7, 121, 2, 2, 439, 64, 3, 2, 2, 2, 440, 441, 7, 114, 2, 2, 441, 442, 7, 99, 2, 2, 442, 443, 7, 101, 2, 2, 443, 444, 7, 109, 2, 2, 444, 445, 7, 99, 2, 2, 445, 446, 7, 105, 2, 2, 446, 447, 7, 103, 2, 2, 447, 66, 3, 2, 2, 2, 448, 449, 7, 114, 2, 2, 449, 450, 7, 116, 2, 2, 450, 451, 7, 107, 2, 2, 451, 452, 7, 120, 2, 2, 452, 453, 7, 99, 2, 2, 453, 454, 7, 118, 2, 2, 454, 455, 7, 103, 2, 2, 455, 68, 3, 2, 2, 2, 456, 457, 7, 114, 2, 2, 457, 458, 7, 116, 2, 2, 458, 459, 7, 113, 2, 2, 459, 460, 7, 118, 2, 2, 460, 461, 7, 103, 2, 2, 461, 462, 7, 101, 2, 2, 462, 463, 7, 118, 2, 2, 463, 464, 7, 103, 2, 2, 464, 465, 7, 102, 2, 2, 465, 70, 3, 2, 2, 2, 466, 467, 7, 114, 2, 2, 467, 468, 7, 119, 2, 2, 468, 469, 7, 100, 2, 2, 469, 470, 7, 110, 2, 2, 470, 471, 7, 107, 2, 2, 471, 472, 7, 101, 2, 2, 472, 72, 3, 2, 2, 2, 473, 474, 7, 116, 2, 2, 474, 475, 7, 103, 2, 2, 475, 476, 7, 118, 2, 2, 476, 477, 7, 119, 2, 2, 477, 478, 7, 116, 2, 2, 478, 479, 7, 112, 2, 2, 479, 74, 3, 2, 2, 2, 480, 481, 7, 117, 2, 2, 481, 482, 7, 106, 2, 2, 482, 483, 7, 113, 2, 2, 483, 484, 7, 116, 2, 2, 484, 485, 7, 118, 2, 2, 485, 76, 3, 2, 2, 2, 486, 487, 7, 117, 2, 2, 487, 488, 7, 118, 2, 2, 488, 489, 7, 99, 2, 2, 489, 490, 7, 118, 2, 2, 490, 491, 7, 107, 2, 2, 491, 492, 7, 101, 2, 2, 492, 78, 3, 2, 2, 2, 493, 494, 7, 117, 2, 2, 494, 495, 7, 118, 2, 2, 495, 496, 7, 116, 2, 2, 496, 497, 7, 107, 2, 2, 497, 498, 7, 101, 2, 2, 498, 499, 7, 118, 2, 2, 499, 500, 7, 104, 2, 2, 500, 501, 7, 114, 2, 2, 501, 80, 3, 2, 2, 2, 502, 503, 7, 117, 2, 2, 503, 504, 7, 119, 2, 2, 504, 505, 7, 114, 2, 2, 505, 506, 7, 103, 2, 2, 506, 507, 7, 116, 2, 2, 507, 82, 3, 2, 2, 2, 508, 509, 7, 117, 2, 2, 509, 510, 7, 121, 2, 2, 510, 511, 7, 107, 2, 2, 511, 512, 7, 118, 2, 2, 512, 513, 7, 101, 2, 2, 513, 514, 7, 106, 2, 2, 514, 84, 3, 2, 2, 2, 515, 516, 7, 117, 2, 2, 516, 517, 7, 123, 2, 2, 517, 518, 7, 112, 2, 2, 518, 519, 7, 101, 2, 2, 519, 520, 7, 106, 2, 2, 520, 521, 7, 116, 2, 2, 521, 522, 7, 113, 2, 2, 522, 523, 7, 112, 2, 2, 523, 524, 7, 107, 2, 2, 524, 525, 7, 124, 2, 2, 525, 526, 7, 103, 2, 2, 526, 527, 7, 102, 2, 2, 527, 86, 3, 2, 2, 2, 528, 529, 7, 118, 2, 2, 529, 530, 7, 106, 2, 2, 530, 531, 7, 107, 2, 2, 531, 532, 7, 117, 2, 2, 532, 88, 3, 2, 2, 2, 533, 534, 7, 118, 2, 2, 534, 535, 7, 106, 2, 2, 535, 536, 7, 116, 2, 2, 536, 537, 7, 113, 2, 2, 537, 538, 7, 121, 2, 2, 538, 90, 3, 2, 2, 2, 539, 540, 7, 118, 2, 2, 540, 541, 7, 106, 2, 2, 541, 542, 7, 116, 2, 2, 542, 543, 7, 113, 2, 2, 543, 544, 7, 121, 2, 2, 544, 545, 7, 117, 2, 2, 545, 92, 3, 2, 2, 2, 546, 547, 7, 118, 2, 2, 547, 548, 7, 116, 2, 2, 548, 549, 7, 99, 2, 2, 549, 550, 7, 112, 2, 2, 550, 551, 7, 117, 2, 2, 551, 552, 7, 107, 2, 2, 552, 553, 7, 103, 2, 2, 553, 554, 7, 112, 2, 2, 554, 555, 7, 118, 2, 2, 555, 94, 3, 2, 2, 2, 556, 557, 7, 118, 2, 2, 557, 558, 7, 116, 2, 2, 558, 559, 7, 123, 2, 2, 559, 96, 3, 2, 2, 2, 560, 561, 7, 120, 2, 2, 561, 562, 7, 113, 2, 2, 562, 563, 7, 107, 2, 2, 563, 564, 7, 102, 2, 2, 564, 98, 3, 2, 2, 2, 565, 566, 7, 120, 2, 2, 566, 567, 7, 113, 2, 2, 567, 568, 7, 110, 2, 2, 568, 569, 7, 99, 2, 2, 569, 570, 7, 118, 2, 2, 570, 571, 7, 107, 2, 2, 571, 572, 7, 110, 2, 2, 572, 573, 7, 103, 2, 2, 573, 100, 3, 2, 2, 2, 574, 575, 7, 121, 2, 2, 575, 576, 7, 106, 2, 2, 576, 577, 7, 107, 2, 2, 577, 578, 7, 110, 2, 2, 578, 579, 7, 103, 2, 2, 579, 102, 3, 2, 2, 2, 580, 594, 7, 50, 2, 2, 581, 591, 9, 2, 2, 2, 582, 584, 5, 235, 118, 2, 583, 582, 3, 2, 2, 2, 583, 584, 3, 2, 2, 2, 584, 592, 3, 2, 2, 2, 585, 587, 7, 97, 2, 2, 586, 585, 3, 2, 2, 2, 587, 588, 3, 2, 2, 2, 588, 586, 3, 2, 2, 2, 588, 589, 3, 2, 2, 2, 589, 590, 3, 2, 2, 2, 590, 592, 5, 235, 118, 2, 591, 583, 3, 2, 2, 2, 591, 586, 3, 2, 2, 2, 592, 594, 3, 2, 2, 2, 593, 580, 3, 2, 2, 2, 593, 581, 3, 2, 2, 2, 594, 596, 3, 2, 2, 2, 595, 597, 9, 3, 2, 2, 596, 595, 3, 2, 2, 2, 596, 597, 3, 2, 2, 2, 597, 104, 3, 2, 2, 2, 598, 599, 7, 50, 2, 2, 599, 600, 9, 4, 2, 2, 600, 608, 9, 5, 2, 2, 601, 603, 9, 6, 2, 2, 602, 601, 3, 2, 2, 2, 603, 606, 3, 2, 2, 2, 604, 602, 3, 2, 2, 2, 604, 605, 3, 2, 2, 2, 605, 607, 3, 2, 2, 2, 606, 604, 3, 2, 2, 2, 607, 609, 9, 5, 2, 2, 608, 604, 3, 2, 2, 2, 608, 609, 3, 2, 2, 2, 609, 611, 3, 2, 2, 2, 610, 612, 9, 3, 2, 2, 611, 610, 3, 2, 2, 2, 611, 612, 3, 2, 2, 2, 612, 106, 3, 2, 2, 2, 613, 617, 7, 50, 2, 2, 614, 616, 7, 97, 2, 2, 615, 614, 3, 2, 2, 2, 616, 619, 3, 2, 2, 2, 617, 615, 3, 2, 2, 2, 617, 618, 3, 2, 2, 2, 618, 620, 3, 2, 2, 2, 619, 617, 3, 2, 2, 2, 620, 628, 9, 7, 2, 2, 621, 623, 9, 8, 2, 2, 622, 621, 3, 2, 2, 2, 623, 626, 3, 2, 2, 2, 624, 622, 3, 2, 2, 2, 624, 625, 3, 2, 2, 2, 625, 627, 3, 2, 2, 2, 626, 624, 3, 2, 2, 2, 627, 629, 9, 7, 2, 2, 628, 624, 3, 2, 2, 2, 628, 629, 3, 2, 2, 2, 629, 631, 3, 2, 2, 2, 630, 632, 9, 3, 2, 2, 631, 630, 3, 2, 2, 2, 631, 632, 3, 2, 2, 2, 632, 108, 3, 2, 2, 2, 633, 634, 7, 50, 2, 2, 634, 635, 9, 9, 2, 2, 635, 643, 9, 10, 2, 2, 636, 638, 9, 11, 2, 2, 637, 636, 3, 2, 2, 2, 638, 641, 3, 2, 2, 2, 639, 637, 3, 2, 2, 2, 639, 640, 3, 2, 2, 2, 640, 642, 3, 2, 2, 2, 641, 639, 3, 2, 2, 2, 642, 644, 9, 10, 2, 2, 643, 639, 3, 2, 2, 2, 643, 644, 3, 2, 2, 2, 644, 646, 3, 2, 2, 2, 645, 647, 9, 3, 2, 2, 646, 645, 3, 2, 2, 2, 646, 647, 3, 2, 2, 2, 647, 110, 3, 2, 2, 2, 648, 649, 5, 235, 118, 2, 649, 651, 7, 48, 2, 2, 650, 652, 5, 235, 118, 2, 651, 650, 3, 2, 2, 2, 651, 652, 3, 2, 2, 2, 652, 656, 3, 2, 2, 2, 653, 654, 7, 48, 2, 2, 654, 656, 5, 235, 118, 2, 655, 648, 3, 2, 2, 2, 655, 653, 3, 2, 2, 2, 656, 658, 3, 2, 2, 2, 657, 659, 5, 227, 114, 2, 658, 657, 3, 2, 2, 2, 658, 659, 3, 2, 2, 2, 659, 661, 3, 2, 2, 2, 660, 662, 9, 12, 2, 2, 661, 660, 3, 2, 2, 2, 661, 662, 3, 2, 2, 2, 662, 672, 3, 2, 2, 2, 663, 669, 5, 235, 118, 2, 664, 666, 5, 227, 114, 2, 665, 667, 9, 12, 2, 2, 666, 665, 3, 2, 2, 2, 666, 667, 3, 2, 2, 2, 667, 670, 3, 2, 2, 2, 668, 670, 9, 12, 2, 2, 669, 664, 3, 2, 2, 2, 669, 668, 3, 2, 2, 2, 670, 672, 3, 2, 2, 2, 671, 655, 3, 2, 2, 2, 671, 663, 3, 2, 2, 2, 672, 112, 3, 2, 2, 2, 673, 674, 7, 50, 2, 2, 674, 684, 9, 4, 2, 2, 675, 677, 5, 231, 116, 2, 676, 678, 7, 48, 2, 2, 677, 676, 3, 2, 2, 2, 677, 678, 3, 2, 2, 2, 678, 685, 3, 2, 2, 2, 679, 681, 5, 231, 116, 2, 680, 679, 3, 2, 2, 2, 680, 681, 3, 2, 2, 2, 681, 682, 3, 2, 2, 2, 682, 683, 7, 48, 2, 2, 683, 685, 5, 231, 116, 2, 684, 675, 3, 2, 2, 2, 684, 680, 3, 2, 2, 2, 685, 686, 3, 2, 2, 2, 686, 688, 9, 13, 2, 2, 687, 689, 9, 14, 2, 2, 688, 687, 3, 2, 2, 2, 688, 689, 3, 2, 2, 2, 689, 690, 3, 2, 2, 2, 690, 692, 5, 235, 118, 2, 691, 693, 9, 12, 2, 2, 692, 691, 3, 2, 2, 2, 692, 693, 3, 2, 2, 2, 693, 114, 3, 2, 2, 2, 694, 695, 7, 118, 2, 2, 695, 696, 7, 116, 2, 2, 696, 697, 7, 119, 2, 2, 697, 704, 7, 103, 2, 2, 698, 699, 7, 104, 2, 2, 699, 700, 7, 99, 2, 2, 700, 701, 7, 110, 2, 2, 701, 702, 7, 117, 2, 2, 702, 704, 7, 103, 2, 2, 703, 694, 3, 2, 2, 2, 703, 698, 3, 2, 2, 2, 704, 116, 3, 2, 2, 2, 705, 708, 7, 41, 2, 2, 706, 709, 10, 15, 2, 2, 707, 709, 5, 229, 115, 2, 708, 706, 3, 2, 2, 2, 708, 707, 3, 2, 2, 2, 709, 710, 3, 2, 2, 2, 710, 711, 7, 41, 2, 2, 711, 118, 3, 2, 2, 2, 712, 717, 7, 41, 2, 2, 713, 716, 10, 15, 2, 2, 714, 716, 5, 229, 115, 2, 715, 713, 3, 2, 2, 2, 715, 714, 3, 2, 2, 2, 716, 719, 3, 2, 2, 2, 717, 715, 3, 2, 2, 2, 717, 718, 3, 2, 2, 2, 718, 720, 3, 2, 2, 2, 719, 717, 3, 2, 2, 2, 720, 721, 7, 41, 2, 2, 721, 120, 3, 2, 2, 2, 722, 727, 7, 36, 2, 2, 723, 726, 10, 16, 2, 2, 724, 726, 5, 229, 115, 2, 725, 723, 3, 2, 2, 2, 725, 724, 3, 2, 2, 2, 726, 729, 3, 2, 2, 2, 727, 725, 3, 2, 2, 2, 727, 728, 3, 2, 2, 2, 728, 730, 3, 2, 2, 2, 729, 727, 3, 2, 2, 2, 730, 731, 7, 36, 2, 2, 731, 122, 3, 2, 2, 2, 732, 733, 7, 112, 2, 2, 733, 734, 7, 119, 2, 2, 734, 735, 7, 110, 2, 2, 735, 736, 7, 110, 2, 2, 736, 124, 3, 2, 2, 2, 737, 738, 7, 42, 2, 2, 738, 126, 3, 2, 2, 2, 739, 740, 7, 43, 2, 2, 740, 128, 3, 2, 2, 2, 741, 742, 7, 125, 2, 2, 742, 130, 3, 2, 2, 2, 743, 744, 7, 127, 2, 2, 744, 132, 3, 2, 2, 2, 745, 746, 7, 93, 2, 2, 746, 134, 3, 2, 2, 2, 747, 748, 7, 95, 2, 2, 748, 136, 3, 2, 2, 2, 749, 750, 7, 61, 2, 2, 750, 138, 3, 2, 2, 2, 751, 752, 7, 46, 2, 2, 752, 140, 3, 2, 2, 2, 753, 754, 7, 48, 2, 2, 754, 142, 3, 2, 2, 2, 755, 756, 7, 63, 2, 2, 756, 144, 3, 2, 2, 2, 757, 758, 7, 64, 2, 2, 758, 146, 3, 2, 2, 2, 759, 760, 7, 62, 2, 2, 760, 148, 3, 2, 2, 2, 761, 762, 7, 35, 2, 2, 762, 150, 3, 2, 2, 2, 763, 764, 7, 128, 2, 2, 764, 152, 3, 2, 2, 2, 765, 766, 7, 65, 2, 2, 766, 154, 3, 2, 2, 2, 767, 768, 7, 60, 2, 2, 768, 156, 3, 2, 2, 2, 769, 770, 7, 63, 2, 2, 770, 771, 7, 63, 2, 2, 771, 158, 3, 2, 2, 2, 772, 773, 7, 62, 2, 2, 773, 774, 7, 63, 2, 2, 774, 160, 3, 2, 2, 2, 775, 776, 7, 64, 2, 2, 776, 777, 7, 63, 2, 2, 777, 162, 3, 2, 2, 2, 778, 779, 7, 35, 2, 2, 779, 780, 7, 63, 2, 2, 780, 164, 3, 2, 2, 2, 781, 782, 7, 40, 2, 2, 782, 783, 7, 40, 2, 2, 783, 166, 3, 2, 2, 2, 784, 785, 7, 126, 2, 2, 785, 786, 7, 126, 2, 2, 786, 168, 3, 2, 2, 2, 787, 788, 7, 45, 2, 2, 788, 789, 7, 45, 2, 2, 789, 170, 3, 2, 2, 2, 790, 791, 7, 47, 2, 2, 791, 792, 7, 47, 2, 2, 792, 172, 3, 2, 2, 2, 793, 794, 7, 45, 2, 2, 794, 174, 3, 2, 2, 2, 795, 796, 7, 47, 2, 2, 796, 176, 3, 2, 2, 2, 797, 798, 7, 44, 2, 2, 798, 178, 3, 2, 2, 2, 799, 800, 7, 49, 2, 2, 800, 180, 3, 2, 2, 2, 801, 802, 7, 40, 2, 2, 802, 182, 3, 2, 2, 2, 803, 804, 7, 126, 2, 2, 804, 184, 3, 2, 2, 2, 805, 806, 7, 96, 2, 2, 806, 186, 3, 2, 2, 2, 807, 808, 7, 39, 2, 2, 808, 188, 3, 2, 2, 2, 809, 810, 7, 45, 2, 2, 810, 811, 7, 63, 2, 2, 811, 190, 3, 2, 2, 2, 812, 813, 7, 47, 2, 2, 813, 814, 7, 63, 2, 2, 814, 192, 3, 2, 2, 2, 815, 816, 7, 44, 2, 2, 816, 817, 7, 63, 2, 2, 817, 194, 3, 2, 2, 2, 818, 819, 7, 49, 2, 2, 819, 820, 7, 63, 2, 2, 820, 196, 3, 2, 2, 2, 821, 822, 7, 40, 2, 2, 822, 823, 7, 63, 2, 2, 823, 198, 3, 2, 2, 2, 824, 825, 7, 126, 2, 2, 825, 826, 7, 63, 2, 2, 826, 200, 3, 2, 2, 2, 827, 828, 7, 96, 2, 2, 828, 829, 7, 63, 2, 2, 829, 202, 3, 2, 2, 2, 830, 831, 7, 39, 2, 2, 831, 832, 7, 63, 2, 2, 832, 204, 3, 2, 2, 2, 833, 834, 7, 62, 2, 2, 834, 835, 7, 62, 2, 2, 835, 836, 7, 63, 2, 2, 836, 206, 3, 2, 2, 2, 837, 838, 7, 64, 2, 2, 838, 839, 7, 64, 2, 2, 839, 840, 7, 63, 2, 2, 840, 208, 3, 2, 2, 2, 841, 842, 7, 64, 2, 2, 842, 843, 7, 64, 2, 2, 843, 844, 7, 64, 2, 2, 844, 845, 7, 63, 2, 2, 845, 210, 3, 2, 2, 2, 846, 847, 7, 47, 2, 2, 847, 848, 7, 64, 2, 2, 848, 212, 3, 2, 2, 2, 849, 850, 7, 60, 2, 2, 850, 851, 7, 60, 2, 2, 851, 214, 3, 2, 2, 2, 852, 853, 7, 66, 2, 2, 853, 216, 3, 2, 2, 2, 854, 855, 7, 48, 2, 2, 855, 856, 7, 48, 2, 2, 856, 857, 7, 48, 2, 2, 857, 218, 3, 2, 2, 2, 858, 860, 9, 17, 2, 2, 859, 858, 3, 2, 2, 2, 860, 861, 3, 2, 2, 2, 861, 859, 3, 2, 2, 2, 861, 862, 3, 2, 2, 2, 862, 863, 3, 2, 2, 2, 863, 864, 8, 110, 2, 2, 864, 220, 3, 2, 2, 2, 865, 866, 7, 49, 2, 2, 866, 867, 7, 44, 2, 2, 867, 871, 3, 2, 2, 2, 868, 870, 11, 2, 2, 2, 869, 868, 3, 2, 2, 2, 870, 873, 3, 2, 2, 2, 871, 872, 3, 2, 2, 2, 871, 869, 3, 2, 2, 2, 872, 874, 3, 2, 2, 2, 873, 871, 3, 2, 2, 2, 874, 875, 7, 44, 2, 2, 875, 876, 7, 49, 2, 2, 876, 877, 3, 2, 2, 2, 877, 878, 8, 111, 2, 2, 878, 222, 3, 2, 2, 2, 879, 880, 7, 49, 2, 2, 880, 881, 7, 49, 2, 2, 881, 885, 3, 2, 2, 2, 882, 884, 10, 18, 2, 2, 883, 882, 3, 2, 2, 2, 884, 887, 3, 2, 2, 2, 885, 883, 3, 2, 2, 2, 885, 886, 3, 2, 2, 2, 886, 888, 3, 2, 2, 2, 887, 885, 3, 2, 2, 2, 888, 889, 8, 112, 2, 2, 889, 224, 3, 2, 2, 2, 890, 894, 5, 239, 120, 2, 891, 893, 5, 237, 119, 2, 892, 891, 3, 2, 2, 2, 893, 896, 3, 2, 2, 2, 894, 892, 3, 2, 2, 2, 894, 895, 3, 2, 2, 2, 895, 226, 3, 2, 2, 2, 896, 894, 3, 2, 2, 2, 897, 899, 9, 19, 2, 2, 898, 900, 9, 14, 2, 2, 899, 898, 3, 2, 2, 2, 899, 900, 3, 2, 2, 2, 900, 901, 3, 2, 2, 2, 901, 902, 5, 235, 118, 2, 902, 228, 3, 2, 2, 2, 903, 904, 7, 94, 2, 2, 904, 925, 9, 20, 2, 2, 905, 910, 7, 94, 2, 2, 906, 908, 9, 21, 2, 2, 907, 906, 3, 2, 2, 2, 907, 908, 3, 2, 2, 2, 908, 909, 3, 2, 2, 2, 909, 911, 9, 7, 2, 2, 910, 907, 3, 2, 2, 2, 910, 911, 3, 2, 2, 2, 911, 912, 3, 2, 2, 2, 912, 925, 9, 7, 2, 2, 913, 915, 7, 94, 2, 2, 914, 916, 7, 119, 2, 2, 915, 914, 3, 2, 2, 2, 916, 917, 3, 2, 2, 2, 917, 915, 3, 2, 2, 2, 917, 918, 3, 2, 2, 2, 918, 919, 3, 2, 2, 2, 919, 920, 5, 233, 117, 2, 920, 921, 5, 233, 117, 2, 921, 922, 5, 233, 117, 2, 922, 923, 5, 233, 117, 2, 923, 925, 3, 2, 2, 2, 924, 903, 3, 2, 2, 2, 924, 905, 3, 2, 2, 2, 924, 913, 3, 2, 2, 2, 925, 230, 3, 2, 2, 2, 926, 935, 5, 233, 117, 2, 927, 930, 5, 233, 117, 2, 928, 930, 7, 97, 2, 2, 929, 927, 3, 2, 2, 2, 929, 928, 3, 2, 2, 2, 930, 933, 3, 2, 2, 2, 931, 929, 3, 2, 2, 2, 931, 932, 3, 2, 2, 2, 932, 934, 3, 2, 2, 2, 933, 931, 3, 2, 2, 2, 934, 936, 5, 233, 117, 2, 935, 931, 3, 2, 2, 2, 935, 936, 3, 2, 2, 2, 936, 232, 3, 2, 2, 2, 937, 938, 9, 5, 2, 2, 938, 234, 3, 2, 2, 2, 939, 947, 9, 22, 2, 2, 940, 942, 9, 23, 2, 2, 941, 940, 3, 2, 2, 2, 942, 945, 3, 2, 2, 2, 943, 941, 3, 2, 2, 2, 943, 944, 3, 2, 2, 2, 944, 946, 3, 2, 2, 2, 945, 943, 3, 2, 2, 2, 946, 948, 9, 22, 2, 2, 947, 943, 3, 2, 2, 2, 947, 948, 3, 2, 2, 2, 948, 236, 3, 2, 2, 2, 949, 952, 5, 239, 120, 2, 950, 952, 9, 22, 2, 2, 951, 949, 3, 2, 2, 2, 951, 950, 3, 2, 2, 2, 952, 238, 3, 2, 2, 2, 953, 958, 9, 24, 2, 2, 954, 958, 10, 25, 2, 2, 955, 956, 9, 26, 2, 2, 956, 958, 9, 27, 2, 2, 957, 953, 3, 2, 2, 2, 957, 954, 3, 2, 2, 2, 957, 955, 3, 2, 2, 2, 958, 240, 3, 2, 2, 2, 52, 2, 583, 588, 591, 593, 596, 604, 608, 611, 617, 624, 628, 631, 639, 643, 646, 651, 655, 658, 661, 666, 669, 671, 677, 680, 684, 688, 692, 703, 708, 715, 717, 725, 727, 861, 871, 885, 894, 899, 907, 910, 917, 924, 929, 931, 935, 943, 947, 951, 957, 3, 2, 3, 2] \ No newline at end of file diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/groovy/GroovyLexer.java b/lexers/src/main/java/com/itsaky/androidide/lexers/groovy/GroovyLexer.java index 2c7ec7799..72bde8c84 100755 --- a/lexers/src/main/java/com/itsaky/androidide/lexers/groovy/GroovyLexer.java +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/groovy/GroovyLexer.java @@ -1,27 +1,7 @@ -/************************************************************************************ - * 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 . - * - **************************************************************************************/ -// Generated from GroovyLexer.g4 by ANTLR 4.9.2 +// Generated from GroovyLexer.g4 by ANTLR 4.9.3 package com.itsaky.androidide.lexers.groovy; import org.antlr.v4.runtime.CharStream; -import org.antlr.v4.runtime.CharStreams; import org.antlr.v4.runtime.Lexer; import org.antlr.v4.runtime.RuntimeMetaData; import org.antlr.v4.runtime.Vocabulary; @@ -32,17 +12,8 @@ import org.antlr.v4.runtime.atn.LexerATNSimulator; import org.antlr.v4.runtime.atn.PredictionContextCache; import org.antlr.v4.runtime.dfa.DFA; -import java.io.IOException; -import java.io.StringReader; - @SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) public class GroovyLexer extends Lexer { - static { - RuntimeMetaData.checkVersion("4.9.2", RuntimeMetaData.VERSION); - } - - protected static final DFA[] _decisionToDFA; - protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache(); public static final int ABSTRACT = 1, ASSERT = 2, BOOLEAN = 3, @@ -155,442 +126,11 @@ public class GroovyLexer extends Lexer { COMMENT = 110, LINE_COMMENT = 111, IDENTIFIER = 112; - public static String[] channelNames = {"DEFAULT_TOKEN_CHANNEL", "HIDDEN"}; - - public static String[] modeNames = {"DEFAULT_MODE"}; - - private static String[] makeRuleNames() { - return new String[] { - "ABSTRACT", - "ASSERT", - "BOOLEAN", - "BREAK", - "BYTE", - "CASE", - "CATCH", - "CHAR", - "CLASS", - "CONST", - "CONTINUE", - "DEFAULT", - "DO", - "DOUBLE", - "ELSE", - "ENUM", - "EXTENDS", - "FINAL", - "FINALLY", - "FLOAT", - "FOR", - "IF", - "GOTO", - "IMPLEMENTS", - "IMPORT", - "INSTANCEOF", - "INT", - "INTERFACE", - "LONG", - "NATIVE", - "NEW", - "PACKAGE", - "PRIVATE", - "PROTECTED", - "PUBLIC", - "RETURN", - "SHORT", - "STATIC", - "STRICTFP", - "SUPER", - "SWITCH", - "SYNCHRONIZED", - "THIS", - "THROW", - "THROWS", - "TRANSIENT", - "TRY", - "VOID", - "VOLATILE", - "WHILE", - "DECIMAL_LITERAL", - "HEX_LITERAL", - "OCT_LITERAL", - "BINARY_LITERAL", - "FLOAT_LITERAL", - "HEX_FLOAT_LITERAL", - "BOOL_LITERAL", - "CHAR_LITERAL", - "SINGLE_QUOTE_STRING", - "STRING_LITERAL", - "NULL_LITERAL", - "LPAREN", - "RPAREN", - "LBRACE", - "RBRACE", - "LBRACK", - "RBRACK", - "SEMI", - "COMMA", - "DOT", - "ASSIGN", - "GT", - "LT", - "BANG", - "TILDE", - "QUESTION", - "COLON", - "EQUAL", - "LE", - "GE", - "NOTEQUAL", - "AND", - "OR", - "INC", - "DEC", - "ADD", - "SUB", - "MUL", - "DIV", - "BITAND", - "BITOR", - "CARET", - "MOD", - "ADD_ASSIGN", - "SUB_ASSIGN", - "MUL_ASSIGN", - "DIV_ASSIGN", - "AND_ASSIGN", - "OR_ASSIGN", - "XOR_ASSIGN", - "MOD_ASSIGN", - "LSHIFT_ASSIGN", - "RSHIFT_ASSIGN", - "URSHIFT_ASSIGN", - "ARROW", - "COLONCOLON", - "AT", - "ELLIPSIS", - "WS", - "COMMENT", - "LINE_COMMENT", - "IDENTIFIER", - "ExponentPart", - "EscapeSequence", - "HexDigits", - "HexDigit", - "Digits", - "LetterOrDigit", - "Letter" - }; - } - public static final String[] ruleNames = makeRuleNames(); - - private static String[] makeLiteralNames() { - return new String[] { - null, - "'abstract'", - "'assert'", - "'boolean'", - "'break'", - "'byte'", - "'case'", - "'catch'", - "'char'", - "'class'", - "'const'", - "'continue'", - "'default'", - "'do'", - "'double'", - "'else'", - "'enum'", - "'extends'", - "'final'", - "'finally'", - "'float'", - "'for'", - "'if'", - "'goto'", - "'implements'", - "'import'", - "'instanceof'", - "'int'", - "'interface'", - "'long'", - "'native'", - "'new'", - "'package'", - "'private'", - "'protected'", - "'public'", - "'return'", - "'short'", - "'static'", - "'strictfp'", - "'super'", - "'switch'", - "'synchronized'", - "'this'", - "'throw'", - "'throws'", - "'transient'", - "'try'", - "'void'", - "'volatile'", - "'while'", - null, - null, - null, - null, - null, - null, - null, - null, - null, - null, - "'null'", - "'('", - "')'", - "'{'", - "'}'", - "'['", - "']'", - "';'", - "','", - "'.'", - "'='", - "'>'", - "'<'", - "'!'", - "'~'", - "'?'", - "':'", - "'=='", - "'<='", - "'>='", - "'!='", - "'&&'", - "'||'", - "'++'", - "'--'", - "'+'", - "'-'", - "'*'", - "'/'", - "'&'", - "'|'", - "'^'", - "'%'", - "'+='", - "'-='", - "'*='", - "'/='", - "'&='", - "'|='", - "'^='", - "'%='", - "'<<='", - "'>>='", - "'>>>='", - "'->'", - "'::'", - "'@'", - "'...'" - }; - } - - private static final String[] _LITERAL_NAMES = makeLiteralNames(); - - private static String[] makeSymbolicNames() { - return new String[] { - null, - "ABSTRACT", - "ASSERT", - "BOOLEAN", - "BREAK", - "BYTE", - "CASE", - "CATCH", - "CHAR", - "CLASS", - "CONST", - "CONTINUE", - "DEFAULT", - "DO", - "DOUBLE", - "ELSE", - "ENUM", - "EXTENDS", - "FINAL", - "FINALLY", - "FLOAT", - "FOR", - "IF", - "GOTO", - "IMPLEMENTS", - "IMPORT", - "INSTANCEOF", - "INT", - "INTERFACE", - "LONG", - "NATIVE", - "NEW", - "PACKAGE", - "PRIVATE", - "PROTECTED", - "PUBLIC", - "RETURN", - "SHORT", - "STATIC", - "STRICTFP", - "SUPER", - "SWITCH", - "SYNCHRONIZED", - "THIS", - "THROW", - "THROWS", - "TRANSIENT", - "TRY", - "VOID", - "VOLATILE", - "WHILE", - "DECIMAL_LITERAL", - "HEX_LITERAL", - "OCT_LITERAL", - "BINARY_LITERAL", - "FLOAT_LITERAL", - "HEX_FLOAT_LITERAL", - "BOOL_LITERAL", - "CHAR_LITERAL", - "SINGLE_QUOTE_STRING", - "STRING_LITERAL", - "NULL_LITERAL", - "LPAREN", - "RPAREN", - "LBRACE", - "RBRACE", - "LBRACK", - "RBRACK", - "SEMI", - "COMMA", - "DOT", - "ASSIGN", - "GT", - "LT", - "BANG", - "TILDE", - "QUESTION", - "COLON", - "EQUAL", - "LE", - "GE", - "NOTEQUAL", - "AND", - "OR", - "INC", - "DEC", - "ADD", - "SUB", - "MUL", - "DIV", - "BITAND", - "BITOR", - "CARET", - "MOD", - "ADD_ASSIGN", - "SUB_ASSIGN", - "MUL_ASSIGN", - "DIV_ASSIGN", - "AND_ASSIGN", - "OR_ASSIGN", - "XOR_ASSIGN", - "MOD_ASSIGN", - "LSHIFT_ASSIGN", - "RSHIFT_ASSIGN", - "URSHIFT_ASSIGN", - "ARROW", - "COLONCOLON", - "AT", - "ELLIPSIS", - "WS", - "COMMENT", - "LINE_COMMENT", - "IDENTIFIER" - }; - } - - 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 GroovyLexer(String input) throws IOException { - this(CharStreams.fromReader(new StringReader(input))); - } - - public GroovyLexer(CharStream input) { - super(input); - _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache); - } - - @Override - public String getGrammarFileName() { - return "GroovyLexer.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\2r\u03bf\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" @@ -929,6 +469,31 @@ public class GroovyLexer extends Lexer { + "\u02cb\u02cd\u02d5\u02d7\u035d\u0367\u0375\u037e\u0383\u038b\u038e\u0395" + "\u039c\u03a1\u03a3\u03a7\u03af\u03b3\u03b7\u03bd\3\2\3\2"; public static final ATN _ATN = new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache(); + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + public static String[] channelNames = {"DEFAULT_TOKEN_CHANNEL", "HIDDEN"}; + public static String[] modeNames = {"DEFAULT_MODE"}; + + static { + RuntimeMetaData.checkVersion("4.9.3", RuntimeMetaData.VERSION); + } + + 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] = ""; + } + } + } static { _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; @@ -936,4 +501,406 @@ public class GroovyLexer extends Lexer { _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); } } + + public GroovyLexer(CharStream input) { + super(input); + _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache); + } + + private static String[] makeRuleNames() { + return new String[] { + "ABSTRACT", + "ASSERT", + "BOOLEAN", + "BREAK", + "BYTE", + "CASE", + "CATCH", + "CHAR", + "CLASS", + "CONST", + "CONTINUE", + "DEFAULT", + "DO", + "DOUBLE", + "ELSE", + "ENUM", + "EXTENDS", + "FINAL", + "FINALLY", + "FLOAT", + "FOR", + "IF", + "GOTO", + "IMPLEMENTS", + "IMPORT", + "INSTANCEOF", + "INT", + "INTERFACE", + "LONG", + "NATIVE", + "NEW", + "PACKAGE", + "PRIVATE", + "PROTECTED", + "PUBLIC", + "RETURN", + "SHORT", + "STATIC", + "STRICTFP", + "SUPER", + "SWITCH", + "SYNCHRONIZED", + "THIS", + "THROW", + "THROWS", + "TRANSIENT", + "TRY", + "VOID", + "VOLATILE", + "WHILE", + "DECIMAL_LITERAL", + "HEX_LITERAL", + "OCT_LITERAL", + "BINARY_LITERAL", + "FLOAT_LITERAL", + "HEX_FLOAT_LITERAL", + "BOOL_LITERAL", + "CHAR_LITERAL", + "SINGLE_QUOTE_STRING", + "STRING_LITERAL", + "NULL_LITERAL", + "LPAREN", + "RPAREN", + "LBRACE", + "RBRACE", + "LBRACK", + "RBRACK", + "SEMI", + "COMMA", + "DOT", + "ASSIGN", + "GT", + "LT", + "BANG", + "TILDE", + "QUESTION", + "COLON", + "EQUAL", + "LE", + "GE", + "NOTEQUAL", + "AND", + "OR", + "INC", + "DEC", + "ADD", + "SUB", + "MUL", + "DIV", + "BITAND", + "BITOR", + "CARET", + "MOD", + "ADD_ASSIGN", + "SUB_ASSIGN", + "MUL_ASSIGN", + "DIV_ASSIGN", + "AND_ASSIGN", + "OR_ASSIGN", + "XOR_ASSIGN", + "MOD_ASSIGN", + "LSHIFT_ASSIGN", + "RSHIFT_ASSIGN", + "URSHIFT_ASSIGN", + "ARROW", + "COLONCOLON", + "AT", + "ELLIPSIS", + "WS", + "COMMENT", + "LINE_COMMENT", + "IDENTIFIER", + "ExponentPart", + "EscapeSequence", + "HexDigits", + "HexDigit", + "Digits", + "LetterOrDigit", + "Letter" + }; + } + + private static String[] makeLiteralNames() { + return new String[] { + null, + "'abstract'", + "'assert'", + "'boolean'", + "'break'", + "'byte'", + "'case'", + "'catch'", + "'char'", + "'class'", + "'const'", + "'continue'", + "'default'", + "'do'", + "'double'", + "'else'", + "'enum'", + "'extends'", + "'final'", + "'finally'", + "'float'", + "'for'", + "'if'", + "'goto'", + "'implements'", + "'import'", + "'instanceof'", + "'int'", + "'interface'", + "'long'", + "'native'", + "'new'", + "'package'", + "'private'", + "'protected'", + "'public'", + "'return'", + "'short'", + "'static'", + "'strictfp'", + "'super'", + "'switch'", + "'synchronized'", + "'this'", + "'throw'", + "'throws'", + "'transient'", + "'try'", + "'void'", + "'volatile'", + "'while'", + null, + null, + null, + null, + null, + null, + null, + null, + null, + null, + "'null'", + "'('", + "')'", + "'{'", + "'}'", + "'['", + "']'", + "';'", + "','", + "'.'", + "'='", + "'>'", + "'<'", + "'!'", + "'~'", + "'?'", + "':'", + "'=='", + "'<='", + "'>='", + "'!='", + "'&&'", + "'||'", + "'++'", + "'--'", + "'+'", + "'-'", + "'*'", + "'/'", + "'&'", + "'|'", + "'^'", + "'%'", + "'+='", + "'-='", + "'*='", + "'/='", + "'&='", + "'|='", + "'^='", + "'%='", + "'<<='", + "'>>='", + "'>>>='", + "'->'", + "'::'", + "'@'", + "'...'" + }; + } + + private static String[] makeSymbolicNames() { + return new String[] { + null, + "ABSTRACT", + "ASSERT", + "BOOLEAN", + "BREAK", + "BYTE", + "CASE", + "CATCH", + "CHAR", + "CLASS", + "CONST", + "CONTINUE", + "DEFAULT", + "DO", + "DOUBLE", + "ELSE", + "ENUM", + "EXTENDS", + "FINAL", + "FINALLY", + "FLOAT", + "FOR", + "IF", + "GOTO", + "IMPLEMENTS", + "IMPORT", + "INSTANCEOF", + "INT", + "INTERFACE", + "LONG", + "NATIVE", + "NEW", + "PACKAGE", + "PRIVATE", + "PROTECTED", + "PUBLIC", + "RETURN", + "SHORT", + "STATIC", + "STRICTFP", + "SUPER", + "SWITCH", + "SYNCHRONIZED", + "THIS", + "THROW", + "THROWS", + "TRANSIENT", + "TRY", + "VOID", + "VOLATILE", + "WHILE", + "DECIMAL_LITERAL", + "HEX_LITERAL", + "OCT_LITERAL", + "BINARY_LITERAL", + "FLOAT_LITERAL", + "HEX_FLOAT_LITERAL", + "BOOL_LITERAL", + "CHAR_LITERAL", + "SINGLE_QUOTE_STRING", + "STRING_LITERAL", + "NULL_LITERAL", + "LPAREN", + "RPAREN", + "LBRACE", + "RBRACE", + "LBRACK", + "RBRACK", + "SEMI", + "COMMA", + "DOT", + "ASSIGN", + "GT", + "LT", + "BANG", + "TILDE", + "QUESTION", + "COLON", + "EQUAL", + "LE", + "GE", + "NOTEQUAL", + "AND", + "OR", + "INC", + "DEC", + "ADD", + "SUB", + "MUL", + "DIV", + "BITAND", + "BITOR", + "CARET", + "MOD", + "ADD_ASSIGN", + "SUB_ASSIGN", + "MUL_ASSIGN", + "DIV_ASSIGN", + "AND_ASSIGN", + "OR_ASSIGN", + "XOR_ASSIGN", + "MOD_ASSIGN", + "LSHIFT_ASSIGN", + "RSHIFT_ASSIGN", + "URSHIFT_ASSIGN", + "ARROW", + "COLONCOLON", + "AT", + "ELLIPSIS", + "WS", + "COMMENT", + "LINE_COMMENT", + "IDENTIFIER" + }; + } + + @Override + public String[] getRuleNames() { + return ruleNames; + } + + @Override + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + @Override + public String getSerializedATN() { + return _serializedATN; + } + + @Override + public String getGrammarFileName() { + return "GroovyLexer.g4"; + } + + @Override + public ATN getATN() { + return _ATN; + } + + @Override + public String[] getChannelNames() { + return channelNames; + } + + @Override + public String[] getModeNames() { + return modeNames; + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } } diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/groovy/GroovyLexer.tokens b/lexers/src/main/java/com/itsaky/androidide/lexers/groovy/GroovyLexer.tokens new file mode 100644 index 000000000..6906e652e --- /dev/null +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/groovy/GroovyLexer.tokens @@ -0,0 +1,210 @@ +ABSTRACT=1 +ASSERT=2 +BOOLEAN=3 +BREAK=4 +BYTE=5 +CASE=6 +CATCH=7 +CHAR=8 +CLASS=9 +CONST=10 +CONTINUE=11 +DEFAULT=12 +DO=13 +DOUBLE=14 +ELSE=15 +ENUM=16 +EXTENDS=17 +FINAL=18 +FINALLY=19 +FLOAT=20 +FOR=21 +IF=22 +GOTO=23 +IMPLEMENTS=24 +IMPORT=25 +INSTANCEOF=26 +INT=27 +INTERFACE=28 +LONG=29 +NATIVE=30 +NEW=31 +PACKAGE=32 +PRIVATE=33 +PROTECTED=34 +PUBLIC=35 +RETURN=36 +SHORT=37 +STATIC=38 +STRICTFP=39 +SUPER=40 +SWITCH=41 +SYNCHRONIZED=42 +THIS=43 +THROW=44 +THROWS=45 +TRANSIENT=46 +TRY=47 +VOID=48 +VOLATILE=49 +WHILE=50 +DECIMAL_LITERAL=51 +HEX_LITERAL=52 +OCT_LITERAL=53 +BINARY_LITERAL=54 +FLOAT_LITERAL=55 +HEX_FLOAT_LITERAL=56 +BOOL_LITERAL=57 +CHAR_LITERAL=58 +SINGLE_QUOTE_STRING=59 +STRING_LITERAL=60 +NULL_LITERAL=61 +LPAREN=62 +RPAREN=63 +LBRACE=64 +RBRACE=65 +LBRACK=66 +RBRACK=67 +SEMI=68 +COMMA=69 +DOT=70 +ASSIGN=71 +GT=72 +LT=73 +BANG=74 +TILDE=75 +QUESTION=76 +COLON=77 +EQUAL=78 +LE=79 +GE=80 +NOTEQUAL=81 +AND=82 +OR=83 +INC=84 +DEC=85 +ADD=86 +SUB=87 +MUL=88 +DIV=89 +BITAND=90 +BITOR=91 +CARET=92 +MOD=93 +ADD_ASSIGN=94 +SUB_ASSIGN=95 +MUL_ASSIGN=96 +DIV_ASSIGN=97 +AND_ASSIGN=98 +OR_ASSIGN=99 +XOR_ASSIGN=100 +MOD_ASSIGN=101 +LSHIFT_ASSIGN=102 +RSHIFT_ASSIGN=103 +URSHIFT_ASSIGN=104 +ARROW=105 +COLONCOLON=106 +AT=107 +ELLIPSIS=108 +WS=109 +COMMENT=110 +LINE_COMMENT=111 +IDENTIFIER=112 +'abstract'=1 +'assert'=2 +'boolean'=3 +'break'=4 +'byte'=5 +'case'=6 +'catch'=7 +'char'=8 +'class'=9 +'const'=10 +'continue'=11 +'default'=12 +'do'=13 +'double'=14 +'else'=15 +'enum'=16 +'extends'=17 +'final'=18 +'finally'=19 +'float'=20 +'for'=21 +'if'=22 +'goto'=23 +'implements'=24 +'import'=25 +'instanceof'=26 +'int'=27 +'interface'=28 +'long'=29 +'native'=30 +'new'=31 +'package'=32 +'private'=33 +'protected'=34 +'public'=35 +'return'=36 +'short'=37 +'static'=38 +'strictfp'=39 +'super'=40 +'switch'=41 +'synchronized'=42 +'this'=43 +'throw'=44 +'throws'=45 +'transient'=46 +'try'=47 +'void'=48 +'volatile'=49 +'while'=50 +'null'=61 +'('=62 +')'=63 +'{'=64 +'}'=65 +'['=66 +']'=67 +';'=68 +','=69 +'.'=70 +'='=71 +'>'=72 +'<'=73 +'!'=74 +'~'=75 +'?'=76 +':'=77 +'=='=78 +'<='=79 +'>='=80 +'!='=81 +'&&'=82 +'||'=83 +'++'=84 +'--'=85 +'+'=86 +'-'=87 +'*'=88 +'/'=89 +'&'=90 +'|'=91 +'^'=92 +'%'=93 +'+='=94 +'-='=95 +'*='=96 +'/='=97 +'&='=98 +'|='=99 +'^='=100 +'%='=101 +'<<='=102 +'>>='=103 +'>>>='=104 +'->'=105 +'::'=106 +'@'=107 +'...'=108 diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/java/JavaLexer.g4 b/lexers/src/main/java/com/itsaky/androidide/lexers/java/JavaLexer.g4 index 26dee8703..e7cc7195b 100755 --- a/lexers/src/main/java/com/itsaky/androidide/lexers/java/JavaLexer.g4 +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/java/JavaLexer.g4 @@ -170,7 +170,7 @@ ELLIPSIS: '...'; WS: [ \t\r\n\u000C]+ -> channel(HIDDEN); BLOCK_COMMENT: '/*' .*? '*/' -> channel(HIDDEN); -LINE_COMMENT: '//' ~[\r\n]* -> channel(HIDDEN); +LINE_COMMENT: '//'~[\r\n]* -> channel(HIDDEN); // Identifiers diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/java/JavaLexer.java b/lexers/src/main/java/com/itsaky/androidide/lexers/java/JavaLexer.java index 47b3a3d23..d5de60a3e 100755 --- a/lexers/src/main/java/com/itsaky/androidide/lexers/java/JavaLexer.java +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/java/JavaLexer.java @@ -1,23 +1,4 @@ -/************************************************************************************ - * 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 . - * - **************************************************************************************/ -// Generated from JavaLexer.g4 by ANTLR 4.9.2 +// Generated from JavaLexer.g4 by ANTLR 4.9.3 package com.itsaky.androidide.lexers.java; import org.antlr.v4.runtime.CharStream; @@ -33,12 +14,6 @@ import org.antlr.v4.runtime.dfa.DFA; @SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) public class JavaLexer extends Lexer { - static { - RuntimeMetaData.checkVersion("4.9.2", RuntimeMetaData.VERSION); - } - - protected static final DFA[] _decisionToDFA; - protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache(); public static final int ABSTRACT = 1, ASSERT = 2, BOOLEAN = 3, @@ -151,438 +126,11 @@ public class JavaLexer extends Lexer { BLOCK_COMMENT = 110, LINE_COMMENT = 111, IDENTIFIER = 112; - public static String[] channelNames = {"DEFAULT_TOKEN_CHANNEL", "HIDDEN"}; - - public static String[] modeNames = {"DEFAULT_MODE"}; - - private static String[] makeRuleNames() { - return new String[] { - "ABSTRACT", - "ASSERT", - "BOOLEAN", - "BREAK", - "BYTE", - "CASE", - "CATCH", - "CHAR", - "CLASS", - "CONST", - "CONTINUE", - "DEFAULT", - "DO", - "DOUBLE", - "ELSE", - "ENUM", - "EXTENDS", - "FINAL", - "FINALLY", - "FLOAT", - "FOR", - "IF", - "GOTO", - "IMPLEMENTS", - "IMPORT", - "INSTANCEOF", - "INT", - "INTERFACE", - "LONG", - "NATIVE", - "NEW", - "PACKAGE", - "PRIVATE", - "PROTECTED", - "PUBLIC", - "RETURN", - "SHORT", - "STATIC", - "STRICTFP", - "SUPER", - "SWITCH", - "SYNCHRONIZED", - "THIS", - "THROW", - "THROWS", - "TRANSIENT", - "TRY", - "VAR", - "VOID", - "VOLATILE", - "WHILE", - "DECIMAL_LITERAL", - "HEX_LITERAL", - "OCT_LITERAL", - "BINARY_LITERAL", - "FLOAT_LITERAL", - "HEX_FLOAT_LITERAL", - "BOOL_LITERAL", - "CHAR_LITERAL", - "STRING_LITERAL", - "NULL_LITERAL", - "LPAREN", - "RPAREN", - "LBRACE", - "RBRACE", - "LBRACK", - "RBRACK", - "SEMI", - "COMMA", - "DOT", - "ASSIGN", - "GT", - "LT", - "BANG", - "TILDE", - "QUESTION", - "COLON", - "EQUAL", - "LE", - "GE", - "NOTEQUAL", - "AND", - "OR", - "INC", - "DEC", - "ADD", - "SUB", - "MUL", - "DIV", - "BITAND", - "BITOR", - "CARET", - "MOD", - "ADD_ASSIGN", - "SUB_ASSIGN", - "MUL_ASSIGN", - "DIV_ASSIGN", - "AND_ASSIGN", - "OR_ASSIGN", - "XOR_ASSIGN", - "MOD_ASSIGN", - "LSHIFT_ASSIGN", - "RSHIFT_ASSIGN", - "URSHIFT_ASSIGN", - "ARROW", - "COLONCOLON", - "AT", - "ELLIPSIS", - "WS", - "BLOCK_COMMENT", - "LINE_COMMENT", - "IDENTIFIER", - "ExponentPart", - "EscapeSequence", - "HexDigits", - "HexDigit", - "Digits", - "LetterOrDigit", - "Letter" - }; - } - public static final String[] ruleNames = makeRuleNames(); - - private static String[] makeLiteralNames() { - return new String[] { - null, - "'abstract'", - "'assert'", - "'boolean'", - "'break'", - "'byte'", - "'case'", - "'catch'", - "'char'", - "'class'", - "'const'", - "'continue'", - "'default'", - "'do'", - "'double'", - "'else'", - "'enum'", - "'extends'", - "'final'", - "'finally'", - "'float'", - "'for'", - "'if'", - "'goto'", - "'implements'", - "'import'", - "'instanceof'", - "'int'", - "'interface'", - "'long'", - "'native'", - "'new'", - "'package'", - "'private'", - "'protected'", - "'public'", - "'return'", - "'short'", - "'static'", - "'strictfp'", - "'super'", - "'switch'", - "'synchronized'", - "'this'", - "'throw'", - "'throws'", - "'transient'", - "'try'", - "'var'", - "'void'", - "'volatile'", - "'while'", - null, - null, - null, - null, - null, - null, - null, - null, - null, - "'null'", - "'('", - "')'", - "'{'", - "'}'", - "'['", - "']'", - "';'", - "','", - "'.'", - "'='", - "'>'", - "'<'", - "'!'", - "'~'", - "'?'", - "':'", - "'=='", - "'<='", - "'>='", - "'!='", - "'&&'", - "'||'", - "'++'", - "'--'", - "'+'", - "'-'", - "'*'", - "'/'", - "'&'", - "'|'", - "'^'", - "'%'", - "'+='", - "'-='", - "'*='", - "'/='", - "'&='", - "'|='", - "'^='", - "'%='", - "'<<='", - "'>>='", - "'>>>='", - "'->'", - "'::'", - "'@'", - "'...'" - }; - } - - private static final String[] _LITERAL_NAMES = makeLiteralNames(); - - private static String[] makeSymbolicNames() { - return new String[] { - null, - "ABSTRACT", - "ASSERT", - "BOOLEAN", - "BREAK", - "BYTE", - "CASE", - "CATCH", - "CHAR", - "CLASS", - "CONST", - "CONTINUE", - "DEFAULT", - "DO", - "DOUBLE", - "ELSE", - "ENUM", - "EXTENDS", - "FINAL", - "FINALLY", - "FLOAT", - "FOR", - "IF", - "GOTO", - "IMPLEMENTS", - "IMPORT", - "INSTANCEOF", - "INT", - "INTERFACE", - "LONG", - "NATIVE", - "NEW", - "PACKAGE", - "PRIVATE", - "PROTECTED", - "PUBLIC", - "RETURN", - "SHORT", - "STATIC", - "STRICTFP", - "SUPER", - "SWITCH", - "SYNCHRONIZED", - "THIS", - "THROW", - "THROWS", - "TRANSIENT", - "TRY", - "VAR", - "VOID", - "VOLATILE", - "WHILE", - "DECIMAL_LITERAL", - "HEX_LITERAL", - "OCT_LITERAL", - "BINARY_LITERAL", - "FLOAT_LITERAL", - "HEX_FLOAT_LITERAL", - "BOOL_LITERAL", - "CHAR_LITERAL", - "STRING_LITERAL", - "NULL_LITERAL", - "LPAREN", - "RPAREN", - "LBRACE", - "RBRACE", - "LBRACK", - "RBRACK", - "SEMI", - "COMMA", - "DOT", - "ASSIGN", - "GT", - "LT", - "BANG", - "TILDE", - "QUESTION", - "COLON", - "EQUAL", - "LE", - "GE", - "NOTEQUAL", - "AND", - "OR", - "INC", - "DEC", - "ADD", - "SUB", - "MUL", - "DIV", - "BITAND", - "BITOR", - "CARET", - "MOD", - "ADD_ASSIGN", - "SUB_ASSIGN", - "MUL_ASSIGN", - "DIV_ASSIGN", - "AND_ASSIGN", - "OR_ASSIGN", - "XOR_ASSIGN", - "MOD_ASSIGN", - "LSHIFT_ASSIGN", - "RSHIFT_ASSIGN", - "URSHIFT_ASSIGN", - "ARROW", - "COLONCOLON", - "AT", - "ELLIPSIS", - "WS", - "BLOCK_COMMENT", - "LINE_COMMENT", - "IDENTIFIER" - }; - } - - 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 JavaLexer(CharStream input) { - super(input); - _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache); - } - - @Override - public String getGrammarFileName() { - return "JavaLexer.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\2r\u03b9\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" @@ -918,6 +466,31 @@ public class JavaLexer extends Lexer { + "\u0378\u037d\u0385\u0388\u038f\u0396\u039b\u039d\u03a1\u03a9\u03ad\u03b1" + "\u03b7\3\2\3\2"; public static final ATN _ATN = new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache(); + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + public static String[] channelNames = {"DEFAULT_TOKEN_CHANNEL", "HIDDEN"}; + public static String[] modeNames = {"DEFAULT_MODE"}; + + static { + RuntimeMetaData.checkVersion("4.9.3", RuntimeMetaData.VERSION); + } + + 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] = ""; + } + } + } static { _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; @@ -925,4 +498,406 @@ public class JavaLexer extends Lexer { _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); } } + + public JavaLexer(CharStream input) { + super(input); + _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache); + } + + private static String[] makeRuleNames() { + return new String[] { + "ABSTRACT", + "ASSERT", + "BOOLEAN", + "BREAK", + "BYTE", + "CASE", + "CATCH", + "CHAR", + "CLASS", + "CONST", + "CONTINUE", + "DEFAULT", + "DO", + "DOUBLE", + "ELSE", + "ENUM", + "EXTENDS", + "FINAL", + "FINALLY", + "FLOAT", + "FOR", + "IF", + "GOTO", + "IMPLEMENTS", + "IMPORT", + "INSTANCEOF", + "INT", + "INTERFACE", + "LONG", + "NATIVE", + "NEW", + "PACKAGE", + "PRIVATE", + "PROTECTED", + "PUBLIC", + "RETURN", + "SHORT", + "STATIC", + "STRICTFP", + "SUPER", + "SWITCH", + "SYNCHRONIZED", + "THIS", + "THROW", + "THROWS", + "TRANSIENT", + "TRY", + "VAR", + "VOID", + "VOLATILE", + "WHILE", + "DECIMAL_LITERAL", + "HEX_LITERAL", + "OCT_LITERAL", + "BINARY_LITERAL", + "FLOAT_LITERAL", + "HEX_FLOAT_LITERAL", + "BOOL_LITERAL", + "CHAR_LITERAL", + "STRING_LITERAL", + "NULL_LITERAL", + "LPAREN", + "RPAREN", + "LBRACE", + "RBRACE", + "LBRACK", + "RBRACK", + "SEMI", + "COMMA", + "DOT", + "ASSIGN", + "GT", + "LT", + "BANG", + "TILDE", + "QUESTION", + "COLON", + "EQUAL", + "LE", + "GE", + "NOTEQUAL", + "AND", + "OR", + "INC", + "DEC", + "ADD", + "SUB", + "MUL", + "DIV", + "BITAND", + "BITOR", + "CARET", + "MOD", + "ADD_ASSIGN", + "SUB_ASSIGN", + "MUL_ASSIGN", + "DIV_ASSIGN", + "AND_ASSIGN", + "OR_ASSIGN", + "XOR_ASSIGN", + "MOD_ASSIGN", + "LSHIFT_ASSIGN", + "RSHIFT_ASSIGN", + "URSHIFT_ASSIGN", + "ARROW", + "COLONCOLON", + "AT", + "ELLIPSIS", + "WS", + "BLOCK_COMMENT", + "LINE_COMMENT", + "IDENTIFIER", + "ExponentPart", + "EscapeSequence", + "HexDigits", + "HexDigit", + "Digits", + "LetterOrDigit", + "Letter" + }; + } + + private static String[] makeLiteralNames() { + return new String[] { + null, + "'abstract'", + "'assert'", + "'boolean'", + "'break'", + "'byte'", + "'case'", + "'catch'", + "'char'", + "'class'", + "'const'", + "'continue'", + "'default'", + "'do'", + "'double'", + "'else'", + "'enum'", + "'extends'", + "'final'", + "'finally'", + "'float'", + "'for'", + "'if'", + "'goto'", + "'implements'", + "'import'", + "'instanceof'", + "'int'", + "'interface'", + "'long'", + "'native'", + "'new'", + "'package'", + "'private'", + "'protected'", + "'public'", + "'return'", + "'short'", + "'static'", + "'strictfp'", + "'super'", + "'switch'", + "'synchronized'", + "'this'", + "'throw'", + "'throws'", + "'transient'", + "'try'", + "'var'", + "'void'", + "'volatile'", + "'while'", + null, + null, + null, + null, + null, + null, + null, + null, + null, + "'null'", + "'('", + "')'", + "'{'", + "'}'", + "'['", + "']'", + "';'", + "','", + "'.'", + "'='", + "'>'", + "'<'", + "'!'", + "'~'", + "'?'", + "':'", + "'=='", + "'<='", + "'>='", + "'!='", + "'&&'", + "'||'", + "'++'", + "'--'", + "'+'", + "'-'", + "'*'", + "'/'", + "'&'", + "'|'", + "'^'", + "'%'", + "'+='", + "'-='", + "'*='", + "'/='", + "'&='", + "'|='", + "'^='", + "'%='", + "'<<='", + "'>>='", + "'>>>='", + "'->'", + "'::'", + "'@'", + "'...'" + }; + } + + private static String[] makeSymbolicNames() { + return new String[] { + null, + "ABSTRACT", + "ASSERT", + "BOOLEAN", + "BREAK", + "BYTE", + "CASE", + "CATCH", + "CHAR", + "CLASS", + "CONST", + "CONTINUE", + "DEFAULT", + "DO", + "DOUBLE", + "ELSE", + "ENUM", + "EXTENDS", + "FINAL", + "FINALLY", + "FLOAT", + "FOR", + "IF", + "GOTO", + "IMPLEMENTS", + "IMPORT", + "INSTANCEOF", + "INT", + "INTERFACE", + "LONG", + "NATIVE", + "NEW", + "PACKAGE", + "PRIVATE", + "PROTECTED", + "PUBLIC", + "RETURN", + "SHORT", + "STATIC", + "STRICTFP", + "SUPER", + "SWITCH", + "SYNCHRONIZED", + "THIS", + "THROW", + "THROWS", + "TRANSIENT", + "TRY", + "VAR", + "VOID", + "VOLATILE", + "WHILE", + "DECIMAL_LITERAL", + "HEX_LITERAL", + "OCT_LITERAL", + "BINARY_LITERAL", + "FLOAT_LITERAL", + "HEX_FLOAT_LITERAL", + "BOOL_LITERAL", + "CHAR_LITERAL", + "STRING_LITERAL", + "NULL_LITERAL", + "LPAREN", + "RPAREN", + "LBRACE", + "RBRACE", + "LBRACK", + "RBRACK", + "SEMI", + "COMMA", + "DOT", + "ASSIGN", + "GT", + "LT", + "BANG", + "TILDE", + "QUESTION", + "COLON", + "EQUAL", + "LE", + "GE", + "NOTEQUAL", + "AND", + "OR", + "INC", + "DEC", + "ADD", + "SUB", + "MUL", + "DIV", + "BITAND", + "BITOR", + "CARET", + "MOD", + "ADD_ASSIGN", + "SUB_ASSIGN", + "MUL_ASSIGN", + "DIV_ASSIGN", + "AND_ASSIGN", + "OR_ASSIGN", + "XOR_ASSIGN", + "MOD_ASSIGN", + "LSHIFT_ASSIGN", + "RSHIFT_ASSIGN", + "URSHIFT_ASSIGN", + "ARROW", + "COLONCOLON", + "AT", + "ELLIPSIS", + "WS", + "BLOCK_COMMENT", + "LINE_COMMENT", + "IDENTIFIER" + }; + } + + @Override + public String[] getRuleNames() { + return ruleNames; + } + + @Override + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + @Override + public String getSerializedATN() { + return _serializedATN; + } + + @Override + public String getGrammarFileName() { + return "JavaLexer.g4"; + } + + @Override + public ATN getATN() { + return _ATN; + } + + @Override + public String[] getChannelNames() { + return channelNames; + } + + @Override + public String[] getModeNames() { + return modeNames; + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } } diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/java/JavaParser.java b/lexers/src/main/java/com/itsaky/androidide/lexers/java/JavaParser.java index 8887f8f3f..d844e0b2c 100755 --- a/lexers/src/main/java/com/itsaky/androidide/lexers/java/JavaParser.java +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/java/JavaParser.java @@ -1,23 +1,4 @@ -/************************************************************************************ - * 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 . - * - **************************************************************************************/ -// Generated from JavaParser.g4 by ANTLR 4.9.2 +// Generated from JavaParser.g4 by ANTLR 4.9.3 package com.itsaky.androidide.lexers.java; import org.antlr.v4.runtime.FailedPredicateException; @@ -44,12 +25,6 @@ import java.util.List; @SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) public class JavaParser extends Parser { - static { - RuntimeMetaData.checkVersion("4.9.2", RuntimeMetaData.VERSION); - } - - protected static final DFA[] _decisionToDFA; - protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache(); public static final int ABSTRACT = 1, ASSERT = 2, BOOLEAN = 3, @@ -267,6 +242,613 @@ public class JavaParser extends Parser { RULE_superSuffix = 102, RULE_explicitGenericInvocationSuffix = 103, RULE_arguments = 104; + public static final String[] ruleNames = makeRuleNames(); + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated public static final String[] tokenNames; + public static final String _serializedATN = + "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3r\u059f\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\3\2\5" + + "\2\u00d6\n\2\3\2\7\2\u00d9\n\2\f\2\16\2\u00dc\13\2\3\2\7\2\u00df\n\2\f" + + "\2\16\2\u00e2\13\2\3\2\3\2\3\3\7\3\u00e7\n\3\f\3\16\3\u00ea\13\3\3\3\3" + + "\3\3\3\3\3\3\4\3\4\5\4\u00f2\n\4\3\4\3\4\3\4\5\4\u00f7\n\4\3\4\3\4\3\5" + + "\7\5\u00fc\n\5\f\5\16\5\u00ff\13\5\3\5\3\5\3\5\3\5\5\5\u0105\n\5\3\5\5" + + "\5\u0108\n\5\3\6\3\6\3\6\3\6\3\6\5\6\u010f\n\6\3\7\3\7\3\7\3\7\3\7\3\7" + + "\3\7\3\7\5\7\u0119\n\7\3\b\3\b\5\b\u011d\n\b\3\t\3\t\3\t\5\t\u0122\n\t" + + "\3\t\3\t\5\t\u0126\n\t\3\t\3\t\5\t\u012a\n\t\3\t\3\t\3\n\3\n\3\n\3\n\7" + + "\n\u0132\n\n\f\n\16\n\u0135\13\n\3\n\3\n\3\13\7\13\u013a\n\13\f\13\16" + + "\13\u013d\13\13\3\13\3\13\3\13\7\13\u0142\n\13\f\13\16\13\u0145\13\13" + + "\3\13\5\13\u0148\n\13\3\f\3\f\3\f\7\f\u014d\n\f\f\f\16\f\u0150\13\f\3" + + "\r\3\r\3\r\3\r\5\r\u0156\n\r\3\r\3\r\5\r\u015a\n\r\3\r\5\r\u015d\n\r\3" + + "\r\5\r\u0160\n\r\3\r\3\r\3\16\3\16\3\16\7\16\u0167\n\16\f\16\16\16\u016a" + + "\13\16\3\17\7\17\u016d\n\17\f\17\16\17\u0170\13\17\3\17\3\17\5\17\u0174" + + "\n\17\3\17\5\17\u0177\n\17\3\20\3\20\7\20\u017b\n\20\f\20\16\20\u017e" + + "\13\20\3\21\3\21\3\21\5\21\u0183\n\21\3\21\3\21\5\21\u0187\n\21\3\21\3" + + "\21\3\22\3\22\7\22\u018d\n\22\f\22\16\22\u0190\13\22\3\22\3\22\3\23\3" + + "\23\7\23\u0196\n\23\f\23\16\23\u0199\13\23\3\23\3\23\3\24\3\24\5\24\u019f" + + "\n\24\3\24\3\24\7\24\u01a3\n\24\f\24\16\24\u01a6\13\24\3\24\5\24\u01a9" + + "\n\24\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\5\25\u01b4\n\25\3\26" + + "\3\26\3\26\3\26\3\26\7\26\u01bb\n\26\f\26\16\26\u01be\13\26\3\26\3\26" + + "\5\26\u01c2\n\26\3\26\3\26\3\27\3\27\5\27\u01c8\n\27\3\30\3\30\5\30\u01cc" + + "\n\30\3\31\3\31\3\31\3\32\3\32\3\32\3\33\3\33\3\33\3\33\5\33\u01d8\n\33" + + "\3\33\3\33\3\34\3\34\3\34\3\34\3\35\7\35\u01e1\n\35\f\35\16\35\u01e4\13" + + "\35\3\35\3\35\5\35\u01e8\n\35\3\36\3\36\3\36\3\36\3\36\3\36\3\36\5\36" + + "\u01f1\n\36\3\37\3\37\3\37\3\37\7\37\u01f7\n\37\f\37\16\37\u01fa\13\37" + + "\3\37\3\37\3 \3 \3 \7 \u0201\n \f \16 \u0204\13 \3 \3 \3 \3!\7!\u020a" + + "\n!\f!\16!\u020d\13!\3!\3!\3!\7!\u0212\n!\f!\16!\u0215\13!\3!\3!\5!\u0219" + + "\n!\3!\3!\3!\3!\7!\u021f\n!\f!\16!\u0222\13!\3!\3!\5!\u0226\n!\3!\3!\3" + + "\"\3\"\3\"\3\"\3\"\3\"\5\"\u0230\n\"\3#\3#\3#\3$\3$\3$\7$\u0238\n$\f$" + + "\16$\u023b\13$\3%\3%\3%\5%\u0240\n%\3&\3&\3&\7&\u0245\n&\f&\16&\u0248" + + "\13&\3\'\3\'\5\'\u024c\n\'\3(\3(\3(\3(\7(\u0252\n(\f(\16(\u0255\13(\3" + + "(\5(\u0258\n(\5(\u025a\n(\3(\3(\3)\3)\5)\u0260\n)\3)\3)\3)\5)\u0265\n" + + ")\7)\u0267\n)\f)\16)\u026a\13)\3*\3*\7*\u026e\n*\f*\16*\u0271\13*\3*\3" + + "*\3*\5*\u0276\n*\5*\u0278\n*\3+\3+\3+\7+\u027d\n+\f+\16+\u0280\13+\3," + + "\3,\5,\u0284\n,\3,\3,\3-\3-\3-\7-\u028b\n-\f-\16-\u028e\13-\3-\3-\5-\u0292" + + "\n-\3-\5-\u0295\n-\3.\7.\u0298\n.\f.\16.\u029b\13.\3.\3.\3.\3/\7/\u02a1" + + "\n/\f/\16/\u02a4\13/\3/\3/\7/\u02a8\n/\f/\16/\u02ab\13/\3/\3/\3/\3\60" + + "\3\60\3\60\7\60\u02b3\n\60\f\60\16\60\u02b6\13\60\3\61\3\61\3\61\3\61" + + "\3\61\3\61\5\61\u02be\n\61\3\62\3\62\3\63\3\63\3\64\3\64\7\64\u02c6\n" + + "\64\f\64\16\64\u02c9\13\64\3\64\3\64\3\64\3\65\3\65\3\65\5\65\u02d1\n" + + "\65\3\65\3\65\3\65\5\65\u02d6\n\65\3\65\5\65\u02d9\n\65\3\66\3\66\3\66" + + "\7\66\u02de\n\66\f\66\16\66\u02e1\13\66\3\67\3\67\3\67\3\67\38\38\38\5" + + "8\u02ea\n8\39\39\39\39\79\u02f0\n9\f9\169\u02f3\139\59\u02f5\n9\39\59" + + "\u02f8\n9\39\39\3:\3:\3:\3:\3:\3;\3;\7;\u0303\n;\f;\16;\u0306\13;\3;\3" + + ";\3<\7<\u030b\n<\f<\16<\u030e\13<\3<\3<\5<\u0312\n<\3=\3=\3=\3=\3=\3=" + + "\5=\u031a\n=\3=\3=\5=\u031e\n=\3=\3=\5=\u0322\n=\3=\3=\5=\u0326\n=\5=" + + "\u0328\n=\3>\3>\5>\u032c\n>\3?\3?\3?\3?\5?\u0332\n?\3@\3@\3A\3A\3A\3B" + + "\3B\7B\u033b\nB\fB\16B\u033e\13B\3B\3B\3C\3C\3C\3C\3C\5C\u0347\nC\3D\7" + + "D\u034a\nD\fD\16D\u034d\13D\3D\3D\3D\3E\7E\u0353\nE\fE\16E\u0356\13E\3" + + "E\3E\5E\u035a\nE\3E\5E\u035d\nE\3F\3F\3F\3F\3F\5F\u0364\nF\3F\3F\3F\3" + + "F\3F\3F\3F\5F\u036d\nF\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3" + + "F\3F\3F\3F\6F\u0382\nF\rF\16F\u0383\3F\5F\u0387\nF\3F\5F\u038a\nF\3F\3" + + "F\3F\3F\7F\u0390\nF\fF\16F\u0393\13F\3F\5F\u0396\nF\3F\3F\3F\3F\7F\u039c" + + "\nF\fF\16F\u039f\13F\3F\7F\u03a2\nF\fF\16F\u03a5\13F\3F\3F\3F\3F\3F\3" + + "F\3F\3F\5F\u03af\nF\3F\3F\3F\3F\3F\3F\3F\5F\u03b8\nF\3F\3F\3F\5F\u03bd" + + "\nF\3F\3F\3F\3F\3F\3F\3F\3F\5F\u03c7\nF\3G\3G\3G\7G\u03cc\nG\fG\16G\u03cf" + + "\13G\3G\3G\3G\3G\3G\3H\3H\3H\7H\u03d9\nH\fH\16H\u03dc\13H\3I\3I\3I\3J" + + "\3J\3J\5J\u03e4\nJ\3J\3J\3K\3K\3K\7K\u03eb\nK\fK\16K\u03ee\13K\3L\7L\u03f1" + + "\nL\fL\16L\u03f4\13L\3L\3L\3L\3L\3L\3M\6M\u03fc\nM\rM\16M\u03fd\3M\6M" + + "\u0401\nM\rM\16M\u0402\3N\3N\3N\5N\u0408\nN\3N\3N\3N\5N\u040d\nN\3O\3" + + "O\5O\u0411\nO\3O\3O\5O\u0415\nO\3O\3O\5O\u0419\nO\5O\u041b\nO\3P\3P\5" + + "P\u041f\nP\3Q\7Q\u0422\nQ\fQ\16Q\u0425\13Q\3Q\3Q\3Q\3Q\3Q\3R\3R\3R\3R" + + "\3S\3S\3S\7S\u0433\nS\fS\16S\u0436\13S\3T\3T\3T\5T\u043b\nT\3T\3T\3T\3" + + "T\5T\u0441\nT\3T\3T\3T\3T\5T\u0447\nT\3T\5T\u044a\nT\3U\3U\3U\3U\3U\3" + + "U\3U\7U\u0453\nU\fU\16U\u0456\13U\3U\3U\3U\7U\u045b\nU\fU\16U\u045e\13" + + "U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\5U\u046b\nU\3U\3U\5U\u046f\nU\3U\3" + + "U\3U\5U\u0474\nU\3U\3U\5U\u0478\nU\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3" + + "U\3U\3U\5U\u0488\nU\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3" + + "U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\5U\u04b0" + + "\nU\3U\3U\3U\3U\5U\u04b6\nU\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\5U" + + "\u04c5\nU\3U\7U\u04c8\nU\fU\16U\u04cb\13U\3V\3V\3V\3V\3W\3W\3W\5W\u04d4" + + "\nW\3W\3W\3W\3W\3W\7W\u04db\nW\fW\16W\u04de\13W\3W\5W\u04e1\nW\3X\3X\5" + + "X\u04e5\nX\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\5Y\u04f7\n" + + "Y\5Y\u04f9\nY\3Z\3Z\3Z\5Z\u04fe\nZ\3Z\7Z\u0501\nZ\fZ\16Z\u0504\13Z\3Z" + + "\3Z\5Z\u0508\nZ\3[\3[\3[\3[\3[\3[\3[\5[\u0511\n[\5[\u0513\n[\3\\\3\\\5" + + "\\\u0517\n\\\3\\\3\\\3\\\5\\\u051c\n\\\7\\\u051e\n\\\f\\\16\\\u0521\13" + + "\\\3\\\5\\\u0524\n\\\3]\3]\5]\u0528\n]\3]\3]\3^\3^\3^\3^\7^\u0530\n^\f" + + "^\16^\u0533\13^\3^\3^\3^\3^\3^\3^\3^\7^\u053c\n^\f^\16^\u053f\13^\3^\3" + + "^\7^\u0543\n^\f^\16^\u0546\13^\5^\u0548\n^\3_\3_\5_\u054c\n_\3`\3`\3`" + + "\3a\3a\3a\5a\u0554\na\3b\3b\3b\5b\u0559\nb\3c\3c\3c\3c\3d\3d\3d\7d\u0562" + + "\nd\fd\16d\u0565\13d\3e\7e\u0568\ne\fe\16e\u056b\13e\3e\3e\5e\u056f\n" + + "e\3e\7e\u0572\ne\fe\16e\u0575\13e\3e\3e\7e\u0579\ne\fe\16e\u057c\13e\3" + + "f\3f\3g\3g\3g\3g\7g\u0584\ng\fg\16g\u0587\13g\3g\3g\3h\3h\3h\3h\5h\u058f" + + "\nh\5h\u0591\nh\3i\3i\3i\3i\5i\u0597\ni\3j\3j\5j\u059b\nj\3j\3j\3j\2\3" + + "\u00a8k\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:" + + "<>@BDFHJLNPRTVXZ\\^`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" + + "\2\16\4\2\23\23**\3\2\669\3\2:;\3\2VY\3\2LM\4\2Z[__\3\2XY\4\2JKQR\4\2" + + "PPSS\4\2II`j\3\2VW\n\2\5\5\7\7\n\n\20\20\26\26\35\35\37\37\'\'\2\u063f" + + "\2\u00d5\3\2\2\2\4\u00e8\3\2\2\2\6\u00ef\3\2\2\2\b\u0107\3\2\2\2\n\u010e" + + "\3\2\2\2\f\u0118\3\2\2\2\16\u011c\3\2\2\2\20\u011e\3\2\2\2\22\u012d\3" + + "\2\2\2\24\u013b\3\2\2\2\26\u0149\3\2\2\2\30\u0151\3\2\2\2\32\u0163\3\2" + + "\2\2\34\u016e\3\2\2\2\36\u0178\3\2\2\2 \u017f\3\2\2\2\"\u018a\3\2\2\2" + + "$\u0193\3\2\2\2&\u01a8\3\2\2\2(\u01b3\3\2\2\2*\u01b5\3\2\2\2,\u01c7\3" + + "\2\2\2.\u01cb\3\2\2\2\60\u01cd\3\2\2\2\62\u01d0\3\2\2\2\64\u01d3\3\2\2" + + "\2\66\u01db\3\2\2\28\u01e7\3\2\2\2:\u01f0\3\2\2\2<\u01f2\3\2\2\2>\u01fd" + + "\3\2\2\2@\u020b\3\2\2\2B\u022f\3\2\2\2D\u0231\3\2\2\2F\u0234\3\2\2\2H" + + "\u023c\3\2\2\2J\u0241\3\2\2\2L\u024b\3\2\2\2N\u024d\3\2\2\2P\u025d\3\2" + + "\2\2R\u0277\3\2\2\2T\u0279\3\2\2\2V\u0281\3\2\2\2X\u0294\3\2\2\2Z\u0299" + + "\3\2\2\2\\\u02a2\3\2\2\2^\u02af\3\2\2\2`\u02bd\3\2\2\2b\u02bf\3\2\2\2" + + "d\u02c1\3\2\2\2f\u02c7\3\2\2\2h\u02d0\3\2\2\2j\u02da\3\2\2\2l\u02e2\3" + + "\2\2\2n\u02e9\3\2\2\2p\u02eb\3\2\2\2r\u02fb\3\2\2\2t\u0300\3\2\2\2v\u0311" + + "\3\2\2\2x\u0327\3\2\2\2z\u032b\3\2\2\2|\u032d\3\2\2\2~\u0333\3\2\2\2\u0080" + + "\u0335\3\2\2\2\u0082\u0338\3\2\2\2\u0084\u0346\3\2\2\2\u0086\u034b\3\2" + + "\2\2\u0088\u035c\3\2\2\2\u008a\u03c6\3\2\2\2\u008c\u03c8\3\2\2\2\u008e" + + "\u03d5\3\2\2\2\u0090\u03dd\3\2\2\2\u0092\u03e0\3\2\2\2\u0094\u03e7\3\2" + + "\2\2\u0096\u03f2\3\2\2\2\u0098\u03fb\3\2\2\2\u009a\u040c\3\2\2\2\u009c" + + "\u041a\3\2\2\2\u009e\u041e\3\2\2\2\u00a0\u0423\3\2\2\2\u00a2\u042b\3\2" + + "\2\2\u00a4\u042f\3\2\2\2\u00a6\u0449\3\2\2\2\u00a8\u0477\3\2\2\2\u00aa" + + "\u04cc\3\2\2\2\u00ac\u04e0\3\2\2\2\u00ae\u04e4\3\2\2\2\u00b0\u04f8\3\2" + + "\2\2\u00b2\u04fd\3\2\2\2\u00b4\u0512\3\2\2\2\u00b6\u0523\3\2\2\2\u00b8" + + "\u0525\3\2\2\2\u00ba\u052b\3\2\2\2\u00bc\u0549\3\2\2\2\u00be\u054d\3\2" + + "\2\2\u00c0\u0553\3\2\2\2\u00c2\u0558\3\2\2\2\u00c4\u055a\3\2\2\2\u00c6" + + "\u055e\3\2\2\2\u00c8\u0569\3\2\2\2\u00ca\u057d\3\2\2\2\u00cc\u057f\3\2" + + "\2\2\u00ce\u0590\3\2\2\2\u00d0\u0596\3\2\2\2\u00d2\u0598\3\2\2\2\u00d4" + + "\u00d6\5\4\3\2\u00d5\u00d4\3\2\2\2\u00d5\u00d6\3\2\2\2\u00d6\u00da\3\2" + + "\2\2\u00d7\u00d9\5\6\4\2\u00d8\u00d7\3\2\2\2\u00d9\u00dc\3\2\2\2\u00da" + + "\u00d8\3\2\2\2\u00da\u00db\3\2\2\2\u00db\u00e0\3\2\2\2\u00dc\u00da\3\2" + + "\2\2\u00dd\u00df\5\b\5\2\u00de\u00dd\3\2\2\2\u00df\u00e2\3\2\2\2\u00e0" + + "\u00de\3\2\2\2\u00e0\u00e1\3\2\2\2\u00e1\u00e3\3\2\2\2\u00e2\u00e0\3\2" + + "\2\2\u00e3\u00e4\7\2\2\3\u00e4\3\3\2\2\2\u00e5\u00e7\5h\65\2\u00e6\u00e5" + + "\3\2\2\2\u00e7\u00ea\3\2\2\2\u00e8\u00e6\3\2\2\2\u00e8\u00e9\3\2\2\2\u00e9" + + "\u00eb\3\2\2\2\u00ea\u00e8\3\2\2\2\u00eb\u00ec\7\"\2\2\u00ec\u00ed\5^" + + "\60\2\u00ed\u00ee\7F\2\2\u00ee\5\3\2\2\2\u00ef\u00f1\7\33\2\2\u00f0\u00f2" + + "\7(\2\2\u00f1\u00f0\3\2\2\2\u00f1\u00f2\3\2\2\2\u00f2\u00f3\3\2\2\2\u00f3" + + "\u00f6\5^\60\2\u00f4\u00f5\7H\2\2\u00f5\u00f7\7Z\2\2\u00f6\u00f4\3\2\2" + + "\2\u00f6\u00f7\3\2\2\2\u00f7\u00f8\3\2\2\2\u00f8\u00f9\7F\2\2\u00f9\7" + + "\3\2\2\2\u00fa\u00fc\5\f\7\2\u00fb\u00fa\3\2\2\2\u00fc\u00ff\3\2\2\2\u00fd" + + "\u00fb\3\2\2\2\u00fd\u00fe\3\2\2\2\u00fe\u0104\3\2\2\2\u00ff\u00fd\3\2" + + "\2\2\u0100\u0105\5\20\t\2\u0101\u0105\5\30\r\2\u0102\u0105\5 \21\2\u0103" + + "\u0105\5r:\2\u0104\u0100\3\2\2\2\u0104\u0101\3\2\2\2\u0104\u0102\3\2\2" + + "\2\u0104\u0103\3\2\2\2\u0105\u0108\3\2\2\2\u0106\u0108\7F\2\2\u0107\u00fd" + + "\3\2\2\2\u0107\u0106\3\2\2\2\u0108\t\3\2\2\2\u0109\u010f\5\f\7\2\u010a" + + "\u010f\7 \2\2\u010b\u010f\7,\2\2\u010c\u010f\7\60\2\2\u010d\u010f\7\64" + + "\2\2\u010e\u0109\3\2\2\2\u010e\u010a\3\2\2\2\u010e\u010b\3\2\2\2\u010e" + + "\u010c\3\2\2\2\u010e\u010d\3\2\2\2\u010f\13\3\2\2\2\u0110\u0119\5h\65" + + "\2\u0111\u0119\7%\2\2\u0112\u0119\7$\2\2\u0113\u0119\7#\2\2\u0114\u0119" + + "\7(\2\2\u0115\u0119\7\3\2\2\u0116\u0119\7\24\2\2\u0117\u0119\7)\2\2\u0118" + + "\u0110\3\2\2\2\u0118\u0111\3\2\2\2\u0118\u0112\3\2\2\2\u0118\u0113\3\2" + + "\2\2\u0118\u0114\3\2\2\2\u0118\u0115\3\2\2\2\u0118\u0116\3\2\2\2\u0118" + + "\u0117\3\2\2\2\u0119\r\3\2\2\2\u011a\u011d\7\24\2\2\u011b\u011d\5h\65" + + "\2\u011c\u011a\3\2\2\2\u011c\u011b\3\2\2\2\u011d\17\3\2\2\2\u011e\u011f" + + "\7\13\2\2\u011f\u0121\7r\2\2\u0120\u0122\5\22\n\2\u0121\u0120\3\2\2\2" + + "\u0121\u0122\3\2\2\2\u0122\u0125\3\2\2\2\u0123\u0124\7\23\2\2\u0124\u0126" + + "\5\u00c8e\2\u0125\u0123\3\2\2\2\u0125\u0126\3\2\2\2\u0126\u0129\3\2\2" + + "\2\u0127\u0128\7\32\2\2\u0128\u012a\5\u00c6d\2\u0129\u0127\3\2\2\2\u0129" + + "\u012a\3\2\2\2\u012a\u012b\3\2\2\2\u012b\u012c\5\"\22\2\u012c\21\3\2\2" + + "\2\u012d\u012e\7K\2\2\u012e\u0133\5\24\13\2\u012f\u0130\7G\2\2\u0130\u0132" + + "\5\24\13\2\u0131\u012f\3\2\2\2\u0132\u0135\3\2\2\2\u0133\u0131\3\2\2\2" + + "\u0133\u0134\3\2\2\2\u0134\u0136\3\2\2\2\u0135\u0133\3\2\2\2\u0136\u0137" + + "\7J\2\2\u0137\23\3\2\2\2\u0138\u013a\5h\65\2\u0139\u0138\3\2\2\2\u013a" + + "\u013d\3\2\2\2\u013b\u0139\3\2\2\2\u013b\u013c\3\2\2\2\u013c\u013e\3\2" + + "\2\2\u013d\u013b\3\2\2\2\u013e\u0147\7r\2\2\u013f\u0143\7\23\2\2\u0140" + + "\u0142\5h\65\2\u0141\u0140\3\2\2\2\u0142\u0145\3\2\2\2\u0143\u0141\3\2" + + "\2\2\u0143\u0144\3\2\2\2\u0144\u0146\3\2\2\2\u0145\u0143\3\2\2\2\u0146" + + "\u0148\5\26\f\2\u0147\u013f\3\2\2\2\u0147\u0148\3\2\2\2\u0148\25\3\2\2" + + "\2\u0149\u014e\5\u00c8e\2\u014a\u014b\7\\\2\2\u014b\u014d\5\u00c8e\2\u014c" + + "\u014a\3\2\2\2\u014d\u0150\3\2\2\2\u014e\u014c\3\2\2\2\u014e\u014f\3\2" + + "\2\2\u014f\27\3\2\2\2\u0150\u014e\3\2\2\2\u0151\u0152\7\22\2\2\u0152\u0155" + + "\7r\2\2\u0153\u0154\7\32\2\2\u0154\u0156\5\u00c6d\2\u0155\u0153\3\2\2" + + "\2\u0155\u0156\3\2\2\2\u0156\u0157\3\2\2\2\u0157\u0159\7B\2\2\u0158\u015a" + + "\5\32\16\2\u0159\u0158\3\2\2\2\u0159\u015a\3\2\2\2\u015a\u015c\3\2\2\2" + + "\u015b\u015d\7G\2\2\u015c\u015b\3\2\2\2\u015c\u015d\3\2\2\2\u015d\u015f" + + "\3\2\2\2\u015e\u0160\5\36\20\2\u015f\u015e\3\2\2\2\u015f\u0160\3\2\2\2" + + "\u0160\u0161\3\2\2\2\u0161\u0162\7C\2\2\u0162\31\3\2\2\2\u0163\u0168\5" + + "\34\17\2\u0164\u0165\7G\2\2\u0165\u0167\5\34\17\2\u0166\u0164\3\2\2\2" + + "\u0167\u016a\3\2\2\2\u0168\u0166\3\2\2\2\u0168\u0169\3\2\2\2\u0169\33" + + "\3\2\2\2\u016a\u0168\3\2\2\2\u016b\u016d\5h\65\2\u016c\u016b\3\2\2\2\u016d" + + "\u0170\3\2\2\2\u016e\u016c\3\2\2\2\u016e\u016f\3\2\2\2\u016f\u0171\3\2" + + "\2\2\u0170\u016e\3\2\2\2\u0171\u0173\7r\2\2\u0172\u0174\5\u00d2j\2\u0173" + + "\u0172\3\2\2\2\u0173\u0174\3\2\2\2\u0174\u0176\3\2\2\2\u0175\u0177\5\"" + + "\22\2\u0176\u0175\3\2\2\2\u0176\u0177\3\2\2\2\u0177\35\3\2\2\2\u0178\u017c" + + "\7F\2\2\u0179\u017b\5&\24\2\u017a\u0179\3\2\2\2\u017b\u017e\3\2\2\2\u017c" + + "\u017a\3\2\2\2\u017c\u017d\3\2\2\2\u017d\37\3\2\2\2\u017e\u017c\3\2\2" + + "\2\u017f\u0180\7\36\2\2\u0180\u0182\7r\2\2\u0181\u0183\5\22\n\2\u0182" + + "\u0181\3\2\2\2\u0182\u0183\3\2\2\2\u0183\u0186\3\2\2\2\u0184\u0185\7\23" + + "\2\2\u0185\u0187\5\u00c6d\2\u0186\u0184\3\2\2\2\u0186\u0187\3\2\2\2\u0187" + + "\u0188\3\2\2\2\u0188\u0189\5$\23\2\u0189!\3\2\2\2\u018a\u018e\7B\2\2\u018b" + + "\u018d\5&\24\2\u018c\u018b\3\2\2\2\u018d\u0190\3\2\2\2\u018e\u018c\3\2" + + "\2\2\u018e\u018f\3\2\2\2\u018f\u0191\3\2\2\2\u0190\u018e\3\2\2\2\u0191" + + "\u0192\7C\2\2\u0192#\3\2\2\2\u0193\u0197\7B\2\2\u0194\u0196\58\35\2\u0195" + + "\u0194\3\2\2\2\u0196\u0199\3\2\2\2\u0197\u0195\3\2\2\2\u0197\u0198\3\2" + + "\2\2\u0198\u019a\3\2\2\2\u0199\u0197\3\2\2\2\u019a\u019b\7C\2\2\u019b" + + "%\3\2\2\2\u019c\u01a9\7F\2\2\u019d\u019f\7(\2\2\u019e\u019d\3\2\2\2\u019e" + + "\u019f\3\2\2\2\u019f\u01a0\3\2\2\2\u01a0\u01a9\5\u0082B\2\u01a1\u01a3" + + "\5\n\6\2\u01a2\u01a1\3\2\2\2\u01a3\u01a6\3\2\2\2\u01a4\u01a2\3\2\2\2\u01a4" + + "\u01a5\3\2\2\2\u01a5\u01a7\3\2\2\2\u01a6\u01a4\3\2\2\2\u01a7\u01a9\5(" + + "\25\2\u01a8\u019c\3\2\2\2\u01a8\u019e\3\2\2\2\u01a8\u01a4\3\2\2\2\u01a9" + + "\'\3\2\2\2\u01aa\u01b4\5*\26\2\u01ab\u01b4\5\60\31\2\u01ac\u01b4\5\66" + + "\34\2\u01ad\u01b4\5\64\33\2\u01ae\u01b4\5\62\32\2\u01af\u01b4\5 \21\2" + + "\u01b0\u01b4\5r:\2\u01b1\u01b4\5\20\t\2\u01b2\u01b4\5\30\r\2\u01b3\u01aa" + + "\3\2\2\2\u01b3\u01ab\3\2\2\2\u01b3\u01ac\3\2\2\2\u01b3\u01ad\3\2\2\2\u01b3" + + "\u01ae\3\2\2\2\u01b3\u01af\3\2\2\2\u01b3\u01b0\3\2\2\2\u01b3\u01b1\3\2" + + "\2\2\u01b3\u01b2\3\2\2\2\u01b4)\3\2\2\2\u01b5\u01b6\5.\30\2\u01b6\u01b7" + + "\7r\2\2\u01b7\u01bc\5V,\2\u01b8\u01b9\7D\2\2\u01b9\u01bb\7E\2\2\u01ba" + + "\u01b8\3\2\2\2\u01bb\u01be\3\2\2\2\u01bc\u01ba\3\2\2\2\u01bc\u01bd\3\2" + + "\2\2\u01bd\u01c1\3\2\2\2\u01be\u01bc\3\2\2\2\u01bf\u01c0\7/\2\2\u01c0" + + "\u01c2\5T+\2\u01c1\u01bf\3\2\2\2\u01c1\u01c2\3\2\2\2\u01c2\u01c3\3\2\2" + + "\2\u01c3\u01c4\5,\27\2\u01c4+\3\2\2\2\u01c5\u01c8\5\u0082B\2\u01c6\u01c8" + + "\7F\2\2\u01c7\u01c5\3\2\2\2\u01c7\u01c6\3\2\2\2\u01c8-\3\2\2\2\u01c9\u01cc" + + "\5\u00c8e\2\u01ca\u01cc\7\63\2\2\u01cb\u01c9\3\2\2\2\u01cb\u01ca\3\2\2" + + "\2\u01cc/\3\2\2\2\u01cd\u01ce\5\22\n\2\u01ce\u01cf\5*\26\2\u01cf\61\3" + + "\2\2\2\u01d0\u01d1\5\22\n\2\u01d1\u01d2\5\64\33\2\u01d2\63\3\2\2\2\u01d3" + + "\u01d4\7r\2\2\u01d4\u01d7\5V,\2\u01d5\u01d6\7/\2\2\u01d6\u01d8\5T+\2\u01d7" + + "\u01d5\3\2\2\2\u01d7\u01d8\3\2\2\2\u01d8\u01d9\3\2\2\2\u01d9\u01da\5\u0082" + + "B\2\u01da\65\3\2\2\2\u01db\u01dc\5\u00c8e\2\u01dc\u01dd\5F$\2\u01dd\u01de" + + "\7F\2\2\u01de\67\3\2\2\2\u01df\u01e1\5\n\6\2\u01e0\u01df\3\2\2\2\u01e1" + + "\u01e4\3\2\2\2\u01e2\u01e0\3\2\2\2\u01e2\u01e3\3\2\2\2\u01e3\u01e5\3\2" + + "\2\2\u01e4\u01e2\3\2\2\2\u01e5\u01e8\5:\36\2\u01e6\u01e8\7F\2\2\u01e7" + + "\u01e2\3\2\2\2\u01e7\u01e6\3\2\2\2\u01e89\3\2\2\2\u01e9\u01f1\5<\37\2" + + "\u01ea\u01f1\5@!\2\u01eb\u01f1\5D#\2\u01ec\u01f1\5 \21\2\u01ed\u01f1\5" + + "r:\2\u01ee\u01f1\5\20\t\2\u01ef\u01f1\5\30\r\2\u01f0\u01e9\3\2\2\2\u01f0" + + "\u01ea\3\2\2\2\u01f0\u01eb\3\2\2\2\u01f0\u01ec\3\2\2\2\u01f0\u01ed\3\2" + + "\2\2\u01f0\u01ee\3\2\2\2\u01f0\u01ef\3\2\2\2\u01f1;\3\2\2\2\u01f2\u01f3" + + "\5\u00c8e\2\u01f3\u01f8\5> \2\u01f4\u01f5\7G\2\2\u01f5\u01f7\5> \2\u01f6" + + "\u01f4\3\2\2\2\u01f7\u01fa\3\2\2\2\u01f8\u01f6\3\2\2\2\u01f8\u01f9\3\2" + + "\2\2\u01f9\u01fb\3\2\2\2\u01fa\u01f8\3\2\2\2\u01fb\u01fc\7F\2\2\u01fc" + + "=\3\2\2\2\u01fd\u0202\7r\2\2\u01fe\u01ff\7D\2\2\u01ff\u0201\7E\2\2\u0200" + + "\u01fe\3\2\2\2\u0201\u0204\3\2\2\2\u0202\u0200\3\2\2\2\u0202\u0203\3\2" + + "\2\2\u0203\u0205\3\2\2\2\u0204\u0202\3\2\2\2\u0205\u0206\7I\2\2\u0206" + + "\u0207\5L\'\2\u0207?\3\2\2\2\u0208\u020a\5B\"\2\u0209\u0208\3\2\2\2\u020a" + + "\u020d\3\2\2\2\u020b\u0209\3\2\2\2\u020b\u020c\3\2\2\2\u020c\u0218\3\2" + + "\2\2\u020d\u020b\3\2\2\2\u020e\u0219\5.\30\2\u020f\u0213\5\22\n\2\u0210" + + "\u0212\5h\65\2\u0211\u0210\3\2\2\2\u0212\u0215\3\2\2\2\u0213\u0211\3\2" + + "\2\2\u0213\u0214\3\2\2\2\u0214\u0216\3\2\2\2\u0215\u0213\3\2\2\2\u0216" + + "\u0217\5.\30\2\u0217\u0219\3\2\2\2\u0218\u020e\3\2\2\2\u0218\u020f\3\2" + + "\2\2\u0219\u021a\3\2\2\2\u021a\u021b\7r\2\2\u021b\u0220\5V,\2\u021c\u021d" + + "\7D\2\2\u021d\u021f\7E\2\2\u021e\u021c\3\2\2\2\u021f\u0222\3\2\2\2\u0220" + + "\u021e\3\2\2\2\u0220\u0221\3\2\2\2\u0221\u0225\3\2\2\2\u0222\u0220\3\2" + + "\2\2\u0223\u0224\7/\2\2\u0224\u0226\5T+\2\u0225\u0223\3\2\2\2\u0225\u0226" + + "\3\2\2\2\u0226\u0227\3\2\2\2\u0227\u0228\5,\27\2\u0228A\3\2\2\2\u0229" + + "\u0230\5h\65\2\u022a\u0230\7%\2\2\u022b\u0230\7\3\2\2\u022c\u0230\7\16" + + "\2\2\u022d\u0230\7(\2\2\u022e\u0230\7)\2\2\u022f\u0229\3\2\2\2\u022f\u022a" + + "\3\2\2\2\u022f\u022b\3\2\2\2\u022f\u022c\3\2\2\2\u022f\u022d\3\2\2\2\u022f" + + "\u022e\3\2\2\2\u0230C\3\2\2\2\u0231\u0232\5\22\n\2\u0232\u0233\5@!\2\u0233" + + "E\3\2\2\2\u0234\u0239\5H%\2\u0235\u0236\7G\2\2\u0236\u0238\5H%\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\u023aG\3\2\2\2\u023b\u0239\3\2\2\2\u023c\u023f\5J&\2\u023d\u023e" + + "\7I\2\2\u023e\u0240\5L\'\2\u023f\u023d\3\2\2\2\u023f\u0240\3\2\2\2\u0240" + + "I\3\2\2\2\u0241\u0246\7r\2\2\u0242\u0243\7D\2\2\u0243\u0245\7E\2\2\u0244" + + "\u0242\3\2\2\2\u0245\u0248\3\2\2\2\u0246\u0244\3\2\2\2\u0246\u0247\3\2" + + "\2\2\u0247K\3\2\2\2\u0248\u0246\3\2\2\2\u0249\u024c\5N(\2\u024a\u024c" + + "\5\u00a8U\2\u024b\u0249\3\2\2\2\u024b\u024a\3\2\2\2\u024cM\3\2\2\2\u024d" + + "\u0259\7B\2\2\u024e\u0253\5L\'\2\u024f\u0250\7G\2\2\u0250\u0252\5L\'\2" + + "\u0251\u024f\3\2\2\2\u0252\u0255\3\2\2\2\u0253\u0251\3\2\2\2\u0253\u0254" + + "\3\2\2\2\u0254\u0257\3\2\2\2\u0255\u0253\3\2\2\2\u0256\u0258\7G\2\2\u0257" + + "\u0256\3\2\2\2\u0257\u0258\3\2\2\2\u0258\u025a\3\2\2\2\u0259\u024e\3\2" + + "\2\2\u0259\u025a\3\2\2\2\u025a\u025b\3\2\2\2\u025b\u025c\7C\2\2\u025c" + + "O\3\2\2\2\u025d\u025f\7r\2\2\u025e\u0260\5\u00ccg\2\u025f\u025e\3\2\2" + + "\2\u025f\u0260\3\2\2\2\u0260\u0268\3\2\2\2\u0261\u0262\7H\2\2\u0262\u0264" + + "\7r\2\2\u0263\u0265\5\u00ccg\2\u0264\u0263\3\2\2\2\u0264\u0265\3\2\2\2" + + "\u0265\u0267\3\2\2\2\u0266\u0261\3\2\2\2\u0267\u026a\3\2\2\2\u0268\u0266" + + "\3\2\2\2\u0268\u0269\3\2\2\2\u0269Q\3\2\2\2\u026a\u0268\3\2\2\2\u026b" + + "\u0278\5\u00c8e\2\u026c\u026e\5h\65\2\u026d\u026c\3\2\2\2\u026e\u0271" + + "\3\2\2\2\u026f\u026d\3\2\2\2\u026f\u0270\3\2\2\2\u0270\u0272\3\2\2\2\u0271" + + "\u026f\3\2\2\2\u0272\u0275\7N\2\2\u0273\u0274\t\2\2\2\u0274\u0276\5\u00c8" + + "e\2\u0275\u0273\3\2\2\2\u0275\u0276\3\2\2\2\u0276\u0278\3\2\2\2\u0277" + + "\u026b\3\2\2\2\u0277\u026f\3\2\2\2\u0278S\3\2\2\2\u0279\u027e\5^\60\2" + + "\u027a\u027b\7G\2\2\u027b\u027d\5^\60\2\u027c\u027a\3\2\2\2\u027d\u0280" + + "\3\2\2\2\u027e\u027c\3\2\2\2\u027e\u027f\3\2\2\2\u027fU\3\2\2\2\u0280" + + "\u027e\3\2\2\2\u0281\u0283\7@\2\2\u0282\u0284\5X-\2\u0283\u0282\3\2\2" + + "\2\u0283\u0284\3\2\2\2\u0284\u0285\3\2\2\2\u0285\u0286\7A\2\2\u0286W\3" + + "\2\2\2\u0287\u028c\5Z.\2\u0288\u0289\7G\2\2\u0289\u028b\5Z.\2\u028a\u0288" + + "\3\2\2\2\u028b\u028e\3\2\2\2\u028c\u028a\3\2\2\2\u028c\u028d\3\2\2\2\u028d" + + "\u0291\3\2\2\2\u028e\u028c\3\2\2\2\u028f\u0290\7G\2\2\u0290\u0292\5\\" + + "/\2\u0291\u028f\3\2\2\2\u0291\u0292\3\2\2\2\u0292\u0295\3\2\2\2\u0293" + + "\u0295\5\\/\2\u0294\u0287\3\2\2\2\u0294\u0293\3\2\2\2\u0295Y\3\2\2\2\u0296" + + "\u0298\5\16\b\2\u0297\u0296\3\2\2\2\u0298\u029b\3\2\2\2\u0299\u0297\3" + + "\2\2\2\u0299\u029a\3\2\2\2\u029a\u029c\3\2\2\2\u029b\u0299\3\2\2\2\u029c" + + "\u029d\5\u00c8e\2\u029d\u029e\5J&\2\u029e[\3\2\2\2\u029f\u02a1\5\16\b" + + "\2\u02a0\u029f\3\2\2\2\u02a1\u02a4\3\2\2\2\u02a2\u02a0\3\2\2\2\u02a2\u02a3" + + "\3\2\2\2\u02a3\u02a5\3\2\2\2\u02a4\u02a2\3\2\2\2\u02a5\u02a9\5\u00c8e" + + "\2\u02a6\u02a8\5h\65\2\u02a7\u02a6\3\2\2\2\u02a8\u02ab\3\2\2\2\u02a9\u02a7" + + "\3\2\2\2\u02a9\u02aa\3\2\2\2\u02aa\u02ac\3\2\2\2\u02ab\u02a9\3\2\2\2\u02ac" + + "\u02ad\7n\2\2\u02ad\u02ae\5J&\2\u02ae]\3\2\2\2\u02af\u02b4\7r\2\2\u02b0" + + "\u02b1\7H\2\2\u02b1\u02b3\7r\2\2\u02b2\u02b0\3\2\2\2\u02b3\u02b6\3\2\2" + + "\2\u02b4\u02b2\3\2\2\2\u02b4\u02b5\3\2\2\2\u02b5_\3\2\2\2\u02b6\u02b4" + + "\3\2\2\2\u02b7\u02be\5b\62\2\u02b8\u02be\5d\63\2\u02b9\u02be\7=\2\2\u02ba" + + "\u02be\7>\2\2\u02bb\u02be\7<\2\2\u02bc\u02be\7?\2\2\u02bd\u02b7\3\2\2" + + "\2\u02bd\u02b8\3\2\2\2\u02bd\u02b9\3\2\2\2\u02bd\u02ba\3\2\2\2\u02bd\u02bb" + + "\3\2\2\2\u02bd\u02bc\3\2\2\2\u02bea\3\2\2\2\u02bf\u02c0\t\3\2\2\u02c0" + + "c\3\2\2\2\u02c1\u02c2\t\4\2\2\u02c2e\3\2\2\2\u02c3\u02c4\7r\2\2\u02c4" + + "\u02c6\7H\2\2\u02c5\u02c3\3\2\2\2\u02c6\u02c9\3\2\2\2\u02c7\u02c5\3\2" + + "\2\2\u02c7\u02c8\3\2\2\2\u02c8\u02ca\3\2\2\2\u02c9\u02c7\3\2\2\2\u02ca" + + "\u02cb\7m\2\2\u02cb\u02cc\7r\2\2\u02ccg\3\2\2\2\u02cd\u02ce\7m\2\2\u02ce" + + "\u02d1\5^\60\2\u02cf\u02d1\5f\64\2\u02d0\u02cd\3\2\2\2\u02d0\u02cf\3\2" + + "\2\2\u02d1\u02d8\3\2\2\2\u02d2\u02d5\7@\2\2\u02d3\u02d6\5j\66\2\u02d4" + + "\u02d6\5n8\2\u02d5\u02d3\3\2\2\2\u02d5\u02d4\3\2\2\2\u02d5\u02d6\3\2\2" + + "\2\u02d6\u02d7\3\2\2\2\u02d7\u02d9\7A\2\2\u02d8\u02d2\3\2\2\2\u02d8\u02d9" + + "\3\2\2\2\u02d9i\3\2\2\2\u02da\u02df\5l\67\2\u02db\u02dc\7G\2\2\u02dc\u02de" + + "\5l\67\2\u02dd\u02db\3\2\2\2\u02de\u02e1\3\2\2\2\u02df\u02dd\3\2\2\2\u02df" + + "\u02e0\3\2\2\2\u02e0k\3\2\2\2\u02e1\u02df\3\2\2\2\u02e2\u02e3\7r\2\2\u02e3" + + "\u02e4\7I\2\2\u02e4\u02e5\5n8\2\u02e5m\3\2\2\2\u02e6\u02ea\5\u00a8U\2" + + "\u02e7\u02ea\5h\65\2\u02e8\u02ea\5p9\2\u02e9\u02e6\3\2\2\2\u02e9\u02e7" + + "\3\2\2\2\u02e9\u02e8\3\2\2\2\u02eao\3\2\2\2\u02eb\u02f4\7B\2\2\u02ec\u02f1" + + "\5n8\2\u02ed\u02ee\7G\2\2\u02ee\u02f0\5n8\2\u02ef\u02ed\3\2\2\2\u02f0" + + "\u02f3\3\2\2\2\u02f1\u02ef\3\2\2\2\u02f1\u02f2\3\2\2\2\u02f2\u02f5\3\2" + + "\2\2\u02f3\u02f1\3\2\2\2\u02f4\u02ec\3\2\2\2\u02f4\u02f5\3\2\2\2\u02f5" + + "\u02f7\3\2\2\2\u02f6\u02f8\7G\2\2\u02f7\u02f6\3\2\2\2\u02f7\u02f8\3\2" + + "\2\2\u02f8\u02f9\3\2\2\2\u02f9\u02fa\7C\2\2\u02faq\3\2\2\2\u02fb\u02fc" + + "\7m\2\2\u02fc\u02fd\7\36\2\2\u02fd\u02fe\7r\2\2\u02fe\u02ff\5t;\2\u02ff" + + "s\3\2\2\2\u0300\u0304\7B\2\2\u0301\u0303\5v<\2\u0302\u0301\3\2\2\2\u0303" + + "\u0306\3\2\2\2\u0304\u0302\3\2\2\2\u0304\u0305\3\2\2\2\u0305\u0307\3\2" + + "\2\2\u0306\u0304\3\2\2\2\u0307\u0308\7C\2\2\u0308u\3\2\2\2\u0309\u030b" + + "\5\n\6\2\u030a\u0309\3\2\2\2\u030b\u030e\3\2\2\2\u030c\u030a\3\2\2\2\u030c" + + "\u030d\3\2\2\2\u030d\u030f\3\2\2\2\u030e\u030c\3\2\2\2\u030f\u0312\5x" + + "=\2\u0310\u0312\7F\2\2\u0311\u030c\3\2\2\2\u0311\u0310\3\2\2\2\u0312w" + + "\3\2\2\2\u0313\u0314\5\u00c8e\2\u0314\u0315\5z>\2\u0315\u0316\7F\2\2\u0316" + + "\u0328\3\2\2\2\u0317\u0319\5\20\t\2\u0318\u031a\7F\2\2\u0319\u0318\3\2" + + "\2\2\u0319\u031a\3\2\2\2\u031a\u0328\3\2\2\2\u031b\u031d\5 \21\2\u031c" + + "\u031e\7F\2\2\u031d\u031c\3\2\2\2\u031d\u031e\3\2\2\2\u031e\u0328\3\2" + + "\2\2\u031f\u0321\5\30\r\2\u0320\u0322\7F\2\2\u0321\u0320\3\2\2\2\u0321" + + "\u0322\3\2\2\2\u0322\u0328\3\2\2\2\u0323\u0325\5r:\2\u0324\u0326\7F\2" + + "\2\u0325\u0324\3\2\2\2\u0325\u0326\3\2\2\2\u0326\u0328\3\2\2\2\u0327\u0313" + + "\3\2\2\2\u0327\u0317\3\2\2\2\u0327\u031b\3\2\2\2\u0327\u031f\3\2\2\2\u0327" + + "\u0323\3\2\2\2\u0328y\3\2\2\2\u0329\u032c\5|?\2\u032a\u032c\5~@\2\u032b" + + "\u0329\3\2\2\2\u032b\u032a\3\2\2\2\u032c{\3\2\2\2\u032d\u032e\7r\2\2\u032e" + + "\u032f\7@\2\2\u032f\u0331\7A\2\2\u0330\u0332\5\u0080A\2\u0331\u0330\3" + + "\2\2\2\u0331\u0332\3\2\2\2\u0332}\3\2\2\2\u0333\u0334\5F$\2\u0334\177" + + "\3\2\2\2\u0335\u0336\7\16\2\2\u0336\u0337\5n8\2\u0337\u0081\3\2\2\2\u0338" + + "\u033c\7B\2\2\u0339\u033b\5\u0084C\2\u033a\u0339\3\2\2\2\u033b\u033e\3" + + "\2\2\2\u033c\u033a\3\2\2\2\u033c\u033d\3\2\2\2\u033d\u033f\3\2\2\2\u033e" + + "\u033c\3\2\2\2\u033f\u0340\7C\2\2\u0340\u0083\3\2\2\2\u0341\u0342\5\u0086" + + "D\2\u0342\u0343\7F\2\2\u0343\u0347\3\2\2\2\u0344\u0347\5\u008aF\2\u0345" + + "\u0347\5\u0088E\2\u0346\u0341\3\2\2\2\u0346\u0344\3\2\2\2\u0346\u0345" + + "\3\2\2\2\u0347\u0085\3\2\2\2\u0348\u034a\5\16\b\2\u0349\u0348\3\2\2\2" + + "\u034a\u034d\3\2\2\2\u034b\u0349\3\2\2\2\u034b\u034c\3\2\2\2\u034c\u034e" + + "\3\2\2\2\u034d\u034b\3\2\2\2\u034e\u034f\5\u00c8e\2\u034f\u0350\5F$\2" + + "\u0350\u0087\3\2\2\2\u0351\u0353\5\f\7\2\u0352\u0351\3\2\2\2\u0353\u0356" + + "\3\2\2\2\u0354\u0352\3\2\2\2\u0354\u0355\3\2\2\2\u0355\u0359\3\2\2\2\u0356" + + "\u0354\3\2\2\2\u0357\u035a\5\20\t\2\u0358\u035a\5 \21\2\u0359\u0357\3" + + "\2\2\2\u0359\u0358\3\2\2\2\u035a\u035d\3\2\2\2\u035b\u035d\7F\2\2\u035c" + + "\u0354\3\2\2\2\u035c\u035b\3\2\2\2\u035d\u0089\3\2\2\2\u035e\u03c7\5\u0082" + + "B\2\u035f\u0360\7\4\2\2\u0360\u0363\5\u00a8U\2\u0361\u0362\7O\2\2\u0362" + + "\u0364\5\u00a8U\2\u0363\u0361\3\2\2\2\u0363\u0364\3\2\2\2\u0364\u0365" + + "\3\2\2\2\u0365\u0366\7F\2\2\u0366\u03c7\3\2\2\2\u0367\u0368\7\30\2\2\u0368" + + "\u0369\5\u00a2R\2\u0369\u036c\5\u008aF\2\u036a\u036b\7\21\2\2\u036b\u036d" + + "\5\u008aF\2\u036c\u036a\3\2\2\2\u036c\u036d\3\2\2\2\u036d\u03c7\3\2\2" + + "\2\u036e\u036f\7\27\2\2\u036f\u0370\7@\2\2\u0370\u0371\5\u009cO\2\u0371" + + "\u0372\7A\2\2\u0372\u0373\5\u008aF\2\u0373\u03c7\3\2\2\2\u0374\u0375\7" + + "\65\2\2\u0375\u0376\5\u00a2R\2\u0376\u0377\5\u008aF\2\u0377\u03c7\3\2" + + "\2\2\u0378\u0379\7\17\2\2\u0379\u037a\5\u008aF\2\u037a\u037b\7\65\2\2" + + "\u037b\u037c\5\u00a2R\2\u037c\u037d\7F\2\2\u037d\u03c7\3\2\2\2\u037e\u037f" + + "\7\61\2\2\u037f\u0389\5\u0082B\2\u0380\u0382\5\u008cG\2\u0381\u0380\3" + + "\2\2\2\u0382\u0383\3\2\2\2\u0383\u0381\3\2\2\2\u0383\u0384\3\2\2\2\u0384" + + "\u0386\3\2\2\2\u0385\u0387\5\u0090I\2\u0386\u0385\3\2\2\2\u0386\u0387" + + "\3\2\2\2\u0387\u038a\3\2\2\2\u0388\u038a\5\u0090I\2\u0389\u0381\3\2\2" + + "\2\u0389\u0388\3\2\2\2\u038a\u03c7\3\2\2\2\u038b\u038c\7\61\2\2\u038c" + + "\u038d\5\u0092J\2\u038d\u0391\5\u0082B\2\u038e\u0390\5\u008cG\2\u038f" + + "\u038e\3\2\2\2\u0390\u0393\3\2\2\2\u0391\u038f\3\2\2\2\u0391\u0392\3\2" + + "\2\2\u0392\u0395\3\2\2\2\u0393\u0391\3\2\2\2\u0394\u0396\5\u0090I\2\u0395" + + "\u0394\3\2\2\2\u0395\u0396\3\2\2\2\u0396\u03c7\3\2\2\2\u0397\u0398\7+" + + "\2\2\u0398\u0399\5\u00a2R\2\u0399\u039d\7B\2\2\u039a\u039c\5\u0098M\2" + + "\u039b\u039a\3\2\2\2\u039c\u039f\3\2\2\2\u039d\u039b\3\2\2\2\u039d\u039e" + + "\3\2\2\2\u039e\u03a3\3\2\2\2\u039f\u039d\3\2\2\2\u03a0\u03a2\5\u009aN" + + "\2\u03a1\u03a0\3\2\2\2\u03a2\u03a5\3\2\2\2\u03a3\u03a1\3\2\2\2\u03a3\u03a4" + + "\3\2\2\2\u03a4\u03a6\3\2\2\2\u03a5\u03a3\3\2\2\2\u03a6\u03a7\7C\2\2\u03a7" + + "\u03c7\3\2\2\2\u03a8\u03a9\7,\2\2\u03a9\u03aa\5\u00a2R\2\u03aa\u03ab\5" + + "\u0082B\2\u03ab\u03c7\3\2\2\2\u03ac\u03ae\7&\2\2\u03ad\u03af\5\u00a8U" + + "\2\u03ae\u03ad\3\2\2\2\u03ae\u03af\3\2\2\2\u03af\u03b0\3\2\2\2\u03b0\u03c7" + + "\7F\2\2\u03b1\u03b2\7.\2\2\u03b2\u03b3\5\u00a8U\2\u03b3\u03b4\7F\2\2\u03b4" + + "\u03c7\3\2\2\2\u03b5\u03b7\7\6\2\2\u03b6\u03b8\7r\2\2\u03b7\u03b6\3\2" + + "\2\2\u03b7\u03b8\3\2\2\2\u03b8\u03b9\3\2\2\2\u03b9\u03c7\7F\2\2\u03ba" + + "\u03bc\7\r\2\2\u03bb\u03bd\7r\2\2\u03bc\u03bb\3\2\2\2\u03bc\u03bd\3\2" + + "\2\2\u03bd\u03be\3\2\2\2\u03be\u03c7\7F\2\2\u03bf\u03c7\7F\2\2\u03c0\u03c1" + + "\5\u00a8U\2\u03c1\u03c2\7F\2\2\u03c2\u03c7\3\2\2\2\u03c3\u03c4\7r\2\2" + + "\u03c4\u03c5\7O\2\2\u03c5\u03c7\5\u008aF\2\u03c6\u035e\3\2\2\2\u03c6\u035f" + + "\3\2\2\2\u03c6\u0367\3\2\2\2\u03c6\u036e\3\2\2\2\u03c6\u0374\3\2\2\2\u03c6" + + "\u0378\3\2\2\2\u03c6\u037e\3\2\2\2\u03c6\u038b\3\2\2\2\u03c6\u0397\3\2" + + "\2\2\u03c6\u03a8\3\2\2\2\u03c6\u03ac\3\2\2\2\u03c6\u03b1\3\2\2\2\u03c6" + + "\u03b5\3\2\2\2\u03c6\u03ba\3\2\2\2\u03c6\u03bf\3\2\2\2\u03c6\u03c0\3\2" + + "\2\2\u03c6\u03c3\3\2\2\2\u03c7\u008b\3\2\2\2\u03c8\u03c9\7\t\2\2\u03c9" + + "\u03cd\7@\2\2\u03ca\u03cc\5\16\b\2\u03cb\u03ca\3\2\2\2\u03cc\u03cf\3\2" + + "\2\2\u03cd\u03cb\3\2\2\2\u03cd\u03ce\3\2\2\2\u03ce\u03d0\3\2\2\2\u03cf" + + "\u03cd\3\2\2\2\u03d0\u03d1\5\u008eH\2\u03d1\u03d2\7r\2\2\u03d2\u03d3\7" + + "A\2\2\u03d3\u03d4\5\u0082B\2\u03d4\u008d\3\2\2\2\u03d5\u03da\5^\60\2\u03d6" + + "\u03d7\7]\2\2\u03d7\u03d9\5^\60\2\u03d8\u03d6\3\2\2\2\u03d9\u03dc\3\2" + + "\2\2\u03da\u03d8\3\2\2\2\u03da\u03db\3\2\2\2\u03db\u008f\3\2\2\2\u03dc" + + "\u03da\3\2\2\2\u03dd\u03de\7\25\2\2\u03de\u03df\5\u0082B\2\u03df\u0091" + + "\3\2\2\2\u03e0\u03e1\7@\2\2\u03e1\u03e3\5\u0094K\2\u03e2\u03e4\7F\2\2" + + "\u03e3\u03e2\3\2\2\2\u03e3\u03e4\3\2\2\2\u03e4\u03e5\3\2\2\2\u03e5\u03e6" + + "\7A\2\2\u03e6\u0093\3\2\2\2\u03e7\u03ec\5\u0096L\2\u03e8\u03e9\7F\2\2" + + "\u03e9\u03eb\5\u0096L\2\u03ea\u03e8\3\2\2\2\u03eb\u03ee\3\2\2\2\u03ec" + + "\u03ea\3\2\2\2\u03ec\u03ed\3\2\2\2\u03ed\u0095\3\2\2\2\u03ee\u03ec\3\2" + + "\2\2\u03ef\u03f1\5\16\b\2\u03f0\u03ef\3\2\2\2\u03f1\u03f4\3\2\2\2\u03f2" + + "\u03f0\3\2\2\2\u03f2\u03f3\3\2\2\2\u03f3\u03f5\3\2\2\2\u03f4\u03f2\3\2" + + "\2\2\u03f5\u03f6\5P)\2\u03f6\u03f7\5J&\2\u03f7\u03f8\7I\2\2\u03f8\u03f9" + + "\5\u00a8U\2\u03f9\u0097\3\2\2\2\u03fa\u03fc\5\u009aN\2\u03fb\u03fa\3\2" + + "\2\2\u03fc\u03fd\3\2\2\2\u03fd\u03fb\3\2\2\2\u03fd\u03fe\3\2\2\2\u03fe" + + "\u0400\3\2\2\2\u03ff\u0401\5\u0084C\2\u0400\u03ff\3\2\2\2\u0401\u0402" + + "\3\2\2\2\u0402\u0400\3\2\2\2\u0402\u0403\3\2\2\2\u0403\u0099\3\2\2\2\u0404" + + "\u0407\7\b\2\2\u0405\u0408\5\u00a8U\2\u0406\u0408\7r\2\2\u0407\u0405\3" + + "\2\2\2\u0407\u0406\3\2\2\2\u0408\u0409\3\2\2\2\u0409\u040d\7O\2\2\u040a" + + "\u040b\7\16\2\2\u040b\u040d\7O\2\2\u040c\u0404\3\2\2\2\u040c\u040a\3\2" + + "\2\2\u040d\u009b\3\2\2\2\u040e\u041b\5\u00a0Q\2\u040f\u0411\5\u009eP\2" + + "\u0410\u040f\3\2\2\2\u0410\u0411\3\2\2\2\u0411\u0412\3\2\2\2\u0412\u0414" + + "\7F\2\2\u0413\u0415\5\u00a8U\2\u0414\u0413\3\2\2\2\u0414\u0415\3\2\2\2" + + "\u0415\u0416\3\2\2\2\u0416\u0418\7F\2\2\u0417\u0419\5\u00a4S\2\u0418\u0417" + + "\3\2\2\2\u0418\u0419\3\2\2\2\u0419\u041b\3\2\2\2\u041a\u040e\3\2\2\2\u041a" + + "\u0410\3\2\2\2\u041b\u009d\3\2\2\2\u041c\u041f\5\u0086D\2\u041d\u041f" + + "\5\u00a4S\2\u041e\u041c\3\2\2\2\u041e\u041d\3\2\2\2\u041f\u009f\3\2\2" + + "\2\u0420\u0422\5\16\b\2\u0421\u0420\3\2\2\2\u0422\u0425\3\2\2\2\u0423" + + "\u0421\3\2\2\2\u0423\u0424\3\2\2\2\u0424\u0426\3\2\2\2\u0425\u0423\3\2" + + "\2\2\u0426\u0427\5\u00c8e\2\u0427\u0428\5J&\2\u0428\u0429\7O\2\2\u0429" + + "\u042a\5\u00a8U\2\u042a\u00a1\3\2\2\2\u042b\u042c\7@\2\2\u042c\u042d\5" + + "\u00a8U\2\u042d\u042e\7A\2\2\u042e\u00a3\3\2\2\2\u042f\u0434\5\u00a8U" + + "\2\u0430\u0431\7G\2\2\u0431\u0433\5\u00a8U\2\u0432\u0430\3\2\2\2\u0433" + + "\u0436\3\2\2\2\u0434\u0432\3\2\2\2\u0434\u0435\3\2\2\2\u0435\u00a5\3\2" + + "\2\2\u0436\u0434\3\2\2\2\u0437\u0438\7r\2\2\u0438\u043a\7@\2\2\u0439\u043b" + + "\5\u00a4S\2\u043a\u0439\3\2\2\2\u043a\u043b\3\2\2\2\u043b\u043c\3\2\2" + + "\2\u043c\u044a\7A\2\2\u043d\u043e\7-\2\2\u043e\u0440\7@\2\2\u043f\u0441" + + "\5\u00a4S\2\u0440\u043f\3\2\2\2\u0440\u0441\3\2\2\2\u0441\u0442\3\2\2" + + "\2\u0442\u044a\7A\2\2\u0443\u0444\7*\2\2\u0444\u0446\7@\2\2\u0445\u0447" + + "\5\u00a4S\2\u0446\u0445\3\2\2\2\u0446\u0447\3\2\2\2\u0447\u0448\3\2\2" + + "\2\u0448\u044a\7A\2\2\u0449\u0437\3\2\2\2\u0449\u043d\3\2\2\2\u0449\u0443" + + "\3\2\2\2\u044a\u00a7\3\2\2\2\u044b\u044c\bU\1\2\u044c\u0478\5\u00b0Y\2" + + "\u044d\u0478\5\u00a6T\2\u044e\u044f\7!\2\2\u044f\u0478\5\u00b4[\2\u0450" + + "\u0454\7@\2\2\u0451\u0453\5h\65\2\u0452\u0451\3\2\2\2\u0453\u0456\3\2" + + "\2\2\u0454\u0452\3\2\2\2\u0454\u0455\3\2\2\2\u0455\u0457\3\2\2\2\u0456" + + "\u0454\3\2\2\2\u0457\u045c\5\u00c8e\2\u0458\u0459\7\\\2\2\u0459\u045b" + + "\5\u00c8e\2\u045a\u0458\3\2\2\2\u045b\u045e\3\2\2\2\u045c\u045a\3\2\2" + + "\2\u045c\u045d\3\2\2\2\u045d\u045f\3\2\2\2\u045e\u045c\3\2\2\2\u045f\u0460" + + "\7A\2\2\u0460\u0461\5\u00a8U\27\u0461\u0478\3\2\2\2\u0462\u0463\t\5\2" + + "\2\u0463\u0478\5\u00a8U\25\u0464\u0465\t\6\2\2\u0465\u0478\5\u00a8U\24" + + "\u0466\u0478\5\u00aaV\2\u0467\u0468\5\u00c8e\2\u0468\u046e\7l\2\2\u0469" + + "\u046b\5\u00ccg\2\u046a\u0469\3\2\2\2\u046a\u046b\3\2\2\2\u046b\u046c" + + "\3\2\2\2\u046c\u046f\7r\2\2\u046d\u046f\7!\2\2\u046e\u046a\3\2\2\2\u046e" + + "\u046d\3\2\2\2\u046f\u0478\3\2\2\2\u0470\u0471\5\u00b2Z\2\u0471\u0473" + + "\7l\2\2\u0472\u0474\5\u00ccg\2\u0473\u0472\3\2\2\2\u0473\u0474\3\2\2\2" + + "\u0474\u0475\3\2\2\2\u0475\u0476\7!\2\2\u0476\u0478\3\2\2\2\u0477\u044b" + + "\3\2\2\2\u0477\u044d\3\2\2\2\u0477\u044e\3\2\2\2\u0477\u0450\3\2\2\2\u0477" + + "\u0462\3\2\2\2\u0477\u0464\3\2\2\2\u0477\u0466\3\2\2\2\u0477\u0467\3\2" + + "\2\2\u0477\u0470\3\2\2\2\u0478\u04c9\3\2\2\2\u0479\u047a\f\23\2\2\u047a" + + "\u047b\t\7\2\2\u047b\u04c8\5\u00a8U\24\u047c\u047d\f\22\2\2\u047d\u047e" + + "\t\b\2\2\u047e\u04c8\5\u00a8U\23\u047f\u0487\f\21\2\2\u0480\u0481\7K\2" + + "\2\u0481\u0488\7K\2\2\u0482\u0483\7J\2\2\u0483\u0484\7J\2\2\u0484\u0488" + + "\7J\2\2\u0485\u0486\7J\2\2\u0486\u0488\7J\2\2\u0487\u0480\3\2\2\2\u0487" + + "\u0482\3\2\2\2\u0487\u0485\3\2\2\2\u0488\u0489\3\2\2\2\u0489\u04c8\5\u00a8" + + "U\22\u048a\u048b\f\20\2\2\u048b\u048c\t\t\2\2\u048c\u04c8\5\u00a8U\21" + + "\u048d\u048e\f\16\2\2\u048e\u048f\t\n\2\2\u048f\u04c8\5\u00a8U\17\u0490" + + "\u0491\f\r\2\2\u0491\u0492\7\\\2\2\u0492\u04c8\5\u00a8U\16\u0493\u0494" + + "\f\f\2\2\u0494\u0495\7^\2\2\u0495\u04c8\5\u00a8U\r\u0496\u0497\f\13\2" + + "\2\u0497\u0498\7]\2\2\u0498\u04c8\5\u00a8U\f\u0499\u049a\f\n\2\2\u049a" + + "\u049b\7T\2\2\u049b\u04c8\5\u00a8U\13\u049c\u049d\f\t\2\2\u049d\u049e" + + "\7U\2\2\u049e\u04c8\5\u00a8U\n\u049f\u04a0\f\b\2\2\u04a0\u04a1\7N\2\2" + + "\u04a1\u04a2\5\u00a8U\2\u04a2\u04a3\7O\2\2\u04a3\u04a4\5\u00a8U\b\u04a4" + + "\u04c8\3\2\2\2\u04a5\u04a6\f\7\2\2\u04a6\u04a7\t\13\2\2\u04a7\u04c8\5" + + "\u00a8U\7\u04a8\u04a9\f\33\2\2\u04a9\u04b5\7H\2\2\u04aa\u04b6\7r\2\2\u04ab" + + "\u04b6\5\u00a6T\2\u04ac\u04b6\7-\2\2\u04ad\u04af\7!\2\2\u04ae\u04b0\5" + + "\u00c4c\2\u04af\u04ae\3\2\2\2\u04af\u04b0\3\2\2\2\u04b0\u04b1\3\2\2\2" + + "\u04b1\u04b6\5\u00b8]\2\u04b2\u04b3\7*\2\2\u04b3\u04b6\5\u00ceh\2\u04b4" + + "\u04b6\5\u00be`\2\u04b5\u04aa\3\2\2\2\u04b5\u04ab\3\2\2\2\u04b5\u04ac" + + "\3\2\2\2\u04b5\u04ad\3\2\2\2\u04b5\u04b2\3\2\2\2\u04b5\u04b4\3\2\2\2\u04b6" + + "\u04c8\3\2\2\2\u04b7\u04b8\f\32\2\2\u04b8\u04b9\7D\2\2\u04b9\u04ba\5\u00a8" + + "U\2\u04ba\u04bb\7E\2\2\u04bb\u04c8\3\2\2\2\u04bc\u04bd\f\26\2\2\u04bd" + + "\u04c8\t\f\2\2\u04be\u04bf\f\17\2\2\u04bf\u04c0\7\34\2\2\u04c0\u04c8\5" + + "\u00c8e\2\u04c1\u04c2\f\5\2\2\u04c2\u04c4\7l\2\2\u04c3\u04c5\5\u00ccg" + + "\2\u04c4\u04c3\3\2\2\2\u04c4\u04c5\3\2\2\2\u04c5\u04c6\3\2\2\2\u04c6\u04c8" + + "\7r\2\2\u04c7\u0479\3\2\2\2\u04c7\u047c\3\2\2\2\u04c7\u047f\3\2\2\2\u04c7" + + "\u048a\3\2\2\2\u04c7\u048d\3\2\2\2\u04c7\u0490\3\2\2\2\u04c7\u0493\3\2" + + "\2\2\u04c7\u0496\3\2\2\2\u04c7\u0499\3\2\2\2\u04c7\u049c\3\2\2\2\u04c7" + + "\u049f\3\2\2\2\u04c7\u04a5\3\2\2\2\u04c7\u04a8\3\2\2\2\u04c7\u04b7\3\2" + + "\2\2\u04c7\u04bc\3\2\2\2\u04c7\u04be\3\2\2\2\u04c7\u04c1\3\2\2\2\u04c8" + + "\u04cb\3\2\2\2\u04c9\u04c7\3\2\2\2\u04c9\u04ca\3\2\2\2\u04ca\u00a9\3\2" + + "\2\2\u04cb\u04c9\3\2\2\2\u04cc\u04cd\5\u00acW\2\u04cd\u04ce\7k\2\2\u04ce" + + "\u04cf\5\u00aeX\2\u04cf\u00ab\3\2\2\2\u04d0\u04e1\7r\2\2\u04d1\u04d3\7" + + "@\2\2\u04d2\u04d4\5X-\2\u04d3\u04d2\3\2\2\2\u04d3\u04d4\3\2\2\2\u04d4" + + "\u04d5\3\2\2\2\u04d5\u04e1\7A\2\2\u04d6\u04d7\7@\2\2\u04d7\u04dc\7r\2" + + "\2\u04d8\u04d9\7G\2\2\u04d9\u04db\7r\2\2\u04da\u04d8\3\2\2\2\u04db\u04de" + + "\3\2\2\2\u04dc\u04da\3\2\2\2\u04dc\u04dd\3\2\2\2\u04dd\u04df\3\2\2\2\u04de" + + "\u04dc\3\2\2\2\u04df\u04e1\7A\2\2\u04e0\u04d0\3\2\2\2\u04e0\u04d1\3\2" + + "\2\2\u04e0\u04d6\3\2\2\2\u04e1\u00ad\3\2\2\2\u04e2\u04e5\5\u00a8U\2\u04e3" + + "\u04e5\5\u0082B\2\u04e4\u04e2\3\2\2\2\u04e4\u04e3\3\2\2\2\u04e5\u00af" + + "\3\2\2\2\u04e6\u04e7\7@\2\2\u04e7\u04e8\5\u00a8U\2\u04e8\u04e9\7A\2\2" + + "\u04e9\u04f9\3\2\2\2\u04ea\u04f9\7-\2\2\u04eb\u04f9\7*\2\2\u04ec\u04f9" + + "\5`\61\2\u04ed\u04f9\7r\2\2\u04ee\u04ef\5.\30\2\u04ef\u04f0\7H\2\2\u04f0" + + "\u04f1\7\13\2\2\u04f1\u04f9\3\2\2\2\u04f2\u04f6\5\u00c4c\2\u04f3\u04f7" + + "\5\u00d0i\2\u04f4\u04f5\7-\2\2\u04f5\u04f7\5\u00d2j\2\u04f6\u04f3\3\2" + + "\2\2\u04f6\u04f4\3\2\2\2\u04f7\u04f9\3\2\2\2\u04f8\u04e6\3\2\2\2\u04f8" + + "\u04ea\3\2\2\2\u04f8\u04eb\3\2\2\2\u04f8\u04ec\3\2\2\2\u04f8\u04ed\3\2" + + "\2\2\u04f8\u04ee\3\2\2\2\u04f8\u04f2\3\2\2\2\u04f9\u00b1\3\2\2\2\u04fa" + + "\u04fb\5P)\2\u04fb\u04fc\7H\2\2\u04fc\u04fe\3\2\2\2\u04fd\u04fa\3\2\2" + + "\2\u04fd\u04fe\3\2\2\2\u04fe\u0502\3\2\2\2\u04ff\u0501\5h\65\2\u0500\u04ff" + + "\3\2\2\2\u0501\u0504\3\2\2\2\u0502\u0500\3\2\2\2\u0502\u0503\3\2\2\2\u0503" + + "\u0505\3\2\2\2\u0504\u0502\3\2\2\2\u0505\u0507\7r\2\2\u0506\u0508\5\u00cc" + + "g\2\u0507\u0506\3\2\2\2\u0507\u0508\3\2\2\2\u0508\u00b3\3\2\2\2\u0509" + + "\u050a\5\u00c4c\2\u050a\u050b\5\u00b6\\\2\u050b\u050c\5\u00bc_\2\u050c" + + "\u0513\3\2\2\2\u050d\u0510\5\u00b6\\\2\u050e\u0511\5\u00ba^\2\u050f\u0511" + + "\5\u00bc_\2\u0510\u050e\3\2\2\2\u0510\u050f\3\2\2\2\u0511\u0513\3\2\2" + + "\2\u0512\u0509\3\2\2\2\u0512\u050d\3\2\2\2\u0513\u00b5\3\2\2\2\u0514\u0516" + + "\7r\2\2\u0515\u0517\5\u00c0a\2\u0516\u0515\3\2\2\2\u0516\u0517\3\2\2\2" + + "\u0517\u051f\3\2\2\2\u0518\u0519\7H\2\2\u0519\u051b\7r\2\2\u051a\u051c" + + "\5\u00c0a\2\u051b\u051a\3\2\2\2\u051b\u051c\3\2\2\2\u051c\u051e\3\2\2" + + "\2\u051d\u0518\3\2\2\2\u051e\u0521\3\2\2\2\u051f\u051d\3\2\2\2\u051f\u0520" + + "\3\2\2\2\u0520\u0524\3\2\2\2\u0521\u051f\3\2\2\2\u0522\u0524\5\u00caf" + + "\2\u0523\u0514\3\2\2\2\u0523\u0522\3\2\2\2\u0524\u00b7\3\2\2\2\u0525\u0527" + + "\7r\2\2\u0526\u0528\5\u00c2b\2\u0527\u0526\3\2\2\2\u0527\u0528\3\2\2\2" + + "\u0528\u0529\3\2\2\2\u0529\u052a\5\u00bc_\2\u052a\u00b9\3\2\2\2\u052b" + + "\u0547\7D\2\2\u052c\u0531\7E\2\2\u052d\u052e\7D\2\2\u052e\u0530\7E\2\2" + + "\u052f\u052d\3\2\2\2\u0530\u0533\3\2\2\2\u0531\u052f\3\2\2\2\u0531\u0532" + + "\3\2\2\2\u0532\u0534\3\2\2\2\u0533\u0531\3\2\2\2\u0534\u0548\5N(\2\u0535" + + "\u0536\5\u00a8U\2\u0536\u053d\7E\2\2\u0537\u0538\7D\2\2\u0538\u0539\5" + + "\u00a8U\2\u0539\u053a\7E\2\2\u053a\u053c\3\2\2\2\u053b\u0537\3\2\2\2\u053c" + + "\u053f\3\2\2\2\u053d\u053b\3\2\2\2\u053d\u053e\3\2\2\2\u053e\u0544\3\2" + + "\2\2\u053f\u053d\3\2\2\2\u0540\u0541\7D\2\2\u0541\u0543\7E\2\2\u0542\u0540" + + "\3\2\2\2\u0543\u0546\3\2\2\2\u0544\u0542\3\2\2\2\u0544\u0545\3\2\2\2\u0545" + + "\u0548\3\2\2\2\u0546\u0544\3\2\2\2\u0547\u052c\3\2\2\2\u0547\u0535\3\2" + + "\2\2\u0548\u00bb\3\2\2\2\u0549\u054b\5\u00d2j\2\u054a\u054c\5\"\22\2\u054b" + + "\u054a\3\2\2\2\u054b\u054c\3\2\2\2\u054c\u00bd\3\2\2\2\u054d\u054e\5\u00c4" + + "c\2\u054e\u054f\5\u00d0i\2\u054f\u00bf\3\2\2\2\u0550\u0551\7K\2\2\u0551" + + "\u0554\7J\2\2\u0552\u0554\5\u00ccg\2\u0553\u0550\3\2\2\2\u0553\u0552\3" + + "\2\2\2\u0554\u00c1\3\2\2\2\u0555\u0556\7K\2\2\u0556\u0559\7J\2\2\u0557" + + "\u0559\5\u00c4c\2\u0558\u0555\3\2\2\2\u0558\u0557\3\2\2\2\u0559\u00c3" + + "\3\2\2\2\u055a\u055b\7K\2\2\u055b\u055c\5\u00c6d\2\u055c\u055d\7J\2\2" + + "\u055d\u00c5\3\2\2\2\u055e\u0563\5\u00c8e\2\u055f\u0560\7G\2\2\u0560\u0562" + + "\5\u00c8e\2\u0561\u055f\3\2\2\2\u0562\u0565\3\2\2\2\u0563\u0561\3\2\2" + + "\2\u0563\u0564\3\2\2\2\u0564\u00c7\3\2\2\2\u0565\u0563\3\2\2\2\u0566\u0568" + + "\5h\65\2\u0567\u0566\3\2\2\2\u0568\u056b\3\2\2\2\u0569\u0567\3\2\2\2\u0569" + + "\u056a\3\2\2\2\u056a\u056e\3\2\2\2\u056b\u0569\3\2\2\2\u056c\u056f\5P" + + ")\2\u056d\u056f\5\u00caf\2\u056e\u056c\3\2\2\2\u056e\u056d\3\2\2\2\u056f" + + "\u057a\3\2\2\2\u0570\u0572\5h\65\2\u0571\u0570\3\2\2\2\u0572\u0575\3\2" + + "\2\2\u0573\u0571\3\2\2\2\u0573\u0574\3\2\2\2\u0574\u0576\3\2\2\2\u0575" + + "\u0573\3\2\2\2\u0576\u0577\7D\2\2\u0577\u0579\7E\2\2\u0578\u0573\3\2\2" + + "\2\u0579\u057c\3\2\2\2\u057a\u0578\3\2\2\2\u057a\u057b\3\2\2\2\u057b\u00c9" + + "\3\2\2\2\u057c\u057a\3\2\2\2\u057d\u057e\t\r\2\2\u057e\u00cb\3\2\2\2\u057f" + + "\u0580\7K\2\2\u0580\u0585\5R*\2\u0581\u0582\7G\2\2\u0582\u0584\5R*\2\u0583" + + "\u0581\3\2\2\2\u0584\u0587\3\2\2\2\u0585\u0583\3\2\2\2\u0585\u0586\3\2" + + "\2\2\u0586\u0588\3\2\2\2\u0587\u0585\3\2\2\2\u0588\u0589\7J\2\2\u0589" + + "\u00cd\3\2\2\2\u058a\u0591\5\u00d2j\2\u058b\u058c\7H\2\2\u058c\u058e\7" + + "r\2\2\u058d\u058f\5\u00d2j\2\u058e\u058d\3\2\2\2\u058e\u058f\3\2\2\2\u058f" + + "\u0591\3\2\2\2\u0590\u058a\3\2\2\2\u0590\u058b\3\2\2\2\u0591\u00cf\3\2" + + "\2\2\u0592\u0593\7*\2\2\u0593\u0597\5\u00ceh\2\u0594\u0595\7r\2\2\u0595" + + "\u0597\5\u00d2j\2\u0596\u0592\3\2\2\2\u0596\u0594\3\2\2\2\u0597\u00d1" + + "\3\2\2\2\u0598\u059a\7@\2\2\u0599\u059b\5\u00a4S\2\u059a\u0599\3\2\2\2" + + "\u059a\u059b\3\2\2\2\u059b\u059c\3\2\2\2\u059c\u059d\7A\2\2\u059d\u00d3" + + "\3\2\2\2\u00b5\u00d5\u00da\u00e0\u00e8\u00f1\u00f6\u00fd\u0104\u0107\u010e" + + "\u0118\u011c\u0121\u0125\u0129\u0133\u013b\u0143\u0147\u014e\u0155\u0159" + + "\u015c\u015f\u0168\u016e\u0173\u0176\u017c\u0182\u0186\u018e\u0197\u019e" + + "\u01a4\u01a8\u01b3\u01bc\u01c1\u01c7\u01cb\u01d7\u01e2\u01e7\u01f0\u01f8" + + "\u0202\u020b\u0213\u0218\u0220\u0225\u022f\u0239\u023f\u0246\u024b\u0253" + + "\u0257\u0259\u025f\u0264\u0268\u026f\u0275\u0277\u027e\u0283\u028c\u0291" + + "\u0294\u0299\u02a2\u02a9\u02b4\u02bd\u02c7\u02d0\u02d5\u02d8\u02df\u02e9" + + "\u02f1\u02f4\u02f7\u0304\u030c\u0311\u0319\u031d\u0321\u0325\u0327\u032b" + + "\u0331\u033c\u0346\u034b\u0354\u0359\u035c\u0363\u036c\u0383\u0386\u0389" + + "\u0391\u0395\u039d\u03a3\u03ae\u03b7\u03bc\u03c6\u03cd\u03da\u03e3\u03ec" + + "\u03f2\u03fd\u0402\u0407\u040c\u0410\u0414\u0418\u041a\u041e\u0423\u0434" + + "\u043a\u0440\u0446\u0449\u0454\u045c\u046a\u046e\u0473\u0477\u0487\u04af" + + "\u04b5\u04c4\u04c7\u04c9\u04d3\u04dc\u04e0\u04e4\u04f6\u04f8\u04fd\u0502" + + "\u0507\u0510\u0512\u0516\u051b\u051f\u0523\u0527\u0531\u053d\u0544\u0547" + + "\u054b\u0553\u0558\u0563\u0569\u056e\u0573\u057a\u0585\u058e\u0590\u0596" + + "\u059a"; + public static final ATN _ATN = new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache(); + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + + static { + RuntimeMetaData.checkVersion("4.9.3", RuntimeMetaData.VERSION); + } + + 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] = ""; + } + } + } + + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } + + public JavaParser(TokenStream input) { + super(input); + _interp = new ParserATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache); + } private static String[] makeRuleNames() { return new String[] { @@ -378,8 +960,6 @@ public class JavaParser extends Parser { }; } - public static final String[] ruleNames = makeRuleNames(); - private static String[] makeLiteralNames() { return new String[] { null, @@ -494,8 +1074,6 @@ public class JavaParser extends Parser { }; } - private static final String[] _LITERAL_NAMES = makeLiteralNames(); - private static String[] makeSymbolicNames() { return new String[] { null, @@ -614,116 +1192,83 @@ public class JavaParser extends Parser { }; } - 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 "JavaParser.g4"; - } - @Override public String[] getRuleNames() { return ruleNames; } + @Override + public Vocabulary getVocabulary() { + return VOCABULARY; + } + @Override public String getSerializedATN() { return _serializedATN; } + @Override + public String getGrammarFileName() { + return "JavaParser.g4"; + } + @Override public ATN getATN() { return _ATN; } - public JavaParser(TokenStream input) { - super(input); - _interp = new ParserATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache); + public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { + switch (ruleIndex) { + case 83: + return expression_sempred((ExpressionContext) _localctx, predIndex); + } + return true; } - public static class CompilationUnitContext extends ParserRuleContext { - public TerminalNode EOF() { - return getToken(JavaParser.EOF, 0); - } - - public PackageDeclarationContext packageDeclaration() { - return getRuleContext(PackageDeclarationContext.class, 0); - } - - public List importDeclaration() { - return getRuleContexts(ImportDeclarationContext.class); - } - - public ImportDeclarationContext importDeclaration(int i) { - return getRuleContext(ImportDeclarationContext.class, i); - } - - public List typeDeclaration() { - return getRuleContexts(TypeDeclarationContext.class); - } - - public TypeDeclarationContext typeDeclaration(int i) { - return getRuleContext(TypeDeclarationContext.class, i); - } - - public CompilationUnitContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_compilationUnit; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterCompilationUnit(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitCompilationUnit(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitCompilationUnit(this); - else return visitor.visitChildren(this); + private boolean expression_sempred(ExpressionContext _localctx, int predIndex) { + switch (predIndex) { + case 0: + return precpred(_ctx, 17); + case 1: + return precpred(_ctx, 16); + case 2: + return precpred(_ctx, 15); + case 3: + return precpred(_ctx, 14); + case 4: + return precpred(_ctx, 12); + case 5: + return precpred(_ctx, 11); + case 6: + return precpred(_ctx, 10); + case 7: + return precpred(_ctx, 9); + case 8: + return precpred(_ctx, 8); + case 9: + return precpred(_ctx, 7); + case 10: + return precpred(_ctx, 6); + case 11: + return precpred(_ctx, 5); + case 12: + return precpred(_ctx, 25); + case 13: + return precpred(_ctx, 24); + case 14: + return precpred(_ctx, 20); + case 15: + return precpred(_ctx, 13); + case 16: + return precpred(_ctx, 3); } + return true; } public final CompilationUnitContext compilationUnit() throws RecognitionException { @@ -800,56 +1345,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class PackageDeclarationContext extends ParserRuleContext { - public TerminalNode PACKAGE() { - return getToken(JavaParser.PACKAGE, 0); - } - - public QualifiedNameContext qualifiedName() { - return getRuleContext(QualifiedNameContext.class, 0); - } - - public TerminalNode SEMI() { - return getToken(JavaParser.SEMI, 0); - } - - public List annotation() { - return getRuleContexts(AnnotationContext.class); - } - - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class, i); - } - - public PackageDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_packageDeclaration; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterPackageDeclaration(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitPackageDeclaration(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitPackageDeclaration(this); - else return visitor.visitChildren(this); - } - } - public final PackageDeclarationContext packageDeclaration() throws RecognitionException { PackageDeclarationContext _localctx = new PackageDeclarationContext(_ctx, getState()); enterRule(_localctx, 2, RULE_packageDeclaration); @@ -888,60 +1383,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class ImportDeclarationContext extends ParserRuleContext { - public TerminalNode IMPORT() { - return getToken(JavaParser.IMPORT, 0); - } - - public QualifiedNameContext qualifiedName() { - return getRuleContext(QualifiedNameContext.class, 0); - } - - public TerminalNode SEMI() { - return getToken(JavaParser.SEMI, 0); - } - - public TerminalNode STATIC() { - return getToken(JavaParser.STATIC, 0); - } - - public TerminalNode DOT() { - return getToken(JavaParser.DOT, 0); - } - - public TerminalNode MUL() { - return getToken(JavaParser.MUL, 0); - } - - public ImportDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_importDeclaration; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterImportDeclaration(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitImportDeclaration(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitImportDeclaration(this); - else return visitor.visitChildren(this); - } - } - public final ImportDeclarationContext importDeclaration() throws RecognitionException { ImportDeclarationContext _localctx = new ImportDeclarationContext(_ctx, getState()); enterRule(_localctx, 4, RULE_importDeclaration); @@ -988,64 +1429,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class TypeDeclarationContext extends ParserRuleContext { - public ClassDeclarationContext classDeclaration() { - return getRuleContext(ClassDeclarationContext.class, 0); - } - - public EnumDeclarationContext enumDeclaration() { - return getRuleContext(EnumDeclarationContext.class, 0); - } - - public InterfaceDeclarationContext interfaceDeclaration() { - return getRuleContext(InterfaceDeclarationContext.class, 0); - } - - public AnnotationTypeDeclarationContext annotationTypeDeclaration() { - return getRuleContext(AnnotationTypeDeclarationContext.class, 0); - } - - public List classOrInterfaceModifier() { - return getRuleContexts(ClassOrInterfaceModifierContext.class); - } - - public ClassOrInterfaceModifierContext classOrInterfaceModifier(int i) { - return getRuleContext(ClassOrInterfaceModifierContext.class, i); - } - - public TerminalNode SEMI() { - return getToken(JavaParser.SEMI, 0); - } - - public TypeDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_typeDeclaration; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterTypeDeclaration(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitTypeDeclaration(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitTypeDeclaration(this); - else return visitor.visitChildren(this); - } - } - public final TypeDeclarationContext typeDeclaration() throws RecognitionException { TypeDeclarationContext _localctx = new TypeDeclarationContext(_ctx, getState()); enterRule(_localctx, 6, RULE_typeDeclaration); @@ -1136,56 +1519,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class ModifierContext extends ParserRuleContext { - public ClassOrInterfaceModifierContext classOrInterfaceModifier() { - return getRuleContext(ClassOrInterfaceModifierContext.class, 0); - } - - public TerminalNode NATIVE() { - return getToken(JavaParser.NATIVE, 0); - } - - public TerminalNode SYNCHRONIZED() { - return getToken(JavaParser.SYNCHRONIZED, 0); - } - - public TerminalNode TRANSIENT() { - return getToken(JavaParser.TRANSIENT, 0); - } - - public TerminalNode VOLATILE() { - return getToken(JavaParser.VOLATILE, 0); - } - - public ModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_modifier; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterModifier(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitModifier(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitModifier(this); - else return visitor.visitChildren(this); - } - } - public final ModifierContext modifier() throws RecognitionException { ModifierContext _localctx = new ModifierContext(_ctx, getState()); enterRule(_localctx, 8, RULE_modifier); @@ -1249,68 +1582,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class ClassOrInterfaceModifierContext extends ParserRuleContext { - public AnnotationContext annotation() { - return getRuleContext(AnnotationContext.class, 0); - } - - public TerminalNode PUBLIC() { - return getToken(JavaParser.PUBLIC, 0); - } - - public TerminalNode PROTECTED() { - return getToken(JavaParser.PROTECTED, 0); - } - - public TerminalNode PRIVATE() { - return getToken(JavaParser.PRIVATE, 0); - } - - public TerminalNode STATIC() { - return getToken(JavaParser.STATIC, 0); - } - - public TerminalNode ABSTRACT() { - return getToken(JavaParser.ABSTRACT, 0); - } - - public TerminalNode FINAL() { - return getToken(JavaParser.FINAL, 0); - } - - public TerminalNode STRICTFP() { - return getToken(JavaParser.STRICTFP, 0); - } - - public ClassOrInterfaceModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_classOrInterfaceModifier; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterClassOrInterfaceModifier(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitClassOrInterfaceModifier(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitClassOrInterfaceModifier(this); - else return visitor.visitChildren(this); - } - } - public final ClassOrInterfaceModifierContext classOrInterfaceModifier() throws RecognitionException { ClassOrInterfaceModifierContext _localctx = @@ -1390,44 +1661,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class VariableModifierContext extends ParserRuleContext { - public TerminalNode FINAL() { - return getToken(JavaParser.FINAL, 0); - } - - public AnnotationContext annotation() { - return getRuleContext(AnnotationContext.class, 0); - } - - public VariableModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_variableModifier; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterVariableModifier(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitVariableModifier(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitVariableModifier(this); - else return visitor.visitChildren(this); - } - } - public final VariableModifierContext variableModifier() throws RecognitionException { VariableModifierContext _localctx = new VariableModifierContext(_ctx, getState()); enterRule(_localctx, 12, RULE_variableModifier); @@ -1463,68 +1696,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class ClassDeclarationContext extends ParserRuleContext { - public TerminalNode CLASS() { - return getToken(JavaParser.CLASS, 0); - } - - public TerminalNode IDENTIFIER() { - return getToken(JavaParser.IDENTIFIER, 0); - } - - public ClassBodyContext classBody() { - return getRuleContext(ClassBodyContext.class, 0); - } - - public TypeParametersContext typeParameters() { - return getRuleContext(TypeParametersContext.class, 0); - } - - public TerminalNode EXTENDS() { - return getToken(JavaParser.EXTENDS, 0); - } - - public TypeTypeContext typeType() { - return getRuleContext(TypeTypeContext.class, 0); - } - - public TerminalNode IMPLEMENTS() { - return getToken(JavaParser.IMPLEMENTS, 0); - } - - public TypeListContext typeList() { - return getRuleContext(TypeListContext.class, 0); - } - - public ClassDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_classDeclaration; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterClassDeclaration(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitClassDeclaration(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitClassDeclaration(this); - else return visitor.visitChildren(this); - } - } - public final ClassDeclarationContext classDeclaration() throws RecognitionException { ClassDeclarationContext _localctx = new ClassDeclarationContext(_ctx, getState()); enterRule(_localctx, 14, RULE_classDeclaration); @@ -1583,60 +1754,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class TypeParametersContext extends ParserRuleContext { - public TerminalNode LT() { - return getToken(JavaParser.LT, 0); - } - - public List typeParameter() { - return getRuleContexts(TypeParameterContext.class); - } - - public TypeParameterContext typeParameter(int i) { - return getRuleContext(TypeParameterContext.class, i); - } - - public TerminalNode GT() { - return getToken(JavaParser.GT, 0); - } - - public List COMMA() { - return getTokens(JavaParser.COMMA); - } - - public TerminalNode COMMA(int i) { - return getToken(JavaParser.COMMA, i); - } - - public TypeParametersContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_typeParameters; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterTypeParameters(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitTypeParameters(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitTypeParameters(this); - else return visitor.visitChildren(this); - } - } - public final TypeParametersContext typeParameters() throws RecognitionException { TypeParametersContext _localctx = new TypeParametersContext(_ctx, getState()); enterRule(_localctx, 16, RULE_typeParameters); @@ -1677,56 +1794,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class TypeParameterContext extends ParserRuleContext { - public TerminalNode IDENTIFIER() { - return getToken(JavaParser.IDENTIFIER, 0); - } - - public List annotation() { - return getRuleContexts(AnnotationContext.class); - } - - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class, i); - } - - public TerminalNode EXTENDS() { - return getToken(JavaParser.EXTENDS, 0); - } - - public TypeBoundContext typeBound() { - return getRuleContext(TypeBoundContext.class, 0); - } - - public TypeParameterContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_typeParameter; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterTypeParameter(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitTypeParameter(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitTypeParameter(this); - else return visitor.visitChildren(this); - } - } - public final TypeParameterContext typeParameter() throws RecognitionException { TypeParameterContext _localctx = new TypeParameterContext(_ctx, getState()); enterRule(_localctx, 18, RULE_typeParameter); @@ -1791,52 +1858,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class TypeBoundContext extends ParserRuleContext { - public List typeType() { - return getRuleContexts(TypeTypeContext.class); - } - - public TypeTypeContext typeType(int i) { - return getRuleContext(TypeTypeContext.class, i); - } - - public List BITAND() { - return getTokens(JavaParser.BITAND); - } - - public TerminalNode BITAND(int i) { - return getToken(JavaParser.BITAND, i); - } - - public TypeBoundContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_typeBound; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterTypeBound(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitTypeBound(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitTypeBound(this); - else return visitor.visitChildren(this); - } - } - public final TypeBoundContext typeBound() throws RecognitionException { TypeBoundContext _localctx = new TypeBoundContext(_ctx, getState()); enterRule(_localctx, 20, RULE_typeBound); @@ -1873,72 +1894,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class EnumDeclarationContext extends ParserRuleContext { - public TerminalNode ENUM() { - return getToken(JavaParser.ENUM, 0); - } - - public TerminalNode IDENTIFIER() { - return getToken(JavaParser.IDENTIFIER, 0); - } - - public TerminalNode LBRACE() { - return getToken(JavaParser.LBRACE, 0); - } - - public TerminalNode RBRACE() { - return getToken(JavaParser.RBRACE, 0); - } - - public TerminalNode IMPLEMENTS() { - return getToken(JavaParser.IMPLEMENTS, 0); - } - - public TypeListContext typeList() { - return getRuleContext(TypeListContext.class, 0); - } - - public EnumConstantsContext enumConstants() { - return getRuleContext(EnumConstantsContext.class, 0); - } - - public TerminalNode COMMA() { - return getToken(JavaParser.COMMA, 0); - } - - public EnumBodyDeclarationsContext enumBodyDeclarations() { - return getRuleContext(EnumBodyDeclarationsContext.class, 0); - } - - public EnumDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_enumDeclaration; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterEnumDeclaration(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitEnumDeclaration(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitEnumDeclaration(this); - else return visitor.visitChildren(this); - } - } - public final EnumDeclarationContext enumDeclaration() throws RecognitionException { EnumDeclarationContext _localctx = new EnumDeclarationContext(_ctx, getState()); enterRule(_localctx, 22, RULE_enumDeclaration); @@ -2007,52 +1962,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class EnumConstantsContext extends ParserRuleContext { - public List enumConstant() { - return getRuleContexts(EnumConstantContext.class); - } - - public EnumConstantContext enumConstant(int i) { - return getRuleContext(EnumConstantContext.class, i); - } - - public List COMMA() { - return getTokens(JavaParser.COMMA); - } - - public TerminalNode COMMA(int i) { - return getToken(JavaParser.COMMA, i); - } - - public EnumConstantsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_enumConstants; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterEnumConstants(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitEnumConstants(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitEnumConstants(this); - else return visitor.visitChildren(this); - } - } - public final EnumConstantsContext enumConstants() throws RecognitionException { EnumConstantsContext _localctx = new EnumConstantsContext(_ctx, getState()); enterRule(_localctx, 24, RULE_enumConstants); @@ -2091,56 +2000,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class EnumConstantContext extends ParserRuleContext { - public TerminalNode IDENTIFIER() { - return getToken(JavaParser.IDENTIFIER, 0); - } - - public List annotation() { - return getRuleContexts(AnnotationContext.class); - } - - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class, i); - } - - public ArgumentsContext arguments() { - return getRuleContext(ArgumentsContext.class, 0); - } - - public ClassBodyContext classBody() { - return getRuleContext(ClassBodyContext.class, 0); - } - - public EnumConstantContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_enumConstant; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterEnumConstant(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitEnumConstant(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitEnumConstant(this); - else return visitor.visitChildren(this); - } - } - public final EnumConstantContext enumConstant() throws RecognitionException { EnumConstantContext _localctx = new EnumConstantContext(_ctx, getState()); enterRule(_localctx, 26, RULE_enumConstant); @@ -2197,48 +2056,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class EnumBodyDeclarationsContext extends ParserRuleContext { - public TerminalNode SEMI() { - return getToken(JavaParser.SEMI, 0); - } - - public List classBodyDeclaration() { - return getRuleContexts(ClassBodyDeclarationContext.class); - } - - public ClassBodyDeclarationContext classBodyDeclaration(int i) { - return getRuleContext(ClassBodyDeclarationContext.class, i); - } - - public EnumBodyDeclarationsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_enumBodyDeclarations; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterEnumBodyDeclarations(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitEnumBodyDeclarations(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitEnumBodyDeclarations(this); - else return visitor.visitChildren(this); - } - } - public final EnumBodyDeclarationsContext enumBodyDeclarations() throws RecognitionException { EnumBodyDeclarationsContext _localctx = new EnumBodyDeclarationsContext(_ctx, getState()); enterRule(_localctx, 28, RULE_enumBodyDeclarations); @@ -2306,60 +2123,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class InterfaceDeclarationContext extends ParserRuleContext { - public TerminalNode INTERFACE() { - return getToken(JavaParser.INTERFACE, 0); - } - - public TerminalNode IDENTIFIER() { - return getToken(JavaParser.IDENTIFIER, 0); - } - - public InterfaceBodyContext interfaceBody() { - return getRuleContext(InterfaceBodyContext.class, 0); - } - - public TypeParametersContext typeParameters() { - return getRuleContext(TypeParametersContext.class, 0); - } - - public TerminalNode EXTENDS() { - return getToken(JavaParser.EXTENDS, 0); - } - - public TypeListContext typeList() { - return getRuleContext(TypeListContext.class, 0); - } - - public InterfaceDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_interfaceDeclaration; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterInterfaceDeclaration(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitInterfaceDeclaration(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitInterfaceDeclaration(this); - else return visitor.visitChildren(this); - } - } - public final InterfaceDeclarationContext interfaceDeclaration() throws RecognitionException { InterfaceDeclarationContext _localctx = new InterfaceDeclarationContext(_ctx, getState()); enterRule(_localctx, 30, RULE_interfaceDeclaration); @@ -2406,52 +2169,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class ClassBodyContext extends ParserRuleContext { - public TerminalNode LBRACE() { - return getToken(JavaParser.LBRACE, 0); - } - - public TerminalNode RBRACE() { - return getToken(JavaParser.RBRACE, 0); - } - - public List classBodyDeclaration() { - return getRuleContexts(ClassBodyDeclarationContext.class); - } - - public ClassBodyDeclarationContext classBodyDeclaration(int i) { - return getRuleContext(ClassBodyDeclarationContext.class, i); - } - - public ClassBodyContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_classBody; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterClassBody(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitClassBody(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitClassBody(this); - else return visitor.visitChildren(this); - } - } - public final ClassBodyContext classBody() throws RecognitionException { ClassBodyContext _localctx = new ClassBodyContext(_ctx, getState()); enterRule(_localctx, 32, RULE_classBody); @@ -2521,52 +2238,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class InterfaceBodyContext extends ParserRuleContext { - public TerminalNode LBRACE() { - return getToken(JavaParser.LBRACE, 0); - } - - public TerminalNode RBRACE() { - return getToken(JavaParser.RBRACE, 0); - } - - public List interfaceBodyDeclaration() { - return getRuleContexts(InterfaceBodyDeclarationContext.class); - } - - public InterfaceBodyDeclarationContext interfaceBodyDeclaration(int i) { - return getRuleContext(InterfaceBodyDeclarationContext.class, i); - } - - public InterfaceBodyContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_interfaceBody; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterInterfaceBody(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitInterfaceBody(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitInterfaceBody(this); - else return visitor.visitChildren(this); - } - } - public final InterfaceBodyContext interfaceBody() throws RecognitionException { InterfaceBodyContext _localctx = new InterfaceBodyContext(_ctx, getState()); enterRule(_localctx, 34, RULE_interfaceBody); @@ -2636,60 +2307,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class ClassBodyDeclarationContext extends ParserRuleContext { - public TerminalNode SEMI() { - return getToken(JavaParser.SEMI, 0); - } - - public BlockContext block() { - return getRuleContext(BlockContext.class, 0); - } - - public TerminalNode STATIC() { - return getToken(JavaParser.STATIC, 0); - } - - public MemberDeclarationContext memberDeclaration() { - return getRuleContext(MemberDeclarationContext.class, 0); - } - - public List modifier() { - return getRuleContexts(ModifierContext.class); - } - - public ModifierContext modifier(int i) { - return getRuleContext(ModifierContext.class, i); - } - - public ClassBodyDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_classBodyDeclaration; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterClassBodyDeclaration(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitClassBodyDeclaration(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitClassBodyDeclaration(this); - else return visitor.visitChildren(this); - } - } - public final ClassBodyDeclarationContext classBodyDeclaration() throws RecognitionException { ClassBodyDeclarationContext _localctx = new ClassBodyDeclarationContext(_ctx, getState()); enterRule(_localctx, 36, RULE_classBodyDeclaration); @@ -2757,72 +2374,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class MemberDeclarationContext extends ParserRuleContext { - public MethodDeclarationContext methodDeclaration() { - return getRuleContext(MethodDeclarationContext.class, 0); - } - - public GenericMethodDeclarationContext genericMethodDeclaration() { - return getRuleContext(GenericMethodDeclarationContext.class, 0); - } - - public FieldDeclarationContext fieldDeclaration() { - return getRuleContext(FieldDeclarationContext.class, 0); - } - - public ConstructorDeclarationContext constructorDeclaration() { - return getRuleContext(ConstructorDeclarationContext.class, 0); - } - - public GenericConstructorDeclarationContext genericConstructorDeclaration() { - return getRuleContext(GenericConstructorDeclarationContext.class, 0); - } - - public InterfaceDeclarationContext interfaceDeclaration() { - return getRuleContext(InterfaceDeclarationContext.class, 0); - } - - public AnnotationTypeDeclarationContext annotationTypeDeclaration() { - return getRuleContext(AnnotationTypeDeclarationContext.class, 0); - } - - public ClassDeclarationContext classDeclaration() { - return getRuleContext(ClassDeclarationContext.class, 0); - } - - public EnumDeclarationContext enumDeclaration() { - return getRuleContext(EnumDeclarationContext.class, 0); - } - - public MemberDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_memberDeclaration; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterMemberDeclaration(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitMemberDeclaration(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitMemberDeclaration(this); - else return visitor.visitChildren(this); - } - } - public final MemberDeclarationContext memberDeclaration() throws RecognitionException { MemberDeclarationContext _localctx = new MemberDeclarationContext(_ctx, getState()); enterRule(_localctx, 38, RULE_memberDeclaration); @@ -2904,76 +2455,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class MethodDeclarationContext extends ParserRuleContext { - public TypeTypeOrVoidContext typeTypeOrVoid() { - return getRuleContext(TypeTypeOrVoidContext.class, 0); - } - - public TerminalNode IDENTIFIER() { - return getToken(JavaParser.IDENTIFIER, 0); - } - - public FormalParametersContext formalParameters() { - return getRuleContext(FormalParametersContext.class, 0); - } - - public MethodBodyContext methodBody() { - return getRuleContext(MethodBodyContext.class, 0); - } - - public List LBRACK() { - return getTokens(JavaParser.LBRACK); - } - - public TerminalNode LBRACK(int i) { - return getToken(JavaParser.LBRACK, i); - } - - public List RBRACK() { - return getTokens(JavaParser.RBRACK); - } - - public TerminalNode RBRACK(int i) { - return getToken(JavaParser.RBRACK, i); - } - - public TerminalNode THROWS() { - return getToken(JavaParser.THROWS, 0); - } - - public QualifiedNameListContext qualifiedNameList() { - return getRuleContext(QualifiedNameListContext.class, 0); - } - - public MethodDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_methodDeclaration; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterMethodDeclaration(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitMethodDeclaration(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitMethodDeclaration(this); - else return visitor.visitChildren(this); - } - } - public final MethodDeclarationContext methodDeclaration() throws RecognitionException { MethodDeclarationContext _localctx = new MethodDeclarationContext(_ctx, getState()); enterRule(_localctx, 40, RULE_methodDeclaration); @@ -3028,44 +2509,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class MethodBodyContext extends ParserRuleContext { - public BlockContext block() { - return getRuleContext(BlockContext.class, 0); - } - - public TerminalNode SEMI() { - return getToken(JavaParser.SEMI, 0); - } - - public MethodBodyContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_methodBody; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterMethodBody(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitMethodBody(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitMethodBody(this); - else return visitor.visitChildren(this); - } - } - public final MethodBodyContext methodBody() throws RecognitionException { MethodBodyContext _localctx = new MethodBodyContext(_ctx, getState()); enterRule(_localctx, 42, RULE_methodBody); @@ -3100,44 +2543,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class TypeTypeOrVoidContext extends ParserRuleContext { - public TypeTypeContext typeType() { - return getRuleContext(TypeTypeContext.class, 0); - } - - public TerminalNode VOID() { - return getToken(JavaParser.VOID, 0); - } - - public TypeTypeOrVoidContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_typeTypeOrVoid; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterTypeTypeOrVoid(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitTypeTypeOrVoid(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitTypeTypeOrVoid(this); - else return visitor.visitChildren(this); - } - } - public final TypeTypeOrVoidContext typeTypeOrVoid() throws RecognitionException { TypeTypeOrVoidContext _localctx = new TypeTypeOrVoidContext(_ctx, getState()); enterRule(_localctx, 44, RULE_typeTypeOrVoid); @@ -3181,44 +2586,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class GenericMethodDeclarationContext extends ParserRuleContext { - public TypeParametersContext typeParameters() { - return getRuleContext(TypeParametersContext.class, 0); - } - - public MethodDeclarationContext methodDeclaration() { - return getRuleContext(MethodDeclarationContext.class, 0); - } - - public GenericMethodDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_genericMethodDeclaration; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterGenericMethodDeclaration(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitGenericMethodDeclaration(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitGenericMethodDeclaration(this); - else return visitor.visitChildren(this); - } - } - public final GenericMethodDeclarationContext genericMethodDeclaration() throws RecognitionException { GenericMethodDeclarationContext _localctx = @@ -3242,44 +2609,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class GenericConstructorDeclarationContext extends ParserRuleContext { - public TypeParametersContext typeParameters() { - return getRuleContext(TypeParametersContext.class, 0); - } - - public ConstructorDeclarationContext constructorDeclaration() { - return getRuleContext(ConstructorDeclarationContext.class, 0); - } - - public GenericConstructorDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_genericConstructorDeclaration; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterGenericConstructorDeclaration(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitGenericConstructorDeclaration(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitGenericConstructorDeclaration(this); - else return visitor.visitChildren(this); - } - } - public final GenericConstructorDeclarationContext genericConstructorDeclaration() throws RecognitionException { GenericConstructorDeclarationContext _localctx = @@ -3303,58 +2632,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class ConstructorDeclarationContext extends ParserRuleContext { - public BlockContext constructorBody; - - public TerminalNode IDENTIFIER() { - return getToken(JavaParser.IDENTIFIER, 0); - } - - public FormalParametersContext formalParameters() { - return getRuleContext(FormalParametersContext.class, 0); - } - - public BlockContext block() { - return getRuleContext(BlockContext.class, 0); - } - - public TerminalNode THROWS() { - return getToken(JavaParser.THROWS, 0); - } - - public QualifiedNameListContext qualifiedNameList() { - return getRuleContext(QualifiedNameListContext.class, 0); - } - - public ConstructorDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_constructorDeclaration; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterConstructorDeclaration(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitConstructorDeclaration(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitConstructorDeclaration(this); - else return visitor.visitChildren(this); - } - } - public final ConstructorDeclarationContext constructorDeclaration() throws RecognitionException { ConstructorDeclarationContext _localctx = new ConstructorDeclarationContext(_ctx, getState()); enterRule(_localctx, 50, RULE_constructorDeclaration); @@ -3391,48 +2668,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class FieldDeclarationContext extends ParserRuleContext { - public TypeTypeContext typeType() { - return getRuleContext(TypeTypeContext.class, 0); - } - - public VariableDeclaratorsContext variableDeclarators() { - return getRuleContext(VariableDeclaratorsContext.class, 0); - } - - public TerminalNode SEMI() { - return getToken(JavaParser.SEMI, 0); - } - - public FieldDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_fieldDeclaration; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterFieldDeclaration(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitFieldDeclaration(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitFieldDeclaration(this); - else return visitor.visitChildren(this); - } - } - public final FieldDeclarationContext fieldDeclaration() throws RecognitionException { FieldDeclarationContext _localctx = new FieldDeclarationContext(_ctx, getState()); enterRule(_localctx, 52, RULE_fieldDeclaration); @@ -3456,52 +2691,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class InterfaceBodyDeclarationContext extends ParserRuleContext { - public InterfaceMemberDeclarationContext interfaceMemberDeclaration() { - return getRuleContext(InterfaceMemberDeclarationContext.class, 0); - } - - public List modifier() { - return getRuleContexts(ModifierContext.class); - } - - public ModifierContext modifier(int i) { - return getRuleContext(ModifierContext.class, i); - } - - public TerminalNode SEMI() { - return getToken(JavaParser.SEMI, 0); - } - - public InterfaceBodyDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_interfaceBodyDeclaration; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterInterfaceBodyDeclaration(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitInterfaceBodyDeclaration(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitInterfaceBodyDeclaration(this); - else return visitor.visitChildren(this); - } - } - public final InterfaceBodyDeclarationContext interfaceBodyDeclaration() throws RecognitionException { InterfaceBodyDeclarationContext _localctx = @@ -3581,64 +2770,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class InterfaceMemberDeclarationContext extends ParserRuleContext { - public ConstDeclarationContext constDeclaration() { - return getRuleContext(ConstDeclarationContext.class, 0); - } - - public InterfaceMethodDeclarationContext interfaceMethodDeclaration() { - return getRuleContext(InterfaceMethodDeclarationContext.class, 0); - } - - public GenericInterfaceMethodDeclarationContext genericInterfaceMethodDeclaration() { - return getRuleContext(GenericInterfaceMethodDeclarationContext.class, 0); - } - - public InterfaceDeclarationContext interfaceDeclaration() { - return getRuleContext(InterfaceDeclarationContext.class, 0); - } - - public AnnotationTypeDeclarationContext annotationTypeDeclaration() { - return getRuleContext(AnnotationTypeDeclarationContext.class, 0); - } - - public ClassDeclarationContext classDeclaration() { - return getRuleContext(ClassDeclarationContext.class, 0); - } - - public EnumDeclarationContext enumDeclaration() { - return getRuleContext(EnumDeclarationContext.class, 0); - } - - public InterfaceMemberDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_interfaceMemberDeclaration; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterInterfaceMemberDeclaration(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitInterfaceMemberDeclaration(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitInterfaceMemberDeclaration(this); - else return visitor.visitChildren(this); - } - } - public final InterfaceMemberDeclarationContext interfaceMemberDeclaration() throws RecognitionException { InterfaceMemberDeclarationContext _localctx = @@ -3708,60 +2839,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class ConstDeclarationContext extends ParserRuleContext { - public TypeTypeContext typeType() { - return getRuleContext(TypeTypeContext.class, 0); - } - - public List constantDeclarator() { - return getRuleContexts(ConstantDeclaratorContext.class); - } - - public ConstantDeclaratorContext constantDeclarator(int i) { - return getRuleContext(ConstantDeclaratorContext.class, i); - } - - public TerminalNode SEMI() { - return getToken(JavaParser.SEMI, 0); - } - - public List COMMA() { - return getTokens(JavaParser.COMMA); - } - - public TerminalNode COMMA(int i) { - return getToken(JavaParser.COMMA, i); - } - - public ConstDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_constDeclaration; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterConstDeclaration(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitConstDeclaration(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitConstDeclaration(this); - else return visitor.visitChildren(this); - } - } - public final ConstDeclarationContext constDeclaration() throws RecognitionException { ConstDeclarationContext _localctx = new ConstDeclarationContext(_ctx, getState()); enterRule(_localctx, 58, RULE_constDeclaration); @@ -3802,64 +2879,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class ConstantDeclaratorContext extends ParserRuleContext { - public TerminalNode IDENTIFIER() { - return getToken(JavaParser.IDENTIFIER, 0); - } - - public TerminalNode ASSIGN() { - return getToken(JavaParser.ASSIGN, 0); - } - - public VariableInitializerContext variableInitializer() { - return getRuleContext(VariableInitializerContext.class, 0); - } - - public List LBRACK() { - return getTokens(JavaParser.LBRACK); - } - - public TerminalNode LBRACK(int i) { - return getToken(JavaParser.LBRACK, i); - } - - public List RBRACK() { - return getTokens(JavaParser.RBRACK); - } - - public TerminalNode RBRACK(int i) { - return getToken(JavaParser.RBRACK, i); - } - - public ConstantDeclaratorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_constantDeclarator; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterConstantDeclarator(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitConstantDeclarator(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitConstantDeclarator(this); - else return visitor.visitChildren(this); - } - } - public final ConstantDeclaratorContext constantDeclarator() throws RecognitionException { ConstantDeclaratorContext _localctx = new ConstantDeclaratorContext(_ctx, getState()); enterRule(_localctx, 60, RULE_constantDeclarator); @@ -3900,96 +2919,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class InterfaceMethodDeclarationContext extends ParserRuleContext { - public TerminalNode IDENTIFIER() { - return getToken(JavaParser.IDENTIFIER, 0); - } - - public FormalParametersContext formalParameters() { - return getRuleContext(FormalParametersContext.class, 0); - } - - public MethodBodyContext methodBody() { - return getRuleContext(MethodBodyContext.class, 0); - } - - public TypeTypeOrVoidContext typeTypeOrVoid() { - return getRuleContext(TypeTypeOrVoidContext.class, 0); - } - - public TypeParametersContext typeParameters() { - return getRuleContext(TypeParametersContext.class, 0); - } - - public List interfaceMethodModifier() { - return getRuleContexts(InterfaceMethodModifierContext.class); - } - - public InterfaceMethodModifierContext interfaceMethodModifier(int i) { - return getRuleContext(InterfaceMethodModifierContext.class, i); - } - - public List LBRACK() { - return getTokens(JavaParser.LBRACK); - } - - public TerminalNode LBRACK(int i) { - return getToken(JavaParser.LBRACK, i); - } - - public List RBRACK() { - return getTokens(JavaParser.RBRACK); - } - - public TerminalNode RBRACK(int i) { - return getToken(JavaParser.RBRACK, i); - } - - public TerminalNode THROWS() { - return getToken(JavaParser.THROWS, 0); - } - - public QualifiedNameListContext qualifiedNameList() { - return getRuleContext(QualifiedNameListContext.class, 0); - } - - public List annotation() { - return getRuleContexts(AnnotationContext.class); - } - - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class, i); - } - - public InterfaceMethodDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_interfaceMethodDeclaration; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterInterfaceMethodDeclaration(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitInterfaceMethodDeclaration(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitInterfaceMethodDeclaration(this); - else return visitor.visitChildren(this); - } - } - public final InterfaceMethodDeclarationContext interfaceMethodDeclaration() throws RecognitionException { InterfaceMethodDeclarationContext _localctx = @@ -4107,60 +3036,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class InterfaceMethodModifierContext extends ParserRuleContext { - public AnnotationContext annotation() { - return getRuleContext(AnnotationContext.class, 0); - } - - public TerminalNode PUBLIC() { - return getToken(JavaParser.PUBLIC, 0); - } - - public TerminalNode ABSTRACT() { - return getToken(JavaParser.ABSTRACT, 0); - } - - public TerminalNode DEFAULT() { - return getToken(JavaParser.DEFAULT, 0); - } - - public TerminalNode STATIC() { - return getToken(JavaParser.STATIC, 0); - } - - public TerminalNode STRICTFP() { - return getToken(JavaParser.STRICTFP, 0); - } - - public InterfaceMethodModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_interfaceMethodModifier; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterInterfaceMethodModifier(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitInterfaceMethodModifier(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitInterfaceMethodModifier(this); - else return visitor.visitChildren(this); - } - } - public final InterfaceMethodModifierContext interfaceMethodModifier() throws RecognitionException { InterfaceMethodModifierContext _localctx = new InterfaceMethodModifierContext(_ctx, getState()); @@ -4225,45 +3100,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class GenericInterfaceMethodDeclarationContext extends ParserRuleContext { - public TypeParametersContext typeParameters() { - return getRuleContext(TypeParametersContext.class, 0); - } - - public InterfaceMethodDeclarationContext interfaceMethodDeclaration() { - return getRuleContext(InterfaceMethodDeclarationContext.class, 0); - } - - public GenericInterfaceMethodDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_genericInterfaceMethodDeclaration; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterGenericInterfaceMethodDeclaration(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitGenericInterfaceMethodDeclaration(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor) - .visitGenericInterfaceMethodDeclaration(this); - else return visitor.visitChildren(this); - } - } - public final GenericInterfaceMethodDeclarationContext genericInterfaceMethodDeclaration() throws RecognitionException { GenericInterfaceMethodDeclarationContext _localctx = @@ -4287,52 +3123,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class VariableDeclaratorsContext extends ParserRuleContext { - public List variableDeclarator() { - return getRuleContexts(VariableDeclaratorContext.class); - } - - public VariableDeclaratorContext variableDeclarator(int i) { - return getRuleContext(VariableDeclaratorContext.class, i); - } - - public List COMMA() { - return getTokens(JavaParser.COMMA); - } - - public TerminalNode COMMA(int i) { - return getToken(JavaParser.COMMA, i); - } - - public VariableDeclaratorsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_variableDeclarators; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterVariableDeclarators(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitVariableDeclarators(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitVariableDeclarators(this); - else return visitor.visitChildren(this); - } - } - public final VariableDeclaratorsContext variableDeclarators() throws RecognitionException { VariableDeclaratorsContext _localctx = new VariableDeclaratorsContext(_ctx, getState()); enterRule(_localctx, 68, RULE_variableDeclarators); @@ -4369,48 +3159,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class VariableDeclaratorContext extends ParserRuleContext { - public VariableDeclaratorIdContext variableDeclaratorId() { - return getRuleContext(VariableDeclaratorIdContext.class, 0); - } - - public TerminalNode ASSIGN() { - return getToken(JavaParser.ASSIGN, 0); - } - - public VariableInitializerContext variableInitializer() { - return getRuleContext(VariableInitializerContext.class, 0); - } - - public VariableDeclaratorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_variableDeclarator; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterVariableDeclarator(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitVariableDeclarator(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitVariableDeclarator(this); - else return visitor.visitChildren(this); - } - } - public final VariableDeclaratorContext variableDeclarator() throws RecognitionException { VariableDeclaratorContext _localctx = new VariableDeclaratorContext(_ctx, getState()); enterRule(_localctx, 70, RULE_variableDeclarator); @@ -4442,56 +3190,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class VariableDeclaratorIdContext extends ParserRuleContext { - public TerminalNode IDENTIFIER() { - return getToken(JavaParser.IDENTIFIER, 0); - } - - public List LBRACK() { - return getTokens(JavaParser.LBRACK); - } - - public TerminalNode LBRACK(int i) { - return getToken(JavaParser.LBRACK, i); - } - - public List RBRACK() { - return getTokens(JavaParser.RBRACK); - } - - public TerminalNode RBRACK(int i) { - return getToken(JavaParser.RBRACK, i); - } - - public VariableDeclaratorIdContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_variableDeclaratorId; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterVariableDeclaratorId(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitVariableDeclaratorId(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitVariableDeclaratorId(this); - else return visitor.visitChildren(this); - } - } - public final VariableDeclaratorIdContext variableDeclaratorId() throws RecognitionException { VariableDeclaratorIdContext _localctx = new VariableDeclaratorIdContext(_ctx, getState()); enterRule(_localctx, 72, RULE_variableDeclaratorId); @@ -4528,44 +3226,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class VariableInitializerContext extends ParserRuleContext { - public ArrayInitializerContext arrayInitializer() { - return getRuleContext(ArrayInitializerContext.class, 0); - } - - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class, 0); - } - - public VariableInitializerContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_variableInitializer; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterVariableInitializer(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitVariableInitializer(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitVariableInitializer(this); - else return visitor.visitChildren(this); - } - } - public final VariableInitializerContext variableInitializer() throws RecognitionException { VariableInitializerContext _localctx = new VariableInitializerContext(_ctx, getState()); enterRule(_localctx, 74, RULE_variableInitializer); @@ -4631,60 +3291,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class ArrayInitializerContext extends ParserRuleContext { - public TerminalNode LBRACE() { - return getToken(JavaParser.LBRACE, 0); - } - - public TerminalNode RBRACE() { - return getToken(JavaParser.RBRACE, 0); - } - - public List variableInitializer() { - return getRuleContexts(VariableInitializerContext.class); - } - - public VariableInitializerContext variableInitializer(int i) { - return getRuleContext(VariableInitializerContext.class, i); - } - - public List COMMA() { - return getTokens(JavaParser.COMMA); - } - - public TerminalNode COMMA(int i) { - return getToken(JavaParser.COMMA, i); - } - - public ArrayInitializerContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_arrayInitializer; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterArrayInitializer(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitArrayInitializer(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitArrayInitializer(this); - else return visitor.visitChildren(this); - } - } - public final ArrayInitializerContext arrayInitializer() throws RecognitionException { ArrayInitializerContext _localctx = new ArrayInitializerContext(_ctx, getState()); enterRule(_localctx, 76, RULE_arrayInitializer); @@ -4783,60 +3389,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class ClassOrInterfaceTypeContext extends ParserRuleContext { - public List IDENTIFIER() { - return getTokens(JavaParser.IDENTIFIER); - } - - public TerminalNode IDENTIFIER(int i) { - return getToken(JavaParser.IDENTIFIER, i); - } - - public List typeArguments() { - return getRuleContexts(TypeArgumentsContext.class); - } - - public TypeArgumentsContext typeArguments(int i) { - return getRuleContext(TypeArgumentsContext.class, i); - } - - public List DOT() { - return getTokens(JavaParser.DOT); - } - - public TerminalNode DOT(int i) { - return getToken(JavaParser.DOT, i); - } - - public ClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_classOrInterfaceType; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterClassOrInterfaceType(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitClassOrInterfaceType(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitClassOrInterfaceType(this); - else return visitor.visitChildren(this); - } - } - public final ClassOrInterfaceTypeContext classOrInterfaceType() throws RecognitionException { ClassOrInterfaceTypeContext _localctx = new ClassOrInterfaceTypeContext(_ctx, getState()); enterRule(_localctx, 78, RULE_classOrInterfaceType); @@ -4895,60 +3447,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class TypeArgumentContext extends ParserRuleContext { - public TypeTypeContext typeType() { - return getRuleContext(TypeTypeContext.class, 0); - } - - public TerminalNode QUESTION() { - return getToken(JavaParser.QUESTION, 0); - } - - public List annotation() { - return getRuleContexts(AnnotationContext.class); - } - - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class, i); - } - - public TerminalNode EXTENDS() { - return getToken(JavaParser.EXTENDS, 0); - } - - public TerminalNode SUPER() { - return getToken(JavaParser.SUPER, 0); - } - - public TypeArgumentContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_typeArgument; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterTypeArgument(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitTypeArgument(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitTypeArgument(this); - else return visitor.visitChildren(this); - } - } - public final TypeArgumentContext typeArgument() throws RecognitionException { TypeArgumentContext _localctx = new TypeArgumentContext(_ctx, getState()); enterRule(_localctx, 80, RULE_typeArgument); @@ -5014,52 +3512,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class QualifiedNameListContext extends ParserRuleContext { - public List qualifiedName() { - return getRuleContexts(QualifiedNameContext.class); - } - - public QualifiedNameContext qualifiedName(int i) { - return getRuleContext(QualifiedNameContext.class, i); - } - - public List COMMA() { - return getTokens(JavaParser.COMMA); - } - - public TerminalNode COMMA(int i) { - return getToken(JavaParser.COMMA, i); - } - - public QualifiedNameListContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_qualifiedNameList; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterQualifiedNameList(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitQualifiedNameList(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitQualifiedNameList(this); - else return visitor.visitChildren(this); - } - } - public final QualifiedNameListContext qualifiedNameList() throws RecognitionException { QualifiedNameListContext _localctx = new QualifiedNameListContext(_ctx, getState()); enterRule(_localctx, 82, RULE_qualifiedNameList); @@ -5096,48 +3548,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class FormalParametersContext extends ParserRuleContext { - public TerminalNode LPAREN() { - return getToken(JavaParser.LPAREN, 0); - } - - public TerminalNode RPAREN() { - return getToken(JavaParser.RPAREN, 0); - } - - public FormalParameterListContext formalParameterList() { - return getRuleContext(FormalParameterListContext.class, 0); - } - - public FormalParametersContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_formalParameters; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterFormalParameters(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitFormalParameters(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitFormalParameters(this); - else return visitor.visitChildren(this); - } - } - public final FormalParametersContext formalParameters() throws RecognitionException { FormalParametersContext _localctx = new FormalParametersContext(_ctx, getState()); enterRule(_localctx, 84, RULE_formalParameters); @@ -5183,56 +3593,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class FormalParameterListContext extends ParserRuleContext { - public List formalParameter() { - return getRuleContexts(FormalParameterContext.class); - } - - public FormalParameterContext formalParameter(int i) { - return getRuleContext(FormalParameterContext.class, i); - } - - public List COMMA() { - return getTokens(JavaParser.COMMA); - } - - public TerminalNode COMMA(int i) { - return getToken(JavaParser.COMMA, i); - } - - public LastFormalParameterContext lastFormalParameter() { - return getRuleContext(LastFormalParameterContext.class, 0); - } - - public FormalParameterListContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_formalParameterList; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterFormalParameterList(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitFormalParameterList(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitFormalParameterList(this); - else return visitor.visitChildren(this); - } - } - public final FormalParameterListContext formalParameterList() throws RecognitionException { FormalParameterListContext _localctx = new FormalParameterListContext(_ctx, getState()); enterRule(_localctx, 86, RULE_formalParameterList); @@ -5296,52 +3656,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class FormalParameterContext extends ParserRuleContext { - public TypeTypeContext typeType() { - return getRuleContext(TypeTypeContext.class, 0); - } - - public VariableDeclaratorIdContext variableDeclaratorId() { - return getRuleContext(VariableDeclaratorIdContext.class, 0); - } - - public List variableModifier() { - return getRuleContexts(VariableModifierContext.class); - } - - public VariableModifierContext variableModifier(int i) { - return getRuleContext(VariableModifierContext.class, i); - } - - public FormalParameterContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_formalParameter; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterFormalParameter(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitFormalParameter(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitFormalParameter(this); - else return visitor.visitChildren(this); - } - } - public final FormalParameterContext formalParameter() throws RecognitionException { FormalParameterContext _localctx = new FormalParameterContext(_ctx, getState()); enterRule(_localctx, 88, RULE_formalParameter); @@ -5380,64 +3694,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class LastFormalParameterContext extends ParserRuleContext { - public TypeTypeContext typeType() { - return getRuleContext(TypeTypeContext.class, 0); - } - - public TerminalNode ELLIPSIS() { - return getToken(JavaParser.ELLIPSIS, 0); - } - - public VariableDeclaratorIdContext variableDeclaratorId() { - return getRuleContext(VariableDeclaratorIdContext.class, 0); - } - - public List variableModifier() { - return getRuleContexts(VariableModifierContext.class); - } - - public VariableModifierContext variableModifier(int i) { - return getRuleContext(VariableModifierContext.class, i); - } - - public List annotation() { - return getRuleContexts(AnnotationContext.class); - } - - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class, i); - } - - public LastFormalParameterContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_lastFormalParameter; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterLastFormalParameter(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitLastFormalParameter(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitLastFormalParameter(this); - else return visitor.visitChildren(this); - } - } - public final LastFormalParameterContext lastFormalParameter() throws RecognitionException { LastFormalParameterContext _localctx = new LastFormalParameterContext(_ctx, getState()); enterRule(_localctx, 90, RULE_lastFormalParameter); @@ -5493,52 +3749,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class QualifiedNameContext extends ParserRuleContext { - public List IDENTIFIER() { - return getTokens(JavaParser.IDENTIFIER); - } - - public TerminalNode IDENTIFIER(int i) { - return getToken(JavaParser.IDENTIFIER, i); - } - - public List DOT() { - return getTokens(JavaParser.DOT); - } - - public TerminalNode DOT(int i) { - return getToken(JavaParser.DOT, i); - } - - public QualifiedNameContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_qualifiedName; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterQualifiedName(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitQualifiedName(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitQualifiedName(this); - else return visitor.visitChildren(this); - } - } - public final QualifiedNameContext qualifiedName() throws RecognitionException { QualifiedNameContext _localctx = new QualifiedNameContext(_ctx, getState()); enterRule(_localctx, 92, RULE_qualifiedName); @@ -5577,59 +3787,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class LiteralContext extends ParserRuleContext { - public IntegerLiteralContext integerLiteral() { - return getRuleContext(IntegerLiteralContext.class, 0); - } - - public FloatLiteralContext floatLiteral() { - return getRuleContext(FloatLiteralContext.class, 0); - } - - public TerminalNode CHAR_LITERAL() { - return getToken(JavaParser.CHAR_LITERAL, 0); - } - - public TerminalNode STRING_LITERAL() { - return getToken(JavaParser.STRING_LITERAL, 0); - } - - public TerminalNode BOOL_LITERAL() { - return getToken(JavaParser.BOOL_LITERAL, 0); - } - - public TerminalNode NULL_LITERAL() { - return getToken(JavaParser.NULL_LITERAL, 0); - } - - public LiteralContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_literal; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterLiteral(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) ((JavaParserListener) listener).exitLiteral(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitLiteral(this); - else return visitor.visitChildren(this); - } - } - public final LiteralContext literal() throws RecognitionException { LiteralContext _localctx = new LiteralContext(_ctx, getState()); enterRule(_localctx, 94, RULE_literal); @@ -5696,52 +3853,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class IntegerLiteralContext extends ParserRuleContext { - public TerminalNode DECIMAL_LITERAL() { - return getToken(JavaParser.DECIMAL_LITERAL, 0); - } - - public TerminalNode HEX_LITERAL() { - return getToken(JavaParser.HEX_LITERAL, 0); - } - - public TerminalNode OCT_LITERAL() { - return getToken(JavaParser.OCT_LITERAL, 0); - } - - public TerminalNode BINARY_LITERAL() { - return getToken(JavaParser.BINARY_LITERAL, 0); - } - - public IntegerLiteralContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_integerLiteral; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterIntegerLiteral(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitIntegerLiteral(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitIntegerLiteral(this); - else return visitor.visitChildren(this); - } - } - public final IntegerLiteralContext integerLiteral() throws RecognitionException { IntegerLiteralContext _localctx = new IntegerLiteralContext(_ctx, getState()); enterRule(_localctx, 96, RULE_integerLiteral); @@ -5775,44 +3886,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class FloatLiteralContext extends ParserRuleContext { - public TerminalNode FLOAT_LITERAL() { - return getToken(JavaParser.FLOAT_LITERAL, 0); - } - - public TerminalNode HEX_FLOAT_LITERAL() { - return getToken(JavaParser.HEX_FLOAT_LITERAL, 0); - } - - public FloatLiteralContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_floatLiteral; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterFloatLiteral(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitFloatLiteral(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitFloatLiteral(this); - else return visitor.visitChildren(this); - } - } - public final FloatLiteralContext floatLiteral() throws RecognitionException { FloatLiteralContext _localctx = new FloatLiteralContext(_ctx, getState()); enterRule(_localctx, 98, RULE_floatLiteral); @@ -5840,56 +3913,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class AltAnnotationQualifiedNameContext extends ParserRuleContext { - public TerminalNode AT() { - return getToken(JavaParser.AT, 0); - } - - public List IDENTIFIER() { - return getTokens(JavaParser.IDENTIFIER); - } - - public TerminalNode IDENTIFIER(int i) { - return getToken(JavaParser.IDENTIFIER, i); - } - - public List DOT() { - return getTokens(JavaParser.DOT); - } - - public TerminalNode DOT(int i) { - return getToken(JavaParser.DOT, i); - } - - public AltAnnotationQualifiedNameContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_altAnnotationQualifiedName; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterAltAnnotationQualifiedName(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitAltAnnotationQualifiedName(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitAltAnnotationQualifiedName(this); - else return visitor.visitChildren(this); - } - } - public final AltAnnotationQualifiedNameContext altAnnotationQualifiedName() throws RecognitionException { AltAnnotationQualifiedNameContext _localctx = @@ -5930,64 +3953,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class AnnotationContext extends ParserRuleContext { - public TerminalNode AT() { - return getToken(JavaParser.AT, 0); - } - - public QualifiedNameContext qualifiedName() { - return getRuleContext(QualifiedNameContext.class, 0); - } - - public AltAnnotationQualifiedNameContext altAnnotationQualifiedName() { - return getRuleContext(AltAnnotationQualifiedNameContext.class, 0); - } - - public TerminalNode LPAREN() { - return getToken(JavaParser.LPAREN, 0); - } - - public TerminalNode RPAREN() { - return getToken(JavaParser.RPAREN, 0); - } - - public ElementValuePairsContext elementValuePairs() { - return getRuleContext(ElementValuePairsContext.class, 0); - } - - public ElementValueContext elementValue() { - return getRuleContext(ElementValueContext.class, 0); - } - - public AnnotationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_annotation; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterAnnotation(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitAnnotation(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitAnnotation(this); - else return visitor.visitChildren(this); - } - } - public final AnnotationContext annotation() throws RecognitionException { AnnotationContext _localctx = new AnnotationContext(_ctx, getState()); enterRule(_localctx, 102, RULE_annotation); @@ -6051,52 +4016,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class ElementValuePairsContext extends ParserRuleContext { - public List elementValuePair() { - return getRuleContexts(ElementValuePairContext.class); - } - - public ElementValuePairContext elementValuePair(int i) { - return getRuleContext(ElementValuePairContext.class, i); - } - - public List COMMA() { - return getTokens(JavaParser.COMMA); - } - - public TerminalNode COMMA(int i) { - return getToken(JavaParser.COMMA, i); - } - - public ElementValuePairsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_elementValuePairs; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterElementValuePairs(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitElementValuePairs(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitElementValuePairs(this); - else return visitor.visitChildren(this); - } - } - public final ElementValuePairsContext elementValuePairs() throws RecognitionException { ElementValuePairsContext _localctx = new ElementValuePairsContext(_ctx, getState()); enterRule(_localctx, 104, RULE_elementValuePairs); @@ -6133,48 +4052,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class ElementValuePairContext extends ParserRuleContext { - public TerminalNode IDENTIFIER() { - return getToken(JavaParser.IDENTIFIER, 0); - } - - public TerminalNode ASSIGN() { - return getToken(JavaParser.ASSIGN, 0); - } - - public ElementValueContext elementValue() { - return getRuleContext(ElementValueContext.class, 0); - } - - public ElementValuePairContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_elementValuePair; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterElementValuePair(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitElementValuePair(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitElementValuePair(this); - else return visitor.visitChildren(this); - } - } - public final ElementValuePairContext elementValuePair() throws RecognitionException { ElementValuePairContext _localctx = new ElementValuePairContext(_ctx, getState()); enterRule(_localctx, 106, RULE_elementValuePair); @@ -6198,48 +4075,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class ElementValueContext extends ParserRuleContext { - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class, 0); - } - - public AnnotationContext annotation() { - return getRuleContext(AnnotationContext.class, 0); - } - - public ElementValueArrayInitializerContext elementValueArrayInitializer() { - return getRuleContext(ElementValueArrayInitializerContext.class, 0); - } - - public ElementValueContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_elementValue; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterElementValue(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitElementValue(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitElementValue(this); - else return visitor.visitChildren(this); - } - } - public final ElementValueContext elementValue() throws RecognitionException { ElementValueContext _localctx = new ElementValueContext(_ctx, getState()); enterRule(_localctx, 108, RULE_elementValue); @@ -6279,60 +4114,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class ElementValueArrayInitializerContext extends ParserRuleContext { - public TerminalNode LBRACE() { - return getToken(JavaParser.LBRACE, 0); - } - - public TerminalNode RBRACE() { - return getToken(JavaParser.RBRACE, 0); - } - - public List elementValue() { - return getRuleContexts(ElementValueContext.class); - } - - public ElementValueContext elementValue(int i) { - return getRuleContext(ElementValueContext.class, i); - } - - public List COMMA() { - return getTokens(JavaParser.COMMA); - } - - public TerminalNode COMMA(int i) { - return getToken(JavaParser.COMMA, i); - } - - public ElementValueArrayInitializerContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_elementValueArrayInitializer; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterElementValueArrayInitializer(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitElementValueArrayInitializer(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitElementValueArrayInitializer(this); - else return visitor.visitChildren(this); - } - } - public final ElementValueArrayInitializerContext elementValueArrayInitializer() throws RecognitionException { ElementValueArrayInitializerContext _localctx = @@ -6434,52 +4215,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class AnnotationTypeDeclarationContext extends ParserRuleContext { - public TerminalNode AT() { - return getToken(JavaParser.AT, 0); - } - - public TerminalNode INTERFACE() { - return getToken(JavaParser.INTERFACE, 0); - } - - public TerminalNode IDENTIFIER() { - return getToken(JavaParser.IDENTIFIER, 0); - } - - public AnnotationTypeBodyContext annotationTypeBody() { - return getRuleContext(AnnotationTypeBodyContext.class, 0); - } - - public AnnotationTypeDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_annotationTypeDeclaration; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterAnnotationTypeDeclaration(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitAnnotationTypeDeclaration(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitAnnotationTypeDeclaration(this); - else return visitor.visitChildren(this); - } - } - public final AnnotationTypeDeclarationContext annotationTypeDeclaration() throws RecognitionException { AnnotationTypeDeclarationContext _localctx = @@ -6507,52 +4242,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class AnnotationTypeBodyContext extends ParserRuleContext { - public TerminalNode LBRACE() { - return getToken(JavaParser.LBRACE, 0); - } - - public TerminalNode RBRACE() { - return getToken(JavaParser.RBRACE, 0); - } - - public List annotationTypeElementDeclaration() { - return getRuleContexts(AnnotationTypeElementDeclarationContext.class); - } - - public AnnotationTypeElementDeclarationContext annotationTypeElementDeclaration(int i) { - return getRuleContext(AnnotationTypeElementDeclarationContext.class, i); - } - - public AnnotationTypeBodyContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_annotationTypeBody; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterAnnotationTypeBody(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitAnnotationTypeBody(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitAnnotationTypeBody(this); - else return visitor.visitChildren(this); - } - } - public final AnnotationTypeBodyContext annotationTypeBody() throws RecognitionException { AnnotationTypeBodyContext _localctx = new AnnotationTypeBodyContext(_ctx, getState()); enterRule(_localctx, 114, RULE_annotationTypeBody); @@ -6617,53 +4306,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class AnnotationTypeElementDeclarationContext extends ParserRuleContext { - public AnnotationTypeElementRestContext annotationTypeElementRest() { - return getRuleContext(AnnotationTypeElementRestContext.class, 0); - } - - public List modifier() { - return getRuleContexts(ModifierContext.class); - } - - public ModifierContext modifier(int i) { - return getRuleContext(ModifierContext.class, i); - } - - public TerminalNode SEMI() { - return getToken(JavaParser.SEMI, 0); - } - - public AnnotationTypeElementDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_annotationTypeElementDeclaration; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterAnnotationTypeElementDeclaration(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitAnnotationTypeElementDeclaration(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor) - .visitAnnotationTypeElementDeclaration(this); - else return visitor.visitChildren(this); - } - } - public final AnnotationTypeElementDeclarationContext annotationTypeElementDeclaration() throws RecognitionException { AnnotationTypeElementDeclarationContext _localctx = @@ -6740,64 +4382,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class AnnotationTypeElementRestContext extends ParserRuleContext { - public TypeTypeContext typeType() { - return getRuleContext(TypeTypeContext.class, 0); - } - - public AnnotationMethodOrConstantRestContext annotationMethodOrConstantRest() { - return getRuleContext(AnnotationMethodOrConstantRestContext.class, 0); - } - - public TerminalNode SEMI() { - return getToken(JavaParser.SEMI, 0); - } - - public ClassDeclarationContext classDeclaration() { - return getRuleContext(ClassDeclarationContext.class, 0); - } - - public InterfaceDeclarationContext interfaceDeclaration() { - return getRuleContext(InterfaceDeclarationContext.class, 0); - } - - public EnumDeclarationContext enumDeclaration() { - return getRuleContext(EnumDeclarationContext.class, 0); - } - - public AnnotationTypeDeclarationContext annotationTypeDeclaration() { - return getRuleContext(AnnotationTypeDeclarationContext.class, 0); - } - - public AnnotationTypeElementRestContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_annotationTypeElementRest; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterAnnotationTypeElementRest(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitAnnotationTypeElementRest(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitAnnotationTypeElementRest(this); - else return visitor.visitChildren(this); - } - } - public final AnnotationTypeElementRestContext annotationTypeElementRest() throws RecognitionException { AnnotationTypeElementRestContext _localctx = @@ -6897,44 +4481,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class AnnotationMethodOrConstantRestContext extends ParserRuleContext { - public AnnotationMethodRestContext annotationMethodRest() { - return getRuleContext(AnnotationMethodRestContext.class, 0); - } - - public AnnotationConstantRestContext annotationConstantRest() { - return getRuleContext(AnnotationConstantRestContext.class, 0); - } - - public AnnotationMethodOrConstantRestContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_annotationMethodOrConstantRest; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterAnnotationMethodOrConstantRest(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitAnnotationMethodOrConstantRest(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitAnnotationMethodOrConstantRest(this); - else return visitor.visitChildren(this); - } - } - public final AnnotationMethodOrConstantRestContext annotationMethodOrConstantRest() throws RecognitionException { AnnotationMethodOrConstantRestContext _localctx = @@ -6969,52 +4515,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class AnnotationMethodRestContext extends ParserRuleContext { - public TerminalNode IDENTIFIER() { - return getToken(JavaParser.IDENTIFIER, 0); - } - - public TerminalNode LPAREN() { - return getToken(JavaParser.LPAREN, 0); - } - - public TerminalNode RPAREN() { - return getToken(JavaParser.RPAREN, 0); - } - - public DefaultValueContext defaultValue() { - return getRuleContext(DefaultValueContext.class, 0); - } - - public AnnotationMethodRestContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_annotationMethodRest; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterAnnotationMethodRest(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitAnnotationMethodRest(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitAnnotationMethodRest(this); - else return visitor.visitChildren(this); - } - } - public final AnnotationMethodRestContext annotationMethodRest() throws RecognitionException { AnnotationMethodRestContext _localctx = new AnnotationMethodRestContext(_ctx, getState()); enterRule(_localctx, 122, RULE_annotationMethodRest); @@ -7048,40 +4548,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class AnnotationConstantRestContext extends ParserRuleContext { - public VariableDeclaratorsContext variableDeclarators() { - return getRuleContext(VariableDeclaratorsContext.class, 0); - } - - public AnnotationConstantRestContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_annotationConstantRest; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterAnnotationConstantRest(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitAnnotationConstantRest(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitAnnotationConstantRest(this); - else return visitor.visitChildren(this); - } - } - public final AnnotationConstantRestContext annotationConstantRest() throws RecognitionException { AnnotationConstantRestContext _localctx = new AnnotationConstantRestContext(_ctx, getState()); enterRule(_localctx, 124, RULE_annotationConstantRest); @@ -7101,44 +4567,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class DefaultValueContext extends ParserRuleContext { - public TerminalNode DEFAULT() { - return getToken(JavaParser.DEFAULT, 0); - } - - public ElementValueContext elementValue() { - return getRuleContext(ElementValueContext.class, 0); - } - - public DefaultValueContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_defaultValue; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterDefaultValue(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitDefaultValue(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitDefaultValue(this); - else return visitor.visitChildren(this); - } - } - public final DefaultValueContext defaultValue() throws RecognitionException { DefaultValueContext _localctx = new DefaultValueContext(_ctx, getState()); enterRule(_localctx, 126, RULE_defaultValue); @@ -7160,50 +4588,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class BlockContext extends ParserRuleContext { - public TerminalNode LBRACE() { - return getToken(JavaParser.LBRACE, 0); - } - - public TerminalNode RBRACE() { - return getToken(JavaParser.RBRACE, 0); - } - - public List blockStatement() { - return getRuleContexts(BlockStatementContext.class); - } - - public BlockStatementContext blockStatement(int i) { - return getRuleContext(BlockStatementContext.class, i); - } - - public BlockContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_block; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) ((JavaParserListener) listener).enterBlock(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) ((JavaParserListener) listener).exitBlock(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitBlock(this); - else return visitor.visitChildren(this); - } - } - public final BlockContext block() throws RecognitionException { BlockContext _localctx = new BlockContext(_ctx, getState()); enterRule(_localctx, 128, RULE_block); @@ -7300,52 +4684,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class BlockStatementContext extends ParserRuleContext { - public LocalVariableDeclarationContext localVariableDeclaration() { - return getRuleContext(LocalVariableDeclarationContext.class, 0); - } - - public TerminalNode SEMI() { - return getToken(JavaParser.SEMI, 0); - } - - public StatementContext statement() { - return getRuleContext(StatementContext.class, 0); - } - - public LocalTypeDeclarationContext localTypeDeclaration() { - return getRuleContext(LocalTypeDeclarationContext.class, 0); - } - - public BlockStatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_blockStatement; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterBlockStatement(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitBlockStatement(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitBlockStatement(this); - else return visitor.visitChildren(this); - } - } - public final BlockStatementContext blockStatement() throws RecognitionException { BlockStatementContext _localctx = new BlockStatementContext(_ctx, getState()); enterRule(_localctx, 130, RULE_blockStatement); @@ -7387,52 +4725,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class LocalVariableDeclarationContext extends ParserRuleContext { - public TypeTypeContext typeType() { - return getRuleContext(TypeTypeContext.class, 0); - } - - public VariableDeclaratorsContext variableDeclarators() { - return getRuleContext(VariableDeclaratorsContext.class, 0); - } - - public List variableModifier() { - return getRuleContexts(VariableModifierContext.class); - } - - public VariableModifierContext variableModifier(int i) { - return getRuleContext(VariableModifierContext.class, i); - } - - public LocalVariableDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_localVariableDeclaration; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterLocalVariableDeclaration(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitLocalVariableDeclaration(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitLocalVariableDeclaration(this); - else return visitor.visitChildren(this); - } - } - public final LocalVariableDeclarationContext localVariableDeclaration() throws RecognitionException { LocalVariableDeclarationContext _localctx = @@ -7473,56 +4765,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class LocalTypeDeclarationContext extends ParserRuleContext { - public ClassDeclarationContext classDeclaration() { - return getRuleContext(ClassDeclarationContext.class, 0); - } - - public InterfaceDeclarationContext interfaceDeclaration() { - return getRuleContext(InterfaceDeclarationContext.class, 0); - } - - public List classOrInterfaceModifier() { - return getRuleContexts(ClassOrInterfaceModifierContext.class); - } - - public ClassOrInterfaceModifierContext classOrInterfaceModifier(int i) { - return getRuleContext(ClassOrInterfaceModifierContext.class, i); - } - - public TerminalNode SEMI() { - return getToken(JavaParser.SEMI, 0); - } - - public LocalTypeDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_localTypeDeclaration; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterLocalTypeDeclaration(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitLocalTypeDeclaration(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitLocalTypeDeclaration(this); - else return visitor.visitChildren(this); - } - } - public final LocalTypeDeclarationContext localTypeDeclaration() throws RecognitionException { LocalTypeDeclarationContext _localctx = new LocalTypeDeclarationContext(_ctx, getState()); enterRule(_localctx, 134, RULE_localTypeDeclaration); @@ -7609,180 +4851,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class StatementContext extends ParserRuleContext { - public BlockContext blockLabel; - public ExpressionContext statementExpression; - public Token identifierLabel; - - public BlockContext block() { - return getRuleContext(BlockContext.class, 0); - } - - public TerminalNode ASSERT() { - return getToken(JavaParser.ASSERT, 0); - } - - public List expression() { - return getRuleContexts(ExpressionContext.class); - } - - public ExpressionContext expression(int i) { - return getRuleContext(ExpressionContext.class, i); - } - - public TerminalNode SEMI() { - return getToken(JavaParser.SEMI, 0); - } - - public TerminalNode COLON() { - return getToken(JavaParser.COLON, 0); - } - - public TerminalNode IF() { - return getToken(JavaParser.IF, 0); - } - - public ParExpressionContext parExpression() { - return getRuleContext(ParExpressionContext.class, 0); - } - - public List statement() { - return getRuleContexts(StatementContext.class); - } - - public StatementContext statement(int i) { - return getRuleContext(StatementContext.class, i); - } - - public TerminalNode ELSE() { - return getToken(JavaParser.ELSE, 0); - } - - public TerminalNode FOR() { - return getToken(JavaParser.FOR, 0); - } - - public TerminalNode LPAREN() { - return getToken(JavaParser.LPAREN, 0); - } - - public ForControlContext forControl() { - return getRuleContext(ForControlContext.class, 0); - } - - public TerminalNode RPAREN() { - return getToken(JavaParser.RPAREN, 0); - } - - public TerminalNode WHILE() { - return getToken(JavaParser.WHILE, 0); - } - - public TerminalNode DO() { - return getToken(JavaParser.DO, 0); - } - - public TerminalNode TRY() { - return getToken(JavaParser.TRY, 0); - } - - public FinallyBlockContext finallyBlock() { - return getRuleContext(FinallyBlockContext.class, 0); - } - - public List catchClause() { - return getRuleContexts(CatchClauseContext.class); - } - - public CatchClauseContext catchClause(int i) { - return getRuleContext(CatchClauseContext.class, i); - } - - public ResourceSpecificationContext resourceSpecification() { - return getRuleContext(ResourceSpecificationContext.class, 0); - } - - public TerminalNode SWITCH() { - return getToken(JavaParser.SWITCH, 0); - } - - public TerminalNode LBRACE() { - return getToken(JavaParser.LBRACE, 0); - } - - public TerminalNode RBRACE() { - return getToken(JavaParser.RBRACE, 0); - } - - public List switchBlockStatementGroup() { - return getRuleContexts(SwitchBlockStatementGroupContext.class); - } - - public SwitchBlockStatementGroupContext switchBlockStatementGroup(int i) { - return getRuleContext(SwitchBlockStatementGroupContext.class, i); - } - - public List switchLabel() { - return getRuleContexts(SwitchLabelContext.class); - } - - public SwitchLabelContext switchLabel(int i) { - return getRuleContext(SwitchLabelContext.class, i); - } - - public TerminalNode SYNCHRONIZED() { - return getToken(JavaParser.SYNCHRONIZED, 0); - } - - public TerminalNode RETURN() { - return getToken(JavaParser.RETURN, 0); - } - - public TerminalNode THROW() { - return getToken(JavaParser.THROW, 0); - } - - public TerminalNode BREAK() { - return getToken(JavaParser.BREAK, 0); - } - - public TerminalNode IDENTIFIER() { - return getToken(JavaParser.IDENTIFIER, 0); - } - - public TerminalNode CONTINUE() { - return getToken(JavaParser.CONTINUE, 0); - } - - public StatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_statement; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterStatement(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitStatement(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitStatement(this); - else return visitor.visitChildren(this); - } - } - public final StatementContext statement() throws RecognitionException { StatementContext _localctx = new StatementContext(_ctx, getState()); enterRule(_localctx, 136, RULE_statement); @@ -8165,68 +5233,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class CatchClauseContext extends ParserRuleContext { - public TerminalNode CATCH() { - return getToken(JavaParser.CATCH, 0); - } - - public TerminalNode LPAREN() { - return getToken(JavaParser.LPAREN, 0); - } - - public CatchTypeContext catchType() { - return getRuleContext(CatchTypeContext.class, 0); - } - - public TerminalNode IDENTIFIER() { - return getToken(JavaParser.IDENTIFIER, 0); - } - - public TerminalNode RPAREN() { - return getToken(JavaParser.RPAREN, 0); - } - - public BlockContext block() { - return getRuleContext(BlockContext.class, 0); - } - - public List variableModifier() { - return getRuleContexts(VariableModifierContext.class); - } - - public VariableModifierContext variableModifier(int i) { - return getRuleContext(VariableModifierContext.class, i); - } - - public CatchClauseContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_catchClause; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterCatchClause(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitCatchClause(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitCatchClause(this); - else return visitor.visitChildren(this); - } - } - public final CatchClauseContext catchClause() throws RecognitionException { CatchClauseContext _localctx = new CatchClauseContext(_ctx, getState()); enterRule(_localctx, 138, RULE_catchClause); @@ -8273,52 +5279,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class CatchTypeContext extends ParserRuleContext { - public List qualifiedName() { - return getRuleContexts(QualifiedNameContext.class); - } - - public QualifiedNameContext qualifiedName(int i) { - return getRuleContext(QualifiedNameContext.class, i); - } - - public List BITOR() { - return getTokens(JavaParser.BITOR); - } - - public TerminalNode BITOR(int i) { - return getToken(JavaParser.BITOR, i); - } - - public CatchTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_catchType; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterCatchType(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitCatchType(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitCatchType(this); - else return visitor.visitChildren(this); - } - } - public final CatchTypeContext catchType() throws RecognitionException { CatchTypeContext _localctx = new CatchTypeContext(_ctx, getState()); enterRule(_localctx, 140, RULE_catchType); @@ -8355,44 +5315,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class FinallyBlockContext extends ParserRuleContext { - public TerminalNode FINALLY() { - return getToken(JavaParser.FINALLY, 0); - } - - public BlockContext block() { - return getRuleContext(BlockContext.class, 0); - } - - public FinallyBlockContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_finallyBlock; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterFinallyBlock(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitFinallyBlock(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitFinallyBlock(this); - else return visitor.visitChildren(this); - } - } - public final FinallyBlockContext finallyBlock() throws RecognitionException { FinallyBlockContext _localctx = new FinallyBlockContext(_ctx, getState()); enterRule(_localctx, 142, RULE_finallyBlock); @@ -8414,52 +5336,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class ResourceSpecificationContext extends ParserRuleContext { - public TerminalNode LPAREN() { - return getToken(JavaParser.LPAREN, 0); - } - - public ResourcesContext resources() { - return getRuleContext(ResourcesContext.class, 0); - } - - public TerminalNode RPAREN() { - return getToken(JavaParser.RPAREN, 0); - } - - public TerminalNode SEMI() { - return getToken(JavaParser.SEMI, 0); - } - - public ResourceSpecificationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_resourceSpecification; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterResourceSpecification(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitResourceSpecification(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitResourceSpecification(this); - else return visitor.visitChildren(this); - } - } - public final ResourceSpecificationContext resourceSpecification() throws RecognitionException { ResourceSpecificationContext _localctx = new ResourceSpecificationContext(_ctx, getState()); enterRule(_localctx, 144, RULE_resourceSpecification); @@ -8494,52 +5370,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class ResourcesContext extends ParserRuleContext { - public List resource() { - return getRuleContexts(ResourceContext.class); - } - - public ResourceContext resource(int i) { - return getRuleContext(ResourceContext.class, i); - } - - public List SEMI() { - return getTokens(JavaParser.SEMI); - } - - public TerminalNode SEMI(int i) { - return getToken(JavaParser.SEMI, i); - } - - public ResourcesContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_resources; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterResources(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitResources(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitResources(this); - else return visitor.visitChildren(this); - } - } - public final ResourcesContext resources() throws RecognitionException { ResourcesContext _localctx = new ResourcesContext(_ctx, getState()); enterRule(_localctx, 146, RULE_resources); @@ -8578,60 +5408,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class ResourceContext extends ParserRuleContext { - public ClassOrInterfaceTypeContext classOrInterfaceType() { - return getRuleContext(ClassOrInterfaceTypeContext.class, 0); - } - - public VariableDeclaratorIdContext variableDeclaratorId() { - return getRuleContext(VariableDeclaratorIdContext.class, 0); - } - - public TerminalNode ASSIGN() { - return getToken(JavaParser.ASSIGN, 0); - } - - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class, 0); - } - - public List variableModifier() { - return getRuleContexts(VariableModifierContext.class); - } - - public VariableModifierContext variableModifier(int i) { - return getRuleContext(VariableModifierContext.class, i); - } - - public ResourceContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_resource; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterResource(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitResource(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitResource(this); - else return visitor.visitChildren(this); - } - } - public final ResourceContext resource() throws RecognitionException { ResourceContext _localctx = new ResourceContext(_ctx, getState()); enterRule(_localctx, 148, RULE_resource); @@ -8674,52 +5450,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class SwitchBlockStatementGroupContext extends ParserRuleContext { - public List switchLabel() { - return getRuleContexts(SwitchLabelContext.class); - } - - public SwitchLabelContext switchLabel(int i) { - return getRuleContext(SwitchLabelContext.class, i); - } - - public List blockStatement() { - return getRuleContexts(BlockStatementContext.class); - } - - public BlockStatementContext blockStatement(int i) { - return getRuleContext(BlockStatementContext.class, i); - } - - public SwitchBlockStatementGroupContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_switchBlockStatementGroup; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterSwitchBlockStatementGroup(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitSwitchBlockStatementGroup(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitSwitchBlockStatementGroup(this); - else return visitor.visitChildren(this); - } - } - public final SwitchBlockStatementGroupContext switchBlockStatementGroup() throws RecognitionException { SwitchBlockStatementGroupContext _localctx = @@ -8828,59 +5558,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class SwitchLabelContext extends ParserRuleContext { - public ExpressionContext constantExpression; - public Token enumConstantName; - - public TerminalNode CASE() { - return getToken(JavaParser.CASE, 0); - } - - public TerminalNode COLON() { - return getToken(JavaParser.COLON, 0); - } - - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class, 0); - } - - public TerminalNode IDENTIFIER() { - return getToken(JavaParser.IDENTIFIER, 0); - } - - public TerminalNode DEFAULT() { - return getToken(JavaParser.DEFAULT, 0); - } - - public SwitchLabelContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_switchLabel; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterSwitchLabel(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitSwitchLabel(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitSwitchLabel(this); - else return visitor.visitChildren(this); - } - } - public final SwitchLabelContext switchLabel() throws RecognitionException { SwitchLabelContext _localctx = new SwitchLabelContext(_ctx, getState()); enterRule(_localctx, 152, RULE_switchLabel); @@ -8935,62 +5612,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class ForControlContext extends ParserRuleContext { - public ExpressionListContext forUpdate; - - public EnhancedForControlContext enhancedForControl() { - return getRuleContext(EnhancedForControlContext.class, 0); - } - - public List SEMI() { - return getTokens(JavaParser.SEMI); - } - - public TerminalNode SEMI(int i) { - return getToken(JavaParser.SEMI, i); - } - - public ForInitContext forInit() { - return getRuleContext(ForInitContext.class, 0); - } - - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class, 0); - } - - public ExpressionListContext expressionList() { - return getRuleContext(ExpressionListContext.class, 0); - } - - public ForControlContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_forControl; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterForControl(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitForControl(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitForControl(this); - else return visitor.visitChildren(this); - } - } - public final ForControlContext forControl() throws RecognitionException { ForControlContext _localctx = new ForControlContext(_ctx, getState()); enterRule(_localctx, 154, RULE_forControl); @@ -9167,43 +5788,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class ForInitContext extends ParserRuleContext { - public LocalVariableDeclarationContext localVariableDeclaration() { - return getRuleContext(LocalVariableDeclarationContext.class, 0); - } - - public ExpressionListContext expressionList() { - return getRuleContext(ExpressionListContext.class, 0); - } - - public ForInitContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_forInit; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterForInit(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) ((JavaParserListener) listener).exitForInit(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitForInit(this); - else return visitor.visitChildren(this); - } - } - public final ForInitContext forInit() throws RecognitionException { ForInitContext _localctx = new ForInitContext(_ctx, getState()); enterRule(_localctx, 156, RULE_forInit); @@ -9236,60 +5820,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class EnhancedForControlContext extends ParserRuleContext { - public TypeTypeContext typeType() { - return getRuleContext(TypeTypeContext.class, 0); - } - - public VariableDeclaratorIdContext variableDeclaratorId() { - return getRuleContext(VariableDeclaratorIdContext.class, 0); - } - - public TerminalNode COLON() { - return getToken(JavaParser.COLON, 0); - } - - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class, 0); - } - - public List variableModifier() { - return getRuleContexts(VariableModifierContext.class); - } - - public VariableModifierContext variableModifier(int i) { - return getRuleContext(VariableModifierContext.class, i); - } - - public EnhancedForControlContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_enhancedForControl; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterEnhancedForControl(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitEnhancedForControl(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitEnhancedForControl(this); - else return visitor.visitChildren(this); - } - } - public final EnhancedForControlContext enhancedForControl() throws RecognitionException { EnhancedForControlContext _localctx = new EnhancedForControlContext(_ctx, getState()); enterRule(_localctx, 158, RULE_enhancedForControl); @@ -9332,48 +5862,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class ParExpressionContext extends ParserRuleContext { - public TerminalNode LPAREN() { - return getToken(JavaParser.LPAREN, 0); - } - - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class, 0); - } - - public TerminalNode RPAREN() { - return getToken(JavaParser.RPAREN, 0); - } - - public ParExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_parExpression; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterParExpression(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitParExpression(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitParExpression(this); - else return visitor.visitChildren(this); - } - } - public final ParExpressionContext parExpression() throws RecognitionException { ParExpressionContext _localctx = new ParExpressionContext(_ctx, getState()); enterRule(_localctx, 160, RULE_parExpression); @@ -9397,52 +5885,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class ExpressionListContext extends ParserRuleContext { - public List expression() { - return getRuleContexts(ExpressionContext.class); - } - - public ExpressionContext expression(int i) { - return getRuleContext(ExpressionContext.class, i); - } - - public List COMMA() { - return getTokens(JavaParser.COMMA); - } - - public TerminalNode COMMA(int i) { - return getToken(JavaParser.COMMA, i); - } - - public ExpressionListContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_expressionList; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterExpressionList(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitExpressionList(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitExpressionList(this); - else return visitor.visitChildren(this); - } - } - public final ExpressionListContext expressionList() throws RecognitionException { ExpressionListContext _localctx = new ExpressionListContext(_ctx, getState()); enterRule(_localctx, 162, RULE_expressionList); @@ -9479,60 +5921,6 @@ public class JavaParser extends Parser { return _localctx; } - public static class MethodCallContext extends ParserRuleContext { - public TerminalNode IDENTIFIER() { - return getToken(JavaParser.IDENTIFIER, 0); - } - - public TerminalNode LPAREN() { - return getToken(JavaParser.LPAREN, 0); - } - - public TerminalNode RPAREN() { - return getToken(JavaParser.RPAREN, 0); - } - - public ExpressionListContext expressionList() { - return getRuleContext(ExpressionListContext.class, 0); - } - - public TerminalNode THIS() { - return getToken(JavaParser.THIS, 0); - } - - public TerminalNode SUPER() { - return getToken(JavaParser.SUPER, 0); - } - - public MethodCallContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_methodCall; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterMethodCall(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitMethodCall(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitMethodCall(this); - else return visitor.visitChildren(this); - } - } - public final MethodCallContext methodCall() throws RecognitionException { MethodCallContext _localctx = new MethodCallContext(_ctx, getState()); enterRule(_localctx, 164, RULE_methodCall); @@ -9728,300 +6116,1145 @@ public class JavaParser extends Parser { return _localctx; } - public static class ExpressionContext extends ParserRuleContext { - public Token prefix; - public Token bop; - public Token postfix; - - public PrimaryContext primary() { - return getRuleContext(PrimaryContext.class, 0); - } - - public MethodCallContext methodCall() { - return getRuleContext(MethodCallContext.class, 0); - } - - public TerminalNode NEW() { - return getToken(JavaParser.NEW, 0); - } - - public CreatorContext creator() { - return getRuleContext(CreatorContext.class, 0); - } - - public TerminalNode LPAREN() { - return getToken(JavaParser.LPAREN, 0); - } - - public List typeType() { - return getRuleContexts(TypeTypeContext.class); - } - - public TypeTypeContext typeType(int i) { - return getRuleContext(TypeTypeContext.class, i); - } - - public TerminalNode RPAREN() { - return getToken(JavaParser.RPAREN, 0); - } - - public List expression() { - return getRuleContexts(ExpressionContext.class); - } - - public ExpressionContext expression(int i) { - return getRuleContext(ExpressionContext.class, i); - } - - public List annotation() { - return getRuleContexts(AnnotationContext.class); - } - - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class, i); - } - - public List BITAND() { - return getTokens(JavaParser.BITAND); - } - - public TerminalNode BITAND(int i) { - return getToken(JavaParser.BITAND, i); - } - - public TerminalNode ADD() { - return getToken(JavaParser.ADD, 0); - } - - public TerminalNode SUB() { - return getToken(JavaParser.SUB, 0); - } - - public TerminalNode INC() { - return getToken(JavaParser.INC, 0); - } - - public TerminalNode DEC() { - return getToken(JavaParser.DEC, 0); - } - - public TerminalNode TILDE() { - return getToken(JavaParser.TILDE, 0); - } - - public TerminalNode BANG() { - return getToken(JavaParser.BANG, 0); - } - - public LambdaExpressionContext lambdaExpression() { - return getRuleContext(LambdaExpressionContext.class, 0); - } - - public TerminalNode COLONCOLON() { - return getToken(JavaParser.COLONCOLON, 0); - } - - public TerminalNode IDENTIFIER() { - return getToken(JavaParser.IDENTIFIER, 0); - } - - public TypeArgumentsContext typeArguments() { - return getRuleContext(TypeArgumentsContext.class, 0); - } - - public ClassTypeContext classType() { - return getRuleContext(ClassTypeContext.class, 0); - } - - public TerminalNode MUL() { - return getToken(JavaParser.MUL, 0); - } - - public TerminalNode DIV() { - return getToken(JavaParser.DIV, 0); - } - - public TerminalNode MOD() { - return getToken(JavaParser.MOD, 0); - } - - public List LT() { - return getTokens(JavaParser.LT); - } - - public TerminalNode LT(int i) { - return getToken(JavaParser.LT, i); - } - - public List GT() { - return getTokens(JavaParser.GT); - } - - public TerminalNode GT(int i) { - return getToken(JavaParser.GT, i); - } - - public TerminalNode LE() { - return getToken(JavaParser.LE, 0); - } - - public TerminalNode GE() { - return getToken(JavaParser.GE, 0); - } - - public TerminalNode EQUAL() { - return getToken(JavaParser.EQUAL, 0); - } - - public TerminalNode NOTEQUAL() { - return getToken(JavaParser.NOTEQUAL, 0); - } - - public TerminalNode CARET() { - return getToken(JavaParser.CARET, 0); - } - - public TerminalNode BITOR() { - return getToken(JavaParser.BITOR, 0); - } - - public TerminalNode AND() { - return getToken(JavaParser.AND, 0); - } - - public TerminalNode OR() { - return getToken(JavaParser.OR, 0); - } - - public TerminalNode COLON() { - return getToken(JavaParser.COLON, 0); - } - - public TerminalNode QUESTION() { - return getToken(JavaParser.QUESTION, 0); - } - - public TerminalNode ASSIGN() { - return getToken(JavaParser.ASSIGN, 0); - } - - public TerminalNode ADD_ASSIGN() { - return getToken(JavaParser.ADD_ASSIGN, 0); - } - - public TerminalNode SUB_ASSIGN() { - return getToken(JavaParser.SUB_ASSIGN, 0); - } - - public TerminalNode MUL_ASSIGN() { - return getToken(JavaParser.MUL_ASSIGN, 0); - } - - public TerminalNode DIV_ASSIGN() { - return getToken(JavaParser.DIV_ASSIGN, 0); - } - - public TerminalNode AND_ASSIGN() { - return getToken(JavaParser.AND_ASSIGN, 0); - } - - public TerminalNode OR_ASSIGN() { - return getToken(JavaParser.OR_ASSIGN, 0); - } - - public TerminalNode XOR_ASSIGN() { - return getToken(JavaParser.XOR_ASSIGN, 0); - } - - public TerminalNode RSHIFT_ASSIGN() { - return getToken(JavaParser.RSHIFT_ASSIGN, 0); - } - - public TerminalNode URSHIFT_ASSIGN() { - return getToken(JavaParser.URSHIFT_ASSIGN, 0); - } - - public TerminalNode LSHIFT_ASSIGN() { - return getToken(JavaParser.LSHIFT_ASSIGN, 0); - } - - public TerminalNode MOD_ASSIGN() { - return getToken(JavaParser.MOD_ASSIGN, 0); - } - - public TerminalNode DOT() { - return getToken(JavaParser.DOT, 0); - } - - public TerminalNode THIS() { - return getToken(JavaParser.THIS, 0); - } - - public InnerCreatorContext innerCreator() { - return getRuleContext(InnerCreatorContext.class, 0); - } - - public TerminalNode SUPER() { - return getToken(JavaParser.SUPER, 0); - } - - public SuperSuffixContext superSuffix() { - return getRuleContext(SuperSuffixContext.class, 0); - } - - public ExplicitGenericInvocationContext explicitGenericInvocation() { - return getRuleContext(ExplicitGenericInvocationContext.class, 0); - } - - public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() { - return getRuleContext(NonWildcardTypeArgumentsContext.class, 0); - } - - public TerminalNode LBRACK() { - return getToken(JavaParser.LBRACK, 0); - } - - public TerminalNode RBRACK() { - return getToken(JavaParser.RBRACK, 0); - } - - public TerminalNode INSTANCEOF() { - return getToken(JavaParser.INSTANCEOF, 0); - } - - public ExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_expression; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).enterExpression(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavaParserListener) - ((JavaParserListener) listener).exitExpression(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitExpression(this); - else return visitor.visitChildren(this); - } - } - public final ExpressionContext expression() throws RecognitionException { return expression(0); } + public final LambdaExpressionContext lambdaExpression() throws RecognitionException { + LambdaExpressionContext _localctx = new LambdaExpressionContext(_ctx, getState()); + enterRule(_localctx, 168, RULE_lambdaExpression); + try { + enterOuterAlt(_localctx, 1); + { + setState(1226); + lambdaParameters(); + setState(1227); + match(ARROW); + setState(1228); + lambdaBody(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final LambdaParametersContext lambdaParameters() throws RecognitionException { + LambdaParametersContext _localctx = new LambdaParametersContext(_ctx, getState()); + enterRule(_localctx, 170, RULE_lambdaParameters); + int _la; + try { + setState(1246); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 148, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1230); + match(IDENTIFIER); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1231); + match(LPAREN); + setState(1233); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 + && ((1L << _la) + & ((1L << BOOLEAN) + | (1L << BYTE) + | (1L << CHAR) + | (1L << DOUBLE) + | (1L << FINAL) + | (1L << FLOAT) + | (1L << INT) + | (1L << LONG) + | (1L << SHORT))) + != 0) + || _la == AT + || _la == IDENTIFIER) { + { + setState(1232); + formalParameterList(); + } + } + + setState(1235); + match(RPAREN); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1236); + match(LPAREN); + setState(1237); + match(IDENTIFIER); + setState(1242); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == COMMA) { + { + { + setState(1238); + match(COMMA); + setState(1239); + match(IDENTIFIER); + } + } + setState(1244); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1245); + match(RPAREN); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final LambdaBodyContext lambdaBody() throws RecognitionException { + LambdaBodyContext _localctx = new LambdaBodyContext(_ctx, getState()); + enterRule(_localctx, 172, RULE_lambdaBody); + try { + setState(1250); + _errHandler.sync(this); + switch (_input.LA(1)) { + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case NEW: + case SHORT: + case SUPER: + case THIS: + case VOID: + case DECIMAL_LITERAL: + case HEX_LITERAL: + case OCT_LITERAL: + case BINARY_LITERAL: + case FLOAT_LITERAL: + case HEX_FLOAT_LITERAL: + case BOOL_LITERAL: + case CHAR_LITERAL: + case STRING_LITERAL: + case NULL_LITERAL: + case LPAREN: + case LT: + case BANG: + case TILDE: + case INC: + case DEC: + case ADD: + case SUB: + case AT: + case IDENTIFIER: + enterOuterAlt(_localctx, 1); + { + setState(1248); + expression(0); + } + break; + case LBRACE: + enterOuterAlt(_localctx, 2); + { + setState(1249); + block(); + } + 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 final PrimaryContext primary() throws RecognitionException { + PrimaryContext _localctx = new PrimaryContext(_ctx, getState()); + enterRule(_localctx, 174, RULE_primary); + try { + setState(1270); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 151, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1252); + match(LPAREN); + setState(1253); + expression(0); + setState(1254); + match(RPAREN); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1256); + match(THIS); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(1257); + match(SUPER); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(1258); + literal(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(1259); + match(IDENTIFIER); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(1260); + typeTypeOrVoid(); + setState(1261); + match(DOT); + setState(1262); + match(CLASS); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(1264); + nonWildcardTypeArguments(); + setState(1268); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SUPER: + case IDENTIFIER: + { + setState(1265); + explicitGenericInvocationSuffix(); + } + break; + case THIS: + { + setState(1266); + match(THIS); + setState(1267); + arguments(); + } + 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 final ClassTypeContext classType() throws RecognitionException { + ClassTypeContext _localctx = new ClassTypeContext(_ctx, getState()); + enterRule(_localctx, 176, RULE_classType); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1275); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 152, _ctx)) { + case 1: + { + setState(1272); + classOrInterfaceType(); + setState(1273); + match(DOT); + } + break; + } + setState(1280); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 153, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1277); + annotation(); + } + } + } + setState(1282); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 153, _ctx); + } + setState(1283); + match(IDENTIFIER); + setState(1285); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == LT) { + { + setState(1284); + typeArguments(); + } + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final CreatorContext creator() throws RecognitionException { + CreatorContext _localctx = new CreatorContext(_ctx, getState()); + enterRule(_localctx, 178, RULE_creator); + try { + setState(1296); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LT: + enterOuterAlt(_localctx, 1); + { + setState(1287); + nonWildcardTypeArguments(); + setState(1288); + createdName(); + setState(1289); + classCreatorRest(); + } + break; + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case SHORT: + case IDENTIFIER: + enterOuterAlt(_localctx, 2); + { + setState(1291); + createdName(); + setState(1294); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LBRACK: + { + setState(1292); + arrayCreatorRest(); + } + break; + case LPAREN: + { + setState(1293); + classCreatorRest(); + } + break; + default: + throw new NoViableAltException(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 final CreatedNameContext createdName() throws RecognitionException { + CreatedNameContext _localctx = new CreatedNameContext(_ctx, getState()); + enterRule(_localctx, 180, RULE_createdName); + int _la; + try { + setState(1313); + _errHandler.sync(this); + switch (_input.LA(1)) { + case IDENTIFIER: + enterOuterAlt(_localctx, 1); + { + setState(1298); + match(IDENTIFIER); + setState(1300); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == LT) { + { + setState(1299); + typeArgumentsOrDiamond(); + } + } + + setState(1309); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == DOT) { + { + { + setState(1302); + match(DOT); + setState(1303); + match(IDENTIFIER); + setState(1305); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == LT) { + { + setState(1304); + typeArgumentsOrDiamond(); + } + } + } + } + setState(1311); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case SHORT: + enterOuterAlt(_localctx, 2); + { + setState(1312); + primitiveType(); + } + 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 final InnerCreatorContext innerCreator() throws RecognitionException { + InnerCreatorContext _localctx = new InnerCreatorContext(_ctx, getState()); + enterRule(_localctx, 182, RULE_innerCreator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1315); + match(IDENTIFIER); + setState(1317); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == LT) { + { + setState(1316); + nonWildcardTypeArgumentsOrDiamond(); + } + } + + setState(1319); + classCreatorRest(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ArrayCreatorRestContext arrayCreatorRest() throws RecognitionException { + ArrayCreatorRestContext _localctx = new ArrayCreatorRestContext(_ctx, getState()); + enterRule(_localctx, 184, RULE_arrayCreatorRest); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1321); + match(LBRACK); + setState(1349); + _errHandler.sync(this); + switch (_input.LA(1)) { + case RBRACK: + { + setState(1322); + match(RBRACK); + setState(1327); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == LBRACK) { + { + { + setState(1323); + match(LBRACK); + setState(1324); + match(RBRACK); + } + } + setState(1329); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1330); + arrayInitializer(); + } + break; + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case NEW: + case SHORT: + case SUPER: + case THIS: + case VOID: + case DECIMAL_LITERAL: + case HEX_LITERAL: + case OCT_LITERAL: + case BINARY_LITERAL: + case FLOAT_LITERAL: + case HEX_FLOAT_LITERAL: + case BOOL_LITERAL: + case CHAR_LITERAL: + case STRING_LITERAL: + case NULL_LITERAL: + case LPAREN: + case LT: + case BANG: + case TILDE: + case INC: + case DEC: + case ADD: + case SUB: + case AT: + case IDENTIFIER: + { + setState(1331); + expression(0); + setState(1332); + match(RBRACK); + setState(1339); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 163, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1333); + match(LBRACK); + setState(1334); + expression(0); + setState(1335); + match(RBRACK); + } + } + } + setState(1341); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 163, _ctx); + } + setState(1346); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 164, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1342); + match(LBRACK); + setState(1343); + match(RBRACK); + } + } + } + setState(1348); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 164, _ctx); + } + } + 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 final ClassCreatorRestContext classCreatorRest() throws RecognitionException { + ClassCreatorRestContext _localctx = new ClassCreatorRestContext(_ctx, getState()); + enterRule(_localctx, 186, RULE_classCreatorRest); + try { + enterOuterAlt(_localctx, 1); + { + setState(1351); + arguments(); + setState(1353); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 166, _ctx)) { + case 1: + { + setState(1352); + classBody(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ExplicitGenericInvocationContext explicitGenericInvocation() + throws RecognitionException { + ExplicitGenericInvocationContext _localctx = + new ExplicitGenericInvocationContext(_ctx, getState()); + enterRule(_localctx, 188, RULE_explicitGenericInvocation); + try { + enterOuterAlt(_localctx, 1); + { + setState(1355); + nonWildcardTypeArguments(); + setState(1356); + explicitGenericInvocationSuffix(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() throws RecognitionException { + TypeArgumentsOrDiamondContext _localctx = new TypeArgumentsOrDiamondContext(_ctx, getState()); + enterRule(_localctx, 190, RULE_typeArgumentsOrDiamond); + try { + setState(1361); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 167, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1358); + match(LT); + setState(1359); + match(GT); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1360); + typeArguments(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final NonWildcardTypeArgumentsOrDiamondContext nonWildcardTypeArgumentsOrDiamond() + throws RecognitionException { + NonWildcardTypeArgumentsOrDiamondContext _localctx = + new NonWildcardTypeArgumentsOrDiamondContext(_ctx, getState()); + enterRule(_localctx, 192, RULE_nonWildcardTypeArgumentsOrDiamond); + try { + setState(1366); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 168, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1363); + match(LT); + setState(1364); + match(GT); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1365); + nonWildcardTypeArguments(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final NonWildcardTypeArgumentsContext nonWildcardTypeArguments() + throws RecognitionException { + NonWildcardTypeArgumentsContext _localctx = + new NonWildcardTypeArgumentsContext(_ctx, getState()); + enterRule(_localctx, 194, RULE_nonWildcardTypeArguments); + try { + enterOuterAlt(_localctx, 1); + { + setState(1368); + match(LT); + setState(1369); + typeList(); + setState(1370); + match(GT); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final TypeListContext typeList() throws RecognitionException { + TypeListContext _localctx = new TypeListContext(_ctx, getState()); + enterRule(_localctx, 196, RULE_typeList); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1372); + typeType(); + setState(1377); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == COMMA) { + { + { + setState(1373); + match(COMMA); + setState(1374); + typeType(); + } + } + setState(1379); + _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 final TypeTypeContext typeType() throws RecognitionException { + TypeTypeContext _localctx = new TypeTypeContext(_ctx, getState()); + enterRule(_localctx, 198, RULE_typeType); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1383); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 170, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1380); + annotation(); + } + } + } + setState(1385); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 170, _ctx); + } + setState(1388); + _errHandler.sync(this); + switch (_input.LA(1)) { + case IDENTIFIER: + { + setState(1386); + classOrInterfaceType(); + } + break; + case BOOLEAN: + case BYTE: + case CHAR: + case DOUBLE: + case FLOAT: + case INT: + case LONG: + case SHORT: + { + setState(1387); + primitiveType(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(1400); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 173, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1393); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == AT || _la == IDENTIFIER) { + { + { + setState(1390); + annotation(); + } + } + setState(1395); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1396); + match(LBRACK); + setState(1397); + match(RBRACK); + } + } + } + setState(1402); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 173, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final PrimitiveTypeContext primitiveType() throws RecognitionException { + PrimitiveTypeContext _localctx = new PrimitiveTypeContext(_ctx, getState()); + enterRule(_localctx, 200, RULE_primitiveType); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1403); + _la = _input.LA(1); + if (!((((_la) & ~0x3f) == 0 + && ((1L << _la) + & ((1L << BOOLEAN) + | (1L << BYTE) + | (1L << CHAR) + | (1L << DOUBLE) + | (1L << FLOAT) + | (1L << INT) + | (1L << LONG) + | (1L << SHORT))) + != 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 final TypeArgumentsContext typeArguments() throws RecognitionException { + TypeArgumentsContext _localctx = new TypeArgumentsContext(_ctx, getState()); + enterRule(_localctx, 202, RULE_typeArguments); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1405); + match(LT); + setState(1406); + typeArgument(); + setState(1411); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == COMMA) { + { + { + setState(1407); + match(COMMA); + setState(1408); + typeArgument(); + } + } + setState(1413); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1414); + match(GT); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final SuperSuffixContext superSuffix() throws RecognitionException { + SuperSuffixContext _localctx = new SuperSuffixContext(_ctx, getState()); + enterRule(_localctx, 204, RULE_superSuffix); + try { + setState(1422); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LPAREN: + enterOuterAlt(_localctx, 1); + { + setState(1416); + arguments(); + } + break; + case DOT: + enterOuterAlt(_localctx, 2); + { + setState(1417); + match(DOT); + setState(1418); + match(IDENTIFIER); + setState(1420); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 175, _ctx)) { + case 1: + { + setState(1419); + arguments(); + } + 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 final ExplicitGenericInvocationSuffixContext explicitGenericInvocationSuffix() + throws RecognitionException { + ExplicitGenericInvocationSuffixContext _localctx = + new ExplicitGenericInvocationSuffixContext(_ctx, getState()); + enterRule(_localctx, 206, RULE_explicitGenericInvocationSuffix); + try { + setState(1428); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SUPER: + enterOuterAlt(_localctx, 1); + { + setState(1424); + match(SUPER); + setState(1425); + superSuffix(); + } + break; + case IDENTIFIER: + enterOuterAlt(_localctx, 2); + { + setState(1426); + match(IDENTIFIER); + setState(1427); + arguments(); + } + 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 final ArgumentsContext arguments() throws RecognitionException { + ArgumentsContext _localctx = new ArgumentsContext(_ctx, getState()); + enterRule(_localctx, 208, RULE_arguments); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1430); + match(LPAREN); + setState(1432); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 + && ((1L << _la) + & ((1L << BOOLEAN) + | (1L << BYTE) + | (1L << CHAR) + | (1L << DOUBLE) + | (1L << FLOAT) + | (1L << INT) + | (1L << LONG) + | (1L << NEW) + | (1L << SHORT) + | (1L << SUPER) + | (1L << THIS) + | (1L << VOID) + | (1L << DECIMAL_LITERAL) + | (1L << HEX_LITERAL) + | (1L << OCT_LITERAL) + | (1L << BINARY_LITERAL) + | (1L << FLOAT_LITERAL) + | (1L << HEX_FLOAT_LITERAL) + | (1L << BOOL_LITERAL) + | (1L << CHAR_LITERAL) + | (1L << STRING_LITERAL) + | (1L << NULL_LITERAL) + | (1L << LPAREN))) + != 0) + || ((((_la - 73)) & ~0x3f) == 0 + && ((1L << (_la - 73)) + & ((1L << (LT - 73)) + | (1L << (BANG - 73)) + | (1L << (TILDE - 73)) + | (1L << (INC - 73)) + | (1L << (DEC - 73)) + | (1L << (ADD - 73)) + | (1L << (SUB - 73)) + | (1L << (AT - 73)) + | (1L << (IDENTIFIER - 73)))) + != 0)) { + { + setState(1431); + expressionList(); + } + } + + setState(1434); + match(RPAREN); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + private ExpressionContext expression(int _p) throws RecognitionException { ParserRuleContext _parentctx = _ctx; int _parentState = getState(); @@ -10620,7 +7853,4512 @@ public class JavaParser extends Parser { return _localctx; } + public static class CompilationUnitContext extends ParserRuleContext { + public CompilationUnitContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode EOF() { + return getToken(JavaParser.EOF, 0); + } + + public PackageDeclarationContext packageDeclaration() { + return getRuleContext(PackageDeclarationContext.class, 0); + } + + public List importDeclaration() { + return getRuleContexts(ImportDeclarationContext.class); + } + + public ImportDeclarationContext importDeclaration(int i) { + return getRuleContext(ImportDeclarationContext.class, i); + } + + public List typeDeclaration() { + return getRuleContexts(TypeDeclarationContext.class); + } + + public TypeDeclarationContext typeDeclaration(int i) { + return getRuleContext(TypeDeclarationContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_compilationUnit; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitCompilationUnit(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterCompilationUnit(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitCompilationUnit(this); + } + } + + public static class PackageDeclarationContext extends ParserRuleContext { + public PackageDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode PACKAGE() { + return getToken(JavaParser.PACKAGE, 0); + } + + public QualifiedNameContext qualifiedName() { + return getRuleContext(QualifiedNameContext.class, 0); + } + + public TerminalNode SEMI() { + return getToken(JavaParser.SEMI, 0); + } + + public List annotation() { + return getRuleContexts(AnnotationContext.class); + } + + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_packageDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitPackageDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterPackageDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitPackageDeclaration(this); + } + } + + public static class ImportDeclarationContext extends ParserRuleContext { + public ImportDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode IMPORT() { + return getToken(JavaParser.IMPORT, 0); + } + + public QualifiedNameContext qualifiedName() { + return getRuleContext(QualifiedNameContext.class, 0); + } + + public TerminalNode SEMI() { + return getToken(JavaParser.SEMI, 0); + } + + public TerminalNode STATIC() { + return getToken(JavaParser.STATIC, 0); + } + + public TerminalNode DOT() { + return getToken(JavaParser.DOT, 0); + } + + public TerminalNode MUL() { + return getToken(JavaParser.MUL, 0); + } + + @Override + public int getRuleIndex() { + return RULE_importDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitImportDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterImportDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitImportDeclaration(this); + } + } + + public static class TypeDeclarationContext extends ParserRuleContext { + public TypeDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public ClassDeclarationContext classDeclaration() { + return getRuleContext(ClassDeclarationContext.class, 0); + } + + public EnumDeclarationContext enumDeclaration() { + return getRuleContext(EnumDeclarationContext.class, 0); + } + + public InterfaceDeclarationContext interfaceDeclaration() { + return getRuleContext(InterfaceDeclarationContext.class, 0); + } + + public AnnotationTypeDeclarationContext annotationTypeDeclaration() { + return getRuleContext(AnnotationTypeDeclarationContext.class, 0); + } + + public List classOrInterfaceModifier() { + return getRuleContexts(ClassOrInterfaceModifierContext.class); + } + + public ClassOrInterfaceModifierContext classOrInterfaceModifier(int i) { + return getRuleContext(ClassOrInterfaceModifierContext.class, i); + } + + public TerminalNode SEMI() { + return getToken(JavaParser.SEMI, 0); + } + + @Override + public int getRuleIndex() { + return RULE_typeDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitTypeDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterTypeDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitTypeDeclaration(this); + } + } + + public static class ModifierContext extends ParserRuleContext { + public ModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public ClassOrInterfaceModifierContext classOrInterfaceModifier() { + return getRuleContext(ClassOrInterfaceModifierContext.class, 0); + } + + public TerminalNode NATIVE() { + return getToken(JavaParser.NATIVE, 0); + } + + public TerminalNode SYNCHRONIZED() { + return getToken(JavaParser.SYNCHRONIZED, 0); + } + + public TerminalNode TRANSIENT() { + return getToken(JavaParser.TRANSIENT, 0); + } + + public TerminalNode VOLATILE() { + return getToken(JavaParser.VOLATILE, 0); + } + + @Override + public int getRuleIndex() { + return RULE_modifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitModifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterModifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitModifier(this); + } + } + + public static class ClassOrInterfaceModifierContext extends ParserRuleContext { + public ClassOrInterfaceModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class, 0); + } + + public TerminalNode PUBLIC() { + return getToken(JavaParser.PUBLIC, 0); + } + + public TerminalNode PROTECTED() { + return getToken(JavaParser.PROTECTED, 0); + } + + public TerminalNode PRIVATE() { + return getToken(JavaParser.PRIVATE, 0); + } + + public TerminalNode STATIC() { + return getToken(JavaParser.STATIC, 0); + } + + public TerminalNode ABSTRACT() { + return getToken(JavaParser.ABSTRACT, 0); + } + + public TerminalNode FINAL() { + return getToken(JavaParser.FINAL, 0); + } + + public TerminalNode STRICTFP() { + return getToken(JavaParser.STRICTFP, 0); + } + + @Override + public int getRuleIndex() { + return RULE_classOrInterfaceModifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitClassOrInterfaceModifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterClassOrInterfaceModifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitClassOrInterfaceModifier(this); + } + } + + public static class VariableModifierContext extends ParserRuleContext { + public VariableModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode FINAL() { + return getToken(JavaParser.FINAL, 0); + } + + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_variableModifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitVariableModifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterVariableModifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitVariableModifier(this); + } + } + + public static class ClassDeclarationContext extends ParserRuleContext { + public ClassDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode CLASS() { + return getToken(JavaParser.CLASS, 0); + } + + public TerminalNode IDENTIFIER() { + return getToken(JavaParser.IDENTIFIER, 0); + } + + public ClassBodyContext classBody() { + return getRuleContext(ClassBodyContext.class, 0); + } + + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class, 0); + } + + public TerminalNode EXTENDS() { + return getToken(JavaParser.EXTENDS, 0); + } + + public TypeTypeContext typeType() { + return getRuleContext(TypeTypeContext.class, 0); + } + + public TerminalNode IMPLEMENTS() { + return getToken(JavaParser.IMPLEMENTS, 0); + } + + public TypeListContext typeList() { + return getRuleContext(TypeListContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_classDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitClassDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterClassDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitClassDeclaration(this); + } + } + + public static class TypeParametersContext extends ParserRuleContext { + public TypeParametersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LT() { + return getToken(JavaParser.LT, 0); + } + + public List typeParameter() { + return getRuleContexts(TypeParameterContext.class); + } + + public TypeParameterContext typeParameter(int i) { + return getRuleContext(TypeParameterContext.class, i); + } + + public TerminalNode GT() { + return getToken(JavaParser.GT, 0); + } + + public List COMMA() { + return getTokens(JavaParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(JavaParser.COMMA, i); + } + + @Override + public int getRuleIndex() { + return RULE_typeParameters; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitTypeParameters(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterTypeParameters(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitTypeParameters(this); + } + } + + public static class TypeParameterContext extends ParserRuleContext { + public TypeParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode IDENTIFIER() { + return getToken(JavaParser.IDENTIFIER, 0); + } + + public List annotation() { + return getRuleContexts(AnnotationContext.class); + } + + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class, i); + } + + public TerminalNode EXTENDS() { + return getToken(JavaParser.EXTENDS, 0); + } + + public TypeBoundContext typeBound() { + return getRuleContext(TypeBoundContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_typeParameter; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitTypeParameter(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterTypeParameter(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitTypeParameter(this); + } + } + + public static class TypeBoundContext extends ParserRuleContext { + public TypeBoundContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List typeType() { + return getRuleContexts(TypeTypeContext.class); + } + + public TypeTypeContext typeType(int i) { + return getRuleContext(TypeTypeContext.class, i); + } + + public List BITAND() { + return getTokens(JavaParser.BITAND); + } + + public TerminalNode BITAND(int i) { + return getToken(JavaParser.BITAND, i); + } + + @Override + public int getRuleIndex() { + return RULE_typeBound; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitTypeBound(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterTypeBound(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitTypeBound(this); + } + } + + public static class EnumDeclarationContext extends ParserRuleContext { + public EnumDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode ENUM() { + return getToken(JavaParser.ENUM, 0); + } + + public TerminalNode IDENTIFIER() { + return getToken(JavaParser.IDENTIFIER, 0); + } + + public TerminalNode LBRACE() { + return getToken(JavaParser.LBRACE, 0); + } + + public TerminalNode RBRACE() { + return getToken(JavaParser.RBRACE, 0); + } + + public TerminalNode IMPLEMENTS() { + return getToken(JavaParser.IMPLEMENTS, 0); + } + + public TypeListContext typeList() { + return getRuleContext(TypeListContext.class, 0); + } + + public EnumConstantsContext enumConstants() { + return getRuleContext(EnumConstantsContext.class, 0); + } + + public TerminalNode COMMA() { + return getToken(JavaParser.COMMA, 0); + } + + public EnumBodyDeclarationsContext enumBodyDeclarations() { + return getRuleContext(EnumBodyDeclarationsContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_enumDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitEnumDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterEnumDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitEnumDeclaration(this); + } + } + + public static class EnumConstantsContext extends ParserRuleContext { + public EnumConstantsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List enumConstant() { + return getRuleContexts(EnumConstantContext.class); + } + + public EnumConstantContext enumConstant(int i) { + return getRuleContext(EnumConstantContext.class, i); + } + + public List COMMA() { + return getTokens(JavaParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(JavaParser.COMMA, i); + } + + @Override + public int getRuleIndex() { + return RULE_enumConstants; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitEnumConstants(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterEnumConstants(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitEnumConstants(this); + } + } + + public static class EnumConstantContext extends ParserRuleContext { + public EnumConstantContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode IDENTIFIER() { + return getToken(JavaParser.IDENTIFIER, 0); + } + + public List annotation() { + return getRuleContexts(AnnotationContext.class); + } + + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class, i); + } + + public ArgumentsContext arguments() { + return getRuleContext(ArgumentsContext.class, 0); + } + + public ClassBodyContext classBody() { + return getRuleContext(ClassBodyContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_enumConstant; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitEnumConstant(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterEnumConstant(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitEnumConstant(this); + } + } + + public static class EnumBodyDeclarationsContext extends ParserRuleContext { + public EnumBodyDeclarationsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode SEMI() { + return getToken(JavaParser.SEMI, 0); + } + + public List classBodyDeclaration() { + return getRuleContexts(ClassBodyDeclarationContext.class); + } + + public ClassBodyDeclarationContext classBodyDeclaration(int i) { + return getRuleContext(ClassBodyDeclarationContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_enumBodyDeclarations; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitEnumBodyDeclarations(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterEnumBodyDeclarations(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitEnumBodyDeclarations(this); + } + } + + public static class InterfaceDeclarationContext extends ParserRuleContext { + public InterfaceDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode INTERFACE() { + return getToken(JavaParser.INTERFACE, 0); + } + + public TerminalNode IDENTIFIER() { + return getToken(JavaParser.IDENTIFIER, 0); + } + + public InterfaceBodyContext interfaceBody() { + return getRuleContext(InterfaceBodyContext.class, 0); + } + + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class, 0); + } + + public TerminalNode EXTENDS() { + return getToken(JavaParser.EXTENDS, 0); + } + + public TypeListContext typeList() { + return getRuleContext(TypeListContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_interfaceDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitInterfaceDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterInterfaceDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitInterfaceDeclaration(this); + } + } + + public static class ClassBodyContext extends ParserRuleContext { + public ClassBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LBRACE() { + return getToken(JavaParser.LBRACE, 0); + } + + public TerminalNode RBRACE() { + return getToken(JavaParser.RBRACE, 0); + } + + public List classBodyDeclaration() { + return getRuleContexts(ClassBodyDeclarationContext.class); + } + + public ClassBodyDeclarationContext classBodyDeclaration(int i) { + return getRuleContext(ClassBodyDeclarationContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_classBody; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitClassBody(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterClassBody(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitClassBody(this); + } + } + + public static class InterfaceBodyContext extends ParserRuleContext { + public InterfaceBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LBRACE() { + return getToken(JavaParser.LBRACE, 0); + } + + public TerminalNode RBRACE() { + return getToken(JavaParser.RBRACE, 0); + } + + public List interfaceBodyDeclaration() { + return getRuleContexts(InterfaceBodyDeclarationContext.class); + } + + public InterfaceBodyDeclarationContext interfaceBodyDeclaration(int i) { + return getRuleContext(InterfaceBodyDeclarationContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_interfaceBody; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitInterfaceBody(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterInterfaceBody(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitInterfaceBody(this); + } + } + + public static class ClassBodyDeclarationContext extends ParserRuleContext { + public ClassBodyDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode SEMI() { + return getToken(JavaParser.SEMI, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public TerminalNode STATIC() { + return getToken(JavaParser.STATIC, 0); + } + + public MemberDeclarationContext memberDeclaration() { + return getRuleContext(MemberDeclarationContext.class, 0); + } + + public List modifier() { + return getRuleContexts(ModifierContext.class); + } + + public ModifierContext modifier(int i) { + return getRuleContext(ModifierContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_classBodyDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitClassBodyDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterClassBodyDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitClassBodyDeclaration(this); + } + } + + public static class MemberDeclarationContext extends ParserRuleContext { + public MemberDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public MethodDeclarationContext methodDeclaration() { + return getRuleContext(MethodDeclarationContext.class, 0); + } + + public GenericMethodDeclarationContext genericMethodDeclaration() { + return getRuleContext(GenericMethodDeclarationContext.class, 0); + } + + public FieldDeclarationContext fieldDeclaration() { + return getRuleContext(FieldDeclarationContext.class, 0); + } + + public ConstructorDeclarationContext constructorDeclaration() { + return getRuleContext(ConstructorDeclarationContext.class, 0); + } + + public GenericConstructorDeclarationContext genericConstructorDeclaration() { + return getRuleContext(GenericConstructorDeclarationContext.class, 0); + } + + public InterfaceDeclarationContext interfaceDeclaration() { + return getRuleContext(InterfaceDeclarationContext.class, 0); + } + + public AnnotationTypeDeclarationContext annotationTypeDeclaration() { + return getRuleContext(AnnotationTypeDeclarationContext.class, 0); + } + + public ClassDeclarationContext classDeclaration() { + return getRuleContext(ClassDeclarationContext.class, 0); + } + + public EnumDeclarationContext enumDeclaration() { + return getRuleContext(EnumDeclarationContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_memberDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitMemberDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterMemberDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitMemberDeclaration(this); + } + } + + public static class MethodDeclarationContext extends ParserRuleContext { + public MethodDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TypeTypeOrVoidContext typeTypeOrVoid() { + return getRuleContext(TypeTypeOrVoidContext.class, 0); + } + + public TerminalNode IDENTIFIER() { + return getToken(JavaParser.IDENTIFIER, 0); + } + + public FormalParametersContext formalParameters() { + return getRuleContext(FormalParametersContext.class, 0); + } + + public MethodBodyContext methodBody() { + return getRuleContext(MethodBodyContext.class, 0); + } + + public List LBRACK() { + return getTokens(JavaParser.LBRACK); + } + + public TerminalNode LBRACK(int i) { + return getToken(JavaParser.LBRACK, i); + } + + public List RBRACK() { + return getTokens(JavaParser.RBRACK); + } + + public TerminalNode RBRACK(int i) { + return getToken(JavaParser.RBRACK, i); + } + + public TerminalNode THROWS() { + return getToken(JavaParser.THROWS, 0); + } + + public QualifiedNameListContext qualifiedNameList() { + return getRuleContext(QualifiedNameListContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_methodDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitMethodDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterMethodDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitMethodDeclaration(this); + } + } + + public static class MethodBodyContext extends ParserRuleContext { + public MethodBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public TerminalNode SEMI() { + return getToken(JavaParser.SEMI, 0); + } + + @Override + public int getRuleIndex() { + return RULE_methodBody; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitMethodBody(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterMethodBody(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitMethodBody(this); + } + } + + public static class TypeTypeOrVoidContext extends ParserRuleContext { + public TypeTypeOrVoidContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TypeTypeContext typeType() { + return getRuleContext(TypeTypeContext.class, 0); + } + + public TerminalNode VOID() { + return getToken(JavaParser.VOID, 0); + } + + @Override + public int getRuleIndex() { + return RULE_typeTypeOrVoid; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitTypeTypeOrVoid(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterTypeTypeOrVoid(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitTypeTypeOrVoid(this); + } + } + + public static class GenericMethodDeclarationContext extends ParserRuleContext { + public GenericMethodDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class, 0); + } + + public MethodDeclarationContext methodDeclaration() { + return getRuleContext(MethodDeclarationContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_genericMethodDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitGenericMethodDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterGenericMethodDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitGenericMethodDeclaration(this); + } + } + + public static class GenericConstructorDeclarationContext extends ParserRuleContext { + public GenericConstructorDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class, 0); + } + + public ConstructorDeclarationContext constructorDeclaration() { + return getRuleContext(ConstructorDeclarationContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_genericConstructorDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitGenericConstructorDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterGenericConstructorDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitGenericConstructorDeclaration(this); + } + } + + public static class ConstructorDeclarationContext extends ParserRuleContext { + public BlockContext constructorBody; + + public ConstructorDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode IDENTIFIER() { + return getToken(JavaParser.IDENTIFIER, 0); + } + + public FormalParametersContext formalParameters() { + return getRuleContext(FormalParametersContext.class, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public TerminalNode THROWS() { + return getToken(JavaParser.THROWS, 0); + } + + public QualifiedNameListContext qualifiedNameList() { + return getRuleContext(QualifiedNameListContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_constructorDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitConstructorDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterConstructorDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitConstructorDeclaration(this); + } + } + + public static class FieldDeclarationContext extends ParserRuleContext { + public FieldDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TypeTypeContext typeType() { + return getRuleContext(TypeTypeContext.class, 0); + } + + public VariableDeclaratorsContext variableDeclarators() { + return getRuleContext(VariableDeclaratorsContext.class, 0); + } + + public TerminalNode SEMI() { + return getToken(JavaParser.SEMI, 0); + } + + @Override + public int getRuleIndex() { + return RULE_fieldDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitFieldDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterFieldDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitFieldDeclaration(this); + } + } + + public static class InterfaceBodyDeclarationContext extends ParserRuleContext { + public InterfaceBodyDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public InterfaceMemberDeclarationContext interfaceMemberDeclaration() { + return getRuleContext(InterfaceMemberDeclarationContext.class, 0); + } + + public List modifier() { + return getRuleContexts(ModifierContext.class); + } + + public ModifierContext modifier(int i) { + return getRuleContext(ModifierContext.class, i); + } + + public TerminalNode SEMI() { + return getToken(JavaParser.SEMI, 0); + } + + @Override + public int getRuleIndex() { + return RULE_interfaceBodyDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitInterfaceBodyDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterInterfaceBodyDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitInterfaceBodyDeclaration(this); + } + } + + public static class InterfaceMemberDeclarationContext extends ParserRuleContext { + public InterfaceMemberDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public ConstDeclarationContext constDeclaration() { + return getRuleContext(ConstDeclarationContext.class, 0); + } + + public InterfaceMethodDeclarationContext interfaceMethodDeclaration() { + return getRuleContext(InterfaceMethodDeclarationContext.class, 0); + } + + public GenericInterfaceMethodDeclarationContext genericInterfaceMethodDeclaration() { + return getRuleContext(GenericInterfaceMethodDeclarationContext.class, 0); + } + + public InterfaceDeclarationContext interfaceDeclaration() { + return getRuleContext(InterfaceDeclarationContext.class, 0); + } + + public AnnotationTypeDeclarationContext annotationTypeDeclaration() { + return getRuleContext(AnnotationTypeDeclarationContext.class, 0); + } + + public ClassDeclarationContext classDeclaration() { + return getRuleContext(ClassDeclarationContext.class, 0); + } + + public EnumDeclarationContext enumDeclaration() { + return getRuleContext(EnumDeclarationContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_interfaceMemberDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitInterfaceMemberDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterInterfaceMemberDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitInterfaceMemberDeclaration(this); + } + } + + public static class ConstDeclarationContext extends ParserRuleContext { + public ConstDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TypeTypeContext typeType() { + return getRuleContext(TypeTypeContext.class, 0); + } + + public List constantDeclarator() { + return getRuleContexts(ConstantDeclaratorContext.class); + } + + public ConstantDeclaratorContext constantDeclarator(int i) { + return getRuleContext(ConstantDeclaratorContext.class, i); + } + + public TerminalNode SEMI() { + return getToken(JavaParser.SEMI, 0); + } + + public List COMMA() { + return getTokens(JavaParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(JavaParser.COMMA, i); + } + + @Override + public int getRuleIndex() { + return RULE_constDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitConstDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterConstDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitConstDeclaration(this); + } + } + + public static class ConstantDeclaratorContext extends ParserRuleContext { + public ConstantDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode IDENTIFIER() { + return getToken(JavaParser.IDENTIFIER, 0); + } + + public TerminalNode ASSIGN() { + return getToken(JavaParser.ASSIGN, 0); + } + + public VariableInitializerContext variableInitializer() { + return getRuleContext(VariableInitializerContext.class, 0); + } + + public List LBRACK() { + return getTokens(JavaParser.LBRACK); + } + + public TerminalNode LBRACK(int i) { + return getToken(JavaParser.LBRACK, i); + } + + public List RBRACK() { + return getTokens(JavaParser.RBRACK); + } + + public TerminalNode RBRACK(int i) { + return getToken(JavaParser.RBRACK, i); + } + + @Override + public int getRuleIndex() { + return RULE_constantDeclarator; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitConstantDeclarator(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterConstantDeclarator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitConstantDeclarator(this); + } + } + + public static class InterfaceMethodDeclarationContext extends ParserRuleContext { + public InterfaceMethodDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode IDENTIFIER() { + return getToken(JavaParser.IDENTIFIER, 0); + } + + public FormalParametersContext formalParameters() { + return getRuleContext(FormalParametersContext.class, 0); + } + + public MethodBodyContext methodBody() { + return getRuleContext(MethodBodyContext.class, 0); + } + + public TypeTypeOrVoidContext typeTypeOrVoid() { + return getRuleContext(TypeTypeOrVoidContext.class, 0); + } + + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class, 0); + } + + public List interfaceMethodModifier() { + return getRuleContexts(InterfaceMethodModifierContext.class); + } + + public InterfaceMethodModifierContext interfaceMethodModifier(int i) { + return getRuleContext(InterfaceMethodModifierContext.class, i); + } + + public List LBRACK() { + return getTokens(JavaParser.LBRACK); + } + + public TerminalNode LBRACK(int i) { + return getToken(JavaParser.LBRACK, i); + } + + public List RBRACK() { + return getTokens(JavaParser.RBRACK); + } + + public TerminalNode RBRACK(int i) { + return getToken(JavaParser.RBRACK, i); + } + + public TerminalNode THROWS() { + return getToken(JavaParser.THROWS, 0); + } + + public QualifiedNameListContext qualifiedNameList() { + return getRuleContext(QualifiedNameListContext.class, 0); + } + + public List annotation() { + return getRuleContexts(AnnotationContext.class); + } + + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_interfaceMethodDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitInterfaceMethodDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterInterfaceMethodDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitInterfaceMethodDeclaration(this); + } + } + + public static class InterfaceMethodModifierContext extends ParserRuleContext { + public InterfaceMethodModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class, 0); + } + + public TerminalNode PUBLIC() { + return getToken(JavaParser.PUBLIC, 0); + } + + public TerminalNode ABSTRACT() { + return getToken(JavaParser.ABSTRACT, 0); + } + + public TerminalNode DEFAULT() { + return getToken(JavaParser.DEFAULT, 0); + } + + public TerminalNode STATIC() { + return getToken(JavaParser.STATIC, 0); + } + + public TerminalNode STRICTFP() { + return getToken(JavaParser.STRICTFP, 0); + } + + @Override + public int getRuleIndex() { + return RULE_interfaceMethodModifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitInterfaceMethodModifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterInterfaceMethodModifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitInterfaceMethodModifier(this); + } + } + + public static class GenericInterfaceMethodDeclarationContext extends ParserRuleContext { + public GenericInterfaceMethodDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class, 0); + } + + public InterfaceMethodDeclarationContext interfaceMethodDeclaration() { + return getRuleContext(InterfaceMethodDeclarationContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_genericInterfaceMethodDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor) + .visitGenericInterfaceMethodDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterGenericInterfaceMethodDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitGenericInterfaceMethodDeclaration(this); + } + } + + public static class VariableDeclaratorsContext extends ParserRuleContext { + public VariableDeclaratorsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List variableDeclarator() { + return getRuleContexts(VariableDeclaratorContext.class); + } + + public VariableDeclaratorContext variableDeclarator(int i) { + return getRuleContext(VariableDeclaratorContext.class, i); + } + + public List COMMA() { + return getTokens(JavaParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(JavaParser.COMMA, i); + } + + @Override + public int getRuleIndex() { + return RULE_variableDeclarators; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitVariableDeclarators(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterVariableDeclarators(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitVariableDeclarators(this); + } + } + + public static class VariableDeclaratorContext extends ParserRuleContext { + public VariableDeclaratorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public VariableDeclaratorIdContext variableDeclaratorId() { + return getRuleContext(VariableDeclaratorIdContext.class, 0); + } + + public TerminalNode ASSIGN() { + return getToken(JavaParser.ASSIGN, 0); + } + + public VariableInitializerContext variableInitializer() { + return getRuleContext(VariableInitializerContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_variableDeclarator; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitVariableDeclarator(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterVariableDeclarator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitVariableDeclarator(this); + } + } + + public static class VariableDeclaratorIdContext extends ParserRuleContext { + public VariableDeclaratorIdContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode IDENTIFIER() { + return getToken(JavaParser.IDENTIFIER, 0); + } + + public List LBRACK() { + return getTokens(JavaParser.LBRACK); + } + + public TerminalNode LBRACK(int i) { + return getToken(JavaParser.LBRACK, i); + } + + public List RBRACK() { + return getTokens(JavaParser.RBRACK); + } + + public TerminalNode RBRACK(int i) { + return getToken(JavaParser.RBRACK, i); + } + + @Override + public int getRuleIndex() { + return RULE_variableDeclaratorId; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitVariableDeclaratorId(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterVariableDeclaratorId(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitVariableDeclaratorId(this); + } + } + + public static class VariableInitializerContext extends ParserRuleContext { + public VariableInitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public ArrayInitializerContext arrayInitializer() { + return getRuleContext(ArrayInitializerContext.class, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_variableInitializer; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitVariableInitializer(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterVariableInitializer(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitVariableInitializer(this); + } + } + + public static class ArrayInitializerContext extends ParserRuleContext { + public ArrayInitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LBRACE() { + return getToken(JavaParser.LBRACE, 0); + } + + public TerminalNode RBRACE() { + return getToken(JavaParser.RBRACE, 0); + } + + public List variableInitializer() { + return getRuleContexts(VariableInitializerContext.class); + } + + public VariableInitializerContext variableInitializer(int i) { + return getRuleContext(VariableInitializerContext.class, i); + } + + public List COMMA() { + return getTokens(JavaParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(JavaParser.COMMA, i); + } + + @Override + public int getRuleIndex() { + return RULE_arrayInitializer; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitArrayInitializer(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterArrayInitializer(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitArrayInitializer(this); + } + } + + public static class ClassOrInterfaceTypeContext extends ParserRuleContext { + public ClassOrInterfaceTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List IDENTIFIER() { + return getTokens(JavaParser.IDENTIFIER); + } + + public TerminalNode IDENTIFIER(int i) { + return getToken(JavaParser.IDENTIFIER, i); + } + + public List typeArguments() { + return getRuleContexts(TypeArgumentsContext.class); + } + + public TypeArgumentsContext typeArguments(int i) { + return getRuleContext(TypeArgumentsContext.class, i); + } + + public List DOT() { + return getTokens(JavaParser.DOT); + } + + public TerminalNode DOT(int i) { + return getToken(JavaParser.DOT, i); + } + + @Override + public int getRuleIndex() { + return RULE_classOrInterfaceType; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitClassOrInterfaceType(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterClassOrInterfaceType(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitClassOrInterfaceType(this); + } + } + + public static class TypeArgumentContext extends ParserRuleContext { + public TypeArgumentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TypeTypeContext typeType() { + return getRuleContext(TypeTypeContext.class, 0); + } + + public TerminalNode QUESTION() { + return getToken(JavaParser.QUESTION, 0); + } + + public List annotation() { + return getRuleContexts(AnnotationContext.class); + } + + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class, i); + } + + public TerminalNode EXTENDS() { + return getToken(JavaParser.EXTENDS, 0); + } + + public TerminalNode SUPER() { + return getToken(JavaParser.SUPER, 0); + } + + @Override + public int getRuleIndex() { + return RULE_typeArgument; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitTypeArgument(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterTypeArgument(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitTypeArgument(this); + } + } + + public static class QualifiedNameListContext extends ParserRuleContext { + public QualifiedNameListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List qualifiedName() { + return getRuleContexts(QualifiedNameContext.class); + } + + public QualifiedNameContext qualifiedName(int i) { + return getRuleContext(QualifiedNameContext.class, i); + } + + public List COMMA() { + return getTokens(JavaParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(JavaParser.COMMA, i); + } + + @Override + public int getRuleIndex() { + return RULE_qualifiedNameList; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitQualifiedNameList(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterQualifiedNameList(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitQualifiedNameList(this); + } + } + + public static class FormalParametersContext extends ParserRuleContext { + public FormalParametersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LPAREN() { + return getToken(JavaParser.LPAREN, 0); + } + + public TerminalNode RPAREN() { + return getToken(JavaParser.RPAREN, 0); + } + + public FormalParameterListContext formalParameterList() { + return getRuleContext(FormalParameterListContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_formalParameters; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitFormalParameters(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterFormalParameters(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitFormalParameters(this); + } + } + + public static class FormalParameterListContext extends ParserRuleContext { + public FormalParameterListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List formalParameter() { + return getRuleContexts(FormalParameterContext.class); + } + + public FormalParameterContext formalParameter(int i) { + return getRuleContext(FormalParameterContext.class, i); + } + + public List COMMA() { + return getTokens(JavaParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(JavaParser.COMMA, i); + } + + public LastFormalParameterContext lastFormalParameter() { + return getRuleContext(LastFormalParameterContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_formalParameterList; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitFormalParameterList(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterFormalParameterList(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitFormalParameterList(this); + } + } + + public static class FormalParameterContext extends ParserRuleContext { + public FormalParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TypeTypeContext typeType() { + return getRuleContext(TypeTypeContext.class, 0); + } + + public VariableDeclaratorIdContext variableDeclaratorId() { + return getRuleContext(VariableDeclaratorIdContext.class, 0); + } + + public List variableModifier() { + return getRuleContexts(VariableModifierContext.class); + } + + public VariableModifierContext variableModifier(int i) { + return getRuleContext(VariableModifierContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_formalParameter; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitFormalParameter(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterFormalParameter(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitFormalParameter(this); + } + } + + public static class LastFormalParameterContext extends ParserRuleContext { + public LastFormalParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TypeTypeContext typeType() { + return getRuleContext(TypeTypeContext.class, 0); + } + + public TerminalNode ELLIPSIS() { + return getToken(JavaParser.ELLIPSIS, 0); + } + + public VariableDeclaratorIdContext variableDeclaratorId() { + return getRuleContext(VariableDeclaratorIdContext.class, 0); + } + + public List variableModifier() { + return getRuleContexts(VariableModifierContext.class); + } + + public VariableModifierContext variableModifier(int i) { + return getRuleContext(VariableModifierContext.class, i); + } + + public List annotation() { + return getRuleContexts(AnnotationContext.class); + } + + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_lastFormalParameter; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitLastFormalParameter(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterLastFormalParameter(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitLastFormalParameter(this); + } + } + + public static class QualifiedNameContext extends ParserRuleContext { + public QualifiedNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List IDENTIFIER() { + return getTokens(JavaParser.IDENTIFIER); + } + + public TerminalNode IDENTIFIER(int i) { + return getToken(JavaParser.IDENTIFIER, i); + } + + public List DOT() { + return getTokens(JavaParser.DOT); + } + + public TerminalNode DOT(int i) { + return getToken(JavaParser.DOT, i); + } + + @Override + public int getRuleIndex() { + return RULE_qualifiedName; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitQualifiedName(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterQualifiedName(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitQualifiedName(this); + } + } + + public static class LiteralContext extends ParserRuleContext { + public LiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public IntegerLiteralContext integerLiteral() { + return getRuleContext(IntegerLiteralContext.class, 0); + } + + public FloatLiteralContext floatLiteral() { + return getRuleContext(FloatLiteralContext.class, 0); + } + + public TerminalNode CHAR_LITERAL() { + return getToken(JavaParser.CHAR_LITERAL, 0); + } + + public TerminalNode STRING_LITERAL() { + return getToken(JavaParser.STRING_LITERAL, 0); + } + + public TerminalNode BOOL_LITERAL() { + return getToken(JavaParser.BOOL_LITERAL, 0); + } + + public TerminalNode NULL_LITERAL() { + return getToken(JavaParser.NULL_LITERAL, 0); + } + + @Override + public int getRuleIndex() { + return RULE_literal; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitLiteral(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterLiteral(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) ((JavaParserListener) listener).exitLiteral(this); + } + } + + public static class IntegerLiteralContext extends ParserRuleContext { + public IntegerLiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode DECIMAL_LITERAL() { + return getToken(JavaParser.DECIMAL_LITERAL, 0); + } + + public TerminalNode HEX_LITERAL() { + return getToken(JavaParser.HEX_LITERAL, 0); + } + + public TerminalNode OCT_LITERAL() { + return getToken(JavaParser.OCT_LITERAL, 0); + } + + public TerminalNode BINARY_LITERAL() { + return getToken(JavaParser.BINARY_LITERAL, 0); + } + + @Override + public int getRuleIndex() { + return RULE_integerLiteral; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitIntegerLiteral(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterIntegerLiteral(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitIntegerLiteral(this); + } + } + + public static class FloatLiteralContext extends ParserRuleContext { + public FloatLiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode FLOAT_LITERAL() { + return getToken(JavaParser.FLOAT_LITERAL, 0); + } + + public TerminalNode HEX_FLOAT_LITERAL() { + return getToken(JavaParser.HEX_FLOAT_LITERAL, 0); + } + + @Override + public int getRuleIndex() { + return RULE_floatLiteral; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitFloatLiteral(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterFloatLiteral(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitFloatLiteral(this); + } + } + + public static class AltAnnotationQualifiedNameContext extends ParserRuleContext { + public AltAnnotationQualifiedNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode AT() { + return getToken(JavaParser.AT, 0); + } + + public List IDENTIFIER() { + return getTokens(JavaParser.IDENTIFIER); + } + + public TerminalNode IDENTIFIER(int i) { + return getToken(JavaParser.IDENTIFIER, i); + } + + public List DOT() { + return getTokens(JavaParser.DOT); + } + + public TerminalNode DOT(int i) { + return getToken(JavaParser.DOT, i); + } + + @Override + public int getRuleIndex() { + return RULE_altAnnotationQualifiedName; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitAltAnnotationQualifiedName(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterAltAnnotationQualifiedName(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitAltAnnotationQualifiedName(this); + } + } + + public static class AnnotationContext extends ParserRuleContext { + public AnnotationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode AT() { + return getToken(JavaParser.AT, 0); + } + + public QualifiedNameContext qualifiedName() { + return getRuleContext(QualifiedNameContext.class, 0); + } + + public AltAnnotationQualifiedNameContext altAnnotationQualifiedName() { + return getRuleContext(AltAnnotationQualifiedNameContext.class, 0); + } + + public TerminalNode LPAREN() { + return getToken(JavaParser.LPAREN, 0); + } + + public TerminalNode RPAREN() { + return getToken(JavaParser.RPAREN, 0); + } + + public ElementValuePairsContext elementValuePairs() { + return getRuleContext(ElementValuePairsContext.class, 0); + } + + public ElementValueContext elementValue() { + return getRuleContext(ElementValueContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_annotation; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitAnnotation(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterAnnotation(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitAnnotation(this); + } + } + + public static class ElementValuePairsContext extends ParserRuleContext { + public ElementValuePairsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List elementValuePair() { + return getRuleContexts(ElementValuePairContext.class); + } + + public ElementValuePairContext elementValuePair(int i) { + return getRuleContext(ElementValuePairContext.class, i); + } + + public List COMMA() { + return getTokens(JavaParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(JavaParser.COMMA, i); + } + + @Override + public int getRuleIndex() { + return RULE_elementValuePairs; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitElementValuePairs(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterElementValuePairs(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitElementValuePairs(this); + } + } + + public static class ElementValuePairContext extends ParserRuleContext { + public ElementValuePairContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode IDENTIFIER() { + return getToken(JavaParser.IDENTIFIER, 0); + } + + public TerminalNode ASSIGN() { + return getToken(JavaParser.ASSIGN, 0); + } + + public ElementValueContext elementValue() { + return getRuleContext(ElementValueContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_elementValuePair; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitElementValuePair(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterElementValuePair(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitElementValuePair(this); + } + } + + public static class ElementValueContext extends ParserRuleContext { + public ElementValueContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class, 0); + } + + public ElementValueArrayInitializerContext elementValueArrayInitializer() { + return getRuleContext(ElementValueArrayInitializerContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_elementValue; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitElementValue(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterElementValue(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitElementValue(this); + } + } + + public static class ElementValueArrayInitializerContext extends ParserRuleContext { + public ElementValueArrayInitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LBRACE() { + return getToken(JavaParser.LBRACE, 0); + } + + public TerminalNode RBRACE() { + return getToken(JavaParser.RBRACE, 0); + } + + public List elementValue() { + return getRuleContexts(ElementValueContext.class); + } + + public ElementValueContext elementValue(int i) { + return getRuleContext(ElementValueContext.class, i); + } + + public List COMMA() { + return getTokens(JavaParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(JavaParser.COMMA, i); + } + + @Override + public int getRuleIndex() { + return RULE_elementValueArrayInitializer; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitElementValueArrayInitializer(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterElementValueArrayInitializer(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitElementValueArrayInitializer(this); + } + } + + public static class AnnotationTypeDeclarationContext extends ParserRuleContext { + public AnnotationTypeDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode AT() { + return getToken(JavaParser.AT, 0); + } + + public TerminalNode INTERFACE() { + return getToken(JavaParser.INTERFACE, 0); + } + + public TerminalNode IDENTIFIER() { + return getToken(JavaParser.IDENTIFIER, 0); + } + + public AnnotationTypeBodyContext annotationTypeBody() { + return getRuleContext(AnnotationTypeBodyContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_annotationTypeDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitAnnotationTypeDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterAnnotationTypeDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitAnnotationTypeDeclaration(this); + } + } + + public static class AnnotationTypeBodyContext extends ParserRuleContext { + public AnnotationTypeBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LBRACE() { + return getToken(JavaParser.LBRACE, 0); + } + + public TerminalNode RBRACE() { + return getToken(JavaParser.RBRACE, 0); + } + + public List annotationTypeElementDeclaration() { + return getRuleContexts(AnnotationTypeElementDeclarationContext.class); + } + + public AnnotationTypeElementDeclarationContext annotationTypeElementDeclaration(int i) { + return getRuleContext(AnnotationTypeElementDeclarationContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_annotationTypeBody; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitAnnotationTypeBody(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterAnnotationTypeBody(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitAnnotationTypeBody(this); + } + } + + public static class AnnotationTypeElementDeclarationContext extends ParserRuleContext { + public AnnotationTypeElementDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public AnnotationTypeElementRestContext annotationTypeElementRest() { + return getRuleContext(AnnotationTypeElementRestContext.class, 0); + } + + public List modifier() { + return getRuleContexts(ModifierContext.class); + } + + public ModifierContext modifier(int i) { + return getRuleContext(ModifierContext.class, i); + } + + public TerminalNode SEMI() { + return getToken(JavaParser.SEMI, 0); + } + + @Override + public int getRuleIndex() { + return RULE_annotationTypeElementDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor) + .visitAnnotationTypeElementDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterAnnotationTypeElementDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitAnnotationTypeElementDeclaration(this); + } + } + + public static class AnnotationTypeElementRestContext extends ParserRuleContext { + public AnnotationTypeElementRestContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TypeTypeContext typeType() { + return getRuleContext(TypeTypeContext.class, 0); + } + + public AnnotationMethodOrConstantRestContext annotationMethodOrConstantRest() { + return getRuleContext(AnnotationMethodOrConstantRestContext.class, 0); + } + + public TerminalNode SEMI() { + return getToken(JavaParser.SEMI, 0); + } + + public ClassDeclarationContext classDeclaration() { + return getRuleContext(ClassDeclarationContext.class, 0); + } + + public InterfaceDeclarationContext interfaceDeclaration() { + return getRuleContext(InterfaceDeclarationContext.class, 0); + } + + public EnumDeclarationContext enumDeclaration() { + return getRuleContext(EnumDeclarationContext.class, 0); + } + + public AnnotationTypeDeclarationContext annotationTypeDeclaration() { + return getRuleContext(AnnotationTypeDeclarationContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_annotationTypeElementRest; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitAnnotationTypeElementRest(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterAnnotationTypeElementRest(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitAnnotationTypeElementRest(this); + } + } + + public static class AnnotationMethodOrConstantRestContext extends ParserRuleContext { + public AnnotationMethodOrConstantRestContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public AnnotationMethodRestContext annotationMethodRest() { + return getRuleContext(AnnotationMethodRestContext.class, 0); + } + + public AnnotationConstantRestContext annotationConstantRest() { + return getRuleContext(AnnotationConstantRestContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_annotationMethodOrConstantRest; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitAnnotationMethodOrConstantRest(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterAnnotationMethodOrConstantRest(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitAnnotationMethodOrConstantRest(this); + } + } + + public static class AnnotationMethodRestContext extends ParserRuleContext { + public AnnotationMethodRestContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode IDENTIFIER() { + return getToken(JavaParser.IDENTIFIER, 0); + } + + public TerminalNode LPAREN() { + return getToken(JavaParser.LPAREN, 0); + } + + public TerminalNode RPAREN() { + return getToken(JavaParser.RPAREN, 0); + } + + public DefaultValueContext defaultValue() { + return getRuleContext(DefaultValueContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_annotationMethodRest; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitAnnotationMethodRest(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterAnnotationMethodRest(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitAnnotationMethodRest(this); + } + } + + public static class AnnotationConstantRestContext extends ParserRuleContext { + public AnnotationConstantRestContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public VariableDeclaratorsContext variableDeclarators() { + return getRuleContext(VariableDeclaratorsContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_annotationConstantRest; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitAnnotationConstantRest(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterAnnotationConstantRest(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitAnnotationConstantRest(this); + } + } + + public static class DefaultValueContext extends ParserRuleContext { + public DefaultValueContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode DEFAULT() { + return getToken(JavaParser.DEFAULT, 0); + } + + public ElementValueContext elementValue() { + return getRuleContext(ElementValueContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_defaultValue; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitDefaultValue(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterDefaultValue(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitDefaultValue(this); + } + } + + public static class BlockContext extends ParserRuleContext { + public BlockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LBRACE() { + return getToken(JavaParser.LBRACE, 0); + } + + public TerminalNode RBRACE() { + return getToken(JavaParser.RBRACE, 0); + } + + public List blockStatement() { + return getRuleContexts(BlockStatementContext.class); + } + + public BlockStatementContext blockStatement(int i) { + return getRuleContext(BlockStatementContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_block; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitBlock(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) ((JavaParserListener) listener).enterBlock(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) ((JavaParserListener) listener).exitBlock(this); + } + } + + public static class BlockStatementContext extends ParserRuleContext { + public BlockStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public LocalVariableDeclarationContext localVariableDeclaration() { + return getRuleContext(LocalVariableDeclarationContext.class, 0); + } + + public TerminalNode SEMI() { + return getToken(JavaParser.SEMI, 0); + } + + public StatementContext statement() { + return getRuleContext(StatementContext.class, 0); + } + + public LocalTypeDeclarationContext localTypeDeclaration() { + return getRuleContext(LocalTypeDeclarationContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_blockStatement; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitBlockStatement(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterBlockStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitBlockStatement(this); + } + } + + public static class LocalVariableDeclarationContext extends ParserRuleContext { + public LocalVariableDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TypeTypeContext typeType() { + return getRuleContext(TypeTypeContext.class, 0); + } + + public VariableDeclaratorsContext variableDeclarators() { + return getRuleContext(VariableDeclaratorsContext.class, 0); + } + + public List variableModifier() { + return getRuleContexts(VariableModifierContext.class); + } + + public VariableModifierContext variableModifier(int i) { + return getRuleContext(VariableModifierContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_localVariableDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitLocalVariableDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterLocalVariableDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitLocalVariableDeclaration(this); + } + } + + public static class LocalTypeDeclarationContext extends ParserRuleContext { + public LocalTypeDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public ClassDeclarationContext classDeclaration() { + return getRuleContext(ClassDeclarationContext.class, 0); + } + + public InterfaceDeclarationContext interfaceDeclaration() { + return getRuleContext(InterfaceDeclarationContext.class, 0); + } + + public List classOrInterfaceModifier() { + return getRuleContexts(ClassOrInterfaceModifierContext.class); + } + + public ClassOrInterfaceModifierContext classOrInterfaceModifier(int i) { + return getRuleContext(ClassOrInterfaceModifierContext.class, i); + } + + public TerminalNode SEMI() { + return getToken(JavaParser.SEMI, 0); + } + + @Override + public int getRuleIndex() { + return RULE_localTypeDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitLocalTypeDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterLocalTypeDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitLocalTypeDeclaration(this); + } + } + + public static class StatementContext extends ParserRuleContext { + public BlockContext blockLabel; + public ExpressionContext statementExpression; + public Token identifierLabel; + + public StatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public TerminalNode ASSERT() { + return getToken(JavaParser.ASSERT, 0); + } + + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class, i); + } + + public TerminalNode SEMI() { + return getToken(JavaParser.SEMI, 0); + } + + public TerminalNode COLON() { + return getToken(JavaParser.COLON, 0); + } + + public TerminalNode IF() { + return getToken(JavaParser.IF, 0); + } + + public ParExpressionContext parExpression() { + return getRuleContext(ParExpressionContext.class, 0); + } + + public List statement() { + return getRuleContexts(StatementContext.class); + } + + public StatementContext statement(int i) { + return getRuleContext(StatementContext.class, i); + } + + public TerminalNode ELSE() { + return getToken(JavaParser.ELSE, 0); + } + + public TerminalNode FOR() { + return getToken(JavaParser.FOR, 0); + } + + public TerminalNode LPAREN() { + return getToken(JavaParser.LPAREN, 0); + } + + public ForControlContext forControl() { + return getRuleContext(ForControlContext.class, 0); + } + + public TerminalNode RPAREN() { + return getToken(JavaParser.RPAREN, 0); + } + + public TerminalNode WHILE() { + return getToken(JavaParser.WHILE, 0); + } + + public TerminalNode DO() { + return getToken(JavaParser.DO, 0); + } + + public TerminalNode TRY() { + return getToken(JavaParser.TRY, 0); + } + + public FinallyBlockContext finallyBlock() { + return getRuleContext(FinallyBlockContext.class, 0); + } + + public List catchClause() { + return getRuleContexts(CatchClauseContext.class); + } + + public CatchClauseContext catchClause(int i) { + return getRuleContext(CatchClauseContext.class, i); + } + + public ResourceSpecificationContext resourceSpecification() { + return getRuleContext(ResourceSpecificationContext.class, 0); + } + + public TerminalNode SWITCH() { + return getToken(JavaParser.SWITCH, 0); + } + + public TerminalNode LBRACE() { + return getToken(JavaParser.LBRACE, 0); + } + + public TerminalNode RBRACE() { + return getToken(JavaParser.RBRACE, 0); + } + + public List switchBlockStatementGroup() { + return getRuleContexts(SwitchBlockStatementGroupContext.class); + } + + public SwitchBlockStatementGroupContext switchBlockStatementGroup(int i) { + return getRuleContext(SwitchBlockStatementGroupContext.class, i); + } + + public List switchLabel() { + return getRuleContexts(SwitchLabelContext.class); + } + + public SwitchLabelContext switchLabel(int i) { + return getRuleContext(SwitchLabelContext.class, i); + } + + public TerminalNode SYNCHRONIZED() { + return getToken(JavaParser.SYNCHRONIZED, 0); + } + + public TerminalNode RETURN() { + return getToken(JavaParser.RETURN, 0); + } + + public TerminalNode THROW() { + return getToken(JavaParser.THROW, 0); + } + + public TerminalNode BREAK() { + return getToken(JavaParser.BREAK, 0); + } + + public TerminalNode IDENTIFIER() { + return getToken(JavaParser.IDENTIFIER, 0); + } + + public TerminalNode CONTINUE() { + return getToken(JavaParser.CONTINUE, 0); + } + + @Override + public int getRuleIndex() { + return RULE_statement; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitStatement(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitStatement(this); + } + } + + public static class CatchClauseContext extends ParserRuleContext { + public CatchClauseContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode CATCH() { + return getToken(JavaParser.CATCH, 0); + } + + public TerminalNode LPAREN() { + return getToken(JavaParser.LPAREN, 0); + } + + public CatchTypeContext catchType() { + return getRuleContext(CatchTypeContext.class, 0); + } + + public TerminalNode IDENTIFIER() { + return getToken(JavaParser.IDENTIFIER, 0); + } + + public TerminalNode RPAREN() { + return getToken(JavaParser.RPAREN, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public List variableModifier() { + return getRuleContexts(VariableModifierContext.class); + } + + public VariableModifierContext variableModifier(int i) { + return getRuleContext(VariableModifierContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_catchClause; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitCatchClause(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterCatchClause(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitCatchClause(this); + } + } + + public static class CatchTypeContext extends ParserRuleContext { + public CatchTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List qualifiedName() { + return getRuleContexts(QualifiedNameContext.class); + } + + public QualifiedNameContext qualifiedName(int i) { + return getRuleContext(QualifiedNameContext.class, i); + } + + public List BITOR() { + return getTokens(JavaParser.BITOR); + } + + public TerminalNode BITOR(int i) { + return getToken(JavaParser.BITOR, i); + } + + @Override + public int getRuleIndex() { + return RULE_catchType; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitCatchType(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterCatchType(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitCatchType(this); + } + } + + public static class FinallyBlockContext extends ParserRuleContext { + public FinallyBlockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode FINALLY() { + return getToken(JavaParser.FINALLY, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_finallyBlock; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitFinallyBlock(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterFinallyBlock(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitFinallyBlock(this); + } + } + + public static class ResourceSpecificationContext extends ParserRuleContext { + public ResourceSpecificationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LPAREN() { + return getToken(JavaParser.LPAREN, 0); + } + + public ResourcesContext resources() { + return getRuleContext(ResourcesContext.class, 0); + } + + public TerminalNode RPAREN() { + return getToken(JavaParser.RPAREN, 0); + } + + public TerminalNode SEMI() { + return getToken(JavaParser.SEMI, 0); + } + + @Override + public int getRuleIndex() { + return RULE_resourceSpecification; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitResourceSpecification(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterResourceSpecification(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitResourceSpecification(this); + } + } + + public static class ResourcesContext extends ParserRuleContext { + public ResourcesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List resource() { + return getRuleContexts(ResourceContext.class); + } + + public ResourceContext resource(int i) { + return getRuleContext(ResourceContext.class, i); + } + + public List SEMI() { + return getTokens(JavaParser.SEMI); + } + + public TerminalNode SEMI(int i) { + return getToken(JavaParser.SEMI, i); + } + + @Override + public int getRuleIndex() { + return RULE_resources; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitResources(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterResources(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitResources(this); + } + } + + public static class ResourceContext extends ParserRuleContext { + public ResourceContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public ClassOrInterfaceTypeContext classOrInterfaceType() { + return getRuleContext(ClassOrInterfaceTypeContext.class, 0); + } + + public VariableDeclaratorIdContext variableDeclaratorId() { + return getRuleContext(VariableDeclaratorIdContext.class, 0); + } + + public TerminalNode ASSIGN() { + return getToken(JavaParser.ASSIGN, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public List variableModifier() { + return getRuleContexts(VariableModifierContext.class); + } + + public VariableModifierContext variableModifier(int i) { + return getRuleContext(VariableModifierContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_resource; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitResource(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterResource(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitResource(this); + } + } + + public static class SwitchBlockStatementGroupContext extends ParserRuleContext { + public SwitchBlockStatementGroupContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List switchLabel() { + return getRuleContexts(SwitchLabelContext.class); + } + + public SwitchLabelContext switchLabel(int i) { + return getRuleContext(SwitchLabelContext.class, i); + } + + public List blockStatement() { + return getRuleContexts(BlockStatementContext.class); + } + + public BlockStatementContext blockStatement(int i) { + return getRuleContext(BlockStatementContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_switchBlockStatementGroup; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitSwitchBlockStatementGroup(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterSwitchBlockStatementGroup(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitSwitchBlockStatementGroup(this); + } + } + + public static class SwitchLabelContext extends ParserRuleContext { + public ExpressionContext constantExpression; + public Token enumConstantName; + + public SwitchLabelContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode CASE() { + return getToken(JavaParser.CASE, 0); + } + + public TerminalNode COLON() { + return getToken(JavaParser.COLON, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode IDENTIFIER() { + return getToken(JavaParser.IDENTIFIER, 0); + } + + public TerminalNode DEFAULT() { + return getToken(JavaParser.DEFAULT, 0); + } + + @Override + public int getRuleIndex() { + return RULE_switchLabel; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitSwitchLabel(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterSwitchLabel(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitSwitchLabel(this); + } + } + + public static class ForControlContext extends ParserRuleContext { + public ExpressionListContext forUpdate; + + public ForControlContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public EnhancedForControlContext enhancedForControl() { + return getRuleContext(EnhancedForControlContext.class, 0); + } + + public List SEMI() { + return getTokens(JavaParser.SEMI); + } + + public TerminalNode SEMI(int i) { + return getToken(JavaParser.SEMI, i); + } + + public ForInitContext forInit() { + return getRuleContext(ForInitContext.class, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public ExpressionListContext expressionList() { + return getRuleContext(ExpressionListContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_forControl; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitForControl(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterForControl(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitForControl(this); + } + } + + public static class ForInitContext extends ParserRuleContext { + public ForInitContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public LocalVariableDeclarationContext localVariableDeclaration() { + return getRuleContext(LocalVariableDeclarationContext.class, 0); + } + + public ExpressionListContext expressionList() { + return getRuleContext(ExpressionListContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_forInit; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitForInit(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterForInit(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) ((JavaParserListener) listener).exitForInit(this); + } + } + + public static class EnhancedForControlContext extends ParserRuleContext { + public EnhancedForControlContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TypeTypeContext typeType() { + return getRuleContext(TypeTypeContext.class, 0); + } + + public VariableDeclaratorIdContext variableDeclaratorId() { + return getRuleContext(VariableDeclaratorIdContext.class, 0); + } + + public TerminalNode COLON() { + return getToken(JavaParser.COLON, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public List variableModifier() { + return getRuleContexts(VariableModifierContext.class); + } + + public VariableModifierContext variableModifier(int i) { + return getRuleContext(VariableModifierContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_enhancedForControl; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitEnhancedForControl(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterEnhancedForControl(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitEnhancedForControl(this); + } + } + + public static class ParExpressionContext extends ParserRuleContext { + public ParExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LPAREN() { + return getToken(JavaParser.LPAREN, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode RPAREN() { + return getToken(JavaParser.RPAREN, 0); + } + + @Override + public int getRuleIndex() { + return RULE_parExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitParExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterParExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitParExpression(this); + } + } + + public static class ExpressionListContext extends ParserRuleContext { + public ExpressionListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class, i); + } + + public List COMMA() { + return getTokens(JavaParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(JavaParser.COMMA, i); + } + + @Override + public int getRuleIndex() { + return RULE_expressionList; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitExpressionList(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterExpressionList(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitExpressionList(this); + } + } + + public static class MethodCallContext extends ParserRuleContext { + public MethodCallContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode IDENTIFIER() { + return getToken(JavaParser.IDENTIFIER, 0); + } + + public TerminalNode LPAREN() { + return getToken(JavaParser.LPAREN, 0); + } + + public TerminalNode RPAREN() { + return getToken(JavaParser.RPAREN, 0); + } + + public ExpressionListContext expressionList() { + return getRuleContext(ExpressionListContext.class, 0); + } + + public TerminalNode THIS() { + return getToken(JavaParser.THIS, 0); + } + + public TerminalNode SUPER() { + return getToken(JavaParser.SUPER, 0); + } + + @Override + public int getRuleIndex() { + return RULE_methodCall; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitMethodCall(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterMethodCall(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitMethodCall(this); + } + } + + public static class ExpressionContext extends ParserRuleContext { + public Token prefix; + public Token bop; + public Token postfix; + + public ExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public PrimaryContext primary() { + return getRuleContext(PrimaryContext.class, 0); + } + + public MethodCallContext methodCall() { + return getRuleContext(MethodCallContext.class, 0); + } + + public TerminalNode NEW() { + return getToken(JavaParser.NEW, 0); + } + + public CreatorContext creator() { + return getRuleContext(CreatorContext.class, 0); + } + + public TerminalNode LPAREN() { + return getToken(JavaParser.LPAREN, 0); + } + + public List typeType() { + return getRuleContexts(TypeTypeContext.class); + } + + public TypeTypeContext typeType(int i) { + return getRuleContext(TypeTypeContext.class, i); + } + + public TerminalNode RPAREN() { + return getToken(JavaParser.RPAREN, 0); + } + + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class, i); + } + + public List annotation() { + return getRuleContexts(AnnotationContext.class); + } + + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class, i); + } + + public List BITAND() { + return getTokens(JavaParser.BITAND); + } + + public TerminalNode BITAND(int i) { + return getToken(JavaParser.BITAND, i); + } + + public TerminalNode ADD() { + return getToken(JavaParser.ADD, 0); + } + + public TerminalNode SUB() { + return getToken(JavaParser.SUB, 0); + } + + public TerminalNode INC() { + return getToken(JavaParser.INC, 0); + } + + public TerminalNode DEC() { + return getToken(JavaParser.DEC, 0); + } + + public TerminalNode TILDE() { + return getToken(JavaParser.TILDE, 0); + } + + public TerminalNode BANG() { + return getToken(JavaParser.BANG, 0); + } + + public LambdaExpressionContext lambdaExpression() { + return getRuleContext(LambdaExpressionContext.class, 0); + } + + public TerminalNode COLONCOLON() { + return getToken(JavaParser.COLONCOLON, 0); + } + + public TerminalNode IDENTIFIER() { + return getToken(JavaParser.IDENTIFIER, 0); + } + + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class, 0); + } + + public ClassTypeContext classType() { + return getRuleContext(ClassTypeContext.class, 0); + } + + public TerminalNode MUL() { + return getToken(JavaParser.MUL, 0); + } + + public TerminalNode DIV() { + return getToken(JavaParser.DIV, 0); + } + + public TerminalNode MOD() { + return getToken(JavaParser.MOD, 0); + } + + public List LT() { + return getTokens(JavaParser.LT); + } + + public TerminalNode LT(int i) { + return getToken(JavaParser.LT, i); + } + + public List GT() { + return getTokens(JavaParser.GT); + } + + public TerminalNode GT(int i) { + return getToken(JavaParser.GT, i); + } + + public TerminalNode LE() { + return getToken(JavaParser.LE, 0); + } + + public TerminalNode GE() { + return getToken(JavaParser.GE, 0); + } + + public TerminalNode EQUAL() { + return getToken(JavaParser.EQUAL, 0); + } + + public TerminalNode NOTEQUAL() { + return getToken(JavaParser.NOTEQUAL, 0); + } + + public TerminalNode CARET() { + return getToken(JavaParser.CARET, 0); + } + + public TerminalNode BITOR() { + return getToken(JavaParser.BITOR, 0); + } + + public TerminalNode AND() { + return getToken(JavaParser.AND, 0); + } + + public TerminalNode OR() { + return getToken(JavaParser.OR, 0); + } + + public TerminalNode COLON() { + return getToken(JavaParser.COLON, 0); + } + + public TerminalNode QUESTION() { + return getToken(JavaParser.QUESTION, 0); + } + + public TerminalNode ASSIGN() { + return getToken(JavaParser.ASSIGN, 0); + } + + public TerminalNode ADD_ASSIGN() { + return getToken(JavaParser.ADD_ASSIGN, 0); + } + + public TerminalNode SUB_ASSIGN() { + return getToken(JavaParser.SUB_ASSIGN, 0); + } + + public TerminalNode MUL_ASSIGN() { + return getToken(JavaParser.MUL_ASSIGN, 0); + } + + public TerminalNode DIV_ASSIGN() { + return getToken(JavaParser.DIV_ASSIGN, 0); + } + + public TerminalNode AND_ASSIGN() { + return getToken(JavaParser.AND_ASSIGN, 0); + } + + public TerminalNode OR_ASSIGN() { + return getToken(JavaParser.OR_ASSIGN, 0); + } + + public TerminalNode XOR_ASSIGN() { + return getToken(JavaParser.XOR_ASSIGN, 0); + } + + public TerminalNode RSHIFT_ASSIGN() { + return getToken(JavaParser.RSHIFT_ASSIGN, 0); + } + + public TerminalNode URSHIFT_ASSIGN() { + return getToken(JavaParser.URSHIFT_ASSIGN, 0); + } + + public TerminalNode LSHIFT_ASSIGN() { + return getToken(JavaParser.LSHIFT_ASSIGN, 0); + } + + public TerminalNode MOD_ASSIGN() { + return getToken(JavaParser.MOD_ASSIGN, 0); + } + + public TerminalNode DOT() { + return getToken(JavaParser.DOT, 0); + } + + public TerminalNode THIS() { + return getToken(JavaParser.THIS, 0); + } + + public InnerCreatorContext innerCreator() { + return getRuleContext(InnerCreatorContext.class, 0); + } + + public TerminalNode SUPER() { + return getToken(JavaParser.SUPER, 0); + } + + public SuperSuffixContext superSuffix() { + return getRuleContext(SuperSuffixContext.class, 0); + } + + public ExplicitGenericInvocationContext explicitGenericInvocation() { + return getRuleContext(ExplicitGenericInvocationContext.class, 0); + } + + public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() { + return getRuleContext(NonWildcardTypeArgumentsContext.class, 0); + } + + public TerminalNode LBRACK() { + return getToken(JavaParser.LBRACK, 0); + } + + public TerminalNode RBRACK() { + return getToken(JavaParser.RBRACK, 0); + } + + public TerminalNode INSTANCEOF() { + return getToken(JavaParser.INSTANCEOF, 0); + } + + @Override + public int getRuleIndex() { + return RULE_expression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).enterExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavaParserListener) + ((JavaParserListener) listener).exitExpression(this); + } + } + public static class LambdaExpressionContext extends ParserRuleContext { + public LambdaExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + public LambdaParametersContext lambdaParameters() { return getRuleContext(LambdaParametersContext.class, 0); } @@ -10633,15 +12371,18 @@ public class JavaParser extends Parser { return getRuleContext(LambdaBodyContext.class, 0); } - public LambdaExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_lambdaExpression; } + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitLambdaExpression(this); + else return visitor.visitChildren(this); + } + @Override public void enterRule(ParseTreeListener listener) { if (listener instanceof JavaParserListener) @@ -10653,39 +12394,13 @@ public class JavaParser extends Parser { if (listener instanceof JavaParserListener) ((JavaParserListener) listener).exitLambdaExpression(this); } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitLambdaExpression(this); - else return visitor.visitChildren(this); - } - } - - public final LambdaExpressionContext lambdaExpression() throws RecognitionException { - LambdaExpressionContext _localctx = new LambdaExpressionContext(_ctx, getState()); - enterRule(_localctx, 168, RULE_lambdaExpression); - try { - enterOuterAlt(_localctx, 1); - { - setState(1226); - lambdaParameters(); - setState(1227); - match(ARROW); - setState(1228); - lambdaBody(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; } public static class LambdaParametersContext extends ParserRuleContext { + public LambdaParametersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + public List IDENTIFIER() { return getTokens(JavaParser.IDENTIFIER); } @@ -10714,15 +12429,18 @@ public class JavaParser extends Parser { return getToken(JavaParser.COMMA, i); } - public LambdaParametersContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_lambdaParameters; } + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitLambdaParameters(this); + else return visitor.visitChildren(this); + } + @Override public void enterRule(ParseTreeListener listener) { if (listener instanceof JavaParserListener) @@ -10734,101 +12452,13 @@ public class JavaParser extends Parser { if (listener instanceof JavaParserListener) ((JavaParserListener) listener).exitLambdaParameters(this); } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitLambdaParameters(this); - else return visitor.visitChildren(this); - } - } - - public final LambdaParametersContext lambdaParameters() throws RecognitionException { - LambdaParametersContext _localctx = new LambdaParametersContext(_ctx, getState()); - enterRule(_localctx, 170, RULE_lambdaParameters); - int _la; - try { - setState(1246); - _errHandler.sync(this); - switch (getInterpreter().adaptivePredict(_input, 148, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1230); - match(IDENTIFIER); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1231); - match(LPAREN); - setState(1233); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 - && ((1L << _la) - & ((1L << BOOLEAN) - | (1L << BYTE) - | (1L << CHAR) - | (1L << DOUBLE) - | (1L << FINAL) - | (1L << FLOAT) - | (1L << INT) - | (1L << LONG) - | (1L << SHORT))) - != 0) - || _la == AT - || _la == IDENTIFIER) { - { - setState(1232); - formalParameterList(); - } - } - - setState(1235); - match(RPAREN); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1236); - match(LPAREN); - setState(1237); - match(IDENTIFIER); - setState(1242); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == COMMA) { - { - { - setState(1238); - match(COMMA); - setState(1239); - match(IDENTIFIER); - } - } - setState(1244); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1245); - match(RPAREN); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; } public static class LambdaBodyContext extends ParserRuleContext { + public LambdaBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + public ExpressionContext expression() { return getRuleContext(ExpressionContext.class, 0); } @@ -10837,15 +12467,18 @@ public class JavaParser extends Parser { return getRuleContext(BlockContext.class, 0); } - public LambdaBodyContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_lambdaBody; } + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitLambdaBody(this); + else return visitor.visitChildren(this); + } + @Override public void enterRule(ParseTreeListener listener) { if (listener instanceof JavaParserListener) @@ -10857,81 +12490,13 @@ public class JavaParser extends Parser { if (listener instanceof JavaParserListener) ((JavaParserListener) listener).exitLambdaBody(this); } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitLambdaBody(this); - else return visitor.visitChildren(this); - } - } - - public final LambdaBodyContext lambdaBody() throws RecognitionException { - LambdaBodyContext _localctx = new LambdaBodyContext(_ctx, getState()); - enterRule(_localctx, 172, RULE_lambdaBody); - try { - setState(1250); - _errHandler.sync(this); - switch (_input.LA(1)) { - case BOOLEAN: - case BYTE: - case CHAR: - case DOUBLE: - case FLOAT: - case INT: - case LONG: - case NEW: - case SHORT: - case SUPER: - case THIS: - case VOID: - case DECIMAL_LITERAL: - case HEX_LITERAL: - case OCT_LITERAL: - case BINARY_LITERAL: - case FLOAT_LITERAL: - case HEX_FLOAT_LITERAL: - case BOOL_LITERAL: - case CHAR_LITERAL: - case STRING_LITERAL: - case NULL_LITERAL: - case LPAREN: - case LT: - case BANG: - case TILDE: - case INC: - case DEC: - case ADD: - case SUB: - case AT: - case IDENTIFIER: - enterOuterAlt(_localctx, 1); - { - setState(1248); - expression(0); - } - break; - case LBRACE: - enterOuterAlt(_localctx, 2); - { - setState(1249); - block(); - } - 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 PrimaryContext extends ParserRuleContext { + public PrimaryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + public TerminalNode LPAREN() { return getToken(JavaParser.LPAREN, 0); } @@ -10984,15 +12549,18 @@ public class JavaParser extends Parser { return getRuleContext(ArgumentsContext.class, 0); } - public PrimaryContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_primary; } + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitPrimary(this); + else return visitor.visitChildren(this); + } + @Override public void enterRule(ParseTreeListener listener) { if (listener instanceof JavaParserListener) @@ -11003,112 +12571,13 @@ public class JavaParser extends Parser { public void exitRule(ParseTreeListener listener) { if (listener instanceof JavaParserListener) ((JavaParserListener) listener).exitPrimary(this); } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitPrimary(this); - else return visitor.visitChildren(this); - } - } - - public final PrimaryContext primary() throws RecognitionException { - PrimaryContext _localctx = new PrimaryContext(_ctx, getState()); - enterRule(_localctx, 174, RULE_primary); - try { - setState(1270); - _errHandler.sync(this); - switch (getInterpreter().adaptivePredict(_input, 151, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1252); - match(LPAREN); - setState(1253); - expression(0); - setState(1254); - match(RPAREN); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1256); - match(THIS); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(1257); - match(SUPER); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(1258); - literal(); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(1259); - match(IDENTIFIER); - } - break; - case 6: - enterOuterAlt(_localctx, 6); - { - setState(1260); - typeTypeOrVoid(); - setState(1261); - match(DOT); - setState(1262); - match(CLASS); - } - break; - case 7: - enterOuterAlt(_localctx, 7); - { - setState(1264); - nonWildcardTypeArguments(); - setState(1268); - _errHandler.sync(this); - switch (_input.LA(1)) { - case SUPER: - case IDENTIFIER: - { - setState(1265); - explicitGenericInvocationSuffix(); - } - break; - case THIS: - { - setState(1266); - match(THIS); - setState(1267); - arguments(); - } - 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 ClassTypeContext extends ParserRuleContext { + public ClassTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + public TerminalNode IDENTIFIER() { return getToken(JavaParser.IDENTIFIER, 0); } @@ -11133,15 +12602,18 @@ public class JavaParser extends Parser { return getRuleContext(TypeArgumentsContext.class, 0); } - public ClassTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_classType; } + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitClassType(this); + else return visitor.visitChildren(this); + } + @Override public void enterRule(ParseTreeListener listener) { if (listener instanceof JavaParserListener) @@ -11153,74 +12625,13 @@ public class JavaParser extends Parser { if (listener instanceof JavaParserListener) ((JavaParserListener) listener).exitClassType(this); } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitClassType(this); - else return visitor.visitChildren(this); - } - } - - public final ClassTypeContext classType() throws RecognitionException { - ClassTypeContext _localctx = new ClassTypeContext(_ctx, getState()); - enterRule(_localctx, 176, RULE_classType); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1275); - _errHandler.sync(this); - switch (getInterpreter().adaptivePredict(_input, 152, _ctx)) { - case 1: - { - setState(1272); - classOrInterfaceType(); - setState(1273); - match(DOT); - } - break; - } - setState(1280); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 153, _ctx); - while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - { - setState(1277); - annotation(); - } - } - } - setState(1282); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 153, _ctx); - } - setState(1283); - match(IDENTIFIER); - setState(1285); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == LT) { - { - setState(1284); - typeArguments(); - } - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; } public static class CreatorContext extends ParserRuleContext { + public CreatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() { return getRuleContext(NonWildcardTypeArgumentsContext.class, 0); } @@ -11237,15 +12648,18 @@ public class JavaParser extends Parser { return getRuleContext(ArrayCreatorRestContext.class, 0); } - public CreatorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_creator; } + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitCreator(this); + else return visitor.visitChildren(this); + } + @Override public void enterRule(ParseTreeListener listener) { if (listener instanceof JavaParserListener) @@ -11256,80 +12670,13 @@ public class JavaParser extends Parser { public void exitRule(ParseTreeListener listener) { if (listener instanceof JavaParserListener) ((JavaParserListener) listener).exitCreator(this); } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitCreator(this); - else return visitor.visitChildren(this); - } - } - - public final CreatorContext creator() throws RecognitionException { - CreatorContext _localctx = new CreatorContext(_ctx, getState()); - enterRule(_localctx, 178, RULE_creator); - try { - setState(1296); - _errHandler.sync(this); - switch (_input.LA(1)) { - case LT: - enterOuterAlt(_localctx, 1); - { - setState(1287); - nonWildcardTypeArguments(); - setState(1288); - createdName(); - setState(1289); - classCreatorRest(); - } - break; - case BOOLEAN: - case BYTE: - case CHAR: - case DOUBLE: - case FLOAT: - case INT: - case LONG: - case SHORT: - case IDENTIFIER: - enterOuterAlt(_localctx, 2); - { - setState(1291); - createdName(); - setState(1294); - _errHandler.sync(this); - switch (_input.LA(1)) { - case LBRACK: - { - setState(1292); - arrayCreatorRest(); - } - break; - case LPAREN: - { - setState(1293); - classCreatorRest(); - } - break; - default: - throw new NoViableAltException(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 CreatedNameContext extends ParserRuleContext { + public CreatedNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + public List IDENTIFIER() { return getTokens(JavaParser.IDENTIFIER); } @@ -11358,15 +12705,18 @@ public class JavaParser extends Parser { return getRuleContext(PrimitiveTypeContext.class, 0); } - public CreatedNameContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_createdName; } + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitCreatedName(this); + else return visitor.visitChildren(this); + } + @Override public void enterRule(ParseTreeListener listener) { if (listener instanceof JavaParserListener) @@ -11378,93 +12728,13 @@ public class JavaParser extends Parser { if (listener instanceof JavaParserListener) ((JavaParserListener) listener).exitCreatedName(this); } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitCreatedName(this); - else return visitor.visitChildren(this); - } - } - - public final CreatedNameContext createdName() throws RecognitionException { - CreatedNameContext _localctx = new CreatedNameContext(_ctx, getState()); - enterRule(_localctx, 180, RULE_createdName); - int _la; - try { - setState(1313); - _errHandler.sync(this); - switch (_input.LA(1)) { - case IDENTIFIER: - enterOuterAlt(_localctx, 1); - { - setState(1298); - match(IDENTIFIER); - setState(1300); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == LT) { - { - setState(1299); - typeArgumentsOrDiamond(); - } - } - - setState(1309); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == DOT) { - { - { - setState(1302); - match(DOT); - setState(1303); - match(IDENTIFIER); - setState(1305); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == LT) { - { - setState(1304); - typeArgumentsOrDiamond(); - } - } - } - } - setState(1311); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - break; - case BOOLEAN: - case BYTE: - case CHAR: - case DOUBLE: - case FLOAT: - case INT: - case LONG: - case SHORT: - enterOuterAlt(_localctx, 2); - { - setState(1312); - primitiveType(); - } - 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 InnerCreatorContext extends ParserRuleContext { + public InnerCreatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + public TerminalNode IDENTIFIER() { return getToken(JavaParser.IDENTIFIER, 0); } @@ -11477,15 +12747,18 @@ public class JavaParser extends Parser { return getRuleContext(NonWildcardTypeArgumentsOrDiamondContext.class, 0); } - public InnerCreatorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_innerCreator; } + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitInnerCreator(this); + else return visitor.visitChildren(this); + } + @Override public void enterRule(ParseTreeListener listener) { if (listener instanceof JavaParserListener) @@ -11497,48 +12770,13 @@ public class JavaParser extends Parser { if (listener instanceof JavaParserListener) ((JavaParserListener) listener).exitInnerCreator(this); } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitInnerCreator(this); - else return visitor.visitChildren(this); - } - } - - public final InnerCreatorContext innerCreator() throws RecognitionException { - InnerCreatorContext _localctx = new InnerCreatorContext(_ctx, getState()); - enterRule(_localctx, 182, RULE_innerCreator); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1315); - match(IDENTIFIER); - setState(1317); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la == LT) { - { - setState(1316); - nonWildcardTypeArgumentsOrDiamond(); - } - } - - setState(1319); - classCreatorRest(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; } public static class ArrayCreatorRestContext extends ParserRuleContext { + public ArrayCreatorRestContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + public List LBRACK() { return getTokens(JavaParser.LBRACK); } @@ -11567,15 +12805,18 @@ public class JavaParser extends Parser { return getRuleContext(ExpressionContext.class, i); } - public ArrayCreatorRestContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_arrayCreatorRest; } + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitArrayCreatorRest(this); + else return visitor.visitChildren(this); + } + @Override public void enterRule(ParseTreeListener listener) { if (listener instanceof JavaParserListener) @@ -11587,144 +12828,13 @@ public class JavaParser extends Parser { if (listener instanceof JavaParserListener) ((JavaParserListener) listener).exitArrayCreatorRest(this); } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitArrayCreatorRest(this); - else return visitor.visitChildren(this); - } - } - - public final ArrayCreatorRestContext arrayCreatorRest() throws RecognitionException { - ArrayCreatorRestContext _localctx = new ArrayCreatorRestContext(_ctx, getState()); - enterRule(_localctx, 184, RULE_arrayCreatorRest); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1321); - match(LBRACK); - setState(1349); - _errHandler.sync(this); - switch (_input.LA(1)) { - case RBRACK: - { - setState(1322); - match(RBRACK); - setState(1327); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == LBRACK) { - { - { - setState(1323); - match(LBRACK); - setState(1324); - match(RBRACK); - } - } - setState(1329); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1330); - arrayInitializer(); - } - break; - case BOOLEAN: - case BYTE: - case CHAR: - case DOUBLE: - case FLOAT: - case INT: - case LONG: - case NEW: - case SHORT: - case SUPER: - case THIS: - case VOID: - case DECIMAL_LITERAL: - case HEX_LITERAL: - case OCT_LITERAL: - case BINARY_LITERAL: - case FLOAT_LITERAL: - case HEX_FLOAT_LITERAL: - case BOOL_LITERAL: - case CHAR_LITERAL: - case STRING_LITERAL: - case NULL_LITERAL: - case LPAREN: - case LT: - case BANG: - case TILDE: - case INC: - case DEC: - case ADD: - case SUB: - case AT: - case IDENTIFIER: - { - setState(1331); - expression(0); - setState(1332); - match(RBRACK); - setState(1339); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 163, _ctx); - while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - { - setState(1333); - match(LBRACK); - setState(1334); - expression(0); - setState(1335); - match(RBRACK); - } - } - } - setState(1341); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 163, _ctx); - } - setState(1346); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 164, _ctx); - while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - { - setState(1342); - match(LBRACK); - setState(1343); - match(RBRACK); - } - } - } - setState(1348); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 164, _ctx); - } - } - 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 ClassCreatorRestContext extends ParserRuleContext { + public ClassCreatorRestContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + public ArgumentsContext arguments() { return getRuleContext(ArgumentsContext.class, 0); } @@ -11733,15 +12843,18 @@ public class JavaParser extends Parser { return getRuleContext(ClassBodyContext.class, 0); } - public ClassCreatorRestContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_classCreatorRest; } + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitClassCreatorRest(this); + else return visitor.visitChildren(this); + } + @Override public void enterRule(ParseTreeListener listener) { if (listener instanceof JavaParserListener) @@ -11753,45 +12866,13 @@ public class JavaParser extends Parser { if (listener instanceof JavaParserListener) ((JavaParserListener) listener).exitClassCreatorRest(this); } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitClassCreatorRest(this); - else return visitor.visitChildren(this); - } - } - - public final ClassCreatorRestContext classCreatorRest() throws RecognitionException { - ClassCreatorRestContext _localctx = new ClassCreatorRestContext(_ctx, getState()); - enterRule(_localctx, 186, RULE_classCreatorRest); - try { - enterOuterAlt(_localctx, 1); - { - setState(1351); - arguments(); - setState(1353); - _errHandler.sync(this); - switch (getInterpreter().adaptivePredict(_input, 166, _ctx)) { - case 1: - { - setState(1352); - classBody(); - } - break; - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; } public static class ExplicitGenericInvocationContext extends ParserRuleContext { + public ExplicitGenericInvocationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + public NonWildcardTypeArgumentsContext nonWildcardTypeArguments() { return getRuleContext(NonWildcardTypeArgumentsContext.class, 0); } @@ -11800,15 +12881,18 @@ public class JavaParser extends Parser { return getRuleContext(ExplicitGenericInvocationSuffixContext.class, 0); } - public ExplicitGenericInvocationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_explicitGenericInvocation; } + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitExplicitGenericInvocation(this); + else return visitor.visitChildren(this); + } + @Override public void enterRule(ParseTreeListener listener) { if (listener instanceof JavaParserListener) @@ -11820,39 +12904,13 @@ public class JavaParser extends Parser { if (listener instanceof JavaParserListener) ((JavaParserListener) listener).exitExplicitGenericInvocation(this); } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitExplicitGenericInvocation(this); - else return visitor.visitChildren(this); - } - } - - public final ExplicitGenericInvocationContext explicitGenericInvocation() - throws RecognitionException { - ExplicitGenericInvocationContext _localctx = - new ExplicitGenericInvocationContext(_ctx, getState()); - enterRule(_localctx, 188, RULE_explicitGenericInvocation); - try { - enterOuterAlt(_localctx, 1); - { - setState(1355); - nonWildcardTypeArguments(); - setState(1356); - explicitGenericInvocationSuffix(); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; } public static class TypeArgumentsOrDiamondContext extends ParserRuleContext { + public TypeArgumentsOrDiamondContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + public TerminalNode LT() { return getToken(JavaParser.LT, 0); } @@ -11865,15 +12923,18 @@ public class JavaParser extends Parser { return getRuleContext(TypeArgumentsContext.class, 0); } - public TypeArgumentsOrDiamondContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeArgumentsOrDiamond; } + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitTypeArgumentsOrDiamond(this); + else return visitor.visitChildren(this); + } + @Override public void enterRule(ParseTreeListener listener) { if (listener instanceof JavaParserListener) @@ -11885,50 +12946,13 @@ public class JavaParser extends Parser { if (listener instanceof JavaParserListener) ((JavaParserListener) listener).exitTypeArgumentsOrDiamond(this); } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitTypeArgumentsOrDiamond(this); - else return visitor.visitChildren(this); - } - } - - public final TypeArgumentsOrDiamondContext typeArgumentsOrDiamond() throws RecognitionException { - TypeArgumentsOrDiamondContext _localctx = new TypeArgumentsOrDiamondContext(_ctx, getState()); - enterRule(_localctx, 190, RULE_typeArgumentsOrDiamond); - try { - setState(1361); - _errHandler.sync(this); - switch (getInterpreter().adaptivePredict(_input, 167, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1358); - match(LT); - setState(1359); - match(GT); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1360); - typeArguments(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; } public static class NonWildcardTypeArgumentsOrDiamondContext extends ParserRuleContext { + public NonWildcardTypeArgumentsOrDiamondContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + public TerminalNode LT() { return getToken(JavaParser.LT, 0); } @@ -11941,15 +12965,19 @@ public class JavaParser extends Parser { return getRuleContext(NonWildcardTypeArgumentsContext.class, 0); } - public NonWildcardTypeArgumentsOrDiamondContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_nonWildcardTypeArgumentsOrDiamond; } + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor) + .visitNonWildcardTypeArgumentsOrDiamond(this); + else return visitor.visitChildren(this); + } + @Override public void enterRule(ParseTreeListener listener) { if (listener instanceof JavaParserListener) @@ -11961,53 +12989,13 @@ public class JavaParser extends Parser { if (listener instanceof JavaParserListener) ((JavaParserListener) listener).exitNonWildcardTypeArgumentsOrDiamond(this); } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor) - .visitNonWildcardTypeArgumentsOrDiamond(this); - else return visitor.visitChildren(this); - } - } - - public final NonWildcardTypeArgumentsOrDiamondContext nonWildcardTypeArgumentsOrDiamond() - throws RecognitionException { - NonWildcardTypeArgumentsOrDiamondContext _localctx = - new NonWildcardTypeArgumentsOrDiamondContext(_ctx, getState()); - enterRule(_localctx, 192, RULE_nonWildcardTypeArgumentsOrDiamond); - try { - setState(1366); - _errHandler.sync(this); - switch (getInterpreter().adaptivePredict(_input, 168, _ctx)) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1363); - match(LT); - setState(1364); - match(GT); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1365); - nonWildcardTypeArguments(); - } - break; - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; } public static class NonWildcardTypeArgumentsContext extends ParserRuleContext { + public NonWildcardTypeArgumentsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + public TerminalNode LT() { return getToken(JavaParser.LT, 0); } @@ -12020,15 +13008,18 @@ public class JavaParser extends Parser { return getToken(JavaParser.GT, 0); } - public NonWildcardTypeArgumentsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_nonWildcardTypeArguments; } + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitNonWildcardTypeArguments(this); + else return visitor.visitChildren(this); + } + @Override public void enterRule(ParseTreeListener listener) { if (listener instanceof JavaParserListener) @@ -12040,41 +13031,13 @@ public class JavaParser extends Parser { if (listener instanceof JavaParserListener) ((JavaParserListener) listener).exitNonWildcardTypeArguments(this); } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitNonWildcardTypeArguments(this); - else return visitor.visitChildren(this); - } - } - - public final NonWildcardTypeArgumentsContext nonWildcardTypeArguments() - throws RecognitionException { - NonWildcardTypeArgumentsContext _localctx = - new NonWildcardTypeArgumentsContext(_ctx, getState()); - enterRule(_localctx, 194, RULE_nonWildcardTypeArguments); - try { - enterOuterAlt(_localctx, 1); - { - setState(1368); - match(LT); - setState(1369); - typeList(); - setState(1370); - match(GT); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; } public static class TypeListContext extends ParserRuleContext { + public TypeListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + public List typeType() { return getRuleContexts(TypeTypeContext.class); } @@ -12091,15 +13054,18 @@ public class JavaParser extends Parser { return getToken(JavaParser.COMMA, i); } - public TypeListContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeList; } + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitTypeList(this); + else return visitor.visitChildren(this); + } + @Override public void enterRule(ParseTreeListener listener) { if (listener instanceof JavaParserListener) @@ -12111,52 +13077,13 @@ public class JavaParser extends Parser { if (listener instanceof JavaParserListener) ((JavaParserListener) listener).exitTypeList(this); } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitTypeList(this); - else return visitor.visitChildren(this); - } - } - - public final TypeListContext typeList() throws RecognitionException { - TypeListContext _localctx = new TypeListContext(_ctx, getState()); - enterRule(_localctx, 196, RULE_typeList); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1372); - typeType(); - setState(1377); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == COMMA) { - { - { - setState(1373); - match(COMMA); - setState(1374); - typeType(); - } - } - setState(1379); - _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 TypeTypeContext extends ParserRuleContext { + public TypeTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + public ClassOrInterfaceTypeContext classOrInterfaceType() { return getRuleContext(ClassOrInterfaceTypeContext.class, 0); } @@ -12189,15 +13116,18 @@ public class JavaParser extends Parser { return getToken(JavaParser.RBRACK, i); } - public TypeTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeType; } + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitTypeType(this); + else return visitor.visitChildren(this); + } + @Override public void enterRule(ParseTreeListener listener) { if (listener instanceof JavaParserListener) @@ -12209,108 +13139,13 @@ public class JavaParser extends Parser { if (listener instanceof JavaParserListener) ((JavaParserListener) listener).exitTypeType(this); } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitTypeType(this); - else return visitor.visitChildren(this); - } - } - - public final TypeTypeContext typeType() throws RecognitionException { - TypeTypeContext _localctx = new TypeTypeContext(_ctx, getState()); - enterRule(_localctx, 198, RULE_typeType); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1383); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 170, _ctx); - while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - { - setState(1380); - annotation(); - } - } - } - setState(1385); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 170, _ctx); - } - setState(1388); - _errHandler.sync(this); - switch (_input.LA(1)) { - case IDENTIFIER: - { - setState(1386); - classOrInterfaceType(); - } - break; - case BOOLEAN: - case BYTE: - case CHAR: - case DOUBLE: - case FLOAT: - case INT: - case LONG: - case SHORT: - { - setState(1387); - primitiveType(); - } - break; - default: - throw new NoViableAltException(this); - } - setState(1400); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 173, _ctx); - while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { - if (_alt == 1) { - { - { - setState(1393); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == AT || _la == IDENTIFIER) { - { - { - setState(1390); - annotation(); - } - } - setState(1395); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1396); - match(LBRACK); - setState(1397); - match(RBRACK); - } - } - } - setState(1402); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input, 173, _ctx); - } - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; } public static class PrimitiveTypeContext extends ParserRuleContext { + public PrimitiveTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + public TerminalNode BOOLEAN() { return getToken(JavaParser.BOOLEAN, 0); } @@ -12343,15 +13178,18 @@ public class JavaParser extends Parser { return getToken(JavaParser.DOUBLE, 0); } - public PrimitiveTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_primitiveType; } + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitPrimitiveType(this); + else return visitor.visitChildren(this); + } + @Override public void enterRule(ParseTreeListener listener) { if (listener instanceof JavaParserListener) @@ -12363,53 +13201,13 @@ public class JavaParser extends Parser { if (listener instanceof JavaParserListener) ((JavaParserListener) listener).exitPrimitiveType(this); } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitPrimitiveType(this); - else return visitor.visitChildren(this); - } - } - - public final PrimitiveTypeContext primitiveType() throws RecognitionException { - PrimitiveTypeContext _localctx = new PrimitiveTypeContext(_ctx, getState()); - enterRule(_localctx, 200, RULE_primitiveType); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1403); - _la = _input.LA(1); - if (!((((_la) & ~0x3f) == 0 - && ((1L << _la) - & ((1L << BOOLEAN) - | (1L << BYTE) - | (1L << CHAR) - | (1L << DOUBLE) - | (1L << FLOAT) - | (1L << INT) - | (1L << LONG) - | (1L << SHORT))) - != 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 TypeArgumentsContext extends ParserRuleContext { + public TypeArgumentsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + public TerminalNode LT() { return getToken(JavaParser.LT, 0); } @@ -12434,15 +13232,18 @@ public class JavaParser extends Parser { return getToken(JavaParser.COMMA, i); } - public TypeArgumentsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeArguments; } + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitTypeArguments(this); + else return visitor.visitChildren(this); + } + @Override public void enterRule(ParseTreeListener listener) { if (listener instanceof JavaParserListener) @@ -12454,56 +13255,13 @@ public class JavaParser extends Parser { if (listener instanceof JavaParserListener) ((JavaParserListener) listener).exitTypeArguments(this); } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitTypeArguments(this); - else return visitor.visitChildren(this); - } - } - - public final TypeArgumentsContext typeArguments() throws RecognitionException { - TypeArgumentsContext _localctx = new TypeArgumentsContext(_ctx, getState()); - enterRule(_localctx, 202, RULE_typeArguments); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1405); - match(LT); - setState(1406); - typeArgument(); - setState(1411); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la == COMMA) { - { - { - setState(1407); - match(COMMA); - setState(1408); - typeArgument(); - } - } - setState(1413); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1414); - match(GT); - } - } catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } finally { - exitRule(); - } - return _localctx; } public static class SuperSuffixContext extends ParserRuleContext { + public SuperSuffixContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + public ArgumentsContext arguments() { return getRuleContext(ArgumentsContext.class, 0); } @@ -12516,15 +13274,18 @@ public class JavaParser extends Parser { return getToken(JavaParser.IDENTIFIER, 0); } - public SuperSuffixContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_superSuffix; } + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitSuperSuffix(this); + else return visitor.visitChildren(this); + } + @Override public void enterRule(ParseTreeListener listener) { if (listener instanceof JavaParserListener) @@ -12536,62 +13297,13 @@ public class JavaParser extends Parser { if (listener instanceof JavaParserListener) ((JavaParserListener) listener).exitSuperSuffix(this); } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitSuperSuffix(this); - else return visitor.visitChildren(this); - } - } - - public final SuperSuffixContext superSuffix() throws RecognitionException { - SuperSuffixContext _localctx = new SuperSuffixContext(_ctx, getState()); - enterRule(_localctx, 204, RULE_superSuffix); - try { - setState(1422); - _errHandler.sync(this); - switch (_input.LA(1)) { - case LPAREN: - enterOuterAlt(_localctx, 1); - { - setState(1416); - arguments(); - } - break; - case DOT: - enterOuterAlt(_localctx, 2); - { - setState(1417); - match(DOT); - setState(1418); - match(IDENTIFIER); - setState(1420); - _errHandler.sync(this); - switch (getInterpreter().adaptivePredict(_input, 175, _ctx)) { - case 1: - { - setState(1419); - arguments(); - } - 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 ExplicitGenericInvocationSuffixContext extends ParserRuleContext { + public ExplicitGenericInvocationSuffixContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + public TerminalNode SUPER() { return getToken(JavaParser.SUPER, 0); } @@ -12608,15 +13320,19 @@ public class JavaParser extends Parser { return getRuleContext(ArgumentsContext.class, 0); } - public ExplicitGenericInvocationSuffixContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_explicitGenericInvocationSuffix; } + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor) + .visitExplicitGenericInvocationSuffix(this); + else return visitor.visitChildren(this); + } + @Override public void enterRule(ParseTreeListener listener) { if (listener instanceof JavaParserListener) @@ -12628,57 +13344,13 @@ public class JavaParser extends Parser { if (listener instanceof JavaParserListener) ((JavaParserListener) listener).exitExplicitGenericInvocationSuffix(this); } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor) - .visitExplicitGenericInvocationSuffix(this); - else return visitor.visitChildren(this); - } - } - - public final ExplicitGenericInvocationSuffixContext explicitGenericInvocationSuffix() - throws RecognitionException { - ExplicitGenericInvocationSuffixContext _localctx = - new ExplicitGenericInvocationSuffixContext(_ctx, getState()); - enterRule(_localctx, 206, RULE_explicitGenericInvocationSuffix); - try { - setState(1428); - _errHandler.sync(this); - switch (_input.LA(1)) { - case SUPER: - enterOuterAlt(_localctx, 1); - { - setState(1424); - match(SUPER); - setState(1425); - superSuffix(); - } - break; - case IDENTIFIER: - enterOuterAlt(_localctx, 2); - { - setState(1426); - match(IDENTIFIER); - setState(1427); - arguments(); - } - 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 ArgumentsContext extends ParserRuleContext { + public ArgumentsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + public TerminalNode LPAREN() { return getToken(JavaParser.LPAREN, 0); } @@ -12691,15 +13363,18 @@ public class JavaParser extends Parser { return getRuleContext(ExpressionListContext.class, 0); } - public ArgumentsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_arguments; } + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavaParserVisitor) + return ((JavaParserVisitor) visitor).visitArguments(this); + else return visitor.visitChildren(this); + } + @Override public void enterRule(ParseTreeListener listener) { if (listener instanceof JavaParserListener) @@ -12711,704 +13386,5 @@ public class JavaParser extends Parser { if (listener instanceof JavaParserListener) ((JavaParserListener) listener).exitArguments(this); } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavaParserVisitor) - return ((JavaParserVisitor) visitor).visitArguments(this); - else return visitor.visitChildren(this); - } - } - - public final ArgumentsContext arguments() throws RecognitionException { - ArgumentsContext _localctx = new ArgumentsContext(_ctx, getState()); - enterRule(_localctx, 208, RULE_arguments); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1430); - match(LPAREN); - setState(1432); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 - && ((1L << _la) - & ((1L << BOOLEAN) - | (1L << BYTE) - | (1L << CHAR) - | (1L << DOUBLE) - | (1L << FLOAT) - | (1L << INT) - | (1L << LONG) - | (1L << NEW) - | (1L << SHORT) - | (1L << SUPER) - | (1L << THIS) - | (1L << VOID) - | (1L << DECIMAL_LITERAL) - | (1L << HEX_LITERAL) - | (1L << OCT_LITERAL) - | (1L << BINARY_LITERAL) - | (1L << FLOAT_LITERAL) - | (1L << HEX_FLOAT_LITERAL) - | (1L << BOOL_LITERAL) - | (1L << CHAR_LITERAL) - | (1L << STRING_LITERAL) - | (1L << NULL_LITERAL) - | (1L << LPAREN))) - != 0) - || ((((_la - 73)) & ~0x3f) == 0 - && ((1L << (_la - 73)) - & ((1L << (LT - 73)) - | (1L << (BANG - 73)) - | (1L << (TILDE - 73)) - | (1L << (INC - 73)) - | (1L << (DEC - 73)) - | (1L << (ADD - 73)) - | (1L << (SUB - 73)) - | (1L << (AT - 73)) - | (1L << (IDENTIFIER - 73)))) - != 0)) { - { - setState(1431); - expressionList(); - } - } - - setState(1434); - match(RPAREN); - } - } 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 83: - return expression_sempred((ExpressionContext) _localctx, predIndex); - } - return true; - } - - private boolean expression_sempred(ExpressionContext _localctx, int predIndex) { - switch (predIndex) { - case 0: - return precpred(_ctx, 17); - case 1: - return precpred(_ctx, 16); - case 2: - return precpred(_ctx, 15); - case 3: - return precpred(_ctx, 14); - case 4: - return precpred(_ctx, 12); - case 5: - return precpred(_ctx, 11); - case 6: - return precpred(_ctx, 10); - case 7: - return precpred(_ctx, 9); - case 8: - return precpred(_ctx, 8); - case 9: - return precpred(_ctx, 7); - case 10: - return precpred(_ctx, 6); - case 11: - return precpred(_ctx, 5); - case 12: - return precpred(_ctx, 25); - case 13: - return precpred(_ctx, 24); - case 14: - return precpred(_ctx, 20); - case 15: - return precpred(_ctx, 13); - case 16: - return precpred(_ctx, 3); - } - return true; - } - - public static final String _serializedATN = - "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3r\u059f\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\3\2\5" - + "\2\u00d6\n\2\3\2\7\2\u00d9\n\2\f\2\16\2\u00dc\13\2\3\2\7\2\u00df\n\2\f" - + "\2\16\2\u00e2\13\2\3\2\3\2\3\3\7\3\u00e7\n\3\f\3\16\3\u00ea\13\3\3\3\3" - + "\3\3\3\3\3\3\4\3\4\5\4\u00f2\n\4\3\4\3\4\3\4\5\4\u00f7\n\4\3\4\3\4\3\5" - + "\7\5\u00fc\n\5\f\5\16\5\u00ff\13\5\3\5\3\5\3\5\3\5\5\5\u0105\n\5\3\5\5" - + "\5\u0108\n\5\3\6\3\6\3\6\3\6\3\6\5\6\u010f\n\6\3\7\3\7\3\7\3\7\3\7\3\7" - + "\3\7\3\7\5\7\u0119\n\7\3\b\3\b\5\b\u011d\n\b\3\t\3\t\3\t\5\t\u0122\n\t" - + "\3\t\3\t\5\t\u0126\n\t\3\t\3\t\5\t\u012a\n\t\3\t\3\t\3\n\3\n\3\n\3\n\7" - + "\n\u0132\n\n\f\n\16\n\u0135\13\n\3\n\3\n\3\13\7\13\u013a\n\13\f\13\16" - + "\13\u013d\13\13\3\13\3\13\3\13\7\13\u0142\n\13\f\13\16\13\u0145\13\13" - + "\3\13\5\13\u0148\n\13\3\f\3\f\3\f\7\f\u014d\n\f\f\f\16\f\u0150\13\f\3" - + "\r\3\r\3\r\3\r\5\r\u0156\n\r\3\r\3\r\5\r\u015a\n\r\3\r\5\r\u015d\n\r\3" - + "\r\5\r\u0160\n\r\3\r\3\r\3\16\3\16\3\16\7\16\u0167\n\16\f\16\16\16\u016a" - + "\13\16\3\17\7\17\u016d\n\17\f\17\16\17\u0170\13\17\3\17\3\17\5\17\u0174" - + "\n\17\3\17\5\17\u0177\n\17\3\20\3\20\7\20\u017b\n\20\f\20\16\20\u017e" - + "\13\20\3\21\3\21\3\21\5\21\u0183\n\21\3\21\3\21\5\21\u0187\n\21\3\21\3" - + "\21\3\22\3\22\7\22\u018d\n\22\f\22\16\22\u0190\13\22\3\22\3\22\3\23\3" - + "\23\7\23\u0196\n\23\f\23\16\23\u0199\13\23\3\23\3\23\3\24\3\24\5\24\u019f" - + "\n\24\3\24\3\24\7\24\u01a3\n\24\f\24\16\24\u01a6\13\24\3\24\5\24\u01a9" - + "\n\24\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\5\25\u01b4\n\25\3\26" - + "\3\26\3\26\3\26\3\26\7\26\u01bb\n\26\f\26\16\26\u01be\13\26\3\26\3\26" - + "\5\26\u01c2\n\26\3\26\3\26\3\27\3\27\5\27\u01c8\n\27\3\30\3\30\5\30\u01cc" - + "\n\30\3\31\3\31\3\31\3\32\3\32\3\32\3\33\3\33\3\33\3\33\5\33\u01d8\n\33" - + "\3\33\3\33\3\34\3\34\3\34\3\34\3\35\7\35\u01e1\n\35\f\35\16\35\u01e4\13" - + "\35\3\35\3\35\5\35\u01e8\n\35\3\36\3\36\3\36\3\36\3\36\3\36\3\36\5\36" - + "\u01f1\n\36\3\37\3\37\3\37\3\37\7\37\u01f7\n\37\f\37\16\37\u01fa\13\37" - + "\3\37\3\37\3 \3 \3 \7 \u0201\n \f \16 \u0204\13 \3 \3 \3 \3!\7!\u020a" - + "\n!\f!\16!\u020d\13!\3!\3!\3!\7!\u0212\n!\f!\16!\u0215\13!\3!\3!\5!\u0219" - + "\n!\3!\3!\3!\3!\7!\u021f\n!\f!\16!\u0222\13!\3!\3!\5!\u0226\n!\3!\3!\3" - + "\"\3\"\3\"\3\"\3\"\3\"\5\"\u0230\n\"\3#\3#\3#\3$\3$\3$\7$\u0238\n$\f$" - + "\16$\u023b\13$\3%\3%\3%\5%\u0240\n%\3&\3&\3&\7&\u0245\n&\f&\16&\u0248" - + "\13&\3\'\3\'\5\'\u024c\n\'\3(\3(\3(\3(\7(\u0252\n(\f(\16(\u0255\13(\3" - + "(\5(\u0258\n(\5(\u025a\n(\3(\3(\3)\3)\5)\u0260\n)\3)\3)\3)\5)\u0265\n" - + ")\7)\u0267\n)\f)\16)\u026a\13)\3*\3*\7*\u026e\n*\f*\16*\u0271\13*\3*\3" - + "*\3*\5*\u0276\n*\5*\u0278\n*\3+\3+\3+\7+\u027d\n+\f+\16+\u0280\13+\3," - + "\3,\5,\u0284\n,\3,\3,\3-\3-\3-\7-\u028b\n-\f-\16-\u028e\13-\3-\3-\5-\u0292" - + "\n-\3-\5-\u0295\n-\3.\7.\u0298\n.\f.\16.\u029b\13.\3.\3.\3.\3/\7/\u02a1" - + "\n/\f/\16/\u02a4\13/\3/\3/\7/\u02a8\n/\f/\16/\u02ab\13/\3/\3/\3/\3\60" - + "\3\60\3\60\7\60\u02b3\n\60\f\60\16\60\u02b6\13\60\3\61\3\61\3\61\3\61" - + "\3\61\3\61\5\61\u02be\n\61\3\62\3\62\3\63\3\63\3\64\3\64\7\64\u02c6\n" - + "\64\f\64\16\64\u02c9\13\64\3\64\3\64\3\64\3\65\3\65\3\65\5\65\u02d1\n" - + "\65\3\65\3\65\3\65\5\65\u02d6\n\65\3\65\5\65\u02d9\n\65\3\66\3\66\3\66" - + "\7\66\u02de\n\66\f\66\16\66\u02e1\13\66\3\67\3\67\3\67\3\67\38\38\38\5" - + "8\u02ea\n8\39\39\39\39\79\u02f0\n9\f9\169\u02f3\139\59\u02f5\n9\39\59" - + "\u02f8\n9\39\39\3:\3:\3:\3:\3:\3;\3;\7;\u0303\n;\f;\16;\u0306\13;\3;\3" - + ";\3<\7<\u030b\n<\f<\16<\u030e\13<\3<\3<\5<\u0312\n<\3=\3=\3=\3=\3=\3=" - + "\5=\u031a\n=\3=\3=\5=\u031e\n=\3=\3=\5=\u0322\n=\3=\3=\5=\u0326\n=\5=" - + "\u0328\n=\3>\3>\5>\u032c\n>\3?\3?\3?\3?\5?\u0332\n?\3@\3@\3A\3A\3A\3B" - + "\3B\7B\u033b\nB\fB\16B\u033e\13B\3B\3B\3C\3C\3C\3C\3C\5C\u0347\nC\3D\7" - + "D\u034a\nD\fD\16D\u034d\13D\3D\3D\3D\3E\7E\u0353\nE\fE\16E\u0356\13E\3" - + "E\3E\5E\u035a\nE\3E\5E\u035d\nE\3F\3F\3F\3F\3F\5F\u0364\nF\3F\3F\3F\3" - + "F\3F\3F\3F\5F\u036d\nF\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3F\3" - + "F\3F\3F\3F\6F\u0382\nF\rF\16F\u0383\3F\5F\u0387\nF\3F\5F\u038a\nF\3F\3" - + "F\3F\3F\7F\u0390\nF\fF\16F\u0393\13F\3F\5F\u0396\nF\3F\3F\3F\3F\7F\u039c" - + "\nF\fF\16F\u039f\13F\3F\7F\u03a2\nF\fF\16F\u03a5\13F\3F\3F\3F\3F\3F\3" - + "F\3F\3F\5F\u03af\nF\3F\3F\3F\3F\3F\3F\3F\5F\u03b8\nF\3F\3F\3F\5F\u03bd" - + "\nF\3F\3F\3F\3F\3F\3F\3F\3F\5F\u03c7\nF\3G\3G\3G\7G\u03cc\nG\fG\16G\u03cf" - + "\13G\3G\3G\3G\3G\3G\3H\3H\3H\7H\u03d9\nH\fH\16H\u03dc\13H\3I\3I\3I\3J" - + "\3J\3J\5J\u03e4\nJ\3J\3J\3K\3K\3K\7K\u03eb\nK\fK\16K\u03ee\13K\3L\7L\u03f1" - + "\nL\fL\16L\u03f4\13L\3L\3L\3L\3L\3L\3M\6M\u03fc\nM\rM\16M\u03fd\3M\6M" - + "\u0401\nM\rM\16M\u0402\3N\3N\3N\5N\u0408\nN\3N\3N\3N\5N\u040d\nN\3O\3" - + "O\5O\u0411\nO\3O\3O\5O\u0415\nO\3O\3O\5O\u0419\nO\5O\u041b\nO\3P\3P\5" - + "P\u041f\nP\3Q\7Q\u0422\nQ\fQ\16Q\u0425\13Q\3Q\3Q\3Q\3Q\3Q\3R\3R\3R\3R" - + "\3S\3S\3S\7S\u0433\nS\fS\16S\u0436\13S\3T\3T\3T\5T\u043b\nT\3T\3T\3T\3" - + "T\5T\u0441\nT\3T\3T\3T\3T\5T\u0447\nT\3T\5T\u044a\nT\3U\3U\3U\3U\3U\3" - + "U\3U\7U\u0453\nU\fU\16U\u0456\13U\3U\3U\3U\7U\u045b\nU\fU\16U\u045e\13" - + "U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\5U\u046b\nU\3U\3U\5U\u046f\nU\3U\3" - + "U\3U\5U\u0474\nU\3U\3U\5U\u0478\nU\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3" - + "U\3U\3U\5U\u0488\nU\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3" - + "U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\5U\u04b0" - + "\nU\3U\3U\3U\3U\5U\u04b6\nU\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\3U\5U" - + "\u04c5\nU\3U\7U\u04c8\nU\fU\16U\u04cb\13U\3V\3V\3V\3V\3W\3W\3W\5W\u04d4" - + "\nW\3W\3W\3W\3W\3W\7W\u04db\nW\fW\16W\u04de\13W\3W\5W\u04e1\nW\3X\3X\5" - + "X\u04e5\nX\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Y\5Y\u04f7\n" - + "Y\5Y\u04f9\nY\3Z\3Z\3Z\5Z\u04fe\nZ\3Z\7Z\u0501\nZ\fZ\16Z\u0504\13Z\3Z" - + "\3Z\5Z\u0508\nZ\3[\3[\3[\3[\3[\3[\3[\5[\u0511\n[\5[\u0513\n[\3\\\3\\\5" - + "\\\u0517\n\\\3\\\3\\\3\\\5\\\u051c\n\\\7\\\u051e\n\\\f\\\16\\\u0521\13" - + "\\\3\\\5\\\u0524\n\\\3]\3]\5]\u0528\n]\3]\3]\3^\3^\3^\3^\7^\u0530\n^\f" - + "^\16^\u0533\13^\3^\3^\3^\3^\3^\3^\3^\7^\u053c\n^\f^\16^\u053f\13^\3^\3" - + "^\7^\u0543\n^\f^\16^\u0546\13^\5^\u0548\n^\3_\3_\5_\u054c\n_\3`\3`\3`" - + "\3a\3a\3a\5a\u0554\na\3b\3b\3b\5b\u0559\nb\3c\3c\3c\3c\3d\3d\3d\7d\u0562" - + "\nd\fd\16d\u0565\13d\3e\7e\u0568\ne\fe\16e\u056b\13e\3e\3e\5e\u056f\n" - + "e\3e\7e\u0572\ne\fe\16e\u0575\13e\3e\3e\7e\u0579\ne\fe\16e\u057c\13e\3" - + "f\3f\3g\3g\3g\3g\7g\u0584\ng\fg\16g\u0587\13g\3g\3g\3h\3h\3h\3h\5h\u058f" - + "\nh\5h\u0591\nh\3i\3i\3i\3i\5i\u0597\ni\3j\3j\5j\u059b\nj\3j\3j\3j\2\3" - + "\u00a8k\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:" - + "<>@BDFHJLNPRTVXZ\\^`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" - + "\2\16\4\2\23\23**\3\2\669\3\2:;\3\2VY\3\2LM\4\2Z[__\3\2XY\4\2JKQR\4\2" - + "PPSS\4\2II`j\3\2VW\n\2\5\5\7\7\n\n\20\20\26\26\35\35\37\37\'\'\2\u063f" - + "\2\u00d5\3\2\2\2\4\u00e8\3\2\2\2\6\u00ef\3\2\2\2\b\u0107\3\2\2\2\n\u010e" - + "\3\2\2\2\f\u0118\3\2\2\2\16\u011c\3\2\2\2\20\u011e\3\2\2\2\22\u012d\3" - + "\2\2\2\24\u013b\3\2\2\2\26\u0149\3\2\2\2\30\u0151\3\2\2\2\32\u0163\3\2" - + "\2\2\34\u016e\3\2\2\2\36\u0178\3\2\2\2 \u017f\3\2\2\2\"\u018a\3\2\2\2" - + "$\u0193\3\2\2\2&\u01a8\3\2\2\2(\u01b3\3\2\2\2*\u01b5\3\2\2\2,\u01c7\3" - + "\2\2\2.\u01cb\3\2\2\2\60\u01cd\3\2\2\2\62\u01d0\3\2\2\2\64\u01d3\3\2\2" - + "\2\66\u01db\3\2\2\28\u01e7\3\2\2\2:\u01f0\3\2\2\2<\u01f2\3\2\2\2>\u01fd" - + "\3\2\2\2@\u020b\3\2\2\2B\u022f\3\2\2\2D\u0231\3\2\2\2F\u0234\3\2\2\2H" - + "\u023c\3\2\2\2J\u0241\3\2\2\2L\u024b\3\2\2\2N\u024d\3\2\2\2P\u025d\3\2" - + "\2\2R\u0277\3\2\2\2T\u0279\3\2\2\2V\u0281\3\2\2\2X\u0294\3\2\2\2Z\u0299" - + "\3\2\2\2\\\u02a2\3\2\2\2^\u02af\3\2\2\2`\u02bd\3\2\2\2b\u02bf\3\2\2\2" - + "d\u02c1\3\2\2\2f\u02c7\3\2\2\2h\u02d0\3\2\2\2j\u02da\3\2\2\2l\u02e2\3" - + "\2\2\2n\u02e9\3\2\2\2p\u02eb\3\2\2\2r\u02fb\3\2\2\2t\u0300\3\2\2\2v\u0311" - + "\3\2\2\2x\u0327\3\2\2\2z\u032b\3\2\2\2|\u032d\3\2\2\2~\u0333\3\2\2\2\u0080" - + "\u0335\3\2\2\2\u0082\u0338\3\2\2\2\u0084\u0346\3\2\2\2\u0086\u034b\3\2" - + "\2\2\u0088\u035c\3\2\2\2\u008a\u03c6\3\2\2\2\u008c\u03c8\3\2\2\2\u008e" - + "\u03d5\3\2\2\2\u0090\u03dd\3\2\2\2\u0092\u03e0\3\2\2\2\u0094\u03e7\3\2" - + "\2\2\u0096\u03f2\3\2\2\2\u0098\u03fb\3\2\2\2\u009a\u040c\3\2\2\2\u009c" - + "\u041a\3\2\2\2\u009e\u041e\3\2\2\2\u00a0\u0423\3\2\2\2\u00a2\u042b\3\2" - + "\2\2\u00a4\u042f\3\2\2\2\u00a6\u0449\3\2\2\2\u00a8\u0477\3\2\2\2\u00aa" - + "\u04cc\3\2\2\2\u00ac\u04e0\3\2\2\2\u00ae\u04e4\3\2\2\2\u00b0\u04f8\3\2" - + "\2\2\u00b2\u04fd\3\2\2\2\u00b4\u0512\3\2\2\2\u00b6\u0523\3\2\2\2\u00b8" - + "\u0525\3\2\2\2\u00ba\u052b\3\2\2\2\u00bc\u0549\3\2\2\2\u00be\u054d\3\2" - + "\2\2\u00c0\u0553\3\2\2\2\u00c2\u0558\3\2\2\2\u00c4\u055a\3\2\2\2\u00c6" - + "\u055e\3\2\2\2\u00c8\u0569\3\2\2\2\u00ca\u057d\3\2\2\2\u00cc\u057f\3\2" - + "\2\2\u00ce\u0590\3\2\2\2\u00d0\u0596\3\2\2\2\u00d2\u0598\3\2\2\2\u00d4" - + "\u00d6\5\4\3\2\u00d5\u00d4\3\2\2\2\u00d5\u00d6\3\2\2\2\u00d6\u00da\3\2" - + "\2\2\u00d7\u00d9\5\6\4\2\u00d8\u00d7\3\2\2\2\u00d9\u00dc\3\2\2\2\u00da" - + "\u00d8\3\2\2\2\u00da\u00db\3\2\2\2\u00db\u00e0\3\2\2\2\u00dc\u00da\3\2" - + "\2\2\u00dd\u00df\5\b\5\2\u00de\u00dd\3\2\2\2\u00df\u00e2\3\2\2\2\u00e0" - + "\u00de\3\2\2\2\u00e0\u00e1\3\2\2\2\u00e1\u00e3\3\2\2\2\u00e2\u00e0\3\2" - + "\2\2\u00e3\u00e4\7\2\2\3\u00e4\3\3\2\2\2\u00e5\u00e7\5h\65\2\u00e6\u00e5" - + "\3\2\2\2\u00e7\u00ea\3\2\2\2\u00e8\u00e6\3\2\2\2\u00e8\u00e9\3\2\2\2\u00e9" - + "\u00eb\3\2\2\2\u00ea\u00e8\3\2\2\2\u00eb\u00ec\7\"\2\2\u00ec\u00ed\5^" - + "\60\2\u00ed\u00ee\7F\2\2\u00ee\5\3\2\2\2\u00ef\u00f1\7\33\2\2\u00f0\u00f2" - + "\7(\2\2\u00f1\u00f0\3\2\2\2\u00f1\u00f2\3\2\2\2\u00f2\u00f3\3\2\2\2\u00f3" - + "\u00f6\5^\60\2\u00f4\u00f5\7H\2\2\u00f5\u00f7\7Z\2\2\u00f6\u00f4\3\2\2" - + "\2\u00f6\u00f7\3\2\2\2\u00f7\u00f8\3\2\2\2\u00f8\u00f9\7F\2\2\u00f9\7" - + "\3\2\2\2\u00fa\u00fc\5\f\7\2\u00fb\u00fa\3\2\2\2\u00fc\u00ff\3\2\2\2\u00fd" - + "\u00fb\3\2\2\2\u00fd\u00fe\3\2\2\2\u00fe\u0104\3\2\2\2\u00ff\u00fd\3\2" - + "\2\2\u0100\u0105\5\20\t\2\u0101\u0105\5\30\r\2\u0102\u0105\5 \21\2\u0103" - + "\u0105\5r:\2\u0104\u0100\3\2\2\2\u0104\u0101\3\2\2\2\u0104\u0102\3\2\2" - + "\2\u0104\u0103\3\2\2\2\u0105\u0108\3\2\2\2\u0106\u0108\7F\2\2\u0107\u00fd" - + "\3\2\2\2\u0107\u0106\3\2\2\2\u0108\t\3\2\2\2\u0109\u010f\5\f\7\2\u010a" - + "\u010f\7 \2\2\u010b\u010f\7,\2\2\u010c\u010f\7\60\2\2\u010d\u010f\7\64" - + "\2\2\u010e\u0109\3\2\2\2\u010e\u010a\3\2\2\2\u010e\u010b\3\2\2\2\u010e" - + "\u010c\3\2\2\2\u010e\u010d\3\2\2\2\u010f\13\3\2\2\2\u0110\u0119\5h\65" - + "\2\u0111\u0119\7%\2\2\u0112\u0119\7$\2\2\u0113\u0119\7#\2\2\u0114\u0119" - + "\7(\2\2\u0115\u0119\7\3\2\2\u0116\u0119\7\24\2\2\u0117\u0119\7)\2\2\u0118" - + "\u0110\3\2\2\2\u0118\u0111\3\2\2\2\u0118\u0112\3\2\2\2\u0118\u0113\3\2" - + "\2\2\u0118\u0114\3\2\2\2\u0118\u0115\3\2\2\2\u0118\u0116\3\2\2\2\u0118" - + "\u0117\3\2\2\2\u0119\r\3\2\2\2\u011a\u011d\7\24\2\2\u011b\u011d\5h\65" - + "\2\u011c\u011a\3\2\2\2\u011c\u011b\3\2\2\2\u011d\17\3\2\2\2\u011e\u011f" - + "\7\13\2\2\u011f\u0121\7r\2\2\u0120\u0122\5\22\n\2\u0121\u0120\3\2\2\2" - + "\u0121\u0122\3\2\2\2\u0122\u0125\3\2\2\2\u0123\u0124\7\23\2\2\u0124\u0126" - + "\5\u00c8e\2\u0125\u0123\3\2\2\2\u0125\u0126\3\2\2\2\u0126\u0129\3\2\2" - + "\2\u0127\u0128\7\32\2\2\u0128\u012a\5\u00c6d\2\u0129\u0127\3\2\2\2\u0129" - + "\u012a\3\2\2\2\u012a\u012b\3\2\2\2\u012b\u012c\5\"\22\2\u012c\21\3\2\2" - + "\2\u012d\u012e\7K\2\2\u012e\u0133\5\24\13\2\u012f\u0130\7G\2\2\u0130\u0132" - + "\5\24\13\2\u0131\u012f\3\2\2\2\u0132\u0135\3\2\2\2\u0133\u0131\3\2\2\2" - + "\u0133\u0134\3\2\2\2\u0134\u0136\3\2\2\2\u0135\u0133\3\2\2\2\u0136\u0137" - + "\7J\2\2\u0137\23\3\2\2\2\u0138\u013a\5h\65\2\u0139\u0138\3\2\2\2\u013a" - + "\u013d\3\2\2\2\u013b\u0139\3\2\2\2\u013b\u013c\3\2\2\2\u013c\u013e\3\2" - + "\2\2\u013d\u013b\3\2\2\2\u013e\u0147\7r\2\2\u013f\u0143\7\23\2\2\u0140" - + "\u0142\5h\65\2\u0141\u0140\3\2\2\2\u0142\u0145\3\2\2\2\u0143\u0141\3\2" - + "\2\2\u0143\u0144\3\2\2\2\u0144\u0146\3\2\2\2\u0145\u0143\3\2\2\2\u0146" - + "\u0148\5\26\f\2\u0147\u013f\3\2\2\2\u0147\u0148\3\2\2\2\u0148\25\3\2\2" - + "\2\u0149\u014e\5\u00c8e\2\u014a\u014b\7\\\2\2\u014b\u014d\5\u00c8e\2\u014c" - + "\u014a\3\2\2\2\u014d\u0150\3\2\2\2\u014e\u014c\3\2\2\2\u014e\u014f\3\2" - + "\2\2\u014f\27\3\2\2\2\u0150\u014e\3\2\2\2\u0151\u0152\7\22\2\2\u0152\u0155" - + "\7r\2\2\u0153\u0154\7\32\2\2\u0154\u0156\5\u00c6d\2\u0155\u0153\3\2\2" - + "\2\u0155\u0156\3\2\2\2\u0156\u0157\3\2\2\2\u0157\u0159\7B\2\2\u0158\u015a" - + "\5\32\16\2\u0159\u0158\3\2\2\2\u0159\u015a\3\2\2\2\u015a\u015c\3\2\2\2" - + "\u015b\u015d\7G\2\2\u015c\u015b\3\2\2\2\u015c\u015d\3\2\2\2\u015d\u015f" - + "\3\2\2\2\u015e\u0160\5\36\20\2\u015f\u015e\3\2\2\2\u015f\u0160\3\2\2\2" - + "\u0160\u0161\3\2\2\2\u0161\u0162\7C\2\2\u0162\31\3\2\2\2\u0163\u0168\5" - + "\34\17\2\u0164\u0165\7G\2\2\u0165\u0167\5\34\17\2\u0166\u0164\3\2\2\2" - + "\u0167\u016a\3\2\2\2\u0168\u0166\3\2\2\2\u0168\u0169\3\2\2\2\u0169\33" - + "\3\2\2\2\u016a\u0168\3\2\2\2\u016b\u016d\5h\65\2\u016c\u016b\3\2\2\2\u016d" - + "\u0170\3\2\2\2\u016e\u016c\3\2\2\2\u016e\u016f\3\2\2\2\u016f\u0171\3\2" - + "\2\2\u0170\u016e\3\2\2\2\u0171\u0173\7r\2\2\u0172\u0174\5\u00d2j\2\u0173" - + "\u0172\3\2\2\2\u0173\u0174\3\2\2\2\u0174\u0176\3\2\2\2\u0175\u0177\5\"" - + "\22\2\u0176\u0175\3\2\2\2\u0176\u0177\3\2\2\2\u0177\35\3\2\2\2\u0178\u017c" - + "\7F\2\2\u0179\u017b\5&\24\2\u017a\u0179\3\2\2\2\u017b\u017e\3\2\2\2\u017c" - + "\u017a\3\2\2\2\u017c\u017d\3\2\2\2\u017d\37\3\2\2\2\u017e\u017c\3\2\2" - + "\2\u017f\u0180\7\36\2\2\u0180\u0182\7r\2\2\u0181\u0183\5\22\n\2\u0182" - + "\u0181\3\2\2\2\u0182\u0183\3\2\2\2\u0183\u0186\3\2\2\2\u0184\u0185\7\23" - + "\2\2\u0185\u0187\5\u00c6d\2\u0186\u0184\3\2\2\2\u0186\u0187\3\2\2\2\u0187" - + "\u0188\3\2\2\2\u0188\u0189\5$\23\2\u0189!\3\2\2\2\u018a\u018e\7B\2\2\u018b" - + "\u018d\5&\24\2\u018c\u018b\3\2\2\2\u018d\u0190\3\2\2\2\u018e\u018c\3\2" - + "\2\2\u018e\u018f\3\2\2\2\u018f\u0191\3\2\2\2\u0190\u018e\3\2\2\2\u0191" - + "\u0192\7C\2\2\u0192#\3\2\2\2\u0193\u0197\7B\2\2\u0194\u0196\58\35\2\u0195" - + "\u0194\3\2\2\2\u0196\u0199\3\2\2\2\u0197\u0195\3\2\2\2\u0197\u0198\3\2" - + "\2\2\u0198\u019a\3\2\2\2\u0199\u0197\3\2\2\2\u019a\u019b\7C\2\2\u019b" - + "%\3\2\2\2\u019c\u01a9\7F\2\2\u019d\u019f\7(\2\2\u019e\u019d\3\2\2\2\u019e" - + "\u019f\3\2\2\2\u019f\u01a0\3\2\2\2\u01a0\u01a9\5\u0082B\2\u01a1\u01a3" - + "\5\n\6\2\u01a2\u01a1\3\2\2\2\u01a3\u01a6\3\2\2\2\u01a4\u01a2\3\2\2\2\u01a4" - + "\u01a5\3\2\2\2\u01a5\u01a7\3\2\2\2\u01a6\u01a4\3\2\2\2\u01a7\u01a9\5(" - + "\25\2\u01a8\u019c\3\2\2\2\u01a8\u019e\3\2\2\2\u01a8\u01a4\3\2\2\2\u01a9" - + "\'\3\2\2\2\u01aa\u01b4\5*\26\2\u01ab\u01b4\5\60\31\2\u01ac\u01b4\5\66" - + "\34\2\u01ad\u01b4\5\64\33\2\u01ae\u01b4\5\62\32\2\u01af\u01b4\5 \21\2" - + "\u01b0\u01b4\5r:\2\u01b1\u01b4\5\20\t\2\u01b2\u01b4\5\30\r\2\u01b3\u01aa" - + "\3\2\2\2\u01b3\u01ab\3\2\2\2\u01b3\u01ac\3\2\2\2\u01b3\u01ad\3\2\2\2\u01b3" - + "\u01ae\3\2\2\2\u01b3\u01af\3\2\2\2\u01b3\u01b0\3\2\2\2\u01b3\u01b1\3\2" - + "\2\2\u01b3\u01b2\3\2\2\2\u01b4)\3\2\2\2\u01b5\u01b6\5.\30\2\u01b6\u01b7" - + "\7r\2\2\u01b7\u01bc\5V,\2\u01b8\u01b9\7D\2\2\u01b9\u01bb\7E\2\2\u01ba" - + "\u01b8\3\2\2\2\u01bb\u01be\3\2\2\2\u01bc\u01ba\3\2\2\2\u01bc\u01bd\3\2" - + "\2\2\u01bd\u01c1\3\2\2\2\u01be\u01bc\3\2\2\2\u01bf\u01c0\7/\2\2\u01c0" - + "\u01c2\5T+\2\u01c1\u01bf\3\2\2\2\u01c1\u01c2\3\2\2\2\u01c2\u01c3\3\2\2" - + "\2\u01c3\u01c4\5,\27\2\u01c4+\3\2\2\2\u01c5\u01c8\5\u0082B\2\u01c6\u01c8" - + "\7F\2\2\u01c7\u01c5\3\2\2\2\u01c7\u01c6\3\2\2\2\u01c8-\3\2\2\2\u01c9\u01cc" - + "\5\u00c8e\2\u01ca\u01cc\7\63\2\2\u01cb\u01c9\3\2\2\2\u01cb\u01ca\3\2\2" - + "\2\u01cc/\3\2\2\2\u01cd\u01ce\5\22\n\2\u01ce\u01cf\5*\26\2\u01cf\61\3" - + "\2\2\2\u01d0\u01d1\5\22\n\2\u01d1\u01d2\5\64\33\2\u01d2\63\3\2\2\2\u01d3" - + "\u01d4\7r\2\2\u01d4\u01d7\5V,\2\u01d5\u01d6\7/\2\2\u01d6\u01d8\5T+\2\u01d7" - + "\u01d5\3\2\2\2\u01d7\u01d8\3\2\2\2\u01d8\u01d9\3\2\2\2\u01d9\u01da\5\u0082" - + "B\2\u01da\65\3\2\2\2\u01db\u01dc\5\u00c8e\2\u01dc\u01dd\5F$\2\u01dd\u01de" - + "\7F\2\2\u01de\67\3\2\2\2\u01df\u01e1\5\n\6\2\u01e0\u01df\3\2\2\2\u01e1" - + "\u01e4\3\2\2\2\u01e2\u01e0\3\2\2\2\u01e2\u01e3\3\2\2\2\u01e3\u01e5\3\2" - + "\2\2\u01e4\u01e2\3\2\2\2\u01e5\u01e8\5:\36\2\u01e6\u01e8\7F\2\2\u01e7" - + "\u01e2\3\2\2\2\u01e7\u01e6\3\2\2\2\u01e89\3\2\2\2\u01e9\u01f1\5<\37\2" - + "\u01ea\u01f1\5@!\2\u01eb\u01f1\5D#\2\u01ec\u01f1\5 \21\2\u01ed\u01f1\5" - + "r:\2\u01ee\u01f1\5\20\t\2\u01ef\u01f1\5\30\r\2\u01f0\u01e9\3\2\2\2\u01f0" - + "\u01ea\3\2\2\2\u01f0\u01eb\3\2\2\2\u01f0\u01ec\3\2\2\2\u01f0\u01ed\3\2" - + "\2\2\u01f0\u01ee\3\2\2\2\u01f0\u01ef\3\2\2\2\u01f1;\3\2\2\2\u01f2\u01f3" - + "\5\u00c8e\2\u01f3\u01f8\5> \2\u01f4\u01f5\7G\2\2\u01f5\u01f7\5> \2\u01f6" - + "\u01f4\3\2\2\2\u01f7\u01fa\3\2\2\2\u01f8\u01f6\3\2\2\2\u01f8\u01f9\3\2" - + "\2\2\u01f9\u01fb\3\2\2\2\u01fa\u01f8\3\2\2\2\u01fb\u01fc\7F\2\2\u01fc" - + "=\3\2\2\2\u01fd\u0202\7r\2\2\u01fe\u01ff\7D\2\2\u01ff\u0201\7E\2\2\u0200" - + "\u01fe\3\2\2\2\u0201\u0204\3\2\2\2\u0202\u0200\3\2\2\2\u0202\u0203\3\2" - + "\2\2\u0203\u0205\3\2\2\2\u0204\u0202\3\2\2\2\u0205\u0206\7I\2\2\u0206" - + "\u0207\5L\'\2\u0207?\3\2\2\2\u0208\u020a\5B\"\2\u0209\u0208\3\2\2\2\u020a" - + "\u020d\3\2\2\2\u020b\u0209\3\2\2\2\u020b\u020c\3\2\2\2\u020c\u0218\3\2" - + "\2\2\u020d\u020b\3\2\2\2\u020e\u0219\5.\30\2\u020f\u0213\5\22\n\2\u0210" - + "\u0212\5h\65\2\u0211\u0210\3\2\2\2\u0212\u0215\3\2\2\2\u0213\u0211\3\2" - + "\2\2\u0213\u0214\3\2\2\2\u0214\u0216\3\2\2\2\u0215\u0213\3\2\2\2\u0216" - + "\u0217\5.\30\2\u0217\u0219\3\2\2\2\u0218\u020e\3\2\2\2\u0218\u020f\3\2" - + "\2\2\u0219\u021a\3\2\2\2\u021a\u021b\7r\2\2\u021b\u0220\5V,\2\u021c\u021d" - + "\7D\2\2\u021d\u021f\7E\2\2\u021e\u021c\3\2\2\2\u021f\u0222\3\2\2\2\u0220" - + "\u021e\3\2\2\2\u0220\u0221\3\2\2\2\u0221\u0225\3\2\2\2\u0222\u0220\3\2" - + "\2\2\u0223\u0224\7/\2\2\u0224\u0226\5T+\2\u0225\u0223\3\2\2\2\u0225\u0226" - + "\3\2\2\2\u0226\u0227\3\2\2\2\u0227\u0228\5,\27\2\u0228A\3\2\2\2\u0229" - + "\u0230\5h\65\2\u022a\u0230\7%\2\2\u022b\u0230\7\3\2\2\u022c\u0230\7\16" - + "\2\2\u022d\u0230\7(\2\2\u022e\u0230\7)\2\2\u022f\u0229\3\2\2\2\u022f\u022a" - + "\3\2\2\2\u022f\u022b\3\2\2\2\u022f\u022c\3\2\2\2\u022f\u022d\3\2\2\2\u022f" - + "\u022e\3\2\2\2\u0230C\3\2\2\2\u0231\u0232\5\22\n\2\u0232\u0233\5@!\2\u0233" - + "E\3\2\2\2\u0234\u0239\5H%\2\u0235\u0236\7G\2\2\u0236\u0238\5H%\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\u023aG\3\2\2\2\u023b\u0239\3\2\2\2\u023c\u023f\5J&\2\u023d\u023e" - + "\7I\2\2\u023e\u0240\5L\'\2\u023f\u023d\3\2\2\2\u023f\u0240\3\2\2\2\u0240" - + "I\3\2\2\2\u0241\u0246\7r\2\2\u0242\u0243\7D\2\2\u0243\u0245\7E\2\2\u0244" - + "\u0242\3\2\2\2\u0245\u0248\3\2\2\2\u0246\u0244\3\2\2\2\u0246\u0247\3\2" - + "\2\2\u0247K\3\2\2\2\u0248\u0246\3\2\2\2\u0249\u024c\5N(\2\u024a\u024c" - + "\5\u00a8U\2\u024b\u0249\3\2\2\2\u024b\u024a\3\2\2\2\u024cM\3\2\2\2\u024d" - + "\u0259\7B\2\2\u024e\u0253\5L\'\2\u024f\u0250\7G\2\2\u0250\u0252\5L\'\2" - + "\u0251\u024f\3\2\2\2\u0252\u0255\3\2\2\2\u0253\u0251\3\2\2\2\u0253\u0254" - + "\3\2\2\2\u0254\u0257\3\2\2\2\u0255\u0253\3\2\2\2\u0256\u0258\7G\2\2\u0257" - + "\u0256\3\2\2\2\u0257\u0258\3\2\2\2\u0258\u025a\3\2\2\2\u0259\u024e\3\2" - + "\2\2\u0259\u025a\3\2\2\2\u025a\u025b\3\2\2\2\u025b\u025c\7C\2\2\u025c" - + "O\3\2\2\2\u025d\u025f\7r\2\2\u025e\u0260\5\u00ccg\2\u025f\u025e\3\2\2" - + "\2\u025f\u0260\3\2\2\2\u0260\u0268\3\2\2\2\u0261\u0262\7H\2\2\u0262\u0264" - + "\7r\2\2\u0263\u0265\5\u00ccg\2\u0264\u0263\3\2\2\2\u0264\u0265\3\2\2\2" - + "\u0265\u0267\3\2\2\2\u0266\u0261\3\2\2\2\u0267\u026a\3\2\2\2\u0268\u0266" - + "\3\2\2\2\u0268\u0269\3\2\2\2\u0269Q\3\2\2\2\u026a\u0268\3\2\2\2\u026b" - + "\u0278\5\u00c8e\2\u026c\u026e\5h\65\2\u026d\u026c\3\2\2\2\u026e\u0271" - + "\3\2\2\2\u026f\u026d\3\2\2\2\u026f\u0270\3\2\2\2\u0270\u0272\3\2\2\2\u0271" - + "\u026f\3\2\2\2\u0272\u0275\7N\2\2\u0273\u0274\t\2\2\2\u0274\u0276\5\u00c8" - + "e\2\u0275\u0273\3\2\2\2\u0275\u0276\3\2\2\2\u0276\u0278\3\2\2\2\u0277" - + "\u026b\3\2\2\2\u0277\u026f\3\2\2\2\u0278S\3\2\2\2\u0279\u027e\5^\60\2" - + "\u027a\u027b\7G\2\2\u027b\u027d\5^\60\2\u027c\u027a\3\2\2\2\u027d\u0280" - + "\3\2\2\2\u027e\u027c\3\2\2\2\u027e\u027f\3\2\2\2\u027fU\3\2\2\2\u0280" - + "\u027e\3\2\2\2\u0281\u0283\7@\2\2\u0282\u0284\5X-\2\u0283\u0282\3\2\2" - + "\2\u0283\u0284\3\2\2\2\u0284\u0285\3\2\2\2\u0285\u0286\7A\2\2\u0286W\3" - + "\2\2\2\u0287\u028c\5Z.\2\u0288\u0289\7G\2\2\u0289\u028b\5Z.\2\u028a\u0288" - + "\3\2\2\2\u028b\u028e\3\2\2\2\u028c\u028a\3\2\2\2\u028c\u028d\3\2\2\2\u028d" - + "\u0291\3\2\2\2\u028e\u028c\3\2\2\2\u028f\u0290\7G\2\2\u0290\u0292\5\\" - + "/\2\u0291\u028f\3\2\2\2\u0291\u0292\3\2\2\2\u0292\u0295\3\2\2\2\u0293" - + "\u0295\5\\/\2\u0294\u0287\3\2\2\2\u0294\u0293\3\2\2\2\u0295Y\3\2\2\2\u0296" - + "\u0298\5\16\b\2\u0297\u0296\3\2\2\2\u0298\u029b\3\2\2\2\u0299\u0297\3" - + "\2\2\2\u0299\u029a\3\2\2\2\u029a\u029c\3\2\2\2\u029b\u0299\3\2\2\2\u029c" - + "\u029d\5\u00c8e\2\u029d\u029e\5J&\2\u029e[\3\2\2\2\u029f\u02a1\5\16\b" - + "\2\u02a0\u029f\3\2\2\2\u02a1\u02a4\3\2\2\2\u02a2\u02a0\3\2\2\2\u02a2\u02a3" - + "\3\2\2\2\u02a3\u02a5\3\2\2\2\u02a4\u02a2\3\2\2\2\u02a5\u02a9\5\u00c8e" - + "\2\u02a6\u02a8\5h\65\2\u02a7\u02a6\3\2\2\2\u02a8\u02ab\3\2\2\2\u02a9\u02a7" - + "\3\2\2\2\u02a9\u02aa\3\2\2\2\u02aa\u02ac\3\2\2\2\u02ab\u02a9\3\2\2\2\u02ac" - + "\u02ad\7n\2\2\u02ad\u02ae\5J&\2\u02ae]\3\2\2\2\u02af\u02b4\7r\2\2\u02b0" - + "\u02b1\7H\2\2\u02b1\u02b3\7r\2\2\u02b2\u02b0\3\2\2\2\u02b3\u02b6\3\2\2" - + "\2\u02b4\u02b2\3\2\2\2\u02b4\u02b5\3\2\2\2\u02b5_\3\2\2\2\u02b6\u02b4" - + "\3\2\2\2\u02b7\u02be\5b\62\2\u02b8\u02be\5d\63\2\u02b9\u02be\7=\2\2\u02ba" - + "\u02be\7>\2\2\u02bb\u02be\7<\2\2\u02bc\u02be\7?\2\2\u02bd\u02b7\3\2\2" - + "\2\u02bd\u02b8\3\2\2\2\u02bd\u02b9\3\2\2\2\u02bd\u02ba\3\2\2\2\u02bd\u02bb" - + "\3\2\2\2\u02bd\u02bc\3\2\2\2\u02bea\3\2\2\2\u02bf\u02c0\t\3\2\2\u02c0" - + "c\3\2\2\2\u02c1\u02c2\t\4\2\2\u02c2e\3\2\2\2\u02c3\u02c4\7r\2\2\u02c4" - + "\u02c6\7H\2\2\u02c5\u02c3\3\2\2\2\u02c6\u02c9\3\2\2\2\u02c7\u02c5\3\2" - + "\2\2\u02c7\u02c8\3\2\2\2\u02c8\u02ca\3\2\2\2\u02c9\u02c7\3\2\2\2\u02ca" - + "\u02cb\7m\2\2\u02cb\u02cc\7r\2\2\u02ccg\3\2\2\2\u02cd\u02ce\7m\2\2\u02ce" - + "\u02d1\5^\60\2\u02cf\u02d1\5f\64\2\u02d0\u02cd\3\2\2\2\u02d0\u02cf\3\2" - + "\2\2\u02d1\u02d8\3\2\2\2\u02d2\u02d5\7@\2\2\u02d3\u02d6\5j\66\2\u02d4" - + "\u02d6\5n8\2\u02d5\u02d3\3\2\2\2\u02d5\u02d4\3\2\2\2\u02d5\u02d6\3\2\2" - + "\2\u02d6\u02d7\3\2\2\2\u02d7\u02d9\7A\2\2\u02d8\u02d2\3\2\2\2\u02d8\u02d9" - + "\3\2\2\2\u02d9i\3\2\2\2\u02da\u02df\5l\67\2\u02db\u02dc\7G\2\2\u02dc\u02de" - + "\5l\67\2\u02dd\u02db\3\2\2\2\u02de\u02e1\3\2\2\2\u02df\u02dd\3\2\2\2\u02df" - + "\u02e0\3\2\2\2\u02e0k\3\2\2\2\u02e1\u02df\3\2\2\2\u02e2\u02e3\7r\2\2\u02e3" - + "\u02e4\7I\2\2\u02e4\u02e5\5n8\2\u02e5m\3\2\2\2\u02e6\u02ea\5\u00a8U\2" - + "\u02e7\u02ea\5h\65\2\u02e8\u02ea\5p9\2\u02e9\u02e6\3\2\2\2\u02e9\u02e7" - + "\3\2\2\2\u02e9\u02e8\3\2\2\2\u02eao\3\2\2\2\u02eb\u02f4\7B\2\2\u02ec\u02f1" - + "\5n8\2\u02ed\u02ee\7G\2\2\u02ee\u02f0\5n8\2\u02ef\u02ed\3\2\2\2\u02f0" - + "\u02f3\3\2\2\2\u02f1\u02ef\3\2\2\2\u02f1\u02f2\3\2\2\2\u02f2\u02f5\3\2" - + "\2\2\u02f3\u02f1\3\2\2\2\u02f4\u02ec\3\2\2\2\u02f4\u02f5\3\2\2\2\u02f5" - + "\u02f7\3\2\2\2\u02f6\u02f8\7G\2\2\u02f7\u02f6\3\2\2\2\u02f7\u02f8\3\2" - + "\2\2\u02f8\u02f9\3\2\2\2\u02f9\u02fa\7C\2\2\u02faq\3\2\2\2\u02fb\u02fc" - + "\7m\2\2\u02fc\u02fd\7\36\2\2\u02fd\u02fe\7r\2\2\u02fe\u02ff\5t;\2\u02ff" - + "s\3\2\2\2\u0300\u0304\7B\2\2\u0301\u0303\5v<\2\u0302\u0301\3\2\2\2\u0303" - + "\u0306\3\2\2\2\u0304\u0302\3\2\2\2\u0304\u0305\3\2\2\2\u0305\u0307\3\2" - + "\2\2\u0306\u0304\3\2\2\2\u0307\u0308\7C\2\2\u0308u\3\2\2\2\u0309\u030b" - + "\5\n\6\2\u030a\u0309\3\2\2\2\u030b\u030e\3\2\2\2\u030c\u030a\3\2\2\2\u030c" - + "\u030d\3\2\2\2\u030d\u030f\3\2\2\2\u030e\u030c\3\2\2\2\u030f\u0312\5x" - + "=\2\u0310\u0312\7F\2\2\u0311\u030c\3\2\2\2\u0311\u0310\3\2\2\2\u0312w" - + "\3\2\2\2\u0313\u0314\5\u00c8e\2\u0314\u0315\5z>\2\u0315\u0316\7F\2\2\u0316" - + "\u0328\3\2\2\2\u0317\u0319\5\20\t\2\u0318\u031a\7F\2\2\u0319\u0318\3\2" - + "\2\2\u0319\u031a\3\2\2\2\u031a\u0328\3\2\2\2\u031b\u031d\5 \21\2\u031c" - + "\u031e\7F\2\2\u031d\u031c\3\2\2\2\u031d\u031e\3\2\2\2\u031e\u0328\3\2" - + "\2\2\u031f\u0321\5\30\r\2\u0320\u0322\7F\2\2\u0321\u0320\3\2\2\2\u0321" - + "\u0322\3\2\2\2\u0322\u0328\3\2\2\2\u0323\u0325\5r:\2\u0324\u0326\7F\2" - + "\2\u0325\u0324\3\2\2\2\u0325\u0326\3\2\2\2\u0326\u0328\3\2\2\2\u0327\u0313" - + "\3\2\2\2\u0327\u0317\3\2\2\2\u0327\u031b\3\2\2\2\u0327\u031f\3\2\2\2\u0327" - + "\u0323\3\2\2\2\u0328y\3\2\2\2\u0329\u032c\5|?\2\u032a\u032c\5~@\2\u032b" - + "\u0329\3\2\2\2\u032b\u032a\3\2\2\2\u032c{\3\2\2\2\u032d\u032e\7r\2\2\u032e" - + "\u032f\7@\2\2\u032f\u0331\7A\2\2\u0330\u0332\5\u0080A\2\u0331\u0330\3" - + "\2\2\2\u0331\u0332\3\2\2\2\u0332}\3\2\2\2\u0333\u0334\5F$\2\u0334\177" - + "\3\2\2\2\u0335\u0336\7\16\2\2\u0336\u0337\5n8\2\u0337\u0081\3\2\2\2\u0338" - + "\u033c\7B\2\2\u0339\u033b\5\u0084C\2\u033a\u0339\3\2\2\2\u033b\u033e\3" - + "\2\2\2\u033c\u033a\3\2\2\2\u033c\u033d\3\2\2\2\u033d\u033f\3\2\2\2\u033e" - + "\u033c\3\2\2\2\u033f\u0340\7C\2\2\u0340\u0083\3\2\2\2\u0341\u0342\5\u0086" - + "D\2\u0342\u0343\7F\2\2\u0343\u0347\3\2\2\2\u0344\u0347\5\u008aF\2\u0345" - + "\u0347\5\u0088E\2\u0346\u0341\3\2\2\2\u0346\u0344\3\2\2\2\u0346\u0345" - + "\3\2\2\2\u0347\u0085\3\2\2\2\u0348\u034a\5\16\b\2\u0349\u0348\3\2\2\2" - + "\u034a\u034d\3\2\2\2\u034b\u0349\3\2\2\2\u034b\u034c\3\2\2\2\u034c\u034e" - + "\3\2\2\2\u034d\u034b\3\2\2\2\u034e\u034f\5\u00c8e\2\u034f\u0350\5F$\2" - + "\u0350\u0087\3\2\2\2\u0351\u0353\5\f\7\2\u0352\u0351\3\2\2\2\u0353\u0356" - + "\3\2\2\2\u0354\u0352\3\2\2\2\u0354\u0355\3\2\2\2\u0355\u0359\3\2\2\2\u0356" - + "\u0354\3\2\2\2\u0357\u035a\5\20\t\2\u0358\u035a\5 \21\2\u0359\u0357\3" - + "\2\2\2\u0359\u0358\3\2\2\2\u035a\u035d\3\2\2\2\u035b\u035d\7F\2\2\u035c" - + "\u0354\3\2\2\2\u035c\u035b\3\2\2\2\u035d\u0089\3\2\2\2\u035e\u03c7\5\u0082" - + "B\2\u035f\u0360\7\4\2\2\u0360\u0363\5\u00a8U\2\u0361\u0362\7O\2\2\u0362" - + "\u0364\5\u00a8U\2\u0363\u0361\3\2\2\2\u0363\u0364\3\2\2\2\u0364\u0365" - + "\3\2\2\2\u0365\u0366\7F\2\2\u0366\u03c7\3\2\2\2\u0367\u0368\7\30\2\2\u0368" - + "\u0369\5\u00a2R\2\u0369\u036c\5\u008aF\2\u036a\u036b\7\21\2\2\u036b\u036d" - + "\5\u008aF\2\u036c\u036a\3\2\2\2\u036c\u036d\3\2\2\2\u036d\u03c7\3\2\2" - + "\2\u036e\u036f\7\27\2\2\u036f\u0370\7@\2\2\u0370\u0371\5\u009cO\2\u0371" - + "\u0372\7A\2\2\u0372\u0373\5\u008aF\2\u0373\u03c7\3\2\2\2\u0374\u0375\7" - + "\65\2\2\u0375\u0376\5\u00a2R\2\u0376\u0377\5\u008aF\2\u0377\u03c7\3\2" - + "\2\2\u0378\u0379\7\17\2\2\u0379\u037a\5\u008aF\2\u037a\u037b\7\65\2\2" - + "\u037b\u037c\5\u00a2R\2\u037c\u037d\7F\2\2\u037d\u03c7\3\2\2\2\u037e\u037f" - + "\7\61\2\2\u037f\u0389\5\u0082B\2\u0380\u0382\5\u008cG\2\u0381\u0380\3" - + "\2\2\2\u0382\u0383\3\2\2\2\u0383\u0381\3\2\2\2\u0383\u0384\3\2\2\2\u0384" - + "\u0386\3\2\2\2\u0385\u0387\5\u0090I\2\u0386\u0385\3\2\2\2\u0386\u0387" - + "\3\2\2\2\u0387\u038a\3\2\2\2\u0388\u038a\5\u0090I\2\u0389\u0381\3\2\2" - + "\2\u0389\u0388\3\2\2\2\u038a\u03c7\3\2\2\2\u038b\u038c\7\61\2\2\u038c" - + "\u038d\5\u0092J\2\u038d\u0391\5\u0082B\2\u038e\u0390\5\u008cG\2\u038f" - + "\u038e\3\2\2\2\u0390\u0393\3\2\2\2\u0391\u038f\3\2\2\2\u0391\u0392\3\2" - + "\2\2\u0392\u0395\3\2\2\2\u0393\u0391\3\2\2\2\u0394\u0396\5\u0090I\2\u0395" - + "\u0394\3\2\2\2\u0395\u0396\3\2\2\2\u0396\u03c7\3\2\2\2\u0397\u0398\7+" - + "\2\2\u0398\u0399\5\u00a2R\2\u0399\u039d\7B\2\2\u039a\u039c\5\u0098M\2" - + "\u039b\u039a\3\2\2\2\u039c\u039f\3\2\2\2\u039d\u039b\3\2\2\2\u039d\u039e" - + "\3\2\2\2\u039e\u03a3\3\2\2\2\u039f\u039d\3\2\2\2\u03a0\u03a2\5\u009aN" - + "\2\u03a1\u03a0\3\2\2\2\u03a2\u03a5\3\2\2\2\u03a3\u03a1\3\2\2\2\u03a3\u03a4" - + "\3\2\2\2\u03a4\u03a6\3\2\2\2\u03a5\u03a3\3\2\2\2\u03a6\u03a7\7C\2\2\u03a7" - + "\u03c7\3\2\2\2\u03a8\u03a9\7,\2\2\u03a9\u03aa\5\u00a2R\2\u03aa\u03ab\5" - + "\u0082B\2\u03ab\u03c7\3\2\2\2\u03ac\u03ae\7&\2\2\u03ad\u03af\5\u00a8U" - + "\2\u03ae\u03ad\3\2\2\2\u03ae\u03af\3\2\2\2\u03af\u03b0\3\2\2\2\u03b0\u03c7" - + "\7F\2\2\u03b1\u03b2\7.\2\2\u03b2\u03b3\5\u00a8U\2\u03b3\u03b4\7F\2\2\u03b4" - + "\u03c7\3\2\2\2\u03b5\u03b7\7\6\2\2\u03b6\u03b8\7r\2\2\u03b7\u03b6\3\2" - + "\2\2\u03b7\u03b8\3\2\2\2\u03b8\u03b9\3\2\2\2\u03b9\u03c7\7F\2\2\u03ba" - + "\u03bc\7\r\2\2\u03bb\u03bd\7r\2\2\u03bc\u03bb\3\2\2\2\u03bc\u03bd\3\2" - + "\2\2\u03bd\u03be\3\2\2\2\u03be\u03c7\7F\2\2\u03bf\u03c7\7F\2\2\u03c0\u03c1" - + "\5\u00a8U\2\u03c1\u03c2\7F\2\2\u03c2\u03c7\3\2\2\2\u03c3\u03c4\7r\2\2" - + "\u03c4\u03c5\7O\2\2\u03c5\u03c7\5\u008aF\2\u03c6\u035e\3\2\2\2\u03c6\u035f" - + "\3\2\2\2\u03c6\u0367\3\2\2\2\u03c6\u036e\3\2\2\2\u03c6\u0374\3\2\2\2\u03c6" - + "\u0378\3\2\2\2\u03c6\u037e\3\2\2\2\u03c6\u038b\3\2\2\2\u03c6\u0397\3\2" - + "\2\2\u03c6\u03a8\3\2\2\2\u03c6\u03ac\3\2\2\2\u03c6\u03b1\3\2\2\2\u03c6" - + "\u03b5\3\2\2\2\u03c6\u03ba\3\2\2\2\u03c6\u03bf\3\2\2\2\u03c6\u03c0\3\2" - + "\2\2\u03c6\u03c3\3\2\2\2\u03c7\u008b\3\2\2\2\u03c8\u03c9\7\t\2\2\u03c9" - + "\u03cd\7@\2\2\u03ca\u03cc\5\16\b\2\u03cb\u03ca\3\2\2\2\u03cc\u03cf\3\2" - + "\2\2\u03cd\u03cb\3\2\2\2\u03cd\u03ce\3\2\2\2\u03ce\u03d0\3\2\2\2\u03cf" - + "\u03cd\3\2\2\2\u03d0\u03d1\5\u008eH\2\u03d1\u03d2\7r\2\2\u03d2\u03d3\7" - + "A\2\2\u03d3\u03d4\5\u0082B\2\u03d4\u008d\3\2\2\2\u03d5\u03da\5^\60\2\u03d6" - + "\u03d7\7]\2\2\u03d7\u03d9\5^\60\2\u03d8\u03d6\3\2\2\2\u03d9\u03dc\3\2" - + "\2\2\u03da\u03d8\3\2\2\2\u03da\u03db\3\2\2\2\u03db\u008f\3\2\2\2\u03dc" - + "\u03da\3\2\2\2\u03dd\u03de\7\25\2\2\u03de\u03df\5\u0082B\2\u03df\u0091" - + "\3\2\2\2\u03e0\u03e1\7@\2\2\u03e1\u03e3\5\u0094K\2\u03e2\u03e4\7F\2\2" - + "\u03e3\u03e2\3\2\2\2\u03e3\u03e4\3\2\2\2\u03e4\u03e5\3\2\2\2\u03e5\u03e6" - + "\7A\2\2\u03e6\u0093\3\2\2\2\u03e7\u03ec\5\u0096L\2\u03e8\u03e9\7F\2\2" - + "\u03e9\u03eb\5\u0096L\2\u03ea\u03e8\3\2\2\2\u03eb\u03ee\3\2\2\2\u03ec" - + "\u03ea\3\2\2\2\u03ec\u03ed\3\2\2\2\u03ed\u0095\3\2\2\2\u03ee\u03ec\3\2" - + "\2\2\u03ef\u03f1\5\16\b\2\u03f0\u03ef\3\2\2\2\u03f1\u03f4\3\2\2\2\u03f2" - + "\u03f0\3\2\2\2\u03f2\u03f3\3\2\2\2\u03f3\u03f5\3\2\2\2\u03f4\u03f2\3\2" - + "\2\2\u03f5\u03f6\5P)\2\u03f6\u03f7\5J&\2\u03f7\u03f8\7I\2\2\u03f8\u03f9" - + "\5\u00a8U\2\u03f9\u0097\3\2\2\2\u03fa\u03fc\5\u009aN\2\u03fb\u03fa\3\2" - + "\2\2\u03fc\u03fd\3\2\2\2\u03fd\u03fb\3\2\2\2\u03fd\u03fe\3\2\2\2\u03fe" - + "\u0400\3\2\2\2\u03ff\u0401\5\u0084C\2\u0400\u03ff\3\2\2\2\u0401\u0402" - + "\3\2\2\2\u0402\u0400\3\2\2\2\u0402\u0403\3\2\2\2\u0403\u0099\3\2\2\2\u0404" - + "\u0407\7\b\2\2\u0405\u0408\5\u00a8U\2\u0406\u0408\7r\2\2\u0407\u0405\3" - + "\2\2\2\u0407\u0406\3\2\2\2\u0408\u0409\3\2\2\2\u0409\u040d\7O\2\2\u040a" - + "\u040b\7\16\2\2\u040b\u040d\7O\2\2\u040c\u0404\3\2\2\2\u040c\u040a\3\2" - + "\2\2\u040d\u009b\3\2\2\2\u040e\u041b\5\u00a0Q\2\u040f\u0411\5\u009eP\2" - + "\u0410\u040f\3\2\2\2\u0410\u0411\3\2\2\2\u0411\u0412\3\2\2\2\u0412\u0414" - + "\7F\2\2\u0413\u0415\5\u00a8U\2\u0414\u0413\3\2\2\2\u0414\u0415\3\2\2\2" - + "\u0415\u0416\3\2\2\2\u0416\u0418\7F\2\2\u0417\u0419\5\u00a4S\2\u0418\u0417" - + "\3\2\2\2\u0418\u0419\3\2\2\2\u0419\u041b\3\2\2\2\u041a\u040e\3\2\2\2\u041a" - + "\u0410\3\2\2\2\u041b\u009d\3\2\2\2\u041c\u041f\5\u0086D\2\u041d\u041f" - + "\5\u00a4S\2\u041e\u041c\3\2\2\2\u041e\u041d\3\2\2\2\u041f\u009f\3\2\2" - + "\2\u0420\u0422\5\16\b\2\u0421\u0420\3\2\2\2\u0422\u0425\3\2\2\2\u0423" - + "\u0421\3\2\2\2\u0423\u0424\3\2\2\2\u0424\u0426\3\2\2\2\u0425\u0423\3\2" - + "\2\2\u0426\u0427\5\u00c8e\2\u0427\u0428\5J&\2\u0428\u0429\7O\2\2\u0429" - + "\u042a\5\u00a8U\2\u042a\u00a1\3\2\2\2\u042b\u042c\7@\2\2\u042c\u042d\5" - + "\u00a8U\2\u042d\u042e\7A\2\2\u042e\u00a3\3\2\2\2\u042f\u0434\5\u00a8U" - + "\2\u0430\u0431\7G\2\2\u0431\u0433\5\u00a8U\2\u0432\u0430\3\2\2\2\u0433" - + "\u0436\3\2\2\2\u0434\u0432\3\2\2\2\u0434\u0435\3\2\2\2\u0435\u00a5\3\2" - + "\2\2\u0436\u0434\3\2\2\2\u0437\u0438\7r\2\2\u0438\u043a\7@\2\2\u0439\u043b" - + "\5\u00a4S\2\u043a\u0439\3\2\2\2\u043a\u043b\3\2\2\2\u043b\u043c\3\2\2" - + "\2\u043c\u044a\7A\2\2\u043d\u043e\7-\2\2\u043e\u0440\7@\2\2\u043f\u0441" - + "\5\u00a4S\2\u0440\u043f\3\2\2\2\u0440\u0441\3\2\2\2\u0441\u0442\3\2\2" - + "\2\u0442\u044a\7A\2\2\u0443\u0444\7*\2\2\u0444\u0446\7@\2\2\u0445\u0447" - + "\5\u00a4S\2\u0446\u0445\3\2\2\2\u0446\u0447\3\2\2\2\u0447\u0448\3\2\2" - + "\2\u0448\u044a\7A\2\2\u0449\u0437\3\2\2\2\u0449\u043d\3\2\2\2\u0449\u0443" - + "\3\2\2\2\u044a\u00a7\3\2\2\2\u044b\u044c\bU\1\2\u044c\u0478\5\u00b0Y\2" - + "\u044d\u0478\5\u00a6T\2\u044e\u044f\7!\2\2\u044f\u0478\5\u00b4[\2\u0450" - + "\u0454\7@\2\2\u0451\u0453\5h\65\2\u0452\u0451\3\2\2\2\u0453\u0456\3\2" - + "\2\2\u0454\u0452\3\2\2\2\u0454\u0455\3\2\2\2\u0455\u0457\3\2\2\2\u0456" - + "\u0454\3\2\2\2\u0457\u045c\5\u00c8e\2\u0458\u0459\7\\\2\2\u0459\u045b" - + "\5\u00c8e\2\u045a\u0458\3\2\2\2\u045b\u045e\3\2\2\2\u045c\u045a\3\2\2" - + "\2\u045c\u045d\3\2\2\2\u045d\u045f\3\2\2\2\u045e\u045c\3\2\2\2\u045f\u0460" - + "\7A\2\2\u0460\u0461\5\u00a8U\27\u0461\u0478\3\2\2\2\u0462\u0463\t\5\2" - + "\2\u0463\u0478\5\u00a8U\25\u0464\u0465\t\6\2\2\u0465\u0478\5\u00a8U\24" - + "\u0466\u0478\5\u00aaV\2\u0467\u0468\5\u00c8e\2\u0468\u046e\7l\2\2\u0469" - + "\u046b\5\u00ccg\2\u046a\u0469\3\2\2\2\u046a\u046b\3\2\2\2\u046b\u046c" - + "\3\2\2\2\u046c\u046f\7r\2\2\u046d\u046f\7!\2\2\u046e\u046a\3\2\2\2\u046e" - + "\u046d\3\2\2\2\u046f\u0478\3\2\2\2\u0470\u0471\5\u00b2Z\2\u0471\u0473" - + "\7l\2\2\u0472\u0474\5\u00ccg\2\u0473\u0472\3\2\2\2\u0473\u0474\3\2\2\2" - + "\u0474\u0475\3\2\2\2\u0475\u0476\7!\2\2\u0476\u0478\3\2\2\2\u0477\u044b" - + "\3\2\2\2\u0477\u044d\3\2\2\2\u0477\u044e\3\2\2\2\u0477\u0450\3\2\2\2\u0477" - + "\u0462\3\2\2\2\u0477\u0464\3\2\2\2\u0477\u0466\3\2\2\2\u0477\u0467\3\2" - + "\2\2\u0477\u0470\3\2\2\2\u0478\u04c9\3\2\2\2\u0479\u047a\f\23\2\2\u047a" - + "\u047b\t\7\2\2\u047b\u04c8\5\u00a8U\24\u047c\u047d\f\22\2\2\u047d\u047e" - + "\t\b\2\2\u047e\u04c8\5\u00a8U\23\u047f\u0487\f\21\2\2\u0480\u0481\7K\2" - + "\2\u0481\u0488\7K\2\2\u0482\u0483\7J\2\2\u0483\u0484\7J\2\2\u0484\u0488" - + "\7J\2\2\u0485\u0486\7J\2\2\u0486\u0488\7J\2\2\u0487\u0480\3\2\2\2\u0487" - + "\u0482\3\2\2\2\u0487\u0485\3\2\2\2\u0488\u0489\3\2\2\2\u0489\u04c8\5\u00a8" - + "U\22\u048a\u048b\f\20\2\2\u048b\u048c\t\t\2\2\u048c\u04c8\5\u00a8U\21" - + "\u048d\u048e\f\16\2\2\u048e\u048f\t\n\2\2\u048f\u04c8\5\u00a8U\17\u0490" - + "\u0491\f\r\2\2\u0491\u0492\7\\\2\2\u0492\u04c8\5\u00a8U\16\u0493\u0494" - + "\f\f\2\2\u0494\u0495\7^\2\2\u0495\u04c8\5\u00a8U\r\u0496\u0497\f\13\2" - + "\2\u0497\u0498\7]\2\2\u0498\u04c8\5\u00a8U\f\u0499\u049a\f\n\2\2\u049a" - + "\u049b\7T\2\2\u049b\u04c8\5\u00a8U\13\u049c\u049d\f\t\2\2\u049d\u049e" - + "\7U\2\2\u049e\u04c8\5\u00a8U\n\u049f\u04a0\f\b\2\2\u04a0\u04a1\7N\2\2" - + "\u04a1\u04a2\5\u00a8U\2\u04a2\u04a3\7O\2\2\u04a3\u04a4\5\u00a8U\b\u04a4" - + "\u04c8\3\2\2\2\u04a5\u04a6\f\7\2\2\u04a6\u04a7\t\13\2\2\u04a7\u04c8\5" - + "\u00a8U\7\u04a8\u04a9\f\33\2\2\u04a9\u04b5\7H\2\2\u04aa\u04b6\7r\2\2\u04ab" - + "\u04b6\5\u00a6T\2\u04ac\u04b6\7-\2\2\u04ad\u04af\7!\2\2\u04ae\u04b0\5" - + "\u00c4c\2\u04af\u04ae\3\2\2\2\u04af\u04b0\3\2\2\2\u04b0\u04b1\3\2\2\2" - + "\u04b1\u04b6\5\u00b8]\2\u04b2\u04b3\7*\2\2\u04b3\u04b6\5\u00ceh\2\u04b4" - + "\u04b6\5\u00be`\2\u04b5\u04aa\3\2\2\2\u04b5\u04ab\3\2\2\2\u04b5\u04ac" - + "\3\2\2\2\u04b5\u04ad\3\2\2\2\u04b5\u04b2\3\2\2\2\u04b5\u04b4\3\2\2\2\u04b6" - + "\u04c8\3\2\2\2\u04b7\u04b8\f\32\2\2\u04b8\u04b9\7D\2\2\u04b9\u04ba\5\u00a8" - + "U\2\u04ba\u04bb\7E\2\2\u04bb\u04c8\3\2\2\2\u04bc\u04bd\f\26\2\2\u04bd" - + "\u04c8\t\f\2\2\u04be\u04bf\f\17\2\2\u04bf\u04c0\7\34\2\2\u04c0\u04c8\5" - + "\u00c8e\2\u04c1\u04c2\f\5\2\2\u04c2\u04c4\7l\2\2\u04c3\u04c5\5\u00ccg" - + "\2\u04c4\u04c3\3\2\2\2\u04c4\u04c5\3\2\2\2\u04c5\u04c6\3\2\2\2\u04c6\u04c8" - + "\7r\2\2\u04c7\u0479\3\2\2\2\u04c7\u047c\3\2\2\2\u04c7\u047f\3\2\2\2\u04c7" - + "\u048a\3\2\2\2\u04c7\u048d\3\2\2\2\u04c7\u0490\3\2\2\2\u04c7\u0493\3\2" - + "\2\2\u04c7\u0496\3\2\2\2\u04c7\u0499\3\2\2\2\u04c7\u049c\3\2\2\2\u04c7" - + "\u049f\3\2\2\2\u04c7\u04a5\3\2\2\2\u04c7\u04a8\3\2\2\2\u04c7\u04b7\3\2" - + "\2\2\u04c7\u04bc\3\2\2\2\u04c7\u04be\3\2\2\2\u04c7\u04c1\3\2\2\2\u04c8" - + "\u04cb\3\2\2\2\u04c9\u04c7\3\2\2\2\u04c9\u04ca\3\2\2\2\u04ca\u00a9\3\2" - + "\2\2\u04cb\u04c9\3\2\2\2\u04cc\u04cd\5\u00acW\2\u04cd\u04ce\7k\2\2\u04ce" - + "\u04cf\5\u00aeX\2\u04cf\u00ab\3\2\2\2\u04d0\u04e1\7r\2\2\u04d1\u04d3\7" - + "@\2\2\u04d2\u04d4\5X-\2\u04d3\u04d2\3\2\2\2\u04d3\u04d4\3\2\2\2\u04d4" - + "\u04d5\3\2\2\2\u04d5\u04e1\7A\2\2\u04d6\u04d7\7@\2\2\u04d7\u04dc\7r\2" - + "\2\u04d8\u04d9\7G\2\2\u04d9\u04db\7r\2\2\u04da\u04d8\3\2\2\2\u04db\u04de" - + "\3\2\2\2\u04dc\u04da\3\2\2\2\u04dc\u04dd\3\2\2\2\u04dd\u04df\3\2\2\2\u04de" - + "\u04dc\3\2\2\2\u04df\u04e1\7A\2\2\u04e0\u04d0\3\2\2\2\u04e0\u04d1\3\2" - + "\2\2\u04e0\u04d6\3\2\2\2\u04e1\u00ad\3\2\2\2\u04e2\u04e5\5\u00a8U\2\u04e3" - + "\u04e5\5\u0082B\2\u04e4\u04e2\3\2\2\2\u04e4\u04e3\3\2\2\2\u04e5\u00af" - + "\3\2\2\2\u04e6\u04e7\7@\2\2\u04e7\u04e8\5\u00a8U\2\u04e8\u04e9\7A\2\2" - + "\u04e9\u04f9\3\2\2\2\u04ea\u04f9\7-\2\2\u04eb\u04f9\7*\2\2\u04ec\u04f9" - + "\5`\61\2\u04ed\u04f9\7r\2\2\u04ee\u04ef\5.\30\2\u04ef\u04f0\7H\2\2\u04f0" - + "\u04f1\7\13\2\2\u04f1\u04f9\3\2\2\2\u04f2\u04f6\5\u00c4c\2\u04f3\u04f7" - + "\5\u00d0i\2\u04f4\u04f5\7-\2\2\u04f5\u04f7\5\u00d2j\2\u04f6\u04f3\3\2" - + "\2\2\u04f6\u04f4\3\2\2\2\u04f7\u04f9\3\2\2\2\u04f8\u04e6\3\2\2\2\u04f8" - + "\u04ea\3\2\2\2\u04f8\u04eb\3\2\2\2\u04f8\u04ec\3\2\2\2\u04f8\u04ed\3\2" - + "\2\2\u04f8\u04ee\3\2\2\2\u04f8\u04f2\3\2\2\2\u04f9\u00b1\3\2\2\2\u04fa" - + "\u04fb\5P)\2\u04fb\u04fc\7H\2\2\u04fc\u04fe\3\2\2\2\u04fd\u04fa\3\2\2" - + "\2\u04fd\u04fe\3\2\2\2\u04fe\u0502\3\2\2\2\u04ff\u0501\5h\65\2\u0500\u04ff" - + "\3\2\2\2\u0501\u0504\3\2\2\2\u0502\u0500\3\2\2\2\u0502\u0503\3\2\2\2\u0503" - + "\u0505\3\2\2\2\u0504\u0502\3\2\2\2\u0505\u0507\7r\2\2\u0506\u0508\5\u00cc" - + "g\2\u0507\u0506\3\2\2\2\u0507\u0508\3\2\2\2\u0508\u00b3\3\2\2\2\u0509" - + "\u050a\5\u00c4c\2\u050a\u050b\5\u00b6\\\2\u050b\u050c\5\u00bc_\2\u050c" - + "\u0513\3\2\2\2\u050d\u0510\5\u00b6\\\2\u050e\u0511\5\u00ba^\2\u050f\u0511" - + "\5\u00bc_\2\u0510\u050e\3\2\2\2\u0510\u050f\3\2\2\2\u0511\u0513\3\2\2" - + "\2\u0512\u0509\3\2\2\2\u0512\u050d\3\2\2\2\u0513\u00b5\3\2\2\2\u0514\u0516" - + "\7r\2\2\u0515\u0517\5\u00c0a\2\u0516\u0515\3\2\2\2\u0516\u0517\3\2\2\2" - + "\u0517\u051f\3\2\2\2\u0518\u0519\7H\2\2\u0519\u051b\7r\2\2\u051a\u051c" - + "\5\u00c0a\2\u051b\u051a\3\2\2\2\u051b\u051c\3\2\2\2\u051c\u051e\3\2\2" - + "\2\u051d\u0518\3\2\2\2\u051e\u0521\3\2\2\2\u051f\u051d\3\2\2\2\u051f\u0520" - + "\3\2\2\2\u0520\u0524\3\2\2\2\u0521\u051f\3\2\2\2\u0522\u0524\5\u00caf" - + "\2\u0523\u0514\3\2\2\2\u0523\u0522\3\2\2\2\u0524\u00b7\3\2\2\2\u0525\u0527" - + "\7r\2\2\u0526\u0528\5\u00c2b\2\u0527\u0526\3\2\2\2\u0527\u0528\3\2\2\2" - + "\u0528\u0529\3\2\2\2\u0529\u052a\5\u00bc_\2\u052a\u00b9\3\2\2\2\u052b" - + "\u0547\7D\2\2\u052c\u0531\7E\2\2\u052d\u052e\7D\2\2\u052e\u0530\7E\2\2" - + "\u052f\u052d\3\2\2\2\u0530\u0533\3\2\2\2\u0531\u052f\3\2\2\2\u0531\u0532" - + "\3\2\2\2\u0532\u0534\3\2\2\2\u0533\u0531\3\2\2\2\u0534\u0548\5N(\2\u0535" - + "\u0536\5\u00a8U\2\u0536\u053d\7E\2\2\u0537\u0538\7D\2\2\u0538\u0539\5" - + "\u00a8U\2\u0539\u053a\7E\2\2\u053a\u053c\3\2\2\2\u053b\u0537\3\2\2\2\u053c" - + "\u053f\3\2\2\2\u053d\u053b\3\2\2\2\u053d\u053e\3\2\2\2\u053e\u0544\3\2" - + "\2\2\u053f\u053d\3\2\2\2\u0540\u0541\7D\2\2\u0541\u0543\7E\2\2\u0542\u0540" - + "\3\2\2\2\u0543\u0546\3\2\2\2\u0544\u0542\3\2\2\2\u0544\u0545\3\2\2\2\u0545" - + "\u0548\3\2\2\2\u0546\u0544\3\2\2\2\u0547\u052c\3\2\2\2\u0547\u0535\3\2" - + "\2\2\u0548\u00bb\3\2\2\2\u0549\u054b\5\u00d2j\2\u054a\u054c\5\"\22\2\u054b" - + "\u054a\3\2\2\2\u054b\u054c\3\2\2\2\u054c\u00bd\3\2\2\2\u054d\u054e\5\u00c4" - + "c\2\u054e\u054f\5\u00d0i\2\u054f\u00bf\3\2\2\2\u0550\u0551\7K\2\2\u0551" - + "\u0554\7J\2\2\u0552\u0554\5\u00ccg\2\u0553\u0550\3\2\2\2\u0553\u0552\3" - + "\2\2\2\u0554\u00c1\3\2\2\2\u0555\u0556\7K\2\2\u0556\u0559\7J\2\2\u0557" - + "\u0559\5\u00c4c\2\u0558\u0555\3\2\2\2\u0558\u0557\3\2\2\2\u0559\u00c3" - + "\3\2\2\2\u055a\u055b\7K\2\2\u055b\u055c\5\u00c6d\2\u055c\u055d\7J\2\2" - + "\u055d\u00c5\3\2\2\2\u055e\u0563\5\u00c8e\2\u055f\u0560\7G\2\2\u0560\u0562" - + "\5\u00c8e\2\u0561\u055f\3\2\2\2\u0562\u0565\3\2\2\2\u0563\u0561\3\2\2" - + "\2\u0563\u0564\3\2\2\2\u0564\u00c7\3\2\2\2\u0565\u0563\3\2\2\2\u0566\u0568" - + "\5h\65\2\u0567\u0566\3\2\2\2\u0568\u056b\3\2\2\2\u0569\u0567\3\2\2\2\u0569" - + "\u056a\3\2\2\2\u056a\u056e\3\2\2\2\u056b\u0569\3\2\2\2\u056c\u056f\5P" - + ")\2\u056d\u056f\5\u00caf\2\u056e\u056c\3\2\2\2\u056e\u056d\3\2\2\2\u056f" - + "\u057a\3\2\2\2\u0570\u0572\5h\65\2\u0571\u0570\3\2\2\2\u0572\u0575\3\2" - + "\2\2\u0573\u0571\3\2\2\2\u0573\u0574\3\2\2\2\u0574\u0576\3\2\2\2\u0575" - + "\u0573\3\2\2\2\u0576\u0577\7D\2\2\u0577\u0579\7E\2\2\u0578\u0573\3\2\2" - + "\2\u0579\u057c\3\2\2\2\u057a\u0578\3\2\2\2\u057a\u057b\3\2\2\2\u057b\u00c9" - + "\3\2\2\2\u057c\u057a\3\2\2\2\u057d\u057e\t\r\2\2\u057e\u00cb\3\2\2\2\u057f" - + "\u0580\7K\2\2\u0580\u0585\5R*\2\u0581\u0582\7G\2\2\u0582\u0584\5R*\2\u0583" - + "\u0581\3\2\2\2\u0584\u0587\3\2\2\2\u0585\u0583\3\2\2\2\u0585\u0586\3\2" - + "\2\2\u0586\u0588\3\2\2\2\u0587\u0585\3\2\2\2\u0588\u0589\7J\2\2\u0589" - + "\u00cd\3\2\2\2\u058a\u0591\5\u00d2j\2\u058b\u058c\7H\2\2\u058c\u058e\7" - + "r\2\2\u058d\u058f\5\u00d2j\2\u058e\u058d\3\2\2\2\u058e\u058f\3\2\2\2\u058f" - + "\u0591\3\2\2\2\u0590\u058a\3\2\2\2\u0590\u058b\3\2\2\2\u0591\u00cf\3\2" - + "\2\2\u0592\u0593\7*\2\2\u0593\u0597\5\u00ceh\2\u0594\u0595\7r\2\2\u0595" - + "\u0597\5\u00d2j\2\u0596\u0592\3\2\2\2\u0596\u0594\3\2\2\2\u0597\u00d1" - + "\3\2\2\2\u0598\u059a\7@\2\2\u0599\u059b\5\u00a4S\2\u059a\u0599\3\2\2\2" - + "\u059a\u059b\3\2\2\2\u059b\u059c\3\2\2\2\u059c\u059d\7A\2\2\u059d\u00d3" - + "\3\2\2\2\u00b5\u00d5\u00da\u00e0\u00e8\u00f1\u00f6\u00fd\u0104\u0107\u010e" - + "\u0118\u011c\u0121\u0125\u0129\u0133\u013b\u0143\u0147\u014e\u0155\u0159" - + "\u015c\u015f\u0168\u016e\u0173\u0176\u017c\u0182\u0186\u018e\u0197\u019e" - + "\u01a4\u01a8\u01b3\u01bc\u01c1\u01c7\u01cb\u01d7\u01e2\u01e7\u01f0\u01f8" - + "\u0202\u020b\u0213\u0218\u0220\u0225\u022f\u0239\u023f\u0246\u024b\u0253" - + "\u0257\u0259\u025f\u0264\u0268\u026f\u0275\u0277\u027e\u0283\u028c\u0291" - + "\u0294\u0299\u02a2\u02a9\u02b4\u02bd\u02c7\u02d0\u02d5\u02d8\u02df\u02e9" - + "\u02f1\u02f4\u02f7\u0304\u030c\u0311\u0319\u031d\u0321\u0325\u0327\u032b" - + "\u0331\u033c\u0346\u034b\u0354\u0359\u035c\u0363\u036c\u0383\u0386\u0389" - + "\u0391\u0395\u039d\u03a3\u03ae\u03b7\u03bc\u03c6\u03cd\u03da\u03e3\u03ec" - + "\u03f2\u03fd\u0402\u0407\u040c\u0410\u0414\u0418\u041a\u041e\u0423\u0434" - + "\u043a\u0440\u0446\u0449\u0454\u045c\u046a\u046e\u0473\u0477\u0487\u04af" - + "\u04b5\u04c4\u04c7\u04c9\u04d3\u04dc\u04e0\u04e4\u04f6\u04f8\u04fd\u0502" - + "\u0507\u0510\u0512\u0516\u051b\u051f\u0523\u0527\u0531\u053d\u0544\u0547" - + "\u054b\u0553\u0558\u0563\u0569\u056e\u0573\u057a\u0585\u058e\u0590\u0596" - + "\u059a"; - public static final ATN _ATN = new ATNDeserializer().deserialize(_serializedATN.toCharArray()); - - static { - _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; - for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { - _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); - } } } diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/java/JavaParserBaseListener.java b/lexers/src/main/java/com/itsaky/androidide/lexers/java/JavaParserBaseListener.java index e57e10d43..843d7d7bf 100755 --- a/lexers/src/main/java/com/itsaky/androidide/lexers/java/JavaParserBaseListener.java +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/java/JavaParserBaseListener.java @@ -1,23 +1,4 @@ -/************************************************************************************ - * 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 . - * - **************************************************************************************/ -// Generated from JavaParser.g4 by ANTLR 4.9.2 +// Generated from JavaParser.g4 by ANTLR 4.9.3 package com.itsaky.androidide.lexers.java; import org.antlr.v4.runtime.ParserRuleContext; @@ -1514,20 +1495,6 @@ public class JavaParserBaseListener implements JavaParserListener { @Override public void exitArguments(JavaParser.ArgumentsContext ctx) {} - /** - * {@inheritDoc} - * - *

The default implementation does nothing. - */ - @Override - public void enterEveryRule(ParserRuleContext ctx) {} - /** - * {@inheritDoc} - * - *

The default implementation does nothing. - */ - @Override - public void exitEveryRule(ParserRuleContext ctx) {} /** * {@inheritDoc} * @@ -1535,6 +1502,7 @@ public class JavaParserBaseListener implements JavaParserListener { */ @Override public void visitTerminal(TerminalNode node) {} + /** * {@inheritDoc} * @@ -1542,4 +1510,20 @@ public class JavaParserBaseListener implements JavaParserListener { */ @Override public void visitErrorNode(ErrorNode node) {} + + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterEveryRule(ParserRuleContext ctx) {} + + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitEveryRule(ParserRuleContext ctx) {} } diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/java/JavaParserBaseVisitor.java b/lexers/src/main/java/com/itsaky/androidide/lexers/java/JavaParserBaseVisitor.java index b6d4f4153..420d42790 100755 --- a/lexers/src/main/java/com/itsaky/androidide/lexers/java/JavaParserBaseVisitor.java +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/java/JavaParserBaseVisitor.java @@ -1,23 +1,4 @@ -/************************************************************************************ - * 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 . - * - **************************************************************************************/ -// Generated from JavaParser.g4 by ANTLR 4.9.2 +// Generated from JavaParser.g4 by ANTLR 4.9.3 package com.itsaky.androidide.lexers.java; import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor; diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/java/JavaParserListener.java b/lexers/src/main/java/com/itsaky/androidide/lexers/java/JavaParserListener.java index 7f7df80ea..ac498243d 100755 --- a/lexers/src/main/java/com/itsaky/androidide/lexers/java/JavaParserListener.java +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/java/JavaParserListener.java @@ -1,23 +1,4 @@ -/************************************************************************************ - * 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 . - * - **************************************************************************************/ -// Generated from JavaParser.g4 by ANTLR 4.9.2 +// Generated from JavaParser.g4 by ANTLR 4.9.3 package com.itsaky.androidide.lexers.java; import org.antlr.v4.runtime.tree.ParseTreeListener; diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/java/JavaParserVisitor.java b/lexers/src/main/java/com/itsaky/androidide/lexers/java/JavaParserVisitor.java index 290803d08..08990ac9d 100755 --- a/lexers/src/main/java/com/itsaky/androidide/lexers/java/JavaParserVisitor.java +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/java/JavaParserVisitor.java @@ -1,23 +1,4 @@ -/************************************************************************************ - * 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 . - * - **************************************************************************************/ -// Generated from JavaParser.g4 by ANTLR 4.9.2 +// Generated from JavaParser.g4 by ANTLR 4.9.3 package com.itsaky.androidide.lexers.java; import org.antlr.v4.runtime.tree.ParseTreeVisitor; diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/javadoc/JavadocLexer.java b/lexers/src/main/java/com/itsaky/androidide/lexers/javadoc/JavadocLexer.java index afac476a8..5ca9f11c3 100755 --- a/lexers/src/main/java/com/itsaky/androidide/lexers/javadoc/JavadocLexer.java +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/javadoc/JavadocLexer.java @@ -1,24 +1,5 @@ -/************************************************************************************ - * 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 . - * - **************************************************************************************/ -// Generated from JavadocLexer.g4 by ANTLR 4.9.2 -package com.itsaky.androidide.antlr4.javadoc; +// Generated from JavadocLexer.g4 by ANTLR 4.9.3 +package com.itsaky.androidide.lexers.javadoc; import org.antlr.v4.runtime.CharStream; import org.antlr.v4.runtime.Lexer; @@ -34,12 +15,6 @@ import org.antlr.v4.runtime.dfa.DFA; @SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) public class JavadocLexer extends Lexer { - static { - RuntimeMetaData.checkVersion("4.9.2", RuntimeMetaData.VERSION); - } - - protected static final DFA[] _decisionToDFA; - protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache(); public static final int NAME = 1, NEWLINE = 2, SPACE = 3, @@ -52,144 +27,11 @@ public class JavadocLexer extends Lexer { INLINE_TAG_START = 10, BRACE_OPEN = 11, BRACE_CLOSE = 12; - public static String[] channelNames = {"DEFAULT_TOKEN_CHANNEL", "HIDDEN"}; - - public static String[] modeNames = {"DEFAULT_MODE"}; - - private static String[] makeRuleNames() { - return new String[] { - "NAME", - "NEWLINE", - "SPACE", - "TEXT_CONTENT", - "AT", - "STAR", - "SLASH", - "JAVADOC_START", - "JAVADOC_END", - "INLINE_TAG_START", - "BRACE_OPEN", - "BRACE_CLOSE" - }; - } - public static final String[] ruleNames = makeRuleNames(); - - private static String[] makeLiteralNames() { - return new String[] { - null, null, null, null, null, "'@'", "'*'", "'/'", null, null, "'{@'", "'{'", "'}'" - }; - } - - private static final String[] _LITERAL_NAMES = makeLiteralNames(); - - private static String[] makeSymbolicNames() { - return new String[] { - null, - "NAME", - "NEWLINE", - "SPACE", - "TEXT_CONTENT", - "AT", - "STAR", - "SLASH", - "JAVADOC_START", - "JAVADOC_END", - "INLINE_TAG_START", - "BRACE_OPEN", - "BRACE_CLOSE" - }; - } - - 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 JavadocLexer(CharStream input) { - super(input); - _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache); - } - - @Override - public String getGrammarFileName() { - return "JavadocLexer.g4"; - } - - @Override - public String[] getRuleNames() { - return ruleNames; - } - - @Override - public String getSerializedATN() { - return _serializedATN; - } - - @Override - public String[] getChannelNames() { - return channelNames; - } - - @Override - public String[] getModeNames() { - return modeNames; - } - - @Override - public ATN getATN() { - return _ATN; - } - - @Override - public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { - switch (ruleIndex) { - case 1: - return NEWLINE_sempred((RuleContext) _localctx, predIndex); - } - return true; - } - - private boolean NEWLINE_sempred(RuleContext _localctx, int predIndex) { - switch (predIndex) { - case 0: - return _input.LA(1) != '/'; - case 1: - return _input.LA(1) != '/'; - case 2: - return _input.LA(1) != '/'; - } - return true; - } - public static final String _serializedATN = "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\16x\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" @@ -224,6 +66,31 @@ public class JavadocLexer extends Lexer { + "no\7,\2\2op\7\61\2\2p\24\3\2\2\2qr\7}\2\2rs\7B\2\2s\26\3\2\2\2tu\7}\2" + "\2u\30\3\2\2\2vw\7\177\2\2w\32\3\2\2\2\23\2\36\")+\618:>EGINSbfk\2"; public static final ATN _ATN = new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache(); + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + public static String[] channelNames = {"DEFAULT_TOKEN_CHANNEL", "HIDDEN"}; + public static String[] modeNames = {"DEFAULT_MODE"}; + + static { + RuntimeMetaData.checkVersion("4.9.3", RuntimeMetaData.VERSION); + } + + 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] = ""; + } + } + } static { _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; @@ -231,4 +98,112 @@ public class JavadocLexer extends Lexer { _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); } } + + public JavadocLexer(CharStream input) { + super(input); + _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache); + } + + private static String[] makeRuleNames() { + return new String[] { + "NAME", + "NEWLINE", + "SPACE", + "TEXT_CONTENT", + "AT", + "STAR", + "SLASH", + "JAVADOC_START", + "JAVADOC_END", + "INLINE_TAG_START", + "BRACE_OPEN", + "BRACE_CLOSE" + }; + } + + private static String[] makeLiteralNames() { + return new String[] { + null, null, null, null, null, "'@'", "'*'", "'/'", null, null, "'{@'", "'{'", "'}'" + }; + } + + private static String[] makeSymbolicNames() { + return new String[] { + null, + "NAME", + "NEWLINE", + "SPACE", + "TEXT_CONTENT", + "AT", + "STAR", + "SLASH", + "JAVADOC_START", + "JAVADOC_END", + "INLINE_TAG_START", + "BRACE_OPEN", + "BRACE_CLOSE" + }; + } + + @Override + public String[] getRuleNames() { + return ruleNames; + } + + @Override + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + @Override + public String getSerializedATN() { + return _serializedATN; + } + + @Override + public String getGrammarFileName() { + return "JavadocLexer.g4"; + } + + @Override + public ATN getATN() { + return _ATN; + } + + @Override + public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) { + switch (ruleIndex) { + case 1: + return NEWLINE_sempred((RuleContext) _localctx, predIndex); + } + return true; + } + + private boolean NEWLINE_sempred(RuleContext _localctx, int predIndex) { + switch (predIndex) { + case 0: + return _input.LA(1) != '/'; + case 1: + return _input.LA(1) != '/'; + case 2: + return _input.LA(1) != '/'; + } + return true; + } + + @Override + public String[] getChannelNames() { + return channelNames; + } + + @Override + public String[] getModeNames() { + return modeNames; + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } } diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/javadoc/JavadocParser.java b/lexers/src/main/java/com/itsaky/androidide/lexers/javadoc/JavadocParser.java index 6e1470d37..c4f072a60 100755 --- a/lexers/src/main/java/com/itsaky/androidide/lexers/javadoc/JavadocParser.java +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/javadoc/JavadocParser.java @@ -1,24 +1,5 @@ -/************************************************************************************ - * 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 . - * - **************************************************************************************/ -// Generated from JavadocParser.g4 by ANTLR 4.9.2 -package com.itsaky.androidide.antlr4.javadoc; +// Generated from JavadocParser.g4 by ANTLR 4.9.3 +package com.itsaky.androidide.lexers.javadoc; import org.antlr.v4.runtime.NoViableAltException; import org.antlr.v4.runtime.Parser; @@ -42,12 +23,6 @@ import java.util.List; @SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) public class JavadocParser extends Parser { - static { - RuntimeMetaData.checkVersion("4.9.2", RuntimeMetaData.VERSION); - } - - protected static final DFA[] _decisionToDFA; - protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache(); public static final int NAME = 1, NEWLINE = 2, SPACE = 3, @@ -82,6 +57,129 @@ public class JavadocParser extends Parser { RULE_braceExpression = 19, RULE_braceContent = 20, RULE_braceText = 21; + public static final String[] ruleNames = makeRuleNames(); + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated public static final String[] tokenNames; + public static final String _serializedATN = + "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\16\u00f2\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\3\2\3\2\3\2\7\2\62" + + "\n\2\f\2\16\2\65\13\2\3\2\3\2\3\2\3\2\3\2\7\2<\n\2\f\2\16\2?\13\2\3\2" + + "\3\2\3\2\5\2D\n\2\3\3\3\3\7\3H\n\3\f\3\16\3K\13\3\3\3\7\3N\n\3\f\3\16" + + "\3Q\13\3\3\3\3\3\3\3\6\3V\n\3\r\3\16\3W\3\3\7\3[\n\3\f\3\16\3^\13\3\3" + + "\3\3\3\5\3b\n\3\3\4\3\4\3\5\3\5\6\5h\n\5\r\5\16\5i\3\5\3\5\7\5n\n\5\f" + + "\5\16\5q\13\5\3\6\3\6\7\6u\n\6\f\6\16\6x\13\6\3\6\3\6\7\6|\n\6\f\6\16" + + "\6\177\13\6\5\6\u0081\n\6\3\7\5\7\u0084\n\7\3\7\6\7\u0087\n\7\r\7\16\7" + + "\u0088\3\7\3\7\3\7\7\7\u008e\n\7\f\7\16\7\u0091\13\7\3\b\3\b\3\t\3\t\5" + + "\t\u0097\n\t\3\n\3\n\3\n\6\n\u009c\n\n\r\n\16\n\u009d\3\13\3\13\3\f\6" + + "\f\u00a3\n\f\r\f\16\f\u00a4\3\r\5\r\u00a8\n\r\3\r\3\r\3\r\5\r\u00ad\n" + + "\r\3\r\7\r\u00b0\n\r\f\r\16\r\u00b3\13\r\3\16\3\16\3\17\3\17\3\17\5\17" + + "\u00ba\n\17\3\20\6\20\u00bd\n\20\r\20\16\20\u00be\3\21\3\21\3\22\3\22" + + "\3\22\7\22\u00c6\n\22\f\22\16\22\u00c9\13\22\3\22\5\22\u00cc\n\22\3\22" + + "\3\22\3\23\3\23\3\24\6\24\u00d3\n\24\r\24\16\24\u00d4\3\25\3\25\7\25\u00d9" + + "\n\25\f\25\16\25\u00dc\13\25\3\25\3\25\3\26\3\26\3\26\7\26\u00e3\n\26" + + "\f\26\16\26\u00e6\13\26\3\26\7\26\u00e9\n\26\f\26\16\26\u00ec\13\26\5" + + "\26\u00ee\n\26\3\27\3\27\3\27\2\2\30\2\4\6\b\n\f\16\20\22\24\26\30\32" + + "\34\36 \"$&(*,\2\6\3\2\4\5\6\2\3\3\6\6\b\t\r\16\6\2\3\3\5\6\b\t\r\16\4" + + "\2\3\6\b\t\2\u0101\2C\3\2\2\2\4a\3\2\2\2\6c\3\2\2\2\be\3\2\2\2\n\u0080" + + "\3\2\2\2\f\u0083\3\2\2\2\16\u0092\3\2\2\2\20\u0096\3\2\2\2\22\u009b\3" + + "\2\2\2\24\u009f\3\2\2\2\26\u00a2\3\2\2\2\30\u00a7\3\2\2\2\32\u00b4\3\2" + + "\2\2\34\u00b9\3\2\2\2\36\u00bc\3\2\2\2 \u00c0\3\2\2\2\"\u00c2\3\2\2\2" + + "$\u00cf\3\2\2\2&\u00d2\3\2\2\2(\u00d6\3\2\2\2*\u00ed\3\2\2\2,\u00ef\3" + + "\2\2\2.D\7\2\2\3/\63\7\n\2\2\60\62\5\6\4\2\61\60\3\2\2\2\62\65\3\2\2\2" + + "\63\61\3\2\2\2\63\64\3\2\2\2\64\66\3\2\2\2\65\63\3\2\2\2\66\67\5\4\3\2" + + "\678\7\13\2\289\7\2\2\39D\3\2\2\2:<\5\6\4\2;:\3\2\2\2\3\2\2\2>@\3\2\2\2?=\3\2\2\2@A\5\4\3\2AB\7\2\2\3BD\3\2\2\2C.\3\2" + + "\2\2C/\3\2\2\2C=\3\2\2\2D\3\3\2\2\2EI\5\b\5\2FH\5\6\4\2GF\3\2\2\2HK\3" + + "\2\2\2IG\3\2\2\2IJ\3\2\2\2Jb\3\2\2\2KI\3\2\2\2LN\5\6\4\2ML\3\2\2\2NQ\3" + + "\2\2\2OM\3\2\2\2OP\3\2\2\2PR\3\2\2\2QO\3\2\2\2Rb\5\26\f\2SU\5\b\5\2TV" + + "\7\4\2\2UT\3\2\2\2VW\3\2\2\2WU\3\2\2\2WX\3\2\2\2X\\\3\2\2\2Y[\5\6\4\2" + + "ZY\3\2\2\2[^\3\2\2\2\\Z\3\2\2\2\\]\3\2\2\2]_\3\2\2\2^\\\3\2\2\2_`\5\26" + + "\f\2`b\3\2\2\2aE\3\2\2\2aO\3\2\2\2aS\3\2\2\2b\5\3\2\2\2cd\t\2\2\2d\7\3" + + "\2\2\2eo\5\n\6\2fh\5\24\13\2gf\3\2\2\2hi\3\2\2\2ig\3\2\2\2ij\3\2\2\2j" + + "k\3\2\2\2kl\5\n\6\2ln\3\2\2\2mg\3\2\2\2nq\3\2\2\2om\3\2\2\2op\3\2\2\2" + + "p\t\3\2\2\2qo\3\2\2\2rv\5\f\7\2su\5\20\t\2ts\3\2\2\2ux\3\2\2\2vt\3\2\2" + + "\2vw\3\2\2\2w\u0081\3\2\2\2xv\3\2\2\2y}\5\"\22\2z|\5\20\t\2{z\3\2\2\2" + + "|\177\3\2\2\2}{\3\2\2\2}~\3\2\2\2~\u0081\3\2\2\2\177}\3\2\2\2\u0080r\3" + + "\2\2\2\u0080y\3\2\2\2\u0081\13\3\2\2\2\u0082\u0084\7\5\2\2\u0083\u0082" + + "\3\2\2\2\u0083\u0084\3\2\2\2\u0084\u0086\3\2\2\2\u0085\u0087\5\16\b\2" + + "\u0086\u0085\3\2\2\2\u0087\u0088\3\2\2\2\u0088\u0086\3\2\2\2\u0088\u0089" + + "\3\2\2\2\u0089\u008f\3\2\2\2\u008a\u008e\5\16\b\2\u008b\u008e\7\5\2\2" + + "\u008c\u008e\7\7\2\2\u008d\u008a\3\2\2\2\u008d\u008b\3\2\2\2\u008d\u008c" + + "\3\2\2\2\u008e\u0091\3\2\2\2\u008f\u008d\3\2\2\2\u008f\u0090\3\2\2\2\u0090" + + "\r\3\2\2\2\u0091\u008f\3\2\2\2\u0092\u0093\t\3\2\2\u0093\17\3\2\2\2\u0094" + + "\u0097\5\"\22\2\u0095\u0097\5\22\n\2\u0096\u0094\3\2\2\2\u0096\u0095\3" + + "\2\2\2\u0097\21\3\2\2\2\u0098\u009c\5\16\b\2\u0099\u009c\7\5\2\2\u009a" + + "\u009c\7\7\2\2\u009b\u0098\3\2\2\2\u009b\u0099\3\2\2\2\u009b\u009a\3\2" + + "\2\2\u009c\u009d\3\2\2\2\u009d\u009b\3\2\2\2\u009d\u009e\3\2\2\2\u009e" + + "\23\3\2\2\2\u009f\u00a0\7\4\2\2\u00a0\25\3\2\2\2\u00a1\u00a3\5\30\r\2" + + "\u00a2\u00a1\3\2\2\2\u00a3\u00a4\3\2\2\2\u00a4\u00a2\3\2\2\2\u00a4\u00a5" + + "\3\2\2\2\u00a5\27\3\2\2\2\u00a6\u00a8\7\5\2\2\u00a7\u00a6\3\2\2\2\u00a7" + + "\u00a8\3\2\2\2\u00a8\u00a9\3\2\2\2\u00a9\u00aa\7\7\2\2\u00aa\u00ac\5\32" + + "\16\2\u00ab\u00ad\7\5\2\2\u00ac\u00ab\3\2\2\2\u00ac\u00ad\3\2\2\2\u00ad" + + "\u00b1\3\2\2\2\u00ae\u00b0\5\34\17\2\u00af\u00ae\3\2\2\2\u00b0\u00b3\3" + + "\2\2\2\u00b1\u00af\3\2\2\2\u00b1\u00b2\3\2\2\2\u00b2\31\3\2\2\2\u00b3" + + "\u00b1\3\2\2\2\u00b4\u00b5\7\3\2\2\u00b5\33\3\2\2\2\u00b6\u00ba\5\36\20" + + "\2\u00b7\u00ba\5\"\22\2\u00b8\u00ba\7\4\2\2\u00b9\u00b6\3\2\2\2\u00b9" + + "\u00b7\3\2\2\2\u00b9\u00b8\3\2\2\2\u00ba\35\3\2\2\2\u00bb\u00bd\5 \21" + + "\2\u00bc\u00bb\3\2\2\2\u00bd\u00be\3\2\2\2\u00be\u00bc\3\2\2\2\u00be\u00bf" + + "\3\2\2\2\u00bf\37\3\2\2\2\u00c0\u00c1\t\4\2\2\u00c1!\3\2\2\2\u00c2\u00c3" + + "\7\f\2\2\u00c3\u00c7\5$\23\2\u00c4\u00c6\7\5\2\2\u00c5\u00c4\3\2\2\2\u00c6" + + "\u00c9\3\2\2\2\u00c7\u00c5\3\2\2\2\u00c7\u00c8\3\2\2\2\u00c8\u00cb\3\2" + + "\2\2\u00c9\u00c7\3\2\2\2\u00ca\u00cc\5&\24\2\u00cb\u00ca\3\2\2\2\u00cb" + + "\u00cc\3\2\2\2\u00cc\u00cd\3\2\2\2\u00cd\u00ce\7\16\2\2\u00ce#\3\2\2\2" + + "\u00cf\u00d0\7\3\2\2\u00d0%\3\2\2\2\u00d1\u00d3\5*\26\2\u00d2\u00d1\3" + + "\2\2\2\u00d3\u00d4\3\2\2\2\u00d4\u00d2\3\2\2\2\u00d4\u00d5\3\2\2\2\u00d5" + + "\'\3\2\2\2\u00d6\u00da\7\r\2\2\u00d7\u00d9\5*\26\2\u00d8\u00d7\3\2\2\2" + + "\u00d9\u00dc\3\2\2\2\u00da\u00d8\3\2\2\2\u00da\u00db\3\2\2\2\u00db\u00dd" + + "\3\2\2\2\u00dc\u00da\3\2\2\2\u00dd\u00de\7\16\2\2\u00de)\3\2\2\2\u00df" + + "\u00ee\5(\25\2\u00e0\u00ea\5,\27\2\u00e1\u00e3\7\4\2\2\u00e2\u00e1\3\2" + + "\2\2\u00e3\u00e6\3\2\2\2\u00e4\u00e2\3\2\2\2\u00e4\u00e5\3\2\2\2\u00e5" + + "\u00e7\3\2\2\2\u00e6\u00e4\3\2\2\2\u00e7\u00e9\5,\27\2\u00e8\u00e4\3\2" + + "\2\2\u00e9\u00ec\3\2\2\2\u00ea\u00e8\3\2\2\2\u00ea\u00eb\3\2\2\2\u00eb" + + "\u00ee\3\2\2\2\u00ec\u00ea\3\2\2\2\u00ed\u00df\3\2\2\2\u00ed\u00e0\3\2" + + "\2\2\u00ee+\3\2\2\2\u00ef\u00f0\t\5\2\2\u00f0-\3\2\2\2#\63=CIOW\\aiov" + + "}\u0080\u0083\u0088\u008d\u008f\u0096\u009b\u009d\u00a4\u00a7\u00ac\u00b1" + + "\u00b9\u00be\u00c7\u00cb\u00d4\u00da\u00e4\u00ea\u00ed"; + public static final ATN _ATN = new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache(); + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + + static { + RuntimeMetaData.checkVersion("4.9.3", RuntimeMetaData.VERSION); + } + + 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] = ""; + } + } + } + + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } + + public JavadocParser(TokenStream input) { + super(input); + _interp = new ParserATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache); + } private static String[] makeRuleNames() { return new String[] { @@ -110,16 +208,12 @@ public class JavadocParser extends Parser { }; } - public static final String[] ruleNames = makeRuleNames(); - private static String[] makeLiteralNames() { return new String[] { null, null, null, null, null, "'@'", "'*'", "'/'", null, null, "'{@'", "'{'", "'}'" }; } - private static final String[] _LITERAL_NAMES = makeLiteralNames(); - private static String[] makeSymbolicNames() { return new String[] { null, @@ -138,118 +232,37 @@ public class JavadocParser extends Parser { }; } - 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 "JavadocParser.g4"; - } - @Override public String[] getRuleNames() { return ruleNames; } + @Override + public Vocabulary getVocabulary() { + return VOCABULARY; + } + @Override public String getSerializedATN() { return _serializedATN; } + @Override + public String getGrammarFileName() { + return "JavadocParser.g4"; + } + @Override public ATN getATN() { return _ATN; } - public JavadocParser(TokenStream input) { - super(input); - _interp = new ParserATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache); - } - - public static class DocumentationContext extends ParserRuleContext { - public TerminalNode EOF() { - return getToken(JavadocParser.EOF, 0); - } - - public TerminalNode JAVADOC_START() { - return getToken(JavadocParser.JAVADOC_START, 0); - } - - public DocumentationContentContext documentationContent() { - return getRuleContext(DocumentationContentContext.class, 0); - } - - public TerminalNode JAVADOC_END() { - return getToken(JavadocParser.JAVADOC_END, 0); - } - - public List skipWhitespace() { - return getRuleContexts(SkipWhitespaceContext.class); - } - - public SkipWhitespaceContext skipWhitespace(int i) { - return getRuleContext(SkipWhitespaceContext.class, i); - } - - public DocumentationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_documentation; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).enterDocumentation(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).exitDocumentation(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavadocParserVisitor) - return ((JavadocParserVisitor) visitor).visitDocumentation(this); - else return visitor.visitChildren(this); - } - } - public final DocumentationContext documentation() throws RecognitionException { DocumentationContext _localctx = new DocumentationContext(_ctx, getState()); enterRule(_localctx, 0, RULE_documentation); @@ -341,60 +354,6 @@ public class JavadocParser extends Parser { return _localctx; } - public static class DocumentationContentContext extends ParserRuleContext { - public DescriptionContext description() { - return getRuleContext(DescriptionContext.class, 0); - } - - public List skipWhitespace() { - return getRuleContexts(SkipWhitespaceContext.class); - } - - public SkipWhitespaceContext skipWhitespace(int i) { - return getRuleContext(SkipWhitespaceContext.class, i); - } - - public TagSectionContext tagSection() { - return getRuleContext(TagSectionContext.class, 0); - } - - public List NEWLINE() { - return getTokens(JavadocParser.NEWLINE); - } - - public TerminalNode NEWLINE(int i) { - return getToken(JavadocParser.NEWLINE, i); - } - - public DocumentationContentContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_documentationContent; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).enterDocumentationContent(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).exitDocumentationContent(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavadocParserVisitor) - return ((JavadocParserVisitor) visitor).visitDocumentationContent(this); - else return visitor.visitChildren(this); - } - } - public final DocumentationContentContext documentationContent() throws RecognitionException { DocumentationContentContext _localctx = new DocumentationContentContext(_ctx, getState()); enterRule(_localctx, 2, RULE_documentationContent); @@ -504,44 +463,6 @@ public class JavadocParser extends Parser { return _localctx; } - public static class SkipWhitespaceContext extends ParserRuleContext { - public TerminalNode SPACE() { - return getToken(JavadocParser.SPACE, 0); - } - - public TerminalNode NEWLINE() { - return getToken(JavadocParser.NEWLINE, 0); - } - - public SkipWhitespaceContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_skipWhitespace; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).enterSkipWhitespace(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).exitSkipWhitespace(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavadocParserVisitor) - return ((JavadocParserVisitor) visitor).visitSkipWhitespace(this); - else return visitor.visitChildren(this); - } - } - public final SkipWhitespaceContext skipWhitespace() throws RecognitionException { SkipWhitespaceContext _localctx = new SkipWhitespaceContext(_ctx, getState()); enterRule(_localctx, 4, RULE_skipWhitespace); @@ -569,52 +490,6 @@ public class JavadocParser extends Parser { return _localctx; } - public static class DescriptionContext extends ParserRuleContext { - public List descriptionLine() { - return getRuleContexts(DescriptionLineContext.class); - } - - public DescriptionLineContext descriptionLine(int i) { - return getRuleContext(DescriptionLineContext.class, i); - } - - public List descriptionNewline() { - return getRuleContexts(DescriptionNewlineContext.class); - } - - public DescriptionNewlineContext descriptionNewline(int i) { - return getRuleContext(DescriptionNewlineContext.class, i); - } - - public DescriptionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_description; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).enterDescription(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).exitDescription(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavadocParserVisitor) - return ((JavadocParserVisitor) visitor).visitDescription(this); - else return visitor.visitChildren(this); - } - } - public final DescriptionContext description() throws RecognitionException { DescriptionContext _localctx = new DescriptionContext(_ctx, getState()); enterRule(_localctx, 6, RULE_description); @@ -666,52 +541,6 @@ public class JavadocParser extends Parser { return _localctx; } - public static class DescriptionLineContext extends ParserRuleContext { - public DescriptionLineStartContext descriptionLineStart() { - return getRuleContext(DescriptionLineStartContext.class, 0); - } - - public List descriptionLineElement() { - return getRuleContexts(DescriptionLineElementContext.class); - } - - public DescriptionLineElementContext descriptionLineElement(int i) { - return getRuleContext(DescriptionLineElementContext.class, i); - } - - public InlineTagContext inlineTag() { - return getRuleContext(InlineTagContext.class, 0); - } - - public DescriptionLineContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_descriptionLine; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).enterDescriptionLine(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).exitDescriptionLine(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavadocParserVisitor) - return ((JavadocParserVisitor) visitor).visitDescriptionLine(this); - else return visitor.visitChildren(this); - } - } - public final DescriptionLineContext descriptionLine() throws RecognitionException { DescriptionLineContext _localctx = new DescriptionLineContext(_ctx, getState()); enterRule(_localctx, 8, RULE_descriptionLine); @@ -785,60 +614,6 @@ public class JavadocParser extends Parser { return _localctx; } - public static class DescriptionLineStartContext extends ParserRuleContext { - public List SPACE() { - return getTokens(JavadocParser.SPACE); - } - - public TerminalNode SPACE(int i) { - return getToken(JavadocParser.SPACE, i); - } - - public List descriptionLineNoSpaceNoAt() { - return getRuleContexts(DescriptionLineNoSpaceNoAtContext.class); - } - - public DescriptionLineNoSpaceNoAtContext descriptionLineNoSpaceNoAt(int i) { - return getRuleContext(DescriptionLineNoSpaceNoAtContext.class, i); - } - - public List AT() { - return getTokens(JavadocParser.AT); - } - - public TerminalNode AT(int i) { - return getToken(JavadocParser.AT, i); - } - - public DescriptionLineStartContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_descriptionLineStart; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).enterDescriptionLineStart(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).exitDescriptionLineStart(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavadocParserVisitor) - return ((JavadocParserVisitor) visitor).visitDescriptionLineStart(this); - else return visitor.visitChildren(this); - } - } - public final DescriptionLineStartContext descriptionLineStart() throws RecognitionException { DescriptionLineStartContext _localctx = new DescriptionLineStartContext(_ctx, getState()); enterRule(_localctx, 10, RULE_descriptionLineStart); @@ -929,60 +704,6 @@ public class JavadocParser extends Parser { return _localctx; } - public static class DescriptionLineNoSpaceNoAtContext extends ParserRuleContext { - public TerminalNode TEXT_CONTENT() { - return getToken(JavadocParser.TEXT_CONTENT, 0); - } - - public TerminalNode NAME() { - return getToken(JavadocParser.NAME, 0); - } - - public TerminalNode STAR() { - return getToken(JavadocParser.STAR, 0); - } - - public TerminalNode SLASH() { - return getToken(JavadocParser.SLASH, 0); - } - - public TerminalNode BRACE_OPEN() { - return getToken(JavadocParser.BRACE_OPEN, 0); - } - - public TerminalNode BRACE_CLOSE() { - return getToken(JavadocParser.BRACE_CLOSE, 0); - } - - public DescriptionLineNoSpaceNoAtContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_descriptionLineNoSpaceNoAt; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).enterDescriptionLineNoSpaceNoAt(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).exitDescriptionLineNoSpaceNoAt(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavadocParserVisitor) - return ((JavadocParserVisitor) visitor).visitDescriptionLineNoSpaceNoAt(this); - else return visitor.visitChildren(this); - } - } - public final DescriptionLineNoSpaceNoAtContext descriptionLineNoSpaceNoAt() throws RecognitionException { DescriptionLineNoSpaceNoAtContext _localctx = @@ -1020,44 +741,6 @@ public class JavadocParser extends Parser { return _localctx; } - public static class DescriptionLineElementContext extends ParserRuleContext { - public InlineTagContext inlineTag() { - return getRuleContext(InlineTagContext.class, 0); - } - - public DescriptionLineTextContext descriptionLineText() { - return getRuleContext(DescriptionLineTextContext.class, 0); - } - - public DescriptionLineElementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_descriptionLineElement; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).enterDescriptionLineElement(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).exitDescriptionLineElement(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavadocParserVisitor) - return ((JavadocParserVisitor) visitor).visitDescriptionLineElement(this); - else return visitor.visitChildren(this); - } - } - public final DescriptionLineElementContext descriptionLineElement() throws RecognitionException { DescriptionLineElementContext _localctx = new DescriptionLineElementContext(_ctx, getState()); enterRule(_localctx, 14, RULE_descriptionLineElement); @@ -1099,60 +782,6 @@ public class JavadocParser extends Parser { return _localctx; } - public static class DescriptionLineTextContext extends ParserRuleContext { - public List descriptionLineNoSpaceNoAt() { - return getRuleContexts(DescriptionLineNoSpaceNoAtContext.class); - } - - public DescriptionLineNoSpaceNoAtContext descriptionLineNoSpaceNoAt(int i) { - return getRuleContext(DescriptionLineNoSpaceNoAtContext.class, i); - } - - public List SPACE() { - return getTokens(JavadocParser.SPACE); - } - - public TerminalNode SPACE(int i) { - return getToken(JavadocParser.SPACE, i); - } - - public List AT() { - return getTokens(JavadocParser.AT); - } - - public TerminalNode AT(int i) { - return getToken(JavadocParser.AT, i); - } - - public DescriptionLineTextContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_descriptionLineText; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).enterDescriptionLineText(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).exitDescriptionLineText(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavadocParserVisitor) - return ((JavadocParserVisitor) visitor).visitDescriptionLineText(this); - else return visitor.visitChildren(this); - } - } - public final DescriptionLineTextContext descriptionLineText() throws RecognitionException { DescriptionLineTextContext _localctx = new DescriptionLineTextContext(_ctx, getState()); enterRule(_localctx, 16, RULE_descriptionLineText); @@ -1216,40 +845,6 @@ public class JavadocParser extends Parser { return _localctx; } - public static class DescriptionNewlineContext extends ParserRuleContext { - public TerminalNode NEWLINE() { - return getToken(JavadocParser.NEWLINE, 0); - } - - public DescriptionNewlineContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_descriptionNewline; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).enterDescriptionNewline(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).exitDescriptionNewline(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavadocParserVisitor) - return ((JavadocParserVisitor) visitor).visitDescriptionNewline(this); - else return visitor.visitChildren(this); - } - } - public final DescriptionNewlineContext descriptionNewline() throws RecognitionException { DescriptionNewlineContext _localctx = new DescriptionNewlineContext(_ctx, getState()); enterRule(_localctx, 18, RULE_descriptionNewline); @@ -1269,44 +864,6 @@ public class JavadocParser extends Parser { return _localctx; } - public static class TagSectionContext extends ParserRuleContext { - public List blockTag() { - return getRuleContexts(BlockTagContext.class); - } - - public BlockTagContext blockTag(int i) { - return getRuleContext(BlockTagContext.class, i); - } - - public TagSectionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_tagSection; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).enterTagSection(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).exitTagSection(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavadocParserVisitor) - return ((JavadocParserVisitor) visitor).visitTagSection(this); - else return visitor.visitChildren(this); - } - } - public final TagSectionContext tagSection() throws RecognitionException { TagSectionContext _localctx = new TagSectionContext(_ctx, getState()); enterRule(_localctx, 20, RULE_tagSection); @@ -1339,60 +896,6 @@ public class JavadocParser extends Parser { return _localctx; } - public static class BlockTagContext extends ParserRuleContext { - public TerminalNode AT() { - return getToken(JavadocParser.AT, 0); - } - - public BlockTagNameContext blockTagName() { - return getRuleContext(BlockTagNameContext.class, 0); - } - - public List SPACE() { - return getTokens(JavadocParser.SPACE); - } - - public TerminalNode SPACE(int i) { - return getToken(JavadocParser.SPACE, i); - } - - public List blockTagContent() { - return getRuleContexts(BlockTagContentContext.class); - } - - public BlockTagContentContext blockTagContent(int i) { - return getRuleContext(BlockTagContentContext.class, i); - } - - public BlockTagContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_blockTag; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).enterBlockTag(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).exitBlockTag(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavadocParserVisitor) - return ((JavadocParserVisitor) visitor).visitBlockTag(this); - else return visitor.visitChildren(this); - } - } - public final BlockTagContext blockTag() throws RecognitionException { BlockTagContext _localctx = new BlockTagContext(_ctx, getState()); enterRule(_localctx, 22, RULE_blockTag); @@ -1452,40 +955,6 @@ public class JavadocParser extends Parser { return _localctx; } - public static class BlockTagNameContext extends ParserRuleContext { - public TerminalNode NAME() { - return getToken(JavadocParser.NAME, 0); - } - - public BlockTagNameContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_blockTagName; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).enterBlockTagName(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).exitBlockTagName(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavadocParserVisitor) - return ((JavadocParserVisitor) visitor).visitBlockTagName(this); - else return visitor.visitChildren(this); - } - } - public final BlockTagNameContext blockTagName() throws RecognitionException { BlockTagNameContext _localctx = new BlockTagNameContext(_ctx, getState()); enterRule(_localctx, 24, RULE_blockTagName); @@ -1505,48 +974,6 @@ public class JavadocParser extends Parser { return _localctx; } - public static class BlockTagContentContext extends ParserRuleContext { - public BlockTagTextContext blockTagText() { - return getRuleContext(BlockTagTextContext.class, 0); - } - - public InlineTagContext inlineTag() { - return getRuleContext(InlineTagContext.class, 0); - } - - public TerminalNode NEWLINE() { - return getToken(JavadocParser.NEWLINE, 0); - } - - public BlockTagContentContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_blockTagContent; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).enterBlockTagContent(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).exitBlockTagContent(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavadocParserVisitor) - return ((JavadocParserVisitor) visitor).visitBlockTagContent(this); - else return visitor.visitChildren(this); - } - } - public final BlockTagContentContext blockTagContent() throws RecognitionException { BlockTagContentContext _localctx = new BlockTagContentContext(_ctx, getState()); enterRule(_localctx, 26, RULE_blockTagContent); @@ -1594,44 +1021,6 @@ public class JavadocParser extends Parser { return _localctx; } - public static class BlockTagTextContext extends ParserRuleContext { - public List blockTagTextElement() { - return getRuleContexts(BlockTagTextElementContext.class); - } - - public BlockTagTextElementContext blockTagTextElement(int i) { - return getRuleContext(BlockTagTextElementContext.class, i); - } - - public BlockTagTextContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_blockTagText; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).enterBlockTagText(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).exitBlockTagText(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavadocParserVisitor) - return ((JavadocParserVisitor) visitor).visitBlockTagText(this); - else return visitor.visitChildren(this); - } - } - public final BlockTagTextContext blockTagText() throws RecognitionException { BlockTagTextContext _localctx = new BlockTagTextContext(_ctx, getState()); enterRule(_localctx, 28, RULE_blockTagText); @@ -1670,64 +1059,6 @@ public class JavadocParser extends Parser { return _localctx; } - public static class BlockTagTextElementContext extends ParserRuleContext { - public TerminalNode TEXT_CONTENT() { - return getToken(JavadocParser.TEXT_CONTENT, 0); - } - - public TerminalNode NAME() { - return getToken(JavadocParser.NAME, 0); - } - - public TerminalNode SPACE() { - return getToken(JavadocParser.SPACE, 0); - } - - public TerminalNode STAR() { - return getToken(JavadocParser.STAR, 0); - } - - public TerminalNode SLASH() { - return getToken(JavadocParser.SLASH, 0); - } - - public TerminalNode BRACE_OPEN() { - return getToken(JavadocParser.BRACE_OPEN, 0); - } - - public TerminalNode BRACE_CLOSE() { - return getToken(JavadocParser.BRACE_CLOSE, 0); - } - - public BlockTagTextElementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_blockTagTextElement; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).enterBlockTagTextElement(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).exitBlockTagTextElement(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavadocParserVisitor) - return ((JavadocParserVisitor) visitor).visitBlockTagTextElement(this); - else return visitor.visitChildren(this); - } - } - public final BlockTagTextElementContext blockTagTextElement() throws RecognitionException { BlockTagTextElementContext _localctx = new BlockTagTextElementContext(_ctx, getState()); enterRule(_localctx, 30, RULE_blockTagTextElement); @@ -1764,60 +1095,6 @@ public class JavadocParser extends Parser { return _localctx; } - public static class InlineTagContext extends ParserRuleContext { - public TerminalNode INLINE_TAG_START() { - return getToken(JavadocParser.INLINE_TAG_START, 0); - } - - public InlineTagNameContext inlineTagName() { - return getRuleContext(InlineTagNameContext.class, 0); - } - - public TerminalNode BRACE_CLOSE() { - return getToken(JavadocParser.BRACE_CLOSE, 0); - } - - public List SPACE() { - return getTokens(JavadocParser.SPACE); - } - - public TerminalNode SPACE(int i) { - return getToken(JavadocParser.SPACE, i); - } - - public InlineTagContentContext inlineTagContent() { - return getRuleContext(InlineTagContentContext.class, 0); - } - - public InlineTagContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_inlineTag; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).enterInlineTag(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).exitInlineTag(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavadocParserVisitor) - return ((JavadocParserVisitor) visitor).visitInlineTag(this); - else return visitor.visitChildren(this); - } - } - public final InlineTagContext inlineTag() throws RecognitionException { InlineTagContext _localctx = new InlineTagContext(_ctx, getState()); enterRule(_localctx, 32, RULE_inlineTag); @@ -1878,40 +1155,6 @@ public class JavadocParser extends Parser { return _localctx; } - public static class InlineTagNameContext extends ParserRuleContext { - public TerminalNode NAME() { - return getToken(JavadocParser.NAME, 0); - } - - public InlineTagNameContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_inlineTagName; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).enterInlineTagName(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).exitInlineTagName(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavadocParserVisitor) - return ((JavadocParserVisitor) visitor).visitInlineTagName(this); - else return visitor.visitChildren(this); - } - } - public final InlineTagNameContext inlineTagName() throws RecognitionException { InlineTagNameContext _localctx = new InlineTagNameContext(_ctx, getState()); enterRule(_localctx, 34, RULE_inlineTagName); @@ -1931,44 +1174,6 @@ public class JavadocParser extends Parser { return _localctx; } - public static class InlineTagContentContext extends ParserRuleContext { - public List braceContent() { - return getRuleContexts(BraceContentContext.class); - } - - public BraceContentContext braceContent(int i) { - return getRuleContext(BraceContentContext.class, i); - } - - public InlineTagContentContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_inlineTagContent; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).enterInlineTagContent(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).exitInlineTagContent(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavadocParserVisitor) - return ((JavadocParserVisitor) visitor).visitInlineTagContent(this); - else return visitor.visitChildren(this); - } - } - public final InlineTagContentContext inlineTagContent() throws RecognitionException { InlineTagContentContext _localctx = new InlineTagContentContext(_ctx, getState()); enterRule(_localctx, 36, RULE_inlineTagContent); @@ -2010,52 +1215,6 @@ public class JavadocParser extends Parser { return _localctx; } - public static class BraceExpressionContext extends ParserRuleContext { - public TerminalNode BRACE_OPEN() { - return getToken(JavadocParser.BRACE_OPEN, 0); - } - - public TerminalNode BRACE_CLOSE() { - return getToken(JavadocParser.BRACE_CLOSE, 0); - } - - public List braceContent() { - return getRuleContexts(BraceContentContext.class); - } - - public BraceContentContext braceContent(int i) { - return getRuleContext(BraceContentContext.class, i); - } - - public BraceExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_braceExpression; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).enterBraceExpression(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).exitBraceExpression(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavadocParserVisitor) - return ((JavadocParserVisitor) visitor).visitBraceExpression(this); - else return visitor.visitChildren(this); - } - } - public final BraceExpressionContext braceExpression() throws RecognitionException { BraceExpressionContext _localctx = new BraceExpressionContext(_ctx, getState()); enterRule(_localctx, 38, RULE_braceExpression); @@ -2101,56 +1260,6 @@ public class JavadocParser extends Parser { return _localctx; } - public static class BraceContentContext extends ParserRuleContext { - public BraceExpressionContext braceExpression() { - return getRuleContext(BraceExpressionContext.class, 0); - } - - public List braceText() { - return getRuleContexts(BraceTextContext.class); - } - - public BraceTextContext braceText(int i) { - return getRuleContext(BraceTextContext.class, i); - } - - public List NEWLINE() { - return getTokens(JavadocParser.NEWLINE); - } - - public TerminalNode NEWLINE(int i) { - return getToken(JavadocParser.NEWLINE, i); - } - - public BraceContentContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_braceContent; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).enterBraceContent(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).exitBraceContent(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavadocParserVisitor) - return ((JavadocParserVisitor) visitor).visitBraceContent(this); - else return visitor.visitChildren(this); - } - } - public final BraceContentContext braceContent() throws RecognitionException { BraceContentContext _localctx = new BraceContentContext(_ctx, getState()); enterRule(_localctx, 40, RULE_braceContent); @@ -2223,60 +1332,6 @@ public class JavadocParser extends Parser { return _localctx; } - public static class BraceTextContext extends ParserRuleContext { - public TerminalNode TEXT_CONTENT() { - return getToken(JavadocParser.TEXT_CONTENT, 0); - } - - public TerminalNode NAME() { - return getToken(JavadocParser.NAME, 0); - } - - public TerminalNode SPACE() { - return getToken(JavadocParser.SPACE, 0); - } - - public TerminalNode STAR() { - return getToken(JavadocParser.STAR, 0); - } - - public TerminalNode SLASH() { - return getToken(JavadocParser.SLASH, 0); - } - - public TerminalNode NEWLINE() { - return getToken(JavadocParser.NEWLINE, 0); - } - - public BraceTextContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_braceText; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).enterBraceText(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof JavadocParserListener) - ((JavadocParserListener) listener).exitBraceText(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof JavadocParserVisitor) - return ((JavadocParserVisitor) visitor).visitBraceText(this); - else return visitor.visitChildren(this); - } - } - public final BraceTextContext braceText() throws RecognitionException { BraceTextContext _localctx = new BraceTextContext(_ctx, getState()); enterRule(_localctx, 42, RULE_braceText); @@ -2312,94 +1367,1015 @@ public class JavadocParser extends Parser { return _localctx; } - public static final String _serializedATN = - "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\16\u00f2\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\3\2\3\2\3\2\7\2\62" - + "\n\2\f\2\16\2\65\13\2\3\2\3\2\3\2\3\2\3\2\7\2<\n\2\f\2\16\2?\13\2\3\2" - + "\3\2\3\2\5\2D\n\2\3\3\3\3\7\3H\n\3\f\3\16\3K\13\3\3\3\7\3N\n\3\f\3\16" - + "\3Q\13\3\3\3\3\3\3\3\6\3V\n\3\r\3\16\3W\3\3\7\3[\n\3\f\3\16\3^\13\3\3" - + "\3\3\3\5\3b\n\3\3\4\3\4\3\5\3\5\6\5h\n\5\r\5\16\5i\3\5\3\5\7\5n\n\5\f" - + "\5\16\5q\13\5\3\6\3\6\7\6u\n\6\f\6\16\6x\13\6\3\6\3\6\7\6|\n\6\f\6\16" - + "\6\177\13\6\5\6\u0081\n\6\3\7\5\7\u0084\n\7\3\7\6\7\u0087\n\7\r\7\16\7" - + "\u0088\3\7\3\7\3\7\7\7\u008e\n\7\f\7\16\7\u0091\13\7\3\b\3\b\3\t\3\t\5" - + "\t\u0097\n\t\3\n\3\n\3\n\6\n\u009c\n\n\r\n\16\n\u009d\3\13\3\13\3\f\6" - + "\f\u00a3\n\f\r\f\16\f\u00a4\3\r\5\r\u00a8\n\r\3\r\3\r\3\r\5\r\u00ad\n" - + "\r\3\r\7\r\u00b0\n\r\f\r\16\r\u00b3\13\r\3\16\3\16\3\17\3\17\3\17\5\17" - + "\u00ba\n\17\3\20\6\20\u00bd\n\20\r\20\16\20\u00be\3\21\3\21\3\22\3\22" - + "\3\22\7\22\u00c6\n\22\f\22\16\22\u00c9\13\22\3\22\5\22\u00cc\n\22\3\22" - + "\3\22\3\23\3\23\3\24\6\24\u00d3\n\24\r\24\16\24\u00d4\3\25\3\25\7\25\u00d9" - + "\n\25\f\25\16\25\u00dc\13\25\3\25\3\25\3\26\3\26\3\26\7\26\u00e3\n\26" - + "\f\26\16\26\u00e6\13\26\3\26\7\26\u00e9\n\26\f\26\16\26\u00ec\13\26\5" - + "\26\u00ee\n\26\3\27\3\27\3\27\2\2\30\2\4\6\b\n\f\16\20\22\24\26\30\32" - + "\34\36 \"$&(*,\2\6\3\2\4\5\6\2\3\3\6\6\b\t\r\16\6\2\3\3\5\6\b\t\r\16\4" - + "\2\3\6\b\t\2\u0101\2C\3\2\2\2\4a\3\2\2\2\6c\3\2\2\2\be\3\2\2\2\n\u0080" - + "\3\2\2\2\f\u0083\3\2\2\2\16\u0092\3\2\2\2\20\u0096\3\2\2\2\22\u009b\3" - + "\2\2\2\24\u009f\3\2\2\2\26\u00a2\3\2\2\2\30\u00a7\3\2\2\2\32\u00b4\3\2" - + "\2\2\34\u00b9\3\2\2\2\36\u00bc\3\2\2\2 \u00c0\3\2\2\2\"\u00c2\3\2\2\2" - + "$\u00cf\3\2\2\2&\u00d2\3\2\2\2(\u00d6\3\2\2\2*\u00ed\3\2\2\2,\u00ef\3" - + "\2\2\2.D\7\2\2\3/\63\7\n\2\2\60\62\5\6\4\2\61\60\3\2\2\2\62\65\3\2\2\2" - + "\63\61\3\2\2\2\63\64\3\2\2\2\64\66\3\2\2\2\65\63\3\2\2\2\66\67\5\4\3\2" - + "\678\7\13\2\289\7\2\2\39D\3\2\2\2:<\5\6\4\2;:\3\2\2\2\3\2\2\2>@\3\2\2\2?=\3\2\2\2@A\5\4\3\2AB\7\2\2\3BD\3\2\2\2C.\3\2" - + "\2\2C/\3\2\2\2C=\3\2\2\2D\3\3\2\2\2EI\5\b\5\2FH\5\6\4\2GF\3\2\2\2HK\3" - + "\2\2\2IG\3\2\2\2IJ\3\2\2\2Jb\3\2\2\2KI\3\2\2\2LN\5\6\4\2ML\3\2\2\2NQ\3" - + "\2\2\2OM\3\2\2\2OP\3\2\2\2PR\3\2\2\2QO\3\2\2\2Rb\5\26\f\2SU\5\b\5\2TV" - + "\7\4\2\2UT\3\2\2\2VW\3\2\2\2WU\3\2\2\2WX\3\2\2\2X\\\3\2\2\2Y[\5\6\4\2" - + "ZY\3\2\2\2[^\3\2\2\2\\Z\3\2\2\2\\]\3\2\2\2]_\3\2\2\2^\\\3\2\2\2_`\5\26" - + "\f\2`b\3\2\2\2aE\3\2\2\2aO\3\2\2\2aS\3\2\2\2b\5\3\2\2\2cd\t\2\2\2d\7\3" - + "\2\2\2eo\5\n\6\2fh\5\24\13\2gf\3\2\2\2hi\3\2\2\2ig\3\2\2\2ij\3\2\2\2j" - + "k\3\2\2\2kl\5\n\6\2ln\3\2\2\2mg\3\2\2\2nq\3\2\2\2om\3\2\2\2op\3\2\2\2" - + "p\t\3\2\2\2qo\3\2\2\2rv\5\f\7\2su\5\20\t\2ts\3\2\2\2ux\3\2\2\2vt\3\2\2" - + "\2vw\3\2\2\2w\u0081\3\2\2\2xv\3\2\2\2y}\5\"\22\2z|\5\20\t\2{z\3\2\2\2" - + "|\177\3\2\2\2}{\3\2\2\2}~\3\2\2\2~\u0081\3\2\2\2\177}\3\2\2\2\u0080r\3" - + "\2\2\2\u0080y\3\2\2\2\u0081\13\3\2\2\2\u0082\u0084\7\5\2\2\u0083\u0082" - + "\3\2\2\2\u0083\u0084\3\2\2\2\u0084\u0086\3\2\2\2\u0085\u0087\5\16\b\2" - + "\u0086\u0085\3\2\2\2\u0087\u0088\3\2\2\2\u0088\u0086\3\2\2\2\u0088\u0089" - + "\3\2\2\2\u0089\u008f\3\2\2\2\u008a\u008e\5\16\b\2\u008b\u008e\7\5\2\2" - + "\u008c\u008e\7\7\2\2\u008d\u008a\3\2\2\2\u008d\u008b\3\2\2\2\u008d\u008c" - + "\3\2\2\2\u008e\u0091\3\2\2\2\u008f\u008d\3\2\2\2\u008f\u0090\3\2\2\2\u0090" - + "\r\3\2\2\2\u0091\u008f\3\2\2\2\u0092\u0093\t\3\2\2\u0093\17\3\2\2\2\u0094" - + "\u0097\5\"\22\2\u0095\u0097\5\22\n\2\u0096\u0094\3\2\2\2\u0096\u0095\3" - + "\2\2\2\u0097\21\3\2\2\2\u0098\u009c\5\16\b\2\u0099\u009c\7\5\2\2\u009a" - + "\u009c\7\7\2\2\u009b\u0098\3\2\2\2\u009b\u0099\3\2\2\2\u009b\u009a\3\2" - + "\2\2\u009c\u009d\3\2\2\2\u009d\u009b\3\2\2\2\u009d\u009e\3\2\2\2\u009e" - + "\23\3\2\2\2\u009f\u00a0\7\4\2\2\u00a0\25\3\2\2\2\u00a1\u00a3\5\30\r\2" - + "\u00a2\u00a1\3\2\2\2\u00a3\u00a4\3\2\2\2\u00a4\u00a2\3\2\2\2\u00a4\u00a5" - + "\3\2\2\2\u00a5\27\3\2\2\2\u00a6\u00a8\7\5\2\2\u00a7\u00a6\3\2\2\2\u00a7" - + "\u00a8\3\2\2\2\u00a8\u00a9\3\2\2\2\u00a9\u00aa\7\7\2\2\u00aa\u00ac\5\32" - + "\16\2\u00ab\u00ad\7\5\2\2\u00ac\u00ab\3\2\2\2\u00ac\u00ad\3\2\2\2\u00ad" - + "\u00b1\3\2\2\2\u00ae\u00b0\5\34\17\2\u00af\u00ae\3\2\2\2\u00b0\u00b3\3" - + "\2\2\2\u00b1\u00af\3\2\2\2\u00b1\u00b2\3\2\2\2\u00b2\31\3\2\2\2\u00b3" - + "\u00b1\3\2\2\2\u00b4\u00b5\7\3\2\2\u00b5\33\3\2\2\2\u00b6\u00ba\5\36\20" - + "\2\u00b7\u00ba\5\"\22\2\u00b8\u00ba\7\4\2\2\u00b9\u00b6\3\2\2\2\u00b9" - + "\u00b7\3\2\2\2\u00b9\u00b8\3\2\2\2\u00ba\35\3\2\2\2\u00bb\u00bd\5 \21" - + "\2\u00bc\u00bb\3\2\2\2\u00bd\u00be\3\2\2\2\u00be\u00bc\3\2\2\2\u00be\u00bf" - + "\3\2\2\2\u00bf\37\3\2\2\2\u00c0\u00c1\t\4\2\2\u00c1!\3\2\2\2\u00c2\u00c3" - + "\7\f\2\2\u00c3\u00c7\5$\23\2\u00c4\u00c6\7\5\2\2\u00c5\u00c4\3\2\2\2\u00c6" - + "\u00c9\3\2\2\2\u00c7\u00c5\3\2\2\2\u00c7\u00c8\3\2\2\2\u00c8\u00cb\3\2" - + "\2\2\u00c9\u00c7\3\2\2\2\u00ca\u00cc\5&\24\2\u00cb\u00ca\3\2\2\2\u00cb" - + "\u00cc\3\2\2\2\u00cc\u00cd\3\2\2\2\u00cd\u00ce\7\16\2\2\u00ce#\3\2\2\2" - + "\u00cf\u00d0\7\3\2\2\u00d0%\3\2\2\2\u00d1\u00d3\5*\26\2\u00d2\u00d1\3" - + "\2\2\2\u00d3\u00d4\3\2\2\2\u00d4\u00d2\3\2\2\2\u00d4\u00d5\3\2\2\2\u00d5" - + "\'\3\2\2\2\u00d6\u00da\7\r\2\2\u00d7\u00d9\5*\26\2\u00d8\u00d7\3\2\2\2" - + "\u00d9\u00dc\3\2\2\2\u00da\u00d8\3\2\2\2\u00da\u00db\3\2\2\2\u00db\u00dd" - + "\3\2\2\2\u00dc\u00da\3\2\2\2\u00dd\u00de\7\16\2\2\u00de)\3\2\2\2\u00df" - + "\u00ee\5(\25\2\u00e0\u00ea\5,\27\2\u00e1\u00e3\7\4\2\2\u00e2\u00e1\3\2" - + "\2\2\u00e3\u00e6\3\2\2\2\u00e4\u00e2\3\2\2\2\u00e4\u00e5\3\2\2\2\u00e5" - + "\u00e7\3\2\2\2\u00e6\u00e4\3\2\2\2\u00e7\u00e9\5,\27\2\u00e8\u00e4\3\2" - + "\2\2\u00e9\u00ec\3\2\2\2\u00ea\u00e8\3\2\2\2\u00ea\u00eb\3\2\2\2\u00eb" - + "\u00ee\3\2\2\2\u00ec\u00ea\3\2\2\2\u00ed\u00df\3\2\2\2\u00ed\u00e0\3\2" - + "\2\2\u00ee+\3\2\2\2\u00ef\u00f0\t\5\2\2\u00f0-\3\2\2\2#\63=CIOW\\aiov" - + "}\u0080\u0083\u0088\u008d\u008f\u0096\u009b\u009d\u00a4\u00a7\u00ac\u00b1" - + "\u00b9\u00be\u00c7\u00cb\u00d4\u00da\u00e4\u00ea\u00ed"; - public static final ATN _ATN = new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + public static class DocumentationContext extends ParserRuleContext { + public DocumentationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } - static { - _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; - for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { - _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + public TerminalNode EOF() { + return getToken(JavadocParser.EOF, 0); + } + + public TerminalNode JAVADOC_START() { + return getToken(JavadocParser.JAVADOC_START, 0); + } + + public DocumentationContentContext documentationContent() { + return getRuleContext(DocumentationContentContext.class, 0); + } + + public TerminalNode JAVADOC_END() { + return getToken(JavadocParser.JAVADOC_END, 0); + } + + public List skipWhitespace() { + return getRuleContexts(SkipWhitespaceContext.class); + } + + public SkipWhitespaceContext skipWhitespace(int i) { + return getRuleContext(SkipWhitespaceContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_documentation; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavadocParserVisitor) + return ((JavadocParserVisitor) visitor).visitDocumentation(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).enterDocumentation(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).exitDocumentation(this); + } + } + + public static class DocumentationContentContext extends ParserRuleContext { + public DocumentationContentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public DescriptionContext description() { + return getRuleContext(DescriptionContext.class, 0); + } + + public List skipWhitespace() { + return getRuleContexts(SkipWhitespaceContext.class); + } + + public SkipWhitespaceContext skipWhitespace(int i) { + return getRuleContext(SkipWhitespaceContext.class, i); + } + + public TagSectionContext tagSection() { + return getRuleContext(TagSectionContext.class, 0); + } + + public List NEWLINE() { + return getTokens(JavadocParser.NEWLINE); + } + + public TerminalNode NEWLINE(int i) { + return getToken(JavadocParser.NEWLINE, i); + } + + @Override + public int getRuleIndex() { + return RULE_documentationContent; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavadocParserVisitor) + return ((JavadocParserVisitor) visitor).visitDocumentationContent(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).enterDocumentationContent(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).exitDocumentationContent(this); + } + } + + public static class SkipWhitespaceContext extends ParserRuleContext { + public SkipWhitespaceContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode SPACE() { + return getToken(JavadocParser.SPACE, 0); + } + + public TerminalNode NEWLINE() { + return getToken(JavadocParser.NEWLINE, 0); + } + + @Override + public int getRuleIndex() { + return RULE_skipWhitespace; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavadocParserVisitor) + return ((JavadocParserVisitor) visitor).visitSkipWhitespace(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).enterSkipWhitespace(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).exitSkipWhitespace(this); + } + } + + public static class DescriptionContext extends ParserRuleContext { + public DescriptionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List descriptionLine() { + return getRuleContexts(DescriptionLineContext.class); + } + + public DescriptionLineContext descriptionLine(int i) { + return getRuleContext(DescriptionLineContext.class, i); + } + + public List descriptionNewline() { + return getRuleContexts(DescriptionNewlineContext.class); + } + + public DescriptionNewlineContext descriptionNewline(int i) { + return getRuleContext(DescriptionNewlineContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_description; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavadocParserVisitor) + return ((JavadocParserVisitor) visitor).visitDescription(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).enterDescription(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).exitDescription(this); + } + } + + public static class DescriptionLineContext extends ParserRuleContext { + public DescriptionLineContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public DescriptionLineStartContext descriptionLineStart() { + return getRuleContext(DescriptionLineStartContext.class, 0); + } + + public List descriptionLineElement() { + return getRuleContexts(DescriptionLineElementContext.class); + } + + public DescriptionLineElementContext descriptionLineElement(int i) { + return getRuleContext(DescriptionLineElementContext.class, i); + } + + public InlineTagContext inlineTag() { + return getRuleContext(InlineTagContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_descriptionLine; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavadocParserVisitor) + return ((JavadocParserVisitor) visitor).visitDescriptionLine(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).enterDescriptionLine(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).exitDescriptionLine(this); + } + } + + public static class DescriptionLineStartContext extends ParserRuleContext { + public DescriptionLineStartContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List SPACE() { + return getTokens(JavadocParser.SPACE); + } + + public TerminalNode SPACE(int i) { + return getToken(JavadocParser.SPACE, i); + } + + public List descriptionLineNoSpaceNoAt() { + return getRuleContexts(DescriptionLineNoSpaceNoAtContext.class); + } + + public DescriptionLineNoSpaceNoAtContext descriptionLineNoSpaceNoAt(int i) { + return getRuleContext(DescriptionLineNoSpaceNoAtContext.class, i); + } + + public List AT() { + return getTokens(JavadocParser.AT); + } + + public TerminalNode AT(int i) { + return getToken(JavadocParser.AT, i); + } + + @Override + public int getRuleIndex() { + return RULE_descriptionLineStart; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavadocParserVisitor) + return ((JavadocParserVisitor) visitor).visitDescriptionLineStart(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).enterDescriptionLineStart(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).exitDescriptionLineStart(this); + } + } + + public static class DescriptionLineNoSpaceNoAtContext extends ParserRuleContext { + public DescriptionLineNoSpaceNoAtContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode TEXT_CONTENT() { + return getToken(JavadocParser.TEXT_CONTENT, 0); + } + + public TerminalNode NAME() { + return getToken(JavadocParser.NAME, 0); + } + + public TerminalNode STAR() { + return getToken(JavadocParser.STAR, 0); + } + + public TerminalNode SLASH() { + return getToken(JavadocParser.SLASH, 0); + } + + public TerminalNode BRACE_OPEN() { + return getToken(JavadocParser.BRACE_OPEN, 0); + } + + public TerminalNode BRACE_CLOSE() { + return getToken(JavadocParser.BRACE_CLOSE, 0); + } + + @Override + public int getRuleIndex() { + return RULE_descriptionLineNoSpaceNoAt; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavadocParserVisitor) + return ((JavadocParserVisitor) visitor).visitDescriptionLineNoSpaceNoAt(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).enterDescriptionLineNoSpaceNoAt(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).exitDescriptionLineNoSpaceNoAt(this); + } + } + + public static class DescriptionLineElementContext extends ParserRuleContext { + public DescriptionLineElementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public InlineTagContext inlineTag() { + return getRuleContext(InlineTagContext.class, 0); + } + + public DescriptionLineTextContext descriptionLineText() { + return getRuleContext(DescriptionLineTextContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_descriptionLineElement; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavadocParserVisitor) + return ((JavadocParserVisitor) visitor).visitDescriptionLineElement(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).enterDescriptionLineElement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).exitDescriptionLineElement(this); + } + } + + public static class DescriptionLineTextContext extends ParserRuleContext { + public DescriptionLineTextContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List descriptionLineNoSpaceNoAt() { + return getRuleContexts(DescriptionLineNoSpaceNoAtContext.class); + } + + public DescriptionLineNoSpaceNoAtContext descriptionLineNoSpaceNoAt(int i) { + return getRuleContext(DescriptionLineNoSpaceNoAtContext.class, i); + } + + public List SPACE() { + return getTokens(JavadocParser.SPACE); + } + + public TerminalNode SPACE(int i) { + return getToken(JavadocParser.SPACE, i); + } + + public List AT() { + return getTokens(JavadocParser.AT); + } + + public TerminalNode AT(int i) { + return getToken(JavadocParser.AT, i); + } + + @Override + public int getRuleIndex() { + return RULE_descriptionLineText; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavadocParserVisitor) + return ((JavadocParserVisitor) visitor).visitDescriptionLineText(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).enterDescriptionLineText(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).exitDescriptionLineText(this); + } + } + + public static class DescriptionNewlineContext extends ParserRuleContext { + public DescriptionNewlineContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode NEWLINE() { + return getToken(JavadocParser.NEWLINE, 0); + } + + @Override + public int getRuleIndex() { + return RULE_descriptionNewline; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavadocParserVisitor) + return ((JavadocParserVisitor) visitor).visitDescriptionNewline(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).enterDescriptionNewline(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).exitDescriptionNewline(this); + } + } + + public static class TagSectionContext extends ParserRuleContext { + public TagSectionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List blockTag() { + return getRuleContexts(BlockTagContext.class); + } + + public BlockTagContext blockTag(int i) { + return getRuleContext(BlockTagContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_tagSection; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavadocParserVisitor) + return ((JavadocParserVisitor) visitor).visitTagSection(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).enterTagSection(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).exitTagSection(this); + } + } + + public static class BlockTagContext extends ParserRuleContext { + public BlockTagContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode AT() { + return getToken(JavadocParser.AT, 0); + } + + public BlockTagNameContext blockTagName() { + return getRuleContext(BlockTagNameContext.class, 0); + } + + public List SPACE() { + return getTokens(JavadocParser.SPACE); + } + + public TerminalNode SPACE(int i) { + return getToken(JavadocParser.SPACE, i); + } + + public List blockTagContent() { + return getRuleContexts(BlockTagContentContext.class); + } + + public BlockTagContentContext blockTagContent(int i) { + return getRuleContext(BlockTagContentContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_blockTag; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavadocParserVisitor) + return ((JavadocParserVisitor) visitor).visitBlockTag(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).enterBlockTag(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).exitBlockTag(this); + } + } + + public static class BlockTagNameContext extends ParserRuleContext { + public BlockTagNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode NAME() { + return getToken(JavadocParser.NAME, 0); + } + + @Override + public int getRuleIndex() { + return RULE_blockTagName; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavadocParserVisitor) + return ((JavadocParserVisitor) visitor).visitBlockTagName(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).enterBlockTagName(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).exitBlockTagName(this); + } + } + + public static class BlockTagContentContext extends ParserRuleContext { + public BlockTagContentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public BlockTagTextContext blockTagText() { + return getRuleContext(BlockTagTextContext.class, 0); + } + + public InlineTagContext inlineTag() { + return getRuleContext(InlineTagContext.class, 0); + } + + public TerminalNode NEWLINE() { + return getToken(JavadocParser.NEWLINE, 0); + } + + @Override + public int getRuleIndex() { + return RULE_blockTagContent; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavadocParserVisitor) + return ((JavadocParserVisitor) visitor).visitBlockTagContent(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).enterBlockTagContent(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).exitBlockTagContent(this); + } + } + + public static class BlockTagTextContext extends ParserRuleContext { + public BlockTagTextContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List blockTagTextElement() { + return getRuleContexts(BlockTagTextElementContext.class); + } + + public BlockTagTextElementContext blockTagTextElement(int i) { + return getRuleContext(BlockTagTextElementContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_blockTagText; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavadocParserVisitor) + return ((JavadocParserVisitor) visitor).visitBlockTagText(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).enterBlockTagText(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).exitBlockTagText(this); + } + } + + public static class BlockTagTextElementContext extends ParserRuleContext { + public BlockTagTextElementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode TEXT_CONTENT() { + return getToken(JavadocParser.TEXT_CONTENT, 0); + } + + public TerminalNode NAME() { + return getToken(JavadocParser.NAME, 0); + } + + public TerminalNode SPACE() { + return getToken(JavadocParser.SPACE, 0); + } + + public TerminalNode STAR() { + return getToken(JavadocParser.STAR, 0); + } + + public TerminalNode SLASH() { + return getToken(JavadocParser.SLASH, 0); + } + + public TerminalNode BRACE_OPEN() { + return getToken(JavadocParser.BRACE_OPEN, 0); + } + + public TerminalNode BRACE_CLOSE() { + return getToken(JavadocParser.BRACE_CLOSE, 0); + } + + @Override + public int getRuleIndex() { + return RULE_blockTagTextElement; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavadocParserVisitor) + return ((JavadocParserVisitor) visitor).visitBlockTagTextElement(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).enterBlockTagTextElement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).exitBlockTagTextElement(this); + } + } + + public static class InlineTagContext extends ParserRuleContext { + public InlineTagContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode INLINE_TAG_START() { + return getToken(JavadocParser.INLINE_TAG_START, 0); + } + + public InlineTagNameContext inlineTagName() { + return getRuleContext(InlineTagNameContext.class, 0); + } + + public TerminalNode BRACE_CLOSE() { + return getToken(JavadocParser.BRACE_CLOSE, 0); + } + + public List SPACE() { + return getTokens(JavadocParser.SPACE); + } + + public TerminalNode SPACE(int i) { + return getToken(JavadocParser.SPACE, i); + } + + public InlineTagContentContext inlineTagContent() { + return getRuleContext(InlineTagContentContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_inlineTag; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavadocParserVisitor) + return ((JavadocParserVisitor) visitor).visitInlineTag(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).enterInlineTag(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).exitInlineTag(this); + } + } + + public static class InlineTagNameContext extends ParserRuleContext { + public InlineTagNameContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode NAME() { + return getToken(JavadocParser.NAME, 0); + } + + @Override + public int getRuleIndex() { + return RULE_inlineTagName; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavadocParserVisitor) + return ((JavadocParserVisitor) visitor).visitInlineTagName(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).enterInlineTagName(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).exitInlineTagName(this); + } + } + + public static class InlineTagContentContext extends ParserRuleContext { + public InlineTagContentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List braceContent() { + return getRuleContexts(BraceContentContext.class); + } + + public BraceContentContext braceContent(int i) { + return getRuleContext(BraceContentContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_inlineTagContent; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavadocParserVisitor) + return ((JavadocParserVisitor) visitor).visitInlineTagContent(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).enterInlineTagContent(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).exitInlineTagContent(this); + } + } + + public static class BraceExpressionContext extends ParserRuleContext { + public BraceExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode BRACE_OPEN() { + return getToken(JavadocParser.BRACE_OPEN, 0); + } + + public TerminalNode BRACE_CLOSE() { + return getToken(JavadocParser.BRACE_CLOSE, 0); + } + + public List braceContent() { + return getRuleContexts(BraceContentContext.class); + } + + public BraceContentContext braceContent(int i) { + return getRuleContext(BraceContentContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_braceExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavadocParserVisitor) + return ((JavadocParserVisitor) visitor).visitBraceExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).enterBraceExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).exitBraceExpression(this); + } + } + + public static class BraceContentContext extends ParserRuleContext { + public BraceContentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public BraceExpressionContext braceExpression() { + return getRuleContext(BraceExpressionContext.class, 0); + } + + public List braceText() { + return getRuleContexts(BraceTextContext.class); + } + + public BraceTextContext braceText(int i) { + return getRuleContext(BraceTextContext.class, i); + } + + public List NEWLINE() { + return getTokens(JavadocParser.NEWLINE); + } + + public TerminalNode NEWLINE(int i) { + return getToken(JavadocParser.NEWLINE, i); + } + + @Override + public int getRuleIndex() { + return RULE_braceContent; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavadocParserVisitor) + return ((JavadocParserVisitor) visitor).visitBraceContent(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).enterBraceContent(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).exitBraceContent(this); + } + } + + public static class BraceTextContext extends ParserRuleContext { + public BraceTextContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode TEXT_CONTENT() { + return getToken(JavadocParser.TEXT_CONTENT, 0); + } + + public TerminalNode NAME() { + return getToken(JavadocParser.NAME, 0); + } + + public TerminalNode SPACE() { + return getToken(JavadocParser.SPACE, 0); + } + + public TerminalNode STAR() { + return getToken(JavadocParser.STAR, 0); + } + + public TerminalNode SLASH() { + return getToken(JavadocParser.SLASH, 0); + } + + public TerminalNode NEWLINE() { + return getToken(JavadocParser.NEWLINE, 0); + } + + @Override + public int getRuleIndex() { + return RULE_braceText; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof JavadocParserVisitor) + return ((JavadocParserVisitor) visitor).visitBraceText(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).enterBraceText(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof JavadocParserListener) + ((JavadocParserListener) listener).exitBraceText(this); } } } diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/javadoc/JavadocParserBaseListener.java b/lexers/src/main/java/com/itsaky/androidide/lexers/javadoc/JavadocParserBaseListener.java index c1fa80f7a..5fa2453f4 100755 --- a/lexers/src/main/java/com/itsaky/androidide/lexers/javadoc/JavadocParserBaseListener.java +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/javadoc/JavadocParserBaseListener.java @@ -1,24 +1,5 @@ -/************************************************************************************ - * 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 . - * - **************************************************************************************/ -// Generated from JavadocParser.g4 by ANTLR 4.9.2 -package com.itsaky.androidide.antlr4.javadoc; +// Generated from JavadocParser.g4 by ANTLR 4.9.3 +package com.itsaky.androidide.lexers.javadoc; import org.antlr.v4.runtime.ParserRuleContext; import org.antlr.v4.runtime.tree.ErrorNode; @@ -339,20 +320,6 @@ public class JavadocParserBaseListener implements JavadocParserListener { @Override public void exitBraceText(JavadocParser.BraceTextContext ctx) {} - /** - * {@inheritDoc} - * - *

The default implementation does nothing. - */ - @Override - public void enterEveryRule(ParserRuleContext ctx) {} - /** - * {@inheritDoc} - * - *

The default implementation does nothing. - */ - @Override - public void exitEveryRule(ParserRuleContext ctx) {} /** * {@inheritDoc} * @@ -360,6 +327,7 @@ public class JavadocParserBaseListener implements JavadocParserListener { */ @Override public void visitTerminal(TerminalNode node) {} + /** * {@inheritDoc} * @@ -367,4 +335,20 @@ public class JavadocParserBaseListener implements JavadocParserListener { */ @Override public void visitErrorNode(ErrorNode node) {} + + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterEveryRule(ParserRuleContext ctx) {} + + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitEveryRule(ParserRuleContext ctx) {} } diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/javadoc/JavadocParserBaseVisitor.java b/lexers/src/main/java/com/itsaky/androidide/lexers/javadoc/JavadocParserBaseVisitor.java index e1ec46c84..588686b5e 100755 --- a/lexers/src/main/java/com/itsaky/androidide/lexers/javadoc/JavadocParserBaseVisitor.java +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/javadoc/JavadocParserBaseVisitor.java @@ -1,24 +1,5 @@ -/************************************************************************************ - * 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 . - * - **************************************************************************************/ -// Generated from JavadocParser.g4 by ANTLR 4.9.2 -package com.itsaky.androidide.antlr4.javadoc; +// Generated from JavadocParser.g4 by ANTLR 4.9.3 +package com.itsaky.androidide.lexers.javadoc; import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor; @@ -35,221 +16,220 @@ public class JavadocParserBaseVisitor extends AbstractParseTreeVisitor * {@inheritDoc} * *

The default implementation returns the result of calling {@link #visitChildren} on {@code - * context}. + * ctx}. */ @Override - public T visitDocumentation(JavadocParser.DocumentationContext context) { - return visitChildren(context); + public T visitDocumentation(JavadocParser.DocumentationContext ctx) { + return visitChildren(ctx); } /** * {@inheritDoc} * *

The default implementation returns the result of calling {@link #visitChildren} on {@code - * context}. + * ctx}. */ @Override - public T visitDocumentationContent(JavadocParser.DocumentationContentContext context) { - return visitChildren(context); + public T visitDocumentationContent(JavadocParser.DocumentationContentContext ctx) { + return visitChildren(ctx); } /** * {@inheritDoc} * *

The default implementation returns the result of calling {@link #visitChildren} on {@code - * context}. + * ctx}. */ @Override - public T visitSkipWhitespace(JavadocParser.SkipWhitespaceContext context) { - return visitChildren(context); + public T visitSkipWhitespace(JavadocParser.SkipWhitespaceContext ctx) { + return visitChildren(ctx); } /** * {@inheritDoc} * *

The default implementation returns the result of calling {@link #visitChildren} on {@code - * context}. + * ctx}. */ @Override - public T visitDescription(JavadocParser.DescriptionContext context) { - return visitChildren(context); + public T visitDescription(JavadocParser.DescriptionContext ctx) { + return visitChildren(ctx); } /** * {@inheritDoc} * *

The default implementation returns the result of calling {@link #visitChildren} on {@code - * context}. + * ctx}. */ @Override - public T visitDescriptionLine(JavadocParser.DescriptionLineContext context) { - return visitChildren(context); + public T visitDescriptionLine(JavadocParser.DescriptionLineContext ctx) { + return visitChildren(ctx); } /** * {@inheritDoc} * *

The default implementation returns the result of calling {@link #visitChildren} on {@code - * context}. + * ctx}. */ @Override - public T visitDescriptionLineStart(JavadocParser.DescriptionLineStartContext context) { - return visitChildren(context); + public T visitDescriptionLineStart(JavadocParser.DescriptionLineStartContext ctx) { + return visitChildren(ctx); } /** * {@inheritDoc} * *

The default implementation returns the result of calling {@link #visitChildren} on {@code - * context}. + * ctx}. */ @Override - public T visitDescriptionLineNoSpaceNoAt( - JavadocParser.DescriptionLineNoSpaceNoAtContext context) { - return visitChildren(context); + public T visitDescriptionLineNoSpaceNoAt(JavadocParser.DescriptionLineNoSpaceNoAtContext ctx) { + return visitChildren(ctx); } /** * {@inheritDoc} * *

The default implementation returns the result of calling {@link #visitChildren} on {@code - * context}. + * ctx}. */ @Override - public T visitDescriptionLineElement(JavadocParser.DescriptionLineElementContext context) { - return visitChildren(context); + public T visitDescriptionLineElement(JavadocParser.DescriptionLineElementContext ctx) { + return visitChildren(ctx); } /** * {@inheritDoc} * *

The default implementation returns the result of calling {@link #visitChildren} on {@code - * context}. + * ctx}. */ @Override - public T visitDescriptionLineText(JavadocParser.DescriptionLineTextContext context) { - return visitChildren(context); + public T visitDescriptionLineText(JavadocParser.DescriptionLineTextContext ctx) { + return visitChildren(ctx); } /** * {@inheritDoc} * *

The default implementation returns the result of calling {@link #visitChildren} on {@code - * context}. + * ctx}. */ @Override - public T visitDescriptionNewline(JavadocParser.DescriptionNewlineContext context) { - return visitChildren(context); + public T visitDescriptionNewline(JavadocParser.DescriptionNewlineContext ctx) { + return visitChildren(ctx); } /** * {@inheritDoc} * *

The default implementation returns the result of calling {@link #visitChildren} on {@code - * context}. + * ctx}. */ @Override - public T visitTagSection(JavadocParser.TagSectionContext context) { - return visitChildren(context); + public T visitTagSection(JavadocParser.TagSectionContext ctx) { + return visitChildren(ctx); } /** * {@inheritDoc} * *

The default implementation returns the result of calling {@link #visitChildren} on {@code - * context}. + * ctx}. */ @Override - public T visitBlockTag(JavadocParser.BlockTagContext context) { - return visitChildren(context); + public T visitBlockTag(JavadocParser.BlockTagContext ctx) { + return visitChildren(ctx); } /** * {@inheritDoc} * *

The default implementation returns the result of calling {@link #visitChildren} on {@code - * context}. + * ctx}. */ @Override - public T visitBlockTagName(JavadocParser.BlockTagNameContext context) { - return visitChildren(context); + public T visitBlockTagName(JavadocParser.BlockTagNameContext ctx) { + return visitChildren(ctx); } /** * {@inheritDoc} * *

The default implementation returns the result of calling {@link #visitChildren} on {@code - * context}. + * ctx}. */ @Override - public T visitBlockTagContent(JavadocParser.BlockTagContentContext context) { - return visitChildren(context); + public T visitBlockTagContent(JavadocParser.BlockTagContentContext ctx) { + return visitChildren(ctx); } /** * {@inheritDoc} * *

The default implementation returns the result of calling {@link #visitChildren} on {@code - * context}. + * ctx}. */ @Override - public T visitBlockTagText(JavadocParser.BlockTagTextContext context) { - return visitChildren(context); + public T visitBlockTagText(JavadocParser.BlockTagTextContext ctx) { + return visitChildren(ctx); } /** * {@inheritDoc} * *

The default implementation returns the result of calling {@link #visitChildren} on {@code - * context}. + * ctx}. */ @Override - public T visitBlockTagTextElement(JavadocParser.BlockTagTextElementContext context) { - return visitChildren(context); + public T visitBlockTagTextElement(JavadocParser.BlockTagTextElementContext ctx) { + return visitChildren(ctx); } /** * {@inheritDoc} * *

The default implementation returns the result of calling {@link #visitChildren} on {@code - * context}. + * ctx}. */ @Override - public T visitInlineTag(JavadocParser.InlineTagContext context) { - return visitChildren(context); + public T visitInlineTag(JavadocParser.InlineTagContext ctx) { + return visitChildren(ctx); } /** * {@inheritDoc} * *

The default implementation returns the result of calling {@link #visitChildren} on {@code - * context}. + * ctx}. */ @Override - public T visitInlineTagName(JavadocParser.InlineTagNameContext context) { - return visitChildren(context); + public T visitInlineTagName(JavadocParser.InlineTagNameContext ctx) { + return visitChildren(ctx); } /** * {@inheritDoc} * *

The default implementation returns the result of calling {@link #visitChildren} on {@code - * context}. + * ctx}. */ @Override - public T visitInlineTagContent(JavadocParser.InlineTagContentContext context) { - return visitChildren(context); + public T visitInlineTagContent(JavadocParser.InlineTagContentContext ctx) { + return visitChildren(ctx); } /** * {@inheritDoc} * *

The default implementation returns the result of calling {@link #visitChildren} on {@code - * context}. + * ctx}. */ @Override - public T visitBraceExpression(JavadocParser.BraceExpressionContext context) { - return visitChildren(context); + public T visitBraceExpression(JavadocParser.BraceExpressionContext ctx) { + return visitChildren(ctx); } /** * {@inheritDoc} * *

The default implementation returns the result of calling {@link #visitChildren} on {@code - * context}. + * ctx}. */ @Override - public T visitBraceContent(JavadocParser.BraceContentContext context) { - return visitChildren(context); + public T visitBraceContent(JavadocParser.BraceContentContext ctx) { + return visitChildren(ctx); } /** * {@inheritDoc} * *

The default implementation returns the result of calling {@link #visitChildren} on {@code - * context}. + * ctx}. */ @Override - public T visitBraceText(JavadocParser.BraceTextContext context) { - return visitChildren(context); + public T visitBraceText(JavadocParser.BraceTextContext ctx) { + return visitChildren(ctx); } } diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/javadoc/JavadocParserListener.java b/lexers/src/main/java/com/itsaky/androidide/lexers/javadoc/JavadocParserListener.java index aa048ca65..cfe3f29a7 100755 --- a/lexers/src/main/java/com/itsaky/androidide/lexers/javadoc/JavadocParserListener.java +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/javadoc/JavadocParserListener.java @@ -1,24 +1,5 @@ -/************************************************************************************ - * 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 . - * - **************************************************************************************/ -// Generated from JavadocParser.g4 by ANTLR 4.9.2 -package com.itsaky.androidide.antlr4.javadoc; +// Generated from JavadocParser.g4 by ANTLR 4.9.3 +package com.itsaky.androidide.lexers.javadoc; import org.antlr.v4.runtime.tree.ParseTreeListener; diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/javadoc/JavadocParserVisitor.java b/lexers/src/main/java/com/itsaky/androidide/lexers/javadoc/JavadocParserVisitor.java index cf0a9fe09..132dd2b00 100755 --- a/lexers/src/main/java/com/itsaky/androidide/lexers/javadoc/JavadocParserVisitor.java +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/javadoc/JavadocParserVisitor.java @@ -1,24 +1,5 @@ -/************************************************************************************ - * 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 . - * - **************************************************************************************/ -// Generated from JavadocParser.g4 by ANTLR 4.9.2 -package com.itsaky.androidide.antlr4.javadoc; +// Generated from JavadocParser.g4 by ANTLR 4.9.3 +package com.itsaky.androidide.lexers.javadoc; import org.antlr.v4.runtime.tree.ParseTreeVisitor; diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/kotlin/KotlinLexer.java b/lexers/src/main/java/com/itsaky/androidide/lexers/kotlin/KotlinLexer.java index e77c40683..c32e028d5 100644 --- a/lexers/src/main/java/com/itsaky/androidide/lexers/kotlin/KotlinLexer.java +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/kotlin/KotlinLexer.java @@ -1,1426 +1,2100 @@ -// Generated from KotlinLexer.g4 by ANTLR 4.9.2 +// Generated from KotlinLexer.g4 by ANTLR 4.9.3 package com.itsaky.androidide.lexers.kotlin; -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.Lexer; +import org.antlr.v4.runtime.RuleContext; +import org.antlr.v4.runtime.RuntimeMetaData; +import org.antlr.v4.runtime.Vocabulary; +import org.antlr.v4.runtime.VocabularyImpl; +import org.antlr.v4.runtime.atn.ATN; +import org.antlr.v4.runtime.atn.ATNDeserializer; +import org.antlr.v4.runtime.atn.LexerATNSimulator; +import org.antlr.v4.runtime.atn.PredictionContextCache; import org.antlr.v4.runtime.dfa.DFA; -import org.antlr.v4.runtime.misc.*; +import org.antlr.v4.runtime.misc.Utils; @SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) public class KotlinLexer extends Lexer { - static { RuntimeMetaData.checkVersion("4.9.2", RuntimeMetaData.VERSION); } + public static final int ShebangLine = 1, + DelimitedComment = 2, + LineComment = 3, + WS = 4, + NL = 5, + RESERVED = 6, + DOT = 7, + COMMA = 8, + LPAREN = 9, + RPAREN = 10, + LSQUARE = 11, + RSQUARE = 12, + LCURL = 13, + RCURL = 14, + MULT = 15, + MOD = 16, + DIV = 17, + ADD = 18, + SUB = 19, + INCR = 20, + DECR = 21, + CONJ = 22, + DISJ = 23, + EXCL_WS = 24, + EXCL_NO_WS = 25, + COLON = 26, + SEMICOLON = 27, + ASSIGNMENT = 28, + ADD_ASSIGNMENT = 29, + SUB_ASSIGNMENT = 30, + MULT_ASSIGNMENT = 31, + DIV_ASSIGNMENT = 32, + MOD_ASSIGNMENT = 33, + ARROW = 34, + DOUBLE_ARROW = 35, + RANGE = 36, + COLONCOLON = 37, + DOUBLE_SEMICOLON = 38, + HASH = 39, + AT_NO_WS = 40, + AT_POST_WS = 41, + AT_PRE_WS = 42, + AT_BOTH_WS = 43, + QUEST_WS = 44, + QUEST_NO_WS = 45, + LANGLE = 46, + RANGLE = 47, + LE = 48, + GE = 49, + EXCL_EQ = 50, + EXCL_EQEQ = 51, + AS_SAFE = 52, + EQEQ = 53, + EQEQEQ = 54, + SINGLE_QUOTE = 55, + RETURN_AT = 56, + CONTINUE_AT = 57, + BREAK_AT = 58, + THIS_AT = 59, + SUPER_AT = 60, + FILE = 61, + FIELD = 62, + PROPERTY = 63, + GET = 64, + SET = 65, + RECEIVER = 66, + PARAM = 67, + SETPARAM = 68, + DELEGATE = 69, + PACKAGE = 70, + IMPORT = 71, + CLASS = 72, + INTERFACE = 73, + FUN = 74, + OBJECT = 75, + VAL = 76, + VAR = 77, + TYPE_ALIAS = 78, + CONSTRUCTOR = 79, + BY = 80, + COMPANION = 81, + INIT = 82, + THIS = 83, + SUPER = 84, + TYPEOF = 85, + WHERE = 86, + IF = 87, + ELSE = 88, + WHEN = 89, + TRY = 90, + CATCH = 91, + FINALLY = 92, + FOR = 93, + DO = 94, + WHILE = 95, + THROW = 96, + RETURN = 97, + CONTINUE = 98, + BREAK = 99, + AS = 100, + IS = 101, + IN = 102, + NOT_IS = 103, + NOT_IN = 104, + OUT = 105, + DYNAMIC = 106, + PUBLIC = 107, + PRIVATE = 108, + PROTECTED = 109, + INTERNAL = 110, + ENUM = 111, + SEALED = 112, + ANNOTATION = 113, + DATA = 114, + INNER = 115, + VALUE = 116, + TAILREC = 117, + OPERATOR = 118, + INLINE = 119, + INFIX = 120, + EXTERNAL = 121, + SUSPEND = 122, + OVERRIDE = 123, + ABSTRACT = 124, + FINAL = 125, + OPEN = 126, + CONST = 127, + LATEINIT = 128, + VARARG = 129, + NOINLINE = 130, + CROSSINLINE = 131, + REIFIED = 132, + EXPECT = 133, + ACTUAL = 134, + RealLiteral = 135, + FloatLiteral = 136, + DoubleLiteral = 137, + IntegerLiteral = 138, + HexLiteral = 139, + BinLiteral = 140, + UnsignedLiteral = 141, + LongLiteral = 142, + BooleanLiteral = 143, + NullLiteral = 144, + CharacterLiteral = 145, + Identifier = 146, + IdentifierOrSoftKey = 147, + FieldIdentifier = 148, + QUOTE_OPEN = 149, + TRIPLE_QUOTE_OPEN = 150, + UNICODE_CLASS_LL = 151, + UNICODE_CLASS_LM = 152, + UNICODE_CLASS_LO = 153, + UNICODE_CLASS_LT = 154, + UNICODE_CLASS_LU = 155, + UNICODE_CLASS_ND = 156, + UNICODE_CLASS_NL = 157, + QUOTE_CLOSE = 158, + LineStrRef = 159, + LineStrText = 160, + LineStrEscapedChar = 161, + LineStrExprStart = 162, + TRIPLE_QUOTE_CLOSE = 163, + MultiLineStringQuote = 164, + MultiLineStrRef = 165, + MultiLineStrText = 166, + MultiLineStrExprStart = 167, + Inside_Comment = 168, + Inside_WS = 169, + Inside_NL = 170, + ErrorCharacter = 171; + public static final int LineString = 1, MultiLineString = 2, Inside = 3; + public static final String[] ruleNames = makeRuleNames(); + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated public static final String[] tokenNames; + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache(); + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + private static final int _serializedATNSegments = 2; + private static final String _serializedATNSegment0 = + "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\u00ad\u08b6\b\1\b" + + "\1\b\1\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\t" + + "F\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4" + + "R\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\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\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\4\u00bf\t\u00bf\4\u00c0\t\u00c0\4\u00c1\t\u00c1\4\u00c2\t\u00c2" + + "\4\u00c3\t\u00c3\4\u00c4\t\u00c4\4\u00c5\t\u00c5\4\u00c6\t\u00c6\4\u00c7" + + "\t\u00c7\4\u00c8\t\u00c8\4\u00c9\t\u00c9\4\u00ca\t\u00ca\4\u00cb\t\u00cb" + + "\4\u00cc\t\u00cc\4\u00cd\t\u00cd\4\u00ce\t\u00ce\4\u00cf\t\u00cf\4\u00d0" + + "\t\u00d0\4\u00d1\t\u00d1\4\u00d2\t\u00d2\4\u00d3\t\u00d3\4\u00d4\t\u00d4" + + "\4\u00d5\t\u00d5\4\u00d6\t\u00d6\4\u00d7\t\u00d7\4\u00d8\t\u00d8\4\u00d9" + + "\t\u00d9\4\u00da\t\u00da\4\u00db\t\u00db\4\u00dc\t\u00dc\4\u00dd\t\u00dd" + + "\4\u00de\t\u00de\4\u00df\t\u00df\4\u00e0\t\u00e0\4\u00e1\t\u00e1\4\u00e2" + + "\t\u00e2\4\u00e3\t\u00e3\4\u00e4\t\u00e4\4\u00e5\t\u00e5\4\u00e6\t\u00e6" + + "\4\u00e7\t\u00e7\4\u00e8\t\u00e8\4\u00e9\t\u00e9\4\u00ea\t\u00ea\4\u00eb" + + "\t\u00eb\4\u00ec\t\u00ec\4\u00ed\t\u00ed\4\u00ee\t\u00ee\4\u00ef\t\u00ef" + + "\4\u00f0\t\u00f0\4\u00f1\t\u00f1\4\u00f2\t\u00f2\4\u00f3\t\u00f3\4\u00f4" + + "\t\u00f4\4\u00f5\t\u00f5\4\u00f6\t\u00f6\4\u00f7\t\u00f7\4\u00f8\t\u00f8" + + "\4\u00f9\t\u00f9\4\u00fa\t\u00fa\4\u00fb\t\u00fb\4\u00fc\t\u00fc\4\u00fd" + + "\t\u00fd\4\u00fe\t\u00fe\4\u00ff\t\u00ff\4\u0100\t\u0100\4\u0101\t\u0101" + + "\4\u0102\t\u0102\4\u0103\t\u0103\4\u0104\t\u0104\4\u0105\t\u0105\4\u0106" + + "\t\u0106\4\u0107\t\u0107\4\u0108\t\u0108\4\u0109\t\u0109\4\u010a\t\u010a" + + "\4\u010b\t\u010b\4\u010c\t\u010c\4\u010d\t\u010d\4\u010e\t\u010e\4\u010f" + + "\t\u010f\4\u0110\t\u0110\4\u0111\t\u0111\4\u0112\t\u0112\4\u0113\t\u0113" + + "\4\u0114\t\u0114\4\u0115\t\u0115\4\u0116\t\u0116\4\u0117\t\u0117\4\u0118" + + "\t\u0118\4\u0119\t\u0119\4\u011a\t\u011a\4\u011b\t\u011b\4\u011c\t\u011c" + + "\4\u011d\t\u011d\4\u011e\t\u011e\4\u011f\t\u011f\4\u0120\t\u0120\4\u0121" + + "\t\u0121\4\u0122\t\u0122\4\u0123\t\u0123\4\u0124\t\u0124\4\u0125\t\u0125" + + "\4\u0126\t\u0126\4\u0127\t\u0127\4\u0128\t\u0128\4\u0129\t\u0129\4\u012a" + + "\t\u012a\4\u012b\t\u012b\4\u012c\t\u012c\4\u012d\t\u012d\4\u012e\t\u012e" + + "\4\u012f\t\u012f\4\u0130\t\u0130\4\u0131\t\u0131\4\u0132\t\u0132\4\u0133" + + "\t\u0133\4\u0134\t\u0134\4\u0135\t\u0135\4\u0136\t\u0136\4\u0137\t\u0137" + + "\4\u0138\t\u0138\4\u0139\t\u0139\3\2\3\2\3\2\3\2\7\2\u027b\n\2\f\2\16" + + "\2\u027e\13\2\3\3\3\3\3\3\3\3\3\3\7\3\u0285\n\3\f\3\16\3\u0288\13\3\3" + + "\3\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3\4\7\4\u0293\n\4\f\4\16\4\u0296\13\4\3" + + "\4\3\4\3\5\3\5\3\5\3\5\3\6\3\6\3\6\5\6\u02a1\n\6\5\6\u02a3\n\6\3\7\3\7" + + "\3\7\5\7\u02a8\n\7\3\b\3\b\3\b\3\b\3\t\3\t\3\n\3\n\3\13\3\13\3\13\3\13" + + "\3\f\3\f\3\r\3\r\3\r\3\r\3\16\3\16\3\17\3\17\3\17\3\17\3\20\3\20\3\20" + + "\3\21\3\21\3\22\3\22\3\23\3\23\3\24\3\24\3\25\3\25\3\26\3\26\3\26\3\27" + + "\3\27\3\27\3\30\3\30\3\30\3\31\3\31\3\31\3\32\3\32\3\32\3\33\3\33\3\34" + + "\3\34\3\35\3\35\3\36\3\36\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+\5+\u030b\n+\3,\3,\5,\u030f\n,\3,\3,\3-\3-\5-\u0315\n-\3-\3-" + + "\3-\5-\u031a\n-\3.\3.\3.\3/\3/\3\60\3\60\3\61\3\61\3\62\3\62\3\62\3\63" + + "\3\63\3\63\3\64\3\64\3\64\3\65\3\65\3\65\3\65\3\66\3\66\3\66\3\66\3\67" + + "\3\67\3\67\38\38\38\38\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" + + "A\3A\3A\3A\3A\3A\3A\3A\3A\3B\3B\3B\3B\3C\3C\3C\3C\3D\3D\3D\3D\3D\3D\3" + + "D\3D\3D\3E\3E\3E\3E\3E\3E\3F\3F\3F\3F\3F\3F\3F\3F\3F\3G\3G\3G\3G\3G\3" + + "G\3G\3G\3G\3H\3H\3H\3H\3H\3H\3H\3H\3I\3I\3I\3I\3I\3I\3I\3J\3J\3J\3J\3" + + "J\3J\3K\3K\3K\3K\3K\3K\3K\3K\3K\3K\3L\3L\3L\3L\3M\3M\3M\3M\3M\3M\3M\3" + + "N\3N\3N\3N\3O\3O\3O\3O\3P\3P\3P\3P\3P\3P\3P\3P\3P\3P\3Q\3Q\3Q\3Q\3Q\3" + + "Q\3Q\3Q\3Q\3Q\3Q\3Q\3R\3R\3R\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3T\3T\3T\3" + + "T\3T\3U\3U\3U\3U\3U\3V\3V\3V\3V\3V\3V\3W\3W\3W\3W\3W\3W\3W\3X\3X\3X\3" + + "X\3X\3X\3Y\3Y\3Y\3Z\3Z\3Z\3Z\3Z\3[\3[\3[\3[\3[\3\\\3\\\3\\\3\\\3]\3]\3" + + "]\3]\3]\3]\3^\3^\3^\3^\3^\3^\3^\3^\3_\3_\3_\3_\3`\3`\3`\3a\3a\3a\3a\3" + + "a\3a\3b\3b\3b\3b\3b\3b\3c\3c\3c\3c\3c\3c\3c\3d\3d\3d\3d\3d\3d\3d\3d\3" + + "d\3e\3e\3e\3e\3e\3e\3f\3f\3f\3g\3g\3g\3h\3h\3h\3i\3i\3i\3i\3i\3i\5i\u0475" + + "\ni\3j\3j\3j\3j\3j\3j\5j\u047d\nj\3k\3k\3k\3k\3l\3l\3l\3l\3l\3l\3l\3l" + + "\3m\3m\3m\3m\3m\3m\3m\3n\3n\3n\3n\3n\3n\3n\3n\3o\3o\3o\3o\3o\3o\3o\3o" + + "\3o\3o\3p\3p\3p\3p\3p\3p\3p\3p\3p\3q\3q\3q\3q\3q\3r\3r\3r\3r\3r\3r\3r" + + "\3s\3s\3s\3s\3s\3s\3s\3s\3s\3s\3s\3t\3t\3t\3t\3t\3u\3u\3u\3u\3u\3u\3v" + + "\3v\3v\3v\3v\3v\3w\3w\3w\3w\3w\3w\3w\3w\3x\3x\3x\3x\3x\3x\3x\3x\3x\3y" + + "\3y\3y\3y\3y\3y\3y\3z\3z\3z\3z\3z\3z\3{\3{\3{\3{\3{\3{\3{\3{\3{\3|\3|" + + "\3|\3|\3|\3|\3|\3|\3}\3}\3}\3}\3}\3}\3}\3}\3}\3~\3~\3~\3~\3~\3~\3~\3~" + + "\3~\3\177\3\177\3\177\3\177\3\177\3\177\3\u0080\3\u0080\3\u0080\3\u0080" + + "\3\u0080\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\3\u0082\3\u0082" + + "\3\u0082\3\u0082\3\u0082\3\u0082\3\u0082\3\u0082\3\u0082\3\u0083\3\u0083" + + "\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083\3\u0084\3\u0084\3\u0084\3\u0084" + + "\3\u0084\3\u0084\3\u0084\3\u0084\3\u0084\3\u0085\3\u0085\3\u0085\3\u0085" + + "\3\u0085\3\u0085\3\u0085\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\u0087\3\u0087" + + "\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087\3\u0088\3\u0088\3\u0088\3\u0088" + + "\3\u0088\3\u0088\3\u0088\3\u0089\3\u0089\3\u008a\3\u008a\3\u008b\3\u008b" + + "\5\u008b\u0568\n\u008b\3\u008c\3\u008c\7\u008c\u056c\n\u008c\f\u008c\16" + + "\u008c\u056f\13\u008c\3\u008c\3\u008c\3\u008c\5\u008c\u0574\n\u008c\3" + + "\u008d\3\u008d\5\u008d\u0578\n\u008d\3\u008d\3\u008d\3\u008e\3\u008e\5" + + "\u008e\u057e\n\u008e\3\u008f\3\u008f\3\u008f\3\u008f\3\u008f\3\u008f\5" + + "\u008f\u0586\n\u008f\3\u0090\5\u0090\u0589\n\u0090\3\u0090\3\u0090\3\u0090" + + "\5\u0090\u058e\n\u0090\3\u0090\3\u0090\3\u0090\5\u0090\u0593\n\u0090\3" + + "\u0091\3\u0091\7\u0091\u0597\n\u0091\f\u0091\16\u0091\u059a\13\u0091\3" + + "\u0091\3\u0091\3\u0091\5\u0091\u059f\n\u0091\3\u0092\3\u0092\3\u0093\3" + + "\u0093\5\u0093\u05a5\n\u0093\3\u0094\3\u0094\3\u0094\3\u0094\7\u0094\u05ab" + + "\n\u0094\f\u0094\16\u0094\u05ae\13\u0094\3\u0094\3\u0094\3\u0094\3\u0094" + + "\3\u0094\5\u0094\u05b5\n\u0094\3\u0095\3\u0095\3\u0096\3\u0096\5\u0096" + + "\u05bb\n\u0096\3\u0097\3\u0097\3\u0097\3\u0097\7\u0097\u05c1\n\u0097\f" + + "\u0097\16\u0097\u05c4\13\u0097\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097" + + "\5\u0097\u05cb\n\u0097\3\u0098\3\u0098\3\u0098\5\u0098\u05d0\n\u0098\3" + + "\u0098\3\u0098\5\u0098\u05d4\n\u0098\3\u0099\3\u0099\3\u0099\5\u0099\u05d9" + + "\n\u0099\3\u0099\3\u0099\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a" + + "\3\u009a\3\u009a\3\u009a\5\u009a\u05e6\n\u009a\3\u009b\3\u009b\3\u009b" + + "\3\u009b\3\u009b\3\u009c\3\u009c\3\u009c\5\u009c\u05f0\n\u009c\3\u009c" + + "\3\u009c\3\u009d\3\u009d\3\u009e\3\u009e\5\u009e\u05f8\n\u009e\3\u009e" + + "\3\u009e\3\u009e\7\u009e\u05fd\n\u009e\f\u009e\16\u009e\u0600\13\u009e" + + "\3\u009e\3\u009e\6\u009e\u0604\n\u009e\r\u009e\16\u009e\u0605\3\u009e" + + "\5\u009e\u0609\n\u009e\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f" + + "\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f" + + "\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f" + + "\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f" + + "\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f" + + "\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\5\u009f\u063b\n\u009f" + + "\3\u00a0\3\u00a0\3\u00a0\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1" + + "\3\u00a1\3\u00a2\3\u00a2\3\u00a2\3\u00a3\3\u00a3\5\u00a3\u064c\n\u00a3" + + "\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4\5\u00a4\u0653\n\u00a4\3\u00a5" + + "\3\u00a5\3\u00a5\3\u00a5\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6" + + "\3\u00a7\3\u00a7\3\u00a8\3\u00a8\3\u00a9\3\u00a9\3\u00aa\3\u00aa\3\u00ab" + + "\3\u00ab\3\u00ac\3\u00ac\3\u00ad\3\u00ad\3\u00ae\3\u00ae\3\u00ae\3\u00ae" + + "\3\u00af\3\u00af\3\u00b0\6\u00b0\u0674\n\u00b0\r\u00b0\16\u00b0\u0675" + + "\3\u00b0\5\u00b0\u0679\n\u00b0\3\u00b1\3\u00b1\5\u00b1\u067d\n\u00b1\3" + + "\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b3\5\u00b3\u0685\n\u00b3\3" + + "\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b4\6\u00b4\u068e\n" + + "\u00b4\r\u00b4\16\u00b4\u068f\3\u00b5\3\u00b5\3\u00b6\6\u00b6\u0695\n" + + "\u00b6\r\u00b6\16\u00b6\u0696\3\u00b6\5\u00b6\u069a\n\u00b6\3\u00b7\3" + + "\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b8\3\u00b8\3\u00b8\3\u00b8\3\u00b8" + + "\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00ba\3\u00ba\3\u00ba\3\u00ba" + + "\3\u00ba\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bc\3\u00bc\3\u00bc" + + "\3\u00bc\3\u00bc\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00be\3\u00be" + + "\3\u00be\3\u00be\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00c0\3\u00c0\3\u00c0" + + "\3\u00c0\3\u00c1\3\u00c1\3\u00c1\3\u00c1\3\u00c2\3\u00c2\3\u00c2\3\u00c2" + + "\3\u00c3\3\u00c3\3\u00c3\3\u00c3\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c5" + + "\3\u00c5\3\u00c5\3\u00c5\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c7\3\u00c7" + + "\3\u00c7\3\u00c7\3\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c9\3\u00c9\3\u00c9" + + "\5\u00c9\u06ee\n\u00c9\3\u00c9\3\u00c9\3\u00ca\3\u00ca\3\u00ca\3\u00ca" + + "\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cd" + + "\3\u00cd\3\u00cd\3\u00cd\3\u00ce\3\u00ce\3\u00ce\3\u00ce\3\u00cf\3\u00cf" + + "\3\u00cf\3\u00cf\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d1\3\u00d1\3\u00d1" + + "\3\u00d1\3\u00d2\3\u00d2\3\u00d2\3\u00d2\3\u00d3\3\u00d3\3\u00d3\3\u00d3" + + "\3\u00d4\3\u00d4\3\u00d4\3\u00d4\3\u00d5\3\u00d5\3\u00d5\3\u00d5\3\u00d6" + + "\3\u00d6\3\u00d6\3\u00d6\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d8\3\u00d8" + + "\3\u00d8\3\u00d8\3\u00d9\3\u00d9\3\u00d9\3\u00d9\3\u00da\3\u00da\3\u00da" + + "\3\u00da\3\u00db\3\u00db\3\u00db\3\u00db\3\u00dc\3\u00dc\3\u00dc\3\u00dc" + + "\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00de\3\u00de\3\u00de\5\u00de\u0745" + + "\n\u00de\3\u00de\3\u00de\3\u00df\3\u00df\3\u00df\3\u00df\3\u00e0\3\u00e0" + + "\3\u00e0\3\u00e0\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e2\3\u00e2\3\u00e2" + + "\3\u00e2\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e4\3\u00e4\3\u00e4\3\u00e4" + + "\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e6\3\u00e6\3\u00e6\3\u00e6\3\u00e7" + + "\3\u00e7\3\u00e7\3\u00e7\3\u00e8\3\u00e8\3\u00e8\3\u00e8\3\u00e9\3\u00e9" + + "\3\u00e9\3\u00e9\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00eb\3\u00eb\3\u00eb" + + "\3\u00eb\3\u00ec\3\u00ec\3\u00ec\3\u00ec\3\u00ed\3\u00ed\3\u00ed\3\u00ed" + + "\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ef\3\u00ef\3\u00ef\3\u00ef" + + "\3\u00ef\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f1\3\u00f1\3\u00f1\3\u00f1" + + "\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f4" + + "\3\u00f4\3\u00f4\3\u00f4\3\u00f5\3\u00f5\3\u00f5\3\u00f5\3\u00f6\3\u00f6" + + "\3\u00f6\3\u00f6\3\u00f7\3\u00f7\3\u00f7\3\u00f7\3\u00f8\3\u00f8\3\u00f8" + + "\3\u00f8\3\u00f9\3\u00f9\3\u00f9\3\u00f9\3\u00fa\3\u00fa\3\u00fa\3\u00fa" + + "\3\u00fb\3\u00fb\3\u00fb\3\u00fb\3\u00fc\3\u00fc\3\u00fc\3\u00fc\3\u00fd" + + "\3\u00fd\3\u00fd\3\u00fd\3\u00fe\3\u00fe\3\u00fe\3\u00fe\3\u00ff\3\u00ff" + + "\3\u00ff\3\u00ff\3\u0100\3\u0100\3\u0100\3\u0100\3\u0101\3\u0101\3\u0101" + + "\3\u0101\3\u0102\3\u0102\3\u0102\3\u0102\3\u0103\3\u0103\3\u0103\3\u0103" + + "\3\u0104\3\u0104\3\u0104\3\u0104\3\u0105\3\u0105\3\u0105\3\u0105\3\u0106" + + "\3\u0106\3\u0106\3\u0106\3\u0107\3\u0107\3\u0107\3\u0107\3\u0108\3\u0108" + + "\3\u0108\3\u0108\3\u0109\3\u0109\3\u0109\3\u0109\3\u010a\3\u010a\3\u010a" + + "\3\u010a\3\u010b\3\u010b\3\u010b\3\u010b\3\u010c\3\u010c\3\u010c\3\u010c" + + "\3\u010d\3\u010d\3\u010d\3\u010d\3\u010e\3\u010e\3\u010e\3\u010e\3\u010f" + + "\3\u010f\3\u010f\3\u010f\3\u0110\3\u0110\3\u0110\3\u0110\3\u0111\3\u0111" + + "\3\u0111\3\u0111\3\u0112\3\u0112\3\u0112\3\u0112\3\u0113\3\u0113\3\u0113" + + "\3\u0113\3\u0114\3\u0114\3\u0114\3\u0114\3\u0115\3\u0115\3\u0115\3\u0115" + + "\3\u0116\3\u0116\3\u0116\3\u0116\3\u0117\3\u0117\3\u0117\3\u0117\3\u0118" + + "\3\u0118\3\u0118\3\u0118\3\u0119\3\u0119\3\u0119\3\u0119\3\u011a\3\u011a" + + "\3\u011a\3\u011a\3\u011b\3\u011b\3\u011b\3\u011b\3\u011c\3\u011c\3\u011c" + + "\3\u011c\3\u011d\3\u011d\3\u011d\3\u011d\3\u011e\3\u011e\3\u011e\3\u011e" + + "\3\u011f\3\u011f\3\u011f\3\u011f\3\u0120\3\u0120\3\u0120\3\u0120\3\u0121" + + "\3\u0121\3\u0121\3\u0121\3\u0122\3\u0122\3\u0122\3\u0122\3\u0123\3\u0123" + + "\3\u0123\3\u0123\3\u0124\3\u0124\3\u0124\3\u0124\3\u0125\3\u0125\3\u0125" + + "\3\u0125\3\u0126\3\u0126\3\u0126\3\u0126\3\u0127\3\u0127\3\u0127\3\u0127" + + "\3\u0128\3\u0128\3\u0128\3\u0128\3\u0129\3\u0129\3\u0129\3\u0129\3\u012a" + + "\3\u012a\3\u012a\3\u012a\3\u012b\3\u012b\3\u012b\3\u012b\3\u012c\3\u012c" + + "\3\u012c\3\u012c\3\u012d\3\u012d\3\u012d\3\u012d\3\u012e\3\u012e\3\u012e" + + "\3\u012e\3\u012f\3\u012f\3\u012f\3\u012f\3\u0130\3\u0130\3\u0130\3\u0130" + + "\3\u0131\3\u0131\3\u0131\3\u0131\3\u0132\3\u0132\3\u0132\3\u0132\3\u0133" + + "\3\u0133\3\u0133\3\u0133\3\u0134\3\u0134\3\u0134\3\u0134\3\u0135\3\u0135" + + "\3\u0135\3\u0135\3\u0136\3\u0136\5\u0136\u08a9\n\u0136\3\u0136\3\u0136" + + "\3\u0137\3\u0137\3\u0137\3\u0137\3\u0138\3\u0138\3\u0138\3\u0138\3\u0139" + + "\3\u0139\3\u0286\2\u013a\6\3\b\4\n\5\f\6\16\7\20\2\22\b\24\t\26\n\30\13" + + "\32\f\34\r\36\16 \17\"\20$\21&\22(\23*\24,\25.\26\60\27\62\30\64\31\66" + + "\328\33:\34<\35>\36@\37B D!F\"H#J$L%N&P\'R(T)V*X+Z,\\-^.`/b\60d\61f\62" + + "h\63j\64l\65n\66p\67r8t9v:x;z<|=~>\u0080?\u0082@\u0084A\u0086B\u0088C" + + "\u008aD\u008cE\u008eF\u0090G\u0092H\u0094I\u0096J\u0098K\u009aL\u009c" + + "M\u009eN\u00a0O\u00a2P\u00a4Q\u00a6R\u00a8S\u00aaT\u00acU\u00aeV\u00b0" + + "W\u00b2X\u00b4Y\u00b6Z\u00b8[\u00ba\\\u00bc]\u00be^\u00c0_\u00c2`\u00c4" + + "a\u00c6b\u00c8c\u00cad\u00cce\u00cef\u00d0g\u00d2h\u00d4i\u00d6j\u00d8" + + "k\u00dal\u00dcm\u00den\u00e0o\u00e2p\u00e4q\u00e6r\u00e8s\u00eat\u00ec" + + "u\u00eev\u00f0w\u00f2x\u00f4y\u00f6z\u00f8{\u00fa|\u00fc}\u00fe~\u0100" + + "\177\u0102\u0080\u0104\u0081\u0106\u0082\u0108\u0083\u010a\u0084\u010c" + + "\u0085\u010e\u0086\u0110\u0087\u0112\u0088\u0114\2\u0116\2\u0118\2\u011a" + + "\2\u011c\2\u011e\u0089\u0120\u008a\u0122\u008b\u0124\u008c\u0126\2\u0128" + + "\2\u012a\u008d\u012c\2\u012e\2\u0130\u008e\u0132\u008f\u0134\u0090\u0136" + + "\u0091\u0138\u0092\u013a\u0093\u013c\2\u013e\u0094\u0140\u0095\u0142\u0096" + + "\u0144\2\u0146\2\u0148\2\u014a\2\u014c\u0097\u014e\u0098\u0150\u0099\u0152" + + "\u009a\u0154\u009b\u0156\u009c\u0158\u009d\u015a\u009e\u015c\u009f\u015e" + + "\u00a0\u0160\u00a1\u0162\u00a2\u0164\u00a3\u0166\u00a4\u0168\u00a5\u016a" + + "\u00a6\u016c\u00a7\u016e\u00a8\u0170\u00a9\u0172\2\u0174\2\u0176\2\u0178" + + "\2\u017a\2\u017c\2\u017e\2\u0180\2\u0182\2\u0184\2\u0186\2\u0188\2\u018a" + + "\2\u018c\2\u018e\2\u0190\2\u0192\2\u0194\2\u0196\2\u0198\2\u019a\2\u019c" + + "\2\u019e\2\u01a0\2\u01a2\2\u01a4\2\u01a6\2\u01a8\2\u01aa\2\u01ac\2\u01ae" + + "\2\u01b0\2\u01b2\2\u01b4\2\u01b6\2\u01b8\2\u01ba\2\u01bc\2\u01be\2\u01c0" + + "\2\u01c2\2\u01c4\2\u01c6\2\u01c8\2\u01ca\2\u01cc\2\u01ce\2\u01d0\2\u01d2" + + "\2\u01d4\2\u01d6\2\u01d8\2\u01da\2\u01dc\2\u01de\2\u01e0\2\u01e2\2\u01e4" + + "\2\u01e6\2\u01e8\2\u01ea\2\u01ec\2\u01ee\2\u01f0\2\u01f2\2\u01f4\2\u01f6" + + "\2\u01f8\2\u01fa\2\u01fc\2\u01fe\2\u0200\2\u0202\2\u0204\2\u0206\2\u0208" + + "\2\u020a\2\u020c\2\u020e\2\u0210\2\u0212\2\u0214\2\u0216\2\u0218\2\u021a" + + "\2\u021c\2\u021e\2\u0220\2\u0222\2\u0224\2\u0226\2\u0228\2\u022a\2\u022c" + + "\2\u022e\2\u0230\2\u0232\2\u0234\2\u0236\2\u0238\2\u023a\2\u023c\2\u023e" + + "\2\u0240\2\u0242\2\u0244\2\u0246\2\u0248\2\u024a\2\u024c\2\u024e\2\u0250" + + "\2\u0252\2\u0254\2\u0256\2\u0258\2\u025a\2\u025c\2\u025e\2\u0260\2\u0262" + + "\2\u0264\2\u0266\2\u0268\2\u026a\2\u026c\2\u026e\u00aa\u0270\u00ab\u0272" + + "\u00ac\u0274\u00ad\6\2\3\4\5\31\4\2\f\f\17\17\5\2\13\13\16\16\"\"\4\2" + + "GGgg\4\2--//\4\2HHhh\5\2\62;CHch\4\2ZZzz\3\2\62\63\4\2DDdd\4\2WWww\4\2" + + "NNnn\6\2\f\f\17\17))^^\5\2\f\f\17\17bb\n\2$$&&))^^ddppttvv\u0248\2c|\u00b7" + + "\u00b7\u00e1\u00f8\u00fa\u0101\u0103\u0103\u0105\u0105\u0107\u0107\u0109" + + "\u0109\u010b\u010b\u010d\u010d\u010f\u010f\u0111\u0111\u0113\u0113\u0115" + + "\u0115\u0117\u0117\u0119\u0119\u011b\u011b\u011d\u011d\u011f\u011f\u0121" + + "\u0121\u0123\u0123\u0125\u0125\u0127\u0127\u0129\u0129\u012b\u012b\u012d" + + "\u012d\u012f\u012f\u0131\u0131\u0133\u0133\u0135\u0135\u0137\u0137\u0139" + + "\u013a\u013c\u013c\u013e\u013e\u0140\u0140\u0142\u0142\u0144\u0144\u0146" + + "\u0146\u0148\u0148\u014a\u014b\u014d\u014d\u014f\u014f\u0151\u0151\u0153" + + "\u0153\u0155\u0155\u0157\u0157\u0159\u0159\u015b\u015b\u015d\u015d\u015f" + + "\u015f\u0161\u0161\u0163\u0163\u0165\u0165\u0167\u0167\u0169\u0169\u016b" + + "\u016b\u016d\u016d\u016f\u016f\u0171\u0171\u0173\u0173\u0175\u0175\u0177" + + "\u0177\u0179\u0179\u017c\u017c\u017e\u017e\u0180\u0182\u0185\u0185\u0187" + + "\u0187\u018a\u018a\u018e\u018f\u0194\u0194\u0197\u0197\u019b\u019d\u01a0" + + "\u01a0\u01a3\u01a3\u01a5\u01a5\u01a7\u01a7\u01aa\u01aa\u01ac\u01ad\u01af" + + "\u01af\u01b2\u01b2\u01b6\u01b6\u01b8\u01b8\u01bb\u01bc\u01bf\u01c1\u01c8" + + "\u01c8\u01cb\u01cb\u01ce\u01ce\u01d0\u01d0\u01d2\u01d2\u01d4\u01d4\u01d6" + + "\u01d6\u01d8\u01d8\u01da\u01da\u01dc\u01dc\u01de\u01df\u01e1\u01e1\u01e3" + + "\u01e3\u01e5\u01e5\u01e7\u01e7\u01e9\u01e9\u01eb\u01eb\u01ed\u01ed\u01ef" + + "\u01ef\u01f1\u01f2\u01f5\u01f5\u01f7\u01f7\u01fb\u01fb\u01fd\u01fd\u01ff" + + "\u01ff\u0201\u0201\u0203\u0203\u0205\u0205\u0207\u0207\u0209\u0209\u020b" + + "\u020b\u020d\u020d\u020f\u020f\u0211\u0211\u0213\u0213\u0215\u0215\u0217" + + "\u0217\u0219\u0219\u021b\u021b\u021d\u021d\u021f\u021f\u0221\u0221\u0223" + + "\u0223\u0225\u0225\u0227\u0227\u0229\u0229\u022b\u022b\u022d\u022d\u022f" + + "\u022f\u0231\u0231\u0233\u0233\u0235\u023b\u023e\u023e\u0241\u0242\u0244" + + "\u0244\u0249\u0249\u024b\u024b\u024d\u024d\u024f\u024f\u0251\u0295\u0297" + + "\u02b1\u0373\u0373\u0375\u0375\u0379\u0379\u037d\u037f\u0392\u0392\u03ae" + + "\u03d0\u03d2\u03d3\u03d7\u03d9\u03db\u03db\u03dd\u03dd\u03df\u03df\u03e1" + + "\u03e1\u03e3\u03e3\u03e5\u03e5\u03e7\u03e7\u03e9\u03e9\u03eb\u03eb\u03ed" + + "\u03ed\u03ef\u03ef\u03f1\u03f5\u03f7\u03f7\u03fa\u03fa\u03fd\u03fe\u0432" + + "\u0461\u0463\u0463\u0465\u0465\u0467\u0467\u0469\u0469\u046b\u046b\u046d" + + "\u046d\u046f\u046f\u0471\u0471\u0473\u0473\u0475\u0475\u0477\u0477\u0479" + + "\u0479\u047b\u047b\u047d\u047d\u047f\u047f\u0481\u0481\u0483\u0483\u048d" + + "\u048d\u048f\u048f\u0491\u0491\u0493\u0493\u0495\u0495\u0497\u0497\u0499" + + "\u0499\u049b\u049b\u049d\u049d\u049f\u049f\u04a1\u04a1\u04a3\u04a3\u04a5" + + "\u04a5\u04a7\u04a7\u04a9\u04a9\u04ab\u04ab\u04ad\u04ad\u04af\u04af\u04b1" + + "\u04b1\u04b3\u04b3\u04b5\u04b5\u04b7\u04b7\u04b9\u04b9\u04bb\u04bb\u04bd" + + "\u04bd\u04bf\u04bf\u04c1\u04c1\u04c4\u04c4\u04c6\u04c6\u04c8\u04c8\u04ca" + + "\u04ca\u04cc\u04cc\u04ce\u04ce\u04d0\u04d1\u04d3\u04d3\u04d5\u04d5\u04d7" + + "\u04d7\u04d9\u04d9\u04db\u04db\u04dd\u04dd\u04df\u04df\u04e1\u04e1\u04e3" + + "\u04e3\u04e5\u04e5\u04e7\u04e7\u04e9\u04e9\u04eb\u04eb\u04ed\u04ed\u04ef" + + "\u04ef\u04f1\u04f1\u04f3\u04f3\u04f5\u04f5\u04f7\u04f7\u04f9\u04f9\u04fb" + + "\u04fb\u04fd\u04fd\u04ff\u04ff\u0501\u0501\u0503\u0503\u0505\u0505\u0507" + + "\u0507\u0509\u0509\u050b\u050b\u050d\u050d\u050f\u050f\u0511\u0511\u0513" + + "\u0513\u0515\u0515\u0517\u0517\u0519\u0519\u051b\u051b\u051d\u051d\u051f" + + "\u051f\u0521\u0521\u0523\u0523\u0525\u0525\u0527\u0527\u0529\u0529\u0563" + + "\u0589\u1d02\u1d2d\u1d6d\u1d79\u1d7b\u1d9c\u1e03\u1e03\u1e05\u1e05\u1e07" + + "\u1e07\u1e09\u1e09\u1e0b\u1e0b\u1e0d\u1e0d\u1e0f\u1e0f\u1e11\u1e11\u1e13" + + "\u1e13\u1e15\u1e15\u1e17\u1e17\u1e19\u1e19\u1e1b\u1e1b\u1e1d\u1e1d\u1e1f" + + "\u1e1f\u1e21\u1e21\u1e23\u1e23\u1e25\u1e25\u1e27\u1e27\u1e29\u1e29\u1e2b" + + "\u1e2b\u1e2d\u1e2d\u1e2f\u1e2f\u1e31\u1e31\u1e33\u1e33\u1e35\u1e35\u1e37" + + "\u1e37\u1e39\u1e39\u1e3b\u1e3b\u1e3d\u1e3d\u1e3f\u1e3f\u1e41\u1e41\u1e43" + + "\u1e43\u1e45\u1e45\u1e47\u1e47\u1e49\u1e49\u1e4b\u1e4b\u1e4d\u1e4d\u1e4f" + + "\u1e4f\u1e51\u1e51\u1e53\u1e53\u1e55\u1e55\u1e57\u1e57\u1e59\u1e59\u1e5b" + + "\u1e5b\u1e5d\u1e5d\u1e5f\u1e5f\u1e61\u1e61\u1e63\u1e63\u1e65\u1e65\u1e67" + + "\u1e67\u1e69\u1e69\u1e6b\u1e6b\u1e6d\u1e6d\u1e6f\u1e6f\u1e71\u1e71\u1e73" + + "\u1e73\u1e75\u1e75\u1e77\u1e77\u1e79\u1e79\u1e7b\u1e7b\u1e7d\u1e7d\u1e7f" + + "\u1e7f\u1e81\u1e81\u1e83\u1e83\u1e85\u1e85\u1e87\u1e87\u1e89\u1e89\u1e8b" + + "\u1e8b\u1e8d\u1e8d\u1e8f\u1e8f\u1e91\u1e91\u1e93\u1e93\u1e95\u1e95\u1e97" + + "\u1e9f\u1ea1\u1ea1\u1ea3\u1ea3\u1ea5\u1ea5\u1ea7\u1ea7\u1ea9\u1ea9\u1eab" + + "\u1eab\u1ead\u1ead\u1eaf\u1eaf\u1eb1\u1eb1\u1eb3\u1eb3\u1eb5\u1eb5\u1eb7" + + "\u1eb7\u1eb9\u1eb9\u1ebb\u1ebb\u1ebd\u1ebd\u1ebf\u1ebf\u1ec1\u1ec1\u1ec3" + + "\u1ec3\u1ec5\u1ec5\u1ec7\u1ec7\u1ec9\u1ec9\u1ecb\u1ecb\u1ecd\u1ecd\u1ecf" + + "\u1ecf\u1ed1\u1ed1\u1ed3\u1ed3\u1ed5\u1ed5\u1ed7\u1ed7\u1ed9\u1ed9\u1edb" + + "\u1edb\u1edd\u1edd\u1edf\u1edf\u1ee1\u1ee1\u1ee3\u1ee3\u1ee5\u1ee5\u1ee7" + + "\u1ee7\u1ee9\u1ee9\u1eeb\u1eeb\u1eed\u1eed\u1eef\u1eef\u1ef1\u1ef1\u1ef3" + + "\u1ef3\u1ef5\u1ef5\u1ef7\u1ef7\u1ef9\u1ef9\u1efb\u1efb\u1efd\u1efd\u1eff" + + "\u1eff\u1f01\u1f09\u1f12\u1f17\u1f22\u1f29\u1f32\u1f39\u1f42\u1f47\u1f52" + + "\u1f59\u1f62\u1f69\u1f72\u1f7f\u1f82\u1f89\u1f92\u1f99\u1fa2\u1fa9\u1fb2" + + "\u1fb6\u1fb8\u1fb9\u1fc0\u1fc0\u1fc4\u1fc6\u1fc8\u1fc9\u1fd2\u1fd5\u1fd8" + + "\u1fd9\u1fe2\u1fe9\u1ff4\u1ff6\u1ff8\u1ff9\u210c\u210c\u2110\u2111\u2115" + + "\u2115\u2131\u2131\u2136\u2136\u213b\u213b\u213e\u213f\u2148\u214b\u2150" + + "\u2150\u2186\u2186\u2c32\u2c60\u2c63\u2c63\u2c67\u2c68\u2c6a\u2c6a\u2c6c" + + "\u2c6c\u2c6e\u2c6e\u2c73\u2c73\u2c75\u2c76\u2c78\u2c7d\u2c83\u2c83\u2c85" + + "\u2c85\u2c87\u2c87\u2c89\u2c89\u2c8b\u2c8b\u2c8d\u2c8d\u2c8f\u2c8f\u2c91" + + "\u2c91\u2c93\u2c93\u2c95\u2c95\u2c97\u2c97\u2c99\u2c99\u2c9b\u2c9b\u2c9d" + + "\u2c9d\u2c9f\u2c9f\u2ca1\u2ca1\u2ca3\u2ca3\u2ca5\u2ca5\u2ca7\u2ca7\u2ca9" + + "\u2ca9\u2cab\u2cab\u2cad\u2cad\u2caf\u2caf\u2cb1\u2cb1\u2cb3\u2cb3\u2cb5" + + "\u2cb5\u2cb7\u2cb7\u2cb9\u2cb9\u2cbb\u2cbb\u2cbd\u2cbd\u2cbf\u2cbf\u2cc1" + + "\u2cc1\u2cc3\u2cc3\u2cc5\u2cc5\u2cc7\u2cc7\u2cc9\u2cc9\u2ccb\u2ccb\u2ccd" + + "\u2ccd\u2ccf\u2ccf\u2cd1\u2cd1\u2cd3\u2cd3\u2cd5\u2cd5\u2cd7\u2cd7\u2cd9" + + "\u2cd9\u2cdb\u2cdb\u2cdd\u2cdd\u2cdf\u2cdf\u2ce1\u2ce1\u2ce3\u2ce3\u2ce5" + + "\u2ce6\u2cee\u2cee\u2cf0\u2cf0\u2cf5\u2cf5\u2d02\u2d27\u2d29\u2d29\u2d2f" + + "\u2d2f\ua643\ua643\ua645\ua645\ua647\ua647\ua649\ua649\ua64b\ua64b\ua64d" + + "\ua64d\ua64f\ua64f\ua651\ua651\ua653\ua653\ua655\ua655\ua657\ua657\ua659" + + "\ua659\ua65b\ua65b\ua65d\ua65d\ua65f\ua65f\ua661\ua661\ua663\ua663\ua665" + + "\ua665\ua667\ua667\ua669\ua669\ua66b\ua66b\ua66d\ua66d\ua66f\ua66f\ua683" + + "\ua683\ua685\ua685\ua687\ua687\ua689\ua689\ua68b\ua68b\ua68d\ua68d\ua68f" + + "\ua68f\ua691\ua691\ua693\ua693\ua695\ua695\ua697\ua697\ua699\ua699\ua725" + + "\ua725\ua727\ua727\ua729\ua729\ua72b\ua72b\ua72d\ua72d\ua72f\ua72f\ua731" + + "\ua733\ua735\ua735\ua737\ua737\ua739\ua739\ua73b\ua73b\ua73d\ua73d\ua73f" + + "\ua73f\ua741\ua741\ua743\ua743\ua745\ua745\ua747\ua747\ua749\ua749\ua74b" + + "\ua74b\ua74d\ua74d\ua74f\ua74f\ua751\ua751\ua753\ua753\ua755\ua755\ua757" + + "\ua757\ua759\ua759\ua75b\ua75b\ua75d\ua75d\ua75f\ua75f\ua761\ua761\ua763" + + "\ua763\ua765\ua765\ua767\ua767\ua769\ua769\ua76b\ua76b\ua76d\ua76d\ua76f" + + "\ua76f\ua771\ua771\ua773\ua77a\ua77c\ua77c\ua77e\ua77e\ua781\ua781\ua783" + + "\ua783\ua785\ua785\ua787\ua787\ua789\ua789\ua78e\ua78e\ua790\ua790\ua793" + + "\ua793\ua795\ua795\ua7a3\ua7a3\ua7a5\ua7a5\ua7a7\ua7a7\ua7a9\ua7a9\ua7ab" + + "\ua7ab\ua7fc\ua7fc\ufb02\ufb08\ufb15\ufb19\uff43\uff5c\65\2\u02b2\u02c3" + + "\u02c8\u02d3\u02e2\u02e6\u02ee\u02ee\u02f0\u02f0\u0376\u0376\u037c\u037c" + + "\u055b\u055b\u0642\u0642\u06e7\u06e8\u07f6\u07f7\u07fc\u07fc\u081c\u081c" + + "\u0826\u0826\u082a\u082a\u0973\u0973\u0e48\u0e48\u0ec8\u0ec8\u10fe\u10fe" + + "\u17d9\u17d9\u1845\u1845\u1aa9\u1aa9\u1c7a\u1c7f\u1d2e\u1d6c\u1d7a\u1d7a" + + "\u1d9d\u1dc1\u2073\u2073\u2081\u2081\u2092\u209e\u2c7e\u2c7f\u2d71\u2d71" + + "\u2e31\u2e31\u3007\u3007\u3033\u3037\u303d\u303d\u309f\u30a0\u30fe\u3100" + + "\ua017\ua017\ua4fa\ua4ff\ua60e\ua60e\ua681\ua681\ua719\ua721\ua772\ua772" + + "\ua78a\ua78a\ua7fa\ua7fb\ua9d1\ua9d1\uaa72\uaa72\uaadf\uaadf\uaaf5\uaaf6" + + "\uff72\uff72\uffa0\uffa1\u0123\2\u00ac\u00ac\u00bc\u00bc\u01bd\u01bd\u01c2" + + "\u01c5\u0296\u0296\u05d2\u05ec\u05f2\u05f4\u0622\u0641\u0643\u064c\u0670" + + "\u0671\u0673\u06d5\u06d7\u06d7\u06f0\u06f1\u06fc\u06fe\u0701\u0701\u0712" + + "\u0712\u0714\u0731\u074f\u07a7\u07b3\u07b3\u07cc\u07ec\u0802\u0817\u0842" + + "\u085a\u08a2\u08a2\u08a4\u08ae\u0906\u093b\u093f\u093f\u0952\u0952\u095a" + + "\u0963\u0974\u0979\u097b\u0981\u0987\u098e\u0991\u0992\u0995\u09aa\u09ac" + + "\u09b2\u09b4\u09b4\u09b8\u09bb\u09bf\u09bf\u09d0\u09d0\u09de\u09df\u09e1" + + "\u09e3\u09f2\u09f3\u0a07\u0a0c\u0a11\u0a12\u0a15\u0a2a\u0a2c\u0a32\u0a34" + + "\u0a35\u0a37\u0a38\u0a3a\u0a3b\u0a5b\u0a5e\u0a60\u0a60\u0a74\u0a76\u0a87" + + "\u0a8f\u0a91\u0a93\u0a95\u0aaa\u0aac\u0ab2\u0ab4\u0ab5\u0ab7\u0abb\u0abf" + + "\u0abf\u0ad2\u0ad2\u0ae2\u0ae3\u0b07\u0b0e\u0b11\u0b12\u0b15\u0b2a\u0b2c" + + "\u0b32\u0b34\u0b35\u0b37\u0b3b\u0b3f\u0b3f\u0b5e\u0b5f\u0b61\u0b63\u0b73" + + "\u0b73\u0b85\u0b85\u0b87\u0b8c\u0b90\u0b92\u0b94\u0b97\u0b9b\u0b9c\u0b9e" + + "\u0b9e\u0ba0\u0ba1\u0ba5\u0ba6\u0baa\u0bac\u0bb0\u0bbb\u0bd2\u0bd2\u0c07" + + "\u0c0e\u0c10\u0c12\u0c14\u0c2a\u0c2c\u0c35\u0c37\u0c3b\u0c3f\u0c3f\u0c5a" + + "\u0c5b\u0c62\u0c63\u0c87\u0c8e\u0c90\u0c92\u0c94\u0caa\u0cac\u0cb5\u0cb7" + + "\u0cbb\u0cbf\u0cbf\u0ce0\u0ce0\u0ce2\u0ce3\u0cf3\u0cf4\u0d07\u0d0e\u0d10" + + "\u0d12\u0d14\u0d3c\u0d3f\u0d3f\u0d50\u0d50\u0d62\u0d63\u0d7c\u0d81\u0d87" + + "\u0d98\u0d9c\u0db3\u0db5\u0dbd\u0dbf\u0dbf\u0dc2\u0dc8\u0e03\u0e32\u0e34" + + "\u0e35\u0e42\u0e47\u0e83\u0e84\u0e86\u0e86\u0e89\u0e8a\u0e8c\u0e8c\u0e8f" + + "\u0e8f\u0e96\u0e99\u0e9b\u0ea1\u0ea3\u0ea5\u0ea7\u0ea7\u0ea9\u0ea9\u0eac" + + "\u0ead\u0eaf\u0eb2\u0eb4\u0eb5\u0ebf\u0ebf\u0ec2\u0ec6\u0ede\u0ee1\u0f02" + + "\u0f02\u0f42\u0f49\u0f4b\u0f6e\u0f8a\u0f8e\u1002\u102c\u1041\u1041\u1052" + + "\u1057\u105c\u105f\u1063\u1063\u1067\u1068\u1070\u1072\u1077\u1083\u1090" + + "\u1090\u10d2\u10fc\u10ff\u124a\u124c\u124f\u1252\u1258\u125a\u125a\u125c" + + "\u125f\u1262\u128a\u128c\u128f\u1292\u12b2\u12b4\u12b7\u12ba\u12c0\u12c2" + + "\u12c2\u12c4\u12c7\u12ca\u12d8\u12da\u1312\u1314\u1317\u131a\u135c\u1382" + + "\u1391\u13a2\u13f6\u1403\u166e\u1671\u1681\u1683\u169c\u16a2\u16ec\u1702" + + "\u170e\u1710\u1713\u1722\u1733\u1742\u1753\u1762\u176e\u1770\u1772\u1782" + + "\u17b5\u17de\u17de\u1822\u1844\u1846\u1879\u1882\u18aa\u18ac\u18ac\u18b2" + + "\u18f7\u1902\u191e\u1952\u196f\u1972\u1976\u1982\u19ad\u19c3\u19c9\u1a02" + + "\u1a18\u1a22\u1a56\u1b07\u1b35\u1b47\u1b4d\u1b85\u1ba2\u1bb0\u1bb1\u1bbc" + + "\u1be7\u1c02\u1c25\u1c4f\u1c51\u1c5c\u1c79\u1ceb\u1cee\u1cf0\u1cf3\u1cf7" + + "\u1cf8\u2137\u213a\u2d32\u2d69\u2d82\u2d98\u2da2\u2da8\u2daa\u2db0\u2db2" + + "\u2db8\u2dba\u2dc0\u2dc2\u2dc8\u2dca\u2dd0\u2dd2\u2dd8\u2dda\u2de0\u3008" + + "\u3008\u303e\u303e\u3043\u3098\u30a1\u30a1\u30a3\u30fc\u3101\u3101\u3107" + + "\u312f\u3133\u3190\u31a2\u31bc\u31f2\u3201\u3402\u3402\u4db7\u4db7\u4e02" + + "\u4e02\u9fce\u9fce\ua002\ua016\ua018\ua48e\ua4d2\ua4f9\ua502\ua60d\ua612" + + "\ua621\ua62c\ua62d\ua670\ua670\ua6a2\ua6e7\ua7fd\ua803\ua805\ua807\ua809" + + "\ua80c\ua80e\ua824\ua842\ua875\ua884\ua8b5\ua8f4\ua8f9\ua8fd\ua8fd\ua90c" + + "\ua927\ua932\ua948\ua962\ua97e\ua986\ua9b4\uaa02\uaa2a\uaa42\uaa44\uaa46" + + "\uaa4d\uaa62\uaa71\uaa73\uaa78\uaa7c\uaa7c\uaa82\uaab1\uaab3\uaab3\uaab7" + + "\uaab8\uaabb\uaabf\uaac2\uaac2\uaac4\uaac4\uaadd\uaade\uaae2\uaaec\uaaf4" + + "\uaaf4\uab03\uab08\uab0b\uab10\uab13\uab18\uab22\uab28\uab2a\uab30\uabc2" + + "\uabe4\uac02\uac02\ud7a5\ud7a5\ud7b2\ud7c8\ud7cd\ud7fd\uf902\ufa6f\ufa72" + + "\ufadb\ufb1f\ufb1f\ufb21\ufb2a\ufb2c\ufb38\ufb3a\ufb3e\ufb40\ufb40\ufb42" + + "\ufb43\ufb45\ufb46\ufb48\ufbb3\ufbd5\ufd3f\ufd52\ufd91\ufd94\ufdc9\ufdf2" + + "\ufdfd\ufe72\ufe76\ufe78\ufefe\uff68\uff71\uff73\uff9f\uffa2\uffc0\uffc4" + + "\uffc9\uffcc\uffd1\uffd4\uffd9\uffdc\uffde\f\2\u01c7\u01c7\u01ca\u01ca" + + "\u01cd\u01cd\u01f4\u01f4\u1f8a\u1f91\u1f9a\u1fa1\u1faa\u1fb1\u1fbe\u1fbe" + + "\u1fce\u1fce\u1ffe\u1ffe\u0242\2C\\\u00c2\u00d8\u00da\u00e0\u0102\u0102" + + "\u0104\u0104\u0106\u0106\u0108\u0108\u010a\u010a\u010c\u010c\u010e\u010e" + + "\u0110\u0110\u0112\u0112\u0114\u0114\u0116\u0116\u0118\u0118\u011a\u011a" + + "\u011c\u011c\u011e\u011e\u0120\u0120\u0122\u0122\u0124\u0124\u0126\u0126" + + "\u0128\u0128\u012a\u012a\u012c\u012c\u012e\u012e\u0130\u0130\u0132\u0132" + + "\u0134\u0134\u0136\u0136\u0138\u0138\u013b\u013b\u013d\u013d\u013f\u013f" + + "\u0141\u0141\u0143\u0143\u0145\u0145\u0147\u0147\u0149\u0149\u014c\u014c" + + "\u014e\u014e\u0150\u0150\u0152\u0152\u0154\u0154\u0156\u0156\u0158\u0158" + + "\u015a\u015a\u015c\u015c\u015e\u015e\u0160\u0160\u0162\u0162\u0164\u0164" + + "\u0166\u0166\u0168\u0168\u016a\u016a\u016c\u016c\u016e\u016e\u0170\u0170" + + "\u0172\u0172\u0174\u0174\u0176\u0176\u0178\u0178\u017a\u017b\u017d\u017d" + + "\u017f\u017f\u0183\u0184\u0186\u0186\u0188\u0189\u018b\u018d\u0190\u0193" + + "\u0195\u0196\u0198\u019a\u019e\u019f\u01a1\u01a2\u01a4\u01a4\u01a6\u01a6" + + "\u01a8\u01a9\u01ab\u01ab\u01ae\u01ae\u01b0\u01b1\u01b3\u01b5\u01b7\u01b7" + + "\u01b9\u01ba\u01be\u01be\u01c6\u01c6\u01c9\u01c9\u01cc\u01cc\u01cf\u01cf" + + "\u01d1\u01d1\u01d3\u01d3\u01d5\u01d5\u01d7\u01d7\u01d9\u01d9\u01db\u01db" + + "\u01dd\u01dd\u01e0\u01e0\u01e2\u01e2\u01e4\u01e4\u01e6\u01e6\u01e8\u01e8" + + "\u01ea\u01ea\u01ec\u01ec\u01ee\u01ee\u01f0\u01f0\u01f3\u01f3\u01f6\u01f6" + + "\u01f8\u01fa\u01fc\u01fc\u01fe\u01fe\u0200\u0200\u0202\u0202\u0204\u0204" + + "\u0206\u0206\u0208\u0208\u020a\u020a\u020c\u020c\u020e\u020e\u0210\u0210" + + "\u0212\u0212\u0214\u0214\u0216\u0216\u0218\u0218\u021a\u021a\u021c\u021c" + + "\u021e\u021e\u0220\u0220\u0222\u0222\u0224\u0224\u0226\u0226\u0228\u0228" + + "\u022a\u022a\u022c\u022c\u022e\u022e\u0230\u0230\u0232\u0232\u0234\u0234" + + "\u023c\u023d\u023f\u0240\u0243\u0243\u0245\u0248\u024a\u024a\u024c\u024c" + + "\u024e\u024e\u0250\u0250\u0372\u0372\u0374\u0374\u0378\u0378\u0388\u0388" + + "\u038a\u038c\u038e\u038e\u0390\u0391\u0393\u03a3\u03a5\u03ad\u03d1\u03d1" + + "\u03d4\u03d6\u03da\u03da\u03dc\u03dc\u03de\u03de\u03e0\u03e0\u03e2\u03e2" + + "\u03e4\u03e4\u03e6\u03e6\u03e8\u03e8\u03ea\u03ea\u03ec\u03ec\u03ee\u03ee" + + "\u03f0\u03f0\u03f6\u03f6\u03f9\u03f9\u03fb\u03fc\u03ff\u0431\u0462\u0462" + + "\u0464\u0464\u0466\u0466\u0468\u0468\u046a\u046a\u046c\u046c\u046e\u046e" + + "\u0470\u0470\u0472\u0472\u0474\u0474\u0476\u0476\u0478\u0478\u047a\u047a" + + "\u047c\u047c\u047e\u047e\u0480\u0480\u0482\u0482\u048c\u048c\u048e\u048e" + + "\u0490\u0490\u0492\u0492\u0494\u0494\u0496\u0496\u0498\u0498\u049a\u049a" + + "\u049c\u049c\u049e\u049e\u04a0\u04a0\u04a2\u04a2\u04a4\u04a4\u04a6\u04a6" + + "\u04a8\u04a8\u04aa\u04aa\u04ac\u04ac\u04ae\u04ae\u04b0\u04b0\u04b2\u04b2" + + "\u04b4\u04b4\u04b6\u04b6\u04b8\u04b8\u04ba\u04ba\u04bc\u04bc\u04be\u04be" + + "\u04c0\u04c0\u04c2\u04c3\u04c5\u04c5\u04c7\u04c7\u04c9\u04c9\u04cb\u04cb" + + "\u04cd\u04cd\u04cf\u04cf\u04d2\u04d2\u04d4\u04d4\u04d6\u04d6\u04d8\u04d8" + + "\u04da\u04da\u04dc\u04dc\u04de\u04de\u04e0\u04e0\u04e2\u04e2\u04e4\u04e4" + + "\u04e6\u04e6\u04e8\u04e8\u04ea\u04ea\u04ec\u04ec\u04ee\u04ee\u04f0\u04f0" + + "\u04f2\u04f2\u04f4\u04f4\u04f6\u04f6\u04f8\u04f8\u04fa\u04fa\u04fc\u04fc" + + "\u04fe\u04fe\u0500\u0500\u0502\u0502\u0504\u0504\u0506\u0506\u0508\u0508" + + "\u050a\u050a\u050c\u050c\u050e\u050e\u0510\u0510\u0512\u0512\u0514\u0514" + + "\u0516\u0516\u0518\u0518\u051a\u051a\u051c\u051c\u051e\u051e\u0520\u0520" + + "\u0522\u0522\u0524\u0524\u0526\u0526\u0528\u0528\u0533\u0558\u10a2\u10c7" + + "\u10c9\u10c9\u10cf\u10cf\u1e02\u1e02\u1e04\u1e04\u1e06\u1e06\u1e08\u1e08" + + "\u1e0a\u1e0a\u1e0c\u1e0c\u1e0e\u1e0e\u1e10\u1e10\u1e12\u1e12\u1e14\u1e14" + + "\u1e16\u1e16\u1e18\u1e18\u1e1a\u1e1a\u1e1c\u1e1c\u1e1e\u1e1e\u1e20\u1e20" + + "\u1e22\u1e22\u1e24\u1e24\u1e26\u1e26\u1e28\u1e28\u1e2a\u1e2a\u1e2c\u1e2c" + + "\u1e2e\u1e2e\u1e30\u1e30\u1e32\u1e32\u1e34\u1e34\u1e36\u1e36\u1e38\u1e38" + + "\u1e3a\u1e3a\u1e3c\u1e3c\u1e3e\u1e3e\u1e40\u1e40\u1e42\u1e42\u1e44\u1e44" + + "\u1e46\u1e46\u1e48\u1e48\u1e4a\u1e4a\u1e4c\u1e4c\u1e4e\u1e4e\u1e50\u1e50" + + "\u1e52\u1e52\u1e54\u1e54\u1e56\u1e56\u1e58\u1e58\u1e5a\u1e5a\u1e5c\u1e5c" + + "\u1e5e\u1e5e\u1e60\u1e60\u1e62\u1e62\u1e64\u1e64\u1e66\u1e66\u1e68\u1e68" + + "\u1e6a\u1e6a\u1e6c\u1e6c\u1e6e\u1e6e\u1e70\u1e70\u1e72\u1e72\u1e74\u1e74" + + "\u1e76\u1e76\u1e78\u1e78\u1e7a\u1e7a\u1e7c\u1e7c\u1e7e\u1e7e\u1e80\u1e80" + + "\u1e82\u1e82\u1e84\u1e84\u1e86\u1e86\u1e88\u1e88\u1e8a\u1e8a\u1e8c\u1e8c" + + "\u1e8e\u1e8e\u1e90\u1e90\u1e92\u1e92\u1e94\u1e94\u1e96\u1e96\u1ea0\u1ea0" + + "\u1ea2\u1ea2\u1ea4\u1ea4\u1ea6\u1ea6\u1ea8\u1ea8\u1eaa\u1eaa\u1eac\u1eac" + + "\u1eae\u1eae\u1eb0\u1eb0\u1eb2\u1eb2\u1eb4\u1eb4\u1eb6\u1eb6\u1eb8\u1eb8" + + "\u1eba\u1eba\u1ebc\u1ebc\u1ebe\u1ebe\u1ec0\u1ec0\u1ec2\u1ec2\u1ec4\u1ec4" + + "\u1ec6\u1ec6\u1ec8\u1ec8\u1eca\u1eca\u1ecc\u1ecc\u1ece\u1ece\u1ed0\u1ed0" + + "\u1ed2\u1ed2\u1ed4\u1ed4\u1ed6\u1ed6\u1ed8\u1ed8\u1eda\u1eda\u1edc\u1edc" + + "\u1ede\u1ede\u1ee0\u1ee0\u1ee2\u1ee2\u1ee4\u1ee4\u1ee6\u1ee6\u1ee8\u1ee8" + + "\u1eea\u1eea\u1eec\u1eec\u1eee\u1eee\u1ef0\u1ef0\u1ef2\u1ef2\u1ef4\u1ef4" + + "\u1ef6\u1ef6\u1ef8\u1ef8\u1efa\u1efa\u1efc\u1efc\u1efe\u1efe\u1f00\u1f00" + + "\u1f0a\u1f11\u1f1a\u1f1f\u1f2a\u1f31\u1f3a\u1f41\u1f4a\u1f4f\u1f5b\u1f5b" + + "\u1f5d\u1f5d\u1f5f\u1f5f\u1f61\u1f61\u1f6a\u1f71\u1fba\u1fbd\u1fca\u1fcd" + + "\u1fda\u1fdd\u1fea\u1fee\u1ffa\u1ffd\u2104\u2104\u2109\u2109\u210d\u210f" + + "\u2112\u2114\u2117\u2117\u211b\u211f\u2126\u2126\u2128\u2128\u212a\u212a" + + "\u212c\u212f\u2132\u2135\u2140\u2141\u2147\u2147\u2185\u2185\u2c02\u2c30" + + "\u2c62\u2c62\u2c64\u2c66\u2c69\u2c69\u2c6b\u2c6b\u2c6d\u2c6d\u2c6f\u2c72" + + "\u2c74\u2c74\u2c77\u2c77\u2c80\u2c82\u2c84\u2c84\u2c86\u2c86\u2c88\u2c88" + + "\u2c8a\u2c8a\u2c8c\u2c8c\u2c8e\u2c8e\u2c90\u2c90\u2c92\u2c92\u2c94\u2c94" + + "\u2c96\u2c96\u2c98\u2c98\u2c9a\u2c9a\u2c9c\u2c9c\u2c9e\u2c9e\u2ca0\u2ca0" + + "\u2ca2\u2ca2\u2ca4\u2ca4\u2ca6\u2ca6\u2ca8\u2ca8\u2caa\u2caa\u2cac\u2cac" + + "\u2cae\u2cae\u2cb0\u2cb0\u2cb2\u2cb2\u2cb4\u2cb4\u2cb6\u2cb6\u2cb8\u2cb8" + + "\u2cba\u2cba\u2cbc\u2cbc\u2cbe\u2cbe\u2cc0\u2cc0\u2cc2\u2cc2\u2cc4\u2cc4" + + "\u2cc6\u2cc6\u2cc8\u2cc8\u2cca\u2cca\u2ccc\u2ccc\u2cce\u2cce\u2cd0\u2cd0" + + "\u2cd2\u2cd2\u2cd4\u2cd4\u2cd6\u2cd6\u2cd8\u2cd8\u2cda\u2cda\u2cdc\u2cdc" + + "\u2cde\u2cde\u2ce0\u2ce0\u2ce2\u2ce2\u2ce4\u2ce4\u2ced\u2ced\u2cef\u2cef" + + "\u2cf4\u2cf4\ua642\ua642\ua644\ua644\ua646\ua646\ua648\ua648\ua64a\ua64a" + + "\ua64c\ua64c\ua64e\ua64e\ua650\ua650\ua652\ua652\ua654\ua654\ua656\ua656" + + "\ua658\ua658\ua65a\ua65a\ua65c\ua65c\ua65e\ua65e\ua660\ua660\ua662\ua662" + + "\ua664\ua664\ua666\ua666\ua668\ua668\ua66a\ua66a\ua66c\ua66c\ua66e\ua66e" + + "\ua682\ua682\ua684\ua684\ua686\ua686\ua688\ua688\ua68a\ua68a\ua68c\ua68c" + + "\ua68e\ua68e\ua690\ua690\ua692\ua692\ua694\ua694\ua696\ua696\ua698\ua698" + + "\ua724\ua724\ua726\ua726\ua728\ua728\ua72a\ua72a\ua72c\ua72c\ua72e\ua72e" + + "\ua730\ua730\ua734\ua734\ua736\ua736\ua738\ua738\ua73a\ua73a\ua73c\ua73c" + + "\ua73e\ua73e\ua740\ua740\ua742\ua742\ua744\ua744\ua746\ua746\ua748\ua748" + + "\ua74a\ua74a\ua74c\ua74c\ua74e\ua74e\ua750\ua750\ua752\ua752\ua754\ua754" + + "\ua756\ua756\ua758\ua758\ua75a\ua75a\ua75c\ua75c\ua75e\ua75e\ua760\ua760" + + "\ua762\ua762\ua764\ua764\ua766\ua766\ua768\ua768\ua76a\ua76a\ua76c\ua76c" + + "\ua76e\ua76e\ua770\ua770\ua77b\ua77b\ua77d\ua77d\ua77f\ua780\ua782\ua782" + + "\ua784\ua784\ua786\ua786\ua788\ua788\ua78d\ua78d\ua78f\ua78f\ua792\ua792" + + "\ua794\ua794\ua7a2\ua7a2\ua7a4\ua7a4\ua7a6\ua7a6\ua7a8\ua7a8\ua7aa\ua7aa" + + "\ua7ac\ua7ac\uff23\uff3c%\2\62;\u0662\u066b\u06f2\u06fb\u07c2\u07cb\u0968" + + "\u0971\u09e8\u09f1\u0a68\u0a71\u0ae8\u0af1\u0b68\u0b71\u0be8\u0bf1\u0c68" + + "\u0c71\u0ce8\u0cf1\u0d68\u0d71\u0e52\u0e5b\u0ed2\u0edb\u0f22\u0f2b\u1042" + + "\u104b\u1092\u109b\u17e2\u17eb\u1812\u181b\u1948\u1951\u19d2\u19db\u1a82" + + "\u1a8b\u1a92\u1a9b\u1b52\u1b5b\u1bb2\u1bbb\u1c42\u1c4b\u1c52\u1c5b\ua622" + + "\ua62b\ua8d2\ua8db\ua902\ua90b\ua9d2\ua9db\uaa52\uaa5b\uabf2\uabfb\uff12" + + "\uff1b\t\2\u16f0\u16f2\u2162\u2184\u2187\u218a\u3009\u3009\u3023\u302b" + + "\u303a\u303c\ua6e8\ua6f1\5\2$$&&^^\4\2$$&&\2\u090d\2\6\3\2\2\2\2\b\3\2" + + "\2\2\2\n\3\2\2\2\2\f\3\2\2\2\2\16\3\2\2\2\2\22\3\2\2\2\2\24\3\2\2\2\2" + + "\26\3\2\2\2\2\30\3\2\2\2\2\32\3\2\2\2\2\34\3\2\2\2\2\36\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\60\3\2\2\2\2\62\3\2\2\2\2\64\3\2\2\2\2\66\3\2\2\2\28\3" + + "\2\2\2\2:\3\2\2\2\2<\3\2\2\2\2>\3\2\2\2\2@\3\2\2\2\2B\3\2\2\2\2D\3\2\2" + + "\2\2F\3\2\2\2\2H\3\2\2\2\2J\3\2\2\2\2L\3\2\2\2\2N\3\2\2\2\2P\3\2\2\2\2" + + "R\3\2\2\2\2T\3\2\2\2\2V\3\2\2\2\2X\3\2\2\2\2Z\3\2\2\2\2\\\3\2\2\2\2^\3" + + "\2\2\2\2`\3\2\2\2\2b\3\2\2\2\2d\3\2\2\2\2f\3\2\2\2\2h\3\2\2\2\2j\3\2\2" + + "\2\2l\3\2\2\2\2n\3\2\2\2\2p\3\2\2\2\2r\3\2\2\2\2t\3\2\2\2\2v\3\2\2\2\2" + + "x\3\2\2\2\2z\3\2\2\2\2|\3\2\2\2\2~\3\2\2\2\2\u0080\3\2\2\2\2\u0082\3\2" + + "\2\2\2\u0084\3\2\2\2\2\u0086\3\2\2\2\2\u0088\3\2\2\2\2\u008a\3\2\2\2\2" + + "\u008c\3\2\2\2\2\u008e\3\2\2\2\2\u0090\3\2\2\2\2\u0092\3\2\2\2\2\u0094" + + "\3\2\2\2\2\u0096\3\2\2\2\2\u0098\3\2\2\2\2\u009a\3\2\2\2\2\u009c\3\2\2" + + "\2\2\u009e\3\2\2\2\2\u00a0\3\2\2\2\2\u00a2\3\2\2\2\2\u00a4\3\2\2\2\2\u00a6" + + "\3\2\2\2\2\u00a8\3\2\2\2\2\u00aa\3\2\2\2\2\u00ac\3\2\2\2\2\u00ae\3\2\2" + + "\2\2\u00b0\3\2\2\2\2\u00b2\3\2\2\2\2\u00b4\3\2\2\2\2\u00b6\3\2\2\2\2\u00b8" + + "\3\2\2\2\2\u00ba\3\2\2\2\2\u00bc\3\2\2\2\2\u00be\3\2\2\2\2\u00c0\3\2\2" + + "\2\2\u00c2\3\2\2\2\2\u00c4\3\2\2\2\2\u00c6\3\2\2\2\2\u00c8\3\2\2\2\2\u00ca" + + "\3\2\2\2\2\u00cc\3\2\2\2\2\u00ce\3\2\2\2\2\u00d0\3\2\2\2\2\u00d2\3\2\2" + + "\2\2\u00d4\3\2\2\2\2\u00d6\3\2\2\2\2\u00d8\3\2\2\2\2\u00da\3\2\2\2\2\u00dc" + + "\3\2\2\2\2\u00de\3\2\2\2\2\u00e0\3\2\2\2\2\u00e2\3\2\2\2\2\u00e4\3\2\2" + + "\2\2\u00e6\3\2\2\2\2\u00e8\3\2\2\2\2\u00ea\3\2\2\2\2\u00ec\3\2\2\2\2\u00ee" + + "\3\2\2\2\2\u00f0\3\2\2\2\2\u00f2\3\2\2\2\2\u00f4\3\2\2\2\2\u00f6\3\2\2" + + "\2\2\u00f8\3\2\2\2\2\u00fa\3\2\2\2\2\u00fc\3\2\2\2\2\u00fe\3\2\2\2\2\u0100" + + "\3\2\2\2\2\u0102\3\2\2\2\2\u0104\3\2\2\2\2\u0106\3\2\2\2\2\u0108\3\2\2" + + "\2\2\u010a\3\2\2\2\2\u010c\3\2\2\2\2\u010e\3\2\2\2\2\u0110\3\2\2\2\2\u0112" + + "\3\2\2\2\2\u011e\3\2\2\2\2\u0120\3\2\2\2\2\u0122\3\2\2\2\2\u0124\3\2\2" + + "\2\2\u012a\3\2\2\2\2\u0130\3\2\2\2\2\u0132\3\2\2\2\2\u0134\3\2\2\2\2\u0136" + + "\3\2\2\2\2\u0138\3\2\2\2\2\u013a\3\2\2\2\2\u013e\3\2\2\2\2\u0140\3\2\2" + + "\2\2\u0142\3\2\2\2\2\u014c\3\2\2\2\2\u014e\3\2\2\2\2\u0150\3\2\2\2\2\u0152" + + "\3\2\2\2\2\u0154\3\2\2\2\2\u0156\3\2\2\2\2\u0158\3\2\2\2\2\u015a\3\2\2" + + "\2\2\u015c\3\2\2\2\2\u0274\3\2\2\2\3\u015e\3\2\2\2\3\u0160\3\2\2\2\3\u0162" + + "\3\2\2\2\3\u0164\3\2\2\2\3\u0166\3\2\2\2\4\u0168\3\2\2\2\4\u016a\3\2\2" + + "\2\4\u016c\3\2\2\2\4\u016e\3\2\2\2\4\u0170\3\2\2\2\5\u0172\3\2\2\2\5\u0174" + + "\3\2\2\2\5\u0176\3\2\2\2\5\u0178\3\2\2\2\5\u017a\3\2\2\2\5\u017c\3\2\2" + + "\2\5\u017e\3\2\2\2\5\u0180\3\2\2\2\5\u0182\3\2\2\2\5\u0184\3\2\2\2\5\u0186" + + "\3\2\2\2\5\u0188\3\2\2\2\5\u018a\3\2\2\2\5\u018c\3\2\2\2\5\u018e\3\2\2" + + "\2\5\u0190\3\2\2\2\5\u0192\3\2\2\2\5\u0194\3\2\2\2\5\u0196\3\2\2\2\5\u0198" + + "\3\2\2\2\5\u019a\3\2\2\2\5\u019c\3\2\2\2\5\u019e\3\2\2\2\5\u01a0\3\2\2" + + "\2\5\u01a2\3\2\2\2\5\u01a4\3\2\2\2\5\u01a6\3\2\2\2\5\u01a8\3\2\2\2\5\u01aa" + + "\3\2\2\2\5\u01ac\3\2\2\2\5\u01ae\3\2\2\2\5\u01b0\3\2\2\2\5\u01b2\3\2\2" + + "\2\5\u01b4\3\2\2\2\5\u01b6\3\2\2\2\5\u01b8\3\2\2\2\5\u01ba\3\2\2\2\5\u01bc" + + "\3\2\2\2\5\u01be\3\2\2\2\5\u01c0\3\2\2\2\5\u01c2\3\2\2\2\5\u01c4\3\2\2" + + "\2\5\u01c6\3\2\2\2\5\u01c8\3\2\2\2\5\u01ca\3\2\2\2\5\u01cc\3\2\2\2\5\u01ce" + + "\3\2\2\2\5\u01d0\3\2\2\2\5\u01d2\3\2\2\2\5\u01d4\3\2\2\2\5\u01d6\3\2\2" + + "\2\5\u01d8\3\2\2\2\5\u01da\3\2\2\2\5\u01dc\3\2\2\2\5\u01de\3\2\2\2\5\u01e0" + + "\3\2\2\2\5\u01e2\3\2\2\2\5\u01e4\3\2\2\2\5\u01e6\3\2\2\2\5\u01e8\3\2\2" + + "\2\5\u01ea\3\2\2\2\5\u01ec\3\2\2\2\5\u01ee\3\2\2\2\5\u01f0\3\2\2\2\5\u01f2" + + "\3\2\2\2\5\u01f4\3\2\2\2\5\u01f6\3\2\2\2\5\u01f8\3\2\2\2\5\u01fa\3\2\2" + + "\2\5\u01fc\3\2\2\2\5\u01fe\3\2\2\2\5\u0200\3\2\2\2\5\u0202\3\2\2\2\5\u0204" + + "\3\2\2\2\5\u0206\3\2\2\2\5\u0208\3\2\2\2\5\u020a\3\2\2\2\5\u020c\3\2\2" + + "\2\5\u020e\3\2\2\2\5\u0210\3\2\2\2\5\u0212\3\2\2\2\5\u0214\3\2\2\2\5\u0216" + + "\3\2\2\2\5\u0218\3\2\2\2\5\u021a\3\2\2\2\5\u021c\3\2\2\2\5\u021e\3\2\2" + + "\2\5\u0220\3\2\2\2\5\u0222\3\2\2\2\5\u0224\3\2\2\2\5\u0226\3\2\2\2\5\u0228" + + "\3\2\2\2\5\u022a\3\2\2\2\5\u022c\3\2\2\2\5\u022e\3\2\2\2\5\u0230\3\2\2" + + "\2\5\u0232\3\2\2\2\5\u0234\3\2\2\2\5\u0236\3\2\2\2\5\u0238\3\2\2\2\5\u023a" + + "\3\2\2\2\5\u023c\3\2\2\2\5\u023e\3\2\2\2\5\u0240\3\2\2\2\5\u0242\3\2\2" + + "\2\5\u0244\3\2\2\2\5\u0246\3\2\2\2\5\u0248\3\2\2\2\5\u024a\3\2\2\2\5\u024c" + + "\3\2\2\2\5\u024e\3\2\2\2\5\u0250\3\2\2\2\5\u0252\3\2\2\2\5\u0254\3\2\2" + + "\2\5\u0256\3\2\2\2\5\u0258\3\2\2\2\5\u025a\3\2\2\2\5\u025c\3\2\2\2\5\u025e" + + "\3\2\2\2\5\u0260\3\2\2\2\5\u0262\3\2\2\2\5\u0264\3\2\2\2\5\u0266\3\2\2" + + "\2\5\u0268\3\2\2\2\5\u026a\3\2\2\2\5\u026c\3\2\2\2\5\u026e\3\2\2\2\5\u0270" + + "\3\2\2\2\5\u0272\3\2\2\2\6\u0276\3\2\2\2\b\u027f\3\2\2\2\n\u028e\3\2\2" + + "\2\f\u0299\3\2\2\2\16\u02a2\3\2\2\2\20\u02a7\3\2\2\2\22\u02a9\3\2\2\2" + + "\24\u02ad\3\2\2\2\26\u02af\3\2\2\2\30\u02b1\3\2\2\2\32\u02b5\3\2\2\2\34" + + "\u02b7\3\2\2\2\36\u02bb\3\2\2\2 \u02bd\3\2\2\2\"\u02c1\3\2\2\2$\u02c4" + + "\3\2\2\2&\u02c6\3\2\2\2(\u02c8\3\2\2\2*\u02ca\3\2\2\2,\u02cc\3\2\2\2." + + "\u02ce\3\2\2\2\60\u02d1\3\2\2\2\62\u02d4\3\2\2\2\64\u02d7\3\2\2\2\66\u02da" + + "\3\2\2\28\u02dd\3\2\2\2:\u02df\3\2\2\2<\u02e1\3\2\2\2>\u02e3\3\2\2\2@" + + "\u02e5\3\2\2\2B\u02e8\3\2\2\2D\u02eb\3\2\2\2F\u02ee\3\2\2\2H\u02f1\3\2" + + "\2\2J\u02f4\3\2\2\2L\u02f7\3\2\2\2N\u02fa\3\2\2\2P\u02fd\3\2\2\2R\u0300" + + "\3\2\2\2T\u0303\3\2\2\2V\u0305\3\2\2\2X\u0307\3\2\2\2Z\u030e\3\2\2\2\\" + + "\u0314\3\2\2\2^\u031b\3\2\2\2`\u031e\3\2\2\2b\u0320\3\2\2\2d\u0322\3\2" + + "\2\2f\u0324\3\2\2\2h\u0327\3\2\2\2j\u032a\3\2\2\2l\u032d\3\2\2\2n\u0331" + + "\3\2\2\2p\u0335\3\2\2\2r\u0338\3\2\2\2t\u033c\3\2\2\2v\u033e\3\2\2\2x" + + "\u0348\3\2\2\2z\u0354\3\2\2\2|\u035d\3\2\2\2~\u0365\3\2\2\2\u0080\u036e" + + "\3\2\2\2\u0082\u0373\3\2\2\2\u0084\u0379\3\2\2\2\u0086\u0382\3\2\2\2\u0088" + + "\u0386\3\2\2\2\u008a\u038a\3\2\2\2\u008c\u0393\3\2\2\2\u008e\u0399\3\2" + + "\2\2\u0090\u03a2\3\2\2\2\u0092\u03ab\3\2\2\2\u0094\u03b3\3\2\2\2\u0096" + + "\u03ba\3\2\2\2\u0098\u03c0\3\2\2\2\u009a\u03ca\3\2\2\2\u009c\u03ce\3\2" + + "\2\2\u009e\u03d5\3\2\2\2\u00a0\u03d9\3\2\2\2\u00a2\u03dd\3\2\2\2\u00a4" + + "\u03e7\3\2\2\2\u00a6\u03f3\3\2\2\2\u00a8\u03f6\3\2\2\2\u00aa\u0400\3\2" + + "\2\2\u00ac\u0405\3\2\2\2\u00ae\u040a\3\2\2\2\u00b0\u0410\3\2\2\2\u00b2" + + "\u0417\3\2\2\2\u00b4\u041d\3\2\2\2\u00b6\u0420\3\2\2\2\u00b8\u0425\3\2" + + "\2\2\u00ba\u042a\3\2\2\2\u00bc\u042e\3\2\2\2\u00be\u0434\3\2\2\2\u00c0" + + "\u043c\3\2\2\2\u00c2\u0440\3\2\2\2\u00c4\u0443\3\2\2\2\u00c6\u0449\3\2" + + "\2\2\u00c8\u044f\3\2\2\2\u00ca\u0456\3\2\2\2\u00cc\u045f\3\2\2\2\u00ce" + + "\u0465\3\2\2\2\u00d0\u0468\3\2\2\2\u00d2\u046b\3\2\2\2\u00d4\u046e\3\2" + + "\2\2\u00d6\u0476\3\2\2\2\u00d8\u047e\3\2\2\2\u00da\u0482\3\2\2\2\u00dc" + + "\u048a\3\2\2\2\u00de\u0491\3\2\2\2\u00e0\u0499\3\2\2\2\u00e2\u04a3\3\2" + + "\2\2\u00e4\u04ac\3\2\2\2\u00e6\u04b1\3\2\2\2\u00e8\u04b8\3\2\2\2\u00ea" + + "\u04c3\3\2\2\2\u00ec\u04c8\3\2\2\2\u00ee\u04ce\3\2\2\2\u00f0\u04d4\3\2" + + "\2\2\u00f2\u04dc\3\2\2\2\u00f4\u04e5\3\2\2\2\u00f6\u04ec\3\2\2\2\u00f8" + + "\u04f2\3\2\2\2\u00fa\u04fb\3\2\2\2\u00fc\u0503\3\2\2\2\u00fe\u050c\3\2" + + "\2\2\u0100\u0515\3\2\2\2\u0102\u051b\3\2\2\2\u0104\u0520\3\2\2\2\u0106" + + "\u0526\3\2\2\2\u0108\u052f\3\2\2\2\u010a\u0536\3\2\2\2\u010c\u053f\3\2" + + "\2\2\u010e\u054b\3\2\2\2\u0110\u0553\3\2\2\2\u0112\u055a\3\2\2\2\u0114" + + "\u0561\3\2\2\2\u0116\u0563\3\2\2\2\u0118\u0567\3\2\2\2\u011a\u0573\3\2" + + "\2\2\u011c\u0575\3\2\2\2\u011e\u057d\3\2\2\2\u0120\u0585\3\2\2\2\u0122" + + "\u0592\3\2\2\2\u0124\u059e\3\2\2\2\u0126\u05a0\3\2\2\2\u0128\u05a4\3\2" + + "\2\2\u012a\u05b4\3\2\2\2\u012c\u05b6\3\2\2\2\u012e\u05ba\3\2\2\2\u0130" + + "\u05ca\3\2\2\2\u0132\u05cf\3\2\2\2\u0134\u05d8\3\2\2\2\u0136\u05e5\3\2" + + "\2\2\u0138\u05e7\3\2\2\2\u013a\u05ec\3\2\2\2\u013c\u05f3\3\2\2\2\u013e" + + "\u0608\3\2\2\2\u0140\u063a\3\2\2\2\u0142\u063c\3\2\2\2\u0144\u063f\3\2" + + "\2\2\u0146\u0646\3\2\2\2\u0148\u064b\3\2\2\2\u014a\u0652\3\2\2\2\u014c" + + "\u0654\3\2\2\2\u014e\u0658\3\2\2\2\u0150\u065e\3\2\2\2\u0152\u0660\3\2" + + "\2\2\u0154\u0662\3\2\2\2\u0156\u0664\3\2\2\2\u0158\u0666\3\2\2\2\u015a" + + "\u0668\3\2\2\2\u015c\u066a\3\2\2\2\u015e\u066c\3\2\2\2\u0160\u0670\3\2" + + "\2\2\u0162\u0678\3\2\2\2\u0164\u067c\3\2\2\2\u0166\u067e\3\2\2\2\u0168" + + "\u0684\3\2\2\2\u016a\u068d\3\2\2\2\u016c\u0691\3\2\2\2\u016e\u0699\3\2" + + "\2\2\u0170\u069b\3\2\2\2\u0172\u06a0\3\2\2\2\u0174\u06a5\3\2\2\2\u0176" + + "\u06aa\3\2\2\2\u0178\u06af\3\2\2\2\u017a\u06b4\3\2\2\2\u017c\u06b9\3\2" + + "\2\2\u017e\u06be\3\2\2\2\u0180\u06c2\3\2\2\2\u0182\u06c6\3\2\2\2\u0184" + + "\u06ca\3\2\2\2\u0186\u06ce\3\2\2\2\u0188\u06d2\3\2\2\2\u018a\u06d6\3\2" + + "\2\2\u018c\u06da\3\2\2\2\u018e\u06de\3\2\2\2\u0190\u06e2\3\2\2\2\u0192" + + "\u06e6\3\2\2\2\u0194\u06ea\3\2\2\2\u0196\u06f1\3\2\2\2\u0198\u06f5\3\2" + + "\2\2\u019a\u06f9\3\2\2\2\u019c\u06fd\3\2\2\2\u019e\u0701\3\2\2\2\u01a0" + + "\u0705\3\2\2\2\u01a2\u0709\3\2\2\2\u01a4\u070d\3\2\2\2\u01a6\u0711\3\2" + + "\2\2\u01a8\u0715\3\2\2\2\u01aa\u0719\3\2\2\2\u01ac\u071d\3\2\2\2\u01ae" + + "\u0721\3\2\2\2\u01b0\u0725\3\2\2\2\u01b2\u0729\3\2\2\2\u01b4\u072d\3\2" + + "\2\2\u01b6\u0731\3\2\2\2\u01b8\u0735\3\2\2\2\u01ba\u0739\3\2\2\2\u01bc" + + "\u073d\3\2\2\2\u01be\u0741\3\2\2\2\u01c0\u0748\3\2\2\2\u01c2\u074c\3\2" + + "\2\2\u01c4\u0750\3\2\2\2\u01c6\u0754\3\2\2\2\u01c8\u0758\3\2\2\2\u01ca" + + "\u075c\3\2\2\2\u01cc\u0760\3\2\2\2\u01ce\u0764\3\2\2\2\u01d0\u0768\3\2" + + "\2\2\u01d2\u076c\3\2\2\2\u01d4\u0770\3\2\2\2\u01d6\u0774\3\2\2\2\u01d8" + + "\u0778\3\2\2\2\u01da\u077c\3\2\2\2\u01dc\u0780\3\2\2\2\u01de\u0784\3\2" + + "\2\2\u01e0\u0789\3\2\2\2\u01e2\u078e\3\2\2\2\u01e4\u0792\3\2\2\2\u01e6" + + "\u0796\3\2\2\2\u01e8\u079a\3\2\2\2\u01ea\u079e\3\2\2\2\u01ec\u07a2\3\2" + + "\2\2\u01ee\u07a6\3\2\2\2\u01f0\u07aa\3\2\2\2\u01f2\u07ae\3\2\2\2\u01f4" + + "\u07b2\3\2\2\2\u01f6\u07b6\3\2\2\2\u01f8\u07ba\3\2\2\2\u01fa\u07be\3\2" + + "\2\2\u01fc\u07c2\3\2\2\2\u01fe\u07c6\3\2\2\2\u0200\u07ca\3\2\2\2\u0202" + + "\u07ce\3\2\2\2\u0204\u07d2\3\2\2\2\u0206\u07d6\3\2\2\2\u0208\u07da\3\2" + + "\2\2\u020a\u07de\3\2\2\2\u020c\u07e2\3\2\2\2\u020e\u07e6\3\2\2\2\u0210" + + "\u07ea\3\2\2\2\u0212\u07ee\3\2\2\2\u0214\u07f2\3\2\2\2\u0216\u07f6\3\2" + + "\2\2\u0218\u07fa\3\2\2\2\u021a\u07fe\3\2\2\2\u021c\u0802\3\2\2\2\u021e" + + "\u0806\3\2\2\2\u0220\u080a\3\2\2\2\u0222\u080e\3\2\2\2\u0224\u0812\3\2" + + "\2\2\u0226\u0816\3\2\2\2\u0228\u081a\3\2\2\2\u022a\u081e\3\2\2\2\u022c" + + "\u0822\3\2\2\2\u022e\u0826\3\2\2\2\u0230\u082a\3\2\2\2\u0232\u082e\3\2" + + "\2\2\u0234\u0832\3\2\2\2\u0236\u0836\3\2\2\2\u0238\u083a\3\2\2\2\u023a" + + "\u083e\3\2\2\2\u023c\u0842\3\2\2\2\u023e\u0846\3\2\2\2\u0240\u084a\3\2" + + "\2\2\u0242\u084e\3\2\2\2\u0244\u0852\3\2\2\2\u0246\u0856\3\2\2\2\u0248" + + "\u085a\3\2\2\2\u024a\u085e\3\2\2\2\u024c\u0862\3\2\2\2\u024e\u0866\3\2" + + "\2\2\u0250\u086a\3\2\2\2\u0252\u086e\3\2\2\2\u0254\u0872\3\2\2\2\u0256" + + "\u0876\3\2\2\2\u0258\u087a\3\2\2\2\u025a\u087e\3\2\2\2\u025c\u0882\3\2" + + "\2\2\u025e\u0886\3\2\2\2\u0260\u088a\3\2\2\2\u0262\u088e\3\2\2\2\u0264" + + "\u0892\3\2\2\2\u0266\u0896\3\2\2\2\u0268\u089a\3\2\2\2\u026a\u089e\3\2" + + "\2\2\u026c\u08a2\3\2\2\2\u026e\u08a8\3\2\2\2\u0270\u08ac\3\2\2\2\u0272" + + "\u08b0\3\2\2\2\u0274\u08b4\3\2\2\2\u0276\u0277\7%\2\2\u0277\u0278\7#\2" + + "\2\u0278\u027c\3\2\2\2\u0279\u027b\n\2\2\2\u027a\u0279\3\2\2\2\u027b\u027e" + + "\3\2\2\2\u027c\u027a\3\2\2\2\u027c\u027d\3\2\2\2\u027d\7\3\2\2\2\u027e" + + "\u027c\3\2\2\2\u027f\u0280\7\61\2\2\u0280\u0281\7,\2\2\u0281\u0286\3\2" + + "\2\2\u0282\u0285\5\b\3\2\u0283\u0285\13\2\2\2\u0284\u0282\3\2\2\2\u0284" + + "\u0283\3\2\2\2\u0285\u0288\3\2\2\2\u0286\u0287\3\2\2\2\u0286\u0284\3\2" + + "\2\2\u0287\u0289\3\2\2\2\u0288\u0286\3\2\2\2\u0289\u028a\7,\2\2\u028a" + + "\u028b\7\61\2\2\u028b\u028c\3\2\2\2\u028c\u028d\b\3\2\2\u028d\t\3\2\2" + + "\2\u028e\u028f\7\61\2\2\u028f\u0290\7\61\2\2\u0290\u0294\3\2\2\2\u0291" + + "\u0293\n\2\2\2\u0292\u0291\3\2\2\2\u0293\u0296\3\2\2\2\u0294\u0292\3\2" + + "\2\2\u0294\u0295\3\2\2\2\u0295\u0297\3\2\2\2\u0296\u0294\3\2\2\2\u0297" + + "\u0298\b\4\2\2\u0298\13\3\2\2\2\u0299\u029a\t\3\2\2\u029a\u029b\3\2\2" + + "\2\u029b\u029c\b\5\2\2\u029c\r\3\2\2\2\u029d\u02a3\7\f\2\2\u029e\u02a0" + + "\7\17\2\2\u029f\u02a1\7\f\2\2\u02a0\u029f\3\2\2\2\u02a0\u02a1\3\2\2\2" + + "\u02a1\u02a3\3\2\2\2\u02a2\u029d\3\2\2\2\u02a2\u029e\3\2\2\2\u02a3\17" + + "\3\2\2\2\u02a4\u02a8\5\b\3\2\u02a5\u02a8\5\n\4\2\u02a6\u02a8\5\f\5\2\u02a7" + + "\u02a4\3\2\2\2\u02a7\u02a5\3\2\2\2\u02a7\u02a6\3\2\2\2\u02a8\21\3\2\2" + + "\2\u02a9\u02aa\7\60\2\2\u02aa\u02ab\7\60\2\2\u02ab\u02ac\7\60\2\2\u02ac" + + "\23\3\2\2\2\u02ad\u02ae\7\60\2\2\u02ae\25\3\2\2\2\u02af\u02b0\7.\2\2\u02b0" + + "\27\3\2\2\2\u02b1\u02b2\7*\2\2\u02b2\u02b3\3\2\2\2\u02b3\u02b4\b\13\3" + + "\2\u02b4\31\3\2\2\2\u02b5\u02b6\7+\2\2\u02b6\33\3\2\2\2\u02b7\u02b8\7" + + "]\2\2\u02b8\u02b9\3\2\2\2\u02b9\u02ba\b\r\3\2\u02ba\35\3\2\2\2\u02bb\u02bc" + + "\7_\2\2\u02bc\37\3\2\2\2\u02bd\u02be\7}\2\2\u02be\u02bf\3\2\2\2\u02bf" + + "\u02c0\b\17\4\2\u02c0!\3\2\2\2\u02c1\u02c2\7\177\2\2\u02c2\u02c3\b\20" + + "\5\2\u02c3#\3\2\2\2\u02c4\u02c5\7,\2\2\u02c5%\3\2\2\2\u02c6\u02c7\7\'" + + "\2\2\u02c7\'\3\2\2\2\u02c8\u02c9\7\61\2\2\u02c9)\3\2\2\2\u02ca\u02cb\7" + + "-\2\2\u02cb+\3\2\2\2\u02cc\u02cd\7/\2\2\u02cd-\3\2\2\2\u02ce\u02cf\7-" + + "\2\2\u02cf\u02d0\7-\2\2\u02d0/\3\2\2\2\u02d1\u02d2\7/\2\2\u02d2\u02d3" + + "\7/\2\2\u02d3\61\3\2\2\2\u02d4\u02d5\7(\2\2\u02d5\u02d6\7(\2\2\u02d6\63" + + "\3\2\2\2\u02d7\u02d8\7~\2\2\u02d8\u02d9\7~\2\2\u02d9\65\3\2\2\2\u02da" + + "\u02db\7#\2\2\u02db\u02dc\5\20\7\2\u02dc\67\3\2\2\2\u02dd\u02de\7#\2\2" + + "\u02de9\3\2\2\2\u02df\u02e0\7<\2\2\u02e0;\3\2\2\2\u02e1\u02e2\7=\2\2\u02e2" + + "=\3\2\2\2\u02e3\u02e4\7?\2\2\u02e4?\3\2\2\2\u02e5\u02e6\7-\2\2\u02e6\u02e7" + + "\7?\2\2\u02e7A\3\2\2\2\u02e8\u02e9\7/\2\2\u02e9\u02ea\7?\2\2\u02eaC\3" + + "\2\2\2\u02eb\u02ec\7,\2\2\u02ec\u02ed\7?\2\2\u02edE\3\2\2\2\u02ee\u02ef" + + "\7\61\2\2\u02ef\u02f0\7?\2\2\u02f0G\3\2\2\2\u02f1\u02f2\7\'\2\2\u02f2" + + "\u02f3\7?\2\2\u02f3I\3\2\2\2\u02f4\u02f5\7/\2\2\u02f5\u02f6\7@\2\2\u02f6" + + "K\3\2\2\2\u02f7\u02f8\7?\2\2\u02f8\u02f9\7@\2\2\u02f9M\3\2\2\2\u02fa\u02fb" + + "\7\60\2\2\u02fb\u02fc\7\60\2\2\u02fcO\3\2\2\2\u02fd\u02fe\7<\2\2\u02fe" + + "\u02ff\7<\2\2\u02ffQ\3\2\2\2\u0300\u0301\7=\2\2\u0301\u0302\7=\2\2\u0302" + + "S\3\2\2\2\u0303\u0304\7%\2\2\u0304U\3\2\2\2\u0305\u0306\7B\2\2\u0306W" + + "\3\2\2\2\u0307\u030a\7B\2\2\u0308\u030b\5\20\7\2\u0309\u030b\5\16\6\2" + + "\u030a\u0308\3\2\2\2\u030a\u0309\3\2\2\2\u030bY\3\2\2\2\u030c\u030f\5" + + "\20\7\2\u030d\u030f\5\16\6\2\u030e\u030c\3\2\2\2\u030e\u030d\3\2\2\2\u030f" + + "\u0310\3\2\2\2\u0310\u0311\7B\2\2\u0311[\3\2\2\2\u0312\u0315\5\20\7\2" + + "\u0313\u0315\5\16\6\2\u0314\u0312\3\2\2\2\u0314\u0313\3\2\2\2\u0315\u0316" + + "\3\2\2\2\u0316\u0319\7B\2\2\u0317\u031a\5\20\7\2\u0318\u031a\5\16\6\2" + + "\u0319\u0317\3\2\2\2\u0319\u0318\3\2\2\2\u031a]\3\2\2\2\u031b\u031c\7" + + "A\2\2\u031c\u031d\5\20\7\2\u031d_\3\2\2\2\u031e\u031f\7A\2\2\u031fa\3" + + "\2\2\2\u0320\u0321\7>\2\2\u0321c\3\2\2\2\u0322\u0323\7@\2\2\u0323e\3\2" + + "\2\2\u0324\u0325\7>\2\2\u0325\u0326\7?\2\2\u0326g\3\2\2\2\u0327\u0328" + + "\7@\2\2\u0328\u0329\7?\2\2\u0329i\3\2\2\2\u032a\u032b\7#\2\2\u032b\u032c" + + "\7?\2\2\u032ck\3\2\2\2\u032d\u032e\7#\2\2\u032e\u032f\7?\2\2\u032f\u0330" + + "\7?\2\2\u0330m\3\2\2\2\u0331\u0332\7c\2\2\u0332\u0333\7u\2\2\u0333\u0334" + + "\7A\2\2\u0334o\3\2\2\2\u0335\u0336\7?\2\2\u0336\u0337\7?\2\2\u0337q\3" + + "\2\2\2\u0338\u0339\7?\2\2\u0339\u033a\7?\2\2\u033a\u033b\7?\2\2\u033b" + + "s\3\2\2\2\u033c\u033d\7)\2\2\u033du\3\2\2\2\u033e\u033f\7t\2\2\u033f\u0340" + + "\7g\2\2\u0340\u0341\7v\2\2\u0341\u0342\7w\2\2\u0342\u0343\7t\2\2\u0343" + + "\u0344\7p\2\2\u0344\u0345\7B\2\2\u0345\u0346\3\2\2\2\u0346\u0347\5\u013e" + + "\u009e\2\u0347w\3\2\2\2\u0348\u0349\7e\2\2\u0349\u034a\7q\2\2\u034a\u034b" + + "\7p\2\2\u034b\u034c\7v\2\2\u034c\u034d\7k\2\2\u034d\u034e\7p\2\2\u034e" + + "\u034f\7w\2\2\u034f\u0350\7g\2\2\u0350\u0351\7B\2\2\u0351\u0352\3\2\2" + + "\2\u0352\u0353\5\u013e\u009e\2\u0353y\3\2\2\2\u0354\u0355\7d\2\2\u0355" + + "\u0356\7t\2\2\u0356\u0357\7g\2\2\u0357\u0358\7c\2\2\u0358\u0359\7m\2\2" + + "\u0359\u035a\7B\2\2\u035a\u035b\3\2\2\2\u035b\u035c\5\u013e\u009e\2\u035c" + + "{\3\2\2\2\u035d\u035e\7v\2\2\u035e\u035f\7j\2\2\u035f\u0360\7k\2\2\u0360" + + "\u0361\7u\2\2\u0361\u0362\7B\2\2\u0362\u0363\3\2\2\2\u0363\u0364\5\u013e" + + "\u009e\2\u0364}\3\2\2\2\u0365\u0366\7u\2\2\u0366\u0367\7w\2\2\u0367\u0368" + + "\7r\2\2\u0368\u0369\7g\2\2\u0369\u036a\7t\2\2\u036a\u036b\7B\2\2\u036b" + + "\u036c\3\2\2\2\u036c\u036d\5\u013e\u009e\2\u036d\177\3\2\2\2\u036e\u036f" + + "\7h\2\2\u036f\u0370\7k\2\2\u0370\u0371\7n\2\2\u0371\u0372\7g\2\2\u0372" + + "\u0081\3\2\2\2\u0373\u0374\7h\2\2\u0374\u0375\7k\2\2\u0375\u0376\7g\2" + + "\2\u0376\u0377\7n\2\2\u0377\u0378\7f\2\2\u0378\u0083\3\2\2\2\u0379\u037a" + + "\7r\2\2\u037a\u037b\7t\2\2\u037b\u037c\7q\2\2\u037c\u037d\7r\2\2\u037d" + + "\u037e\7g\2\2\u037e\u037f\7t\2\2\u037f\u0380\7v\2\2\u0380\u0381\7{\2\2" + + "\u0381\u0085\3\2\2\2\u0382\u0383\7i\2\2\u0383\u0384\7g\2\2\u0384\u0385" + + "\7v\2\2\u0385\u0087\3\2\2\2\u0386\u0387\7u\2\2\u0387\u0388\7g\2\2\u0388" + + "\u0389\7v\2\2\u0389\u0089\3\2\2\2\u038a\u038b\7t\2\2\u038b\u038c\7g\2" + + "\2\u038c\u038d\7e\2\2\u038d\u038e\7g\2\2\u038e\u038f\7k\2\2\u038f\u0390" + + "\7x\2\2\u0390\u0391\7g\2\2\u0391\u0392\7t\2\2\u0392\u008b\3\2\2\2\u0393" + + "\u0394\7r\2\2\u0394\u0395\7c\2\2\u0395\u0396\7t\2\2\u0396\u0397\7c\2\2" + + "\u0397\u0398\7o\2\2\u0398\u008d\3\2\2\2\u0399\u039a\7u\2\2\u039a\u039b" + + "\7g\2\2\u039b\u039c\7v\2\2\u039c\u039d\7r\2\2\u039d\u039e\7c\2\2\u039e" + + "\u039f\7t\2\2\u039f\u03a0\7c\2\2\u03a0\u03a1\7o\2\2\u03a1\u008f\3\2\2" + + "\2\u03a2\u03a3\7f\2\2\u03a3\u03a4\7g\2\2\u03a4\u03a5\7n\2\2\u03a5\u03a6" + + "\7g\2\2\u03a6\u03a7\7i\2\2\u03a7\u03a8\7c\2\2\u03a8\u03a9\7v\2\2\u03a9" + + "\u03aa\7g\2\2\u03aa\u0091\3\2\2\2\u03ab\u03ac\7r\2\2\u03ac\u03ad\7c\2" + + "\2\u03ad\u03ae\7e\2\2\u03ae\u03af\7m\2\2\u03af\u03b0\7c\2\2\u03b0\u03b1" + + "\7i\2\2\u03b1\u03b2\7g\2\2\u03b2\u0093\3\2\2\2\u03b3\u03b4\7k\2\2\u03b4" + + "\u03b5\7o\2\2\u03b5\u03b6\7r\2\2\u03b6\u03b7\7q\2\2\u03b7\u03b8\7t\2\2" + + "\u03b8\u03b9\7v\2\2\u03b9\u0095\3\2\2\2\u03ba\u03bb\7e\2\2\u03bb\u03bc" + + "\7n\2\2\u03bc\u03bd\7c\2\2\u03bd\u03be\7u\2\2\u03be\u03bf\7u\2\2\u03bf" + + "\u0097\3\2\2\2\u03c0\u03c1\7k\2\2\u03c1\u03c2\7p\2\2\u03c2\u03c3\7v\2" + + "\2\u03c3\u03c4\7g\2\2\u03c4\u03c5\7t\2\2\u03c5\u03c6\7h\2\2\u03c6\u03c7" + + "\7c\2\2\u03c7\u03c8\7e\2\2\u03c8\u03c9\7g\2\2\u03c9\u0099\3\2\2\2\u03ca" + + "\u03cb\7h\2\2\u03cb\u03cc\7w\2\2\u03cc\u03cd\7p\2\2\u03cd\u009b\3\2\2" + + "\2\u03ce\u03cf\7q\2\2\u03cf\u03d0\7d\2\2\u03d0\u03d1\7l\2\2\u03d1\u03d2" + + "\7g\2\2\u03d2\u03d3\7e\2\2\u03d3\u03d4\7v\2\2\u03d4\u009d\3\2\2\2\u03d5" + + "\u03d6\7x\2\2\u03d6\u03d7\7c\2\2\u03d7\u03d8\7n\2\2\u03d8\u009f\3\2\2" + + "\2\u03d9\u03da\7x\2\2\u03da\u03db\7c\2\2\u03db\u03dc\7t\2\2\u03dc\u00a1" + + "\3\2\2\2\u03dd\u03de\7v\2\2\u03de\u03df\7{\2\2\u03df\u03e0\7r\2\2\u03e0" + + "\u03e1\7g\2\2\u03e1\u03e2\7c\2\2\u03e2\u03e3\7n\2\2\u03e3\u03e4\7k\2\2" + + "\u03e4\u03e5\7c\2\2\u03e5\u03e6\7u\2\2\u03e6\u00a3\3\2\2\2\u03e7\u03e8" + + "\7e\2\2\u03e8\u03e9\7q\2\2\u03e9\u03ea\7p\2\2\u03ea\u03eb\7u\2\2\u03eb" + + "\u03ec\7v\2\2\u03ec\u03ed\7t\2\2\u03ed\u03ee\7w\2\2\u03ee\u03ef\7e\2\2" + + "\u03ef\u03f0\7v\2\2\u03f0\u03f1\7q\2\2\u03f1\u03f2\7t\2\2\u03f2\u00a5" + + "\3\2\2\2\u03f3\u03f4\7d\2\2\u03f4\u03f5\7{\2\2\u03f5\u00a7\3\2\2\2\u03f6" + + "\u03f7\7e\2\2\u03f7\u03f8\7q\2\2\u03f8\u03f9\7o\2\2\u03f9\u03fa\7r\2\2" + + "\u03fa\u03fb\7c\2\2\u03fb\u03fc\7p\2\2\u03fc\u03fd\7k\2\2\u03fd\u03fe" + + "\7q\2\2\u03fe\u03ff\7p\2\2\u03ff\u00a9\3\2\2\2\u0400\u0401\7k\2\2\u0401" + + "\u0402\7p\2\2\u0402\u0403\7k\2\2\u0403\u0404\7v\2\2\u0404\u00ab\3\2\2" + + "\2\u0405\u0406\7v\2\2\u0406\u0407\7j\2\2\u0407\u0408\7k\2\2\u0408\u0409" + + "\7u\2\2\u0409\u00ad\3\2\2\2\u040a\u040b\7u\2\2\u040b\u040c\7w\2\2\u040c" + + "\u040d\7r\2\2\u040d\u040e\7g\2\2\u040e\u040f\7t\2\2\u040f\u00af\3\2\2" + + "\2\u0410\u0411\7v\2\2\u0411\u0412\7{\2\2\u0412\u0413\7r\2\2\u0413\u0414" + + "\7g\2\2\u0414\u0415\7q\2\2\u0415\u0416\7h\2\2\u0416\u00b1\3\2\2\2\u0417" + + "\u0418\7y\2\2\u0418\u0419\7j\2\2\u0419\u041a\7g\2\2\u041a\u041b\7t\2\2" + + "\u041b\u041c\7g\2\2\u041c\u00b3\3\2\2\2\u041d\u041e\7k\2\2\u041e\u041f" + + "\7h\2\2\u041f\u00b5\3\2\2\2\u0420\u0421\7g\2\2\u0421\u0422\7n\2\2\u0422" + + "\u0423\7u\2\2\u0423\u0424\7g\2\2\u0424\u00b7\3\2\2\2\u0425\u0426\7y\2" + + "\2\u0426\u0427\7j\2\2\u0427\u0428\7g\2\2\u0428\u0429\7p\2\2\u0429\u00b9" + + "\3\2\2\2\u042a\u042b\7v\2\2\u042b\u042c\7t\2\2\u042c\u042d\7{\2\2\u042d" + + "\u00bb\3\2\2\2\u042e\u042f\7e\2\2\u042f\u0430\7c\2\2\u0430\u0431\7v\2" + + "\2\u0431\u0432\7e\2\2\u0432\u0433\7j\2\2\u0433\u00bd\3\2\2\2\u0434\u0435" + + "\7h\2\2\u0435\u0436\7k\2\2\u0436\u0437\7p\2\2\u0437\u0438\7c\2\2\u0438" + + "\u0439\7n\2\2\u0439\u043a\7n\2\2\u043a\u043b\7{\2\2\u043b\u00bf\3\2\2" + + "\2\u043c\u043d\7h\2\2\u043d\u043e\7q\2\2\u043e\u043f\7t\2\2\u043f\u00c1" + + "\3\2\2\2\u0440\u0441\7f\2\2\u0441\u0442\7q\2\2\u0442\u00c3\3\2\2\2\u0443" + + "\u0444\7y\2\2\u0444\u0445\7j\2\2\u0445\u0446\7k\2\2\u0446\u0447\7n\2\2" + + "\u0447\u0448\7g\2\2\u0448\u00c5\3\2\2\2\u0449\u044a\7v\2\2\u044a\u044b" + + "\7j\2\2\u044b\u044c\7t\2\2\u044c\u044d\7q\2\2\u044d\u044e\7y\2\2\u044e" + + "\u00c7\3\2\2\2\u044f\u0450\7t\2\2\u0450\u0451\7g\2\2\u0451\u0452\7v\2" + + "\2\u0452\u0453\7w\2\2\u0453\u0454\7t\2\2\u0454\u0455\7p\2\2\u0455\u00c9" + + "\3\2\2\2\u0456\u0457\7e\2\2\u0457\u0458\7q\2\2\u0458\u0459\7p\2\2\u0459" + + "\u045a\7v\2\2\u045a\u045b\7k\2\2\u045b\u045c\7p\2\2\u045c\u045d\7w\2\2" + + "\u045d\u045e\7g\2\2\u045e\u00cb\3\2\2\2\u045f\u0460\7d\2\2\u0460\u0461" + + "\7t\2\2\u0461\u0462\7g\2\2\u0462\u0463\7c\2\2\u0463\u0464\7m\2\2\u0464" + + "\u00cd\3\2\2\2\u0465\u0466\7c\2\2\u0466\u0467\7u\2\2\u0467\u00cf\3\2\2" + + "\2\u0468\u0469\7k\2\2\u0469\u046a\7u\2\2\u046a\u00d1\3\2\2\2\u046b\u046c" + + "\7k\2\2\u046c\u046d\7p\2\2\u046d\u00d3\3\2\2\2\u046e\u046f\7#\2\2\u046f" + + "\u0470\7k\2\2\u0470\u0471\7u\2\2\u0471\u0474\3\2\2\2\u0472\u0475\5\20" + + "\7\2\u0473\u0475\5\16\6\2\u0474\u0472\3\2\2\2\u0474\u0473\3\2\2\2\u0475" + + "\u00d5\3\2\2\2\u0476\u0477\7#\2\2\u0477\u0478\7k\2\2\u0478\u0479\7p\2" + + "\2\u0479\u047c\3\2\2\2\u047a\u047d\5\20\7\2\u047b\u047d\5\16\6\2\u047c" + + "\u047a\3\2\2\2\u047c\u047b\3\2\2\2\u047d\u00d7\3\2\2\2\u047e\u047f\7q" + + "\2\2\u047f\u0480\7w\2\2\u0480\u0481\7v\2\2\u0481\u00d9\3\2\2\2\u0482\u0483" + + "\7f\2\2\u0483\u0484\7{\2\2\u0484\u0485\7p\2\2\u0485\u0486\7c\2\2\u0486" + + "\u0487\7o\2\2\u0487\u0488\7k\2\2\u0488\u0489\7e\2\2\u0489\u00db\3\2\2" + + "\2\u048a\u048b\7r\2\2\u048b\u048c\7w\2\2\u048c\u048d\7d\2\2\u048d\u048e" + + "\7n\2\2\u048e\u048f\7k\2\2\u048f\u0490\7e\2\2\u0490\u00dd\3\2\2\2\u0491" + + "\u0492\7r\2\2\u0492\u0493\7t\2\2\u0493\u0494\7k\2\2\u0494\u0495\7x\2\2" + + "\u0495\u0496\7c\2\2\u0496\u0497\7v\2\2\u0497\u0498\7g\2\2\u0498\u00df" + + "\3\2\2\2\u0499\u049a\7r\2\2\u049a\u049b\7t\2\2\u049b\u049c\7q\2\2\u049c" + + "\u049d\7v\2\2\u049d\u049e\7g\2\2\u049e\u049f\7e\2\2\u049f\u04a0\7v\2\2" + + "\u04a0\u04a1\7g\2\2\u04a1\u04a2\7f\2\2\u04a2\u00e1\3\2\2\2\u04a3\u04a4" + + "\7k\2\2\u04a4\u04a5\7p\2\2\u04a5\u04a6\7v\2\2\u04a6\u04a7\7g\2\2\u04a7" + + "\u04a8\7t\2\2\u04a8\u04a9\7p\2\2\u04a9\u04aa\7c\2\2\u04aa\u04ab\7n\2\2" + + "\u04ab\u00e3\3\2\2\2\u04ac\u04ad\7g\2\2\u04ad\u04ae\7p\2\2\u04ae\u04af" + + "\7w\2\2\u04af\u04b0\7o\2\2\u04b0\u00e5\3\2\2\2\u04b1\u04b2\7u\2\2\u04b2" + + "\u04b3\7g\2\2\u04b3\u04b4\7c\2\2\u04b4\u04b5\7n\2\2\u04b5\u04b6\7g\2\2" + + "\u04b6\u04b7\7f\2\2\u04b7\u00e7\3\2\2\2\u04b8\u04b9\7c\2\2\u04b9\u04ba" + + "\7p\2\2\u04ba\u04bb\7p\2\2\u04bb\u04bc\7q\2\2\u04bc\u04bd\7v\2\2\u04bd" + + "\u04be\7c\2\2\u04be\u04bf\7v\2\2\u04bf\u04c0\7k\2\2\u04c0\u04c1\7q\2\2" + + "\u04c1\u04c2\7p\2\2\u04c2\u00e9\3\2\2\2\u04c3\u04c4\7f\2\2\u04c4\u04c5" + + "\7c\2\2\u04c5\u04c6\7v\2\2\u04c6\u04c7\7c\2\2\u04c7\u00eb\3\2\2\2\u04c8" + + "\u04c9\7k\2\2\u04c9\u04ca\7p\2\2\u04ca\u04cb\7p\2\2\u04cb\u04cc\7g\2\2" + + "\u04cc\u04cd\7t\2\2\u04cd\u00ed\3\2\2\2\u04ce\u04cf\7x\2\2\u04cf\u04d0" + + "\7c\2\2\u04d0\u04d1\7n\2\2\u04d1\u04d2\7w\2\2\u04d2\u04d3\7g\2\2\u04d3" + + "\u00ef\3\2\2\2\u04d4\u04d5\7v\2\2\u04d5\u04d6\7c\2\2\u04d6\u04d7\7k\2" + + "\2\u04d7\u04d8\7n\2\2\u04d8\u04d9\7t\2\2\u04d9\u04da\7g\2\2\u04da\u04db" + + "\7e\2\2\u04db\u00f1\3\2\2\2\u04dc\u04dd\7q\2\2\u04dd\u04de\7r\2\2\u04de" + + "\u04df\7g\2\2\u04df\u04e0\7t\2\2\u04e0\u04e1\7c\2\2\u04e1\u04e2\7v\2\2" + + "\u04e2\u04e3\7q\2\2\u04e3\u04e4\7t\2\2\u04e4\u00f3\3\2\2\2\u04e5\u04e6" + + "\7k\2\2\u04e6\u04e7\7p\2\2\u04e7\u04e8\7n\2\2\u04e8\u04e9\7k\2\2\u04e9" + + "\u04ea\7p\2\2\u04ea\u04eb\7g\2\2\u04eb\u00f5\3\2\2\2\u04ec\u04ed\7k\2" + + "\2\u04ed\u04ee\7p\2\2\u04ee\u04ef\7h\2\2\u04ef\u04f0\7k\2\2\u04f0\u04f1" + + "\7z\2\2\u04f1\u00f7\3\2\2\2\u04f2\u04f3\7g\2\2\u04f3\u04f4\7z\2\2\u04f4" + + "\u04f5\7v\2\2\u04f5\u04f6\7g\2\2\u04f6\u04f7\7t\2\2\u04f7\u04f8\7p\2\2" + + "\u04f8\u04f9\7c\2\2\u04f9\u04fa\7n\2\2\u04fa\u00f9\3\2\2\2\u04fb\u04fc" + + "\7u\2\2\u04fc\u04fd\7w\2\2\u04fd\u04fe\7u\2\2\u04fe\u04ff\7r\2\2\u04ff" + + "\u0500\7g\2\2\u0500\u0501\7p\2\2\u0501\u0502\7f\2\2\u0502\u00fb\3\2\2" + + "\2\u0503\u0504\7q\2\2\u0504\u0505\7x\2\2\u0505\u0506\7g\2\2\u0506\u0507" + + "\7t\2\2\u0507\u0508\7t\2\2\u0508\u0509\7k\2\2\u0509\u050a\7f\2\2\u050a" + + "\u050b\7g\2\2\u050b\u00fd\3\2\2\2\u050c\u050d\7c\2\2\u050d\u050e\7d\2" + + "\2\u050e\u050f\7u\2\2\u050f\u0510\7v\2\2\u0510\u0511\7t\2\2\u0511\u0512" + + "\7c\2\2\u0512\u0513\7e\2\2\u0513\u0514\7v\2\2\u0514\u00ff\3\2\2\2\u0515" + + "\u0516\7h\2\2\u0516\u0517\7k\2\2\u0517\u0518\7p\2\2\u0518\u0519\7c\2\2" + + "\u0519\u051a\7n\2\2\u051a\u0101\3\2\2\2\u051b\u051c\7q\2\2\u051c\u051d" + + "\7r\2\2\u051d\u051e\7g\2\2\u051e\u051f\7p\2\2\u051f\u0103\3\2\2\2\u0520" + + "\u0521\7e\2\2\u0521\u0522\7q\2\2\u0522\u0523\7p\2\2\u0523\u0524\7u\2\2" + + "\u0524\u0525\7v\2\2\u0525\u0105\3\2\2\2\u0526\u0527\7n\2\2\u0527\u0528" + + "\7c\2\2\u0528\u0529\7v\2\2\u0529\u052a\7g\2\2\u052a\u052b\7k\2\2\u052b" + + "\u052c\7p\2\2\u052c\u052d\7k\2\2\u052d\u052e\7v\2\2\u052e\u0107\3\2\2" + + "\2\u052f\u0530\7x\2\2\u0530\u0531\7c\2\2\u0531\u0532\7t\2\2\u0532\u0533" + + "\7c\2\2\u0533\u0534\7t\2\2\u0534\u0535\7i\2\2\u0535\u0109\3\2\2\2\u0536" + + "\u0537\7p\2\2\u0537\u0538\7q\2\2\u0538\u0539\7k\2\2\u0539\u053a\7p\2\2" + + "\u053a\u053b\7n\2\2\u053b\u053c\7k\2\2\u053c\u053d\7p\2\2\u053d\u053e" + + "\7g\2\2\u053e\u010b\3\2\2\2\u053f\u0540\7e\2\2\u0540\u0541\7t\2\2\u0541" + + "\u0542\7q\2\2\u0542\u0543\7u\2\2\u0543\u0544\7u\2\2\u0544\u0545\7k\2\2" + + "\u0545\u0546\7p\2\2\u0546\u0547\7n\2\2\u0547\u0548\7k\2\2\u0548\u0549" + + "\7p\2\2\u0549\u054a\7g\2\2\u054a\u010d\3\2\2\2\u054b\u054c\7t\2\2\u054c" + + "\u054d\7g\2\2\u054d\u054e\7k\2\2\u054e\u054f\7h\2\2\u054f\u0550\7k\2\2" + + "\u0550\u0551\7g\2\2\u0551\u0552\7f\2\2\u0552\u010f\3\2\2\2\u0553\u0554" + + "\7g\2\2\u0554\u0555\7z\2\2\u0555\u0556\7r\2\2\u0556\u0557\7g\2\2\u0557" + + "\u0558\7e\2\2\u0558\u0559\7v\2\2\u0559\u0111\3\2\2\2\u055a\u055b\7c\2" + + "\2\u055b\u055c\7e\2\2\u055c\u055d\7v\2\2\u055d\u055e\7w\2\2\u055e\u055f" + + "\7c\2\2\u055f\u0560\7n\2\2\u0560\u0113\3\2\2\2\u0561\u0562\4\62;\2\u0562" + + "\u0115\3\2\2\2\u0563\u0564\4\63;\2\u0564\u0117\3\2\2\2\u0565\u0568\5\u0114" + + "\u0089\2\u0566\u0568\7a\2\2\u0567\u0565\3\2\2\2\u0567\u0566\3\2\2\2\u0568" + + "\u0119\3\2\2\2\u0569\u056d\5\u0114\u0089\2\u056a\u056c\5\u0118\u008b\2" + + "\u056b\u056a\3\2\2\2\u056c\u056f\3\2\2\2\u056d\u056b\3\2\2\2\u056d\u056e" + + "\3\2\2\2\u056e\u0570\3\2\2\2\u056f\u056d\3\2\2\2\u0570\u0571\5\u0114\u0089" + + "\2\u0571\u0574\3\2\2\2\u0572\u0574\5\u0114\u0089\2\u0573\u0569\3\2\2\2" + + "\u0573\u0572\3\2\2\2\u0574\u011b\3\2\2\2\u0575\u0577\t\4\2\2\u0576\u0578" + + "\t\5\2\2\u0577\u0576\3\2\2\2\u0577\u0578\3\2\2\2\u0578\u0579\3\2\2\2\u0579" + + "\u057a\5\u011a\u008c\2\u057a\u011d\3\2\2\2\u057b\u057e\5\u0120\u008f\2" + + "\u057c\u057e\5\u0122\u0090\2\u057d\u057b\3\2\2\2\u057d\u057c\3\2\2\2\u057e" + + "\u011f\3\2\2\2\u057f\u0580\5\u0122\u0090\2\u0580\u0581\t\6\2\2\u0581\u0586" + + "\3\2\2\2\u0582\u0583\5\u011a\u008c\2\u0583\u0584\t\6\2\2\u0584\u0586\3" + + "\2\2\2\u0585\u057f\3\2\2\2\u0585\u0582\3\2\2\2\u0586\u0121\3\2\2\2\u0587" + + "\u0589\5\u011a\u008c\2\u0588\u0587\3\2\2\2\u0588\u0589\3\2\2\2\u0589\u058a" + + "\3\2\2\2\u058a\u058b\7\60\2\2\u058b\u058d\5\u011a\u008c\2\u058c\u058e" + + "\5\u011c\u008d\2\u058d\u058c\3\2\2\2\u058d\u058e\3\2\2\2\u058e\u0593\3" + + "\2\2\2\u058f\u0590\5\u011a\u008c\2\u0590\u0591\5\u011c\u008d\2\u0591\u0593" + + "\3\2\2\2\u0592\u0588\3\2\2\2\u0592\u058f\3\2\2\2\u0593\u0123\3\2\2\2\u0594" + + "\u0598\5\u0116\u008a\2\u0595\u0597\5\u0118\u008b\2\u0596\u0595\3\2\2\2" + + "\u0597\u059a\3\2\2\2\u0598\u0596\3\2\2\2\u0598\u0599\3\2\2\2\u0599\u059b" + + "\3\2\2\2\u059a\u0598\3\2\2\2\u059b\u059c\5\u0114\u0089\2\u059c\u059f\3" + + "\2\2\2\u059d\u059f\5\u0114\u0089\2\u059e\u0594\3\2\2\2\u059e\u059d\3\2" + + "\2\2\u059f\u0125\3\2\2\2\u05a0\u05a1\t\7\2\2\u05a1\u0127\3\2\2\2\u05a2" + + "\u05a5\5\u0126\u0092\2\u05a3\u05a5\7a\2\2\u05a4\u05a2\3\2\2\2\u05a4\u05a3" + + "\3\2\2\2\u05a5\u0129\3\2\2\2\u05a6\u05a7\7\62\2\2\u05a7\u05a8\t\b\2\2" + + "\u05a8\u05ac\5\u0126\u0092\2\u05a9\u05ab\5\u0128\u0093\2\u05aa\u05a9\3" + + "\2\2\2\u05ab\u05ae\3\2\2\2\u05ac\u05aa\3\2\2\2\u05ac\u05ad\3\2\2\2\u05ad" + + "\u05af\3\2\2\2\u05ae\u05ac\3\2\2\2\u05af\u05b0\5\u0126\u0092\2\u05b0\u05b5" + + "\3\2\2\2\u05b1\u05b2\7\62\2\2\u05b2\u05b3\t\b\2\2\u05b3\u05b5\5\u0126" + + "\u0092\2\u05b4\u05a6\3\2\2\2\u05b4\u05b1\3\2\2\2\u05b5\u012b\3\2\2\2\u05b6" + + "\u05b7\t\t\2\2\u05b7\u012d\3\2\2\2\u05b8\u05bb\5\u012c\u0095\2\u05b9\u05bb" + + "\7a\2\2\u05ba\u05b8\3\2\2\2\u05ba\u05b9\3\2\2\2\u05bb\u012f\3\2\2\2\u05bc" + + "\u05bd\7\62\2\2\u05bd\u05be\t\n\2\2\u05be\u05c2\5\u012c\u0095\2\u05bf" + + "\u05c1\5\u012e\u0096\2\u05c0\u05bf\3\2\2\2\u05c1\u05c4\3\2\2\2\u05c2\u05c0" + + "\3\2\2\2\u05c2\u05c3\3\2\2\2\u05c3\u05c5\3\2\2\2\u05c4\u05c2\3\2\2\2\u05c5" + + "\u05c6\5\u012c\u0095\2\u05c6\u05cb\3\2\2\2\u05c7\u05c8\7\62\2\2\u05c8" + + "\u05c9\t\n\2\2\u05c9\u05cb\5\u012c\u0095\2\u05ca\u05bc\3\2\2\2\u05ca\u05c7" + + "\3\2\2\2\u05cb\u0131\3\2\2\2\u05cc\u05d0\5\u0124\u0091\2\u05cd\u05d0\5" + + "\u012a\u0094\2\u05ce\u05d0\5\u0130\u0097\2\u05cf\u05cc\3\2\2\2\u05cf\u05cd" + + "\3\2\2\2\u05cf\u05ce\3\2\2\2\u05d0\u05d1\3\2\2\2\u05d1\u05d3\t\13\2\2" + + "\u05d2\u05d4\t\f\2\2\u05d3\u05d2\3\2\2\2\u05d3\u05d4\3\2\2\2\u05d4\u0133" + + "\3\2\2\2\u05d5\u05d9\5\u0124\u0091\2\u05d6\u05d9\5\u012a\u0094\2\u05d7" + + "\u05d9\5\u0130\u0097\2\u05d8\u05d5\3\2\2\2\u05d8\u05d6\3\2\2\2\u05d8\u05d7" + + "\3\2\2\2\u05d9\u05da\3\2\2\2\u05da\u05db\t\f\2\2\u05db\u0135\3\2\2\2\u05dc" + + "\u05dd\7v\2\2\u05dd\u05de\7t\2\2\u05de\u05df\7w\2\2\u05df\u05e6\7g\2\2" + + "\u05e0\u05e1\7h\2\2\u05e1\u05e2\7c\2\2\u05e2\u05e3\7n\2\2\u05e3\u05e4" + + "\7u\2\2\u05e4\u05e6\7g\2\2\u05e5\u05dc\3\2\2\2\u05e5\u05e0\3\2\2\2\u05e6" + + "\u0137\3\2\2\2\u05e7\u05e8\7p\2\2\u05e8\u05e9\7w\2\2\u05e9\u05ea\7n\2" + + "\2\u05ea\u05eb\7n\2\2\u05eb\u0139\3\2\2\2\u05ec\u05ef\7)\2\2\u05ed\u05f0" + + "\5\u0148\u00a3\2\u05ee\u05f0\n\r\2\2\u05ef\u05ed\3\2\2\2\u05ef\u05ee\3" + + "\2\2\2\u05f0\u05f1\3\2\2\2\u05f1\u05f2\7)\2\2\u05f2\u013b\3\2\2\2\u05f3" + + "\u05f4\5\u015a\u00ac\2\u05f4\u013d\3\2\2\2\u05f5\u05f8\5\u014a\u00a4\2" + + "\u05f6\u05f8\7a\2\2\u05f7\u05f5\3\2\2\2\u05f7\u05f6\3\2\2\2\u05f8\u05fe" + + "\3\2\2\2\u05f9\u05fd\5\u014a\u00a4\2\u05fa\u05fd\7a\2\2\u05fb\u05fd\5" + + "\u013c\u009d\2\u05fc\u05f9\3\2\2\2\u05fc\u05fa\3\2\2\2\u05fc\u05fb\3\2" + + "\2\2\u05fd\u0600\3\2\2\2\u05fe\u05fc\3\2\2\2\u05fe\u05ff\3\2\2\2\u05ff" + + "\u0609\3\2\2\2\u0600\u05fe\3\2\2\2\u0601\u0603\7b\2\2\u0602\u0604\n\16" + + "\2\2\u0603\u0602\3\2\2\2\u0604\u0605\3\2\2\2\u0605\u0603\3\2\2\2\u0605" + + "\u0606\3\2\2\2\u0606\u0607\3\2\2\2\u0607\u0609\7b\2\2\u0608\u05f7\3\2" + + "\2\2\u0608\u0601\3\2\2\2\u0609\u013f\3\2\2\2\u060a\u063b\5\u013e\u009e" + + "\2\u060b\u063b\5\u00fe~\2\u060c\u063b\5\u00e8s\2\u060d\u063b\5\u00a6R" + + "\2\u060e\u063b\5\u00bc]\2\u060f\u063b\5\u00a8S\2\u0610\u063b\5\u00a4Q" + + "\2\u0611\u063b\5\u010c\u0085\2\u0612\u063b\5\u00eat\2\u0613\u063b\5\u00da" + + "l\2\u0614\u063b\5\u00e4q\2\u0615\u063b\5\u00f8{\2\u0616\u063b\5\u0100" + + "\177\2\u0617\u063b\5\u00be^\2\u0618\u063b\5\u0094I\2\u0619\u063b\5\u00f6" + + "z\2\u061a\u063b\5\u00aaT\2\u061b\u063b\5\u00f4y\2\u061c\u063b\5\u00ec" + + "u\2\u061d\u063b\5\u00e2p\2\u061e\u063b\5\u0106\u0082\2\u061f\u063b\5\u010a" + + "\u0084\2\u0620\u063b\5\u0102\u0080\2\u0621\u063b\5\u00f2x\2\u0622\u063b" + + "\5\u00d8k\2\u0623\u063b\5\u00fc}\2\u0624\u063b\5\u00den\2\u0625\u063b" + + "\5\u00e0o\2\u0626\u063b\5\u00dcm\2\u0627\u063b\5\u010e\u0086\2\u0628\u063b" + + "\5\u00e6r\2\u0629\u063b\5\u00f0w\2\u062a\u063b\5\u0108\u0083\2\u062b\u063b" + + "\5\u00b2X\2\u062c\u063b\5\u0086B\2\u062d\u063b\5\u0088C\2\u062e\u063b" + + "\5\u0082@\2\u062f\u063b\5\u0084A\2\u0630\u063b\5\u008aD\2\u0631\u063b" + + "\5\u008cE\2\u0632\u063b\5\u008eF\2\u0633\u063b\5\u0090G\2\u0634\u063b" + + "\5\u0080?\2\u0635\u063b\5\u0110\u0087\2\u0636\u063b\5\u0112\u0088\2\u0637" + + "\u063b\5\u00eev\2\u0638\u063b\5\u0104\u0081\2\u0639\u063b\5\u00fa|\2\u063a" + + "\u060a\3\2\2\2\u063a\u060b\3\2\2\2\u063a\u060c\3\2\2\2\u063a\u060d\3\2" + + "\2\2\u063a\u060e\3\2\2\2\u063a\u060f\3\2\2\2\u063a\u0610\3\2\2\2\u063a" + + "\u0611\3\2\2\2\u063a\u0612\3\2\2\2\u063a\u0613\3\2\2\2\u063a\u0614\3\2" + + "\2\2\u063a\u0615\3\2\2\2\u063a\u0616\3\2\2\2\u063a\u0617\3\2\2\2\u063a" + + "\u0618\3\2\2\2\u063a\u0619\3\2\2\2\u063a\u061a\3\2\2\2\u063a\u061b\3\2" + + "\2\2\u063a\u061c\3\2\2\2\u063a\u061d\3\2\2\2\u063a\u061e\3\2\2\2\u063a" + + "\u061f\3\2\2\2\u063a\u0620\3\2\2\2\u063a\u0621\3\2\2\2\u063a\u0622\3\2" + + "\2\2\u063a\u0623\3\2\2\2\u063a\u0624\3\2\2\2\u063a\u0625\3\2\2\2\u063a" + + "\u0626\3\2\2\2\u063a\u0627\3\2\2\2\u063a\u0628\3\2\2\2\u063a\u0629\3\2" + + "\2\2\u063a\u062a\3\2\2\2\u063a\u062b\3\2\2\2\u063a\u062c\3\2\2\2\u063a" + + "\u062d\3\2\2\2\u063a\u062e\3\2\2\2\u063a\u062f\3\2\2\2\u063a\u0630\3\2" + + "\2\2\u063a\u0631\3\2\2\2\u063a\u0632\3\2\2\2\u063a\u0633\3\2\2\2\u063a" + + "\u0634\3\2\2\2\u063a\u0635\3\2\2\2\u063a\u0636\3\2\2\2\u063a\u0637\3\2" + + "\2\2\u063a\u0638\3\2\2\2\u063a\u0639\3\2\2\2\u063b\u0141\3\2\2\2\u063c" + + "\u063d\7&\2\2\u063d\u063e\5\u0140\u009f\2\u063e\u0143\3\2\2\2\u063f\u0640" + + "\7^\2\2\u0640\u0641\7w\2\2\u0641\u0642\5\u0126\u0092\2\u0642\u0643\5\u0126" + + "\u0092\2\u0643\u0644\5\u0126\u0092\2\u0644\u0645\5\u0126\u0092\2\u0645" + + "\u0145\3\2\2\2\u0646\u0647\7^\2\2\u0647\u0648\t\17\2\2\u0648\u0147\3\2" + + "\2\2\u0649\u064c\5\u0144\u00a1\2\u064a\u064c\5\u0146\u00a2\2\u064b\u0649" + + "\3\2\2\2\u064b\u064a\3\2\2\2\u064c\u0149\3\2\2\2\u064d\u0653\5\u0158\u00ab" + + "\2\u064e\u0653\5\u0150\u00a7\2\u064f\u0653\5\u0156\u00aa\2\u0650\u0653" + + "\5\u0152\u00a8\2\u0651\u0653\5\u0154\u00a9\2\u0652\u064d\3\2\2\2\u0652" + + "\u064e\3\2\2\2\u0652\u064f\3\2\2\2\u0652\u0650\3\2\2\2\u0652\u0651\3\2" + + "\2\2\u0653\u014b\3\2\2\2\u0654\u0655\7$\2\2\u0655\u0656\3\2\2\2\u0656" + + "\u0657\b\u00a5\6\2\u0657\u014d\3\2\2\2\u0658\u0659\7$\2\2\u0659\u065a" + + "\7$\2\2\u065a\u065b\7$\2\2\u065b\u065c\3\2\2\2\u065c\u065d\b\u00a6\7\2" + + "\u065d\u014f\3\2\2\2\u065e\u065f\t\20\2\2\u065f\u0151\3\2\2\2\u0660\u0661" + + "\t\21\2\2\u0661\u0153\3\2\2\2\u0662\u0663\t\22\2\2\u0663\u0155\3\2\2\2" + + "\u0664\u0665\t\23\2\2\u0665\u0157\3\2\2\2\u0666\u0667\t\24\2\2\u0667\u0159" + + "\3\2\2\2\u0668\u0669\t\25\2\2\u0669\u015b\3\2\2\2\u066a\u066b\t\26\2\2" + + "\u066b\u015d\3\2\2\2\u066c\u066d\7$\2\2\u066d\u066e\3\2\2\2\u066e\u066f" + + "\b\u00ae\b\2\u066f\u015f\3\2\2\2\u0670\u0671\5\u0142\u00a0\2\u0671\u0161" + + "\3\2\2\2\u0672\u0674\n\27\2\2\u0673\u0672\3\2\2\2\u0674\u0675\3\2\2\2" + + "\u0675\u0673\3\2\2\2\u0675\u0676\3\2\2\2\u0676\u0679\3\2\2\2\u0677\u0679" + + "\7&\2\2\u0678\u0673\3\2\2\2\u0678\u0677\3\2\2\2\u0679\u0163\3\2\2\2\u067a" + + "\u067d\5\u0146\u00a2\2\u067b\u067d\5\u0144\u00a1\2\u067c\u067a\3\2\2\2" + + "\u067c\u067b\3\2\2\2\u067d\u0165\3\2\2\2\u067e\u067f\7&\2\2\u067f\u0680" + + "\7}\2\2\u0680\u0681\3\2\2\2\u0681\u0682\b\u00b2\4\2\u0682\u0167\3\2\2" + + "\2\u0683\u0685\5\u016a\u00b4\2\u0684\u0683\3\2\2\2\u0684\u0685\3\2\2\2" + + "\u0685\u0686\3\2\2\2\u0686\u0687\7$\2\2\u0687\u0688\7$\2\2\u0688\u0689" + + "\7$\2\2\u0689\u068a\3\2\2\2\u068a\u068b\b\u00b3\b\2\u068b\u0169\3\2\2" + + "\2\u068c\u068e\7$\2\2\u068d\u068c\3\2\2\2\u068e\u068f\3\2\2\2\u068f\u068d" + + "\3\2\2\2\u068f\u0690\3\2\2\2\u0690\u016b\3\2\2\2\u0691\u0692\5\u0142\u00a0" + + "\2\u0692\u016d\3\2\2\2\u0693\u0695\n\30\2\2\u0694\u0693\3\2\2\2\u0695" + + "\u0696\3\2\2\2\u0696\u0694\3\2\2\2\u0696\u0697\3\2\2\2\u0697\u069a\3\2" + + "\2\2\u0698\u069a\7&\2\2\u0699\u0694\3\2\2\2\u0699\u0698\3\2\2\2\u069a" + + "\u016f\3\2\2\2\u069b\u069c\7&\2\2\u069c\u069d\7}\2\2\u069d\u069e\3\2\2" + + "\2\u069e\u069f\b\u00b7\4\2\u069f\u0171\3\2\2\2\u06a0\u06a1\5\32\f\2\u06a1" + + "\u06a2\3\2\2\2\u06a2\u06a3\b\u00b8\b\2\u06a3\u06a4\b\u00b8\t\2\u06a4\u0173" + + "\3\2\2\2\u06a5\u06a6\5\36\16\2\u06a6\u06a7\3\2\2\2\u06a7\u06a8\b\u00b9" + + "\b\2\u06a8\u06a9\b\u00b9\n\2\u06a9\u0175\3\2\2\2\u06aa\u06ab\5\30\13\2" + + "\u06ab\u06ac\3\2\2\2\u06ac\u06ad\b\u00ba\3\2\u06ad\u06ae\b\u00ba\13\2" + + "\u06ae\u0177\3\2\2\2\u06af\u06b0\5\34\r\2\u06b0\u06b1\3\2\2\2\u06b1\u06b2" + + "\b\u00bb\3\2\u06b2\u06b3\b\u00bb\f\2\u06b3\u0179\3\2\2\2\u06b4\u06b5\5" + + " \17\2\u06b5\u06b6\3\2\2\2\u06b6\u06b7\b\u00bc\4\2\u06b7\u06b8\b\u00bc" + + "\r\2\u06b8\u017b\3\2\2\2\u06b9\u06ba\5\"\20\2\u06ba\u06bb\3\2\2\2\u06bb" + + "\u06bc\b\u00bd\b\2\u06bc\u06bd\b\u00bd\16\2\u06bd\u017d\3\2\2\2\u06be" + + "\u06bf\5\24\t\2\u06bf\u06c0\3\2\2\2\u06c0\u06c1\b\u00be\17\2\u06c1\u017f" + + "\3\2\2\2\u06c2\u06c3\5\26\n\2\u06c3\u06c4\3\2\2\2\u06c4\u06c5\b\u00bf" + + "\20\2\u06c5\u0181\3\2\2\2\u06c6\u06c7\5$\21\2\u06c7\u06c8\3\2\2\2\u06c8" + + "\u06c9\b\u00c0\21\2\u06c9\u0183\3\2\2\2\u06ca\u06cb\5&\22\2\u06cb\u06cc" + + "\3\2\2\2\u06cc\u06cd\b\u00c1\22\2\u06cd\u0185\3\2\2\2\u06ce\u06cf\5(\23" + + "\2\u06cf\u06d0\3\2\2\2\u06d0\u06d1\b\u00c2\23\2\u06d1\u0187\3\2\2\2\u06d2" + + "\u06d3\5*\24\2\u06d3\u06d4\3\2\2\2\u06d4\u06d5\b\u00c3\24\2\u06d5\u0189" + + "\3\2\2\2\u06d6\u06d7\5,\25\2\u06d7\u06d8\3\2\2\2\u06d8\u06d9\b\u00c4\25" + + "\2\u06d9\u018b\3\2\2\2\u06da\u06db\5.\26\2\u06db\u06dc\3\2\2\2\u06dc\u06dd" + + "\b\u00c5\26\2\u06dd\u018d\3\2\2\2\u06de\u06df\5\60\27\2\u06df\u06e0\3" + + "\2\2\2\u06e0\u06e1\b\u00c6\27\2\u06e1\u018f\3\2\2\2\u06e2\u06e3\5\62\30" + + "\2\u06e3\u06e4\3\2\2\2\u06e4\u06e5\b\u00c7\30\2\u06e5\u0191\3\2\2\2\u06e6" + + "\u06e7\5\64\31\2\u06e7\u06e8\3\2\2\2\u06e8\u06e9\b\u00c8\31\2\u06e9\u0193" + + "\3\2\2\2\u06ea\u06ed\7#\2\2\u06eb\u06ee\5\20\7\2\u06ec\u06ee\5\16\6\2" + + "\u06ed\u06eb\3\2\2\2\u06ed\u06ec\3\2\2\2\u06ee\u06ef\3\2\2\2\u06ef\u06f0" + + "\b\u00c9\32\2\u06f0\u0195\3\2\2\2\u06f1\u06f2\58\33\2\u06f2\u06f3\3\2" + + "\2\2\u06f3\u06f4\b\u00ca\33\2\u06f4\u0197\3\2\2\2\u06f5\u06f6\5:\34\2" + + "\u06f6\u06f7\3\2\2\2\u06f7\u06f8\b\u00cb\34\2\u06f8\u0199\3\2\2\2\u06f9" + + "\u06fa\5<\35\2\u06fa\u06fb\3\2\2\2\u06fb\u06fc\b\u00cc\35\2\u06fc\u019b" + + "\3\2\2\2\u06fd\u06fe\5>\36\2\u06fe\u06ff\3\2\2\2\u06ff\u0700\b\u00cd\36" + + "\2\u0700\u019d\3\2\2\2\u0701\u0702\5@\37\2\u0702\u0703\3\2\2\2\u0703\u0704" + + "\b\u00ce\37\2\u0704\u019f\3\2\2\2\u0705\u0706\5B \2\u0706\u0707\3\2\2" + + "\2\u0707\u0708\b\u00cf \2\u0708\u01a1\3\2\2\2\u0709\u070a\5D!\2\u070a" + + "\u070b\3\2\2\2\u070b\u070c\b\u00d0!\2\u070c\u01a3\3\2\2\2\u070d\u070e" + + "\5F\"\2\u070e\u070f\3\2\2\2\u070f\u0710\b\u00d1\"\2\u0710\u01a5\3\2\2" + + "\2\u0711\u0712\5H#\2\u0712\u0713\3\2\2\2\u0713\u0714\b\u00d2#\2\u0714" + + "\u01a7\3\2\2\2\u0715\u0716\5J$\2\u0716\u0717\3\2\2\2\u0717\u0718\b\u00d3" + + "$\2\u0718\u01a9\3\2\2\2\u0719\u071a\5L%\2\u071a\u071b\3\2\2\2\u071b\u071c" + + "\b\u00d4%\2\u071c\u01ab\3\2\2\2\u071d\u071e\5N&\2\u071e\u071f\3\2\2\2" + + "\u071f\u0720\b\u00d5&\2\u0720\u01ad\3\2\2\2\u0721\u0722\5\22\b\2\u0722" + + "\u0723\3\2\2\2\u0723\u0724\b\u00d6\'\2\u0724\u01af\3\2\2\2\u0725\u0726" + + "\5P\'\2\u0726\u0727\3\2\2\2\u0727\u0728\b\u00d7(\2\u0728\u01b1\3\2\2\2" + + "\u0729\u072a\5R(\2\u072a\u072b\3\2\2\2\u072b\u072c\b\u00d8)\2\u072c\u01b3" + + "\3\2\2\2\u072d\u072e\5T)\2\u072e\u072f\3\2\2\2\u072f\u0730\b\u00d9*\2" + + "\u0730\u01b5\3\2\2\2\u0731\u0732\5V*\2\u0732\u0733\3\2\2\2\u0733\u0734" + + "\b\u00da+\2\u0734\u01b7\3\2\2\2\u0735\u0736\5X+\2\u0736\u0737\3\2\2\2" + + "\u0737\u0738\b\u00db,\2\u0738\u01b9\3\2\2\2\u0739\u073a\5Z,\2\u073a\u073b" + + "\3\2\2\2\u073b\u073c\b\u00dc-\2\u073c\u01bb\3\2\2\2\u073d\u073e\5\\-\2" + + "\u073e\u073f\3\2\2\2\u073f\u0740\b\u00dd.\2\u0740\u01bd\3\2\2\2\u0741" + + "\u0744\7A\2\2\u0742\u0745\5\20\7\2\u0743\u0745\5\16\6\2\u0744\u0742\3" + + "\2\2\2\u0744\u0743\3\2\2\2\u0745\u0746\3\2\2\2\u0746\u0747\b\u00de/\2" + + "\u0747\u01bf\3\2\2\2\u0748\u0749\5`/\2\u0749\u074a\3\2\2\2\u074a\u074b" + + "\b\u00df\60\2\u074b\u01c1\3\2\2\2\u074c\u074d\5b\60\2\u074d\u074e\3\2" + + "\2\2\u074e\u074f\b\u00e0\61\2\u074f\u01c3\3\2\2\2\u0750\u0751\5d\61\2" + + "\u0751\u0752\3\2\2\2\u0752\u0753\b\u00e1\62\2\u0753\u01c5\3\2\2\2\u0754" + + "\u0755\5f\62\2\u0755\u0756\3\2\2\2\u0756\u0757\b\u00e2\63\2\u0757\u01c7" + + "\3\2\2\2\u0758\u0759\5h\63\2\u0759\u075a\3\2\2\2\u075a\u075b\b\u00e3\64" + + "\2\u075b\u01c9\3\2\2\2\u075c\u075d\5j\64\2\u075d\u075e\3\2\2\2\u075e\u075f" + + "\b\u00e4\65\2\u075f\u01cb\3\2\2\2\u0760\u0761\5l\65\2\u0761\u0762\3\2" + + "\2\2\u0762\u0763\b\u00e5\66\2\u0763\u01cd\3\2\2\2\u0764\u0765\5\u00d0" + + "g\2\u0765\u0766\3\2\2\2\u0766\u0767\b\u00e6\67\2\u0767\u01cf\3\2\2\2\u0768" + + "\u0769\5\u00d4i\2\u0769\u076a\3\2\2\2\u076a\u076b\b\u00e78\2\u076b\u01d1" + + "\3\2\2\2\u076c\u076d\5\u00d6j\2\u076d\u076e\3\2\2\2\u076e\u076f\b\u00e8" + + "9\2\u076f\u01d3\3\2\2\2\u0770\u0771\5\u00cef\2\u0771\u0772\3\2\2\2\u0772" + + "\u0773\b\u00e9:\2\u0773\u01d5\3\2\2\2\u0774\u0775\5n\66\2\u0775\u0776" + + "\3\2\2\2\u0776\u0777\b\u00ea;\2\u0777\u01d7\3\2\2\2\u0778\u0779\5p\67" + + "\2\u0779\u077a\3\2\2\2\u077a\u077b\b\u00eb<\2\u077b\u01d9\3\2\2\2\u077c" + + "\u077d\5r8\2\u077d\u077e\3\2\2\2\u077e\u077f\b\u00ec=\2\u077f\u01db\3" + + "\2\2\2\u0780\u0781\5t9\2\u0781\u0782\3\2\2\2\u0782\u0783\b\u00ed>\2\u0783" + + "\u01dd\3\2\2\2\u0784\u0785\5\u014c\u00a5\2\u0785\u0786\3\2\2\2\u0786\u0787" + + "\b\u00ee\6\2\u0787\u0788\b\u00ee?\2\u0788\u01df\3\2\2\2\u0789\u078a\5" + + "\u014e\u00a6\2\u078a\u078b\3\2\2\2\u078b\u078c\b\u00ef\7\2\u078c\u078d" + + "\b\u00ef@\2\u078d\u01e1\3\2\2\2\u078e\u078f\5\u009eN\2\u078f\u0790\3\2" + + "\2\2\u0790\u0791\b\u00f0A\2\u0791\u01e3\3\2\2\2\u0792\u0793\5\u00a0O\2" + + "\u0793\u0794\3\2\2\2\u0794\u0795\b\u00f1B\2\u0795\u01e5\3\2\2\2\u0796" + + "\u0797\5\u009aL\2\u0797\u0798\3\2\2\2\u0798\u0799\b\u00f2C\2\u0799\u01e7" + + "\3\2\2\2\u079a\u079b\5\u009cM\2\u079b\u079c\3\2\2\2\u079c\u079d\b\u00f3" + + "D\2\u079d\u01e9\3\2\2\2\u079e\u079f\5\u00aeV\2\u079f\u07a0\3\2\2\2\u07a0" + + "\u07a1\b\u00f4E\2\u07a1\u01eb\3\2\2\2\u07a2\u07a3\5\u00d2h\2\u07a3\u07a4" + + "\3\2\2\2\u07a4\u07a5\b\u00f5F\2\u07a5\u01ed\3\2\2\2\u07a6\u07a7\5\u00d8" + + "k\2\u07a7\u07a8\3\2\2\2\u07a8\u07a9\b\u00f6G\2\u07a9\u01ef\3\2\2\2\u07aa" + + "\u07ab\5\u0082@\2\u07ab\u07ac\3\2\2\2\u07ac\u07ad\b\u00f7H\2\u07ad\u01f1" + + "\3\2\2\2\u07ae\u07af\5\u0080?\2\u07af\u07b0\3\2\2\2\u07b0\u07b1\b\u00f8" + + "I\2\u07b1\u01f3\3\2\2\2\u07b2\u07b3\5\u0084A\2\u07b3\u07b4\3\2\2\2\u07b4" + + "\u07b5\b\u00f9J\2\u07b5\u01f5\3\2\2\2\u07b6\u07b7\5\u0086B\2\u07b7\u07b8" + + "\3\2\2\2\u07b8\u07b9\b\u00faK\2\u07b9\u01f7\3\2\2\2\u07ba\u07bb\5\u0088" + + "C\2\u07bb\u07bc\3\2\2\2\u07bc\u07bd\b\u00fbL\2\u07bd\u01f9\3\2\2\2\u07be" + + "\u07bf\5\u008aD\2\u07bf\u07c0\3\2\2\2\u07c0\u07c1\b\u00fcM\2\u07c1\u01fb" + + "\3\2\2\2\u07c2\u07c3\5\u008cE\2\u07c3\u07c4\3\2\2\2\u07c4\u07c5\b\u00fd" + + "N\2\u07c5\u01fd\3\2\2\2\u07c6\u07c7\5\u008eF\2\u07c7\u07c8\3\2\2\2\u07c8" + + "\u07c9\b\u00feO\2\u07c9\u01ff\3\2\2\2\u07ca\u07cb\5\u0090G\2\u07cb\u07cc" + + "\3\2\2\2\u07cc\u07cd\b\u00ffP\2\u07cd\u0201\3\2\2\2\u07ce\u07cf\5\u00c6" + + "b\2\u07cf\u07d0\3\2\2\2\u07d0\u07d1\b\u0100Q\2\u07d1\u0203\3\2\2\2\u07d2" + + "\u07d3\5\u00c8c\2\u07d3\u07d4\3\2\2\2\u07d4\u07d5\b\u0101R\2\u07d5\u0205" + + "\3\2\2\2\u07d6\u07d7\5\u00cad\2\u07d7\u07d8\3\2\2\2\u07d8\u07d9\b\u0102" + + "S\2\u07d9\u0207\3\2\2\2\u07da\u07db\5\u00cce\2\u07db\u07dc\3\2\2\2\u07dc" + + "\u07dd\b\u0103T\2\u07dd\u0209\3\2\2\2\u07de\u07df\5v:\2\u07df\u07e0\3" + + "\2\2\2\u07e0\u07e1\b\u0104U\2\u07e1\u020b\3\2\2\2\u07e2\u07e3\5x;\2\u07e3" + + "\u07e4\3\2\2\2\u07e4\u07e5\b\u0105V\2\u07e5\u020d\3\2\2\2\u07e6\u07e7" + + "\5z<\2\u07e7\u07e8\3\2\2\2\u07e8\u07e9\b\u0106W\2\u07e9\u020f\3\2\2\2" + + "\u07ea\u07eb\5\u00b4Y\2\u07eb\u07ec\3\2\2\2\u07ec\u07ed\b\u0107X\2\u07ed" + + "\u0211\3\2\2\2\u07ee\u07ef\5\u00b6Z\2\u07ef\u07f0\3\2\2\2\u07f0\u07f1" + + "\b\u0108Y\2\u07f1\u0213\3\2\2\2\u07f2\u07f3\5\u00b8[\2\u07f3\u07f4\3\2" + + "\2\2\u07f4\u07f5\b\u0109Z\2\u07f5\u0215\3\2\2\2\u07f6\u07f7\5\u00ba\\" + + "\2\u07f7\u07f8\3\2\2\2\u07f8\u07f9\b\u010a[\2\u07f9\u0217\3\2\2\2\u07fa" + + "\u07fb\5\u00bc]\2\u07fb\u07fc\3\2\2\2\u07fc\u07fd\b\u010b\\\2\u07fd\u0219" + + "\3\2\2\2\u07fe\u07ff\5\u00be^\2\u07ff\u0800\3\2\2\2\u0800\u0801\b\u010c" + + "]\2\u0801\u021b\3\2\2\2\u0802\u0803\5\u00c0_\2\u0803\u0804\3\2\2\2\u0804" + + "\u0805\b\u010d^\2\u0805\u021d\3\2\2\2\u0806\u0807\5\u00c2`\2\u0807\u0808" + + "\3\2\2\2\u0808\u0809\b\u010e_\2\u0809\u021f\3\2\2\2\u080a\u080b\5\u00c4" + + "a\2\u080b\u080c\3\2\2\2\u080c\u080d\b\u010f`\2\u080d\u0221\3\2\2\2\u080e" + + "\u080f\5\u00dcm\2\u080f\u0810\3\2\2\2\u0810\u0811\b\u0110a\2\u0811\u0223" + + "\3\2\2\2\u0812\u0813\5\u00den\2\u0813\u0814\3\2\2\2\u0814\u0815\b\u0111" + + "b\2\u0815\u0225\3\2\2\2\u0816\u0817\5\u00e0o\2\u0817\u0818\3\2\2\2\u0818" + + "\u0819\b\u0112c\2\u0819\u0227\3\2\2\2\u081a\u081b\5\u00e2p\2\u081b\u081c" + + "\3\2\2\2\u081c\u081d\b\u0113d\2\u081d\u0229\3\2\2\2\u081e\u081f\5\u00e4" + + "q\2\u081f\u0820\3\2\2\2\u0820\u0821\b\u0114e\2\u0821\u022b\3\2\2\2\u0822" + + "\u0823\5\u00e6r\2\u0823\u0824\3\2\2\2\u0824\u0825\b\u0115f\2\u0825\u022d" + + "\3\2\2\2\u0826\u0827\5\u00e8s\2\u0827\u0828\3\2\2\2\u0828\u0829\b\u0116" + + "g\2\u0829\u022f\3\2\2\2\u082a\u082b\5\u00eat\2\u082b\u082c\3\2\2\2\u082c" + + "\u082d\b\u0117h\2\u082d\u0231\3\2\2\2\u082e\u082f\5\u00ecu\2\u082f\u0830" + + "\3\2\2\2\u0830\u0831\b\u0118i\2\u0831\u0233\3\2\2\2\u0832\u0833\5\u00ee" + + "v\2\u0833\u0834\3\2\2\2\u0834\u0835\b\u0119j\2\u0835\u0235\3\2\2\2\u0836" + + "\u0837\5\u00f0w\2\u0837\u0838\3\2\2\2\u0838\u0839\b\u011ak\2\u0839\u0237" + + "\3\2\2\2\u083a\u083b\5\u00f2x\2\u083b\u083c\3\2\2\2\u083c\u083d\b\u011b" + + "l\2\u083d\u0239\3\2\2\2\u083e\u083f\5\u00f4y\2\u083f\u0840\3\2\2\2\u0840" + + "\u0841\b\u011cm\2\u0841\u023b\3\2\2\2\u0842\u0843\5\u00f6z\2\u0843\u0844" + + "\3\2\2\2\u0844\u0845\b\u011dn\2\u0845\u023d\3\2\2\2\u0846\u0847\5\u00f8" + + "{\2\u0847\u0848\3\2\2\2\u0848\u0849\b\u011eo\2\u0849\u023f\3\2\2\2\u084a" + + "\u084b\5\u00fa|\2\u084b\u084c\3\2\2\2\u084c\u084d\b\u011fp\2\u084d\u0241" + + "\3\2\2\2\u084e\u084f\5\u00fc}\2\u084f\u0850\3\2\2\2\u0850\u0851\b\u0120" + + "q\2\u0851\u0243\3\2\2\2\u0852\u0853\5\u00fe~\2\u0853\u0854\3\2\2\2\u0854" + + "\u0855\b\u0121r\2\u0855\u0245\3\2\2\2\u0856\u0857\5\u0100\177\2\u0857" + + "\u0858\3\2\2\2\u0858\u0859\b\u0122s\2\u0859\u0247\3\2\2\2\u085a\u085b" + + "\5\u0102\u0080\2\u085b\u085c\3\2\2\2\u085c\u085d\b\u0123t\2\u085d\u0249" + + "\3\2\2\2\u085e\u085f\5\u0104\u0081\2\u085f\u0860\3\2\2\2\u0860\u0861\b" + + "\u0124u\2\u0861\u024b\3\2\2\2\u0862\u0863\5\u0106\u0082\2\u0863\u0864" + + "\3\2\2\2\u0864\u0865\b\u0125v\2\u0865\u024d\3\2\2\2\u0866\u0867\5\u0108" + + "\u0083\2\u0867\u0868\3\2\2\2\u0868\u0869\b\u0126w\2\u0869\u024f\3\2\2" + + "\2\u086a\u086b\5\u010a\u0084\2\u086b\u086c\3\2\2\2\u086c\u086d\b\u0127" + + "x\2"; + private static final String _serializedATNSegment1 = + "\u086d\u0251\3\2\2\2\u086e\u086f\5\u010c\u0085\2\u086f\u0870\3\2\2\2\u0870" + + "\u0871\b\u0128y\2\u0871\u0253\3\2\2\2\u0872\u0873\5\u010e\u0086\2\u0873" + + "\u0874\3\2\2\2\u0874\u0875\b\u0129z\2\u0875\u0255\3\2\2\2\u0876\u0877" + + "\5\u0110\u0087\2\u0877\u0878\3\2\2\2\u0878\u0879\b\u012a{\2\u0879\u0257" + + "\3\2\2\2\u087a\u087b\5\u0112\u0088\2\u087b\u087c\3\2\2\2\u087c\u087d\b" + + "\u012b|\2\u087d\u0259\3\2\2\2\u087e\u087f\5\u0136\u009a\2\u087f\u0880" + + "\3\2\2\2\u0880\u0881\b\u012c}\2\u0881\u025b\3\2\2\2\u0882\u0883\5\u0124" + + "\u0091\2\u0883\u0884\3\2\2\2\u0884\u0885\b\u012d~\2\u0885\u025d\3\2\2" + + "\2\u0886\u0887\5\u012a\u0094\2\u0887\u0888\3\2\2\2\u0888\u0889\b\u012e" + + "\177\2\u0889\u025f\3\2\2\2\u088a\u088b\5\u0130\u0097\2\u088b\u088c\3\2" + + "\2\2\u088c\u088d\b\u012f\u0080\2\u088d\u0261\3\2\2\2\u088e\u088f\5\u013a" + + "\u009c\2\u088f\u0890\3\2\2\2\u0890\u0891\b\u0130\u0081\2\u0891\u0263\3" + + "\2\2\2\u0892\u0893\5\u011e\u008e\2\u0893\u0894\3\2\2\2\u0894\u0895\b\u0131" + + "\u0082\2\u0895\u0265\3\2\2\2\u0896\u0897\5\u0138\u009b\2\u0897\u0898\3" + + "\2\2\2\u0898\u0899\b\u0132\u0083\2\u0899\u0267\3\2\2\2\u089a\u089b\5\u0134" + + "\u0099\2\u089b\u089c\3\2\2\2\u089c\u089d\b\u0133\u0084\2\u089d\u0269\3" + + "\2\2\2\u089e\u089f\5\u0132\u0098\2\u089f\u08a0\3\2\2\2\u08a0\u08a1\b\u0134" + + "\u0085\2\u08a1\u026b\3\2\2\2\u08a2\u08a3\5\u013e\u009e\2\u08a3\u08a4\3" + + "\2\2\2\u08a4\u08a5\b\u0135\u0086\2\u08a5\u026d\3\2\2\2\u08a6\u08a9\5\n" + + "\4\2\u08a7\u08a9\5\b\3\2\u08a8\u08a6\3\2\2\2\u08a8\u08a7\3\2\2\2\u08a9" + + "\u08aa\3\2\2\2\u08aa\u08ab\b\u0136\2\2\u08ab\u026f\3\2\2\2\u08ac\u08ad" + + "\5\f\5\2\u08ad\u08ae\3\2\2\2\u08ae\u08af\b\u0137\2\2\u08af\u0271\3\2\2" + + "\2\u08b0\u08b1\5\16\6\2\u08b1\u08b2\3\2\2\2\u08b2\u08b3\b\u0138\2\2\u08b3" + + "\u0273\3\2\2\2\u08b4\u08b5\13\2\2\2\u08b5\u0275\3\2\2\2;\2\3\4\5\u027c" + + "\u0284\u0286\u0294\u02a0\u02a2\u02a7\u030a\u030e\u0314\u0319\u0474\u047c" + + "\u0567\u056d\u0573\u0577\u057d\u0585\u0588\u058d\u0592\u0598\u059e\u05a4" + + "\u05ac\u05b4\u05ba\u05c2\u05ca\u05cf\u05d3\u05d8\u05e5\u05ef\u05f7\u05fc" + + "\u05fe\u0605\u0608\u063a\u064b\u0652\u0675\u0678\u067c\u0684\u068f\u0696" + + "\u0699\u06ed\u0744\u08a8\u0087\2\3\2\7\5\2\7\2\2\3\20\2\7\3\2\7\4\2\6" + + "\2\2\t\f\2\t\16\2\t\13\2\t\r\2\t\17\2\t\20\2\t\t\2\t\n\2\t\21\2\t\22\2" + + "\t\23\2\t\24\2\t\25\2\t\26\2\t\27\2\t\30\2\t\31\2\t\32\2\t\33\2\t\34\2" + + "\t\35\2\t\36\2\t\37\2\t \2\t!\2\t\"\2\t#\2\t$\2\t%\2\t&\2\t\b\2\t\'\2" + + "\t(\2\t)\2\t*\2\t+\2\t,\2\t-\2\t.\2\t/\2\t\60\2\t\61\2\t\62\2\t\63\2\t" + + "\64\2\t\65\2\tg\2\ti\2\tj\2\tf\2\t\66\2\t\67\2\t8\2\t9\2\t\u0097\2\t\u0098" + + "\2\tN\2\tO\2\tL\2\tM\2\tV\2\th\2\tk\2\t@\2\t?\2\tA\2\tB\2\tC\2\tD\2\t" + + "E\2\tF\2\tG\2\tb\2\tc\2\td\2\te\2\t:\2\t;\2\t<\2\tY\2\tZ\2\t[\2\t\\\2" + + "\t]\2\t^\2\t_\2\t`\2\ta\2\tm\2\tn\2\to\2\tp\2\tq\2\tr\2\ts\2\tt\2\tu\2" + + "\tv\2\tw\2\tx\2\ty\2\tz\2\t{\2\t|\2\t}\2\t~\2\t\177\2\t\u0080\2\t\u0081" + + "\2\t\u0082\2\t\u0083\2\t\u0084\2\t\u0085\2\t\u0086\2\t\u0087\2\t\u0088" + + "\2\t\u0091\2\t\u008c\2\t\u008d\2\t\u008e\2\t\u0093\2\t\u0089\2\t\u0092" + + "\2\t\u0090\2\t\u008f\2\t\u0094\2"; + public static final String _serializedATN = + Utils.join(new String[] {_serializedATNSegment0, _serializedATNSegment1}, ""); + public static final ATN _ATN = new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + public static String[] channelNames = {"DEFAULT_TOKEN_CHANNEL", "HIDDEN"}; + public static String[] modeNames = {"DEFAULT_MODE", "LineString", "MultiLineString", "Inside"}; - protected static final DFA[] _decisionToDFA; - protected static final PredictionContextCache _sharedContextCache = - new PredictionContextCache(); - public static final int - ShebangLine=1, DelimitedComment=2, LineComment=3, WS=4, NL=5, RESERVED=6, - DOT=7, COMMA=8, LPAREN=9, RPAREN=10, LSQUARE=11, RSQUARE=12, LCURL=13, - RCURL=14, MULT=15, MOD=16, DIV=17, ADD=18, SUB=19, INCR=20, DECR=21, CONJ=22, - DISJ=23, EXCL_WS=24, EXCL_NO_WS=25, COLON=26, SEMICOLON=27, ASSIGNMENT=28, - ADD_ASSIGNMENT=29, SUB_ASSIGNMENT=30, MULT_ASSIGNMENT=31, DIV_ASSIGNMENT=32, - MOD_ASSIGNMENT=33, ARROW=34, DOUBLE_ARROW=35, RANGE=36, COLONCOLON=37, - DOUBLE_SEMICOLON=38, HASH=39, AT_NO_WS=40, AT_POST_WS=41, AT_PRE_WS=42, - AT_BOTH_WS=43, QUEST_WS=44, QUEST_NO_WS=45, LANGLE=46, RANGLE=47, LE=48, - GE=49, EXCL_EQ=50, EXCL_EQEQ=51, AS_SAFE=52, EQEQ=53, EQEQEQ=54, SINGLE_QUOTE=55, - RETURN_AT=56, CONTINUE_AT=57, BREAK_AT=58, THIS_AT=59, SUPER_AT=60, FILE=61, - FIELD=62, PROPERTY=63, GET=64, SET=65, RECEIVER=66, PARAM=67, SETPARAM=68, - DELEGATE=69, PACKAGE=70, IMPORT=71, CLASS=72, INTERFACE=73, FUN=74, OBJECT=75, - VAL=76, VAR=77, TYPE_ALIAS=78, CONSTRUCTOR=79, BY=80, COMPANION=81, INIT=82, - THIS=83, SUPER=84, TYPEOF=85, WHERE=86, IF=87, ELSE=88, WHEN=89, TRY=90, - CATCH=91, FINALLY=92, FOR=93, DO=94, WHILE=95, THROW=96, RETURN=97, CONTINUE=98, - BREAK=99, AS=100, IS=101, IN=102, NOT_IS=103, NOT_IN=104, OUT=105, DYNAMIC=106, - PUBLIC=107, PRIVATE=108, PROTECTED=109, INTERNAL=110, ENUM=111, SEALED=112, - ANNOTATION=113, DATA=114, INNER=115, VALUE=116, TAILREC=117, OPERATOR=118, - INLINE=119, INFIX=120, EXTERNAL=121, SUSPEND=122, OVERRIDE=123, ABSTRACT=124, - FINAL=125, OPEN=126, CONST=127, LATEINIT=128, VARARG=129, NOINLINE=130, - CROSSINLINE=131, REIFIED=132, EXPECT=133, ACTUAL=134, RealLiteral=135, - FloatLiteral=136, DoubleLiteral=137, IntegerLiteral=138, HexLiteral=139, - BinLiteral=140, UnsignedLiteral=141, LongLiteral=142, BooleanLiteral=143, - NullLiteral=144, CharacterLiteral=145, Identifier=146, IdentifierOrSoftKey=147, - FieldIdentifier=148, QUOTE_OPEN=149, TRIPLE_QUOTE_OPEN=150, UNICODE_CLASS_LL=151, - UNICODE_CLASS_LM=152, UNICODE_CLASS_LO=153, UNICODE_CLASS_LT=154, UNICODE_CLASS_LU=155, - UNICODE_CLASS_ND=156, UNICODE_CLASS_NL=157, QUOTE_CLOSE=158, LineStrRef=159, - LineStrText=160, LineStrEscapedChar=161, LineStrExprStart=162, TRIPLE_QUOTE_CLOSE=163, - MultiLineStringQuote=164, MultiLineStrRef=165, MultiLineStrText=166, MultiLineStrExprStart=167, - Inside_Comment=168, Inside_WS=169, Inside_NL=170, ErrorCharacter=171; - public static final int - LineString=1, MultiLineString=2, Inside=3; - public static String[] channelNames = { - "DEFAULT_TOKEN_CHANNEL", "HIDDEN" - }; + static { + RuntimeMetaData.checkVersion("4.9.3", RuntimeMetaData.VERSION); + } - public static String[] modeNames = { - "DEFAULT_MODE", "LineString", "MultiLineString", "Inside" - }; + 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); + } - private static String[] makeRuleNames() { - return new String[] { - "ShebangLine", "DelimitedComment", "LineComment", "WS", "NL", "Hidden", - "RESERVED", "DOT", "COMMA", "LPAREN", "RPAREN", "LSQUARE", "RSQUARE", - "LCURL", "RCURL", "MULT", "MOD", "DIV", "ADD", "SUB", "INCR", "DECR", - "CONJ", "DISJ", "EXCL_WS", "EXCL_NO_WS", "COLON", "SEMICOLON", "ASSIGNMENT", - "ADD_ASSIGNMENT", "SUB_ASSIGNMENT", "MULT_ASSIGNMENT", "DIV_ASSIGNMENT", - "MOD_ASSIGNMENT", "ARROW", "DOUBLE_ARROW", "RANGE", "COLONCOLON", "DOUBLE_SEMICOLON", - "HASH", "AT_NO_WS", "AT_POST_WS", "AT_PRE_WS", "AT_BOTH_WS", "QUEST_WS", - "QUEST_NO_WS", "LANGLE", "RANGLE", "LE", "GE", "EXCL_EQ", "EXCL_EQEQ", - "AS_SAFE", "EQEQ", "EQEQEQ", "SINGLE_QUOTE", "RETURN_AT", "CONTINUE_AT", - "BREAK_AT", "THIS_AT", "SUPER_AT", "FILE", "FIELD", "PROPERTY", "GET", - "SET", "RECEIVER", "PARAM", "SETPARAM", "DELEGATE", "PACKAGE", "IMPORT", - "CLASS", "INTERFACE", "FUN", "OBJECT", "VAL", "VAR", "TYPE_ALIAS", "CONSTRUCTOR", - "BY", "COMPANION", "INIT", "THIS", "SUPER", "TYPEOF", "WHERE", "IF", - "ELSE", "WHEN", "TRY", "CATCH", "FINALLY", "FOR", "DO", "WHILE", "THROW", - "RETURN", "CONTINUE", "BREAK", "AS", "IS", "IN", "NOT_IS", "NOT_IN", - "OUT", "DYNAMIC", "PUBLIC", "PRIVATE", "PROTECTED", "INTERNAL", "ENUM", - "SEALED", "ANNOTATION", "DATA", "INNER", "VALUE", "TAILREC", "OPERATOR", - "INLINE", "INFIX", "EXTERNAL", "SUSPEND", "OVERRIDE", "ABSTRACT", "FINAL", - "OPEN", "CONST", "LATEINIT", "VARARG", "NOINLINE", "CROSSINLINE", "REIFIED", - "EXPECT", "ACTUAL", "DecDigit", "DecDigitNoZero", "DecDigitOrSeparator", - "DecDigits", "DoubleExponent", "RealLiteral", "FloatLiteral", "DoubleLiteral", - "IntegerLiteral", "HexDigit", "HexDigitOrSeparator", "HexLiteral", "BinDigit", - "BinDigitOrSeparator", "BinLiteral", "UnsignedLiteral", "LongLiteral", - "BooleanLiteral", "NullLiteral", "CharacterLiteral", "UnicodeDigit", - "Identifier", "IdentifierOrSoftKey", "FieldIdentifier", "UniCharacterLiteral", - "EscapedIdentifier", "EscapeSeq", "Letter", "QUOTE_OPEN", "TRIPLE_QUOTE_OPEN", - "UNICODE_CLASS_LL", "UNICODE_CLASS_LM", "UNICODE_CLASS_LO", "UNICODE_CLASS_LT", - "UNICODE_CLASS_LU", "UNICODE_CLASS_ND", "UNICODE_CLASS_NL", "QUOTE_CLOSE", - "LineStrRef", "LineStrText", "LineStrEscapedChar", "LineStrExprStart", - "TRIPLE_QUOTE_CLOSE", "MultiLineStringQuote", "MultiLineStrRef", "MultiLineStrText", - "MultiLineStrExprStart", "Inside_RPAREN", "Inside_RSQUARE", "Inside_LPAREN", - "Inside_LSQUARE", "Inside_LCURL", "Inside_RCURL", "Inside_DOT", "Inside_COMMA", - "Inside_MULT", "Inside_MOD", "Inside_DIV", "Inside_ADD", "Inside_SUB", - "Inside_INCR", "Inside_DECR", "Inside_CONJ", "Inside_DISJ", "Inside_EXCL_WS", - "Inside_EXCL_NO_WS", "Inside_COLON", "Inside_SEMICOLON", "Inside_ASSIGNMENT", - "Inside_ADD_ASSIGNMENT", "Inside_SUB_ASSIGNMENT", "Inside_MULT_ASSIGNMENT", - "Inside_DIV_ASSIGNMENT", "Inside_MOD_ASSIGNMENT", "Inside_ARROW", "Inside_DOUBLE_ARROW", - "Inside_RANGE", "Inside_RESERVED", "Inside_COLONCOLON", "Inside_DOUBLE_SEMICOLON", - "Inside_HASH", "Inside_AT_NO_WS", "Inside_AT_POST_WS", "Inside_AT_PRE_WS", - "Inside_AT_BOTH_WS", "Inside_QUEST_WS", "Inside_QUEST_NO_WS", "Inside_LANGLE", - "Inside_RANGLE", "Inside_LE", "Inside_GE", "Inside_EXCL_EQ", "Inside_EXCL_EQEQ", - "Inside_IS", "Inside_NOT_IS", "Inside_NOT_IN", "Inside_AS", "Inside_AS_SAFE", - "Inside_EQEQ", "Inside_EQEQEQ", "Inside_SINGLE_QUOTE", "Inside_QUOTE_OPEN", - "Inside_TRIPLE_QUOTE_OPEN", "Inside_VAL", "Inside_VAR", "Inside_FUN", - "Inside_OBJECT", "Inside_SUPER", "Inside_IN", "Inside_OUT", "Inside_FIELD", - "Inside_FILE", "Inside_PROPERTY", "Inside_GET", "Inside_SET", "Inside_RECEIVER", - "Inside_PARAM", "Inside_SETPARAM", "Inside_DELEGATE", "Inside_THROW", - "Inside_RETURN", "Inside_CONTINUE", "Inside_BREAK", "Inside_RETURN_AT", - "Inside_CONTINUE_AT", "Inside_BREAK_AT", "Inside_IF", "Inside_ELSE", - "Inside_WHEN", "Inside_TRY", "Inside_CATCH", "Inside_FINALLY", "Inside_FOR", - "Inside_DO", "Inside_WHILE", "Inside_PUBLIC", "Inside_PRIVATE", "Inside_PROTECTED", - "Inside_INTERNAL", "Inside_ENUM", "Inside_SEALED", "Inside_ANNOTATION", - "Inside_DATA", "Inside_INNER", "Inside_VALUE", "Inside_TAILREC", "Inside_OPERATOR", - "Inside_INLINE", "Inside_INFIX", "Inside_EXTERNAL", "Inside_SUSPEND", - "Inside_OVERRIDE", "Inside_ABSTRACT", "Inside_FINAL", "Inside_OPEN", - "Inside_CONST", "Inside_LATEINIT", "Inside_VARARG", "Inside_NOINLINE", - "Inside_CROSSINLINE", "Inside_REIFIED", "Inside_EXPECT", "Inside_ACTUAL", - "Inside_BooleanLiteral", "Inside_IntegerLiteral", "Inside_HexLiteral", - "Inside_BinLiteral", "Inside_CharacterLiteral", "Inside_RealLiteral", - "Inside_NullLiteral", "Inside_LongLiteral", "Inside_UnsignedLiteral", - "Inside_Identifier", "Inside_Comment", "Inside_WS", "Inside_NL", "ErrorCharacter" - }; - } - public static final String[] ruleNames = makeRuleNames(); + if (tokenNames[i] == null) { + tokenNames[i] = ""; + } + } + } - private static String[] makeLiteralNames() { - return new String[] { - null, null, null, null, null, null, "'...'", "'.'", "','", "'('", "')'", - "'['", "']'", "'{'", "'}'", "'*'", "'%'", "'/'", "'+'", "'-'", "'++'", - "'--'", "'&&'", "'||'", null, "'!'", "':'", "';'", "'='", "'+='", "'-='", - "'*='", "'/='", "'%='", "'->'", "'=>'", "'..'", "'::'", "';;'", "'#'", - "'@'", null, null, null, null, "'?'", "'<'", "'>'", "'<='", "'>='", "'!='", - "'!=='", "'as?'", "'=='", "'==='", "'''", null, null, null, null, null, - "'file'", "'field'", "'property'", "'get'", "'set'", "'receiver'", "'param'", - "'setparam'", "'delegate'", "'package'", "'import'", "'class'", "'interface'", - "'fun'", "'object'", "'val'", "'var'", "'typealias'", "'constructor'", - "'by'", "'companion'", "'init'", "'this'", "'super'", "'typeof'", "'where'", - "'if'", "'else'", "'when'", "'try'", "'catch'", "'finally'", "'for'", - "'do'", "'while'", "'throw'", "'return'", "'continue'", "'break'", "'as'", - "'is'", "'in'", null, null, "'out'", "'dynamic'", "'public'", "'private'", - "'protected'", "'internal'", "'enum'", "'sealed'", "'annotation'", "'data'", - "'inner'", "'value'", "'tailrec'", "'operator'", "'inline'", "'infix'", - "'external'", "'suspend'", "'override'", "'abstract'", "'final'", "'open'", - "'const'", "'lateinit'", "'vararg'", "'noinline'", "'crossinline'", "'reified'", - "'expect'", "'actual'", null, null, null, null, null, null, null, null, - null, "'null'", null, null, null, null, null, "'\"\"\"'" - }; - } - private static final String[] _LITERAL_NAMES = makeLiteralNames(); - private static String[] makeSymbolicNames() { - return new String[] { - null, "ShebangLine", "DelimitedComment", "LineComment", "WS", "NL", "RESERVED", - "DOT", "COMMA", "LPAREN", "RPAREN", "LSQUARE", "RSQUARE", "LCURL", "RCURL", - "MULT", "MOD", "DIV", "ADD", "SUB", "INCR", "DECR", "CONJ", "DISJ", "EXCL_WS", - "EXCL_NO_WS", "COLON", "SEMICOLON", "ASSIGNMENT", "ADD_ASSIGNMENT", "SUB_ASSIGNMENT", - "MULT_ASSIGNMENT", "DIV_ASSIGNMENT", "MOD_ASSIGNMENT", "ARROW", "DOUBLE_ARROW", - "RANGE", "COLONCOLON", "DOUBLE_SEMICOLON", "HASH", "AT_NO_WS", "AT_POST_WS", - "AT_PRE_WS", "AT_BOTH_WS", "QUEST_WS", "QUEST_NO_WS", "LANGLE", "RANGLE", - "LE", "GE", "EXCL_EQ", "EXCL_EQEQ", "AS_SAFE", "EQEQ", "EQEQEQ", "SINGLE_QUOTE", - "RETURN_AT", "CONTINUE_AT", "BREAK_AT", "THIS_AT", "SUPER_AT", "FILE", - "FIELD", "PROPERTY", "GET", "SET", "RECEIVER", "PARAM", "SETPARAM", "DELEGATE", - "PACKAGE", "IMPORT", "CLASS", "INTERFACE", "FUN", "OBJECT", "VAL", "VAR", - "TYPE_ALIAS", "CONSTRUCTOR", "BY", "COMPANION", "INIT", "THIS", "SUPER", - "TYPEOF", "WHERE", "IF", "ELSE", "WHEN", "TRY", "CATCH", "FINALLY", "FOR", - "DO", "WHILE", "THROW", "RETURN", "CONTINUE", "BREAK", "AS", "IS", "IN", - "NOT_IS", "NOT_IN", "OUT", "DYNAMIC", "PUBLIC", "PRIVATE", "PROTECTED", - "INTERNAL", "ENUM", "SEALED", "ANNOTATION", "DATA", "INNER", "VALUE", - "TAILREC", "OPERATOR", "INLINE", "INFIX", "EXTERNAL", "SUSPEND", "OVERRIDE", - "ABSTRACT", "FINAL", "OPEN", "CONST", "LATEINIT", "VARARG", "NOINLINE", - "CROSSINLINE", "REIFIED", "EXPECT", "ACTUAL", "RealLiteral", "FloatLiteral", - "DoubleLiteral", "IntegerLiteral", "HexLiteral", "BinLiteral", "UnsignedLiteral", - "LongLiteral", "BooleanLiteral", "NullLiteral", "CharacterLiteral", "Identifier", - "IdentifierOrSoftKey", "FieldIdentifier", "QUOTE_OPEN", "TRIPLE_QUOTE_OPEN", - "UNICODE_CLASS_LL", "UNICODE_CLASS_LM", "UNICODE_CLASS_LO", "UNICODE_CLASS_LT", - "UNICODE_CLASS_LU", "UNICODE_CLASS_ND", "UNICODE_CLASS_NL", "QUOTE_CLOSE", - "LineStrRef", "LineStrText", "LineStrEscapedChar", "LineStrExprStart", - "TRIPLE_QUOTE_CLOSE", "MultiLineStringQuote", "MultiLineStrRef", "MultiLineStrText", - "MultiLineStrExprStart", "Inside_Comment", "Inside_WS", "Inside_NL", - "ErrorCharacter" - }; - } - private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); - public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } - /** - * @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); - } + public KotlinLexer(CharStream input) { + super(input); + _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache); + } - if (tokenNames[i] == null) { - tokenNames[i] = ""; - } - } - } + private static String[] makeRuleNames() { + return new String[] { + "ShebangLine", + "DelimitedComment", + "LineComment", + "WS", + "NL", + "Hidden", + "RESERVED", + "DOT", + "COMMA", + "LPAREN", + "RPAREN", + "LSQUARE", + "RSQUARE", + "LCURL", + "RCURL", + "MULT", + "MOD", + "DIV", + "ADD", + "SUB", + "INCR", + "DECR", + "CONJ", + "DISJ", + "EXCL_WS", + "EXCL_NO_WS", + "COLON", + "SEMICOLON", + "ASSIGNMENT", + "ADD_ASSIGNMENT", + "SUB_ASSIGNMENT", + "MULT_ASSIGNMENT", + "DIV_ASSIGNMENT", + "MOD_ASSIGNMENT", + "ARROW", + "DOUBLE_ARROW", + "RANGE", + "COLONCOLON", + "DOUBLE_SEMICOLON", + "HASH", + "AT_NO_WS", + "AT_POST_WS", + "AT_PRE_WS", + "AT_BOTH_WS", + "QUEST_WS", + "QUEST_NO_WS", + "LANGLE", + "RANGLE", + "LE", + "GE", + "EXCL_EQ", + "EXCL_EQEQ", + "AS_SAFE", + "EQEQ", + "EQEQEQ", + "SINGLE_QUOTE", + "RETURN_AT", + "CONTINUE_AT", + "BREAK_AT", + "THIS_AT", + "SUPER_AT", + "FILE", + "FIELD", + "PROPERTY", + "GET", + "SET", + "RECEIVER", + "PARAM", + "SETPARAM", + "DELEGATE", + "PACKAGE", + "IMPORT", + "CLASS", + "INTERFACE", + "FUN", + "OBJECT", + "VAL", + "VAR", + "TYPE_ALIAS", + "CONSTRUCTOR", + "BY", + "COMPANION", + "INIT", + "THIS", + "SUPER", + "TYPEOF", + "WHERE", + "IF", + "ELSE", + "WHEN", + "TRY", + "CATCH", + "FINALLY", + "FOR", + "DO", + "WHILE", + "THROW", + "RETURN", + "CONTINUE", + "BREAK", + "AS", + "IS", + "IN", + "NOT_IS", + "NOT_IN", + "OUT", + "DYNAMIC", + "PUBLIC", + "PRIVATE", + "PROTECTED", + "INTERNAL", + "ENUM", + "SEALED", + "ANNOTATION", + "DATA", + "INNER", + "VALUE", + "TAILREC", + "OPERATOR", + "INLINE", + "INFIX", + "EXTERNAL", + "SUSPEND", + "OVERRIDE", + "ABSTRACT", + "FINAL", + "OPEN", + "CONST", + "LATEINIT", + "VARARG", + "NOINLINE", + "CROSSINLINE", + "REIFIED", + "EXPECT", + "ACTUAL", + "DecDigit", + "DecDigitNoZero", + "DecDigitOrSeparator", + "DecDigits", + "DoubleExponent", + "RealLiteral", + "FloatLiteral", + "DoubleLiteral", + "IntegerLiteral", + "HexDigit", + "HexDigitOrSeparator", + "HexLiteral", + "BinDigit", + "BinDigitOrSeparator", + "BinLiteral", + "UnsignedLiteral", + "LongLiteral", + "BooleanLiteral", + "NullLiteral", + "CharacterLiteral", + "UnicodeDigit", + "Identifier", + "IdentifierOrSoftKey", + "FieldIdentifier", + "UniCharacterLiteral", + "EscapedIdentifier", + "EscapeSeq", + "Letter", + "QUOTE_OPEN", + "TRIPLE_QUOTE_OPEN", + "UNICODE_CLASS_LL", + "UNICODE_CLASS_LM", + "UNICODE_CLASS_LO", + "UNICODE_CLASS_LT", + "UNICODE_CLASS_LU", + "UNICODE_CLASS_ND", + "UNICODE_CLASS_NL", + "QUOTE_CLOSE", + "LineStrRef", + "LineStrText", + "LineStrEscapedChar", + "LineStrExprStart", + "TRIPLE_QUOTE_CLOSE", + "MultiLineStringQuote", + "MultiLineStrRef", + "MultiLineStrText", + "MultiLineStrExprStart", + "Inside_RPAREN", + "Inside_RSQUARE", + "Inside_LPAREN", + "Inside_LSQUARE", + "Inside_LCURL", + "Inside_RCURL", + "Inside_DOT", + "Inside_COMMA", + "Inside_MULT", + "Inside_MOD", + "Inside_DIV", + "Inside_ADD", + "Inside_SUB", + "Inside_INCR", + "Inside_DECR", + "Inside_CONJ", + "Inside_DISJ", + "Inside_EXCL_WS", + "Inside_EXCL_NO_WS", + "Inside_COLON", + "Inside_SEMICOLON", + "Inside_ASSIGNMENT", + "Inside_ADD_ASSIGNMENT", + "Inside_SUB_ASSIGNMENT", + "Inside_MULT_ASSIGNMENT", + "Inside_DIV_ASSIGNMENT", + "Inside_MOD_ASSIGNMENT", + "Inside_ARROW", + "Inside_DOUBLE_ARROW", + "Inside_RANGE", + "Inside_RESERVED", + "Inside_COLONCOLON", + "Inside_DOUBLE_SEMICOLON", + "Inside_HASH", + "Inside_AT_NO_WS", + "Inside_AT_POST_WS", + "Inside_AT_PRE_WS", + "Inside_AT_BOTH_WS", + "Inside_QUEST_WS", + "Inside_QUEST_NO_WS", + "Inside_LANGLE", + "Inside_RANGLE", + "Inside_LE", + "Inside_GE", + "Inside_EXCL_EQ", + "Inside_EXCL_EQEQ", + "Inside_IS", + "Inside_NOT_IS", + "Inside_NOT_IN", + "Inside_AS", + "Inside_AS_SAFE", + "Inside_EQEQ", + "Inside_EQEQEQ", + "Inside_SINGLE_QUOTE", + "Inside_QUOTE_OPEN", + "Inside_TRIPLE_QUOTE_OPEN", + "Inside_VAL", + "Inside_VAR", + "Inside_FUN", + "Inside_OBJECT", + "Inside_SUPER", + "Inside_IN", + "Inside_OUT", + "Inside_FIELD", + "Inside_FILE", + "Inside_PROPERTY", + "Inside_GET", + "Inside_SET", + "Inside_RECEIVER", + "Inside_PARAM", + "Inside_SETPARAM", + "Inside_DELEGATE", + "Inside_THROW", + "Inside_RETURN", + "Inside_CONTINUE", + "Inside_BREAK", + "Inside_RETURN_AT", + "Inside_CONTINUE_AT", + "Inside_BREAK_AT", + "Inside_IF", + "Inside_ELSE", + "Inside_WHEN", + "Inside_TRY", + "Inside_CATCH", + "Inside_FINALLY", + "Inside_FOR", + "Inside_DO", + "Inside_WHILE", + "Inside_PUBLIC", + "Inside_PRIVATE", + "Inside_PROTECTED", + "Inside_INTERNAL", + "Inside_ENUM", + "Inside_SEALED", + "Inside_ANNOTATION", + "Inside_DATA", + "Inside_INNER", + "Inside_VALUE", + "Inside_TAILREC", + "Inside_OPERATOR", + "Inside_INLINE", + "Inside_INFIX", + "Inside_EXTERNAL", + "Inside_SUSPEND", + "Inside_OVERRIDE", + "Inside_ABSTRACT", + "Inside_FINAL", + "Inside_OPEN", + "Inside_CONST", + "Inside_LATEINIT", + "Inside_VARARG", + "Inside_NOINLINE", + "Inside_CROSSINLINE", + "Inside_REIFIED", + "Inside_EXPECT", + "Inside_ACTUAL", + "Inside_BooleanLiteral", + "Inside_IntegerLiteral", + "Inside_HexLiteral", + "Inside_BinLiteral", + "Inside_CharacterLiteral", + "Inside_RealLiteral", + "Inside_NullLiteral", + "Inside_LongLiteral", + "Inside_UnsignedLiteral", + "Inside_Identifier", + "Inside_Comment", + "Inside_WS", + "Inside_NL", + "ErrorCharacter" + }; + } - @Override - @Deprecated - public String[] getTokenNames() { - return tokenNames; - } + private static String[] makeLiteralNames() { + return new String[] { + null, + null, + null, + null, + null, + null, + "'...'", + "'.'", + "','", + "'('", + "')'", + "'['", + "']'", + "'{'", + "'}'", + "'*'", + "'%'", + "'/'", + "'+'", + "'-'", + "'++'", + "'--'", + "'&&'", + "'||'", + null, + "'!'", + "':'", + "';'", + "'='", + "'+='", + "'-='", + "'*='", + "'/='", + "'%='", + "'->'", + "'=>'", + "'..'", + "'::'", + "';;'", + "'#'", + "'@'", + null, + null, + null, + null, + "'?'", + "'<'", + "'>'", + "'<='", + "'>='", + "'!='", + "'!=='", + "'as?'", + "'=='", + "'==='", + "'''", + null, + null, + null, + null, + null, + "'file'", + "'field'", + "'property'", + "'get'", + "'set'", + "'receiver'", + "'param'", + "'setparam'", + "'delegate'", + "'package'", + "'import'", + "'class'", + "'interface'", + "'fun'", + "'object'", + "'val'", + "'var'", + "'typealias'", + "'constructor'", + "'by'", + "'companion'", + "'init'", + "'this'", + "'super'", + "'typeof'", + "'where'", + "'if'", + "'else'", + "'when'", + "'try'", + "'catch'", + "'finally'", + "'for'", + "'do'", + "'while'", + "'throw'", + "'return'", + "'continue'", + "'break'", + "'as'", + "'is'", + "'in'", + null, + null, + "'out'", + "'dynamic'", + "'public'", + "'private'", + "'protected'", + "'internal'", + "'enum'", + "'sealed'", + "'annotation'", + "'data'", + "'inner'", + "'value'", + "'tailrec'", + "'operator'", + "'inline'", + "'infix'", + "'external'", + "'suspend'", + "'override'", + "'abstract'", + "'final'", + "'open'", + "'const'", + "'lateinit'", + "'vararg'", + "'noinline'", + "'crossinline'", + "'reified'", + "'expect'", + "'actual'", + null, + null, + null, + null, + null, + null, + null, + null, + null, + "'null'", + null, + null, + null, + null, + null, + "'\"\"\"'" + }; + } - @Override + private static String[] makeSymbolicNames() { + return new String[] { + null, + "ShebangLine", + "DelimitedComment", + "LineComment", + "WS", + "NL", + "RESERVED", + "DOT", + "COMMA", + "LPAREN", + "RPAREN", + "LSQUARE", + "RSQUARE", + "LCURL", + "RCURL", + "MULT", + "MOD", + "DIV", + "ADD", + "SUB", + "INCR", + "DECR", + "CONJ", + "DISJ", + "EXCL_WS", + "EXCL_NO_WS", + "COLON", + "SEMICOLON", + "ASSIGNMENT", + "ADD_ASSIGNMENT", + "SUB_ASSIGNMENT", + "MULT_ASSIGNMENT", + "DIV_ASSIGNMENT", + "MOD_ASSIGNMENT", + "ARROW", + "DOUBLE_ARROW", + "RANGE", + "COLONCOLON", + "DOUBLE_SEMICOLON", + "HASH", + "AT_NO_WS", + "AT_POST_WS", + "AT_PRE_WS", + "AT_BOTH_WS", + "QUEST_WS", + "QUEST_NO_WS", + "LANGLE", + "RANGLE", + "LE", + "GE", + "EXCL_EQ", + "EXCL_EQEQ", + "AS_SAFE", + "EQEQ", + "EQEQEQ", + "SINGLE_QUOTE", + "RETURN_AT", + "CONTINUE_AT", + "BREAK_AT", + "THIS_AT", + "SUPER_AT", + "FILE", + "FIELD", + "PROPERTY", + "GET", + "SET", + "RECEIVER", + "PARAM", + "SETPARAM", + "DELEGATE", + "PACKAGE", + "IMPORT", + "CLASS", + "INTERFACE", + "FUN", + "OBJECT", + "VAL", + "VAR", + "TYPE_ALIAS", + "CONSTRUCTOR", + "BY", + "COMPANION", + "INIT", + "THIS", + "SUPER", + "TYPEOF", + "WHERE", + "IF", + "ELSE", + "WHEN", + "TRY", + "CATCH", + "FINALLY", + "FOR", + "DO", + "WHILE", + "THROW", + "RETURN", + "CONTINUE", + "BREAK", + "AS", + "IS", + "IN", + "NOT_IS", + "NOT_IN", + "OUT", + "DYNAMIC", + "PUBLIC", + "PRIVATE", + "PROTECTED", + "INTERNAL", + "ENUM", + "SEALED", + "ANNOTATION", + "DATA", + "INNER", + "VALUE", + "TAILREC", + "OPERATOR", + "INLINE", + "INFIX", + "EXTERNAL", + "SUSPEND", + "OVERRIDE", + "ABSTRACT", + "FINAL", + "OPEN", + "CONST", + "LATEINIT", + "VARARG", + "NOINLINE", + "CROSSINLINE", + "REIFIED", + "EXPECT", + "ACTUAL", + "RealLiteral", + "FloatLiteral", + "DoubleLiteral", + "IntegerLiteral", + "HexLiteral", + "BinLiteral", + "UnsignedLiteral", + "LongLiteral", + "BooleanLiteral", + "NullLiteral", + "CharacterLiteral", + "Identifier", + "IdentifierOrSoftKey", + "FieldIdentifier", + "QUOTE_OPEN", + "TRIPLE_QUOTE_OPEN", + "UNICODE_CLASS_LL", + "UNICODE_CLASS_LM", + "UNICODE_CLASS_LO", + "UNICODE_CLASS_LT", + "UNICODE_CLASS_LU", + "UNICODE_CLASS_ND", + "UNICODE_CLASS_NL", + "QUOTE_CLOSE", + "LineStrRef", + "LineStrText", + "LineStrEscapedChar", + "LineStrExprStart", + "TRIPLE_QUOTE_CLOSE", + "MultiLineStringQuote", + "MultiLineStrRef", + "MultiLineStrText", + "MultiLineStrExprStart", + "Inside_Comment", + "Inside_WS", + "Inside_NL", + "ErrorCharacter" + }; + } - public Vocabulary getVocabulary() { - return VOCABULARY; - } + @Override + public String[] getRuleNames() { + return ruleNames; + } + @Override + public Vocabulary getVocabulary() { + return VOCABULARY; + } - public KotlinLexer(CharStream input) { - super(input); - _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); - } + @Override + public String getSerializedATN() { + return _serializedATN; + } - @Override - public String getGrammarFileName() { return "KotlinLexer.g4"; } + @Override + public String getGrammarFileName() { + return "KotlinLexer.g4"; + } - @Override - public String[] getRuleNames() { return ruleNames; } + @Override + public ATN getATN() { + return _ATN; + } - @Override - public String getSerializedATN() { return _serializedATN; } + @Override + public void action(RuleContext _localctx, int ruleIndex, int actionIndex) { + switch (ruleIndex) { + case 14: + RCURL_action((RuleContext) _localctx, actionIndex); + break; + } + } - @Override - public String[] getChannelNames() { return channelNames; } + private void RCURL_action(RuleContext _localctx, int actionIndex) { + switch (actionIndex) { + case 0: + if (!_modeStack.isEmpty()) { + popMode(); + } + break; + } + } - @Override - public String[] getModeNames() { return modeNames; } + @Override + public String[] getChannelNames() { + return channelNames; + } - @Override - public ATN getATN() { return _ATN; } + @Override + public String[] getModeNames() { + return modeNames; + } - @Override - public void action(RuleContext _localctx, int ruleIndex, int actionIndex) { - switch (ruleIndex) { - case 14: - RCURL_action((RuleContext)_localctx, actionIndex); - break; - } - } - private void RCURL_action(RuleContext _localctx, int actionIndex) { - switch (actionIndex) { - case 0: - if (!_modeStack.isEmpty()) { popMode(); } - break; - } - } - - private static final int _serializedATNSegments = 2; - private static final String _serializedATNSegment0 = - "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\u00ad\u08b6\b\1\b"+ - "\1\b\1\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\t"+ - "F\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4"+ - "R\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\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\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\4\u00bf\t\u00bf\4\u00c0\t\u00c0\4\u00c1\t\u00c1\4\u00c2\t\u00c2"+ - "\4\u00c3\t\u00c3\4\u00c4\t\u00c4\4\u00c5\t\u00c5\4\u00c6\t\u00c6\4\u00c7"+ - "\t\u00c7\4\u00c8\t\u00c8\4\u00c9\t\u00c9\4\u00ca\t\u00ca\4\u00cb\t\u00cb"+ - "\4\u00cc\t\u00cc\4\u00cd\t\u00cd\4\u00ce\t\u00ce\4\u00cf\t\u00cf\4\u00d0"+ - "\t\u00d0\4\u00d1\t\u00d1\4\u00d2\t\u00d2\4\u00d3\t\u00d3\4\u00d4\t\u00d4"+ - "\4\u00d5\t\u00d5\4\u00d6\t\u00d6\4\u00d7\t\u00d7\4\u00d8\t\u00d8\4\u00d9"+ - "\t\u00d9\4\u00da\t\u00da\4\u00db\t\u00db\4\u00dc\t\u00dc\4\u00dd\t\u00dd"+ - "\4\u00de\t\u00de\4\u00df\t\u00df\4\u00e0\t\u00e0\4\u00e1\t\u00e1\4\u00e2"+ - "\t\u00e2\4\u00e3\t\u00e3\4\u00e4\t\u00e4\4\u00e5\t\u00e5\4\u00e6\t\u00e6"+ - "\4\u00e7\t\u00e7\4\u00e8\t\u00e8\4\u00e9\t\u00e9\4\u00ea\t\u00ea\4\u00eb"+ - "\t\u00eb\4\u00ec\t\u00ec\4\u00ed\t\u00ed\4\u00ee\t\u00ee\4\u00ef\t\u00ef"+ - "\4\u00f0\t\u00f0\4\u00f1\t\u00f1\4\u00f2\t\u00f2\4\u00f3\t\u00f3\4\u00f4"+ - "\t\u00f4\4\u00f5\t\u00f5\4\u00f6\t\u00f6\4\u00f7\t\u00f7\4\u00f8\t\u00f8"+ - "\4\u00f9\t\u00f9\4\u00fa\t\u00fa\4\u00fb\t\u00fb\4\u00fc\t\u00fc\4\u00fd"+ - "\t\u00fd\4\u00fe\t\u00fe\4\u00ff\t\u00ff\4\u0100\t\u0100\4\u0101\t\u0101"+ - "\4\u0102\t\u0102\4\u0103\t\u0103\4\u0104\t\u0104\4\u0105\t\u0105\4\u0106"+ - "\t\u0106\4\u0107\t\u0107\4\u0108\t\u0108\4\u0109\t\u0109\4\u010a\t\u010a"+ - "\4\u010b\t\u010b\4\u010c\t\u010c\4\u010d\t\u010d\4\u010e\t\u010e\4\u010f"+ - "\t\u010f\4\u0110\t\u0110\4\u0111\t\u0111\4\u0112\t\u0112\4\u0113\t\u0113"+ - "\4\u0114\t\u0114\4\u0115\t\u0115\4\u0116\t\u0116\4\u0117\t\u0117\4\u0118"+ - "\t\u0118\4\u0119\t\u0119\4\u011a\t\u011a\4\u011b\t\u011b\4\u011c\t\u011c"+ - "\4\u011d\t\u011d\4\u011e\t\u011e\4\u011f\t\u011f\4\u0120\t\u0120\4\u0121"+ - "\t\u0121\4\u0122\t\u0122\4\u0123\t\u0123\4\u0124\t\u0124\4\u0125\t\u0125"+ - "\4\u0126\t\u0126\4\u0127\t\u0127\4\u0128\t\u0128\4\u0129\t\u0129\4\u012a"+ - "\t\u012a\4\u012b\t\u012b\4\u012c\t\u012c\4\u012d\t\u012d\4\u012e\t\u012e"+ - "\4\u012f\t\u012f\4\u0130\t\u0130\4\u0131\t\u0131\4\u0132\t\u0132\4\u0133"+ - "\t\u0133\4\u0134\t\u0134\4\u0135\t\u0135\4\u0136\t\u0136\4\u0137\t\u0137"+ - "\4\u0138\t\u0138\4\u0139\t\u0139\3\2\3\2\3\2\3\2\7\2\u027b\n\2\f\2\16"+ - "\2\u027e\13\2\3\3\3\3\3\3\3\3\3\3\7\3\u0285\n\3\f\3\16\3\u0288\13\3\3"+ - "\3\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3\4\7\4\u0293\n\4\f\4\16\4\u0296\13\4\3"+ - "\4\3\4\3\5\3\5\3\5\3\5\3\6\3\6\3\6\5\6\u02a1\n\6\5\6\u02a3\n\6\3\7\3\7"+ - "\3\7\5\7\u02a8\n\7\3\b\3\b\3\b\3\b\3\t\3\t\3\n\3\n\3\13\3\13\3\13\3\13"+ - "\3\f\3\f\3\r\3\r\3\r\3\r\3\16\3\16\3\17\3\17\3\17\3\17\3\20\3\20\3\20"+ - "\3\21\3\21\3\22\3\22\3\23\3\23\3\24\3\24\3\25\3\25\3\26\3\26\3\26\3\27"+ - "\3\27\3\27\3\30\3\30\3\30\3\31\3\31\3\31\3\32\3\32\3\32\3\33\3\33\3\34"+ - "\3\34\3\35\3\35\3\36\3\36\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+\5+\u030b\n+\3,\3,\5,\u030f\n,\3,\3,\3-\3-\5-\u0315\n-\3-\3-"+ - "\3-\5-\u031a\n-\3.\3.\3.\3/\3/\3\60\3\60\3\61\3\61\3\62\3\62\3\62\3\63"+ - "\3\63\3\63\3\64\3\64\3\64\3\65\3\65\3\65\3\65\3\66\3\66\3\66\3\66\3\67"+ - "\3\67\3\67\38\38\38\38\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"+ - "A\3A\3A\3A\3A\3A\3A\3A\3A\3B\3B\3B\3B\3C\3C\3C\3C\3D\3D\3D\3D\3D\3D\3"+ - "D\3D\3D\3E\3E\3E\3E\3E\3E\3F\3F\3F\3F\3F\3F\3F\3F\3F\3G\3G\3G\3G\3G\3"+ - "G\3G\3G\3G\3H\3H\3H\3H\3H\3H\3H\3H\3I\3I\3I\3I\3I\3I\3I\3J\3J\3J\3J\3"+ - "J\3J\3K\3K\3K\3K\3K\3K\3K\3K\3K\3K\3L\3L\3L\3L\3M\3M\3M\3M\3M\3M\3M\3"+ - "N\3N\3N\3N\3O\3O\3O\3O\3P\3P\3P\3P\3P\3P\3P\3P\3P\3P\3Q\3Q\3Q\3Q\3Q\3"+ - "Q\3Q\3Q\3Q\3Q\3Q\3Q\3R\3R\3R\3S\3S\3S\3S\3S\3S\3S\3S\3S\3S\3T\3T\3T\3"+ - "T\3T\3U\3U\3U\3U\3U\3V\3V\3V\3V\3V\3V\3W\3W\3W\3W\3W\3W\3W\3X\3X\3X\3"+ - "X\3X\3X\3Y\3Y\3Y\3Z\3Z\3Z\3Z\3Z\3[\3[\3[\3[\3[\3\\\3\\\3\\\3\\\3]\3]\3"+ - "]\3]\3]\3]\3^\3^\3^\3^\3^\3^\3^\3^\3_\3_\3_\3_\3`\3`\3`\3a\3a\3a\3a\3"+ - "a\3a\3b\3b\3b\3b\3b\3b\3c\3c\3c\3c\3c\3c\3c\3d\3d\3d\3d\3d\3d\3d\3d\3"+ - "d\3e\3e\3e\3e\3e\3e\3f\3f\3f\3g\3g\3g\3h\3h\3h\3i\3i\3i\3i\3i\3i\5i\u0475"+ - "\ni\3j\3j\3j\3j\3j\3j\5j\u047d\nj\3k\3k\3k\3k\3l\3l\3l\3l\3l\3l\3l\3l"+ - "\3m\3m\3m\3m\3m\3m\3m\3n\3n\3n\3n\3n\3n\3n\3n\3o\3o\3o\3o\3o\3o\3o\3o"+ - "\3o\3o\3p\3p\3p\3p\3p\3p\3p\3p\3p\3q\3q\3q\3q\3q\3r\3r\3r\3r\3r\3r\3r"+ - "\3s\3s\3s\3s\3s\3s\3s\3s\3s\3s\3s\3t\3t\3t\3t\3t\3u\3u\3u\3u\3u\3u\3v"+ - "\3v\3v\3v\3v\3v\3w\3w\3w\3w\3w\3w\3w\3w\3x\3x\3x\3x\3x\3x\3x\3x\3x\3y"+ - "\3y\3y\3y\3y\3y\3y\3z\3z\3z\3z\3z\3z\3{\3{\3{\3{\3{\3{\3{\3{\3{\3|\3|"+ - "\3|\3|\3|\3|\3|\3|\3}\3}\3}\3}\3}\3}\3}\3}\3}\3~\3~\3~\3~\3~\3~\3~\3~"+ - "\3~\3\177\3\177\3\177\3\177\3\177\3\177\3\u0080\3\u0080\3\u0080\3\u0080"+ - "\3\u0080\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\3\u0081\3\u0082\3\u0082"+ - "\3\u0082\3\u0082\3\u0082\3\u0082\3\u0082\3\u0082\3\u0082\3\u0083\3\u0083"+ - "\3\u0083\3\u0083\3\u0083\3\u0083\3\u0083\3\u0084\3\u0084\3\u0084\3\u0084"+ - "\3\u0084\3\u0084\3\u0084\3\u0084\3\u0084\3\u0085\3\u0085\3\u0085\3\u0085"+ - "\3\u0085\3\u0085\3\u0085\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\u0087\3\u0087"+ - "\3\u0087\3\u0087\3\u0087\3\u0087\3\u0087\3\u0088\3\u0088\3\u0088\3\u0088"+ - "\3\u0088\3\u0088\3\u0088\3\u0089\3\u0089\3\u008a\3\u008a\3\u008b\3\u008b"+ - "\5\u008b\u0568\n\u008b\3\u008c\3\u008c\7\u008c\u056c\n\u008c\f\u008c\16"+ - "\u008c\u056f\13\u008c\3\u008c\3\u008c\3\u008c\5\u008c\u0574\n\u008c\3"+ - "\u008d\3\u008d\5\u008d\u0578\n\u008d\3\u008d\3\u008d\3\u008e\3\u008e\5"+ - "\u008e\u057e\n\u008e\3\u008f\3\u008f\3\u008f\3\u008f\3\u008f\3\u008f\5"+ - "\u008f\u0586\n\u008f\3\u0090\5\u0090\u0589\n\u0090\3\u0090\3\u0090\3\u0090"+ - "\5\u0090\u058e\n\u0090\3\u0090\3\u0090\3\u0090\5\u0090\u0593\n\u0090\3"+ - "\u0091\3\u0091\7\u0091\u0597\n\u0091\f\u0091\16\u0091\u059a\13\u0091\3"+ - "\u0091\3\u0091\3\u0091\5\u0091\u059f\n\u0091\3\u0092\3\u0092\3\u0093\3"+ - "\u0093\5\u0093\u05a5\n\u0093\3\u0094\3\u0094\3\u0094\3\u0094\7\u0094\u05ab"+ - "\n\u0094\f\u0094\16\u0094\u05ae\13\u0094\3\u0094\3\u0094\3\u0094\3\u0094"+ - "\3\u0094\5\u0094\u05b5\n\u0094\3\u0095\3\u0095\3\u0096\3\u0096\5\u0096"+ - "\u05bb\n\u0096\3\u0097\3\u0097\3\u0097\3\u0097\7\u0097\u05c1\n\u0097\f"+ - "\u0097\16\u0097\u05c4\13\u0097\3\u0097\3\u0097\3\u0097\3\u0097\3\u0097"+ - "\5\u0097\u05cb\n\u0097\3\u0098\3\u0098\3\u0098\5\u0098\u05d0\n\u0098\3"+ - "\u0098\3\u0098\5\u0098\u05d4\n\u0098\3\u0099\3\u0099\3\u0099\5\u0099\u05d9"+ - "\n\u0099\3\u0099\3\u0099\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a\3\u009a"+ - "\3\u009a\3\u009a\3\u009a\5\u009a\u05e6\n\u009a\3\u009b\3\u009b\3\u009b"+ - "\3\u009b\3\u009b\3\u009c\3\u009c\3\u009c\5\u009c\u05f0\n\u009c\3\u009c"+ - "\3\u009c\3\u009d\3\u009d\3\u009e\3\u009e\5\u009e\u05f8\n\u009e\3\u009e"+ - "\3\u009e\3\u009e\7\u009e\u05fd\n\u009e\f\u009e\16\u009e\u0600\13\u009e"+ - "\3\u009e\3\u009e\6\u009e\u0604\n\u009e\r\u009e\16\u009e\u0605\3\u009e"+ - "\5\u009e\u0609\n\u009e\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f"+ - "\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f"+ - "\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f"+ - "\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f"+ - "\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f"+ - "\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\3\u009f\5\u009f\u063b\n\u009f"+ - "\3\u00a0\3\u00a0\3\u00a0\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1\3\u00a1"+ - "\3\u00a1\3\u00a2\3\u00a2\3\u00a2\3\u00a3\3\u00a3\5\u00a3\u064c\n\u00a3"+ - "\3\u00a4\3\u00a4\3\u00a4\3\u00a4\3\u00a4\5\u00a4\u0653\n\u00a4\3\u00a5"+ - "\3\u00a5\3\u00a5\3\u00a5\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6\3\u00a6"+ - "\3\u00a7\3\u00a7\3\u00a8\3\u00a8\3\u00a9\3\u00a9\3\u00aa\3\u00aa\3\u00ab"+ - "\3\u00ab\3\u00ac\3\u00ac\3\u00ad\3\u00ad\3\u00ae\3\u00ae\3\u00ae\3\u00ae"+ - "\3\u00af\3\u00af\3\u00b0\6\u00b0\u0674\n\u00b0\r\u00b0\16\u00b0\u0675"+ - "\3\u00b0\5\u00b0\u0679\n\u00b0\3\u00b1\3\u00b1\5\u00b1\u067d\n\u00b1\3"+ - "\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b2\3\u00b3\5\u00b3\u0685\n\u00b3\3"+ - "\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b3\3\u00b4\6\u00b4\u068e\n"+ - "\u00b4\r\u00b4\16\u00b4\u068f\3\u00b5\3\u00b5\3\u00b6\6\u00b6\u0695\n"+ - "\u00b6\r\u00b6\16\u00b6\u0696\3\u00b6\5\u00b6\u069a\n\u00b6\3\u00b7\3"+ - "\u00b7\3\u00b7\3\u00b7\3\u00b7\3\u00b8\3\u00b8\3\u00b8\3\u00b8\3\u00b8"+ - "\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00b9\3\u00ba\3\u00ba\3\u00ba\3\u00ba"+ - "\3\u00ba\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bb\3\u00bc\3\u00bc\3\u00bc"+ - "\3\u00bc\3\u00bc\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00bd\3\u00be\3\u00be"+ - "\3\u00be\3\u00be\3\u00bf\3\u00bf\3\u00bf\3\u00bf\3\u00c0\3\u00c0\3\u00c0"+ - "\3\u00c0\3\u00c1\3\u00c1\3\u00c1\3\u00c1\3\u00c2\3\u00c2\3\u00c2\3\u00c2"+ - "\3\u00c3\3\u00c3\3\u00c3\3\u00c3\3\u00c4\3\u00c4\3\u00c4\3\u00c4\3\u00c5"+ - "\3\u00c5\3\u00c5\3\u00c5\3\u00c6\3\u00c6\3\u00c6\3\u00c6\3\u00c7\3\u00c7"+ - "\3\u00c7\3\u00c7\3\u00c8\3\u00c8\3\u00c8\3\u00c8\3\u00c9\3\u00c9\3\u00c9"+ - "\5\u00c9\u06ee\n\u00c9\3\u00c9\3\u00c9\3\u00ca\3\u00ca\3\u00ca\3\u00ca"+ - "\3\u00cb\3\u00cb\3\u00cb\3\u00cb\3\u00cc\3\u00cc\3\u00cc\3\u00cc\3\u00cd"+ - "\3\u00cd\3\u00cd\3\u00cd\3\u00ce\3\u00ce\3\u00ce\3\u00ce\3\u00cf\3\u00cf"+ - "\3\u00cf\3\u00cf\3\u00d0\3\u00d0\3\u00d0\3\u00d0\3\u00d1\3\u00d1\3\u00d1"+ - "\3\u00d1\3\u00d2\3\u00d2\3\u00d2\3\u00d2\3\u00d3\3\u00d3\3\u00d3\3\u00d3"+ - "\3\u00d4\3\u00d4\3\u00d4\3\u00d4\3\u00d5\3\u00d5\3\u00d5\3\u00d5\3\u00d6"+ - "\3\u00d6\3\u00d6\3\u00d6\3\u00d7\3\u00d7\3\u00d7\3\u00d7\3\u00d8\3\u00d8"+ - "\3\u00d8\3\u00d8\3\u00d9\3\u00d9\3\u00d9\3\u00d9\3\u00da\3\u00da\3\u00da"+ - "\3\u00da\3\u00db\3\u00db\3\u00db\3\u00db\3\u00dc\3\u00dc\3\u00dc\3\u00dc"+ - "\3\u00dd\3\u00dd\3\u00dd\3\u00dd\3\u00de\3\u00de\3\u00de\5\u00de\u0745"+ - "\n\u00de\3\u00de\3\u00de\3\u00df\3\u00df\3\u00df\3\u00df\3\u00e0\3\u00e0"+ - "\3\u00e0\3\u00e0\3\u00e1\3\u00e1\3\u00e1\3\u00e1\3\u00e2\3\u00e2\3\u00e2"+ - "\3\u00e2\3\u00e3\3\u00e3\3\u00e3\3\u00e3\3\u00e4\3\u00e4\3\u00e4\3\u00e4"+ - "\3\u00e5\3\u00e5\3\u00e5\3\u00e5\3\u00e6\3\u00e6\3\u00e6\3\u00e6\3\u00e7"+ - "\3\u00e7\3\u00e7\3\u00e7\3\u00e8\3\u00e8\3\u00e8\3\u00e8\3\u00e9\3\u00e9"+ - "\3\u00e9\3\u00e9\3\u00ea\3\u00ea\3\u00ea\3\u00ea\3\u00eb\3\u00eb\3\u00eb"+ - "\3\u00eb\3\u00ec\3\u00ec\3\u00ec\3\u00ec\3\u00ed\3\u00ed\3\u00ed\3\u00ed"+ - "\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ee\3\u00ef\3\u00ef\3\u00ef\3\u00ef"+ - "\3\u00ef\3\u00f0\3\u00f0\3\u00f0\3\u00f0\3\u00f1\3\u00f1\3\u00f1\3\u00f1"+ - "\3\u00f2\3\u00f2\3\u00f2\3\u00f2\3\u00f3\3\u00f3\3\u00f3\3\u00f3\3\u00f4"+ - "\3\u00f4\3\u00f4\3\u00f4\3\u00f5\3\u00f5\3\u00f5\3\u00f5\3\u00f6\3\u00f6"+ - "\3\u00f6\3\u00f6\3\u00f7\3\u00f7\3\u00f7\3\u00f7\3\u00f8\3\u00f8\3\u00f8"+ - "\3\u00f8\3\u00f9\3\u00f9\3\u00f9\3\u00f9\3\u00fa\3\u00fa\3\u00fa\3\u00fa"+ - "\3\u00fb\3\u00fb\3\u00fb\3\u00fb\3\u00fc\3\u00fc\3\u00fc\3\u00fc\3\u00fd"+ - "\3\u00fd\3\u00fd\3\u00fd\3\u00fe\3\u00fe\3\u00fe\3\u00fe\3\u00ff\3\u00ff"+ - "\3\u00ff\3\u00ff\3\u0100\3\u0100\3\u0100\3\u0100\3\u0101\3\u0101\3\u0101"+ - "\3\u0101\3\u0102\3\u0102\3\u0102\3\u0102\3\u0103\3\u0103\3\u0103\3\u0103"+ - "\3\u0104\3\u0104\3\u0104\3\u0104\3\u0105\3\u0105\3\u0105\3\u0105\3\u0106"+ - "\3\u0106\3\u0106\3\u0106\3\u0107\3\u0107\3\u0107\3\u0107\3\u0108\3\u0108"+ - "\3\u0108\3\u0108\3\u0109\3\u0109\3\u0109\3\u0109\3\u010a\3\u010a\3\u010a"+ - "\3\u010a\3\u010b\3\u010b\3\u010b\3\u010b\3\u010c\3\u010c\3\u010c\3\u010c"+ - "\3\u010d\3\u010d\3\u010d\3\u010d\3\u010e\3\u010e\3\u010e\3\u010e\3\u010f"+ - "\3\u010f\3\u010f\3\u010f\3\u0110\3\u0110\3\u0110\3\u0110\3\u0111\3\u0111"+ - "\3\u0111\3\u0111\3\u0112\3\u0112\3\u0112\3\u0112\3\u0113\3\u0113\3\u0113"+ - "\3\u0113\3\u0114\3\u0114\3\u0114\3\u0114\3\u0115\3\u0115\3\u0115\3\u0115"+ - "\3\u0116\3\u0116\3\u0116\3\u0116\3\u0117\3\u0117\3\u0117\3\u0117\3\u0118"+ - "\3\u0118\3\u0118\3\u0118\3\u0119\3\u0119\3\u0119\3\u0119\3\u011a\3\u011a"+ - "\3\u011a\3\u011a\3\u011b\3\u011b\3\u011b\3\u011b\3\u011c\3\u011c\3\u011c"+ - "\3\u011c\3\u011d\3\u011d\3\u011d\3\u011d\3\u011e\3\u011e\3\u011e\3\u011e"+ - "\3\u011f\3\u011f\3\u011f\3\u011f\3\u0120\3\u0120\3\u0120\3\u0120\3\u0121"+ - "\3\u0121\3\u0121\3\u0121\3\u0122\3\u0122\3\u0122\3\u0122\3\u0123\3\u0123"+ - "\3\u0123\3\u0123\3\u0124\3\u0124\3\u0124\3\u0124\3\u0125\3\u0125\3\u0125"+ - "\3\u0125\3\u0126\3\u0126\3\u0126\3\u0126\3\u0127\3\u0127\3\u0127\3\u0127"+ - "\3\u0128\3\u0128\3\u0128\3\u0128\3\u0129\3\u0129\3\u0129\3\u0129\3\u012a"+ - "\3\u012a\3\u012a\3\u012a\3\u012b\3\u012b\3\u012b\3\u012b\3\u012c\3\u012c"+ - "\3\u012c\3\u012c\3\u012d\3\u012d\3\u012d\3\u012d\3\u012e\3\u012e\3\u012e"+ - "\3\u012e\3\u012f\3\u012f\3\u012f\3\u012f\3\u0130\3\u0130\3\u0130\3\u0130"+ - "\3\u0131\3\u0131\3\u0131\3\u0131\3\u0132\3\u0132\3\u0132\3\u0132\3\u0133"+ - "\3\u0133\3\u0133\3\u0133\3\u0134\3\u0134\3\u0134\3\u0134\3\u0135\3\u0135"+ - "\3\u0135\3\u0135\3\u0136\3\u0136\5\u0136\u08a9\n\u0136\3\u0136\3\u0136"+ - "\3\u0137\3\u0137\3\u0137\3\u0137\3\u0138\3\u0138\3\u0138\3\u0138\3\u0139"+ - "\3\u0139\3\u0286\2\u013a\6\3\b\4\n\5\f\6\16\7\20\2\22\b\24\t\26\n\30\13"+ - "\32\f\34\r\36\16 \17\"\20$\21&\22(\23*\24,\25.\26\60\27\62\30\64\31\66"+ - "\328\33:\34<\35>\36@\37B D!F\"H#J$L%N&P\'R(T)V*X+Z,\\-^.`/b\60d\61f\62"+ - "h\63j\64l\65n\66p\67r8t9v:x;z<|=~>\u0080?\u0082@\u0084A\u0086B\u0088C"+ - "\u008aD\u008cE\u008eF\u0090G\u0092H\u0094I\u0096J\u0098K\u009aL\u009c"+ - "M\u009eN\u00a0O\u00a2P\u00a4Q\u00a6R\u00a8S\u00aaT\u00acU\u00aeV\u00b0"+ - "W\u00b2X\u00b4Y\u00b6Z\u00b8[\u00ba\\\u00bc]\u00be^\u00c0_\u00c2`\u00c4"+ - "a\u00c6b\u00c8c\u00cad\u00cce\u00cef\u00d0g\u00d2h\u00d4i\u00d6j\u00d8"+ - "k\u00dal\u00dcm\u00den\u00e0o\u00e2p\u00e4q\u00e6r\u00e8s\u00eat\u00ec"+ - "u\u00eev\u00f0w\u00f2x\u00f4y\u00f6z\u00f8{\u00fa|\u00fc}\u00fe~\u0100"+ - "\177\u0102\u0080\u0104\u0081\u0106\u0082\u0108\u0083\u010a\u0084\u010c"+ - "\u0085\u010e\u0086\u0110\u0087\u0112\u0088\u0114\2\u0116\2\u0118\2\u011a"+ - "\2\u011c\2\u011e\u0089\u0120\u008a\u0122\u008b\u0124\u008c\u0126\2\u0128"+ - "\2\u012a\u008d\u012c\2\u012e\2\u0130\u008e\u0132\u008f\u0134\u0090\u0136"+ - "\u0091\u0138\u0092\u013a\u0093\u013c\2\u013e\u0094\u0140\u0095\u0142\u0096"+ - "\u0144\2\u0146\2\u0148\2\u014a\2\u014c\u0097\u014e\u0098\u0150\u0099\u0152"+ - "\u009a\u0154\u009b\u0156\u009c\u0158\u009d\u015a\u009e\u015c\u009f\u015e"+ - "\u00a0\u0160\u00a1\u0162\u00a2\u0164\u00a3\u0166\u00a4\u0168\u00a5\u016a"+ - "\u00a6\u016c\u00a7\u016e\u00a8\u0170\u00a9\u0172\2\u0174\2\u0176\2\u0178"+ - "\2\u017a\2\u017c\2\u017e\2\u0180\2\u0182\2\u0184\2\u0186\2\u0188\2\u018a"+ - "\2\u018c\2\u018e\2\u0190\2\u0192\2\u0194\2\u0196\2\u0198\2\u019a\2\u019c"+ - "\2\u019e\2\u01a0\2\u01a2\2\u01a4\2\u01a6\2\u01a8\2\u01aa\2\u01ac\2\u01ae"+ - "\2\u01b0\2\u01b2\2\u01b4\2\u01b6\2\u01b8\2\u01ba\2\u01bc\2\u01be\2\u01c0"+ - "\2\u01c2\2\u01c4\2\u01c6\2\u01c8\2\u01ca\2\u01cc\2\u01ce\2\u01d0\2\u01d2"+ - "\2\u01d4\2\u01d6\2\u01d8\2\u01da\2\u01dc\2\u01de\2\u01e0\2\u01e2\2\u01e4"+ - "\2\u01e6\2\u01e8\2\u01ea\2\u01ec\2\u01ee\2\u01f0\2\u01f2\2\u01f4\2\u01f6"+ - "\2\u01f8\2\u01fa\2\u01fc\2\u01fe\2\u0200\2\u0202\2\u0204\2\u0206\2\u0208"+ - "\2\u020a\2\u020c\2\u020e\2\u0210\2\u0212\2\u0214\2\u0216\2\u0218\2\u021a"+ - "\2\u021c\2\u021e\2\u0220\2\u0222\2\u0224\2\u0226\2\u0228\2\u022a\2\u022c"+ - "\2\u022e\2\u0230\2\u0232\2\u0234\2\u0236\2\u0238\2\u023a\2\u023c\2\u023e"+ - "\2\u0240\2\u0242\2\u0244\2\u0246\2\u0248\2\u024a\2\u024c\2\u024e\2\u0250"+ - "\2\u0252\2\u0254\2\u0256\2\u0258\2\u025a\2\u025c\2\u025e\2\u0260\2\u0262"+ - "\2\u0264\2\u0266\2\u0268\2\u026a\2\u026c\2\u026e\u00aa\u0270\u00ab\u0272"+ - "\u00ac\u0274\u00ad\6\2\3\4\5\31\4\2\f\f\17\17\5\2\13\13\16\16\"\"\4\2"+ - "GGgg\4\2--//\4\2HHhh\5\2\62;CHch\4\2ZZzz\3\2\62\63\4\2DDdd\4\2WWww\4\2"+ - "NNnn\6\2\f\f\17\17))^^\5\2\f\f\17\17bb\n\2$$&&))^^ddppttvv\u0248\2c|\u00b7"+ - "\u00b7\u00e1\u00f8\u00fa\u0101\u0103\u0103\u0105\u0105\u0107\u0107\u0109"+ - "\u0109\u010b\u010b\u010d\u010d\u010f\u010f\u0111\u0111\u0113\u0113\u0115"+ - "\u0115\u0117\u0117\u0119\u0119\u011b\u011b\u011d\u011d\u011f\u011f\u0121"+ - "\u0121\u0123\u0123\u0125\u0125\u0127\u0127\u0129\u0129\u012b\u012b\u012d"+ - "\u012d\u012f\u012f\u0131\u0131\u0133\u0133\u0135\u0135\u0137\u0137\u0139"+ - "\u013a\u013c\u013c\u013e\u013e\u0140\u0140\u0142\u0142\u0144\u0144\u0146"+ - "\u0146\u0148\u0148\u014a\u014b\u014d\u014d\u014f\u014f\u0151\u0151\u0153"+ - "\u0153\u0155\u0155\u0157\u0157\u0159\u0159\u015b\u015b\u015d\u015d\u015f"+ - "\u015f\u0161\u0161\u0163\u0163\u0165\u0165\u0167\u0167\u0169\u0169\u016b"+ - "\u016b\u016d\u016d\u016f\u016f\u0171\u0171\u0173\u0173\u0175\u0175\u0177"+ - "\u0177\u0179\u0179\u017c\u017c\u017e\u017e\u0180\u0182\u0185\u0185\u0187"+ - "\u0187\u018a\u018a\u018e\u018f\u0194\u0194\u0197\u0197\u019b\u019d\u01a0"+ - "\u01a0\u01a3\u01a3\u01a5\u01a5\u01a7\u01a7\u01aa\u01aa\u01ac\u01ad\u01af"+ - "\u01af\u01b2\u01b2\u01b6\u01b6\u01b8\u01b8\u01bb\u01bc\u01bf\u01c1\u01c8"+ - "\u01c8\u01cb\u01cb\u01ce\u01ce\u01d0\u01d0\u01d2\u01d2\u01d4\u01d4\u01d6"+ - "\u01d6\u01d8\u01d8\u01da\u01da\u01dc\u01dc\u01de\u01df\u01e1\u01e1\u01e3"+ - "\u01e3\u01e5\u01e5\u01e7\u01e7\u01e9\u01e9\u01eb\u01eb\u01ed\u01ed\u01ef"+ - "\u01ef\u01f1\u01f2\u01f5\u01f5\u01f7\u01f7\u01fb\u01fb\u01fd\u01fd\u01ff"+ - "\u01ff\u0201\u0201\u0203\u0203\u0205\u0205\u0207\u0207\u0209\u0209\u020b"+ - "\u020b\u020d\u020d\u020f\u020f\u0211\u0211\u0213\u0213\u0215\u0215\u0217"+ - "\u0217\u0219\u0219\u021b\u021b\u021d\u021d\u021f\u021f\u0221\u0221\u0223"+ - "\u0223\u0225\u0225\u0227\u0227\u0229\u0229\u022b\u022b\u022d\u022d\u022f"+ - "\u022f\u0231\u0231\u0233\u0233\u0235\u023b\u023e\u023e\u0241\u0242\u0244"+ - "\u0244\u0249\u0249\u024b\u024b\u024d\u024d\u024f\u024f\u0251\u0295\u0297"+ - "\u02b1\u0373\u0373\u0375\u0375\u0379\u0379\u037d\u037f\u0392\u0392\u03ae"+ - "\u03d0\u03d2\u03d3\u03d7\u03d9\u03db\u03db\u03dd\u03dd\u03df\u03df\u03e1"+ - "\u03e1\u03e3\u03e3\u03e5\u03e5\u03e7\u03e7\u03e9\u03e9\u03eb\u03eb\u03ed"+ - "\u03ed\u03ef\u03ef\u03f1\u03f5\u03f7\u03f7\u03fa\u03fa\u03fd\u03fe\u0432"+ - "\u0461\u0463\u0463\u0465\u0465\u0467\u0467\u0469\u0469\u046b\u046b\u046d"+ - "\u046d\u046f\u046f\u0471\u0471\u0473\u0473\u0475\u0475\u0477\u0477\u0479"+ - "\u0479\u047b\u047b\u047d\u047d\u047f\u047f\u0481\u0481\u0483\u0483\u048d"+ - "\u048d\u048f\u048f\u0491\u0491\u0493\u0493\u0495\u0495\u0497\u0497\u0499"+ - "\u0499\u049b\u049b\u049d\u049d\u049f\u049f\u04a1\u04a1\u04a3\u04a3\u04a5"+ - "\u04a5\u04a7\u04a7\u04a9\u04a9\u04ab\u04ab\u04ad\u04ad\u04af\u04af\u04b1"+ - "\u04b1\u04b3\u04b3\u04b5\u04b5\u04b7\u04b7\u04b9\u04b9\u04bb\u04bb\u04bd"+ - "\u04bd\u04bf\u04bf\u04c1\u04c1\u04c4\u04c4\u04c6\u04c6\u04c8\u04c8\u04ca"+ - "\u04ca\u04cc\u04cc\u04ce\u04ce\u04d0\u04d1\u04d3\u04d3\u04d5\u04d5\u04d7"+ - "\u04d7\u04d9\u04d9\u04db\u04db\u04dd\u04dd\u04df\u04df\u04e1\u04e1\u04e3"+ - "\u04e3\u04e5\u04e5\u04e7\u04e7\u04e9\u04e9\u04eb\u04eb\u04ed\u04ed\u04ef"+ - "\u04ef\u04f1\u04f1\u04f3\u04f3\u04f5\u04f5\u04f7\u04f7\u04f9\u04f9\u04fb"+ - "\u04fb\u04fd\u04fd\u04ff\u04ff\u0501\u0501\u0503\u0503\u0505\u0505\u0507"+ - "\u0507\u0509\u0509\u050b\u050b\u050d\u050d\u050f\u050f\u0511\u0511\u0513"+ - "\u0513\u0515\u0515\u0517\u0517\u0519\u0519\u051b\u051b\u051d\u051d\u051f"+ - "\u051f\u0521\u0521\u0523\u0523\u0525\u0525\u0527\u0527\u0529\u0529\u0563"+ - "\u0589\u1d02\u1d2d\u1d6d\u1d79\u1d7b\u1d9c\u1e03\u1e03\u1e05\u1e05\u1e07"+ - "\u1e07\u1e09\u1e09\u1e0b\u1e0b\u1e0d\u1e0d\u1e0f\u1e0f\u1e11\u1e11\u1e13"+ - "\u1e13\u1e15\u1e15\u1e17\u1e17\u1e19\u1e19\u1e1b\u1e1b\u1e1d\u1e1d\u1e1f"+ - "\u1e1f\u1e21\u1e21\u1e23\u1e23\u1e25\u1e25\u1e27\u1e27\u1e29\u1e29\u1e2b"+ - "\u1e2b\u1e2d\u1e2d\u1e2f\u1e2f\u1e31\u1e31\u1e33\u1e33\u1e35\u1e35\u1e37"+ - "\u1e37\u1e39\u1e39\u1e3b\u1e3b\u1e3d\u1e3d\u1e3f\u1e3f\u1e41\u1e41\u1e43"+ - "\u1e43\u1e45\u1e45\u1e47\u1e47\u1e49\u1e49\u1e4b\u1e4b\u1e4d\u1e4d\u1e4f"+ - "\u1e4f\u1e51\u1e51\u1e53\u1e53\u1e55\u1e55\u1e57\u1e57\u1e59\u1e59\u1e5b"+ - "\u1e5b\u1e5d\u1e5d\u1e5f\u1e5f\u1e61\u1e61\u1e63\u1e63\u1e65\u1e65\u1e67"+ - "\u1e67\u1e69\u1e69\u1e6b\u1e6b\u1e6d\u1e6d\u1e6f\u1e6f\u1e71\u1e71\u1e73"+ - "\u1e73\u1e75\u1e75\u1e77\u1e77\u1e79\u1e79\u1e7b\u1e7b\u1e7d\u1e7d\u1e7f"+ - "\u1e7f\u1e81\u1e81\u1e83\u1e83\u1e85\u1e85\u1e87\u1e87\u1e89\u1e89\u1e8b"+ - "\u1e8b\u1e8d\u1e8d\u1e8f\u1e8f\u1e91\u1e91\u1e93\u1e93\u1e95\u1e95\u1e97"+ - "\u1e9f\u1ea1\u1ea1\u1ea3\u1ea3\u1ea5\u1ea5\u1ea7\u1ea7\u1ea9\u1ea9\u1eab"+ - "\u1eab\u1ead\u1ead\u1eaf\u1eaf\u1eb1\u1eb1\u1eb3\u1eb3\u1eb5\u1eb5\u1eb7"+ - "\u1eb7\u1eb9\u1eb9\u1ebb\u1ebb\u1ebd\u1ebd\u1ebf\u1ebf\u1ec1\u1ec1\u1ec3"+ - "\u1ec3\u1ec5\u1ec5\u1ec7\u1ec7\u1ec9\u1ec9\u1ecb\u1ecb\u1ecd\u1ecd\u1ecf"+ - "\u1ecf\u1ed1\u1ed1\u1ed3\u1ed3\u1ed5\u1ed5\u1ed7\u1ed7\u1ed9\u1ed9\u1edb"+ - "\u1edb\u1edd\u1edd\u1edf\u1edf\u1ee1\u1ee1\u1ee3\u1ee3\u1ee5\u1ee5\u1ee7"+ - "\u1ee7\u1ee9\u1ee9\u1eeb\u1eeb\u1eed\u1eed\u1eef\u1eef\u1ef1\u1ef1\u1ef3"+ - "\u1ef3\u1ef5\u1ef5\u1ef7\u1ef7\u1ef9\u1ef9\u1efb\u1efb\u1efd\u1efd\u1eff"+ - "\u1eff\u1f01\u1f09\u1f12\u1f17\u1f22\u1f29\u1f32\u1f39\u1f42\u1f47\u1f52"+ - "\u1f59\u1f62\u1f69\u1f72\u1f7f\u1f82\u1f89\u1f92\u1f99\u1fa2\u1fa9\u1fb2"+ - "\u1fb6\u1fb8\u1fb9\u1fc0\u1fc0\u1fc4\u1fc6\u1fc8\u1fc9\u1fd2\u1fd5\u1fd8"+ - "\u1fd9\u1fe2\u1fe9\u1ff4\u1ff6\u1ff8\u1ff9\u210c\u210c\u2110\u2111\u2115"+ - "\u2115\u2131\u2131\u2136\u2136\u213b\u213b\u213e\u213f\u2148\u214b\u2150"+ - "\u2150\u2186\u2186\u2c32\u2c60\u2c63\u2c63\u2c67\u2c68\u2c6a\u2c6a\u2c6c"+ - "\u2c6c\u2c6e\u2c6e\u2c73\u2c73\u2c75\u2c76\u2c78\u2c7d\u2c83\u2c83\u2c85"+ - "\u2c85\u2c87\u2c87\u2c89\u2c89\u2c8b\u2c8b\u2c8d\u2c8d\u2c8f\u2c8f\u2c91"+ - "\u2c91\u2c93\u2c93\u2c95\u2c95\u2c97\u2c97\u2c99\u2c99\u2c9b\u2c9b\u2c9d"+ - "\u2c9d\u2c9f\u2c9f\u2ca1\u2ca1\u2ca3\u2ca3\u2ca5\u2ca5\u2ca7\u2ca7\u2ca9"+ - "\u2ca9\u2cab\u2cab\u2cad\u2cad\u2caf\u2caf\u2cb1\u2cb1\u2cb3\u2cb3\u2cb5"+ - "\u2cb5\u2cb7\u2cb7\u2cb9\u2cb9\u2cbb\u2cbb\u2cbd\u2cbd\u2cbf\u2cbf\u2cc1"+ - "\u2cc1\u2cc3\u2cc3\u2cc5\u2cc5\u2cc7\u2cc7\u2cc9\u2cc9\u2ccb\u2ccb\u2ccd"+ - "\u2ccd\u2ccf\u2ccf\u2cd1\u2cd1\u2cd3\u2cd3\u2cd5\u2cd5\u2cd7\u2cd7\u2cd9"+ - "\u2cd9\u2cdb\u2cdb\u2cdd\u2cdd\u2cdf\u2cdf\u2ce1\u2ce1\u2ce3\u2ce3\u2ce5"+ - "\u2ce6\u2cee\u2cee\u2cf0\u2cf0\u2cf5\u2cf5\u2d02\u2d27\u2d29\u2d29\u2d2f"+ - "\u2d2f\ua643\ua643\ua645\ua645\ua647\ua647\ua649\ua649\ua64b\ua64b\ua64d"+ - "\ua64d\ua64f\ua64f\ua651\ua651\ua653\ua653\ua655\ua655\ua657\ua657\ua659"+ - "\ua659\ua65b\ua65b\ua65d\ua65d\ua65f\ua65f\ua661\ua661\ua663\ua663\ua665"+ - "\ua665\ua667\ua667\ua669\ua669\ua66b\ua66b\ua66d\ua66d\ua66f\ua66f\ua683"+ - "\ua683\ua685\ua685\ua687\ua687\ua689\ua689\ua68b\ua68b\ua68d\ua68d\ua68f"+ - "\ua68f\ua691\ua691\ua693\ua693\ua695\ua695\ua697\ua697\ua699\ua699\ua725"+ - "\ua725\ua727\ua727\ua729\ua729\ua72b\ua72b\ua72d\ua72d\ua72f\ua72f\ua731"+ - "\ua733\ua735\ua735\ua737\ua737\ua739\ua739\ua73b\ua73b\ua73d\ua73d\ua73f"+ - "\ua73f\ua741\ua741\ua743\ua743\ua745\ua745\ua747\ua747\ua749\ua749\ua74b"+ - "\ua74b\ua74d\ua74d\ua74f\ua74f\ua751\ua751\ua753\ua753\ua755\ua755\ua757"+ - "\ua757\ua759\ua759\ua75b\ua75b\ua75d\ua75d\ua75f\ua75f\ua761\ua761\ua763"+ - "\ua763\ua765\ua765\ua767\ua767\ua769\ua769\ua76b\ua76b\ua76d\ua76d\ua76f"+ - "\ua76f\ua771\ua771\ua773\ua77a\ua77c\ua77c\ua77e\ua77e\ua781\ua781\ua783"+ - "\ua783\ua785\ua785\ua787\ua787\ua789\ua789\ua78e\ua78e\ua790\ua790\ua793"+ - "\ua793\ua795\ua795\ua7a3\ua7a3\ua7a5\ua7a5\ua7a7\ua7a7\ua7a9\ua7a9\ua7ab"+ - "\ua7ab\ua7fc\ua7fc\ufb02\ufb08\ufb15\ufb19\uff43\uff5c\65\2\u02b2\u02c3"+ - "\u02c8\u02d3\u02e2\u02e6\u02ee\u02ee\u02f0\u02f0\u0376\u0376\u037c\u037c"+ - "\u055b\u055b\u0642\u0642\u06e7\u06e8\u07f6\u07f7\u07fc\u07fc\u081c\u081c"+ - "\u0826\u0826\u082a\u082a\u0973\u0973\u0e48\u0e48\u0ec8\u0ec8\u10fe\u10fe"+ - "\u17d9\u17d9\u1845\u1845\u1aa9\u1aa9\u1c7a\u1c7f\u1d2e\u1d6c\u1d7a\u1d7a"+ - "\u1d9d\u1dc1\u2073\u2073\u2081\u2081\u2092\u209e\u2c7e\u2c7f\u2d71\u2d71"+ - "\u2e31\u2e31\u3007\u3007\u3033\u3037\u303d\u303d\u309f\u30a0\u30fe\u3100"+ - "\ua017\ua017\ua4fa\ua4ff\ua60e\ua60e\ua681\ua681\ua719\ua721\ua772\ua772"+ - "\ua78a\ua78a\ua7fa\ua7fb\ua9d1\ua9d1\uaa72\uaa72\uaadf\uaadf\uaaf5\uaaf6"+ - "\uff72\uff72\uffa0\uffa1\u0123\2\u00ac\u00ac\u00bc\u00bc\u01bd\u01bd\u01c2"+ - "\u01c5\u0296\u0296\u05d2\u05ec\u05f2\u05f4\u0622\u0641\u0643\u064c\u0670"+ - "\u0671\u0673\u06d5\u06d7\u06d7\u06f0\u06f1\u06fc\u06fe\u0701\u0701\u0712"+ - "\u0712\u0714\u0731\u074f\u07a7\u07b3\u07b3\u07cc\u07ec\u0802\u0817\u0842"+ - "\u085a\u08a2\u08a2\u08a4\u08ae\u0906\u093b\u093f\u093f\u0952\u0952\u095a"+ - "\u0963\u0974\u0979\u097b\u0981\u0987\u098e\u0991\u0992\u0995\u09aa\u09ac"+ - "\u09b2\u09b4\u09b4\u09b8\u09bb\u09bf\u09bf\u09d0\u09d0\u09de\u09df\u09e1"+ - "\u09e3\u09f2\u09f3\u0a07\u0a0c\u0a11\u0a12\u0a15\u0a2a\u0a2c\u0a32\u0a34"+ - "\u0a35\u0a37\u0a38\u0a3a\u0a3b\u0a5b\u0a5e\u0a60\u0a60\u0a74\u0a76\u0a87"+ - "\u0a8f\u0a91\u0a93\u0a95\u0aaa\u0aac\u0ab2\u0ab4\u0ab5\u0ab7\u0abb\u0abf"+ - "\u0abf\u0ad2\u0ad2\u0ae2\u0ae3\u0b07\u0b0e\u0b11\u0b12\u0b15\u0b2a\u0b2c"+ - "\u0b32\u0b34\u0b35\u0b37\u0b3b\u0b3f\u0b3f\u0b5e\u0b5f\u0b61\u0b63\u0b73"+ - "\u0b73\u0b85\u0b85\u0b87\u0b8c\u0b90\u0b92\u0b94\u0b97\u0b9b\u0b9c\u0b9e"+ - "\u0b9e\u0ba0\u0ba1\u0ba5\u0ba6\u0baa\u0bac\u0bb0\u0bbb\u0bd2\u0bd2\u0c07"+ - "\u0c0e\u0c10\u0c12\u0c14\u0c2a\u0c2c\u0c35\u0c37\u0c3b\u0c3f\u0c3f\u0c5a"+ - "\u0c5b\u0c62\u0c63\u0c87\u0c8e\u0c90\u0c92\u0c94\u0caa\u0cac\u0cb5\u0cb7"+ - "\u0cbb\u0cbf\u0cbf\u0ce0\u0ce0\u0ce2\u0ce3\u0cf3\u0cf4\u0d07\u0d0e\u0d10"+ - "\u0d12\u0d14\u0d3c\u0d3f\u0d3f\u0d50\u0d50\u0d62\u0d63\u0d7c\u0d81\u0d87"+ - "\u0d98\u0d9c\u0db3\u0db5\u0dbd\u0dbf\u0dbf\u0dc2\u0dc8\u0e03\u0e32\u0e34"+ - "\u0e35\u0e42\u0e47\u0e83\u0e84\u0e86\u0e86\u0e89\u0e8a\u0e8c\u0e8c\u0e8f"+ - "\u0e8f\u0e96\u0e99\u0e9b\u0ea1\u0ea3\u0ea5\u0ea7\u0ea7\u0ea9\u0ea9\u0eac"+ - "\u0ead\u0eaf\u0eb2\u0eb4\u0eb5\u0ebf\u0ebf\u0ec2\u0ec6\u0ede\u0ee1\u0f02"+ - "\u0f02\u0f42\u0f49\u0f4b\u0f6e\u0f8a\u0f8e\u1002\u102c\u1041\u1041\u1052"+ - "\u1057\u105c\u105f\u1063\u1063\u1067\u1068\u1070\u1072\u1077\u1083\u1090"+ - "\u1090\u10d2\u10fc\u10ff\u124a\u124c\u124f\u1252\u1258\u125a\u125a\u125c"+ - "\u125f\u1262\u128a\u128c\u128f\u1292\u12b2\u12b4\u12b7\u12ba\u12c0\u12c2"+ - "\u12c2\u12c4\u12c7\u12ca\u12d8\u12da\u1312\u1314\u1317\u131a\u135c\u1382"+ - "\u1391\u13a2\u13f6\u1403\u166e\u1671\u1681\u1683\u169c\u16a2\u16ec\u1702"+ - "\u170e\u1710\u1713\u1722\u1733\u1742\u1753\u1762\u176e\u1770\u1772\u1782"+ - "\u17b5\u17de\u17de\u1822\u1844\u1846\u1879\u1882\u18aa\u18ac\u18ac\u18b2"+ - "\u18f7\u1902\u191e\u1952\u196f\u1972\u1976\u1982\u19ad\u19c3\u19c9\u1a02"+ - "\u1a18\u1a22\u1a56\u1b07\u1b35\u1b47\u1b4d\u1b85\u1ba2\u1bb0\u1bb1\u1bbc"+ - "\u1be7\u1c02\u1c25\u1c4f\u1c51\u1c5c\u1c79\u1ceb\u1cee\u1cf0\u1cf3\u1cf7"+ - "\u1cf8\u2137\u213a\u2d32\u2d69\u2d82\u2d98\u2da2\u2da8\u2daa\u2db0\u2db2"+ - "\u2db8\u2dba\u2dc0\u2dc2\u2dc8\u2dca\u2dd0\u2dd2\u2dd8\u2dda\u2de0\u3008"+ - "\u3008\u303e\u303e\u3043\u3098\u30a1\u30a1\u30a3\u30fc\u3101\u3101\u3107"+ - "\u312f\u3133\u3190\u31a2\u31bc\u31f2\u3201\u3402\u3402\u4db7\u4db7\u4e02"+ - "\u4e02\u9fce\u9fce\ua002\ua016\ua018\ua48e\ua4d2\ua4f9\ua502\ua60d\ua612"+ - "\ua621\ua62c\ua62d\ua670\ua670\ua6a2\ua6e7\ua7fd\ua803\ua805\ua807\ua809"+ - "\ua80c\ua80e\ua824\ua842\ua875\ua884\ua8b5\ua8f4\ua8f9\ua8fd\ua8fd\ua90c"+ - "\ua927\ua932\ua948\ua962\ua97e\ua986\ua9b4\uaa02\uaa2a\uaa42\uaa44\uaa46"+ - "\uaa4d\uaa62\uaa71\uaa73\uaa78\uaa7c\uaa7c\uaa82\uaab1\uaab3\uaab3\uaab7"+ - "\uaab8\uaabb\uaabf\uaac2\uaac2\uaac4\uaac4\uaadd\uaade\uaae2\uaaec\uaaf4"+ - "\uaaf4\uab03\uab08\uab0b\uab10\uab13\uab18\uab22\uab28\uab2a\uab30\uabc2"+ - "\uabe4\uac02\uac02\ud7a5\ud7a5\ud7b2\ud7c8\ud7cd\ud7fd\uf902\ufa6f\ufa72"+ - "\ufadb\ufb1f\ufb1f\ufb21\ufb2a\ufb2c\ufb38\ufb3a\ufb3e\ufb40\ufb40\ufb42"+ - "\ufb43\ufb45\ufb46\ufb48\ufbb3\ufbd5\ufd3f\ufd52\ufd91\ufd94\ufdc9\ufdf2"+ - "\ufdfd\ufe72\ufe76\ufe78\ufefe\uff68\uff71\uff73\uff9f\uffa2\uffc0\uffc4"+ - "\uffc9\uffcc\uffd1\uffd4\uffd9\uffdc\uffde\f\2\u01c7\u01c7\u01ca\u01ca"+ - "\u01cd\u01cd\u01f4\u01f4\u1f8a\u1f91\u1f9a\u1fa1\u1faa\u1fb1\u1fbe\u1fbe"+ - "\u1fce\u1fce\u1ffe\u1ffe\u0242\2C\\\u00c2\u00d8\u00da\u00e0\u0102\u0102"+ - "\u0104\u0104\u0106\u0106\u0108\u0108\u010a\u010a\u010c\u010c\u010e\u010e"+ - "\u0110\u0110\u0112\u0112\u0114\u0114\u0116\u0116\u0118\u0118\u011a\u011a"+ - "\u011c\u011c\u011e\u011e\u0120\u0120\u0122\u0122\u0124\u0124\u0126\u0126"+ - "\u0128\u0128\u012a\u012a\u012c\u012c\u012e\u012e\u0130\u0130\u0132\u0132"+ - "\u0134\u0134\u0136\u0136\u0138\u0138\u013b\u013b\u013d\u013d\u013f\u013f"+ - "\u0141\u0141\u0143\u0143\u0145\u0145\u0147\u0147\u0149\u0149\u014c\u014c"+ - "\u014e\u014e\u0150\u0150\u0152\u0152\u0154\u0154\u0156\u0156\u0158\u0158"+ - "\u015a\u015a\u015c\u015c\u015e\u015e\u0160\u0160\u0162\u0162\u0164\u0164"+ - "\u0166\u0166\u0168\u0168\u016a\u016a\u016c\u016c\u016e\u016e\u0170\u0170"+ - "\u0172\u0172\u0174\u0174\u0176\u0176\u0178\u0178\u017a\u017b\u017d\u017d"+ - "\u017f\u017f\u0183\u0184\u0186\u0186\u0188\u0189\u018b\u018d\u0190\u0193"+ - "\u0195\u0196\u0198\u019a\u019e\u019f\u01a1\u01a2\u01a4\u01a4\u01a6\u01a6"+ - "\u01a8\u01a9\u01ab\u01ab\u01ae\u01ae\u01b0\u01b1\u01b3\u01b5\u01b7\u01b7"+ - "\u01b9\u01ba\u01be\u01be\u01c6\u01c6\u01c9\u01c9\u01cc\u01cc\u01cf\u01cf"+ - "\u01d1\u01d1\u01d3\u01d3\u01d5\u01d5\u01d7\u01d7\u01d9\u01d9\u01db\u01db"+ - "\u01dd\u01dd\u01e0\u01e0\u01e2\u01e2\u01e4\u01e4\u01e6\u01e6\u01e8\u01e8"+ - "\u01ea\u01ea\u01ec\u01ec\u01ee\u01ee\u01f0\u01f0\u01f3\u01f3\u01f6\u01f6"+ - "\u01f8\u01fa\u01fc\u01fc\u01fe\u01fe\u0200\u0200\u0202\u0202\u0204\u0204"+ - "\u0206\u0206\u0208\u0208\u020a\u020a\u020c\u020c\u020e\u020e\u0210\u0210"+ - "\u0212\u0212\u0214\u0214\u0216\u0216\u0218\u0218\u021a\u021a\u021c\u021c"+ - "\u021e\u021e\u0220\u0220\u0222\u0222\u0224\u0224\u0226\u0226\u0228\u0228"+ - "\u022a\u022a\u022c\u022c\u022e\u022e\u0230\u0230\u0232\u0232\u0234\u0234"+ - "\u023c\u023d\u023f\u0240\u0243\u0243\u0245\u0248\u024a\u024a\u024c\u024c"+ - "\u024e\u024e\u0250\u0250\u0372\u0372\u0374\u0374\u0378\u0378\u0388\u0388"+ - "\u038a\u038c\u038e\u038e\u0390\u0391\u0393\u03a3\u03a5\u03ad\u03d1\u03d1"+ - "\u03d4\u03d6\u03da\u03da\u03dc\u03dc\u03de\u03de\u03e0\u03e0\u03e2\u03e2"+ - "\u03e4\u03e4\u03e6\u03e6\u03e8\u03e8\u03ea\u03ea\u03ec\u03ec\u03ee\u03ee"+ - "\u03f0\u03f0\u03f6\u03f6\u03f9\u03f9\u03fb\u03fc\u03ff\u0431\u0462\u0462"+ - "\u0464\u0464\u0466\u0466\u0468\u0468\u046a\u046a\u046c\u046c\u046e\u046e"+ - "\u0470\u0470\u0472\u0472\u0474\u0474\u0476\u0476\u0478\u0478\u047a\u047a"+ - "\u047c\u047c\u047e\u047e\u0480\u0480\u0482\u0482\u048c\u048c\u048e\u048e"+ - "\u0490\u0490\u0492\u0492\u0494\u0494\u0496\u0496\u0498\u0498\u049a\u049a"+ - "\u049c\u049c\u049e\u049e\u04a0\u04a0\u04a2\u04a2\u04a4\u04a4\u04a6\u04a6"+ - "\u04a8\u04a8\u04aa\u04aa\u04ac\u04ac\u04ae\u04ae\u04b0\u04b0\u04b2\u04b2"+ - "\u04b4\u04b4\u04b6\u04b6\u04b8\u04b8\u04ba\u04ba\u04bc\u04bc\u04be\u04be"+ - "\u04c0\u04c0\u04c2\u04c3\u04c5\u04c5\u04c7\u04c7\u04c9\u04c9\u04cb\u04cb"+ - "\u04cd\u04cd\u04cf\u04cf\u04d2\u04d2\u04d4\u04d4\u04d6\u04d6\u04d8\u04d8"+ - "\u04da\u04da\u04dc\u04dc\u04de\u04de\u04e0\u04e0\u04e2\u04e2\u04e4\u04e4"+ - "\u04e6\u04e6\u04e8\u04e8\u04ea\u04ea\u04ec\u04ec\u04ee\u04ee\u04f0\u04f0"+ - "\u04f2\u04f2\u04f4\u04f4\u04f6\u04f6\u04f8\u04f8\u04fa\u04fa\u04fc\u04fc"+ - "\u04fe\u04fe\u0500\u0500\u0502\u0502\u0504\u0504\u0506\u0506\u0508\u0508"+ - "\u050a\u050a\u050c\u050c\u050e\u050e\u0510\u0510\u0512\u0512\u0514\u0514"+ - "\u0516\u0516\u0518\u0518\u051a\u051a\u051c\u051c\u051e\u051e\u0520\u0520"+ - "\u0522\u0522\u0524\u0524\u0526\u0526\u0528\u0528\u0533\u0558\u10a2\u10c7"+ - "\u10c9\u10c9\u10cf\u10cf\u1e02\u1e02\u1e04\u1e04\u1e06\u1e06\u1e08\u1e08"+ - "\u1e0a\u1e0a\u1e0c\u1e0c\u1e0e\u1e0e\u1e10\u1e10\u1e12\u1e12\u1e14\u1e14"+ - "\u1e16\u1e16\u1e18\u1e18\u1e1a\u1e1a\u1e1c\u1e1c\u1e1e\u1e1e\u1e20\u1e20"+ - "\u1e22\u1e22\u1e24\u1e24\u1e26\u1e26\u1e28\u1e28\u1e2a\u1e2a\u1e2c\u1e2c"+ - "\u1e2e\u1e2e\u1e30\u1e30\u1e32\u1e32\u1e34\u1e34\u1e36\u1e36\u1e38\u1e38"+ - "\u1e3a\u1e3a\u1e3c\u1e3c\u1e3e\u1e3e\u1e40\u1e40\u1e42\u1e42\u1e44\u1e44"+ - "\u1e46\u1e46\u1e48\u1e48\u1e4a\u1e4a\u1e4c\u1e4c\u1e4e\u1e4e\u1e50\u1e50"+ - "\u1e52\u1e52\u1e54\u1e54\u1e56\u1e56\u1e58\u1e58\u1e5a\u1e5a\u1e5c\u1e5c"+ - "\u1e5e\u1e5e\u1e60\u1e60\u1e62\u1e62\u1e64\u1e64\u1e66\u1e66\u1e68\u1e68"+ - "\u1e6a\u1e6a\u1e6c\u1e6c\u1e6e\u1e6e\u1e70\u1e70\u1e72\u1e72\u1e74\u1e74"+ - "\u1e76\u1e76\u1e78\u1e78\u1e7a\u1e7a\u1e7c\u1e7c\u1e7e\u1e7e\u1e80\u1e80"+ - "\u1e82\u1e82\u1e84\u1e84\u1e86\u1e86\u1e88\u1e88\u1e8a\u1e8a\u1e8c\u1e8c"+ - "\u1e8e\u1e8e\u1e90\u1e90\u1e92\u1e92\u1e94\u1e94\u1e96\u1e96\u1ea0\u1ea0"+ - "\u1ea2\u1ea2\u1ea4\u1ea4\u1ea6\u1ea6\u1ea8\u1ea8\u1eaa\u1eaa\u1eac\u1eac"+ - "\u1eae\u1eae\u1eb0\u1eb0\u1eb2\u1eb2\u1eb4\u1eb4\u1eb6\u1eb6\u1eb8\u1eb8"+ - "\u1eba\u1eba\u1ebc\u1ebc\u1ebe\u1ebe\u1ec0\u1ec0\u1ec2\u1ec2\u1ec4\u1ec4"+ - "\u1ec6\u1ec6\u1ec8\u1ec8\u1eca\u1eca\u1ecc\u1ecc\u1ece\u1ece\u1ed0\u1ed0"+ - "\u1ed2\u1ed2\u1ed4\u1ed4\u1ed6\u1ed6\u1ed8\u1ed8\u1eda\u1eda\u1edc\u1edc"+ - "\u1ede\u1ede\u1ee0\u1ee0\u1ee2\u1ee2\u1ee4\u1ee4\u1ee6\u1ee6\u1ee8\u1ee8"+ - "\u1eea\u1eea\u1eec\u1eec\u1eee\u1eee\u1ef0\u1ef0\u1ef2\u1ef2\u1ef4\u1ef4"+ - "\u1ef6\u1ef6\u1ef8\u1ef8\u1efa\u1efa\u1efc\u1efc\u1efe\u1efe\u1f00\u1f00"+ - "\u1f0a\u1f11\u1f1a\u1f1f\u1f2a\u1f31\u1f3a\u1f41\u1f4a\u1f4f\u1f5b\u1f5b"+ - "\u1f5d\u1f5d\u1f5f\u1f5f\u1f61\u1f61\u1f6a\u1f71\u1fba\u1fbd\u1fca\u1fcd"+ - "\u1fda\u1fdd\u1fea\u1fee\u1ffa\u1ffd\u2104\u2104\u2109\u2109\u210d\u210f"+ - "\u2112\u2114\u2117\u2117\u211b\u211f\u2126\u2126\u2128\u2128\u212a\u212a"+ - "\u212c\u212f\u2132\u2135\u2140\u2141\u2147\u2147\u2185\u2185\u2c02\u2c30"+ - "\u2c62\u2c62\u2c64\u2c66\u2c69\u2c69\u2c6b\u2c6b\u2c6d\u2c6d\u2c6f\u2c72"+ - "\u2c74\u2c74\u2c77\u2c77\u2c80\u2c82\u2c84\u2c84\u2c86\u2c86\u2c88\u2c88"+ - "\u2c8a\u2c8a\u2c8c\u2c8c\u2c8e\u2c8e\u2c90\u2c90\u2c92\u2c92\u2c94\u2c94"+ - "\u2c96\u2c96\u2c98\u2c98\u2c9a\u2c9a\u2c9c\u2c9c\u2c9e\u2c9e\u2ca0\u2ca0"+ - "\u2ca2\u2ca2\u2ca4\u2ca4\u2ca6\u2ca6\u2ca8\u2ca8\u2caa\u2caa\u2cac\u2cac"+ - "\u2cae\u2cae\u2cb0\u2cb0\u2cb2\u2cb2\u2cb4\u2cb4\u2cb6\u2cb6\u2cb8\u2cb8"+ - "\u2cba\u2cba\u2cbc\u2cbc\u2cbe\u2cbe\u2cc0\u2cc0\u2cc2\u2cc2\u2cc4\u2cc4"+ - "\u2cc6\u2cc6\u2cc8\u2cc8\u2cca\u2cca\u2ccc\u2ccc\u2cce\u2cce\u2cd0\u2cd0"+ - "\u2cd2\u2cd2\u2cd4\u2cd4\u2cd6\u2cd6\u2cd8\u2cd8\u2cda\u2cda\u2cdc\u2cdc"+ - "\u2cde\u2cde\u2ce0\u2ce0\u2ce2\u2ce2\u2ce4\u2ce4\u2ced\u2ced\u2cef\u2cef"+ - "\u2cf4\u2cf4\ua642\ua642\ua644\ua644\ua646\ua646\ua648\ua648\ua64a\ua64a"+ - "\ua64c\ua64c\ua64e\ua64e\ua650\ua650\ua652\ua652\ua654\ua654\ua656\ua656"+ - "\ua658\ua658\ua65a\ua65a\ua65c\ua65c\ua65e\ua65e\ua660\ua660\ua662\ua662"+ - "\ua664\ua664\ua666\ua666\ua668\ua668\ua66a\ua66a\ua66c\ua66c\ua66e\ua66e"+ - "\ua682\ua682\ua684\ua684\ua686\ua686\ua688\ua688\ua68a\ua68a\ua68c\ua68c"+ - "\ua68e\ua68e\ua690\ua690\ua692\ua692\ua694\ua694\ua696\ua696\ua698\ua698"+ - "\ua724\ua724\ua726\ua726\ua728\ua728\ua72a\ua72a\ua72c\ua72c\ua72e\ua72e"+ - "\ua730\ua730\ua734\ua734\ua736\ua736\ua738\ua738\ua73a\ua73a\ua73c\ua73c"+ - "\ua73e\ua73e\ua740\ua740\ua742\ua742\ua744\ua744\ua746\ua746\ua748\ua748"+ - "\ua74a\ua74a\ua74c\ua74c\ua74e\ua74e\ua750\ua750\ua752\ua752\ua754\ua754"+ - "\ua756\ua756\ua758\ua758\ua75a\ua75a\ua75c\ua75c\ua75e\ua75e\ua760\ua760"+ - "\ua762\ua762\ua764\ua764\ua766\ua766\ua768\ua768\ua76a\ua76a\ua76c\ua76c"+ - "\ua76e\ua76e\ua770\ua770\ua77b\ua77b\ua77d\ua77d\ua77f\ua780\ua782\ua782"+ - "\ua784\ua784\ua786\ua786\ua788\ua788\ua78d\ua78d\ua78f\ua78f\ua792\ua792"+ - "\ua794\ua794\ua7a2\ua7a2\ua7a4\ua7a4\ua7a6\ua7a6\ua7a8\ua7a8\ua7aa\ua7aa"+ - "\ua7ac\ua7ac\uff23\uff3c%\2\62;\u0662\u066b\u06f2\u06fb\u07c2\u07cb\u0968"+ - "\u0971\u09e8\u09f1\u0a68\u0a71\u0ae8\u0af1\u0b68\u0b71\u0be8\u0bf1\u0c68"+ - "\u0c71\u0ce8\u0cf1\u0d68\u0d71\u0e52\u0e5b\u0ed2\u0edb\u0f22\u0f2b\u1042"+ - "\u104b\u1092\u109b\u17e2\u17eb\u1812\u181b\u1948\u1951\u19d2\u19db\u1a82"+ - "\u1a8b\u1a92\u1a9b\u1b52\u1b5b\u1bb2\u1bbb\u1c42\u1c4b\u1c52\u1c5b\ua622"+ - "\ua62b\ua8d2\ua8db\ua902\ua90b\ua9d2\ua9db\uaa52\uaa5b\uabf2\uabfb\uff12"+ - "\uff1b\t\2\u16f0\u16f2\u2162\u2184\u2187\u218a\u3009\u3009\u3023\u302b"+ - "\u303a\u303c\ua6e8\ua6f1\5\2$$&&^^\4\2$$&&\2\u090d\2\6\3\2\2\2\2\b\3\2"+ - "\2\2\2\n\3\2\2\2\2\f\3\2\2\2\2\16\3\2\2\2\2\22\3\2\2\2\2\24\3\2\2\2\2"+ - "\26\3\2\2\2\2\30\3\2\2\2\2\32\3\2\2\2\2\34\3\2\2\2\2\36\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\60\3\2\2\2\2\62\3\2\2\2\2\64\3\2\2\2\2\66\3\2\2\2\28\3"+ - "\2\2\2\2:\3\2\2\2\2<\3\2\2\2\2>\3\2\2\2\2@\3\2\2\2\2B\3\2\2\2\2D\3\2\2"+ - "\2\2F\3\2\2\2\2H\3\2\2\2\2J\3\2\2\2\2L\3\2\2\2\2N\3\2\2\2\2P\3\2\2\2\2"+ - "R\3\2\2\2\2T\3\2\2\2\2V\3\2\2\2\2X\3\2\2\2\2Z\3\2\2\2\2\\\3\2\2\2\2^\3"+ - "\2\2\2\2`\3\2\2\2\2b\3\2\2\2\2d\3\2\2\2\2f\3\2\2\2\2h\3\2\2\2\2j\3\2\2"+ - "\2\2l\3\2\2\2\2n\3\2\2\2\2p\3\2\2\2\2r\3\2\2\2\2t\3\2\2\2\2v\3\2\2\2\2"+ - "x\3\2\2\2\2z\3\2\2\2\2|\3\2\2\2\2~\3\2\2\2\2\u0080\3\2\2\2\2\u0082\3\2"+ - "\2\2\2\u0084\3\2\2\2\2\u0086\3\2\2\2\2\u0088\3\2\2\2\2\u008a\3\2\2\2\2"+ - "\u008c\3\2\2\2\2\u008e\3\2\2\2\2\u0090\3\2\2\2\2\u0092\3\2\2\2\2\u0094"+ - "\3\2\2\2\2\u0096\3\2\2\2\2\u0098\3\2\2\2\2\u009a\3\2\2\2\2\u009c\3\2\2"+ - "\2\2\u009e\3\2\2\2\2\u00a0\3\2\2\2\2\u00a2\3\2\2\2\2\u00a4\3\2\2\2\2\u00a6"+ - "\3\2\2\2\2\u00a8\3\2\2\2\2\u00aa\3\2\2\2\2\u00ac\3\2\2\2\2\u00ae\3\2\2"+ - "\2\2\u00b0\3\2\2\2\2\u00b2\3\2\2\2\2\u00b4\3\2\2\2\2\u00b6\3\2\2\2\2\u00b8"+ - "\3\2\2\2\2\u00ba\3\2\2\2\2\u00bc\3\2\2\2\2\u00be\3\2\2\2\2\u00c0\3\2\2"+ - "\2\2\u00c2\3\2\2\2\2\u00c4\3\2\2\2\2\u00c6\3\2\2\2\2\u00c8\3\2\2\2\2\u00ca"+ - "\3\2\2\2\2\u00cc\3\2\2\2\2\u00ce\3\2\2\2\2\u00d0\3\2\2\2\2\u00d2\3\2\2"+ - "\2\2\u00d4\3\2\2\2\2\u00d6\3\2\2\2\2\u00d8\3\2\2\2\2\u00da\3\2\2\2\2\u00dc"+ - "\3\2\2\2\2\u00de\3\2\2\2\2\u00e0\3\2\2\2\2\u00e2\3\2\2\2\2\u00e4\3\2\2"+ - "\2\2\u00e6\3\2\2\2\2\u00e8\3\2\2\2\2\u00ea\3\2\2\2\2\u00ec\3\2\2\2\2\u00ee"+ - "\3\2\2\2\2\u00f0\3\2\2\2\2\u00f2\3\2\2\2\2\u00f4\3\2\2\2\2\u00f6\3\2\2"+ - "\2\2\u00f8\3\2\2\2\2\u00fa\3\2\2\2\2\u00fc\3\2\2\2\2\u00fe\3\2\2\2\2\u0100"+ - "\3\2\2\2\2\u0102\3\2\2\2\2\u0104\3\2\2\2\2\u0106\3\2\2\2\2\u0108\3\2\2"+ - "\2\2\u010a\3\2\2\2\2\u010c\3\2\2\2\2\u010e\3\2\2\2\2\u0110\3\2\2\2\2\u0112"+ - "\3\2\2\2\2\u011e\3\2\2\2\2\u0120\3\2\2\2\2\u0122\3\2\2\2\2\u0124\3\2\2"+ - "\2\2\u012a\3\2\2\2\2\u0130\3\2\2\2\2\u0132\3\2\2\2\2\u0134\3\2\2\2\2\u0136"+ - "\3\2\2\2\2\u0138\3\2\2\2\2\u013a\3\2\2\2\2\u013e\3\2\2\2\2\u0140\3\2\2"+ - "\2\2\u0142\3\2\2\2\2\u014c\3\2\2\2\2\u014e\3\2\2\2\2\u0150\3\2\2\2\2\u0152"+ - "\3\2\2\2\2\u0154\3\2\2\2\2\u0156\3\2\2\2\2\u0158\3\2\2\2\2\u015a\3\2\2"+ - "\2\2\u015c\3\2\2\2\2\u0274\3\2\2\2\3\u015e\3\2\2\2\3\u0160\3\2\2\2\3\u0162"+ - "\3\2\2\2\3\u0164\3\2\2\2\3\u0166\3\2\2\2\4\u0168\3\2\2\2\4\u016a\3\2\2"+ - "\2\4\u016c\3\2\2\2\4\u016e\3\2\2\2\4\u0170\3\2\2\2\5\u0172\3\2\2\2\5\u0174"+ - "\3\2\2\2\5\u0176\3\2\2\2\5\u0178\3\2\2\2\5\u017a\3\2\2\2\5\u017c\3\2\2"+ - "\2\5\u017e\3\2\2\2\5\u0180\3\2\2\2\5\u0182\3\2\2\2\5\u0184\3\2\2\2\5\u0186"+ - "\3\2\2\2\5\u0188\3\2\2\2\5\u018a\3\2\2\2\5\u018c\3\2\2\2\5\u018e\3\2\2"+ - "\2\5\u0190\3\2\2\2\5\u0192\3\2\2\2\5\u0194\3\2\2\2\5\u0196\3\2\2\2\5\u0198"+ - "\3\2\2\2\5\u019a\3\2\2\2\5\u019c\3\2\2\2\5\u019e\3\2\2\2\5\u01a0\3\2\2"+ - "\2\5\u01a2\3\2\2\2\5\u01a4\3\2\2\2\5\u01a6\3\2\2\2\5\u01a8\3\2\2\2\5\u01aa"+ - "\3\2\2\2\5\u01ac\3\2\2\2\5\u01ae\3\2\2\2\5\u01b0\3\2\2\2\5\u01b2\3\2\2"+ - "\2\5\u01b4\3\2\2\2\5\u01b6\3\2\2\2\5\u01b8\3\2\2\2\5\u01ba\3\2\2\2\5\u01bc"+ - "\3\2\2\2\5\u01be\3\2\2\2\5\u01c0\3\2\2\2\5\u01c2\3\2\2\2\5\u01c4\3\2\2"+ - "\2\5\u01c6\3\2\2\2\5\u01c8\3\2\2\2\5\u01ca\3\2\2\2\5\u01cc\3\2\2\2\5\u01ce"+ - "\3\2\2\2\5\u01d0\3\2\2\2\5\u01d2\3\2\2\2\5\u01d4\3\2\2\2\5\u01d6\3\2\2"+ - "\2\5\u01d8\3\2\2\2\5\u01da\3\2\2\2\5\u01dc\3\2\2\2\5\u01de\3\2\2\2\5\u01e0"+ - "\3\2\2\2\5\u01e2\3\2\2\2\5\u01e4\3\2\2\2\5\u01e6\3\2\2\2\5\u01e8\3\2\2"+ - "\2\5\u01ea\3\2\2\2\5\u01ec\3\2\2\2\5\u01ee\3\2\2\2\5\u01f0\3\2\2\2\5\u01f2"+ - "\3\2\2\2\5\u01f4\3\2\2\2\5\u01f6\3\2\2\2\5\u01f8\3\2\2\2\5\u01fa\3\2\2"+ - "\2\5\u01fc\3\2\2\2\5\u01fe\3\2\2\2\5\u0200\3\2\2\2\5\u0202\3\2\2\2\5\u0204"+ - "\3\2\2\2\5\u0206\3\2\2\2\5\u0208\3\2\2\2\5\u020a\3\2\2\2\5\u020c\3\2\2"+ - "\2\5\u020e\3\2\2\2\5\u0210\3\2\2\2\5\u0212\3\2\2\2\5\u0214\3\2\2\2\5\u0216"+ - "\3\2\2\2\5\u0218\3\2\2\2\5\u021a\3\2\2\2\5\u021c\3\2\2\2\5\u021e\3\2\2"+ - "\2\5\u0220\3\2\2\2\5\u0222\3\2\2\2\5\u0224\3\2\2\2\5\u0226\3\2\2\2\5\u0228"+ - "\3\2\2\2\5\u022a\3\2\2\2\5\u022c\3\2\2\2\5\u022e\3\2\2\2\5\u0230\3\2\2"+ - "\2\5\u0232\3\2\2\2\5\u0234\3\2\2\2\5\u0236\3\2\2\2\5\u0238\3\2\2\2\5\u023a"+ - "\3\2\2\2\5\u023c\3\2\2\2\5\u023e\3\2\2\2\5\u0240\3\2\2\2\5\u0242\3\2\2"+ - "\2\5\u0244\3\2\2\2\5\u0246\3\2\2\2\5\u0248\3\2\2\2\5\u024a\3\2\2\2\5\u024c"+ - "\3\2\2\2\5\u024e\3\2\2\2\5\u0250\3\2\2\2\5\u0252\3\2\2\2\5\u0254\3\2\2"+ - "\2\5\u0256\3\2\2\2\5\u0258\3\2\2\2\5\u025a\3\2\2\2\5\u025c\3\2\2\2\5\u025e"+ - "\3\2\2\2\5\u0260\3\2\2\2\5\u0262\3\2\2\2\5\u0264\3\2\2\2\5\u0266\3\2\2"+ - "\2\5\u0268\3\2\2\2\5\u026a\3\2\2\2\5\u026c\3\2\2\2\5\u026e\3\2\2\2\5\u0270"+ - "\3\2\2\2\5\u0272\3\2\2\2\6\u0276\3\2\2\2\b\u027f\3\2\2\2\n\u028e\3\2\2"+ - "\2\f\u0299\3\2\2\2\16\u02a2\3\2\2\2\20\u02a7\3\2\2\2\22\u02a9\3\2\2\2"+ - "\24\u02ad\3\2\2\2\26\u02af\3\2\2\2\30\u02b1\3\2\2\2\32\u02b5\3\2\2\2\34"+ - "\u02b7\3\2\2\2\36\u02bb\3\2\2\2 \u02bd\3\2\2\2\"\u02c1\3\2\2\2$\u02c4"+ - "\3\2\2\2&\u02c6\3\2\2\2(\u02c8\3\2\2\2*\u02ca\3\2\2\2,\u02cc\3\2\2\2."+ - "\u02ce\3\2\2\2\60\u02d1\3\2\2\2\62\u02d4\3\2\2\2\64\u02d7\3\2\2\2\66\u02da"+ - "\3\2\2\28\u02dd\3\2\2\2:\u02df\3\2\2\2<\u02e1\3\2\2\2>\u02e3\3\2\2\2@"+ - "\u02e5\3\2\2\2B\u02e8\3\2\2\2D\u02eb\3\2\2\2F\u02ee\3\2\2\2H\u02f1\3\2"+ - "\2\2J\u02f4\3\2\2\2L\u02f7\3\2\2\2N\u02fa\3\2\2\2P\u02fd\3\2\2\2R\u0300"+ - "\3\2\2\2T\u0303\3\2\2\2V\u0305\3\2\2\2X\u0307\3\2\2\2Z\u030e\3\2\2\2\\"+ - "\u0314\3\2\2\2^\u031b\3\2\2\2`\u031e\3\2\2\2b\u0320\3\2\2\2d\u0322\3\2"+ - "\2\2f\u0324\3\2\2\2h\u0327\3\2\2\2j\u032a\3\2\2\2l\u032d\3\2\2\2n\u0331"+ - "\3\2\2\2p\u0335\3\2\2\2r\u0338\3\2\2\2t\u033c\3\2\2\2v\u033e\3\2\2\2x"+ - "\u0348\3\2\2\2z\u0354\3\2\2\2|\u035d\3\2\2\2~\u0365\3\2\2\2\u0080\u036e"+ - "\3\2\2\2\u0082\u0373\3\2\2\2\u0084\u0379\3\2\2\2\u0086\u0382\3\2\2\2\u0088"+ - "\u0386\3\2\2\2\u008a\u038a\3\2\2\2\u008c\u0393\3\2\2\2\u008e\u0399\3\2"+ - "\2\2\u0090\u03a2\3\2\2\2\u0092\u03ab\3\2\2\2\u0094\u03b3\3\2\2\2\u0096"+ - "\u03ba\3\2\2\2\u0098\u03c0\3\2\2\2\u009a\u03ca\3\2\2\2\u009c\u03ce\3\2"+ - "\2\2\u009e\u03d5\3\2\2\2\u00a0\u03d9\3\2\2\2\u00a2\u03dd\3\2\2\2\u00a4"+ - "\u03e7\3\2\2\2\u00a6\u03f3\3\2\2\2\u00a8\u03f6\3\2\2\2\u00aa\u0400\3\2"+ - "\2\2\u00ac\u0405\3\2\2\2\u00ae\u040a\3\2\2\2\u00b0\u0410\3\2\2\2\u00b2"+ - "\u0417\3\2\2\2\u00b4\u041d\3\2\2\2\u00b6\u0420\3\2\2\2\u00b8\u0425\3\2"+ - "\2\2\u00ba\u042a\3\2\2\2\u00bc\u042e\3\2\2\2\u00be\u0434\3\2\2\2\u00c0"+ - "\u043c\3\2\2\2\u00c2\u0440\3\2\2\2\u00c4\u0443\3\2\2\2\u00c6\u0449\3\2"+ - "\2\2\u00c8\u044f\3\2\2\2\u00ca\u0456\3\2\2\2\u00cc\u045f\3\2\2\2\u00ce"+ - "\u0465\3\2\2\2\u00d0\u0468\3\2\2\2\u00d2\u046b\3\2\2\2\u00d4\u046e\3\2"+ - "\2\2\u00d6\u0476\3\2\2\2\u00d8\u047e\3\2\2\2\u00da\u0482\3\2\2\2\u00dc"+ - "\u048a\3\2\2\2\u00de\u0491\3\2\2\2\u00e0\u0499\3\2\2\2\u00e2\u04a3\3\2"+ - "\2\2\u00e4\u04ac\3\2\2\2\u00e6\u04b1\3\2\2\2\u00e8\u04b8\3\2\2\2\u00ea"+ - "\u04c3\3\2\2\2\u00ec\u04c8\3\2\2\2\u00ee\u04ce\3\2\2\2\u00f0\u04d4\3\2"+ - "\2\2\u00f2\u04dc\3\2\2\2\u00f4\u04e5\3\2\2\2\u00f6\u04ec\3\2\2\2\u00f8"+ - "\u04f2\3\2\2\2\u00fa\u04fb\3\2\2\2\u00fc\u0503\3\2\2\2\u00fe\u050c\3\2"+ - "\2\2\u0100\u0515\3\2\2\2\u0102\u051b\3\2\2\2\u0104\u0520\3\2\2\2\u0106"+ - "\u0526\3\2\2\2\u0108\u052f\3\2\2\2\u010a\u0536\3\2\2\2\u010c\u053f\3\2"+ - "\2\2\u010e\u054b\3\2\2\2\u0110\u0553\3\2\2\2\u0112\u055a\3\2\2\2\u0114"+ - "\u0561\3\2\2\2\u0116\u0563\3\2\2\2\u0118\u0567\3\2\2\2\u011a\u0573\3\2"+ - "\2\2\u011c\u0575\3\2\2\2\u011e\u057d\3\2\2\2\u0120\u0585\3\2\2\2\u0122"+ - "\u0592\3\2\2\2\u0124\u059e\3\2\2\2\u0126\u05a0\3\2\2\2\u0128\u05a4\3\2"+ - "\2\2\u012a\u05b4\3\2\2\2\u012c\u05b6\3\2\2\2\u012e\u05ba\3\2\2\2\u0130"+ - "\u05ca\3\2\2\2\u0132\u05cf\3\2\2\2\u0134\u05d8\3\2\2\2\u0136\u05e5\3\2"+ - "\2\2\u0138\u05e7\3\2\2\2\u013a\u05ec\3\2\2\2\u013c\u05f3\3\2\2\2\u013e"+ - "\u0608\3\2\2\2\u0140\u063a\3\2\2\2\u0142\u063c\3\2\2\2\u0144\u063f\3\2"+ - "\2\2\u0146\u0646\3\2\2\2\u0148\u064b\3\2\2\2\u014a\u0652\3\2\2\2\u014c"+ - "\u0654\3\2\2\2\u014e\u0658\3\2\2\2\u0150\u065e\3\2\2\2\u0152\u0660\3\2"+ - "\2\2\u0154\u0662\3\2\2\2\u0156\u0664\3\2\2\2\u0158\u0666\3\2\2\2\u015a"+ - "\u0668\3\2\2\2\u015c\u066a\3\2\2\2\u015e\u066c\3\2\2\2\u0160\u0670\3\2"+ - "\2\2\u0162\u0678\3\2\2\2\u0164\u067c\3\2\2\2\u0166\u067e\3\2\2\2\u0168"+ - "\u0684\3\2\2\2\u016a\u068d\3\2\2\2\u016c\u0691\3\2\2\2\u016e\u0699\3\2"+ - "\2\2\u0170\u069b\3\2\2\2\u0172\u06a0\3\2\2\2\u0174\u06a5\3\2\2\2\u0176"+ - "\u06aa\3\2\2\2\u0178\u06af\3\2\2\2\u017a\u06b4\3\2\2\2\u017c\u06b9\3\2"+ - "\2\2\u017e\u06be\3\2\2\2\u0180\u06c2\3\2\2\2\u0182\u06c6\3\2\2\2\u0184"+ - "\u06ca\3\2\2\2\u0186\u06ce\3\2\2\2\u0188\u06d2\3\2\2\2\u018a\u06d6\3\2"+ - "\2\2\u018c\u06da\3\2\2\2\u018e\u06de\3\2\2\2\u0190\u06e2\3\2\2\2\u0192"+ - "\u06e6\3\2\2\2\u0194\u06ea\3\2\2\2\u0196\u06f1\3\2\2\2\u0198\u06f5\3\2"+ - "\2\2\u019a\u06f9\3\2\2\2\u019c\u06fd\3\2\2\2\u019e\u0701\3\2\2\2\u01a0"+ - "\u0705\3\2\2\2\u01a2\u0709\3\2\2\2\u01a4\u070d\3\2\2\2\u01a6\u0711\3\2"+ - "\2\2\u01a8\u0715\3\2\2\2\u01aa\u0719\3\2\2\2\u01ac\u071d\3\2\2\2\u01ae"+ - "\u0721\3\2\2\2\u01b0\u0725\3\2\2\2\u01b2\u0729\3\2\2\2\u01b4\u072d\3\2"+ - "\2\2\u01b6\u0731\3\2\2\2\u01b8\u0735\3\2\2\2\u01ba\u0739\3\2\2\2\u01bc"+ - "\u073d\3\2\2\2\u01be\u0741\3\2\2\2\u01c0\u0748\3\2\2\2\u01c2\u074c\3\2"+ - "\2\2\u01c4\u0750\3\2\2\2\u01c6\u0754\3\2\2\2\u01c8\u0758\3\2\2\2\u01ca"+ - "\u075c\3\2\2\2\u01cc\u0760\3\2\2\2\u01ce\u0764\3\2\2\2\u01d0\u0768\3\2"+ - "\2\2\u01d2\u076c\3\2\2\2\u01d4\u0770\3\2\2\2\u01d6\u0774\3\2\2\2\u01d8"+ - "\u0778\3\2\2\2\u01da\u077c\3\2\2\2\u01dc\u0780\3\2\2\2\u01de\u0784\3\2"+ - "\2\2\u01e0\u0789\3\2\2\2\u01e2\u078e\3\2\2\2\u01e4\u0792\3\2\2\2\u01e6"+ - "\u0796\3\2\2\2\u01e8\u079a\3\2\2\2\u01ea\u079e\3\2\2\2\u01ec\u07a2\3\2"+ - "\2\2\u01ee\u07a6\3\2\2\2\u01f0\u07aa\3\2\2\2\u01f2\u07ae\3\2\2\2\u01f4"+ - "\u07b2\3\2\2\2\u01f6\u07b6\3\2\2\2\u01f8\u07ba\3\2\2\2\u01fa\u07be\3\2"+ - "\2\2\u01fc\u07c2\3\2\2\2\u01fe\u07c6\3\2\2\2\u0200\u07ca\3\2\2\2\u0202"+ - "\u07ce\3\2\2\2\u0204\u07d2\3\2\2\2\u0206\u07d6\3\2\2\2\u0208\u07da\3\2"+ - "\2\2\u020a\u07de\3\2\2\2\u020c\u07e2\3\2\2\2\u020e\u07e6\3\2\2\2\u0210"+ - "\u07ea\3\2\2\2\u0212\u07ee\3\2\2\2\u0214\u07f2\3\2\2\2\u0216\u07f6\3\2"+ - "\2\2\u0218\u07fa\3\2\2\2\u021a\u07fe\3\2\2\2\u021c\u0802\3\2\2\2\u021e"+ - "\u0806\3\2\2\2\u0220\u080a\3\2\2\2\u0222\u080e\3\2\2\2\u0224\u0812\3\2"+ - "\2\2\u0226\u0816\3\2\2\2\u0228\u081a\3\2\2\2\u022a\u081e\3\2\2\2\u022c"+ - "\u0822\3\2\2\2\u022e\u0826\3\2\2\2\u0230\u082a\3\2\2\2\u0232\u082e\3\2"+ - "\2\2\u0234\u0832\3\2\2\2\u0236\u0836\3\2\2\2\u0238\u083a\3\2\2\2\u023a"+ - "\u083e\3\2\2\2\u023c\u0842\3\2\2\2\u023e\u0846\3\2\2\2\u0240\u084a\3\2"+ - "\2\2\u0242\u084e\3\2\2\2\u0244\u0852\3\2\2\2\u0246\u0856\3\2\2\2\u0248"+ - "\u085a\3\2\2\2\u024a\u085e\3\2\2\2\u024c\u0862\3\2\2\2\u024e\u0866\3\2"+ - "\2\2\u0250\u086a\3\2\2\2\u0252\u086e\3\2\2\2\u0254\u0872\3\2\2\2\u0256"+ - "\u0876\3\2\2\2\u0258\u087a\3\2\2\2\u025a\u087e\3\2\2\2\u025c\u0882\3\2"+ - "\2\2\u025e\u0886\3\2\2\2\u0260\u088a\3\2\2\2\u0262\u088e\3\2\2\2\u0264"+ - "\u0892\3\2\2\2\u0266\u0896\3\2\2\2\u0268\u089a\3\2\2\2\u026a\u089e\3\2"+ - "\2\2\u026c\u08a2\3\2\2\2\u026e\u08a8\3\2\2\2\u0270\u08ac\3\2\2\2\u0272"+ - "\u08b0\3\2\2\2\u0274\u08b4\3\2\2\2\u0276\u0277\7%\2\2\u0277\u0278\7#\2"+ - "\2\u0278\u027c\3\2\2\2\u0279\u027b\n\2\2\2\u027a\u0279\3\2\2\2\u027b\u027e"+ - "\3\2\2\2\u027c\u027a\3\2\2\2\u027c\u027d\3\2\2\2\u027d\7\3\2\2\2\u027e"+ - "\u027c\3\2\2\2\u027f\u0280\7\61\2\2\u0280\u0281\7,\2\2\u0281\u0286\3\2"+ - "\2\2\u0282\u0285\5\b\3\2\u0283\u0285\13\2\2\2\u0284\u0282\3\2\2\2\u0284"+ - "\u0283\3\2\2\2\u0285\u0288\3\2\2\2\u0286\u0287\3\2\2\2\u0286\u0284\3\2"+ - "\2\2\u0287\u0289\3\2\2\2\u0288\u0286\3\2\2\2\u0289\u028a\7,\2\2\u028a"+ - "\u028b\7\61\2\2\u028b\u028c\3\2\2\2\u028c\u028d\b\3\2\2\u028d\t\3\2\2"+ - "\2\u028e\u028f\7\61\2\2\u028f\u0290\7\61\2\2\u0290\u0294\3\2\2\2\u0291"+ - "\u0293\n\2\2\2\u0292\u0291\3\2\2\2\u0293\u0296\3\2\2\2\u0294\u0292\3\2"+ - "\2\2\u0294\u0295\3\2\2\2\u0295\u0297\3\2\2\2\u0296\u0294\3\2\2\2\u0297"+ - "\u0298\b\4\2\2\u0298\13\3\2\2\2\u0299\u029a\t\3\2\2\u029a\u029b\3\2\2"+ - "\2\u029b\u029c\b\5\2\2\u029c\r\3\2\2\2\u029d\u02a3\7\f\2\2\u029e\u02a0"+ - "\7\17\2\2\u029f\u02a1\7\f\2\2\u02a0\u029f\3\2\2\2\u02a0\u02a1\3\2\2\2"+ - "\u02a1\u02a3\3\2\2\2\u02a2\u029d\3\2\2\2\u02a2\u029e\3\2\2\2\u02a3\17"+ - "\3\2\2\2\u02a4\u02a8\5\b\3\2\u02a5\u02a8\5\n\4\2\u02a6\u02a8\5\f\5\2\u02a7"+ - "\u02a4\3\2\2\2\u02a7\u02a5\3\2\2\2\u02a7\u02a6\3\2\2\2\u02a8\21\3\2\2"+ - "\2\u02a9\u02aa\7\60\2\2\u02aa\u02ab\7\60\2\2\u02ab\u02ac\7\60\2\2\u02ac"+ - "\23\3\2\2\2\u02ad\u02ae\7\60\2\2\u02ae\25\3\2\2\2\u02af\u02b0\7.\2\2\u02b0"+ - "\27\3\2\2\2\u02b1\u02b2\7*\2\2\u02b2\u02b3\3\2\2\2\u02b3\u02b4\b\13\3"+ - "\2\u02b4\31\3\2\2\2\u02b5\u02b6\7+\2\2\u02b6\33\3\2\2\2\u02b7\u02b8\7"+ - "]\2\2\u02b8\u02b9\3\2\2\2\u02b9\u02ba\b\r\3\2\u02ba\35\3\2\2\2\u02bb\u02bc"+ - "\7_\2\2\u02bc\37\3\2\2\2\u02bd\u02be\7}\2\2\u02be\u02bf\3\2\2\2\u02bf"+ - "\u02c0\b\17\4\2\u02c0!\3\2\2\2\u02c1\u02c2\7\177\2\2\u02c2\u02c3\b\20"+ - "\5\2\u02c3#\3\2\2\2\u02c4\u02c5\7,\2\2\u02c5%\3\2\2\2\u02c6\u02c7\7\'"+ - "\2\2\u02c7\'\3\2\2\2\u02c8\u02c9\7\61\2\2\u02c9)\3\2\2\2\u02ca\u02cb\7"+ - "-\2\2\u02cb+\3\2\2\2\u02cc\u02cd\7/\2\2\u02cd-\3\2\2\2\u02ce\u02cf\7-"+ - "\2\2\u02cf\u02d0\7-\2\2\u02d0/\3\2\2\2\u02d1\u02d2\7/\2\2\u02d2\u02d3"+ - "\7/\2\2\u02d3\61\3\2\2\2\u02d4\u02d5\7(\2\2\u02d5\u02d6\7(\2\2\u02d6\63"+ - "\3\2\2\2\u02d7\u02d8\7~\2\2\u02d8\u02d9\7~\2\2\u02d9\65\3\2\2\2\u02da"+ - "\u02db\7#\2\2\u02db\u02dc\5\20\7\2\u02dc\67\3\2\2\2\u02dd\u02de\7#\2\2"+ - "\u02de9\3\2\2\2\u02df\u02e0\7<\2\2\u02e0;\3\2\2\2\u02e1\u02e2\7=\2\2\u02e2"+ - "=\3\2\2\2\u02e3\u02e4\7?\2\2\u02e4?\3\2\2\2\u02e5\u02e6\7-\2\2\u02e6\u02e7"+ - "\7?\2\2\u02e7A\3\2\2\2\u02e8\u02e9\7/\2\2\u02e9\u02ea\7?\2\2\u02eaC\3"+ - "\2\2\2\u02eb\u02ec\7,\2\2\u02ec\u02ed\7?\2\2\u02edE\3\2\2\2\u02ee\u02ef"+ - "\7\61\2\2\u02ef\u02f0\7?\2\2\u02f0G\3\2\2\2\u02f1\u02f2\7\'\2\2\u02f2"+ - "\u02f3\7?\2\2\u02f3I\3\2\2\2\u02f4\u02f5\7/\2\2\u02f5\u02f6\7@\2\2\u02f6"+ - "K\3\2\2\2\u02f7\u02f8\7?\2\2\u02f8\u02f9\7@\2\2\u02f9M\3\2\2\2\u02fa\u02fb"+ - "\7\60\2\2\u02fb\u02fc\7\60\2\2\u02fcO\3\2\2\2\u02fd\u02fe\7<\2\2\u02fe"+ - "\u02ff\7<\2\2\u02ffQ\3\2\2\2\u0300\u0301\7=\2\2\u0301\u0302\7=\2\2\u0302"+ - "S\3\2\2\2\u0303\u0304\7%\2\2\u0304U\3\2\2\2\u0305\u0306\7B\2\2\u0306W"+ - "\3\2\2\2\u0307\u030a\7B\2\2\u0308\u030b\5\20\7\2\u0309\u030b\5\16\6\2"+ - "\u030a\u0308\3\2\2\2\u030a\u0309\3\2\2\2\u030bY\3\2\2\2\u030c\u030f\5"+ - "\20\7\2\u030d\u030f\5\16\6\2\u030e\u030c\3\2\2\2\u030e\u030d\3\2\2\2\u030f"+ - "\u0310\3\2\2\2\u0310\u0311\7B\2\2\u0311[\3\2\2\2\u0312\u0315\5\20\7\2"+ - "\u0313\u0315\5\16\6\2\u0314\u0312\3\2\2\2\u0314\u0313\3\2\2\2\u0315\u0316"+ - "\3\2\2\2\u0316\u0319\7B\2\2\u0317\u031a\5\20\7\2\u0318\u031a\5\16\6\2"+ - "\u0319\u0317\3\2\2\2\u0319\u0318\3\2\2\2\u031a]\3\2\2\2\u031b\u031c\7"+ - "A\2\2\u031c\u031d\5\20\7\2\u031d_\3\2\2\2\u031e\u031f\7A\2\2\u031fa\3"+ - "\2\2\2\u0320\u0321\7>\2\2\u0321c\3\2\2\2\u0322\u0323\7@\2\2\u0323e\3\2"+ - "\2\2\u0324\u0325\7>\2\2\u0325\u0326\7?\2\2\u0326g\3\2\2\2\u0327\u0328"+ - "\7@\2\2\u0328\u0329\7?\2\2\u0329i\3\2\2\2\u032a\u032b\7#\2\2\u032b\u032c"+ - "\7?\2\2\u032ck\3\2\2\2\u032d\u032e\7#\2\2\u032e\u032f\7?\2\2\u032f\u0330"+ - "\7?\2\2\u0330m\3\2\2\2\u0331\u0332\7c\2\2\u0332\u0333\7u\2\2\u0333\u0334"+ - "\7A\2\2\u0334o\3\2\2\2\u0335\u0336\7?\2\2\u0336\u0337\7?\2\2\u0337q\3"+ - "\2\2\2\u0338\u0339\7?\2\2\u0339\u033a\7?\2\2\u033a\u033b\7?\2\2\u033b"+ - "s\3\2\2\2\u033c\u033d\7)\2\2\u033du\3\2\2\2\u033e\u033f\7t\2\2\u033f\u0340"+ - "\7g\2\2\u0340\u0341\7v\2\2\u0341\u0342\7w\2\2\u0342\u0343\7t\2\2\u0343"+ - "\u0344\7p\2\2\u0344\u0345\7B\2\2\u0345\u0346\3\2\2\2\u0346\u0347\5\u013e"+ - "\u009e\2\u0347w\3\2\2\2\u0348\u0349\7e\2\2\u0349\u034a\7q\2\2\u034a\u034b"+ - "\7p\2\2\u034b\u034c\7v\2\2\u034c\u034d\7k\2\2\u034d\u034e\7p\2\2\u034e"+ - "\u034f\7w\2\2\u034f\u0350\7g\2\2\u0350\u0351\7B\2\2\u0351\u0352\3\2\2"+ - "\2\u0352\u0353\5\u013e\u009e\2\u0353y\3\2\2\2\u0354\u0355\7d\2\2\u0355"+ - "\u0356\7t\2\2\u0356\u0357\7g\2\2\u0357\u0358\7c\2\2\u0358\u0359\7m\2\2"+ - "\u0359\u035a\7B\2\2\u035a\u035b\3\2\2\2\u035b\u035c\5\u013e\u009e\2\u035c"+ - "{\3\2\2\2\u035d\u035e\7v\2\2\u035e\u035f\7j\2\2\u035f\u0360\7k\2\2\u0360"+ - "\u0361\7u\2\2\u0361\u0362\7B\2\2\u0362\u0363\3\2\2\2\u0363\u0364\5\u013e"+ - "\u009e\2\u0364}\3\2\2\2\u0365\u0366\7u\2\2\u0366\u0367\7w\2\2\u0367\u0368"+ - "\7r\2\2\u0368\u0369\7g\2\2\u0369\u036a\7t\2\2\u036a\u036b\7B\2\2\u036b"+ - "\u036c\3\2\2\2\u036c\u036d\5\u013e\u009e\2\u036d\177\3\2\2\2\u036e\u036f"+ - "\7h\2\2\u036f\u0370\7k\2\2\u0370\u0371\7n\2\2\u0371\u0372\7g\2\2\u0372"+ - "\u0081\3\2\2\2\u0373\u0374\7h\2\2\u0374\u0375\7k\2\2\u0375\u0376\7g\2"+ - "\2\u0376\u0377\7n\2\2\u0377\u0378\7f\2\2\u0378\u0083\3\2\2\2\u0379\u037a"+ - "\7r\2\2\u037a\u037b\7t\2\2\u037b\u037c\7q\2\2\u037c\u037d\7r\2\2\u037d"+ - "\u037e\7g\2\2\u037e\u037f\7t\2\2\u037f\u0380\7v\2\2\u0380\u0381\7{\2\2"+ - "\u0381\u0085\3\2\2\2\u0382\u0383\7i\2\2\u0383\u0384\7g\2\2\u0384\u0385"+ - "\7v\2\2\u0385\u0087\3\2\2\2\u0386\u0387\7u\2\2\u0387\u0388\7g\2\2\u0388"+ - "\u0389\7v\2\2\u0389\u0089\3\2\2\2\u038a\u038b\7t\2\2\u038b\u038c\7g\2"+ - "\2\u038c\u038d\7e\2\2\u038d\u038e\7g\2\2\u038e\u038f\7k\2\2\u038f\u0390"+ - "\7x\2\2\u0390\u0391\7g\2\2\u0391\u0392\7t\2\2\u0392\u008b\3\2\2\2\u0393"+ - "\u0394\7r\2\2\u0394\u0395\7c\2\2\u0395\u0396\7t\2\2\u0396\u0397\7c\2\2"+ - "\u0397\u0398\7o\2\2\u0398\u008d\3\2\2\2\u0399\u039a\7u\2\2\u039a\u039b"+ - "\7g\2\2\u039b\u039c\7v\2\2\u039c\u039d\7r\2\2\u039d\u039e\7c\2\2\u039e"+ - "\u039f\7t\2\2\u039f\u03a0\7c\2\2\u03a0\u03a1\7o\2\2\u03a1\u008f\3\2\2"+ - "\2\u03a2\u03a3\7f\2\2\u03a3\u03a4\7g\2\2\u03a4\u03a5\7n\2\2\u03a5\u03a6"+ - "\7g\2\2\u03a6\u03a7\7i\2\2\u03a7\u03a8\7c\2\2\u03a8\u03a9\7v\2\2\u03a9"+ - "\u03aa\7g\2\2\u03aa\u0091\3\2\2\2\u03ab\u03ac\7r\2\2\u03ac\u03ad\7c\2"+ - "\2\u03ad\u03ae\7e\2\2\u03ae\u03af\7m\2\2\u03af\u03b0\7c\2\2\u03b0\u03b1"+ - "\7i\2\2\u03b1\u03b2\7g\2\2\u03b2\u0093\3\2\2\2\u03b3\u03b4\7k\2\2\u03b4"+ - "\u03b5\7o\2\2\u03b5\u03b6\7r\2\2\u03b6\u03b7\7q\2\2\u03b7\u03b8\7t\2\2"+ - "\u03b8\u03b9\7v\2\2\u03b9\u0095\3\2\2\2\u03ba\u03bb\7e\2\2\u03bb\u03bc"+ - "\7n\2\2\u03bc\u03bd\7c\2\2\u03bd\u03be\7u\2\2\u03be\u03bf\7u\2\2\u03bf"+ - "\u0097\3\2\2\2\u03c0\u03c1\7k\2\2\u03c1\u03c2\7p\2\2\u03c2\u03c3\7v\2"+ - "\2\u03c3\u03c4\7g\2\2\u03c4\u03c5\7t\2\2\u03c5\u03c6\7h\2\2\u03c6\u03c7"+ - "\7c\2\2\u03c7\u03c8\7e\2\2\u03c8\u03c9\7g\2\2\u03c9\u0099\3\2\2\2\u03ca"+ - "\u03cb\7h\2\2\u03cb\u03cc\7w\2\2\u03cc\u03cd\7p\2\2\u03cd\u009b\3\2\2"+ - "\2\u03ce\u03cf\7q\2\2\u03cf\u03d0\7d\2\2\u03d0\u03d1\7l\2\2\u03d1\u03d2"+ - "\7g\2\2\u03d2\u03d3\7e\2\2\u03d3\u03d4\7v\2\2\u03d4\u009d\3\2\2\2\u03d5"+ - "\u03d6\7x\2\2\u03d6\u03d7\7c\2\2\u03d7\u03d8\7n\2\2\u03d8\u009f\3\2\2"+ - "\2\u03d9\u03da\7x\2\2\u03da\u03db\7c\2\2\u03db\u03dc\7t\2\2\u03dc\u00a1"+ - "\3\2\2\2\u03dd\u03de\7v\2\2\u03de\u03df\7{\2\2\u03df\u03e0\7r\2\2\u03e0"+ - "\u03e1\7g\2\2\u03e1\u03e2\7c\2\2\u03e2\u03e3\7n\2\2\u03e3\u03e4\7k\2\2"+ - "\u03e4\u03e5\7c\2\2\u03e5\u03e6\7u\2\2\u03e6\u00a3\3\2\2\2\u03e7\u03e8"+ - "\7e\2\2\u03e8\u03e9\7q\2\2\u03e9\u03ea\7p\2\2\u03ea\u03eb\7u\2\2\u03eb"+ - "\u03ec\7v\2\2\u03ec\u03ed\7t\2\2\u03ed\u03ee\7w\2\2\u03ee\u03ef\7e\2\2"+ - "\u03ef\u03f0\7v\2\2\u03f0\u03f1\7q\2\2\u03f1\u03f2\7t\2\2\u03f2\u00a5"+ - "\3\2\2\2\u03f3\u03f4\7d\2\2\u03f4\u03f5\7{\2\2\u03f5\u00a7\3\2\2\2\u03f6"+ - "\u03f7\7e\2\2\u03f7\u03f8\7q\2\2\u03f8\u03f9\7o\2\2\u03f9\u03fa\7r\2\2"+ - "\u03fa\u03fb\7c\2\2\u03fb\u03fc\7p\2\2\u03fc\u03fd\7k\2\2\u03fd\u03fe"+ - "\7q\2\2\u03fe\u03ff\7p\2\2\u03ff\u00a9\3\2\2\2\u0400\u0401\7k\2\2\u0401"+ - "\u0402\7p\2\2\u0402\u0403\7k\2\2\u0403\u0404\7v\2\2\u0404\u00ab\3\2\2"+ - "\2\u0405\u0406\7v\2\2\u0406\u0407\7j\2\2\u0407\u0408\7k\2\2\u0408\u0409"+ - "\7u\2\2\u0409\u00ad\3\2\2\2\u040a\u040b\7u\2\2\u040b\u040c\7w\2\2\u040c"+ - "\u040d\7r\2\2\u040d\u040e\7g\2\2\u040e\u040f\7t\2\2\u040f\u00af\3\2\2"+ - "\2\u0410\u0411\7v\2\2\u0411\u0412\7{\2\2\u0412\u0413\7r\2\2\u0413\u0414"+ - "\7g\2\2\u0414\u0415\7q\2\2\u0415\u0416\7h\2\2\u0416\u00b1\3\2\2\2\u0417"+ - "\u0418\7y\2\2\u0418\u0419\7j\2\2\u0419\u041a\7g\2\2\u041a\u041b\7t\2\2"+ - "\u041b\u041c\7g\2\2\u041c\u00b3\3\2\2\2\u041d\u041e\7k\2\2\u041e\u041f"+ - "\7h\2\2\u041f\u00b5\3\2\2\2\u0420\u0421\7g\2\2\u0421\u0422\7n\2\2\u0422"+ - "\u0423\7u\2\2\u0423\u0424\7g\2\2\u0424\u00b7\3\2\2\2\u0425\u0426\7y\2"+ - "\2\u0426\u0427\7j\2\2\u0427\u0428\7g\2\2\u0428\u0429\7p\2\2\u0429\u00b9"+ - "\3\2\2\2\u042a\u042b\7v\2\2\u042b\u042c\7t\2\2\u042c\u042d\7{\2\2\u042d"+ - "\u00bb\3\2\2\2\u042e\u042f\7e\2\2\u042f\u0430\7c\2\2\u0430\u0431\7v\2"+ - "\2\u0431\u0432\7e\2\2\u0432\u0433\7j\2\2\u0433\u00bd\3\2\2\2\u0434\u0435"+ - "\7h\2\2\u0435\u0436\7k\2\2\u0436\u0437\7p\2\2\u0437\u0438\7c\2\2\u0438"+ - "\u0439\7n\2\2\u0439\u043a\7n\2\2\u043a\u043b\7{\2\2\u043b\u00bf\3\2\2"+ - "\2\u043c\u043d\7h\2\2\u043d\u043e\7q\2\2\u043e\u043f\7t\2\2\u043f\u00c1"+ - "\3\2\2\2\u0440\u0441\7f\2\2\u0441\u0442\7q\2\2\u0442\u00c3\3\2\2\2\u0443"+ - "\u0444\7y\2\2\u0444\u0445\7j\2\2\u0445\u0446\7k\2\2\u0446\u0447\7n\2\2"+ - "\u0447\u0448\7g\2\2\u0448\u00c5\3\2\2\2\u0449\u044a\7v\2\2\u044a\u044b"+ - "\7j\2\2\u044b\u044c\7t\2\2\u044c\u044d\7q\2\2\u044d\u044e\7y\2\2\u044e"+ - "\u00c7\3\2\2\2\u044f\u0450\7t\2\2\u0450\u0451\7g\2\2\u0451\u0452\7v\2"+ - "\2\u0452\u0453\7w\2\2\u0453\u0454\7t\2\2\u0454\u0455\7p\2\2\u0455\u00c9"+ - "\3\2\2\2\u0456\u0457\7e\2\2\u0457\u0458\7q\2\2\u0458\u0459\7p\2\2\u0459"+ - "\u045a\7v\2\2\u045a\u045b\7k\2\2\u045b\u045c\7p\2\2\u045c\u045d\7w\2\2"+ - "\u045d\u045e\7g\2\2\u045e\u00cb\3\2\2\2\u045f\u0460\7d\2\2\u0460\u0461"+ - "\7t\2\2\u0461\u0462\7g\2\2\u0462\u0463\7c\2\2\u0463\u0464\7m\2\2\u0464"+ - "\u00cd\3\2\2\2\u0465\u0466\7c\2\2\u0466\u0467\7u\2\2\u0467\u00cf\3\2\2"+ - "\2\u0468\u0469\7k\2\2\u0469\u046a\7u\2\2\u046a\u00d1\3\2\2\2\u046b\u046c"+ - "\7k\2\2\u046c\u046d\7p\2\2\u046d\u00d3\3\2\2\2\u046e\u046f\7#\2\2\u046f"+ - "\u0470\7k\2\2\u0470\u0471\7u\2\2\u0471\u0474\3\2\2\2\u0472\u0475\5\20"+ - "\7\2\u0473\u0475\5\16\6\2\u0474\u0472\3\2\2\2\u0474\u0473\3\2\2\2\u0475"+ - "\u00d5\3\2\2\2\u0476\u0477\7#\2\2\u0477\u0478\7k\2\2\u0478\u0479\7p\2"+ - "\2\u0479\u047c\3\2\2\2\u047a\u047d\5\20\7\2\u047b\u047d\5\16\6\2\u047c"+ - "\u047a\3\2\2\2\u047c\u047b\3\2\2\2\u047d\u00d7\3\2\2\2\u047e\u047f\7q"+ - "\2\2\u047f\u0480\7w\2\2\u0480\u0481\7v\2\2\u0481\u00d9\3\2\2\2\u0482\u0483"+ - "\7f\2\2\u0483\u0484\7{\2\2\u0484\u0485\7p\2\2\u0485\u0486\7c\2\2\u0486"+ - "\u0487\7o\2\2\u0487\u0488\7k\2\2\u0488\u0489\7e\2\2\u0489\u00db\3\2\2"+ - "\2\u048a\u048b\7r\2\2\u048b\u048c\7w\2\2\u048c\u048d\7d\2\2\u048d\u048e"+ - "\7n\2\2\u048e\u048f\7k\2\2\u048f\u0490\7e\2\2\u0490\u00dd\3\2\2\2\u0491"+ - "\u0492\7r\2\2\u0492\u0493\7t\2\2\u0493\u0494\7k\2\2\u0494\u0495\7x\2\2"+ - "\u0495\u0496\7c\2\2\u0496\u0497\7v\2\2\u0497\u0498\7g\2\2\u0498\u00df"+ - "\3\2\2\2\u0499\u049a\7r\2\2\u049a\u049b\7t\2\2\u049b\u049c\7q\2\2\u049c"+ - "\u049d\7v\2\2\u049d\u049e\7g\2\2\u049e\u049f\7e\2\2\u049f\u04a0\7v\2\2"+ - "\u04a0\u04a1\7g\2\2\u04a1\u04a2\7f\2\2\u04a2\u00e1\3\2\2\2\u04a3\u04a4"+ - "\7k\2\2\u04a4\u04a5\7p\2\2\u04a5\u04a6\7v\2\2\u04a6\u04a7\7g\2\2\u04a7"+ - "\u04a8\7t\2\2\u04a8\u04a9\7p\2\2\u04a9\u04aa\7c\2\2\u04aa\u04ab\7n\2\2"+ - "\u04ab\u00e3\3\2\2\2\u04ac\u04ad\7g\2\2\u04ad\u04ae\7p\2\2\u04ae\u04af"+ - "\7w\2\2\u04af\u04b0\7o\2\2\u04b0\u00e5\3\2\2\2\u04b1\u04b2\7u\2\2\u04b2"+ - "\u04b3\7g\2\2\u04b3\u04b4\7c\2\2\u04b4\u04b5\7n\2\2\u04b5\u04b6\7g\2\2"+ - "\u04b6\u04b7\7f\2\2\u04b7\u00e7\3\2\2\2\u04b8\u04b9\7c\2\2\u04b9\u04ba"+ - "\7p\2\2\u04ba\u04bb\7p\2\2\u04bb\u04bc\7q\2\2\u04bc\u04bd\7v\2\2\u04bd"+ - "\u04be\7c\2\2\u04be\u04bf\7v\2\2\u04bf\u04c0\7k\2\2\u04c0\u04c1\7q\2\2"+ - "\u04c1\u04c2\7p\2\2\u04c2\u00e9\3\2\2\2\u04c3\u04c4\7f\2\2\u04c4\u04c5"+ - "\7c\2\2\u04c5\u04c6\7v\2\2\u04c6\u04c7\7c\2\2\u04c7\u00eb\3\2\2\2\u04c8"+ - "\u04c9\7k\2\2\u04c9\u04ca\7p\2\2\u04ca\u04cb\7p\2\2\u04cb\u04cc\7g\2\2"+ - "\u04cc\u04cd\7t\2\2\u04cd\u00ed\3\2\2\2\u04ce\u04cf\7x\2\2\u04cf\u04d0"+ - "\7c\2\2\u04d0\u04d1\7n\2\2\u04d1\u04d2\7w\2\2\u04d2\u04d3\7g\2\2\u04d3"+ - "\u00ef\3\2\2\2\u04d4\u04d5\7v\2\2\u04d5\u04d6\7c\2\2\u04d6\u04d7\7k\2"+ - "\2\u04d7\u04d8\7n\2\2\u04d8\u04d9\7t\2\2\u04d9\u04da\7g\2\2\u04da\u04db"+ - "\7e\2\2\u04db\u00f1\3\2\2\2\u04dc\u04dd\7q\2\2\u04dd\u04de\7r\2\2\u04de"+ - "\u04df\7g\2\2\u04df\u04e0\7t\2\2\u04e0\u04e1\7c\2\2\u04e1\u04e2\7v\2\2"+ - "\u04e2\u04e3\7q\2\2\u04e3\u04e4\7t\2\2\u04e4\u00f3\3\2\2\2\u04e5\u04e6"+ - "\7k\2\2\u04e6\u04e7\7p\2\2\u04e7\u04e8\7n\2\2\u04e8\u04e9\7k\2\2\u04e9"+ - "\u04ea\7p\2\2\u04ea\u04eb\7g\2\2\u04eb\u00f5\3\2\2\2\u04ec\u04ed\7k\2"+ - "\2\u04ed\u04ee\7p\2\2\u04ee\u04ef\7h\2\2\u04ef\u04f0\7k\2\2\u04f0\u04f1"+ - "\7z\2\2\u04f1\u00f7\3\2\2\2\u04f2\u04f3\7g\2\2\u04f3\u04f4\7z\2\2\u04f4"+ - "\u04f5\7v\2\2\u04f5\u04f6\7g\2\2\u04f6\u04f7\7t\2\2\u04f7\u04f8\7p\2\2"+ - "\u04f8\u04f9\7c\2\2\u04f9\u04fa\7n\2\2\u04fa\u00f9\3\2\2\2\u04fb\u04fc"+ - "\7u\2\2\u04fc\u04fd\7w\2\2\u04fd\u04fe\7u\2\2\u04fe\u04ff\7r\2\2\u04ff"+ - "\u0500\7g\2\2\u0500\u0501\7p\2\2\u0501\u0502\7f\2\2\u0502\u00fb\3\2\2"+ - "\2\u0503\u0504\7q\2\2\u0504\u0505\7x\2\2\u0505\u0506\7g\2\2\u0506\u0507"+ - "\7t\2\2\u0507\u0508\7t\2\2\u0508\u0509\7k\2\2\u0509\u050a\7f\2\2\u050a"+ - "\u050b\7g\2\2\u050b\u00fd\3\2\2\2\u050c\u050d\7c\2\2\u050d\u050e\7d\2"+ - "\2\u050e\u050f\7u\2\2\u050f\u0510\7v\2\2\u0510\u0511\7t\2\2\u0511\u0512"+ - "\7c\2\2\u0512\u0513\7e\2\2\u0513\u0514\7v\2\2\u0514\u00ff\3\2\2\2\u0515"+ - "\u0516\7h\2\2\u0516\u0517\7k\2\2\u0517\u0518\7p\2\2\u0518\u0519\7c\2\2"+ - "\u0519\u051a\7n\2\2\u051a\u0101\3\2\2\2\u051b\u051c\7q\2\2\u051c\u051d"+ - "\7r\2\2\u051d\u051e\7g\2\2\u051e\u051f\7p\2\2\u051f\u0103\3\2\2\2\u0520"+ - "\u0521\7e\2\2\u0521\u0522\7q\2\2\u0522\u0523\7p\2\2\u0523\u0524\7u\2\2"+ - "\u0524\u0525\7v\2\2\u0525\u0105\3\2\2\2\u0526\u0527\7n\2\2\u0527\u0528"+ - "\7c\2\2\u0528\u0529\7v\2\2\u0529\u052a\7g\2\2\u052a\u052b\7k\2\2\u052b"+ - "\u052c\7p\2\2\u052c\u052d\7k\2\2\u052d\u052e\7v\2\2\u052e\u0107\3\2\2"+ - "\2\u052f\u0530\7x\2\2\u0530\u0531\7c\2\2\u0531\u0532\7t\2\2\u0532\u0533"+ - "\7c\2\2\u0533\u0534\7t\2\2\u0534\u0535\7i\2\2\u0535\u0109\3\2\2\2\u0536"+ - "\u0537\7p\2\2\u0537\u0538\7q\2\2\u0538\u0539\7k\2\2\u0539\u053a\7p\2\2"+ - "\u053a\u053b\7n\2\2\u053b\u053c\7k\2\2\u053c\u053d\7p\2\2\u053d\u053e"+ - "\7g\2\2\u053e\u010b\3\2\2\2\u053f\u0540\7e\2\2\u0540\u0541\7t\2\2\u0541"+ - "\u0542\7q\2\2\u0542\u0543\7u\2\2\u0543\u0544\7u\2\2\u0544\u0545\7k\2\2"+ - "\u0545\u0546\7p\2\2\u0546\u0547\7n\2\2\u0547\u0548\7k\2\2\u0548\u0549"+ - "\7p\2\2\u0549\u054a\7g\2\2\u054a\u010d\3\2\2\2\u054b\u054c\7t\2\2\u054c"+ - "\u054d\7g\2\2\u054d\u054e\7k\2\2\u054e\u054f\7h\2\2\u054f\u0550\7k\2\2"+ - "\u0550\u0551\7g\2\2\u0551\u0552\7f\2\2\u0552\u010f\3\2\2\2\u0553\u0554"+ - "\7g\2\2\u0554\u0555\7z\2\2\u0555\u0556\7r\2\2\u0556\u0557\7g\2\2\u0557"+ - "\u0558\7e\2\2\u0558\u0559\7v\2\2\u0559\u0111\3\2\2\2\u055a\u055b\7c\2"+ - "\2\u055b\u055c\7e\2\2\u055c\u055d\7v\2\2\u055d\u055e\7w\2\2\u055e\u055f"+ - "\7c\2\2\u055f\u0560\7n\2\2\u0560\u0113\3\2\2\2\u0561\u0562\4\62;\2\u0562"+ - "\u0115\3\2\2\2\u0563\u0564\4\63;\2\u0564\u0117\3\2\2\2\u0565\u0568\5\u0114"+ - "\u0089\2\u0566\u0568\7a\2\2\u0567\u0565\3\2\2\2\u0567\u0566\3\2\2\2\u0568"+ - "\u0119\3\2\2\2\u0569\u056d\5\u0114\u0089\2\u056a\u056c\5\u0118\u008b\2"+ - "\u056b\u056a\3\2\2\2\u056c\u056f\3\2\2\2\u056d\u056b\3\2\2\2\u056d\u056e"+ - "\3\2\2\2\u056e\u0570\3\2\2\2\u056f\u056d\3\2\2\2\u0570\u0571\5\u0114\u0089"+ - "\2\u0571\u0574\3\2\2\2\u0572\u0574\5\u0114\u0089\2\u0573\u0569\3\2\2\2"+ - "\u0573\u0572\3\2\2\2\u0574\u011b\3\2\2\2\u0575\u0577\t\4\2\2\u0576\u0578"+ - "\t\5\2\2\u0577\u0576\3\2\2\2\u0577\u0578\3\2\2\2\u0578\u0579\3\2\2\2\u0579"+ - "\u057a\5\u011a\u008c\2\u057a\u011d\3\2\2\2\u057b\u057e\5\u0120\u008f\2"+ - "\u057c\u057e\5\u0122\u0090\2\u057d\u057b\3\2\2\2\u057d\u057c\3\2\2\2\u057e"+ - "\u011f\3\2\2\2\u057f\u0580\5\u0122\u0090\2\u0580\u0581\t\6\2\2\u0581\u0586"+ - "\3\2\2\2\u0582\u0583\5\u011a\u008c\2\u0583\u0584\t\6\2\2\u0584\u0586\3"+ - "\2\2\2\u0585\u057f\3\2\2\2\u0585\u0582\3\2\2\2\u0586\u0121\3\2\2\2\u0587"+ - "\u0589\5\u011a\u008c\2\u0588\u0587\3\2\2\2\u0588\u0589\3\2\2\2\u0589\u058a"+ - "\3\2\2\2\u058a\u058b\7\60\2\2\u058b\u058d\5\u011a\u008c\2\u058c\u058e"+ - "\5\u011c\u008d\2\u058d\u058c\3\2\2\2\u058d\u058e\3\2\2\2\u058e\u0593\3"+ - "\2\2\2\u058f\u0590\5\u011a\u008c\2\u0590\u0591\5\u011c\u008d\2\u0591\u0593"+ - "\3\2\2\2\u0592\u0588\3\2\2\2\u0592\u058f\3\2\2\2\u0593\u0123\3\2\2\2\u0594"+ - "\u0598\5\u0116\u008a\2\u0595\u0597\5\u0118\u008b\2\u0596\u0595\3\2\2\2"+ - "\u0597\u059a\3\2\2\2\u0598\u0596\3\2\2\2\u0598\u0599\3\2\2\2\u0599\u059b"+ - "\3\2\2\2\u059a\u0598\3\2\2\2\u059b\u059c\5\u0114\u0089\2\u059c\u059f\3"+ - "\2\2\2\u059d\u059f\5\u0114\u0089\2\u059e\u0594\3\2\2\2\u059e\u059d\3\2"+ - "\2\2\u059f\u0125\3\2\2\2\u05a0\u05a1\t\7\2\2\u05a1\u0127\3\2\2\2\u05a2"+ - "\u05a5\5\u0126\u0092\2\u05a3\u05a5\7a\2\2\u05a4\u05a2\3\2\2\2\u05a4\u05a3"+ - "\3\2\2\2\u05a5\u0129\3\2\2\2\u05a6\u05a7\7\62\2\2\u05a7\u05a8\t\b\2\2"+ - "\u05a8\u05ac\5\u0126\u0092\2\u05a9\u05ab\5\u0128\u0093\2\u05aa\u05a9\3"+ - "\2\2\2\u05ab\u05ae\3\2\2\2\u05ac\u05aa\3\2\2\2\u05ac\u05ad\3\2\2\2\u05ad"+ - "\u05af\3\2\2\2\u05ae\u05ac\3\2\2\2\u05af\u05b0\5\u0126\u0092\2\u05b0\u05b5"+ - "\3\2\2\2\u05b1\u05b2\7\62\2\2\u05b2\u05b3\t\b\2\2\u05b3\u05b5\5\u0126"+ - "\u0092\2\u05b4\u05a6\3\2\2\2\u05b4\u05b1\3\2\2\2\u05b5\u012b\3\2\2\2\u05b6"+ - "\u05b7\t\t\2\2\u05b7\u012d\3\2\2\2\u05b8\u05bb\5\u012c\u0095\2\u05b9\u05bb"+ - "\7a\2\2\u05ba\u05b8\3\2\2\2\u05ba\u05b9\3\2\2\2\u05bb\u012f\3\2\2\2\u05bc"+ - "\u05bd\7\62\2\2\u05bd\u05be\t\n\2\2\u05be\u05c2\5\u012c\u0095\2\u05bf"+ - "\u05c1\5\u012e\u0096\2\u05c0\u05bf\3\2\2\2\u05c1\u05c4\3\2\2\2\u05c2\u05c0"+ - "\3\2\2\2\u05c2\u05c3\3\2\2\2\u05c3\u05c5\3\2\2\2\u05c4\u05c2\3\2\2\2\u05c5"+ - "\u05c6\5\u012c\u0095\2\u05c6\u05cb\3\2\2\2\u05c7\u05c8\7\62\2\2\u05c8"+ - "\u05c9\t\n\2\2\u05c9\u05cb\5\u012c\u0095\2\u05ca\u05bc\3\2\2\2\u05ca\u05c7"+ - "\3\2\2\2\u05cb\u0131\3\2\2\2\u05cc\u05d0\5\u0124\u0091\2\u05cd\u05d0\5"+ - "\u012a\u0094\2\u05ce\u05d0\5\u0130\u0097\2\u05cf\u05cc\3\2\2\2\u05cf\u05cd"+ - "\3\2\2\2\u05cf\u05ce\3\2\2\2\u05d0\u05d1\3\2\2\2\u05d1\u05d3\t\13\2\2"+ - "\u05d2\u05d4\t\f\2\2\u05d3\u05d2\3\2\2\2\u05d3\u05d4\3\2\2\2\u05d4\u0133"+ - "\3\2\2\2\u05d5\u05d9\5\u0124\u0091\2\u05d6\u05d9\5\u012a\u0094\2\u05d7"+ - "\u05d9\5\u0130\u0097\2\u05d8\u05d5\3\2\2\2\u05d8\u05d6\3\2\2\2\u05d8\u05d7"+ - "\3\2\2\2\u05d9\u05da\3\2\2\2\u05da\u05db\t\f\2\2\u05db\u0135\3\2\2\2\u05dc"+ - "\u05dd\7v\2\2\u05dd\u05de\7t\2\2\u05de\u05df\7w\2\2\u05df\u05e6\7g\2\2"+ - "\u05e0\u05e1\7h\2\2\u05e1\u05e2\7c\2\2\u05e2\u05e3\7n\2\2\u05e3\u05e4"+ - "\7u\2\2\u05e4\u05e6\7g\2\2\u05e5\u05dc\3\2\2\2\u05e5\u05e0\3\2\2\2\u05e6"+ - "\u0137\3\2\2\2\u05e7\u05e8\7p\2\2\u05e8\u05e9\7w\2\2\u05e9\u05ea\7n\2"+ - "\2\u05ea\u05eb\7n\2\2\u05eb\u0139\3\2\2\2\u05ec\u05ef\7)\2\2\u05ed\u05f0"+ - "\5\u0148\u00a3\2\u05ee\u05f0\n\r\2\2\u05ef\u05ed\3\2\2\2\u05ef\u05ee\3"+ - "\2\2\2\u05f0\u05f1\3\2\2\2\u05f1\u05f2\7)\2\2\u05f2\u013b\3\2\2\2\u05f3"+ - "\u05f4\5\u015a\u00ac\2\u05f4\u013d\3\2\2\2\u05f5\u05f8\5\u014a\u00a4\2"+ - "\u05f6\u05f8\7a\2\2\u05f7\u05f5\3\2\2\2\u05f7\u05f6\3\2\2\2\u05f8\u05fe"+ - "\3\2\2\2\u05f9\u05fd\5\u014a\u00a4\2\u05fa\u05fd\7a\2\2\u05fb\u05fd\5"+ - "\u013c\u009d\2\u05fc\u05f9\3\2\2\2\u05fc\u05fa\3\2\2\2\u05fc\u05fb\3\2"+ - "\2\2\u05fd\u0600\3\2\2\2\u05fe\u05fc\3\2\2\2\u05fe\u05ff\3\2\2\2\u05ff"+ - "\u0609\3\2\2\2\u0600\u05fe\3\2\2\2\u0601\u0603\7b\2\2\u0602\u0604\n\16"+ - "\2\2\u0603\u0602\3\2\2\2\u0604\u0605\3\2\2\2\u0605\u0603\3\2\2\2\u0605"+ - "\u0606\3\2\2\2\u0606\u0607\3\2\2\2\u0607\u0609\7b\2\2\u0608\u05f7\3\2"+ - "\2\2\u0608\u0601\3\2\2\2\u0609\u013f\3\2\2\2\u060a\u063b\5\u013e\u009e"+ - "\2\u060b\u063b\5\u00fe~\2\u060c\u063b\5\u00e8s\2\u060d\u063b\5\u00a6R"+ - "\2\u060e\u063b\5\u00bc]\2\u060f\u063b\5\u00a8S\2\u0610\u063b\5\u00a4Q"+ - "\2\u0611\u063b\5\u010c\u0085\2\u0612\u063b\5\u00eat\2\u0613\u063b\5\u00da"+ - "l\2\u0614\u063b\5\u00e4q\2\u0615\u063b\5\u00f8{\2\u0616\u063b\5\u0100"+ - "\177\2\u0617\u063b\5\u00be^\2\u0618\u063b\5\u0094I\2\u0619\u063b\5\u00f6"+ - "z\2\u061a\u063b\5\u00aaT\2\u061b\u063b\5\u00f4y\2\u061c\u063b\5\u00ec"+ - "u\2\u061d\u063b\5\u00e2p\2\u061e\u063b\5\u0106\u0082\2\u061f\u063b\5\u010a"+ - "\u0084\2\u0620\u063b\5\u0102\u0080\2\u0621\u063b\5\u00f2x\2\u0622\u063b"+ - "\5\u00d8k\2\u0623\u063b\5\u00fc}\2\u0624\u063b\5\u00den\2\u0625\u063b"+ - "\5\u00e0o\2\u0626\u063b\5\u00dcm\2\u0627\u063b\5\u010e\u0086\2\u0628\u063b"+ - "\5\u00e6r\2\u0629\u063b\5\u00f0w\2\u062a\u063b\5\u0108\u0083\2\u062b\u063b"+ - "\5\u00b2X\2\u062c\u063b\5\u0086B\2\u062d\u063b\5\u0088C\2\u062e\u063b"+ - "\5\u0082@\2\u062f\u063b\5\u0084A\2\u0630\u063b\5\u008aD\2\u0631\u063b"+ - "\5\u008cE\2\u0632\u063b\5\u008eF\2\u0633\u063b\5\u0090G\2\u0634\u063b"+ - "\5\u0080?\2\u0635\u063b\5\u0110\u0087\2\u0636\u063b\5\u0112\u0088\2\u0637"+ - "\u063b\5\u00eev\2\u0638\u063b\5\u0104\u0081\2\u0639\u063b\5\u00fa|\2\u063a"+ - "\u060a\3\2\2\2\u063a\u060b\3\2\2\2\u063a\u060c\3\2\2\2\u063a\u060d\3\2"+ - "\2\2\u063a\u060e\3\2\2\2\u063a\u060f\3\2\2\2\u063a\u0610\3\2\2\2\u063a"+ - "\u0611\3\2\2\2\u063a\u0612\3\2\2\2\u063a\u0613\3\2\2\2\u063a\u0614\3\2"+ - "\2\2\u063a\u0615\3\2\2\2\u063a\u0616\3\2\2\2\u063a\u0617\3\2\2\2\u063a"+ - "\u0618\3\2\2\2\u063a\u0619\3\2\2\2\u063a\u061a\3\2\2\2\u063a\u061b\3\2"+ - "\2\2\u063a\u061c\3\2\2\2\u063a\u061d\3\2\2\2\u063a\u061e\3\2\2\2\u063a"+ - "\u061f\3\2\2\2\u063a\u0620\3\2\2\2\u063a\u0621\3\2\2\2\u063a\u0622\3\2"+ - "\2\2\u063a\u0623\3\2\2\2\u063a\u0624\3\2\2\2\u063a\u0625\3\2\2\2\u063a"+ - "\u0626\3\2\2\2\u063a\u0627\3\2\2\2\u063a\u0628\3\2\2\2\u063a\u0629\3\2"+ - "\2\2\u063a\u062a\3\2\2\2\u063a\u062b\3\2\2\2\u063a\u062c\3\2\2\2\u063a"+ - "\u062d\3\2\2\2\u063a\u062e\3\2\2\2\u063a\u062f\3\2\2\2\u063a\u0630\3\2"+ - "\2\2\u063a\u0631\3\2\2\2\u063a\u0632\3\2\2\2\u063a\u0633\3\2\2\2\u063a"+ - "\u0634\3\2\2\2\u063a\u0635\3\2\2\2\u063a\u0636\3\2\2\2\u063a\u0637\3\2"+ - "\2\2\u063a\u0638\3\2\2\2\u063a\u0639\3\2\2\2\u063b\u0141\3\2\2\2\u063c"+ - "\u063d\7&\2\2\u063d\u063e\5\u0140\u009f\2\u063e\u0143\3\2\2\2\u063f\u0640"+ - "\7^\2\2\u0640\u0641\7w\2\2\u0641\u0642\5\u0126\u0092\2\u0642\u0643\5\u0126"+ - "\u0092\2\u0643\u0644\5\u0126\u0092\2\u0644\u0645\5\u0126\u0092\2\u0645"+ - "\u0145\3\2\2\2\u0646\u0647\7^\2\2\u0647\u0648\t\17\2\2\u0648\u0147\3\2"+ - "\2\2\u0649\u064c\5\u0144\u00a1\2\u064a\u064c\5\u0146\u00a2\2\u064b\u0649"+ - "\3\2\2\2\u064b\u064a\3\2\2\2\u064c\u0149\3\2\2\2\u064d\u0653\5\u0158\u00ab"+ - "\2\u064e\u0653\5\u0150\u00a7\2\u064f\u0653\5\u0156\u00aa\2\u0650\u0653"+ - "\5\u0152\u00a8\2\u0651\u0653\5\u0154\u00a9\2\u0652\u064d\3\2\2\2\u0652"+ - "\u064e\3\2\2\2\u0652\u064f\3\2\2\2\u0652\u0650\3\2\2\2\u0652\u0651\3\2"+ - "\2\2\u0653\u014b\3\2\2\2\u0654\u0655\7$\2\2\u0655\u0656\3\2\2\2\u0656"+ - "\u0657\b\u00a5\6\2\u0657\u014d\3\2\2\2\u0658\u0659\7$\2\2\u0659\u065a"+ - "\7$\2\2\u065a\u065b\7$\2\2\u065b\u065c\3\2\2\2\u065c\u065d\b\u00a6\7\2"+ - "\u065d\u014f\3\2\2\2\u065e\u065f\t\20\2\2\u065f\u0151\3\2\2\2\u0660\u0661"+ - "\t\21\2\2\u0661\u0153\3\2\2\2\u0662\u0663\t\22\2\2\u0663\u0155\3\2\2\2"+ - "\u0664\u0665\t\23\2\2\u0665\u0157\3\2\2\2\u0666\u0667\t\24\2\2\u0667\u0159"+ - "\3\2\2\2\u0668\u0669\t\25\2\2\u0669\u015b\3\2\2\2\u066a\u066b\t\26\2\2"+ - "\u066b\u015d\3\2\2\2\u066c\u066d\7$\2\2\u066d\u066e\3\2\2\2\u066e\u066f"+ - "\b\u00ae\b\2\u066f\u015f\3\2\2\2\u0670\u0671\5\u0142\u00a0\2\u0671\u0161"+ - "\3\2\2\2\u0672\u0674\n\27\2\2\u0673\u0672\3\2\2\2\u0674\u0675\3\2\2\2"+ - "\u0675\u0673\3\2\2\2\u0675\u0676\3\2\2\2\u0676\u0679\3\2\2\2\u0677\u0679"+ - "\7&\2\2\u0678\u0673\3\2\2\2\u0678\u0677\3\2\2\2\u0679\u0163\3\2\2\2\u067a"+ - "\u067d\5\u0146\u00a2\2\u067b\u067d\5\u0144\u00a1\2\u067c\u067a\3\2\2\2"+ - "\u067c\u067b\3\2\2\2\u067d\u0165\3\2\2\2\u067e\u067f\7&\2\2\u067f\u0680"+ - "\7}\2\2\u0680\u0681\3\2\2\2\u0681\u0682\b\u00b2\4\2\u0682\u0167\3\2\2"+ - "\2\u0683\u0685\5\u016a\u00b4\2\u0684\u0683\3\2\2\2\u0684\u0685\3\2\2\2"+ - "\u0685\u0686\3\2\2\2\u0686\u0687\7$\2\2\u0687\u0688\7$\2\2\u0688\u0689"+ - "\7$\2\2\u0689\u068a\3\2\2\2\u068a\u068b\b\u00b3\b\2\u068b\u0169\3\2\2"+ - "\2\u068c\u068e\7$\2\2\u068d\u068c\3\2\2\2\u068e\u068f\3\2\2\2\u068f\u068d"+ - "\3\2\2\2\u068f\u0690\3\2\2\2\u0690\u016b\3\2\2\2\u0691\u0692\5\u0142\u00a0"+ - "\2\u0692\u016d\3\2\2\2\u0693\u0695\n\30\2\2\u0694\u0693\3\2\2\2\u0695"+ - "\u0696\3\2\2\2\u0696\u0694\3\2\2\2\u0696\u0697\3\2\2\2\u0697\u069a\3\2"+ - "\2\2\u0698\u069a\7&\2\2\u0699\u0694\3\2\2\2\u0699\u0698\3\2\2\2\u069a"+ - "\u016f\3\2\2\2\u069b\u069c\7&\2\2\u069c\u069d\7}\2\2\u069d\u069e\3\2\2"+ - "\2\u069e\u069f\b\u00b7\4\2\u069f\u0171\3\2\2\2\u06a0\u06a1\5\32\f\2\u06a1"+ - "\u06a2\3\2\2\2\u06a2\u06a3\b\u00b8\b\2\u06a3\u06a4\b\u00b8\t\2\u06a4\u0173"+ - "\3\2\2\2\u06a5\u06a6\5\36\16\2\u06a6\u06a7\3\2\2\2\u06a7\u06a8\b\u00b9"+ - "\b\2\u06a8\u06a9\b\u00b9\n\2\u06a9\u0175\3\2\2\2\u06aa\u06ab\5\30\13\2"+ - "\u06ab\u06ac\3\2\2\2\u06ac\u06ad\b\u00ba\3\2\u06ad\u06ae\b\u00ba\13\2"+ - "\u06ae\u0177\3\2\2\2\u06af\u06b0\5\34\r\2\u06b0\u06b1\3\2\2\2\u06b1\u06b2"+ - "\b\u00bb\3\2\u06b2\u06b3\b\u00bb\f\2\u06b3\u0179\3\2\2\2\u06b4\u06b5\5"+ - " \17\2\u06b5\u06b6\3\2\2\2\u06b6\u06b7\b\u00bc\4\2\u06b7\u06b8\b\u00bc"+ - "\r\2\u06b8\u017b\3\2\2\2\u06b9\u06ba\5\"\20\2\u06ba\u06bb\3\2\2\2\u06bb"+ - "\u06bc\b\u00bd\b\2\u06bc\u06bd\b\u00bd\16\2\u06bd\u017d\3\2\2\2\u06be"+ - "\u06bf\5\24\t\2\u06bf\u06c0\3\2\2\2\u06c0\u06c1\b\u00be\17\2\u06c1\u017f"+ - "\3\2\2\2\u06c2\u06c3\5\26\n\2\u06c3\u06c4\3\2\2\2\u06c4\u06c5\b\u00bf"+ - "\20\2\u06c5\u0181\3\2\2\2\u06c6\u06c7\5$\21\2\u06c7\u06c8\3\2\2\2\u06c8"+ - "\u06c9\b\u00c0\21\2\u06c9\u0183\3\2\2\2\u06ca\u06cb\5&\22\2\u06cb\u06cc"+ - "\3\2\2\2\u06cc\u06cd\b\u00c1\22\2\u06cd\u0185\3\2\2\2\u06ce\u06cf\5(\23"+ - "\2\u06cf\u06d0\3\2\2\2\u06d0\u06d1\b\u00c2\23\2\u06d1\u0187\3\2\2\2\u06d2"+ - "\u06d3\5*\24\2\u06d3\u06d4\3\2\2\2\u06d4\u06d5\b\u00c3\24\2\u06d5\u0189"+ - "\3\2\2\2\u06d6\u06d7\5,\25\2\u06d7\u06d8\3\2\2\2\u06d8\u06d9\b\u00c4\25"+ - "\2\u06d9\u018b\3\2\2\2\u06da\u06db\5.\26\2\u06db\u06dc\3\2\2\2\u06dc\u06dd"+ - "\b\u00c5\26\2\u06dd\u018d\3\2\2\2\u06de\u06df\5\60\27\2\u06df\u06e0\3"+ - "\2\2\2\u06e0\u06e1\b\u00c6\27\2\u06e1\u018f\3\2\2\2\u06e2\u06e3\5\62\30"+ - "\2\u06e3\u06e4\3\2\2\2\u06e4\u06e5\b\u00c7\30\2\u06e5\u0191\3\2\2\2\u06e6"+ - "\u06e7\5\64\31\2\u06e7\u06e8\3\2\2\2\u06e8\u06e9\b\u00c8\31\2\u06e9\u0193"+ - "\3\2\2\2\u06ea\u06ed\7#\2\2\u06eb\u06ee\5\20\7\2\u06ec\u06ee\5\16\6\2"+ - "\u06ed\u06eb\3\2\2\2\u06ed\u06ec\3\2\2\2\u06ee\u06ef\3\2\2\2\u06ef\u06f0"+ - "\b\u00c9\32\2\u06f0\u0195\3\2\2\2\u06f1\u06f2\58\33\2\u06f2\u06f3\3\2"+ - "\2\2\u06f3\u06f4\b\u00ca\33\2\u06f4\u0197\3\2\2\2\u06f5\u06f6\5:\34\2"+ - "\u06f6\u06f7\3\2\2\2\u06f7\u06f8\b\u00cb\34\2\u06f8\u0199\3\2\2\2\u06f9"+ - "\u06fa\5<\35\2\u06fa\u06fb\3\2\2\2\u06fb\u06fc\b\u00cc\35\2\u06fc\u019b"+ - "\3\2\2\2\u06fd\u06fe\5>\36\2\u06fe\u06ff\3\2\2\2\u06ff\u0700\b\u00cd\36"+ - "\2\u0700\u019d\3\2\2\2\u0701\u0702\5@\37\2\u0702\u0703\3\2\2\2\u0703\u0704"+ - "\b\u00ce\37\2\u0704\u019f\3\2\2\2\u0705\u0706\5B \2\u0706\u0707\3\2\2"+ - "\2\u0707\u0708\b\u00cf \2\u0708\u01a1\3\2\2\2\u0709\u070a\5D!\2\u070a"+ - "\u070b\3\2\2\2\u070b\u070c\b\u00d0!\2\u070c\u01a3\3\2\2\2\u070d\u070e"+ - "\5F\"\2\u070e\u070f\3\2\2\2\u070f\u0710\b\u00d1\"\2\u0710\u01a5\3\2\2"+ - "\2\u0711\u0712\5H#\2\u0712\u0713\3\2\2\2\u0713\u0714\b\u00d2#\2\u0714"+ - "\u01a7\3\2\2\2\u0715\u0716\5J$\2\u0716\u0717\3\2\2\2\u0717\u0718\b\u00d3"+ - "$\2\u0718\u01a9\3\2\2\2\u0719\u071a\5L%\2\u071a\u071b\3\2\2\2\u071b\u071c"+ - "\b\u00d4%\2\u071c\u01ab\3\2\2\2\u071d\u071e\5N&\2\u071e\u071f\3\2\2\2"+ - "\u071f\u0720\b\u00d5&\2\u0720\u01ad\3\2\2\2\u0721\u0722\5\22\b\2\u0722"+ - "\u0723\3\2\2\2\u0723\u0724\b\u00d6\'\2\u0724\u01af\3\2\2\2\u0725\u0726"+ - "\5P\'\2\u0726\u0727\3\2\2\2\u0727\u0728\b\u00d7(\2\u0728\u01b1\3\2\2\2"+ - "\u0729\u072a\5R(\2\u072a\u072b\3\2\2\2\u072b\u072c\b\u00d8)\2\u072c\u01b3"+ - "\3\2\2\2\u072d\u072e\5T)\2\u072e\u072f\3\2\2\2\u072f\u0730\b\u00d9*\2"+ - "\u0730\u01b5\3\2\2\2\u0731\u0732\5V*\2\u0732\u0733\3\2\2\2\u0733\u0734"+ - "\b\u00da+\2\u0734\u01b7\3\2\2\2\u0735\u0736\5X+\2\u0736\u0737\3\2\2\2"+ - "\u0737\u0738\b\u00db,\2\u0738\u01b9\3\2\2\2\u0739\u073a\5Z,\2\u073a\u073b"+ - "\3\2\2\2\u073b\u073c\b\u00dc-\2\u073c\u01bb\3\2\2\2\u073d\u073e\5\\-\2"+ - "\u073e\u073f\3\2\2\2\u073f\u0740\b\u00dd.\2\u0740\u01bd\3\2\2\2\u0741"+ - "\u0744\7A\2\2\u0742\u0745\5\20\7\2\u0743\u0745\5\16\6\2\u0744\u0742\3"+ - "\2\2\2\u0744\u0743\3\2\2\2\u0745\u0746\3\2\2\2\u0746\u0747\b\u00de/\2"+ - "\u0747\u01bf\3\2\2\2\u0748\u0749\5`/\2\u0749\u074a\3\2\2\2\u074a\u074b"+ - "\b\u00df\60\2\u074b\u01c1\3\2\2\2\u074c\u074d\5b\60\2\u074d\u074e\3\2"+ - "\2\2\u074e\u074f\b\u00e0\61\2\u074f\u01c3\3\2\2\2\u0750\u0751\5d\61\2"+ - "\u0751\u0752\3\2\2\2\u0752\u0753\b\u00e1\62\2\u0753\u01c5\3\2\2\2\u0754"+ - "\u0755\5f\62\2\u0755\u0756\3\2\2\2\u0756\u0757\b\u00e2\63\2\u0757\u01c7"+ - "\3\2\2\2\u0758\u0759\5h\63\2\u0759\u075a\3\2\2\2\u075a\u075b\b\u00e3\64"+ - "\2\u075b\u01c9\3\2\2\2\u075c\u075d\5j\64\2\u075d\u075e\3\2\2\2\u075e\u075f"+ - "\b\u00e4\65\2\u075f\u01cb\3\2\2\2\u0760\u0761\5l\65\2\u0761\u0762\3\2"+ - "\2\2\u0762\u0763\b\u00e5\66\2\u0763\u01cd\3\2\2\2\u0764\u0765\5\u00d0"+ - "g\2\u0765\u0766\3\2\2\2\u0766\u0767\b\u00e6\67\2\u0767\u01cf\3\2\2\2\u0768"+ - "\u0769\5\u00d4i\2\u0769\u076a\3\2\2\2\u076a\u076b\b\u00e78\2\u076b\u01d1"+ - "\3\2\2\2\u076c\u076d\5\u00d6j\2\u076d\u076e\3\2\2\2\u076e\u076f\b\u00e8"+ - "9\2\u076f\u01d3\3\2\2\2\u0770\u0771\5\u00cef\2\u0771\u0772\3\2\2\2\u0772"+ - "\u0773\b\u00e9:\2\u0773\u01d5\3\2\2\2\u0774\u0775\5n\66\2\u0775\u0776"+ - "\3\2\2\2\u0776\u0777\b\u00ea;\2\u0777\u01d7\3\2\2\2\u0778\u0779\5p\67"+ - "\2\u0779\u077a\3\2\2\2\u077a\u077b\b\u00eb<\2\u077b\u01d9\3\2\2\2\u077c"+ - "\u077d\5r8\2\u077d\u077e\3\2\2\2\u077e\u077f\b\u00ec=\2\u077f\u01db\3"+ - "\2\2\2\u0780\u0781\5t9\2\u0781\u0782\3\2\2\2\u0782\u0783\b\u00ed>\2\u0783"+ - "\u01dd\3\2\2\2\u0784\u0785\5\u014c\u00a5\2\u0785\u0786\3\2\2\2\u0786\u0787"+ - "\b\u00ee\6\2\u0787\u0788\b\u00ee?\2\u0788\u01df\3\2\2\2\u0789\u078a\5"+ - "\u014e\u00a6\2\u078a\u078b\3\2\2\2\u078b\u078c\b\u00ef\7\2\u078c\u078d"+ - "\b\u00ef@\2\u078d\u01e1\3\2\2\2\u078e\u078f\5\u009eN\2\u078f\u0790\3\2"+ - "\2\2\u0790\u0791\b\u00f0A\2\u0791\u01e3\3\2\2\2\u0792\u0793\5\u00a0O\2"+ - "\u0793\u0794\3\2\2\2\u0794\u0795\b\u00f1B\2\u0795\u01e5\3\2\2\2\u0796"+ - "\u0797\5\u009aL\2\u0797\u0798\3\2\2\2\u0798\u0799\b\u00f2C\2\u0799\u01e7"+ - "\3\2\2\2\u079a\u079b\5\u009cM\2\u079b\u079c\3\2\2\2\u079c\u079d\b\u00f3"+ - "D\2\u079d\u01e9\3\2\2\2\u079e\u079f\5\u00aeV\2\u079f\u07a0\3\2\2\2\u07a0"+ - "\u07a1\b\u00f4E\2\u07a1\u01eb\3\2\2\2\u07a2\u07a3\5\u00d2h\2\u07a3\u07a4"+ - "\3\2\2\2\u07a4\u07a5\b\u00f5F\2\u07a5\u01ed\3\2\2\2\u07a6\u07a7\5\u00d8"+ - "k\2\u07a7\u07a8\3\2\2\2\u07a8\u07a9\b\u00f6G\2\u07a9\u01ef\3\2\2\2\u07aa"+ - "\u07ab\5\u0082@\2\u07ab\u07ac\3\2\2\2\u07ac\u07ad\b\u00f7H\2\u07ad\u01f1"+ - "\3\2\2\2\u07ae\u07af\5\u0080?\2\u07af\u07b0\3\2\2\2\u07b0\u07b1\b\u00f8"+ - "I\2\u07b1\u01f3\3\2\2\2\u07b2\u07b3\5\u0084A\2\u07b3\u07b4\3\2\2\2\u07b4"+ - "\u07b5\b\u00f9J\2\u07b5\u01f5\3\2\2\2\u07b6\u07b7\5\u0086B\2\u07b7\u07b8"+ - "\3\2\2\2\u07b8\u07b9\b\u00faK\2\u07b9\u01f7\3\2\2\2\u07ba\u07bb\5\u0088"+ - "C\2\u07bb\u07bc\3\2\2\2\u07bc\u07bd\b\u00fbL\2\u07bd\u01f9\3\2\2\2\u07be"+ - "\u07bf\5\u008aD\2\u07bf\u07c0\3\2\2\2\u07c0\u07c1\b\u00fcM\2\u07c1\u01fb"+ - "\3\2\2\2\u07c2\u07c3\5\u008cE\2\u07c3\u07c4\3\2\2\2\u07c4\u07c5\b\u00fd"+ - "N\2\u07c5\u01fd\3\2\2\2\u07c6\u07c7\5\u008eF\2\u07c7\u07c8\3\2\2\2\u07c8"+ - "\u07c9\b\u00feO\2\u07c9\u01ff\3\2\2\2\u07ca\u07cb\5\u0090G\2\u07cb\u07cc"+ - "\3\2\2\2\u07cc\u07cd\b\u00ffP\2\u07cd\u0201\3\2\2\2\u07ce\u07cf\5\u00c6"+ - "b\2\u07cf\u07d0\3\2\2\2\u07d0\u07d1\b\u0100Q\2\u07d1\u0203\3\2\2\2\u07d2"+ - "\u07d3\5\u00c8c\2\u07d3\u07d4\3\2\2\2\u07d4\u07d5\b\u0101R\2\u07d5\u0205"+ - "\3\2\2\2\u07d6\u07d7\5\u00cad\2\u07d7\u07d8\3\2\2\2\u07d8\u07d9\b\u0102"+ - "S\2\u07d9\u0207\3\2\2\2\u07da\u07db\5\u00cce\2\u07db\u07dc\3\2\2\2\u07dc"+ - "\u07dd\b\u0103T\2\u07dd\u0209\3\2\2\2\u07de\u07df\5v:\2\u07df\u07e0\3"+ - "\2\2\2\u07e0\u07e1\b\u0104U\2\u07e1\u020b\3\2\2\2\u07e2\u07e3\5x;\2\u07e3"+ - "\u07e4\3\2\2\2\u07e4\u07e5\b\u0105V\2\u07e5\u020d\3\2\2\2\u07e6\u07e7"+ - "\5z<\2\u07e7\u07e8\3\2\2\2\u07e8\u07e9\b\u0106W\2\u07e9\u020f\3\2\2\2"+ - "\u07ea\u07eb\5\u00b4Y\2\u07eb\u07ec\3\2\2\2\u07ec\u07ed\b\u0107X\2\u07ed"+ - "\u0211\3\2\2\2\u07ee\u07ef\5\u00b6Z\2\u07ef\u07f0\3\2\2\2\u07f0\u07f1"+ - "\b\u0108Y\2\u07f1\u0213\3\2\2\2\u07f2\u07f3\5\u00b8[\2\u07f3\u07f4\3\2"+ - "\2\2\u07f4\u07f5\b\u0109Z\2\u07f5\u0215\3\2\2\2\u07f6\u07f7\5\u00ba\\"+ - "\2\u07f7\u07f8\3\2\2\2\u07f8\u07f9\b\u010a[\2\u07f9\u0217\3\2\2\2\u07fa"+ - "\u07fb\5\u00bc]\2\u07fb\u07fc\3\2\2\2\u07fc\u07fd\b\u010b\\\2\u07fd\u0219"+ - "\3\2\2\2\u07fe\u07ff\5\u00be^\2\u07ff\u0800\3\2\2\2\u0800\u0801\b\u010c"+ - "]\2\u0801\u021b\3\2\2\2\u0802\u0803\5\u00c0_\2\u0803\u0804\3\2\2\2\u0804"+ - "\u0805\b\u010d^\2\u0805\u021d\3\2\2\2\u0806\u0807\5\u00c2`\2\u0807\u0808"+ - "\3\2\2\2\u0808\u0809\b\u010e_\2\u0809\u021f\3\2\2\2\u080a\u080b\5\u00c4"+ - "a\2\u080b\u080c\3\2\2\2\u080c\u080d\b\u010f`\2\u080d\u0221\3\2\2\2\u080e"+ - "\u080f\5\u00dcm\2\u080f\u0810\3\2\2\2\u0810\u0811\b\u0110a\2\u0811\u0223"+ - "\3\2\2\2\u0812\u0813\5\u00den\2\u0813\u0814\3\2\2\2\u0814\u0815\b\u0111"+ - "b\2\u0815\u0225\3\2\2\2\u0816\u0817\5\u00e0o\2\u0817\u0818\3\2\2\2\u0818"+ - "\u0819\b\u0112c\2\u0819\u0227\3\2\2\2\u081a\u081b\5\u00e2p\2\u081b\u081c"+ - "\3\2\2\2\u081c\u081d\b\u0113d\2\u081d\u0229\3\2\2\2\u081e\u081f\5\u00e4"+ - "q\2\u081f\u0820\3\2\2\2\u0820\u0821\b\u0114e\2\u0821\u022b\3\2\2\2\u0822"+ - "\u0823\5\u00e6r\2\u0823\u0824\3\2\2\2\u0824\u0825\b\u0115f\2\u0825\u022d"+ - "\3\2\2\2\u0826\u0827\5\u00e8s\2\u0827\u0828\3\2\2\2\u0828\u0829\b\u0116"+ - "g\2\u0829\u022f\3\2\2\2\u082a\u082b\5\u00eat\2\u082b\u082c\3\2\2\2\u082c"+ - "\u082d\b\u0117h\2\u082d\u0231\3\2\2\2\u082e\u082f\5\u00ecu\2\u082f\u0830"+ - "\3\2\2\2\u0830\u0831\b\u0118i\2\u0831\u0233\3\2\2\2\u0832\u0833\5\u00ee"+ - "v\2\u0833\u0834\3\2\2\2\u0834\u0835\b\u0119j\2\u0835\u0235\3\2\2\2\u0836"+ - "\u0837\5\u00f0w\2\u0837\u0838\3\2\2\2\u0838\u0839\b\u011ak\2\u0839\u0237"+ - "\3\2\2\2\u083a\u083b\5\u00f2x\2\u083b\u083c\3\2\2\2\u083c\u083d\b\u011b"+ - "l\2\u083d\u0239\3\2\2\2\u083e\u083f\5\u00f4y\2\u083f\u0840\3\2\2\2\u0840"+ - "\u0841\b\u011cm\2\u0841\u023b\3\2\2\2\u0842\u0843\5\u00f6z\2\u0843\u0844"+ - "\3\2\2\2\u0844\u0845\b\u011dn\2\u0845\u023d\3\2\2\2\u0846\u0847\5\u00f8"+ - "{\2\u0847\u0848\3\2\2\2\u0848\u0849\b\u011eo\2\u0849\u023f\3\2\2\2\u084a"+ - "\u084b\5\u00fa|\2\u084b\u084c\3\2\2\2\u084c\u084d\b\u011fp\2\u084d\u0241"+ - "\3\2\2\2\u084e\u084f\5\u00fc}\2\u084f\u0850\3\2\2\2\u0850\u0851\b\u0120"+ - "q\2\u0851\u0243\3\2\2\2\u0852\u0853\5\u00fe~\2\u0853\u0854\3\2\2\2\u0854"+ - "\u0855\b\u0121r\2\u0855\u0245\3\2\2\2\u0856\u0857\5\u0100\177\2\u0857"+ - "\u0858\3\2\2\2\u0858\u0859\b\u0122s\2\u0859\u0247\3\2\2\2\u085a\u085b"+ - "\5\u0102\u0080\2\u085b\u085c\3\2\2\2\u085c\u085d\b\u0123t\2\u085d\u0249"+ - "\3\2\2\2\u085e\u085f\5\u0104\u0081\2\u085f\u0860\3\2\2\2\u0860\u0861\b"+ - "\u0124u\2\u0861\u024b\3\2\2\2\u0862\u0863\5\u0106\u0082\2\u0863\u0864"+ - "\3\2\2\2\u0864\u0865\b\u0125v\2\u0865\u024d\3\2\2\2\u0866\u0867\5\u0108"+ - "\u0083\2\u0867\u0868\3\2\2\2\u0868\u0869\b\u0126w\2\u0869\u024f\3\2\2"+ - "\2\u086a\u086b\5\u010a\u0084\2\u086b\u086c\3\2\2\2\u086c\u086d\b\u0127"+ - "x\2"; - private static final String _serializedATNSegment1 = - "\u086d\u0251\3\2\2\2\u086e\u086f\5\u010c\u0085\2\u086f\u0870\3\2\2\2\u0870"+ - "\u0871\b\u0128y\2\u0871\u0253\3\2\2\2\u0872\u0873\5\u010e\u0086\2\u0873"+ - "\u0874\3\2\2\2\u0874\u0875\b\u0129z\2\u0875\u0255\3\2\2\2\u0876\u0877"+ - "\5\u0110\u0087\2\u0877\u0878\3\2\2\2\u0878\u0879\b\u012a{\2\u0879\u0257"+ - "\3\2\2\2\u087a\u087b\5\u0112\u0088\2\u087b\u087c\3\2\2\2\u087c\u087d\b"+ - "\u012b|\2\u087d\u0259\3\2\2\2\u087e\u087f\5\u0136\u009a\2\u087f\u0880"+ - "\3\2\2\2\u0880\u0881\b\u012c}\2\u0881\u025b\3\2\2\2\u0882\u0883\5\u0124"+ - "\u0091\2\u0883\u0884\3\2\2\2\u0884\u0885\b\u012d~\2\u0885\u025d\3\2\2"+ - "\2\u0886\u0887\5\u012a\u0094\2\u0887\u0888\3\2\2\2\u0888\u0889\b\u012e"+ - "\177\2\u0889\u025f\3\2\2\2\u088a\u088b\5\u0130\u0097\2\u088b\u088c\3\2"+ - "\2\2\u088c\u088d\b\u012f\u0080\2\u088d\u0261\3\2\2\2\u088e\u088f\5\u013a"+ - "\u009c\2\u088f\u0890\3\2\2\2\u0890\u0891\b\u0130\u0081\2\u0891\u0263\3"+ - "\2\2\2\u0892\u0893\5\u011e\u008e\2\u0893\u0894\3\2\2\2\u0894\u0895\b\u0131"+ - "\u0082\2\u0895\u0265\3\2\2\2\u0896\u0897\5\u0138\u009b\2\u0897\u0898\3"+ - "\2\2\2\u0898\u0899\b\u0132\u0083\2\u0899\u0267\3\2\2\2\u089a\u089b\5\u0134"+ - "\u0099\2\u089b\u089c\3\2\2\2\u089c\u089d\b\u0133\u0084\2\u089d\u0269\3"+ - "\2\2\2\u089e\u089f\5\u0132\u0098\2\u089f\u08a0\3\2\2\2\u08a0\u08a1\b\u0134"+ - "\u0085\2\u08a1\u026b\3\2\2\2\u08a2\u08a3\5\u013e\u009e\2\u08a3\u08a4\3"+ - "\2\2\2\u08a4\u08a5\b\u0135\u0086\2\u08a5\u026d\3\2\2\2\u08a6\u08a9\5\n"+ - "\4\2\u08a7\u08a9\5\b\3\2\u08a8\u08a6\3\2\2\2\u08a8\u08a7\3\2\2\2\u08a9"+ - "\u08aa\3\2\2\2\u08aa\u08ab\b\u0136\2\2\u08ab\u026f\3\2\2\2\u08ac\u08ad"+ - "\5\f\5\2\u08ad\u08ae\3\2\2\2\u08ae\u08af\b\u0137\2\2\u08af\u0271\3\2\2"+ - "\2\u08b0\u08b1\5\16\6\2\u08b1\u08b2\3\2\2\2\u08b2\u08b3\b\u0138\2\2\u08b3"+ - "\u0273\3\2\2\2\u08b4\u08b5\13\2\2\2\u08b5\u0275\3\2\2\2;\2\3\4\5\u027c"+ - "\u0284\u0286\u0294\u02a0\u02a2\u02a7\u030a\u030e\u0314\u0319\u0474\u047c"+ - "\u0567\u056d\u0573\u0577\u057d\u0585\u0588\u058d\u0592\u0598\u059e\u05a4"+ - "\u05ac\u05b4\u05ba\u05c2\u05ca\u05cf\u05d3\u05d8\u05e5\u05ef\u05f7\u05fc"+ - "\u05fe\u0605\u0608\u063a\u064b\u0652\u0675\u0678\u067c\u0684\u068f\u0696"+ - "\u0699\u06ed\u0744\u08a8\u0087\2\3\2\7\5\2\7\2\2\3\20\2\7\3\2\7\4\2\6"+ - "\2\2\t\f\2\t\16\2\t\13\2\t\r\2\t\17\2\t\20\2\t\t\2\t\n\2\t\21\2\t\22\2"+ - "\t\23\2\t\24\2\t\25\2\t\26\2\t\27\2\t\30\2\t\31\2\t\32\2\t\33\2\t\34\2"+ - "\t\35\2\t\36\2\t\37\2\t \2\t!\2\t\"\2\t#\2\t$\2\t%\2\t&\2\t\b\2\t\'\2"+ - "\t(\2\t)\2\t*\2\t+\2\t,\2\t-\2\t.\2\t/\2\t\60\2\t\61\2\t\62\2\t\63\2\t"+ - "\64\2\t\65\2\tg\2\ti\2\tj\2\tf\2\t\66\2\t\67\2\t8\2\t9\2\t\u0097\2\t\u0098"+ - "\2\tN\2\tO\2\tL\2\tM\2\tV\2\th\2\tk\2\t@\2\t?\2\tA\2\tB\2\tC\2\tD\2\t"+ - "E\2\tF\2\tG\2\tb\2\tc\2\td\2\te\2\t:\2\t;\2\t<\2\tY\2\tZ\2\t[\2\t\\\2"+ - "\t]\2\t^\2\t_\2\t`\2\ta\2\tm\2\tn\2\to\2\tp\2\tq\2\tr\2\ts\2\tt\2\tu\2"+ - "\tv\2\tw\2\tx\2\ty\2\tz\2\t{\2\t|\2\t}\2\t~\2\t\177\2\t\u0080\2\t\u0081"+ - "\2\t\u0082\2\t\u0083\2\t\u0084\2\t\u0085\2\t\u0086\2\t\u0087\2\t\u0088"+ - "\2\t\u0091\2\t\u008c\2\t\u008d\2\t\u008e\2\t\u0093\2\t\u0089\2\t\u0092"+ - "\2\t\u0090\2\t\u008f\2\t\u0094\2"; - public static final String _serializedATN = Utils.join( - new String[] { - _serializedATNSegment0, - _serializedATNSegment1 - }, - "" - ); - 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 + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } +} diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/kotlin/KotlinParser.java b/lexers/src/main/java/com/itsaky/androidide/lexers/kotlin/KotlinParser.java index 1c63aa378..a45e6299c 100644 --- a/lexers/src/main/java/com/itsaky/androidide/lexers/kotlin/KotlinParser.java +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/kotlin/KotlinParser.java @@ -1,19558 +1,25973 @@ -// Generated from KotlinParser.g4 by ANTLR 4.9.2 +// Generated from KotlinParser.g4 by ANTLR 4.9.3 package com.itsaky.androidide.lexers.kotlin; -import org.antlr.v4.runtime.atn.*; + +import org.antlr.v4.runtime.NoViableAltException; +import org.antlr.v4.runtime.Parser; +import org.antlr.v4.runtime.ParserRuleContext; +import org.antlr.v4.runtime.RecognitionException; +import org.antlr.v4.runtime.RuntimeMetaData; +import org.antlr.v4.runtime.Token; +import org.antlr.v4.runtime.TokenStream; +import org.antlr.v4.runtime.Vocabulary; +import org.antlr.v4.runtime.VocabularyImpl; +import org.antlr.v4.runtime.atn.ATN; +import org.antlr.v4.runtime.atn.ATNDeserializer; +import org.antlr.v4.runtime.atn.ParserATNSimulator; +import org.antlr.v4.runtime.atn.PredictionContextCache; 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 org.antlr.v4.runtime.misc.Utils; +import org.antlr.v4.runtime.tree.ParseTreeListener; +import org.antlr.v4.runtime.tree.ParseTreeVisitor; +import org.antlr.v4.runtime.tree.TerminalNode; + import java.util.List; -import java.util.Iterator; -import java.util.ArrayList; @SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) public class KotlinParser extends Parser { - static { RuntimeMetaData.checkVersion("4.9.2", RuntimeMetaData.VERSION); } - - protected static final DFA[] _decisionToDFA; - protected static final PredictionContextCache _sharedContextCache = - new PredictionContextCache(); - public static final int - ShebangLine=1, DelimitedComment=2, LineComment=3, WS=4, NL=5, RESERVED=6, - DOT=7, COMMA=8, LPAREN=9, RPAREN=10, LSQUARE=11, RSQUARE=12, LCURL=13, - RCURL=14, MULT=15, MOD=16, DIV=17, ADD=18, SUB=19, INCR=20, DECR=21, CONJ=22, - DISJ=23, EXCL_WS=24, EXCL_NO_WS=25, COLON=26, SEMICOLON=27, ASSIGNMENT=28, - ADD_ASSIGNMENT=29, SUB_ASSIGNMENT=30, MULT_ASSIGNMENT=31, DIV_ASSIGNMENT=32, - MOD_ASSIGNMENT=33, ARROW=34, DOUBLE_ARROW=35, RANGE=36, COLONCOLON=37, - DOUBLE_SEMICOLON=38, HASH=39, AT_NO_WS=40, AT_POST_WS=41, AT_PRE_WS=42, - AT_BOTH_WS=43, QUEST_WS=44, QUEST_NO_WS=45, LANGLE=46, RANGLE=47, LE=48, - GE=49, EXCL_EQ=50, EXCL_EQEQ=51, AS_SAFE=52, EQEQ=53, EQEQEQ=54, SINGLE_QUOTE=55, - RETURN_AT=56, CONTINUE_AT=57, BREAK_AT=58, THIS_AT=59, SUPER_AT=60, FILE=61, - FIELD=62, PROPERTY=63, GET=64, SET=65, RECEIVER=66, PARAM=67, SETPARAM=68, - DELEGATE=69, PACKAGE=70, IMPORT=71, CLASS=72, INTERFACE=73, FUN=74, OBJECT=75, - VAL=76, VAR=77, TYPE_ALIAS=78, CONSTRUCTOR=79, BY=80, COMPANION=81, INIT=82, - THIS=83, SUPER=84, TYPEOF=85, WHERE=86, IF=87, ELSE=88, WHEN=89, TRY=90, - CATCH=91, FINALLY=92, FOR=93, DO=94, WHILE=95, THROW=96, RETURN=97, CONTINUE=98, - BREAK=99, AS=100, IS=101, IN=102, NOT_IS=103, NOT_IN=104, OUT=105, DYNAMIC=106, - PUBLIC=107, PRIVATE=108, PROTECTED=109, INTERNAL=110, ENUM=111, SEALED=112, - ANNOTATION=113, DATA=114, INNER=115, VALUE=116, TAILREC=117, OPERATOR=118, - INLINE=119, INFIX=120, EXTERNAL=121, SUSPEND=122, OVERRIDE=123, ABSTRACT=124, - FINAL=125, OPEN=126, CONST=127, LATEINIT=128, VARARG=129, NOINLINE=130, - CROSSINLINE=131, REIFIED=132, EXPECT=133, ACTUAL=134, RealLiteral=135, - FloatLiteral=136, DoubleLiteral=137, IntegerLiteral=138, HexLiteral=139, - BinLiteral=140, UnsignedLiteral=141, LongLiteral=142, BooleanLiteral=143, - NullLiteral=144, CharacterLiteral=145, Identifier=146, IdentifierOrSoftKey=147, - FieldIdentifier=148, QUOTE_OPEN=149, TRIPLE_QUOTE_OPEN=150, UNICODE_CLASS_LL=151, - UNICODE_CLASS_LM=152, UNICODE_CLASS_LO=153, UNICODE_CLASS_LT=154, UNICODE_CLASS_LU=155, - UNICODE_CLASS_ND=156, UNICODE_CLASS_NL=157, QUOTE_CLOSE=158, LineStrRef=159, - LineStrText=160, LineStrEscapedChar=161, LineStrExprStart=162, TRIPLE_QUOTE_CLOSE=163, - MultiLineStringQuote=164, MultiLineStrRef=165, MultiLineStrText=166, MultiLineStrExprStart=167, - Inside_Comment=168, Inside_WS=169, Inside_NL=170, ErrorCharacter=171; - public static final int - RULE_kotlinFile = 0, RULE_script = 1, RULE_shebangLine = 2, RULE_fileAnnotation = 3, - RULE_packageHeader = 4, RULE_importList = 5, RULE_importHeader = 6, RULE_importAlias = 7, - RULE_topLevelObject = 8, RULE_typeAlias = 9, RULE_declaration = 10, RULE_classDeclaration = 11, - RULE_primaryConstructor = 12, RULE_classBody = 13, RULE_classParameters = 14, - RULE_classParameter = 15, RULE_delegationSpecifiers = 16, RULE_delegationSpecifier = 17, - RULE_constructorInvocation = 18, RULE_annotatedDelegationSpecifier = 19, - RULE_explicitDelegation = 20, RULE_typeParameters = 21, RULE_typeParameter = 22, - RULE_typeConstraints = 23, RULE_typeConstraint = 24, RULE_classMemberDeclarations = 25, - RULE_classMemberDeclaration = 26, RULE_anonymousInitializer = 27, RULE_companionObject = 28, - RULE_functionValueParameters = 29, RULE_functionValueParameter = 30, RULE_functionDeclaration = 31, - RULE_functionBody = 32, RULE_variableDeclaration = 33, RULE_multiVariableDeclaration = 34, - RULE_propertyDeclaration = 35, RULE_propertyDelegate = 36, RULE_getter = 37, - RULE_setter = 38, RULE_parametersWithOptionalType = 39, RULE_functionValueParameterWithOptionalType = 40, - RULE_parameterWithOptionalType = 41, RULE_parameter = 42, RULE_objectDeclaration = 43, - RULE_secondaryConstructor = 44, RULE_constructorDelegationCall = 45, RULE_enumClassBody = 46, - RULE_enumEntries = 47, RULE_enumEntry = 48, RULE_type = 49, RULE_typeReference = 50, - RULE_nullableType = 51, RULE_quest = 52, RULE_userType = 53, RULE_simpleUserType = 54, - RULE_typeProjection = 55, RULE_typeProjectionModifiers = 56, RULE_typeProjectionModifier = 57, - RULE_functionType = 58, RULE_functionTypeParameters = 59, RULE_parenthesizedType = 60, - RULE_receiverType = 61, RULE_parenthesizedUserType = 62, RULE_statements = 63, - RULE_statement = 64, RULE_label = 65, RULE_controlStructureBody = 66, - RULE_block = 67, RULE_loopStatement = 68, RULE_forStatement = 69, RULE_whileStatement = 70, - RULE_doWhileStatement = 71, RULE_assignment = 72, RULE_semi = 73, RULE_semis = 74, - RULE_expression = 75, RULE_disjunction = 76, RULE_conjunction = 77, RULE_equality = 78, - RULE_comparison = 79, RULE_genericCallLikeComparison = 80, RULE_infixOperation = 81, - RULE_elvisExpression = 82, RULE_elvis = 83, RULE_infixFunctionCall = 84, - RULE_rangeExpression = 85, RULE_additiveExpression = 86, RULE_multiplicativeExpression = 87, - RULE_asExpression = 88, RULE_prefixUnaryExpression = 89, RULE_unaryPrefix = 90, - RULE_postfixUnaryExpression = 91, RULE_postfixUnarySuffix = 92, RULE_directlyAssignableExpression = 93, - RULE_parenthesizedDirectlyAssignableExpression = 94, RULE_assignableExpression = 95, - RULE_parenthesizedAssignableExpression = 96, RULE_assignableSuffix = 97, - RULE_indexingSuffix = 98, RULE_navigationSuffix = 99, RULE_callSuffix = 100, - RULE_annotatedLambda = 101, RULE_typeArguments = 102, RULE_valueArguments = 103, - RULE_valueArgument = 104, RULE_primaryExpression = 105, RULE_parenthesizedExpression = 106, - RULE_collectionLiteral = 107, RULE_literalConstant = 108, RULE_stringLiteral = 109, - RULE_lineStringLiteral = 110, RULE_multiLineStringLiteral = 111, RULE_lineStringContent = 112, - RULE_lineStringExpression = 113, RULE_multiLineStringContent = 114, RULE_multiLineStringExpression = 115, - RULE_lambdaLiteral = 116, RULE_lambdaParameters = 117, RULE_lambdaParameter = 118, - RULE_anonymousFunction = 119, RULE_functionLiteral = 120, RULE_objectLiteral = 121, - RULE_thisExpression = 122, RULE_superExpression = 123, RULE_ifExpression = 124, - RULE_whenSubject = 125, RULE_whenExpression = 126, RULE_whenEntry = 127, - RULE_whenCondition = 128, RULE_rangeTest = 129, RULE_typeTest = 130, RULE_tryExpression = 131, - RULE_catchBlock = 132, RULE_finallyBlock = 133, RULE_jumpExpression = 134, - RULE_callableReference = 135, RULE_assignmentAndOperator = 136, RULE_equalityOperator = 137, - RULE_comparisonOperator = 138, RULE_inOperator = 139, RULE_isOperator = 140, - RULE_additiveOperator = 141, RULE_multiplicativeOperator = 142, RULE_asOperator = 143, - RULE_prefixUnaryOperator = 144, RULE_postfixUnaryOperator = 145, RULE_excl = 146, - RULE_memberAccessOperator = 147, RULE_safeNav = 148, RULE_modifiers = 149, - RULE_parameterModifiers = 150, RULE_modifier = 151, RULE_typeModifiers = 152, - RULE_typeModifier = 153, RULE_classModifier = 154, RULE_memberModifier = 155, - RULE_visibilityModifier = 156, RULE_varianceModifier = 157, RULE_typeParameterModifiers = 158, - RULE_typeParameterModifier = 159, RULE_functionModifier = 160, RULE_propertyModifier = 161, - RULE_inheritanceModifier = 162, RULE_parameterModifier = 163, RULE_reificationModifier = 164, - RULE_platformModifier = 165, RULE_annotation = 166, RULE_singleAnnotation = 167, - RULE_multiAnnotation = 168, RULE_annotationUseSiteTarget = 169, RULE_unescapedAnnotation = 170, - RULE_simpleIdentifier = 171, RULE_identifier = 172; - private static String[] makeRuleNames() { - return new String[] { - "kotlinFile", "script", "shebangLine", "fileAnnotation", "packageHeader", - "importList", "importHeader", "importAlias", "topLevelObject", "typeAlias", - "declaration", "classDeclaration", "primaryConstructor", "classBody", - "classParameters", "classParameter", "delegationSpecifiers", "delegationSpecifier", - "constructorInvocation", "annotatedDelegationSpecifier", "explicitDelegation", - "typeParameters", "typeParameter", "typeConstraints", "typeConstraint", - "classMemberDeclarations", "classMemberDeclaration", "anonymousInitializer", - "companionObject", "functionValueParameters", "functionValueParameter", - "functionDeclaration", "functionBody", "variableDeclaration", "multiVariableDeclaration", - "propertyDeclaration", "propertyDelegate", "getter", "setter", "parametersWithOptionalType", - "functionValueParameterWithOptionalType", "parameterWithOptionalType", - "parameter", "objectDeclaration", "secondaryConstructor", "constructorDelegationCall", - "enumClassBody", "enumEntries", "enumEntry", "type", "typeReference", - "nullableType", "quest", "userType", "simpleUserType", "typeProjection", - "typeProjectionModifiers", "typeProjectionModifier", "functionType", - "functionTypeParameters", "parenthesizedType", "receiverType", "parenthesizedUserType", - "statements", "statement", "label", "controlStructureBody", "block", - "loopStatement", "forStatement", "whileStatement", "doWhileStatement", - "assignment", "semi", "semis", "expression", "disjunction", "conjunction", - "equality", "comparison", "genericCallLikeComparison", "infixOperation", - "elvisExpression", "elvis", "infixFunctionCall", "rangeExpression", "additiveExpression", - "multiplicativeExpression", "asExpression", "prefixUnaryExpression", - "unaryPrefix", "postfixUnaryExpression", "postfixUnarySuffix", "directlyAssignableExpression", - "parenthesizedDirectlyAssignableExpression", "assignableExpression", - "parenthesizedAssignableExpression", "assignableSuffix", "indexingSuffix", - "navigationSuffix", "callSuffix", "annotatedLambda", "typeArguments", - "valueArguments", "valueArgument", "primaryExpression", "parenthesizedExpression", - "collectionLiteral", "literalConstant", "stringLiteral", "lineStringLiteral", - "multiLineStringLiteral", "lineStringContent", "lineStringExpression", - "multiLineStringContent", "multiLineStringExpression", "lambdaLiteral", - "lambdaParameters", "lambdaParameter", "anonymousFunction", "functionLiteral", - "objectLiteral", "thisExpression", "superExpression", "ifExpression", - "whenSubject", "whenExpression", "whenEntry", "whenCondition", "rangeTest", - "typeTest", "tryExpression", "catchBlock", "finallyBlock", "jumpExpression", - "callableReference", "assignmentAndOperator", "equalityOperator", "comparisonOperator", - "inOperator", "isOperator", "additiveOperator", "multiplicativeOperator", - "asOperator", "prefixUnaryOperator", "postfixUnaryOperator", "excl", - "memberAccessOperator", "safeNav", "modifiers", "parameterModifiers", - "modifier", "typeModifiers", "typeModifier", "classModifier", "memberModifier", - "visibilityModifier", "varianceModifier", "typeParameterModifiers", "typeParameterModifier", - "functionModifier", "propertyModifier", "inheritanceModifier", "parameterModifier", - "reificationModifier", "platformModifier", "annotation", "singleAnnotation", - "multiAnnotation", "annotationUseSiteTarget", "unescapedAnnotation", - "simpleIdentifier", "identifier" - }; - } - public static final String[] ruleNames = makeRuleNames(); - - private static String[] makeLiteralNames() { - return new String[] { - null, null, null, null, null, null, "'...'", "'.'", "','", "'('", "')'", - "'['", "']'", "'{'", "'}'", "'*'", "'%'", "'/'", "'+'", "'-'", "'++'", - "'--'", "'&&'", "'||'", null, "'!'", "':'", "';'", "'='", "'+='", "'-='", - "'*='", "'/='", "'%='", "'->'", "'=>'", "'..'", "'::'", "';;'", "'#'", - "'@'", null, null, null, null, "'?'", "'<'", "'>'", "'<='", "'>='", "'!='", - "'!=='", "'as?'", "'=='", "'==='", "'''", null, null, null, null, null, - "'file'", "'field'", "'property'", "'get'", "'set'", "'receiver'", "'param'", - "'setparam'", "'delegate'", "'package'", "'import'", "'class'", "'interface'", - "'fun'", "'object'", "'val'", "'var'", "'typealias'", "'constructor'", - "'by'", "'companion'", "'init'", "'this'", "'super'", "'typeof'", "'where'", - "'if'", "'else'", "'when'", "'try'", "'catch'", "'finally'", "'for'", - "'do'", "'while'", "'throw'", "'return'", "'continue'", "'break'", "'as'", - "'is'", "'in'", null, null, "'out'", "'dynamic'", "'public'", "'private'", - "'protected'", "'internal'", "'enum'", "'sealed'", "'annotation'", "'data'", - "'inner'", "'value'", "'tailrec'", "'operator'", "'inline'", "'infix'", - "'external'", "'suspend'", "'override'", "'abstract'", "'final'", "'open'", - "'const'", "'lateinit'", "'vararg'", "'noinline'", "'crossinline'", "'reified'", - "'expect'", "'actual'", null, null, null, null, null, null, null, null, - null, "'null'", null, null, null, null, null, "'\"\"\"'" - }; - } - private static final String[] _LITERAL_NAMES = makeLiteralNames(); - private static String[] makeSymbolicNames() { - return new String[] { - null, "ShebangLine", "DelimitedComment", "LineComment", "WS", "NL", "RESERVED", - "DOT", "COMMA", "LPAREN", "RPAREN", "LSQUARE", "RSQUARE", "LCURL", "RCURL", - "MULT", "MOD", "DIV", "ADD", "SUB", "INCR", "DECR", "CONJ", "DISJ", "EXCL_WS", - "EXCL_NO_WS", "COLON", "SEMICOLON", "ASSIGNMENT", "ADD_ASSIGNMENT", "SUB_ASSIGNMENT", - "MULT_ASSIGNMENT", "DIV_ASSIGNMENT", "MOD_ASSIGNMENT", "ARROW", "DOUBLE_ARROW", - "RANGE", "COLONCOLON", "DOUBLE_SEMICOLON", "HASH", "AT_NO_WS", "AT_POST_WS", - "AT_PRE_WS", "AT_BOTH_WS", "QUEST_WS", "QUEST_NO_WS", "LANGLE", "RANGLE", - "LE", "GE", "EXCL_EQ", "EXCL_EQEQ", "AS_SAFE", "EQEQ", "EQEQEQ", "SINGLE_QUOTE", - "RETURN_AT", "CONTINUE_AT", "BREAK_AT", "THIS_AT", "SUPER_AT", "FILE", - "FIELD", "PROPERTY", "GET", "SET", "RECEIVER", "PARAM", "SETPARAM", "DELEGATE", - "PACKAGE", "IMPORT", "CLASS", "INTERFACE", "FUN", "OBJECT", "VAL", "VAR", - "TYPE_ALIAS", "CONSTRUCTOR", "BY", "COMPANION", "INIT", "THIS", "SUPER", - "TYPEOF", "WHERE", "IF", "ELSE", "WHEN", "TRY", "CATCH", "FINALLY", "FOR", - "DO", "WHILE", "THROW", "RETURN", "CONTINUE", "BREAK", "AS", "IS", "IN", - "NOT_IS", "NOT_IN", "OUT", "DYNAMIC", "PUBLIC", "PRIVATE", "PROTECTED", - "INTERNAL", "ENUM", "SEALED", "ANNOTATION", "DATA", "INNER", "VALUE", - "TAILREC", "OPERATOR", "INLINE", "INFIX", "EXTERNAL", "SUSPEND", "OVERRIDE", - "ABSTRACT", "FINAL", "OPEN", "CONST", "LATEINIT", "VARARG", "NOINLINE", - "CROSSINLINE", "REIFIED", "EXPECT", "ACTUAL", "RealLiteral", "FloatLiteral", - "DoubleLiteral", "IntegerLiteral", "HexLiteral", "BinLiteral", "UnsignedLiteral", - "LongLiteral", "BooleanLiteral", "NullLiteral", "CharacterLiteral", "Identifier", - "IdentifierOrSoftKey", "FieldIdentifier", "QUOTE_OPEN", "TRIPLE_QUOTE_OPEN", - "UNICODE_CLASS_LL", "UNICODE_CLASS_LM", "UNICODE_CLASS_LO", "UNICODE_CLASS_LT", - "UNICODE_CLASS_LU", "UNICODE_CLASS_ND", "UNICODE_CLASS_NL", "QUOTE_CLOSE", - "LineStrRef", "LineStrText", "LineStrEscapedChar", "LineStrExprStart", - "TRIPLE_QUOTE_CLOSE", "MultiLineStringQuote", "MultiLineStrRef", "MultiLineStrText", - "MultiLineStrExprStart", "Inside_Comment", "Inside_WS", "Inside_NL", - "ErrorCharacter" - }; - } - 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 "KotlinParser.g4"; } - - @Override - public String[] getRuleNames() { return ruleNames; } - - @Override - public String getSerializedATN() { return _serializedATN; } - - @Override - public ATN getATN() { return _ATN; } - - public KotlinParser(TokenStream input) { - super(input); - _interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); - } - - public static class KotlinFileContext extends ParserRuleContext { - public PackageHeaderContext packageHeader() { - return getRuleContext(PackageHeaderContext.class,0); - } - public ImportListContext importList() { - return getRuleContext(ImportListContext.class,0); - } - public TerminalNode EOF() { return getToken(KotlinParser.EOF, 0); } - public ShebangLineContext shebangLine() { - return getRuleContext(ShebangLineContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public List fileAnnotation() { - return getRuleContexts(FileAnnotationContext.class); - } - public FileAnnotationContext fileAnnotation(int i) { - return getRuleContext(FileAnnotationContext.class,i); - } - public List topLevelObject() { - return getRuleContexts(TopLevelObjectContext.class); - } - public TopLevelObjectContext topLevelObject(int i) { - return getRuleContext(TopLevelObjectContext.class,i); - } - public KotlinFileContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_kotlinFile; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterKotlinFile(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitKotlinFile(this); - } - } - - public final KotlinFileContext kotlinFile() throws RecognitionException { - KotlinFileContext _localctx = new KotlinFileContext(_ctx, getState()); - enterRule(_localctx, 0, RULE_kotlinFile); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(347); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ShebangLine) { - { - setState(346); - shebangLine(); - } - } - - setState(352); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(349); - match(NL); - } - } - setState(354); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(358); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,2,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(355); - fileAnnotation(); - } - } - } - setState(360); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,2,_ctx); - } - setState(361); - packageHeader(); - setState(362); - importList(); - setState(366); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==AT_NO_WS || _la==AT_PRE_WS || ((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & ((1L << (CLASS - 72)) | (1L << (INTERFACE - 72)) | (1L << (FUN - 72)) | (1L << (OBJECT - 72)) | (1L << (VAL - 72)) | (1L << (VAR - 72)) | (1L << (TYPE_ALIAS - 72)) | (1L << (PUBLIC - 72)) | (1L << (PRIVATE - 72)) | (1L << (PROTECTED - 72)) | (1L << (INTERNAL - 72)) | (1L << (ENUM - 72)) | (1L << (SEALED - 72)) | (1L << (ANNOTATION - 72)) | (1L << (DATA - 72)) | (1L << (INNER - 72)) | (1L << (VALUE - 72)) | (1L << (TAILREC - 72)) | (1L << (OPERATOR - 72)) | (1L << (INLINE - 72)) | (1L << (INFIX - 72)) | (1L << (EXTERNAL - 72)) | (1L << (SUSPEND - 72)) | (1L << (OVERRIDE - 72)) | (1L << (ABSTRACT - 72)) | (1L << (FINAL - 72)) | (1L << (OPEN - 72)) | (1L << (CONST - 72)) | (1L << (LATEINIT - 72)) | (1L << (VARARG - 72)) | (1L << (NOINLINE - 72)) | (1L << (CROSSINLINE - 72)) | (1L << (EXPECT - 72)) | (1L << (ACTUAL - 72)))) != 0)) { - { - { - setState(363); - topLevelObject(); - } - } - setState(368); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(369); - match(EOF); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ScriptContext extends ParserRuleContext { - public PackageHeaderContext packageHeader() { - return getRuleContext(PackageHeaderContext.class,0); - } - public ImportListContext importList() { - return getRuleContext(ImportListContext.class,0); - } - public TerminalNode EOF() { return getToken(KotlinParser.EOF, 0); } - public ShebangLineContext shebangLine() { - return getRuleContext(ShebangLineContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public List fileAnnotation() { - return getRuleContexts(FileAnnotationContext.class); - } - public FileAnnotationContext fileAnnotation(int i) { - return getRuleContext(FileAnnotationContext.class,i); - } - public List statement() { - return getRuleContexts(StatementContext.class); - } - public StatementContext statement(int i) { - return getRuleContext(StatementContext.class,i); - } - public List semi() { - return getRuleContexts(SemiContext.class); - } - public SemiContext semi(int i) { - return getRuleContext(SemiContext.class,i); - } - public ScriptContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_script; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterScript(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitScript(this); - } - } - - public final ScriptContext script() throws RecognitionException { - ScriptContext _localctx = new ScriptContext(_ctx, getState()); - enterRule(_localctx, 2, RULE_script); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(372); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==ShebangLine) { - { - setState(371); - shebangLine(); - } - } - - setState(377); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(374); - match(NL); - } - } - setState(379); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(383); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,6,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(380); - fileAnnotation(); - } - } - } - setState(385); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,6,_ctx); - } - setState(386); - packageHeader(); - setState(387); - importList(); - setState(393); - _errHandler.sync(this); - _la = _input.LA(1); - while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LPAREN) | (1L << LSQUARE) | (1L << LCURL) | (1L << ADD) | (1L << SUB) | (1L << INCR) | (1L << DECR) | (1L << EXCL_WS) | (1L << EXCL_NO_WS) | (1L << COLONCOLON) | (1L << AT_NO_WS) | (1L << AT_PRE_WS) | (1L << RETURN_AT) | (1L << CONTINUE_AT) | (1L << BREAK_AT) | (1L << THIS_AT) | (1L << SUPER_AT) | (1L << FILE) | (1L << FIELD) | (1L << PROPERTY))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (GET - 64)) | (1L << (SET - 64)) | (1L << (RECEIVER - 64)) | (1L << (PARAM - 64)) | (1L << (SETPARAM - 64)) | (1L << (DELEGATE - 64)) | (1L << (IMPORT - 64)) | (1L << (CLASS - 64)) | (1L << (INTERFACE - 64)) | (1L << (FUN - 64)) | (1L << (OBJECT - 64)) | (1L << (VAL - 64)) | (1L << (VAR - 64)) | (1L << (TYPE_ALIAS - 64)) | (1L << (CONSTRUCTOR - 64)) | (1L << (BY - 64)) | (1L << (COMPANION - 64)) | (1L << (INIT - 64)) | (1L << (THIS - 64)) | (1L << (SUPER - 64)) | (1L << (WHERE - 64)) | (1L << (IF - 64)) | (1L << (WHEN - 64)) | (1L << (TRY - 64)) | (1L << (CATCH - 64)) | (1L << (FINALLY - 64)) | (1L << (FOR - 64)) | (1L << (DO - 64)) | (1L << (WHILE - 64)) | (1L << (THROW - 64)) | (1L << (RETURN - 64)) | (1L << (CONTINUE - 64)) | (1L << (BREAK - 64)) | (1L << (OUT - 64)) | (1L << (DYNAMIC - 64)) | (1L << (PUBLIC - 64)) | (1L << (PRIVATE - 64)) | (1L << (PROTECTED - 64)) | (1L << (INTERNAL - 64)) | (1L << (ENUM - 64)) | (1L << (SEALED - 64)) | (1L << (ANNOTATION - 64)) | (1L << (DATA - 64)) | (1L << (INNER - 64)) | (1L << (VALUE - 64)) | (1L << (TAILREC - 64)) | (1L << (OPERATOR - 64)) | (1L << (INLINE - 64)) | (1L << (INFIX - 64)) | (1L << (EXTERNAL - 64)) | (1L << (SUSPEND - 64)) | (1L << (OVERRIDE - 64)) | (1L << (ABSTRACT - 64)) | (1L << (FINAL - 64)) | (1L << (OPEN - 64)) | (1L << (CONST - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (LATEINIT - 128)) | (1L << (VARARG - 128)) | (1L << (NOINLINE - 128)) | (1L << (CROSSINLINE - 128)) | (1L << (REIFIED - 128)) | (1L << (EXPECT - 128)) | (1L << (ACTUAL - 128)) | (1L << (RealLiteral - 128)) | (1L << (IntegerLiteral - 128)) | (1L << (HexLiteral - 128)) | (1L << (BinLiteral - 128)) | (1L << (UnsignedLiteral - 128)) | (1L << (LongLiteral - 128)) | (1L << (BooleanLiteral - 128)) | (1L << (NullLiteral - 128)) | (1L << (CharacterLiteral - 128)) | (1L << (Identifier - 128)) | (1L << (QUOTE_OPEN - 128)) | (1L << (TRIPLE_QUOTE_OPEN - 128)))) != 0)) { - { - { - setState(388); - statement(); - setState(389); - semi(); - } - } - setState(395); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(396); - match(EOF); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ShebangLineContext extends ParserRuleContext { - public TerminalNode ShebangLine() { return getToken(KotlinParser.ShebangLine, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public ShebangLineContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_shebangLine; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterShebangLine(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitShebangLine(this); - } - } - - public final ShebangLineContext shebangLine() throws RecognitionException { - ShebangLineContext _localctx = new ShebangLineContext(_ctx, getState()); - enterRule(_localctx, 4, RULE_shebangLine); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(398); - match(ShebangLine); - setState(400); - _errHandler.sync(this); - _alt = 1; - do { - switch (_alt) { - case 1: - { - { - setState(399); - match(NL); - } - } - break; - default: - throw new NoViableAltException(this); - } - setState(402); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,8,_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 FileAnnotationContext extends ParserRuleContext { - public TerminalNode FILE() { return getToken(KotlinParser.FILE, 0); } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public TerminalNode AT_NO_WS() { return getToken(KotlinParser.AT_NO_WS, 0); } - public TerminalNode AT_PRE_WS() { return getToken(KotlinParser.AT_PRE_WS, 0); } - public TerminalNode LSQUARE() { return getToken(KotlinParser.LSQUARE, 0); } - public TerminalNode RSQUARE() { return getToken(KotlinParser.RSQUARE, 0); } - public List unescapedAnnotation() { - return getRuleContexts(UnescapedAnnotationContext.class); - } - public UnescapedAnnotationContext unescapedAnnotation(int i) { - return getRuleContext(UnescapedAnnotationContext.class,i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public FileAnnotationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_fileAnnotation; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterFileAnnotation(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitFileAnnotation(this); - } - } - - public final FileAnnotationContext fileAnnotation() throws RecognitionException { - FileAnnotationContext _localctx = new FileAnnotationContext(_ctx, getState()); - enterRule(_localctx, 6, RULE_fileAnnotation); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(404); - _la = _input.LA(1); - if ( !(_la==AT_NO_WS || _la==AT_PRE_WS) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(405); - match(FILE); - setState(409); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(406); - match(NL); - } - } - setState(411); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(412); - match(COLON); - setState(416); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(413); - match(NL); - } - } - setState(418); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(428); - _errHandler.sync(this); - switch (_input.LA(1)) { - case LSQUARE: - { - setState(419); - match(LSQUARE); - setState(421); - _errHandler.sync(this); - _la = _input.LA(1); - do { - { - { - setState(420); - unescapedAnnotation(); - } - } - setState(423); - _errHandler.sync(this); - _la = _input.LA(1); - } while ( ((((_la - 61)) & ~0x3f) == 0 && ((1L << (_la - 61)) & ((1L << (FILE - 61)) | (1L << (FIELD - 61)) | (1L << (PROPERTY - 61)) | (1L << (GET - 61)) | (1L << (SET - 61)) | (1L << (RECEIVER - 61)) | (1L << (PARAM - 61)) | (1L << (SETPARAM - 61)) | (1L << (DELEGATE - 61)) | (1L << (IMPORT - 61)) | (1L << (CONSTRUCTOR - 61)) | (1L << (BY - 61)) | (1L << (COMPANION - 61)) | (1L << (INIT - 61)) | (1L << (WHERE - 61)) | (1L << (CATCH - 61)) | (1L << (FINALLY - 61)) | (1L << (OUT - 61)) | (1L << (DYNAMIC - 61)) | (1L << (PUBLIC - 61)) | (1L << (PRIVATE - 61)) | (1L << (PROTECTED - 61)) | (1L << (INTERNAL - 61)) | (1L << (ENUM - 61)) | (1L << (SEALED - 61)) | (1L << (ANNOTATION - 61)) | (1L << (DATA - 61)) | (1L << (INNER - 61)) | (1L << (VALUE - 61)) | (1L << (TAILREC - 61)) | (1L << (OPERATOR - 61)) | (1L << (INLINE - 61)) | (1L << (INFIX - 61)) | (1L << (EXTERNAL - 61)) | (1L << (SUSPEND - 61)) | (1L << (OVERRIDE - 61)) | (1L << (ABSTRACT - 61)))) != 0) || ((((_la - 125)) & ~0x3f) == 0 && ((1L << (_la - 125)) & ((1L << (FINAL - 125)) | (1L << (OPEN - 125)) | (1L << (CONST - 125)) | (1L << (LATEINIT - 125)) | (1L << (VARARG - 125)) | (1L << (NOINLINE - 125)) | (1L << (CROSSINLINE - 125)) | (1L << (REIFIED - 125)) | (1L << (EXPECT - 125)) | (1L << (ACTUAL - 125)) | (1L << (Identifier - 125)))) != 0) ); - setState(425); - match(RSQUARE); - } - break; - case FILE: - case FIELD: - case PROPERTY: - case GET: - case SET: - case RECEIVER: - case PARAM: - case SETPARAM: - case DELEGATE: - case IMPORT: - case CONSTRUCTOR: - case BY: - case COMPANION: - case INIT: - case WHERE: - case CATCH: - case FINALLY: - case OUT: - case DYNAMIC: - case PUBLIC: - case PRIVATE: - case PROTECTED: - case INTERNAL: - case ENUM: - case SEALED: - case ANNOTATION: - case DATA: - case INNER: - case VALUE: - case TAILREC: - case OPERATOR: - case INLINE: - case INFIX: - case EXTERNAL: - case SUSPEND: - case OVERRIDE: - case ABSTRACT: - case FINAL: - case OPEN: - case CONST: - case LATEINIT: - case VARARG: - case NOINLINE: - case CROSSINLINE: - case REIFIED: - case EXPECT: - case ACTUAL: - case Identifier: - { - setState(427); - unescapedAnnotation(); - } - break; - default: - throw new NoViableAltException(this); - } - setState(433); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(430); - match(NL); - } - } - setState(435); - _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 PackageHeaderContext extends ParserRuleContext { - public TerminalNode PACKAGE() { return getToken(KotlinParser.PACKAGE, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public SemiContext semi() { - return getRuleContext(SemiContext.class,0); - } - public PackageHeaderContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_packageHeader; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterPackageHeader(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitPackageHeader(this); - } - } - - public final PackageHeaderContext packageHeader() throws RecognitionException { - PackageHeaderContext _localctx = new PackageHeaderContext(_ctx, getState()); - enterRule(_localctx, 8, RULE_packageHeader); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(441); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==PACKAGE) { - { - setState(436); - match(PACKAGE); - setState(437); - identifier(); - setState(439); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) { - case 1: - { - setState(438); - semi(); - } - break; - } - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ImportListContext extends ParserRuleContext { - public List importHeader() { - return getRuleContexts(ImportHeaderContext.class); - } - public ImportHeaderContext importHeader(int i) { - return getRuleContext(ImportHeaderContext.class,i); - } - public ImportListContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_importList; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterImportList(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitImportList(this); - } - } - - public final ImportListContext importList() throws RecognitionException { - ImportListContext _localctx = new ImportListContext(_ctx, getState()); - enterRule(_localctx, 10, RULE_importList); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(446); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,16,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(443); - importHeader(); - } - } - } - setState(448); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,16,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ImportHeaderContext extends ParserRuleContext { - public TerminalNode IMPORT() { return getToken(KotlinParser.IMPORT, 0); } - public IdentifierContext identifier() { - return getRuleContext(IdentifierContext.class,0); - } - public TerminalNode DOT() { return getToken(KotlinParser.DOT, 0); } - public TerminalNode MULT() { return getToken(KotlinParser.MULT, 0); } - public ImportAliasContext importAlias() { - return getRuleContext(ImportAliasContext.class,0); - } - public SemiContext semi() { - return getRuleContext(SemiContext.class,0); - } - public ImportHeaderContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_importHeader; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterImportHeader(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitImportHeader(this); - } - } - - public final ImportHeaderContext importHeader() throws RecognitionException { - ImportHeaderContext _localctx = new ImportHeaderContext(_ctx, getState()); - enterRule(_localctx, 12, RULE_importHeader); - try { - enterOuterAlt(_localctx, 1); - { - setState(449); - match(IMPORT); - setState(450); - identifier(); - setState(454); - _errHandler.sync(this); - switch (_input.LA(1)) { - case DOT: - { - setState(451); - match(DOT); - setState(452); - match(MULT); - } - break; - case AS: - { - setState(453); - importAlias(); - } - break; - case EOF: - case NL: - case LPAREN: - case LSQUARE: - case LCURL: - case ADD: - case SUB: - case INCR: - case DECR: - case EXCL_WS: - case EXCL_NO_WS: - case SEMICOLON: - case COLONCOLON: - case AT_NO_WS: - case AT_PRE_WS: - case RETURN_AT: - case CONTINUE_AT: - case BREAK_AT: - case THIS_AT: - case SUPER_AT: - case FILE: - case FIELD: - case PROPERTY: - case GET: - case SET: - case RECEIVER: - case PARAM: - case SETPARAM: - case DELEGATE: - case IMPORT: - case CLASS: - case INTERFACE: - case FUN: - case OBJECT: - case VAL: - case VAR: - case TYPE_ALIAS: - case CONSTRUCTOR: - case BY: - case COMPANION: - case INIT: - case THIS: - case SUPER: - case WHERE: - case IF: - case WHEN: - case TRY: - case CATCH: - case FINALLY: - case FOR: - case DO: - case WHILE: - case THROW: - case RETURN: - case CONTINUE: - case BREAK: - case OUT: - case DYNAMIC: - case PUBLIC: - case PRIVATE: - case PROTECTED: - case INTERNAL: - case ENUM: - case SEALED: - case ANNOTATION: - case DATA: - case INNER: - case VALUE: - case TAILREC: - case OPERATOR: - case INLINE: - case INFIX: - case EXTERNAL: - case SUSPEND: - case OVERRIDE: - case ABSTRACT: - case FINAL: - case OPEN: - case CONST: - case LATEINIT: - case VARARG: - case NOINLINE: - case CROSSINLINE: - case REIFIED: - case EXPECT: - case ACTUAL: - case RealLiteral: - case IntegerLiteral: - case HexLiteral: - case BinLiteral: - case UnsignedLiteral: - case LongLiteral: - case BooleanLiteral: - case NullLiteral: - case CharacterLiteral: - case Identifier: - case QUOTE_OPEN: - case TRIPLE_QUOTE_OPEN: - break; - default: - break; - } - setState(457); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) { - case 1: - { - setState(456); - semi(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ImportAliasContext extends ParserRuleContext { - public TerminalNode AS() { return getToken(KotlinParser.AS, 0); } - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public ImportAliasContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_importAlias; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterImportAlias(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitImportAlias(this); - } - } - - public final ImportAliasContext importAlias() throws RecognitionException { - ImportAliasContext _localctx = new ImportAliasContext(_ctx, getState()); - enterRule(_localctx, 14, RULE_importAlias); - try { - enterOuterAlt(_localctx, 1); - { - setState(459); - match(AS); - setState(460); - simpleIdentifier(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TopLevelObjectContext extends ParserRuleContext { - public DeclarationContext declaration() { - return getRuleContext(DeclarationContext.class,0); - } - public SemisContext semis() { - return getRuleContext(SemisContext.class,0); - } - public TopLevelObjectContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_topLevelObject; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterTopLevelObject(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitTopLevelObject(this); - } - } - - public final TopLevelObjectContext topLevelObject() throws RecognitionException { - TopLevelObjectContext _localctx = new TopLevelObjectContext(_ctx, getState()); - enterRule(_localctx, 16, RULE_topLevelObject); - try { - enterOuterAlt(_localctx, 1); - { - setState(462); - declaration(); - setState(464); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) { - case 1: - { - setState(463); - semis(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TypeAliasContext extends ParserRuleContext { - public TerminalNode TYPE_ALIAS() { return getToken(KotlinParser.TYPE_ALIAS, 0); } - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public TerminalNode ASSIGNMENT() { return getToken(KotlinParser.ASSIGNMENT, 0); } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public ModifiersContext modifiers() { - return getRuleContext(ModifiersContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TypeParametersContext typeParameters() { - return getRuleContext(TypeParametersContext.class,0); - } - public TypeAliasContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeAlias; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterTypeAlias(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitTypeAlias(this); - } - } - - public final TypeAliasContext typeAlias() throws RecognitionException { - TypeAliasContext _localctx = new TypeAliasContext(_ctx, getState()); - enterRule(_localctx, 18, RULE_typeAlias); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(467); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==AT_NO_WS || _la==AT_PRE_WS || ((((_la - 107)) & ~0x3f) == 0 && ((1L << (_la - 107)) & ((1L << (PUBLIC - 107)) | (1L << (PRIVATE - 107)) | (1L << (PROTECTED - 107)) | (1L << (INTERNAL - 107)) | (1L << (ENUM - 107)) | (1L << (SEALED - 107)) | (1L << (ANNOTATION - 107)) | (1L << (DATA - 107)) | (1L << (INNER - 107)) | (1L << (VALUE - 107)) | (1L << (TAILREC - 107)) | (1L << (OPERATOR - 107)) | (1L << (INLINE - 107)) | (1L << (INFIX - 107)) | (1L << (EXTERNAL - 107)) | (1L << (SUSPEND - 107)) | (1L << (OVERRIDE - 107)) | (1L << (ABSTRACT - 107)) | (1L << (FINAL - 107)) | (1L << (OPEN - 107)) | (1L << (CONST - 107)) | (1L << (LATEINIT - 107)) | (1L << (VARARG - 107)) | (1L << (NOINLINE - 107)) | (1L << (CROSSINLINE - 107)) | (1L << (EXPECT - 107)) | (1L << (ACTUAL - 107)))) != 0)) { - { - setState(466); - modifiers(); - } - } - - setState(469); - match(TYPE_ALIAS); - setState(473); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(470); - match(NL); - } - } - setState(475); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(476); - simpleIdentifier(); - setState(484); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,23,_ctx) ) { - case 1: - { - setState(480); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(477); - match(NL); - } - } - setState(482); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(483); - typeParameters(); - } - break; - } - setState(489); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(486); - match(NL); - } - } - setState(491); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(492); - match(ASSIGNMENT); - setState(496); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(493); - match(NL); - } - } - setState(498); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(499); - type(); - } - } - 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 ClassDeclarationContext classDeclaration() { - return getRuleContext(ClassDeclarationContext.class,0); - } - public ObjectDeclarationContext objectDeclaration() { - return getRuleContext(ObjectDeclarationContext.class,0); - } - public FunctionDeclarationContext functionDeclaration() { - return getRuleContext(FunctionDeclarationContext.class,0); - } - public PropertyDeclarationContext propertyDeclaration() { - return getRuleContext(PropertyDeclarationContext.class,0); - } - public TypeAliasContext typeAlias() { - return getRuleContext(TypeAliasContext.class,0); - } - public DeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_declaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitDeclaration(this); - } - } - - public final DeclarationContext declaration() throws RecognitionException { - DeclarationContext _localctx = new DeclarationContext(_ctx, getState()); - enterRule(_localctx, 20, RULE_declaration); - try { - setState(506); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(501); - classDeclaration(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(502); - objectDeclaration(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(503); - functionDeclaration(); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(504); - propertyDeclaration(); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(505); - typeAlias(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ClassDeclarationContext extends ParserRuleContext { - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public TerminalNode CLASS() { return getToken(KotlinParser.CLASS, 0); } - public TerminalNode INTERFACE() { return getToken(KotlinParser.INTERFACE, 0); } - public ModifiersContext modifiers() { - return getRuleContext(ModifiersContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TypeParametersContext typeParameters() { - return getRuleContext(TypeParametersContext.class,0); - } - public PrimaryConstructorContext primaryConstructor() { - return getRuleContext(PrimaryConstructorContext.class,0); - } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public DelegationSpecifiersContext delegationSpecifiers() { - return getRuleContext(DelegationSpecifiersContext.class,0); - } - public TypeConstraintsContext typeConstraints() { - return getRuleContext(TypeConstraintsContext.class,0); - } - public ClassBodyContext classBody() { - return getRuleContext(ClassBodyContext.class,0); - } - public EnumClassBodyContext enumClassBody() { - return getRuleContext(EnumClassBodyContext.class,0); - } - public TerminalNode FUN() { return getToken(KotlinParser.FUN, 0); } - public ClassDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_classDeclaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterClassDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitClassDeclaration(this); - } - } - - public final ClassDeclarationContext classDeclaration() throws RecognitionException { - ClassDeclarationContext _localctx = new ClassDeclarationContext(_ctx, getState()); - enterRule(_localctx, 22, RULE_classDeclaration); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(509); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==AT_NO_WS || _la==AT_PRE_WS || ((((_la - 107)) & ~0x3f) == 0 && ((1L << (_la - 107)) & ((1L << (PUBLIC - 107)) | (1L << (PRIVATE - 107)) | (1L << (PROTECTED - 107)) | (1L << (INTERNAL - 107)) | (1L << (ENUM - 107)) | (1L << (SEALED - 107)) | (1L << (ANNOTATION - 107)) | (1L << (DATA - 107)) | (1L << (INNER - 107)) | (1L << (VALUE - 107)) | (1L << (TAILREC - 107)) | (1L << (OPERATOR - 107)) | (1L << (INLINE - 107)) | (1L << (INFIX - 107)) | (1L << (EXTERNAL - 107)) | (1L << (SUSPEND - 107)) | (1L << (OVERRIDE - 107)) | (1L << (ABSTRACT - 107)) | (1L << (FINAL - 107)) | (1L << (OPEN - 107)) | (1L << (CONST - 107)) | (1L << (LATEINIT - 107)) | (1L << (VARARG - 107)) | (1L << (NOINLINE - 107)) | (1L << (CROSSINLINE - 107)) | (1L << (EXPECT - 107)) | (1L << (ACTUAL - 107)))) != 0)) { - { - setState(508); - modifiers(); - } - } - - setState(522); - _errHandler.sync(this); - switch (_input.LA(1)) { - case CLASS: - { - setState(511); - match(CLASS); - } - break; - case INTERFACE: - case FUN: - { - setState(519); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==FUN) { - { - setState(512); - match(FUN); - setState(516); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(513); - match(NL); - } - } - setState(518); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - - setState(521); - match(INTERFACE); - } - break; - default: - throw new NoViableAltException(this); - } - setState(527); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(524); - match(NL); - } - } - setState(529); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(530); - simpleIdentifier(); - setState(538); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,33,_ctx) ) { - case 1: - { - setState(534); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(531); - match(NL); - } - } - setState(536); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(537); - typeParameters(); - } - break; - } - setState(547); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) { - case 1: - { - setState(543); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(540); - match(NL); - } - } - setState(545); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(546); - primaryConstructor(); - } - break; - } - setState(563); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,38,_ctx) ) { - case 1: - { - setState(552); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(549); - match(NL); - } - } - setState(554); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(555); - match(COLON); - setState(559); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,37,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(556); - match(NL); - } - } - } - setState(561); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,37,_ctx); - } - setState(562); - delegationSpecifiers(); - } - break; - } - setState(572); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) { - case 1: - { - setState(568); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(565); - match(NL); - } - } - setState(570); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(571); - typeConstraints(); - } - break; - } - setState(588); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,43,_ctx) ) { - case 1: - { - setState(577); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(574); - match(NL); - } - } - setState(579); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(580); - classBody(); - } - break; - case 2: - { - setState(584); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(581); - match(NL); - } - } - setState(586); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(587); - enumClassBody(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class PrimaryConstructorContext extends ParserRuleContext { - public ClassParametersContext classParameters() { - return getRuleContext(ClassParametersContext.class,0); - } - public TerminalNode CONSTRUCTOR() { return getToken(KotlinParser.CONSTRUCTOR, 0); } - public ModifiersContext modifiers() { - return getRuleContext(ModifiersContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public PrimaryConstructorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_primaryConstructor; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterPrimaryConstructor(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitPrimaryConstructor(this); - } - } - - public final PrimaryConstructorContext primaryConstructor() throws RecognitionException { - PrimaryConstructorContext _localctx = new PrimaryConstructorContext(_ctx, getState()); - enterRule(_localctx, 24, RULE_primaryConstructor); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(600); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==AT_NO_WS || _la==AT_PRE_WS || ((((_la - 79)) & ~0x3f) == 0 && ((1L << (_la - 79)) & ((1L << (CONSTRUCTOR - 79)) | (1L << (PUBLIC - 79)) | (1L << (PRIVATE - 79)) | (1L << (PROTECTED - 79)) | (1L << (INTERNAL - 79)) | (1L << (ENUM - 79)) | (1L << (SEALED - 79)) | (1L << (ANNOTATION - 79)) | (1L << (DATA - 79)) | (1L << (INNER - 79)) | (1L << (VALUE - 79)) | (1L << (TAILREC - 79)) | (1L << (OPERATOR - 79)) | (1L << (INLINE - 79)) | (1L << (INFIX - 79)) | (1L << (EXTERNAL - 79)) | (1L << (SUSPEND - 79)) | (1L << (OVERRIDE - 79)) | (1L << (ABSTRACT - 79)) | (1L << (FINAL - 79)) | (1L << (OPEN - 79)) | (1L << (CONST - 79)) | (1L << (LATEINIT - 79)) | (1L << (VARARG - 79)) | (1L << (NOINLINE - 79)) | (1L << (CROSSINLINE - 79)) | (1L << (EXPECT - 79)) | (1L << (ACTUAL - 79)))) != 0)) { - { - setState(591); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==AT_NO_WS || _la==AT_PRE_WS || ((((_la - 107)) & ~0x3f) == 0 && ((1L << (_la - 107)) & ((1L << (PUBLIC - 107)) | (1L << (PRIVATE - 107)) | (1L << (PROTECTED - 107)) | (1L << (INTERNAL - 107)) | (1L << (ENUM - 107)) | (1L << (SEALED - 107)) | (1L << (ANNOTATION - 107)) | (1L << (DATA - 107)) | (1L << (INNER - 107)) | (1L << (VALUE - 107)) | (1L << (TAILREC - 107)) | (1L << (OPERATOR - 107)) | (1L << (INLINE - 107)) | (1L << (INFIX - 107)) | (1L << (EXTERNAL - 107)) | (1L << (SUSPEND - 107)) | (1L << (OVERRIDE - 107)) | (1L << (ABSTRACT - 107)) | (1L << (FINAL - 107)) | (1L << (OPEN - 107)) | (1L << (CONST - 107)) | (1L << (LATEINIT - 107)) | (1L << (VARARG - 107)) | (1L << (NOINLINE - 107)) | (1L << (CROSSINLINE - 107)) | (1L << (EXPECT - 107)) | (1L << (ACTUAL - 107)))) != 0)) { - { - setState(590); - modifiers(); - } - } - - setState(593); - match(CONSTRUCTOR); - setState(597); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(594); - match(NL); - } - } - setState(599); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - - setState(602); - classParameters(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ClassBodyContext extends ParserRuleContext { - public TerminalNode LCURL() { return getToken(KotlinParser.LCURL, 0); } - public ClassMemberDeclarationsContext classMemberDeclarations() { - return getRuleContext(ClassMemberDeclarationsContext.class,0); - } - public TerminalNode RCURL() { return getToken(KotlinParser.RCURL, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public ClassBodyContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_classBody; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterClassBody(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitClassBody(this); - } - } - - public final ClassBodyContext classBody() throws RecognitionException { - ClassBodyContext _localctx = new ClassBodyContext(_ctx, getState()); - enterRule(_localctx, 26, RULE_classBody); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(604); - match(LCURL); - setState(608); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,47,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(605); - match(NL); - } - } - } - setState(610); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,47,_ctx); - } - setState(611); - classMemberDeclarations(); - setState(615); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(612); - match(NL); - } - } - setState(617); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(618); - match(RCURL); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ClassParametersContext extends ParserRuleContext { - public TerminalNode LPAREN() { return getToken(KotlinParser.LPAREN, 0); } - public TerminalNode RPAREN() { return getToken(KotlinParser.RPAREN, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public List classParameter() { - return getRuleContexts(ClassParameterContext.class); - } - public ClassParameterContext classParameter(int i) { - return getRuleContext(ClassParameterContext.class,i); - } - public List COMMA() { return getTokens(KotlinParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(KotlinParser.COMMA, i); - } - public ClassParametersContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_classParameters; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterClassParameters(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitClassParameters(this); - } - } - - public final ClassParametersContext classParameters() throws RecognitionException { - ClassParametersContext _localctx = new ClassParametersContext(_ctx, getState()); - enterRule(_localctx, 28, RULE_classParameters); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(620); - match(LPAREN); - setState(624); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,49,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(621); - match(NL); - } - } - } - setState(626); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,49,_ctx); - } - setState(656); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,55,_ctx) ) { - case 1: - { - setState(627); - classParameter(); - setState(644); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,52,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(631); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(628); - match(NL); - } - } - setState(633); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(634); - match(COMMA); - setState(638); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,51,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(635); - match(NL); - } - } - } - setState(640); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,51,_ctx); - } - setState(641); - classParameter(); - } - } - } - setState(646); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,52,_ctx); - } - setState(654); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,54,_ctx) ) { - case 1: - { - setState(650); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(647); - match(NL); - } - } - setState(652); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(653); - match(COMMA); - } - break; - } - } - break; - } - setState(661); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(658); - match(NL); - } - } - setState(663); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(664); - match(RPAREN); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ClassParameterContext extends ParserRuleContext { - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public ModifiersContext modifiers() { - return getRuleContext(ModifiersContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TerminalNode ASSIGNMENT() { return getToken(KotlinParser.ASSIGNMENT, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode VAL() { return getToken(KotlinParser.VAL, 0); } - public TerminalNode VAR() { return getToken(KotlinParser.VAR, 0); } - public ClassParameterContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_classParameter; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterClassParameter(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitClassParameter(this); - } - } - - public final ClassParameterContext classParameter() throws RecognitionException { - ClassParameterContext _localctx = new ClassParameterContext(_ctx, getState()); - enterRule(_localctx, 30, RULE_classParameter); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(667); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,57,_ctx) ) { - case 1: - { - setState(666); - modifiers(); - } - break; - } - setState(670); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==VAL || _la==VAR) { - { - setState(669); - _la = _input.LA(1); - if ( !(_la==VAL || _la==VAR) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - - setState(675); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(672); - match(NL); - } - } - setState(677); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(678); - simpleIdentifier(); - setState(679); - match(COLON); - setState(683); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(680); - match(NL); - } - } - setState(685); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(686); - type(); - setState(701); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,63,_ctx) ) { - case 1: - { - setState(690); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(687); - match(NL); - } - } - setState(692); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(693); - match(ASSIGNMENT); - setState(697); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(694); - match(NL); - } - } - setState(699); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(700); - expression(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class DelegationSpecifiersContext extends ParserRuleContext { - public List annotatedDelegationSpecifier() { - return getRuleContexts(AnnotatedDelegationSpecifierContext.class); - } - public AnnotatedDelegationSpecifierContext annotatedDelegationSpecifier(int i) { - return getRuleContext(AnnotatedDelegationSpecifierContext.class,i); - } - public List COMMA() { return getTokens(KotlinParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(KotlinParser.COMMA, i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public DelegationSpecifiersContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_delegationSpecifiers; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterDelegationSpecifiers(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitDelegationSpecifiers(this); - } - } - - public final DelegationSpecifiersContext delegationSpecifiers() throws RecognitionException { - DelegationSpecifiersContext _localctx = new DelegationSpecifiersContext(_ctx, getState()); - enterRule(_localctx, 32, RULE_delegationSpecifiers); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(703); - annotatedDelegationSpecifier(); - setState(720); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,66,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(707); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(704); - match(NL); - } - } - setState(709); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(710); - match(COMMA); - setState(714); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,65,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(711); - match(NL); - } - } - } - setState(716); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,65,_ctx); - } - setState(717); - annotatedDelegationSpecifier(); - } - } - } - setState(722); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,66,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class DelegationSpecifierContext extends ParserRuleContext { - public ConstructorInvocationContext constructorInvocation() { - return getRuleContext(ConstructorInvocationContext.class,0); - } - public ExplicitDelegationContext explicitDelegation() { - return getRuleContext(ExplicitDelegationContext.class,0); - } - public UserTypeContext userType() { - return getRuleContext(UserTypeContext.class,0); - } - public FunctionTypeContext functionType() { - return getRuleContext(FunctionTypeContext.class,0); - } - public DelegationSpecifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_delegationSpecifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterDelegationSpecifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitDelegationSpecifier(this); - } - } - - public final DelegationSpecifierContext delegationSpecifier() throws RecognitionException { - DelegationSpecifierContext _localctx = new DelegationSpecifierContext(_ctx, getState()); - enterRule(_localctx, 34, RULE_delegationSpecifier); - try { - setState(727); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,67,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(723); - constructorInvocation(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(724); - explicitDelegation(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(725); - userType(); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(726); - functionType(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ConstructorInvocationContext extends ParserRuleContext { - public UserTypeContext userType() { - return getRuleContext(UserTypeContext.class,0); - } - public ValueArgumentsContext valueArguments() { - return getRuleContext(ValueArgumentsContext.class,0); - } - public ConstructorInvocationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_constructorInvocation; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterConstructorInvocation(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitConstructorInvocation(this); - } - } - - public final ConstructorInvocationContext constructorInvocation() throws RecognitionException { - ConstructorInvocationContext _localctx = new ConstructorInvocationContext(_ctx, getState()); - enterRule(_localctx, 36, RULE_constructorInvocation); - try { - enterOuterAlt(_localctx, 1); - { - setState(729); - userType(); - setState(730); - valueArguments(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class AnnotatedDelegationSpecifierContext extends ParserRuleContext { - public DelegationSpecifierContext delegationSpecifier() { - return getRuleContext(DelegationSpecifierContext.class,0); - } - public List annotation() { - return getRuleContexts(AnnotationContext.class); - } - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class,i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public AnnotatedDelegationSpecifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_annotatedDelegationSpecifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterAnnotatedDelegationSpecifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitAnnotatedDelegationSpecifier(this); - } - } - - public final AnnotatedDelegationSpecifierContext annotatedDelegationSpecifier() throws RecognitionException { - AnnotatedDelegationSpecifierContext _localctx = new AnnotatedDelegationSpecifierContext(_ctx, getState()); - enterRule(_localctx, 38, RULE_annotatedDelegationSpecifier); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(735); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,68,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(732); - annotation(); - } - } - } - setState(737); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,68,_ctx); - } - setState(741); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(738); - match(NL); - } - } - setState(743); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(744); - delegationSpecifier(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ExplicitDelegationContext extends ParserRuleContext { - public TerminalNode BY() { return getToken(KotlinParser.BY, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public UserTypeContext userType() { - return getRuleContext(UserTypeContext.class,0); - } - public FunctionTypeContext functionType() { - return getRuleContext(FunctionTypeContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public ExplicitDelegationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_explicitDelegation; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterExplicitDelegation(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitExplicitDelegation(this); - } - } - - public final ExplicitDelegationContext explicitDelegation() throws RecognitionException { - ExplicitDelegationContext _localctx = new ExplicitDelegationContext(_ctx, getState()); - enterRule(_localctx, 40, RULE_explicitDelegation); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(748); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,70,_ctx) ) { - case 1: - { - setState(746); - userType(); - } - break; - case 2: - { - setState(747); - functionType(); - } - break; - } - setState(753); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(750); - match(NL); - } - } - setState(755); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(756); - match(BY); - setState(760); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(757); - match(NL); - } - } - setState(762); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(763); - expression(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TypeParametersContext extends ParserRuleContext { - public TerminalNode LANGLE() { return getToken(KotlinParser.LANGLE, 0); } - public List typeParameter() { - return getRuleContexts(TypeParameterContext.class); - } - public TypeParameterContext typeParameter(int i) { - return getRuleContext(TypeParameterContext.class,i); - } - public TerminalNode RANGLE() { return getToken(KotlinParser.RANGLE, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public List COMMA() { return getTokens(KotlinParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(KotlinParser.COMMA, i); - } - public TypeParametersContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeParameters; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterTypeParameters(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitTypeParameters(this); - } - } - - public final TypeParametersContext typeParameters() throws RecognitionException { - TypeParametersContext _localctx = new TypeParametersContext(_ctx, getState()); - enterRule(_localctx, 42, RULE_typeParameters); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(765); - match(LANGLE); - setState(769); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,73,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(766); - match(NL); - } - } - } - setState(771); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,73,_ctx); - } - setState(772); - typeParameter(); - setState(789); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,76,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(776); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(773); - match(NL); - } - } - setState(778); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(779); - match(COMMA); - setState(783); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,75,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(780); - match(NL); - } - } - } - setState(785); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,75,_ctx); - } - setState(786); - typeParameter(); - } - } - } - setState(791); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,76,_ctx); - } - setState(799); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,78,_ctx) ) { - case 1: - { - setState(795); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(792); - match(NL); - } - } - setState(797); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(798); - match(COMMA); - } - break; - } - setState(804); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(801); - match(NL); - } - } - setState(806); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(807); - match(RANGLE); - } - } - 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 SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public TypeParameterModifiersContext typeParameterModifiers() { - return getRuleContext(TypeParameterModifiersContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public TypeParameterContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeParameter; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterTypeParameter(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitTypeParameter(this); - } - } - - public final TypeParameterContext typeParameter() throws RecognitionException { - TypeParameterContext _localctx = new TypeParameterContext(_ctx, getState()); - enterRule(_localctx, 44, RULE_typeParameter); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(810); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,80,_ctx) ) { - case 1: - { - setState(809); - typeParameterModifiers(); - } - break; - } - setState(815); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(812); - match(NL); - } - } - setState(817); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(818); - simpleIdentifier(); - setState(833); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,84,_ctx) ) { - case 1: - { - setState(822); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(819); - match(NL); - } - } - setState(824); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(825); - match(COLON); - setState(829); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(826); - match(NL); - } - } - setState(831); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(832); - type(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TypeConstraintsContext extends ParserRuleContext { - public TerminalNode WHERE() { return getToken(KotlinParser.WHERE, 0); } - public List typeConstraint() { - return getRuleContexts(TypeConstraintContext.class); - } - public TypeConstraintContext typeConstraint(int i) { - return getRuleContext(TypeConstraintContext.class,i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public List COMMA() { return getTokens(KotlinParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(KotlinParser.COMMA, i); - } - public TypeConstraintsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeConstraints; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterTypeConstraints(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitTypeConstraints(this); - } - } - - public final TypeConstraintsContext typeConstraints() throws RecognitionException { - TypeConstraintsContext _localctx = new TypeConstraintsContext(_ctx, getState()); - enterRule(_localctx, 46, RULE_typeConstraints); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(835); - match(WHERE); - setState(839); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(836); - match(NL); - } - } - setState(841); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(842); - typeConstraint(); - setState(859); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,88,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(846); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(843); - match(NL); - } - } - setState(848); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(849); - match(COMMA); - setState(853); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(850); - match(NL); - } - } - setState(855); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(856); - typeConstraint(); - } - } - } - setState(861); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,88,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TypeConstraintContext extends ParserRuleContext { - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public List annotation() { - return getRuleContexts(AnnotationContext.class); - } - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class,i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TypeConstraintContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeConstraint; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterTypeConstraint(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitTypeConstraint(this); - } - } - - public final TypeConstraintContext typeConstraint() throws RecognitionException { - TypeConstraintContext _localctx = new TypeConstraintContext(_ctx, getState()); - enterRule(_localctx, 48, RULE_typeConstraint); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(865); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==AT_NO_WS || _la==AT_PRE_WS) { - { - { - setState(862); - annotation(); - } - } - setState(867); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(868); - simpleIdentifier(); - setState(872); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(869); - match(NL); - } - } - setState(874); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(875); - match(COLON); - setState(879); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(876); - match(NL); - } - } - setState(881); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(882); - type(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ClassMemberDeclarationsContext extends ParserRuleContext { - public List classMemberDeclaration() { - return getRuleContexts(ClassMemberDeclarationContext.class); - } - public ClassMemberDeclarationContext classMemberDeclaration(int i) { - return getRuleContext(ClassMemberDeclarationContext.class,i); - } - public List semis() { - return getRuleContexts(SemisContext.class); - } - public SemisContext semis(int i) { - return getRuleContext(SemisContext.class,i); - } - public ClassMemberDeclarationsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_classMemberDeclarations; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterClassMemberDeclarations(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitClassMemberDeclarations(this); - } - } - - public final ClassMemberDeclarationsContext classMemberDeclarations() throws RecognitionException { - ClassMemberDeclarationsContext _localctx = new ClassMemberDeclarationsContext(_ctx, getState()); - enterRule(_localctx, 50, RULE_classMemberDeclarations); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(890); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==AT_NO_WS || _la==AT_PRE_WS || ((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & ((1L << (CLASS - 72)) | (1L << (INTERFACE - 72)) | (1L << (FUN - 72)) | (1L << (OBJECT - 72)) | (1L << (VAL - 72)) | (1L << (VAR - 72)) | (1L << (TYPE_ALIAS - 72)) | (1L << (CONSTRUCTOR - 72)) | (1L << (COMPANION - 72)) | (1L << (INIT - 72)) | (1L << (PUBLIC - 72)) | (1L << (PRIVATE - 72)) | (1L << (PROTECTED - 72)) | (1L << (INTERNAL - 72)) | (1L << (ENUM - 72)) | (1L << (SEALED - 72)) | (1L << (ANNOTATION - 72)) | (1L << (DATA - 72)) | (1L << (INNER - 72)) | (1L << (VALUE - 72)) | (1L << (TAILREC - 72)) | (1L << (OPERATOR - 72)) | (1L << (INLINE - 72)) | (1L << (INFIX - 72)) | (1L << (EXTERNAL - 72)) | (1L << (SUSPEND - 72)) | (1L << (OVERRIDE - 72)) | (1L << (ABSTRACT - 72)) | (1L << (FINAL - 72)) | (1L << (OPEN - 72)) | (1L << (CONST - 72)) | (1L << (LATEINIT - 72)) | (1L << (VARARG - 72)) | (1L << (NOINLINE - 72)) | (1L << (CROSSINLINE - 72)) | (1L << (EXPECT - 72)) | (1L << (ACTUAL - 72)))) != 0)) { - { - { - setState(884); - classMemberDeclaration(); - setState(886); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,92,_ctx) ) { - case 1: - { - setState(885); - semis(); - } - break; - } - } - } - setState(892); - _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 ClassMemberDeclarationContext extends ParserRuleContext { - public DeclarationContext declaration() { - return getRuleContext(DeclarationContext.class,0); - } - public CompanionObjectContext companionObject() { - return getRuleContext(CompanionObjectContext.class,0); - } - public AnonymousInitializerContext anonymousInitializer() { - return getRuleContext(AnonymousInitializerContext.class,0); - } - public SecondaryConstructorContext secondaryConstructor() { - return getRuleContext(SecondaryConstructorContext.class,0); - } - public ClassMemberDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_classMemberDeclaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterClassMemberDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitClassMemberDeclaration(this); - } - } - - public final ClassMemberDeclarationContext classMemberDeclaration() throws RecognitionException { - ClassMemberDeclarationContext _localctx = new ClassMemberDeclarationContext(_ctx, getState()); - enterRule(_localctx, 52, RULE_classMemberDeclaration); - try { - setState(897); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,94,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(893); - declaration(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(894); - companionObject(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(895); - anonymousInitializer(); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(896); - secondaryConstructor(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class AnonymousInitializerContext extends ParserRuleContext { - public TerminalNode INIT() { return getToken(KotlinParser.INIT, 0); } - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public AnonymousInitializerContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_anonymousInitializer; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterAnonymousInitializer(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitAnonymousInitializer(this); - } - } - - public final AnonymousInitializerContext anonymousInitializer() throws RecognitionException { - AnonymousInitializerContext _localctx = new AnonymousInitializerContext(_ctx, getState()); - enterRule(_localctx, 54, RULE_anonymousInitializer); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(899); - match(INIT); - setState(903); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(900); - match(NL); - } - } - setState(905); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(906); - block(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class CompanionObjectContext extends ParserRuleContext { - public TerminalNode COMPANION() { return getToken(KotlinParser.COMPANION, 0); } - public TerminalNode OBJECT() { return getToken(KotlinParser.OBJECT, 0); } - public ModifiersContext modifiers() { - return getRuleContext(ModifiersContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public DelegationSpecifiersContext delegationSpecifiers() { - return getRuleContext(DelegationSpecifiersContext.class,0); - } - public ClassBodyContext classBody() { - return getRuleContext(ClassBodyContext.class,0); - } - public CompanionObjectContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_companionObject; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterCompanionObject(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitCompanionObject(this); - } - } - - public final CompanionObjectContext companionObject() throws RecognitionException { - CompanionObjectContext _localctx = new CompanionObjectContext(_ctx, getState()); - enterRule(_localctx, 56, RULE_companionObject); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(909); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==AT_NO_WS || _la==AT_PRE_WS || ((((_la - 107)) & ~0x3f) == 0 && ((1L << (_la - 107)) & ((1L << (PUBLIC - 107)) | (1L << (PRIVATE - 107)) | (1L << (PROTECTED - 107)) | (1L << (INTERNAL - 107)) | (1L << (ENUM - 107)) | (1L << (SEALED - 107)) | (1L << (ANNOTATION - 107)) | (1L << (DATA - 107)) | (1L << (INNER - 107)) | (1L << (VALUE - 107)) | (1L << (TAILREC - 107)) | (1L << (OPERATOR - 107)) | (1L << (INLINE - 107)) | (1L << (INFIX - 107)) | (1L << (EXTERNAL - 107)) | (1L << (SUSPEND - 107)) | (1L << (OVERRIDE - 107)) | (1L << (ABSTRACT - 107)) | (1L << (FINAL - 107)) | (1L << (OPEN - 107)) | (1L << (CONST - 107)) | (1L << (LATEINIT - 107)) | (1L << (VARARG - 107)) | (1L << (NOINLINE - 107)) | (1L << (CROSSINLINE - 107)) | (1L << (EXPECT - 107)) | (1L << (ACTUAL - 107)))) != 0)) { - { - setState(908); - modifiers(); - } - } - - setState(911); - match(COMPANION); - setState(915); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(912); - match(NL); - } - } - setState(917); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(918); - match(OBJECT); - setState(926); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,99,_ctx) ) { - case 1: - { - setState(922); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(919); - match(NL); - } - } - setState(924); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(925); - simpleIdentifier(); - } - break; - } - setState(942); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,102,_ctx) ) { - case 1: - { - setState(931); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(928); - match(NL); - } - } - setState(933); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(934); - match(COLON); - setState(938); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,101,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(935); - match(NL); - } - } - } - setState(940); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,101,_ctx); - } - setState(941); - delegationSpecifiers(); - } - break; - } - setState(951); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,104,_ctx) ) { - case 1: - { - setState(947); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(944); - match(NL); - } - } - setState(949); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(950); - classBody(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class FunctionValueParametersContext extends ParserRuleContext { - public TerminalNode LPAREN() { return getToken(KotlinParser.LPAREN, 0); } - public TerminalNode RPAREN() { return getToken(KotlinParser.RPAREN, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public List functionValueParameter() { - return getRuleContexts(FunctionValueParameterContext.class); - } - public FunctionValueParameterContext functionValueParameter(int i) { - return getRuleContext(FunctionValueParameterContext.class,i); - } - public List COMMA() { return getTokens(KotlinParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(KotlinParser.COMMA, i); - } - public FunctionValueParametersContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_functionValueParameters; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterFunctionValueParameters(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitFunctionValueParameters(this); - } - } - - public final FunctionValueParametersContext functionValueParameters() throws RecognitionException { - FunctionValueParametersContext _localctx = new FunctionValueParametersContext(_ctx, getState()); - enterRule(_localctx, 58, RULE_functionValueParameters); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(953); - match(LPAREN); - setState(957); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,105,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(954); - match(NL); - } - } - } - setState(959); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,105,_ctx); - } - setState(989); - _errHandler.sync(this); - _la = _input.LA(1); - if (((((_la - 40)) & ~0x3f) == 0 && ((1L << (_la - 40)) & ((1L << (AT_NO_WS - 40)) | (1L << (AT_PRE_WS - 40)) | (1L << (FILE - 40)) | (1L << (FIELD - 40)) | (1L << (PROPERTY - 40)) | (1L << (GET - 40)) | (1L << (SET - 40)) | (1L << (RECEIVER - 40)) | (1L << (PARAM - 40)) | (1L << (SETPARAM - 40)) | (1L << (DELEGATE - 40)) | (1L << (IMPORT - 40)) | (1L << (CONSTRUCTOR - 40)) | (1L << (BY - 40)) | (1L << (COMPANION - 40)) | (1L << (INIT - 40)) | (1L << (WHERE - 40)) | (1L << (CATCH - 40)) | (1L << (FINALLY - 40)))) != 0) || ((((_la - 105)) & ~0x3f) == 0 && ((1L << (_la - 105)) & ((1L << (OUT - 105)) | (1L << (DYNAMIC - 105)) | (1L << (PUBLIC - 105)) | (1L << (PRIVATE - 105)) | (1L << (PROTECTED - 105)) | (1L << (INTERNAL - 105)) | (1L << (ENUM - 105)) | (1L << (SEALED - 105)) | (1L << (ANNOTATION - 105)) | (1L << (DATA - 105)) | (1L << (INNER - 105)) | (1L << (VALUE - 105)) | (1L << (TAILREC - 105)) | (1L << (OPERATOR - 105)) | (1L << (INLINE - 105)) | (1L << (INFIX - 105)) | (1L << (EXTERNAL - 105)) | (1L << (SUSPEND - 105)) | (1L << (OVERRIDE - 105)) | (1L << (ABSTRACT - 105)) | (1L << (FINAL - 105)) | (1L << (OPEN - 105)) | (1L << (CONST - 105)) | (1L << (LATEINIT - 105)) | (1L << (VARARG - 105)) | (1L << (NOINLINE - 105)) | (1L << (CROSSINLINE - 105)) | (1L << (REIFIED - 105)) | (1L << (EXPECT - 105)) | (1L << (ACTUAL - 105)) | (1L << (Identifier - 105)))) != 0)) { - { - setState(960); - functionValueParameter(); - setState(977); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,108,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(964); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(961); - match(NL); - } - } - setState(966); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(967); - match(COMMA); - setState(971); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(968); - match(NL); - } - } - setState(973); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(974); - functionValueParameter(); - } - } - } - setState(979); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,108,_ctx); - } - setState(987); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,110,_ctx) ) { - case 1: - { - setState(983); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(980); - match(NL); - } - } - setState(985); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(986); - match(COMMA); - } - break; - } - } - } - - setState(994); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(991); - match(NL); - } - } - setState(996); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(997); - match(RPAREN); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class FunctionValueParameterContext extends ParserRuleContext { - public ParameterContext parameter() { - return getRuleContext(ParameterContext.class,0); - } - public ParameterModifiersContext parameterModifiers() { - return getRuleContext(ParameterModifiersContext.class,0); - } - public TerminalNode ASSIGNMENT() { return getToken(KotlinParser.ASSIGNMENT, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public FunctionValueParameterContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_functionValueParameter; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterFunctionValueParameter(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitFunctionValueParameter(this); - } - } - - public final FunctionValueParameterContext functionValueParameter() throws RecognitionException { - FunctionValueParameterContext _localctx = new FunctionValueParameterContext(_ctx, getState()); - enterRule(_localctx, 60, RULE_functionValueParameter); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1000); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,113,_ctx) ) { - case 1: - { - setState(999); - parameterModifiers(); - } - break; - } - setState(1002); - parameter(); - setState(1017); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,116,_ctx) ) { - case 1: - { - setState(1006); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1003); - match(NL); - } - } - setState(1008); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1009); - match(ASSIGNMENT); - setState(1013); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1010); - match(NL); - } - } - setState(1015); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1016); - expression(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class FunctionDeclarationContext extends ParserRuleContext { - public TerminalNode FUN() { return getToken(KotlinParser.FUN, 0); } - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public FunctionValueParametersContext functionValueParameters() { - return getRuleContext(FunctionValueParametersContext.class,0); - } - public ModifiersContext modifiers() { - return getRuleContext(ModifiersContext.class,0); - } - public TypeParametersContext typeParameters() { - return getRuleContext(TypeParametersContext.class,0); - } - public ReceiverTypeContext receiverType() { - return getRuleContext(ReceiverTypeContext.class,0); - } - public TerminalNode DOT() { return getToken(KotlinParser.DOT, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public TypeConstraintsContext typeConstraints() { - return getRuleContext(TypeConstraintsContext.class,0); - } - public FunctionBodyContext functionBody() { - return getRuleContext(FunctionBodyContext.class,0); - } - public FunctionDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_functionDeclaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterFunctionDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitFunctionDeclaration(this); - } - } - - public final FunctionDeclarationContext functionDeclaration() throws RecognitionException { - FunctionDeclarationContext _localctx = new FunctionDeclarationContext(_ctx, getState()); - enterRule(_localctx, 62, RULE_functionDeclaration); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1020); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==AT_NO_WS || _la==AT_PRE_WS || ((((_la - 107)) & ~0x3f) == 0 && ((1L << (_la - 107)) & ((1L << (PUBLIC - 107)) | (1L << (PRIVATE - 107)) | (1L << (PROTECTED - 107)) | (1L << (INTERNAL - 107)) | (1L << (ENUM - 107)) | (1L << (SEALED - 107)) | (1L << (ANNOTATION - 107)) | (1L << (DATA - 107)) | (1L << (INNER - 107)) | (1L << (VALUE - 107)) | (1L << (TAILREC - 107)) | (1L << (OPERATOR - 107)) | (1L << (INLINE - 107)) | (1L << (INFIX - 107)) | (1L << (EXTERNAL - 107)) | (1L << (SUSPEND - 107)) | (1L << (OVERRIDE - 107)) | (1L << (ABSTRACT - 107)) | (1L << (FINAL - 107)) | (1L << (OPEN - 107)) | (1L << (CONST - 107)) | (1L << (LATEINIT - 107)) | (1L << (VARARG - 107)) | (1L << (NOINLINE - 107)) | (1L << (CROSSINLINE - 107)) | (1L << (EXPECT - 107)) | (1L << (ACTUAL - 107)))) != 0)) { - { - setState(1019); - modifiers(); - } - } - - setState(1022); - match(FUN); - setState(1030); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,119,_ctx) ) { - case 1: - { - setState(1026); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1023); - match(NL); - } - } - setState(1028); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1029); - typeParameters(); - } - break; - } - setState(1047); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,122,_ctx) ) { - case 1: - { - setState(1035); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1032); - match(NL); - } - } - setState(1037); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1038); - receiverType(); - setState(1042); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1039); - match(NL); - } - } - setState(1044); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1045); - match(DOT); - } - break; - } - setState(1052); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1049); - match(NL); - } - } - setState(1054); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1055); - simpleIdentifier(); - setState(1059); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1056); - match(NL); - } - } - setState(1061); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1062); - functionValueParameters(); - setState(1077); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,127,_ctx) ) { - case 1: - { - setState(1066); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1063); - match(NL); - } - } - setState(1068); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1069); - match(COLON); - setState(1073); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1070); - match(NL); - } - } - setState(1075); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1076); - type(); - } - break; - } - setState(1086); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,129,_ctx) ) { - case 1: - { - setState(1082); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1079); - match(NL); - } - } - setState(1084); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1085); - typeConstraints(); - } - break; - } - setState(1095); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,131,_ctx) ) { - case 1: - { - setState(1091); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1088); - match(NL); - } - } - setState(1093); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1094); - functionBody(); - } - break; - } - } - } - 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 BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public TerminalNode ASSIGNMENT() { return getToken(KotlinParser.ASSIGNMENT, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public FunctionBodyContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_functionBody; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterFunctionBody(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitFunctionBody(this); - } - } - - public final FunctionBodyContext functionBody() throws RecognitionException { - FunctionBodyContext _localctx = new FunctionBodyContext(_ctx, getState()); - enterRule(_localctx, 64, RULE_functionBody); - int _la; - try { - setState(1106); - _errHandler.sync(this); - switch (_input.LA(1)) { - case LCURL: - enterOuterAlt(_localctx, 1); - { - setState(1097); - block(); - } - break; - case ASSIGNMENT: - enterOuterAlt(_localctx, 2); - { - setState(1098); - match(ASSIGNMENT); - setState(1102); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1099); - match(NL); - } - } - setState(1104); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1105); - expression(); - } - 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 VariableDeclarationContext extends ParserRuleContext { - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public List annotation() { - return getRuleContexts(AnnotationContext.class); - } - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class,i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public VariableDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_variableDeclaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterVariableDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitVariableDeclaration(this); - } - } - - public final VariableDeclarationContext variableDeclaration() throws RecognitionException { - VariableDeclarationContext _localctx = new VariableDeclarationContext(_ctx, getState()); - enterRule(_localctx, 66, RULE_variableDeclaration); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1111); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==AT_NO_WS || _la==AT_PRE_WS) { - { - { - setState(1108); - annotation(); - } - } - setState(1113); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1117); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1114); - match(NL); - } - } - setState(1119); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1120); - simpleIdentifier(); - setState(1135); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,138,_ctx) ) { - case 1: - { - setState(1124); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1121); - match(NL); - } - } - setState(1126); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1127); - match(COLON); - setState(1131); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1128); - match(NL); - } - } - setState(1133); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1134); - type(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class MultiVariableDeclarationContext extends ParserRuleContext { - public TerminalNode LPAREN() { return getToken(KotlinParser.LPAREN, 0); } - public List variableDeclaration() { - return getRuleContexts(VariableDeclarationContext.class); - } - public VariableDeclarationContext variableDeclaration(int i) { - return getRuleContext(VariableDeclarationContext.class,i); - } - public TerminalNode RPAREN() { return getToken(KotlinParser.RPAREN, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public List COMMA() { return getTokens(KotlinParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(KotlinParser.COMMA, i); - } - public MultiVariableDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_multiVariableDeclaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterMultiVariableDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitMultiVariableDeclaration(this); - } - } - - public final MultiVariableDeclarationContext multiVariableDeclaration() throws RecognitionException { - MultiVariableDeclarationContext _localctx = new MultiVariableDeclarationContext(_ctx, getState()); - enterRule(_localctx, 68, RULE_multiVariableDeclaration); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1137); - match(LPAREN); - setState(1141); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,139,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1138); - match(NL); - } - } - } - setState(1143); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,139,_ctx); - } - setState(1144); - variableDeclaration(); - setState(1161); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,142,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1148); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1145); - match(NL); - } - } - setState(1150); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1151); - match(COMMA); - setState(1155); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,141,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1152); - match(NL); - } - } - } - setState(1157); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,141,_ctx); - } - setState(1158); - variableDeclaration(); - } - } - } - setState(1163); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,142,_ctx); - } - setState(1171); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,144,_ctx) ) { - case 1: - { - setState(1167); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1164); - match(NL); - } - } - setState(1169); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1170); - match(COMMA); - } - break; - } - setState(1176); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1173); - match(NL); - } - } - setState(1178); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1179); - match(RPAREN); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class PropertyDeclarationContext extends ParserRuleContext { - public TerminalNode VAL() { return getToken(KotlinParser.VAL, 0); } - public TerminalNode VAR() { return getToken(KotlinParser.VAR, 0); } - public ModifiersContext modifiers() { - return getRuleContext(ModifiersContext.class,0); - } - public TypeParametersContext typeParameters() { - return getRuleContext(TypeParametersContext.class,0); - } - public ReceiverTypeContext receiverType() { - return getRuleContext(ReceiverTypeContext.class,0); - } - public TerminalNode DOT() { return getToken(KotlinParser.DOT, 0); } - public TypeConstraintsContext typeConstraints() { - return getRuleContext(TypeConstraintsContext.class,0); - } - public TerminalNode SEMICOLON() { return getToken(KotlinParser.SEMICOLON, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public MultiVariableDeclarationContext multiVariableDeclaration() { - return getRuleContext(MultiVariableDeclarationContext.class,0); - } - public VariableDeclarationContext variableDeclaration() { - return getRuleContext(VariableDeclarationContext.class,0); - } - public TerminalNode ASSIGNMENT() { return getToken(KotlinParser.ASSIGNMENT, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public PropertyDelegateContext propertyDelegate() { - return getRuleContext(PropertyDelegateContext.class,0); - } - public GetterContext getter() { - return getRuleContext(GetterContext.class,0); - } - public SetterContext setter() { - return getRuleContext(SetterContext.class,0); - } - public SemiContext semi() { - return getRuleContext(SemiContext.class,0); - } - public PropertyDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_propertyDeclaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterPropertyDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitPropertyDeclaration(this); - } - } - - public final PropertyDeclarationContext propertyDeclaration() throws RecognitionException { - PropertyDeclarationContext _localctx = new PropertyDeclarationContext(_ctx, getState()); - enterRule(_localctx, 70, RULE_propertyDeclaration); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1182); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==AT_NO_WS || _la==AT_PRE_WS || ((((_la - 107)) & ~0x3f) == 0 && ((1L << (_la - 107)) & ((1L << (PUBLIC - 107)) | (1L << (PRIVATE - 107)) | (1L << (PROTECTED - 107)) | (1L << (INTERNAL - 107)) | (1L << (ENUM - 107)) | (1L << (SEALED - 107)) | (1L << (ANNOTATION - 107)) | (1L << (DATA - 107)) | (1L << (INNER - 107)) | (1L << (VALUE - 107)) | (1L << (TAILREC - 107)) | (1L << (OPERATOR - 107)) | (1L << (INLINE - 107)) | (1L << (INFIX - 107)) | (1L << (EXTERNAL - 107)) | (1L << (SUSPEND - 107)) | (1L << (OVERRIDE - 107)) | (1L << (ABSTRACT - 107)) | (1L << (FINAL - 107)) | (1L << (OPEN - 107)) | (1L << (CONST - 107)) | (1L << (LATEINIT - 107)) | (1L << (VARARG - 107)) | (1L << (NOINLINE - 107)) | (1L << (CROSSINLINE - 107)) | (1L << (EXPECT - 107)) | (1L << (ACTUAL - 107)))) != 0)) { - { - setState(1181); - modifiers(); - } - } - - setState(1184); - _la = _input.LA(1); - if ( !(_la==VAL || _la==VAR) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(1192); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,148,_ctx) ) { - case 1: - { - setState(1188); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1185); - match(NL); - } - } - setState(1190); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1191); - typeParameters(); - } - break; - } - setState(1209); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,151,_ctx) ) { - case 1: - { - setState(1197); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1194); - match(NL); - } - } - setState(1199); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1200); - receiverType(); - setState(1204); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1201); - match(NL); - } - } - setState(1206); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1207); - match(DOT); - } - break; - } - { - setState(1214); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,152,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1211); - match(NL); - } - } - } - setState(1216); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,152,_ctx); - } - setState(1219); - _errHandler.sync(this); - switch (_input.LA(1)) { - case LPAREN: - { - setState(1217); - multiVariableDeclaration(); - } - break; - case NL: - case AT_NO_WS: - case AT_PRE_WS: - case FILE: - case FIELD: - case PROPERTY: - case GET: - case SET: - case RECEIVER: - case PARAM: - case SETPARAM: - case DELEGATE: - case IMPORT: - case CONSTRUCTOR: - case BY: - case COMPANION: - case INIT: - case WHERE: - case CATCH: - case FINALLY: - case OUT: - case DYNAMIC: - case PUBLIC: - case PRIVATE: - case PROTECTED: - case INTERNAL: - case ENUM: - case SEALED: - case ANNOTATION: - case DATA: - case INNER: - case VALUE: - case TAILREC: - case OPERATOR: - case INLINE: - case INFIX: - case EXTERNAL: - case SUSPEND: - case OVERRIDE: - case ABSTRACT: - case FINAL: - case OPEN: - case CONST: - case LATEINIT: - case VARARG: - case NOINLINE: - case CROSSINLINE: - case REIFIED: - case EXPECT: - case ACTUAL: - case Identifier: - { - setState(1218); - variableDeclaration(); - } - break; - default: - throw new NoViableAltException(this); - } - } - setState(1228); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,155,_ctx) ) { - case 1: - { - setState(1224); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1221); - match(NL); - } - } - setState(1226); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1227); - typeConstraints(); - } - break; - } - setState(1247); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,159,_ctx) ) { - case 1: - { - setState(1233); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1230); - match(NL); - } - } - setState(1235); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1245); - _errHandler.sync(this); - switch (_input.LA(1)) { - case ASSIGNMENT: - { - setState(1236); - match(ASSIGNMENT); - setState(1240); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1237); - match(NL); - } - } - setState(1242); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1243); - expression(); - } - break; - case BY: - { - setState(1244); - propertyDelegate(); - } - break; - default: - throw new NoViableAltException(this); - } - } - break; - } - setState(1255); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,161,_ctx) ) { - case 1: - { - setState(1250); - _errHandler.sync(this); - _la = _input.LA(1); - do { - { - { - setState(1249); - match(NL); - } - } - setState(1252); - _errHandler.sync(this); - _la = _input.LA(1); - } while ( _la==NL ); - setState(1254); - match(SEMICOLON); - } - break; - } - setState(1260); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,162,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1257); - match(NL); - } - } - } - setState(1262); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,162,_ctx); - } - setState(1293); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,171,_ctx) ) { - case 1: - { - setState(1264); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,163,_ctx) ) { - case 1: - { - setState(1263); - getter(); - } - break; - } - setState(1276); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,166,_ctx) ) { - case 1: - { - setState(1269); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,164,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1266); - match(NL); - } - } - } - setState(1271); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,164,_ctx); - } - setState(1273); - _errHandler.sync(this); - _la = _input.LA(1); - if (((((_la - -1)) & ~0x3f) == 0 && ((1L << (_la - -1)) & ((1L << (EOF - -1)) | (1L << (NL - -1)) | (1L << (SEMICOLON - -1)))) != 0)) { - { - setState(1272); - semi(); - } - } - - setState(1275); - setter(); - } - break; - } - } - break; - case 2: - { - setState(1279); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,167,_ctx) ) { - case 1: - { - setState(1278); - setter(); - } - break; - } - setState(1291); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,170,_ctx) ) { - case 1: - { - setState(1284); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,168,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1281); - match(NL); - } - } - } - setState(1286); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,168,_ctx); - } - setState(1288); - _errHandler.sync(this); - _la = _input.LA(1); - if (((((_la - -1)) & ~0x3f) == 0 && ((1L << (_la - -1)) & ((1L << (EOF - -1)) | (1L << (NL - -1)) | (1L << (SEMICOLON - -1)))) != 0)) { - { - setState(1287); - semi(); - } - } - - setState(1290); - getter(); - } - break; - } - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class PropertyDelegateContext extends ParserRuleContext { - public TerminalNode BY() { return getToken(KotlinParser.BY, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public PropertyDelegateContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_propertyDelegate; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterPropertyDelegate(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitPropertyDelegate(this); - } - } - - public final PropertyDelegateContext propertyDelegate() throws RecognitionException { - PropertyDelegateContext _localctx = new PropertyDelegateContext(_ctx, getState()); - enterRule(_localctx, 72, RULE_propertyDelegate); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1295); - match(BY); - setState(1299); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1296); - match(NL); - } - } - setState(1301); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1302); - expression(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class GetterContext extends ParserRuleContext { - public TerminalNode GET() { return getToken(KotlinParser.GET, 0); } - public ModifiersContext modifiers() { - return getRuleContext(ModifiersContext.class,0); - } - public TerminalNode LPAREN() { return getToken(KotlinParser.LPAREN, 0); } - public TerminalNode RPAREN() { return getToken(KotlinParser.RPAREN, 0); } - public FunctionBodyContext functionBody() { - return getRuleContext(FunctionBodyContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public GetterContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_getter; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterGetter(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitGetter(this); - } - } - - public final GetterContext getter() throws RecognitionException { - GetterContext _localctx = new GetterContext(_ctx, getState()); - enterRule(_localctx, 74, RULE_getter); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1305); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==AT_NO_WS || _la==AT_PRE_WS || ((((_la - 107)) & ~0x3f) == 0 && ((1L << (_la - 107)) & ((1L << (PUBLIC - 107)) | (1L << (PRIVATE - 107)) | (1L << (PROTECTED - 107)) | (1L << (INTERNAL - 107)) | (1L << (ENUM - 107)) | (1L << (SEALED - 107)) | (1L << (ANNOTATION - 107)) | (1L << (DATA - 107)) | (1L << (INNER - 107)) | (1L << (VALUE - 107)) | (1L << (TAILREC - 107)) | (1L << (OPERATOR - 107)) | (1L << (INLINE - 107)) | (1L << (INFIX - 107)) | (1L << (EXTERNAL - 107)) | (1L << (SUSPEND - 107)) | (1L << (OVERRIDE - 107)) | (1L << (ABSTRACT - 107)) | (1L << (FINAL - 107)) | (1L << (OPEN - 107)) | (1L << (CONST - 107)) | (1L << (LATEINIT - 107)) | (1L << (VARARG - 107)) | (1L << (NOINLINE - 107)) | (1L << (CROSSINLINE - 107)) | (1L << (EXPECT - 107)) | (1L << (ACTUAL - 107)))) != 0)) { - { - setState(1304); - modifiers(); - } - } - - setState(1307); - match(GET); - setState(1345); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,180,_ctx) ) { - case 1: - { - setState(1311); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1308); - match(NL); - } - } - setState(1313); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1314); - match(LPAREN); - setState(1318); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1315); - match(NL); - } - } - setState(1320); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1321); - match(RPAREN); - setState(1336); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,178,_ctx) ) { - case 1: - { - setState(1325); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1322); - match(NL); - } - } - setState(1327); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1328); - match(COLON); - setState(1332); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1329); - match(NL); - } - } - setState(1334); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1335); - type(); - } - break; - } - setState(1341); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1338); - match(NL); - } - } - setState(1343); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1344); - functionBody(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class SetterContext extends ParserRuleContext { - public TerminalNode SET() { return getToken(KotlinParser.SET, 0); } - public ModifiersContext modifiers() { - return getRuleContext(ModifiersContext.class,0); - } - public TerminalNode LPAREN() { return getToken(KotlinParser.LPAREN, 0); } - public FunctionValueParameterWithOptionalTypeContext functionValueParameterWithOptionalType() { - return getRuleContext(FunctionValueParameterWithOptionalTypeContext.class,0); - } - public TerminalNode RPAREN() { return getToken(KotlinParser.RPAREN, 0); } - public FunctionBodyContext functionBody() { - return getRuleContext(FunctionBodyContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TerminalNode COMMA() { return getToken(KotlinParser.COMMA, 0); } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public SetterContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_setter; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterSetter(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitSetter(this); - } - } - - public final SetterContext setter() throws RecognitionException { - SetterContext _localctx = new SetterContext(_ctx, getState()); - enterRule(_localctx, 76, RULE_setter); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1348); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==AT_NO_WS || _la==AT_PRE_WS || ((((_la - 107)) & ~0x3f) == 0 && ((1L << (_la - 107)) & ((1L << (PUBLIC - 107)) | (1L << (PRIVATE - 107)) | (1L << (PROTECTED - 107)) | (1L << (INTERNAL - 107)) | (1L << (ENUM - 107)) | (1L << (SEALED - 107)) | (1L << (ANNOTATION - 107)) | (1L << (DATA - 107)) | (1L << (INNER - 107)) | (1L << (VALUE - 107)) | (1L << (TAILREC - 107)) | (1L << (OPERATOR - 107)) | (1L << (INLINE - 107)) | (1L << (INFIX - 107)) | (1L << (EXTERNAL - 107)) | (1L << (SUSPEND - 107)) | (1L << (OVERRIDE - 107)) | (1L << (ABSTRACT - 107)) | (1L << (FINAL - 107)) | (1L << (OPEN - 107)) | (1L << (CONST - 107)) | (1L << (LATEINIT - 107)) | (1L << (VARARG - 107)) | (1L << (NOINLINE - 107)) | (1L << (CROSSINLINE - 107)) | (1L << (EXPECT - 107)) | (1L << (ACTUAL - 107)))) != 0)) { - { - setState(1347); - modifiers(); - } - } - - setState(1350); - match(SET); - setState(1405); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,191,_ctx) ) { - case 1: - { - setState(1354); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1351); - match(NL); - } - } - setState(1356); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1357); - match(LPAREN); - setState(1361); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1358); - match(NL); - } - } - setState(1363); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1364); - functionValueParameterWithOptionalType(); - setState(1372); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,185,_ctx) ) { - case 1: - { - setState(1368); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1365); - match(NL); - } - } - setState(1370); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1371); - match(COMMA); - } - break; - } - setState(1377); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1374); - match(NL); - } - } - setState(1379); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1380); - match(RPAREN); - setState(1395); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,189,_ctx) ) { - case 1: - { - setState(1384); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1381); - match(NL); - } - } - setState(1386); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1387); - match(COLON); - setState(1391); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1388); - match(NL); - } - } - setState(1393); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1394); - type(); - } - break; - } - setState(1400); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1397); - match(NL); - } - } - setState(1402); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1403); - functionBody(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ParametersWithOptionalTypeContext extends ParserRuleContext { - public TerminalNode LPAREN() { return getToken(KotlinParser.LPAREN, 0); } - public TerminalNode RPAREN() { return getToken(KotlinParser.RPAREN, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public List functionValueParameterWithOptionalType() { - return getRuleContexts(FunctionValueParameterWithOptionalTypeContext.class); - } - public FunctionValueParameterWithOptionalTypeContext functionValueParameterWithOptionalType(int i) { - return getRuleContext(FunctionValueParameterWithOptionalTypeContext.class,i); - } - public List COMMA() { return getTokens(KotlinParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(KotlinParser.COMMA, i); - } - public ParametersWithOptionalTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_parametersWithOptionalType; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterParametersWithOptionalType(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitParametersWithOptionalType(this); - } - } - - public final ParametersWithOptionalTypeContext parametersWithOptionalType() throws RecognitionException { - ParametersWithOptionalTypeContext _localctx = new ParametersWithOptionalTypeContext(_ctx, getState()); - enterRule(_localctx, 78, RULE_parametersWithOptionalType); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1407); - match(LPAREN); - setState(1411); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,192,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1408); - match(NL); - } - } - } - setState(1413); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,192,_ctx); - } - setState(1443); - _errHandler.sync(this); - _la = _input.LA(1); - if (((((_la - 40)) & ~0x3f) == 0 && ((1L << (_la - 40)) & ((1L << (AT_NO_WS - 40)) | (1L << (AT_PRE_WS - 40)) | (1L << (FILE - 40)) | (1L << (FIELD - 40)) | (1L << (PROPERTY - 40)) | (1L << (GET - 40)) | (1L << (SET - 40)) | (1L << (RECEIVER - 40)) | (1L << (PARAM - 40)) | (1L << (SETPARAM - 40)) | (1L << (DELEGATE - 40)) | (1L << (IMPORT - 40)) | (1L << (CONSTRUCTOR - 40)) | (1L << (BY - 40)) | (1L << (COMPANION - 40)) | (1L << (INIT - 40)) | (1L << (WHERE - 40)) | (1L << (CATCH - 40)) | (1L << (FINALLY - 40)))) != 0) || ((((_la - 105)) & ~0x3f) == 0 && ((1L << (_la - 105)) & ((1L << (OUT - 105)) | (1L << (DYNAMIC - 105)) | (1L << (PUBLIC - 105)) | (1L << (PRIVATE - 105)) | (1L << (PROTECTED - 105)) | (1L << (INTERNAL - 105)) | (1L << (ENUM - 105)) | (1L << (SEALED - 105)) | (1L << (ANNOTATION - 105)) | (1L << (DATA - 105)) | (1L << (INNER - 105)) | (1L << (VALUE - 105)) | (1L << (TAILREC - 105)) | (1L << (OPERATOR - 105)) | (1L << (INLINE - 105)) | (1L << (INFIX - 105)) | (1L << (EXTERNAL - 105)) | (1L << (SUSPEND - 105)) | (1L << (OVERRIDE - 105)) | (1L << (ABSTRACT - 105)) | (1L << (FINAL - 105)) | (1L << (OPEN - 105)) | (1L << (CONST - 105)) | (1L << (LATEINIT - 105)) | (1L << (VARARG - 105)) | (1L << (NOINLINE - 105)) | (1L << (CROSSINLINE - 105)) | (1L << (REIFIED - 105)) | (1L << (EXPECT - 105)) | (1L << (ACTUAL - 105)) | (1L << (Identifier - 105)))) != 0)) { - { - setState(1414); - functionValueParameterWithOptionalType(); - setState(1431); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,195,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1418); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1415); - match(NL); - } - } - setState(1420); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1421); - match(COMMA); - setState(1425); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1422); - match(NL); - } - } - setState(1427); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1428); - functionValueParameterWithOptionalType(); - } - } - } - setState(1433); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,195,_ctx); - } - setState(1441); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,197,_ctx) ) { - case 1: - { - setState(1437); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1434); - match(NL); - } - } - setState(1439); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1440); - match(COMMA); - } - break; - } - } - } - - setState(1448); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1445); - match(NL); - } - } - setState(1450); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1451); - match(RPAREN); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class FunctionValueParameterWithOptionalTypeContext extends ParserRuleContext { - public ParameterWithOptionalTypeContext parameterWithOptionalType() { - return getRuleContext(ParameterWithOptionalTypeContext.class,0); - } - public ParameterModifiersContext parameterModifiers() { - return getRuleContext(ParameterModifiersContext.class,0); - } - public TerminalNode ASSIGNMENT() { return getToken(KotlinParser.ASSIGNMENT, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public FunctionValueParameterWithOptionalTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_functionValueParameterWithOptionalType; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterFunctionValueParameterWithOptionalType(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitFunctionValueParameterWithOptionalType(this); - } - } - - public final FunctionValueParameterWithOptionalTypeContext functionValueParameterWithOptionalType() throws RecognitionException { - FunctionValueParameterWithOptionalTypeContext _localctx = new FunctionValueParameterWithOptionalTypeContext(_ctx, getState()); - enterRule(_localctx, 80, RULE_functionValueParameterWithOptionalType); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1454); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,200,_ctx) ) { - case 1: - { - setState(1453); - parameterModifiers(); - } - break; - } - setState(1456); - parameterWithOptionalType(); - setState(1471); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,203,_ctx) ) { - case 1: - { - setState(1460); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1457); - match(NL); - } - } - setState(1462); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1463); - match(ASSIGNMENT); - setState(1467); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1464); - match(NL); - } - } - setState(1469); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1470); - expression(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ParameterWithOptionalTypeContext extends ParserRuleContext { - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public ParameterWithOptionalTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_parameterWithOptionalType; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterParameterWithOptionalType(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitParameterWithOptionalType(this); - } - } - - public final ParameterWithOptionalTypeContext parameterWithOptionalType() throws RecognitionException { - ParameterWithOptionalTypeContext _localctx = new ParameterWithOptionalTypeContext(_ctx, getState()); - enterRule(_localctx, 82, RULE_parameterWithOptionalType); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1473); - simpleIdentifier(); - setState(1477); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,204,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1474); - match(NL); - } - } - } - setState(1479); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,204,_ctx); - } - setState(1488); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COLON) { - { - setState(1480); - match(COLON); - setState(1484); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1481); - match(NL); - } - } - setState(1486); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1487); - type(); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ParameterContext extends ParserRuleContext { - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public ParameterContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_parameter; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterParameter(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitParameter(this); - } - } - - public final ParameterContext parameter() throws RecognitionException { - ParameterContext _localctx = new ParameterContext(_ctx, getState()); - enterRule(_localctx, 84, RULE_parameter); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1490); - simpleIdentifier(); - setState(1494); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1491); - match(NL); - } - } - setState(1496); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1497); - match(COLON); - setState(1501); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1498); - match(NL); - } - } - setState(1503); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1504); - type(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ObjectDeclarationContext extends ParserRuleContext { - public TerminalNode OBJECT() { return getToken(KotlinParser.OBJECT, 0); } - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public ModifiersContext modifiers() { - return getRuleContext(ModifiersContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public DelegationSpecifiersContext delegationSpecifiers() { - return getRuleContext(DelegationSpecifiersContext.class,0); - } - public ClassBodyContext classBody() { - return getRuleContext(ClassBodyContext.class,0); - } - public ObjectDeclarationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_objectDeclaration; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterObjectDeclaration(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitObjectDeclaration(this); - } - } - - public final ObjectDeclarationContext objectDeclaration() throws RecognitionException { - ObjectDeclarationContext _localctx = new ObjectDeclarationContext(_ctx, getState()); - enterRule(_localctx, 86, RULE_objectDeclaration); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1507); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==AT_NO_WS || _la==AT_PRE_WS || ((((_la - 107)) & ~0x3f) == 0 && ((1L << (_la - 107)) & ((1L << (PUBLIC - 107)) | (1L << (PRIVATE - 107)) | (1L << (PROTECTED - 107)) | (1L << (INTERNAL - 107)) | (1L << (ENUM - 107)) | (1L << (SEALED - 107)) | (1L << (ANNOTATION - 107)) | (1L << (DATA - 107)) | (1L << (INNER - 107)) | (1L << (VALUE - 107)) | (1L << (TAILREC - 107)) | (1L << (OPERATOR - 107)) | (1L << (INLINE - 107)) | (1L << (INFIX - 107)) | (1L << (EXTERNAL - 107)) | (1L << (SUSPEND - 107)) | (1L << (OVERRIDE - 107)) | (1L << (ABSTRACT - 107)) | (1L << (FINAL - 107)) | (1L << (OPEN - 107)) | (1L << (CONST - 107)) | (1L << (LATEINIT - 107)) | (1L << (VARARG - 107)) | (1L << (NOINLINE - 107)) | (1L << (CROSSINLINE - 107)) | (1L << (EXPECT - 107)) | (1L << (ACTUAL - 107)))) != 0)) { - { - setState(1506); - modifiers(); - } - } - - setState(1509); - match(OBJECT); - setState(1513); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1510); - match(NL); - } - } - setState(1515); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1516); - simpleIdentifier(); - setState(1531); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,213,_ctx) ) { - case 1: - { - setState(1520); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1517); - match(NL); - } - } - setState(1522); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1523); - match(COLON); - setState(1527); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,212,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1524); - match(NL); - } - } - } - setState(1529); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,212,_ctx); - } - setState(1530); - delegationSpecifiers(); - } - break; - } - setState(1540); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,215,_ctx) ) { - case 1: - { - setState(1536); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1533); - match(NL); - } - } - setState(1538); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1539); - classBody(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class SecondaryConstructorContext extends ParserRuleContext { - public TerminalNode CONSTRUCTOR() { return getToken(KotlinParser.CONSTRUCTOR, 0); } - public FunctionValueParametersContext functionValueParameters() { - return getRuleContext(FunctionValueParametersContext.class,0); - } - public ModifiersContext modifiers() { - return getRuleContext(ModifiersContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public ConstructorDelegationCallContext constructorDelegationCall() { - return getRuleContext(ConstructorDelegationCallContext.class,0); - } - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public SecondaryConstructorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_secondaryConstructor; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterSecondaryConstructor(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitSecondaryConstructor(this); - } - } - - public final SecondaryConstructorContext secondaryConstructor() throws RecognitionException { - SecondaryConstructorContext _localctx = new SecondaryConstructorContext(_ctx, getState()); - enterRule(_localctx, 88, RULE_secondaryConstructor); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1543); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==AT_NO_WS || _la==AT_PRE_WS || ((((_la - 107)) & ~0x3f) == 0 && ((1L << (_la - 107)) & ((1L << (PUBLIC - 107)) | (1L << (PRIVATE - 107)) | (1L << (PROTECTED - 107)) | (1L << (INTERNAL - 107)) | (1L << (ENUM - 107)) | (1L << (SEALED - 107)) | (1L << (ANNOTATION - 107)) | (1L << (DATA - 107)) | (1L << (INNER - 107)) | (1L << (VALUE - 107)) | (1L << (TAILREC - 107)) | (1L << (OPERATOR - 107)) | (1L << (INLINE - 107)) | (1L << (INFIX - 107)) | (1L << (EXTERNAL - 107)) | (1L << (SUSPEND - 107)) | (1L << (OVERRIDE - 107)) | (1L << (ABSTRACT - 107)) | (1L << (FINAL - 107)) | (1L << (OPEN - 107)) | (1L << (CONST - 107)) | (1L << (LATEINIT - 107)) | (1L << (VARARG - 107)) | (1L << (NOINLINE - 107)) | (1L << (CROSSINLINE - 107)) | (1L << (EXPECT - 107)) | (1L << (ACTUAL - 107)))) != 0)) { - { - setState(1542); - modifiers(); - } - } - - setState(1545); - match(CONSTRUCTOR); - setState(1549); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1546); - match(NL); - } - } - setState(1551); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1552); - functionValueParameters(); - setState(1567); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,220,_ctx) ) { - case 1: - { - setState(1556); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1553); - match(NL); - } - } - setState(1558); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1559); - match(COLON); - setState(1563); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1560); - match(NL); - } - } - setState(1565); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1566); - constructorDelegationCall(); - } - break; - } - setState(1572); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,221,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1569); - match(NL); - } - } - } - setState(1574); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,221,_ctx); - } - setState(1576); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==LCURL) { - { - setState(1575); - block(); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ConstructorDelegationCallContext extends ParserRuleContext { - public ValueArgumentsContext valueArguments() { - return getRuleContext(ValueArgumentsContext.class,0); - } - public TerminalNode THIS() { return getToken(KotlinParser.THIS, 0); } - public TerminalNode SUPER() { return getToken(KotlinParser.SUPER, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public ConstructorDelegationCallContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_constructorDelegationCall; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterConstructorDelegationCall(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitConstructorDelegationCall(this); - } - } - - public final ConstructorDelegationCallContext constructorDelegationCall() throws RecognitionException { - ConstructorDelegationCallContext _localctx = new ConstructorDelegationCallContext(_ctx, getState()); - enterRule(_localctx, 90, RULE_constructorDelegationCall); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1578); - _la = _input.LA(1); - if ( !(_la==THIS || _la==SUPER) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(1582); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1579); - match(NL); - } - } - setState(1584); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1585); - valueArguments(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class EnumClassBodyContext extends ParserRuleContext { - public TerminalNode LCURL() { return getToken(KotlinParser.LCURL, 0); } - public TerminalNode RCURL() { return getToken(KotlinParser.RCURL, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public EnumEntriesContext enumEntries() { - return getRuleContext(EnumEntriesContext.class,0); - } - public TerminalNode SEMICOLON() { return getToken(KotlinParser.SEMICOLON, 0); } - public ClassMemberDeclarationsContext classMemberDeclarations() { - return getRuleContext(ClassMemberDeclarationsContext.class,0); - } - public EnumClassBodyContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_enumClassBody; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterEnumClassBody(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitEnumClassBody(this); - } - } - - public final EnumClassBodyContext enumClassBody() throws RecognitionException { - EnumClassBodyContext _localctx = new EnumClassBodyContext(_ctx, getState()); - enterRule(_localctx, 92, RULE_enumClassBody); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1587); - match(LCURL); - setState(1591); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,224,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1588); - match(NL); - } - } - } - setState(1593); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,224,_ctx); - } - setState(1595); - _errHandler.sync(this); - _la = _input.LA(1); - if (((((_la - 40)) & ~0x3f) == 0 && ((1L << (_la - 40)) & ((1L << (AT_NO_WS - 40)) | (1L << (AT_PRE_WS - 40)) | (1L << (FILE - 40)) | (1L << (FIELD - 40)) | (1L << (PROPERTY - 40)) | (1L << (GET - 40)) | (1L << (SET - 40)) | (1L << (RECEIVER - 40)) | (1L << (PARAM - 40)) | (1L << (SETPARAM - 40)) | (1L << (DELEGATE - 40)) | (1L << (IMPORT - 40)) | (1L << (CONSTRUCTOR - 40)) | (1L << (BY - 40)) | (1L << (COMPANION - 40)) | (1L << (INIT - 40)) | (1L << (WHERE - 40)) | (1L << (CATCH - 40)) | (1L << (FINALLY - 40)))) != 0) || ((((_la - 105)) & ~0x3f) == 0 && ((1L << (_la - 105)) & ((1L << (OUT - 105)) | (1L << (DYNAMIC - 105)) | (1L << (PUBLIC - 105)) | (1L << (PRIVATE - 105)) | (1L << (PROTECTED - 105)) | (1L << (INTERNAL - 105)) | (1L << (ENUM - 105)) | (1L << (SEALED - 105)) | (1L << (ANNOTATION - 105)) | (1L << (DATA - 105)) | (1L << (INNER - 105)) | (1L << (VALUE - 105)) | (1L << (TAILREC - 105)) | (1L << (OPERATOR - 105)) | (1L << (INLINE - 105)) | (1L << (INFIX - 105)) | (1L << (EXTERNAL - 105)) | (1L << (SUSPEND - 105)) | (1L << (OVERRIDE - 105)) | (1L << (ABSTRACT - 105)) | (1L << (FINAL - 105)) | (1L << (OPEN - 105)) | (1L << (CONST - 105)) | (1L << (LATEINIT - 105)) | (1L << (VARARG - 105)) | (1L << (NOINLINE - 105)) | (1L << (CROSSINLINE - 105)) | (1L << (REIFIED - 105)) | (1L << (EXPECT - 105)) | (1L << (ACTUAL - 105)) | (1L << (Identifier - 105)))) != 0)) { - { - setState(1594); - enumEntries(); - } - } - - setState(1611); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,228,_ctx) ) { - case 1: - { - setState(1600); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1597); - match(NL); - } - } - setState(1602); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1603); - match(SEMICOLON); - setState(1607); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,227,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1604); - match(NL); - } - } - } - setState(1609); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,227,_ctx); - } - setState(1610); - classMemberDeclarations(); - } - break; - } - setState(1616); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1613); - match(NL); - } - } - setState(1618); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1619); - match(RCURL); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class EnumEntriesContext extends ParserRuleContext { - public List enumEntry() { - return getRuleContexts(EnumEntryContext.class); - } - public EnumEntryContext enumEntry(int i) { - return getRuleContext(EnumEntryContext.class,i); - } - public List COMMA() { return getTokens(KotlinParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(KotlinParser.COMMA, i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public EnumEntriesContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_enumEntries; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterEnumEntries(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitEnumEntries(this); - } - } - - public final EnumEntriesContext enumEntries() throws RecognitionException { - EnumEntriesContext _localctx = new EnumEntriesContext(_ctx, getState()); - enterRule(_localctx, 94, RULE_enumEntries); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1621); - enumEntry(); - setState(1638); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,232,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1625); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1622); - match(NL); - } - } - setState(1627); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1628); - match(COMMA); - setState(1632); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1629); - match(NL); - } - } - setState(1634); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1635); - enumEntry(); - } - } - } - setState(1640); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,232,_ctx); - } - setState(1644); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,233,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1641); - match(NL); - } - } - } - setState(1646); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,233,_ctx); - } - setState(1648); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==COMMA) { - { - setState(1647); - match(COMMA); - } - } - - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class EnumEntryContext extends ParserRuleContext { - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public ModifiersContext modifiers() { - return getRuleContext(ModifiersContext.class,0); - } - public ValueArgumentsContext valueArguments() { - return getRuleContext(ValueArgumentsContext.class,0); - } - public ClassBodyContext classBody() { - return getRuleContext(ClassBodyContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public EnumEntryContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_enumEntry; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterEnumEntry(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitEnumEntry(this); - } - } - - public final EnumEntryContext enumEntry() throws RecognitionException { - EnumEntryContext _localctx = new EnumEntryContext(_ctx, getState()); - enterRule(_localctx, 96, RULE_enumEntry); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1657); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,236,_ctx) ) { - case 1: - { - setState(1650); - modifiers(); - setState(1654); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1651); - match(NL); - } - } - setState(1656); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - break; - } - setState(1659); - simpleIdentifier(); - setState(1667); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,238,_ctx) ) { - case 1: - { - setState(1663); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1660); - match(NL); - } - } - setState(1665); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1666); - valueArguments(); - } - break; - } - setState(1676); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,240,_ctx) ) { - case 1: - { - setState(1672); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1669); - match(NL); - } - } - setState(1674); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1675); - classBody(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TypeContext extends ParserRuleContext { - public ParenthesizedTypeContext parenthesizedType() { - return getRuleContext(ParenthesizedTypeContext.class,0); - } - public NullableTypeContext nullableType() { - return getRuleContext(NullableTypeContext.class,0); - } - public TypeReferenceContext typeReference() { - return getRuleContext(TypeReferenceContext.class,0); - } - public FunctionTypeContext functionType() { - return getRuleContext(FunctionTypeContext.class,0); - } - public TypeModifiersContext typeModifiers() { - return getRuleContext(TypeModifiersContext.class,0); - } - public TypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_type; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterType(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitType(this); - } - } - - public final TypeContext type() throws RecognitionException { - TypeContext _localctx = new TypeContext(_ctx, getState()); - enterRule(_localctx, 98, RULE_type); - try { - enterOuterAlt(_localctx, 1); - { - setState(1679); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,241,_ctx) ) { - case 1: - { - setState(1678); - typeModifiers(); - } - break; - } - setState(1685); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,242,_ctx) ) { - case 1: - { - setState(1681); - parenthesizedType(); - } - break; - case 2: - { - setState(1682); - nullableType(); - } - break; - case 3: - { - setState(1683); - typeReference(); - } - break; - case 4: - { - setState(1684); - functionType(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TypeReferenceContext extends ParserRuleContext { - public UserTypeContext userType() { - return getRuleContext(UserTypeContext.class,0); - } - public TerminalNode DYNAMIC() { return getToken(KotlinParser.DYNAMIC, 0); } - public TypeReferenceContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeReference; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterTypeReference(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitTypeReference(this); - } - } - - public final TypeReferenceContext typeReference() throws RecognitionException { - TypeReferenceContext _localctx = new TypeReferenceContext(_ctx, getState()); - enterRule(_localctx, 100, RULE_typeReference); - try { - setState(1689); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,243,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1687); - userType(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1688); - match(DYNAMIC); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class NullableTypeContext extends ParserRuleContext { - public TypeReferenceContext typeReference() { - return getRuleContext(TypeReferenceContext.class,0); - } - public ParenthesizedTypeContext parenthesizedType() { - return getRuleContext(ParenthesizedTypeContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public List quest() { - return getRuleContexts(QuestContext.class); - } - public QuestContext quest(int i) { - return getRuleContext(QuestContext.class,i); - } - public NullableTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_nullableType; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterNullableType(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitNullableType(this); - } - } - - public final NullableTypeContext nullableType() throws RecognitionException { - NullableTypeContext _localctx = new NullableTypeContext(_ctx, getState()); - enterRule(_localctx, 102, RULE_nullableType); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1693); - _errHandler.sync(this); - switch (_input.LA(1)) { - case FILE: - case FIELD: - case PROPERTY: - case GET: - case SET: - case RECEIVER: - case PARAM: - case SETPARAM: - case DELEGATE: - case IMPORT: - case CONSTRUCTOR: - case BY: - case COMPANION: - case INIT: - case WHERE: - case CATCH: - case FINALLY: - case OUT: - case DYNAMIC: - case PUBLIC: - case PRIVATE: - case PROTECTED: - case INTERNAL: - case ENUM: - case SEALED: - case ANNOTATION: - case DATA: - case INNER: - case VALUE: - case TAILREC: - case OPERATOR: - case INLINE: - case INFIX: - case EXTERNAL: - case SUSPEND: - case OVERRIDE: - case ABSTRACT: - case FINAL: - case OPEN: - case CONST: - case LATEINIT: - case VARARG: - case NOINLINE: - case CROSSINLINE: - case REIFIED: - case EXPECT: - case ACTUAL: - case Identifier: - { - setState(1691); - typeReference(); - } - break; - case LPAREN: - { - setState(1692); - parenthesizedType(); - } - break; - default: - throw new NoViableAltException(this); - } - setState(1698); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1695); - match(NL); - } - } - setState(1700); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1702); - _errHandler.sync(this); - _alt = 1; - do { - switch (_alt) { - case 1: - { - { - setState(1701); - quest(); - } - } - break; - default: - throw new NoViableAltException(this); - } - setState(1704); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,246,_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 QuestContext extends ParserRuleContext { - public TerminalNode QUEST_NO_WS() { return getToken(KotlinParser.QUEST_NO_WS, 0); } - public TerminalNode QUEST_WS() { return getToken(KotlinParser.QUEST_WS, 0); } - public QuestContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_quest; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterQuest(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitQuest(this); - } - } - - public final QuestContext quest() throws RecognitionException { - QuestContext _localctx = new QuestContext(_ctx, getState()); - enterRule(_localctx, 104, RULE_quest); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1706); - _la = _input.LA(1); - if ( !(_la==QUEST_WS || _la==QUEST_NO_WS) ) { - _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 UserTypeContext extends ParserRuleContext { - public List simpleUserType() { - return getRuleContexts(SimpleUserTypeContext.class); - } - public SimpleUserTypeContext simpleUserType(int i) { - return getRuleContext(SimpleUserTypeContext.class,i); - } - public List DOT() { return getTokens(KotlinParser.DOT); } - public TerminalNode DOT(int i) { - return getToken(KotlinParser.DOT, i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public UserTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_userType; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterUserType(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitUserType(this); - } - } - - public final UserTypeContext userType() throws RecognitionException { - UserTypeContext _localctx = new UserTypeContext(_ctx, getState()); - enterRule(_localctx, 106, RULE_userType); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1708); - simpleUserType(); - setState(1725); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,249,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1712); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1709); - match(NL); - } - } - setState(1714); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1715); - match(DOT); - setState(1719); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1716); - match(NL); - } - } - setState(1721); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1722); - simpleUserType(); - } - } - } - setState(1727); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,249,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class SimpleUserTypeContext extends ParserRuleContext { - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public TypeArgumentsContext typeArguments() { - return getRuleContext(TypeArgumentsContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public SimpleUserTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_simpleUserType; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterSimpleUserType(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitSimpleUserType(this); - } - } - - public final SimpleUserTypeContext simpleUserType() throws RecognitionException { - SimpleUserTypeContext _localctx = new SimpleUserTypeContext(_ctx, getState()); - enterRule(_localctx, 108, RULE_simpleUserType); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1728); - simpleIdentifier(); - setState(1736); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,251,_ctx) ) { - case 1: - { - setState(1732); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1729); - match(NL); - } - } - setState(1734); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1735); - typeArguments(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TypeProjectionContext extends ParserRuleContext { - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public TypeProjectionModifiersContext typeProjectionModifiers() { - return getRuleContext(TypeProjectionModifiersContext.class,0); - } - public TerminalNode MULT() { return getToken(KotlinParser.MULT, 0); } - public TypeProjectionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeProjection; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterTypeProjection(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitTypeProjection(this); - } - } - - public final TypeProjectionContext typeProjection() throws RecognitionException { - TypeProjectionContext _localctx = new TypeProjectionContext(_ctx, getState()); - enterRule(_localctx, 110, RULE_typeProjection); - try { - setState(1743); - _errHandler.sync(this); - switch (_input.LA(1)) { - case LPAREN: - case AT_NO_WS: - case AT_PRE_WS: - case FILE: - case FIELD: - case PROPERTY: - case GET: - case SET: - case RECEIVER: - case PARAM: - case SETPARAM: - case DELEGATE: - case IMPORT: - case CONSTRUCTOR: - case BY: - case COMPANION: - case INIT: - case WHERE: - case CATCH: - case FINALLY: - case IN: - case OUT: - case DYNAMIC: - case PUBLIC: - case PRIVATE: - case PROTECTED: - case INTERNAL: - case ENUM: - case SEALED: - case ANNOTATION: - case DATA: - case INNER: - case VALUE: - case TAILREC: - case OPERATOR: - case INLINE: - case INFIX: - case EXTERNAL: - case SUSPEND: - case OVERRIDE: - case ABSTRACT: - case FINAL: - case OPEN: - case CONST: - case LATEINIT: - case VARARG: - case NOINLINE: - case CROSSINLINE: - case REIFIED: - case EXPECT: - case ACTUAL: - case Identifier: - enterOuterAlt(_localctx, 1); - { - setState(1739); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,252,_ctx) ) { - case 1: - { - setState(1738); - typeProjectionModifiers(); - } - break; - } - setState(1741); - type(); - } - break; - case MULT: - enterOuterAlt(_localctx, 2); - { - setState(1742); - match(MULT); - } - 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 TypeProjectionModifiersContext extends ParserRuleContext { - public List typeProjectionModifier() { - return getRuleContexts(TypeProjectionModifierContext.class); - } - public TypeProjectionModifierContext typeProjectionModifier(int i) { - return getRuleContext(TypeProjectionModifierContext.class,i); - } - public TypeProjectionModifiersContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeProjectionModifiers; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterTypeProjectionModifiers(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitTypeProjectionModifiers(this); - } - } - - public final TypeProjectionModifiersContext typeProjectionModifiers() throws RecognitionException { - TypeProjectionModifiersContext _localctx = new TypeProjectionModifiersContext(_ctx, getState()); - enterRule(_localctx, 112, RULE_typeProjectionModifiers); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1746); - _errHandler.sync(this); - _alt = 1; - do { - switch (_alt) { - case 1: - { - { - setState(1745); - typeProjectionModifier(); - } - } - break; - default: - throw new NoViableAltException(this); - } - setState(1748); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,254,_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 TypeProjectionModifierContext extends ParserRuleContext { - public VarianceModifierContext varianceModifier() { - return getRuleContext(VarianceModifierContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public AnnotationContext annotation() { - return getRuleContext(AnnotationContext.class,0); - } - public TypeProjectionModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeProjectionModifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterTypeProjectionModifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitTypeProjectionModifier(this); - } - } - - public final TypeProjectionModifierContext typeProjectionModifier() throws RecognitionException { - TypeProjectionModifierContext _localctx = new TypeProjectionModifierContext(_ctx, getState()); - enterRule(_localctx, 114, RULE_typeProjectionModifier); - int _la; - try { - setState(1758); - _errHandler.sync(this); - switch (_input.LA(1)) { - case IN: - case OUT: - enterOuterAlt(_localctx, 1); - { - setState(1750); - varianceModifier(); - setState(1754); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1751); - match(NL); - } - } - setState(1756); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - break; - case AT_NO_WS: - case AT_PRE_WS: - enterOuterAlt(_localctx, 2); - { - setState(1757); - annotation(); - } - 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 FunctionTypeContext extends ParserRuleContext { - public FunctionTypeParametersContext functionTypeParameters() { - return getRuleContext(FunctionTypeParametersContext.class,0); - } - public TerminalNode ARROW() { return getToken(KotlinParser.ARROW, 0); } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public ReceiverTypeContext receiverType() { - return getRuleContext(ReceiverTypeContext.class,0); - } - public TerminalNode DOT() { return getToken(KotlinParser.DOT, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public FunctionTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_functionType; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterFunctionType(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitFunctionType(this); - } - } - - public final FunctionTypeContext functionType() throws RecognitionException { - FunctionTypeContext _localctx = new FunctionTypeContext(_ctx, getState()); - enterRule(_localctx, 116, RULE_functionType); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1774); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,259,_ctx) ) { - case 1: - { - setState(1760); - receiverType(); - setState(1764); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1761); - match(NL); - } - } - setState(1766); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1767); - match(DOT); - setState(1771); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1768); - match(NL); - } - } - setState(1773); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - break; - } - setState(1776); - functionTypeParameters(); - setState(1780); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1777); - match(NL); - } - } - setState(1782); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1783); - match(ARROW); - setState(1787); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1784); - match(NL); - } - } - setState(1789); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1790); - type(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class FunctionTypeParametersContext extends ParserRuleContext { - public TerminalNode LPAREN() { return getToken(KotlinParser.LPAREN, 0); } - public TerminalNode RPAREN() { return getToken(KotlinParser.RPAREN, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public List parameter() { - return getRuleContexts(ParameterContext.class); - } - public ParameterContext parameter(int i) { - return getRuleContext(ParameterContext.class,i); - } - public List type() { - return getRuleContexts(TypeContext.class); - } - public TypeContext type(int i) { - return getRuleContext(TypeContext.class,i); - } - public List COMMA() { return getTokens(KotlinParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(KotlinParser.COMMA, i); - } - public FunctionTypeParametersContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_functionTypeParameters; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterFunctionTypeParameters(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitFunctionTypeParameters(this); - } - } - - public final FunctionTypeParametersContext functionTypeParameters() throws RecognitionException { - FunctionTypeParametersContext _localctx = new FunctionTypeParametersContext(_ctx, getState()); - enterRule(_localctx, 118, RULE_functionTypeParameters); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1792); - match(LPAREN); - setState(1796); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,262,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1793); - match(NL); - } - } - } - setState(1798); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,262,_ctx); - } - setState(1801); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,263,_ctx) ) { - case 1: - { - setState(1799); - parameter(); - } - break; - case 2: - { - setState(1800); - type(); - } - break; - } - setState(1822); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,267,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1806); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1803); - match(NL); - } - } - setState(1808); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1809); - match(COMMA); - setState(1813); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1810); - match(NL); - } - } - setState(1815); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1818); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,266,_ctx) ) { - case 1: - { - setState(1816); - parameter(); - } - break; - case 2: - { - setState(1817); - type(); - } - break; - } - } - } - } - setState(1824); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,267,_ctx); - } - setState(1832); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,269,_ctx) ) { - case 1: - { - setState(1828); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1825); - match(NL); - } - } - setState(1830); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1831); - match(COMMA); - } - break; - } - setState(1837); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1834); - match(NL); - } - } - setState(1839); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1840); - match(RPAREN); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ParenthesizedTypeContext extends ParserRuleContext { - public TerminalNode LPAREN() { return getToken(KotlinParser.LPAREN, 0); } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public TerminalNode RPAREN() { return getToken(KotlinParser.RPAREN, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public ParenthesizedTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_parenthesizedType; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterParenthesizedType(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitParenthesizedType(this); - } - } - - public final ParenthesizedTypeContext parenthesizedType() throws RecognitionException { - ParenthesizedTypeContext _localctx = new ParenthesizedTypeContext(_ctx, getState()); - enterRule(_localctx, 120, RULE_parenthesizedType); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1842); - match(LPAREN); - setState(1846); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1843); - match(NL); - } - } - setState(1848); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1849); - type(); - setState(1853); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1850); - match(NL); - } - } - setState(1855); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1856); - match(RPAREN); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ReceiverTypeContext extends ParserRuleContext { - public ParenthesizedTypeContext parenthesizedType() { - return getRuleContext(ParenthesizedTypeContext.class,0); - } - public NullableTypeContext nullableType() { - return getRuleContext(NullableTypeContext.class,0); - } - public TypeReferenceContext typeReference() { - return getRuleContext(TypeReferenceContext.class,0); - } - public TypeModifiersContext typeModifiers() { - return getRuleContext(TypeModifiersContext.class,0); - } - public ReceiverTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_receiverType; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterReceiverType(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitReceiverType(this); - } - } - - public final ReceiverTypeContext receiverType() throws RecognitionException { - ReceiverTypeContext _localctx = new ReceiverTypeContext(_ctx, getState()); - enterRule(_localctx, 122, RULE_receiverType); - try { - enterOuterAlt(_localctx, 1); - { - setState(1859); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,273,_ctx) ) { - case 1: - { - setState(1858); - typeModifiers(); - } - break; - } - setState(1864); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,274,_ctx) ) { - case 1: - { - setState(1861); - parenthesizedType(); - } - break; - case 2: - { - setState(1862); - nullableType(); - } - break; - case 3: - { - setState(1863); - typeReference(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ParenthesizedUserTypeContext extends ParserRuleContext { - public TerminalNode LPAREN() { return getToken(KotlinParser.LPAREN, 0); } - public TerminalNode RPAREN() { return getToken(KotlinParser.RPAREN, 0); } - public UserTypeContext userType() { - return getRuleContext(UserTypeContext.class,0); - } - public ParenthesizedUserTypeContext parenthesizedUserType() { - return getRuleContext(ParenthesizedUserTypeContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public ParenthesizedUserTypeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_parenthesizedUserType; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterParenthesizedUserType(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitParenthesizedUserType(this); - } - } - - public final ParenthesizedUserTypeContext parenthesizedUserType() throws RecognitionException { - ParenthesizedUserTypeContext _localctx = new ParenthesizedUserTypeContext(_ctx, getState()); - enterRule(_localctx, 124, RULE_parenthesizedUserType); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1866); - match(LPAREN); - setState(1870); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1867); - match(NL); - } - } - setState(1872); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1875); - _errHandler.sync(this); - switch (_input.LA(1)) { - case FILE: - case FIELD: - case PROPERTY: - case GET: - case SET: - case RECEIVER: - case PARAM: - case SETPARAM: - case DELEGATE: - case IMPORT: - case CONSTRUCTOR: - case BY: - case COMPANION: - case INIT: - case WHERE: - case CATCH: - case FINALLY: - case OUT: - case DYNAMIC: - case PUBLIC: - case PRIVATE: - case PROTECTED: - case INTERNAL: - case ENUM: - case SEALED: - case ANNOTATION: - case DATA: - case INNER: - case VALUE: - case TAILREC: - case OPERATOR: - case INLINE: - case INFIX: - case EXTERNAL: - case SUSPEND: - case OVERRIDE: - case ABSTRACT: - case FINAL: - case OPEN: - case CONST: - case LATEINIT: - case VARARG: - case NOINLINE: - case CROSSINLINE: - case REIFIED: - case EXPECT: - case ACTUAL: - case Identifier: - { - setState(1873); - userType(); - } - break; - case LPAREN: - { - setState(1874); - parenthesizedUserType(); - } - break; - default: - throw new NoViableAltException(this); - } - setState(1880); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1877); - match(NL); - } - } - setState(1882); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1883); - match(RPAREN); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class StatementsContext extends ParserRuleContext { - public List statement() { - return getRuleContexts(StatementContext.class); - } - public StatementContext statement(int i) { - return getRuleContext(StatementContext.class,i); - } - public List semis() { - return getRuleContexts(SemisContext.class); - } - public SemisContext semis(int i) { - return getRuleContext(SemisContext.class,i); - } - public StatementsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_statements; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterStatements(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitStatements(this); - } - } - - public final StatementsContext statements() throws RecognitionException { - StatementsContext _localctx = new StatementsContext(_ctx, getState()); - enterRule(_localctx, 126, RULE_statements); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1894); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LPAREN) | (1L << LSQUARE) | (1L << LCURL) | (1L << ADD) | (1L << SUB) | (1L << INCR) | (1L << DECR) | (1L << EXCL_WS) | (1L << EXCL_NO_WS) | (1L << COLONCOLON) | (1L << AT_NO_WS) | (1L << AT_PRE_WS) | (1L << RETURN_AT) | (1L << CONTINUE_AT) | (1L << BREAK_AT) | (1L << THIS_AT) | (1L << SUPER_AT) | (1L << FILE) | (1L << FIELD) | (1L << PROPERTY))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (GET - 64)) | (1L << (SET - 64)) | (1L << (RECEIVER - 64)) | (1L << (PARAM - 64)) | (1L << (SETPARAM - 64)) | (1L << (DELEGATE - 64)) | (1L << (IMPORT - 64)) | (1L << (CLASS - 64)) | (1L << (INTERFACE - 64)) | (1L << (FUN - 64)) | (1L << (OBJECT - 64)) | (1L << (VAL - 64)) | (1L << (VAR - 64)) | (1L << (TYPE_ALIAS - 64)) | (1L << (CONSTRUCTOR - 64)) | (1L << (BY - 64)) | (1L << (COMPANION - 64)) | (1L << (INIT - 64)) | (1L << (THIS - 64)) | (1L << (SUPER - 64)) | (1L << (WHERE - 64)) | (1L << (IF - 64)) | (1L << (WHEN - 64)) | (1L << (TRY - 64)) | (1L << (CATCH - 64)) | (1L << (FINALLY - 64)) | (1L << (FOR - 64)) | (1L << (DO - 64)) | (1L << (WHILE - 64)) | (1L << (THROW - 64)) | (1L << (RETURN - 64)) | (1L << (CONTINUE - 64)) | (1L << (BREAK - 64)) | (1L << (OUT - 64)) | (1L << (DYNAMIC - 64)) | (1L << (PUBLIC - 64)) | (1L << (PRIVATE - 64)) | (1L << (PROTECTED - 64)) | (1L << (INTERNAL - 64)) | (1L << (ENUM - 64)) | (1L << (SEALED - 64)) | (1L << (ANNOTATION - 64)) | (1L << (DATA - 64)) | (1L << (INNER - 64)) | (1L << (VALUE - 64)) | (1L << (TAILREC - 64)) | (1L << (OPERATOR - 64)) | (1L << (INLINE - 64)) | (1L << (INFIX - 64)) | (1L << (EXTERNAL - 64)) | (1L << (SUSPEND - 64)) | (1L << (OVERRIDE - 64)) | (1L << (ABSTRACT - 64)) | (1L << (FINAL - 64)) | (1L << (OPEN - 64)) | (1L << (CONST - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (LATEINIT - 128)) | (1L << (VARARG - 128)) | (1L << (NOINLINE - 128)) | (1L << (CROSSINLINE - 128)) | (1L << (REIFIED - 128)) | (1L << (EXPECT - 128)) | (1L << (ACTUAL - 128)) | (1L << (RealLiteral - 128)) | (1L << (IntegerLiteral - 128)) | (1L << (HexLiteral - 128)) | (1L << (BinLiteral - 128)) | (1L << (UnsignedLiteral - 128)) | (1L << (LongLiteral - 128)) | (1L << (BooleanLiteral - 128)) | (1L << (NullLiteral - 128)) | (1L << (CharacterLiteral - 128)) | (1L << (Identifier - 128)) | (1L << (QUOTE_OPEN - 128)) | (1L << (TRIPLE_QUOTE_OPEN - 128)))) != 0)) { - { - setState(1885); - statement(); - setState(1891); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,278,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1886); - semis(); - setState(1887); - statement(); - } - } - } - setState(1893); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,278,_ctx); - } - } - } - - setState(1897); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,280,_ctx) ) { - case 1: - { - setState(1896); - semis(); - } - break; - } - } - } - 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 DeclarationContext declaration() { - return getRuleContext(DeclarationContext.class,0); - } - public AssignmentContext assignment() { - return getRuleContext(AssignmentContext.class,0); - } - public LoopStatementContext loopStatement() { - return getRuleContext(LoopStatementContext.class,0); - } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public List label() { - return getRuleContexts(LabelContext.class); - } - public LabelContext label(int i) { - return getRuleContext(LabelContext.class,i); - } - public List annotation() { - return getRuleContexts(AnnotationContext.class); - } - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class,i); - } - public StatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_statement; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitStatement(this); - } - } - - public final StatementContext statement() throws RecognitionException { - StatementContext _localctx = new StatementContext(_ctx, getState()); - enterRule(_localctx, 128, RULE_statement); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1903); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,282,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - setState(1901); - _errHandler.sync(this); - switch (_input.LA(1)) { - case FILE: - case FIELD: - case PROPERTY: - case GET: - case SET: - case RECEIVER: - case PARAM: - case SETPARAM: - case DELEGATE: - case IMPORT: - case CONSTRUCTOR: - case BY: - case COMPANION: - case INIT: - case WHERE: - case CATCH: - case FINALLY: - case OUT: - case DYNAMIC: - case PUBLIC: - case PRIVATE: - case PROTECTED: - case INTERNAL: - case ENUM: - case SEALED: - case ANNOTATION: - case DATA: - case INNER: - case VALUE: - case TAILREC: - case OPERATOR: - case INLINE: - case INFIX: - case EXTERNAL: - case SUSPEND: - case OVERRIDE: - case ABSTRACT: - case FINAL: - case OPEN: - case CONST: - case LATEINIT: - case VARARG: - case NOINLINE: - case CROSSINLINE: - case REIFIED: - case EXPECT: - case ACTUAL: - case Identifier: - { - setState(1899); - label(); - } - break; - case AT_NO_WS: - case AT_PRE_WS: - { - setState(1900); - annotation(); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - setState(1905); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,282,_ctx); - } - setState(1910); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,283,_ctx) ) { - case 1: - { - setState(1906); - declaration(); - } - break; - case 2: - { - setState(1907); - assignment(); - } - break; - case 3: - { - setState(1908); - loopStatement(); - } - break; - case 4: - { - setState(1909); - expression(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class LabelContext extends ParserRuleContext { - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public TerminalNode AT_NO_WS() { return getToken(KotlinParser.AT_NO_WS, 0); } - public TerminalNode AT_POST_WS() { return getToken(KotlinParser.AT_POST_WS, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public LabelContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_label; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterLabel(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitLabel(this); - } - } - - public final LabelContext label() throws RecognitionException { - LabelContext _localctx = new LabelContext(_ctx, getState()); - enterRule(_localctx, 130, RULE_label); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1912); - simpleIdentifier(); - setState(1913); - _la = _input.LA(1); - if ( !(_la==AT_NO_WS || _la==AT_POST_WS) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(1917); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,284,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1914); - match(NL); - } - } - } - setState(1919); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,284,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ControlStructureBodyContext extends ParserRuleContext { - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public StatementContext statement() { - return getRuleContext(StatementContext.class,0); - } - public ControlStructureBodyContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_controlStructureBody; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterControlStructureBody(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitControlStructureBody(this); - } - } - - public final ControlStructureBodyContext controlStructureBody() throws RecognitionException { - ControlStructureBodyContext _localctx = new ControlStructureBodyContext(_ctx, getState()); - enterRule(_localctx, 132, RULE_controlStructureBody); - try { - setState(1922); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,285,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(1920); - block(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(1921); - statement(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class BlockContext extends ParserRuleContext { - public TerminalNode LCURL() { return getToken(KotlinParser.LCURL, 0); } - public StatementsContext statements() { - return getRuleContext(StatementsContext.class,0); - } - public TerminalNode RCURL() { return getToken(KotlinParser.RCURL, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public BlockContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_block; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterBlock(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitBlock(this); - } - } - - public final BlockContext block() throws RecognitionException { - BlockContext _localctx = new BlockContext(_ctx, getState()); - enterRule(_localctx, 134, RULE_block); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1924); - match(LCURL); - setState(1928); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,286,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1925); - match(NL); - } - } - } - setState(1930); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,286,_ctx); - } - setState(1931); - statements(); - setState(1935); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1932); - match(NL); - } - } - setState(1937); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1938); - match(RCURL); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class LoopStatementContext extends ParserRuleContext { - public ForStatementContext forStatement() { - return getRuleContext(ForStatementContext.class,0); - } - public WhileStatementContext whileStatement() { - return getRuleContext(WhileStatementContext.class,0); - } - public DoWhileStatementContext doWhileStatement() { - return getRuleContext(DoWhileStatementContext.class,0); - } - public LoopStatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_loopStatement; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterLoopStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitLoopStatement(this); - } - } - - public final LoopStatementContext loopStatement() throws RecognitionException { - LoopStatementContext _localctx = new LoopStatementContext(_ctx, getState()); - enterRule(_localctx, 136, RULE_loopStatement); - try { - setState(1943); - _errHandler.sync(this); - switch (_input.LA(1)) { - case FOR: - enterOuterAlt(_localctx, 1); - { - setState(1940); - forStatement(); - } - break; - case WHILE: - enterOuterAlt(_localctx, 2); - { - setState(1941); - whileStatement(); - } - break; - case DO: - enterOuterAlt(_localctx, 3); - { - setState(1942); - doWhileStatement(); - } - 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 ForStatementContext extends ParserRuleContext { - public TerminalNode FOR() { return getToken(KotlinParser.FOR, 0); } - public TerminalNode LPAREN() { return getToken(KotlinParser.LPAREN, 0); } - public TerminalNode IN() { return getToken(KotlinParser.IN, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode RPAREN() { return getToken(KotlinParser.RPAREN, 0); } - public VariableDeclarationContext variableDeclaration() { - return getRuleContext(VariableDeclarationContext.class,0); - } - public MultiVariableDeclarationContext multiVariableDeclaration() { - return getRuleContext(MultiVariableDeclarationContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public List annotation() { - return getRuleContexts(AnnotationContext.class); - } - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class,i); - } - public ControlStructureBodyContext controlStructureBody() { - return getRuleContext(ControlStructureBodyContext.class,0); - } - public ForStatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_forStatement; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterForStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitForStatement(this); - } - } - - public final ForStatementContext forStatement() throws RecognitionException { - ForStatementContext _localctx = new ForStatementContext(_ctx, getState()); - enterRule(_localctx, 138, RULE_forStatement); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1945); - match(FOR); - setState(1949); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1946); - match(NL); - } - } - setState(1951); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1952); - match(LPAREN); - setState(1956); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,290,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1953); - annotation(); - } - } - } - setState(1958); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,290,_ctx); - } - setState(1961); - _errHandler.sync(this); - switch (_input.LA(1)) { - case NL: - case AT_NO_WS: - case AT_PRE_WS: - case FILE: - case FIELD: - case PROPERTY: - case GET: - case SET: - case RECEIVER: - case PARAM: - case SETPARAM: - case DELEGATE: - case IMPORT: - case CONSTRUCTOR: - case BY: - case COMPANION: - case INIT: - case WHERE: - case CATCH: - case FINALLY: - case OUT: - case DYNAMIC: - case PUBLIC: - case PRIVATE: - case PROTECTED: - case INTERNAL: - case ENUM: - case SEALED: - case ANNOTATION: - case DATA: - case INNER: - case VALUE: - case TAILREC: - case OPERATOR: - case INLINE: - case INFIX: - case EXTERNAL: - case SUSPEND: - case OVERRIDE: - case ABSTRACT: - case FINAL: - case OPEN: - case CONST: - case LATEINIT: - case VARARG: - case NOINLINE: - case CROSSINLINE: - case REIFIED: - case EXPECT: - case ACTUAL: - case Identifier: - { - setState(1959); - variableDeclaration(); - } - break; - case LPAREN: - { - setState(1960); - multiVariableDeclaration(); - } - break; - default: - throw new NoViableAltException(this); - } - setState(1963); - match(IN); - setState(1964); - expression(); - setState(1965); - match(RPAREN); - setState(1969); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,292,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1966); - match(NL); - } - } - } - setState(1971); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,292,_ctx); - } - setState(1973); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,293,_ctx) ) { - case 1: - { - setState(1972); - controlStructureBody(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class WhileStatementContext extends ParserRuleContext { - public TerminalNode WHILE() { return getToken(KotlinParser.WHILE, 0); } - public TerminalNode LPAREN() { return getToken(KotlinParser.LPAREN, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode RPAREN() { return getToken(KotlinParser.RPAREN, 0); } - public ControlStructureBodyContext controlStructureBody() { - return getRuleContext(ControlStructureBodyContext.class,0); - } - public TerminalNode SEMICOLON() { return getToken(KotlinParser.SEMICOLON, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public WhileStatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_whileStatement; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterWhileStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitWhileStatement(this); - } - } - - public final WhileStatementContext whileStatement() throws RecognitionException { - WhileStatementContext _localctx = new WhileStatementContext(_ctx, getState()); - enterRule(_localctx, 140, RULE_whileStatement); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(1975); - match(WHILE); - setState(1979); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1976); - match(NL); - } - } - setState(1981); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1982); - match(LPAREN); - setState(1983); - expression(); - setState(1984); - match(RPAREN); - setState(1988); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(1985); - match(NL); - } - } - setState(1990); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(1993); - _errHandler.sync(this); - switch (_input.LA(1)) { - case LPAREN: - case LSQUARE: - case LCURL: - case ADD: - case SUB: - case INCR: - case DECR: - case EXCL_WS: - case EXCL_NO_WS: - case COLONCOLON: - case AT_NO_WS: - case AT_PRE_WS: - case RETURN_AT: - case CONTINUE_AT: - case BREAK_AT: - case THIS_AT: - case SUPER_AT: - case FILE: - case FIELD: - case PROPERTY: - case GET: - case SET: - case RECEIVER: - case PARAM: - case SETPARAM: - case DELEGATE: - case IMPORT: - case CLASS: - case INTERFACE: - case FUN: - case OBJECT: - case VAL: - case VAR: - case TYPE_ALIAS: - case CONSTRUCTOR: - case BY: - case COMPANION: - case INIT: - case THIS: - case SUPER: - case WHERE: - case IF: - case WHEN: - case TRY: - case CATCH: - case FINALLY: - case FOR: - case DO: - case WHILE: - case THROW: - case RETURN: - case CONTINUE: - case BREAK: - case OUT: - case DYNAMIC: - case PUBLIC: - case PRIVATE: - case PROTECTED: - case INTERNAL: - case ENUM: - case SEALED: - case ANNOTATION: - case DATA: - case INNER: - case VALUE: - case TAILREC: - case OPERATOR: - case INLINE: - case INFIX: - case EXTERNAL: - case SUSPEND: - case OVERRIDE: - case ABSTRACT: - case FINAL: - case OPEN: - case CONST: - case LATEINIT: - case VARARG: - case NOINLINE: - case CROSSINLINE: - case REIFIED: - case EXPECT: - case ACTUAL: - case RealLiteral: - case IntegerLiteral: - case HexLiteral: - case BinLiteral: - case UnsignedLiteral: - case LongLiteral: - case BooleanLiteral: - case NullLiteral: - case CharacterLiteral: - case Identifier: - case QUOTE_OPEN: - case TRIPLE_QUOTE_OPEN: - { - setState(1991); - controlStructureBody(); - } - break; - case SEMICOLON: - { - setState(1992); - match(SEMICOLON); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class DoWhileStatementContext extends ParserRuleContext { - public TerminalNode DO() { return getToken(KotlinParser.DO, 0); } - public TerminalNode WHILE() { return getToken(KotlinParser.WHILE, 0); } - public TerminalNode LPAREN() { return getToken(KotlinParser.LPAREN, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode RPAREN() { return getToken(KotlinParser.RPAREN, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public ControlStructureBodyContext controlStructureBody() { - return getRuleContext(ControlStructureBodyContext.class,0); - } - public DoWhileStatementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_doWhileStatement; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterDoWhileStatement(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitDoWhileStatement(this); - } - } - - public final DoWhileStatementContext doWhileStatement() throws RecognitionException { - DoWhileStatementContext _localctx = new DoWhileStatementContext(_ctx, getState()); - enterRule(_localctx, 142, RULE_doWhileStatement); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(1995); - match(DO); - setState(1999); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,297,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(1996); - match(NL); - } - } - } - setState(2001); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,297,_ctx); - } - setState(2003); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,298,_ctx) ) { - case 1: - { - setState(2002); - controlStructureBody(); - } - break; - } - setState(2008); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2005); - match(NL); - } - } - setState(2010); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2011); - match(WHILE); - setState(2015); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2012); - match(NL); - } - } - setState(2017); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2018); - match(LPAREN); - setState(2019); - expression(); - setState(2020); - match(RPAREN); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class AssignmentContext extends ParserRuleContext { - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public DirectlyAssignableExpressionContext directlyAssignableExpression() { - return getRuleContext(DirectlyAssignableExpressionContext.class,0); - } - public TerminalNode ASSIGNMENT() { return getToken(KotlinParser.ASSIGNMENT, 0); } - public AssignableExpressionContext assignableExpression() { - return getRuleContext(AssignableExpressionContext.class,0); - } - public AssignmentAndOperatorContext assignmentAndOperator() { - return getRuleContext(AssignmentAndOperatorContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public AssignmentContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_assignment; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterAssignment(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitAssignment(this); - } - } - - public final AssignmentContext assignment() throws RecognitionException { - AssignmentContext _localctx = new AssignmentContext(_ctx, getState()); - enterRule(_localctx, 144, RULE_assignment); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2028); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,301,_ctx) ) { - case 1: - { - setState(2022); - directlyAssignableExpression(); - setState(2023); - match(ASSIGNMENT); - } - break; - case 2: - { - setState(2025); - assignableExpression(); - setState(2026); - assignmentAndOperator(); - } - break; - } - setState(2033); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2030); - match(NL); - } - } - setState(2035); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2036); - expression(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class SemiContext extends ParserRuleContext { - public TerminalNode SEMICOLON() { return getToken(KotlinParser.SEMICOLON, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TerminalNode EOF() { return getToken(KotlinParser.EOF, 0); } - public SemiContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_semi; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterSemi(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitSemi(this); - } - } - - public final SemiContext semi() throws RecognitionException { - SemiContext _localctx = new SemiContext(_ctx, getState()); - enterRule(_localctx, 146, RULE_semi); - int _la; - try { - int _alt; - setState(2046); - _errHandler.sync(this); - switch (_input.LA(1)) { - case NL: - case SEMICOLON: - enterOuterAlt(_localctx, 1); - { - setState(2038); - _la = _input.LA(1); - if ( !(_la==NL || _la==SEMICOLON) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(2042); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,303,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2039); - match(NL); - } - } - } - setState(2044); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,303,_ctx); - } - } - break; - case EOF: - enterOuterAlt(_localctx, 2); - { - setState(2045); - match(EOF); - } - 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 SemisContext extends ParserRuleContext { - public List SEMICOLON() { return getTokens(KotlinParser.SEMICOLON); } - public TerminalNode SEMICOLON(int i) { - return getToken(KotlinParser.SEMICOLON, i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TerminalNode EOF() { return getToken(KotlinParser.EOF, 0); } - public SemisContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_semis; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterSemis(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitSemis(this); - } - } - - public final SemisContext semis() throws RecognitionException { - SemisContext _localctx = new SemisContext(_ctx, getState()); - enterRule(_localctx, 148, RULE_semis); - int _la; - try { - int _alt; - setState(2054); - _errHandler.sync(this); - switch (_input.LA(1)) { - case NL: - case SEMICOLON: - enterOuterAlt(_localctx, 1); - { - setState(2049); - _errHandler.sync(this); - _alt = 1; - do { - switch (_alt) { - case 1: - { - { - setState(2048); - _la = _input.LA(1); - if ( !(_la==NL || _la==SEMICOLON) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - } - } - break; - default: - throw new NoViableAltException(this); - } - setState(2051); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,305,_ctx); - } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); - } - break; - case EOF: - enterOuterAlt(_localctx, 2); - { - setState(2053); - match(EOF); - } - 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 ExpressionContext extends ParserRuleContext { - public DisjunctionContext disjunction() { - return getRuleContext(DisjunctionContext.class,0); - } - public ExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_expression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitExpression(this); - } - } - - public final ExpressionContext expression() throws RecognitionException { - ExpressionContext _localctx = new ExpressionContext(_ctx, getState()); - enterRule(_localctx, 150, RULE_expression); - try { - enterOuterAlt(_localctx, 1); - { - setState(2056); - disjunction(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class DisjunctionContext extends ParserRuleContext { - public List conjunction() { - return getRuleContexts(ConjunctionContext.class); - } - public ConjunctionContext conjunction(int i) { - return getRuleContext(ConjunctionContext.class,i); - } - public List DISJ() { return getTokens(KotlinParser.DISJ); } - public TerminalNode DISJ(int i) { - return getToken(KotlinParser.DISJ, i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public DisjunctionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_disjunction; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterDisjunction(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitDisjunction(this); - } - } - - public final DisjunctionContext disjunction() throws RecognitionException { - DisjunctionContext _localctx = new DisjunctionContext(_ctx, getState()); - enterRule(_localctx, 152, RULE_disjunction); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2058); - conjunction(); - setState(2075); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,309,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2062); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2059); - match(NL); - } - } - setState(2064); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2065); - match(DISJ); - setState(2069); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2066); - match(NL); - } - } - setState(2071); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2072); - conjunction(); - } - } - } - setState(2077); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,309,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ConjunctionContext extends ParserRuleContext { - public List equality() { - return getRuleContexts(EqualityContext.class); - } - public EqualityContext equality(int i) { - return getRuleContext(EqualityContext.class,i); - } - public List CONJ() { return getTokens(KotlinParser.CONJ); } - public TerminalNode CONJ(int i) { - return getToken(KotlinParser.CONJ, i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public ConjunctionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_conjunction; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterConjunction(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitConjunction(this); - } - } - - public final ConjunctionContext conjunction() throws RecognitionException { - ConjunctionContext _localctx = new ConjunctionContext(_ctx, getState()); - enterRule(_localctx, 154, RULE_conjunction); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2078); - equality(); - setState(2095); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,312,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2082); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2079); - match(NL); - } - } - setState(2084); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2085); - match(CONJ); - setState(2089); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2086); - match(NL); - } - } - setState(2091); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2092); - equality(); - } - } - } - setState(2097); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,312,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class EqualityContext extends ParserRuleContext { - public List comparison() { - return getRuleContexts(ComparisonContext.class); - } - public ComparisonContext comparison(int i) { - return getRuleContext(ComparisonContext.class,i); - } - public List equalityOperator() { - return getRuleContexts(EqualityOperatorContext.class); - } - public EqualityOperatorContext equalityOperator(int i) { - return getRuleContext(EqualityOperatorContext.class,i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public EqualityContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_equality; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterEquality(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitEquality(this); - } - } - - public final EqualityContext equality() throws RecognitionException { - EqualityContext _localctx = new EqualityContext(_ctx, getState()); - enterRule(_localctx, 156, RULE_equality); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2098); - comparison(); - setState(2110); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,314,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2099); - equalityOperator(); - setState(2103); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2100); - match(NL); - } - } - setState(2105); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2106); - comparison(); - } - } - } - setState(2112); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,314,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ComparisonContext extends ParserRuleContext { - public List genericCallLikeComparison() { - return getRuleContexts(GenericCallLikeComparisonContext.class); - } - public GenericCallLikeComparisonContext genericCallLikeComparison(int i) { - return getRuleContext(GenericCallLikeComparisonContext.class,i); - } - public List comparisonOperator() { - return getRuleContexts(ComparisonOperatorContext.class); - } - public ComparisonOperatorContext comparisonOperator(int i) { - return getRuleContext(ComparisonOperatorContext.class,i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public ComparisonContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_comparison; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterComparison(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitComparison(this); - } - } - - public final ComparisonContext comparison() throws RecognitionException { - ComparisonContext _localctx = new ComparisonContext(_ctx, getState()); - enterRule(_localctx, 158, RULE_comparison); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2113); - genericCallLikeComparison(); - setState(2125); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,316,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2114); - comparisonOperator(); - setState(2118); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2115); - match(NL); - } - } - setState(2120); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2121); - genericCallLikeComparison(); - } - } - } - setState(2127); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,316,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class GenericCallLikeComparisonContext extends ParserRuleContext { - public InfixOperationContext infixOperation() { - return getRuleContext(InfixOperationContext.class,0); - } - public List callSuffix() { - return getRuleContexts(CallSuffixContext.class); - } - public CallSuffixContext callSuffix(int i) { - return getRuleContext(CallSuffixContext.class,i); - } - public GenericCallLikeComparisonContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_genericCallLikeComparison; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterGenericCallLikeComparison(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitGenericCallLikeComparison(this); - } - } - - public final GenericCallLikeComparisonContext genericCallLikeComparison() throws RecognitionException { - GenericCallLikeComparisonContext _localctx = new GenericCallLikeComparisonContext(_ctx, getState()); - enterRule(_localctx, 160, RULE_genericCallLikeComparison); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2128); - infixOperation(); - setState(2132); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,317,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2129); - callSuffix(); - } - } - } - setState(2134); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,317,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class InfixOperationContext extends ParserRuleContext { - public List elvisExpression() { - return getRuleContexts(ElvisExpressionContext.class); - } - public ElvisExpressionContext elvisExpression(int i) { - return getRuleContext(ElvisExpressionContext.class,i); - } - public List inOperator() { - return getRuleContexts(InOperatorContext.class); - } - public InOperatorContext inOperator(int i) { - return getRuleContext(InOperatorContext.class,i); - } - public List isOperator() { - return getRuleContexts(IsOperatorContext.class); - } - public IsOperatorContext isOperator(int i) { - return getRuleContext(IsOperatorContext.class,i); - } - public List type() { - return getRuleContexts(TypeContext.class); - } - public TypeContext type(int i) { - return getRuleContext(TypeContext.class,i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public InfixOperationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_infixOperation; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterInfixOperation(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitInfixOperation(this); - } - } - - public final InfixOperationContext infixOperation() throws RecognitionException { - InfixOperationContext _localctx = new InfixOperationContext(_ctx, getState()); - enterRule(_localctx, 162, RULE_infixOperation); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2135); - elvisExpression(); - setState(2156); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,321,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - setState(2154); - _errHandler.sync(this); - switch (_input.LA(1)) { - case IN: - case NOT_IN: - { - setState(2136); - inOperator(); - setState(2140); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2137); - match(NL); - } - } - setState(2142); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2143); - elvisExpression(); - } - break; - case IS: - case NOT_IS: - { - setState(2145); - isOperator(); - setState(2149); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2146); - match(NL); - } - } - setState(2151); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2152); - type(); - } - break; - default: - throw new NoViableAltException(this); - } - } - } - setState(2158); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,321,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ElvisExpressionContext extends ParserRuleContext { - public List infixFunctionCall() { - return getRuleContexts(InfixFunctionCallContext.class); - } - public InfixFunctionCallContext infixFunctionCall(int i) { - return getRuleContext(InfixFunctionCallContext.class,i); - } - public List elvis() { - return getRuleContexts(ElvisContext.class); - } - public ElvisContext elvis(int i) { - return getRuleContext(ElvisContext.class,i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public ElvisExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_elvisExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterElvisExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitElvisExpression(this); - } - } - - public final ElvisExpressionContext elvisExpression() throws RecognitionException { - ElvisExpressionContext _localctx = new ElvisExpressionContext(_ctx, getState()); - enterRule(_localctx, 164, RULE_elvisExpression); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2159); - infixFunctionCall(); - setState(2177); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,324,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2163); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2160); - match(NL); - } - } - setState(2165); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2166); - elvis(); - setState(2170); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2167); - match(NL); - } - } - setState(2172); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2173); - infixFunctionCall(); - } - } - } - setState(2179); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,324,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ElvisContext extends ParserRuleContext { - public TerminalNode QUEST_NO_WS() { return getToken(KotlinParser.QUEST_NO_WS, 0); } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public ElvisContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_elvis; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterElvis(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitElvis(this); - } - } - - public final ElvisContext elvis() throws RecognitionException { - ElvisContext _localctx = new ElvisContext(_ctx, getState()); - enterRule(_localctx, 166, RULE_elvis); - try { - enterOuterAlt(_localctx, 1); - { - setState(2180); - match(QUEST_NO_WS); - setState(2181); - match(COLON); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class InfixFunctionCallContext extends ParserRuleContext { - public List rangeExpression() { - return getRuleContexts(RangeExpressionContext.class); - } - public RangeExpressionContext rangeExpression(int i) { - return getRuleContext(RangeExpressionContext.class,i); - } - public List simpleIdentifier() { - return getRuleContexts(SimpleIdentifierContext.class); - } - public SimpleIdentifierContext simpleIdentifier(int i) { - return getRuleContext(SimpleIdentifierContext.class,i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public InfixFunctionCallContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_infixFunctionCall; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterInfixFunctionCall(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitInfixFunctionCall(this); - } - } - - public final InfixFunctionCallContext infixFunctionCall() throws RecognitionException { - InfixFunctionCallContext _localctx = new InfixFunctionCallContext(_ctx, getState()); - enterRule(_localctx, 168, RULE_infixFunctionCall); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2183); - rangeExpression(); - setState(2195); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,326,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2184); - simpleIdentifier(); - setState(2188); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2185); - match(NL); - } - } - setState(2190); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2191); - rangeExpression(); - } - } - } - setState(2197); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,326,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class RangeExpressionContext extends ParserRuleContext { - public List additiveExpression() { - return getRuleContexts(AdditiveExpressionContext.class); - } - public AdditiveExpressionContext additiveExpression(int i) { - return getRuleContext(AdditiveExpressionContext.class,i); - } - public List RANGE() { return getTokens(KotlinParser.RANGE); } - public TerminalNode RANGE(int i) { - return getToken(KotlinParser.RANGE, i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public RangeExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_rangeExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterRangeExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitRangeExpression(this); - } - } - - public final RangeExpressionContext rangeExpression() throws RecognitionException { - RangeExpressionContext _localctx = new RangeExpressionContext(_ctx, getState()); - enterRule(_localctx, 170, RULE_rangeExpression); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2198); - additiveExpression(); - setState(2209); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,328,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2199); - match(RANGE); - setState(2203); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2200); - match(NL); - } - } - setState(2205); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2206); - additiveExpression(); - } - } - } - setState(2211); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,328,_ctx); - } - } - } - 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 additiveOperator() { - return getRuleContexts(AdditiveOperatorContext.class); - } - public AdditiveOperatorContext additiveOperator(int i) { - return getRuleContext(AdditiveOperatorContext.class,i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public AdditiveExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_additiveExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterAdditiveExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitAdditiveExpression(this); - } - } - - public final AdditiveExpressionContext additiveExpression() throws RecognitionException { - AdditiveExpressionContext _localctx = new AdditiveExpressionContext(_ctx, getState()); - enterRule(_localctx, 172, RULE_additiveExpression); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2212); - multiplicativeExpression(); - setState(2224); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,330,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2213); - additiveOperator(); - setState(2217); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2214); - match(NL); - } - } - setState(2219); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2220); - multiplicativeExpression(); - } - } - } - setState(2226); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,330,_ctx); - } - } - } - 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 asExpression() { - return getRuleContexts(AsExpressionContext.class); - } - public AsExpressionContext asExpression(int i) { - return getRuleContext(AsExpressionContext.class,i); - } - public List multiplicativeOperator() { - return getRuleContexts(MultiplicativeOperatorContext.class); - } - public MultiplicativeOperatorContext multiplicativeOperator(int i) { - return getRuleContext(MultiplicativeOperatorContext.class,i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public MultiplicativeExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_multiplicativeExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterMultiplicativeExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitMultiplicativeExpression(this); - } - } - - public final MultiplicativeExpressionContext multiplicativeExpression() throws RecognitionException { - MultiplicativeExpressionContext _localctx = new MultiplicativeExpressionContext(_ctx, getState()); - enterRule(_localctx, 174, RULE_multiplicativeExpression); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2227); - asExpression(); - setState(2239); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,332,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2228); - multiplicativeOperator(); - setState(2232); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2229); - match(NL); - } - } - setState(2234); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2235); - asExpression(); - } - } - } - setState(2241); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,332,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class AsExpressionContext extends ParserRuleContext { - public PrefixUnaryExpressionContext prefixUnaryExpression() { - return getRuleContext(PrefixUnaryExpressionContext.class,0); - } - public List asOperator() { - return getRuleContexts(AsOperatorContext.class); - } - public AsOperatorContext asOperator(int i) { - return getRuleContext(AsOperatorContext.class,i); - } - public List type() { - return getRuleContexts(TypeContext.class); - } - public TypeContext type(int i) { - return getRuleContext(TypeContext.class,i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public AsExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_asExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterAsExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitAsExpression(this); - } - } - - public final AsExpressionContext asExpression() throws RecognitionException { - AsExpressionContext _localctx = new AsExpressionContext(_ctx, getState()); - enterRule(_localctx, 176, RULE_asExpression); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2242); - prefixUnaryExpression(); - setState(2260); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,335,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2246); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2243); - match(NL); - } - } - setState(2248); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2249); - asOperator(); - setState(2253); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2250); - match(NL); - } - } - setState(2255); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2256); - type(); - } - } - } - setState(2262); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,335,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class PrefixUnaryExpressionContext extends ParserRuleContext { - public PostfixUnaryExpressionContext postfixUnaryExpression() { - return getRuleContext(PostfixUnaryExpressionContext.class,0); - } - public List unaryPrefix() { - return getRuleContexts(UnaryPrefixContext.class); - } - public UnaryPrefixContext unaryPrefix(int i) { - return getRuleContext(UnaryPrefixContext.class,i); - } - public PrefixUnaryExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_prefixUnaryExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterPrefixUnaryExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitPrefixUnaryExpression(this); - } - } - - public final PrefixUnaryExpressionContext prefixUnaryExpression() throws RecognitionException { - PrefixUnaryExpressionContext _localctx = new PrefixUnaryExpressionContext(_ctx, getState()); - enterRule(_localctx, 178, RULE_prefixUnaryExpression); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2266); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,336,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2263); - unaryPrefix(); - } - } - } - setState(2268); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,336,_ctx); - } - setState(2269); - postfixUnaryExpression(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class UnaryPrefixContext extends ParserRuleContext { - public AnnotationContext annotation() { - return getRuleContext(AnnotationContext.class,0); - } - public LabelContext label() { - return getRuleContext(LabelContext.class,0); - } - public PrefixUnaryOperatorContext prefixUnaryOperator() { - return getRuleContext(PrefixUnaryOperatorContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public UnaryPrefixContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_unaryPrefix; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterUnaryPrefix(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitUnaryPrefix(this); - } - } - - public final UnaryPrefixContext unaryPrefix() throws RecognitionException { - UnaryPrefixContext _localctx = new UnaryPrefixContext(_ctx, getState()); - enterRule(_localctx, 180, RULE_unaryPrefix); - int _la; - try { - setState(2280); - _errHandler.sync(this); - switch (_input.LA(1)) { - case AT_NO_WS: - case AT_PRE_WS: - enterOuterAlt(_localctx, 1); - { - setState(2271); - annotation(); - } - break; - case FILE: - case FIELD: - case PROPERTY: - case GET: - case SET: - case RECEIVER: - case PARAM: - case SETPARAM: - case DELEGATE: - case IMPORT: - case CONSTRUCTOR: - case BY: - case COMPANION: - case INIT: - case WHERE: - case CATCH: - case FINALLY: - case OUT: - case DYNAMIC: - case PUBLIC: - case PRIVATE: - case PROTECTED: - case INTERNAL: - case ENUM: - case SEALED: - case ANNOTATION: - case DATA: - case INNER: - case VALUE: - case TAILREC: - case OPERATOR: - case INLINE: - case INFIX: - case EXTERNAL: - case SUSPEND: - case OVERRIDE: - case ABSTRACT: - case FINAL: - case OPEN: - case CONST: - case LATEINIT: - case VARARG: - case NOINLINE: - case CROSSINLINE: - case REIFIED: - case EXPECT: - case ACTUAL: - case Identifier: - enterOuterAlt(_localctx, 2); - { - setState(2272); - label(); - } - break; - case ADD: - case SUB: - case INCR: - case DECR: - case EXCL_WS: - case EXCL_NO_WS: - enterOuterAlt(_localctx, 3); - { - setState(2273); - prefixUnaryOperator(); - setState(2277); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2274); - match(NL); - } - } - setState(2279); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class PostfixUnaryExpressionContext extends ParserRuleContext { - public PrimaryExpressionContext primaryExpression() { - return getRuleContext(PrimaryExpressionContext.class,0); - } - public List postfixUnarySuffix() { - return getRuleContexts(PostfixUnarySuffixContext.class); - } - public PostfixUnarySuffixContext postfixUnarySuffix(int i) { - return getRuleContext(PostfixUnarySuffixContext.class,i); - } - public PostfixUnaryExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_postfixUnaryExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterPostfixUnaryExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitPostfixUnaryExpression(this); - } - } - - public final PostfixUnaryExpressionContext postfixUnaryExpression() throws RecognitionException { - PostfixUnaryExpressionContext _localctx = new PostfixUnaryExpressionContext(_ctx, getState()); - enterRule(_localctx, 182, RULE_postfixUnaryExpression); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2282); - primaryExpression(); - setState(2286); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,339,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2283); - postfixUnarySuffix(); - } - } - } - setState(2288); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,339,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class PostfixUnarySuffixContext extends ParserRuleContext { - public PostfixUnaryOperatorContext postfixUnaryOperator() { - return getRuleContext(PostfixUnaryOperatorContext.class,0); - } - public TypeArgumentsContext typeArguments() { - return getRuleContext(TypeArgumentsContext.class,0); - } - public CallSuffixContext callSuffix() { - return getRuleContext(CallSuffixContext.class,0); - } - public IndexingSuffixContext indexingSuffix() { - return getRuleContext(IndexingSuffixContext.class,0); - } - public NavigationSuffixContext navigationSuffix() { - return getRuleContext(NavigationSuffixContext.class,0); - } - public PostfixUnarySuffixContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_postfixUnarySuffix; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterPostfixUnarySuffix(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitPostfixUnarySuffix(this); - } - } - - public final PostfixUnarySuffixContext postfixUnarySuffix() throws RecognitionException { - PostfixUnarySuffixContext _localctx = new PostfixUnarySuffixContext(_ctx, getState()); - enterRule(_localctx, 184, RULE_postfixUnarySuffix); - try { - setState(2294); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,340,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(2289); - postfixUnaryOperator(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(2290); - typeArguments(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(2291); - callSuffix(); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(2292); - indexingSuffix(); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(2293); - navigationSuffix(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class DirectlyAssignableExpressionContext extends ParserRuleContext { - public PostfixUnaryExpressionContext postfixUnaryExpression() { - return getRuleContext(PostfixUnaryExpressionContext.class,0); - } - public AssignableSuffixContext assignableSuffix() { - return getRuleContext(AssignableSuffixContext.class,0); - } - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public ParenthesizedDirectlyAssignableExpressionContext parenthesizedDirectlyAssignableExpression() { - return getRuleContext(ParenthesizedDirectlyAssignableExpressionContext.class,0); - } - public DirectlyAssignableExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_directlyAssignableExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterDirectlyAssignableExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitDirectlyAssignableExpression(this); - } - } - - public final DirectlyAssignableExpressionContext directlyAssignableExpression() throws RecognitionException { - DirectlyAssignableExpressionContext _localctx = new DirectlyAssignableExpressionContext(_ctx, getState()); - enterRule(_localctx, 186, RULE_directlyAssignableExpression); - try { - setState(2301); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,341,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(2296); - postfixUnaryExpression(); - setState(2297); - assignableSuffix(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(2299); - simpleIdentifier(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(2300); - parenthesizedDirectlyAssignableExpression(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ParenthesizedDirectlyAssignableExpressionContext extends ParserRuleContext { - public TerminalNode LPAREN() { return getToken(KotlinParser.LPAREN, 0); } - public DirectlyAssignableExpressionContext directlyAssignableExpression() { - return getRuleContext(DirectlyAssignableExpressionContext.class,0); - } - public TerminalNode RPAREN() { return getToken(KotlinParser.RPAREN, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public ParenthesizedDirectlyAssignableExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_parenthesizedDirectlyAssignableExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterParenthesizedDirectlyAssignableExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitParenthesizedDirectlyAssignableExpression(this); - } - } - - public final ParenthesizedDirectlyAssignableExpressionContext parenthesizedDirectlyAssignableExpression() throws RecognitionException { - ParenthesizedDirectlyAssignableExpressionContext _localctx = new ParenthesizedDirectlyAssignableExpressionContext(_ctx, getState()); - enterRule(_localctx, 188, RULE_parenthesizedDirectlyAssignableExpression); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2303); - match(LPAREN); - setState(2307); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2304); - match(NL); - } - } - setState(2309); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2310); - directlyAssignableExpression(); - setState(2314); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2311); - match(NL); - } - } - setState(2316); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2317); - match(RPAREN); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class AssignableExpressionContext extends ParserRuleContext { - public PrefixUnaryExpressionContext prefixUnaryExpression() { - return getRuleContext(PrefixUnaryExpressionContext.class,0); - } - public ParenthesizedAssignableExpressionContext parenthesizedAssignableExpression() { - return getRuleContext(ParenthesizedAssignableExpressionContext.class,0); - } - public AssignableExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_assignableExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterAssignableExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitAssignableExpression(this); - } - } - - public final AssignableExpressionContext assignableExpression() throws RecognitionException { - AssignableExpressionContext _localctx = new AssignableExpressionContext(_ctx, getState()); - enterRule(_localctx, 190, RULE_assignableExpression); - try { - setState(2321); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,344,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(2319); - prefixUnaryExpression(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(2320); - parenthesizedAssignableExpression(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ParenthesizedAssignableExpressionContext extends ParserRuleContext { - public TerminalNode LPAREN() { return getToken(KotlinParser.LPAREN, 0); } - public AssignableExpressionContext assignableExpression() { - return getRuleContext(AssignableExpressionContext.class,0); - } - public TerminalNode RPAREN() { return getToken(KotlinParser.RPAREN, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public ParenthesizedAssignableExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_parenthesizedAssignableExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterParenthesizedAssignableExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitParenthesizedAssignableExpression(this); - } - } - - public final ParenthesizedAssignableExpressionContext parenthesizedAssignableExpression() throws RecognitionException { - ParenthesizedAssignableExpressionContext _localctx = new ParenthesizedAssignableExpressionContext(_ctx, getState()); - enterRule(_localctx, 192, RULE_parenthesizedAssignableExpression); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2323); - match(LPAREN); - setState(2327); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2324); - match(NL); - } - } - setState(2329); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2330); - assignableExpression(); - setState(2334); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2331); - match(NL); - } - } - setState(2336); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2337); - match(RPAREN); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class AssignableSuffixContext extends ParserRuleContext { - public TypeArgumentsContext typeArguments() { - return getRuleContext(TypeArgumentsContext.class,0); - } - public IndexingSuffixContext indexingSuffix() { - return getRuleContext(IndexingSuffixContext.class,0); - } - public NavigationSuffixContext navigationSuffix() { - return getRuleContext(NavigationSuffixContext.class,0); - } - public AssignableSuffixContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_assignableSuffix; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterAssignableSuffix(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitAssignableSuffix(this); - } - } - - public final AssignableSuffixContext assignableSuffix() throws RecognitionException { - AssignableSuffixContext _localctx = new AssignableSuffixContext(_ctx, getState()); - enterRule(_localctx, 194, RULE_assignableSuffix); - try { - setState(2342); - _errHandler.sync(this); - switch (_input.LA(1)) { - case LANGLE: - enterOuterAlt(_localctx, 1); - { - setState(2339); - typeArguments(); - } - break; - case LSQUARE: - enterOuterAlt(_localctx, 2); - { - setState(2340); - indexingSuffix(); - } - break; - case NL: - case DOT: - case COLONCOLON: - case QUEST_NO_WS: - enterOuterAlt(_localctx, 3); - { - setState(2341); - navigationSuffix(); - } - 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 IndexingSuffixContext extends ParserRuleContext { - public TerminalNode LSQUARE() { return getToken(KotlinParser.LSQUARE, 0); } - public List expression() { - return getRuleContexts(ExpressionContext.class); - } - public ExpressionContext expression(int i) { - return getRuleContext(ExpressionContext.class,i); - } - public TerminalNode RSQUARE() { return getToken(KotlinParser.RSQUARE, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public List COMMA() { return getTokens(KotlinParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(KotlinParser.COMMA, i); - } - public IndexingSuffixContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_indexingSuffix; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterIndexingSuffix(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitIndexingSuffix(this); - } - } - - public final IndexingSuffixContext indexingSuffix() throws RecognitionException { - IndexingSuffixContext _localctx = new IndexingSuffixContext(_ctx, getState()); - enterRule(_localctx, 196, RULE_indexingSuffix); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2344); - match(LSQUARE); - setState(2348); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2345); - match(NL); - } - } - setState(2350); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2351); - expression(); - setState(2368); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,351,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2355); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2352); - match(NL); - } - } - setState(2357); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2358); - match(COMMA); - setState(2362); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2359); - match(NL); - } - } - setState(2364); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2365); - expression(); - } - } - } - setState(2370); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,351,_ctx); - } - setState(2378); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,353,_ctx) ) { - case 1: - { - setState(2374); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2371); - match(NL); - } - } - setState(2376); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2377); - match(COMMA); - } - break; - } - setState(2383); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2380); - match(NL); - } - } - setState(2385); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2386); - match(RSQUARE); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class NavigationSuffixContext extends ParserRuleContext { - public MemberAccessOperatorContext memberAccessOperator() { - return getRuleContext(MemberAccessOperatorContext.class,0); - } - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public ParenthesizedExpressionContext parenthesizedExpression() { - return getRuleContext(ParenthesizedExpressionContext.class,0); - } - public TerminalNode CLASS() { return getToken(KotlinParser.CLASS, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public NavigationSuffixContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_navigationSuffix; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterNavigationSuffix(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitNavigationSuffix(this); - } - } - - public final NavigationSuffixContext navigationSuffix() throws RecognitionException { - NavigationSuffixContext _localctx = new NavigationSuffixContext(_ctx, getState()); - enterRule(_localctx, 198, RULE_navigationSuffix); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2388); - memberAccessOperator(); - setState(2392); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2389); - match(NL); - } - } - setState(2394); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2398); - _errHandler.sync(this); - switch (_input.LA(1)) { - case FILE: - case FIELD: - case PROPERTY: - case GET: - case SET: - case RECEIVER: - case PARAM: - case SETPARAM: - case DELEGATE: - case IMPORT: - case CONSTRUCTOR: - case BY: - case COMPANION: - case INIT: - case WHERE: - case CATCH: - case FINALLY: - case OUT: - case DYNAMIC: - case PUBLIC: - case PRIVATE: - case PROTECTED: - case INTERNAL: - case ENUM: - case SEALED: - case ANNOTATION: - case DATA: - case INNER: - case VALUE: - case TAILREC: - case OPERATOR: - case INLINE: - case INFIX: - case EXTERNAL: - case SUSPEND: - case OVERRIDE: - case ABSTRACT: - case FINAL: - case OPEN: - case CONST: - case LATEINIT: - case VARARG: - case NOINLINE: - case CROSSINLINE: - case REIFIED: - case EXPECT: - case ACTUAL: - case Identifier: - { - setState(2395); - simpleIdentifier(); - } - break; - case LPAREN: - { - setState(2396); - parenthesizedExpression(); - } - break; - case CLASS: - { - setState(2397); - match(CLASS); - } - 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 CallSuffixContext extends ParserRuleContext { - public AnnotatedLambdaContext annotatedLambda() { - return getRuleContext(AnnotatedLambdaContext.class,0); - } - public ValueArgumentsContext valueArguments() { - return getRuleContext(ValueArgumentsContext.class,0); - } - public TypeArgumentsContext typeArguments() { - return getRuleContext(TypeArgumentsContext.class,0); - } - public CallSuffixContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_callSuffix; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterCallSuffix(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitCallSuffix(this); - } - } - - public final CallSuffixContext callSuffix() throws RecognitionException { - CallSuffixContext _localctx = new CallSuffixContext(_ctx, getState()); - enterRule(_localctx, 200, RULE_callSuffix); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2401); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==LANGLE) { - { - setState(2400); - typeArguments(); - } - } - - setState(2408); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,359,_ctx) ) { - case 1: - { - setState(2404); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==LPAREN) { - { - setState(2403); - valueArguments(); - } - } - - setState(2406); - annotatedLambda(); - } - break; - case 2: - { - setState(2407); - valueArguments(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class AnnotatedLambdaContext extends ParserRuleContext { - public LambdaLiteralContext lambdaLiteral() { - return getRuleContext(LambdaLiteralContext.class,0); - } - public List annotation() { - return getRuleContexts(AnnotationContext.class); - } - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class,i); - } - public LabelContext label() { - return getRuleContext(LabelContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public AnnotatedLambdaContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_annotatedLambda; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterAnnotatedLambda(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitAnnotatedLambda(this); - } - } - - public final AnnotatedLambdaContext annotatedLambda() throws RecognitionException { - AnnotatedLambdaContext _localctx = new AnnotatedLambdaContext(_ctx, getState()); - enterRule(_localctx, 202, RULE_annotatedLambda); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2413); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==AT_NO_WS || _la==AT_PRE_WS) { - { - { - setState(2410); - annotation(); - } - } - setState(2415); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2417); - _errHandler.sync(this); - _la = _input.LA(1); - if (((((_la - 61)) & ~0x3f) == 0 && ((1L << (_la - 61)) & ((1L << (FILE - 61)) | (1L << (FIELD - 61)) | (1L << (PROPERTY - 61)) | (1L << (GET - 61)) | (1L << (SET - 61)) | (1L << (RECEIVER - 61)) | (1L << (PARAM - 61)) | (1L << (SETPARAM - 61)) | (1L << (DELEGATE - 61)) | (1L << (IMPORT - 61)) | (1L << (CONSTRUCTOR - 61)) | (1L << (BY - 61)) | (1L << (COMPANION - 61)) | (1L << (INIT - 61)) | (1L << (WHERE - 61)) | (1L << (CATCH - 61)) | (1L << (FINALLY - 61)) | (1L << (OUT - 61)) | (1L << (DYNAMIC - 61)) | (1L << (PUBLIC - 61)) | (1L << (PRIVATE - 61)) | (1L << (PROTECTED - 61)) | (1L << (INTERNAL - 61)) | (1L << (ENUM - 61)) | (1L << (SEALED - 61)) | (1L << (ANNOTATION - 61)) | (1L << (DATA - 61)) | (1L << (INNER - 61)) | (1L << (VALUE - 61)) | (1L << (TAILREC - 61)) | (1L << (OPERATOR - 61)) | (1L << (INLINE - 61)) | (1L << (INFIX - 61)) | (1L << (EXTERNAL - 61)) | (1L << (SUSPEND - 61)) | (1L << (OVERRIDE - 61)) | (1L << (ABSTRACT - 61)))) != 0) || ((((_la - 125)) & ~0x3f) == 0 && ((1L << (_la - 125)) & ((1L << (FINAL - 125)) | (1L << (OPEN - 125)) | (1L << (CONST - 125)) | (1L << (LATEINIT - 125)) | (1L << (VARARG - 125)) | (1L << (NOINLINE - 125)) | (1L << (CROSSINLINE - 125)) | (1L << (REIFIED - 125)) | (1L << (EXPECT - 125)) | (1L << (ACTUAL - 125)) | (1L << (Identifier - 125)))) != 0)) { - { - setState(2416); - label(); - } - } - - setState(2422); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2419); - match(NL); - } - } - setState(2424); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2425); - lambdaLiteral(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TypeArgumentsContext extends ParserRuleContext { - public TerminalNode LANGLE() { return getToken(KotlinParser.LANGLE, 0); } - public List typeProjection() { - return getRuleContexts(TypeProjectionContext.class); - } - public TypeProjectionContext typeProjection(int i) { - return getRuleContext(TypeProjectionContext.class,i); - } - public TerminalNode RANGLE() { return getToken(KotlinParser.RANGLE, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public List COMMA() { return getTokens(KotlinParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(KotlinParser.COMMA, i); - } - public TypeArgumentsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeArguments; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterTypeArguments(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitTypeArguments(this); - } - } - - public final TypeArgumentsContext typeArguments() throws RecognitionException { - TypeArgumentsContext _localctx = new TypeArgumentsContext(_ctx, getState()); - enterRule(_localctx, 204, RULE_typeArguments); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2427); - match(LANGLE); - setState(2431); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2428); - match(NL); - } - } - setState(2433); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2434); - typeProjection(); - setState(2451); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,366,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2438); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2435); - match(NL); - } - } - setState(2440); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2441); - match(COMMA); - setState(2445); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2442); - match(NL); - } - } - setState(2447); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2448); - typeProjection(); - } - } - } - setState(2453); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,366,_ctx); - } - setState(2461); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,368,_ctx) ) { - case 1: - { - setState(2457); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2454); - match(NL); - } - } - setState(2459); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2460); - match(COMMA); - } - break; - } - setState(2466); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2463); - match(NL); - } - } - setState(2468); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2469); - match(RANGLE); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ValueArgumentsContext extends ParserRuleContext { - public TerminalNode LPAREN() { return getToken(KotlinParser.LPAREN, 0); } - public TerminalNode RPAREN() { return getToken(KotlinParser.RPAREN, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public List valueArgument() { - return getRuleContexts(ValueArgumentContext.class); - } - public ValueArgumentContext valueArgument(int i) { - return getRuleContext(ValueArgumentContext.class,i); - } - public List COMMA() { return getTokens(KotlinParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(KotlinParser.COMMA, i); - } - public ValueArgumentsContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_valueArguments; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterValueArguments(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitValueArguments(this); - } - } - - public final ValueArgumentsContext valueArguments() throws RecognitionException { - ValueArgumentsContext _localctx = new ValueArgumentsContext(_ctx, getState()); - enterRule(_localctx, 206, RULE_valueArguments); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2471); - match(LPAREN); - setState(2475); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,370,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2472); - match(NL); - } - } - } - setState(2477); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,370,_ctx); - } - setState(2513); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << NL) | (1L << LPAREN) | (1L << LSQUARE) | (1L << LCURL) | (1L << MULT) | (1L << ADD) | (1L << SUB) | (1L << INCR) | (1L << DECR) | (1L << EXCL_WS) | (1L << EXCL_NO_WS) | (1L << COLONCOLON) | (1L << AT_NO_WS) | (1L << AT_PRE_WS) | (1L << RETURN_AT) | (1L << CONTINUE_AT) | (1L << BREAK_AT) | (1L << THIS_AT) | (1L << SUPER_AT) | (1L << FILE) | (1L << FIELD) | (1L << PROPERTY))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (GET - 64)) | (1L << (SET - 64)) | (1L << (RECEIVER - 64)) | (1L << (PARAM - 64)) | (1L << (SETPARAM - 64)) | (1L << (DELEGATE - 64)) | (1L << (IMPORT - 64)) | (1L << (FUN - 64)) | (1L << (OBJECT - 64)) | (1L << (CONSTRUCTOR - 64)) | (1L << (BY - 64)) | (1L << (COMPANION - 64)) | (1L << (INIT - 64)) | (1L << (THIS - 64)) | (1L << (SUPER - 64)) | (1L << (WHERE - 64)) | (1L << (IF - 64)) | (1L << (WHEN - 64)) | (1L << (TRY - 64)) | (1L << (CATCH - 64)) | (1L << (FINALLY - 64)) | (1L << (THROW - 64)) | (1L << (RETURN - 64)) | (1L << (CONTINUE - 64)) | (1L << (BREAK - 64)) | (1L << (OUT - 64)) | (1L << (DYNAMIC - 64)) | (1L << (PUBLIC - 64)) | (1L << (PRIVATE - 64)) | (1L << (PROTECTED - 64)) | (1L << (INTERNAL - 64)) | (1L << (ENUM - 64)) | (1L << (SEALED - 64)) | (1L << (ANNOTATION - 64)) | (1L << (DATA - 64)) | (1L << (INNER - 64)) | (1L << (VALUE - 64)) | (1L << (TAILREC - 64)) | (1L << (OPERATOR - 64)) | (1L << (INLINE - 64)) | (1L << (INFIX - 64)) | (1L << (EXTERNAL - 64)) | (1L << (SUSPEND - 64)) | (1L << (OVERRIDE - 64)) | (1L << (ABSTRACT - 64)) | (1L << (FINAL - 64)) | (1L << (OPEN - 64)) | (1L << (CONST - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (LATEINIT - 128)) | (1L << (VARARG - 128)) | (1L << (NOINLINE - 128)) | (1L << (CROSSINLINE - 128)) | (1L << (REIFIED - 128)) | (1L << (EXPECT - 128)) | (1L << (ACTUAL - 128)) | (1L << (RealLiteral - 128)) | (1L << (IntegerLiteral - 128)) | (1L << (HexLiteral - 128)) | (1L << (BinLiteral - 128)) | (1L << (UnsignedLiteral - 128)) | (1L << (LongLiteral - 128)) | (1L << (BooleanLiteral - 128)) | (1L << (NullLiteral - 128)) | (1L << (CharacterLiteral - 128)) | (1L << (Identifier - 128)) | (1L << (QUOTE_OPEN - 128)) | (1L << (TRIPLE_QUOTE_OPEN - 128)))) != 0)) { - { - setState(2478); - valueArgument(); - setState(2495); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,373,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2482); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2479); - match(NL); - } - } - setState(2484); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2485); - match(COMMA); - setState(2489); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,372,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2486); - match(NL); - } - } - } - setState(2491); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,372,_ctx); - } - setState(2492); - valueArgument(); - } - } - } - setState(2497); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,373,_ctx); - } - setState(2505); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,375,_ctx) ) { - case 1: - { - setState(2501); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2498); - match(NL); - } - } - setState(2503); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2504); - match(COMMA); - } - break; - } - setState(2510); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2507); - match(NL); - } - } - setState(2512); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - - setState(2515); - match(RPAREN); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ValueArgumentContext extends ParserRuleContext { - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public AnnotationContext annotation() { - return getRuleContext(AnnotationContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public TerminalNode ASSIGNMENT() { return getToken(KotlinParser.ASSIGNMENT, 0); } - public TerminalNode MULT() { return getToken(KotlinParser.MULT, 0); } - public ValueArgumentContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_valueArgument; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterValueArgument(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitValueArgument(this); - } - } - - public final ValueArgumentContext valueArgument() throws RecognitionException { - ValueArgumentContext _localctx = new ValueArgumentContext(_ctx, getState()); - enterRule(_localctx, 208, RULE_valueArgument); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2518); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,378,_ctx) ) { - case 1: - { - setState(2517); - annotation(); - } - break; - } - setState(2523); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,379,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2520); - match(NL); - } - } - } - setState(2525); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,379,_ctx); - } - setState(2540); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,382,_ctx) ) { - case 1: - { - setState(2526); - simpleIdentifier(); - setState(2530); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2527); - match(NL); - } - } - setState(2532); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2533); - match(ASSIGNMENT); - setState(2537); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,381,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2534); - match(NL); - } - } - } - setState(2539); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,381,_ctx); - } - } - break; - } - setState(2543); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==MULT) { - { - setState(2542); - match(MULT); - } - } - - setState(2548); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2545); - match(NL); - } - } - setState(2550); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2551); - expression(); - } - } - 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 ParenthesizedExpressionContext parenthesizedExpression() { - return getRuleContext(ParenthesizedExpressionContext.class,0); - } - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public LiteralConstantContext literalConstant() { - return getRuleContext(LiteralConstantContext.class,0); - } - public StringLiteralContext stringLiteral() { - return getRuleContext(StringLiteralContext.class,0); - } - public CallableReferenceContext callableReference() { - return getRuleContext(CallableReferenceContext.class,0); - } - public FunctionLiteralContext functionLiteral() { - return getRuleContext(FunctionLiteralContext.class,0); - } - public ObjectLiteralContext objectLiteral() { - return getRuleContext(ObjectLiteralContext.class,0); - } - public CollectionLiteralContext collectionLiteral() { - return getRuleContext(CollectionLiteralContext.class,0); - } - public ThisExpressionContext thisExpression() { - return getRuleContext(ThisExpressionContext.class,0); - } - public SuperExpressionContext superExpression() { - return getRuleContext(SuperExpressionContext.class,0); - } - public IfExpressionContext ifExpression() { - return getRuleContext(IfExpressionContext.class,0); - } - public WhenExpressionContext whenExpression() { - return getRuleContext(WhenExpressionContext.class,0); - } - public TryExpressionContext tryExpression() { - return getRuleContext(TryExpressionContext.class,0); - } - public JumpExpressionContext jumpExpression() { - return getRuleContext(JumpExpressionContext.class,0); - } - public PrimaryExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_primaryExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterPrimaryExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitPrimaryExpression(this); - } - } - - public final PrimaryExpressionContext primaryExpression() throws RecognitionException { - PrimaryExpressionContext _localctx = new PrimaryExpressionContext(_ctx, getState()); - enterRule(_localctx, 210, RULE_primaryExpression); - try { - setState(2567); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,385,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(2553); - parenthesizedExpression(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(2554); - simpleIdentifier(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(2555); - literalConstant(); - } - break; - case 4: - enterOuterAlt(_localctx, 4); - { - setState(2556); - stringLiteral(); - } - break; - case 5: - enterOuterAlt(_localctx, 5); - { - setState(2557); - callableReference(); - } - break; - case 6: - enterOuterAlt(_localctx, 6); - { - setState(2558); - functionLiteral(); - } - break; - case 7: - enterOuterAlt(_localctx, 7); - { - setState(2559); - objectLiteral(); - } - break; - case 8: - enterOuterAlt(_localctx, 8); - { - setState(2560); - collectionLiteral(); - } - break; - case 9: - enterOuterAlt(_localctx, 9); - { - setState(2561); - thisExpression(); - } - break; - case 10: - enterOuterAlt(_localctx, 10); - { - setState(2562); - superExpression(); - } - break; - case 11: - enterOuterAlt(_localctx, 11); - { - setState(2563); - ifExpression(); - } - break; - case 12: - enterOuterAlt(_localctx, 12); - { - setState(2564); - whenExpression(); - } - break; - case 13: - enterOuterAlt(_localctx, 13); - { - setState(2565); - tryExpression(); - } - break; - case 14: - enterOuterAlt(_localctx, 14); - { - setState(2566); - jumpExpression(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ParenthesizedExpressionContext extends ParserRuleContext { - public TerminalNode LPAREN() { return getToken(KotlinParser.LPAREN, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode RPAREN() { return getToken(KotlinParser.RPAREN, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public ParenthesizedExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_parenthesizedExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterParenthesizedExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitParenthesizedExpression(this); - } - } - - public final ParenthesizedExpressionContext parenthesizedExpression() throws RecognitionException { - ParenthesizedExpressionContext _localctx = new ParenthesizedExpressionContext(_ctx, getState()); - enterRule(_localctx, 212, RULE_parenthesizedExpression); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2569); - match(LPAREN); - setState(2573); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2570); - match(NL); - } - } - setState(2575); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2576); - expression(); - setState(2580); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2577); - match(NL); - } - } - setState(2582); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2583); - match(RPAREN); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class CollectionLiteralContext extends ParserRuleContext { - public TerminalNode LSQUARE() { return getToken(KotlinParser.LSQUARE, 0); } - public TerminalNode RSQUARE() { return getToken(KotlinParser.RSQUARE, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public List expression() { - return getRuleContexts(ExpressionContext.class); - } - public ExpressionContext expression(int i) { - return getRuleContext(ExpressionContext.class,i); - } - public List COMMA() { return getTokens(KotlinParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(KotlinParser.COMMA, i); - } - public CollectionLiteralContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_collectionLiteral; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterCollectionLiteral(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitCollectionLiteral(this); - } - } - - public final CollectionLiteralContext collectionLiteral() throws RecognitionException { - CollectionLiteralContext _localctx = new CollectionLiteralContext(_ctx, getState()); - enterRule(_localctx, 214, RULE_collectionLiteral); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2585); - match(LSQUARE); - setState(2589); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2586); - match(NL); - } - } - setState(2591); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2627); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LPAREN) | (1L << LSQUARE) | (1L << LCURL) | (1L << ADD) | (1L << SUB) | (1L << INCR) | (1L << DECR) | (1L << EXCL_WS) | (1L << EXCL_NO_WS) | (1L << COLONCOLON) | (1L << AT_NO_WS) | (1L << AT_PRE_WS) | (1L << RETURN_AT) | (1L << CONTINUE_AT) | (1L << BREAK_AT) | (1L << THIS_AT) | (1L << SUPER_AT) | (1L << FILE) | (1L << FIELD) | (1L << PROPERTY))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (GET - 64)) | (1L << (SET - 64)) | (1L << (RECEIVER - 64)) | (1L << (PARAM - 64)) | (1L << (SETPARAM - 64)) | (1L << (DELEGATE - 64)) | (1L << (IMPORT - 64)) | (1L << (FUN - 64)) | (1L << (OBJECT - 64)) | (1L << (CONSTRUCTOR - 64)) | (1L << (BY - 64)) | (1L << (COMPANION - 64)) | (1L << (INIT - 64)) | (1L << (THIS - 64)) | (1L << (SUPER - 64)) | (1L << (WHERE - 64)) | (1L << (IF - 64)) | (1L << (WHEN - 64)) | (1L << (TRY - 64)) | (1L << (CATCH - 64)) | (1L << (FINALLY - 64)) | (1L << (THROW - 64)) | (1L << (RETURN - 64)) | (1L << (CONTINUE - 64)) | (1L << (BREAK - 64)) | (1L << (OUT - 64)) | (1L << (DYNAMIC - 64)) | (1L << (PUBLIC - 64)) | (1L << (PRIVATE - 64)) | (1L << (PROTECTED - 64)) | (1L << (INTERNAL - 64)) | (1L << (ENUM - 64)) | (1L << (SEALED - 64)) | (1L << (ANNOTATION - 64)) | (1L << (DATA - 64)) | (1L << (INNER - 64)) | (1L << (VALUE - 64)) | (1L << (TAILREC - 64)) | (1L << (OPERATOR - 64)) | (1L << (INLINE - 64)) | (1L << (INFIX - 64)) | (1L << (EXTERNAL - 64)) | (1L << (SUSPEND - 64)) | (1L << (OVERRIDE - 64)) | (1L << (ABSTRACT - 64)) | (1L << (FINAL - 64)) | (1L << (OPEN - 64)) | (1L << (CONST - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (LATEINIT - 128)) | (1L << (VARARG - 128)) | (1L << (NOINLINE - 128)) | (1L << (CROSSINLINE - 128)) | (1L << (REIFIED - 128)) | (1L << (EXPECT - 128)) | (1L << (ACTUAL - 128)) | (1L << (RealLiteral - 128)) | (1L << (IntegerLiteral - 128)) | (1L << (HexLiteral - 128)) | (1L << (BinLiteral - 128)) | (1L << (UnsignedLiteral - 128)) | (1L << (LongLiteral - 128)) | (1L << (BooleanLiteral - 128)) | (1L << (NullLiteral - 128)) | (1L << (CharacterLiteral - 128)) | (1L << (Identifier - 128)) | (1L << (QUOTE_OPEN - 128)) | (1L << (TRIPLE_QUOTE_OPEN - 128)))) != 0)) { - { - setState(2592); - expression(); - setState(2609); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,391,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2596); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2593); - match(NL); - } - } - setState(2598); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2599); - match(COMMA); - setState(2603); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2600); - match(NL); - } - } - setState(2605); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2606); - expression(); - } - } - } - setState(2611); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,391,_ctx); - } - setState(2619); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,393,_ctx) ) { - case 1: - { - setState(2615); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2612); - match(NL); - } - } - setState(2617); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2618); - match(COMMA); - } - break; - } - setState(2624); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2621); - match(NL); - } - } - setState(2626); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - } - - setState(2629); - match(RSQUARE); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class LiteralConstantContext extends ParserRuleContext { - public TerminalNode BooleanLiteral() { return getToken(KotlinParser.BooleanLiteral, 0); } - public TerminalNode IntegerLiteral() { return getToken(KotlinParser.IntegerLiteral, 0); } - public TerminalNode HexLiteral() { return getToken(KotlinParser.HexLiteral, 0); } - public TerminalNode BinLiteral() { return getToken(KotlinParser.BinLiteral, 0); } - public TerminalNode CharacterLiteral() { return getToken(KotlinParser.CharacterLiteral, 0); } - public TerminalNode RealLiteral() { return getToken(KotlinParser.RealLiteral, 0); } - public TerminalNode NullLiteral() { return getToken(KotlinParser.NullLiteral, 0); } - public TerminalNode LongLiteral() { return getToken(KotlinParser.LongLiteral, 0); } - public TerminalNode UnsignedLiteral() { return getToken(KotlinParser.UnsignedLiteral, 0); } - public LiteralConstantContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_literalConstant; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterLiteralConstant(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitLiteralConstant(this); - } - } - - public final LiteralConstantContext literalConstant() throws RecognitionException { - LiteralConstantContext _localctx = new LiteralConstantContext(_ctx, getState()); - enterRule(_localctx, 216, RULE_literalConstant); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2631); - _la = _input.LA(1); - if ( !(((((_la - 135)) & ~0x3f) == 0 && ((1L << (_la - 135)) & ((1L << (RealLiteral - 135)) | (1L << (IntegerLiteral - 135)) | (1L << (HexLiteral - 135)) | (1L << (BinLiteral - 135)) | (1L << (UnsignedLiteral - 135)) | (1L << (LongLiteral - 135)) | (1L << (BooleanLiteral - 135)) | (1L << (NullLiteral - 135)) | (1L << (CharacterLiteral - 135)))) != 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 StringLiteralContext extends ParserRuleContext { - public LineStringLiteralContext lineStringLiteral() { - return getRuleContext(LineStringLiteralContext.class,0); - } - public MultiLineStringLiteralContext multiLineStringLiteral() { - return getRuleContext(MultiLineStringLiteralContext.class,0); - } - public StringLiteralContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_stringLiteral; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterStringLiteral(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitStringLiteral(this); - } - } - - public final StringLiteralContext stringLiteral() throws RecognitionException { - StringLiteralContext _localctx = new StringLiteralContext(_ctx, getState()); - enterRule(_localctx, 218, RULE_stringLiteral); - try { - setState(2635); - _errHandler.sync(this); - switch (_input.LA(1)) { - case QUOTE_OPEN: - enterOuterAlt(_localctx, 1); - { - setState(2633); - lineStringLiteral(); - } - break; - case TRIPLE_QUOTE_OPEN: - enterOuterAlt(_localctx, 2); - { - setState(2634); - multiLineStringLiteral(); - } - 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 LineStringLiteralContext extends ParserRuleContext { - public TerminalNode QUOTE_OPEN() { return getToken(KotlinParser.QUOTE_OPEN, 0); } - public TerminalNode QUOTE_CLOSE() { return getToken(KotlinParser.QUOTE_CLOSE, 0); } - public List lineStringContent() { - return getRuleContexts(LineStringContentContext.class); - } - public LineStringContentContext lineStringContent(int i) { - return getRuleContext(LineStringContentContext.class,i); - } - public List lineStringExpression() { - return getRuleContexts(LineStringExpressionContext.class); - } - public LineStringExpressionContext lineStringExpression(int i) { - return getRuleContext(LineStringExpressionContext.class,i); - } - public LineStringLiteralContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_lineStringLiteral; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterLineStringLiteral(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitLineStringLiteral(this); - } - } - - public final LineStringLiteralContext lineStringLiteral() throws RecognitionException { - LineStringLiteralContext _localctx = new LineStringLiteralContext(_ctx, getState()); - enterRule(_localctx, 220, RULE_lineStringLiteral); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2637); - match(QUOTE_OPEN); - setState(2642); - _errHandler.sync(this); - _la = _input.LA(1); - while (((((_la - 159)) & ~0x3f) == 0 && ((1L << (_la - 159)) & ((1L << (LineStrRef - 159)) | (1L << (LineStrText - 159)) | (1L << (LineStrEscapedChar - 159)) | (1L << (LineStrExprStart - 159)))) != 0)) { - { - setState(2640); - _errHandler.sync(this); - switch (_input.LA(1)) { - case LineStrRef: - case LineStrText: - case LineStrEscapedChar: - { - setState(2638); - lineStringContent(); - } - break; - case LineStrExprStart: - { - setState(2639); - lineStringExpression(); - } - break; - default: - throw new NoViableAltException(this); - } - } - setState(2644); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2645); - match(QUOTE_CLOSE); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class MultiLineStringLiteralContext extends ParserRuleContext { - public TerminalNode TRIPLE_QUOTE_OPEN() { return getToken(KotlinParser.TRIPLE_QUOTE_OPEN, 0); } - public TerminalNode TRIPLE_QUOTE_CLOSE() { return getToken(KotlinParser.TRIPLE_QUOTE_CLOSE, 0); } - public List multiLineStringContent() { - return getRuleContexts(MultiLineStringContentContext.class); - } - public MultiLineStringContentContext multiLineStringContent(int i) { - return getRuleContext(MultiLineStringContentContext.class,i); - } - public List multiLineStringExpression() { - return getRuleContexts(MultiLineStringExpressionContext.class); - } - public MultiLineStringExpressionContext multiLineStringExpression(int i) { - return getRuleContext(MultiLineStringExpressionContext.class,i); - } - public List MultiLineStringQuote() { return getTokens(KotlinParser.MultiLineStringQuote); } - public TerminalNode MultiLineStringQuote(int i) { - return getToken(KotlinParser.MultiLineStringQuote, i); - } - public MultiLineStringLiteralContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_multiLineStringLiteral; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterMultiLineStringLiteral(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitMultiLineStringLiteral(this); - } - } - - public final MultiLineStringLiteralContext multiLineStringLiteral() throws RecognitionException { - MultiLineStringLiteralContext _localctx = new MultiLineStringLiteralContext(_ctx, getState()); - enterRule(_localctx, 222, RULE_multiLineStringLiteral); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2647); - match(TRIPLE_QUOTE_OPEN); - setState(2653); - _errHandler.sync(this); - _la = _input.LA(1); - while (((((_la - 164)) & ~0x3f) == 0 && ((1L << (_la - 164)) & ((1L << (MultiLineStringQuote - 164)) | (1L << (MultiLineStrRef - 164)) | (1L << (MultiLineStrText - 164)) | (1L << (MultiLineStrExprStart - 164)))) != 0)) { - { - setState(2651); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,399,_ctx) ) { - case 1: - { - setState(2648); - multiLineStringContent(); - } - break; - case 2: - { - setState(2649); - multiLineStringExpression(); - } - break; - case 3: - { - setState(2650); - match(MultiLineStringQuote); - } - break; - } - } - setState(2655); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2656); - match(TRIPLE_QUOTE_CLOSE); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class LineStringContentContext extends ParserRuleContext { - public TerminalNode LineStrText() { return getToken(KotlinParser.LineStrText, 0); } - public TerminalNode LineStrEscapedChar() { return getToken(KotlinParser.LineStrEscapedChar, 0); } - public TerminalNode LineStrRef() { return getToken(KotlinParser.LineStrRef, 0); } - public LineStringContentContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_lineStringContent; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterLineStringContent(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitLineStringContent(this); - } - } - - public final LineStringContentContext lineStringContent() throws RecognitionException { - LineStringContentContext _localctx = new LineStringContentContext(_ctx, getState()); - enterRule(_localctx, 224, RULE_lineStringContent); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2658); - _la = _input.LA(1); - if ( !(((((_la - 159)) & ~0x3f) == 0 && ((1L << (_la - 159)) & ((1L << (LineStrRef - 159)) | (1L << (LineStrText - 159)) | (1L << (LineStrEscapedChar - 159)))) != 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 LineStringExpressionContext extends ParserRuleContext { - public TerminalNode LineStrExprStart() { return getToken(KotlinParser.LineStrExprStart, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode RCURL() { return getToken(KotlinParser.RCURL, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public LineStringExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_lineStringExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterLineStringExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitLineStringExpression(this); - } - } - - public final LineStringExpressionContext lineStringExpression() throws RecognitionException { - LineStringExpressionContext _localctx = new LineStringExpressionContext(_ctx, getState()); - enterRule(_localctx, 226, RULE_lineStringExpression); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2660); - match(LineStrExprStart); - setState(2664); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2661); - match(NL); - } - } - setState(2666); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2667); - expression(); - setState(2671); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2668); - match(NL); - } - } - setState(2673); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2674); - match(RCURL); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class MultiLineStringContentContext extends ParserRuleContext { - public TerminalNode MultiLineStrText() { return getToken(KotlinParser.MultiLineStrText, 0); } - public TerminalNode MultiLineStringQuote() { return getToken(KotlinParser.MultiLineStringQuote, 0); } - public TerminalNode MultiLineStrRef() { return getToken(KotlinParser.MultiLineStrRef, 0); } - public MultiLineStringContentContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_multiLineStringContent; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterMultiLineStringContent(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitMultiLineStringContent(this); - } - } - - public final MultiLineStringContentContext multiLineStringContent() throws RecognitionException { - MultiLineStringContentContext _localctx = new MultiLineStringContentContext(_ctx, getState()); - enterRule(_localctx, 228, RULE_multiLineStringContent); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2676); - _la = _input.LA(1); - if ( !(((((_la - 164)) & ~0x3f) == 0 && ((1L << (_la - 164)) & ((1L << (MultiLineStringQuote - 164)) | (1L << (MultiLineStrRef - 164)) | (1L << (MultiLineStrText - 164)))) != 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 MultiLineStringExpressionContext extends ParserRuleContext { - public TerminalNode MultiLineStrExprStart() { return getToken(KotlinParser.MultiLineStrExprStart, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode RCURL() { return getToken(KotlinParser.RCURL, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public MultiLineStringExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_multiLineStringExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterMultiLineStringExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitMultiLineStringExpression(this); - } - } - - public final MultiLineStringExpressionContext multiLineStringExpression() throws RecognitionException { - MultiLineStringExpressionContext _localctx = new MultiLineStringExpressionContext(_ctx, getState()); - enterRule(_localctx, 230, RULE_multiLineStringExpression); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2678); - match(MultiLineStrExprStart); - setState(2682); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2679); - match(NL); - } - } - setState(2684); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2685); - expression(); - setState(2689); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2686); - match(NL); - } - } - setState(2691); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2692); - match(RCURL); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class LambdaLiteralContext extends ParserRuleContext { - public TerminalNode LCURL() { return getToken(KotlinParser.LCURL, 0); } - public StatementsContext statements() { - return getRuleContext(StatementsContext.class,0); - } - public TerminalNode RCURL() { return getToken(KotlinParser.RCURL, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TerminalNode ARROW() { return getToken(KotlinParser.ARROW, 0); } - public LambdaParametersContext lambdaParameters() { - return getRuleContext(LambdaParametersContext.class,0); - } - public LambdaLiteralContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_lambdaLiteral; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterLambdaLiteral(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitLambdaLiteral(this); - } - } - - public final LambdaLiteralContext lambdaLiteral() throws RecognitionException { - LambdaLiteralContext _localctx = new LambdaLiteralContext(_ctx, getState()); - enterRule(_localctx, 232, RULE_lambdaLiteral); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2694); - match(LCURL); - setState(2698); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,405,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2695); - match(NL); - } - } - } - setState(2700); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,405,_ctx); - } - setState(2717); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,409,_ctx) ) { - case 1: - { - setState(2702); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,406,_ctx) ) { - case 1: - { - setState(2701); - lambdaParameters(); - } - break; - } - setState(2707); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2704); - match(NL); - } - } - setState(2709); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2710); - match(ARROW); - setState(2714); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,408,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2711); - match(NL); - } - } - } - setState(2716); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,408,_ctx); - } - } - break; - } - setState(2719); - statements(); - setState(2723); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2720); - match(NL); - } - } - setState(2725); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2726); - match(RCURL); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class LambdaParametersContext extends ParserRuleContext { - public List lambdaParameter() { - return getRuleContexts(LambdaParameterContext.class); - } - public LambdaParameterContext lambdaParameter(int i) { - return getRuleContext(LambdaParameterContext.class,i); - } - public List COMMA() { return getTokens(KotlinParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(KotlinParser.COMMA, i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public LambdaParametersContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_lambdaParameters; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterLambdaParameters(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitLambdaParameters(this); - } - } - - public final LambdaParametersContext lambdaParameters() throws RecognitionException { - LambdaParametersContext _localctx = new LambdaParametersContext(_ctx, getState()); - enterRule(_localctx, 234, RULE_lambdaParameters); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2728); - lambdaParameter(); - setState(2745); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,413,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2732); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2729); - match(NL); - } - } - setState(2734); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2735); - match(COMMA); - setState(2739); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,412,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2736); - match(NL); - } - } - } - setState(2741); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,412,_ctx); - } - setState(2742); - lambdaParameter(); - } - } - } - setState(2747); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,413,_ctx); - } - setState(2755); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,415,_ctx) ) { - case 1: - { - setState(2751); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2748); - match(NL); - } - } - setState(2753); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2754); - match(COMMA); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class LambdaParameterContext extends ParserRuleContext { - public VariableDeclarationContext variableDeclaration() { - return getRuleContext(VariableDeclarationContext.class,0); - } - public MultiVariableDeclarationContext multiVariableDeclaration() { - return getRuleContext(MultiVariableDeclarationContext.class,0); - } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public LambdaParameterContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_lambdaParameter; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterLambdaParameter(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitLambdaParameter(this); - } - } - - public final LambdaParameterContext lambdaParameter() throws RecognitionException { - LambdaParameterContext _localctx = new LambdaParameterContext(_ctx, getState()); - enterRule(_localctx, 236, RULE_lambdaParameter); - int _la; - try { - setState(2775); - _errHandler.sync(this); - switch (_input.LA(1)) { - case NL: - case AT_NO_WS: - case AT_PRE_WS: - case FILE: - case FIELD: - case PROPERTY: - case GET: - case SET: - case RECEIVER: - case PARAM: - case SETPARAM: - case DELEGATE: - case IMPORT: - case CONSTRUCTOR: - case BY: - case COMPANION: - case INIT: - case WHERE: - case CATCH: - case FINALLY: - case OUT: - case DYNAMIC: - case PUBLIC: - case PRIVATE: - case PROTECTED: - case INTERNAL: - case ENUM: - case SEALED: - case ANNOTATION: - case DATA: - case INNER: - case VALUE: - case TAILREC: - case OPERATOR: - case INLINE: - case INFIX: - case EXTERNAL: - case SUSPEND: - case OVERRIDE: - case ABSTRACT: - case FINAL: - case OPEN: - case CONST: - case LATEINIT: - case VARARG: - case NOINLINE: - case CROSSINLINE: - case REIFIED: - case EXPECT: - case ACTUAL: - case Identifier: - enterOuterAlt(_localctx, 1); - { - setState(2757); - variableDeclaration(); - } - break; - case LPAREN: - enterOuterAlt(_localctx, 2); - { - setState(2758); - multiVariableDeclaration(); - setState(2773); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,418,_ctx) ) { - case 1: - { - setState(2762); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2759); - match(NL); - } - } - setState(2764); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2765); - match(COLON); - setState(2769); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2766); - match(NL); - } - } - setState(2771); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2772); - type(); - } - 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 AnonymousFunctionContext extends ParserRuleContext { - public TerminalNode FUN() { return getToken(KotlinParser.FUN, 0); } - public ParametersWithOptionalTypeContext parametersWithOptionalType() { - return getRuleContext(ParametersWithOptionalTypeContext.class,0); - } - public List type() { - return getRuleContexts(TypeContext.class); - } - public TypeContext type(int i) { - return getRuleContext(TypeContext.class,i); - } - public TerminalNode DOT() { return getToken(KotlinParser.DOT, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public TypeConstraintsContext typeConstraints() { - return getRuleContext(TypeConstraintsContext.class,0); - } - public FunctionBodyContext functionBody() { - return getRuleContext(FunctionBodyContext.class,0); - } - public AnonymousFunctionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_anonymousFunction; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterAnonymousFunction(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitAnonymousFunction(this); - } - } - - public final AnonymousFunctionContext anonymousFunction() throws RecognitionException { - AnonymousFunctionContext _localctx = new AnonymousFunctionContext(_ctx, getState()); - enterRule(_localctx, 238, RULE_anonymousFunction); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2777); - match(FUN); - setState(2793); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,422,_ctx) ) { - case 1: - { - setState(2781); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2778); - match(NL); - } - } - setState(2783); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2784); - type(); - setState(2788); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2785); - match(NL); - } - } - setState(2790); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2791); - match(DOT); - } - break; - } - setState(2798); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2795); - match(NL); - } - } - setState(2800); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2801); - parametersWithOptionalType(); - setState(2816); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,426,_ctx) ) { - case 1: - { - setState(2805); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2802); - match(NL); - } - } - setState(2807); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2808); - match(COLON); - setState(2812); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2809); - match(NL); - } - } - setState(2814); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2815); - type(); - } - break; - } - setState(2825); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,428,_ctx) ) { - case 1: - { - setState(2821); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2818); - match(NL); - } - } - setState(2823); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2824); - typeConstraints(); - } - break; - } - setState(2834); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,430,_ctx) ) { - case 1: - { - setState(2830); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2827); - match(NL); - } - } - setState(2832); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2833); - functionBody(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class FunctionLiteralContext extends ParserRuleContext { - public LambdaLiteralContext lambdaLiteral() { - return getRuleContext(LambdaLiteralContext.class,0); - } - public AnonymousFunctionContext anonymousFunction() { - return getRuleContext(AnonymousFunctionContext.class,0); - } - public FunctionLiteralContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_functionLiteral; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterFunctionLiteral(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitFunctionLiteral(this); - } - } - - public final FunctionLiteralContext functionLiteral() throws RecognitionException { - FunctionLiteralContext _localctx = new FunctionLiteralContext(_ctx, getState()); - enterRule(_localctx, 240, RULE_functionLiteral); - try { - setState(2838); - _errHandler.sync(this); - switch (_input.LA(1)) { - case LCURL: - enterOuterAlt(_localctx, 1); - { - setState(2836); - lambdaLiteral(); - } - break; - case FUN: - enterOuterAlt(_localctx, 2); - { - setState(2837); - anonymousFunction(); - } - 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 ObjectLiteralContext extends ParserRuleContext { - public TerminalNode OBJECT() { return getToken(KotlinParser.OBJECT, 0); } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public DelegationSpecifiersContext delegationSpecifiers() { - return getRuleContext(DelegationSpecifiersContext.class,0); - } - public ClassBodyContext classBody() { - return getRuleContext(ClassBodyContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public ObjectLiteralContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_objectLiteral; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterObjectLiteral(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitObjectLiteral(this); - } - } - - public final ObjectLiteralContext objectLiteral() throws RecognitionException { - ObjectLiteralContext _localctx = new ObjectLiteralContext(_ctx, getState()); - enterRule(_localctx, 242, RULE_objectLiteral); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2840); - match(OBJECT); - setState(2861); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,435,_ctx) ) { - case 1: - { - setState(2844); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2841); - match(NL); - } - } - setState(2846); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2847); - match(COLON); - setState(2851); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,433,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2848); - match(NL); - } - } - } - setState(2853); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,433,_ctx); - } - setState(2854); - delegationSpecifiers(); - setState(2858); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,434,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2855); - match(NL); - } - } - } - setState(2860); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,434,_ctx); - } - } - break; - } - setState(2870); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,437,_ctx) ) { - case 1: - { - setState(2866); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2863); - match(NL); - } - } - setState(2868); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2869); - classBody(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ThisExpressionContext extends ParserRuleContext { - public TerminalNode THIS() { return getToken(KotlinParser.THIS, 0); } - public TerminalNode THIS_AT() { return getToken(KotlinParser.THIS_AT, 0); } - public ThisExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_thisExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterThisExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitThisExpression(this); - } - } - - public final ThisExpressionContext thisExpression() throws RecognitionException { - ThisExpressionContext _localctx = new ThisExpressionContext(_ctx, getState()); - enterRule(_localctx, 244, RULE_thisExpression); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(2872); - _la = _input.LA(1); - if ( !(_la==THIS_AT || _la==THIS) ) { - _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 SuperExpressionContext extends ParserRuleContext { - public TerminalNode SUPER() { return getToken(KotlinParser.SUPER, 0); } - public TerminalNode LANGLE() { return getToken(KotlinParser.LANGLE, 0); } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public TerminalNode RANGLE() { return getToken(KotlinParser.RANGLE, 0); } - public TerminalNode AT_NO_WS() { return getToken(KotlinParser.AT_NO_WS, 0); } - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TerminalNode SUPER_AT() { return getToken(KotlinParser.SUPER_AT, 0); } - public SuperExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_superExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterSuperExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitSuperExpression(this); - } - } - - public final SuperExpressionContext superExpression() throws RecognitionException { - SuperExpressionContext _localctx = new SuperExpressionContext(_ctx, getState()); - enterRule(_localctx, 246, RULE_superExpression); - int _la; - try { - setState(2898); - _errHandler.sync(this); - switch (_input.LA(1)) { - case SUPER: - enterOuterAlt(_localctx, 1); - { - setState(2874); - match(SUPER); - setState(2891); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,440,_ctx) ) { - case 1: - { - setState(2875); - match(LANGLE); - setState(2879); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2876); - match(NL); - } - } - setState(2881); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2882); - type(); - setState(2886); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2883); - match(NL); - } - } - setState(2888); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2889); - match(RANGLE); - } - break; - } - setState(2895); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,441,_ctx) ) { - case 1: - { - setState(2893); - match(AT_NO_WS); - setState(2894); - simpleIdentifier(); - } - break; - } - } - break; - case SUPER_AT: - enterOuterAlt(_localctx, 2); - { - setState(2897); - match(SUPER_AT); - } - 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 IfExpressionContext extends ParserRuleContext { - public TerminalNode IF() { return getToken(KotlinParser.IF, 0); } - public TerminalNode LPAREN() { return getToken(KotlinParser.LPAREN, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode RPAREN() { return getToken(KotlinParser.RPAREN, 0); } - public List controlStructureBody() { - return getRuleContexts(ControlStructureBodyContext.class); - } - public ControlStructureBodyContext controlStructureBody(int i) { - return getRuleContext(ControlStructureBodyContext.class,i); - } - public TerminalNode ELSE() { return getToken(KotlinParser.ELSE, 0); } - public List SEMICOLON() { return getTokens(KotlinParser.SEMICOLON); } - public TerminalNode SEMICOLON(int i) { - return getToken(KotlinParser.SEMICOLON, i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public IfExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_ifExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterIfExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitIfExpression(this); - } - } - - public final IfExpressionContext ifExpression() throws RecognitionException { - IfExpressionContext _localctx = new IfExpressionContext(_ctx, getState()); - enterRule(_localctx, 248, RULE_ifExpression); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2900); - match(IF); - setState(2904); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2901); - match(NL); - } - } - setState(2906); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2907); - match(LPAREN); - setState(2911); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2908); - match(NL); - } - } - setState(2913); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2914); - expression(); - setState(2918); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2915); - match(NL); - } - } - setState(2920); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2921); - match(RPAREN); - setState(2925); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,446,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2922); - match(NL); - } - } - } - setState(2927); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,446,_ctx); - } - setState(2959); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,453,_ctx) ) { - case 1: - { - setState(2928); - controlStructureBody(); - } - break; - case 2: - { - setState(2930); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LPAREN) | (1L << LSQUARE) | (1L << LCURL) | (1L << ADD) | (1L << SUB) | (1L << INCR) | (1L << DECR) | (1L << EXCL_WS) | (1L << EXCL_NO_WS) | (1L << COLONCOLON) | (1L << AT_NO_WS) | (1L << AT_PRE_WS) | (1L << RETURN_AT) | (1L << CONTINUE_AT) | (1L << BREAK_AT) | (1L << THIS_AT) | (1L << SUPER_AT) | (1L << FILE) | (1L << FIELD) | (1L << PROPERTY))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (GET - 64)) | (1L << (SET - 64)) | (1L << (RECEIVER - 64)) | (1L << (PARAM - 64)) | (1L << (SETPARAM - 64)) | (1L << (DELEGATE - 64)) | (1L << (IMPORT - 64)) | (1L << (CLASS - 64)) | (1L << (INTERFACE - 64)) | (1L << (FUN - 64)) | (1L << (OBJECT - 64)) | (1L << (VAL - 64)) | (1L << (VAR - 64)) | (1L << (TYPE_ALIAS - 64)) | (1L << (CONSTRUCTOR - 64)) | (1L << (BY - 64)) | (1L << (COMPANION - 64)) | (1L << (INIT - 64)) | (1L << (THIS - 64)) | (1L << (SUPER - 64)) | (1L << (WHERE - 64)) | (1L << (IF - 64)) | (1L << (WHEN - 64)) | (1L << (TRY - 64)) | (1L << (CATCH - 64)) | (1L << (FINALLY - 64)) | (1L << (FOR - 64)) | (1L << (DO - 64)) | (1L << (WHILE - 64)) | (1L << (THROW - 64)) | (1L << (RETURN - 64)) | (1L << (CONTINUE - 64)) | (1L << (BREAK - 64)) | (1L << (OUT - 64)) | (1L << (DYNAMIC - 64)) | (1L << (PUBLIC - 64)) | (1L << (PRIVATE - 64)) | (1L << (PROTECTED - 64)) | (1L << (INTERNAL - 64)) | (1L << (ENUM - 64)) | (1L << (SEALED - 64)) | (1L << (ANNOTATION - 64)) | (1L << (DATA - 64)) | (1L << (INNER - 64)) | (1L << (VALUE - 64)) | (1L << (TAILREC - 64)) | (1L << (OPERATOR - 64)) | (1L << (INLINE - 64)) | (1L << (INFIX - 64)) | (1L << (EXTERNAL - 64)) | (1L << (SUSPEND - 64)) | (1L << (OVERRIDE - 64)) | (1L << (ABSTRACT - 64)) | (1L << (FINAL - 64)) | (1L << (OPEN - 64)) | (1L << (CONST - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (LATEINIT - 128)) | (1L << (VARARG - 128)) | (1L << (NOINLINE - 128)) | (1L << (CROSSINLINE - 128)) | (1L << (REIFIED - 128)) | (1L << (EXPECT - 128)) | (1L << (ACTUAL - 128)) | (1L << (RealLiteral - 128)) | (1L << (IntegerLiteral - 128)) | (1L << (HexLiteral - 128)) | (1L << (BinLiteral - 128)) | (1L << (UnsignedLiteral - 128)) | (1L << (LongLiteral - 128)) | (1L << (BooleanLiteral - 128)) | (1L << (NullLiteral - 128)) | (1L << (CharacterLiteral - 128)) | (1L << (Identifier - 128)) | (1L << (QUOTE_OPEN - 128)) | (1L << (TRIPLE_QUOTE_OPEN - 128)))) != 0)) { - { - setState(2929); - controlStructureBody(); - } - } - - setState(2935); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,448,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2932); - match(NL); - } - } - } - setState(2937); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,448,_ctx); - } - setState(2939); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==SEMICOLON) { - { - setState(2938); - match(SEMICOLON); - } - } - - setState(2944); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2941); - match(NL); - } - } - setState(2946); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2947); - match(ELSE); - setState(2951); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2948); - match(NL); - } - } - setState(2953); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2956); - _errHandler.sync(this); - switch (_input.LA(1)) { - case LPAREN: - case LSQUARE: - case LCURL: - case ADD: - case SUB: - case INCR: - case DECR: - case EXCL_WS: - case EXCL_NO_WS: - case COLONCOLON: - case AT_NO_WS: - case AT_PRE_WS: - case RETURN_AT: - case CONTINUE_AT: - case BREAK_AT: - case THIS_AT: - case SUPER_AT: - case FILE: - case FIELD: - case PROPERTY: - case GET: - case SET: - case RECEIVER: - case PARAM: - case SETPARAM: - case DELEGATE: - case IMPORT: - case CLASS: - case INTERFACE: - case FUN: - case OBJECT: - case VAL: - case VAR: - case TYPE_ALIAS: - case CONSTRUCTOR: - case BY: - case COMPANION: - case INIT: - case THIS: - case SUPER: - case WHERE: - case IF: - case WHEN: - case TRY: - case CATCH: - case FINALLY: - case FOR: - case DO: - case WHILE: - case THROW: - case RETURN: - case CONTINUE: - case BREAK: - case OUT: - case DYNAMIC: - case PUBLIC: - case PRIVATE: - case PROTECTED: - case INTERNAL: - case ENUM: - case SEALED: - case ANNOTATION: - case DATA: - case INNER: - case VALUE: - case TAILREC: - case OPERATOR: - case INLINE: - case INFIX: - case EXTERNAL: - case SUSPEND: - case OVERRIDE: - case ABSTRACT: - case FINAL: - case OPEN: - case CONST: - case LATEINIT: - case VARARG: - case NOINLINE: - case CROSSINLINE: - case REIFIED: - case EXPECT: - case ACTUAL: - case RealLiteral: - case IntegerLiteral: - case HexLiteral: - case BinLiteral: - case UnsignedLiteral: - case LongLiteral: - case BooleanLiteral: - case NullLiteral: - case CharacterLiteral: - case Identifier: - case QUOTE_OPEN: - case TRIPLE_QUOTE_OPEN: - { - setState(2954); - controlStructureBody(); - } - break; - case SEMICOLON: - { - setState(2955); - match(SEMICOLON); - } - break; - default: - throw new NoViableAltException(this); - } - } - break; - case 3: - { - setState(2958); - match(SEMICOLON); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class WhenSubjectContext extends ParserRuleContext { - public TerminalNode LPAREN() { return getToken(KotlinParser.LPAREN, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public TerminalNode RPAREN() { return getToken(KotlinParser.RPAREN, 0); } - public TerminalNode VAL() { return getToken(KotlinParser.VAL, 0); } - public VariableDeclarationContext variableDeclaration() { - return getRuleContext(VariableDeclarationContext.class,0); - } - public TerminalNode ASSIGNMENT() { return getToken(KotlinParser.ASSIGNMENT, 0); } - public List annotation() { - return getRuleContexts(AnnotationContext.class); - } - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class,i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public WhenSubjectContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_whenSubject; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterWhenSubject(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitWhenSubject(this); - } - } - - public final WhenSubjectContext whenSubject() throws RecognitionException { - WhenSubjectContext _localctx = new WhenSubjectContext(_ctx, getState()); - enterRule(_localctx, 250, RULE_whenSubject); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(2961); - match(LPAREN); - setState(2995); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,459,_ctx) ) { - case 1: - { - setState(2965); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==AT_NO_WS || _la==AT_PRE_WS) { - { - { - setState(2962); - annotation(); - } - } - setState(2967); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2971); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2968); - match(NL); - } - } - setState(2973); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2974); - match(VAL); - setState(2978); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,456,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(2975); - match(NL); - } - } - } - setState(2980); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,456,_ctx); - } - setState(2981); - variableDeclaration(); - setState(2985); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2982); - match(NL); - } - } - setState(2987); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(2988); - match(ASSIGNMENT); - setState(2992); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(2989); - match(NL); - } - } - setState(2994); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - break; - } - setState(2997); - expression(); - setState(2998); - match(RPAREN); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class WhenExpressionContext extends ParserRuleContext { - public TerminalNode WHEN() { return getToken(KotlinParser.WHEN, 0); } - public TerminalNode LCURL() { return getToken(KotlinParser.LCURL, 0); } - public TerminalNode RCURL() { return getToken(KotlinParser.RCURL, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public WhenSubjectContext whenSubject() { - return getRuleContext(WhenSubjectContext.class,0); - } - public List whenEntry() { - return getRuleContexts(WhenEntryContext.class); - } - public WhenEntryContext whenEntry(int i) { - return getRuleContext(WhenEntryContext.class,i); - } - public WhenExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_whenExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterWhenExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitWhenExpression(this); - } - } - - public final WhenExpressionContext whenExpression() throws RecognitionException { - WhenExpressionContext _localctx = new WhenExpressionContext(_ctx, getState()); - enterRule(_localctx, 252, RULE_whenExpression); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(3000); - match(WHEN); - setState(3004); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,460,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(3001); - match(NL); - } - } - } - setState(3006); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,460,_ctx); - } - setState(3008); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==LPAREN) { - { - setState(3007); - whenSubject(); - } - } - - setState(3013); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3010); - match(NL); - } - } - setState(3015); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3016); - match(LCURL); - setState(3020); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,463,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(3017); - match(NL); - } - } - } - setState(3022); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,463,_ctx); - } - setState(3032); - _errHandler.sync(this); - _la = _input.LA(1); - while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LPAREN) | (1L << LSQUARE) | (1L << LCURL) | (1L << ADD) | (1L << SUB) | (1L << INCR) | (1L << DECR) | (1L << EXCL_WS) | (1L << EXCL_NO_WS) | (1L << COLONCOLON) | (1L << AT_NO_WS) | (1L << AT_PRE_WS) | (1L << RETURN_AT) | (1L << CONTINUE_AT) | (1L << BREAK_AT) | (1L << THIS_AT) | (1L << SUPER_AT) | (1L << FILE) | (1L << FIELD) | (1L << PROPERTY))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (GET - 64)) | (1L << (SET - 64)) | (1L << (RECEIVER - 64)) | (1L << (PARAM - 64)) | (1L << (SETPARAM - 64)) | (1L << (DELEGATE - 64)) | (1L << (IMPORT - 64)) | (1L << (FUN - 64)) | (1L << (OBJECT - 64)) | (1L << (CONSTRUCTOR - 64)) | (1L << (BY - 64)) | (1L << (COMPANION - 64)) | (1L << (INIT - 64)) | (1L << (THIS - 64)) | (1L << (SUPER - 64)) | (1L << (WHERE - 64)) | (1L << (IF - 64)) | (1L << (ELSE - 64)) | (1L << (WHEN - 64)) | (1L << (TRY - 64)) | (1L << (CATCH - 64)) | (1L << (FINALLY - 64)) | (1L << (THROW - 64)) | (1L << (RETURN - 64)) | (1L << (CONTINUE - 64)) | (1L << (BREAK - 64)) | (1L << (IS - 64)) | (1L << (IN - 64)) | (1L << (NOT_IS - 64)) | (1L << (NOT_IN - 64)) | (1L << (OUT - 64)) | (1L << (DYNAMIC - 64)) | (1L << (PUBLIC - 64)) | (1L << (PRIVATE - 64)) | (1L << (PROTECTED - 64)) | (1L << (INTERNAL - 64)) | (1L << (ENUM - 64)) | (1L << (SEALED - 64)) | (1L << (ANNOTATION - 64)) | (1L << (DATA - 64)) | (1L << (INNER - 64)) | (1L << (VALUE - 64)) | (1L << (TAILREC - 64)) | (1L << (OPERATOR - 64)) | (1L << (INLINE - 64)) | (1L << (INFIX - 64)) | (1L << (EXTERNAL - 64)) | (1L << (SUSPEND - 64)) | (1L << (OVERRIDE - 64)) | (1L << (ABSTRACT - 64)) | (1L << (FINAL - 64)) | (1L << (OPEN - 64)) | (1L << (CONST - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (LATEINIT - 128)) | (1L << (VARARG - 128)) | (1L << (NOINLINE - 128)) | (1L << (CROSSINLINE - 128)) | (1L << (REIFIED - 128)) | (1L << (EXPECT - 128)) | (1L << (ACTUAL - 128)) | (1L << (RealLiteral - 128)) | (1L << (IntegerLiteral - 128)) | (1L << (HexLiteral - 128)) | (1L << (BinLiteral - 128)) | (1L << (UnsignedLiteral - 128)) | (1L << (LongLiteral - 128)) | (1L << (BooleanLiteral - 128)) | (1L << (NullLiteral - 128)) | (1L << (CharacterLiteral - 128)) | (1L << (Identifier - 128)) | (1L << (QUOTE_OPEN - 128)) | (1L << (TRIPLE_QUOTE_OPEN - 128)))) != 0)) { - { - { - setState(3023); - whenEntry(); - setState(3027); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,464,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(3024); - match(NL); - } - } - } - setState(3029); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,464,_ctx); - } - } - } - setState(3034); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3038); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3035); - match(NL); - } - } - setState(3040); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3041); - match(RCURL); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class WhenEntryContext extends ParserRuleContext { - public List whenCondition() { - return getRuleContexts(WhenConditionContext.class); - } - public WhenConditionContext whenCondition(int i) { - return getRuleContext(WhenConditionContext.class,i); - } - public TerminalNode ARROW() { return getToken(KotlinParser.ARROW, 0); } - public ControlStructureBodyContext controlStructureBody() { - return getRuleContext(ControlStructureBodyContext.class,0); - } - public List COMMA() { return getTokens(KotlinParser.COMMA); } - public TerminalNode COMMA(int i) { - return getToken(KotlinParser.COMMA, i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public SemiContext semi() { - return getRuleContext(SemiContext.class,0); - } - public TerminalNode ELSE() { return getToken(KotlinParser.ELSE, 0); } - public WhenEntryContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_whenEntry; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterWhenEntry(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitWhenEntry(this); - } - } - - public final WhenEntryContext whenEntry() throws RecognitionException { - WhenEntryContext _localctx = new WhenEntryContext(_ctx, getState()); - enterRule(_localctx, 254, RULE_whenEntry); - int _la; - try { - int _alt; - setState(3107); - _errHandler.sync(this); - switch (_input.LA(1)) { - case LPAREN: - case LSQUARE: - case LCURL: - case ADD: - case SUB: - case INCR: - case DECR: - case EXCL_WS: - case EXCL_NO_WS: - case COLONCOLON: - case AT_NO_WS: - case AT_PRE_WS: - case RETURN_AT: - case CONTINUE_AT: - case BREAK_AT: - case THIS_AT: - case SUPER_AT: - case FILE: - case FIELD: - case PROPERTY: - case GET: - case SET: - case RECEIVER: - case PARAM: - case SETPARAM: - case DELEGATE: - case IMPORT: - case FUN: - case OBJECT: - case CONSTRUCTOR: - case BY: - case COMPANION: - case INIT: - case THIS: - case SUPER: - case WHERE: - case IF: - case WHEN: - case TRY: - case CATCH: - case FINALLY: - case THROW: - case RETURN: - case CONTINUE: - case BREAK: - case IS: - case IN: - case NOT_IS: - case NOT_IN: - case OUT: - case DYNAMIC: - case PUBLIC: - case PRIVATE: - case PROTECTED: - case INTERNAL: - case ENUM: - case SEALED: - case ANNOTATION: - case DATA: - case INNER: - case VALUE: - case TAILREC: - case OPERATOR: - case INLINE: - case INFIX: - case EXTERNAL: - case SUSPEND: - case OVERRIDE: - case ABSTRACT: - case FINAL: - case OPEN: - case CONST: - case LATEINIT: - case VARARG: - case NOINLINE: - case CROSSINLINE: - case REIFIED: - case EXPECT: - case ACTUAL: - case RealLiteral: - case IntegerLiteral: - case HexLiteral: - case BinLiteral: - case UnsignedLiteral: - case LongLiteral: - case BooleanLiteral: - case NullLiteral: - case CharacterLiteral: - case Identifier: - case QUOTE_OPEN: - case TRIPLE_QUOTE_OPEN: - enterOuterAlt(_localctx, 1); - { - setState(3043); - whenCondition(); - setState(3060); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,469,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(3047); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3044); - match(NL); - } - } - setState(3049); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3050); - match(COMMA); - setState(3054); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3051); - match(NL); - } - } - setState(3056); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3057); - whenCondition(); - } - } - } - setState(3062); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,469,_ctx); - } - setState(3070); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,471,_ctx) ) { - case 1: - { - setState(3066); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3063); - match(NL); - } - } - setState(3068); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3069); - match(COMMA); - } - break; - } - setState(3075); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3072); - match(NL); - } - } - setState(3077); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3078); - match(ARROW); - setState(3082); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3079); - match(NL); - } - } - setState(3084); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3085); - controlStructureBody(); - setState(3087); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,474,_ctx) ) { - case 1: - { - setState(3086); - semi(); - } - break; - } - } - break; - case ELSE: - enterOuterAlt(_localctx, 2); - { - setState(3089); - match(ELSE); - setState(3093); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3090); - match(NL); - } - } - setState(3095); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3096); - match(ARROW); - setState(3100); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3097); - match(NL); - } - } - setState(3102); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3103); - controlStructureBody(); - setState(3105); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,477,_ctx) ) { - case 1: - { - setState(3104); - semi(); - } - 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 WhenConditionContext extends ParserRuleContext { - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public RangeTestContext rangeTest() { - return getRuleContext(RangeTestContext.class,0); - } - public TypeTestContext typeTest() { - return getRuleContext(TypeTestContext.class,0); - } - public WhenConditionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_whenCondition; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterWhenCondition(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitWhenCondition(this); - } - } - - public final WhenConditionContext whenCondition() throws RecognitionException { - WhenConditionContext _localctx = new WhenConditionContext(_ctx, getState()); - enterRule(_localctx, 256, RULE_whenCondition); - try { - setState(3112); - _errHandler.sync(this); - switch (_input.LA(1)) { - case LPAREN: - case LSQUARE: - case LCURL: - case ADD: - case SUB: - case INCR: - case DECR: - case EXCL_WS: - case EXCL_NO_WS: - case COLONCOLON: - case AT_NO_WS: - case AT_PRE_WS: - case RETURN_AT: - case CONTINUE_AT: - case BREAK_AT: - case THIS_AT: - case SUPER_AT: - case FILE: - case FIELD: - case PROPERTY: - case GET: - case SET: - case RECEIVER: - case PARAM: - case SETPARAM: - case DELEGATE: - case IMPORT: - case FUN: - case OBJECT: - case CONSTRUCTOR: - case BY: - case COMPANION: - case INIT: - case THIS: - case SUPER: - case WHERE: - case IF: - case WHEN: - case TRY: - case CATCH: - case FINALLY: - case THROW: - case RETURN: - case CONTINUE: - case BREAK: - case OUT: - case DYNAMIC: - case PUBLIC: - case PRIVATE: - case PROTECTED: - case INTERNAL: - case ENUM: - case SEALED: - case ANNOTATION: - case DATA: - case INNER: - case VALUE: - case TAILREC: - case OPERATOR: - case INLINE: - case INFIX: - case EXTERNAL: - case SUSPEND: - case OVERRIDE: - case ABSTRACT: - case FINAL: - case OPEN: - case CONST: - case LATEINIT: - case VARARG: - case NOINLINE: - case CROSSINLINE: - case REIFIED: - case EXPECT: - case ACTUAL: - case RealLiteral: - case IntegerLiteral: - case HexLiteral: - case BinLiteral: - case UnsignedLiteral: - case LongLiteral: - case BooleanLiteral: - case NullLiteral: - case CharacterLiteral: - case Identifier: - case QUOTE_OPEN: - case TRIPLE_QUOTE_OPEN: - enterOuterAlt(_localctx, 1); - { - setState(3109); - expression(); - } - break; - case IN: - case NOT_IN: - enterOuterAlt(_localctx, 2); - { - setState(3110); - rangeTest(); - } - break; - case IS: - case NOT_IS: - enterOuterAlt(_localctx, 3); - { - setState(3111); - typeTest(); - } - 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 RangeTestContext extends ParserRuleContext { - public InOperatorContext inOperator() { - return getRuleContext(InOperatorContext.class,0); - } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public RangeTestContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_rangeTest; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterRangeTest(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitRangeTest(this); - } - } - - public final RangeTestContext rangeTest() throws RecognitionException { - RangeTestContext _localctx = new RangeTestContext(_ctx, getState()); - enterRule(_localctx, 258, RULE_rangeTest); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3114); - inOperator(); - setState(3118); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3115); - match(NL); - } - } - setState(3120); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3121); - expression(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TypeTestContext extends ParserRuleContext { - public IsOperatorContext isOperator() { - return getRuleContext(IsOperatorContext.class,0); - } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TypeTestContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeTest; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterTypeTest(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitTypeTest(this); - } - } - - public final TypeTestContext typeTest() throws RecognitionException { - TypeTestContext _localctx = new TypeTestContext(_ctx, getState()); - enterRule(_localctx, 260, RULE_typeTest); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3123); - isOperator(); - setState(3127); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3124); - match(NL); - } - } - setState(3129); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3130); - type(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TryExpressionContext extends ParserRuleContext { - public TerminalNode TRY() { return getToken(KotlinParser.TRY, 0); } - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public FinallyBlockContext finallyBlock() { - return getRuleContext(FinallyBlockContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public List catchBlock() { - return getRuleContexts(CatchBlockContext.class); - } - public CatchBlockContext catchBlock(int i) { - return getRuleContext(CatchBlockContext.class,i); - } - public TryExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_tryExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterTryExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitTryExpression(this); - } - } - - public final TryExpressionContext tryExpression() throws RecognitionException { - TryExpressionContext _localctx = new TryExpressionContext(_ctx, getState()); - enterRule(_localctx, 262, RULE_tryExpression); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(3132); - match(TRY); - setState(3136); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3133); - match(NL); - } - } - setState(3138); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3139); - block(); - setState(3167); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,488,_ctx) ) { - case 1: - { - setState(3147); - _errHandler.sync(this); - _alt = 1; - do { - switch (_alt) { - case 1: - { - { - setState(3143); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3140); - match(NL); - } - } - setState(3145); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3146); - catchBlock(); - } - } - break; - default: - throw new NoViableAltException(this); - } - setState(3149); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,484,_ctx); - } while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ); - setState(3158); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,486,_ctx) ) { - case 1: - { - setState(3154); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3151); - match(NL); - } - } - setState(3156); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3157); - finallyBlock(); - } - break; - } - } - break; - case 2: - { - setState(3163); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3160); - match(NL); - } - } - setState(3165); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3166); - finallyBlock(); - } - break; - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class CatchBlockContext extends ParserRuleContext { - public TerminalNode CATCH() { return getToken(KotlinParser.CATCH, 0); } - public TerminalNode LPAREN() { return getToken(KotlinParser.LPAREN, 0); } - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public TypeContext type() { - return getRuleContext(TypeContext.class,0); - } - public TerminalNode RPAREN() { return getToken(KotlinParser.RPAREN, 0); } - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public List annotation() { - return getRuleContexts(AnnotationContext.class); - } - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class,i); - } - public TerminalNode COMMA() { return getToken(KotlinParser.COMMA, 0); } - public CatchBlockContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_catchBlock; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterCatchBlock(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitCatchBlock(this); - } - } - - public final CatchBlockContext catchBlock() throws RecognitionException { - CatchBlockContext _localctx = new CatchBlockContext(_ctx, getState()); - enterRule(_localctx, 264, RULE_catchBlock); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3169); - match(CATCH); - setState(3173); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3170); - match(NL); - } - } - setState(3175); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3176); - match(LPAREN); - setState(3180); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==AT_NO_WS || _la==AT_PRE_WS) { - { - { - setState(3177); - annotation(); - } - } - setState(3182); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3183); - simpleIdentifier(); - setState(3184); - match(COLON); - setState(3185); - type(); - setState(3193); - _errHandler.sync(this); - _la = _input.LA(1); - if (_la==NL || _la==COMMA) { - { - setState(3189); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3186); - match(NL); - } - } - setState(3191); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3192); - match(COMMA); - } - } - - setState(3195); - match(RPAREN); - setState(3199); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3196); - match(NL); - } - } - setState(3201); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3202); - block(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class FinallyBlockContext extends ParserRuleContext { - public TerminalNode FINALLY() { return getToken(KotlinParser.FINALLY, 0); } - public BlockContext block() { - return getRuleContext(BlockContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public FinallyBlockContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_finallyBlock; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterFinallyBlock(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitFinallyBlock(this); - } - } - - public final FinallyBlockContext finallyBlock() throws RecognitionException { - FinallyBlockContext _localctx = new FinallyBlockContext(_ctx, getState()); - enterRule(_localctx, 266, RULE_finallyBlock); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3204); - match(FINALLY); - setState(3208); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3205); - match(NL); - } - } - setState(3210); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3211); - block(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class JumpExpressionContext extends ParserRuleContext { - public TerminalNode THROW() { return getToken(KotlinParser.THROW, 0); } - public ExpressionContext expression() { - return getRuleContext(ExpressionContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TerminalNode RETURN() { return getToken(KotlinParser.RETURN, 0); } - public TerminalNode RETURN_AT() { return getToken(KotlinParser.RETURN_AT, 0); } - public TerminalNode CONTINUE() { return getToken(KotlinParser.CONTINUE, 0); } - public TerminalNode CONTINUE_AT() { return getToken(KotlinParser.CONTINUE_AT, 0); } - public TerminalNode BREAK() { return getToken(KotlinParser.BREAK, 0); } - public TerminalNode BREAK_AT() { return getToken(KotlinParser.BREAK_AT, 0); } - public JumpExpressionContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_jumpExpression; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterJumpExpression(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitJumpExpression(this); - } - } - - public final JumpExpressionContext jumpExpression() throws RecognitionException { - JumpExpressionContext _localctx = new JumpExpressionContext(_ctx, getState()); - enterRule(_localctx, 268, RULE_jumpExpression); - int _la; - try { - setState(3229); - _errHandler.sync(this); - switch (_input.LA(1)) { - case THROW: - enterOuterAlt(_localctx, 1); - { - setState(3213); - match(THROW); - setState(3217); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3214); - match(NL); - } - } - setState(3219); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3220); - expression(); - } - break; - case RETURN_AT: - case RETURN: - enterOuterAlt(_localctx, 2); - { - setState(3221); - _la = _input.LA(1); - if ( !(_la==RETURN_AT || _la==RETURN) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(3223); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,496,_ctx) ) { - case 1: - { - setState(3222); - expression(); - } - break; - } - } - break; - case CONTINUE: - enterOuterAlt(_localctx, 3); - { - setState(3225); - match(CONTINUE); - } - break; - case CONTINUE_AT: - enterOuterAlt(_localctx, 4); - { - setState(3226); - match(CONTINUE_AT); - } - break; - case BREAK: - enterOuterAlt(_localctx, 5); - { - setState(3227); - match(BREAK); - } - break; - case BREAK_AT: - enterOuterAlt(_localctx, 6); - { - setState(3228); - match(BREAK_AT); - } - 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 CallableReferenceContext extends ParserRuleContext { - public TerminalNode COLONCOLON() { return getToken(KotlinParser.COLONCOLON, 0); } - public SimpleIdentifierContext simpleIdentifier() { - return getRuleContext(SimpleIdentifierContext.class,0); - } - public TerminalNode CLASS() { return getToken(KotlinParser.CLASS, 0); } - public ReceiverTypeContext receiverType() { - return getRuleContext(ReceiverTypeContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public CallableReferenceContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_callableReference; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterCallableReference(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitCallableReference(this); - } - } - - public final CallableReferenceContext callableReference() throws RecognitionException { - CallableReferenceContext _localctx = new CallableReferenceContext(_ctx, getState()); - enterRule(_localctx, 270, RULE_callableReference); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3232); - _errHandler.sync(this); - _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LPAREN) | (1L << AT_NO_WS) | (1L << AT_PRE_WS) | (1L << FILE) | (1L << FIELD) | (1L << PROPERTY))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (GET - 64)) | (1L << (SET - 64)) | (1L << (RECEIVER - 64)) | (1L << (PARAM - 64)) | (1L << (SETPARAM - 64)) | (1L << (DELEGATE - 64)) | (1L << (IMPORT - 64)) | (1L << (CONSTRUCTOR - 64)) | (1L << (BY - 64)) | (1L << (COMPANION - 64)) | (1L << (INIT - 64)) | (1L << (WHERE - 64)) | (1L << (CATCH - 64)) | (1L << (FINALLY - 64)) | (1L << (OUT - 64)) | (1L << (DYNAMIC - 64)) | (1L << (PUBLIC - 64)) | (1L << (PRIVATE - 64)) | (1L << (PROTECTED - 64)) | (1L << (INTERNAL - 64)) | (1L << (ENUM - 64)) | (1L << (SEALED - 64)) | (1L << (ANNOTATION - 64)) | (1L << (DATA - 64)) | (1L << (INNER - 64)) | (1L << (VALUE - 64)) | (1L << (TAILREC - 64)) | (1L << (OPERATOR - 64)) | (1L << (INLINE - 64)) | (1L << (INFIX - 64)) | (1L << (EXTERNAL - 64)) | (1L << (SUSPEND - 64)) | (1L << (OVERRIDE - 64)) | (1L << (ABSTRACT - 64)) | (1L << (FINAL - 64)) | (1L << (OPEN - 64)) | (1L << (CONST - 64)))) != 0) || ((((_la - 128)) & ~0x3f) == 0 && ((1L << (_la - 128)) & ((1L << (LATEINIT - 128)) | (1L << (VARARG - 128)) | (1L << (NOINLINE - 128)) | (1L << (CROSSINLINE - 128)) | (1L << (REIFIED - 128)) | (1L << (EXPECT - 128)) | (1L << (ACTUAL - 128)) | (1L << (Identifier - 128)))) != 0)) { - { - setState(3231); - receiverType(); - } - } - - setState(3234); - match(COLONCOLON); - setState(3238); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3235); - match(NL); - } - } - setState(3240); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3243); - _errHandler.sync(this); - switch (_input.LA(1)) { - case FILE: - case FIELD: - case PROPERTY: - case GET: - case SET: - case RECEIVER: - case PARAM: - case SETPARAM: - case DELEGATE: - case IMPORT: - case CONSTRUCTOR: - case BY: - case COMPANION: - case INIT: - case WHERE: - case CATCH: - case FINALLY: - case OUT: - case DYNAMIC: - case PUBLIC: - case PRIVATE: - case PROTECTED: - case INTERNAL: - case ENUM: - case SEALED: - case ANNOTATION: - case DATA: - case INNER: - case VALUE: - case TAILREC: - case OPERATOR: - case INLINE: - case INFIX: - case EXTERNAL: - case SUSPEND: - case OVERRIDE: - case ABSTRACT: - case FINAL: - case OPEN: - case CONST: - case LATEINIT: - case VARARG: - case NOINLINE: - case CROSSINLINE: - case REIFIED: - case EXPECT: - case ACTUAL: - case Identifier: - { - setState(3241); - simpleIdentifier(); - } - break; - case CLASS: - { - setState(3242); - match(CLASS); - } - 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 AssignmentAndOperatorContext extends ParserRuleContext { - public TerminalNode ADD_ASSIGNMENT() { return getToken(KotlinParser.ADD_ASSIGNMENT, 0); } - public TerminalNode SUB_ASSIGNMENT() { return getToken(KotlinParser.SUB_ASSIGNMENT, 0); } - public TerminalNode MULT_ASSIGNMENT() { return getToken(KotlinParser.MULT_ASSIGNMENT, 0); } - public TerminalNode DIV_ASSIGNMENT() { return getToken(KotlinParser.DIV_ASSIGNMENT, 0); } - public TerminalNode MOD_ASSIGNMENT() { return getToken(KotlinParser.MOD_ASSIGNMENT, 0); } - public AssignmentAndOperatorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_assignmentAndOperator; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterAssignmentAndOperator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitAssignmentAndOperator(this); - } - } - - public final AssignmentAndOperatorContext assignmentAndOperator() throws RecognitionException { - AssignmentAndOperatorContext _localctx = new AssignmentAndOperatorContext(_ctx, getState()); - enterRule(_localctx, 272, RULE_assignmentAndOperator); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3245); - _la = _input.LA(1); - if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << ADD_ASSIGNMENT) | (1L << SUB_ASSIGNMENT) | (1L << MULT_ASSIGNMENT) | (1L << DIV_ASSIGNMENT) | (1L << MOD_ASSIGNMENT))) != 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 EqualityOperatorContext extends ParserRuleContext { - public TerminalNode EXCL_EQ() { return getToken(KotlinParser.EXCL_EQ, 0); } - public TerminalNode EXCL_EQEQ() { return getToken(KotlinParser.EXCL_EQEQ, 0); } - public TerminalNode EQEQ() { return getToken(KotlinParser.EQEQ, 0); } - public TerminalNode EQEQEQ() { return getToken(KotlinParser.EQEQEQ, 0); } - public EqualityOperatorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_equalityOperator; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterEqualityOperator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitEqualityOperator(this); - } - } - - public final EqualityOperatorContext equalityOperator() throws RecognitionException { - EqualityOperatorContext _localctx = new EqualityOperatorContext(_ctx, getState()); - enterRule(_localctx, 274, RULE_equalityOperator); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3247); - _la = _input.LA(1); - if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << EXCL_EQ) | (1L << EXCL_EQEQ) | (1L << EQEQ) | (1L << EQEQEQ))) != 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 ComparisonOperatorContext extends ParserRuleContext { - public TerminalNode LANGLE() { return getToken(KotlinParser.LANGLE, 0); } - public TerminalNode RANGLE() { return getToken(KotlinParser.RANGLE, 0); } - public TerminalNode LE() { return getToken(KotlinParser.LE, 0); } - public TerminalNode GE() { return getToken(KotlinParser.GE, 0); } - public ComparisonOperatorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_comparisonOperator; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterComparisonOperator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitComparisonOperator(this); - } - } - - public final ComparisonOperatorContext comparisonOperator() throws RecognitionException { - ComparisonOperatorContext _localctx = new ComparisonOperatorContext(_ctx, getState()); - enterRule(_localctx, 276, RULE_comparisonOperator); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3249); - _la = _input.LA(1); - if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LANGLE) | (1L << RANGLE) | (1L << LE) | (1L << GE))) != 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 InOperatorContext extends ParserRuleContext { - public TerminalNode IN() { return getToken(KotlinParser.IN, 0); } - public TerminalNode NOT_IN() { return getToken(KotlinParser.NOT_IN, 0); } - public InOperatorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_inOperator; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterInOperator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitInOperator(this); - } - } - - public final InOperatorContext inOperator() throws RecognitionException { - InOperatorContext _localctx = new InOperatorContext(_ctx, getState()); - enterRule(_localctx, 278, RULE_inOperator); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3251); - _la = _input.LA(1); - if ( !(_la==IN || _la==NOT_IN) ) { - _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 IsOperatorContext extends ParserRuleContext { - public TerminalNode IS() { return getToken(KotlinParser.IS, 0); } - public TerminalNode NOT_IS() { return getToken(KotlinParser.NOT_IS, 0); } - public IsOperatorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_isOperator; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterIsOperator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitIsOperator(this); - } - } - - public final IsOperatorContext isOperator() throws RecognitionException { - IsOperatorContext _localctx = new IsOperatorContext(_ctx, getState()); - enterRule(_localctx, 280, RULE_isOperator); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3253); - _la = _input.LA(1); - if ( !(_la==IS || _la==NOT_IS) ) { - _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 AdditiveOperatorContext extends ParserRuleContext { - public TerminalNode ADD() { return getToken(KotlinParser.ADD, 0); } - public TerminalNode SUB() { return getToken(KotlinParser.SUB, 0); } - public AdditiveOperatorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_additiveOperator; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterAdditiveOperator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitAdditiveOperator(this); - } - } - - public final AdditiveOperatorContext additiveOperator() throws RecognitionException { - AdditiveOperatorContext _localctx = new AdditiveOperatorContext(_ctx, getState()); - enterRule(_localctx, 282, RULE_additiveOperator); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3255); - _la = _input.LA(1); - if ( !(_la==ADD || _la==SUB) ) { - _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 MultiplicativeOperatorContext extends ParserRuleContext { - public TerminalNode MULT() { return getToken(KotlinParser.MULT, 0); } - public TerminalNode DIV() { return getToken(KotlinParser.DIV, 0); } - public TerminalNode MOD() { return getToken(KotlinParser.MOD, 0); } - public MultiplicativeOperatorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_multiplicativeOperator; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterMultiplicativeOperator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitMultiplicativeOperator(this); - } - } - - public final MultiplicativeOperatorContext multiplicativeOperator() throws RecognitionException { - MultiplicativeOperatorContext _localctx = new MultiplicativeOperatorContext(_ctx, getState()); - enterRule(_localctx, 284, RULE_multiplicativeOperator); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3257); - _la = _input.LA(1); - if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << MULT) | (1L << MOD) | (1L << DIV))) != 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 AsOperatorContext extends ParserRuleContext { - public TerminalNode AS() { return getToken(KotlinParser.AS, 0); } - public TerminalNode AS_SAFE() { return getToken(KotlinParser.AS_SAFE, 0); } - public AsOperatorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_asOperator; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterAsOperator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitAsOperator(this); - } - } - - public final AsOperatorContext asOperator() throws RecognitionException { - AsOperatorContext _localctx = new AsOperatorContext(_ctx, getState()); - enterRule(_localctx, 286, RULE_asOperator); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3259); - _la = _input.LA(1); - if ( !(_la==AS_SAFE || _la==AS) ) { - _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 PrefixUnaryOperatorContext extends ParserRuleContext { - public TerminalNode INCR() { return getToken(KotlinParser.INCR, 0); } - public TerminalNode DECR() { return getToken(KotlinParser.DECR, 0); } - public TerminalNode SUB() { return getToken(KotlinParser.SUB, 0); } - public TerminalNode ADD() { return getToken(KotlinParser.ADD, 0); } - public ExclContext excl() { - return getRuleContext(ExclContext.class,0); - } - public PrefixUnaryOperatorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_prefixUnaryOperator; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterPrefixUnaryOperator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitPrefixUnaryOperator(this); - } - } - - public final PrefixUnaryOperatorContext prefixUnaryOperator() throws RecognitionException { - PrefixUnaryOperatorContext _localctx = new PrefixUnaryOperatorContext(_ctx, getState()); - enterRule(_localctx, 288, RULE_prefixUnaryOperator); - try { - setState(3266); - _errHandler.sync(this); - switch (_input.LA(1)) { - case INCR: - enterOuterAlt(_localctx, 1); - { - setState(3261); - match(INCR); - } - break; - case DECR: - enterOuterAlt(_localctx, 2); - { - setState(3262); - match(DECR); - } - break; - case SUB: - enterOuterAlt(_localctx, 3); - { - setState(3263); - match(SUB); - } - break; - case ADD: - enterOuterAlt(_localctx, 4); - { - setState(3264); - match(ADD); - } - break; - case EXCL_WS: - case EXCL_NO_WS: - enterOuterAlt(_localctx, 5); - { - setState(3265); - excl(); - } - 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 PostfixUnaryOperatorContext extends ParserRuleContext { - public TerminalNode INCR() { return getToken(KotlinParser.INCR, 0); } - public TerminalNode DECR() { return getToken(KotlinParser.DECR, 0); } - public TerminalNode EXCL_NO_WS() { return getToken(KotlinParser.EXCL_NO_WS, 0); } - public ExclContext excl() { - return getRuleContext(ExclContext.class,0); - } - public PostfixUnaryOperatorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_postfixUnaryOperator; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterPostfixUnaryOperator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitPostfixUnaryOperator(this); - } - } - - public final PostfixUnaryOperatorContext postfixUnaryOperator() throws RecognitionException { - PostfixUnaryOperatorContext _localctx = new PostfixUnaryOperatorContext(_ctx, getState()); - enterRule(_localctx, 290, RULE_postfixUnaryOperator); - try { - setState(3272); - _errHandler.sync(this); - switch (_input.LA(1)) { - case INCR: - enterOuterAlt(_localctx, 1); - { - setState(3268); - match(INCR); - } - break; - case DECR: - enterOuterAlt(_localctx, 2); - { - setState(3269); - match(DECR); - } - break; - case EXCL_NO_WS: - enterOuterAlt(_localctx, 3); - { - setState(3270); - match(EXCL_NO_WS); - setState(3271); - excl(); - } - 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 ExclContext extends ParserRuleContext { - public TerminalNode EXCL_NO_WS() { return getToken(KotlinParser.EXCL_NO_WS, 0); } - public TerminalNode EXCL_WS() { return getToken(KotlinParser.EXCL_WS, 0); } - public ExclContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_excl; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterExcl(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitExcl(this); - } - } - - public final ExclContext excl() throws RecognitionException { - ExclContext _localctx = new ExclContext(_ctx, getState()); - enterRule(_localctx, 292, RULE_excl); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3274); - _la = _input.LA(1); - if ( !(_la==EXCL_WS || _la==EXCL_NO_WS) ) { - _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 MemberAccessOperatorContext extends ParserRuleContext { - public TerminalNode DOT() { return getToken(KotlinParser.DOT, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public SafeNavContext safeNav() { - return getRuleContext(SafeNavContext.class,0); - } - public TerminalNode COLONCOLON() { return getToken(KotlinParser.COLONCOLON, 0); } - public MemberAccessOperatorContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_memberAccessOperator; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterMemberAccessOperator(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitMemberAccessOperator(this); - } - } - - public final MemberAccessOperatorContext memberAccessOperator() throws RecognitionException { - MemberAccessOperatorContext _localctx = new MemberAccessOperatorContext(_ctx, getState()); - enterRule(_localctx, 294, RULE_memberAccessOperator); - int _la; - try { - setState(3291); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,505,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(3279); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3276); - match(NL); - } - } - setState(3281); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3282); - match(DOT); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(3286); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3283); - match(NL); - } - } - setState(3288); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3289); - safeNav(); - } - break; - case 3: - enterOuterAlt(_localctx, 3); - { - setState(3290); - match(COLONCOLON); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class SafeNavContext extends ParserRuleContext { - public TerminalNode QUEST_NO_WS() { return getToken(KotlinParser.QUEST_NO_WS, 0); } - public TerminalNode DOT() { return getToken(KotlinParser.DOT, 0); } - public SafeNavContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_safeNav; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterSafeNav(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitSafeNav(this); - } - } - - public final SafeNavContext safeNav() throws RecognitionException { - SafeNavContext _localctx = new SafeNavContext(_ctx, getState()); - enterRule(_localctx, 296, RULE_safeNav); - try { - enterOuterAlt(_localctx, 1); - { - setState(3293); - match(QUEST_NO_WS); - setState(3294); - match(DOT); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ModifiersContext extends ParserRuleContext { - public List annotation() { - return getRuleContexts(AnnotationContext.class); - } - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class,i); - } - public List modifier() { - return getRuleContexts(ModifierContext.class); - } - public ModifierContext modifier(int i) { - return getRuleContext(ModifierContext.class,i); - } - public ModifiersContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_modifiers; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterModifiers(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitModifiers(this); - } - } - - public final ModifiersContext modifiers() throws RecognitionException { - ModifiersContext _localctx = new ModifiersContext(_ctx, getState()); - enterRule(_localctx, 298, RULE_modifiers); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(3298); - _errHandler.sync(this); - _alt = 1; - do { - switch (_alt) { - case 1: - { - setState(3298); - _errHandler.sync(this); - switch (_input.LA(1)) { - case AT_NO_WS: - case AT_PRE_WS: - { - setState(3296); - annotation(); - } - break; - case PUBLIC: - case PRIVATE: - case PROTECTED: - case INTERNAL: - case ENUM: - case SEALED: - case ANNOTATION: - case DATA: - case INNER: - case VALUE: - case TAILREC: - case OPERATOR: - case INLINE: - case INFIX: - case EXTERNAL: - case SUSPEND: - case OVERRIDE: - case ABSTRACT: - case FINAL: - case OPEN: - case CONST: - case LATEINIT: - case VARARG: - case NOINLINE: - case CROSSINLINE: - case EXPECT: - case ACTUAL: - { - setState(3297); - modifier(); - } - break; - default: - throw new NoViableAltException(this); - } - } - break; - default: - throw new NoViableAltException(this); - } - setState(3300); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,507,_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 ParameterModifiersContext extends ParserRuleContext { - public List annotation() { - return getRuleContexts(AnnotationContext.class); - } - public AnnotationContext annotation(int i) { - return getRuleContext(AnnotationContext.class,i); - } - public List parameterModifier() { - return getRuleContexts(ParameterModifierContext.class); - } - public ParameterModifierContext parameterModifier(int i) { - return getRuleContext(ParameterModifierContext.class,i); - } - public ParameterModifiersContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_parameterModifiers; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterParameterModifiers(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitParameterModifiers(this); - } - } - - public final ParameterModifiersContext parameterModifiers() throws RecognitionException { - ParameterModifiersContext _localctx = new ParameterModifiersContext(_ctx, getState()); - enterRule(_localctx, 300, RULE_parameterModifiers); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(3304); - _errHandler.sync(this); - _alt = 1; - do { - switch (_alt) { - case 1: - { - setState(3304); - _errHandler.sync(this); - switch (_input.LA(1)) { - case AT_NO_WS: - case AT_PRE_WS: - { - setState(3302); - annotation(); - } - break; - case VARARG: - case NOINLINE: - case CROSSINLINE: - { - setState(3303); - parameterModifier(); - } - break; - default: - throw new NoViableAltException(this); - } - } - break; - default: - throw new NoViableAltException(this); - } - setState(3306); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,509,_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 ModifierContext extends ParserRuleContext { - public ClassModifierContext classModifier() { - return getRuleContext(ClassModifierContext.class,0); - } - public MemberModifierContext memberModifier() { - return getRuleContext(MemberModifierContext.class,0); - } - public VisibilityModifierContext visibilityModifier() { - return getRuleContext(VisibilityModifierContext.class,0); - } - public FunctionModifierContext functionModifier() { - return getRuleContext(FunctionModifierContext.class,0); - } - public PropertyModifierContext propertyModifier() { - return getRuleContext(PropertyModifierContext.class,0); - } - public InheritanceModifierContext inheritanceModifier() { - return getRuleContext(InheritanceModifierContext.class,0); - } - public ParameterModifierContext parameterModifier() { - return getRuleContext(ParameterModifierContext.class,0); - } - public PlatformModifierContext platformModifier() { - return getRuleContext(PlatformModifierContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public ModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_modifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterModifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitModifier(this); - } - } - - public final ModifierContext modifier() throws RecognitionException { - ModifierContext _localctx = new ModifierContext(_ctx, getState()); - enterRule(_localctx, 302, RULE_modifier); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(3316); - _errHandler.sync(this); - switch (_input.LA(1)) { - case ENUM: - case SEALED: - case ANNOTATION: - case DATA: - case INNER: - case VALUE: - { - setState(3308); - classModifier(); - } - break; - case OVERRIDE: - case LATEINIT: - { - setState(3309); - memberModifier(); - } - break; - case PUBLIC: - case PRIVATE: - case PROTECTED: - case INTERNAL: - { - setState(3310); - visibilityModifier(); - } - break; - case TAILREC: - case OPERATOR: - case INLINE: - case INFIX: - case EXTERNAL: - case SUSPEND: - { - setState(3311); - functionModifier(); - } - break; - case CONST: - { - setState(3312); - propertyModifier(); - } - break; - case ABSTRACT: - case FINAL: - case OPEN: - { - setState(3313); - inheritanceModifier(); - } - break; - case VARARG: - case NOINLINE: - case CROSSINLINE: - { - setState(3314); - parameterModifier(); - } - break; - case EXPECT: - case ACTUAL: - { - setState(3315); - platformModifier(); - } - break; - default: - throw new NoViableAltException(this); - } - setState(3321); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,511,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(3318); - match(NL); - } - } - } - setState(3323); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,511,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class TypeModifiersContext extends ParserRuleContext { - public List typeModifier() { - return getRuleContexts(TypeModifierContext.class); - } - public TypeModifierContext typeModifier(int i) { - return getRuleContext(TypeModifierContext.class,i); - } - public TypeModifiersContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeModifiers; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterTypeModifiers(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitTypeModifiers(this); - } - } - - public final TypeModifiersContext typeModifiers() throws RecognitionException { - TypeModifiersContext _localctx = new TypeModifiersContext(_ctx, getState()); - enterRule(_localctx, 304, RULE_typeModifiers); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(3325); - _errHandler.sync(this); - _alt = 1; - do { - switch (_alt) { - case 1: - { - { - setState(3324); - typeModifier(); - } - } - break; - default: - throw new NoViableAltException(this); - } - setState(3327); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,512,_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 TypeModifierContext extends ParserRuleContext { - public AnnotationContext annotation() { - return getRuleContext(AnnotationContext.class,0); - } - public TerminalNode SUSPEND() { return getToken(KotlinParser.SUSPEND, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public TypeModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeModifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterTypeModifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitTypeModifier(this); - } - } - - public final TypeModifierContext typeModifier() throws RecognitionException { - TypeModifierContext _localctx = new TypeModifierContext(_ctx, getState()); - enterRule(_localctx, 306, RULE_typeModifier); - int _la; - try { - setState(3337); - _errHandler.sync(this); - switch (_input.LA(1)) { - case AT_NO_WS: - case AT_PRE_WS: - enterOuterAlt(_localctx, 1); - { - setState(3329); - annotation(); - } - break; - case SUSPEND: - enterOuterAlt(_localctx, 2); - { - setState(3330); - match(SUSPEND); - setState(3334); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3331); - match(NL); - } - } - setState(3336); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - break; - default: - throw new NoViableAltException(this); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class ClassModifierContext extends ParserRuleContext { - public TerminalNode ENUM() { return getToken(KotlinParser.ENUM, 0); } - public TerminalNode SEALED() { return getToken(KotlinParser.SEALED, 0); } - public TerminalNode ANNOTATION() { return getToken(KotlinParser.ANNOTATION, 0); } - public TerminalNode DATA() { return getToken(KotlinParser.DATA, 0); } - public TerminalNode INNER() { return getToken(KotlinParser.INNER, 0); } - public TerminalNode VALUE() { return getToken(KotlinParser.VALUE, 0); } - public ClassModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_classModifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterClassModifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitClassModifier(this); - } - } - - public final ClassModifierContext classModifier() throws RecognitionException { - ClassModifierContext _localctx = new ClassModifierContext(_ctx, getState()); - enterRule(_localctx, 308, RULE_classModifier); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3339); - _la = _input.LA(1); - if ( !(((((_la - 111)) & ~0x3f) == 0 && ((1L << (_la - 111)) & ((1L << (ENUM - 111)) | (1L << (SEALED - 111)) | (1L << (ANNOTATION - 111)) | (1L << (DATA - 111)) | (1L << (INNER - 111)) | (1L << (VALUE - 111)))) != 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 MemberModifierContext extends ParserRuleContext { - public TerminalNode OVERRIDE() { return getToken(KotlinParser.OVERRIDE, 0); } - public TerminalNode LATEINIT() { return getToken(KotlinParser.LATEINIT, 0); } - public MemberModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_memberModifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterMemberModifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitMemberModifier(this); - } - } - - public final MemberModifierContext memberModifier() throws RecognitionException { - MemberModifierContext _localctx = new MemberModifierContext(_ctx, getState()); - enterRule(_localctx, 310, RULE_memberModifier); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3341); - _la = _input.LA(1); - if ( !(_la==OVERRIDE || _la==LATEINIT) ) { - _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 VisibilityModifierContext extends ParserRuleContext { - public TerminalNode PUBLIC() { return getToken(KotlinParser.PUBLIC, 0); } - public TerminalNode PRIVATE() { return getToken(KotlinParser.PRIVATE, 0); } - public TerminalNode INTERNAL() { return getToken(KotlinParser.INTERNAL, 0); } - public TerminalNode PROTECTED() { return getToken(KotlinParser.PROTECTED, 0); } - public VisibilityModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_visibilityModifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterVisibilityModifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitVisibilityModifier(this); - } - } - - public final VisibilityModifierContext visibilityModifier() throws RecognitionException { - VisibilityModifierContext _localctx = new VisibilityModifierContext(_ctx, getState()); - enterRule(_localctx, 312, RULE_visibilityModifier); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3343); - _la = _input.LA(1); - if ( !(((((_la - 107)) & ~0x3f) == 0 && ((1L << (_la - 107)) & ((1L << (PUBLIC - 107)) | (1L << (PRIVATE - 107)) | (1L << (PROTECTED - 107)) | (1L << (INTERNAL - 107)))) != 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 VarianceModifierContext extends ParserRuleContext { - public TerminalNode IN() { return getToken(KotlinParser.IN, 0); } - public TerminalNode OUT() { return getToken(KotlinParser.OUT, 0); } - public VarianceModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_varianceModifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterVarianceModifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitVarianceModifier(this); - } - } - - public final VarianceModifierContext varianceModifier() throws RecognitionException { - VarianceModifierContext _localctx = new VarianceModifierContext(_ctx, getState()); - enterRule(_localctx, 314, RULE_varianceModifier); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3345); - _la = _input.LA(1); - if ( !(_la==IN || _la==OUT) ) { - _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 TypeParameterModifiersContext extends ParserRuleContext { - public List typeParameterModifier() { - return getRuleContexts(TypeParameterModifierContext.class); - } - public TypeParameterModifierContext typeParameterModifier(int i) { - return getRuleContext(TypeParameterModifierContext.class,i); - } - public TypeParameterModifiersContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeParameterModifiers; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterTypeParameterModifiers(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitTypeParameterModifiers(this); - } - } - - public final TypeParameterModifiersContext typeParameterModifiers() throws RecognitionException { - TypeParameterModifiersContext _localctx = new TypeParameterModifiersContext(_ctx, getState()); - enterRule(_localctx, 316, RULE_typeParameterModifiers); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(3348); - _errHandler.sync(this); - _alt = 1; - do { - switch (_alt) { - case 1: - { - { - setState(3347); - typeParameterModifier(); - } - } - break; - default: - throw new NoViableAltException(this); - } - setState(3350); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,515,_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 TypeParameterModifierContext extends ParserRuleContext { - public ReificationModifierContext reificationModifier() { - return getRuleContext(ReificationModifierContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public VarianceModifierContext varianceModifier() { - return getRuleContext(VarianceModifierContext.class,0); - } - public AnnotationContext annotation() { - return getRuleContext(AnnotationContext.class,0); - } - public TypeParameterModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_typeParameterModifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterTypeParameterModifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitTypeParameterModifier(this); - } - } - - public final TypeParameterModifierContext typeParameterModifier() throws RecognitionException { - TypeParameterModifierContext _localctx = new TypeParameterModifierContext(_ctx, getState()); - enterRule(_localctx, 318, RULE_typeParameterModifier); - try { - int _alt; - setState(3367); - _errHandler.sync(this); - switch (_input.LA(1)) { - case REIFIED: - enterOuterAlt(_localctx, 1); - { - setState(3352); - reificationModifier(); - setState(3356); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,516,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(3353); - match(NL); - } - } - } - setState(3358); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,516,_ctx); - } - } - break; - case IN: - case OUT: - enterOuterAlt(_localctx, 2); - { - setState(3359); - varianceModifier(); - setState(3363); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,517,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(3360); - match(NL); - } - } - } - setState(3365); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,517,_ctx); - } - } - break; - case AT_NO_WS: - case AT_PRE_WS: - enterOuterAlt(_localctx, 3); - { - setState(3366); - annotation(); - } - 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 FunctionModifierContext extends ParserRuleContext { - public TerminalNode TAILREC() { return getToken(KotlinParser.TAILREC, 0); } - public TerminalNode OPERATOR() { return getToken(KotlinParser.OPERATOR, 0); } - public TerminalNode INFIX() { return getToken(KotlinParser.INFIX, 0); } - public TerminalNode INLINE() { return getToken(KotlinParser.INLINE, 0); } - public TerminalNode EXTERNAL() { return getToken(KotlinParser.EXTERNAL, 0); } - public TerminalNode SUSPEND() { return getToken(KotlinParser.SUSPEND, 0); } - public FunctionModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_functionModifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterFunctionModifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitFunctionModifier(this); - } - } - - public final FunctionModifierContext functionModifier() throws RecognitionException { - FunctionModifierContext _localctx = new FunctionModifierContext(_ctx, getState()); - enterRule(_localctx, 320, RULE_functionModifier); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3369); - _la = _input.LA(1); - if ( !(((((_la - 117)) & ~0x3f) == 0 && ((1L << (_la - 117)) & ((1L << (TAILREC - 117)) | (1L << (OPERATOR - 117)) | (1L << (INLINE - 117)) | (1L << (INFIX - 117)) | (1L << (EXTERNAL - 117)) | (1L << (SUSPEND - 117)))) != 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 PropertyModifierContext extends ParserRuleContext { - public TerminalNode CONST() { return getToken(KotlinParser.CONST, 0); } - public PropertyModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_propertyModifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterPropertyModifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitPropertyModifier(this); - } - } - - public final PropertyModifierContext propertyModifier() throws RecognitionException { - PropertyModifierContext _localctx = new PropertyModifierContext(_ctx, getState()); - enterRule(_localctx, 322, RULE_propertyModifier); - try { - enterOuterAlt(_localctx, 1); - { - setState(3371); - match(CONST); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class InheritanceModifierContext extends ParserRuleContext { - public TerminalNode ABSTRACT() { return getToken(KotlinParser.ABSTRACT, 0); } - public TerminalNode FINAL() { return getToken(KotlinParser.FINAL, 0); } - public TerminalNode OPEN() { return getToken(KotlinParser.OPEN, 0); } - public InheritanceModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_inheritanceModifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterInheritanceModifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitInheritanceModifier(this); - } - } - - public final InheritanceModifierContext inheritanceModifier() throws RecognitionException { - InheritanceModifierContext _localctx = new InheritanceModifierContext(_ctx, getState()); - enterRule(_localctx, 324, RULE_inheritanceModifier); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3373); - _la = _input.LA(1); - if ( !(((((_la - 124)) & ~0x3f) == 0 && ((1L << (_la - 124)) & ((1L << (ABSTRACT - 124)) | (1L << (FINAL - 124)) | (1L << (OPEN - 124)))) != 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 ParameterModifierContext extends ParserRuleContext { - public TerminalNode VARARG() { return getToken(KotlinParser.VARARG, 0); } - public TerminalNode NOINLINE() { return getToken(KotlinParser.NOINLINE, 0); } - public TerminalNode CROSSINLINE() { return getToken(KotlinParser.CROSSINLINE, 0); } - public ParameterModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_parameterModifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterParameterModifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitParameterModifier(this); - } - } - - public final ParameterModifierContext parameterModifier() throws RecognitionException { - ParameterModifierContext _localctx = new ParameterModifierContext(_ctx, getState()); - enterRule(_localctx, 326, RULE_parameterModifier); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3375); - _la = _input.LA(1); - if ( !(((((_la - 129)) & ~0x3f) == 0 && ((1L << (_la - 129)) & ((1L << (VARARG - 129)) | (1L << (NOINLINE - 129)) | (1L << (CROSSINLINE - 129)))) != 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 ReificationModifierContext extends ParserRuleContext { - public TerminalNode REIFIED() { return getToken(KotlinParser.REIFIED, 0); } - public ReificationModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_reificationModifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterReificationModifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitReificationModifier(this); - } - } - - public final ReificationModifierContext reificationModifier() throws RecognitionException { - ReificationModifierContext _localctx = new ReificationModifierContext(_ctx, getState()); - enterRule(_localctx, 328, RULE_reificationModifier); - try { - enterOuterAlt(_localctx, 1); - { - setState(3377); - match(REIFIED); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class PlatformModifierContext extends ParserRuleContext { - public TerminalNode EXPECT() { return getToken(KotlinParser.EXPECT, 0); } - public TerminalNode ACTUAL() { return getToken(KotlinParser.ACTUAL, 0); } - public PlatformModifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_platformModifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterPlatformModifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitPlatformModifier(this); - } - } - - public final PlatformModifierContext platformModifier() throws RecognitionException { - PlatformModifierContext _localctx = new PlatformModifierContext(_ctx, getState()); - enterRule(_localctx, 330, RULE_platformModifier); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3379); - _la = _input.LA(1); - if ( !(_la==EXPECT || _la==ACTUAL) ) { - _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 AnnotationContext extends ParserRuleContext { - public SingleAnnotationContext singleAnnotation() { - return getRuleContext(SingleAnnotationContext.class,0); - } - public MultiAnnotationContext multiAnnotation() { - return getRuleContext(MultiAnnotationContext.class,0); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public AnnotationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_annotation; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterAnnotation(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitAnnotation(this); - } - } - - public final AnnotationContext annotation() throws RecognitionException { - AnnotationContext _localctx = new AnnotationContext(_ctx, getState()); - enterRule(_localctx, 332, RULE_annotation); - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(3383); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,519,_ctx) ) { - case 1: - { - setState(3381); - singleAnnotation(); - } - break; - case 2: - { - setState(3382); - multiAnnotation(); - } - break; - } - setState(3388); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,520,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(3385); - match(NL); - } - } - } - setState(3390); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,520,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class SingleAnnotationContext extends ParserRuleContext { - public UnescapedAnnotationContext unescapedAnnotation() { - return getRuleContext(UnescapedAnnotationContext.class,0); - } - public AnnotationUseSiteTargetContext annotationUseSiteTarget() { - return getRuleContext(AnnotationUseSiteTargetContext.class,0); - } - public TerminalNode AT_NO_WS() { return getToken(KotlinParser.AT_NO_WS, 0); } - public TerminalNode AT_PRE_WS() { return getToken(KotlinParser.AT_PRE_WS, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public SingleAnnotationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_singleAnnotation; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterSingleAnnotation(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitSingleAnnotation(this); - } - } - - public final SingleAnnotationContext singleAnnotation() throws RecognitionException { - SingleAnnotationContext _localctx = new SingleAnnotationContext(_ctx, getState()); - enterRule(_localctx, 334, RULE_singleAnnotation); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3400); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,522,_ctx) ) { - case 1: - { - setState(3391); - annotationUseSiteTarget(); - setState(3395); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3392); - match(NL); - } - } - setState(3397); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - break; - case 2: - { - setState(3398); - match(AT_NO_WS); - } - break; - case 3: - { - setState(3399); - match(AT_PRE_WS); - } - break; - } - setState(3402); - unescapedAnnotation(); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class MultiAnnotationContext extends ParserRuleContext { - public TerminalNode LSQUARE() { return getToken(KotlinParser.LSQUARE, 0); } - public TerminalNode RSQUARE() { return getToken(KotlinParser.RSQUARE, 0); } - public AnnotationUseSiteTargetContext annotationUseSiteTarget() { - return getRuleContext(AnnotationUseSiteTargetContext.class,0); - } - public TerminalNode AT_NO_WS() { return getToken(KotlinParser.AT_NO_WS, 0); } - public TerminalNode AT_PRE_WS() { return getToken(KotlinParser.AT_PRE_WS, 0); } - public List unescapedAnnotation() { - return getRuleContexts(UnescapedAnnotationContext.class); - } - public UnescapedAnnotationContext unescapedAnnotation(int i) { - return getRuleContext(UnescapedAnnotationContext.class,i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public MultiAnnotationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_multiAnnotation; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterMultiAnnotation(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitMultiAnnotation(this); - } - } - - public final MultiAnnotationContext multiAnnotation() throws RecognitionException { - MultiAnnotationContext _localctx = new MultiAnnotationContext(_ctx, getState()); - enterRule(_localctx, 336, RULE_multiAnnotation); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3413); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,524,_ctx) ) { - case 1: - { - setState(3404); - annotationUseSiteTarget(); - setState(3408); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3405); - match(NL); - } - } - setState(3410); - _errHandler.sync(this); - _la = _input.LA(1); - } - } - break; - case 2: - { - setState(3411); - match(AT_NO_WS); - } - break; - case 3: - { - setState(3412); - match(AT_PRE_WS); - } - break; - } - setState(3415); - match(LSQUARE); - setState(3417); - _errHandler.sync(this); - _la = _input.LA(1); - do { - { - { - setState(3416); - unescapedAnnotation(); - } - } - setState(3419); - _errHandler.sync(this); - _la = _input.LA(1); - } while ( ((((_la - 61)) & ~0x3f) == 0 && ((1L << (_la - 61)) & ((1L << (FILE - 61)) | (1L << (FIELD - 61)) | (1L << (PROPERTY - 61)) | (1L << (GET - 61)) | (1L << (SET - 61)) | (1L << (RECEIVER - 61)) | (1L << (PARAM - 61)) | (1L << (SETPARAM - 61)) | (1L << (DELEGATE - 61)) | (1L << (IMPORT - 61)) | (1L << (CONSTRUCTOR - 61)) | (1L << (BY - 61)) | (1L << (COMPANION - 61)) | (1L << (INIT - 61)) | (1L << (WHERE - 61)) | (1L << (CATCH - 61)) | (1L << (FINALLY - 61)) | (1L << (OUT - 61)) | (1L << (DYNAMIC - 61)) | (1L << (PUBLIC - 61)) | (1L << (PRIVATE - 61)) | (1L << (PROTECTED - 61)) | (1L << (INTERNAL - 61)) | (1L << (ENUM - 61)) | (1L << (SEALED - 61)) | (1L << (ANNOTATION - 61)) | (1L << (DATA - 61)) | (1L << (INNER - 61)) | (1L << (VALUE - 61)) | (1L << (TAILREC - 61)) | (1L << (OPERATOR - 61)) | (1L << (INLINE - 61)) | (1L << (INFIX - 61)) | (1L << (EXTERNAL - 61)) | (1L << (SUSPEND - 61)) | (1L << (OVERRIDE - 61)) | (1L << (ABSTRACT - 61)))) != 0) || ((((_la - 125)) & ~0x3f) == 0 && ((1L << (_la - 125)) & ((1L << (FINAL - 125)) | (1L << (OPEN - 125)) | (1L << (CONST - 125)) | (1L << (LATEINIT - 125)) | (1L << (VARARG - 125)) | (1L << (NOINLINE - 125)) | (1L << (CROSSINLINE - 125)) | (1L << (REIFIED - 125)) | (1L << (EXPECT - 125)) | (1L << (ACTUAL - 125)) | (1L << (Identifier - 125)))) != 0) ); - setState(3421); - match(RSQUARE); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class AnnotationUseSiteTargetContext extends ParserRuleContext { - public TerminalNode COLON() { return getToken(KotlinParser.COLON, 0); } - public TerminalNode AT_NO_WS() { return getToken(KotlinParser.AT_NO_WS, 0); } - public TerminalNode AT_PRE_WS() { return getToken(KotlinParser.AT_PRE_WS, 0); } - public TerminalNode FIELD() { return getToken(KotlinParser.FIELD, 0); } - public TerminalNode PROPERTY() { return getToken(KotlinParser.PROPERTY, 0); } - public TerminalNode GET() { return getToken(KotlinParser.GET, 0); } - public TerminalNode SET() { return getToken(KotlinParser.SET, 0); } - public TerminalNode RECEIVER() { return getToken(KotlinParser.RECEIVER, 0); } - public TerminalNode PARAM() { return getToken(KotlinParser.PARAM, 0); } - public TerminalNode SETPARAM() { return getToken(KotlinParser.SETPARAM, 0); } - public TerminalNode DELEGATE() { return getToken(KotlinParser.DELEGATE, 0); } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public AnnotationUseSiteTargetContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_annotationUseSiteTarget; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterAnnotationUseSiteTarget(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitAnnotationUseSiteTarget(this); - } - } - - public final AnnotationUseSiteTargetContext annotationUseSiteTarget() throws RecognitionException { - AnnotationUseSiteTargetContext _localctx = new AnnotationUseSiteTargetContext(_ctx, getState()); - enterRule(_localctx, 338, RULE_annotationUseSiteTarget); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3423); - _la = _input.LA(1); - if ( !(_la==AT_NO_WS || _la==AT_PRE_WS) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(3424); - _la = _input.LA(1); - if ( !(((((_la - 62)) & ~0x3f) == 0 && ((1L << (_la - 62)) & ((1L << (FIELD - 62)) | (1L << (PROPERTY - 62)) | (1L << (GET - 62)) | (1L << (SET - 62)) | (1L << (RECEIVER - 62)) | (1L << (PARAM - 62)) | (1L << (SETPARAM - 62)) | (1L << (DELEGATE - 62)))) != 0)) ) { - _errHandler.recoverInline(this); - } - else { - if ( _input.LA(1)==Token.EOF ) matchedEOF = true; - _errHandler.reportMatch(this); - consume(); - } - setState(3428); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3425); - match(NL); - } - } - setState(3430); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3431); - match(COLON); - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class UnescapedAnnotationContext extends ParserRuleContext { - public ConstructorInvocationContext constructorInvocation() { - return getRuleContext(ConstructorInvocationContext.class,0); - } - public UserTypeContext userType() { - return getRuleContext(UserTypeContext.class,0); - } - public UnescapedAnnotationContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_unescapedAnnotation; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterUnescapedAnnotation(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitUnescapedAnnotation(this); - } - } - - public final UnescapedAnnotationContext unescapedAnnotation() throws RecognitionException { - UnescapedAnnotationContext _localctx = new UnescapedAnnotationContext(_ctx, getState()); - enterRule(_localctx, 340, RULE_unescapedAnnotation); - try { - setState(3435); - _errHandler.sync(this); - switch ( getInterpreter().adaptivePredict(_input,527,_ctx) ) { - case 1: - enterOuterAlt(_localctx, 1); - { - setState(3433); - constructorInvocation(); - } - break; - case 2: - enterOuterAlt(_localctx, 2); - { - setState(3434); - userType(); - } - break; - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - public static class SimpleIdentifierContext extends ParserRuleContext { - public TerminalNode Identifier() { return getToken(KotlinParser.Identifier, 0); } - public TerminalNode ABSTRACT() { return getToken(KotlinParser.ABSTRACT, 0); } - public TerminalNode ANNOTATION() { return getToken(KotlinParser.ANNOTATION, 0); } - public TerminalNode BY() { return getToken(KotlinParser.BY, 0); } - public TerminalNode CATCH() { return getToken(KotlinParser.CATCH, 0); } - public TerminalNode COMPANION() { return getToken(KotlinParser.COMPANION, 0); } - public TerminalNode CONSTRUCTOR() { return getToken(KotlinParser.CONSTRUCTOR, 0); } - public TerminalNode CROSSINLINE() { return getToken(KotlinParser.CROSSINLINE, 0); } - public TerminalNode DATA() { return getToken(KotlinParser.DATA, 0); } - public TerminalNode DYNAMIC() { return getToken(KotlinParser.DYNAMIC, 0); } - public TerminalNode ENUM() { return getToken(KotlinParser.ENUM, 0); } - public TerminalNode EXTERNAL() { return getToken(KotlinParser.EXTERNAL, 0); } - public TerminalNode FINAL() { return getToken(KotlinParser.FINAL, 0); } - public TerminalNode FINALLY() { return getToken(KotlinParser.FINALLY, 0); } - public TerminalNode GET() { return getToken(KotlinParser.GET, 0); } - public TerminalNode IMPORT() { return getToken(KotlinParser.IMPORT, 0); } - public TerminalNode INFIX() { return getToken(KotlinParser.INFIX, 0); } - public TerminalNode INIT() { return getToken(KotlinParser.INIT, 0); } - public TerminalNode INLINE() { return getToken(KotlinParser.INLINE, 0); } - public TerminalNode INNER() { return getToken(KotlinParser.INNER, 0); } - public TerminalNode INTERNAL() { return getToken(KotlinParser.INTERNAL, 0); } - public TerminalNode LATEINIT() { return getToken(KotlinParser.LATEINIT, 0); } - public TerminalNode NOINLINE() { return getToken(KotlinParser.NOINLINE, 0); } - public TerminalNode OPEN() { return getToken(KotlinParser.OPEN, 0); } - public TerminalNode OPERATOR() { return getToken(KotlinParser.OPERATOR, 0); } - public TerminalNode OUT() { return getToken(KotlinParser.OUT, 0); } - public TerminalNode OVERRIDE() { return getToken(KotlinParser.OVERRIDE, 0); } - public TerminalNode PRIVATE() { return getToken(KotlinParser.PRIVATE, 0); } - public TerminalNode PROTECTED() { return getToken(KotlinParser.PROTECTED, 0); } - public TerminalNode PUBLIC() { return getToken(KotlinParser.PUBLIC, 0); } - public TerminalNode REIFIED() { return getToken(KotlinParser.REIFIED, 0); } - public TerminalNode SEALED() { return getToken(KotlinParser.SEALED, 0); } - public TerminalNode TAILREC() { return getToken(KotlinParser.TAILREC, 0); } - public TerminalNode SET() { return getToken(KotlinParser.SET, 0); } - public TerminalNode VARARG() { return getToken(KotlinParser.VARARG, 0); } - public TerminalNode WHERE() { return getToken(KotlinParser.WHERE, 0); } - public TerminalNode FIELD() { return getToken(KotlinParser.FIELD, 0); } - public TerminalNode PROPERTY() { return getToken(KotlinParser.PROPERTY, 0); } - public TerminalNode RECEIVER() { return getToken(KotlinParser.RECEIVER, 0); } - public TerminalNode PARAM() { return getToken(KotlinParser.PARAM, 0); } - public TerminalNode SETPARAM() { return getToken(KotlinParser.SETPARAM, 0); } - public TerminalNode DELEGATE() { return getToken(KotlinParser.DELEGATE, 0); } - public TerminalNode FILE() { return getToken(KotlinParser.FILE, 0); } - public TerminalNode EXPECT() { return getToken(KotlinParser.EXPECT, 0); } - public TerminalNode ACTUAL() { return getToken(KotlinParser.ACTUAL, 0); } - public TerminalNode CONST() { return getToken(KotlinParser.CONST, 0); } - public TerminalNode SUSPEND() { return getToken(KotlinParser.SUSPEND, 0); } - public TerminalNode VALUE() { return getToken(KotlinParser.VALUE, 0); } - public SimpleIdentifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_simpleIdentifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterSimpleIdentifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitSimpleIdentifier(this); - } - } - - public final SimpleIdentifierContext simpleIdentifier() throws RecognitionException { - SimpleIdentifierContext _localctx = new SimpleIdentifierContext(_ctx, getState()); - enterRule(_localctx, 342, RULE_simpleIdentifier); - int _la; - try { - enterOuterAlt(_localctx, 1); - { - setState(3437); - _la = _input.LA(1); - if ( !(((((_la - 61)) & ~0x3f) == 0 && ((1L << (_la - 61)) & ((1L << (FILE - 61)) | (1L << (FIELD - 61)) | (1L << (PROPERTY - 61)) | (1L << (GET - 61)) | (1L << (SET - 61)) | (1L << (RECEIVER - 61)) | (1L << (PARAM - 61)) | (1L << (SETPARAM - 61)) | (1L << (DELEGATE - 61)) | (1L << (IMPORT - 61)) | (1L << (CONSTRUCTOR - 61)) | (1L << (BY - 61)) | (1L << (COMPANION - 61)) | (1L << (INIT - 61)) | (1L << (WHERE - 61)) | (1L << (CATCH - 61)) | (1L << (FINALLY - 61)) | (1L << (OUT - 61)) | (1L << (DYNAMIC - 61)) | (1L << (PUBLIC - 61)) | (1L << (PRIVATE - 61)) | (1L << (PROTECTED - 61)) | (1L << (INTERNAL - 61)) | (1L << (ENUM - 61)) | (1L << (SEALED - 61)) | (1L << (ANNOTATION - 61)) | (1L << (DATA - 61)) | (1L << (INNER - 61)) | (1L << (VALUE - 61)) | (1L << (TAILREC - 61)) | (1L << (OPERATOR - 61)) | (1L << (INLINE - 61)) | (1L << (INFIX - 61)) | (1L << (EXTERNAL - 61)) | (1L << (SUSPEND - 61)) | (1L << (OVERRIDE - 61)) | (1L << (ABSTRACT - 61)))) != 0) || ((((_la - 125)) & ~0x3f) == 0 && ((1L << (_la - 125)) & ((1L << (FINAL - 125)) | (1L << (OPEN - 125)) | (1L << (CONST - 125)) | (1L << (LATEINIT - 125)) | (1L << (VARARG - 125)) | (1L << (NOINLINE - 125)) | (1L << (CROSSINLINE - 125)) | (1L << (REIFIED - 125)) | (1L << (EXPECT - 125)) | (1L << (ACTUAL - 125)) | (1L << (Identifier - 125)))) != 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 IdentifierContext extends ParserRuleContext { - public List simpleIdentifier() { - return getRuleContexts(SimpleIdentifierContext.class); - } - public SimpleIdentifierContext simpleIdentifier(int i) { - return getRuleContext(SimpleIdentifierContext.class,i); - } - public List DOT() { return getTokens(KotlinParser.DOT); } - public TerminalNode DOT(int i) { - return getToken(KotlinParser.DOT, i); - } - public List NL() { return getTokens(KotlinParser.NL); } - public TerminalNode NL(int i) { - return getToken(KotlinParser.NL, i); - } - public IdentifierContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - @Override public int getRuleIndex() { return RULE_identifier; } - @Override - public void enterRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).enterIdentifier(this); - } - @Override - public void exitRule(ParseTreeListener listener) { - if ( listener instanceof KotlinParserListener ) ((KotlinParserListener)listener).exitIdentifier(this); - } - } - - public final IdentifierContext identifier() throws RecognitionException { - IdentifierContext _localctx = new IdentifierContext(_ctx, getState()); - enterRule(_localctx, 344, RULE_identifier); - int _la; - try { - int _alt; - enterOuterAlt(_localctx, 1); - { - setState(3439); - simpleIdentifier(); - setState(3450); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,529,_ctx); - while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { - if ( _alt==1 ) { - { - { - setState(3443); - _errHandler.sync(this); - _la = _input.LA(1); - while (_la==NL) { - { - { - setState(3440); - match(NL); - } - } - setState(3445); - _errHandler.sync(this); - _la = _input.LA(1); - } - setState(3446); - match(DOT); - setState(3447); - simpleIdentifier(); - } - } - } - setState(3452); - _errHandler.sync(this); - _alt = getInterpreter().adaptivePredict(_input,529,_ctx); - } - } - } - catch (RecognitionException re) { - _localctx.exception = re; - _errHandler.reportError(this, re); - _errHandler.recover(this, re); - } - finally { - exitRule(); - } - return _localctx; - } - - private static final int _serializedATNSegments = 2; - private static final String _serializedATNSegment0 = - "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u00ad\u0d80\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\3\2\5\2\u015e\n\2\3\2\7\2\u0161\n\2\f\2\16\2\u0164\13"+ - "\2\3\2\7\2\u0167\n\2\f\2\16\2\u016a\13\2\3\2\3\2\3\2\7\2\u016f\n\2\f\2"+ - "\16\2\u0172\13\2\3\2\3\2\3\3\5\3\u0177\n\3\3\3\7\3\u017a\n\3\f\3\16\3"+ - "\u017d\13\3\3\3\7\3\u0180\n\3\f\3\16\3\u0183\13\3\3\3\3\3\3\3\3\3\3\3"+ - "\7\3\u018a\n\3\f\3\16\3\u018d\13\3\3\3\3\3\3\4\3\4\6\4\u0193\n\4\r\4\16"+ - "\4\u0194\3\5\3\5\3\5\7\5\u019a\n\5\f\5\16\5\u019d\13\5\3\5\3\5\7\5\u01a1"+ - "\n\5\f\5\16\5\u01a4\13\5\3\5\3\5\6\5\u01a8\n\5\r\5\16\5\u01a9\3\5\3\5"+ - "\3\5\5\5\u01af\n\5\3\5\7\5\u01b2\n\5\f\5\16\5\u01b5\13\5\3\6\3\6\3\6\5"+ - "\6\u01ba\n\6\5\6\u01bc\n\6\3\7\7\7\u01bf\n\7\f\7\16\7\u01c2\13\7\3\b\3"+ - "\b\3\b\3\b\3\b\5\b\u01c9\n\b\3\b\5\b\u01cc\n\b\3\t\3\t\3\t\3\n\3\n\5\n"+ - "\u01d3\n\n\3\13\5\13\u01d6\n\13\3\13\3\13\7\13\u01da\n\13\f\13\16\13\u01dd"+ - "\13\13\3\13\3\13\7\13\u01e1\n\13\f\13\16\13\u01e4\13\13\3\13\5\13\u01e7"+ - "\n\13\3\13\7\13\u01ea\n\13\f\13\16\13\u01ed\13\13\3\13\3\13\7\13\u01f1"+ - "\n\13\f\13\16\13\u01f4\13\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\5\f\u01fd\n"+ - "\f\3\r\5\r\u0200\n\r\3\r\3\r\3\r\7\r\u0205\n\r\f\r\16\r\u0208\13\r\5\r"+ - "\u020a\n\r\3\r\5\r\u020d\n\r\3\r\7\r\u0210\n\r\f\r\16\r\u0213\13\r\3\r"+ - "\3\r\7\r\u0217\n\r\f\r\16\r\u021a\13\r\3\r\5\r\u021d\n\r\3\r\7\r\u0220"+ - "\n\r\f\r\16\r\u0223\13\r\3\r\5\r\u0226\n\r\3\r\7\r\u0229\n\r\f\r\16\r"+ - "\u022c\13\r\3\r\3\r\7\r\u0230\n\r\f\r\16\r\u0233\13\r\3\r\5\r\u0236\n"+ - "\r\3\r\7\r\u0239\n\r\f\r\16\r\u023c\13\r\3\r\5\r\u023f\n\r\3\r\7\r\u0242"+ - "\n\r\f\r\16\r\u0245\13\r\3\r\3\r\7\r\u0249\n\r\f\r\16\r\u024c\13\r\3\r"+ - "\5\r\u024f\n\r\3\16\5\16\u0252\n\16\3\16\3\16\7\16\u0256\n\16\f\16\16"+ - "\16\u0259\13\16\5\16\u025b\n\16\3\16\3\16\3\17\3\17\7\17\u0261\n\17\f"+ - "\17\16\17\u0264\13\17\3\17\3\17\7\17\u0268\n\17\f\17\16\17\u026b\13\17"+ - "\3\17\3\17\3\20\3\20\7\20\u0271\n\20\f\20\16\20\u0274\13\20\3\20\3\20"+ - "\7\20\u0278\n\20\f\20\16\20\u027b\13\20\3\20\3\20\7\20\u027f\n\20\f\20"+ - "\16\20\u0282\13\20\3\20\7\20\u0285\n\20\f\20\16\20\u0288\13\20\3\20\7"+ - "\20\u028b\n\20\f\20\16\20\u028e\13\20\3\20\5\20\u0291\n\20\5\20\u0293"+ - "\n\20\3\20\7\20\u0296\n\20\f\20\16\20\u0299\13\20\3\20\3\20\3\21\5\21"+ - "\u029e\n\21\3\21\5\21\u02a1\n\21\3\21\7\21\u02a4\n\21\f\21\16\21\u02a7"+ - "\13\21\3\21\3\21\3\21\7\21\u02ac\n\21\f\21\16\21\u02af\13\21\3\21\3\21"+ - "\7\21\u02b3\n\21\f\21\16\21\u02b6\13\21\3\21\3\21\7\21\u02ba\n\21\f\21"+ - "\16\21\u02bd\13\21\3\21\5\21\u02c0\n\21\3\22\3\22\7\22\u02c4\n\22\f\22"+ - "\16\22\u02c7\13\22\3\22\3\22\7\22\u02cb\n\22\f\22\16\22\u02ce\13\22\3"+ - "\22\7\22\u02d1\n\22\f\22\16\22\u02d4\13\22\3\23\3\23\3\23\3\23\5\23\u02da"+ - "\n\23\3\24\3\24\3\24\3\25\7\25\u02e0\n\25\f\25\16\25\u02e3\13\25\3\25"+ - "\7\25\u02e6\n\25\f\25\16\25\u02e9\13\25\3\25\3\25\3\26\3\26\5\26\u02ef"+ - "\n\26\3\26\7\26\u02f2\n\26\f\26\16\26\u02f5\13\26\3\26\3\26\7\26\u02f9"+ - "\n\26\f\26\16\26\u02fc\13\26\3\26\3\26\3\27\3\27\7\27\u0302\n\27\f\27"+ - "\16\27\u0305\13\27\3\27\3\27\7\27\u0309\n\27\f\27\16\27\u030c\13\27\3"+ - "\27\3\27\7\27\u0310\n\27\f\27\16\27\u0313\13\27\3\27\7\27\u0316\n\27\f"+ - "\27\16\27\u0319\13\27\3\27\7\27\u031c\n\27\f\27\16\27\u031f\13\27\3\27"+ - "\5\27\u0322\n\27\3\27\7\27\u0325\n\27\f\27\16\27\u0328\13\27\3\27\3\27"+ - "\3\30\5\30\u032d\n\30\3\30\7\30\u0330\n\30\f\30\16\30\u0333\13\30\3\30"+ - "\3\30\7\30\u0337\n\30\f\30\16\30\u033a\13\30\3\30\3\30\7\30\u033e\n\30"+ - "\f\30\16\30\u0341\13\30\3\30\5\30\u0344\n\30\3\31\3\31\7\31\u0348\n\31"+ - "\f\31\16\31\u034b\13\31\3\31\3\31\7\31\u034f\n\31\f\31\16\31\u0352\13"+ - "\31\3\31\3\31\7\31\u0356\n\31\f\31\16\31\u0359\13\31\3\31\7\31\u035c\n"+ - "\31\f\31\16\31\u035f\13\31\3\32\7\32\u0362\n\32\f\32\16\32\u0365\13\32"+ - "\3\32\3\32\7\32\u0369\n\32\f\32\16\32\u036c\13\32\3\32\3\32\7\32\u0370"+ - "\n\32\f\32\16\32\u0373\13\32\3\32\3\32\3\33\3\33\5\33\u0379\n\33\7\33"+ - "\u037b\n\33\f\33\16\33\u037e\13\33\3\34\3\34\3\34\3\34\5\34\u0384\n\34"+ - "\3\35\3\35\7\35\u0388\n\35\f\35\16\35\u038b\13\35\3\35\3\35\3\36\5\36"+ - "\u0390\n\36\3\36\3\36\7\36\u0394\n\36\f\36\16\36\u0397\13\36\3\36\3\36"+ - "\7\36\u039b\n\36\f\36\16\36\u039e\13\36\3\36\5\36\u03a1\n\36\3\36\7\36"+ - "\u03a4\n\36\f\36\16\36\u03a7\13\36\3\36\3\36\7\36\u03ab\n\36\f\36\16\36"+ - "\u03ae\13\36\3\36\5\36\u03b1\n\36\3\36\7\36\u03b4\n\36\f\36\16\36\u03b7"+ - "\13\36\3\36\5\36\u03ba\n\36\3\37\3\37\7\37\u03be\n\37\f\37\16\37\u03c1"+ - "\13\37\3\37\3\37\7\37\u03c5\n\37\f\37\16\37\u03c8\13\37\3\37\3\37\7\37"+ - "\u03cc\n\37\f\37\16\37\u03cf\13\37\3\37\7\37\u03d2\n\37\f\37\16\37\u03d5"+ - "\13\37\3\37\7\37\u03d8\n\37\f\37\16\37\u03db\13\37\3\37\5\37\u03de\n\37"+ - "\5\37\u03e0\n\37\3\37\7\37\u03e3\n\37\f\37\16\37\u03e6\13\37\3\37\3\37"+ - "\3 \5 \u03eb\n \3 \3 \7 \u03ef\n \f \16 \u03f2\13 \3 \3 \7 \u03f6\n \f"+ - " \16 \u03f9\13 \3 \5 \u03fc\n \3!\5!\u03ff\n!\3!\3!\7!\u0403\n!\f!\16"+ - "!\u0406\13!\3!\5!\u0409\n!\3!\7!\u040c\n!\f!\16!\u040f\13!\3!\3!\7!\u0413"+ - "\n!\f!\16!\u0416\13!\3!\3!\5!\u041a\n!\3!\7!\u041d\n!\f!\16!\u0420\13"+ - "!\3!\3!\7!\u0424\n!\f!\16!\u0427\13!\3!\3!\7!\u042b\n!\f!\16!\u042e\13"+ - "!\3!\3!\7!\u0432\n!\f!\16!\u0435\13!\3!\5!\u0438\n!\3!\7!\u043b\n!\f!"+ - "\16!\u043e\13!\3!\5!\u0441\n!\3!\7!\u0444\n!\f!\16!\u0447\13!\3!\5!\u044a"+ - "\n!\3\"\3\"\3\"\7\"\u044f\n\"\f\"\16\"\u0452\13\"\3\"\5\"\u0455\n\"\3"+ - "#\7#\u0458\n#\f#\16#\u045b\13#\3#\7#\u045e\n#\f#\16#\u0461\13#\3#\3#\7"+ - "#\u0465\n#\f#\16#\u0468\13#\3#\3#\7#\u046c\n#\f#\16#\u046f\13#\3#\5#\u0472"+ - "\n#\3$\3$\7$\u0476\n$\f$\16$\u0479\13$\3$\3$\7$\u047d\n$\f$\16$\u0480"+ - "\13$\3$\3$\7$\u0484\n$\f$\16$\u0487\13$\3$\7$\u048a\n$\f$\16$\u048d\13"+ - "$\3$\7$\u0490\n$\f$\16$\u0493\13$\3$\5$\u0496\n$\3$\7$\u0499\n$\f$\16"+ - "$\u049c\13$\3$\3$\3%\5%\u04a1\n%\3%\3%\7%\u04a5\n%\f%\16%\u04a8\13%\3"+ - "%\5%\u04ab\n%\3%\7%\u04ae\n%\f%\16%\u04b1\13%\3%\3%\7%\u04b5\n%\f%\16"+ - "%\u04b8\13%\3%\3%\5%\u04bc\n%\3%\7%\u04bf\n%\f%\16%\u04c2\13%\3%\3%\5"+ - "%\u04c6\n%\3%\7%\u04c9\n%\f%\16%\u04cc\13%\3%\5%\u04cf\n%\3%\7%\u04d2"+ - "\n%\f%\16%\u04d5\13%\3%\3%\7%\u04d9\n%\f%\16%\u04dc\13%\3%\3%\5%\u04e0"+ - "\n%\5%\u04e2\n%\3%\6%\u04e5\n%\r%\16%\u04e6\3%\5%\u04ea\n%\3%\7%\u04ed"+ - "\n%\f%\16%\u04f0\13%\3%\5%\u04f3\n%\3%\7%\u04f6\n%\f%\16%\u04f9\13%\3"+ - "%\5%\u04fc\n%\3%\5%\u04ff\n%\3%\5%\u0502\n%\3%\7%\u0505\n%\f%\16%\u0508"+ - "\13%\3%\5%\u050b\n%\3%\5%\u050e\n%\5%\u0510\n%\3&\3&\7&\u0514\n&\f&\16"+ - "&\u0517\13&\3&\3&\3\'\5\'\u051c\n\'\3\'\3\'\7\'\u0520\n\'\f\'\16\'\u0523"+ - "\13\'\3\'\3\'\7\'\u0527\n\'\f\'\16\'\u052a\13\'\3\'\3\'\7\'\u052e\n\'"+ - "\f\'\16\'\u0531\13\'\3\'\3\'\7\'\u0535\n\'\f\'\16\'\u0538\13\'\3\'\5\'"+ - "\u053b\n\'\3\'\7\'\u053e\n\'\f\'\16\'\u0541\13\'\3\'\5\'\u0544\n\'\3("+ - "\5(\u0547\n(\3(\3(\7(\u054b\n(\f(\16(\u054e\13(\3(\3(\7(\u0552\n(\f(\16"+ - "(\u0555\13(\3(\3(\7(\u0559\n(\f(\16(\u055c\13(\3(\5(\u055f\n(\3(\7(\u0562"+ - "\n(\f(\16(\u0565\13(\3(\3(\7(\u0569\n(\f(\16(\u056c\13(\3(\3(\7(\u0570"+ - "\n(\f(\16(\u0573\13(\3(\5(\u0576\n(\3(\7(\u0579\n(\f(\16(\u057c\13(\3"+ - "(\3(\5(\u0580\n(\3)\3)\7)\u0584\n)\f)\16)\u0587\13)\3)\3)\7)\u058b\n)"+ - "\f)\16)\u058e\13)\3)\3)\7)\u0592\n)\f)\16)\u0595\13)\3)\7)\u0598\n)\f"+ - ")\16)\u059b\13)\3)\7)\u059e\n)\f)\16)\u05a1\13)\3)\5)\u05a4\n)\5)\u05a6"+ - "\n)\3)\7)\u05a9\n)\f)\16)\u05ac\13)\3)\3)\3*\5*\u05b1\n*\3*\3*\7*\u05b5"+ - "\n*\f*\16*\u05b8\13*\3*\3*\7*\u05bc\n*\f*\16*\u05bf\13*\3*\5*\u05c2\n"+ - "*\3+\3+\7+\u05c6\n+\f+\16+\u05c9\13+\3+\3+\7+\u05cd\n+\f+\16+\u05d0\13"+ - "+\3+\5+\u05d3\n+\3,\3,\7,\u05d7\n,\f,\16,\u05da\13,\3,\3,\7,\u05de\n,"+ - "\f,\16,\u05e1\13,\3,\3,\3-\5-\u05e6\n-\3-\3-\7-\u05ea\n-\f-\16-\u05ed"+ - "\13-\3-\3-\7-\u05f1\n-\f-\16-\u05f4\13-\3-\3-\7-\u05f8\n-\f-\16-\u05fb"+ - "\13-\3-\5-\u05fe\n-\3-\7-\u0601\n-\f-\16-\u0604\13-\3-\5-\u0607\n-\3."+ - "\5.\u060a\n.\3.\3.\7.\u060e\n.\f.\16.\u0611\13.\3.\3.\7.\u0615\n.\f.\16"+ - ".\u0618\13.\3.\3.\7.\u061c\n.\f.\16.\u061f\13.\3.\5.\u0622\n.\3.\7.\u0625"+ - "\n.\f.\16.\u0628\13.\3.\5.\u062b\n.\3/\3/\7/\u062f\n/\f/\16/\u0632\13"+ - "/\3/\3/\3\60\3\60\7\60\u0638\n\60\f\60\16\60\u063b\13\60\3\60\5\60\u063e"+ - "\n\60\3\60\7\60\u0641\n\60\f\60\16\60\u0644\13\60\3\60\3\60\7\60\u0648"+ - "\n\60\f\60\16\60\u064b\13\60\3\60\5\60\u064e\n\60\3\60\7\60\u0651\n\60"+ - "\f\60\16\60\u0654\13\60\3\60\3\60\3\61\3\61\7\61\u065a\n\61\f\61\16\61"+ - "\u065d\13\61\3\61\3\61\7\61\u0661\n\61\f\61\16\61\u0664\13\61\3\61\7\61"+ - "\u0667\n\61\f\61\16\61\u066a\13\61\3\61\7\61\u066d\n\61\f\61\16\61\u0670"+ - "\13\61\3\61\5\61\u0673\n\61\3\62\3\62\7\62\u0677\n\62\f\62\16\62\u067a"+ - "\13\62\5\62\u067c\n\62\3\62\3\62\7\62\u0680\n\62\f\62\16\62\u0683\13\62"+ - "\3\62\5\62\u0686\n\62\3\62\7\62\u0689\n\62\f\62\16\62\u068c\13\62\3\62"+ - "\5\62\u068f\n\62\3\63\5\63\u0692\n\63\3\63\3\63\3\63\3\63\5\63\u0698\n"+ - "\63\3\64\3\64\5\64\u069c\n\64\3\65\3\65\5\65\u06a0\n\65\3\65\7\65\u06a3"+ - "\n\65\f\65\16\65\u06a6\13\65\3\65\6\65\u06a9\n\65\r\65\16\65\u06aa\3\66"+ - "\3\66\3\67\3\67\7\67\u06b1\n\67\f\67\16\67\u06b4\13\67\3\67\3\67\7\67"+ - "\u06b8\n\67\f\67\16\67\u06bb\13\67\3\67\7\67\u06be\n\67\f\67\16\67\u06c1"+ - "\13\67\38\38\78\u06c5\n8\f8\168\u06c8\138\38\58\u06cb\n8\39\59\u06ce\n"+ - "9\39\39\59\u06d2\n9\3:\6:\u06d5\n:\r:\16:\u06d6\3;\3;\7;\u06db\n;\f;\16"+ - ";\u06de\13;\3;\5;\u06e1\n;\3<\3<\7<\u06e5\n<\f<\16<\u06e8\13<\3<\3<\7"+ - "<\u06ec\n<\f<\16<\u06ef\13<\5<\u06f1\n<\3<\3<\7<\u06f5\n<\f<\16<\u06f8"+ - "\13<\3<\3<\7<\u06fc\n<\f<\16<\u06ff\13<\3<\3<\3=\3=\7=\u0705\n=\f=\16"+ - "=\u0708\13=\3=\3=\5=\u070c\n=\3=\7=\u070f\n=\f=\16=\u0712\13=\3=\3=\7"+ - "=\u0716\n=\f=\16=\u0719\13=\3=\3=\5=\u071d\n=\7=\u071f\n=\f=\16=\u0722"+ - "\13=\3=\7=\u0725\n=\f=\16=\u0728\13=\3=\5=\u072b\n=\3=\7=\u072e\n=\f="+ - "\16=\u0731\13=\3=\3=\3>\3>\7>\u0737\n>\f>\16>\u073a\13>\3>\3>\7>\u073e"+ - "\n>\f>\16>\u0741\13>\3>\3>\3?\5?\u0746\n?\3?\3?\3?\5?\u074b\n?\3@\3@\7"+ - "@\u074f\n@\f@\16@\u0752\13@\3@\3@\5@\u0756\n@\3@\7@\u0759\n@\f@\16@\u075c"+ - "\13@\3@\3@\3A\3A\3A\3A\7A\u0764\nA\fA\16A\u0767\13A\5A\u0769\nA\3A\5A"+ - "\u076c\nA\3B\3B\7B\u0770\nB\fB\16B\u0773\13B\3B\3B\3B\3B\5B\u0779\nB\3"+ - "C\3C\3C\7C\u077e\nC\fC\16C\u0781\13C\3D\3D\5D\u0785\nD\3E\3E\7E\u0789"+ - "\nE\fE\16E\u078c\13E\3E\3E\7E\u0790\nE\fE\16E\u0793\13E\3E\3E\3F\3F\3"+ - "F\5F\u079a\nF\3G\3G\7G\u079e\nG\fG\16G\u07a1\13G\3G\3G\7G\u07a5\nG\fG"+ - "\16G\u07a8\13G\3G\3G\5G\u07ac\nG\3G\3G\3G\3G\7G\u07b2\nG\fG\16G\u07b5"+ - "\13G\3G\5G\u07b8\nG\3H\3H\7H\u07bc\nH\fH\16H\u07bf\13H\3H\3H\3H\3H\7H"+ - "\u07c5\nH\fH\16H\u07c8\13H\3H\3H\5H\u07cc\nH\3I\3I\7I\u07d0\nI\fI\16I"+ - "\u07d3\13I\3I\5I\u07d6\nI\3I\7I\u07d9\nI\fI\16I\u07dc\13I\3I\3I\7I\u07e0"+ - "\nI\fI\16I\u07e3\13I\3I\3I\3I\3I\3J\3J\3J\3J\3J\3J\5J\u07ef\nJ\3J\7J\u07f2"+ - "\nJ\fJ\16J\u07f5\13J\3J\3J\3K\3K\7K\u07fb\nK\fK\16K\u07fe\13K\3K\5K\u0801"+ - "\nK\3L\6L\u0804\nL\rL\16L\u0805\3L\5L\u0809\nL\3M\3M\3N\3N\7N\u080f\n"+ - "N\fN\16N\u0812\13N\3N\3N\7N\u0816\nN\fN\16N\u0819\13N\3N\7N\u081c\nN\f"+ - "N\16N\u081f\13N\3O\3O\7O\u0823\nO\fO\16O\u0826\13O\3O\3O\7O\u082a\nO\f"+ - "O\16O\u082d\13O\3O\7O\u0830\nO\fO\16O\u0833\13O\3P\3P\3P\7P\u0838\nP\f"+ - "P\16P\u083b\13P\3P\3P\7P\u083f\nP\fP\16P\u0842\13P\3Q\3Q\3Q\7Q\u0847\n"+ - "Q\fQ\16Q\u084a\13Q\3Q\3Q\7Q\u084e\nQ\fQ\16Q\u0851\13Q\3R\3R\7R\u0855\n"+ - "R\fR\16R\u0858\13R\3S\3S\3S\7S\u085d\nS\fS\16S\u0860\13S\3S\3S\3S\3S\7"+ - "S\u0866\nS\fS\16S\u0869\13S\3S\3S\7S\u086d\nS\fS\16S\u0870\13S\3T\3T\7"+ - "T\u0874\nT\fT\16T\u0877\13T\3T\3T\7T\u087b\nT\fT\16T\u087e\13T\3T\3T\7"+ - "T\u0882\nT\fT\16T\u0885\13T\3U\3U\3U\3V\3V\3V\7V\u088d\nV\fV\16V\u0890"+ - "\13V\3V\3V\7V\u0894\nV\fV\16V\u0897\13V\3W\3W\3W\7W\u089c\nW\fW\16W\u089f"+ - "\13W\3W\7W\u08a2\nW\fW\16W\u08a5\13W\3X\3X\3X\7X\u08aa\nX\fX\16X\u08ad"+ - "\13X\3X\3X\7X\u08b1\nX\fX\16X\u08b4\13X\3Y\3Y\3Y\7Y\u08b9\nY\fY\16Y\u08bc"+ - "\13Y\3Y\3Y\7Y\u08c0\nY\fY\16Y\u08c3\13Y\3Z\3Z\7Z\u08c7\nZ\fZ\16Z\u08ca"+ - "\13Z\3Z\3Z\7Z\u08ce\nZ\fZ\16Z\u08d1\13Z\3Z\3Z\7Z\u08d5\nZ\fZ\16Z\u08d8"+ - "\13Z\3[\7[\u08db\n[\f[\16[\u08de\13[\3[\3[\3\\\3\\\3\\\3\\\7\\\u08e6\n"+ - "\\\f\\\16\\\u08e9\13\\\5\\\u08eb\n\\\3]\3]\7]\u08ef\n]\f]\16]\u08f2\13"+ - "]\3^\3^\3^\3^\3^\5^\u08f9\n^\3_\3_\3_\3_\3_\5_\u0900\n_\3`\3`\7`\u0904"+ - "\n`\f`\16`\u0907\13`\3`\3`\7`\u090b\n`\f`\16`\u090e\13`\3`\3`\3a\3a\5"+ - "a\u0914\na\3b\3b\7b\u0918\nb\fb\16b\u091b\13b\3b\3b\7b\u091f\nb\fb\16"+ - "b\u0922\13b\3b\3b\3c\3c\3c\5c\u0929\nc\3d\3d\7d\u092d\nd\fd\16d\u0930"+ - "\13d\3d\3d\7d\u0934\nd\fd\16d\u0937\13d\3d\3d\7d\u093b\nd\fd\16d\u093e"+ - "\13d\3d\7d\u0941\nd\fd\16d\u0944\13d\3d\7d\u0947\nd\fd\16d\u094a\13d\3"+ - "d\5d\u094d\nd\3d\7d\u0950\nd\fd\16d\u0953\13d\3d\3d\3e\3e\7e\u0959\ne"+ - "\fe\16e\u095c\13e\3e\3e\3e\5e\u0961\ne\3f\5f\u0964\nf\3f\5f\u0967\nf\3"+ - "f\3f\5f\u096b\nf\3g\7g\u096e\ng\fg\16g\u0971\13g\3g\5g\u0974\ng\3g\7g"+ - "\u0977\ng\fg\16g\u097a\13g\3g\3g\3h\3h\7h\u0980\nh\fh\16h\u0983\13h\3"+ - "h\3h\7h\u0987\nh\fh\16h\u098a\13h\3h\3h\7h\u098e\nh\fh\16h\u0991\13h\3"+ - "h\7h\u0994\nh\fh\16h\u0997\13h\3h\7h\u099a\nh\fh\16h\u099d\13h\3h\5h\u09a0"+ - "\nh\3h\7h\u09a3\nh\fh\16h\u09a6\13h\3h\3h\3i\3i\7i\u09ac\ni\fi\16i\u09af"+ - "\13i\3i\3i\7i\u09b3\ni\fi\16i\u09b6\13i\3i\3i\7i\u09ba\ni\fi\16i\u09bd"+ - "\13i\3i\7i\u09c0\ni\fi\16i\u09c3\13i\3i\7i\u09c6\ni\fi\16i\u09c9\13i\3"+ - "i\5i\u09cc\ni\3i\7i\u09cf\ni\fi\16i\u09d2\13i\5i\u09d4\ni\3i\3i\3j\5j"+ - "\u09d9\nj\3j\7j\u09dc\nj\fj\16j\u09df\13j\3j\3j\7j\u09e3\nj\fj\16j\u09e6"+ - "\13j\3j\3j\7j\u09ea\nj\fj\16j\u09ed\13j\5j\u09ef\nj\3j\5j\u09f2\nj\3j"+ - "\7j\u09f5\nj\fj\16j\u09f8\13j\3j\3j\3k\3k\3k\3k\3k\3k\3k\3k\3k\3k\3k\3"+ - "k\3k\3k\5k\u0a0a\nk\3l\3l\7l\u0a0e\nl\fl\16l\u0a11\13l\3l\3l\7l\u0a15"+ - "\nl\fl\16l\u0a18\13l\3l\3l\3m\3m\7m\u0a1e\nm\fm\16m\u0a21\13m\3m\3m\7"+ - "m\u0a25\nm\fm\16m\u0a28\13m\3m\3m\7m\u0a2c\nm\fm\16m\u0a2f\13m\3m\7m\u0a32"+ - "\nm\fm\16m\u0a35\13m\3m\7m\u0a38\nm\fm\16m\u0a3b\13m\3m\5m\u0a3e\nm\3"+ - "m\7m\u0a41\nm\fm\16m\u0a44\13m\5m\u0a46\nm\3m\3m\3n\3n\3o\3o\5o\u0a4e"+ - "\no\3p\3p\3p\7p\u0a53\np\fp\16p\u0a56\13p\3p\3p\3q\3q\3q\3q\7q\u0a5e\n"+ - "q\fq\16q\u0a61\13q\3q\3q\3r\3r\3s\3s\7s\u0a69\ns\fs\16s\u0a6c\13s\3s\3"+ - "s\7s\u0a70\ns\fs\16s\u0a73\13s\3s\3s\3t\3t\3u\3u\7u\u0a7b\nu\fu\16u\u0a7e"+ - "\13u\3u\3u\7u\u0a82\nu\fu\16u\u0a85\13u\3u\3u\3v\3v\7v\u0a8b\nv\fv\16"+ - "v\u0a8e\13v\3v\5v\u0a91\nv\3v\7v\u0a94\nv\fv\16v\u0a97\13v\3v\3v\7v\u0a9b"+ - "\nv\fv\16v\u0a9e\13v\5v\u0aa0\nv\3v\3v\7v\u0aa4\nv\fv\16v\u0aa7\13v\3"+ - "v\3v\3w\3w\7w\u0aad\nw\fw\16w\u0ab0\13w\3w\3w\7w\u0ab4\nw\fw\16w\u0ab7"+ - "\13w\3w\7w\u0aba\nw\fw\16w\u0abd\13w\3w\7w\u0ac0\nw\fw\16w\u0ac3\13w\3"+ - "w\5w\u0ac6\nw\3x\3x\3x\7x\u0acb\nx\fx\16x\u0ace\13x\3x\3x\7x\u0ad2\nx"+ - "\fx\16x\u0ad5\13x\3x\5x\u0ad8\nx\5x\u0ada\nx\3y\3y\7y\u0ade\ny\fy\16y"+ - "\u0ae1\13y\3y\3y\7y\u0ae5\ny\fy\16y\u0ae8\13y\3y\3y\5y\u0aec\ny\3y\7y"+ - "\u0aef\ny\fy\16y\u0af2\13y\3y\3y\7y\u0af6\ny\fy\16y\u0af9\13y\3y\3y\7"+ - "y\u0afd\ny\fy\16y\u0b00\13y\3y\5y\u0b03\ny\3y\7y\u0b06\ny\fy\16y\u0b09"+ - "\13y\3y\5y\u0b0c\ny\3y\7y\u0b0f\ny\fy\16y\u0b12\13y\3y\5y\u0b15\ny\3z"+ - "\3z\5z\u0b19\nz\3{\3{\7{\u0b1d\n{\f{\16{\u0b20\13{\3{\3{\7{\u0b24\n{\f"+ - "{\16{\u0b27\13{\3{\3{\7{\u0b2b\n{\f{\16{\u0b2e\13{\5{\u0b30\n{\3{\7{\u0b33"+ - "\n{\f{\16{\u0b36\13{\3{\5{\u0b39\n{\3|\3|\3}\3}\3}\7}\u0b40\n}\f}\16}"+ - "\u0b43\13}\3}\3}\7}\u0b47\n}\f}\16}\u0b4a\13}\3}\3}\5}\u0b4e\n}\3}\3}"+ - "\5}\u0b52\n}\3}\5}\u0b55\n}\3~\3~\7~\u0b59\n~\f~\16~\u0b5c\13~\3~\3~\7"+ - "~\u0b60\n~\f~\16~\u0b63\13~\3~\3~\7~\u0b67\n~\f~\16~\u0b6a\13~\3~\3~\7"+ - "~\u0b6e\n~\f~\16~\u0b71\13~\3~\3~\5~\u0b75\n~\3~\7~\u0b78\n~\f~\16~\u0b7b"+ - "\13~\3~\5~\u0b7e\n~\3~\7~\u0b81\n~\f~\16~\u0b84\13~\3~\3~\7~\u0b88\n~"+ - "\f~\16~\u0b8b\13~\3~\3~\5~\u0b8f\n~\3~\5~\u0b92\n~\3\177\3\177\7\177\u0b96"+ - "\n\177\f\177\16\177\u0b99\13\177\3\177\7\177\u0b9c\n\177\f\177\16\177"+ - "\u0b9f\13\177\3\177\3\177\7\177\u0ba3\n\177\f\177\16\177\u0ba6\13\177"+ - "\3\177\3\177\7\177\u0baa\n\177\f\177\16\177\u0bad\13\177\3\177\3\177\7"+ - "\177\u0bb1\n\177\f\177\16\177\u0bb4\13\177\5\177\u0bb6\n\177\3\177\3\177"+ - "\3\177\3\u0080\3\u0080\7\u0080\u0bbd\n\u0080\f\u0080\16\u0080\u0bc0\13"+ - "\u0080\3\u0080\5\u0080\u0bc3\n\u0080\3\u0080\7\u0080\u0bc6\n\u0080\f\u0080"+ - "\16\u0080\u0bc9\13\u0080\3\u0080\3\u0080\7\u0080\u0bcd\n\u0080\f\u0080"+ - "\16\u0080\u0bd0\13\u0080\3\u0080\3\u0080\7\u0080\u0bd4\n\u0080\f\u0080"+ - "\16\u0080\u0bd7\13\u0080\7\u0080\u0bd9\n\u0080\f\u0080\16\u0080\u0bdc"+ - "\13\u0080\3\u0080\7\u0080\u0bdf\n\u0080\f\u0080\16\u0080\u0be2\13\u0080"+ - "\3\u0080\3\u0080\3\u0081\3\u0081\7\u0081\u0be8\n\u0081\f\u0081\16\u0081"+ - "\u0beb\13\u0081\3\u0081\3\u0081\7\u0081\u0bef\n\u0081\f\u0081\16\u0081"+ - "\u0bf2\13\u0081\3\u0081\7\u0081\u0bf5\n\u0081\f\u0081\16\u0081\u0bf8\13"+ - "\u0081\3\u0081\7\u0081\u0bfb\n\u0081\f\u0081\16\u0081\u0bfe\13\u0081\3"+ - "\u0081\5\u0081\u0c01\n\u0081\3\u0081\7\u0081\u0c04\n\u0081\f\u0081\16"+ - "\u0081\u0c07\13\u0081\3\u0081\3\u0081\7\u0081\u0c0b\n\u0081\f\u0081\16"+ - "\u0081\u0c0e\13\u0081\3\u0081\3\u0081\5\u0081\u0c12\n\u0081\3\u0081\3"+ - "\u0081\7\u0081\u0c16\n\u0081\f\u0081\16\u0081\u0c19\13\u0081\3\u0081\3"+ - "\u0081\7\u0081\u0c1d\n\u0081\f\u0081\16\u0081\u0c20\13\u0081\3\u0081\3"+ - "\u0081\5\u0081\u0c24\n\u0081\5\u0081\u0c26\n\u0081\3\u0082\3\u0082\3\u0082"+ - "\5\u0082\u0c2b\n\u0082\3\u0083\3\u0083\7\u0083\u0c2f\n\u0083\f\u0083\16"+ - "\u0083\u0c32\13\u0083\3\u0083\3\u0083\3\u0084\3\u0084\7\u0084\u0c38\n"+ - "\u0084\f\u0084\16\u0084\u0c3b\13\u0084\3\u0084\3\u0084\3\u0085\3\u0085"+ - "\7\u0085\u0c41\n\u0085\f\u0085\16\u0085\u0c44\13\u0085\3\u0085\3\u0085"+ - "\7\u0085\u0c48\n\u0085\f\u0085\16\u0085\u0c4b\13\u0085\3\u0085\6\u0085"+ - "\u0c4e\n\u0085\r\u0085\16\u0085\u0c4f\3\u0085\7\u0085\u0c53\n\u0085\f"+ - "\u0085\16\u0085\u0c56\13\u0085\3\u0085\5\u0085\u0c59\n\u0085\3\u0085\7"+ - "\u0085\u0c5c\n\u0085\f\u0085\16\u0085\u0c5f\13\u0085\3\u0085\5\u0085\u0c62"+ - "\n\u0085\3\u0086\3\u0086\7\u0086\u0c66\n\u0086\f\u0086\16\u0086\u0c69"+ - "\13\u0086\3\u0086\3\u0086\7\u0086\u0c6d\n\u0086\f\u0086\16\u0086\u0c70"+ - "\13\u0086\3\u0086\3\u0086\3\u0086\3\u0086\7\u0086\u0c76\n\u0086\f\u0086"+ - "\16\u0086\u0c79\13\u0086\3\u0086\5\u0086\u0c7c\n\u0086\3\u0086\3\u0086"+ - "\7\u0086\u0c80\n\u0086\f\u0086\16\u0086\u0c83\13\u0086\3\u0086\3\u0086"+ - "\3\u0087\3\u0087\7\u0087\u0c89\n\u0087\f\u0087\16\u0087\u0c8c\13\u0087"+ - "\3\u0087\3\u0087\3\u0088\3\u0088\7\u0088\u0c92\n\u0088\f\u0088\16\u0088"+ - "\u0c95\13\u0088\3\u0088\3\u0088\3\u0088\5\u0088\u0c9a\n\u0088\3\u0088"+ - "\3\u0088\3\u0088\3\u0088\5\u0088\u0ca0\n\u0088\3\u0089\5\u0089\u0ca3\n"+ - "\u0089\3\u0089\3\u0089\7\u0089\u0ca7\n\u0089\f\u0089\16\u0089\u0caa\13"+ - "\u0089\3\u0089\3\u0089\5\u0089\u0cae\n\u0089\3\u008a\3\u008a\3\u008b\3"+ - "\u008b\3\u008c\3\u008c\3\u008d\3\u008d\3\u008e\3\u008e\3\u008f\3\u008f"+ - "\3\u0090\3\u0090\3\u0091\3\u0091\3\u0092\3\u0092\3\u0092\3\u0092\3\u0092"+ - "\5\u0092\u0cc5\n\u0092\3\u0093\3\u0093\3\u0093\3\u0093\5\u0093\u0ccb\n"+ - "\u0093\3\u0094\3\u0094\3\u0095\7\u0095\u0cd0\n\u0095\f\u0095\16\u0095"+ - "\u0cd3\13\u0095\3\u0095\3\u0095\7\u0095\u0cd7\n\u0095\f\u0095\16\u0095"+ - "\u0cda\13\u0095\3\u0095\3\u0095\5\u0095\u0cde\n\u0095\3\u0096\3\u0096"+ - "\3\u0096\3\u0097\3\u0097\6\u0097\u0ce5\n\u0097\r\u0097\16\u0097\u0ce6"+ - "\3\u0098\3\u0098\6\u0098\u0ceb\n\u0098\r\u0098\16\u0098\u0cec\3\u0099"+ - "\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\5\u0099\u0cf7"+ - "\n\u0099\3\u0099\7\u0099\u0cfa\n\u0099\f\u0099\16\u0099\u0cfd\13\u0099"+ - "\3\u009a\6\u009a\u0d00\n\u009a\r\u009a\16\u009a\u0d01\3\u009b\3\u009b"+ - "\3\u009b\7\u009b\u0d07\n\u009b\f\u009b\16\u009b\u0d0a\13\u009b\5\u009b"+ - "\u0d0c\n\u009b\3\u009c\3\u009c\3\u009d\3\u009d\3\u009e\3\u009e\3\u009f"+ - "\3\u009f\3\u00a0\6\u00a0\u0d17\n\u00a0\r\u00a0\16\u00a0\u0d18\3\u00a1"+ - "\3\u00a1\7\u00a1\u0d1d\n\u00a1\f\u00a1\16\u00a1\u0d20\13\u00a1\3\u00a1"+ - "\3\u00a1\7\u00a1\u0d24\n\u00a1\f\u00a1\16\u00a1\u0d27\13\u00a1\3\u00a1"+ - "\5\u00a1\u0d2a\n\u00a1\3\u00a2\3\u00a2\3\u00a3\3\u00a3\3\u00a4\3\u00a4"+ - "\3\u00a5\3\u00a5\3\u00a6\3\u00a6\3\u00a7\3\u00a7\3\u00a8\3\u00a8\5\u00a8"+ - "\u0d3a\n\u00a8\3\u00a8\7\u00a8\u0d3d\n\u00a8\f\u00a8\16\u00a8\u0d40\13"+ - "\u00a8\3\u00a9\3\u00a9\7\u00a9\u0d44\n\u00a9\f\u00a9\16\u00a9\u0d47\13"+ - "\u00a9\3\u00a9\3\u00a9\5\u00a9\u0d4b\n\u00a9\3\u00a9\3\u00a9\3\u00aa\3"+ - "\u00aa\7\u00aa\u0d51\n\u00aa\f\u00aa\16\u00aa\u0d54\13\u00aa\3\u00aa\3"+ - "\u00aa\5\u00aa\u0d58\n\u00aa\3\u00aa\3\u00aa\6\u00aa\u0d5c\n\u00aa\r\u00aa"+ - "\16\u00aa\u0d5d\3\u00aa\3\u00aa\3\u00ab\3\u00ab\3\u00ab\7\u00ab\u0d65"+ - "\n\u00ab\f\u00ab\16\u00ab\u0d68\13\u00ab\3\u00ab\3\u00ab\3\u00ac\3\u00ac"+ - "\5\u00ac\u0d6e\n\u00ac\3\u00ad\3\u00ad\3\u00ae\3\u00ae\7\u00ae\u0d74\n"+ - "\u00ae\f\u00ae\16\u00ae\u0d77\13\u00ae\3\u00ae\3\u00ae\7\u00ae\u0d7b\n"+ - "\u00ae\f\u00ae\16\u00ae\u0d7e\13\u00ae\3\u00ae\2\2\u00af\2\4\6\b\n\f\16"+ - "\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bd"+ - "fhjlnprtvxz|~\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\2 \4\2**,,\3\2NO\3\2UV\3\2./\3\2*+\4\2\7\7\35"+ - "\35\4\2\u0089\u0089\u008c\u0093\3\2\u00a1\u00a3\3\2\u00a6\u00a8\4\2=="+ - "UU\4\2::cc\3\2\37#\4\2\64\65\678\3\2\60\63\4\2hhjj\4\2ggii\3\2\24\25\3"+ - "\2\21\23\4\2\66\66ff\3\2\32\33\3\2qv\4\2}}\u0082\u0082\3\2mp\4\2hhkk\3"+ - "\2w|\3\2~\u0080\3\2\u0083\u0085\3\2\u0087\u0088\3\2@G\t\2?GIIQTXX]^k\u0088"+ - "\u0094\u0094\2\u0f1c\2\u015d\3\2\2\2\4\u0176\3\2\2\2\6\u0190\3\2\2\2\b"+ - "\u0196\3\2\2\2\n\u01bb\3\2\2\2\f\u01c0\3\2\2\2\16\u01c3\3\2\2\2\20\u01cd"+ - "\3\2\2\2\22\u01d0\3\2\2\2\24\u01d5\3\2\2\2\26\u01fc\3\2\2\2\30\u01ff\3"+ - "\2\2\2\32\u025a\3\2\2\2\34\u025e\3\2\2\2\36\u026e\3\2\2\2 \u029d\3\2\2"+ - "\2\"\u02c1\3\2\2\2$\u02d9\3\2\2\2&\u02db\3\2\2\2(\u02e1\3\2\2\2*\u02ee"+ - "\3\2\2\2,\u02ff\3\2\2\2.\u032c\3\2\2\2\60\u0345\3\2\2\2\62\u0363\3\2\2"+ - "\2\64\u037c\3\2\2\2\66\u0383\3\2\2\28\u0385\3\2\2\2:\u038f\3\2\2\2<\u03bb"+ - "\3\2\2\2>\u03ea\3\2\2\2@\u03fe\3\2\2\2B\u0454\3\2\2\2D\u0459\3\2\2\2F"+ - "\u0473\3\2\2\2H\u04a0\3\2\2\2J\u0511\3\2\2\2L\u051b\3\2\2\2N\u0546\3\2"+ - "\2\2P\u0581\3\2\2\2R\u05b0\3\2\2\2T\u05c3\3\2\2\2V\u05d4\3\2\2\2X\u05e5"+ - "\3\2\2\2Z\u0609\3\2\2\2\\\u062c\3\2\2\2^\u0635\3\2\2\2`\u0657\3\2\2\2"+ - "b\u067b\3\2\2\2d\u0691\3\2\2\2f\u069b\3\2\2\2h\u069f\3\2\2\2j\u06ac\3"+ - "\2\2\2l\u06ae\3\2\2\2n\u06c2\3\2\2\2p\u06d1\3\2\2\2r\u06d4\3\2\2\2t\u06e0"+ - "\3\2\2\2v\u06f0\3\2\2\2x\u0702\3\2\2\2z\u0734\3\2\2\2|\u0745\3\2\2\2~"+ - "\u074c\3\2\2\2\u0080\u0768\3\2\2\2\u0082\u0771\3\2\2\2\u0084\u077a\3\2"+ - "\2\2\u0086\u0784\3\2\2\2\u0088\u0786\3\2\2\2\u008a\u0799\3\2\2\2\u008c"+ - "\u079b\3\2\2\2\u008e\u07b9\3\2\2\2\u0090\u07cd\3\2\2\2\u0092\u07ee\3\2"+ - "\2\2\u0094\u0800\3\2\2\2\u0096\u0808\3\2\2\2\u0098\u080a\3\2\2\2\u009a"+ - "\u080c\3\2\2\2\u009c\u0820\3\2\2\2\u009e\u0834\3\2\2\2\u00a0\u0843\3\2"+ - "\2\2\u00a2\u0852\3\2\2\2\u00a4\u0859\3\2\2\2\u00a6\u0871\3\2\2\2\u00a8"+ - "\u0886\3\2\2\2\u00aa\u0889\3\2\2\2\u00ac\u0898\3\2\2\2\u00ae\u08a6\3\2"+ - "\2\2\u00b0\u08b5\3\2\2\2\u00b2\u08c4\3\2\2\2\u00b4\u08dc\3\2\2\2\u00b6"+ - "\u08ea\3\2\2\2\u00b8\u08ec\3\2\2\2\u00ba\u08f8\3\2\2\2\u00bc\u08ff\3\2"+ - "\2\2\u00be\u0901\3\2\2\2\u00c0\u0913\3\2\2\2\u00c2\u0915\3\2\2\2\u00c4"+ - "\u0928\3\2\2\2\u00c6\u092a\3\2\2\2\u00c8\u0956\3\2\2\2\u00ca\u0963\3\2"+ - "\2\2\u00cc\u096f\3\2\2\2\u00ce\u097d\3\2\2\2\u00d0\u09a9\3\2\2\2\u00d2"+ - "\u09d8\3\2\2\2\u00d4\u0a09\3\2\2\2\u00d6\u0a0b\3\2\2\2\u00d8\u0a1b\3\2"+ - "\2\2\u00da\u0a49\3\2\2\2\u00dc\u0a4d\3\2\2\2\u00de\u0a4f\3\2\2\2\u00e0"+ - "\u0a59\3\2\2\2\u00e2\u0a64\3\2\2\2\u00e4\u0a66\3\2\2\2\u00e6\u0a76\3\2"+ - "\2\2\u00e8\u0a78\3\2\2\2\u00ea\u0a88\3\2\2\2\u00ec\u0aaa\3\2\2\2\u00ee"+ - "\u0ad9\3\2\2\2\u00f0\u0adb\3\2\2\2\u00f2\u0b18\3\2\2\2\u00f4\u0b1a\3\2"+ - "\2\2\u00f6\u0b3a\3\2\2\2\u00f8\u0b54\3\2\2\2\u00fa\u0b56\3\2\2\2\u00fc"+ - "\u0b93\3\2\2\2\u00fe\u0bba\3\2\2\2\u0100\u0c25\3\2\2\2\u0102\u0c2a\3\2"+ - "\2\2\u0104\u0c2c\3\2\2\2\u0106\u0c35\3\2\2\2\u0108\u0c3e\3\2\2\2\u010a"+ - "\u0c63\3\2\2\2\u010c\u0c86\3\2\2\2\u010e\u0c9f\3\2\2\2\u0110\u0ca2\3\2"+ - "\2\2\u0112\u0caf\3\2\2\2\u0114\u0cb1\3\2\2\2\u0116\u0cb3\3\2\2\2\u0118"+ - "\u0cb5\3\2\2\2\u011a\u0cb7\3\2\2\2\u011c\u0cb9\3\2\2\2\u011e\u0cbb\3\2"+ - "\2\2\u0120\u0cbd\3\2\2\2\u0122\u0cc4\3\2\2\2\u0124\u0cca\3\2\2\2\u0126"+ - "\u0ccc\3\2\2\2\u0128\u0cdd\3\2\2\2\u012a\u0cdf\3\2\2\2\u012c\u0ce4\3\2"+ - "\2\2\u012e\u0cea\3\2\2\2\u0130\u0cf6\3\2\2\2\u0132\u0cff\3\2\2\2\u0134"+ - "\u0d0b\3\2\2\2\u0136\u0d0d\3\2\2\2\u0138\u0d0f\3\2\2\2\u013a\u0d11\3\2"+ - "\2\2\u013c\u0d13\3\2\2\2\u013e\u0d16\3\2\2\2\u0140\u0d29\3\2\2\2\u0142"+ - "\u0d2b\3\2\2\2\u0144\u0d2d\3\2\2\2\u0146\u0d2f\3\2\2\2\u0148\u0d31\3\2"+ - "\2\2\u014a\u0d33\3\2\2\2\u014c\u0d35\3\2\2\2\u014e\u0d39\3\2\2\2\u0150"+ - "\u0d4a\3\2\2\2\u0152\u0d57\3\2\2\2\u0154\u0d61\3\2\2\2\u0156\u0d6d\3\2"+ - "\2\2\u0158\u0d6f\3\2\2\2\u015a\u0d71\3\2\2\2\u015c\u015e\5\6\4\2\u015d"+ - "\u015c\3\2\2\2\u015d\u015e\3\2\2\2\u015e\u0162\3\2\2\2\u015f\u0161\7\7"+ - "\2\2\u0160\u015f\3\2\2\2\u0161\u0164\3\2\2\2\u0162\u0160\3\2\2\2\u0162"+ - "\u0163\3\2\2\2\u0163\u0168\3\2\2\2\u0164\u0162\3\2\2\2\u0165\u0167\5\b"+ - "\5\2\u0166\u0165\3\2\2\2\u0167\u016a\3\2\2\2\u0168\u0166\3\2\2\2\u0168"+ - "\u0169\3\2\2\2\u0169\u016b\3\2\2\2\u016a\u0168\3\2\2\2\u016b\u016c\5\n"+ - "\6\2\u016c\u0170\5\f\7\2\u016d\u016f\5\22\n\2\u016e\u016d\3\2\2\2\u016f"+ - "\u0172\3\2\2\2\u0170\u016e\3\2\2\2\u0170\u0171\3\2\2\2\u0171\u0173\3\2"+ - "\2\2\u0172\u0170\3\2\2\2\u0173\u0174\7\2\2\3\u0174\3\3\2\2\2\u0175\u0177"+ - "\5\6\4\2\u0176\u0175\3\2\2\2\u0176\u0177\3\2\2\2\u0177\u017b\3\2\2\2\u0178"+ - "\u017a\7\7\2\2\u0179\u0178\3\2\2\2\u017a\u017d\3\2\2\2\u017b\u0179\3\2"+ - "\2\2\u017b\u017c\3\2\2\2\u017c\u0181\3\2\2\2\u017d\u017b\3\2\2\2\u017e"+ - "\u0180\5\b\5\2\u017f\u017e\3\2\2\2\u0180\u0183\3\2\2\2\u0181\u017f\3\2"+ - "\2\2\u0181\u0182\3\2\2\2\u0182\u0184\3\2\2\2\u0183\u0181\3\2\2\2\u0184"+ - "\u0185\5\n\6\2\u0185\u018b\5\f\7\2\u0186\u0187\5\u0082B\2\u0187\u0188"+ - "\5\u0094K\2\u0188\u018a\3\2\2\2\u0189\u0186\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\u018f\7\2\2\3\u018f\5\3\2\2\2\u0190\u0192\7\3\2\2\u0191"+ - "\u0193\7\7\2\2\u0192\u0191\3\2\2\2\u0193\u0194\3\2\2\2\u0194\u0192\3\2"+ - "\2\2\u0194\u0195\3\2\2\2\u0195\7\3\2\2\2\u0196\u0197\t\2\2\2\u0197\u019b"+ - "\7?\2\2\u0198\u019a\7\7\2\2\u0199\u0198\3\2\2\2\u019a\u019d\3\2\2\2\u019b"+ - "\u0199\3\2\2\2\u019b\u019c\3\2\2\2\u019c\u019e\3\2\2\2\u019d\u019b\3\2"+ - "\2\2\u019e\u01a2\7\34\2\2\u019f\u01a1\7\7\2\2\u01a0\u019f\3\2\2\2\u01a1"+ - "\u01a4\3\2\2\2\u01a2\u01a0\3\2\2\2\u01a2\u01a3\3\2\2\2\u01a3\u01ae\3\2"+ - "\2\2\u01a4\u01a2\3\2\2\2\u01a5\u01a7\7\r\2\2\u01a6\u01a8\5\u0156\u00ac"+ - "\2\u01a7\u01a6\3\2\2\2\u01a8\u01a9\3\2\2\2\u01a9\u01a7\3\2\2\2\u01a9\u01aa"+ - "\3\2\2\2\u01aa\u01ab\3\2\2\2\u01ab\u01ac\7\16\2\2\u01ac\u01af\3\2\2\2"+ - "\u01ad\u01af\5\u0156\u00ac\2\u01ae\u01a5\3\2\2\2\u01ae\u01ad\3\2\2\2\u01af"+ - "\u01b3\3\2\2\2\u01b0\u01b2\7\7\2\2\u01b1\u01b0\3\2\2\2\u01b2\u01b5\3\2"+ - "\2\2\u01b3\u01b1\3\2\2\2\u01b3\u01b4\3\2\2\2\u01b4\t\3\2\2\2\u01b5\u01b3"+ - "\3\2\2\2\u01b6\u01b7\7H\2\2\u01b7\u01b9\5\u015a\u00ae\2\u01b8\u01ba\5"+ - "\u0094K\2\u01b9\u01b8\3\2\2\2\u01b9\u01ba\3\2\2\2\u01ba\u01bc\3\2\2\2"+ - "\u01bb\u01b6\3\2\2\2\u01bb\u01bc\3\2\2\2\u01bc\13\3\2\2\2\u01bd\u01bf"+ - "\5\16\b\2\u01be\u01bd\3\2\2\2\u01bf\u01c2\3\2\2\2\u01c0\u01be\3\2\2\2"+ - "\u01c0\u01c1\3\2\2\2\u01c1\r\3\2\2\2\u01c2\u01c0\3\2\2\2\u01c3\u01c4\7"+ - "I\2\2\u01c4\u01c8\5\u015a\u00ae\2\u01c5\u01c6\7\t\2\2\u01c6\u01c9\7\21"+ - "\2\2\u01c7\u01c9\5\20\t\2\u01c8\u01c5\3\2\2\2\u01c8\u01c7\3\2\2\2\u01c8"+ - "\u01c9\3\2\2\2\u01c9\u01cb\3\2\2\2\u01ca\u01cc\5\u0094K\2\u01cb\u01ca"+ - "\3\2\2\2\u01cb\u01cc\3\2\2\2\u01cc\17\3\2\2\2\u01cd\u01ce\7f\2\2\u01ce"+ - "\u01cf\5\u0158\u00ad\2\u01cf\21\3\2\2\2\u01d0\u01d2\5\26\f\2\u01d1\u01d3"+ - "\5\u0096L\2\u01d2\u01d1\3\2\2\2\u01d2\u01d3\3\2\2\2\u01d3\23\3\2\2\2\u01d4"+ - "\u01d6\5\u012c\u0097\2\u01d5\u01d4\3\2\2\2\u01d5\u01d6\3\2\2\2\u01d6\u01d7"+ - "\3\2\2\2\u01d7\u01db\7P\2\2\u01d8\u01da\7\7\2\2\u01d9\u01d8\3\2\2\2\u01da"+ - "\u01dd\3\2\2\2\u01db\u01d9\3\2\2\2\u01db\u01dc\3\2\2\2\u01dc\u01de\3\2"+ - "\2\2\u01dd\u01db\3\2\2\2\u01de\u01e6\5\u0158\u00ad\2\u01df\u01e1\7\7\2"+ - "\2\u01e0\u01df\3\2\2\2\u01e1\u01e4\3\2\2\2\u01e2\u01e0\3\2\2\2\u01e2\u01e3"+ - "\3\2\2\2\u01e3\u01e5\3\2\2\2\u01e4\u01e2\3\2\2\2\u01e5\u01e7\5,\27\2\u01e6"+ - "\u01e2\3\2\2\2\u01e6\u01e7\3\2\2\2\u01e7\u01eb\3\2\2\2\u01e8\u01ea\7\7"+ - "\2\2\u01e9\u01e8\3\2\2\2\u01ea\u01ed\3\2\2\2\u01eb\u01e9\3\2\2\2\u01eb"+ - "\u01ec\3\2\2\2\u01ec\u01ee\3\2\2\2\u01ed\u01eb\3\2\2\2\u01ee\u01f2\7\36"+ - "\2\2\u01ef\u01f1\7\7\2\2\u01f0\u01ef\3\2\2\2\u01f1\u01f4\3\2\2\2\u01f2"+ - "\u01f0\3\2\2\2\u01f2\u01f3\3\2\2\2\u01f3\u01f5\3\2\2\2\u01f4\u01f2\3\2"+ - "\2\2\u01f5\u01f6\5d\63\2\u01f6\25\3\2\2\2\u01f7\u01fd\5\30\r\2\u01f8\u01fd"+ - "\5X-\2\u01f9\u01fd\5@!\2\u01fa\u01fd\5H%\2\u01fb\u01fd\5\24\13\2\u01fc"+ - "\u01f7\3\2\2\2\u01fc\u01f8\3\2\2\2\u01fc\u01f9\3\2\2\2\u01fc\u01fa\3\2"+ - "\2\2\u01fc\u01fb\3\2\2\2\u01fd\27\3\2\2\2\u01fe\u0200\5\u012c\u0097\2"+ - "\u01ff\u01fe\3\2\2\2\u01ff\u0200\3\2\2\2\u0200\u020c\3\2\2\2\u0201\u020d"+ - "\7J\2\2\u0202\u0206\7L\2\2\u0203\u0205\7\7\2\2\u0204\u0203\3\2\2\2\u0205"+ - "\u0208\3\2\2\2\u0206\u0204\3\2\2\2\u0206\u0207\3\2\2\2\u0207\u020a\3\2"+ - "\2\2\u0208\u0206\3\2\2\2\u0209\u0202\3\2\2\2\u0209\u020a\3\2\2\2\u020a"+ - "\u020b\3\2\2\2\u020b\u020d\7K\2\2\u020c\u0201\3\2\2\2\u020c\u0209\3\2"+ - "\2\2\u020d\u0211\3\2\2\2\u020e\u0210\7\7\2\2\u020f\u020e\3\2\2\2\u0210"+ - "\u0213\3\2\2\2\u0211\u020f\3\2\2\2\u0211\u0212\3\2\2\2\u0212\u0214\3\2"+ - "\2\2\u0213\u0211\3\2\2\2\u0214\u021c\5\u0158\u00ad\2\u0215\u0217\7\7\2"+ - "\2\u0216\u0215\3\2\2\2\u0217\u021a\3\2\2\2\u0218\u0216\3\2\2\2\u0218\u0219"+ - "\3\2\2\2\u0219\u021b\3\2\2\2\u021a\u0218\3\2\2\2\u021b\u021d\5,\27\2\u021c"+ - "\u0218\3\2\2\2\u021c\u021d\3\2\2\2\u021d\u0225\3\2\2\2\u021e\u0220\7\7"+ - "\2\2\u021f\u021e\3\2\2\2\u0220\u0223\3\2\2\2\u0221\u021f\3\2\2\2\u0221"+ - "\u0222\3\2\2\2\u0222\u0224\3\2\2\2\u0223\u0221\3\2\2\2\u0224\u0226\5\32"+ - "\16\2\u0225\u0221\3\2\2\2\u0225\u0226\3\2\2\2\u0226\u0235\3\2\2\2\u0227"+ - "\u0229\7\7\2\2\u0228\u0227\3\2\2\2\u0229\u022c\3\2\2\2\u022a\u0228\3\2"+ - "\2\2\u022a\u022b\3\2\2\2\u022b\u022d\3\2\2\2\u022c\u022a\3\2\2\2\u022d"+ - "\u0231\7\34\2\2\u022e\u0230\7\7\2\2\u022f\u022e\3\2\2\2\u0230\u0233\3"+ - "\2\2\2\u0231\u022f\3\2\2\2\u0231\u0232\3\2\2\2\u0232\u0234\3\2\2\2\u0233"+ - "\u0231\3\2\2\2\u0234\u0236\5\"\22\2\u0235\u022a\3\2\2\2\u0235\u0236\3"+ - "\2\2\2\u0236\u023e\3\2\2\2\u0237\u0239\7\7\2\2\u0238\u0237\3\2\2\2\u0239"+ - "\u023c\3\2\2\2\u023a\u0238\3\2\2\2\u023a\u023b\3\2\2\2\u023b\u023d\3\2"+ - "\2\2\u023c\u023a\3\2\2\2\u023d\u023f\5\60\31\2\u023e\u023a\3\2\2\2\u023e"+ - "\u023f\3\2\2\2\u023f\u024e\3\2\2\2\u0240\u0242\7\7\2\2\u0241\u0240\3\2"+ - "\2\2\u0242\u0245\3\2\2\2\u0243\u0241\3\2\2\2\u0243\u0244\3\2\2\2\u0244"+ - "\u0246\3\2\2\2\u0245\u0243\3\2\2\2\u0246\u024f\5\34\17\2\u0247\u0249\7"+ - "\7\2\2\u0248\u0247\3\2\2\2\u0249\u024c\3\2\2\2\u024a\u0248\3\2\2\2\u024a"+ - "\u024b\3\2\2\2\u024b\u024d\3\2\2\2\u024c\u024a\3\2\2\2\u024d\u024f\5^"+ - "\60\2\u024e\u0243\3\2\2\2\u024e\u024a\3\2\2\2\u024e\u024f\3\2\2\2\u024f"+ - "\31\3\2\2\2\u0250\u0252\5\u012c\u0097\2\u0251\u0250\3\2\2\2\u0251\u0252"+ - "\3\2\2\2\u0252\u0253\3\2\2\2\u0253\u0257\7Q\2\2\u0254\u0256\7\7\2\2\u0255"+ - "\u0254\3\2\2\2\u0256\u0259\3\2\2\2\u0257\u0255\3\2\2\2\u0257\u0258\3\2"+ - "\2\2\u0258\u025b\3\2\2\2\u0259\u0257\3\2\2\2\u025a\u0251\3\2\2\2\u025a"+ - "\u025b\3\2\2\2\u025b\u025c\3\2\2\2\u025c\u025d\5\36\20\2\u025d\33\3\2"+ - "\2\2\u025e\u0262\7\17\2\2\u025f\u0261\7\7\2\2\u0260\u025f\3\2\2\2\u0261"+ - "\u0264\3\2\2\2\u0262\u0260\3\2\2\2\u0262\u0263\3\2\2\2\u0263\u0265\3\2"+ - "\2\2\u0264\u0262\3\2\2\2\u0265\u0269\5\64\33\2\u0266\u0268\7\7\2\2\u0267"+ - "\u0266\3\2\2\2\u0268\u026b\3\2\2\2\u0269\u0267\3\2\2\2\u0269\u026a\3\2"+ - "\2\2\u026a\u026c\3\2\2\2\u026b\u0269\3\2\2\2\u026c\u026d\7\20\2\2\u026d"+ - "\35\3\2\2\2\u026e\u0272\7\13\2\2\u026f\u0271\7\7\2\2\u0270\u026f\3\2\2"+ - "\2\u0271\u0274\3\2\2\2\u0272\u0270\3\2\2\2\u0272\u0273\3\2\2\2\u0273\u0292"+ - "\3\2\2\2\u0274\u0272\3\2\2\2\u0275\u0286\5 \21\2\u0276\u0278\7\7\2\2\u0277"+ - "\u0276\3\2\2\2\u0278\u027b\3\2\2\2\u0279\u0277\3\2\2\2\u0279\u027a\3\2"+ - "\2\2\u027a\u027c\3\2\2\2\u027b\u0279\3\2\2\2\u027c\u0280\7\n\2\2\u027d"+ - "\u027f\7\7\2\2\u027e\u027d\3\2\2\2\u027f\u0282\3\2\2\2\u0280\u027e\3\2"+ - "\2\2\u0280\u0281\3\2\2\2\u0281\u0283\3\2\2\2\u0282\u0280\3\2\2\2\u0283"+ - "\u0285\5 \21\2\u0284\u0279\3\2\2\2\u0285\u0288\3\2\2\2\u0286\u0284\3\2"+ - "\2\2\u0286\u0287\3\2\2\2\u0287\u0290\3\2\2\2\u0288\u0286\3\2\2\2\u0289"+ - "\u028b\7\7\2\2\u028a\u0289\3\2\2\2\u028b\u028e\3\2\2\2\u028c\u028a\3\2"+ - "\2\2\u028c\u028d\3\2\2\2\u028d\u028f\3\2\2\2\u028e\u028c\3\2\2\2\u028f"+ - "\u0291\7\n\2\2\u0290\u028c\3\2\2\2\u0290\u0291\3\2\2\2\u0291\u0293\3\2"+ - "\2\2\u0292\u0275\3\2\2\2\u0292\u0293\3\2\2\2\u0293\u0297\3\2\2\2\u0294"+ - "\u0296\7\7\2\2\u0295\u0294\3\2\2\2\u0296\u0299\3\2\2\2\u0297\u0295\3\2"+ - "\2\2\u0297\u0298\3\2\2\2\u0298\u029a\3\2\2\2\u0299\u0297\3\2\2\2\u029a"+ - "\u029b\7\f\2\2\u029b\37\3\2\2\2\u029c\u029e\5\u012c\u0097\2\u029d\u029c"+ - "\3\2\2\2\u029d\u029e\3\2\2\2\u029e\u02a0\3\2\2\2\u029f\u02a1\t\3\2\2\u02a0"+ - "\u029f\3\2\2\2\u02a0\u02a1\3\2\2\2\u02a1\u02a5\3\2\2\2\u02a2\u02a4\7\7"+ - "\2\2\u02a3\u02a2\3\2\2\2\u02a4\u02a7\3\2\2\2\u02a5\u02a3\3\2\2\2\u02a5"+ - "\u02a6\3\2\2\2\u02a6\u02a8\3\2\2\2\u02a7\u02a5\3\2\2\2\u02a8\u02a9\5\u0158"+ - "\u00ad\2\u02a9\u02ad\7\34\2\2\u02aa\u02ac\7\7\2\2\u02ab\u02aa\3\2\2\2"+ - "\u02ac\u02af\3\2\2\2\u02ad\u02ab\3\2\2\2\u02ad\u02ae\3\2\2\2\u02ae\u02b0"+ - "\3\2\2\2\u02af\u02ad\3\2\2\2\u02b0\u02bf\5d\63\2\u02b1\u02b3\7\7\2\2\u02b2"+ - "\u02b1\3\2\2\2\u02b3\u02b6\3\2\2\2\u02b4\u02b2\3\2\2\2\u02b4\u02b5\3\2"+ - "\2\2\u02b5\u02b7\3\2\2\2\u02b6\u02b4\3\2\2\2\u02b7\u02bb\7\36\2\2\u02b8"+ - "\u02ba\7\7\2\2\u02b9\u02b8\3\2\2\2\u02ba\u02bd\3\2\2\2\u02bb\u02b9\3\2"+ - "\2\2\u02bb\u02bc\3\2\2\2\u02bc\u02be\3\2\2\2\u02bd\u02bb\3\2\2\2\u02be"+ - "\u02c0\5\u0098M\2\u02bf\u02b4\3\2\2\2\u02bf\u02c0\3\2\2\2\u02c0!\3\2\2"+ - "\2\u02c1\u02d2\5(\25\2\u02c2\u02c4\7\7\2\2\u02c3\u02c2\3\2\2\2\u02c4\u02c7"+ - "\3\2\2\2\u02c5\u02c3\3\2\2\2\u02c5\u02c6\3\2\2\2\u02c6\u02c8\3\2\2\2\u02c7"+ - "\u02c5\3\2\2\2\u02c8\u02cc\7\n\2\2\u02c9\u02cb\7\7\2\2\u02ca\u02c9\3\2"+ - "\2\2\u02cb\u02ce\3\2\2\2\u02cc\u02ca\3\2\2\2\u02cc\u02cd\3\2\2\2\u02cd"+ - "\u02cf\3\2\2\2\u02ce\u02cc\3\2\2\2\u02cf\u02d1\5(\25\2\u02d0\u02c5\3\2"+ - "\2\2\u02d1\u02d4\3\2\2\2\u02d2\u02d0\3\2\2\2\u02d2\u02d3\3\2\2\2\u02d3"+ - "#\3\2\2\2\u02d4\u02d2\3\2\2\2\u02d5\u02da\5&\24\2\u02d6\u02da\5*\26\2"+ - "\u02d7\u02da\5l\67\2\u02d8\u02da\5v<\2\u02d9\u02d5\3\2\2\2\u02d9\u02d6"+ - "\3\2\2\2\u02d9\u02d7\3\2\2\2\u02d9\u02d8\3\2\2\2\u02da%\3\2\2\2\u02db"+ - "\u02dc\5l\67\2\u02dc\u02dd\5\u00d0i\2\u02dd\'\3\2\2\2\u02de\u02e0\5\u014e"+ - "\u00a8\2\u02df\u02de\3\2\2\2\u02e0\u02e3\3\2\2\2\u02e1\u02df\3\2\2\2\u02e1"+ - "\u02e2\3\2\2\2\u02e2\u02e7\3\2\2\2\u02e3\u02e1\3\2\2\2\u02e4\u02e6\7\7"+ - "\2\2\u02e5\u02e4\3\2\2\2\u02e6\u02e9\3\2\2\2\u02e7\u02e5\3\2\2\2\u02e7"+ - "\u02e8\3\2\2\2\u02e8\u02ea\3\2\2\2\u02e9\u02e7\3\2\2\2\u02ea\u02eb\5$"+ - "\23\2\u02eb)\3\2\2\2\u02ec\u02ef\5l\67\2\u02ed\u02ef\5v<\2\u02ee\u02ec"+ - "\3\2\2\2\u02ee\u02ed\3\2\2\2\u02ef\u02f3\3\2\2\2\u02f0\u02f2\7\7\2\2\u02f1"+ - "\u02f0\3\2\2\2\u02f2\u02f5\3\2\2\2\u02f3\u02f1\3\2\2\2\u02f3\u02f4\3\2"+ - "\2\2\u02f4\u02f6\3\2\2\2\u02f5\u02f3\3\2\2\2\u02f6\u02fa\7R\2\2\u02f7"+ - "\u02f9\7\7\2\2\u02f8\u02f7\3\2\2\2\u02f9\u02fc\3\2\2\2\u02fa\u02f8\3\2"+ - "\2\2\u02fa\u02fb\3\2\2\2\u02fb\u02fd\3\2\2\2\u02fc\u02fa\3\2\2\2\u02fd"+ - "\u02fe\5\u0098M\2\u02fe+\3\2\2\2\u02ff\u0303\7\60\2\2\u0300\u0302\7\7"+ - "\2\2\u0301\u0300\3\2\2\2\u0302\u0305\3\2\2\2\u0303\u0301\3\2\2\2\u0303"+ - "\u0304\3\2\2\2\u0304\u0306\3\2\2\2\u0305\u0303\3\2\2\2\u0306\u0317\5."+ - "\30\2\u0307\u0309\7\7\2\2\u0308\u0307\3\2\2\2\u0309\u030c\3\2\2\2\u030a"+ - "\u0308\3\2\2\2\u030a\u030b\3\2\2\2\u030b\u030d\3\2\2\2\u030c\u030a\3\2"+ - "\2\2\u030d\u0311\7\n\2\2\u030e\u0310\7\7\2\2\u030f\u030e\3\2\2\2\u0310"+ - "\u0313\3\2\2\2\u0311\u030f\3\2\2\2\u0311\u0312\3\2\2\2\u0312\u0314\3\2"+ - "\2\2\u0313\u0311\3\2\2\2\u0314\u0316\5.\30\2\u0315\u030a\3\2\2\2\u0316"+ - "\u0319\3\2\2\2\u0317\u0315\3\2\2\2\u0317\u0318\3\2\2\2\u0318\u0321\3\2"+ - "\2\2\u0319\u0317\3\2\2\2\u031a\u031c\7\7\2\2\u031b\u031a\3\2\2\2\u031c"+ - "\u031f\3\2\2\2\u031d\u031b\3\2\2\2\u031d\u031e\3\2\2\2\u031e\u0320\3\2"+ - "\2\2\u031f\u031d\3\2\2\2\u0320\u0322\7\n\2\2\u0321\u031d\3\2\2\2\u0321"+ - "\u0322\3\2\2\2\u0322\u0326\3\2\2\2\u0323\u0325\7\7\2\2\u0324\u0323\3\2"+ - "\2\2\u0325\u0328\3\2\2\2\u0326\u0324\3\2\2\2\u0326\u0327\3\2\2\2\u0327"+ - "\u0329\3\2\2\2\u0328\u0326\3\2\2\2\u0329\u032a\7\61\2\2\u032a-\3\2\2\2"+ - "\u032b\u032d\5\u013e\u00a0\2\u032c\u032b\3\2\2\2\u032c\u032d\3\2\2\2\u032d"+ - "\u0331\3\2\2\2\u032e\u0330\7\7\2\2\u032f\u032e\3\2\2\2\u0330\u0333\3\2"+ - "\2\2\u0331\u032f\3\2\2\2\u0331\u0332\3\2\2\2\u0332\u0334\3\2\2\2\u0333"+ - "\u0331\3\2\2\2\u0334\u0343\5\u0158\u00ad\2\u0335\u0337\7\7\2\2\u0336\u0335"+ - "\3\2\2\2\u0337\u033a\3\2\2\2\u0338\u0336\3\2\2\2\u0338\u0339\3\2\2\2\u0339"+ - "\u033b\3\2\2\2\u033a\u0338\3\2\2\2\u033b\u033f\7\34\2\2\u033c\u033e\7"+ - "\7\2\2\u033d\u033c\3\2\2\2\u033e\u0341\3\2\2\2\u033f\u033d\3\2\2\2\u033f"+ - "\u0340\3\2\2\2\u0340\u0342\3\2\2\2\u0341\u033f\3\2\2\2\u0342\u0344\5d"+ - "\63\2\u0343\u0338\3\2\2\2\u0343\u0344\3\2\2\2\u0344/\3\2\2\2\u0345\u0349"+ - "\7X\2\2\u0346\u0348\7\7\2\2\u0347\u0346\3\2\2\2\u0348\u034b\3\2\2\2\u0349"+ - "\u0347\3\2\2\2\u0349\u034a\3\2\2\2\u034a\u034c\3\2\2\2\u034b\u0349\3\2"+ - "\2\2\u034c\u035d\5\62\32\2\u034d\u034f\7\7\2\2\u034e\u034d\3\2\2\2\u034f"+ - "\u0352\3\2\2\2\u0350\u034e\3\2\2\2\u0350\u0351\3\2\2\2\u0351\u0353\3\2"+ - "\2\2\u0352\u0350\3\2\2\2\u0353\u0357\7\n\2\2\u0354\u0356\7\7\2\2\u0355"+ - "\u0354\3\2\2\2\u0356\u0359\3\2\2\2\u0357\u0355\3\2\2\2\u0357\u0358\3\2"+ - "\2\2\u0358\u035a\3\2\2\2\u0359\u0357\3\2\2\2\u035a\u035c\5\62\32\2\u035b"+ - "\u0350\3\2\2\2\u035c\u035f\3\2\2\2\u035d\u035b\3\2\2\2\u035d\u035e\3\2"+ - "\2\2\u035e\61\3\2\2\2\u035f\u035d\3\2\2\2\u0360\u0362\5\u014e\u00a8\2"+ - "\u0361\u0360\3\2\2\2\u0362\u0365\3\2\2\2\u0363\u0361\3\2\2\2\u0363\u0364"+ - "\3\2\2\2\u0364\u0366\3\2\2\2\u0365\u0363\3\2\2\2\u0366\u036a\5\u0158\u00ad"+ - "\2\u0367\u0369\7\7\2\2\u0368\u0367\3\2\2\2\u0369\u036c\3\2\2\2\u036a\u0368"+ - "\3\2\2\2\u036a\u036b\3\2\2\2\u036b\u036d\3\2\2\2\u036c\u036a\3\2\2\2\u036d"+ - "\u0371\7\34\2\2\u036e\u0370\7\7\2\2\u036f\u036e\3\2\2\2\u0370\u0373\3"+ - "\2\2\2\u0371\u036f\3\2\2\2\u0371\u0372\3\2\2\2\u0372\u0374\3\2\2\2\u0373"+ - "\u0371\3\2\2\2\u0374\u0375\5d\63\2\u0375\63\3\2\2\2\u0376\u0378\5\66\34"+ - "\2\u0377\u0379\5\u0096L\2\u0378\u0377\3\2\2\2\u0378\u0379\3\2\2\2\u0379"+ - "\u037b\3\2\2\2\u037a\u0376\3\2\2\2\u037b\u037e\3\2\2\2\u037c\u037a\3\2"+ - "\2\2\u037c\u037d\3\2\2\2\u037d\65\3\2\2\2\u037e\u037c\3\2\2\2\u037f\u0384"+ - "\5\26\f\2\u0380\u0384\5:\36\2\u0381\u0384\58\35\2\u0382\u0384\5Z.\2\u0383"+ - "\u037f\3\2\2\2\u0383\u0380\3\2\2\2\u0383\u0381\3\2\2\2\u0383\u0382\3\2"+ - "\2\2\u0384\67\3\2\2\2\u0385\u0389\7T\2\2\u0386\u0388\7\7\2\2\u0387\u0386"+ - "\3\2\2\2\u0388\u038b\3\2\2\2\u0389\u0387\3\2\2\2\u0389\u038a\3\2\2\2\u038a"+ - "\u038c\3\2\2\2\u038b\u0389\3\2\2\2\u038c\u038d\5\u0088E\2\u038d9\3\2\2"+ - "\2\u038e\u0390\5\u012c\u0097\2\u038f\u038e\3\2\2\2\u038f\u0390\3\2\2\2"+ - "\u0390\u0391\3\2\2\2\u0391\u0395\7S\2\2\u0392\u0394\7\7\2\2\u0393\u0392"+ - "\3\2\2\2\u0394\u0397\3\2\2\2\u0395\u0393\3\2\2\2\u0395\u0396\3\2\2\2\u0396"+ - "\u0398\3\2\2\2\u0397\u0395\3\2\2\2\u0398\u03a0\7M\2\2\u0399\u039b\7\7"+ - "\2\2\u039a\u0399\3\2\2\2\u039b\u039e\3\2\2\2\u039c\u039a\3\2\2\2\u039c"+ - "\u039d\3\2\2\2\u039d\u039f\3\2\2\2\u039e\u039c\3\2\2\2\u039f\u03a1\5\u0158"+ - "\u00ad\2\u03a0\u039c\3\2\2\2\u03a0\u03a1\3\2\2\2\u03a1\u03b0\3\2\2\2\u03a2"+ - "\u03a4\7\7\2\2\u03a3\u03a2\3\2\2\2\u03a4\u03a7\3\2\2\2\u03a5\u03a3\3\2"+ - "\2\2\u03a5\u03a6\3\2\2\2\u03a6\u03a8\3\2\2\2\u03a7\u03a5\3\2\2\2\u03a8"+ - "\u03ac\7\34\2\2\u03a9\u03ab\7\7\2\2\u03aa\u03a9\3\2\2\2\u03ab\u03ae\3"+ - "\2\2\2\u03ac\u03aa\3\2\2\2\u03ac\u03ad\3\2\2\2\u03ad\u03af\3\2\2\2\u03ae"+ - "\u03ac\3\2\2\2\u03af\u03b1\5\"\22\2\u03b0\u03a5\3\2\2\2\u03b0\u03b1\3"+ - "\2\2\2\u03b1\u03b9\3\2\2\2\u03b2\u03b4\7\7\2\2\u03b3\u03b2\3\2\2\2\u03b4"+ - "\u03b7\3\2\2\2\u03b5\u03b3\3\2\2\2\u03b5\u03b6\3\2\2\2\u03b6\u03b8\3\2"+ - "\2\2\u03b7\u03b5\3\2\2\2\u03b8\u03ba\5\34\17\2\u03b9\u03b5\3\2\2\2\u03b9"+ - "\u03ba\3\2\2\2\u03ba;\3\2\2\2\u03bb\u03bf\7\13\2\2\u03bc\u03be\7\7\2\2"+ - "\u03bd\u03bc\3\2\2\2\u03be\u03c1\3\2\2\2\u03bf\u03bd\3\2\2\2\u03bf\u03c0"+ - "\3\2\2\2\u03c0\u03df\3\2\2\2\u03c1\u03bf\3\2\2\2\u03c2\u03d3\5> \2\u03c3"+ - "\u03c5\7\7\2\2\u03c4\u03c3\3\2\2\2\u03c5\u03c8\3\2\2\2\u03c6\u03c4\3\2"+ - "\2\2\u03c6\u03c7\3\2\2\2\u03c7\u03c9\3\2\2\2\u03c8\u03c6\3\2\2\2\u03c9"+ - "\u03cd\7\n\2\2\u03ca\u03cc\7\7\2\2\u03cb\u03ca\3\2\2\2\u03cc\u03cf\3\2"+ - "\2\2\u03cd\u03cb\3\2\2\2\u03cd\u03ce\3\2\2\2\u03ce\u03d0\3\2\2\2\u03cf"+ - "\u03cd\3\2\2\2\u03d0\u03d2\5> \2\u03d1\u03c6\3\2\2\2\u03d2\u03d5\3\2\2"+ - "\2\u03d3\u03d1\3\2\2\2\u03d3\u03d4\3\2\2\2\u03d4\u03dd\3\2\2\2\u03d5\u03d3"+ - "\3\2\2\2\u03d6\u03d8\7\7\2\2\u03d7\u03d6\3\2\2\2\u03d8\u03db\3\2\2\2\u03d9"+ - "\u03d7\3\2\2\2\u03d9\u03da\3\2\2\2\u03da\u03dc\3\2\2\2\u03db\u03d9\3\2"+ - "\2\2\u03dc\u03de\7\n\2\2\u03dd\u03d9\3\2\2\2\u03dd\u03de\3\2\2\2\u03de"+ - "\u03e0\3\2\2\2\u03df\u03c2\3\2\2\2\u03df\u03e0\3\2\2\2\u03e0\u03e4\3\2"+ - "\2\2\u03e1\u03e3\7\7\2\2\u03e2\u03e1\3\2\2\2\u03e3\u03e6\3\2\2\2\u03e4"+ - "\u03e2\3\2\2\2\u03e4\u03e5\3\2\2\2\u03e5\u03e7\3\2\2\2\u03e6\u03e4\3\2"+ - "\2\2\u03e7\u03e8\7\f\2\2\u03e8=\3\2\2\2\u03e9\u03eb\5\u012e\u0098\2\u03ea"+ - "\u03e9\3\2\2\2\u03ea\u03eb\3\2\2\2\u03eb\u03ec\3\2\2\2\u03ec\u03fb\5V"+ - ",\2\u03ed\u03ef\7\7\2\2\u03ee\u03ed\3\2\2\2\u03ef\u03f2\3\2\2\2\u03f0"+ - "\u03ee\3\2\2\2\u03f0\u03f1\3\2\2\2\u03f1\u03f3\3\2\2\2\u03f2\u03f0\3\2"+ - "\2\2\u03f3\u03f7\7\36\2\2\u03f4\u03f6\7\7\2\2\u03f5\u03f4\3\2\2\2\u03f6"+ - "\u03f9\3\2\2\2\u03f7\u03f5\3\2\2\2\u03f7\u03f8\3\2\2\2\u03f8\u03fa\3\2"+ - "\2\2\u03f9\u03f7\3\2\2\2\u03fa\u03fc\5\u0098M\2\u03fb\u03f0\3\2\2\2\u03fb"+ - "\u03fc\3\2\2\2\u03fc?\3\2\2\2\u03fd\u03ff\5\u012c\u0097\2\u03fe\u03fd"+ - "\3\2\2\2\u03fe\u03ff\3\2\2\2\u03ff\u0400\3\2\2\2\u0400\u0408\7L\2\2\u0401"+ - "\u0403\7\7\2\2\u0402\u0401\3\2\2\2\u0403\u0406\3\2\2\2\u0404\u0402\3\2"+ - "\2\2\u0404\u0405\3\2\2\2\u0405\u0407\3\2\2\2\u0406\u0404\3\2\2\2\u0407"+ - "\u0409\5,\27\2\u0408\u0404\3\2\2\2\u0408\u0409\3\2\2\2\u0409\u0419\3\2"+ - "\2\2\u040a\u040c\7\7\2\2\u040b\u040a\3\2\2\2\u040c\u040f\3\2\2\2\u040d"+ - "\u040b\3\2\2\2\u040d\u040e\3\2\2\2\u040e\u0410\3\2\2\2\u040f\u040d\3\2"+ - "\2\2\u0410\u0414\5|?\2\u0411\u0413\7\7\2\2\u0412\u0411\3\2\2\2\u0413\u0416"+ - "\3\2\2\2\u0414\u0412\3\2\2\2\u0414\u0415\3\2\2\2\u0415\u0417\3\2\2\2\u0416"+ - "\u0414\3\2\2\2\u0417\u0418\7\t\2\2\u0418\u041a\3\2\2\2\u0419\u040d\3\2"+ - "\2\2\u0419\u041a\3\2\2\2\u041a\u041e\3\2\2\2\u041b\u041d\7\7\2\2\u041c"+ - "\u041b\3\2\2\2\u041d\u0420\3\2\2\2\u041e\u041c\3\2\2\2\u041e\u041f\3\2"+ - "\2\2\u041f\u0421\3\2\2\2\u0420\u041e\3\2\2\2\u0421\u0425\5\u0158\u00ad"+ - "\2\u0422\u0424\7\7\2\2\u0423\u0422\3\2\2\2\u0424\u0427\3\2\2\2\u0425\u0423"+ - "\3\2\2\2\u0425\u0426\3\2\2\2\u0426\u0428\3\2\2\2\u0427\u0425\3\2\2\2\u0428"+ - "\u0437\5<\37\2\u0429\u042b\7\7\2\2\u042a\u0429\3\2\2\2\u042b\u042e\3\2"+ - "\2\2\u042c\u042a\3\2\2\2\u042c\u042d\3\2\2\2\u042d\u042f\3\2\2\2\u042e"+ - "\u042c\3\2\2\2\u042f\u0433\7\34\2\2\u0430\u0432\7\7\2\2\u0431\u0430\3"+ - "\2\2\2\u0432\u0435\3\2\2\2\u0433\u0431\3\2\2\2\u0433\u0434\3\2\2\2\u0434"+ - "\u0436\3\2\2\2\u0435\u0433\3\2\2\2\u0436\u0438\5d\63\2\u0437\u042c\3\2"+ - "\2\2\u0437\u0438\3\2\2\2\u0438\u0440\3\2\2\2\u0439\u043b\7\7\2\2\u043a"+ - "\u0439\3\2\2\2\u043b\u043e\3\2\2\2\u043c\u043a\3\2\2\2\u043c\u043d\3\2"+ - "\2\2\u043d\u043f\3\2\2\2\u043e\u043c\3\2\2\2\u043f\u0441\5\60\31\2\u0440"+ - "\u043c\3\2\2\2\u0440\u0441\3\2\2\2\u0441\u0449\3\2\2\2\u0442\u0444\7\7"+ - "\2\2\u0443\u0442\3\2\2\2\u0444\u0447\3\2\2\2\u0445\u0443\3\2\2\2\u0445"+ - "\u0446\3\2\2\2\u0446\u0448\3\2\2\2\u0447\u0445\3\2\2\2\u0448\u044a\5B"+ - "\"\2\u0449\u0445\3\2\2\2\u0449\u044a\3\2\2\2\u044aA\3\2\2\2\u044b\u0455"+ - "\5\u0088E\2\u044c\u0450\7\36\2\2\u044d\u044f\7\7\2\2\u044e\u044d\3\2\2"+ - "\2\u044f\u0452\3\2\2\2\u0450\u044e\3\2\2\2\u0450\u0451\3\2\2\2\u0451\u0453"+ - "\3\2\2\2\u0452\u0450\3\2\2\2\u0453\u0455\5\u0098M\2\u0454\u044b\3\2\2"+ - "\2\u0454\u044c\3\2\2\2\u0455C\3\2\2\2\u0456\u0458\5\u014e\u00a8\2\u0457"+ - "\u0456\3\2\2\2\u0458\u045b\3\2\2\2\u0459\u0457\3\2\2\2\u0459\u045a\3\2"+ - "\2\2\u045a\u045f\3\2\2\2\u045b\u0459\3\2\2\2\u045c\u045e\7\7\2\2\u045d"+ - "\u045c\3\2\2\2\u045e\u0461\3\2\2\2\u045f\u045d\3\2\2\2\u045f\u0460\3\2"+ - "\2\2\u0460\u0462\3\2\2\2\u0461\u045f\3\2\2\2\u0462\u0471\5\u0158\u00ad"+ - "\2\u0463\u0465\7\7\2\2\u0464\u0463\3\2\2\2\u0465\u0468\3\2\2\2\u0466\u0464"+ - "\3\2\2\2\u0466\u0467\3\2\2\2\u0467\u0469\3\2\2\2\u0468\u0466\3\2\2\2\u0469"+ - "\u046d\7\34\2\2\u046a\u046c\7\7\2\2\u046b\u046a\3\2\2\2\u046c\u046f\3"+ - "\2\2\2\u046d\u046b\3\2\2\2\u046d\u046e\3\2\2\2\u046e\u0470\3\2\2\2\u046f"+ - "\u046d\3\2\2\2\u0470\u0472\5d\63\2\u0471\u0466\3\2\2\2\u0471\u0472\3\2"+ - "\2\2\u0472E\3\2\2\2\u0473\u0477\7\13\2\2\u0474\u0476\7\7\2\2\u0475\u0474"+ - "\3\2\2\2\u0476\u0479\3\2\2\2\u0477\u0475\3\2\2\2\u0477\u0478\3\2\2\2\u0478"+ - "\u047a\3\2\2\2\u0479\u0477\3\2\2\2\u047a\u048b\5D#\2\u047b\u047d\7\7\2"+ - "\2\u047c\u047b\3\2\2\2\u047d\u0480\3\2\2\2\u047e\u047c\3\2\2\2\u047e\u047f"+ - "\3\2\2\2\u047f\u0481\3\2\2\2\u0480\u047e\3\2\2\2\u0481\u0485\7\n\2\2\u0482"+ - "\u0484\7\7\2\2\u0483\u0482\3\2\2\2\u0484\u0487\3\2\2\2\u0485\u0483\3\2"+ - "\2\2\u0485\u0486\3\2\2\2\u0486\u0488\3\2\2\2\u0487\u0485\3\2\2\2\u0488"+ - "\u048a\5D#\2\u0489\u047e\3\2\2\2\u048a\u048d\3\2\2\2\u048b\u0489\3\2\2"+ - "\2\u048b\u048c\3\2\2\2\u048c\u0495\3\2\2\2\u048d\u048b\3\2\2\2\u048e\u0490"+ - "\7\7\2\2\u048f\u048e\3\2\2\2\u0490\u0493\3\2\2\2\u0491\u048f\3\2\2\2\u0491"+ - "\u0492\3\2\2\2\u0492\u0494\3\2\2\2\u0493\u0491\3\2\2\2\u0494\u0496\7\n"+ - "\2\2\u0495\u0491\3\2\2\2\u0495\u0496\3\2\2\2\u0496\u049a\3\2\2\2\u0497"+ - "\u0499\7\7\2\2\u0498\u0497\3\2\2\2\u0499\u049c\3\2\2\2\u049a\u0498\3\2"+ - "\2\2\u049a\u049b\3\2\2\2\u049b\u049d\3\2\2\2\u049c\u049a\3\2\2\2\u049d"+ - "\u049e\7\f\2\2\u049eG\3\2\2\2\u049f\u04a1\5\u012c\u0097\2\u04a0\u049f"+ - "\3\2\2\2\u04a0\u04a1\3\2\2\2\u04a1\u04a2\3\2\2\2\u04a2\u04aa\t\3\2\2\u04a3"+ - "\u04a5\7\7\2\2\u04a4\u04a3\3\2\2\2\u04a5\u04a8\3\2\2\2\u04a6\u04a4\3\2"+ - "\2\2\u04a6\u04a7\3\2\2\2\u04a7\u04a9\3\2\2\2\u04a8\u04a6\3\2\2\2\u04a9"+ - "\u04ab\5,\27\2\u04aa\u04a6\3\2\2\2\u04aa\u04ab\3\2\2\2\u04ab\u04bb\3\2"+ - "\2\2\u04ac\u04ae\7\7\2\2\u04ad\u04ac\3\2\2\2\u04ae\u04b1\3\2\2\2\u04af"+ - "\u04ad\3\2\2\2\u04af\u04b0\3\2\2\2\u04b0\u04b2\3\2\2\2\u04b1\u04af\3\2"+ - "\2\2\u04b2\u04b6\5|?\2\u04b3\u04b5\7\7\2\2\u04b4\u04b3\3\2\2\2\u04b5\u04b8"+ - "\3\2\2\2\u04b6\u04b4\3\2\2\2\u04b6\u04b7\3\2\2\2\u04b7\u04b9\3\2\2\2\u04b8"+ - "\u04b6\3\2\2\2\u04b9\u04ba\7\t\2\2\u04ba\u04bc\3\2\2\2\u04bb\u04af\3\2"+ - "\2\2\u04bb\u04bc\3\2\2\2\u04bc\u04c0\3\2\2\2\u04bd\u04bf\7\7\2\2\u04be"+ - "\u04bd\3\2\2\2\u04bf\u04c2\3\2\2\2\u04c0\u04be\3\2\2\2\u04c0\u04c1\3\2"+ - "\2\2\u04c1\u04c5\3\2\2\2\u04c2\u04c0\3\2\2\2\u04c3\u04c6\5F$\2\u04c4\u04c6"+ - "\5D#\2\u04c5\u04c3\3\2\2\2\u04c5\u04c4\3\2\2\2\u04c6\u04ce\3\2\2\2\u04c7"+ - "\u04c9\7\7\2\2\u04c8\u04c7\3\2\2\2\u04c9\u04cc\3\2\2\2\u04ca\u04c8\3\2"+ - "\2\2\u04ca\u04cb\3\2\2\2\u04cb\u04cd\3\2\2\2\u04cc\u04ca\3\2\2\2\u04cd"+ - "\u04cf\5\60\31\2\u04ce\u04ca\3\2\2\2\u04ce\u04cf\3\2\2\2\u04cf\u04e1\3"+ - "\2\2\2\u04d0\u04d2\7\7\2\2\u04d1\u04d0\3\2\2\2\u04d2\u04d5\3\2\2\2\u04d3"+ - "\u04d1\3\2\2\2\u04d3\u04d4\3\2\2\2\u04d4\u04df\3\2\2\2\u04d5\u04d3\3\2"+ - "\2\2\u04d6\u04da\7\36\2\2\u04d7\u04d9\7\7\2\2\u04d8\u04d7\3\2\2\2\u04d9"+ - "\u04dc\3\2\2\2\u04da\u04d8\3\2\2\2\u04da\u04db\3\2\2\2\u04db\u04dd\3\2"+ - "\2\2\u04dc\u04da\3\2\2\2\u04dd\u04e0\5\u0098M\2\u04de\u04e0\5J&\2\u04df"+ - "\u04d6\3\2\2\2\u04df\u04de\3\2\2\2\u04e0\u04e2\3\2\2\2\u04e1\u04d3\3\2"+ - "\2\2\u04e1\u04e2\3\2\2\2\u04e2\u04e9\3\2\2\2\u04e3\u04e5\7\7\2\2\u04e4"+ - "\u04e3\3\2\2\2\u04e5\u04e6\3\2\2\2\u04e6\u04e4\3\2\2\2\u04e6\u04e7\3\2"+ - "\2\2\u04e7\u04e8\3\2\2\2\u04e8\u04ea\7\35\2\2\u04e9\u04e4\3\2\2\2\u04e9"+ - "\u04ea\3\2\2\2\u04ea\u04ee\3\2\2\2\u04eb\u04ed\7\7\2\2\u04ec\u04eb\3\2"+ - "\2\2\u04ed\u04f0\3\2\2\2\u04ee\u04ec\3\2\2\2\u04ee\u04ef\3\2\2\2\u04ef"+ - "\u050f\3\2\2\2\u04f0\u04ee\3\2\2\2\u04f1\u04f3\5L\'\2\u04f2\u04f1\3\2"+ - "\2\2\u04f2\u04f3\3\2\2\2\u04f3\u04fe\3\2\2\2\u04f4\u04f6\7\7\2\2\u04f5"+ - "\u04f4\3\2\2\2\u04f6\u04f9\3\2\2\2\u04f7\u04f5\3\2\2\2\u04f7\u04f8\3\2"+ - "\2\2\u04f8\u04fb\3\2\2\2\u04f9\u04f7\3\2\2\2\u04fa\u04fc\5\u0094K\2\u04fb"+ - "\u04fa\3\2\2\2\u04fb\u04fc\3\2\2\2\u04fc\u04fd\3\2\2\2\u04fd\u04ff\5N"+ - "(\2\u04fe\u04f7\3\2\2\2\u04fe\u04ff\3\2\2\2\u04ff\u0510\3\2\2\2\u0500"+ - "\u0502\5N(\2\u0501\u0500\3\2\2\2\u0501\u0502\3\2\2\2\u0502\u050d\3\2\2"+ - "\2\u0503\u0505\7\7\2\2\u0504\u0503\3\2\2\2\u0505\u0508\3\2\2\2\u0506\u0504"+ - "\3\2\2\2\u0506\u0507\3\2\2\2\u0507\u050a\3\2\2\2\u0508\u0506\3\2\2\2\u0509"+ - "\u050b\5\u0094K\2\u050a\u0509\3\2\2\2\u050a\u050b\3\2\2\2\u050b\u050c"+ - "\3\2\2\2\u050c\u050e\5L\'\2\u050d\u0506\3\2\2\2\u050d\u050e\3\2\2\2\u050e"+ - "\u0510\3\2\2\2\u050f\u04f2\3\2\2\2\u050f\u0501\3\2\2\2\u0510I\3\2\2\2"+ - "\u0511\u0515\7R\2\2\u0512\u0514\7\7\2\2\u0513\u0512\3\2\2\2\u0514\u0517"+ - "\3\2\2\2\u0515\u0513\3\2\2\2\u0515\u0516\3\2\2\2\u0516\u0518\3\2\2\2\u0517"+ - "\u0515\3\2\2\2\u0518\u0519\5\u0098M\2\u0519K\3\2\2\2\u051a\u051c\5\u012c"+ - "\u0097\2\u051b\u051a\3\2\2\2\u051b\u051c\3\2\2\2\u051c\u051d\3\2\2\2\u051d"+ - "\u0543\7B\2\2\u051e\u0520\7\7\2\2\u051f\u051e\3\2\2\2\u0520\u0523\3\2"+ - "\2\2\u0521\u051f\3\2\2\2\u0521\u0522\3\2\2\2\u0522\u0524\3\2\2\2\u0523"+ - "\u0521\3\2\2\2\u0524\u0528\7\13\2\2\u0525\u0527\7\7\2\2\u0526\u0525\3"+ - "\2\2\2\u0527\u052a\3\2\2\2\u0528\u0526\3\2\2\2\u0528\u0529\3\2\2\2\u0529"+ - "\u052b\3\2\2\2\u052a\u0528\3\2\2\2\u052b\u053a\7\f\2\2\u052c\u052e\7\7"+ - "\2\2\u052d\u052c\3\2\2\2\u052e\u0531\3\2\2\2\u052f\u052d\3\2\2\2\u052f"+ - "\u0530\3\2\2\2\u0530\u0532\3\2\2\2\u0531\u052f\3\2\2\2\u0532\u0536\7\34"+ - "\2\2\u0533\u0535\7\7\2\2\u0534\u0533\3\2\2\2\u0535\u0538\3\2\2\2\u0536"+ - "\u0534\3\2\2\2\u0536\u0537\3\2\2\2\u0537\u0539\3\2\2\2\u0538\u0536\3\2"+ - "\2\2\u0539\u053b\5d\63\2\u053a\u052f\3\2\2\2\u053a\u053b\3\2\2\2\u053b"+ - "\u053f\3\2\2\2\u053c\u053e\7\7\2\2\u053d\u053c\3\2\2\2\u053e\u0541\3\2"+ - "\2\2\u053f\u053d\3\2\2\2\u053f\u0540\3\2\2\2\u0540\u0542\3\2\2\2\u0541"+ - "\u053f\3\2\2\2\u0542\u0544\5B\"\2\u0543\u0521\3\2\2\2\u0543\u0544\3\2"+ - "\2\2\u0544M\3\2\2\2\u0545\u0547\5\u012c\u0097\2\u0546\u0545\3\2\2\2\u0546"+ - "\u0547\3\2\2\2\u0547\u0548\3\2\2\2\u0548\u057f\7C\2\2\u0549\u054b\7\7"+ - "\2\2\u054a\u0549\3\2\2\2\u054b\u054e\3\2\2\2\u054c\u054a\3\2\2\2\u054c"+ - "\u054d\3\2\2\2\u054d\u054f\3\2\2\2\u054e\u054c\3\2\2\2\u054f\u0553\7\13"+ - "\2\2\u0550\u0552\7\7\2\2\u0551\u0550\3\2\2\2\u0552\u0555\3\2\2\2\u0553"+ - "\u0551\3\2\2\2\u0553\u0554\3\2\2\2\u0554\u0556\3\2\2\2\u0555\u0553\3\2"+ - "\2\2\u0556\u055e\5R*\2\u0557\u0559\7\7\2\2\u0558\u0557\3\2\2\2\u0559\u055c"+ - "\3\2\2\2\u055a\u0558\3\2\2\2\u055a\u055b\3\2\2\2\u055b\u055d\3\2\2\2\u055c"+ - "\u055a\3\2\2\2\u055d\u055f\7\n\2\2\u055e\u055a\3\2\2\2\u055e\u055f\3\2"+ - "\2\2\u055f\u0563\3\2\2\2\u0560\u0562\7\7\2\2\u0561\u0560\3\2\2\2\u0562"+ - "\u0565\3\2\2\2\u0563\u0561\3\2\2\2\u0563\u0564\3\2\2\2\u0564\u0566\3\2"+ - "\2\2\u0565\u0563\3\2\2\2\u0566\u0575\7\f\2\2\u0567\u0569\7\7\2\2\u0568"+ - "\u0567\3\2\2\2\u0569\u056c\3\2\2\2\u056a\u0568\3\2\2\2\u056a\u056b\3\2"+ - "\2\2\u056b\u056d\3\2\2\2\u056c\u056a\3\2\2\2\u056d\u0571\7\34\2\2\u056e"+ - "\u0570\7\7\2\2\u056f\u056e\3\2\2\2\u0570\u0573\3\2\2\2\u0571\u056f\3\2"+ - "\2\2\u0571\u0572\3\2\2\2\u0572\u0574\3\2\2\2\u0573\u0571\3\2\2\2\u0574"+ - "\u0576\5d\63\2\u0575\u056a\3\2\2\2\u0575\u0576\3\2\2\2\u0576\u057a\3\2"+ - "\2\2\u0577\u0579\7\7\2\2\u0578\u0577\3\2\2\2\u0579\u057c\3\2\2\2\u057a"+ - "\u0578\3\2\2\2\u057a\u057b\3\2\2\2\u057b\u057d\3\2\2\2\u057c\u057a\3\2"+ - "\2\2\u057d\u057e\5B\"\2\u057e\u0580\3\2\2\2\u057f\u054c\3\2\2\2\u057f"+ - "\u0580\3\2\2\2\u0580O\3\2\2\2\u0581\u0585\7\13\2\2\u0582\u0584\7\7\2\2"+ - "\u0583\u0582\3\2\2\2\u0584\u0587\3\2\2\2\u0585\u0583\3\2\2\2\u0585\u0586"+ - "\3\2\2\2\u0586\u05a5\3\2\2\2\u0587\u0585\3\2\2\2\u0588\u0599\5R*\2\u0589"+ - "\u058b\7\7\2\2\u058a\u0589\3\2\2\2\u058b\u058e\3\2\2\2\u058c\u058a\3\2"+ - "\2\2\u058c\u058d\3\2\2\2\u058d\u058f\3\2\2\2\u058e\u058c\3\2\2\2\u058f"+ - "\u0593\7\n\2\2\u0590\u0592\7\7\2\2\u0591\u0590\3\2\2\2\u0592\u0595\3\2"+ - "\2\2\u0593\u0591\3\2\2\2\u0593\u0594\3\2\2\2\u0594\u0596\3\2\2\2\u0595"+ - "\u0593\3\2\2\2\u0596\u0598\5R*\2\u0597\u058c\3\2\2\2\u0598\u059b\3\2\2"+ - "\2\u0599\u0597\3\2\2\2\u0599\u059a\3\2\2\2\u059a\u05a3\3\2\2\2\u059b\u0599"+ - "\3\2\2\2\u059c\u059e\7\7\2\2\u059d\u059c\3\2\2\2\u059e\u05a1\3\2\2\2\u059f"+ - "\u059d\3\2\2\2\u059f\u05a0\3\2\2\2\u05a0\u05a2\3\2\2\2\u05a1\u059f\3\2"+ - "\2\2\u05a2\u05a4\7\n\2\2\u05a3\u059f\3\2\2\2\u05a3\u05a4\3\2\2\2\u05a4"+ - "\u05a6\3\2\2\2\u05a5\u0588\3\2\2\2\u05a5\u05a6\3\2\2\2\u05a6\u05aa\3\2"+ - "\2\2\u05a7\u05a9\7\7\2\2\u05a8\u05a7\3\2\2\2\u05a9\u05ac\3\2\2\2\u05aa"+ - "\u05a8\3\2\2\2\u05aa\u05ab\3\2\2\2\u05ab\u05ad\3\2\2\2\u05ac\u05aa\3\2"+ - "\2\2\u05ad\u05ae\7\f\2\2\u05aeQ\3\2\2\2\u05af\u05b1\5\u012e\u0098\2\u05b0"+ - "\u05af\3\2\2\2\u05b0\u05b1\3\2\2\2\u05b1\u05b2\3\2\2\2\u05b2\u05c1\5T"+ - "+\2\u05b3\u05b5\7\7\2\2\u05b4\u05b3\3\2\2\2\u05b5\u05b8\3\2\2\2\u05b6"+ - "\u05b4\3\2\2\2\u05b6\u05b7\3\2\2\2\u05b7\u05b9\3\2\2\2\u05b8\u05b6\3\2"+ - "\2\2\u05b9\u05bd\7\36\2\2\u05ba\u05bc\7\7\2\2\u05bb\u05ba\3\2\2\2\u05bc"+ - "\u05bf\3\2\2\2\u05bd\u05bb\3\2\2\2\u05bd\u05be\3\2\2\2\u05be\u05c0\3\2"+ - "\2\2\u05bf\u05bd\3\2\2\2\u05c0\u05c2\5\u0098M\2\u05c1\u05b6\3\2\2\2\u05c1"+ - "\u05c2\3\2\2\2\u05c2S\3\2\2\2\u05c3\u05c7\5\u0158\u00ad\2\u05c4\u05c6"+ - "\7\7\2\2\u05c5\u05c4\3\2\2\2\u05c6\u05c9\3\2\2\2\u05c7\u05c5\3\2\2\2\u05c7"+ - "\u05c8\3\2\2\2\u05c8\u05d2\3\2\2\2\u05c9\u05c7\3\2\2\2\u05ca\u05ce\7\34"+ - "\2\2\u05cb\u05cd\7\7\2\2\u05cc\u05cb\3\2\2\2\u05cd\u05d0\3\2\2\2\u05ce"+ - "\u05cc\3\2\2\2\u05ce\u05cf\3\2\2\2\u05cf\u05d1\3\2\2\2\u05d0\u05ce\3\2"+ - "\2\2\u05d1\u05d3\5d\63\2\u05d2\u05ca\3\2\2\2\u05d2\u05d3\3\2\2\2\u05d3"+ - "U\3\2\2\2\u05d4\u05d8\5\u0158\u00ad\2\u05d5\u05d7\7\7\2\2\u05d6\u05d5"+ - "\3\2\2\2\u05d7\u05da\3\2\2\2\u05d8\u05d6\3\2\2\2\u05d8\u05d9\3\2\2\2\u05d9"+ - "\u05db\3\2\2\2\u05da\u05d8\3\2\2\2\u05db\u05df\7\34\2\2\u05dc\u05de\7"+ - "\7\2\2\u05dd\u05dc\3\2\2\2\u05de\u05e1\3\2\2\2\u05df\u05dd\3\2\2\2\u05df"+ - "\u05e0\3\2\2\2\u05e0\u05e2\3\2\2\2\u05e1\u05df\3\2\2\2\u05e2\u05e3\5d"+ - "\63\2\u05e3W\3\2\2\2\u05e4\u05e6\5\u012c\u0097\2\u05e5\u05e4\3\2\2\2\u05e5"+ - "\u05e6\3\2\2\2\u05e6\u05e7\3\2\2\2\u05e7\u05eb\7M\2\2\u05e8\u05ea\7\7"+ - "\2\2\u05e9\u05e8\3\2\2\2\u05ea\u05ed\3\2\2\2\u05eb\u05e9\3\2\2\2\u05eb"+ - "\u05ec\3\2\2\2\u05ec\u05ee\3\2\2\2\u05ed\u05eb\3\2\2\2\u05ee\u05fd\5\u0158"+ - "\u00ad\2\u05ef\u05f1\7\7\2\2\u05f0\u05ef\3\2\2\2\u05f1\u05f4\3\2\2\2\u05f2"+ - "\u05f0\3\2\2\2\u05f2\u05f3\3\2\2\2\u05f3\u05f5\3\2\2\2\u05f4\u05f2\3\2"+ - "\2\2\u05f5\u05f9\7\34\2\2\u05f6\u05f8\7\7\2\2\u05f7\u05f6\3\2\2\2\u05f8"+ - "\u05fb\3\2\2\2\u05f9\u05f7\3\2\2\2\u05f9\u05fa\3\2\2\2\u05fa\u05fc\3\2"+ - "\2\2\u05fb\u05f9\3\2\2\2\u05fc\u05fe\5\"\22\2\u05fd\u05f2\3\2\2\2\u05fd"+ - "\u05fe\3\2\2\2\u05fe\u0606\3\2\2\2\u05ff\u0601\7\7\2\2\u0600\u05ff\3\2"+ - "\2\2\u0601\u0604\3\2\2\2\u0602\u0600\3\2\2\2\u0602\u0603\3\2\2\2\u0603"+ - "\u0605\3\2\2\2\u0604\u0602\3\2\2\2\u0605\u0607\5\34\17\2\u0606\u0602\3"+ - "\2\2\2\u0606\u0607\3\2\2\2\u0607Y\3\2\2\2\u0608\u060a\5\u012c\u0097\2"+ - "\u0609\u0608\3\2\2\2\u0609\u060a\3\2\2\2\u060a\u060b\3\2\2\2\u060b\u060f"+ - "\7Q\2\2\u060c\u060e\7\7\2\2\u060d\u060c\3\2\2\2\u060e\u0611\3\2\2\2\u060f"+ - "\u060d\3\2\2\2\u060f\u0610\3\2\2\2\u0610\u0612\3\2\2\2\u0611\u060f\3\2"+ - "\2\2\u0612\u0621\5<\37\2\u0613\u0615\7\7\2\2\u0614\u0613\3\2\2\2\u0615"+ - "\u0618\3\2\2\2\u0616\u0614\3\2\2\2\u0616\u0617\3\2\2\2\u0617\u0619\3\2"+ - "\2\2\u0618\u0616\3\2\2\2\u0619\u061d\7\34\2\2\u061a\u061c\7\7\2\2\u061b"+ - "\u061a\3\2\2\2\u061c\u061f\3\2\2\2\u061d\u061b\3\2\2\2\u061d\u061e\3\2"+ - "\2\2\u061e\u0620\3\2\2\2\u061f\u061d\3\2\2\2\u0620\u0622\5\\/\2\u0621"+ - "\u0616\3\2\2\2\u0621\u0622\3\2\2\2\u0622\u0626\3\2\2\2\u0623\u0625\7\7"+ - "\2\2\u0624\u0623\3\2\2\2\u0625\u0628\3\2\2\2\u0626\u0624\3\2\2\2\u0626"+ - "\u0627\3\2\2\2\u0627\u062a\3\2\2\2\u0628\u0626\3\2\2\2\u0629\u062b\5\u0088"+ - "E\2\u062a\u0629\3\2\2\2\u062a\u062b\3\2\2\2\u062b[\3\2\2\2\u062c\u0630"+ - "\t\4\2\2\u062d\u062f\7\7\2\2\u062e\u062d\3\2\2\2\u062f\u0632\3\2\2\2\u0630"+ - "\u062e\3\2\2\2\u0630\u0631\3\2\2\2\u0631\u0633\3\2\2\2\u0632\u0630\3\2"+ - "\2\2\u0633\u0634\5\u00d0i\2\u0634]\3\2\2\2\u0635\u0639\7\17\2\2\u0636"+ - "\u0638\7\7\2\2\u0637\u0636\3\2\2\2\u0638\u063b\3\2\2\2\u0639\u0637\3\2"+ - "\2\2\u0639\u063a\3\2\2\2\u063a\u063d\3\2\2\2\u063b\u0639\3\2\2\2\u063c"+ - "\u063e\5`\61\2\u063d\u063c\3\2\2\2\u063d\u063e\3\2\2\2\u063e\u064d\3\2"+ - "\2\2\u063f\u0641\7\7\2\2\u0640\u063f\3\2\2\2\u0641\u0644\3\2\2\2\u0642"+ - "\u0640\3\2\2\2\u0642\u0643\3\2\2\2\u0643\u0645\3\2\2\2\u0644\u0642\3\2"+ - "\2\2\u0645\u0649\7\35\2\2\u0646\u0648\7\7\2\2\u0647\u0646\3\2\2\2\u0648"+ - "\u064b\3\2\2\2\u0649\u0647\3\2\2\2\u0649\u064a\3\2\2\2\u064a\u064c\3\2"+ - "\2\2\u064b\u0649\3\2\2\2\u064c\u064e\5\64\33\2\u064d\u0642\3\2\2\2\u064d"+ - "\u064e\3\2\2\2\u064e\u0652\3\2\2\2\u064f\u0651\7\7\2\2\u0650\u064f\3\2"+ - "\2\2\u0651\u0654\3\2\2\2\u0652\u0650\3\2\2\2\u0652\u0653\3\2\2\2\u0653"+ - "\u0655\3\2\2\2\u0654\u0652\3\2\2\2\u0655\u0656\7\20\2\2\u0656_\3\2\2\2"+ - "\u0657\u0668\5b\62\2\u0658\u065a\7\7\2\2\u0659\u0658\3\2\2\2\u065a\u065d"+ - "\3\2\2\2\u065b\u0659\3\2\2\2\u065b\u065c\3\2\2\2\u065c\u065e\3\2\2\2\u065d"+ - "\u065b\3\2\2\2\u065e\u0662\7\n\2\2\u065f\u0661\7\7\2\2\u0660\u065f\3\2"+ - "\2\2\u0661\u0664\3\2\2\2\u0662\u0660\3\2\2\2\u0662\u0663\3\2\2\2\u0663"+ - "\u0665\3\2\2\2\u0664\u0662\3\2\2\2\u0665\u0667\5b\62\2\u0666\u065b\3\2"+ - "\2\2\u0667\u066a\3\2\2\2\u0668\u0666\3\2\2\2\u0668\u0669\3\2\2\2\u0669"+ - "\u066e\3\2\2\2\u066a\u0668\3\2\2\2\u066b\u066d\7\7\2\2\u066c\u066b\3\2"+ - "\2\2\u066d\u0670\3\2\2\2\u066e\u066c\3\2\2\2\u066e\u066f\3\2\2\2\u066f"+ - "\u0672\3\2\2\2\u0670\u066e\3\2\2\2\u0671\u0673\7\n\2\2\u0672\u0671\3\2"+ - "\2\2\u0672\u0673\3\2\2\2\u0673a\3\2\2\2\u0674\u0678\5\u012c\u0097\2\u0675"+ - "\u0677\7\7\2\2\u0676\u0675\3\2\2\2\u0677\u067a\3\2\2\2\u0678\u0676\3\2"+ - "\2\2\u0678\u0679\3\2\2\2\u0679\u067c\3\2\2\2\u067a\u0678\3\2\2\2\u067b"+ - "\u0674\3\2\2\2\u067b\u067c\3\2\2\2\u067c\u067d\3\2\2\2\u067d\u0685\5\u0158"+ - "\u00ad\2\u067e\u0680\7\7\2\2\u067f\u067e\3\2\2\2\u0680\u0683\3\2\2\2\u0681"+ - "\u067f\3\2\2\2\u0681\u0682\3\2\2\2\u0682\u0684\3\2\2\2\u0683\u0681\3\2"+ - "\2\2\u0684\u0686\5\u00d0i\2\u0685\u0681\3\2\2\2\u0685\u0686\3\2\2\2\u0686"+ - "\u068e\3\2\2\2\u0687\u0689\7\7\2\2\u0688\u0687\3\2\2\2\u0689\u068c\3\2"+ - "\2\2\u068a\u0688\3\2\2\2\u068a\u068b\3\2\2\2\u068b\u068d\3\2\2\2\u068c"+ - "\u068a\3\2\2\2\u068d\u068f\5\34\17\2\u068e\u068a\3\2\2\2\u068e\u068f\3"+ - "\2\2\2\u068fc\3\2\2\2\u0690\u0692\5\u0132\u009a\2\u0691\u0690\3\2\2\2"+ - "\u0691\u0692\3\2\2\2\u0692\u0697\3\2\2\2\u0693\u0698\5z>\2\u0694\u0698"+ - "\5h\65\2\u0695\u0698\5f\64\2\u0696\u0698\5v<\2\u0697\u0693\3\2\2\2\u0697"+ - "\u0694\3\2\2\2\u0697\u0695\3\2\2\2\u0697\u0696\3\2\2\2\u0698e\3\2\2\2"+ - "\u0699\u069c\5l\67\2\u069a\u069c\7l\2\2\u069b\u0699\3\2\2\2\u069b\u069a"+ - "\3\2\2\2\u069cg\3\2\2\2\u069d\u06a0\5f\64\2\u069e\u06a0\5z>\2\u069f\u069d"+ - "\3\2\2\2\u069f\u069e\3\2\2\2\u06a0\u06a4\3\2\2\2\u06a1\u06a3\7\7\2\2\u06a2"+ - "\u06a1\3\2\2\2\u06a3\u06a6\3\2\2\2\u06a4\u06a2\3\2\2\2\u06a4\u06a5\3\2"+ - "\2\2\u06a5\u06a8\3\2\2\2\u06a6\u06a4\3\2\2\2\u06a7\u06a9\5j\66\2\u06a8"+ - "\u06a7\3\2\2\2\u06a9\u06aa\3\2\2\2\u06aa\u06a8\3\2\2\2\u06aa\u06ab\3\2"+ - "\2\2\u06abi\3\2\2\2\u06ac\u06ad\t\5\2\2\u06adk\3\2\2\2\u06ae\u06bf\5n"+ - "8\2\u06af\u06b1\7\7\2\2\u06b0\u06af\3\2\2\2\u06b1\u06b4\3\2\2\2\u06b2"+ - "\u06b0\3\2\2\2\u06b2\u06b3\3\2\2\2\u06b3\u06b5\3\2\2\2\u06b4\u06b2\3\2"+ - "\2\2\u06b5\u06b9\7\t\2\2\u06b6\u06b8\7\7\2\2\u06b7\u06b6\3\2\2\2\u06b8"+ - "\u06bb\3\2\2\2\u06b9\u06b7\3\2\2\2\u06b9\u06ba\3\2\2\2\u06ba\u06bc\3\2"+ - "\2\2\u06bb\u06b9\3\2\2\2\u06bc\u06be\5n8\2\u06bd\u06b2\3\2\2\2\u06be\u06c1"+ - "\3\2\2\2\u06bf\u06bd\3\2\2\2\u06bf\u06c0\3\2\2\2\u06c0m\3\2\2\2\u06c1"+ - "\u06bf\3\2\2\2\u06c2\u06ca\5\u0158\u00ad\2\u06c3\u06c5\7\7\2\2\u06c4\u06c3"+ - "\3\2\2\2\u06c5\u06c8\3\2\2\2\u06c6\u06c4\3\2\2\2\u06c6\u06c7\3\2\2\2\u06c7"+ - "\u06c9\3\2\2\2\u06c8\u06c6\3\2\2\2\u06c9\u06cb\5\u00ceh\2\u06ca\u06c6"+ - "\3\2\2\2\u06ca\u06cb\3\2\2\2\u06cbo\3\2\2\2\u06cc\u06ce\5r:\2\u06cd\u06cc"+ - "\3\2\2\2\u06cd\u06ce\3\2\2\2\u06ce\u06cf\3\2\2\2\u06cf\u06d2\5d\63\2\u06d0"+ - "\u06d2\7\21\2\2\u06d1\u06cd\3\2\2\2\u06d1\u06d0\3\2\2\2\u06d2q\3\2\2\2"+ - "\u06d3\u06d5\5t;\2\u06d4\u06d3\3\2\2\2\u06d5\u06d6\3\2\2\2\u06d6\u06d4"+ - "\3\2\2\2\u06d6\u06d7\3\2\2\2\u06d7s\3\2\2\2\u06d8\u06dc\5\u013c\u009f"+ - "\2\u06d9\u06db\7\7\2\2\u06da\u06d9\3\2\2\2\u06db\u06de\3\2\2\2\u06dc\u06da"+ - "\3\2\2\2\u06dc\u06dd\3\2\2\2\u06dd\u06e1\3\2\2\2\u06de\u06dc\3\2\2\2\u06df"+ - "\u06e1\5\u014e\u00a8\2\u06e0\u06d8\3\2\2\2\u06e0\u06df\3\2\2\2\u06e1u"+ - "\3\2\2\2\u06e2\u06e6\5|?\2\u06e3\u06e5\7\7\2\2\u06e4\u06e3\3\2\2\2\u06e5"+ - "\u06e8\3\2\2\2\u06e6\u06e4\3\2\2\2\u06e6\u06e7\3\2\2\2\u06e7\u06e9\3\2"+ - "\2\2\u06e8\u06e6\3\2\2\2\u06e9\u06ed\7\t\2\2\u06ea\u06ec\7\7\2\2\u06eb"+ - "\u06ea\3\2\2\2\u06ec\u06ef\3\2\2\2\u06ed\u06eb\3\2\2\2\u06ed\u06ee\3\2"+ - "\2\2\u06ee\u06f1\3\2\2\2\u06ef\u06ed\3\2\2\2\u06f0\u06e2\3\2\2\2\u06f0"+ - "\u06f1\3\2\2\2\u06f1\u06f2\3\2\2\2\u06f2\u06f6\5x=\2\u06f3\u06f5\7\7\2"+ - "\2\u06f4\u06f3\3\2\2\2\u06f5\u06f8\3\2\2\2\u06f6\u06f4\3\2\2\2\u06f6\u06f7"+ - "\3\2\2\2\u06f7\u06f9\3\2\2\2\u06f8\u06f6\3\2\2\2\u06f9\u06fd\7$\2\2\u06fa"+ - "\u06fc\7\7\2\2\u06fb\u06fa\3\2\2\2\u06fc\u06ff\3\2\2\2\u06fd\u06fb\3\2"+ - "\2\2\u06fd\u06fe\3\2\2\2\u06fe\u0700\3\2\2\2\u06ff\u06fd\3\2\2\2\u0700"+ - "\u0701\5d\63\2\u0701w\3\2\2\2\u0702\u0706\7\13\2\2\u0703\u0705\7\7\2\2"+ - "\u0704\u0703\3\2\2\2\u0705\u0708\3\2\2\2\u0706\u0704\3\2\2\2\u0706\u0707"+ - "\3\2\2\2\u0707\u070b\3\2\2\2\u0708\u0706\3\2\2\2\u0709\u070c\5V,\2\u070a"+ - "\u070c\5d\63\2\u070b\u0709\3\2\2\2\u070b\u070a\3\2\2\2\u070b\u070c\3\2"+ - "\2\2\u070c\u0720\3\2\2\2\u070d\u070f\7\7\2\2\u070e\u070d\3\2\2\2\u070f"+ - "\u0712\3\2\2\2\u0710\u070e\3\2\2\2\u0710\u0711\3\2\2\2\u0711\u0713\3\2"+ - "\2\2\u0712\u0710\3\2\2\2\u0713\u0717\7\n\2\2\u0714\u0716\7\7\2\2\u0715"+ - "\u0714\3\2\2\2\u0716\u0719\3\2\2\2\u0717\u0715\3\2\2\2\u0717\u0718\3\2"+ - "\2\2\u0718\u071c\3\2\2\2\u0719\u0717\3\2\2\2\u071a\u071d\5V,\2\u071b\u071d"+ - "\5d\63\2\u071c\u071a\3\2\2\2\u071c\u071b\3\2\2\2\u071d\u071f\3\2\2\2\u071e"+ - "\u0710\3\2\2\2\u071f\u0722\3\2\2\2\u0720\u071e\3\2\2\2\u0720\u0721\3\2"+ - "\2\2\u0721\u072a\3\2\2\2\u0722\u0720\3\2\2\2\u0723\u0725\7\7\2\2\u0724"+ - "\u0723\3\2\2\2\u0725\u0728\3\2\2\2\u0726\u0724\3\2\2\2\u0726\u0727\3\2"+ - "\2\2\u0727\u0729\3\2\2\2\u0728\u0726\3\2\2\2\u0729\u072b\7\n\2\2\u072a"+ - "\u0726\3\2\2\2\u072a\u072b\3\2\2\2\u072b\u072f\3\2\2\2\u072c\u072e\7\7"+ - "\2\2\u072d\u072c\3\2\2\2\u072e\u0731\3\2\2\2\u072f\u072d\3\2\2\2\u072f"+ - "\u0730\3\2\2\2\u0730\u0732\3\2\2\2\u0731\u072f\3\2\2\2\u0732\u0733\7\f"+ - "\2\2\u0733y\3\2\2\2\u0734\u0738\7\13\2\2\u0735\u0737\7\7\2\2\u0736\u0735"+ - "\3\2\2\2\u0737\u073a\3\2\2\2\u0738\u0736\3\2\2\2\u0738\u0739\3\2\2\2\u0739"+ - "\u073b\3\2\2\2\u073a\u0738\3\2\2\2\u073b\u073f\5d\63\2\u073c\u073e\7\7"+ - "\2\2\u073d\u073c\3\2\2\2\u073e\u0741\3\2\2\2\u073f\u073d\3\2\2\2\u073f"+ - "\u0740\3\2\2\2\u0740\u0742\3\2\2\2\u0741\u073f\3\2\2\2\u0742\u0743\7\f"+ - "\2\2\u0743{\3\2\2\2\u0744\u0746\5\u0132\u009a\2\u0745\u0744\3\2\2\2\u0745"+ - "\u0746\3\2\2\2\u0746\u074a\3\2\2\2\u0747\u074b\5z>\2\u0748\u074b\5h\65"+ - "\2\u0749\u074b\5f\64\2\u074a\u0747\3\2\2\2\u074a\u0748\3\2\2\2\u074a\u0749"+ - "\3\2\2\2\u074b}\3\2\2\2\u074c\u0750\7\13\2\2\u074d\u074f\7\7\2\2\u074e"+ - "\u074d\3\2\2\2\u074f\u0752\3\2\2\2\u0750\u074e\3\2\2\2\u0750\u0751\3\2"+ - "\2\2\u0751\u0755\3\2\2\2\u0752\u0750\3\2\2\2\u0753\u0756\5l\67\2\u0754"+ - "\u0756\5~@\2\u0755\u0753\3\2\2\2\u0755\u0754\3\2\2\2\u0756\u075a\3\2\2"+ - "\2\u0757\u0759\7\7\2\2\u0758\u0757\3\2\2\2\u0759\u075c\3\2\2\2\u075a\u0758"+ - "\3\2\2\2\u075a\u075b\3\2\2\2\u075b\u075d\3\2\2\2\u075c\u075a\3\2\2\2\u075d"+ - "\u075e\7\f\2\2\u075e\177\3\2\2\2\u075f\u0765\5\u0082B\2\u0760\u0761\5"+ - "\u0096L\2\u0761\u0762\5\u0082B\2\u0762\u0764\3\2\2\2\u0763\u0760\3\2\2"+ - "\2\u0764\u0767\3\2\2\2\u0765\u0763\3\2\2\2\u0765\u0766\3\2\2\2\u0766\u0769"+ - "\3\2\2\2\u0767\u0765\3\2\2\2\u0768\u075f\3\2\2\2\u0768\u0769\3\2\2\2\u0769"+ - "\u076b\3\2\2\2\u076a\u076c\5\u0096L\2\u076b\u076a\3\2\2\2\u076b\u076c"+ - "\3\2\2\2\u076c\u0081\3\2\2\2\u076d\u0770\5\u0084C\2\u076e\u0770\5\u014e"+ - "\u00a8\2\u076f\u076d\3\2\2\2\u076f\u076e\3\2\2\2\u0770\u0773\3\2\2\2\u0771"+ - "\u076f\3\2\2\2\u0771\u0772\3\2\2\2\u0772\u0778\3\2\2\2\u0773\u0771\3\2"+ - "\2\2\u0774\u0779\5\26\f\2\u0775\u0779\5\u0092J\2\u0776\u0779\5\u008aF"+ - "\2\u0777\u0779\5\u0098M\2\u0778\u0774\3\2\2\2\u0778\u0775\3\2\2\2\u0778"+ - "\u0776\3\2\2\2\u0778\u0777\3\2\2\2\u0779\u0083\3\2\2\2\u077a\u077b\5\u0158"+ - "\u00ad\2\u077b\u077f\t\6\2\2\u077c\u077e\7\7\2\2\u077d\u077c\3\2\2\2\u077e"+ - "\u0781\3\2\2\2\u077f\u077d\3\2\2\2\u077f\u0780\3\2\2\2\u0780\u0085\3\2"+ - "\2\2\u0781\u077f\3\2\2\2\u0782\u0785\5\u0088E\2\u0783\u0785\5\u0082B\2"+ - "\u0784\u0782\3\2\2\2\u0784\u0783\3\2\2\2\u0785\u0087\3\2\2\2\u0786\u078a"+ - "\7\17\2\2\u0787\u0789\7\7\2\2\u0788\u0787\3\2\2\2\u0789\u078c\3\2\2\2"+ - "\u078a\u0788\3\2\2\2\u078a\u078b\3\2\2\2\u078b\u078d\3\2\2\2\u078c\u078a"+ - "\3\2\2\2\u078d\u0791\5\u0080A\2\u078e\u0790\7\7\2\2\u078f\u078e\3\2\2"+ - "\2\u0790\u0793\3\2\2\2\u0791\u078f\3\2\2\2\u0791\u0792\3\2\2\2\u0792\u0794"+ - "\3\2\2\2\u0793\u0791\3\2\2\2\u0794\u0795\7\20\2\2\u0795\u0089\3\2\2\2"+ - "\u0796\u079a\5\u008cG\2\u0797\u079a\5\u008eH\2\u0798\u079a\5\u0090I\2"+ - "\u0799\u0796\3\2\2\2\u0799\u0797\3\2\2\2\u0799\u0798\3\2\2\2\u079a\u008b"+ - "\3\2\2\2\u079b\u079f\7_\2\2\u079c\u079e\7\7\2\2\u079d\u079c\3\2\2\2\u079e"+ - "\u07a1\3\2\2\2\u079f\u079d\3\2\2\2\u079f\u07a0\3\2\2\2\u07a0\u07a2\3\2"+ - "\2\2\u07a1\u079f\3\2\2\2\u07a2\u07a6\7\13\2\2\u07a3\u07a5\5\u014e\u00a8"+ - "\2\u07a4\u07a3\3\2\2\2\u07a5\u07a8\3\2\2\2\u07a6\u07a4\3\2\2\2\u07a6\u07a7"+ - "\3\2\2\2\u07a7\u07ab\3\2\2\2\u07a8\u07a6\3\2\2\2\u07a9\u07ac\5D#\2\u07aa"+ - "\u07ac\5F$\2\u07ab\u07a9\3\2\2\2\u07ab\u07aa\3\2\2\2\u07ac\u07ad\3\2\2"+ - "\2\u07ad\u07ae\7h\2\2\u07ae\u07af\5\u0098M\2\u07af\u07b3\7\f\2\2\u07b0"+ - "\u07b2\7\7\2\2\u07b1\u07b0\3\2\2\2\u07b2\u07b5\3\2\2\2\u07b3\u07b1\3\2"+ - "\2\2\u07b3\u07b4\3\2\2\2\u07b4\u07b7\3\2\2\2\u07b5\u07b3\3\2\2\2\u07b6"+ - "\u07b8\5\u0086D\2\u07b7\u07b6\3\2\2\2\u07b7\u07b8\3\2\2\2\u07b8\u008d"+ - "\3\2\2\2\u07b9\u07bd\7a\2\2\u07ba\u07bc\7\7\2\2\u07bb\u07ba\3\2\2\2\u07bc"+ - "\u07bf\3\2\2\2\u07bd\u07bb\3\2\2\2\u07bd\u07be\3\2\2\2\u07be\u07c0\3\2"+ - "\2\2\u07bf\u07bd\3\2\2\2\u07c0\u07c1\7\13\2\2\u07c1\u07c2\5\u0098M\2\u07c2"+ - "\u07c6\7\f\2\2\u07c3\u07c5\7\7\2\2\u07c4\u07c3\3\2\2\2\u07c5\u07c8\3\2"+ - "\2\2\u07c6\u07c4\3\2\2\2\u07c6\u07c7\3\2\2\2\u07c7\u07cb\3\2\2\2\u07c8"+ - "\u07c6\3\2\2\2\u07c9\u07cc\5\u0086D\2\u07ca\u07cc\7\35\2\2\u07cb\u07c9"+ - "\3\2\2\2\u07cb\u07ca\3\2\2\2\u07cc\u008f\3\2\2\2\u07cd\u07d1\7`\2\2\u07ce"+ - "\u07d0\7\7\2\2\u07cf\u07ce\3\2\2\2\u07d0\u07d3\3\2\2\2\u07d1\u07cf\3\2"+ - "\2\2\u07d1\u07d2\3\2\2\2\u07d2\u07d5\3\2\2\2\u07d3\u07d1\3\2\2\2\u07d4"+ - "\u07d6\5\u0086D\2\u07d5\u07d4\3\2\2\2\u07d5\u07d6\3\2\2\2\u07d6\u07da"+ - "\3\2\2\2\u07d7\u07d9\7\7\2\2\u07d8\u07d7\3\2\2\2\u07d9\u07dc\3\2\2\2\u07da"+ - "\u07d8\3\2\2\2\u07da\u07db\3\2\2\2\u07db\u07dd\3\2\2\2\u07dc\u07da\3\2"+ - "\2\2\u07dd\u07e1\7a\2\2\u07de\u07e0\7\7\2\2\u07df\u07de\3\2\2\2\u07e0"+ - "\u07e3\3\2\2\2\u07e1\u07df\3\2\2\2\u07e1\u07e2\3\2\2\2\u07e2\u07e4\3\2"+ - "\2\2\u07e3\u07e1\3\2\2\2\u07e4\u07e5\7\13\2\2\u07e5\u07e6\5\u0098M\2\u07e6"+ - "\u07e7\7\f\2\2\u07e7\u0091\3\2\2\2\u07e8\u07e9\5\u00bc_\2\u07e9\u07ea"+ - "\7\36\2\2\u07ea\u07ef\3\2\2\2\u07eb\u07ec\5\u00c0a\2\u07ec\u07ed\5\u0112"+ - "\u008a\2\u07ed\u07ef\3\2\2\2\u07ee\u07e8\3\2\2\2\u07ee\u07eb\3\2\2\2\u07ef"+ - "\u07f3\3\2\2\2\u07f0\u07f2\7\7\2\2\u07f1\u07f0\3\2\2\2\u07f2\u07f5\3\2"+ - "\2\2\u07f3\u07f1\3\2\2\2\u07f3\u07f4\3\2\2\2\u07f4\u07f6\3\2\2\2\u07f5"+ - "\u07f3\3\2\2\2\u07f6\u07f7\5\u0098M\2\u07f7\u0093\3\2\2\2\u07f8\u07fc"+ - "\t\7\2\2\u07f9\u07fb\7\7\2\2\u07fa\u07f9\3\2\2\2\u07fb\u07fe\3\2\2\2\u07fc"+ - "\u07fa\3\2\2\2\u07fc\u07fd\3\2\2\2\u07fd\u0801\3\2\2\2\u07fe\u07fc\3\2"+ - "\2\2\u07ff\u0801\7\2\2\3\u0800\u07f8\3\2\2\2\u0800\u07ff\3\2\2\2\u0801"+ - "\u0095\3\2\2\2\u0802\u0804\t\7\2\2\u0803\u0802\3\2\2\2\u0804\u0805\3\2"+ - "\2\2\u0805\u0803\3\2\2\2\u0805\u0806\3\2\2\2\u0806\u0809\3\2\2\2\u0807"+ - "\u0809\7\2\2\3\u0808\u0803\3\2\2\2\u0808\u0807\3\2\2\2\u0809\u0097\3\2"+ - "\2\2\u080a\u080b\5\u009aN\2\u080b\u0099\3\2\2\2\u080c\u081d\5\u009cO\2"+ - "\u080d\u080f\7\7\2\2\u080e\u080d\3\2\2\2\u080f\u0812\3\2\2\2\u0810\u080e"+ - "\3\2\2\2\u0810\u0811\3\2\2\2\u0811\u0813\3\2\2\2\u0812\u0810\3\2\2\2\u0813"+ - "\u0817\7\31\2\2\u0814\u0816\7\7\2\2\u0815\u0814\3\2\2\2\u0816\u0819\3"+ - "\2\2\2\u0817\u0815\3\2\2\2\u0817\u0818\3\2\2\2\u0818\u081a\3\2\2\2\u0819"+ - "\u0817\3\2\2\2\u081a\u081c\5\u009cO\2\u081b\u0810\3\2\2\2\u081c\u081f"+ - "\3\2\2\2\u081d\u081b\3\2\2\2\u081d\u081e\3\2\2\2\u081e\u009b\3\2\2\2\u081f"+ - "\u081d\3\2\2\2\u0820\u0831\5\u009eP\2\u0821\u0823\7\7\2\2\u0822\u0821"+ - "\3\2\2\2\u0823\u0826\3\2\2\2\u0824\u0822\3\2\2\2\u0824\u0825\3\2\2\2\u0825"+ - "\u0827\3\2\2\2\u0826\u0824\3\2\2\2\u0827\u082b\7\30\2\2\u0828\u082a\7"+ - "\7\2\2\u0829\u0828\3\2\2\2\u082a\u082d\3\2\2\2\u082b\u0829\3\2\2\2\u082b"+ - "\u082c\3\2\2\2\u082c\u082e\3\2\2\2\u082d\u082b\3\2\2\2\u082e\u0830\5\u009e"+ - "P\2\u082f\u0824\3\2\2\2\u0830\u0833\3\2\2\2\u0831\u082f\3\2\2\2\u0831"+ - "\u0832\3\2\2\2\u0832\u009d\3\2\2\2\u0833\u0831\3\2\2\2\u0834\u0840\5\u00a0"+ - "Q\2\u0835\u0839\5\u0114\u008b\2\u0836\u0838\7\7\2\2\u0837\u0836\3\2\2"+ - "\2\u0838\u083b\3\2\2\2\u0839\u0837\3\2\2\2\u0839\u083a\3\2\2\2\u083a\u083c"+ - "\3\2\2\2\u083b\u0839\3\2\2\2\u083c\u083d\5\u00a0Q\2\u083d\u083f\3\2\2"+ - "\2\u083e\u0835\3\2\2\2\u083f\u0842\3\2\2\2\u0840\u083e\3\2\2\2\u0840\u0841"+ - "\3\2\2\2\u0841\u009f\3\2\2\2\u0842\u0840\3\2\2\2\u0843\u084f\5\u00a2R"+ - "\2\u0844\u0848\5\u0116\u008c\2\u0845\u0847\7\7\2\2\u0846\u0845\3\2\2\2"+ - "\u0847\u084a\3\2\2\2\u0848\u0846\3\2\2\2\u0848\u0849\3\2\2\2\u0849\u084b"+ - "\3\2\2\2\u084a\u0848\3\2\2\2\u084b\u084c\5\u00a2R\2\u084c\u084e\3\2\2"+ - "\2\u084d\u0844\3\2\2\2\u084e\u0851\3\2\2\2\u084f\u084d\3\2\2\2\u084f\u0850"+ - "\3\2\2\2\u0850\u00a1\3\2\2\2\u0851"; - private static final String _serializedATNSegment1 = - "\u084f\3\2\2\2\u0852\u0856\5\u00a4S\2\u0853\u0855\5\u00caf\2\u0854\u0853"+ - "\3\2\2\2\u0855\u0858\3\2\2\2\u0856\u0854\3\2\2\2\u0856\u0857\3\2\2\2\u0857"+ - "\u00a3\3\2\2\2\u0858\u0856\3\2\2\2\u0859\u086e\5\u00a6T\2\u085a\u085e"+ - "\5\u0118\u008d\2\u085b\u085d\7\7\2\2\u085c\u085b\3\2\2\2\u085d\u0860\3"+ - "\2\2\2\u085e\u085c\3\2\2\2\u085e\u085f\3\2\2\2\u085f\u0861\3\2\2\2\u0860"+ - "\u085e\3\2\2\2\u0861\u0862\5\u00a6T\2\u0862\u086d\3\2\2\2\u0863\u0867"+ - "\5\u011a\u008e\2\u0864\u0866\7\7\2\2\u0865\u0864\3\2\2\2\u0866\u0869\3"+ - "\2\2\2\u0867\u0865\3\2\2\2\u0867\u0868\3\2\2\2\u0868\u086a\3\2\2\2\u0869"+ - "\u0867\3\2\2\2\u086a\u086b\5d\63\2\u086b\u086d\3\2\2\2\u086c\u085a\3\2"+ - "\2\2\u086c\u0863\3\2\2\2\u086d\u0870\3\2\2\2\u086e\u086c\3\2\2\2\u086e"+ - "\u086f\3\2\2\2\u086f\u00a5\3\2\2\2\u0870\u086e\3\2\2\2\u0871\u0883\5\u00aa"+ - "V\2\u0872\u0874\7\7\2\2\u0873\u0872\3\2\2\2\u0874\u0877\3\2\2\2\u0875"+ - "\u0873\3\2\2\2\u0875\u0876\3\2\2\2\u0876\u0878\3\2\2\2\u0877\u0875\3\2"+ - "\2\2\u0878\u087c\5\u00a8U\2\u0879\u087b\7\7\2\2\u087a\u0879\3\2\2\2\u087b"+ - "\u087e\3\2\2\2\u087c\u087a\3\2\2\2\u087c\u087d\3\2\2\2\u087d\u087f\3\2"+ - "\2\2\u087e\u087c\3\2\2\2\u087f\u0880\5\u00aaV\2\u0880\u0882\3\2\2\2\u0881"+ - "\u0875\3\2\2\2\u0882\u0885\3\2\2\2\u0883\u0881\3\2\2\2\u0883\u0884\3\2"+ - "\2\2\u0884\u00a7\3\2\2\2\u0885\u0883\3\2\2\2\u0886\u0887\7/\2\2\u0887"+ - "\u0888\7\34\2\2\u0888\u00a9\3\2\2\2\u0889\u0895\5\u00acW\2\u088a\u088e"+ - "\5\u0158\u00ad\2\u088b\u088d\7\7\2\2\u088c\u088b\3\2\2\2\u088d\u0890\3"+ - "\2\2\2\u088e\u088c\3\2\2\2\u088e\u088f\3\2\2\2\u088f\u0891\3\2\2\2\u0890"+ - "\u088e\3\2\2\2\u0891\u0892\5\u00acW\2\u0892\u0894\3\2\2\2\u0893\u088a"+ - "\3\2\2\2\u0894\u0897\3\2\2\2\u0895\u0893\3\2\2\2\u0895\u0896\3\2\2\2\u0896"+ - "\u00ab\3\2\2\2\u0897\u0895\3\2\2\2\u0898\u08a3\5\u00aeX\2\u0899\u089d"+ - "\7&\2\2\u089a\u089c\7\7\2\2\u089b\u089a\3\2\2\2\u089c\u089f\3\2\2\2\u089d"+ - "\u089b\3\2\2\2\u089d\u089e\3\2\2\2\u089e\u08a0\3\2\2\2\u089f\u089d\3\2"+ - "\2\2\u08a0\u08a2\5\u00aeX\2\u08a1\u0899\3\2\2\2\u08a2\u08a5\3\2\2\2\u08a3"+ - "\u08a1\3\2\2\2\u08a3\u08a4\3\2\2\2\u08a4\u00ad\3\2\2\2\u08a5\u08a3\3\2"+ - "\2\2\u08a6\u08b2\5\u00b0Y\2\u08a7\u08ab\5\u011c\u008f\2\u08a8\u08aa\7"+ - "\7\2\2\u08a9\u08a8\3\2\2\2\u08aa\u08ad\3\2\2\2\u08ab\u08a9\3\2\2\2\u08ab"+ - "\u08ac\3\2\2\2\u08ac\u08ae\3\2\2\2\u08ad\u08ab\3\2\2\2\u08ae\u08af\5\u00b0"+ - "Y\2\u08af\u08b1\3\2\2\2\u08b0\u08a7\3\2\2\2\u08b1\u08b4\3\2\2\2\u08b2"+ - "\u08b0\3\2\2\2\u08b2\u08b3\3\2\2\2\u08b3\u00af\3\2\2\2\u08b4\u08b2\3\2"+ - "\2\2\u08b5\u08c1\5\u00b2Z\2\u08b6\u08ba\5\u011e\u0090\2\u08b7\u08b9\7"+ - "\7\2\2\u08b8\u08b7\3\2\2\2\u08b9\u08bc\3\2\2\2\u08ba\u08b8\3\2\2\2\u08ba"+ - "\u08bb\3\2\2\2\u08bb\u08bd\3\2\2\2\u08bc\u08ba\3\2\2\2\u08bd\u08be\5\u00b2"+ - "Z\2\u08be\u08c0\3\2\2\2\u08bf\u08b6\3\2\2\2\u08c0\u08c3\3\2\2\2\u08c1"+ - "\u08bf\3\2\2\2\u08c1\u08c2\3\2\2\2\u08c2\u00b1\3\2\2\2\u08c3\u08c1\3\2"+ - "\2\2\u08c4\u08d6\5\u00b4[\2\u08c5\u08c7\7\7\2\2\u08c6\u08c5\3\2\2\2\u08c7"+ - "\u08ca\3\2\2\2\u08c8\u08c6\3\2\2\2\u08c8\u08c9\3\2\2\2\u08c9\u08cb\3\2"+ - "\2\2\u08ca\u08c8\3\2\2\2\u08cb\u08cf\5\u0120\u0091\2\u08cc\u08ce\7\7\2"+ - "\2\u08cd\u08cc\3\2\2\2\u08ce\u08d1\3\2\2\2\u08cf\u08cd\3\2\2\2\u08cf\u08d0"+ - "\3\2\2\2\u08d0\u08d2\3\2\2\2\u08d1\u08cf\3\2\2\2\u08d2\u08d3\5d\63\2\u08d3"+ - "\u08d5\3\2\2\2\u08d4\u08c8\3\2\2\2\u08d5\u08d8\3\2\2\2\u08d6\u08d4\3\2"+ - "\2\2\u08d6\u08d7\3\2\2\2\u08d7\u00b3\3\2\2\2\u08d8\u08d6\3\2\2\2\u08d9"+ - "\u08db\5\u00b6\\\2\u08da\u08d9\3\2\2\2\u08db\u08de\3\2\2\2\u08dc\u08da"+ - "\3\2\2\2\u08dc\u08dd\3\2\2\2\u08dd\u08df\3\2\2\2\u08de\u08dc\3\2\2\2\u08df"+ - "\u08e0\5\u00b8]\2\u08e0\u00b5\3\2\2\2\u08e1\u08eb\5\u014e\u00a8\2\u08e2"+ - "\u08eb\5\u0084C\2\u08e3\u08e7\5\u0122\u0092\2\u08e4\u08e6\7\7\2\2\u08e5"+ - "\u08e4\3\2\2\2\u08e6\u08e9\3\2\2\2\u08e7\u08e5\3\2\2\2\u08e7\u08e8\3\2"+ - "\2\2\u08e8\u08eb\3\2\2\2\u08e9\u08e7\3\2\2\2\u08ea\u08e1\3\2\2\2\u08ea"+ - "\u08e2\3\2\2\2\u08ea\u08e3\3\2\2\2\u08eb\u00b7\3\2\2\2\u08ec\u08f0\5\u00d4"+ - "k\2\u08ed\u08ef\5\u00ba^\2\u08ee\u08ed\3\2\2\2\u08ef\u08f2\3\2\2\2\u08f0"+ - "\u08ee\3\2\2\2\u08f0\u08f1\3\2\2\2\u08f1\u00b9\3\2\2\2\u08f2\u08f0\3\2"+ - "\2\2\u08f3\u08f9\5\u0124\u0093\2\u08f4\u08f9\5\u00ceh\2\u08f5\u08f9\5"+ - "\u00caf\2\u08f6\u08f9\5\u00c6d\2\u08f7\u08f9\5\u00c8e\2\u08f8\u08f3\3"+ - "\2\2\2\u08f8\u08f4\3\2\2\2\u08f8\u08f5\3\2\2\2\u08f8\u08f6\3\2\2\2\u08f8"+ - "\u08f7\3\2\2\2\u08f9\u00bb\3\2\2\2\u08fa\u08fb\5\u00b8]\2\u08fb\u08fc"+ - "\5\u00c4c\2\u08fc\u0900\3\2\2\2\u08fd\u0900\5\u0158\u00ad\2\u08fe\u0900"+ - "\5\u00be`\2\u08ff\u08fa\3\2\2\2\u08ff\u08fd\3\2\2\2\u08ff\u08fe\3\2\2"+ - "\2\u0900\u00bd\3\2\2\2\u0901\u0905\7\13\2\2\u0902\u0904\7\7\2\2\u0903"+ - "\u0902\3\2\2\2\u0904\u0907\3\2\2\2\u0905\u0903\3\2\2\2\u0905\u0906\3\2"+ - "\2\2\u0906\u0908\3\2\2\2\u0907\u0905\3\2\2\2\u0908\u090c\5\u00bc_\2\u0909"+ - "\u090b\7\7\2\2\u090a\u0909\3\2\2\2\u090b\u090e\3\2\2\2\u090c\u090a\3\2"+ - "\2\2\u090c\u090d\3\2\2\2\u090d\u090f\3\2\2\2\u090e\u090c\3\2\2\2\u090f"+ - "\u0910\7\f\2\2\u0910\u00bf\3\2\2\2\u0911\u0914\5\u00b4[\2\u0912\u0914"+ - "\5\u00c2b\2\u0913\u0911\3\2\2\2\u0913\u0912\3\2\2\2\u0914\u00c1\3\2\2"+ - "\2\u0915\u0919\7\13\2\2\u0916\u0918\7\7\2\2\u0917\u0916\3\2\2\2\u0918"+ - "\u091b\3\2\2\2\u0919\u0917\3\2\2\2\u0919\u091a\3\2\2\2\u091a\u091c\3\2"+ - "\2\2\u091b\u0919\3\2\2\2\u091c\u0920\5\u00c0a\2\u091d\u091f\7\7\2\2\u091e"+ - "\u091d\3\2\2\2\u091f\u0922\3\2\2\2\u0920\u091e\3\2\2\2\u0920\u0921\3\2"+ - "\2\2\u0921\u0923\3\2\2\2\u0922\u0920\3\2\2\2\u0923\u0924\7\f\2\2\u0924"+ - "\u00c3\3\2\2\2\u0925\u0929\5\u00ceh\2\u0926\u0929\5\u00c6d\2\u0927\u0929"+ - "\5\u00c8e\2\u0928\u0925\3\2\2\2\u0928\u0926\3\2\2\2\u0928\u0927\3\2\2"+ - "\2\u0929\u00c5\3\2\2\2\u092a\u092e\7\r\2\2\u092b\u092d\7\7\2\2\u092c\u092b"+ - "\3\2\2\2\u092d\u0930\3\2\2\2\u092e\u092c\3\2\2\2\u092e\u092f\3\2\2\2\u092f"+ - "\u0931\3\2\2\2\u0930\u092e\3\2\2\2\u0931\u0942\5\u0098M\2\u0932\u0934"+ - "\7\7\2\2\u0933\u0932\3\2\2\2\u0934\u0937\3\2\2\2\u0935\u0933\3\2\2\2\u0935"+ - "\u0936\3\2\2\2\u0936\u0938\3\2\2\2\u0937\u0935\3\2\2\2\u0938\u093c\7\n"+ - "\2\2\u0939\u093b\7\7\2\2\u093a\u0939\3\2\2\2\u093b\u093e\3\2\2\2\u093c"+ - "\u093a\3\2\2\2\u093c\u093d\3\2\2\2\u093d\u093f\3\2\2\2\u093e\u093c\3\2"+ - "\2\2\u093f\u0941\5\u0098M\2\u0940\u0935\3\2\2\2\u0941\u0944\3\2\2\2\u0942"+ - "\u0940\3\2\2\2\u0942\u0943\3\2\2\2\u0943\u094c\3\2\2\2\u0944\u0942\3\2"+ - "\2\2\u0945\u0947\7\7\2\2\u0946\u0945\3\2\2\2\u0947\u094a\3\2\2\2\u0948"+ - "\u0946\3\2\2\2\u0948\u0949\3\2\2\2\u0949\u094b\3\2\2\2\u094a\u0948\3\2"+ - "\2\2\u094b\u094d\7\n\2\2\u094c\u0948\3\2\2\2\u094c\u094d\3\2\2\2\u094d"+ - "\u0951\3\2\2\2\u094e\u0950\7\7\2\2\u094f\u094e\3\2\2\2\u0950\u0953\3\2"+ - "\2\2\u0951\u094f\3\2\2\2\u0951\u0952\3\2\2\2\u0952\u0954\3\2\2\2\u0953"+ - "\u0951\3\2\2\2\u0954\u0955\7\16\2\2\u0955\u00c7\3\2\2\2\u0956\u095a\5"+ - "\u0128\u0095\2\u0957\u0959\7\7\2\2\u0958\u0957\3\2\2\2\u0959\u095c\3\2"+ - "\2\2\u095a\u0958\3\2\2\2\u095a\u095b\3\2\2\2\u095b\u0960\3\2\2\2\u095c"+ - "\u095a\3\2\2\2\u095d\u0961\5\u0158\u00ad\2\u095e\u0961\5\u00d6l\2\u095f"+ - "\u0961\7J\2\2\u0960\u095d\3\2\2\2\u0960\u095e\3\2\2\2\u0960\u095f\3\2"+ - "\2\2\u0961\u00c9\3\2\2\2\u0962\u0964\5\u00ceh\2\u0963\u0962\3\2\2\2\u0963"+ - "\u0964\3\2\2\2\u0964\u096a\3\2\2\2\u0965\u0967\5\u00d0i\2\u0966\u0965"+ - "\3\2\2\2\u0966\u0967\3\2\2\2\u0967\u0968\3\2\2\2\u0968\u096b\5\u00ccg"+ - "\2\u0969\u096b\5\u00d0i\2\u096a\u0966\3\2\2\2\u096a\u0969\3\2\2\2\u096b"+ - "\u00cb\3\2\2\2\u096c\u096e\5\u014e\u00a8\2\u096d\u096c\3\2\2\2\u096e\u0971"+ - "\3\2\2\2\u096f\u096d\3\2\2\2\u096f\u0970\3\2\2\2\u0970\u0973\3\2\2\2\u0971"+ - "\u096f\3\2\2\2\u0972\u0974\5\u0084C\2\u0973\u0972\3\2\2\2\u0973\u0974"+ - "\3\2\2\2\u0974\u0978\3\2\2\2\u0975\u0977\7\7\2\2\u0976\u0975\3\2\2\2\u0977"+ - "\u097a\3\2\2\2\u0978\u0976\3\2\2\2\u0978\u0979\3\2\2\2\u0979\u097b\3\2"+ - "\2\2\u097a\u0978\3\2\2\2\u097b\u097c\5\u00eav\2\u097c\u00cd\3\2\2\2\u097d"+ - "\u0981\7\60\2\2\u097e\u0980\7\7\2\2\u097f\u097e\3\2\2\2\u0980\u0983\3"+ - "\2\2\2\u0981\u097f\3\2\2\2\u0981\u0982\3\2\2\2\u0982\u0984\3\2\2\2\u0983"+ - "\u0981\3\2\2\2\u0984\u0995\5p9\2\u0985\u0987\7\7\2\2\u0986\u0985\3\2\2"+ - "\2\u0987\u098a\3\2\2\2\u0988\u0986\3\2\2\2\u0988\u0989\3\2\2\2\u0989\u098b"+ - "\3\2\2\2\u098a\u0988\3\2\2\2\u098b\u098f\7\n\2\2\u098c\u098e\7\7\2\2\u098d"+ - "\u098c\3\2\2\2\u098e\u0991\3\2\2\2\u098f\u098d\3\2\2\2\u098f\u0990\3\2"+ - "\2\2\u0990\u0992\3\2\2\2\u0991\u098f\3\2\2\2\u0992\u0994\5p9\2\u0993\u0988"+ - "\3\2\2\2\u0994\u0997\3\2\2\2\u0995\u0993\3\2\2\2\u0995\u0996\3\2\2\2\u0996"+ - "\u099f\3\2\2\2\u0997\u0995\3\2\2\2\u0998\u099a\7\7\2\2\u0999\u0998\3\2"+ - "\2\2\u099a\u099d\3\2\2\2\u099b\u0999\3\2\2\2\u099b\u099c\3\2\2\2\u099c"+ - "\u099e\3\2\2\2\u099d\u099b\3\2\2\2\u099e\u09a0\7\n\2\2\u099f\u099b\3\2"+ - "\2\2\u099f\u09a0\3\2\2\2\u09a0\u09a4\3\2\2\2\u09a1\u09a3\7\7\2\2\u09a2"+ - "\u09a1\3\2\2\2\u09a3\u09a6\3\2\2\2\u09a4\u09a2\3\2\2\2\u09a4\u09a5\3\2"+ - "\2\2\u09a5\u09a7\3\2\2\2\u09a6\u09a4\3\2\2\2\u09a7\u09a8\7\61\2\2\u09a8"+ - "\u00cf\3\2\2\2\u09a9\u09ad\7\13\2\2\u09aa\u09ac\7\7\2\2\u09ab\u09aa\3"+ - "\2\2\2\u09ac\u09af\3\2\2\2\u09ad\u09ab\3\2\2\2\u09ad\u09ae\3\2\2\2\u09ae"+ - "\u09d3\3\2\2\2\u09af\u09ad\3\2\2\2\u09b0\u09c1\5\u00d2j\2\u09b1\u09b3"+ - "\7\7\2\2\u09b2\u09b1\3\2\2\2\u09b3\u09b6\3\2\2\2\u09b4\u09b2\3\2\2\2\u09b4"+ - "\u09b5\3\2\2\2\u09b5\u09b7\3\2\2\2\u09b6\u09b4\3\2\2\2\u09b7\u09bb\7\n"+ - "\2\2\u09b8\u09ba\7\7\2\2\u09b9\u09b8\3\2\2\2\u09ba\u09bd\3\2\2\2\u09bb"+ - "\u09b9\3\2\2\2\u09bb\u09bc\3\2\2\2\u09bc\u09be\3\2\2\2\u09bd\u09bb\3\2"+ - "\2\2\u09be\u09c0\5\u00d2j\2\u09bf\u09b4\3\2\2\2\u09c0\u09c3\3\2\2\2\u09c1"+ - "\u09bf\3\2\2\2\u09c1\u09c2\3\2\2\2\u09c2\u09cb\3\2\2\2\u09c3\u09c1\3\2"+ - "\2\2\u09c4\u09c6\7\7\2\2\u09c5\u09c4\3\2\2\2\u09c6\u09c9\3\2\2\2\u09c7"+ - "\u09c5\3\2\2\2\u09c7\u09c8\3\2\2\2\u09c8\u09ca\3\2\2\2\u09c9\u09c7\3\2"+ - "\2\2\u09ca\u09cc\7\n\2\2\u09cb\u09c7\3\2\2\2\u09cb\u09cc\3\2\2\2\u09cc"+ - "\u09d0\3\2\2\2\u09cd\u09cf\7\7\2\2\u09ce\u09cd\3\2\2\2\u09cf\u09d2\3\2"+ - "\2\2\u09d0\u09ce\3\2\2\2\u09d0\u09d1\3\2\2\2\u09d1\u09d4\3\2\2\2\u09d2"+ - "\u09d0\3\2\2\2\u09d3\u09b0\3\2\2\2\u09d3\u09d4\3\2\2\2\u09d4\u09d5\3\2"+ - "\2\2\u09d5\u09d6\7\f\2\2\u09d6\u00d1\3\2\2\2\u09d7\u09d9\5\u014e\u00a8"+ - "\2\u09d8\u09d7\3\2\2\2\u09d8\u09d9\3\2\2\2\u09d9\u09dd\3\2\2\2\u09da\u09dc"+ - "\7\7\2\2\u09db\u09da\3\2\2\2\u09dc\u09df\3\2\2\2\u09dd\u09db\3\2\2\2\u09dd"+ - "\u09de\3\2\2\2\u09de\u09ee\3\2\2\2\u09df\u09dd\3\2\2\2\u09e0\u09e4\5\u0158"+ - "\u00ad\2\u09e1\u09e3\7\7\2\2\u09e2\u09e1\3\2\2\2\u09e3\u09e6\3\2\2\2\u09e4"+ - "\u09e2\3\2\2\2\u09e4\u09e5\3\2\2\2\u09e5\u09e7\3\2\2\2\u09e6\u09e4\3\2"+ - "\2\2\u09e7\u09eb\7\36\2\2\u09e8\u09ea\7\7\2\2\u09e9\u09e8\3\2\2\2\u09ea"+ - "\u09ed\3\2\2\2\u09eb\u09e9\3\2\2\2\u09eb\u09ec\3\2\2\2\u09ec\u09ef\3\2"+ - "\2\2\u09ed\u09eb\3\2\2\2\u09ee\u09e0\3\2\2\2\u09ee\u09ef\3\2\2\2\u09ef"+ - "\u09f1\3\2\2\2\u09f0\u09f2\7\21\2\2\u09f1\u09f0\3\2\2\2\u09f1\u09f2\3"+ - "\2\2\2\u09f2\u09f6\3\2\2\2\u09f3\u09f5\7\7\2\2\u09f4\u09f3\3\2\2\2\u09f5"+ - "\u09f8\3\2\2\2\u09f6\u09f4\3\2\2\2\u09f6\u09f7\3\2\2\2\u09f7\u09f9\3\2"+ - "\2\2\u09f8\u09f6\3\2\2\2\u09f9\u09fa\5\u0098M\2\u09fa\u00d3\3\2\2\2\u09fb"+ - "\u0a0a\5\u00d6l\2\u09fc\u0a0a\5\u0158\u00ad\2\u09fd\u0a0a\5\u00dan\2\u09fe"+ - "\u0a0a\5\u00dco\2\u09ff\u0a0a\5\u0110\u0089\2\u0a00\u0a0a\5\u00f2z\2\u0a01"+ - "\u0a0a\5\u00f4{\2\u0a02\u0a0a\5\u00d8m\2\u0a03\u0a0a\5\u00f6|\2\u0a04"+ - "\u0a0a\5\u00f8}\2\u0a05\u0a0a\5\u00fa~\2\u0a06\u0a0a\5\u00fe\u0080\2\u0a07"+ - "\u0a0a\5\u0108\u0085\2\u0a08\u0a0a\5\u010e\u0088\2\u0a09\u09fb\3\2\2\2"+ - "\u0a09\u09fc\3\2\2\2\u0a09\u09fd\3\2\2\2\u0a09\u09fe\3\2\2\2\u0a09\u09ff"+ - "\3\2\2\2\u0a09\u0a00\3\2\2\2\u0a09\u0a01\3\2\2\2\u0a09\u0a02\3\2\2\2\u0a09"+ - "\u0a03\3\2\2\2\u0a09\u0a04\3\2\2\2\u0a09\u0a05\3\2\2\2\u0a09\u0a06\3\2"+ - "\2\2\u0a09\u0a07\3\2\2\2\u0a09\u0a08\3\2\2\2\u0a0a\u00d5\3\2\2\2\u0a0b"+ - "\u0a0f\7\13\2\2\u0a0c\u0a0e\7\7\2\2\u0a0d\u0a0c\3\2\2\2\u0a0e\u0a11\3"+ - "\2\2\2\u0a0f\u0a0d\3\2\2\2\u0a0f\u0a10\3\2\2\2\u0a10\u0a12\3\2\2\2\u0a11"+ - "\u0a0f\3\2\2\2\u0a12\u0a16\5\u0098M\2\u0a13\u0a15\7\7\2\2\u0a14\u0a13"+ - "\3\2\2\2\u0a15\u0a18\3\2\2\2\u0a16\u0a14\3\2\2\2\u0a16\u0a17\3\2\2\2\u0a17"+ - "\u0a19\3\2\2\2\u0a18\u0a16\3\2\2\2\u0a19\u0a1a\7\f\2\2\u0a1a\u00d7\3\2"+ - "\2\2\u0a1b\u0a1f\7\r\2\2\u0a1c\u0a1e\7\7\2\2\u0a1d\u0a1c\3\2\2\2\u0a1e"+ - "\u0a21\3\2\2\2\u0a1f\u0a1d\3\2\2\2\u0a1f\u0a20\3\2\2\2\u0a20\u0a45\3\2"+ - "\2\2\u0a21\u0a1f\3\2\2\2\u0a22\u0a33\5\u0098M\2\u0a23\u0a25\7\7\2\2\u0a24"+ - "\u0a23\3\2\2\2\u0a25\u0a28\3\2\2\2\u0a26\u0a24\3\2\2\2\u0a26\u0a27\3\2"+ - "\2\2\u0a27\u0a29\3\2\2\2\u0a28\u0a26\3\2\2\2\u0a29\u0a2d\7\n\2\2\u0a2a"+ - "\u0a2c\7\7\2\2\u0a2b\u0a2a\3\2\2\2\u0a2c\u0a2f\3\2\2\2\u0a2d\u0a2b\3\2"+ - "\2\2\u0a2d\u0a2e\3\2\2\2\u0a2e\u0a30\3\2\2\2\u0a2f\u0a2d\3\2\2\2\u0a30"+ - "\u0a32\5\u0098M\2\u0a31\u0a26\3\2\2\2\u0a32\u0a35\3\2\2\2\u0a33\u0a31"+ - "\3\2\2\2\u0a33\u0a34\3\2\2\2\u0a34\u0a3d\3\2\2\2\u0a35\u0a33\3\2\2\2\u0a36"+ - "\u0a38\7\7\2\2\u0a37\u0a36\3\2\2\2\u0a38\u0a3b\3\2\2\2\u0a39\u0a37\3\2"+ - "\2\2\u0a39\u0a3a\3\2\2\2\u0a3a\u0a3c\3\2\2\2\u0a3b\u0a39\3\2\2\2\u0a3c"+ - "\u0a3e\7\n\2\2\u0a3d\u0a39\3\2\2\2\u0a3d\u0a3e\3\2\2\2\u0a3e\u0a42\3\2"+ - "\2\2\u0a3f\u0a41\7\7\2\2\u0a40\u0a3f\3\2\2\2\u0a41\u0a44\3\2\2\2\u0a42"+ - "\u0a40\3\2\2\2\u0a42\u0a43\3\2\2\2\u0a43\u0a46\3\2\2\2\u0a44\u0a42\3\2"+ - "\2\2\u0a45\u0a22\3\2\2\2\u0a45\u0a46\3\2\2\2\u0a46\u0a47\3\2\2\2\u0a47"+ - "\u0a48\7\16\2\2\u0a48\u00d9\3\2\2\2\u0a49\u0a4a\t\b\2\2\u0a4a\u00db\3"+ - "\2\2\2\u0a4b\u0a4e\5\u00dep\2\u0a4c\u0a4e\5\u00e0q\2\u0a4d\u0a4b\3\2\2"+ - "\2\u0a4d\u0a4c\3\2\2\2\u0a4e\u00dd\3\2\2\2\u0a4f\u0a54\7\u0097\2\2\u0a50"+ - "\u0a53\5\u00e2r\2\u0a51\u0a53\5\u00e4s\2\u0a52\u0a50\3\2\2\2\u0a52\u0a51"+ - "\3\2\2\2\u0a53\u0a56\3\2\2\2\u0a54\u0a52\3\2\2\2\u0a54\u0a55\3\2\2\2\u0a55"+ - "\u0a57\3\2\2\2\u0a56\u0a54\3\2\2\2\u0a57\u0a58\7\u00a0\2\2\u0a58\u00df"+ - "\3\2\2\2\u0a59\u0a5f\7\u0098\2\2\u0a5a\u0a5e\5\u00e6t\2\u0a5b\u0a5e\5"+ - "\u00e8u\2\u0a5c\u0a5e\7\u00a6\2\2\u0a5d\u0a5a\3\2\2\2\u0a5d\u0a5b\3\2"+ - "\2\2\u0a5d\u0a5c\3\2\2\2\u0a5e\u0a61\3\2\2\2\u0a5f\u0a5d\3\2\2\2\u0a5f"+ - "\u0a60\3\2\2\2\u0a60\u0a62\3\2\2\2\u0a61\u0a5f\3\2\2\2\u0a62\u0a63\7\u00a5"+ - "\2\2\u0a63\u00e1\3\2\2\2\u0a64\u0a65\t\t\2\2\u0a65\u00e3\3\2\2\2\u0a66"+ - "\u0a6a\7\u00a4\2\2\u0a67\u0a69\7\7\2\2\u0a68\u0a67\3\2\2\2\u0a69\u0a6c"+ - "\3\2\2\2\u0a6a\u0a68\3\2\2\2\u0a6a\u0a6b\3\2\2\2\u0a6b\u0a6d\3\2\2\2\u0a6c"+ - "\u0a6a\3\2\2\2\u0a6d\u0a71\5\u0098M\2\u0a6e\u0a70\7\7\2\2\u0a6f\u0a6e"+ - "\3\2\2\2\u0a70\u0a73\3\2\2\2\u0a71\u0a6f\3\2\2\2\u0a71\u0a72\3\2\2\2\u0a72"+ - "\u0a74\3\2\2\2\u0a73\u0a71\3\2\2\2\u0a74\u0a75\7\20\2\2\u0a75\u00e5\3"+ - "\2\2\2\u0a76\u0a77\t\n\2\2\u0a77\u00e7\3\2\2\2\u0a78\u0a7c\7\u00a9\2\2"+ - "\u0a79\u0a7b\7\7\2\2\u0a7a\u0a79\3\2\2\2\u0a7b\u0a7e\3\2\2\2\u0a7c\u0a7a"+ - "\3\2\2\2\u0a7c\u0a7d\3\2\2\2\u0a7d\u0a7f\3\2\2\2\u0a7e\u0a7c\3\2\2\2\u0a7f"+ - "\u0a83\5\u0098M\2\u0a80\u0a82\7\7\2\2\u0a81\u0a80\3\2\2\2\u0a82\u0a85"+ - "\3\2\2\2\u0a83\u0a81\3\2\2\2\u0a83\u0a84\3\2\2\2\u0a84\u0a86\3\2\2\2\u0a85"+ - "\u0a83\3\2\2\2\u0a86\u0a87\7\20\2\2\u0a87\u00e9\3\2\2\2\u0a88\u0a8c\7"+ - "\17\2\2\u0a89\u0a8b\7\7\2\2\u0a8a\u0a89\3\2\2\2\u0a8b\u0a8e\3\2\2\2\u0a8c"+ - "\u0a8a\3\2\2\2\u0a8c\u0a8d\3\2\2\2\u0a8d\u0a9f\3\2\2\2\u0a8e\u0a8c\3\2"+ - "\2\2\u0a8f\u0a91\5\u00ecw\2\u0a90\u0a8f\3\2\2\2\u0a90\u0a91\3\2\2\2\u0a91"+ - "\u0a95\3\2\2\2\u0a92\u0a94\7\7\2\2\u0a93\u0a92\3\2\2\2\u0a94\u0a97\3\2"+ - "\2\2\u0a95\u0a93\3\2\2\2\u0a95\u0a96\3\2\2\2\u0a96\u0a98\3\2\2\2\u0a97"+ - "\u0a95\3\2\2\2\u0a98\u0a9c\7$\2\2\u0a99\u0a9b\7\7\2\2\u0a9a\u0a99\3\2"+ - "\2\2\u0a9b\u0a9e\3\2\2\2\u0a9c\u0a9a\3\2\2\2\u0a9c\u0a9d\3\2\2\2\u0a9d"+ - "\u0aa0\3\2\2\2\u0a9e\u0a9c\3\2\2\2\u0a9f\u0a90\3\2\2\2\u0a9f\u0aa0\3\2"+ - "\2\2\u0aa0\u0aa1\3\2\2\2\u0aa1\u0aa5\5\u0080A\2\u0aa2\u0aa4\7\7\2\2\u0aa3"+ - "\u0aa2\3\2\2\2\u0aa4\u0aa7\3\2\2\2\u0aa5\u0aa3\3\2\2\2\u0aa5\u0aa6\3\2"+ - "\2\2\u0aa6\u0aa8\3\2\2\2\u0aa7\u0aa5\3\2\2\2\u0aa8\u0aa9\7\20\2\2\u0aa9"+ - "\u00eb\3\2\2\2\u0aaa\u0abb\5\u00eex\2\u0aab\u0aad\7\7\2\2\u0aac\u0aab"+ - "\3\2\2\2\u0aad\u0ab0\3\2\2\2\u0aae\u0aac\3\2\2\2\u0aae\u0aaf\3\2\2\2\u0aaf"+ - "\u0ab1\3\2\2\2\u0ab0\u0aae\3\2\2\2\u0ab1\u0ab5\7\n\2\2\u0ab2\u0ab4\7\7"+ - "\2\2\u0ab3\u0ab2\3\2\2\2\u0ab4\u0ab7\3\2\2\2\u0ab5\u0ab3\3\2\2\2\u0ab5"+ - "\u0ab6\3\2\2\2\u0ab6\u0ab8\3\2\2\2\u0ab7\u0ab5\3\2\2\2\u0ab8\u0aba\5\u00ee"+ - "x\2\u0ab9\u0aae\3\2\2\2\u0aba\u0abd\3\2\2\2\u0abb\u0ab9\3\2\2\2\u0abb"+ - "\u0abc\3\2\2\2\u0abc\u0ac5\3\2\2\2\u0abd\u0abb\3\2\2\2\u0abe\u0ac0\7\7"+ - "\2\2\u0abf\u0abe\3\2\2\2\u0ac0\u0ac3\3\2\2\2\u0ac1\u0abf\3\2\2\2\u0ac1"+ - "\u0ac2\3\2\2\2\u0ac2\u0ac4\3\2\2\2\u0ac3\u0ac1\3\2\2\2\u0ac4\u0ac6\7\n"+ - "\2\2\u0ac5\u0ac1\3\2\2\2\u0ac5\u0ac6\3\2\2\2\u0ac6\u00ed\3\2\2\2\u0ac7"+ - "\u0ada\5D#\2\u0ac8\u0ad7\5F$\2\u0ac9\u0acb\7\7\2\2\u0aca\u0ac9\3\2\2\2"+ - "\u0acb\u0ace\3\2\2\2\u0acc\u0aca\3\2\2\2\u0acc\u0acd\3\2\2\2\u0acd\u0acf"+ - "\3\2\2\2\u0ace\u0acc\3\2\2\2\u0acf\u0ad3\7\34\2\2\u0ad0\u0ad2\7\7\2\2"+ - "\u0ad1\u0ad0\3\2\2\2\u0ad2\u0ad5\3\2\2\2\u0ad3\u0ad1\3\2\2\2\u0ad3\u0ad4"+ - "\3\2\2\2\u0ad4\u0ad6\3\2\2\2\u0ad5\u0ad3\3\2\2\2\u0ad6\u0ad8\5d\63\2\u0ad7"+ - "\u0acc\3\2\2\2\u0ad7\u0ad8\3\2\2\2\u0ad8\u0ada\3\2\2\2\u0ad9\u0ac7\3\2"+ - "\2\2\u0ad9\u0ac8\3\2\2\2\u0ada\u00ef\3\2\2\2\u0adb\u0aeb\7L\2\2\u0adc"+ - "\u0ade\7\7\2\2\u0add\u0adc\3\2\2\2\u0ade\u0ae1\3\2\2\2\u0adf\u0add\3\2"+ - "\2\2\u0adf\u0ae0\3\2\2\2\u0ae0\u0ae2\3\2\2\2\u0ae1\u0adf\3\2\2\2\u0ae2"+ - "\u0ae6\5d\63\2\u0ae3\u0ae5\7\7\2\2\u0ae4\u0ae3\3\2\2\2\u0ae5\u0ae8\3\2"+ - "\2\2\u0ae6\u0ae4\3\2\2\2\u0ae6\u0ae7\3\2\2\2\u0ae7\u0ae9\3\2\2\2\u0ae8"+ - "\u0ae6\3\2\2\2\u0ae9\u0aea\7\t\2\2\u0aea\u0aec\3\2\2\2\u0aeb\u0adf\3\2"+ - "\2\2\u0aeb\u0aec\3\2\2\2\u0aec\u0af0\3\2\2\2\u0aed\u0aef\7\7\2\2\u0aee"+ - "\u0aed\3\2\2\2\u0aef\u0af2\3\2\2\2\u0af0\u0aee\3\2\2\2\u0af0\u0af1\3\2"+ - "\2\2\u0af1\u0af3\3\2\2\2\u0af2\u0af0\3\2\2\2\u0af3\u0b02\5P)\2\u0af4\u0af6"+ - "\7\7\2\2\u0af5\u0af4\3\2\2\2\u0af6\u0af9\3\2\2\2\u0af7\u0af5\3\2\2\2\u0af7"+ - "\u0af8\3\2\2\2\u0af8\u0afa\3\2\2\2\u0af9\u0af7\3\2\2\2\u0afa\u0afe\7\34"+ - "\2\2\u0afb\u0afd\7\7\2\2\u0afc\u0afb\3\2\2\2\u0afd\u0b00\3\2\2\2\u0afe"+ - "\u0afc\3\2\2\2\u0afe\u0aff\3\2\2\2\u0aff\u0b01\3\2\2\2\u0b00\u0afe\3\2"+ - "\2\2\u0b01\u0b03\5d\63\2\u0b02\u0af7\3\2\2\2\u0b02\u0b03\3\2\2\2\u0b03"+ - "\u0b0b\3\2\2\2\u0b04\u0b06\7\7\2\2\u0b05\u0b04\3\2\2\2\u0b06\u0b09\3\2"+ - "\2\2\u0b07\u0b05\3\2\2\2\u0b07\u0b08\3\2\2\2\u0b08\u0b0a\3\2\2\2\u0b09"+ - "\u0b07\3\2\2\2\u0b0a\u0b0c\5\60\31\2\u0b0b\u0b07\3\2\2\2\u0b0b\u0b0c\3"+ - "\2\2\2\u0b0c\u0b14\3\2\2\2\u0b0d\u0b0f\7\7\2\2\u0b0e\u0b0d\3\2\2\2\u0b0f"+ - "\u0b12\3\2\2\2\u0b10\u0b0e\3\2\2\2\u0b10\u0b11\3\2\2\2\u0b11\u0b13\3\2"+ - "\2\2\u0b12\u0b10\3\2\2\2\u0b13\u0b15\5B\"\2\u0b14\u0b10\3\2\2\2\u0b14"+ - "\u0b15\3\2\2\2\u0b15\u00f1\3\2\2\2\u0b16\u0b19\5\u00eav\2\u0b17\u0b19"+ - "\5\u00f0y\2\u0b18\u0b16\3\2\2\2\u0b18\u0b17\3\2\2\2\u0b19\u00f3\3\2\2"+ - "\2\u0b1a\u0b2f\7M\2\2\u0b1b\u0b1d\7\7\2\2\u0b1c\u0b1b\3\2\2\2\u0b1d\u0b20"+ - "\3\2\2\2\u0b1e\u0b1c\3\2\2\2\u0b1e\u0b1f\3\2\2\2\u0b1f\u0b21\3\2\2\2\u0b20"+ - "\u0b1e\3\2\2\2\u0b21\u0b25\7\34\2\2\u0b22\u0b24\7\7\2\2\u0b23\u0b22\3"+ - "\2\2\2\u0b24\u0b27\3\2\2\2\u0b25\u0b23\3\2\2\2\u0b25\u0b26\3\2\2\2\u0b26"+ - "\u0b28\3\2\2\2\u0b27\u0b25\3\2\2\2\u0b28\u0b2c\5\"\22\2\u0b29\u0b2b\7"+ - "\7\2\2\u0b2a\u0b29\3\2\2\2\u0b2b\u0b2e\3\2\2\2\u0b2c\u0b2a\3\2\2\2\u0b2c"+ - "\u0b2d\3\2\2\2\u0b2d\u0b30\3\2\2\2\u0b2e\u0b2c\3\2\2\2\u0b2f\u0b1e\3\2"+ - "\2\2\u0b2f\u0b30\3\2\2\2\u0b30\u0b38\3\2\2\2\u0b31\u0b33\7\7\2\2\u0b32"+ - "\u0b31\3\2\2\2\u0b33\u0b36\3\2\2\2\u0b34\u0b32\3\2\2\2\u0b34\u0b35\3\2"+ - "\2\2\u0b35\u0b37\3\2\2\2\u0b36\u0b34\3\2\2\2\u0b37\u0b39\5\34\17\2\u0b38"+ - "\u0b34\3\2\2\2\u0b38\u0b39\3\2\2\2\u0b39\u00f5\3\2\2\2\u0b3a\u0b3b\t\13"+ - "\2\2\u0b3b\u00f7\3\2\2\2\u0b3c\u0b4d\7V\2\2\u0b3d\u0b41\7\60\2\2\u0b3e"+ - "\u0b40\7\7\2\2\u0b3f\u0b3e\3\2\2\2\u0b40\u0b43\3\2\2\2\u0b41\u0b3f\3\2"+ - "\2\2\u0b41\u0b42\3\2\2\2\u0b42\u0b44\3\2\2\2\u0b43\u0b41\3\2\2\2\u0b44"+ - "\u0b48\5d\63\2\u0b45\u0b47\7\7\2\2\u0b46\u0b45\3\2\2\2\u0b47\u0b4a\3\2"+ - "\2\2\u0b48\u0b46\3\2\2\2\u0b48\u0b49\3\2\2\2\u0b49\u0b4b\3\2\2\2\u0b4a"+ - "\u0b48\3\2\2\2\u0b4b\u0b4c\7\61\2\2\u0b4c\u0b4e\3\2\2\2\u0b4d\u0b3d\3"+ - "\2\2\2\u0b4d\u0b4e\3\2\2\2\u0b4e\u0b51\3\2\2\2\u0b4f\u0b50\7*\2\2\u0b50"+ - "\u0b52\5\u0158\u00ad\2\u0b51\u0b4f\3\2\2\2\u0b51\u0b52\3\2\2\2\u0b52\u0b55"+ - "\3\2\2\2\u0b53\u0b55\7>\2\2\u0b54\u0b3c\3\2\2\2\u0b54\u0b53\3\2\2\2\u0b55"+ - "\u00f9\3\2\2\2\u0b56\u0b5a\7Y\2\2\u0b57\u0b59\7\7\2\2\u0b58\u0b57\3\2"+ - "\2\2\u0b59\u0b5c\3\2\2\2\u0b5a\u0b58\3\2\2\2\u0b5a\u0b5b\3\2\2\2\u0b5b"+ - "\u0b5d\3\2\2\2\u0b5c\u0b5a\3\2\2\2\u0b5d\u0b61\7\13\2\2\u0b5e\u0b60\7"+ - "\7\2\2\u0b5f\u0b5e\3\2\2\2\u0b60\u0b63\3\2\2\2\u0b61\u0b5f\3\2\2\2\u0b61"+ - "\u0b62\3\2\2\2\u0b62\u0b64\3\2\2\2\u0b63\u0b61\3\2\2\2\u0b64\u0b68\5\u0098"+ - "M\2\u0b65\u0b67\7\7\2\2\u0b66\u0b65\3\2\2\2\u0b67\u0b6a\3\2\2\2\u0b68"+ - "\u0b66\3\2\2\2\u0b68\u0b69\3\2\2\2\u0b69\u0b6b\3\2\2\2\u0b6a\u0b68\3\2"+ - "\2\2\u0b6b\u0b6f\7\f\2\2\u0b6c\u0b6e\7\7\2\2\u0b6d\u0b6c\3\2\2\2\u0b6e"+ - "\u0b71\3\2\2\2\u0b6f\u0b6d\3\2\2\2\u0b6f\u0b70\3\2\2\2\u0b70\u0b91\3\2"+ - "\2\2\u0b71\u0b6f\3\2\2\2\u0b72\u0b92\5\u0086D\2\u0b73\u0b75\5\u0086D\2"+ - "\u0b74\u0b73\3\2\2\2\u0b74\u0b75\3\2\2\2\u0b75\u0b79\3\2\2\2\u0b76\u0b78"+ - "\7\7\2\2\u0b77\u0b76\3\2\2\2\u0b78\u0b7b\3\2\2\2\u0b79\u0b77\3\2\2\2\u0b79"+ - "\u0b7a\3\2\2\2\u0b7a\u0b7d\3\2\2\2\u0b7b\u0b79\3\2\2\2\u0b7c\u0b7e\7\35"+ - "\2\2\u0b7d\u0b7c\3\2\2\2\u0b7d\u0b7e\3\2\2\2\u0b7e\u0b82\3\2\2\2\u0b7f"+ - "\u0b81\7\7\2\2\u0b80\u0b7f\3\2\2\2\u0b81\u0b84\3\2\2\2\u0b82\u0b80\3\2"+ - "\2\2\u0b82\u0b83\3\2\2\2\u0b83\u0b85\3\2\2\2\u0b84\u0b82\3\2\2\2\u0b85"+ - "\u0b89\7Z\2\2\u0b86\u0b88\7\7\2\2\u0b87\u0b86\3\2\2\2\u0b88\u0b8b\3\2"+ - "\2\2\u0b89\u0b87\3\2\2\2\u0b89\u0b8a\3\2\2\2\u0b8a\u0b8e\3\2\2\2\u0b8b"+ - "\u0b89\3\2\2\2\u0b8c\u0b8f\5\u0086D\2\u0b8d\u0b8f\7\35\2\2\u0b8e\u0b8c"+ - "\3\2\2\2\u0b8e\u0b8d\3\2\2\2\u0b8f\u0b92\3\2\2\2\u0b90\u0b92\7\35\2\2"+ - "\u0b91\u0b72\3\2\2\2\u0b91\u0b74\3\2\2\2\u0b91\u0b90\3\2\2\2\u0b92\u00fb"+ - "\3\2\2\2\u0b93\u0bb5\7\13\2\2\u0b94\u0b96\5\u014e\u00a8\2\u0b95\u0b94"+ - "\3\2\2\2\u0b96\u0b99\3\2\2\2\u0b97\u0b95\3\2\2\2\u0b97\u0b98\3\2\2\2\u0b98"+ - "\u0b9d\3\2\2\2\u0b99\u0b97\3\2\2\2\u0b9a\u0b9c\7\7\2\2\u0b9b\u0b9a\3\2"+ - "\2\2\u0b9c\u0b9f\3\2\2\2\u0b9d\u0b9b\3\2\2\2\u0b9d\u0b9e\3\2\2\2\u0b9e"+ - "\u0ba0\3\2\2\2\u0b9f\u0b9d\3\2\2\2\u0ba0\u0ba4\7N\2\2\u0ba1\u0ba3\7\7"+ - "\2\2\u0ba2\u0ba1\3\2\2\2\u0ba3\u0ba6\3\2\2\2\u0ba4\u0ba2\3\2\2\2\u0ba4"+ - "\u0ba5\3\2\2\2\u0ba5\u0ba7\3\2\2\2\u0ba6\u0ba4\3\2\2\2\u0ba7\u0bab\5D"+ - "#\2\u0ba8\u0baa\7\7\2\2\u0ba9\u0ba8\3\2\2\2\u0baa\u0bad\3\2\2\2\u0bab"+ - "\u0ba9\3\2\2\2\u0bab\u0bac\3\2\2\2\u0bac\u0bae\3\2\2\2\u0bad\u0bab\3\2"+ - "\2\2\u0bae\u0bb2\7\36\2\2\u0baf\u0bb1\7\7\2\2\u0bb0\u0baf\3\2\2\2\u0bb1"+ - "\u0bb4\3\2\2\2\u0bb2\u0bb0\3\2\2\2\u0bb2\u0bb3\3\2\2\2\u0bb3\u0bb6\3\2"+ - "\2\2\u0bb4\u0bb2\3\2\2\2\u0bb5\u0b97\3\2\2\2\u0bb5\u0bb6\3\2\2\2\u0bb6"+ - "\u0bb7\3\2\2\2\u0bb7\u0bb8\5\u0098M\2\u0bb8\u0bb9\7\f\2\2\u0bb9\u00fd"+ - "\3\2\2\2\u0bba\u0bbe\7[\2\2\u0bbb\u0bbd\7\7\2\2\u0bbc\u0bbb\3\2\2\2\u0bbd"+ - "\u0bc0\3\2\2\2\u0bbe\u0bbc\3\2\2\2\u0bbe\u0bbf\3\2\2\2\u0bbf\u0bc2\3\2"+ - "\2\2\u0bc0\u0bbe\3\2\2\2\u0bc1\u0bc3\5\u00fc\177\2\u0bc2\u0bc1\3\2\2\2"+ - "\u0bc2\u0bc3\3\2\2\2\u0bc3\u0bc7\3\2\2\2\u0bc4\u0bc6\7\7\2\2\u0bc5\u0bc4"+ - "\3\2\2\2\u0bc6\u0bc9\3\2\2\2\u0bc7\u0bc5\3\2\2\2\u0bc7\u0bc8\3\2\2\2\u0bc8"+ - "\u0bca\3\2\2\2\u0bc9\u0bc7\3\2\2\2\u0bca\u0bce\7\17\2\2\u0bcb\u0bcd\7"+ - "\7\2\2\u0bcc\u0bcb\3\2\2\2\u0bcd\u0bd0\3\2\2\2\u0bce\u0bcc\3\2\2\2\u0bce"+ - "\u0bcf\3\2\2\2\u0bcf\u0bda\3\2\2\2\u0bd0\u0bce\3\2\2\2\u0bd1\u0bd5\5\u0100"+ - "\u0081\2\u0bd2\u0bd4\7\7\2\2\u0bd3\u0bd2\3\2\2\2\u0bd4\u0bd7\3\2\2\2\u0bd5"+ - "\u0bd3\3\2\2\2\u0bd5\u0bd6\3\2\2\2\u0bd6\u0bd9\3\2\2\2\u0bd7\u0bd5\3\2"+ - "\2\2\u0bd8\u0bd1\3\2\2\2\u0bd9\u0bdc\3\2\2\2\u0bda\u0bd8\3\2\2\2\u0bda"+ - "\u0bdb\3\2\2\2\u0bdb\u0be0\3\2\2\2\u0bdc\u0bda\3\2\2\2\u0bdd\u0bdf\7\7"+ - "\2\2\u0bde\u0bdd\3\2\2\2\u0bdf\u0be2\3\2\2\2\u0be0\u0bde\3\2\2\2\u0be0"+ - "\u0be1\3\2\2\2\u0be1\u0be3\3\2\2\2\u0be2\u0be0\3\2\2\2\u0be3\u0be4\7\20"+ - "\2\2\u0be4\u00ff\3\2\2\2\u0be5\u0bf6\5\u0102\u0082\2\u0be6\u0be8\7\7\2"+ - "\2\u0be7\u0be6\3\2\2\2\u0be8\u0beb\3\2\2\2\u0be9\u0be7\3\2\2\2\u0be9\u0bea"+ - "\3\2\2\2\u0bea\u0bec\3\2\2\2\u0beb\u0be9\3\2\2\2\u0bec\u0bf0\7\n\2\2\u0bed"+ - "\u0bef\7\7\2\2\u0bee\u0bed\3\2\2\2\u0bef\u0bf2\3\2\2\2\u0bf0\u0bee\3\2"+ - "\2\2\u0bf0\u0bf1\3\2\2\2\u0bf1\u0bf3\3\2\2\2\u0bf2\u0bf0\3\2\2\2\u0bf3"+ - "\u0bf5\5\u0102\u0082\2\u0bf4\u0be9\3\2\2\2\u0bf5\u0bf8\3\2\2\2\u0bf6\u0bf4"+ - "\3\2\2\2\u0bf6\u0bf7\3\2\2\2\u0bf7\u0c00\3\2\2\2\u0bf8\u0bf6\3\2\2\2\u0bf9"+ - "\u0bfb\7\7\2\2\u0bfa\u0bf9\3\2\2\2\u0bfb\u0bfe\3\2\2\2\u0bfc\u0bfa\3\2"+ - "\2\2\u0bfc\u0bfd\3\2\2\2\u0bfd\u0bff\3\2\2\2\u0bfe\u0bfc\3\2\2\2\u0bff"+ - "\u0c01\7\n\2\2\u0c00\u0bfc\3\2\2\2\u0c00\u0c01\3\2\2\2\u0c01\u0c05\3\2"+ - "\2\2\u0c02\u0c04\7\7\2\2\u0c03\u0c02\3\2\2\2\u0c04\u0c07\3\2\2\2\u0c05"+ - "\u0c03\3\2\2\2\u0c05\u0c06\3\2\2\2\u0c06\u0c08\3\2\2\2\u0c07\u0c05\3\2"+ - "\2\2\u0c08\u0c0c\7$\2\2\u0c09\u0c0b\7\7\2\2\u0c0a\u0c09\3\2\2\2\u0c0b"+ - "\u0c0e\3\2\2\2\u0c0c\u0c0a\3\2\2\2\u0c0c\u0c0d\3\2\2\2\u0c0d\u0c0f\3\2"+ - "\2\2\u0c0e\u0c0c\3\2\2\2\u0c0f\u0c11\5\u0086D\2\u0c10\u0c12\5\u0094K\2"+ - "\u0c11\u0c10\3\2\2\2\u0c11\u0c12\3\2\2\2\u0c12\u0c26\3\2\2\2\u0c13\u0c17"+ - "\7Z\2\2\u0c14\u0c16\7\7\2\2\u0c15\u0c14\3\2\2\2\u0c16\u0c19\3\2\2\2\u0c17"+ - "\u0c15\3\2\2\2\u0c17\u0c18\3\2\2\2\u0c18\u0c1a\3\2\2\2\u0c19\u0c17\3\2"+ - "\2\2\u0c1a\u0c1e\7$\2\2\u0c1b\u0c1d\7\7\2\2\u0c1c\u0c1b\3\2\2\2\u0c1d"+ - "\u0c20\3\2\2\2\u0c1e\u0c1c\3\2\2\2\u0c1e\u0c1f\3\2\2\2\u0c1f\u0c21\3\2"+ - "\2\2\u0c20\u0c1e\3\2\2\2\u0c21\u0c23\5\u0086D\2\u0c22\u0c24\5\u0094K\2"+ - "\u0c23\u0c22\3\2\2\2\u0c23\u0c24\3\2\2\2\u0c24\u0c26\3\2\2\2\u0c25\u0be5"+ - "\3\2\2\2\u0c25\u0c13\3\2\2\2\u0c26\u0101\3\2\2\2\u0c27\u0c2b\5\u0098M"+ - "\2\u0c28\u0c2b\5\u0104\u0083\2\u0c29\u0c2b\5\u0106\u0084\2\u0c2a\u0c27"+ - "\3\2\2\2\u0c2a\u0c28\3\2\2\2\u0c2a\u0c29\3\2\2\2\u0c2b\u0103\3\2\2\2\u0c2c"+ - "\u0c30\5\u0118\u008d\2\u0c2d\u0c2f\7\7\2\2\u0c2e\u0c2d\3\2\2\2\u0c2f\u0c32"+ - "\3\2\2\2\u0c30\u0c2e\3\2\2\2\u0c30\u0c31\3\2\2\2\u0c31\u0c33\3\2\2\2\u0c32"+ - "\u0c30\3\2\2\2\u0c33\u0c34\5\u0098M\2\u0c34\u0105\3\2\2\2\u0c35\u0c39"+ - "\5\u011a\u008e\2\u0c36\u0c38\7\7\2\2\u0c37\u0c36\3\2\2\2\u0c38\u0c3b\3"+ - "\2\2\2\u0c39\u0c37\3\2\2\2\u0c39\u0c3a\3\2\2\2\u0c3a\u0c3c\3\2\2\2\u0c3b"+ - "\u0c39\3\2\2\2\u0c3c\u0c3d\5d\63\2\u0c3d\u0107\3\2\2\2\u0c3e\u0c42\7\\"+ - "\2\2\u0c3f\u0c41\7\7\2\2\u0c40\u0c3f\3\2\2\2\u0c41\u0c44\3\2\2\2\u0c42"+ - "\u0c40\3\2\2\2\u0c42\u0c43\3\2\2\2\u0c43\u0c45\3\2\2\2\u0c44\u0c42\3\2"+ - "\2\2\u0c45\u0c61\5\u0088E\2\u0c46\u0c48\7\7\2\2\u0c47\u0c46\3\2\2\2\u0c48"+ - "\u0c4b\3\2\2\2\u0c49\u0c47\3\2\2\2\u0c49\u0c4a\3\2\2\2\u0c4a\u0c4c\3\2"+ - "\2\2\u0c4b\u0c49\3\2\2\2\u0c4c\u0c4e\5\u010a\u0086\2\u0c4d\u0c49\3\2\2"+ - "\2\u0c4e\u0c4f\3\2\2\2\u0c4f\u0c4d\3\2\2\2\u0c4f\u0c50\3\2\2\2\u0c50\u0c58"+ - "\3\2\2\2\u0c51\u0c53\7\7\2\2\u0c52\u0c51\3\2\2\2\u0c53\u0c56\3\2\2\2\u0c54"+ - "\u0c52\3\2\2\2\u0c54\u0c55\3\2\2\2\u0c55\u0c57\3\2\2\2\u0c56\u0c54\3\2"+ - "\2\2\u0c57\u0c59\5\u010c\u0087\2\u0c58\u0c54\3\2\2\2\u0c58\u0c59\3\2\2"+ - "\2\u0c59\u0c62\3\2\2\2\u0c5a\u0c5c\7\7\2\2\u0c5b\u0c5a\3\2\2\2\u0c5c\u0c5f"+ - "\3\2\2\2\u0c5d\u0c5b\3\2\2\2\u0c5d\u0c5e\3\2\2\2\u0c5e\u0c60\3\2\2\2\u0c5f"+ - "\u0c5d\3\2\2\2\u0c60\u0c62\5\u010c\u0087\2\u0c61\u0c4d\3\2\2\2\u0c61\u0c5d"+ - "\3\2\2\2\u0c62\u0109\3\2\2\2\u0c63\u0c67\7]\2\2\u0c64\u0c66\7\7\2\2\u0c65"+ - "\u0c64\3\2\2\2\u0c66\u0c69\3\2\2\2\u0c67\u0c65\3\2\2\2\u0c67\u0c68\3\2"+ - "\2\2\u0c68\u0c6a\3\2\2\2\u0c69\u0c67\3\2\2\2\u0c6a\u0c6e\7\13\2\2\u0c6b"+ - "\u0c6d\5\u014e\u00a8\2\u0c6c\u0c6b\3\2\2\2\u0c6d\u0c70\3\2\2\2\u0c6e\u0c6c"+ - "\3\2\2\2\u0c6e\u0c6f\3\2\2\2\u0c6f\u0c71\3\2\2\2\u0c70\u0c6e\3\2\2\2\u0c71"+ - "\u0c72\5\u0158\u00ad\2\u0c72\u0c73\7\34\2\2\u0c73\u0c7b\5d\63\2\u0c74"+ - "\u0c76\7\7\2\2\u0c75\u0c74\3\2\2\2\u0c76\u0c79\3\2\2\2\u0c77\u0c75\3\2"+ - "\2\2\u0c77\u0c78\3\2\2\2\u0c78\u0c7a\3\2\2\2\u0c79\u0c77\3\2\2\2\u0c7a"+ - "\u0c7c\7\n\2\2\u0c7b\u0c77\3\2\2\2\u0c7b\u0c7c\3\2\2\2\u0c7c\u0c7d\3\2"+ - "\2\2\u0c7d\u0c81\7\f\2\2\u0c7e\u0c80\7\7\2\2\u0c7f\u0c7e\3\2\2\2\u0c80"+ - "\u0c83\3\2\2\2\u0c81\u0c7f\3\2\2\2\u0c81\u0c82\3\2\2\2\u0c82\u0c84\3\2"+ - "\2\2\u0c83\u0c81\3\2\2\2\u0c84\u0c85\5\u0088E\2\u0c85\u010b\3\2\2\2\u0c86"+ - "\u0c8a\7^\2\2\u0c87\u0c89\7\7\2\2\u0c88\u0c87\3\2\2\2\u0c89\u0c8c\3\2"+ - "\2\2\u0c8a\u0c88\3\2\2\2\u0c8a\u0c8b\3\2\2\2\u0c8b\u0c8d\3\2\2\2\u0c8c"+ - "\u0c8a\3\2\2\2\u0c8d\u0c8e\5\u0088E\2\u0c8e\u010d\3\2\2\2\u0c8f\u0c93"+ - "\7b\2\2\u0c90\u0c92\7\7\2\2\u0c91\u0c90\3\2\2\2\u0c92\u0c95\3\2\2\2\u0c93"+ - "\u0c91\3\2\2\2\u0c93\u0c94\3\2\2\2\u0c94\u0c96\3\2\2\2\u0c95\u0c93\3\2"+ - "\2\2\u0c96\u0ca0\5\u0098M\2\u0c97\u0c99\t\f\2\2\u0c98\u0c9a\5\u0098M\2"+ - "\u0c99\u0c98\3\2\2\2\u0c99\u0c9a\3\2\2\2\u0c9a\u0ca0\3\2\2\2\u0c9b\u0ca0"+ - "\7d\2\2\u0c9c\u0ca0\7;\2\2\u0c9d\u0ca0\7e\2\2\u0c9e\u0ca0\7<\2\2\u0c9f"+ - "\u0c8f\3\2\2\2\u0c9f\u0c97\3\2\2\2\u0c9f\u0c9b\3\2\2\2\u0c9f\u0c9c\3\2"+ - "\2\2\u0c9f\u0c9d\3\2\2\2\u0c9f\u0c9e\3\2\2\2\u0ca0\u010f\3\2\2\2\u0ca1"+ - "\u0ca3\5|?\2\u0ca2\u0ca1\3\2\2\2\u0ca2\u0ca3\3\2\2\2\u0ca3\u0ca4\3\2\2"+ - "\2\u0ca4\u0ca8\7\'\2\2\u0ca5\u0ca7\7\7\2\2\u0ca6\u0ca5\3\2\2\2\u0ca7\u0caa"+ - "\3\2\2\2\u0ca8\u0ca6\3\2\2\2\u0ca8\u0ca9\3\2\2\2\u0ca9\u0cad\3\2\2\2\u0caa"+ - "\u0ca8\3\2\2\2\u0cab\u0cae\5\u0158\u00ad\2\u0cac\u0cae\7J\2\2\u0cad\u0cab"+ - "\3\2\2\2\u0cad\u0cac\3\2\2\2\u0cae\u0111\3\2\2\2\u0caf\u0cb0\t\r\2\2\u0cb0"+ - "\u0113\3\2\2\2\u0cb1\u0cb2\t\16\2\2\u0cb2\u0115\3\2\2\2\u0cb3\u0cb4\t"+ - "\17\2\2\u0cb4\u0117\3\2\2\2\u0cb5\u0cb6\t\20\2\2\u0cb6\u0119\3\2\2\2\u0cb7"+ - "\u0cb8\t\21\2\2\u0cb8\u011b\3\2\2\2\u0cb9\u0cba\t\22\2\2\u0cba\u011d\3"+ - "\2\2\2\u0cbb\u0cbc\t\23\2\2\u0cbc\u011f\3\2\2\2\u0cbd\u0cbe\t\24\2\2\u0cbe"+ - "\u0121\3\2\2\2\u0cbf\u0cc5\7\26\2\2\u0cc0\u0cc5\7\27\2\2\u0cc1\u0cc5\7"+ - "\25\2\2\u0cc2\u0cc5\7\24\2\2\u0cc3\u0cc5\5\u0126\u0094\2\u0cc4\u0cbf\3"+ - "\2\2\2\u0cc4\u0cc0\3\2\2\2\u0cc4\u0cc1\3\2\2\2\u0cc4\u0cc2\3\2\2\2\u0cc4"+ - "\u0cc3\3\2\2\2\u0cc5\u0123\3\2\2\2\u0cc6\u0ccb\7\26\2\2\u0cc7\u0ccb\7"+ - "\27\2\2\u0cc8\u0cc9\7\33\2\2\u0cc9\u0ccb\5\u0126\u0094\2\u0cca\u0cc6\3"+ - "\2\2\2\u0cca\u0cc7\3\2\2\2\u0cca\u0cc8\3\2\2\2\u0ccb\u0125\3\2\2\2\u0ccc"+ - "\u0ccd\t\25\2\2\u0ccd\u0127\3\2\2\2\u0cce\u0cd0\7\7\2\2\u0ccf\u0cce\3"+ - "\2\2\2\u0cd0\u0cd3\3\2\2\2\u0cd1\u0ccf\3\2\2\2\u0cd1\u0cd2\3\2\2\2\u0cd2"+ - "\u0cd4\3\2\2\2\u0cd3\u0cd1\3\2\2\2\u0cd4\u0cde\7\t\2\2\u0cd5\u0cd7\7\7"+ - "\2\2\u0cd6\u0cd5\3\2\2\2\u0cd7\u0cda\3\2\2\2\u0cd8\u0cd6\3\2\2\2\u0cd8"+ - "\u0cd9\3\2\2\2\u0cd9\u0cdb\3\2\2\2\u0cda\u0cd8\3\2\2\2\u0cdb\u0cde\5\u012a"+ - "\u0096\2\u0cdc\u0cde\7\'\2\2\u0cdd\u0cd1\3\2\2\2\u0cdd\u0cd8\3\2\2\2\u0cdd"+ - "\u0cdc\3\2\2\2\u0cde\u0129\3\2\2\2\u0cdf\u0ce0\7/\2\2\u0ce0\u0ce1\7\t"+ - "\2\2\u0ce1\u012b\3\2\2\2\u0ce2\u0ce5\5\u014e\u00a8\2\u0ce3\u0ce5\5\u0130"+ - "\u0099\2\u0ce4\u0ce2\3\2\2\2\u0ce4\u0ce3\3\2\2\2\u0ce5\u0ce6\3\2\2\2\u0ce6"+ - "\u0ce4\3\2\2\2\u0ce6\u0ce7\3\2\2\2\u0ce7\u012d\3\2\2\2\u0ce8\u0ceb\5\u014e"+ - "\u00a8\2\u0ce9\u0ceb\5\u0148\u00a5\2\u0cea\u0ce8\3\2\2\2\u0cea\u0ce9\3"+ - "\2\2\2\u0ceb\u0cec\3\2\2\2\u0cec\u0cea\3\2\2\2\u0cec\u0ced\3\2\2\2\u0ced"+ - "\u012f\3\2\2\2\u0cee\u0cf7\5\u0136\u009c\2\u0cef\u0cf7\5\u0138\u009d\2"+ - "\u0cf0\u0cf7\5\u013a\u009e\2\u0cf1\u0cf7\5\u0142\u00a2\2\u0cf2\u0cf7\5"+ - "\u0144\u00a3\2\u0cf3\u0cf7\5\u0146\u00a4\2\u0cf4\u0cf7\5\u0148\u00a5\2"+ - "\u0cf5\u0cf7\5\u014c\u00a7\2\u0cf6\u0cee\3\2\2\2\u0cf6\u0cef\3\2\2\2\u0cf6"+ - "\u0cf0\3\2\2\2\u0cf6\u0cf1\3\2\2\2\u0cf6\u0cf2\3\2\2\2\u0cf6\u0cf3\3\2"+ - "\2\2\u0cf6\u0cf4\3\2\2\2\u0cf6\u0cf5\3\2\2\2\u0cf7\u0cfb\3\2\2\2\u0cf8"+ - "\u0cfa\7\7\2\2\u0cf9\u0cf8\3\2\2\2\u0cfa\u0cfd\3\2\2\2\u0cfb\u0cf9\3\2"+ - "\2\2\u0cfb\u0cfc\3\2\2\2\u0cfc\u0131\3\2\2\2\u0cfd\u0cfb\3\2\2\2\u0cfe"+ - "\u0d00\5\u0134\u009b\2\u0cff\u0cfe\3\2\2\2\u0d00\u0d01\3\2\2\2\u0d01\u0cff"+ - "\3\2\2\2\u0d01\u0d02\3\2\2\2\u0d02\u0133\3\2\2\2\u0d03\u0d0c\5\u014e\u00a8"+ - "\2\u0d04\u0d08\7|\2\2\u0d05\u0d07\7\7\2\2\u0d06\u0d05\3\2\2\2\u0d07\u0d0a"+ - "\3\2\2\2\u0d08\u0d06\3\2\2\2\u0d08\u0d09\3\2\2\2\u0d09\u0d0c\3\2\2\2\u0d0a"+ - "\u0d08\3\2\2\2\u0d0b\u0d03\3\2\2\2\u0d0b\u0d04\3\2\2\2\u0d0c\u0135\3\2"+ - "\2\2\u0d0d\u0d0e\t\26\2\2\u0d0e\u0137\3\2\2\2\u0d0f\u0d10\t\27\2\2\u0d10"+ - "\u0139\3\2\2\2\u0d11\u0d12\t\30\2\2\u0d12\u013b\3\2\2\2\u0d13\u0d14\t"+ - "\31\2\2\u0d14\u013d\3\2\2\2\u0d15\u0d17\5\u0140\u00a1\2\u0d16\u0d15\3"+ - "\2\2\2\u0d17\u0d18\3\2\2\2\u0d18\u0d16\3\2\2\2\u0d18\u0d19\3\2\2\2\u0d19"+ - "\u013f\3\2\2\2\u0d1a\u0d1e\5\u014a\u00a6\2\u0d1b\u0d1d\7\7\2\2\u0d1c\u0d1b"+ - "\3\2\2\2\u0d1d\u0d20\3\2\2\2\u0d1e\u0d1c\3\2\2\2\u0d1e\u0d1f\3\2\2\2\u0d1f"+ - "\u0d2a\3\2\2\2\u0d20\u0d1e\3\2\2\2\u0d21\u0d25\5\u013c\u009f\2\u0d22\u0d24"+ - "\7\7\2\2\u0d23\u0d22\3\2\2\2\u0d24\u0d27\3\2\2\2\u0d25\u0d23\3\2\2\2\u0d25"+ - "\u0d26\3\2\2\2\u0d26\u0d2a\3\2\2\2\u0d27\u0d25\3\2\2\2\u0d28\u0d2a\5\u014e"+ - "\u00a8\2\u0d29\u0d1a\3\2\2\2\u0d29\u0d21\3\2\2\2\u0d29\u0d28\3\2\2\2\u0d2a"+ - "\u0141\3\2\2\2\u0d2b\u0d2c\t\32\2\2\u0d2c\u0143\3\2\2\2\u0d2d\u0d2e\7"+ - "\u0081\2\2\u0d2e\u0145\3\2\2\2\u0d2f\u0d30\t\33\2\2\u0d30\u0147\3\2\2"+ - "\2\u0d31\u0d32\t\34\2\2\u0d32\u0149\3\2\2\2\u0d33\u0d34\7\u0086\2\2\u0d34"+ - "\u014b\3\2\2\2\u0d35\u0d36\t\35\2\2\u0d36\u014d\3\2\2\2\u0d37\u0d3a\5"+ - "\u0150\u00a9\2\u0d38\u0d3a\5\u0152\u00aa\2\u0d39\u0d37\3\2\2\2\u0d39\u0d38"+ - "\3\2\2\2\u0d3a\u0d3e\3\2\2\2\u0d3b\u0d3d\7\7\2\2\u0d3c\u0d3b\3\2\2\2\u0d3d"+ - "\u0d40\3\2\2\2\u0d3e\u0d3c\3\2\2\2\u0d3e\u0d3f\3\2\2\2\u0d3f\u014f\3\2"+ - "\2\2\u0d40\u0d3e\3\2\2\2\u0d41\u0d45\5\u0154\u00ab\2\u0d42\u0d44\7\7\2"+ - "\2\u0d43\u0d42\3\2\2\2\u0d44\u0d47\3\2\2\2\u0d45\u0d43\3\2\2\2\u0d45\u0d46"+ - "\3\2\2\2\u0d46\u0d4b\3\2\2\2\u0d47\u0d45\3\2\2\2\u0d48\u0d4b\7*\2\2\u0d49"+ - "\u0d4b\7,\2\2\u0d4a\u0d41\3\2\2\2\u0d4a\u0d48\3\2\2\2\u0d4a\u0d49\3\2"+ - "\2\2\u0d4b\u0d4c\3\2\2\2\u0d4c\u0d4d\5\u0156\u00ac\2\u0d4d\u0151\3\2\2"+ - "\2\u0d4e\u0d52\5\u0154\u00ab\2\u0d4f\u0d51\7\7\2\2\u0d50\u0d4f\3\2\2\2"+ - "\u0d51\u0d54\3\2\2\2\u0d52\u0d50\3\2\2\2\u0d52\u0d53\3\2\2\2\u0d53\u0d58"+ - "\3\2\2\2\u0d54\u0d52\3\2\2\2\u0d55\u0d58\7*\2\2\u0d56\u0d58\7,\2\2\u0d57"+ - "\u0d4e\3\2\2\2\u0d57\u0d55\3\2\2\2\u0d57\u0d56\3\2\2\2\u0d58\u0d59\3\2"+ - "\2\2\u0d59\u0d5b\7\r\2\2\u0d5a\u0d5c\5\u0156\u00ac\2\u0d5b\u0d5a\3\2\2"+ - "\2\u0d5c\u0d5d\3\2\2\2\u0d5d\u0d5b\3\2\2\2\u0d5d\u0d5e\3\2\2\2\u0d5e\u0d5f"+ - "\3\2\2\2\u0d5f\u0d60\7\16\2\2\u0d60\u0153\3\2\2\2\u0d61\u0d62\t\2\2\2"+ - "\u0d62\u0d66\t\36\2\2\u0d63\u0d65\7\7\2\2\u0d64\u0d63\3\2\2\2\u0d65\u0d68"+ - "\3\2\2\2\u0d66\u0d64\3\2\2\2\u0d66\u0d67\3\2\2\2\u0d67\u0d69\3\2\2\2\u0d68"+ - "\u0d66\3\2\2\2\u0d69\u0d6a\7\34\2\2\u0d6a\u0155\3\2\2\2\u0d6b\u0d6e\5"+ - "&\24\2\u0d6c\u0d6e\5l\67\2\u0d6d\u0d6b\3\2\2\2\u0d6d\u0d6c\3\2\2\2\u0d6e"+ - "\u0157\3\2\2\2\u0d6f\u0d70\t\37\2\2\u0d70\u0159\3\2\2\2\u0d71\u0d7c\5"+ - "\u0158\u00ad\2\u0d72\u0d74\7\7\2\2\u0d73\u0d72\3\2\2\2\u0d74\u0d77\3\2"+ - "\2\2\u0d75\u0d73\3\2\2\2\u0d75\u0d76\3\2\2\2\u0d76\u0d78\3\2\2\2\u0d77"+ - "\u0d75\3\2\2\2\u0d78\u0d79\7\t\2\2\u0d79\u0d7b\5\u0158\u00ad\2\u0d7a\u0d75"+ - "\3\2\2\2\u0d7b\u0d7e\3\2\2\2\u0d7c\u0d7a\3\2\2\2\u0d7c\u0d7d\3\2\2\2\u0d7d"+ - "\u015b\3\2\2\2\u0d7e\u0d7c\3\2\2\2\u0214\u015d\u0162\u0168\u0170\u0176"+ - "\u017b\u0181\u018b\u0194\u019b\u01a2\u01a9\u01ae\u01b3\u01b9\u01bb\u01c0"+ - "\u01c8\u01cb\u01d2\u01d5\u01db\u01e2\u01e6\u01eb\u01f2\u01fc\u01ff\u0206"+ - "\u0209\u020c\u0211\u0218\u021c\u0221\u0225\u022a\u0231\u0235\u023a\u023e"+ - "\u0243\u024a\u024e\u0251\u0257\u025a\u0262\u0269\u0272\u0279\u0280\u0286"+ - "\u028c\u0290\u0292\u0297\u029d\u02a0\u02a5\u02ad\u02b4\u02bb\u02bf\u02c5"+ - "\u02cc\u02d2\u02d9\u02e1\u02e7\u02ee\u02f3\u02fa\u0303\u030a\u0311\u0317"+ - "\u031d\u0321\u0326\u032c\u0331\u0338\u033f\u0343\u0349\u0350\u0357\u035d"+ - "\u0363\u036a\u0371\u0378\u037c\u0383\u0389\u038f\u0395\u039c\u03a0\u03a5"+ - "\u03ac\u03b0\u03b5\u03b9\u03bf\u03c6\u03cd\u03d3\u03d9\u03dd\u03df\u03e4"+ - "\u03ea\u03f0\u03f7\u03fb\u03fe\u0404\u0408\u040d\u0414\u0419\u041e\u0425"+ - "\u042c\u0433\u0437\u043c\u0440\u0445\u0449\u0450\u0454\u0459\u045f\u0466"+ - "\u046d\u0471\u0477\u047e\u0485\u048b\u0491\u0495\u049a\u04a0\u04a6\u04aa"+ - "\u04af\u04b6\u04bb\u04c0\u04c5\u04ca\u04ce\u04d3\u04da\u04df\u04e1\u04e6"+ - "\u04e9\u04ee\u04f2\u04f7\u04fb\u04fe\u0501\u0506\u050a\u050d\u050f\u0515"+ - "\u051b\u0521\u0528\u052f\u0536\u053a\u053f\u0543\u0546\u054c\u0553\u055a"+ - "\u055e\u0563\u056a\u0571\u0575\u057a\u057f\u0585\u058c\u0593\u0599\u059f"+ - "\u05a3\u05a5\u05aa\u05b0\u05b6\u05bd\u05c1\u05c7\u05ce\u05d2\u05d8\u05df"+ - "\u05e5\u05eb\u05f2\u05f9\u05fd\u0602\u0606\u0609\u060f\u0616\u061d\u0621"+ - "\u0626\u062a\u0630\u0639\u063d\u0642\u0649\u064d\u0652\u065b\u0662\u0668"+ - "\u066e\u0672\u0678\u067b\u0681\u0685\u068a\u068e\u0691\u0697\u069b\u069f"+ - "\u06a4\u06aa\u06b2\u06b9\u06bf\u06c6\u06ca\u06cd\u06d1\u06d6\u06dc\u06e0"+ - "\u06e6\u06ed\u06f0\u06f6\u06fd\u0706\u070b\u0710\u0717\u071c\u0720\u0726"+ - "\u072a\u072f\u0738\u073f\u0745\u074a\u0750\u0755\u075a\u0765\u0768\u076b"+ - "\u076f\u0771\u0778\u077f\u0784\u078a\u0791\u0799\u079f\u07a6\u07ab\u07b3"+ - "\u07b7\u07bd\u07c6\u07cb\u07d1\u07d5\u07da\u07e1\u07ee\u07f3\u07fc\u0800"+ - "\u0805\u0808\u0810\u0817\u081d\u0824\u082b\u0831\u0839\u0840\u0848\u084f"+ - "\u0856\u085e\u0867\u086c\u086e\u0875\u087c\u0883\u088e\u0895\u089d\u08a3"+ - "\u08ab\u08b2\u08ba\u08c1\u08c8\u08cf\u08d6\u08dc\u08e7\u08ea\u08f0\u08f8"+ - "\u08ff\u0905\u090c\u0913\u0919\u0920\u0928\u092e\u0935\u093c\u0942\u0948"+ - "\u094c\u0951\u095a\u0960\u0963\u0966\u096a\u096f\u0973\u0978\u0981\u0988"+ - "\u098f\u0995\u099b\u099f\u09a4\u09ad\u09b4\u09bb\u09c1\u09c7\u09cb\u09d0"+ - "\u09d3\u09d8\u09dd\u09e4\u09eb\u09ee\u09f1\u09f6\u0a09\u0a0f\u0a16\u0a1f"+ - "\u0a26\u0a2d\u0a33\u0a39\u0a3d\u0a42\u0a45\u0a4d\u0a52\u0a54\u0a5d\u0a5f"+ - "\u0a6a\u0a71\u0a7c\u0a83\u0a8c\u0a90\u0a95\u0a9c\u0a9f\u0aa5\u0aae\u0ab5"+ - "\u0abb\u0ac1\u0ac5\u0acc\u0ad3\u0ad7\u0ad9\u0adf\u0ae6\u0aeb\u0af0\u0af7"+ - "\u0afe\u0b02\u0b07\u0b0b\u0b10\u0b14\u0b18\u0b1e\u0b25\u0b2c\u0b2f\u0b34"+ - "\u0b38\u0b41\u0b48\u0b4d\u0b51\u0b54\u0b5a\u0b61\u0b68\u0b6f\u0b74\u0b79"+ - "\u0b7d\u0b82\u0b89\u0b8e\u0b91\u0b97\u0b9d\u0ba4\u0bab\u0bb2\u0bb5\u0bbe"+ - "\u0bc2\u0bc7\u0bce\u0bd5\u0bda\u0be0\u0be9\u0bf0\u0bf6\u0bfc\u0c00\u0c05"+ - "\u0c0c\u0c11\u0c17\u0c1e\u0c23\u0c25\u0c2a\u0c30\u0c39\u0c42\u0c49\u0c4f"+ - "\u0c54\u0c58\u0c5d\u0c61\u0c67\u0c6e\u0c77\u0c7b\u0c81\u0c8a\u0c93\u0c99"+ - "\u0c9f\u0ca2\u0ca8\u0cad\u0cc4\u0cca\u0cd1\u0cd8\u0cdd\u0ce4\u0ce6\u0cea"+ - "\u0cec\u0cf6\u0cfb\u0d01\u0d08\u0d0b\u0d18\u0d1e\u0d25\u0d29\u0d39\u0d3e"+ - "\u0d45\u0d4a\u0d52\u0d57\u0d5d\u0d66\u0d6d\u0d75\u0d7c"; - public static final String _serializedATN = Utils.join( - new String[] { - _serializedATNSegment0, - _serializedATNSegment1 - }, - "" - ); - 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 + public static final int ShebangLine = 1, + DelimitedComment = 2, + LineComment = 3, + WS = 4, + NL = 5, + RESERVED = 6, + DOT = 7, + COMMA = 8, + LPAREN = 9, + RPAREN = 10, + LSQUARE = 11, + RSQUARE = 12, + LCURL = 13, + RCURL = 14, + MULT = 15, + MOD = 16, + DIV = 17, + ADD = 18, + SUB = 19, + INCR = 20, + DECR = 21, + CONJ = 22, + DISJ = 23, + EXCL_WS = 24, + EXCL_NO_WS = 25, + COLON = 26, + SEMICOLON = 27, + ASSIGNMENT = 28, + ADD_ASSIGNMENT = 29, + SUB_ASSIGNMENT = 30, + MULT_ASSIGNMENT = 31, + DIV_ASSIGNMENT = 32, + MOD_ASSIGNMENT = 33, + ARROW = 34, + DOUBLE_ARROW = 35, + RANGE = 36, + COLONCOLON = 37, + DOUBLE_SEMICOLON = 38, + HASH = 39, + AT_NO_WS = 40, + AT_POST_WS = 41, + AT_PRE_WS = 42, + AT_BOTH_WS = 43, + QUEST_WS = 44, + QUEST_NO_WS = 45, + LANGLE = 46, + RANGLE = 47, + LE = 48, + GE = 49, + EXCL_EQ = 50, + EXCL_EQEQ = 51, + AS_SAFE = 52, + EQEQ = 53, + EQEQEQ = 54, + SINGLE_QUOTE = 55, + RETURN_AT = 56, + CONTINUE_AT = 57, + BREAK_AT = 58, + THIS_AT = 59, + SUPER_AT = 60, + FILE = 61, + FIELD = 62, + PROPERTY = 63, + GET = 64, + SET = 65, + RECEIVER = 66, + PARAM = 67, + SETPARAM = 68, + DELEGATE = 69, + PACKAGE = 70, + IMPORT = 71, + CLASS = 72, + INTERFACE = 73, + FUN = 74, + OBJECT = 75, + VAL = 76, + VAR = 77, + TYPE_ALIAS = 78, + CONSTRUCTOR = 79, + BY = 80, + COMPANION = 81, + INIT = 82, + THIS = 83, + SUPER = 84, + TYPEOF = 85, + WHERE = 86, + IF = 87, + ELSE = 88, + WHEN = 89, + TRY = 90, + CATCH = 91, + FINALLY = 92, + FOR = 93, + DO = 94, + WHILE = 95, + THROW = 96, + RETURN = 97, + CONTINUE = 98, + BREAK = 99, + AS = 100, + IS = 101, + IN = 102, + NOT_IS = 103, + NOT_IN = 104, + OUT = 105, + DYNAMIC = 106, + PUBLIC = 107, + PRIVATE = 108, + PROTECTED = 109, + INTERNAL = 110, + ENUM = 111, + SEALED = 112, + ANNOTATION = 113, + DATA = 114, + INNER = 115, + VALUE = 116, + TAILREC = 117, + OPERATOR = 118, + INLINE = 119, + INFIX = 120, + EXTERNAL = 121, + SUSPEND = 122, + OVERRIDE = 123, + ABSTRACT = 124, + FINAL = 125, + OPEN = 126, + CONST = 127, + LATEINIT = 128, + VARARG = 129, + NOINLINE = 130, + CROSSINLINE = 131, + REIFIED = 132, + EXPECT = 133, + ACTUAL = 134, + RealLiteral = 135, + FloatLiteral = 136, + DoubleLiteral = 137, + IntegerLiteral = 138, + HexLiteral = 139, + BinLiteral = 140, + UnsignedLiteral = 141, + LongLiteral = 142, + BooleanLiteral = 143, + NullLiteral = 144, + CharacterLiteral = 145, + Identifier = 146, + IdentifierOrSoftKey = 147, + FieldIdentifier = 148, + QUOTE_OPEN = 149, + TRIPLE_QUOTE_OPEN = 150, + UNICODE_CLASS_LL = 151, + UNICODE_CLASS_LM = 152, + UNICODE_CLASS_LO = 153, + UNICODE_CLASS_LT = 154, + UNICODE_CLASS_LU = 155, + UNICODE_CLASS_ND = 156, + UNICODE_CLASS_NL = 157, + QUOTE_CLOSE = 158, + LineStrRef = 159, + LineStrText = 160, + LineStrEscapedChar = 161, + LineStrExprStart = 162, + TRIPLE_QUOTE_CLOSE = 163, + MultiLineStringQuote = 164, + MultiLineStrRef = 165, + MultiLineStrText = 166, + MultiLineStrExprStart = 167, + Inside_Comment = 168, + Inside_WS = 169, + Inside_NL = 170, + ErrorCharacter = 171; + public static final int RULE_kotlinFile = 0, + RULE_script = 1, + RULE_shebangLine = 2, + RULE_fileAnnotation = 3, + RULE_packageHeader = 4, + RULE_importList = 5, + RULE_importHeader = 6, + RULE_importAlias = 7, + RULE_topLevelObject = 8, + RULE_typeAlias = 9, + RULE_declaration = 10, + RULE_classDeclaration = 11, + RULE_primaryConstructor = 12, + RULE_classBody = 13, + RULE_classParameters = 14, + RULE_classParameter = 15, + RULE_delegationSpecifiers = 16, + RULE_delegationSpecifier = 17, + RULE_constructorInvocation = 18, + RULE_annotatedDelegationSpecifier = 19, + RULE_explicitDelegation = 20, + RULE_typeParameters = 21, + RULE_typeParameter = 22, + RULE_typeConstraints = 23, + RULE_typeConstraint = 24, + RULE_classMemberDeclarations = 25, + RULE_classMemberDeclaration = 26, + RULE_anonymousInitializer = 27, + RULE_companionObject = 28, + RULE_functionValueParameters = 29, + RULE_functionValueParameter = 30, + RULE_functionDeclaration = 31, + RULE_functionBody = 32, + RULE_variableDeclaration = 33, + RULE_multiVariableDeclaration = 34, + RULE_propertyDeclaration = 35, + RULE_propertyDelegate = 36, + RULE_getter = 37, + RULE_setter = 38, + RULE_parametersWithOptionalType = 39, + RULE_functionValueParameterWithOptionalType = 40, + RULE_parameterWithOptionalType = 41, + RULE_parameter = 42, + RULE_objectDeclaration = 43, + RULE_secondaryConstructor = 44, + RULE_constructorDelegationCall = 45, + RULE_enumClassBody = 46, + RULE_enumEntries = 47, + RULE_enumEntry = 48, + RULE_type = 49, + RULE_typeReference = 50, + RULE_nullableType = 51, + RULE_quest = 52, + RULE_userType = 53, + RULE_simpleUserType = 54, + RULE_typeProjection = 55, + RULE_typeProjectionModifiers = 56, + RULE_typeProjectionModifier = 57, + RULE_functionType = 58, + RULE_functionTypeParameters = 59, + RULE_parenthesizedType = 60, + RULE_receiverType = 61, + RULE_parenthesizedUserType = 62, + RULE_statements = 63, + RULE_statement = 64, + RULE_label = 65, + RULE_controlStructureBody = 66, + RULE_block = 67, + RULE_loopStatement = 68, + RULE_forStatement = 69, + RULE_whileStatement = 70, + RULE_doWhileStatement = 71, + RULE_assignment = 72, + RULE_semi = 73, + RULE_semis = 74, + RULE_expression = 75, + RULE_disjunction = 76, + RULE_conjunction = 77, + RULE_equality = 78, + RULE_comparison = 79, + RULE_genericCallLikeComparison = 80, + RULE_infixOperation = 81, + RULE_elvisExpression = 82, + RULE_elvis = 83, + RULE_infixFunctionCall = 84, + RULE_rangeExpression = 85, + RULE_additiveExpression = 86, + RULE_multiplicativeExpression = 87, + RULE_asExpression = 88, + RULE_prefixUnaryExpression = 89, + RULE_unaryPrefix = 90, + RULE_postfixUnaryExpression = 91, + RULE_postfixUnarySuffix = 92, + RULE_directlyAssignableExpression = 93, + RULE_parenthesizedDirectlyAssignableExpression = 94, + RULE_assignableExpression = 95, + RULE_parenthesizedAssignableExpression = 96, + RULE_assignableSuffix = 97, + RULE_indexingSuffix = 98, + RULE_navigationSuffix = 99, + RULE_callSuffix = 100, + RULE_annotatedLambda = 101, + RULE_typeArguments = 102, + RULE_valueArguments = 103, + RULE_valueArgument = 104, + RULE_primaryExpression = 105, + RULE_parenthesizedExpression = 106, + RULE_collectionLiteral = 107, + RULE_literalConstant = 108, + RULE_stringLiteral = 109, + RULE_lineStringLiteral = 110, + RULE_multiLineStringLiteral = 111, + RULE_lineStringContent = 112, + RULE_lineStringExpression = 113, + RULE_multiLineStringContent = 114, + RULE_multiLineStringExpression = 115, + RULE_lambdaLiteral = 116, + RULE_lambdaParameters = 117, + RULE_lambdaParameter = 118, + RULE_anonymousFunction = 119, + RULE_functionLiteral = 120, + RULE_objectLiteral = 121, + RULE_thisExpression = 122, + RULE_superExpression = 123, + RULE_ifExpression = 124, + RULE_whenSubject = 125, + RULE_whenExpression = 126, + RULE_whenEntry = 127, + RULE_whenCondition = 128, + RULE_rangeTest = 129, + RULE_typeTest = 130, + RULE_tryExpression = 131, + RULE_catchBlock = 132, + RULE_finallyBlock = 133, + RULE_jumpExpression = 134, + RULE_callableReference = 135, + RULE_assignmentAndOperator = 136, + RULE_equalityOperator = 137, + RULE_comparisonOperator = 138, + RULE_inOperator = 139, + RULE_isOperator = 140, + RULE_additiveOperator = 141, + RULE_multiplicativeOperator = 142, + RULE_asOperator = 143, + RULE_prefixUnaryOperator = 144, + RULE_postfixUnaryOperator = 145, + RULE_excl = 146, + RULE_memberAccessOperator = 147, + RULE_safeNav = 148, + RULE_modifiers = 149, + RULE_parameterModifiers = 150, + RULE_modifier = 151, + RULE_typeModifiers = 152, + RULE_typeModifier = 153, + RULE_classModifier = 154, + RULE_memberModifier = 155, + RULE_visibilityModifier = 156, + RULE_varianceModifier = 157, + RULE_typeParameterModifiers = 158, + RULE_typeParameterModifier = 159, + RULE_functionModifier = 160, + RULE_propertyModifier = 161, + RULE_inheritanceModifier = 162, + RULE_parameterModifier = 163, + RULE_reificationModifier = 164, + RULE_platformModifier = 165, + RULE_annotation = 166, + RULE_singleAnnotation = 167, + RULE_multiAnnotation = 168, + RULE_annotationUseSiteTarget = 169, + RULE_unescapedAnnotation = 170, + RULE_simpleIdentifier = 171, + RULE_identifier = 172; + public static final String[] ruleNames = makeRuleNames(); + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated public static final String[] tokenNames; + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache(); + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + private static final int _serializedATNSegments = 2; + private static final String _serializedATNSegment0 = + "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\u00ad\u0d80\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\3\2\5\2\u015e\n\2\3\2\7\2\u0161\n\2\f\2\16\2\u0164\13" + + "\2\3\2\7\2\u0167\n\2\f\2\16\2\u016a\13\2\3\2\3\2\3\2\7\2\u016f\n\2\f\2" + + "\16\2\u0172\13\2\3\2\3\2\3\3\5\3\u0177\n\3\3\3\7\3\u017a\n\3\f\3\16\3" + + "\u017d\13\3\3\3\7\3\u0180\n\3\f\3\16\3\u0183\13\3\3\3\3\3\3\3\3\3\3\3" + + "\7\3\u018a\n\3\f\3\16\3\u018d\13\3\3\3\3\3\3\4\3\4\6\4\u0193\n\4\r\4\16" + + "\4\u0194\3\5\3\5\3\5\7\5\u019a\n\5\f\5\16\5\u019d\13\5\3\5\3\5\7\5\u01a1" + + "\n\5\f\5\16\5\u01a4\13\5\3\5\3\5\6\5\u01a8\n\5\r\5\16\5\u01a9\3\5\3\5" + + "\3\5\5\5\u01af\n\5\3\5\7\5\u01b2\n\5\f\5\16\5\u01b5\13\5\3\6\3\6\3\6\5" + + "\6\u01ba\n\6\5\6\u01bc\n\6\3\7\7\7\u01bf\n\7\f\7\16\7\u01c2\13\7\3\b\3" + + "\b\3\b\3\b\3\b\5\b\u01c9\n\b\3\b\5\b\u01cc\n\b\3\t\3\t\3\t\3\n\3\n\5\n" + + "\u01d3\n\n\3\13\5\13\u01d6\n\13\3\13\3\13\7\13\u01da\n\13\f\13\16\13\u01dd" + + "\13\13\3\13\3\13\7\13\u01e1\n\13\f\13\16\13\u01e4\13\13\3\13\5\13\u01e7" + + "\n\13\3\13\7\13\u01ea\n\13\f\13\16\13\u01ed\13\13\3\13\3\13\7\13\u01f1" + + "\n\13\f\13\16\13\u01f4\13\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\5\f\u01fd\n" + + "\f\3\r\5\r\u0200\n\r\3\r\3\r\3\r\7\r\u0205\n\r\f\r\16\r\u0208\13\r\5\r" + + "\u020a\n\r\3\r\5\r\u020d\n\r\3\r\7\r\u0210\n\r\f\r\16\r\u0213\13\r\3\r" + + "\3\r\7\r\u0217\n\r\f\r\16\r\u021a\13\r\3\r\5\r\u021d\n\r\3\r\7\r\u0220" + + "\n\r\f\r\16\r\u0223\13\r\3\r\5\r\u0226\n\r\3\r\7\r\u0229\n\r\f\r\16\r" + + "\u022c\13\r\3\r\3\r\7\r\u0230\n\r\f\r\16\r\u0233\13\r\3\r\5\r\u0236\n" + + "\r\3\r\7\r\u0239\n\r\f\r\16\r\u023c\13\r\3\r\5\r\u023f\n\r\3\r\7\r\u0242" + + "\n\r\f\r\16\r\u0245\13\r\3\r\3\r\7\r\u0249\n\r\f\r\16\r\u024c\13\r\3\r" + + "\5\r\u024f\n\r\3\16\5\16\u0252\n\16\3\16\3\16\7\16\u0256\n\16\f\16\16" + + "\16\u0259\13\16\5\16\u025b\n\16\3\16\3\16\3\17\3\17\7\17\u0261\n\17\f" + + "\17\16\17\u0264\13\17\3\17\3\17\7\17\u0268\n\17\f\17\16\17\u026b\13\17" + + "\3\17\3\17\3\20\3\20\7\20\u0271\n\20\f\20\16\20\u0274\13\20\3\20\3\20" + + "\7\20\u0278\n\20\f\20\16\20\u027b\13\20\3\20\3\20\7\20\u027f\n\20\f\20" + + "\16\20\u0282\13\20\3\20\7\20\u0285\n\20\f\20\16\20\u0288\13\20\3\20\7" + + "\20\u028b\n\20\f\20\16\20\u028e\13\20\3\20\5\20\u0291\n\20\5\20\u0293" + + "\n\20\3\20\7\20\u0296\n\20\f\20\16\20\u0299\13\20\3\20\3\20\3\21\5\21" + + "\u029e\n\21\3\21\5\21\u02a1\n\21\3\21\7\21\u02a4\n\21\f\21\16\21\u02a7" + + "\13\21\3\21\3\21\3\21\7\21\u02ac\n\21\f\21\16\21\u02af\13\21\3\21\3\21" + + "\7\21\u02b3\n\21\f\21\16\21\u02b6\13\21\3\21\3\21\7\21\u02ba\n\21\f\21" + + "\16\21\u02bd\13\21\3\21\5\21\u02c0\n\21\3\22\3\22\7\22\u02c4\n\22\f\22" + + "\16\22\u02c7\13\22\3\22\3\22\7\22\u02cb\n\22\f\22\16\22\u02ce\13\22\3" + + "\22\7\22\u02d1\n\22\f\22\16\22\u02d4\13\22\3\23\3\23\3\23\3\23\5\23\u02da" + + "\n\23\3\24\3\24\3\24\3\25\7\25\u02e0\n\25\f\25\16\25\u02e3\13\25\3\25" + + "\7\25\u02e6\n\25\f\25\16\25\u02e9\13\25\3\25\3\25\3\26\3\26\5\26\u02ef" + + "\n\26\3\26\7\26\u02f2\n\26\f\26\16\26\u02f5\13\26\3\26\3\26\7\26\u02f9" + + "\n\26\f\26\16\26\u02fc\13\26\3\26\3\26\3\27\3\27\7\27\u0302\n\27\f\27" + + "\16\27\u0305\13\27\3\27\3\27\7\27\u0309\n\27\f\27\16\27\u030c\13\27\3" + + "\27\3\27\7\27\u0310\n\27\f\27\16\27\u0313\13\27\3\27\7\27\u0316\n\27\f" + + "\27\16\27\u0319\13\27\3\27\7\27\u031c\n\27\f\27\16\27\u031f\13\27\3\27" + + "\5\27\u0322\n\27\3\27\7\27\u0325\n\27\f\27\16\27\u0328\13\27\3\27\3\27" + + "\3\30\5\30\u032d\n\30\3\30\7\30\u0330\n\30\f\30\16\30\u0333\13\30\3\30" + + "\3\30\7\30\u0337\n\30\f\30\16\30\u033a\13\30\3\30\3\30\7\30\u033e\n\30" + + "\f\30\16\30\u0341\13\30\3\30\5\30\u0344\n\30\3\31\3\31\7\31\u0348\n\31" + + "\f\31\16\31\u034b\13\31\3\31\3\31\7\31\u034f\n\31\f\31\16\31\u0352\13" + + "\31\3\31\3\31\7\31\u0356\n\31\f\31\16\31\u0359\13\31\3\31\7\31\u035c\n" + + "\31\f\31\16\31\u035f\13\31\3\32\7\32\u0362\n\32\f\32\16\32\u0365\13\32" + + "\3\32\3\32\7\32\u0369\n\32\f\32\16\32\u036c\13\32\3\32\3\32\7\32\u0370" + + "\n\32\f\32\16\32\u0373\13\32\3\32\3\32\3\33\3\33\5\33\u0379\n\33\7\33" + + "\u037b\n\33\f\33\16\33\u037e\13\33\3\34\3\34\3\34\3\34\5\34\u0384\n\34" + + "\3\35\3\35\7\35\u0388\n\35\f\35\16\35\u038b\13\35\3\35\3\35\3\36\5\36" + + "\u0390\n\36\3\36\3\36\7\36\u0394\n\36\f\36\16\36\u0397\13\36\3\36\3\36" + + "\7\36\u039b\n\36\f\36\16\36\u039e\13\36\3\36\5\36\u03a1\n\36\3\36\7\36" + + "\u03a4\n\36\f\36\16\36\u03a7\13\36\3\36\3\36\7\36\u03ab\n\36\f\36\16\36" + + "\u03ae\13\36\3\36\5\36\u03b1\n\36\3\36\7\36\u03b4\n\36\f\36\16\36\u03b7" + + "\13\36\3\36\5\36\u03ba\n\36\3\37\3\37\7\37\u03be\n\37\f\37\16\37\u03c1" + + "\13\37\3\37\3\37\7\37\u03c5\n\37\f\37\16\37\u03c8\13\37\3\37\3\37\7\37" + + "\u03cc\n\37\f\37\16\37\u03cf\13\37\3\37\7\37\u03d2\n\37\f\37\16\37\u03d5" + + "\13\37\3\37\7\37\u03d8\n\37\f\37\16\37\u03db\13\37\3\37\5\37\u03de\n\37" + + "\5\37\u03e0\n\37\3\37\7\37\u03e3\n\37\f\37\16\37\u03e6\13\37\3\37\3\37" + + "\3 \5 \u03eb\n \3 \3 \7 \u03ef\n \f \16 \u03f2\13 \3 \3 \7 \u03f6\n \f" + + " \16 \u03f9\13 \3 \5 \u03fc\n \3!\5!\u03ff\n!\3!\3!\7!\u0403\n!\f!\16" + + "!\u0406\13!\3!\5!\u0409\n!\3!\7!\u040c\n!\f!\16!\u040f\13!\3!\3!\7!\u0413" + + "\n!\f!\16!\u0416\13!\3!\3!\5!\u041a\n!\3!\7!\u041d\n!\f!\16!\u0420\13" + + "!\3!\3!\7!\u0424\n!\f!\16!\u0427\13!\3!\3!\7!\u042b\n!\f!\16!\u042e\13" + + "!\3!\3!\7!\u0432\n!\f!\16!\u0435\13!\3!\5!\u0438\n!\3!\7!\u043b\n!\f!" + + "\16!\u043e\13!\3!\5!\u0441\n!\3!\7!\u0444\n!\f!\16!\u0447\13!\3!\5!\u044a" + + "\n!\3\"\3\"\3\"\7\"\u044f\n\"\f\"\16\"\u0452\13\"\3\"\5\"\u0455\n\"\3" + + "#\7#\u0458\n#\f#\16#\u045b\13#\3#\7#\u045e\n#\f#\16#\u0461\13#\3#\3#\7" + + "#\u0465\n#\f#\16#\u0468\13#\3#\3#\7#\u046c\n#\f#\16#\u046f\13#\3#\5#\u0472" + + "\n#\3$\3$\7$\u0476\n$\f$\16$\u0479\13$\3$\3$\7$\u047d\n$\f$\16$\u0480" + + "\13$\3$\3$\7$\u0484\n$\f$\16$\u0487\13$\3$\7$\u048a\n$\f$\16$\u048d\13" + + "$\3$\7$\u0490\n$\f$\16$\u0493\13$\3$\5$\u0496\n$\3$\7$\u0499\n$\f$\16" + + "$\u049c\13$\3$\3$\3%\5%\u04a1\n%\3%\3%\7%\u04a5\n%\f%\16%\u04a8\13%\3" + + "%\5%\u04ab\n%\3%\7%\u04ae\n%\f%\16%\u04b1\13%\3%\3%\7%\u04b5\n%\f%\16" + + "%\u04b8\13%\3%\3%\5%\u04bc\n%\3%\7%\u04bf\n%\f%\16%\u04c2\13%\3%\3%\5" + + "%\u04c6\n%\3%\7%\u04c9\n%\f%\16%\u04cc\13%\3%\5%\u04cf\n%\3%\7%\u04d2" + + "\n%\f%\16%\u04d5\13%\3%\3%\7%\u04d9\n%\f%\16%\u04dc\13%\3%\3%\5%\u04e0" + + "\n%\5%\u04e2\n%\3%\6%\u04e5\n%\r%\16%\u04e6\3%\5%\u04ea\n%\3%\7%\u04ed" + + "\n%\f%\16%\u04f0\13%\3%\5%\u04f3\n%\3%\7%\u04f6\n%\f%\16%\u04f9\13%\3" + + "%\5%\u04fc\n%\3%\5%\u04ff\n%\3%\5%\u0502\n%\3%\7%\u0505\n%\f%\16%\u0508" + + "\13%\3%\5%\u050b\n%\3%\5%\u050e\n%\5%\u0510\n%\3&\3&\7&\u0514\n&\f&\16" + + "&\u0517\13&\3&\3&\3\'\5\'\u051c\n\'\3\'\3\'\7\'\u0520\n\'\f\'\16\'\u0523" + + "\13\'\3\'\3\'\7\'\u0527\n\'\f\'\16\'\u052a\13\'\3\'\3\'\7\'\u052e\n\'" + + "\f\'\16\'\u0531\13\'\3\'\3\'\7\'\u0535\n\'\f\'\16\'\u0538\13\'\3\'\5\'" + + "\u053b\n\'\3\'\7\'\u053e\n\'\f\'\16\'\u0541\13\'\3\'\5\'\u0544\n\'\3(" + + "\5(\u0547\n(\3(\3(\7(\u054b\n(\f(\16(\u054e\13(\3(\3(\7(\u0552\n(\f(\16" + + "(\u0555\13(\3(\3(\7(\u0559\n(\f(\16(\u055c\13(\3(\5(\u055f\n(\3(\7(\u0562" + + "\n(\f(\16(\u0565\13(\3(\3(\7(\u0569\n(\f(\16(\u056c\13(\3(\3(\7(\u0570" + + "\n(\f(\16(\u0573\13(\3(\5(\u0576\n(\3(\7(\u0579\n(\f(\16(\u057c\13(\3" + + "(\3(\5(\u0580\n(\3)\3)\7)\u0584\n)\f)\16)\u0587\13)\3)\3)\7)\u058b\n)" + + "\f)\16)\u058e\13)\3)\3)\7)\u0592\n)\f)\16)\u0595\13)\3)\7)\u0598\n)\f" + + ")\16)\u059b\13)\3)\7)\u059e\n)\f)\16)\u05a1\13)\3)\5)\u05a4\n)\5)\u05a6" + + "\n)\3)\7)\u05a9\n)\f)\16)\u05ac\13)\3)\3)\3*\5*\u05b1\n*\3*\3*\7*\u05b5" + + "\n*\f*\16*\u05b8\13*\3*\3*\7*\u05bc\n*\f*\16*\u05bf\13*\3*\5*\u05c2\n" + + "*\3+\3+\7+\u05c6\n+\f+\16+\u05c9\13+\3+\3+\7+\u05cd\n+\f+\16+\u05d0\13" + + "+\3+\5+\u05d3\n+\3,\3,\7,\u05d7\n,\f,\16,\u05da\13,\3,\3,\7,\u05de\n," + + "\f,\16,\u05e1\13,\3,\3,\3-\5-\u05e6\n-\3-\3-\7-\u05ea\n-\f-\16-\u05ed" + + "\13-\3-\3-\7-\u05f1\n-\f-\16-\u05f4\13-\3-\3-\7-\u05f8\n-\f-\16-\u05fb" + + "\13-\3-\5-\u05fe\n-\3-\7-\u0601\n-\f-\16-\u0604\13-\3-\5-\u0607\n-\3." + + "\5.\u060a\n.\3.\3.\7.\u060e\n.\f.\16.\u0611\13.\3.\3.\7.\u0615\n.\f.\16" + + ".\u0618\13.\3.\3.\7.\u061c\n.\f.\16.\u061f\13.\3.\5.\u0622\n.\3.\7.\u0625" + + "\n.\f.\16.\u0628\13.\3.\5.\u062b\n.\3/\3/\7/\u062f\n/\f/\16/\u0632\13" + + "/\3/\3/\3\60\3\60\7\60\u0638\n\60\f\60\16\60\u063b\13\60\3\60\5\60\u063e" + + "\n\60\3\60\7\60\u0641\n\60\f\60\16\60\u0644\13\60\3\60\3\60\7\60\u0648" + + "\n\60\f\60\16\60\u064b\13\60\3\60\5\60\u064e\n\60\3\60\7\60\u0651\n\60" + + "\f\60\16\60\u0654\13\60\3\60\3\60\3\61\3\61\7\61\u065a\n\61\f\61\16\61" + + "\u065d\13\61\3\61\3\61\7\61\u0661\n\61\f\61\16\61\u0664\13\61\3\61\7\61" + + "\u0667\n\61\f\61\16\61\u066a\13\61\3\61\7\61\u066d\n\61\f\61\16\61\u0670" + + "\13\61\3\61\5\61\u0673\n\61\3\62\3\62\7\62\u0677\n\62\f\62\16\62\u067a" + + "\13\62\5\62\u067c\n\62\3\62\3\62\7\62\u0680\n\62\f\62\16\62\u0683\13\62" + + "\3\62\5\62\u0686\n\62\3\62\7\62\u0689\n\62\f\62\16\62\u068c\13\62\3\62" + + "\5\62\u068f\n\62\3\63\5\63\u0692\n\63\3\63\3\63\3\63\3\63\5\63\u0698\n" + + "\63\3\64\3\64\5\64\u069c\n\64\3\65\3\65\5\65\u06a0\n\65\3\65\7\65\u06a3" + + "\n\65\f\65\16\65\u06a6\13\65\3\65\6\65\u06a9\n\65\r\65\16\65\u06aa\3\66" + + "\3\66\3\67\3\67\7\67\u06b1\n\67\f\67\16\67\u06b4\13\67\3\67\3\67\7\67" + + "\u06b8\n\67\f\67\16\67\u06bb\13\67\3\67\7\67\u06be\n\67\f\67\16\67\u06c1" + + "\13\67\38\38\78\u06c5\n8\f8\168\u06c8\138\38\58\u06cb\n8\39\59\u06ce\n" + + "9\39\39\59\u06d2\n9\3:\6:\u06d5\n:\r:\16:\u06d6\3;\3;\7;\u06db\n;\f;\16" + + ";\u06de\13;\3;\5;\u06e1\n;\3<\3<\7<\u06e5\n<\f<\16<\u06e8\13<\3<\3<\7" + + "<\u06ec\n<\f<\16<\u06ef\13<\5<\u06f1\n<\3<\3<\7<\u06f5\n<\f<\16<\u06f8" + + "\13<\3<\3<\7<\u06fc\n<\f<\16<\u06ff\13<\3<\3<\3=\3=\7=\u0705\n=\f=\16" + + "=\u0708\13=\3=\3=\5=\u070c\n=\3=\7=\u070f\n=\f=\16=\u0712\13=\3=\3=\7" + + "=\u0716\n=\f=\16=\u0719\13=\3=\3=\5=\u071d\n=\7=\u071f\n=\f=\16=\u0722" + + "\13=\3=\7=\u0725\n=\f=\16=\u0728\13=\3=\5=\u072b\n=\3=\7=\u072e\n=\f=" + + "\16=\u0731\13=\3=\3=\3>\3>\7>\u0737\n>\f>\16>\u073a\13>\3>\3>\7>\u073e" + + "\n>\f>\16>\u0741\13>\3>\3>\3?\5?\u0746\n?\3?\3?\3?\5?\u074b\n?\3@\3@\7" + + "@\u074f\n@\f@\16@\u0752\13@\3@\3@\5@\u0756\n@\3@\7@\u0759\n@\f@\16@\u075c" + + "\13@\3@\3@\3A\3A\3A\3A\7A\u0764\nA\fA\16A\u0767\13A\5A\u0769\nA\3A\5A" + + "\u076c\nA\3B\3B\7B\u0770\nB\fB\16B\u0773\13B\3B\3B\3B\3B\5B\u0779\nB\3" + + "C\3C\3C\7C\u077e\nC\fC\16C\u0781\13C\3D\3D\5D\u0785\nD\3E\3E\7E\u0789" + + "\nE\fE\16E\u078c\13E\3E\3E\7E\u0790\nE\fE\16E\u0793\13E\3E\3E\3F\3F\3" + + "F\5F\u079a\nF\3G\3G\7G\u079e\nG\fG\16G\u07a1\13G\3G\3G\7G\u07a5\nG\fG" + + "\16G\u07a8\13G\3G\3G\5G\u07ac\nG\3G\3G\3G\3G\7G\u07b2\nG\fG\16G\u07b5" + + "\13G\3G\5G\u07b8\nG\3H\3H\7H\u07bc\nH\fH\16H\u07bf\13H\3H\3H\3H\3H\7H" + + "\u07c5\nH\fH\16H\u07c8\13H\3H\3H\5H\u07cc\nH\3I\3I\7I\u07d0\nI\fI\16I" + + "\u07d3\13I\3I\5I\u07d6\nI\3I\7I\u07d9\nI\fI\16I\u07dc\13I\3I\3I\7I\u07e0" + + "\nI\fI\16I\u07e3\13I\3I\3I\3I\3I\3J\3J\3J\3J\3J\3J\5J\u07ef\nJ\3J\7J\u07f2" + + "\nJ\fJ\16J\u07f5\13J\3J\3J\3K\3K\7K\u07fb\nK\fK\16K\u07fe\13K\3K\5K\u0801" + + "\nK\3L\6L\u0804\nL\rL\16L\u0805\3L\5L\u0809\nL\3M\3M\3N\3N\7N\u080f\n" + + "N\fN\16N\u0812\13N\3N\3N\7N\u0816\nN\fN\16N\u0819\13N\3N\7N\u081c\nN\f" + + "N\16N\u081f\13N\3O\3O\7O\u0823\nO\fO\16O\u0826\13O\3O\3O\7O\u082a\nO\f" + + "O\16O\u082d\13O\3O\7O\u0830\nO\fO\16O\u0833\13O\3P\3P\3P\7P\u0838\nP\f" + + "P\16P\u083b\13P\3P\3P\7P\u083f\nP\fP\16P\u0842\13P\3Q\3Q\3Q\7Q\u0847\n" + + "Q\fQ\16Q\u084a\13Q\3Q\3Q\7Q\u084e\nQ\fQ\16Q\u0851\13Q\3R\3R\7R\u0855\n" + + "R\fR\16R\u0858\13R\3S\3S\3S\7S\u085d\nS\fS\16S\u0860\13S\3S\3S\3S\3S\7" + + "S\u0866\nS\fS\16S\u0869\13S\3S\3S\7S\u086d\nS\fS\16S\u0870\13S\3T\3T\7" + + "T\u0874\nT\fT\16T\u0877\13T\3T\3T\7T\u087b\nT\fT\16T\u087e\13T\3T\3T\7" + + "T\u0882\nT\fT\16T\u0885\13T\3U\3U\3U\3V\3V\3V\7V\u088d\nV\fV\16V\u0890" + + "\13V\3V\3V\7V\u0894\nV\fV\16V\u0897\13V\3W\3W\3W\7W\u089c\nW\fW\16W\u089f" + + "\13W\3W\7W\u08a2\nW\fW\16W\u08a5\13W\3X\3X\3X\7X\u08aa\nX\fX\16X\u08ad" + + "\13X\3X\3X\7X\u08b1\nX\fX\16X\u08b4\13X\3Y\3Y\3Y\7Y\u08b9\nY\fY\16Y\u08bc" + + "\13Y\3Y\3Y\7Y\u08c0\nY\fY\16Y\u08c3\13Y\3Z\3Z\7Z\u08c7\nZ\fZ\16Z\u08ca" + + "\13Z\3Z\3Z\7Z\u08ce\nZ\fZ\16Z\u08d1\13Z\3Z\3Z\7Z\u08d5\nZ\fZ\16Z\u08d8" + + "\13Z\3[\7[\u08db\n[\f[\16[\u08de\13[\3[\3[\3\\\3\\\3\\\3\\\7\\\u08e6\n" + + "\\\f\\\16\\\u08e9\13\\\5\\\u08eb\n\\\3]\3]\7]\u08ef\n]\f]\16]\u08f2\13" + + "]\3^\3^\3^\3^\3^\5^\u08f9\n^\3_\3_\3_\3_\3_\5_\u0900\n_\3`\3`\7`\u0904" + + "\n`\f`\16`\u0907\13`\3`\3`\7`\u090b\n`\f`\16`\u090e\13`\3`\3`\3a\3a\5" + + "a\u0914\na\3b\3b\7b\u0918\nb\fb\16b\u091b\13b\3b\3b\7b\u091f\nb\fb\16" + + "b\u0922\13b\3b\3b\3c\3c\3c\5c\u0929\nc\3d\3d\7d\u092d\nd\fd\16d\u0930" + + "\13d\3d\3d\7d\u0934\nd\fd\16d\u0937\13d\3d\3d\7d\u093b\nd\fd\16d\u093e" + + "\13d\3d\7d\u0941\nd\fd\16d\u0944\13d\3d\7d\u0947\nd\fd\16d\u094a\13d\3" + + "d\5d\u094d\nd\3d\7d\u0950\nd\fd\16d\u0953\13d\3d\3d\3e\3e\7e\u0959\ne" + + "\fe\16e\u095c\13e\3e\3e\3e\5e\u0961\ne\3f\5f\u0964\nf\3f\5f\u0967\nf\3" + + "f\3f\5f\u096b\nf\3g\7g\u096e\ng\fg\16g\u0971\13g\3g\5g\u0974\ng\3g\7g" + + "\u0977\ng\fg\16g\u097a\13g\3g\3g\3h\3h\7h\u0980\nh\fh\16h\u0983\13h\3" + + "h\3h\7h\u0987\nh\fh\16h\u098a\13h\3h\3h\7h\u098e\nh\fh\16h\u0991\13h\3" + + "h\7h\u0994\nh\fh\16h\u0997\13h\3h\7h\u099a\nh\fh\16h\u099d\13h\3h\5h\u09a0" + + "\nh\3h\7h\u09a3\nh\fh\16h\u09a6\13h\3h\3h\3i\3i\7i\u09ac\ni\fi\16i\u09af" + + "\13i\3i\3i\7i\u09b3\ni\fi\16i\u09b6\13i\3i\3i\7i\u09ba\ni\fi\16i\u09bd" + + "\13i\3i\7i\u09c0\ni\fi\16i\u09c3\13i\3i\7i\u09c6\ni\fi\16i\u09c9\13i\3" + + "i\5i\u09cc\ni\3i\7i\u09cf\ni\fi\16i\u09d2\13i\5i\u09d4\ni\3i\3i\3j\5j" + + "\u09d9\nj\3j\7j\u09dc\nj\fj\16j\u09df\13j\3j\3j\7j\u09e3\nj\fj\16j\u09e6" + + "\13j\3j\3j\7j\u09ea\nj\fj\16j\u09ed\13j\5j\u09ef\nj\3j\5j\u09f2\nj\3j" + + "\7j\u09f5\nj\fj\16j\u09f8\13j\3j\3j\3k\3k\3k\3k\3k\3k\3k\3k\3k\3k\3k\3" + + "k\3k\3k\5k\u0a0a\nk\3l\3l\7l\u0a0e\nl\fl\16l\u0a11\13l\3l\3l\7l\u0a15" + + "\nl\fl\16l\u0a18\13l\3l\3l\3m\3m\7m\u0a1e\nm\fm\16m\u0a21\13m\3m\3m\7" + + "m\u0a25\nm\fm\16m\u0a28\13m\3m\3m\7m\u0a2c\nm\fm\16m\u0a2f\13m\3m\7m\u0a32" + + "\nm\fm\16m\u0a35\13m\3m\7m\u0a38\nm\fm\16m\u0a3b\13m\3m\5m\u0a3e\nm\3" + + "m\7m\u0a41\nm\fm\16m\u0a44\13m\5m\u0a46\nm\3m\3m\3n\3n\3o\3o\5o\u0a4e" + + "\no\3p\3p\3p\7p\u0a53\np\fp\16p\u0a56\13p\3p\3p\3q\3q\3q\3q\7q\u0a5e\n" + + "q\fq\16q\u0a61\13q\3q\3q\3r\3r\3s\3s\7s\u0a69\ns\fs\16s\u0a6c\13s\3s\3" + + "s\7s\u0a70\ns\fs\16s\u0a73\13s\3s\3s\3t\3t\3u\3u\7u\u0a7b\nu\fu\16u\u0a7e" + + "\13u\3u\3u\7u\u0a82\nu\fu\16u\u0a85\13u\3u\3u\3v\3v\7v\u0a8b\nv\fv\16" + + "v\u0a8e\13v\3v\5v\u0a91\nv\3v\7v\u0a94\nv\fv\16v\u0a97\13v\3v\3v\7v\u0a9b" + + "\nv\fv\16v\u0a9e\13v\5v\u0aa0\nv\3v\3v\7v\u0aa4\nv\fv\16v\u0aa7\13v\3" + + "v\3v\3w\3w\7w\u0aad\nw\fw\16w\u0ab0\13w\3w\3w\7w\u0ab4\nw\fw\16w\u0ab7" + + "\13w\3w\7w\u0aba\nw\fw\16w\u0abd\13w\3w\7w\u0ac0\nw\fw\16w\u0ac3\13w\3" + + "w\5w\u0ac6\nw\3x\3x\3x\7x\u0acb\nx\fx\16x\u0ace\13x\3x\3x\7x\u0ad2\nx" + + "\fx\16x\u0ad5\13x\3x\5x\u0ad8\nx\5x\u0ada\nx\3y\3y\7y\u0ade\ny\fy\16y" + + "\u0ae1\13y\3y\3y\7y\u0ae5\ny\fy\16y\u0ae8\13y\3y\3y\5y\u0aec\ny\3y\7y" + + "\u0aef\ny\fy\16y\u0af2\13y\3y\3y\7y\u0af6\ny\fy\16y\u0af9\13y\3y\3y\7" + + "y\u0afd\ny\fy\16y\u0b00\13y\3y\5y\u0b03\ny\3y\7y\u0b06\ny\fy\16y\u0b09" + + "\13y\3y\5y\u0b0c\ny\3y\7y\u0b0f\ny\fy\16y\u0b12\13y\3y\5y\u0b15\ny\3z" + + "\3z\5z\u0b19\nz\3{\3{\7{\u0b1d\n{\f{\16{\u0b20\13{\3{\3{\7{\u0b24\n{\f" + + "{\16{\u0b27\13{\3{\3{\7{\u0b2b\n{\f{\16{\u0b2e\13{\5{\u0b30\n{\3{\7{\u0b33" + + "\n{\f{\16{\u0b36\13{\3{\5{\u0b39\n{\3|\3|\3}\3}\3}\7}\u0b40\n}\f}\16}" + + "\u0b43\13}\3}\3}\7}\u0b47\n}\f}\16}\u0b4a\13}\3}\3}\5}\u0b4e\n}\3}\3}" + + "\5}\u0b52\n}\3}\5}\u0b55\n}\3~\3~\7~\u0b59\n~\f~\16~\u0b5c\13~\3~\3~\7" + + "~\u0b60\n~\f~\16~\u0b63\13~\3~\3~\7~\u0b67\n~\f~\16~\u0b6a\13~\3~\3~\7" + + "~\u0b6e\n~\f~\16~\u0b71\13~\3~\3~\5~\u0b75\n~\3~\7~\u0b78\n~\f~\16~\u0b7b" + + "\13~\3~\5~\u0b7e\n~\3~\7~\u0b81\n~\f~\16~\u0b84\13~\3~\3~\7~\u0b88\n~" + + "\f~\16~\u0b8b\13~\3~\3~\5~\u0b8f\n~\3~\5~\u0b92\n~\3\177\3\177\7\177\u0b96" + + "\n\177\f\177\16\177\u0b99\13\177\3\177\7\177\u0b9c\n\177\f\177\16\177" + + "\u0b9f\13\177\3\177\3\177\7\177\u0ba3\n\177\f\177\16\177\u0ba6\13\177" + + "\3\177\3\177\7\177\u0baa\n\177\f\177\16\177\u0bad\13\177\3\177\3\177\7" + + "\177\u0bb1\n\177\f\177\16\177\u0bb4\13\177\5\177\u0bb6\n\177\3\177\3\177" + + "\3\177\3\u0080\3\u0080\7\u0080\u0bbd\n\u0080\f\u0080\16\u0080\u0bc0\13" + + "\u0080\3\u0080\5\u0080\u0bc3\n\u0080\3\u0080\7\u0080\u0bc6\n\u0080\f\u0080" + + "\16\u0080\u0bc9\13\u0080\3\u0080\3\u0080\7\u0080\u0bcd\n\u0080\f\u0080" + + "\16\u0080\u0bd0\13\u0080\3\u0080\3\u0080\7\u0080\u0bd4\n\u0080\f\u0080" + + "\16\u0080\u0bd7\13\u0080\7\u0080\u0bd9\n\u0080\f\u0080\16\u0080\u0bdc" + + "\13\u0080\3\u0080\7\u0080\u0bdf\n\u0080\f\u0080\16\u0080\u0be2\13\u0080" + + "\3\u0080\3\u0080\3\u0081\3\u0081\7\u0081\u0be8\n\u0081\f\u0081\16\u0081" + + "\u0beb\13\u0081\3\u0081\3\u0081\7\u0081\u0bef\n\u0081\f\u0081\16\u0081" + + "\u0bf2\13\u0081\3\u0081\7\u0081\u0bf5\n\u0081\f\u0081\16\u0081\u0bf8\13" + + "\u0081\3\u0081\7\u0081\u0bfb\n\u0081\f\u0081\16\u0081\u0bfe\13\u0081\3" + + "\u0081\5\u0081\u0c01\n\u0081\3\u0081\7\u0081\u0c04\n\u0081\f\u0081\16" + + "\u0081\u0c07\13\u0081\3\u0081\3\u0081\7\u0081\u0c0b\n\u0081\f\u0081\16" + + "\u0081\u0c0e\13\u0081\3\u0081\3\u0081\5\u0081\u0c12\n\u0081\3\u0081\3" + + "\u0081\7\u0081\u0c16\n\u0081\f\u0081\16\u0081\u0c19\13\u0081\3\u0081\3" + + "\u0081\7\u0081\u0c1d\n\u0081\f\u0081\16\u0081\u0c20\13\u0081\3\u0081\3" + + "\u0081\5\u0081\u0c24\n\u0081\5\u0081\u0c26\n\u0081\3\u0082\3\u0082\3\u0082" + + "\5\u0082\u0c2b\n\u0082\3\u0083\3\u0083\7\u0083\u0c2f\n\u0083\f\u0083\16" + + "\u0083\u0c32\13\u0083\3\u0083\3\u0083\3\u0084\3\u0084\7\u0084\u0c38\n" + + "\u0084\f\u0084\16\u0084\u0c3b\13\u0084\3\u0084\3\u0084\3\u0085\3\u0085" + + "\7\u0085\u0c41\n\u0085\f\u0085\16\u0085\u0c44\13\u0085\3\u0085\3\u0085" + + "\7\u0085\u0c48\n\u0085\f\u0085\16\u0085\u0c4b\13\u0085\3\u0085\6\u0085" + + "\u0c4e\n\u0085\r\u0085\16\u0085\u0c4f\3\u0085\7\u0085\u0c53\n\u0085\f" + + "\u0085\16\u0085\u0c56\13\u0085\3\u0085\5\u0085\u0c59\n\u0085\3\u0085\7" + + "\u0085\u0c5c\n\u0085\f\u0085\16\u0085\u0c5f\13\u0085\3\u0085\5\u0085\u0c62" + + "\n\u0085\3\u0086\3\u0086\7\u0086\u0c66\n\u0086\f\u0086\16\u0086\u0c69" + + "\13\u0086\3\u0086\3\u0086\7\u0086\u0c6d\n\u0086\f\u0086\16\u0086\u0c70" + + "\13\u0086\3\u0086\3\u0086\3\u0086\3\u0086\7\u0086\u0c76\n\u0086\f\u0086" + + "\16\u0086\u0c79\13\u0086\3\u0086\5\u0086\u0c7c\n\u0086\3\u0086\3\u0086" + + "\7\u0086\u0c80\n\u0086\f\u0086\16\u0086\u0c83\13\u0086\3\u0086\3\u0086" + + "\3\u0087\3\u0087\7\u0087\u0c89\n\u0087\f\u0087\16\u0087\u0c8c\13\u0087" + + "\3\u0087\3\u0087\3\u0088\3\u0088\7\u0088\u0c92\n\u0088\f\u0088\16\u0088" + + "\u0c95\13\u0088\3\u0088\3\u0088\3\u0088\5\u0088\u0c9a\n\u0088\3\u0088" + + "\3\u0088\3\u0088\3\u0088\5\u0088\u0ca0\n\u0088\3\u0089\5\u0089\u0ca3\n" + + "\u0089\3\u0089\3\u0089\7\u0089\u0ca7\n\u0089\f\u0089\16\u0089\u0caa\13" + + "\u0089\3\u0089\3\u0089\5\u0089\u0cae\n\u0089\3\u008a\3\u008a\3\u008b\3" + + "\u008b\3\u008c\3\u008c\3\u008d\3\u008d\3\u008e\3\u008e\3\u008f\3\u008f" + + "\3\u0090\3\u0090\3\u0091\3\u0091\3\u0092\3\u0092\3\u0092\3\u0092\3\u0092" + + "\5\u0092\u0cc5\n\u0092\3\u0093\3\u0093\3\u0093\3\u0093\5\u0093\u0ccb\n" + + "\u0093\3\u0094\3\u0094\3\u0095\7\u0095\u0cd0\n\u0095\f\u0095\16\u0095" + + "\u0cd3\13\u0095\3\u0095\3\u0095\7\u0095\u0cd7\n\u0095\f\u0095\16\u0095" + + "\u0cda\13\u0095\3\u0095\3\u0095\5\u0095\u0cde\n\u0095\3\u0096\3\u0096" + + "\3\u0096\3\u0097\3\u0097\6\u0097\u0ce5\n\u0097\r\u0097\16\u0097\u0ce6" + + "\3\u0098\3\u0098\6\u0098\u0ceb\n\u0098\r\u0098\16\u0098\u0cec\3\u0099" + + "\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\3\u0099\5\u0099\u0cf7" + + "\n\u0099\3\u0099\7\u0099\u0cfa\n\u0099\f\u0099\16\u0099\u0cfd\13\u0099" + + "\3\u009a\6\u009a\u0d00\n\u009a\r\u009a\16\u009a\u0d01\3\u009b\3\u009b" + + "\3\u009b\7\u009b\u0d07\n\u009b\f\u009b\16\u009b\u0d0a\13\u009b\5\u009b" + + "\u0d0c\n\u009b\3\u009c\3\u009c\3\u009d\3\u009d\3\u009e\3\u009e\3\u009f" + + "\3\u009f\3\u00a0\6\u00a0\u0d17\n\u00a0\r\u00a0\16\u00a0\u0d18\3\u00a1" + + "\3\u00a1\7\u00a1\u0d1d\n\u00a1\f\u00a1\16\u00a1\u0d20\13\u00a1\3\u00a1" + + "\3\u00a1\7\u00a1\u0d24\n\u00a1\f\u00a1\16\u00a1\u0d27\13\u00a1\3\u00a1" + + "\5\u00a1\u0d2a\n\u00a1\3\u00a2\3\u00a2\3\u00a3\3\u00a3\3\u00a4\3\u00a4" + + "\3\u00a5\3\u00a5\3\u00a6\3\u00a6\3\u00a7\3\u00a7\3\u00a8\3\u00a8\5\u00a8" + + "\u0d3a\n\u00a8\3\u00a8\7\u00a8\u0d3d\n\u00a8\f\u00a8\16\u00a8\u0d40\13" + + "\u00a8\3\u00a9\3\u00a9\7\u00a9\u0d44\n\u00a9\f\u00a9\16\u00a9\u0d47\13" + + "\u00a9\3\u00a9\3\u00a9\5\u00a9\u0d4b\n\u00a9\3\u00a9\3\u00a9\3\u00aa\3" + + "\u00aa\7\u00aa\u0d51\n\u00aa\f\u00aa\16\u00aa\u0d54\13\u00aa\3\u00aa\3" + + "\u00aa\5\u00aa\u0d58\n\u00aa\3\u00aa\3\u00aa\6\u00aa\u0d5c\n\u00aa\r\u00aa" + + "\16\u00aa\u0d5d\3\u00aa\3\u00aa\3\u00ab\3\u00ab\3\u00ab\7\u00ab\u0d65" + + "\n\u00ab\f\u00ab\16\u00ab\u0d68\13\u00ab\3\u00ab\3\u00ab\3\u00ac\3\u00ac" + + "\5\u00ac\u0d6e\n\u00ac\3\u00ad\3\u00ad\3\u00ae\3\u00ae\7\u00ae\u0d74\n" + + "\u00ae\f\u00ae\16\u00ae\u0d77\13\u00ae\3\u00ae\3\u00ae\7\u00ae\u0d7b\n" + + "\u00ae\f\u00ae\16\u00ae\u0d7e\13\u00ae\3\u00ae\2\2\u00af\2\4\6\b\n\f\16" + + "\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bd" + + "fhjlnprtvxz|~\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\2 \4\2**,,\3\2NO\3\2UV\3\2./\3\2*+\4\2\7\7\35" + + "\35\4\2\u0089\u0089\u008c\u0093\3\2\u00a1\u00a3\3\2\u00a6\u00a8\4\2==" + + "UU\4\2::cc\3\2\37#\4\2\64\65\678\3\2\60\63\4\2hhjj\4\2ggii\3\2\24\25\3" + + "\2\21\23\4\2\66\66ff\3\2\32\33\3\2qv\4\2}}\u0082\u0082\3\2mp\4\2hhkk\3" + + "\2w|\3\2~\u0080\3\2\u0083\u0085\3\2\u0087\u0088\3\2@G\t\2?GIIQTXX]^k\u0088" + + "\u0094\u0094\2\u0f1c\2\u015d\3\2\2\2\4\u0176\3\2\2\2\6\u0190\3\2\2\2\b" + + "\u0196\3\2\2\2\n\u01bb\3\2\2\2\f\u01c0\3\2\2\2\16\u01c3\3\2\2\2\20\u01cd" + + "\3\2\2\2\22\u01d0\3\2\2\2\24\u01d5\3\2\2\2\26\u01fc\3\2\2\2\30\u01ff\3" + + "\2\2\2\32\u025a\3\2\2\2\34\u025e\3\2\2\2\36\u026e\3\2\2\2 \u029d\3\2\2" + + "\2\"\u02c1\3\2\2\2$\u02d9\3\2\2\2&\u02db\3\2\2\2(\u02e1\3\2\2\2*\u02ee" + + "\3\2\2\2,\u02ff\3\2\2\2.\u032c\3\2\2\2\60\u0345\3\2\2\2\62\u0363\3\2\2" + + "\2\64\u037c\3\2\2\2\66\u0383\3\2\2\28\u0385\3\2\2\2:\u038f\3\2\2\2<\u03bb" + + "\3\2\2\2>\u03ea\3\2\2\2@\u03fe\3\2\2\2B\u0454\3\2\2\2D\u0459\3\2\2\2F" + + "\u0473\3\2\2\2H\u04a0\3\2\2\2J\u0511\3\2\2\2L\u051b\3\2\2\2N\u0546\3\2" + + "\2\2P\u0581\3\2\2\2R\u05b0\3\2\2\2T\u05c3\3\2\2\2V\u05d4\3\2\2\2X\u05e5" + + "\3\2\2\2Z\u0609\3\2\2\2\\\u062c\3\2\2\2^\u0635\3\2\2\2`\u0657\3\2\2\2" + + "b\u067b\3\2\2\2d\u0691\3\2\2\2f\u069b\3\2\2\2h\u069f\3\2\2\2j\u06ac\3" + + "\2\2\2l\u06ae\3\2\2\2n\u06c2\3\2\2\2p\u06d1\3\2\2\2r\u06d4\3\2\2\2t\u06e0" + + "\3\2\2\2v\u06f0\3\2\2\2x\u0702\3\2\2\2z\u0734\3\2\2\2|\u0745\3\2\2\2~" + + "\u074c\3\2\2\2\u0080\u0768\3\2\2\2\u0082\u0771\3\2\2\2\u0084\u077a\3\2" + + "\2\2\u0086\u0784\3\2\2\2\u0088\u0786\3\2\2\2\u008a\u0799\3\2\2\2\u008c" + + "\u079b\3\2\2\2\u008e\u07b9\3\2\2\2\u0090\u07cd\3\2\2\2\u0092\u07ee\3\2" + + "\2\2\u0094\u0800\3\2\2\2\u0096\u0808\3\2\2\2\u0098\u080a\3\2\2\2\u009a" + + "\u080c\3\2\2\2\u009c\u0820\3\2\2\2\u009e\u0834\3\2\2\2\u00a0\u0843\3\2" + + "\2\2\u00a2\u0852\3\2\2\2\u00a4\u0859\3\2\2\2\u00a6\u0871\3\2\2\2\u00a8" + + "\u0886\3\2\2\2\u00aa\u0889\3\2\2\2\u00ac\u0898\3\2\2\2\u00ae\u08a6\3\2" + + "\2\2\u00b0\u08b5\3\2\2\2\u00b2\u08c4\3\2\2\2\u00b4\u08dc\3\2\2\2\u00b6" + + "\u08ea\3\2\2\2\u00b8\u08ec\3\2\2\2\u00ba\u08f8\3\2\2\2\u00bc\u08ff\3\2" + + "\2\2\u00be\u0901\3\2\2\2\u00c0\u0913\3\2\2\2\u00c2\u0915\3\2\2\2\u00c4" + + "\u0928\3\2\2\2\u00c6\u092a\3\2\2\2\u00c8\u0956\3\2\2\2\u00ca\u0963\3\2" + + "\2\2\u00cc\u096f\3\2\2\2\u00ce\u097d\3\2\2\2\u00d0\u09a9\3\2\2\2\u00d2" + + "\u09d8\3\2\2\2\u00d4\u0a09\3\2\2\2\u00d6\u0a0b\3\2\2\2\u00d8\u0a1b\3\2" + + "\2\2\u00da\u0a49\3\2\2\2\u00dc\u0a4d\3\2\2\2\u00de\u0a4f\3\2\2\2\u00e0" + + "\u0a59\3\2\2\2\u00e2\u0a64\3\2\2\2\u00e4\u0a66\3\2\2\2\u00e6\u0a76\3\2" + + "\2\2\u00e8\u0a78\3\2\2\2\u00ea\u0a88\3\2\2\2\u00ec\u0aaa\3\2\2\2\u00ee" + + "\u0ad9\3\2\2\2\u00f0\u0adb\3\2\2\2\u00f2\u0b18\3\2\2\2\u00f4\u0b1a\3\2" + + "\2\2\u00f6\u0b3a\3\2\2\2\u00f8\u0b54\3\2\2\2\u00fa\u0b56\3\2\2\2\u00fc" + + "\u0b93\3\2\2\2\u00fe\u0bba\3\2\2\2\u0100\u0c25\3\2\2\2\u0102\u0c2a\3\2" + + "\2\2\u0104\u0c2c\3\2\2\2\u0106\u0c35\3\2\2\2\u0108\u0c3e\3\2\2\2\u010a" + + "\u0c63\3\2\2\2\u010c\u0c86\3\2\2\2\u010e\u0c9f\3\2\2\2\u0110\u0ca2\3\2" + + "\2\2\u0112\u0caf\3\2\2\2\u0114\u0cb1\3\2\2\2\u0116\u0cb3\3\2\2\2\u0118" + + "\u0cb5\3\2\2\2\u011a\u0cb7\3\2\2\2\u011c\u0cb9\3\2\2\2\u011e\u0cbb\3\2" + + "\2\2\u0120\u0cbd\3\2\2\2\u0122\u0cc4\3\2\2\2\u0124\u0cca\3\2\2\2\u0126" + + "\u0ccc\3\2\2\2\u0128\u0cdd\3\2\2\2\u012a\u0cdf\3\2\2\2\u012c\u0ce4\3\2" + + "\2\2\u012e\u0cea\3\2\2\2\u0130\u0cf6\3\2\2\2\u0132\u0cff\3\2\2\2\u0134" + + "\u0d0b\3\2\2\2\u0136\u0d0d\3\2\2\2\u0138\u0d0f\3\2\2\2\u013a\u0d11\3\2" + + "\2\2\u013c\u0d13\3\2\2\2\u013e\u0d16\3\2\2\2\u0140\u0d29\3\2\2\2\u0142" + + "\u0d2b\3\2\2\2\u0144\u0d2d\3\2\2\2\u0146\u0d2f\3\2\2\2\u0148\u0d31\3\2" + + "\2\2\u014a\u0d33\3\2\2\2\u014c\u0d35\3\2\2\2\u014e\u0d39\3\2\2\2\u0150" + + "\u0d4a\3\2\2\2\u0152\u0d57\3\2\2\2\u0154\u0d61\3\2\2\2\u0156\u0d6d\3\2" + + "\2\2\u0158\u0d6f\3\2\2\2\u015a\u0d71\3\2\2\2\u015c\u015e\5\6\4\2\u015d" + + "\u015c\3\2\2\2\u015d\u015e\3\2\2\2\u015e\u0162\3\2\2\2\u015f\u0161\7\7" + + "\2\2\u0160\u015f\3\2\2\2\u0161\u0164\3\2\2\2\u0162\u0160\3\2\2\2\u0162" + + "\u0163\3\2\2\2\u0163\u0168\3\2\2\2\u0164\u0162\3\2\2\2\u0165\u0167\5\b" + + "\5\2\u0166\u0165\3\2\2\2\u0167\u016a\3\2\2\2\u0168\u0166\3\2\2\2\u0168" + + "\u0169\3\2\2\2\u0169\u016b\3\2\2\2\u016a\u0168\3\2\2\2\u016b\u016c\5\n" + + "\6\2\u016c\u0170\5\f\7\2\u016d\u016f\5\22\n\2\u016e\u016d\3\2\2\2\u016f" + + "\u0172\3\2\2\2\u0170\u016e\3\2\2\2\u0170\u0171\3\2\2\2\u0171\u0173\3\2" + + "\2\2\u0172\u0170\3\2\2\2\u0173\u0174\7\2\2\3\u0174\3\3\2\2\2\u0175\u0177" + + "\5\6\4\2\u0176\u0175\3\2\2\2\u0176\u0177\3\2\2\2\u0177\u017b\3\2\2\2\u0178" + + "\u017a\7\7\2\2\u0179\u0178\3\2\2\2\u017a\u017d\3\2\2\2\u017b\u0179\3\2" + + "\2\2\u017b\u017c\3\2\2\2\u017c\u0181\3\2\2\2\u017d\u017b\3\2\2\2\u017e" + + "\u0180\5\b\5\2\u017f\u017e\3\2\2\2\u0180\u0183\3\2\2\2\u0181\u017f\3\2" + + "\2\2\u0181\u0182\3\2\2\2\u0182\u0184\3\2\2\2\u0183\u0181\3\2\2\2\u0184" + + "\u0185\5\n\6\2\u0185\u018b\5\f\7\2\u0186\u0187\5\u0082B\2\u0187\u0188" + + "\5\u0094K\2\u0188\u018a\3\2\2\2\u0189\u0186\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\u018f\7\2\2\3\u018f\5\3\2\2\2\u0190\u0192\7\3\2\2\u0191" + + "\u0193\7\7\2\2\u0192\u0191\3\2\2\2\u0193\u0194\3\2\2\2\u0194\u0192\3\2" + + "\2\2\u0194\u0195\3\2\2\2\u0195\7\3\2\2\2\u0196\u0197\t\2\2\2\u0197\u019b" + + "\7?\2\2\u0198\u019a\7\7\2\2\u0199\u0198\3\2\2\2\u019a\u019d\3\2\2\2\u019b" + + "\u0199\3\2\2\2\u019b\u019c\3\2\2\2\u019c\u019e\3\2\2\2\u019d\u019b\3\2" + + "\2\2\u019e\u01a2\7\34\2\2\u019f\u01a1\7\7\2\2\u01a0\u019f\3\2\2\2\u01a1" + + "\u01a4\3\2\2\2\u01a2\u01a0\3\2\2\2\u01a2\u01a3\3\2\2\2\u01a3\u01ae\3\2" + + "\2\2\u01a4\u01a2\3\2\2\2\u01a5\u01a7\7\r\2\2\u01a6\u01a8\5\u0156\u00ac" + + "\2\u01a7\u01a6\3\2\2\2\u01a8\u01a9\3\2\2\2\u01a9\u01a7\3\2\2\2\u01a9\u01aa" + + "\3\2\2\2\u01aa\u01ab\3\2\2\2\u01ab\u01ac\7\16\2\2\u01ac\u01af\3\2\2\2" + + "\u01ad\u01af\5\u0156\u00ac\2\u01ae\u01a5\3\2\2\2\u01ae\u01ad\3\2\2\2\u01af" + + "\u01b3\3\2\2\2\u01b0\u01b2\7\7\2\2\u01b1\u01b0\3\2\2\2\u01b2\u01b5\3\2" + + "\2\2\u01b3\u01b1\3\2\2\2\u01b3\u01b4\3\2\2\2\u01b4\t\3\2\2\2\u01b5\u01b3" + + "\3\2\2\2\u01b6\u01b7\7H\2\2\u01b7\u01b9\5\u015a\u00ae\2\u01b8\u01ba\5" + + "\u0094K\2\u01b9\u01b8\3\2\2\2\u01b9\u01ba\3\2\2\2\u01ba\u01bc\3\2\2\2" + + "\u01bb\u01b6\3\2\2\2\u01bb\u01bc\3\2\2\2\u01bc\13\3\2\2\2\u01bd\u01bf" + + "\5\16\b\2\u01be\u01bd\3\2\2\2\u01bf\u01c2\3\2\2\2\u01c0\u01be\3\2\2\2" + + "\u01c0\u01c1\3\2\2\2\u01c1\r\3\2\2\2\u01c2\u01c0\3\2\2\2\u01c3\u01c4\7" + + "I\2\2\u01c4\u01c8\5\u015a\u00ae\2\u01c5\u01c6\7\t\2\2\u01c6\u01c9\7\21" + + "\2\2\u01c7\u01c9\5\20\t\2\u01c8\u01c5\3\2\2\2\u01c8\u01c7\3\2\2\2\u01c8" + + "\u01c9\3\2\2\2\u01c9\u01cb\3\2\2\2\u01ca\u01cc\5\u0094K\2\u01cb\u01ca" + + "\3\2\2\2\u01cb\u01cc\3\2\2\2\u01cc\17\3\2\2\2\u01cd\u01ce\7f\2\2\u01ce" + + "\u01cf\5\u0158\u00ad\2\u01cf\21\3\2\2\2\u01d0\u01d2\5\26\f\2\u01d1\u01d3" + + "\5\u0096L\2\u01d2\u01d1\3\2\2\2\u01d2\u01d3\3\2\2\2\u01d3\23\3\2\2\2\u01d4" + + "\u01d6\5\u012c\u0097\2\u01d5\u01d4\3\2\2\2\u01d5\u01d6\3\2\2\2\u01d6\u01d7" + + "\3\2\2\2\u01d7\u01db\7P\2\2\u01d8\u01da\7\7\2\2\u01d9\u01d8\3\2\2\2\u01da" + + "\u01dd\3\2\2\2\u01db\u01d9\3\2\2\2\u01db\u01dc\3\2\2\2\u01dc\u01de\3\2" + + "\2\2\u01dd\u01db\3\2\2\2\u01de\u01e6\5\u0158\u00ad\2\u01df\u01e1\7\7\2" + + "\2\u01e0\u01df\3\2\2\2\u01e1\u01e4\3\2\2\2\u01e2\u01e0\3\2\2\2\u01e2\u01e3" + + "\3\2\2\2\u01e3\u01e5\3\2\2\2\u01e4\u01e2\3\2\2\2\u01e5\u01e7\5,\27\2\u01e6" + + "\u01e2\3\2\2\2\u01e6\u01e7\3\2\2\2\u01e7\u01eb\3\2\2\2\u01e8\u01ea\7\7" + + "\2\2\u01e9\u01e8\3\2\2\2\u01ea\u01ed\3\2\2\2\u01eb\u01e9\3\2\2\2\u01eb" + + "\u01ec\3\2\2\2\u01ec\u01ee\3\2\2\2\u01ed\u01eb\3\2\2\2\u01ee\u01f2\7\36" + + "\2\2\u01ef\u01f1\7\7\2\2\u01f0\u01ef\3\2\2\2\u01f1\u01f4\3\2\2\2\u01f2" + + "\u01f0\3\2\2\2\u01f2\u01f3\3\2\2\2\u01f3\u01f5\3\2\2\2\u01f4\u01f2\3\2" + + "\2\2\u01f5\u01f6\5d\63\2\u01f6\25\3\2\2\2\u01f7\u01fd\5\30\r\2\u01f8\u01fd" + + "\5X-\2\u01f9\u01fd\5@!\2\u01fa\u01fd\5H%\2\u01fb\u01fd\5\24\13\2\u01fc" + + "\u01f7\3\2\2\2\u01fc\u01f8\3\2\2\2\u01fc\u01f9\3\2\2\2\u01fc\u01fa\3\2" + + "\2\2\u01fc\u01fb\3\2\2\2\u01fd\27\3\2\2\2\u01fe\u0200\5\u012c\u0097\2" + + "\u01ff\u01fe\3\2\2\2\u01ff\u0200\3\2\2\2\u0200\u020c\3\2\2\2\u0201\u020d" + + "\7J\2\2\u0202\u0206\7L\2\2\u0203\u0205\7\7\2\2\u0204\u0203\3\2\2\2\u0205" + + "\u0208\3\2\2\2\u0206\u0204\3\2\2\2\u0206\u0207\3\2\2\2\u0207\u020a\3\2" + + "\2\2\u0208\u0206\3\2\2\2\u0209\u0202\3\2\2\2\u0209\u020a\3\2\2\2\u020a" + + "\u020b\3\2\2\2\u020b\u020d\7K\2\2\u020c\u0201\3\2\2\2\u020c\u0209\3\2" + + "\2\2\u020d\u0211\3\2\2\2\u020e\u0210\7\7\2\2\u020f\u020e\3\2\2\2\u0210" + + "\u0213\3\2\2\2\u0211\u020f\3\2\2\2\u0211\u0212\3\2\2\2\u0212\u0214\3\2" + + "\2\2\u0213\u0211\3\2\2\2\u0214\u021c\5\u0158\u00ad\2\u0215\u0217\7\7\2" + + "\2\u0216\u0215\3\2\2\2\u0217\u021a\3\2\2\2\u0218\u0216\3\2\2\2\u0218\u0219" + + "\3\2\2\2\u0219\u021b\3\2\2\2\u021a\u0218\3\2\2\2\u021b\u021d\5,\27\2\u021c" + + "\u0218\3\2\2\2\u021c\u021d\3\2\2\2\u021d\u0225\3\2\2\2\u021e\u0220\7\7" + + "\2\2\u021f\u021e\3\2\2\2\u0220\u0223\3\2\2\2\u0221\u021f\3\2\2\2\u0221" + + "\u0222\3\2\2\2\u0222\u0224\3\2\2\2\u0223\u0221\3\2\2\2\u0224\u0226\5\32" + + "\16\2\u0225\u0221\3\2\2\2\u0225\u0226\3\2\2\2\u0226\u0235\3\2\2\2\u0227" + + "\u0229\7\7\2\2\u0228\u0227\3\2\2\2\u0229\u022c\3\2\2\2\u022a\u0228\3\2" + + "\2\2\u022a\u022b\3\2\2\2\u022b\u022d\3\2\2\2\u022c\u022a\3\2\2\2\u022d" + + "\u0231\7\34\2\2\u022e\u0230\7\7\2\2\u022f\u022e\3\2\2\2\u0230\u0233\3" + + "\2\2\2\u0231\u022f\3\2\2\2\u0231\u0232\3\2\2\2\u0232\u0234\3\2\2\2\u0233" + + "\u0231\3\2\2\2\u0234\u0236\5\"\22\2\u0235\u022a\3\2\2\2\u0235\u0236\3" + + "\2\2\2\u0236\u023e\3\2\2\2\u0237\u0239\7\7\2\2\u0238\u0237\3\2\2\2\u0239" + + "\u023c\3\2\2\2\u023a\u0238\3\2\2\2\u023a\u023b\3\2\2\2\u023b\u023d\3\2" + + "\2\2\u023c\u023a\3\2\2\2\u023d\u023f\5\60\31\2\u023e\u023a\3\2\2\2\u023e" + + "\u023f\3\2\2\2\u023f\u024e\3\2\2\2\u0240\u0242\7\7\2\2\u0241\u0240\3\2" + + "\2\2\u0242\u0245\3\2\2\2\u0243\u0241\3\2\2\2\u0243\u0244\3\2\2\2\u0244" + + "\u0246\3\2\2\2\u0245\u0243\3\2\2\2\u0246\u024f\5\34\17\2\u0247\u0249\7" + + "\7\2\2\u0248\u0247\3\2\2\2\u0249\u024c\3\2\2\2\u024a\u0248\3\2\2\2\u024a" + + "\u024b\3\2\2\2\u024b\u024d\3\2\2\2\u024c\u024a\3\2\2\2\u024d\u024f\5^" + + "\60\2\u024e\u0243\3\2\2\2\u024e\u024a\3\2\2\2\u024e\u024f\3\2\2\2\u024f" + + "\31\3\2\2\2\u0250\u0252\5\u012c\u0097\2\u0251\u0250\3\2\2\2\u0251\u0252" + + "\3\2\2\2\u0252\u0253\3\2\2\2\u0253\u0257\7Q\2\2\u0254\u0256\7\7\2\2\u0255" + + "\u0254\3\2\2\2\u0256\u0259\3\2\2\2\u0257\u0255\3\2\2\2\u0257\u0258\3\2" + + "\2\2\u0258\u025b\3\2\2\2\u0259\u0257\3\2\2\2\u025a\u0251\3\2\2\2\u025a" + + "\u025b\3\2\2\2\u025b\u025c\3\2\2\2\u025c\u025d\5\36\20\2\u025d\33\3\2" + + "\2\2\u025e\u0262\7\17\2\2\u025f\u0261\7\7\2\2\u0260\u025f\3\2\2\2\u0261" + + "\u0264\3\2\2\2\u0262\u0260\3\2\2\2\u0262\u0263\3\2\2\2\u0263\u0265\3\2" + + "\2\2\u0264\u0262\3\2\2\2\u0265\u0269\5\64\33\2\u0266\u0268\7\7\2\2\u0267" + + "\u0266\3\2\2\2\u0268\u026b\3\2\2\2\u0269\u0267\3\2\2\2\u0269\u026a\3\2" + + "\2\2\u026a\u026c\3\2\2\2\u026b\u0269\3\2\2\2\u026c\u026d\7\20\2\2\u026d" + + "\35\3\2\2\2\u026e\u0272\7\13\2\2\u026f\u0271\7\7\2\2\u0270\u026f\3\2\2" + + "\2\u0271\u0274\3\2\2\2\u0272\u0270\3\2\2\2\u0272\u0273\3\2\2\2\u0273\u0292" + + "\3\2\2\2\u0274\u0272\3\2\2\2\u0275\u0286\5 \21\2\u0276\u0278\7\7\2\2\u0277" + + "\u0276\3\2\2\2\u0278\u027b\3\2\2\2\u0279\u0277\3\2\2\2\u0279\u027a\3\2" + + "\2\2\u027a\u027c\3\2\2\2\u027b\u0279\3\2\2\2\u027c\u0280\7\n\2\2\u027d" + + "\u027f\7\7\2\2\u027e\u027d\3\2\2\2\u027f\u0282\3\2\2\2\u0280\u027e\3\2" + + "\2\2\u0280\u0281\3\2\2\2\u0281\u0283\3\2\2\2\u0282\u0280\3\2\2\2\u0283" + + "\u0285\5 \21\2\u0284\u0279\3\2\2\2\u0285\u0288\3\2\2\2\u0286\u0284\3\2" + + "\2\2\u0286\u0287\3\2\2\2\u0287\u0290\3\2\2\2\u0288\u0286\3\2\2\2\u0289" + + "\u028b\7\7\2\2\u028a\u0289\3\2\2\2\u028b\u028e\3\2\2\2\u028c\u028a\3\2" + + "\2\2\u028c\u028d\3\2\2\2\u028d\u028f\3\2\2\2\u028e\u028c\3\2\2\2\u028f" + + "\u0291\7\n\2\2\u0290\u028c\3\2\2\2\u0290\u0291\3\2\2\2\u0291\u0293\3\2" + + "\2\2\u0292\u0275\3\2\2\2\u0292\u0293\3\2\2\2\u0293\u0297\3\2\2\2\u0294" + + "\u0296\7\7\2\2\u0295\u0294\3\2\2\2\u0296\u0299\3\2\2\2\u0297\u0295\3\2" + + "\2\2\u0297\u0298\3\2\2\2\u0298\u029a\3\2\2\2\u0299\u0297\3\2\2\2\u029a" + + "\u029b\7\f\2\2\u029b\37\3\2\2\2\u029c\u029e\5\u012c\u0097\2\u029d\u029c" + + "\3\2\2\2\u029d\u029e\3\2\2\2\u029e\u02a0\3\2\2\2\u029f\u02a1\t\3\2\2\u02a0" + + "\u029f\3\2\2\2\u02a0\u02a1\3\2\2\2\u02a1\u02a5\3\2\2\2\u02a2\u02a4\7\7" + + "\2\2\u02a3\u02a2\3\2\2\2\u02a4\u02a7\3\2\2\2\u02a5\u02a3\3\2\2\2\u02a5" + + "\u02a6\3\2\2\2\u02a6\u02a8\3\2\2\2\u02a7\u02a5\3\2\2\2\u02a8\u02a9\5\u0158" + + "\u00ad\2\u02a9\u02ad\7\34\2\2\u02aa\u02ac\7\7\2\2\u02ab\u02aa\3\2\2\2" + + "\u02ac\u02af\3\2\2\2\u02ad\u02ab\3\2\2\2\u02ad\u02ae\3\2\2\2\u02ae\u02b0" + + "\3\2\2\2\u02af\u02ad\3\2\2\2\u02b0\u02bf\5d\63\2\u02b1\u02b3\7\7\2\2\u02b2" + + "\u02b1\3\2\2\2\u02b3\u02b6\3\2\2\2\u02b4\u02b2\3\2\2\2\u02b4\u02b5\3\2" + + "\2\2\u02b5\u02b7\3\2\2\2\u02b6\u02b4\3\2\2\2\u02b7\u02bb\7\36\2\2\u02b8" + + "\u02ba\7\7\2\2\u02b9\u02b8\3\2\2\2\u02ba\u02bd\3\2\2\2\u02bb\u02b9\3\2" + + "\2\2\u02bb\u02bc\3\2\2\2\u02bc\u02be\3\2\2\2\u02bd\u02bb\3\2\2\2\u02be" + + "\u02c0\5\u0098M\2\u02bf\u02b4\3\2\2\2\u02bf\u02c0\3\2\2\2\u02c0!\3\2\2" + + "\2\u02c1\u02d2\5(\25\2\u02c2\u02c4\7\7\2\2\u02c3\u02c2\3\2\2\2\u02c4\u02c7" + + "\3\2\2\2\u02c5\u02c3\3\2\2\2\u02c5\u02c6\3\2\2\2\u02c6\u02c8\3\2\2\2\u02c7" + + "\u02c5\3\2\2\2\u02c8\u02cc\7\n\2\2\u02c9\u02cb\7\7\2\2\u02ca\u02c9\3\2" + + "\2\2\u02cb\u02ce\3\2\2\2\u02cc\u02ca\3\2\2\2\u02cc\u02cd\3\2\2\2\u02cd" + + "\u02cf\3\2\2\2\u02ce\u02cc\3\2\2\2\u02cf\u02d1\5(\25\2\u02d0\u02c5\3\2" + + "\2\2\u02d1\u02d4\3\2\2\2\u02d2\u02d0\3\2\2\2\u02d2\u02d3\3\2\2\2\u02d3" + + "#\3\2\2\2\u02d4\u02d2\3\2\2\2\u02d5\u02da\5&\24\2\u02d6\u02da\5*\26\2" + + "\u02d7\u02da\5l\67\2\u02d8\u02da\5v<\2\u02d9\u02d5\3\2\2\2\u02d9\u02d6" + + "\3\2\2\2\u02d9\u02d7\3\2\2\2\u02d9\u02d8\3\2\2\2\u02da%\3\2\2\2\u02db" + + "\u02dc\5l\67\2\u02dc\u02dd\5\u00d0i\2\u02dd\'\3\2\2\2\u02de\u02e0\5\u014e" + + "\u00a8\2\u02df\u02de\3\2\2\2\u02e0\u02e3\3\2\2\2\u02e1\u02df\3\2\2\2\u02e1" + + "\u02e2\3\2\2\2\u02e2\u02e7\3\2\2\2\u02e3\u02e1\3\2\2\2\u02e4\u02e6\7\7" + + "\2\2\u02e5\u02e4\3\2\2\2\u02e6\u02e9\3\2\2\2\u02e7\u02e5\3\2\2\2\u02e7" + + "\u02e8\3\2\2\2\u02e8\u02ea\3\2\2\2\u02e9\u02e7\3\2\2\2\u02ea\u02eb\5$" + + "\23\2\u02eb)\3\2\2\2\u02ec\u02ef\5l\67\2\u02ed\u02ef\5v<\2\u02ee\u02ec" + + "\3\2\2\2\u02ee\u02ed\3\2\2\2\u02ef\u02f3\3\2\2\2\u02f0\u02f2\7\7\2\2\u02f1" + + "\u02f0\3\2\2\2\u02f2\u02f5\3\2\2\2\u02f3\u02f1\3\2\2\2\u02f3\u02f4\3\2" + + "\2\2\u02f4\u02f6\3\2\2\2\u02f5\u02f3\3\2\2\2\u02f6\u02fa\7R\2\2\u02f7" + + "\u02f9\7\7\2\2\u02f8\u02f7\3\2\2\2\u02f9\u02fc\3\2\2\2\u02fa\u02f8\3\2" + + "\2\2\u02fa\u02fb\3\2\2\2\u02fb\u02fd\3\2\2\2\u02fc\u02fa\3\2\2\2\u02fd" + + "\u02fe\5\u0098M\2\u02fe+\3\2\2\2\u02ff\u0303\7\60\2\2\u0300\u0302\7\7" + + "\2\2\u0301\u0300\3\2\2\2\u0302\u0305\3\2\2\2\u0303\u0301\3\2\2\2\u0303" + + "\u0304\3\2\2\2\u0304\u0306\3\2\2\2\u0305\u0303\3\2\2\2\u0306\u0317\5." + + "\30\2\u0307\u0309\7\7\2\2\u0308\u0307\3\2\2\2\u0309\u030c\3\2\2\2\u030a" + + "\u0308\3\2\2\2\u030a\u030b\3\2\2\2\u030b\u030d\3\2\2\2\u030c\u030a\3\2" + + "\2\2\u030d\u0311\7\n\2\2\u030e\u0310\7\7\2\2\u030f\u030e\3\2\2\2\u0310" + + "\u0313\3\2\2\2\u0311\u030f\3\2\2\2\u0311\u0312\3\2\2\2\u0312\u0314\3\2" + + "\2\2\u0313\u0311\3\2\2\2\u0314\u0316\5.\30\2\u0315\u030a\3\2\2\2\u0316" + + "\u0319\3\2\2\2\u0317\u0315\3\2\2\2\u0317\u0318\3\2\2\2\u0318\u0321\3\2" + + "\2\2\u0319\u0317\3\2\2\2\u031a\u031c\7\7\2\2\u031b\u031a\3\2\2\2\u031c" + + "\u031f\3\2\2\2\u031d\u031b\3\2\2\2\u031d\u031e\3\2\2\2\u031e\u0320\3\2" + + "\2\2\u031f\u031d\3\2\2\2\u0320\u0322\7\n\2\2\u0321\u031d\3\2\2\2\u0321" + + "\u0322\3\2\2\2\u0322\u0326\3\2\2\2\u0323\u0325\7\7\2\2\u0324\u0323\3\2" + + "\2\2\u0325\u0328\3\2\2\2\u0326\u0324\3\2\2\2\u0326\u0327\3\2\2\2\u0327" + + "\u0329\3\2\2\2\u0328\u0326\3\2\2\2\u0329\u032a\7\61\2\2\u032a-\3\2\2\2" + + "\u032b\u032d\5\u013e\u00a0\2\u032c\u032b\3\2\2\2\u032c\u032d\3\2\2\2\u032d" + + "\u0331\3\2\2\2\u032e\u0330\7\7\2\2\u032f\u032e\3\2\2\2\u0330\u0333\3\2" + + "\2\2\u0331\u032f\3\2\2\2\u0331\u0332\3\2\2\2\u0332\u0334\3\2\2\2\u0333" + + "\u0331\3\2\2\2\u0334\u0343\5\u0158\u00ad\2\u0335\u0337\7\7\2\2\u0336\u0335" + + "\3\2\2\2\u0337\u033a\3\2\2\2\u0338\u0336\3\2\2\2\u0338\u0339\3\2\2\2\u0339" + + "\u033b\3\2\2\2\u033a\u0338\3\2\2\2\u033b\u033f\7\34\2\2\u033c\u033e\7" + + "\7\2\2\u033d\u033c\3\2\2\2\u033e\u0341\3\2\2\2\u033f\u033d\3\2\2\2\u033f" + + "\u0340\3\2\2\2\u0340\u0342\3\2\2\2\u0341\u033f\3\2\2\2\u0342\u0344\5d" + + "\63\2\u0343\u0338\3\2\2\2\u0343\u0344\3\2\2\2\u0344/\3\2\2\2\u0345\u0349" + + "\7X\2\2\u0346\u0348\7\7\2\2\u0347\u0346\3\2\2\2\u0348\u034b\3\2\2\2\u0349" + + "\u0347\3\2\2\2\u0349\u034a\3\2\2\2\u034a\u034c\3\2\2\2\u034b\u0349\3\2" + + "\2\2\u034c\u035d\5\62\32\2\u034d\u034f\7\7\2\2\u034e\u034d\3\2\2\2\u034f" + + "\u0352\3\2\2\2\u0350\u034e\3\2\2\2\u0350\u0351\3\2\2\2\u0351\u0353\3\2" + + "\2\2\u0352\u0350\3\2\2\2\u0353\u0357\7\n\2\2\u0354\u0356\7\7\2\2\u0355" + + "\u0354\3\2\2\2\u0356\u0359\3\2\2\2\u0357\u0355\3\2\2\2\u0357\u0358\3\2" + + "\2\2\u0358\u035a\3\2\2\2\u0359\u0357\3\2\2\2\u035a\u035c\5\62\32\2\u035b" + + "\u0350\3\2\2\2\u035c\u035f\3\2\2\2\u035d\u035b\3\2\2\2\u035d\u035e\3\2" + + "\2\2\u035e\61\3\2\2\2\u035f\u035d\3\2\2\2\u0360\u0362\5\u014e\u00a8\2" + + "\u0361\u0360\3\2\2\2\u0362\u0365\3\2\2\2\u0363\u0361\3\2\2\2\u0363\u0364" + + "\3\2\2\2\u0364\u0366\3\2\2\2\u0365\u0363\3\2\2\2\u0366\u036a\5\u0158\u00ad" + + "\2\u0367\u0369\7\7\2\2\u0368\u0367\3\2\2\2\u0369\u036c\3\2\2\2\u036a\u0368" + + "\3\2\2\2\u036a\u036b\3\2\2\2\u036b\u036d\3\2\2\2\u036c\u036a\3\2\2\2\u036d" + + "\u0371\7\34\2\2\u036e\u0370\7\7\2\2\u036f\u036e\3\2\2\2\u0370\u0373\3" + + "\2\2\2\u0371\u036f\3\2\2\2\u0371\u0372\3\2\2\2\u0372\u0374\3\2\2\2\u0373" + + "\u0371\3\2\2\2\u0374\u0375\5d\63\2\u0375\63\3\2\2\2\u0376\u0378\5\66\34" + + "\2\u0377\u0379\5\u0096L\2\u0378\u0377\3\2\2\2\u0378\u0379\3\2\2\2\u0379" + + "\u037b\3\2\2\2\u037a\u0376\3\2\2\2\u037b\u037e\3\2\2\2\u037c\u037a\3\2" + + "\2\2\u037c\u037d\3\2\2\2\u037d\65\3\2\2\2\u037e\u037c\3\2\2\2\u037f\u0384" + + "\5\26\f\2\u0380\u0384\5:\36\2\u0381\u0384\58\35\2\u0382\u0384\5Z.\2\u0383" + + "\u037f\3\2\2\2\u0383\u0380\3\2\2\2\u0383\u0381\3\2\2\2\u0383\u0382\3\2" + + "\2\2\u0384\67\3\2\2\2\u0385\u0389\7T\2\2\u0386\u0388\7\7\2\2\u0387\u0386" + + "\3\2\2\2\u0388\u038b\3\2\2\2\u0389\u0387\3\2\2\2\u0389\u038a\3\2\2\2\u038a" + + "\u038c\3\2\2\2\u038b\u0389\3\2\2\2\u038c\u038d\5\u0088E\2\u038d9\3\2\2" + + "\2\u038e\u0390\5\u012c\u0097\2\u038f\u038e\3\2\2\2\u038f\u0390\3\2\2\2" + + "\u0390\u0391\3\2\2\2\u0391\u0395\7S\2\2\u0392\u0394\7\7\2\2\u0393\u0392" + + "\3\2\2\2\u0394\u0397\3\2\2\2\u0395\u0393\3\2\2\2\u0395\u0396\3\2\2\2\u0396" + + "\u0398\3\2\2\2\u0397\u0395\3\2\2\2\u0398\u03a0\7M\2\2\u0399\u039b\7\7" + + "\2\2\u039a\u0399\3\2\2\2\u039b\u039e\3\2\2\2\u039c\u039a\3\2\2\2\u039c" + + "\u039d\3\2\2\2\u039d\u039f\3\2\2\2\u039e\u039c\3\2\2\2\u039f\u03a1\5\u0158" + + "\u00ad\2\u03a0\u039c\3\2\2\2\u03a0\u03a1\3\2\2\2\u03a1\u03b0\3\2\2\2\u03a2" + + "\u03a4\7\7\2\2\u03a3\u03a2\3\2\2\2\u03a4\u03a7\3\2\2\2\u03a5\u03a3\3\2" + + "\2\2\u03a5\u03a6\3\2\2\2\u03a6\u03a8\3\2\2\2\u03a7\u03a5\3\2\2\2\u03a8" + + "\u03ac\7\34\2\2\u03a9\u03ab\7\7\2\2\u03aa\u03a9\3\2\2\2\u03ab\u03ae\3" + + "\2\2\2\u03ac\u03aa\3\2\2\2\u03ac\u03ad\3\2\2\2\u03ad\u03af\3\2\2\2\u03ae" + + "\u03ac\3\2\2\2\u03af\u03b1\5\"\22\2\u03b0\u03a5\3\2\2\2\u03b0\u03b1\3" + + "\2\2\2\u03b1\u03b9\3\2\2\2\u03b2\u03b4\7\7\2\2\u03b3\u03b2\3\2\2\2\u03b4" + + "\u03b7\3\2\2\2\u03b5\u03b3\3\2\2\2\u03b5\u03b6\3\2\2\2\u03b6\u03b8\3\2" + + "\2\2\u03b7\u03b5\3\2\2\2\u03b8\u03ba\5\34\17\2\u03b9\u03b5\3\2\2\2\u03b9" + + "\u03ba\3\2\2\2\u03ba;\3\2\2\2\u03bb\u03bf\7\13\2\2\u03bc\u03be\7\7\2\2" + + "\u03bd\u03bc\3\2\2\2\u03be\u03c1\3\2\2\2\u03bf\u03bd\3\2\2\2\u03bf\u03c0" + + "\3\2\2\2\u03c0\u03df\3\2\2\2\u03c1\u03bf\3\2\2\2\u03c2\u03d3\5> \2\u03c3" + + "\u03c5\7\7\2\2\u03c4\u03c3\3\2\2\2\u03c5\u03c8\3\2\2\2\u03c6\u03c4\3\2" + + "\2\2\u03c6\u03c7\3\2\2\2\u03c7\u03c9\3\2\2\2\u03c8\u03c6\3\2\2\2\u03c9" + + "\u03cd\7\n\2\2\u03ca\u03cc\7\7\2\2\u03cb\u03ca\3\2\2\2\u03cc\u03cf\3\2" + + "\2\2\u03cd\u03cb\3\2\2\2\u03cd\u03ce\3\2\2\2\u03ce\u03d0\3\2\2\2\u03cf" + + "\u03cd\3\2\2\2\u03d0\u03d2\5> \2\u03d1\u03c6\3\2\2\2\u03d2\u03d5\3\2\2" + + "\2\u03d3\u03d1\3\2\2\2\u03d3\u03d4\3\2\2\2\u03d4\u03dd\3\2\2\2\u03d5\u03d3" + + "\3\2\2\2\u03d6\u03d8\7\7\2\2\u03d7\u03d6\3\2\2\2\u03d8\u03db\3\2\2\2\u03d9" + + "\u03d7\3\2\2\2\u03d9\u03da\3\2\2\2\u03da\u03dc\3\2\2\2\u03db\u03d9\3\2" + + "\2\2\u03dc\u03de\7\n\2\2\u03dd\u03d9\3\2\2\2\u03dd\u03de\3\2\2\2\u03de" + + "\u03e0\3\2\2\2\u03df\u03c2\3\2\2\2\u03df\u03e0\3\2\2\2\u03e0\u03e4\3\2" + + "\2\2\u03e1\u03e3\7\7\2\2\u03e2\u03e1\3\2\2\2\u03e3\u03e6\3\2\2\2\u03e4" + + "\u03e2\3\2\2\2\u03e4\u03e5\3\2\2\2\u03e5\u03e7\3\2\2\2\u03e6\u03e4\3\2" + + "\2\2\u03e7\u03e8\7\f\2\2\u03e8=\3\2\2\2\u03e9\u03eb\5\u012e\u0098\2\u03ea" + + "\u03e9\3\2\2\2\u03ea\u03eb\3\2\2\2\u03eb\u03ec\3\2\2\2\u03ec\u03fb\5V" + + ",\2\u03ed\u03ef\7\7\2\2\u03ee\u03ed\3\2\2\2\u03ef\u03f2\3\2\2\2\u03f0" + + "\u03ee\3\2\2\2\u03f0\u03f1\3\2\2\2\u03f1\u03f3\3\2\2\2\u03f2\u03f0\3\2" + + "\2\2\u03f3\u03f7\7\36\2\2\u03f4\u03f6\7\7\2\2\u03f5\u03f4\3\2\2\2\u03f6" + + "\u03f9\3\2\2\2\u03f7\u03f5\3\2\2\2\u03f7\u03f8\3\2\2\2\u03f8\u03fa\3\2" + + "\2\2\u03f9\u03f7\3\2\2\2\u03fa\u03fc\5\u0098M\2\u03fb\u03f0\3\2\2\2\u03fb" + + "\u03fc\3\2\2\2\u03fc?\3\2\2\2\u03fd\u03ff\5\u012c\u0097\2\u03fe\u03fd" + + "\3\2\2\2\u03fe\u03ff\3\2\2\2\u03ff\u0400\3\2\2\2\u0400\u0408\7L\2\2\u0401" + + "\u0403\7\7\2\2\u0402\u0401\3\2\2\2\u0403\u0406\3\2\2\2\u0404\u0402\3\2" + + "\2\2\u0404\u0405\3\2\2\2\u0405\u0407\3\2\2\2\u0406\u0404\3\2\2\2\u0407" + + "\u0409\5,\27\2\u0408\u0404\3\2\2\2\u0408\u0409\3\2\2\2\u0409\u0419\3\2" + + "\2\2\u040a\u040c\7\7\2\2\u040b\u040a\3\2\2\2\u040c\u040f\3\2\2\2\u040d" + + "\u040b\3\2\2\2\u040d\u040e\3\2\2\2\u040e\u0410\3\2\2\2\u040f\u040d\3\2" + + "\2\2\u0410\u0414\5|?\2\u0411\u0413\7\7\2\2\u0412\u0411\3\2\2\2\u0413\u0416" + + "\3\2\2\2\u0414\u0412\3\2\2\2\u0414\u0415\3\2\2\2\u0415\u0417\3\2\2\2\u0416" + + "\u0414\3\2\2\2\u0417\u0418\7\t\2\2\u0418\u041a\3\2\2\2\u0419\u040d\3\2" + + "\2\2\u0419\u041a\3\2\2\2\u041a\u041e\3\2\2\2\u041b\u041d\7\7\2\2\u041c" + + "\u041b\3\2\2\2\u041d\u0420\3\2\2\2\u041e\u041c\3\2\2\2\u041e\u041f\3\2" + + "\2\2\u041f\u0421\3\2\2\2\u0420\u041e\3\2\2\2\u0421\u0425\5\u0158\u00ad" + + "\2\u0422\u0424\7\7\2\2\u0423\u0422\3\2\2\2\u0424\u0427\3\2\2\2\u0425\u0423" + + "\3\2\2\2\u0425\u0426\3\2\2\2\u0426\u0428\3\2\2\2\u0427\u0425\3\2\2\2\u0428" + + "\u0437\5<\37\2\u0429\u042b\7\7\2\2\u042a\u0429\3\2\2\2\u042b\u042e\3\2" + + "\2\2\u042c\u042a\3\2\2\2\u042c\u042d\3\2\2\2\u042d\u042f\3\2\2\2\u042e" + + "\u042c\3\2\2\2\u042f\u0433\7\34\2\2\u0430\u0432\7\7\2\2\u0431\u0430\3" + + "\2\2\2\u0432\u0435\3\2\2\2\u0433\u0431\3\2\2\2\u0433\u0434\3\2\2\2\u0434" + + "\u0436\3\2\2\2\u0435\u0433\3\2\2\2\u0436\u0438\5d\63\2\u0437\u042c\3\2" + + "\2\2\u0437\u0438\3\2\2\2\u0438\u0440\3\2\2\2\u0439\u043b\7\7\2\2\u043a" + + "\u0439\3\2\2\2\u043b\u043e\3\2\2\2\u043c\u043a\3\2\2\2\u043c\u043d\3\2" + + "\2\2\u043d\u043f\3\2\2\2\u043e\u043c\3\2\2\2\u043f\u0441\5\60\31\2\u0440" + + "\u043c\3\2\2\2\u0440\u0441\3\2\2\2\u0441\u0449\3\2\2\2\u0442\u0444\7\7" + + "\2\2\u0443\u0442\3\2\2\2\u0444\u0447\3\2\2\2\u0445\u0443\3\2\2\2\u0445" + + "\u0446\3\2\2\2\u0446\u0448\3\2\2\2\u0447\u0445\3\2\2\2\u0448\u044a\5B" + + "\"\2\u0449\u0445\3\2\2\2\u0449\u044a\3\2\2\2\u044aA\3\2\2\2\u044b\u0455" + + "\5\u0088E\2\u044c\u0450\7\36\2\2\u044d\u044f\7\7\2\2\u044e\u044d\3\2\2" + + "\2\u044f\u0452\3\2\2\2\u0450\u044e\3\2\2\2\u0450\u0451\3\2\2\2\u0451\u0453" + + "\3\2\2\2\u0452\u0450\3\2\2\2\u0453\u0455\5\u0098M\2\u0454\u044b\3\2\2" + + "\2\u0454\u044c\3\2\2\2\u0455C\3\2\2\2\u0456\u0458\5\u014e\u00a8\2\u0457" + + "\u0456\3\2\2\2\u0458\u045b\3\2\2\2\u0459\u0457\3\2\2\2\u0459\u045a\3\2" + + "\2\2\u045a\u045f\3\2\2\2\u045b\u0459\3\2\2\2\u045c\u045e\7\7\2\2\u045d" + + "\u045c\3\2\2\2\u045e\u0461\3\2\2\2\u045f\u045d\3\2\2\2\u045f\u0460\3\2" + + "\2\2\u0460\u0462\3\2\2\2\u0461\u045f\3\2\2\2\u0462\u0471\5\u0158\u00ad" + + "\2\u0463\u0465\7\7\2\2\u0464\u0463\3\2\2\2\u0465\u0468\3\2\2\2\u0466\u0464" + + "\3\2\2\2\u0466\u0467\3\2\2\2\u0467\u0469\3\2\2\2\u0468\u0466\3\2\2\2\u0469" + + "\u046d\7\34\2\2\u046a\u046c\7\7\2\2\u046b\u046a\3\2\2\2\u046c\u046f\3" + + "\2\2\2\u046d\u046b\3\2\2\2\u046d\u046e\3\2\2\2\u046e\u0470\3\2\2\2\u046f" + + "\u046d\3\2\2\2\u0470\u0472\5d\63\2\u0471\u0466\3\2\2\2\u0471\u0472\3\2" + + "\2\2\u0472E\3\2\2\2\u0473\u0477\7\13\2\2\u0474\u0476\7\7\2\2\u0475\u0474" + + "\3\2\2\2\u0476\u0479\3\2\2\2\u0477\u0475\3\2\2\2\u0477\u0478\3\2\2\2\u0478" + + "\u047a\3\2\2\2\u0479\u0477\3\2\2\2\u047a\u048b\5D#\2\u047b\u047d\7\7\2" + + "\2\u047c\u047b\3\2\2\2\u047d\u0480\3\2\2\2\u047e\u047c\3\2\2\2\u047e\u047f" + + "\3\2\2\2\u047f\u0481\3\2\2\2\u0480\u047e\3\2\2\2\u0481\u0485\7\n\2\2\u0482" + + "\u0484\7\7\2\2\u0483\u0482\3\2\2\2\u0484\u0487\3\2\2\2\u0485\u0483\3\2" + + "\2\2\u0485\u0486\3\2\2\2\u0486\u0488\3\2\2\2\u0487\u0485\3\2\2\2\u0488" + + "\u048a\5D#\2\u0489\u047e\3\2\2\2\u048a\u048d\3\2\2\2\u048b\u0489\3\2\2" + + "\2\u048b\u048c\3\2\2\2\u048c\u0495\3\2\2\2\u048d\u048b\3\2\2\2\u048e\u0490" + + "\7\7\2\2\u048f\u048e\3\2\2\2\u0490\u0493\3\2\2\2\u0491\u048f\3\2\2\2\u0491" + + "\u0492\3\2\2\2\u0492\u0494\3\2\2\2\u0493\u0491\3\2\2\2\u0494\u0496\7\n" + + "\2\2\u0495\u0491\3\2\2\2\u0495\u0496\3\2\2\2\u0496\u049a\3\2\2\2\u0497" + + "\u0499\7\7\2\2\u0498\u0497\3\2\2\2\u0499\u049c\3\2\2\2\u049a\u0498\3\2" + + "\2\2\u049a\u049b\3\2\2\2\u049b\u049d\3\2\2\2\u049c\u049a\3\2\2\2\u049d" + + "\u049e\7\f\2\2\u049eG\3\2\2\2\u049f\u04a1\5\u012c\u0097\2\u04a0\u049f" + + "\3\2\2\2\u04a0\u04a1\3\2\2\2\u04a1\u04a2\3\2\2\2\u04a2\u04aa\t\3\2\2\u04a3" + + "\u04a5\7\7\2\2\u04a4\u04a3\3\2\2\2\u04a5\u04a8\3\2\2\2\u04a6\u04a4\3\2" + + "\2\2\u04a6\u04a7\3\2\2\2\u04a7\u04a9\3\2\2\2\u04a8\u04a6\3\2\2\2\u04a9" + + "\u04ab\5,\27\2\u04aa\u04a6\3\2\2\2\u04aa\u04ab\3\2\2\2\u04ab\u04bb\3\2" + + "\2\2\u04ac\u04ae\7\7\2\2\u04ad\u04ac\3\2\2\2\u04ae\u04b1\3\2\2\2\u04af" + + "\u04ad\3\2\2\2\u04af\u04b0\3\2\2\2\u04b0\u04b2\3\2\2\2\u04b1\u04af\3\2" + + "\2\2\u04b2\u04b6\5|?\2\u04b3\u04b5\7\7\2\2\u04b4\u04b3\3\2\2\2\u04b5\u04b8" + + "\3\2\2\2\u04b6\u04b4\3\2\2\2\u04b6\u04b7\3\2\2\2\u04b7\u04b9\3\2\2\2\u04b8" + + "\u04b6\3\2\2\2\u04b9\u04ba\7\t\2\2\u04ba\u04bc\3\2\2\2\u04bb\u04af\3\2" + + "\2\2\u04bb\u04bc\3\2\2\2\u04bc\u04c0\3\2\2\2\u04bd\u04bf\7\7\2\2\u04be" + + "\u04bd\3\2\2\2\u04bf\u04c2\3\2\2\2\u04c0\u04be\3\2\2\2\u04c0\u04c1\3\2" + + "\2\2\u04c1\u04c5\3\2\2\2\u04c2\u04c0\3\2\2\2\u04c3\u04c6\5F$\2\u04c4\u04c6" + + "\5D#\2\u04c5\u04c3\3\2\2\2\u04c5\u04c4\3\2\2\2\u04c6\u04ce\3\2\2\2\u04c7" + + "\u04c9\7\7\2\2\u04c8\u04c7\3\2\2\2\u04c9\u04cc\3\2\2\2\u04ca\u04c8\3\2" + + "\2\2\u04ca\u04cb\3\2\2\2\u04cb\u04cd\3\2\2\2\u04cc\u04ca\3\2\2\2\u04cd" + + "\u04cf\5\60\31\2\u04ce\u04ca\3\2\2\2\u04ce\u04cf\3\2\2\2\u04cf\u04e1\3" + + "\2\2\2\u04d0\u04d2\7\7\2\2\u04d1\u04d0\3\2\2\2\u04d2\u04d5\3\2\2\2\u04d3" + + "\u04d1\3\2\2\2\u04d3\u04d4\3\2\2\2\u04d4\u04df\3\2\2\2\u04d5\u04d3\3\2" + + "\2\2\u04d6\u04da\7\36\2\2\u04d7\u04d9\7\7\2\2\u04d8\u04d7\3\2\2\2\u04d9" + + "\u04dc\3\2\2\2\u04da\u04d8\3\2\2\2\u04da\u04db\3\2\2\2\u04db\u04dd\3\2" + + "\2\2\u04dc\u04da\3\2\2\2\u04dd\u04e0\5\u0098M\2\u04de\u04e0\5J&\2\u04df" + + "\u04d6\3\2\2\2\u04df\u04de\3\2\2\2\u04e0\u04e2\3\2\2\2\u04e1\u04d3\3\2" + + "\2\2\u04e1\u04e2\3\2\2\2\u04e2\u04e9\3\2\2\2\u04e3\u04e5\7\7\2\2\u04e4" + + "\u04e3\3\2\2\2\u04e5\u04e6\3\2\2\2\u04e6\u04e4\3\2\2\2\u04e6\u04e7\3\2" + + "\2\2\u04e7\u04e8\3\2\2\2\u04e8\u04ea\7\35\2\2\u04e9\u04e4\3\2\2\2\u04e9" + + "\u04ea\3\2\2\2\u04ea\u04ee\3\2\2\2\u04eb\u04ed\7\7\2\2\u04ec\u04eb\3\2" + + "\2\2\u04ed\u04f0\3\2\2\2\u04ee\u04ec\3\2\2\2\u04ee\u04ef\3\2\2\2\u04ef" + + "\u050f\3\2\2\2\u04f0\u04ee\3\2\2\2\u04f1\u04f3\5L\'\2\u04f2\u04f1\3\2" + + "\2\2\u04f2\u04f3\3\2\2\2\u04f3\u04fe\3\2\2\2\u04f4\u04f6\7\7\2\2\u04f5" + + "\u04f4\3\2\2\2\u04f6\u04f9\3\2\2\2\u04f7\u04f5\3\2\2\2\u04f7\u04f8\3\2" + + "\2\2\u04f8\u04fb\3\2\2\2\u04f9\u04f7\3\2\2\2\u04fa\u04fc\5\u0094K\2\u04fb" + + "\u04fa\3\2\2\2\u04fb\u04fc\3\2\2\2\u04fc\u04fd\3\2\2\2\u04fd\u04ff\5N" + + "(\2\u04fe\u04f7\3\2\2\2\u04fe\u04ff\3\2\2\2\u04ff\u0510\3\2\2\2\u0500" + + "\u0502\5N(\2\u0501\u0500\3\2\2\2\u0501\u0502\3\2\2\2\u0502\u050d\3\2\2" + + "\2\u0503\u0505\7\7\2\2\u0504\u0503\3\2\2\2\u0505\u0508\3\2\2\2\u0506\u0504" + + "\3\2\2\2\u0506\u0507\3\2\2\2\u0507\u050a\3\2\2\2\u0508\u0506\3\2\2\2\u0509" + + "\u050b\5\u0094K\2\u050a\u0509\3\2\2\2\u050a\u050b\3\2\2\2\u050b\u050c" + + "\3\2\2\2\u050c\u050e\5L\'\2\u050d\u0506\3\2\2\2\u050d\u050e\3\2\2\2\u050e" + + "\u0510\3\2\2\2\u050f\u04f2\3\2\2\2\u050f\u0501\3\2\2\2\u0510I\3\2\2\2" + + "\u0511\u0515\7R\2\2\u0512\u0514\7\7\2\2\u0513\u0512\3\2\2\2\u0514\u0517" + + "\3\2\2\2\u0515\u0513\3\2\2\2\u0515\u0516\3\2\2\2\u0516\u0518\3\2\2\2\u0517" + + "\u0515\3\2\2\2\u0518\u0519\5\u0098M\2\u0519K\3\2\2\2\u051a\u051c\5\u012c" + + "\u0097\2\u051b\u051a\3\2\2\2\u051b\u051c\3\2\2\2\u051c\u051d\3\2\2\2\u051d" + + "\u0543\7B\2\2\u051e\u0520\7\7\2\2\u051f\u051e\3\2\2\2\u0520\u0523\3\2" + + "\2\2\u0521\u051f\3\2\2\2\u0521\u0522\3\2\2\2\u0522\u0524\3\2\2\2\u0523" + + "\u0521\3\2\2\2\u0524\u0528\7\13\2\2\u0525\u0527\7\7\2\2\u0526\u0525\3" + + "\2\2\2\u0527\u052a\3\2\2\2\u0528\u0526\3\2\2\2\u0528\u0529\3\2\2\2\u0529" + + "\u052b\3\2\2\2\u052a\u0528\3\2\2\2\u052b\u053a\7\f\2\2\u052c\u052e\7\7" + + "\2\2\u052d\u052c\3\2\2\2\u052e\u0531\3\2\2\2\u052f\u052d\3\2\2\2\u052f" + + "\u0530\3\2\2\2\u0530\u0532\3\2\2\2\u0531\u052f\3\2\2\2\u0532\u0536\7\34" + + "\2\2\u0533\u0535\7\7\2\2\u0534\u0533\3\2\2\2\u0535\u0538\3\2\2\2\u0536" + + "\u0534\3\2\2\2\u0536\u0537\3\2\2\2\u0537\u0539\3\2\2\2\u0538\u0536\3\2" + + "\2\2\u0539\u053b\5d\63\2\u053a\u052f\3\2\2\2\u053a\u053b\3\2\2\2\u053b" + + "\u053f\3\2\2\2\u053c\u053e\7\7\2\2\u053d\u053c\3\2\2\2\u053e\u0541\3\2" + + "\2\2\u053f\u053d\3\2\2\2\u053f\u0540\3\2\2\2\u0540\u0542\3\2\2\2\u0541" + + "\u053f\3\2\2\2\u0542\u0544\5B\"\2\u0543\u0521\3\2\2\2\u0543\u0544\3\2" + + "\2\2\u0544M\3\2\2\2\u0545\u0547\5\u012c\u0097\2\u0546\u0545\3\2\2\2\u0546" + + "\u0547\3\2\2\2\u0547\u0548\3\2\2\2\u0548\u057f\7C\2\2\u0549\u054b\7\7" + + "\2\2\u054a\u0549\3\2\2\2\u054b\u054e\3\2\2\2\u054c\u054a\3\2\2\2\u054c" + + "\u054d\3\2\2\2\u054d\u054f\3\2\2\2\u054e\u054c\3\2\2\2\u054f\u0553\7\13" + + "\2\2\u0550\u0552\7\7\2\2\u0551\u0550\3\2\2\2\u0552\u0555\3\2\2\2\u0553" + + "\u0551\3\2\2\2\u0553\u0554\3\2\2\2\u0554\u0556\3\2\2\2\u0555\u0553\3\2" + + "\2\2\u0556\u055e\5R*\2\u0557\u0559\7\7\2\2\u0558\u0557\3\2\2\2\u0559\u055c" + + "\3\2\2\2\u055a\u0558\3\2\2\2\u055a\u055b\3\2\2\2\u055b\u055d\3\2\2\2\u055c" + + "\u055a\3\2\2\2\u055d\u055f\7\n\2\2\u055e\u055a\3\2\2\2\u055e\u055f\3\2" + + "\2\2\u055f\u0563\3\2\2\2\u0560\u0562\7\7\2\2\u0561\u0560\3\2\2\2\u0562" + + "\u0565\3\2\2\2\u0563\u0561\3\2\2\2\u0563\u0564\3\2\2\2\u0564\u0566\3\2" + + "\2\2\u0565\u0563\3\2\2\2\u0566\u0575\7\f\2\2\u0567\u0569\7\7\2\2\u0568" + + "\u0567\3\2\2\2\u0569\u056c\3\2\2\2\u056a\u0568\3\2\2\2\u056a\u056b\3\2" + + "\2\2\u056b\u056d\3\2\2\2\u056c\u056a\3\2\2\2\u056d\u0571\7\34\2\2\u056e" + + "\u0570\7\7\2\2\u056f\u056e\3\2\2\2\u0570\u0573\3\2\2\2\u0571\u056f\3\2" + + "\2\2\u0571\u0572\3\2\2\2\u0572\u0574\3\2\2\2\u0573\u0571\3\2\2\2\u0574" + + "\u0576\5d\63\2\u0575\u056a\3\2\2\2\u0575\u0576\3\2\2\2\u0576\u057a\3\2" + + "\2\2\u0577\u0579\7\7\2\2\u0578\u0577\3\2\2\2\u0579\u057c\3\2\2\2\u057a" + + "\u0578\3\2\2\2\u057a\u057b\3\2\2\2\u057b\u057d\3\2\2\2\u057c\u057a\3\2" + + "\2\2\u057d\u057e\5B\"\2\u057e\u0580\3\2\2\2\u057f\u054c\3\2\2\2\u057f" + + "\u0580\3\2\2\2\u0580O\3\2\2\2\u0581\u0585\7\13\2\2\u0582\u0584\7\7\2\2" + + "\u0583\u0582\3\2\2\2\u0584\u0587\3\2\2\2\u0585\u0583\3\2\2\2\u0585\u0586" + + "\3\2\2\2\u0586\u05a5\3\2\2\2\u0587\u0585\3\2\2\2\u0588\u0599\5R*\2\u0589" + + "\u058b\7\7\2\2\u058a\u0589\3\2\2\2\u058b\u058e\3\2\2\2\u058c\u058a\3\2" + + "\2\2\u058c\u058d\3\2\2\2\u058d\u058f\3\2\2\2\u058e\u058c\3\2\2\2\u058f" + + "\u0593\7\n\2\2\u0590\u0592\7\7\2\2\u0591\u0590\3\2\2\2\u0592\u0595\3\2" + + "\2\2\u0593\u0591\3\2\2\2\u0593\u0594\3\2\2\2\u0594\u0596\3\2\2\2\u0595" + + "\u0593\3\2\2\2\u0596\u0598\5R*\2\u0597\u058c\3\2\2\2\u0598\u059b\3\2\2" + + "\2\u0599\u0597\3\2\2\2\u0599\u059a\3\2\2\2\u059a\u05a3\3\2\2\2\u059b\u0599" + + "\3\2\2\2\u059c\u059e\7\7\2\2\u059d\u059c\3\2\2\2\u059e\u05a1\3\2\2\2\u059f" + + "\u059d\3\2\2\2\u059f\u05a0\3\2\2\2\u05a0\u05a2\3\2\2\2\u05a1\u059f\3\2" + + "\2\2\u05a2\u05a4\7\n\2\2\u05a3\u059f\3\2\2\2\u05a3\u05a4\3\2\2\2\u05a4" + + "\u05a6\3\2\2\2\u05a5\u0588\3\2\2\2\u05a5\u05a6\3\2\2\2\u05a6\u05aa\3\2" + + "\2\2\u05a7\u05a9\7\7\2\2\u05a8\u05a7\3\2\2\2\u05a9\u05ac\3\2\2\2\u05aa" + + "\u05a8\3\2\2\2\u05aa\u05ab\3\2\2\2\u05ab\u05ad\3\2\2\2\u05ac\u05aa\3\2" + + "\2\2\u05ad\u05ae\7\f\2\2\u05aeQ\3\2\2\2\u05af\u05b1\5\u012e\u0098\2\u05b0" + + "\u05af\3\2\2\2\u05b0\u05b1\3\2\2\2\u05b1\u05b2\3\2\2\2\u05b2\u05c1\5T" + + "+\2\u05b3\u05b5\7\7\2\2\u05b4\u05b3\3\2\2\2\u05b5\u05b8\3\2\2\2\u05b6" + + "\u05b4\3\2\2\2\u05b6\u05b7\3\2\2\2\u05b7\u05b9\3\2\2\2\u05b8\u05b6\3\2" + + "\2\2\u05b9\u05bd\7\36\2\2\u05ba\u05bc\7\7\2\2\u05bb\u05ba\3\2\2\2\u05bc" + + "\u05bf\3\2\2\2\u05bd\u05bb\3\2\2\2\u05bd\u05be\3\2\2\2\u05be\u05c0\3\2" + + "\2\2\u05bf\u05bd\3\2\2\2\u05c0\u05c2\5\u0098M\2\u05c1\u05b6\3\2\2\2\u05c1" + + "\u05c2\3\2\2\2\u05c2S\3\2\2\2\u05c3\u05c7\5\u0158\u00ad\2\u05c4\u05c6" + + "\7\7\2\2\u05c5\u05c4\3\2\2\2\u05c6\u05c9\3\2\2\2\u05c7\u05c5\3\2\2\2\u05c7" + + "\u05c8\3\2\2\2\u05c8\u05d2\3\2\2\2\u05c9\u05c7\3\2\2\2\u05ca\u05ce\7\34" + + "\2\2\u05cb\u05cd\7\7\2\2\u05cc\u05cb\3\2\2\2\u05cd\u05d0\3\2\2\2\u05ce" + + "\u05cc\3\2\2\2\u05ce\u05cf\3\2\2\2\u05cf\u05d1\3\2\2\2\u05d0\u05ce\3\2" + + "\2\2\u05d1\u05d3\5d\63\2\u05d2\u05ca\3\2\2\2\u05d2\u05d3\3\2\2\2\u05d3" + + "U\3\2\2\2\u05d4\u05d8\5\u0158\u00ad\2\u05d5\u05d7\7\7\2\2\u05d6\u05d5" + + "\3\2\2\2\u05d7\u05da\3\2\2\2\u05d8\u05d6\3\2\2\2\u05d8\u05d9\3\2\2\2\u05d9" + + "\u05db\3\2\2\2\u05da\u05d8\3\2\2\2\u05db\u05df\7\34\2\2\u05dc\u05de\7" + + "\7\2\2\u05dd\u05dc\3\2\2\2\u05de\u05e1\3\2\2\2\u05df\u05dd\3\2\2\2\u05df" + + "\u05e0\3\2\2\2\u05e0\u05e2\3\2\2\2\u05e1\u05df\3\2\2\2\u05e2\u05e3\5d" + + "\63\2\u05e3W\3\2\2\2\u05e4\u05e6\5\u012c\u0097\2\u05e5\u05e4\3\2\2\2\u05e5" + + "\u05e6\3\2\2\2\u05e6\u05e7\3\2\2\2\u05e7\u05eb\7M\2\2\u05e8\u05ea\7\7" + + "\2\2\u05e9\u05e8\3\2\2\2\u05ea\u05ed\3\2\2\2\u05eb\u05e9\3\2\2\2\u05eb" + + "\u05ec\3\2\2\2\u05ec\u05ee\3\2\2\2\u05ed\u05eb\3\2\2\2\u05ee\u05fd\5\u0158" + + "\u00ad\2\u05ef\u05f1\7\7\2\2\u05f0\u05ef\3\2\2\2\u05f1\u05f4\3\2\2\2\u05f2" + + "\u05f0\3\2\2\2\u05f2\u05f3\3\2\2\2\u05f3\u05f5\3\2\2\2\u05f4\u05f2\3\2" + + "\2\2\u05f5\u05f9\7\34\2\2\u05f6\u05f8\7\7\2\2\u05f7\u05f6\3\2\2\2\u05f8" + + "\u05fb\3\2\2\2\u05f9\u05f7\3\2\2\2\u05f9\u05fa\3\2\2\2\u05fa\u05fc\3\2" + + "\2\2\u05fb\u05f9\3\2\2\2\u05fc\u05fe\5\"\22\2\u05fd\u05f2\3\2\2\2\u05fd" + + "\u05fe\3\2\2\2\u05fe\u0606\3\2\2\2\u05ff\u0601\7\7\2\2\u0600\u05ff\3\2" + + "\2\2\u0601\u0604\3\2\2\2\u0602\u0600\3\2\2\2\u0602\u0603\3\2\2\2\u0603" + + "\u0605\3\2\2\2\u0604\u0602\3\2\2\2\u0605\u0607\5\34\17\2\u0606\u0602\3" + + "\2\2\2\u0606\u0607\3\2\2\2\u0607Y\3\2\2\2\u0608\u060a\5\u012c\u0097\2" + + "\u0609\u0608\3\2\2\2\u0609\u060a\3\2\2\2\u060a\u060b\3\2\2\2\u060b\u060f" + + "\7Q\2\2\u060c\u060e\7\7\2\2\u060d\u060c\3\2\2\2\u060e\u0611\3\2\2\2\u060f" + + "\u060d\3\2\2\2\u060f\u0610\3\2\2\2\u0610\u0612\3\2\2\2\u0611\u060f\3\2" + + "\2\2\u0612\u0621\5<\37\2\u0613\u0615\7\7\2\2\u0614\u0613\3\2\2\2\u0615" + + "\u0618\3\2\2\2\u0616\u0614\3\2\2\2\u0616\u0617\3\2\2\2\u0617\u0619\3\2" + + "\2\2\u0618\u0616\3\2\2\2\u0619\u061d\7\34\2\2\u061a\u061c\7\7\2\2\u061b" + + "\u061a\3\2\2\2\u061c\u061f\3\2\2\2\u061d\u061b\3\2\2\2\u061d\u061e\3\2" + + "\2\2\u061e\u0620\3\2\2\2\u061f\u061d\3\2\2\2\u0620\u0622\5\\/\2\u0621" + + "\u0616\3\2\2\2\u0621\u0622\3\2\2\2\u0622\u0626\3\2\2\2\u0623\u0625\7\7" + + "\2\2\u0624\u0623\3\2\2\2\u0625\u0628\3\2\2\2\u0626\u0624\3\2\2\2\u0626" + + "\u0627\3\2\2\2\u0627\u062a\3\2\2\2\u0628\u0626\3\2\2\2\u0629\u062b\5\u0088" + + "E\2\u062a\u0629\3\2\2\2\u062a\u062b\3\2\2\2\u062b[\3\2\2\2\u062c\u0630" + + "\t\4\2\2\u062d\u062f\7\7\2\2\u062e\u062d\3\2\2\2\u062f\u0632\3\2\2\2\u0630" + + "\u062e\3\2\2\2\u0630\u0631\3\2\2\2\u0631\u0633\3\2\2\2\u0632\u0630\3\2" + + "\2\2\u0633\u0634\5\u00d0i\2\u0634]\3\2\2\2\u0635\u0639\7\17\2\2\u0636" + + "\u0638\7\7\2\2\u0637\u0636\3\2\2\2\u0638\u063b\3\2\2\2\u0639\u0637\3\2" + + "\2\2\u0639\u063a\3\2\2\2\u063a\u063d\3\2\2\2\u063b\u0639\3\2\2\2\u063c" + + "\u063e\5`\61\2\u063d\u063c\3\2\2\2\u063d\u063e\3\2\2\2\u063e\u064d\3\2" + + "\2\2\u063f\u0641\7\7\2\2\u0640\u063f\3\2\2\2\u0641\u0644\3\2\2\2\u0642" + + "\u0640\3\2\2\2\u0642\u0643\3\2\2\2\u0643\u0645\3\2\2\2\u0644\u0642\3\2" + + "\2\2\u0645\u0649\7\35\2\2\u0646\u0648\7\7\2\2\u0647\u0646\3\2\2\2\u0648" + + "\u064b\3\2\2\2\u0649\u0647\3\2\2\2\u0649\u064a\3\2\2\2\u064a\u064c\3\2" + + "\2\2\u064b\u0649\3\2\2\2\u064c\u064e\5\64\33\2\u064d\u0642\3\2\2\2\u064d" + + "\u064e\3\2\2\2\u064e\u0652\3\2\2\2\u064f\u0651\7\7\2\2\u0650\u064f\3\2" + + "\2\2\u0651\u0654\3\2\2\2\u0652\u0650\3\2\2\2\u0652\u0653\3\2\2\2\u0653" + + "\u0655\3\2\2\2\u0654\u0652\3\2\2\2\u0655\u0656\7\20\2\2\u0656_\3\2\2\2" + + "\u0657\u0668\5b\62\2\u0658\u065a\7\7\2\2\u0659\u0658\3\2\2\2\u065a\u065d" + + "\3\2\2\2\u065b\u0659\3\2\2\2\u065b\u065c\3\2\2\2\u065c\u065e\3\2\2\2\u065d" + + "\u065b\3\2\2\2\u065e\u0662\7\n\2\2\u065f\u0661\7\7\2\2\u0660\u065f\3\2" + + "\2\2\u0661\u0664\3\2\2\2\u0662\u0660\3\2\2\2\u0662\u0663\3\2\2\2\u0663" + + "\u0665\3\2\2\2\u0664\u0662\3\2\2\2\u0665\u0667\5b\62\2\u0666\u065b\3\2" + + "\2\2\u0667\u066a\3\2\2\2\u0668\u0666\3\2\2\2\u0668\u0669\3\2\2\2\u0669" + + "\u066e\3\2\2\2\u066a\u0668\3\2\2\2\u066b\u066d\7\7\2\2\u066c\u066b\3\2" + + "\2\2\u066d\u0670\3\2\2\2\u066e\u066c\3\2\2\2\u066e\u066f\3\2\2\2\u066f" + + "\u0672\3\2\2\2\u0670\u066e\3\2\2\2\u0671\u0673\7\n\2\2\u0672\u0671\3\2" + + "\2\2\u0672\u0673\3\2\2\2\u0673a\3\2\2\2\u0674\u0678\5\u012c\u0097\2\u0675" + + "\u0677\7\7\2\2\u0676\u0675\3\2\2\2\u0677\u067a\3\2\2\2\u0678\u0676\3\2" + + "\2\2\u0678\u0679\3\2\2\2\u0679\u067c\3\2\2\2\u067a\u0678\3\2\2\2\u067b" + + "\u0674\3\2\2\2\u067b\u067c\3\2\2\2\u067c\u067d\3\2\2\2\u067d\u0685\5\u0158" + + "\u00ad\2\u067e\u0680\7\7\2\2\u067f\u067e\3\2\2\2\u0680\u0683\3\2\2\2\u0681" + + "\u067f\3\2\2\2\u0681\u0682\3\2\2\2\u0682\u0684\3\2\2\2\u0683\u0681\3\2" + + "\2\2\u0684\u0686\5\u00d0i\2\u0685\u0681\3\2\2\2\u0685\u0686\3\2\2\2\u0686" + + "\u068e\3\2\2\2\u0687\u0689\7\7\2\2\u0688\u0687\3\2\2\2\u0689\u068c\3\2" + + "\2\2\u068a\u0688\3\2\2\2\u068a\u068b\3\2\2\2\u068b\u068d\3\2\2\2\u068c" + + "\u068a\3\2\2\2\u068d\u068f\5\34\17\2\u068e\u068a\3\2\2\2\u068e\u068f\3" + + "\2\2\2\u068fc\3\2\2\2\u0690\u0692\5\u0132\u009a\2\u0691\u0690\3\2\2\2" + + "\u0691\u0692\3\2\2\2\u0692\u0697\3\2\2\2\u0693\u0698\5z>\2\u0694\u0698" + + "\5h\65\2\u0695\u0698\5f\64\2\u0696\u0698\5v<\2\u0697\u0693\3\2\2\2\u0697" + + "\u0694\3\2\2\2\u0697\u0695\3\2\2\2\u0697\u0696\3\2\2\2\u0698e\3\2\2\2" + + "\u0699\u069c\5l\67\2\u069a\u069c\7l\2\2\u069b\u0699\3\2\2\2\u069b\u069a" + + "\3\2\2\2\u069cg\3\2\2\2\u069d\u06a0\5f\64\2\u069e\u06a0\5z>\2\u069f\u069d" + + "\3\2\2\2\u069f\u069e\3\2\2\2\u06a0\u06a4\3\2\2\2\u06a1\u06a3\7\7\2\2\u06a2" + + "\u06a1\3\2\2\2\u06a3\u06a6\3\2\2\2\u06a4\u06a2\3\2\2\2\u06a4\u06a5\3\2" + + "\2\2\u06a5\u06a8\3\2\2\2\u06a6\u06a4\3\2\2\2\u06a7\u06a9\5j\66\2\u06a8" + + "\u06a7\3\2\2\2\u06a9\u06aa\3\2\2\2\u06aa\u06a8\3\2\2\2\u06aa\u06ab\3\2" + + "\2\2\u06abi\3\2\2\2\u06ac\u06ad\t\5\2\2\u06adk\3\2\2\2\u06ae\u06bf\5n" + + "8\2\u06af\u06b1\7\7\2\2\u06b0\u06af\3\2\2\2\u06b1\u06b4\3\2\2\2\u06b2" + + "\u06b0\3\2\2\2\u06b2\u06b3\3\2\2\2\u06b3\u06b5\3\2\2\2\u06b4\u06b2\3\2" + + "\2\2\u06b5\u06b9\7\t\2\2\u06b6\u06b8\7\7\2\2\u06b7\u06b6\3\2\2\2\u06b8" + + "\u06bb\3\2\2\2\u06b9\u06b7\3\2\2\2\u06b9\u06ba\3\2\2\2\u06ba\u06bc\3\2" + + "\2\2\u06bb\u06b9\3\2\2\2\u06bc\u06be\5n8\2\u06bd\u06b2\3\2\2\2\u06be\u06c1" + + "\3\2\2\2\u06bf\u06bd\3\2\2\2\u06bf\u06c0\3\2\2\2\u06c0m\3\2\2\2\u06c1" + + "\u06bf\3\2\2\2\u06c2\u06ca\5\u0158\u00ad\2\u06c3\u06c5\7\7\2\2\u06c4\u06c3" + + "\3\2\2\2\u06c5\u06c8\3\2\2\2\u06c6\u06c4\3\2\2\2\u06c6\u06c7\3\2\2\2\u06c7" + + "\u06c9\3\2\2\2\u06c8\u06c6\3\2\2\2\u06c9\u06cb\5\u00ceh\2\u06ca\u06c6" + + "\3\2\2\2\u06ca\u06cb\3\2\2\2\u06cbo\3\2\2\2\u06cc\u06ce\5r:\2\u06cd\u06cc" + + "\3\2\2\2\u06cd\u06ce\3\2\2\2\u06ce\u06cf\3\2\2\2\u06cf\u06d2\5d\63\2\u06d0" + + "\u06d2\7\21\2\2\u06d1\u06cd\3\2\2\2\u06d1\u06d0\3\2\2\2\u06d2q\3\2\2\2" + + "\u06d3\u06d5\5t;\2\u06d4\u06d3\3\2\2\2\u06d5\u06d6\3\2\2\2\u06d6\u06d4" + + "\3\2\2\2\u06d6\u06d7\3\2\2\2\u06d7s\3\2\2\2\u06d8\u06dc\5\u013c\u009f" + + "\2\u06d9\u06db\7\7\2\2\u06da\u06d9\3\2\2\2\u06db\u06de\3\2\2\2\u06dc\u06da" + + "\3\2\2\2\u06dc\u06dd\3\2\2\2\u06dd\u06e1\3\2\2\2\u06de\u06dc\3\2\2\2\u06df" + + "\u06e1\5\u014e\u00a8\2\u06e0\u06d8\3\2\2\2\u06e0\u06df\3\2\2\2\u06e1u" + + "\3\2\2\2\u06e2\u06e6\5|?\2\u06e3\u06e5\7\7\2\2\u06e4\u06e3\3\2\2\2\u06e5" + + "\u06e8\3\2\2\2\u06e6\u06e4\3\2\2\2\u06e6\u06e7\3\2\2\2\u06e7\u06e9\3\2" + + "\2\2\u06e8\u06e6\3\2\2\2\u06e9\u06ed\7\t\2\2\u06ea\u06ec\7\7\2\2\u06eb" + + "\u06ea\3\2\2\2\u06ec\u06ef\3\2\2\2\u06ed\u06eb\3\2\2\2\u06ed\u06ee\3\2" + + "\2\2\u06ee\u06f1\3\2\2\2\u06ef\u06ed\3\2\2\2\u06f0\u06e2\3\2\2\2\u06f0" + + "\u06f1\3\2\2\2\u06f1\u06f2\3\2\2\2\u06f2\u06f6\5x=\2\u06f3\u06f5\7\7\2" + + "\2\u06f4\u06f3\3\2\2\2\u06f5\u06f8\3\2\2\2\u06f6\u06f4\3\2\2\2\u06f6\u06f7" + + "\3\2\2\2\u06f7\u06f9\3\2\2\2\u06f8\u06f6\3\2\2\2\u06f9\u06fd\7$\2\2\u06fa" + + "\u06fc\7\7\2\2\u06fb\u06fa\3\2\2\2\u06fc\u06ff\3\2\2\2\u06fd\u06fb\3\2" + + "\2\2\u06fd\u06fe\3\2\2\2\u06fe\u0700\3\2\2\2\u06ff\u06fd\3\2\2\2\u0700" + + "\u0701\5d\63\2\u0701w\3\2\2\2\u0702\u0706\7\13\2\2\u0703\u0705\7\7\2\2" + + "\u0704\u0703\3\2\2\2\u0705\u0708\3\2\2\2\u0706\u0704\3\2\2\2\u0706\u0707" + + "\3\2\2\2\u0707\u070b\3\2\2\2\u0708\u0706\3\2\2\2\u0709\u070c\5V,\2\u070a" + + "\u070c\5d\63\2\u070b\u0709\3\2\2\2\u070b\u070a\3\2\2\2\u070b\u070c\3\2" + + "\2\2\u070c\u0720\3\2\2\2\u070d\u070f\7\7\2\2\u070e\u070d\3\2\2\2\u070f" + + "\u0712\3\2\2\2\u0710\u070e\3\2\2\2\u0710\u0711\3\2\2\2\u0711\u0713\3\2" + + "\2\2\u0712\u0710\3\2\2\2\u0713\u0717\7\n\2\2\u0714\u0716\7\7\2\2\u0715" + + "\u0714\3\2\2\2\u0716\u0719\3\2\2\2\u0717\u0715\3\2\2\2\u0717\u0718\3\2" + + "\2\2\u0718\u071c\3\2\2\2\u0719\u0717\3\2\2\2\u071a\u071d\5V,\2\u071b\u071d" + + "\5d\63\2\u071c\u071a\3\2\2\2\u071c\u071b\3\2\2\2\u071d\u071f\3\2\2\2\u071e" + + "\u0710\3\2\2\2\u071f\u0722\3\2\2\2\u0720\u071e\3\2\2\2\u0720\u0721\3\2" + + "\2\2\u0721\u072a\3\2\2\2\u0722\u0720\3\2\2\2\u0723\u0725\7\7\2\2\u0724" + + "\u0723\3\2\2\2\u0725\u0728\3\2\2\2\u0726\u0724\3\2\2\2\u0726\u0727\3\2" + + "\2\2\u0727\u0729\3\2\2\2\u0728\u0726\3\2\2\2\u0729\u072b\7\n\2\2\u072a" + + "\u0726\3\2\2\2\u072a\u072b\3\2\2\2\u072b\u072f\3\2\2\2\u072c\u072e\7\7" + + "\2\2\u072d\u072c\3\2\2\2\u072e\u0731\3\2\2\2\u072f\u072d\3\2\2\2\u072f" + + "\u0730\3\2\2\2\u0730\u0732\3\2\2\2\u0731\u072f\3\2\2\2\u0732\u0733\7\f" + + "\2\2\u0733y\3\2\2\2\u0734\u0738\7\13\2\2\u0735\u0737\7\7\2\2\u0736\u0735" + + "\3\2\2\2\u0737\u073a\3\2\2\2\u0738\u0736\3\2\2\2\u0738\u0739\3\2\2\2\u0739" + + "\u073b\3\2\2\2\u073a\u0738\3\2\2\2\u073b\u073f\5d\63\2\u073c\u073e\7\7" + + "\2\2\u073d\u073c\3\2\2\2\u073e\u0741\3\2\2\2\u073f\u073d\3\2\2\2\u073f" + + "\u0740\3\2\2\2\u0740\u0742\3\2\2\2\u0741\u073f\3\2\2\2\u0742\u0743\7\f" + + "\2\2\u0743{\3\2\2\2\u0744\u0746\5\u0132\u009a\2\u0745\u0744\3\2\2\2\u0745" + + "\u0746\3\2\2\2\u0746\u074a\3\2\2\2\u0747\u074b\5z>\2\u0748\u074b\5h\65" + + "\2\u0749\u074b\5f\64\2\u074a\u0747\3\2\2\2\u074a\u0748\3\2\2\2\u074a\u0749" + + "\3\2\2\2\u074b}\3\2\2\2\u074c\u0750\7\13\2\2\u074d\u074f\7\7\2\2\u074e" + + "\u074d\3\2\2\2\u074f\u0752\3\2\2\2\u0750\u074e\3\2\2\2\u0750\u0751\3\2" + + "\2\2\u0751\u0755\3\2\2\2\u0752\u0750\3\2\2\2\u0753\u0756\5l\67\2\u0754" + + "\u0756\5~@\2\u0755\u0753\3\2\2\2\u0755\u0754\3\2\2\2\u0756\u075a\3\2\2" + + "\2\u0757\u0759\7\7\2\2\u0758\u0757\3\2\2\2\u0759\u075c\3\2\2\2\u075a\u0758" + + "\3\2\2\2\u075a\u075b\3\2\2\2\u075b\u075d\3\2\2\2\u075c\u075a\3\2\2\2\u075d" + + "\u075e\7\f\2\2\u075e\177\3\2\2\2\u075f\u0765\5\u0082B\2\u0760\u0761\5" + + "\u0096L\2\u0761\u0762\5\u0082B\2\u0762\u0764\3\2\2\2\u0763\u0760\3\2\2" + + "\2\u0764\u0767\3\2\2\2\u0765\u0763\3\2\2\2\u0765\u0766\3\2\2\2\u0766\u0769" + + "\3\2\2\2\u0767\u0765\3\2\2\2\u0768\u075f\3\2\2\2\u0768\u0769\3\2\2\2\u0769" + + "\u076b\3\2\2\2\u076a\u076c\5\u0096L\2\u076b\u076a\3\2\2\2\u076b\u076c" + + "\3\2\2\2\u076c\u0081\3\2\2\2\u076d\u0770\5\u0084C\2\u076e\u0770\5\u014e" + + "\u00a8\2\u076f\u076d\3\2\2\2\u076f\u076e\3\2\2\2\u0770\u0773\3\2\2\2\u0771" + + "\u076f\3\2\2\2\u0771\u0772\3\2\2\2\u0772\u0778\3\2\2\2\u0773\u0771\3\2" + + "\2\2\u0774\u0779\5\26\f\2\u0775\u0779\5\u0092J\2\u0776\u0779\5\u008aF" + + "\2\u0777\u0779\5\u0098M\2\u0778\u0774\3\2\2\2\u0778\u0775\3\2\2\2\u0778" + + "\u0776\3\2\2\2\u0778\u0777\3\2\2\2\u0779\u0083\3\2\2\2\u077a\u077b\5\u0158" + + "\u00ad\2\u077b\u077f\t\6\2\2\u077c\u077e\7\7\2\2\u077d\u077c\3\2\2\2\u077e" + + "\u0781\3\2\2\2\u077f\u077d\3\2\2\2\u077f\u0780\3\2\2\2\u0780\u0085\3\2" + + "\2\2\u0781\u077f\3\2\2\2\u0782\u0785\5\u0088E\2\u0783\u0785\5\u0082B\2" + + "\u0784\u0782\3\2\2\2\u0784\u0783\3\2\2\2\u0785\u0087\3\2\2\2\u0786\u078a" + + "\7\17\2\2\u0787\u0789\7\7\2\2\u0788\u0787\3\2\2\2\u0789\u078c\3\2\2\2" + + "\u078a\u0788\3\2\2\2\u078a\u078b\3\2\2\2\u078b\u078d\3\2\2\2\u078c\u078a" + + "\3\2\2\2\u078d\u0791\5\u0080A\2\u078e\u0790\7\7\2\2\u078f\u078e\3\2\2" + + "\2\u0790\u0793\3\2\2\2\u0791\u078f\3\2\2\2\u0791\u0792\3\2\2\2\u0792\u0794" + + "\3\2\2\2\u0793\u0791\3\2\2\2\u0794\u0795\7\20\2\2\u0795\u0089\3\2\2\2" + + "\u0796\u079a\5\u008cG\2\u0797\u079a\5\u008eH\2\u0798\u079a\5\u0090I\2" + + "\u0799\u0796\3\2\2\2\u0799\u0797\3\2\2\2\u0799\u0798\3\2\2\2\u079a\u008b" + + "\3\2\2\2\u079b\u079f\7_\2\2\u079c\u079e\7\7\2\2\u079d\u079c\3\2\2\2\u079e" + + "\u07a1\3\2\2\2\u079f\u079d\3\2\2\2\u079f\u07a0\3\2\2\2\u07a0\u07a2\3\2" + + "\2\2\u07a1\u079f\3\2\2\2\u07a2\u07a6\7\13\2\2\u07a3\u07a5\5\u014e\u00a8" + + "\2\u07a4\u07a3\3\2\2\2\u07a5\u07a8\3\2\2\2\u07a6\u07a4\3\2\2\2\u07a6\u07a7" + + "\3\2\2\2\u07a7\u07ab\3\2\2\2\u07a8\u07a6\3\2\2\2\u07a9\u07ac\5D#\2\u07aa" + + "\u07ac\5F$\2\u07ab\u07a9\3\2\2\2\u07ab\u07aa\3\2\2\2\u07ac\u07ad\3\2\2" + + "\2\u07ad\u07ae\7h\2\2\u07ae\u07af\5\u0098M\2\u07af\u07b3\7\f\2\2\u07b0" + + "\u07b2\7\7\2\2\u07b1\u07b0\3\2\2\2\u07b2\u07b5\3\2\2\2\u07b3\u07b1\3\2" + + "\2\2\u07b3\u07b4\3\2\2\2\u07b4\u07b7\3\2\2\2\u07b5\u07b3\3\2\2\2\u07b6" + + "\u07b8\5\u0086D\2\u07b7\u07b6\3\2\2\2\u07b7\u07b8\3\2\2\2\u07b8\u008d" + + "\3\2\2\2\u07b9\u07bd\7a\2\2\u07ba\u07bc\7\7\2\2\u07bb\u07ba\3\2\2\2\u07bc" + + "\u07bf\3\2\2\2\u07bd\u07bb\3\2\2\2\u07bd\u07be\3\2\2\2\u07be\u07c0\3\2" + + "\2\2\u07bf\u07bd\3\2\2\2\u07c0\u07c1\7\13\2\2\u07c1\u07c2\5\u0098M\2\u07c2" + + "\u07c6\7\f\2\2\u07c3\u07c5\7\7\2\2\u07c4\u07c3\3\2\2\2\u07c5\u07c8\3\2" + + "\2\2\u07c6\u07c4\3\2\2\2\u07c6\u07c7\3\2\2\2\u07c7\u07cb\3\2\2\2\u07c8" + + "\u07c6\3\2\2\2\u07c9\u07cc\5\u0086D\2\u07ca\u07cc\7\35\2\2\u07cb\u07c9" + + "\3\2\2\2\u07cb\u07ca\3\2\2\2\u07cc\u008f\3\2\2\2\u07cd\u07d1\7`\2\2\u07ce" + + "\u07d0\7\7\2\2\u07cf\u07ce\3\2\2\2\u07d0\u07d3\3\2\2\2\u07d1\u07cf\3\2" + + "\2\2\u07d1\u07d2\3\2\2\2\u07d2\u07d5\3\2\2\2\u07d3\u07d1\3\2\2\2\u07d4" + + "\u07d6\5\u0086D\2\u07d5\u07d4\3\2\2\2\u07d5\u07d6\3\2\2\2\u07d6\u07da" + + "\3\2\2\2\u07d7\u07d9\7\7\2\2\u07d8\u07d7\3\2\2\2\u07d9\u07dc\3\2\2\2\u07da" + + "\u07d8\3\2\2\2\u07da\u07db\3\2\2\2\u07db\u07dd\3\2\2\2\u07dc\u07da\3\2" + + "\2\2\u07dd\u07e1\7a\2\2\u07de\u07e0\7\7\2\2\u07df\u07de\3\2\2\2\u07e0" + + "\u07e3\3\2\2\2\u07e1\u07df\3\2\2\2\u07e1\u07e2\3\2\2\2\u07e2\u07e4\3\2" + + "\2\2\u07e3\u07e1\3\2\2\2\u07e4\u07e5\7\13\2\2\u07e5\u07e6\5\u0098M\2\u07e6" + + "\u07e7\7\f\2\2\u07e7\u0091\3\2\2\2\u07e8\u07e9\5\u00bc_\2\u07e9\u07ea" + + "\7\36\2\2\u07ea\u07ef\3\2\2\2\u07eb\u07ec\5\u00c0a\2\u07ec\u07ed\5\u0112" + + "\u008a\2\u07ed\u07ef\3\2\2\2\u07ee\u07e8\3\2\2\2\u07ee\u07eb\3\2\2\2\u07ef" + + "\u07f3\3\2\2\2\u07f0\u07f2\7\7\2\2\u07f1\u07f0\3\2\2\2\u07f2\u07f5\3\2" + + "\2\2\u07f3\u07f1\3\2\2\2\u07f3\u07f4\3\2\2\2\u07f4\u07f6\3\2\2\2\u07f5" + + "\u07f3\3\2\2\2\u07f6\u07f7\5\u0098M\2\u07f7\u0093\3\2\2\2\u07f8\u07fc" + + "\t\7\2\2\u07f9\u07fb\7\7\2\2\u07fa\u07f9\3\2\2\2\u07fb\u07fe\3\2\2\2\u07fc" + + "\u07fa\3\2\2\2\u07fc\u07fd\3\2\2\2\u07fd\u0801\3\2\2\2\u07fe\u07fc\3\2" + + "\2\2\u07ff\u0801\7\2\2\3\u0800\u07f8\3\2\2\2\u0800\u07ff\3\2\2\2\u0801" + + "\u0095\3\2\2\2\u0802\u0804\t\7\2\2\u0803\u0802\3\2\2\2\u0804\u0805\3\2" + + "\2\2\u0805\u0803\3\2\2\2\u0805\u0806\3\2\2\2\u0806\u0809\3\2\2\2\u0807" + + "\u0809\7\2\2\3\u0808\u0803\3\2\2\2\u0808\u0807\3\2\2\2\u0809\u0097\3\2" + + "\2\2\u080a\u080b\5\u009aN\2\u080b\u0099\3\2\2\2\u080c\u081d\5\u009cO\2" + + "\u080d\u080f\7\7\2\2\u080e\u080d\3\2\2\2\u080f\u0812\3\2\2\2\u0810\u080e" + + "\3\2\2\2\u0810\u0811\3\2\2\2\u0811\u0813\3\2\2\2\u0812\u0810\3\2\2\2\u0813" + + "\u0817\7\31\2\2\u0814\u0816\7\7\2\2\u0815\u0814\3\2\2\2\u0816\u0819\3" + + "\2\2\2\u0817\u0815\3\2\2\2\u0817\u0818\3\2\2\2\u0818\u081a\3\2\2\2\u0819" + + "\u0817\3\2\2\2\u081a\u081c\5\u009cO\2\u081b\u0810\3\2\2\2\u081c\u081f" + + "\3\2\2\2\u081d\u081b\3\2\2\2\u081d\u081e\3\2\2\2\u081e\u009b\3\2\2\2\u081f" + + "\u081d\3\2\2\2\u0820\u0831\5\u009eP\2\u0821\u0823\7\7\2\2\u0822\u0821" + + "\3\2\2\2\u0823\u0826\3\2\2\2\u0824\u0822\3\2\2\2\u0824\u0825\3\2\2\2\u0825" + + "\u0827\3\2\2\2\u0826\u0824\3\2\2\2\u0827\u082b\7\30\2\2\u0828\u082a\7" + + "\7\2\2\u0829\u0828\3\2\2\2\u082a\u082d\3\2\2\2\u082b\u0829\3\2\2\2\u082b" + + "\u082c\3\2\2\2\u082c\u082e\3\2\2\2\u082d\u082b\3\2\2\2\u082e\u0830\5\u009e" + + "P\2\u082f\u0824\3\2\2\2\u0830\u0833\3\2\2\2\u0831\u082f\3\2\2\2\u0831" + + "\u0832\3\2\2\2\u0832\u009d\3\2\2\2\u0833\u0831\3\2\2\2\u0834\u0840\5\u00a0" + + "Q\2\u0835\u0839\5\u0114\u008b\2\u0836\u0838\7\7\2\2\u0837\u0836\3\2\2" + + "\2\u0838\u083b\3\2\2\2\u0839\u0837\3\2\2\2\u0839\u083a\3\2\2\2\u083a\u083c" + + "\3\2\2\2\u083b\u0839\3\2\2\2\u083c\u083d\5\u00a0Q\2\u083d\u083f\3\2\2" + + "\2\u083e\u0835\3\2\2\2\u083f\u0842\3\2\2\2\u0840\u083e\3\2\2\2\u0840\u0841" + + "\3\2\2\2\u0841\u009f\3\2\2\2\u0842\u0840\3\2\2\2\u0843\u084f\5\u00a2R" + + "\2\u0844\u0848\5\u0116\u008c\2\u0845\u0847\7\7\2\2\u0846\u0845\3\2\2\2" + + "\u0847\u084a\3\2\2\2\u0848\u0846\3\2\2\2\u0848\u0849\3\2\2\2\u0849\u084b" + + "\3\2\2\2\u084a\u0848\3\2\2\2\u084b\u084c\5\u00a2R\2\u084c\u084e\3\2\2" + + "\2\u084d\u0844\3\2\2\2\u084e\u0851\3\2\2\2\u084f\u084d\3\2\2\2\u084f\u0850" + + "\3\2\2\2\u0850\u00a1\3\2\2\2\u0851"; + private static final String _serializedATNSegment1 = + "\u084f\3\2\2\2\u0852\u0856\5\u00a4S\2\u0853\u0855\5\u00caf\2\u0854\u0853" + + "\3\2\2\2\u0855\u0858\3\2\2\2\u0856\u0854\3\2\2\2\u0856\u0857\3\2\2\2\u0857" + + "\u00a3\3\2\2\2\u0858\u0856\3\2\2\2\u0859\u086e\5\u00a6T\2\u085a\u085e" + + "\5\u0118\u008d\2\u085b\u085d\7\7\2\2\u085c\u085b\3\2\2\2\u085d\u0860\3" + + "\2\2\2\u085e\u085c\3\2\2\2\u085e\u085f\3\2\2\2\u085f\u0861\3\2\2\2\u0860" + + "\u085e\3\2\2\2\u0861\u0862\5\u00a6T\2\u0862\u086d\3\2\2\2\u0863\u0867" + + "\5\u011a\u008e\2\u0864\u0866\7\7\2\2\u0865\u0864\3\2\2\2\u0866\u0869\3" + + "\2\2\2\u0867\u0865\3\2\2\2\u0867\u0868\3\2\2\2\u0868\u086a\3\2\2\2\u0869" + + "\u0867\3\2\2\2\u086a\u086b\5d\63\2\u086b\u086d\3\2\2\2\u086c\u085a\3\2" + + "\2\2\u086c\u0863\3\2\2\2\u086d\u0870\3\2\2\2\u086e\u086c\3\2\2\2\u086e" + + "\u086f\3\2\2\2\u086f\u00a5\3\2\2\2\u0870\u086e\3\2\2\2\u0871\u0883\5\u00aa" + + "V\2\u0872\u0874\7\7\2\2\u0873\u0872\3\2\2\2\u0874\u0877\3\2\2\2\u0875" + + "\u0873\3\2\2\2\u0875\u0876\3\2\2\2\u0876\u0878\3\2\2\2\u0877\u0875\3\2" + + "\2\2\u0878\u087c\5\u00a8U\2\u0879\u087b\7\7\2\2\u087a\u0879\3\2\2\2\u087b" + + "\u087e\3\2\2\2\u087c\u087a\3\2\2\2\u087c\u087d\3\2\2\2\u087d\u087f\3\2" + + "\2\2\u087e\u087c\3\2\2\2\u087f\u0880\5\u00aaV\2\u0880\u0882\3\2\2\2\u0881" + + "\u0875\3\2\2\2\u0882\u0885\3\2\2\2\u0883\u0881\3\2\2\2\u0883\u0884\3\2" + + "\2\2\u0884\u00a7\3\2\2\2\u0885\u0883\3\2\2\2\u0886\u0887\7/\2\2\u0887" + + "\u0888\7\34\2\2\u0888\u00a9\3\2\2\2\u0889\u0895\5\u00acW\2\u088a\u088e" + + "\5\u0158\u00ad\2\u088b\u088d\7\7\2\2\u088c\u088b\3\2\2\2\u088d\u0890\3" + + "\2\2\2\u088e\u088c\3\2\2\2\u088e\u088f\3\2\2\2\u088f\u0891\3\2\2\2\u0890" + + "\u088e\3\2\2\2\u0891\u0892\5\u00acW\2\u0892\u0894\3\2\2\2\u0893\u088a" + + "\3\2\2\2\u0894\u0897\3\2\2\2\u0895\u0893\3\2\2\2\u0895\u0896\3\2\2\2\u0896" + + "\u00ab\3\2\2\2\u0897\u0895\3\2\2\2\u0898\u08a3\5\u00aeX\2\u0899\u089d" + + "\7&\2\2\u089a\u089c\7\7\2\2\u089b\u089a\3\2\2\2\u089c\u089f\3\2\2\2\u089d" + + "\u089b\3\2\2\2\u089d\u089e\3\2\2\2\u089e\u08a0\3\2\2\2\u089f\u089d\3\2" + + "\2\2\u08a0\u08a2\5\u00aeX\2\u08a1\u0899\3\2\2\2\u08a2\u08a5\3\2\2\2\u08a3" + + "\u08a1\3\2\2\2\u08a3\u08a4\3\2\2\2\u08a4\u00ad\3\2\2\2\u08a5\u08a3\3\2" + + "\2\2\u08a6\u08b2\5\u00b0Y\2\u08a7\u08ab\5\u011c\u008f\2\u08a8\u08aa\7" + + "\7\2\2\u08a9\u08a8\3\2\2\2\u08aa\u08ad\3\2\2\2\u08ab\u08a9\3\2\2\2\u08ab" + + "\u08ac\3\2\2\2\u08ac\u08ae\3\2\2\2\u08ad\u08ab\3\2\2\2\u08ae\u08af\5\u00b0" + + "Y\2\u08af\u08b1\3\2\2\2\u08b0\u08a7\3\2\2\2\u08b1\u08b4\3\2\2\2\u08b2" + + "\u08b0\3\2\2\2\u08b2\u08b3\3\2\2\2\u08b3\u00af\3\2\2\2\u08b4\u08b2\3\2" + + "\2\2\u08b5\u08c1\5\u00b2Z\2\u08b6\u08ba\5\u011e\u0090\2\u08b7\u08b9\7" + + "\7\2\2\u08b8\u08b7\3\2\2\2\u08b9\u08bc\3\2\2\2\u08ba\u08b8\3\2\2\2\u08ba" + + "\u08bb\3\2\2\2\u08bb\u08bd\3\2\2\2\u08bc\u08ba\3\2\2\2\u08bd\u08be\5\u00b2" + + "Z\2\u08be\u08c0\3\2\2\2\u08bf\u08b6\3\2\2\2\u08c0\u08c3\3\2\2\2\u08c1" + + "\u08bf\3\2\2\2\u08c1\u08c2\3\2\2\2\u08c2\u00b1\3\2\2\2\u08c3\u08c1\3\2" + + "\2\2\u08c4\u08d6\5\u00b4[\2\u08c5\u08c7\7\7\2\2\u08c6\u08c5\3\2\2\2\u08c7" + + "\u08ca\3\2\2\2\u08c8\u08c6\3\2\2\2\u08c8\u08c9\3\2\2\2\u08c9\u08cb\3\2" + + "\2\2\u08ca\u08c8\3\2\2\2\u08cb\u08cf\5\u0120\u0091\2\u08cc\u08ce\7\7\2" + + "\2\u08cd\u08cc\3\2\2\2\u08ce\u08d1\3\2\2\2\u08cf\u08cd\3\2\2\2\u08cf\u08d0" + + "\3\2\2\2\u08d0\u08d2\3\2\2\2\u08d1\u08cf\3\2\2\2\u08d2\u08d3\5d\63\2\u08d3" + + "\u08d5\3\2\2\2\u08d4\u08c8\3\2\2\2\u08d5\u08d8\3\2\2\2\u08d6\u08d4\3\2" + + "\2\2\u08d6\u08d7\3\2\2\2\u08d7\u00b3\3\2\2\2\u08d8\u08d6\3\2\2\2\u08d9" + + "\u08db\5\u00b6\\\2\u08da\u08d9\3\2\2\2\u08db\u08de\3\2\2\2\u08dc\u08da" + + "\3\2\2\2\u08dc\u08dd\3\2\2\2\u08dd\u08df\3\2\2\2\u08de\u08dc\3\2\2\2\u08df" + + "\u08e0\5\u00b8]\2\u08e0\u00b5\3\2\2\2\u08e1\u08eb\5\u014e\u00a8\2\u08e2" + + "\u08eb\5\u0084C\2\u08e3\u08e7\5\u0122\u0092\2\u08e4\u08e6\7\7\2\2\u08e5" + + "\u08e4\3\2\2\2\u08e6\u08e9\3\2\2\2\u08e7\u08e5\3\2\2\2\u08e7\u08e8\3\2" + + "\2\2\u08e8\u08eb\3\2\2\2\u08e9\u08e7\3\2\2\2\u08ea\u08e1\3\2\2\2\u08ea" + + "\u08e2\3\2\2\2\u08ea\u08e3\3\2\2\2\u08eb\u00b7\3\2\2\2\u08ec\u08f0\5\u00d4" + + "k\2\u08ed\u08ef\5\u00ba^\2\u08ee\u08ed\3\2\2\2\u08ef\u08f2\3\2\2\2\u08f0" + + "\u08ee\3\2\2\2\u08f0\u08f1\3\2\2\2\u08f1\u00b9\3\2\2\2\u08f2\u08f0\3\2" + + "\2\2\u08f3\u08f9\5\u0124\u0093\2\u08f4\u08f9\5\u00ceh\2\u08f5\u08f9\5" + + "\u00caf\2\u08f6\u08f9\5\u00c6d\2\u08f7\u08f9\5\u00c8e\2\u08f8\u08f3\3" + + "\2\2\2\u08f8\u08f4\3\2\2\2\u08f8\u08f5\3\2\2\2\u08f8\u08f6\3\2\2\2\u08f8" + + "\u08f7\3\2\2\2\u08f9\u00bb\3\2\2\2\u08fa\u08fb\5\u00b8]\2\u08fb\u08fc" + + "\5\u00c4c\2\u08fc\u0900\3\2\2\2\u08fd\u0900\5\u0158\u00ad\2\u08fe\u0900" + + "\5\u00be`\2\u08ff\u08fa\3\2\2\2\u08ff\u08fd\3\2\2\2\u08ff\u08fe\3\2\2" + + "\2\u0900\u00bd\3\2\2\2\u0901\u0905\7\13\2\2\u0902\u0904\7\7\2\2\u0903" + + "\u0902\3\2\2\2\u0904\u0907\3\2\2\2\u0905\u0903\3\2\2\2\u0905\u0906\3\2" + + "\2\2\u0906\u0908\3\2\2\2\u0907\u0905\3\2\2\2\u0908\u090c\5\u00bc_\2\u0909" + + "\u090b\7\7\2\2\u090a\u0909\3\2\2\2\u090b\u090e\3\2\2\2\u090c\u090a\3\2" + + "\2\2\u090c\u090d\3\2\2\2\u090d\u090f\3\2\2\2\u090e\u090c\3\2\2\2\u090f" + + "\u0910\7\f\2\2\u0910\u00bf\3\2\2\2\u0911\u0914\5\u00b4[\2\u0912\u0914" + + "\5\u00c2b\2\u0913\u0911\3\2\2\2\u0913\u0912\3\2\2\2\u0914\u00c1\3\2\2" + + "\2\u0915\u0919\7\13\2\2\u0916\u0918\7\7\2\2\u0917\u0916\3\2\2\2\u0918" + + "\u091b\3\2\2\2\u0919\u0917\3\2\2\2\u0919\u091a\3\2\2\2\u091a\u091c\3\2" + + "\2\2\u091b\u0919\3\2\2\2\u091c\u0920\5\u00c0a\2\u091d\u091f\7\7\2\2\u091e" + + "\u091d\3\2\2\2\u091f\u0922\3\2\2\2\u0920\u091e\3\2\2\2\u0920\u0921\3\2" + + "\2\2\u0921\u0923\3\2\2\2\u0922\u0920\3\2\2\2\u0923\u0924\7\f\2\2\u0924" + + "\u00c3\3\2\2\2\u0925\u0929\5\u00ceh\2\u0926\u0929\5\u00c6d\2\u0927\u0929" + + "\5\u00c8e\2\u0928\u0925\3\2\2\2\u0928\u0926\3\2\2\2\u0928\u0927\3\2\2" + + "\2\u0929\u00c5\3\2\2\2\u092a\u092e\7\r\2\2\u092b\u092d\7\7\2\2\u092c\u092b" + + "\3\2\2\2\u092d\u0930\3\2\2\2\u092e\u092c\3\2\2\2\u092e\u092f\3\2\2\2\u092f" + + "\u0931\3\2\2\2\u0930\u092e\3\2\2\2\u0931\u0942\5\u0098M\2\u0932\u0934" + + "\7\7\2\2\u0933\u0932\3\2\2\2\u0934\u0937\3\2\2\2\u0935\u0933\3\2\2\2\u0935" + + "\u0936\3\2\2\2\u0936\u0938\3\2\2\2\u0937\u0935\3\2\2\2\u0938\u093c\7\n" + + "\2\2\u0939\u093b\7\7\2\2\u093a\u0939\3\2\2\2\u093b\u093e\3\2\2\2\u093c" + + "\u093a\3\2\2\2\u093c\u093d\3\2\2\2\u093d\u093f\3\2\2\2\u093e\u093c\3\2" + + "\2\2\u093f\u0941\5\u0098M\2\u0940\u0935\3\2\2\2\u0941\u0944\3\2\2\2\u0942" + + "\u0940\3\2\2\2\u0942\u0943\3\2\2\2\u0943\u094c\3\2\2\2\u0944\u0942\3\2" + + "\2\2\u0945\u0947\7\7\2\2\u0946\u0945\3\2\2\2\u0947\u094a\3\2\2\2\u0948" + + "\u0946\3\2\2\2\u0948\u0949\3\2\2\2\u0949\u094b\3\2\2\2\u094a\u0948\3\2" + + "\2\2\u094b\u094d\7\n\2\2\u094c\u0948\3\2\2\2\u094c\u094d\3\2\2\2\u094d" + + "\u0951\3\2\2\2\u094e\u0950\7\7\2\2\u094f\u094e\3\2\2\2\u0950\u0953\3\2" + + "\2\2\u0951\u094f\3\2\2\2\u0951\u0952\3\2\2\2\u0952\u0954\3\2\2\2\u0953" + + "\u0951\3\2\2\2\u0954\u0955\7\16\2\2\u0955\u00c7\3\2\2\2\u0956\u095a\5" + + "\u0128\u0095\2\u0957\u0959\7\7\2\2\u0958\u0957\3\2\2\2\u0959\u095c\3\2" + + "\2\2\u095a\u0958\3\2\2\2\u095a\u095b\3\2\2\2\u095b\u0960\3\2\2\2\u095c" + + "\u095a\3\2\2\2\u095d\u0961\5\u0158\u00ad\2\u095e\u0961\5\u00d6l\2\u095f" + + "\u0961\7J\2\2\u0960\u095d\3\2\2\2\u0960\u095e\3\2\2\2\u0960\u095f\3\2" + + "\2\2\u0961\u00c9\3\2\2\2\u0962\u0964\5\u00ceh\2\u0963\u0962\3\2\2\2\u0963" + + "\u0964\3\2\2\2\u0964\u096a\3\2\2\2\u0965\u0967\5\u00d0i\2\u0966\u0965" + + "\3\2\2\2\u0966\u0967\3\2\2\2\u0967\u0968\3\2\2\2\u0968\u096b\5\u00ccg" + + "\2\u0969\u096b\5\u00d0i\2\u096a\u0966\3\2\2\2\u096a\u0969\3\2\2\2\u096b" + + "\u00cb\3\2\2\2\u096c\u096e\5\u014e\u00a8\2\u096d\u096c\3\2\2\2\u096e\u0971" + + "\3\2\2\2\u096f\u096d\3\2\2\2\u096f\u0970\3\2\2\2\u0970\u0973\3\2\2\2\u0971" + + "\u096f\3\2\2\2\u0972\u0974\5\u0084C\2\u0973\u0972\3\2\2\2\u0973\u0974" + + "\3\2\2\2\u0974\u0978\3\2\2\2\u0975\u0977\7\7\2\2\u0976\u0975\3\2\2\2\u0977" + + "\u097a\3\2\2\2\u0978\u0976\3\2\2\2\u0978\u0979\3\2\2\2\u0979\u097b\3\2" + + "\2\2\u097a\u0978\3\2\2\2\u097b\u097c\5\u00eav\2\u097c\u00cd\3\2\2\2\u097d" + + "\u0981\7\60\2\2\u097e\u0980\7\7\2\2\u097f\u097e\3\2\2\2\u0980\u0983\3" + + "\2\2\2\u0981\u097f\3\2\2\2\u0981\u0982\3\2\2\2\u0982\u0984\3\2\2\2\u0983" + + "\u0981\3\2\2\2\u0984\u0995\5p9\2\u0985\u0987\7\7\2\2\u0986\u0985\3\2\2" + + "\2\u0987\u098a\3\2\2\2\u0988\u0986\3\2\2\2\u0988\u0989\3\2\2\2\u0989\u098b" + + "\3\2\2\2\u098a\u0988\3\2\2\2\u098b\u098f\7\n\2\2\u098c\u098e\7\7\2\2\u098d" + + "\u098c\3\2\2\2\u098e\u0991\3\2\2\2\u098f\u098d\3\2\2\2\u098f\u0990\3\2" + + "\2\2\u0990\u0992\3\2\2\2\u0991\u098f\3\2\2\2\u0992\u0994\5p9\2\u0993\u0988" + + "\3\2\2\2\u0994\u0997\3\2\2\2\u0995\u0993\3\2\2\2\u0995\u0996\3\2\2\2\u0996" + + "\u099f\3\2\2\2\u0997\u0995\3\2\2\2\u0998\u099a\7\7\2\2\u0999\u0998\3\2" + + "\2\2\u099a\u099d\3\2\2\2\u099b\u0999\3\2\2\2\u099b\u099c\3\2\2\2\u099c" + + "\u099e\3\2\2\2\u099d\u099b\3\2\2\2\u099e\u09a0\7\n\2\2\u099f\u099b\3\2" + + "\2\2\u099f\u09a0\3\2\2\2\u09a0\u09a4\3\2\2\2\u09a1\u09a3\7\7\2\2\u09a2" + + "\u09a1\3\2\2\2\u09a3\u09a6\3\2\2\2\u09a4\u09a2\3\2\2\2\u09a4\u09a5\3\2" + + "\2\2\u09a5\u09a7\3\2\2\2\u09a6\u09a4\3\2\2\2\u09a7\u09a8\7\61\2\2\u09a8" + + "\u00cf\3\2\2\2\u09a9\u09ad\7\13\2\2\u09aa\u09ac\7\7\2\2\u09ab\u09aa\3" + + "\2\2\2\u09ac\u09af\3\2\2\2\u09ad\u09ab\3\2\2\2\u09ad\u09ae\3\2\2\2\u09ae" + + "\u09d3\3\2\2\2\u09af\u09ad\3\2\2\2\u09b0\u09c1\5\u00d2j\2\u09b1\u09b3" + + "\7\7\2\2\u09b2\u09b1\3\2\2\2\u09b3\u09b6\3\2\2\2\u09b4\u09b2\3\2\2\2\u09b4" + + "\u09b5\3\2\2\2\u09b5\u09b7\3\2\2\2\u09b6\u09b4\3\2\2\2\u09b7\u09bb\7\n" + + "\2\2\u09b8\u09ba\7\7\2\2\u09b9\u09b8\3\2\2\2\u09ba\u09bd\3\2\2\2\u09bb" + + "\u09b9\3\2\2\2\u09bb\u09bc\3\2\2\2\u09bc\u09be\3\2\2\2\u09bd\u09bb\3\2" + + "\2\2\u09be\u09c0\5\u00d2j\2\u09bf\u09b4\3\2\2\2\u09c0\u09c3\3\2\2\2\u09c1" + + "\u09bf\3\2\2\2\u09c1\u09c2\3\2\2\2\u09c2\u09cb\3\2\2\2\u09c3\u09c1\3\2" + + "\2\2\u09c4\u09c6\7\7\2\2\u09c5\u09c4\3\2\2\2\u09c6\u09c9\3\2\2\2\u09c7" + + "\u09c5\3\2\2\2\u09c7\u09c8\3\2\2\2\u09c8\u09ca\3\2\2\2\u09c9\u09c7\3\2" + + "\2\2\u09ca\u09cc\7\n\2\2\u09cb\u09c7\3\2\2\2\u09cb\u09cc\3\2\2\2\u09cc" + + "\u09d0\3\2\2\2\u09cd\u09cf\7\7\2\2\u09ce\u09cd\3\2\2\2\u09cf\u09d2\3\2" + + "\2\2\u09d0\u09ce\3\2\2\2\u09d0\u09d1\3\2\2\2\u09d1\u09d4\3\2\2\2\u09d2" + + "\u09d0\3\2\2\2\u09d3\u09b0\3\2\2\2\u09d3\u09d4\3\2\2\2\u09d4\u09d5\3\2" + + "\2\2\u09d5\u09d6\7\f\2\2\u09d6\u00d1\3\2\2\2\u09d7\u09d9\5\u014e\u00a8" + + "\2\u09d8\u09d7\3\2\2\2\u09d8\u09d9\3\2\2\2\u09d9\u09dd\3\2\2\2\u09da\u09dc" + + "\7\7\2\2\u09db\u09da\3\2\2\2\u09dc\u09df\3\2\2\2\u09dd\u09db\3\2\2\2\u09dd" + + "\u09de\3\2\2\2\u09de\u09ee\3\2\2\2\u09df\u09dd\3\2\2\2\u09e0\u09e4\5\u0158" + + "\u00ad\2\u09e1\u09e3\7\7\2\2\u09e2\u09e1\3\2\2\2\u09e3\u09e6\3\2\2\2\u09e4" + + "\u09e2\3\2\2\2\u09e4\u09e5\3\2\2\2\u09e5\u09e7\3\2\2\2\u09e6\u09e4\3\2" + + "\2\2\u09e7\u09eb\7\36\2\2\u09e8\u09ea\7\7\2\2\u09e9\u09e8\3\2\2\2\u09ea" + + "\u09ed\3\2\2\2\u09eb\u09e9\3\2\2\2\u09eb\u09ec\3\2\2\2\u09ec\u09ef\3\2" + + "\2\2\u09ed\u09eb\3\2\2\2\u09ee\u09e0\3\2\2\2\u09ee\u09ef\3\2\2\2\u09ef" + + "\u09f1\3\2\2\2\u09f0\u09f2\7\21\2\2\u09f1\u09f0\3\2\2\2\u09f1\u09f2\3" + + "\2\2\2\u09f2\u09f6\3\2\2\2\u09f3\u09f5\7\7\2\2\u09f4\u09f3\3\2\2\2\u09f5" + + "\u09f8\3\2\2\2\u09f6\u09f4\3\2\2\2\u09f6\u09f7\3\2\2\2\u09f7\u09f9\3\2" + + "\2\2\u09f8\u09f6\3\2\2\2\u09f9\u09fa\5\u0098M\2\u09fa\u00d3\3\2\2\2\u09fb" + + "\u0a0a\5\u00d6l\2\u09fc\u0a0a\5\u0158\u00ad\2\u09fd\u0a0a\5\u00dan\2\u09fe" + + "\u0a0a\5\u00dco\2\u09ff\u0a0a\5\u0110\u0089\2\u0a00\u0a0a\5\u00f2z\2\u0a01" + + "\u0a0a\5\u00f4{\2\u0a02\u0a0a\5\u00d8m\2\u0a03\u0a0a\5\u00f6|\2\u0a04" + + "\u0a0a\5\u00f8}\2\u0a05\u0a0a\5\u00fa~\2\u0a06\u0a0a\5\u00fe\u0080\2\u0a07" + + "\u0a0a\5\u0108\u0085\2\u0a08\u0a0a\5\u010e\u0088\2\u0a09\u09fb\3\2\2\2" + + "\u0a09\u09fc\3\2\2\2\u0a09\u09fd\3\2\2\2\u0a09\u09fe\3\2\2\2\u0a09\u09ff" + + "\3\2\2\2\u0a09\u0a00\3\2\2\2\u0a09\u0a01\3\2\2\2\u0a09\u0a02\3\2\2\2\u0a09" + + "\u0a03\3\2\2\2\u0a09\u0a04\3\2\2\2\u0a09\u0a05\3\2\2\2\u0a09\u0a06\3\2" + + "\2\2\u0a09\u0a07\3\2\2\2\u0a09\u0a08\3\2\2\2\u0a0a\u00d5\3\2\2\2\u0a0b" + + "\u0a0f\7\13\2\2\u0a0c\u0a0e\7\7\2\2\u0a0d\u0a0c\3\2\2\2\u0a0e\u0a11\3" + + "\2\2\2\u0a0f\u0a0d\3\2\2\2\u0a0f\u0a10\3\2\2\2\u0a10\u0a12\3\2\2\2\u0a11" + + "\u0a0f\3\2\2\2\u0a12\u0a16\5\u0098M\2\u0a13\u0a15\7\7\2\2\u0a14\u0a13" + + "\3\2\2\2\u0a15\u0a18\3\2\2\2\u0a16\u0a14\3\2\2\2\u0a16\u0a17\3\2\2\2\u0a17" + + "\u0a19\3\2\2\2\u0a18\u0a16\3\2\2\2\u0a19\u0a1a\7\f\2\2\u0a1a\u00d7\3\2" + + "\2\2\u0a1b\u0a1f\7\r\2\2\u0a1c\u0a1e\7\7\2\2\u0a1d\u0a1c\3\2\2\2\u0a1e" + + "\u0a21\3\2\2\2\u0a1f\u0a1d\3\2\2\2\u0a1f\u0a20\3\2\2\2\u0a20\u0a45\3\2" + + "\2\2\u0a21\u0a1f\3\2\2\2\u0a22\u0a33\5\u0098M\2\u0a23\u0a25\7\7\2\2\u0a24" + + "\u0a23\3\2\2\2\u0a25\u0a28\3\2\2\2\u0a26\u0a24\3\2\2\2\u0a26\u0a27\3\2" + + "\2\2\u0a27\u0a29\3\2\2\2\u0a28\u0a26\3\2\2\2\u0a29\u0a2d\7\n\2\2\u0a2a" + + "\u0a2c\7\7\2\2\u0a2b\u0a2a\3\2\2\2\u0a2c\u0a2f\3\2\2\2\u0a2d\u0a2b\3\2" + + "\2\2\u0a2d\u0a2e\3\2\2\2\u0a2e\u0a30\3\2\2\2\u0a2f\u0a2d\3\2\2\2\u0a30" + + "\u0a32\5\u0098M\2\u0a31\u0a26\3\2\2\2\u0a32\u0a35\3\2\2\2\u0a33\u0a31" + + "\3\2\2\2\u0a33\u0a34\3\2\2\2\u0a34\u0a3d\3\2\2\2\u0a35\u0a33\3\2\2\2\u0a36" + + "\u0a38\7\7\2\2\u0a37\u0a36\3\2\2\2\u0a38\u0a3b\3\2\2\2\u0a39\u0a37\3\2" + + "\2\2\u0a39\u0a3a\3\2\2\2\u0a3a\u0a3c\3\2\2\2\u0a3b\u0a39\3\2\2\2\u0a3c" + + "\u0a3e\7\n\2\2\u0a3d\u0a39\3\2\2\2\u0a3d\u0a3e\3\2\2\2\u0a3e\u0a42\3\2" + + "\2\2\u0a3f\u0a41\7\7\2\2\u0a40\u0a3f\3\2\2\2\u0a41\u0a44\3\2\2\2\u0a42" + + "\u0a40\3\2\2\2\u0a42\u0a43\3\2\2\2\u0a43\u0a46\3\2\2\2\u0a44\u0a42\3\2" + + "\2\2\u0a45\u0a22\3\2\2\2\u0a45\u0a46\3\2\2\2\u0a46\u0a47\3\2\2\2\u0a47" + + "\u0a48\7\16\2\2\u0a48\u00d9\3\2\2\2\u0a49\u0a4a\t\b\2\2\u0a4a\u00db\3" + + "\2\2\2\u0a4b\u0a4e\5\u00dep\2\u0a4c\u0a4e\5\u00e0q\2\u0a4d\u0a4b\3\2\2" + + "\2\u0a4d\u0a4c\3\2\2\2\u0a4e\u00dd\3\2\2\2\u0a4f\u0a54\7\u0097\2\2\u0a50" + + "\u0a53\5\u00e2r\2\u0a51\u0a53\5\u00e4s\2\u0a52\u0a50\3\2\2\2\u0a52\u0a51" + + "\3\2\2\2\u0a53\u0a56\3\2\2\2\u0a54\u0a52\3\2\2\2\u0a54\u0a55\3\2\2\2\u0a55" + + "\u0a57\3\2\2\2\u0a56\u0a54\3\2\2\2\u0a57\u0a58\7\u00a0\2\2\u0a58\u00df" + + "\3\2\2\2\u0a59\u0a5f\7\u0098\2\2\u0a5a\u0a5e\5\u00e6t\2\u0a5b\u0a5e\5" + + "\u00e8u\2\u0a5c\u0a5e\7\u00a6\2\2\u0a5d\u0a5a\3\2\2\2\u0a5d\u0a5b\3\2" + + "\2\2\u0a5d\u0a5c\3\2\2\2\u0a5e\u0a61\3\2\2\2\u0a5f\u0a5d\3\2\2\2\u0a5f" + + "\u0a60\3\2\2\2\u0a60\u0a62\3\2\2\2\u0a61\u0a5f\3\2\2\2\u0a62\u0a63\7\u00a5" + + "\2\2\u0a63\u00e1\3\2\2\2\u0a64\u0a65\t\t\2\2\u0a65\u00e3\3\2\2\2\u0a66" + + "\u0a6a\7\u00a4\2\2\u0a67\u0a69\7\7\2\2\u0a68\u0a67\3\2\2\2\u0a69\u0a6c" + + "\3\2\2\2\u0a6a\u0a68\3\2\2\2\u0a6a\u0a6b\3\2\2\2\u0a6b\u0a6d\3\2\2\2\u0a6c" + + "\u0a6a\3\2\2\2\u0a6d\u0a71\5\u0098M\2\u0a6e\u0a70\7\7\2\2\u0a6f\u0a6e" + + "\3\2\2\2\u0a70\u0a73\3\2\2\2\u0a71\u0a6f\3\2\2\2\u0a71\u0a72\3\2\2\2\u0a72" + + "\u0a74\3\2\2\2\u0a73\u0a71\3\2\2\2\u0a74\u0a75\7\20\2\2\u0a75\u00e5\3" + + "\2\2\2\u0a76\u0a77\t\n\2\2\u0a77\u00e7\3\2\2\2\u0a78\u0a7c\7\u00a9\2\2" + + "\u0a79\u0a7b\7\7\2\2\u0a7a\u0a79\3\2\2\2\u0a7b\u0a7e\3\2\2\2\u0a7c\u0a7a" + + "\3\2\2\2\u0a7c\u0a7d\3\2\2\2\u0a7d\u0a7f\3\2\2\2\u0a7e\u0a7c\3\2\2\2\u0a7f" + + "\u0a83\5\u0098M\2\u0a80\u0a82\7\7\2\2\u0a81\u0a80\3\2\2\2\u0a82\u0a85" + + "\3\2\2\2\u0a83\u0a81\3\2\2\2\u0a83\u0a84\3\2\2\2\u0a84\u0a86\3\2\2\2\u0a85" + + "\u0a83\3\2\2\2\u0a86\u0a87\7\20\2\2\u0a87\u00e9\3\2\2\2\u0a88\u0a8c\7" + + "\17\2\2\u0a89\u0a8b\7\7\2\2\u0a8a\u0a89\3\2\2\2\u0a8b\u0a8e\3\2\2\2\u0a8c" + + "\u0a8a\3\2\2\2\u0a8c\u0a8d\3\2\2\2\u0a8d\u0a9f\3\2\2\2\u0a8e\u0a8c\3\2" + + "\2\2\u0a8f\u0a91\5\u00ecw\2\u0a90\u0a8f\3\2\2\2\u0a90\u0a91\3\2\2\2\u0a91" + + "\u0a95\3\2\2\2\u0a92\u0a94\7\7\2\2\u0a93\u0a92\3\2\2\2\u0a94\u0a97\3\2" + + "\2\2\u0a95\u0a93\3\2\2\2\u0a95\u0a96\3\2\2\2\u0a96\u0a98\3\2\2\2\u0a97" + + "\u0a95\3\2\2\2\u0a98\u0a9c\7$\2\2\u0a99\u0a9b\7\7\2\2\u0a9a\u0a99\3\2" + + "\2\2\u0a9b\u0a9e\3\2\2\2\u0a9c\u0a9a\3\2\2\2\u0a9c\u0a9d\3\2\2\2\u0a9d" + + "\u0aa0\3\2\2\2\u0a9e\u0a9c\3\2\2\2\u0a9f\u0a90\3\2\2\2\u0a9f\u0aa0\3\2" + + "\2\2\u0aa0\u0aa1\3\2\2\2\u0aa1\u0aa5\5\u0080A\2\u0aa2\u0aa4\7\7\2\2\u0aa3" + + "\u0aa2\3\2\2\2\u0aa4\u0aa7\3\2\2\2\u0aa5\u0aa3\3\2\2\2\u0aa5\u0aa6\3\2" + + "\2\2\u0aa6\u0aa8\3\2\2\2\u0aa7\u0aa5\3\2\2\2\u0aa8\u0aa9\7\20\2\2\u0aa9" + + "\u00eb\3\2\2\2\u0aaa\u0abb\5\u00eex\2\u0aab\u0aad\7\7\2\2\u0aac\u0aab" + + "\3\2\2\2\u0aad\u0ab0\3\2\2\2\u0aae\u0aac\3\2\2\2\u0aae\u0aaf\3\2\2\2\u0aaf" + + "\u0ab1\3\2\2\2\u0ab0\u0aae\3\2\2\2\u0ab1\u0ab5\7\n\2\2\u0ab2\u0ab4\7\7" + + "\2\2\u0ab3\u0ab2\3\2\2\2\u0ab4\u0ab7\3\2\2\2\u0ab5\u0ab3\3\2\2\2\u0ab5" + + "\u0ab6\3\2\2\2\u0ab6\u0ab8\3\2\2\2\u0ab7\u0ab5\3\2\2\2\u0ab8\u0aba\5\u00ee" + + "x\2\u0ab9\u0aae\3\2\2\2\u0aba\u0abd\3\2\2\2\u0abb\u0ab9\3\2\2\2\u0abb" + + "\u0abc\3\2\2\2\u0abc\u0ac5\3\2\2\2\u0abd\u0abb\3\2\2\2\u0abe\u0ac0\7\7" + + "\2\2\u0abf\u0abe\3\2\2\2\u0ac0\u0ac3\3\2\2\2\u0ac1\u0abf\3\2\2\2\u0ac1" + + "\u0ac2\3\2\2\2\u0ac2\u0ac4\3\2\2\2\u0ac3\u0ac1\3\2\2\2\u0ac4\u0ac6\7\n" + + "\2\2\u0ac5\u0ac1\3\2\2\2\u0ac5\u0ac6\3\2\2\2\u0ac6\u00ed\3\2\2\2\u0ac7" + + "\u0ada\5D#\2\u0ac8\u0ad7\5F$\2\u0ac9\u0acb\7\7\2\2\u0aca\u0ac9\3\2\2\2" + + "\u0acb\u0ace\3\2\2\2\u0acc\u0aca\3\2\2\2\u0acc\u0acd\3\2\2\2\u0acd\u0acf" + + "\3\2\2\2\u0ace\u0acc\3\2\2\2\u0acf\u0ad3\7\34\2\2\u0ad0\u0ad2\7\7\2\2" + + "\u0ad1\u0ad0\3\2\2\2\u0ad2\u0ad5\3\2\2\2\u0ad3\u0ad1\3\2\2\2\u0ad3\u0ad4" + + "\3\2\2\2\u0ad4\u0ad6\3\2\2\2\u0ad5\u0ad3\3\2\2\2\u0ad6\u0ad8\5d\63\2\u0ad7" + + "\u0acc\3\2\2\2\u0ad7\u0ad8\3\2\2\2\u0ad8\u0ada\3\2\2\2\u0ad9\u0ac7\3\2" + + "\2\2\u0ad9\u0ac8\3\2\2\2\u0ada\u00ef\3\2\2\2\u0adb\u0aeb\7L\2\2\u0adc" + + "\u0ade\7\7\2\2\u0add\u0adc\3\2\2\2\u0ade\u0ae1\3\2\2\2\u0adf\u0add\3\2" + + "\2\2\u0adf\u0ae0\3\2\2\2\u0ae0\u0ae2\3\2\2\2\u0ae1\u0adf\3\2\2\2\u0ae2" + + "\u0ae6\5d\63\2\u0ae3\u0ae5\7\7\2\2\u0ae4\u0ae3\3\2\2\2\u0ae5\u0ae8\3\2" + + "\2\2\u0ae6\u0ae4\3\2\2\2\u0ae6\u0ae7\3\2\2\2\u0ae7\u0ae9\3\2\2\2\u0ae8" + + "\u0ae6\3\2\2\2\u0ae9\u0aea\7\t\2\2\u0aea\u0aec\3\2\2\2\u0aeb\u0adf\3\2" + + "\2\2\u0aeb\u0aec\3\2\2\2\u0aec\u0af0\3\2\2\2\u0aed\u0aef\7\7\2\2\u0aee" + + "\u0aed\3\2\2\2\u0aef\u0af2\3\2\2\2\u0af0\u0aee\3\2\2\2\u0af0\u0af1\3\2" + + "\2\2\u0af1\u0af3\3\2\2\2\u0af2\u0af0\3\2\2\2\u0af3\u0b02\5P)\2\u0af4\u0af6" + + "\7\7\2\2\u0af5\u0af4\3\2\2\2\u0af6\u0af9\3\2\2\2\u0af7\u0af5\3\2\2\2\u0af7" + + "\u0af8\3\2\2\2\u0af8\u0afa\3\2\2\2\u0af9\u0af7\3\2\2\2\u0afa\u0afe\7\34" + + "\2\2\u0afb\u0afd\7\7\2\2\u0afc\u0afb\3\2\2\2\u0afd\u0b00\3\2\2\2\u0afe" + + "\u0afc\3\2\2\2\u0afe\u0aff\3\2\2\2\u0aff\u0b01\3\2\2\2\u0b00\u0afe\3\2" + + "\2\2\u0b01\u0b03\5d\63\2\u0b02\u0af7\3\2\2\2\u0b02\u0b03\3\2\2\2\u0b03" + + "\u0b0b\3\2\2\2\u0b04\u0b06\7\7\2\2\u0b05\u0b04\3\2\2\2\u0b06\u0b09\3\2" + + "\2\2\u0b07\u0b05\3\2\2\2\u0b07\u0b08\3\2\2\2\u0b08\u0b0a\3\2\2\2\u0b09" + + "\u0b07\3\2\2\2\u0b0a\u0b0c\5\60\31\2\u0b0b\u0b07\3\2\2\2\u0b0b\u0b0c\3" + + "\2\2\2\u0b0c\u0b14\3\2\2\2\u0b0d\u0b0f\7\7\2\2\u0b0e\u0b0d\3\2\2\2\u0b0f" + + "\u0b12\3\2\2\2\u0b10\u0b0e\3\2\2\2\u0b10\u0b11\3\2\2\2\u0b11\u0b13\3\2" + + "\2\2\u0b12\u0b10\3\2\2\2\u0b13\u0b15\5B\"\2\u0b14\u0b10\3\2\2\2\u0b14" + + "\u0b15\3\2\2\2\u0b15\u00f1\3\2\2\2\u0b16\u0b19\5\u00eav\2\u0b17\u0b19" + + "\5\u00f0y\2\u0b18\u0b16\3\2\2\2\u0b18\u0b17\3\2\2\2\u0b19\u00f3\3\2\2" + + "\2\u0b1a\u0b2f\7M\2\2\u0b1b\u0b1d\7\7\2\2\u0b1c\u0b1b\3\2\2\2\u0b1d\u0b20" + + "\3\2\2\2\u0b1e\u0b1c\3\2\2\2\u0b1e\u0b1f\3\2\2\2\u0b1f\u0b21\3\2\2\2\u0b20" + + "\u0b1e\3\2\2\2\u0b21\u0b25\7\34\2\2\u0b22\u0b24\7\7\2\2\u0b23\u0b22\3" + + "\2\2\2\u0b24\u0b27\3\2\2\2\u0b25\u0b23\3\2\2\2\u0b25\u0b26\3\2\2\2\u0b26" + + "\u0b28\3\2\2\2\u0b27\u0b25\3\2\2\2\u0b28\u0b2c\5\"\22\2\u0b29\u0b2b\7" + + "\7\2\2\u0b2a\u0b29\3\2\2\2\u0b2b\u0b2e\3\2\2\2\u0b2c\u0b2a\3\2\2\2\u0b2c" + + "\u0b2d\3\2\2\2\u0b2d\u0b30\3\2\2\2\u0b2e\u0b2c\3\2\2\2\u0b2f\u0b1e\3\2" + + "\2\2\u0b2f\u0b30\3\2\2\2\u0b30\u0b38\3\2\2\2\u0b31\u0b33\7\7\2\2\u0b32" + + "\u0b31\3\2\2\2\u0b33\u0b36\3\2\2\2\u0b34\u0b32\3\2\2\2\u0b34\u0b35\3\2" + + "\2\2\u0b35\u0b37\3\2\2\2\u0b36\u0b34\3\2\2\2\u0b37\u0b39\5\34\17\2\u0b38" + + "\u0b34\3\2\2\2\u0b38\u0b39\3\2\2\2\u0b39\u00f5\3\2\2\2\u0b3a\u0b3b\t\13" + + "\2\2\u0b3b\u00f7\3\2\2\2\u0b3c\u0b4d\7V\2\2\u0b3d\u0b41\7\60\2\2\u0b3e" + + "\u0b40\7\7\2\2\u0b3f\u0b3e\3\2\2\2\u0b40\u0b43\3\2\2\2\u0b41\u0b3f\3\2" + + "\2\2\u0b41\u0b42\3\2\2\2\u0b42\u0b44\3\2\2\2\u0b43\u0b41\3\2\2\2\u0b44" + + "\u0b48\5d\63\2\u0b45\u0b47\7\7\2\2\u0b46\u0b45\3\2\2\2\u0b47\u0b4a\3\2" + + "\2\2\u0b48\u0b46\3\2\2\2\u0b48\u0b49\3\2\2\2\u0b49\u0b4b\3\2\2\2\u0b4a" + + "\u0b48\3\2\2\2\u0b4b\u0b4c\7\61\2\2\u0b4c\u0b4e\3\2\2\2\u0b4d\u0b3d\3" + + "\2\2\2\u0b4d\u0b4e\3\2\2\2\u0b4e\u0b51\3\2\2\2\u0b4f\u0b50\7*\2\2\u0b50" + + "\u0b52\5\u0158\u00ad\2\u0b51\u0b4f\3\2\2\2\u0b51\u0b52\3\2\2\2\u0b52\u0b55" + + "\3\2\2\2\u0b53\u0b55\7>\2\2\u0b54\u0b3c\3\2\2\2\u0b54\u0b53\3\2\2\2\u0b55" + + "\u00f9\3\2\2\2\u0b56\u0b5a\7Y\2\2\u0b57\u0b59\7\7\2\2\u0b58\u0b57\3\2" + + "\2\2\u0b59\u0b5c\3\2\2\2\u0b5a\u0b58\3\2\2\2\u0b5a\u0b5b\3\2\2\2\u0b5b" + + "\u0b5d\3\2\2\2\u0b5c\u0b5a\3\2\2\2\u0b5d\u0b61\7\13\2\2\u0b5e\u0b60\7" + + "\7\2\2\u0b5f\u0b5e\3\2\2\2\u0b60\u0b63\3\2\2\2\u0b61\u0b5f\3\2\2\2\u0b61" + + "\u0b62\3\2\2\2\u0b62\u0b64\3\2\2\2\u0b63\u0b61\3\2\2\2\u0b64\u0b68\5\u0098" + + "M\2\u0b65\u0b67\7\7\2\2\u0b66\u0b65\3\2\2\2\u0b67\u0b6a\3\2\2\2\u0b68" + + "\u0b66\3\2\2\2\u0b68\u0b69\3\2\2\2\u0b69\u0b6b\3\2\2\2\u0b6a\u0b68\3\2" + + "\2\2\u0b6b\u0b6f\7\f\2\2\u0b6c\u0b6e\7\7\2\2\u0b6d\u0b6c\3\2\2\2\u0b6e" + + "\u0b71\3\2\2\2\u0b6f\u0b6d\3\2\2\2\u0b6f\u0b70\3\2\2\2\u0b70\u0b91\3\2" + + "\2\2\u0b71\u0b6f\3\2\2\2\u0b72\u0b92\5\u0086D\2\u0b73\u0b75\5\u0086D\2" + + "\u0b74\u0b73\3\2\2\2\u0b74\u0b75\3\2\2\2\u0b75\u0b79\3\2\2\2\u0b76\u0b78" + + "\7\7\2\2\u0b77\u0b76\3\2\2\2\u0b78\u0b7b\3\2\2\2\u0b79\u0b77\3\2\2\2\u0b79" + + "\u0b7a\3\2\2\2\u0b7a\u0b7d\3\2\2\2\u0b7b\u0b79\3\2\2\2\u0b7c\u0b7e\7\35" + + "\2\2\u0b7d\u0b7c\3\2\2\2\u0b7d\u0b7e\3\2\2\2\u0b7e\u0b82\3\2\2\2\u0b7f" + + "\u0b81\7\7\2\2\u0b80\u0b7f\3\2\2\2\u0b81\u0b84\3\2\2\2\u0b82\u0b80\3\2" + + "\2\2\u0b82\u0b83\3\2\2\2\u0b83\u0b85\3\2\2\2\u0b84\u0b82\3\2\2\2\u0b85" + + "\u0b89\7Z\2\2\u0b86\u0b88\7\7\2\2\u0b87\u0b86\3\2\2\2\u0b88\u0b8b\3\2" + + "\2\2\u0b89\u0b87\3\2\2\2\u0b89\u0b8a\3\2\2\2\u0b8a\u0b8e\3\2\2\2\u0b8b" + + "\u0b89\3\2\2\2\u0b8c\u0b8f\5\u0086D\2\u0b8d\u0b8f\7\35\2\2\u0b8e\u0b8c" + + "\3\2\2\2\u0b8e\u0b8d\3\2\2\2\u0b8f\u0b92\3\2\2\2\u0b90\u0b92\7\35\2\2" + + "\u0b91\u0b72\3\2\2\2\u0b91\u0b74\3\2\2\2\u0b91\u0b90\3\2\2\2\u0b92\u00fb" + + "\3\2\2\2\u0b93\u0bb5\7\13\2\2\u0b94\u0b96\5\u014e\u00a8\2\u0b95\u0b94" + + "\3\2\2\2\u0b96\u0b99\3\2\2\2\u0b97\u0b95\3\2\2\2\u0b97\u0b98\3\2\2\2\u0b98" + + "\u0b9d\3\2\2\2\u0b99\u0b97\3\2\2\2\u0b9a\u0b9c\7\7\2\2\u0b9b\u0b9a\3\2" + + "\2\2\u0b9c\u0b9f\3\2\2\2\u0b9d\u0b9b\3\2\2\2\u0b9d\u0b9e\3\2\2\2\u0b9e" + + "\u0ba0\3\2\2\2\u0b9f\u0b9d\3\2\2\2\u0ba0\u0ba4\7N\2\2\u0ba1\u0ba3\7\7" + + "\2\2\u0ba2\u0ba1\3\2\2\2\u0ba3\u0ba6\3\2\2\2\u0ba4\u0ba2\3\2\2\2\u0ba4" + + "\u0ba5\3\2\2\2\u0ba5\u0ba7\3\2\2\2\u0ba6\u0ba4\3\2\2\2\u0ba7\u0bab\5D" + + "#\2\u0ba8\u0baa\7\7\2\2\u0ba9\u0ba8\3\2\2\2\u0baa\u0bad\3\2\2\2\u0bab" + + "\u0ba9\3\2\2\2\u0bab\u0bac\3\2\2\2\u0bac\u0bae\3\2\2\2\u0bad\u0bab\3\2" + + "\2\2\u0bae\u0bb2\7\36\2\2\u0baf\u0bb1\7\7\2\2\u0bb0\u0baf\3\2\2\2\u0bb1" + + "\u0bb4\3\2\2\2\u0bb2\u0bb0\3\2\2\2\u0bb2\u0bb3\3\2\2\2\u0bb3\u0bb6\3\2" + + "\2\2\u0bb4\u0bb2\3\2\2\2\u0bb5\u0b97\3\2\2\2\u0bb5\u0bb6\3\2\2\2\u0bb6" + + "\u0bb7\3\2\2\2\u0bb7\u0bb8\5\u0098M\2\u0bb8\u0bb9\7\f\2\2\u0bb9\u00fd" + + "\3\2\2\2\u0bba\u0bbe\7[\2\2\u0bbb\u0bbd\7\7\2\2\u0bbc\u0bbb\3\2\2\2\u0bbd" + + "\u0bc0\3\2\2\2\u0bbe\u0bbc\3\2\2\2\u0bbe\u0bbf\3\2\2\2\u0bbf\u0bc2\3\2" + + "\2\2\u0bc0\u0bbe\3\2\2\2\u0bc1\u0bc3\5\u00fc\177\2\u0bc2\u0bc1\3\2\2\2" + + "\u0bc2\u0bc3\3\2\2\2\u0bc3\u0bc7\3\2\2\2\u0bc4\u0bc6\7\7\2\2\u0bc5\u0bc4" + + "\3\2\2\2\u0bc6\u0bc9\3\2\2\2\u0bc7\u0bc5\3\2\2\2\u0bc7\u0bc8\3\2\2\2\u0bc8" + + "\u0bca\3\2\2\2\u0bc9\u0bc7\3\2\2\2\u0bca\u0bce\7\17\2\2\u0bcb\u0bcd\7" + + "\7\2\2\u0bcc\u0bcb\3\2\2\2\u0bcd\u0bd0\3\2\2\2\u0bce\u0bcc\3\2\2\2\u0bce" + + "\u0bcf\3\2\2\2\u0bcf\u0bda\3\2\2\2\u0bd0\u0bce\3\2\2\2\u0bd1\u0bd5\5\u0100" + + "\u0081\2\u0bd2\u0bd4\7\7\2\2\u0bd3\u0bd2\3\2\2\2\u0bd4\u0bd7\3\2\2\2\u0bd5" + + "\u0bd3\3\2\2\2\u0bd5\u0bd6\3\2\2\2\u0bd6\u0bd9\3\2\2\2\u0bd7\u0bd5\3\2" + + "\2\2\u0bd8\u0bd1\3\2\2\2\u0bd9\u0bdc\3\2\2\2\u0bda\u0bd8\3\2\2\2\u0bda" + + "\u0bdb\3\2\2\2\u0bdb\u0be0\3\2\2\2\u0bdc\u0bda\3\2\2\2\u0bdd\u0bdf\7\7" + + "\2\2\u0bde\u0bdd\3\2\2\2\u0bdf\u0be2\3\2\2\2\u0be0\u0bde\3\2\2\2\u0be0" + + "\u0be1\3\2\2\2\u0be1\u0be3\3\2\2\2\u0be2\u0be0\3\2\2\2\u0be3\u0be4\7\20" + + "\2\2\u0be4\u00ff\3\2\2\2\u0be5\u0bf6\5\u0102\u0082\2\u0be6\u0be8\7\7\2" + + "\2\u0be7\u0be6\3\2\2\2\u0be8\u0beb\3\2\2\2\u0be9\u0be7\3\2\2\2\u0be9\u0bea" + + "\3\2\2\2\u0bea\u0bec\3\2\2\2\u0beb\u0be9\3\2\2\2\u0bec\u0bf0\7\n\2\2\u0bed" + + "\u0bef\7\7\2\2\u0bee\u0bed\3\2\2\2\u0bef\u0bf2\3\2\2\2\u0bf0\u0bee\3\2" + + "\2\2\u0bf0\u0bf1\3\2\2\2\u0bf1\u0bf3\3\2\2\2\u0bf2\u0bf0\3\2\2\2\u0bf3" + + "\u0bf5\5\u0102\u0082\2\u0bf4\u0be9\3\2\2\2\u0bf5\u0bf8\3\2\2\2\u0bf6\u0bf4" + + "\3\2\2\2\u0bf6\u0bf7\3\2\2\2\u0bf7\u0c00\3\2\2\2\u0bf8\u0bf6\3\2\2\2\u0bf9" + + "\u0bfb\7\7\2\2\u0bfa\u0bf9\3\2\2\2\u0bfb\u0bfe\3\2\2\2\u0bfc\u0bfa\3\2" + + "\2\2\u0bfc\u0bfd\3\2\2\2\u0bfd\u0bff\3\2\2\2\u0bfe\u0bfc\3\2\2\2\u0bff" + + "\u0c01\7\n\2\2\u0c00\u0bfc\3\2\2\2\u0c00\u0c01\3\2\2\2\u0c01\u0c05\3\2" + + "\2\2\u0c02\u0c04\7\7\2\2\u0c03\u0c02\3\2\2\2\u0c04\u0c07\3\2\2\2\u0c05" + + "\u0c03\3\2\2\2\u0c05\u0c06\3\2\2\2\u0c06\u0c08\3\2\2\2\u0c07\u0c05\3\2" + + "\2\2\u0c08\u0c0c\7$\2\2\u0c09\u0c0b\7\7\2\2\u0c0a\u0c09\3\2\2\2\u0c0b" + + "\u0c0e\3\2\2\2\u0c0c\u0c0a\3\2\2\2\u0c0c\u0c0d\3\2\2\2\u0c0d\u0c0f\3\2" + + "\2\2\u0c0e\u0c0c\3\2\2\2\u0c0f\u0c11\5\u0086D\2\u0c10\u0c12\5\u0094K\2" + + "\u0c11\u0c10\3\2\2\2\u0c11\u0c12\3\2\2\2\u0c12\u0c26\3\2\2\2\u0c13\u0c17" + + "\7Z\2\2\u0c14\u0c16\7\7\2\2\u0c15\u0c14\3\2\2\2\u0c16\u0c19\3\2\2\2\u0c17" + + "\u0c15\3\2\2\2\u0c17\u0c18\3\2\2\2\u0c18\u0c1a\3\2\2\2\u0c19\u0c17\3\2" + + "\2\2\u0c1a\u0c1e\7$\2\2\u0c1b\u0c1d\7\7\2\2\u0c1c\u0c1b\3\2\2\2\u0c1d" + + "\u0c20\3\2\2\2\u0c1e\u0c1c\3\2\2\2\u0c1e\u0c1f\3\2\2\2\u0c1f\u0c21\3\2" + + "\2\2\u0c20\u0c1e\3\2\2\2\u0c21\u0c23\5\u0086D\2\u0c22\u0c24\5\u0094K\2" + + "\u0c23\u0c22\3\2\2\2\u0c23\u0c24\3\2\2\2\u0c24\u0c26\3\2\2\2\u0c25\u0be5" + + "\3\2\2\2\u0c25\u0c13\3\2\2\2\u0c26\u0101\3\2\2\2\u0c27\u0c2b\5\u0098M" + + "\2\u0c28\u0c2b\5\u0104\u0083\2\u0c29\u0c2b\5\u0106\u0084\2\u0c2a\u0c27" + + "\3\2\2\2\u0c2a\u0c28\3\2\2\2\u0c2a\u0c29\3\2\2\2\u0c2b\u0103\3\2\2\2\u0c2c" + + "\u0c30\5\u0118\u008d\2\u0c2d\u0c2f\7\7\2\2\u0c2e\u0c2d\3\2\2\2\u0c2f\u0c32" + + "\3\2\2\2\u0c30\u0c2e\3\2\2\2\u0c30\u0c31\3\2\2\2\u0c31\u0c33\3\2\2\2\u0c32" + + "\u0c30\3\2\2\2\u0c33\u0c34\5\u0098M\2\u0c34\u0105\3\2\2\2\u0c35\u0c39" + + "\5\u011a\u008e\2\u0c36\u0c38\7\7\2\2\u0c37\u0c36\3\2\2\2\u0c38\u0c3b\3" + + "\2\2\2\u0c39\u0c37\3\2\2\2\u0c39\u0c3a\3\2\2\2\u0c3a\u0c3c\3\2\2\2\u0c3b" + + "\u0c39\3\2\2\2\u0c3c\u0c3d\5d\63\2\u0c3d\u0107\3\2\2\2\u0c3e\u0c42\7\\" + + "\2\2\u0c3f\u0c41\7\7\2\2\u0c40\u0c3f\3\2\2\2\u0c41\u0c44\3\2\2\2\u0c42" + + "\u0c40\3\2\2\2\u0c42\u0c43\3\2\2\2\u0c43\u0c45\3\2\2\2\u0c44\u0c42\3\2" + + "\2\2\u0c45\u0c61\5\u0088E\2\u0c46\u0c48\7\7\2\2\u0c47\u0c46\3\2\2\2\u0c48" + + "\u0c4b\3\2\2\2\u0c49\u0c47\3\2\2\2\u0c49\u0c4a\3\2\2\2\u0c4a\u0c4c\3\2" + + "\2\2\u0c4b\u0c49\3\2\2\2\u0c4c\u0c4e\5\u010a\u0086\2\u0c4d\u0c49\3\2\2" + + "\2\u0c4e\u0c4f\3\2\2\2\u0c4f\u0c4d\3\2\2\2\u0c4f\u0c50\3\2\2\2\u0c50\u0c58" + + "\3\2\2\2\u0c51\u0c53\7\7\2\2\u0c52\u0c51\3\2\2\2\u0c53\u0c56\3\2\2\2\u0c54" + + "\u0c52\3\2\2\2\u0c54\u0c55\3\2\2\2\u0c55\u0c57\3\2\2\2\u0c56\u0c54\3\2" + + "\2\2\u0c57\u0c59\5\u010c\u0087\2\u0c58\u0c54\3\2\2\2\u0c58\u0c59\3\2\2" + + "\2\u0c59\u0c62\3\2\2\2\u0c5a\u0c5c\7\7\2\2\u0c5b\u0c5a\3\2\2\2\u0c5c\u0c5f" + + "\3\2\2\2\u0c5d\u0c5b\3\2\2\2\u0c5d\u0c5e\3\2\2\2\u0c5e\u0c60\3\2\2\2\u0c5f" + + "\u0c5d\3\2\2\2\u0c60\u0c62\5\u010c\u0087\2\u0c61\u0c4d\3\2\2\2\u0c61\u0c5d" + + "\3\2\2\2\u0c62\u0109\3\2\2\2\u0c63\u0c67\7]\2\2\u0c64\u0c66\7\7\2\2\u0c65" + + "\u0c64\3\2\2\2\u0c66\u0c69\3\2\2\2\u0c67\u0c65\3\2\2\2\u0c67\u0c68\3\2" + + "\2\2\u0c68\u0c6a\3\2\2\2\u0c69\u0c67\3\2\2\2\u0c6a\u0c6e\7\13\2\2\u0c6b" + + "\u0c6d\5\u014e\u00a8\2\u0c6c\u0c6b\3\2\2\2\u0c6d\u0c70\3\2\2\2\u0c6e\u0c6c" + + "\3\2\2\2\u0c6e\u0c6f\3\2\2\2\u0c6f\u0c71\3\2\2\2\u0c70\u0c6e\3\2\2\2\u0c71" + + "\u0c72\5\u0158\u00ad\2\u0c72\u0c73\7\34\2\2\u0c73\u0c7b\5d\63\2\u0c74" + + "\u0c76\7\7\2\2\u0c75\u0c74\3\2\2\2\u0c76\u0c79\3\2\2\2\u0c77\u0c75\3\2" + + "\2\2\u0c77\u0c78\3\2\2\2\u0c78\u0c7a\3\2\2\2\u0c79\u0c77\3\2\2\2\u0c7a" + + "\u0c7c\7\n\2\2\u0c7b\u0c77\3\2\2\2\u0c7b\u0c7c\3\2\2\2\u0c7c\u0c7d\3\2" + + "\2\2\u0c7d\u0c81\7\f\2\2\u0c7e\u0c80\7\7\2\2\u0c7f\u0c7e\3\2\2\2\u0c80" + + "\u0c83\3\2\2\2\u0c81\u0c7f\3\2\2\2\u0c81\u0c82\3\2\2\2\u0c82\u0c84\3\2" + + "\2\2\u0c83\u0c81\3\2\2\2\u0c84\u0c85\5\u0088E\2\u0c85\u010b\3\2\2\2\u0c86" + + "\u0c8a\7^\2\2\u0c87\u0c89\7\7\2\2\u0c88\u0c87\3\2\2\2\u0c89\u0c8c\3\2" + + "\2\2\u0c8a\u0c88\3\2\2\2\u0c8a\u0c8b\3\2\2\2\u0c8b\u0c8d\3\2\2\2\u0c8c" + + "\u0c8a\3\2\2\2\u0c8d\u0c8e\5\u0088E\2\u0c8e\u010d\3\2\2\2\u0c8f\u0c93" + + "\7b\2\2\u0c90\u0c92\7\7\2\2\u0c91\u0c90\3\2\2\2\u0c92\u0c95\3\2\2\2\u0c93" + + "\u0c91\3\2\2\2\u0c93\u0c94\3\2\2\2\u0c94\u0c96\3\2\2\2\u0c95\u0c93\3\2" + + "\2\2\u0c96\u0ca0\5\u0098M\2\u0c97\u0c99\t\f\2\2\u0c98\u0c9a\5\u0098M\2" + + "\u0c99\u0c98\3\2\2\2\u0c99\u0c9a\3\2\2\2\u0c9a\u0ca0\3\2\2\2\u0c9b\u0ca0" + + "\7d\2\2\u0c9c\u0ca0\7;\2\2\u0c9d\u0ca0\7e\2\2\u0c9e\u0ca0\7<\2\2\u0c9f" + + "\u0c8f\3\2\2\2\u0c9f\u0c97\3\2\2\2\u0c9f\u0c9b\3\2\2\2\u0c9f\u0c9c\3\2" + + "\2\2\u0c9f\u0c9d\3\2\2\2\u0c9f\u0c9e\3\2\2\2\u0ca0\u010f\3\2\2\2\u0ca1" + + "\u0ca3\5|?\2\u0ca2\u0ca1\3\2\2\2\u0ca2\u0ca3\3\2\2\2\u0ca3\u0ca4\3\2\2" + + "\2\u0ca4\u0ca8\7\'\2\2\u0ca5\u0ca7\7\7\2\2\u0ca6\u0ca5\3\2\2\2\u0ca7\u0caa" + + "\3\2\2\2\u0ca8\u0ca6\3\2\2\2\u0ca8\u0ca9\3\2\2\2\u0ca9\u0cad\3\2\2\2\u0caa" + + "\u0ca8\3\2\2\2\u0cab\u0cae\5\u0158\u00ad\2\u0cac\u0cae\7J\2\2\u0cad\u0cab" + + "\3\2\2\2\u0cad\u0cac\3\2\2\2\u0cae\u0111\3\2\2\2\u0caf\u0cb0\t\r\2\2\u0cb0" + + "\u0113\3\2\2\2\u0cb1\u0cb2\t\16\2\2\u0cb2\u0115\3\2\2\2\u0cb3\u0cb4\t" + + "\17\2\2\u0cb4\u0117\3\2\2\2\u0cb5\u0cb6\t\20\2\2\u0cb6\u0119\3\2\2\2\u0cb7" + + "\u0cb8\t\21\2\2\u0cb8\u011b\3\2\2\2\u0cb9\u0cba\t\22\2\2\u0cba\u011d\3" + + "\2\2\2\u0cbb\u0cbc\t\23\2\2\u0cbc\u011f\3\2\2\2\u0cbd\u0cbe\t\24\2\2\u0cbe" + + "\u0121\3\2\2\2\u0cbf\u0cc5\7\26\2\2\u0cc0\u0cc5\7\27\2\2\u0cc1\u0cc5\7" + + "\25\2\2\u0cc2\u0cc5\7\24\2\2\u0cc3\u0cc5\5\u0126\u0094\2\u0cc4\u0cbf\3" + + "\2\2\2\u0cc4\u0cc0\3\2\2\2\u0cc4\u0cc1\3\2\2\2\u0cc4\u0cc2\3\2\2\2\u0cc4" + + "\u0cc3\3\2\2\2\u0cc5\u0123\3\2\2\2\u0cc6\u0ccb\7\26\2\2\u0cc7\u0ccb\7" + + "\27\2\2\u0cc8\u0cc9\7\33\2\2\u0cc9\u0ccb\5\u0126\u0094\2\u0cca\u0cc6\3" + + "\2\2\2\u0cca\u0cc7\3\2\2\2\u0cca\u0cc8\3\2\2\2\u0ccb\u0125\3\2\2\2\u0ccc" + + "\u0ccd\t\25\2\2\u0ccd\u0127\3\2\2\2\u0cce\u0cd0\7\7\2\2\u0ccf\u0cce\3" + + "\2\2\2\u0cd0\u0cd3\3\2\2\2\u0cd1\u0ccf\3\2\2\2\u0cd1\u0cd2\3\2\2\2\u0cd2" + + "\u0cd4\3\2\2\2\u0cd3\u0cd1\3\2\2\2\u0cd4\u0cde\7\t\2\2\u0cd5\u0cd7\7\7" + + "\2\2\u0cd6\u0cd5\3\2\2\2\u0cd7\u0cda\3\2\2\2\u0cd8\u0cd6\3\2\2\2\u0cd8" + + "\u0cd9\3\2\2\2\u0cd9\u0cdb\3\2\2\2\u0cda\u0cd8\3\2\2\2\u0cdb\u0cde\5\u012a" + + "\u0096\2\u0cdc\u0cde\7\'\2\2\u0cdd\u0cd1\3\2\2\2\u0cdd\u0cd8\3\2\2\2\u0cdd" + + "\u0cdc\3\2\2\2\u0cde\u0129\3\2\2\2\u0cdf\u0ce0\7/\2\2\u0ce0\u0ce1\7\t" + + "\2\2\u0ce1\u012b\3\2\2\2\u0ce2\u0ce5\5\u014e\u00a8\2\u0ce3\u0ce5\5\u0130" + + "\u0099\2\u0ce4\u0ce2\3\2\2\2\u0ce4\u0ce3\3\2\2\2\u0ce5\u0ce6\3\2\2\2\u0ce6" + + "\u0ce4\3\2\2\2\u0ce6\u0ce7\3\2\2\2\u0ce7\u012d\3\2\2\2\u0ce8\u0ceb\5\u014e" + + "\u00a8\2\u0ce9\u0ceb\5\u0148\u00a5\2\u0cea\u0ce8\3\2\2\2\u0cea\u0ce9\3" + + "\2\2\2\u0ceb\u0cec\3\2\2\2\u0cec\u0cea\3\2\2\2\u0cec\u0ced\3\2\2\2\u0ced" + + "\u012f\3\2\2\2\u0cee\u0cf7\5\u0136\u009c\2\u0cef\u0cf7\5\u0138\u009d\2" + + "\u0cf0\u0cf7\5\u013a\u009e\2\u0cf1\u0cf7\5\u0142\u00a2\2\u0cf2\u0cf7\5" + + "\u0144\u00a3\2\u0cf3\u0cf7\5\u0146\u00a4\2\u0cf4\u0cf7\5\u0148\u00a5\2" + + "\u0cf5\u0cf7\5\u014c\u00a7\2\u0cf6\u0cee\3\2\2\2\u0cf6\u0cef\3\2\2\2\u0cf6" + + "\u0cf0\3\2\2\2\u0cf6\u0cf1\3\2\2\2\u0cf6\u0cf2\3\2\2\2\u0cf6\u0cf3\3\2" + + "\2\2\u0cf6\u0cf4\3\2\2\2\u0cf6\u0cf5\3\2\2\2\u0cf7\u0cfb\3\2\2\2\u0cf8" + + "\u0cfa\7\7\2\2\u0cf9\u0cf8\3\2\2\2\u0cfa\u0cfd\3\2\2\2\u0cfb\u0cf9\3\2" + + "\2\2\u0cfb\u0cfc\3\2\2\2\u0cfc\u0131\3\2\2\2\u0cfd\u0cfb\3\2\2\2\u0cfe" + + "\u0d00\5\u0134\u009b\2\u0cff\u0cfe\3\2\2\2\u0d00\u0d01\3\2\2\2\u0d01\u0cff" + + "\3\2\2\2\u0d01\u0d02\3\2\2\2\u0d02\u0133\3\2\2\2\u0d03\u0d0c\5\u014e\u00a8" + + "\2\u0d04\u0d08\7|\2\2\u0d05\u0d07\7\7\2\2\u0d06\u0d05\3\2\2\2\u0d07\u0d0a" + + "\3\2\2\2\u0d08\u0d06\3\2\2\2\u0d08\u0d09\3\2\2\2\u0d09\u0d0c\3\2\2\2\u0d0a" + + "\u0d08\3\2\2\2\u0d0b\u0d03\3\2\2\2\u0d0b\u0d04\3\2\2\2\u0d0c\u0135\3\2" + + "\2\2\u0d0d\u0d0e\t\26\2\2\u0d0e\u0137\3\2\2\2\u0d0f\u0d10\t\27\2\2\u0d10" + + "\u0139\3\2\2\2\u0d11\u0d12\t\30\2\2\u0d12\u013b\3\2\2\2\u0d13\u0d14\t" + + "\31\2\2\u0d14\u013d\3\2\2\2\u0d15\u0d17\5\u0140\u00a1\2\u0d16\u0d15\3" + + "\2\2\2\u0d17\u0d18\3\2\2\2\u0d18\u0d16\3\2\2\2\u0d18\u0d19\3\2\2\2\u0d19" + + "\u013f\3\2\2\2\u0d1a\u0d1e\5\u014a\u00a6\2\u0d1b\u0d1d\7\7\2\2\u0d1c\u0d1b" + + "\3\2\2\2\u0d1d\u0d20\3\2\2\2\u0d1e\u0d1c\3\2\2\2\u0d1e\u0d1f\3\2\2\2\u0d1f" + + "\u0d2a\3\2\2\2\u0d20\u0d1e\3\2\2\2\u0d21\u0d25\5\u013c\u009f\2\u0d22\u0d24" + + "\7\7\2\2\u0d23\u0d22\3\2\2\2\u0d24\u0d27\3\2\2\2\u0d25\u0d23\3\2\2\2\u0d25" + + "\u0d26\3\2\2\2\u0d26\u0d2a\3\2\2\2\u0d27\u0d25\3\2\2\2\u0d28\u0d2a\5\u014e" + + "\u00a8\2\u0d29\u0d1a\3\2\2\2\u0d29\u0d21\3\2\2\2\u0d29\u0d28\3\2\2\2\u0d2a" + + "\u0141\3\2\2\2\u0d2b\u0d2c\t\32\2\2\u0d2c\u0143\3\2\2\2\u0d2d\u0d2e\7" + + "\u0081\2\2\u0d2e\u0145\3\2\2\2\u0d2f\u0d30\t\33\2\2\u0d30\u0147\3\2\2" + + "\2\u0d31\u0d32\t\34\2\2\u0d32\u0149\3\2\2\2\u0d33\u0d34\7\u0086\2\2\u0d34" + + "\u014b\3\2\2\2\u0d35\u0d36\t\35\2\2\u0d36\u014d\3\2\2\2\u0d37\u0d3a\5" + + "\u0150\u00a9\2\u0d38\u0d3a\5\u0152\u00aa\2\u0d39\u0d37\3\2\2\2\u0d39\u0d38" + + "\3\2\2\2\u0d3a\u0d3e\3\2\2\2\u0d3b\u0d3d\7\7\2\2\u0d3c\u0d3b\3\2\2\2\u0d3d" + + "\u0d40\3\2\2\2\u0d3e\u0d3c\3\2\2\2\u0d3e\u0d3f\3\2\2\2\u0d3f\u014f\3\2" + + "\2\2\u0d40\u0d3e\3\2\2\2\u0d41\u0d45\5\u0154\u00ab\2\u0d42\u0d44\7\7\2" + + "\2\u0d43\u0d42\3\2\2\2\u0d44\u0d47\3\2\2\2\u0d45\u0d43\3\2\2\2\u0d45\u0d46" + + "\3\2\2\2\u0d46\u0d4b\3\2\2\2\u0d47\u0d45\3\2\2\2\u0d48\u0d4b\7*\2\2\u0d49" + + "\u0d4b\7,\2\2\u0d4a\u0d41\3\2\2\2\u0d4a\u0d48\3\2\2\2\u0d4a\u0d49\3\2" + + "\2\2\u0d4b\u0d4c\3\2\2\2\u0d4c\u0d4d\5\u0156\u00ac\2\u0d4d\u0151\3\2\2" + + "\2\u0d4e\u0d52\5\u0154\u00ab\2\u0d4f\u0d51\7\7\2\2\u0d50\u0d4f\3\2\2\2" + + "\u0d51\u0d54\3\2\2\2\u0d52\u0d50\3\2\2\2\u0d52\u0d53\3\2\2\2\u0d53\u0d58" + + "\3\2\2\2\u0d54\u0d52\3\2\2\2\u0d55\u0d58\7*\2\2\u0d56\u0d58\7,\2\2\u0d57" + + "\u0d4e\3\2\2\2\u0d57\u0d55\3\2\2\2\u0d57\u0d56\3\2\2\2\u0d58\u0d59\3\2" + + "\2\2\u0d59\u0d5b\7\r\2\2\u0d5a\u0d5c\5\u0156\u00ac\2\u0d5b\u0d5a\3\2\2" + + "\2\u0d5c\u0d5d\3\2\2\2\u0d5d\u0d5b\3\2\2\2\u0d5d\u0d5e\3\2\2\2\u0d5e\u0d5f" + + "\3\2\2\2\u0d5f\u0d60\7\16\2\2\u0d60\u0153\3\2\2\2\u0d61\u0d62\t\2\2\2" + + "\u0d62\u0d66\t\36\2\2\u0d63\u0d65\7\7\2\2\u0d64\u0d63\3\2\2\2\u0d65\u0d68" + + "\3\2\2\2\u0d66\u0d64\3\2\2\2\u0d66\u0d67\3\2\2\2\u0d67\u0d69\3\2\2\2\u0d68" + + "\u0d66\3\2\2\2\u0d69\u0d6a\7\34\2\2\u0d6a\u0155\3\2\2\2\u0d6b\u0d6e\5" + + "&\24\2\u0d6c\u0d6e\5l\67\2\u0d6d\u0d6b\3\2\2\2\u0d6d\u0d6c\3\2\2\2\u0d6e" + + "\u0157\3\2\2\2\u0d6f\u0d70\t\37\2\2\u0d70\u0159\3\2\2\2\u0d71\u0d7c\5" + + "\u0158\u00ad\2\u0d72\u0d74\7\7\2\2\u0d73\u0d72\3\2\2\2\u0d74\u0d77\3\2" + + "\2\2\u0d75\u0d73\3\2\2\2\u0d75\u0d76\3\2\2\2\u0d76\u0d78\3\2\2\2\u0d77" + + "\u0d75\3\2\2\2\u0d78\u0d79\7\t\2\2\u0d79\u0d7b\5\u0158\u00ad\2\u0d7a\u0d75" + + "\3\2\2\2\u0d7b\u0d7e\3\2\2\2\u0d7c\u0d7a\3\2\2\2\u0d7c\u0d7d\3\2\2\2\u0d7d" + + "\u015b\3\2\2\2\u0d7e\u0d7c\3\2\2\2\u0214\u015d\u0162\u0168\u0170\u0176" + + "\u017b\u0181\u018b\u0194\u019b\u01a2\u01a9\u01ae\u01b3\u01b9\u01bb\u01c0" + + "\u01c8\u01cb\u01d2\u01d5\u01db\u01e2\u01e6\u01eb\u01f2\u01fc\u01ff\u0206" + + "\u0209\u020c\u0211\u0218\u021c\u0221\u0225\u022a\u0231\u0235\u023a\u023e" + + "\u0243\u024a\u024e\u0251\u0257\u025a\u0262\u0269\u0272\u0279\u0280\u0286" + + "\u028c\u0290\u0292\u0297\u029d\u02a0\u02a5\u02ad\u02b4\u02bb\u02bf\u02c5" + + "\u02cc\u02d2\u02d9\u02e1\u02e7\u02ee\u02f3\u02fa\u0303\u030a\u0311\u0317" + + "\u031d\u0321\u0326\u032c\u0331\u0338\u033f\u0343\u0349\u0350\u0357\u035d" + + "\u0363\u036a\u0371\u0378\u037c\u0383\u0389\u038f\u0395\u039c\u03a0\u03a5" + + "\u03ac\u03b0\u03b5\u03b9\u03bf\u03c6\u03cd\u03d3\u03d9\u03dd\u03df\u03e4" + + "\u03ea\u03f0\u03f7\u03fb\u03fe\u0404\u0408\u040d\u0414\u0419\u041e\u0425" + + "\u042c\u0433\u0437\u043c\u0440\u0445\u0449\u0450\u0454\u0459\u045f\u0466" + + "\u046d\u0471\u0477\u047e\u0485\u048b\u0491\u0495\u049a\u04a0\u04a6\u04aa" + + "\u04af\u04b6\u04bb\u04c0\u04c5\u04ca\u04ce\u04d3\u04da\u04df\u04e1\u04e6" + + "\u04e9\u04ee\u04f2\u04f7\u04fb\u04fe\u0501\u0506\u050a\u050d\u050f\u0515" + + "\u051b\u0521\u0528\u052f\u0536\u053a\u053f\u0543\u0546\u054c\u0553\u055a" + + "\u055e\u0563\u056a\u0571\u0575\u057a\u057f\u0585\u058c\u0593\u0599\u059f" + + "\u05a3\u05a5\u05aa\u05b0\u05b6\u05bd\u05c1\u05c7\u05ce\u05d2\u05d8\u05df" + + "\u05e5\u05eb\u05f2\u05f9\u05fd\u0602\u0606\u0609\u060f\u0616\u061d\u0621" + + "\u0626\u062a\u0630\u0639\u063d\u0642\u0649\u064d\u0652\u065b\u0662\u0668" + + "\u066e\u0672\u0678\u067b\u0681\u0685\u068a\u068e\u0691\u0697\u069b\u069f" + + "\u06a4\u06aa\u06b2\u06b9\u06bf\u06c6\u06ca\u06cd\u06d1\u06d6\u06dc\u06e0" + + "\u06e6\u06ed\u06f0\u06f6\u06fd\u0706\u070b\u0710\u0717\u071c\u0720\u0726" + + "\u072a\u072f\u0738\u073f\u0745\u074a\u0750\u0755\u075a\u0765\u0768\u076b" + + "\u076f\u0771\u0778\u077f\u0784\u078a\u0791\u0799\u079f\u07a6\u07ab\u07b3" + + "\u07b7\u07bd\u07c6\u07cb\u07d1\u07d5\u07da\u07e1\u07ee\u07f3\u07fc\u0800" + + "\u0805\u0808\u0810\u0817\u081d\u0824\u082b\u0831\u0839\u0840\u0848\u084f" + + "\u0856\u085e\u0867\u086c\u086e\u0875\u087c\u0883\u088e\u0895\u089d\u08a3" + + "\u08ab\u08b2\u08ba\u08c1\u08c8\u08cf\u08d6\u08dc\u08e7\u08ea\u08f0\u08f8" + + "\u08ff\u0905\u090c\u0913\u0919\u0920\u0928\u092e\u0935\u093c\u0942\u0948" + + "\u094c\u0951\u095a\u0960\u0963\u0966\u096a\u096f\u0973\u0978\u0981\u0988" + + "\u098f\u0995\u099b\u099f\u09a4\u09ad\u09b4\u09bb\u09c1\u09c7\u09cb\u09d0" + + "\u09d3\u09d8\u09dd\u09e4\u09eb\u09ee\u09f1\u09f6\u0a09\u0a0f\u0a16\u0a1f" + + "\u0a26\u0a2d\u0a33\u0a39\u0a3d\u0a42\u0a45\u0a4d\u0a52\u0a54\u0a5d\u0a5f" + + "\u0a6a\u0a71\u0a7c\u0a83\u0a8c\u0a90\u0a95\u0a9c\u0a9f\u0aa5\u0aae\u0ab5" + + "\u0abb\u0ac1\u0ac5\u0acc\u0ad3\u0ad7\u0ad9\u0adf\u0ae6\u0aeb\u0af0\u0af7" + + "\u0afe\u0b02\u0b07\u0b0b\u0b10\u0b14\u0b18\u0b1e\u0b25\u0b2c\u0b2f\u0b34" + + "\u0b38\u0b41\u0b48\u0b4d\u0b51\u0b54\u0b5a\u0b61\u0b68\u0b6f\u0b74\u0b79" + + "\u0b7d\u0b82\u0b89\u0b8e\u0b91\u0b97\u0b9d\u0ba4\u0bab\u0bb2\u0bb5\u0bbe" + + "\u0bc2\u0bc7\u0bce\u0bd5\u0bda\u0be0\u0be9\u0bf0\u0bf6\u0bfc\u0c00\u0c05" + + "\u0c0c\u0c11\u0c17\u0c1e\u0c23\u0c25\u0c2a\u0c30\u0c39\u0c42\u0c49\u0c4f" + + "\u0c54\u0c58\u0c5d\u0c61\u0c67\u0c6e\u0c77\u0c7b\u0c81\u0c8a\u0c93\u0c99" + + "\u0c9f\u0ca2\u0ca8\u0cad\u0cc4\u0cca\u0cd1\u0cd8\u0cdd\u0ce4\u0ce6\u0cea" + + "\u0cec\u0cf6\u0cfb\u0d01\u0d08\u0d0b\u0d18\u0d1e\u0d25\u0d29\u0d39\u0d3e" + + "\u0d45\u0d4a\u0d52\u0d57\u0d5d\u0d66\u0d6d\u0d75\u0d7c"; + public static final String _serializedATN = + Utils.join(new String[] {_serializedATNSegment0, _serializedATNSegment1}, ""); + public static final ATN _ATN = new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + + static { + RuntimeMetaData.checkVersion("4.9.3", RuntimeMetaData.VERSION); + } + + 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] = ""; + } + } + } + + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } + + public KotlinParser(TokenStream input) { + super(input); + _interp = new ParserATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache); + } + + private static String[] makeRuleNames() { + return new String[] { + "kotlinFile", + "script", + "shebangLine", + "fileAnnotation", + "packageHeader", + "importList", + "importHeader", + "importAlias", + "topLevelObject", + "typeAlias", + "declaration", + "classDeclaration", + "primaryConstructor", + "classBody", + "classParameters", + "classParameter", + "delegationSpecifiers", + "delegationSpecifier", + "constructorInvocation", + "annotatedDelegationSpecifier", + "explicitDelegation", + "typeParameters", + "typeParameter", + "typeConstraints", + "typeConstraint", + "classMemberDeclarations", + "classMemberDeclaration", + "anonymousInitializer", + "companionObject", + "functionValueParameters", + "functionValueParameter", + "functionDeclaration", + "functionBody", + "variableDeclaration", + "multiVariableDeclaration", + "propertyDeclaration", + "propertyDelegate", + "getter", + "setter", + "parametersWithOptionalType", + "functionValueParameterWithOptionalType", + "parameterWithOptionalType", + "parameter", + "objectDeclaration", + "secondaryConstructor", + "constructorDelegationCall", + "enumClassBody", + "enumEntries", + "enumEntry", + "type", + "typeReference", + "nullableType", + "quest", + "userType", + "simpleUserType", + "typeProjection", + "typeProjectionModifiers", + "typeProjectionModifier", + "functionType", + "functionTypeParameters", + "parenthesizedType", + "receiverType", + "parenthesizedUserType", + "statements", + "statement", + "label", + "controlStructureBody", + "block", + "loopStatement", + "forStatement", + "whileStatement", + "doWhileStatement", + "assignment", + "semi", + "semis", + "expression", + "disjunction", + "conjunction", + "equality", + "comparison", + "genericCallLikeComparison", + "infixOperation", + "elvisExpression", + "elvis", + "infixFunctionCall", + "rangeExpression", + "additiveExpression", + "multiplicativeExpression", + "asExpression", + "prefixUnaryExpression", + "unaryPrefix", + "postfixUnaryExpression", + "postfixUnarySuffix", + "directlyAssignableExpression", + "parenthesizedDirectlyAssignableExpression", + "assignableExpression", + "parenthesizedAssignableExpression", + "assignableSuffix", + "indexingSuffix", + "navigationSuffix", + "callSuffix", + "annotatedLambda", + "typeArguments", + "valueArguments", + "valueArgument", + "primaryExpression", + "parenthesizedExpression", + "collectionLiteral", + "literalConstant", + "stringLiteral", + "lineStringLiteral", + "multiLineStringLiteral", + "lineStringContent", + "lineStringExpression", + "multiLineStringContent", + "multiLineStringExpression", + "lambdaLiteral", + "lambdaParameters", + "lambdaParameter", + "anonymousFunction", + "functionLiteral", + "objectLiteral", + "thisExpression", + "superExpression", + "ifExpression", + "whenSubject", + "whenExpression", + "whenEntry", + "whenCondition", + "rangeTest", + "typeTest", + "tryExpression", + "catchBlock", + "finallyBlock", + "jumpExpression", + "callableReference", + "assignmentAndOperator", + "equalityOperator", + "comparisonOperator", + "inOperator", + "isOperator", + "additiveOperator", + "multiplicativeOperator", + "asOperator", + "prefixUnaryOperator", + "postfixUnaryOperator", + "excl", + "memberAccessOperator", + "safeNav", + "modifiers", + "parameterModifiers", + "modifier", + "typeModifiers", + "typeModifier", + "classModifier", + "memberModifier", + "visibilityModifier", + "varianceModifier", + "typeParameterModifiers", + "typeParameterModifier", + "functionModifier", + "propertyModifier", + "inheritanceModifier", + "parameterModifier", + "reificationModifier", + "platformModifier", + "annotation", + "singleAnnotation", + "multiAnnotation", + "annotationUseSiteTarget", + "unescapedAnnotation", + "simpleIdentifier", + "identifier" + }; + } + + private static String[] makeLiteralNames() { + return new String[] { + null, + null, + null, + null, + null, + null, + "'...'", + "'.'", + "','", + "'('", + "')'", + "'['", + "']'", + "'{'", + "'}'", + "'*'", + "'%'", + "'/'", + "'+'", + "'-'", + "'++'", + "'--'", + "'&&'", + "'||'", + null, + "'!'", + "':'", + "';'", + "'='", + "'+='", + "'-='", + "'*='", + "'/='", + "'%='", + "'->'", + "'=>'", + "'..'", + "'::'", + "';;'", + "'#'", + "'@'", + null, + null, + null, + null, + "'?'", + "'<'", + "'>'", + "'<='", + "'>='", + "'!='", + "'!=='", + "'as?'", + "'=='", + "'==='", + "'''", + null, + null, + null, + null, + null, + "'file'", + "'field'", + "'property'", + "'get'", + "'set'", + "'receiver'", + "'param'", + "'setparam'", + "'delegate'", + "'package'", + "'import'", + "'class'", + "'interface'", + "'fun'", + "'object'", + "'val'", + "'var'", + "'typealias'", + "'constructor'", + "'by'", + "'companion'", + "'init'", + "'this'", + "'super'", + "'typeof'", + "'where'", + "'if'", + "'else'", + "'when'", + "'try'", + "'catch'", + "'finally'", + "'for'", + "'do'", + "'while'", + "'throw'", + "'return'", + "'continue'", + "'break'", + "'as'", + "'is'", + "'in'", + null, + null, + "'out'", + "'dynamic'", + "'public'", + "'private'", + "'protected'", + "'internal'", + "'enum'", + "'sealed'", + "'annotation'", + "'data'", + "'inner'", + "'value'", + "'tailrec'", + "'operator'", + "'inline'", + "'infix'", + "'external'", + "'suspend'", + "'override'", + "'abstract'", + "'final'", + "'open'", + "'const'", + "'lateinit'", + "'vararg'", + "'noinline'", + "'crossinline'", + "'reified'", + "'expect'", + "'actual'", + null, + null, + null, + null, + null, + null, + null, + null, + null, + "'null'", + null, + null, + null, + null, + null, + "'\"\"\"'" + }; + } + + private static String[] makeSymbolicNames() { + return new String[] { + null, + "ShebangLine", + "DelimitedComment", + "LineComment", + "WS", + "NL", + "RESERVED", + "DOT", + "COMMA", + "LPAREN", + "RPAREN", + "LSQUARE", + "RSQUARE", + "LCURL", + "RCURL", + "MULT", + "MOD", + "DIV", + "ADD", + "SUB", + "INCR", + "DECR", + "CONJ", + "DISJ", + "EXCL_WS", + "EXCL_NO_WS", + "COLON", + "SEMICOLON", + "ASSIGNMENT", + "ADD_ASSIGNMENT", + "SUB_ASSIGNMENT", + "MULT_ASSIGNMENT", + "DIV_ASSIGNMENT", + "MOD_ASSIGNMENT", + "ARROW", + "DOUBLE_ARROW", + "RANGE", + "COLONCOLON", + "DOUBLE_SEMICOLON", + "HASH", + "AT_NO_WS", + "AT_POST_WS", + "AT_PRE_WS", + "AT_BOTH_WS", + "QUEST_WS", + "QUEST_NO_WS", + "LANGLE", + "RANGLE", + "LE", + "GE", + "EXCL_EQ", + "EXCL_EQEQ", + "AS_SAFE", + "EQEQ", + "EQEQEQ", + "SINGLE_QUOTE", + "RETURN_AT", + "CONTINUE_AT", + "BREAK_AT", + "THIS_AT", + "SUPER_AT", + "FILE", + "FIELD", + "PROPERTY", + "GET", + "SET", + "RECEIVER", + "PARAM", + "SETPARAM", + "DELEGATE", + "PACKAGE", + "IMPORT", + "CLASS", + "INTERFACE", + "FUN", + "OBJECT", + "VAL", + "VAR", + "TYPE_ALIAS", + "CONSTRUCTOR", + "BY", + "COMPANION", + "INIT", + "THIS", + "SUPER", + "TYPEOF", + "WHERE", + "IF", + "ELSE", + "WHEN", + "TRY", + "CATCH", + "FINALLY", + "FOR", + "DO", + "WHILE", + "THROW", + "RETURN", + "CONTINUE", + "BREAK", + "AS", + "IS", + "IN", + "NOT_IS", + "NOT_IN", + "OUT", + "DYNAMIC", + "PUBLIC", + "PRIVATE", + "PROTECTED", + "INTERNAL", + "ENUM", + "SEALED", + "ANNOTATION", + "DATA", + "INNER", + "VALUE", + "TAILREC", + "OPERATOR", + "INLINE", + "INFIX", + "EXTERNAL", + "SUSPEND", + "OVERRIDE", + "ABSTRACT", + "FINAL", + "OPEN", + "CONST", + "LATEINIT", + "VARARG", + "NOINLINE", + "CROSSINLINE", + "REIFIED", + "EXPECT", + "ACTUAL", + "RealLiteral", + "FloatLiteral", + "DoubleLiteral", + "IntegerLiteral", + "HexLiteral", + "BinLiteral", + "UnsignedLiteral", + "LongLiteral", + "BooleanLiteral", + "NullLiteral", + "CharacterLiteral", + "Identifier", + "IdentifierOrSoftKey", + "FieldIdentifier", + "QUOTE_OPEN", + "TRIPLE_QUOTE_OPEN", + "UNICODE_CLASS_LL", + "UNICODE_CLASS_LM", + "UNICODE_CLASS_LO", + "UNICODE_CLASS_LT", + "UNICODE_CLASS_LU", + "UNICODE_CLASS_ND", + "UNICODE_CLASS_NL", + "QUOTE_CLOSE", + "LineStrRef", + "LineStrText", + "LineStrEscapedChar", + "LineStrExprStart", + "TRIPLE_QUOTE_CLOSE", + "MultiLineStringQuote", + "MultiLineStrRef", + "MultiLineStrText", + "MultiLineStrExprStart", + "Inside_Comment", + "Inside_WS", + "Inside_NL", + "ErrorCharacter" + }; + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } + + @Override + public String[] getRuleNames() { + return ruleNames; + } + + @Override + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + @Override + public String getSerializedATN() { + return _serializedATN; + } + + @Override + public String getGrammarFileName() { + return "KotlinParser.g4"; + } + + @Override + public ATN getATN() { + return _ATN; + } + + public final KotlinFileContext kotlinFile() throws RecognitionException { + KotlinFileContext _localctx = new KotlinFileContext(_ctx, getState()); + enterRule(_localctx, 0, RULE_kotlinFile); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(347); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == ShebangLine) { + { + setState(346); + shebangLine(); + } + } + + setState(352); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(349); + match(NL); + } + } + setState(354); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(358); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 2, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(355); + fileAnnotation(); + } + } + } + setState(360); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 2, _ctx); + } + setState(361); + packageHeader(); + setState(362); + importList(); + setState(366); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == AT_NO_WS + || _la == AT_PRE_WS + || ((((_la - 72)) & ~0x3f) == 0 + && ((1L << (_la - 72)) + & ((1L << (CLASS - 72)) + | (1L << (INTERFACE - 72)) + | (1L << (FUN - 72)) + | (1L << (OBJECT - 72)) + | (1L << (VAL - 72)) + | (1L << (VAR - 72)) + | (1L << (TYPE_ALIAS - 72)) + | (1L << (PUBLIC - 72)) + | (1L << (PRIVATE - 72)) + | (1L << (PROTECTED - 72)) + | (1L << (INTERNAL - 72)) + | (1L << (ENUM - 72)) + | (1L << (SEALED - 72)) + | (1L << (ANNOTATION - 72)) + | (1L << (DATA - 72)) + | (1L << (INNER - 72)) + | (1L << (VALUE - 72)) + | (1L << (TAILREC - 72)) + | (1L << (OPERATOR - 72)) + | (1L << (INLINE - 72)) + | (1L << (INFIX - 72)) + | (1L << (EXTERNAL - 72)) + | (1L << (SUSPEND - 72)) + | (1L << (OVERRIDE - 72)) + | (1L << (ABSTRACT - 72)) + | (1L << (FINAL - 72)) + | (1L << (OPEN - 72)) + | (1L << (CONST - 72)) + | (1L << (LATEINIT - 72)) + | (1L << (VARARG - 72)) + | (1L << (NOINLINE - 72)) + | (1L << (CROSSINLINE - 72)) + | (1L << (EXPECT - 72)) + | (1L << (ACTUAL - 72)))) + != 0)) { + { + { + setState(363); + topLevelObject(); + } + } + setState(368); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(369); + match(EOF); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ScriptContext script() throws RecognitionException { + ScriptContext _localctx = new ScriptContext(_ctx, getState()); + enterRule(_localctx, 2, RULE_script); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(372); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == ShebangLine) { + { + setState(371); + shebangLine(); + } + } + + setState(377); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(374); + match(NL); + } + } + setState(379); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(383); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 6, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(380); + fileAnnotation(); + } + } + } + setState(385); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 6, _ctx); + } + setState(386); + packageHeader(); + setState(387); + importList(); + setState(393); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 + && ((1L << _la) + & ((1L << LPAREN) + | (1L << LSQUARE) + | (1L << LCURL) + | (1L << ADD) + | (1L << SUB) + | (1L << INCR) + | (1L << DECR) + | (1L << EXCL_WS) + | (1L << EXCL_NO_WS) + | (1L << COLONCOLON) + | (1L << AT_NO_WS) + | (1L << AT_PRE_WS) + | (1L << RETURN_AT) + | (1L << CONTINUE_AT) + | (1L << BREAK_AT) + | (1L << THIS_AT) + | (1L << SUPER_AT) + | (1L << FILE) + | (1L << FIELD) + | (1L << PROPERTY))) + != 0) + || ((((_la - 64)) & ~0x3f) == 0 + && ((1L << (_la - 64)) + & ((1L << (GET - 64)) + | (1L << (SET - 64)) + | (1L << (RECEIVER - 64)) + | (1L << (PARAM - 64)) + | (1L << (SETPARAM - 64)) + | (1L << (DELEGATE - 64)) + | (1L << (IMPORT - 64)) + | (1L << (CLASS - 64)) + | (1L << (INTERFACE - 64)) + | (1L << (FUN - 64)) + | (1L << (OBJECT - 64)) + | (1L << (VAL - 64)) + | (1L << (VAR - 64)) + | (1L << (TYPE_ALIAS - 64)) + | (1L << (CONSTRUCTOR - 64)) + | (1L << (BY - 64)) + | (1L << (COMPANION - 64)) + | (1L << (INIT - 64)) + | (1L << (THIS - 64)) + | (1L << (SUPER - 64)) + | (1L << (WHERE - 64)) + | (1L << (IF - 64)) + | (1L << (WHEN - 64)) + | (1L << (TRY - 64)) + | (1L << (CATCH - 64)) + | (1L << (FINALLY - 64)) + | (1L << (FOR - 64)) + | (1L << (DO - 64)) + | (1L << (WHILE - 64)) + | (1L << (THROW - 64)) + | (1L << (RETURN - 64)) + | (1L << (CONTINUE - 64)) + | (1L << (BREAK - 64)) + | (1L << (OUT - 64)) + | (1L << (DYNAMIC - 64)) + | (1L << (PUBLIC - 64)) + | (1L << (PRIVATE - 64)) + | (1L << (PROTECTED - 64)) + | (1L << (INTERNAL - 64)) + | (1L << (ENUM - 64)) + | (1L << (SEALED - 64)) + | (1L << (ANNOTATION - 64)) + | (1L << (DATA - 64)) + | (1L << (INNER - 64)) + | (1L << (VALUE - 64)) + | (1L << (TAILREC - 64)) + | (1L << (OPERATOR - 64)) + | (1L << (INLINE - 64)) + | (1L << (INFIX - 64)) + | (1L << (EXTERNAL - 64)) + | (1L << (SUSPEND - 64)) + | (1L << (OVERRIDE - 64)) + | (1L << (ABSTRACT - 64)) + | (1L << (FINAL - 64)) + | (1L << (OPEN - 64)) + | (1L << (CONST - 64)))) + != 0) + || ((((_la - 128)) & ~0x3f) == 0 + && ((1L << (_la - 128)) + & ((1L << (LATEINIT - 128)) + | (1L << (VARARG - 128)) + | (1L << (NOINLINE - 128)) + | (1L << (CROSSINLINE - 128)) + | (1L << (REIFIED - 128)) + | (1L << (EXPECT - 128)) + | (1L << (ACTUAL - 128)) + | (1L << (RealLiteral - 128)) + | (1L << (IntegerLiteral - 128)) + | (1L << (HexLiteral - 128)) + | (1L << (BinLiteral - 128)) + | (1L << (UnsignedLiteral - 128)) + | (1L << (LongLiteral - 128)) + | (1L << (BooleanLiteral - 128)) + | (1L << (NullLiteral - 128)) + | (1L << (CharacterLiteral - 128)) + | (1L << (Identifier - 128)) + | (1L << (QUOTE_OPEN - 128)) + | (1L << (TRIPLE_QUOTE_OPEN - 128)))) + != 0)) { + { + { + setState(388); + statement(); + setState(389); + semi(); + } + } + setState(395); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(396); + match(EOF); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ShebangLineContext shebangLine() throws RecognitionException { + ShebangLineContext _localctx = new ShebangLineContext(_ctx, getState()); + enterRule(_localctx, 4, RULE_shebangLine); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(398); + match(ShebangLine); + setState(400); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(399); + match(NL); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(402); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 8, _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 final FileAnnotationContext fileAnnotation() throws RecognitionException { + FileAnnotationContext _localctx = new FileAnnotationContext(_ctx, getState()); + enterRule(_localctx, 6, RULE_fileAnnotation); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(404); + _la = _input.LA(1); + if (!(_la == AT_NO_WS || _la == AT_PRE_WS)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(405); + match(FILE); + setState(409); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(406); + match(NL); + } + } + setState(411); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(412); + match(COLON); + setState(416); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(413); + match(NL); + } + } + setState(418); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(428); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LSQUARE: + { + setState(419); + match(LSQUARE); + setState(421); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(420); + unescapedAnnotation(); + } + } + setState(423); + _errHandler.sync(this); + _la = _input.LA(1); + } while (((((_la - 61)) & ~0x3f) == 0 + && ((1L << (_la - 61)) + & ((1L << (FILE - 61)) + | (1L << (FIELD - 61)) + | (1L << (PROPERTY - 61)) + | (1L << (GET - 61)) + | (1L << (SET - 61)) + | (1L << (RECEIVER - 61)) + | (1L << (PARAM - 61)) + | (1L << (SETPARAM - 61)) + | (1L << (DELEGATE - 61)) + | (1L << (IMPORT - 61)) + | (1L << (CONSTRUCTOR - 61)) + | (1L << (BY - 61)) + | (1L << (COMPANION - 61)) + | (1L << (INIT - 61)) + | (1L << (WHERE - 61)) + | (1L << (CATCH - 61)) + | (1L << (FINALLY - 61)) + | (1L << (OUT - 61)) + | (1L << (DYNAMIC - 61)) + | (1L << (PUBLIC - 61)) + | (1L << (PRIVATE - 61)) + | (1L << (PROTECTED - 61)) + | (1L << (INTERNAL - 61)) + | (1L << (ENUM - 61)) + | (1L << (SEALED - 61)) + | (1L << (ANNOTATION - 61)) + | (1L << (DATA - 61)) + | (1L << (INNER - 61)) + | (1L << (VALUE - 61)) + | (1L << (TAILREC - 61)) + | (1L << (OPERATOR - 61)) + | (1L << (INLINE - 61)) + | (1L << (INFIX - 61)) + | (1L << (EXTERNAL - 61)) + | (1L << (SUSPEND - 61)) + | (1L << (OVERRIDE - 61)) + | (1L << (ABSTRACT - 61)))) + != 0) + || ((((_la - 125)) & ~0x3f) == 0 + && ((1L << (_la - 125)) + & ((1L << (FINAL - 125)) + | (1L << (OPEN - 125)) + | (1L << (CONST - 125)) + | (1L << (LATEINIT - 125)) + | (1L << (VARARG - 125)) + | (1L << (NOINLINE - 125)) + | (1L << (CROSSINLINE - 125)) + | (1L << (REIFIED - 125)) + | (1L << (EXPECT - 125)) + | (1L << (ACTUAL - 125)) + | (1L << (Identifier - 125)))) + != 0)); + setState(425); + match(RSQUARE); + } + break; + case FILE: + case FIELD: + case PROPERTY: + case GET: + case SET: + case RECEIVER: + case PARAM: + case SETPARAM: + case DELEGATE: + case IMPORT: + case CONSTRUCTOR: + case BY: + case COMPANION: + case INIT: + case WHERE: + case CATCH: + case FINALLY: + case OUT: + case DYNAMIC: + case PUBLIC: + case PRIVATE: + case PROTECTED: + case INTERNAL: + case ENUM: + case SEALED: + case ANNOTATION: + case DATA: + case INNER: + case VALUE: + case TAILREC: + case OPERATOR: + case INLINE: + case INFIX: + case EXTERNAL: + case SUSPEND: + case OVERRIDE: + case ABSTRACT: + case FINAL: + case OPEN: + case CONST: + case LATEINIT: + case VARARG: + case NOINLINE: + case CROSSINLINE: + case REIFIED: + case EXPECT: + case ACTUAL: + case Identifier: + { + setState(427); + unescapedAnnotation(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(433); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(430); + match(NL); + } + } + setState(435); + _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 final PackageHeaderContext packageHeader() throws RecognitionException { + PackageHeaderContext _localctx = new PackageHeaderContext(_ctx, getState()); + enterRule(_localctx, 8, RULE_packageHeader); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(441); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == PACKAGE) { + { + setState(436); + match(PACKAGE); + setState(437); + identifier(); + setState(439); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 14, _ctx)) { + case 1: + { + setState(438); + semi(); + } + break; + } + } + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ImportListContext importList() throws RecognitionException { + ImportListContext _localctx = new ImportListContext(_ctx, getState()); + enterRule(_localctx, 10, RULE_importList); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(446); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 16, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(443); + importHeader(); + } + } + } + setState(448); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 16, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ImportHeaderContext importHeader() throws RecognitionException { + ImportHeaderContext _localctx = new ImportHeaderContext(_ctx, getState()); + enterRule(_localctx, 12, RULE_importHeader); + try { + enterOuterAlt(_localctx, 1); + { + setState(449); + match(IMPORT); + setState(450); + identifier(); + setState(454); + _errHandler.sync(this); + switch (_input.LA(1)) { + case DOT: + { + setState(451); + match(DOT); + setState(452); + match(MULT); + } + break; + case AS: + { + setState(453); + importAlias(); + } + break; + case EOF: + case NL: + case LPAREN: + case LSQUARE: + case LCURL: + case ADD: + case SUB: + case INCR: + case DECR: + case EXCL_WS: + case EXCL_NO_WS: + case SEMICOLON: + case COLONCOLON: + case AT_NO_WS: + case AT_PRE_WS: + case RETURN_AT: + case CONTINUE_AT: + case BREAK_AT: + case THIS_AT: + case SUPER_AT: + case FILE: + case FIELD: + case PROPERTY: + case GET: + case SET: + case RECEIVER: + case PARAM: + case SETPARAM: + case DELEGATE: + case IMPORT: + case CLASS: + case INTERFACE: + case FUN: + case OBJECT: + case VAL: + case VAR: + case TYPE_ALIAS: + case CONSTRUCTOR: + case BY: + case COMPANION: + case INIT: + case THIS: + case SUPER: + case WHERE: + case IF: + case WHEN: + case TRY: + case CATCH: + case FINALLY: + case FOR: + case DO: + case WHILE: + case THROW: + case RETURN: + case CONTINUE: + case BREAK: + case OUT: + case DYNAMIC: + case PUBLIC: + case PRIVATE: + case PROTECTED: + case INTERNAL: + case ENUM: + case SEALED: + case ANNOTATION: + case DATA: + case INNER: + case VALUE: + case TAILREC: + case OPERATOR: + case INLINE: + case INFIX: + case EXTERNAL: + case SUSPEND: + case OVERRIDE: + case ABSTRACT: + case FINAL: + case OPEN: + case CONST: + case LATEINIT: + case VARARG: + case NOINLINE: + case CROSSINLINE: + case REIFIED: + case EXPECT: + case ACTUAL: + case RealLiteral: + case IntegerLiteral: + case HexLiteral: + case BinLiteral: + case UnsignedLiteral: + case LongLiteral: + case BooleanLiteral: + case NullLiteral: + case CharacterLiteral: + case Identifier: + case QUOTE_OPEN: + case TRIPLE_QUOTE_OPEN: + break; + default: + break; + } + setState(457); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 18, _ctx)) { + case 1: + { + setState(456); + semi(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ImportAliasContext importAlias() throws RecognitionException { + ImportAliasContext _localctx = new ImportAliasContext(_ctx, getState()); + enterRule(_localctx, 14, RULE_importAlias); + try { + enterOuterAlt(_localctx, 1); + { + setState(459); + match(AS); + setState(460); + simpleIdentifier(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final TopLevelObjectContext topLevelObject() throws RecognitionException { + TopLevelObjectContext _localctx = new TopLevelObjectContext(_ctx, getState()); + enterRule(_localctx, 16, RULE_topLevelObject); + try { + enterOuterAlt(_localctx, 1); + { + setState(462); + declaration(); + setState(464); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 19, _ctx)) { + case 1: + { + setState(463); + semis(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final TypeAliasContext typeAlias() throws RecognitionException { + TypeAliasContext _localctx = new TypeAliasContext(_ctx, getState()); + enterRule(_localctx, 18, RULE_typeAlias); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(467); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == AT_NO_WS + || _la == AT_PRE_WS + || ((((_la - 107)) & ~0x3f) == 0 + && ((1L << (_la - 107)) + & ((1L << (PUBLIC - 107)) + | (1L << (PRIVATE - 107)) + | (1L << (PROTECTED - 107)) + | (1L << (INTERNAL - 107)) + | (1L << (ENUM - 107)) + | (1L << (SEALED - 107)) + | (1L << (ANNOTATION - 107)) + | (1L << (DATA - 107)) + | (1L << (INNER - 107)) + | (1L << (VALUE - 107)) + | (1L << (TAILREC - 107)) + | (1L << (OPERATOR - 107)) + | (1L << (INLINE - 107)) + | (1L << (INFIX - 107)) + | (1L << (EXTERNAL - 107)) + | (1L << (SUSPEND - 107)) + | (1L << (OVERRIDE - 107)) + | (1L << (ABSTRACT - 107)) + | (1L << (FINAL - 107)) + | (1L << (OPEN - 107)) + | (1L << (CONST - 107)) + | (1L << (LATEINIT - 107)) + | (1L << (VARARG - 107)) + | (1L << (NOINLINE - 107)) + | (1L << (CROSSINLINE - 107)) + | (1L << (EXPECT - 107)) + | (1L << (ACTUAL - 107)))) + != 0)) { + { + setState(466); + modifiers(); + } + } + + setState(469); + match(TYPE_ALIAS); + setState(473); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(470); + match(NL); + } + } + setState(475); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(476); + simpleIdentifier(); + setState(484); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 23, _ctx)) { + case 1: + { + setState(480); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(477); + match(NL); + } + } + setState(482); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(483); + typeParameters(); + } + break; + } + setState(489); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(486); + match(NL); + } + } + setState(491); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(492); + match(ASSIGNMENT); + setState(496); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(493); + match(NL); + } + } + setState(498); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(499); + type(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final DeclarationContext declaration() throws RecognitionException { + DeclarationContext _localctx = new DeclarationContext(_ctx, getState()); + enterRule(_localctx, 20, RULE_declaration); + try { + setState(506); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 26, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(501); + classDeclaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(502); + objectDeclaration(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(503); + functionDeclaration(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(504); + propertyDeclaration(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(505); + typeAlias(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ClassDeclarationContext classDeclaration() throws RecognitionException { + ClassDeclarationContext _localctx = new ClassDeclarationContext(_ctx, getState()); + enterRule(_localctx, 22, RULE_classDeclaration); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(509); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == AT_NO_WS + || _la == AT_PRE_WS + || ((((_la - 107)) & ~0x3f) == 0 + && ((1L << (_la - 107)) + & ((1L << (PUBLIC - 107)) + | (1L << (PRIVATE - 107)) + | (1L << (PROTECTED - 107)) + | (1L << (INTERNAL - 107)) + | (1L << (ENUM - 107)) + | (1L << (SEALED - 107)) + | (1L << (ANNOTATION - 107)) + | (1L << (DATA - 107)) + | (1L << (INNER - 107)) + | (1L << (VALUE - 107)) + | (1L << (TAILREC - 107)) + | (1L << (OPERATOR - 107)) + | (1L << (INLINE - 107)) + | (1L << (INFIX - 107)) + | (1L << (EXTERNAL - 107)) + | (1L << (SUSPEND - 107)) + | (1L << (OVERRIDE - 107)) + | (1L << (ABSTRACT - 107)) + | (1L << (FINAL - 107)) + | (1L << (OPEN - 107)) + | (1L << (CONST - 107)) + | (1L << (LATEINIT - 107)) + | (1L << (VARARG - 107)) + | (1L << (NOINLINE - 107)) + | (1L << (CROSSINLINE - 107)) + | (1L << (EXPECT - 107)) + | (1L << (ACTUAL - 107)))) + != 0)) { + { + setState(508); + modifiers(); + } + } + + setState(522); + _errHandler.sync(this); + switch (_input.LA(1)) { + case CLASS: + { + setState(511); + match(CLASS); + } + break; + case INTERFACE: + case FUN: + { + setState(519); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == FUN) { + { + setState(512); + match(FUN); + setState(516); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(513); + match(NL); + } + } + setState(518); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + + setState(521); + match(INTERFACE); + } + break; + default: + throw new NoViableAltException(this); + } + setState(527); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(524); + match(NL); + } + } + setState(529); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(530); + simpleIdentifier(); + setState(538); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 33, _ctx)) { + case 1: + { + setState(534); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(531); + match(NL); + } + } + setState(536); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(537); + typeParameters(); + } + break; + } + setState(547); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 35, _ctx)) { + case 1: + { + setState(543); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(540); + match(NL); + } + } + setState(545); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(546); + primaryConstructor(); + } + break; + } + setState(563); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 38, _ctx)) { + case 1: + { + setState(552); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(549); + match(NL); + } + } + setState(554); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(555); + match(COLON); + setState(559); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 37, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(556); + match(NL); + } + } + } + setState(561); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 37, _ctx); + } + setState(562); + delegationSpecifiers(); + } + break; + } + setState(572); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 40, _ctx)) { + case 1: + { + setState(568); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(565); + match(NL); + } + } + setState(570); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(571); + typeConstraints(); + } + break; + } + setState(588); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 43, _ctx)) { + case 1: + { + setState(577); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(574); + match(NL); + } + } + setState(579); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(580); + classBody(); + } + break; + case 2: + { + setState(584); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(581); + match(NL); + } + } + setState(586); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(587); + enumClassBody(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final PrimaryConstructorContext primaryConstructor() throws RecognitionException { + PrimaryConstructorContext _localctx = new PrimaryConstructorContext(_ctx, getState()); + enterRule(_localctx, 24, RULE_primaryConstructor); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(600); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == AT_NO_WS + || _la == AT_PRE_WS + || ((((_la - 79)) & ~0x3f) == 0 + && ((1L << (_la - 79)) + & ((1L << (CONSTRUCTOR - 79)) + | (1L << (PUBLIC - 79)) + | (1L << (PRIVATE - 79)) + | (1L << (PROTECTED - 79)) + | (1L << (INTERNAL - 79)) + | (1L << (ENUM - 79)) + | (1L << (SEALED - 79)) + | (1L << (ANNOTATION - 79)) + | (1L << (DATA - 79)) + | (1L << (INNER - 79)) + | (1L << (VALUE - 79)) + | (1L << (TAILREC - 79)) + | (1L << (OPERATOR - 79)) + | (1L << (INLINE - 79)) + | (1L << (INFIX - 79)) + | (1L << (EXTERNAL - 79)) + | (1L << (SUSPEND - 79)) + | (1L << (OVERRIDE - 79)) + | (1L << (ABSTRACT - 79)) + | (1L << (FINAL - 79)) + | (1L << (OPEN - 79)) + | (1L << (CONST - 79)) + | (1L << (LATEINIT - 79)) + | (1L << (VARARG - 79)) + | (1L << (NOINLINE - 79)) + | (1L << (CROSSINLINE - 79)) + | (1L << (EXPECT - 79)) + | (1L << (ACTUAL - 79)))) + != 0)) { + { + setState(591); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == AT_NO_WS + || _la == AT_PRE_WS + || ((((_la - 107)) & ~0x3f) == 0 + && ((1L << (_la - 107)) + & ((1L << (PUBLIC - 107)) + | (1L << (PRIVATE - 107)) + | (1L << (PROTECTED - 107)) + | (1L << (INTERNAL - 107)) + | (1L << (ENUM - 107)) + | (1L << (SEALED - 107)) + | (1L << (ANNOTATION - 107)) + | (1L << (DATA - 107)) + | (1L << (INNER - 107)) + | (1L << (VALUE - 107)) + | (1L << (TAILREC - 107)) + | (1L << (OPERATOR - 107)) + | (1L << (INLINE - 107)) + | (1L << (INFIX - 107)) + | (1L << (EXTERNAL - 107)) + | (1L << (SUSPEND - 107)) + | (1L << (OVERRIDE - 107)) + | (1L << (ABSTRACT - 107)) + | (1L << (FINAL - 107)) + | (1L << (OPEN - 107)) + | (1L << (CONST - 107)) + | (1L << (LATEINIT - 107)) + | (1L << (VARARG - 107)) + | (1L << (NOINLINE - 107)) + | (1L << (CROSSINLINE - 107)) + | (1L << (EXPECT - 107)) + | (1L << (ACTUAL - 107)))) + != 0)) { + { + setState(590); + modifiers(); + } + } + + setState(593); + match(CONSTRUCTOR); + setState(597); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(594); + match(NL); + } + } + setState(599); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + + setState(602); + classParameters(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ClassBodyContext classBody() throws RecognitionException { + ClassBodyContext _localctx = new ClassBodyContext(_ctx, getState()); + enterRule(_localctx, 26, RULE_classBody); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(604); + match(LCURL); + setState(608); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 47, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(605); + match(NL); + } + } + } + setState(610); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 47, _ctx); + } + setState(611); + classMemberDeclarations(); + setState(615); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(612); + match(NL); + } + } + setState(617); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(618); + match(RCURL); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ClassParametersContext classParameters() throws RecognitionException { + ClassParametersContext _localctx = new ClassParametersContext(_ctx, getState()); + enterRule(_localctx, 28, RULE_classParameters); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(620); + match(LPAREN); + setState(624); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 49, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(621); + match(NL); + } + } + } + setState(626); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 49, _ctx); + } + setState(656); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 55, _ctx)) { + case 1: + { + setState(627); + classParameter(); + setState(644); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 52, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(631); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(628); + match(NL); + } + } + setState(633); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(634); + match(COMMA); + setState(638); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 51, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(635); + match(NL); + } + } + } + setState(640); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 51, _ctx); + } + setState(641); + classParameter(); + } + } + } + setState(646); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 52, _ctx); + } + setState(654); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 54, _ctx)) { + case 1: + { + setState(650); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(647); + match(NL); + } + } + setState(652); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(653); + match(COMMA); + } + break; + } + } + break; + } + setState(661); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(658); + match(NL); + } + } + setState(663); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(664); + match(RPAREN); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ClassParameterContext classParameter() throws RecognitionException { + ClassParameterContext _localctx = new ClassParameterContext(_ctx, getState()); + enterRule(_localctx, 30, RULE_classParameter); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(667); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 57, _ctx)) { + case 1: + { + setState(666); + modifiers(); + } + break; + } + setState(670); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == VAL || _la == VAR) { + { + setState(669); + _la = _input.LA(1); + if (!(_la == VAL || _la == VAR)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + + setState(675); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(672); + match(NL); + } + } + setState(677); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(678); + simpleIdentifier(); + setState(679); + match(COLON); + setState(683); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(680); + match(NL); + } + } + setState(685); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(686); + type(); + setState(701); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 63, _ctx)) { + case 1: + { + setState(690); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(687); + match(NL); + } + } + setState(692); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(693); + match(ASSIGNMENT); + setState(697); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(694); + match(NL); + } + } + setState(699); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(700); + expression(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final DelegationSpecifiersContext delegationSpecifiers() throws RecognitionException { + DelegationSpecifiersContext _localctx = new DelegationSpecifiersContext(_ctx, getState()); + enterRule(_localctx, 32, RULE_delegationSpecifiers); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(703); + annotatedDelegationSpecifier(); + setState(720); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 66, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(707); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(704); + match(NL); + } + } + setState(709); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(710); + match(COMMA); + setState(714); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 65, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(711); + match(NL); + } + } + } + setState(716); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 65, _ctx); + } + setState(717); + annotatedDelegationSpecifier(); + } + } + } + setState(722); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 66, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final DelegationSpecifierContext delegationSpecifier() throws RecognitionException { + DelegationSpecifierContext _localctx = new DelegationSpecifierContext(_ctx, getState()); + enterRule(_localctx, 34, RULE_delegationSpecifier); + try { + setState(727); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 67, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(723); + constructorInvocation(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(724); + explicitDelegation(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(725); + userType(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(726); + functionType(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ConstructorInvocationContext constructorInvocation() throws RecognitionException { + ConstructorInvocationContext _localctx = new ConstructorInvocationContext(_ctx, getState()); + enterRule(_localctx, 36, RULE_constructorInvocation); + try { + enterOuterAlt(_localctx, 1); + { + setState(729); + userType(); + setState(730); + valueArguments(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final AnnotatedDelegationSpecifierContext annotatedDelegationSpecifier() + throws RecognitionException { + AnnotatedDelegationSpecifierContext _localctx = + new AnnotatedDelegationSpecifierContext(_ctx, getState()); + enterRule(_localctx, 38, RULE_annotatedDelegationSpecifier); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(735); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 68, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(732); + annotation(); + } + } + } + setState(737); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 68, _ctx); + } + setState(741); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(738); + match(NL); + } + } + setState(743); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(744); + delegationSpecifier(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ExplicitDelegationContext explicitDelegation() throws RecognitionException { + ExplicitDelegationContext _localctx = new ExplicitDelegationContext(_ctx, getState()); + enterRule(_localctx, 40, RULE_explicitDelegation); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(748); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 70, _ctx)) { + case 1: + { + setState(746); + userType(); + } + break; + case 2: + { + setState(747); + functionType(); + } + break; + } + setState(753); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(750); + match(NL); + } + } + setState(755); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(756); + match(BY); + setState(760); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(757); + match(NL); + } + } + setState(762); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(763); + expression(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final TypeParametersContext typeParameters() throws RecognitionException { + TypeParametersContext _localctx = new TypeParametersContext(_ctx, getState()); + enterRule(_localctx, 42, RULE_typeParameters); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(765); + match(LANGLE); + setState(769); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 73, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(766); + match(NL); + } + } + } + setState(771); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 73, _ctx); + } + setState(772); + typeParameter(); + setState(789); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 76, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(776); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(773); + match(NL); + } + } + setState(778); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(779); + match(COMMA); + setState(783); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 75, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(780); + match(NL); + } + } + } + setState(785); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 75, _ctx); + } + setState(786); + typeParameter(); + } + } + } + setState(791); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 76, _ctx); + } + setState(799); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 78, _ctx)) { + case 1: + { + setState(795); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(792); + match(NL); + } + } + setState(797); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(798); + match(COMMA); + } + break; + } + setState(804); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(801); + match(NL); + } + } + setState(806); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(807); + match(RANGLE); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final TypeParameterContext typeParameter() throws RecognitionException { + TypeParameterContext _localctx = new TypeParameterContext(_ctx, getState()); + enterRule(_localctx, 44, RULE_typeParameter); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(810); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 80, _ctx)) { + case 1: + { + setState(809); + typeParameterModifiers(); + } + break; + } + setState(815); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(812); + match(NL); + } + } + setState(817); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(818); + simpleIdentifier(); + setState(833); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 84, _ctx)) { + case 1: + { + setState(822); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(819); + match(NL); + } + } + setState(824); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(825); + match(COLON); + setState(829); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(826); + match(NL); + } + } + setState(831); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(832); + type(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final TypeConstraintsContext typeConstraints() throws RecognitionException { + TypeConstraintsContext _localctx = new TypeConstraintsContext(_ctx, getState()); + enterRule(_localctx, 46, RULE_typeConstraints); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(835); + match(WHERE); + setState(839); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(836); + match(NL); + } + } + setState(841); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(842); + typeConstraint(); + setState(859); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 88, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(846); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(843); + match(NL); + } + } + setState(848); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(849); + match(COMMA); + setState(853); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(850); + match(NL); + } + } + setState(855); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(856); + typeConstraint(); + } + } + } + setState(861); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 88, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final TypeConstraintContext typeConstraint() throws RecognitionException { + TypeConstraintContext _localctx = new TypeConstraintContext(_ctx, getState()); + enterRule(_localctx, 48, RULE_typeConstraint); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(865); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == AT_NO_WS || _la == AT_PRE_WS) { + { + { + setState(862); + annotation(); + } + } + setState(867); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(868); + simpleIdentifier(); + setState(872); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(869); + match(NL); + } + } + setState(874); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(875); + match(COLON); + setState(879); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(876); + match(NL); + } + } + setState(881); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(882); + type(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ClassMemberDeclarationsContext classMemberDeclarations() + throws RecognitionException { + ClassMemberDeclarationsContext _localctx = new ClassMemberDeclarationsContext(_ctx, getState()); + enterRule(_localctx, 50, RULE_classMemberDeclarations); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(890); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == AT_NO_WS + || _la == AT_PRE_WS + || ((((_la - 72)) & ~0x3f) == 0 + && ((1L << (_la - 72)) + & ((1L << (CLASS - 72)) + | (1L << (INTERFACE - 72)) + | (1L << (FUN - 72)) + | (1L << (OBJECT - 72)) + | (1L << (VAL - 72)) + | (1L << (VAR - 72)) + | (1L << (TYPE_ALIAS - 72)) + | (1L << (CONSTRUCTOR - 72)) + | (1L << (COMPANION - 72)) + | (1L << (INIT - 72)) + | (1L << (PUBLIC - 72)) + | (1L << (PRIVATE - 72)) + | (1L << (PROTECTED - 72)) + | (1L << (INTERNAL - 72)) + | (1L << (ENUM - 72)) + | (1L << (SEALED - 72)) + | (1L << (ANNOTATION - 72)) + | (1L << (DATA - 72)) + | (1L << (INNER - 72)) + | (1L << (VALUE - 72)) + | (1L << (TAILREC - 72)) + | (1L << (OPERATOR - 72)) + | (1L << (INLINE - 72)) + | (1L << (INFIX - 72)) + | (1L << (EXTERNAL - 72)) + | (1L << (SUSPEND - 72)) + | (1L << (OVERRIDE - 72)) + | (1L << (ABSTRACT - 72)) + | (1L << (FINAL - 72)) + | (1L << (OPEN - 72)) + | (1L << (CONST - 72)) + | (1L << (LATEINIT - 72)) + | (1L << (VARARG - 72)) + | (1L << (NOINLINE - 72)) + | (1L << (CROSSINLINE - 72)) + | (1L << (EXPECT - 72)) + | (1L << (ACTUAL - 72)))) + != 0)) { + { + { + setState(884); + classMemberDeclaration(); + setState(886); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 92, _ctx)) { + case 1: + { + setState(885); + semis(); + } + break; + } + } + } + setState(892); + _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 final ClassMemberDeclarationContext classMemberDeclaration() throws RecognitionException { + ClassMemberDeclarationContext _localctx = new ClassMemberDeclarationContext(_ctx, getState()); + enterRule(_localctx, 52, RULE_classMemberDeclaration); + try { + setState(897); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 94, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(893); + declaration(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(894); + companionObject(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(895); + anonymousInitializer(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(896); + secondaryConstructor(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final AnonymousInitializerContext anonymousInitializer() throws RecognitionException { + AnonymousInitializerContext _localctx = new AnonymousInitializerContext(_ctx, getState()); + enterRule(_localctx, 54, RULE_anonymousInitializer); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(899); + match(INIT); + setState(903); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(900); + match(NL); + } + } + setState(905); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(906); + block(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final CompanionObjectContext companionObject() throws RecognitionException { + CompanionObjectContext _localctx = new CompanionObjectContext(_ctx, getState()); + enterRule(_localctx, 56, RULE_companionObject); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(909); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == AT_NO_WS + || _la == AT_PRE_WS + || ((((_la - 107)) & ~0x3f) == 0 + && ((1L << (_la - 107)) + & ((1L << (PUBLIC - 107)) + | (1L << (PRIVATE - 107)) + | (1L << (PROTECTED - 107)) + | (1L << (INTERNAL - 107)) + | (1L << (ENUM - 107)) + | (1L << (SEALED - 107)) + | (1L << (ANNOTATION - 107)) + | (1L << (DATA - 107)) + | (1L << (INNER - 107)) + | (1L << (VALUE - 107)) + | (1L << (TAILREC - 107)) + | (1L << (OPERATOR - 107)) + | (1L << (INLINE - 107)) + | (1L << (INFIX - 107)) + | (1L << (EXTERNAL - 107)) + | (1L << (SUSPEND - 107)) + | (1L << (OVERRIDE - 107)) + | (1L << (ABSTRACT - 107)) + | (1L << (FINAL - 107)) + | (1L << (OPEN - 107)) + | (1L << (CONST - 107)) + | (1L << (LATEINIT - 107)) + | (1L << (VARARG - 107)) + | (1L << (NOINLINE - 107)) + | (1L << (CROSSINLINE - 107)) + | (1L << (EXPECT - 107)) + | (1L << (ACTUAL - 107)))) + != 0)) { + { + setState(908); + modifiers(); + } + } + + setState(911); + match(COMPANION); + setState(915); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(912); + match(NL); + } + } + setState(917); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(918); + match(OBJECT); + setState(926); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 99, _ctx)) { + case 1: + { + setState(922); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(919); + match(NL); + } + } + setState(924); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(925); + simpleIdentifier(); + } + break; + } + setState(942); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 102, _ctx)) { + case 1: + { + setState(931); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(928); + match(NL); + } + } + setState(933); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(934); + match(COLON); + setState(938); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 101, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(935); + match(NL); + } + } + } + setState(940); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 101, _ctx); + } + setState(941); + delegationSpecifiers(); + } + break; + } + setState(951); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 104, _ctx)) { + case 1: + { + setState(947); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(944); + match(NL); + } + } + setState(949); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(950); + classBody(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final FunctionValueParametersContext functionValueParameters() + throws RecognitionException { + FunctionValueParametersContext _localctx = new FunctionValueParametersContext(_ctx, getState()); + enterRule(_localctx, 58, RULE_functionValueParameters); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(953); + match(LPAREN); + setState(957); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 105, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(954); + match(NL); + } + } + } + setState(959); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 105, _ctx); + } + setState(989); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 40)) & ~0x3f) == 0 + && ((1L << (_la - 40)) + & ((1L << (AT_NO_WS - 40)) + | (1L << (AT_PRE_WS - 40)) + | (1L << (FILE - 40)) + | (1L << (FIELD - 40)) + | (1L << (PROPERTY - 40)) + | (1L << (GET - 40)) + | (1L << (SET - 40)) + | (1L << (RECEIVER - 40)) + | (1L << (PARAM - 40)) + | (1L << (SETPARAM - 40)) + | (1L << (DELEGATE - 40)) + | (1L << (IMPORT - 40)) + | (1L << (CONSTRUCTOR - 40)) + | (1L << (BY - 40)) + | (1L << (COMPANION - 40)) + | (1L << (INIT - 40)) + | (1L << (WHERE - 40)) + | (1L << (CATCH - 40)) + | (1L << (FINALLY - 40)))) + != 0) + || ((((_la - 105)) & ~0x3f) == 0 + && ((1L << (_la - 105)) + & ((1L << (OUT - 105)) + | (1L << (DYNAMIC - 105)) + | (1L << (PUBLIC - 105)) + | (1L << (PRIVATE - 105)) + | (1L << (PROTECTED - 105)) + | (1L << (INTERNAL - 105)) + | (1L << (ENUM - 105)) + | (1L << (SEALED - 105)) + | (1L << (ANNOTATION - 105)) + | (1L << (DATA - 105)) + | (1L << (INNER - 105)) + | (1L << (VALUE - 105)) + | (1L << (TAILREC - 105)) + | (1L << (OPERATOR - 105)) + | (1L << (INLINE - 105)) + | (1L << (INFIX - 105)) + | (1L << (EXTERNAL - 105)) + | (1L << (SUSPEND - 105)) + | (1L << (OVERRIDE - 105)) + | (1L << (ABSTRACT - 105)) + | (1L << (FINAL - 105)) + | (1L << (OPEN - 105)) + | (1L << (CONST - 105)) + | (1L << (LATEINIT - 105)) + | (1L << (VARARG - 105)) + | (1L << (NOINLINE - 105)) + | (1L << (CROSSINLINE - 105)) + | (1L << (REIFIED - 105)) + | (1L << (EXPECT - 105)) + | (1L << (ACTUAL - 105)) + | (1L << (Identifier - 105)))) + != 0)) { + { + setState(960); + functionValueParameter(); + setState(977); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 108, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(964); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(961); + match(NL); + } + } + setState(966); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(967); + match(COMMA); + setState(971); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(968); + match(NL); + } + } + setState(973); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(974); + functionValueParameter(); + } + } + } + setState(979); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 108, _ctx); + } + setState(987); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 110, _ctx)) { + case 1: + { + setState(983); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(980); + match(NL); + } + } + setState(985); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(986); + match(COMMA); + } + break; + } + } + } + + setState(994); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(991); + match(NL); + } + } + setState(996); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(997); + match(RPAREN); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final FunctionValueParameterContext functionValueParameter() throws RecognitionException { + FunctionValueParameterContext _localctx = new FunctionValueParameterContext(_ctx, getState()); + enterRule(_localctx, 60, RULE_functionValueParameter); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1000); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 113, _ctx)) { + case 1: + { + setState(999); + parameterModifiers(); + } + break; + } + setState(1002); + parameter(); + setState(1017); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 116, _ctx)) { + case 1: + { + setState(1006); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1003); + match(NL); + } + } + setState(1008); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1009); + match(ASSIGNMENT); + setState(1013); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1010); + match(NL); + } + } + setState(1015); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1016); + expression(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final FunctionDeclarationContext functionDeclaration() throws RecognitionException { + FunctionDeclarationContext _localctx = new FunctionDeclarationContext(_ctx, getState()); + enterRule(_localctx, 62, RULE_functionDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1020); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == AT_NO_WS + || _la == AT_PRE_WS + || ((((_la - 107)) & ~0x3f) == 0 + && ((1L << (_la - 107)) + & ((1L << (PUBLIC - 107)) + | (1L << (PRIVATE - 107)) + | (1L << (PROTECTED - 107)) + | (1L << (INTERNAL - 107)) + | (1L << (ENUM - 107)) + | (1L << (SEALED - 107)) + | (1L << (ANNOTATION - 107)) + | (1L << (DATA - 107)) + | (1L << (INNER - 107)) + | (1L << (VALUE - 107)) + | (1L << (TAILREC - 107)) + | (1L << (OPERATOR - 107)) + | (1L << (INLINE - 107)) + | (1L << (INFIX - 107)) + | (1L << (EXTERNAL - 107)) + | (1L << (SUSPEND - 107)) + | (1L << (OVERRIDE - 107)) + | (1L << (ABSTRACT - 107)) + | (1L << (FINAL - 107)) + | (1L << (OPEN - 107)) + | (1L << (CONST - 107)) + | (1L << (LATEINIT - 107)) + | (1L << (VARARG - 107)) + | (1L << (NOINLINE - 107)) + | (1L << (CROSSINLINE - 107)) + | (1L << (EXPECT - 107)) + | (1L << (ACTUAL - 107)))) + != 0)) { + { + setState(1019); + modifiers(); + } + } + + setState(1022); + match(FUN); + setState(1030); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 119, _ctx)) { + case 1: + { + setState(1026); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1023); + match(NL); + } + } + setState(1028); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1029); + typeParameters(); + } + break; + } + setState(1047); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 122, _ctx)) { + case 1: + { + setState(1035); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1032); + match(NL); + } + } + setState(1037); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1038); + receiverType(); + setState(1042); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1039); + match(NL); + } + } + setState(1044); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1045); + match(DOT); + } + break; + } + setState(1052); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1049); + match(NL); + } + } + setState(1054); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1055); + simpleIdentifier(); + setState(1059); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1056); + match(NL); + } + } + setState(1061); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1062); + functionValueParameters(); + setState(1077); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 127, _ctx)) { + case 1: + { + setState(1066); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1063); + match(NL); + } + } + setState(1068); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1069); + match(COLON); + setState(1073); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1070); + match(NL); + } + } + setState(1075); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1076); + type(); + } + break; + } + setState(1086); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 129, _ctx)) { + case 1: + { + setState(1082); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1079); + match(NL); + } + } + setState(1084); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1085); + typeConstraints(); + } + break; + } + setState(1095); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 131, _ctx)) { + case 1: + { + setState(1091); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1088); + match(NL); + } + } + setState(1093); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1094); + functionBody(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final FunctionBodyContext functionBody() throws RecognitionException { + FunctionBodyContext _localctx = new FunctionBodyContext(_ctx, getState()); + enterRule(_localctx, 64, RULE_functionBody); + int _la; + try { + setState(1106); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LCURL: + enterOuterAlt(_localctx, 1); + { + setState(1097); + block(); + } + break; + case ASSIGNMENT: + enterOuterAlt(_localctx, 2); + { + setState(1098); + match(ASSIGNMENT); + setState(1102); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1099); + match(NL); + } + } + setState(1104); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1105); + expression(); + } + 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 final VariableDeclarationContext variableDeclaration() throws RecognitionException { + VariableDeclarationContext _localctx = new VariableDeclarationContext(_ctx, getState()); + enterRule(_localctx, 66, RULE_variableDeclaration); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1111); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == AT_NO_WS || _la == AT_PRE_WS) { + { + { + setState(1108); + annotation(); + } + } + setState(1113); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1117); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1114); + match(NL); + } + } + setState(1119); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1120); + simpleIdentifier(); + setState(1135); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 138, _ctx)) { + case 1: + { + setState(1124); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1121); + match(NL); + } + } + setState(1126); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1127); + match(COLON); + setState(1131); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1128); + match(NL); + } + } + setState(1133); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1134); + type(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final MultiVariableDeclarationContext multiVariableDeclaration() + throws RecognitionException { + MultiVariableDeclarationContext _localctx = + new MultiVariableDeclarationContext(_ctx, getState()); + enterRule(_localctx, 68, RULE_multiVariableDeclaration); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1137); + match(LPAREN); + setState(1141); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 139, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1138); + match(NL); + } + } + } + setState(1143); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 139, _ctx); + } + setState(1144); + variableDeclaration(); + setState(1161); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 142, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1148); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1145); + match(NL); + } + } + setState(1150); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1151); + match(COMMA); + setState(1155); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 141, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1152); + match(NL); + } + } + } + setState(1157); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 141, _ctx); + } + setState(1158); + variableDeclaration(); + } + } + } + setState(1163); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 142, _ctx); + } + setState(1171); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 144, _ctx)) { + case 1: + { + setState(1167); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1164); + match(NL); + } + } + setState(1169); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1170); + match(COMMA); + } + break; + } + setState(1176); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1173); + match(NL); + } + } + setState(1178); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1179); + match(RPAREN); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final PropertyDeclarationContext propertyDeclaration() throws RecognitionException { + PropertyDeclarationContext _localctx = new PropertyDeclarationContext(_ctx, getState()); + enterRule(_localctx, 70, RULE_propertyDeclaration); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1182); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == AT_NO_WS + || _la == AT_PRE_WS + || ((((_la - 107)) & ~0x3f) == 0 + && ((1L << (_la - 107)) + & ((1L << (PUBLIC - 107)) + | (1L << (PRIVATE - 107)) + | (1L << (PROTECTED - 107)) + | (1L << (INTERNAL - 107)) + | (1L << (ENUM - 107)) + | (1L << (SEALED - 107)) + | (1L << (ANNOTATION - 107)) + | (1L << (DATA - 107)) + | (1L << (INNER - 107)) + | (1L << (VALUE - 107)) + | (1L << (TAILREC - 107)) + | (1L << (OPERATOR - 107)) + | (1L << (INLINE - 107)) + | (1L << (INFIX - 107)) + | (1L << (EXTERNAL - 107)) + | (1L << (SUSPEND - 107)) + | (1L << (OVERRIDE - 107)) + | (1L << (ABSTRACT - 107)) + | (1L << (FINAL - 107)) + | (1L << (OPEN - 107)) + | (1L << (CONST - 107)) + | (1L << (LATEINIT - 107)) + | (1L << (VARARG - 107)) + | (1L << (NOINLINE - 107)) + | (1L << (CROSSINLINE - 107)) + | (1L << (EXPECT - 107)) + | (1L << (ACTUAL - 107)))) + != 0)) { + { + setState(1181); + modifiers(); + } + } + + setState(1184); + _la = _input.LA(1); + if (!(_la == VAL || _la == VAR)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1192); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 148, _ctx)) { + case 1: + { + setState(1188); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1185); + match(NL); + } + } + setState(1190); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1191); + typeParameters(); + } + break; + } + setState(1209); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 151, _ctx)) { + case 1: + { + setState(1197); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1194); + match(NL); + } + } + setState(1199); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1200); + receiverType(); + setState(1204); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1201); + match(NL); + } + } + setState(1206); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1207); + match(DOT); + } + break; + } + { + setState(1214); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 152, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1211); + match(NL); + } + } + } + setState(1216); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 152, _ctx); + } + setState(1219); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LPAREN: + { + setState(1217); + multiVariableDeclaration(); + } + break; + case NL: + case AT_NO_WS: + case AT_PRE_WS: + case FILE: + case FIELD: + case PROPERTY: + case GET: + case SET: + case RECEIVER: + case PARAM: + case SETPARAM: + case DELEGATE: + case IMPORT: + case CONSTRUCTOR: + case BY: + case COMPANION: + case INIT: + case WHERE: + case CATCH: + case FINALLY: + case OUT: + case DYNAMIC: + case PUBLIC: + case PRIVATE: + case PROTECTED: + case INTERNAL: + case ENUM: + case SEALED: + case ANNOTATION: + case DATA: + case INNER: + case VALUE: + case TAILREC: + case OPERATOR: + case INLINE: + case INFIX: + case EXTERNAL: + case SUSPEND: + case OVERRIDE: + case ABSTRACT: + case FINAL: + case OPEN: + case CONST: + case LATEINIT: + case VARARG: + case NOINLINE: + case CROSSINLINE: + case REIFIED: + case EXPECT: + case ACTUAL: + case Identifier: + { + setState(1218); + variableDeclaration(); + } + break; + default: + throw new NoViableAltException(this); + } + } + setState(1228); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 155, _ctx)) { + case 1: + { + setState(1224); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1221); + match(NL); + } + } + setState(1226); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1227); + typeConstraints(); + } + break; + } + setState(1247); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 159, _ctx)) { + case 1: + { + setState(1233); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1230); + match(NL); + } + } + setState(1235); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1245); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ASSIGNMENT: + { + setState(1236); + match(ASSIGNMENT); + setState(1240); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1237); + match(NL); + } + } + setState(1242); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1243); + expression(); + } + break; + case BY: + { + setState(1244); + propertyDelegate(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + } + setState(1255); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 161, _ctx)) { + case 1: + { + setState(1250); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(1249); + match(NL); + } + } + setState(1252); + _errHandler.sync(this); + _la = _input.LA(1); + } while (_la == NL); + setState(1254); + match(SEMICOLON); + } + break; + } + setState(1260); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 162, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1257); + match(NL); + } + } + } + setState(1262); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 162, _ctx); + } + setState(1293); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 171, _ctx)) { + case 1: + { + setState(1264); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 163, _ctx)) { + case 1: + { + setState(1263); + getter(); + } + break; + } + setState(1276); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 166, _ctx)) { + case 1: + { + setState(1269); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 164, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1266); + match(NL); + } + } + } + setState(1271); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 164, _ctx); + } + setState(1273); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - -1)) & ~0x3f) == 0 + && ((1L << (_la - -1)) + & ((1L << (EOF - -1)) + | (1L << (NL - -1)) + | (1L << (SEMICOLON - -1)))) + != 0)) { + { + setState(1272); + semi(); + } + } + + setState(1275); + setter(); + } + break; + } + } + break; + case 2: + { + setState(1279); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 167, _ctx)) { + case 1: + { + setState(1278); + setter(); + } + break; + } + setState(1291); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 170, _ctx)) { + case 1: + { + setState(1284); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 168, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1281); + match(NL); + } + } + } + setState(1286); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 168, _ctx); + } + setState(1288); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - -1)) & ~0x3f) == 0 + && ((1L << (_la - -1)) + & ((1L << (EOF - -1)) + | (1L << (NL - -1)) + | (1L << (SEMICOLON - -1)))) + != 0)) { + { + setState(1287); + semi(); + } + } + + setState(1290); + getter(); + } + break; + } + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final PropertyDelegateContext propertyDelegate() throws RecognitionException { + PropertyDelegateContext _localctx = new PropertyDelegateContext(_ctx, getState()); + enterRule(_localctx, 72, RULE_propertyDelegate); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1295); + match(BY); + setState(1299); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1296); + match(NL); + } + } + setState(1301); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1302); + expression(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final GetterContext getter() throws RecognitionException { + GetterContext _localctx = new GetterContext(_ctx, getState()); + enterRule(_localctx, 74, RULE_getter); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1305); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == AT_NO_WS + || _la == AT_PRE_WS + || ((((_la - 107)) & ~0x3f) == 0 + && ((1L << (_la - 107)) + & ((1L << (PUBLIC - 107)) + | (1L << (PRIVATE - 107)) + | (1L << (PROTECTED - 107)) + | (1L << (INTERNAL - 107)) + | (1L << (ENUM - 107)) + | (1L << (SEALED - 107)) + | (1L << (ANNOTATION - 107)) + | (1L << (DATA - 107)) + | (1L << (INNER - 107)) + | (1L << (VALUE - 107)) + | (1L << (TAILREC - 107)) + | (1L << (OPERATOR - 107)) + | (1L << (INLINE - 107)) + | (1L << (INFIX - 107)) + | (1L << (EXTERNAL - 107)) + | (1L << (SUSPEND - 107)) + | (1L << (OVERRIDE - 107)) + | (1L << (ABSTRACT - 107)) + | (1L << (FINAL - 107)) + | (1L << (OPEN - 107)) + | (1L << (CONST - 107)) + | (1L << (LATEINIT - 107)) + | (1L << (VARARG - 107)) + | (1L << (NOINLINE - 107)) + | (1L << (CROSSINLINE - 107)) + | (1L << (EXPECT - 107)) + | (1L << (ACTUAL - 107)))) + != 0)) { + { + setState(1304); + modifiers(); + } + } + + setState(1307); + match(GET); + setState(1345); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 180, _ctx)) { + case 1: + { + setState(1311); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1308); + match(NL); + } + } + setState(1313); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1314); + match(LPAREN); + setState(1318); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1315); + match(NL); + } + } + setState(1320); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1321); + match(RPAREN); + setState(1336); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 178, _ctx)) { + case 1: + { + setState(1325); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1322); + match(NL); + } + } + setState(1327); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1328); + match(COLON); + setState(1332); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1329); + match(NL); + } + } + setState(1334); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1335); + type(); + } + break; + } + setState(1341); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1338); + match(NL); + } + } + setState(1343); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1344); + functionBody(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final SetterContext setter() throws RecognitionException { + SetterContext _localctx = new SetterContext(_ctx, getState()); + enterRule(_localctx, 76, RULE_setter); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1348); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == AT_NO_WS + || _la == AT_PRE_WS + || ((((_la - 107)) & ~0x3f) == 0 + && ((1L << (_la - 107)) + & ((1L << (PUBLIC - 107)) + | (1L << (PRIVATE - 107)) + | (1L << (PROTECTED - 107)) + | (1L << (INTERNAL - 107)) + | (1L << (ENUM - 107)) + | (1L << (SEALED - 107)) + | (1L << (ANNOTATION - 107)) + | (1L << (DATA - 107)) + | (1L << (INNER - 107)) + | (1L << (VALUE - 107)) + | (1L << (TAILREC - 107)) + | (1L << (OPERATOR - 107)) + | (1L << (INLINE - 107)) + | (1L << (INFIX - 107)) + | (1L << (EXTERNAL - 107)) + | (1L << (SUSPEND - 107)) + | (1L << (OVERRIDE - 107)) + | (1L << (ABSTRACT - 107)) + | (1L << (FINAL - 107)) + | (1L << (OPEN - 107)) + | (1L << (CONST - 107)) + | (1L << (LATEINIT - 107)) + | (1L << (VARARG - 107)) + | (1L << (NOINLINE - 107)) + | (1L << (CROSSINLINE - 107)) + | (1L << (EXPECT - 107)) + | (1L << (ACTUAL - 107)))) + != 0)) { + { + setState(1347); + modifiers(); + } + } + + setState(1350); + match(SET); + setState(1405); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 191, _ctx)) { + case 1: + { + setState(1354); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1351); + match(NL); + } + } + setState(1356); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1357); + match(LPAREN); + setState(1361); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1358); + match(NL); + } + } + setState(1363); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1364); + functionValueParameterWithOptionalType(); + setState(1372); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 185, _ctx)) { + case 1: + { + setState(1368); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1365); + match(NL); + } + } + setState(1370); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1371); + match(COMMA); + } + break; + } + setState(1377); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1374); + match(NL); + } + } + setState(1379); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1380); + match(RPAREN); + setState(1395); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 189, _ctx)) { + case 1: + { + setState(1384); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1381); + match(NL); + } + } + setState(1386); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1387); + match(COLON); + setState(1391); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1388); + match(NL); + } + } + setState(1393); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1394); + type(); + } + break; + } + setState(1400); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1397); + match(NL); + } + } + setState(1402); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1403); + functionBody(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ParametersWithOptionalTypeContext parametersWithOptionalType() + throws RecognitionException { + ParametersWithOptionalTypeContext _localctx = + new ParametersWithOptionalTypeContext(_ctx, getState()); + enterRule(_localctx, 78, RULE_parametersWithOptionalType); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1407); + match(LPAREN); + setState(1411); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 192, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1408); + match(NL); + } + } + } + setState(1413); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 192, _ctx); + } + setState(1443); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 40)) & ~0x3f) == 0 + && ((1L << (_la - 40)) + & ((1L << (AT_NO_WS - 40)) + | (1L << (AT_PRE_WS - 40)) + | (1L << (FILE - 40)) + | (1L << (FIELD - 40)) + | (1L << (PROPERTY - 40)) + | (1L << (GET - 40)) + | (1L << (SET - 40)) + | (1L << (RECEIVER - 40)) + | (1L << (PARAM - 40)) + | (1L << (SETPARAM - 40)) + | (1L << (DELEGATE - 40)) + | (1L << (IMPORT - 40)) + | (1L << (CONSTRUCTOR - 40)) + | (1L << (BY - 40)) + | (1L << (COMPANION - 40)) + | (1L << (INIT - 40)) + | (1L << (WHERE - 40)) + | (1L << (CATCH - 40)) + | (1L << (FINALLY - 40)))) + != 0) + || ((((_la - 105)) & ~0x3f) == 0 + && ((1L << (_la - 105)) + & ((1L << (OUT - 105)) + | (1L << (DYNAMIC - 105)) + | (1L << (PUBLIC - 105)) + | (1L << (PRIVATE - 105)) + | (1L << (PROTECTED - 105)) + | (1L << (INTERNAL - 105)) + | (1L << (ENUM - 105)) + | (1L << (SEALED - 105)) + | (1L << (ANNOTATION - 105)) + | (1L << (DATA - 105)) + | (1L << (INNER - 105)) + | (1L << (VALUE - 105)) + | (1L << (TAILREC - 105)) + | (1L << (OPERATOR - 105)) + | (1L << (INLINE - 105)) + | (1L << (INFIX - 105)) + | (1L << (EXTERNAL - 105)) + | (1L << (SUSPEND - 105)) + | (1L << (OVERRIDE - 105)) + | (1L << (ABSTRACT - 105)) + | (1L << (FINAL - 105)) + | (1L << (OPEN - 105)) + | (1L << (CONST - 105)) + | (1L << (LATEINIT - 105)) + | (1L << (VARARG - 105)) + | (1L << (NOINLINE - 105)) + | (1L << (CROSSINLINE - 105)) + | (1L << (REIFIED - 105)) + | (1L << (EXPECT - 105)) + | (1L << (ACTUAL - 105)) + | (1L << (Identifier - 105)))) + != 0)) { + { + setState(1414); + functionValueParameterWithOptionalType(); + setState(1431); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 195, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1418); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1415); + match(NL); + } + } + setState(1420); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1421); + match(COMMA); + setState(1425); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1422); + match(NL); + } + } + setState(1427); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1428); + functionValueParameterWithOptionalType(); + } + } + } + setState(1433); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 195, _ctx); + } + setState(1441); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 197, _ctx)) { + case 1: + { + setState(1437); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1434); + match(NL); + } + } + setState(1439); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1440); + match(COMMA); + } + break; + } + } + } + + setState(1448); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1445); + match(NL); + } + } + setState(1450); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1451); + match(RPAREN); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final FunctionValueParameterWithOptionalTypeContext + functionValueParameterWithOptionalType() throws RecognitionException { + FunctionValueParameterWithOptionalTypeContext _localctx = + new FunctionValueParameterWithOptionalTypeContext(_ctx, getState()); + enterRule(_localctx, 80, RULE_functionValueParameterWithOptionalType); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1454); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 200, _ctx)) { + case 1: + { + setState(1453); + parameterModifiers(); + } + break; + } + setState(1456); + parameterWithOptionalType(); + setState(1471); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 203, _ctx)) { + case 1: + { + setState(1460); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1457); + match(NL); + } + } + setState(1462); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1463); + match(ASSIGNMENT); + setState(1467); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1464); + match(NL); + } + } + setState(1469); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1470); + expression(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ParameterWithOptionalTypeContext parameterWithOptionalType() + throws RecognitionException { + ParameterWithOptionalTypeContext _localctx = + new ParameterWithOptionalTypeContext(_ctx, getState()); + enterRule(_localctx, 82, RULE_parameterWithOptionalType); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1473); + simpleIdentifier(); + setState(1477); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 204, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1474); + match(NL); + } + } + } + setState(1479); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 204, _ctx); + } + setState(1488); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COLON) { + { + setState(1480); + match(COLON); + setState(1484); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1481); + match(NL); + } + } + setState(1486); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1487); + type(); + } + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ParameterContext parameter() throws RecognitionException { + ParameterContext _localctx = new ParameterContext(_ctx, getState()); + enterRule(_localctx, 84, RULE_parameter); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1490); + simpleIdentifier(); + setState(1494); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1491); + match(NL); + } + } + setState(1496); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1497); + match(COLON); + setState(1501); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1498); + match(NL); + } + } + setState(1503); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1504); + type(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ObjectDeclarationContext objectDeclaration() throws RecognitionException { + ObjectDeclarationContext _localctx = new ObjectDeclarationContext(_ctx, getState()); + enterRule(_localctx, 86, RULE_objectDeclaration); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1507); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == AT_NO_WS + || _la == AT_PRE_WS + || ((((_la - 107)) & ~0x3f) == 0 + && ((1L << (_la - 107)) + & ((1L << (PUBLIC - 107)) + | (1L << (PRIVATE - 107)) + | (1L << (PROTECTED - 107)) + | (1L << (INTERNAL - 107)) + | (1L << (ENUM - 107)) + | (1L << (SEALED - 107)) + | (1L << (ANNOTATION - 107)) + | (1L << (DATA - 107)) + | (1L << (INNER - 107)) + | (1L << (VALUE - 107)) + | (1L << (TAILREC - 107)) + | (1L << (OPERATOR - 107)) + | (1L << (INLINE - 107)) + | (1L << (INFIX - 107)) + | (1L << (EXTERNAL - 107)) + | (1L << (SUSPEND - 107)) + | (1L << (OVERRIDE - 107)) + | (1L << (ABSTRACT - 107)) + | (1L << (FINAL - 107)) + | (1L << (OPEN - 107)) + | (1L << (CONST - 107)) + | (1L << (LATEINIT - 107)) + | (1L << (VARARG - 107)) + | (1L << (NOINLINE - 107)) + | (1L << (CROSSINLINE - 107)) + | (1L << (EXPECT - 107)) + | (1L << (ACTUAL - 107)))) + != 0)) { + { + setState(1506); + modifiers(); + } + } + + setState(1509); + match(OBJECT); + setState(1513); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1510); + match(NL); + } + } + setState(1515); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1516); + simpleIdentifier(); + setState(1531); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 213, _ctx)) { + case 1: + { + setState(1520); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1517); + match(NL); + } + } + setState(1522); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1523); + match(COLON); + setState(1527); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 212, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1524); + match(NL); + } + } + } + setState(1529); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 212, _ctx); + } + setState(1530); + delegationSpecifiers(); + } + break; + } + setState(1540); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 215, _ctx)) { + case 1: + { + setState(1536); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1533); + match(NL); + } + } + setState(1538); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1539); + classBody(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final SecondaryConstructorContext secondaryConstructor() throws RecognitionException { + SecondaryConstructorContext _localctx = new SecondaryConstructorContext(_ctx, getState()); + enterRule(_localctx, 88, RULE_secondaryConstructor); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1543); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == AT_NO_WS + || _la == AT_PRE_WS + || ((((_la - 107)) & ~0x3f) == 0 + && ((1L << (_la - 107)) + & ((1L << (PUBLIC - 107)) + | (1L << (PRIVATE - 107)) + | (1L << (PROTECTED - 107)) + | (1L << (INTERNAL - 107)) + | (1L << (ENUM - 107)) + | (1L << (SEALED - 107)) + | (1L << (ANNOTATION - 107)) + | (1L << (DATA - 107)) + | (1L << (INNER - 107)) + | (1L << (VALUE - 107)) + | (1L << (TAILREC - 107)) + | (1L << (OPERATOR - 107)) + | (1L << (INLINE - 107)) + | (1L << (INFIX - 107)) + | (1L << (EXTERNAL - 107)) + | (1L << (SUSPEND - 107)) + | (1L << (OVERRIDE - 107)) + | (1L << (ABSTRACT - 107)) + | (1L << (FINAL - 107)) + | (1L << (OPEN - 107)) + | (1L << (CONST - 107)) + | (1L << (LATEINIT - 107)) + | (1L << (VARARG - 107)) + | (1L << (NOINLINE - 107)) + | (1L << (CROSSINLINE - 107)) + | (1L << (EXPECT - 107)) + | (1L << (ACTUAL - 107)))) + != 0)) { + { + setState(1542); + modifiers(); + } + } + + setState(1545); + match(CONSTRUCTOR); + setState(1549); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1546); + match(NL); + } + } + setState(1551); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1552); + functionValueParameters(); + setState(1567); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 220, _ctx)) { + case 1: + { + setState(1556); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1553); + match(NL); + } + } + setState(1558); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1559); + match(COLON); + setState(1563); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1560); + match(NL); + } + } + setState(1565); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1566); + constructorDelegationCall(); + } + break; + } + setState(1572); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 221, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1569); + match(NL); + } + } + } + setState(1574); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 221, _ctx); + } + setState(1576); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == LCURL) { + { + setState(1575); + block(); + } + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ConstructorDelegationCallContext constructorDelegationCall() + throws RecognitionException { + ConstructorDelegationCallContext _localctx = + new ConstructorDelegationCallContext(_ctx, getState()); + enterRule(_localctx, 90, RULE_constructorDelegationCall); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1578); + _la = _input.LA(1); + if (!(_la == THIS || _la == SUPER)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1582); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1579); + match(NL); + } + } + setState(1584); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1585); + valueArguments(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final EnumClassBodyContext enumClassBody() throws RecognitionException { + EnumClassBodyContext _localctx = new EnumClassBodyContext(_ctx, getState()); + enterRule(_localctx, 92, RULE_enumClassBody); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1587); + match(LCURL); + setState(1591); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 224, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1588); + match(NL); + } + } + } + setState(1593); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 224, _ctx); + } + setState(1595); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 40)) & ~0x3f) == 0 + && ((1L << (_la - 40)) + & ((1L << (AT_NO_WS - 40)) + | (1L << (AT_PRE_WS - 40)) + | (1L << (FILE - 40)) + | (1L << (FIELD - 40)) + | (1L << (PROPERTY - 40)) + | (1L << (GET - 40)) + | (1L << (SET - 40)) + | (1L << (RECEIVER - 40)) + | (1L << (PARAM - 40)) + | (1L << (SETPARAM - 40)) + | (1L << (DELEGATE - 40)) + | (1L << (IMPORT - 40)) + | (1L << (CONSTRUCTOR - 40)) + | (1L << (BY - 40)) + | (1L << (COMPANION - 40)) + | (1L << (INIT - 40)) + | (1L << (WHERE - 40)) + | (1L << (CATCH - 40)) + | (1L << (FINALLY - 40)))) + != 0) + || ((((_la - 105)) & ~0x3f) == 0 + && ((1L << (_la - 105)) + & ((1L << (OUT - 105)) + | (1L << (DYNAMIC - 105)) + | (1L << (PUBLIC - 105)) + | (1L << (PRIVATE - 105)) + | (1L << (PROTECTED - 105)) + | (1L << (INTERNAL - 105)) + | (1L << (ENUM - 105)) + | (1L << (SEALED - 105)) + | (1L << (ANNOTATION - 105)) + | (1L << (DATA - 105)) + | (1L << (INNER - 105)) + | (1L << (VALUE - 105)) + | (1L << (TAILREC - 105)) + | (1L << (OPERATOR - 105)) + | (1L << (INLINE - 105)) + | (1L << (INFIX - 105)) + | (1L << (EXTERNAL - 105)) + | (1L << (SUSPEND - 105)) + | (1L << (OVERRIDE - 105)) + | (1L << (ABSTRACT - 105)) + | (1L << (FINAL - 105)) + | (1L << (OPEN - 105)) + | (1L << (CONST - 105)) + | (1L << (LATEINIT - 105)) + | (1L << (VARARG - 105)) + | (1L << (NOINLINE - 105)) + | (1L << (CROSSINLINE - 105)) + | (1L << (REIFIED - 105)) + | (1L << (EXPECT - 105)) + | (1L << (ACTUAL - 105)) + | (1L << (Identifier - 105)))) + != 0)) { + { + setState(1594); + enumEntries(); + } + } + + setState(1611); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 228, _ctx)) { + case 1: + { + setState(1600); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1597); + match(NL); + } + } + setState(1602); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1603); + match(SEMICOLON); + setState(1607); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 227, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1604); + match(NL); + } + } + } + setState(1609); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 227, _ctx); + } + setState(1610); + classMemberDeclarations(); + } + break; + } + setState(1616); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1613); + match(NL); + } + } + setState(1618); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1619); + match(RCURL); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final EnumEntriesContext enumEntries() throws RecognitionException { + EnumEntriesContext _localctx = new EnumEntriesContext(_ctx, getState()); + enterRule(_localctx, 94, RULE_enumEntries); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1621); + enumEntry(); + setState(1638); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 232, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1625); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1622); + match(NL); + } + } + setState(1627); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1628); + match(COMMA); + setState(1632); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1629); + match(NL); + } + } + setState(1634); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1635); + enumEntry(); + } + } + } + setState(1640); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 232, _ctx); + } + setState(1644); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 233, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1641); + match(NL); + } + } + } + setState(1646); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 233, _ctx); + } + setState(1648); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == COMMA) { + { + setState(1647); + match(COMMA); + } + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final EnumEntryContext enumEntry() throws RecognitionException { + EnumEntryContext _localctx = new EnumEntryContext(_ctx, getState()); + enterRule(_localctx, 96, RULE_enumEntry); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1657); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 236, _ctx)) { + case 1: + { + setState(1650); + modifiers(); + setState(1654); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1651); + match(NL); + } + } + setState(1656); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + } + setState(1659); + simpleIdentifier(); + setState(1667); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 238, _ctx)) { + case 1: + { + setState(1663); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1660); + match(NL); + } + } + setState(1665); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1666); + valueArguments(); + } + break; + } + setState(1676); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 240, _ctx)) { + case 1: + { + setState(1672); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1669); + match(NL); + } + } + setState(1674); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1675); + classBody(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final TypeContext type() throws RecognitionException { + TypeContext _localctx = new TypeContext(_ctx, getState()); + enterRule(_localctx, 98, RULE_type); + try { + enterOuterAlt(_localctx, 1); + { + setState(1679); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 241, _ctx)) { + case 1: + { + setState(1678); + typeModifiers(); + } + break; + } + setState(1685); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 242, _ctx)) { + case 1: + { + setState(1681); + parenthesizedType(); + } + break; + case 2: + { + setState(1682); + nullableType(); + } + break; + case 3: + { + setState(1683); + typeReference(); + } + break; + case 4: + { + setState(1684); + functionType(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final TypeReferenceContext typeReference() throws RecognitionException { + TypeReferenceContext _localctx = new TypeReferenceContext(_ctx, getState()); + enterRule(_localctx, 100, RULE_typeReference); + try { + setState(1689); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 243, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1687); + userType(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1688); + match(DYNAMIC); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final NullableTypeContext nullableType() throws RecognitionException { + NullableTypeContext _localctx = new NullableTypeContext(_ctx, getState()); + enterRule(_localctx, 102, RULE_nullableType); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1693); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FILE: + case FIELD: + case PROPERTY: + case GET: + case SET: + case RECEIVER: + case PARAM: + case SETPARAM: + case DELEGATE: + case IMPORT: + case CONSTRUCTOR: + case BY: + case COMPANION: + case INIT: + case WHERE: + case CATCH: + case FINALLY: + case OUT: + case DYNAMIC: + case PUBLIC: + case PRIVATE: + case PROTECTED: + case INTERNAL: + case ENUM: + case SEALED: + case ANNOTATION: + case DATA: + case INNER: + case VALUE: + case TAILREC: + case OPERATOR: + case INLINE: + case INFIX: + case EXTERNAL: + case SUSPEND: + case OVERRIDE: + case ABSTRACT: + case FINAL: + case OPEN: + case CONST: + case LATEINIT: + case VARARG: + case NOINLINE: + case CROSSINLINE: + case REIFIED: + case EXPECT: + case ACTUAL: + case Identifier: + { + setState(1691); + typeReference(); + } + break; + case LPAREN: + { + setState(1692); + parenthesizedType(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(1698); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1695); + match(NL); + } + } + setState(1700); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1702); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(1701); + quest(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1704); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 246, _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 final QuestContext quest() throws RecognitionException { + QuestContext _localctx = new QuestContext(_ctx, getState()); + enterRule(_localctx, 104, RULE_quest); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1706); + _la = _input.LA(1); + if (!(_la == QUEST_WS || _la == QUEST_NO_WS)) { + _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 final UserTypeContext userType() throws RecognitionException { + UserTypeContext _localctx = new UserTypeContext(_ctx, getState()); + enterRule(_localctx, 106, RULE_userType); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1708); + simpleUserType(); + setState(1725); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 249, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1712); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1709); + match(NL); + } + } + setState(1714); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1715); + match(DOT); + setState(1719); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1716); + match(NL); + } + } + setState(1721); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1722); + simpleUserType(); + } + } + } + setState(1727); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 249, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final SimpleUserTypeContext simpleUserType() throws RecognitionException { + SimpleUserTypeContext _localctx = new SimpleUserTypeContext(_ctx, getState()); + enterRule(_localctx, 108, RULE_simpleUserType); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1728); + simpleIdentifier(); + setState(1736); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 251, _ctx)) { + case 1: + { + setState(1732); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1729); + match(NL); + } + } + setState(1734); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1735); + typeArguments(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final TypeProjectionContext typeProjection() throws RecognitionException { + TypeProjectionContext _localctx = new TypeProjectionContext(_ctx, getState()); + enterRule(_localctx, 110, RULE_typeProjection); + try { + setState(1743); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LPAREN: + case AT_NO_WS: + case AT_PRE_WS: + case FILE: + case FIELD: + case PROPERTY: + case GET: + case SET: + case RECEIVER: + case PARAM: + case SETPARAM: + case DELEGATE: + case IMPORT: + case CONSTRUCTOR: + case BY: + case COMPANION: + case INIT: + case WHERE: + case CATCH: + case FINALLY: + case IN: + case OUT: + case DYNAMIC: + case PUBLIC: + case PRIVATE: + case PROTECTED: + case INTERNAL: + case ENUM: + case SEALED: + case ANNOTATION: + case DATA: + case INNER: + case VALUE: + case TAILREC: + case OPERATOR: + case INLINE: + case INFIX: + case EXTERNAL: + case SUSPEND: + case OVERRIDE: + case ABSTRACT: + case FINAL: + case OPEN: + case CONST: + case LATEINIT: + case VARARG: + case NOINLINE: + case CROSSINLINE: + case REIFIED: + case EXPECT: + case ACTUAL: + case Identifier: + enterOuterAlt(_localctx, 1); + { + setState(1739); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 252, _ctx)) { + case 1: + { + setState(1738); + typeProjectionModifiers(); + } + break; + } + setState(1741); + type(); + } + break; + case MULT: + enterOuterAlt(_localctx, 2); + { + setState(1742); + match(MULT); + } + 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 final TypeProjectionModifiersContext typeProjectionModifiers() + throws RecognitionException { + TypeProjectionModifiersContext _localctx = new TypeProjectionModifiersContext(_ctx, getState()); + enterRule(_localctx, 112, RULE_typeProjectionModifiers); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1746); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(1745); + typeProjectionModifier(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(1748); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 254, _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 final TypeProjectionModifierContext typeProjectionModifier() throws RecognitionException { + TypeProjectionModifierContext _localctx = new TypeProjectionModifierContext(_ctx, getState()); + enterRule(_localctx, 114, RULE_typeProjectionModifier); + int _la; + try { + setState(1758); + _errHandler.sync(this); + switch (_input.LA(1)) { + case IN: + case OUT: + enterOuterAlt(_localctx, 1); + { + setState(1750); + varianceModifier(); + setState(1754); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1751); + match(NL); + } + } + setState(1756); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + case AT_NO_WS: + case AT_PRE_WS: + enterOuterAlt(_localctx, 2); + { + setState(1757); + annotation(); + } + 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 final FunctionTypeContext functionType() throws RecognitionException { + FunctionTypeContext _localctx = new FunctionTypeContext(_ctx, getState()); + enterRule(_localctx, 116, RULE_functionType); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1774); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 259, _ctx)) { + case 1: + { + setState(1760); + receiverType(); + setState(1764); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1761); + match(NL); + } + } + setState(1766); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1767); + match(DOT); + setState(1771); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1768); + match(NL); + } + } + setState(1773); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + } + setState(1776); + functionTypeParameters(); + setState(1780); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1777); + match(NL); + } + } + setState(1782); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1783); + match(ARROW); + setState(1787); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1784); + match(NL); + } + } + setState(1789); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1790); + type(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final FunctionTypeParametersContext functionTypeParameters() throws RecognitionException { + FunctionTypeParametersContext _localctx = new FunctionTypeParametersContext(_ctx, getState()); + enterRule(_localctx, 118, RULE_functionTypeParameters); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1792); + match(LPAREN); + setState(1796); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 262, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1793); + match(NL); + } + } + } + setState(1798); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 262, _ctx); + } + setState(1801); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 263, _ctx)) { + case 1: + { + setState(1799); + parameter(); + } + break; + case 2: + { + setState(1800); + type(); + } + break; + } + setState(1822); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 267, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1806); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1803); + match(NL); + } + } + setState(1808); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1809); + match(COMMA); + setState(1813); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1810); + match(NL); + } + } + setState(1815); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1818); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 266, _ctx)) { + case 1: + { + setState(1816); + parameter(); + } + break; + case 2: + { + setState(1817); + type(); + } + break; + } + } + } + } + setState(1824); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 267, _ctx); + } + setState(1832); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 269, _ctx)) { + case 1: + { + setState(1828); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1825); + match(NL); + } + } + setState(1830); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1831); + match(COMMA); + } + break; + } + setState(1837); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1834); + match(NL); + } + } + setState(1839); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1840); + match(RPAREN); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ParenthesizedTypeContext parenthesizedType() throws RecognitionException { + ParenthesizedTypeContext _localctx = new ParenthesizedTypeContext(_ctx, getState()); + enterRule(_localctx, 120, RULE_parenthesizedType); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1842); + match(LPAREN); + setState(1846); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1843); + match(NL); + } + } + setState(1848); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1849); + type(); + setState(1853); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1850); + match(NL); + } + } + setState(1855); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1856); + match(RPAREN); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ReceiverTypeContext receiverType() throws RecognitionException { + ReceiverTypeContext _localctx = new ReceiverTypeContext(_ctx, getState()); + enterRule(_localctx, 122, RULE_receiverType); + try { + enterOuterAlt(_localctx, 1); + { + setState(1859); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 273, _ctx)) { + case 1: + { + setState(1858); + typeModifiers(); + } + break; + } + setState(1864); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 274, _ctx)) { + case 1: + { + setState(1861); + parenthesizedType(); + } + break; + case 2: + { + setState(1862); + nullableType(); + } + break; + case 3: + { + setState(1863); + typeReference(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ParenthesizedUserTypeContext parenthesizedUserType() throws RecognitionException { + ParenthesizedUserTypeContext _localctx = new ParenthesizedUserTypeContext(_ctx, getState()); + enterRule(_localctx, 124, RULE_parenthesizedUserType); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1866); + match(LPAREN); + setState(1870); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1867); + match(NL); + } + } + setState(1872); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1875); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FILE: + case FIELD: + case PROPERTY: + case GET: + case SET: + case RECEIVER: + case PARAM: + case SETPARAM: + case DELEGATE: + case IMPORT: + case CONSTRUCTOR: + case BY: + case COMPANION: + case INIT: + case WHERE: + case CATCH: + case FINALLY: + case OUT: + case DYNAMIC: + case PUBLIC: + case PRIVATE: + case PROTECTED: + case INTERNAL: + case ENUM: + case SEALED: + case ANNOTATION: + case DATA: + case INNER: + case VALUE: + case TAILREC: + case OPERATOR: + case INLINE: + case INFIX: + case EXTERNAL: + case SUSPEND: + case OVERRIDE: + case ABSTRACT: + case FINAL: + case OPEN: + case CONST: + case LATEINIT: + case VARARG: + case NOINLINE: + case CROSSINLINE: + case REIFIED: + case EXPECT: + case ACTUAL: + case Identifier: + { + setState(1873); + userType(); + } + break; + case LPAREN: + { + setState(1874); + parenthesizedUserType(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(1880); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1877); + match(NL); + } + } + setState(1882); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1883); + match(RPAREN); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final StatementsContext statements() throws RecognitionException { + StatementsContext _localctx = new StatementsContext(_ctx, getState()); + enterRule(_localctx, 126, RULE_statements); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1894); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 + && ((1L << _la) + & ((1L << LPAREN) + | (1L << LSQUARE) + | (1L << LCURL) + | (1L << ADD) + | (1L << SUB) + | (1L << INCR) + | (1L << DECR) + | (1L << EXCL_WS) + | (1L << EXCL_NO_WS) + | (1L << COLONCOLON) + | (1L << AT_NO_WS) + | (1L << AT_PRE_WS) + | (1L << RETURN_AT) + | (1L << CONTINUE_AT) + | (1L << BREAK_AT) + | (1L << THIS_AT) + | (1L << SUPER_AT) + | (1L << FILE) + | (1L << FIELD) + | (1L << PROPERTY))) + != 0) + || ((((_la - 64)) & ~0x3f) == 0 + && ((1L << (_la - 64)) + & ((1L << (GET - 64)) + | (1L << (SET - 64)) + | (1L << (RECEIVER - 64)) + | (1L << (PARAM - 64)) + | (1L << (SETPARAM - 64)) + | (1L << (DELEGATE - 64)) + | (1L << (IMPORT - 64)) + | (1L << (CLASS - 64)) + | (1L << (INTERFACE - 64)) + | (1L << (FUN - 64)) + | (1L << (OBJECT - 64)) + | (1L << (VAL - 64)) + | (1L << (VAR - 64)) + | (1L << (TYPE_ALIAS - 64)) + | (1L << (CONSTRUCTOR - 64)) + | (1L << (BY - 64)) + | (1L << (COMPANION - 64)) + | (1L << (INIT - 64)) + | (1L << (THIS - 64)) + | (1L << (SUPER - 64)) + | (1L << (WHERE - 64)) + | (1L << (IF - 64)) + | (1L << (WHEN - 64)) + | (1L << (TRY - 64)) + | (1L << (CATCH - 64)) + | (1L << (FINALLY - 64)) + | (1L << (FOR - 64)) + | (1L << (DO - 64)) + | (1L << (WHILE - 64)) + | (1L << (THROW - 64)) + | (1L << (RETURN - 64)) + | (1L << (CONTINUE - 64)) + | (1L << (BREAK - 64)) + | (1L << (OUT - 64)) + | (1L << (DYNAMIC - 64)) + | (1L << (PUBLIC - 64)) + | (1L << (PRIVATE - 64)) + | (1L << (PROTECTED - 64)) + | (1L << (INTERNAL - 64)) + | (1L << (ENUM - 64)) + | (1L << (SEALED - 64)) + | (1L << (ANNOTATION - 64)) + | (1L << (DATA - 64)) + | (1L << (INNER - 64)) + | (1L << (VALUE - 64)) + | (1L << (TAILREC - 64)) + | (1L << (OPERATOR - 64)) + | (1L << (INLINE - 64)) + | (1L << (INFIX - 64)) + | (1L << (EXTERNAL - 64)) + | (1L << (SUSPEND - 64)) + | (1L << (OVERRIDE - 64)) + | (1L << (ABSTRACT - 64)) + | (1L << (FINAL - 64)) + | (1L << (OPEN - 64)) + | (1L << (CONST - 64)))) + != 0) + || ((((_la - 128)) & ~0x3f) == 0 + && ((1L << (_la - 128)) + & ((1L << (LATEINIT - 128)) + | (1L << (VARARG - 128)) + | (1L << (NOINLINE - 128)) + | (1L << (CROSSINLINE - 128)) + | (1L << (REIFIED - 128)) + | (1L << (EXPECT - 128)) + | (1L << (ACTUAL - 128)) + | (1L << (RealLiteral - 128)) + | (1L << (IntegerLiteral - 128)) + | (1L << (HexLiteral - 128)) + | (1L << (BinLiteral - 128)) + | (1L << (UnsignedLiteral - 128)) + | (1L << (LongLiteral - 128)) + | (1L << (BooleanLiteral - 128)) + | (1L << (NullLiteral - 128)) + | (1L << (CharacterLiteral - 128)) + | (1L << (Identifier - 128)) + | (1L << (QUOTE_OPEN - 128)) + | (1L << (TRIPLE_QUOTE_OPEN - 128)))) + != 0)) { + { + setState(1885); + statement(); + setState(1891); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 278, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1886); + semis(); + setState(1887); + statement(); + } + } + } + setState(1893); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 278, _ctx); + } + } + } + + setState(1897); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 280, _ctx)) { + case 1: + { + setState(1896); + semis(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final StatementContext statement() throws RecognitionException { + StatementContext _localctx = new StatementContext(_ctx, getState()); + enterRule(_localctx, 128, RULE_statement); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1903); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 282, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + setState(1901); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FILE: + case FIELD: + case PROPERTY: + case GET: + case SET: + case RECEIVER: + case PARAM: + case SETPARAM: + case DELEGATE: + case IMPORT: + case CONSTRUCTOR: + case BY: + case COMPANION: + case INIT: + case WHERE: + case CATCH: + case FINALLY: + case OUT: + case DYNAMIC: + case PUBLIC: + case PRIVATE: + case PROTECTED: + case INTERNAL: + case ENUM: + case SEALED: + case ANNOTATION: + case DATA: + case INNER: + case VALUE: + case TAILREC: + case OPERATOR: + case INLINE: + case INFIX: + case EXTERNAL: + case SUSPEND: + case OVERRIDE: + case ABSTRACT: + case FINAL: + case OPEN: + case CONST: + case LATEINIT: + case VARARG: + case NOINLINE: + case CROSSINLINE: + case REIFIED: + case EXPECT: + case ACTUAL: + case Identifier: + { + setState(1899); + label(); + } + break; + case AT_NO_WS: + case AT_PRE_WS: + { + setState(1900); + annotation(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + setState(1905); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 282, _ctx); + } + setState(1910); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 283, _ctx)) { + case 1: + { + setState(1906); + declaration(); + } + break; + case 2: + { + setState(1907); + assignment(); + } + break; + case 3: + { + setState(1908); + loopStatement(); + } + break; + case 4: + { + setState(1909); + expression(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final LabelContext label() throws RecognitionException { + LabelContext _localctx = new LabelContext(_ctx, getState()); + enterRule(_localctx, 130, RULE_label); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1912); + simpleIdentifier(); + setState(1913); + _la = _input.LA(1); + if (!(_la == AT_NO_WS || _la == AT_POST_WS)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(1917); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 284, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1914); + match(NL); + } + } + } + setState(1919); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 284, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ControlStructureBodyContext controlStructureBody() throws RecognitionException { + ControlStructureBodyContext _localctx = new ControlStructureBodyContext(_ctx, getState()); + enterRule(_localctx, 132, RULE_controlStructureBody); + try { + setState(1922); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 285, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(1920); + block(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(1921); + statement(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final BlockContext block() throws RecognitionException { + BlockContext _localctx = new BlockContext(_ctx, getState()); + enterRule(_localctx, 134, RULE_block); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1924); + match(LCURL); + setState(1928); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 286, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1925); + match(NL); + } + } + } + setState(1930); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 286, _ctx); + } + setState(1931); + statements(); + setState(1935); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1932); + match(NL); + } + } + setState(1937); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1938); + match(RCURL); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final LoopStatementContext loopStatement() throws RecognitionException { + LoopStatementContext _localctx = new LoopStatementContext(_ctx, getState()); + enterRule(_localctx, 136, RULE_loopStatement); + try { + setState(1943); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FOR: + enterOuterAlt(_localctx, 1); + { + setState(1940); + forStatement(); + } + break; + case WHILE: + enterOuterAlt(_localctx, 2); + { + setState(1941); + whileStatement(); + } + break; + case DO: + enterOuterAlt(_localctx, 3); + { + setState(1942); + doWhileStatement(); + } + 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 final ForStatementContext forStatement() throws RecognitionException { + ForStatementContext _localctx = new ForStatementContext(_ctx, getState()); + enterRule(_localctx, 138, RULE_forStatement); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1945); + match(FOR); + setState(1949); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1946); + match(NL); + } + } + setState(1951); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1952); + match(LPAREN); + setState(1956); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 290, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1953); + annotation(); + } + } + } + setState(1958); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 290, _ctx); + } + setState(1961); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NL: + case AT_NO_WS: + case AT_PRE_WS: + case FILE: + case FIELD: + case PROPERTY: + case GET: + case SET: + case RECEIVER: + case PARAM: + case SETPARAM: + case DELEGATE: + case IMPORT: + case CONSTRUCTOR: + case BY: + case COMPANION: + case INIT: + case WHERE: + case CATCH: + case FINALLY: + case OUT: + case DYNAMIC: + case PUBLIC: + case PRIVATE: + case PROTECTED: + case INTERNAL: + case ENUM: + case SEALED: + case ANNOTATION: + case DATA: + case INNER: + case VALUE: + case TAILREC: + case OPERATOR: + case INLINE: + case INFIX: + case EXTERNAL: + case SUSPEND: + case OVERRIDE: + case ABSTRACT: + case FINAL: + case OPEN: + case CONST: + case LATEINIT: + case VARARG: + case NOINLINE: + case CROSSINLINE: + case REIFIED: + case EXPECT: + case ACTUAL: + case Identifier: + { + setState(1959); + variableDeclaration(); + } + break; + case LPAREN: + { + setState(1960); + multiVariableDeclaration(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(1963); + match(IN); + setState(1964); + expression(); + setState(1965); + match(RPAREN); + setState(1969); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 292, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1966); + match(NL); + } + } + } + setState(1971); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 292, _ctx); + } + setState(1973); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 293, _ctx)) { + case 1: + { + setState(1972); + controlStructureBody(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final WhileStatementContext whileStatement() throws RecognitionException { + WhileStatementContext _localctx = new WhileStatementContext(_ctx, getState()); + enterRule(_localctx, 140, RULE_whileStatement); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(1975); + match(WHILE); + setState(1979); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1976); + match(NL); + } + } + setState(1981); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1982); + match(LPAREN); + setState(1983); + expression(); + setState(1984); + match(RPAREN); + setState(1988); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(1985); + match(NL); + } + } + setState(1990); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(1993); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LPAREN: + case LSQUARE: + case LCURL: + case ADD: + case SUB: + case INCR: + case DECR: + case EXCL_WS: + case EXCL_NO_WS: + case COLONCOLON: + case AT_NO_WS: + case AT_PRE_WS: + case RETURN_AT: + case CONTINUE_AT: + case BREAK_AT: + case THIS_AT: + case SUPER_AT: + case FILE: + case FIELD: + case PROPERTY: + case GET: + case SET: + case RECEIVER: + case PARAM: + case SETPARAM: + case DELEGATE: + case IMPORT: + case CLASS: + case INTERFACE: + case FUN: + case OBJECT: + case VAL: + case VAR: + case TYPE_ALIAS: + case CONSTRUCTOR: + case BY: + case COMPANION: + case INIT: + case THIS: + case SUPER: + case WHERE: + case IF: + case WHEN: + case TRY: + case CATCH: + case FINALLY: + case FOR: + case DO: + case WHILE: + case THROW: + case RETURN: + case CONTINUE: + case BREAK: + case OUT: + case DYNAMIC: + case PUBLIC: + case PRIVATE: + case PROTECTED: + case INTERNAL: + case ENUM: + case SEALED: + case ANNOTATION: + case DATA: + case INNER: + case VALUE: + case TAILREC: + case OPERATOR: + case INLINE: + case INFIX: + case EXTERNAL: + case SUSPEND: + case OVERRIDE: + case ABSTRACT: + case FINAL: + case OPEN: + case CONST: + case LATEINIT: + case VARARG: + case NOINLINE: + case CROSSINLINE: + case REIFIED: + case EXPECT: + case ACTUAL: + case RealLiteral: + case IntegerLiteral: + case HexLiteral: + case BinLiteral: + case UnsignedLiteral: + case LongLiteral: + case BooleanLiteral: + case NullLiteral: + case CharacterLiteral: + case Identifier: + case QUOTE_OPEN: + case TRIPLE_QUOTE_OPEN: + { + setState(1991); + controlStructureBody(); + } + break; + case SEMICOLON: + { + setState(1992); + match(SEMICOLON); + } + break; + default: + throw new NoViableAltException(this); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final DoWhileStatementContext doWhileStatement() throws RecognitionException { + DoWhileStatementContext _localctx = new DoWhileStatementContext(_ctx, getState()); + enterRule(_localctx, 142, RULE_doWhileStatement); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(1995); + match(DO); + setState(1999); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 297, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(1996); + match(NL); + } + } + } + setState(2001); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 297, _ctx); + } + setState(2003); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 298, _ctx)) { + case 1: + { + setState(2002); + controlStructureBody(); + } + break; + } + setState(2008); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2005); + match(NL); + } + } + setState(2010); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2011); + match(WHILE); + setState(2015); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2012); + match(NL); + } + } + setState(2017); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2018); + match(LPAREN); + setState(2019); + expression(); + setState(2020); + match(RPAREN); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final AssignmentContext assignment() throws RecognitionException { + AssignmentContext _localctx = new AssignmentContext(_ctx, getState()); + enterRule(_localctx, 144, RULE_assignment); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2028); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 301, _ctx)) { + case 1: + { + setState(2022); + directlyAssignableExpression(); + setState(2023); + match(ASSIGNMENT); + } + break; + case 2: + { + setState(2025); + assignableExpression(); + setState(2026); + assignmentAndOperator(); + } + break; + } + setState(2033); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2030); + match(NL); + } + } + setState(2035); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2036); + expression(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final SemiContext semi() throws RecognitionException { + SemiContext _localctx = new SemiContext(_ctx, getState()); + enterRule(_localctx, 146, RULE_semi); + int _la; + try { + int _alt; + setState(2046); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NL: + case SEMICOLON: + enterOuterAlt(_localctx, 1); + { + setState(2038); + _la = _input.LA(1); + if (!(_la == NL || _la == SEMICOLON)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(2042); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 303, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2039); + match(NL); + } + } + } + setState(2044); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 303, _ctx); + } + } + break; + case EOF: + enterOuterAlt(_localctx, 2); + { + setState(2045); + match(EOF); + } + 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 final SemisContext semis() throws RecognitionException { + SemisContext _localctx = new SemisContext(_ctx, getState()); + enterRule(_localctx, 148, RULE_semis); + int _la; + try { + int _alt; + setState(2054); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NL: + case SEMICOLON: + enterOuterAlt(_localctx, 1); + { + setState(2049); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(2048); + _la = _input.LA(1); + if (!(_la == NL || _la == SEMICOLON)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(2051); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 305, _ctx); + } while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER); + } + break; + case EOF: + enterOuterAlt(_localctx, 2); + { + setState(2053); + match(EOF); + } + 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 final ExpressionContext expression() throws RecognitionException { + ExpressionContext _localctx = new ExpressionContext(_ctx, getState()); + enterRule(_localctx, 150, RULE_expression); + try { + enterOuterAlt(_localctx, 1); + { + setState(2056); + disjunction(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final DisjunctionContext disjunction() throws RecognitionException { + DisjunctionContext _localctx = new DisjunctionContext(_ctx, getState()); + enterRule(_localctx, 152, RULE_disjunction); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2058); + conjunction(); + setState(2075); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 309, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2062); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2059); + match(NL); + } + } + setState(2064); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2065); + match(DISJ); + setState(2069); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2066); + match(NL); + } + } + setState(2071); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2072); + conjunction(); + } + } + } + setState(2077); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 309, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ConjunctionContext conjunction() throws RecognitionException { + ConjunctionContext _localctx = new ConjunctionContext(_ctx, getState()); + enterRule(_localctx, 154, RULE_conjunction); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2078); + equality(); + setState(2095); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 312, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2082); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2079); + match(NL); + } + } + setState(2084); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2085); + match(CONJ); + setState(2089); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2086); + match(NL); + } + } + setState(2091); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2092); + equality(); + } + } + } + setState(2097); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 312, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final EqualityContext equality() throws RecognitionException { + EqualityContext _localctx = new EqualityContext(_ctx, getState()); + enterRule(_localctx, 156, RULE_equality); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2098); + comparison(); + setState(2110); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 314, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2099); + equalityOperator(); + setState(2103); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2100); + match(NL); + } + } + setState(2105); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2106); + comparison(); + } + } + } + setState(2112); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 314, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ComparisonContext comparison() throws RecognitionException { + ComparisonContext _localctx = new ComparisonContext(_ctx, getState()); + enterRule(_localctx, 158, RULE_comparison); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2113); + genericCallLikeComparison(); + setState(2125); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 316, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2114); + comparisonOperator(); + setState(2118); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2115); + match(NL); + } + } + setState(2120); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2121); + genericCallLikeComparison(); + } + } + } + setState(2127); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 316, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final GenericCallLikeComparisonContext genericCallLikeComparison() + throws RecognitionException { + GenericCallLikeComparisonContext _localctx = + new GenericCallLikeComparisonContext(_ctx, getState()); + enterRule(_localctx, 160, RULE_genericCallLikeComparison); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2128); + infixOperation(); + setState(2132); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 317, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2129); + callSuffix(); + } + } + } + setState(2134); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 317, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final InfixOperationContext infixOperation() throws RecognitionException { + InfixOperationContext _localctx = new InfixOperationContext(_ctx, getState()); + enterRule(_localctx, 162, RULE_infixOperation); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2135); + elvisExpression(); + setState(2156); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 321, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + setState(2154); + _errHandler.sync(this); + switch (_input.LA(1)) { + case IN: + case NOT_IN: + { + setState(2136); + inOperator(); + setState(2140); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2137); + match(NL); + } + } + setState(2142); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2143); + elvisExpression(); + } + break; + case IS: + case NOT_IS: + { + setState(2145); + isOperator(); + setState(2149); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2146); + match(NL); + } + } + setState(2151); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2152); + type(); + } + break; + default: + throw new NoViableAltException(this); + } + } + } + setState(2158); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 321, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ElvisExpressionContext elvisExpression() throws RecognitionException { + ElvisExpressionContext _localctx = new ElvisExpressionContext(_ctx, getState()); + enterRule(_localctx, 164, RULE_elvisExpression); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2159); + infixFunctionCall(); + setState(2177); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 324, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2163); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2160); + match(NL); + } + } + setState(2165); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2166); + elvis(); + setState(2170); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2167); + match(NL); + } + } + setState(2172); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2173); + infixFunctionCall(); + } + } + } + setState(2179); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 324, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ElvisContext elvis() throws RecognitionException { + ElvisContext _localctx = new ElvisContext(_ctx, getState()); + enterRule(_localctx, 166, RULE_elvis); + try { + enterOuterAlt(_localctx, 1); + { + setState(2180); + match(QUEST_NO_WS); + setState(2181); + match(COLON); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final InfixFunctionCallContext infixFunctionCall() throws RecognitionException { + InfixFunctionCallContext _localctx = new InfixFunctionCallContext(_ctx, getState()); + enterRule(_localctx, 168, RULE_infixFunctionCall); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2183); + rangeExpression(); + setState(2195); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 326, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2184); + simpleIdentifier(); + setState(2188); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2185); + match(NL); + } + } + setState(2190); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2191); + rangeExpression(); + } + } + } + setState(2197); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 326, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final RangeExpressionContext rangeExpression() throws RecognitionException { + RangeExpressionContext _localctx = new RangeExpressionContext(_ctx, getState()); + enterRule(_localctx, 170, RULE_rangeExpression); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2198); + additiveExpression(); + setState(2209); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 328, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2199); + match(RANGE); + setState(2203); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2200); + match(NL); + } + } + setState(2205); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2206); + additiveExpression(); + } + } + } + setState(2211); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 328, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final AdditiveExpressionContext additiveExpression() throws RecognitionException { + AdditiveExpressionContext _localctx = new AdditiveExpressionContext(_ctx, getState()); + enterRule(_localctx, 172, RULE_additiveExpression); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2212); + multiplicativeExpression(); + setState(2224); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 330, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2213); + additiveOperator(); + setState(2217); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2214); + match(NL); + } + } + setState(2219); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2220); + multiplicativeExpression(); + } + } + } + setState(2226); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 330, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final MultiplicativeExpressionContext multiplicativeExpression() + throws RecognitionException { + MultiplicativeExpressionContext _localctx = + new MultiplicativeExpressionContext(_ctx, getState()); + enterRule(_localctx, 174, RULE_multiplicativeExpression); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2227); + asExpression(); + setState(2239); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 332, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2228); + multiplicativeOperator(); + setState(2232); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2229); + match(NL); + } + } + setState(2234); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2235); + asExpression(); + } + } + } + setState(2241); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 332, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final AsExpressionContext asExpression() throws RecognitionException { + AsExpressionContext _localctx = new AsExpressionContext(_ctx, getState()); + enterRule(_localctx, 176, RULE_asExpression); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2242); + prefixUnaryExpression(); + setState(2260); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 335, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2246); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2243); + match(NL); + } + } + setState(2248); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2249); + asOperator(); + setState(2253); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2250); + match(NL); + } + } + setState(2255); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2256); + type(); + } + } + } + setState(2262); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 335, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final PrefixUnaryExpressionContext prefixUnaryExpression() throws RecognitionException { + PrefixUnaryExpressionContext _localctx = new PrefixUnaryExpressionContext(_ctx, getState()); + enterRule(_localctx, 178, RULE_prefixUnaryExpression); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2266); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 336, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2263); + unaryPrefix(); + } + } + } + setState(2268); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 336, _ctx); + } + setState(2269); + postfixUnaryExpression(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final UnaryPrefixContext unaryPrefix() throws RecognitionException { + UnaryPrefixContext _localctx = new UnaryPrefixContext(_ctx, getState()); + enterRule(_localctx, 180, RULE_unaryPrefix); + int _la; + try { + setState(2280); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AT_NO_WS: + case AT_PRE_WS: + enterOuterAlt(_localctx, 1); + { + setState(2271); + annotation(); + } + break; + case FILE: + case FIELD: + case PROPERTY: + case GET: + case SET: + case RECEIVER: + case PARAM: + case SETPARAM: + case DELEGATE: + case IMPORT: + case CONSTRUCTOR: + case BY: + case COMPANION: + case INIT: + case WHERE: + case CATCH: + case FINALLY: + case OUT: + case DYNAMIC: + case PUBLIC: + case PRIVATE: + case PROTECTED: + case INTERNAL: + case ENUM: + case SEALED: + case ANNOTATION: + case DATA: + case INNER: + case VALUE: + case TAILREC: + case OPERATOR: + case INLINE: + case INFIX: + case EXTERNAL: + case SUSPEND: + case OVERRIDE: + case ABSTRACT: + case FINAL: + case OPEN: + case CONST: + case LATEINIT: + case VARARG: + case NOINLINE: + case CROSSINLINE: + case REIFIED: + case EXPECT: + case ACTUAL: + case Identifier: + enterOuterAlt(_localctx, 2); + { + setState(2272); + label(); + } + break; + case ADD: + case SUB: + case INCR: + case DECR: + case EXCL_WS: + case EXCL_NO_WS: + enterOuterAlt(_localctx, 3); + { + setState(2273); + prefixUnaryOperator(); + setState(2277); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2274); + match(NL); + } + } + setState(2279); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final PostfixUnaryExpressionContext postfixUnaryExpression() throws RecognitionException { + PostfixUnaryExpressionContext _localctx = new PostfixUnaryExpressionContext(_ctx, getState()); + enterRule(_localctx, 182, RULE_postfixUnaryExpression); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2282); + primaryExpression(); + setState(2286); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 339, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2283); + postfixUnarySuffix(); + } + } + } + setState(2288); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 339, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final PostfixUnarySuffixContext postfixUnarySuffix() throws RecognitionException { + PostfixUnarySuffixContext _localctx = new PostfixUnarySuffixContext(_ctx, getState()); + enterRule(_localctx, 184, RULE_postfixUnarySuffix); + try { + setState(2294); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 340, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2289); + postfixUnaryOperator(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2290); + typeArguments(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2291); + callSuffix(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(2292); + indexingSuffix(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(2293); + navigationSuffix(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final DirectlyAssignableExpressionContext directlyAssignableExpression() + throws RecognitionException { + DirectlyAssignableExpressionContext _localctx = + new DirectlyAssignableExpressionContext(_ctx, getState()); + enterRule(_localctx, 186, RULE_directlyAssignableExpression); + try { + setState(2301); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 341, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2296); + postfixUnaryExpression(); + setState(2297); + assignableSuffix(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2299); + simpleIdentifier(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2300); + parenthesizedDirectlyAssignableExpression(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ParenthesizedDirectlyAssignableExpressionContext + parenthesizedDirectlyAssignableExpression() throws RecognitionException { + ParenthesizedDirectlyAssignableExpressionContext _localctx = + new ParenthesizedDirectlyAssignableExpressionContext(_ctx, getState()); + enterRule(_localctx, 188, RULE_parenthesizedDirectlyAssignableExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2303); + match(LPAREN); + setState(2307); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2304); + match(NL); + } + } + setState(2309); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2310); + directlyAssignableExpression(); + setState(2314); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2311); + match(NL); + } + } + setState(2316); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2317); + match(RPAREN); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final AssignableExpressionContext assignableExpression() throws RecognitionException { + AssignableExpressionContext _localctx = new AssignableExpressionContext(_ctx, getState()); + enterRule(_localctx, 190, RULE_assignableExpression); + try { + setState(2321); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 344, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2319); + prefixUnaryExpression(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2320); + parenthesizedAssignableExpression(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ParenthesizedAssignableExpressionContext parenthesizedAssignableExpression() + throws RecognitionException { + ParenthesizedAssignableExpressionContext _localctx = + new ParenthesizedAssignableExpressionContext(_ctx, getState()); + enterRule(_localctx, 192, RULE_parenthesizedAssignableExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2323); + match(LPAREN); + setState(2327); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2324); + match(NL); + } + } + setState(2329); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2330); + assignableExpression(); + setState(2334); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2331); + match(NL); + } + } + setState(2336); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2337); + match(RPAREN); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final AssignableSuffixContext assignableSuffix() throws RecognitionException { + AssignableSuffixContext _localctx = new AssignableSuffixContext(_ctx, getState()); + enterRule(_localctx, 194, RULE_assignableSuffix); + try { + setState(2342); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LANGLE: + enterOuterAlt(_localctx, 1); + { + setState(2339); + typeArguments(); + } + break; + case LSQUARE: + enterOuterAlt(_localctx, 2); + { + setState(2340); + indexingSuffix(); + } + break; + case NL: + case DOT: + case COLONCOLON: + case QUEST_NO_WS: + enterOuterAlt(_localctx, 3); + { + setState(2341); + navigationSuffix(); + } + 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 final IndexingSuffixContext indexingSuffix() throws RecognitionException { + IndexingSuffixContext _localctx = new IndexingSuffixContext(_ctx, getState()); + enterRule(_localctx, 196, RULE_indexingSuffix); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2344); + match(LSQUARE); + setState(2348); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2345); + match(NL); + } + } + setState(2350); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2351); + expression(); + setState(2368); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 351, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2355); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2352); + match(NL); + } + } + setState(2357); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2358); + match(COMMA); + setState(2362); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2359); + match(NL); + } + } + setState(2364); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2365); + expression(); + } + } + } + setState(2370); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 351, _ctx); + } + setState(2378); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 353, _ctx)) { + case 1: + { + setState(2374); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2371); + match(NL); + } + } + setState(2376); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2377); + match(COMMA); + } + break; + } + setState(2383); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2380); + match(NL); + } + } + setState(2385); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2386); + match(RSQUARE); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final NavigationSuffixContext navigationSuffix() throws RecognitionException { + NavigationSuffixContext _localctx = new NavigationSuffixContext(_ctx, getState()); + enterRule(_localctx, 198, RULE_navigationSuffix); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2388); + memberAccessOperator(); + setState(2392); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2389); + match(NL); + } + } + setState(2394); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2398); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FILE: + case FIELD: + case PROPERTY: + case GET: + case SET: + case RECEIVER: + case PARAM: + case SETPARAM: + case DELEGATE: + case IMPORT: + case CONSTRUCTOR: + case BY: + case COMPANION: + case INIT: + case WHERE: + case CATCH: + case FINALLY: + case OUT: + case DYNAMIC: + case PUBLIC: + case PRIVATE: + case PROTECTED: + case INTERNAL: + case ENUM: + case SEALED: + case ANNOTATION: + case DATA: + case INNER: + case VALUE: + case TAILREC: + case OPERATOR: + case INLINE: + case INFIX: + case EXTERNAL: + case SUSPEND: + case OVERRIDE: + case ABSTRACT: + case FINAL: + case OPEN: + case CONST: + case LATEINIT: + case VARARG: + case NOINLINE: + case CROSSINLINE: + case REIFIED: + case EXPECT: + case ACTUAL: + case Identifier: + { + setState(2395); + simpleIdentifier(); + } + break; + case LPAREN: + { + setState(2396); + parenthesizedExpression(); + } + break; + case CLASS: + { + setState(2397); + match(CLASS); + } + 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 final CallSuffixContext callSuffix() throws RecognitionException { + CallSuffixContext _localctx = new CallSuffixContext(_ctx, getState()); + enterRule(_localctx, 200, RULE_callSuffix); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2401); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == LANGLE) { + { + setState(2400); + typeArguments(); + } + } + + setState(2408); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 359, _ctx)) { + case 1: + { + setState(2404); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == LPAREN) { + { + setState(2403); + valueArguments(); + } + } + + setState(2406); + annotatedLambda(); + } + break; + case 2: + { + setState(2407); + valueArguments(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final AnnotatedLambdaContext annotatedLambda() throws RecognitionException { + AnnotatedLambdaContext _localctx = new AnnotatedLambdaContext(_ctx, getState()); + enterRule(_localctx, 202, RULE_annotatedLambda); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2413); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == AT_NO_WS || _la == AT_PRE_WS) { + { + { + setState(2410); + annotation(); + } + } + setState(2415); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2417); + _errHandler.sync(this); + _la = _input.LA(1); + if (((((_la - 61)) & ~0x3f) == 0 + && ((1L << (_la - 61)) + & ((1L << (FILE - 61)) + | (1L << (FIELD - 61)) + | (1L << (PROPERTY - 61)) + | (1L << (GET - 61)) + | (1L << (SET - 61)) + | (1L << (RECEIVER - 61)) + | (1L << (PARAM - 61)) + | (1L << (SETPARAM - 61)) + | (1L << (DELEGATE - 61)) + | (1L << (IMPORT - 61)) + | (1L << (CONSTRUCTOR - 61)) + | (1L << (BY - 61)) + | (1L << (COMPANION - 61)) + | (1L << (INIT - 61)) + | (1L << (WHERE - 61)) + | (1L << (CATCH - 61)) + | (1L << (FINALLY - 61)) + | (1L << (OUT - 61)) + | (1L << (DYNAMIC - 61)) + | (1L << (PUBLIC - 61)) + | (1L << (PRIVATE - 61)) + | (1L << (PROTECTED - 61)) + | (1L << (INTERNAL - 61)) + | (1L << (ENUM - 61)) + | (1L << (SEALED - 61)) + | (1L << (ANNOTATION - 61)) + | (1L << (DATA - 61)) + | (1L << (INNER - 61)) + | (1L << (VALUE - 61)) + | (1L << (TAILREC - 61)) + | (1L << (OPERATOR - 61)) + | (1L << (INLINE - 61)) + | (1L << (INFIX - 61)) + | (1L << (EXTERNAL - 61)) + | (1L << (SUSPEND - 61)) + | (1L << (OVERRIDE - 61)) + | (1L << (ABSTRACT - 61)))) + != 0) + || ((((_la - 125)) & ~0x3f) == 0 + && ((1L << (_la - 125)) + & ((1L << (FINAL - 125)) + | (1L << (OPEN - 125)) + | (1L << (CONST - 125)) + | (1L << (LATEINIT - 125)) + | (1L << (VARARG - 125)) + | (1L << (NOINLINE - 125)) + | (1L << (CROSSINLINE - 125)) + | (1L << (REIFIED - 125)) + | (1L << (EXPECT - 125)) + | (1L << (ACTUAL - 125)) + | (1L << (Identifier - 125)))) + != 0)) { + { + setState(2416); + label(); + } + } + + setState(2422); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2419); + match(NL); + } + } + setState(2424); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2425); + lambdaLiteral(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final TypeArgumentsContext typeArguments() throws RecognitionException { + TypeArgumentsContext _localctx = new TypeArgumentsContext(_ctx, getState()); + enterRule(_localctx, 204, RULE_typeArguments); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2427); + match(LANGLE); + setState(2431); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2428); + match(NL); + } + } + setState(2433); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2434); + typeProjection(); + setState(2451); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 366, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2438); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2435); + match(NL); + } + } + setState(2440); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2441); + match(COMMA); + setState(2445); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2442); + match(NL); + } + } + setState(2447); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2448); + typeProjection(); + } + } + } + setState(2453); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 366, _ctx); + } + setState(2461); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 368, _ctx)) { + case 1: + { + setState(2457); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2454); + match(NL); + } + } + setState(2459); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2460); + match(COMMA); + } + break; + } + setState(2466); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2463); + match(NL); + } + } + setState(2468); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2469); + match(RANGLE); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ValueArgumentsContext valueArguments() throws RecognitionException { + ValueArgumentsContext _localctx = new ValueArgumentsContext(_ctx, getState()); + enterRule(_localctx, 206, RULE_valueArguments); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2471); + match(LPAREN); + setState(2475); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 370, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2472); + match(NL); + } + } + } + setState(2477); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 370, _ctx); + } + setState(2513); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 + && ((1L << _la) + & ((1L << NL) + | (1L << LPAREN) + | (1L << LSQUARE) + | (1L << LCURL) + | (1L << MULT) + | (1L << ADD) + | (1L << SUB) + | (1L << INCR) + | (1L << DECR) + | (1L << EXCL_WS) + | (1L << EXCL_NO_WS) + | (1L << COLONCOLON) + | (1L << AT_NO_WS) + | (1L << AT_PRE_WS) + | (1L << RETURN_AT) + | (1L << CONTINUE_AT) + | (1L << BREAK_AT) + | (1L << THIS_AT) + | (1L << SUPER_AT) + | (1L << FILE) + | (1L << FIELD) + | (1L << PROPERTY))) + != 0) + || ((((_la - 64)) & ~0x3f) == 0 + && ((1L << (_la - 64)) + & ((1L << (GET - 64)) + | (1L << (SET - 64)) + | (1L << (RECEIVER - 64)) + | (1L << (PARAM - 64)) + | (1L << (SETPARAM - 64)) + | (1L << (DELEGATE - 64)) + | (1L << (IMPORT - 64)) + | (1L << (FUN - 64)) + | (1L << (OBJECT - 64)) + | (1L << (CONSTRUCTOR - 64)) + | (1L << (BY - 64)) + | (1L << (COMPANION - 64)) + | (1L << (INIT - 64)) + | (1L << (THIS - 64)) + | (1L << (SUPER - 64)) + | (1L << (WHERE - 64)) + | (1L << (IF - 64)) + | (1L << (WHEN - 64)) + | (1L << (TRY - 64)) + | (1L << (CATCH - 64)) + | (1L << (FINALLY - 64)) + | (1L << (THROW - 64)) + | (1L << (RETURN - 64)) + | (1L << (CONTINUE - 64)) + | (1L << (BREAK - 64)) + | (1L << (OUT - 64)) + | (1L << (DYNAMIC - 64)) + | (1L << (PUBLIC - 64)) + | (1L << (PRIVATE - 64)) + | (1L << (PROTECTED - 64)) + | (1L << (INTERNAL - 64)) + | (1L << (ENUM - 64)) + | (1L << (SEALED - 64)) + | (1L << (ANNOTATION - 64)) + | (1L << (DATA - 64)) + | (1L << (INNER - 64)) + | (1L << (VALUE - 64)) + | (1L << (TAILREC - 64)) + | (1L << (OPERATOR - 64)) + | (1L << (INLINE - 64)) + | (1L << (INFIX - 64)) + | (1L << (EXTERNAL - 64)) + | (1L << (SUSPEND - 64)) + | (1L << (OVERRIDE - 64)) + | (1L << (ABSTRACT - 64)) + | (1L << (FINAL - 64)) + | (1L << (OPEN - 64)) + | (1L << (CONST - 64)))) + != 0) + || ((((_la - 128)) & ~0x3f) == 0 + && ((1L << (_la - 128)) + & ((1L << (LATEINIT - 128)) + | (1L << (VARARG - 128)) + | (1L << (NOINLINE - 128)) + | (1L << (CROSSINLINE - 128)) + | (1L << (REIFIED - 128)) + | (1L << (EXPECT - 128)) + | (1L << (ACTUAL - 128)) + | (1L << (RealLiteral - 128)) + | (1L << (IntegerLiteral - 128)) + | (1L << (HexLiteral - 128)) + | (1L << (BinLiteral - 128)) + | (1L << (UnsignedLiteral - 128)) + | (1L << (LongLiteral - 128)) + | (1L << (BooleanLiteral - 128)) + | (1L << (NullLiteral - 128)) + | (1L << (CharacterLiteral - 128)) + | (1L << (Identifier - 128)) + | (1L << (QUOTE_OPEN - 128)) + | (1L << (TRIPLE_QUOTE_OPEN - 128)))) + != 0)) { + { + setState(2478); + valueArgument(); + setState(2495); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 373, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2482); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2479); + match(NL); + } + } + setState(2484); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2485); + match(COMMA); + setState(2489); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 372, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2486); + match(NL); + } + } + } + setState(2491); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 372, _ctx); + } + setState(2492); + valueArgument(); + } + } + } + setState(2497); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 373, _ctx); + } + setState(2505); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 375, _ctx)) { + case 1: + { + setState(2501); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2498); + match(NL); + } + } + setState(2503); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2504); + match(COMMA); + } + break; + } + setState(2510); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2507); + match(NL); + } + } + setState(2512); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + + setState(2515); + match(RPAREN); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ValueArgumentContext valueArgument() throws RecognitionException { + ValueArgumentContext _localctx = new ValueArgumentContext(_ctx, getState()); + enterRule(_localctx, 208, RULE_valueArgument); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2518); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 378, _ctx)) { + case 1: + { + setState(2517); + annotation(); + } + break; + } + setState(2523); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 379, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2520); + match(NL); + } + } + } + setState(2525); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 379, _ctx); + } + setState(2540); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 382, _ctx)) { + case 1: + { + setState(2526); + simpleIdentifier(); + setState(2530); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2527); + match(NL); + } + } + setState(2532); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2533); + match(ASSIGNMENT); + setState(2537); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 381, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2534); + match(NL); + } + } + } + setState(2539); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 381, _ctx); + } + } + break; + } + setState(2543); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == MULT) { + { + setState(2542); + match(MULT); + } + } + + setState(2548); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2545); + match(NL); + } + } + setState(2550); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2551); + expression(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final PrimaryExpressionContext primaryExpression() throws RecognitionException { + PrimaryExpressionContext _localctx = new PrimaryExpressionContext(_ctx, getState()); + enterRule(_localctx, 210, RULE_primaryExpression); + try { + setState(2567); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 385, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(2553); + parenthesizedExpression(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(2554); + simpleIdentifier(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(2555); + literalConstant(); + } + break; + case 4: + enterOuterAlt(_localctx, 4); + { + setState(2556); + stringLiteral(); + } + break; + case 5: + enterOuterAlt(_localctx, 5); + { + setState(2557); + callableReference(); + } + break; + case 6: + enterOuterAlt(_localctx, 6); + { + setState(2558); + functionLiteral(); + } + break; + case 7: + enterOuterAlt(_localctx, 7); + { + setState(2559); + objectLiteral(); + } + break; + case 8: + enterOuterAlt(_localctx, 8); + { + setState(2560); + collectionLiteral(); + } + break; + case 9: + enterOuterAlt(_localctx, 9); + { + setState(2561); + thisExpression(); + } + break; + case 10: + enterOuterAlt(_localctx, 10); + { + setState(2562); + superExpression(); + } + break; + case 11: + enterOuterAlt(_localctx, 11); + { + setState(2563); + ifExpression(); + } + break; + case 12: + enterOuterAlt(_localctx, 12); + { + setState(2564); + whenExpression(); + } + break; + case 13: + enterOuterAlt(_localctx, 13); + { + setState(2565); + tryExpression(); + } + break; + case 14: + enterOuterAlt(_localctx, 14); + { + setState(2566); + jumpExpression(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ParenthesizedExpressionContext parenthesizedExpression() + throws RecognitionException { + ParenthesizedExpressionContext _localctx = new ParenthesizedExpressionContext(_ctx, getState()); + enterRule(_localctx, 212, RULE_parenthesizedExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2569); + match(LPAREN); + setState(2573); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2570); + match(NL); + } + } + setState(2575); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2576); + expression(); + setState(2580); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2577); + match(NL); + } + } + setState(2582); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2583); + match(RPAREN); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final CollectionLiteralContext collectionLiteral() throws RecognitionException { + CollectionLiteralContext _localctx = new CollectionLiteralContext(_ctx, getState()); + enterRule(_localctx, 214, RULE_collectionLiteral); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2585); + match(LSQUARE); + setState(2589); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2586); + match(NL); + } + } + setState(2591); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2627); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 + && ((1L << _la) + & ((1L << LPAREN) + | (1L << LSQUARE) + | (1L << LCURL) + | (1L << ADD) + | (1L << SUB) + | (1L << INCR) + | (1L << DECR) + | (1L << EXCL_WS) + | (1L << EXCL_NO_WS) + | (1L << COLONCOLON) + | (1L << AT_NO_WS) + | (1L << AT_PRE_WS) + | (1L << RETURN_AT) + | (1L << CONTINUE_AT) + | (1L << BREAK_AT) + | (1L << THIS_AT) + | (1L << SUPER_AT) + | (1L << FILE) + | (1L << FIELD) + | (1L << PROPERTY))) + != 0) + || ((((_la - 64)) & ~0x3f) == 0 + && ((1L << (_la - 64)) + & ((1L << (GET - 64)) + | (1L << (SET - 64)) + | (1L << (RECEIVER - 64)) + | (1L << (PARAM - 64)) + | (1L << (SETPARAM - 64)) + | (1L << (DELEGATE - 64)) + | (1L << (IMPORT - 64)) + | (1L << (FUN - 64)) + | (1L << (OBJECT - 64)) + | (1L << (CONSTRUCTOR - 64)) + | (1L << (BY - 64)) + | (1L << (COMPANION - 64)) + | (1L << (INIT - 64)) + | (1L << (THIS - 64)) + | (1L << (SUPER - 64)) + | (1L << (WHERE - 64)) + | (1L << (IF - 64)) + | (1L << (WHEN - 64)) + | (1L << (TRY - 64)) + | (1L << (CATCH - 64)) + | (1L << (FINALLY - 64)) + | (1L << (THROW - 64)) + | (1L << (RETURN - 64)) + | (1L << (CONTINUE - 64)) + | (1L << (BREAK - 64)) + | (1L << (OUT - 64)) + | (1L << (DYNAMIC - 64)) + | (1L << (PUBLIC - 64)) + | (1L << (PRIVATE - 64)) + | (1L << (PROTECTED - 64)) + | (1L << (INTERNAL - 64)) + | (1L << (ENUM - 64)) + | (1L << (SEALED - 64)) + | (1L << (ANNOTATION - 64)) + | (1L << (DATA - 64)) + | (1L << (INNER - 64)) + | (1L << (VALUE - 64)) + | (1L << (TAILREC - 64)) + | (1L << (OPERATOR - 64)) + | (1L << (INLINE - 64)) + | (1L << (INFIX - 64)) + | (1L << (EXTERNAL - 64)) + | (1L << (SUSPEND - 64)) + | (1L << (OVERRIDE - 64)) + | (1L << (ABSTRACT - 64)) + | (1L << (FINAL - 64)) + | (1L << (OPEN - 64)) + | (1L << (CONST - 64)))) + != 0) + || ((((_la - 128)) & ~0x3f) == 0 + && ((1L << (_la - 128)) + & ((1L << (LATEINIT - 128)) + | (1L << (VARARG - 128)) + | (1L << (NOINLINE - 128)) + | (1L << (CROSSINLINE - 128)) + | (1L << (REIFIED - 128)) + | (1L << (EXPECT - 128)) + | (1L << (ACTUAL - 128)) + | (1L << (RealLiteral - 128)) + | (1L << (IntegerLiteral - 128)) + | (1L << (HexLiteral - 128)) + | (1L << (BinLiteral - 128)) + | (1L << (UnsignedLiteral - 128)) + | (1L << (LongLiteral - 128)) + | (1L << (BooleanLiteral - 128)) + | (1L << (NullLiteral - 128)) + | (1L << (CharacterLiteral - 128)) + | (1L << (Identifier - 128)) + | (1L << (QUOTE_OPEN - 128)) + | (1L << (TRIPLE_QUOTE_OPEN - 128)))) + != 0)) { + { + setState(2592); + expression(); + setState(2609); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 391, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2596); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2593); + match(NL); + } + } + setState(2598); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2599); + match(COMMA); + setState(2603); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2600); + match(NL); + } + } + setState(2605); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2606); + expression(); + } + } + } + setState(2611); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 391, _ctx); + } + setState(2619); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 393, _ctx)) { + case 1: + { + setState(2615); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2612); + match(NL); + } + } + setState(2617); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2618); + match(COMMA); + } + break; + } + setState(2624); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2621); + match(NL); + } + } + setState(2626); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + } + + setState(2629); + match(RSQUARE); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final LiteralConstantContext literalConstant() throws RecognitionException { + LiteralConstantContext _localctx = new LiteralConstantContext(_ctx, getState()); + enterRule(_localctx, 216, RULE_literalConstant); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2631); + _la = _input.LA(1); + if (!(((((_la - 135)) & ~0x3f) == 0 + && ((1L << (_la - 135)) + & ((1L << (RealLiteral - 135)) + | (1L << (IntegerLiteral - 135)) + | (1L << (HexLiteral - 135)) + | (1L << (BinLiteral - 135)) + | (1L << (UnsignedLiteral - 135)) + | (1L << (LongLiteral - 135)) + | (1L << (BooleanLiteral - 135)) + | (1L << (NullLiteral - 135)) + | (1L << (CharacterLiteral - 135)))) + != 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 final StringLiteralContext stringLiteral() throws RecognitionException { + StringLiteralContext _localctx = new StringLiteralContext(_ctx, getState()); + enterRule(_localctx, 218, RULE_stringLiteral); + try { + setState(2635); + _errHandler.sync(this); + switch (_input.LA(1)) { + case QUOTE_OPEN: + enterOuterAlt(_localctx, 1); + { + setState(2633); + lineStringLiteral(); + } + break; + case TRIPLE_QUOTE_OPEN: + enterOuterAlt(_localctx, 2); + { + setState(2634); + multiLineStringLiteral(); + } + 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 final LineStringLiteralContext lineStringLiteral() throws RecognitionException { + LineStringLiteralContext _localctx = new LineStringLiteralContext(_ctx, getState()); + enterRule(_localctx, 220, RULE_lineStringLiteral); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2637); + match(QUOTE_OPEN); + setState(2642); + _errHandler.sync(this); + _la = _input.LA(1); + while (((((_la - 159)) & ~0x3f) == 0 + && ((1L << (_la - 159)) + & ((1L << (LineStrRef - 159)) + | (1L << (LineStrText - 159)) + | (1L << (LineStrEscapedChar - 159)) + | (1L << (LineStrExprStart - 159)))) + != 0)) { + { + setState(2640); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LineStrRef: + case LineStrText: + case LineStrEscapedChar: + { + setState(2638); + lineStringContent(); + } + break; + case LineStrExprStart: + { + setState(2639); + lineStringExpression(); + } + break; + default: + throw new NoViableAltException(this); + } + } + setState(2644); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2645); + match(QUOTE_CLOSE); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final MultiLineStringLiteralContext multiLineStringLiteral() throws RecognitionException { + MultiLineStringLiteralContext _localctx = new MultiLineStringLiteralContext(_ctx, getState()); + enterRule(_localctx, 222, RULE_multiLineStringLiteral); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2647); + match(TRIPLE_QUOTE_OPEN); + setState(2653); + _errHandler.sync(this); + _la = _input.LA(1); + while (((((_la - 164)) & ~0x3f) == 0 + && ((1L << (_la - 164)) + & ((1L << (MultiLineStringQuote - 164)) + | (1L << (MultiLineStrRef - 164)) + | (1L << (MultiLineStrText - 164)) + | (1L << (MultiLineStrExprStart - 164)))) + != 0)) { + { + setState(2651); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 399, _ctx)) { + case 1: + { + setState(2648); + multiLineStringContent(); + } + break; + case 2: + { + setState(2649); + multiLineStringExpression(); + } + break; + case 3: + { + setState(2650); + match(MultiLineStringQuote); + } + break; + } + } + setState(2655); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2656); + match(TRIPLE_QUOTE_CLOSE); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final LineStringContentContext lineStringContent() throws RecognitionException { + LineStringContentContext _localctx = new LineStringContentContext(_ctx, getState()); + enterRule(_localctx, 224, RULE_lineStringContent); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2658); + _la = _input.LA(1); + if (!(((((_la - 159)) & ~0x3f) == 0 + && ((1L << (_la - 159)) + & ((1L << (LineStrRef - 159)) + | (1L << (LineStrText - 159)) + | (1L << (LineStrEscapedChar - 159)))) + != 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 final LineStringExpressionContext lineStringExpression() throws RecognitionException { + LineStringExpressionContext _localctx = new LineStringExpressionContext(_ctx, getState()); + enterRule(_localctx, 226, RULE_lineStringExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2660); + match(LineStrExprStart); + setState(2664); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2661); + match(NL); + } + } + setState(2666); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2667); + expression(); + setState(2671); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2668); + match(NL); + } + } + setState(2673); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2674); + match(RCURL); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final MultiLineStringContentContext multiLineStringContent() throws RecognitionException { + MultiLineStringContentContext _localctx = new MultiLineStringContentContext(_ctx, getState()); + enterRule(_localctx, 228, RULE_multiLineStringContent); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2676); + _la = _input.LA(1); + if (!(((((_la - 164)) & ~0x3f) == 0 + && ((1L << (_la - 164)) + & ((1L << (MultiLineStringQuote - 164)) + | (1L << (MultiLineStrRef - 164)) + | (1L << (MultiLineStrText - 164)))) + != 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 final MultiLineStringExpressionContext multiLineStringExpression() + throws RecognitionException { + MultiLineStringExpressionContext _localctx = + new MultiLineStringExpressionContext(_ctx, getState()); + enterRule(_localctx, 230, RULE_multiLineStringExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2678); + match(MultiLineStrExprStart); + setState(2682); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2679); + match(NL); + } + } + setState(2684); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2685); + expression(); + setState(2689); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2686); + match(NL); + } + } + setState(2691); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2692); + match(RCURL); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final LambdaLiteralContext lambdaLiteral() throws RecognitionException { + LambdaLiteralContext _localctx = new LambdaLiteralContext(_ctx, getState()); + enterRule(_localctx, 232, RULE_lambdaLiteral); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2694); + match(LCURL); + setState(2698); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 405, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2695); + match(NL); + } + } + } + setState(2700); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 405, _ctx); + } + setState(2717); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 409, _ctx)) { + case 1: + { + setState(2702); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 406, _ctx)) { + case 1: + { + setState(2701); + lambdaParameters(); + } + break; + } + setState(2707); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2704); + match(NL); + } + } + setState(2709); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2710); + match(ARROW); + setState(2714); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 408, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2711); + match(NL); + } + } + } + setState(2716); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 408, _ctx); + } + } + break; + } + setState(2719); + statements(); + setState(2723); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2720); + match(NL); + } + } + setState(2725); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2726); + match(RCURL); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final LambdaParametersContext lambdaParameters() throws RecognitionException { + LambdaParametersContext _localctx = new LambdaParametersContext(_ctx, getState()); + enterRule(_localctx, 234, RULE_lambdaParameters); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2728); + lambdaParameter(); + setState(2745); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 413, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2732); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2729); + match(NL); + } + } + setState(2734); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2735); + match(COMMA); + setState(2739); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 412, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2736); + match(NL); + } + } + } + setState(2741); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 412, _ctx); + } + setState(2742); + lambdaParameter(); + } + } + } + setState(2747); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 413, _ctx); + } + setState(2755); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 415, _ctx)) { + case 1: + { + setState(2751); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2748); + match(NL); + } + } + setState(2753); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2754); + match(COMMA); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final LambdaParameterContext lambdaParameter() throws RecognitionException { + LambdaParameterContext _localctx = new LambdaParameterContext(_ctx, getState()); + enterRule(_localctx, 236, RULE_lambdaParameter); + int _la; + try { + setState(2775); + _errHandler.sync(this); + switch (_input.LA(1)) { + case NL: + case AT_NO_WS: + case AT_PRE_WS: + case FILE: + case FIELD: + case PROPERTY: + case GET: + case SET: + case RECEIVER: + case PARAM: + case SETPARAM: + case DELEGATE: + case IMPORT: + case CONSTRUCTOR: + case BY: + case COMPANION: + case INIT: + case WHERE: + case CATCH: + case FINALLY: + case OUT: + case DYNAMIC: + case PUBLIC: + case PRIVATE: + case PROTECTED: + case INTERNAL: + case ENUM: + case SEALED: + case ANNOTATION: + case DATA: + case INNER: + case VALUE: + case TAILREC: + case OPERATOR: + case INLINE: + case INFIX: + case EXTERNAL: + case SUSPEND: + case OVERRIDE: + case ABSTRACT: + case FINAL: + case OPEN: + case CONST: + case LATEINIT: + case VARARG: + case NOINLINE: + case CROSSINLINE: + case REIFIED: + case EXPECT: + case ACTUAL: + case Identifier: + enterOuterAlt(_localctx, 1); + { + setState(2757); + variableDeclaration(); + } + break; + case LPAREN: + enterOuterAlt(_localctx, 2); + { + setState(2758); + multiVariableDeclaration(); + setState(2773); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 418, _ctx)) { + case 1: + { + setState(2762); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2759); + match(NL); + } + } + setState(2764); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2765); + match(COLON); + setState(2769); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2766); + match(NL); + } + } + setState(2771); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2772); + type(); + } + 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 final AnonymousFunctionContext anonymousFunction() throws RecognitionException { + AnonymousFunctionContext _localctx = new AnonymousFunctionContext(_ctx, getState()); + enterRule(_localctx, 238, RULE_anonymousFunction); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2777); + match(FUN); + setState(2793); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 422, _ctx)) { + case 1: + { + setState(2781); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2778); + match(NL); + } + } + setState(2783); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2784); + type(); + setState(2788); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2785); + match(NL); + } + } + setState(2790); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2791); + match(DOT); + } + break; + } + setState(2798); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2795); + match(NL); + } + } + setState(2800); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2801); + parametersWithOptionalType(); + setState(2816); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 426, _ctx)) { + case 1: + { + setState(2805); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2802); + match(NL); + } + } + setState(2807); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2808); + match(COLON); + setState(2812); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2809); + match(NL); + } + } + setState(2814); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2815); + type(); + } + break; + } + setState(2825); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 428, _ctx)) { + case 1: + { + setState(2821); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2818); + match(NL); + } + } + setState(2823); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2824); + typeConstraints(); + } + break; + } + setState(2834); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 430, _ctx)) { + case 1: + { + setState(2830); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2827); + match(NL); + } + } + setState(2832); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2833); + functionBody(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final FunctionLiteralContext functionLiteral() throws RecognitionException { + FunctionLiteralContext _localctx = new FunctionLiteralContext(_ctx, getState()); + enterRule(_localctx, 240, RULE_functionLiteral); + try { + setState(2838); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LCURL: + enterOuterAlt(_localctx, 1); + { + setState(2836); + lambdaLiteral(); + } + break; + case FUN: + enterOuterAlt(_localctx, 2); + { + setState(2837); + anonymousFunction(); + } + 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 final ObjectLiteralContext objectLiteral() throws RecognitionException { + ObjectLiteralContext _localctx = new ObjectLiteralContext(_ctx, getState()); + enterRule(_localctx, 242, RULE_objectLiteral); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2840); + match(OBJECT); + setState(2861); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 435, _ctx)) { + case 1: + { + setState(2844); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2841); + match(NL); + } + } + setState(2846); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2847); + match(COLON); + setState(2851); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 433, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2848); + match(NL); + } + } + } + setState(2853); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 433, _ctx); + } + setState(2854); + delegationSpecifiers(); + setState(2858); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 434, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2855); + match(NL); + } + } + } + setState(2860); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 434, _ctx); + } + } + break; + } + setState(2870); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 437, _ctx)) { + case 1: + { + setState(2866); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2863); + match(NL); + } + } + setState(2868); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2869); + classBody(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ThisExpressionContext thisExpression() throws RecognitionException { + ThisExpressionContext _localctx = new ThisExpressionContext(_ctx, getState()); + enterRule(_localctx, 244, RULE_thisExpression); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(2872); + _la = _input.LA(1); + if (!(_la == THIS_AT || _la == THIS)) { + _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 final SuperExpressionContext superExpression() throws RecognitionException { + SuperExpressionContext _localctx = new SuperExpressionContext(_ctx, getState()); + enterRule(_localctx, 246, RULE_superExpression); + int _la; + try { + setState(2898); + _errHandler.sync(this); + switch (_input.LA(1)) { + case SUPER: + enterOuterAlt(_localctx, 1); + { + setState(2874); + match(SUPER); + setState(2891); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 440, _ctx)) { + case 1: + { + setState(2875); + match(LANGLE); + setState(2879); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2876); + match(NL); + } + } + setState(2881); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2882); + type(); + setState(2886); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2883); + match(NL); + } + } + setState(2888); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2889); + match(RANGLE); + } + break; + } + setState(2895); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 441, _ctx)) { + case 1: + { + setState(2893); + match(AT_NO_WS); + setState(2894); + simpleIdentifier(); + } + break; + } + } + break; + case SUPER_AT: + enterOuterAlt(_localctx, 2); + { + setState(2897); + match(SUPER_AT); + } + 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 final IfExpressionContext ifExpression() throws RecognitionException { + IfExpressionContext _localctx = new IfExpressionContext(_ctx, getState()); + enterRule(_localctx, 248, RULE_ifExpression); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2900); + match(IF); + setState(2904); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2901); + match(NL); + } + } + setState(2906); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2907); + match(LPAREN); + setState(2911); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2908); + match(NL); + } + } + setState(2913); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2914); + expression(); + setState(2918); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2915); + match(NL); + } + } + setState(2920); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2921); + match(RPAREN); + setState(2925); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 446, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2922); + match(NL); + } + } + } + setState(2927); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 446, _ctx); + } + setState(2959); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 453, _ctx)) { + case 1: + { + setState(2928); + controlStructureBody(); + } + break; + case 2: + { + setState(2930); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 + && ((1L << _la) + & ((1L << LPAREN) + | (1L << LSQUARE) + | (1L << LCURL) + | (1L << ADD) + | (1L << SUB) + | (1L << INCR) + | (1L << DECR) + | (1L << EXCL_WS) + | (1L << EXCL_NO_WS) + | (1L << COLONCOLON) + | (1L << AT_NO_WS) + | (1L << AT_PRE_WS) + | (1L << RETURN_AT) + | (1L << CONTINUE_AT) + | (1L << BREAK_AT) + | (1L << THIS_AT) + | (1L << SUPER_AT) + | (1L << FILE) + | (1L << FIELD) + | (1L << PROPERTY))) + != 0) + || ((((_la - 64)) & ~0x3f) == 0 + && ((1L << (_la - 64)) + & ((1L << (GET - 64)) + | (1L << (SET - 64)) + | (1L << (RECEIVER - 64)) + | (1L << (PARAM - 64)) + | (1L << (SETPARAM - 64)) + | (1L << (DELEGATE - 64)) + | (1L << (IMPORT - 64)) + | (1L << (CLASS - 64)) + | (1L << (INTERFACE - 64)) + | (1L << (FUN - 64)) + | (1L << (OBJECT - 64)) + | (1L << (VAL - 64)) + | (1L << (VAR - 64)) + | (1L << (TYPE_ALIAS - 64)) + | (1L << (CONSTRUCTOR - 64)) + | (1L << (BY - 64)) + | (1L << (COMPANION - 64)) + | (1L << (INIT - 64)) + | (1L << (THIS - 64)) + | (1L << (SUPER - 64)) + | (1L << (WHERE - 64)) + | (1L << (IF - 64)) + | (1L << (WHEN - 64)) + | (1L << (TRY - 64)) + | (1L << (CATCH - 64)) + | (1L << (FINALLY - 64)) + | (1L << (FOR - 64)) + | (1L << (DO - 64)) + | (1L << (WHILE - 64)) + | (1L << (THROW - 64)) + | (1L << (RETURN - 64)) + | (1L << (CONTINUE - 64)) + | (1L << (BREAK - 64)) + | (1L << (OUT - 64)) + | (1L << (DYNAMIC - 64)) + | (1L << (PUBLIC - 64)) + | (1L << (PRIVATE - 64)) + | (1L << (PROTECTED - 64)) + | (1L << (INTERNAL - 64)) + | (1L << (ENUM - 64)) + | (1L << (SEALED - 64)) + | (1L << (ANNOTATION - 64)) + | (1L << (DATA - 64)) + | (1L << (INNER - 64)) + | (1L << (VALUE - 64)) + | (1L << (TAILREC - 64)) + | (1L << (OPERATOR - 64)) + | (1L << (INLINE - 64)) + | (1L << (INFIX - 64)) + | (1L << (EXTERNAL - 64)) + | (1L << (SUSPEND - 64)) + | (1L << (OVERRIDE - 64)) + | (1L << (ABSTRACT - 64)) + | (1L << (FINAL - 64)) + | (1L << (OPEN - 64)) + | (1L << (CONST - 64)))) + != 0) + || ((((_la - 128)) & ~0x3f) == 0 + && ((1L << (_la - 128)) + & ((1L << (LATEINIT - 128)) + | (1L << (VARARG - 128)) + | (1L << (NOINLINE - 128)) + | (1L << (CROSSINLINE - 128)) + | (1L << (REIFIED - 128)) + | (1L << (EXPECT - 128)) + | (1L << (ACTUAL - 128)) + | (1L << (RealLiteral - 128)) + | (1L << (IntegerLiteral - 128)) + | (1L << (HexLiteral - 128)) + | (1L << (BinLiteral - 128)) + | (1L << (UnsignedLiteral - 128)) + | (1L << (LongLiteral - 128)) + | (1L << (BooleanLiteral - 128)) + | (1L << (NullLiteral - 128)) + | (1L << (CharacterLiteral - 128)) + | (1L << (Identifier - 128)) + | (1L << (QUOTE_OPEN - 128)) + | (1L << (TRIPLE_QUOTE_OPEN - 128)))) + != 0)) { + { + setState(2929); + controlStructureBody(); + } + } + + setState(2935); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 448, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2932); + match(NL); + } + } + } + setState(2937); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 448, _ctx); + } + setState(2939); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == SEMICOLON) { + { + setState(2938); + match(SEMICOLON); + } + } + + setState(2944); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2941); + match(NL); + } + } + setState(2946); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2947); + match(ELSE); + setState(2951); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2948); + match(NL); + } + } + setState(2953); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2956); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LPAREN: + case LSQUARE: + case LCURL: + case ADD: + case SUB: + case INCR: + case DECR: + case EXCL_WS: + case EXCL_NO_WS: + case COLONCOLON: + case AT_NO_WS: + case AT_PRE_WS: + case RETURN_AT: + case CONTINUE_AT: + case BREAK_AT: + case THIS_AT: + case SUPER_AT: + case FILE: + case FIELD: + case PROPERTY: + case GET: + case SET: + case RECEIVER: + case PARAM: + case SETPARAM: + case DELEGATE: + case IMPORT: + case CLASS: + case INTERFACE: + case FUN: + case OBJECT: + case VAL: + case VAR: + case TYPE_ALIAS: + case CONSTRUCTOR: + case BY: + case COMPANION: + case INIT: + case THIS: + case SUPER: + case WHERE: + case IF: + case WHEN: + case TRY: + case CATCH: + case FINALLY: + case FOR: + case DO: + case WHILE: + case THROW: + case RETURN: + case CONTINUE: + case BREAK: + case OUT: + case DYNAMIC: + case PUBLIC: + case PRIVATE: + case PROTECTED: + case INTERNAL: + case ENUM: + case SEALED: + case ANNOTATION: + case DATA: + case INNER: + case VALUE: + case TAILREC: + case OPERATOR: + case INLINE: + case INFIX: + case EXTERNAL: + case SUSPEND: + case OVERRIDE: + case ABSTRACT: + case FINAL: + case OPEN: + case CONST: + case LATEINIT: + case VARARG: + case NOINLINE: + case CROSSINLINE: + case REIFIED: + case EXPECT: + case ACTUAL: + case RealLiteral: + case IntegerLiteral: + case HexLiteral: + case BinLiteral: + case UnsignedLiteral: + case LongLiteral: + case BooleanLiteral: + case NullLiteral: + case CharacterLiteral: + case Identifier: + case QUOTE_OPEN: + case TRIPLE_QUOTE_OPEN: + { + setState(2954); + controlStructureBody(); + } + break; + case SEMICOLON: + { + setState(2955); + match(SEMICOLON); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + case 3: + { + setState(2958); + match(SEMICOLON); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final WhenSubjectContext whenSubject() throws RecognitionException { + WhenSubjectContext _localctx = new WhenSubjectContext(_ctx, getState()); + enterRule(_localctx, 250, RULE_whenSubject); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(2961); + match(LPAREN); + setState(2995); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 459, _ctx)) { + case 1: + { + setState(2965); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == AT_NO_WS || _la == AT_PRE_WS) { + { + { + setState(2962); + annotation(); + } + } + setState(2967); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2971); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2968); + match(NL); + } + } + setState(2973); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2974); + match(VAL); + setState(2978); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 456, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(2975); + match(NL); + } + } + } + setState(2980); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 456, _ctx); + } + setState(2981); + variableDeclaration(); + setState(2985); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2982); + match(NL); + } + } + setState(2987); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(2988); + match(ASSIGNMENT); + setState(2992); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(2989); + match(NL); + } + } + setState(2994); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + } + setState(2997); + expression(); + setState(2998); + match(RPAREN); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final WhenExpressionContext whenExpression() throws RecognitionException { + WhenExpressionContext _localctx = new WhenExpressionContext(_ctx, getState()); + enterRule(_localctx, 252, RULE_whenExpression); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(3000); + match(WHEN); + setState(3004); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 460, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(3001); + match(NL); + } + } + } + setState(3006); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 460, _ctx); + } + setState(3008); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == LPAREN) { + { + setState(3007); + whenSubject(); + } + } + + setState(3013); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(3010); + match(NL); + } + } + setState(3015); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3016); + match(LCURL); + setState(3020); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 463, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(3017); + match(NL); + } + } + } + setState(3022); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 463, _ctx); + } + setState(3032); + _errHandler.sync(this); + _la = _input.LA(1); + while ((((_la) & ~0x3f) == 0 + && ((1L << _la) + & ((1L << LPAREN) + | (1L << LSQUARE) + | (1L << LCURL) + | (1L << ADD) + | (1L << SUB) + | (1L << INCR) + | (1L << DECR) + | (1L << EXCL_WS) + | (1L << EXCL_NO_WS) + | (1L << COLONCOLON) + | (1L << AT_NO_WS) + | (1L << AT_PRE_WS) + | (1L << RETURN_AT) + | (1L << CONTINUE_AT) + | (1L << BREAK_AT) + | (1L << THIS_AT) + | (1L << SUPER_AT) + | (1L << FILE) + | (1L << FIELD) + | (1L << PROPERTY))) + != 0) + || ((((_la - 64)) & ~0x3f) == 0 + && ((1L << (_la - 64)) + & ((1L << (GET - 64)) + | (1L << (SET - 64)) + | (1L << (RECEIVER - 64)) + | (1L << (PARAM - 64)) + | (1L << (SETPARAM - 64)) + | (1L << (DELEGATE - 64)) + | (1L << (IMPORT - 64)) + | (1L << (FUN - 64)) + | (1L << (OBJECT - 64)) + | (1L << (CONSTRUCTOR - 64)) + | (1L << (BY - 64)) + | (1L << (COMPANION - 64)) + | (1L << (INIT - 64)) + | (1L << (THIS - 64)) + | (1L << (SUPER - 64)) + | (1L << (WHERE - 64)) + | (1L << (IF - 64)) + | (1L << (ELSE - 64)) + | (1L << (WHEN - 64)) + | (1L << (TRY - 64)) + | (1L << (CATCH - 64)) + | (1L << (FINALLY - 64)) + | (1L << (THROW - 64)) + | (1L << (RETURN - 64)) + | (1L << (CONTINUE - 64)) + | (1L << (BREAK - 64)) + | (1L << (IS - 64)) + | (1L << (IN - 64)) + | (1L << (NOT_IS - 64)) + | (1L << (NOT_IN - 64)) + | (1L << (OUT - 64)) + | (1L << (DYNAMIC - 64)) + | (1L << (PUBLIC - 64)) + | (1L << (PRIVATE - 64)) + | (1L << (PROTECTED - 64)) + | (1L << (INTERNAL - 64)) + | (1L << (ENUM - 64)) + | (1L << (SEALED - 64)) + | (1L << (ANNOTATION - 64)) + | (1L << (DATA - 64)) + | (1L << (INNER - 64)) + | (1L << (VALUE - 64)) + | (1L << (TAILREC - 64)) + | (1L << (OPERATOR - 64)) + | (1L << (INLINE - 64)) + | (1L << (INFIX - 64)) + | (1L << (EXTERNAL - 64)) + | (1L << (SUSPEND - 64)) + | (1L << (OVERRIDE - 64)) + | (1L << (ABSTRACT - 64)) + | (1L << (FINAL - 64)) + | (1L << (OPEN - 64)) + | (1L << (CONST - 64)))) + != 0) + || ((((_la - 128)) & ~0x3f) == 0 + && ((1L << (_la - 128)) + & ((1L << (LATEINIT - 128)) + | (1L << (VARARG - 128)) + | (1L << (NOINLINE - 128)) + | (1L << (CROSSINLINE - 128)) + | (1L << (REIFIED - 128)) + | (1L << (EXPECT - 128)) + | (1L << (ACTUAL - 128)) + | (1L << (RealLiteral - 128)) + | (1L << (IntegerLiteral - 128)) + | (1L << (HexLiteral - 128)) + | (1L << (BinLiteral - 128)) + | (1L << (UnsignedLiteral - 128)) + | (1L << (LongLiteral - 128)) + | (1L << (BooleanLiteral - 128)) + | (1L << (NullLiteral - 128)) + | (1L << (CharacterLiteral - 128)) + | (1L << (Identifier - 128)) + | (1L << (QUOTE_OPEN - 128)) + | (1L << (TRIPLE_QUOTE_OPEN - 128)))) + != 0)) { + { + { + setState(3023); + whenEntry(); + setState(3027); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 464, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(3024); + match(NL); + } + } + } + setState(3029); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 464, _ctx); + } + } + } + setState(3034); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3038); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(3035); + match(NL); + } + } + setState(3040); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3041); + match(RCURL); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final WhenEntryContext whenEntry() throws RecognitionException { + WhenEntryContext _localctx = new WhenEntryContext(_ctx, getState()); + enterRule(_localctx, 254, RULE_whenEntry); + int _la; + try { + int _alt; + setState(3107); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LPAREN: + case LSQUARE: + case LCURL: + case ADD: + case SUB: + case INCR: + case DECR: + case EXCL_WS: + case EXCL_NO_WS: + case COLONCOLON: + case AT_NO_WS: + case AT_PRE_WS: + case RETURN_AT: + case CONTINUE_AT: + case BREAK_AT: + case THIS_AT: + case SUPER_AT: + case FILE: + case FIELD: + case PROPERTY: + case GET: + case SET: + case RECEIVER: + case PARAM: + case SETPARAM: + case DELEGATE: + case IMPORT: + case FUN: + case OBJECT: + case CONSTRUCTOR: + case BY: + case COMPANION: + case INIT: + case THIS: + case SUPER: + case WHERE: + case IF: + case WHEN: + case TRY: + case CATCH: + case FINALLY: + case THROW: + case RETURN: + case CONTINUE: + case BREAK: + case IS: + case IN: + case NOT_IS: + case NOT_IN: + case OUT: + case DYNAMIC: + case PUBLIC: + case PRIVATE: + case PROTECTED: + case INTERNAL: + case ENUM: + case SEALED: + case ANNOTATION: + case DATA: + case INNER: + case VALUE: + case TAILREC: + case OPERATOR: + case INLINE: + case INFIX: + case EXTERNAL: + case SUSPEND: + case OVERRIDE: + case ABSTRACT: + case FINAL: + case OPEN: + case CONST: + case LATEINIT: + case VARARG: + case NOINLINE: + case CROSSINLINE: + case REIFIED: + case EXPECT: + case ACTUAL: + case RealLiteral: + case IntegerLiteral: + case HexLiteral: + case BinLiteral: + case UnsignedLiteral: + case LongLiteral: + case BooleanLiteral: + case NullLiteral: + case CharacterLiteral: + case Identifier: + case QUOTE_OPEN: + case TRIPLE_QUOTE_OPEN: + enterOuterAlt(_localctx, 1); + { + setState(3043); + whenCondition(); + setState(3060); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 469, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(3047); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(3044); + match(NL); + } + } + setState(3049); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3050); + match(COMMA); + setState(3054); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(3051); + match(NL); + } + } + setState(3056); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3057); + whenCondition(); + } + } + } + setState(3062); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 469, _ctx); + } + setState(3070); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 471, _ctx)) { + case 1: + { + setState(3066); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(3063); + match(NL); + } + } + setState(3068); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3069); + match(COMMA); + } + break; + } + setState(3075); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(3072); + match(NL); + } + } + setState(3077); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3078); + match(ARROW); + setState(3082); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(3079); + match(NL); + } + } + setState(3084); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3085); + controlStructureBody(); + setState(3087); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 474, _ctx)) { + case 1: + { + setState(3086); + semi(); + } + break; + } + } + break; + case ELSE: + enterOuterAlt(_localctx, 2); + { + setState(3089); + match(ELSE); + setState(3093); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(3090); + match(NL); + } + } + setState(3095); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3096); + match(ARROW); + setState(3100); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(3097); + match(NL); + } + } + setState(3102); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3103); + controlStructureBody(); + setState(3105); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 477, _ctx)) { + case 1: + { + setState(3104); + semi(); + } + 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 final WhenConditionContext whenCondition() throws RecognitionException { + WhenConditionContext _localctx = new WhenConditionContext(_ctx, getState()); + enterRule(_localctx, 256, RULE_whenCondition); + try { + setState(3112); + _errHandler.sync(this); + switch (_input.LA(1)) { + case LPAREN: + case LSQUARE: + case LCURL: + case ADD: + case SUB: + case INCR: + case DECR: + case EXCL_WS: + case EXCL_NO_WS: + case COLONCOLON: + case AT_NO_WS: + case AT_PRE_WS: + case RETURN_AT: + case CONTINUE_AT: + case BREAK_AT: + case THIS_AT: + case SUPER_AT: + case FILE: + case FIELD: + case PROPERTY: + case GET: + case SET: + case RECEIVER: + case PARAM: + case SETPARAM: + case DELEGATE: + case IMPORT: + case FUN: + case OBJECT: + case CONSTRUCTOR: + case BY: + case COMPANION: + case INIT: + case THIS: + case SUPER: + case WHERE: + case IF: + case WHEN: + case TRY: + case CATCH: + case FINALLY: + case THROW: + case RETURN: + case CONTINUE: + case BREAK: + case OUT: + case DYNAMIC: + case PUBLIC: + case PRIVATE: + case PROTECTED: + case INTERNAL: + case ENUM: + case SEALED: + case ANNOTATION: + case DATA: + case INNER: + case VALUE: + case TAILREC: + case OPERATOR: + case INLINE: + case INFIX: + case EXTERNAL: + case SUSPEND: + case OVERRIDE: + case ABSTRACT: + case FINAL: + case OPEN: + case CONST: + case LATEINIT: + case VARARG: + case NOINLINE: + case CROSSINLINE: + case REIFIED: + case EXPECT: + case ACTUAL: + case RealLiteral: + case IntegerLiteral: + case HexLiteral: + case BinLiteral: + case UnsignedLiteral: + case LongLiteral: + case BooleanLiteral: + case NullLiteral: + case CharacterLiteral: + case Identifier: + case QUOTE_OPEN: + case TRIPLE_QUOTE_OPEN: + enterOuterAlt(_localctx, 1); + { + setState(3109); + expression(); + } + break; + case IN: + case NOT_IN: + enterOuterAlt(_localctx, 2); + { + setState(3110); + rangeTest(); + } + break; + case IS: + case NOT_IS: + enterOuterAlt(_localctx, 3); + { + setState(3111); + typeTest(); + } + 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 final RangeTestContext rangeTest() throws RecognitionException { + RangeTestContext _localctx = new RangeTestContext(_ctx, getState()); + enterRule(_localctx, 258, RULE_rangeTest); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3114); + inOperator(); + setState(3118); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(3115); + match(NL); + } + } + setState(3120); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3121); + expression(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final TypeTestContext typeTest() throws RecognitionException { + TypeTestContext _localctx = new TypeTestContext(_ctx, getState()); + enterRule(_localctx, 260, RULE_typeTest); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3123); + isOperator(); + setState(3127); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(3124); + match(NL); + } + } + setState(3129); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3130); + type(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final TryExpressionContext tryExpression() throws RecognitionException { + TryExpressionContext _localctx = new TryExpressionContext(_ctx, getState()); + enterRule(_localctx, 262, RULE_tryExpression); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(3132); + match(TRY); + setState(3136); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(3133); + match(NL); + } + } + setState(3138); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3139); + block(); + setState(3167); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 488, _ctx)) { + case 1: + { + setState(3147); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(3143); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(3140); + match(NL); + } + } + setState(3145); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3146); + catchBlock(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(3149); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 484, _ctx); + } while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER); + setState(3158); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 486, _ctx)) { + case 1: + { + setState(3154); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(3151); + match(NL); + } + } + setState(3156); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3157); + finallyBlock(); + } + break; + } + } + break; + case 2: + { + setState(3163); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(3160); + match(NL); + } + } + setState(3165); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3166); + finallyBlock(); + } + break; + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final CatchBlockContext catchBlock() throws RecognitionException { + CatchBlockContext _localctx = new CatchBlockContext(_ctx, getState()); + enterRule(_localctx, 264, RULE_catchBlock); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3169); + match(CATCH); + setState(3173); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(3170); + match(NL); + } + } + setState(3175); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3176); + match(LPAREN); + setState(3180); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == AT_NO_WS || _la == AT_PRE_WS) { + { + { + setState(3177); + annotation(); + } + } + setState(3182); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3183); + simpleIdentifier(); + setState(3184); + match(COLON); + setState(3185); + type(); + setState(3193); + _errHandler.sync(this); + _la = _input.LA(1); + if (_la == NL || _la == COMMA) { + { + setState(3189); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(3186); + match(NL); + } + } + setState(3191); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3192); + match(COMMA); + } + } + + setState(3195); + match(RPAREN); + setState(3199); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(3196); + match(NL); + } + } + setState(3201); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3202); + block(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final FinallyBlockContext finallyBlock() throws RecognitionException { + FinallyBlockContext _localctx = new FinallyBlockContext(_ctx, getState()); + enterRule(_localctx, 266, RULE_finallyBlock); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3204); + match(FINALLY); + setState(3208); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(3205); + match(NL); + } + } + setState(3210); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3211); + block(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final JumpExpressionContext jumpExpression() throws RecognitionException { + JumpExpressionContext _localctx = new JumpExpressionContext(_ctx, getState()); + enterRule(_localctx, 268, RULE_jumpExpression); + int _la; + try { + setState(3229); + _errHandler.sync(this); + switch (_input.LA(1)) { + case THROW: + enterOuterAlt(_localctx, 1); + { + setState(3213); + match(THROW); + setState(3217); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(3214); + match(NL); + } + } + setState(3219); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3220); + expression(); + } + break; + case RETURN_AT: + case RETURN: + enterOuterAlt(_localctx, 2); + { + setState(3221); + _la = _input.LA(1); + if (!(_la == RETURN_AT || _la == RETURN)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(3223); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 496, _ctx)) { + case 1: + { + setState(3222); + expression(); + } + break; + } + } + break; + case CONTINUE: + enterOuterAlt(_localctx, 3); + { + setState(3225); + match(CONTINUE); + } + break; + case CONTINUE_AT: + enterOuterAlt(_localctx, 4); + { + setState(3226); + match(CONTINUE_AT); + } + break; + case BREAK: + enterOuterAlt(_localctx, 5); + { + setState(3227); + match(BREAK); + } + break; + case BREAK_AT: + enterOuterAlt(_localctx, 6); + { + setState(3228); + match(BREAK_AT); + } + 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 final CallableReferenceContext callableReference() throws RecognitionException { + CallableReferenceContext _localctx = new CallableReferenceContext(_ctx, getState()); + enterRule(_localctx, 270, RULE_callableReference); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3232); + _errHandler.sync(this); + _la = _input.LA(1); + if ((((_la) & ~0x3f) == 0 + && ((1L << _la) + & ((1L << LPAREN) + | (1L << AT_NO_WS) + | (1L << AT_PRE_WS) + | (1L << FILE) + | (1L << FIELD) + | (1L << PROPERTY))) + != 0) + || ((((_la - 64)) & ~0x3f) == 0 + && ((1L << (_la - 64)) + & ((1L << (GET - 64)) + | (1L << (SET - 64)) + | (1L << (RECEIVER - 64)) + | (1L << (PARAM - 64)) + | (1L << (SETPARAM - 64)) + | (1L << (DELEGATE - 64)) + | (1L << (IMPORT - 64)) + | (1L << (CONSTRUCTOR - 64)) + | (1L << (BY - 64)) + | (1L << (COMPANION - 64)) + | (1L << (INIT - 64)) + | (1L << (WHERE - 64)) + | (1L << (CATCH - 64)) + | (1L << (FINALLY - 64)) + | (1L << (OUT - 64)) + | (1L << (DYNAMIC - 64)) + | (1L << (PUBLIC - 64)) + | (1L << (PRIVATE - 64)) + | (1L << (PROTECTED - 64)) + | (1L << (INTERNAL - 64)) + | (1L << (ENUM - 64)) + | (1L << (SEALED - 64)) + | (1L << (ANNOTATION - 64)) + | (1L << (DATA - 64)) + | (1L << (INNER - 64)) + | (1L << (VALUE - 64)) + | (1L << (TAILREC - 64)) + | (1L << (OPERATOR - 64)) + | (1L << (INLINE - 64)) + | (1L << (INFIX - 64)) + | (1L << (EXTERNAL - 64)) + | (1L << (SUSPEND - 64)) + | (1L << (OVERRIDE - 64)) + | (1L << (ABSTRACT - 64)) + | (1L << (FINAL - 64)) + | (1L << (OPEN - 64)) + | (1L << (CONST - 64)))) + != 0) + || ((((_la - 128)) & ~0x3f) == 0 + && ((1L << (_la - 128)) + & ((1L << (LATEINIT - 128)) + | (1L << (VARARG - 128)) + | (1L << (NOINLINE - 128)) + | (1L << (CROSSINLINE - 128)) + | (1L << (REIFIED - 128)) + | (1L << (EXPECT - 128)) + | (1L << (ACTUAL - 128)) + | (1L << (Identifier - 128)))) + != 0)) { + { + setState(3231); + receiverType(); + } + } + + setState(3234); + match(COLONCOLON); + setState(3238); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(3235); + match(NL); + } + } + setState(3240); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3243); + _errHandler.sync(this); + switch (_input.LA(1)) { + case FILE: + case FIELD: + case PROPERTY: + case GET: + case SET: + case RECEIVER: + case PARAM: + case SETPARAM: + case DELEGATE: + case IMPORT: + case CONSTRUCTOR: + case BY: + case COMPANION: + case INIT: + case WHERE: + case CATCH: + case FINALLY: + case OUT: + case DYNAMIC: + case PUBLIC: + case PRIVATE: + case PROTECTED: + case INTERNAL: + case ENUM: + case SEALED: + case ANNOTATION: + case DATA: + case INNER: + case VALUE: + case TAILREC: + case OPERATOR: + case INLINE: + case INFIX: + case EXTERNAL: + case SUSPEND: + case OVERRIDE: + case ABSTRACT: + case FINAL: + case OPEN: + case CONST: + case LATEINIT: + case VARARG: + case NOINLINE: + case CROSSINLINE: + case REIFIED: + case EXPECT: + case ACTUAL: + case Identifier: + { + setState(3241); + simpleIdentifier(); + } + break; + case CLASS: + { + setState(3242); + match(CLASS); + } + 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 final AssignmentAndOperatorContext assignmentAndOperator() throws RecognitionException { + AssignmentAndOperatorContext _localctx = new AssignmentAndOperatorContext(_ctx, getState()); + enterRule(_localctx, 272, RULE_assignmentAndOperator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3245); + _la = _input.LA(1); + if (!((((_la) & ~0x3f) == 0 + && ((1L << _la) + & ((1L << ADD_ASSIGNMENT) + | (1L << SUB_ASSIGNMENT) + | (1L << MULT_ASSIGNMENT) + | (1L << DIV_ASSIGNMENT) + | (1L << MOD_ASSIGNMENT))) + != 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 final EqualityOperatorContext equalityOperator() throws RecognitionException { + EqualityOperatorContext _localctx = new EqualityOperatorContext(_ctx, getState()); + enterRule(_localctx, 274, RULE_equalityOperator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3247); + _la = _input.LA(1); + if (!((((_la) & ~0x3f) == 0 + && ((1L << _la) & ((1L << EXCL_EQ) | (1L << EXCL_EQEQ) | (1L << EQEQ) | (1L << EQEQEQ))) + != 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 final ComparisonOperatorContext comparisonOperator() throws RecognitionException { + ComparisonOperatorContext _localctx = new ComparisonOperatorContext(_ctx, getState()); + enterRule(_localctx, 276, RULE_comparisonOperator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3249); + _la = _input.LA(1); + if (!((((_la) & ~0x3f) == 0 + && ((1L << _la) & ((1L << LANGLE) | (1L << RANGLE) | (1L << LE) | (1L << GE))) != 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 final InOperatorContext inOperator() throws RecognitionException { + InOperatorContext _localctx = new InOperatorContext(_ctx, getState()); + enterRule(_localctx, 278, RULE_inOperator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3251); + _la = _input.LA(1); + if (!(_la == IN || _la == NOT_IN)) { + _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 final IsOperatorContext isOperator() throws RecognitionException { + IsOperatorContext _localctx = new IsOperatorContext(_ctx, getState()); + enterRule(_localctx, 280, RULE_isOperator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3253); + _la = _input.LA(1); + if (!(_la == IS || _la == NOT_IS)) { + _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 final AdditiveOperatorContext additiveOperator() throws RecognitionException { + AdditiveOperatorContext _localctx = new AdditiveOperatorContext(_ctx, getState()); + enterRule(_localctx, 282, RULE_additiveOperator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3255); + _la = _input.LA(1); + if (!(_la == ADD || _la == SUB)) { + _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 final MultiplicativeOperatorContext multiplicativeOperator() throws RecognitionException { + MultiplicativeOperatorContext _localctx = new MultiplicativeOperatorContext(_ctx, getState()); + enterRule(_localctx, 284, RULE_multiplicativeOperator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3257); + _la = _input.LA(1); + if (!((((_la) & ~0x3f) == 0 + && ((1L << _la) & ((1L << MULT) | (1L << MOD) | (1L << DIV))) != 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 final AsOperatorContext asOperator() throws RecognitionException { + AsOperatorContext _localctx = new AsOperatorContext(_ctx, getState()); + enterRule(_localctx, 286, RULE_asOperator); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3259); + _la = _input.LA(1); + if (!(_la == AS_SAFE || _la == AS)) { + _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 final PrefixUnaryOperatorContext prefixUnaryOperator() throws RecognitionException { + PrefixUnaryOperatorContext _localctx = new PrefixUnaryOperatorContext(_ctx, getState()); + enterRule(_localctx, 288, RULE_prefixUnaryOperator); + try { + setState(3266); + _errHandler.sync(this); + switch (_input.LA(1)) { + case INCR: + enterOuterAlt(_localctx, 1); + { + setState(3261); + match(INCR); + } + break; + case DECR: + enterOuterAlt(_localctx, 2); + { + setState(3262); + match(DECR); + } + break; + case SUB: + enterOuterAlt(_localctx, 3); + { + setState(3263); + match(SUB); + } + break; + case ADD: + enterOuterAlt(_localctx, 4); + { + setState(3264); + match(ADD); + } + break; + case EXCL_WS: + case EXCL_NO_WS: + enterOuterAlt(_localctx, 5); + { + setState(3265); + excl(); + } + 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 final PostfixUnaryOperatorContext postfixUnaryOperator() throws RecognitionException { + PostfixUnaryOperatorContext _localctx = new PostfixUnaryOperatorContext(_ctx, getState()); + enterRule(_localctx, 290, RULE_postfixUnaryOperator); + try { + setState(3272); + _errHandler.sync(this); + switch (_input.LA(1)) { + case INCR: + enterOuterAlt(_localctx, 1); + { + setState(3268); + match(INCR); + } + break; + case DECR: + enterOuterAlt(_localctx, 2); + { + setState(3269); + match(DECR); + } + break; + case EXCL_NO_WS: + enterOuterAlt(_localctx, 3); + { + setState(3270); + match(EXCL_NO_WS); + setState(3271); + excl(); + } + 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 final ExclContext excl() throws RecognitionException { + ExclContext _localctx = new ExclContext(_ctx, getState()); + enterRule(_localctx, 292, RULE_excl); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3274); + _la = _input.LA(1); + if (!(_la == EXCL_WS || _la == EXCL_NO_WS)) { + _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 final MemberAccessOperatorContext memberAccessOperator() throws RecognitionException { + MemberAccessOperatorContext _localctx = new MemberAccessOperatorContext(_ctx, getState()); + enterRule(_localctx, 294, RULE_memberAccessOperator); + int _la; + try { + setState(3291); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 505, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(3279); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(3276); + match(NL); + } + } + setState(3281); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3282); + match(DOT); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(3286); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(3283); + match(NL); + } + } + setState(3288); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3289); + safeNav(); + } + break; + case 3: + enterOuterAlt(_localctx, 3); + { + setState(3290); + match(COLONCOLON); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final SafeNavContext safeNav() throws RecognitionException { + SafeNavContext _localctx = new SafeNavContext(_ctx, getState()); + enterRule(_localctx, 296, RULE_safeNav); + try { + enterOuterAlt(_localctx, 1); + { + setState(3293); + match(QUEST_NO_WS); + setState(3294); + match(DOT); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ModifiersContext modifiers() throws RecognitionException { + ModifiersContext _localctx = new ModifiersContext(_ctx, getState()); + enterRule(_localctx, 298, RULE_modifiers); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(3298); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + setState(3298); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AT_NO_WS: + case AT_PRE_WS: + { + setState(3296); + annotation(); + } + break; + case PUBLIC: + case PRIVATE: + case PROTECTED: + case INTERNAL: + case ENUM: + case SEALED: + case ANNOTATION: + case DATA: + case INNER: + case VALUE: + case TAILREC: + case OPERATOR: + case INLINE: + case INFIX: + case EXTERNAL: + case SUSPEND: + case OVERRIDE: + case ABSTRACT: + case FINAL: + case OPEN: + case CONST: + case LATEINIT: + case VARARG: + case NOINLINE: + case CROSSINLINE: + case EXPECT: + case ACTUAL: + { + setState(3297); + modifier(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(3300); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 507, _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 final ParameterModifiersContext parameterModifiers() throws RecognitionException { + ParameterModifiersContext _localctx = new ParameterModifiersContext(_ctx, getState()); + enterRule(_localctx, 300, RULE_parameterModifiers); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(3304); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + setState(3304); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AT_NO_WS: + case AT_PRE_WS: + { + setState(3302); + annotation(); + } + break; + case VARARG: + case NOINLINE: + case CROSSINLINE: + { + setState(3303); + parameterModifier(); + } + break; + default: + throw new NoViableAltException(this); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(3306); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 509, _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 final ModifierContext modifier() throws RecognitionException { + ModifierContext _localctx = new ModifierContext(_ctx, getState()); + enterRule(_localctx, 302, RULE_modifier); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(3316); + _errHandler.sync(this); + switch (_input.LA(1)) { + case ENUM: + case SEALED: + case ANNOTATION: + case DATA: + case INNER: + case VALUE: + { + setState(3308); + classModifier(); + } + break; + case OVERRIDE: + case LATEINIT: + { + setState(3309); + memberModifier(); + } + break; + case PUBLIC: + case PRIVATE: + case PROTECTED: + case INTERNAL: + { + setState(3310); + visibilityModifier(); + } + break; + case TAILREC: + case OPERATOR: + case INLINE: + case INFIX: + case EXTERNAL: + case SUSPEND: + { + setState(3311); + functionModifier(); + } + break; + case CONST: + { + setState(3312); + propertyModifier(); + } + break; + case ABSTRACT: + case FINAL: + case OPEN: + { + setState(3313); + inheritanceModifier(); + } + break; + case VARARG: + case NOINLINE: + case CROSSINLINE: + { + setState(3314); + parameterModifier(); + } + break; + case EXPECT: + case ACTUAL: + { + setState(3315); + platformModifier(); + } + break; + default: + throw new NoViableAltException(this); + } + setState(3321); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 511, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(3318); + match(NL); + } + } + } + setState(3323); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 511, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final TypeModifiersContext typeModifiers() throws RecognitionException { + TypeModifiersContext _localctx = new TypeModifiersContext(_ctx, getState()); + enterRule(_localctx, 304, RULE_typeModifiers); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(3325); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(3324); + typeModifier(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(3327); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 512, _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 final TypeModifierContext typeModifier() throws RecognitionException { + TypeModifierContext _localctx = new TypeModifierContext(_ctx, getState()); + enterRule(_localctx, 306, RULE_typeModifier); + int _la; + try { + setState(3337); + _errHandler.sync(this); + switch (_input.LA(1)) { + case AT_NO_WS: + case AT_PRE_WS: + enterOuterAlt(_localctx, 1); + { + setState(3329); + annotation(); + } + break; + case SUSPEND: + enterOuterAlt(_localctx, 2); + { + setState(3330); + match(SUSPEND); + setState(3334); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(3331); + match(NL); + } + } + setState(3336); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + default: + throw new NoViableAltException(this); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final ClassModifierContext classModifier() throws RecognitionException { + ClassModifierContext _localctx = new ClassModifierContext(_ctx, getState()); + enterRule(_localctx, 308, RULE_classModifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3339); + _la = _input.LA(1); + if (!(((((_la - 111)) & ~0x3f) == 0 + && ((1L << (_la - 111)) + & ((1L << (ENUM - 111)) + | (1L << (SEALED - 111)) + | (1L << (ANNOTATION - 111)) + | (1L << (DATA - 111)) + | (1L << (INNER - 111)) + | (1L << (VALUE - 111)))) + != 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 final MemberModifierContext memberModifier() throws RecognitionException { + MemberModifierContext _localctx = new MemberModifierContext(_ctx, getState()); + enterRule(_localctx, 310, RULE_memberModifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3341); + _la = _input.LA(1); + if (!(_la == OVERRIDE || _la == LATEINIT)) { + _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 final VisibilityModifierContext visibilityModifier() throws RecognitionException { + VisibilityModifierContext _localctx = new VisibilityModifierContext(_ctx, getState()); + enterRule(_localctx, 312, RULE_visibilityModifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3343); + _la = _input.LA(1); + if (!(((((_la - 107)) & ~0x3f) == 0 + && ((1L << (_la - 107)) + & ((1L << (PUBLIC - 107)) + | (1L << (PRIVATE - 107)) + | (1L << (PROTECTED - 107)) + | (1L << (INTERNAL - 107)))) + != 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 final VarianceModifierContext varianceModifier() throws RecognitionException { + VarianceModifierContext _localctx = new VarianceModifierContext(_ctx, getState()); + enterRule(_localctx, 314, RULE_varianceModifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3345); + _la = _input.LA(1); + if (!(_la == IN || _la == OUT)) { + _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 final TypeParameterModifiersContext typeParameterModifiers() throws RecognitionException { + TypeParameterModifiersContext _localctx = new TypeParameterModifiersContext(_ctx, getState()); + enterRule(_localctx, 316, RULE_typeParameterModifiers); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(3348); + _errHandler.sync(this); + _alt = 1; + do { + switch (_alt) { + case 1: + { + { + setState(3347); + typeParameterModifier(); + } + } + break; + default: + throw new NoViableAltException(this); + } + setState(3350); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 515, _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 final TypeParameterModifierContext typeParameterModifier() throws RecognitionException { + TypeParameterModifierContext _localctx = new TypeParameterModifierContext(_ctx, getState()); + enterRule(_localctx, 318, RULE_typeParameterModifier); + try { + int _alt; + setState(3367); + _errHandler.sync(this); + switch (_input.LA(1)) { + case REIFIED: + enterOuterAlt(_localctx, 1); + { + setState(3352); + reificationModifier(); + setState(3356); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 516, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(3353); + match(NL); + } + } + } + setState(3358); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 516, _ctx); + } + } + break; + case IN: + case OUT: + enterOuterAlt(_localctx, 2); + { + setState(3359); + varianceModifier(); + setState(3363); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 517, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(3360); + match(NL); + } + } + } + setState(3365); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 517, _ctx); + } + } + break; + case AT_NO_WS: + case AT_PRE_WS: + enterOuterAlt(_localctx, 3); + { + setState(3366); + annotation(); + } + 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 final FunctionModifierContext functionModifier() throws RecognitionException { + FunctionModifierContext _localctx = new FunctionModifierContext(_ctx, getState()); + enterRule(_localctx, 320, RULE_functionModifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3369); + _la = _input.LA(1); + if (!(((((_la - 117)) & ~0x3f) == 0 + && ((1L << (_la - 117)) + & ((1L << (TAILREC - 117)) + | (1L << (OPERATOR - 117)) + | (1L << (INLINE - 117)) + | (1L << (INFIX - 117)) + | (1L << (EXTERNAL - 117)) + | (1L << (SUSPEND - 117)))) + != 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 final PropertyModifierContext propertyModifier() throws RecognitionException { + PropertyModifierContext _localctx = new PropertyModifierContext(_ctx, getState()); + enterRule(_localctx, 322, RULE_propertyModifier); + try { + enterOuterAlt(_localctx, 1); + { + setState(3371); + match(CONST); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final InheritanceModifierContext inheritanceModifier() throws RecognitionException { + InheritanceModifierContext _localctx = new InheritanceModifierContext(_ctx, getState()); + enterRule(_localctx, 324, RULE_inheritanceModifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3373); + _la = _input.LA(1); + if (!(((((_la - 124)) & ~0x3f) == 0 + && ((1L << (_la - 124)) + & ((1L << (ABSTRACT - 124)) | (1L << (FINAL - 124)) | (1L << (OPEN - 124)))) + != 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 final ParameterModifierContext parameterModifier() throws RecognitionException { + ParameterModifierContext _localctx = new ParameterModifierContext(_ctx, getState()); + enterRule(_localctx, 326, RULE_parameterModifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3375); + _la = _input.LA(1); + if (!(((((_la - 129)) & ~0x3f) == 0 + && ((1L << (_la - 129)) + & ((1L << (VARARG - 129)) + | (1L << (NOINLINE - 129)) + | (1L << (CROSSINLINE - 129)))) + != 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 final ReificationModifierContext reificationModifier() throws RecognitionException { + ReificationModifierContext _localctx = new ReificationModifierContext(_ctx, getState()); + enterRule(_localctx, 328, RULE_reificationModifier); + try { + enterOuterAlt(_localctx, 1); + { + setState(3377); + match(REIFIED); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final PlatformModifierContext platformModifier() throws RecognitionException { + PlatformModifierContext _localctx = new PlatformModifierContext(_ctx, getState()); + enterRule(_localctx, 330, RULE_platformModifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3379); + _la = _input.LA(1); + if (!(_la == EXPECT || _la == ACTUAL)) { + _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 final AnnotationContext annotation() throws RecognitionException { + AnnotationContext _localctx = new AnnotationContext(_ctx, getState()); + enterRule(_localctx, 332, RULE_annotation); + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(3383); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 519, _ctx)) { + case 1: + { + setState(3381); + singleAnnotation(); + } + break; + case 2: + { + setState(3382); + multiAnnotation(); + } + break; + } + setState(3388); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 520, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(3385); + match(NL); + } + } + } + setState(3390); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 520, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final SingleAnnotationContext singleAnnotation() throws RecognitionException { + SingleAnnotationContext _localctx = new SingleAnnotationContext(_ctx, getState()); + enterRule(_localctx, 334, RULE_singleAnnotation); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3400); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 522, _ctx)) { + case 1: + { + setState(3391); + annotationUseSiteTarget(); + setState(3395); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(3392); + match(NL); + } + } + setState(3397); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + case 2: + { + setState(3398); + match(AT_NO_WS); + } + break; + case 3: + { + setState(3399); + match(AT_PRE_WS); + } + break; + } + setState(3402); + unescapedAnnotation(); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final MultiAnnotationContext multiAnnotation() throws RecognitionException { + MultiAnnotationContext _localctx = new MultiAnnotationContext(_ctx, getState()); + enterRule(_localctx, 336, RULE_multiAnnotation); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3413); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 524, _ctx)) { + case 1: + { + setState(3404); + annotationUseSiteTarget(); + setState(3408); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(3405); + match(NL); + } + } + setState(3410); + _errHandler.sync(this); + _la = _input.LA(1); + } + } + break; + case 2: + { + setState(3411); + match(AT_NO_WS); + } + break; + case 3: + { + setState(3412); + match(AT_PRE_WS); + } + break; + } + setState(3415); + match(LSQUARE); + setState(3417); + _errHandler.sync(this); + _la = _input.LA(1); + do { + { + { + setState(3416); + unescapedAnnotation(); + } + } + setState(3419); + _errHandler.sync(this); + _la = _input.LA(1); + } while (((((_la - 61)) & ~0x3f) == 0 + && ((1L << (_la - 61)) + & ((1L << (FILE - 61)) + | (1L << (FIELD - 61)) + | (1L << (PROPERTY - 61)) + | (1L << (GET - 61)) + | (1L << (SET - 61)) + | (1L << (RECEIVER - 61)) + | (1L << (PARAM - 61)) + | (1L << (SETPARAM - 61)) + | (1L << (DELEGATE - 61)) + | (1L << (IMPORT - 61)) + | (1L << (CONSTRUCTOR - 61)) + | (1L << (BY - 61)) + | (1L << (COMPANION - 61)) + | (1L << (INIT - 61)) + | (1L << (WHERE - 61)) + | (1L << (CATCH - 61)) + | (1L << (FINALLY - 61)) + | (1L << (OUT - 61)) + | (1L << (DYNAMIC - 61)) + | (1L << (PUBLIC - 61)) + | (1L << (PRIVATE - 61)) + | (1L << (PROTECTED - 61)) + | (1L << (INTERNAL - 61)) + | (1L << (ENUM - 61)) + | (1L << (SEALED - 61)) + | (1L << (ANNOTATION - 61)) + | (1L << (DATA - 61)) + | (1L << (INNER - 61)) + | (1L << (VALUE - 61)) + | (1L << (TAILREC - 61)) + | (1L << (OPERATOR - 61)) + | (1L << (INLINE - 61)) + | (1L << (INFIX - 61)) + | (1L << (EXTERNAL - 61)) + | (1L << (SUSPEND - 61)) + | (1L << (OVERRIDE - 61)) + | (1L << (ABSTRACT - 61)))) + != 0) + || ((((_la - 125)) & ~0x3f) == 0 + && ((1L << (_la - 125)) + & ((1L << (FINAL - 125)) + | (1L << (OPEN - 125)) + | (1L << (CONST - 125)) + | (1L << (LATEINIT - 125)) + | (1L << (VARARG - 125)) + | (1L << (NOINLINE - 125)) + | (1L << (CROSSINLINE - 125)) + | (1L << (REIFIED - 125)) + | (1L << (EXPECT - 125)) + | (1L << (ACTUAL - 125)) + | (1L << (Identifier - 125)))) + != 0)); + setState(3421); + match(RSQUARE); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final AnnotationUseSiteTargetContext annotationUseSiteTarget() + throws RecognitionException { + AnnotationUseSiteTargetContext _localctx = new AnnotationUseSiteTargetContext(_ctx, getState()); + enterRule(_localctx, 338, RULE_annotationUseSiteTarget); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3423); + _la = _input.LA(1); + if (!(_la == AT_NO_WS || _la == AT_PRE_WS)) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(3424); + _la = _input.LA(1); + if (!(((((_la - 62)) & ~0x3f) == 0 + && ((1L << (_la - 62)) + & ((1L << (FIELD - 62)) + | (1L << (PROPERTY - 62)) + | (1L << (GET - 62)) + | (1L << (SET - 62)) + | (1L << (RECEIVER - 62)) + | (1L << (PARAM - 62)) + | (1L << (SETPARAM - 62)) + | (1L << (DELEGATE - 62)))) + != 0))) { + _errHandler.recoverInline(this); + } else { + if (_input.LA(1) == Token.EOF) matchedEOF = true; + _errHandler.reportMatch(this); + consume(); + } + setState(3428); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(3425); + match(NL); + } + } + setState(3430); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3431); + match(COLON); + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final UnescapedAnnotationContext unescapedAnnotation() throws RecognitionException { + UnescapedAnnotationContext _localctx = new UnescapedAnnotationContext(_ctx, getState()); + enterRule(_localctx, 340, RULE_unescapedAnnotation); + try { + setState(3435); + _errHandler.sync(this); + switch (getInterpreter().adaptivePredict(_input, 527, _ctx)) { + case 1: + enterOuterAlt(_localctx, 1); + { + setState(3433); + constructorInvocation(); + } + break; + case 2: + enterOuterAlt(_localctx, 2); + { + setState(3434); + userType(); + } + break; + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public final SimpleIdentifierContext simpleIdentifier() throws RecognitionException { + SimpleIdentifierContext _localctx = new SimpleIdentifierContext(_ctx, getState()); + enterRule(_localctx, 342, RULE_simpleIdentifier); + int _la; + try { + enterOuterAlt(_localctx, 1); + { + setState(3437); + _la = _input.LA(1); + if (!(((((_la - 61)) & ~0x3f) == 0 + && ((1L << (_la - 61)) + & ((1L << (FILE - 61)) + | (1L << (FIELD - 61)) + | (1L << (PROPERTY - 61)) + | (1L << (GET - 61)) + | (1L << (SET - 61)) + | (1L << (RECEIVER - 61)) + | (1L << (PARAM - 61)) + | (1L << (SETPARAM - 61)) + | (1L << (DELEGATE - 61)) + | (1L << (IMPORT - 61)) + | (1L << (CONSTRUCTOR - 61)) + | (1L << (BY - 61)) + | (1L << (COMPANION - 61)) + | (1L << (INIT - 61)) + | (1L << (WHERE - 61)) + | (1L << (CATCH - 61)) + | (1L << (FINALLY - 61)) + | (1L << (OUT - 61)) + | (1L << (DYNAMIC - 61)) + | (1L << (PUBLIC - 61)) + | (1L << (PRIVATE - 61)) + | (1L << (PROTECTED - 61)) + | (1L << (INTERNAL - 61)) + | (1L << (ENUM - 61)) + | (1L << (SEALED - 61)) + | (1L << (ANNOTATION - 61)) + | (1L << (DATA - 61)) + | (1L << (INNER - 61)) + | (1L << (VALUE - 61)) + | (1L << (TAILREC - 61)) + | (1L << (OPERATOR - 61)) + | (1L << (INLINE - 61)) + | (1L << (INFIX - 61)) + | (1L << (EXTERNAL - 61)) + | (1L << (SUSPEND - 61)) + | (1L << (OVERRIDE - 61)) + | (1L << (ABSTRACT - 61)))) + != 0) + || ((((_la - 125)) & ~0x3f) == 0 + && ((1L << (_la - 125)) + & ((1L << (FINAL - 125)) + | (1L << (OPEN - 125)) + | (1L << (CONST - 125)) + | (1L << (LATEINIT - 125)) + | (1L << (VARARG - 125)) + | (1L << (NOINLINE - 125)) + | (1L << (CROSSINLINE - 125)) + | (1L << (REIFIED - 125)) + | (1L << (EXPECT - 125)) + | (1L << (ACTUAL - 125)) + | (1L << (Identifier - 125)))) + != 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 final IdentifierContext identifier() throws RecognitionException { + IdentifierContext _localctx = new IdentifierContext(_ctx, getState()); + enterRule(_localctx, 344, RULE_identifier); + int _la; + try { + int _alt; + enterOuterAlt(_localctx, 1); + { + setState(3439); + simpleIdentifier(); + setState(3450); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 529, _ctx); + while (_alt != 2 && _alt != org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER) { + if (_alt == 1) { + { + { + setState(3443); + _errHandler.sync(this); + _la = _input.LA(1); + while (_la == NL) { + { + { + setState(3440); + match(NL); + } + } + setState(3445); + _errHandler.sync(this); + _la = _input.LA(1); + } + setState(3446); + match(DOT); + setState(3447); + simpleIdentifier(); + } + } + } + setState(3452); + _errHandler.sync(this); + _alt = getInterpreter().adaptivePredict(_input, 529, _ctx); + } + } + } catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } finally { + exitRule(); + } + return _localctx; + } + + public static class KotlinFileContext extends ParserRuleContext { + public KotlinFileContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public PackageHeaderContext packageHeader() { + return getRuleContext(PackageHeaderContext.class, 0); + } + + public ImportListContext importList() { + return getRuleContext(ImportListContext.class, 0); + } + + public TerminalNode EOF() { + return getToken(KotlinParser.EOF, 0); + } + + public ShebangLineContext shebangLine() { + return getRuleContext(ShebangLineContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public List fileAnnotation() { + return getRuleContexts(FileAnnotationContext.class); + } + + public FileAnnotationContext fileAnnotation(int i) { + return getRuleContext(FileAnnotationContext.class, i); + } + + public List topLevelObject() { + return getRuleContexts(TopLevelObjectContext.class); + } + + public TopLevelObjectContext topLevelObject(int i) { + return getRuleContext(TopLevelObjectContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_kotlinFile; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitKotlinFile(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterKotlinFile(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitKotlinFile(this); + } + } + + public static class ScriptContext extends ParserRuleContext { + public ScriptContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public PackageHeaderContext packageHeader() { + return getRuleContext(PackageHeaderContext.class, 0); + } + + public ImportListContext importList() { + return getRuleContext(ImportListContext.class, 0); + } + + public TerminalNode EOF() { + return getToken(KotlinParser.EOF, 0); + } + + public ShebangLineContext shebangLine() { + return getRuleContext(ShebangLineContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public List fileAnnotation() { + return getRuleContexts(FileAnnotationContext.class); + } + + public FileAnnotationContext fileAnnotation(int i) { + return getRuleContext(FileAnnotationContext.class, i); + } + + public List statement() { + return getRuleContexts(StatementContext.class); + } + + public StatementContext statement(int i) { + return getRuleContext(StatementContext.class, i); + } + + public List semi() { + return getRuleContexts(SemiContext.class); + } + + public SemiContext semi(int i) { + return getRuleContext(SemiContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_script; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitScript(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterScript(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitScript(this); + } + } + + public static class ShebangLineContext extends ParserRuleContext { + public ShebangLineContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode ShebangLine() { + return getToken(KotlinParser.ShebangLine, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_shebangLine; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitShebangLine(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterShebangLine(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitShebangLine(this); + } + } + + public static class FileAnnotationContext extends ParserRuleContext { + public FileAnnotationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode FILE() { + return getToken(KotlinParser.FILE, 0); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public TerminalNode AT_NO_WS() { + return getToken(KotlinParser.AT_NO_WS, 0); + } + + public TerminalNode AT_PRE_WS() { + return getToken(KotlinParser.AT_PRE_WS, 0); + } + + public TerminalNode LSQUARE() { + return getToken(KotlinParser.LSQUARE, 0); + } + + public TerminalNode RSQUARE() { + return getToken(KotlinParser.RSQUARE, 0); + } + + public List unescapedAnnotation() { + return getRuleContexts(UnescapedAnnotationContext.class); + } + + public UnescapedAnnotationContext unescapedAnnotation(int i) { + return getRuleContext(UnescapedAnnotationContext.class, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_fileAnnotation; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitFileAnnotation(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterFileAnnotation(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitFileAnnotation(this); + } + } + + public static class PackageHeaderContext extends ParserRuleContext { + public PackageHeaderContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode PACKAGE() { + return getToken(KotlinParser.PACKAGE, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public SemiContext semi() { + return getRuleContext(SemiContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_packageHeader; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitPackageHeader(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterPackageHeader(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitPackageHeader(this); + } + } + + public static class ImportListContext extends ParserRuleContext { + public ImportListContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List importHeader() { + return getRuleContexts(ImportHeaderContext.class); + } + + public ImportHeaderContext importHeader(int i) { + return getRuleContext(ImportHeaderContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_importList; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitImportList(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterImportList(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitImportList(this); + } + } + + public static class ImportHeaderContext extends ParserRuleContext { + public ImportHeaderContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode IMPORT() { + return getToken(KotlinParser.IMPORT, 0); + } + + public IdentifierContext identifier() { + return getRuleContext(IdentifierContext.class, 0); + } + + public TerminalNode DOT() { + return getToken(KotlinParser.DOT, 0); + } + + public TerminalNode MULT() { + return getToken(KotlinParser.MULT, 0); + } + + public ImportAliasContext importAlias() { + return getRuleContext(ImportAliasContext.class, 0); + } + + public SemiContext semi() { + return getRuleContext(SemiContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_importHeader; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitImportHeader(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterImportHeader(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitImportHeader(this); + } + } + + public static class ImportAliasContext extends ParserRuleContext { + public ImportAliasContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode AS() { + return getToken(KotlinParser.AS, 0); + } + + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_importAlias; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitImportAlias(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterImportAlias(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitImportAlias(this); + } + } + + public static class TopLevelObjectContext extends ParserRuleContext { + public TopLevelObjectContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public DeclarationContext declaration() { + return getRuleContext(DeclarationContext.class, 0); + } + + public SemisContext semis() { + return getRuleContext(SemisContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_topLevelObject; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitTopLevelObject(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterTopLevelObject(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitTopLevelObject(this); + } + } + + public static class TypeAliasContext extends ParserRuleContext { + public TypeAliasContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode TYPE_ALIAS() { + return getToken(KotlinParser.TYPE_ALIAS, 0); + } + + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public TerminalNode ASSIGNMENT() { + return getToken(KotlinParser.ASSIGNMENT, 0); + } + + public TypeContext type() { + return getRuleContext(TypeContext.class, 0); + } + + public ModifiersContext modifiers() { + return getRuleContext(ModifiersContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_typeAlias; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitTypeAlias(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterTypeAlias(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitTypeAlias(this); + } + } + + public static class DeclarationContext extends ParserRuleContext { + public DeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public ClassDeclarationContext classDeclaration() { + return getRuleContext(ClassDeclarationContext.class, 0); + } + + public ObjectDeclarationContext objectDeclaration() { + return getRuleContext(ObjectDeclarationContext.class, 0); + } + + public FunctionDeclarationContext functionDeclaration() { + return getRuleContext(FunctionDeclarationContext.class, 0); + } + + public PropertyDeclarationContext propertyDeclaration() { + return getRuleContext(PropertyDeclarationContext.class, 0); + } + + public TypeAliasContext typeAlias() { + return getRuleContext(TypeAliasContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_declaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitDeclaration(this); + } + } + + public static class ClassDeclarationContext extends ParserRuleContext { + public ClassDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public TerminalNode CLASS() { + return getToken(KotlinParser.CLASS, 0); + } + + public TerminalNode INTERFACE() { + return getToken(KotlinParser.INTERFACE, 0); + } + + public ModifiersContext modifiers() { + return getRuleContext(ModifiersContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class, 0); + } + + public PrimaryConstructorContext primaryConstructor() { + return getRuleContext(PrimaryConstructorContext.class, 0); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public DelegationSpecifiersContext delegationSpecifiers() { + return getRuleContext(DelegationSpecifiersContext.class, 0); + } + + public TypeConstraintsContext typeConstraints() { + return getRuleContext(TypeConstraintsContext.class, 0); + } + + public ClassBodyContext classBody() { + return getRuleContext(ClassBodyContext.class, 0); + } + + public EnumClassBodyContext enumClassBody() { + return getRuleContext(EnumClassBodyContext.class, 0); + } + + public TerminalNode FUN() { + return getToken(KotlinParser.FUN, 0); + } + + @Override + public int getRuleIndex() { + return RULE_classDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitClassDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterClassDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitClassDeclaration(this); + } + } + + public static class PrimaryConstructorContext extends ParserRuleContext { + public PrimaryConstructorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public ClassParametersContext classParameters() { + return getRuleContext(ClassParametersContext.class, 0); + } + + public TerminalNode CONSTRUCTOR() { + return getToken(KotlinParser.CONSTRUCTOR, 0); + } + + public ModifiersContext modifiers() { + return getRuleContext(ModifiersContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_primaryConstructor; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitPrimaryConstructor(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterPrimaryConstructor(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitPrimaryConstructor(this); + } + } + + public static class ClassBodyContext extends ParserRuleContext { + public ClassBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LCURL() { + return getToken(KotlinParser.LCURL, 0); + } + + public ClassMemberDeclarationsContext classMemberDeclarations() { + return getRuleContext(ClassMemberDeclarationsContext.class, 0); + } + + public TerminalNode RCURL() { + return getToken(KotlinParser.RCURL, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_classBody; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitClassBody(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterClassBody(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitClassBody(this); + } + } + + public static class ClassParametersContext extends ParserRuleContext { + public ClassParametersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LPAREN() { + return getToken(KotlinParser.LPAREN, 0); + } + + public TerminalNode RPAREN() { + return getToken(KotlinParser.RPAREN, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public List classParameter() { + return getRuleContexts(ClassParameterContext.class); + } + + public ClassParameterContext classParameter(int i) { + return getRuleContext(ClassParameterContext.class, i); + } + + public List COMMA() { + return getTokens(KotlinParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(KotlinParser.COMMA, i); + } + + @Override + public int getRuleIndex() { + return RULE_classParameters; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitClassParameters(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterClassParameters(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitClassParameters(this); + } + } + + public static class ClassParameterContext extends ParserRuleContext { + public ClassParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public TypeContext type() { + return getRuleContext(TypeContext.class, 0); + } + + public ModifiersContext modifiers() { + return getRuleContext(ModifiersContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public TerminalNode ASSIGNMENT() { + return getToken(KotlinParser.ASSIGNMENT, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode VAL() { + return getToken(KotlinParser.VAL, 0); + } + + public TerminalNode VAR() { + return getToken(KotlinParser.VAR, 0); + } + + @Override + public int getRuleIndex() { + return RULE_classParameter; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitClassParameter(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterClassParameter(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitClassParameter(this); + } + } + + public static class DelegationSpecifiersContext extends ParserRuleContext { + public DelegationSpecifiersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List annotatedDelegationSpecifier() { + return getRuleContexts(AnnotatedDelegationSpecifierContext.class); + } + + public AnnotatedDelegationSpecifierContext annotatedDelegationSpecifier(int i) { + return getRuleContext(AnnotatedDelegationSpecifierContext.class, i); + } + + public List COMMA() { + return getTokens(KotlinParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(KotlinParser.COMMA, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_delegationSpecifiers; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitDelegationSpecifiers(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterDelegationSpecifiers(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitDelegationSpecifiers(this); + } + } + + public static class DelegationSpecifierContext extends ParserRuleContext { + public DelegationSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public ConstructorInvocationContext constructorInvocation() { + return getRuleContext(ConstructorInvocationContext.class, 0); + } + + public ExplicitDelegationContext explicitDelegation() { + return getRuleContext(ExplicitDelegationContext.class, 0); + } + + public UserTypeContext userType() { + return getRuleContext(UserTypeContext.class, 0); + } + + public FunctionTypeContext functionType() { + return getRuleContext(FunctionTypeContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_delegationSpecifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitDelegationSpecifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterDelegationSpecifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitDelegationSpecifier(this); + } + } + + public static class ConstructorInvocationContext extends ParserRuleContext { + public ConstructorInvocationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public UserTypeContext userType() { + return getRuleContext(UserTypeContext.class, 0); + } + + public ValueArgumentsContext valueArguments() { + return getRuleContext(ValueArgumentsContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_constructorInvocation; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitConstructorInvocation(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterConstructorInvocation(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitConstructorInvocation(this); + } + } + + public static class AnnotatedDelegationSpecifierContext extends ParserRuleContext { + public AnnotatedDelegationSpecifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public DelegationSpecifierContext delegationSpecifier() { + return getRuleContext(DelegationSpecifierContext.class, 0); + } + + public List annotation() { + return getRuleContexts(AnnotationContext.class); + } + + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_annotatedDelegationSpecifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitAnnotatedDelegationSpecifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterAnnotatedDelegationSpecifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitAnnotatedDelegationSpecifier(this); + } + } + + public static class ExplicitDelegationContext extends ParserRuleContext { + public ExplicitDelegationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode BY() { + return getToken(KotlinParser.BY, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public UserTypeContext userType() { + return getRuleContext(UserTypeContext.class, 0); + } + + public FunctionTypeContext functionType() { + return getRuleContext(FunctionTypeContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_explicitDelegation; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitExplicitDelegation(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterExplicitDelegation(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitExplicitDelegation(this); + } + } + + public static class TypeParametersContext extends ParserRuleContext { + public TypeParametersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LANGLE() { + return getToken(KotlinParser.LANGLE, 0); + } + + public List typeParameter() { + return getRuleContexts(TypeParameterContext.class); + } + + public TypeParameterContext typeParameter(int i) { + return getRuleContext(TypeParameterContext.class, i); + } + + public TerminalNode RANGLE() { + return getToken(KotlinParser.RANGLE, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public List COMMA() { + return getTokens(KotlinParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(KotlinParser.COMMA, i); + } + + @Override + public int getRuleIndex() { + return RULE_typeParameters; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitTypeParameters(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterTypeParameters(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitTypeParameters(this); + } + } + + public static class TypeParameterContext extends ParserRuleContext { + public TypeParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public TypeParameterModifiersContext typeParameterModifiers() { + return getRuleContext(TypeParameterModifiersContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public TypeContext type() { + return getRuleContext(TypeContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_typeParameter; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitTypeParameter(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterTypeParameter(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitTypeParameter(this); + } + } + + public static class TypeConstraintsContext extends ParserRuleContext { + public TypeConstraintsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode WHERE() { + return getToken(KotlinParser.WHERE, 0); + } + + public List typeConstraint() { + return getRuleContexts(TypeConstraintContext.class); + } + + public TypeConstraintContext typeConstraint(int i) { + return getRuleContext(TypeConstraintContext.class, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public List COMMA() { + return getTokens(KotlinParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(KotlinParser.COMMA, i); + } + + @Override + public int getRuleIndex() { + return RULE_typeConstraints; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitTypeConstraints(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterTypeConstraints(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitTypeConstraints(this); + } + } + + public static class TypeConstraintContext extends ParserRuleContext { + public TypeConstraintContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public TypeContext type() { + return getRuleContext(TypeContext.class, 0); + } + + public List annotation() { + return getRuleContexts(AnnotationContext.class); + } + + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_typeConstraint; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitTypeConstraint(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterTypeConstraint(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitTypeConstraint(this); + } + } + + public static class ClassMemberDeclarationsContext extends ParserRuleContext { + public ClassMemberDeclarationsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List classMemberDeclaration() { + return getRuleContexts(ClassMemberDeclarationContext.class); + } + + public ClassMemberDeclarationContext classMemberDeclaration(int i) { + return getRuleContext(ClassMemberDeclarationContext.class, i); + } + + public List semis() { + return getRuleContexts(SemisContext.class); + } + + public SemisContext semis(int i) { + return getRuleContext(SemisContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_classMemberDeclarations; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitClassMemberDeclarations(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterClassMemberDeclarations(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitClassMemberDeclarations(this); + } + } + + public static class ClassMemberDeclarationContext extends ParserRuleContext { + public ClassMemberDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public DeclarationContext declaration() { + return getRuleContext(DeclarationContext.class, 0); + } + + public CompanionObjectContext companionObject() { + return getRuleContext(CompanionObjectContext.class, 0); + } + + public AnonymousInitializerContext anonymousInitializer() { + return getRuleContext(AnonymousInitializerContext.class, 0); + } + + public SecondaryConstructorContext secondaryConstructor() { + return getRuleContext(SecondaryConstructorContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_classMemberDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitClassMemberDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterClassMemberDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitClassMemberDeclaration(this); + } + } + + public static class AnonymousInitializerContext extends ParserRuleContext { + public AnonymousInitializerContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode INIT() { + return getToken(KotlinParser.INIT, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_anonymousInitializer; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitAnonymousInitializer(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterAnonymousInitializer(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitAnonymousInitializer(this); + } + } + + public static class CompanionObjectContext extends ParserRuleContext { + public CompanionObjectContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode COMPANION() { + return getToken(KotlinParser.COMPANION, 0); + } + + public TerminalNode OBJECT() { + return getToken(KotlinParser.OBJECT, 0); + } + + public ModifiersContext modifiers() { + return getRuleContext(ModifiersContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public DelegationSpecifiersContext delegationSpecifiers() { + return getRuleContext(DelegationSpecifiersContext.class, 0); + } + + public ClassBodyContext classBody() { + return getRuleContext(ClassBodyContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_companionObject; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitCompanionObject(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterCompanionObject(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitCompanionObject(this); + } + } + + public static class FunctionValueParametersContext extends ParserRuleContext { + public FunctionValueParametersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LPAREN() { + return getToken(KotlinParser.LPAREN, 0); + } + + public TerminalNode RPAREN() { + return getToken(KotlinParser.RPAREN, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public List functionValueParameter() { + return getRuleContexts(FunctionValueParameterContext.class); + } + + public FunctionValueParameterContext functionValueParameter(int i) { + return getRuleContext(FunctionValueParameterContext.class, i); + } + + public List COMMA() { + return getTokens(KotlinParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(KotlinParser.COMMA, i); + } + + @Override + public int getRuleIndex() { + return RULE_functionValueParameters; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitFunctionValueParameters(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterFunctionValueParameters(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitFunctionValueParameters(this); + } + } + + public static class FunctionValueParameterContext extends ParserRuleContext { + public FunctionValueParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public ParameterContext parameter() { + return getRuleContext(ParameterContext.class, 0); + } + + public ParameterModifiersContext parameterModifiers() { + return getRuleContext(ParameterModifiersContext.class, 0); + } + + public TerminalNode ASSIGNMENT() { + return getToken(KotlinParser.ASSIGNMENT, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_functionValueParameter; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitFunctionValueParameter(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterFunctionValueParameter(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitFunctionValueParameter(this); + } + } + + public static class FunctionDeclarationContext extends ParserRuleContext { + public FunctionDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode FUN() { + return getToken(KotlinParser.FUN, 0); + } + + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public FunctionValueParametersContext functionValueParameters() { + return getRuleContext(FunctionValueParametersContext.class, 0); + } + + public ModifiersContext modifiers() { + return getRuleContext(ModifiersContext.class, 0); + } + + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class, 0); + } + + public ReceiverTypeContext receiverType() { + return getRuleContext(ReceiverTypeContext.class, 0); + } + + public TerminalNode DOT() { + return getToken(KotlinParser.DOT, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public TypeContext type() { + return getRuleContext(TypeContext.class, 0); + } + + public TypeConstraintsContext typeConstraints() { + return getRuleContext(TypeConstraintsContext.class, 0); + } + + public FunctionBodyContext functionBody() { + return getRuleContext(FunctionBodyContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_functionDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitFunctionDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterFunctionDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitFunctionDeclaration(this); + } + } + + public static class FunctionBodyContext extends ParserRuleContext { + public FunctionBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public TerminalNode ASSIGNMENT() { + return getToken(KotlinParser.ASSIGNMENT, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_functionBody; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitFunctionBody(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterFunctionBody(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitFunctionBody(this); + } + } + + public static class VariableDeclarationContext extends ParserRuleContext { + public VariableDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public List annotation() { + return getRuleContexts(AnnotationContext.class); + } + + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public TypeContext type() { + return getRuleContext(TypeContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_variableDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitVariableDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterVariableDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitVariableDeclaration(this); + } + } + + public static class MultiVariableDeclarationContext extends ParserRuleContext { + public MultiVariableDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LPAREN() { + return getToken(KotlinParser.LPAREN, 0); + } + + public List variableDeclaration() { + return getRuleContexts(VariableDeclarationContext.class); + } + + public VariableDeclarationContext variableDeclaration(int i) { + return getRuleContext(VariableDeclarationContext.class, i); + } + + public TerminalNode RPAREN() { + return getToken(KotlinParser.RPAREN, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public List COMMA() { + return getTokens(KotlinParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(KotlinParser.COMMA, i); + } + + @Override + public int getRuleIndex() { + return RULE_multiVariableDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitMultiVariableDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterMultiVariableDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitMultiVariableDeclaration(this); + } + } + + public static class PropertyDeclarationContext extends ParserRuleContext { + public PropertyDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode VAL() { + return getToken(KotlinParser.VAL, 0); + } + + public TerminalNode VAR() { + return getToken(KotlinParser.VAR, 0); + } + + public ModifiersContext modifiers() { + return getRuleContext(ModifiersContext.class, 0); + } + + public TypeParametersContext typeParameters() { + return getRuleContext(TypeParametersContext.class, 0); + } + + public ReceiverTypeContext receiverType() { + return getRuleContext(ReceiverTypeContext.class, 0); + } + + public TerminalNode DOT() { + return getToken(KotlinParser.DOT, 0); + } + + public TypeConstraintsContext typeConstraints() { + return getRuleContext(TypeConstraintsContext.class, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(KotlinParser.SEMICOLON, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public MultiVariableDeclarationContext multiVariableDeclaration() { + return getRuleContext(MultiVariableDeclarationContext.class, 0); + } + + public VariableDeclarationContext variableDeclaration() { + return getRuleContext(VariableDeclarationContext.class, 0); + } + + public TerminalNode ASSIGNMENT() { + return getToken(KotlinParser.ASSIGNMENT, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public PropertyDelegateContext propertyDelegate() { + return getRuleContext(PropertyDelegateContext.class, 0); + } + + public GetterContext getter() { + return getRuleContext(GetterContext.class, 0); + } + + public SetterContext setter() { + return getRuleContext(SetterContext.class, 0); + } + + public SemiContext semi() { + return getRuleContext(SemiContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_propertyDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitPropertyDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterPropertyDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitPropertyDeclaration(this); + } + } + + public static class PropertyDelegateContext extends ParserRuleContext { + public PropertyDelegateContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode BY() { + return getToken(KotlinParser.BY, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_propertyDelegate; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitPropertyDelegate(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterPropertyDelegate(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitPropertyDelegate(this); + } + } + + public static class GetterContext extends ParserRuleContext { + public GetterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode GET() { + return getToken(KotlinParser.GET, 0); + } + + public ModifiersContext modifiers() { + return getRuleContext(ModifiersContext.class, 0); + } + + public TerminalNode LPAREN() { + return getToken(KotlinParser.LPAREN, 0); + } + + public TerminalNode RPAREN() { + return getToken(KotlinParser.RPAREN, 0); + } + + public FunctionBodyContext functionBody() { + return getRuleContext(FunctionBodyContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public TypeContext type() { + return getRuleContext(TypeContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_getter; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitGetter(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterGetter(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitGetter(this); + } + } + + public static class SetterContext extends ParserRuleContext { + public SetterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode SET() { + return getToken(KotlinParser.SET, 0); + } + + public ModifiersContext modifiers() { + return getRuleContext(ModifiersContext.class, 0); + } + + public TerminalNode LPAREN() { + return getToken(KotlinParser.LPAREN, 0); + } + + public FunctionValueParameterWithOptionalTypeContext functionValueParameterWithOptionalType() { + return getRuleContext(FunctionValueParameterWithOptionalTypeContext.class, 0); + } + + public TerminalNode RPAREN() { + return getToken(KotlinParser.RPAREN, 0); + } + + public FunctionBodyContext functionBody() { + return getRuleContext(FunctionBodyContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public TerminalNode COMMA() { + return getToken(KotlinParser.COMMA, 0); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public TypeContext type() { + return getRuleContext(TypeContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_setter; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitSetter(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterSetter(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitSetter(this); + } + } + + public static class ParametersWithOptionalTypeContext extends ParserRuleContext { + public ParametersWithOptionalTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LPAREN() { + return getToken(KotlinParser.LPAREN, 0); + } + + public TerminalNode RPAREN() { + return getToken(KotlinParser.RPAREN, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public List + functionValueParameterWithOptionalType() { + return getRuleContexts(FunctionValueParameterWithOptionalTypeContext.class); + } + + public FunctionValueParameterWithOptionalTypeContext functionValueParameterWithOptionalType( + int i) { + return getRuleContext(FunctionValueParameterWithOptionalTypeContext.class, i); + } + + public List COMMA() { + return getTokens(KotlinParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(KotlinParser.COMMA, i); + } + + @Override + public int getRuleIndex() { + return RULE_parametersWithOptionalType; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitParametersWithOptionalType(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterParametersWithOptionalType(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitParametersWithOptionalType(this); + } + } + + public static class FunctionValueParameterWithOptionalTypeContext extends ParserRuleContext { + public FunctionValueParameterWithOptionalTypeContext( + ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public ParameterWithOptionalTypeContext parameterWithOptionalType() { + return getRuleContext(ParameterWithOptionalTypeContext.class, 0); + } + + public ParameterModifiersContext parameterModifiers() { + return getRuleContext(ParameterModifiersContext.class, 0); + } + + public TerminalNode ASSIGNMENT() { + return getToken(KotlinParser.ASSIGNMENT, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_functionValueParameterWithOptionalType; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor) + .visitFunctionValueParameterWithOptionalType(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterFunctionValueParameterWithOptionalType(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitFunctionValueParameterWithOptionalType(this); + } + } + + public static class ParameterWithOptionalTypeContext extends ParserRuleContext { + public ParameterWithOptionalTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public TypeContext type() { + return getRuleContext(TypeContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_parameterWithOptionalType; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitParameterWithOptionalType(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterParameterWithOptionalType(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitParameterWithOptionalType(this); + } + } + + public static class ParameterContext extends ParserRuleContext { + public ParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public TypeContext type() { + return getRuleContext(TypeContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_parameter; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitParameter(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterParameter(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitParameter(this); + } + } + + public static class ObjectDeclarationContext extends ParserRuleContext { + public ObjectDeclarationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode OBJECT() { + return getToken(KotlinParser.OBJECT, 0); + } + + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public ModifiersContext modifiers() { + return getRuleContext(ModifiersContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public DelegationSpecifiersContext delegationSpecifiers() { + return getRuleContext(DelegationSpecifiersContext.class, 0); + } + + public ClassBodyContext classBody() { + return getRuleContext(ClassBodyContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_objectDeclaration; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitObjectDeclaration(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterObjectDeclaration(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitObjectDeclaration(this); + } + } + + public static class SecondaryConstructorContext extends ParserRuleContext { + public SecondaryConstructorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode CONSTRUCTOR() { + return getToken(KotlinParser.CONSTRUCTOR, 0); + } + + public FunctionValueParametersContext functionValueParameters() { + return getRuleContext(FunctionValueParametersContext.class, 0); + } + + public ModifiersContext modifiers() { + return getRuleContext(ModifiersContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public ConstructorDelegationCallContext constructorDelegationCall() { + return getRuleContext(ConstructorDelegationCallContext.class, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_secondaryConstructor; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitSecondaryConstructor(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterSecondaryConstructor(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitSecondaryConstructor(this); + } + } + + public static class ConstructorDelegationCallContext extends ParserRuleContext { + public ConstructorDelegationCallContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public ValueArgumentsContext valueArguments() { + return getRuleContext(ValueArgumentsContext.class, 0); + } + + public TerminalNode THIS() { + return getToken(KotlinParser.THIS, 0); + } + + public TerminalNode SUPER() { + return getToken(KotlinParser.SUPER, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_constructorDelegationCall; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitConstructorDelegationCall(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterConstructorDelegationCall(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitConstructorDelegationCall(this); + } + } + + public static class EnumClassBodyContext extends ParserRuleContext { + public EnumClassBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LCURL() { + return getToken(KotlinParser.LCURL, 0); + } + + public TerminalNode RCURL() { + return getToken(KotlinParser.RCURL, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public EnumEntriesContext enumEntries() { + return getRuleContext(EnumEntriesContext.class, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(KotlinParser.SEMICOLON, 0); + } + + public ClassMemberDeclarationsContext classMemberDeclarations() { + return getRuleContext(ClassMemberDeclarationsContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_enumClassBody; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitEnumClassBody(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterEnumClassBody(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitEnumClassBody(this); + } + } + + public static class EnumEntriesContext extends ParserRuleContext { + public EnumEntriesContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List enumEntry() { + return getRuleContexts(EnumEntryContext.class); + } + + public EnumEntryContext enumEntry(int i) { + return getRuleContext(EnumEntryContext.class, i); + } + + public List COMMA() { + return getTokens(KotlinParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(KotlinParser.COMMA, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_enumEntries; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitEnumEntries(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterEnumEntries(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitEnumEntries(this); + } + } + + public static class EnumEntryContext extends ParserRuleContext { + public EnumEntryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public ModifiersContext modifiers() { + return getRuleContext(ModifiersContext.class, 0); + } + + public ValueArgumentsContext valueArguments() { + return getRuleContext(ValueArgumentsContext.class, 0); + } + + public ClassBodyContext classBody() { + return getRuleContext(ClassBodyContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_enumEntry; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitEnumEntry(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterEnumEntry(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitEnumEntry(this); + } + } + + public static class TypeContext extends ParserRuleContext { + public TypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public ParenthesizedTypeContext parenthesizedType() { + return getRuleContext(ParenthesizedTypeContext.class, 0); + } + + public NullableTypeContext nullableType() { + return getRuleContext(NullableTypeContext.class, 0); + } + + public TypeReferenceContext typeReference() { + return getRuleContext(TypeReferenceContext.class, 0); + } + + public FunctionTypeContext functionType() { + return getRuleContext(FunctionTypeContext.class, 0); + } + + public TypeModifiersContext typeModifiers() { + return getRuleContext(TypeModifiersContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_type; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitType(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterType(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitType(this); + } + } + + public static class TypeReferenceContext extends ParserRuleContext { + public TypeReferenceContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public UserTypeContext userType() { + return getRuleContext(UserTypeContext.class, 0); + } + + public TerminalNode DYNAMIC() { + return getToken(KotlinParser.DYNAMIC, 0); + } + + @Override + public int getRuleIndex() { + return RULE_typeReference; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitTypeReference(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterTypeReference(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitTypeReference(this); + } + } + + public static class NullableTypeContext extends ParserRuleContext { + public NullableTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TypeReferenceContext typeReference() { + return getRuleContext(TypeReferenceContext.class, 0); + } + + public ParenthesizedTypeContext parenthesizedType() { + return getRuleContext(ParenthesizedTypeContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public List quest() { + return getRuleContexts(QuestContext.class); + } + + public QuestContext quest(int i) { + return getRuleContext(QuestContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_nullableType; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitNullableType(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterNullableType(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitNullableType(this); + } + } + + public static class QuestContext extends ParserRuleContext { + public QuestContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode QUEST_NO_WS() { + return getToken(KotlinParser.QUEST_NO_WS, 0); + } + + public TerminalNode QUEST_WS() { + return getToken(KotlinParser.QUEST_WS, 0); + } + + @Override + public int getRuleIndex() { + return RULE_quest; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitQuest(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterQuest(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitQuest(this); + } + } + + public static class UserTypeContext extends ParserRuleContext { + public UserTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List simpleUserType() { + return getRuleContexts(SimpleUserTypeContext.class); + } + + public SimpleUserTypeContext simpleUserType(int i) { + return getRuleContext(SimpleUserTypeContext.class, i); + } + + public List DOT() { + return getTokens(KotlinParser.DOT); + } + + public TerminalNode DOT(int i) { + return getToken(KotlinParser.DOT, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_userType; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitUserType(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterUserType(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitUserType(this); + } + } + + public static class SimpleUserTypeContext extends ParserRuleContext { + public SimpleUserTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_simpleUserType; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitSimpleUserType(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterSimpleUserType(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitSimpleUserType(this); + } + } + + public static class TypeProjectionContext extends ParserRuleContext { + public TypeProjectionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TypeContext type() { + return getRuleContext(TypeContext.class, 0); + } + + public TypeProjectionModifiersContext typeProjectionModifiers() { + return getRuleContext(TypeProjectionModifiersContext.class, 0); + } + + public TerminalNode MULT() { + return getToken(KotlinParser.MULT, 0); + } + + @Override + public int getRuleIndex() { + return RULE_typeProjection; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitTypeProjection(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterTypeProjection(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitTypeProjection(this); + } + } + + public static class TypeProjectionModifiersContext extends ParserRuleContext { + public TypeProjectionModifiersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List typeProjectionModifier() { + return getRuleContexts(TypeProjectionModifierContext.class); + } + + public TypeProjectionModifierContext typeProjectionModifier(int i) { + return getRuleContext(TypeProjectionModifierContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_typeProjectionModifiers; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitTypeProjectionModifiers(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterTypeProjectionModifiers(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitTypeProjectionModifiers(this); + } + } + + public static class TypeProjectionModifierContext extends ParserRuleContext { + public TypeProjectionModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public VarianceModifierContext varianceModifier() { + return getRuleContext(VarianceModifierContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_typeProjectionModifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitTypeProjectionModifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterTypeProjectionModifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitTypeProjectionModifier(this); + } + } + + public static class FunctionTypeContext extends ParserRuleContext { + public FunctionTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public FunctionTypeParametersContext functionTypeParameters() { + return getRuleContext(FunctionTypeParametersContext.class, 0); + } + + public TerminalNode ARROW() { + return getToken(KotlinParser.ARROW, 0); + } + + public TypeContext type() { + return getRuleContext(TypeContext.class, 0); + } + + public ReceiverTypeContext receiverType() { + return getRuleContext(ReceiverTypeContext.class, 0); + } + + public TerminalNode DOT() { + return getToken(KotlinParser.DOT, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_functionType; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitFunctionType(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterFunctionType(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitFunctionType(this); + } + } + + public static class FunctionTypeParametersContext extends ParserRuleContext { + public FunctionTypeParametersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LPAREN() { + return getToken(KotlinParser.LPAREN, 0); + } + + public TerminalNode RPAREN() { + return getToken(KotlinParser.RPAREN, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public List parameter() { + return getRuleContexts(ParameterContext.class); + } + + public ParameterContext parameter(int i) { + return getRuleContext(ParameterContext.class, i); + } + + public List type() { + return getRuleContexts(TypeContext.class); + } + + public TypeContext type(int i) { + return getRuleContext(TypeContext.class, i); + } + + public List COMMA() { + return getTokens(KotlinParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(KotlinParser.COMMA, i); + } + + @Override + public int getRuleIndex() { + return RULE_functionTypeParameters; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitFunctionTypeParameters(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterFunctionTypeParameters(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitFunctionTypeParameters(this); + } + } + + public static class ParenthesizedTypeContext extends ParserRuleContext { + public ParenthesizedTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LPAREN() { + return getToken(KotlinParser.LPAREN, 0); + } + + public TypeContext type() { + return getRuleContext(TypeContext.class, 0); + } + + public TerminalNode RPAREN() { + return getToken(KotlinParser.RPAREN, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_parenthesizedType; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitParenthesizedType(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterParenthesizedType(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitParenthesizedType(this); + } + } + + public static class ReceiverTypeContext extends ParserRuleContext { + public ReceiverTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public ParenthesizedTypeContext parenthesizedType() { + return getRuleContext(ParenthesizedTypeContext.class, 0); + } + + public NullableTypeContext nullableType() { + return getRuleContext(NullableTypeContext.class, 0); + } + + public TypeReferenceContext typeReference() { + return getRuleContext(TypeReferenceContext.class, 0); + } + + public TypeModifiersContext typeModifiers() { + return getRuleContext(TypeModifiersContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_receiverType; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitReceiverType(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterReceiverType(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitReceiverType(this); + } + } + + public static class ParenthesizedUserTypeContext extends ParserRuleContext { + public ParenthesizedUserTypeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LPAREN() { + return getToken(KotlinParser.LPAREN, 0); + } + + public TerminalNode RPAREN() { + return getToken(KotlinParser.RPAREN, 0); + } + + public UserTypeContext userType() { + return getRuleContext(UserTypeContext.class, 0); + } + + public ParenthesizedUserTypeContext parenthesizedUserType() { + return getRuleContext(ParenthesizedUserTypeContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_parenthesizedUserType; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitParenthesizedUserType(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterParenthesizedUserType(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitParenthesizedUserType(this); + } + } + + public static class StatementsContext extends ParserRuleContext { + public StatementsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List statement() { + return getRuleContexts(StatementContext.class); + } + + public StatementContext statement(int i) { + return getRuleContext(StatementContext.class, i); + } + + public List semis() { + return getRuleContexts(SemisContext.class); + } + + public SemisContext semis(int i) { + return getRuleContext(SemisContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_statements; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitStatements(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterStatements(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitStatements(this); + } + } + + public static class StatementContext extends ParserRuleContext { + public StatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public DeclarationContext declaration() { + return getRuleContext(DeclarationContext.class, 0); + } + + public AssignmentContext assignment() { + return getRuleContext(AssignmentContext.class, 0); + } + + public LoopStatementContext loopStatement() { + return getRuleContext(LoopStatementContext.class, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public List label() { + return getRuleContexts(LabelContext.class); + } + + public LabelContext label(int i) { + return getRuleContext(LabelContext.class, i); + } + + public List annotation() { + return getRuleContexts(AnnotationContext.class); + } + + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_statement; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitStatement(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitStatement(this); + } + } + + public static class LabelContext extends ParserRuleContext { + public LabelContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public TerminalNode AT_NO_WS() { + return getToken(KotlinParser.AT_NO_WS, 0); + } + + public TerminalNode AT_POST_WS() { + return getToken(KotlinParser.AT_POST_WS, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_label; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitLabel(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterLabel(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitLabel(this); + } + } + + public static class ControlStructureBodyContext extends ParserRuleContext { + public ControlStructureBodyContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public StatementContext statement() { + return getRuleContext(StatementContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_controlStructureBody; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitControlStructureBody(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterControlStructureBody(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitControlStructureBody(this); + } + } + + public static class BlockContext extends ParserRuleContext { + public BlockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LCURL() { + return getToken(KotlinParser.LCURL, 0); + } + + public StatementsContext statements() { + return getRuleContext(StatementsContext.class, 0); + } + + public TerminalNode RCURL() { + return getToken(KotlinParser.RCURL, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_block; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitBlock(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterBlock(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitBlock(this); + } + } + + public static class LoopStatementContext extends ParserRuleContext { + public LoopStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public ForStatementContext forStatement() { + return getRuleContext(ForStatementContext.class, 0); + } + + public WhileStatementContext whileStatement() { + return getRuleContext(WhileStatementContext.class, 0); + } + + public DoWhileStatementContext doWhileStatement() { + return getRuleContext(DoWhileStatementContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_loopStatement; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitLoopStatement(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterLoopStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitLoopStatement(this); + } + } + + public static class ForStatementContext extends ParserRuleContext { + public ForStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode FOR() { + return getToken(KotlinParser.FOR, 0); + } + + public TerminalNode LPAREN() { + return getToken(KotlinParser.LPAREN, 0); + } + + public TerminalNode IN() { + return getToken(KotlinParser.IN, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode RPAREN() { + return getToken(KotlinParser.RPAREN, 0); + } + + public VariableDeclarationContext variableDeclaration() { + return getRuleContext(VariableDeclarationContext.class, 0); + } + + public MultiVariableDeclarationContext multiVariableDeclaration() { + return getRuleContext(MultiVariableDeclarationContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public List annotation() { + return getRuleContexts(AnnotationContext.class); + } + + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class, i); + } + + public ControlStructureBodyContext controlStructureBody() { + return getRuleContext(ControlStructureBodyContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_forStatement; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitForStatement(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterForStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitForStatement(this); + } + } + + public static class WhileStatementContext extends ParserRuleContext { + public WhileStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode WHILE() { + return getToken(KotlinParser.WHILE, 0); + } + + public TerminalNode LPAREN() { + return getToken(KotlinParser.LPAREN, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode RPAREN() { + return getToken(KotlinParser.RPAREN, 0); + } + + public ControlStructureBodyContext controlStructureBody() { + return getRuleContext(ControlStructureBodyContext.class, 0); + } + + public TerminalNode SEMICOLON() { + return getToken(KotlinParser.SEMICOLON, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_whileStatement; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitWhileStatement(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterWhileStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitWhileStatement(this); + } + } + + public static class DoWhileStatementContext extends ParserRuleContext { + public DoWhileStatementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode DO() { + return getToken(KotlinParser.DO, 0); + } + + public TerminalNode WHILE() { + return getToken(KotlinParser.WHILE, 0); + } + + public TerminalNode LPAREN() { + return getToken(KotlinParser.LPAREN, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode RPAREN() { + return getToken(KotlinParser.RPAREN, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public ControlStructureBodyContext controlStructureBody() { + return getRuleContext(ControlStructureBodyContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_doWhileStatement; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitDoWhileStatement(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterDoWhileStatement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitDoWhileStatement(this); + } + } + + public static class AssignmentContext extends ParserRuleContext { + public AssignmentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public DirectlyAssignableExpressionContext directlyAssignableExpression() { + return getRuleContext(DirectlyAssignableExpressionContext.class, 0); + } + + public TerminalNode ASSIGNMENT() { + return getToken(KotlinParser.ASSIGNMENT, 0); + } + + public AssignableExpressionContext assignableExpression() { + return getRuleContext(AssignableExpressionContext.class, 0); + } + + public AssignmentAndOperatorContext assignmentAndOperator() { + return getRuleContext(AssignmentAndOperatorContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_assignment; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitAssignment(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterAssignment(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitAssignment(this); + } + } + + public static class SemiContext extends ParserRuleContext { + public SemiContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode SEMICOLON() { + return getToken(KotlinParser.SEMICOLON, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public TerminalNode EOF() { + return getToken(KotlinParser.EOF, 0); + } + + @Override + public int getRuleIndex() { + return RULE_semi; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitSemi(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterSemi(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitSemi(this); + } + } + + public static class SemisContext extends ParserRuleContext { + public SemisContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List SEMICOLON() { + return getTokens(KotlinParser.SEMICOLON); + } + + public TerminalNode SEMICOLON(int i) { + return getToken(KotlinParser.SEMICOLON, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public TerminalNode EOF() { + return getToken(KotlinParser.EOF, 0); + } + + @Override + public int getRuleIndex() { + return RULE_semis; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitSemis(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterSemis(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitSemis(this); + } + } + + public static class ExpressionContext extends ParserRuleContext { + public ExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public DisjunctionContext disjunction() { + return getRuleContext(DisjunctionContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_expression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitExpression(this); + } + } + + public static class DisjunctionContext extends ParserRuleContext { + public DisjunctionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List conjunction() { + return getRuleContexts(ConjunctionContext.class); + } + + public ConjunctionContext conjunction(int i) { + return getRuleContext(ConjunctionContext.class, i); + } + + public List DISJ() { + return getTokens(KotlinParser.DISJ); + } + + public TerminalNode DISJ(int i) { + return getToken(KotlinParser.DISJ, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_disjunction; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitDisjunction(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterDisjunction(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitDisjunction(this); + } + } + + public static class ConjunctionContext extends ParserRuleContext { + public ConjunctionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List equality() { + return getRuleContexts(EqualityContext.class); + } + + public EqualityContext equality(int i) { + return getRuleContext(EqualityContext.class, i); + } + + public List CONJ() { + return getTokens(KotlinParser.CONJ); + } + + public TerminalNode CONJ(int i) { + return getToken(KotlinParser.CONJ, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_conjunction; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitConjunction(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterConjunction(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitConjunction(this); + } + } + + public static class EqualityContext extends ParserRuleContext { + public EqualityContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List comparison() { + return getRuleContexts(ComparisonContext.class); + } + + public ComparisonContext comparison(int i) { + return getRuleContext(ComparisonContext.class, i); + } + + public List equalityOperator() { + return getRuleContexts(EqualityOperatorContext.class); + } + + public EqualityOperatorContext equalityOperator(int i) { + return getRuleContext(EqualityOperatorContext.class, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_equality; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitEquality(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterEquality(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitEquality(this); + } + } + + public static class ComparisonContext extends ParserRuleContext { + public ComparisonContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List genericCallLikeComparison() { + return getRuleContexts(GenericCallLikeComparisonContext.class); + } + + public GenericCallLikeComparisonContext genericCallLikeComparison(int i) { + return getRuleContext(GenericCallLikeComparisonContext.class, i); + } + + public List comparisonOperator() { + return getRuleContexts(ComparisonOperatorContext.class); + } + + public ComparisonOperatorContext comparisonOperator(int i) { + return getRuleContext(ComparisonOperatorContext.class, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_comparison; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitComparison(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterComparison(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitComparison(this); + } + } + + public static class GenericCallLikeComparisonContext extends ParserRuleContext { + public GenericCallLikeComparisonContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public InfixOperationContext infixOperation() { + return getRuleContext(InfixOperationContext.class, 0); + } + + public List callSuffix() { + return getRuleContexts(CallSuffixContext.class); + } + + public CallSuffixContext callSuffix(int i) { + return getRuleContext(CallSuffixContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_genericCallLikeComparison; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitGenericCallLikeComparison(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterGenericCallLikeComparison(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitGenericCallLikeComparison(this); + } + } + + public static class InfixOperationContext extends ParserRuleContext { + public InfixOperationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List elvisExpression() { + return getRuleContexts(ElvisExpressionContext.class); + } + + public ElvisExpressionContext elvisExpression(int i) { + return getRuleContext(ElvisExpressionContext.class, i); + } + + public List inOperator() { + return getRuleContexts(InOperatorContext.class); + } + + public InOperatorContext inOperator(int i) { + return getRuleContext(InOperatorContext.class, i); + } + + public List isOperator() { + return getRuleContexts(IsOperatorContext.class); + } + + public IsOperatorContext isOperator(int i) { + return getRuleContext(IsOperatorContext.class, i); + } + + public List type() { + return getRuleContexts(TypeContext.class); + } + + public TypeContext type(int i) { + return getRuleContext(TypeContext.class, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_infixOperation; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitInfixOperation(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterInfixOperation(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitInfixOperation(this); + } + } + + public static class ElvisExpressionContext extends ParserRuleContext { + public ElvisExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List infixFunctionCall() { + return getRuleContexts(InfixFunctionCallContext.class); + } + + public InfixFunctionCallContext infixFunctionCall(int i) { + return getRuleContext(InfixFunctionCallContext.class, i); + } + + public List elvis() { + return getRuleContexts(ElvisContext.class); + } + + public ElvisContext elvis(int i) { + return getRuleContext(ElvisContext.class, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_elvisExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitElvisExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterElvisExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitElvisExpression(this); + } + } + + public static class ElvisContext extends ParserRuleContext { + public ElvisContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode QUEST_NO_WS() { + return getToken(KotlinParser.QUEST_NO_WS, 0); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + @Override + public int getRuleIndex() { + return RULE_elvis; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitElvis(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterElvis(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitElvis(this); + } + } + + public static class InfixFunctionCallContext extends ParserRuleContext { + public InfixFunctionCallContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List rangeExpression() { + return getRuleContexts(RangeExpressionContext.class); + } + + public RangeExpressionContext rangeExpression(int i) { + return getRuleContext(RangeExpressionContext.class, i); + } + + public List simpleIdentifier() { + return getRuleContexts(SimpleIdentifierContext.class); + } + + public SimpleIdentifierContext simpleIdentifier(int i) { + return getRuleContext(SimpleIdentifierContext.class, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_infixFunctionCall; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitInfixFunctionCall(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterInfixFunctionCall(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitInfixFunctionCall(this); + } + } + + public static class RangeExpressionContext extends ParserRuleContext { + public RangeExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List additiveExpression() { + return getRuleContexts(AdditiveExpressionContext.class); + } + + public AdditiveExpressionContext additiveExpression(int i) { + return getRuleContext(AdditiveExpressionContext.class, i); + } + + public List RANGE() { + return getTokens(KotlinParser.RANGE); + } + + public TerminalNode RANGE(int i) { + return getToken(KotlinParser.RANGE, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_rangeExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitRangeExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterRangeExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitRangeExpression(this); + } + } + + public static class AdditiveExpressionContext extends ParserRuleContext { + public AdditiveExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List multiplicativeExpression() { + return getRuleContexts(MultiplicativeExpressionContext.class); + } + + public MultiplicativeExpressionContext multiplicativeExpression(int i) { + return getRuleContext(MultiplicativeExpressionContext.class, i); + } + + public List additiveOperator() { + return getRuleContexts(AdditiveOperatorContext.class); + } + + public AdditiveOperatorContext additiveOperator(int i) { + return getRuleContext(AdditiveOperatorContext.class, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_additiveExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitAdditiveExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterAdditiveExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitAdditiveExpression(this); + } + } + + public static class MultiplicativeExpressionContext extends ParserRuleContext { + public MultiplicativeExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List asExpression() { + return getRuleContexts(AsExpressionContext.class); + } + + public AsExpressionContext asExpression(int i) { + return getRuleContext(AsExpressionContext.class, i); + } + + public List multiplicativeOperator() { + return getRuleContexts(MultiplicativeOperatorContext.class); + } + + public MultiplicativeOperatorContext multiplicativeOperator(int i) { + return getRuleContext(MultiplicativeOperatorContext.class, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_multiplicativeExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitMultiplicativeExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterMultiplicativeExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitMultiplicativeExpression(this); + } + } + + public static class AsExpressionContext extends ParserRuleContext { + public AsExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public PrefixUnaryExpressionContext prefixUnaryExpression() { + return getRuleContext(PrefixUnaryExpressionContext.class, 0); + } + + public List asOperator() { + return getRuleContexts(AsOperatorContext.class); + } + + public AsOperatorContext asOperator(int i) { + return getRuleContext(AsOperatorContext.class, i); + } + + public List type() { + return getRuleContexts(TypeContext.class); + } + + public TypeContext type(int i) { + return getRuleContext(TypeContext.class, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_asExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitAsExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterAsExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitAsExpression(this); + } + } + + public static class PrefixUnaryExpressionContext extends ParserRuleContext { + public PrefixUnaryExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public PostfixUnaryExpressionContext postfixUnaryExpression() { + return getRuleContext(PostfixUnaryExpressionContext.class, 0); + } + + public List unaryPrefix() { + return getRuleContexts(UnaryPrefixContext.class); + } + + public UnaryPrefixContext unaryPrefix(int i) { + return getRuleContext(UnaryPrefixContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_prefixUnaryExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitPrefixUnaryExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterPrefixUnaryExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitPrefixUnaryExpression(this); + } + } + + public static class UnaryPrefixContext extends ParserRuleContext { + public UnaryPrefixContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class, 0); + } + + public LabelContext label() { + return getRuleContext(LabelContext.class, 0); + } + + public PrefixUnaryOperatorContext prefixUnaryOperator() { + return getRuleContext(PrefixUnaryOperatorContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_unaryPrefix; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitUnaryPrefix(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterUnaryPrefix(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitUnaryPrefix(this); + } + } + + public static class PostfixUnaryExpressionContext extends ParserRuleContext { + public PostfixUnaryExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public PrimaryExpressionContext primaryExpression() { + return getRuleContext(PrimaryExpressionContext.class, 0); + } + + public List postfixUnarySuffix() { + return getRuleContexts(PostfixUnarySuffixContext.class); + } + + public PostfixUnarySuffixContext postfixUnarySuffix(int i) { + return getRuleContext(PostfixUnarySuffixContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_postfixUnaryExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitPostfixUnaryExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterPostfixUnaryExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitPostfixUnaryExpression(this); + } + } + + public static class PostfixUnarySuffixContext extends ParserRuleContext { + public PostfixUnarySuffixContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public PostfixUnaryOperatorContext postfixUnaryOperator() { + return getRuleContext(PostfixUnaryOperatorContext.class, 0); + } + + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class, 0); + } + + public CallSuffixContext callSuffix() { + return getRuleContext(CallSuffixContext.class, 0); + } + + public IndexingSuffixContext indexingSuffix() { + return getRuleContext(IndexingSuffixContext.class, 0); + } + + public NavigationSuffixContext navigationSuffix() { + return getRuleContext(NavigationSuffixContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_postfixUnarySuffix; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitPostfixUnarySuffix(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterPostfixUnarySuffix(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitPostfixUnarySuffix(this); + } + } + + public static class DirectlyAssignableExpressionContext extends ParserRuleContext { + public DirectlyAssignableExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public PostfixUnaryExpressionContext postfixUnaryExpression() { + return getRuleContext(PostfixUnaryExpressionContext.class, 0); + } + + public AssignableSuffixContext assignableSuffix() { + return getRuleContext(AssignableSuffixContext.class, 0); + } + + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public ParenthesizedDirectlyAssignableExpressionContext + parenthesizedDirectlyAssignableExpression() { + return getRuleContext(ParenthesizedDirectlyAssignableExpressionContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_directlyAssignableExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitDirectlyAssignableExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterDirectlyAssignableExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitDirectlyAssignableExpression(this); + } + } + + public static class ParenthesizedDirectlyAssignableExpressionContext extends ParserRuleContext { + public ParenthesizedDirectlyAssignableExpressionContext( + ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LPAREN() { + return getToken(KotlinParser.LPAREN, 0); + } + + public DirectlyAssignableExpressionContext directlyAssignableExpression() { + return getRuleContext(DirectlyAssignableExpressionContext.class, 0); + } + + public TerminalNode RPAREN() { + return getToken(KotlinParser.RPAREN, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_parenthesizedDirectlyAssignableExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor) + .visitParenthesizedDirectlyAssignableExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterParenthesizedDirectlyAssignableExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitParenthesizedDirectlyAssignableExpression(this); + } + } + + public static class AssignableExpressionContext extends ParserRuleContext { + public AssignableExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public PrefixUnaryExpressionContext prefixUnaryExpression() { + return getRuleContext(PrefixUnaryExpressionContext.class, 0); + } + + public ParenthesizedAssignableExpressionContext parenthesizedAssignableExpression() { + return getRuleContext(ParenthesizedAssignableExpressionContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_assignableExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitAssignableExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterAssignableExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitAssignableExpression(this); + } + } + + public static class ParenthesizedAssignableExpressionContext extends ParserRuleContext { + public ParenthesizedAssignableExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LPAREN() { + return getToken(KotlinParser.LPAREN, 0); + } + + public AssignableExpressionContext assignableExpression() { + return getRuleContext(AssignableExpressionContext.class, 0); + } + + public TerminalNode RPAREN() { + return getToken(KotlinParser.RPAREN, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_parenthesizedAssignableExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor) + .visitParenthesizedAssignableExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterParenthesizedAssignableExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitParenthesizedAssignableExpression(this); + } + } + + public static class AssignableSuffixContext extends ParserRuleContext { + public AssignableSuffixContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class, 0); + } + + public IndexingSuffixContext indexingSuffix() { + return getRuleContext(IndexingSuffixContext.class, 0); + } + + public NavigationSuffixContext navigationSuffix() { + return getRuleContext(NavigationSuffixContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_assignableSuffix; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitAssignableSuffix(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterAssignableSuffix(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitAssignableSuffix(this); + } + } + + public static class IndexingSuffixContext extends ParserRuleContext { + public IndexingSuffixContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LSQUARE() { + return getToken(KotlinParser.LSQUARE, 0); + } + + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class, i); + } + + public TerminalNode RSQUARE() { + return getToken(KotlinParser.RSQUARE, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public List COMMA() { + return getTokens(KotlinParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(KotlinParser.COMMA, i); + } + + @Override + public int getRuleIndex() { + return RULE_indexingSuffix; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitIndexingSuffix(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterIndexingSuffix(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitIndexingSuffix(this); + } + } + + public static class NavigationSuffixContext extends ParserRuleContext { + public NavigationSuffixContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public MemberAccessOperatorContext memberAccessOperator() { + return getRuleContext(MemberAccessOperatorContext.class, 0); + } + + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public ParenthesizedExpressionContext parenthesizedExpression() { + return getRuleContext(ParenthesizedExpressionContext.class, 0); + } + + public TerminalNode CLASS() { + return getToken(KotlinParser.CLASS, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_navigationSuffix; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitNavigationSuffix(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterNavigationSuffix(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitNavigationSuffix(this); + } + } + + public static class CallSuffixContext extends ParserRuleContext { + public CallSuffixContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public AnnotatedLambdaContext annotatedLambda() { + return getRuleContext(AnnotatedLambdaContext.class, 0); + } + + public ValueArgumentsContext valueArguments() { + return getRuleContext(ValueArgumentsContext.class, 0); + } + + public TypeArgumentsContext typeArguments() { + return getRuleContext(TypeArgumentsContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_callSuffix; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitCallSuffix(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterCallSuffix(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitCallSuffix(this); + } + } + + public static class AnnotatedLambdaContext extends ParserRuleContext { + public AnnotatedLambdaContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public LambdaLiteralContext lambdaLiteral() { + return getRuleContext(LambdaLiteralContext.class, 0); + } + + public List annotation() { + return getRuleContexts(AnnotationContext.class); + } + + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class, i); + } + + public LabelContext label() { + return getRuleContext(LabelContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_annotatedLambda; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitAnnotatedLambda(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterAnnotatedLambda(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitAnnotatedLambda(this); + } + } + + public static class TypeArgumentsContext extends ParserRuleContext { + public TypeArgumentsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LANGLE() { + return getToken(KotlinParser.LANGLE, 0); + } + + public List typeProjection() { + return getRuleContexts(TypeProjectionContext.class); + } + + public TypeProjectionContext typeProjection(int i) { + return getRuleContext(TypeProjectionContext.class, i); + } + + public TerminalNode RANGLE() { + return getToken(KotlinParser.RANGLE, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public List COMMA() { + return getTokens(KotlinParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(KotlinParser.COMMA, i); + } + + @Override + public int getRuleIndex() { + return RULE_typeArguments; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitTypeArguments(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterTypeArguments(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitTypeArguments(this); + } + } + + public static class ValueArgumentsContext extends ParserRuleContext { + public ValueArgumentsContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LPAREN() { + return getToken(KotlinParser.LPAREN, 0); + } + + public TerminalNode RPAREN() { + return getToken(KotlinParser.RPAREN, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public List valueArgument() { + return getRuleContexts(ValueArgumentContext.class); + } + + public ValueArgumentContext valueArgument(int i) { + return getRuleContext(ValueArgumentContext.class, i); + } + + public List COMMA() { + return getTokens(KotlinParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(KotlinParser.COMMA, i); + } + + @Override + public int getRuleIndex() { + return RULE_valueArguments; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitValueArguments(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterValueArguments(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitValueArguments(this); + } + } + + public static class ValueArgumentContext extends ParserRuleContext { + public ValueArgumentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public TerminalNode ASSIGNMENT() { + return getToken(KotlinParser.ASSIGNMENT, 0); + } + + public TerminalNode MULT() { + return getToken(KotlinParser.MULT, 0); + } + + @Override + public int getRuleIndex() { + return RULE_valueArgument; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitValueArgument(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterValueArgument(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitValueArgument(this); + } + } + + public static class PrimaryExpressionContext extends ParserRuleContext { + public PrimaryExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public ParenthesizedExpressionContext parenthesizedExpression() { + return getRuleContext(ParenthesizedExpressionContext.class, 0); + } + + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public LiteralConstantContext literalConstant() { + return getRuleContext(LiteralConstantContext.class, 0); + } + + public StringLiteralContext stringLiteral() { + return getRuleContext(StringLiteralContext.class, 0); + } + + public CallableReferenceContext callableReference() { + return getRuleContext(CallableReferenceContext.class, 0); + } + + public FunctionLiteralContext functionLiteral() { + return getRuleContext(FunctionLiteralContext.class, 0); + } + + public ObjectLiteralContext objectLiteral() { + return getRuleContext(ObjectLiteralContext.class, 0); + } + + public CollectionLiteralContext collectionLiteral() { + return getRuleContext(CollectionLiteralContext.class, 0); + } + + public ThisExpressionContext thisExpression() { + return getRuleContext(ThisExpressionContext.class, 0); + } + + public SuperExpressionContext superExpression() { + return getRuleContext(SuperExpressionContext.class, 0); + } + + public IfExpressionContext ifExpression() { + return getRuleContext(IfExpressionContext.class, 0); + } + + public WhenExpressionContext whenExpression() { + return getRuleContext(WhenExpressionContext.class, 0); + } + + public TryExpressionContext tryExpression() { + return getRuleContext(TryExpressionContext.class, 0); + } + + public JumpExpressionContext jumpExpression() { + return getRuleContext(JumpExpressionContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_primaryExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitPrimaryExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterPrimaryExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitPrimaryExpression(this); + } + } + + public static class ParenthesizedExpressionContext extends ParserRuleContext { + public ParenthesizedExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LPAREN() { + return getToken(KotlinParser.LPAREN, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode RPAREN() { + return getToken(KotlinParser.RPAREN, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_parenthesizedExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitParenthesizedExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterParenthesizedExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitParenthesizedExpression(this); + } + } + + public static class CollectionLiteralContext extends ParserRuleContext { + public CollectionLiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LSQUARE() { + return getToken(KotlinParser.LSQUARE, 0); + } + + public TerminalNode RSQUARE() { + return getToken(KotlinParser.RSQUARE, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public List expression() { + return getRuleContexts(ExpressionContext.class); + } + + public ExpressionContext expression(int i) { + return getRuleContext(ExpressionContext.class, i); + } + + public List COMMA() { + return getTokens(KotlinParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(KotlinParser.COMMA, i); + } + + @Override + public int getRuleIndex() { + return RULE_collectionLiteral; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitCollectionLiteral(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterCollectionLiteral(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitCollectionLiteral(this); + } + } + + public static class LiteralConstantContext extends ParserRuleContext { + public LiteralConstantContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode BooleanLiteral() { + return getToken(KotlinParser.BooleanLiteral, 0); + } + + public TerminalNode IntegerLiteral() { + return getToken(KotlinParser.IntegerLiteral, 0); + } + + public TerminalNode HexLiteral() { + return getToken(KotlinParser.HexLiteral, 0); + } + + public TerminalNode BinLiteral() { + return getToken(KotlinParser.BinLiteral, 0); + } + + public TerminalNode CharacterLiteral() { + return getToken(KotlinParser.CharacterLiteral, 0); + } + + public TerminalNode RealLiteral() { + return getToken(KotlinParser.RealLiteral, 0); + } + + public TerminalNode NullLiteral() { + return getToken(KotlinParser.NullLiteral, 0); + } + + public TerminalNode LongLiteral() { + return getToken(KotlinParser.LongLiteral, 0); + } + + public TerminalNode UnsignedLiteral() { + return getToken(KotlinParser.UnsignedLiteral, 0); + } + + @Override + public int getRuleIndex() { + return RULE_literalConstant; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitLiteralConstant(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterLiteralConstant(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitLiteralConstant(this); + } + } + + public static class StringLiteralContext extends ParserRuleContext { + public StringLiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public LineStringLiteralContext lineStringLiteral() { + return getRuleContext(LineStringLiteralContext.class, 0); + } + + public MultiLineStringLiteralContext multiLineStringLiteral() { + return getRuleContext(MultiLineStringLiteralContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_stringLiteral; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitStringLiteral(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterStringLiteral(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitStringLiteral(this); + } + } + + public static class LineStringLiteralContext extends ParserRuleContext { + public LineStringLiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode QUOTE_OPEN() { + return getToken(KotlinParser.QUOTE_OPEN, 0); + } + + public TerminalNode QUOTE_CLOSE() { + return getToken(KotlinParser.QUOTE_CLOSE, 0); + } + + public List lineStringContent() { + return getRuleContexts(LineStringContentContext.class); + } + + public LineStringContentContext lineStringContent(int i) { + return getRuleContext(LineStringContentContext.class, i); + } + + public List lineStringExpression() { + return getRuleContexts(LineStringExpressionContext.class); + } + + public LineStringExpressionContext lineStringExpression(int i) { + return getRuleContext(LineStringExpressionContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_lineStringLiteral; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitLineStringLiteral(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterLineStringLiteral(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitLineStringLiteral(this); + } + } + + public static class MultiLineStringLiteralContext extends ParserRuleContext { + public MultiLineStringLiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode TRIPLE_QUOTE_OPEN() { + return getToken(KotlinParser.TRIPLE_QUOTE_OPEN, 0); + } + + public TerminalNode TRIPLE_QUOTE_CLOSE() { + return getToken(KotlinParser.TRIPLE_QUOTE_CLOSE, 0); + } + + public List multiLineStringContent() { + return getRuleContexts(MultiLineStringContentContext.class); + } + + public MultiLineStringContentContext multiLineStringContent(int i) { + return getRuleContext(MultiLineStringContentContext.class, i); + } + + public List multiLineStringExpression() { + return getRuleContexts(MultiLineStringExpressionContext.class); + } + + public MultiLineStringExpressionContext multiLineStringExpression(int i) { + return getRuleContext(MultiLineStringExpressionContext.class, i); + } + + public List MultiLineStringQuote() { + return getTokens(KotlinParser.MultiLineStringQuote); + } + + public TerminalNode MultiLineStringQuote(int i) { + return getToken(KotlinParser.MultiLineStringQuote, i); + } + + @Override + public int getRuleIndex() { + return RULE_multiLineStringLiteral; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitMultiLineStringLiteral(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterMultiLineStringLiteral(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitMultiLineStringLiteral(this); + } + } + + public static class LineStringContentContext extends ParserRuleContext { + public LineStringContentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LineStrText() { + return getToken(KotlinParser.LineStrText, 0); + } + + public TerminalNode LineStrEscapedChar() { + return getToken(KotlinParser.LineStrEscapedChar, 0); + } + + public TerminalNode LineStrRef() { + return getToken(KotlinParser.LineStrRef, 0); + } + + @Override + public int getRuleIndex() { + return RULE_lineStringContent; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitLineStringContent(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterLineStringContent(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitLineStringContent(this); + } + } + + public static class LineStringExpressionContext extends ParserRuleContext { + public LineStringExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LineStrExprStart() { + return getToken(KotlinParser.LineStrExprStart, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode RCURL() { + return getToken(KotlinParser.RCURL, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_lineStringExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitLineStringExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterLineStringExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitLineStringExpression(this); + } + } + + public static class MultiLineStringContentContext extends ParserRuleContext { + public MultiLineStringContentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode MultiLineStrText() { + return getToken(KotlinParser.MultiLineStrText, 0); + } + + public TerminalNode MultiLineStringQuote() { + return getToken(KotlinParser.MultiLineStringQuote, 0); + } + + public TerminalNode MultiLineStrRef() { + return getToken(KotlinParser.MultiLineStrRef, 0); + } + + @Override + public int getRuleIndex() { + return RULE_multiLineStringContent; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitMultiLineStringContent(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterMultiLineStringContent(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitMultiLineStringContent(this); + } + } + + public static class MultiLineStringExpressionContext extends ParserRuleContext { + public MultiLineStringExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode MultiLineStrExprStart() { + return getToken(KotlinParser.MultiLineStrExprStart, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode RCURL() { + return getToken(KotlinParser.RCURL, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_multiLineStringExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitMultiLineStringExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterMultiLineStringExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitMultiLineStringExpression(this); + } + } + + public static class LambdaLiteralContext extends ParserRuleContext { + public LambdaLiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LCURL() { + return getToken(KotlinParser.LCURL, 0); + } + + public StatementsContext statements() { + return getRuleContext(StatementsContext.class, 0); + } + + public TerminalNode RCURL() { + return getToken(KotlinParser.RCURL, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public TerminalNode ARROW() { + return getToken(KotlinParser.ARROW, 0); + } + + public LambdaParametersContext lambdaParameters() { + return getRuleContext(LambdaParametersContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_lambdaLiteral; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitLambdaLiteral(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterLambdaLiteral(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitLambdaLiteral(this); + } + } + + public static class LambdaParametersContext extends ParserRuleContext { + public LambdaParametersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List lambdaParameter() { + return getRuleContexts(LambdaParameterContext.class); + } + + public LambdaParameterContext lambdaParameter(int i) { + return getRuleContext(LambdaParameterContext.class, i); + } + + public List COMMA() { + return getTokens(KotlinParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(KotlinParser.COMMA, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_lambdaParameters; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitLambdaParameters(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterLambdaParameters(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitLambdaParameters(this); + } + } + + public static class LambdaParameterContext extends ParserRuleContext { + public LambdaParameterContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public VariableDeclarationContext variableDeclaration() { + return getRuleContext(VariableDeclarationContext.class, 0); + } + + public MultiVariableDeclarationContext multiVariableDeclaration() { + return getRuleContext(MultiVariableDeclarationContext.class, 0); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public TypeContext type() { + return getRuleContext(TypeContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_lambdaParameter; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitLambdaParameter(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterLambdaParameter(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitLambdaParameter(this); + } + } + + public static class AnonymousFunctionContext extends ParserRuleContext { + public AnonymousFunctionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode FUN() { + return getToken(KotlinParser.FUN, 0); + } + + public ParametersWithOptionalTypeContext parametersWithOptionalType() { + return getRuleContext(ParametersWithOptionalTypeContext.class, 0); + } + + public List type() { + return getRuleContexts(TypeContext.class); + } + + public TypeContext type(int i) { + return getRuleContext(TypeContext.class, i); + } + + public TerminalNode DOT() { + return getToken(KotlinParser.DOT, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public TypeConstraintsContext typeConstraints() { + return getRuleContext(TypeConstraintsContext.class, 0); + } + + public FunctionBodyContext functionBody() { + return getRuleContext(FunctionBodyContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_anonymousFunction; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitAnonymousFunction(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterAnonymousFunction(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitAnonymousFunction(this); + } + } + + public static class FunctionLiteralContext extends ParserRuleContext { + public FunctionLiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public LambdaLiteralContext lambdaLiteral() { + return getRuleContext(LambdaLiteralContext.class, 0); + } + + public AnonymousFunctionContext anonymousFunction() { + return getRuleContext(AnonymousFunctionContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_functionLiteral; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitFunctionLiteral(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterFunctionLiteral(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitFunctionLiteral(this); + } + } + + public static class ObjectLiteralContext extends ParserRuleContext { + public ObjectLiteralContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode OBJECT() { + return getToken(KotlinParser.OBJECT, 0); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public DelegationSpecifiersContext delegationSpecifiers() { + return getRuleContext(DelegationSpecifiersContext.class, 0); + } + + public ClassBodyContext classBody() { + return getRuleContext(ClassBodyContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_objectLiteral; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitObjectLiteral(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterObjectLiteral(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitObjectLiteral(this); + } + } + + public static class ThisExpressionContext extends ParserRuleContext { + public ThisExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode THIS() { + return getToken(KotlinParser.THIS, 0); + } + + public TerminalNode THIS_AT() { + return getToken(KotlinParser.THIS_AT, 0); + } + + @Override + public int getRuleIndex() { + return RULE_thisExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitThisExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterThisExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitThisExpression(this); + } + } + + public static class SuperExpressionContext extends ParserRuleContext { + public SuperExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode SUPER() { + return getToken(KotlinParser.SUPER, 0); + } + + public TerminalNode LANGLE() { + return getToken(KotlinParser.LANGLE, 0); + } + + public TypeContext type() { + return getRuleContext(TypeContext.class, 0); + } + + public TerminalNode RANGLE() { + return getToken(KotlinParser.RANGLE, 0); + } + + public TerminalNode AT_NO_WS() { + return getToken(KotlinParser.AT_NO_WS, 0); + } + + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public TerminalNode SUPER_AT() { + return getToken(KotlinParser.SUPER_AT, 0); + } + + @Override + public int getRuleIndex() { + return RULE_superExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitSuperExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterSuperExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitSuperExpression(this); + } + } + + public static class IfExpressionContext extends ParserRuleContext { + public IfExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode IF() { + return getToken(KotlinParser.IF, 0); + } + + public TerminalNode LPAREN() { + return getToken(KotlinParser.LPAREN, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode RPAREN() { + return getToken(KotlinParser.RPAREN, 0); + } + + public List controlStructureBody() { + return getRuleContexts(ControlStructureBodyContext.class); + } + + public ControlStructureBodyContext controlStructureBody(int i) { + return getRuleContext(ControlStructureBodyContext.class, i); + } + + public TerminalNode ELSE() { + return getToken(KotlinParser.ELSE, 0); + } + + public List SEMICOLON() { + return getTokens(KotlinParser.SEMICOLON); + } + + public TerminalNode SEMICOLON(int i) { + return getToken(KotlinParser.SEMICOLON, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_ifExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitIfExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterIfExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitIfExpression(this); + } + } + + public static class WhenSubjectContext extends ParserRuleContext { + public WhenSubjectContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LPAREN() { + return getToken(KotlinParser.LPAREN, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public TerminalNode RPAREN() { + return getToken(KotlinParser.RPAREN, 0); + } + + public TerminalNode VAL() { + return getToken(KotlinParser.VAL, 0); + } + + public VariableDeclarationContext variableDeclaration() { + return getRuleContext(VariableDeclarationContext.class, 0); + } + + public TerminalNode ASSIGNMENT() { + return getToken(KotlinParser.ASSIGNMENT, 0); + } + + public List annotation() { + return getRuleContexts(AnnotationContext.class); + } + + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_whenSubject; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitWhenSubject(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterWhenSubject(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitWhenSubject(this); + } + } + + public static class WhenExpressionContext extends ParserRuleContext { + public WhenExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode WHEN() { + return getToken(KotlinParser.WHEN, 0); + } + + public TerminalNode LCURL() { + return getToken(KotlinParser.LCURL, 0); + } + + public TerminalNode RCURL() { + return getToken(KotlinParser.RCURL, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public WhenSubjectContext whenSubject() { + return getRuleContext(WhenSubjectContext.class, 0); + } + + public List whenEntry() { + return getRuleContexts(WhenEntryContext.class); + } + + public WhenEntryContext whenEntry(int i) { + return getRuleContext(WhenEntryContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_whenExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitWhenExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterWhenExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitWhenExpression(this); + } + } + + public static class WhenEntryContext extends ParserRuleContext { + public WhenEntryContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List whenCondition() { + return getRuleContexts(WhenConditionContext.class); + } + + public WhenConditionContext whenCondition(int i) { + return getRuleContext(WhenConditionContext.class, i); + } + + public TerminalNode ARROW() { + return getToken(KotlinParser.ARROW, 0); + } + + public ControlStructureBodyContext controlStructureBody() { + return getRuleContext(ControlStructureBodyContext.class, 0); + } + + public List COMMA() { + return getTokens(KotlinParser.COMMA); + } + + public TerminalNode COMMA(int i) { + return getToken(KotlinParser.COMMA, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public SemiContext semi() { + return getRuleContext(SemiContext.class, 0); + } + + public TerminalNode ELSE() { + return getToken(KotlinParser.ELSE, 0); + } + + @Override + public int getRuleIndex() { + return RULE_whenEntry; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitWhenEntry(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterWhenEntry(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitWhenEntry(this); + } + } + + public static class WhenConditionContext extends ParserRuleContext { + public WhenConditionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public RangeTestContext rangeTest() { + return getRuleContext(RangeTestContext.class, 0); + } + + public TypeTestContext typeTest() { + return getRuleContext(TypeTestContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_whenCondition; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitWhenCondition(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterWhenCondition(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitWhenCondition(this); + } + } + + public static class RangeTestContext extends ParserRuleContext { + public RangeTestContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public InOperatorContext inOperator() { + return getRuleContext(InOperatorContext.class, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_rangeTest; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitRangeTest(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterRangeTest(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitRangeTest(this); + } + } + + public static class TypeTestContext extends ParserRuleContext { + public TypeTestContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public IsOperatorContext isOperator() { + return getRuleContext(IsOperatorContext.class, 0); + } + + public TypeContext type() { + return getRuleContext(TypeContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_typeTest; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitTypeTest(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterTypeTest(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitTypeTest(this); + } + } + + public static class TryExpressionContext extends ParserRuleContext { + public TryExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode TRY() { + return getToken(KotlinParser.TRY, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public FinallyBlockContext finallyBlock() { + return getRuleContext(FinallyBlockContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public List catchBlock() { + return getRuleContexts(CatchBlockContext.class); + } + + public CatchBlockContext catchBlock(int i) { + return getRuleContext(CatchBlockContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_tryExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitTryExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterTryExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitTryExpression(this); + } + } + + public static class CatchBlockContext extends ParserRuleContext { + public CatchBlockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode CATCH() { + return getToken(KotlinParser.CATCH, 0); + } + + public TerminalNode LPAREN() { + return getToken(KotlinParser.LPAREN, 0); + } + + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public TypeContext type() { + return getRuleContext(TypeContext.class, 0); + } + + public TerminalNode RPAREN() { + return getToken(KotlinParser.RPAREN, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public List annotation() { + return getRuleContexts(AnnotationContext.class); + } + + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class, i); + } + + public TerminalNode COMMA() { + return getToken(KotlinParser.COMMA, 0); + } + + @Override + public int getRuleIndex() { + return RULE_catchBlock; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitCatchBlock(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterCatchBlock(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitCatchBlock(this); + } + } + + public static class FinallyBlockContext extends ParserRuleContext { + public FinallyBlockContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode FINALLY() { + return getToken(KotlinParser.FINALLY, 0); + } + + public BlockContext block() { + return getRuleContext(BlockContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_finallyBlock; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitFinallyBlock(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterFinallyBlock(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitFinallyBlock(this); + } + } + + public static class JumpExpressionContext extends ParserRuleContext { + public JumpExpressionContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode THROW() { + return getToken(KotlinParser.THROW, 0); + } + + public ExpressionContext expression() { + return getRuleContext(ExpressionContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public TerminalNode RETURN() { + return getToken(KotlinParser.RETURN, 0); + } + + public TerminalNode RETURN_AT() { + return getToken(KotlinParser.RETURN_AT, 0); + } + + public TerminalNode CONTINUE() { + return getToken(KotlinParser.CONTINUE, 0); + } + + public TerminalNode CONTINUE_AT() { + return getToken(KotlinParser.CONTINUE_AT, 0); + } + + public TerminalNode BREAK() { + return getToken(KotlinParser.BREAK, 0); + } + + public TerminalNode BREAK_AT() { + return getToken(KotlinParser.BREAK_AT, 0); + } + + @Override + public int getRuleIndex() { + return RULE_jumpExpression; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitJumpExpression(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterJumpExpression(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitJumpExpression(this); + } + } + + public static class CallableReferenceContext extends ParserRuleContext { + public CallableReferenceContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode COLONCOLON() { + return getToken(KotlinParser.COLONCOLON, 0); + } + + public SimpleIdentifierContext simpleIdentifier() { + return getRuleContext(SimpleIdentifierContext.class, 0); + } + + public TerminalNode CLASS() { + return getToken(KotlinParser.CLASS, 0); + } + + public ReceiverTypeContext receiverType() { + return getRuleContext(ReceiverTypeContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_callableReference; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitCallableReference(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterCallableReference(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitCallableReference(this); + } + } + + public static class AssignmentAndOperatorContext extends ParserRuleContext { + public AssignmentAndOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode ADD_ASSIGNMENT() { + return getToken(KotlinParser.ADD_ASSIGNMENT, 0); + } + + public TerminalNode SUB_ASSIGNMENT() { + return getToken(KotlinParser.SUB_ASSIGNMENT, 0); + } + + public TerminalNode MULT_ASSIGNMENT() { + return getToken(KotlinParser.MULT_ASSIGNMENT, 0); + } + + public TerminalNode DIV_ASSIGNMENT() { + return getToken(KotlinParser.DIV_ASSIGNMENT, 0); + } + + public TerminalNode MOD_ASSIGNMENT() { + return getToken(KotlinParser.MOD_ASSIGNMENT, 0); + } + + @Override + public int getRuleIndex() { + return RULE_assignmentAndOperator; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitAssignmentAndOperator(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterAssignmentAndOperator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitAssignmentAndOperator(this); + } + } + + public static class EqualityOperatorContext extends ParserRuleContext { + public EqualityOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode EXCL_EQ() { + return getToken(KotlinParser.EXCL_EQ, 0); + } + + public TerminalNode EXCL_EQEQ() { + return getToken(KotlinParser.EXCL_EQEQ, 0); + } + + public TerminalNode EQEQ() { + return getToken(KotlinParser.EQEQ, 0); + } + + public TerminalNode EQEQEQ() { + return getToken(KotlinParser.EQEQEQ, 0); + } + + @Override + public int getRuleIndex() { + return RULE_equalityOperator; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitEqualityOperator(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterEqualityOperator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitEqualityOperator(this); + } + } + + public static class ComparisonOperatorContext extends ParserRuleContext { + public ComparisonOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LANGLE() { + return getToken(KotlinParser.LANGLE, 0); + } + + public TerminalNode RANGLE() { + return getToken(KotlinParser.RANGLE, 0); + } + + public TerminalNode LE() { + return getToken(KotlinParser.LE, 0); + } + + public TerminalNode GE() { + return getToken(KotlinParser.GE, 0); + } + + @Override + public int getRuleIndex() { + return RULE_comparisonOperator; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitComparisonOperator(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterComparisonOperator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitComparisonOperator(this); + } + } + + public static class InOperatorContext extends ParserRuleContext { + public InOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode IN() { + return getToken(KotlinParser.IN, 0); + } + + public TerminalNode NOT_IN() { + return getToken(KotlinParser.NOT_IN, 0); + } + + @Override + public int getRuleIndex() { + return RULE_inOperator; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitInOperator(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterInOperator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitInOperator(this); + } + } + + public static class IsOperatorContext extends ParserRuleContext { + public IsOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode IS() { + return getToken(KotlinParser.IS, 0); + } + + public TerminalNode NOT_IS() { + return getToken(KotlinParser.NOT_IS, 0); + } + + @Override + public int getRuleIndex() { + return RULE_isOperator; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitIsOperator(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterIsOperator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitIsOperator(this); + } + } + + public static class AdditiveOperatorContext extends ParserRuleContext { + public AdditiveOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode ADD() { + return getToken(KotlinParser.ADD, 0); + } + + public TerminalNode SUB() { + return getToken(KotlinParser.SUB, 0); + } + + @Override + public int getRuleIndex() { + return RULE_additiveOperator; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitAdditiveOperator(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterAdditiveOperator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitAdditiveOperator(this); + } + } + + public static class MultiplicativeOperatorContext extends ParserRuleContext { + public MultiplicativeOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode MULT() { + return getToken(KotlinParser.MULT, 0); + } + + public TerminalNode DIV() { + return getToken(KotlinParser.DIV, 0); + } + + public TerminalNode MOD() { + return getToken(KotlinParser.MOD, 0); + } + + @Override + public int getRuleIndex() { + return RULE_multiplicativeOperator; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitMultiplicativeOperator(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterMultiplicativeOperator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitMultiplicativeOperator(this); + } + } + + public static class AsOperatorContext extends ParserRuleContext { + public AsOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode AS() { + return getToken(KotlinParser.AS, 0); + } + + public TerminalNode AS_SAFE() { + return getToken(KotlinParser.AS_SAFE, 0); + } + + @Override + public int getRuleIndex() { + return RULE_asOperator; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitAsOperator(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterAsOperator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitAsOperator(this); + } + } + + public static class PrefixUnaryOperatorContext extends ParserRuleContext { + public PrefixUnaryOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode INCR() { + return getToken(KotlinParser.INCR, 0); + } + + public TerminalNode DECR() { + return getToken(KotlinParser.DECR, 0); + } + + public TerminalNode SUB() { + return getToken(KotlinParser.SUB, 0); + } + + public TerminalNode ADD() { + return getToken(KotlinParser.ADD, 0); + } + + public ExclContext excl() { + return getRuleContext(ExclContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_prefixUnaryOperator; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitPrefixUnaryOperator(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterPrefixUnaryOperator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitPrefixUnaryOperator(this); + } + } + + public static class PostfixUnaryOperatorContext extends ParserRuleContext { + public PostfixUnaryOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode INCR() { + return getToken(KotlinParser.INCR, 0); + } + + public TerminalNode DECR() { + return getToken(KotlinParser.DECR, 0); + } + + public TerminalNode EXCL_NO_WS() { + return getToken(KotlinParser.EXCL_NO_WS, 0); + } + + public ExclContext excl() { + return getRuleContext(ExclContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_postfixUnaryOperator; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitPostfixUnaryOperator(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterPostfixUnaryOperator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitPostfixUnaryOperator(this); + } + } + + public static class ExclContext extends ParserRuleContext { + public ExclContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode EXCL_NO_WS() { + return getToken(KotlinParser.EXCL_NO_WS, 0); + } + + public TerminalNode EXCL_WS() { + return getToken(KotlinParser.EXCL_WS, 0); + } + + @Override + public int getRuleIndex() { + return RULE_excl; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitExcl(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterExcl(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitExcl(this); + } + } + + public static class MemberAccessOperatorContext extends ParserRuleContext { + public MemberAccessOperatorContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode DOT() { + return getToken(KotlinParser.DOT, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public SafeNavContext safeNav() { + return getRuleContext(SafeNavContext.class, 0); + } + + public TerminalNode COLONCOLON() { + return getToken(KotlinParser.COLONCOLON, 0); + } + + @Override + public int getRuleIndex() { + return RULE_memberAccessOperator; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitMemberAccessOperator(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterMemberAccessOperator(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitMemberAccessOperator(this); + } + } + + public static class SafeNavContext extends ParserRuleContext { + public SafeNavContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode QUEST_NO_WS() { + return getToken(KotlinParser.QUEST_NO_WS, 0); + } + + public TerminalNode DOT() { + return getToken(KotlinParser.DOT, 0); + } + + @Override + public int getRuleIndex() { + return RULE_safeNav; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitSafeNav(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterSafeNav(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitSafeNav(this); + } + } + + public static class ModifiersContext extends ParserRuleContext { + public ModifiersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List annotation() { + return getRuleContexts(AnnotationContext.class); + } + + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class, i); + } + + public List modifier() { + return getRuleContexts(ModifierContext.class); + } + + public ModifierContext modifier(int i) { + return getRuleContext(ModifierContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_modifiers; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitModifiers(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterModifiers(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitModifiers(this); + } + } + + public static class ParameterModifiersContext extends ParserRuleContext { + public ParameterModifiersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List annotation() { + return getRuleContexts(AnnotationContext.class); + } + + public AnnotationContext annotation(int i) { + return getRuleContext(AnnotationContext.class, i); + } + + public List parameterModifier() { + return getRuleContexts(ParameterModifierContext.class); + } + + public ParameterModifierContext parameterModifier(int i) { + return getRuleContext(ParameterModifierContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_parameterModifiers; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitParameterModifiers(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterParameterModifiers(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitParameterModifiers(this); + } + } + + public static class ModifierContext extends ParserRuleContext { + public ModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public ClassModifierContext classModifier() { + return getRuleContext(ClassModifierContext.class, 0); + } + + public MemberModifierContext memberModifier() { + return getRuleContext(MemberModifierContext.class, 0); + } + + public VisibilityModifierContext visibilityModifier() { + return getRuleContext(VisibilityModifierContext.class, 0); + } + + public FunctionModifierContext functionModifier() { + return getRuleContext(FunctionModifierContext.class, 0); + } + + public PropertyModifierContext propertyModifier() { + return getRuleContext(PropertyModifierContext.class, 0); + } + + public InheritanceModifierContext inheritanceModifier() { + return getRuleContext(InheritanceModifierContext.class, 0); + } + + public ParameterModifierContext parameterModifier() { + return getRuleContext(ParameterModifierContext.class, 0); + } + + public PlatformModifierContext platformModifier() { + return getRuleContext(PlatformModifierContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_modifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitModifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterModifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitModifier(this); + } + } + + public static class TypeModifiersContext extends ParserRuleContext { + public TypeModifiersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List typeModifier() { + return getRuleContexts(TypeModifierContext.class); + } + + public TypeModifierContext typeModifier(int i) { + return getRuleContext(TypeModifierContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_typeModifiers; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitTypeModifiers(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterTypeModifiers(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitTypeModifiers(this); + } + } + + public static class TypeModifierContext extends ParserRuleContext { + public TypeModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class, 0); + } + + public TerminalNode SUSPEND() { + return getToken(KotlinParser.SUSPEND, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_typeModifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitTypeModifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterTypeModifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitTypeModifier(this); + } + } + + public static class ClassModifierContext extends ParserRuleContext { + public ClassModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode ENUM() { + return getToken(KotlinParser.ENUM, 0); + } + + public TerminalNode SEALED() { + return getToken(KotlinParser.SEALED, 0); + } + + public TerminalNode ANNOTATION() { + return getToken(KotlinParser.ANNOTATION, 0); + } + + public TerminalNode DATA() { + return getToken(KotlinParser.DATA, 0); + } + + public TerminalNode INNER() { + return getToken(KotlinParser.INNER, 0); + } + + public TerminalNode VALUE() { + return getToken(KotlinParser.VALUE, 0); + } + + @Override + public int getRuleIndex() { + return RULE_classModifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitClassModifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterClassModifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitClassModifier(this); + } + } + + public static class MemberModifierContext extends ParserRuleContext { + public MemberModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode OVERRIDE() { + return getToken(KotlinParser.OVERRIDE, 0); + } + + public TerminalNode LATEINIT() { + return getToken(KotlinParser.LATEINIT, 0); + } + + @Override + public int getRuleIndex() { + return RULE_memberModifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitMemberModifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterMemberModifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitMemberModifier(this); + } + } + + public static class VisibilityModifierContext extends ParserRuleContext { + public VisibilityModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode PUBLIC() { + return getToken(KotlinParser.PUBLIC, 0); + } + + public TerminalNode PRIVATE() { + return getToken(KotlinParser.PRIVATE, 0); + } + + public TerminalNode INTERNAL() { + return getToken(KotlinParser.INTERNAL, 0); + } + + public TerminalNode PROTECTED() { + return getToken(KotlinParser.PROTECTED, 0); + } + + @Override + public int getRuleIndex() { + return RULE_visibilityModifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitVisibilityModifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterVisibilityModifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitVisibilityModifier(this); + } + } + + public static class VarianceModifierContext extends ParserRuleContext { + public VarianceModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode IN() { + return getToken(KotlinParser.IN, 0); + } + + public TerminalNode OUT() { + return getToken(KotlinParser.OUT, 0); + } + + @Override + public int getRuleIndex() { + return RULE_varianceModifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitVarianceModifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterVarianceModifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitVarianceModifier(this); + } + } + + public static class TypeParameterModifiersContext extends ParserRuleContext { + public TypeParameterModifiersContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List typeParameterModifier() { + return getRuleContexts(TypeParameterModifierContext.class); + } + + public TypeParameterModifierContext typeParameterModifier(int i) { + return getRuleContext(TypeParameterModifierContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_typeParameterModifiers; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitTypeParameterModifiers(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterTypeParameterModifiers(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitTypeParameterModifiers(this); + } + } + + public static class TypeParameterModifierContext extends ParserRuleContext { + public TypeParameterModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public ReificationModifierContext reificationModifier() { + return getRuleContext(ReificationModifierContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + public VarianceModifierContext varianceModifier() { + return getRuleContext(VarianceModifierContext.class, 0); + } + + public AnnotationContext annotation() { + return getRuleContext(AnnotationContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_typeParameterModifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitTypeParameterModifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterTypeParameterModifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitTypeParameterModifier(this); + } + } + + public static class FunctionModifierContext extends ParserRuleContext { + public FunctionModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode TAILREC() { + return getToken(KotlinParser.TAILREC, 0); + } + + public TerminalNode OPERATOR() { + return getToken(KotlinParser.OPERATOR, 0); + } + + public TerminalNode INFIX() { + return getToken(KotlinParser.INFIX, 0); + } + + public TerminalNode INLINE() { + return getToken(KotlinParser.INLINE, 0); + } + + public TerminalNode EXTERNAL() { + return getToken(KotlinParser.EXTERNAL, 0); + } + + public TerminalNode SUSPEND() { + return getToken(KotlinParser.SUSPEND, 0); + } + + @Override + public int getRuleIndex() { + return RULE_functionModifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitFunctionModifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterFunctionModifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitFunctionModifier(this); + } + } + + public static class PropertyModifierContext extends ParserRuleContext { + public PropertyModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode CONST() { + return getToken(KotlinParser.CONST, 0); + } + + @Override + public int getRuleIndex() { + return RULE_propertyModifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitPropertyModifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterPropertyModifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitPropertyModifier(this); + } + } + + public static class InheritanceModifierContext extends ParserRuleContext { + public InheritanceModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode ABSTRACT() { + return getToken(KotlinParser.ABSTRACT, 0); + } + + public TerminalNode FINAL() { + return getToken(KotlinParser.FINAL, 0); + } + + public TerminalNode OPEN() { + return getToken(KotlinParser.OPEN, 0); + } + + @Override + public int getRuleIndex() { + return RULE_inheritanceModifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitInheritanceModifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterInheritanceModifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitInheritanceModifier(this); + } + } + + public static class ParameterModifierContext extends ParserRuleContext { + public ParameterModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode VARARG() { + return getToken(KotlinParser.VARARG, 0); + } + + public TerminalNode NOINLINE() { + return getToken(KotlinParser.NOINLINE, 0); + } + + public TerminalNode CROSSINLINE() { + return getToken(KotlinParser.CROSSINLINE, 0); + } + + @Override + public int getRuleIndex() { + return RULE_parameterModifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitParameterModifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterParameterModifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitParameterModifier(this); + } + } + + public static class ReificationModifierContext extends ParserRuleContext { + public ReificationModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode REIFIED() { + return getToken(KotlinParser.REIFIED, 0); + } + + @Override + public int getRuleIndex() { + return RULE_reificationModifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitReificationModifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterReificationModifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitReificationModifier(this); + } + } + + public static class PlatformModifierContext extends ParserRuleContext { + public PlatformModifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode EXPECT() { + return getToken(KotlinParser.EXPECT, 0); + } + + public TerminalNode ACTUAL() { + return getToken(KotlinParser.ACTUAL, 0); + } + + @Override + public int getRuleIndex() { + return RULE_platformModifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitPlatformModifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterPlatformModifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitPlatformModifier(this); + } + } + + public static class AnnotationContext extends ParserRuleContext { + public AnnotationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public SingleAnnotationContext singleAnnotation() { + return getRuleContext(SingleAnnotationContext.class, 0); + } + + public MultiAnnotationContext multiAnnotation() { + return getRuleContext(MultiAnnotationContext.class, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_annotation; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitAnnotation(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterAnnotation(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitAnnotation(this); + } + } + + public static class SingleAnnotationContext extends ParserRuleContext { + public SingleAnnotationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public UnescapedAnnotationContext unescapedAnnotation() { + return getRuleContext(UnescapedAnnotationContext.class, 0); + } + + public AnnotationUseSiteTargetContext annotationUseSiteTarget() { + return getRuleContext(AnnotationUseSiteTargetContext.class, 0); + } + + public TerminalNode AT_NO_WS() { + return getToken(KotlinParser.AT_NO_WS, 0); + } + + public TerminalNode AT_PRE_WS() { + return getToken(KotlinParser.AT_PRE_WS, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_singleAnnotation; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitSingleAnnotation(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterSingleAnnotation(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitSingleAnnotation(this); + } + } + + public static class MultiAnnotationContext extends ParserRuleContext { + public MultiAnnotationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode LSQUARE() { + return getToken(KotlinParser.LSQUARE, 0); + } + + public TerminalNode RSQUARE() { + return getToken(KotlinParser.RSQUARE, 0); + } + + public AnnotationUseSiteTargetContext annotationUseSiteTarget() { + return getRuleContext(AnnotationUseSiteTargetContext.class, 0); + } + + public TerminalNode AT_NO_WS() { + return getToken(KotlinParser.AT_NO_WS, 0); + } + + public TerminalNode AT_PRE_WS() { + return getToken(KotlinParser.AT_PRE_WS, 0); + } + + public List unescapedAnnotation() { + return getRuleContexts(UnescapedAnnotationContext.class); + } + + public UnescapedAnnotationContext unescapedAnnotation(int i) { + return getRuleContext(UnescapedAnnotationContext.class, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_multiAnnotation; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitMultiAnnotation(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterMultiAnnotation(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitMultiAnnotation(this); + } + } + + public static class AnnotationUseSiteTargetContext extends ParserRuleContext { + public AnnotationUseSiteTargetContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode COLON() { + return getToken(KotlinParser.COLON, 0); + } + + public TerminalNode AT_NO_WS() { + return getToken(KotlinParser.AT_NO_WS, 0); + } + + public TerminalNode AT_PRE_WS() { + return getToken(KotlinParser.AT_PRE_WS, 0); + } + + public TerminalNode FIELD() { + return getToken(KotlinParser.FIELD, 0); + } + + public TerminalNode PROPERTY() { + return getToken(KotlinParser.PROPERTY, 0); + } + + public TerminalNode GET() { + return getToken(KotlinParser.GET, 0); + } + + public TerminalNode SET() { + return getToken(KotlinParser.SET, 0); + } + + public TerminalNode RECEIVER() { + return getToken(KotlinParser.RECEIVER, 0); + } + + public TerminalNode PARAM() { + return getToken(KotlinParser.PARAM, 0); + } + + public TerminalNode SETPARAM() { + return getToken(KotlinParser.SETPARAM, 0); + } + + public TerminalNode DELEGATE() { + return getToken(KotlinParser.DELEGATE, 0); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_annotationUseSiteTarget; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitAnnotationUseSiteTarget(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterAnnotationUseSiteTarget(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitAnnotationUseSiteTarget(this); + } + } + + public static class UnescapedAnnotationContext extends ParserRuleContext { + public UnescapedAnnotationContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public ConstructorInvocationContext constructorInvocation() { + return getRuleContext(ConstructorInvocationContext.class, 0); + } + + public UserTypeContext userType() { + return getRuleContext(UserTypeContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_unescapedAnnotation; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitUnescapedAnnotation(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterUnescapedAnnotation(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitUnescapedAnnotation(this); + } + } + + public static class SimpleIdentifierContext extends ParserRuleContext { + public SimpleIdentifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Identifier() { + return getToken(KotlinParser.Identifier, 0); + } + + public TerminalNode ABSTRACT() { + return getToken(KotlinParser.ABSTRACT, 0); + } + + public TerminalNode ANNOTATION() { + return getToken(KotlinParser.ANNOTATION, 0); + } + + public TerminalNode BY() { + return getToken(KotlinParser.BY, 0); + } + + public TerminalNode CATCH() { + return getToken(KotlinParser.CATCH, 0); + } + + public TerminalNode COMPANION() { + return getToken(KotlinParser.COMPANION, 0); + } + + public TerminalNode CONSTRUCTOR() { + return getToken(KotlinParser.CONSTRUCTOR, 0); + } + + public TerminalNode CROSSINLINE() { + return getToken(KotlinParser.CROSSINLINE, 0); + } + + public TerminalNode DATA() { + return getToken(KotlinParser.DATA, 0); + } + + public TerminalNode DYNAMIC() { + return getToken(KotlinParser.DYNAMIC, 0); + } + + public TerminalNode ENUM() { + return getToken(KotlinParser.ENUM, 0); + } + + public TerminalNode EXTERNAL() { + return getToken(KotlinParser.EXTERNAL, 0); + } + + public TerminalNode FINAL() { + return getToken(KotlinParser.FINAL, 0); + } + + public TerminalNode FINALLY() { + return getToken(KotlinParser.FINALLY, 0); + } + + public TerminalNode GET() { + return getToken(KotlinParser.GET, 0); + } + + public TerminalNode IMPORT() { + return getToken(KotlinParser.IMPORT, 0); + } + + public TerminalNode INFIX() { + return getToken(KotlinParser.INFIX, 0); + } + + public TerminalNode INIT() { + return getToken(KotlinParser.INIT, 0); + } + + public TerminalNode INLINE() { + return getToken(KotlinParser.INLINE, 0); + } + + public TerminalNode INNER() { + return getToken(KotlinParser.INNER, 0); + } + + public TerminalNode INTERNAL() { + return getToken(KotlinParser.INTERNAL, 0); + } + + public TerminalNode LATEINIT() { + return getToken(KotlinParser.LATEINIT, 0); + } + + public TerminalNode NOINLINE() { + return getToken(KotlinParser.NOINLINE, 0); + } + + public TerminalNode OPEN() { + return getToken(KotlinParser.OPEN, 0); + } + + public TerminalNode OPERATOR() { + return getToken(KotlinParser.OPERATOR, 0); + } + + public TerminalNode OUT() { + return getToken(KotlinParser.OUT, 0); + } + + public TerminalNode OVERRIDE() { + return getToken(KotlinParser.OVERRIDE, 0); + } + + public TerminalNode PRIVATE() { + return getToken(KotlinParser.PRIVATE, 0); + } + + public TerminalNode PROTECTED() { + return getToken(KotlinParser.PROTECTED, 0); + } + + public TerminalNode PUBLIC() { + return getToken(KotlinParser.PUBLIC, 0); + } + + public TerminalNode REIFIED() { + return getToken(KotlinParser.REIFIED, 0); + } + + public TerminalNode SEALED() { + return getToken(KotlinParser.SEALED, 0); + } + + public TerminalNode TAILREC() { + return getToken(KotlinParser.TAILREC, 0); + } + + public TerminalNode SET() { + return getToken(KotlinParser.SET, 0); + } + + public TerminalNode VARARG() { + return getToken(KotlinParser.VARARG, 0); + } + + public TerminalNode WHERE() { + return getToken(KotlinParser.WHERE, 0); + } + + public TerminalNode FIELD() { + return getToken(KotlinParser.FIELD, 0); + } + + public TerminalNode PROPERTY() { + return getToken(KotlinParser.PROPERTY, 0); + } + + public TerminalNode RECEIVER() { + return getToken(KotlinParser.RECEIVER, 0); + } + + public TerminalNode PARAM() { + return getToken(KotlinParser.PARAM, 0); + } + + public TerminalNode SETPARAM() { + return getToken(KotlinParser.SETPARAM, 0); + } + + public TerminalNode DELEGATE() { + return getToken(KotlinParser.DELEGATE, 0); + } + + public TerminalNode FILE() { + return getToken(KotlinParser.FILE, 0); + } + + public TerminalNode EXPECT() { + return getToken(KotlinParser.EXPECT, 0); + } + + public TerminalNode ACTUAL() { + return getToken(KotlinParser.ACTUAL, 0); + } + + public TerminalNode CONST() { + return getToken(KotlinParser.CONST, 0); + } + + public TerminalNode SUSPEND() { + return getToken(KotlinParser.SUSPEND, 0); + } + + public TerminalNode VALUE() { + return getToken(KotlinParser.VALUE, 0); + } + + @Override + public int getRuleIndex() { + return RULE_simpleIdentifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitSimpleIdentifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterSimpleIdentifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitSimpleIdentifier(this); + } + } + + public static class IdentifierContext extends ParserRuleContext { + public IdentifierContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List simpleIdentifier() { + return getRuleContexts(SimpleIdentifierContext.class); + } + + public SimpleIdentifierContext simpleIdentifier(int i) { + return getRuleContext(SimpleIdentifierContext.class, i); + } + + public List DOT() { + return getTokens(KotlinParser.DOT); + } + + public TerminalNode DOT(int i) { + return getToken(KotlinParser.DOT, i); + } + + public List NL() { + return getTokens(KotlinParser.NL); + } + + public TerminalNode NL(int i) { + return getToken(KotlinParser.NL, i); + } + + @Override + public int getRuleIndex() { + return RULE_identifier; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof KotlinParserVisitor) + return ((KotlinParserVisitor) visitor).visitIdentifier(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).enterIdentifier(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof KotlinParserListener) + ((KotlinParserListener) listener).exitIdentifier(this); + } + } +} diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/kotlin/KotlinParserBaseListener.java b/lexers/src/main/java/com/itsaky/androidide/lexers/kotlin/KotlinParserBaseListener.java index 2603606ff..7f62e2dd6 100644 --- a/lexers/src/main/java/com/itsaky/androidide/lexers/kotlin/KotlinParserBaseListener.java +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/kotlin/KotlinParserBaseListener.java @@ -1,4 +1,4 @@ -// Generated from KotlinParser.g4 by ANTLR 4.9.2 +// Generated from KotlinParser.g4 by ANTLR 4.9.3 package com.itsaky.androidide.lexers.kotlin; import org.antlr.v4.runtime.ParserRuleContext; @@ -6,2110 +6,2472 @@ import org.antlr.v4.runtime.tree.ErrorNode; import org.antlr.v4.runtime.tree.TerminalNode; /** - * This class provides an empty implementation of {@link KotlinParserListener}, - * which can be extended to create a listener which only needs to handle a subset - * of the available methods. + * This class provides an empty implementation of {@link KotlinParserListener}, which can be + * extended to create a listener which only needs to handle a subset of the available methods. */ public class KotlinParserBaseListener implements KotlinParserListener { - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterKotlinFile(KotlinParser.KotlinFileContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitKotlinFile(KotlinParser.KotlinFileContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterScript(KotlinParser.ScriptContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitScript(KotlinParser.ScriptContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterShebangLine(KotlinParser.ShebangLineContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitShebangLine(KotlinParser.ShebangLineContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterFileAnnotation(KotlinParser.FileAnnotationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitFileAnnotation(KotlinParser.FileAnnotationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterPackageHeader(KotlinParser.PackageHeaderContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitPackageHeader(KotlinParser.PackageHeaderContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterImportList(KotlinParser.ImportListContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitImportList(KotlinParser.ImportListContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterImportHeader(KotlinParser.ImportHeaderContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitImportHeader(KotlinParser.ImportHeaderContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterImportAlias(KotlinParser.ImportAliasContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitImportAlias(KotlinParser.ImportAliasContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterTopLevelObject(KotlinParser.TopLevelObjectContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitTopLevelObject(KotlinParser.TopLevelObjectContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterTypeAlias(KotlinParser.TypeAliasContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitTypeAlias(KotlinParser.TypeAliasContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterDeclaration(KotlinParser.DeclarationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitDeclaration(KotlinParser.DeclarationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterClassDeclaration(KotlinParser.ClassDeclarationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitClassDeclaration(KotlinParser.ClassDeclarationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterPrimaryConstructor(KotlinParser.PrimaryConstructorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitPrimaryConstructor(KotlinParser.PrimaryConstructorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterClassBody(KotlinParser.ClassBodyContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitClassBody(KotlinParser.ClassBodyContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterClassParameters(KotlinParser.ClassParametersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitClassParameters(KotlinParser.ClassParametersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterClassParameter(KotlinParser.ClassParameterContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitClassParameter(KotlinParser.ClassParameterContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterDelegationSpecifiers(KotlinParser.DelegationSpecifiersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitDelegationSpecifiers(KotlinParser.DelegationSpecifiersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterDelegationSpecifier(KotlinParser.DelegationSpecifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitDelegationSpecifier(KotlinParser.DelegationSpecifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterConstructorInvocation(KotlinParser.ConstructorInvocationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitConstructorInvocation(KotlinParser.ConstructorInvocationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterAnnotatedDelegationSpecifier(KotlinParser.AnnotatedDelegationSpecifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitAnnotatedDelegationSpecifier(KotlinParser.AnnotatedDelegationSpecifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterExplicitDelegation(KotlinParser.ExplicitDelegationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitExplicitDelegation(KotlinParser.ExplicitDelegationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterTypeParameters(KotlinParser.TypeParametersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitTypeParameters(KotlinParser.TypeParametersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterTypeParameter(KotlinParser.TypeParameterContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitTypeParameter(KotlinParser.TypeParameterContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterTypeConstraints(KotlinParser.TypeConstraintsContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitTypeConstraints(KotlinParser.TypeConstraintsContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterTypeConstraint(KotlinParser.TypeConstraintContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitTypeConstraint(KotlinParser.TypeConstraintContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterClassMemberDeclarations(KotlinParser.ClassMemberDeclarationsContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitClassMemberDeclarations(KotlinParser.ClassMemberDeclarationsContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterClassMemberDeclaration(KotlinParser.ClassMemberDeclarationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitClassMemberDeclaration(KotlinParser.ClassMemberDeclarationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterAnonymousInitializer(KotlinParser.AnonymousInitializerContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitAnonymousInitializer(KotlinParser.AnonymousInitializerContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterCompanionObject(KotlinParser.CompanionObjectContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitCompanionObject(KotlinParser.CompanionObjectContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterFunctionValueParameters(KotlinParser.FunctionValueParametersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitFunctionValueParameters(KotlinParser.FunctionValueParametersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterFunctionValueParameter(KotlinParser.FunctionValueParameterContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitFunctionValueParameter(KotlinParser.FunctionValueParameterContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterFunctionDeclaration(KotlinParser.FunctionDeclarationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitFunctionDeclaration(KotlinParser.FunctionDeclarationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterFunctionBody(KotlinParser.FunctionBodyContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitFunctionBody(KotlinParser.FunctionBodyContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterVariableDeclaration(KotlinParser.VariableDeclarationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitVariableDeclaration(KotlinParser.VariableDeclarationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterMultiVariableDeclaration(KotlinParser.MultiVariableDeclarationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitMultiVariableDeclaration(KotlinParser.MultiVariableDeclarationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterPropertyDeclaration(KotlinParser.PropertyDeclarationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitPropertyDeclaration(KotlinParser.PropertyDeclarationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterPropertyDelegate(KotlinParser.PropertyDelegateContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitPropertyDelegate(KotlinParser.PropertyDelegateContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterGetter(KotlinParser.GetterContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitGetter(KotlinParser.GetterContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterSetter(KotlinParser.SetterContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitSetter(KotlinParser.SetterContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterParametersWithOptionalType(KotlinParser.ParametersWithOptionalTypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitParametersWithOptionalType(KotlinParser.ParametersWithOptionalTypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterFunctionValueParameterWithOptionalType(KotlinParser.FunctionValueParameterWithOptionalTypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitFunctionValueParameterWithOptionalType(KotlinParser.FunctionValueParameterWithOptionalTypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterParameterWithOptionalType(KotlinParser.ParameterWithOptionalTypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitParameterWithOptionalType(KotlinParser.ParameterWithOptionalTypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterParameter(KotlinParser.ParameterContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitParameter(KotlinParser.ParameterContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterObjectDeclaration(KotlinParser.ObjectDeclarationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitObjectDeclaration(KotlinParser.ObjectDeclarationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterSecondaryConstructor(KotlinParser.SecondaryConstructorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitSecondaryConstructor(KotlinParser.SecondaryConstructorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterConstructorDelegationCall(KotlinParser.ConstructorDelegationCallContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitConstructorDelegationCall(KotlinParser.ConstructorDelegationCallContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterEnumClassBody(KotlinParser.EnumClassBodyContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitEnumClassBody(KotlinParser.EnumClassBodyContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterEnumEntries(KotlinParser.EnumEntriesContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitEnumEntries(KotlinParser.EnumEntriesContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterEnumEntry(KotlinParser.EnumEntryContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitEnumEntry(KotlinParser.EnumEntryContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterType(KotlinParser.TypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitType(KotlinParser.TypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterTypeReference(KotlinParser.TypeReferenceContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitTypeReference(KotlinParser.TypeReferenceContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterNullableType(KotlinParser.NullableTypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitNullableType(KotlinParser.NullableTypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterQuest(KotlinParser.QuestContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitQuest(KotlinParser.QuestContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterUserType(KotlinParser.UserTypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitUserType(KotlinParser.UserTypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterSimpleUserType(KotlinParser.SimpleUserTypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitSimpleUserType(KotlinParser.SimpleUserTypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterTypeProjection(KotlinParser.TypeProjectionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitTypeProjection(KotlinParser.TypeProjectionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterTypeProjectionModifiers(KotlinParser.TypeProjectionModifiersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitTypeProjectionModifiers(KotlinParser.TypeProjectionModifiersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterTypeProjectionModifier(KotlinParser.TypeProjectionModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitTypeProjectionModifier(KotlinParser.TypeProjectionModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterFunctionType(KotlinParser.FunctionTypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitFunctionType(KotlinParser.FunctionTypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterFunctionTypeParameters(KotlinParser.FunctionTypeParametersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitFunctionTypeParameters(KotlinParser.FunctionTypeParametersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterParenthesizedType(KotlinParser.ParenthesizedTypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitParenthesizedType(KotlinParser.ParenthesizedTypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterReceiverType(KotlinParser.ReceiverTypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitReceiverType(KotlinParser.ReceiverTypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterParenthesizedUserType(KotlinParser.ParenthesizedUserTypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitParenthesizedUserType(KotlinParser.ParenthesizedUserTypeContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterStatements(KotlinParser.StatementsContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitStatements(KotlinParser.StatementsContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterStatement(KotlinParser.StatementContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitStatement(KotlinParser.StatementContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterLabel(KotlinParser.LabelContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitLabel(KotlinParser.LabelContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterControlStructureBody(KotlinParser.ControlStructureBodyContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitControlStructureBody(KotlinParser.ControlStructureBodyContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterBlock(KotlinParser.BlockContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitBlock(KotlinParser.BlockContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterLoopStatement(KotlinParser.LoopStatementContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitLoopStatement(KotlinParser.LoopStatementContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterForStatement(KotlinParser.ForStatementContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitForStatement(KotlinParser.ForStatementContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterWhileStatement(KotlinParser.WhileStatementContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitWhileStatement(KotlinParser.WhileStatementContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterDoWhileStatement(KotlinParser.DoWhileStatementContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitDoWhileStatement(KotlinParser.DoWhileStatementContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterAssignment(KotlinParser.AssignmentContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitAssignment(KotlinParser.AssignmentContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterSemi(KotlinParser.SemiContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitSemi(KotlinParser.SemiContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterSemis(KotlinParser.SemisContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitSemis(KotlinParser.SemisContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterExpression(KotlinParser.ExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitExpression(KotlinParser.ExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterDisjunction(KotlinParser.DisjunctionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitDisjunction(KotlinParser.DisjunctionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterConjunction(KotlinParser.ConjunctionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitConjunction(KotlinParser.ConjunctionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterEquality(KotlinParser.EqualityContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitEquality(KotlinParser.EqualityContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterComparison(KotlinParser.ComparisonContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitComparison(KotlinParser.ComparisonContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterGenericCallLikeComparison(KotlinParser.GenericCallLikeComparisonContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitGenericCallLikeComparison(KotlinParser.GenericCallLikeComparisonContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterInfixOperation(KotlinParser.InfixOperationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitInfixOperation(KotlinParser.InfixOperationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterElvisExpression(KotlinParser.ElvisExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitElvisExpression(KotlinParser.ElvisExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterElvis(KotlinParser.ElvisContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitElvis(KotlinParser.ElvisContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterInfixFunctionCall(KotlinParser.InfixFunctionCallContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitInfixFunctionCall(KotlinParser.InfixFunctionCallContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterRangeExpression(KotlinParser.RangeExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitRangeExpression(KotlinParser.RangeExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterAdditiveExpression(KotlinParser.AdditiveExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitAdditiveExpression(KotlinParser.AdditiveExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterMultiplicativeExpression(KotlinParser.MultiplicativeExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitMultiplicativeExpression(KotlinParser.MultiplicativeExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterAsExpression(KotlinParser.AsExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitAsExpression(KotlinParser.AsExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterPrefixUnaryExpression(KotlinParser.PrefixUnaryExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitPrefixUnaryExpression(KotlinParser.PrefixUnaryExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterUnaryPrefix(KotlinParser.UnaryPrefixContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitUnaryPrefix(KotlinParser.UnaryPrefixContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterPostfixUnaryExpression(KotlinParser.PostfixUnaryExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitPostfixUnaryExpression(KotlinParser.PostfixUnaryExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterPostfixUnarySuffix(KotlinParser.PostfixUnarySuffixContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitPostfixUnarySuffix(KotlinParser.PostfixUnarySuffixContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterDirectlyAssignableExpression(KotlinParser.DirectlyAssignableExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitDirectlyAssignableExpression(KotlinParser.DirectlyAssignableExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterParenthesizedDirectlyAssignableExpression(KotlinParser.ParenthesizedDirectlyAssignableExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitParenthesizedDirectlyAssignableExpression(KotlinParser.ParenthesizedDirectlyAssignableExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterAssignableExpression(KotlinParser.AssignableExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitAssignableExpression(KotlinParser.AssignableExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterParenthesizedAssignableExpression(KotlinParser.ParenthesizedAssignableExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitParenthesizedAssignableExpression(KotlinParser.ParenthesizedAssignableExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterAssignableSuffix(KotlinParser.AssignableSuffixContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitAssignableSuffix(KotlinParser.AssignableSuffixContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterIndexingSuffix(KotlinParser.IndexingSuffixContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitIndexingSuffix(KotlinParser.IndexingSuffixContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterNavigationSuffix(KotlinParser.NavigationSuffixContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitNavigationSuffix(KotlinParser.NavigationSuffixContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterCallSuffix(KotlinParser.CallSuffixContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitCallSuffix(KotlinParser.CallSuffixContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterAnnotatedLambda(KotlinParser.AnnotatedLambdaContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitAnnotatedLambda(KotlinParser.AnnotatedLambdaContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterTypeArguments(KotlinParser.TypeArgumentsContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitTypeArguments(KotlinParser.TypeArgumentsContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterValueArguments(KotlinParser.ValueArgumentsContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitValueArguments(KotlinParser.ValueArgumentsContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterValueArgument(KotlinParser.ValueArgumentContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitValueArgument(KotlinParser.ValueArgumentContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterPrimaryExpression(KotlinParser.PrimaryExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitPrimaryExpression(KotlinParser.PrimaryExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterParenthesizedExpression(KotlinParser.ParenthesizedExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitParenthesizedExpression(KotlinParser.ParenthesizedExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterCollectionLiteral(KotlinParser.CollectionLiteralContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitCollectionLiteral(KotlinParser.CollectionLiteralContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterLiteralConstant(KotlinParser.LiteralConstantContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitLiteralConstant(KotlinParser.LiteralConstantContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterStringLiteral(KotlinParser.StringLiteralContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitStringLiteral(KotlinParser.StringLiteralContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterLineStringLiteral(KotlinParser.LineStringLiteralContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitLineStringLiteral(KotlinParser.LineStringLiteralContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterMultiLineStringLiteral(KotlinParser.MultiLineStringLiteralContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitMultiLineStringLiteral(KotlinParser.MultiLineStringLiteralContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterLineStringContent(KotlinParser.LineStringContentContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitLineStringContent(KotlinParser.LineStringContentContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterLineStringExpression(KotlinParser.LineStringExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitLineStringExpression(KotlinParser.LineStringExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterMultiLineStringContent(KotlinParser.MultiLineStringContentContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitMultiLineStringContent(KotlinParser.MultiLineStringContentContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterMultiLineStringExpression(KotlinParser.MultiLineStringExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitMultiLineStringExpression(KotlinParser.MultiLineStringExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterLambdaLiteral(KotlinParser.LambdaLiteralContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitLambdaLiteral(KotlinParser.LambdaLiteralContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterLambdaParameters(KotlinParser.LambdaParametersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitLambdaParameters(KotlinParser.LambdaParametersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterLambdaParameter(KotlinParser.LambdaParameterContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitLambdaParameter(KotlinParser.LambdaParameterContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterAnonymousFunction(KotlinParser.AnonymousFunctionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitAnonymousFunction(KotlinParser.AnonymousFunctionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterFunctionLiteral(KotlinParser.FunctionLiteralContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitFunctionLiteral(KotlinParser.FunctionLiteralContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterObjectLiteral(KotlinParser.ObjectLiteralContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitObjectLiteral(KotlinParser.ObjectLiteralContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterThisExpression(KotlinParser.ThisExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitThisExpression(KotlinParser.ThisExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterSuperExpression(KotlinParser.SuperExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitSuperExpression(KotlinParser.SuperExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterIfExpression(KotlinParser.IfExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitIfExpression(KotlinParser.IfExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterWhenSubject(KotlinParser.WhenSubjectContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitWhenSubject(KotlinParser.WhenSubjectContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterWhenExpression(KotlinParser.WhenExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitWhenExpression(KotlinParser.WhenExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterWhenEntry(KotlinParser.WhenEntryContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitWhenEntry(KotlinParser.WhenEntryContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterWhenCondition(KotlinParser.WhenConditionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitWhenCondition(KotlinParser.WhenConditionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterRangeTest(KotlinParser.RangeTestContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitRangeTest(KotlinParser.RangeTestContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterTypeTest(KotlinParser.TypeTestContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitTypeTest(KotlinParser.TypeTestContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterTryExpression(KotlinParser.TryExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitTryExpression(KotlinParser.TryExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterCatchBlock(KotlinParser.CatchBlockContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitCatchBlock(KotlinParser.CatchBlockContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterFinallyBlock(KotlinParser.FinallyBlockContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitFinallyBlock(KotlinParser.FinallyBlockContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterJumpExpression(KotlinParser.JumpExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitJumpExpression(KotlinParser.JumpExpressionContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterCallableReference(KotlinParser.CallableReferenceContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitCallableReference(KotlinParser.CallableReferenceContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterAssignmentAndOperator(KotlinParser.AssignmentAndOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitAssignmentAndOperator(KotlinParser.AssignmentAndOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterEqualityOperator(KotlinParser.EqualityOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitEqualityOperator(KotlinParser.EqualityOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterComparisonOperator(KotlinParser.ComparisonOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitComparisonOperator(KotlinParser.ComparisonOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterInOperator(KotlinParser.InOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitInOperator(KotlinParser.InOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterIsOperator(KotlinParser.IsOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitIsOperator(KotlinParser.IsOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterAdditiveOperator(KotlinParser.AdditiveOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitAdditiveOperator(KotlinParser.AdditiveOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterMultiplicativeOperator(KotlinParser.MultiplicativeOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitMultiplicativeOperator(KotlinParser.MultiplicativeOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterAsOperator(KotlinParser.AsOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitAsOperator(KotlinParser.AsOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterPrefixUnaryOperator(KotlinParser.PrefixUnaryOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitPrefixUnaryOperator(KotlinParser.PrefixUnaryOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterPostfixUnaryOperator(KotlinParser.PostfixUnaryOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitPostfixUnaryOperator(KotlinParser.PostfixUnaryOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterExcl(KotlinParser.ExclContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitExcl(KotlinParser.ExclContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterMemberAccessOperator(KotlinParser.MemberAccessOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitMemberAccessOperator(KotlinParser.MemberAccessOperatorContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterSafeNav(KotlinParser.SafeNavContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitSafeNav(KotlinParser.SafeNavContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterModifiers(KotlinParser.ModifiersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitModifiers(KotlinParser.ModifiersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterParameterModifiers(KotlinParser.ParameterModifiersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitParameterModifiers(KotlinParser.ParameterModifiersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterModifier(KotlinParser.ModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitModifier(KotlinParser.ModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterTypeModifiers(KotlinParser.TypeModifiersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitTypeModifiers(KotlinParser.TypeModifiersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterTypeModifier(KotlinParser.TypeModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitTypeModifier(KotlinParser.TypeModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterClassModifier(KotlinParser.ClassModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitClassModifier(KotlinParser.ClassModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterMemberModifier(KotlinParser.MemberModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitMemberModifier(KotlinParser.MemberModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterVisibilityModifier(KotlinParser.VisibilityModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitVisibilityModifier(KotlinParser.VisibilityModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterVarianceModifier(KotlinParser.VarianceModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitVarianceModifier(KotlinParser.VarianceModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterTypeParameterModifiers(KotlinParser.TypeParameterModifiersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitTypeParameterModifiers(KotlinParser.TypeParameterModifiersContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterTypeParameterModifier(KotlinParser.TypeParameterModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitTypeParameterModifier(KotlinParser.TypeParameterModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterFunctionModifier(KotlinParser.FunctionModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitFunctionModifier(KotlinParser.FunctionModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterPropertyModifier(KotlinParser.PropertyModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitPropertyModifier(KotlinParser.PropertyModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterInheritanceModifier(KotlinParser.InheritanceModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitInheritanceModifier(KotlinParser.InheritanceModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterParameterModifier(KotlinParser.ParameterModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitParameterModifier(KotlinParser.ParameterModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterReificationModifier(KotlinParser.ReificationModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitReificationModifier(KotlinParser.ReificationModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterPlatformModifier(KotlinParser.PlatformModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitPlatformModifier(KotlinParser.PlatformModifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterAnnotation(KotlinParser.AnnotationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitAnnotation(KotlinParser.AnnotationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterSingleAnnotation(KotlinParser.SingleAnnotationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitSingleAnnotation(KotlinParser.SingleAnnotationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterMultiAnnotation(KotlinParser.MultiAnnotationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitMultiAnnotation(KotlinParser.MultiAnnotationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterAnnotationUseSiteTarget(KotlinParser.AnnotationUseSiteTargetContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitAnnotationUseSiteTarget(KotlinParser.AnnotationUseSiteTargetContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterUnescapedAnnotation(KotlinParser.UnescapedAnnotationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitUnescapedAnnotation(KotlinParser.UnescapedAnnotationContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterSimpleIdentifier(KotlinParser.SimpleIdentifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitSimpleIdentifier(KotlinParser.SimpleIdentifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterIdentifier(KotlinParser.IdentifierContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitIdentifier(KotlinParser.IdentifierContext ctx) { } + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterKotlinFile(KotlinParser.KotlinFileContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitKotlinFile(KotlinParser.KotlinFileContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterScript(KotlinParser.ScriptContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitScript(KotlinParser.ScriptContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterShebangLine(KotlinParser.ShebangLineContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitShebangLine(KotlinParser.ShebangLineContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterFileAnnotation(KotlinParser.FileAnnotationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitFileAnnotation(KotlinParser.FileAnnotationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterPackageHeader(KotlinParser.PackageHeaderContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitPackageHeader(KotlinParser.PackageHeaderContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterImportList(KotlinParser.ImportListContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitImportList(KotlinParser.ImportListContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterImportHeader(KotlinParser.ImportHeaderContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitImportHeader(KotlinParser.ImportHeaderContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterImportAlias(KotlinParser.ImportAliasContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitImportAlias(KotlinParser.ImportAliasContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTopLevelObject(KotlinParser.TopLevelObjectContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTopLevelObject(KotlinParser.TopLevelObjectContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTypeAlias(KotlinParser.TypeAliasContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTypeAlias(KotlinParser.TypeAliasContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterDeclaration(KotlinParser.DeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitDeclaration(KotlinParser.DeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterClassDeclaration(KotlinParser.ClassDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitClassDeclaration(KotlinParser.ClassDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterPrimaryConstructor(KotlinParser.PrimaryConstructorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitPrimaryConstructor(KotlinParser.PrimaryConstructorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterClassBody(KotlinParser.ClassBodyContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitClassBody(KotlinParser.ClassBodyContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterClassParameters(KotlinParser.ClassParametersContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitClassParameters(KotlinParser.ClassParametersContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterClassParameter(KotlinParser.ClassParameterContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitClassParameter(KotlinParser.ClassParameterContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterDelegationSpecifiers(KotlinParser.DelegationSpecifiersContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitDelegationSpecifiers(KotlinParser.DelegationSpecifiersContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterDelegationSpecifier(KotlinParser.DelegationSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitDelegationSpecifier(KotlinParser.DelegationSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterConstructorInvocation(KotlinParser.ConstructorInvocationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitConstructorInvocation(KotlinParser.ConstructorInvocationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterAnnotatedDelegationSpecifier( + KotlinParser.AnnotatedDelegationSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitAnnotatedDelegationSpecifier( + KotlinParser.AnnotatedDelegationSpecifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterExplicitDelegation(KotlinParser.ExplicitDelegationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitExplicitDelegation(KotlinParser.ExplicitDelegationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTypeParameters(KotlinParser.TypeParametersContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTypeParameters(KotlinParser.TypeParametersContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTypeParameter(KotlinParser.TypeParameterContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTypeParameter(KotlinParser.TypeParameterContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTypeConstraints(KotlinParser.TypeConstraintsContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTypeConstraints(KotlinParser.TypeConstraintsContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTypeConstraint(KotlinParser.TypeConstraintContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTypeConstraint(KotlinParser.TypeConstraintContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterClassMemberDeclarations(KotlinParser.ClassMemberDeclarationsContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitClassMemberDeclarations(KotlinParser.ClassMemberDeclarationsContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterClassMemberDeclaration(KotlinParser.ClassMemberDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitClassMemberDeclaration(KotlinParser.ClassMemberDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterAnonymousInitializer(KotlinParser.AnonymousInitializerContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitAnonymousInitializer(KotlinParser.AnonymousInitializerContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterCompanionObject(KotlinParser.CompanionObjectContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitCompanionObject(KotlinParser.CompanionObjectContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterFunctionValueParameters(KotlinParser.FunctionValueParametersContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitFunctionValueParameters(KotlinParser.FunctionValueParametersContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterFunctionValueParameter(KotlinParser.FunctionValueParameterContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitFunctionValueParameter(KotlinParser.FunctionValueParameterContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterFunctionDeclaration(KotlinParser.FunctionDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitFunctionDeclaration(KotlinParser.FunctionDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterFunctionBody(KotlinParser.FunctionBodyContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitFunctionBody(KotlinParser.FunctionBodyContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterVariableDeclaration(KotlinParser.VariableDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitVariableDeclaration(KotlinParser.VariableDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterMultiVariableDeclaration(KotlinParser.MultiVariableDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitMultiVariableDeclaration(KotlinParser.MultiVariableDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterPropertyDeclaration(KotlinParser.PropertyDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitPropertyDeclaration(KotlinParser.PropertyDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterPropertyDelegate(KotlinParser.PropertyDelegateContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitPropertyDelegate(KotlinParser.PropertyDelegateContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterGetter(KotlinParser.GetterContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitGetter(KotlinParser.GetterContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterSetter(KotlinParser.SetterContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitSetter(KotlinParser.SetterContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterParametersWithOptionalType(KotlinParser.ParametersWithOptionalTypeContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitParametersWithOptionalType(KotlinParser.ParametersWithOptionalTypeContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterFunctionValueParameterWithOptionalType( + KotlinParser.FunctionValueParameterWithOptionalTypeContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitFunctionValueParameterWithOptionalType( + KotlinParser.FunctionValueParameterWithOptionalTypeContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterParameterWithOptionalType(KotlinParser.ParameterWithOptionalTypeContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitParameterWithOptionalType(KotlinParser.ParameterWithOptionalTypeContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterParameter(KotlinParser.ParameterContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitParameter(KotlinParser.ParameterContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterObjectDeclaration(KotlinParser.ObjectDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitObjectDeclaration(KotlinParser.ObjectDeclarationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterSecondaryConstructor(KotlinParser.SecondaryConstructorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitSecondaryConstructor(KotlinParser.SecondaryConstructorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterConstructorDelegationCall(KotlinParser.ConstructorDelegationCallContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitConstructorDelegationCall(KotlinParser.ConstructorDelegationCallContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterEnumClassBody(KotlinParser.EnumClassBodyContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitEnumClassBody(KotlinParser.EnumClassBodyContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterEnumEntries(KotlinParser.EnumEntriesContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitEnumEntries(KotlinParser.EnumEntriesContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterEnumEntry(KotlinParser.EnumEntryContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitEnumEntry(KotlinParser.EnumEntryContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterType(KotlinParser.TypeContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitType(KotlinParser.TypeContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTypeReference(KotlinParser.TypeReferenceContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTypeReference(KotlinParser.TypeReferenceContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterNullableType(KotlinParser.NullableTypeContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitNullableType(KotlinParser.NullableTypeContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterQuest(KotlinParser.QuestContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitQuest(KotlinParser.QuestContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterUserType(KotlinParser.UserTypeContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitUserType(KotlinParser.UserTypeContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterSimpleUserType(KotlinParser.SimpleUserTypeContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitSimpleUserType(KotlinParser.SimpleUserTypeContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTypeProjection(KotlinParser.TypeProjectionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTypeProjection(KotlinParser.TypeProjectionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTypeProjectionModifiers(KotlinParser.TypeProjectionModifiersContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTypeProjectionModifiers(KotlinParser.TypeProjectionModifiersContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTypeProjectionModifier(KotlinParser.TypeProjectionModifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTypeProjectionModifier(KotlinParser.TypeProjectionModifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterFunctionType(KotlinParser.FunctionTypeContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitFunctionType(KotlinParser.FunctionTypeContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterFunctionTypeParameters(KotlinParser.FunctionTypeParametersContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitFunctionTypeParameters(KotlinParser.FunctionTypeParametersContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterParenthesizedType(KotlinParser.ParenthesizedTypeContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitParenthesizedType(KotlinParser.ParenthesizedTypeContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterReceiverType(KotlinParser.ReceiverTypeContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitReceiverType(KotlinParser.ReceiverTypeContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterParenthesizedUserType(KotlinParser.ParenthesizedUserTypeContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitParenthesizedUserType(KotlinParser.ParenthesizedUserTypeContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterStatements(KotlinParser.StatementsContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitStatements(KotlinParser.StatementsContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterStatement(KotlinParser.StatementContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitStatement(KotlinParser.StatementContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterLabel(KotlinParser.LabelContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitLabel(KotlinParser.LabelContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterControlStructureBody(KotlinParser.ControlStructureBodyContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitControlStructureBody(KotlinParser.ControlStructureBodyContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterBlock(KotlinParser.BlockContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitBlock(KotlinParser.BlockContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterLoopStatement(KotlinParser.LoopStatementContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitLoopStatement(KotlinParser.LoopStatementContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterForStatement(KotlinParser.ForStatementContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitForStatement(KotlinParser.ForStatementContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterWhileStatement(KotlinParser.WhileStatementContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitWhileStatement(KotlinParser.WhileStatementContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterDoWhileStatement(KotlinParser.DoWhileStatementContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitDoWhileStatement(KotlinParser.DoWhileStatementContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterAssignment(KotlinParser.AssignmentContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitAssignment(KotlinParser.AssignmentContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterSemi(KotlinParser.SemiContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitSemi(KotlinParser.SemiContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterSemis(KotlinParser.SemisContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitSemis(KotlinParser.SemisContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterExpression(KotlinParser.ExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitExpression(KotlinParser.ExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterDisjunction(KotlinParser.DisjunctionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitDisjunction(KotlinParser.DisjunctionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterConjunction(KotlinParser.ConjunctionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitConjunction(KotlinParser.ConjunctionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterEquality(KotlinParser.EqualityContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitEquality(KotlinParser.EqualityContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterComparison(KotlinParser.ComparisonContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitComparison(KotlinParser.ComparisonContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterGenericCallLikeComparison(KotlinParser.GenericCallLikeComparisonContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitGenericCallLikeComparison(KotlinParser.GenericCallLikeComparisonContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterInfixOperation(KotlinParser.InfixOperationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitInfixOperation(KotlinParser.InfixOperationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterElvisExpression(KotlinParser.ElvisExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitElvisExpression(KotlinParser.ElvisExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterElvis(KotlinParser.ElvisContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitElvis(KotlinParser.ElvisContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterInfixFunctionCall(KotlinParser.InfixFunctionCallContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitInfixFunctionCall(KotlinParser.InfixFunctionCallContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterRangeExpression(KotlinParser.RangeExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitRangeExpression(KotlinParser.RangeExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterAdditiveExpression(KotlinParser.AdditiveExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitAdditiveExpression(KotlinParser.AdditiveExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterMultiplicativeExpression(KotlinParser.MultiplicativeExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitMultiplicativeExpression(KotlinParser.MultiplicativeExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterAsExpression(KotlinParser.AsExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitAsExpression(KotlinParser.AsExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterPrefixUnaryExpression(KotlinParser.PrefixUnaryExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitPrefixUnaryExpression(KotlinParser.PrefixUnaryExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterUnaryPrefix(KotlinParser.UnaryPrefixContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitUnaryPrefix(KotlinParser.UnaryPrefixContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterPostfixUnaryExpression(KotlinParser.PostfixUnaryExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitPostfixUnaryExpression(KotlinParser.PostfixUnaryExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterPostfixUnarySuffix(KotlinParser.PostfixUnarySuffixContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitPostfixUnarySuffix(KotlinParser.PostfixUnarySuffixContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterDirectlyAssignableExpression( + KotlinParser.DirectlyAssignableExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitDirectlyAssignableExpression( + KotlinParser.DirectlyAssignableExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterParenthesizedDirectlyAssignableExpression( + KotlinParser.ParenthesizedDirectlyAssignableExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitParenthesizedDirectlyAssignableExpression( + KotlinParser.ParenthesizedDirectlyAssignableExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterAssignableExpression(KotlinParser.AssignableExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitAssignableExpression(KotlinParser.AssignableExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterParenthesizedAssignableExpression( + KotlinParser.ParenthesizedAssignableExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitParenthesizedAssignableExpression( + KotlinParser.ParenthesizedAssignableExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterAssignableSuffix(KotlinParser.AssignableSuffixContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitAssignableSuffix(KotlinParser.AssignableSuffixContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterIndexingSuffix(KotlinParser.IndexingSuffixContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitIndexingSuffix(KotlinParser.IndexingSuffixContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterNavigationSuffix(KotlinParser.NavigationSuffixContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitNavigationSuffix(KotlinParser.NavigationSuffixContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterCallSuffix(KotlinParser.CallSuffixContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitCallSuffix(KotlinParser.CallSuffixContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterAnnotatedLambda(KotlinParser.AnnotatedLambdaContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitAnnotatedLambda(KotlinParser.AnnotatedLambdaContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTypeArguments(KotlinParser.TypeArgumentsContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTypeArguments(KotlinParser.TypeArgumentsContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterValueArguments(KotlinParser.ValueArgumentsContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitValueArguments(KotlinParser.ValueArgumentsContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterValueArgument(KotlinParser.ValueArgumentContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitValueArgument(KotlinParser.ValueArgumentContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterPrimaryExpression(KotlinParser.PrimaryExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitPrimaryExpression(KotlinParser.PrimaryExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterParenthesizedExpression(KotlinParser.ParenthesizedExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitParenthesizedExpression(KotlinParser.ParenthesizedExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterCollectionLiteral(KotlinParser.CollectionLiteralContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitCollectionLiteral(KotlinParser.CollectionLiteralContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterLiteralConstant(KotlinParser.LiteralConstantContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitLiteralConstant(KotlinParser.LiteralConstantContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterStringLiteral(KotlinParser.StringLiteralContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitStringLiteral(KotlinParser.StringLiteralContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterLineStringLiteral(KotlinParser.LineStringLiteralContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitLineStringLiteral(KotlinParser.LineStringLiteralContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterMultiLineStringLiteral(KotlinParser.MultiLineStringLiteralContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitMultiLineStringLiteral(KotlinParser.MultiLineStringLiteralContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterLineStringContent(KotlinParser.LineStringContentContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitLineStringContent(KotlinParser.LineStringContentContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterLineStringExpression(KotlinParser.LineStringExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitLineStringExpression(KotlinParser.LineStringExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterMultiLineStringContent(KotlinParser.MultiLineStringContentContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitMultiLineStringContent(KotlinParser.MultiLineStringContentContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterMultiLineStringExpression(KotlinParser.MultiLineStringExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitMultiLineStringExpression(KotlinParser.MultiLineStringExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterLambdaLiteral(KotlinParser.LambdaLiteralContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitLambdaLiteral(KotlinParser.LambdaLiteralContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterLambdaParameters(KotlinParser.LambdaParametersContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitLambdaParameters(KotlinParser.LambdaParametersContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterLambdaParameter(KotlinParser.LambdaParameterContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitLambdaParameter(KotlinParser.LambdaParameterContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterAnonymousFunction(KotlinParser.AnonymousFunctionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitAnonymousFunction(KotlinParser.AnonymousFunctionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterFunctionLiteral(KotlinParser.FunctionLiteralContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitFunctionLiteral(KotlinParser.FunctionLiteralContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterObjectLiteral(KotlinParser.ObjectLiteralContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitObjectLiteral(KotlinParser.ObjectLiteralContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterThisExpression(KotlinParser.ThisExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitThisExpression(KotlinParser.ThisExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterSuperExpression(KotlinParser.SuperExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitSuperExpression(KotlinParser.SuperExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterIfExpression(KotlinParser.IfExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitIfExpression(KotlinParser.IfExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterWhenSubject(KotlinParser.WhenSubjectContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitWhenSubject(KotlinParser.WhenSubjectContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterWhenExpression(KotlinParser.WhenExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitWhenExpression(KotlinParser.WhenExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterWhenEntry(KotlinParser.WhenEntryContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitWhenEntry(KotlinParser.WhenEntryContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterWhenCondition(KotlinParser.WhenConditionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitWhenCondition(KotlinParser.WhenConditionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterRangeTest(KotlinParser.RangeTestContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitRangeTest(KotlinParser.RangeTestContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTypeTest(KotlinParser.TypeTestContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTypeTest(KotlinParser.TypeTestContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTryExpression(KotlinParser.TryExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTryExpression(KotlinParser.TryExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterCatchBlock(KotlinParser.CatchBlockContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitCatchBlock(KotlinParser.CatchBlockContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterFinallyBlock(KotlinParser.FinallyBlockContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitFinallyBlock(KotlinParser.FinallyBlockContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterJumpExpression(KotlinParser.JumpExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitJumpExpression(KotlinParser.JumpExpressionContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterCallableReference(KotlinParser.CallableReferenceContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitCallableReference(KotlinParser.CallableReferenceContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterAssignmentAndOperator(KotlinParser.AssignmentAndOperatorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitAssignmentAndOperator(KotlinParser.AssignmentAndOperatorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterEqualityOperator(KotlinParser.EqualityOperatorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitEqualityOperator(KotlinParser.EqualityOperatorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterComparisonOperator(KotlinParser.ComparisonOperatorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitComparisonOperator(KotlinParser.ComparisonOperatorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterInOperator(KotlinParser.InOperatorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitInOperator(KotlinParser.InOperatorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterIsOperator(KotlinParser.IsOperatorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitIsOperator(KotlinParser.IsOperatorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterAdditiveOperator(KotlinParser.AdditiveOperatorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitAdditiveOperator(KotlinParser.AdditiveOperatorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterMultiplicativeOperator(KotlinParser.MultiplicativeOperatorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitMultiplicativeOperator(KotlinParser.MultiplicativeOperatorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterAsOperator(KotlinParser.AsOperatorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitAsOperator(KotlinParser.AsOperatorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterPrefixUnaryOperator(KotlinParser.PrefixUnaryOperatorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitPrefixUnaryOperator(KotlinParser.PrefixUnaryOperatorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterPostfixUnaryOperator(KotlinParser.PostfixUnaryOperatorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitPostfixUnaryOperator(KotlinParser.PostfixUnaryOperatorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterExcl(KotlinParser.ExclContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitExcl(KotlinParser.ExclContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterMemberAccessOperator(KotlinParser.MemberAccessOperatorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitMemberAccessOperator(KotlinParser.MemberAccessOperatorContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterSafeNav(KotlinParser.SafeNavContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitSafeNav(KotlinParser.SafeNavContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterModifiers(KotlinParser.ModifiersContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitModifiers(KotlinParser.ModifiersContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterParameterModifiers(KotlinParser.ParameterModifiersContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitParameterModifiers(KotlinParser.ParameterModifiersContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterModifier(KotlinParser.ModifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitModifier(KotlinParser.ModifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTypeModifiers(KotlinParser.TypeModifiersContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTypeModifiers(KotlinParser.TypeModifiersContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTypeModifier(KotlinParser.TypeModifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTypeModifier(KotlinParser.TypeModifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterClassModifier(KotlinParser.ClassModifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitClassModifier(KotlinParser.ClassModifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterMemberModifier(KotlinParser.MemberModifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitMemberModifier(KotlinParser.MemberModifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterVisibilityModifier(KotlinParser.VisibilityModifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitVisibilityModifier(KotlinParser.VisibilityModifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterVarianceModifier(KotlinParser.VarianceModifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitVarianceModifier(KotlinParser.VarianceModifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTypeParameterModifiers(KotlinParser.TypeParameterModifiersContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTypeParameterModifiers(KotlinParser.TypeParameterModifiersContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterTypeParameterModifier(KotlinParser.TypeParameterModifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitTypeParameterModifier(KotlinParser.TypeParameterModifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterFunctionModifier(KotlinParser.FunctionModifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitFunctionModifier(KotlinParser.FunctionModifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterPropertyModifier(KotlinParser.PropertyModifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitPropertyModifier(KotlinParser.PropertyModifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterInheritanceModifier(KotlinParser.InheritanceModifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitInheritanceModifier(KotlinParser.InheritanceModifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterParameterModifier(KotlinParser.ParameterModifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitParameterModifier(KotlinParser.ParameterModifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterReificationModifier(KotlinParser.ReificationModifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitReificationModifier(KotlinParser.ReificationModifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterPlatformModifier(KotlinParser.PlatformModifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitPlatformModifier(KotlinParser.PlatformModifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterAnnotation(KotlinParser.AnnotationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitAnnotation(KotlinParser.AnnotationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterSingleAnnotation(KotlinParser.SingleAnnotationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitSingleAnnotation(KotlinParser.SingleAnnotationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterMultiAnnotation(KotlinParser.MultiAnnotationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitMultiAnnotation(KotlinParser.MultiAnnotationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterAnnotationUseSiteTarget(KotlinParser.AnnotationUseSiteTargetContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitAnnotationUseSiteTarget(KotlinParser.AnnotationUseSiteTargetContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterUnescapedAnnotation(KotlinParser.UnescapedAnnotationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitUnescapedAnnotation(KotlinParser.UnescapedAnnotationContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterSimpleIdentifier(KotlinParser.SimpleIdentifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitSimpleIdentifier(KotlinParser.SimpleIdentifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterIdentifier(KotlinParser.IdentifierContext ctx) {} + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitIdentifier(KotlinParser.IdentifierContext ctx) {} - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void enterEveryRule(ParserRuleContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void exitEveryRule(ParserRuleContext ctx) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void visitTerminal(TerminalNode node) { } - /** - * {@inheritDoc} - * - *

The default implementation does nothing.

- */ - @Override public void visitErrorNode(ErrorNode node) { } -} \ No newline at end of file + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void visitTerminal(TerminalNode node) {} + + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void visitErrorNode(ErrorNode node) {} + + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterEveryRule(ParserRuleContext ctx) {} + + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitEveryRule(ParserRuleContext ctx) {} +} diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/kotlin/KotlinParserBaseVisitor.java b/lexers/src/main/java/com/itsaky/androidide/lexers/kotlin/KotlinParserBaseVisitor.java new file mode 100644 index 000000000..a79c1f4a3 --- /dev/null +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/kotlin/KotlinParserBaseVisitor.java @@ -0,0 +1,1748 @@ +// Generated from KotlinParser.g4 by ANTLR 4.9.3 +package com.itsaky.androidide.lexers.kotlin; + +import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor; + +/** + * This class provides an empty implementation of {@link KotlinParserVisitor}, which can be extended + * to create a visitor which only needs to handle a subset of the available methods. + * + * @param The return type of the visit operation. Use {@link Void} for operations with no return + * type. + */ +public class KotlinParserBaseVisitor extends AbstractParseTreeVisitor + implements KotlinParserVisitor { + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitKotlinFile(KotlinParser.KotlinFileContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitScript(KotlinParser.ScriptContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitShebangLine(KotlinParser.ShebangLineContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitFileAnnotation(KotlinParser.FileAnnotationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitPackageHeader(KotlinParser.PackageHeaderContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitImportList(KotlinParser.ImportListContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitImportHeader(KotlinParser.ImportHeaderContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitImportAlias(KotlinParser.ImportAliasContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTopLevelObject(KotlinParser.TopLevelObjectContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTypeAlias(KotlinParser.TypeAliasContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitDeclaration(KotlinParser.DeclarationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitClassDeclaration(KotlinParser.ClassDeclarationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitPrimaryConstructor(KotlinParser.PrimaryConstructorContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitClassBody(KotlinParser.ClassBodyContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitClassParameters(KotlinParser.ClassParametersContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitClassParameter(KotlinParser.ClassParameterContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitDelegationSpecifiers(KotlinParser.DelegationSpecifiersContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitDelegationSpecifier(KotlinParser.DelegationSpecifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitConstructorInvocation(KotlinParser.ConstructorInvocationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitAnnotatedDelegationSpecifier(KotlinParser.AnnotatedDelegationSpecifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitExplicitDelegation(KotlinParser.ExplicitDelegationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTypeParameters(KotlinParser.TypeParametersContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTypeParameter(KotlinParser.TypeParameterContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTypeConstraints(KotlinParser.TypeConstraintsContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTypeConstraint(KotlinParser.TypeConstraintContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitClassMemberDeclarations(KotlinParser.ClassMemberDeclarationsContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitClassMemberDeclaration(KotlinParser.ClassMemberDeclarationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitAnonymousInitializer(KotlinParser.AnonymousInitializerContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitCompanionObject(KotlinParser.CompanionObjectContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitFunctionValueParameters(KotlinParser.FunctionValueParametersContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitFunctionValueParameter(KotlinParser.FunctionValueParameterContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitFunctionDeclaration(KotlinParser.FunctionDeclarationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitFunctionBody(KotlinParser.FunctionBodyContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitVariableDeclaration(KotlinParser.VariableDeclarationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitMultiVariableDeclaration(KotlinParser.MultiVariableDeclarationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitPropertyDeclaration(KotlinParser.PropertyDeclarationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitPropertyDelegate(KotlinParser.PropertyDelegateContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitGetter(KotlinParser.GetterContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitSetter(KotlinParser.SetterContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitParametersWithOptionalType(KotlinParser.ParametersWithOptionalTypeContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitFunctionValueParameterWithOptionalType( + KotlinParser.FunctionValueParameterWithOptionalTypeContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitParameterWithOptionalType(KotlinParser.ParameterWithOptionalTypeContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitParameter(KotlinParser.ParameterContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitObjectDeclaration(KotlinParser.ObjectDeclarationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitSecondaryConstructor(KotlinParser.SecondaryConstructorContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitConstructorDelegationCall(KotlinParser.ConstructorDelegationCallContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitEnumClassBody(KotlinParser.EnumClassBodyContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitEnumEntries(KotlinParser.EnumEntriesContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitEnumEntry(KotlinParser.EnumEntryContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitType(KotlinParser.TypeContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTypeReference(KotlinParser.TypeReferenceContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitNullableType(KotlinParser.NullableTypeContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitQuest(KotlinParser.QuestContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitUserType(KotlinParser.UserTypeContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitSimpleUserType(KotlinParser.SimpleUserTypeContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTypeProjection(KotlinParser.TypeProjectionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTypeProjectionModifiers(KotlinParser.TypeProjectionModifiersContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTypeProjectionModifier(KotlinParser.TypeProjectionModifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitFunctionType(KotlinParser.FunctionTypeContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitFunctionTypeParameters(KotlinParser.FunctionTypeParametersContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitParenthesizedType(KotlinParser.ParenthesizedTypeContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitReceiverType(KotlinParser.ReceiverTypeContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitParenthesizedUserType(KotlinParser.ParenthesizedUserTypeContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitStatements(KotlinParser.StatementsContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitStatement(KotlinParser.StatementContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitLabel(KotlinParser.LabelContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitControlStructureBody(KotlinParser.ControlStructureBodyContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitBlock(KotlinParser.BlockContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitLoopStatement(KotlinParser.LoopStatementContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitForStatement(KotlinParser.ForStatementContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitWhileStatement(KotlinParser.WhileStatementContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitDoWhileStatement(KotlinParser.DoWhileStatementContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitAssignment(KotlinParser.AssignmentContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitSemi(KotlinParser.SemiContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitSemis(KotlinParser.SemisContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitExpression(KotlinParser.ExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitDisjunction(KotlinParser.DisjunctionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitConjunction(KotlinParser.ConjunctionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitEquality(KotlinParser.EqualityContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitComparison(KotlinParser.ComparisonContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitGenericCallLikeComparison(KotlinParser.GenericCallLikeComparisonContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitInfixOperation(KotlinParser.InfixOperationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitElvisExpression(KotlinParser.ElvisExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitElvis(KotlinParser.ElvisContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitInfixFunctionCall(KotlinParser.InfixFunctionCallContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitRangeExpression(KotlinParser.RangeExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitAdditiveExpression(KotlinParser.AdditiveExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitMultiplicativeExpression(KotlinParser.MultiplicativeExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitAsExpression(KotlinParser.AsExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitPrefixUnaryExpression(KotlinParser.PrefixUnaryExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitUnaryPrefix(KotlinParser.UnaryPrefixContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitPostfixUnaryExpression(KotlinParser.PostfixUnaryExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitPostfixUnarySuffix(KotlinParser.PostfixUnarySuffixContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitDirectlyAssignableExpression(KotlinParser.DirectlyAssignableExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitParenthesizedDirectlyAssignableExpression( + KotlinParser.ParenthesizedDirectlyAssignableExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitAssignableExpression(KotlinParser.AssignableExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitParenthesizedAssignableExpression( + KotlinParser.ParenthesizedAssignableExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitAssignableSuffix(KotlinParser.AssignableSuffixContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitIndexingSuffix(KotlinParser.IndexingSuffixContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitNavigationSuffix(KotlinParser.NavigationSuffixContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitCallSuffix(KotlinParser.CallSuffixContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitAnnotatedLambda(KotlinParser.AnnotatedLambdaContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTypeArguments(KotlinParser.TypeArgumentsContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitValueArguments(KotlinParser.ValueArgumentsContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitValueArgument(KotlinParser.ValueArgumentContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitPrimaryExpression(KotlinParser.PrimaryExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitParenthesizedExpression(KotlinParser.ParenthesizedExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitCollectionLiteral(KotlinParser.CollectionLiteralContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitLiteralConstant(KotlinParser.LiteralConstantContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitStringLiteral(KotlinParser.StringLiteralContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitLineStringLiteral(KotlinParser.LineStringLiteralContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitMultiLineStringLiteral(KotlinParser.MultiLineStringLiteralContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitLineStringContent(KotlinParser.LineStringContentContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitLineStringExpression(KotlinParser.LineStringExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitMultiLineStringContent(KotlinParser.MultiLineStringContentContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitMultiLineStringExpression(KotlinParser.MultiLineStringExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitLambdaLiteral(KotlinParser.LambdaLiteralContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitLambdaParameters(KotlinParser.LambdaParametersContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitLambdaParameter(KotlinParser.LambdaParameterContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitAnonymousFunction(KotlinParser.AnonymousFunctionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitFunctionLiteral(KotlinParser.FunctionLiteralContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitObjectLiteral(KotlinParser.ObjectLiteralContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitThisExpression(KotlinParser.ThisExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitSuperExpression(KotlinParser.SuperExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitIfExpression(KotlinParser.IfExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitWhenSubject(KotlinParser.WhenSubjectContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitWhenExpression(KotlinParser.WhenExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitWhenEntry(KotlinParser.WhenEntryContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitWhenCondition(KotlinParser.WhenConditionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitRangeTest(KotlinParser.RangeTestContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTypeTest(KotlinParser.TypeTestContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTryExpression(KotlinParser.TryExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitCatchBlock(KotlinParser.CatchBlockContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitFinallyBlock(KotlinParser.FinallyBlockContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitJumpExpression(KotlinParser.JumpExpressionContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitCallableReference(KotlinParser.CallableReferenceContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitAssignmentAndOperator(KotlinParser.AssignmentAndOperatorContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitEqualityOperator(KotlinParser.EqualityOperatorContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitComparisonOperator(KotlinParser.ComparisonOperatorContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitInOperator(KotlinParser.InOperatorContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitIsOperator(KotlinParser.IsOperatorContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitAdditiveOperator(KotlinParser.AdditiveOperatorContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitMultiplicativeOperator(KotlinParser.MultiplicativeOperatorContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitAsOperator(KotlinParser.AsOperatorContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitPrefixUnaryOperator(KotlinParser.PrefixUnaryOperatorContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitPostfixUnaryOperator(KotlinParser.PostfixUnaryOperatorContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitExcl(KotlinParser.ExclContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitMemberAccessOperator(KotlinParser.MemberAccessOperatorContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitSafeNav(KotlinParser.SafeNavContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitModifiers(KotlinParser.ModifiersContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitParameterModifiers(KotlinParser.ParameterModifiersContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitModifier(KotlinParser.ModifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTypeModifiers(KotlinParser.TypeModifiersContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTypeModifier(KotlinParser.TypeModifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitClassModifier(KotlinParser.ClassModifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitMemberModifier(KotlinParser.MemberModifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitVisibilityModifier(KotlinParser.VisibilityModifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitVarianceModifier(KotlinParser.VarianceModifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTypeParameterModifiers(KotlinParser.TypeParameterModifiersContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitTypeParameterModifier(KotlinParser.TypeParameterModifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitFunctionModifier(KotlinParser.FunctionModifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitPropertyModifier(KotlinParser.PropertyModifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitInheritanceModifier(KotlinParser.InheritanceModifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitParameterModifier(KotlinParser.ParameterModifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitReificationModifier(KotlinParser.ReificationModifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitPlatformModifier(KotlinParser.PlatformModifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitAnnotation(KotlinParser.AnnotationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitSingleAnnotation(KotlinParser.SingleAnnotationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitMultiAnnotation(KotlinParser.MultiAnnotationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitAnnotationUseSiteTarget(KotlinParser.AnnotationUseSiteTargetContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitUnescapedAnnotation(KotlinParser.UnescapedAnnotationContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitSimpleIdentifier(KotlinParser.SimpleIdentifierContext ctx) { + return visitChildren(ctx); + } + /** + * {@inheritDoc} + * + *

The default implementation returns the result of calling {@link #visitChildren} on {@code + * ctx}. + */ + @Override + public T visitIdentifier(KotlinParser.IdentifierContext ctx) { + return visitChildren(ctx); + } +} diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/kotlin/KotlinParserListener.java b/lexers/src/main/java/com/itsaky/androidide/lexers/kotlin/KotlinParserListener.java index f6c5541d9..692972715 100644 --- a/lexers/src/main/java/com/itsaky/androidide/lexers/kotlin/KotlinParserListener.java +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/kotlin/KotlinParserListener.java @@ -1,1740 +1,2090 @@ -// Generated from KotlinParser.g4 by ANTLR 4.9.2 +// Generated from KotlinParser.g4 by ANTLR 4.9.3 package com.itsaky.androidide.lexers.kotlin; + import org.antlr.v4.runtime.tree.ParseTreeListener; -/** - * This interface defines a complete listener for a parse tree produced by - * {@link KotlinParser}. - */ +/** This interface defines a complete listener for a parse tree produced by {@link KotlinParser}. */ public interface KotlinParserListener extends ParseTreeListener { - /** - * Enter a parse tree produced by {@link KotlinParser#kotlinFile}. - * @param ctx the parse tree - */ - void enterKotlinFile(KotlinParser.KotlinFileContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#kotlinFile}. - * @param ctx the parse tree - */ - void exitKotlinFile(KotlinParser.KotlinFileContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#script}. - * @param ctx the parse tree - */ - void enterScript(KotlinParser.ScriptContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#script}. - * @param ctx the parse tree - */ - void exitScript(KotlinParser.ScriptContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#shebangLine}. - * @param ctx the parse tree - */ - void enterShebangLine(KotlinParser.ShebangLineContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#shebangLine}. - * @param ctx the parse tree - */ - void exitShebangLine(KotlinParser.ShebangLineContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#fileAnnotation}. - * @param ctx the parse tree - */ - void enterFileAnnotation(KotlinParser.FileAnnotationContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#fileAnnotation}. - * @param ctx the parse tree - */ - void exitFileAnnotation(KotlinParser.FileAnnotationContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#packageHeader}. - * @param ctx the parse tree - */ - void enterPackageHeader(KotlinParser.PackageHeaderContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#packageHeader}. - * @param ctx the parse tree - */ - void exitPackageHeader(KotlinParser.PackageHeaderContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#importList}. - * @param ctx the parse tree - */ - void enterImportList(KotlinParser.ImportListContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#importList}. - * @param ctx the parse tree - */ - void exitImportList(KotlinParser.ImportListContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#importHeader}. - * @param ctx the parse tree - */ - void enterImportHeader(KotlinParser.ImportHeaderContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#importHeader}. - * @param ctx the parse tree - */ - void exitImportHeader(KotlinParser.ImportHeaderContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#importAlias}. - * @param ctx the parse tree - */ - void enterImportAlias(KotlinParser.ImportAliasContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#importAlias}. - * @param ctx the parse tree - */ - void exitImportAlias(KotlinParser.ImportAliasContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#topLevelObject}. - * @param ctx the parse tree - */ - void enterTopLevelObject(KotlinParser.TopLevelObjectContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#topLevelObject}. - * @param ctx the parse tree - */ - void exitTopLevelObject(KotlinParser.TopLevelObjectContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#typeAlias}. - * @param ctx the parse tree - */ - void enterTypeAlias(KotlinParser.TypeAliasContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#typeAlias}. - * @param ctx the parse tree - */ - void exitTypeAlias(KotlinParser.TypeAliasContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#declaration}. - * @param ctx the parse tree - */ - void enterDeclaration(KotlinParser.DeclarationContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#declaration}. - * @param ctx the parse tree - */ - void exitDeclaration(KotlinParser.DeclarationContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#classDeclaration}. - * @param ctx the parse tree - */ - void enterClassDeclaration(KotlinParser.ClassDeclarationContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#classDeclaration}. - * @param ctx the parse tree - */ - void exitClassDeclaration(KotlinParser.ClassDeclarationContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#primaryConstructor}. - * @param ctx the parse tree - */ - void enterPrimaryConstructor(KotlinParser.PrimaryConstructorContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#primaryConstructor}. - * @param ctx the parse tree - */ - void exitPrimaryConstructor(KotlinParser.PrimaryConstructorContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#classBody}. - * @param ctx the parse tree - */ - void enterClassBody(KotlinParser.ClassBodyContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#classBody}. - * @param ctx the parse tree - */ - void exitClassBody(KotlinParser.ClassBodyContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#classParameters}. - * @param ctx the parse tree - */ - void enterClassParameters(KotlinParser.ClassParametersContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#classParameters}. - * @param ctx the parse tree - */ - void exitClassParameters(KotlinParser.ClassParametersContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#classParameter}. - * @param ctx the parse tree - */ - void enterClassParameter(KotlinParser.ClassParameterContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#classParameter}. - * @param ctx the parse tree - */ - void exitClassParameter(KotlinParser.ClassParameterContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#delegationSpecifiers}. - * @param ctx the parse tree - */ - void enterDelegationSpecifiers(KotlinParser.DelegationSpecifiersContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#delegationSpecifiers}. - * @param ctx the parse tree - */ - void exitDelegationSpecifiers(KotlinParser.DelegationSpecifiersContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#delegationSpecifier}. - * @param ctx the parse tree - */ - void enterDelegationSpecifier(KotlinParser.DelegationSpecifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#delegationSpecifier}. - * @param ctx the parse tree - */ - void exitDelegationSpecifier(KotlinParser.DelegationSpecifierContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#constructorInvocation}. - * @param ctx the parse tree - */ - void enterConstructorInvocation(KotlinParser.ConstructorInvocationContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#constructorInvocation}. - * @param ctx the parse tree - */ - void exitConstructorInvocation(KotlinParser.ConstructorInvocationContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#annotatedDelegationSpecifier}. - * @param ctx the parse tree - */ - void enterAnnotatedDelegationSpecifier(KotlinParser.AnnotatedDelegationSpecifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#annotatedDelegationSpecifier}. - * @param ctx the parse tree - */ - void exitAnnotatedDelegationSpecifier(KotlinParser.AnnotatedDelegationSpecifierContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#explicitDelegation}. - * @param ctx the parse tree - */ - void enterExplicitDelegation(KotlinParser.ExplicitDelegationContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#explicitDelegation}. - * @param ctx the parse tree - */ - void exitExplicitDelegation(KotlinParser.ExplicitDelegationContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#typeParameters}. - * @param ctx the parse tree - */ - void enterTypeParameters(KotlinParser.TypeParametersContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#typeParameters}. - * @param ctx the parse tree - */ - void exitTypeParameters(KotlinParser.TypeParametersContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#typeParameter}. - * @param ctx the parse tree - */ - void enterTypeParameter(KotlinParser.TypeParameterContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#typeParameter}. - * @param ctx the parse tree - */ - void exitTypeParameter(KotlinParser.TypeParameterContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#typeConstraints}. - * @param ctx the parse tree - */ - void enterTypeConstraints(KotlinParser.TypeConstraintsContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#typeConstraints}. - * @param ctx the parse tree - */ - void exitTypeConstraints(KotlinParser.TypeConstraintsContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#typeConstraint}. - * @param ctx the parse tree - */ - void enterTypeConstraint(KotlinParser.TypeConstraintContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#typeConstraint}. - * @param ctx the parse tree - */ - void exitTypeConstraint(KotlinParser.TypeConstraintContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#classMemberDeclarations}. - * @param ctx the parse tree - */ - void enterClassMemberDeclarations(KotlinParser.ClassMemberDeclarationsContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#classMemberDeclarations}. - * @param ctx the parse tree - */ - void exitClassMemberDeclarations(KotlinParser.ClassMemberDeclarationsContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#classMemberDeclaration}. - * @param ctx the parse tree - */ - void enterClassMemberDeclaration(KotlinParser.ClassMemberDeclarationContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#classMemberDeclaration}. - * @param ctx the parse tree - */ - void exitClassMemberDeclaration(KotlinParser.ClassMemberDeclarationContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#anonymousInitializer}. - * @param ctx the parse tree - */ - void enterAnonymousInitializer(KotlinParser.AnonymousInitializerContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#anonymousInitializer}. - * @param ctx the parse tree - */ - void exitAnonymousInitializer(KotlinParser.AnonymousInitializerContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#companionObject}. - * @param ctx the parse tree - */ - void enterCompanionObject(KotlinParser.CompanionObjectContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#companionObject}. - * @param ctx the parse tree - */ - void exitCompanionObject(KotlinParser.CompanionObjectContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#functionValueParameters}. - * @param ctx the parse tree - */ - void enterFunctionValueParameters(KotlinParser.FunctionValueParametersContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#functionValueParameters}. - * @param ctx the parse tree - */ - void exitFunctionValueParameters(KotlinParser.FunctionValueParametersContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#functionValueParameter}. - * @param ctx the parse tree - */ - void enterFunctionValueParameter(KotlinParser.FunctionValueParameterContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#functionValueParameter}. - * @param ctx the parse tree - */ - void exitFunctionValueParameter(KotlinParser.FunctionValueParameterContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#functionDeclaration}. - * @param ctx the parse tree - */ - void enterFunctionDeclaration(KotlinParser.FunctionDeclarationContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#functionDeclaration}. - * @param ctx the parse tree - */ - void exitFunctionDeclaration(KotlinParser.FunctionDeclarationContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#functionBody}. - * @param ctx the parse tree - */ - void enterFunctionBody(KotlinParser.FunctionBodyContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#functionBody}. - * @param ctx the parse tree - */ - void exitFunctionBody(KotlinParser.FunctionBodyContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#variableDeclaration}. - * @param ctx the parse tree - */ - void enterVariableDeclaration(KotlinParser.VariableDeclarationContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#variableDeclaration}. - * @param ctx the parse tree - */ - void exitVariableDeclaration(KotlinParser.VariableDeclarationContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#multiVariableDeclaration}. - * @param ctx the parse tree - */ - void enterMultiVariableDeclaration(KotlinParser.MultiVariableDeclarationContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#multiVariableDeclaration}. - * @param ctx the parse tree - */ - void exitMultiVariableDeclaration(KotlinParser.MultiVariableDeclarationContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#propertyDeclaration}. - * @param ctx the parse tree - */ - void enterPropertyDeclaration(KotlinParser.PropertyDeclarationContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#propertyDeclaration}. - * @param ctx the parse tree - */ - void exitPropertyDeclaration(KotlinParser.PropertyDeclarationContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#propertyDelegate}. - * @param ctx the parse tree - */ - void enterPropertyDelegate(KotlinParser.PropertyDelegateContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#propertyDelegate}. - * @param ctx the parse tree - */ - void exitPropertyDelegate(KotlinParser.PropertyDelegateContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#getter}. - * @param ctx the parse tree - */ - void enterGetter(KotlinParser.GetterContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#getter}. - * @param ctx the parse tree - */ - void exitGetter(KotlinParser.GetterContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#setter}. - * @param ctx the parse tree - */ - void enterSetter(KotlinParser.SetterContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#setter}. - * @param ctx the parse tree - */ - void exitSetter(KotlinParser.SetterContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#parametersWithOptionalType}. - * @param ctx the parse tree - */ - void enterParametersWithOptionalType(KotlinParser.ParametersWithOptionalTypeContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#parametersWithOptionalType}. - * @param ctx the parse tree - */ - void exitParametersWithOptionalType(KotlinParser.ParametersWithOptionalTypeContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#functionValueParameterWithOptionalType}. - * @param ctx the parse tree - */ - void enterFunctionValueParameterWithOptionalType(KotlinParser.FunctionValueParameterWithOptionalTypeContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#functionValueParameterWithOptionalType}. - * @param ctx the parse tree - */ - void exitFunctionValueParameterWithOptionalType(KotlinParser.FunctionValueParameterWithOptionalTypeContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#parameterWithOptionalType}. - * @param ctx the parse tree - */ - void enterParameterWithOptionalType(KotlinParser.ParameterWithOptionalTypeContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#parameterWithOptionalType}. - * @param ctx the parse tree - */ - void exitParameterWithOptionalType(KotlinParser.ParameterWithOptionalTypeContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#parameter}. - * @param ctx the parse tree - */ - void enterParameter(KotlinParser.ParameterContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#parameter}. - * @param ctx the parse tree - */ - void exitParameter(KotlinParser.ParameterContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#objectDeclaration}. - * @param ctx the parse tree - */ - void enterObjectDeclaration(KotlinParser.ObjectDeclarationContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#objectDeclaration}. - * @param ctx the parse tree - */ - void exitObjectDeclaration(KotlinParser.ObjectDeclarationContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#secondaryConstructor}. - * @param ctx the parse tree - */ - void enterSecondaryConstructor(KotlinParser.SecondaryConstructorContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#secondaryConstructor}. - * @param ctx the parse tree - */ - void exitSecondaryConstructor(KotlinParser.SecondaryConstructorContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#constructorDelegationCall}. - * @param ctx the parse tree - */ - void enterConstructorDelegationCall(KotlinParser.ConstructorDelegationCallContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#constructorDelegationCall}. - * @param ctx the parse tree - */ - void exitConstructorDelegationCall(KotlinParser.ConstructorDelegationCallContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#enumClassBody}. - * @param ctx the parse tree - */ - void enterEnumClassBody(KotlinParser.EnumClassBodyContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#enumClassBody}. - * @param ctx the parse tree - */ - void exitEnumClassBody(KotlinParser.EnumClassBodyContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#enumEntries}. - * @param ctx the parse tree - */ - void enterEnumEntries(KotlinParser.EnumEntriesContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#enumEntries}. - * @param ctx the parse tree - */ - void exitEnumEntries(KotlinParser.EnumEntriesContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#enumEntry}. - * @param ctx the parse tree - */ - void enterEnumEntry(KotlinParser.EnumEntryContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#enumEntry}. - * @param ctx the parse tree - */ - void exitEnumEntry(KotlinParser.EnumEntryContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#type}. - * @param ctx the parse tree - */ - void enterType(KotlinParser.TypeContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#type}. - * @param ctx the parse tree - */ - void exitType(KotlinParser.TypeContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#typeReference}. - * @param ctx the parse tree - */ - void enterTypeReference(KotlinParser.TypeReferenceContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#typeReference}. - * @param ctx the parse tree - */ - void exitTypeReference(KotlinParser.TypeReferenceContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#nullableType}. - * @param ctx the parse tree - */ - void enterNullableType(KotlinParser.NullableTypeContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#nullableType}. - * @param ctx the parse tree - */ - void exitNullableType(KotlinParser.NullableTypeContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#quest}. - * @param ctx the parse tree - */ - void enterQuest(KotlinParser.QuestContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#quest}. - * @param ctx the parse tree - */ - void exitQuest(KotlinParser.QuestContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#userType}. - * @param ctx the parse tree - */ - void enterUserType(KotlinParser.UserTypeContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#userType}. - * @param ctx the parse tree - */ - void exitUserType(KotlinParser.UserTypeContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#simpleUserType}. - * @param ctx the parse tree - */ - void enterSimpleUserType(KotlinParser.SimpleUserTypeContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#simpleUserType}. - * @param ctx the parse tree - */ - void exitSimpleUserType(KotlinParser.SimpleUserTypeContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#typeProjection}. - * @param ctx the parse tree - */ - void enterTypeProjection(KotlinParser.TypeProjectionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#typeProjection}. - * @param ctx the parse tree - */ - void exitTypeProjection(KotlinParser.TypeProjectionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#typeProjectionModifiers}. - * @param ctx the parse tree - */ - void enterTypeProjectionModifiers(KotlinParser.TypeProjectionModifiersContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#typeProjectionModifiers}. - * @param ctx the parse tree - */ - void exitTypeProjectionModifiers(KotlinParser.TypeProjectionModifiersContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#typeProjectionModifier}. - * @param ctx the parse tree - */ - void enterTypeProjectionModifier(KotlinParser.TypeProjectionModifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#typeProjectionModifier}. - * @param ctx the parse tree - */ - void exitTypeProjectionModifier(KotlinParser.TypeProjectionModifierContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#functionType}. - * @param ctx the parse tree - */ - void enterFunctionType(KotlinParser.FunctionTypeContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#functionType}. - * @param ctx the parse tree - */ - void exitFunctionType(KotlinParser.FunctionTypeContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#functionTypeParameters}. - * @param ctx the parse tree - */ - void enterFunctionTypeParameters(KotlinParser.FunctionTypeParametersContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#functionTypeParameters}. - * @param ctx the parse tree - */ - void exitFunctionTypeParameters(KotlinParser.FunctionTypeParametersContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#parenthesizedType}. - * @param ctx the parse tree - */ - void enterParenthesizedType(KotlinParser.ParenthesizedTypeContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#parenthesizedType}. - * @param ctx the parse tree - */ - void exitParenthesizedType(KotlinParser.ParenthesizedTypeContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#receiverType}. - * @param ctx the parse tree - */ - void enterReceiverType(KotlinParser.ReceiverTypeContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#receiverType}. - * @param ctx the parse tree - */ - void exitReceiverType(KotlinParser.ReceiverTypeContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#parenthesizedUserType}. - * @param ctx the parse tree - */ - void enterParenthesizedUserType(KotlinParser.ParenthesizedUserTypeContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#parenthesizedUserType}. - * @param ctx the parse tree - */ - void exitParenthesizedUserType(KotlinParser.ParenthesizedUserTypeContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#statements}. - * @param ctx the parse tree - */ - void enterStatements(KotlinParser.StatementsContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#statements}. - * @param ctx the parse tree - */ - void exitStatements(KotlinParser.StatementsContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#statement}. - * @param ctx the parse tree - */ - void enterStatement(KotlinParser.StatementContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#statement}. - * @param ctx the parse tree - */ - void exitStatement(KotlinParser.StatementContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#label}. - * @param ctx the parse tree - */ - void enterLabel(KotlinParser.LabelContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#label}. - * @param ctx the parse tree - */ - void exitLabel(KotlinParser.LabelContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#controlStructureBody}. - * @param ctx the parse tree - */ - void enterControlStructureBody(KotlinParser.ControlStructureBodyContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#controlStructureBody}. - * @param ctx the parse tree - */ - void exitControlStructureBody(KotlinParser.ControlStructureBodyContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#block}. - * @param ctx the parse tree - */ - void enterBlock(KotlinParser.BlockContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#block}. - * @param ctx the parse tree - */ - void exitBlock(KotlinParser.BlockContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#loopStatement}. - * @param ctx the parse tree - */ - void enterLoopStatement(KotlinParser.LoopStatementContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#loopStatement}. - * @param ctx the parse tree - */ - void exitLoopStatement(KotlinParser.LoopStatementContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#forStatement}. - * @param ctx the parse tree - */ - void enterForStatement(KotlinParser.ForStatementContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#forStatement}. - * @param ctx the parse tree - */ - void exitForStatement(KotlinParser.ForStatementContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#whileStatement}. - * @param ctx the parse tree - */ - void enterWhileStatement(KotlinParser.WhileStatementContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#whileStatement}. - * @param ctx the parse tree - */ - void exitWhileStatement(KotlinParser.WhileStatementContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#doWhileStatement}. - * @param ctx the parse tree - */ - void enterDoWhileStatement(KotlinParser.DoWhileStatementContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#doWhileStatement}. - * @param ctx the parse tree - */ - void exitDoWhileStatement(KotlinParser.DoWhileStatementContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#assignment}. - * @param ctx the parse tree - */ - void enterAssignment(KotlinParser.AssignmentContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#assignment}. - * @param ctx the parse tree - */ - void exitAssignment(KotlinParser.AssignmentContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#semi}. - * @param ctx the parse tree - */ - void enterSemi(KotlinParser.SemiContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#semi}. - * @param ctx the parse tree - */ - void exitSemi(KotlinParser.SemiContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#semis}. - * @param ctx the parse tree - */ - void enterSemis(KotlinParser.SemisContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#semis}. - * @param ctx the parse tree - */ - void exitSemis(KotlinParser.SemisContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#expression}. - * @param ctx the parse tree - */ - void enterExpression(KotlinParser.ExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#expression}. - * @param ctx the parse tree - */ - void exitExpression(KotlinParser.ExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#disjunction}. - * @param ctx the parse tree - */ - void enterDisjunction(KotlinParser.DisjunctionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#disjunction}. - * @param ctx the parse tree - */ - void exitDisjunction(KotlinParser.DisjunctionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#conjunction}. - * @param ctx the parse tree - */ - void enterConjunction(KotlinParser.ConjunctionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#conjunction}. - * @param ctx the parse tree - */ - void exitConjunction(KotlinParser.ConjunctionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#equality}. - * @param ctx the parse tree - */ - void enterEquality(KotlinParser.EqualityContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#equality}. - * @param ctx the parse tree - */ - void exitEquality(KotlinParser.EqualityContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#comparison}. - * @param ctx the parse tree - */ - void enterComparison(KotlinParser.ComparisonContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#comparison}. - * @param ctx the parse tree - */ - void exitComparison(KotlinParser.ComparisonContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#genericCallLikeComparison}. - * @param ctx the parse tree - */ - void enterGenericCallLikeComparison(KotlinParser.GenericCallLikeComparisonContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#genericCallLikeComparison}. - * @param ctx the parse tree - */ - void exitGenericCallLikeComparison(KotlinParser.GenericCallLikeComparisonContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#infixOperation}. - * @param ctx the parse tree - */ - void enterInfixOperation(KotlinParser.InfixOperationContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#infixOperation}. - * @param ctx the parse tree - */ - void exitInfixOperation(KotlinParser.InfixOperationContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#elvisExpression}. - * @param ctx the parse tree - */ - void enterElvisExpression(KotlinParser.ElvisExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#elvisExpression}. - * @param ctx the parse tree - */ - void exitElvisExpression(KotlinParser.ElvisExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#elvis}. - * @param ctx the parse tree - */ - void enterElvis(KotlinParser.ElvisContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#elvis}. - * @param ctx the parse tree - */ - void exitElvis(KotlinParser.ElvisContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#infixFunctionCall}. - * @param ctx the parse tree - */ - void enterInfixFunctionCall(KotlinParser.InfixFunctionCallContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#infixFunctionCall}. - * @param ctx the parse tree - */ - void exitInfixFunctionCall(KotlinParser.InfixFunctionCallContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#rangeExpression}. - * @param ctx the parse tree - */ - void enterRangeExpression(KotlinParser.RangeExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#rangeExpression}. - * @param ctx the parse tree - */ - void exitRangeExpression(KotlinParser.RangeExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#additiveExpression}. - * @param ctx the parse tree - */ - void enterAdditiveExpression(KotlinParser.AdditiveExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#additiveExpression}. - * @param ctx the parse tree - */ - void exitAdditiveExpression(KotlinParser.AdditiveExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#multiplicativeExpression}. - * @param ctx the parse tree - */ - void enterMultiplicativeExpression(KotlinParser.MultiplicativeExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#multiplicativeExpression}. - * @param ctx the parse tree - */ - void exitMultiplicativeExpression(KotlinParser.MultiplicativeExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#asExpression}. - * @param ctx the parse tree - */ - void enterAsExpression(KotlinParser.AsExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#asExpression}. - * @param ctx the parse tree - */ - void exitAsExpression(KotlinParser.AsExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#prefixUnaryExpression}. - * @param ctx the parse tree - */ - void enterPrefixUnaryExpression(KotlinParser.PrefixUnaryExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#prefixUnaryExpression}. - * @param ctx the parse tree - */ - void exitPrefixUnaryExpression(KotlinParser.PrefixUnaryExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#unaryPrefix}. - * @param ctx the parse tree - */ - void enterUnaryPrefix(KotlinParser.UnaryPrefixContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#unaryPrefix}. - * @param ctx the parse tree - */ - void exitUnaryPrefix(KotlinParser.UnaryPrefixContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#postfixUnaryExpression}. - * @param ctx the parse tree - */ - void enterPostfixUnaryExpression(KotlinParser.PostfixUnaryExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#postfixUnaryExpression}. - * @param ctx the parse tree - */ - void exitPostfixUnaryExpression(KotlinParser.PostfixUnaryExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#postfixUnarySuffix}. - * @param ctx the parse tree - */ - void enterPostfixUnarySuffix(KotlinParser.PostfixUnarySuffixContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#postfixUnarySuffix}. - * @param ctx the parse tree - */ - void exitPostfixUnarySuffix(KotlinParser.PostfixUnarySuffixContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#directlyAssignableExpression}. - * @param ctx the parse tree - */ - void enterDirectlyAssignableExpression(KotlinParser.DirectlyAssignableExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#directlyAssignableExpression}. - * @param ctx the parse tree - */ - void exitDirectlyAssignableExpression(KotlinParser.DirectlyAssignableExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#parenthesizedDirectlyAssignableExpression}. - * @param ctx the parse tree - */ - void enterParenthesizedDirectlyAssignableExpression(KotlinParser.ParenthesizedDirectlyAssignableExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#parenthesizedDirectlyAssignableExpression}. - * @param ctx the parse tree - */ - void exitParenthesizedDirectlyAssignableExpression(KotlinParser.ParenthesizedDirectlyAssignableExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#assignableExpression}. - * @param ctx the parse tree - */ - void enterAssignableExpression(KotlinParser.AssignableExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#assignableExpression}. - * @param ctx the parse tree - */ - void exitAssignableExpression(KotlinParser.AssignableExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#parenthesizedAssignableExpression}. - * @param ctx the parse tree - */ - void enterParenthesizedAssignableExpression(KotlinParser.ParenthesizedAssignableExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#parenthesizedAssignableExpression}. - * @param ctx the parse tree - */ - void exitParenthesizedAssignableExpression(KotlinParser.ParenthesizedAssignableExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#assignableSuffix}. - * @param ctx the parse tree - */ - void enterAssignableSuffix(KotlinParser.AssignableSuffixContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#assignableSuffix}. - * @param ctx the parse tree - */ - void exitAssignableSuffix(KotlinParser.AssignableSuffixContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#indexingSuffix}. - * @param ctx the parse tree - */ - void enterIndexingSuffix(KotlinParser.IndexingSuffixContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#indexingSuffix}. - * @param ctx the parse tree - */ - void exitIndexingSuffix(KotlinParser.IndexingSuffixContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#navigationSuffix}. - * @param ctx the parse tree - */ - void enterNavigationSuffix(KotlinParser.NavigationSuffixContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#navigationSuffix}. - * @param ctx the parse tree - */ - void exitNavigationSuffix(KotlinParser.NavigationSuffixContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#callSuffix}. - * @param ctx the parse tree - */ - void enterCallSuffix(KotlinParser.CallSuffixContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#callSuffix}. - * @param ctx the parse tree - */ - void exitCallSuffix(KotlinParser.CallSuffixContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#annotatedLambda}. - * @param ctx the parse tree - */ - void enterAnnotatedLambda(KotlinParser.AnnotatedLambdaContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#annotatedLambda}. - * @param ctx the parse tree - */ - void exitAnnotatedLambda(KotlinParser.AnnotatedLambdaContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#typeArguments}. - * @param ctx the parse tree - */ - void enterTypeArguments(KotlinParser.TypeArgumentsContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#typeArguments}. - * @param ctx the parse tree - */ - void exitTypeArguments(KotlinParser.TypeArgumentsContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#valueArguments}. - * @param ctx the parse tree - */ - void enterValueArguments(KotlinParser.ValueArgumentsContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#valueArguments}. - * @param ctx the parse tree - */ - void exitValueArguments(KotlinParser.ValueArgumentsContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#valueArgument}. - * @param ctx the parse tree - */ - void enterValueArgument(KotlinParser.ValueArgumentContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#valueArgument}. - * @param ctx the parse tree - */ - void exitValueArgument(KotlinParser.ValueArgumentContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#primaryExpression}. - * @param ctx the parse tree - */ - void enterPrimaryExpression(KotlinParser.PrimaryExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#primaryExpression}. - * @param ctx the parse tree - */ - void exitPrimaryExpression(KotlinParser.PrimaryExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#parenthesizedExpression}. - * @param ctx the parse tree - */ - void enterParenthesizedExpression(KotlinParser.ParenthesizedExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#parenthesizedExpression}. - * @param ctx the parse tree - */ - void exitParenthesizedExpression(KotlinParser.ParenthesizedExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#collectionLiteral}. - * @param ctx the parse tree - */ - void enterCollectionLiteral(KotlinParser.CollectionLiteralContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#collectionLiteral}. - * @param ctx the parse tree - */ - void exitCollectionLiteral(KotlinParser.CollectionLiteralContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#literalConstant}. - * @param ctx the parse tree - */ - void enterLiteralConstant(KotlinParser.LiteralConstantContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#literalConstant}. - * @param ctx the parse tree - */ - void exitLiteralConstant(KotlinParser.LiteralConstantContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#stringLiteral}. - * @param ctx the parse tree - */ - void enterStringLiteral(KotlinParser.StringLiteralContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#stringLiteral}. - * @param ctx the parse tree - */ - void exitStringLiteral(KotlinParser.StringLiteralContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#lineStringLiteral}. - * @param ctx the parse tree - */ - void enterLineStringLiteral(KotlinParser.LineStringLiteralContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#lineStringLiteral}. - * @param ctx the parse tree - */ - void exitLineStringLiteral(KotlinParser.LineStringLiteralContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#multiLineStringLiteral}. - * @param ctx the parse tree - */ - void enterMultiLineStringLiteral(KotlinParser.MultiLineStringLiteralContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#multiLineStringLiteral}. - * @param ctx the parse tree - */ - void exitMultiLineStringLiteral(KotlinParser.MultiLineStringLiteralContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#lineStringContent}. - * @param ctx the parse tree - */ - void enterLineStringContent(KotlinParser.LineStringContentContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#lineStringContent}. - * @param ctx the parse tree - */ - void exitLineStringContent(KotlinParser.LineStringContentContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#lineStringExpression}. - * @param ctx the parse tree - */ - void enterLineStringExpression(KotlinParser.LineStringExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#lineStringExpression}. - * @param ctx the parse tree - */ - void exitLineStringExpression(KotlinParser.LineStringExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#multiLineStringContent}. - * @param ctx the parse tree - */ - void enterMultiLineStringContent(KotlinParser.MultiLineStringContentContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#multiLineStringContent}. - * @param ctx the parse tree - */ - void exitMultiLineStringContent(KotlinParser.MultiLineStringContentContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#multiLineStringExpression}. - * @param ctx the parse tree - */ - void enterMultiLineStringExpression(KotlinParser.MultiLineStringExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#multiLineStringExpression}. - * @param ctx the parse tree - */ - void exitMultiLineStringExpression(KotlinParser.MultiLineStringExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#lambdaLiteral}. - * @param ctx the parse tree - */ - void enterLambdaLiteral(KotlinParser.LambdaLiteralContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#lambdaLiteral}. - * @param ctx the parse tree - */ - void exitLambdaLiteral(KotlinParser.LambdaLiteralContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#lambdaParameters}. - * @param ctx the parse tree - */ - void enterLambdaParameters(KotlinParser.LambdaParametersContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#lambdaParameters}. - * @param ctx the parse tree - */ - void exitLambdaParameters(KotlinParser.LambdaParametersContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#lambdaParameter}. - * @param ctx the parse tree - */ - void enterLambdaParameter(KotlinParser.LambdaParameterContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#lambdaParameter}. - * @param ctx the parse tree - */ - void exitLambdaParameter(KotlinParser.LambdaParameterContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#anonymousFunction}. - * @param ctx the parse tree - */ - void enterAnonymousFunction(KotlinParser.AnonymousFunctionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#anonymousFunction}. - * @param ctx the parse tree - */ - void exitAnonymousFunction(KotlinParser.AnonymousFunctionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#functionLiteral}. - * @param ctx the parse tree - */ - void enterFunctionLiteral(KotlinParser.FunctionLiteralContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#functionLiteral}. - * @param ctx the parse tree - */ - void exitFunctionLiteral(KotlinParser.FunctionLiteralContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#objectLiteral}. - * @param ctx the parse tree - */ - void enterObjectLiteral(KotlinParser.ObjectLiteralContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#objectLiteral}. - * @param ctx the parse tree - */ - void exitObjectLiteral(KotlinParser.ObjectLiteralContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#thisExpression}. - * @param ctx the parse tree - */ - void enterThisExpression(KotlinParser.ThisExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#thisExpression}. - * @param ctx the parse tree - */ - void exitThisExpression(KotlinParser.ThisExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#superExpression}. - * @param ctx the parse tree - */ - void enterSuperExpression(KotlinParser.SuperExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#superExpression}. - * @param ctx the parse tree - */ - void exitSuperExpression(KotlinParser.SuperExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#ifExpression}. - * @param ctx the parse tree - */ - void enterIfExpression(KotlinParser.IfExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#ifExpression}. - * @param ctx the parse tree - */ - void exitIfExpression(KotlinParser.IfExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#whenSubject}. - * @param ctx the parse tree - */ - void enterWhenSubject(KotlinParser.WhenSubjectContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#whenSubject}. - * @param ctx the parse tree - */ - void exitWhenSubject(KotlinParser.WhenSubjectContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#whenExpression}. - * @param ctx the parse tree - */ - void enterWhenExpression(KotlinParser.WhenExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#whenExpression}. - * @param ctx the parse tree - */ - void exitWhenExpression(KotlinParser.WhenExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#whenEntry}. - * @param ctx the parse tree - */ - void enterWhenEntry(KotlinParser.WhenEntryContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#whenEntry}. - * @param ctx the parse tree - */ - void exitWhenEntry(KotlinParser.WhenEntryContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#whenCondition}. - * @param ctx the parse tree - */ - void enterWhenCondition(KotlinParser.WhenConditionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#whenCondition}. - * @param ctx the parse tree - */ - void exitWhenCondition(KotlinParser.WhenConditionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#rangeTest}. - * @param ctx the parse tree - */ - void enterRangeTest(KotlinParser.RangeTestContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#rangeTest}. - * @param ctx the parse tree - */ - void exitRangeTest(KotlinParser.RangeTestContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#typeTest}. - * @param ctx the parse tree - */ - void enterTypeTest(KotlinParser.TypeTestContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#typeTest}. - * @param ctx the parse tree - */ - void exitTypeTest(KotlinParser.TypeTestContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#tryExpression}. - * @param ctx the parse tree - */ - void enterTryExpression(KotlinParser.TryExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#tryExpression}. - * @param ctx the parse tree - */ - void exitTryExpression(KotlinParser.TryExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#catchBlock}. - * @param ctx the parse tree - */ - void enterCatchBlock(KotlinParser.CatchBlockContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#catchBlock}. - * @param ctx the parse tree - */ - void exitCatchBlock(KotlinParser.CatchBlockContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#finallyBlock}. - * @param ctx the parse tree - */ - void enterFinallyBlock(KotlinParser.FinallyBlockContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#finallyBlock}. - * @param ctx the parse tree - */ - void exitFinallyBlock(KotlinParser.FinallyBlockContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#jumpExpression}. - * @param ctx the parse tree - */ - void enterJumpExpression(KotlinParser.JumpExpressionContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#jumpExpression}. - * @param ctx the parse tree - */ - void exitJumpExpression(KotlinParser.JumpExpressionContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#callableReference}. - * @param ctx the parse tree - */ - void enterCallableReference(KotlinParser.CallableReferenceContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#callableReference}. - * @param ctx the parse tree - */ - void exitCallableReference(KotlinParser.CallableReferenceContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#assignmentAndOperator}. - * @param ctx the parse tree - */ - void enterAssignmentAndOperator(KotlinParser.AssignmentAndOperatorContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#assignmentAndOperator}. - * @param ctx the parse tree - */ - void exitAssignmentAndOperator(KotlinParser.AssignmentAndOperatorContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#equalityOperator}. - * @param ctx the parse tree - */ - void enterEqualityOperator(KotlinParser.EqualityOperatorContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#equalityOperator}. - * @param ctx the parse tree - */ - void exitEqualityOperator(KotlinParser.EqualityOperatorContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#comparisonOperator}. - * @param ctx the parse tree - */ - void enterComparisonOperator(KotlinParser.ComparisonOperatorContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#comparisonOperator}. - * @param ctx the parse tree - */ - void exitComparisonOperator(KotlinParser.ComparisonOperatorContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#inOperator}. - * @param ctx the parse tree - */ - void enterInOperator(KotlinParser.InOperatorContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#inOperator}. - * @param ctx the parse tree - */ - void exitInOperator(KotlinParser.InOperatorContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#isOperator}. - * @param ctx the parse tree - */ - void enterIsOperator(KotlinParser.IsOperatorContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#isOperator}. - * @param ctx the parse tree - */ - void exitIsOperator(KotlinParser.IsOperatorContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#additiveOperator}. - * @param ctx the parse tree - */ - void enterAdditiveOperator(KotlinParser.AdditiveOperatorContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#additiveOperator}. - * @param ctx the parse tree - */ - void exitAdditiveOperator(KotlinParser.AdditiveOperatorContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#multiplicativeOperator}. - * @param ctx the parse tree - */ - void enterMultiplicativeOperator(KotlinParser.MultiplicativeOperatorContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#multiplicativeOperator}. - * @param ctx the parse tree - */ - void exitMultiplicativeOperator(KotlinParser.MultiplicativeOperatorContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#asOperator}. - * @param ctx the parse tree - */ - void enterAsOperator(KotlinParser.AsOperatorContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#asOperator}. - * @param ctx the parse tree - */ - void exitAsOperator(KotlinParser.AsOperatorContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#prefixUnaryOperator}. - * @param ctx the parse tree - */ - void enterPrefixUnaryOperator(KotlinParser.PrefixUnaryOperatorContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#prefixUnaryOperator}. - * @param ctx the parse tree - */ - void exitPrefixUnaryOperator(KotlinParser.PrefixUnaryOperatorContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#postfixUnaryOperator}. - * @param ctx the parse tree - */ - void enterPostfixUnaryOperator(KotlinParser.PostfixUnaryOperatorContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#postfixUnaryOperator}. - * @param ctx the parse tree - */ - void exitPostfixUnaryOperator(KotlinParser.PostfixUnaryOperatorContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#excl}. - * @param ctx the parse tree - */ - void enterExcl(KotlinParser.ExclContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#excl}. - * @param ctx the parse tree - */ - void exitExcl(KotlinParser.ExclContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#memberAccessOperator}. - * @param ctx the parse tree - */ - void enterMemberAccessOperator(KotlinParser.MemberAccessOperatorContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#memberAccessOperator}. - * @param ctx the parse tree - */ - void exitMemberAccessOperator(KotlinParser.MemberAccessOperatorContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#safeNav}. - * @param ctx the parse tree - */ - void enterSafeNav(KotlinParser.SafeNavContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#safeNav}. - * @param ctx the parse tree - */ - void exitSafeNav(KotlinParser.SafeNavContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#modifiers}. - * @param ctx the parse tree - */ - void enterModifiers(KotlinParser.ModifiersContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#modifiers}. - * @param ctx the parse tree - */ - void exitModifiers(KotlinParser.ModifiersContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#parameterModifiers}. - * @param ctx the parse tree - */ - void enterParameterModifiers(KotlinParser.ParameterModifiersContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#parameterModifiers}. - * @param ctx the parse tree - */ - void exitParameterModifiers(KotlinParser.ParameterModifiersContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#modifier}. - * @param ctx the parse tree - */ - void enterModifier(KotlinParser.ModifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#modifier}. - * @param ctx the parse tree - */ - void exitModifier(KotlinParser.ModifierContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#typeModifiers}. - * @param ctx the parse tree - */ - void enterTypeModifiers(KotlinParser.TypeModifiersContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#typeModifiers}. - * @param ctx the parse tree - */ - void exitTypeModifiers(KotlinParser.TypeModifiersContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#typeModifier}. - * @param ctx the parse tree - */ - void enterTypeModifier(KotlinParser.TypeModifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#typeModifier}. - * @param ctx the parse tree - */ - void exitTypeModifier(KotlinParser.TypeModifierContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#classModifier}. - * @param ctx the parse tree - */ - void enterClassModifier(KotlinParser.ClassModifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#classModifier}. - * @param ctx the parse tree - */ - void exitClassModifier(KotlinParser.ClassModifierContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#memberModifier}. - * @param ctx the parse tree - */ - void enterMemberModifier(KotlinParser.MemberModifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#memberModifier}. - * @param ctx the parse tree - */ - void exitMemberModifier(KotlinParser.MemberModifierContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#visibilityModifier}. - * @param ctx the parse tree - */ - void enterVisibilityModifier(KotlinParser.VisibilityModifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#visibilityModifier}. - * @param ctx the parse tree - */ - void exitVisibilityModifier(KotlinParser.VisibilityModifierContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#varianceModifier}. - * @param ctx the parse tree - */ - void enterVarianceModifier(KotlinParser.VarianceModifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#varianceModifier}. - * @param ctx the parse tree - */ - void exitVarianceModifier(KotlinParser.VarianceModifierContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#typeParameterModifiers}. - * @param ctx the parse tree - */ - void enterTypeParameterModifiers(KotlinParser.TypeParameterModifiersContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#typeParameterModifiers}. - * @param ctx the parse tree - */ - void exitTypeParameterModifiers(KotlinParser.TypeParameterModifiersContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#typeParameterModifier}. - * @param ctx the parse tree - */ - void enterTypeParameterModifier(KotlinParser.TypeParameterModifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#typeParameterModifier}. - * @param ctx the parse tree - */ - void exitTypeParameterModifier(KotlinParser.TypeParameterModifierContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#functionModifier}. - * @param ctx the parse tree - */ - void enterFunctionModifier(KotlinParser.FunctionModifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#functionModifier}. - * @param ctx the parse tree - */ - void exitFunctionModifier(KotlinParser.FunctionModifierContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#propertyModifier}. - * @param ctx the parse tree - */ - void enterPropertyModifier(KotlinParser.PropertyModifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#propertyModifier}. - * @param ctx the parse tree - */ - void exitPropertyModifier(KotlinParser.PropertyModifierContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#inheritanceModifier}. - * @param ctx the parse tree - */ - void enterInheritanceModifier(KotlinParser.InheritanceModifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#inheritanceModifier}. - * @param ctx the parse tree - */ - void exitInheritanceModifier(KotlinParser.InheritanceModifierContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#parameterModifier}. - * @param ctx the parse tree - */ - void enterParameterModifier(KotlinParser.ParameterModifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#parameterModifier}. - * @param ctx the parse tree - */ - void exitParameterModifier(KotlinParser.ParameterModifierContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#reificationModifier}. - * @param ctx the parse tree - */ - void enterReificationModifier(KotlinParser.ReificationModifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#reificationModifier}. - * @param ctx the parse tree - */ - void exitReificationModifier(KotlinParser.ReificationModifierContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#platformModifier}. - * @param ctx the parse tree - */ - void enterPlatformModifier(KotlinParser.PlatformModifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#platformModifier}. - * @param ctx the parse tree - */ - void exitPlatformModifier(KotlinParser.PlatformModifierContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#annotation}. - * @param ctx the parse tree - */ - void enterAnnotation(KotlinParser.AnnotationContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#annotation}. - * @param ctx the parse tree - */ - void exitAnnotation(KotlinParser.AnnotationContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#singleAnnotation}. - * @param ctx the parse tree - */ - void enterSingleAnnotation(KotlinParser.SingleAnnotationContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#singleAnnotation}. - * @param ctx the parse tree - */ - void exitSingleAnnotation(KotlinParser.SingleAnnotationContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#multiAnnotation}. - * @param ctx the parse tree - */ - void enterMultiAnnotation(KotlinParser.MultiAnnotationContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#multiAnnotation}. - * @param ctx the parse tree - */ - void exitMultiAnnotation(KotlinParser.MultiAnnotationContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#annotationUseSiteTarget}. - * @param ctx the parse tree - */ - void enterAnnotationUseSiteTarget(KotlinParser.AnnotationUseSiteTargetContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#annotationUseSiteTarget}. - * @param ctx the parse tree - */ - void exitAnnotationUseSiteTarget(KotlinParser.AnnotationUseSiteTargetContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#unescapedAnnotation}. - * @param ctx the parse tree - */ - void enterUnescapedAnnotation(KotlinParser.UnescapedAnnotationContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#unescapedAnnotation}. - * @param ctx the parse tree - */ - void exitUnescapedAnnotation(KotlinParser.UnescapedAnnotationContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#simpleIdentifier}. - * @param ctx the parse tree - */ - void enterSimpleIdentifier(KotlinParser.SimpleIdentifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#simpleIdentifier}. - * @param ctx the parse tree - */ - void exitSimpleIdentifier(KotlinParser.SimpleIdentifierContext ctx); - /** - * Enter a parse tree produced by {@link KotlinParser#identifier}. - * @param ctx the parse tree - */ - void enterIdentifier(KotlinParser.IdentifierContext ctx); - /** - * Exit a parse tree produced by {@link KotlinParser#identifier}. - * @param ctx the parse tree - */ - void exitIdentifier(KotlinParser.IdentifierContext ctx); -} \ No newline at end of file + /** + * Enter a parse tree produced by {@link KotlinParser#kotlinFile}. + * + * @param ctx the parse tree + */ + void enterKotlinFile(KotlinParser.KotlinFileContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#kotlinFile}. + * + * @param ctx the parse tree + */ + void exitKotlinFile(KotlinParser.KotlinFileContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#script}. + * + * @param ctx the parse tree + */ + void enterScript(KotlinParser.ScriptContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#script}. + * + * @param ctx the parse tree + */ + void exitScript(KotlinParser.ScriptContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#shebangLine}. + * + * @param ctx the parse tree + */ + void enterShebangLine(KotlinParser.ShebangLineContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#shebangLine}. + * + * @param ctx the parse tree + */ + void exitShebangLine(KotlinParser.ShebangLineContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#fileAnnotation}. + * + * @param ctx the parse tree + */ + void enterFileAnnotation(KotlinParser.FileAnnotationContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#fileAnnotation}. + * + * @param ctx the parse tree + */ + void exitFileAnnotation(KotlinParser.FileAnnotationContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#packageHeader}. + * + * @param ctx the parse tree + */ + void enterPackageHeader(KotlinParser.PackageHeaderContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#packageHeader}. + * + * @param ctx the parse tree + */ + void exitPackageHeader(KotlinParser.PackageHeaderContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#importList}. + * + * @param ctx the parse tree + */ + void enterImportList(KotlinParser.ImportListContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#importList}. + * + * @param ctx the parse tree + */ + void exitImportList(KotlinParser.ImportListContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#importHeader}. + * + * @param ctx the parse tree + */ + void enterImportHeader(KotlinParser.ImportHeaderContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#importHeader}. + * + * @param ctx the parse tree + */ + void exitImportHeader(KotlinParser.ImportHeaderContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#importAlias}. + * + * @param ctx the parse tree + */ + void enterImportAlias(KotlinParser.ImportAliasContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#importAlias}. + * + * @param ctx the parse tree + */ + void exitImportAlias(KotlinParser.ImportAliasContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#topLevelObject}. + * + * @param ctx the parse tree + */ + void enterTopLevelObject(KotlinParser.TopLevelObjectContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#topLevelObject}. + * + * @param ctx the parse tree + */ + void exitTopLevelObject(KotlinParser.TopLevelObjectContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#typeAlias}. + * + * @param ctx the parse tree + */ + void enterTypeAlias(KotlinParser.TypeAliasContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#typeAlias}. + * + * @param ctx the parse tree + */ + void exitTypeAlias(KotlinParser.TypeAliasContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#declaration}. + * + * @param ctx the parse tree + */ + void enterDeclaration(KotlinParser.DeclarationContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#declaration}. + * + * @param ctx the parse tree + */ + void exitDeclaration(KotlinParser.DeclarationContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#classDeclaration}. + * + * @param ctx the parse tree + */ + void enterClassDeclaration(KotlinParser.ClassDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#classDeclaration}. + * + * @param ctx the parse tree + */ + void exitClassDeclaration(KotlinParser.ClassDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#primaryConstructor}. + * + * @param ctx the parse tree + */ + void enterPrimaryConstructor(KotlinParser.PrimaryConstructorContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#primaryConstructor}. + * + * @param ctx the parse tree + */ + void exitPrimaryConstructor(KotlinParser.PrimaryConstructorContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#classBody}. + * + * @param ctx the parse tree + */ + void enterClassBody(KotlinParser.ClassBodyContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#classBody}. + * + * @param ctx the parse tree + */ + void exitClassBody(KotlinParser.ClassBodyContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#classParameters}. + * + * @param ctx the parse tree + */ + void enterClassParameters(KotlinParser.ClassParametersContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#classParameters}. + * + * @param ctx the parse tree + */ + void exitClassParameters(KotlinParser.ClassParametersContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#classParameter}. + * + * @param ctx the parse tree + */ + void enterClassParameter(KotlinParser.ClassParameterContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#classParameter}. + * + * @param ctx the parse tree + */ + void exitClassParameter(KotlinParser.ClassParameterContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#delegationSpecifiers}. + * + * @param ctx the parse tree + */ + void enterDelegationSpecifiers(KotlinParser.DelegationSpecifiersContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#delegationSpecifiers}. + * + * @param ctx the parse tree + */ + void exitDelegationSpecifiers(KotlinParser.DelegationSpecifiersContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#delegationSpecifier}. + * + * @param ctx the parse tree + */ + void enterDelegationSpecifier(KotlinParser.DelegationSpecifierContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#delegationSpecifier}. + * + * @param ctx the parse tree + */ + void exitDelegationSpecifier(KotlinParser.DelegationSpecifierContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#constructorInvocation}. + * + * @param ctx the parse tree + */ + void enterConstructorInvocation(KotlinParser.ConstructorInvocationContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#constructorInvocation}. + * + * @param ctx the parse tree + */ + void exitConstructorInvocation(KotlinParser.ConstructorInvocationContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#annotatedDelegationSpecifier}. + * + * @param ctx the parse tree + */ + void enterAnnotatedDelegationSpecifier(KotlinParser.AnnotatedDelegationSpecifierContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#annotatedDelegationSpecifier}. + * + * @param ctx the parse tree + */ + void exitAnnotatedDelegationSpecifier(KotlinParser.AnnotatedDelegationSpecifierContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#explicitDelegation}. + * + * @param ctx the parse tree + */ + void enterExplicitDelegation(KotlinParser.ExplicitDelegationContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#explicitDelegation}. + * + * @param ctx the parse tree + */ + void exitExplicitDelegation(KotlinParser.ExplicitDelegationContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#typeParameters}. + * + * @param ctx the parse tree + */ + void enterTypeParameters(KotlinParser.TypeParametersContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#typeParameters}. + * + * @param ctx the parse tree + */ + void exitTypeParameters(KotlinParser.TypeParametersContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#typeParameter}. + * + * @param ctx the parse tree + */ + void enterTypeParameter(KotlinParser.TypeParameterContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#typeParameter}. + * + * @param ctx the parse tree + */ + void exitTypeParameter(KotlinParser.TypeParameterContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#typeConstraints}. + * + * @param ctx the parse tree + */ + void enterTypeConstraints(KotlinParser.TypeConstraintsContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#typeConstraints}. + * + * @param ctx the parse tree + */ + void exitTypeConstraints(KotlinParser.TypeConstraintsContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#typeConstraint}. + * + * @param ctx the parse tree + */ + void enterTypeConstraint(KotlinParser.TypeConstraintContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#typeConstraint}. + * + * @param ctx the parse tree + */ + void exitTypeConstraint(KotlinParser.TypeConstraintContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#classMemberDeclarations}. + * + * @param ctx the parse tree + */ + void enterClassMemberDeclarations(KotlinParser.ClassMemberDeclarationsContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#classMemberDeclarations}. + * + * @param ctx the parse tree + */ + void exitClassMemberDeclarations(KotlinParser.ClassMemberDeclarationsContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#classMemberDeclaration}. + * + * @param ctx the parse tree + */ + void enterClassMemberDeclaration(KotlinParser.ClassMemberDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#classMemberDeclaration}. + * + * @param ctx the parse tree + */ + void exitClassMemberDeclaration(KotlinParser.ClassMemberDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#anonymousInitializer}. + * + * @param ctx the parse tree + */ + void enterAnonymousInitializer(KotlinParser.AnonymousInitializerContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#anonymousInitializer}. + * + * @param ctx the parse tree + */ + void exitAnonymousInitializer(KotlinParser.AnonymousInitializerContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#companionObject}. + * + * @param ctx the parse tree + */ + void enterCompanionObject(KotlinParser.CompanionObjectContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#companionObject}. + * + * @param ctx the parse tree + */ + void exitCompanionObject(KotlinParser.CompanionObjectContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#functionValueParameters}. + * + * @param ctx the parse tree + */ + void enterFunctionValueParameters(KotlinParser.FunctionValueParametersContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#functionValueParameters}. + * + * @param ctx the parse tree + */ + void exitFunctionValueParameters(KotlinParser.FunctionValueParametersContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#functionValueParameter}. + * + * @param ctx the parse tree + */ + void enterFunctionValueParameter(KotlinParser.FunctionValueParameterContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#functionValueParameter}. + * + * @param ctx the parse tree + */ + void exitFunctionValueParameter(KotlinParser.FunctionValueParameterContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#functionDeclaration}. + * + * @param ctx the parse tree + */ + void enterFunctionDeclaration(KotlinParser.FunctionDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#functionDeclaration}. + * + * @param ctx the parse tree + */ + void exitFunctionDeclaration(KotlinParser.FunctionDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#functionBody}. + * + * @param ctx the parse tree + */ + void enterFunctionBody(KotlinParser.FunctionBodyContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#functionBody}. + * + * @param ctx the parse tree + */ + void exitFunctionBody(KotlinParser.FunctionBodyContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#variableDeclaration}. + * + * @param ctx the parse tree + */ + void enterVariableDeclaration(KotlinParser.VariableDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#variableDeclaration}. + * + * @param ctx the parse tree + */ + void exitVariableDeclaration(KotlinParser.VariableDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#multiVariableDeclaration}. + * + * @param ctx the parse tree + */ + void enterMultiVariableDeclaration(KotlinParser.MultiVariableDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#multiVariableDeclaration}. + * + * @param ctx the parse tree + */ + void exitMultiVariableDeclaration(KotlinParser.MultiVariableDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#propertyDeclaration}. + * + * @param ctx the parse tree + */ + void enterPropertyDeclaration(KotlinParser.PropertyDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#propertyDeclaration}. + * + * @param ctx the parse tree + */ + void exitPropertyDeclaration(KotlinParser.PropertyDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#propertyDelegate}. + * + * @param ctx the parse tree + */ + void enterPropertyDelegate(KotlinParser.PropertyDelegateContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#propertyDelegate}. + * + * @param ctx the parse tree + */ + void exitPropertyDelegate(KotlinParser.PropertyDelegateContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#getter}. + * + * @param ctx the parse tree + */ + void enterGetter(KotlinParser.GetterContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#getter}. + * + * @param ctx the parse tree + */ + void exitGetter(KotlinParser.GetterContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#setter}. + * + * @param ctx the parse tree + */ + void enterSetter(KotlinParser.SetterContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#setter}. + * + * @param ctx the parse tree + */ + void exitSetter(KotlinParser.SetterContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#parametersWithOptionalType}. + * + * @param ctx the parse tree + */ + void enterParametersWithOptionalType(KotlinParser.ParametersWithOptionalTypeContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#parametersWithOptionalType}. + * + * @param ctx the parse tree + */ + void exitParametersWithOptionalType(KotlinParser.ParametersWithOptionalTypeContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#functionValueParameterWithOptionalType}. + * + * @param ctx the parse tree + */ + void enterFunctionValueParameterWithOptionalType( + KotlinParser.FunctionValueParameterWithOptionalTypeContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#functionValueParameterWithOptionalType}. + * + * @param ctx the parse tree + */ + void exitFunctionValueParameterWithOptionalType( + KotlinParser.FunctionValueParameterWithOptionalTypeContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#parameterWithOptionalType}. + * + * @param ctx the parse tree + */ + void enterParameterWithOptionalType(KotlinParser.ParameterWithOptionalTypeContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#parameterWithOptionalType}. + * + * @param ctx the parse tree + */ + void exitParameterWithOptionalType(KotlinParser.ParameterWithOptionalTypeContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#parameter}. + * + * @param ctx the parse tree + */ + void enterParameter(KotlinParser.ParameterContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#parameter}. + * + * @param ctx the parse tree + */ + void exitParameter(KotlinParser.ParameterContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#objectDeclaration}. + * + * @param ctx the parse tree + */ + void enterObjectDeclaration(KotlinParser.ObjectDeclarationContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#objectDeclaration}. + * + * @param ctx the parse tree + */ + void exitObjectDeclaration(KotlinParser.ObjectDeclarationContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#secondaryConstructor}. + * + * @param ctx the parse tree + */ + void enterSecondaryConstructor(KotlinParser.SecondaryConstructorContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#secondaryConstructor}. + * + * @param ctx the parse tree + */ + void exitSecondaryConstructor(KotlinParser.SecondaryConstructorContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#constructorDelegationCall}. + * + * @param ctx the parse tree + */ + void enterConstructorDelegationCall(KotlinParser.ConstructorDelegationCallContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#constructorDelegationCall}. + * + * @param ctx the parse tree + */ + void exitConstructorDelegationCall(KotlinParser.ConstructorDelegationCallContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#enumClassBody}. + * + * @param ctx the parse tree + */ + void enterEnumClassBody(KotlinParser.EnumClassBodyContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#enumClassBody}. + * + * @param ctx the parse tree + */ + void exitEnumClassBody(KotlinParser.EnumClassBodyContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#enumEntries}. + * + * @param ctx the parse tree + */ + void enterEnumEntries(KotlinParser.EnumEntriesContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#enumEntries}. + * + * @param ctx the parse tree + */ + void exitEnumEntries(KotlinParser.EnumEntriesContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#enumEntry}. + * + * @param ctx the parse tree + */ + void enterEnumEntry(KotlinParser.EnumEntryContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#enumEntry}. + * + * @param ctx the parse tree + */ + void exitEnumEntry(KotlinParser.EnumEntryContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#type}. + * + * @param ctx the parse tree + */ + void enterType(KotlinParser.TypeContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#type}. + * + * @param ctx the parse tree + */ + void exitType(KotlinParser.TypeContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#typeReference}. + * + * @param ctx the parse tree + */ + void enterTypeReference(KotlinParser.TypeReferenceContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#typeReference}. + * + * @param ctx the parse tree + */ + void exitTypeReference(KotlinParser.TypeReferenceContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#nullableType}. + * + * @param ctx the parse tree + */ + void enterNullableType(KotlinParser.NullableTypeContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#nullableType}. + * + * @param ctx the parse tree + */ + void exitNullableType(KotlinParser.NullableTypeContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#quest}. + * + * @param ctx the parse tree + */ + void enterQuest(KotlinParser.QuestContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#quest}. + * + * @param ctx the parse tree + */ + void exitQuest(KotlinParser.QuestContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#userType}. + * + * @param ctx the parse tree + */ + void enterUserType(KotlinParser.UserTypeContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#userType}. + * + * @param ctx the parse tree + */ + void exitUserType(KotlinParser.UserTypeContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#simpleUserType}. + * + * @param ctx the parse tree + */ + void enterSimpleUserType(KotlinParser.SimpleUserTypeContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#simpleUserType}. + * + * @param ctx the parse tree + */ + void exitSimpleUserType(KotlinParser.SimpleUserTypeContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#typeProjection}. + * + * @param ctx the parse tree + */ + void enterTypeProjection(KotlinParser.TypeProjectionContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#typeProjection}. + * + * @param ctx the parse tree + */ + void exitTypeProjection(KotlinParser.TypeProjectionContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#typeProjectionModifiers}. + * + * @param ctx the parse tree + */ + void enterTypeProjectionModifiers(KotlinParser.TypeProjectionModifiersContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#typeProjectionModifiers}. + * + * @param ctx the parse tree + */ + void exitTypeProjectionModifiers(KotlinParser.TypeProjectionModifiersContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#typeProjectionModifier}. + * + * @param ctx the parse tree + */ + void enterTypeProjectionModifier(KotlinParser.TypeProjectionModifierContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#typeProjectionModifier}. + * + * @param ctx the parse tree + */ + void exitTypeProjectionModifier(KotlinParser.TypeProjectionModifierContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#functionType}. + * + * @param ctx the parse tree + */ + void enterFunctionType(KotlinParser.FunctionTypeContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#functionType}. + * + * @param ctx the parse tree + */ + void exitFunctionType(KotlinParser.FunctionTypeContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#functionTypeParameters}. + * + * @param ctx the parse tree + */ + void enterFunctionTypeParameters(KotlinParser.FunctionTypeParametersContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#functionTypeParameters}. + * + * @param ctx the parse tree + */ + void exitFunctionTypeParameters(KotlinParser.FunctionTypeParametersContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#parenthesizedType}. + * + * @param ctx the parse tree + */ + void enterParenthesizedType(KotlinParser.ParenthesizedTypeContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#parenthesizedType}. + * + * @param ctx the parse tree + */ + void exitParenthesizedType(KotlinParser.ParenthesizedTypeContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#receiverType}. + * + * @param ctx the parse tree + */ + void enterReceiverType(KotlinParser.ReceiverTypeContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#receiverType}. + * + * @param ctx the parse tree + */ + void exitReceiverType(KotlinParser.ReceiverTypeContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#parenthesizedUserType}. + * + * @param ctx the parse tree + */ + void enterParenthesizedUserType(KotlinParser.ParenthesizedUserTypeContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#parenthesizedUserType}. + * + * @param ctx the parse tree + */ + void exitParenthesizedUserType(KotlinParser.ParenthesizedUserTypeContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#statements}. + * + * @param ctx the parse tree + */ + void enterStatements(KotlinParser.StatementsContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#statements}. + * + * @param ctx the parse tree + */ + void exitStatements(KotlinParser.StatementsContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#statement}. + * + * @param ctx the parse tree + */ + void enterStatement(KotlinParser.StatementContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#statement}. + * + * @param ctx the parse tree + */ + void exitStatement(KotlinParser.StatementContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#label}. + * + * @param ctx the parse tree + */ + void enterLabel(KotlinParser.LabelContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#label}. + * + * @param ctx the parse tree + */ + void exitLabel(KotlinParser.LabelContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#controlStructureBody}. + * + * @param ctx the parse tree + */ + void enterControlStructureBody(KotlinParser.ControlStructureBodyContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#controlStructureBody}. + * + * @param ctx the parse tree + */ + void exitControlStructureBody(KotlinParser.ControlStructureBodyContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#block}. + * + * @param ctx the parse tree + */ + void enterBlock(KotlinParser.BlockContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#block}. + * + * @param ctx the parse tree + */ + void exitBlock(KotlinParser.BlockContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#loopStatement}. + * + * @param ctx the parse tree + */ + void enterLoopStatement(KotlinParser.LoopStatementContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#loopStatement}. + * + * @param ctx the parse tree + */ + void exitLoopStatement(KotlinParser.LoopStatementContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#forStatement}. + * + * @param ctx the parse tree + */ + void enterForStatement(KotlinParser.ForStatementContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#forStatement}. + * + * @param ctx the parse tree + */ + void exitForStatement(KotlinParser.ForStatementContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#whileStatement}. + * + * @param ctx the parse tree + */ + void enterWhileStatement(KotlinParser.WhileStatementContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#whileStatement}. + * + * @param ctx the parse tree + */ + void exitWhileStatement(KotlinParser.WhileStatementContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#doWhileStatement}. + * + * @param ctx the parse tree + */ + void enterDoWhileStatement(KotlinParser.DoWhileStatementContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#doWhileStatement}. + * + * @param ctx the parse tree + */ + void exitDoWhileStatement(KotlinParser.DoWhileStatementContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#assignment}. + * + * @param ctx the parse tree + */ + void enterAssignment(KotlinParser.AssignmentContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#assignment}. + * + * @param ctx the parse tree + */ + void exitAssignment(KotlinParser.AssignmentContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#semi}. + * + * @param ctx the parse tree + */ + void enterSemi(KotlinParser.SemiContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#semi}. + * + * @param ctx the parse tree + */ + void exitSemi(KotlinParser.SemiContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#semis}. + * + * @param ctx the parse tree + */ + void enterSemis(KotlinParser.SemisContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#semis}. + * + * @param ctx the parse tree + */ + void exitSemis(KotlinParser.SemisContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#expression}. + * + * @param ctx the parse tree + */ + void enterExpression(KotlinParser.ExpressionContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#expression}. + * + * @param ctx the parse tree + */ + void exitExpression(KotlinParser.ExpressionContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#disjunction}. + * + * @param ctx the parse tree + */ + void enterDisjunction(KotlinParser.DisjunctionContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#disjunction}. + * + * @param ctx the parse tree + */ + void exitDisjunction(KotlinParser.DisjunctionContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#conjunction}. + * + * @param ctx the parse tree + */ + void enterConjunction(KotlinParser.ConjunctionContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#conjunction}. + * + * @param ctx the parse tree + */ + void exitConjunction(KotlinParser.ConjunctionContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#equality}. + * + * @param ctx the parse tree + */ + void enterEquality(KotlinParser.EqualityContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#equality}. + * + * @param ctx the parse tree + */ + void exitEquality(KotlinParser.EqualityContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#comparison}. + * + * @param ctx the parse tree + */ + void enterComparison(KotlinParser.ComparisonContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#comparison}. + * + * @param ctx the parse tree + */ + void exitComparison(KotlinParser.ComparisonContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#genericCallLikeComparison}. + * + * @param ctx the parse tree + */ + void enterGenericCallLikeComparison(KotlinParser.GenericCallLikeComparisonContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#genericCallLikeComparison}. + * + * @param ctx the parse tree + */ + void exitGenericCallLikeComparison(KotlinParser.GenericCallLikeComparisonContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#infixOperation}. + * + * @param ctx the parse tree + */ + void enterInfixOperation(KotlinParser.InfixOperationContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#infixOperation}. + * + * @param ctx the parse tree + */ + void exitInfixOperation(KotlinParser.InfixOperationContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#elvisExpression}. + * + * @param ctx the parse tree + */ + void enterElvisExpression(KotlinParser.ElvisExpressionContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#elvisExpression}. + * + * @param ctx the parse tree + */ + void exitElvisExpression(KotlinParser.ElvisExpressionContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#elvis}. + * + * @param ctx the parse tree + */ + void enterElvis(KotlinParser.ElvisContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#elvis}. + * + * @param ctx the parse tree + */ + void exitElvis(KotlinParser.ElvisContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#infixFunctionCall}. + * + * @param ctx the parse tree + */ + void enterInfixFunctionCall(KotlinParser.InfixFunctionCallContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#infixFunctionCall}. + * + * @param ctx the parse tree + */ + void exitInfixFunctionCall(KotlinParser.InfixFunctionCallContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#rangeExpression}. + * + * @param ctx the parse tree + */ + void enterRangeExpression(KotlinParser.RangeExpressionContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#rangeExpression}. + * + * @param ctx the parse tree + */ + void exitRangeExpression(KotlinParser.RangeExpressionContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#additiveExpression}. + * + * @param ctx the parse tree + */ + void enterAdditiveExpression(KotlinParser.AdditiveExpressionContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#additiveExpression}. + * + * @param ctx the parse tree + */ + void exitAdditiveExpression(KotlinParser.AdditiveExpressionContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#multiplicativeExpression}. + * + * @param ctx the parse tree + */ + void enterMultiplicativeExpression(KotlinParser.MultiplicativeExpressionContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#multiplicativeExpression}. + * + * @param ctx the parse tree + */ + void exitMultiplicativeExpression(KotlinParser.MultiplicativeExpressionContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#asExpression}. + * + * @param ctx the parse tree + */ + void enterAsExpression(KotlinParser.AsExpressionContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#asExpression}. + * + * @param ctx the parse tree + */ + void exitAsExpression(KotlinParser.AsExpressionContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#prefixUnaryExpression}. + * + * @param ctx the parse tree + */ + void enterPrefixUnaryExpression(KotlinParser.PrefixUnaryExpressionContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#prefixUnaryExpression}. + * + * @param ctx the parse tree + */ + void exitPrefixUnaryExpression(KotlinParser.PrefixUnaryExpressionContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#unaryPrefix}. + * + * @param ctx the parse tree + */ + void enterUnaryPrefix(KotlinParser.UnaryPrefixContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#unaryPrefix}. + * + * @param ctx the parse tree + */ + void exitUnaryPrefix(KotlinParser.UnaryPrefixContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#postfixUnaryExpression}. + * + * @param ctx the parse tree + */ + void enterPostfixUnaryExpression(KotlinParser.PostfixUnaryExpressionContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#postfixUnaryExpression}. + * + * @param ctx the parse tree + */ + void exitPostfixUnaryExpression(KotlinParser.PostfixUnaryExpressionContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#postfixUnarySuffix}. + * + * @param ctx the parse tree + */ + void enterPostfixUnarySuffix(KotlinParser.PostfixUnarySuffixContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#postfixUnarySuffix}. + * + * @param ctx the parse tree + */ + void exitPostfixUnarySuffix(KotlinParser.PostfixUnarySuffixContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#directlyAssignableExpression}. + * + * @param ctx the parse tree + */ + void enterDirectlyAssignableExpression(KotlinParser.DirectlyAssignableExpressionContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#directlyAssignableExpression}. + * + * @param ctx the parse tree + */ + void exitDirectlyAssignableExpression(KotlinParser.DirectlyAssignableExpressionContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#parenthesizedDirectlyAssignableExpression}. + * + * @param ctx the parse tree + */ + void enterParenthesizedDirectlyAssignableExpression( + KotlinParser.ParenthesizedDirectlyAssignableExpressionContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#parenthesizedDirectlyAssignableExpression}. + * + * @param ctx the parse tree + */ + void exitParenthesizedDirectlyAssignableExpression( + KotlinParser.ParenthesizedDirectlyAssignableExpressionContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#assignableExpression}. + * + * @param ctx the parse tree + */ + void enterAssignableExpression(KotlinParser.AssignableExpressionContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#assignableExpression}. + * + * @param ctx the parse tree + */ + void exitAssignableExpression(KotlinParser.AssignableExpressionContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#parenthesizedAssignableExpression}. + * + * @param ctx the parse tree + */ + void enterParenthesizedAssignableExpression( + KotlinParser.ParenthesizedAssignableExpressionContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#parenthesizedAssignableExpression}. + * + * @param ctx the parse tree + */ + void exitParenthesizedAssignableExpression( + KotlinParser.ParenthesizedAssignableExpressionContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#assignableSuffix}. + * + * @param ctx the parse tree + */ + void enterAssignableSuffix(KotlinParser.AssignableSuffixContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#assignableSuffix}. + * + * @param ctx the parse tree + */ + void exitAssignableSuffix(KotlinParser.AssignableSuffixContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#indexingSuffix}. + * + * @param ctx the parse tree + */ + void enterIndexingSuffix(KotlinParser.IndexingSuffixContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#indexingSuffix}. + * + * @param ctx the parse tree + */ + void exitIndexingSuffix(KotlinParser.IndexingSuffixContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#navigationSuffix}. + * + * @param ctx the parse tree + */ + void enterNavigationSuffix(KotlinParser.NavigationSuffixContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#navigationSuffix}. + * + * @param ctx the parse tree + */ + void exitNavigationSuffix(KotlinParser.NavigationSuffixContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#callSuffix}. + * + * @param ctx the parse tree + */ + void enterCallSuffix(KotlinParser.CallSuffixContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#callSuffix}. + * + * @param ctx the parse tree + */ + void exitCallSuffix(KotlinParser.CallSuffixContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#annotatedLambda}. + * + * @param ctx the parse tree + */ + void enterAnnotatedLambda(KotlinParser.AnnotatedLambdaContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#annotatedLambda}. + * + * @param ctx the parse tree + */ + void exitAnnotatedLambda(KotlinParser.AnnotatedLambdaContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#typeArguments}. + * + * @param ctx the parse tree + */ + void enterTypeArguments(KotlinParser.TypeArgumentsContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#typeArguments}. + * + * @param ctx the parse tree + */ + void exitTypeArguments(KotlinParser.TypeArgumentsContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#valueArguments}. + * + * @param ctx the parse tree + */ + void enterValueArguments(KotlinParser.ValueArgumentsContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#valueArguments}. + * + * @param ctx the parse tree + */ + void exitValueArguments(KotlinParser.ValueArgumentsContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#valueArgument}. + * + * @param ctx the parse tree + */ + void enterValueArgument(KotlinParser.ValueArgumentContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#valueArgument}. + * + * @param ctx the parse tree + */ + void exitValueArgument(KotlinParser.ValueArgumentContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#primaryExpression}. + * + * @param ctx the parse tree + */ + void enterPrimaryExpression(KotlinParser.PrimaryExpressionContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#primaryExpression}. + * + * @param ctx the parse tree + */ + void exitPrimaryExpression(KotlinParser.PrimaryExpressionContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#parenthesizedExpression}. + * + * @param ctx the parse tree + */ + void enterParenthesizedExpression(KotlinParser.ParenthesizedExpressionContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#parenthesizedExpression}. + * + * @param ctx the parse tree + */ + void exitParenthesizedExpression(KotlinParser.ParenthesizedExpressionContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#collectionLiteral}. + * + * @param ctx the parse tree + */ + void enterCollectionLiteral(KotlinParser.CollectionLiteralContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#collectionLiteral}. + * + * @param ctx the parse tree + */ + void exitCollectionLiteral(KotlinParser.CollectionLiteralContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#literalConstant}. + * + * @param ctx the parse tree + */ + void enterLiteralConstant(KotlinParser.LiteralConstantContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#literalConstant}. + * + * @param ctx the parse tree + */ + void exitLiteralConstant(KotlinParser.LiteralConstantContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#stringLiteral}. + * + * @param ctx the parse tree + */ + void enterStringLiteral(KotlinParser.StringLiteralContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#stringLiteral}. + * + * @param ctx the parse tree + */ + void exitStringLiteral(KotlinParser.StringLiteralContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#lineStringLiteral}. + * + * @param ctx the parse tree + */ + void enterLineStringLiteral(KotlinParser.LineStringLiteralContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#lineStringLiteral}. + * + * @param ctx the parse tree + */ + void exitLineStringLiteral(KotlinParser.LineStringLiteralContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#multiLineStringLiteral}. + * + * @param ctx the parse tree + */ + void enterMultiLineStringLiteral(KotlinParser.MultiLineStringLiteralContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#multiLineStringLiteral}. + * + * @param ctx the parse tree + */ + void exitMultiLineStringLiteral(KotlinParser.MultiLineStringLiteralContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#lineStringContent}. + * + * @param ctx the parse tree + */ + void enterLineStringContent(KotlinParser.LineStringContentContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#lineStringContent}. + * + * @param ctx the parse tree + */ + void exitLineStringContent(KotlinParser.LineStringContentContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#lineStringExpression}. + * + * @param ctx the parse tree + */ + void enterLineStringExpression(KotlinParser.LineStringExpressionContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#lineStringExpression}. + * + * @param ctx the parse tree + */ + void exitLineStringExpression(KotlinParser.LineStringExpressionContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#multiLineStringContent}. + * + * @param ctx the parse tree + */ + void enterMultiLineStringContent(KotlinParser.MultiLineStringContentContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#multiLineStringContent}. + * + * @param ctx the parse tree + */ + void exitMultiLineStringContent(KotlinParser.MultiLineStringContentContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#multiLineStringExpression}. + * + * @param ctx the parse tree + */ + void enterMultiLineStringExpression(KotlinParser.MultiLineStringExpressionContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#multiLineStringExpression}. + * + * @param ctx the parse tree + */ + void exitMultiLineStringExpression(KotlinParser.MultiLineStringExpressionContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#lambdaLiteral}. + * + * @param ctx the parse tree + */ + void enterLambdaLiteral(KotlinParser.LambdaLiteralContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#lambdaLiteral}. + * + * @param ctx the parse tree + */ + void exitLambdaLiteral(KotlinParser.LambdaLiteralContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#lambdaParameters}. + * + * @param ctx the parse tree + */ + void enterLambdaParameters(KotlinParser.LambdaParametersContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#lambdaParameters}. + * + * @param ctx the parse tree + */ + void exitLambdaParameters(KotlinParser.LambdaParametersContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#lambdaParameter}. + * + * @param ctx the parse tree + */ + void enterLambdaParameter(KotlinParser.LambdaParameterContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#lambdaParameter}. + * + * @param ctx the parse tree + */ + void exitLambdaParameter(KotlinParser.LambdaParameterContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#anonymousFunction}. + * + * @param ctx the parse tree + */ + void enterAnonymousFunction(KotlinParser.AnonymousFunctionContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#anonymousFunction}. + * + * @param ctx the parse tree + */ + void exitAnonymousFunction(KotlinParser.AnonymousFunctionContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#functionLiteral}. + * + * @param ctx the parse tree + */ + void enterFunctionLiteral(KotlinParser.FunctionLiteralContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#functionLiteral}. + * + * @param ctx the parse tree + */ + void exitFunctionLiteral(KotlinParser.FunctionLiteralContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#objectLiteral}. + * + * @param ctx the parse tree + */ + void enterObjectLiteral(KotlinParser.ObjectLiteralContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#objectLiteral}. + * + * @param ctx the parse tree + */ + void exitObjectLiteral(KotlinParser.ObjectLiteralContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#thisExpression}. + * + * @param ctx the parse tree + */ + void enterThisExpression(KotlinParser.ThisExpressionContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#thisExpression}. + * + * @param ctx the parse tree + */ + void exitThisExpression(KotlinParser.ThisExpressionContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#superExpression}. + * + * @param ctx the parse tree + */ + void enterSuperExpression(KotlinParser.SuperExpressionContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#superExpression}. + * + * @param ctx the parse tree + */ + void exitSuperExpression(KotlinParser.SuperExpressionContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#ifExpression}. + * + * @param ctx the parse tree + */ + void enterIfExpression(KotlinParser.IfExpressionContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#ifExpression}. + * + * @param ctx the parse tree + */ + void exitIfExpression(KotlinParser.IfExpressionContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#whenSubject}. + * + * @param ctx the parse tree + */ + void enterWhenSubject(KotlinParser.WhenSubjectContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#whenSubject}. + * + * @param ctx the parse tree + */ + void exitWhenSubject(KotlinParser.WhenSubjectContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#whenExpression}. + * + * @param ctx the parse tree + */ + void enterWhenExpression(KotlinParser.WhenExpressionContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#whenExpression}. + * + * @param ctx the parse tree + */ + void exitWhenExpression(KotlinParser.WhenExpressionContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#whenEntry}. + * + * @param ctx the parse tree + */ + void enterWhenEntry(KotlinParser.WhenEntryContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#whenEntry}. + * + * @param ctx the parse tree + */ + void exitWhenEntry(KotlinParser.WhenEntryContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#whenCondition}. + * + * @param ctx the parse tree + */ + void enterWhenCondition(KotlinParser.WhenConditionContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#whenCondition}. + * + * @param ctx the parse tree + */ + void exitWhenCondition(KotlinParser.WhenConditionContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#rangeTest}. + * + * @param ctx the parse tree + */ + void enterRangeTest(KotlinParser.RangeTestContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#rangeTest}. + * + * @param ctx the parse tree + */ + void exitRangeTest(KotlinParser.RangeTestContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#typeTest}. + * + * @param ctx the parse tree + */ + void enterTypeTest(KotlinParser.TypeTestContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#typeTest}. + * + * @param ctx the parse tree + */ + void exitTypeTest(KotlinParser.TypeTestContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#tryExpression}. + * + * @param ctx the parse tree + */ + void enterTryExpression(KotlinParser.TryExpressionContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#tryExpression}. + * + * @param ctx the parse tree + */ + void exitTryExpression(KotlinParser.TryExpressionContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#catchBlock}. + * + * @param ctx the parse tree + */ + void enterCatchBlock(KotlinParser.CatchBlockContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#catchBlock}. + * + * @param ctx the parse tree + */ + void exitCatchBlock(KotlinParser.CatchBlockContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#finallyBlock}. + * + * @param ctx the parse tree + */ + void enterFinallyBlock(KotlinParser.FinallyBlockContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#finallyBlock}. + * + * @param ctx the parse tree + */ + void exitFinallyBlock(KotlinParser.FinallyBlockContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#jumpExpression}. + * + * @param ctx the parse tree + */ + void enterJumpExpression(KotlinParser.JumpExpressionContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#jumpExpression}. + * + * @param ctx the parse tree + */ + void exitJumpExpression(KotlinParser.JumpExpressionContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#callableReference}. + * + * @param ctx the parse tree + */ + void enterCallableReference(KotlinParser.CallableReferenceContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#callableReference}. + * + * @param ctx the parse tree + */ + void exitCallableReference(KotlinParser.CallableReferenceContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#assignmentAndOperator}. + * + * @param ctx the parse tree + */ + void enterAssignmentAndOperator(KotlinParser.AssignmentAndOperatorContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#assignmentAndOperator}. + * + * @param ctx the parse tree + */ + void exitAssignmentAndOperator(KotlinParser.AssignmentAndOperatorContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#equalityOperator}. + * + * @param ctx the parse tree + */ + void enterEqualityOperator(KotlinParser.EqualityOperatorContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#equalityOperator}. + * + * @param ctx the parse tree + */ + void exitEqualityOperator(KotlinParser.EqualityOperatorContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#comparisonOperator}. + * + * @param ctx the parse tree + */ + void enterComparisonOperator(KotlinParser.ComparisonOperatorContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#comparisonOperator}. + * + * @param ctx the parse tree + */ + void exitComparisonOperator(KotlinParser.ComparisonOperatorContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#inOperator}. + * + * @param ctx the parse tree + */ + void enterInOperator(KotlinParser.InOperatorContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#inOperator}. + * + * @param ctx the parse tree + */ + void exitInOperator(KotlinParser.InOperatorContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#isOperator}. + * + * @param ctx the parse tree + */ + void enterIsOperator(KotlinParser.IsOperatorContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#isOperator}. + * + * @param ctx the parse tree + */ + void exitIsOperator(KotlinParser.IsOperatorContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#additiveOperator}. + * + * @param ctx the parse tree + */ + void enterAdditiveOperator(KotlinParser.AdditiveOperatorContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#additiveOperator}. + * + * @param ctx the parse tree + */ + void exitAdditiveOperator(KotlinParser.AdditiveOperatorContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#multiplicativeOperator}. + * + * @param ctx the parse tree + */ + void enterMultiplicativeOperator(KotlinParser.MultiplicativeOperatorContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#multiplicativeOperator}. + * + * @param ctx the parse tree + */ + void exitMultiplicativeOperator(KotlinParser.MultiplicativeOperatorContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#asOperator}. + * + * @param ctx the parse tree + */ + void enterAsOperator(KotlinParser.AsOperatorContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#asOperator}. + * + * @param ctx the parse tree + */ + void exitAsOperator(KotlinParser.AsOperatorContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#prefixUnaryOperator}. + * + * @param ctx the parse tree + */ + void enterPrefixUnaryOperator(KotlinParser.PrefixUnaryOperatorContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#prefixUnaryOperator}. + * + * @param ctx the parse tree + */ + void exitPrefixUnaryOperator(KotlinParser.PrefixUnaryOperatorContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#postfixUnaryOperator}. + * + * @param ctx the parse tree + */ + void enterPostfixUnaryOperator(KotlinParser.PostfixUnaryOperatorContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#postfixUnaryOperator}. + * + * @param ctx the parse tree + */ + void exitPostfixUnaryOperator(KotlinParser.PostfixUnaryOperatorContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#excl}. + * + * @param ctx the parse tree + */ + void enterExcl(KotlinParser.ExclContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#excl}. + * + * @param ctx the parse tree + */ + void exitExcl(KotlinParser.ExclContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#memberAccessOperator}. + * + * @param ctx the parse tree + */ + void enterMemberAccessOperator(KotlinParser.MemberAccessOperatorContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#memberAccessOperator}. + * + * @param ctx the parse tree + */ + void exitMemberAccessOperator(KotlinParser.MemberAccessOperatorContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#safeNav}. + * + * @param ctx the parse tree + */ + void enterSafeNav(KotlinParser.SafeNavContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#safeNav}. + * + * @param ctx the parse tree + */ + void exitSafeNav(KotlinParser.SafeNavContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#modifiers}. + * + * @param ctx the parse tree + */ + void enterModifiers(KotlinParser.ModifiersContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#modifiers}. + * + * @param ctx the parse tree + */ + void exitModifiers(KotlinParser.ModifiersContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#parameterModifiers}. + * + * @param ctx the parse tree + */ + void enterParameterModifiers(KotlinParser.ParameterModifiersContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#parameterModifiers}. + * + * @param ctx the parse tree + */ + void exitParameterModifiers(KotlinParser.ParameterModifiersContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#modifier}. + * + * @param ctx the parse tree + */ + void enterModifier(KotlinParser.ModifierContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#modifier}. + * + * @param ctx the parse tree + */ + void exitModifier(KotlinParser.ModifierContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#typeModifiers}. + * + * @param ctx the parse tree + */ + void enterTypeModifiers(KotlinParser.TypeModifiersContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#typeModifiers}. + * + * @param ctx the parse tree + */ + void exitTypeModifiers(KotlinParser.TypeModifiersContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#typeModifier}. + * + * @param ctx the parse tree + */ + void enterTypeModifier(KotlinParser.TypeModifierContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#typeModifier}. + * + * @param ctx the parse tree + */ + void exitTypeModifier(KotlinParser.TypeModifierContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#classModifier}. + * + * @param ctx the parse tree + */ + void enterClassModifier(KotlinParser.ClassModifierContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#classModifier}. + * + * @param ctx the parse tree + */ + void exitClassModifier(KotlinParser.ClassModifierContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#memberModifier}. + * + * @param ctx the parse tree + */ + void enterMemberModifier(KotlinParser.MemberModifierContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#memberModifier}. + * + * @param ctx the parse tree + */ + void exitMemberModifier(KotlinParser.MemberModifierContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#visibilityModifier}. + * + * @param ctx the parse tree + */ + void enterVisibilityModifier(KotlinParser.VisibilityModifierContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#visibilityModifier}. + * + * @param ctx the parse tree + */ + void exitVisibilityModifier(KotlinParser.VisibilityModifierContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#varianceModifier}. + * + * @param ctx the parse tree + */ + void enterVarianceModifier(KotlinParser.VarianceModifierContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#varianceModifier}. + * + * @param ctx the parse tree + */ + void exitVarianceModifier(KotlinParser.VarianceModifierContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#typeParameterModifiers}. + * + * @param ctx the parse tree + */ + void enterTypeParameterModifiers(KotlinParser.TypeParameterModifiersContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#typeParameterModifiers}. + * + * @param ctx the parse tree + */ + void exitTypeParameterModifiers(KotlinParser.TypeParameterModifiersContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#typeParameterModifier}. + * + * @param ctx the parse tree + */ + void enterTypeParameterModifier(KotlinParser.TypeParameterModifierContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#typeParameterModifier}. + * + * @param ctx the parse tree + */ + void exitTypeParameterModifier(KotlinParser.TypeParameterModifierContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#functionModifier}. + * + * @param ctx the parse tree + */ + void enterFunctionModifier(KotlinParser.FunctionModifierContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#functionModifier}. + * + * @param ctx the parse tree + */ + void exitFunctionModifier(KotlinParser.FunctionModifierContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#propertyModifier}. + * + * @param ctx the parse tree + */ + void enterPropertyModifier(KotlinParser.PropertyModifierContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#propertyModifier}. + * + * @param ctx the parse tree + */ + void exitPropertyModifier(KotlinParser.PropertyModifierContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#inheritanceModifier}. + * + * @param ctx the parse tree + */ + void enterInheritanceModifier(KotlinParser.InheritanceModifierContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#inheritanceModifier}. + * + * @param ctx the parse tree + */ + void exitInheritanceModifier(KotlinParser.InheritanceModifierContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#parameterModifier}. + * + * @param ctx the parse tree + */ + void enterParameterModifier(KotlinParser.ParameterModifierContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#parameterModifier}. + * + * @param ctx the parse tree + */ + void exitParameterModifier(KotlinParser.ParameterModifierContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#reificationModifier}. + * + * @param ctx the parse tree + */ + void enterReificationModifier(KotlinParser.ReificationModifierContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#reificationModifier}. + * + * @param ctx the parse tree + */ + void exitReificationModifier(KotlinParser.ReificationModifierContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#platformModifier}. + * + * @param ctx the parse tree + */ + void enterPlatformModifier(KotlinParser.PlatformModifierContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#platformModifier}. + * + * @param ctx the parse tree + */ + void exitPlatformModifier(KotlinParser.PlatformModifierContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#annotation}. + * + * @param ctx the parse tree + */ + void enterAnnotation(KotlinParser.AnnotationContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#annotation}. + * + * @param ctx the parse tree + */ + void exitAnnotation(KotlinParser.AnnotationContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#singleAnnotation}. + * + * @param ctx the parse tree + */ + void enterSingleAnnotation(KotlinParser.SingleAnnotationContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#singleAnnotation}. + * + * @param ctx the parse tree + */ + void exitSingleAnnotation(KotlinParser.SingleAnnotationContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#multiAnnotation}. + * + * @param ctx the parse tree + */ + void enterMultiAnnotation(KotlinParser.MultiAnnotationContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#multiAnnotation}. + * + * @param ctx the parse tree + */ + void exitMultiAnnotation(KotlinParser.MultiAnnotationContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#annotationUseSiteTarget}. + * + * @param ctx the parse tree + */ + void enterAnnotationUseSiteTarget(KotlinParser.AnnotationUseSiteTargetContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#annotationUseSiteTarget}. + * + * @param ctx the parse tree + */ + void exitAnnotationUseSiteTarget(KotlinParser.AnnotationUseSiteTargetContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#unescapedAnnotation}. + * + * @param ctx the parse tree + */ + void enterUnescapedAnnotation(KotlinParser.UnescapedAnnotationContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#unescapedAnnotation}. + * + * @param ctx the parse tree + */ + void exitUnescapedAnnotation(KotlinParser.UnescapedAnnotationContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#simpleIdentifier}. + * + * @param ctx the parse tree + */ + void enterSimpleIdentifier(KotlinParser.SimpleIdentifierContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#simpleIdentifier}. + * + * @param ctx the parse tree + */ + void exitSimpleIdentifier(KotlinParser.SimpleIdentifierContext ctx); + /** + * Enter a parse tree produced by {@link KotlinParser#identifier}. + * + * @param ctx the parse tree + */ + void enterIdentifier(KotlinParser.IdentifierContext ctx); + /** + * Exit a parse tree produced by {@link KotlinParser#identifier}. + * + * @param ctx the parse tree + */ + void exitIdentifier(KotlinParser.IdentifierContext ctx); +} diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/kotlin/KotlinParserVisitor.java b/lexers/src/main/java/com/itsaky/androidide/lexers/kotlin/KotlinParserVisitor.java new file mode 100644 index 000000000..fcb691cdb --- /dev/null +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/kotlin/KotlinParserVisitor.java @@ -0,0 +1,1228 @@ +// Generated from KotlinParser.g4 by ANTLR 4.9.3 +package com.itsaky.androidide.lexers.kotlin; + +import org.antlr.v4.runtime.tree.ParseTreeVisitor; + +/** + * This interface defines a complete generic visitor for a parse tree produced by {@link + * KotlinParser}. + * + * @param The return type of the visit operation. Use {@link Void} for operations with no return + * type. + */ +public interface KotlinParserVisitor extends ParseTreeVisitor { + /** + * Visit a parse tree produced by {@link KotlinParser#kotlinFile}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitKotlinFile(KotlinParser.KotlinFileContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#script}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitScript(KotlinParser.ScriptContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#shebangLine}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitShebangLine(KotlinParser.ShebangLineContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#fileAnnotation}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitFileAnnotation(KotlinParser.FileAnnotationContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#packageHeader}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitPackageHeader(KotlinParser.PackageHeaderContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#importList}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitImportList(KotlinParser.ImportListContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#importHeader}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitImportHeader(KotlinParser.ImportHeaderContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#importAlias}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitImportAlias(KotlinParser.ImportAliasContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#topLevelObject}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTopLevelObject(KotlinParser.TopLevelObjectContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#typeAlias}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeAlias(KotlinParser.TypeAliasContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#declaration}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitDeclaration(KotlinParser.DeclarationContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#classDeclaration}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassDeclaration(KotlinParser.ClassDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#primaryConstructor}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitPrimaryConstructor(KotlinParser.PrimaryConstructorContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#classBody}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassBody(KotlinParser.ClassBodyContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#classParameters}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassParameters(KotlinParser.ClassParametersContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#classParameter}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassParameter(KotlinParser.ClassParameterContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#delegationSpecifiers}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitDelegationSpecifiers(KotlinParser.DelegationSpecifiersContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#delegationSpecifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitDelegationSpecifier(KotlinParser.DelegationSpecifierContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#constructorInvocation}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitConstructorInvocation(KotlinParser.ConstructorInvocationContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#annotatedDelegationSpecifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitAnnotatedDelegationSpecifier(KotlinParser.AnnotatedDelegationSpecifierContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#explicitDelegation}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitExplicitDelegation(KotlinParser.ExplicitDelegationContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#typeParameters}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeParameters(KotlinParser.TypeParametersContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#typeParameter}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeParameter(KotlinParser.TypeParameterContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#typeConstraints}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeConstraints(KotlinParser.TypeConstraintsContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#typeConstraint}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeConstraint(KotlinParser.TypeConstraintContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#classMemberDeclarations}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassMemberDeclarations(KotlinParser.ClassMemberDeclarationsContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#classMemberDeclaration}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassMemberDeclaration(KotlinParser.ClassMemberDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#anonymousInitializer}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitAnonymousInitializer(KotlinParser.AnonymousInitializerContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#companionObject}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitCompanionObject(KotlinParser.CompanionObjectContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#functionValueParameters}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitFunctionValueParameters(KotlinParser.FunctionValueParametersContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#functionValueParameter}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitFunctionValueParameter(KotlinParser.FunctionValueParameterContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#functionDeclaration}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitFunctionDeclaration(KotlinParser.FunctionDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#functionBody}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitFunctionBody(KotlinParser.FunctionBodyContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#variableDeclaration}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitVariableDeclaration(KotlinParser.VariableDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#multiVariableDeclaration}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitMultiVariableDeclaration(KotlinParser.MultiVariableDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#propertyDeclaration}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitPropertyDeclaration(KotlinParser.PropertyDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#propertyDelegate}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitPropertyDelegate(KotlinParser.PropertyDelegateContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#getter}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitGetter(KotlinParser.GetterContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#setter}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitSetter(KotlinParser.SetterContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#parametersWithOptionalType}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitParametersWithOptionalType(KotlinParser.ParametersWithOptionalTypeContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#functionValueParameterWithOptionalType}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitFunctionValueParameterWithOptionalType( + KotlinParser.FunctionValueParameterWithOptionalTypeContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#parameterWithOptionalType}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitParameterWithOptionalType(KotlinParser.ParameterWithOptionalTypeContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#parameter}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitParameter(KotlinParser.ParameterContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#objectDeclaration}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitObjectDeclaration(KotlinParser.ObjectDeclarationContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#secondaryConstructor}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitSecondaryConstructor(KotlinParser.SecondaryConstructorContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#constructorDelegationCall}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitConstructorDelegationCall(KotlinParser.ConstructorDelegationCallContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#enumClassBody}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumClassBody(KotlinParser.EnumClassBodyContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#enumEntries}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumEntries(KotlinParser.EnumEntriesContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#enumEntry}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitEnumEntry(KotlinParser.EnumEntryContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#type}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitType(KotlinParser.TypeContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#typeReference}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeReference(KotlinParser.TypeReferenceContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#nullableType}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitNullableType(KotlinParser.NullableTypeContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#quest}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitQuest(KotlinParser.QuestContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#userType}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitUserType(KotlinParser.UserTypeContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#simpleUserType}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitSimpleUserType(KotlinParser.SimpleUserTypeContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#typeProjection}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeProjection(KotlinParser.TypeProjectionContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#typeProjectionModifiers}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeProjectionModifiers(KotlinParser.TypeProjectionModifiersContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#typeProjectionModifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeProjectionModifier(KotlinParser.TypeProjectionModifierContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#functionType}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitFunctionType(KotlinParser.FunctionTypeContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#functionTypeParameters}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitFunctionTypeParameters(KotlinParser.FunctionTypeParametersContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#parenthesizedType}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitParenthesizedType(KotlinParser.ParenthesizedTypeContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#receiverType}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitReceiverType(KotlinParser.ReceiverTypeContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#parenthesizedUserType}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitParenthesizedUserType(KotlinParser.ParenthesizedUserTypeContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#statements}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitStatements(KotlinParser.StatementsContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#statement}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitStatement(KotlinParser.StatementContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#label}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitLabel(KotlinParser.LabelContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#controlStructureBody}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitControlStructureBody(KotlinParser.ControlStructureBodyContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#block}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitBlock(KotlinParser.BlockContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#loopStatement}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitLoopStatement(KotlinParser.LoopStatementContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#forStatement}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitForStatement(KotlinParser.ForStatementContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#whileStatement}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitWhileStatement(KotlinParser.WhileStatementContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#doWhileStatement}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitDoWhileStatement(KotlinParser.DoWhileStatementContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#assignment}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitAssignment(KotlinParser.AssignmentContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#semi}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitSemi(KotlinParser.SemiContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#semis}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitSemis(KotlinParser.SemisContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#expression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitExpression(KotlinParser.ExpressionContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#disjunction}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitDisjunction(KotlinParser.DisjunctionContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#conjunction}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitConjunction(KotlinParser.ConjunctionContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#equality}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitEquality(KotlinParser.EqualityContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#comparison}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitComparison(KotlinParser.ComparisonContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#genericCallLikeComparison}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitGenericCallLikeComparison(KotlinParser.GenericCallLikeComparisonContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#infixOperation}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitInfixOperation(KotlinParser.InfixOperationContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#elvisExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitElvisExpression(KotlinParser.ElvisExpressionContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#elvis}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitElvis(KotlinParser.ElvisContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#infixFunctionCall}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitInfixFunctionCall(KotlinParser.InfixFunctionCallContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#rangeExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitRangeExpression(KotlinParser.RangeExpressionContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#additiveExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitAdditiveExpression(KotlinParser.AdditiveExpressionContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#multiplicativeExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitMultiplicativeExpression(KotlinParser.MultiplicativeExpressionContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#asExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitAsExpression(KotlinParser.AsExpressionContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#prefixUnaryExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitPrefixUnaryExpression(KotlinParser.PrefixUnaryExpressionContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#unaryPrefix}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnaryPrefix(KotlinParser.UnaryPrefixContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#postfixUnaryExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitPostfixUnaryExpression(KotlinParser.PostfixUnaryExpressionContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#postfixUnarySuffix}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitPostfixUnarySuffix(KotlinParser.PostfixUnarySuffixContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#directlyAssignableExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitDirectlyAssignableExpression(KotlinParser.DirectlyAssignableExpressionContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#parenthesizedDirectlyAssignableExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitParenthesizedDirectlyAssignableExpression( + KotlinParser.ParenthesizedDirectlyAssignableExpressionContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#assignableExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitAssignableExpression(KotlinParser.AssignableExpressionContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#parenthesizedAssignableExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitParenthesizedAssignableExpression( + KotlinParser.ParenthesizedAssignableExpressionContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#assignableSuffix}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitAssignableSuffix(KotlinParser.AssignableSuffixContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#indexingSuffix}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitIndexingSuffix(KotlinParser.IndexingSuffixContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#navigationSuffix}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitNavigationSuffix(KotlinParser.NavigationSuffixContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#callSuffix}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitCallSuffix(KotlinParser.CallSuffixContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#annotatedLambda}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitAnnotatedLambda(KotlinParser.AnnotatedLambdaContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#typeArguments}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeArguments(KotlinParser.TypeArgumentsContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#valueArguments}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitValueArguments(KotlinParser.ValueArgumentsContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#valueArgument}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitValueArgument(KotlinParser.ValueArgumentContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#primaryExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitPrimaryExpression(KotlinParser.PrimaryExpressionContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#parenthesizedExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitParenthesizedExpression(KotlinParser.ParenthesizedExpressionContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#collectionLiteral}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitCollectionLiteral(KotlinParser.CollectionLiteralContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#literalConstant}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitLiteralConstant(KotlinParser.LiteralConstantContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#stringLiteral}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitStringLiteral(KotlinParser.StringLiteralContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#lineStringLiteral}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitLineStringLiteral(KotlinParser.LineStringLiteralContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#multiLineStringLiteral}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitMultiLineStringLiteral(KotlinParser.MultiLineStringLiteralContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#lineStringContent}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitLineStringContent(KotlinParser.LineStringContentContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#lineStringExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitLineStringExpression(KotlinParser.LineStringExpressionContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#multiLineStringContent}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitMultiLineStringContent(KotlinParser.MultiLineStringContentContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#multiLineStringExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitMultiLineStringExpression(KotlinParser.MultiLineStringExpressionContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#lambdaLiteral}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitLambdaLiteral(KotlinParser.LambdaLiteralContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#lambdaParameters}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitLambdaParameters(KotlinParser.LambdaParametersContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#lambdaParameter}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitLambdaParameter(KotlinParser.LambdaParameterContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#anonymousFunction}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitAnonymousFunction(KotlinParser.AnonymousFunctionContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#functionLiteral}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitFunctionLiteral(KotlinParser.FunctionLiteralContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#objectLiteral}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitObjectLiteral(KotlinParser.ObjectLiteralContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#thisExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitThisExpression(KotlinParser.ThisExpressionContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#superExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitSuperExpression(KotlinParser.SuperExpressionContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#ifExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitIfExpression(KotlinParser.IfExpressionContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#whenSubject}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitWhenSubject(KotlinParser.WhenSubjectContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#whenExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitWhenExpression(KotlinParser.WhenExpressionContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#whenEntry}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitWhenEntry(KotlinParser.WhenEntryContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#whenCondition}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitWhenCondition(KotlinParser.WhenConditionContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#rangeTest}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitRangeTest(KotlinParser.RangeTestContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#typeTest}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeTest(KotlinParser.TypeTestContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#tryExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTryExpression(KotlinParser.TryExpressionContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#catchBlock}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitCatchBlock(KotlinParser.CatchBlockContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#finallyBlock}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitFinallyBlock(KotlinParser.FinallyBlockContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#jumpExpression}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitJumpExpression(KotlinParser.JumpExpressionContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#callableReference}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitCallableReference(KotlinParser.CallableReferenceContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#assignmentAndOperator}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitAssignmentAndOperator(KotlinParser.AssignmentAndOperatorContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#equalityOperator}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitEqualityOperator(KotlinParser.EqualityOperatorContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#comparisonOperator}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitComparisonOperator(KotlinParser.ComparisonOperatorContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#inOperator}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitInOperator(KotlinParser.InOperatorContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#isOperator}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitIsOperator(KotlinParser.IsOperatorContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#additiveOperator}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitAdditiveOperator(KotlinParser.AdditiveOperatorContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#multiplicativeOperator}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitMultiplicativeOperator(KotlinParser.MultiplicativeOperatorContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#asOperator}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitAsOperator(KotlinParser.AsOperatorContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#prefixUnaryOperator}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitPrefixUnaryOperator(KotlinParser.PrefixUnaryOperatorContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#postfixUnaryOperator}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitPostfixUnaryOperator(KotlinParser.PostfixUnaryOperatorContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#excl}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitExcl(KotlinParser.ExclContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#memberAccessOperator}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitMemberAccessOperator(KotlinParser.MemberAccessOperatorContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#safeNav}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitSafeNav(KotlinParser.SafeNavContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#modifiers}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitModifiers(KotlinParser.ModifiersContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#parameterModifiers}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitParameterModifiers(KotlinParser.ParameterModifiersContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#modifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitModifier(KotlinParser.ModifierContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#typeModifiers}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeModifiers(KotlinParser.TypeModifiersContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#typeModifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeModifier(KotlinParser.TypeModifierContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#classModifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitClassModifier(KotlinParser.ClassModifierContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#memberModifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitMemberModifier(KotlinParser.MemberModifierContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#visibilityModifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitVisibilityModifier(KotlinParser.VisibilityModifierContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#varianceModifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitVarianceModifier(KotlinParser.VarianceModifierContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#typeParameterModifiers}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeParameterModifiers(KotlinParser.TypeParameterModifiersContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#typeParameterModifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitTypeParameterModifier(KotlinParser.TypeParameterModifierContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#functionModifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitFunctionModifier(KotlinParser.FunctionModifierContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#propertyModifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitPropertyModifier(KotlinParser.PropertyModifierContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#inheritanceModifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitInheritanceModifier(KotlinParser.InheritanceModifierContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#parameterModifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitParameterModifier(KotlinParser.ParameterModifierContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#reificationModifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitReificationModifier(KotlinParser.ReificationModifierContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#platformModifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitPlatformModifier(KotlinParser.PlatformModifierContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#annotation}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitAnnotation(KotlinParser.AnnotationContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#singleAnnotation}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitSingleAnnotation(KotlinParser.SingleAnnotationContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#multiAnnotation}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitMultiAnnotation(KotlinParser.MultiAnnotationContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#annotationUseSiteTarget}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitAnnotationUseSiteTarget(KotlinParser.AnnotationUseSiteTargetContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#unescapedAnnotation}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitUnescapedAnnotation(KotlinParser.UnescapedAnnotationContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#simpleIdentifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitSimpleIdentifier(KotlinParser.SimpleIdentifierContext ctx); + /** + * Visit a parse tree produced by {@link KotlinParser#identifier}. + * + * @param ctx the parse tree + * @return the visitor result + */ + T visitIdentifier(KotlinParser.IdentifierContext ctx); +} diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/kotlin/UnicodeClasses.java b/lexers/src/main/java/com/itsaky/androidide/lexers/kotlin/UnicodeClasses.java index ca7f0adf0..129e2d590 100644 --- a/lexers/src/main/java/com/itsaky/androidide/lexers/kotlin/UnicodeClasses.java +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/kotlin/UnicodeClasses.java @@ -1,384 +1,406 @@ -// Generated from UnicodeClasses.g4 by ANTLR 4.9.2 +// Generated from UnicodeClasses.g4 by ANTLR 4.9.3 package com.itsaky.androidide.lexers.kotlin; -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.Lexer; +import org.antlr.v4.runtime.RuntimeMetaData; +import org.antlr.v4.runtime.Vocabulary; +import org.antlr.v4.runtime.VocabularyImpl; +import org.antlr.v4.runtime.atn.ATN; +import org.antlr.v4.runtime.atn.ATNDeserializer; +import org.antlr.v4.runtime.atn.LexerATNSimulator; +import org.antlr.v4.runtime.atn.PredictionContextCache; import org.antlr.v4.runtime.dfa.DFA; -import org.antlr.v4.runtime.misc.*; @SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) public class UnicodeClasses extends Lexer { - static { RuntimeMetaData.checkVersion("4.9.2", RuntimeMetaData.VERSION); } + public static final int UNICODE_CLASS_LL = 1, + UNICODE_CLASS_LM = 2, + UNICODE_CLASS_LO = 3, + UNICODE_CLASS_LT = 4, + UNICODE_CLASS_LU = 5, + UNICODE_CLASS_ND = 6, + UNICODE_CLASS_NL = 7; + public static final String[] ruleNames = makeRuleNames(); + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated public static final String[] tokenNames; + public static final String _serializedATN = + "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\t\37\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\3\2\3\2\3\3\3\3\3\4\3" + + "\4\3\5\3\5\3\6\3\6\3\7\3\7\3\b\3\b\2\2\t\3\3\5\4\7\5\t\6\13\7\r\b\17\t" + + "\3\2\t\u0248\2c|\u00b7\u00b7\u00e1\u00f8\u00fa\u0101\u0103\u0103\u0105" + + "\u0105\u0107\u0107\u0109\u0109\u010b\u010b\u010d\u010d\u010f\u010f\u0111" + + "\u0111\u0113\u0113\u0115\u0115\u0117\u0117\u0119\u0119\u011b\u011b\u011d" + + "\u011d\u011f\u011f\u0121\u0121\u0123\u0123\u0125\u0125\u0127\u0127\u0129" + + "\u0129\u012b\u012b\u012d\u012d\u012f\u012f\u0131\u0131\u0133\u0133\u0135" + + "\u0135\u0137\u0137\u0139\u013a\u013c\u013c\u013e\u013e\u0140\u0140\u0142" + + "\u0142\u0144\u0144\u0146\u0146\u0148\u0148\u014a\u014b\u014d\u014d\u014f" + + "\u014f\u0151\u0151\u0153\u0153\u0155\u0155\u0157\u0157\u0159\u0159\u015b" + + "\u015b\u015d\u015d\u015f\u015f\u0161\u0161\u0163\u0163\u0165\u0165\u0167" + + "\u0167\u0169\u0169\u016b\u016b\u016d\u016d\u016f\u016f\u0171\u0171\u0173" + + "\u0173\u0175\u0175\u0177\u0177\u0179\u0179\u017c\u017c\u017e\u017e\u0180" + + "\u0182\u0185\u0185\u0187\u0187\u018a\u018a\u018e\u018f\u0194\u0194\u0197" + + "\u0197\u019b\u019d\u01a0\u01a0\u01a3\u01a3\u01a5\u01a5\u01a7\u01a7\u01aa" + + "\u01aa\u01ac\u01ad\u01af\u01af\u01b2\u01b2\u01b6\u01b6\u01b8\u01b8\u01bb" + + "\u01bc\u01bf\u01c1\u01c8\u01c8\u01cb\u01cb\u01ce\u01ce\u01d0\u01d0\u01d2" + + "\u01d2\u01d4\u01d4\u01d6\u01d6\u01d8\u01d8\u01da\u01da\u01dc\u01dc\u01de" + + "\u01df\u01e1\u01e1\u01e3\u01e3\u01e5\u01e5\u01e7\u01e7\u01e9\u01e9\u01eb" + + "\u01eb\u01ed\u01ed\u01ef\u01ef\u01f1\u01f2\u01f5\u01f5\u01f7\u01f7\u01fb" + + "\u01fb\u01fd\u01fd\u01ff\u01ff\u0201\u0201\u0203\u0203\u0205\u0205\u0207" + + "\u0207\u0209\u0209\u020b\u020b\u020d\u020d\u020f\u020f\u0211\u0211\u0213" + + "\u0213\u0215\u0215\u0217\u0217\u0219\u0219\u021b\u021b\u021d\u021d\u021f" + + "\u021f\u0221\u0221\u0223\u0223\u0225\u0225\u0227\u0227\u0229\u0229\u022b" + + "\u022b\u022d\u022d\u022f\u022f\u0231\u0231\u0233\u0233\u0235\u023b\u023e" + + "\u023e\u0241\u0242\u0244\u0244\u0249\u0249\u024b\u024b\u024d\u024d\u024f" + + "\u024f\u0251\u0295\u0297\u02b1\u0373\u0373\u0375\u0375\u0379\u0379\u037d" + + "\u037f\u0392\u0392\u03ae\u03d0\u03d2\u03d3\u03d7\u03d9\u03db\u03db\u03dd" + + "\u03dd\u03df\u03df\u03e1\u03e1\u03e3\u03e3\u03e5\u03e5\u03e7\u03e7\u03e9" + + "\u03e9\u03eb\u03eb\u03ed\u03ed\u03ef\u03ef\u03f1\u03f5\u03f7\u03f7\u03fa" + + "\u03fa\u03fd\u03fe\u0432\u0461\u0463\u0463\u0465\u0465\u0467\u0467\u0469" + + "\u0469\u046b\u046b\u046d\u046d\u046f\u046f\u0471\u0471\u0473\u0473\u0475" + + "\u0475\u0477\u0477\u0479\u0479\u047b\u047b\u047d\u047d\u047f\u047f\u0481" + + "\u0481\u0483\u0483\u048d\u048d\u048f\u048f\u0491\u0491\u0493\u0493\u0495" + + "\u0495\u0497\u0497\u0499\u0499\u049b\u049b\u049d\u049d\u049f\u049f\u04a1" + + "\u04a1\u04a3\u04a3\u04a5\u04a5\u04a7\u04a7\u04a9\u04a9\u04ab\u04ab\u04ad" + + "\u04ad\u04af\u04af\u04b1\u04b1\u04b3\u04b3\u04b5\u04b5\u04b7\u04b7\u04b9" + + "\u04b9\u04bb\u04bb\u04bd\u04bd\u04bf\u04bf\u04c1\u04c1\u04c4\u04c4\u04c6" + + "\u04c6\u04c8\u04c8\u04ca\u04ca\u04cc\u04cc\u04ce\u04ce\u04d0\u04d1\u04d3" + + "\u04d3\u04d5\u04d5\u04d7\u04d7\u04d9\u04d9\u04db\u04db\u04dd\u04dd\u04df" + + "\u04df\u04e1\u04e1\u04e3\u04e3\u04e5\u04e5\u04e7\u04e7\u04e9\u04e9\u04eb" + + "\u04eb\u04ed\u04ed\u04ef\u04ef\u04f1\u04f1\u04f3\u04f3\u04f5\u04f5\u04f7" + + "\u04f7\u04f9\u04f9\u04fb\u04fb\u04fd\u04fd\u04ff\u04ff\u0501\u0501\u0503" + + "\u0503\u0505\u0505\u0507\u0507\u0509\u0509\u050b\u050b\u050d\u050d\u050f" + + "\u050f\u0511\u0511\u0513\u0513\u0515\u0515\u0517\u0517\u0519\u0519\u051b" + + "\u051b\u051d\u051d\u051f\u051f\u0521\u0521\u0523\u0523\u0525\u0525\u0527" + + "\u0527\u0529\u0529\u0563\u0589\u1d02\u1d2d\u1d6d\u1d79\u1d7b\u1d9c\u1e03" + + "\u1e03\u1e05\u1e05\u1e07\u1e07\u1e09\u1e09\u1e0b\u1e0b\u1e0d\u1e0d\u1e0f" + + "\u1e0f\u1e11\u1e11\u1e13\u1e13\u1e15\u1e15\u1e17\u1e17\u1e19\u1e19\u1e1b" + + "\u1e1b\u1e1d\u1e1d\u1e1f\u1e1f\u1e21\u1e21\u1e23\u1e23\u1e25\u1e25\u1e27" + + "\u1e27\u1e29\u1e29\u1e2b\u1e2b\u1e2d\u1e2d\u1e2f\u1e2f\u1e31\u1e31\u1e33" + + "\u1e33\u1e35\u1e35\u1e37\u1e37\u1e39\u1e39\u1e3b\u1e3b\u1e3d\u1e3d\u1e3f" + + "\u1e3f\u1e41\u1e41\u1e43\u1e43\u1e45\u1e45\u1e47\u1e47\u1e49\u1e49\u1e4b" + + "\u1e4b\u1e4d\u1e4d\u1e4f\u1e4f\u1e51\u1e51\u1e53\u1e53\u1e55\u1e55\u1e57" + + "\u1e57\u1e59\u1e59\u1e5b\u1e5b\u1e5d\u1e5d\u1e5f\u1e5f\u1e61\u1e61\u1e63" + + "\u1e63\u1e65\u1e65\u1e67\u1e67\u1e69\u1e69\u1e6b\u1e6b\u1e6d\u1e6d\u1e6f" + + "\u1e6f\u1e71\u1e71\u1e73\u1e73\u1e75\u1e75\u1e77\u1e77\u1e79\u1e79\u1e7b" + + "\u1e7b\u1e7d\u1e7d\u1e7f\u1e7f\u1e81\u1e81\u1e83\u1e83\u1e85\u1e85\u1e87" + + "\u1e87\u1e89\u1e89\u1e8b\u1e8b\u1e8d\u1e8d\u1e8f\u1e8f\u1e91\u1e91\u1e93" + + "\u1e93\u1e95\u1e95\u1e97\u1e9f\u1ea1\u1ea1\u1ea3\u1ea3\u1ea5\u1ea5\u1ea7" + + "\u1ea7\u1ea9\u1ea9\u1eab\u1eab\u1ead\u1ead\u1eaf\u1eaf\u1eb1\u1eb1\u1eb3" + + "\u1eb3\u1eb5\u1eb5\u1eb7\u1eb7\u1eb9\u1eb9\u1ebb\u1ebb\u1ebd\u1ebd\u1ebf" + + "\u1ebf\u1ec1\u1ec1\u1ec3\u1ec3\u1ec5\u1ec5\u1ec7\u1ec7\u1ec9\u1ec9\u1ecb" + + "\u1ecb\u1ecd\u1ecd\u1ecf\u1ecf\u1ed1\u1ed1\u1ed3\u1ed3\u1ed5\u1ed5\u1ed7" + + "\u1ed7\u1ed9\u1ed9\u1edb\u1edb\u1edd\u1edd\u1edf\u1edf\u1ee1\u1ee1\u1ee3" + + "\u1ee3\u1ee5\u1ee5\u1ee7\u1ee7\u1ee9\u1ee9\u1eeb\u1eeb\u1eed\u1eed\u1eef" + + "\u1eef\u1ef1\u1ef1\u1ef3\u1ef3\u1ef5\u1ef5\u1ef7\u1ef7\u1ef9\u1ef9\u1efb" + + "\u1efb\u1efd\u1efd\u1eff\u1eff\u1f01\u1f09\u1f12\u1f17\u1f22\u1f29\u1f32" + + "\u1f39\u1f42\u1f47\u1f52\u1f59\u1f62\u1f69\u1f72\u1f7f\u1f82\u1f89\u1f92" + + "\u1f99\u1fa2\u1fa9\u1fb2\u1fb6\u1fb8\u1fb9\u1fc0\u1fc0\u1fc4\u1fc6\u1fc8" + + "\u1fc9\u1fd2\u1fd5\u1fd8\u1fd9\u1fe2\u1fe9\u1ff4\u1ff6\u1ff8\u1ff9\u210c" + + "\u210c\u2110\u2111\u2115\u2115\u2131\u2131\u2136\u2136\u213b\u213b\u213e" + + "\u213f\u2148\u214b\u2150\u2150\u2186\u2186\u2c32\u2c60\u2c63\u2c63\u2c67" + + "\u2c68\u2c6a\u2c6a\u2c6c\u2c6c\u2c6e\u2c6e\u2c73\u2c73\u2c75\u2c76\u2c78" + + "\u2c7d\u2c83\u2c83\u2c85\u2c85\u2c87\u2c87\u2c89\u2c89\u2c8b\u2c8b\u2c8d" + + "\u2c8d\u2c8f\u2c8f\u2c91\u2c91\u2c93\u2c93\u2c95\u2c95\u2c97\u2c97\u2c99" + + "\u2c99\u2c9b\u2c9b\u2c9d\u2c9d\u2c9f\u2c9f\u2ca1\u2ca1\u2ca3\u2ca3\u2ca5" + + "\u2ca5\u2ca7\u2ca7\u2ca9\u2ca9\u2cab\u2cab\u2cad\u2cad\u2caf\u2caf\u2cb1" + + "\u2cb1\u2cb3\u2cb3\u2cb5\u2cb5\u2cb7\u2cb7\u2cb9\u2cb9\u2cbb\u2cbb\u2cbd" + + "\u2cbd\u2cbf\u2cbf\u2cc1\u2cc1\u2cc3\u2cc3\u2cc5\u2cc5\u2cc7\u2cc7\u2cc9" + + "\u2cc9\u2ccb\u2ccb\u2ccd\u2ccd\u2ccf\u2ccf\u2cd1\u2cd1\u2cd3\u2cd3\u2cd5" + + "\u2cd5\u2cd7\u2cd7\u2cd9\u2cd9\u2cdb\u2cdb\u2cdd\u2cdd\u2cdf\u2cdf\u2ce1" + + "\u2ce1\u2ce3\u2ce3\u2ce5\u2ce6\u2cee\u2cee\u2cf0\u2cf0\u2cf5\u2cf5\u2d02" + + "\u2d27\u2d29\u2d29\u2d2f\u2d2f\ua643\ua643\ua645\ua645\ua647\ua647\ua649" + + "\ua649\ua64b\ua64b\ua64d\ua64d\ua64f\ua64f\ua651\ua651\ua653\ua653\ua655" + + "\ua655\ua657\ua657\ua659\ua659\ua65b\ua65b\ua65d\ua65d\ua65f\ua65f\ua661" + + "\ua661\ua663\ua663\ua665\ua665\ua667\ua667\ua669\ua669\ua66b\ua66b\ua66d" + + "\ua66d\ua66f\ua66f\ua683\ua683\ua685\ua685\ua687\ua687\ua689\ua689\ua68b" + + "\ua68b\ua68d\ua68d\ua68f\ua68f\ua691\ua691\ua693\ua693\ua695\ua695\ua697" + + "\ua697\ua699\ua699\ua725\ua725\ua727\ua727\ua729\ua729\ua72b\ua72b\ua72d" + + "\ua72d\ua72f\ua72f\ua731\ua733\ua735\ua735\ua737\ua737\ua739\ua739\ua73b" + + "\ua73b\ua73d\ua73d\ua73f\ua73f\ua741\ua741\ua743\ua743\ua745\ua745\ua747" + + "\ua747\ua749\ua749\ua74b\ua74b\ua74d\ua74d\ua74f\ua74f\ua751\ua751\ua753" + + "\ua753\ua755\ua755\ua757\ua757\ua759\ua759\ua75b\ua75b\ua75d\ua75d\ua75f" + + "\ua75f\ua761\ua761\ua763\ua763\ua765\ua765\ua767\ua767\ua769\ua769\ua76b" + + "\ua76b\ua76d\ua76d\ua76f\ua76f\ua771\ua771\ua773\ua77a\ua77c\ua77c\ua77e" + + "\ua77e\ua781\ua781\ua783\ua783\ua785\ua785\ua787\ua787\ua789\ua789\ua78e" + + "\ua78e\ua790\ua790\ua793\ua793\ua795\ua795\ua7a3\ua7a3\ua7a5\ua7a5\ua7a7" + + "\ua7a7\ua7a9\ua7a9\ua7ab\ua7ab\ua7fc\ua7fc\ufb02\ufb08\ufb15\ufb19\uff43" + + "\uff5c\65\2\u02b2\u02c3\u02c8\u02d3\u02e2\u02e6\u02ee\u02ee\u02f0\u02f0" + + "\u0376\u0376\u037c\u037c\u055b\u055b\u0642\u0642\u06e7\u06e8\u07f6\u07f7" + + "\u07fc\u07fc\u081c\u081c\u0826\u0826\u082a\u082a\u0973\u0973\u0e48\u0e48" + + "\u0ec8\u0ec8\u10fe\u10fe\u17d9\u17d9\u1845\u1845\u1aa9\u1aa9\u1c7a\u1c7f" + + "\u1d2e\u1d6c\u1d7a\u1d7a\u1d9d\u1dc1\u2073\u2073\u2081\u2081\u2092\u209e" + + "\u2c7e\u2c7f\u2d71\u2d71\u2e31\u2e31\u3007\u3007\u3033\u3037\u303d\u303d" + + "\u309f\u30a0\u30fe\u3100\ua017\ua017\ua4fa\ua4ff\ua60e\ua60e\ua681\ua681" + + "\ua719\ua721\ua772\ua772\ua78a\ua78a\ua7fa\ua7fb\ua9d1\ua9d1\uaa72\uaa72" + + "\uaadf\uaadf\uaaf5\uaaf6\uff72\uff72\uffa0\uffa1\u0123\2\u00ac\u00ac\u00bc" + + "\u00bc\u01bd\u01bd\u01c2\u01c5\u0296\u0296\u05d2\u05ec\u05f2\u05f4\u0622" + + "\u0641\u0643\u064c\u0670\u0671\u0673\u06d5\u06d7\u06d7\u06f0\u06f1\u06fc" + + "\u06fe\u0701\u0701\u0712\u0712\u0714\u0731\u074f\u07a7\u07b3\u07b3\u07cc" + + "\u07ec\u0802\u0817\u0842\u085a\u08a2\u08a2\u08a4\u08ae\u0906\u093b\u093f" + + "\u093f\u0952\u0952\u095a\u0963\u0974\u0979\u097b\u0981\u0987\u098e\u0991" + + "\u0992\u0995\u09aa\u09ac\u09b2\u09b4\u09b4\u09b8\u09bb\u09bf\u09bf\u09d0" + + "\u09d0\u09de\u09df\u09e1\u09e3\u09f2\u09f3\u0a07\u0a0c\u0a11\u0a12\u0a15" + + "\u0a2a\u0a2c\u0a32\u0a34\u0a35\u0a37\u0a38\u0a3a\u0a3b\u0a5b\u0a5e\u0a60" + + "\u0a60\u0a74\u0a76\u0a87\u0a8f\u0a91\u0a93\u0a95\u0aaa\u0aac\u0ab2\u0ab4" + + "\u0ab5\u0ab7\u0abb\u0abf\u0abf\u0ad2\u0ad2\u0ae2\u0ae3\u0b07\u0b0e\u0b11" + + "\u0b12\u0b15\u0b2a\u0b2c\u0b32\u0b34\u0b35\u0b37\u0b3b\u0b3f\u0b3f\u0b5e" + + "\u0b5f\u0b61\u0b63\u0b73\u0b73\u0b85\u0b85\u0b87\u0b8c\u0b90\u0b92\u0b94" + + "\u0b97\u0b9b\u0b9c\u0b9e\u0b9e\u0ba0\u0ba1\u0ba5\u0ba6\u0baa\u0bac\u0bb0" + + "\u0bbb\u0bd2\u0bd2\u0c07\u0c0e\u0c10\u0c12\u0c14\u0c2a\u0c2c\u0c35\u0c37" + + "\u0c3b\u0c3f\u0c3f\u0c5a\u0c5b\u0c62\u0c63\u0c87\u0c8e\u0c90\u0c92\u0c94" + + "\u0caa\u0cac\u0cb5\u0cb7\u0cbb\u0cbf\u0cbf\u0ce0\u0ce0\u0ce2\u0ce3\u0cf3" + + "\u0cf4\u0d07\u0d0e\u0d10\u0d12\u0d14\u0d3c\u0d3f\u0d3f\u0d50\u0d50\u0d62" + + "\u0d63\u0d7c\u0d81\u0d87\u0d98\u0d9c\u0db3\u0db5\u0dbd\u0dbf\u0dbf\u0dc2" + + "\u0dc8\u0e03\u0e32\u0e34\u0e35\u0e42\u0e47\u0e83\u0e84\u0e86\u0e86\u0e89" + + "\u0e8a\u0e8c\u0e8c\u0e8f\u0e8f\u0e96\u0e99\u0e9b\u0ea1\u0ea3\u0ea5\u0ea7" + + "\u0ea7\u0ea9\u0ea9\u0eac\u0ead\u0eaf\u0eb2\u0eb4\u0eb5\u0ebf\u0ebf\u0ec2" + + "\u0ec6\u0ede\u0ee1\u0f02\u0f02\u0f42\u0f49\u0f4b\u0f6e\u0f8a\u0f8e\u1002" + + "\u102c\u1041\u1041\u1052\u1057\u105c\u105f\u1063\u1063\u1067\u1068\u1070" + + "\u1072\u1077\u1083\u1090\u1090\u10d2\u10fc\u10ff\u124a\u124c\u124f\u1252" + + "\u1258\u125a\u125a\u125c\u125f\u1262\u128a\u128c\u128f\u1292\u12b2\u12b4" + + "\u12b7\u12ba\u12c0\u12c2\u12c2\u12c4\u12c7\u12ca\u12d8\u12da\u1312\u1314" + + "\u1317\u131a\u135c\u1382\u1391\u13a2\u13f6\u1403\u166e\u1671\u1681\u1683" + + "\u169c\u16a2\u16ec\u1702\u170e\u1710\u1713\u1722\u1733\u1742\u1753\u1762" + + "\u176e\u1770\u1772\u1782\u17b5\u17de\u17de\u1822\u1844\u1846\u1879\u1882" + + "\u18aa\u18ac\u18ac\u18b2\u18f7\u1902\u191e\u1952\u196f\u1972\u1976\u1982" + + "\u19ad\u19c3\u19c9\u1a02\u1a18\u1a22\u1a56\u1b07\u1b35\u1b47\u1b4d\u1b85" + + "\u1ba2\u1bb0\u1bb1\u1bbc\u1be7\u1c02\u1c25\u1c4f\u1c51\u1c5c\u1c79\u1ceb" + + "\u1cee\u1cf0\u1cf3\u1cf7\u1cf8\u2137\u213a\u2d32\u2d69\u2d82\u2d98\u2da2" + + "\u2da8\u2daa\u2db0\u2db2\u2db8\u2dba\u2dc0\u2dc2\u2dc8\u2dca\u2dd0\u2dd2" + + "\u2dd8\u2dda\u2de0\u3008\u3008\u303e\u303e\u3043\u3098\u30a1\u30a1\u30a3" + + "\u30fc\u3101\u3101\u3107\u312f\u3133\u3190\u31a2\u31bc\u31f2\u3201\u3402" + + "\u3402\u4db7\u4db7\u4e02\u4e02\u9fce\u9fce\ua002\ua016\ua018\ua48e\ua4d2" + + "\ua4f9\ua502\ua60d\ua612\ua621\ua62c\ua62d\ua670\ua670\ua6a2\ua6e7\ua7fd" + + "\ua803\ua805\ua807\ua809\ua80c\ua80e\ua824\ua842\ua875\ua884\ua8b5\ua8f4" + + "\ua8f9\ua8fd\ua8fd\ua90c\ua927\ua932\ua948\ua962\ua97e\ua986\ua9b4\uaa02" + + "\uaa2a\uaa42\uaa44\uaa46\uaa4d\uaa62\uaa71\uaa73\uaa78\uaa7c\uaa7c\uaa82" + + "\uaab1\uaab3\uaab3\uaab7\uaab8\uaabb\uaabf\uaac2\uaac2\uaac4\uaac4\uaadd" + + "\uaade\uaae2\uaaec\uaaf4\uaaf4\uab03\uab08\uab0b\uab10\uab13\uab18\uab22" + + "\uab28\uab2a\uab30\uabc2\uabe4\uac02\uac02\ud7a5\ud7a5\ud7b2\ud7c8\ud7cd" + + "\ud7fd\uf902\ufa6f\ufa72\ufadb\ufb1f\ufb1f\ufb21\ufb2a\ufb2c\ufb38\ufb3a" + + "\ufb3e\ufb40\ufb40\ufb42\ufb43\ufb45\ufb46\ufb48\ufbb3\ufbd5\ufd3f\ufd52" + + "\ufd91\ufd94\ufdc9\ufdf2\ufdfd\ufe72\ufe76\ufe78\ufefe\uff68\uff71\uff73" + + "\uff9f\uffa2\uffc0\uffc4\uffc9\uffcc\uffd1\uffd4\uffd9\uffdc\uffde\f\2" + + "\u01c7\u01c7\u01ca\u01ca\u01cd\u01cd\u01f4\u01f4\u1f8a\u1f91\u1f9a\u1fa1" + + "\u1faa\u1fb1\u1fbe\u1fbe\u1fce\u1fce\u1ffe\u1ffe\u0242\2C\\\u00c2\u00d8" + + "\u00da\u00e0\u0102\u0102\u0104\u0104\u0106\u0106\u0108\u0108\u010a\u010a" + + "\u010c\u010c\u010e\u010e\u0110\u0110\u0112\u0112\u0114\u0114\u0116\u0116" + + "\u0118\u0118\u011a\u011a\u011c\u011c\u011e\u011e\u0120\u0120\u0122\u0122" + + "\u0124\u0124\u0126\u0126\u0128\u0128\u012a\u012a\u012c\u012c\u012e\u012e" + + "\u0130\u0130\u0132\u0132\u0134\u0134\u0136\u0136\u0138\u0138\u013b\u013b" + + "\u013d\u013d\u013f\u013f\u0141\u0141\u0143\u0143\u0145\u0145\u0147\u0147" + + "\u0149\u0149\u014c\u014c\u014e\u014e\u0150\u0150\u0152\u0152\u0154\u0154" + + "\u0156\u0156\u0158\u0158\u015a\u015a\u015c\u015c\u015e\u015e\u0160\u0160" + + "\u0162\u0162\u0164\u0164\u0166\u0166\u0168\u0168\u016a\u016a\u016c\u016c" + + "\u016e\u016e\u0170\u0170\u0172\u0172\u0174\u0174\u0176\u0176\u0178\u0178" + + "\u017a\u017b\u017d\u017d\u017f\u017f\u0183\u0184\u0186\u0186\u0188\u0189" + + "\u018b\u018d\u0190\u0193\u0195\u0196\u0198\u019a\u019e\u019f\u01a1\u01a2" + + "\u01a4\u01a4\u01a6\u01a6\u01a8\u01a9\u01ab\u01ab\u01ae\u01ae\u01b0\u01b1" + + "\u01b3\u01b5\u01b7\u01b7\u01b9\u01ba\u01be\u01be\u01c6\u01c6\u01c9\u01c9" + + "\u01cc\u01cc\u01cf\u01cf\u01d1\u01d1\u01d3\u01d3\u01d5\u01d5\u01d7\u01d7" + + "\u01d9\u01d9\u01db\u01db\u01dd\u01dd\u01e0\u01e0\u01e2\u01e2\u01e4\u01e4" + + "\u01e6\u01e6\u01e8\u01e8\u01ea\u01ea\u01ec\u01ec\u01ee\u01ee\u01f0\u01f0" + + "\u01f3\u01f3\u01f6\u01f6\u01f8\u01fa\u01fc\u01fc\u01fe\u01fe\u0200\u0200" + + "\u0202\u0202\u0204\u0204\u0206\u0206\u0208\u0208\u020a\u020a\u020c\u020c" + + "\u020e\u020e\u0210\u0210\u0212\u0212\u0214\u0214\u0216\u0216\u0218\u0218" + + "\u021a\u021a\u021c\u021c\u021e\u021e\u0220\u0220\u0222\u0222\u0224\u0224" + + "\u0226\u0226\u0228\u0228\u022a\u022a\u022c\u022c\u022e\u022e\u0230\u0230" + + "\u0232\u0232\u0234\u0234\u023c\u023d\u023f\u0240\u0243\u0243\u0245\u0248" + + "\u024a\u024a\u024c\u024c\u024e\u024e\u0250\u0250\u0372\u0372\u0374\u0374" + + "\u0378\u0378\u0388\u0388\u038a\u038c\u038e\u038e\u0390\u0391\u0393\u03a3" + + "\u03a5\u03ad\u03d1\u03d1\u03d4\u03d6\u03da\u03da\u03dc\u03dc\u03de\u03de" + + "\u03e0\u03e0\u03e2\u03e2\u03e4\u03e4\u03e6\u03e6\u03e8\u03e8\u03ea\u03ea" + + "\u03ec\u03ec\u03ee\u03ee\u03f0\u03f0\u03f6\u03f6\u03f9\u03f9\u03fb\u03fc" + + "\u03ff\u0431\u0462\u0462\u0464\u0464\u0466\u0466\u0468\u0468\u046a\u046a" + + "\u046c\u046c\u046e\u046e\u0470\u0470\u0472\u0472\u0474\u0474\u0476\u0476" + + "\u0478\u0478\u047a\u047a\u047c\u047c\u047e\u047e\u0480\u0480\u0482\u0482" + + "\u048c\u048c\u048e\u048e\u0490\u0490\u0492\u0492\u0494\u0494\u0496\u0496" + + "\u0498\u0498\u049a\u049a\u049c\u049c\u049e\u049e\u04a0\u04a0\u04a2\u04a2" + + "\u04a4\u04a4\u04a6\u04a6\u04a8\u04a8\u04aa\u04aa\u04ac\u04ac\u04ae\u04ae" + + "\u04b0\u04b0\u04b2\u04b2\u04b4\u04b4\u04b6\u04b6\u04b8\u04b8\u04ba\u04ba" + + "\u04bc\u04bc\u04be\u04be\u04c0\u04c0\u04c2\u04c3\u04c5\u04c5\u04c7\u04c7" + + "\u04c9\u04c9\u04cb\u04cb\u04cd\u04cd\u04cf\u04cf\u04d2\u04d2\u04d4\u04d4" + + "\u04d6\u04d6\u04d8\u04d8\u04da\u04da\u04dc\u04dc\u04de\u04de\u04e0\u04e0" + + "\u04e2\u04e2\u04e4\u04e4\u04e6\u04e6\u04e8\u04e8\u04ea\u04ea\u04ec\u04ec" + + "\u04ee\u04ee\u04f0\u04f0\u04f2\u04f2\u04f4\u04f4\u04f6\u04f6\u04f8\u04f8" + + "\u04fa\u04fa\u04fc\u04fc\u04fe\u04fe\u0500\u0500\u0502\u0502\u0504\u0504" + + "\u0506\u0506\u0508\u0508\u050a\u050a\u050c\u050c\u050e\u050e\u0510\u0510" + + "\u0512\u0512\u0514\u0514\u0516\u0516\u0518\u0518\u051a\u051a\u051c\u051c" + + "\u051e\u051e\u0520\u0520\u0522\u0522\u0524\u0524\u0526\u0526\u0528\u0528" + + "\u0533\u0558\u10a2\u10c7\u10c9\u10c9\u10cf\u10cf\u1e02\u1e02\u1e04\u1e04" + + "\u1e06\u1e06\u1e08\u1e08\u1e0a\u1e0a\u1e0c\u1e0c\u1e0e\u1e0e\u1e10\u1e10" + + "\u1e12\u1e12\u1e14\u1e14\u1e16\u1e16\u1e18\u1e18\u1e1a\u1e1a\u1e1c\u1e1c" + + "\u1e1e\u1e1e\u1e20\u1e20\u1e22\u1e22\u1e24\u1e24\u1e26\u1e26\u1e28\u1e28" + + "\u1e2a\u1e2a\u1e2c\u1e2c\u1e2e\u1e2e\u1e30\u1e30\u1e32\u1e32\u1e34\u1e34" + + "\u1e36\u1e36\u1e38\u1e38\u1e3a\u1e3a\u1e3c\u1e3c\u1e3e\u1e3e\u1e40\u1e40" + + "\u1e42\u1e42\u1e44\u1e44\u1e46\u1e46\u1e48\u1e48\u1e4a\u1e4a\u1e4c\u1e4c" + + "\u1e4e\u1e4e\u1e50\u1e50\u1e52\u1e52\u1e54\u1e54\u1e56\u1e56\u1e58\u1e58" + + "\u1e5a\u1e5a\u1e5c\u1e5c\u1e5e\u1e5e\u1e60\u1e60\u1e62\u1e62\u1e64\u1e64" + + "\u1e66\u1e66\u1e68\u1e68\u1e6a\u1e6a\u1e6c\u1e6c\u1e6e\u1e6e\u1e70\u1e70" + + "\u1e72\u1e72\u1e74\u1e74\u1e76\u1e76\u1e78\u1e78\u1e7a\u1e7a\u1e7c\u1e7c" + + "\u1e7e\u1e7e\u1e80\u1e80\u1e82\u1e82\u1e84\u1e84\u1e86\u1e86\u1e88\u1e88" + + "\u1e8a\u1e8a\u1e8c\u1e8c\u1e8e\u1e8e\u1e90\u1e90\u1e92\u1e92\u1e94\u1e94" + + "\u1e96\u1e96\u1ea0\u1ea0\u1ea2\u1ea2\u1ea4\u1ea4\u1ea6\u1ea6\u1ea8\u1ea8" + + "\u1eaa\u1eaa\u1eac\u1eac\u1eae\u1eae\u1eb0\u1eb0\u1eb2\u1eb2\u1eb4\u1eb4" + + "\u1eb6\u1eb6\u1eb8\u1eb8\u1eba\u1eba\u1ebc\u1ebc\u1ebe\u1ebe\u1ec0\u1ec0" + + "\u1ec2\u1ec2\u1ec4\u1ec4\u1ec6\u1ec6\u1ec8\u1ec8\u1eca\u1eca\u1ecc\u1ecc" + + "\u1ece\u1ece\u1ed0\u1ed0\u1ed2\u1ed2\u1ed4\u1ed4\u1ed6\u1ed6\u1ed8\u1ed8" + + "\u1eda\u1eda\u1edc\u1edc\u1ede\u1ede\u1ee0\u1ee0\u1ee2\u1ee2\u1ee4\u1ee4" + + "\u1ee6\u1ee6\u1ee8\u1ee8\u1eea\u1eea\u1eec\u1eec\u1eee\u1eee\u1ef0\u1ef0" + + "\u1ef2\u1ef2\u1ef4\u1ef4\u1ef6\u1ef6\u1ef8\u1ef8\u1efa\u1efa\u1efc\u1efc" + + "\u1efe\u1efe\u1f00\u1f00\u1f0a\u1f11\u1f1a\u1f1f\u1f2a\u1f31\u1f3a\u1f41" + + "\u1f4a\u1f4f\u1f5b\u1f5b\u1f5d\u1f5d\u1f5f\u1f5f\u1f61\u1f61\u1f6a\u1f71" + + "\u1fba\u1fbd\u1fca\u1fcd\u1fda\u1fdd\u1fea\u1fee\u1ffa\u1ffd\u2104\u2104" + + "\u2109\u2109\u210d\u210f\u2112\u2114\u2117\u2117\u211b\u211f\u2126\u2126" + + "\u2128\u2128\u212a\u212a\u212c\u212f\u2132\u2135\u2140\u2141\u2147\u2147" + + "\u2185\u2185\u2c02\u2c30\u2c62\u2c62\u2c64\u2c66\u2c69\u2c69\u2c6b\u2c6b" + + "\u2c6d\u2c6d\u2c6f\u2c72\u2c74\u2c74\u2c77\u2c77\u2c80\u2c82\u2c84\u2c84" + + "\u2c86\u2c86\u2c88\u2c88\u2c8a\u2c8a\u2c8c\u2c8c\u2c8e\u2c8e\u2c90\u2c90" + + "\u2c92\u2c92\u2c94\u2c94\u2c96\u2c96\u2c98\u2c98\u2c9a\u2c9a\u2c9c\u2c9c" + + "\u2c9e\u2c9e\u2ca0\u2ca0\u2ca2\u2ca2\u2ca4\u2ca4\u2ca6\u2ca6\u2ca8\u2ca8" + + "\u2caa\u2caa\u2cac\u2cac\u2cae\u2cae\u2cb0\u2cb0\u2cb2\u2cb2\u2cb4\u2cb4" + + "\u2cb6\u2cb6\u2cb8\u2cb8\u2cba\u2cba\u2cbc\u2cbc\u2cbe\u2cbe\u2cc0\u2cc0" + + "\u2cc2\u2cc2\u2cc4\u2cc4\u2cc6\u2cc6\u2cc8\u2cc8\u2cca\u2cca\u2ccc\u2ccc" + + "\u2cce\u2cce\u2cd0\u2cd0\u2cd2\u2cd2\u2cd4\u2cd4\u2cd6\u2cd6\u2cd8\u2cd8" + + "\u2cda\u2cda\u2cdc\u2cdc\u2cde\u2cde\u2ce0\u2ce0\u2ce2\u2ce2\u2ce4\u2ce4" + + "\u2ced\u2ced\u2cef\u2cef\u2cf4\u2cf4\ua642\ua642\ua644\ua644\ua646\ua646" + + "\ua648\ua648\ua64a\ua64a\ua64c\ua64c\ua64e\ua64e\ua650\ua650\ua652\ua652" + + "\ua654\ua654\ua656\ua656\ua658\ua658\ua65a\ua65a\ua65c\ua65c\ua65e\ua65e" + + "\ua660\ua660\ua662\ua662\ua664\ua664\ua666\ua666\ua668\ua668\ua66a\ua66a" + + "\ua66c\ua66c\ua66e\ua66e\ua682\ua682\ua684\ua684\ua686\ua686\ua688\ua688" + + "\ua68a\ua68a\ua68c\ua68c\ua68e\ua68e\ua690\ua690\ua692\ua692\ua694\ua694" + + "\ua696\ua696\ua698\ua698\ua724\ua724\ua726\ua726\ua728\ua728\ua72a\ua72a" + + "\ua72c\ua72c\ua72e\ua72e\ua730\ua730\ua734\ua734\ua736\ua736\ua738\ua738" + + "\ua73a\ua73a\ua73c\ua73c\ua73e\ua73e\ua740\ua740\ua742\ua742\ua744\ua744" + + "\ua746\ua746\ua748\ua748\ua74a\ua74a\ua74c\ua74c\ua74e\ua74e\ua750\ua750" + + "\ua752\ua752\ua754\ua754\ua756\ua756\ua758\ua758\ua75a\ua75a\ua75c\ua75c" + + "\ua75e\ua75e\ua760\ua760\ua762\ua762\ua764\ua764\ua766\ua766\ua768\ua768" + + "\ua76a\ua76a\ua76c\ua76c\ua76e\ua76e\ua770\ua770\ua77b\ua77b\ua77d\ua77d" + + "\ua77f\ua780\ua782\ua782\ua784\ua784\ua786\ua786\ua788\ua788\ua78d\ua78d" + + "\ua78f\ua78f\ua792\ua792\ua794\ua794\ua7a2\ua7a2\ua7a4\ua7a4\ua7a6\ua7a6" + + "\ua7a8\ua7a8\ua7aa\ua7aa\ua7ac\ua7ac\uff23\uff3c%\2\62;\u0662\u066b\u06f2" + + "\u06fb\u07c2\u07cb\u0968\u0971\u09e8\u09f1\u0a68\u0a71\u0ae8\u0af1\u0b68" + + "\u0b71\u0be8\u0bf1\u0c68\u0c71\u0ce8\u0cf1\u0d68\u0d71\u0e52\u0e5b\u0ed2" + + "\u0edb\u0f22\u0f2b\u1042\u104b\u1092\u109b\u17e2\u17eb\u1812\u181b\u1948" + + "\u1951\u19d2\u19db\u1a82\u1a8b\u1a92\u1a9b\u1b52\u1b5b\u1bb2\u1bbb\u1c42" + + "\u1c4b\u1c52\u1c5b\ua622\ua62b\ua8d2\ua8db\ua902\ua90b\ua9d2\ua9db\uaa52" + + "\uaa5b\uabf2\uabfb\uff12\uff1b\t\2\u16f0\u16f2\u2162\u2184\u2187\u218a" + + "\u3009\u3009\u3023\u302b\u303a\u303c\ua6e8\ua6f1\2\36\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" + + "\3\21\3\2\2\2\5\23\3\2\2\2\7\25\3\2\2\2\t\27\3\2\2\2\13\31\3\2\2\2\r\33" + + "\3\2\2\2\17\35\3\2\2\2\21\22\t\2\2\2\22\4\3\2\2\2\23\24\t\3\2\2\24\6\3" + + "\2\2\2\25\26\t\4\2\2\26\b\3\2\2\2\27\30\t\5\2\2\30\n\3\2\2\2\31\32\t\6" + + "\2\2\32\f\3\2\2\2\33\34\t\7\2\2\34\16\3\2\2\2\35\36\t\b\2\2\36\20\3\2" + + "\2\2\3\2\2"; + public static final ATN _ATN = new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache(); + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + public static String[] channelNames = {"DEFAULT_TOKEN_CHANNEL", "HIDDEN"}; + public static String[] modeNames = {"DEFAULT_MODE"}; - protected static final DFA[] _decisionToDFA; - protected static final PredictionContextCache _sharedContextCache = - new PredictionContextCache(); - public static final int - UNICODE_CLASS_LL=1, UNICODE_CLASS_LM=2, UNICODE_CLASS_LO=3, UNICODE_CLASS_LT=4, - UNICODE_CLASS_LU=5, UNICODE_CLASS_ND=6, UNICODE_CLASS_NL=7; - public static String[] channelNames = { - "DEFAULT_TOKEN_CHANNEL", "HIDDEN" - }; + static { + RuntimeMetaData.checkVersion("4.9.3", RuntimeMetaData.VERSION); + } - public static String[] modeNames = { - "DEFAULT_MODE" - }; + 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); + } - private static String[] makeRuleNames() { - return new String[] { - "UNICODE_CLASS_LL", "UNICODE_CLASS_LM", "UNICODE_CLASS_LO", "UNICODE_CLASS_LT", - "UNICODE_CLASS_LU", "UNICODE_CLASS_ND", "UNICODE_CLASS_NL" - }; - } - public static final String[] ruleNames = makeRuleNames(); + if (tokenNames[i] == null) { + tokenNames[i] = ""; + } + } + } - private static String[] makeLiteralNames() { - return new String[] { - }; - } - private static final String[] _LITERAL_NAMES = makeLiteralNames(); - private static String[] makeSymbolicNames() { - return new String[] { - null, "UNICODE_CLASS_LL", "UNICODE_CLASS_LM", "UNICODE_CLASS_LO", "UNICODE_CLASS_LT", - "UNICODE_CLASS_LU", "UNICODE_CLASS_ND", "UNICODE_CLASS_NL" - }; - } - private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); - public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } - /** - * @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); - } + public UnicodeClasses(CharStream input) { + super(input); + _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache); + } - if (tokenNames[i] == null) { - tokenNames[i] = ""; - } - } - } + private static String[] makeRuleNames() { + return new String[] { + "UNICODE_CLASS_LL", + "UNICODE_CLASS_LM", + "UNICODE_CLASS_LO", + "UNICODE_CLASS_LT", + "UNICODE_CLASS_LU", + "UNICODE_CLASS_ND", + "UNICODE_CLASS_NL" + }; + } - @Override - @Deprecated - public String[] getTokenNames() { - return tokenNames; - } + private static String[] makeLiteralNames() { + return new String[] {}; + } - @Override + private static String[] makeSymbolicNames() { + return new String[] { + null, + "UNICODE_CLASS_LL", + "UNICODE_CLASS_LM", + "UNICODE_CLASS_LO", + "UNICODE_CLASS_LT", + "UNICODE_CLASS_LU", + "UNICODE_CLASS_ND", + "UNICODE_CLASS_NL" + }; + } - public Vocabulary getVocabulary() { - return VOCABULARY; - } + @Override + public String[] getRuleNames() { + return ruleNames; + } + @Override + public Vocabulary getVocabulary() { + return VOCABULARY; + } - public UnicodeClasses(CharStream input) { - super(input); - _interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache); - } + @Override + public String getSerializedATN() { + return _serializedATN; + } - @Override - public String getGrammarFileName() { return "UnicodeClasses.g4"; } + @Override + public String getGrammarFileName() { + return "UnicodeClasses.g4"; + } - @Override - public String[] getRuleNames() { return ruleNames; } + @Override + public ATN getATN() { + return _ATN; + } - @Override - public String getSerializedATN() { return _serializedATN; } + @Override + public String[] getChannelNames() { + return channelNames; + } - @Override - public String[] getChannelNames() { return channelNames; } + @Override + public String[] getModeNames() { + return modeNames; + } - @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\t\37\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\3\2\3\2\3\3\3\3\3\4\3"+ - "\4\3\5\3\5\3\6\3\6\3\7\3\7\3\b\3\b\2\2\t\3\3\5\4\7\5\t\6\13\7\r\b\17\t"+ - "\3\2\t\u0248\2c|\u00b7\u00b7\u00e1\u00f8\u00fa\u0101\u0103\u0103\u0105"+ - "\u0105\u0107\u0107\u0109\u0109\u010b\u010b\u010d\u010d\u010f\u010f\u0111"+ - "\u0111\u0113\u0113\u0115\u0115\u0117\u0117\u0119\u0119\u011b\u011b\u011d"+ - "\u011d\u011f\u011f\u0121\u0121\u0123\u0123\u0125\u0125\u0127\u0127\u0129"+ - "\u0129\u012b\u012b\u012d\u012d\u012f\u012f\u0131\u0131\u0133\u0133\u0135"+ - "\u0135\u0137\u0137\u0139\u013a\u013c\u013c\u013e\u013e\u0140\u0140\u0142"+ - "\u0142\u0144\u0144\u0146\u0146\u0148\u0148\u014a\u014b\u014d\u014d\u014f"+ - "\u014f\u0151\u0151\u0153\u0153\u0155\u0155\u0157\u0157\u0159\u0159\u015b"+ - "\u015b\u015d\u015d\u015f\u015f\u0161\u0161\u0163\u0163\u0165\u0165\u0167"+ - "\u0167\u0169\u0169\u016b\u016b\u016d\u016d\u016f\u016f\u0171\u0171\u0173"+ - "\u0173\u0175\u0175\u0177\u0177\u0179\u0179\u017c\u017c\u017e\u017e\u0180"+ - "\u0182\u0185\u0185\u0187\u0187\u018a\u018a\u018e\u018f\u0194\u0194\u0197"+ - "\u0197\u019b\u019d\u01a0\u01a0\u01a3\u01a3\u01a5\u01a5\u01a7\u01a7\u01aa"+ - "\u01aa\u01ac\u01ad\u01af\u01af\u01b2\u01b2\u01b6\u01b6\u01b8\u01b8\u01bb"+ - "\u01bc\u01bf\u01c1\u01c8\u01c8\u01cb\u01cb\u01ce\u01ce\u01d0\u01d0\u01d2"+ - "\u01d2\u01d4\u01d4\u01d6\u01d6\u01d8\u01d8\u01da\u01da\u01dc\u01dc\u01de"+ - "\u01df\u01e1\u01e1\u01e3\u01e3\u01e5\u01e5\u01e7\u01e7\u01e9\u01e9\u01eb"+ - "\u01eb\u01ed\u01ed\u01ef\u01ef\u01f1\u01f2\u01f5\u01f5\u01f7\u01f7\u01fb"+ - "\u01fb\u01fd\u01fd\u01ff\u01ff\u0201\u0201\u0203\u0203\u0205\u0205\u0207"+ - "\u0207\u0209\u0209\u020b\u020b\u020d\u020d\u020f\u020f\u0211\u0211\u0213"+ - "\u0213\u0215\u0215\u0217\u0217\u0219\u0219\u021b\u021b\u021d\u021d\u021f"+ - "\u021f\u0221\u0221\u0223\u0223\u0225\u0225\u0227\u0227\u0229\u0229\u022b"+ - "\u022b\u022d\u022d\u022f\u022f\u0231\u0231\u0233\u0233\u0235\u023b\u023e"+ - "\u023e\u0241\u0242\u0244\u0244\u0249\u0249\u024b\u024b\u024d\u024d\u024f"+ - "\u024f\u0251\u0295\u0297\u02b1\u0373\u0373\u0375\u0375\u0379\u0379\u037d"+ - "\u037f\u0392\u0392\u03ae\u03d0\u03d2\u03d3\u03d7\u03d9\u03db\u03db\u03dd"+ - "\u03dd\u03df\u03df\u03e1\u03e1\u03e3\u03e3\u03e5\u03e5\u03e7\u03e7\u03e9"+ - "\u03e9\u03eb\u03eb\u03ed\u03ed\u03ef\u03ef\u03f1\u03f5\u03f7\u03f7\u03fa"+ - "\u03fa\u03fd\u03fe\u0432\u0461\u0463\u0463\u0465\u0465\u0467\u0467\u0469"+ - "\u0469\u046b\u046b\u046d\u046d\u046f\u046f\u0471\u0471\u0473\u0473\u0475"+ - "\u0475\u0477\u0477\u0479\u0479\u047b\u047b\u047d\u047d\u047f\u047f\u0481"+ - "\u0481\u0483\u0483\u048d\u048d\u048f\u048f\u0491\u0491\u0493\u0493\u0495"+ - "\u0495\u0497\u0497\u0499\u0499\u049b\u049b\u049d\u049d\u049f\u049f\u04a1"+ - "\u04a1\u04a3\u04a3\u04a5\u04a5\u04a7\u04a7\u04a9\u04a9\u04ab\u04ab\u04ad"+ - "\u04ad\u04af\u04af\u04b1\u04b1\u04b3\u04b3\u04b5\u04b5\u04b7\u04b7\u04b9"+ - "\u04b9\u04bb\u04bb\u04bd\u04bd\u04bf\u04bf\u04c1\u04c1\u04c4\u04c4\u04c6"+ - "\u04c6\u04c8\u04c8\u04ca\u04ca\u04cc\u04cc\u04ce\u04ce\u04d0\u04d1\u04d3"+ - "\u04d3\u04d5\u04d5\u04d7\u04d7\u04d9\u04d9\u04db\u04db\u04dd\u04dd\u04df"+ - "\u04df\u04e1\u04e1\u04e3\u04e3\u04e5\u04e5\u04e7\u04e7\u04e9\u04e9\u04eb"+ - "\u04eb\u04ed\u04ed\u04ef\u04ef\u04f1\u04f1\u04f3\u04f3\u04f5\u04f5\u04f7"+ - "\u04f7\u04f9\u04f9\u04fb\u04fb\u04fd\u04fd\u04ff\u04ff\u0501\u0501\u0503"+ - "\u0503\u0505\u0505\u0507\u0507\u0509\u0509\u050b\u050b\u050d\u050d\u050f"+ - "\u050f\u0511\u0511\u0513\u0513\u0515\u0515\u0517\u0517\u0519\u0519\u051b"+ - "\u051b\u051d\u051d\u051f\u051f\u0521\u0521\u0523\u0523\u0525\u0525\u0527"+ - "\u0527\u0529\u0529\u0563\u0589\u1d02\u1d2d\u1d6d\u1d79\u1d7b\u1d9c\u1e03"+ - "\u1e03\u1e05\u1e05\u1e07\u1e07\u1e09\u1e09\u1e0b\u1e0b\u1e0d\u1e0d\u1e0f"+ - "\u1e0f\u1e11\u1e11\u1e13\u1e13\u1e15\u1e15\u1e17\u1e17\u1e19\u1e19\u1e1b"+ - "\u1e1b\u1e1d\u1e1d\u1e1f\u1e1f\u1e21\u1e21\u1e23\u1e23\u1e25\u1e25\u1e27"+ - "\u1e27\u1e29\u1e29\u1e2b\u1e2b\u1e2d\u1e2d\u1e2f\u1e2f\u1e31\u1e31\u1e33"+ - "\u1e33\u1e35\u1e35\u1e37\u1e37\u1e39\u1e39\u1e3b\u1e3b\u1e3d\u1e3d\u1e3f"+ - "\u1e3f\u1e41\u1e41\u1e43\u1e43\u1e45\u1e45\u1e47\u1e47\u1e49\u1e49\u1e4b"+ - "\u1e4b\u1e4d\u1e4d\u1e4f\u1e4f\u1e51\u1e51\u1e53\u1e53\u1e55\u1e55\u1e57"+ - "\u1e57\u1e59\u1e59\u1e5b\u1e5b\u1e5d\u1e5d\u1e5f\u1e5f\u1e61\u1e61\u1e63"+ - "\u1e63\u1e65\u1e65\u1e67\u1e67\u1e69\u1e69\u1e6b\u1e6b\u1e6d\u1e6d\u1e6f"+ - "\u1e6f\u1e71\u1e71\u1e73\u1e73\u1e75\u1e75\u1e77\u1e77\u1e79\u1e79\u1e7b"+ - "\u1e7b\u1e7d\u1e7d\u1e7f\u1e7f\u1e81\u1e81\u1e83\u1e83\u1e85\u1e85\u1e87"+ - "\u1e87\u1e89\u1e89\u1e8b\u1e8b\u1e8d\u1e8d\u1e8f\u1e8f\u1e91\u1e91\u1e93"+ - "\u1e93\u1e95\u1e95\u1e97\u1e9f\u1ea1\u1ea1\u1ea3\u1ea3\u1ea5\u1ea5\u1ea7"+ - "\u1ea7\u1ea9\u1ea9\u1eab\u1eab\u1ead\u1ead\u1eaf\u1eaf\u1eb1\u1eb1\u1eb3"+ - "\u1eb3\u1eb5\u1eb5\u1eb7\u1eb7\u1eb9\u1eb9\u1ebb\u1ebb\u1ebd\u1ebd\u1ebf"+ - "\u1ebf\u1ec1\u1ec1\u1ec3\u1ec3\u1ec5\u1ec5\u1ec7\u1ec7\u1ec9\u1ec9\u1ecb"+ - "\u1ecb\u1ecd\u1ecd\u1ecf\u1ecf\u1ed1\u1ed1\u1ed3\u1ed3\u1ed5\u1ed5\u1ed7"+ - "\u1ed7\u1ed9\u1ed9\u1edb\u1edb\u1edd\u1edd\u1edf\u1edf\u1ee1\u1ee1\u1ee3"+ - "\u1ee3\u1ee5\u1ee5\u1ee7\u1ee7\u1ee9\u1ee9\u1eeb\u1eeb\u1eed\u1eed\u1eef"+ - "\u1eef\u1ef1\u1ef1\u1ef3\u1ef3\u1ef5\u1ef5\u1ef7\u1ef7\u1ef9\u1ef9\u1efb"+ - "\u1efb\u1efd\u1efd\u1eff\u1eff\u1f01\u1f09\u1f12\u1f17\u1f22\u1f29\u1f32"+ - "\u1f39\u1f42\u1f47\u1f52\u1f59\u1f62\u1f69\u1f72\u1f7f\u1f82\u1f89\u1f92"+ - "\u1f99\u1fa2\u1fa9\u1fb2\u1fb6\u1fb8\u1fb9\u1fc0\u1fc0\u1fc4\u1fc6\u1fc8"+ - "\u1fc9\u1fd2\u1fd5\u1fd8\u1fd9\u1fe2\u1fe9\u1ff4\u1ff6\u1ff8\u1ff9\u210c"+ - "\u210c\u2110\u2111\u2115\u2115\u2131\u2131\u2136\u2136\u213b\u213b\u213e"+ - "\u213f\u2148\u214b\u2150\u2150\u2186\u2186\u2c32\u2c60\u2c63\u2c63\u2c67"+ - "\u2c68\u2c6a\u2c6a\u2c6c\u2c6c\u2c6e\u2c6e\u2c73\u2c73\u2c75\u2c76\u2c78"+ - "\u2c7d\u2c83\u2c83\u2c85\u2c85\u2c87\u2c87\u2c89\u2c89\u2c8b\u2c8b\u2c8d"+ - "\u2c8d\u2c8f\u2c8f\u2c91\u2c91\u2c93\u2c93\u2c95\u2c95\u2c97\u2c97\u2c99"+ - "\u2c99\u2c9b\u2c9b\u2c9d\u2c9d\u2c9f\u2c9f\u2ca1\u2ca1\u2ca3\u2ca3\u2ca5"+ - "\u2ca5\u2ca7\u2ca7\u2ca9\u2ca9\u2cab\u2cab\u2cad\u2cad\u2caf\u2caf\u2cb1"+ - "\u2cb1\u2cb3\u2cb3\u2cb5\u2cb5\u2cb7\u2cb7\u2cb9\u2cb9\u2cbb\u2cbb\u2cbd"+ - "\u2cbd\u2cbf\u2cbf\u2cc1\u2cc1\u2cc3\u2cc3\u2cc5\u2cc5\u2cc7\u2cc7\u2cc9"+ - "\u2cc9\u2ccb\u2ccb\u2ccd\u2ccd\u2ccf\u2ccf\u2cd1\u2cd1\u2cd3\u2cd3\u2cd5"+ - "\u2cd5\u2cd7\u2cd7\u2cd9\u2cd9\u2cdb\u2cdb\u2cdd\u2cdd\u2cdf\u2cdf\u2ce1"+ - "\u2ce1\u2ce3\u2ce3\u2ce5\u2ce6\u2cee\u2cee\u2cf0\u2cf0\u2cf5\u2cf5\u2d02"+ - "\u2d27\u2d29\u2d29\u2d2f\u2d2f\ua643\ua643\ua645\ua645\ua647\ua647\ua649"+ - "\ua649\ua64b\ua64b\ua64d\ua64d\ua64f\ua64f\ua651\ua651\ua653\ua653\ua655"+ - "\ua655\ua657\ua657\ua659\ua659\ua65b\ua65b\ua65d\ua65d\ua65f\ua65f\ua661"+ - "\ua661\ua663\ua663\ua665\ua665\ua667\ua667\ua669\ua669\ua66b\ua66b\ua66d"+ - "\ua66d\ua66f\ua66f\ua683\ua683\ua685\ua685\ua687\ua687\ua689\ua689\ua68b"+ - "\ua68b\ua68d\ua68d\ua68f\ua68f\ua691\ua691\ua693\ua693\ua695\ua695\ua697"+ - "\ua697\ua699\ua699\ua725\ua725\ua727\ua727\ua729\ua729\ua72b\ua72b\ua72d"+ - "\ua72d\ua72f\ua72f\ua731\ua733\ua735\ua735\ua737\ua737\ua739\ua739\ua73b"+ - "\ua73b\ua73d\ua73d\ua73f\ua73f\ua741\ua741\ua743\ua743\ua745\ua745\ua747"+ - "\ua747\ua749\ua749\ua74b\ua74b\ua74d\ua74d\ua74f\ua74f\ua751\ua751\ua753"+ - "\ua753\ua755\ua755\ua757\ua757\ua759\ua759\ua75b\ua75b\ua75d\ua75d\ua75f"+ - "\ua75f\ua761\ua761\ua763\ua763\ua765\ua765\ua767\ua767\ua769\ua769\ua76b"+ - "\ua76b\ua76d\ua76d\ua76f\ua76f\ua771\ua771\ua773\ua77a\ua77c\ua77c\ua77e"+ - "\ua77e\ua781\ua781\ua783\ua783\ua785\ua785\ua787\ua787\ua789\ua789\ua78e"+ - "\ua78e\ua790\ua790\ua793\ua793\ua795\ua795\ua7a3\ua7a3\ua7a5\ua7a5\ua7a7"+ - "\ua7a7\ua7a9\ua7a9\ua7ab\ua7ab\ua7fc\ua7fc\ufb02\ufb08\ufb15\ufb19\uff43"+ - "\uff5c\65\2\u02b2\u02c3\u02c8\u02d3\u02e2\u02e6\u02ee\u02ee\u02f0\u02f0"+ - "\u0376\u0376\u037c\u037c\u055b\u055b\u0642\u0642\u06e7\u06e8\u07f6\u07f7"+ - "\u07fc\u07fc\u081c\u081c\u0826\u0826\u082a\u082a\u0973\u0973\u0e48\u0e48"+ - "\u0ec8\u0ec8\u10fe\u10fe\u17d9\u17d9\u1845\u1845\u1aa9\u1aa9\u1c7a\u1c7f"+ - "\u1d2e\u1d6c\u1d7a\u1d7a\u1d9d\u1dc1\u2073\u2073\u2081\u2081\u2092\u209e"+ - "\u2c7e\u2c7f\u2d71\u2d71\u2e31\u2e31\u3007\u3007\u3033\u3037\u303d\u303d"+ - "\u309f\u30a0\u30fe\u3100\ua017\ua017\ua4fa\ua4ff\ua60e\ua60e\ua681\ua681"+ - "\ua719\ua721\ua772\ua772\ua78a\ua78a\ua7fa\ua7fb\ua9d1\ua9d1\uaa72\uaa72"+ - "\uaadf\uaadf\uaaf5\uaaf6\uff72\uff72\uffa0\uffa1\u0123\2\u00ac\u00ac\u00bc"+ - "\u00bc\u01bd\u01bd\u01c2\u01c5\u0296\u0296\u05d2\u05ec\u05f2\u05f4\u0622"+ - "\u0641\u0643\u064c\u0670\u0671\u0673\u06d5\u06d7\u06d7\u06f0\u06f1\u06fc"+ - "\u06fe\u0701\u0701\u0712\u0712\u0714\u0731\u074f\u07a7\u07b3\u07b3\u07cc"+ - "\u07ec\u0802\u0817\u0842\u085a\u08a2\u08a2\u08a4\u08ae\u0906\u093b\u093f"+ - "\u093f\u0952\u0952\u095a\u0963\u0974\u0979\u097b\u0981\u0987\u098e\u0991"+ - "\u0992\u0995\u09aa\u09ac\u09b2\u09b4\u09b4\u09b8\u09bb\u09bf\u09bf\u09d0"+ - "\u09d0\u09de\u09df\u09e1\u09e3\u09f2\u09f3\u0a07\u0a0c\u0a11\u0a12\u0a15"+ - "\u0a2a\u0a2c\u0a32\u0a34\u0a35\u0a37\u0a38\u0a3a\u0a3b\u0a5b\u0a5e\u0a60"+ - "\u0a60\u0a74\u0a76\u0a87\u0a8f\u0a91\u0a93\u0a95\u0aaa\u0aac\u0ab2\u0ab4"+ - "\u0ab5\u0ab7\u0abb\u0abf\u0abf\u0ad2\u0ad2\u0ae2\u0ae3\u0b07\u0b0e\u0b11"+ - "\u0b12\u0b15\u0b2a\u0b2c\u0b32\u0b34\u0b35\u0b37\u0b3b\u0b3f\u0b3f\u0b5e"+ - "\u0b5f\u0b61\u0b63\u0b73\u0b73\u0b85\u0b85\u0b87\u0b8c\u0b90\u0b92\u0b94"+ - "\u0b97\u0b9b\u0b9c\u0b9e\u0b9e\u0ba0\u0ba1\u0ba5\u0ba6\u0baa\u0bac\u0bb0"+ - "\u0bbb\u0bd2\u0bd2\u0c07\u0c0e\u0c10\u0c12\u0c14\u0c2a\u0c2c\u0c35\u0c37"+ - "\u0c3b\u0c3f\u0c3f\u0c5a\u0c5b\u0c62\u0c63\u0c87\u0c8e\u0c90\u0c92\u0c94"+ - "\u0caa\u0cac\u0cb5\u0cb7\u0cbb\u0cbf\u0cbf\u0ce0\u0ce0\u0ce2\u0ce3\u0cf3"+ - "\u0cf4\u0d07\u0d0e\u0d10\u0d12\u0d14\u0d3c\u0d3f\u0d3f\u0d50\u0d50\u0d62"+ - "\u0d63\u0d7c\u0d81\u0d87\u0d98\u0d9c\u0db3\u0db5\u0dbd\u0dbf\u0dbf\u0dc2"+ - "\u0dc8\u0e03\u0e32\u0e34\u0e35\u0e42\u0e47\u0e83\u0e84\u0e86\u0e86\u0e89"+ - "\u0e8a\u0e8c\u0e8c\u0e8f\u0e8f\u0e96\u0e99\u0e9b\u0ea1\u0ea3\u0ea5\u0ea7"+ - "\u0ea7\u0ea9\u0ea9\u0eac\u0ead\u0eaf\u0eb2\u0eb4\u0eb5\u0ebf\u0ebf\u0ec2"+ - "\u0ec6\u0ede\u0ee1\u0f02\u0f02\u0f42\u0f49\u0f4b\u0f6e\u0f8a\u0f8e\u1002"+ - "\u102c\u1041\u1041\u1052\u1057\u105c\u105f\u1063\u1063\u1067\u1068\u1070"+ - "\u1072\u1077\u1083\u1090\u1090\u10d2\u10fc\u10ff\u124a\u124c\u124f\u1252"+ - "\u1258\u125a\u125a\u125c\u125f\u1262\u128a\u128c\u128f\u1292\u12b2\u12b4"+ - "\u12b7\u12ba\u12c0\u12c2\u12c2\u12c4\u12c7\u12ca\u12d8\u12da\u1312\u1314"+ - "\u1317\u131a\u135c\u1382\u1391\u13a2\u13f6\u1403\u166e\u1671\u1681\u1683"+ - "\u169c\u16a2\u16ec\u1702\u170e\u1710\u1713\u1722\u1733\u1742\u1753\u1762"+ - "\u176e\u1770\u1772\u1782\u17b5\u17de\u17de\u1822\u1844\u1846\u1879\u1882"+ - "\u18aa\u18ac\u18ac\u18b2\u18f7\u1902\u191e\u1952\u196f\u1972\u1976\u1982"+ - "\u19ad\u19c3\u19c9\u1a02\u1a18\u1a22\u1a56\u1b07\u1b35\u1b47\u1b4d\u1b85"+ - "\u1ba2\u1bb0\u1bb1\u1bbc\u1be7\u1c02\u1c25\u1c4f\u1c51\u1c5c\u1c79\u1ceb"+ - "\u1cee\u1cf0\u1cf3\u1cf7\u1cf8\u2137\u213a\u2d32\u2d69\u2d82\u2d98\u2da2"+ - "\u2da8\u2daa\u2db0\u2db2\u2db8\u2dba\u2dc0\u2dc2\u2dc8\u2dca\u2dd0\u2dd2"+ - "\u2dd8\u2dda\u2de0\u3008\u3008\u303e\u303e\u3043\u3098\u30a1\u30a1\u30a3"+ - "\u30fc\u3101\u3101\u3107\u312f\u3133\u3190\u31a2\u31bc\u31f2\u3201\u3402"+ - "\u3402\u4db7\u4db7\u4e02\u4e02\u9fce\u9fce\ua002\ua016\ua018\ua48e\ua4d2"+ - "\ua4f9\ua502\ua60d\ua612\ua621\ua62c\ua62d\ua670\ua670\ua6a2\ua6e7\ua7fd"+ - "\ua803\ua805\ua807\ua809\ua80c\ua80e\ua824\ua842\ua875\ua884\ua8b5\ua8f4"+ - "\ua8f9\ua8fd\ua8fd\ua90c\ua927\ua932\ua948\ua962\ua97e\ua986\ua9b4\uaa02"+ - "\uaa2a\uaa42\uaa44\uaa46\uaa4d\uaa62\uaa71\uaa73\uaa78\uaa7c\uaa7c\uaa82"+ - "\uaab1\uaab3\uaab3\uaab7\uaab8\uaabb\uaabf\uaac2\uaac2\uaac4\uaac4\uaadd"+ - "\uaade\uaae2\uaaec\uaaf4\uaaf4\uab03\uab08\uab0b\uab10\uab13\uab18\uab22"+ - "\uab28\uab2a\uab30\uabc2\uabe4\uac02\uac02\ud7a5\ud7a5\ud7b2\ud7c8\ud7cd"+ - "\ud7fd\uf902\ufa6f\ufa72\ufadb\ufb1f\ufb1f\ufb21\ufb2a\ufb2c\ufb38\ufb3a"+ - "\ufb3e\ufb40\ufb40\ufb42\ufb43\ufb45\ufb46\ufb48\ufbb3\ufbd5\ufd3f\ufd52"+ - "\ufd91\ufd94\ufdc9\ufdf2\ufdfd\ufe72\ufe76\ufe78\ufefe\uff68\uff71\uff73"+ - "\uff9f\uffa2\uffc0\uffc4\uffc9\uffcc\uffd1\uffd4\uffd9\uffdc\uffde\f\2"+ - "\u01c7\u01c7\u01ca\u01ca\u01cd\u01cd\u01f4\u01f4\u1f8a\u1f91\u1f9a\u1fa1"+ - "\u1faa\u1fb1\u1fbe\u1fbe\u1fce\u1fce\u1ffe\u1ffe\u0242\2C\\\u00c2\u00d8"+ - "\u00da\u00e0\u0102\u0102\u0104\u0104\u0106\u0106\u0108\u0108\u010a\u010a"+ - "\u010c\u010c\u010e\u010e\u0110\u0110\u0112\u0112\u0114\u0114\u0116\u0116"+ - "\u0118\u0118\u011a\u011a\u011c\u011c\u011e\u011e\u0120\u0120\u0122\u0122"+ - "\u0124\u0124\u0126\u0126\u0128\u0128\u012a\u012a\u012c\u012c\u012e\u012e"+ - "\u0130\u0130\u0132\u0132\u0134\u0134\u0136\u0136\u0138\u0138\u013b\u013b"+ - "\u013d\u013d\u013f\u013f\u0141\u0141\u0143\u0143\u0145\u0145\u0147\u0147"+ - "\u0149\u0149\u014c\u014c\u014e\u014e\u0150\u0150\u0152\u0152\u0154\u0154"+ - "\u0156\u0156\u0158\u0158\u015a\u015a\u015c\u015c\u015e\u015e\u0160\u0160"+ - "\u0162\u0162\u0164\u0164\u0166\u0166\u0168\u0168\u016a\u016a\u016c\u016c"+ - "\u016e\u016e\u0170\u0170\u0172\u0172\u0174\u0174\u0176\u0176\u0178\u0178"+ - "\u017a\u017b\u017d\u017d\u017f\u017f\u0183\u0184\u0186\u0186\u0188\u0189"+ - "\u018b\u018d\u0190\u0193\u0195\u0196\u0198\u019a\u019e\u019f\u01a1\u01a2"+ - "\u01a4\u01a4\u01a6\u01a6\u01a8\u01a9\u01ab\u01ab\u01ae\u01ae\u01b0\u01b1"+ - "\u01b3\u01b5\u01b7\u01b7\u01b9\u01ba\u01be\u01be\u01c6\u01c6\u01c9\u01c9"+ - "\u01cc\u01cc\u01cf\u01cf\u01d1\u01d1\u01d3\u01d3\u01d5\u01d5\u01d7\u01d7"+ - "\u01d9\u01d9\u01db\u01db\u01dd\u01dd\u01e0\u01e0\u01e2\u01e2\u01e4\u01e4"+ - "\u01e6\u01e6\u01e8\u01e8\u01ea\u01ea\u01ec\u01ec\u01ee\u01ee\u01f0\u01f0"+ - "\u01f3\u01f3\u01f6\u01f6\u01f8\u01fa\u01fc\u01fc\u01fe\u01fe\u0200\u0200"+ - "\u0202\u0202\u0204\u0204\u0206\u0206\u0208\u0208\u020a\u020a\u020c\u020c"+ - "\u020e\u020e\u0210\u0210\u0212\u0212\u0214\u0214\u0216\u0216\u0218\u0218"+ - "\u021a\u021a\u021c\u021c\u021e\u021e\u0220\u0220\u0222\u0222\u0224\u0224"+ - "\u0226\u0226\u0228\u0228\u022a\u022a\u022c\u022c\u022e\u022e\u0230\u0230"+ - "\u0232\u0232\u0234\u0234\u023c\u023d\u023f\u0240\u0243\u0243\u0245\u0248"+ - "\u024a\u024a\u024c\u024c\u024e\u024e\u0250\u0250\u0372\u0372\u0374\u0374"+ - "\u0378\u0378\u0388\u0388\u038a\u038c\u038e\u038e\u0390\u0391\u0393\u03a3"+ - "\u03a5\u03ad\u03d1\u03d1\u03d4\u03d6\u03da\u03da\u03dc\u03dc\u03de\u03de"+ - "\u03e0\u03e0\u03e2\u03e2\u03e4\u03e4\u03e6\u03e6\u03e8\u03e8\u03ea\u03ea"+ - "\u03ec\u03ec\u03ee\u03ee\u03f0\u03f0\u03f6\u03f6\u03f9\u03f9\u03fb\u03fc"+ - "\u03ff\u0431\u0462\u0462\u0464\u0464\u0466\u0466\u0468\u0468\u046a\u046a"+ - "\u046c\u046c\u046e\u046e\u0470\u0470\u0472\u0472\u0474\u0474\u0476\u0476"+ - "\u0478\u0478\u047a\u047a\u047c\u047c\u047e\u047e\u0480\u0480\u0482\u0482"+ - "\u048c\u048c\u048e\u048e\u0490\u0490\u0492\u0492\u0494\u0494\u0496\u0496"+ - "\u0498\u0498\u049a\u049a\u049c\u049c\u049e\u049e\u04a0\u04a0\u04a2\u04a2"+ - "\u04a4\u04a4\u04a6\u04a6\u04a8\u04a8\u04aa\u04aa\u04ac\u04ac\u04ae\u04ae"+ - "\u04b0\u04b0\u04b2\u04b2\u04b4\u04b4\u04b6\u04b6\u04b8\u04b8\u04ba\u04ba"+ - "\u04bc\u04bc\u04be\u04be\u04c0\u04c0\u04c2\u04c3\u04c5\u04c5\u04c7\u04c7"+ - "\u04c9\u04c9\u04cb\u04cb\u04cd\u04cd\u04cf\u04cf\u04d2\u04d2\u04d4\u04d4"+ - "\u04d6\u04d6\u04d8\u04d8\u04da\u04da\u04dc\u04dc\u04de\u04de\u04e0\u04e0"+ - "\u04e2\u04e2\u04e4\u04e4\u04e6\u04e6\u04e8\u04e8\u04ea\u04ea\u04ec\u04ec"+ - "\u04ee\u04ee\u04f0\u04f0\u04f2\u04f2\u04f4\u04f4\u04f6\u04f6\u04f8\u04f8"+ - "\u04fa\u04fa\u04fc\u04fc\u04fe\u04fe\u0500\u0500\u0502\u0502\u0504\u0504"+ - "\u0506\u0506\u0508\u0508\u050a\u050a\u050c\u050c\u050e\u050e\u0510\u0510"+ - "\u0512\u0512\u0514\u0514\u0516\u0516\u0518\u0518\u051a\u051a\u051c\u051c"+ - "\u051e\u051e\u0520\u0520\u0522\u0522\u0524\u0524\u0526\u0526\u0528\u0528"+ - "\u0533\u0558\u10a2\u10c7\u10c9\u10c9\u10cf\u10cf\u1e02\u1e02\u1e04\u1e04"+ - "\u1e06\u1e06\u1e08\u1e08\u1e0a\u1e0a\u1e0c\u1e0c\u1e0e\u1e0e\u1e10\u1e10"+ - "\u1e12\u1e12\u1e14\u1e14\u1e16\u1e16\u1e18\u1e18\u1e1a\u1e1a\u1e1c\u1e1c"+ - "\u1e1e\u1e1e\u1e20\u1e20\u1e22\u1e22\u1e24\u1e24\u1e26\u1e26\u1e28\u1e28"+ - "\u1e2a\u1e2a\u1e2c\u1e2c\u1e2e\u1e2e\u1e30\u1e30\u1e32\u1e32\u1e34\u1e34"+ - "\u1e36\u1e36\u1e38\u1e38\u1e3a\u1e3a\u1e3c\u1e3c\u1e3e\u1e3e\u1e40\u1e40"+ - "\u1e42\u1e42\u1e44\u1e44\u1e46\u1e46\u1e48\u1e48\u1e4a\u1e4a\u1e4c\u1e4c"+ - "\u1e4e\u1e4e\u1e50\u1e50\u1e52\u1e52\u1e54\u1e54\u1e56\u1e56\u1e58\u1e58"+ - "\u1e5a\u1e5a\u1e5c\u1e5c\u1e5e\u1e5e\u1e60\u1e60\u1e62\u1e62\u1e64\u1e64"+ - "\u1e66\u1e66\u1e68\u1e68\u1e6a\u1e6a\u1e6c\u1e6c\u1e6e\u1e6e\u1e70\u1e70"+ - "\u1e72\u1e72\u1e74\u1e74\u1e76\u1e76\u1e78\u1e78\u1e7a\u1e7a\u1e7c\u1e7c"+ - "\u1e7e\u1e7e\u1e80\u1e80\u1e82\u1e82\u1e84\u1e84\u1e86\u1e86\u1e88\u1e88"+ - "\u1e8a\u1e8a\u1e8c\u1e8c\u1e8e\u1e8e\u1e90\u1e90\u1e92\u1e92\u1e94\u1e94"+ - "\u1e96\u1e96\u1ea0\u1ea0\u1ea2\u1ea2\u1ea4\u1ea4\u1ea6\u1ea6\u1ea8\u1ea8"+ - "\u1eaa\u1eaa\u1eac\u1eac\u1eae\u1eae\u1eb0\u1eb0\u1eb2\u1eb2\u1eb4\u1eb4"+ - "\u1eb6\u1eb6\u1eb8\u1eb8\u1eba\u1eba\u1ebc\u1ebc\u1ebe\u1ebe\u1ec0\u1ec0"+ - "\u1ec2\u1ec2\u1ec4\u1ec4\u1ec6\u1ec6\u1ec8\u1ec8\u1eca\u1eca\u1ecc\u1ecc"+ - "\u1ece\u1ece\u1ed0\u1ed0\u1ed2\u1ed2\u1ed4\u1ed4\u1ed6\u1ed6\u1ed8\u1ed8"+ - "\u1eda\u1eda\u1edc\u1edc\u1ede\u1ede\u1ee0\u1ee0\u1ee2\u1ee2\u1ee4\u1ee4"+ - "\u1ee6\u1ee6\u1ee8\u1ee8\u1eea\u1eea\u1eec\u1eec\u1eee\u1eee\u1ef0\u1ef0"+ - "\u1ef2\u1ef2\u1ef4\u1ef4\u1ef6\u1ef6\u1ef8\u1ef8\u1efa\u1efa\u1efc\u1efc"+ - "\u1efe\u1efe\u1f00\u1f00\u1f0a\u1f11\u1f1a\u1f1f\u1f2a\u1f31\u1f3a\u1f41"+ - "\u1f4a\u1f4f\u1f5b\u1f5b\u1f5d\u1f5d\u1f5f\u1f5f\u1f61\u1f61\u1f6a\u1f71"+ - "\u1fba\u1fbd\u1fca\u1fcd\u1fda\u1fdd\u1fea\u1fee\u1ffa\u1ffd\u2104\u2104"+ - "\u2109\u2109\u210d\u210f\u2112\u2114\u2117\u2117\u211b\u211f\u2126\u2126"+ - "\u2128\u2128\u212a\u212a\u212c\u212f\u2132\u2135\u2140\u2141\u2147\u2147"+ - "\u2185\u2185\u2c02\u2c30\u2c62\u2c62\u2c64\u2c66\u2c69\u2c69\u2c6b\u2c6b"+ - "\u2c6d\u2c6d\u2c6f\u2c72\u2c74\u2c74\u2c77\u2c77\u2c80\u2c82\u2c84\u2c84"+ - "\u2c86\u2c86\u2c88\u2c88\u2c8a\u2c8a\u2c8c\u2c8c\u2c8e\u2c8e\u2c90\u2c90"+ - "\u2c92\u2c92\u2c94\u2c94\u2c96\u2c96\u2c98\u2c98\u2c9a\u2c9a\u2c9c\u2c9c"+ - "\u2c9e\u2c9e\u2ca0\u2ca0\u2ca2\u2ca2\u2ca4\u2ca4\u2ca6\u2ca6\u2ca8\u2ca8"+ - "\u2caa\u2caa\u2cac\u2cac\u2cae\u2cae\u2cb0\u2cb0\u2cb2\u2cb2\u2cb4\u2cb4"+ - "\u2cb6\u2cb6\u2cb8\u2cb8\u2cba\u2cba\u2cbc\u2cbc\u2cbe\u2cbe\u2cc0\u2cc0"+ - "\u2cc2\u2cc2\u2cc4\u2cc4\u2cc6\u2cc6\u2cc8\u2cc8\u2cca\u2cca\u2ccc\u2ccc"+ - "\u2cce\u2cce\u2cd0\u2cd0\u2cd2\u2cd2\u2cd4\u2cd4\u2cd6\u2cd6\u2cd8\u2cd8"+ - "\u2cda\u2cda\u2cdc\u2cdc\u2cde\u2cde\u2ce0\u2ce0\u2ce2\u2ce2\u2ce4\u2ce4"+ - "\u2ced\u2ced\u2cef\u2cef\u2cf4\u2cf4\ua642\ua642\ua644\ua644\ua646\ua646"+ - "\ua648\ua648\ua64a\ua64a\ua64c\ua64c\ua64e\ua64e\ua650\ua650\ua652\ua652"+ - "\ua654\ua654\ua656\ua656\ua658\ua658\ua65a\ua65a\ua65c\ua65c\ua65e\ua65e"+ - "\ua660\ua660\ua662\ua662\ua664\ua664\ua666\ua666\ua668\ua668\ua66a\ua66a"+ - "\ua66c\ua66c\ua66e\ua66e\ua682\ua682\ua684\ua684\ua686\ua686\ua688\ua688"+ - "\ua68a\ua68a\ua68c\ua68c\ua68e\ua68e\ua690\ua690\ua692\ua692\ua694\ua694"+ - "\ua696\ua696\ua698\ua698\ua724\ua724\ua726\ua726\ua728\ua728\ua72a\ua72a"+ - "\ua72c\ua72c\ua72e\ua72e\ua730\ua730\ua734\ua734\ua736\ua736\ua738\ua738"+ - "\ua73a\ua73a\ua73c\ua73c\ua73e\ua73e\ua740\ua740\ua742\ua742\ua744\ua744"+ - "\ua746\ua746\ua748\ua748\ua74a\ua74a\ua74c\ua74c\ua74e\ua74e\ua750\ua750"+ - "\ua752\ua752\ua754\ua754\ua756\ua756\ua758\ua758\ua75a\ua75a\ua75c\ua75c"+ - "\ua75e\ua75e\ua760\ua760\ua762\ua762\ua764\ua764\ua766\ua766\ua768\ua768"+ - "\ua76a\ua76a\ua76c\ua76c\ua76e\ua76e\ua770\ua770\ua77b\ua77b\ua77d\ua77d"+ - "\ua77f\ua780\ua782\ua782\ua784\ua784\ua786\ua786\ua788\ua788\ua78d\ua78d"+ - "\ua78f\ua78f\ua792\ua792\ua794\ua794\ua7a2\ua7a2\ua7a4\ua7a4\ua7a6\ua7a6"+ - "\ua7a8\ua7a8\ua7aa\ua7aa\ua7ac\ua7ac\uff23\uff3c%\2\62;\u0662\u066b\u06f2"+ - "\u06fb\u07c2\u07cb\u0968\u0971\u09e8\u09f1\u0a68\u0a71\u0ae8\u0af1\u0b68"+ - "\u0b71\u0be8\u0bf1\u0c68\u0c71\u0ce8\u0cf1\u0d68\u0d71\u0e52\u0e5b\u0ed2"+ - "\u0edb\u0f22\u0f2b\u1042\u104b\u1092\u109b\u17e2\u17eb\u1812\u181b\u1948"+ - "\u1951\u19d2\u19db\u1a82\u1a8b\u1a92\u1a9b\u1b52\u1b5b\u1bb2\u1bbb\u1c42"+ - "\u1c4b\u1c52\u1c5b\ua622\ua62b\ua8d2\ua8db\ua902\ua90b\ua9d2\ua9db\uaa52"+ - "\uaa5b\uabf2\uabfb\uff12\uff1b\t\2\u16f0\u16f2\u2162\u2184\u2187\u218a"+ - "\u3009\u3009\u3023\u302b\u303a\u303c\ua6e8\ua6f1\2\36\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"+ - "\3\21\3\2\2\2\5\23\3\2\2\2\7\25\3\2\2\2\t\27\3\2\2\2\13\31\3\2\2\2\r\33"+ - "\3\2\2\2\17\35\3\2\2\2\21\22\t\2\2\2\22\4\3\2\2\2\23\24\t\3\2\2\24\6\3"+ - "\2\2\2\25\26\t\4\2\2\26\b\3\2\2\2\27\30\t\5\2\2\30\n\3\2\2\2\31\32\t\6"+ - "\2\2\32\f\3\2\2\2\33\34\t\7\2\2\34\16\3\2\2\2\35\36\t\b\2\2\36\20\3\2"+ - "\2\2\3\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 + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } +} diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/xml/XMLLexer.java b/lexers/src/main/java/com/itsaky/androidide/lexers/xml/XMLLexer.java index 8acff9bae..cec2537c6 100755 --- a/lexers/src/main/java/com/itsaky/androidide/lexers/xml/XMLLexer.java +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/xml/XMLLexer.java @@ -1,5 +1,4 @@ -// Generated from -// D:/Projects/AndroidStudioProjects/AndroidIDE/lexers/src/main/java/com/itsaky/androidide/lexers/xml\XMLLexer.g4 by ANTLR 4.9.2 +// Generated from XMLLexer.g4 by ANTLR 4.9.3 package com.itsaky.androidide.lexers.xml; import org.antlr.v4.runtime.CharStream; @@ -15,12 +14,6 @@ import org.antlr.v4.runtime.dfa.DFA; @SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) public class XMLLexer extends Lexer { - static { - RuntimeMetaData.checkVersion("4.9.2", RuntimeMetaData.VERSION); - } - - protected static final DFA[] _decisionToDFA; - protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache(); public static final int COLON = 1, COMMENT = 2, CDATA = 3, @@ -42,146 +35,11 @@ public class XMLLexer extends Lexer { S = 19, PI = 20; public static final int INSIDE = 1, PROC_INSTR = 2; - public static String[] channelNames = {"DEFAULT_TOKEN_CHANNEL", "HIDDEN"}; - - public static String[] modeNames = {"DEFAULT_MODE", "INSIDE", "PROC_INSTR"}; - - private static String[] makeRuleNames() { - return new String[] { - "COLON", - "COMMENT", - "CDATA", - "DTD", - "EntityRef", - "CharRef", - "SEA_WS", - "OPEN", - "OPEN_SLASH", - "XMLDeclOpen", - "SPECIAL_OPEN", - "TEXT", - "CLOSE", - "SPECIAL_CLOSE", - "SLASH_CLOSE", - "SLASH", - "EQUALS", - "STRING", - "Name", - "S", - "HEXDIGIT", - "DIGIT", - "NameChar", - "NameStartChar", - "PI", - "IGNORE" - }; - } - public static final String[] ruleNames = makeRuleNames(); - - private static String[] makeLiteralNames() { - return new String[] { - null, "':'", null, null, null, null, null, null, "'<'", "''", null, - "'/>'", "'/'", "'='" - }; - } - - private static final String[] _LITERAL_NAMES = makeLiteralNames(); - - private static String[] makeSymbolicNames() { - return new String[] { - null, - "COLON", - "COMMENT", - "CDATA", - "DTD", - "EntityRef", - "CharRef", - "SEA_WS", - "OPEN", - "OPEN_SLASH", - "XMLDeclOpen", - "TEXT", - "CLOSE", - "SPECIAL_CLOSE", - "SLASH_CLOSE", - "SLASH", - "EQUALS", - "STRING", - "Name", - "S", - "PI" - }; - } - - 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 XMLLexer(CharStream input) { - super(input); - _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache); - } - - @Override - public String getGrammarFileName() { - return "XMLLexer.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\26\u00f4\b\1\b\1" + "\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" @@ -264,6 +122,31 @@ public class XMLLexer extends Lexer { + "8\3\2\2\2\25\2\3\4CWdu\u0080\u0084\u0088\u008b\u008d\u00ad\u00c5\u00cd" + "\u00d1\u00d7\u00e6\u00e9\7\b\2\2\7\3\2\5\2\2\7\4\2\6\2\2"; public static final ATN _ATN = new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache(); + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + public static String[] channelNames = {"DEFAULT_TOKEN_CHANNEL", "HIDDEN"}; + public static String[] modeNames = {"DEFAULT_MODE", "INSIDE", "PROC_INSTR"}; + + static { + RuntimeMetaData.checkVersion("4.9.3", RuntimeMetaData.VERSION); + } + + 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] = ""; + } + } + } static { _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; @@ -271,4 +154,114 @@ public class XMLLexer extends Lexer { _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); } } + + public XMLLexer(CharStream input) { + super(input); + _interp = new LexerATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache); + } + + private static String[] makeRuleNames() { + return new String[] { + "COLON", + "COMMENT", + "CDATA", + "DTD", + "EntityRef", + "CharRef", + "SEA_WS", + "OPEN", + "OPEN_SLASH", + "XMLDeclOpen", + "SPECIAL_OPEN", + "TEXT", + "CLOSE", + "SPECIAL_CLOSE", + "SLASH_CLOSE", + "SLASH", + "EQUALS", + "STRING", + "Name", + "S", + "HEXDIGIT", + "DIGIT", + "NameChar", + "NameStartChar", + "PI", + "IGNORE" + }; + } + + private static String[] makeLiteralNames() { + return new String[] { + null, "':'", null, null, null, null, null, null, "'<'", "''", null, + "'/>'", "'/'", "'='" + }; + } + + private static String[] makeSymbolicNames() { + return new String[] { + null, + "COLON", + "COMMENT", + "CDATA", + "DTD", + "EntityRef", + "CharRef", + "SEA_WS", + "OPEN", + "OPEN_SLASH", + "XMLDeclOpen", + "TEXT", + "CLOSE", + "SPECIAL_CLOSE", + "SLASH_CLOSE", + "SLASH", + "EQUALS", + "STRING", + "Name", + "S", + "PI" + }; + } + + @Override + public String[] getRuleNames() { + return ruleNames; + } + + @Override + public Vocabulary getVocabulary() { + return VOCABULARY; + } + + @Override + public String getSerializedATN() { + return _serializedATN; + } + + @Override + public String getGrammarFileName() { + return "XMLLexer.g4"; + } + + @Override + public ATN getATN() { + return _ATN; + } + + @Override + public String[] getChannelNames() { + return channelNames; + } + + @Override + public String[] getModeNames() { + return modeNames; + } + + @Override + @Deprecated + public String[] getTokenNames() { + return tokenNames; + } } diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/xml/XMLParser.java b/lexers/src/main/java/com/itsaky/androidide/lexers/xml/XMLParser.java index 667b91548..9b17a15bd 100644 --- a/lexers/src/main/java/com/itsaky/androidide/lexers/xml/XMLParser.java +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/xml/XMLParser.java @@ -1,5 +1,4 @@ -// Generated from -// D:/Projects/AndroidStudioProjects/AndroidIDE/lexers/src/main/java/com/itsaky/androidide/lexers/xml\XMLParser.g4 by ANTLR 4.9.2 +// Generated from XMLParser.g4 by ANTLR 4.9.3 package com.itsaky.androidide.lexers.xml; import org.antlr.v4.runtime.NoViableAltException; @@ -24,12 +23,6 @@ import java.util.List; @SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"}) public class XMLParser extends Parser { - static { - RuntimeMetaData.checkVersion("4.9.2", RuntimeMetaData.VERSION); - } - - protected static final DFA[] _decisionToDFA; - protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache(); public static final int COLON = 1, COMMENT = 2, CDATA = 3, @@ -61,6 +54,76 @@ public class XMLParser extends Parser { RULE_prefix = 8, RULE_chardata = 9, RULE_misc = 10; + public static final String[] ruleNames = makeRuleNames(); + /** + * @deprecated Use {@link #VOCABULARY} instead. + */ + @Deprecated public static final String[] tokenNames; + public static final String _serializedATN = + "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\26p\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\3\2\5\2\32\n\2\3\2\7\2\35\n\2\f\2\16\2 \13\2\3\2\3\2\7\2$\n\2\f" + + "\2\16\2\'\13\2\3\3\3\3\7\3+\n\3\f\3\16\3.\13\3\3\3\3\3\3\4\5\4\63\n\4" + + "\3\4\3\4\3\4\3\4\3\4\5\4:\n\4\3\4\5\4=\n\4\7\4?\n\4\f\4\16\4B\13\4\3\5" + + "\3\5\5\5F\n\5\3\6\3\6\3\6\7\6K\n\6\f\6\16\6N\13\6\3\6\3\6\3\6\3\6\3\6" + + "\3\6\3\7\3\7\3\7\7\7Y\n\7\f\7\16\7\\\13\7\3\7\3\7\3\b\3\b\3\t\5\tc\n\t" + + "\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\13\3\13\3\f\3\f\3\f\2\2\r\2\4\6\b\n\f\16" + + "\20\22\24\26\2\5\3\2\7\b\4\2\t\t\r\r\5\2\4\4\t\t\26\26\2s\2\31\3\2\2\2" + + "\4(\3\2\2\2\6\62\3\2\2\2\bE\3\2\2\2\nG\3\2\2\2\fU\3\2\2\2\16_\3\2\2\2" + + "\20b\3\2\2\2\22h\3\2\2\2\24k\3\2\2\2\26m\3\2\2\2\30\32\5\4\3\2\31\30\3" + + "\2\2\2\31\32\3\2\2\2\32\36\3\2\2\2\33\35\5\26\f\2\34\33\3\2\2\2\35 \3" + + "\2\2\2\36\34\3\2\2\2\36\37\3\2\2\2\37!\3\2\2\2 \36\3\2\2\2!%\5\b\5\2\"" + + "$\5\26\f\2#\"\3\2\2\2$\'\3\2\2\2%#\3\2\2\2%&\3\2\2\2&\3\3\2\2\2\'%\3\2" + + "\2\2(,\7\f\2\2)+\5\20\t\2*)\3\2\2\2+.\3\2\2\2,*\3\2\2\2,-\3\2\2\2-/\3" + + "\2\2\2.,\3\2\2\2/\60\7\17\2\2\60\5\3\2\2\2\61\63\5\24\13\2\62\61\3\2\2" + + "\2\62\63\3\2\2\2\63@\3\2\2\2\64:\5\b\5\2\65:\5\16\b\2\66:\7\5\2\2\67:" + + "\7\26\2\28:\7\4\2\29\64\3\2\2\29\65\3\2\2\29\66\3\2\2\29\67\3\2\2\298" + + "\3\2\2\2:<\3\2\2\2;=\5\24\13\2<;\3\2\2\2<=\3\2\2\2=?\3\2\2\2>9\3\2\2\2" + + "?B\3\2\2\2@>\3\2\2\2@A\3\2\2\2A\7\3\2\2\2B@\3\2\2\2CF\5\n\6\2DF\5\f\7" + + "\2EC\3\2\2\2ED\3\2\2\2F\t\3\2\2\2GH\7\n\2\2HL\7\24\2\2IK\5\20\t\2JI\3" + + "\2\2\2KN\3\2\2\2LJ\3\2\2\2LM\3\2\2\2MO\3\2\2\2NL\3\2\2\2OP\7\16\2\2PQ" + + "\5\6\4\2QR\7\13\2\2RS\7\24\2\2ST\7\16\2\2T\13\3\2\2\2UV\7\n\2\2VZ\7\24" + + "\2\2WY\5\20\t\2XW\3\2\2\2Y\\\3\2\2\2ZX\3\2\2\2Z[\3\2\2\2[]\3\2\2\2\\Z" + + "\3\2\2\2]^\7\20\2\2^\r\3\2\2\2_`\t\2\2\2`\17\3\2\2\2ac\5\22\n\2ba\3\2" + + "\2\2bc\3\2\2\2cd\3\2\2\2de\7\24\2\2ef\7\22\2\2fg\7\23\2\2g\21\3\2\2\2" + + "hi\7\24\2\2ij\7\3\2\2j\23\3\2\2\2kl\t\3\2\2l\25\3\2\2\2mn\t\4\2\2n\27" + + "\3\2\2\2\16\31\36%,\629<@ELZb"; + public static final ATN _ATN = new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + protected static final DFA[] _decisionToDFA; + protected static final PredictionContextCache _sharedContextCache = new PredictionContextCache(); + private static final String[] _LITERAL_NAMES = makeLiteralNames(); + private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames(); + public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES); + + static { + RuntimeMetaData.checkVersion("4.9.3", RuntimeMetaData.VERSION); + } + + 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] = ""; + } + } + } + + static { + _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; + for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { + _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + } + } + + public XMLParser(TokenStream input) { + super(input); + _interp = new ParserATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache); + } private static String[] makeRuleNames() { return new String[] { @@ -70,8 +133,6 @@ public class XMLParser extends Parser { }; } - public static final String[] ruleNames = makeRuleNames(); - private static String[] makeLiteralNames() { return new String[] { null, "':'", null, null, null, null, null, null, "'<'", "''", null, @@ -79,8 +140,6 @@ public class XMLParser extends Parser { }; } - private static final String[] _LITERAL_NAMES = makeLiteralNames(); - private static String[] makeSymbolicNames() { return new String[] { null, @@ -107,108 +166,37 @@ public class XMLParser extends Parser { }; } - 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 "XMLParser.g4"; - } - @Override public String[] getRuleNames() { return ruleNames; } + @Override + public Vocabulary getVocabulary() { + return VOCABULARY; + } + @Override public String getSerializedATN() { return _serializedATN; } + @Override + public String getGrammarFileName() { + return "XMLParser.g4"; + } + @Override public ATN getATN() { return _ATN; } - public XMLParser(TokenStream input) { - super(input); - _interp = new ParserATNSimulator(this, _ATN, _decisionToDFA, _sharedContextCache); - } - - public static class DocumentContext extends ParserRuleContext { - public ElementContext element() { - return getRuleContext(ElementContext.class, 0); - } - - public PrologContext prolog() { - return getRuleContext(PrologContext.class, 0); - } - - public List misc() { - return getRuleContexts(MiscContext.class); - } - - public MiscContext misc(int i) { - return getRuleContext(MiscContext.class, i); - } - - public DocumentContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_document; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof XMLParserListener) ((XMLParserListener) listener).enterDocument(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof XMLParserListener) ((XMLParserListener) listener).exitDocument(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof XMLParserVisitor) - return ((XMLParserVisitor) visitor).visitDocument(this); - else return visitor.visitChildren(this); - } - } - public final DocumentContext document() throws RecognitionException { DocumentContext _localctx = new DocumentContext(_ctx, getState()); enterRule(_localctx, 0, RULE_document); @@ -269,50 +257,6 @@ public class XMLParser extends Parser { return _localctx; } - public static class PrologContext extends ParserRuleContext { - public TerminalNode XMLDeclOpen() { - return getToken(XMLParser.XMLDeclOpen, 0); - } - - public TerminalNode SPECIAL_CLOSE() { - return getToken(XMLParser.SPECIAL_CLOSE, 0); - } - - public List attribute() { - return getRuleContexts(AttributeContext.class); - } - - public AttributeContext attribute(int i) { - return getRuleContext(AttributeContext.class, i); - } - - public PrologContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_prolog; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof XMLParserListener) ((XMLParserListener) listener).enterProlog(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof XMLParserListener) ((XMLParserListener) listener).exitProlog(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof XMLParserVisitor) - return ((XMLParserVisitor) visitor).visitProlog(this); - else return visitor.visitChildren(this); - } - } - public final PrologContext prolog() throws RecognitionException { PrologContext _localctx = new PrologContext(_ctx, getState()); enterRule(_localctx, 2, RULE_prolog); @@ -349,82 +293,6 @@ public class XMLParser extends Parser { return _localctx; } - public static class ContentContext extends ParserRuleContext { - public List chardata() { - return getRuleContexts(ChardataContext.class); - } - - public ChardataContext chardata(int i) { - return getRuleContext(ChardataContext.class, i); - } - - public List element() { - return getRuleContexts(ElementContext.class); - } - - public ElementContext element(int i) { - return getRuleContext(ElementContext.class, i); - } - - public List reference() { - return getRuleContexts(ReferenceContext.class); - } - - public ReferenceContext reference(int i) { - return getRuleContext(ReferenceContext.class, i); - } - - public List CDATA() { - return getTokens(XMLParser.CDATA); - } - - public TerminalNode CDATA(int i) { - return getToken(XMLParser.CDATA, i); - } - - public List PI() { - return getTokens(XMLParser.PI); - } - - public TerminalNode PI(int i) { - return getToken(XMLParser.PI, i); - } - - public List COMMENT() { - return getTokens(XMLParser.COMMENT); - } - - public TerminalNode COMMENT(int i) { - return getToken(XMLParser.COMMENT, i); - } - - public ContentContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_content; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof XMLParserListener) ((XMLParserListener) listener).enterContent(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof XMLParserListener) ((XMLParserListener) listener).exitContent(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof XMLParserVisitor) - return ((XMLParserVisitor) visitor).visitContent(this); - else return visitor.visitChildren(this); - } - } - public final ContentContext content() throws RecognitionException { ContentContext _localctx = new ContentContext(_ctx, getState()); enterRule(_localctx, 4, RULE_content); @@ -519,42 +387,6 @@ public class XMLParser extends Parser { return _localctx; } - public static class ElementContext extends ParserRuleContext { - public NonEmptyClosingElementContext nonEmptyClosingElement() { - return getRuleContext(NonEmptyClosingElementContext.class, 0); - } - - public EmptyClosingElementContext emptyClosingElement() { - return getRuleContext(EmptyClosingElementContext.class, 0); - } - - public ElementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_element; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof XMLParserListener) ((XMLParserListener) listener).enterElement(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof XMLParserListener) ((XMLParserListener) listener).exitElement(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof XMLParserVisitor) - return ((XMLParserVisitor) visitor).visitElement(this); - else return visitor.visitChildren(this); - } - } - public final ElementContext element() throws RecognitionException { ElementContext _localctx = new ElementContext(_ctx, getState()); enterRule(_localctx, 6, RULE_element); @@ -587,72 +419,6 @@ public class XMLParser extends Parser { return _localctx; } - public static class NonEmptyClosingElementContext extends ParserRuleContext { - public TerminalNode OPEN() { - return getToken(XMLParser.OPEN, 0); - } - - public List Name() { - return getTokens(XMLParser.Name); - } - - public TerminalNode Name(int i) { - return getToken(XMLParser.Name, i); - } - - public List CLOSE() { - return getTokens(XMLParser.CLOSE); - } - - public TerminalNode CLOSE(int i) { - return getToken(XMLParser.CLOSE, i); - } - - public ContentContext content() { - return getRuleContext(ContentContext.class, 0); - } - - public TerminalNode OPEN_SLASH() { - return getToken(XMLParser.OPEN_SLASH, 0); - } - - public List attribute() { - return getRuleContexts(AttributeContext.class); - } - - public AttributeContext attribute(int i) { - return getRuleContext(AttributeContext.class, i); - } - - public NonEmptyClosingElementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_nonEmptyClosingElement; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof XMLParserListener) - ((XMLParserListener) listener).enterNonEmptyClosingElement(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof XMLParserListener) - ((XMLParserListener) listener).exitNonEmptyClosingElement(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof XMLParserVisitor) - return ((XMLParserVisitor) visitor).visitNonEmptyClosingElement(this); - else return visitor.visitChildren(this); - } - } - public final NonEmptyClosingElementContext nonEmptyClosingElement() throws RecognitionException { NonEmptyClosingElementContext _localctx = new NonEmptyClosingElementContext(_ctx, getState()); enterRule(_localctx, 8, RULE_nonEmptyClosingElement); @@ -699,56 +465,6 @@ public class XMLParser extends Parser { return _localctx; } - public static class EmptyClosingElementContext extends ParserRuleContext { - public TerminalNode OPEN() { - return getToken(XMLParser.OPEN, 0); - } - - public TerminalNode Name() { - return getToken(XMLParser.Name, 0); - } - - public TerminalNode SLASH_CLOSE() { - return getToken(XMLParser.SLASH_CLOSE, 0); - } - - public List attribute() { - return getRuleContexts(AttributeContext.class); - } - - public AttributeContext attribute(int i) { - return getRuleContext(AttributeContext.class, i); - } - - public EmptyClosingElementContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_emptyClosingElement; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof XMLParserListener) - ((XMLParserListener) listener).enterEmptyClosingElement(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof XMLParserListener) - ((XMLParserListener) listener).exitEmptyClosingElement(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof XMLParserVisitor) - return ((XMLParserVisitor) visitor).visitEmptyClosingElement(this); - else return visitor.visitChildren(this); - } - } - public final EmptyClosingElementContext emptyClosingElement() throws RecognitionException { EmptyClosingElementContext _localctx = new EmptyClosingElementContext(_ctx, getState()); enterRule(_localctx, 10, RULE_emptyClosingElement); @@ -787,43 +503,6 @@ public class XMLParser extends Parser { return _localctx; } - public static class ReferenceContext extends ParserRuleContext { - public TerminalNode EntityRef() { - return getToken(XMLParser.EntityRef, 0); - } - - public TerminalNode CharRef() { - return getToken(XMLParser.CharRef, 0); - } - - public ReferenceContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_reference; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof XMLParserListener) - ((XMLParserListener) listener).enterReference(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof XMLParserListener) ((XMLParserListener) listener).exitReference(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof XMLParserVisitor) - return ((XMLParserVisitor) visitor).visitReference(this); - else return visitor.visitChildren(this); - } - } - public final ReferenceContext reference() throws RecognitionException { ReferenceContext _localctx = new ReferenceContext(_ctx, getState()); enterRule(_localctx, 12, RULE_reference); @@ -851,51 +530,6 @@ public class XMLParser extends Parser { return _localctx; } - public static class AttributeContext extends ParserRuleContext { - public TerminalNode Name() { - return getToken(XMLParser.Name, 0); - } - - public TerminalNode EQUALS() { - return getToken(XMLParser.EQUALS, 0); - } - - public TerminalNode STRING() { - return getToken(XMLParser.STRING, 0); - } - - public PrefixContext prefix() { - return getRuleContext(PrefixContext.class, 0); - } - - public AttributeContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_attribute; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof XMLParserListener) - ((XMLParserListener) listener).enterAttribute(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof XMLParserListener) ((XMLParserListener) listener).exitAttribute(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof XMLParserVisitor) - return ((XMLParserVisitor) visitor).visitAttribute(this); - else return visitor.visitChildren(this); - } - } - public final AttributeContext attribute() throws RecognitionException { AttributeContext _localctx = new AttributeContext(_ctx, getState()); enterRule(_localctx, 14, RULE_attribute); @@ -929,42 +563,6 @@ public class XMLParser extends Parser { return _localctx; } - public static class PrefixContext extends ParserRuleContext { - public TerminalNode Name() { - return getToken(XMLParser.Name, 0); - } - - public TerminalNode COLON() { - return getToken(XMLParser.COLON, 0); - } - - public PrefixContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_prefix; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof XMLParserListener) ((XMLParserListener) listener).enterPrefix(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof XMLParserListener) ((XMLParserListener) listener).exitPrefix(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof XMLParserVisitor) - return ((XMLParserVisitor) visitor).visitPrefix(this); - else return visitor.visitChildren(this); - } - } - public final PrefixContext prefix() throws RecognitionException { PrefixContext _localctx = new PrefixContext(_ctx, getState()); enterRule(_localctx, 16, RULE_prefix); @@ -986,42 +584,6 @@ public class XMLParser extends Parser { return _localctx; } - public static class ChardataContext extends ParserRuleContext { - public TerminalNode TEXT() { - return getToken(XMLParser.TEXT, 0); - } - - public TerminalNode SEA_WS() { - return getToken(XMLParser.SEA_WS, 0); - } - - public ChardataContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_chardata; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof XMLParserListener) ((XMLParserListener) listener).enterChardata(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof XMLParserListener) ((XMLParserListener) listener).exitChardata(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof XMLParserVisitor) - return ((XMLParserVisitor) visitor).visitChardata(this); - else return visitor.visitChildren(this); - } - } - public final ChardataContext chardata() throws RecognitionException { ChardataContext _localctx = new ChardataContext(_ctx, getState()); enterRule(_localctx, 18, RULE_chardata); @@ -1049,46 +611,6 @@ public class XMLParser extends Parser { return _localctx; } - public static class MiscContext extends ParserRuleContext { - public TerminalNode COMMENT() { - return getToken(XMLParser.COMMENT, 0); - } - - public TerminalNode PI() { - return getToken(XMLParser.PI, 0); - } - - public TerminalNode SEA_WS() { - return getToken(XMLParser.SEA_WS, 0); - } - - public MiscContext(ParserRuleContext parent, int invokingState) { - super(parent, invokingState); - } - - @Override - public int getRuleIndex() { - return RULE_misc; - } - - @Override - public void enterRule(ParseTreeListener listener) { - if (listener instanceof XMLParserListener) ((XMLParserListener) listener).enterMisc(this); - } - - @Override - public void exitRule(ParseTreeListener listener) { - if (listener instanceof XMLParserListener) ((XMLParserListener) listener).exitMisc(this); - } - - @Override - public T accept(ParseTreeVisitor visitor) { - if (visitor instanceof XMLParserVisitor) - return ((XMLParserVisitor) visitor).visitMisc(this); - else return visitor.visitChildren(this); - } - } - public final MiscContext misc() throws RecognitionException { MiscContext _localctx = new MiscContext(_ctx, getState()); enterRule(_localctx, 20, RULE_misc); @@ -1117,41 +639,513 @@ public class XMLParser extends Parser { return _localctx; } - public static final String _serializedATN = - "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\26p\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\3\2\5\2\32\n\2\3\2\7\2\35\n\2\f\2\16\2 \13\2\3\2\3\2\7\2$\n\2\f" - + "\2\16\2\'\13\2\3\3\3\3\7\3+\n\3\f\3\16\3.\13\3\3\3\3\3\3\4\5\4\63\n\4" - + "\3\4\3\4\3\4\3\4\3\4\5\4:\n\4\3\4\5\4=\n\4\7\4?\n\4\f\4\16\4B\13\4\3\5" - + "\3\5\5\5F\n\5\3\6\3\6\3\6\7\6K\n\6\f\6\16\6N\13\6\3\6\3\6\3\6\3\6\3\6" - + "\3\6\3\7\3\7\3\7\7\7Y\n\7\f\7\16\7\\\13\7\3\7\3\7\3\b\3\b\3\t\5\tc\n\t" - + "\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\13\3\13\3\f\3\f\3\f\2\2\r\2\4\6\b\n\f\16" - + "\20\22\24\26\2\5\3\2\7\b\4\2\t\t\r\r\5\2\4\4\t\t\26\26\2s\2\31\3\2\2\2" - + "\4(\3\2\2\2\6\62\3\2\2\2\bE\3\2\2\2\nG\3\2\2\2\fU\3\2\2\2\16_\3\2\2\2" - + "\20b\3\2\2\2\22h\3\2\2\2\24k\3\2\2\2\26m\3\2\2\2\30\32\5\4\3\2\31\30\3" - + "\2\2\2\31\32\3\2\2\2\32\36\3\2\2\2\33\35\5\26\f\2\34\33\3\2\2\2\35 \3" - + "\2\2\2\36\34\3\2\2\2\36\37\3\2\2\2\37!\3\2\2\2 \36\3\2\2\2!%\5\b\5\2\"" - + "$\5\26\f\2#\"\3\2\2\2$\'\3\2\2\2%#\3\2\2\2%&\3\2\2\2&\3\3\2\2\2\'%\3\2" - + "\2\2(,\7\f\2\2)+\5\20\t\2*)\3\2\2\2+.\3\2\2\2,*\3\2\2\2,-\3\2\2\2-/\3" - + "\2\2\2.,\3\2\2\2/\60\7\17\2\2\60\5\3\2\2\2\61\63\5\24\13\2\62\61\3\2\2" - + "\2\62\63\3\2\2\2\63@\3\2\2\2\64:\5\b\5\2\65:\5\16\b\2\66:\7\5\2\2\67:" - + "\7\26\2\28:\7\4\2\29\64\3\2\2\29\65\3\2\2\29\66\3\2\2\29\67\3\2\2\298" - + "\3\2\2\2:<\3\2\2\2;=\5\24\13\2<;\3\2\2\2<=\3\2\2\2=?\3\2\2\2>9\3\2\2\2" - + "?B\3\2\2\2@>\3\2\2\2@A\3\2\2\2A\7\3\2\2\2B@\3\2\2\2CF\5\n\6\2DF\5\f\7" - + "\2EC\3\2\2\2ED\3\2\2\2F\t\3\2\2\2GH\7\n\2\2HL\7\24\2\2IK\5\20\t\2JI\3" - + "\2\2\2KN\3\2\2\2LJ\3\2\2\2LM\3\2\2\2MO\3\2\2\2NL\3\2\2\2OP\7\16\2\2PQ" - + "\5\6\4\2QR\7\13\2\2RS\7\24\2\2ST\7\16\2\2T\13\3\2\2\2UV\7\n\2\2VZ\7\24" - + "\2\2WY\5\20\t\2XW\3\2\2\2Y\\\3\2\2\2ZX\3\2\2\2Z[\3\2\2\2[]\3\2\2\2\\Z" - + "\3\2\2\2]^\7\20\2\2^\r\3\2\2\2_`\t\2\2\2`\17\3\2\2\2ac\5\22\n\2ba\3\2" - + "\2\2bc\3\2\2\2cd\3\2\2\2de\7\24\2\2ef\7\22\2\2fg\7\23\2\2g\21\3\2\2\2" - + "hi\7\24\2\2ij\7\3\2\2j\23\3\2\2\2kl\t\3\2\2l\25\3\2\2\2mn\t\4\2\2n\27" - + "\3\2\2\2\16\31\36%,\629<@ELZb"; - public static final ATN _ATN = new ATNDeserializer().deserialize(_serializedATN.toCharArray()); + public static class DocumentContext extends ParserRuleContext { + public DocumentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } - static { - _decisionToDFA = new DFA[_ATN.getNumberOfDecisions()]; - for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) { - _decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i); + public ElementContext element() { + return getRuleContext(ElementContext.class, 0); + } + + public PrologContext prolog() { + return getRuleContext(PrologContext.class, 0); + } + + public List misc() { + return getRuleContexts(MiscContext.class); + } + + public MiscContext misc(int i) { + return getRuleContext(MiscContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_document; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof XMLParserVisitor) + return ((XMLParserVisitor) visitor).visitDocument(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof XMLParserListener) ((XMLParserListener) listener).enterDocument(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof XMLParserListener) ((XMLParserListener) listener).exitDocument(this); + } + } + + public static class PrologContext extends ParserRuleContext { + public PrologContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode XMLDeclOpen() { + return getToken(XMLParser.XMLDeclOpen, 0); + } + + public TerminalNode SPECIAL_CLOSE() { + return getToken(XMLParser.SPECIAL_CLOSE, 0); + } + + public List attribute() { + return getRuleContexts(AttributeContext.class); + } + + public AttributeContext attribute(int i) { + return getRuleContext(AttributeContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_prolog; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof XMLParserVisitor) + return ((XMLParserVisitor) visitor).visitProlog(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof XMLParserListener) ((XMLParserListener) listener).enterProlog(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof XMLParserListener) ((XMLParserListener) listener).exitProlog(this); + } + } + + public static class ContentContext extends ParserRuleContext { + public ContentContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public List chardata() { + return getRuleContexts(ChardataContext.class); + } + + public ChardataContext chardata(int i) { + return getRuleContext(ChardataContext.class, i); + } + + public List element() { + return getRuleContexts(ElementContext.class); + } + + public ElementContext element(int i) { + return getRuleContext(ElementContext.class, i); + } + + public List reference() { + return getRuleContexts(ReferenceContext.class); + } + + public ReferenceContext reference(int i) { + return getRuleContext(ReferenceContext.class, i); + } + + public List CDATA() { + return getTokens(XMLParser.CDATA); + } + + public TerminalNode CDATA(int i) { + return getToken(XMLParser.CDATA, i); + } + + public List PI() { + return getTokens(XMLParser.PI); + } + + public TerminalNode PI(int i) { + return getToken(XMLParser.PI, i); + } + + public List COMMENT() { + return getTokens(XMLParser.COMMENT); + } + + public TerminalNode COMMENT(int i) { + return getToken(XMLParser.COMMENT, i); + } + + @Override + public int getRuleIndex() { + return RULE_content; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof XMLParserVisitor) + return ((XMLParserVisitor) visitor).visitContent(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof XMLParserListener) ((XMLParserListener) listener).enterContent(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof XMLParserListener) ((XMLParserListener) listener).exitContent(this); + } + } + + public static class ElementContext extends ParserRuleContext { + public ElementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public NonEmptyClosingElementContext nonEmptyClosingElement() { + return getRuleContext(NonEmptyClosingElementContext.class, 0); + } + + public EmptyClosingElementContext emptyClosingElement() { + return getRuleContext(EmptyClosingElementContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_element; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof XMLParserVisitor) + return ((XMLParserVisitor) visitor).visitElement(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof XMLParserListener) ((XMLParserListener) listener).enterElement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof XMLParserListener) ((XMLParserListener) listener).exitElement(this); + } + } + + public static class NonEmptyClosingElementContext extends ParserRuleContext { + public NonEmptyClosingElementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode OPEN() { + return getToken(XMLParser.OPEN, 0); + } + + public List Name() { + return getTokens(XMLParser.Name); + } + + public TerminalNode Name(int i) { + return getToken(XMLParser.Name, i); + } + + public List CLOSE() { + return getTokens(XMLParser.CLOSE); + } + + public TerminalNode CLOSE(int i) { + return getToken(XMLParser.CLOSE, i); + } + + public ContentContext content() { + return getRuleContext(ContentContext.class, 0); + } + + public TerminalNode OPEN_SLASH() { + return getToken(XMLParser.OPEN_SLASH, 0); + } + + public List attribute() { + return getRuleContexts(AttributeContext.class); + } + + public AttributeContext attribute(int i) { + return getRuleContext(AttributeContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_nonEmptyClosingElement; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof XMLParserVisitor) + return ((XMLParserVisitor) visitor).visitNonEmptyClosingElement(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof XMLParserListener) + ((XMLParserListener) listener).enterNonEmptyClosingElement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof XMLParserListener) + ((XMLParserListener) listener).exitNonEmptyClosingElement(this); + } + } + + public static class EmptyClosingElementContext extends ParserRuleContext { + public EmptyClosingElementContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode OPEN() { + return getToken(XMLParser.OPEN, 0); + } + + public TerminalNode Name() { + return getToken(XMLParser.Name, 0); + } + + public TerminalNode SLASH_CLOSE() { + return getToken(XMLParser.SLASH_CLOSE, 0); + } + + public List attribute() { + return getRuleContexts(AttributeContext.class); + } + + public AttributeContext attribute(int i) { + return getRuleContext(AttributeContext.class, i); + } + + @Override + public int getRuleIndex() { + return RULE_emptyClosingElement; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof XMLParserVisitor) + return ((XMLParserVisitor) visitor).visitEmptyClosingElement(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof XMLParserListener) + ((XMLParserListener) listener).enterEmptyClosingElement(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof XMLParserListener) + ((XMLParserListener) listener).exitEmptyClosingElement(this); + } + } + + public static class ReferenceContext extends ParserRuleContext { + public ReferenceContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode EntityRef() { + return getToken(XMLParser.EntityRef, 0); + } + + public TerminalNode CharRef() { + return getToken(XMLParser.CharRef, 0); + } + + @Override + public int getRuleIndex() { + return RULE_reference; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof XMLParserVisitor) + return ((XMLParserVisitor) visitor).visitReference(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof XMLParserListener) + ((XMLParserListener) listener).enterReference(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof XMLParserListener) ((XMLParserListener) listener).exitReference(this); + } + } + + public static class AttributeContext extends ParserRuleContext { + public AttributeContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Name() { + return getToken(XMLParser.Name, 0); + } + + public TerminalNode EQUALS() { + return getToken(XMLParser.EQUALS, 0); + } + + public TerminalNode STRING() { + return getToken(XMLParser.STRING, 0); + } + + public PrefixContext prefix() { + return getRuleContext(PrefixContext.class, 0); + } + + @Override + public int getRuleIndex() { + return RULE_attribute; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof XMLParserVisitor) + return ((XMLParserVisitor) visitor).visitAttribute(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof XMLParserListener) + ((XMLParserListener) listener).enterAttribute(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof XMLParserListener) ((XMLParserListener) listener).exitAttribute(this); + } + } + + public static class PrefixContext extends ParserRuleContext { + public PrefixContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode Name() { + return getToken(XMLParser.Name, 0); + } + + public TerminalNode COLON() { + return getToken(XMLParser.COLON, 0); + } + + @Override + public int getRuleIndex() { + return RULE_prefix; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof XMLParserVisitor) + return ((XMLParserVisitor) visitor).visitPrefix(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof XMLParserListener) ((XMLParserListener) listener).enterPrefix(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof XMLParserListener) ((XMLParserListener) listener).exitPrefix(this); + } + } + + public static class ChardataContext extends ParserRuleContext { + public ChardataContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode TEXT() { + return getToken(XMLParser.TEXT, 0); + } + + public TerminalNode SEA_WS() { + return getToken(XMLParser.SEA_WS, 0); + } + + @Override + public int getRuleIndex() { + return RULE_chardata; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof XMLParserVisitor) + return ((XMLParserVisitor) visitor).visitChardata(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof XMLParserListener) ((XMLParserListener) listener).enterChardata(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof XMLParserListener) ((XMLParserListener) listener).exitChardata(this); + } + } + + public static class MiscContext extends ParserRuleContext { + public MiscContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + + public TerminalNode COMMENT() { + return getToken(XMLParser.COMMENT, 0); + } + + public TerminalNode PI() { + return getToken(XMLParser.PI, 0); + } + + public TerminalNode SEA_WS() { + return getToken(XMLParser.SEA_WS, 0); + } + + @Override + public int getRuleIndex() { + return RULE_misc; + } + + @Override + public T accept(ParseTreeVisitor visitor) { + if (visitor instanceof XMLParserVisitor) + return ((XMLParserVisitor) visitor).visitMisc(this); + else return visitor.visitChildren(this); + } + + @Override + public void enterRule(ParseTreeListener listener) { + if (listener instanceof XMLParserListener) ((XMLParserListener) listener).enterMisc(this); + } + + @Override + public void exitRule(ParseTreeListener listener) { + if (listener instanceof XMLParserListener) ((XMLParserListener) listener).exitMisc(this); } } } diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/xml/XMLParserBaseListener.java b/lexers/src/main/java/com/itsaky/androidide/lexers/xml/XMLParserBaseListener.java index 7c0805e04..b916dfc4c 100644 --- a/lexers/src/main/java/com/itsaky/androidide/lexers/xml/XMLParserBaseListener.java +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/xml/XMLParserBaseListener.java @@ -1,5 +1,4 @@ -// Generated from -// D:/Projects/AndroidStudioProjects/AndroidIDE/lexers/src/main/java/com/itsaky/androidide/lexers/xml\XMLParser.g4 by ANTLR 4.9.2 +// Generated from XMLParser.g4 by ANTLR 4.9.3 package com.itsaky.androidide.lexers.xml; import org.antlr.v4.runtime.ParserRuleContext; @@ -166,20 +165,6 @@ public class XMLParserBaseListener implements XMLParserListener { @Override public void exitMisc(XMLParser.MiscContext ctx) {} - /** - * {@inheritDoc} - * - *

The default implementation does nothing. - */ - @Override - public void enterEveryRule(ParserRuleContext ctx) {} - /** - * {@inheritDoc} - * - *

The default implementation does nothing. - */ - @Override - public void exitEveryRule(ParserRuleContext ctx) {} /** * {@inheritDoc} * @@ -187,6 +172,7 @@ public class XMLParserBaseListener implements XMLParserListener { */ @Override public void visitTerminal(TerminalNode node) {} + /** * {@inheritDoc} * @@ -194,4 +180,20 @@ public class XMLParserBaseListener implements XMLParserListener { */ @Override public void visitErrorNode(ErrorNode node) {} + + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void enterEveryRule(ParserRuleContext ctx) {} + + /** + * {@inheritDoc} + * + *

The default implementation does nothing. + */ + @Override + public void exitEveryRule(ParserRuleContext ctx) {} } diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/xml/XMLParserBaseVisitor.java b/lexers/src/main/java/com/itsaky/androidide/lexers/xml/XMLParserBaseVisitor.java index 934661eca..a577d7d13 100644 --- a/lexers/src/main/java/com/itsaky/androidide/lexers/xml/XMLParserBaseVisitor.java +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/xml/XMLParserBaseVisitor.java @@ -1,5 +1,4 @@ -// Generated from -// D:/Projects/AndroidStudioProjects/AndroidIDE/lexers/src/main/java/com/itsaky/androidide/lexers/xml\XMLParser.g4 by ANTLR 4.9.2 +// Generated from XMLParser.g4 by ANTLR 4.9.3 package com.itsaky.androidide.lexers.xml; import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor; diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/xml/XMLParserListener.java b/lexers/src/main/java/com/itsaky/androidide/lexers/xml/XMLParserListener.java index 2ac6ac9b0..3026456c5 100644 --- a/lexers/src/main/java/com/itsaky/androidide/lexers/xml/XMLParserListener.java +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/xml/XMLParserListener.java @@ -1,5 +1,4 @@ -// Generated from -// D:/Projects/AndroidStudioProjects/AndroidIDE/lexers/src/main/java/com/itsaky/androidide/lexers/xml\XMLParser.g4 by ANTLR 4.9.2 +// Generated from XMLParser.g4 by ANTLR 4.9.3 package com.itsaky.androidide.lexers.xml; import org.antlr.v4.runtime.tree.ParseTreeListener; diff --git a/lexers/src/main/java/com/itsaky/androidide/lexers/xml/XMLParserVisitor.java b/lexers/src/main/java/com/itsaky/androidide/lexers/xml/XMLParserVisitor.java index 592cb2cc5..28c0f7961 100644 --- a/lexers/src/main/java/com/itsaky/androidide/lexers/xml/XMLParserVisitor.java +++ b/lexers/src/main/java/com/itsaky/androidide/lexers/xml/XMLParserVisitor.java @@ -1,5 +1,4 @@ -// Generated from -// D:/Projects/AndroidStudioProjects/AndroidIDE/lexers/src/main/java/com/itsaky/androidide/lexers/xml\XMLParser.g4 by ANTLR 4.9.2 +// Generated from XMLParser.g4 by ANTLR 4.9.3 package com.itsaky.androidide.lexers.xml; import org.antlr.v4.runtime.tree.ParseTreeVisitor; diff --git a/lsp/java/src/main/java/org/netbeans/lib/nbjavac/services/CancelService.java b/lsp/java/src/main/java/org/netbeans/lib/nbjavac/services/CancelService.java index c5c8ff954..245f16f8b 100644 --- a/lsp/java/src/main/java/org/netbeans/lib/nbjavac/services/CancelService.java +++ b/lsp/java/src/main/java/org/netbeans/lib/nbjavac/services/CancelService.java @@ -29,7 +29,8 @@ import com.sun.tools.javac.util.Context; public class CancelService { /** The context key for the parameter name resolver. */ - protected static final Context.Key cancelServiceKey = new Context.Key<>(); + protected static final Context.Key cancelServiceKey = + new Context.Key<>(); @NonNull public static CancelService instance(@NonNull Context context) { diff --git a/lsp/java/src/main/java/org/netbeans/lib/nbjavac/services/NBParserFactory.java b/lsp/java/src/main/java/org/netbeans/lib/nbjavac/services/NBParserFactory.java index 1eef550e2..8294f9ee5 100644 --- a/lsp/java/src/main/java/org/netbeans/lib/nbjavac/services/NBParserFactory.java +++ b/lsp/java/src/main/java/org/netbeans/lib/nbjavac/services/NBParserFactory.java @@ -43,9 +43,7 @@ import com.sun.tools.javac.util.Position; public class NBParserFactory extends ParserFactory { public static void preRegister(Context context) { - context.put( - parserFactoryKey, - (Context.Factory) NBParserFactory::new); + context.put(parserFactoryKey, (Context.Factory) NBParserFactory::new); } private final ScannerFactory scannerFactory;