# Generated from Typescript.g4 by ANTLR 4.9.2
# encoding: utf-8
import sys
from io import StringIO

from antlr4 import *

if sys.version_info[1] > 5:
	from typing import TextIO
else:
	from typing.io import TextIO


def serializedATN():
    with StringIO() as buf:
        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\66")
        buf.write("\u02de\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\4C\tC\4D\t")
        buf.write("D\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\tJ\4K\tK\4L\tL\4M\t")
        buf.write("M\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\3\2\3\2\3\2\3\2\3\2\3")
        buf.write("\2\3\2\3\2\3\2\7\2\u00ae\n\2\f\2\16\2\u00b1\13\2\3\2\3")
        buf.write("\2\3\3\3\3\3\3\5\3\u00b8\n\3\3\4\3\4\3\4\3\4\3\4\5\4\u00bf")
        buf.write("\n\4\3\5\3\5\3\5\3\5\3\5\5\5\u00c6\n\5\3\6\3\6\5\6\u00ca")
        buf.write("\n\6\3\7\3\7\3\7\3\7\3\7\5\7\u00d1\n\7\3\b\3\b\3\b\5\b")
        buf.write("\u00d6\n\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\5\t\u00e0\n")
        buf.write("\t\3\n\3\n\3\n\5\n\u00e5\n\n\3\13\3\13\3\f\3\f\3\r\3\r")
        buf.write("\3\16\3\16\3\17\3\17\3\20\3\20\3\21\3\21\3\22\3\22\3\23")
        buf.write("\3\23\3\24\3\24\3\25\3\25\3\26\3\26\3\27\3\27\3\30\3\30")
        buf.write("\3\31\3\31\5\31\u0105\n\31\3\31\3\31\3\31\5\31\u010a\n")
        buf.write("\31\6\31\u010c\n\31\r\31\16\31\u010d\3\32\3\32\3\32\3")
        buf.write("\32\3\32\6\32\u0115\n\32\r\32\16\32\u0116\3\32\5\32\u011a")
        buf.write("\n\32\3\32\3\32\3\33\3\33\5\33\u0120\n\33\3\34\3\34\3")
        buf.write("\34\3\34\3\34\5\34\u0127\n\34\3\35\3\35\5\35\u012b\n\35")
        buf.write("\3\35\3\35\3\35\5\35\u0130\n\35\7\35\u0132\n\35\f\35\16")
        buf.write("\35\u0135\13\35\3\36\3\36\3\36\3\36\3\36\6\36\u013c\n")
        buf.write("\36\r\36\16\36\u013d\3\36\5\36\u0141\n\36\3\36\3\36\3")
        buf.write("\37\3\37\5\37\u0147\n\37\3 \3 \3 \3 \3 \3 \5 \u014f\n")
        buf.write(" \3!\3!\5!\u0153\n!\3!\3!\3!\5!\u0158\n!\6!\u015a\n!\r")
        buf.write("!\16!\u015b\3\"\3\"\3\"\3\"\3\"\6\"\u0163\n\"\r\"\16\"")
        buf.write("\u0164\3\"\5\"\u0168\n\"\3\"\3\"\3#\3#\3$\3$\5$\u0170")
        buf.write("\n$\3%\3%\5%\u0174\n%\3%\3%\3%\5%\u0179\n%\6%\u017b\n")
        buf.write("%\r%\16%\u017c\3&\3&\3&\3&\3&\6&\u0184\n&\r&\16&\u0185")
        buf.write("\3&\5&\u0189\n&\3&\3&\3\'\3\'\3(\3(\3(\5(\u0192\n(\3)")
        buf.write("\3)\3)\3)\5)\u0198\n)\3*\3*\5*\u019c\n*\3*\3*\3*\3+\3")
        buf.write("+\3+\3+\6+\u01a5\n+\r+\16+\u01a6\3,\3,\3-\3-\3-\3.\3.")
        buf.write("\3.\3.\5.\u01b2\n.\3/\3/\3/\7/\u01b7\n/\f/\16/\u01ba\13")
        buf.write("/\3\60\3\60\3\60\5\60\u01bf\n\60\3\61\3\61\3\61\7\61\u01c4")
        buf.write("\n\61\f\61\16\61\u01c7\13\61\3\62\3\62\3\62\3\62\5\62")
        buf.write("\u01cd\n\62\3\62\3\62\3\62\5\62\u01d2\n\62\3\63\3\63\3")
        buf.write("\63\3\63\3\64\3\64\3\64\5\64\u01db\n\64\3\64\3\64\5\64")
        buf.write("\u01df\n\64\3\65\3\65\3\65\3\65\3\65\3\65\5\65\u01e7\n")
        buf.write("\65\3\66\3\66\3\67\3\67\5\67\u01ed\n\67\38\38\38\38\3")
        buf.write("8\38\58\u01f5\n8\38\38\68\u01f9\n8\r8\168\u01fa\39\39")
        buf.write("\39\59\u0200\n9\3:\3:\3:\6:\u0205\n:\r:\16:\u0206\3;\3")
        buf.write(";\3;\3;\5;\u020d\n;\3;\5;\u0210\n;\3<\3<\3<\7<\u0215\n")
        buf.write("<\f<\16<\u0218\13<\3<\5<\u021b\n<\3<\5<\u021e\n<\3=\3")
        buf.write("=\3=\3=\3=\5=\u0225\n=\3>\3>\3>\3>\3>\3>\3>\3>\3>\5>\u0230")
        buf.write("\n>\3>\7>\u0233\n>\f>\16>\u0236\13>\3>\5>\u0239\n>\3?")
        buf.write("\3?\3?\3?\3?\3?\5?\u0241\n?\3@\3@\3@\3@\3@\3@\3@\3@\3")
        buf.write("@\3@\5@\u024d\n@\3A\3A\3B\3B\3C\3C\3D\3D\3D\3D\7D\u0259")
        buf.write("\nD\fD\16D\u025c\13D\5D\u025e\nD\3D\3D\3E\3E\3E\3E\3E")
        buf.write("\3E\3E\3E\3E\7E\u026b\nE\fE\16E\u026e\13E\5E\u0270\nE")
        buf.write("\3E\3E\3F\3F\3F\3F\3F\3F\3F\3F\3F\5F\u027d\nF\3F\3F\3")
        buf.write("G\3G\3G\3G\3G\3G\3H\3H\3H\3H\3H\3H\3H\3H\5H\u028f\nH\3")
        buf.write("H\3H\3H\3I\3I\3I\3I\3I\3I\3I\5I\u029b\nI\3I\3I\3I\3J\3")
        buf.write("J\3J\3J\3J\3J\3J\3J\3J\3K\3K\3K\3K\3L\3L\3M\3M\3N\3N\3")
        buf.write("N\3N\3N\3N\5N\u02b7\nN\3N\5N\u02ba\nN\3O\3O\3O\3O\3O\3")
        buf.write("O\5O\u02c2\nO\3O\5O\u02c5\nO\3P\3P\3P\3P\3P\3P\5P\u02cd")
        buf.write("\nP\3P\5P\u02d0\nP\3Q\3Q\3Q\3Q\5Q\u02d6\nQ\3R\3R\3R\3")
        buf.write("R\5R\u02dc\nR\3R\2\2S\2\4\6\b\n\f\16\20\22\24\26\30\32")
        buf.write("\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfh")
        buf.write("jlnprtvxz|~\u0080\u0082\u0084\u0086\u0088\u008a\u008c")
        buf.write("\u008e\u0090\u0092\u0094\u0096\u0098\u009a\u009c\u009e")
        buf.write("\u00a0\u00a2\2\7\3\2\27\30\3\2\31\32\3\2#%\3\2\3\4\3\2")
        buf.write(",-\2\u030a\2\u00af\3\2\2\2\4\u00b7\3\2\2\2\6\u00be\3\2")
        buf.write("\2\2\b\u00c5\3\2\2\2\n\u00c9\3\2\2\2\f\u00d0\3\2\2\2\16")
        buf.write("\u00d5\3\2\2\2\20\u00df\3\2\2\2\22\u00e4\3\2\2\2\24\u00e6")
        buf.write("\3\2\2\2\26\u00e8\3\2\2\2\30\u00ea\3\2\2\2\32\u00ec\3")
        buf.write("\2\2\2\34\u00ee\3\2\2\2\36\u00f0\3\2\2\2 \u00f2\3\2\2")
        buf.write("\2\"\u00f4\3\2\2\2$\u00f6\3\2\2\2&\u00f8\3\2\2\2(\u00fa")
        buf.write("\3\2\2\2*\u00fc\3\2\2\2,\u00fe\3\2\2\2.\u0100\3\2\2\2")
        buf.write("\60\u0104\3\2\2\2\62\u010f\3\2\2\2\64\u011f\3\2\2\2\66")
        buf.write("\u0126\3\2\2\28\u012a\3\2\2\2:\u0136\3\2\2\2<\u0146\3")
        buf.write("\2\2\2>\u014e\3\2\2\2@\u0152\3\2\2\2B\u015d\3\2\2\2D\u016b")
        buf.write("\3\2\2\2F\u016f\3\2\2\2H\u0173\3\2\2\2J\u017e\3\2\2\2")
        buf.write("L\u018c\3\2\2\2N\u0191\3\2\2\2P\u0193\3\2\2\2R\u019b\3")
        buf.write("\2\2\2T\u01a0\3\2\2\2V\u01a8\3\2\2\2X\u01aa\3\2\2\2Z\u01b1")
        buf.write("\3\2\2\2\\\u01b3\3\2\2\2^\u01bb\3\2\2\2`\u01c0\3\2\2\2")
        buf.write("b\u01c8\3\2\2\2d\u01d3\3\2\2\2f\u01d7\3\2\2\2h\u01e0\3")
        buf.write("\2\2\2j\u01e8\3\2\2\2l\u01ec\3\2\2\2n\u01ee\3\2\2\2p\u01ff")
        buf.write("\3\2\2\2r\u0201\3\2\2\2t\u020c\3\2\2\2v\u0216\3\2\2\2")
        buf.write("x\u021f\3\2\2\2z\u0226\3\2\2\2|\u023a\3\2\2\2~\u0242\3")
        buf.write("\2\2\2\u0080\u024e\3\2\2\2\u0082\u0250\3\2\2\2\u0084\u0252")
        buf.write("\3\2\2\2\u0086\u0254\3\2\2\2\u0088\u0261\3\2\2\2\u008a")
        buf.write("\u027c\3\2\2\2\u008c\u0280\3\2\2\2\u008e\u0286\3\2\2\2")
        buf.write("\u0090\u0293\3\2\2\2\u0092\u029f\3\2\2\2\u0094\u02a8\3")
        buf.write("\2\2\2\u0096\u02ac\3\2\2\2\u0098\u02ae\3\2\2\2\u009a\u02b0")
        buf.write("\3\2\2\2\u009c\u02bb\3\2\2\2\u009e\u02c6\3\2\2\2\u00a0")
        buf.write("\u02d1\3\2\2\2\u00a2\u02d7\3\2\2\2\u00a4\u00ae\5\16\b")
        buf.write("\2\u00a5\u00ae\5j\66\2\u00a6\u00ae\5\b\5\2\u00a7\u00ae")
        buf.write("\5\n\6\2\u00a8\u00ae\5\f\7\2\u00a9\u00ae\5\20\t\2\u00aa")
        buf.write("\u00ae\5x=\2\u00ab\u00ae\5X-\2\u00ac\u00ae\5\22\n\2\u00ad")
        buf.write("\u00a4\3\2\2\2\u00ad\u00a5\3\2\2\2\u00ad\u00a6\3\2\2\2")
        buf.write("\u00ad\u00a7\3\2\2\2\u00ad\u00a8\3\2\2\2\u00ad\u00a9\3")
        buf.write("\2\2\2\u00ad\u00aa\3\2\2\2\u00ad\u00ab\3\2\2\2\u00ad\u00ac")
        buf.write("\3\2\2\2\u00ae\u00b1\3\2\2\2\u00af\u00ad\3\2\2\2\u00af")
        buf.write("\u00b0\3\2\2\2\u00b0\u00b2\3\2\2\2\u00b1\u00af\3\2\2\2")
        buf.write("\u00b2\u00b3\7\2\2\3\u00b3\3\3\2\2\2\u00b4\u00b8\5\u0082")
        buf.write("B\2\u00b5\u00b8\5j\66\2\u00b6\u00b8\5\16\b\2\u00b7\u00b4")
        buf.write("\3\2\2\2\u00b7\u00b5\3\2\2\2\u00b7\u00b6\3\2\2\2\u00b8")
        buf.write("\5\3\2\2\2\u00b9\u00bf\5\24\13\2\u00ba\u00bf\5\26\f\2")
        buf.write("\u00bb\u00bf\5\30\r\2\u00bc\u00bf\5\32\16\2\u00bd\u00bf")
        buf.write("\5\34\17\2\u00be\u00b9\3\2\2\2\u00be\u00ba\3\2\2\2\u00be")
        buf.write("\u00bb\3\2\2\2\u00be\u00bc\3\2\2\2\u00be\u00bd\3\2\2\2")
        buf.write("\u00bf\7\3\2\2\2\u00c0\u00c6\5N(\2\u00c1\u00c6\5\60\31")
        buf.write("\2\u00c2\u00c6\58\35\2\u00c3\u00c6\5@!\2\u00c4\u00c6\5")
        buf.write("H%\2\u00c5\u00c0\3\2\2\2\u00c5\u00c1\3\2\2\2\u00c5\u00c2")
        buf.write("\3\2\2\2\u00c5\u00c3\3\2\2\2\u00c5\u00c4\3\2\2\2\u00c6")
        buf.write("\t\3\2\2\2\u00c7\u00ca\5\62\32\2\u00c8\u00ca\5:\36\2\u00c9")
        buf.write("\u00c7\3\2\2\2\u00c9\u00c8\3\2\2\2\u00ca\13\3\2\2\2\u00cb")
        buf.write("\u00d1\5\u0082B\2\u00cc\u00d1\5\u0084C\2\u00cd\u00d1\5")
        buf.write("\u0080A\2\u00ce\u00d1\5\u0086D\2\u00cf\u00d1\5\u0088E")
        buf.write("\2\u00d0\u00cb\3\2\2\2\u00d0\u00cc\3\2\2\2\u00d0\u00cd")
        buf.write("\3\2\2\2\u00d0\u00ce\3\2\2\2\u00d0\u00cf\3\2\2\2\u00d1")
        buf.write("\r\3\2\2\2\u00d2\u00d6\5n8\2\u00d3\u00d6\5r:\2\u00d4\u00d6")
        buf.write("\5f\64\2\u00d5\u00d2\3\2\2\2\u00d5\u00d3\3\2\2\2\u00d5")
        buf.write("\u00d4\3\2\2\2\u00d6\17\3\2\2\2\u00d7\u00e0\5z>\2\u00d8")
        buf.write("\u00e0\5\u008cG\2\u00d9\u00e0\5\u008eH\2\u00da\u00e0\5")
        buf.write("\u0090I\2\u00db\u00e0\5\u0092J\2\u00dc\u00e0\5\u008aF")
        buf.write("\2\u00dd\u00e0\5\u0096L\2\u00de\u00e0\5\u0098M\2\u00df")
        buf.write("\u00d7\3\2\2\2\u00df\u00d8\3\2\2\2\u00df\u00d9\3\2\2\2")
        buf.write("\u00df\u00da\3\2\2\2\u00df\u00db\3\2\2\2\u00df\u00dc\3")
        buf.write("\2\2\2\u00df\u00dd\3\2\2\2\u00df\u00de\3\2\2\2\u00e0\21")
        buf.write("\3\2\2\2\u00e1\u00e5\5\u009aN\2\u00e2\u00e5\5\u009cO\2")
        buf.write("\u00e3\u00e5\5\u009eP\2\u00e4\u00e1\3\2\2\2\u00e4\u00e2")
        buf.write("\3\2\2\2\u00e4\u00e3\3\2\2\2\u00e5\23\3\2\2\2\u00e6\u00e7")
        buf.write("\7\t\2\2\u00e7\25\3\2\2\2\u00e8\u00e9\7\n\2\2\u00e9\27")
        buf.write("\3\2\2\2\u00ea\u00eb\7\13\2\2\u00eb\31\3\2\2\2\u00ec\u00ed")
        buf.write("\7\f\2\2\u00ed\33\3\2\2\2\u00ee\u00ef\7\r\2\2\u00ef\35")
        buf.write("\3\2\2\2\u00f0\u00f1\7\24\2\2\u00f1\37\3\2\2\2\u00f2\u00f3")
        buf.write("\7\25\2\2\u00f3!\3\2\2\2\u00f4\u00f5\7\26\2\2\u00f5#\3")
        buf.write("\2\2\2\u00f6\u00f7\t\2\2\2\u00f7%\3\2\2\2\u00f8\u00f9")
        buf.write("\t\3\2\2\u00f9\'\3\2\2\2\u00fa\u00fb\7\33\2\2\u00fb)\3")
        buf.write("\2\2\2\u00fc\u00fd\7\34\2\2\u00fd+\3\2\2\2\u00fe\u00ff")
        buf.write("\7\35\2\2\u00ff-\3\2\2\2\u0100\u0101\7\36\2\2\u0101/\3")
        buf.write("\2\2\2\u0102\u0105\5\4\3\2\u0103\u0105\5\62\32\2\u0104")
        buf.write("\u0102\3\2\2\2\u0104\u0103\3\2\2\2\u0105\u010b\3\2\2\2")
        buf.write("\u0106\u0109\5\6\4\2\u0107\u010a\5\4\3\2\u0108\u010a\5")
        buf.write("\62\32\2\u0109\u0107\3\2\2\2\u0109\u0108\3\2\2\2\u010a")
        buf.write("\u010c\3\2\2\2\u010b\u0106\3\2\2\2\u010c\u010d\3\2\2\2")
        buf.write("\u010d\u010b\3\2\2\2\u010d\u010e\3\2\2\2\u010e\61\3\2")
        buf.write("\2\2\u010f\u0119\7\16\2\2\u0110\u0114\5\4\3\2\u0111\u0112")
        buf.write("\5\6\4\2\u0112\u0113\5\4\3\2\u0113\u0115\3\2\2\2\u0114")
        buf.write("\u0111\3\2\2\2\u0115\u0116\3\2\2\2\u0116\u0114\3\2\2\2")
        buf.write("\u0116\u0117\3\2\2\2\u0117\u011a\3\2\2\2\u0118\u011a\5")
        buf.write("\62\32\2\u0119\u0110\3\2\2\2\u0119\u0118\3\2\2\2\u011a")
        buf.write("\u011b\3\2\2\2\u011b\u011c\7\17\2\2\u011c\63\3\2\2\2\u011d")
        buf.write("\u0120\5\f\7\2\u011e\u0120\5j\66\2\u011f\u011d\3\2\2\2")
        buf.write("\u011f\u011e\3\2\2\2\u0120\65\3\2\2\2\u0121\u0127\5\36")
        buf.write("\20\2\u0122\u0127\5 \21\2\u0123\u0127\5\"\22\2\u0124\u0127")
        buf.write("\5$\23\2\u0125\u0127\5&\24\2\u0126\u0121\3\2\2\2\u0126")
        buf.write("\u0122\3\2\2\2\u0126\u0123\3\2\2\2\u0126\u0124\3\2\2\2")
        buf.write("\u0126\u0125\3\2\2\2\u0127\67\3\2\2\2\u0128\u012b\5\64")
        buf.write("\33\2\u0129\u012b\5:\36\2\u012a\u0128\3\2\2\2\u012a\u0129")
        buf.write("\3\2\2\2\u012b\u0133\3\2\2\2\u012c\u012f\5\66\34\2\u012d")
        buf.write("\u0130\5\64\33\2\u012e\u0130\5:\36\2\u012f\u012d\3\2\2")
        buf.write("\2\u012f\u012e\3\2\2\2\u0130\u0132\3\2\2\2\u0131\u012c")
        buf.write("\3\2\2\2\u0132\u0135\3\2\2\2\u0133\u0131\3\2\2\2\u0133")
        buf.write("\u0134\3\2\2\2\u01349\3\2\2\2\u0135\u0133\3\2\2\2\u0136")
        buf.write("\u0140\7\16\2\2\u0137\u013b\5\64\33\2\u0138\u0139\5\66")
        buf.write("\34\2\u0139\u013a\5\64\33\2\u013a\u013c\3\2\2\2\u013b")
        buf.write("\u0138\3\2\2\2\u013c\u013d\3\2\2\2\u013d\u013b\3\2\2\2")
        buf.write("\u013d\u013e\3\2\2\2\u013e\u0141\3\2\2\2\u013f\u0141\5")
        buf.write(":\36\2\u0140\u0137\3\2\2\2\u0140\u013f\3\2\2\2\u0141\u0142")
        buf.write("\3\2\2\2\u0142\u0143\7\17\2\2\u0143;\3\2\2\2\u0144\u0147")
        buf.write("\5\u0082B\2\u0145\u0147\5j\66\2\u0146\u0144\3\2\2\2\u0146")
        buf.write("\u0145\3\2\2\2\u0147=\3\2\2\2\u0148\u014f\5$\23\2\u0149")
        buf.write("\u014f\5&\24\2\u014a\u014f\5(\25\2\u014b\u014f\5*\26\2")
        buf.write("\u014c\u014f\5,\27\2\u014d\u014f\5.\30\2\u014e\u0148\3")
        buf.write("\2\2\2\u014e\u0149\3\2\2\2\u014e\u014a\3\2\2\2\u014e\u014b")
        buf.write("\3\2\2\2\u014e\u014c\3\2\2\2\u014e\u014d\3\2\2\2\u014f")
        buf.write("?\3\2\2\2\u0150\u0153\5<\37\2\u0151\u0153\5B\"\2\u0152")
        buf.write("\u0150\3\2\2\2\u0152\u0151\3\2\2\2\u0153\u0159\3\2\2\2")
        buf.write("\u0154\u0157\5> \2\u0155\u0158\5<\37\2\u0156\u0158\5B")
        buf.write("\"\2\u0157\u0155\3\2\2\2\u0157\u0156\3\2\2\2\u0158\u015a")
        buf.write("\3\2\2\2\u0159\u0154\3\2\2\2\u015a\u015b\3\2\2\2\u015b")
        buf.write("\u0159\3\2\2\2\u015b\u015c\3\2\2\2\u015cA\3\2\2\2\u015d")
        buf.write("\u0167\7\16\2\2\u015e\u0162\5<\37\2\u015f\u0160\5> \2")
        buf.write("\u0160\u0161\5<\37\2\u0161\u0163\3\2\2\2\u0162\u015f\3")
        buf.write("\2\2\2\u0163\u0164\3\2\2\2\u0164\u0162\3\2\2\2\u0164\u0165")
        buf.write("\3\2\2\2\u0165\u0168\3\2\2\2\u0166\u0168\5B\"\2\u0167")
        buf.write("\u015e\3\2\2\2\u0167\u0166\3\2\2\2\u0168\u0169\3\2\2\2")
        buf.write("\u0169\u016a\7\17\2\2\u016aC\3\2\2\2\u016b\u016c\5\u0080")
        buf.write("A\2\u016cE\3\2\2\2\u016d\u0170\5$\23\2\u016e\u0170\5&")
        buf.write("\24\2\u016f\u016d\3\2\2\2\u016f\u016e\3\2\2\2\u0170G\3")
        buf.write("\2\2\2\u0171\u0174\5D#\2\u0172\u0174\5J&\2\u0173\u0171")
        buf.write("\3\2\2\2\u0173\u0172\3\2\2\2\u0174\u017a\3\2\2\2\u0175")
        buf.write("\u0178\5F$\2\u0176\u0179\5D#\2\u0177\u0179\5J&\2\u0178")
        buf.write("\u0176\3\2\2\2\u0178\u0177\3\2\2\2\u0179\u017b\3\2\2\2")
        buf.write("\u017a\u0175\3\2\2\2\u017b\u017c\3\2\2\2\u017c\u017a\3")
        buf.write("\2\2\2\u017c\u017d\3\2\2\2\u017dI\3\2\2\2\u017e\u0188")
        buf.write("\7\16\2\2\u017f\u0183\5D#\2\u0180\u0181\5F$\2\u0181\u0182")
        buf.write("\5D#\2\u0182\u0184\3\2\2\2\u0183\u0180\3\2\2\2\u0184\u0185")
        buf.write("\3\2\2\2\u0185\u0183\3\2\2\2\u0185\u0186\3\2\2\2\u0186")
        buf.write("\u0189\3\2\2\2\u0187\u0189\5J&\2\u0188\u017f\3\2\2\2\u0188")
        buf.write("\u0187\3\2\2\2\u0189\u018a\3\2\2\2\u018a\u018b\7\17\2")
        buf.write("\2\u018bK\3\2\2\2\u018c\u018d\5\u0080A\2\u018dM\3\2\2")
        buf.write("\2\u018e\u0192\5T+\2\u018f\u0192\5P)\2\u0190\u0192\5R")
        buf.write("*\2\u0191\u018e\3\2\2\2\u0191\u018f\3\2\2\2\u0191\u0190")
        buf.write("\3\2\2\2\u0192O\3\2\2\2\u0193\u0194\5\u0080A\2\u0194\u0197")
        buf.write("\5\24\13\2\u0195\u0198\5\f\7\2\u0196\u0198\5j\66\2\u0197")
        buf.write("\u0195\3\2\2\2\u0197\u0196\3\2\2\2\u0198Q\3\2\2\2\u0199")
        buf.write("\u019c\5\f\7\2\u019a\u019c\5j\66\2\u019b\u0199\3\2\2\2")
        buf.write("\u019b\u019a\3\2\2\2\u019c\u019d\3\2\2\2\u019d\u019e\5")
        buf.write("\24\13\2\u019e\u019f\5\u0080A\2\u019fS\3\2\2\2\u01a0\u01a4")
        buf.write("\5\u0080A\2\u01a1\u01a2\5\24\13\2\u01a2\u01a3\5\u0080")
        buf.write("A\2\u01a3\u01a5\3\2\2\2\u01a4\u01a1\3\2\2\2\u01a5\u01a6")
        buf.write("\3\2\2\2\u01a6\u01a4\3\2\2\2\u01a6\u01a7\3\2\2\2\u01a7")
        buf.write("U\3\2\2\2\u01a8\u01a9\t\4\2\2\u01a9W\3\2\2\2\u01aa\u01ab")
        buf.write("\5b\62\2\u01ab\u01ac\5d\63\2\u01acY\3\2\2\2\u01ad\u01b2")
        buf.write("\5\f\7\2\u01ae\u01b2\5\b\5\2\u01af\u01b2\5h\65\2\u01b0")
        buf.write("\u01b2\5\16\b\2\u01b1\u01ad\3\2\2\2\u01b1\u01ae\3\2\2")
        buf.write("\2\u01b1\u01af\3\2\2\2\u01b1\u01b0\3\2\2\2\u01b2[\3\2")
        buf.write("\2\2\u01b3\u01b8\5Z.\2\u01b4\u01b5\7\7\2\2\u01b5\u01b7")
        buf.write("\5Z.\2\u01b6\u01b4\3\2\2\2\u01b7\u01ba\3\2\2\2\u01b8\u01b6")
        buf.write("\3\2\2\2\u01b8\u01b9\3\2\2\2\u01b9]\3\2\2\2\u01ba\u01b8")
        buf.write("\3\2\2\2\u01bb\u01be\5j\66\2\u01bc\u01bd\7\6\2\2\u01bd")
        buf.write("\u01bf\5V,\2\u01be\u01bc\3\2\2\2\u01be\u01bf\3\2\2\2\u01bf")
        buf.write("_\3\2\2\2\u01c0\u01c5\5^\60\2\u01c1\u01c2\7\7\2\2\u01c2")
        buf.write("\u01c4\5^\60\2\u01c3\u01c1\3\2\2\2\u01c4\u01c7\3\2\2\2")
        buf.write("\u01c5\u01c3\3\2\2\2\u01c5\u01c6\3\2\2\2\u01c6a\3\2\2")
        buf.write("\2\u01c7\u01c5\3\2\2\2\u01c8\u01c9\7\"\2\2\u01c9\u01ca")
        buf.write("\7\61\2\2\u01ca\u01cc\7\16\2\2\u01cb\u01cd\5`\61\2\u01cc")
        buf.write("\u01cb\3\2\2\2\u01cc\u01cd\3\2\2\2\u01cd\u01ce\3\2\2\2")
        buf.write("\u01ce\u01d1\7\17\2\2\u01cf\u01d0\7\6\2\2\u01d0\u01d2")
        buf.write("\5V,\2\u01d1\u01cf\3\2\2\2\u01d1\u01d2\3\2\2\2\u01d2c")
        buf.write("\3\2\2\2\u01d3\u01d4\7\20\2\2\u01d4\u01d5\5v<\2\u01d5")
        buf.write("\u01d6\7\21\2\2\u01d6e\3\2\2\2\u01d7\u01d8\7\61\2\2\u01d8")
        buf.write("\u01da\7\16\2\2\u01d9\u01db\5\\/\2\u01da\u01d9\3\2\2\2")
        buf.write("\u01da\u01db\3\2\2\2\u01db\u01dc\3\2\2\2\u01dc\u01de\7")
        buf.write("\17\2\2\u01dd\u01df\7\b\2\2\u01de\u01dd\3\2\2\2\u01de")
        buf.write("\u01df\3\2\2\2\u01dfg\3\2\2\2\u01e0\u01e1\7\16\2\2\u01e1")
        buf.write("\u01e2\5`\61\2\u01e2\u01e3\7\17\2\2\u01e3\u01e6\7&\2\2")
        buf.write("\u01e4\u01e7\5\b\5\2\u01e5\u01e7\5d\63\2\u01e6\u01e4\3")
        buf.write("\2\2\2\u01e6\u01e5\3\2\2\2\u01e7i\3\2\2\2\u01e8\u01e9")
        buf.write("\7\61\2\2\u01e9k\3\2\2\2\u01ea\u01ed\5\u0080A\2\u01eb")
        buf.write("\u01ed\5j\66\2\u01ec\u01ea\3\2\2\2\u01ec\u01eb\3\2\2\2")
        buf.write("\u01edm\3\2\2\2\u01ee\u01f8\5l\67\2\u01ef\u01f0\7\5\2")
        buf.write("\2\u01f0\u01f9\5j\66\2\u01f1\u01f4\7\22\2\2\u01f2\u01f5")
        buf.write("\5\u0082B\2\u01f3\u01f5\5\u0080A\2\u01f4\u01f2\3\2\2\2")
        buf.write("\u01f4\u01f3\3\2\2\2\u01f5\u01f6\3\2\2\2\u01f6\u01f7\7")
        buf.write("\23\2\2\u01f7\u01f9\3\2\2\2\u01f8\u01ef\3\2\2\2\u01f8")
        buf.write("\u01f1\3\2\2\2\u01f9\u01fa\3\2\2\2\u01fa\u01f8\3\2\2\2")
        buf.write("\u01fa\u01fb\3\2\2\2\u01fbo\3\2\2\2\u01fc\u0200\5\u0080")
        buf.write("A\2\u01fd\u0200\5j\66\2\u01fe\u0200\5\u0086D\2\u01ff\u01fc")
        buf.write("\3\2\2\2\u01ff\u01fd\3\2\2\2\u01ff\u01fe\3\2\2\2\u0200")
        buf.write("q\3\2\2\2\u0201\u0204\5p9\2\u0202\u0203\7\5\2\2\u0203")
        buf.write("\u0205\5f\64\2\u0204\u0202\3\2\2\2\u0205\u0206\3\2\2\2")
        buf.write("\u0206\u0204\3\2\2\2\u0206\u0207\3\2\2\2\u0207s\3\2\2")
        buf.write("\2\u0208\u020d\5\20\t\2\u0209\u020d\5\u009eP\2\u020a\u020d")
        buf.write("\5\16\b\2\u020b\u020d\5x=\2\u020c\u0208\3\2\2\2\u020c")
        buf.write("\u0209\3\2\2\2\u020c\u020a\3\2\2\2\u020c\u020b\3\2\2\2")
        buf.write("\u020d\u020f\3\2\2\2\u020e\u0210\7\b\2\2\u020f\u020e\3")
        buf.write("\2\2\2\u020f\u0210\3\2\2\2\u0210u\3\2\2\2\u0211\u0215")
        buf.write("\5\20\t\2\u0212\u0215\5\u009eP\2\u0213\u0215\5\16\b\2")
        buf.write("\u0214\u0211\3\2\2\2\u0214\u0212\3\2\2\2\u0214\u0213\3")
        buf.write("\2\2\2\u0215\u0218\3\2\2\2\u0216\u0214\3\2\2\2\u0216\u0217")
        buf.write("\3\2\2\2\u0217\u021a\3\2\2\2\u0218\u0216\3\2\2\2\u0219")
        buf.write("\u021b\5x=\2\u021a\u0219\3\2\2\2\u021a\u021b\3\2\2\2\u021b")
        buf.write("\u021d\3\2\2\2\u021c\u021e\7\b\2\2\u021d\u021c\3\2\2\2")
        buf.write("\u021d\u021e\3\2\2\2\u021ew\3\2\2\2\u021f\u0224\7!\2\2")
        buf.write("\u0220\u0225\5\f\7\2\u0221\u0225\5\b\5\2\u0222\u0225\5")
        buf.write("j\66\2\u0223\u0225\5\16\b\2\u0224\u0220\3\2\2\2\u0224")
        buf.write("\u0221\3\2\2\2\u0224\u0222\3\2\2\2\u0224\u0223\3\2\2\2")
        buf.write("\u0225y\3\2\2\2\u0226\u0227\7\37\2\2\u0227\u0228\7\16")
        buf.write("\2\2\u0228\u0229\5\b\5\2\u0229\u022f\7\17\2\2\u022a\u0230")
        buf.write("\5t;\2\u022b\u022c\7\20\2\2\u022c\u022d\5v<\2\u022d\u022e")
        buf.write("\7\21\2\2\u022e\u0230\3\2\2\2\u022f\u022a\3\2\2\2\u022f")
        buf.write("\u022b\3\2\2\2\u0230\u0234\3\2\2\2\u0231\u0233\5~@\2\u0232")
        buf.write("\u0231\3\2\2\2\u0233\u0236\3\2\2\2\u0234\u0232\3\2\2\2")
        buf.write("\u0234\u0235\3\2\2\2\u0235\u0238\3\2\2\2\u0236\u0234\3")
        buf.write("\2\2\2\u0237\u0239\5|?\2\u0238\u0237\3\2\2\2\u0238\u0239")
        buf.write("\3\2\2\2\u0239{\3\2\2\2\u023a\u0240\7 \2\2\u023b\u0241")
        buf.write("\5x=\2\u023c\u023d\7\20\2\2\u023d\u023e\5v<\2\u023e\u023f")
        buf.write("\7\21\2\2\u023f\u0241\3\2\2\2\u0240\u023b\3\2\2\2\u0240")
        buf.write("\u023c\3\2\2\2\u0241}\3\2\2\2\u0242\u0243\7 \2\2\u0243")
        buf.write("\u0244\7\37\2\2\u0244\u0245\7\16\2\2\u0245\u0246\58\35")
        buf.write("\2\u0246\u024c\7\17\2\2\u0247\u024d\5x=\2\u0248\u0249")
        buf.write("\7\20\2\2\u0249\u024a\5v<\2\u024a\u024b\7\21\2\2\u024b")
        buf.write("\u024d\3\2\2\2\u024c\u0247\3\2\2\2\u024c\u0248\3\2\2\2")
        buf.write("\u024d\177\3\2\2\2\u024e\u024f\7\62\2\2\u024f\u0081\3")
        buf.write("\2\2\2\u0250\u0251\7\63\2\2\u0251\u0083\3\2\2\2\u0252")
        buf.write("\u0253\t\5\2\2\u0253\u0085\3\2\2\2\u0254\u025d\7\22\2")
        buf.write("\2\u0255\u025a\5\f\7\2\u0256\u0257\7\7\2\2\u0257\u0259")
        buf.write("\5\f\7\2\u0258\u0256\3\2\2\2\u0259\u025c\3\2\2\2\u025a")
        buf.write("\u0258\3\2\2\2\u025a\u025b\3\2\2\2\u025b\u025e\3\2\2\2")
        buf.write("\u025c\u025a\3\2\2\2\u025d\u0255\3\2\2\2\u025d\u025e\3")
        buf.write("\2\2\2\u025e\u025f\3\2\2\2\u025f\u0260\7\23\2\2\u0260")
        buf.write("\u0087\3\2\2\2\u0261\u026f\7\20\2\2\u0262\u0263\5\u0080")
        buf.write("A\2\u0263\u0264\7\6\2\2\u0264\u026c\5\f\7\2\u0265\u0266")
        buf.write("\7\7\2\2\u0266\u0267\5\u0080A\2\u0267\u0268\7\6\2\2\u0268")
        buf.write("\u0269\5\f\7\2\u0269\u026b\3\2\2\2\u026a\u0265\3\2\2\2")
        buf.write("\u026b\u026e\3\2\2\2\u026c\u026a\3\2\2\2\u026c\u026d\3")
        buf.write("\2\2\2\u026d\u0270\3\2\2\2\u026e\u026c\3\2\2\2\u026f\u0262")
        buf.write("\3\2\2\2\u026f\u0270\3\2\2\2\u0270\u0271\3\2\2\2\u0271")
        buf.write("\u0272\7\21\2\2\u0272\u0089\3\2\2\2\u0273\u0274\7\'\2")
        buf.write("\2\u0274\u0275\7\16\2\2\u0275\u0276\7\3\2\2\u0276\u027d")
        buf.write("\7\17\2\2\u0277\u0278\7(\2\2\u0278\u0279\7\16\2\2\u0279")
        buf.write("\u027a\7\b\2\2\u027a\u027b\7\b\2\2\u027b\u027d\7\17\2")
        buf.write("\2\u027c\u0273\3\2\2\2\u027c\u0277\3\2\2\2\u027d\u027e")
        buf.write("\3\2\2\2\u027e\u027f\5\u0094K\2\u027f\u008b\3\2\2\2\u0280")
        buf.write("\u0281\7\'\2\2\u0281\u0282\7\16\2\2\u0282\u0283\5\b\5")
        buf.write("\2\u0283\u0284\7\17\2\2\u0284\u0285\5\u0094K\2\u0285\u008d")
        buf.write("\3\2\2\2\u0286\u0287\7(\2\2\u0287\u0288\7\16\2\2\u0288")
        buf.write("\u0289\5\22\n\2\u0289\u028a\7\b\2\2\u028a\u028b\5@!\2")
        buf.write("\u028b\u028e\7\b\2\2\u028c\u028f\5\u00a0Q\2\u028d\u028f")
        buf.write("\5\u00a2R\2\u028e\u028c\3\2\2\2\u028e\u028d\3\2\2\2\u028f")
        buf.write("\u0290\3\2\2\2\u0290\u0291\7\17\2\2\u0291\u0292\5\u0094")
        buf.write("K\2\u0292\u008f\3\2\2\2\u0293\u0294\7(\2\2\u0294\u0295")
        buf.write("\7\16\2\2\u0295\u0296\t\6\2\2\u0296\u0297\7\61\2\2\u0297")
        buf.write("\u029a\7*\2\2\u0298\u029b\5\u0086D\2\u0299\u029b\5\u0080")
        buf.write("A\2\u029a\u0298\3\2\2\2\u029a\u0299\3\2\2\2\u029b\u029c")
        buf.write("\3\2\2\2\u029c\u029d\7\17\2\2\u029d\u029e\5\u0094K\2\u029e")
        buf.write("\u0091\3\2\2\2\u029f\u02a0\7(\2\2\u02a0\u02a1\7\16\2\2")
        buf.write("\u02a1\u02a2\t\6\2\2\u02a2\u02a3\7\61\2\2\u02a3\u02a4")
        buf.write("\7)\2\2\u02a4\u02a5\5\u0086D\2\u02a5\u02a6\7\17\2\2\u02a6")
        buf.write("\u02a7\5\u0094K\2\u02a7\u0093\3\2\2\2\u02a8\u02a9\7\20")
        buf.write("\2\2\u02a9\u02aa\5v<\2\u02aa\u02ab\7\21\2\2\u02ab\u0095")
        buf.write("\3\2\2\2\u02ac\u02ad\7\60\2\2\u02ad\u0097\3\2\2\2\u02ae")
        buf.write("\u02af\7/\2\2\u02af\u0099\3\2\2\2\u02b0\u02b1\t\6\2\2")
        buf.write("\u02b1\u02b2\7\61\2\2\u02b2\u02b6\7.\2\2\u02b3\u02b7\5")
        buf.write("\b\5\2\u02b4\u02b7\5\f\7\2\u02b5\u02b7\5\16\b\2\u02b6")
        buf.write("\u02b3\3\2\2\2\u02b6\u02b4\3\2\2\2\u02b6\u02b5\3\2\2\2")
        buf.write("\u02b7\u02b9\3\2\2\2\u02b8\u02ba\7\b\2\2\u02b9\u02b8\3")
        buf.write("\2\2\2\u02b9\u02ba\3\2\2\2\u02ba\u009b\3\2\2\2\u02bb\u02bc")
        buf.write("\7+\2\2\u02bc\u02bd\7\61\2\2\u02bd\u02c1\7.\2\2\u02be")
        buf.write("\u02c2\5\b\5\2\u02bf\u02c2\5\f\7\2\u02c0\u02c2\5\16\b")
        buf.write("\2\u02c1\u02be\3\2\2\2\u02c1\u02bf\3\2\2\2\u02c1\u02c0")
        buf.write("\3\2\2\2\u02c2\u02c4\3\2\2\2\u02c3\u02c5\7\b\2\2\u02c4")
        buf.write("\u02c3\3\2\2\2\u02c4\u02c5\3\2\2\2\u02c5\u009d\3\2\2\2")
        buf.write("\u02c6\u02c7\7\61\2\2\u02c7\u02cc\7.\2\2\u02c8\u02cd\5")
        buf.write("\b\5\2\u02c9\u02cd\5\f\7\2\u02ca\u02cd\5\16\b\2\u02cb")
        buf.write("\u02cd\5j\66\2\u02cc\u02c8\3\2\2\2\u02cc\u02c9\3\2\2\2")
        buf.write("\u02cc\u02ca\3\2\2\2\u02cc\u02cb\3\2\2\2\u02cd\u02cf\3")
        buf.write("\2\2\2\u02ce\u02d0\7\b\2\2\u02cf\u02ce\3\2\2\2\u02cf\u02d0")
        buf.write("\3\2\2\2\u02d0\u009f\3\2\2\2\u02d1\u02d2\5j\66\2\u02d2")
        buf.write("\u02d3\7\t\2\2\u02d3\u02d5\7\t\2\2\u02d4\u02d6\7\b\2\2")
        buf.write("\u02d5\u02d4\3\2\2\2\u02d5\u02d6\3\2\2\2\u02d6\u00a1\3")
        buf.write("\2\2\2\u02d7\u02d8\5j\66\2\u02d8\u02d9\7\n\2\2\u02d9\u02db")
        buf.write("\7\n\2\2\u02da\u02dc\7\b\2\2\u02db\u02da\3\2\2\2\u02db")
        buf.write("\u02dc\3\2\2\2\u02dc\u00a3\3\2\2\2S\u00ad\u00af\u00b7")
        buf.write("\u00be\u00c5\u00c9\u00d0\u00d5\u00df\u00e4\u0104\u0109")
        buf.write("\u010d\u0116\u0119\u011f\u0126\u012a\u012f\u0133\u013d")
        buf.write("\u0140\u0146\u014e\u0152\u0157\u015b\u0164\u0167\u016f")
        buf.write("\u0173\u0178\u017c\u0185\u0188\u0191\u0197\u019b\u01a6")
        buf.write("\u01b1\u01b8\u01be\u01c5\u01cc\u01d1\u01da\u01de\u01e6")
        buf.write("\u01ec\u01f4\u01f8\u01fa\u01ff\u0206\u020c\u020f\u0214")
        buf.write("\u0216\u021a\u021d\u0224\u022f\u0234\u0238\u0240\u024c")
        buf.write("\u025a\u025d\u026c\u026f\u027c\u028e\u029a\u02b6\u02b9")
        buf.write("\u02c1\u02c4\u02cc\u02cf\u02d5\u02db")
        return buf.getvalue()


class TypescriptParser ( Parser ):

    grammarFileName = "Typescript.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'true'", "'false'", "'.'", "':'", "','", 
                     "';'", "'+'", "'-'", "'*'", "'/'", "'**'", "'('", "')'", 
                     "'{'", "'}'", "'['", "']'", "'&&'", "'||'", "'!'", 
                     "'=='", "'==='", "'!='", "'!=='", "'<'", "'<='", "'>'", 
                     "'>='", "'if'", "'else'", "'return'", "'function'", 
                     "'string'", "'number'", "'boolean'", "'=>'", "'while'", 
                     "'for'", "'in'", "'of'", "'const'", "'var'", "'let'", 
                     "'='", "'break'", "'continue'", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "' '" ]

    symbolicNames = [ "<INVALID>", "TRUE", "FALSE", "DOT", "COLON", "COMMA", 
                      "SEMICOLON", "PLUS", "MINUS", "MUL", "DIV", "POWER", 
                      "ROUND_LEFT", "ROUND_RIGHT", "CURLY_LEFT", "CURLY_RIGHT", 
                      "BRACKET_LEFT", "BRACKET_RIGHT", "AND", "OR", "NOT", 
                      "EQ", "STRICT_EQ", "NEQ", "STRICT_NEQ", "LT", "LE", 
                      "GT", "GE", "IF", "ELSE", "RETURN", "FUNCTION", "STRING", 
                      "NUMBER", "BOOLEAN", "ARROW", "WHILE", "FOR", "IN", 
                      "OF", "CONST", "VAR", "LET", "EQUAL", "BREAK", "CONTINUE", 
                      "IDENTIFIER", "CHARS", "DIGITS", "WS", "LINE_COMMENT", 
                      "WHITESPACE" ]

    RULE_sAll = 0
    RULE_sOperand = 1
    RULE_sOperator = 2
    RULE_sExpression = 3
    RULE_sTerm = 4
    RULE_sValue = 5
    RULE_sInvocation = 6
    RULE_sControl = 7
    RULE_sStatement = 8
    RULE_sPlus = 9
    RULE_sMinus = 10
    RULE_sMul = 11
    RULE_sDiv = 12
    RULE_sPower = 13
    RULE_sAnd = 14
    RULE_sOr = 15
    RULE_sNot = 16
    RULE_sEquals = 17
    RULE_sNotEquals = 18
    RULE_sLowerThan = 19
    RULE_sLowerEquals = 20
    RULE_sGreaterThan = 21
    RULE_sGreaterEquals = 22
    RULE_sArithmeticExpression = 23
    RULE_sArithmeticTerm = 24
    RULE_sBooleanOperand = 25
    RULE_sBooleanOperator = 26
    RULE_sBooleanExpression = 27
    RULE_sBooleanTerm = 28
    RULE_sNumberOperand = 29
    RULE_sNumberOperator = 30
    RULE_sNumberExpression = 31
    RULE_sNumberTerm = 32
    RULE_sStringOperand = 33
    RULE_sStringOperator = 34
    RULE_sStringExpression = 35
    RULE_sStringTerm = 36
    RULE_sConcatOperand = 37
    RULE_sConcatExpression = 38
    RULE_sConcatLeft = 39
    RULE_sConcatRight = 40
    RULE_sConcatBoth = 41
    RULE_sType = 42
    RULE_sFunction = 43
    RULE_sFunctionArg = 44
    RULE_sFunctionArgs = 45
    RULE_sFunctionArgDef = 46
    RULE_sFunctionArgDefs = 47
    RULE_sFunctionHead = 48
    RULE_sFunctionTail = 49
    RULE_sFunctionCall = 50
    RULE_sFunctionLambda = 51
    RULE_sProperty = 52
    RULE_sPropertyAware = 53
    RULE_sPropertyAccess = 54
    RULE_sFunctionAware = 55
    RULE_sFunctionAccess = 56
    RULE_sLine = 57
    RULE_sBody = 58
    RULE_sReturn = 59
    RULE_sIf = 60
    RULE_sElse = 61
    RULE_sElseIf = 62
    RULE_sString = 63
    RULE_sNumber = 64
    RULE_sBoolean = 65
    RULE_sArray = 66
    RULE_sMap = 67
    RULE_sEndlessLoop = 68
    RULE_sWhile = 69
    RULE_sFor = 70
    RULE_sForOf = 71
    RULE_sForIn = 72
    RULE_sLoopTail = 73
    RULE_sContinue = 74
    RULE_sBreak = 75
    RULE_sMutableVar = 76
    RULE_sImmutableVar = 77
    RULE_sAssignment = 78
    RULE_sIncrement = 79
    RULE_sDecrement = 80

    ruleNames =  [ "sAll", "sOperand", "sOperator", "sExpression", "sTerm", 
                   "sValue", "sInvocation", "sControl", "sStatement", "sPlus", 
                   "sMinus", "sMul", "sDiv", "sPower", "sAnd", "sOr", "sNot", 
                   "sEquals", "sNotEquals", "sLowerThan", "sLowerEquals", 
                   "sGreaterThan", "sGreaterEquals", "sArithmeticExpression", 
                   "sArithmeticTerm", "sBooleanOperand", "sBooleanOperator", 
                   "sBooleanExpression", "sBooleanTerm", "sNumberOperand", 
                   "sNumberOperator", "sNumberExpression", "sNumberTerm", 
                   "sStringOperand", "sStringOperator", "sStringExpression", 
                   "sStringTerm", "sConcatOperand", "sConcatExpression", 
                   "sConcatLeft", "sConcatRight", "sConcatBoth", "sType", 
                   "sFunction", "sFunctionArg", "sFunctionArgs", "sFunctionArgDef", 
                   "sFunctionArgDefs", "sFunctionHead", "sFunctionTail", 
                   "sFunctionCall", "sFunctionLambda", "sProperty", "sPropertyAware", 
                   "sPropertyAccess", "sFunctionAware", "sFunctionAccess", 
                   "sLine", "sBody", "sReturn", "sIf", "sElse", "sElseIf", 
                   "sString", "sNumber", "sBoolean", "sArray", "sMap", "sEndlessLoop", 
                   "sWhile", "sFor", "sForOf", "sForIn", "sLoopTail", "sContinue", 
                   "sBreak", "sMutableVar", "sImmutableVar", "sAssignment", 
                   "sIncrement", "sDecrement" ]

    EOF = Token.EOF
    TRUE=1
    FALSE=2
    DOT=3
    COLON=4
    COMMA=5
    SEMICOLON=6
    PLUS=7
    MINUS=8
    MUL=9
    DIV=10
    POWER=11
    ROUND_LEFT=12
    ROUND_RIGHT=13
    CURLY_LEFT=14
    CURLY_RIGHT=15
    BRACKET_LEFT=16
    BRACKET_RIGHT=17
    AND=18
    OR=19
    NOT=20
    EQ=21
    STRICT_EQ=22
    NEQ=23
    STRICT_NEQ=24
    LT=25
    LE=26
    GT=27
    GE=28
    IF=29
    ELSE=30
    RETURN=31
    FUNCTION=32
    STRING=33
    NUMBER=34
    BOOLEAN=35
    ARROW=36
    WHILE=37
    FOR=38
    IN=39
    OF=40
    CONST=41
    VAR=42
    LET=43
    EQUAL=44
    BREAK=45
    CONTINUE=46
    IDENTIFIER=47
    CHARS=48
    DIGITS=49
    WS=50
    LINE_COMMENT=51
    WHITESPACE=52

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




    class SAllContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def EOF(self):
            return self.getToken(TypescriptParser.EOF, 0)

        def sInvocation(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SInvocationContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SInvocationContext,i)


        def sProperty(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SPropertyContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SPropertyContext,i)


        def sExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SExpressionContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SExpressionContext,i)


        def sTerm(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.STermContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.STermContext,i)


        def sValue(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SValueContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SValueContext,i)


        def sControl(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SControlContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SControlContext,i)


        def sReturn(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SReturnContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SReturnContext,i)


        def sFunction(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SFunctionContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SFunctionContext,i)


        def sStatement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SStatementContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SStatementContext,i)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sAll

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

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

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




    def sAll(self):

        localctx = TypescriptParser.SAllContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_sAll)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 173
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << TypescriptParser.TRUE) | (1 << TypescriptParser.FALSE) | (1 << TypescriptParser.ROUND_LEFT) | (1 << TypescriptParser.CURLY_LEFT) | (1 << TypescriptParser.BRACKET_LEFT) | (1 << TypescriptParser.IF) | (1 << TypescriptParser.RETURN) | (1 << TypescriptParser.FUNCTION) | (1 << TypescriptParser.WHILE) | (1 << TypescriptParser.FOR) | (1 << TypescriptParser.CONST) | (1 << TypescriptParser.VAR) | (1 << TypescriptParser.LET) | (1 << TypescriptParser.BREAK) | (1 << TypescriptParser.CONTINUE) | (1 << TypescriptParser.IDENTIFIER) | (1 << TypescriptParser.CHARS) | (1 << TypescriptParser.DIGITS))) != 0):
                self.state = 171
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,0,self._ctx)
                if la_ == 1:
                    self.state = 162
                    self.sInvocation()
                    pass

                elif la_ == 2:
                    self.state = 163
                    self.sProperty()
                    pass

                elif la_ == 3:
                    self.state = 164
                    self.sExpression()
                    pass

                elif la_ == 4:
                    self.state = 165
                    self.sTerm()
                    pass

                elif la_ == 5:
                    self.state = 166
                    self.sValue()
                    pass

                elif la_ == 6:
                    self.state = 167
                    self.sControl()
                    pass

                elif la_ == 7:
                    self.state = 168
                    self.sReturn()
                    pass

                elif la_ == 8:
                    self.state = 169
                    self.sFunction()
                    pass

                elif la_ == 9:
                    self.state = 170
                    self.sStatement()
                    pass


                self.state = 175
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 176
            self.match(TypescriptParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SOperandContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sNumber(self):
            return self.getTypedRuleContext(TypescriptParser.SNumberContext,0)


        def sProperty(self):
            return self.getTypedRuleContext(TypescriptParser.SPropertyContext,0)


        def sInvocation(self):
            return self.getTypedRuleContext(TypescriptParser.SInvocationContext,0)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sOperand

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

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

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




    def sOperand(self):

        localctx = TypescriptParser.SOperandContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_sOperand)
        try:
            self.state = 181
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,2,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 178
                self.sNumber()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 179
                self.sProperty()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 180
                self.sInvocation()
                pass


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


    class SOperatorContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sPlus(self):
            return self.getTypedRuleContext(TypescriptParser.SPlusContext,0)


        def sMinus(self):
            return self.getTypedRuleContext(TypescriptParser.SMinusContext,0)


        def sMul(self):
            return self.getTypedRuleContext(TypescriptParser.SMulContext,0)


        def sDiv(self):
            return self.getTypedRuleContext(TypescriptParser.SDivContext,0)


        def sPower(self):
            return self.getTypedRuleContext(TypescriptParser.SPowerContext,0)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sOperator

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

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

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




    def sOperator(self):

        localctx = TypescriptParser.SOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_sOperator)
        try:
            self.state = 188
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [TypescriptParser.PLUS]:
                self.enterOuterAlt(localctx, 1)
                self.state = 183
                self.sPlus()
                pass
            elif token in [TypescriptParser.MINUS]:
                self.enterOuterAlt(localctx, 2)
                self.state = 184
                self.sMinus()
                pass
            elif token in [TypescriptParser.MUL]:
                self.enterOuterAlt(localctx, 3)
                self.state = 185
                self.sMul()
                pass
            elif token in [TypescriptParser.DIV]:
                self.enterOuterAlt(localctx, 4)
                self.state = 186
                self.sDiv()
                pass
            elif token in [TypescriptParser.POWER]:
                self.enterOuterAlt(localctx, 5)
                self.state = 187
                self.sPower()
                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 SExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sConcatExpression(self):
            return self.getTypedRuleContext(TypescriptParser.SConcatExpressionContext,0)


        def sArithmeticExpression(self):
            return self.getTypedRuleContext(TypescriptParser.SArithmeticExpressionContext,0)


        def sBooleanExpression(self):
            return self.getTypedRuleContext(TypescriptParser.SBooleanExpressionContext,0)


        def sNumberExpression(self):
            return self.getTypedRuleContext(TypescriptParser.SNumberExpressionContext,0)


        def sStringExpression(self):
            return self.getTypedRuleContext(TypescriptParser.SStringExpressionContext,0)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sExpression

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

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

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




    def sExpression(self):

        localctx = TypescriptParser.SExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_sExpression)
        try:
            self.state = 195
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,4,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 190
                self.sConcatExpression()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 191
                self.sArithmeticExpression()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 192
                self.sBooleanExpression()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 193
                self.sNumberExpression()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 194
                self.sStringExpression()
                pass


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


    class STermContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sArithmeticTerm(self):
            return self.getTypedRuleContext(TypescriptParser.SArithmeticTermContext,0)


        def sBooleanTerm(self):
            return self.getTypedRuleContext(TypescriptParser.SBooleanTermContext,0)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sTerm

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

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

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




    def sTerm(self):

        localctx = TypescriptParser.STermContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_sTerm)
        try:
            self.state = 199
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,5,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 197
                self.sArithmeticTerm()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 198
                self.sBooleanTerm()
                pass


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


    class SValueContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sNumber(self):
            return self.getTypedRuleContext(TypescriptParser.SNumberContext,0)


        def sBoolean(self):
            return self.getTypedRuleContext(TypescriptParser.SBooleanContext,0)


        def sString(self):
            return self.getTypedRuleContext(TypescriptParser.SStringContext,0)


        def sArray(self):
            return self.getTypedRuleContext(TypescriptParser.SArrayContext,0)


        def sMap(self):
            return self.getTypedRuleContext(TypescriptParser.SMapContext,0)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sValue

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

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

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




    def sValue(self):

        localctx = TypescriptParser.SValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_sValue)
        try:
            self.state = 206
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [TypescriptParser.DIGITS]:
                self.enterOuterAlt(localctx, 1)
                self.state = 201
                self.sNumber()
                pass
            elif token in [TypescriptParser.TRUE, TypescriptParser.FALSE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 202
                self.sBoolean()
                pass
            elif token in [TypescriptParser.CHARS]:
                self.enterOuterAlt(localctx, 3)
                self.state = 203
                self.sString()
                pass
            elif token in [TypescriptParser.BRACKET_LEFT]:
                self.enterOuterAlt(localctx, 4)
                self.state = 204
                self.sArray()
                pass
            elif token in [TypescriptParser.CURLY_LEFT]:
                self.enterOuterAlt(localctx, 5)
                self.state = 205
                self.sMap()
                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 SInvocationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sPropertyAccess(self):
            return self.getTypedRuleContext(TypescriptParser.SPropertyAccessContext,0)


        def sFunctionAccess(self):
            return self.getTypedRuleContext(TypescriptParser.SFunctionAccessContext,0)


        def sFunctionCall(self):
            return self.getTypedRuleContext(TypescriptParser.SFunctionCallContext,0)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sInvocation

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

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

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




    def sInvocation(self):

        localctx = TypescriptParser.SInvocationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_sInvocation)
        try:
            self.state = 211
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,7,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 208
                self.sPropertyAccess()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 209
                self.sFunctionAccess()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 210
                self.sFunctionCall()
                pass


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


    class SControlContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sIf(self):
            return self.getTypedRuleContext(TypescriptParser.SIfContext,0)


        def sWhile(self):
            return self.getTypedRuleContext(TypescriptParser.SWhileContext,0)


        def sFor(self):
            return self.getTypedRuleContext(TypescriptParser.SForContext,0)


        def sForOf(self):
            return self.getTypedRuleContext(TypescriptParser.SForOfContext,0)


        def sForIn(self):
            return self.getTypedRuleContext(TypescriptParser.SForInContext,0)


        def sEndlessLoop(self):
            return self.getTypedRuleContext(TypescriptParser.SEndlessLoopContext,0)


        def sContinue(self):
            return self.getTypedRuleContext(TypescriptParser.SContinueContext,0)


        def sBreak(self):
            return self.getTypedRuleContext(TypescriptParser.SBreakContext,0)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sControl

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

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

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




    def sControl(self):

        localctx = TypescriptParser.SControlContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_sControl)
        try:
            self.state = 221
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,8,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 213
                self.sIf()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 214
                self.sWhile()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 215
                self.sFor()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 216
                self.sForOf()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 217
                self.sForIn()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 218
                self.sEndlessLoop()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 219
                self.sContinue()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 220
                self.sBreak()
                pass


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


    class SStatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sMutableVar(self):
            return self.getTypedRuleContext(TypescriptParser.SMutableVarContext,0)


        def sImmutableVar(self):
            return self.getTypedRuleContext(TypescriptParser.SImmutableVarContext,0)


        def sAssignment(self):
            return self.getTypedRuleContext(TypescriptParser.SAssignmentContext,0)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sStatement

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

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

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




    def sStatement(self):

        localctx = TypescriptParser.SStatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_sStatement)
        try:
            self.state = 226
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [TypescriptParser.VAR, TypescriptParser.LET]:
                self.enterOuterAlt(localctx, 1)
                self.state = 223
                self.sMutableVar()
                pass
            elif token in [TypescriptParser.CONST]:
                self.enterOuterAlt(localctx, 2)
                self.state = 224
                self.sImmutableVar()
                pass
            elif token in [TypescriptParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 3)
                self.state = 225
                self.sAssignment()
                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 SPlusContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def PLUS(self):
            return self.getToken(TypescriptParser.PLUS, 0)

        def getRuleIndex(self):
            return TypescriptParser.RULE_sPlus

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

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

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




    def sPlus(self):

        localctx = TypescriptParser.SPlusContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_sPlus)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 228
            self.match(TypescriptParser.PLUS)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SMinusContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def MINUS(self):
            return self.getToken(TypescriptParser.MINUS, 0)

        def getRuleIndex(self):
            return TypescriptParser.RULE_sMinus

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

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

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




    def sMinus(self):

        localctx = TypescriptParser.SMinusContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_sMinus)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 230
            self.match(TypescriptParser.MINUS)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SMulContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def MUL(self):
            return self.getToken(TypescriptParser.MUL, 0)

        def getRuleIndex(self):
            return TypescriptParser.RULE_sMul

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

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

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




    def sMul(self):

        localctx = TypescriptParser.SMulContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_sMul)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 232
            self.match(TypescriptParser.MUL)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SDivContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DIV(self):
            return self.getToken(TypescriptParser.DIV, 0)

        def getRuleIndex(self):
            return TypescriptParser.RULE_sDiv

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

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

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




    def sDiv(self):

        localctx = TypescriptParser.SDivContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_sDiv)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 234
            self.match(TypescriptParser.DIV)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SPowerContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def POWER(self):
            return self.getToken(TypescriptParser.POWER, 0)

        def getRuleIndex(self):
            return TypescriptParser.RULE_sPower

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

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

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




    def sPower(self):

        localctx = TypescriptParser.SPowerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_sPower)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 236
            self.match(TypescriptParser.POWER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SAndContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def AND(self):
            return self.getToken(TypescriptParser.AND, 0)

        def getRuleIndex(self):
            return TypescriptParser.RULE_sAnd

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

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

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




    def sAnd(self):

        localctx = TypescriptParser.SAndContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_sAnd)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 238
            self.match(TypescriptParser.AND)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SOrContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def OR(self):
            return self.getToken(TypescriptParser.OR, 0)

        def getRuleIndex(self):
            return TypescriptParser.RULE_sOr

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

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

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




    def sOr(self):

        localctx = TypescriptParser.SOrContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_sOr)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 240
            self.match(TypescriptParser.OR)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SNotContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def NOT(self):
            return self.getToken(TypescriptParser.NOT, 0)

        def getRuleIndex(self):
            return TypescriptParser.RULE_sNot

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

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

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




    def sNot(self):

        localctx = TypescriptParser.SNotContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_sNot)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 242
            self.match(TypescriptParser.NOT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SEqualsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def EQ(self):
            return self.getToken(TypescriptParser.EQ, 0)

        def STRICT_EQ(self):
            return self.getToken(TypescriptParser.STRICT_EQ, 0)

        def getRuleIndex(self):
            return TypescriptParser.RULE_sEquals

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

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

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




    def sEquals(self):

        localctx = TypescriptParser.SEqualsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_sEquals)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 244
            _la = self._input.LA(1)
            if not(_la==TypescriptParser.EQ or _la==TypescriptParser.STRICT_EQ):
                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 SNotEqualsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def NEQ(self):
            return self.getToken(TypescriptParser.NEQ, 0)

        def STRICT_NEQ(self):
            return self.getToken(TypescriptParser.STRICT_NEQ, 0)

        def getRuleIndex(self):
            return TypescriptParser.RULE_sNotEquals

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

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

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




    def sNotEquals(self):

        localctx = TypescriptParser.SNotEqualsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_sNotEquals)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 246
            _la = self._input.LA(1)
            if not(_la==TypescriptParser.NEQ or _la==TypescriptParser.STRICT_NEQ):
                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 SLowerThanContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LT(self):
            return self.getToken(TypescriptParser.LT, 0)

        def getRuleIndex(self):
            return TypescriptParser.RULE_sLowerThan

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

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

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




    def sLowerThan(self):

        localctx = TypescriptParser.SLowerThanContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_sLowerThan)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 248
            self.match(TypescriptParser.LT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SLowerEqualsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def LE(self):
            return self.getToken(TypescriptParser.LE, 0)

        def getRuleIndex(self):
            return TypescriptParser.RULE_sLowerEquals

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

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

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




    def sLowerEquals(self):

        localctx = TypescriptParser.SLowerEqualsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_sLowerEquals)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 250
            self.match(TypescriptParser.LE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SGreaterThanContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def GT(self):
            return self.getToken(TypescriptParser.GT, 0)

        def getRuleIndex(self):
            return TypescriptParser.RULE_sGreaterThan

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

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

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




    def sGreaterThan(self):

        localctx = TypescriptParser.SGreaterThanContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_sGreaterThan)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 252
            self.match(TypescriptParser.GT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SGreaterEqualsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def GE(self):
            return self.getToken(TypescriptParser.GE, 0)

        def getRuleIndex(self):
            return TypescriptParser.RULE_sGreaterEquals

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

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

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




    def sGreaterEquals(self):

        localctx = TypescriptParser.SGreaterEqualsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_sGreaterEquals)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 254
            self.match(TypescriptParser.GE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SArithmeticExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sOperand(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SOperandContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SOperandContext,i)


        def sArithmeticTerm(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SArithmeticTermContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SArithmeticTermContext,i)


        def sOperator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SOperatorContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SOperatorContext,i)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sArithmeticExpression

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

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

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




    def sArithmeticExpression(self):

        localctx = TypescriptParser.SArithmeticExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_sArithmeticExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 258
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [TypescriptParser.BRACKET_LEFT, TypescriptParser.IDENTIFIER, TypescriptParser.CHARS, TypescriptParser.DIGITS]:
                self.state = 256
                self.sOperand()
                pass
            elif token in [TypescriptParser.ROUND_LEFT]:
                self.state = 257
                self.sArithmeticTerm()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 265 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 260
                self.sOperator()
                self.state = 263
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [TypescriptParser.BRACKET_LEFT, TypescriptParser.IDENTIFIER, TypescriptParser.CHARS, TypescriptParser.DIGITS]:
                    self.state = 261
                    self.sOperand()
                    pass
                elif token in [TypescriptParser.ROUND_LEFT]:
                    self.state = 262
                    self.sArithmeticTerm()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 267 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << TypescriptParser.PLUS) | (1 << TypescriptParser.MINUS) | (1 << TypescriptParser.MUL) | (1 << TypescriptParser.DIV) | (1 << TypescriptParser.POWER))) != 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 SArithmeticTermContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ROUND_LEFT(self):
            return self.getToken(TypescriptParser.ROUND_LEFT, 0)

        def ROUND_RIGHT(self):
            return self.getToken(TypescriptParser.ROUND_RIGHT, 0)

        def sArithmeticTerm(self):
            return self.getTypedRuleContext(TypescriptParser.SArithmeticTermContext,0)


        def sOperand(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SOperandContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SOperandContext,i)


        def sOperator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SOperatorContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SOperatorContext,i)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sArithmeticTerm

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

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

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




    def sArithmeticTerm(self):

        localctx = TypescriptParser.SArithmeticTermContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_sArithmeticTerm)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 269
            self.match(TypescriptParser.ROUND_LEFT)
            self.state = 279
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [TypescriptParser.BRACKET_LEFT, TypescriptParser.IDENTIFIER, TypescriptParser.CHARS, TypescriptParser.DIGITS]:
                self.state = 270
                self.sOperand()
                self.state = 274 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 271
                    self.sOperator()
                    self.state = 272
                    self.sOperand()
                    self.state = 276 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << TypescriptParser.PLUS) | (1 << TypescriptParser.MINUS) | (1 << TypescriptParser.MUL) | (1 << TypescriptParser.DIV) | (1 << TypescriptParser.POWER))) != 0)):
                        break

                pass
            elif token in [TypescriptParser.ROUND_LEFT]:
                self.state = 278
                self.sArithmeticTerm()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 281
            self.match(TypescriptParser.ROUND_RIGHT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SBooleanOperandContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sValue(self):
            return self.getTypedRuleContext(TypescriptParser.SValueContext,0)


        def sProperty(self):
            return self.getTypedRuleContext(TypescriptParser.SPropertyContext,0)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sBooleanOperand

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

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

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




    def sBooleanOperand(self):

        localctx = TypescriptParser.SBooleanOperandContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_sBooleanOperand)
        try:
            self.state = 285
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [TypescriptParser.TRUE, TypescriptParser.FALSE, TypescriptParser.CURLY_LEFT, TypescriptParser.BRACKET_LEFT, TypescriptParser.CHARS, TypescriptParser.DIGITS]:
                self.enterOuterAlt(localctx, 1)
                self.state = 283
                self.sValue()
                pass
            elif token in [TypescriptParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 284
                self.sProperty()
                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 SBooleanOperatorContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sAnd(self):
            return self.getTypedRuleContext(TypescriptParser.SAndContext,0)


        def sOr(self):
            return self.getTypedRuleContext(TypescriptParser.SOrContext,0)


        def sNot(self):
            return self.getTypedRuleContext(TypescriptParser.SNotContext,0)


        def sEquals(self):
            return self.getTypedRuleContext(TypescriptParser.SEqualsContext,0)


        def sNotEquals(self):
            return self.getTypedRuleContext(TypescriptParser.SNotEqualsContext,0)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sBooleanOperator

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

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

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




    def sBooleanOperator(self):

        localctx = TypescriptParser.SBooleanOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_sBooleanOperator)
        try:
            self.state = 292
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [TypescriptParser.AND]:
                self.enterOuterAlt(localctx, 1)
                self.state = 287
                self.sAnd()
                pass
            elif token in [TypescriptParser.OR]:
                self.enterOuterAlt(localctx, 2)
                self.state = 288
                self.sOr()
                pass
            elif token in [TypescriptParser.NOT]:
                self.enterOuterAlt(localctx, 3)
                self.state = 289
                self.sNot()
                pass
            elif token in [TypescriptParser.EQ, TypescriptParser.STRICT_EQ]:
                self.enterOuterAlt(localctx, 4)
                self.state = 290
                self.sEquals()
                pass
            elif token in [TypescriptParser.NEQ, TypescriptParser.STRICT_NEQ]:
                self.enterOuterAlt(localctx, 5)
                self.state = 291
                self.sNotEquals()
                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 SBooleanExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sBooleanOperand(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SBooleanOperandContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SBooleanOperandContext,i)


        def sBooleanTerm(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SBooleanTermContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SBooleanTermContext,i)


        def sBooleanOperator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SBooleanOperatorContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SBooleanOperatorContext,i)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sBooleanExpression

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

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

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




    def sBooleanExpression(self):

        localctx = TypescriptParser.SBooleanExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_sBooleanExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 296
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [TypescriptParser.TRUE, TypescriptParser.FALSE, TypescriptParser.CURLY_LEFT, TypescriptParser.BRACKET_LEFT, TypescriptParser.IDENTIFIER, TypescriptParser.CHARS, TypescriptParser.DIGITS]:
                self.state = 294
                self.sBooleanOperand()
                pass
            elif token in [TypescriptParser.ROUND_LEFT]:
                self.state = 295
                self.sBooleanTerm()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 305
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << TypescriptParser.AND) | (1 << TypescriptParser.OR) | (1 << TypescriptParser.NOT) | (1 << TypescriptParser.EQ) | (1 << TypescriptParser.STRICT_EQ) | (1 << TypescriptParser.NEQ) | (1 << TypescriptParser.STRICT_NEQ))) != 0):
                self.state = 298
                self.sBooleanOperator()
                self.state = 301
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [TypescriptParser.TRUE, TypescriptParser.FALSE, TypescriptParser.CURLY_LEFT, TypescriptParser.BRACKET_LEFT, TypescriptParser.IDENTIFIER, TypescriptParser.CHARS, TypescriptParser.DIGITS]:
                    self.state = 299
                    self.sBooleanOperand()
                    pass
                elif token in [TypescriptParser.ROUND_LEFT]:
                    self.state = 300
                    self.sBooleanTerm()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 307
                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 SBooleanTermContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ROUND_LEFT(self):
            return self.getToken(TypescriptParser.ROUND_LEFT, 0)

        def ROUND_RIGHT(self):
            return self.getToken(TypescriptParser.ROUND_RIGHT, 0)

        def sBooleanTerm(self):
            return self.getTypedRuleContext(TypescriptParser.SBooleanTermContext,0)


        def sBooleanOperand(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SBooleanOperandContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SBooleanOperandContext,i)


        def sBooleanOperator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SBooleanOperatorContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SBooleanOperatorContext,i)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sBooleanTerm

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

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

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




    def sBooleanTerm(self):

        localctx = TypescriptParser.SBooleanTermContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_sBooleanTerm)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 308
            self.match(TypescriptParser.ROUND_LEFT)
            self.state = 318
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [TypescriptParser.TRUE, TypescriptParser.FALSE, TypescriptParser.CURLY_LEFT, TypescriptParser.BRACKET_LEFT, TypescriptParser.IDENTIFIER, TypescriptParser.CHARS, TypescriptParser.DIGITS]:
                self.state = 309
                self.sBooleanOperand()
                self.state = 313 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 310
                    self.sBooleanOperator()
                    self.state = 311
                    self.sBooleanOperand()
                    self.state = 315 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << TypescriptParser.AND) | (1 << TypescriptParser.OR) | (1 << TypescriptParser.NOT) | (1 << TypescriptParser.EQ) | (1 << TypescriptParser.STRICT_EQ) | (1 << TypescriptParser.NEQ) | (1 << TypescriptParser.STRICT_NEQ))) != 0)):
                        break

                pass
            elif token in [TypescriptParser.ROUND_LEFT]:
                self.state = 317
                self.sBooleanTerm()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 320
            self.match(TypescriptParser.ROUND_RIGHT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SNumberOperandContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sNumber(self):
            return self.getTypedRuleContext(TypescriptParser.SNumberContext,0)


        def sProperty(self):
            return self.getTypedRuleContext(TypescriptParser.SPropertyContext,0)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sNumberOperand

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

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

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




    def sNumberOperand(self):

        localctx = TypescriptParser.SNumberOperandContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_sNumberOperand)
        try:
            self.state = 324
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [TypescriptParser.DIGITS]:
                self.enterOuterAlt(localctx, 1)
                self.state = 322
                self.sNumber()
                pass
            elif token in [TypescriptParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 323
                self.sProperty()
                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 SNumberOperatorContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sEquals(self):
            return self.getTypedRuleContext(TypescriptParser.SEqualsContext,0)


        def sNotEquals(self):
            return self.getTypedRuleContext(TypescriptParser.SNotEqualsContext,0)


        def sLowerThan(self):
            return self.getTypedRuleContext(TypescriptParser.SLowerThanContext,0)


        def sLowerEquals(self):
            return self.getTypedRuleContext(TypescriptParser.SLowerEqualsContext,0)


        def sGreaterThan(self):
            return self.getTypedRuleContext(TypescriptParser.SGreaterThanContext,0)


        def sGreaterEquals(self):
            return self.getTypedRuleContext(TypescriptParser.SGreaterEqualsContext,0)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sNumberOperator

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

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

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




    def sNumberOperator(self):

        localctx = TypescriptParser.SNumberOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_sNumberOperator)
        try:
            self.state = 332
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [TypescriptParser.EQ, TypescriptParser.STRICT_EQ]:
                self.enterOuterAlt(localctx, 1)
                self.state = 326
                self.sEquals()
                pass
            elif token in [TypescriptParser.NEQ, TypescriptParser.STRICT_NEQ]:
                self.enterOuterAlt(localctx, 2)
                self.state = 327
                self.sNotEquals()
                pass
            elif token in [TypescriptParser.LT]:
                self.enterOuterAlt(localctx, 3)
                self.state = 328
                self.sLowerThan()
                pass
            elif token in [TypescriptParser.LE]:
                self.enterOuterAlt(localctx, 4)
                self.state = 329
                self.sLowerEquals()
                pass
            elif token in [TypescriptParser.GT]:
                self.enterOuterAlt(localctx, 5)
                self.state = 330
                self.sGreaterThan()
                pass
            elif token in [TypescriptParser.GE]:
                self.enterOuterAlt(localctx, 6)
                self.state = 331
                self.sGreaterEquals()
                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 SNumberExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sNumberOperand(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SNumberOperandContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SNumberOperandContext,i)


        def sNumberTerm(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SNumberTermContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SNumberTermContext,i)


        def sNumberOperator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SNumberOperatorContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SNumberOperatorContext,i)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sNumberExpression

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

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

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




    def sNumberExpression(self):

        localctx = TypescriptParser.SNumberExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_sNumberExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 336
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [TypescriptParser.IDENTIFIER, TypescriptParser.DIGITS]:
                self.state = 334
                self.sNumberOperand()
                pass
            elif token in [TypescriptParser.ROUND_LEFT]:
                self.state = 335
                self.sNumberTerm()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 343 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 338
                self.sNumberOperator()
                self.state = 341
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [TypescriptParser.IDENTIFIER, TypescriptParser.DIGITS]:
                    self.state = 339
                    self.sNumberOperand()
                    pass
                elif token in [TypescriptParser.ROUND_LEFT]:
                    self.state = 340
                    self.sNumberTerm()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 345 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << TypescriptParser.EQ) | (1 << TypescriptParser.STRICT_EQ) | (1 << TypescriptParser.NEQ) | (1 << TypescriptParser.STRICT_NEQ) | (1 << TypescriptParser.LT) | (1 << TypescriptParser.LE) | (1 << TypescriptParser.GT) | (1 << TypescriptParser.GE))) != 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 SNumberTermContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ROUND_LEFT(self):
            return self.getToken(TypescriptParser.ROUND_LEFT, 0)

        def ROUND_RIGHT(self):
            return self.getToken(TypescriptParser.ROUND_RIGHT, 0)

        def sNumberTerm(self):
            return self.getTypedRuleContext(TypescriptParser.SNumberTermContext,0)


        def sNumberOperand(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SNumberOperandContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SNumberOperandContext,i)


        def sNumberOperator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SNumberOperatorContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SNumberOperatorContext,i)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sNumberTerm

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

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

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




    def sNumberTerm(self):

        localctx = TypescriptParser.SNumberTermContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_sNumberTerm)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 347
            self.match(TypescriptParser.ROUND_LEFT)
            self.state = 357
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [TypescriptParser.IDENTIFIER, TypescriptParser.DIGITS]:
                self.state = 348
                self.sNumberOperand()
                self.state = 352 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 349
                    self.sNumberOperator()
                    self.state = 350
                    self.sNumberOperand()
                    self.state = 354 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << TypescriptParser.EQ) | (1 << TypescriptParser.STRICT_EQ) | (1 << TypescriptParser.NEQ) | (1 << TypescriptParser.STRICT_NEQ) | (1 << TypescriptParser.LT) | (1 << TypescriptParser.LE) | (1 << TypescriptParser.GT) | (1 << TypescriptParser.GE))) != 0)):
                        break

                pass
            elif token in [TypescriptParser.ROUND_LEFT]:
                self.state = 356
                self.sNumberTerm()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 359
            self.match(TypescriptParser.ROUND_RIGHT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SStringOperandContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sString(self):
            return self.getTypedRuleContext(TypescriptParser.SStringContext,0)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sStringOperand

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

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

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




    def sStringOperand(self):

        localctx = TypescriptParser.SStringOperandContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_sStringOperand)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 361
            self.sString()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SStringOperatorContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sEquals(self):
            return self.getTypedRuleContext(TypescriptParser.SEqualsContext,0)


        def sNotEquals(self):
            return self.getTypedRuleContext(TypescriptParser.SNotEqualsContext,0)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sStringOperator

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

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

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




    def sStringOperator(self):

        localctx = TypescriptParser.SStringOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_sStringOperator)
        try:
            self.state = 365
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [TypescriptParser.EQ, TypescriptParser.STRICT_EQ]:
                self.enterOuterAlt(localctx, 1)
                self.state = 363
                self.sEquals()
                pass
            elif token in [TypescriptParser.NEQ, TypescriptParser.STRICT_NEQ]:
                self.enterOuterAlt(localctx, 2)
                self.state = 364
                self.sNotEquals()
                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 SStringExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sStringOperand(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SStringOperandContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SStringOperandContext,i)


        def sStringTerm(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SStringTermContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SStringTermContext,i)


        def sStringOperator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SStringOperatorContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SStringOperatorContext,i)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sStringExpression

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

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

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




    def sStringExpression(self):

        localctx = TypescriptParser.SStringExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_sStringExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 369
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [TypescriptParser.CHARS]:
                self.state = 367
                self.sStringOperand()
                pass
            elif token in [TypescriptParser.ROUND_LEFT]:
                self.state = 368
                self.sStringTerm()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 376 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 371
                self.sStringOperator()
                self.state = 374
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [TypescriptParser.CHARS]:
                    self.state = 372
                    self.sStringOperand()
                    pass
                elif token in [TypescriptParser.ROUND_LEFT]:
                    self.state = 373
                    self.sStringTerm()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 378 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << TypescriptParser.EQ) | (1 << TypescriptParser.STRICT_EQ) | (1 << TypescriptParser.NEQ) | (1 << TypescriptParser.STRICT_NEQ))) != 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 SStringTermContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ROUND_LEFT(self):
            return self.getToken(TypescriptParser.ROUND_LEFT, 0)

        def ROUND_RIGHT(self):
            return self.getToken(TypescriptParser.ROUND_RIGHT, 0)

        def sStringTerm(self):
            return self.getTypedRuleContext(TypescriptParser.SStringTermContext,0)


        def sStringOperand(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SStringOperandContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SStringOperandContext,i)


        def sStringOperator(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SStringOperatorContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SStringOperatorContext,i)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sStringTerm

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

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

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




    def sStringTerm(self):

        localctx = TypescriptParser.SStringTermContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_sStringTerm)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 380
            self.match(TypescriptParser.ROUND_LEFT)
            self.state = 390
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [TypescriptParser.CHARS]:
                self.state = 381
                self.sStringOperand()
                self.state = 385 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 382
                    self.sStringOperator()
                    self.state = 383
                    self.sStringOperand()
                    self.state = 387 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << TypescriptParser.EQ) | (1 << TypescriptParser.STRICT_EQ) | (1 << TypescriptParser.NEQ) | (1 << TypescriptParser.STRICT_NEQ))) != 0)):
                        break

                pass
            elif token in [TypescriptParser.ROUND_LEFT]:
                self.state = 389
                self.sStringTerm()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 392
            self.match(TypescriptParser.ROUND_RIGHT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SConcatOperandContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sString(self):
            return self.getTypedRuleContext(TypescriptParser.SStringContext,0)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sConcatOperand

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

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

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




    def sConcatOperand(self):

        localctx = TypescriptParser.SConcatOperandContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_sConcatOperand)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 394
            self.sString()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SConcatExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sConcatBoth(self):
            return self.getTypedRuleContext(TypescriptParser.SConcatBothContext,0)


        def sConcatLeft(self):
            return self.getTypedRuleContext(TypescriptParser.SConcatLeftContext,0)


        def sConcatRight(self):
            return self.getTypedRuleContext(TypescriptParser.SConcatRightContext,0)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sConcatExpression

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

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

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




    def sConcatExpression(self):

        localctx = TypescriptParser.SConcatExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_sConcatExpression)
        try:
            self.state = 399
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 396
                self.sConcatBoth()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 397
                self.sConcatLeft()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 398
                self.sConcatRight()
                pass


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


    class SConcatLeftContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sString(self):
            return self.getTypedRuleContext(TypescriptParser.SStringContext,0)


        def sPlus(self):
            return self.getTypedRuleContext(TypescriptParser.SPlusContext,0)


        def sValue(self):
            return self.getTypedRuleContext(TypescriptParser.SValueContext,0)


        def sProperty(self):
            return self.getTypedRuleContext(TypescriptParser.SPropertyContext,0)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sConcatLeft

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

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

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




    def sConcatLeft(self):

        localctx = TypescriptParser.SConcatLeftContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_sConcatLeft)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 401
            self.sString()
            self.state = 402
            self.sPlus()
            self.state = 405
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [TypescriptParser.TRUE, TypescriptParser.FALSE, TypescriptParser.CURLY_LEFT, TypescriptParser.BRACKET_LEFT, TypescriptParser.CHARS, TypescriptParser.DIGITS]:
                self.state = 403
                self.sValue()
                pass
            elif token in [TypescriptParser.IDENTIFIER]:
                self.state = 404
                self.sProperty()
                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 SConcatRightContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sPlus(self):
            return self.getTypedRuleContext(TypescriptParser.SPlusContext,0)


        def sString(self):
            return self.getTypedRuleContext(TypescriptParser.SStringContext,0)


        def sValue(self):
            return self.getTypedRuleContext(TypescriptParser.SValueContext,0)


        def sProperty(self):
            return self.getTypedRuleContext(TypescriptParser.SPropertyContext,0)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sConcatRight

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

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

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




    def sConcatRight(self):

        localctx = TypescriptParser.SConcatRightContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_sConcatRight)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 409
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [TypescriptParser.TRUE, TypescriptParser.FALSE, TypescriptParser.CURLY_LEFT, TypescriptParser.BRACKET_LEFT, TypescriptParser.CHARS, TypescriptParser.DIGITS]:
                self.state = 407
                self.sValue()
                pass
            elif token in [TypescriptParser.IDENTIFIER]:
                self.state = 408
                self.sProperty()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 411
            self.sPlus()
            self.state = 412
            self.sString()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SConcatBothContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sString(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SStringContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SStringContext,i)


        def sPlus(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SPlusContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SPlusContext,i)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sConcatBoth

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

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

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




    def sConcatBoth(self):

        localctx = TypescriptParser.SConcatBothContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_sConcatBoth)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 414
            self.sString()
            self.state = 418 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 415
                self.sPlus()
                self.state = 416
                self.sString()
                self.state = 420 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==TypescriptParser.PLUS):
                    break

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


    class STypeContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

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

        def BOOLEAN(self):
            return self.getToken(TypescriptParser.BOOLEAN, 0)

        def getRuleIndex(self):
            return TypescriptParser.RULE_sType

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

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

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




    def sType(self):

        localctx = TypescriptParser.STypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_sType)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 422
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << TypescriptParser.STRING) | (1 << TypescriptParser.NUMBER) | (1 << TypescriptParser.BOOLEAN))) != 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 SFunctionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sFunctionHead(self):
            return self.getTypedRuleContext(TypescriptParser.SFunctionHeadContext,0)


        def sFunctionTail(self):
            return self.getTypedRuleContext(TypescriptParser.SFunctionTailContext,0)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sFunction

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

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

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




    def sFunction(self):

        localctx = TypescriptParser.SFunctionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_sFunction)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 424
            self.sFunctionHead()
            self.state = 425
            self.sFunctionTail()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SFunctionArgContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sValue(self):
            return self.getTypedRuleContext(TypescriptParser.SValueContext,0)


        def sExpression(self):
            return self.getTypedRuleContext(TypescriptParser.SExpressionContext,0)


        def sFunctionLambda(self):
            return self.getTypedRuleContext(TypescriptParser.SFunctionLambdaContext,0)


        def sInvocation(self):
            return self.getTypedRuleContext(TypescriptParser.SInvocationContext,0)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sFunctionArg

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

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

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




    def sFunctionArg(self):

        localctx = TypescriptParser.SFunctionArgContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_sFunctionArg)
        try:
            self.state = 431
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,39,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 427
                self.sValue()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 428
                self.sExpression()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 429
                self.sFunctionLambda()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 430
                self.sInvocation()
                pass


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


    class SFunctionArgsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sFunctionArg(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SFunctionArgContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SFunctionArgContext,i)


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

        def getRuleIndex(self):
            return TypescriptParser.RULE_sFunctionArgs

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

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

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




    def sFunctionArgs(self):

        localctx = TypescriptParser.SFunctionArgsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_sFunctionArgs)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 433
            self.sFunctionArg()
            self.state = 438
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==TypescriptParser.COMMA:
                self.state = 434
                self.match(TypescriptParser.COMMA)
                self.state = 435
                self.sFunctionArg()
                self.state = 440
                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 SFunctionArgDefContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sProperty(self):
            return self.getTypedRuleContext(TypescriptParser.SPropertyContext,0)


        def COLON(self):
            return self.getToken(TypescriptParser.COLON, 0)

        def sType(self):
            return self.getTypedRuleContext(TypescriptParser.STypeContext,0)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sFunctionArgDef

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

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

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




    def sFunctionArgDef(self):

        localctx = TypescriptParser.SFunctionArgDefContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_sFunctionArgDef)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 441
            self.sProperty()
            self.state = 444
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==TypescriptParser.COLON:
                self.state = 442
                self.match(TypescriptParser.COLON)
                self.state = 443
                self.sType()


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


    class SFunctionArgDefsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sFunctionArgDef(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SFunctionArgDefContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SFunctionArgDefContext,i)


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

        def getRuleIndex(self):
            return TypescriptParser.RULE_sFunctionArgDefs

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

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

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




    def sFunctionArgDefs(self):

        localctx = TypescriptParser.SFunctionArgDefsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_sFunctionArgDefs)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 446
            self.sFunctionArgDef()
            self.state = 451
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==TypescriptParser.COMMA:
                self.state = 447
                self.match(TypescriptParser.COMMA)
                self.state = 448
                self.sFunctionArgDef()
                self.state = 453
                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 SFunctionHeadContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def FUNCTION(self):
            return self.getToken(TypescriptParser.FUNCTION, 0)

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

        def ROUND_LEFT(self):
            return self.getToken(TypescriptParser.ROUND_LEFT, 0)

        def ROUND_RIGHT(self):
            return self.getToken(TypescriptParser.ROUND_RIGHT, 0)

        def sFunctionArgDefs(self):
            return self.getTypedRuleContext(TypescriptParser.SFunctionArgDefsContext,0)


        def COLON(self):
            return self.getToken(TypescriptParser.COLON, 0)

        def sType(self):
            return self.getTypedRuleContext(TypescriptParser.STypeContext,0)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sFunctionHead

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

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

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




    def sFunctionHead(self):

        localctx = TypescriptParser.SFunctionHeadContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_sFunctionHead)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 454
            self.match(TypescriptParser.FUNCTION)
            self.state = 455
            self.match(TypescriptParser.IDENTIFIER)
            self.state = 456
            self.match(TypescriptParser.ROUND_LEFT)
            self.state = 458
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==TypescriptParser.IDENTIFIER:
                self.state = 457
                self.sFunctionArgDefs()


            self.state = 460
            self.match(TypescriptParser.ROUND_RIGHT)
            self.state = 463
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==TypescriptParser.COLON:
                self.state = 461
                self.match(TypescriptParser.COLON)
                self.state = 462
                self.sType()


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


    class SFunctionTailContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CURLY_LEFT(self):
            return self.getToken(TypescriptParser.CURLY_LEFT, 0)

        def sBody(self):
            return self.getTypedRuleContext(TypescriptParser.SBodyContext,0)


        def CURLY_RIGHT(self):
            return self.getToken(TypescriptParser.CURLY_RIGHT, 0)

        def getRuleIndex(self):
            return TypescriptParser.RULE_sFunctionTail

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

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

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




    def sFunctionTail(self):

        localctx = TypescriptParser.SFunctionTailContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_sFunctionTail)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 465
            self.match(TypescriptParser.CURLY_LEFT)
            self.state = 466
            self.sBody()
            self.state = 467
            self.match(TypescriptParser.CURLY_RIGHT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SFunctionCallContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def ROUND_LEFT(self):
            return self.getToken(TypescriptParser.ROUND_LEFT, 0)

        def ROUND_RIGHT(self):
            return self.getToken(TypescriptParser.ROUND_RIGHT, 0)

        def sFunctionArgs(self):
            return self.getTypedRuleContext(TypescriptParser.SFunctionArgsContext,0)


        def SEMICOLON(self):
            return self.getToken(TypescriptParser.SEMICOLON, 0)

        def getRuleIndex(self):
            return TypescriptParser.RULE_sFunctionCall

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

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

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




    def sFunctionCall(self):

        localctx = TypescriptParser.SFunctionCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_sFunctionCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 469
            self.match(TypescriptParser.IDENTIFIER)
            self.state = 470
            self.match(TypescriptParser.ROUND_LEFT)
            self.state = 472
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << TypescriptParser.TRUE) | (1 << TypescriptParser.FALSE) | (1 << TypescriptParser.ROUND_LEFT) | (1 << TypescriptParser.CURLY_LEFT) | (1 << TypescriptParser.BRACKET_LEFT) | (1 << TypescriptParser.IDENTIFIER) | (1 << TypescriptParser.CHARS) | (1 << TypescriptParser.DIGITS))) != 0):
                self.state = 471
                self.sFunctionArgs()


            self.state = 474
            self.match(TypescriptParser.ROUND_RIGHT)
            self.state = 476
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,46,self._ctx)
            if la_ == 1:
                self.state = 475
                self.match(TypescriptParser.SEMICOLON)


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


    class SFunctionLambdaContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ROUND_LEFT(self):
            return self.getToken(TypescriptParser.ROUND_LEFT, 0)

        def sFunctionArgDefs(self):
            return self.getTypedRuleContext(TypescriptParser.SFunctionArgDefsContext,0)


        def ROUND_RIGHT(self):
            return self.getToken(TypescriptParser.ROUND_RIGHT, 0)

        def ARROW(self):
            return self.getToken(TypescriptParser.ARROW, 0)

        def sExpression(self):
            return self.getTypedRuleContext(TypescriptParser.SExpressionContext,0)


        def sFunctionTail(self):
            return self.getTypedRuleContext(TypescriptParser.SFunctionTailContext,0)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sFunctionLambda

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

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

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




    def sFunctionLambda(self):

        localctx = TypescriptParser.SFunctionLambdaContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_sFunctionLambda)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 478
            self.match(TypescriptParser.ROUND_LEFT)
            self.state = 479
            self.sFunctionArgDefs()
            self.state = 480
            self.match(TypescriptParser.ROUND_RIGHT)
            self.state = 481
            self.match(TypescriptParser.ARROW)
            self.state = 484
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,47,self._ctx)
            if la_ == 1:
                self.state = 482
                self.sExpression()
                pass

            elif la_ == 2:
                self.state = 483
                self.sFunctionTail()
                pass


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


    class SPropertyContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def getRuleIndex(self):
            return TypescriptParser.RULE_sProperty

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

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

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




    def sProperty(self):

        localctx = TypescriptParser.SPropertyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_sProperty)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 486
            self.match(TypescriptParser.IDENTIFIER)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SPropertyAwareContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sString(self):
            return self.getTypedRuleContext(TypescriptParser.SStringContext,0)


        def sProperty(self):
            return self.getTypedRuleContext(TypescriptParser.SPropertyContext,0)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sPropertyAware

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

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

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




    def sPropertyAware(self):

        localctx = TypescriptParser.SPropertyAwareContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_sPropertyAware)
        try:
            self.state = 490
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [TypescriptParser.CHARS]:
                self.enterOuterAlt(localctx, 1)
                self.state = 488
                self.sString()
                pass
            elif token in [TypescriptParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 489
                self.sProperty()
                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 SPropertyAccessContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sPropertyAware(self):
            return self.getTypedRuleContext(TypescriptParser.SPropertyAwareContext,0)


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

        def sProperty(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SPropertyContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SPropertyContext,i)


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

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

        def sNumber(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SNumberContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SNumberContext,i)


        def sString(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SStringContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SStringContext,i)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sPropertyAccess

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

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

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




    def sPropertyAccess(self):

        localctx = TypescriptParser.SPropertyAccessContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_sPropertyAccess)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 492
            self.sPropertyAware()
            self.state = 502 
            self._errHandler.sync(self)
            _alt = 1
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt == 1:
                    self.state = 502
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [TypescriptParser.DOT]:
                        self.state = 493
                        self.match(TypescriptParser.DOT)
                        self.state = 494
                        self.sProperty()
                        pass
                    elif token in [TypescriptParser.BRACKET_LEFT]:
                        self.state = 495
                        self.match(TypescriptParser.BRACKET_LEFT)
                        self.state = 498
                        self._errHandler.sync(self)
                        token = self._input.LA(1)
                        if token in [TypescriptParser.DIGITS]:
                            self.state = 496
                            self.sNumber()
                            pass
                        elif token in [TypescriptParser.CHARS]:
                            self.state = 497
                            self.sString()
                            pass
                        else:
                            raise NoViableAltException(self)

                        self.state = 500
                        self.match(TypescriptParser.BRACKET_RIGHT)
                        pass
                    else:
                        raise NoViableAltException(self)


                else:
                    raise NoViableAltException(self)
                self.state = 504 
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,51,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 SFunctionAwareContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sString(self):
            return self.getTypedRuleContext(TypescriptParser.SStringContext,0)


        def sProperty(self):
            return self.getTypedRuleContext(TypescriptParser.SPropertyContext,0)


        def sArray(self):
            return self.getTypedRuleContext(TypescriptParser.SArrayContext,0)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sFunctionAware

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

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

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




    def sFunctionAware(self):

        localctx = TypescriptParser.SFunctionAwareContext(self, self._ctx, self.state)
        self.enterRule(localctx, 110, self.RULE_sFunctionAware)
        try:
            self.state = 509
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [TypescriptParser.CHARS]:
                self.enterOuterAlt(localctx, 1)
                self.state = 506
                self.sString()
                pass
            elif token in [TypescriptParser.IDENTIFIER]:
                self.enterOuterAlt(localctx, 2)
                self.state = 507
                self.sProperty()
                pass
            elif token in [TypescriptParser.BRACKET_LEFT]:
                self.enterOuterAlt(localctx, 3)
                self.state = 508
                self.sArray()
                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 SFunctionAccessContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sFunctionAware(self):
            return self.getTypedRuleContext(TypescriptParser.SFunctionAwareContext,0)


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

        def sFunctionCall(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SFunctionCallContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SFunctionCallContext,i)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sFunctionAccess

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

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

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




    def sFunctionAccess(self):

        localctx = TypescriptParser.SFunctionAccessContext(self, self._ctx, self.state)
        self.enterRule(localctx, 112, self.RULE_sFunctionAccess)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 511
            self.sFunctionAware()
            self.state = 514 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 512
                self.match(TypescriptParser.DOT)
                self.state = 513
                self.sFunctionCall()
                self.state = 516 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==TypescriptParser.DOT):
                    break

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


    class SLineContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sControl(self):
            return self.getTypedRuleContext(TypescriptParser.SControlContext,0)


        def sAssignment(self):
            return self.getTypedRuleContext(TypescriptParser.SAssignmentContext,0)


        def sInvocation(self):
            return self.getTypedRuleContext(TypescriptParser.SInvocationContext,0)


        def sReturn(self):
            return self.getTypedRuleContext(TypescriptParser.SReturnContext,0)


        def SEMICOLON(self):
            return self.getToken(TypescriptParser.SEMICOLON, 0)

        def getRuleIndex(self):
            return TypescriptParser.RULE_sLine

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

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

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




    def sLine(self):

        localctx = TypescriptParser.SLineContext(self, self._ctx, self.state)
        self.enterRule(localctx, 114, self.RULE_sLine)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 522
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,54,self._ctx)
            if la_ == 1:
                self.state = 518
                self.sControl()
                pass

            elif la_ == 2:
                self.state = 519
                self.sAssignment()
                pass

            elif la_ == 3:
                self.state = 520
                self.sInvocation()
                pass

            elif la_ == 4:
                self.state = 521
                self.sReturn()
                pass


            self.state = 525
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,55,self._ctx)
            if la_ == 1:
                self.state = 524
                self.match(TypescriptParser.SEMICOLON)


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


    class SBodyContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sControl(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SControlContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SControlContext,i)


        def sAssignment(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SAssignmentContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SAssignmentContext,i)


        def sInvocation(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SInvocationContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SInvocationContext,i)


        def sReturn(self):
            return self.getTypedRuleContext(TypescriptParser.SReturnContext,0)


        def SEMICOLON(self):
            return self.getToken(TypescriptParser.SEMICOLON, 0)

        def getRuleIndex(self):
            return TypescriptParser.RULE_sBody

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

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

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




    def sBody(self):

        localctx = TypescriptParser.SBodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 116, self.RULE_sBody)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 532
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << TypescriptParser.BRACKET_LEFT) | (1 << TypescriptParser.IF) | (1 << TypescriptParser.WHILE) | (1 << TypescriptParser.FOR) | (1 << TypescriptParser.BREAK) | (1 << TypescriptParser.CONTINUE) | (1 << TypescriptParser.IDENTIFIER) | (1 << TypescriptParser.CHARS))) != 0):
                self.state = 530
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,56,self._ctx)
                if la_ == 1:
                    self.state = 527
                    self.sControl()
                    pass

                elif la_ == 2:
                    self.state = 528
                    self.sAssignment()
                    pass

                elif la_ == 3:
                    self.state = 529
                    self.sInvocation()
                    pass


                self.state = 534
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 536
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==TypescriptParser.RETURN:
                self.state = 535
                self.sReturn()


            self.state = 539
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==TypescriptParser.SEMICOLON:
                self.state = 538
                self.match(TypescriptParser.SEMICOLON)


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


    class SReturnContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def RETURN(self):
            return self.getToken(TypescriptParser.RETURN, 0)

        def sValue(self):
            return self.getTypedRuleContext(TypescriptParser.SValueContext,0)


        def sExpression(self):
            return self.getTypedRuleContext(TypescriptParser.SExpressionContext,0)


        def sProperty(self):
            return self.getTypedRuleContext(TypescriptParser.SPropertyContext,0)


        def sInvocation(self):
            return self.getTypedRuleContext(TypescriptParser.SInvocationContext,0)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sReturn

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

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

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




    def sReturn(self):

        localctx = TypescriptParser.SReturnContext(self, self._ctx, self.state)
        self.enterRule(localctx, 118, self.RULE_sReturn)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 541
            self.match(TypescriptParser.RETURN)
            self.state = 546
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,60,self._ctx)
            if la_ == 1:
                self.state = 542
                self.sValue()
                pass

            elif la_ == 2:
                self.state = 543
                self.sExpression()
                pass

            elif la_ == 3:
                self.state = 544
                self.sProperty()
                pass

            elif la_ == 4:
                self.state = 545
                self.sInvocation()
                pass


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


    class SIfContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def IF(self):
            return self.getToken(TypescriptParser.IF, 0)

        def ROUND_LEFT(self):
            return self.getToken(TypescriptParser.ROUND_LEFT, 0)

        def sExpression(self):
            return self.getTypedRuleContext(TypescriptParser.SExpressionContext,0)


        def ROUND_RIGHT(self):
            return self.getToken(TypescriptParser.ROUND_RIGHT, 0)

        def sLine(self):
            return self.getTypedRuleContext(TypescriptParser.SLineContext,0)


        def sElseIf(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SElseIfContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SElseIfContext,i)


        def sElse(self):
            return self.getTypedRuleContext(TypescriptParser.SElseContext,0)


        def CURLY_LEFT(self):
            return self.getToken(TypescriptParser.CURLY_LEFT, 0)

        def sBody(self):
            return self.getTypedRuleContext(TypescriptParser.SBodyContext,0)


        def CURLY_RIGHT(self):
            return self.getToken(TypescriptParser.CURLY_RIGHT, 0)

        def getRuleIndex(self):
            return TypescriptParser.RULE_sIf

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

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

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




    def sIf(self):

        localctx = TypescriptParser.SIfContext(self, self._ctx, self.state)
        self.enterRule(localctx, 120, self.RULE_sIf)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 548
            self.match(TypescriptParser.IF)
            self.state = 549
            self.match(TypescriptParser.ROUND_LEFT)
            self.state = 550
            self.sExpression()
            self.state = 551
            self.match(TypescriptParser.ROUND_RIGHT)
            self.state = 557
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [TypescriptParser.BRACKET_LEFT, TypescriptParser.IF, TypescriptParser.RETURN, TypescriptParser.WHILE, TypescriptParser.FOR, TypescriptParser.BREAK, TypescriptParser.CONTINUE, TypescriptParser.IDENTIFIER, TypescriptParser.CHARS]:
                self.state = 552
                self.sLine()
                pass
            elif token in [TypescriptParser.CURLY_LEFT]:
                self.state = 553
                self.match(TypescriptParser.CURLY_LEFT)
                self.state = 554
                self.sBody()
                self.state = 555
                self.match(TypescriptParser.CURLY_RIGHT)
                pass
            else:
                raise NoViableAltException(self)

            self.state = 562
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,62,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 559
                    self.sElseIf() 
                self.state = 564
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,62,self._ctx)

            self.state = 566
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,63,self._ctx)
            if la_ == 1:
                self.state = 565
                self.sElse()


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


    class SElseContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ELSE(self):
            return self.getToken(TypescriptParser.ELSE, 0)

        def sReturn(self):
            return self.getTypedRuleContext(TypescriptParser.SReturnContext,0)


        def CURLY_LEFT(self):
            return self.getToken(TypescriptParser.CURLY_LEFT, 0)

        def sBody(self):
            return self.getTypedRuleContext(TypescriptParser.SBodyContext,0)


        def CURLY_RIGHT(self):
            return self.getToken(TypescriptParser.CURLY_RIGHT, 0)

        def getRuleIndex(self):
            return TypescriptParser.RULE_sElse

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

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

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




    def sElse(self):

        localctx = TypescriptParser.SElseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 122, self.RULE_sElse)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 568
            self.match(TypescriptParser.ELSE)
            self.state = 574
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [TypescriptParser.RETURN]:
                self.state = 569
                self.sReturn()
                pass
            elif token in [TypescriptParser.CURLY_LEFT]:
                self.state = 570
                self.match(TypescriptParser.CURLY_LEFT)
                self.state = 571
                self.sBody()
                self.state = 572
                self.match(TypescriptParser.CURLY_RIGHT)
                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 SElseIfContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ELSE(self):
            return self.getToken(TypescriptParser.ELSE, 0)

        def IF(self):
            return self.getToken(TypescriptParser.IF, 0)

        def ROUND_LEFT(self):
            return self.getToken(TypescriptParser.ROUND_LEFT, 0)

        def sBooleanExpression(self):
            return self.getTypedRuleContext(TypescriptParser.SBooleanExpressionContext,0)


        def ROUND_RIGHT(self):
            return self.getToken(TypescriptParser.ROUND_RIGHT, 0)

        def sReturn(self):
            return self.getTypedRuleContext(TypescriptParser.SReturnContext,0)


        def CURLY_LEFT(self):
            return self.getToken(TypescriptParser.CURLY_LEFT, 0)

        def sBody(self):
            return self.getTypedRuleContext(TypescriptParser.SBodyContext,0)


        def CURLY_RIGHT(self):
            return self.getToken(TypescriptParser.CURLY_RIGHT, 0)

        def getRuleIndex(self):
            return TypescriptParser.RULE_sElseIf

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

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

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




    def sElseIf(self):

        localctx = TypescriptParser.SElseIfContext(self, self._ctx, self.state)
        self.enterRule(localctx, 124, self.RULE_sElseIf)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 576
            self.match(TypescriptParser.ELSE)
            self.state = 577
            self.match(TypescriptParser.IF)
            self.state = 578
            self.match(TypescriptParser.ROUND_LEFT)
            self.state = 579
            self.sBooleanExpression()
            self.state = 580
            self.match(TypescriptParser.ROUND_RIGHT)
            self.state = 586
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [TypescriptParser.RETURN]:
                self.state = 581
                self.sReturn()
                pass
            elif token in [TypescriptParser.CURLY_LEFT]:
                self.state = 582
                self.match(TypescriptParser.CURLY_LEFT)
                self.state = 583
                self.sBody()
                self.state = 584
                self.match(TypescriptParser.CURLY_RIGHT)
                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 SStringContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CHARS(self):
            return self.getToken(TypescriptParser.CHARS, 0)

        def getRuleIndex(self):
            return TypescriptParser.RULE_sString

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

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

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




    def sString(self):

        localctx = TypescriptParser.SStringContext(self, self._ctx, self.state)
        self.enterRule(localctx, 126, self.RULE_sString)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 588
            self.match(TypescriptParser.CHARS)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SNumberContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DIGITS(self):
            return self.getToken(TypescriptParser.DIGITS, 0)

        def getRuleIndex(self):
            return TypescriptParser.RULE_sNumber

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

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

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




    def sNumber(self):

        localctx = TypescriptParser.SNumberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 128, self.RULE_sNumber)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 590
            self.match(TypescriptParser.DIGITS)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SBooleanContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def TRUE(self):
            return self.getToken(TypescriptParser.TRUE, 0)

        def FALSE(self):
            return self.getToken(TypescriptParser.FALSE, 0)

        def getRuleIndex(self):
            return TypescriptParser.RULE_sBoolean

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

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

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




    def sBoolean(self):

        localctx = TypescriptParser.SBooleanContext(self, self._ctx, self.state)
        self.enterRule(localctx, 130, self.RULE_sBoolean)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 592
            _la = self._input.LA(1)
            if not(_la==TypescriptParser.TRUE or _la==TypescriptParser.FALSE):
                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 SArrayContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def BRACKET_LEFT(self):
            return self.getToken(TypescriptParser.BRACKET_LEFT, 0)

        def BRACKET_RIGHT(self):
            return self.getToken(TypescriptParser.BRACKET_RIGHT, 0)

        def sValue(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SValueContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SValueContext,i)


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

        def getRuleIndex(self):
            return TypescriptParser.RULE_sArray

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

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

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




    def sArray(self):

        localctx = TypescriptParser.SArrayContext(self, self._ctx, self.state)
        self.enterRule(localctx, 132, self.RULE_sArray)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 594
            self.match(TypescriptParser.BRACKET_LEFT)
            self.state = 603
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << TypescriptParser.TRUE) | (1 << TypescriptParser.FALSE) | (1 << TypescriptParser.CURLY_LEFT) | (1 << TypescriptParser.BRACKET_LEFT) | (1 << TypescriptParser.CHARS) | (1 << TypescriptParser.DIGITS))) != 0):
                self.state = 595
                self.sValue()
                self.state = 600
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==TypescriptParser.COMMA:
                    self.state = 596
                    self.match(TypescriptParser.COMMA)
                    self.state = 597
                    self.sValue()
                    self.state = 602
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 605
            self.match(TypescriptParser.BRACKET_RIGHT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SMapContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CURLY_LEFT(self):
            return self.getToken(TypescriptParser.CURLY_LEFT, 0)

        def CURLY_RIGHT(self):
            return self.getToken(TypescriptParser.CURLY_RIGHT, 0)

        def sString(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SStringContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SStringContext,i)


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

        def sValue(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(TypescriptParser.SValueContext)
            else:
                return self.getTypedRuleContext(TypescriptParser.SValueContext,i)


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

        def getRuleIndex(self):
            return TypescriptParser.RULE_sMap

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

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

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




    def sMap(self):

        localctx = TypescriptParser.SMapContext(self, self._ctx, self.state)
        self.enterRule(localctx, 134, self.RULE_sMap)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 607
            self.match(TypescriptParser.CURLY_LEFT)
            self.state = 621
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==TypescriptParser.CHARS:
                self.state = 608
                self.sString()
                self.state = 609
                self.match(TypescriptParser.COLON)
                self.state = 610
                self.sValue()
                self.state = 618
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==TypescriptParser.COMMA:
                    self.state = 611
                    self.match(TypescriptParser.COMMA)
                    self.state = 612
                    self.sString()
                    self.state = 613
                    self.match(TypescriptParser.COLON)
                    self.state = 614
                    self.sValue()
                    self.state = 620
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)



            self.state = 623
            self.match(TypescriptParser.CURLY_RIGHT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SEndlessLoopContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sLoopTail(self):
            return self.getTypedRuleContext(TypescriptParser.SLoopTailContext,0)


        def WHILE(self):
            return self.getToken(TypescriptParser.WHILE, 0)

        def ROUND_LEFT(self):
            return self.getToken(TypescriptParser.ROUND_LEFT, 0)

        def TRUE(self):
            return self.getToken(TypescriptParser.TRUE, 0)

        def ROUND_RIGHT(self):
            return self.getToken(TypescriptParser.ROUND_RIGHT, 0)

        def FOR(self):
            return self.getToken(TypescriptParser.FOR, 0)

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

        def getRuleIndex(self):
            return TypescriptParser.RULE_sEndlessLoop

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

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

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




    def sEndlessLoop(self):

        localctx = TypescriptParser.SEndlessLoopContext(self, self._ctx, self.state)
        self.enterRule(localctx, 136, self.RULE_sEndlessLoop)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 634
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [TypescriptParser.WHILE]:
                self.state = 625
                self.match(TypescriptParser.WHILE)
                self.state = 626
                self.match(TypescriptParser.ROUND_LEFT)
                self.state = 627
                self.match(TypescriptParser.TRUE)
                self.state = 628
                self.match(TypescriptParser.ROUND_RIGHT)
                pass
            elif token in [TypescriptParser.FOR]:
                self.state = 629
                self.match(TypescriptParser.FOR)
                self.state = 630
                self.match(TypescriptParser.ROUND_LEFT)
                self.state = 631
                self.match(TypescriptParser.SEMICOLON)
                self.state = 632
                self.match(TypescriptParser.SEMICOLON)
                self.state = 633
                self.match(TypescriptParser.ROUND_RIGHT)
                pass
            else:
                raise NoViableAltException(self)

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


    class SWhileContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def WHILE(self):
            return self.getToken(TypescriptParser.WHILE, 0)

        def ROUND_LEFT(self):
            return self.getToken(TypescriptParser.ROUND_LEFT, 0)

        def sExpression(self):
            return self.getTypedRuleContext(TypescriptParser.SExpressionContext,0)


        def ROUND_RIGHT(self):
            return self.getToken(TypescriptParser.ROUND_RIGHT, 0)

        def sLoopTail(self):
            return self.getTypedRuleContext(TypescriptParser.SLoopTailContext,0)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sWhile

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

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

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




    def sWhile(self):

        localctx = TypescriptParser.SWhileContext(self, self._ctx, self.state)
        self.enterRule(localctx, 138, self.RULE_sWhile)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 638
            self.match(TypescriptParser.WHILE)
            self.state = 639
            self.match(TypescriptParser.ROUND_LEFT)
            self.state = 640
            self.sExpression()
            self.state = 641
            self.match(TypescriptParser.ROUND_RIGHT)
            self.state = 642
            self.sLoopTail()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SForContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def FOR(self):
            return self.getToken(TypescriptParser.FOR, 0)

        def ROUND_LEFT(self):
            return self.getToken(TypescriptParser.ROUND_LEFT, 0)

        def sStatement(self):
            return self.getTypedRuleContext(TypescriptParser.SStatementContext,0)


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

        def sNumberExpression(self):
            return self.getTypedRuleContext(TypescriptParser.SNumberExpressionContext,0)


        def ROUND_RIGHT(self):
            return self.getToken(TypescriptParser.ROUND_RIGHT, 0)

        def sLoopTail(self):
            return self.getTypedRuleContext(TypescriptParser.SLoopTailContext,0)


        def sIncrement(self):
            return self.getTypedRuleContext(TypescriptParser.SIncrementContext,0)


        def sDecrement(self):
            return self.getTypedRuleContext(TypescriptParser.SDecrementContext,0)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sFor

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

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

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




    def sFor(self):

        localctx = TypescriptParser.SForContext(self, self._ctx, self.state)
        self.enterRule(localctx, 140, self.RULE_sFor)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 644
            self.match(TypescriptParser.FOR)
            self.state = 645
            self.match(TypescriptParser.ROUND_LEFT)
            self.state = 646
            self.sStatement()
            self.state = 647
            self.match(TypescriptParser.SEMICOLON)
            self.state = 648
            self.sNumberExpression()
            self.state = 649
            self.match(TypescriptParser.SEMICOLON)
            self.state = 652
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,71,self._ctx)
            if la_ == 1:
                self.state = 650
                self.sIncrement()
                pass

            elif la_ == 2:
                self.state = 651
                self.sDecrement()
                pass


            self.state = 654
            self.match(TypescriptParser.ROUND_RIGHT)
            self.state = 655
            self.sLoopTail()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SForOfContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def FOR(self):
            return self.getToken(TypescriptParser.FOR, 0)

        def ROUND_LEFT(self):
            return self.getToken(TypescriptParser.ROUND_LEFT, 0)

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

        def OF(self):
            return self.getToken(TypescriptParser.OF, 0)

        def ROUND_RIGHT(self):
            return self.getToken(TypescriptParser.ROUND_RIGHT, 0)

        def sLoopTail(self):
            return self.getTypedRuleContext(TypescriptParser.SLoopTailContext,0)


        def VAR(self):
            return self.getToken(TypescriptParser.VAR, 0)

        def LET(self):
            return self.getToken(TypescriptParser.LET, 0)

        def sArray(self):
            return self.getTypedRuleContext(TypescriptParser.SArrayContext,0)


        def sString(self):
            return self.getTypedRuleContext(TypescriptParser.SStringContext,0)


        def getRuleIndex(self):
            return TypescriptParser.RULE_sForOf

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

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

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




    def sForOf(self):

        localctx = TypescriptParser.SForOfContext(self, self._ctx, self.state)
        self.enterRule(localctx, 142, self.RULE_sForOf)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 657
            self.match(TypescriptParser.FOR)
            self.state = 658
            self.match(TypescriptParser.ROUND_LEFT)
            self.state = 659
            _la = self._input.LA(1)
            if not(_la==TypescriptParser.VAR or _la==TypescriptParser.LET):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 660
            self.match(TypescriptParser.IDENTIFIER)
            self.state = 661
            self.match(TypescriptParser.OF)
            self.state = 664
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [TypescriptParser.BRACKET_LEFT]:
                self.state = 662
                self.sArray()
                pass
            elif token in [TypescriptParser.CHARS]:
                self.state = 663
                self.sString()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 666
            self.match(TypescriptParser.ROUND_RIGHT)
            self.state = 667
            self.sLoopTail()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SForInContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def FOR(self):
            return self.getToken(TypescriptParser.FOR, 0)

        def ROUND_LEFT(self):
            return self.getToken(TypescriptParser.ROUND_LEFT, 0)

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

        def IN(self):
            return self.getToken(TypescriptParser.IN, 0)

        def sArray(self):
            return self.getTypedRuleContext(TypescriptParser.SArrayContext,0)


        def ROUND_RIGHT(self):
            return self.getToken(TypescriptParser.ROUND_RIGHT, 0)

        def sLoopTail(self):
            return self.getTypedRuleContext(TypescriptParser.SLoopTailContext,0)


        def VAR(self):
            return self.getToken(TypescriptParser.VAR, 0)

        def LET(self):
            return self.getToken(TypescriptParser.LET, 0)

        def getRuleIndex(self):
            return TypescriptParser.RULE_sForIn

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

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

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




    def sForIn(self):

        localctx = TypescriptParser.SForInContext(self, self._ctx, self.state)
        self.enterRule(localctx, 144, self.RULE_sForIn)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 669
            self.match(TypescriptParser.FOR)
            self.state = 670
            self.match(TypescriptParser.ROUND_LEFT)
            self.state = 671
            _la = self._input.LA(1)
            if not(_la==TypescriptParser.VAR or _la==TypescriptParser.LET):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 672
            self.match(TypescriptParser.IDENTIFIER)
            self.state = 673
            self.match(TypescriptParser.IN)
            self.state = 674
            self.sArray()
            self.state = 675
            self.match(TypescriptParser.ROUND_RIGHT)
            self.state = 676
            self.sLoopTail()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SLoopTailContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CURLY_LEFT(self):
            return self.getToken(TypescriptParser.CURLY_LEFT, 0)

        def sBody(self):
            return self.getTypedRuleContext(TypescriptParser.SBodyContext,0)


        def CURLY_RIGHT(self):
            return self.getToken(TypescriptParser.CURLY_RIGHT, 0)

        def getRuleIndex(self):
            return TypescriptParser.RULE_sLoopTail

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

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

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




    def sLoopTail(self):

        localctx = TypescriptParser.SLoopTailContext(self, self._ctx, self.state)
        self.enterRule(localctx, 146, self.RULE_sLoopTail)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 678
            self.match(TypescriptParser.CURLY_LEFT)
            self.state = 679
            self.sBody()
            self.state = 680
            self.match(TypescriptParser.CURLY_RIGHT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SContinueContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CONTINUE(self):
            return self.getToken(TypescriptParser.CONTINUE, 0)

        def getRuleIndex(self):
            return TypescriptParser.RULE_sContinue

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

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

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




    def sContinue(self):

        localctx = TypescriptParser.SContinueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 148, self.RULE_sContinue)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 682
            self.match(TypescriptParser.CONTINUE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SBreakContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def BREAK(self):
            return self.getToken(TypescriptParser.BREAK, 0)

        def getRuleIndex(self):
            return TypescriptParser.RULE_sBreak

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

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

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




    def sBreak(self):

        localctx = TypescriptParser.SBreakContext(self, self._ctx, self.state)
        self.enterRule(localctx, 150, self.RULE_sBreak)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 684
            self.match(TypescriptParser.BREAK)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SMutableVarContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def EQUAL(self):
            return self.getToken(TypescriptParser.EQUAL, 0)

        def VAR(self):
            return self.getToken(TypescriptParser.VAR, 0)

        def LET(self):
            return self.getToken(TypescriptParser.LET, 0)

        def sExpression(self):
            return self.getTypedRuleContext(TypescriptParser.SExpressionContext,0)


        def sValue(self):
            return self.getTypedRuleContext(TypescriptParser.SValueContext,0)


        def sInvocation(self):
            return self.getTypedRuleContext(TypescriptParser.SInvocationContext,0)


        def SEMICOLON(self):
            return self.getToken(TypescriptParser.SEMICOLON, 0)

        def getRuleIndex(self):
            return TypescriptParser.RULE_sMutableVar

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

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

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




    def sMutableVar(self):

        localctx = TypescriptParser.SMutableVarContext(self, self._ctx, self.state)
        self.enterRule(localctx, 152, self.RULE_sMutableVar)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 686
            _la = self._input.LA(1)
            if not(_la==TypescriptParser.VAR or _la==TypescriptParser.LET):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 687
            self.match(TypescriptParser.IDENTIFIER)
            self.state = 688
            self.match(TypescriptParser.EQUAL)
            self.state = 692
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,73,self._ctx)
            if la_ == 1:
                self.state = 689
                self.sExpression()
                pass

            elif la_ == 2:
                self.state = 690
                self.sValue()
                pass

            elif la_ == 3:
                self.state = 691
                self.sInvocation()
                pass


            self.state = 695
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,74,self._ctx)
            if la_ == 1:
                self.state = 694
                self.match(TypescriptParser.SEMICOLON)


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


    class SImmutableVarContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def CONST(self):
            return self.getToken(TypescriptParser.CONST, 0)

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

        def EQUAL(self):
            return self.getToken(TypescriptParser.EQUAL, 0)

        def sExpression(self):
            return self.getTypedRuleContext(TypescriptParser.SExpressionContext,0)


        def sValue(self):
            return self.getTypedRuleContext(TypescriptParser.SValueContext,0)


        def sInvocation(self):
            return self.getTypedRuleContext(TypescriptParser.SInvocationContext,0)


        def SEMICOLON(self):
            return self.getToken(TypescriptParser.SEMICOLON, 0)

        def getRuleIndex(self):
            return TypescriptParser.RULE_sImmutableVar

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

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

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




    def sImmutableVar(self):

        localctx = TypescriptParser.SImmutableVarContext(self, self._ctx, self.state)
        self.enterRule(localctx, 154, self.RULE_sImmutableVar)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 697
            self.match(TypescriptParser.CONST)
            self.state = 698
            self.match(TypescriptParser.IDENTIFIER)
            self.state = 699
            self.match(TypescriptParser.EQUAL)
            self.state = 703
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,75,self._ctx)
            if la_ == 1:
                self.state = 700
                self.sExpression()
                pass

            elif la_ == 2:
                self.state = 701
                self.sValue()
                pass

            elif la_ == 3:
                self.state = 702
                self.sInvocation()
                pass


            self.state = 706
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,76,self._ctx)
            if la_ == 1:
                self.state = 705
                self.match(TypescriptParser.SEMICOLON)


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


    class SAssignmentContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def EQUAL(self):
            return self.getToken(TypescriptParser.EQUAL, 0)

        def sExpression(self):
            return self.getTypedRuleContext(TypescriptParser.SExpressionContext,0)


        def sValue(self):
            return self.getTypedRuleContext(TypescriptParser.SValueContext,0)


        def sInvocation(self):
            return self.getTypedRuleContext(TypescriptParser.SInvocationContext,0)


        def sProperty(self):
            return self.getTypedRuleContext(TypescriptParser.SPropertyContext,0)


        def SEMICOLON(self):
            return self.getToken(TypescriptParser.SEMICOLON, 0)

        def getRuleIndex(self):
            return TypescriptParser.RULE_sAssignment

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

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

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




    def sAssignment(self):

        localctx = TypescriptParser.SAssignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 156, self.RULE_sAssignment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 708
            self.match(TypescriptParser.IDENTIFIER)
            self.state = 709
            self.match(TypescriptParser.EQUAL)
            self.state = 714
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,77,self._ctx)
            if la_ == 1:
                self.state = 710
                self.sExpression()
                pass

            elif la_ == 2:
                self.state = 711
                self.sValue()
                pass

            elif la_ == 3:
                self.state = 712
                self.sInvocation()
                pass

            elif la_ == 4:
                self.state = 713
                self.sProperty()
                pass


            self.state = 717
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,78,self._ctx)
            if la_ == 1:
                self.state = 716
                self.match(TypescriptParser.SEMICOLON)


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


    class SIncrementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sProperty(self):
            return self.getTypedRuleContext(TypescriptParser.SPropertyContext,0)


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

        def SEMICOLON(self):
            return self.getToken(TypescriptParser.SEMICOLON, 0)

        def getRuleIndex(self):
            return TypescriptParser.RULE_sIncrement

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

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

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




    def sIncrement(self):

        localctx = TypescriptParser.SIncrementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 158, self.RULE_sIncrement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 719
            self.sProperty()
            self.state = 720
            self.match(TypescriptParser.PLUS)
            self.state = 721
            self.match(TypescriptParser.PLUS)
            self.state = 723
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==TypescriptParser.SEMICOLON:
                self.state = 722
                self.match(TypescriptParser.SEMICOLON)


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


    class SDecrementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def sProperty(self):
            return self.getTypedRuleContext(TypescriptParser.SPropertyContext,0)


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

        def SEMICOLON(self):
            return self.getToken(TypescriptParser.SEMICOLON, 0)

        def getRuleIndex(self):
            return TypescriptParser.RULE_sDecrement

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

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

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




    def sDecrement(self):

        localctx = TypescriptParser.SDecrementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 160, self.RULE_sDecrement)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 725
            self.sProperty()
            self.state = 726
            self.match(TypescriptParser.MINUS)
            self.state = 727
            self.match(TypescriptParser.MINUS)
            self.state = 729
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==TypescriptParser.SEMICOLON:
                self.state = 728
                self.match(TypescriptParser.SEMICOLON)


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





