# Generated from ./vendor/wizparse/wizards/wizard.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\3D")
        buf.write("\u0145\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\3\2\3\2")
        buf.write("\3\2\3\3\3\3\7\3@\n\3\f\3\16\3C\13\3\3\4\3\4\3\4\3\4\5")
        buf.write("\4I\n\4\3\5\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\7\3\7\3\7\3")
        buf.write("\7\3\7\3\7\3\7\3\7\5\7[\n\7\3\b\3\b\5\b_\n\b\3\t\3\t\3")
        buf.write("\t\3\t\3\n\3\n\3\n\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\r")
        buf.write("\3\r\3\r\3\r\5\rs\n\r\3\r\3\r\3\r\3\16\3\16\3\16\3\16")
        buf.write("\3\16\3\16\5\16~\n\16\3\17\3\17\3\17\3\20\3\20\3\20\3")
        buf.write("\20\7\20\u0087\n\20\f\20\16\20\u008a\13\20\3\20\5\20\u008d")
        buf.write("\n\20\3\20\3\20\3\21\3\21\5\21\u0093\n\21\3\21\3\21\3")
        buf.write("\22\7\22\u0098\n\22\f\22\16\22\u009b\13\22\3\22\5\22\u009e")
        buf.write("\n\22\3\23\3\23\3\23\3\23\3\23\3\23\3\24\3\24\3\24\3\24")
        buf.write("\7\24\u00aa\n\24\f\24\16\24\u00ad\13\24\3\24\5\24\u00b0")
        buf.write("\n\24\3\24\3\24\3\25\3\25\3\25\3\25\7\25\u00b8\n\25\f")
        buf.write("\25\16\25\u00bb\13\25\3\25\5\25\u00be\n\25\3\25\3\25\3")
        buf.write("\26\3\26\3\26\3\26\3\26\3\27\3\27\3\27\7\27\u00ca\n\27")
        buf.write("\f\27\16\27\u00cd\13\27\5\27\u00cf\n\27\3\30\3\30\3\30")
        buf.write("\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31")
        buf.write("\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31")
        buf.write("\3\31\3\31\3\31\3\31\3\31\5\31\u00ef\n\31\5\31\u00f1\n")
        buf.write("\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31")
        buf.write("\3\31\3\31\5\31\u00ff\n\31\3\31\3\31\3\31\3\31\5\31\u0105")
        buf.write("\n\31\3\31\3\31\3\31\3\31\5\31\u010b\n\31\3\31\3\31\3")
        buf.write("\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31")
        buf.write("\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\5\31\u0123")
        buf.write("\n\31\3\31\3\31\5\31\u0127\n\31\3\31\3\31\5\31\u012b\n")
        buf.write("\31\5\31\u012d\n\31\3\31\3\31\3\31\3\31\3\31\5\31\u0134")
        buf.write("\n\31\7\31\u0136\n\31\f\31\16\31\u0139\13\31\3\32\3\32")
        buf.write("\3\33\3\33\3\34\3\34\3\34\3\34\3\35\3\35\3\35\2\3\60\36")
        buf.write("\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62")
        buf.write("\64\668\2\r\3\2 %\3\2\16\17\4\2::>?\3\2;<\3\2\'(\3\2)")
        buf.write("*\4\2&&++\3\2\20\21\3\2\22\23\3\2\24\26\3\289\2\u0162")
        buf.write("\2:\3\2\2\2\4A\3\2\2\2\6H\3\2\2\2\bJ\3\2\2\2\nN\3\2\2")
        buf.write("\2\fZ\3\2\2\2\16\\\3\2\2\2\20`\3\2\2\2\22d\3\2\2\2\24")
        buf.write("g\3\2\2\2\26k\3\2\2\2\30n\3\2\2\2\32w\3\2\2\2\34\177\3")
        buf.write("\2\2\2\36\u0082\3\2\2\2 \u0092\3\2\2\2\"\u0099\3\2\2\2")
        buf.write("$\u009f\3\2\2\2&\u00a5\3\2\2\2(\u00b3\3\2\2\2*\u00c1\3")
        buf.write("\2\2\2,\u00ce\3\2\2\2.\u00d0\3\2\2\2\60\u00f0\3\2\2\2")
        buf.write("\62\u013a\3\2\2\2\64\u013c\3\2\2\2\66\u013e\3\2\2\28\u0142")
        buf.write("\3\2\2\2:;\5\4\3\2;<\7\2\2\3<\3\3\2\2\2=@\5\6\4\2>@\5")
        buf.write("\60\31\2?=\3\2\2\2?>\3\2\2\2@C\3\2\2\2A?\3\2\2\2AB\3\2")
        buf.write("\2\2B\5\3\2\2\2CA\3\2\2\2DI\5\b\5\2EI\5\n\6\2FI\5\f\7")
        buf.write("\2GI\5.\30\2HD\3\2\2\2HE\3\2\2\2HF\3\2\2\2HG\3\2\2\2I")
        buf.write("\7\3\2\2\2JK\7C\2\2KL\7,\2\2LM\5\60\31\2M\t\3\2\2\2NO")
        buf.write("\7C\2\2OP\t\2\2\2PQ\5\60\31\2Q\13\3\2\2\2R[\7-\2\2S[\5")
        buf.write("\16\b\2T[\7.\2\2U[\5\30\r\2V[\5\36\20\2W[\7\65\2\2X[\5")
        buf.write(" \21\2Y[\5*\26\2ZR\3\2\2\2ZS\3\2\2\2ZT\3\2\2\2ZU\3\2\2")
        buf.write("\2ZV\3\2\2\2ZW\3\2\2\2ZX\3\2\2\2ZY\3\2\2\2[\r\3\2\2\2")
        buf.write("\\^\7\3\2\2]_\5\60\31\2^]\3\2\2\2^_\3\2\2\2_\17\3\2\2")
        buf.write("\2`a\7\4\2\2ab\5\60\31\2bc\5\4\3\2c\21\3\2\2\2de\7\5\2")
        buf.write("\2ef\5\4\3\2f\23\3\2\2\2gh\7/\2\2hi\5\60\31\2ij\5\4\3")
        buf.write("\2j\25\3\2\2\2kl\7\60\2\2lm\5\4\3\2m\27\3\2\2\2no\7\6")
        buf.write("\2\2or\7C\2\2ps\5\32\16\2qs\5\34\17\2rp\3\2\2\2rq\3\2")
        buf.write("\2\2st\3\2\2\2tu\5\4\3\2uv\7\61\2\2v\31\3\2\2\2wx\7\7")
        buf.write("\2\2xy\5\60\31\2yz\7\b\2\2z}\5\60\31\2{|\7\t\2\2|~\5\60")
        buf.write("\31\2}{\3\2\2\2}~\3\2\2\2~\33\3\2\2\2\177\u0080\7A\2\2")
        buf.write("\u0080\u0081\5\60\31\2\u0081\35\3\2\2\2\u0082\u0083\7")
        buf.write("\n\2\2\u0083\u0084\5\60\31\2\u0084\u0088\5\4\3\2\u0085")
        buf.write("\u0087\5\24\13\2\u0086\u0085\3\2\2\2\u0087\u008a\3\2\2")
        buf.write("\2\u0088\u0086\3\2\2\2\u0088\u0089\3\2\2\2\u0089\u008c")
        buf.write("\3\2\2\2\u008a\u0088\3\2\2\2\u008b\u008d\5\26\f\2\u008c")
        buf.write("\u008b\3\2\2\2\u008c\u008d\3\2\2\2\u008d\u008e\3\2\2\2")
        buf.write("\u008e\u008f\7\62\2\2\u008f\37\3\2\2\2\u0090\u0093\5&")
        buf.write("\24\2\u0091\u0093\5(\25\2\u0092\u0090\3\2\2\2\u0092\u0091")
        buf.write("\3\2\2\2\u0093\u0094\3\2\2\2\u0094\u0095\7\63\2\2\u0095")
        buf.write("!\3\2\2\2\u0096\u0098\5\20\t\2\u0097\u0096\3\2\2\2\u0098")
        buf.write("\u009b\3\2\2\2\u0099\u0097\3\2\2\2\u0099\u009a\3\2\2\2")
        buf.write("\u009a\u009d\3\2\2\2\u009b\u0099\3\2\2\2\u009c\u009e\5")
        buf.write("\22\n\2\u009d\u009c\3\2\2\2\u009d\u009e\3\2\2\2\u009e")
        buf.write("#\3\2\2\2\u009f\u00a0\5\60\31\2\u00a0\u00a1\7\31\2\2\u00a1")
        buf.write("\u00a2\5\60\31\2\u00a2\u00a3\7\31\2\2\u00a3\u00a4\5\60")
        buf.write("\31\2\u00a4%\3\2\2\2\u00a5\u00a6\7\13\2\2\u00a6\u00ab")
        buf.write("\5\60\31\2\u00a7\u00a8\7\31\2\2\u00a8\u00aa\5$\23\2\u00a9")
        buf.write("\u00a7\3\2\2\2\u00aa\u00ad\3\2\2\2\u00ab\u00a9\3\2\2\2")
        buf.write("\u00ab\u00ac\3\2\2\2\u00ac\u00af\3\2\2\2\u00ad\u00ab\3")
        buf.write("\2\2\2\u00ae\u00b0\7\31\2\2\u00af\u00ae\3\2\2\2\u00af")
        buf.write("\u00b0\3\2\2\2\u00b0\u00b1\3\2\2\2\u00b1\u00b2\5\"\22")
        buf.write("\2\u00b2\'\3\2\2\2\u00b3\u00b4\7\f\2\2\u00b4\u00b9\5\60")
        buf.write("\31\2\u00b5\u00b6\7\31\2\2\u00b6\u00b8\5$\23\2\u00b7\u00b5")
        buf.write("\3\2\2\2\u00b8\u00bb\3\2\2\2\u00b9\u00b7\3\2\2\2\u00b9")
        buf.write("\u00ba\3\2\2\2\u00ba\u00bd\3\2\2\2\u00bb\u00b9\3\2\2\2")
        buf.write("\u00bc\u00be\7\31\2\2\u00bd\u00bc\3\2\2\2\u00bd\u00be")
        buf.write("\3\2\2\2\u00be\u00bf\3\2\2\2\u00bf\u00c0\5\"\22\2\u00c0")
        buf.write(")\3\2\2\2\u00c1\u00c2\7\r\2\2\u00c2\u00c3\5\60\31\2\u00c3")
        buf.write("\u00c4\5\4\3\2\u00c4\u00c5\7\64\2\2\u00c5+\3\2\2\2\u00c6")
        buf.write("\u00cb\5\60\31\2\u00c7\u00c8\7\31\2\2\u00c8\u00ca\5\60")
        buf.write("\31\2\u00c9\u00c7\3\2\2\2\u00ca\u00cd\3\2\2\2\u00cb\u00c9")
        buf.write("\3\2\2\2\u00cb\u00cc\3\2\2\2\u00cc\u00cf\3\2\2\2\u00cd")
        buf.write("\u00cb\3\2\2\2\u00ce\u00c6\3\2\2\2\u00ce\u00cf\3\2\2\2")
        buf.write("\u00cf-\3\2\2\2\u00d0\u00d1\7\66\2\2\u00d1\u00d2\5,\27")
        buf.write("\2\u00d2/\3\2\2\2\u00d3\u00d4\b\31\1\2\u00d4\u00d5\7\33")
        buf.write("\2\2\u00d5\u00d6\5\60\31\2\u00d6\u00d7\7\34\2\2\u00d7")
        buf.write("\u00f1\3\2\2\2\u00d8\u00d9\7C\2\2\u00d9\u00da\7\33\2\2")
        buf.write("\u00da\u00db\5,\27\2\u00db\u00dc\7\34\2\2\u00dc\u00f1")
        buf.write("\3\2\2\2\u00dd\u00de\7B\2\2\u00de\u00f1\7C\2\2\u00df\u00e0")
        buf.write("\7C\2\2\u00e0\u00f1\7B\2\2\u00e1\u00e2\7@\2\2\u00e2\u00f1")
        buf.write("\7C\2\2\u00e3\u00e4\7C\2\2\u00e4\u00f1\7@\2\2\u00e5\u00e6")
        buf.write("\7;\2\2\u00e6\u00f1\5\60\31\20\u00e7\u00e8\t\3\2\2\u00e8")
        buf.write("\u00f1\5\60\31\17\u00e9\u00ef\5\62\32\2\u00ea\u00ef\5")
        buf.write("\66\34\2\u00eb\u00ef\5\64\33\2\u00ec\u00ef\58\35\2\u00ed")
        buf.write("\u00ef\7C\2\2\u00ee\u00e9\3\2\2\2\u00ee\u00ea\3\2\2\2")
        buf.write("\u00ee\u00eb\3\2\2\2\u00ee\u00ec\3\2\2\2\u00ee\u00ed\3")
        buf.write("\2\2\2\u00ef\u00f1\3\2\2\2\u00f0\u00d3\3\2\2\2\u00f0\u00d8")
        buf.write("\3\2\2\2\u00f0\u00dd\3\2\2\2\u00f0\u00df\3\2\2\2\u00f0")
        buf.write("\u00e1\3\2\2\2\u00f0\u00e3\3\2\2\2\u00f0\u00e5\3\2\2\2")
        buf.write("\u00f0\u00e7\3\2\2\2\u00f0\u00ee\3\2\2\2\u00f1\u0137\3")
        buf.write("\2\2\2\u00f2\u00f3\f\f\2\2\u00f3\u00f4\7=\2\2\u00f4\u0136")
        buf.write("\5\60\31\r\u00f5\u00f6\f\13\2\2\u00f6\u00f7\t\4\2\2\u00f7")
        buf.write("\u0136\5\60\31\f\u00f8\u00f9\f\n\2\2\u00f9\u00fa\t\5\2")
        buf.write("\2\u00fa\u0136\5\60\31\13\u00fb\u00fc\f\t\2\2\u00fc\u00fe")
        buf.write("\t\6\2\2\u00fd\u00ff\7\37\2\2\u00fe\u00fd\3\2\2\2\u00fe")
        buf.write("\u00ff\3\2\2\2\u00ff\u0100\3\2\2\2\u0100\u0136\5\60\31")
        buf.write("\n\u0101\u0102\f\b\2\2\u0102\u0104\t\7\2\2\u0103\u0105")
        buf.write("\7\37\2\2\u0104\u0103\3\2\2\2\u0104\u0105\3\2\2\2\u0105")
        buf.write("\u0106\3\2\2\2\u0106\u0136\5\60\31\t\u0107\u0108\f\7\2")
        buf.write("\2\u0108\u010a\t\b\2\2\u0109\u010b\7\37\2\2\u010a\u0109")
        buf.write("\3\2\2\2\u010a\u010b\3\2\2\2\u010b\u010c\3\2\2\2\u010c")
        buf.write("\u0136\5\60\31\b\u010d\u010e\f\6\2\2\u010e\u010f\t\t\2")
        buf.write("\2\u010f\u0136\5\60\31\7\u0110\u0111\f\5\2\2\u0111\u0112")
        buf.write("\t\n\2\2\u0112\u0136\5\60\31\6\u0113\u0114\f\26\2\2\u0114")
        buf.write("\u0115\7\32\2\2\u0115\u0116\7C\2\2\u0116\u0117\7\33\2")
        buf.write("\2\u0117\u0118\5,\27\2\u0118\u0119\7\34\2\2\u0119\u0136")
        buf.write("\3\2\2\2\u011a\u011b\f\16\2\2\u011b\u011c\7\35\2\2\u011c")
        buf.write("\u011d\5\60\31\2\u011d\u011e\7\36\2\2\u011e\u0136\3\2")
        buf.write("\2\2\u011f\u0120\f\r\2\2\u0120\u0122\7\35\2\2\u0121\u0123")
        buf.write("\5\60\31\2\u0122\u0121\3\2\2\2\u0122\u0123\3\2\2\2\u0123")
        buf.write("\u0124\3\2\2\2\u0124\u0126\7\37\2\2\u0125\u0127\5\60\31")
        buf.write("\2\u0126\u0125\3\2\2\2\u0126\u0127\3\2\2\2\u0127\u012c")
        buf.write("\3\2\2\2\u0128\u012a\7\37\2\2\u0129\u012b\5\60\31\2\u012a")
        buf.write("\u0129\3\2\2\2\u012a\u012b\3\2\2\2\u012b\u012d\3\2\2\2")
        buf.write("\u012c\u0128\3\2\2\2\u012c\u012d\3\2\2\2\u012d\u012e\3")
        buf.write("\2\2\2\u012e\u0136\7\36\2\2\u012f\u0130\f\4\2\2\u0130")
        buf.write("\u0131\7A\2\2\u0131\u0133\5\60\31\2\u0132\u0134\7\37\2")
        buf.write("\2\u0133\u0132\3\2\2\2\u0133\u0134\3\2\2\2\u0134\u0136")
        buf.write("\3\2\2\2\u0135\u00f2\3\2\2\2\u0135\u00f5\3\2\2\2\u0135")
        buf.write("\u00f8\3\2\2\2\u0135\u00fb\3\2\2\2\u0135\u0101\3\2\2\2")
        buf.write("\u0135\u0107\3\2\2\2\u0135\u010d\3\2\2\2\u0135\u0110\3")
        buf.write("\2\2\2\u0135\u0113\3\2\2\2\u0135\u011a\3\2\2\2\u0135\u011f")
        buf.write("\3\2\2\2\u0135\u012f\3\2\2\2\u0136\u0139\3\2\2\2\u0137")
        buf.write("\u0135\3\2\2\2\u0137\u0138\3\2\2\2\u0138\61\3\2\2\2\u0139")
        buf.write("\u0137\3\2\2\2\u013a\u013b\t\13\2\2\u013b\63\3\2\2\2\u013c")
        buf.write("\u013d\7\67\2\2\u013d\65\3\2\2\2\u013e\u013f\7\67\2\2")
        buf.write("\u013f\u0140\7\32\2\2\u0140\u0141\7\67\2\2\u0141\67\3")
        buf.write("\2\2\2\u0142\u0143\t\f\2\2\u01439\3\2\2\2 ?AHZ^r}\u0088")
        buf.write("\u008c\u0092\u0099\u009d\u00ab\u00af\u00b9\u00bd\u00cb")
        buf.write("\u00ce\u00ee\u00f0\u00fe\u0104\u010a\u0122\u0126\u012a")
        buf.write("\u012c\u0133\u0135\u0137")
        return buf.getvalue()


class wizardParser ( Parser ):

    grammarFileName = "wizard.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'Cancel'", "'Case'", "'Default'", "'For'", 
                     "'from'", "'to'", "'by'", "'If'", "'SelectOne'", "'SelectMany'", 
                     "'While'", "'!'", "'not'", "'|'", "'or'", "'&'", "'and'", 
                     "'False'", "'True'", "'SubPackages'", "<INVALID>", 
                     "<INVALID>", "','", "'.'", "'('", "')'", "'['", "']'", 
                     "':'", "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'Break'", "'Continue'", "'Elif'", "'Else'", 
                     "'EndFor'", "'EndIf'", "'EndSelect'", "'EndWhile'", 
                     "'Return'", "<INVALID>", "<INVALID>", "<INVALID>", 
                     "<INVALID>", "'/'", "'-'", "'+'", "'^'", "'*'", "'%'", 
                     "<INVALID>", "'in'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "COMMENT", "CONTINUATION", "Comma", "Dot", 
                      "LeftParenthesis", "RightParenthesis", "LeftBracket", 
                      "RightBracket", "Colon", "CompoundAdd", "CompoundSub", 
                      "CompoundMul", "CompoundDiv", "CompoundExp", "CompoundMod", 
                      "Equal", "GreaterOrEqual", "Greater", "LesserOrEqual", 
                      "Lesser", "NotEqual", "Assign", "Break", "Continue", 
                      "Elif", "Else", "EndFor", "EndIf", "EndSelect", "EndWhile", 
                      "Return", "Keyword", "Number", "DoubleQuotedString", 
                      "SingleQuotedString", "Divide", "Minus", "Plus", "Raise", 
                      "Times", "Modulo", "Decrement", "In", "Increment", 
                      "Identifier", "WHITESPACE" ]

    RULE_parseWizard = 0
    RULE_body = 1
    RULE_stmt = 2
    RULE_assignment = 3
    RULE_compoundAssignment = 4
    RULE_controlFlowStmt = 5
    RULE_cancelStmt = 6
    RULE_caseStmt = 7
    RULE_defaultStmt = 8
    RULE_elifStmt = 9
    RULE_elseStmt = 10
    RULE_forStmt = 11
    RULE_forRangeHeader = 12
    RULE_forInHeader = 13
    RULE_ifStmt = 14
    RULE_selectStmt = 15
    RULE_selectCaseList = 16
    RULE_optionTuple = 17
    RULE_selectOne = 18
    RULE_selectMany = 19
    RULE_whileStmt = 20
    RULE_argList = 21
    RULE_keywordStmt = 22
    RULE_expr = 23
    RULE_constant = 24
    RULE_integer = 25
    RULE_decimal = 26
    RULE_string = 27

    ruleNames =  [ "parseWizard", "body", "stmt", "assignment", "compoundAssignment", 
                   "controlFlowStmt", "cancelStmt", "caseStmt", "defaultStmt", 
                   "elifStmt", "elseStmt", "forStmt", "forRangeHeader", 
                   "forInHeader", "ifStmt", "selectStmt", "selectCaseList", 
                   "optionTuple", "selectOne", "selectMany", "whileStmt", 
                   "argList", "keywordStmt", "expr", "constant", "integer", 
                   "decimal", "string" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    T__3=4
    T__4=5
    T__5=6
    T__6=7
    T__7=8
    T__8=9
    T__9=10
    T__10=11
    T__11=12
    T__12=13
    T__13=14
    T__14=15
    T__15=16
    T__16=17
    T__17=18
    T__18=19
    T__19=20
    COMMENT=21
    CONTINUATION=22
    Comma=23
    Dot=24
    LeftParenthesis=25
    RightParenthesis=26
    LeftBracket=27
    RightBracket=28
    Colon=29
    CompoundAdd=30
    CompoundSub=31
    CompoundMul=32
    CompoundDiv=33
    CompoundExp=34
    CompoundMod=35
    Equal=36
    GreaterOrEqual=37
    Greater=38
    LesserOrEqual=39
    Lesser=40
    NotEqual=41
    Assign=42
    Break=43
    Continue=44
    Elif=45
    Else=46
    EndFor=47
    EndIf=48
    EndSelect=49
    EndWhile=50
    Return=51
    Keyword=52
    Number=53
    DoubleQuotedString=54
    SingleQuotedString=55
    Divide=56
    Minus=57
    Plus=58
    Raise=59
    Times=60
    Modulo=61
    Decrement=62
    In=63
    Increment=64
    Identifier=65
    WHITESPACE=66

    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 ParseWizardContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


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

        def getRuleIndex(self):
            return wizardParser.RULE_parseWizard

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

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

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




    def parseWizard(self):

        localctx = wizardParser.ParseWizardContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_parseWizard)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 56
            self.body()
            self.state = 57
            self.match(wizardParser.EOF)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BodyContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def stmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(wizardParser.StmtContext)
            else:
                return self.getTypedRuleContext(wizardParser.StmtContext,i)


        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(wizardParser.ExprContext)
            else:
                return self.getTypedRuleContext(wizardParser.ExprContext,i)


        def getRuleIndex(self):
            return wizardParser.RULE_body

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

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

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




    def body(self):

        localctx = wizardParser.BodyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_body)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 63
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << wizardParser.T__0) | (1 << wizardParser.T__3) | (1 << wizardParser.T__7) | (1 << wizardParser.T__8) | (1 << wizardParser.T__9) | (1 << wizardParser.T__10) | (1 << wizardParser.T__11) | (1 << wizardParser.T__12) | (1 << wizardParser.T__17) | (1 << wizardParser.T__18) | (1 << wizardParser.T__19) | (1 << wizardParser.LeftParenthesis) | (1 << wizardParser.Break) | (1 << wizardParser.Continue) | (1 << wizardParser.Return) | (1 << wizardParser.Keyword) | (1 << wizardParser.Number) | (1 << wizardParser.DoubleQuotedString) | (1 << wizardParser.SingleQuotedString) | (1 << wizardParser.Minus) | (1 << wizardParser.Decrement))) != 0) or _la==wizardParser.Increment or _la==wizardParser.Identifier:
                self.state = 61
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,0,self._ctx)
                if la_ == 1:
                    self.state = 59
                    self.stmt()
                    pass

                elif la_ == 2:
                    self.state = 60
                    self.expr(0)
                    pass


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

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

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


        def compoundAssignment(self):
            return self.getTypedRuleContext(wizardParser.CompoundAssignmentContext,0)


        def controlFlowStmt(self):
            return self.getTypedRuleContext(wizardParser.ControlFlowStmtContext,0)


        def keywordStmt(self):
            return self.getTypedRuleContext(wizardParser.KeywordStmtContext,0)


        def getRuleIndex(self):
            return wizardParser.RULE_stmt

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

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

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




    def stmt(self):

        localctx = wizardParser.StmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_stmt)
        try:
            self.state = 70
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,2,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 66
                self.assignment()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 67
                self.compoundAssignment()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 68
                self.controlFlowStmt()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 69
                self.keywordStmt()
                pass


        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 Identifier(self):
            return self.getToken(wizardParser.Identifier, 0)

        def Assign(self):
            return self.getToken(wizardParser.Assign, 0)

        def expr(self):
            return self.getTypedRuleContext(wizardParser.ExprContext,0)


        def getRuleIndex(self):
            return wizardParser.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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitAssignment" ):
                return visitor.visitAssignment(self)
            else:
                return visitor.visitChildren(self)




    def assignment(self):

        localctx = wizardParser.AssignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_assignment)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 72
            self.match(wizardParser.Identifier)
            self.state = 73
            self.match(wizardParser.Assign)
            self.state = 74
            self.expr(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class CompoundAssignmentContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Identifier(self):
            return self.getToken(wizardParser.Identifier, 0)

        def expr(self):
            return self.getTypedRuleContext(wizardParser.ExprContext,0)


        def CompoundExp(self):
            return self.getToken(wizardParser.CompoundExp, 0)

        def CompoundMul(self):
            return self.getToken(wizardParser.CompoundMul, 0)

        def CompoundDiv(self):
            return self.getToken(wizardParser.CompoundDiv, 0)

        def CompoundMod(self):
            return self.getToken(wizardParser.CompoundMod, 0)

        def CompoundAdd(self):
            return self.getToken(wizardParser.CompoundAdd, 0)

        def CompoundSub(self):
            return self.getToken(wizardParser.CompoundSub, 0)

        def getRuleIndex(self):
            return wizardParser.RULE_compoundAssignment

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

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

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




    def compoundAssignment(self):

        localctx = wizardParser.CompoundAssignmentContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_compoundAssignment)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 76
            self.match(wizardParser.Identifier)
            self.state = 77
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << wizardParser.CompoundAdd) | (1 << wizardParser.CompoundSub) | (1 << wizardParser.CompoundMul) | (1 << wizardParser.CompoundDiv) | (1 << wizardParser.CompoundExp) | (1 << wizardParser.CompoundMod))) != 0)):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 78
            self.expr(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ControlFlowStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return wizardParser.RULE_controlFlowStmt

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)



    class ReturnContext(ControlFlowStmtContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a wizardParser.ControlFlowStmtContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def Return(self):
            return self.getToken(wizardParser.Return, 0)

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

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

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


    class CancelContext(ControlFlowStmtContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a wizardParser.ControlFlowStmtContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def cancelStmt(self):
            return self.getTypedRuleContext(wizardParser.CancelStmtContext,0)


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

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

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


    class BreakContext(ControlFlowStmtContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a wizardParser.ControlFlowStmtContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def Break(self):
            return self.getToken(wizardParser.Break, 0)

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

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

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


    class ForContext(ControlFlowStmtContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a wizardParser.ControlFlowStmtContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def forStmt(self):
            return self.getTypedRuleContext(wizardParser.ForStmtContext,0)


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

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

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


    class SelectContext(ControlFlowStmtContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a wizardParser.ControlFlowStmtContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def selectStmt(self):
            return self.getTypedRuleContext(wizardParser.SelectStmtContext,0)


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

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

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


    class WhileContext(ControlFlowStmtContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a wizardParser.ControlFlowStmtContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def whileStmt(self):
            return self.getTypedRuleContext(wizardParser.WhileStmtContext,0)


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

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

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


    class ContinueContext(ControlFlowStmtContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a wizardParser.ControlFlowStmtContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def Continue(self):
            return self.getToken(wizardParser.Continue, 0)

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

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

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


    class IfContext(ControlFlowStmtContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a wizardParser.ControlFlowStmtContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def ifStmt(self):
            return self.getTypedRuleContext(wizardParser.IfStmtContext,0)


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

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

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



    def controlFlowStmt(self):

        localctx = wizardParser.ControlFlowStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_controlFlowStmt)
        try:
            self.state = 88
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [wizardParser.Break]:
                localctx = wizardParser.BreakContext(self, localctx)
                self.enterOuterAlt(localctx, 1)
                self.state = 80
                self.match(wizardParser.Break)
                pass
            elif token in [wizardParser.T__0]:
                localctx = wizardParser.CancelContext(self, localctx)
                self.enterOuterAlt(localctx, 2)
                self.state = 81
                self.cancelStmt()
                pass
            elif token in [wizardParser.Continue]:
                localctx = wizardParser.ContinueContext(self, localctx)
                self.enterOuterAlt(localctx, 3)
                self.state = 82
                self.match(wizardParser.Continue)
                pass
            elif token in [wizardParser.T__3]:
                localctx = wizardParser.ForContext(self, localctx)
                self.enterOuterAlt(localctx, 4)
                self.state = 83
                self.forStmt()
                pass
            elif token in [wizardParser.T__7]:
                localctx = wizardParser.IfContext(self, localctx)
                self.enterOuterAlt(localctx, 5)
                self.state = 84
                self.ifStmt()
                pass
            elif token in [wizardParser.Return]:
                localctx = wizardParser.ReturnContext(self, localctx)
                self.enterOuterAlt(localctx, 6)
                self.state = 85
                self.match(wizardParser.Return)
                pass
            elif token in [wizardParser.T__8, wizardParser.T__9]:
                localctx = wizardParser.SelectContext(self, localctx)
                self.enterOuterAlt(localctx, 7)
                self.state = 86
                self.selectStmt()
                pass
            elif token in [wizardParser.T__10]:
                localctx = wizardParser.WhileContext(self, localctx)
                self.enterOuterAlt(localctx, 8)
                self.state = 87
                self.whileStmt()
                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 CancelStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expr(self):
            return self.getTypedRuleContext(wizardParser.ExprContext,0)


        def getRuleIndex(self):
            return wizardParser.RULE_cancelStmt

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

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

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




    def cancelStmt(self):

        localctx = wizardParser.CancelStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_cancelStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 90
            self.match(wizardParser.T__0)
            self.state = 92
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,4,self._ctx)
            if la_ == 1:
                self.state = 91
                self.expr(0)


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


    class CaseStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expr(self):
            return self.getTypedRuleContext(wizardParser.ExprContext,0)


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


        def getRuleIndex(self):
            return wizardParser.RULE_caseStmt

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

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

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




    def caseStmt(self):

        localctx = wizardParser.CaseStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_caseStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 94
            self.match(wizardParser.T__1)
            self.state = 95
            self.expr(0)
            self.state = 96
            self.body()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DefaultStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

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


        def getRuleIndex(self):
            return wizardParser.RULE_defaultStmt

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

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

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




    def defaultStmt(self):

        localctx = wizardParser.DefaultStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_defaultStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 98
            self.match(wizardParser.T__2)
            self.state = 99
            self.body()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ElifStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Elif(self):
            return self.getToken(wizardParser.Elif, 0)

        def expr(self):
            return self.getTypedRuleContext(wizardParser.ExprContext,0)


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


        def getRuleIndex(self):
            return wizardParser.RULE_elifStmt

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

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

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




    def elifStmt(self):

        localctx = wizardParser.ElifStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_elifStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 101
            self.match(wizardParser.Elif)
            self.state = 102
            self.expr(0)
            self.state = 103
            self.body()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ElseStmtContext(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(wizardParser.Else, 0)

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


        def getRuleIndex(self):
            return wizardParser.RULE_elseStmt

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

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

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




    def elseStmt(self):

        localctx = wizardParser.ElseStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_elseStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 105
            self.match(wizardParser.Else)
            self.state = 106
            self.body()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ForStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Identifier(self):
            return self.getToken(wizardParser.Identifier, 0)

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


        def EndFor(self):
            return self.getToken(wizardParser.EndFor, 0)

        def forRangeHeader(self):
            return self.getTypedRuleContext(wizardParser.ForRangeHeaderContext,0)


        def forInHeader(self):
            return self.getTypedRuleContext(wizardParser.ForInHeaderContext,0)


        def getRuleIndex(self):
            return wizardParser.RULE_forStmt

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

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

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




    def forStmt(self):

        localctx = wizardParser.ForStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_forStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 108
            self.match(wizardParser.T__3)
            self.state = 109
            self.match(wizardParser.Identifier)
            self.state = 112
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [wizardParser.T__4]:
                self.state = 110
                self.forRangeHeader()
                pass
            elif token in [wizardParser.In]:
                self.state = 111
                self.forInHeader()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 114
            self.body()
            self.state = 115
            self.match(wizardParser.EndFor)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ForRangeHeaderContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(wizardParser.ExprContext)
            else:
                return self.getTypedRuleContext(wizardParser.ExprContext,i)


        def getRuleIndex(self):
            return wizardParser.RULE_forRangeHeader

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

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

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




    def forRangeHeader(self):

        localctx = wizardParser.ForRangeHeaderContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_forRangeHeader)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 117
            self.match(wizardParser.T__4)
            self.state = 118
            self.expr(0)
            self.state = 119
            self.match(wizardParser.T__5)
            self.state = 120
            self.expr(0)
            self.state = 123
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==wizardParser.T__6:
                self.state = 121
                self.match(wizardParser.T__6)
                self.state = 122
                self.expr(0)


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


    class ForInHeaderContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def In(self):
            return self.getToken(wizardParser.In, 0)

        def expr(self):
            return self.getTypedRuleContext(wizardParser.ExprContext,0)


        def getRuleIndex(self):
            return wizardParser.RULE_forInHeader

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

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

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




    def forInHeader(self):

        localctx = wizardParser.ForInHeaderContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_forInHeader)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 125
            self.match(wizardParser.In)
            self.state = 126
            self.expr(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class IfStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expr(self):
            return self.getTypedRuleContext(wizardParser.ExprContext,0)


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


        def EndIf(self):
            return self.getToken(wizardParser.EndIf, 0)

        def elifStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(wizardParser.ElifStmtContext)
            else:
                return self.getTypedRuleContext(wizardParser.ElifStmtContext,i)


        def elseStmt(self):
            return self.getTypedRuleContext(wizardParser.ElseStmtContext,0)


        def getRuleIndex(self):
            return wizardParser.RULE_ifStmt

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

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

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




    def ifStmt(self):

        localctx = wizardParser.IfStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_ifStmt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 128
            self.match(wizardParser.T__7)
            self.state = 129
            self.expr(0)
            self.state = 130
            self.body()
            self.state = 134
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==wizardParser.Elif:
                self.state = 131
                self.elifStmt()
                self.state = 136
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 138
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==wizardParser.Else:
                self.state = 137
                self.elseStmt()


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


    class SelectStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def EndSelect(self):
            return self.getToken(wizardParser.EndSelect, 0)

        def selectOne(self):
            return self.getTypedRuleContext(wizardParser.SelectOneContext,0)


        def selectMany(self):
            return self.getTypedRuleContext(wizardParser.SelectManyContext,0)


        def getRuleIndex(self):
            return wizardParser.RULE_selectStmt

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

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

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




    def selectStmt(self):

        localctx = wizardParser.SelectStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_selectStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 144
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [wizardParser.T__8]:
                self.state = 142
                self.selectOne()
                pass
            elif token in [wizardParser.T__9]:
                self.state = 143
                self.selectMany()
                pass
            else:
                raise NoViableAltException(self)

            self.state = 146
            self.match(wizardParser.EndSelect)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SelectCaseListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def caseStmt(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(wizardParser.CaseStmtContext)
            else:
                return self.getTypedRuleContext(wizardParser.CaseStmtContext,i)


        def defaultStmt(self):
            return self.getTypedRuleContext(wizardParser.DefaultStmtContext,0)


        def getRuleIndex(self):
            return wizardParser.RULE_selectCaseList

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

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

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




    def selectCaseList(self):

        localctx = wizardParser.SelectCaseListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_selectCaseList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 151
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==wizardParser.T__1:
                self.state = 148
                self.caseStmt()
                self.state = 153
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 155
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==wizardParser.T__2:
                self.state = 154
                self.defaultStmt()


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


    class OptionTupleContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(wizardParser.ExprContext)
            else:
                return self.getTypedRuleContext(wizardParser.ExprContext,i)


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

        def getRuleIndex(self):
            return wizardParser.RULE_optionTuple

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

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

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




    def optionTuple(self):

        localctx = wizardParser.OptionTupleContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_optionTuple)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 157
            self.expr(0)
            self.state = 158
            self.match(wizardParser.Comma)
            self.state = 159
            self.expr(0)
            self.state = 160
            self.match(wizardParser.Comma)
            self.state = 161
            self.expr(0)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SelectOneContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expr(self):
            return self.getTypedRuleContext(wizardParser.ExprContext,0)


        def selectCaseList(self):
            return self.getTypedRuleContext(wizardParser.SelectCaseListContext,0)


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

        def optionTuple(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(wizardParser.OptionTupleContext)
            else:
                return self.getTypedRuleContext(wizardParser.OptionTupleContext,i)


        def getRuleIndex(self):
            return wizardParser.RULE_selectOne

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

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

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




    def selectOne(self):

        localctx = wizardParser.SelectOneContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_selectOne)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 163
            self.match(wizardParser.T__8)
            self.state = 164
            self.expr(0)
            self.state = 169
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,12,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 165
                    self.match(wizardParser.Comma)
                    self.state = 166
                    self.optionTuple() 
                self.state = 171
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,12,self._ctx)

            self.state = 173
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==wizardParser.Comma:
                self.state = 172
                self.match(wizardParser.Comma)


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


    class SelectManyContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expr(self):
            return self.getTypedRuleContext(wizardParser.ExprContext,0)


        def selectCaseList(self):
            return self.getTypedRuleContext(wizardParser.SelectCaseListContext,0)


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

        def optionTuple(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(wizardParser.OptionTupleContext)
            else:
                return self.getTypedRuleContext(wizardParser.OptionTupleContext,i)


        def getRuleIndex(self):
            return wizardParser.RULE_selectMany

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

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

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




    def selectMany(self):

        localctx = wizardParser.SelectManyContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_selectMany)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 177
            self.match(wizardParser.T__9)
            self.state = 178
            self.expr(0)
            self.state = 183
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,14,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 179
                    self.match(wizardParser.Comma)
                    self.state = 180
                    self.optionTuple() 
                self.state = 185
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,14,self._ctx)

            self.state = 187
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==wizardParser.Comma:
                self.state = 186
                self.match(wizardParser.Comma)


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


    class WhileStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expr(self):
            return self.getTypedRuleContext(wizardParser.ExprContext,0)


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


        def EndWhile(self):
            return self.getToken(wizardParser.EndWhile, 0)

        def getRuleIndex(self):
            return wizardParser.RULE_whileStmt

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

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

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




    def whileStmt(self):

        localctx = wizardParser.WhileStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_whileStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 191
            self.match(wizardParser.T__10)
            self.state = 192
            self.expr(0)
            self.state = 193
            self.body()
            self.state = 194
            self.match(wizardParser.EndWhile)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ArgListContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(wizardParser.ExprContext)
            else:
                return self.getTypedRuleContext(wizardParser.ExprContext,i)


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

        def getRuleIndex(self):
            return wizardParser.RULE_argList

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

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

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




    def argList(self):

        localctx = wizardParser.ArgListContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_argList)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 204
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,17,self._ctx)
            if la_ == 1:
                self.state = 196
                self.expr(0)
                self.state = 201
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==wizardParser.Comma:
                    self.state = 197
                    self.match(wizardParser.Comma)
                    self.state = 198
                    self.expr(0)
                    self.state = 203
                    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 KeywordStmtContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Keyword(self):
            return self.getToken(wizardParser.Keyword, 0)

        def argList(self):
            return self.getTypedRuleContext(wizardParser.ArgListContext,0)


        def getRuleIndex(self):
            return wizardParser.RULE_keywordStmt

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

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

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




    def keywordStmt(self):

        localctx = wizardParser.KeywordStmtContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_keywordStmt)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 206
            self.match(wizardParser.Keyword)
            self.state = 207
            self.argList()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class ExprContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return wizardParser.RULE_expr

     
        def copyFrom(self, ctx:ParserRuleContext):
            super().copyFrom(ctx)


    class PreIncrementContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a wizardParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def Increment(self):
            return self.getToken(wizardParser.Increment, 0)
        def Identifier(self):
            return self.getToken(wizardParser.Identifier, 0)

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

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

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


    class DotFunctionCallContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a wizardParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expr(self):
            return self.getTypedRuleContext(wizardParser.ExprContext,0)

        def Dot(self):
            return self.getToken(wizardParser.Dot, 0)
        def Identifier(self):
            return self.getToken(wizardParser.Identifier, 0)
        def LeftParenthesis(self):
            return self.getToken(wizardParser.LeftParenthesis, 0)
        def argList(self):
            return self.getTypedRuleContext(wizardParser.ArgListContext,0)

        def RightParenthesis(self):
            return self.getToken(wizardParser.RightParenthesis, 0)

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

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

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


    class OrContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a wizardParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(wizardParser.ExprContext)
            else:
                return self.getTypedRuleContext(wizardParser.ExprContext,i)


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

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

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


    class InContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a wizardParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(wizardParser.ExprContext)
            else:
                return self.getTypedRuleContext(wizardParser.ExprContext,i)

        def In(self):
            return self.getToken(wizardParser.In, 0)
        def Colon(self):
            return self.getToken(wizardParser.Colon, 0)

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

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

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


    class PostDecrementContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a wizardParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def Identifier(self):
            return self.getToken(wizardParser.Identifier, 0)
        def Decrement(self):
            return self.getToken(wizardParser.Decrement, 0)

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

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

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


    class TimesDivideModuloContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a wizardParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(wizardParser.ExprContext)
            else:
                return self.getTypedRuleContext(wizardParser.ExprContext,i)

        def Times(self):
            return self.getToken(wizardParser.Times, 0)
        def Divide(self):
            return self.getToken(wizardParser.Divide, 0)
        def Modulo(self):
            return self.getToken(wizardParser.Modulo, 0)

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

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

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


    class IndexContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a wizardParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(wizardParser.ExprContext)
            else:
                return self.getTypedRuleContext(wizardParser.ExprContext,i)

        def LeftBracket(self):
            return self.getToken(wizardParser.LeftBracket, 0)
        def RightBracket(self):
            return self.getToken(wizardParser.RightBracket, 0)

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

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

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


    class ExponentiationContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a wizardParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(wizardParser.ExprContext)
            else:
                return self.getTypedRuleContext(wizardParser.ExprContext,i)

        def Raise(self):
            return self.getToken(wizardParser.Raise, 0)

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

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

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


    class PlusMinusContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a wizardParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(wizardParser.ExprContext)
            else:
                return self.getTypedRuleContext(wizardParser.ExprContext,i)

        def Plus(self):
            return self.getToken(wizardParser.Plus, 0)
        def Minus(self):
            return self.getToken(wizardParser.Minus, 0)

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

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

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


    class NotContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a wizardParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expr(self):
            return self.getTypedRuleContext(wizardParser.ExprContext,0)


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

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

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


    class LesserContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a wizardParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(wizardParser.ExprContext)
            else:
                return self.getTypedRuleContext(wizardParser.ExprContext,i)

        def Lesser(self):
            return self.getToken(wizardParser.Lesser, 0)
        def LesserOrEqual(self):
            return self.getToken(wizardParser.LesserOrEqual, 0)
        def Colon(self):
            return self.getToken(wizardParser.Colon, 0)

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

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

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


    class NegativeContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a wizardParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def Minus(self):
            return self.getToken(wizardParser.Minus, 0)
        def expr(self):
            return self.getTypedRuleContext(wizardParser.ExprContext,0)


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

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

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


    class EqualContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a wizardParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(wizardParser.ExprContext)
            else:
                return self.getTypedRuleContext(wizardParser.ExprContext,i)

        def Equal(self):
            return self.getToken(wizardParser.Equal, 0)
        def NotEqual(self):
            return self.getToken(wizardParser.NotEqual, 0)
        def Colon(self):
            return self.getToken(wizardParser.Colon, 0)

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

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

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


    class AndContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a wizardParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(wizardParser.ExprContext)
            else:
                return self.getTypedRuleContext(wizardParser.ExprContext,i)


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

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

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


    class SliceContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a wizardParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(wizardParser.ExprContext)
            else:
                return self.getTypedRuleContext(wizardParser.ExprContext,i)

        def LeftBracket(self):
            return self.getToken(wizardParser.LeftBracket, 0)
        def Colon(self, i:int=None):
            if i is None:
                return self.getTokens(wizardParser.Colon)
            else:
                return self.getToken(wizardParser.Colon, i)
        def RightBracket(self):
            return self.getToken(wizardParser.RightBracket, 0)

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

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

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


    class ValueContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a wizardParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def constant(self):
            return self.getTypedRuleContext(wizardParser.ConstantContext,0)

        def decimal(self):
            return self.getTypedRuleContext(wizardParser.DecimalContext,0)

        def integer(self):
            return self.getTypedRuleContext(wizardParser.IntegerContext,0)

        def string(self):
            return self.getTypedRuleContext(wizardParser.StringContext,0)

        def Identifier(self):
            return self.getToken(wizardParser.Identifier, 0)

        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 accept(self, visitor:ParseTreeVisitor):
            if hasattr( visitor, "visitValue" ):
                return visitor.visitValue(self)
            else:
                return visitor.visitChildren(self)


    class GreaterContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a wizardParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def expr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(wizardParser.ExprContext)
            else:
                return self.getTypedRuleContext(wizardParser.ExprContext,i)

        def Greater(self):
            return self.getToken(wizardParser.Greater, 0)
        def GreaterOrEqual(self):
            return self.getToken(wizardParser.GreaterOrEqual, 0)
        def Colon(self):
            return self.getToken(wizardParser.Colon, 0)

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

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

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


    class FunctionCallContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a wizardParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def Identifier(self):
            return self.getToken(wizardParser.Identifier, 0)
        def LeftParenthesis(self):
            return self.getToken(wizardParser.LeftParenthesis, 0)
        def argList(self):
            return self.getTypedRuleContext(wizardParser.ArgListContext,0)

        def RightParenthesis(self):
            return self.getToken(wizardParser.RightParenthesis, 0)

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

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

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


    class PostIncrementContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a wizardParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def Identifier(self):
            return self.getToken(wizardParser.Identifier, 0)
        def Increment(self):
            return self.getToken(wizardParser.Increment, 0)

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

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

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


    class ParenExprContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a wizardParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def LeftParenthesis(self):
            return self.getToken(wizardParser.LeftParenthesis, 0)
        def expr(self):
            return self.getTypedRuleContext(wizardParser.ExprContext,0)

        def RightParenthesis(self):
            return self.getToken(wizardParser.RightParenthesis, 0)

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

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

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


    class PreDecrementContext(ExprContext):

        def __init__(self, parser, ctx:ParserRuleContext): # actually a wizardParser.ExprContext
            super().__init__(parser)
            self.copyFrom(ctx)

        def Decrement(self):
            return self.getToken(wizardParser.Decrement, 0)
        def Identifier(self):
            return self.getToken(wizardParser.Identifier, 0)

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

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

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



    def expr(self, _p:int=0):
        _parentctx = self._ctx
        _parentState = self.state
        localctx = wizardParser.ExprContext(self, self._ctx, _parentState)
        _prevctx = localctx
        _startState = 46
        self.enterRecursionRule(localctx, 46, self.RULE_expr, _p)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 238
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,19,self._ctx)
            if la_ == 1:
                localctx = wizardParser.ParenExprContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx

                self.state = 210
                self.match(wizardParser.LeftParenthesis)
                self.state = 211
                self.expr(0)
                self.state = 212
                self.match(wizardParser.RightParenthesis)
                pass

            elif la_ == 2:
                localctx = wizardParser.FunctionCallContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 214
                self.match(wizardParser.Identifier)
                self.state = 215
                self.match(wizardParser.LeftParenthesis)
                self.state = 216
                self.argList()
                self.state = 217
                self.match(wizardParser.RightParenthesis)
                pass

            elif la_ == 3:
                localctx = wizardParser.PreIncrementContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 219
                self.match(wizardParser.Increment)
                self.state = 220
                self.match(wizardParser.Identifier)
                pass

            elif la_ == 4:
                localctx = wizardParser.PostIncrementContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 221
                self.match(wizardParser.Identifier)
                self.state = 222
                self.match(wizardParser.Increment)
                pass

            elif la_ == 5:
                localctx = wizardParser.PreDecrementContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 223
                self.match(wizardParser.Decrement)
                self.state = 224
                self.match(wizardParser.Identifier)
                pass

            elif la_ == 6:
                localctx = wizardParser.PostDecrementContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 225
                self.match(wizardParser.Identifier)
                self.state = 226
                self.match(wizardParser.Decrement)
                pass

            elif la_ == 7:
                localctx = wizardParser.NegativeContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 227
                self.match(wizardParser.Minus)
                self.state = 228
                self.expr(14)
                pass

            elif la_ == 8:
                localctx = wizardParser.NotContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 229
                _la = self._input.LA(1)
                if not(_la==wizardParser.T__11 or _la==wizardParser.T__12):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()
                self.state = 230
                self.expr(13)
                pass

            elif la_ == 9:
                localctx = wizardParser.ValueContext(self, localctx)
                self._ctx = localctx
                _prevctx = localctx
                self.state = 236
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,18,self._ctx)
                if la_ == 1:
                    self.state = 231
                    self.constant()
                    pass

                elif la_ == 2:
                    self.state = 232
                    self.decimal()
                    pass

                elif la_ == 3:
                    self.state = 233
                    self.integer()
                    pass

                elif la_ == 4:
                    self.state = 234
                    self.string()
                    pass

                elif la_ == 5:
                    self.state = 235
                    self.match(wizardParser.Identifier)
                    pass


                pass


            self._ctx.stop = self._input.LT(-1)
            self.state = 309
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,29,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    if self._parseListeners is not None:
                        self.triggerExitRuleEvent()
                    _prevctx = localctx
                    self.state = 307
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,28,self._ctx)
                    if la_ == 1:
                        localctx = wizardParser.ExponentiationContext(self, wizardParser.ExprContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 240
                        if not self.precpred(self._ctx, 10):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 10)")
                        self.state = 241
                        self.match(wizardParser.Raise)
                        self.state = 242
                        self.expr(11)
                        pass

                    elif la_ == 2:
                        localctx = wizardParser.TimesDivideModuloContext(self, wizardParser.ExprContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 243
                        if not self.precpred(self._ctx, 9):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 9)")
                        self.state = 244
                        _la = self._input.LA(1)
                        if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << wizardParser.Divide) | (1 << wizardParser.Times) | (1 << wizardParser.Modulo))) != 0)):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 245
                        self.expr(10)
                        pass

                    elif la_ == 3:
                        localctx = wizardParser.PlusMinusContext(self, wizardParser.ExprContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 246
                        if not self.precpred(self._ctx, 8):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
                        self.state = 247
                        _la = self._input.LA(1)
                        if not(_la==wizardParser.Minus or _la==wizardParser.Plus):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 248
                        self.expr(9)
                        pass

                    elif la_ == 4:
                        localctx = wizardParser.GreaterContext(self, wizardParser.ExprContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 249
                        if not self.precpred(self._ctx, 7):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 7)")
                        self.state = 250
                        _la = self._input.LA(1)
                        if not(_la==wizardParser.GreaterOrEqual or _la==wizardParser.Greater):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 252
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==wizardParser.Colon:
                            self.state = 251
                            self.match(wizardParser.Colon)


                        self.state = 254
                        self.expr(8)
                        pass

                    elif la_ == 5:
                        localctx = wizardParser.LesserContext(self, wizardParser.ExprContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 255
                        if not self.precpred(self._ctx, 6):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
                        self.state = 256
                        _la = self._input.LA(1)
                        if not(_la==wizardParser.LesserOrEqual or _la==wizardParser.Lesser):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 258
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==wizardParser.Colon:
                            self.state = 257
                            self.match(wizardParser.Colon)


                        self.state = 260
                        self.expr(7)
                        pass

                    elif la_ == 6:
                        localctx = wizardParser.EqualContext(self, wizardParser.ExprContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 261
                        if not self.precpred(self._ctx, 5):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
                        self.state = 262
                        _la = self._input.LA(1)
                        if not(_la==wizardParser.Equal or _la==wizardParser.NotEqual):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 264
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==wizardParser.Colon:
                            self.state = 263
                            self.match(wizardParser.Colon)


                        self.state = 266
                        self.expr(6)
                        pass

                    elif la_ == 7:
                        localctx = wizardParser.OrContext(self, wizardParser.ExprContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 267
                        if not self.precpred(self._ctx, 4):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
                        self.state = 268
                        _la = self._input.LA(1)
                        if not(_la==wizardParser.T__13 or _la==wizardParser.T__14):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 269
                        self.expr(5)
                        pass

                    elif la_ == 8:
                        localctx = wizardParser.AndContext(self, wizardParser.ExprContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 270
                        if not self.precpred(self._ctx, 3):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 3)")
                        self.state = 271
                        _la = self._input.LA(1)
                        if not(_la==wizardParser.T__15 or _la==wizardParser.T__16):
                            self._errHandler.recoverInline(self)
                        else:
                            self._errHandler.reportMatch(self)
                            self.consume()
                        self.state = 272
                        self.expr(4)
                        pass

                    elif la_ == 9:
                        localctx = wizardParser.DotFunctionCallContext(self, wizardParser.ExprContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 273
                        if not self.precpred(self._ctx, 20):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 20)")
                        self.state = 274
                        self.match(wizardParser.Dot)
                        self.state = 275
                        self.match(wizardParser.Identifier)
                        self.state = 276
                        self.match(wizardParser.LeftParenthesis)
                        self.state = 277
                        self.argList()
                        self.state = 278
                        self.match(wizardParser.RightParenthesis)
                        pass

                    elif la_ == 10:
                        localctx = wizardParser.IndexContext(self, wizardParser.ExprContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 280
                        if not self.precpred(self._ctx, 12):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 12)")
                        self.state = 281
                        self.match(wizardParser.LeftBracket)
                        self.state = 282
                        self.expr(0)
                        self.state = 283
                        self.match(wizardParser.RightBracket)
                        pass

                    elif la_ == 11:
                        localctx = wizardParser.SliceContext(self, wizardParser.ExprContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 285
                        if not self.precpred(self._ctx, 11):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 11)")
                        self.state = 286
                        self.match(wizardParser.LeftBracket)
                        self.state = 288
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if ((((_la - 12)) & ~0x3f) == 0 and ((1 << (_la - 12)) & ((1 << (wizardParser.T__11 - 12)) | (1 << (wizardParser.T__12 - 12)) | (1 << (wizardParser.T__17 - 12)) | (1 << (wizardParser.T__18 - 12)) | (1 << (wizardParser.T__19 - 12)) | (1 << (wizardParser.LeftParenthesis - 12)) | (1 << (wizardParser.Number - 12)) | (1 << (wizardParser.DoubleQuotedString - 12)) | (1 << (wizardParser.SingleQuotedString - 12)) | (1 << (wizardParser.Minus - 12)) | (1 << (wizardParser.Decrement - 12)) | (1 << (wizardParser.Increment - 12)) | (1 << (wizardParser.Identifier - 12)))) != 0):
                            self.state = 287
                            self.expr(0)


                        self.state = 290
                        self.match(wizardParser.Colon)
                        self.state = 292
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if ((((_la - 12)) & ~0x3f) == 0 and ((1 << (_la - 12)) & ((1 << (wizardParser.T__11 - 12)) | (1 << (wizardParser.T__12 - 12)) | (1 << (wizardParser.T__17 - 12)) | (1 << (wizardParser.T__18 - 12)) | (1 << (wizardParser.T__19 - 12)) | (1 << (wizardParser.LeftParenthesis - 12)) | (1 << (wizardParser.Number - 12)) | (1 << (wizardParser.DoubleQuotedString - 12)) | (1 << (wizardParser.SingleQuotedString - 12)) | (1 << (wizardParser.Minus - 12)) | (1 << (wizardParser.Decrement - 12)) | (1 << (wizardParser.Increment - 12)) | (1 << (wizardParser.Identifier - 12)))) != 0):
                            self.state = 291
                            self.expr(0)


                        self.state = 298
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if _la==wizardParser.Colon:
                            self.state = 294
                            self.match(wizardParser.Colon)
                            self.state = 296
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)
                            if ((((_la - 12)) & ~0x3f) == 0 and ((1 << (_la - 12)) & ((1 << (wizardParser.T__11 - 12)) | (1 << (wizardParser.T__12 - 12)) | (1 << (wizardParser.T__17 - 12)) | (1 << (wizardParser.T__18 - 12)) | (1 << (wizardParser.T__19 - 12)) | (1 << (wizardParser.LeftParenthesis - 12)) | (1 << (wizardParser.Number - 12)) | (1 << (wizardParser.DoubleQuotedString - 12)) | (1 << (wizardParser.SingleQuotedString - 12)) | (1 << (wizardParser.Minus - 12)) | (1 << (wizardParser.Decrement - 12)) | (1 << (wizardParser.Increment - 12)) | (1 << (wizardParser.Identifier - 12)))) != 0):
                                self.state = 295
                                self.expr(0)




                        self.state = 300
                        self.match(wizardParser.RightBracket)
                        pass

                    elif la_ == 12:
                        localctx = wizardParser.InContext(self, wizardParser.ExprContext(self, _parentctx, _parentState))
                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
                        self.state = 301
                        if not self.precpred(self._ctx, 2):
                            from antlr4.error.Errors import FailedPredicateException
                            raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
                        self.state = 302
                        self.match(wizardParser.In)
                        self.state = 303
                        self.expr(0)
                        self.state = 305
                        self._errHandler.sync(self)
                        la_ = self._interp.adaptivePredict(self._input,27,self._ctx)
                        if la_ == 1:
                            self.state = 304
                            self.match(wizardParser.Colon)


                        pass

             
                self.state = 311
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,29,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 ConstantContext(ParserRuleContext):
        __slots__ = 'parser'

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


        def getRuleIndex(self):
            return wizardParser.RULE_constant

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

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

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




    def constant(self):

        localctx = wizardParser.ConstantContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_constant)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 312
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << wizardParser.T__17) | (1 << wizardParser.T__18) | (1 << wizardParser.T__19))) != 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 IntegerContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def Number(self):
            return self.getToken(wizardParser.Number, 0)

        def getRuleIndex(self):
            return wizardParser.RULE_integer

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

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

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




    def integer(self):

        localctx = wizardParser.IntegerContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_integer)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 314
            self.match(wizardParser.Number)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DecimalContext(ParserRuleContext):
        __slots__ = 'parser'

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

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

        def Dot(self):
            return self.getToken(wizardParser.Dot, 0)

        def getRuleIndex(self):
            return wizardParser.RULE_decimal

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

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

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




    def decimal(self):

        localctx = wizardParser.DecimalContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_decimal)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 316
            self.match(wizardParser.Number)
            self.state = 317
            self.match(wizardParser.Dot)
            self.state = 318
            self.match(wizardParser.Number)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class StringContext(ParserRuleContext):
        __slots__ = 'parser'

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

        def DoubleQuotedString(self):
            return self.getToken(wizardParser.DoubleQuotedString, 0)

        def SingleQuotedString(self):
            return self.getToken(wizardParser.SingleQuotedString, 0)

        def getRuleIndex(self):
            return wizardParser.RULE_string

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

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

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




    def string(self):

        localctx = wizardParser.StringContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_string)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 320
            _la = self._input.LA(1)
            if not(_la==wizardParser.DoubleQuotedString or _la==wizardParser.SingleQuotedString):
                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[23] = self.expr_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 expr_sempred(self, localctx:ExprContext, predIndex:int):
            if predIndex == 0:
                return self.precpred(self._ctx, 10)
         

            if predIndex == 1:
                return self.precpred(self._ctx, 9)
         

            if predIndex == 2:
                return self.precpred(self._ctx, 8)
         

            if predIndex == 3:
                return self.precpred(self._ctx, 7)
         

            if predIndex == 4:
                return self.precpred(self._ctx, 6)
         

            if predIndex == 5:
                return self.precpred(self._ctx, 5)
         

            if predIndex == 6:
                return self.precpred(self._ctx, 4)
         

            if predIndex == 7:
                return self.precpred(self._ctx, 3)
         

            if predIndex == 8:
                return self.precpred(self._ctx, 20)
         

            if predIndex == 9:
                return self.precpred(self._ctx, 12)
         

            if predIndex == 10:
                return self.precpred(self._ctx, 11)
         

            if predIndex == 11:
                return self.precpred(self._ctx, 2)
         




