# Generated from /Volumes/krishna/CIDAR/pylfr/lfrX.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\3J")
        buf.write("\u0266\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\4\35\t\35\4\36\t\36")
        buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t")
        buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4")
        buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64")
        buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t")
        buf.write(";\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\3\2\6\2\u0086")
        buf.write("\n\2\r\2\16\2\u0087\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3\4\3")
        buf.write("\4\3\4\5\4\u0094\n\4\3\4\3\4\3\5\3\5\6\5\u009a\n\5\r\5")
        buf.write("\16\5\u009b\3\6\3\6\3\6\7\6\u00a1\n\6\f\6\16\6\u00a4\13")
        buf.write("\6\3\6\3\6\3\6\7\6\u00a9\n\6\f\6\16\6\u00ac\13\6\5\6\u00ae")
        buf.write("\n\6\3\7\3\7\5\7\u00b2\n\7\3\b\3\b\3\b\3\b\7\b\u00b8\n")
        buf.write("\b\f\b\16\b\u00bb\13\b\3\b\3\b\3\b\3\b\7\b\u00c1\n\b\f")
        buf.write("\b\16\b\u00c4\13\b\3\b\3\b\3\b\3\b\7\b\u00ca\n\b\f\b\16")
        buf.write("\b\u00cd\13\b\5\b\u00cf\n\b\3\t\5\t\u00d2\n\t\3\t\3\t")
        buf.write("\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\13\6\13\u00df\n\13")
        buf.write("\r\13\16\13\u00e0\3\f\3\f\3\f\5\f\u00e6\n\f\3\r\3\r\7")
        buf.write("\r\u00ea\n\r\f\r\16\r\u00ed\13\r\3\r\5\r\u00f0\n\r\3\16")
        buf.write("\3\16\3\16\3\16\3\16\3\16\3\17\3\17\3\17\3\20\3\20\3\20")
        buf.write("\3\20\3\20\3\20\3\20\3\21\3\21\3\21\3\21\3\22\3\22\6\22")
        buf.write("\u0108\n\22\r\22\16\22\u0109\3\22\3\22\3\22\5\22\u010f")
        buf.write("\n\22\3\23\3\23\6\23\u0113\n\23\r\23\16\23\u0114\3\23")
        buf.write("\5\23\u0118\n\23\3\23\3\23\3\24\3\24\3\24\3\24\3\24\3")
        buf.write("\25\3\25\3\25\3\25\3\26\3\26\3\26\3\26\3\27\3\27\3\30")
        buf.write("\3\30\3\30\3\30\3\30\5\30\u0130\n\30\3\30\3\30\3\31\3")
        buf.write("\31\3\31\7\31\u0137\n\31\f\31\16\31\u013a\13\31\3\32\3")
        buf.write("\32\5\32\u013e\n\32\3\33\3\33\3\33\3\33\5\33\u0144\n\33")
        buf.write("\3\34\3\34\3\34\3\34\3\34\5\34\u014b\n\34\3\35\3\35\3")
        buf.write("\35\3\35\3\35\3\35\3\36\3\36\5\36\u0155\n\36\3\37\3\37")
        buf.write("\3\37\7\37\u015a\n\37\f\37\16\37\u015d\13\37\3 \3 \3 ")
        buf.write("\7 \u0162\n \f \16 \u0165\13 \3!\3!\3!\3!\3!\3!\3\"\3")
        buf.write("\"\3#\3#\3$\3$\3$\3$\5$\u0175\n$\3%\3%\3%\3%\7%\u017b")
        buf.write("\n%\f%\16%\u017e\13%\3&\3&\3&\3&\7&\u0184\n&\f&\16&\u0187")
        buf.write("\13&\3\'\3\'\3\'\3\'\7\'\u018d\n\'\f\'\16\'\u0190\13\'")
        buf.write("\3(\3(\3(\3(\7(\u0196\n(\f(\16(\u0199\13(\3)\3)\3)\3)")
        buf.write("\3)\5)\u01a0\n)\3*\3*\3*\3*\5*\u01a6\n*\3+\5+\u01a9\n")
        buf.write("+\3+\3+\3+\3+\3,\3,\5,\u01b1\n,\3,\3,\3,\5,\u01b6\n,\7")
        buf.write(",\u01b8\n,\f,\16,\u01bb\13,\3-\5-\u01be\n-\3-\3-\5-\u01c2")
        buf.write("\n-\3.\3.\5.\u01c6\n.\3.\3.\3.\5.\u01cb\n.\7.\u01cd\n")
        buf.write(".\f.\16.\u01d0\13.\3/\3/\3/\3/\3\60\3\60\3\61\3\61\3\61")
        buf.write("\3\61\5\61\u01dc\n\61\3\61\3\61\3\62\3\62\5\62\u01e2\n")
        buf.write("\62\3\63\3\63\3\63\3\63\7\63\u01e8\n\63\f\63\16\63\u01eb")
        buf.write("\13\63\3\63\3\63\5\63\u01ef\n\63\3\64\3\64\3\65\3\65\3")
        buf.write("\66\3\66\3\66\7\66\u01f8\n\66\f\66\16\66\u01fb\13\66\3")
        buf.write("\67\3\67\3\67\5\67\u0200\n\67\38\38\38\68\u0205\n8\r8")
        buf.write("\168\u0206\38\38\38\38\58\u020d\n8\38\38\39\39\39\39\3")
        buf.write(":\3:\5:\u0217\n:\3;\3;\3;\3<\3<\3<\5<\u021f\n<\3<\3<\3")
        buf.write("<\3<\3<\5<\u0226\n<\3<\3<\3<\5<\u022b\n<\3<\3<\3<\3<\3")
        buf.write("<\5<\u0232\n<\3<\3<\3<\5<\u0237\n<\3<\3<\3<\3<\3<\5<\u023e")
        buf.write("\n<\3<\3<\3<\5<\u0243\n<\3<\3<\3<\3<\3<\5<\u024a\n<\3")
        buf.write("<\3<\3<\5<\u024f\n<\3<\3<\3<\3<\3<\5<\u0256\n<\5<\u0258")
        buf.write("\n<\3=\3=\3>\3>\3?\3?\3@\3@\3A\3A\3B\3B\3B\2\2C\2\4\6")
        buf.write("\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\66")
        buf.write("8:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\2\t")
        buf.write("\3\2!\"\4\2\31\31\33\33\4\2!\"*\62\6\2\25\25!\"\'+\60")
        buf.write("@\4\2!\",\62\6\2!\"\60\62\66\67:;\3\2FJ\2\u0271\2\u0085")
        buf.write("\3\2\2\2\4\u0089\3\2\2\2\6\u008d\3\2\2\2\b\u0099\3\2\2")
        buf.write("\2\n\u00ad\3\2\2\2\f\u00af\3\2\2\2\16\u00ce\3\2\2\2\20")
        buf.write("\u00d1\3\2\2\2\22\u00d5\3\2\2\2\24\u00de\3\2\2\2\26\u00e5")
        buf.write("\3\2\2\2\30\u00e7\3\2\2\2\32\u00f1\3\2\2\2\34\u00f7\3")
        buf.write("\2\2\2\36\u00fa\3\2\2\2 \u0101\3\2\2\2\"\u010e\3\2\2\2")
        buf.write("$\u0110\3\2\2\2&\u011b\3\2\2\2(\u0120\3\2\2\2*\u0124\3")
        buf.write("\2\2\2,\u0128\3\2\2\2.\u012a\3\2\2\2\60\u0133\3\2\2\2")
        buf.write("\62\u013b\3\2\2\2\64\u0143\3\2\2\2\66\u014a\3\2\2\28\u014c")
        buf.write("\3\2\2\2:\u0154\3\2\2\2<\u0156\3\2\2\2>\u015e\3\2\2\2")
        buf.write("@\u0166\3\2\2\2B\u016c\3\2\2\2D\u016e\3\2\2\2F\u0174\3")
        buf.write("\2\2\2H\u0176\3\2\2\2J\u017f\3\2\2\2L\u0188\3\2\2\2N\u0191")
        buf.write("\3\2\2\2P\u019a\3\2\2\2R\u01a1\3\2\2\2T\u01a8\3\2\2\2")
        buf.write("V\u01b0\3\2\2\2X\u01c1\3\2\2\2Z\u01c5\3\2\2\2\\\u01d1")
        buf.write("\3\2\2\2^\u01d5\3\2\2\2`\u01d7\3\2\2\2b\u01e1\3\2\2\2")
        buf.write("d\u01e3\3\2\2\2f\u01f0\3\2\2\2h\u01f2\3\2\2\2j\u01f4\3")
        buf.write("\2\2\2l\u01ff\3\2\2\2n\u0201\3\2\2\2p\u0210\3\2\2\2r\u0216")
        buf.write("\3\2\2\2t\u0218\3\2\2\2v\u0257\3\2\2\2x\u0259\3\2\2\2")
        buf.write("z\u025b\3\2\2\2|\u025d\3\2\2\2~\u025f\3\2\2\2\u0080\u0261")
        buf.write("\3\2\2\2\u0082\u0263\3\2\2\2\u0084\u0086\5\4\3\2\u0085")
        buf.write("\u0084\3\2\2\2\u0086\u0087\3\2\2\2\u0087\u0085\3\2\2\2")
        buf.write("\u0087\u0088\3\2\2\2\u0088\3\3\2\2\2\u0089\u008a\5\6\4")
        buf.write("\2\u008a\u008b\5\b\5\2\u008b\u008c\7\3\2\2\u008c\5\3\2")
        buf.write("\2\2\u008d\u008e\7\4\2\2\u008e\u0093\7A\2\2\u008f\u0090")
        buf.write("\7\5\2\2\u0090\u0091\5\n\6\2\u0091\u0092\7\6\2\2\u0092")
        buf.write("\u0094\3\2\2\2\u0093\u008f\3\2\2\2\u0093\u0094\3\2\2\2")
        buf.write("\u0094\u0095\3\2\2\2\u0095\u0096\7\7\2\2\u0096\7\3\2\2")
        buf.write("\2\u0097\u009a\5\64\33\2\u0098\u009a\5\22\n\2\u0099\u0097")
        buf.write("\3\2\2\2\u0099\u0098\3\2\2\2\u009a\u009b\3\2\2\2\u009b")
        buf.write("\u0099\3\2\2\2\u009b\u009c\3\2\2\2\u009c\t\3\2\2\2\u009d")
        buf.write("\u00a2\5\f\7\2\u009e\u009f\7\b\2\2\u009f\u00a1\5\f\7\2")
        buf.write("\u00a0\u009e\3\2\2\2\u00a1\u00a4\3\2\2\2\u00a2\u00a0\3")
        buf.write("\2\2\2\u00a2\u00a3\3\2\2\2\u00a3\u00ae\3\2\2\2\u00a4\u00a2")
        buf.write("\3\2\2\2\u00a5\u00aa\5\16\b\2\u00a6\u00a7\7\b\2\2\u00a7")
        buf.write("\u00a9\5\16\b\2\u00a8\u00a6\3\2\2\2\u00a9\u00ac\3\2\2")
        buf.write("\2\u00aa\u00a8\3\2\2\2\u00aa\u00ab\3\2\2\2\u00ab\u00ae")
        buf.write("\3\2\2\2\u00ac\u00aa\3\2\2\2\u00ad\u009d\3\2\2\2\u00ad")
        buf.write("\u00a5\3\2\2\2\u00ae\13\3\2\2\2\u00af\u00b1\7A\2\2\u00b0")
        buf.write("\u00b2\5`\61\2\u00b1\u00b0\3\2\2\2\u00b1\u00b2\3\2\2\2")
        buf.write("\u00b2\r\3\2\2\2\u00b3\u00b4\7\t\2\2\u00b4\u00b9\5\20")
        buf.write("\t\2\u00b5\u00b6\7\b\2\2\u00b6\u00b8\5\20\t\2\u00b7\u00b5")
        buf.write("\3\2\2\2\u00b8\u00bb\3\2\2\2\u00b9\u00b7\3\2\2\2\u00b9")
        buf.write("\u00ba\3\2\2\2\u00ba\u00cf\3\2\2\2\u00bb\u00b9\3\2\2\2")
        buf.write("\u00bc\u00bd\7\n\2\2\u00bd\u00c2\5\20\t\2\u00be\u00bf")
        buf.write("\7\b\2\2\u00bf\u00c1\5\20\t\2\u00c0\u00be\3\2\2\2\u00c1")
        buf.write("\u00c4\3\2\2\2\u00c2\u00c0\3\2\2\2\u00c2\u00c3\3\2\2\2")
        buf.write("\u00c3\u00cf\3\2\2\2\u00c4\u00c2\3\2\2\2\u00c5\u00c6\7")
        buf.write("\13\2\2\u00c6\u00cb\5\20\t\2\u00c7\u00c8\7\b\2\2\u00c8")
        buf.write("\u00ca\5\20\t\2\u00c9\u00c7\3\2\2\2\u00ca\u00cd\3\2\2")
        buf.write("\2\u00cb\u00c9\3\2\2\2\u00cb\u00cc\3\2\2\2\u00cc\u00cf")
        buf.write("\3\2\2\2\u00cd\u00cb\3\2\2\2\u00ce\u00b3\3\2\2\2\u00ce")
        buf.write("\u00bc\3\2\2\2\u00ce\u00c5\3\2\2\2\u00cf\17\3\2\2\2\u00d0")
        buf.write("\u00d2\5`\61\2\u00d1\u00d0\3\2\2\2\u00d1\u00d2\3\2\2\2")
        buf.write("\u00d2\u00d3\3\2\2\2\u00d3\u00d4\7A\2\2\u00d4\21\3\2\2")
        buf.write("\2\u00d5\u00d6\7\f\2\2\u00d6\u00d7\7\5\2\2\u00d7\u00d8")
        buf.write("\5\60\31\2\u00d8\u00d9\7\6\2\2\u00d9\u00da\7\r\2\2\u00da")
        buf.write("\u00db\5\24\13\2\u00db\u00dc\7\16\2\2\u00dc\23\3\2\2\2")
        buf.write("\u00dd\u00df\5\26\f\2\u00de\u00dd\3\2\2\2\u00df\u00e0")
        buf.write("\3\2\2\2\u00e0\u00de\3\2\2\2\u00e0\u00e1\3\2\2\2\u00e1")
        buf.write("\25\3\2\2\2\u00e2\u00e6\5.\30\2\u00e3\u00e6\5$\23\2\u00e4")
        buf.write("\u00e6\5\30\r\2\u00e5\u00e2\3\2\2\2\u00e5\u00e3\3\2\2")
        buf.write("\2\u00e5\u00e4\3\2\2\2\u00e6\27\3\2\2\2\u00e7\u00eb\5")
        buf.write("\32\16\2\u00e8\u00ea\5\36\20\2\u00e9\u00e8\3\2\2\2\u00ea")
        buf.write("\u00ed\3\2\2\2\u00eb\u00e9\3\2\2\2\u00eb\u00ec\3\2\2\2")
        buf.write("\u00ec\u00ef\3\2\2\2\u00ed\u00eb\3\2\2\2\u00ee\u00f0\5")
        buf.write("\34\17\2\u00ef\u00ee\3\2\2\2\u00ef\u00f0\3\2\2\2\u00f0")
        buf.write("\31\3\2\2\2\u00f1\u00f2\7\17\2\2\u00f2\u00f3\7\5\2\2\u00f3")
        buf.write("\u00f4\5 \21\2\u00f4\u00f5\7\6\2\2\u00f5\u00f6\5\"\22")
        buf.write("\2\u00f6\33\3\2\2\2\u00f7\u00f8\7\20\2\2\u00f8\u00f9\5")
        buf.write("\"\22\2\u00f9\35\3\2\2\2\u00fa\u00fb\7\20\2\2\u00fb\u00fc")
        buf.write("\7\17\2\2\u00fc\u00fd\7\5\2\2\u00fd\u00fe\5 \21\2\u00fe")
        buf.write("\u00ff\7\6\2\2\u00ff\u0100\5\"\22\2\u0100\37\3\2\2\2\u0101")
        buf.write("\u0102\5f\64\2\u0102\u0103\5\u0080A\2\u0103\u0104\5,\27")
        buf.write("\2\u0104!\3\2\2\2\u0105\u0107\7\r\2\2\u0106\u0108\5.\30")
        buf.write("\2\u0107\u0106\3\2\2\2\u0108\u0109\3\2\2\2\u0109\u0107")
        buf.write("\3\2\2\2\u0109\u010a\3\2\2\2\u010a\u010b\3\2\2\2\u010b")
        buf.write("\u010c\7\16\2\2\u010c\u010f\3\2\2\2\u010d\u010f\5.\30")
        buf.write("\2\u010e\u0105\3\2\2\2\u010e\u010d\3\2\2\2\u010f#\3\2")
        buf.write("\2\2\u0110\u0112\5&\24\2\u0111\u0113\5(\25\2\u0112\u0111")
        buf.write("\3\2\2\2\u0113\u0114\3\2\2\2\u0114\u0112\3\2\2\2\u0114")
        buf.write("\u0115\3\2\2\2\u0115\u0117\3\2\2\2\u0116\u0118\5*\26\2")
        buf.write("\u0117\u0116\3\2\2\2\u0117\u0118\3\2\2\2\u0118\u0119\3")
        buf.write("\2\2\2\u0119\u011a\7\21\2\2\u011a%\3\2\2\2\u011b\u011c")
        buf.write("\7\22\2\2\u011c\u011d\7\5\2\2\u011d\u011e\5f\64\2\u011e")
        buf.write("\u011f\7\6\2\2\u011f\'\3\2\2\2\u0120\u0121\5,\27\2\u0121")
        buf.write("\u0122\7\23\2\2\u0122\u0123\5\"\22\2\u0123)\3\2\2\2\u0124")
        buf.write("\u0125\7\24\2\2\u0125\u0126\7\23\2\2\u0126\u0127\5\"\22")
        buf.write("\2\u0127+\3\2\2\2\u0128\u0129\5\u0082B\2\u0129-\3\2\2")
        buf.write("\2\u012a\u012b\5f\64\2\u012b\u012f\7\25\2\2\u012c\u0130")
        buf.write("\5\u0082B\2\u012d\u0130\5b\62\2\u012e\u0130\5V,\2\u012f")
        buf.write("\u012c\3\2\2\2\u012f\u012d\3\2\2\2\u012f\u012e\3\2\2\2")
        buf.write("\u0130\u0131\3\2\2\2\u0131\u0132\7\7\2\2\u0132/\3\2\2")
        buf.write("\2\u0133\u0138\5\62\32\2\u0134\u0135\7\b\2\2\u0135\u0137")
        buf.write("\5\62\32\2\u0136\u0134\3\2\2\2\u0137\u013a\3\2\2\2\u0138")
        buf.write("\u0136\3\2\2\2\u0138\u0139\3\2\2\2\u0139\61\3\2\2\2\u013a")
        buf.write("\u0138\3\2\2\2\u013b\u013d\7A\2\2\u013c\u013e\5`\61\2")
        buf.write("\u013d\u013c\3\2\2\2\u013d\u013e\3\2\2\2\u013e\63\3\2")
        buf.write("\2\2\u013f\u0140\5\66\34\2\u0140\u0141\7\7\2\2\u0141\u0144")
        buf.write("\3\2\2\2\u0142\u0144\5j\66\2\u0143\u013f\3\2\2\2\u0143")
        buf.write("\u0142\3\2\2\2\u0144\65\3\2\2\2\u0145\u014b\5h\65\2\u0146")
        buf.write("\u014b\5P)\2\u0147\u014b\5F$\2\u0148\u014b\5R*\2\u0149")
        buf.write("\u014b\58\35\2\u014a\u0145\3\2\2\2\u014a\u0146\3\2\2\2")
        buf.write("\u014a\u0147\3\2\2\2\u014a\u0148\3\2\2\2\u014a\u0149\3")
        buf.write("\2\2\2\u014b\67\3\2\2\2\u014c\u014d\5D#\2\u014d\u014e")
        buf.write("\5B\"\2\u014e\u014f\7\5\2\2\u014f\u0150\5:\36\2\u0150")
        buf.write("\u0151\7\6\2\2\u01519\3\2\2\2\u0152\u0155\5<\37\2\u0153")
        buf.write("\u0155\5> \2\u0154\u0152\3\2\2\2\u0154\u0153\3\2\2\2\u0155")
        buf.write(";\3\2\2\2\u0156\u015b\5\f\7\2\u0157\u0158\7\b\2\2\u0158")
        buf.write("\u015a\5\f\7\2\u0159\u0157\3\2\2\2\u015a\u015d\3\2\2\2")
        buf.write("\u015b\u0159\3\2\2\2\u015b\u015c\3\2\2\2\u015c=\3\2\2")
        buf.write("\2\u015d\u015b\3\2\2\2\u015e\u0163\5@!\2\u015f\u0160\7")
        buf.write("\b\2\2\u0160\u0162\5@!\2\u0161\u015f\3\2\2\2\u0162\u0165")
        buf.write("\3\2\2\2\u0163\u0161\3\2\2\2\u0163\u0164\3\2\2\2\u0164")
        buf.write("?\3\2\2\2\u0165\u0163\3\2\2\2\u0166\u0167\7\26\2\2\u0167")
        buf.write("\u0168\5\f\7\2\u0168\u0169\7\5\2\2\u0169\u016a\5b\62\2")
        buf.write("\u016a\u016b\7\6\2\2\u016bA\3\2\2\2\u016c\u016d\7A\2\2")
        buf.write("\u016dC\3\2\2\2\u016e\u016f\7A\2\2\u016fE\3\2\2\2\u0170")
        buf.write("\u0175\5J&\2\u0171\u0175\5L\'\2\u0172\u0175\5N(\2\u0173")
        buf.write("\u0175\5H%\2\u0174\u0170\3\2\2\2\u0174\u0171\3\2\2\2\u0174")
        buf.write("\u0172\3\2\2\2\u0174\u0173\3\2\2\2\u0175G\3\2\2\2\u0176")
        buf.write("\u0177\7\27\2\2\u0177\u017c\5\20\t\2\u0178\u0179\7\b\2")
        buf.write("\2\u0179\u017b\5\20\t\2\u017a\u0178\3\2\2\2\u017b\u017e")
        buf.write("\3\2\2\2\u017c\u017a\3\2\2\2\u017c\u017d\3\2\2\2\u017d")
        buf.write("I\3\2\2\2\u017e\u017c\3\2\2\2\u017f\u0180\7\30\2\2\u0180")
        buf.write("\u0185\5\20\t\2\u0181\u0182\7\b\2\2\u0182\u0184\5\20\t")
        buf.write("\2\u0183\u0181\3\2\2\2\u0184\u0187\3\2\2\2\u0185\u0183")
        buf.write("\3\2\2\2\u0185\u0186\3\2\2\2\u0186K\3\2\2\2\u0187\u0185")
        buf.write("\3\2\2\2\u0188\u0189\7\31\2\2\u0189\u018e\5\20\t\2\u018a")
        buf.write("\u018b\7\b\2\2\u018b\u018d\5\20\t\2\u018c\u018a\3\2\2")
        buf.write("\2\u018d\u0190\3\2\2\2\u018e\u018c\3\2\2\2\u018e\u018f")
        buf.write("\3\2\2\2\u018fM\3\2\2\2\u0190\u018e\3\2\2\2\u0191\u0192")
        buf.write("\7\32\2\2\u0192\u0197\5R*\2\u0193\u0194\7\b\2\2\u0194")
        buf.write("\u0196\5R*\2\u0195\u0193\3\2\2\2\u0196\u0199\3\2\2\2\u0197")
        buf.write("\u0195\3\2\2\2\u0197\u0198\3\2\2\2\u0198O\3\2\2\2\u0199")
        buf.write("\u0197\3\2\2\2\u019a\u019b\7\33\2\2\u019b\u019c\5f\64")
        buf.write("\2\u019c\u019f\7\34\2\2\u019d\u01a0\5T+\2\u019e\u01a0")
        buf.write("\5V,\2\u019f\u019d\3\2\2\2\u019f\u019e\3\2\2\2\u01a0Q")
        buf.write("\3\2\2\2\u01a1\u01a2\7A\2\2\u01a2\u01a5\7\34\2\2\u01a3")
        buf.write("\u01a6\5T+\2\u01a4\u01a6\5V,\2\u01a5\u01a3\3\2\2\2\u01a5")
        buf.write("\u01a4\3\2\2\2\u01a6S\3\2\2\2\u01a7\u01a9\5z>\2\u01a8")
        buf.write("\u01a7\3\2\2\2\u01a8\u01a9\3\2\2\2\u01a9\u01aa\3\2\2\2")
        buf.write("\u01aa\u01ab\7\5\2\2\u01ab\u01ac\5V,\2\u01ac\u01ad\7\6")
        buf.write("\2\2\u01adU\3\2\2\2\u01ae\u01b1\5T+\2\u01af\u01b1\5X-")
        buf.write("\2\u01b0\u01ae\3\2\2\2\u01b0\u01af\3\2\2\2\u01b1\u01b9")
        buf.write("\3\2\2\2\u01b2\u01b5\5|?\2\u01b3\u01b6\5T+\2\u01b4\u01b6")
        buf.write("\5X-\2\u01b5\u01b3\3\2\2\2\u01b5\u01b4\3\2\2\2\u01b6\u01b8")
        buf.write("\3\2\2\2\u01b7\u01b2\3\2\2\2\u01b8\u01bb\3\2\2\2\u01b9")
        buf.write("\u01b7\3\2\2\2\u01b9\u01ba\3\2\2\2\u01baW\3\2\2\2\u01bb")
        buf.write("\u01b9\3\2\2\2\u01bc\u01be\5z>\2\u01bd\u01bc\3\2\2\2\u01bd")
        buf.write("\u01be\3\2\2\2\u01be\u01bf\3\2\2\2\u01bf\u01c2\5b\62\2")
        buf.write("\u01c0\u01c2\5\u0082B\2\u01c1\u01bd\3\2\2\2\u01c1\u01c0")
        buf.write("\3\2\2\2\u01c2Y\3\2\2\2\u01c3\u01c6\5T+\2\u01c4\u01c6")
        buf.write("\5X-\2\u01c5\u01c3\3\2\2\2\u01c5\u01c4\3\2\2\2\u01c6\u01ce")
        buf.write("\3\2\2\2\u01c7\u01ca\5|?\2\u01c8\u01cb\5T+\2\u01c9\u01cb")
        buf.write("\5X-\2\u01ca\u01c8\3\2\2\2\u01ca\u01c9\3\2\2\2\u01cb\u01cd")
        buf.write("\3\2\2\2\u01cc\u01c7\3\2\2\2\u01cd\u01d0\3\2\2\2\u01ce")
        buf.write("\u01cc\3\2\2\2\u01ce\u01cf\3\2\2\2\u01cf[\3\2\2\2\u01d0")
        buf.write("\u01ce\3\2\2\2\u01d1\u01d2\5Z.\2\u01d2\u01d3\5\u0080A")
        buf.write("\2\u01d3\u01d4\5^\60\2\u01d4]\3\2\2\2\u01d5\u01d6\5\u0082")
        buf.write("B\2\u01d6_\3\2\2\2\u01d7\u01d8\7\35\2\2\u01d8\u01db\7")
        buf.write("G\2\2\u01d9\u01da\7\23\2\2\u01da\u01dc\7G\2\2\u01db\u01d9")
        buf.write("\3\2\2\2\u01db\u01dc\3\2\2\2\u01dc\u01dd\3\2\2\2\u01dd")
        buf.write("\u01de\7\36\2\2\u01dea\3\2\2\2\u01df\u01e2\5\f\7\2\u01e0")
        buf.write("\u01e2\5d\63\2\u01e1\u01df\3\2\2\2\u01e1\u01e0\3\2\2\2")
        buf.write("\u01e2c\3\2\2\2\u01e3\u01e4\7\37\2\2\u01e4\u01e9\5\f\7")
        buf.write("\2\u01e5\u01e6\7\b\2\2\u01e6\u01e8\5\f\7\2\u01e7\u01e5")
        buf.write("\3\2\2\2\u01e8\u01eb\3\2\2\2\u01e9\u01e7\3\2\2\2\u01e9")
        buf.write("\u01ea\3\2\2\2\u01ea\u01ec\3\2\2\2\u01eb\u01e9\3\2\2\2")
        buf.write("\u01ec\u01ee\7 \2\2\u01ed\u01ef\5`\61\2\u01ee\u01ed\3")
        buf.write("\2\2\2\u01ee\u01ef\3\2\2\2\u01efe\3\2\2\2\u01f0\u01f1")
        buf.write("\5b\62\2\u01f1g\3\2\2\2\u01f2\u01f3\5\16\b\2\u01f3i\3")
        buf.write("\2\2\2\u01f4\u01f9\5l\67\2\u01f5\u01f6\t\2\2\2\u01f6\u01f8")
        buf.write("\5l\67\2\u01f7\u01f5\3\2\2\2\u01f8\u01fb\3\2\2\2\u01f9")
        buf.write("\u01f7\3\2\2\2\u01f9\u01fa\3\2\2\2\u01fak\3\2\2\2\u01fb")
        buf.write("\u01f9\3\2\2\2\u01fc\u0200\5t;\2\u01fd\u0200\5n8\2\u01fe")
        buf.write("\u0200\5p9\2\u01ff\u01fc\3\2\2\2\u01ff\u01fd\3\2\2\2\u01ff")
        buf.write("\u01fe\3\2\2\2\u0200m\3\2\2\2\u0201\u0202\7#\2\2\u0202")
        buf.write("\u0204\7$\2\2\u0203\u0205\7A\2\2\u0204\u0203\3\2\2\2\u0205")
        buf.write("\u0206\3\2\2\2\u0206\u0204\3\2\2\2\u0206\u0207\3\2\2\2")
        buf.write("\u0207\u0208\3\2\2\2\u0208\u0209\7$\2\2\u0209\u020c\7")
        buf.write("$\2\2\u020a\u020d\5r:\2\u020b\u020d\t\3\2\2\u020c\u020a")
        buf.write("\3\2\2\2\u020c\u020b\3\2\2\2\u020d\u020e\3\2\2\2\u020e")
        buf.write("\u020f\7$\2\2\u020fo\3\2\2\2\u0210\u0211\7%\2\2\u0211")
        buf.write("\u0212\7A\2\2\u0212\u0213\7A\2\2\u0213q\3\2\2\2\u0214")
        buf.write("\u0217\5|?\2\u0215\u0217\5z>\2\u0216\u0214\3\2\2\2\u0216")
        buf.write("\u0215\3\2\2\2\u0217s\3\2\2\2\u0218\u0219\7&\2\2\u0219")
        buf.write("\u021a\5v<\2\u021au\3\2\2\2\u021b\u021e\7$\2\2\u021c\u021f")
        buf.write("\5|?\2\u021d\u021f\5z>\2\u021e\u021c\3\2\2\2\u021e\u021d")
        buf.write("\3\2\2\2\u021f\u0220\3\2\2\2\u0220\u0221\7$\2\2\u0221")
        buf.write("\u0222\7A\2\2\u0222\u0223\7\34\2\2\u0223\u0225\5\u0082")
        buf.write("B\2\u0224\u0226\5x=\2\u0225\u0224\3\2\2\2\u0225\u0226")
        buf.write("\3\2\2\2\u0226\u0258\3\2\2\2\u0227\u022a\7$\2\2\u0228")
        buf.write("\u022b\5|?\2\u0229\u022b\5z>\2\u022a\u0228\3\2\2\2\u022a")
        buf.write("\u0229\3\2\2\2\u022b\u022c\3\2\2\2\u022c\u022d\7$\2\2")
        buf.write("\u022d\u022e\7A\2\2\u022e\u022f\7\'\2\2\u022f\u0231\5")
        buf.write("\u0082B\2\u0230\u0232\5x=\2\u0231\u0230\3\2\2\2\u0231")
        buf.write("\u0232\3\2\2\2\u0232\u0258\3\2\2\2\u0233\u0236\7$\2\2")
        buf.write("\u0234\u0237\5|?\2\u0235\u0237\5z>\2\u0236\u0234\3\2\2")
        buf.write("\2\u0236\u0235\3\2\2\2\u0237\u0238\3\2\2\2\u0238\u0239")
        buf.write("\7$\2\2\u0239\u023a\7A\2\2\u023a\u023b\7(\2\2\u023b\u023d")
        buf.write("\5\u0082B\2\u023c\u023e\5x=\2\u023d\u023c\3\2\2\2\u023d")
        buf.write("\u023e\3\2\2\2\u023e\u0258\3\2\2\2\u023f\u0242\7$\2\2")
        buf.write("\u0240\u0243\5|?\2\u0241\u0243\5z>\2\u0242\u0240\3\2\2")
        buf.write("\2\u0242\u0241\3\2\2\2\u0243\u0244\3\2\2\2\u0244\u0245")
        buf.write("\7$\2\2\u0245\u0246\7A\2\2\u0246\u0247\7)\2\2\u0247\u0249")
        buf.write("\5\u0082B\2\u0248\u024a\5x=\2\u0249\u0248\3\2\2\2\u0249")
        buf.write("\u024a\3\2\2\2\u024a\u0258\3\2\2\2\u024b\u024e\7$\2\2")
        buf.write("\u024c\u024f\5|?\2\u024d\u024f\5z>\2\u024e\u024c\3\2\2")
        buf.write("\2\u024e\u024d\3\2\2\2\u024f\u0250\3\2\2\2\u0250\u0251")
        buf.write("\7$\2\2\u0251\u0252\7A\2\2\u0252\u0253\7\25\2\2\u0253")
        buf.write("\u0255\5\u0082B\2\u0254\u0256\5x=\2\u0255\u0254\3\2\2")
        buf.write("\2\u0255\u0256\3\2\2\2\u0256\u0258\3\2\2\2\u0257\u021b")
        buf.write("\3\2\2\2\u0257\u0227\3\2\2\2\u0257\u0233\3\2\2\2\u0257")
        buf.write("\u023f\3\2\2\2\u0257\u024b\3\2\2\2\u0258w\3\2\2\2\u0259")
        buf.write("\u025a\7A\2\2\u025ay\3\2\2\2\u025b\u025c\t\4\2\2\u025c")
        buf.write("{\3\2\2\2\u025d\u025e\t\5\2\2\u025e}\3\2\2\2\u025f\u0260")
        buf.write("\t\6\2\2\u0260\177\3\2\2\2\u0261\u0262\t\7\2\2\u0262\u0081")
        buf.write("\3\2\2\2\u0263\u0264\t\b\2\2\u0264\u0083\3\2\2\2C\u0087")
        buf.write("\u0093\u0099\u009b\u00a2\u00aa\u00ad\u00b1\u00b9\u00c2")
        buf.write("\u00cb\u00ce\u00d1\u00e0\u00e5\u00eb\u00ef\u0109\u010e")
        buf.write("\u0114\u0117\u012f\u0138\u013d\u0143\u014a\u0154\u015b")
        buf.write("\u0163\u0174\u017c\u0185\u018e\u0197\u019f\u01a5\u01a8")
        buf.write("\u01b0\u01b5\u01b9\u01bd\u01c1\u01c5\u01ca\u01ce\u01db")
        buf.write("\u01e1\u01e9\u01ee\u01f9\u01ff\u0206\u020c\u0216\u021e")
        buf.write("\u0225\u022a\u0231\u0236\u023d\u0242\u0249\u024e\u0255")
        buf.write("\u0257")
        return buf.getvalue()


class lfrXParser ( Parser ):

    grammarFileName = "lfrX.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'endmodule'", "'module'", "'('", "')'", 
                     "';'", "','", "'finput'", "'foutput'", "'control'", 
                     "'distribute@'", "'begin'", "'end'", "'if'", "'else'", 
                     "'endcase'", "'case'", "':'", "'default'", "'<='", 
                     "'.'", "'signal'", "'flow'", "'storage'", "'number'", 
                     "'assign'", "'='", "'['", "']'", "'{'", "'}'", "'|'", 
                     "'&'", "'#MAP'", "'''", "'#MATERIAL'", "'#CONSTRAIN'", 
                     "'>'", "'<'", "'>='", "'+'", "'-'", "'!'", "'~'", "'~&'", 
                     "'~|'", "'^'", "'~^'", "'^~'", "'*'", "'/'", "'%'", 
                     "'=='", "'!='", "'==='", "'!=='", "'&&'", "'||'", "'**'", 
                     "'>>'", "'<<'", "'>>>'", "'<<<'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "ID", "WS", 
                      "One_line_comment", "Block_comment", "Import_line", 
                      "Real_number", "Decimal_number", "Binary_number", 
                      "Octal_number", "Hex_number" ]

    RULE_skeleton = 0
    RULE_module = 1
    RULE_moduledefinition = 2
    RULE_body = 3
    RULE_ioblock = 4
    RULE_vectorvar = 5
    RULE_explicitIOBlock = 6
    RULE_declvar = 7
    RULE_distributionBlock = 8
    RULE_distributionBody = 9
    RULE_distributeBodyStat = 10
    RULE_ifElseBlock = 11
    RULE_ifBlock = 12
    RULE_elseBlock = 13
    RULE_elseIfBlock = 14
    RULE_distributeCondition = 15
    RULE_statementBlock = 16
    RULE_caseBlock = 17
    RULE_caseBlockHeader = 18
    RULE_casestat = 19
    RULE_defaultCaseStat = 20
    RULE_distvalue = 21
    RULE_distributionassignstat = 22
    RULE_sensitivitylist = 23
    RULE_signal = 24
    RULE_statements = 25
    RULE_statement = 26
    RULE_moduleinstantiationstat = 27
    RULE_instanceioblock = 28
    RULE_orderedioblock = 29
    RULE_unorderedioblock = 30
    RULE_explicitinstanceiomapping = 31
    RULE_instancenames = 32
    RULE_moduletype = 33
    RULE_tempvariablesstat = 34
    RULE_signalvarstat = 35
    RULE_fluiddeclstat = 36
    RULE_storagestat = 37
    RULE_numvarstat = 38
    RULE_assignstat = 39
    RULE_literalassignstat = 40
    RULE_bracketexpression = 41
    RULE_expression = 42
    RULE_expressionterm = 43
    RULE_logiccondition_operand = 44
    RULE_logiccondition = 45
    RULE_logic_value = 46
    RULE_vector = 47
    RULE_variables = 48
    RULE_concatenation = 49
    RULE_lhs = 50
    RULE_ioassignstat = 51
    RULE_technologydirectives = 52
    RULE_directive = 53
    RULE_technologymappingdirective = 54
    RULE_materialmappingdirective = 55
    RULE_mappingoperator = 56
    RULE_performancedirective = 57
    RULE_constraint = 58
    RULE_unit = 59
    RULE_unary_operator = 60
    RULE_binary_operator = 61
    RULE_unary_module_path_operator = 62
    RULE_binary_module_path_operator = 63
    RULE_number = 64

    ruleNames =  [ "skeleton", "module", "moduledefinition", "body", "ioblock", 
                   "vectorvar", "explicitIOBlock", "declvar", "distributionBlock", 
                   "distributionBody", "distributeBodyStat", "ifElseBlock", 
                   "ifBlock", "elseBlock", "elseIfBlock", "distributeCondition", 
                   "statementBlock", "caseBlock", "caseBlockHeader", "casestat", 
                   "defaultCaseStat", "distvalue", "distributionassignstat", 
                   "sensitivitylist", "signal", "statements", "statement", 
                   "moduleinstantiationstat", "instanceioblock", "orderedioblock", 
                   "unorderedioblock", "explicitinstanceiomapping", "instancenames", 
                   "moduletype", "tempvariablesstat", "signalvarstat", "fluiddeclstat", 
                   "storagestat", "numvarstat", "assignstat", "literalassignstat", 
                   "bracketexpression", "expression", "expressionterm", 
                   "logiccondition_operand", "logiccondition", "logic_value", 
                   "vector", "variables", "concatenation", "lhs", "ioassignstat", 
                   "technologydirectives", "directive", "technologymappingdirective", 
                   "materialmappingdirective", "mappingoperator", "performancedirective", 
                   "constraint", "unit", "unary_operator", "binary_operator", 
                   "unary_module_path_operator", "binary_module_path_operator", 
                   "number" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    T__3=4
    T__4=5
    T__5=6
    T__6=7
    T__7=8
    T__8=9
    T__9=10
    T__10=11
    T__11=12
    T__12=13
    T__13=14
    T__14=15
    T__15=16
    T__16=17
    T__17=18
    T__18=19
    T__19=20
    T__20=21
    T__21=22
    T__22=23
    T__23=24
    T__24=25
    T__25=26
    T__26=27
    T__27=28
    T__28=29
    T__29=30
    T__30=31
    T__31=32
    T__32=33
    T__33=34
    T__34=35
    T__35=36
    T__36=37
    T__37=38
    T__38=39
    T__39=40
    T__40=41
    T__41=42
    T__42=43
    T__43=44
    T__44=45
    T__45=46
    T__46=47
    T__47=48
    T__48=49
    T__49=50
    T__50=51
    T__51=52
    T__52=53
    T__53=54
    T__54=55
    T__55=56
    T__56=57
    T__57=58
    T__58=59
    T__59=60
    T__60=61
    T__61=62
    ID=63
    WS=64
    One_line_comment=65
    Block_comment=66
    Import_line=67
    Real_number=68
    Decimal_number=69
    Binary_number=70
    Octal_number=71
    Hex_number=72

    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 SkeletonContext(ParserRuleContext):

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

        def module(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(lfrXParser.ModuleContext)
            else:
                return self.getTypedRuleContext(lfrXParser.ModuleContext,i)


        def getRuleIndex(self):
            return lfrXParser.RULE_skeleton

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSkeleton" ):
                listener.enterSkeleton(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSkeleton" ):
                listener.exitSkeleton(self)

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




    def skeleton(self):

        localctx = lfrXParser.SkeletonContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_skeleton)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 131 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 130
                self.module()
                self.state = 133 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==lfrXParser.T__1):
                    break

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


    class ModuleContext(ParserRuleContext):

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

        def moduledefinition(self):
            return self.getTypedRuleContext(lfrXParser.ModuledefinitionContext,0)


        def body(self):
            return self.getTypedRuleContext(lfrXParser.BodyContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_module

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterModule" ):
                listener.enterModule(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitModule" ):
                listener.exitModule(self)

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




    def module(self):

        localctx = lfrXParser.ModuleContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_module)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 135
            self.moduledefinition()
            self.state = 136
            self.body()
            self.state = 137
            self.match(lfrXParser.T__0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ModuledefinitionContext(ParserRuleContext):

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

        def ID(self):
            return self.getToken(lfrXParser.ID, 0)

        def ioblock(self):
            return self.getTypedRuleContext(lfrXParser.IoblockContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_moduledefinition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterModuledefinition" ):
                listener.enterModuledefinition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitModuledefinition" ):
                listener.exitModuledefinition(self)

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




    def moduledefinition(self):

        localctx = lfrXParser.ModuledefinitionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_moduledefinition)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 139
            self.match(lfrXParser.T__1)
            self.state = 140
            self.match(lfrXParser.ID)
            self.state = 145
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==lfrXParser.T__2:
                self.state = 141
                self.match(lfrXParser.T__2)
                self.state = 142
                self.ioblock()
                self.state = 143
                self.match(lfrXParser.T__3)


            self.state = 147
            self.match(lfrXParser.T__4)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BodyContext(ParserRuleContext):

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

        def statements(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(lfrXParser.StatementsContext)
            else:
                return self.getTypedRuleContext(lfrXParser.StatementsContext,i)


        def distributionBlock(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(lfrXParser.DistributionBlockContext)
            else:
                return self.getTypedRuleContext(lfrXParser.DistributionBlockContext,i)


        def getRuleIndex(self):
            return lfrXParser.RULE_body

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBody" ):
                listener.enterBody(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBody" ):
                listener.exitBody(self)

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




    def body(self):

        localctx = lfrXParser.BodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_body)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 151 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 151
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [lfrXParser.T__6, lfrXParser.T__7, lfrXParser.T__8, lfrXParser.T__20, lfrXParser.T__21, lfrXParser.T__22, lfrXParser.T__23, lfrXParser.T__24, lfrXParser.T__32, lfrXParser.T__34, lfrXParser.T__35, lfrXParser.ID]:
                    self.state = 149
                    self.statements()
                    pass
                elif token in [lfrXParser.T__9]:
                    self.state = 150
                    self.distributionBlock()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 153 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << lfrXParser.T__6) | (1 << lfrXParser.T__7) | (1 << lfrXParser.T__8) | (1 << lfrXParser.T__9) | (1 << lfrXParser.T__20) | (1 << lfrXParser.T__21) | (1 << lfrXParser.T__22) | (1 << lfrXParser.T__23) | (1 << lfrXParser.T__24) | (1 << lfrXParser.T__32) | (1 << lfrXParser.T__34) | (1 << lfrXParser.T__35) | (1 << lfrXParser.ID))) != 0)):
                    break

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


    class IoblockContext(ParserRuleContext):

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

        def vectorvar(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(lfrXParser.VectorvarContext)
            else:
                return self.getTypedRuleContext(lfrXParser.VectorvarContext,i)


        def explicitIOBlock(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(lfrXParser.ExplicitIOBlockContext)
            else:
                return self.getTypedRuleContext(lfrXParser.ExplicitIOBlockContext,i)


        def getRuleIndex(self):
            return lfrXParser.RULE_ioblock

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterIoblock" ):
                listener.enterIoblock(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitIoblock" ):
                listener.exitIoblock(self)

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




    def ioblock(self):

        localctx = lfrXParser.IoblockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_ioblock)
        self._la = 0 # Token type
        try:
            self.state = 171
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [lfrXParser.ID]:
                self.enterOuterAlt(localctx, 1)
                self.state = 155
                self.vectorvar()
                self.state = 160
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==lfrXParser.T__5:
                    self.state = 156
                    self.match(lfrXParser.T__5)
                    self.state = 157
                    self.vectorvar()
                    self.state = 162
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                pass
            elif token in [lfrXParser.T__6, lfrXParser.T__7, lfrXParser.T__8]:
                self.enterOuterAlt(localctx, 2)
                self.state = 163
                self.explicitIOBlock()
                self.state = 168
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==lfrXParser.T__5:
                    self.state = 164
                    self.match(lfrXParser.T__5)
                    self.state = 165
                    self.explicitIOBlock()
                    self.state = 170
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                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 VectorvarContext(ParserRuleContext):

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

        def ID(self):
            return self.getToken(lfrXParser.ID, 0)

        def vector(self):
            return self.getTypedRuleContext(lfrXParser.VectorContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_vectorvar

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVectorvar" ):
                listener.enterVectorvar(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVectorvar" ):
                listener.exitVectorvar(self)

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




    def vectorvar(self):

        localctx = lfrXParser.VectorvarContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_vectorvar)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 173
            self.match(lfrXParser.ID)
            self.state = 175
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==lfrXParser.T__26:
                self.state = 174
                self.vector()


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


    class ExplicitIOBlockContext(ParserRuleContext):

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

        def declvar(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(lfrXParser.DeclvarContext)
            else:
                return self.getTypedRuleContext(lfrXParser.DeclvarContext,i)


        def getRuleIndex(self):
            return lfrXParser.RULE_explicitIOBlock

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExplicitIOBlock" ):
                listener.enterExplicitIOBlock(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExplicitIOBlock" ):
                listener.exitExplicitIOBlock(self)

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




    def explicitIOBlock(self):

        localctx = lfrXParser.ExplicitIOBlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_explicitIOBlock)
        try:
            self.state = 204
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [lfrXParser.T__6]:
                self.enterOuterAlt(localctx, 1)
                self.state = 177
                self.match(lfrXParser.T__6)
                self.state = 178
                self.declvar()
                self.state = 183
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,8,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 179
                        self.match(lfrXParser.T__5)
                        self.state = 180
                        self.declvar() 
                    self.state = 185
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,8,self._ctx)

                pass
            elif token in [lfrXParser.T__7]:
                self.enterOuterAlt(localctx, 2)
                self.state = 186
                self.match(lfrXParser.T__7)
                self.state = 187
                self.declvar()
                self.state = 192
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,9,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 188
                        self.match(lfrXParser.T__5)
                        self.state = 189
                        self.declvar() 
                    self.state = 194
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,9,self._ctx)

                pass
            elif token in [lfrXParser.T__8]:
                self.enterOuterAlt(localctx, 3)
                self.state = 195
                self.match(lfrXParser.T__8)
                self.state = 196
                self.declvar()
                self.state = 201
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,10,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 197
                        self.match(lfrXParser.T__5)
                        self.state = 198
                        self.declvar() 
                    self.state = 203
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,10,self._ctx)

                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 DeclvarContext(ParserRuleContext):

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

        def ID(self):
            return self.getToken(lfrXParser.ID, 0)

        def vector(self):
            return self.getTypedRuleContext(lfrXParser.VectorContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_declvar

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDeclvar" ):
                listener.enterDeclvar(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDeclvar" ):
                listener.exitDeclvar(self)

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




    def declvar(self):

        localctx = lfrXParser.DeclvarContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_declvar)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 207
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==lfrXParser.T__26:
                self.state = 206
                self.vector()


            self.state = 209
            self.match(lfrXParser.ID)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DistributionBlockContext(ParserRuleContext):

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

        def sensitivitylist(self):
            return self.getTypedRuleContext(lfrXParser.SensitivitylistContext,0)


        def distributionBody(self):
            return self.getTypedRuleContext(lfrXParser.DistributionBodyContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_distributionBlock

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDistributionBlock" ):
                listener.enterDistributionBlock(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDistributionBlock" ):
                listener.exitDistributionBlock(self)

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




    def distributionBlock(self):

        localctx = lfrXParser.DistributionBlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_distributionBlock)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 211
            self.match(lfrXParser.T__9)
            self.state = 212
            self.match(lfrXParser.T__2)
            self.state = 213
            self.sensitivitylist()
            self.state = 214
            self.match(lfrXParser.T__3)
            self.state = 215
            self.match(lfrXParser.T__10)
            self.state = 216
            self.distributionBody()
            self.state = 217
            self.match(lfrXParser.T__11)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DistributionBodyContext(ParserRuleContext):

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

        def distributeBodyStat(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(lfrXParser.DistributeBodyStatContext)
            else:
                return self.getTypedRuleContext(lfrXParser.DistributeBodyStatContext,i)


        def getRuleIndex(self):
            return lfrXParser.RULE_distributionBody

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDistributionBody" ):
                listener.enterDistributionBody(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDistributionBody" ):
                listener.exitDistributionBody(self)

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




    def distributionBody(self):

        localctx = lfrXParser.DistributionBodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_distributionBody)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 220 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 219
                self.distributeBodyStat()
                self.state = 222 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << lfrXParser.T__12) | (1 << lfrXParser.T__15) | (1 << lfrXParser.T__28) | (1 << lfrXParser.ID))) != 0)):
                    break

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


    class DistributeBodyStatContext(ParserRuleContext):

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

        def distributionassignstat(self):
            return self.getTypedRuleContext(lfrXParser.DistributionassignstatContext,0)


        def caseBlock(self):
            return self.getTypedRuleContext(lfrXParser.CaseBlockContext,0)


        def ifElseBlock(self):
            return self.getTypedRuleContext(lfrXParser.IfElseBlockContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_distributeBodyStat

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDistributeBodyStat" ):
                listener.enterDistributeBodyStat(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDistributeBodyStat" ):
                listener.exitDistributeBodyStat(self)

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




    def distributeBodyStat(self):

        localctx = lfrXParser.DistributeBodyStatContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_distributeBodyStat)
        try:
            self.state = 227
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [lfrXParser.T__28, lfrXParser.ID]:
                self.enterOuterAlt(localctx, 1)
                self.state = 224
                self.distributionassignstat()
                pass
            elif token in [lfrXParser.T__15]:
                self.enterOuterAlt(localctx, 2)
                self.state = 225
                self.caseBlock()
                pass
            elif token in [lfrXParser.T__12]:
                self.enterOuterAlt(localctx, 3)
                self.state = 226
                self.ifElseBlock()
                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 IfElseBlockContext(ParserRuleContext):

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

        def ifBlock(self):
            return self.getTypedRuleContext(lfrXParser.IfBlockContext,0)


        def elseIfBlock(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(lfrXParser.ElseIfBlockContext)
            else:
                return self.getTypedRuleContext(lfrXParser.ElseIfBlockContext,i)


        def elseBlock(self):
            return self.getTypedRuleContext(lfrXParser.ElseBlockContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_ifElseBlock

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterIfElseBlock" ):
                listener.enterIfElseBlock(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitIfElseBlock" ):
                listener.exitIfElseBlock(self)

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




    def ifElseBlock(self):

        localctx = lfrXParser.IfElseBlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_ifElseBlock)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 229
            self.ifBlock()
            self.state = 233
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,15,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 230
                    self.elseIfBlock() 
                self.state = 235
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,15,self._ctx)

            self.state = 237
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==lfrXParser.T__13:
                self.state = 236
                self.elseBlock()


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


    class IfBlockContext(ParserRuleContext):

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

        def distributeCondition(self):
            return self.getTypedRuleContext(lfrXParser.DistributeConditionContext,0)


        def statementBlock(self):
            return self.getTypedRuleContext(lfrXParser.StatementBlockContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_ifBlock

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterIfBlock" ):
                listener.enterIfBlock(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitIfBlock" ):
                listener.exitIfBlock(self)

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




    def ifBlock(self):

        localctx = lfrXParser.IfBlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_ifBlock)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 239
            self.match(lfrXParser.T__12)
            self.state = 240
            self.match(lfrXParser.T__2)
            self.state = 241
            self.distributeCondition()
            self.state = 242
            self.match(lfrXParser.T__3)
            self.state = 243
            self.statementBlock()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ElseBlockContext(ParserRuleContext):

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

        def statementBlock(self):
            return self.getTypedRuleContext(lfrXParser.StatementBlockContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_elseBlock

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterElseBlock" ):
                listener.enterElseBlock(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitElseBlock" ):
                listener.exitElseBlock(self)

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




    def elseBlock(self):

        localctx = lfrXParser.ElseBlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_elseBlock)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 245
            self.match(lfrXParser.T__13)
            self.state = 246
            self.statementBlock()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ElseIfBlockContext(ParserRuleContext):

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

        def distributeCondition(self):
            return self.getTypedRuleContext(lfrXParser.DistributeConditionContext,0)


        def statementBlock(self):
            return self.getTypedRuleContext(lfrXParser.StatementBlockContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_elseIfBlock

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterElseIfBlock" ):
                listener.enterElseIfBlock(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitElseIfBlock" ):
                listener.exitElseIfBlock(self)

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




    def elseIfBlock(self):

        localctx = lfrXParser.ElseIfBlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_elseIfBlock)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 248
            self.match(lfrXParser.T__13)
            self.state = 249
            self.match(lfrXParser.T__12)
            self.state = 250
            self.match(lfrXParser.T__2)
            self.state = 251
            self.distributeCondition()
            self.state = 252
            self.match(lfrXParser.T__3)
            self.state = 253
            self.statementBlock()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DistributeConditionContext(ParserRuleContext):

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

        def lhs(self):
            return self.getTypedRuleContext(lfrXParser.LhsContext,0)


        def binary_module_path_operator(self):
            return self.getTypedRuleContext(lfrXParser.Binary_module_path_operatorContext,0)


        def distvalue(self):
            return self.getTypedRuleContext(lfrXParser.DistvalueContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_distributeCondition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDistributeCondition" ):
                listener.enterDistributeCondition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDistributeCondition" ):
                listener.exitDistributeCondition(self)

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




    def distributeCondition(self):

        localctx = lfrXParser.DistributeConditionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_distributeCondition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 255
            self.lhs()
            self.state = 256
            self.binary_module_path_operator()
            self.state = 257
            self.distvalue()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StatementBlockContext(ParserRuleContext):

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

        def distributionassignstat(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(lfrXParser.DistributionassignstatContext)
            else:
                return self.getTypedRuleContext(lfrXParser.DistributionassignstatContext,i)


        def getRuleIndex(self):
            return lfrXParser.RULE_statementBlock

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStatementBlock" ):
                listener.enterStatementBlock(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStatementBlock" ):
                listener.exitStatementBlock(self)

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




    def statementBlock(self):

        localctx = lfrXParser.StatementBlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_statementBlock)
        self._la = 0 # Token type
        try:
            self.state = 268
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [lfrXParser.T__10]:
                self.enterOuterAlt(localctx, 1)
                self.state = 259
                self.match(lfrXParser.T__10)
                self.state = 261 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 260
                    self.distributionassignstat()
                    self.state = 263 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==lfrXParser.T__28 or _la==lfrXParser.ID):
                        break

                self.state = 265
                self.match(lfrXParser.T__11)
                pass
            elif token in [lfrXParser.T__28, lfrXParser.ID]:
                self.enterOuterAlt(localctx, 2)
                self.state = 267
                self.distributionassignstat()
                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 CaseBlockContext(ParserRuleContext):

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

        def caseBlockHeader(self):
            return self.getTypedRuleContext(lfrXParser.CaseBlockHeaderContext,0)


        def casestat(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(lfrXParser.CasestatContext)
            else:
                return self.getTypedRuleContext(lfrXParser.CasestatContext,i)


        def defaultCaseStat(self):
            return self.getTypedRuleContext(lfrXParser.DefaultCaseStatContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_caseBlock

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCaseBlock" ):
                listener.enterCaseBlock(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCaseBlock" ):
                listener.exitCaseBlock(self)

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




    def caseBlock(self):

        localctx = lfrXParser.CaseBlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_caseBlock)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 270
            self.caseBlockHeader()
            self.state = 272 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 271
                self.casestat()
                self.state = 274 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (lfrXParser.Real_number - 68)) | (1 << (lfrXParser.Decimal_number - 68)) | (1 << (lfrXParser.Binary_number - 68)) | (1 << (lfrXParser.Octal_number - 68)) | (1 << (lfrXParser.Hex_number - 68)))) != 0)):
                    break

            self.state = 277
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==lfrXParser.T__17:
                self.state = 276
                self.defaultCaseStat()


            self.state = 279
            self.match(lfrXParser.T__14)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CaseBlockHeaderContext(ParserRuleContext):

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

        def lhs(self):
            return self.getTypedRuleContext(lfrXParser.LhsContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_caseBlockHeader

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCaseBlockHeader" ):
                listener.enterCaseBlockHeader(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCaseBlockHeader" ):
                listener.exitCaseBlockHeader(self)

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




    def caseBlockHeader(self):

        localctx = lfrXParser.CaseBlockHeaderContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_caseBlockHeader)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 281
            self.match(lfrXParser.T__15)
            self.state = 282
            self.match(lfrXParser.T__2)
            self.state = 283
            self.lhs()
            self.state = 284
            self.match(lfrXParser.T__3)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CasestatContext(ParserRuleContext):

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

        def distvalue(self):
            return self.getTypedRuleContext(lfrXParser.DistvalueContext,0)


        def statementBlock(self):
            return self.getTypedRuleContext(lfrXParser.StatementBlockContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_casestat

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterCasestat" ):
                listener.enterCasestat(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitCasestat" ):
                listener.exitCasestat(self)

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




    def casestat(self):

        localctx = lfrXParser.CasestatContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_casestat)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 286
            self.distvalue()
            self.state = 287
            self.match(lfrXParser.T__16)
            self.state = 288
            self.statementBlock()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DefaultCaseStatContext(ParserRuleContext):

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

        def statementBlock(self):
            return self.getTypedRuleContext(lfrXParser.StatementBlockContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_defaultCaseStat

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDefaultCaseStat" ):
                listener.enterDefaultCaseStat(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDefaultCaseStat" ):
                listener.exitDefaultCaseStat(self)

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




    def defaultCaseStat(self):

        localctx = lfrXParser.DefaultCaseStatContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_defaultCaseStat)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 290
            self.match(lfrXParser.T__17)
            self.state = 291
            self.match(lfrXParser.T__16)
            self.state = 292
            self.statementBlock()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DistvalueContext(ParserRuleContext):

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

        def number(self):
            return self.getTypedRuleContext(lfrXParser.NumberContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_distvalue

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDistvalue" ):
                listener.enterDistvalue(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDistvalue" ):
                listener.exitDistvalue(self)

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




    def distvalue(self):

        localctx = lfrXParser.DistvalueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_distvalue)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 294
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DistributionassignstatContext(ParserRuleContext):

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

        def lhs(self):
            return self.getTypedRuleContext(lfrXParser.LhsContext,0)


        def number(self):
            return self.getTypedRuleContext(lfrXParser.NumberContext,0)


        def variables(self):
            return self.getTypedRuleContext(lfrXParser.VariablesContext,0)


        def expression(self):
            return self.getTypedRuleContext(lfrXParser.ExpressionContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_distributionassignstat

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDistributionassignstat" ):
                listener.enterDistributionassignstat(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDistributionassignstat" ):
                listener.exitDistributionassignstat(self)

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




    def distributionassignstat(self):

        localctx = lfrXParser.DistributionassignstatContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_distributionassignstat)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 296
            self.lhs()
            self.state = 297
            self.match(lfrXParser.T__18)
            self.state = 301
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,21,self._ctx)
            if la_ == 1:
                self.state = 298
                self.number()
                pass

            elif la_ == 2:
                self.state = 299
                self.variables()
                pass

            elif la_ == 3:
                self.state = 300
                self.expression()
                pass


            self.state = 303
            self.match(lfrXParser.T__4)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SensitivitylistContext(ParserRuleContext):

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

        def signal(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(lfrXParser.SignalContext)
            else:
                return self.getTypedRuleContext(lfrXParser.SignalContext,i)


        def getRuleIndex(self):
            return lfrXParser.RULE_sensitivitylist

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSensitivitylist" ):
                listener.enterSensitivitylist(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSensitivitylist" ):
                listener.exitSensitivitylist(self)

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




    def sensitivitylist(self):

        localctx = lfrXParser.SensitivitylistContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_sensitivitylist)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 305
            self.signal()
            self.state = 310
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==lfrXParser.T__5:
                self.state = 306
                self.match(lfrXParser.T__5)
                self.state = 307
                self.signal()
                self.state = 312
                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 SignalContext(ParserRuleContext):

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

        def ID(self):
            return self.getToken(lfrXParser.ID, 0)

        def vector(self):
            return self.getTypedRuleContext(lfrXParser.VectorContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_signal

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSignal" ):
                listener.enterSignal(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSignal" ):
                listener.exitSignal(self)

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




    def signal(self):

        localctx = lfrXParser.SignalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_signal)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 313
            self.match(lfrXParser.ID)
            self.state = 315
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==lfrXParser.T__26:
                self.state = 314
                self.vector()


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


    class StatementsContext(ParserRuleContext):

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

        def statement(self):
            return self.getTypedRuleContext(lfrXParser.StatementContext,0)


        def technologydirectives(self):
            return self.getTypedRuleContext(lfrXParser.TechnologydirectivesContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_statements

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStatements" ):
                listener.enterStatements(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStatements" ):
                listener.exitStatements(self)

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




    def statements(self):

        localctx = lfrXParser.StatementsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_statements)
        try:
            self.state = 321
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [lfrXParser.T__6, lfrXParser.T__7, lfrXParser.T__8, lfrXParser.T__20, lfrXParser.T__21, lfrXParser.T__22, lfrXParser.T__23, lfrXParser.T__24, lfrXParser.ID]:
                self.enterOuterAlt(localctx, 1)
                self.state = 317
                self.statement()
                self.state = 318
                self.match(lfrXParser.T__4)
                pass
            elif token in [lfrXParser.T__32, lfrXParser.T__34, lfrXParser.T__35]:
                self.enterOuterAlt(localctx, 2)
                self.state = 320
                self.technologydirectives()
                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 StatementContext(ParserRuleContext):

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

        def ioassignstat(self):
            return self.getTypedRuleContext(lfrXParser.IoassignstatContext,0)


        def assignstat(self):
            return self.getTypedRuleContext(lfrXParser.AssignstatContext,0)


        def tempvariablesstat(self):
            return self.getTypedRuleContext(lfrXParser.TempvariablesstatContext,0)


        def literalassignstat(self):
            return self.getTypedRuleContext(lfrXParser.LiteralassignstatContext,0)


        def moduleinstantiationstat(self):
            return self.getTypedRuleContext(lfrXParser.ModuleinstantiationstatContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_statement

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStatement" ):
                listener.enterStatement(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStatement" ):
                listener.exitStatement(self)

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




    def statement(self):

        localctx = lfrXParser.StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_statement)
        try:
            self.state = 328
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,25,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 323
                self.ioassignstat()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 324
                self.assignstat()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 325
                self.tempvariablesstat()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 326
                self.literalassignstat()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 327
                self.moduleinstantiationstat()
                pass


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


    class ModuleinstantiationstatContext(ParserRuleContext):

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

        def moduletype(self):
            return self.getTypedRuleContext(lfrXParser.ModuletypeContext,0)


        def instancenames(self):
            return self.getTypedRuleContext(lfrXParser.InstancenamesContext,0)


        def instanceioblock(self):
            return self.getTypedRuleContext(lfrXParser.InstanceioblockContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_moduleinstantiationstat

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterModuleinstantiationstat" ):
                listener.enterModuleinstantiationstat(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitModuleinstantiationstat" ):
                listener.exitModuleinstantiationstat(self)

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




    def moduleinstantiationstat(self):

        localctx = lfrXParser.ModuleinstantiationstatContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_moduleinstantiationstat)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 330
            self.moduletype()
            self.state = 331
            self.instancenames()
            self.state = 332
            self.match(lfrXParser.T__2)
            self.state = 333
            self.instanceioblock()
            self.state = 334
            self.match(lfrXParser.T__3)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InstanceioblockContext(ParserRuleContext):

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

        def orderedioblock(self):
            return self.getTypedRuleContext(lfrXParser.OrderedioblockContext,0)


        def unorderedioblock(self):
            return self.getTypedRuleContext(lfrXParser.UnorderedioblockContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_instanceioblock

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInstanceioblock" ):
                listener.enterInstanceioblock(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInstanceioblock" ):
                listener.exitInstanceioblock(self)

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




    def instanceioblock(self):

        localctx = lfrXParser.InstanceioblockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_instanceioblock)
        try:
            self.state = 338
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [lfrXParser.ID]:
                self.enterOuterAlt(localctx, 1)
                self.state = 336
                self.orderedioblock()
                pass
            elif token in [lfrXParser.T__19]:
                self.enterOuterAlt(localctx, 2)
                self.state = 337
                self.unorderedioblock()
                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 OrderedioblockContext(ParserRuleContext):

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

        def vectorvar(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(lfrXParser.VectorvarContext)
            else:
                return self.getTypedRuleContext(lfrXParser.VectorvarContext,i)


        def getRuleIndex(self):
            return lfrXParser.RULE_orderedioblock

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterOrderedioblock" ):
                listener.enterOrderedioblock(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitOrderedioblock" ):
                listener.exitOrderedioblock(self)

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




    def orderedioblock(self):

        localctx = lfrXParser.OrderedioblockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_orderedioblock)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 340
            self.vectorvar()
            self.state = 345
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==lfrXParser.T__5:
                self.state = 341
                self.match(lfrXParser.T__5)
                self.state = 342
                self.vectorvar()
                self.state = 347
                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 UnorderedioblockContext(ParserRuleContext):

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

        def explicitinstanceiomapping(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(lfrXParser.ExplicitinstanceiomappingContext)
            else:
                return self.getTypedRuleContext(lfrXParser.ExplicitinstanceiomappingContext,i)


        def getRuleIndex(self):
            return lfrXParser.RULE_unorderedioblock

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUnorderedioblock" ):
                listener.enterUnorderedioblock(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUnorderedioblock" ):
                listener.exitUnorderedioblock(self)

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




    def unorderedioblock(self):

        localctx = lfrXParser.UnorderedioblockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_unorderedioblock)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 348
            self.explicitinstanceiomapping()
            self.state = 353
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==lfrXParser.T__5:
                self.state = 349
                self.match(lfrXParser.T__5)
                self.state = 350
                self.explicitinstanceiomapping()
                self.state = 355
                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 ExplicitinstanceiomappingContext(ParserRuleContext):

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

        def vectorvar(self):
            return self.getTypedRuleContext(lfrXParser.VectorvarContext,0)


        def variables(self):
            return self.getTypedRuleContext(lfrXParser.VariablesContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_explicitinstanceiomapping

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExplicitinstanceiomapping" ):
                listener.enterExplicitinstanceiomapping(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExplicitinstanceiomapping" ):
                listener.exitExplicitinstanceiomapping(self)

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




    def explicitinstanceiomapping(self):

        localctx = lfrXParser.ExplicitinstanceiomappingContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_explicitinstanceiomapping)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 356
            self.match(lfrXParser.T__19)
            self.state = 357
            self.vectorvar()
            self.state = 358
            self.match(lfrXParser.T__2)
            self.state = 359
            self.variables()
            self.state = 360
            self.match(lfrXParser.T__3)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InstancenamesContext(ParserRuleContext):

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

        def ID(self):
            return self.getToken(lfrXParser.ID, 0)

        def getRuleIndex(self):
            return lfrXParser.RULE_instancenames

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterInstancenames" ):
                listener.enterInstancenames(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitInstancenames" ):
                listener.exitInstancenames(self)

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




    def instancenames(self):

        localctx = lfrXParser.InstancenamesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_instancenames)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 362
            self.match(lfrXParser.ID)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ModuletypeContext(ParserRuleContext):

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

        def ID(self):
            return self.getToken(lfrXParser.ID, 0)

        def getRuleIndex(self):
            return lfrXParser.RULE_moduletype

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterModuletype" ):
                listener.enterModuletype(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitModuletype" ):
                listener.exitModuletype(self)

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




    def moduletype(self):

        localctx = lfrXParser.ModuletypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_moduletype)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 364
            self.match(lfrXParser.ID)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TempvariablesstatContext(ParserRuleContext):

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

        def fluiddeclstat(self):
            return self.getTypedRuleContext(lfrXParser.FluiddeclstatContext,0)


        def storagestat(self):
            return self.getTypedRuleContext(lfrXParser.StoragestatContext,0)


        def numvarstat(self):
            return self.getTypedRuleContext(lfrXParser.NumvarstatContext,0)


        def signalvarstat(self):
            return self.getTypedRuleContext(lfrXParser.SignalvarstatContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_tempvariablesstat

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTempvariablesstat" ):
                listener.enterTempvariablesstat(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTempvariablesstat" ):
                listener.exitTempvariablesstat(self)

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




    def tempvariablesstat(self):

        localctx = lfrXParser.TempvariablesstatContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_tempvariablesstat)
        try:
            self.state = 370
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [lfrXParser.T__21]:
                self.enterOuterAlt(localctx, 1)
                self.state = 366
                self.fluiddeclstat()
                pass
            elif token in [lfrXParser.T__22]:
                self.enterOuterAlt(localctx, 2)
                self.state = 367
                self.storagestat()
                pass
            elif token in [lfrXParser.T__23]:
                self.enterOuterAlt(localctx, 3)
                self.state = 368
                self.numvarstat()
                pass
            elif token in [lfrXParser.T__20]:
                self.enterOuterAlt(localctx, 4)
                self.state = 369
                self.signalvarstat()
                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 SignalvarstatContext(ParserRuleContext):

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

        def declvar(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(lfrXParser.DeclvarContext)
            else:
                return self.getTypedRuleContext(lfrXParser.DeclvarContext,i)


        def getRuleIndex(self):
            return lfrXParser.RULE_signalvarstat

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterSignalvarstat" ):
                listener.enterSignalvarstat(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitSignalvarstat" ):
                listener.exitSignalvarstat(self)

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




    def signalvarstat(self):

        localctx = lfrXParser.SignalvarstatContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_signalvarstat)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 372
            self.match(lfrXParser.T__20)
            self.state = 373
            self.declvar()
            self.state = 378
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==lfrXParser.T__5:
                self.state = 374
                self.match(lfrXParser.T__5)
                self.state = 375
                self.declvar()
                self.state = 380
                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 FluiddeclstatContext(ParserRuleContext):

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

        def declvar(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(lfrXParser.DeclvarContext)
            else:
                return self.getTypedRuleContext(lfrXParser.DeclvarContext,i)


        def getRuleIndex(self):
            return lfrXParser.RULE_fluiddeclstat

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterFluiddeclstat" ):
                listener.enterFluiddeclstat(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitFluiddeclstat" ):
                listener.exitFluiddeclstat(self)

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




    def fluiddeclstat(self):

        localctx = lfrXParser.FluiddeclstatContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_fluiddeclstat)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 381
            self.match(lfrXParser.T__21)
            self.state = 382
            self.declvar()
            self.state = 387
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==lfrXParser.T__5:
                self.state = 383
                self.match(lfrXParser.T__5)
                self.state = 384
                self.declvar()
                self.state = 389
                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 StoragestatContext(ParserRuleContext):

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

        def declvar(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(lfrXParser.DeclvarContext)
            else:
                return self.getTypedRuleContext(lfrXParser.DeclvarContext,i)


        def getRuleIndex(self):
            return lfrXParser.RULE_storagestat

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterStoragestat" ):
                listener.enterStoragestat(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitStoragestat" ):
                listener.exitStoragestat(self)

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




    def storagestat(self):

        localctx = lfrXParser.StoragestatContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_storagestat)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 390
            self.match(lfrXParser.T__22)
            self.state = 391
            self.declvar()
            self.state = 396
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==lfrXParser.T__5:
                self.state = 392
                self.match(lfrXParser.T__5)
                self.state = 393
                self.declvar()
                self.state = 398
                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 NumvarstatContext(ParserRuleContext):

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

        def literalassignstat(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(lfrXParser.LiteralassignstatContext)
            else:
                return self.getTypedRuleContext(lfrXParser.LiteralassignstatContext,i)


        def getRuleIndex(self):
            return lfrXParser.RULE_numvarstat

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNumvarstat" ):
                listener.enterNumvarstat(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNumvarstat" ):
                listener.exitNumvarstat(self)

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




    def numvarstat(self):

        localctx = lfrXParser.NumvarstatContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_numvarstat)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 399
            self.match(lfrXParser.T__23)
            self.state = 400
            self.literalassignstat()
            self.state = 405
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==lfrXParser.T__5:
                self.state = 401
                self.match(lfrXParser.T__5)
                self.state = 402
                self.literalassignstat()
                self.state = 407
                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 AssignstatContext(ParserRuleContext):

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

        def lhs(self):
            return self.getTypedRuleContext(lfrXParser.LhsContext,0)


        def bracketexpression(self):
            return self.getTypedRuleContext(lfrXParser.BracketexpressionContext,0)


        def expression(self):
            return self.getTypedRuleContext(lfrXParser.ExpressionContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_assignstat

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterAssignstat" ):
                listener.enterAssignstat(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitAssignstat" ):
                listener.exitAssignstat(self)

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




    def assignstat(self):

        localctx = lfrXParser.AssignstatContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_assignstat)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 408
            self.match(lfrXParser.T__24)
            self.state = 409
            self.lhs()
            self.state = 410
            self.match(lfrXParser.T__25)
            self.state = 413
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,34,self._ctx)
            if la_ == 1:
                self.state = 411
                self.bracketexpression()
                pass

            elif la_ == 2:
                self.state = 412
                self.expression()
                pass


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


    class LiteralassignstatContext(ParserRuleContext):

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

        def ID(self):
            return self.getToken(lfrXParser.ID, 0)

        def bracketexpression(self):
            return self.getTypedRuleContext(lfrXParser.BracketexpressionContext,0)


        def expression(self):
            return self.getTypedRuleContext(lfrXParser.ExpressionContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_literalassignstat

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLiteralassignstat" ):
                listener.enterLiteralassignstat(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLiteralassignstat" ):
                listener.exitLiteralassignstat(self)

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




    def literalassignstat(self):

        localctx = lfrXParser.LiteralassignstatContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_literalassignstat)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 415
            self.match(lfrXParser.ID)
            self.state = 416
            self.match(lfrXParser.T__25)
            self.state = 419
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
            if la_ == 1:
                self.state = 417
                self.bracketexpression()
                pass

            elif la_ == 2:
                self.state = 418
                self.expression()
                pass


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


    class BracketexpressionContext(ParserRuleContext):

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

        def expression(self):
            return self.getTypedRuleContext(lfrXParser.ExpressionContext,0)


        def unary_operator(self):
            return self.getTypedRuleContext(lfrXParser.Unary_operatorContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_bracketexpression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBracketexpression" ):
                listener.enterBracketexpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBracketexpression" ):
                listener.exitBracketexpression(self)

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




    def bracketexpression(self):

        localctx = lfrXParser.BracketexpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_bracketexpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 422
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << lfrXParser.T__30) | (1 << lfrXParser.T__31) | (1 << lfrXParser.T__39) | (1 << lfrXParser.T__40) | (1 << lfrXParser.T__41) | (1 << lfrXParser.T__42) | (1 << lfrXParser.T__43) | (1 << lfrXParser.T__44) | (1 << lfrXParser.T__45) | (1 << lfrXParser.T__46) | (1 << lfrXParser.T__47))) != 0):
                self.state = 421
                self.unary_operator()


            self.state = 424
            self.match(lfrXParser.T__2)
            self.state = 425
            self.expression()
            self.state = 426
            self.match(lfrXParser.T__3)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExpressionContext(ParserRuleContext):

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

        def bracketexpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(lfrXParser.BracketexpressionContext)
            else:
                return self.getTypedRuleContext(lfrXParser.BracketexpressionContext,i)


        def expressionterm(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(lfrXParser.ExpressiontermContext)
            else:
                return self.getTypedRuleContext(lfrXParser.ExpressiontermContext,i)


        def binary_operator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(lfrXParser.Binary_operatorContext)
            else:
                return self.getTypedRuleContext(lfrXParser.Binary_operatorContext,i)


        def getRuleIndex(self):
            return lfrXParser.RULE_expression

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExpression" ):
                listener.enterExpression(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExpression" ):
                listener.exitExpression(self)

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




    def expression(self):

        localctx = lfrXParser.ExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_expression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 430
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,37,self._ctx)
            if la_ == 1:
                self.state = 428
                self.bracketexpression()
                pass

            elif la_ == 2:
                self.state = 429
                self.expressionterm()
                pass


            self.state = 439
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << lfrXParser.T__18) | (1 << lfrXParser.T__30) | (1 << lfrXParser.T__31) | (1 << lfrXParser.T__36) | (1 << lfrXParser.T__37) | (1 << lfrXParser.T__38) | (1 << lfrXParser.T__39) | (1 << lfrXParser.T__40) | (1 << lfrXParser.T__45) | (1 << lfrXParser.T__46) | (1 << lfrXParser.T__47) | (1 << lfrXParser.T__48) | (1 << lfrXParser.T__49) | (1 << lfrXParser.T__50) | (1 << lfrXParser.T__51) | (1 << lfrXParser.T__52) | (1 << lfrXParser.T__53) | (1 << lfrXParser.T__54) | (1 << lfrXParser.T__55) | (1 << lfrXParser.T__56) | (1 << lfrXParser.T__57) | (1 << lfrXParser.T__58) | (1 << lfrXParser.T__59) | (1 << lfrXParser.T__60) | (1 << lfrXParser.T__61))) != 0):
                self.state = 432
                self.binary_operator()
                self.state = 435
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,38,self._ctx)
                if la_ == 1:
                    self.state = 433
                    self.bracketexpression()
                    pass

                elif la_ == 2:
                    self.state = 434
                    self.expressionterm()
                    pass


                self.state = 441
                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 ExpressiontermContext(ParserRuleContext):

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

        def variables(self):
            return self.getTypedRuleContext(lfrXParser.VariablesContext,0)


        def unary_operator(self):
            return self.getTypedRuleContext(lfrXParser.Unary_operatorContext,0)


        def number(self):
            return self.getTypedRuleContext(lfrXParser.NumberContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_expressionterm

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterExpressionterm" ):
                listener.enterExpressionterm(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitExpressionterm" ):
                listener.exitExpressionterm(self)

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




    def expressionterm(self):

        localctx = lfrXParser.ExpressiontermContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_expressionterm)
        self._la = 0 # Token type
        try:
            self.state = 447
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [lfrXParser.T__28, lfrXParser.T__30, lfrXParser.T__31, lfrXParser.T__39, lfrXParser.T__40, lfrXParser.T__41, lfrXParser.T__42, lfrXParser.T__43, lfrXParser.T__44, lfrXParser.T__45, lfrXParser.T__46, lfrXParser.T__47, lfrXParser.ID]:
                self.enterOuterAlt(localctx, 1)
                self.state = 443
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << lfrXParser.T__30) | (1 << lfrXParser.T__31) | (1 << lfrXParser.T__39) | (1 << lfrXParser.T__40) | (1 << lfrXParser.T__41) | (1 << lfrXParser.T__42) | (1 << lfrXParser.T__43) | (1 << lfrXParser.T__44) | (1 << lfrXParser.T__45) | (1 << lfrXParser.T__46) | (1 << lfrXParser.T__47))) != 0):
                    self.state = 442
                    self.unary_operator()


                self.state = 445
                self.variables()
                pass
            elif token in [lfrXParser.Real_number, lfrXParser.Decimal_number, lfrXParser.Binary_number, lfrXParser.Octal_number, lfrXParser.Hex_number]:
                self.enterOuterAlt(localctx, 2)
                self.state = 446
                self.number()
                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 Logiccondition_operandContext(ParserRuleContext):

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

        def bracketexpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(lfrXParser.BracketexpressionContext)
            else:
                return self.getTypedRuleContext(lfrXParser.BracketexpressionContext,i)


        def expressionterm(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(lfrXParser.ExpressiontermContext)
            else:
                return self.getTypedRuleContext(lfrXParser.ExpressiontermContext,i)


        def binary_operator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(lfrXParser.Binary_operatorContext)
            else:
                return self.getTypedRuleContext(lfrXParser.Binary_operatorContext,i)


        def getRuleIndex(self):
            return lfrXParser.RULE_logiccondition_operand

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLogiccondition_operand" ):
                listener.enterLogiccondition_operand(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLogiccondition_operand" ):
                listener.exitLogiccondition_operand(self)

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




    def logiccondition_operand(self):

        localctx = lfrXParser.Logiccondition_operandContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_logiccondition_operand)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 451
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,42,self._ctx)
            if la_ == 1:
                self.state = 449
                self.bracketexpression()
                pass

            elif la_ == 2:
                self.state = 450
                self.expressionterm()
                pass


            self.state = 460
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,44,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 453
                    self.binary_operator()
                    self.state = 456
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,43,self._ctx)
                    if la_ == 1:
                        self.state = 454
                        self.bracketexpression()
                        pass

                    elif la_ == 2:
                        self.state = 455
                        self.expressionterm()
                        pass

             
                self.state = 462
                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


    class LogicconditionContext(ParserRuleContext):

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

        def logiccondition_operand(self):
            return self.getTypedRuleContext(lfrXParser.Logiccondition_operandContext,0)


        def binary_module_path_operator(self):
            return self.getTypedRuleContext(lfrXParser.Binary_module_path_operatorContext,0)


        def logic_value(self):
            return self.getTypedRuleContext(lfrXParser.Logic_valueContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_logiccondition

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLogiccondition" ):
                listener.enterLogiccondition(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLogiccondition" ):
                listener.exitLogiccondition(self)

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




    def logiccondition(self):

        localctx = lfrXParser.LogicconditionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_logiccondition)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 463
            self.logiccondition_operand()
            self.state = 464
            self.binary_module_path_operator()
            self.state = 465
            self.logic_value()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Logic_valueContext(ParserRuleContext):

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

        def number(self):
            return self.getTypedRuleContext(lfrXParser.NumberContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_logic_value

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLogic_value" ):
                listener.enterLogic_value(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLogic_value" ):
                listener.exitLogic_value(self)

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




    def logic_value(self):

        localctx = lfrXParser.Logic_valueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_logic_value)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 467
            self.number()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VectorContext(ParserRuleContext):

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

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

        def getRuleIndex(self):
            return lfrXParser.RULE_vector

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVector" ):
                listener.enterVector(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVector" ):
                listener.exitVector(self)

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




    def vector(self):

        localctx = lfrXParser.VectorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_vector)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 469
            self.match(lfrXParser.T__26)
            self.state = 470
            localctx.start = self.match(lfrXParser.Decimal_number)
            self.state = 473
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==lfrXParser.T__16:
                self.state = 471
                self.match(lfrXParser.T__16)
                self.state = 472
                localctx.end = self.match(lfrXParser.Decimal_number)


            self.state = 475
            self.match(lfrXParser.T__27)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class VariablesContext(ParserRuleContext):

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

        def vectorvar(self):
            return self.getTypedRuleContext(lfrXParser.VectorvarContext,0)


        def concatenation(self):
            return self.getTypedRuleContext(lfrXParser.ConcatenationContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_variables

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterVariables" ):
                listener.enterVariables(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitVariables" ):
                listener.exitVariables(self)

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




    def variables(self):

        localctx = lfrXParser.VariablesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_variables)
        try:
            self.state = 479
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [lfrXParser.ID]:
                self.enterOuterAlt(localctx, 1)
                self.state = 477
                self.vectorvar()
                pass
            elif token in [lfrXParser.T__28]:
                self.enterOuterAlt(localctx, 2)
                self.state = 478
                self.concatenation()
                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 ConcatenationContext(ParserRuleContext):

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

        def vectorvar(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(lfrXParser.VectorvarContext)
            else:
                return self.getTypedRuleContext(lfrXParser.VectorvarContext,i)


        def vector(self):
            return self.getTypedRuleContext(lfrXParser.VectorContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_concatenation

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterConcatenation" ):
                listener.enterConcatenation(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitConcatenation" ):
                listener.exitConcatenation(self)

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




    def concatenation(self):

        localctx = lfrXParser.ConcatenationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_concatenation)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 481
            self.match(lfrXParser.T__28)
            self.state = 482
            self.vectorvar()
            self.state = 487
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==lfrXParser.T__5:
                self.state = 483
                self.match(lfrXParser.T__5)
                self.state = 484
                self.vectorvar()
                self.state = 489
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 490
            self.match(lfrXParser.T__29)
            self.state = 492
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==lfrXParser.T__26:
                self.state = 491
                self.vector()


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


    class LhsContext(ParserRuleContext):

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

        def variables(self):
            return self.getTypedRuleContext(lfrXParser.VariablesContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_lhs

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterLhs" ):
                listener.enterLhs(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitLhs" ):
                listener.exitLhs(self)

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




    def lhs(self):

        localctx = lfrXParser.LhsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_lhs)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 494
            self.variables()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IoassignstatContext(ParserRuleContext):

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

        def explicitIOBlock(self):
            return self.getTypedRuleContext(lfrXParser.ExplicitIOBlockContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_ioassignstat

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterIoassignstat" ):
                listener.enterIoassignstat(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitIoassignstat" ):
                listener.exitIoassignstat(self)

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




    def ioassignstat(self):

        localctx = lfrXParser.IoassignstatContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_ioassignstat)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 496
            self.explicitIOBlock()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class TechnologydirectivesContext(ParserRuleContext):

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

        def directive(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(lfrXParser.DirectiveContext)
            else:
                return self.getTypedRuleContext(lfrXParser.DirectiveContext,i)


        def getRuleIndex(self):
            return lfrXParser.RULE_technologydirectives

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTechnologydirectives" ):
                listener.enterTechnologydirectives(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTechnologydirectives" ):
                listener.exitTechnologydirectives(self)

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




    def technologydirectives(self):

        localctx = lfrXParser.TechnologydirectivesContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_technologydirectives)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 498
            self.directive()
            self.state = 503
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==lfrXParser.T__30 or _la==lfrXParser.T__31:
                self.state = 499
                _la = self._input.LA(1)
                if not(_la==lfrXParser.T__30 or _la==lfrXParser.T__31):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 500
                self.directive()
                self.state = 505
                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 DirectiveContext(ParserRuleContext):

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

        def performancedirective(self):
            return self.getTypedRuleContext(lfrXParser.PerformancedirectiveContext,0)


        def technologymappingdirective(self):
            return self.getTypedRuleContext(lfrXParser.TechnologymappingdirectiveContext,0)


        def materialmappingdirective(self):
            return self.getTypedRuleContext(lfrXParser.MaterialmappingdirectiveContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_directive

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterDirective" ):
                listener.enterDirective(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitDirective" ):
                listener.exitDirective(self)

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




    def directive(self):

        localctx = lfrXParser.DirectiveContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_directive)
        try:
            self.state = 509
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [lfrXParser.T__35]:
                self.enterOuterAlt(localctx, 1)
                self.state = 506
                self.performancedirective()
                pass
            elif token in [lfrXParser.T__32]:
                self.enterOuterAlt(localctx, 2)
                self.state = 507
                self.technologymappingdirective()
                pass
            elif token in [lfrXParser.T__34]:
                self.enterOuterAlt(localctx, 3)
                self.state = 508
                self.materialmappingdirective()
                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 TechnologymappingdirectiveContext(ParserRuleContext):

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

        def mappingoperator(self):
            return self.getTypedRuleContext(lfrXParser.MappingoperatorContext,0)


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

        def getRuleIndex(self):
            return lfrXParser.RULE_technologymappingdirective

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterTechnologymappingdirective" ):
                listener.enterTechnologymappingdirective(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitTechnologymappingdirective" ):
                listener.exitTechnologymappingdirective(self)

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




    def technologymappingdirective(self):

        localctx = lfrXParser.TechnologymappingdirectiveContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_technologymappingdirective)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 511
            self.match(lfrXParser.T__32)
            self.state = 512
            self.match(lfrXParser.T__33)
            self.state = 514 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 513
                self.match(lfrXParser.ID)
                self.state = 516 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==lfrXParser.ID):
                    break

            self.state = 518
            self.match(lfrXParser.T__33)
            self.state = 519
            self.match(lfrXParser.T__33)
            self.state = 522
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [lfrXParser.T__18, lfrXParser.T__30, lfrXParser.T__31, lfrXParser.T__36, lfrXParser.T__37, lfrXParser.T__38, lfrXParser.T__39, lfrXParser.T__40, lfrXParser.T__41, lfrXParser.T__42, lfrXParser.T__43, lfrXParser.T__44, lfrXParser.T__45, lfrXParser.T__46, lfrXParser.T__47, lfrXParser.T__48, lfrXParser.T__49, lfrXParser.T__50, lfrXParser.T__51, lfrXParser.T__52, lfrXParser.T__53, lfrXParser.T__54, lfrXParser.T__55, lfrXParser.T__56, lfrXParser.T__57, lfrXParser.T__58, lfrXParser.T__59, lfrXParser.T__60, lfrXParser.T__61]:
                self.state = 520
                self.mappingoperator()
                pass
            elif token in [lfrXParser.T__22, lfrXParser.T__24]:
                self.state = 521
                localctx.assignmode = self._input.LT(1)
                _la = self._input.LA(1)
                if not(_la==lfrXParser.T__22 or _la==lfrXParser.T__24):
                    localctx.assignmode = self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 524
            self.match(lfrXParser.T__33)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MaterialmappingdirectiveContext(ParserRuleContext):

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

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

        def getRuleIndex(self):
            return lfrXParser.RULE_materialmappingdirective

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMaterialmappingdirective" ):
                listener.enterMaterialmappingdirective(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMaterialmappingdirective" ):
                listener.exitMaterialmappingdirective(self)

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




    def materialmappingdirective(self):

        localctx = lfrXParser.MaterialmappingdirectiveContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_materialmappingdirective)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 526
            self.match(lfrXParser.T__34)
            self.state = 527
            self.match(lfrXParser.ID)
            self.state = 528
            localctx.materialtype = self.match(lfrXParser.ID)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MappingoperatorContext(ParserRuleContext):

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

        def binary_operator(self):
            return self.getTypedRuleContext(lfrXParser.Binary_operatorContext,0)


        def unary_operator(self):
            return self.getTypedRuleContext(lfrXParser.Unary_operatorContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_mappingoperator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterMappingoperator" ):
                listener.enterMappingoperator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitMappingoperator" ):
                listener.exitMappingoperator(self)

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




    def mappingoperator(self):

        localctx = lfrXParser.MappingoperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_mappingoperator)
        try:
            self.state = 532
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,53,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 530
                self.binary_operator()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 531
                self.unary_operator()
                pass


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


    class PerformancedirectiveContext(ParserRuleContext):

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

        def constraint(self):
            return self.getTypedRuleContext(lfrXParser.ConstraintContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_performancedirective

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterPerformancedirective" ):
                listener.enterPerformancedirective(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitPerformancedirective" ):
                listener.exitPerformancedirective(self)

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




    def performancedirective(self):

        localctx = lfrXParser.PerformancedirectiveContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_performancedirective)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 534
            self.match(lfrXParser.T__35)
            self.state = 535
            self.constraint()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ConstraintContext(ParserRuleContext):

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

        def ID(self):
            return self.getToken(lfrXParser.ID, 0)

        def number(self):
            return self.getTypedRuleContext(lfrXParser.NumberContext,0)


        def binary_operator(self):
            return self.getTypedRuleContext(lfrXParser.Binary_operatorContext,0)


        def unary_operator(self):
            return self.getTypedRuleContext(lfrXParser.Unary_operatorContext,0)


        def unit(self):
            return self.getTypedRuleContext(lfrXParser.UnitContext,0)


        def getRuleIndex(self):
            return lfrXParser.RULE_constraint

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterConstraint" ):
                listener.enterConstraint(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitConstraint" ):
                listener.exitConstraint(self)

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




    def constraint(self):

        localctx = lfrXParser.ConstraintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_constraint)
        try:
            self.state = 597
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,64,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 537
                self.match(lfrXParser.T__33)
                self.state = 540
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,54,self._ctx)
                if la_ == 1:
                    self.state = 538
                    self.binary_operator()
                    pass

                elif la_ == 2:
                    self.state = 539
                    self.unary_operator()
                    pass


                self.state = 542
                self.match(lfrXParser.T__33)
                self.state = 543
                self.match(lfrXParser.ID)
                self.state = 544
                localctx.operator = self.match(lfrXParser.T__25)
                self.state = 545
                self.number()
                self.state = 547
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,55,self._ctx)
                if la_ == 1:
                    self.state = 546
                    self.unit()


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 549
                self.match(lfrXParser.T__33)
                self.state = 552
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,56,self._ctx)
                if la_ == 1:
                    self.state = 550
                    self.binary_operator()
                    pass

                elif la_ == 2:
                    self.state = 551
                    self.unary_operator()
                    pass


                self.state = 554
                self.match(lfrXParser.T__33)
                self.state = 555
                self.match(lfrXParser.ID)
                self.state = 556
                localctx.operator = self.match(lfrXParser.T__36)
                self.state = 557
                self.number()
                self.state = 559
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,57,self._ctx)
                if la_ == 1:
                    self.state = 558
                    self.unit()


                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 561
                self.match(lfrXParser.T__33)
                self.state = 564
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,58,self._ctx)
                if la_ == 1:
                    self.state = 562
                    self.binary_operator()
                    pass

                elif la_ == 2:
                    self.state = 563
                    self.unary_operator()
                    pass


                self.state = 566
                self.match(lfrXParser.T__33)
                self.state = 567
                self.match(lfrXParser.ID)
                self.state = 568
                localctx.operator = self.match(lfrXParser.T__37)
                self.state = 569
                self.number()
                self.state = 571
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,59,self._ctx)
                if la_ == 1:
                    self.state = 570
                    self.unit()


                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 573
                self.match(lfrXParser.T__33)
                self.state = 576
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,60,self._ctx)
                if la_ == 1:
                    self.state = 574
                    self.binary_operator()
                    pass

                elif la_ == 2:
                    self.state = 575
                    self.unary_operator()
                    pass


                self.state = 578
                self.match(lfrXParser.T__33)
                self.state = 579
                self.match(lfrXParser.ID)
                self.state = 580
                localctx.operator = self.match(lfrXParser.T__38)
                self.state = 581
                self.number()
                self.state = 583
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,61,self._ctx)
                if la_ == 1:
                    self.state = 582
                    self.unit()


                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 585
                self.match(lfrXParser.T__33)
                self.state = 588
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,62,self._ctx)
                if la_ == 1:
                    self.state = 586
                    self.binary_operator()
                    pass

                elif la_ == 2:
                    self.state = 587
                    self.unary_operator()
                    pass


                self.state = 590
                self.match(lfrXParser.T__33)
                self.state = 591
                self.match(lfrXParser.ID)
                self.state = 592
                localctx.operator = self.match(lfrXParser.T__18)
                self.state = 593
                self.number()
                self.state = 595
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,63,self._ctx)
                if la_ == 1:
                    self.state = 594
                    self.unit()


                pass


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


    class UnitContext(ParserRuleContext):

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

        def ID(self):
            return self.getToken(lfrXParser.ID, 0)

        def getRuleIndex(self):
            return lfrXParser.RULE_unit

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUnit" ):
                listener.enterUnit(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUnit" ):
                listener.exitUnit(self)

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




    def unit(self):

        localctx = lfrXParser.UnitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_unit)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 599
            self.match(lfrXParser.ID)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Unary_operatorContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return lfrXParser.RULE_unary_operator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUnary_operator" ):
                listener.enterUnary_operator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUnary_operator" ):
                listener.exitUnary_operator(self)

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




    def unary_operator(self):

        localctx = lfrXParser.Unary_operatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_unary_operator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 601
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << lfrXParser.T__30) | (1 << lfrXParser.T__31) | (1 << lfrXParser.T__39) | (1 << lfrXParser.T__40) | (1 << lfrXParser.T__41) | (1 << lfrXParser.T__42) | (1 << lfrXParser.T__43) | (1 << lfrXParser.T__44) | (1 << lfrXParser.T__45) | (1 << lfrXParser.T__46) | (1 << lfrXParser.T__47))) != 0)):
                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 Binary_operatorContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return lfrXParser.RULE_binary_operator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBinary_operator" ):
                listener.enterBinary_operator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBinary_operator" ):
                listener.exitBinary_operator(self)

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




    def binary_operator(self):

        localctx = lfrXParser.Binary_operatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_binary_operator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 603
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << lfrXParser.T__18) | (1 << lfrXParser.T__30) | (1 << lfrXParser.T__31) | (1 << lfrXParser.T__36) | (1 << lfrXParser.T__37) | (1 << lfrXParser.T__38) | (1 << lfrXParser.T__39) | (1 << lfrXParser.T__40) | (1 << lfrXParser.T__45) | (1 << lfrXParser.T__46) | (1 << lfrXParser.T__47) | (1 << lfrXParser.T__48) | (1 << lfrXParser.T__49) | (1 << lfrXParser.T__50) | (1 << lfrXParser.T__51) | (1 << lfrXParser.T__52) | (1 << lfrXParser.T__53) | (1 << lfrXParser.T__54) | (1 << lfrXParser.T__55) | (1 << lfrXParser.T__56) | (1 << lfrXParser.T__57) | (1 << lfrXParser.T__58) | (1 << lfrXParser.T__59) | (1 << lfrXParser.T__60) | (1 << lfrXParser.T__61))) != 0)):
                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 Unary_module_path_operatorContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return lfrXParser.RULE_unary_module_path_operator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterUnary_module_path_operator" ):
                listener.enterUnary_module_path_operator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitUnary_module_path_operator" ):
                listener.exitUnary_module_path_operator(self)

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




    def unary_module_path_operator(self):

        localctx = lfrXParser.Unary_module_path_operatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_unary_module_path_operator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 605
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << lfrXParser.T__30) | (1 << lfrXParser.T__31) | (1 << lfrXParser.T__41) | (1 << lfrXParser.T__42) | (1 << lfrXParser.T__43) | (1 << lfrXParser.T__44) | (1 << lfrXParser.T__45) | (1 << lfrXParser.T__46) | (1 << lfrXParser.T__47))) != 0)):
                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 Binary_module_path_operatorContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return lfrXParser.RULE_binary_module_path_operator

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterBinary_module_path_operator" ):
                listener.enterBinary_module_path_operator(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitBinary_module_path_operator" ):
                listener.exitBinary_module_path_operator(self)

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




    def binary_module_path_operator(self):

        localctx = lfrXParser.Binary_module_path_operatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_binary_module_path_operator)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 607
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << lfrXParser.T__30) | (1 << lfrXParser.T__31) | (1 << lfrXParser.T__45) | (1 << lfrXParser.T__46) | (1 << lfrXParser.T__47) | (1 << lfrXParser.T__51) | (1 << lfrXParser.T__52) | (1 << lfrXParser.T__55) | (1 << lfrXParser.T__56))) != 0)):
                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 NumberContext(ParserRuleContext):

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

        def Decimal_number(self):
            return self.getToken(lfrXParser.Decimal_number, 0)

        def Octal_number(self):
            return self.getToken(lfrXParser.Octal_number, 0)

        def Binary_number(self):
            return self.getToken(lfrXParser.Binary_number, 0)

        def Hex_number(self):
            return self.getToken(lfrXParser.Hex_number, 0)

        def Real_number(self):
            return self.getToken(lfrXParser.Real_number, 0)

        def getRuleIndex(self):
            return lfrXParser.RULE_number

        def enterRule(self, listener:ParseTreeListener):
            if hasattr( listener, "enterNumber" ):
                listener.enterNumber(self)

        def exitRule(self, listener:ParseTreeListener):
            if hasattr( listener, "exitNumber" ):
                listener.exitNumber(self)

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




    def number(self):

        localctx = lfrXParser.NumberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_number)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 609
            _la = self._input.LA(1)
            if not(((((_la - 68)) & ~0x3f) == 0 and ((1 << (_la - 68)) & ((1 << (lfrXParser.Real_number - 68)) | (1 << (lfrXParser.Decimal_number - 68)) | (1 << (lfrXParser.Binary_number - 68)) | (1 << (lfrXParser.Octal_number - 68)) | (1 << (lfrXParser.Hex_number - 68)))) != 0)):
                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





