# Generated from StraceParser.g4 by ANTLR 4.8
# encoding: utf-8
from antlr4 import *
from io import StringIO
import sys
if sys.version_info[1] > 5:
	from typing import TextIO
else:
	from typing.io import TextIO


def serializedATN():
    with StringIO() as buf:
        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3;")
        buf.write("\u0158\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
        buf.write("\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")
        buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
        buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
        buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\3\2\7\2:\n\2\f\2\16")
        buf.write("\2=\13\2\3\2\7\2@\n\2\f\2\16\2C\13\2\3\2\5\2F\n\2\3\2")
        buf.write("\7\2I\n\2\f\2\16\2L\13\2\3\3\5\3O\n\3\3\3\3\3\3\3\5\3")
        buf.write("T\n\3\3\3\3\3\3\4\3\4\5\4Z\n\4\3\4\3\4\3\4\3\4\5\4`\n")
        buf.write("\4\3\4\3\4\3\4\3\4\5\4f\n\4\3\4\5\4i\n\4\3\4\3\4\5\4m")
        buf.write("\n\4\3\5\3\5\3\5\3\6\3\6\3\6\7\6u\n\6\f\6\16\6x\13\6\3")
        buf.write("\6\3\6\5\6|\n\6\3\7\3\7\5\7\u0080\n\7\3\b\3\b\3\b\3\b")
        buf.write("\3\t\3\t\3\t\3\t\5\t\u008a\n\t\3\n\5\n\u008d\n\n\3\n\3")
        buf.write("\n\3\13\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\3\f\3")
        buf.write("\f\3\f\5\f\u009e\n\f\3\r\3\r\5\r\u00a2\n\r\3\r\3\r\5\r")
        buf.write("\u00a6\n\r\3\r\5\r\u00a9\n\r\3\16\3\16\3\16\3\16\3\16")
        buf.write("\3\16\3\16\3\16\3\16\5\16\u00b4\n\16\3\17\3\17\3\17\3")
        buf.write("\20\3\20\5\20\u00bb\n\20\3\20\7\20\u00be\n\20\f\20\16")
        buf.write("\20\u00c1\13\20\3\20\5\20\u00c4\n\20\3\20\5\20\u00c7\n")
        buf.write("\20\3\21\5\21\u00ca\n\21\3\21\3\21\5\21\u00ce\n\21\3\21")
        buf.write("\3\21\5\21\u00d2\n\21\3\21\3\21\5\21\u00d6\n\21\3\21\3")
        buf.write("\21\3\21\5\21\u00db\n\21\3\21\5\21\u00de\n\21\3\22\3\22")
        buf.write("\3\22\6\22\u00e3\n\22\r\22\16\22\u00e4\3\22\3\22\3\22")
        buf.write("\3\22\6\22\u00eb\n\22\r\22\16\22\u00ec\3\22\3\22\3\22")
        buf.write("\3\22\3\22\3\22\3\22\3\22\5\22\u00f7\n\22\3\22\3\22\3")
        buf.write("\22\3\22\3\22\3\22\3\22\5\22\u0100\n\22\3\22\3\22\3\22")
        buf.write("\3\22\3\22\6\22\u0107\n\22\r\22\16\22\u0108\3\22\3\22")
        buf.write("\3\22\5\22\u010e\n\22\3\23\3\23\3\23\3\23\3\23\3\23\3")
        buf.write("\23\3\24\3\24\3\24\3\24\5\24\u011b\n\24\3\24\3\24\5\24")
        buf.write("\u011f\n\24\3\24\3\24\3\25\3\25\3\25\3\25\5\25\u0127\n")
        buf.write("\25\3\25\3\25\3\26\3\26\3\27\3\27\3\27\3\27\3\27\3\27")
        buf.write("\3\30\3\30\3\30\3\30\3\30\3\31\3\31\3\31\6\31\u013b\n")
        buf.write("\31\r\31\16\31\u013c\3\32\3\32\3\32\3\32\3\32\6\32\u0144")
        buf.write("\n\32\r\32\16\32\u0145\3\32\3\32\3\32\3\33\3\33\3\33\5")
        buf.write("\33\u014e\n\33\3\33\5\33\u0151\n\33\3\34\6\34\u0154\n")
        buf.write("\34\r\34\16\34\u0155\3\34\3\u0155\2\35\2\4\6\b\n\f\16")
        buf.write("\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\66\2\6\4\2")
        buf.write("\23\23\34\34\3\2\678\4\2\37\37##\3\2\6\6\2\u0177\2;\3")
        buf.write("\2\2\2\4N\3\2\2\2\6l\3\2\2\2\bn\3\2\2\2\nq\3\2\2\2\f\177")
        buf.write("\3\2\2\2\16\u0081\3\2\2\2\20\u0085\3\2\2\2\22\u008c\3")
        buf.write("\2\2\2\24\u0090\3\2\2\2\26\u009d\3\2\2\2\30\u00a8\3\2")
        buf.write("\2\2\32\u00b3\3\2\2\2\34\u00b5\3\2\2\2\36\u00b8\3\2\2")
        buf.write("\2 \u00dd\3\2\2\2\"\u010d\3\2\2\2$\u010f\3\2\2\2&\u0116")
        buf.write("\3\2\2\2(\u0122\3\2\2\2*\u012a\3\2\2\2,\u012c\3\2\2\2")
        buf.write(".\u0132\3\2\2\2\60\u0137\3\2\2\2\62\u013e\3\2\2\2\64\u014d")
        buf.write("\3\2\2\2\66\u0153\3\2\2\28:\7\6\2\298\3\2\2\2:=\3\2\2")
        buf.write("\2;9\3\2\2\2;<\3\2\2\2<A\3\2\2\2=;\3\2\2\2>@\5\4\3\2?")
        buf.write(">\3\2\2\2@C\3\2\2\2A?\3\2\2\2AB\3\2\2\2BE\3\2\2\2CA\3")
        buf.write("\2\2\2DF\7\17\2\2ED\3\2\2\2EF\3\2\2\2FJ\3\2\2\2GI\7\6")
        buf.write("\2\2HG\3\2\2\2IL\3\2\2\2JH\3\2\2\2JK\3\2\2\2K\3\3\2\2")
        buf.write("\2LJ\3\2\2\2MO\7\37\2\2NM\3\2\2\2NO\3\2\2\2OS\3\2\2\2")
        buf.write("PT\5\6\4\2QT\5\24\13\2RT\5\26\f\2SP\3\2\2\2SQ\3\2\2\2")
        buf.write("SR\3\2\2\2TU\3\2\2\2UV\7\6\2\2V\5\3\2\2\2WY\5\b\5\2XZ")
        buf.write("\5\n\6\2YX\3\2\2\2YZ\3\2\2\2Z[\3\2\2\2[\\\5\16\b\2\\m")
        buf.write("\3\2\2\2]_\5\b\5\2^`\5\n\6\2_^\3\2\2\2_`\3\2\2\2`a\3\2")
        buf.write("\2\2ab\5\22\n\2bm\3\2\2\2ce\5\20\t\2df\5\34\17\2ed\3\2")
        buf.write("\2\2ef\3\2\2\2fh\3\2\2\2gi\5\n\6\2hg\3\2\2\2hi\3\2\2\2")
        buf.write("ij\3\2\2\2jk\5\16\b\2km\3\2\2\2lW\3\2\2\2l]\3\2\2\2lc")
        buf.write("\3\2\2\2m\7\3\2\2\2no\7#\2\2op\7\20\2\2p\t\3\2\2\2qv\5")
        buf.write("\f\7\2rs\7\23\2\2su\5\f\7\2tr\3\2\2\2ux\3\2\2\2vt\3\2")
        buf.write("\2\2vw\3\2\2\2w{\3\2\2\2xv\3\2\2\2yz\7\23\2\2z|\7\"\2")
        buf.write("\2{y\3\2\2\2{|\3\2\2\2|\13\3\2\2\2}\u0080\5\30\r\2~\u0080")
        buf.write("\7\4\2\2\177}\3\2\2\2\177~\3\2\2\2\u0080\r\3\2\2\2\u0081")
        buf.write("\u0082\7\21\2\2\u0082\u0083\7\22\2\2\u0083\u0084\5\64")
        buf.write("\33\2\u0084\17\3\2\2\2\u0085\u0086\7\7\2\2\u0086\u0087")
        buf.write("\7#\2\2\u0087\u0089\7\b\2\2\u0088\u008a\7\23\2\2\u0089")
        buf.write("\u0088\3\2\2\2\u0089\u008a\3\2\2\2\u008a\21\3\2\2\2\u008b")
        buf.write("\u008d\7\23\2\2\u008c\u008b\3\2\2\2\u008c\u008d\3\2\2")
        buf.write("\2\u008d\u008e\3\2\2\2\u008e\u008f\7\t\2\2\u008f\23\3")
        buf.write("\2\2\2\u0090\u0091\7\13\2\2\u0091\u0092\7#\2\2\u0092\u0093")
        buf.write("\5 \21\2\u0093\u0094\7\13\2\2\u0094\25\3\2\2\2\u0095\u0096")
        buf.write("\7\f\2\2\u0096\u0097\7\r\2\2\u0097\u0098\7\37\2\2\u0098")
        buf.write("\u009e\7\f\2\2\u0099\u009a\7\f\2\2\u009a\u009b\7\16\2")
        buf.write("\2\u009b\u009c\7#\2\2\u009c\u009e\7\f\2\2\u009d\u0095")
        buf.write("\3\2\2\2\u009d\u0099\3\2\2\2\u009e\27\3\2\2\2\u009f\u00a0")
        buf.write("\7#\2\2\u00a0\u00a2\7\22\2\2\u00a1\u009f\3\2\2\2\u00a1")
        buf.write("\u00a2\3\2\2\2\u00a2\u00a3\3\2\2\2\u00a3\u00a5\5\32\16")
        buf.write("\2\u00a4\u00a6\5\34\17\2\u00a5\u00a4\3\2\2\2\u00a5\u00a6")
        buf.write("\3\2\2\2\u00a6\u00a9\3\2\2\2\u00a7\u00a9\5\34\17\2\u00a8")
        buf.write("\u00a1\3\2\2\2\u00a8\u00a7\3\2\2\2\u00a9\31\3\2\2\2\u00aa")
        buf.write("\u00b4\5 \21\2\u00ab\u00b4\5\"\22\2\u00ac\u00b4\5.\30")
        buf.write("\2\u00ad\u00b4\5\60\31\2\u00ae\u00b4\5\62\32\2\u00af\u00b4")
        buf.write("\7\36\2\2\u00b0\u00b4\7\37\2\2\u00b1\u00b4\7$\2\2\u00b2")
        buf.write("\u00b4\7#\2\2\u00b3\u00aa\3\2\2\2\u00b3\u00ab\3\2\2\2")
        buf.write("\u00b3\u00ac\3\2\2\2\u00b3\u00ad\3\2\2\2\u00b3\u00ae\3")
        buf.write("\2\2\2\u00b3\u00af\3\2\2\2\u00b3\u00b0\3\2\2\2\u00b3\u00b1")
        buf.write("\3\2\2\2\u00b3\u00b2\3\2\2\2\u00b4\33\3\2\2\2\u00b5\u00b6")
        buf.write("\7\35\2\2\u00b6\u00b7\5\30\r\2\u00b7\35\3\2\2\2\u00b8")
        buf.write("\u00bf\5\30\r\2\u00b9\u00bb\t\2\2\2\u00ba\u00b9\3\2\2")
        buf.write("\2\u00ba\u00bb\3\2\2\2\u00bb\u00bc\3\2\2\2\u00bc\u00be")
        buf.write("\5\30\r\2\u00bd\u00ba\3\2\2\2\u00be\u00c1\3\2\2\2\u00bf")
        buf.write("\u00bd\3\2\2\2\u00bf\u00c0\3\2\2\2\u00c0\u00c6\3\2\2\2")
        buf.write("\u00c1\u00bf\3\2\2\2\u00c2\u00c4\7\23\2\2\u00c3\u00c2")
        buf.write("\3\2\2\2\u00c3\u00c4\3\2\2\2\u00c4\u00c5\3\2\2\2\u00c5")
        buf.write("\u00c7\7\"\2\2\u00c6\u00c3\3\2\2\2\u00c6\u00c7\3\2\2\2")
        buf.write("\u00c7\37\3\2\2\2\u00c8\u00ca\7\25\2\2\u00c9\u00c8\3\2")
        buf.write("\2\2\u00c9\u00ca\3\2\2\2\u00ca\u00cb\3\2\2\2\u00cb\u00cd")
        buf.write("\7\26\2\2\u00cc\u00ce\5\36\20\2\u00cd\u00cc\3\2\2\2\u00cd")
        buf.write("\u00ce\3\2\2\2\u00ce\u00cf\3\2\2\2\u00cf\u00de\7\27\2")
        buf.write("\2\u00d0\u00d2\7\25\2\2\u00d1\u00d0\3\2\2\2\u00d1\u00d2")
        buf.write("\3\2\2\2\u00d2\u00d3\3\2\2\2\u00d3\u00d5\7\20\2\2\u00d4")
        buf.write("\u00d6\5\36\20\2\u00d5\u00d4\3\2\2\2\u00d5\u00d6\3\2\2")
        buf.write("\2\u00d6\u00d7\3\2\2\2\u00d7\u00de\7\21\2\2\u00d8\u00da")
        buf.write("\7\30\2\2\u00d9\u00db\5\36\20\2\u00da\u00d9\3\2\2\2\u00da")
        buf.write("\u00db\3\2\2\2\u00db\u00dc\3\2\2\2\u00dc\u00de\7\31\2")
        buf.write("\2\u00dd\u00c9\3\2\2\2\u00dd\u00d1\3\2\2\2\u00dd\u00d8")
        buf.write("\3\2\2\2\u00de!\3\2\2\2\u00df\u00e0\7\37\2\2\u00e0\u00e2")
        buf.write("\7\32\2\2\u00e1\u00e3\7+\2\2\u00e2\u00e1\3\2\2\2\u00e3")
        buf.write("\u00e4\3\2\2\2\u00e4\u00e2\3\2\2\2\u00e4\u00e5\3\2\2\2")
        buf.write("\u00e5\u00e6\3\2\2\2\u00e6\u010e\7\'\2\2\u00e7\u00e8\7")
        buf.write("\37\2\2\u00e8\u00ea\7\32\2\2\u00e9\u00eb\7+\2\2\u00ea")
        buf.write("\u00e9\3\2\2\2\u00eb\u00ec\3\2\2\2\u00ec\u00ea\3\2\2\2")
        buf.write("\u00ec\u00ed\3\2\2\2\u00ed\u00ee\3\2\2\2\u00ee\u00ef\5")
        buf.write("$\23\2\u00ef\u00f0\7\'\2\2\u00f0\u010e\3\2\2\2\u00f1\u00f2")
        buf.write("\7\37\2\2\u00f2\u00f3\7\32\2\2\u00f3\u00f6\7)\2\2\u00f4")
        buf.write("\u00f7\5&\24\2\u00f5\u00f7\5(\25\2\u00f6\u00f4\3\2\2\2")
        buf.write("\u00f6\u00f5\3\2\2\2\u00f7\u00f8\3\2\2\2\u00f8\u00f9\7")
        buf.write("\'\2\2\u00f9\u010e\3\2\2\2\u00fa\u00fb\7\37\2\2\u00fb")
        buf.write("\u00fc\7\32\2\2\u00fc\u00ff\7*\2\2\u00fd\u0100\5&\24\2")
        buf.write("\u00fe\u0100\5,\27\2\u00ff\u00fd\3\2\2\2\u00ff\u00fe\3")
        buf.write("\2\2\2\u0100\u0101\3\2\2\2\u0101\u0102\7\'\2\2\u0102\u010e")
        buf.write("\3\2\2\2\u0103\u0104\7\37\2\2\u0104\u0106\7\32\2\2\u0105")
        buf.write("\u0107\7+\2\2\u0106\u0105\3\2\2\2\u0107\u0108\3\2\2\2")
        buf.write("\u0108\u0106\3\2\2\2\u0108\u0109\3\2\2\2\u0109\u010a\3")
        buf.write("\2\2\2\u010a\u010b\5&\24\2\u010b\u010c\7\'\2\2\u010c\u010e")
        buf.write("\3\2\2\2\u010d\u00df\3\2\2\2\u010d\u00e7\3\2\2\2\u010d")
        buf.write("\u00f1\3\2\2\2\u010d\u00fa\3\2\2\2\u010d\u0103\3\2\2\2")
        buf.write("\u010e#\3\2\2\2\u010f\u0110\7&\2\2\u0110\u0111\7\60\2")
        buf.write("\2\u0111\u0112\7/\2\2\u0112\u0113\7.\2\2\u0113\u0114\7")
        buf.write("/\2\2\u0114\u0115\7-\2\2\u0115%\3\2\2\2\u0116\u0117\7")
        buf.write("(\2\2\u0117\u011a\7\66\2\2\u0118\u0119\7\65\2\2\u0119")
        buf.write("\u011b\7\66\2\2\u011a\u0118\3\2\2\2\u011a\u011b\3\2\2")
        buf.write("\2\u011b\u011e\3\2\2\2\u011c\u011d\7\64\2\2\u011d\u011f")
        buf.write("\7;\2\2\u011e\u011c\3\2\2\2\u011e\u011f\3\2\2\2\u011f")
        buf.write("\u0120\3\2\2\2\u0120\u0121\7\62\2\2\u0121\'\3\2\2\2\u0122")
        buf.write("\u0123\7(\2\2\u0123\u0126\5*\26\2\u0124\u0125\7\65\2\2")
        buf.write("\u0125\u0127\5*\26\2\u0126\u0124\3\2\2\2\u0126\u0127\3")
        buf.write("\2\2\2\u0127\u0128\3\2\2\2\u0128\u0129\7\62\2\2\u0129")
        buf.write(")\3\2\2\2\u012a\u012b\t\3\2\2\u012b+\3\2\2\2\u012c\u012d")
        buf.write("\7(\2\2\u012d\u012e\7:\2\2\u012e\u012f\7\63\2\2\u012f")
        buf.write("\u0130\7\66\2\2\u0130\u0131\7\62\2\2\u0131-\3\2\2\2\u0132")
        buf.write("\u0133\7#\2\2\u0133\u0134\7\20\2\2\u0134\u0135\5\36\20")
        buf.write("\2\u0135\u0136\7\21\2\2\u0136/\3\2\2\2\u0137\u013a\t\4")
        buf.write("\2\2\u0138\u0139\7!\2\2\u0139\u013b\t\4\2\2\u013a\u0138")
        buf.write("\3\2\2\2\u013b\u013c\3\2\2\2\u013c\u013a\3\2\2\2\u013c")
        buf.write("\u013d\3\2\2\2\u013d\61\3\2\2\2\u013e\u013f\7\26\2\2\u013f")
        buf.write("\u0140\7\30\2\2\u0140\u0143\5\30\r\2\u0141\u0142\7 \2")
        buf.write("\2\u0142\u0144\5\30\r\2\u0143\u0141\3\2\2\2\u0144\u0145")
        buf.write("\3\2\2\2\u0145\u0143\3\2\2\2\u0145\u0146\3\2\2\2\u0146")
        buf.write("\u0147\3\2\2\2\u0147\u0148\7\31\2\2\u0148\u0149\7\27\2")
        buf.write("\2\u0149\63\3\2\2\2\u014a\u014e\7\37\2\2\u014b\u014e\7")
        buf.write("\24\2\2\u014c\u014e\5\"\22\2\u014d\u014a\3\2\2\2\u014d")
        buf.write("\u014b\3\2\2\2\u014d\u014c\3\2\2\2\u014e\u0150\3\2\2\2")
        buf.write("\u014f\u0151\5\66\34\2\u0150\u014f\3\2\2\2\u0150\u0151")
        buf.write("\3\2\2\2\u0151\65\3\2\2\2\u0152\u0154\n\5\2\2\u0153\u0152")
        buf.write("\3\2\2\2\u0154\u0155\3\2\2\2\u0155\u0156\3\2\2\2\u0155")
        buf.write("\u0153\3\2\2\2\u0156\67\3\2\2\2/;AEJNSY_ehlv{\177\u0089")
        buf.write("\u008c\u009d\u00a1\u00a5\u00a8\u00b3\u00ba\u00bf\u00c3")
        buf.write("\u00c6\u00c9\u00cd\u00d1\u00d5\u00da\u00dd\u00e4\u00ec")
        buf.write("\u00f6\u00ff\u0108\u010d\u011a\u011e\u0126\u013c\u0145")
        buf.write("\u014d\u0150\u0155")
        return buf.getvalue()


class StraceParser ( Parser ):

    grammarFileName = "StraceParser.g4"

    atn = ATNDeserializer().deserialize(serializedATN())

    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'<... '", "' resumed>'", "'<unfinished ...>'", 
                     "'<... resuming interrupted futex ...>'", "'---'", 
                     "'+++'", "'exited with'", "'killed by'", "'TRUNCATED'", 
                     "'('", "')'", "'='", "<INVALID>", "'?'", "'~'", "<INVALID>", 
                     "<INVALID>", "'{'", "'}'", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'=>'", "'NULL'", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'...'", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "':['", "<INVALID>", "'NETLINK'" ]

    symbolicNames = [ "<INVALID>", "WHITESPACE", "OMITTED_ARGUMENTS", "COMMENT", 
                      "NEWLINE", "RESUMED_START", "RESUMED_END", "UNFINISHED", 
                      "RESUME_INTERRUPTED_FUTEX", "SIGNAL_DELIMITER", "EXIT_DELIMITER", 
                      "EXITED_WITH", "KILLED_BY", "TRUNCATED", "LEFT_PARENTHESIS", 
                      "RIGHT_PARENTHESIS", "EQUALS", "COMMA", "QUESTION_MARK", 
                      "TILDE", "LEFT_BRACKET", "RIGHT_BRACKET", "LEFT_CURLY_BRACKET", 
                      "RIGHT_CURLY_BRACKET", "FD_LEFT_ANGLE_BRACKET", "COLON", 
                      "SINGLE_ARROW", "DOUBLE_ARROW", "NULL", "NUMBER", 
                      "BOOLEAN_BINARY_OPERATOR", "NUMERIC_BINARY_OPERATOR", 
                      "ELLIPSIS", "IDENTIFIER", "STRING", "FD_WHITESPACE", 
                      "DEV_LEFT_ANGLE_BRACKET", "FD_RIGHT_ANGLE_BRACKET", 
                      "FD_INFO_OPEN", "FD_SOCKET_PROTOCOL", "FD_SOCKET_PROTOCOL_NETLINK", 
                      "FD_CHARACTER", "DEV_WHITESPACE", "DEV_RIGHT_ANGLE_BRACKET", 
                      "DEV_COLON", "DEV_NUMBER", "DEV_TEXT", "FD_INFO_LEFT_BRACKET", 
                      "FD_INFO_RIGHT_BRACKET", "FD_INFO_COLON", "FD_INFO_COMMA", 
                      "FD_INFO_REFERENCE", "FD_INFO_NUMBER", "FD_INFO_IPV4", 
                      "FD_INFO_IPV6", "FD_INFO_IPV6_ADDR", "FD_INFO_NETLINK_PROTOCOL", 
                      "FD_INFO_FILENAME" ]

    RULE_strace = 0
    RULE_trace_line = 1
    RULE_syscall = 2
    RULE_syscall_start = 3
    RULE_syscall_arguments = 4
    RULE_syscall_argument = 5
    RULE_syscall_end = 6
    RULE_syscall_resumed = 7
    RULE_syscall_unfinished = 8
    RULE_signal = 9
    RULE_exit_statement = 10
    RULE_literal = 11
    RULE_literal_value = 12
    RULE_mapping = 13
    RULE_literal_list = 14
    RULE_collection = 15
    RULE_file_descriptor = 16
    RULE_device_info = 17
    RULE_inode_info = 18
    RULE_ip_info = 19
    RULE_ip_addr = 20
    RULE_netlink_info = 21
    RULE_function_call = 22
    RULE_numeric_expression = 23
    RULE_boolean_expression = 24
    RULE_return_value = 25
    RULE_return_notes = 26

    ruleNames =  [ "strace", "trace_line", "syscall", "syscall_start", "syscall_arguments", 
                   "syscall_argument", "syscall_end", "syscall_resumed", 
                   "syscall_unfinished", "signal", "exit_statement", "literal", 
                   "literal_value", "mapping", "literal_list", "collection", 
                   "file_descriptor", "device_info", "inode_info", "ip_info", 
                   "ip_addr", "netlink_info", "function_call", "numeric_expression", 
                   "boolean_expression", "return_value", "return_notes" ]

    EOF = Token.EOF
    WHITESPACE=1
    OMITTED_ARGUMENTS=2
    COMMENT=3
    NEWLINE=4
    RESUMED_START=5
    RESUMED_END=6
    UNFINISHED=7
    RESUME_INTERRUPTED_FUTEX=8
    SIGNAL_DELIMITER=9
    EXIT_DELIMITER=10
    EXITED_WITH=11
    KILLED_BY=12
    TRUNCATED=13
    LEFT_PARENTHESIS=14
    RIGHT_PARENTHESIS=15
    EQUALS=16
    COMMA=17
    QUESTION_MARK=18
    TILDE=19
    LEFT_BRACKET=20
    RIGHT_BRACKET=21
    LEFT_CURLY_BRACKET=22
    RIGHT_CURLY_BRACKET=23
    FD_LEFT_ANGLE_BRACKET=24
    COLON=25
    SINGLE_ARROW=26
    DOUBLE_ARROW=27
    NULL=28
    NUMBER=29
    BOOLEAN_BINARY_OPERATOR=30
    NUMERIC_BINARY_OPERATOR=31
    ELLIPSIS=32
    IDENTIFIER=33
    STRING=34
    FD_WHITESPACE=35
    DEV_LEFT_ANGLE_BRACKET=36
    FD_RIGHT_ANGLE_BRACKET=37
    FD_INFO_OPEN=38
    FD_SOCKET_PROTOCOL=39
    FD_SOCKET_PROTOCOL_NETLINK=40
    FD_CHARACTER=41
    DEV_WHITESPACE=42
    DEV_RIGHT_ANGLE_BRACKET=43
    DEV_COLON=44
    DEV_NUMBER=45
    DEV_TEXT=46
    FD_INFO_LEFT_BRACKET=47
    FD_INFO_RIGHT_BRACKET=48
    FD_INFO_COLON=49
    FD_INFO_COMMA=50
    FD_INFO_REFERENCE=51
    FD_INFO_NUMBER=52
    FD_INFO_IPV4=53
    FD_INFO_IPV6=54
    FD_INFO_IPV6_ADDR=55
    FD_INFO_NETLINK_PROTOCOL=56
    FD_INFO_FILENAME=57

    def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
        super().__init__(input, output)
        self.checkVersion("4.8")
        self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
        self._predicates = None




    class StraceContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NEWLINE(self, i:int=None):
            if i is None:
                return self.getTokens(StraceParser.NEWLINE)
            else:
                return self.getToken(StraceParser.NEWLINE, i)

        def trace_line(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(StraceParser.Trace_lineContext)
            else:
                return self.getTypedRuleContext(StraceParser.Trace_lineContext,i)


        def TRUNCATED(self):
            return self.getToken(StraceParser.TRUNCATED, 0)

        def getRuleIndex(self):
            return StraceParser.RULE_strace

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitStrace" ):
                return visitor.visitStrace(self)
            else:
                return visitor.visitChildren(self)




    def strace(self):

        localctx = StraceParser.StraceContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_strace)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 57
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,0,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 54
                    self.match(StraceParser.NEWLINE) 
                self.state = 59
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,0,self._ctx)

            self.state = 63
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << StraceParser.RESUMED_START) | (1 << StraceParser.SIGNAL_DELIMITER) | (1 << StraceParser.EXIT_DELIMITER) | (1 << StraceParser.NUMBER) | (1 << StraceParser.IDENTIFIER))) != 0):
                self.state = 60
                self.trace_line()
                self.state = 65
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 67
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==StraceParser.TRUNCATED:
                self.state = 66
                self.match(StraceParser.TRUNCATED)


            self.state = 72
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==StraceParser.NEWLINE:
                self.state = 69
                self.match(StraceParser.NEWLINE)
                self.state = 74
                self._errHandler.sync(self)
                _la = self._input.LA(1)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Trace_lineContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NEWLINE(self):
            return self.getToken(StraceParser.NEWLINE, 0)

        def syscall(self):
            return self.getTypedRuleContext(StraceParser.SyscallContext,0)


        def signal(self):
            return self.getTypedRuleContext(StraceParser.SignalContext,0)


        def exit_statement(self):
            return self.getTypedRuleContext(StraceParser.Exit_statementContext,0)


        def NUMBER(self):
            return self.getToken(StraceParser.NUMBER, 0)

        def getRuleIndex(self):
            return StraceParser.RULE_trace_line

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitTrace_line" ):
                return visitor.visitTrace_line(self)
            else:
                return visitor.visitChildren(self)




    def trace_line(self):

        localctx = StraceParser.Trace_lineContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_trace_line)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 76
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==StraceParser.NUMBER:
                self.state = 75
                self.match(StraceParser.NUMBER)


            self.state = 81
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [StraceParser.RESUMED_START, StraceParser.IDENTIFIER]:
                self.state = 78
                self.syscall()
                pass
            elif token in [StraceParser.SIGNAL_DELIMITER]:
                self.state = 79
                self.signal()
                pass
            elif token in [StraceParser.EXIT_DELIMITER]:
                self.state = 80
                self.exit_statement()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 83
            self.match(StraceParser.NEWLINE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SyscallContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def syscall_start(self):
            return self.getTypedRuleContext(StraceParser.Syscall_startContext,0)


        def syscall_end(self):
            return self.getTypedRuleContext(StraceParser.Syscall_endContext,0)


        def syscall_arguments(self):
            return self.getTypedRuleContext(StraceParser.Syscall_argumentsContext,0)


        def syscall_unfinished(self):
            return self.getTypedRuleContext(StraceParser.Syscall_unfinishedContext,0)


        def syscall_resumed(self):
            return self.getTypedRuleContext(StraceParser.Syscall_resumedContext,0)


        def mapping(self):
            return self.getTypedRuleContext(StraceParser.MappingContext,0)


        def getRuleIndex(self):
            return StraceParser.RULE_syscall

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSyscall" ):
                return visitor.visitSyscall(self)
            else:
                return visitor.visitChildren(self)




    def syscall(self):

        localctx = StraceParser.SyscallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_syscall)
        self._la = 0 # Token type
        try:
            self.state = 106
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,10,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 85
                self.syscall_start()
                self.state = 87
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << StraceParser.OMITTED_ARGUMENTS) | (1 << StraceParser.LEFT_PARENTHESIS) | (1 << StraceParser.TILDE) | (1 << StraceParser.LEFT_BRACKET) | (1 << StraceParser.LEFT_CURLY_BRACKET) | (1 << StraceParser.DOUBLE_ARROW) | (1 << StraceParser.NULL) | (1 << StraceParser.NUMBER) | (1 << StraceParser.IDENTIFIER) | (1 << StraceParser.STRING))) != 0):
                    self.state = 86
                    self.syscall_arguments()


                self.state = 89
                self.syscall_end()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 91
                self.syscall_start()
                self.state = 93
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << StraceParser.OMITTED_ARGUMENTS) | (1 << StraceParser.LEFT_PARENTHESIS) | (1 << StraceParser.TILDE) | (1 << StraceParser.LEFT_BRACKET) | (1 << StraceParser.LEFT_CURLY_BRACKET) | (1 << StraceParser.DOUBLE_ARROW) | (1 << StraceParser.NULL) | (1 << StraceParser.NUMBER) | (1 << StraceParser.IDENTIFIER) | (1 << StraceParser.STRING))) != 0):
                    self.state = 92
                    self.syscall_arguments()


                self.state = 95
                self.syscall_unfinished()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 97
                self.syscall_resumed()
                self.state = 99
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,8,self._ctx)
                if la_ == 1:
                    self.state = 98
                    self.mapping()


                self.state = 102
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << StraceParser.OMITTED_ARGUMENTS) | (1 << StraceParser.LEFT_PARENTHESIS) | (1 << StraceParser.TILDE) | (1 << StraceParser.LEFT_BRACKET) | (1 << StraceParser.LEFT_CURLY_BRACKET) | (1 << StraceParser.DOUBLE_ARROW) | (1 << StraceParser.NULL) | (1 << StraceParser.NUMBER) | (1 << StraceParser.IDENTIFIER) | (1 << StraceParser.STRING))) != 0):
                    self.state = 101
                    self.syscall_arguments()


                self.state = 104
                self.syscall_end()
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Syscall_startContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def IDENTIFIER(self):
            return self.getToken(StraceParser.IDENTIFIER, 0)

        def LEFT_PARENTHESIS(self):
            return self.getToken(StraceParser.LEFT_PARENTHESIS, 0)

        def getRuleIndex(self):
            return StraceParser.RULE_syscall_start

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSyscall_start" ):
                return visitor.visitSyscall_start(self)
            else:
                return visitor.visitChildren(self)




    def syscall_start(self):

        localctx = StraceParser.Syscall_startContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_syscall_start)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 108
            self.match(StraceParser.IDENTIFIER)
            self.state = 109
            self.match(StraceParser.LEFT_PARENTHESIS)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Syscall_argumentsContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def syscall_argument(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(StraceParser.Syscall_argumentContext)
            else:
                return self.getTypedRuleContext(StraceParser.Syscall_argumentContext,i)


        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(StraceParser.COMMA)
            else:
                return self.getToken(StraceParser.COMMA, i)

        def ELLIPSIS(self):
            return self.getToken(StraceParser.ELLIPSIS, 0)

        def getRuleIndex(self):
            return StraceParser.RULE_syscall_arguments

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSyscall_arguments" ):
                return visitor.visitSyscall_arguments(self)
            else:
                return visitor.visitChildren(self)




    def syscall_arguments(self):

        localctx = StraceParser.Syscall_argumentsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_syscall_arguments)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 111
            self.syscall_argument()
            self.state = 116
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,11,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 112
                    self.match(StraceParser.COMMA)
                    self.state = 113
                    self.syscall_argument() 
                self.state = 118
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,11,self._ctx)

            self.state = 121
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,12,self._ctx)
            if la_ == 1:
                self.state = 119
                self.match(StraceParser.COMMA)
                self.state = 120
                self.match(StraceParser.ELLIPSIS)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Syscall_argumentContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def literal(self):
            return self.getTypedRuleContext(StraceParser.LiteralContext,0)


        def OMITTED_ARGUMENTS(self):
            return self.getToken(StraceParser.OMITTED_ARGUMENTS, 0)

        def getRuleIndex(self):
            return StraceParser.RULE_syscall_argument

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSyscall_argument" ):
                return visitor.visitSyscall_argument(self)
            else:
                return visitor.visitChildren(self)




    def syscall_argument(self):

        localctx = StraceParser.Syscall_argumentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_syscall_argument)
        try:
            self.state = 125
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [StraceParser.LEFT_PARENTHESIS, StraceParser.TILDE, StraceParser.LEFT_BRACKET, StraceParser.LEFT_CURLY_BRACKET, StraceParser.DOUBLE_ARROW, StraceParser.NULL, StraceParser.NUMBER, StraceParser.IDENTIFIER, StraceParser.STRING]:
                self.enterOuterAlt(localctx, 1)
                self.state = 123
                self.literal()
                pass
            elif token in [StraceParser.OMITTED_ARGUMENTS]:
                self.enterOuterAlt(localctx, 2)
                self.state = 124
                self.match(StraceParser.OMITTED_ARGUMENTS)
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Syscall_endContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def RIGHT_PARENTHESIS(self):
            return self.getToken(StraceParser.RIGHT_PARENTHESIS, 0)

        def EQUALS(self):
            return self.getToken(StraceParser.EQUALS, 0)

        def return_value(self):
            return self.getTypedRuleContext(StraceParser.Return_valueContext,0)


        def getRuleIndex(self):
            return StraceParser.RULE_syscall_end

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSyscall_end" ):
                return visitor.visitSyscall_end(self)
            else:
                return visitor.visitChildren(self)




    def syscall_end(self):

        localctx = StraceParser.Syscall_endContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_syscall_end)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 127
            self.match(StraceParser.RIGHT_PARENTHESIS)
            self.state = 128
            self.match(StraceParser.EQUALS)
            self.state = 129
            self.return_value()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Syscall_resumedContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def RESUMED_START(self):
            return self.getToken(StraceParser.RESUMED_START, 0)

        def IDENTIFIER(self):
            return self.getToken(StraceParser.IDENTIFIER, 0)

        def RESUMED_END(self):
            return self.getToken(StraceParser.RESUMED_END, 0)

        def COMMA(self):
            return self.getToken(StraceParser.COMMA, 0)

        def getRuleIndex(self):
            return StraceParser.RULE_syscall_resumed

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSyscall_resumed" ):
                return visitor.visitSyscall_resumed(self)
            else:
                return visitor.visitChildren(self)




    def syscall_resumed(self):

        localctx = StraceParser.Syscall_resumedContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_syscall_resumed)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 131
            self.match(StraceParser.RESUMED_START)
            self.state = 132
            self.match(StraceParser.IDENTIFIER)
            self.state = 133
            self.match(StraceParser.RESUMED_END)
            self.state = 135
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==StraceParser.COMMA:
                self.state = 134
                self.match(StraceParser.COMMA)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Syscall_unfinishedContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def UNFINISHED(self):
            return self.getToken(StraceParser.UNFINISHED, 0)

        def COMMA(self):
            return self.getToken(StraceParser.COMMA, 0)

        def getRuleIndex(self):
            return StraceParser.RULE_syscall_unfinished

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSyscall_unfinished" ):
                return visitor.visitSyscall_unfinished(self)
            else:
                return visitor.visitChildren(self)




    def syscall_unfinished(self):

        localctx = StraceParser.Syscall_unfinishedContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_syscall_unfinished)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 138
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==StraceParser.COMMA:
                self.state = 137
                self.match(StraceParser.COMMA)


            self.state = 140
            self.match(StraceParser.UNFINISHED)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SignalContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def SIGNAL_DELIMITER(self, i:int=None):
            if i is None:
                return self.getTokens(StraceParser.SIGNAL_DELIMITER)
            else:
                return self.getToken(StraceParser.SIGNAL_DELIMITER, i)

        def IDENTIFIER(self):
            return self.getToken(StraceParser.IDENTIFIER, 0)

        def collection(self):
            return self.getTypedRuleContext(StraceParser.CollectionContext,0)


        def getRuleIndex(self):
            return StraceParser.RULE_signal

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitSignal" ):
                return visitor.visitSignal(self)
            else:
                return visitor.visitChildren(self)




    def signal(self):

        localctx = StraceParser.SignalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_signal)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 142
            self.match(StraceParser.SIGNAL_DELIMITER)
            self.state = 143
            self.match(StraceParser.IDENTIFIER)
            self.state = 144
            self.collection()
            self.state = 145
            self.match(StraceParser.SIGNAL_DELIMITER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Exit_statementContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def EXIT_DELIMITER(self, i:int=None):
            if i is None:
                return self.getTokens(StraceParser.EXIT_DELIMITER)
            else:
                return self.getToken(StraceParser.EXIT_DELIMITER, i)

        def EXITED_WITH(self):
            return self.getToken(StraceParser.EXITED_WITH, 0)

        def NUMBER(self):
            return self.getToken(StraceParser.NUMBER, 0)

        def KILLED_BY(self):
            return self.getToken(StraceParser.KILLED_BY, 0)

        def IDENTIFIER(self):
            return self.getToken(StraceParser.IDENTIFIER, 0)

        def getRuleIndex(self):
            return StraceParser.RULE_exit_statement

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitExit_statement" ):
                return visitor.visitExit_statement(self)
            else:
                return visitor.visitChildren(self)




    def exit_statement(self):

        localctx = StraceParser.Exit_statementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_exit_statement)
        try:
            self.state = 155
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,16,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 147
                self.match(StraceParser.EXIT_DELIMITER)
                self.state = 148
                self.match(StraceParser.EXITED_WITH)
                self.state = 149
                self.match(StraceParser.NUMBER)
                self.state = 150
                self.match(StraceParser.EXIT_DELIMITER)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 151
                self.match(StraceParser.EXIT_DELIMITER)
                self.state = 152
                self.match(StraceParser.KILLED_BY)
                self.state = 153
                self.match(StraceParser.IDENTIFIER)
                self.state = 154
                self.match(StraceParser.EXIT_DELIMITER)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LiteralContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def literal_value(self):
            return self.getTypedRuleContext(StraceParser.Literal_valueContext,0)


        def IDENTIFIER(self):
            return self.getToken(StraceParser.IDENTIFIER, 0)

        def EQUALS(self):
            return self.getToken(StraceParser.EQUALS, 0)

        def mapping(self):
            return self.getTypedRuleContext(StraceParser.MappingContext,0)


        def getRuleIndex(self):
            return StraceParser.RULE_literal

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLiteral" ):
                return visitor.visitLiteral(self)
            else:
                return visitor.visitChildren(self)




    def literal(self):

        localctx = StraceParser.LiteralContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_literal)
        try:
            self.state = 166
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [StraceParser.LEFT_PARENTHESIS, StraceParser.TILDE, StraceParser.LEFT_BRACKET, StraceParser.LEFT_CURLY_BRACKET, StraceParser.NULL, StraceParser.NUMBER, StraceParser.IDENTIFIER, StraceParser.STRING]:
                self.enterOuterAlt(localctx, 1)
                self.state = 159
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,17,self._ctx)
                if la_ == 1:
                    self.state = 157
                    self.match(StraceParser.IDENTIFIER)
                    self.state = 158
                    self.match(StraceParser.EQUALS)


                self.state = 161
                self.literal_value()
                self.state = 163
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,18,self._ctx)
                if la_ == 1:
                    self.state = 162
                    self.mapping()


                pass
            elif token in [StraceParser.DOUBLE_ARROW]:
                self.enterOuterAlt(localctx, 2)
                self.state = 165
                self.mapping()
                pass
            else:
                raise NoViableAltException(self)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Literal_valueContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def collection(self):
            return self.getTypedRuleContext(StraceParser.CollectionContext,0)


        def file_descriptor(self):
            return self.getTypedRuleContext(StraceParser.File_descriptorContext,0)


        def function_call(self):
            return self.getTypedRuleContext(StraceParser.Function_callContext,0)


        def numeric_expression(self):
            return self.getTypedRuleContext(StraceParser.Numeric_expressionContext,0)


        def boolean_expression(self):
            return self.getTypedRuleContext(StraceParser.Boolean_expressionContext,0)


        def NULL(self):
            return self.getToken(StraceParser.NULL, 0)

        def NUMBER(self):
            return self.getToken(StraceParser.NUMBER, 0)

        def STRING(self):
            return self.getToken(StraceParser.STRING, 0)

        def IDENTIFIER(self):
            return self.getToken(StraceParser.IDENTIFIER, 0)

        def getRuleIndex(self):
            return StraceParser.RULE_literal_value

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLiteral_value" ):
                return visitor.visitLiteral_value(self)
            else:
                return visitor.visitChildren(self)




    def literal_value(self):

        localctx = StraceParser.Literal_valueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_literal_value)
        try:
            self.state = 177
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,20,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 168
                self.collection()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 169
                self.file_descriptor()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 170
                self.function_call()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 171
                self.numeric_expression()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 172
                self.boolean_expression()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 173
                self.match(StraceParser.NULL)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 174
                self.match(StraceParser.NUMBER)
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 175
                self.match(StraceParser.STRING)
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 176
                self.match(StraceParser.IDENTIFIER)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MappingContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def DOUBLE_ARROW(self):
            return self.getToken(StraceParser.DOUBLE_ARROW, 0)

        def literal(self):
            return self.getTypedRuleContext(StraceParser.LiteralContext,0)


        def getRuleIndex(self):
            return StraceParser.RULE_mapping

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitMapping" ):
                return visitor.visitMapping(self)
            else:
                return visitor.visitChildren(self)




    def mapping(self):

        localctx = StraceParser.MappingContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_mapping)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 179
            self.match(StraceParser.DOUBLE_ARROW)
            self.state = 180
            self.literal()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Literal_listContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def literal(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(StraceParser.LiteralContext)
            else:
                return self.getTypedRuleContext(StraceParser.LiteralContext,i)


        def ELLIPSIS(self):
            return self.getToken(StraceParser.ELLIPSIS, 0)

        def COMMA(self, i:int=None):
            if i is None:
                return self.getTokens(StraceParser.COMMA)
            else:
                return self.getToken(StraceParser.COMMA, i)

        def SINGLE_ARROW(self, i:int=None):
            if i is None:
                return self.getTokens(StraceParser.SINGLE_ARROW)
            else:
                return self.getToken(StraceParser.SINGLE_ARROW, i)

        def getRuleIndex(self):
            return StraceParser.RULE_literal_list

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitLiteral_list" ):
                return visitor.visitLiteral_list(self)
            else:
                return visitor.visitChildren(self)




    def literal_list(self):

        localctx = StraceParser.Literal_listContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_literal_list)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 182
            self.literal()
            self.state = 189
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,22,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 184
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if _la==StraceParser.COMMA or _la==StraceParser.SINGLE_ARROW:
                        self.state = 183
                        _la = self._input.LA(1)
                        if not(_la==StraceParser.COMMA or _la==StraceParser.SINGLE_ARROW):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()


                    self.state = 186
                    self.literal() 
                self.state = 191
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,22,self._ctx)

            self.state = 196
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==StraceParser.COMMA or _la==StraceParser.ELLIPSIS:
                self.state = 193
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==StraceParser.COMMA:
                    self.state = 192
                    self.match(StraceParser.COMMA)


                self.state = 195
                self.match(StraceParser.ELLIPSIS)


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CollectionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LEFT_BRACKET(self):
            return self.getToken(StraceParser.LEFT_BRACKET, 0)

        def RIGHT_BRACKET(self):
            return self.getToken(StraceParser.RIGHT_BRACKET, 0)

        def TILDE(self):
            return self.getToken(StraceParser.TILDE, 0)

        def literal_list(self):
            return self.getTypedRuleContext(StraceParser.Literal_listContext,0)


        def LEFT_PARENTHESIS(self):
            return self.getToken(StraceParser.LEFT_PARENTHESIS, 0)

        def RIGHT_PARENTHESIS(self):
            return self.getToken(StraceParser.RIGHT_PARENTHESIS, 0)

        def LEFT_CURLY_BRACKET(self):
            return self.getToken(StraceParser.LEFT_CURLY_BRACKET, 0)

        def RIGHT_CURLY_BRACKET(self):
            return self.getToken(StraceParser.RIGHT_CURLY_BRACKET, 0)

        def getRuleIndex(self):
            return StraceParser.RULE_collection

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitCollection" ):
                return visitor.visitCollection(self)
            else:
                return visitor.visitChildren(self)




    def collection(self):

        localctx = StraceParser.CollectionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_collection)
        self._la = 0 # Token type
        try:
            self.state = 219
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,30,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 199
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==StraceParser.TILDE:
                    self.state = 198
                    self.match(StraceParser.TILDE)


                self.state = 201
                self.match(StraceParser.LEFT_BRACKET)
                self.state = 203
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << StraceParser.LEFT_PARENTHESIS) | (1 << StraceParser.TILDE) | (1 << StraceParser.LEFT_BRACKET) | (1 << StraceParser.LEFT_CURLY_BRACKET) | (1 << StraceParser.DOUBLE_ARROW) | (1 << StraceParser.NULL) | (1 << StraceParser.NUMBER) | (1 << StraceParser.IDENTIFIER) | (1 << StraceParser.STRING))) != 0):
                    self.state = 202
                    self.literal_list()


                self.state = 205
                self.match(StraceParser.RIGHT_BRACKET)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 207
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==StraceParser.TILDE:
                    self.state = 206
                    self.match(StraceParser.TILDE)


                self.state = 209
                self.match(StraceParser.LEFT_PARENTHESIS)
                self.state = 211
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << StraceParser.LEFT_PARENTHESIS) | (1 << StraceParser.TILDE) | (1 << StraceParser.LEFT_BRACKET) | (1 << StraceParser.LEFT_CURLY_BRACKET) | (1 << StraceParser.DOUBLE_ARROW) | (1 << StraceParser.NULL) | (1 << StraceParser.NUMBER) | (1 << StraceParser.IDENTIFIER) | (1 << StraceParser.STRING))) != 0):
                    self.state = 210
                    self.literal_list()


                self.state = 213
                self.match(StraceParser.RIGHT_PARENTHESIS)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 214
                self.match(StraceParser.LEFT_CURLY_BRACKET)
                self.state = 216
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << StraceParser.LEFT_PARENTHESIS) | (1 << StraceParser.TILDE) | (1 << StraceParser.LEFT_BRACKET) | (1 << StraceParser.LEFT_CURLY_BRACKET) | (1 << StraceParser.DOUBLE_ARROW) | (1 << StraceParser.NULL) | (1 << StraceParser.NUMBER) | (1 << StraceParser.IDENTIFIER) | (1 << StraceParser.STRING))) != 0):
                    self.state = 215
                    self.literal_list()


                self.state = 218
                self.match(StraceParser.RIGHT_CURLY_BRACKET)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class File_descriptorContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NUMBER(self):
            return self.getToken(StraceParser.NUMBER, 0)

        def FD_LEFT_ANGLE_BRACKET(self):
            return self.getToken(StraceParser.FD_LEFT_ANGLE_BRACKET, 0)

        def FD_RIGHT_ANGLE_BRACKET(self):
            return self.getToken(StraceParser.FD_RIGHT_ANGLE_BRACKET, 0)

        def FD_CHARACTER(self, i:int=None):
            if i is None:
                return self.getTokens(StraceParser.FD_CHARACTER)
            else:
                return self.getToken(StraceParser.FD_CHARACTER, i)

        def device_info(self):
            return self.getTypedRuleContext(StraceParser.Device_infoContext,0)


        def FD_SOCKET_PROTOCOL(self):
            return self.getToken(StraceParser.FD_SOCKET_PROTOCOL, 0)

        def inode_info(self):
            return self.getTypedRuleContext(StraceParser.Inode_infoContext,0)


        def ip_info(self):
            return self.getTypedRuleContext(StraceParser.Ip_infoContext,0)


        def FD_SOCKET_PROTOCOL_NETLINK(self):
            return self.getToken(StraceParser.FD_SOCKET_PROTOCOL_NETLINK, 0)

        def netlink_info(self):
            return self.getTypedRuleContext(StraceParser.Netlink_infoContext,0)


        def getRuleIndex(self):
            return StraceParser.RULE_file_descriptor

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFile_descriptor" ):
                return visitor.visitFile_descriptor(self)
            else:
                return visitor.visitChildren(self)




    def file_descriptor(self):

        localctx = StraceParser.File_descriptorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_file_descriptor)
        self._la = 0 # Token type
        try:
            self.state = 267
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,36,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 221
                self.match(StraceParser.NUMBER)
                self.state = 222
                self.match(StraceParser.FD_LEFT_ANGLE_BRACKET)
                self.state = 224 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 223
                    self.match(StraceParser.FD_CHARACTER)
                    self.state = 226 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==StraceParser.FD_CHARACTER):
                        break

                self.state = 228
                self.match(StraceParser.FD_RIGHT_ANGLE_BRACKET)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 229
                self.match(StraceParser.NUMBER)
                self.state = 230
                self.match(StraceParser.FD_LEFT_ANGLE_BRACKET)
                self.state = 232 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 231
                    self.match(StraceParser.FD_CHARACTER)
                    self.state = 234 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==StraceParser.FD_CHARACTER):
                        break

                self.state = 236
                self.device_info()
                self.state = 237
                self.match(StraceParser.FD_RIGHT_ANGLE_BRACKET)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 239
                self.match(StraceParser.NUMBER)
                self.state = 240
                self.match(StraceParser.FD_LEFT_ANGLE_BRACKET)
                self.state = 241
                self.match(StraceParser.FD_SOCKET_PROTOCOL)
                self.state = 244
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,33,self._ctx)
                if la_ == 1:
                    self.state = 242
                    self.inode_info()
                    pass

                elif la_ == 2:
                    self.state = 243
                    self.ip_info()
                    pass


                self.state = 246
                self.match(StraceParser.FD_RIGHT_ANGLE_BRACKET)
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 248
                self.match(StraceParser.NUMBER)
                self.state = 249
                self.match(StraceParser.FD_LEFT_ANGLE_BRACKET)
                self.state = 250
                self.match(StraceParser.FD_SOCKET_PROTOCOL_NETLINK)
                self.state = 253
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,34,self._ctx)
                if la_ == 1:
                    self.state = 251
                    self.inode_info()
                    pass

                elif la_ == 2:
                    self.state = 252
                    self.netlink_info()
                    pass


                self.state = 255
                self.match(StraceParser.FD_RIGHT_ANGLE_BRACKET)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 257
                self.match(StraceParser.NUMBER)
                self.state = 258
                self.match(StraceParser.FD_LEFT_ANGLE_BRACKET)
                self.state = 260 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 259
                    self.match(StraceParser.FD_CHARACTER)
                    self.state = 262 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==StraceParser.FD_CHARACTER):
                        break

                self.state = 264
                self.inode_info()
                self.state = 265
                self.match(StraceParser.FD_RIGHT_ANGLE_BRACKET)
                pass


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Device_infoContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def DEV_LEFT_ANGLE_BRACKET(self):
            return self.getToken(StraceParser.DEV_LEFT_ANGLE_BRACKET, 0)

        def DEV_TEXT(self):
            return self.getToken(StraceParser.DEV_TEXT, 0)

        def DEV_NUMBER(self, i:int=None):
            if i is None:
                return self.getTokens(StraceParser.DEV_NUMBER)
            else:
                return self.getToken(StraceParser.DEV_NUMBER, i)

        def DEV_COLON(self):
            return self.getToken(StraceParser.DEV_COLON, 0)

        def DEV_RIGHT_ANGLE_BRACKET(self):
            return self.getToken(StraceParser.DEV_RIGHT_ANGLE_BRACKET, 0)

        def getRuleIndex(self):
            return StraceParser.RULE_device_info

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitDevice_info" ):
                return visitor.visitDevice_info(self)
            else:
                return visitor.visitChildren(self)




    def device_info(self):

        localctx = StraceParser.Device_infoContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_device_info)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 269
            self.match(StraceParser.DEV_LEFT_ANGLE_BRACKET)
            self.state = 270
            self.match(StraceParser.DEV_TEXT)
            self.state = 271
            self.match(StraceParser.DEV_NUMBER)
            self.state = 272
            self.match(StraceParser.DEV_COLON)
            self.state = 273
            self.match(StraceParser.DEV_NUMBER)
            self.state = 274
            self.match(StraceParser.DEV_RIGHT_ANGLE_BRACKET)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Inode_infoContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def FD_INFO_OPEN(self):
            return self.getToken(StraceParser.FD_INFO_OPEN, 0)

        def FD_INFO_NUMBER(self, i:int=None):
            if i is None:
                return self.getTokens(StraceParser.FD_INFO_NUMBER)
            else:
                return self.getToken(StraceParser.FD_INFO_NUMBER, i)

        def FD_INFO_RIGHT_BRACKET(self):
            return self.getToken(StraceParser.FD_INFO_RIGHT_BRACKET, 0)

        def FD_INFO_REFERENCE(self):
            return self.getToken(StraceParser.FD_INFO_REFERENCE, 0)

        def FD_INFO_COMMA(self):
            return self.getToken(StraceParser.FD_INFO_COMMA, 0)

        def FD_INFO_FILENAME(self):
            return self.getToken(StraceParser.FD_INFO_FILENAME, 0)

        def getRuleIndex(self):
            return StraceParser.RULE_inode_info

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitInode_info" ):
                return visitor.visitInode_info(self)
            else:
                return visitor.visitChildren(self)




    def inode_info(self):

        localctx = StraceParser.Inode_infoContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_inode_info)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 276
            self.match(StraceParser.FD_INFO_OPEN)
            self.state = 277
            self.match(StraceParser.FD_INFO_NUMBER)
            self.state = 280
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==StraceParser.FD_INFO_REFERENCE:
                self.state = 278
                self.match(StraceParser.FD_INFO_REFERENCE)
                self.state = 279
                self.match(StraceParser.FD_INFO_NUMBER)


            self.state = 284
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==StraceParser.FD_INFO_COMMA:
                self.state = 282
                self.match(StraceParser.FD_INFO_COMMA)
                self.state = 283
                self.match(StraceParser.FD_INFO_FILENAME)


            self.state = 286
            self.match(StraceParser.FD_INFO_RIGHT_BRACKET)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Ip_infoContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def FD_INFO_OPEN(self):
            return self.getToken(StraceParser.FD_INFO_OPEN, 0)

        def ip_addr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(StraceParser.Ip_addrContext)
            else:
                return self.getTypedRuleContext(StraceParser.Ip_addrContext,i)


        def FD_INFO_RIGHT_BRACKET(self):
            return self.getToken(StraceParser.FD_INFO_RIGHT_BRACKET, 0)

        def FD_INFO_REFERENCE(self):
            return self.getToken(StraceParser.FD_INFO_REFERENCE, 0)

        def getRuleIndex(self):
            return StraceParser.RULE_ip_info

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIp_info" ):
                return visitor.visitIp_info(self)
            else:
                return visitor.visitChildren(self)




    def ip_info(self):

        localctx = StraceParser.Ip_infoContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_ip_info)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 288
            self.match(StraceParser.FD_INFO_OPEN)
            self.state = 289
            self.ip_addr()
            self.state = 292
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==StraceParser.FD_INFO_REFERENCE:
                self.state = 290
                self.match(StraceParser.FD_INFO_REFERENCE)
                self.state = 291
                self.ip_addr()


            self.state = 294
            self.match(StraceParser.FD_INFO_RIGHT_BRACKET)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Ip_addrContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def FD_INFO_IPV4(self):
            return self.getToken(StraceParser.FD_INFO_IPV4, 0)

        def FD_INFO_IPV6(self):
            return self.getToken(StraceParser.FD_INFO_IPV6, 0)

        def getRuleIndex(self):
            return StraceParser.RULE_ip_addr

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitIp_addr" ):
                return visitor.visitIp_addr(self)
            else:
                return visitor.visitChildren(self)




    def ip_addr(self):

        localctx = StraceParser.Ip_addrContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_ip_addr)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 296
            _la = self._input.LA(1)
            if not(_la==StraceParser.FD_INFO_IPV4 or _la==StraceParser.FD_INFO_IPV6):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Netlink_infoContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def FD_INFO_OPEN(self):
            return self.getToken(StraceParser.FD_INFO_OPEN, 0)

        def FD_INFO_NETLINK_PROTOCOL(self):
            return self.getToken(StraceParser.FD_INFO_NETLINK_PROTOCOL, 0)

        def FD_INFO_COLON(self):
            return self.getToken(StraceParser.FD_INFO_COLON, 0)

        def FD_INFO_NUMBER(self):
            return self.getToken(StraceParser.FD_INFO_NUMBER, 0)

        def FD_INFO_RIGHT_BRACKET(self):
            return self.getToken(StraceParser.FD_INFO_RIGHT_BRACKET, 0)

        def getRuleIndex(self):
            return StraceParser.RULE_netlink_info

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNetlink_info" ):
                return visitor.visitNetlink_info(self)
            else:
                return visitor.visitChildren(self)




    def netlink_info(self):

        localctx = StraceParser.Netlink_infoContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_netlink_info)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 298
            self.match(StraceParser.FD_INFO_OPEN)
            self.state = 299
            self.match(StraceParser.FD_INFO_NETLINK_PROTOCOL)
            self.state = 300
            self.match(StraceParser.FD_INFO_COLON)
            self.state = 301
            self.match(StraceParser.FD_INFO_NUMBER)
            self.state = 302
            self.match(StraceParser.FD_INFO_RIGHT_BRACKET)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Function_callContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def IDENTIFIER(self):
            return self.getToken(StraceParser.IDENTIFIER, 0)

        def LEFT_PARENTHESIS(self):
            return self.getToken(StraceParser.LEFT_PARENTHESIS, 0)

        def literal_list(self):
            return self.getTypedRuleContext(StraceParser.Literal_listContext,0)


        def RIGHT_PARENTHESIS(self):
            return self.getToken(StraceParser.RIGHT_PARENTHESIS, 0)

        def getRuleIndex(self):
            return StraceParser.RULE_function_call

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitFunction_call" ):
                return visitor.visitFunction_call(self)
            else:
                return visitor.visitChildren(self)




    def function_call(self):

        localctx = StraceParser.Function_callContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_function_call)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 304
            self.match(StraceParser.IDENTIFIER)
            self.state = 305
            self.match(StraceParser.LEFT_PARENTHESIS)
            self.state = 306
            self.literal_list()
            self.state = 307
            self.match(StraceParser.RIGHT_PARENTHESIS)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Numeric_expressionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NUMBER(self, i:int=None):
            if i is None:
                return self.getTokens(StraceParser.NUMBER)
            else:
                return self.getToken(StraceParser.NUMBER, i)

        def IDENTIFIER(self, i:int=None):
            if i is None:
                return self.getTokens(StraceParser.IDENTIFIER)
            else:
                return self.getToken(StraceParser.IDENTIFIER, i)

        def NUMERIC_BINARY_OPERATOR(self, i:int=None):
            if i is None:
                return self.getTokens(StraceParser.NUMERIC_BINARY_OPERATOR)
            else:
                return self.getToken(StraceParser.NUMERIC_BINARY_OPERATOR, i)

        def getRuleIndex(self):
            return StraceParser.RULE_numeric_expression

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitNumeric_expression" ):
                return visitor.visitNumeric_expression(self)
            else:
                return visitor.visitChildren(self)




    def numeric_expression(self):

        localctx = StraceParser.Numeric_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_numeric_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 309
            _la = self._input.LA(1)
            if not(_la==StraceParser.NUMBER or _la==StraceParser.IDENTIFIER):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 312 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 310
                self.match(StraceParser.NUMERIC_BINARY_OPERATOR)
                self.state = 311
                _la = self._input.LA(1)
                if not(_la==StraceParser.NUMBER or _la==StraceParser.IDENTIFIER):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 314 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==StraceParser.NUMERIC_BINARY_OPERATOR):
                    break

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Boolean_expressionContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def LEFT_BRACKET(self):
            return self.getToken(StraceParser.LEFT_BRACKET, 0)

        def LEFT_CURLY_BRACKET(self):
            return self.getToken(StraceParser.LEFT_CURLY_BRACKET, 0)

        def literal(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(StraceParser.LiteralContext)
            else:
                return self.getTypedRuleContext(StraceParser.LiteralContext,i)


        def RIGHT_CURLY_BRACKET(self):
            return self.getToken(StraceParser.RIGHT_CURLY_BRACKET, 0)

        def RIGHT_BRACKET(self):
            return self.getToken(StraceParser.RIGHT_BRACKET, 0)

        def BOOLEAN_BINARY_OPERATOR(self, i:int=None):
            if i is None:
                return self.getTokens(StraceParser.BOOLEAN_BINARY_OPERATOR)
            else:
                return self.getToken(StraceParser.BOOLEAN_BINARY_OPERATOR, i)

        def getRuleIndex(self):
            return StraceParser.RULE_boolean_expression

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitBoolean_expression" ):
                return visitor.visitBoolean_expression(self)
            else:
                return visitor.visitChildren(self)




    def boolean_expression(self):

        localctx = StraceParser.Boolean_expressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_boolean_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 316
            self.match(StraceParser.LEFT_BRACKET)
            self.state = 317
            self.match(StraceParser.LEFT_CURLY_BRACKET)
            self.state = 318
            self.literal()
            self.state = 321 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 319
                self.match(StraceParser.BOOLEAN_BINARY_OPERATOR)
                self.state = 320
                self.literal()
                self.state = 323 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==StraceParser.BOOLEAN_BINARY_OPERATOR):
                    break

            self.state = 325
            self.match(StraceParser.RIGHT_CURLY_BRACKET)
            self.state = 326
            self.match(StraceParser.RIGHT_BRACKET)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Return_valueContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NUMBER(self):
            return self.getToken(StraceParser.NUMBER, 0)

        def QUESTION_MARK(self):
            return self.getToken(StraceParser.QUESTION_MARK, 0)

        def file_descriptor(self):
            return self.getTypedRuleContext(StraceParser.File_descriptorContext,0)


        def return_notes(self):
            return self.getTypedRuleContext(StraceParser.Return_notesContext,0)


        def getRuleIndex(self):
            return StraceParser.RULE_return_value

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitReturn_value" ):
                return visitor.visitReturn_value(self)
            else:
                return visitor.visitChildren(self)




    def return_value(self):

        localctx = StraceParser.Return_valueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_return_value)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 331
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,42,self._ctx)
            if la_ == 1:
                self.state = 328
                self.match(StraceParser.NUMBER)
                pass

            elif la_ == 2:
                self.state = 329
                self.match(StraceParser.QUESTION_MARK)
                pass

            elif la_ == 3:
                self.state = 330
                self.file_descriptor()
                pass


            self.state = 334
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << StraceParser.WHITESPACE) | (1 << StraceParser.OMITTED_ARGUMENTS) | (1 << StraceParser.COMMENT) | (1 << StraceParser.RESUMED_START) | (1 << StraceParser.RESUMED_END) | (1 << StraceParser.UNFINISHED) | (1 << StraceParser.RESUME_INTERRUPTED_FUTEX) | (1 << StraceParser.SIGNAL_DELIMITER) | (1 << StraceParser.EXIT_DELIMITER) | (1 << StraceParser.EXITED_WITH) | (1 << StraceParser.KILLED_BY) | (1 << StraceParser.TRUNCATED) | (1 << StraceParser.LEFT_PARENTHESIS) | (1 << StraceParser.RIGHT_PARENTHESIS) | (1 << StraceParser.EQUALS) | (1 << StraceParser.COMMA) | (1 << StraceParser.QUESTION_MARK) | (1 << StraceParser.TILDE) | (1 << StraceParser.LEFT_BRACKET) | (1 << StraceParser.RIGHT_BRACKET) | (1 << StraceParser.LEFT_CURLY_BRACKET) | (1 << StraceParser.RIGHT_CURLY_BRACKET) | (1 << StraceParser.FD_LEFT_ANGLE_BRACKET) | (1 << StraceParser.COLON) | (1 << StraceParser.SINGLE_ARROW) | (1 << StraceParser.DOUBLE_ARROW) | (1 << StraceParser.NULL) | (1 << StraceParser.NUMBER) | (1 << StraceParser.BOOLEAN_BINARY_OPERATOR) | (1 << StraceParser.NUMERIC_BINARY_OPERATOR) | (1 << StraceParser.ELLIPSIS) | (1 << StraceParser.IDENTIFIER) | (1 << StraceParser.STRING) | (1 << StraceParser.FD_WHITESPACE) | (1 << StraceParser.DEV_LEFT_ANGLE_BRACKET) | (1 << StraceParser.FD_RIGHT_ANGLE_BRACKET) | (1 << StraceParser.FD_INFO_OPEN) | (1 << StraceParser.FD_SOCKET_PROTOCOL) | (1 << StraceParser.FD_SOCKET_PROTOCOL_NETLINK) | (1 << StraceParser.FD_CHARACTER) | (1 << StraceParser.DEV_WHITESPACE) | (1 << StraceParser.DEV_RIGHT_ANGLE_BRACKET) | (1 << StraceParser.DEV_COLON) | (1 << StraceParser.DEV_NUMBER) | (1 << StraceParser.DEV_TEXT) | (1 << StraceParser.FD_INFO_LEFT_BRACKET) | (1 << StraceParser.FD_INFO_RIGHT_BRACKET) | (1 << StraceParser.FD_INFO_COLON) | (1 << StraceParser.FD_INFO_COMMA) | (1 << StraceParser.FD_INFO_REFERENCE) | (1 << StraceParser.FD_INFO_NUMBER) | (1 << StraceParser.FD_INFO_IPV4) | (1 << StraceParser.FD_INFO_IPV6) | (1 << StraceParser.FD_INFO_IPV6_ADDR) | (1 << StraceParser.FD_INFO_NETLINK_PROTOCOL) | (1 << StraceParser.FD_INFO_FILENAME))) != 0):
                self.state = 333
                self.return_notes()


        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Return_notesContext(ParserRuleContext):

        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
            super().__init__(parent, invokingState)
            self.parser = parser

        def NEWLINE(self, i:int=None):
            if i is None:
                return self.getTokens(StraceParser.NEWLINE)
            else:
                return self.getToken(StraceParser.NEWLINE, i)

        def getRuleIndex(self):
            return StraceParser.RULE_return_notes

        def accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitReturn_notes" ):
                return visitor.visitReturn_notes(self)
            else:
                return visitor.visitChildren(self)




    def return_notes(self):

        localctx = StraceParser.Return_notesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_return_notes)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 337 
            self._errHandler.sync(self)
            _alt = 1+1
            while _alt!=1 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1+1:
                    self.state = 336
                    _la = self._input.LA(1)
                    if _la <= 0 or _la==StraceParser.NEWLINE:
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()

                else:
                    raise NoViableAltException(self)
                self.state = 339 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,44,self._ctx)

        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx





