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


def serializedATN():
    with StringIO() as buf:
        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\66")
        buf.write("\u0196\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,\3\2\7\2Z\n\2\f")
        buf.write("\2\16\2]\13\2\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3")
        buf.write("\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\3\5\3r\n\3\3\4\3\4")
        buf.write("\3\4\3\4\3\4\3\5\3\5\3\5\3\5\3\5\3\6\3\6\3\6\3\6\7\6\u0082")
        buf.write("\n\6\f\6\16\6\u0085\13\6\3\7\3\7\3\7\3\7\3\7\3\7\3\7\5")
        buf.write("\7\u008e\n\7\3\b\3\b\3\b\3\b\5\b\u0094\n\b\3\b\5\b\u0097")
        buf.write("\n\b\3\b\3\b\3\b\5\b\u009c\n\b\3\t\5\t\u009f\n\t\3\t\3")
        buf.write("\t\3\n\3\n\3\n\5\n\u00a6\n\n\3\13\3\13\3\13\3\13\3\13")
        buf.write("\3\13\3\f\3\f\3\f\3\f\3\f\3\f\3\r\3\r\3\r\3\16\3\16\7")
        buf.write("\16\u00b9\n\16\f\16\16\16\u00bc\13\16\3\16\3\16\3\17\3")
        buf.write("\17\7\17\u00c2\n\17\f\17\16\17\u00c5\13\17\3\17\3\17\3")
        buf.write("\17\5\17\u00ca\n\17\3\17\3\17\3\20\3\20\3\21\3\21\3\21")
        buf.write("\3\21\7\21\u00d4\n\21\f\21\16\21\u00d7\13\21\3\22\3\22")
        buf.write("\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22\5\22\u00e4")
        buf.write("\n\22\3\23\3\23\5\23\u00e8\n\23\3\24\3\24\3\24\3\24\3")
        buf.write("\24\3\24\5\24\u00f0\n\24\3\25\3\25\3\26\3\26\3\27\3\27")
        buf.write("\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\30\3\30\3\30")
        buf.write("\3\30\3\31\3\31\3\31\3\31\3\31\3\31\3\32\3\32\3\32\3\33")
        buf.write("\5\33\u010e\n\33\3\33\3\33\3\33\3\33\3\34\3\34\3\34\3")
        buf.write("\34\5\34\u0118\n\34\3\34\3\34\3\34\3\35\3\35\3\35\3\35")
        buf.write("\3\35\3\35\7\35\u0123\n\35\f\35\16\35\u0126\13\35\3\36")
        buf.write("\3\36\3\36\3\36\3\36\7\36\u012d\n\36\f\36\16\36\u0130")
        buf.write("\13\36\3\36\3\36\3\37\3\37\3 \3 \5 \u0138\n \3!\3!\3!")
        buf.write("\3!\5!\u013e\n!\3\"\3\"\3\"\3\"\5\"\u0144\n\"\3#\3#\3")
        buf.write("#\5#\u0149\n#\3$\3$\3%\3%\3%\3%\5%\u0151\n%\3&\3&\3&\3")
        buf.write("&\5&\u0157\n&\3\'\3\'\3\'\3(\3(\3(\3(\3(\3(\3(\3(\3(\3")
        buf.write("(\3(\7(\u0167\n(\f(\16(\u016a\13(\3(\3(\3(\3(\3(\5(\u0171")
        buf.write("\n(\3(\3(\3(\5(\u0176\n(\3(\3(\3(\5(\u017b\n(\3(\7(\u017e")
        buf.write("\n(\f(\16(\u0181\13(\7(\u0183\n(\f(\16(\u0186\13(\3)\3")
        buf.write(")\3)\3)\3)\3)\5)\u018e\n)\3*\3*\3+\3+\3,\3,\3,\2\3N-\2")
        buf.write("\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64")
        buf.write("\668:<>@BDFHJLNPRTV\2\7\3\2\n\17\5\2\4\4\6\b\n\16\3\2")
        buf.write(")-\3\2(-\3\2./\2\u01a1\2[\3\2\2\2\4q\3\2\2\2\6s\3\2\2")
        buf.write("\2\bx\3\2\2\2\n}\3\2\2\2\f\u008d\3\2\2\2\16\u009b\3\2")
        buf.write("\2\2\20\u009e\3\2\2\2\22\u00a5\3\2\2\2\24\u00a7\3\2\2")
        buf.write("\2\26\u00ad\3\2\2\2\30\u00b3\3\2\2\2\32\u00b6\3\2\2\2")
        buf.write("\34\u00bf\3\2\2\2\36\u00cd\3\2\2\2 \u00cf\3\2\2\2\"\u00e3")
        buf.write("\3\2\2\2$\u00e7\3\2\2\2&\u00ef\3\2\2\2(\u00f1\3\2\2\2")
        buf.write("*\u00f3\3\2\2\2,\u00f5\3\2\2\2.\u00ff\3\2\2\2\60\u0103")
        buf.write("\3\2\2\2\62\u0109\3\2\2\2\64\u010d\3\2\2\2\66\u0113\3")
        buf.write("\2\2\28\u011c\3\2\2\2:\u0127\3\2\2\2<\u0133\3\2\2\2>\u0137")
        buf.write("\3\2\2\2@\u013d\3\2\2\2B\u0143\3\2\2\2D\u0148\3\2\2\2")
        buf.write("F\u014a\3\2\2\2H\u0150\3\2\2\2J\u0156\3\2\2\2L\u0158\3")
        buf.write("\2\2\2N\u0170\3\2\2\2P\u018d\3\2\2\2R\u018f\3\2\2\2T\u0191")
        buf.write("\3\2\2\2V\u0193\3\2\2\2XZ\5\4\3\2YX\3\2\2\2Z]\3\2\2\2")
        buf.write("[Y\3\2\2\2[\\\3\2\2\2\\^\3\2\2\2][\3\2\2\2^_\7\2\2\3_")
        buf.write("\3\3\2\2\2`a\5\16\b\2ab\7\33\2\2br\3\2\2\2cr\5\22\n\2")
        buf.write("dr\5,\27\2er\5\60\31\2fr\5\66\34\2gh\5:\36\2hi\7\33\2")
        buf.write("\2ir\3\2\2\2jr\5\f\7\2kl\5\6\4\2lm\7\33\2\2mr\3\2\2\2")
        buf.write("no\5\b\5\2op\7\33\2\2pr\3\2\2\2q`\3\2\2\2qc\3\2\2\2qd")
        buf.write("\3\2\2\2qe\3\2\2\2qf\3\2\2\2qg\3\2\2\2qj\3\2\2\2qk\3\2")
        buf.write("\2\2qn\3\2\2\2r\5\3\2\2\2st\7\65\2\2tu\7\25\2\2uv\5\n")
        buf.write("\6\2vw\7\26\2\2w\7\3\2\2\2xy\7\66\2\2yz\7\25\2\2z{\5\n")
        buf.write("\6\2{|\7\26\2\2|\t\3\2\2\2}\u0083\5P)\2~\177\5F$\2\177")
        buf.write("\u0080\5P)\2\u0080\u0082\3\2\2\2\u0081~\3\2\2\2\u0082")
        buf.write("\u0085\3\2\2\2\u0083\u0081\3\2\2\2\u0083\u0084\3\2\2\2")
        buf.write("\u0084\13\3\2\2\2\u0085\u0083\3\2\2\2\u0086\u008e\5\16")
        buf.write("\b\2\u0087\u0088\5H%\2\u0088\u0089\7\33\2\2\u0089\u008e")
        buf.write("\3\2\2\2\u008a\u008b\5J&\2\u008b\u008c\7\33\2\2\u008c")
        buf.write("\u008e\3\2\2\2\u008d\u0086\3\2\2\2\u008d\u0087\3\2\2\2")
        buf.write("\u008d\u008a\3\2\2\2\u008e\r\3\2\2\2\u008f\u0090\5R*\2")
        buf.write("\u0090\u0093\7\60\2\2\u0091\u0092\7\t\2\2\u0092\u0094")
        buf.write("\5\20\t\2\u0093\u0091\3\2\2\2\u0093\u0094\3\2\2\2\u0094")
        buf.write("\u009c\3\2\2\2\u0095\u0097\5R*\2\u0096\u0095\3\2\2\2\u0096")
        buf.write("\u0097\3\2\2\2\u0097\u0098\3\2\2\2\u0098\u0099\7\60\2")
        buf.write("\2\u0099\u009a\7\t\2\2\u009a\u009c\5\20\t\2\u009b\u008f")
        buf.write("\3\2\2\2\u009b\u0096\3\2\2\2\u009c\17\3\2\2\2\u009d\u009f")
        buf.write("\5<\37\2\u009e\u009d\3\2\2\2\u009e\u009f\3\2\2\2\u009f")
        buf.write("\u00a0\3\2\2\2\u00a0\u00a1\5N(\2\u00a1\21\3\2\2\2\u00a2")
        buf.write("\u00a6\5\24\13\2\u00a3\u00a6\5\26\f\2\u00a4\u00a6\5\30")
        buf.write("\r\2\u00a5\u00a2\3\2\2\2\u00a5\u00a3\3\2\2\2\u00a5\u00a4")
        buf.write("\3\2\2\2\u00a6\23\3\2\2\2\u00a7\u00a8\7\"\2\2\u00a8\u00a9")
        buf.write("\7\25\2\2\u00a9\u00aa\5 \21\2\u00aa\u00ab\7\26\2\2\u00ab")
        buf.write("\u00ac\5\32\16\2\u00ac\25\3\2\2\2\u00ad\u00ae\7$\2\2\u00ae")
        buf.write("\u00af\7\25\2\2\u00af\u00b0\5 \21\2\u00b0\u00b1\7\26\2")
        buf.write("\2\u00b1\u00b2\5\32\16\2\u00b2\27\3\2\2\2\u00b3\u00b4")
        buf.write("\7#\2\2\u00b4\u00b5\5\32\16\2\u00b5\31\3\2\2\2\u00b6\u00ba")
        buf.write("\7\31\2\2\u00b7\u00b9\5\4\3\2\u00b8\u00b7\3\2\2\2\u00b9")
        buf.write("\u00bc\3\2\2\2\u00ba\u00b8\3\2\2\2\u00ba\u00bb\3\2\2\2")
        buf.write("\u00bb\u00bd\3\2\2\2\u00bc\u00ba\3\2\2\2\u00bd\u00be\7")
        buf.write("\32\2\2\u00be\33\3\2\2\2\u00bf\u00c3\7\31\2\2\u00c0\u00c2")
        buf.write("\5\4\3\2\u00c1\u00c0\3\2\2\2\u00c2\u00c5\3\2\2\2\u00c3")
        buf.write("\u00c1\3\2\2\2\u00c3\u00c4\3\2\2\2\u00c4\u00c9\3\2\2\2")
        buf.write("\u00c5\u00c3\3\2\2\2\u00c6\u00c7\5\62\32\2\u00c7\u00c8")
        buf.write("\7\33\2\2\u00c8\u00ca\3\2\2\2\u00c9\u00c6\3\2\2\2\u00c9")
        buf.write("\u00ca\3\2\2\2\u00ca\u00cb\3\2\2\2\u00cb\u00cc\7\32\2")
        buf.write("\2\u00cc\35\3\2\2\2\u00cd\u00ce\t\2\2\2\u00ce\37\3\2\2")
        buf.write("\2\u00cf\u00d5\5\"\22\2\u00d0\u00d1\5$\23\2\u00d1\u00d2")
        buf.write("\5\"\22\2\u00d2\u00d4\3\2\2\2\u00d3\u00d0\3\2\2\2\u00d4")
        buf.write("\u00d7\3\2\2\2\u00d5\u00d3\3\2\2\2\u00d5\u00d6\3\2\2\2")
        buf.write("\u00d6!\3\2\2\2\u00d7\u00d5\3\2\2\2\u00d8\u00d9\5N(\2")
        buf.write("\u00d9\u00da\5\36\20\2\u00da\u00db\5N(\2\u00db\u00e4\3")
        buf.write("\2\2\2\u00dc\u00dd\7\22\2\2\u00dd\u00e4\5&\24\2\u00de")
        buf.write("\u00e4\5V,\2\u00df\u00e4\7\60\2\2\u00e0\u00e1\5<\37\2")
        buf.write("\u00e1\u00e2\5\"\22\2\u00e2\u00e4\3\2\2\2\u00e3\u00d8")
        buf.write("\3\2\2\2\u00e3\u00dc\3\2\2\2\u00e3\u00de\3\2\2\2\u00e3")
        buf.write("\u00df\3\2\2\2\u00e3\u00e0\3\2\2\2\u00e4#\3\2\2\2\u00e5")
        buf.write("\u00e8\5(\25\2\u00e6\u00e8\5*\26\2\u00e7\u00e5\3\2\2\2")
        buf.write("\u00e7\u00e6\3\2\2\2\u00e8%\3\2\2\2\u00e9\u00ea\7\25\2")
        buf.write("\2\u00ea\u00eb\5\"\22\2\u00eb\u00ec\7\26\2\2\u00ec\u00f0")
        buf.write("\3\2\2\2\u00ed\u00f0\5V,\2\u00ee\u00f0\7\60\2\2\u00ef")
        buf.write("\u00e9\3\2\2\2\u00ef\u00ed\3\2\2\2\u00ef\u00ee\3\2\2\2")
        buf.write("\u00f0\'\3\2\2\2\u00f1\u00f2\7\21\2\2\u00f2)\3\2\2\2\u00f3")
        buf.write("\u00f4\7\20\2\2\u00f4+\3\2\2\2\u00f5\u00f6\7 \2\2\u00f6")
        buf.write("\u00f7\7\25\2\2\u00f7\u00f8\5\64\33\2\u00f8\u00f9\7\33")
        buf.write("\2\2\u00f9\u00fa\5.\30\2\u00fa\u00fb\7\33\2\2\u00fb\u00fc")
        buf.write("\5> \2\u00fc\u00fd\7\26\2\2\u00fd\u00fe\5\32\16\2\u00fe")
        buf.write("-\3\2\2\2\u00ff\u0100\5N(\2\u0100\u0101\5\36\20\2\u0101")
        buf.write("\u0102\5N(\2\u0102/\3\2\2\2\u0103\u0104\7!\2\2\u0104\u0105")
        buf.write("\7\25\2\2\u0105\u0106\5 \21\2\u0106\u0107\7\26\2\2\u0107")
        buf.write("\u0108\5\32\16\2\u0108\61\3\2\2\2\u0109\u010a\7\'\2\2")
        buf.write("\u010a\u010b\5N(\2\u010b\63\3\2\2\2\u010c\u010e\5R*\2")
        buf.write("\u010d\u010c\3\2\2\2\u010d\u010e\3\2\2\2\u010e\u010f\3")
        buf.write("\2\2\2\u010f\u0110\7\60\2\2\u0110\u0111\7\t\2\2\u0111")
        buf.write("\u0112\5\20\t\2\u0112\65\3\2\2\2\u0113\u0114\5T+\2\u0114")
        buf.write("\u0115\7\60\2\2\u0115\u0117\7\25\2\2\u0116\u0118\58\35")
        buf.write("\2\u0117\u0116\3\2\2\2\u0117\u0118\3\2\2\2\u0118\u0119")
        buf.write("\3\2\2\2\u0119\u011a\7\26\2\2\u011a\u011b\5\34\17\2\u011b")
        buf.write("\67\3\2\2\2\u011c\u011d\5R*\2\u011d\u0124\7\60\2\2\u011e")
        buf.write("\u011f\7\34\2\2\u011f\u0120\5R*\2\u0120\u0121\7\60\2\2")
        buf.write("\u0121\u0123\3\2\2\2\u0122\u011e\3\2\2\2\u0123\u0126\3")
        buf.write("\2\2\2\u0124\u0122\3\2\2\2\u0124\u0125\3\2\2\2\u01259")
        buf.write("\3\2\2\2\u0126\u0124\3\2\2\2\u0127\u0128\7\60\2\2\u0128")
        buf.write("\u0129\7\25\2\2\u0129\u012e\5N(\2\u012a\u012b\7\34\2\2")
        buf.write("\u012b\u012d\5N(\2\u012c\u012a\3\2\2\2\u012d\u0130\3\2")
        buf.write("\2\2\u012e\u012c\3\2\2\2\u012e\u012f\3\2\2\2\u012f\u0131")
        buf.write("\3\2\2\2\u0130\u012e\3\2\2\2\u0131\u0132\7\26\2\2\u0132")
        buf.write(";\3\2\2\2\u0133\u0134\7\5\2\2\u0134=\3\2\2\2\u0135\u0138")
        buf.write("\5@!\2\u0136\u0138\5B\"\2\u0137\u0135\3\2\2\2\u0137\u0136")
        buf.write("\3\2\2\2\u0138?\3\2\2\2\u0139\u013a\7\23\2\2\u013a\u013e")
        buf.write("\7\60\2\2\u013b\u013c\7\60\2\2\u013c\u013e\7\23\2\2\u013d")
        buf.write("\u0139\3\2\2\2\u013d\u013b\3\2\2\2\u013eA\3\2\2\2\u013f")
        buf.write("\u0140\7\24\2\2\u0140\u0144\7\60\2\2\u0141\u0142\7\60")
        buf.write("\2\2\u0142\u0144\7\24\2\2\u0143\u013f\3\2\2\2\u0143\u0141")
        buf.write("\3\2\2\2\u0144C\3\2\2\2\u0145\u0149\5H%\2\u0146\u0149")
        buf.write("\5J&\2\u0147\u0149\5L\'\2\u0148\u0145\3\2\2\2\u0148\u0146")
        buf.write("\3\2\2\2\u0148\u0147\3\2\2\2\u0149E\3\2\2\2\u014a\u014b")
        buf.write("\t\3\2\2\u014bG\3\2\2\2\u014c\u014d\7\23\2\2\u014d\u0151")
        buf.write("\7\60\2\2\u014e\u014f\7\60\2\2\u014f\u0151\7\23\2\2\u0150")
        buf.write("\u014c\3\2\2\2\u0150\u014e\3\2\2\2\u0151I\3\2\2\2\u0152")
        buf.write("\u0153\7\24\2\2\u0153\u0157\7\60\2\2\u0154\u0155\7\60")
        buf.write("\2\2\u0155\u0157\7\24\2\2\u0156\u0152\3\2\2\2\u0156\u0154")
        buf.write("\3\2\2\2\u0157K\3\2\2\2\u0158\u0159\7\22\2\2\u0159\u015a")
        buf.write("\7\60\2\2\u015aM\3\2\2\2\u015b\u015c\b(\1\2\u015c\u015d")
        buf.write("\7\25\2\2\u015d\u015e\5N(\2\u015e\u015f\7\26\2\2\u015f")
        buf.write("\u0171\3\2\2\2\u0160\u0171\5P)\2\u0161\u0168\7\60\2\2")
        buf.write("\u0162\u0163\7\27\2\2\u0163\u0164\5N(\2\u0164\u0165\7")
        buf.write("\30\2\2\u0165\u0167\3\2\2\2\u0166\u0162\3\2\2\2\u0167")
        buf.write("\u016a\3\2\2\2\u0168\u0166\3\2\2\2\u0168\u0169\3\2\2\2")
        buf.write("\u0169\u0171\3\2\2\2\u016a\u0168\3\2\2\2\u016b\u0171\5")
        buf.write("D#\2\u016c\u016d\5<\37\2\u016d\u016e\5N(\5\u016e\u0171")
        buf.write("\3\2\2\2\u016f\u0171\5:\36\2\u0170\u015b\3\2\2\2\u0170")
        buf.write("\u0160\3\2\2\2\u0170\u0161\3\2\2\2\u0170\u016b\3\2\2\2")
        buf.write("\u0170\u016c\3\2\2\2\u0170\u016f\3\2\2\2\u0171\u0184\3")
        buf.write("\2\2\2\u0172\u0175\f\3\2\2\u0173\u0176\5F$\2\u0174\u0176")
        buf.write("\7\5\2\2\u0175\u0173\3\2\2\2\u0175\u0174\3\2\2\2\u0176")
        buf.write("\u0177\3\2\2\2\u0177\u017f\5N(\2\u0178\u017b\5F$\2\u0179")
        buf.write("\u017b\7\5\2\2\u017a\u0178\3\2\2\2\u017a\u0179\3\2\2\2")
        buf.write("\u017b\u017c\3\2\2\2\u017c\u017e\5N(\2\u017d\u017a\3\2")
        buf.write("\2\2\u017e\u0181\3\2\2\2\u017f\u017d\3\2\2\2\u017f\u0180")
        buf.write("\3\2\2\2\u0180\u0183\3\2\2\2\u0181\u017f\3\2\2\2\u0182")
        buf.write("\u0172\3\2\2\2\u0183\u0186\3\2\2\2\u0184\u0182\3\2\2\2")
        buf.write("\u0184\u0185\3\2\2\2\u0185O\3\2\2\2\u0186\u0184\3\2\2")
        buf.write("\2\u0187\u018e\7\61\2\2\u0188\u018e\7\62\2\2\u0189\u018e")
        buf.write("\7\63\2\2\u018a\u018e\7\64\2\2\u018b\u018e\5V,\2\u018c")
        buf.write("\u018e\7\60\2\2\u018d\u0187\3\2\2\2\u018d\u0188\3\2\2")
        buf.write("\2\u018d\u0189\3\2\2\2\u018d\u018a\3\2\2\2\u018d\u018b")
        buf.write("\3\2\2\2\u018d\u018c\3\2\2\2\u018eQ\3\2\2\2\u018f\u0190")
        buf.write("\t\4\2\2\u0190S\3\2\2\2\u0191\u0192\t\5\2\2\u0192U\3\2")
        buf.write("\2\2\u0193\u0194\t\6\2\2\u0194W\3\2\2\2#[q\u0083\u008d")
        buf.write("\u0093\u0096\u009b\u009e\u00a5\u00ba\u00c3\u00c9\u00d5")
        buf.write("\u00e3\u00e7\u00ef\u010d\u0117\u0124\u012e\u0137\u013d")
        buf.write("\u0143\u0148\u0150\u0156\u0168\u0170\u0175\u017a\u017f")
        buf.write("\u0184\u018d")
        return buf.getvalue()


class javaToPythonParser ( Parser ):

    grammarFileName = "javaToPython.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "<INVALID>", "'+'", "'-'", "'*'", "'/'", 
                     "'%'", "'='", "'>'", "'<'", "'=='", "'>='", "'<='", 
                     "'!='", "'&&'", "'||'", "'!'", "'++'", "'--'", "'('", 
                     "')'", "'['", "']'", "'{'", "'}'", "';'", "','", "'.'", 
                     "'''", "'\"'", "'for'", "'while'", "'if'", "'else'", 
                     "'else if'", "'break'", "'function'", "'return'", "'void'", 
                     "'int'", "'float'", "'char'", "'string'", "'boolean'", 
                     "'true'", "'false'", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "'System.out.print'", "'System.out.println'" ]

    symbolicNames = [ "<INVALID>", "WHITESPACE", "PLUS", "MINUS", "MUL", 
                      "DIV", "MOD", "ASSIGN", "GT", "LT", "EQ", "GT_EQ", 
                      "LT_EQ", "NEQ", "AND", "OR", "NOT", "INCR", "DECR", 
                      "L_PAREN", "R_PAREN", "L_BRACKET", "R_BRACKET", "L_BRACE", 
                      "R_BRACE", "SEMICOLON", "COMMA", "DOT", "QUOTE1", 
                      "QUOTE2", "FOR", "WHILE", "IF", "ELSE", "ELSEIF", 
                      "BREAK", "FUNCTION", "RETURN", "VOID", "INT", "FLOAT", 
                      "CHAR", "STRING", "BOOLEAN", "TRUE", "FALSE", "ID", 
                      "INT_VAL", "FLOAT_VAL", "STRING_VAL", "CHAR_VAL", 
                      "PRINT", "PRINTLN" ]

    RULE_start = 0
    RULE_statement = 1
    RULE_statement_print = 2
    RULE_statement_println = 3
    RULE_inPrint = 4
    RULE_operacjeMatematyczne = 5
    RULE_identifierDec = 6
    RULE_identifierInitializer = 7
    RULE_statement_condition = 8
    RULE_statement_if = 9
    RULE_statement_elseif = 10
    RULE_statement_else = 11
    RULE_block = 12
    RULE_block_function = 13
    RULE_compare = 14
    RULE_conditions = 15
    RULE_condition = 16
    RULE_condOp = 17
    RULE_toNot = 18
    RULE_orOperation = 19
    RULE_andOperation = 20
    RULE_statement_for = 21
    RULE_expression_for = 22
    RULE_statement_while = 23
    RULE_statement_return = 24
    RULE_assignment = 25
    RULE_methodDec = 26
    RULE_params = 27
    RULE_methodCall = 28
    RULE_minusOperator = 29
    RULE_oneArgumentExpressionFor = 30
    RULE_incrementOperationFor = 31
    RULE_decrementOperationFor = 32
    RULE_oneArgumentExpression = 33
    RULE_twoArgumentExpression = 34
    RULE_incrementOperation = 35
    RULE_decrementOperation = 36
    RULE_notOperation = 37
    RULE_expression = 38
    RULE_value = 39
    RULE_identifierType = 40
    RULE_methodType = 41
    RULE_boolean_val = 42

    ruleNames =  [ "start", "statement", "statement_print", "statement_println", 
                   "inPrint", "operacjeMatematyczne", "identifierDec", "identifierInitializer", 
                   "statement_condition", "statement_if", "statement_elseif", 
                   "statement_else", "block", "block_function", "compare", 
                   "conditions", "condition", "condOp", "toNot", "orOperation", 
                   "andOperation", "statement_for", "expression_for", "statement_while", 
                   "statement_return", "assignment", "methodDec", "params", 
                   "methodCall", "minusOperator", "oneArgumentExpressionFor", 
                   "incrementOperationFor", "decrementOperationFor", "oneArgumentExpression", 
                   "twoArgumentExpression", "incrementOperation", "decrementOperation", 
                   "notOperation", "expression", "value", "identifierType", 
                   "methodType", "boolean_val" ]

    EOF = Token.EOF
    WHITESPACE=1
    PLUS=2
    MINUS=3
    MUL=4
    DIV=5
    MOD=6
    ASSIGN=7
    GT=8
    LT=9
    EQ=10
    GT_EQ=11
    LT_EQ=12
    NEQ=13
    AND=14
    OR=15
    NOT=16
    INCR=17
    DECR=18
    L_PAREN=19
    R_PAREN=20
    L_BRACKET=21
    R_BRACKET=22
    L_BRACE=23
    R_BRACE=24
    SEMICOLON=25
    COMMA=26
    DOT=27
    QUOTE1=28
    QUOTE2=29
    FOR=30
    WHILE=31
    IF=32
    ELSE=33
    ELSEIF=34
    BREAK=35
    FUNCTION=36
    RETURN=37
    VOID=38
    INT=39
    FLOAT=40
    CHAR=41
    STRING=42
    BOOLEAN=43
    TRUE=44
    FALSE=45
    ID=46
    INT_VAL=47
    FLOAT_VAL=48
    STRING_VAL=49
    CHAR_VAL=50
    PRINT=51
    PRINTLN=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 StartContext(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(javaToPythonParser.EOF, 0)

        def statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(javaToPythonParser.StatementContext)
            else:
                return self.getTypedRuleContext(javaToPythonParser.StatementContext,i)


        def getRuleIndex(self):
            return javaToPythonParser.RULE_start

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

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




    def start(self):

        localctx = javaToPythonParser.StartContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_start)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 89
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << javaToPythonParser.INCR) | (1 << javaToPythonParser.DECR) | (1 << javaToPythonParser.FOR) | (1 << javaToPythonParser.WHILE) | (1 << javaToPythonParser.IF) | (1 << javaToPythonParser.ELSE) | (1 << javaToPythonParser.ELSEIF) | (1 << javaToPythonParser.VOID) | (1 << javaToPythonParser.INT) | (1 << javaToPythonParser.FLOAT) | (1 << javaToPythonParser.CHAR) | (1 << javaToPythonParser.STRING) | (1 << javaToPythonParser.BOOLEAN) | (1 << javaToPythonParser.ID) | (1 << javaToPythonParser.PRINT) | (1 << javaToPythonParser.PRINTLN))) != 0):
                self.state = 86
                self.statement()
                self.state = 91
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class StatementContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifierDec(self):
            return self.getTypedRuleContext(javaToPythonParser.IdentifierDecContext,0)


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

        def statement_condition(self):
            return self.getTypedRuleContext(javaToPythonParser.Statement_conditionContext,0)


        def statement_for(self):
            return self.getTypedRuleContext(javaToPythonParser.Statement_forContext,0)


        def statement_while(self):
            return self.getTypedRuleContext(javaToPythonParser.Statement_whileContext,0)


        def methodDec(self):
            return self.getTypedRuleContext(javaToPythonParser.MethodDecContext,0)


        def methodCall(self):
            return self.getTypedRuleContext(javaToPythonParser.MethodCallContext,0)


        def operacjeMatematyczne(self):
            return self.getTypedRuleContext(javaToPythonParser.OperacjeMatematyczneContext,0)


        def statement_print(self):
            return self.getTypedRuleContext(javaToPythonParser.Statement_printContext,0)


        def statement_println(self):
            return self.getTypedRuleContext(javaToPythonParser.Statement_printlnContext,0)


        def getRuleIndex(self):
            return javaToPythonParser.RULE_statement

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

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




    def statement(self):

        localctx = javaToPythonParser.StatementContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_statement)
        try:
            self.state = 111
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,1,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 94
                self.identifierDec()
                self.state = 95
                self.match(javaToPythonParser.SEMICOLON)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 97
                self.statement_condition()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 98
                self.statement_for()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 99
                self.statement_while()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 100
                self.methodDec()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 101
                self.methodCall()
                self.state = 102
                self.match(javaToPythonParser.SEMICOLON)
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 104
                self.operacjeMatematyczne()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 105
                self.statement_print()
                self.state = 106
                self.match(javaToPythonParser.SEMICOLON)
                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 108
                self.statement_println()
                self.state = 109
                self.match(javaToPythonParser.SEMICOLON)
                pass


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


    class Statement_printContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def PRINT(self):
            return self.getToken(javaToPythonParser.PRINT, 0)

        def L_PAREN(self):
            return self.getToken(javaToPythonParser.L_PAREN, 0)

        def inPrint(self):
            return self.getTypedRuleContext(javaToPythonParser.InPrintContext,0)


        def R_PAREN(self):
            return self.getToken(javaToPythonParser.R_PAREN, 0)

        def getRuleIndex(self):
            return javaToPythonParser.RULE_statement_print

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

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




    def statement_print(self):

        localctx = javaToPythonParser.Statement_printContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_statement_print)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 113
            self.match(javaToPythonParser.PRINT)
            self.state = 114
            self.match(javaToPythonParser.L_PAREN)
            self.state = 115
            self.inPrint()
            self.state = 116
            self.match(javaToPythonParser.R_PAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Statement_printlnContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def PRINTLN(self):
            return self.getToken(javaToPythonParser.PRINTLN, 0)

        def L_PAREN(self):
            return self.getToken(javaToPythonParser.L_PAREN, 0)

        def inPrint(self):
            return self.getTypedRuleContext(javaToPythonParser.InPrintContext,0)


        def R_PAREN(self):
            return self.getToken(javaToPythonParser.R_PAREN, 0)

        def getRuleIndex(self):
            return javaToPythonParser.RULE_statement_println

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

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




    def statement_println(self):

        localctx = javaToPythonParser.Statement_printlnContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_statement_println)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 118
            self.match(javaToPythonParser.PRINTLN)
            self.state = 119
            self.match(javaToPythonParser.L_PAREN)
            self.state = 120
            self.inPrint()
            self.state = 121
            self.match(javaToPythonParser.R_PAREN)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class InPrintContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def value(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(javaToPythonParser.ValueContext)
            else:
                return self.getTypedRuleContext(javaToPythonParser.ValueContext,i)


        def twoArgumentExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(javaToPythonParser.TwoArgumentExpressionContext)
            else:
                return self.getTypedRuleContext(javaToPythonParser.TwoArgumentExpressionContext,i)


        def getRuleIndex(self):
            return javaToPythonParser.RULE_inPrint

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

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




    def inPrint(self):

        localctx = javaToPythonParser.InPrintContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_inPrint)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 123
            self.value()
            self.state = 129
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << javaToPythonParser.PLUS) | (1 << javaToPythonParser.MUL) | (1 << javaToPythonParser.DIV) | (1 << javaToPythonParser.MOD) | (1 << javaToPythonParser.GT) | (1 << javaToPythonParser.LT) | (1 << javaToPythonParser.EQ) | (1 << javaToPythonParser.GT_EQ) | (1 << javaToPythonParser.LT_EQ))) != 0):
                self.state = 124
                self.twoArgumentExpression()
                self.state = 125
                self.value()
                self.state = 131
                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 OperacjeMatematyczneContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifierDec(self):
            return self.getTypedRuleContext(javaToPythonParser.IdentifierDecContext,0)


        def incrementOperation(self):
            return self.getTypedRuleContext(javaToPythonParser.IncrementOperationContext,0)


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

        def decrementOperation(self):
            return self.getTypedRuleContext(javaToPythonParser.DecrementOperationContext,0)


        def getRuleIndex(self):
            return javaToPythonParser.RULE_operacjeMatematyczne

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

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




    def operacjeMatematyczne(self):

        localctx = javaToPythonParser.OperacjeMatematyczneContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_operacjeMatematyczne)
        try:
            self.state = 139
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,3,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 132
                self.identifierDec()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 133
                self.incrementOperation()
                self.state = 134
                self.match(javaToPythonParser.SEMICOLON)
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 136
                self.decrementOperation()
                self.state = 137
                self.match(javaToPythonParser.SEMICOLON)
                pass


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


    class IdentifierDecContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def identifierType(self):
            return self.getTypedRuleContext(javaToPythonParser.IdentifierTypeContext,0)


        def ASSIGN(self):
            return self.getToken(javaToPythonParser.ASSIGN, 0)

        def identifierInitializer(self):
            return self.getTypedRuleContext(javaToPythonParser.IdentifierInitializerContext,0)


        def getRuleIndex(self):
            return javaToPythonParser.RULE_identifierDec

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

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




    def identifierDec(self):

        localctx = javaToPythonParser.IdentifierDecContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_identifierDec)
        self._la = 0 # Token type
        try:
            self.state = 153
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,6,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 141
                self.identifierType()
                self.state = 142
                self.match(javaToPythonParser.ID)
                self.state = 145
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if _la==javaToPythonParser.ASSIGN:
                    self.state = 143
                    self.match(javaToPythonParser.ASSIGN)
                    self.state = 144
                    self.identifierInitializer()


                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 148
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << javaToPythonParser.INT) | (1 << javaToPythonParser.FLOAT) | (1 << javaToPythonParser.CHAR) | (1 << javaToPythonParser.STRING) | (1 << javaToPythonParser.BOOLEAN))) != 0):
                    self.state = 147
                    self.identifierType()


                self.state = 150
                self.match(javaToPythonParser.ID)

                self.state = 151
                self.match(javaToPythonParser.ASSIGN)
                self.state = 152
                self.identifierInitializer()
                pass


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


    class IdentifierInitializerContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def minusOperator(self):
            return self.getTypedRuleContext(javaToPythonParser.MinusOperatorContext,0)


        def getRuleIndex(self):
            return javaToPythonParser.RULE_identifierInitializer

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

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




    def identifierInitializer(self):

        localctx = javaToPythonParser.IdentifierInitializerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_identifierInitializer)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 156
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,7,self._ctx)
            if la_ == 1:
                self.state = 155
                self.minusOperator()


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


    class Statement_conditionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def statement_if(self):
            return self.getTypedRuleContext(javaToPythonParser.Statement_ifContext,0)


        def statement_elseif(self):
            return self.getTypedRuleContext(javaToPythonParser.Statement_elseifContext,0)


        def statement_else(self):
            return self.getTypedRuleContext(javaToPythonParser.Statement_elseContext,0)


        def getRuleIndex(self):
            return javaToPythonParser.RULE_statement_condition

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

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




    def statement_condition(self):

        localctx = javaToPythonParser.Statement_conditionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_statement_condition)
        try:
            self.state = 163
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [javaToPythonParser.IF]:
                self.enterOuterAlt(localctx, 1)
                self.state = 160
                self.statement_if()
                pass
            elif token in [javaToPythonParser.ELSEIF]:
                self.enterOuterAlt(localctx, 2)
                self.state = 161
                self.statement_elseif()
                pass
            elif token in [javaToPythonParser.ELSE]:
                self.enterOuterAlt(localctx, 3)
                self.state = 162
                self.statement_else()
                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 Statement_ifContext(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(javaToPythonParser.IF, 0)

        def L_PAREN(self):
            return self.getToken(javaToPythonParser.L_PAREN, 0)

        def conditions(self):
            return self.getTypedRuleContext(javaToPythonParser.ConditionsContext,0)


        def R_PAREN(self):
            return self.getToken(javaToPythonParser.R_PAREN, 0)

        def block(self):
            return self.getTypedRuleContext(javaToPythonParser.BlockContext,0)


        def getRuleIndex(self):
            return javaToPythonParser.RULE_statement_if

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

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




    def statement_if(self):

        localctx = javaToPythonParser.Statement_ifContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_statement_if)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 165
            self.match(javaToPythonParser.IF)
            self.state = 166
            self.match(javaToPythonParser.L_PAREN)
            self.state = 167
            self.conditions()
            self.state = 168
            self.match(javaToPythonParser.R_PAREN)
            self.state = 169
            self.block()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Statement_elseifContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def ELSEIF(self):
            return self.getToken(javaToPythonParser.ELSEIF, 0)

        def L_PAREN(self):
            return self.getToken(javaToPythonParser.L_PAREN, 0)

        def conditions(self):
            return self.getTypedRuleContext(javaToPythonParser.ConditionsContext,0)


        def R_PAREN(self):
            return self.getToken(javaToPythonParser.R_PAREN, 0)

        def block(self):
            return self.getTypedRuleContext(javaToPythonParser.BlockContext,0)


        def getRuleIndex(self):
            return javaToPythonParser.RULE_statement_elseif

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

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




    def statement_elseif(self):

        localctx = javaToPythonParser.Statement_elseifContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_statement_elseif)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 171
            self.match(javaToPythonParser.ELSEIF)
            self.state = 172
            self.match(javaToPythonParser.L_PAREN)
            self.state = 173
            self.conditions()
            self.state = 174
            self.match(javaToPythonParser.R_PAREN)
            self.state = 175
            self.block()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Statement_elseContext(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(javaToPythonParser.ELSE, 0)

        def block(self):
            return self.getTypedRuleContext(javaToPythonParser.BlockContext,0)


        def getRuleIndex(self):
            return javaToPythonParser.RULE_statement_else

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

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




    def statement_else(self):

        localctx = javaToPythonParser.Statement_elseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_statement_else)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 177
            self.match(javaToPythonParser.ELSE)
            self.state = 178
            self.block()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BlockContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def L_BRACE(self):
            return self.getToken(javaToPythonParser.L_BRACE, 0)

        def R_BRACE(self):
            return self.getToken(javaToPythonParser.R_BRACE, 0)

        def statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(javaToPythonParser.StatementContext)
            else:
                return self.getTypedRuleContext(javaToPythonParser.StatementContext,i)


        def getRuleIndex(self):
            return javaToPythonParser.RULE_block

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

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




    def block(self):

        localctx = javaToPythonParser.BlockContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_block)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 180
            self.match(javaToPythonParser.L_BRACE)
            self.state = 184
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << javaToPythonParser.INCR) | (1 << javaToPythonParser.DECR) | (1 << javaToPythonParser.FOR) | (1 << javaToPythonParser.WHILE) | (1 << javaToPythonParser.IF) | (1 << javaToPythonParser.ELSE) | (1 << javaToPythonParser.ELSEIF) | (1 << javaToPythonParser.VOID) | (1 << javaToPythonParser.INT) | (1 << javaToPythonParser.FLOAT) | (1 << javaToPythonParser.CHAR) | (1 << javaToPythonParser.STRING) | (1 << javaToPythonParser.BOOLEAN) | (1 << javaToPythonParser.ID) | (1 << javaToPythonParser.PRINT) | (1 << javaToPythonParser.PRINTLN))) != 0):
                self.state = 181
                self.statement()
                self.state = 186
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 187
            self.match(javaToPythonParser.R_BRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Block_functionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def L_BRACE(self):
            return self.getToken(javaToPythonParser.L_BRACE, 0)

        def R_BRACE(self):
            return self.getToken(javaToPythonParser.R_BRACE, 0)

        def statement(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(javaToPythonParser.StatementContext)
            else:
                return self.getTypedRuleContext(javaToPythonParser.StatementContext,i)


        def statement_return(self):
            return self.getTypedRuleContext(javaToPythonParser.Statement_returnContext,0)


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

        def getRuleIndex(self):
            return javaToPythonParser.RULE_block_function

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

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




    def block_function(self):

        localctx = javaToPythonParser.Block_functionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_block_function)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 189
            self.match(javaToPythonParser.L_BRACE)
            self.state = 193
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << javaToPythonParser.INCR) | (1 << javaToPythonParser.DECR) | (1 << javaToPythonParser.FOR) | (1 << javaToPythonParser.WHILE) | (1 << javaToPythonParser.IF) | (1 << javaToPythonParser.ELSE) | (1 << javaToPythonParser.ELSEIF) | (1 << javaToPythonParser.VOID) | (1 << javaToPythonParser.INT) | (1 << javaToPythonParser.FLOAT) | (1 << javaToPythonParser.CHAR) | (1 << javaToPythonParser.STRING) | (1 << javaToPythonParser.BOOLEAN) | (1 << javaToPythonParser.ID) | (1 << javaToPythonParser.PRINT) | (1 << javaToPythonParser.PRINTLN))) != 0):
                self.state = 190
                self.statement()
                self.state = 195
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 199
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==javaToPythonParser.RETURN:
                self.state = 196
                self.statement_return()
                self.state = 197
                self.match(javaToPythonParser.SEMICOLON)


            self.state = 201
            self.match(javaToPythonParser.R_BRACE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CompareContext(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(javaToPythonParser.GT, 0)

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

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

        def GT_EQ(self):
            return self.getToken(javaToPythonParser.GT_EQ, 0)

        def LT_EQ(self):
            return self.getToken(javaToPythonParser.LT_EQ, 0)

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

        def getRuleIndex(self):
            return javaToPythonParser.RULE_compare

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

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




    def compare(self):

        localctx = javaToPythonParser.CompareContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_compare)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 203
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << javaToPythonParser.GT) | (1 << javaToPythonParser.LT) | (1 << javaToPythonParser.EQ) | (1 << javaToPythonParser.GT_EQ) | (1 << javaToPythonParser.LT_EQ) | (1 << javaToPythonParser.NEQ))) != 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 ConditionsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def condition(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(javaToPythonParser.ConditionContext)
            else:
                return self.getTypedRuleContext(javaToPythonParser.ConditionContext,i)


        def condOp(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(javaToPythonParser.CondOpContext)
            else:
                return self.getTypedRuleContext(javaToPythonParser.CondOpContext,i)


        def getRuleIndex(self):
            return javaToPythonParser.RULE_conditions

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

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




    def conditions(self):

        localctx = javaToPythonParser.ConditionsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_conditions)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 205
            self.condition()
            self.state = 211
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==javaToPythonParser.AND or _la==javaToPythonParser.OR:
                self.state = 206
                self.condOp()
                self.state = 207
                self.condition()
                self.state = 213
                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 ConditionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(javaToPythonParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(javaToPythonParser.ExpressionContext,i)


        def compare(self):
            return self.getTypedRuleContext(javaToPythonParser.CompareContext,0)


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

        def toNot(self):
            return self.getTypedRuleContext(javaToPythonParser.ToNotContext,0)


        def boolean_val(self):
            return self.getTypedRuleContext(javaToPythonParser.Boolean_valContext,0)


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

        def minusOperator(self):
            return self.getTypedRuleContext(javaToPythonParser.MinusOperatorContext,0)


        def condition(self):
            return self.getTypedRuleContext(javaToPythonParser.ConditionContext,0)


        def getRuleIndex(self):
            return javaToPythonParser.RULE_condition

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

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




    def condition(self):

        localctx = javaToPythonParser.ConditionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_condition)
        try:
            self.state = 225
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,13,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 214
                self.expression(0)
                self.state = 215
                self.compare()
                self.state = 216
                self.expression(0)
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 218
                self.match(javaToPythonParser.NOT)
                self.state = 219
                self.toNot()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 220
                self.boolean_val()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 221
                self.match(javaToPythonParser.ID)
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 222
                self.minusOperator()
                self.state = 223
                self.condition()
                pass


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


    class CondOpContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def orOperation(self):
            return self.getTypedRuleContext(javaToPythonParser.OrOperationContext,0)


        def andOperation(self):
            return self.getTypedRuleContext(javaToPythonParser.AndOperationContext,0)


        def getRuleIndex(self):
            return javaToPythonParser.RULE_condOp

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

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




    def condOp(self):

        localctx = javaToPythonParser.CondOpContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_condOp)
        try:
            self.state = 229
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [javaToPythonParser.OR]:
                self.enterOuterAlt(localctx, 1)
                self.state = 227
                self.orOperation()
                pass
            elif token in [javaToPythonParser.AND]:
                self.enterOuterAlt(localctx, 2)
                self.state = 228
                self.andOperation()
                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 ToNotContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def L_PAREN(self):
            return self.getToken(javaToPythonParser.L_PAREN, 0)

        def condition(self):
            return self.getTypedRuleContext(javaToPythonParser.ConditionContext,0)


        def R_PAREN(self):
            return self.getToken(javaToPythonParser.R_PAREN, 0)

        def boolean_val(self):
            return self.getTypedRuleContext(javaToPythonParser.Boolean_valContext,0)


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

        def getRuleIndex(self):
            return javaToPythonParser.RULE_toNot

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

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




    def toNot(self):

        localctx = javaToPythonParser.ToNotContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_toNot)
        try:
            self.state = 237
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [javaToPythonParser.L_PAREN]:
                self.enterOuterAlt(localctx, 1)
                self.state = 231
                self.match(javaToPythonParser.L_PAREN)
                self.state = 232
                self.condition()
                self.state = 233
                self.match(javaToPythonParser.R_PAREN)
                pass
            elif token in [javaToPythonParser.TRUE, javaToPythonParser.FALSE]:
                self.enterOuterAlt(localctx, 2)
                self.state = 235
                self.boolean_val()
                pass
            elif token in [javaToPythonParser.ID]:
                self.enterOuterAlt(localctx, 3)
                self.state = 236
                self.match(javaToPythonParser.ID)
                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 OrOperationContext(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(javaToPythonParser.OR, 0)

        def getRuleIndex(self):
            return javaToPythonParser.RULE_orOperation

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

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




    def orOperation(self):

        localctx = javaToPythonParser.OrOperationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_orOperation)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 239
            self.match(javaToPythonParser.OR)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AndOperationContext(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(javaToPythonParser.AND, 0)

        def getRuleIndex(self):
            return javaToPythonParser.RULE_andOperation

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

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




    def andOperation(self):

        localctx = javaToPythonParser.AndOperationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_andOperation)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 241
            self.match(javaToPythonParser.AND)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Statement_forContext(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(javaToPythonParser.FOR, 0)

        def L_PAREN(self):
            return self.getToken(javaToPythonParser.L_PAREN, 0)

        def assignment(self):
            return self.getTypedRuleContext(javaToPythonParser.AssignmentContext,0)


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

        def expression_for(self):
            return self.getTypedRuleContext(javaToPythonParser.Expression_forContext,0)


        def oneArgumentExpressionFor(self):
            return self.getTypedRuleContext(javaToPythonParser.OneArgumentExpressionForContext,0)


        def R_PAREN(self):
            return self.getToken(javaToPythonParser.R_PAREN, 0)

        def block(self):
            return self.getTypedRuleContext(javaToPythonParser.BlockContext,0)


        def getRuleIndex(self):
            return javaToPythonParser.RULE_statement_for

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

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




    def statement_for(self):

        localctx = javaToPythonParser.Statement_forContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_statement_for)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 243
            self.match(javaToPythonParser.FOR)
            self.state = 244
            self.match(javaToPythonParser.L_PAREN)
            self.state = 245
            self.assignment()
            self.state = 246
            self.match(javaToPythonParser.SEMICOLON)
            self.state = 247
            self.expression_for()
            self.state = 248
            self.match(javaToPythonParser.SEMICOLON)
            self.state = 249
            self.oneArgumentExpressionFor()
            self.state = 250
            self.match(javaToPythonParser.R_PAREN)
            self.state = 251
            self.block()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Expression_forContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(javaToPythonParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(javaToPythonParser.ExpressionContext,i)


        def compare(self):
            return self.getTypedRuleContext(javaToPythonParser.CompareContext,0)


        def getRuleIndex(self):
            return javaToPythonParser.RULE_expression_for

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

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




    def expression_for(self):

        localctx = javaToPythonParser.Expression_forContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_expression_for)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 253
            self.expression(0)
            self.state = 254
            self.compare()
            self.state = 255
            self.expression(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Statement_whileContext(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(javaToPythonParser.WHILE, 0)

        def L_PAREN(self):
            return self.getToken(javaToPythonParser.L_PAREN, 0)

        def conditions(self):
            return self.getTypedRuleContext(javaToPythonParser.ConditionsContext,0)


        def R_PAREN(self):
            return self.getToken(javaToPythonParser.R_PAREN, 0)

        def block(self):
            return self.getTypedRuleContext(javaToPythonParser.BlockContext,0)


        def getRuleIndex(self):
            return javaToPythonParser.RULE_statement_while

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

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




    def statement_while(self):

        localctx = javaToPythonParser.Statement_whileContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_statement_while)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 257
            self.match(javaToPythonParser.WHILE)
            self.state = 258
            self.match(javaToPythonParser.L_PAREN)
            self.state = 259
            self.conditions()
            self.state = 260
            self.match(javaToPythonParser.R_PAREN)
            self.state = 261
            self.block()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class Statement_returnContext(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(javaToPythonParser.RETURN, 0)

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


        def getRuleIndex(self):
            return javaToPythonParser.RULE_statement_return

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

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




    def statement_return(self):

        localctx = javaToPythonParser.Statement_returnContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_statement_return)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 263
            self.match(javaToPythonParser.RETURN)
            self.state = 264
            self.expression(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class AssignmentContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def ASSIGN(self):
            return self.getToken(javaToPythonParser.ASSIGN, 0)

        def identifierInitializer(self):
            return self.getTypedRuleContext(javaToPythonParser.IdentifierInitializerContext,0)


        def identifierType(self):
            return self.getTypedRuleContext(javaToPythonParser.IdentifierTypeContext,0)


        def getRuleIndex(self):
            return javaToPythonParser.RULE_assignment

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

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




    def assignment(self):

        localctx = javaToPythonParser.AssignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_assignment)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 267
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << javaToPythonParser.INT) | (1 << javaToPythonParser.FLOAT) | (1 << javaToPythonParser.CHAR) | (1 << javaToPythonParser.STRING) | (1 << javaToPythonParser.BOOLEAN))) != 0):
                self.state = 266
                self.identifierType()


            self.state = 269
            self.match(javaToPythonParser.ID)
            self.state = 270
            self.match(javaToPythonParser.ASSIGN)
            self.state = 271
            self.identifierInitializer()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MethodDecContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def methodType(self):
            return self.getTypedRuleContext(javaToPythonParser.MethodTypeContext,0)


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

        def L_PAREN(self):
            return self.getToken(javaToPythonParser.L_PAREN, 0)

        def R_PAREN(self):
            return self.getToken(javaToPythonParser.R_PAREN, 0)

        def block_function(self):
            return self.getTypedRuleContext(javaToPythonParser.Block_functionContext,0)


        def params(self):
            return self.getTypedRuleContext(javaToPythonParser.ParamsContext,0)


        def getRuleIndex(self):
            return javaToPythonParser.RULE_methodDec

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

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




    def methodDec(self):

        localctx = javaToPythonParser.MethodDecContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_methodDec)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 273
            self.methodType()
            self.state = 274
            self.match(javaToPythonParser.ID)
            self.state = 275
            self.match(javaToPythonParser.L_PAREN)
            self.state = 277
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << javaToPythonParser.INT) | (1 << javaToPythonParser.FLOAT) | (1 << javaToPythonParser.CHAR) | (1 << javaToPythonParser.STRING) | (1 << javaToPythonParser.BOOLEAN))) != 0):
                self.state = 276
                self.params()


            self.state = 279
            self.match(javaToPythonParser.R_PAREN)
            self.state = 280
            self.block_function()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ParamsContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def identifierType(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(javaToPythonParser.IdentifierTypeContext)
            else:
                return self.getTypedRuleContext(javaToPythonParser.IdentifierTypeContext,i)


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

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

        def getRuleIndex(self):
            return javaToPythonParser.RULE_params

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

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




    def params(self):

        localctx = javaToPythonParser.ParamsContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_params)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 282
            self.identifierType()
            self.state = 283
            self.match(javaToPythonParser.ID)
            self.state = 290
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==javaToPythonParser.COMMA:
                self.state = 284
                self.match(javaToPythonParser.COMMA)
                self.state = 285
                self.identifierType()
                self.state = 286
                self.match(javaToPythonParser.ID)
                self.state = 292
                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 MethodCallContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def L_PAREN(self):
            return self.getToken(javaToPythonParser.L_PAREN, 0)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(javaToPythonParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(javaToPythonParser.ExpressionContext,i)


        def R_PAREN(self):
            return self.getToken(javaToPythonParser.R_PAREN, 0)

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

        def getRuleIndex(self):
            return javaToPythonParser.RULE_methodCall

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

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




    def methodCall(self):

        localctx = javaToPythonParser.MethodCallContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_methodCall)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 293
            self.match(javaToPythonParser.ID)
            self.state = 294
            self.match(javaToPythonParser.L_PAREN)
            self.state = 295
            self.expression(0)
            self.state = 300
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==javaToPythonParser.COMMA:
                self.state = 296
                self.match(javaToPythonParser.COMMA)
                self.state = 297
                self.expression(0)
                self.state = 302
                self._errHandler.sync(self)
                _la = self._input.LA(1)

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


    class MinusOperatorContext(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(javaToPythonParser.MINUS, 0)

        def getRuleIndex(self):
            return javaToPythonParser.RULE_minusOperator

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

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




    def minusOperator(self):

        localctx = javaToPythonParser.MinusOperatorContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_minusOperator)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 305
            self.match(javaToPythonParser.MINUS)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class OneArgumentExpressionForContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def incrementOperationFor(self):
            return self.getTypedRuleContext(javaToPythonParser.IncrementOperationForContext,0)


        def decrementOperationFor(self):
            return self.getTypedRuleContext(javaToPythonParser.DecrementOperationForContext,0)


        def getRuleIndex(self):
            return javaToPythonParser.RULE_oneArgumentExpressionFor

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

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




    def oneArgumentExpressionFor(self):

        localctx = javaToPythonParser.OneArgumentExpressionForContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_oneArgumentExpressionFor)
        try:
            self.state = 309
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,20,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 307
                self.incrementOperationFor()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 308
                self.decrementOperationFor()
                pass


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


    class IncrementOperationForContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def INCR(self):
            return self.getToken(javaToPythonParser.INCR, 0)

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

        def getRuleIndex(self):
            return javaToPythonParser.RULE_incrementOperationFor

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

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




    def incrementOperationFor(self):

        localctx = javaToPythonParser.IncrementOperationForContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_incrementOperationFor)
        try:
            self.state = 315
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [javaToPythonParser.INCR]:
                self.enterOuterAlt(localctx, 1)
                self.state = 311
                self.match(javaToPythonParser.INCR)
                self.state = 312
                self.match(javaToPythonParser.ID)
                pass
            elif token in [javaToPythonParser.ID]:
                self.enterOuterAlt(localctx, 2)
                self.state = 313
                self.match(javaToPythonParser.ID)
                self.state = 314
                self.match(javaToPythonParser.INCR)
                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 DecrementOperationForContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DECR(self):
            return self.getToken(javaToPythonParser.DECR, 0)

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

        def getRuleIndex(self):
            return javaToPythonParser.RULE_decrementOperationFor

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

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




    def decrementOperationFor(self):

        localctx = javaToPythonParser.DecrementOperationForContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_decrementOperationFor)
        try:
            self.state = 321
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [javaToPythonParser.DECR]:
                self.enterOuterAlt(localctx, 1)
                self.state = 317
                self.match(javaToPythonParser.DECR)
                self.state = 318
                self.match(javaToPythonParser.ID)
                pass
            elif token in [javaToPythonParser.ID]:
                self.enterOuterAlt(localctx, 2)
                self.state = 319
                self.match(javaToPythonParser.ID)
                self.state = 320
                self.match(javaToPythonParser.DECR)
                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 OneArgumentExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def incrementOperation(self):
            return self.getTypedRuleContext(javaToPythonParser.IncrementOperationContext,0)


        def decrementOperation(self):
            return self.getTypedRuleContext(javaToPythonParser.DecrementOperationContext,0)


        def notOperation(self):
            return self.getTypedRuleContext(javaToPythonParser.NotOperationContext,0)


        def getRuleIndex(self):
            return javaToPythonParser.RULE_oneArgumentExpression

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

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




    def oneArgumentExpression(self):

        localctx = javaToPythonParser.OneArgumentExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_oneArgumentExpression)
        try:
            self.state = 326
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,23,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 323
                self.incrementOperation()
                pass

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

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


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


    class TwoArgumentExpressionContext(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(javaToPythonParser.MUL, 0)

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

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

        def MOD(self):
            return self.getToken(javaToPythonParser.MOD, 0)

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

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

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

        def GT_EQ(self):
            return self.getToken(javaToPythonParser.GT_EQ, 0)

        def LT_EQ(self):
            return self.getToken(javaToPythonParser.LT_EQ, 0)

        def getRuleIndex(self):
            return javaToPythonParser.RULE_twoArgumentExpression

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

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




    def twoArgumentExpression(self):

        localctx = javaToPythonParser.TwoArgumentExpressionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_twoArgumentExpression)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 328
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << javaToPythonParser.PLUS) | (1 << javaToPythonParser.MUL) | (1 << javaToPythonParser.DIV) | (1 << javaToPythonParser.MOD) | (1 << javaToPythonParser.GT) | (1 << javaToPythonParser.LT) | (1 << javaToPythonParser.EQ) | (1 << javaToPythonParser.GT_EQ) | (1 << javaToPythonParser.LT_EQ))) != 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 IncrementOperationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def INCR(self):
            return self.getToken(javaToPythonParser.INCR, 0)

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

        def getRuleIndex(self):
            return javaToPythonParser.RULE_incrementOperation

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

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




    def incrementOperation(self):

        localctx = javaToPythonParser.IncrementOperationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_incrementOperation)
        try:
            self.state = 334
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [javaToPythonParser.INCR]:
                self.enterOuterAlt(localctx, 1)
                self.state = 330
                self.match(javaToPythonParser.INCR)
                self.state = 331
                self.match(javaToPythonParser.ID)
                pass
            elif token in [javaToPythonParser.ID]:
                self.enterOuterAlt(localctx, 2)
                self.state = 332
                self.match(javaToPythonParser.ID)
                self.state = 333
                self.match(javaToPythonParser.INCR)
                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 DecrementOperationContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DECR(self):
            return self.getToken(javaToPythonParser.DECR, 0)

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

        def getRuleIndex(self):
            return javaToPythonParser.RULE_decrementOperation

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

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




    def decrementOperation(self):

        localctx = javaToPythonParser.DecrementOperationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_decrementOperation)
        try:
            self.state = 340
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [javaToPythonParser.DECR]:
                self.enterOuterAlt(localctx, 1)
                self.state = 336
                self.match(javaToPythonParser.DECR)
                self.state = 337
                self.match(javaToPythonParser.ID)
                pass
            elif token in [javaToPythonParser.ID]:
                self.enterOuterAlt(localctx, 2)
                self.state = 338
                self.match(javaToPythonParser.ID)
                self.state = 339
                self.match(javaToPythonParser.DECR)
                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 NotOperationContext(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(javaToPythonParser.NOT, 0)

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

        def getRuleIndex(self):
            return javaToPythonParser.RULE_notOperation

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

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




    def notOperation(self):

        localctx = javaToPythonParser.NotOperationContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_notOperation)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 342
            self.match(javaToPythonParser.NOT)
            self.state = 343
            self.match(javaToPythonParser.ID)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExpressionContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def L_PAREN(self):
            return self.getToken(javaToPythonParser.L_PAREN, 0)

        def expression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(javaToPythonParser.ExpressionContext)
            else:
                return self.getTypedRuleContext(javaToPythonParser.ExpressionContext,i)


        def R_PAREN(self):
            return self.getToken(javaToPythonParser.R_PAREN, 0)

        def value(self):
            return self.getTypedRuleContext(javaToPythonParser.ValueContext,0)


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

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

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

        def oneArgumentExpression(self):
            return self.getTypedRuleContext(javaToPythonParser.OneArgumentExpressionContext,0)


        def minusOperator(self):
            return self.getTypedRuleContext(javaToPythonParser.MinusOperatorContext,0)


        def methodCall(self):
            return self.getTypedRuleContext(javaToPythonParser.MethodCallContext,0)


        def twoArgumentExpression(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(javaToPythonParser.TwoArgumentExpressionContext)
            else:
                return self.getTypedRuleContext(javaToPythonParser.TwoArgumentExpressionContext,i)


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

        def getRuleIndex(self):
            return javaToPythonParser.RULE_expression

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

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



    def expression(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = javaToPythonParser.ExpressionContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 76
        self.enterRecursionRule(localctx, 76, self.RULE_expression, _p)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 366
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,27,self._ctx)
            if la_ == 1:
                self.state = 346
                self.match(javaToPythonParser.L_PAREN)
                self.state = 347
                self.expression(0)
                self.state = 348
                self.match(javaToPythonParser.R_PAREN)
                pass

            elif la_ == 2:
                self.state = 350
                self.value()
                pass

            elif la_ == 3:
                self.state = 351
                self.match(javaToPythonParser.ID)
                self.state = 358
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,26,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 352
                        self.match(javaToPythonParser.L_BRACKET)
                        self.state = 353
                        self.expression(0)
                        self.state = 354
                        self.match(javaToPythonParser.R_BRACKET) 
                    self.state = 360
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,26,self._ctx)

                pass

            elif la_ == 4:
                self.state = 361
                self.oneArgumentExpression()
                pass

            elif la_ == 5:
                self.state = 362
                self.minusOperator()
                self.state = 363
                self.expression(3)
                pass

            elif la_ == 6:
                self.state = 365
                self.methodCall()
                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 386
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,31,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    localctx = javaToPythonParser.ExpressionContext(self, _parentctx, _parentState)
                    self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
                    self.state = 368
                    if not self.precpred(self._ctx, 1):
                        from antlr4.error.Errors import FailedPredicateException
                        raise FailedPredicateException(self, "self.precpred(self._ctx, 1)")
                    self.state = 371
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [javaToPythonParser.PLUS, javaToPythonParser.MUL, javaToPythonParser.DIV, javaToPythonParser.MOD, javaToPythonParser.GT, javaToPythonParser.LT, javaToPythonParser.EQ, javaToPythonParser.GT_EQ, javaToPythonParser.LT_EQ]:
                        self.state = 369
                        self.twoArgumentExpression()
                        pass
                    elif token in [javaToPythonParser.MINUS]:
                        self.state = 370
                        self.match(javaToPythonParser.MINUS)
                        pass
                    else:
                        raise NoViableAltException(self)

                    self.state = 373
                    self.expression(0)
                    self.state = 381
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,30,self._ctx)
                    while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                        if _alt==1:
                            self.state = 376
                            self._errHandler.sync(self)
                            token = self._input.LA(1)
                            if token in [javaToPythonParser.PLUS, javaToPythonParser.MUL, javaToPythonParser.DIV, javaToPythonParser.MOD, javaToPythonParser.GT, javaToPythonParser.LT, javaToPythonParser.EQ, javaToPythonParser.GT_EQ, javaToPythonParser.LT_EQ]:
                                self.state = 374
                                self.twoArgumentExpression()
                                pass
                            elif token in [javaToPythonParser.MINUS]:
                                self.state = 375
                                self.match(javaToPythonParser.MINUS)
                                pass
                            else:
                                raise NoViableAltException(self)

                            self.state = 378
                            self.expression(0) 
                        self.state = 383
                        self._errHandler.sync(self)
                        _alt = self._interp.adaptivePredict(self._input,30,self._ctx)
             
                self.state = 388
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,31,self._ctx)

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


    class ValueContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def INT_VAL(self):
            return self.getToken(javaToPythonParser.INT_VAL, 0)

        def FLOAT_VAL(self):
            return self.getToken(javaToPythonParser.FLOAT_VAL, 0)

        def STRING_VAL(self):
            return self.getToken(javaToPythonParser.STRING_VAL, 0)

        def CHAR_VAL(self):
            return self.getToken(javaToPythonParser.CHAR_VAL, 0)

        def boolean_val(self):
            return self.getTypedRuleContext(javaToPythonParser.Boolean_valContext,0)


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

        def getRuleIndex(self):
            return javaToPythonParser.RULE_value

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

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




    def value(self):

        localctx = javaToPythonParser.ValueContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_value)
        try:
            self.state = 395
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [javaToPythonParser.INT_VAL]:
                self.enterOuterAlt(localctx, 1)
                self.state = 389
                self.match(javaToPythonParser.INT_VAL)
                pass
            elif token in [javaToPythonParser.FLOAT_VAL]:
                self.enterOuterAlt(localctx, 2)
                self.state = 390
                self.match(javaToPythonParser.FLOAT_VAL)
                pass
            elif token in [javaToPythonParser.STRING_VAL]:
                self.enterOuterAlt(localctx, 3)
                self.state = 391
                self.match(javaToPythonParser.STRING_VAL)
                pass
            elif token in [javaToPythonParser.CHAR_VAL]:
                self.enterOuterAlt(localctx, 4)
                self.state = 392
                self.match(javaToPythonParser.CHAR_VAL)
                pass
            elif token in [javaToPythonParser.TRUE, javaToPythonParser.FALSE]:
                self.enterOuterAlt(localctx, 5)
                self.state = 393
                self.boolean_val()
                pass
            elif token in [javaToPythonParser.ID]:
                self.enterOuterAlt(localctx, 6)
                self.state = 394
                self.match(javaToPythonParser.ID)
                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 IdentifierTypeContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def INT(self):
            return self.getToken(javaToPythonParser.INT, 0)

        def FLOAT(self):
            return self.getToken(javaToPythonParser.FLOAT, 0)

        def CHAR(self):
            return self.getToken(javaToPythonParser.CHAR, 0)

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

        def getRuleIndex(self):
            return javaToPythonParser.RULE_identifierType

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

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




    def identifierType(self):

        localctx = javaToPythonParser.IdentifierTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_identifierType)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 397
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << javaToPythonParser.INT) | (1 << javaToPythonParser.FLOAT) | (1 << javaToPythonParser.CHAR) | (1 << javaToPythonParser.STRING) | (1 << javaToPythonParser.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 MethodTypeContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def INT(self):
            return self.getToken(javaToPythonParser.INT, 0)

        def FLOAT(self):
            return self.getToken(javaToPythonParser.FLOAT, 0)

        def VOID(self):
            return self.getToken(javaToPythonParser.VOID, 0)

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

        def CHAR(self):
            return self.getToken(javaToPythonParser.CHAR, 0)

        def getRuleIndex(self):
            return javaToPythonParser.RULE_methodType

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

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




    def methodType(self):

        localctx = javaToPythonParser.MethodTypeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_methodType)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 399
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << javaToPythonParser.VOID) | (1 << javaToPythonParser.INT) | (1 << javaToPythonParser.FLOAT) | (1 << javaToPythonParser.CHAR) | (1 << javaToPythonParser.STRING) | (1 << javaToPythonParser.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 Boolean_valContext(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(javaToPythonParser.TRUE, 0)

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

        def getRuleIndex(self):
            return javaToPythonParser.RULE_boolean_val

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

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




    def boolean_val(self):

        localctx = javaToPythonParser.Boolean_valContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_boolean_val)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 401
            _la = self._input.LA(1)
            if not(_la==javaToPythonParser.TRUE or _la==javaToPythonParser.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



    def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
        if self._predicates == None:
            self._predicates = dict()
        self._predicates[38] = self.expression_sempred
        pred = self._predicates.get(ruleIndex, None)
        if pred is None:
            raise Exception("No predicate with index:" + str(ruleIndex))
        else:
            return pred(localctx, predIndex)

    def expression_sempred(self, localctx:ExpressionContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 1)
         




