# Generated from ./dateparse_utils.g4 by ANTLR 4.9
# 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\3e")
        buf.write("\u02b0\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
        buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
        buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
        buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
        buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
        buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t")
        buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.\t.\4")
        buf.write("/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t\64")
        buf.write("\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\3\2\7\2r\n\2\f\2")
        buf.write("\16\2u\13\2\3\2\3\2\7\2y\n\2\f\2\16\2|\13\2\3\2\3\2\7")
        buf.write("\2\u0080\n\2\f\2\16\2\u0083\13\2\3\2\3\2\7\2\u0087\n\2")
        buf.write("\f\2\16\2\u008a\13\2\3\2\5\2\u008d\n\2\3\2\7\2\u0090\n")
        buf.write("\2\f\2\16\2\u0093\13\2\3\2\3\2\3\2\7\2\u0098\n\2\f\2\16")
        buf.write("\2\u009b\13\2\3\2\3\2\7\2\u009f\n\2\f\2\16\2\u00a2\13")
        buf.write("\2\3\2\5\2\u00a5\n\2\3\2\6\2\u00a8\n\2\r\2\16\2\u00a9")
        buf.write("\3\2\3\2\5\2\u00ae\n\2\3\3\3\3\5\3\u00b2\n\3\3\4\3\4\5")
        buf.write("\4\u00b6\n\4\3\5\3\5\3\5\5\5\u00bb\n\5\3\6\3\6\3\6\6\6")
        buf.write("\u00c0\n\6\r\6\16\6\u00c1\3\6\3\6\3\6\6\6\u00c7\n\6\r")
        buf.write("\6\16\6\u00c8\3\6\3\6\3\6\6\6\u00ce\n\6\r\6\16\6\u00cf")
        buf.write("\3\6\5\6\u00d3\n\6\5\6\u00d5\n\6\5\6\u00d7\n\6\3\6\7\6")
        buf.write("\u00da\n\6\f\6\16\6\u00dd\13\6\3\6\5\6\u00e0\n\6\3\7\3")
        buf.write("\7\3\7\6\7\u00e5\n\7\r\7\16\7\u00e6\3\7\3\7\3\7\6\7\u00ec")
        buf.write("\n\7\r\7\16\7\u00ed\3\7\3\7\3\7\6\7\u00f3\n\7\r\7\16\7")
        buf.write("\u00f4\3\7\5\7\u00f8\n\7\5\7\u00fa\n\7\5\7\u00fc\n\7\3")
        buf.write("\7\7\7\u00ff\n\7\f\7\16\7\u0102\13\7\3\7\3\7\7\7\u0106")
        buf.write("\n\7\f\7\16\7\u0109\13\7\3\7\5\7\u010c\n\7\3\b\3\b\3\t")
        buf.write("\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\6\t\u011a\n\t\r\t")
        buf.write("\16\t\u011b\3\t\3\t\3\t\7\t\u0121\n\t\f\t\16\t\u0124\13")
        buf.write("\t\3\t\7\t\u0127\n\t\f\t\16\t\u012a\13\t\3\t\5\t\u012d")
        buf.write("\n\t\3\n\3\n\3\n\6\n\u0132\n\n\r\n\16\n\u0133\3\n\3\n")
        buf.write("\3\n\6\n\u0139\n\n\r\n\16\n\u013a\3\n\5\n\u013e\n\n\3")
        buf.write("\13\3\13\3\13\6\13\u0143\n\13\r\13\16\13\u0144\3\13\3")
        buf.write("\13\3\13\6\13\u014a\n\13\r\13\16\13\u014b\3\13\5\13\u014f")
        buf.write("\n\13\3\f\3\f\3\f\6\f\u0154\n\f\r\f\16\f\u0155\3\f\3\f")
        buf.write("\3\f\6\f\u015b\n\f\r\f\16\f\u015c\3\f\3\f\3\r\3\r\6\r")
        buf.write("\u0163\n\r\r\r\16\r\u0164\3\r\3\r\6\r\u0169\n\r\r\r\16")
        buf.write("\r\u016a\3\r\3\r\6\r\u016f\n\r\r\r\16\r\u0170\3\r\3\r")
        buf.write("\3\r\6\r\u0176\n\r\r\r\16\r\u0177\3\r\5\r\u017b\n\r\3")
        buf.write("\16\3\16\6\16\u017f\n\16\r\16\16\16\u0180\3\16\3\16\6")
        buf.write("\16\u0185\n\16\r\16\16\16\u0186\3\16\5\16\u018a\n\16\3")
        buf.write("\16\6\16\u018d\n\16\r\16\16\16\u018e\3\16\3\16\3\16\6")
        buf.write("\16\u0194\n\16\r\16\16\16\u0195\3\16\5\16\u0199\n\16\3")
        buf.write("\17\3\17\6\17\u019d\n\17\r\17\16\17\u019e\5\17\u01a1\n")
        buf.write("\17\3\17\3\17\3\17\6\17\u01a6\n\17\r\17\16\17\u01a7\3")
        buf.write("\17\5\17\u01ab\n\17\3\20\3\20\3\21\3\21\6\21\u01b1\n\21")
        buf.write("\r\21\16\21\u01b2\3\21\3\21\3\21\3\21\6\21\u01b9\n\21")
        buf.write("\r\21\16\21\u01ba\3\21\3\21\5\21\u01bf\n\21\3\22\3\22")
        buf.write("\5\22\u01c3\n\22\3\23\3\23\6\23\u01c7\n\23\r\23\16\23")
        buf.write("\u01c8\3\23\3\23\3\24\3\24\6\24\u01cf\n\24\r\24\16\24")
        buf.write("\u01d0\3\24\3\24\6\24\u01d5\n\24\r\24\16\24\u01d6\3\24")
        buf.write("\3\24\3\25\3\25\3\26\3\26\6\26\u01df\n\26\r\26\16\26\u01e0")
        buf.write("\3\26\3\26\3\26\3\26\6\26\u01e7\n\26\r\26\16\26\u01e8")
        buf.write("\3\26\3\26\5\26\u01ed\n\26\3\27\3\27\3\30\3\30\6\30\u01f3")
        buf.write("\n\30\r\30\16\30\u01f4\3\30\3\30\6\30\u01f9\n\30\r\30")
        buf.write("\16\30\u01fa\3\30\5\30\u01fe\n\30\3\31\3\31\3\32\3\32")
        buf.write("\5\32\u0204\n\32\3\33\3\33\6\33\u0208\n\33\r\33\16\33")
        buf.write("\u0209\3\33\5\33\u020d\n\33\3\33\6\33\u0210\n\33\r\33")
        buf.write("\16\33\u0211\3\33\3\33\3\34\3\34\6\34\u0218\n\34\r\34")
        buf.write("\16\34\u0219\3\34\3\34\3\35\3\35\3\36\3\36\3\37\3\37\3")
        buf.write(" \3 \3!\3!\5!\u0228\n!\3\"\3\"\3\"\3\"\3\"\3#\3#\3$\3")
        buf.write("$\5$\u0233\n$\3$\5$\u0236\n$\3$\3$\6$\u023a\n$\r$\16$")
        buf.write("\u023b\3$\5$\u023f\n$\3$\3$\6$\u0243\n$\r$\16$\u0244\3")
        buf.write("$\5$\u0248\n$\3$\3$\6$\u024c\n$\r$\16$\u024d\3$\5$\u0251")
        buf.write("\n$\5$\u0253\n$\3%\3%\3&\5&\u0258\n&\3&\6&\u025b\n&\r")
        buf.write("&\16&\u025c\3&\5&\u0260\n&\3\'\6\'\u0263\n\'\r\'\16\'")
        buf.write("\u0264\3(\3(\3)\3)\6)\u026b\n)\r)\16)\u026c\3)\5)\u0270")
        buf.write("\n)\3*\3*\3+\3+\3,\3,\3-\3-\5-\u027a\n-\3.\3.\5.\u027e")
        buf.write("\n.\3/\3/\3/\3\60\3\60\3\60\3\61\3\61\5\61\u0288\n\61")
        buf.write("\3\61\5\61\u028b\n\61\3\61\5\61\u028e\n\61\3\61\5\61\u0291")
        buf.write("\n\61\3\61\5\61\u0294\n\61\3\61\5\61\u0297\n\61\3\62\3")
        buf.write("\62\3\63\3\63\3\64\3\64\3\65\3\65\3\66\3\66\5\66\u02a3")
        buf.write("\n\66\3\67\3\67\3\67\3\67\5\67\u02a9\n\67\3\67\3\67\3")
        buf.write("\67\38\38\38\2\29\2\4\6\b\n\f\16\20\22\24\26\30\32\34")
        buf.write("\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjln")
        buf.write("\2\20\3\2\3\n\3\2\13\f\3\2WY\4\2WWYY\6\2\62\62:;?@dd\4")
        buf.write("\2<>dd\3\2]^\3\2\r\24\3\2VW\3\2 !\5\2\25\25  \"\"\3\2")
        buf.write("#$\3\2\25\32\4\2\25\25\32\34\2\u02fb\2\u00ad\3\2\2\2\4")
        buf.write("\u00b1\3\2\2\2\6\u00b5\3\2\2\2\b\u00ba\3\2\2\2\n\u00bc")
        buf.write("\3\2\2\2\f\u00e1\3\2\2\2\16\u010d\3\2\2\2\20\u012c\3\2")
        buf.write("\2\2\22\u012e\3\2\2\2\24\u013f\3\2\2\2\26\u0150\3\2\2")
        buf.write("\2\30\u0160\3\2\2\2\32\u017c\3\2\2\2\34\u01a0\3\2\2\2")
        buf.write("\36\u01ac\3\2\2\2 \u01be\3\2\2\2\"\u01c2\3\2\2\2$\u01c4")
        buf.write("\3\2\2\2&\u01cc\3\2\2\2(\u01da\3\2\2\2*\u01ec\3\2\2\2")
        buf.write(",\u01ee\3\2\2\2.\u01f0\3\2\2\2\60\u01ff\3\2\2\2\62\u0203")
        buf.write("\3\2\2\2\64\u0205\3\2\2\2\66\u0215\3\2\2\28\u021d\3\2")
        buf.write("\2\2:\u021f\3\2\2\2<\u0221\3\2\2\2>\u0223\3\2\2\2@\u0227")
        buf.write("\3\2\2\2B\u0229\3\2\2\2D\u022e\3\2\2\2F\u0252\3\2\2\2")
        buf.write("H\u0254\3\2\2\2J\u0257\3\2\2\2L\u0262\3\2\2\2N\u0266\3")
        buf.write("\2\2\2P\u0268\3\2\2\2R\u0271\3\2\2\2T\u0273\3\2\2\2V\u0275")
        buf.write("\3\2\2\2X\u0277\3\2\2\2Z\u027b\3\2\2\2\\\u027f\3\2\2\2")
        buf.write("^\u0282\3\2\2\2`\u0285\3\2\2\2b\u0298\3\2\2\2d\u029a\3")
        buf.write("\2\2\2f\u029c\3\2\2\2h\u029e\3\2\2\2j\u02a2\3\2\2\2l\u02a4")
        buf.write("\3\2\2\2n\u02ad\3\2\2\2pr\7\35\2\2qp\3\2\2\2ru\3\2\2\2")
        buf.write("sq\3\2\2\2st\3\2\2\2tv\3\2\2\2us\3\2\2\2v\u00ae\5\4\3")
        buf.write("\2wy\7\35\2\2xw\3\2\2\2y|\3\2\2\2zx\3\2\2\2z{\3\2\2\2")
        buf.write("{}\3\2\2\2|z\3\2\2\2}\u00ae\5\6\4\2~\u0080\7\35\2\2\177")
        buf.write("~\3\2\2\2\u0080\u0083\3\2\2\2\u0081\177\3\2\2\2\u0081")
        buf.write("\u0082\3\2\2\2\u0082\u0084\3\2\2\2\u0083\u0081\3\2\2\2")
        buf.write("\u0084\u0088\5\4\3\2\u0085\u0087\7\35\2\2\u0086\u0085")
        buf.write("\3\2\2\2\u0087\u008a\3\2\2\2\u0088\u0086\3\2\2\2\u0088")
        buf.write("\u0089\3\2\2\2\u0089\u008c\3\2\2\2\u008a\u0088\3\2\2\2")
        buf.write("\u008b\u008d\5f\64\2\u008c\u008b\3\2\2\2\u008c\u008d\3")
        buf.write("\2\2\2\u008d\u0091\3\2\2\2\u008e\u0090\7\35\2\2\u008f")
        buf.write("\u008e\3\2\2\2\u0090\u0093\3\2\2\2\u0091\u008f\3\2\2\2")
        buf.write("\u0091\u0092\3\2\2\2\u0092\u0094\3\2\2\2\u0093\u0091\3")
        buf.write("\2\2\2\u0094\u0095\5\6\4\2\u0095\u00ae\3\2\2\2\u0096\u0098")
        buf.write("\7\35\2\2\u0097\u0096\3\2\2\2\u0098\u009b\3\2\2\2\u0099")
        buf.write("\u0097\3\2\2\2\u0099\u009a\3\2\2\2\u009a\u009c\3\2\2\2")
        buf.write("\u009b\u0099\3\2\2\2\u009c\u00a0\5\6\4\2\u009d\u009f\7")
        buf.write("\35\2\2\u009e\u009d\3\2\2\2\u009f\u00a2\3\2\2\2\u00a0")
        buf.write("\u009e\3\2\2\2\u00a0\u00a1\3\2\2\2\u00a1\u00a4\3\2\2\2")
        buf.write("\u00a2\u00a0\3\2\2\2\u00a3\u00a5\5h\65\2\u00a4\u00a3\3")
        buf.write("\2\2\2\u00a4\u00a5\3\2\2\2\u00a5\u00a7\3\2\2\2\u00a6\u00a8")
        buf.write("\7\35\2\2\u00a7\u00a6\3\2\2\2\u00a8\u00a9\3\2\2\2\u00a9")
        buf.write("\u00a7\3\2\2\2\u00a9\u00aa\3\2\2\2\u00aa\u00ab\3\2\2\2")
        buf.write("\u00ab\u00ac\5\4\3\2\u00ac\u00ae\3\2\2\2\u00ads\3\2\2")
        buf.write("\2\u00adz\3\2\2\2\u00ad\u0081\3\2\2\2\u00ad\u0099\3\2")
        buf.write("\2\2\u00ae\3\3\2\2\2\u00af\u00b2\5\20\t\2\u00b0\u00b2")
        buf.write("\5 \21\2\u00b1\u00af\3\2\2\2\u00b1\u00b0\3\2\2\2\u00b2")
        buf.write("\5\3\2\2\2\u00b3\u00b6\5\b\5\2\u00b4\u00b6\5*\26\2\u00b5")
        buf.write("\u00b3\3\2\2\2\u00b5\u00b4\3\2\2\2\u00b6\7\3\2\2\2\u00b7")
        buf.write("\u00bb\5\n\6\2\u00b8\u00bb\5\f\7\2\u00b9\u00bb\5P)\2\u00ba")
        buf.write("\u00b7\3\2\2\2\u00ba\u00b8\3\2\2\2\u00ba\u00b9\3\2\2\2")
        buf.write("\u00bb\t\3\2\2\2\u00bc\u00d6\5Z.\2\u00bd\u00c0\7\35\2")
        buf.write("\2\u00be\u00c0\5d\63\2\u00bf\u00bd\3\2\2\2\u00bf\u00be")
        buf.write("\3\2\2\2\u00c0\u00c1\3\2\2\2\u00c1\u00bf\3\2\2\2\u00c1")
        buf.write("\u00c2\3\2\2\2\u00c2\u00c3\3\2\2\2\u00c3\u00d4\5\\/\2")
        buf.write("\u00c4\u00c7\7\35\2\2\u00c5\u00c7\5d\63\2\u00c6\u00c4")
        buf.write("\3\2\2\2\u00c6\u00c5\3\2\2\2\u00c7\u00c8\3\2\2\2\u00c8")
        buf.write("\u00c6\3\2\2\2\u00c8\u00c9\3\2\2\2\u00c9\u00ca\3\2\2\2")
        buf.write("\u00ca\u00d2\5^\60\2\u00cb\u00ce\7\35\2\2\u00cc\u00ce")
        buf.write("\5d\63\2\u00cd\u00cb\3\2\2\2\u00cd\u00cc\3\2\2\2\u00ce")
        buf.write("\u00cf\3\2\2\2\u00cf\u00cd\3\2\2\2\u00cf\u00d0\3\2\2\2")
        buf.write("\u00d0\u00d1\3\2\2\2\u00d1\u00d3\5`\61\2\u00d2\u00cd\3")
        buf.write("\2\2\2\u00d2\u00d3\3\2\2\2\u00d3\u00d5\3\2\2\2\u00d4\u00c6")
        buf.write("\3\2\2\2\u00d4\u00d5\3\2\2\2\u00d5\u00d7\3\2\2\2\u00d6")
        buf.write("\u00bf\3\2\2\2\u00d6\u00d7\3\2\2\2\u00d7\u00db\3\2\2\2")
        buf.write("\u00d8\u00da\7\35\2\2\u00d9\u00d8\3\2\2\2\u00da\u00dd")
        buf.write("\3\2\2\2\u00db\u00d9\3\2\2\2\u00db\u00dc\3\2\2\2\u00dc")
        buf.write("\u00df\3\2\2\2\u00dd\u00db\3\2\2\2\u00de\u00e0\5j\66\2")
        buf.write("\u00df\u00de\3\2\2\2\u00df\u00e0\3\2\2\2\u00e0\13\3\2")
        buf.write("\2\2\u00e1\u00fb\5Z.\2\u00e2\u00e5\7\35\2\2\u00e3\u00e5")
        buf.write("\5d\63\2\u00e4\u00e2\3\2\2\2\u00e4\u00e3\3\2\2\2\u00e5")
        buf.write("\u00e6\3\2\2\2\u00e6\u00e4\3\2\2\2\u00e6\u00e7\3\2\2\2")
        buf.write("\u00e7\u00e8\3\2\2\2\u00e8\u00f9\5\\/\2\u00e9\u00ec\7")
        buf.write("\35\2\2\u00ea\u00ec\5d\63\2\u00eb\u00e9\3\2\2\2\u00eb")
        buf.write("\u00ea\3\2\2\2\u00ec\u00ed\3\2\2\2\u00ed\u00eb\3\2\2\2")
        buf.write("\u00ed\u00ee\3\2\2\2\u00ee\u00ef\3\2\2\2\u00ef\u00f7\5")
        buf.write("^\60\2\u00f0\u00f3\7\35\2\2\u00f1\u00f3\5d\63\2\u00f2")
        buf.write("\u00f0\3\2\2\2\u00f2\u00f1\3\2\2\2\u00f3\u00f4\3\2\2\2")
        buf.write("\u00f4\u00f2\3\2\2\2\u00f4\u00f5\3\2\2\2\u00f5\u00f6\3")
        buf.write("\2\2\2\u00f6\u00f8\5`\61\2\u00f7\u00f2\3\2\2\2\u00f7\u00f8")
        buf.write("\3\2\2\2\u00f8\u00fa\3\2\2\2\u00f9\u00eb\3\2\2\2\u00f9")
        buf.write("\u00fa\3\2\2\2\u00fa\u00fc\3\2\2\2\u00fb\u00e4\3\2\2\2")
        buf.write("\u00fb\u00fc\3\2\2\2\u00fc\u0100\3\2\2\2\u00fd\u00ff\7")
        buf.write("\35\2\2\u00fe\u00fd\3\2\2\2\u00ff\u0102\3\2\2\2\u0100")
        buf.write("\u00fe\3\2\2\2\u0100\u0101\3\2\2\2\u0101\u0103\3\2\2\2")
        buf.write("\u0102\u0100\3\2\2\2\u0103\u0107\5\16\b\2\u0104\u0106")
        buf.write("\7\35\2\2\u0105\u0104\3\2\2\2\u0106\u0109\3\2\2\2\u0107")
        buf.write("\u0105\3\2\2\2\u0107\u0108\3\2\2\2\u0108\u010b\3\2\2\2")
        buf.write("\u0109\u0107\3\2\2\2\u010a\u010c\5j\66\2\u010b\u010a\3")
        buf.write("\2\2\2\u010b\u010c\3\2\2\2\u010c\r\3\2\2\2\u010d\u010e")
        buf.write("\t\2\2\2\u010e\17\3\2\2\2\u010f\u012d\5\22\n\2\u0110\u012d")
        buf.write("\5\24\13\2\u0111\u012d\5\26\f\2\u0112\u012d\5\34\17\2")
        buf.write("\u0113\u012d\5\30\r\2\u0114\u012d\5\32\16\2\u0115\u012d")
        buf.write("\5\"\22\2\u0116\u0119\5T+\2\u0117\u011a\7\35\2\2\u0118")
        buf.write("\u011a\5b\62\2\u0119\u0117\3\2\2\2\u0119\u0118\3\2\2\2")
        buf.write("\u011a\u011b\3\2\2\2\u011b\u0119\3\2\2\2\u011b\u011c\3")
        buf.write("\2\2\2\u011c\u011d\3\2\2\2\u011d\u0122\5\22\n\2\u011e")
        buf.write("\u0121\7\35\2\2\u011f\u0121\5b\62\2\u0120\u011e\3\2\2")
        buf.write("\2\u0120\u011f\3\2\2\2\u0121\u0124\3\2\2\2\u0122\u0120")
        buf.write("\3\2\2\2\u0122\u0123\3\2\2\2\u0123\u0128\3\2\2\2\u0124")
        buf.write("\u0122\3\2\2\2\u0125\u0127\5\b\5\2\u0126\u0125\3\2\2\2")
        buf.write("\u0127\u012a\3\2\2\2\u0128\u0126\3\2\2\2\u0128\u0129\3")
        buf.write("\2\2\2\u0129\u012d\3\2\2\2\u012a\u0128\3\2\2\2\u012b\u012d")
        buf.write("\5T+\2\u012c\u010f\3\2\2\2\u012c\u0110\3\2\2\2\u012c\u0111")
        buf.write("\3\2\2\2\u012c\u0112\3\2\2\2\u012c\u0113\3\2\2\2\u012c")
        buf.write("\u0114\3\2\2\2\u012c\u0115\3\2\2\2\u012c\u0116\3\2\2\2")
        buf.write("\u012c\u012b\3\2\2\2\u012d\21\3\2\2\2\u012e\u0131\5@!")
        buf.write("\2\u012f\u0132\7\35\2\2\u0130\u0132\5b\62\2\u0131\u012f")
        buf.write("\3\2\2\2\u0131\u0130\3\2\2\2\u0132\u0133\3\2\2\2\u0133")
        buf.write("\u0131\3\2\2\2\u0133\u0134\3\2\2\2\u0134\u0135\3\2\2\2")
        buf.write("\u0135\u013d\5F$\2\u0136\u0139\7\35\2\2\u0137\u0139\5")
        buf.write("b\62\2\u0138\u0136\3\2\2\2\u0138\u0137\3\2\2\2\u0139\u013a")
        buf.write("\3\2\2\2\u013a\u0138\3\2\2\2\u013a\u013b\3\2\2\2\u013b")
        buf.write("\u013c\3\2\2\2\u013c\u013e\5B\"\2\u013d\u0138\3\2\2\2")
        buf.write("\u013d\u013e\3\2\2\2\u013e\23\3\2\2\2\u013f\u0142\5F$")
        buf.write("\2\u0140\u0143\7\35\2\2\u0141\u0143\5b\62\2\u0142\u0140")
        buf.write("\3\2\2\2\u0142\u0141\3\2\2\2\u0143\u0144\3\2\2\2\u0144")
        buf.write("\u0142\3\2\2\2\u0144\u0145\3\2\2\2\u0145\u0146\3\2\2\2")
        buf.write("\u0146\u014e\5V,\2\u0147\u014a\7\35\2\2\u0148\u014a\5")
        buf.write("b\62\2\u0149\u0147\3\2\2\2\u0149\u0148\3\2\2\2\u014a\u014b")
        buf.write("\3\2\2\2\u014b\u0149\3\2\2\2\u014b\u014c\3\2\2\2\u014c")
        buf.write("\u014d\3\2\2\2\u014d\u014f\5B\"\2\u014e\u0149\3\2\2\2")
        buf.write("\u014e\u014f\3\2\2\2\u014f\25\3\2\2\2\u0150\u0153\5B\"")
        buf.write("\2\u0151\u0154\7\35\2\2\u0152\u0154\5b\62\2\u0153\u0151")
        buf.write("\3\2\2\2\u0153\u0152\3\2\2\2\u0154\u0155\3\2\2\2\u0155")
        buf.write("\u0153\3\2\2\2\u0155\u0156\3\2\2\2\u0156\u0157\3\2\2\2")
        buf.write("\u0157\u015a\5@!\2\u0158\u015b\7\35\2\2\u0159\u015b\5")
        buf.write("b\62\2\u015a\u0158\3\2\2\2\u015a\u0159\3\2\2\2\u015b\u015c")
        buf.write("\3\2\2\2\u015c\u015a\3\2\2\2\u015c\u015d\3\2\2\2\u015d")
        buf.write("\u015e\3\2\2\2\u015e\u015f\5F$\2\u015f\27\3\2\2\2\u0160")
        buf.write("\u0162\5J&\2\u0161\u0163\7\35\2\2\u0162\u0161\3\2\2\2")
        buf.write("\u0163\u0164\3\2\2\2\u0164\u0162\3\2\2\2\u0164\u0165\3")
        buf.write("\2\2\2\u0165\u0166\3\2\2\2\u0166\u0168\5T+\2\u0167\u0169")
        buf.write("\7\35\2\2\u0168\u0167\3\2\2\2\u0169\u016a\3\2\2\2\u016a")
        buf.write("\u0168\3\2\2\2\u016a\u016b\3\2\2\2\u016b\u016c\3\2\2\2")
        buf.write("\u016c\u016e\t\3\2\2\u016d\u016f\7\35\2\2\u016e\u016d")
        buf.write("\3\2\2\2\u016f\u0170\3\2\2\2\u0170\u016e\3\2\2\2\u0170")
        buf.write("\u0171\3\2\2\2\u0171\u0172\3\2\2\2\u0172\u017a\5V,\2\u0173")
        buf.write("\u0176\5b\62\2\u0174\u0176\7\35\2\2\u0175\u0173\3\2\2")
        buf.write("\2\u0175\u0174\3\2\2\2\u0176\u0177\3\2\2\2\u0177\u0175")
        buf.write("\3\2\2\2\u0177\u0178\3\2\2\2\u0178\u0179\3\2\2\2\u0179")
        buf.write("\u017b\5B\"\2\u017a\u0175\3\2\2\2\u017a\u017b\3\2\2\2")
        buf.write("\u017b\31\3\2\2\2\u017c\u017e\5H%\2\u017d\u017f\7\35\2")
        buf.write("\2\u017e\u017d\3\2\2\2\u017f\u0180\3\2\2\2\u0180\u017e")
        buf.write("\3\2\2\2\u0180\u0181\3\2\2\2\u0181\u0182\3\2\2\2\u0182")
        buf.write("\u0189\5T+\2\u0183\u0185\7\35\2\2\u0184\u0183\3\2\2\2")
        buf.write("\u0185\u0186\3\2\2\2\u0186\u0184\3\2\2\2\u0186\u0187\3")
        buf.write("\2\2\2\u0187\u0188\3\2\2\2\u0188\u018a\t\3\2\2\u0189\u0184")
        buf.write("\3\2\2\2\u0189\u018a\3\2\2\2\u018a\u018c\3\2\2\2\u018b")
        buf.write("\u018d\7\35\2\2\u018c\u018b\3\2\2\2\u018d\u018e\3\2\2")
        buf.write("\2\u018e\u018c\3\2\2\2\u018e\u018f\3\2\2\2\u018f\u0190")
        buf.write("\3\2\2\2\u0190\u0198\5V,\2\u0191\u0194\5b\62\2\u0192\u0194")
        buf.write("\7\35\2\2\u0193\u0191\3\2\2\2\u0193\u0192\3\2\2\2\u0194")
        buf.write("\u0195\3\2\2\2\u0195\u0193\3\2\2\2\u0195\u0196\3\2\2\2")
        buf.write("\u0196\u0197\3\2\2\2\u0197\u0199\5B\"\2\u0198\u0193\3")
        buf.write("\2\2\2\u0198\u0199\3\2\2\2\u0199\33\3\2\2\2\u019a\u019c")
        buf.write("\5\36\20\2\u019b\u019d\7\35\2\2\u019c\u019b\3\2\2\2\u019d")
        buf.write("\u019e\3\2\2\2\u019e\u019c\3\2\2\2\u019e\u019f\3\2\2\2")
        buf.write("\u019f\u01a1\3\2\2\2\u01a0\u019a\3\2\2\2\u01a0\u01a1\3")
        buf.write("\2\2\2\u01a1\u01a2\3\2\2\2\u01a2\u01aa\5D#\2\u01a3\u01a6")
        buf.write("\7\35\2\2\u01a4\u01a6\5b\62\2\u01a5\u01a3\3\2\2\2\u01a5")
        buf.write("\u01a4\3\2\2\2\u01a6\u01a7\3\2\2\2\u01a7\u01a5\3\2\2\2")
        buf.write("\u01a7\u01a8\3\2\2\2\u01a8\u01a9\3\2\2\2\u01a9\u01ab\5")
        buf.write("B\"\2\u01aa\u01a5\3\2\2\2\u01aa\u01ab\3\2\2\2\u01ab\35")
        buf.write("\3\2\2\2\u01ac\u01ad\t\4\2\2\u01ad\37\3\2\2\2\u01ae\u01b0")
        buf.write("\5(\25\2\u01af\u01b1\7\35\2\2\u01b0\u01af\3\2\2\2\u01b1")
        buf.write("\u01b2\3\2\2\2\u01b2\u01b0\3\2\2\2\u01b2\u01b3\3\2\2\2")
        buf.write("\u01b3\u01b4\3\2\2\2\u01b4\u01b5\5.\30\2\u01b5\u01bf\3")
        buf.write("\2\2\2\u01b6\u01b8\5.\30\2\u01b7\u01b9\7\35\2\2\u01b8")
        buf.write("\u01b7\3\2\2\2\u01b9\u01ba\3\2\2\2\u01ba\u01b8\3\2\2\2")
        buf.write("\u01ba\u01bb\3\2\2\2\u01bb\u01bc\3\2\2\2\u01bc\u01bd\5")
        buf.write("(\25\2\u01bd\u01bf\3\2\2\2\u01be\u01ae\3\2\2\2\u01be\u01b6")
        buf.write("\3\2\2\2\u01bf!\3\2\2\2\u01c0\u01c3\5&\24\2\u01c1\u01c3")
        buf.write("\5$\23\2\u01c2\u01c0\3\2\2\2\u01c2\u01c1\3\2\2\2\u01c3")
        buf.write("#\3\2\2\2\u01c4\u01c6\5\36\20\2\u01c5\u01c7\7\35\2\2\u01c6")
        buf.write("\u01c5\3\2\2\2\u01c7\u01c8\3\2\2\2\u01c8\u01c6\3\2\2\2")
        buf.write("\u01c8\u01c9\3\2\2\2\u01c9\u01ca\3\2\2\2\u01ca\u01cb\5")
        buf.write("8\35\2\u01cb%\3\2\2\2\u01cc\u01ce\5L\'\2\u01cd\u01cf\7")
        buf.write("\35\2\2\u01ce\u01cd\3\2\2\2\u01cf\u01d0\3\2\2\2\u01d0")
        buf.write("\u01ce\3\2\2\2\u01d0\u01d1\3\2\2\2\u01d1\u01d2\3\2\2\2")
        buf.write("\u01d2\u01d4\58\35\2\u01d3\u01d5\7\35\2\2\u01d4\u01d3")
        buf.write("\3\2\2\2\u01d5\u01d6\3\2\2\2\u01d6\u01d4\3\2\2\2\u01d6")
        buf.write("\u01d7\3\2\2\2\u01d7\u01d8\3\2\2\2\u01d8\u01d9\7Z\2\2")
        buf.write("\u01d9\'\3\2\2\2\u01da\u01db\5\20\t\2\u01db)\3\2\2\2\u01dc")
        buf.write("\u01de\5\62\32\2\u01dd\u01df\7\35\2\2\u01de\u01dd\3\2")
        buf.write("\2\2\u01df\u01e0\3\2\2\2\u01e0\u01de\3\2\2\2\u01e0\u01e1")
        buf.write("\3\2\2\2\u01e1\u01e2\3\2\2\2\u01e2\u01e3\5,\27\2\u01e3")
        buf.write("\u01ed\3\2\2\2\u01e4\u01e6\5,\27\2\u01e5\u01e7\7\35\2")
        buf.write("\2\u01e6\u01e5\3\2\2\2\u01e7\u01e8\3\2\2\2\u01e8\u01e6")
        buf.write("\3\2\2\2\u01e8\u01e9\3\2\2\2\u01e9\u01ea\3\2\2\2\u01ea")
        buf.write("\u01eb\5\62\32\2\u01eb\u01ed\3\2\2\2\u01ec\u01dc\3\2\2")
        buf.write("\2\u01ec\u01e4\3\2\2\2\u01ed+\3\2\2\2\u01ee\u01ef\5\b")
        buf.write("\5\2\u01ef-\3\2\2\2\u01f0\u01f2\5J&\2\u01f1\u01f3\7\35")
        buf.write("\2\2\u01f2\u01f1\3\2\2\2\u01f3\u01f4\3\2\2\2\u01f4\u01f2")
        buf.write("\3\2\2\2\u01f4\u01f5\3\2\2\2\u01f5\u01f6\3\2\2\2\u01f6")
        buf.write("\u01fd\58\35\2\u01f7\u01f9\7\35\2\2\u01f8\u01f7\3\2\2")
        buf.write("\2\u01f9\u01fa\3\2\2\2\u01fa\u01f8\3\2\2\2\u01fa\u01fb")
        buf.write("\3\2\2\2\u01fb\u01fc\3\2\2\2\u01fc\u01fe\5<\37\2\u01fd")
        buf.write("\u01f8\3\2\2\2\u01fd\u01fe\3\2\2\2\u01fe/\3\2\2\2\u01ff")
        buf.write("\u0200\t\5\2\2\u0200\61\3\2\2\2\u0201\u0204\5\64\33\2")
        buf.write("\u0202\u0204\5\66\34\2\u0203\u0201\3\2\2\2\u0203\u0202")
        buf.write("\3\2\2\2\u0204\63\3\2\2\2\u0205\u020c\5J&\2\u0206\u0208")
        buf.write("\7\35\2\2\u0207\u0206\3\2\2\2\u0208\u0209\3\2\2\2\u0209")
        buf.write("\u0207\3\2\2\2\u0209\u020a\3\2\2\2\u020a\u020b\3\2\2\2")
        buf.write("\u020b\u020d\5:\36\2\u020c\u0207\3\2\2\2\u020c\u020d\3")
        buf.write("\2\2\2\u020d\u020f\3\2\2\2\u020e\u0210\7\35\2\2\u020f")
        buf.write("\u020e\3\2\2\2\u0210\u0211\3\2\2\2\u0211\u020f\3\2\2\2")
        buf.write("\u0211\u0212\3\2\2\2\u0212\u0213\3\2\2\2\u0213\u0214\5")
        buf.write("> \2\u0214\65\3\2\2\2\u0215\u0217\5N(\2\u0216\u0218\7")
        buf.write("\35\2\2\u0217\u0216\3\2\2\2\u0218\u0219\3\2\2\2\u0219")
        buf.write("\u0217\3\2\2\2\u0219\u021a\3\2\2\2\u021a\u021b\3\2\2\2")
        buf.write("\u021b\u021c\5> \2\u021c\67\3\2\2\2\u021d\u021e\t\6\2")
        buf.write("\2\u021e9\3\2\2\2\u021f\u0220\t\7\2\2\u0220;\3\2\2\2\u0221")
        buf.write("\u0222\t\b\2\2\u0222=\3\2\2\2\u0223\u0224\t\b\2\2\u0224")
        buf.write("?\3\2\2\2\u0225\u0228\5V,\2\u0226\u0228\5X-\2\u0227\u0225")
        buf.write("\3\2\2\2\u0227\u0226\3\2\2\2\u0228A\3\2\2\2\u0229\u022a")
        buf.write("\7`\2\2\u022a\u022b\7`\2\2\u022b\u022c\7`\2\2\u022c\u022d")
        buf.write("\7`\2\2\u022dC\3\2\2\2\u022e\u022f\7A\2\2\u022fE\3\2\2")
        buf.write("\2\u0230\u0232\7`\2\2\u0231\u0233\7`\2\2\u0232\u0231\3")
        buf.write("\2\2\2\u0232\u0233\3\2\2\2\u0233\u0235\3\2\2\2\u0234\u0236")
        buf.write("\t\t\2\2\u0235\u0234\3\2\2\2\u0235\u0236\3\2\2\2\u0236")
        buf.write("\u0253\3\2\2\2\u0237\u023e\7c\2\2\u0238\u023a\7\35\2\2")
        buf.write("\u0239\u0238\3\2\2\2\u023a\u023b\3\2\2\2\u023b\u0239\3")
        buf.write("\2\2\2\u023b\u023c\3\2\2\2\u023c\u023d\3\2\2\2\u023d\u023f")
        buf.write("\7\f\2\2\u023e\u0239\3\2\2\2\u023e\u023f\3\2\2\2\u023f")
        buf.write("\u0253\3\2\2\2\u0240\u0247\7a\2\2\u0241\u0243\7\35\2\2")
        buf.write("\u0242\u0241\3\2\2\2\u0243\u0244\3\2\2\2\u0244\u0242\3")
        buf.write("\2\2\2\u0244\u0245\3\2\2\2\u0245\u0246\3\2\2\2\u0246\u0248")
        buf.write("\7\f\2\2\u0247\u0242\3\2\2\2\u0247\u0248\3\2\2\2\u0248")
        buf.write("\u0253\3\2\2\2\u0249\u0250\7b\2\2\u024a\u024c\7\35\2\2")
        buf.write("\u024b\u024a\3\2\2\2\u024c\u024d\3\2\2\2\u024d\u024b\3")
        buf.write("\2\2\2\u024d\u024e\3\2\2\2\u024e\u024f\3\2\2\2\u024f\u0251")
        buf.write("\7\f\2\2\u0250\u024b\3\2\2\2\u0250\u0251\3\2\2\2\u0251")
        buf.write("\u0253\3\2\2\2\u0252\u0230\3\2\2\2\u0252\u0237\3\2\2\2")
        buf.write("\u0252\u0240\3\2\2\2\u0252\u0249\3\2\2\2\u0253G\3\2\2")
        buf.write("\2\u0254\u0255\t\n\2\2\u0255I\3\2\2\2\u0256\u0258\t\13")
        buf.write("\2\2\u0257\u0256\3\2\2\2\u0257\u0258\3\2\2\2\u0258\u025a")
        buf.write("\3\2\2\2\u0259\u025b\7`\2\2\u025a\u0259\3\2\2\2\u025b")
        buf.write("\u025c\3\2\2\2\u025c\u025a\3\2\2\2\u025c\u025d\3\2\2\2")
        buf.write("\u025d\u025f\3\2\2\2\u025e\u0260\t\t\2\2\u025f\u025e\3")
        buf.write("\2\2\2\u025f\u0260\3\2\2\2\u0260K\3\2\2\2\u0261\u0263")
        buf.write("\7`\2\2\u0262\u0261\3\2\2\2\u0263\u0264\3\2\2\2\u0264")
        buf.write("\u0262\3\2\2\2\u0264\u0265\3\2\2\2\u0265M\3\2\2\2\u0266")
        buf.write("\u0267\7_\2\2\u0267O\3\2\2\2\u0268\u026f\5R*\2\u0269\u026b")
        buf.write("\7\35\2\2\u026a\u0269\3\2\2\2\u026b\u026c\3\2\2\2\u026c")
        buf.write("\u026a\3\2\2\2\u026c\u026d\3\2\2\2\u026d\u026e\3\2\2\2")
        buf.write("\u026e\u0270\5j\66\2\u026f\u026a\3\2\2\2\u026f\u0270\3")
        buf.write("\2\2\2\u0270Q\3\2\2\2\u0271\u0272\7B\2\2\u0272S\3\2\2")
        buf.write("\2\u0273\u0274\7\62\2\2\u0274U\3\2\2\2\u0275\u0276\7%")
        buf.write("\2\2\u0276W\3\2\2\2\u0277\u0279\7`\2\2\u0278\u027a\7`")
        buf.write("\2\2\u0279\u0278\3\2\2\2\u0279\u027a\3\2\2\2\u027aY\3")
        buf.write("\2\2\2\u027b\u027d\7`\2\2\u027c\u027e\7`\2\2\u027d\u027c")
        buf.write("\3\2\2\2\u027d\u027e\3\2\2\2\u027e[\3\2\2\2\u027f\u0280")
        buf.write("\7`\2\2\u0280\u0281\7`\2\2\u0281]\3\2\2\2\u0282\u0283")
        buf.write("\7`\2\2\u0283\u0284\7`\2\2\u0284_\3\2\2\2\u0285\u0287")
        buf.write("\7`\2\2\u0286\u0288\7`\2\2\u0287\u0286\3\2\2\2\u0287\u0288")
        buf.write("\3\2\2\2\u0288\u028a\3\2\2\2\u0289\u028b\7`\2\2\u028a")
        buf.write("\u0289\3\2\2\2\u028a\u028b\3\2\2\2\u028b\u028d\3\2\2\2")
        buf.write("\u028c\u028e\7`\2\2\u028d\u028c\3\2\2\2\u028d\u028e\3")
        buf.write("\2\2\2\u028e\u0290\3\2\2\2\u028f\u0291\7`\2\2\u0290\u028f")
        buf.write("\3\2\2\2\u0290\u0291\3\2\2\2\u0291\u0293\3\2\2\2\u0292")
        buf.write("\u0294\7`\2\2\u0293\u0292\3\2\2\2\u0293\u0294\3\2\2\2")
        buf.write("\u0294\u0296\3\2\2\2\u0295\u0297\7`\2\2\u0296\u0295\3")
        buf.write("\2\2\2\u0296\u0297\3\2\2\2\u0297a\3\2\2\2\u0298\u0299")
        buf.write("\t\f\2\2\u0299c\3\2\2\2\u029a\u029b\t\r\2\2\u029be\3\2")
        buf.write("\2\2\u029c\u029d\t\16\2\2\u029dg\3\2\2\2\u029e\u029f\t")
        buf.write("\17\2\2\u029fi\3\2\2\2\u02a0\u02a3\5l\67\2\u02a1\u02a3")
        buf.write("\5n8\2\u02a2\u02a0\3\2\2\2\u02a2\u02a1\3\2\2\2\u02a3k")
        buf.write("\3\2\2\2\u02a4\u02a5\t\13\2\2\u02a5\u02a6\7`\2\2\u02a6")
        buf.write("\u02a8\7`\2\2\u02a7\u02a9\7$\2\2\u02a8\u02a7\3\2\2\2\u02a8")
        buf.write("\u02a9\3\2\2\2\u02a9\u02aa\3\2\2\2\u02aa\u02ab\7`\2\2")
        buf.write("\u02ab\u02ac\7`\2\2\u02acm\3\2\2\2\u02ad\u02ae\7e\2\2")
        buf.write("\u02aeo\3\2\2\2ysz\u0081\u0088\u008c\u0091\u0099\u00a0")
        buf.write("\u00a4\u00a9\u00ad\u00b1\u00b5\u00ba\u00bf\u00c1\u00c6")
        buf.write("\u00c8\u00cd\u00cf\u00d2\u00d4\u00d6\u00db\u00df\u00e4")
        buf.write("\u00e6\u00eb\u00ed\u00f2\u00f4\u00f7\u00f9\u00fb\u0100")
        buf.write("\u0107\u010b\u0119\u011b\u0120\u0122\u0128\u012c\u0131")
        buf.write("\u0133\u0138\u013a\u013d\u0142\u0144\u0149\u014b\u014e")
        buf.write("\u0153\u0155\u015a\u015c\u0164\u016a\u0170\u0175\u0177")
        buf.write("\u017a\u0180\u0186\u0189\u018e\u0193\u0195\u0198\u019e")
        buf.write("\u01a0\u01a5\u01a7\u01aa\u01b2\u01ba\u01be\u01c2\u01c8")
        buf.write("\u01d0\u01d6\u01e0\u01e8\u01ec\u01f4\u01fa\u01fd\u0203")
        buf.write("\u0209\u020c\u0211\u0219\u0227\u0232\u0235\u023b\u023e")
        buf.write("\u0244\u0247\u024d\u0250\u0252\u0257\u025c\u025f\u0264")
        buf.write("\u026c\u026f\u0279\u027d\u0287\u028a\u028d\u0290\u0293")
        buf.write("\u0296\u02a2\u02a8")
        return buf.getvalue()


class dateparse_utilsParser ( Parser ):

    grammarFileName = "dateparse_utils.g4"

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

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

    sharedContextCache = PredictionContextCache()

    literalNames = [ "<INVALID>", "'a'", "'am'", "'p'", "'pm'", "'AM'", 
                     "'PM'", "'A'", "'P'", "'in'", "'of'", "'st'", "'ST'", 
                     "'nd'", "'ND'", "'rd'", "'RD'", "'th'", "'TH'", "','", 
                     "'T'", "'t'", "'at'", "'AT'", "';'", "'on'", "'ON'", 
                     "<INVALID>", "<INVALID>", "<INVALID>", "'-'", "'+'", 
                     "'/'", "'.'", "':'" ]

    symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "<INVALID>", "SPACE", "COMMENT", 
                      "THE", "DASH", "PLUS", "SLASH", "DOT", "COLON", "MONTH_NAME", 
                      "JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", 
                      "SEP", "OCT", "NOV", "DEC", "WEEKDAY", "SUN", "MON", 
                      "TUE", "WED", "THU", "FRI", "SAT", "WEEK", "DAY", 
                      "HOUR", "MINUTE", "SECOND", "MONTH", "YEAR", "SPECIAL_DATE", 
                      "SPECIAL_TIME", "NOON", "MIDNIGHT", "TODAY", "YESTERDAY", 
                      "TOMORROW", "EASTER", "NEW_YEARS_DAY", "NEW_YEARS_EVE", 
                      "CHRISTMAS", "CHRISTMAS_EVE", "MARTIN_LUTHER_KING_DAY", 
                      "MEMORIAL_DAY", "INDEPENDENCE_DAY", "LABOR_DAY", "PRESIDENTS_DAY", 
                      "COLUMBUS_DAY", "VETERANS_DAY", "HALLOWEEN", "THANKSGIVING_DAY", 
                      "FIRST", "LAST", "THIS", "NEXT", "AGO_FROM_NOW", "AGO", 
                      "FROM_NOW", "BEFORE", "AFTER", "DELTA_TIME_FRACTION", 
                      "DIGIT", "IDES", "NONES", "KALENDS", "WORKDAY", "UPPERCASE_STRING" ]

    RULE_parse = 0
    RULE_dateExpr = 1
    RULE_timeExpr = 2
    RULE_singleTimeExpr = 3
    RULE_twentyFourHourTimeExpr = 4
    RULE_twelveHourTimeExpr = 5
    RULE_ampm = 6
    RULE_singleDateExpr = 7
    RULE_monthDayMaybeYearExpr = 8
    RULE_dayMonthMaybeYearExpr = 9
    RULE_yearMonthDayExpr = 10
    RULE_nthWeekdayInMonthMaybeYearExpr = 11
    RULE_firstLastWeekdayInMonthMaybeYearExpr = 12
    RULE_specialDateMaybeYearExpr = 13
    RULE_thisNextLast = 14
    RULE_baseAndOffsetDateExpr = 15
    RULE_deltaDateExprRelativeToTodayImplied = 16
    RULE_deltaRelativeToTodayExpr = 17
    RULE_nFoosFromTodayAgoExpr = 18
    RULE_baseDate = 19
    RULE_baseAndOffsetTimeExpr = 20
    RULE_baseTime = 21
    RULE_deltaPlusMinusExpr = 22
    RULE_deltaNextLast = 23
    RULE_deltaPlusMinusTimeExpr = 24
    RULE_countUnitsBeforeAfterTimeExpr = 25
    RULE_fractionBeforeAfterTimeExpr = 26
    RULE_deltaUnit = 27
    RULE_deltaTimeUnit = 28
    RULE_deltaBeforeAfter = 29
    RULE_deltaTimeBeforeAfter = 30
    RULE_monthExpr = 31
    RULE_year = 32
    RULE_specialDate = 33
    RULE_dayOfMonth = 34
    RULE_firstOrLast = 35
    RULE_nth = 36
    RULE_unsignedInt = 37
    RULE_deltaTimeFraction = 38
    RULE_specialTimeExpr = 39
    RULE_specialTime = 40
    RULE_dayName = 41
    RULE_monthName = 42
    RULE_monthNumber = 43
    RULE_hour = 44
    RULE_minute = 45
    RULE_second = 46
    RULE_micros = 47
    RULE_ddiv = 48
    RULE_tdiv = 49
    RULE_dtdiv = 50
    RULE_tddiv = 51
    RULE_tzExpr = 52
    RULE_ntz = 53
    RULE_ltz = 54

    ruleNames =  [ "parse", "dateExpr", "timeExpr", "singleTimeExpr", "twentyFourHourTimeExpr", 
                   "twelveHourTimeExpr", "ampm", "singleDateExpr", "monthDayMaybeYearExpr", 
                   "dayMonthMaybeYearExpr", "yearMonthDayExpr", "nthWeekdayInMonthMaybeYearExpr", 
                   "firstLastWeekdayInMonthMaybeYearExpr", "specialDateMaybeYearExpr", 
                   "thisNextLast", "baseAndOffsetDateExpr", "deltaDateExprRelativeToTodayImplied", 
                   "deltaRelativeToTodayExpr", "nFoosFromTodayAgoExpr", 
                   "baseDate", "baseAndOffsetTimeExpr", "baseTime", "deltaPlusMinusExpr", 
                   "deltaNextLast", "deltaPlusMinusTimeExpr", "countUnitsBeforeAfterTimeExpr", 
                   "fractionBeforeAfterTimeExpr", "deltaUnit", "deltaTimeUnit", 
                   "deltaBeforeAfter", "deltaTimeBeforeAfter", "monthExpr", 
                   "year", "specialDate", "dayOfMonth", "firstOrLast", "nth", 
                   "unsignedInt", "deltaTimeFraction", "specialTimeExpr", 
                   "specialTime", "dayName", "monthName", "monthNumber", 
                   "hour", "minute", "second", "micros", "ddiv", "tdiv", 
                   "dtdiv", "tddiv", "tzExpr", "ntz", "ltz" ]

    EOF = Token.EOF
    T__0=1
    T__1=2
    T__2=3
    T__3=4
    T__4=5
    T__5=6
    T__6=7
    T__7=8
    T__8=9
    T__9=10
    T__10=11
    T__11=12
    T__12=13
    T__13=14
    T__14=15
    T__15=16
    T__16=17
    T__17=18
    T__18=19
    T__19=20
    T__20=21
    T__21=22
    T__22=23
    T__23=24
    T__24=25
    T__25=26
    SPACE=27
    COMMENT=28
    THE=29
    DASH=30
    PLUS=31
    SLASH=32
    DOT=33
    COLON=34
    MONTH_NAME=35
    JAN=36
    FEB=37
    MAR=38
    APR=39
    MAY=40
    JUN=41
    JUL=42
    AUG=43
    SEP=44
    OCT=45
    NOV=46
    DEC=47
    WEEKDAY=48
    SUN=49
    MON=50
    TUE=51
    WED=52
    THU=53
    FRI=54
    SAT=55
    WEEK=56
    DAY=57
    HOUR=58
    MINUTE=59
    SECOND=60
    MONTH=61
    YEAR=62
    SPECIAL_DATE=63
    SPECIAL_TIME=64
    NOON=65
    MIDNIGHT=66
    TODAY=67
    YESTERDAY=68
    TOMORROW=69
    EASTER=70
    NEW_YEARS_DAY=71
    NEW_YEARS_EVE=72
    CHRISTMAS=73
    CHRISTMAS_EVE=74
    MARTIN_LUTHER_KING_DAY=75
    MEMORIAL_DAY=76
    INDEPENDENCE_DAY=77
    LABOR_DAY=78
    PRESIDENTS_DAY=79
    COLUMBUS_DAY=80
    VETERANS_DAY=81
    HALLOWEEN=82
    THANKSGIVING_DAY=83
    FIRST=84
    LAST=85
    THIS=86
    NEXT=87
    AGO_FROM_NOW=88
    AGO=89
    FROM_NOW=90
    BEFORE=91
    AFTER=92
    DELTA_TIME_FRACTION=93
    DIGIT=94
    IDES=95
    NONES=96
    KALENDS=97
    WORKDAY=98
    UPPERCASE_STRING=99

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




    class ParseContext(ParserRuleContext):

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

        def dateExpr(self):
            return self.getTypedRuleContext(dateparse_utilsParser.DateExprContext,0)


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

        def timeExpr(self):
            return self.getTypedRuleContext(dateparse_utilsParser.TimeExprContext,0)


        def dtdiv(self):
            return self.getTypedRuleContext(dateparse_utilsParser.DtdivContext,0)


        def tddiv(self):
            return self.getTypedRuleContext(dateparse_utilsParser.TddivContext,0)


        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_parse

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

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




    def parse(self):

        localctx = dateparse_utilsParser.ParseContext(self, self._ctx, self.state)
        self.enterRule(localctx, 0, self.RULE_parse)
        self._la = 0 # Token type
        try:
            self.state = 171
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,10,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 113
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==dateparse_utilsParser.SPACE:
                    self.state = 110
                    self.match(dateparse_utilsParser.SPACE)
                    self.state = 115
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 116
                self.dateExpr()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 120
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==dateparse_utilsParser.SPACE:
                    self.state = 117
                    self.match(dateparse_utilsParser.SPACE)
                    self.state = 122
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 123
                self.timeExpr()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 127
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==dateparse_utilsParser.SPACE:
                    self.state = 124
                    self.match(dateparse_utilsParser.SPACE)
                    self.state = 129
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 130
                self.dateExpr()
                self.state = 134
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,3,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 131
                        self.match(dateparse_utilsParser.SPACE) 
                    self.state = 136
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,3,self._ctx)

                self.state = 138
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << dateparse_utilsParser.T__18) | (1 << dateparse_utilsParser.T__19) | (1 << dateparse_utilsParser.T__20) | (1 << dateparse_utilsParser.T__21) | (1 << dateparse_utilsParser.T__22) | (1 << dateparse_utilsParser.T__23))) != 0):
                    self.state = 137
                    self.dtdiv()


                self.state = 143
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==dateparse_utilsParser.SPACE:
                    self.state = 140
                    self.match(dateparse_utilsParser.SPACE)
                    self.state = 145
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 146
                self.timeExpr()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 151
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while _la==dateparse_utilsParser.SPACE:
                    self.state = 148
                    self.match(dateparse_utilsParser.SPACE)
                    self.state = 153
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)

                self.state = 154
                self.timeExpr()
                self.state = 158
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,7,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 155
                        self.match(dateparse_utilsParser.SPACE) 
                    self.state = 160
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,7,self._ctx)

                self.state = 162
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << dateparse_utilsParser.T__18) | (1 << dateparse_utilsParser.T__23) | (1 << dateparse_utilsParser.T__24) | (1 << dateparse_utilsParser.T__25))) != 0):
                    self.state = 161
                    self.tddiv()


                self.state = 165 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 164
                    self.match(dateparse_utilsParser.SPACE)
                    self.state = 167 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==dateparse_utilsParser.SPACE):
                        break

                self.state = 169
                self.dateExpr()
                pass


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


    class DateExprContext(ParserRuleContext):

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

        def singleDateExpr(self):
            return self.getTypedRuleContext(dateparse_utilsParser.SingleDateExprContext,0)


        def baseAndOffsetDateExpr(self):
            return self.getTypedRuleContext(dateparse_utilsParser.BaseAndOffsetDateExprContext,0)


        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_dateExpr

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

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




    def dateExpr(self):

        localctx = dateparse_utilsParser.DateExprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 2, self.RULE_dateExpr)
        try:
            self.state = 175
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,11,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 173
                self.singleDateExpr()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 174
                self.baseAndOffsetDateExpr()
                pass


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


    class TimeExprContext(ParserRuleContext):

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

        def singleTimeExpr(self):
            return self.getTypedRuleContext(dateparse_utilsParser.SingleTimeExprContext,0)


        def baseAndOffsetTimeExpr(self):
            return self.getTypedRuleContext(dateparse_utilsParser.BaseAndOffsetTimeExprContext,0)


        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_timeExpr

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

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




    def timeExpr(self):

        localctx = dateparse_utilsParser.TimeExprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 4, self.RULE_timeExpr)
        try:
            self.state = 179
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,12,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 177
                self.singleTimeExpr()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 178
                self.baseAndOffsetTimeExpr()
                pass


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


    class SingleTimeExprContext(ParserRuleContext):

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

        def twentyFourHourTimeExpr(self):
            return self.getTypedRuleContext(dateparse_utilsParser.TwentyFourHourTimeExprContext,0)


        def twelveHourTimeExpr(self):
            return self.getTypedRuleContext(dateparse_utilsParser.TwelveHourTimeExprContext,0)


        def specialTimeExpr(self):
            return self.getTypedRuleContext(dateparse_utilsParser.SpecialTimeExprContext,0)


        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_singleTimeExpr

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

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




    def singleTimeExpr(self):

        localctx = dateparse_utilsParser.SingleTimeExprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 6, self.RULE_singleTimeExpr)
        try:
            self.state = 184
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,13,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 181
                self.twentyFourHourTimeExpr()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 182
                self.twelveHourTimeExpr()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 183
                self.specialTimeExpr()
                pass


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


    class TwentyFourHourTimeExprContext(ParserRuleContext):

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

        def hour(self):
            return self.getTypedRuleContext(dateparse_utilsParser.HourContext,0)


        def minute(self):
            return self.getTypedRuleContext(dateparse_utilsParser.MinuteContext,0)


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

        def tzExpr(self):
            return self.getTypedRuleContext(dateparse_utilsParser.TzExprContext,0)


        def tdiv(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(dateparse_utilsParser.TdivContext)
            else:
                return self.getTypedRuleContext(dateparse_utilsParser.TdivContext,i)


        def second(self):
            return self.getTypedRuleContext(dateparse_utilsParser.SecondContext,0)


        def micros(self):
            return self.getTypedRuleContext(dateparse_utilsParser.MicrosContext,0)


        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_twentyFourHourTimeExpr

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

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




    def twentyFourHourTimeExpr(self):

        localctx = dateparse_utilsParser.TwentyFourHourTimeExprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 8, self.RULE_twentyFourHourTimeExpr)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 186
            self.hour()
            self.state = 212
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,22,self._ctx)
            if la_ == 1:
                self.state = 189 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 189
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [dateparse_utilsParser.SPACE]:
                        self.state = 187
                        self.match(dateparse_utilsParser.SPACE)
                        pass
                    elif token in [dateparse_utilsParser.DOT, dateparse_utilsParser.COLON]:
                        self.state = 188
                        self.tdiv()
                        pass
                    else:
                        raise NoViableAltException(self)

                    self.state = 191 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << dateparse_utilsParser.SPACE) | (1 << dateparse_utilsParser.DOT) | (1 << dateparse_utilsParser.COLON))) != 0)):
                        break

                self.state = 193
                self.minute()
                self.state = 210
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,21,self._ctx)
                if la_ == 1:
                    self.state = 196 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while True:
                        self.state = 196
                        self._errHandler.sync(self)
                        token = self._input.LA(1)
                        if token in [dateparse_utilsParser.SPACE]:
                            self.state = 194
                            self.match(dateparse_utilsParser.SPACE)
                            pass
                        elif token in [dateparse_utilsParser.DOT, dateparse_utilsParser.COLON]:
                            self.state = 195
                            self.tdiv()
                            pass
                        else:
                            raise NoViableAltException(self)

                        self.state = 198 
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << dateparse_utilsParser.SPACE) | (1 << dateparse_utilsParser.DOT) | (1 << dateparse_utilsParser.COLON))) != 0)):
                            break

                    self.state = 200
                    self.second()
                    self.state = 208
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,20,self._ctx)
                    if la_ == 1:
                        self.state = 203 
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while True:
                            self.state = 203
                            self._errHandler.sync(self)
                            token = self._input.LA(1)
                            if token in [dateparse_utilsParser.SPACE]:
                                self.state = 201
                                self.match(dateparse_utilsParser.SPACE)
                                pass
                            elif token in [dateparse_utilsParser.DOT, dateparse_utilsParser.COLON]:
                                self.state = 202
                                self.tdiv()
                                pass
                            else:
                                raise NoViableAltException(self)

                            self.state = 205 
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)
                            if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << dateparse_utilsParser.SPACE) | (1 << dateparse_utilsParser.DOT) | (1 << dateparse_utilsParser.COLON))) != 0)):
                                break

                        self.state = 207
                        self.micros()






            self.state = 217
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,23,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 214
                    self.match(dateparse_utilsParser.SPACE) 
                self.state = 219
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,23,self._ctx)

            self.state = 221
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,24,self._ctx)
            if la_ == 1:
                self.state = 220
                self.tzExpr()


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


    class TwelveHourTimeExprContext(ParserRuleContext):

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

        def hour(self):
            return self.getTypedRuleContext(dateparse_utilsParser.HourContext,0)


        def ampm(self):
            return self.getTypedRuleContext(dateparse_utilsParser.AmpmContext,0)


        def minute(self):
            return self.getTypedRuleContext(dateparse_utilsParser.MinuteContext,0)


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

        def tzExpr(self):
            return self.getTypedRuleContext(dateparse_utilsParser.TzExprContext,0)


        def tdiv(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(dateparse_utilsParser.TdivContext)
            else:
                return self.getTypedRuleContext(dateparse_utilsParser.TdivContext,i)


        def second(self):
            return self.getTypedRuleContext(dateparse_utilsParser.SecondContext,0)


        def micros(self):
            return self.getTypedRuleContext(dateparse_utilsParser.MicrosContext,0)


        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_twelveHourTimeExpr

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

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




    def twelveHourTimeExpr(self):

        localctx = dateparse_utilsParser.TwelveHourTimeExprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 10, self.RULE_twelveHourTimeExpr)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 223
            self.hour()
            self.state = 249
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,33,self._ctx)
            if la_ == 1:
                self.state = 226 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 226
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [dateparse_utilsParser.SPACE]:
                        self.state = 224
                        self.match(dateparse_utilsParser.SPACE)
                        pass
                    elif token in [dateparse_utilsParser.DOT, dateparse_utilsParser.COLON]:
                        self.state = 225
                        self.tdiv()
                        pass
                    else:
                        raise NoViableAltException(self)

                    self.state = 228 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << dateparse_utilsParser.SPACE) | (1 << dateparse_utilsParser.DOT) | (1 << dateparse_utilsParser.COLON))) != 0)):
                        break

                self.state = 230
                self.minute()
                self.state = 247
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,32,self._ctx)
                if la_ == 1:
                    self.state = 233 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while True:
                        self.state = 233
                        self._errHandler.sync(self)
                        token = self._input.LA(1)
                        if token in [dateparse_utilsParser.SPACE]:
                            self.state = 231
                            self.match(dateparse_utilsParser.SPACE)
                            pass
                        elif token in [dateparse_utilsParser.DOT, dateparse_utilsParser.COLON]:
                            self.state = 232
                            self.tdiv()
                            pass
                        else:
                            raise NoViableAltException(self)

                        self.state = 235 
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << dateparse_utilsParser.SPACE) | (1 << dateparse_utilsParser.DOT) | (1 << dateparse_utilsParser.COLON))) != 0)):
                            break

                    self.state = 237
                    self.second()
                    self.state = 245
                    self._errHandler.sync(self)
                    la_ = self._interp.adaptivePredict(self._input,31,self._ctx)
                    if la_ == 1:
                        self.state = 240 
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        while True:
                            self.state = 240
                            self._errHandler.sync(self)
                            token = self._input.LA(1)
                            if token in [dateparse_utilsParser.SPACE]:
                                self.state = 238
                                self.match(dateparse_utilsParser.SPACE)
                                pass
                            elif token in [dateparse_utilsParser.DOT, dateparse_utilsParser.COLON]:
                                self.state = 239
                                self.tdiv()
                                pass
                            else:
                                raise NoViableAltException(self)

                            self.state = 242 
                            self._errHandler.sync(self)
                            _la = self._input.LA(1)
                            if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << dateparse_utilsParser.SPACE) | (1 << dateparse_utilsParser.DOT) | (1 << dateparse_utilsParser.COLON))) != 0)):
                                break

                        self.state = 244
                        self.micros()






            self.state = 254
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while _la==dateparse_utilsParser.SPACE:
                self.state = 251
                self.match(dateparse_utilsParser.SPACE)
                self.state = 256
                self._errHandler.sync(self)
                _la = self._input.LA(1)

            self.state = 257
            self.ampm()
            self.state = 261
            self._errHandler.sync(self)
            _alt = self._interp.adaptivePredict(self._input,35,self._ctx)
            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                if _alt==1:
                    self.state = 258
                    self.match(dateparse_utilsParser.SPACE) 
                self.state = 263
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,35,self._ctx)

            self.state = 265
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,36,self._ctx)
            if la_ == 1:
                self.state = 264
                self.tzExpr()


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


    class AmpmContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_ampm

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

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




    def ampm(self):

        localctx = dateparse_utilsParser.AmpmContext(self, self._ctx, self.state)
        self.enterRule(localctx, 12, self.RULE_ampm)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 267
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << dateparse_utilsParser.T__0) | (1 << dateparse_utilsParser.T__1) | (1 << dateparse_utilsParser.T__2) | (1 << dateparse_utilsParser.T__3) | (1 << dateparse_utilsParser.T__4) | (1 << dateparse_utilsParser.T__5) | (1 << dateparse_utilsParser.T__6) | (1 << dateparse_utilsParser.T__7))) != 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 SingleDateExprContext(ParserRuleContext):

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

        def monthDayMaybeYearExpr(self):
            return self.getTypedRuleContext(dateparse_utilsParser.MonthDayMaybeYearExprContext,0)


        def dayMonthMaybeYearExpr(self):
            return self.getTypedRuleContext(dateparse_utilsParser.DayMonthMaybeYearExprContext,0)


        def yearMonthDayExpr(self):
            return self.getTypedRuleContext(dateparse_utilsParser.YearMonthDayExprContext,0)


        def specialDateMaybeYearExpr(self):
            return self.getTypedRuleContext(dateparse_utilsParser.SpecialDateMaybeYearExprContext,0)


        def nthWeekdayInMonthMaybeYearExpr(self):
            return self.getTypedRuleContext(dateparse_utilsParser.NthWeekdayInMonthMaybeYearExprContext,0)


        def firstLastWeekdayInMonthMaybeYearExpr(self):
            return self.getTypedRuleContext(dateparse_utilsParser.FirstLastWeekdayInMonthMaybeYearExprContext,0)


        def deltaDateExprRelativeToTodayImplied(self):
            return self.getTypedRuleContext(dateparse_utilsParser.DeltaDateExprRelativeToTodayImpliedContext,0)


        def dayName(self):
            return self.getTypedRuleContext(dateparse_utilsParser.DayNameContext,0)


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

        def ddiv(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(dateparse_utilsParser.DdivContext)
            else:
                return self.getTypedRuleContext(dateparse_utilsParser.DdivContext,i)


        def singleTimeExpr(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(dateparse_utilsParser.SingleTimeExprContext)
            else:
                return self.getTypedRuleContext(dateparse_utilsParser.SingleTimeExprContext,i)


        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_singleDateExpr

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

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




    def singleDateExpr(self):

        localctx = dateparse_utilsParser.SingleDateExprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 14, self.RULE_singleDateExpr)
        self._la = 0 # Token type
        try:
            self.state = 298
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,42,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 269
                self.monthDayMaybeYearExpr()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 270
                self.dayMonthMaybeYearExpr()
                pass

            elif la_ == 3:
                self.enterOuterAlt(localctx, 3)
                self.state = 271
                self.yearMonthDayExpr()
                pass

            elif la_ == 4:
                self.enterOuterAlt(localctx, 4)
                self.state = 272
                self.specialDateMaybeYearExpr()
                pass

            elif la_ == 5:
                self.enterOuterAlt(localctx, 5)
                self.state = 273
                self.nthWeekdayInMonthMaybeYearExpr()
                pass

            elif la_ == 6:
                self.enterOuterAlt(localctx, 6)
                self.state = 274
                self.firstLastWeekdayInMonthMaybeYearExpr()
                pass

            elif la_ == 7:
                self.enterOuterAlt(localctx, 7)
                self.state = 275
                self.deltaDateExprRelativeToTodayImplied()
                pass

            elif la_ == 8:
                self.enterOuterAlt(localctx, 8)
                self.state = 276
                self.dayName()
                self.state = 279 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 279
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [dateparse_utilsParser.SPACE]:
                        self.state = 277
                        self.match(dateparse_utilsParser.SPACE)
                        pass
                    elif token in [dateparse_utilsParser.T__18, dateparse_utilsParser.DASH, dateparse_utilsParser.SLASH]:
                        self.state = 278
                        self.ddiv()
                        pass
                    else:
                        raise NoViableAltException(self)

                    self.state = 281 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << dateparse_utilsParser.T__18) | (1 << dateparse_utilsParser.SPACE) | (1 << dateparse_utilsParser.DASH) | (1 << dateparse_utilsParser.SLASH))) != 0)):
                        break

                self.state = 283
                self.monthDayMaybeYearExpr()
                self.state = 288
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,40,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 286
                        self._errHandler.sync(self)
                        token = self._input.LA(1)
                        if token in [dateparse_utilsParser.SPACE]:
                            self.state = 284
                            self.match(dateparse_utilsParser.SPACE)
                            pass
                        elif token in [dateparse_utilsParser.T__18, dateparse_utilsParser.DASH, dateparse_utilsParser.SLASH]:
                            self.state = 285
                            self.ddiv()
                            pass
                        else:
                            raise NoViableAltException(self)
                 
                    self.state = 290
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,40,self._ctx)

                self.state = 294
                self._errHandler.sync(self)
                _alt = self._interp.adaptivePredict(self._input,41,self._ctx)
                while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                    if _alt==1:
                        self.state = 291
                        self.singleTimeExpr() 
                    self.state = 296
                    self._errHandler.sync(self)
                    _alt = self._interp.adaptivePredict(self._input,41,self._ctx)

                pass

            elif la_ == 9:
                self.enterOuterAlt(localctx, 9)
                self.state = 297
                self.dayName()
                pass


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


    class MonthDayMaybeYearExprContext(ParserRuleContext):

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

        def monthExpr(self):
            return self.getTypedRuleContext(dateparse_utilsParser.MonthExprContext,0)


        def dayOfMonth(self):
            return self.getTypedRuleContext(dateparse_utilsParser.DayOfMonthContext,0)


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

        def ddiv(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(dateparse_utilsParser.DdivContext)
            else:
                return self.getTypedRuleContext(dateparse_utilsParser.DdivContext,i)


        def year(self):
            return self.getTypedRuleContext(dateparse_utilsParser.YearContext,0)


        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_monthDayMaybeYearExpr

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

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




    def monthDayMaybeYearExpr(self):

        localctx = dateparse_utilsParser.MonthDayMaybeYearExprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 16, self.RULE_monthDayMaybeYearExpr)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 300
            self.monthExpr()
            self.state = 303 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 303
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [dateparse_utilsParser.SPACE]:
                    self.state = 301
                    self.match(dateparse_utilsParser.SPACE)
                    pass
                elif token in [dateparse_utilsParser.T__18, dateparse_utilsParser.DASH, dateparse_utilsParser.SLASH]:
                    self.state = 302
                    self.ddiv()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 305 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << dateparse_utilsParser.T__18) | (1 << dateparse_utilsParser.SPACE) | (1 << dateparse_utilsParser.DASH) | (1 << dateparse_utilsParser.SLASH))) != 0)):
                    break

            self.state = 307
            self.dayOfMonth()
            self.state = 315
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,47,self._ctx)
            if la_ == 1:
                self.state = 310 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 310
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [dateparse_utilsParser.SPACE]:
                        self.state = 308
                        self.match(dateparse_utilsParser.SPACE)
                        pass
                    elif token in [dateparse_utilsParser.T__18, dateparse_utilsParser.DASH, dateparse_utilsParser.SLASH]:
                        self.state = 309
                        self.ddiv()
                        pass
                    else:
                        raise NoViableAltException(self)

                    self.state = 312 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << dateparse_utilsParser.T__18) | (1 << dateparse_utilsParser.SPACE) | (1 << dateparse_utilsParser.DASH) | (1 << dateparse_utilsParser.SLASH))) != 0)):
                        break

                self.state = 314
                self.year()


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


    class DayMonthMaybeYearExprContext(ParserRuleContext):

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

        def dayOfMonth(self):
            return self.getTypedRuleContext(dateparse_utilsParser.DayOfMonthContext,0)


        def monthName(self):
            return self.getTypedRuleContext(dateparse_utilsParser.MonthNameContext,0)


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

        def ddiv(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(dateparse_utilsParser.DdivContext)
            else:
                return self.getTypedRuleContext(dateparse_utilsParser.DdivContext,i)


        def year(self):
            return self.getTypedRuleContext(dateparse_utilsParser.YearContext,0)


        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_dayMonthMaybeYearExpr

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

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




    def dayMonthMaybeYearExpr(self):

        localctx = dateparse_utilsParser.DayMonthMaybeYearExprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 18, self.RULE_dayMonthMaybeYearExpr)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 317
            self.dayOfMonth()
            self.state = 320 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 320
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [dateparse_utilsParser.SPACE]:
                    self.state = 318
                    self.match(dateparse_utilsParser.SPACE)
                    pass
                elif token in [dateparse_utilsParser.T__18, dateparse_utilsParser.DASH, dateparse_utilsParser.SLASH]:
                    self.state = 319
                    self.ddiv()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 322 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << dateparse_utilsParser.T__18) | (1 << dateparse_utilsParser.SPACE) | (1 << dateparse_utilsParser.DASH) | (1 << dateparse_utilsParser.SLASH))) != 0)):
                    break

            self.state = 324
            self.monthName()
            self.state = 332
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,52,self._ctx)
            if la_ == 1:
                self.state = 327 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 327
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [dateparse_utilsParser.SPACE]:
                        self.state = 325
                        self.match(dateparse_utilsParser.SPACE)
                        pass
                    elif token in [dateparse_utilsParser.T__18, dateparse_utilsParser.DASH, dateparse_utilsParser.SLASH]:
                        self.state = 326
                        self.ddiv()
                        pass
                    else:
                        raise NoViableAltException(self)

                    self.state = 329 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << dateparse_utilsParser.T__18) | (1 << dateparse_utilsParser.SPACE) | (1 << dateparse_utilsParser.DASH) | (1 << dateparse_utilsParser.SLASH))) != 0)):
                        break

                self.state = 331
                self.year()


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


    class YearMonthDayExprContext(ParserRuleContext):

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

        def year(self):
            return self.getTypedRuleContext(dateparse_utilsParser.YearContext,0)


        def monthExpr(self):
            return self.getTypedRuleContext(dateparse_utilsParser.MonthExprContext,0)


        def dayOfMonth(self):
            return self.getTypedRuleContext(dateparse_utilsParser.DayOfMonthContext,0)


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

        def ddiv(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(dateparse_utilsParser.DdivContext)
            else:
                return self.getTypedRuleContext(dateparse_utilsParser.DdivContext,i)


        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_yearMonthDayExpr

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

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




    def yearMonthDayExpr(self):

        localctx = dateparse_utilsParser.YearMonthDayExprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 20, self.RULE_yearMonthDayExpr)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 334
            self.year()
            self.state = 337 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 337
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [dateparse_utilsParser.SPACE]:
                    self.state = 335
                    self.match(dateparse_utilsParser.SPACE)
                    pass
                elif token in [dateparse_utilsParser.T__18, dateparse_utilsParser.DASH, dateparse_utilsParser.SLASH]:
                    self.state = 336
                    self.ddiv()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 339 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << dateparse_utilsParser.T__18) | (1 << dateparse_utilsParser.SPACE) | (1 << dateparse_utilsParser.DASH) | (1 << dateparse_utilsParser.SLASH))) != 0)):
                    break

            self.state = 341
            self.monthExpr()
            self.state = 344 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 344
                self._errHandler.sync(self)
                token = self._input.LA(1)
                if token in [dateparse_utilsParser.SPACE]:
                    self.state = 342
                    self.match(dateparse_utilsParser.SPACE)
                    pass
                elif token in [dateparse_utilsParser.T__18, dateparse_utilsParser.DASH, dateparse_utilsParser.SLASH]:
                    self.state = 343
                    self.ddiv()
                    pass
                else:
                    raise NoViableAltException(self)

                self.state = 346 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << dateparse_utilsParser.T__18) | (1 << dateparse_utilsParser.SPACE) | (1 << dateparse_utilsParser.DASH) | (1 << dateparse_utilsParser.SLASH))) != 0)):
                    break

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


    class NthWeekdayInMonthMaybeYearExprContext(ParserRuleContext):

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

        def nth(self):
            return self.getTypedRuleContext(dateparse_utilsParser.NthContext,0)


        def dayName(self):
            return self.getTypedRuleContext(dateparse_utilsParser.DayNameContext,0)


        def monthName(self):
            return self.getTypedRuleContext(dateparse_utilsParser.MonthNameContext,0)


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

        def year(self):
            return self.getTypedRuleContext(dateparse_utilsParser.YearContext,0)


        def ddiv(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(dateparse_utilsParser.DdivContext)
            else:
                return self.getTypedRuleContext(dateparse_utilsParser.DdivContext,i)


        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_nthWeekdayInMonthMaybeYearExpr

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

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




    def nthWeekdayInMonthMaybeYearExpr(self):

        localctx = dateparse_utilsParser.NthWeekdayInMonthMaybeYearExprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 22, self.RULE_nthWeekdayInMonthMaybeYearExpr)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 350
            self.nth()
            self.state = 352 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 351
                self.match(dateparse_utilsParser.SPACE)
                self.state = 354 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==dateparse_utilsParser.SPACE):
                    break

            self.state = 356
            self.dayName()
            self.state = 358 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 357
                self.match(dateparse_utilsParser.SPACE)
                self.state = 360 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==dateparse_utilsParser.SPACE):
                    break

            self.state = 362
            _la = self._input.LA(1)
            if not(_la==dateparse_utilsParser.T__8 or _la==dateparse_utilsParser.T__9):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 364 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 363
                self.match(dateparse_utilsParser.SPACE)
                self.state = 366 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==dateparse_utilsParser.SPACE):
                    break

            self.state = 368
            self.monthName()
            self.state = 376
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,62,self._ctx)
            if la_ == 1:
                self.state = 371 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 371
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [dateparse_utilsParser.T__18, dateparse_utilsParser.DASH, dateparse_utilsParser.SLASH]:
                        self.state = 369
                        self.ddiv()
                        pass
                    elif token in [dateparse_utilsParser.SPACE]:
                        self.state = 370
                        self.match(dateparse_utilsParser.SPACE)
                        pass
                    else:
                        raise NoViableAltException(self)

                    self.state = 373 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << dateparse_utilsParser.T__18) | (1 << dateparse_utilsParser.SPACE) | (1 << dateparse_utilsParser.DASH) | (1 << dateparse_utilsParser.SLASH))) != 0)):
                        break

                self.state = 375
                self.year()


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


    class FirstLastWeekdayInMonthMaybeYearExprContext(ParserRuleContext):

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

        def firstOrLast(self):
            return self.getTypedRuleContext(dateparse_utilsParser.FirstOrLastContext,0)


        def dayName(self):
            return self.getTypedRuleContext(dateparse_utilsParser.DayNameContext,0)


        def monthName(self):
            return self.getTypedRuleContext(dateparse_utilsParser.MonthNameContext,0)


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

        def year(self):
            return self.getTypedRuleContext(dateparse_utilsParser.YearContext,0)


        def ddiv(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(dateparse_utilsParser.DdivContext)
            else:
                return self.getTypedRuleContext(dateparse_utilsParser.DdivContext,i)


        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_firstLastWeekdayInMonthMaybeYearExpr

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

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




    def firstLastWeekdayInMonthMaybeYearExpr(self):

        localctx = dateparse_utilsParser.FirstLastWeekdayInMonthMaybeYearExprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 24, self.RULE_firstLastWeekdayInMonthMaybeYearExpr)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 378
            self.firstOrLast()
            self.state = 380 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 379
                self.match(dateparse_utilsParser.SPACE)
                self.state = 382 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==dateparse_utilsParser.SPACE):
                    break

            self.state = 384
            self.dayName()
            self.state = 391
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,65,self._ctx)
            if la_ == 1:
                self.state = 386 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 385
                    self.match(dateparse_utilsParser.SPACE)
                    self.state = 388 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==dateparse_utilsParser.SPACE):
                        break

                self.state = 390
                _la = self._input.LA(1)
                if not(_la==dateparse_utilsParser.T__8 or _la==dateparse_utilsParser.T__9):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 394 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 393
                self.match(dateparse_utilsParser.SPACE)
                self.state = 396 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==dateparse_utilsParser.SPACE):
                    break

            self.state = 398
            self.monthName()
            self.state = 406
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,69,self._ctx)
            if la_ == 1:
                self.state = 401 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 401
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [dateparse_utilsParser.T__18, dateparse_utilsParser.DASH, dateparse_utilsParser.SLASH]:
                        self.state = 399
                        self.ddiv()
                        pass
                    elif token in [dateparse_utilsParser.SPACE]:
                        self.state = 400
                        self.match(dateparse_utilsParser.SPACE)
                        pass
                    else:
                        raise NoViableAltException(self)

                    self.state = 403 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << dateparse_utilsParser.T__18) | (1 << dateparse_utilsParser.SPACE) | (1 << dateparse_utilsParser.DASH) | (1 << dateparse_utilsParser.SLASH))) != 0)):
                        break

                self.state = 405
                self.year()


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


    class SpecialDateMaybeYearExprContext(ParserRuleContext):

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

        def specialDate(self):
            return self.getTypedRuleContext(dateparse_utilsParser.SpecialDateContext,0)


        def thisNextLast(self):
            return self.getTypedRuleContext(dateparse_utilsParser.ThisNextLastContext,0)


        def year(self):
            return self.getTypedRuleContext(dateparse_utilsParser.YearContext,0)


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

        def ddiv(self, i:int=None):
            if i is None:
                return self.getTypedRuleContexts(dateparse_utilsParser.DdivContext)
            else:
                return self.getTypedRuleContext(dateparse_utilsParser.DdivContext,i)


        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_specialDateMaybeYearExpr

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

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




    def specialDateMaybeYearExpr(self):

        localctx = dateparse_utilsParser.SpecialDateMaybeYearExprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 26, self.RULE_specialDateMaybeYearExpr)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 414
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if ((((_la - 85)) & ~0x3f) == 0 and ((1 << (_la - 85)) & ((1 << (dateparse_utilsParser.LAST - 85)) | (1 << (dateparse_utilsParser.THIS - 85)) | (1 << (dateparse_utilsParser.NEXT - 85)))) != 0):
                self.state = 408
                self.thisNextLast()
                self.state = 410 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 409
                    self.match(dateparse_utilsParser.SPACE)
                    self.state = 412 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==dateparse_utilsParser.SPACE):
                        break



            self.state = 416
            self.specialDate()
            self.state = 424
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,74,self._ctx)
            if la_ == 1:
                self.state = 419 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 419
                    self._errHandler.sync(self)
                    token = self._input.LA(1)
                    if token in [dateparse_utilsParser.SPACE]:
                        self.state = 417
                        self.match(dateparse_utilsParser.SPACE)
                        pass
                    elif token in [dateparse_utilsParser.T__18, dateparse_utilsParser.DASH, dateparse_utilsParser.SLASH]:
                        self.state = 418
                        self.ddiv()
                        pass
                    else:
                        raise NoViableAltException(self)

                    self.state = 421 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << dateparse_utilsParser.T__18) | (1 << dateparse_utilsParser.SPACE) | (1 << dateparse_utilsParser.DASH) | (1 << dateparse_utilsParser.SLASH))) != 0)):
                        break

                self.state = 423
                self.year()


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


    class ThisNextLastContext(ParserRuleContext):

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

        def THIS(self):
            return self.getToken(dateparse_utilsParser.THIS, 0)

        def NEXT(self):
            return self.getToken(dateparse_utilsParser.NEXT, 0)

        def LAST(self):
            return self.getToken(dateparse_utilsParser.LAST, 0)

        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_thisNextLast

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

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




    def thisNextLast(self):

        localctx = dateparse_utilsParser.ThisNextLastContext(self, self._ctx, self.state)
        self.enterRule(localctx, 28, self.RULE_thisNextLast)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 426
            _la = self._input.LA(1)
            if not(((((_la - 85)) & ~0x3f) == 0 and ((1 << (_la - 85)) & ((1 << (dateparse_utilsParser.LAST - 85)) | (1 << (dateparse_utilsParser.THIS - 85)) | (1 << (dateparse_utilsParser.NEXT - 85)))) != 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 BaseAndOffsetDateExprContext(ParserRuleContext):

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

        def baseDate(self):
            return self.getTypedRuleContext(dateparse_utilsParser.BaseDateContext,0)


        def deltaPlusMinusExpr(self):
            return self.getTypedRuleContext(dateparse_utilsParser.DeltaPlusMinusExprContext,0)


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

        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_baseAndOffsetDateExpr

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

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




    def baseAndOffsetDateExpr(self):

        localctx = dateparse_utilsParser.BaseAndOffsetDateExprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 30, self.RULE_baseAndOffsetDateExpr)
        self._la = 0 # Token type
        try:
            self.state = 444
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,77,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 428
                self.baseDate()
                self.state = 430 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 429
                    self.match(dateparse_utilsParser.SPACE)
                    self.state = 432 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==dateparse_utilsParser.SPACE):
                        break

                self.state = 434
                self.deltaPlusMinusExpr()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 436
                self.deltaPlusMinusExpr()
                self.state = 438 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 437
                    self.match(dateparse_utilsParser.SPACE)
                    self.state = 440 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==dateparse_utilsParser.SPACE):
                        break

                self.state = 442
                self.baseDate()
                pass


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


    class DeltaDateExprRelativeToTodayImpliedContext(ParserRuleContext):

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

        def nFoosFromTodayAgoExpr(self):
            return self.getTypedRuleContext(dateparse_utilsParser.NFoosFromTodayAgoExprContext,0)


        def deltaRelativeToTodayExpr(self):
            return self.getTypedRuleContext(dateparse_utilsParser.DeltaRelativeToTodayExprContext,0)


        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_deltaDateExprRelativeToTodayImplied

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

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




    def deltaDateExprRelativeToTodayImplied(self):

        localctx = dateparse_utilsParser.DeltaDateExprRelativeToTodayImpliedContext(self, self._ctx, self.state)
        self.enterRule(localctx, 32, self.RULE_deltaDateExprRelativeToTodayImplied)
        try:
            self.state = 448
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [dateparse_utilsParser.DIGIT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 446
                self.nFoosFromTodayAgoExpr()
                pass
            elif token in [dateparse_utilsParser.LAST, dateparse_utilsParser.THIS, dateparse_utilsParser.NEXT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 447
                self.deltaRelativeToTodayExpr()
                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 DeltaRelativeToTodayExprContext(ParserRuleContext):

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

        def thisNextLast(self):
            return self.getTypedRuleContext(dateparse_utilsParser.ThisNextLastContext,0)


        def deltaUnit(self):
            return self.getTypedRuleContext(dateparse_utilsParser.DeltaUnitContext,0)


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

        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_deltaRelativeToTodayExpr

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

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




    def deltaRelativeToTodayExpr(self):

        localctx = dateparse_utilsParser.DeltaRelativeToTodayExprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 34, self.RULE_deltaRelativeToTodayExpr)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 450
            self.thisNextLast()
            self.state = 452 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 451
                self.match(dateparse_utilsParser.SPACE)
                self.state = 454 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==dateparse_utilsParser.SPACE):
                    break

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


    class NFoosFromTodayAgoExprContext(ParserRuleContext):

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

        def unsignedInt(self):
            return self.getTypedRuleContext(dateparse_utilsParser.UnsignedIntContext,0)


        def deltaUnit(self):
            return self.getTypedRuleContext(dateparse_utilsParser.DeltaUnitContext,0)


        def AGO_FROM_NOW(self):
            return self.getToken(dateparse_utilsParser.AGO_FROM_NOW, 0)

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

        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_nFoosFromTodayAgoExpr

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

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




    def nFoosFromTodayAgoExpr(self):

        localctx = dateparse_utilsParser.NFoosFromTodayAgoExprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 36, self.RULE_nFoosFromTodayAgoExpr)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 458
            self.unsignedInt()
            self.state = 460 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 459
                self.match(dateparse_utilsParser.SPACE)
                self.state = 462 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==dateparse_utilsParser.SPACE):
                    break

            self.state = 464
            self.deltaUnit()
            self.state = 466 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 465
                self.match(dateparse_utilsParser.SPACE)
                self.state = 468 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==dateparse_utilsParser.SPACE):
                    break

            self.state = 470
            self.match(dateparse_utilsParser.AGO_FROM_NOW)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BaseDateContext(ParserRuleContext):

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

        def singleDateExpr(self):
            return self.getTypedRuleContext(dateparse_utilsParser.SingleDateExprContext,0)


        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_baseDate

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

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




    def baseDate(self):

        localctx = dateparse_utilsParser.BaseDateContext(self, self._ctx, self.state)
        self.enterRule(localctx, 38, self.RULE_baseDate)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 472
            self.singleDateExpr()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class BaseAndOffsetTimeExprContext(ParserRuleContext):

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

        def deltaPlusMinusTimeExpr(self):
            return self.getTypedRuleContext(dateparse_utilsParser.DeltaPlusMinusTimeExprContext,0)


        def baseTime(self):
            return self.getTypedRuleContext(dateparse_utilsParser.BaseTimeContext,0)


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

        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_baseAndOffsetTimeExpr

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

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




    def baseAndOffsetTimeExpr(self):

        localctx = dateparse_utilsParser.BaseAndOffsetTimeExprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 40, self.RULE_baseAndOffsetTimeExpr)
        self._la = 0 # Token type
        try:
            self.state = 490
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,84,self._ctx)
            if la_ == 1:
                self.enterOuterAlt(localctx, 1)
                self.state = 474
                self.deltaPlusMinusTimeExpr()
                self.state = 476 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 475
                    self.match(dateparse_utilsParser.SPACE)
                    self.state = 478 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==dateparse_utilsParser.SPACE):
                        break

                self.state = 480
                self.baseTime()
                pass

            elif la_ == 2:
                self.enterOuterAlt(localctx, 2)
                self.state = 482
                self.baseTime()
                self.state = 484 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 483
                    self.match(dateparse_utilsParser.SPACE)
                    self.state = 486 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==dateparse_utilsParser.SPACE):
                        break

                self.state = 488
                self.deltaPlusMinusTimeExpr()
                pass


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


    class BaseTimeContext(ParserRuleContext):

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

        def singleTimeExpr(self):
            return self.getTypedRuleContext(dateparse_utilsParser.SingleTimeExprContext,0)


        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_baseTime

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

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




    def baseTime(self):

        localctx = dateparse_utilsParser.BaseTimeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 42, self.RULE_baseTime)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 492
            self.singleTimeExpr()
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DeltaPlusMinusExprContext(ParserRuleContext):

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

        def nth(self):
            return self.getTypedRuleContext(dateparse_utilsParser.NthContext,0)


        def deltaUnit(self):
            return self.getTypedRuleContext(dateparse_utilsParser.DeltaUnitContext,0)


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

        def deltaBeforeAfter(self):
            return self.getTypedRuleContext(dateparse_utilsParser.DeltaBeforeAfterContext,0)


        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_deltaPlusMinusExpr

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

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




    def deltaPlusMinusExpr(self):

        localctx = dateparse_utilsParser.DeltaPlusMinusExprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 44, self.RULE_deltaPlusMinusExpr)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 494
            self.nth()
            self.state = 496 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 495
                self.match(dateparse_utilsParser.SPACE)
                self.state = 498 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==dateparse_utilsParser.SPACE):
                    break

            self.state = 500
            self.deltaUnit()
            self.state = 507
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,87,self._ctx)
            if la_ == 1:
                self.state = 502 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 501
                    self.match(dateparse_utilsParser.SPACE)
                    self.state = 504 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==dateparse_utilsParser.SPACE):
                        break

                self.state = 506
                self.deltaBeforeAfter()


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


    class DeltaNextLastContext(ParserRuleContext):

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

        def NEXT(self):
            return self.getToken(dateparse_utilsParser.NEXT, 0)

        def LAST(self):
            return self.getToken(dateparse_utilsParser.LAST, 0)

        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_deltaNextLast

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

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




    def deltaNextLast(self):

        localctx = dateparse_utilsParser.DeltaNextLastContext(self, self._ctx, self.state)
        self.enterRule(localctx, 46, self.RULE_deltaNextLast)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 509
            _la = self._input.LA(1)
            if not(_la==dateparse_utilsParser.LAST or _la==dateparse_utilsParser.NEXT):
                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 DeltaPlusMinusTimeExprContext(ParserRuleContext):

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

        def countUnitsBeforeAfterTimeExpr(self):
            return self.getTypedRuleContext(dateparse_utilsParser.CountUnitsBeforeAfterTimeExprContext,0)


        def fractionBeforeAfterTimeExpr(self):
            return self.getTypedRuleContext(dateparse_utilsParser.FractionBeforeAfterTimeExprContext,0)


        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_deltaPlusMinusTimeExpr

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

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




    def deltaPlusMinusTimeExpr(self):

        localctx = dateparse_utilsParser.DeltaPlusMinusTimeExprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 48, self.RULE_deltaPlusMinusTimeExpr)
        try:
            self.state = 513
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [dateparse_utilsParser.DASH, dateparse_utilsParser.PLUS, dateparse_utilsParser.DIGIT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 511
                self.countUnitsBeforeAfterTimeExpr()
                pass
            elif token in [dateparse_utilsParser.DELTA_TIME_FRACTION]:
                self.enterOuterAlt(localctx, 2)
                self.state = 512
                self.fractionBeforeAfterTimeExpr()
                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 CountUnitsBeforeAfterTimeExprContext(ParserRuleContext):

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

        def nth(self):
            return self.getTypedRuleContext(dateparse_utilsParser.NthContext,0)


        def deltaTimeBeforeAfter(self):
            return self.getTypedRuleContext(dateparse_utilsParser.DeltaTimeBeforeAfterContext,0)


        def deltaTimeUnit(self):
            return self.getTypedRuleContext(dateparse_utilsParser.DeltaTimeUnitContext,0)


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

        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_countUnitsBeforeAfterTimeExpr

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

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




    def countUnitsBeforeAfterTimeExpr(self):

        localctx = dateparse_utilsParser.CountUnitsBeforeAfterTimeExprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 50, self.RULE_countUnitsBeforeAfterTimeExpr)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 515
            self.nth()
            self.state = 522
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,90,self._ctx)
            if la_ == 1:
                self.state = 517 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 516
                    self.match(dateparse_utilsParser.SPACE)
                    self.state = 519 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==dateparse_utilsParser.SPACE):
                        break

                self.state = 521
                self.deltaTimeUnit()


            self.state = 525 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 524
                self.match(dateparse_utilsParser.SPACE)
                self.state = 527 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==dateparse_utilsParser.SPACE):
                    break

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


    class FractionBeforeAfterTimeExprContext(ParserRuleContext):

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

        def deltaTimeFraction(self):
            return self.getTypedRuleContext(dateparse_utilsParser.DeltaTimeFractionContext,0)


        def deltaTimeBeforeAfter(self):
            return self.getTypedRuleContext(dateparse_utilsParser.DeltaTimeBeforeAfterContext,0)


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

        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_fractionBeforeAfterTimeExpr

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

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




    def fractionBeforeAfterTimeExpr(self):

        localctx = dateparse_utilsParser.FractionBeforeAfterTimeExprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 52, self.RULE_fractionBeforeAfterTimeExpr)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 531
            self.deltaTimeFraction()
            self.state = 533 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 532
                self.match(dateparse_utilsParser.SPACE)
                self.state = 535 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==dateparse_utilsParser.SPACE):
                    break

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


    class DeltaUnitContext(ParserRuleContext):

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

        def YEAR(self):
            return self.getToken(dateparse_utilsParser.YEAR, 0)

        def MONTH(self):
            return self.getToken(dateparse_utilsParser.MONTH, 0)

        def WEEK(self):
            return self.getToken(dateparse_utilsParser.WEEK, 0)

        def DAY(self):
            return self.getToken(dateparse_utilsParser.DAY, 0)

        def WEEKDAY(self):
            return self.getToken(dateparse_utilsParser.WEEKDAY, 0)

        def WORKDAY(self):
            return self.getToken(dateparse_utilsParser.WORKDAY, 0)

        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_deltaUnit

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

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




    def deltaUnit(self):

        localctx = dateparse_utilsParser.DeltaUnitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 54, self.RULE_deltaUnit)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 539
            _la = self._input.LA(1)
            if not(((((_la - 48)) & ~0x3f) == 0 and ((1 << (_la - 48)) & ((1 << (dateparse_utilsParser.WEEKDAY - 48)) | (1 << (dateparse_utilsParser.WEEK - 48)) | (1 << (dateparse_utilsParser.DAY - 48)) | (1 << (dateparse_utilsParser.MONTH - 48)) | (1 << (dateparse_utilsParser.YEAR - 48)) | (1 << (dateparse_utilsParser.WORKDAY - 48)))) != 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 DeltaTimeUnitContext(ParserRuleContext):

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

        def SECOND(self):
            return self.getToken(dateparse_utilsParser.SECOND, 0)

        def MINUTE(self):
            return self.getToken(dateparse_utilsParser.MINUTE, 0)

        def HOUR(self):
            return self.getToken(dateparse_utilsParser.HOUR, 0)

        def WORKDAY(self):
            return self.getToken(dateparse_utilsParser.WORKDAY, 0)

        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_deltaTimeUnit

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

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




    def deltaTimeUnit(self):

        localctx = dateparse_utilsParser.DeltaTimeUnitContext(self, self._ctx, self.state)
        self.enterRule(localctx, 56, self.RULE_deltaTimeUnit)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 541
            _la = self._input.LA(1)
            if not(((((_la - 58)) & ~0x3f) == 0 and ((1 << (_la - 58)) & ((1 << (dateparse_utilsParser.HOUR - 58)) | (1 << (dateparse_utilsParser.MINUTE - 58)) | (1 << (dateparse_utilsParser.SECOND - 58)) | (1 << (dateparse_utilsParser.WORKDAY - 58)))) != 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 DeltaBeforeAfterContext(ParserRuleContext):

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

        def BEFORE(self):
            return self.getToken(dateparse_utilsParser.BEFORE, 0)

        def AFTER(self):
            return self.getToken(dateparse_utilsParser.AFTER, 0)

        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_deltaBeforeAfter

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

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




    def deltaBeforeAfter(self):

        localctx = dateparse_utilsParser.DeltaBeforeAfterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 58, self.RULE_deltaBeforeAfter)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 543
            _la = self._input.LA(1)
            if not(_la==dateparse_utilsParser.BEFORE or _la==dateparse_utilsParser.AFTER):
                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 DeltaTimeBeforeAfterContext(ParserRuleContext):

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

        def BEFORE(self):
            return self.getToken(dateparse_utilsParser.BEFORE, 0)

        def AFTER(self):
            return self.getToken(dateparse_utilsParser.AFTER, 0)

        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_deltaTimeBeforeAfter

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

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




    def deltaTimeBeforeAfter(self):

        localctx = dateparse_utilsParser.DeltaTimeBeforeAfterContext(self, self._ctx, self.state)
        self.enterRule(localctx, 60, self.RULE_deltaTimeBeforeAfter)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 545
            _la = self._input.LA(1)
            if not(_la==dateparse_utilsParser.BEFORE or _la==dateparse_utilsParser.AFTER):
                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 MonthExprContext(ParserRuleContext):

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

        def monthName(self):
            return self.getTypedRuleContext(dateparse_utilsParser.MonthNameContext,0)


        def monthNumber(self):
            return self.getTypedRuleContext(dateparse_utilsParser.MonthNumberContext,0)


        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_monthExpr

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

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




    def monthExpr(self):

        localctx = dateparse_utilsParser.MonthExprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 62, self.RULE_monthExpr)
        try:
            self.state = 549
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [dateparse_utilsParser.MONTH_NAME]:
                self.enterOuterAlt(localctx, 1)
                self.state = 547
                self.monthName()
                pass
            elif token in [dateparse_utilsParser.DIGIT]:
                self.enterOuterAlt(localctx, 2)
                self.state = 548
                self.monthNumber()
                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 YearContext(ParserRuleContext):

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

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

        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_year

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

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




    def year(self):

        localctx = dateparse_utilsParser.YearContext(self, self._ctx, self.state)
        self.enterRule(localctx, 64, self.RULE_year)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 551
            self.match(dateparse_utilsParser.DIGIT)
            self.state = 552
            self.match(dateparse_utilsParser.DIGIT)
            self.state = 553
            self.match(dateparse_utilsParser.DIGIT)
            self.state = 554
            self.match(dateparse_utilsParser.DIGIT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SpecialDateContext(ParserRuleContext):

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

        def SPECIAL_DATE(self):
            return self.getToken(dateparse_utilsParser.SPECIAL_DATE, 0)

        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_specialDate

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

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




    def specialDate(self):

        localctx = dateparse_utilsParser.SpecialDateContext(self, self._ctx, self.state)
        self.enterRule(localctx, 66, self.RULE_specialDate)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 556
            self.match(dateparse_utilsParser.SPECIAL_DATE)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DayOfMonthContext(ParserRuleContext):

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

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

        def KALENDS(self):
            return self.getToken(dateparse_utilsParser.KALENDS, 0)

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

        def IDES(self):
            return self.getToken(dateparse_utilsParser.IDES, 0)

        def NONES(self):
            return self.getToken(dateparse_utilsParser.NONES, 0)

        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_dayOfMonth

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

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




    def dayOfMonth(self):

        localctx = dateparse_utilsParser.DayOfMonthContext(self, self._ctx, self.state)
        self.enterRule(localctx, 68, self.RULE_dayOfMonth)
        self._la = 0 # Token type
        try:
            self.state = 592
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [dateparse_utilsParser.DIGIT]:
                self.enterOuterAlt(localctx, 1)
                self.state = 558
                self.match(dateparse_utilsParser.DIGIT)
                self.state = 560
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,94,self._ctx)
                if la_ == 1:
                    self.state = 559
                    self.match(dateparse_utilsParser.DIGIT)


                self.state = 563
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << dateparse_utilsParser.T__10) | (1 << dateparse_utilsParser.T__11) | (1 << dateparse_utilsParser.T__12) | (1 << dateparse_utilsParser.T__13) | (1 << dateparse_utilsParser.T__14) | (1 << dateparse_utilsParser.T__15) | (1 << dateparse_utilsParser.T__16) | (1 << dateparse_utilsParser.T__17))) != 0):
                    self.state = 562
                    _la = self._input.LA(1)
                    if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << dateparse_utilsParser.T__10) | (1 << dateparse_utilsParser.T__11) | (1 << dateparse_utilsParser.T__12) | (1 << dateparse_utilsParser.T__13) | (1 << dateparse_utilsParser.T__14) | (1 << dateparse_utilsParser.T__15) | (1 << dateparse_utilsParser.T__16) | (1 << dateparse_utilsParser.T__17))) != 0)):
                        self._errHandler.recoverInline(self)
                    else:
                        self._errHandler.reportMatch(self)
                        self.consume()


                pass
            elif token in [dateparse_utilsParser.KALENDS]:
                self.enterOuterAlt(localctx, 2)
                self.state = 565
                self.match(dateparse_utilsParser.KALENDS)
                self.state = 572
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,97,self._ctx)
                if la_ == 1:
                    self.state = 567 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while True:
                        self.state = 566
                        self.match(dateparse_utilsParser.SPACE)
                        self.state = 569 
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if not (_la==dateparse_utilsParser.SPACE):
                            break

                    self.state = 571
                    self.match(dateparse_utilsParser.T__9)


                pass
            elif token in [dateparse_utilsParser.IDES]:
                self.enterOuterAlt(localctx, 3)
                self.state = 574
                self.match(dateparse_utilsParser.IDES)
                self.state = 581
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,99,self._ctx)
                if la_ == 1:
                    self.state = 576 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while True:
                        self.state = 575
                        self.match(dateparse_utilsParser.SPACE)
                        self.state = 578 
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if not (_la==dateparse_utilsParser.SPACE):
                            break

                    self.state = 580
                    self.match(dateparse_utilsParser.T__9)


                pass
            elif token in [dateparse_utilsParser.NONES]:
                self.enterOuterAlt(localctx, 4)
                self.state = 583
                self.match(dateparse_utilsParser.NONES)
                self.state = 590
                self._errHandler.sync(self)
                la_ = self._interp.adaptivePredict(self._input,101,self._ctx)
                if la_ == 1:
                    self.state = 585 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    while True:
                        self.state = 584
                        self.match(dateparse_utilsParser.SPACE)
                        self.state = 587 
                        self._errHandler.sync(self)
                        _la = self._input.LA(1)
                        if not (_la==dateparse_utilsParser.SPACE):
                            break

                    self.state = 589
                    self.match(dateparse_utilsParser.T__9)


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

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

        def FIRST(self):
            return self.getToken(dateparse_utilsParser.FIRST, 0)

        def LAST(self):
            return self.getToken(dateparse_utilsParser.LAST, 0)

        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_firstOrLast

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

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




    def firstOrLast(self):

        localctx = dateparse_utilsParser.FirstOrLastContext(self, self._ctx, self.state)
        self.enterRule(localctx, 70, self.RULE_firstOrLast)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 594
            _la = self._input.LA(1)
            if not(_la==dateparse_utilsParser.FIRST or _la==dateparse_utilsParser.LAST):
                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 NthContext(ParserRuleContext):

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

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

        def DASH(self):
            return self.getToken(dateparse_utilsParser.DASH, 0)

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

        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_nth

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

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




    def nth(self):

        localctx = dateparse_utilsParser.NthContext(self, self._ctx, self.state)
        self.enterRule(localctx, 72, self.RULE_nth)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 597
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==dateparse_utilsParser.DASH or _la==dateparse_utilsParser.PLUS:
                self.state = 596
                _la = self._input.LA(1)
                if not(_la==dateparse_utilsParser.DASH or _la==dateparse_utilsParser.PLUS):
                    self._errHandler.recoverInline(self)
                else:
                    self._errHandler.reportMatch(self)
                    self.consume()


            self.state = 600 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 599
                self.match(dateparse_utilsParser.DIGIT)
                self.state = 602 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==dateparse_utilsParser.DIGIT):
                    break

            self.state = 605
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << dateparse_utilsParser.T__10) | (1 << dateparse_utilsParser.T__11) | (1 << dateparse_utilsParser.T__12) | (1 << dateparse_utilsParser.T__13) | (1 << dateparse_utilsParser.T__14) | (1 << dateparse_utilsParser.T__15) | (1 << dateparse_utilsParser.T__16) | (1 << dateparse_utilsParser.T__17))) != 0):
                self.state = 604
                _la = self._input.LA(1)
                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << dateparse_utilsParser.T__10) | (1 << dateparse_utilsParser.T__11) | (1 << dateparse_utilsParser.T__12) | (1 << dateparse_utilsParser.T__13) | (1 << dateparse_utilsParser.T__14) | (1 << dateparse_utilsParser.T__15) | (1 << dateparse_utilsParser.T__16) | (1 << dateparse_utilsParser.T__17))) != 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 UnsignedIntContext(ParserRuleContext):

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

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

        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_unsignedInt

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

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




    def unsignedInt(self):

        localctx = dateparse_utilsParser.UnsignedIntContext(self, self._ctx, self.state)
        self.enterRule(localctx, 74, self.RULE_unsignedInt)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 608 
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            while True:
                self.state = 607
                self.match(dateparse_utilsParser.DIGIT)
                self.state = 610 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                if not (_la==dateparse_utilsParser.DIGIT):
                    break

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


    class DeltaTimeFractionContext(ParserRuleContext):

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

        def DELTA_TIME_FRACTION(self):
            return self.getToken(dateparse_utilsParser.DELTA_TIME_FRACTION, 0)

        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_deltaTimeFraction

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

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




    def deltaTimeFraction(self):

        localctx = dateparse_utilsParser.DeltaTimeFractionContext(self, self._ctx, self.state)
        self.enterRule(localctx, 76, self.RULE_deltaTimeFraction)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 612
            self.match(dateparse_utilsParser.DELTA_TIME_FRACTION)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SpecialTimeExprContext(ParserRuleContext):

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

        def specialTime(self):
            return self.getTypedRuleContext(dateparse_utilsParser.SpecialTimeContext,0)


        def tzExpr(self):
            return self.getTypedRuleContext(dateparse_utilsParser.TzExprContext,0)


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

        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_specialTimeExpr

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

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




    def specialTimeExpr(self):

        localctx = dateparse_utilsParser.SpecialTimeExprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 78, self.RULE_specialTimeExpr)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 614
            self.specialTime()
            self.state = 621
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,108,self._ctx)
            if la_ == 1:
                self.state = 616 
                self._errHandler.sync(self)
                _la = self._input.LA(1)
                while True:
                    self.state = 615
                    self.match(dateparse_utilsParser.SPACE)
                    self.state = 618 
                    self._errHandler.sync(self)
                    _la = self._input.LA(1)
                    if not (_la==dateparse_utilsParser.SPACE):
                        break

                self.state = 620
                self.tzExpr()


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


    class SpecialTimeContext(ParserRuleContext):

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

        def SPECIAL_TIME(self):
            return self.getToken(dateparse_utilsParser.SPECIAL_TIME, 0)

        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_specialTime

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

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




    def specialTime(self):

        localctx = dateparse_utilsParser.SpecialTimeContext(self, self._ctx, self.state)
        self.enterRule(localctx, 80, self.RULE_specialTime)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 623
            self.match(dateparse_utilsParser.SPECIAL_TIME)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class DayNameContext(ParserRuleContext):

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

        def WEEKDAY(self):
            return self.getToken(dateparse_utilsParser.WEEKDAY, 0)

        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_dayName

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

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




    def dayName(self):

        localctx = dateparse_utilsParser.DayNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 82, self.RULE_dayName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 625
            self.match(dateparse_utilsParser.WEEKDAY)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MonthNameContext(ParserRuleContext):

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

        def MONTH_NAME(self):
            return self.getToken(dateparse_utilsParser.MONTH_NAME, 0)

        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_monthName

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

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




    def monthName(self):

        localctx = dateparse_utilsParser.MonthNameContext(self, self._ctx, self.state)
        self.enterRule(localctx, 84, self.RULE_monthName)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 627
            self.match(dateparse_utilsParser.MONTH_NAME)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MonthNumberContext(ParserRuleContext):

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

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

        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_monthNumber

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

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




    def monthNumber(self):

        localctx = dateparse_utilsParser.MonthNumberContext(self, self._ctx, self.state)
        self.enterRule(localctx, 86, self.RULE_monthNumber)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 629
            self.match(dateparse_utilsParser.DIGIT)
            self.state = 631
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==dateparse_utilsParser.DIGIT:
                self.state = 630
                self.match(dateparse_utilsParser.DIGIT)


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


    class HourContext(ParserRuleContext):

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

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

        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_hour

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

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




    def hour(self):

        localctx = dateparse_utilsParser.HourContext(self, self._ctx, self.state)
        self.enterRule(localctx, 88, self.RULE_hour)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 633
            self.match(dateparse_utilsParser.DIGIT)
            self.state = 635
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,110,self._ctx)
            if la_ == 1:
                self.state = 634
                self.match(dateparse_utilsParser.DIGIT)


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


    class MinuteContext(ParserRuleContext):

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

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

        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_minute

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

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




    def minute(self):

        localctx = dateparse_utilsParser.MinuteContext(self, self._ctx, self.state)
        self.enterRule(localctx, 90, self.RULE_minute)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 637
            self.match(dateparse_utilsParser.DIGIT)
            self.state = 638
            self.match(dateparse_utilsParser.DIGIT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class SecondContext(ParserRuleContext):

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

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

        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_second

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

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




    def second(self):

        localctx = dateparse_utilsParser.SecondContext(self, self._ctx, self.state)
        self.enterRule(localctx, 92, self.RULE_second)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 640
            self.match(dateparse_utilsParser.DIGIT)
            self.state = 641
            self.match(dateparse_utilsParser.DIGIT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class MicrosContext(ParserRuleContext):

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

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

        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_micros

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

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




    def micros(self):

        localctx = dateparse_utilsParser.MicrosContext(self, self._ctx, self.state)
        self.enterRule(localctx, 94, self.RULE_micros)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 643
            self.match(dateparse_utilsParser.DIGIT)
            self.state = 645
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,111,self._ctx)
            if la_ == 1:
                self.state = 644
                self.match(dateparse_utilsParser.DIGIT)


            self.state = 648
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,112,self._ctx)
            if la_ == 1:
                self.state = 647
                self.match(dateparse_utilsParser.DIGIT)


            self.state = 651
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,113,self._ctx)
            if la_ == 1:
                self.state = 650
                self.match(dateparse_utilsParser.DIGIT)


            self.state = 654
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,114,self._ctx)
            if la_ == 1:
                self.state = 653
                self.match(dateparse_utilsParser.DIGIT)


            self.state = 657
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,115,self._ctx)
            if la_ == 1:
                self.state = 656
                self.match(dateparse_utilsParser.DIGIT)


            self.state = 660
            self._errHandler.sync(self)
            la_ = self._interp.adaptivePredict(self._input,116,self._ctx)
            if la_ == 1:
                self.state = 659
                self.match(dateparse_utilsParser.DIGIT)


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


    class DdivContext(ParserRuleContext):

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

        def SLASH(self):
            return self.getToken(dateparse_utilsParser.SLASH, 0)

        def DASH(self):
            return self.getToken(dateparse_utilsParser.DASH, 0)

        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_ddiv

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

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




    def ddiv(self):

        localctx = dateparse_utilsParser.DdivContext(self, self._ctx, self.state)
        self.enterRule(localctx, 96, self.RULE_ddiv)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 662
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << dateparse_utilsParser.T__18) | (1 << dateparse_utilsParser.DASH) | (1 << dateparse_utilsParser.SLASH))) != 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 TdivContext(ParserRuleContext):

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

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

        def DOT(self):
            return self.getToken(dateparse_utilsParser.DOT, 0)

        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_tdiv

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

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




    def tdiv(self):

        localctx = dateparse_utilsParser.TdivContext(self, self._ctx, self.state)
        self.enterRule(localctx, 98, self.RULE_tdiv)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 664
            _la = self._input.LA(1)
            if not(_la==dateparse_utilsParser.DOT or _la==dateparse_utilsParser.COLON):
                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 DtdivContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_dtdiv

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

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




    def dtdiv(self):

        localctx = dateparse_utilsParser.DtdivContext(self, self._ctx, self.state)
        self.enterRule(localctx, 100, self.RULE_dtdiv)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 666
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << dateparse_utilsParser.T__18) | (1 << dateparse_utilsParser.T__19) | (1 << dateparse_utilsParser.T__20) | (1 << dateparse_utilsParser.T__21) | (1 << dateparse_utilsParser.T__22) | (1 << dateparse_utilsParser.T__23))) != 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 TddivContext(ParserRuleContext):

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


        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_tddiv

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

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




    def tddiv(self):

        localctx = dateparse_utilsParser.TddivContext(self, self._ctx, self.state)
        self.enterRule(localctx, 102, self.RULE_tddiv)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 668
            _la = self._input.LA(1)
            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << dateparse_utilsParser.T__18) | (1 << dateparse_utilsParser.T__23) | (1 << dateparse_utilsParser.T__24) | (1 << dateparse_utilsParser.T__25))) != 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 TzExprContext(ParserRuleContext):

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

        def ntz(self):
            return self.getTypedRuleContext(dateparse_utilsParser.NtzContext,0)


        def ltz(self):
            return self.getTypedRuleContext(dateparse_utilsParser.LtzContext,0)


        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_tzExpr

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

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




    def tzExpr(self):

        localctx = dateparse_utilsParser.TzExprContext(self, self._ctx, self.state)
        self.enterRule(localctx, 104, self.RULE_tzExpr)
        try:
            self.state = 672
            self._errHandler.sync(self)
            token = self._input.LA(1)
            if token in [dateparse_utilsParser.DASH, dateparse_utilsParser.PLUS]:
                self.enterOuterAlt(localctx, 1)
                self.state = 670
                self.ntz()
                pass
            elif token in [dateparse_utilsParser.UPPERCASE_STRING]:
                self.enterOuterAlt(localctx, 2)
                self.state = 671
                self.ltz()
                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 NtzContext(ParserRuleContext):

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

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

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

        def DASH(self):
            return self.getToken(dateparse_utilsParser.DASH, 0)

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

        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_ntz

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

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




    def ntz(self):

        localctx = dateparse_utilsParser.NtzContext(self, self._ctx, self.state)
        self.enterRule(localctx, 106, self.RULE_ntz)
        self._la = 0 # Token type
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 674
            _la = self._input.LA(1)
            if not(_la==dateparse_utilsParser.DASH or _la==dateparse_utilsParser.PLUS):
                self._errHandler.recoverInline(self)
            else:
                self._errHandler.reportMatch(self)
                self.consume()
            self.state = 675
            self.match(dateparse_utilsParser.DIGIT)
            self.state = 676
            self.match(dateparse_utilsParser.DIGIT)
            self.state = 678
            self._errHandler.sync(self)
            _la = self._input.LA(1)
            if _la==dateparse_utilsParser.COLON:
                self.state = 677
                self.match(dateparse_utilsParser.COLON)


            self.state = 680
            self.match(dateparse_utilsParser.DIGIT)
            self.state = 681
            self.match(dateparse_utilsParser.DIGIT)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx


    class LtzContext(ParserRuleContext):

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

        def UPPERCASE_STRING(self):
            return self.getToken(dateparse_utilsParser.UPPERCASE_STRING, 0)

        def getRuleIndex(self):
            return dateparse_utilsParser.RULE_ltz

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

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




    def ltz(self):

        localctx = dateparse_utilsParser.LtzContext(self, self._ctx, self.state)
        self.enterRule(localctx, 108, self.RULE_ltz)
        try:
            self.enterOuterAlt(localctx, 1)
            self.state = 683
            self.match(dateparse_utilsParser.UPPERCASE_STRING)
        except RecognitionException as re:
            localctx.exception = re
            self._errHandler.reportError(self, re)
            self._errHandler.recover(self, re)
        finally:
            self.exitRule()
        return localctx





