Repository: oasis-open/cti-pattern-validator

Issue:
Pattern passes unexpectedly
The following pattern passes with the latest version installed via `pip`

```
$ pip3 install stix2-patterns
Requirement already satisfied: stix2-patterns in /usr/local/lib/python3.6/site-packages
Requirement already satisfied: six in /usr/local/lib/python3.6/site-packages (from stix2-patterns)
Requirement already satisfied: antlr4-python3-runtime==4.7; python_version >= "3" in /usr/local/lib/python3.6/site-packages (from stix2-patterns)
$ validate-patterns
Enter a pattern to validate: [file:hashes.'SHA-256' =? 'bf07a7fbb825fc0aae7bf4a1177b2b31fcf8a3feeaf7092761e18c859ee52a9c' OR file:hashes.MD5 = 'cead3f77f6cda6ec00f57d76c9a6879f'] AND [file:hashes.'SHA-256' = 'aec070645fe53ee3b3763059376134f058cc337247c978add178b6ccdfb0019f']

PASS: [file:hashes.'SHA-256' =? 'bf07a7fbb825fc0aae7bf4a1177b2b31fcf8a3feeaf7092761e18c859ee52a9c' OR file:hashes.MD5 = 'cead3f77f6cda6ec00f57d76c9a6879f'] AND [file:hashes.'SHA-256' = 'aec070645fe53ee3b3763059376134f058cc337247c978add178b6ccdfb0019f']
```

I don't see where `=?` matches in patterns operator. In our STIX2 Patterns parser, this fails. Our parser has a catch-all pattern at the end that returns an `unexpected` token. Maybe that would fix this issue for your ANTLR implementation?

Discussion:

Patch:
diff --git a/stix2patterns/grammars/STIXPatternLexer.py b/stix2patterns/grammars/STIXPatternLexer.py
index dd44915..dc01a53 100644
--- a/stix2patterns/grammars/STIXPatternLexer.py
+++ b/stix2patterns/grammars/STIXPatternLexer.py
@@ -1,4 +1,4 @@
-# Generated from STIXPattern.g4 by ANTLR 4.7
+# Generated from STIXPattern.g4 by ANTLR 4.7.1
 # encoding: utf-8
 from __future__ import print_function
 
@@ -11,7 +11,7 @@ from antlr4 import *
 def serializedATN():
     with StringIO() as buf:
         buf.write(u"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2")
-        buf.write(u"\64\u020e\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6")
+        buf.write(u"\67\u0257\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6")
         buf.write(u"\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4")
         buf.write(u"\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t")
         buf.write(u"\22\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27")
@@ -22,233 +22,275 @@ def serializedATN():
         buf.write(u"\4\63\t\63\4\64\t\64\4\65\t\65\4\66\t\66\4\67\t\67\4")
         buf.write(u"8\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@")
         buf.write(u"\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I\t")
-        buf.write(u"I\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\3\2\5\2\u00a3")
-        buf.write(u"\n\2\3\2\3\2\3\2\7\2\u00a8\n\2\f\2\16\2\u00ab\13\2\5")
-        buf.write(u"\2\u00ad\n\2\3\3\5\3\u00b0\n\3\3\3\7\3\u00b3\n\3\f\3")
-        buf.write(u"\16\3\u00b6\13\3\3\3\3\3\6\3\u00ba\n\3\r\3\16\3\u00bb")
-        buf.write(u"\3\4\3\4\3\4\7\4\u00c1\n\4\f\4\16\4\u00c4\13\4\3\4\3")
-        buf.write(u"\4\3\5\3\5\3\5\7\5\u00cb\n\5\f\5\16\5\u00ce\13\5\3\5")
-        buf.write(u"\3\5\3\6\3\6\3\6\3\6\3\6\3\6\7\6\u00d8\n\6\f\6\16\6\u00db")
-        buf.write(u"\13\6\3\6\3\6\3\7\3\7\5\7\u00e1\n\7\3\b\3\b\3\b\3\b\3")
-        buf.write(u"\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3")
-        buf.write(u"\b\3\b\3\b\3\b\3\b\3\b\6\b\u00fa\n\b\r\b\16\b\u00fb\5")
-        buf.write(u"\b\u00fe\n\b\3\b\3\b\3\b\3\t\3\t\3\t\3\t\3\n\3\n\3\n")
-        buf.write(u"\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f")
-        buf.write(u"\3\f\3\f\3\f\3\r\3\r\3\r\3\r\3\r\3\16\3\16\3\16\3\16")
-        buf.write(u"\3\16\3\16\3\16\3\16\3\17\3\17\3\17\3\17\3\17\3\17\3")
-        buf.write(u"\17\3\17\3\17\3\17\3\17\3\20\3\20\3\20\3\20\3\20\3\20")
-        buf.write(u"\3\20\3\20\3\20\3\21\3\21\3\21\3\21\3\21\3\22\3\22\3")
-        buf.write(u"\22\3\23\3\23\3\23\3\23\3\23\3\23\3\24\3\24\3\24\3\24")
-        buf.write(u"\3\24\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\26\3")
-        buf.write(u"\26\3\26\3\26\3\26\3\27\3\27\3\27\3\27\3\27\3\27\3\30")
-        buf.write(u"\3\30\3\30\3\30\3\30\3\30\3\30\3\31\3\31\3\31\3\31\3")
-        buf.write(u"\31\3\31\3\31\3\31\3\32\3\32\3\32\3\32\3\32\3\32\3\33")
-        buf.write(u"\3\33\7\33\u0177\n\33\f\33\16\33\u017a\13\33\3\34\3\34")
-        buf.write(u"\7\34\u017e\n\34\f\34\16\34\u0181\13\34\3\35\3\35\3\35")
-        buf.write(u"\5\35\u0186\n\35\3\36\3\36\3\36\3\36\5\36\u018c\n\36")
-        buf.write(u"\3\37\3\37\3 \3 \3 \3!\3!\3\"\3\"\3\"\3#\3#\3$\3$\3%")
-        buf.write(u"\3%\3&\3&\3\'\3\'\3(\3(\3)\3)\3*\3*\3+\3+\3,\3,\3-\3")
-        buf.write(u"-\3.\3.\3/\3/\3\60\3\60\3\61\3\61\3\62\3\62\3\63\3\63")
-        buf.write(u"\3\64\3\64\3\65\3\65\3\66\3\66\3\67\3\67\38\38\39\39")
-        buf.write(u"\3:\3:\3;\3;\3<\3<\3=\3=\3>\3>\3?\3?\3@\3@\3A\3A\3B\3")
-        buf.write(u"B\3C\3C\3D\3D\3E\3E\3F\3F\3G\3G\3H\3H\3I\3I\3J\3J\3K")
-        buf.write(u"\3K\3L\3L\3L\3M\3M\3N\6N\u01f0\nN\rN\16N\u01f1\3N\3N")
-        buf.write(u"\3O\3O\3O\3O\7O\u01fa\nO\fO\16O\u01fd\13O\3O\3O\3O\3")
-        buf.write(u"O\3O\3P\3P\3P\3P\7P\u0208\nP\fP\16P\u020b\13P\3P\3P\3")
-        buf.write(u"\u01fb\2Q\3\3\5\4\7\5\t\6\13\7\r\b\17\t\21\n\23\13\25")
-        buf.write(u"\f\27\r\31\16\33\17\35\20\37\21!\22#\23%\24\'\25)\26")
-        buf.write(u"+\27-\30/\31\61\32\63\33\65\34\67\359\36;\37= ?!A\"C")
-        buf.write(u"#E$G%I&K\'M(O)Q*S+U,W-Y.[/]\60_\61a\2c\2e\2g\2i\2k\2")
-        buf.write(u"m\2o\2q\2s\2u\2w\2y\2{\2}\2\177\2\u0081\2\u0083\2\u0085")
-        buf.write(u"\2\u0087\2\u0089\2\u008b\2\u008d\2\u008f\2\u0091\2\u0093")
-        buf.write(u"\2\u0095\2\u0097\2\u0099\2\u009b\62\u009d\63\u009f\64")
-        buf.write(u"\3\2\'\4\2--//\3\2\63;\3\2\62;\4\2))^^\5\2C\\aac|\6\2")
-        buf.write(u"\62;C\\aac|\7\2//\62;C\\aac|\4\2CCcc\4\2DDdd\4\2EEee")
-        buf.write(u"\4\2FFff\4\2GGgg\4\2HHhh\4\2IIii\4\2JJjj\4\2KKkk\4\2")
-        buf.write(u"LLll\4\2MMmm\4\2NNnn\4\2OOoo\4\2PPpp\4\2QQqq\4\2RRrr")
-        buf.write(u"\4\2SSss\4\2TTtt\4\2UUuu\4\2VVvv\4\2WWww\4\2XXxx\4\2")
-        buf.write(u"YYyy\4\2ZZzz\4\2[[{{\4\2\\\\||\5\2\62;CHch\7\2--\61;")
-        buf.write(u"??C\\c|\f\2\13\17\"\"\u0087\u0087\u00a2\u00a2\u1682\u1682")
-        buf.write(u"\u2002\u200c\u202a\u202b\u2031\u2031\u2061\u2061\u3002")
-        buf.write(u"\u3002\4\2\f\f\17\17\2\u0205\2\3\3\2\2\2\2\5\3\2\2\2")
-        buf.write(u"\2\7\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17")
-        buf.write(u"\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2\27")
-        buf.write(u"\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2\2\2\2\37")
-        buf.write(u"\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2\2\'\3\2\2\2")
-        buf.write(u"\2)\3\2\2\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2")
-        buf.write(u"\2\2\2\63\3\2\2\2\2\65\3\2\2\2\2\67\3\2\2\2\29\3\2\2")
-        buf.write(u"\2\2;\3\2\2\2\2=\3\2\2\2\2?\3\2\2\2\2A\3\2\2\2\2C\3\2")
-        buf.write(u"\2\2\2E\3\2\2\2\2G\3\2\2\2\2I\3\2\2\2\2K\3\2\2\2\2M\3")
-        buf.write(u"\2\2\2\2O\3\2\2\2\2Q\3\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2")
-        buf.write(u"W\3\2\2\2\2Y\3\2\2\2\2[\3\2\2\2\2]\3\2\2\2\2_\3\2\2\2")
-        buf.write(u"\2\u009b\3\2\2\2\2\u009d\3\2\2\2\2\u009f\3\2\2\2\3\u00a2")
-        buf.write(u"\3\2\2\2\5\u00af\3\2\2\2\7\u00bd\3\2\2\2\t\u00c7\3\2")
-        buf.write(u"\2\2\13\u00d1\3\2\2\2\r\u00e0\3\2\2\2\17\u00e2\3\2\2")
-        buf.write(u"\2\21\u0102\3\2\2\2\23\u0106\3\2\2\2\25\u0109\3\2\2\2")
-        buf.write(u"\27\u010d\3\2\2\2\31\u0118\3\2\2\2\33\u011d\3\2\2\2\35")
-        buf.write(u"\u0125\3\2\2\2\37\u0130\3\2\2\2!\u0139\3\2\2\2#\u013e")
-        buf.write(u"\3\2\2\2%\u0141\3\2\2\2\'\u0147\3\2\2\2)\u014c\3\2\2")
-        buf.write(u"\2+\u0154\3\2\2\2-\u0159\3\2\2\2/\u015f\3\2\2\2\61\u0166")
-        buf.write(u"\3\2\2\2\63\u016e\3\2\2\2\65\u0174\3\2\2\2\67\u017b\3")
-        buf.write(u"\2\2\29\u0185\3\2\2\2;\u018b\3\2\2\2=\u018d\3\2\2\2?")
-        buf.write(u"\u018f\3\2\2\2A\u0192\3\2\2\2C\u0194\3\2\2\2E\u0197\3")
-        buf.write(u"\2\2\2G\u0199\3\2\2\2I\u019b\3\2\2\2K\u019d\3\2\2\2M")
-        buf.write(u"\u019f\3\2\2\2O\u01a1\3\2\2\2Q\u01a3\3\2\2\2S\u01a5\3")
-        buf.write(u"\2\2\2U\u01a7\3\2\2\2W\u01a9\3\2\2\2Y\u01ab\3\2\2\2[")
-        buf.write(u"\u01ad\3\2\2\2]\u01af\3\2\2\2_\u01b1\3\2\2\2a\u01b3\3")
-        buf.write(u"\2\2\2c\u01b5\3\2\2\2e\u01b7\3\2\2\2g\u01b9\3\2\2\2i")
-        buf.write(u"\u01bb\3\2\2\2k\u01bd\3\2\2\2m\u01bf\3\2\2\2o\u01c1\3")
-        buf.write(u"\2\2\2q\u01c3\3\2\2\2s\u01c5\3\2\2\2u\u01c7\3\2\2\2w")
-        buf.write(u"\u01c9\3\2\2\2y\u01cb\3\2\2\2{\u01cd\3\2\2\2}\u01cf\3")
-        buf.write(u"\2\2\2\177\u01d1\3\2\2\2\u0081\u01d3\3\2\2\2\u0083\u01d5")
-        buf.write(u"\3\2\2\2\u0085\u01d7\3\2\2\2\u0087\u01d9\3\2\2\2\u0089")
-        buf.write(u"\u01db\3\2\2\2\u008b\u01dd\3\2\2\2\u008d\u01df\3\2\2")
-        buf.write(u"\2\u008f\u01e1\3\2\2\2\u0091\u01e3\3\2\2\2\u0093\u01e5")
-        buf.write(u"\3\2\2\2\u0095\u01e7\3\2\2\2\u0097\u01e9\3\2\2\2\u0099")
-        buf.write(u"\u01ec\3\2\2\2\u009b\u01ef\3\2\2\2\u009d\u01f5\3\2\2")
-        buf.write(u"\2\u009f\u0203\3\2\2\2\u00a1\u00a3\t\2\2\2\u00a2\u00a1")
-        buf.write(u"\3\2\2\2\u00a2\u00a3\3\2\2\2\u00a3\u00ac\3\2\2\2\u00a4")
-        buf.write(u"\u00ad\7\62\2\2\u00a5\u00a9\t\3\2\2\u00a6\u00a8\t\4\2")
-        buf.write(u"\2\u00a7\u00a6\3\2\2\2\u00a8\u00ab\3\2\2\2\u00a9\u00a7")
-        buf.write(u"\3\2\2\2\u00a9\u00aa\3\2\2\2\u00aa\u00ad\3\2\2\2\u00ab")
-        buf.write(u"\u00a9\3\2\2\2\u00ac\u00a4\3\2\2\2\u00ac\u00a5\3\2\2")
-        buf.write(u"\2\u00ad\4\3\2\2\2\u00ae\u00b0\t\2\2\2\u00af\u00ae\3")
-        buf.write(u"\2\2\2\u00af\u00b0\3\2\2\2\u00b0\u00b4\3\2\2\2\u00b1")
-        buf.write(u"\u00b3\t\4\2\2\u00b2\u00b1\3\2\2\2\u00b3\u00b6\3\2\2")
-        buf.write(u"\2\u00b4\u00b2\3\2\2\2\u00b4\u00b5\3\2\2\2\u00b5\u00b7")
-        buf.write(u"\3\2\2\2\u00b6\u00b4\3\2\2\2\u00b7\u00b9\7\60\2\2\u00b8")
-        buf.write(u"\u00ba\t\4\2\2\u00b9\u00b8\3\2\2\2\u00ba\u00bb\3\2\2")
-        buf.write(u"\2\u00bb\u00b9\3\2\2\2\u00bb\u00bc\3\2\2\2\u00bc\6\3")
-        buf.write(u"\2\2\2\u00bd\u00be\7j\2\2\u00be\u00c2\5E#\2\u00bf\u00c1")
-        buf.write(u"\5\u0097L\2\u00c0\u00bf\3\2\2\2\u00c1\u00c4\3\2\2\2\u00c2")
-        buf.write(u"\u00c0\3\2\2\2\u00c2\u00c3\3\2\2\2\u00c3\u00c5\3\2\2")
-        buf.write(u"\2\u00c4\u00c2\3\2\2\2\u00c5\u00c6\5E#\2\u00c6\b\3\2")
-        buf.write(u"\2\2\u00c7\u00c8\7d\2\2\u00c8\u00cc\5E#\2\u00c9\u00cb")
-        buf.write(u"\5\u0099M\2\u00ca\u00c9\3\2\2\2\u00cb\u00ce\3\2\2\2\u00cc")
-        buf.write(u"\u00ca\3\2\2\2\u00cc\u00cd\3\2\2\2\u00cd\u00cf\3\2\2")
-        buf.write(u"\2\u00ce\u00cc\3\2\2\2\u00cf\u00d0\5E#\2\u00d0\n\3\2")
-        buf.write(u"\2\2\u00d1\u00d9\5E#\2\u00d2\u00d8\n\5\2\2\u00d3\u00d4")
-        buf.write(u"\7^\2\2\u00d4\u00d8\7)\2\2\u00d5\u00d6\7^\2\2\u00d6\u00d8")
-        buf.write(u"\7^\2\2\u00d7\u00d2\3\2\2\2\u00d7\u00d3\3\2\2\2\u00d7")
-        buf.write(u"\u00d5\3\2\2\2\u00d8\u00db\3\2\2\2\u00d9\u00d7\3\2\2")
-        buf.write(u"\2\u00d9\u00da\3\2\2\2\u00da\u00dc\3\2\2\2\u00db\u00d9")
-        buf.write(u"\3\2\2\2\u00dc\u00dd\5E#\2\u00dd\f\3\2\2\2\u00de\u00e1")
-        buf.write(u"\5+\26\2\u00df\u00e1\5-\27\2\u00e0\u00de\3\2\2\2\u00e0")
-        buf.write(u"\u00df\3\2\2\2\u00e1\16\3\2\2\2\u00e2\u00e3\7v\2\2\u00e3")
-        buf.write(u"\u00e4\5E#\2\u00e4\u00e5\t\4\2\2\u00e5\u00e6\t\4\2\2")
-        buf.write(u"\u00e6\u00e7\t\4\2\2\u00e7\u00e8\t\4\2\2\u00e8\u00e9")
-        buf.write(u"\5W,\2\u00e9\u00ea\t\4\2\2\u00ea\u00eb\t\4\2\2\u00eb")
-        buf.write(u"\u00ec\5W,\2\u00ec\u00ed\t\4\2\2\u00ed\u00ee\t\4\2\2")
-        buf.write(u"\u00ee\u00ef\7V\2\2\u00ef\u00f0\t\4\2\2\u00f0\u00f1\t")
-        buf.write(u"\4\2\2\u00f1\u00f2\5G$\2\u00f2\u00f3\t\4\2\2\u00f3\u00f4")
-        buf.write(u"\t\4\2\2\u00f4\u00f5\5G$\2\u00f5\u00f6\t\4\2\2\u00f6")
-        buf.write(u"\u00fd\t\4\2\2\u00f7\u00f9\5I%\2\u00f8\u00fa\t\4\2\2")
-        buf.write(u"\u00f9\u00f8\3\2\2\2\u00fa\u00fb\3\2\2\2\u00fb\u00f9")
-        buf.write(u"\3\2\2\2\u00fb\u00fc\3\2\2\2\u00fc\u00fe\3\2\2\2\u00fd")
-        buf.write(u"\u00f7\3\2\2\2\u00fd\u00fe\3\2\2\2\u00fe\u00ff\3\2\2")
-        buf.write(u"\2\u00ff\u0100\7\\\2\2\u0100\u0101\5E#\2\u0101\20\3\2")
-        buf.write(u"\2\2\u0102\u0103\5a\61\2\u0103\u0104\5{>\2\u0104\u0105")
-        buf.write(u"\5g\64\2\u0105\22\3\2\2\2\u0106\u0107\5}?\2\u0107\u0108")
-        buf.write(u"\5\u0083B\2\u0108\24\3\2\2\2\u0109\u010a\5{>\2\u010a")
-        buf.write(u"\u010b\5}?\2\u010b\u010c\5\u0087D\2\u010c\26\3\2\2\2")
-        buf.write(u"\u010d\u010e\5k\66\2\u010e\u010f\5}?\2\u010f\u0110\5")
-        buf.write(u"w<\2\u0110\u0111\5w<\2\u0111\u0112\5}?\2\u0112\u0113")
-        buf.write(u"\5\u008dG\2\u0113\u0114\5i\65\2\u0114\u0115\5g\64\2\u0115")
-        buf.write(u"\u0116\5c\62\2\u0116\u0117\5\u0091I\2\u0117\30\3\2\2")
-        buf.write(u"\2\u0118\u0119\5w<\2\u0119\u011a\5q9\2\u011a\u011b\5")
-        buf.write(u"u;\2\u011b\u011c\5i\65\2\u011c\32\3\2\2\2\u011d\u011e")
-        buf.write(u"\5y=\2\u011e\u011f\5a\61\2\u011f\u0120\5\u0087D\2\u0120")
-        buf.write(u"\u0121\5e\63\2\u0121\u0122\5o8\2\u0122\u0123\5i\65\2")
-        buf.write(u"\u0123\u0124\5\u0085C\2\u0124\34\3\2\2\2\u0125\u0126")
-        buf.write(u"\5q9\2\u0126\u0127\5\u0085C\2\u0127\u0128\5\u0085C\2")
-        buf.write(u"\u0128\u0129\5\u0089E\2\u0129\u012a\5\177@\2\u012a\u012b")
-        buf.write(u"\5i\65\2\u012b\u012c\5\u0083B\2\u012c\u012d\5\u0085C")
-        buf.write(u"\2\u012d\u012e\5i\65\2\u012e\u012f\5\u0087D\2\u012f\36")
-        buf.write(u"\3\2\2\2\u0130\u0131\5q9\2\u0131\u0132\5\u0085C\2\u0132")
-        buf.write(u"\u0133\5\u0085C\2\u0133\u0134\5\u0089E\2\u0134\u0135")
-        buf.write(u"\5c\62\2\u0135\u0136\5\u0085C\2\u0136\u0137\5i\65\2\u0137")
-        buf.write(u"\u0138\5\u0087D\2\u0138 \3\2\2\2\u0139\u013a\5w<\2\u013a")
-        buf.write(u"\u013b\5a\61\2\u013b\u013c\5\u0085C\2\u013c\u013d\5\u0087")
-        buf.write(u"D\2\u013d\"\3\2\2\2\u013e\u013f\5q9\2\u013f\u0140\5{")
-        buf.write(u">\2\u0140$\3\2\2\2\u0141\u0142\5\u0085C\2\u0142\u0143")
-        buf.write(u"\5\u0087D\2\u0143\u0144\5a\61\2\u0144\u0145\5\u0083B")
-        buf.write(u"\2\u0145\u0146\5\u0087D\2\u0146&\3\2\2\2\u0147\u0148")
-        buf.write(u"\5\u0085C\2\u0148\u0149\5\u0087D\2\u0149\u014a\5}?\2")
-        buf.write(u"\u014a\u014b\5\177@\2\u014b(\3\2\2\2\u014c\u014d\5\u0085")
-        buf.write(u"C\2\u014d\u014e\5i\65\2\u014e\u014f\5e\63\2\u014f\u0150")
-        buf.write(u"\5}?\2\u0150\u0151\5{>\2\u0151\u0152\5g\64\2\u0152\u0153")
-        buf.write(u"\5\u0085C\2\u0153*\3\2\2\2\u0154\u0155\5\u0087D\2\u0155")
-        buf.write(u"\u0156\5\u0083B\2\u0156\u0157\5\u0089E\2\u0157\u0158")
-        buf.write(u"\5i\65\2\u0158,\3\2\2\2\u0159\u015a\5k\66\2\u015a\u015b")
-        buf.write(u"\5a\61\2\u015b\u015c\5w<\2\u015c\u015d\5\u0085C\2\u015d")
-        buf.write(u"\u015e\5i\65\2\u015e.\3\2\2\2\u015f\u0160\5\u008dG\2")
-        buf.write(u"\u0160\u0161\5q9\2\u0161\u0162\5\u0087D\2\u0162\u0163")
-        buf.write(u"\5o8\2\u0163\u0164\5q9\2\u0164\u0165\5{>\2\u0165\60\3")
-        buf.write(u"\2\2\2\u0166\u0167\5\u0083B\2\u0167\u0168\5i\65\2\u0168")
-        buf.write(u"\u0169\5\177@\2\u0169\u016a\5i\65\2\u016a\u016b\5a\61")
-        buf.write(u"\2\u016b\u016c\5\u0087D\2\u016c\u016d\5\u0085C\2\u016d")
-        buf.write(u"\62\3\2\2\2\u016e\u016f\5\u0087D\2\u016f\u0170\5q9\2")
-        buf.write(u"\u0170\u0171\5y=\2\u0171\u0172\5i\65\2\u0172\u0173\5")
-        buf.write(u"\u0085C\2\u0173\64\3\2\2\2\u0174\u0178\t\6\2\2\u0175")
-        buf.write(u"\u0177\t\7\2\2\u0176\u0175\3\2\2\2\u0177\u017a\3\2\2")
-        buf.write(u"\2\u0178\u0176\3\2\2\2\u0178\u0179\3\2\2\2\u0179\66\3")
-        buf.write(u"\2\2\2\u017a\u0178\3\2\2\2\u017b\u017f\t\6\2\2\u017c")
-        buf.write(u"\u017e\t\b\2\2\u017d\u017c\3\2\2\2\u017e\u0181\3\2\2")
-        buf.write(u"\2\u017f\u017d\3\2\2\2\u017f\u0180\3\2\2\2\u01808\3\2")
-        buf.write(u"\2\2\u0181\u017f\3\2\2\2\u0182\u0186\7?\2\2\u0183\u0184")
-        buf.write(u"\7?\2\2\u0184\u0186\7?\2\2\u0185\u0182\3\2\2\2\u0185")
-        buf.write(u"\u0183\3\2\2\2\u0186:\3\2\2\2\u0187\u0188\7#\2\2\u0188")
-        buf.write(u"\u018c\7?\2\2\u0189\u018a\7>\2\2\u018a\u018c\7@\2\2\u018b")
-        buf.write(u"\u0187\3\2\2\2\u018b\u0189\3\2\2\2\u018c<\3\2\2\2\u018d")
-        buf.write(u"\u018e\7>\2\2\u018e>\3\2\2\2\u018f\u0190\7>\2\2\u0190")
-        buf.write(u"\u0191\7?\2\2\u0191@\3\2\2\2\u0192\u0193\7@\2\2\u0193")
-        buf.write(u"B\3\2\2\2\u0194\u0195\7@\2\2\u0195\u0196\7?\2\2\u0196")
-        buf.write(u"D\3\2\2\2\u0197\u0198\7)\2\2\u0198F\3\2\2\2\u0199\u019a")
-        buf.write(u"\7<\2\2\u019aH\3\2\2\2\u019b\u019c\7\60\2\2\u019cJ\3")
-        buf.write(u"\2\2\2\u019d\u019e\7.\2\2\u019eL\3\2\2\2\u019f\u01a0")
-        buf.write(u"\7+\2\2\u01a0N\3\2\2\2\u01a1\u01a2\7*\2\2\u01a2P\3\2")
-        buf.write(u"\2\2\u01a3\u01a4\7_\2\2\u01a4R\3\2\2\2\u01a5\u01a6\7")
-        buf.write(u"]\2\2\u01a6T\3\2\2\2\u01a7\u01a8\7-\2\2\u01a8V\3\2\2")
-        buf.write(u"\2\u01a9\u01aa\5Y-\2\u01aaX\3\2\2\2\u01ab\u01ac\7/\2")
-        buf.write(u"\2\u01acZ\3\2\2\2\u01ad\u01ae\7`\2\2\u01ae\\\3\2\2\2")
-        buf.write(u"\u01af\u01b0\7\61\2\2\u01b0^\3\2\2\2\u01b1\u01b2\7,\2")
-        buf.write(u"\2\u01b2`\3\2\2\2\u01b3\u01b4\t\t\2\2\u01b4b\3\2\2\2")
-        buf.write(u"\u01b5\u01b6\t\n\2\2\u01b6d\3\2\2\2\u01b7\u01b8\t\13")
-        buf.write(u"\2\2\u01b8f\3\2\2\2\u01b9\u01ba\t\f\2\2\u01bah\3\2\2")
-        buf.write(u"\2\u01bb\u01bc\t\r\2\2\u01bcj\3\2\2\2\u01bd\u01be\t\16")
-        buf.write(u"\2\2\u01bel\3\2\2\2\u01bf\u01c0\t\17\2\2\u01c0n\3\2\2")
-        buf.write(u"\2\u01c1\u01c2\t\20\2\2\u01c2p\3\2\2\2\u01c3\u01c4\t")
-        buf.write(u"\21\2\2\u01c4r\3\2\2\2\u01c5\u01c6\t\22\2\2\u01c6t\3")
-        buf.write(u"\2\2\2\u01c7\u01c8\t\23\2\2\u01c8v\3\2\2\2\u01c9\u01ca")
-        buf.write(u"\t\24\2\2\u01cax\3\2\2\2\u01cb\u01cc\t\25\2\2\u01ccz")
-        buf.write(u"\3\2\2\2\u01cd\u01ce\t\26\2\2\u01ce|\3\2\2\2\u01cf\u01d0")
-        buf.write(u"\t\27\2\2\u01d0~\3\2\2\2\u01d1\u01d2\t\30\2\2\u01d2\u0080")
-        buf.write(u"\3\2\2\2\u01d3\u01d4\t\31\2\2\u01d4\u0082\3\2\2\2\u01d5")
-        buf.write(u"\u01d6\t\32\2\2\u01d6\u0084\3\2\2\2\u01d7\u01d8\t\33")
-        buf.write(u"\2\2\u01d8\u0086\3\2\2\2\u01d9\u01da\t\34\2\2\u01da\u0088")
-        buf.write(u"\3\2\2\2\u01db\u01dc\t\35\2\2\u01dc\u008a\3\2\2\2\u01dd")
-        buf.write(u"\u01de\t\36\2\2\u01de\u008c\3\2\2\2\u01df\u01e0\t\37")
-        buf.write(u"\2\2\u01e0\u008e\3\2\2\2\u01e1\u01e2\t \2\2\u01e2\u0090")
-        buf.write(u"\3\2\2\2\u01e3\u01e4\t!\2\2\u01e4\u0092\3\2\2\2\u01e5")
-        buf.write(u"\u01e6\t\"\2\2\u01e6\u0094\3\2\2\2\u01e7\u01e8\t#\2\2")
-        buf.write(u"\u01e8\u0096\3\2\2\2\u01e9\u01ea\5\u0095K\2\u01ea\u01eb")
-        buf.write(u"\5\u0095K\2\u01eb\u0098\3\2\2\2\u01ec\u01ed\t$\2\2\u01ed")
-        buf.write(u"\u009a\3\2\2\2\u01ee\u01f0\t%\2\2\u01ef\u01ee\3\2\2\2")
-        buf.write(u"\u01f0\u01f1\3\2\2\2\u01f1\u01ef\3\2\2\2\u01f1\u01f2")
-        buf.write(u"\3\2\2\2\u01f2\u01f3\3\2\2\2\u01f3\u01f4\bN\2\2\u01f4")
-        buf.write(u"\u009c\3\2\2\2\u01f5\u01f6\7\61\2\2\u01f6\u01f7\7,\2")
-        buf.write(u"\2\u01f7\u01fb\3\2\2\2\u01f8\u01fa\13\2\2\2\u01f9\u01f8")
-        buf.write(u"\3\2\2\2\u01fa\u01fd\3\2\2\2\u01fb\u01fc\3\2\2\2\u01fb")
-        buf.write(u"\u01f9\3\2\2\2\u01fc\u01fe\3\2\2\2\u01fd\u01fb\3\2\2")
-        buf.write(u"\2\u01fe\u01ff\7,\2\2\u01ff\u0200\7\61\2\2\u0200\u0201")
-        buf.write(u"\3\2\2\2\u0201\u0202\bO\2\2\u0202\u009e\3\2\2\2\u0203")
-        buf.write(u"\u0204\7\61\2\2\u0204\u0205\7\61\2\2\u0205\u0209\3\2")
-        buf.write(u"\2\2\u0206\u0208\n&\2\2\u0207\u0206\3\2\2\2\u0208\u020b")
-        buf.write(u"\3\2\2\2\u0209\u0207\3\2\2\2\u0209\u020a\3\2\2\2\u020a")
-        buf.write(u"\u020c\3\2\2\2\u020b\u0209\3\2\2\2\u020c\u020d\bP\2\2")
-        buf.write(u"\u020d\u00a0\3\2\2\2\27\2\u00a2\u00a9\u00ac\u00af\u00b4")
-        buf.write(u"\u00bb\u00c2\u00cc\u00d7\u00d9\u00e0\u00fb\u00fd\u0178")
-        buf.write(u"\u017f\u0185\u018b\u01f1\u01fb\u0209\3\b\2\2")
+        buf.write(u"I\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R")
+        buf.write(u"\tR\4S\tS\3\2\3\2\3\2\3\2\7\2\u00ac\n\2\f\2\16\2\u00af")
+        buf.write(u"\13\2\5\2\u00b1\n\2\3\3\5\3\u00b4\n\3\3\3\3\3\3\3\7\3")
+        buf.write(u"\u00b9\n\3\f\3\16\3\u00bc\13\3\5\3\u00be\n\3\3\4\3\4")
+        buf.write(u"\7\4\u00c2\n\4\f\4\16\4\u00c5\13\4\3\4\3\4\6\4\u00c9")
+        buf.write(u"\n\4\r\4\16\4\u00ca\3\5\5\5\u00ce\n\5\3\5\7\5\u00d1\n")
+        buf.write(u"\5\f\5\16\5\u00d4\13\5\3\5\3\5\6\5\u00d8\n\5\r\5\16\5")
+        buf.write(u"\u00d9\3\6\3\6\3\6\7\6\u00df\n\6\f\6\16\6\u00e2\13\6")
+        buf.write(u"\3\6\3\6\3\7\3\7\3\7\3\7\3\7\3\7\3\7\7\7\u00ed\n\7\f")
+        buf.write(u"\7\16\7\u00f0\13\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3")
+        buf.write(u"\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\5\7\u0103\n\7\3\7")
+        buf.write(u"\3\7\3\b\3\b\3\b\3\b\3\b\3\b\7\b\u010d\n\b\f\b\16\b\u0110")
+        buf.write(u"\13\b\3\b\3\b\3\t\3\t\5\t\u0116\n\t\3\n\3\n\3\n\3\n\3")
+        buf.write(u"\n\3\n\3\n\3\n\3\n\3\n\3\n\5\n\u0123\n\n\3\n\3\n\3\n")
+        buf.write(u"\3\n\3\n\3\n\3\n\5\n\u012c\n\n\3\n\3\n\3\n\3\n\3\n\5")
+        buf.write(u"\n\u0133\n\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\5\n\u013d")
+        buf.write(u"\n\n\3\n\3\n\6\n\u0141\n\n\r\n\16\n\u0142\5\n\u0145\n")
+        buf.write(u"\n\3\n\3\n\3\n\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\r\3")
+        buf.write(u"\r\3\r\3\r\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3")
+        buf.write(u"\16\3\16\3\16\3\17\3\17\3\17\3\17\3\17\3\20\3\20\3\20")
+        buf.write(u"\3\20\3\20\3\20\3\20\3\20\3\21\3\21\3\21\3\21\3\21\3")
+        buf.write(u"\21\3\21\3\21\3\21\3\21\3\21\3\22\3\22\3\22\3\22\3\22")
+        buf.write(u"\3\22\3\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3\24\3")
+        buf.write(u"\24\3\24\3\25\3\25\3\25\3\25\3\25\3\25\3\26\3\26\3\26")
+        buf.write(u"\3\26\3\26\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3")
+        buf.write(u"\30\3\30\3\30\3\30\3\30\3\31\3\31\3\31\3\31\3\31\3\31")
+        buf.write(u"\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\33\3\33\3\33\3")
+        buf.write(u"\33\3\33\3\33\3\33\3\33\3\34\3\34\3\34\3\34\3\34\3\34")
+        buf.write(u"\3\35\3\35\7\35\u01be\n\35\f\35\16\35\u01c1\13\35\3\36")
+        buf.write(u"\3\36\7\36\u01c5\n\36\f\36\16\36\u01c8\13\36\3\37\3\37")
+        buf.write(u"\3\37\5\37\u01cd\n\37\3 \3 \3 \3 \5 \u01d3\n \3!\3!\3")
+        buf.write(u"\"\3\"\3\"\3#\3#\3$\3$\3$\3%\3%\3&\3&\3\'\3\'\3(\3(\3")
+        buf.write(u")\3)\3*\3*\3+\3+\3,\3,\3-\3-\3.\3.\3/\3/\3\60\3\60\3")
+        buf.write(u"\61\3\61\3\62\3\62\3\63\3\63\3\64\3\64\3\65\3\65\3\66")
+        buf.write(u"\3\66\3\67\3\67\38\38\39\39\3:\3:\3;\3;\3<\3<\3=\3=\3")
+        buf.write(u">\3>\3?\3?\3@\3@\3A\3A\3B\3B\3C\3C\3D\3D\3E\3E\3F\3F")
+        buf.write(u"\3G\3G\3H\3H\3I\3I\3J\3J\3K\3K\3L\3L\3M\3M\3N\3N\3N\3")
+        buf.write(u"O\3O\3P\6P\u0237\nP\rP\16P\u0238\3P\3P\3Q\3Q\3Q\3Q\7")
+        buf.write(u"Q\u0241\nQ\fQ\16Q\u0244\13Q\3Q\3Q\3Q\3Q\3Q\3R\3R\3R\3")
+        buf.write(u"R\7R\u024f\nR\fR\16R\u0252\13R\3R\3R\3S\3S\3\u0242\2")
+        buf.write(u"T\3\3\5\4\7\5\t\6\13\7\r\b\17\t\21\n\23\13\25\f\27\r")
+        buf.write(u"\31\16\33\17\35\20\37\21!\22#\23%\24\'\25)\26+\27-\30")
+        buf.write(u"/\31\61\32\63\33\65\34\67\359\36;\37= ?!A\"C#E$G%I&K")
+        buf.write(u"\'M(O)Q*S+U,W-Y.[/]\60_\61a\62c\63e\2g\2i\2k\2m\2o\2")
+        buf.write(u"q\2s\2u\2w\2y\2{\2}\2\177\2\u0081\2\u0083\2\u0085\2\u0087")
+        buf.write(u"\2\u0089\2\u008b\2\u008d\2\u008f\2\u0091\2\u0093\2\u0095")
+        buf.write(u"\2\u0097\2\u0099\2\u009b\2\u009d\2\u009f\64\u00a1\65")
+        buf.write(u"\u00a3\66\u00a5\67\3\2-\3\2\639\3\2\62;\3\2\63:\4\2)")
+        buf.write(u")^^\3\2\63;\3\2\62\64\3\2\63\64\3\2\62\63\3\2\62\65\3")
+        buf.write(u"\2\62\67\5\2C\\aac|\6\2\62;C\\aac|\7\2//\62;C\\aac|\4")
+        buf.write(u"\2CCcc\4\2DDdd\4\2EEee\4\2FFff\4\2GGgg\4\2HHhh\4\2II")
+        buf.write(u"ii\4\2JJjj\4\2KKkk\4\2LLll\4\2MMmm\4\2NNnn\4\2OOoo\4")
+        buf.write(u"\2PPpp\4\2QQqq\4\2RRrr\4\2SSss\4\2TTtt\4\2UUuu\4\2VV")
+        buf.write(u"vv\4\2WWww\4\2XXxx\4\2YYyy\4\2ZZzz\4\2[[{{\4\2\\\\||")
+        buf.write(u"\5\2\62;CHch\6\2--\61;C\\c|\f\2\13\17\"\"\u0087\u0087")
+        buf.write(u"\u00a2\u00a2\u1682\u1682\u2002\u200c\u202a\u202b\u2031")
+        buf.write(u"\u2031\u2061\u2061\u3002\u3002\4\2\f\f\17\17\2\u0259")
+        buf.write(u"\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3\2\2\2\2\t\3\2\2\2\2\13")
+        buf.write(u"\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3")
+        buf.write(u"\2\2\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3")
+        buf.write(u"\2\2\2\2\35\3\2\2\2\2\37\3\2\2\2\2!\3\2\2\2\2#\3\2\2")
+        buf.write(u"\2\2%\3\2\2\2\2\'\3\2\2\2\2)\3\2\2\2\2+\3\2\2\2\2-\3")
+        buf.write(u"\2\2\2\2/\3\2\2\2\2\61\3\2\2\2\2\63\3\2\2\2\2\65\3\2")
+        buf.write(u"\2\2\2\67\3\2\2\2\29\3\2\2\2\2;\3\2\2\2\2=\3\2\2\2\2")
+        buf.write(u"?\3\2\2\2\2A\3\2\2\2\2C\3\2\2\2\2E\3\2\2\2\2G\3\2\2\2")
+        buf.write(u"\2I\3\2\2\2\2K\3\2\2\2\2M\3\2\2\2\2O\3\2\2\2\2Q\3\2\2")
+        buf.write(u"\2\2S\3\2\2\2\2U\3\2\2\2\2W\3\2\2\2\2Y\3\2\2\2\2[\3\2")
+        buf.write(u"\2\2\2]\3\2\2\2\2_\3\2\2\2\2a\3\2\2\2\2c\3\2\2\2\2\u009f")
+        buf.write(u"\3\2\2\2\2\u00a1\3\2\2\2\2\u00a3\3\2\2\2\2\u00a5\3\2")
+        buf.write(u"\2\2\3\u00a7\3\2\2\2\5\u00b3\3\2\2\2\7\u00bf\3\2\2\2")
+        buf.write(u"\t\u00cd\3\2\2\2\13\u00db\3\2\2\2\r\u00e5\3\2\2\2\17")
+        buf.write(u"\u0106\3\2\2\2\21\u0115\3\2\2\2\23\u0117\3\2\2\2\25\u0149")
+        buf.write(u"\3\2\2\2\27\u014d\3\2\2\2\31\u0150\3\2\2\2\33\u0154\3")
+        buf.write(u"\2\2\2\35\u015f\3\2\2\2\37\u0164\3\2\2\2!\u016c\3\2\2")
+        buf.write(u"\2#\u0177\3\2\2\2%\u0180\3\2\2\2\'\u0185\3\2\2\2)\u0188")
+        buf.write(u"\3\2\2\2+\u018e\3\2\2\2-\u0193\3\2\2\2/\u019b\3\2\2\2")
+        buf.write(u"\61\u01a0\3\2\2\2\63\u01a6\3\2\2\2\65\u01ad\3\2\2\2\67")
+        buf.write(u"\u01b5\3\2\2\29\u01bb\3\2\2\2;\u01c2\3\2\2\2=\u01cc\3")
+        buf.write(u"\2\2\2?\u01d2\3\2\2\2A\u01d4\3\2\2\2C\u01d6\3\2\2\2E")
+        buf.write(u"\u01d9\3\2\2\2G\u01db\3\2\2\2I\u01de\3\2\2\2K\u01e0\3")
+        buf.write(u"\2\2\2M\u01e2\3\2\2\2O\u01e4\3\2\2\2Q\u01e6\3\2\2\2S")
+        buf.write(u"\u01e8\3\2\2\2U\u01ea\3\2\2\2W\u01ec\3\2\2\2Y\u01ee\3")
+        buf.write(u"\2\2\2[\u01f0\3\2\2\2]\u01f2\3\2\2\2_\u01f4\3\2\2\2a")
+        buf.write(u"\u01f6\3\2\2\2c\u01f8\3\2\2\2e\u01fa\3\2\2\2g\u01fc\3")
+        buf.write(u"\2\2\2i\u01fe\3\2\2\2k\u0200\3\2\2\2m\u0202\3\2\2\2o")
+        buf.write(u"\u0204\3\2\2\2q\u0206\3\2\2\2s\u0208\3\2\2\2u\u020a\3")
+        buf.write(u"\2\2\2w\u020c\3\2\2\2y\u020e\3\2\2\2{\u0210\3\2\2\2}")
+        buf.write(u"\u0212\3\2\2\2\177\u0214\3\2\2\2\u0081\u0216\3\2\2\2")
+        buf.write(u"\u0083\u0218\3\2\2\2\u0085\u021a\3\2\2\2\u0087\u021c")
+        buf.write(u"\3\2\2\2\u0089\u021e\3\2\2\2\u008b\u0220\3\2\2\2\u008d")
+        buf.write(u"\u0222\3\2\2\2\u008f\u0224\3\2\2\2\u0091\u0226\3\2\2")
+        buf.write(u"\2\u0093\u0228\3\2\2\2\u0095\u022a\3\2\2\2\u0097\u022c")
+        buf.write(u"\3\2\2\2\u0099\u022e\3\2\2\2\u009b\u0230\3\2\2\2\u009d")
+        buf.write(u"\u0233\3\2\2\2\u009f\u0236\3\2\2\2\u00a1\u023c\3\2\2")
+        buf.write(u"\2\u00a3\u024a\3\2\2\2\u00a5\u0255\3\2\2\2\u00a7\u00b0")
+        buf.write(u"\7/\2\2\u00a8\u00b1\7\62\2\2\u00a9\u00ad\t\2\2\2\u00aa")
+        buf.write(u"\u00ac\t\3\2\2\u00ab\u00aa\3\2\2\2\u00ac\u00af\3\2\2")
+        buf.write(u"\2\u00ad\u00ab\3\2\2\2\u00ad\u00ae\3\2\2\2\u00ae\u00b1")
+        buf.write(u"\3\2\2\2\u00af\u00ad\3\2\2\2\u00b0\u00a8\3\2\2\2\u00b0")
+        buf.write(u"\u00a9\3\2\2\2\u00b1\4\3\2\2\2\u00b2\u00b4\7-\2\2\u00b3")
+        buf.write(u"\u00b2\3\2\2\2\u00b3\u00b4\3\2\2\2\u00b4\u00bd\3\2\2")
+        buf.write(u"\2\u00b5\u00be\7\62\2\2\u00b6\u00ba\t\4\2\2\u00b7\u00b9")
+        buf.write(u"\t\3\2\2\u00b8\u00b7\3\2\2\2\u00b9\u00bc\3\2\2\2\u00ba")
+        buf.write(u"\u00b8\3\2\2\2\u00ba\u00bb\3\2\2\2\u00bb\u00be\3\2\2")
+        buf.write(u"\2\u00bc\u00ba\3\2\2\2\u00bd\u00b5\3\2\2\2\u00bd\u00b6")
+        buf.write(u"\3\2\2\2\u00be\6\3\2\2\2\u00bf\u00c3\7/\2\2\u00c0\u00c2")
+        buf.write(u"\t\3\2\2\u00c1\u00c0\3\2\2\2\u00c2\u00c5\3\2\2\2\u00c3")
+        buf.write(u"\u00c1\3\2\2\2\u00c3\u00c4\3\2\2\2\u00c4\u00c6\3\2\2")
+        buf.write(u"\2\u00c5\u00c3\3\2\2\2\u00c6\u00c8\7\60\2\2\u00c7\u00c9")
+        buf.write(u"\t\3\2\2\u00c8\u00c7\3\2\2\2\u00c9\u00ca\3\2\2\2\u00ca")
+        buf.write(u"\u00c8\3\2\2\2\u00ca\u00cb\3\2\2\2\u00cb\b\3\2\2\2\u00cc")
+        buf.write(u"\u00ce\7-\2\2\u00cd\u00cc\3\2\2\2\u00cd\u00ce\3\2\2\2")
+        buf.write(u"\u00ce\u00d2\3\2\2\2\u00cf\u00d1\t\3\2\2\u00d0\u00cf")
+        buf.write(u"\3\2\2\2\u00d1\u00d4\3\2\2\2\u00d2\u00d0\3\2\2\2\u00d2")
+        buf.write(u"\u00d3\3\2\2\2\u00d3\u00d5\3\2\2\2\u00d4\u00d2\3\2\2")
+        buf.write(u"\2\u00d5\u00d7\7\60\2\2\u00d6\u00d8\t\3\2\2\u00d7\u00d6")
+        buf.write(u"\3\2\2\2\u00d8\u00d9\3\2\2\2\u00d9\u00d7\3\2\2\2\u00d9")
+        buf.write(u"\u00da\3\2\2\2\u00da\n\3\2\2\2\u00db\u00dc\7j\2\2\u00dc")
+        buf.write(u"\u00e0\5I%\2\u00dd\u00df\5\u009bN\2\u00de\u00dd\3\2\2")
+        buf.write(u"\2\u00df\u00e2\3\2\2\2\u00e0\u00de\3\2\2\2\u00e0\u00e1")
+        buf.write(u"\3\2\2\2\u00e1\u00e3\3\2\2\2\u00e2\u00e0\3\2\2\2\u00e3")
+        buf.write(u"\u00e4\5I%\2\u00e4\f\3\2\2\2\u00e5\u00e6\7d\2\2\u00e6")
+        buf.write(u"\u00ee\5I%\2\u00e7\u00e8\5\u009dO\2\u00e8\u00e9\5\u009d")
+        buf.write(u"O\2\u00e9\u00ea\5\u009dO\2\u00ea\u00eb\5\u009dO\2\u00eb")
+        buf.write(u"\u00ed\3\2\2\2\u00ec\u00e7\3\2\2\2\u00ed\u00f0\3\2\2")
+        buf.write(u"\2\u00ee\u00ec\3\2\2\2\u00ee\u00ef\3\2\2\2\u00ef\u0102")
+        buf.write(u"\3\2\2\2\u00f0\u00ee\3\2\2\2\u00f1\u00f2\5\u009dO\2\u00f2")
+        buf.write(u"\u00f3\5\u009dO\2\u00f3\u00f4\5\u009dO\2\u00f4\u00f5")
+        buf.write(u"\5\u009dO\2\u00f5\u0103\3\2\2\2\u00f6\u00f7\5\u009dO")
+        buf.write(u"\2\u00f7\u00f8\5\u009dO\2\u00f8\u00f9\5\u009dO\2\u00f9")
+        buf.write(u"\u00fa\3\2\2\2\u00fa\u00fb\7?\2\2\u00fb\u0103\3\2\2\2")
+        buf.write(u"\u00fc\u00fd\5\u009dO\2\u00fd\u00fe\5\u009dO\2\u00fe")
+        buf.write(u"\u00ff\3\2\2\2\u00ff\u0100\7?\2\2\u0100\u0101\7?\2\2")
+        buf.write(u"\u0101\u0103\3\2\2\2\u0102\u00f1\3\2\2\2\u0102\u00f6")
+        buf.write(u"\3\2\2\2\u0102\u00fc\3\2\2\2\u0103\u0104\3\2\2\2\u0104")
+        buf.write(u"\u0105\5I%\2\u0105\16\3\2\2\2\u0106\u010e\5I%\2\u0107")
+        buf.write(u"\u010d\n\5\2\2\u0108\u0109\7^\2\2\u0109\u010d\7)\2\2")
+        buf.write(u"\u010a\u010b\7^\2\2\u010b\u010d\7^\2\2\u010c\u0107\3")
+        buf.write(u"\2\2\2\u010c\u0108\3\2\2\2\u010c\u010a\3\2\2\2\u010d")
+        buf.write(u"\u0110\3\2\2\2\u010e\u010c\3\2\2\2\u010e\u010f\3\2\2")
+        buf.write(u"\2\u010f\u0111\3\2\2\2\u0110\u010e\3\2\2\2\u0111\u0112")
+        buf.write(u"\5I%\2\u0112\20\3\2\2\2\u0113\u0116\5/\30\2\u0114\u0116")
+        buf.write(u"\5\61\31\2\u0115\u0113\3\2\2\2\u0115\u0114\3\2\2\2\u0116")
+        buf.write(u"\22\3\2\2\2\u0117\u0118\7v\2\2\u0118\u0119\5I%\2\u0119")
+        buf.write(u"\u011a\t\3\2\2\u011a\u011b\t\3\2\2\u011b\u011c\t\3\2")
+        buf.write(u"\2\u011c\u011d\t\3\2\2\u011d\u0122\5[.\2\u011e\u011f")
+        buf.write(u"\7\62\2\2\u011f\u0123\t\6\2\2\u0120\u0121\7\63\2\2\u0121")
+        buf.write(u"\u0123\t\7\2\2\u0122\u011e\3\2\2\2\u0122\u0120\3\2\2")
+        buf.write(u"\2\u0123\u0124\3\2\2\2\u0124\u012b\5[.\2\u0125\u0126")
+        buf.write(u"\7\62\2\2\u0126\u012c\t\6\2\2\u0127\u0128\t\b\2\2\u0128")
+        buf.write(u"\u012c\t\3\2\2\u0129\u012a\7\65\2\2\u012a\u012c\t\t\2")
+        buf.write(u"\2\u012b\u0125\3\2\2\2\u012b\u0127\3\2\2\2\u012b\u0129")
+        buf.write(u"\3\2\2\2\u012c\u012d\3\2\2\2\u012d\u0132\7V\2\2\u012e")
+        buf.write(u"\u012f\t\t\2\2\u012f\u0133\t\3\2\2\u0130\u0131\7\64\2")
+        buf.write(u"\2\u0131\u0133\t\n\2\2\u0132\u012e\3\2\2\2\u0132\u0130")
+        buf.write(u"\3\2\2\2\u0133\u0134\3\2\2\2\u0134\u0135\5K&\2\u0135")
+        buf.write(u"\u0136\t\13\2\2\u0136\u0137\t\3\2\2\u0137\u013c\5K&\2")
+        buf.write(u"\u0138\u0139\t\13\2\2\u0139\u013d\t\3\2\2\u013a\u013b")
+        buf.write(u"\78\2\2\u013b\u013d\7\62\2\2\u013c\u0138\3\2\2\2\u013c")
+        buf.write(u"\u013a\3\2\2\2\u013d\u0144\3\2\2\2\u013e\u0140\5M\'\2")
+        buf.write(u"\u013f\u0141\t\3\2\2\u0140\u013f\3\2\2\2\u0141\u0142")
+        buf.write(u"\3\2\2\2\u0142\u0140\3\2\2\2\u0142\u0143\3\2\2\2\u0143")
+        buf.write(u"\u0145\3\2\2\2\u0144\u013e\3\2\2\2\u0144\u0145\3\2\2")
+        buf.write(u"\2\u0145\u0146\3\2\2\2\u0146\u0147\7\\\2\2\u0147\u0148")
+        buf.write(u"\5I%\2\u0148\24\3\2\2\2\u0149\u014a\5e\63\2\u014a\u014b")
+        buf.write(u"\5\177@\2\u014b\u014c\5k\66\2\u014c\26\3\2\2\2\u014d")
+        buf.write(u"\u014e\5\u0081A\2\u014e\u014f\5\u0087D\2\u014f\30\3\2")
+        buf.write(u"\2\2\u0150\u0151\5\177@\2\u0151\u0152\5\u0081A\2\u0152")
+        buf.write(u"\u0153\5\u008bF\2\u0153\32\3\2\2\2\u0154\u0155\5o8\2")
+        buf.write(u"\u0155\u0156\5\u0081A\2\u0156\u0157\5{>\2\u0157\u0158")
+        buf.write(u"\5{>\2\u0158\u0159\5\u0081A\2\u0159\u015a\5\u0091I\2")
+        buf.write(u"\u015a\u015b\5m\67\2\u015b\u015c\5k\66\2\u015c\u015d")
+        buf.write(u"\5g\64\2\u015d\u015e\5\u0095K\2\u015e\34\3\2\2\2\u015f")
+        buf.write(u"\u0160\5{>\2\u0160\u0161\5u;\2\u0161\u0162\5y=\2\u0162")
+        buf.write(u"\u0163\5m\67\2\u0163\36\3\2\2\2\u0164\u0165\5}?\2\u0165")
+        buf.write(u"\u0166\5e\63\2\u0166\u0167\5\u008bF\2\u0167\u0168\5i")
+        buf.write(u"\65\2\u0168\u0169\5s:\2\u0169\u016a\5m\67\2\u016a\u016b")
+        buf.write(u"\5\u0089E\2\u016b \3\2\2\2\u016c\u016d\5u;\2\u016d\u016e")
+        buf.write(u"\5\u0089E\2\u016e\u016f\5\u0089E\2\u016f\u0170\5\u008d")
+        buf.write(u"G\2\u0170\u0171\5\u0083B\2\u0171\u0172\5m\67\2\u0172")
+        buf.write(u"\u0173\5\u0087D\2\u0173\u0174\5\u0089E\2\u0174\u0175")
+        buf.write(u"\5m\67\2\u0175\u0176\5\u008bF\2\u0176\"\3\2\2\2\u0177")
+        buf.write(u"\u0178\5u;\2\u0178\u0179\5\u0089E\2\u0179\u017a\5\u0089")
+        buf.write(u"E\2\u017a\u017b\5\u008dG\2\u017b\u017c\5g\64\2\u017c")
+        buf.write(u"\u017d\5\u0089E\2\u017d\u017e\5m\67\2\u017e\u017f\5\u008b")
+        buf.write(u"F\2\u017f$\3\2\2\2\u0180\u0181\5{>\2\u0181\u0182\5e\63")
+        buf.write(u"\2\u0182\u0183\5\u0089E\2\u0183\u0184\5\u008bF\2\u0184")
+        buf.write(u"&\3\2\2\2\u0185\u0186\5u;\2\u0186\u0187\5\177@\2\u0187")
+        buf.write(u"(\3\2\2\2\u0188\u0189\5\u0089E\2\u0189\u018a\5\u008b")
+        buf.write(u"F\2\u018a\u018b\5e\63\2\u018b\u018c\5\u0087D\2\u018c")
+        buf.write(u"\u018d\5\u008bF\2\u018d*\3\2\2\2\u018e\u018f\5\u0089")
+        buf.write(u"E\2\u018f\u0190\5\u008bF\2\u0190\u0191\5\u0081A\2\u0191")
+        buf.write(u"\u0192\5\u0083B\2\u0192,\3\2\2\2\u0193\u0194\5\u0089")
+        buf.write(u"E\2\u0194\u0195\5m\67\2\u0195\u0196\5i\65\2\u0196\u0197")
+        buf.write(u"\5\u0081A\2\u0197\u0198\5\177@\2\u0198\u0199\5k\66\2")
+        buf.write(u"\u0199\u019a\5\u0089E\2\u019a.\3\2\2\2\u019b\u019c\5")
+        buf.write(u"\u008bF\2\u019c\u019d\5\u0087D\2\u019d\u019e\5\u008d")
+        buf.write(u"G\2\u019e\u019f\5m\67\2\u019f\60\3\2\2\2\u01a0\u01a1")
+        buf.write(u"\5o8\2\u01a1\u01a2\5e\63\2\u01a2\u01a3\5{>\2\u01a3\u01a4")
+        buf.write(u"\5\u0089E\2\u01a4\u01a5\5m\67\2\u01a5\62\3\2\2\2\u01a6")
+        buf.write(u"\u01a7\5\u0091I\2\u01a7\u01a8\5u;\2\u01a8\u01a9\5\u008b")
+        buf.write(u"F\2\u01a9\u01aa\5s:\2\u01aa\u01ab\5u;\2\u01ab\u01ac\5")
+        buf.write(u"\177@\2\u01ac\64\3\2\2\2\u01ad\u01ae\5\u0087D\2\u01ae")
+        buf.write(u"\u01af\5m\67\2\u01af\u01b0\5\u0083B\2\u01b0\u01b1\5m")
+        buf.write(u"\67\2\u01b1\u01b2\5e\63\2\u01b2\u01b3\5\u008bF\2\u01b3")
+        buf.write(u"\u01b4\5\u0089E\2\u01b4\66\3\2\2\2\u01b5\u01b6\5\u008b")
+        buf.write(u"F\2\u01b6\u01b7\5u;\2\u01b7\u01b8\5}?\2\u01b8\u01b9\5")
+        buf.write(u"m\67\2\u01b9\u01ba\5\u0089E\2\u01ba8\3\2\2\2\u01bb\u01bf")
+        buf.write(u"\t\f\2\2\u01bc\u01be\t\r\2\2\u01bd\u01bc\3\2\2\2\u01be")
+        buf.write(u"\u01c1\3\2\2\2\u01bf\u01bd\3\2\2\2\u01bf\u01c0\3\2\2")
+        buf.write(u"\2\u01c0:\3\2\2\2\u01c1\u01bf\3\2\2\2\u01c2\u01c6\t\f")
+        buf.write(u"\2\2\u01c3\u01c5\t\16\2\2\u01c4\u01c3\3\2\2\2\u01c5\u01c8")
+        buf.write(u"\3\2\2\2\u01c6\u01c4\3\2\2\2\u01c6\u01c7\3\2\2\2\u01c7")
+        buf.write(u"<\3\2\2\2\u01c8\u01c6\3\2\2\2\u01c9\u01cd\7?\2\2\u01ca")
+        buf.write(u"\u01cb\7?\2\2\u01cb\u01cd\7?\2\2\u01cc\u01c9\3\2\2\2")
+        buf.write(u"\u01cc\u01ca\3\2\2\2\u01cd>\3\2\2\2\u01ce\u01cf\7#\2")
+        buf.write(u"\2\u01cf\u01d3\7?\2\2\u01d0\u01d1\7>\2\2\u01d1\u01d3")
+        buf.write(u"\7@\2\2\u01d2\u01ce\3\2\2\2\u01d2\u01d0\3\2\2\2\u01d3")
+        buf.write(u"@\3\2\2\2\u01d4\u01d5\7>\2\2\u01d5B\3\2\2\2\u01d6\u01d7")
+        buf.write(u"\7>\2\2\u01d7\u01d8\7?\2\2\u01d8D\3\2\2\2\u01d9\u01da")
+        buf.write(u"\7@\2\2\u01daF\3\2\2\2\u01db\u01dc\7@\2\2\u01dc\u01dd")
+        buf.write(u"\7?\2\2\u01ddH\3\2\2\2\u01de\u01df\7)\2\2\u01dfJ\3\2")
+        buf.write(u"\2\2\u01e0\u01e1\7<\2\2\u01e1L\3\2\2\2\u01e2\u01e3\7")
+        buf.write(u"\60\2\2\u01e3N\3\2\2\2\u01e4\u01e5\7.\2\2\u01e5P\3\2")
+        buf.write(u"\2\2\u01e6\u01e7\7+\2\2\u01e7R\3\2\2\2\u01e8\u01e9\7")
+        buf.write(u"*\2\2\u01e9T\3\2\2\2\u01ea\u01eb\7_\2\2\u01ebV\3\2\2")
+        buf.write(u"\2\u01ec\u01ed\7]\2\2\u01edX\3\2\2\2\u01ee\u01ef\7-\2")
+        buf.write(u"\2\u01efZ\3\2\2\2\u01f0\u01f1\5]/\2\u01f1\\\3\2\2\2\u01f2")
+        buf.write(u"\u01f3\7/\2\2\u01f3^\3\2\2\2\u01f4\u01f5\7`\2\2\u01f5")
+        buf.write(u"`\3\2\2\2\u01f6\u01f7\7\61\2\2\u01f7b\3\2\2\2\u01f8\u01f9")
+        buf.write(u"\7,\2\2\u01f9d\3\2\2\2\u01fa\u01fb\t\17\2\2\u01fbf\3")
+        buf.write(u"\2\2\2\u01fc\u01fd\t\20\2\2\u01fdh\3\2\2\2\u01fe\u01ff")
+        buf.write(u"\t\21\2\2\u01ffj\3\2\2\2\u0200\u0201\t\22\2\2\u0201l")
+        buf.write(u"\3\2\2\2\u0202\u0203\t\23\2\2\u0203n\3\2\2\2\u0204\u0205")
+        buf.write(u"\t\24\2\2\u0205p\3\2\2\2\u0206\u0207\t\25\2\2\u0207r")
+        buf.write(u"\3\2\2\2\u0208\u0209\t\26\2\2\u0209t\3\2\2\2\u020a\u020b")
+        buf.write(u"\t\27\2\2\u020bv\3\2\2\2\u020c\u020d\t\30\2\2\u020dx")
+        buf.write(u"\3\2\2\2\u020e\u020f\t\31\2\2\u020fz\3\2\2\2\u0210\u0211")
+        buf.write(u"\t\32\2\2\u0211|\3\2\2\2\u0212\u0213\t\33\2\2\u0213~")
+        buf.write(u"\3\2\2\2\u0214\u0215\t\34\2\2\u0215\u0080\3\2\2\2\u0216")
+        buf.write(u"\u0217\t\35\2\2\u0217\u0082\3\2\2\2\u0218\u0219\t\36")
+        buf.write(u"\2\2\u0219\u0084\3\2\2\2\u021a\u021b\t\37\2\2\u021b\u0086")
+        buf.write(u"\3\2\2\2\u021c\u021d\t \2\2\u021d\u0088\3\2\2\2\u021e")
+        buf.write(u"\u021f\t!\2\2\u021f\u008a\3\2\2\2\u0220\u0221\t\"\2\2")
+        buf.write(u"\u0221\u008c\3\2\2\2\u0222\u0223\t#\2\2\u0223\u008e\3")
+        buf.write(u"\2\2\2\u0224\u0225\t$\2\2\u0225\u0090\3\2\2\2\u0226\u0227")
+        buf.write(u"\t%\2\2\u0227\u0092\3\2\2\2\u0228\u0229\t&\2\2\u0229")
+        buf.write(u"\u0094\3\2\2\2\u022a\u022b\t\'\2\2\u022b\u0096\3\2\2")
+        buf.write(u"\2\u022c\u022d\t(\2\2\u022d\u0098\3\2\2\2\u022e\u022f")
+        buf.write(u"\t)\2\2\u022f\u009a\3\2\2\2\u0230\u0231\5\u0099M\2\u0231")
+        buf.write(u"\u0232\5\u0099M\2\u0232\u009c\3\2\2\2\u0233\u0234\t*")
+        buf.write(u"\2\2\u0234\u009e\3\2\2\2\u0235\u0237\t+\2\2\u0236\u0235")
+        buf.write(u"\3\2\2\2\u0237\u0238\3\2\2\2\u0238\u0236\3\2\2\2\u0238")
+        buf.write(u"\u0239\3\2\2\2\u0239\u023a\3\2\2\2\u023a\u023b\bP\2\2")
+        buf.write(u"\u023b\u00a0\3\2\2\2\u023c\u023d\7\61\2\2\u023d\u023e")
+        buf.write(u"\7,\2\2\u023e\u0242\3\2\2\2\u023f\u0241\13\2\2\2\u0240")
+        buf.write(u"\u023f\3\2\2\2\u0241\u0244\3\2\2\2\u0242\u0243\3\2\2")
+        buf.write(u"\2\u0242\u0240\3\2\2\2\u0243\u0245\3\2\2\2\u0244\u0242")
+        buf.write(u"\3\2\2\2\u0245\u0246\7,\2\2\u0246\u0247\7\61\2\2\u0247")
+        buf.write(u"\u0248\3\2\2\2\u0248\u0249\bQ\2\2\u0249\u00a2\3\2\2\2")
+        buf.write(u"\u024a\u024b\7\61\2\2\u024b\u024c\7\61\2\2\u024c\u0250")
+        buf.write(u"\3\2\2\2\u024d\u024f\n,\2\2\u024e\u024d\3\2\2\2\u024f")
+        buf.write(u"\u0252\3\2\2\2\u0250\u024e\3\2\2\2\u0250\u0251\3\2\2")
+        buf.write(u"\2\u0251\u0253\3\2\2\2\u0252\u0250\3\2\2\2\u0253\u0254")
+        buf.write(u"\bR\2\2\u0254\u00a4\3\2\2\2\u0255\u0256\13\2\2\2\u0256")
+        buf.write(u"\u00a6\3\2\2\2 \2\u00ad\u00b0\u00b3\u00ba\u00bd\u00c3")
+        buf.write(u"\u00ca\u00cd\u00d2\u00d9\u00e0\u00ee\u0102\u010c\u010e")
+        buf.write(u"\u0115\u0122\u012b\u0132\u013c\u0142\u0144\u01bf\u01c6")
+        buf.write(u"\u01cc\u01d2\u0238\u0242\u0250\3\b\2\2")
         return buf.getvalue()
 
 
@@ -256,100 +298,103 @@ class STIXPatternLexer(Lexer):
 
     atn = ATNDeserializer().deserialize(serializedATN())
 
-    decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)]
+    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
 
-    IntLiteral = 1
-    FloatLiteral = 2
-    HexLiteral = 3
-    BinaryLiteral = 4
-    StringLiteral = 5
-    BoolLiteral = 6
-    TimestampLiteral = 7
-    AND = 8
-    OR = 9
-    NOT = 10
-    FOLLOWEDBY = 11
-    LIKE = 12
-    MATCHES = 13
-    ISSUPERSET = 14
-    ISSUBSET = 15
-    LAST = 16
-    IN = 17
-    START = 18
-    STOP = 19
-    SECONDS = 20
-    TRUE = 21
-    FALSE = 22
-    WITHIN = 23
-    REPEATS = 24
-    TIMES = 25
-    IdentifierWithoutHyphen = 26
-    IdentifierWithHyphen = 27
-    EQ = 28
-    NEQ = 29
-    LT = 30
-    LE = 31
-    GT = 32
-    GE = 33
-    QUOTE = 34
-    COLON = 35
-    DOT = 36
-    COMMA = 37
-    RPAREN = 38
-    LPAREN = 39
-    RBRACK = 40
-    LBRACK = 41
-    PLUS = 42
-    HYPHEN = 43
-    MINUS = 44
-    POWER_OP = 45
-    DIVIDE = 46
-    ASTERISK = 47
-    WS = 48
-    COMMENT = 49
-    LINE_COMMENT = 50
+    IntNegLiteral = 1
+    IntPosLiteral = 2
+    FloatNegLiteral = 3
+    FloatPosLiteral = 4
+    HexLiteral = 5
+    BinaryLiteral = 6
+    StringLiteral = 7
+    BoolLiteral = 8
+    TimestampLiteral = 9
+    AND = 10
+    OR = 11
+    NOT = 12
+    FOLLOWEDBY = 13
+    LIKE = 14
+    MATCHES = 15
+    ISSUPERSET = 16
+    ISSUBSET = 17
+    LAST = 18
+    IN = 19
+    START = 20
+    STOP = 21
+    SECONDS = 22
+    TRUE = 23
+    FALSE = 24
+    WITHIN = 25
+    REPEATS = 26
+    TIMES = 27
+    IdentifierWithoutHyphen = 28
+    IdentifierWithHyphen = 29
+    EQ = 30
+    NEQ = 31
+    LT = 32
+    LE = 33
+    GT = 34
+    GE = 35
+    QUOTE = 36
+    COLON = 37
+    DOT = 38
+    COMMA = 39
+    RPAREN = 40
+    LPAREN = 41
+    RBRACK = 42
+    LBRACK = 43
+    PLUS = 44
+    HYPHEN = 45
+    MINUS = 46
+    POWER_OP = 47
+    DIVIDE = 48
+    ASTERISK = 49
+    WS = 50
+    COMMENT = 51
+    LINE_COMMENT = 52
+    InvalidCharacter = 53
 
-    channelNames = [u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN"]
+    channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ]
 
-    modeNames = [u"DEFAULT_MODE"]
+    modeNames = [ u"DEFAULT_MODE" ]
 
-    literalNames = [u"<INVALID>", u"'<'", u"'<='", u"'>'", u"'>='", u"'''",
-                    u"':'", u"'.'", u"','", u"')'", u"'('", u"']'", u"'['",
-                    u"'+'", u"'-'", u"'^'", u"'/'", u"'*'"]
+    literalNames = [ u"<INVALID>",
+            u"'<'", u"'<='", u"'>'", u"'>='", u"'''", u"':'", u"'.'", u"','",
+            u"')'", u"'('", u"']'", u"'['", u"'+'", u"'-'", u"'^'", u"'/'",
+            u"'*'" ]
 
-    symbolicNames = [u"<INVALID>", u"IntLiteral", u"FloatLiteral",
-                     u"HexLiteral", u"BinaryLiteral", u"StringLiteral",
-                     u"BoolLiteral", u"TimestampLiteral", u"AND", u"OR",
-                     u"NOT", u"FOLLOWEDBY", u"LIKE", u"MATCHES", u"ISSUPERSET",
-                     u"ISSUBSET", u"LAST", u"IN", u"START", u"STOP", u"SECONDS",
-                     u"TRUE", u"FALSE", u"WITHIN", u"REPEATS", u"TIMES",
-                     u"IdentifierWithoutHyphen", u"IdentifierWithHyphen",
-                     u"EQ", u"NEQ", u"LT", u"LE", u"GT", u"GE", u"QUOTE",
-                     u"COLON", u"DOT", u"COMMA", u"RPAREN", u"LPAREN",
-                     u"RBRACK", u"LBRACK", u"PLUS", u"HYPHEN", u"MINUS",
-                     u"POWER_OP", u"DIVIDE", u"ASTERISK", u"WS", u"COMMENT",
-                     u"LINE_COMMENT"]
+    symbolicNames = [ u"<INVALID>",
+            u"IntNegLiteral", u"IntPosLiteral", u"FloatNegLiteral", u"FloatPosLiteral",
+            u"HexLiteral", u"BinaryLiteral", u"StringLiteral", u"BoolLiteral",
+            u"TimestampLiteral", u"AND", u"OR", u"NOT", u"FOLLOWEDBY", u"LIKE",
+            u"MATCHES", u"ISSUPERSET", u"ISSUBSET", u"LAST", u"IN", u"START",
+            u"STOP", u"SECONDS", u"TRUE", u"FALSE", u"WITHIN", u"REPEATS",
+            u"TIMES", u"IdentifierWithoutHyphen", u"IdentifierWithHyphen",
+            u"EQ", u"NEQ", u"LT", u"LE", u"GT", u"GE", u"QUOTE", u"COLON",
+            u"DOT", u"COMMA", u"RPAREN", u"LPAREN", u"RBRACK", u"LBRACK",
+            u"PLUS", u"HYPHEN", u"MINUS", u"POWER_OP", u"DIVIDE", u"ASTERISK",
+            u"WS", u"COMMENT", u"LINE_COMMENT", u"InvalidCharacter" ]
 
-    ruleNames = [u"IntLiteral", u"FloatLiteral", u"HexLiteral", u"BinaryLiteral",
-                 u"StringLiteral", u"BoolLiteral", u"TimestampLiteral",
-                 u"AND", u"OR", u"NOT", u"FOLLOWEDBY", u"LIKE", u"MATCHES",
-                 u"ISSUPERSET", u"ISSUBSET", u"LAST", u"IN", u"START",
-                 u"STOP", u"SECONDS", u"TRUE", u"FALSE", u"WITHIN", u"REPEATS",
-                 u"TIMES", u"IdentifierWithoutHyphen", u"IdentifierWithHyphen",
-                 u"EQ", u"NEQ", u"LT", u"LE", u"GT", u"GE", u"QUOTE", u"COLON",
-                 u"DOT", u"COMMA", u"RPAREN", u"LPAREN", u"RBRACK", u"LBRACK",
-                 u"PLUS", u"HYPHEN", u"MINUS", u"POWER_OP", u"DIVIDE",
-                 u"ASTERISK", u"A", u"B", u"C", u"D", u"E", u"F", u"G",
-                 u"H", u"I", u"J", u"K", u"L", u"M", u"N", u"O", u"P",
-                 u"Q", u"R", u"S", u"T", u"U", u"V", u"W", u"X", u"Y",
-                 u"Z", u"HexDigit", u"TwoHexDigits", u"Base64Char", u"WS",
-                 u"COMMENT", u"LINE_COMMENT"]
+    ruleNames = [ u"IntNegLiteral", u"IntPosLiteral", u"FloatNegLiteral",
+                  u"FloatPosLiteral", u"HexLiteral", u"BinaryLiteral", u"StringLiteral",
+                  u"BoolLiteral", u"TimestampLiteral", u"AND", u"OR", u"NOT",
+                  u"FOLLOWEDBY", u"LIKE", u"MATCHES", u"ISSUPERSET", u"ISSUBSET",
+                  u"LAST", u"IN", u"START", u"STOP", u"SECONDS", u"TRUE",
+                  u"FALSE", u"WITHIN", u"REPEATS", u"TIMES", u"IdentifierWithoutHyphen",
+                  u"IdentifierWithHyphen", u"EQ", u"NEQ", u"LT", u"LE",
+                  u"GT", u"GE", u"QUOTE", u"COLON", u"DOT", u"COMMA", u"RPAREN",
+                  u"LPAREN", u"RBRACK", u"LBRACK", u"PLUS", u"HYPHEN", u"MINUS",
+                  u"POWER_OP", u"DIVIDE", u"ASTERISK", u"A", u"B", u"C",
+                  u"D", u"E", u"F", u"G", u"H", u"I", u"J", u"K", u"L",
+                  u"M", u"N", u"O", u"P", u"Q", u"R", u"S", u"T", u"U",
+                  u"V", u"W", u"X", u"Y", u"Z", u"HexDigit", u"TwoHexDigits",
+                  u"Base64Char", u"WS", u"COMMENT", u"LINE_COMMENT", u"InvalidCharacter" ]
 
     grammarFileName = u"STIXPattern.g4"
 
     def __init__(self, input=None, output=sys.stdout):
         super(STIXPatternLexer, self).__init__(input, output=output)
-        self.checkVersion("4.7")
+        self.checkVersion("4.7.1")
         self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache())
         self._actions = None
         self._predicates = None
diff --git a/stix2patterns/grammars/STIXPatternListener.py b/stix2patterns/grammars/STIXPatternListener.py
index e8e17fd..e7f88d4 100644
--- a/stix2patterns/grammars/STIXPatternListener.py
+++ b/stix2patterns/grammars/STIXPatternListener.py
@@ -1,4 +1,5 @@
-# Generated from STIXPattern.g4 by ANTLR 4.7
+# Generated from STIXPattern.g4 by ANTLR 4.7.1
+
 from antlr4 import *
 
 
@@ -13,6 +14,7 @@ class STIXPatternListener(ParseTreeListener):
     def exitPattern(self, ctx):
         pass
 
+
     # Enter a parse tree produced by STIXPatternParser#observationExpressions.
     def enterObservationExpressions(self, ctx):
         pass
@@ -21,6 +23,7 @@ class STIXPatternListener(ParseTreeListener):
     def exitObservationExpressions(self, ctx):
         pass
 
+
     # Enter a parse tree produced by STIXPatternParser#observationExpressionOr.
     def enterObservationExpressionOr(self, ctx):
         pass
@@ -29,6 +32,7 @@ class STIXPatternListener(ParseTreeListener):
     def exitObservationExpressionOr(self, ctx):
         pass
 
+
     # Enter a parse tree produced by STIXPatternParser#observationExpressionAnd.
     def enterObservationExpressionAnd(self, ctx):
         pass
@@ -37,6 +41,7 @@ class STIXPatternListener(ParseTreeListener):
     def exitObservationExpressionAnd(self, ctx):
         pass
 
+
     # Enter a parse tree produced by STIXPatternParser#observationExpressionRepeated.
     def enterObservationExpressionRepeated(self, ctx):
         pass
@@ -45,6 +50,7 @@ class STIXPatternListener(ParseTreeListener):
     def exitObservationExpressionRepeated(self, ctx):
         pass
 
+
     # Enter a parse tree produced by STIXPatternParser#observationExpressionSimple.
     def enterObservationExpressionSimple(self, ctx):
         pass
@@ -53,6 +59,7 @@ class STIXPatternListener(ParseTreeListener):
     def exitObservationExpressionSimple(self, ctx):
         pass
 
+
     # Enter a parse tree produced by STIXPatternParser#observationExpressionCompound.
     def enterObservationExpressionCompound(self, ctx):
         pass
@@ -61,6 +68,7 @@ class STIXPatternListener(ParseTreeListener):
     def exitObservationExpressionCompound(self, ctx):
         pass
 
+
     # Enter a parse tree produced by STIXPatternParser#observationExpressionWithin.
     def enterObservationExpressionWithin(self, ctx):
         pass
@@ -69,6 +77,7 @@ class STIXPatternListener(ParseTreeListener):
     def exitObservationExpressionWithin(self, ctx):
         pass
 
+
     # Enter a parse tree produced by STIXPatternParser#observationExpressionStartStop.
     def enterObservationExpressionStartStop(self, ctx):
         pass
@@ -77,6 +86,7 @@ class STIXPatternListener(ParseTreeListener):
     def exitObservationExpressionStartStop(self, ctx):
         pass
 
+
     # Enter a parse tree produced by STIXPatternParser#comparisonExpression.
     def enterComparisonExpression(self, ctx):
         pass
@@ -85,6 +95,7 @@ class STIXPatternListener(ParseTreeListener):
     def exitComparisonExpression(self, ctx):
         pass
 
+
     # Enter a parse tree produced by STIXPatternParser#comparisonExpressionAnd.
     def enterComparisonExpressionAnd(self, ctx):
         pass
@@ -93,6 +104,7 @@ class STIXPatternListener(ParseTreeListener):
     def exitComparisonExpressionAnd(self, ctx):
         pass
 
+
     # Enter a parse tree produced by STIXPatternParser#propTestEqual.
     def enterPropTestEqual(self, ctx):
         pass
@@ -101,6 +113,7 @@ class STIXPatternListener(ParseTreeListener):
     def exitPropTestEqual(self, ctx):
         pass
 
+
     # Enter a parse tree produced by STIXPatternParser#propTestOrder.
     def enterPropTestOrder(self, ctx):
         pass
@@ -109,6 +122,7 @@ class STIXPatternListener(ParseTreeListener):
     def exitPropTestOrder(self, ctx):
         pass
 
+
     # Enter a parse tree produced by STIXPatternParser#propTestSet.
     def enterPropTestSet(self, ctx):
         pass
@@ -117,6 +131,7 @@ class STIXPatternListener(ParseTreeListener):
     def exitPropTestSet(self, ctx):
         pass
 
+
     # Enter a parse tree produced by STIXPatternParser#propTestLike.
     def enterPropTestLike(self, ctx):
         pass
@@ -125,6 +140,7 @@ class STIXPatternListener(ParseTreeListener):
     def exitPropTestLike(self, ctx):
         pass
 
+
     # Enter a parse tree produced by STIXPatternParser#propTestRegex.
     def enterPropTestRegex(self, ctx):
         pass
@@ -133,6 +149,7 @@ class STIXPatternListener(ParseTreeListener):
     def exitPropTestRegex(self, ctx):
         pass
 
+
     # Enter a parse tree produced by STIXPatternParser#propTestIsSubset.
     def enterPropTestIsSubset(self, ctx):
         pass
@@ -141,6 +158,7 @@ class STIXPatternListener(ParseTreeListener):
     def exitPropTestIsSubset(self, ctx):
         pass
 
+
     # Enter a parse tree produced by STIXPatternParser#propTestIsSuperset.
     def enterPropTestIsSuperset(self, ctx):
         pass
@@ -149,6 +167,7 @@ class STIXPatternListener(ParseTreeListener):
     def exitPropTestIsSuperset(self, ctx):
         pass
 
+
     # Enter a parse tree produced by STIXPatternParser#propTestParen.
     def enterPropTestParen(self, ctx):
         pass
@@ -157,6 +176,7 @@ class STIXPatternListener(ParseTreeListener):
     def exitPropTestParen(self, ctx):
         pass
 
+
     # Enter a parse tree produced by STIXPatternParser#startStopQualifier.
     def enterStartStopQualifier(self, ctx):
         pass
@@ -165,6 +185,7 @@ class STIXPatternListener(ParseTreeListener):
     def exitStartStopQualifier(self, ctx):
         pass
 
+
     # Enter a parse tree produced by STIXPatternParser#withinQualifier.
     def enterWithinQualifier(self, ctx):
         pass
@@ -173,6 +194,7 @@ class STIXPatternListener(ParseTreeListener):
     def exitWithinQualifier(self, ctx):
         pass
 
+
     # Enter a parse tree produced by STIXPatternParser#repeatedQualifier.
     def enterRepeatedQualifier(self, ctx):
         pass
@@ -181,6 +203,7 @@ class STIXPatternListener(ParseTreeListener):
     def exitRepeatedQualifier(self, ctx):
         pass
 
+
     # Enter a parse tree produced by STIXPatternParser#objectPath.
     def enterObjectPath(self, ctx):
         pass
@@ -189,6 +212,7 @@ class STIXPatternListener(ParseTreeListener):
     def exitObjectPath(self, ctx):
         pass
 
+
     # Enter a parse tree produced by STIXPatternParser#objectType.
     def enterObjectType(self, ctx):
         pass
@@ -197,6 +221,7 @@ class STIXPatternListener(ParseTreeListener):
     def exitObjectType(self, ctx):
         pass
 
+
     # Enter a parse tree produced by STIXPatternParser#firstPathComponent.
     def enterFirstPathComponent(self, ctx):
         pass
@@ -205,6 +230,7 @@ class STIXPatternListener(ParseTreeListener):
     def exitFirstPathComponent(self, ctx):
         pass
 
+
     # Enter a parse tree produced by STIXPatternParser#indexPathStep.
     def enterIndexPathStep(self, ctx):
         pass
@@ -213,6 +239,7 @@ class STIXPatternListener(ParseTreeListener):
     def exitIndexPathStep(self, ctx):
         pass
 
+
     # Enter a parse tree produced by STIXPatternParser#pathStep.
     def enterPathStep(self, ctx):
         pass
@@ -221,6 +248,7 @@ class STIXPatternListener(ParseTreeListener):
     def exitPathStep(self, ctx):
         pass
 
+
     # Enter a parse tree produced by STIXPatternParser#keyPathStep.
     def enterKeyPathStep(self, ctx):
         pass
@@ -229,6 +257,7 @@ class STIXPatternListener(ParseTreeListener):
     def exitKeyPathStep(self, ctx):
         pass
 
+
     # Enter a parse tree produced by STIXPatternParser#setLiteral.
     def enterSetLiteral(self, ctx):
         pass
@@ -237,6 +266,7 @@ class STIXPatternListener(ParseTreeListener):
     def exitSetLiteral(self, ctx):
         pass
 
+
     # Enter a parse tree produced by STIXPatternParser#primitiveLiteral.
     def enterPrimitiveLiteral(self, ctx):
         pass
@@ -245,6 +275,7 @@ class STIXPatternListener(ParseTreeListener):
     def exitPrimitiveLiteral(self, ctx):
         pass
 
+
     # Enter a parse tree produced by STIXPatternParser#orderableLiteral.
     def enterOrderableLiteral(self, ctx):
         pass
diff --git a/stix2patterns/grammars/STIXPatternParser.py b/stix2patterns/grammars/STIXPatternParser.py
index 2789809..c4d3e6d 100644
--- a/stix2patterns/grammars/STIXPatternParser.py
+++ b/stix2patterns/grammars/STIXPatternParser.py
@@ -1,4 +1,4 @@
-# Generated from STIXPattern.g4 by ANTLR 4.7
+# Generated from STIXPattern.g4 by ANTLR 4.7.1
 # encoding: utf-8
 from __future__ import print_function
 
@@ -11,7 +11,7 @@ from antlr4 import *
 def serializedATN():
     with StringIO() as buf:
         buf.write(u"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3")
-        buf.write(u"\64\u00e8\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7")
+        buf.write(u"\67\u00e8\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7")
         buf.write(u"\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t")
         buf.write(u"\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22")
         buf.write(u"\4\23\t\23\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\3\7\3/\n\3\f")
@@ -33,120 +33,117 @@ def serializedATN():
         buf.write(u"\3\21\7\21\u00d9\n\21\f\21\16\21\u00dc\13\21\3\21\3\21")
         buf.write(u"\5\21\u00e0\n\21\3\22\3\22\5\22\u00e4\n\22\3\23\3\23")
         buf.write(u"\3\23\2\t\4\6\b\n\f\16\36\24\2\4\6\b\n\f\16\20\22\24")
-        buf.write(u"\26\30\32\34\36 \"$\2\t\3\2\36\37\3\2 #\3\2\3\4\3\2\34")
-        buf.write(u"\35\4\2\7\7\34\34\4\2\3\3\61\61\4\2\3\7\t\t\2\u00f2\2")
-        buf.write(u"&\3\2\2\2\4(\3\2\2\2\6\63\3\2\2\2\b>\3\2\2\2\nR\3\2\2")
-        buf.write(u"\2\f_\3\2\2\2\16j\3\2\2\2\20\u00aa\3\2\2\2\22\u00ac\3")
-        buf.write(u"\2\2\2\24\u00b1\3\2\2\2\26\u00b5\3\2\2\2\30\u00b9\3\2")
-        buf.write(u"\2\2\32\u00bf\3\2\2\2\34\u00c1\3\2\2\2\36\u00c9\3\2\2")
-        buf.write(u"\2 \u00df\3\2\2\2\"\u00e3\3\2\2\2$\u00e5\3\2\2\2&\'\5")
-        buf.write(u"\4\3\2\'\3\3\2\2\2()\b\3\1\2)*\5\6\4\2*\60\3\2\2\2+,")
-        buf.write(u"\f\4\2\2,-\7\r\2\2-/\5\4\3\5.+\3\2\2\2/\62\3\2\2\2\60")
-        buf.write(u".\3\2\2\2\60\61\3\2\2\2\61\5\3\2\2\2\62\60\3\2\2\2\63")
-        buf.write(u"\64\b\4\1\2\64\65\5\b\5\2\65;\3\2\2\2\66\67\f\4\2\2\67")
-        buf.write(u"8\7\13\2\28:\5\6\4\59\66\3\2\2\2:=\3\2\2\2;9\3\2\2\2")
-        buf.write(u";<\3\2\2\2<\7\3\2\2\2=;\3\2\2\2>?\b\5\1\2?@\5\n\6\2@")
-        buf.write(u"F\3\2\2\2AB\f\4\2\2BC\7\n\2\2CE\5\b\5\5DA\3\2\2\2EH\3")
-        buf.write(u"\2\2\2FD\3\2\2\2FG\3\2\2\2G\t\3\2\2\2HF\3\2\2\2IJ\b\6")
-        buf.write(u"\1\2JK\7+\2\2KL\5\f\7\2LM\7*\2\2MS\3\2\2\2NO\7)\2\2O")
-        buf.write(u"P\5\4\3\2PQ\7(\2\2QS\3\2\2\2RI\3\2\2\2RN\3\2\2\2S\\\3")
-        buf.write(u"\2\2\2TU\f\5\2\2U[\5\22\n\2VW\f\4\2\2W[\5\24\13\2XY\f")
-        buf.write(u"\3\2\2Y[\5\26\f\2ZT\3\2\2\2ZV\3\2\2\2ZX\3\2\2\2[^\3\2")
-        buf.write(u"\2\2\\Z\3\2\2\2\\]\3\2\2\2]\13\3\2\2\2^\\\3\2\2\2_`\b")
-        buf.write(u"\7\1\2`a\5\16\b\2ag\3\2\2\2bc\f\4\2\2cd\7\13\2\2df\5")
-        buf.write(u"\f\7\5eb\3\2\2\2fi\3\2\2\2ge\3\2\2\2gh\3\2\2\2h\r\3\2")
-        buf.write(u"\2\2ig\3\2\2\2jk\b\b\1\2kl\5\20\t\2lr\3\2\2\2mn\f\4\2")
-        buf.write(u"\2no\7\n\2\2oq\5\16\b\5pm\3\2\2\2qt\3\2\2\2rp\3\2\2\2")
-        buf.write(u"rs\3\2\2\2s\17\3\2\2\2tr\3\2\2\2uw\5\30\r\2vx\7\f\2\2")
-        buf.write(u"wv\3\2\2\2wx\3\2\2\2xy\3\2\2\2yz\t\2\2\2z{\5\"\22\2{")
-        buf.write(u"\u00ab\3\2\2\2|~\5\30\r\2}\177\7\f\2\2~}\3\2\2\2~\177")
-        buf.write(u"\3\2\2\2\177\u0080\3\2\2\2\u0080\u0081\t\3\2\2\u0081")
+        buf.write(u"\26\30\32\34\36 \"$\2\t\3\2 !\3\2\"%\4\2\4\4\6\6\3\2")
+        buf.write(u"\36\37\4\2\t\t\36\36\4\2\3\4\63\63\4\2\3\t\13\13\2\u00f2")
+        buf.write(u"\2&\3\2\2\2\4(\3\2\2\2\6\63\3\2\2\2\b>\3\2\2\2\nR\3\2")
+        buf.write(u"\2\2\f_\3\2\2\2\16j\3\2\2\2\20\u00aa\3\2\2\2\22\u00ac")
+        buf.write(u"\3\2\2\2\24\u00b1\3\2\2\2\26\u00b5\3\2\2\2\30\u00b9\3")
+        buf.write(u"\2\2\2\32\u00bf\3\2\2\2\34\u00c1\3\2\2\2\36\u00c9\3\2")
+        buf.write(u"\2\2 \u00df\3\2\2\2\"\u00e3\3\2\2\2$\u00e5\3\2\2\2&\'")
+        buf.write(u"\5\4\3\2\'\3\3\2\2\2()\b\3\1\2)*\5\6\4\2*\60\3\2\2\2")
+        buf.write(u"+,\f\4\2\2,-\7\17\2\2-/\5\4\3\5.+\3\2\2\2/\62\3\2\2\2")
+        buf.write(u"\60.\3\2\2\2\60\61\3\2\2\2\61\5\3\2\2\2\62\60\3\2\2\2")
+        buf.write(u"\63\64\b\4\1\2\64\65\5\b\5\2\65;\3\2\2\2\66\67\f\4\2")
+        buf.write(u"\2\678\7\r\2\28:\5\6\4\59\66\3\2\2\2:=\3\2\2\2;9\3\2")
+        buf.write(u"\2\2;<\3\2\2\2<\7\3\2\2\2=;\3\2\2\2>?\b\5\1\2?@\5\n\6")
+        buf.write(u"\2@F\3\2\2\2AB\f\4\2\2BC\7\f\2\2CE\5\b\5\5DA\3\2\2\2")
+        buf.write(u"EH\3\2\2\2FD\3\2\2\2FG\3\2\2\2G\t\3\2\2\2HF\3\2\2\2I")
+        buf.write(u"J\b\6\1\2JK\7-\2\2KL\5\f\7\2LM\7,\2\2MS\3\2\2\2NO\7+")
+        buf.write(u"\2\2OP\5\4\3\2PQ\7*\2\2QS\3\2\2\2RI\3\2\2\2RN\3\2\2\2")
+        buf.write(u"S\\\3\2\2\2TU\f\5\2\2U[\5\22\n\2VW\f\4\2\2W[\5\24\13")
+        buf.write(u"\2XY\f\3\2\2Y[\5\26\f\2ZT\3\2\2\2ZV\3\2\2\2ZX\3\2\2\2")
+        buf.write(u"[^\3\2\2\2\\Z\3\2\2\2\\]\3\2\2\2]\13\3\2\2\2^\\\3\2\2")
+        buf.write(u"\2_`\b\7\1\2`a\5\16\b\2ag\3\2\2\2bc\f\4\2\2cd\7\r\2\2")
+        buf.write(u"df\5\f\7\5eb\3\2\2\2fi\3\2\2\2ge\3\2\2\2gh\3\2\2\2h\r")
+        buf.write(u"\3\2\2\2ig\3\2\2\2jk\b\b\1\2kl\5\20\t\2lr\3\2\2\2mn\f")
+        buf.write(u"\4\2\2no\7\f\2\2oq\5\16\b\5pm\3\2\2\2qt\3\2\2\2rp\3\2")
+        buf.write(u"\2\2rs\3\2\2\2s\17\3\2\2\2tr\3\2\2\2uw\5\30\r\2vx\7\16")
+        buf.write(u"\2\2wv\3\2\2\2wx\3\2\2\2xy\3\2\2\2yz\t\2\2\2z{\5\"\22")
+        buf.write(u"\2{\u00ab\3\2\2\2|~\5\30\r\2}\177\7\16\2\2~}\3\2\2\2")
+        buf.write(u"~\177\3\2\2\2\177\u0080\3\2\2\2\u0080\u0081\t\3\2\2\u0081")
         buf.write(u"\u0082\5$\23\2\u0082\u00ab\3\2\2\2\u0083\u0085\5\30\r")
-        buf.write(u"\2\u0084\u0086\7\f\2\2\u0085\u0084\3\2\2\2\u0085\u0086")
-        buf.write(u"\3\2\2\2\u0086\u0087\3\2\2\2\u0087\u0088\7\23\2\2\u0088")
+        buf.write(u"\2\u0084\u0086\7\16\2\2\u0085\u0084\3\2\2\2\u0085\u0086")
+        buf.write(u"\3\2\2\2\u0086\u0087\3\2\2\2\u0087\u0088\7\25\2\2\u0088")
         buf.write(u"\u0089\5 \21\2\u0089\u00ab\3\2\2\2\u008a\u008c\5\30\r")
-        buf.write(u"\2\u008b\u008d\7\f\2\2\u008c\u008b\3\2\2\2\u008c\u008d")
-        buf.write(u"\3\2\2\2\u008d\u008e\3\2\2\2\u008e\u008f\7\16\2\2\u008f")
-        buf.write(u"\u0090\7\7\2\2\u0090\u00ab\3\2\2\2\u0091\u0093\5\30\r")
-        buf.write(u"\2\u0092\u0094\7\f\2\2\u0093\u0092\3\2\2\2\u0093\u0094")
-        buf.write(u"\3\2\2\2\u0094\u0095\3\2\2\2\u0095\u0096\7\17\2\2\u0096")
-        buf.write(u"\u0097\7\7\2\2\u0097\u00ab\3\2\2\2\u0098\u009a\5\30\r")
-        buf.write(u"\2\u0099\u009b\7\f\2\2\u009a\u0099\3\2\2\2\u009a\u009b")
-        buf.write(u"\3\2\2\2\u009b\u009c\3\2\2\2\u009c\u009d\7\21\2\2\u009d")
-        buf.write(u"\u009e\7\7\2\2\u009e\u00ab\3\2\2\2\u009f\u00a1\5\30\r")
-        buf.write(u"\2\u00a0\u00a2\7\f\2\2\u00a1\u00a0\3\2\2\2\u00a1\u00a2")
-        buf.write(u"\3\2\2\2\u00a2\u00a3\3\2\2\2\u00a3\u00a4\7\20\2\2\u00a4")
-        buf.write(u"\u00a5\7\7\2\2\u00a5\u00ab\3\2\2\2\u00a6\u00a7\7)\2\2")
-        buf.write(u"\u00a7\u00a8\5\f\7\2\u00a8\u00a9\7(\2\2\u00a9\u00ab\3")
+        buf.write(u"\2\u008b\u008d\7\16\2\2\u008c\u008b\3\2\2\2\u008c\u008d")
+        buf.write(u"\3\2\2\2\u008d\u008e\3\2\2\2\u008e\u008f\7\20\2\2\u008f")
+        buf.write(u"\u0090\7\t\2\2\u0090\u00ab\3\2\2\2\u0091\u0093\5\30\r")
+        buf.write(u"\2\u0092\u0094\7\16\2\2\u0093\u0092\3\2\2\2\u0093\u0094")
+        buf.write(u"\3\2\2\2\u0094\u0095\3\2\2\2\u0095\u0096\7\21\2\2\u0096")
+        buf.write(u"\u0097\7\t\2\2\u0097\u00ab\3\2\2\2\u0098\u009a\5\30\r")
+        buf.write(u"\2\u0099\u009b\7\16\2\2\u009a\u0099\3\2\2\2\u009a\u009b")
+        buf.write(u"\3\2\2\2\u009b\u009c\3\2\2\2\u009c\u009d\7\23\2\2\u009d")
+        buf.write(u"\u009e\7\t\2\2\u009e\u00ab\3\2\2\2\u009f\u00a1\5\30\r")
+        buf.write(u"\2\u00a0\u00a2\7\16\2\2\u00a1\u00a0\3\2\2\2\u00a1\u00a2")
+        buf.write(u"\3\2\2\2\u00a2\u00a3\3\2\2\2\u00a3\u00a4\7\22\2\2\u00a4")
+        buf.write(u"\u00a5\7\t\2\2\u00a5\u00ab\3\2\2\2\u00a6\u00a7\7+\2\2")
+        buf.write(u"\u00a7\u00a8\5\f\7\2\u00a8\u00a9\7*\2\2\u00a9\u00ab\3")
         buf.write(u"\2\2\2\u00aau\3\2\2\2\u00aa|\3\2\2\2\u00aa\u0083\3\2")
         buf.write(u"\2\2\u00aa\u008a\3\2\2\2\u00aa\u0091\3\2\2\2\u00aa\u0098")
         buf.write(u"\3\2\2\2\u00aa\u009f\3\2\2\2\u00aa\u00a6\3\2\2\2\u00ab")
-        buf.write(u"\21\3\2\2\2\u00ac\u00ad\7\24\2\2\u00ad\u00ae\7\7\2\2")
-        buf.write(u"\u00ae\u00af\7\25\2\2\u00af\u00b0\7\7\2\2\u00b0\23\3")
-        buf.write(u"\2\2\2\u00b1\u00b2\7\31\2\2\u00b2\u00b3\t\4\2\2\u00b3")
-        buf.write(u"\u00b4\7\26\2\2\u00b4\25\3\2\2\2\u00b5\u00b6\7\32\2\2")
-        buf.write(u"\u00b6\u00b7\7\3\2\2\u00b7\u00b8\7\33\2\2\u00b8\27\3")
-        buf.write(u"\2\2\2\u00b9\u00ba\5\32\16\2\u00ba\u00bb\7%\2\2\u00bb")
+        buf.write(u"\21\3\2\2\2\u00ac\u00ad\7\26\2\2\u00ad\u00ae\7\t\2\2")
+        buf.write(u"\u00ae\u00af\7\27\2\2\u00af\u00b0\7\t\2\2\u00b0\23\3")
+        buf.write(u"\2\2\2\u00b1\u00b2\7\33\2\2\u00b2\u00b3\t\4\2\2\u00b3")
+        buf.write(u"\u00b4\7\30\2\2\u00b4\25\3\2\2\2\u00b5\u00b6\7\34\2\2")
+        buf.write(u"\u00b6\u00b7\7\4\2\2\u00b7\u00b8\7\35\2\2\u00b8\27\3")
+        buf.write(u"\2\2\2\u00b9\u00ba\5\32\16\2\u00ba\u00bb\7\'\2\2\u00bb")
         buf.write(u"\u00bd\5\34\17\2\u00bc\u00be\5\36\20\2\u00bd\u00bc\3")
         buf.write(u"\2\2\2\u00bd\u00be\3\2\2\2\u00be\31\3\2\2\2\u00bf\u00c0")
         buf.write(u"\t\5\2\2\u00c0\33\3\2\2\2\u00c1\u00c2\t\6\2\2\u00c2\35")
-        buf.write(u"\3\2\2\2\u00c3\u00c4\b\20\1\2\u00c4\u00c5\7&\2\2\u00c5")
-        buf.write(u"\u00ca\t\6\2\2\u00c6\u00c7\7+\2\2\u00c7\u00c8\t\7\2\2")
-        buf.write(u"\u00c8\u00ca\7*\2\2\u00c9\u00c3\3\2\2\2\u00c9\u00c6\3")
+        buf.write(u"\3\2\2\2\u00c3\u00c4\b\20\1\2\u00c4\u00c5\7(\2\2\u00c5")
+        buf.write(u"\u00ca\t\6\2\2\u00c6\u00c7\7-\2\2\u00c7\u00c8\t\7\2\2")
+        buf.write(u"\u00c8\u00ca\7,\2\2\u00c9\u00c3\3\2\2\2\u00c9\u00c6\3")
         buf.write(u"\2\2\2\u00ca\u00cf\3\2\2\2\u00cb\u00cc\f\5\2\2\u00cc")
         buf.write(u"\u00ce\5\36\20\6\u00cd\u00cb\3\2\2\2\u00ce\u00d1\3\2")
         buf.write(u"\2\2\u00cf\u00cd\3\2\2\2\u00cf\u00d0\3\2\2\2\u00d0\37")
-        buf.write(u"\3\2\2\2\u00d1\u00cf\3\2\2\2\u00d2\u00d3\7)\2\2\u00d3")
-        buf.write(u"\u00e0\7(\2\2\u00d4\u00d5\7)\2\2\u00d5\u00da\5\"\22\2")
-        buf.write(u"\u00d6\u00d7\7\'\2\2\u00d7\u00d9\5\"\22\2\u00d8\u00d6")
+        buf.write(u"\3\2\2\2\u00d1\u00cf\3\2\2\2\u00d2\u00d3\7+\2\2\u00d3")
+        buf.write(u"\u00e0\7*\2\2\u00d4\u00d5\7+\2\2\u00d5\u00da\5\"\22\2")
+        buf.write(u"\u00d6\u00d7\7)\2\2\u00d7\u00d9\5\"\22\2\u00d8\u00d6")
         buf.write(u"\3\2\2\2\u00d9\u00dc\3\2\2\2\u00da\u00d8\3\2\2\2\u00da")
         buf.write(u"\u00db\3\2\2\2\u00db\u00dd\3\2\2\2\u00dc\u00da\3\2\2")
-        buf.write(u"\2\u00dd\u00de\7(\2\2\u00de\u00e0\3\2\2\2\u00df\u00d2")
+        buf.write(u"\2\u00dd\u00de\7*\2\2\u00de\u00e0\3\2\2\2\u00df\u00d2")
         buf.write(u"\3\2\2\2\u00df\u00d4\3\2\2\2\u00e0!\3\2\2\2\u00e1\u00e4")
-        buf.write(u"\5$\23\2\u00e2\u00e4\7\b\2\2\u00e3\u00e1\3\2\2\2\u00e3")
+        buf.write(u"\5$\23\2\u00e2\u00e4\7\n\2\2\u00e3\u00e1\3\2\2\2\u00e3")
         buf.write(u"\u00e2\3\2\2\2\u00e4#\3\2\2\2\u00e5\u00e6\t\b\2\2\u00e6")
         buf.write(u"%\3\2\2\2\30\60;FRZ\\grw~\u0085\u008c\u0093\u009a\u00a1")
         buf.write(u"\u00aa\u00bd\u00c9\u00cf\u00da\u00df\u00e3")
         return buf.getvalue()
 
 
-class STIXPatternParser(Parser):
+class STIXPatternParser ( Parser ):
 
     grammarFileName = "STIXPattern.g4"
 
     atn = ATNDeserializer().deserialize(serializedATN())
 
-    decisionsToDFA = [DFA(ds, i) for i, ds in enumerate(atn.decisionToState)]
+    decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]
 
     sharedContextCache = PredictionContextCache()
 
-    literalNames = [
-        u"<INVALID>", u"<INVALID>", u"<INVALID>", u"<INVALID>",
-        u"<INVALID>", u"<INVALID>", u"<INVALID>", u"<INVALID>",
-        u"<INVALID>", u"<INVALID>", u"<INVALID>", u"<INVALID>",
-        u"<INVALID>", u"<INVALID>", u"<INVALID>", u"<INVALID>",
-        u"<INVALID>", u"<INVALID>", u"<INVALID>", u"<INVALID>",
-        u"<INVALID>", u"<INVALID>", u"<INVALID>", u"<INVALID>",
-        u"<INVALID>", u"<INVALID>", u"<INVALID>", u"<INVALID>",
-        u"<INVALID>", u"<INVALID>", u"'<'", u"'<='", u"'>'",
-        u"'>='", u"'''", u"':'", u"'.'", u"','", u"')'", u"'('",
-        u"']'", u"'['", u"'+'", u"<INVALID>", u"'-'", u"'^'",
-        u"'/'", u"'*'"
-    ]
-
-    symbolicNames = [
-        u"<INVALID>", u"IntLiteral", u"FloatLiteral", u"HexLiteral",
-        u"BinaryLiteral", u"StringLiteral", u"BoolLiteral",
-        u"TimestampLiteral", u"AND", u"OR", u"NOT", u"FOLLOWEDBY",
-        u"LIKE", u"MATCHES", u"ISSUPERSET", u"ISSUBSET", u"LAST",
-        u"IN", u"START", u"STOP", u"SECONDS", u"TRUE", u"FALSE",
-        u"WITHIN", u"REPEATS", u"TIMES", u"IdentifierWithoutHyphen",
-        u"IdentifierWithHyphen", u"EQ", u"NEQ", u"LT", u"LE",
-        u"GT", u"GE", u"QUOTE", u"COLON", u"DOT", u"COMMA",
-        u"RPAREN", u"LPAREN", u"RBRACK", u"LBRACK", u"PLUS",
-        u"HYPHEN", u"MINUS", u"POWER_OP", u"DIVIDE", u"ASTERISK",
-        u"WS", u"COMMENT", u"LINE_COMMENT"
-    ]
+    literalNames = [ u"<INVALID>", u"<INVALID>", u"<INVALID>", u"<INVALID>",
+                     u"<INVALID>", u"<INVALID>", u"<INVALID>", u"<INVALID>",
+                     u"<INVALID>", u"<INVALID>", u"<INVALID>", u"<INVALID>",
+                     u"<INVALID>", u"<INVALID>", u"<INVALID>", u"<INVALID>",
+                     u"<INVALID>", u"<INVALID>", u"<INVALID>", u"<INVALID>",
+                     u"<INVALID>", u"<INVALID>", u"<INVALID>", u"<INVALID>",
+                     u"<INVALID>", u"<INVALID>", u"<INVALID>", u"<INVALID>",
+                     u"<INVALID>", u"<INVALID>", u"<INVALID>", u"<INVALID>",
+                     u"'<'", u"'<='", u"'>'", u"'>='", u"'''", u"':'", u"'.'",
+                     u"','", u"')'", u"'('", u"']'", u"'['", u"'+'", u"<INVALID>",
+                     u"'-'", u"'^'", u"'/'", u"'*'" ]
+
+    symbolicNames = [ u"<INVALID>", u"IntNegLiteral", u"IntPosLiteral",
+                      u"FloatNegLiteral", u"FloatPosLiteral", u"HexLiteral",
+                      u"BinaryLiteral", u"StringLiteral", u"BoolLiteral",
+                      u"TimestampLiteral", u"AND", u"OR", u"NOT", u"FOLLOWEDBY",
+                      u"LIKE", u"MATCHES", u"ISSUPERSET", u"ISSUBSET", u"LAST",
+                      u"IN", u"START", u"STOP", u"SECONDS", u"TRUE", u"FALSE",
+                      u"WITHIN", u"REPEATS", u"TIMES", u"IdentifierWithoutHyphen",
+                      u"IdentifierWithHyphen", u"EQ", u"NEQ", u"LT", u"LE",
+                      u"GT", u"GE", u"QUOTE", u"COLON", u"DOT", u"COMMA",
+                      u"RPAREN", u"LPAREN", u"RBRACK", u"LBRACK", u"PLUS",
+                      u"HYPHEN", u"MINUS", u"POWER_OP", u"DIVIDE", u"ASTERISK",
+                      u"WS", u"COMMENT", u"LINE_COMMENT", u"InvalidCharacter" ]
 
     RULE_pattern = 0
     RULE_observationExpressions = 1
@@ -167,74 +164,77 @@ class STIXPatternParser(Parser):
     RULE_primitiveLiteral = 16
     RULE_orderableLiteral = 17
 
-    ruleNames = [
-        u"pattern", u"observationExpressions", u"observationExpressionOr",
-        u"observationExpressionAnd", u"observationExpression",
-        u"comparisonExpression", u"comparisonExpressionAnd",
-        u"propTest", u"startStopQualifier", u"withinQualifier",
-        u"repeatedQualifier", u"objectPath", u"objectType", u"firstPathComponent",
-        u"objectPathComponent", u"setLiteral", u"primitiveLiteral",
-        u"orderableLiteral"
-    ]
+    ruleNames =  [ u"pattern", u"observationExpressions", u"observationExpressionOr",
+                   u"observationExpressionAnd", u"observationExpression",
+                   u"comparisonExpression", u"comparisonExpressionAnd",
+                   u"propTest", u"startStopQualifier", u"withinQualifier",
+                   u"repeatedQualifier", u"objectPath", u"objectType", u"firstPathComponent",
+                   u"objectPathComponent", u"setLiteral", u"primitiveLiteral",
+                   u"orderableLiteral" ]
 
     EOF = Token.EOF
-    IntLiteral = 1
-    FloatLiteral = 2
-    HexLiteral = 3
-    BinaryLiteral = 4
-    StringLiteral = 5
-    BoolLiteral = 6
-    TimestampLiteral = 7
-    AND = 8
-    OR = 9
-    NOT = 10
-    FOLLOWEDBY = 11
-    LIKE = 12
-    MATCHES = 13
-    ISSUPERSET = 14
-    ISSUBSET = 15
-    LAST = 16
-    IN = 17
-    START = 18
-    STOP = 19
-    SECONDS = 20
-    TRUE = 21
-    FALSE = 22
-    WITHIN = 23
-    REPEATS = 24
-    TIMES = 25
-    IdentifierWithoutHyphen = 26
-    IdentifierWithHyphen = 27
-    EQ = 28
-    NEQ = 29
-    LT = 30
-    LE = 31
-    GT = 32
-    GE = 33
-    QUOTE = 34
-    COLON = 35
-    DOT = 36
-    COMMA = 37
-    RPAREN = 38
-    LPAREN = 39
-    RBRACK = 40
-    LBRACK = 41
-    PLUS = 42
-    HYPHEN = 43
-    MINUS = 44
-    POWER_OP = 45
-    DIVIDE = 46
-    ASTERISK = 47
-    WS = 48
-    COMMENT = 49
-    LINE_COMMENT = 50
+    IntNegLiteral=1
+    IntPosLiteral=2
+    FloatNegLiteral=3
+    FloatPosLiteral=4
+    HexLiteral=5
+    BinaryLiteral=6
+    StringLiteral=7
+    BoolLiteral=8
+    TimestampLiteral=9
+    AND=10
+    OR=11
+    NOT=12
+    FOLLOWEDBY=13
+    LIKE=14
+    MATCHES=15
+    ISSUPERSET=16
+    ISSUBSET=17
+    LAST=18
+    IN=19
+    START=20
+    STOP=21
+    SECONDS=22
+    TRUE=23
+    FALSE=24
+    WITHIN=25
+    REPEATS=26
+    TIMES=27
+    IdentifierWithoutHyphen=28
+    IdentifierWithHyphen=29
+    EQ=30
+    NEQ=31
+    LT=32
+    LE=33
+    GT=34
+    GE=35
+    QUOTE=36
+    COLON=37
+    DOT=38
+    COMMA=39
+    RPAREN=40
+    LPAREN=41
+    RBRACK=42
+    LBRACK=43
+    PLUS=44
+    HYPHEN=45
+    MINUS=46
+    POWER_OP=47
+    DIVIDE=48
+    ASTERISK=49
+    WS=50
+    COMMENT=51
+    LINE_COMMENT=52
+    InvalidCharacter=53
 
     def __init__(self, input, output=sys.stdout):
         super(STIXPatternParser, self).__init__(input, output=output)
-        self.checkVersion("4.7")
+        self.checkVersion("4.7.1")
         self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
         self._predicates = None
 
+
+
     class PatternContext(ParserRuleContext):
 
         def __init__(self, parser, parent=None, invokingState=-1):
@@ -242,7 +242,8 @@ class STIXPatternParser(Parser):
             self.parser = parser
 
         def observationExpressions(self):
-            return self.getTypedRuleContext(STIXPatternParser.ObservationExpressionsContext, 0)
+            return self.getTypedRuleContext(STIXPatternParser.ObservationExpressionsContext,0)
+
 
         def getRuleIndex(self):
             return STIXPatternParser.RULE_pattern
@@ -255,7 +256,11 @@ class STIXPatternParser(Parser):
             if hasattr(listener, "exitPattern"):
                 listener.exitPattern(self)
 
+
+
+
     def pattern(self):
+
         localctx = STIXPatternParser.PatternContext(self, self._ctx, self.state)
         self.enterRule(localctx, 0, self.RULE_pattern)
         try:
@@ -277,13 +282,15 @@ class STIXPatternParser(Parser):
             self.parser = parser
 
         def observationExpressionOr(self):
-            return self.getTypedRuleContext(STIXPatternParser.ObservationExpressionOrContext, 0)
+            return self.getTypedRuleContext(STIXPatternParser.ObservationExpressionOrContext,0)
+
 
         def observationExpressions(self, i=None):
             if i is None:
                 return self.getTypedRuleContexts(STIXPatternParser.ObservationExpressionsContext)
             else:
-                return self.getTypedRuleContext(STIXPatternParser.ObservationExpressionsContext, i)
+                return self.getTypedRuleContext(STIXPatternParser.ObservationExpressionsContext,i)
+
 
         def FOLLOWEDBY(self):
             return self.getToken(STIXPatternParser.FOLLOWEDBY, 0)
@@ -299,10 +306,13 @@ class STIXPatternParser(Parser):
             if hasattr(listener, "exitObservationExpressions"):
                 listener.exitObservationExpressions(self)
 
+
+
     def observationExpressions(self, _p=0):
         _parentctx = self._ctx
         _parentState = self.state
         localctx = STIXPatternParser.ObservationExpressionsContext(self, self._ctx, _parentState)
+        _prevctx = localctx
         _startState = 2
         self.enterRecursionRule(localctx, 2, self.RULE_observationExpressions, _p)
         try:
@@ -312,11 +322,12 @@ class STIXPatternParser(Parser):
             self._ctx.stop = self._input.LT(-1)
             self.state = 46
             self._errHandler.sync(self)
-            _alt = self._interp.adaptivePredict(self._input, 0, self._ctx)
-            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
-                if _alt == 1:
+            _alt = self._interp.adaptivePredict(self._input,0,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
                     if self._parseListeners is not None:
                         self.triggerExitRuleEvent()
+                    _prevctx = localctx
                     localctx = STIXPatternParser.ObservationExpressionsContext(self, _parentctx, _parentState)
                     self.pushNewRecursionContext(localctx, _startState, self.RULE_observationExpressions)
                     self.state = 41
@@ -329,7 +340,7 @@ class STIXPatternParser(Parser):
                     self.observationExpressions(3)
                 self.state = 48
                 self._errHandler.sync(self)
-                _alt = self._interp.adaptivePredict(self._input, 0, self._ctx)
+                _alt = self._interp.adaptivePredict(self._input,0,self._ctx)
 
         except RecognitionException as re:
             localctx.exception = re
@@ -346,13 +357,15 @@ class STIXPatternParser(Parser):
             self.parser = parser
 
         def observationExpressionAnd(self):
-            return self.getTypedRuleContext(STIXPatternParser.ObservationExpressionAndContext, 0)
+            return self.getTypedRuleContext(STIXPatternParser.ObservationExpressionAndContext,0)
+
 
         def observationExpressionOr(self, i=None):
             if i is None:
                 return self.getTypedRuleContexts(STIXPatternParser.ObservationExpressionOrContext)
             else:
-                return self.getTypedRuleContext(STIXPatternParser.ObservationExpressionOrContext, i)
+                return self.getTypedRuleContext(STIXPatternParser.ObservationExpressionOrContext,i)
+
 
         def OR(self):
             return self.getToken(STIXPatternParser.OR, 0)
@@ -368,10 +381,13 @@ class STIXPatternParser(Parser):
             if hasattr(listener, "exitObservationExpressionOr"):
                 listener.exitObservationExpressionOr(self)
 
+
+
     def observationExpressionOr(self, _p=0):
         _parentctx = self._ctx
         _parentState = self.state
         localctx = STIXPatternParser.ObservationExpressionOrContext(self, self._ctx, _parentState)
+        _prevctx = localctx
         _startState = 4
         self.enterRecursionRule(localctx, 4, self.RULE_observationExpressionOr, _p)
         try:
@@ -381,11 +397,12 @@ class STIXPatternParser(Parser):
             self._ctx.stop = self._input.LT(-1)
             self.state = 57
             self._errHandler.sync(self)
-            _alt = self._interp.adaptivePredict(self._input, 1, self._ctx)
-            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
-                if _alt == 1:
+            _alt = self._interp.adaptivePredict(self._input,1,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
                     if self._parseListeners is not None:
                         self.triggerExitRuleEvent()
+                    _prevctx = localctx
                     localctx = STIXPatternParser.ObservationExpressionOrContext(self, _parentctx, _parentState)
                     self.pushNewRecursionContext(localctx, _startState, self.RULE_observationExpressionOr)
                     self.state = 52
@@ -398,7 +415,8 @@ class STIXPatternParser(Parser):
                     self.observationExpressionOr(3)
                 self.state = 59
                 self._errHandler.sync(self)
-                _alt = self._interp.adaptivePredict(self._input, 1, self._ctx)
+                _alt = self._interp.adaptivePredict(self._input,1,self._ctx)
+
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -414,13 +432,15 @@ class STIXPatternParser(Parser):
             self.parser = parser
 
         def observationExpression(self):
-            return self.getTypedRuleContext(STIXPatternParser.ObservationExpressionContext, 0)
+            return self.getTypedRuleContext(STIXPatternParser.ObservationExpressionContext,0)
+
 
         def observationExpressionAnd(self, i=None):
             if i is None:
                 return self.getTypedRuleContexts(STIXPatternParser.ObservationExpressionAndContext)
             else:
-                return self.getTypedRuleContext(STIXPatternParser.ObservationExpressionAndContext, i)
+                return self.getTypedRuleContext(STIXPatternParser.ObservationExpressionAndContext,i)
+
 
         def AND(self):
             return self.getToken(STIXPatternParser.AND, 0)
@@ -436,10 +456,13 @@ class STIXPatternParser(Parser):
             if hasattr(listener, "exitObservationExpressionAnd"):
                 listener.exitObservationExpressionAnd(self)
 
+
+
     def observationExpressionAnd(self, _p=0):
         _parentctx = self._ctx
         _parentState = self.state
         localctx = STIXPatternParser.ObservationExpressionAndContext(self, self._ctx, _parentState)
+        _prevctx = localctx
         _startState = 6
         self.enterRecursionRule(localctx, 6, self.RULE_observationExpressionAnd, _p)
         try:
@@ -449,11 +472,12 @@ class STIXPatternParser(Parser):
             self._ctx.stop = self._input.LT(-1)
             self.state = 68
             self._errHandler.sync(self)
-            _alt = self._interp.adaptivePredict(self._input, 2, self._ctx)
-            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
-                if _alt == 1:
+            _alt = self._interp.adaptivePredict(self._input,2,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
                     if self._parseListeners is not None:
                         self.triggerExitRuleEvent()
+                    _prevctx = localctx
                     localctx = STIXPatternParser.ObservationExpressionAndContext(self, _parentctx, _parentState)
                     self.pushNewRecursionContext(localctx, _startState, self.RULE_observationExpressionAnd)
                     self.state = 63
@@ -466,7 +490,8 @@ class STIXPatternParser(Parser):
                     self.observationExpressionAnd(3)
                 self.state = 70
                 self._errHandler.sync(self)
-                _alt = self._interp.adaptivePredict(self._input, 2, self._ctx)
+                _alt = self._interp.adaptivePredict(self._input,2,self._ctx)
+
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -481,23 +506,27 @@ class STIXPatternParser(Parser):
             super(STIXPatternParser.ObservationExpressionContext, self).__init__(parent, invokingState)
             self.parser = parser
 
+
         def getRuleIndex(self):
             return STIXPatternParser.RULE_observationExpression
 
+
         def copyFrom(self, ctx):
             super(STIXPatternParser.ObservationExpressionContext, self).copyFrom(ctx)
 
+
     class ObservationExpressionRepeatedContext(ObservationExpressionContext):
 
-        def __init__(self, parser, ctx):  # actually a STIXPatternParser.ObservationExpressionContext)
+        def __init__(self, parser, ctx): # actually a STIXPatternParser.ObservationExpressionContext)
             super(STIXPatternParser.ObservationExpressionRepeatedContext, self).__init__(parser)
             self.copyFrom(ctx)
 
         def observationExpression(self):
-            return self.getTypedRuleContext(STIXPatternParser.ObservationExpressionContext, 0)
+            return self.getTypedRuleContext(STIXPatternParser.ObservationExpressionContext,0)
 
         def repeatedQualifier(self):
-            return self.getTypedRuleContext(STIXPatternParser.RepeatedQualifierContext, 0)
+            return self.getTypedRuleContext(STIXPatternParser.RepeatedQualifierContext,0)
+
 
         def enterRule(self, listener):
             if hasattr(listener, "enterObservationExpressionRepeated"):
@@ -507,17 +536,17 @@ class STIXPatternParser(Parser):
             if hasattr(listener, "exitObservationExpressionRepeated"):
                 listener.exitObservationExpressionRepeated(self)
 
+
     class ObservationExpressionSimpleContext(ObservationExpressionContext):
 
-        def __init__(self, parser, ctx):  # actually a STIXPatternParser.ObservationExpressionContext)
+        def __init__(self, parser, ctx): # actually a STIXPatternParser.ObservationExpressionContext)
             super(STIXPatternParser.ObservationExpressionSimpleContext, self).__init__(parser)
             self.copyFrom(ctx)
 
         def LBRACK(self):
             return self.getToken(STIXPatternParser.LBRACK, 0)
-
         def comparisonExpression(self):
-            return self.getTypedRuleContext(STIXPatternParser.ComparisonExpressionContext, 0)
+            return self.getTypedRuleContext(STIXPatternParser.ComparisonExpressionContext,0)
 
         def RBRACK(self):
             return self.getToken(STIXPatternParser.RBRACK, 0)
@@ -530,17 +559,17 @@ class STIXPatternParser(Parser):
             if hasattr(listener, "exitObservationExpressionSimple"):
                 listener.exitObservationExpressionSimple(self)
 
+
     class ObservationExpressionCompoundContext(ObservationExpressionContext):
 
-        def __init__(self, parser, ctx):  # actually a STIXPatternParser.ObservationExpressionContext)
+        def __init__(self, parser, ctx): # actually a STIXPatternParser.ObservationExpressionContext)
             super(STIXPatternParser.ObservationExpressionCompoundContext, self).__init__(parser)
             self.copyFrom(ctx)
 
         def LPAREN(self):
             return self.getToken(STIXPatternParser.LPAREN, 0)
-
         def observationExpressions(self):
-            return self.getTypedRuleContext(STIXPatternParser.ObservationExpressionsContext, 0)
+            return self.getTypedRuleContext(STIXPatternParser.ObservationExpressionsContext,0)
 
         def RPAREN(self):
             return self.getToken(STIXPatternParser.RPAREN, 0)
@@ -553,17 +582,19 @@ class STIXPatternParser(Parser):
             if hasattr(listener, "exitObservationExpressionCompound"):
                 listener.exitObservationExpressionCompound(self)
 
+
     class ObservationExpressionWithinContext(ObservationExpressionContext):
 
-        def __init__(self, parser, ctx):  # actually a STIXPatternParser.ObservationExpressionContext)
+        def __init__(self, parser, ctx): # actually a STIXPatternParser.ObservationExpressionContext)
             super(STIXPatternParser.ObservationExpressionWithinContext, self).__init__(parser)
             self.copyFrom(ctx)
 
         def observationExpression(self):
-            return self.getTypedRuleContext(STIXPatternParser.ObservationExpressionContext, 0)
+            return self.getTypedRuleContext(STIXPatternParser.ObservationExpressionContext,0)
 
         def withinQualifier(self):
-            return self.getTypedRuleContext(STIXPatternParser.WithinQualifierContext, 0)
+            return self.getTypedRuleContext(STIXPatternParser.WithinQualifierContext,0)
+
 
         def enterRule(self, listener):
             if hasattr(listener, "enterObservationExpressionWithin"):
@@ -573,17 +604,19 @@ class STIXPatternParser(Parser):
             if hasattr(listener, "exitObservationExpressionWithin"):
                 listener.exitObservationExpressionWithin(self)
 
+
     class ObservationExpressionStartStopContext(ObservationExpressionContext):
 
-        def __init__(self, parser, ctx):  # actually a STIXPatternParser.ObservationExpressionContext)
+        def __init__(self, parser, ctx): # actually a STIXPatternParser.ObservationExpressionContext)
             super(STIXPatternParser.ObservationExpressionStartStopContext, self).__init__(parser)
             self.copyFrom(ctx)
 
         def observationExpression(self):
-            return self.getTypedRuleContext(STIXPatternParser.ObservationExpressionContext, 0)
+            return self.getTypedRuleContext(STIXPatternParser.ObservationExpressionContext,0)
 
         def startStopQualifier(self):
-            return self.getTypedRuleContext(STIXPatternParser.StartStopQualifierContext, 0)
+            return self.getTypedRuleContext(STIXPatternParser.StartStopQualifierContext,0)
+
 
         def enterRule(self, listener):
             if hasattr(listener, "enterObservationExpressionStartStop"):
@@ -593,10 +626,13 @@ class STIXPatternParser(Parser):
             if hasattr(listener, "exitObservationExpressionStartStop"):
                 listener.exitObservationExpressionStartStop(self)
 
+
+
     def observationExpression(self, _p=0):
         _parentctx = self._ctx
         _parentState = self.state
         localctx = STIXPatternParser.ObservationExpressionContext(self, self._ctx, _parentState)
+        _prevctx = localctx
         _startState = 8
         self.enterRecursionRule(localctx, 8, self.RULE_observationExpression, _p)
         try:
@@ -607,6 +643,7 @@ class STIXPatternParser(Parser):
             if token in [STIXPatternParser.LBRACK]:
                 localctx = STIXPatternParser.ObservationExpressionSimpleContext(self, localctx)
                 self._ctx = localctx
+                _prevctx = localctx
 
                 self.state = 72
                 self.match(STIXPatternParser.LBRACK)
@@ -618,6 +655,7 @@ class STIXPatternParser(Parser):
             elif token in [STIXPatternParser.LPAREN]:
                 localctx = STIXPatternParser.ObservationExpressionCompoundContext(self, localctx)
                 self._ctx = localctx
+                _prevctx = localctx
                 self.state = 76
                 self.match(STIXPatternParser.LPAREN)
                 self.state = 77
@@ -631,17 +669,17 @@ class STIXPatternParser(Parser):
             self._ctx.stop = self._input.LT(-1)
             self.state = 90
             self._errHandler.sync(self)
-            _alt = self._interp.adaptivePredict(self._input, 5, self._ctx)
-            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
-                if _alt == 1:
+            _alt = self._interp.adaptivePredict(self._input,5,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
                     if self._parseListeners is not None:
                         self.triggerExitRuleEvent()
+                    _prevctx = localctx
                     self.state = 88
                     self._errHandler.sync(self)
-                    la_ = self._interp.adaptivePredict(self._input, 4, self._ctx)
+                    la_ = self._interp.adaptivePredict(self._input,4,self._ctx)
                     if la_ == 1:
-                        localctx = STIXPatternParser.\
-                            ObservationExpressionStartStopContext(self, STIXPatternParser.ObservationExpressionContext(self, _parentctx, _parentState))
+                        localctx = STIXPatternParser.ObservationExpressionStartStopContext(self, STIXPatternParser.ObservationExpressionContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_observationExpression)
                         self.state = 82
                         if not self.precpred(self._ctx, 3):
@@ -652,8 +690,7 @@ class STIXPatternParser(Parser):
                         pass
 
                     elif la_ == 2:
-                        localctx = STIXPatternParser.\
-                            ObservationExpressionWithinContext(self, STIXPatternParser.ObservationExpressionContext(self, _parentctx, _parentState))
+                        localctx = STIXPatternParser.ObservationExpressionWithinContext(self, STIXPatternParser.ObservationExpressionContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_observationExpression)
                         self.state = 84
                         if not self.precpred(self._ctx, 2):
@@ -664,8 +701,7 @@ class STIXPatternParser(Parser):
                         pass
 
                     elif la_ == 3:
-                        localctx = STIXPatternParser.\
-                            ObservationExpressionRepeatedContext(self, STIXPatternParser.ObservationExpressionContext(self, _parentctx, _parentState))
+                        localctx = STIXPatternParser.ObservationExpressionRepeatedContext(self, STIXPatternParser.ObservationExpressionContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_observationExpression)
                         self.state = 86
                         if not self.precpred(self._ctx, 1):
@@ -675,9 +711,10 @@ class STIXPatternParser(Parser):
                         self.repeatedQualifier()
                         pass
 
+
                 self.state = 92
                 self._errHandler.sync(self)
-                _alt = self._interp.adaptivePredict(self._input, 5, self._ctx)
+                _alt = self._interp.adaptivePredict(self._input,5,self._ctx)
 
         except RecognitionException as re:
             localctx.exception = re
@@ -694,13 +731,15 @@ class STIXPatternParser(Parser):
             self.parser = parser
 
         def comparisonExpressionAnd(self):
-            return self.getTypedRuleContext(STIXPatternParser.ComparisonExpressionAndContext, 0)
+            return self.getTypedRuleContext(STIXPatternParser.ComparisonExpressionAndContext,0)
+
 
         def comparisonExpression(self, i=None):
             if i is None:
                 return self.getTypedRuleContexts(STIXPatternParser.ComparisonExpressionContext)
             else:
-                return self.getTypedRuleContext(STIXPatternParser.ComparisonExpressionContext, i)
+                return self.getTypedRuleContext(STIXPatternParser.ComparisonExpressionContext,i)
+
 
         def OR(self):
             return self.getToken(STIXPatternParser.OR, 0)
@@ -716,10 +755,13 @@ class STIXPatternParser(Parser):
             if hasattr(listener, "exitComparisonExpression"):
                 listener.exitComparisonExpression(self)
 
+
+
     def comparisonExpression(self, _p=0):
         _parentctx = self._ctx
         _parentState = self.state
         localctx = STIXPatternParser.ComparisonExpressionContext(self, self._ctx, _parentState)
+        _prevctx = localctx
         _startState = 10
         self.enterRecursionRule(localctx, 10, self.RULE_comparisonExpression, _p)
         try:
@@ -729,11 +771,12 @@ class STIXPatternParser(Parser):
             self._ctx.stop = self._input.LT(-1)
             self.state = 101
             self._errHandler.sync(self)
-            _alt = self._interp.adaptivePredict(self._input, 6, self._ctx)
-            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
-                if _alt == 1:
+            _alt = self._interp.adaptivePredict(self._input,6,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
                     if self._parseListeners is not None:
                         self.triggerExitRuleEvent()
+                    _prevctx = localctx
                     localctx = STIXPatternParser.ComparisonExpressionContext(self, _parentctx, _parentState)
                     self.pushNewRecursionContext(localctx, _startState, self.RULE_comparisonExpression)
                     self.state = 96
@@ -746,7 +789,7 @@ class STIXPatternParser(Parser):
                     self.comparisonExpression(3)
                 self.state = 103
                 self._errHandler.sync(self)
-                _alt = self._interp.adaptivePredict(self._input, 6, self._ctx)
+                _alt = self._interp.adaptivePredict(self._input,6,self._ctx)
 
         except RecognitionException as re:
             localctx.exception = re
@@ -763,13 +806,15 @@ class STIXPatternParser(Parser):
             self.parser = parser
 
         def propTest(self):
-            return self.getTypedRuleContext(STIXPatternParser.PropTestContext, 0)
+            return self.getTypedRuleContext(STIXPatternParser.PropTestContext,0)
+
 
         def comparisonExpressionAnd(self, i=None):
             if i is None:
                 return self.getTypedRuleContexts(STIXPatternParser.ComparisonExpressionAndContext)
             else:
-                return self.getTypedRuleContext(STIXPatternParser.ComparisonExpressionAndContext, i)
+                return self.getTypedRuleContext(STIXPatternParser.ComparisonExpressionAndContext,i)
+
 
         def AND(self):
             return self.getToken(STIXPatternParser.AND, 0)
@@ -785,10 +830,13 @@ class STIXPatternParser(Parser):
             if hasattr(listener, "exitComparisonExpressionAnd"):
                 listener.exitComparisonExpressionAnd(self)
 
+
+
     def comparisonExpressionAnd(self, _p=0):
         _parentctx = self._ctx
         _parentState = self.state
         localctx = STIXPatternParser.ComparisonExpressionAndContext(self, self._ctx, _parentState)
+        _prevctx = localctx
         _startState = 12
         self.enterRecursionRule(localctx, 12, self.RULE_comparisonExpressionAnd, _p)
         try:
@@ -798,11 +846,12 @@ class STIXPatternParser(Parser):
             self._ctx.stop = self._input.LT(-1)
             self.state = 112
             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:
+            _alt = self._interp.adaptivePredict(self._input,7,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
                     if self._parseListeners is not None:
                         self.triggerExitRuleEvent()
+                    _prevctx = localctx
                     localctx = STIXPatternParser.ComparisonExpressionAndContext(self, _parentctx, _parentState)
                     self.pushNewRecursionContext(localctx, _startState, self.RULE_comparisonExpressionAnd)
                     self.state = 107
@@ -815,7 +864,7 @@ class STIXPatternParser(Parser):
                     self.comparisonExpressionAnd(3)
                 self.state = 114
                 self._errHandler.sync(self)
-                _alt = self._interp.adaptivePredict(self._input, 7, self._ctx)
+                _alt = self._interp.adaptivePredict(self._input,7,self._ctx)
 
         except RecognitionException as re:
             localctx.exception = re
@@ -831,27 +880,29 @@ class STIXPatternParser(Parser):
             super(STIXPatternParser.PropTestContext, self).__init__(parent, invokingState)
             self.parser = parser
 
+
         def getRuleIndex(self):
             return STIXPatternParser.RULE_propTest
 
+
         def copyFrom(self, ctx):
             super(STIXPatternParser.PropTestContext, self).copyFrom(ctx)
 
+
+
     class PropTestRegexContext(PropTestContext):
 
-        def __init__(self, parser, ctx):  # actually a STIXPatternParser.PropTestContext)
+        def __init__(self, parser, ctx): # actually a STIXPatternParser.PropTestContext)
             super(STIXPatternParser.PropTestRegexContext, self).__init__(parser)
             self.copyFrom(ctx)
 
         def objectPath(self):
-            return self.getTypedRuleContext(STIXPatternParser.ObjectPathContext, 0)
+            return self.getTypedRuleContext(STIXPatternParser.ObjectPathContext,0)
 
         def MATCHES(self):
             return self.getToken(STIXPatternParser.MATCHES, 0)
-
         def StringLiteral(self):
             return self.getToken(STIXPatternParser.StringLiteral, 0)
-
         def NOT(self):
             return self.getToken(STIXPatternParser.NOT, 0)
 
@@ -863,30 +914,27 @@ class STIXPatternParser(Parser):
             if hasattr(listener, "exitPropTestRegex"):
                 listener.exitPropTestRegex(self)
 
+
     class PropTestOrderContext(PropTestContext):
 
-        def __init__(self, parser, ctx):  # actually a STIXPatternParser.PropTestContext)
+        def __init__(self, parser, ctx): # actually a STIXPatternParser.PropTestContext)
             super(STIXPatternParser.PropTestOrderContext, self).__init__(parser)
             self.copyFrom(ctx)
 
         def objectPath(self):
-            return self.getTypedRuleContext(STIXPatternParser.ObjectPathContext, 0)
+            return self.getTypedRuleContext(STIXPatternParser.ObjectPathContext,0)
 
         def orderableLiteral(self):
-            return self.getTypedRuleContext(STIXPatternParser.OrderableLiteralContext, 0)
+            return self.getTypedRuleContext(STIXPatternParser.OrderableLiteralContext,0)
 
         def GT(self):
             return self.getToken(STIXPatternParser.GT, 0)
-
         def LT(self):
             return self.getToken(STIXPatternParser.LT, 0)
-
         def GE(self):
             return self.getToken(STIXPatternParser.GE, 0)
-
         def LE(self):
             return self.getToken(STIXPatternParser.LE, 0)
-
         def NOT(self):
             return self.getToken(STIXPatternParser.NOT, 0)
 
@@ -898,21 +946,20 @@ class STIXPatternParser(Parser):
             if hasattr(listener, "exitPropTestOrder"):
                 listener.exitPropTestOrder(self)
 
+
     class PropTestLikeContext(PropTestContext):
 
-        def __init__(self, parser, ctx):  # actually a STIXPatternParser.PropTestContext)
+        def __init__(self, parser, ctx): # actually a STIXPatternParser.PropTestContext)
             super(STIXPatternParser.PropTestLikeContext, self).__init__(parser)
             self.copyFrom(ctx)
 
         def objectPath(self):
-            return self.getTypedRuleContext(STIXPatternParser.ObjectPathContext, 0)
+            return self.getTypedRuleContext(STIXPatternParser.ObjectPathContext,0)
 
         def LIKE(self):
             return self.getToken(STIXPatternParser.LIKE, 0)
-
         def StringLiteral(self):
             return self.getToken(STIXPatternParser.StringLiteral, 0)
-
         def NOT(self):
             return self.getToken(STIXPatternParser.NOT, 0)
 
@@ -924,24 +971,23 @@ class STIXPatternParser(Parser):
             if hasattr(listener, "exitPropTestLike"):
                 listener.exitPropTestLike(self)
 
+
     class PropTestEqualContext(PropTestContext):
 
-        def __init__(self, parser, ctx):  # actually a STIXPatternParser.PropTestContext)
+        def __init__(self, parser, ctx): # actually a STIXPatternParser.PropTestContext)
             super(STIXPatternParser.PropTestEqualContext, self).__init__(parser)
             self.copyFrom(ctx)
 
         def objectPath(self):
-            return self.getTypedRuleContext(STIXPatternParser.ObjectPathContext, 0)
+            return self.getTypedRuleContext(STIXPatternParser.ObjectPathContext,0)
 
         def primitiveLiteral(self):
-            return self.getTypedRuleContext(STIXPatternParser.PrimitiveLiteralContext, 0)
+            return self.getTypedRuleContext(STIXPatternParser.PrimitiveLiteralContext,0)
 
         def EQ(self):
             return self.getToken(STIXPatternParser.EQ, 0)
-
         def NEQ(self):
             return self.getToken(STIXPatternParser.NEQ, 0)
-
         def NOT(self):
             return self.getToken(STIXPatternParser.NOT, 0)
 
@@ -953,20 +999,20 @@ class STIXPatternParser(Parser):
             if hasattr(listener, "exitPropTestEqual"):
                 listener.exitPropTestEqual(self)
 
+
     class PropTestSetContext(PropTestContext):
 
-        def __init__(self, parser, ctx):  # actually a STIXPatternParser.PropTestContext)
+        def __init__(self, parser, ctx): # actually a STIXPatternParser.PropTestContext)
             super(STIXPatternParser.PropTestSetContext, self).__init__(parser)
             self.copyFrom(ctx)
 
         def objectPath(self):
-            return self.getTypedRuleContext(STIXPatternParser.ObjectPathContext, 0)
+            return self.getTypedRuleContext(STIXPatternParser.ObjectPathContext,0)
 
         def IN(self):
             return self.getToken(STIXPatternParser.IN, 0)
-
         def setLiteral(self):
-            return self.getTypedRuleContext(STIXPatternParser.SetLiteralContext, 0)
+            return self.getTypedRuleContext(STIXPatternParser.SetLiteralContext,0)
 
         def NOT(self):
             return self.getToken(STIXPatternParser.NOT, 0)
@@ -979,21 +1025,20 @@ class STIXPatternParser(Parser):
             if hasattr(listener, "exitPropTestSet"):
                 listener.exitPropTestSet(self)
 
+
     class PropTestIsSubsetContext(PropTestContext):
 
-        def __init__(self, parser, ctx):  # actually a STIXPatternParser.PropTestContext)
+        def __init__(self, parser, ctx): # actually a STIXPatternParser.PropTestContext)
             super(STIXPatternParser.PropTestIsSubsetContext, self).__init__(parser)
             self.copyFrom(ctx)
 
         def objectPath(self):
-            return self.getTypedRuleContext(STIXPatternParser.ObjectPathContext, 0)
+            return self.getTypedRuleContext(STIXPatternParser.ObjectPathContext,0)
 
         def ISSUBSET(self):
             return self.getToken(STIXPatternParser.ISSUBSET, 0)
-
         def StringLiteral(self):
             return self.getToken(STIXPatternParser.StringLiteral, 0)
-
         def NOT(self):
             return self.getToken(STIXPatternParser.NOT, 0)
 
@@ -1005,17 +1050,17 @@ class STIXPatternParser(Parser):
             if hasattr(listener, "exitPropTestIsSubset"):
                 listener.exitPropTestIsSubset(self)
 
+
     class PropTestParenContext(PropTestContext):
 
-        def __init__(self, parser, ctx):  # actually a STIXPatternParser.PropTestContext)
+        def __init__(self, parser, ctx): # actually a STIXPatternParser.PropTestContext)
             super(STIXPatternParser.PropTestParenContext, self).__init__(parser)
             self.copyFrom(ctx)
 
         def LPAREN(self):
             return self.getToken(STIXPatternParser.LPAREN, 0)
-
         def comparisonExpression(self):
-            return self.getTypedRuleContext(STIXPatternParser.ComparisonExpressionContext, 0)
+            return self.getTypedRuleContext(STIXPatternParser.ComparisonExpressionContext,0)
 
         def RPAREN(self):
             return self.getToken(STIXPatternParser.RPAREN, 0)
@@ -1028,21 +1073,20 @@ class STIXPatternParser(Parser):
             if hasattr(listener, "exitPropTestParen"):
                 listener.exitPropTestParen(self)
 
+
     class PropTestIsSupersetContext(PropTestContext):
 
-        def __init__(self, parser, ctx):  # actually a STIXPatternParser.PropTestContext)
+        def __init__(self, parser, ctx): # actually a STIXPatternParser.PropTestContext)
             super(STIXPatternParser.PropTestIsSupersetContext, self).__init__(parser)
             self.copyFrom(ctx)
 
         def objectPath(self):
-            return self.getTypedRuleContext(STIXPatternParser.ObjectPathContext, 0)
+            return self.getTypedRuleContext(STIXPatternParser.ObjectPathContext,0)
 
         def ISSUPERSET(self):
             return self.getToken(STIXPatternParser.ISSUPERSET, 0)
-
         def StringLiteral(self):
             return self.getToken(STIXPatternParser.StringLiteral, 0)
-
         def NOT(self):
             return self.getToken(STIXPatternParser.NOT, 0)
 
@@ -1054,14 +1098,17 @@ class STIXPatternParser(Parser):
             if hasattr(listener, "exitPropTestIsSuperset"):
                 listener.exitPropTestIsSuperset(self)
 
+
+
     def propTest(self):
+
         localctx = STIXPatternParser.PropTestContext(self, self._ctx, self.state)
         self.enterRule(localctx, 14, self.RULE_propTest)
-        self._la = 0  # Token type
+        self._la = 0 # Token type
         try:
             self.state = 168
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input, 15, self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,15,self._ctx)
             if la_ == 1:
                 localctx = STIXPatternParser.PropTestEqualContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
@@ -1070,13 +1117,14 @@ class STIXPatternParser(Parser):
                 self.state = 117
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if _la == STIXPatternParser.NOT:
+                if _la==STIXPatternParser.NOT:
                     self.state = 116
                     self.match(STIXPatternParser.NOT)
 
+
                 self.state = 119
                 _la = self._input.LA(1)
-                if not(_la == STIXPatternParser.EQ or _la == STIXPatternParser.NEQ):
+                if not(_la==STIXPatternParser.EQ or _la==STIXPatternParser.NEQ):
                     self._errHandler.recoverInline(self)
                 else:
                     self._errHandler.reportMatch(self)
@@ -1093,17 +1141,14 @@ class STIXPatternParser(Parser):
                 self.state = 124
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if _la == STIXPatternParser.NOT:
+                if _la==STIXPatternParser.NOT:
                     self.state = 123
                     self.match(STIXPatternParser.NOT)
 
+
                 self.state = 126
                 _la = self._input.LA(1)
-                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & (
-                        (1 << STIXPatternParser.LT) |
-                        (1 << STIXPatternParser.LE) |
-                        (1 << STIXPatternParser.GT) |
-                        (1 << STIXPatternParser.GE))) != 0)):
+                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << STIXPatternParser.LT) | (1 << STIXPatternParser.LE) | (1 << STIXPatternParser.GT) | (1 << STIXPatternParser.GE))) != 0)):
                     self._errHandler.recoverInline(self)
                 else:
                     self._errHandler.reportMatch(self)
@@ -1120,10 +1165,11 @@ class STIXPatternParser(Parser):
                 self.state = 131
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if _la == STIXPatternParser.NOT:
+                if _la==STIXPatternParser.NOT:
                     self.state = 130
                     self.match(STIXPatternParser.NOT)
 
+
                 self.state = 133
                 self.match(STIXPatternParser.IN)
                 self.state = 134
@@ -1138,10 +1184,11 @@ class STIXPatternParser(Parser):
                 self.state = 138
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if _la == STIXPatternParser.NOT:
+                if _la==STIXPatternParser.NOT:
                     self.state = 137
                     self.match(STIXPatternParser.NOT)
 
+
                 self.state = 140
                 self.match(STIXPatternParser.LIKE)
                 self.state = 141
@@ -1156,10 +1203,11 @@ class STIXPatternParser(Parser):
                 self.state = 145
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if _la == STIXPatternParser.NOT:
+                if _la==STIXPatternParser.NOT:
                     self.state = 144
                     self.match(STIXPatternParser.NOT)
 
+
                 self.state = 147
                 self.match(STIXPatternParser.MATCHES)
                 self.state = 148
@@ -1174,10 +1222,11 @@ class STIXPatternParser(Parser):
                 self.state = 152
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if _la == STIXPatternParser.NOT:
+                if _la==STIXPatternParser.NOT:
                     self.state = 151
                     self.match(STIXPatternParser.NOT)
 
+
                 self.state = 154
                 self.match(STIXPatternParser.ISSUBSET)
                 self.state = 155
@@ -1192,10 +1241,11 @@ class STIXPatternParser(Parser):
                 self.state = 159
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if _la == STIXPatternParser.NOT:
+                if _la==STIXPatternParser.NOT:
                     self.state = 158
                     self.match(STIXPatternParser.NOT)
 
+
                 self.state = 161
                 self.match(STIXPatternParser.ISSUPERSET)
                 self.state = 162
@@ -1213,6 +1263,7 @@ class STIXPatternParser(Parser):
                 self.match(STIXPatternParser.RPAREN)
                 pass
 
+
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -1250,7 +1301,11 @@ class STIXPatternParser(Parser):
             if hasattr(listener, "exitStartStopQualifier"):
                 listener.exitStartStopQualifier(self)
 
+
+
+
     def startStopQualifier(self):
+
         localctx = STIXPatternParser.StartStopQualifierContext(self, self._ctx, self.state)
         self.enterRule(localctx, 16, self.RULE_startStopQualifier)
         try:
@@ -1283,11 +1338,11 @@ class STIXPatternParser(Parser):
         def SECONDS(self):
             return self.getToken(STIXPatternParser.SECONDS, 0)
 
-        def IntLiteral(self):
-            return self.getToken(STIXPatternParser.IntLiteral, 0)
+        def IntPosLiteral(self):
+            return self.getToken(STIXPatternParser.IntPosLiteral, 0)
 
-        def FloatLiteral(self):
-            return self.getToken(STIXPatternParser.FloatLiteral, 0)
+        def FloatPosLiteral(self):
+            return self.getToken(STIXPatternParser.FloatPosLiteral, 0)
 
         def getRuleIndex(self):
             return STIXPatternParser.RULE_withinQualifier
@@ -1300,17 +1355,21 @@ class STIXPatternParser(Parser):
             if hasattr(listener, "exitWithinQualifier"):
                 listener.exitWithinQualifier(self)
 
+
+
+
     def withinQualifier(self):
+
         localctx = STIXPatternParser.WithinQualifierContext(self, self._ctx, self.state)
         self.enterRule(localctx, 18, self.RULE_withinQualifier)
-        self._la = 0  # Token type
+        self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
             self.state = 175
             self.match(STIXPatternParser.WITHIN)
             self.state = 176
             _la = self._input.LA(1)
-            if not(_la == STIXPatternParser.IntLiteral or _la == STIXPatternParser.FloatLiteral):
+            if not(_la==STIXPatternParser.IntPosLiteral or _la==STIXPatternParser.FloatPosLiteral):
                 self._errHandler.recoverInline(self)
             else:
                 self._errHandler.reportMatch(self)
@@ -1334,8 +1393,8 @@ class STIXPatternParser(Parser):
         def REPEATS(self):
             return self.getToken(STIXPatternParser.REPEATS, 0)
 
-        def IntLiteral(self):
-            return self.getToken(STIXPatternParser.IntLiteral, 0)
+        def IntPosLiteral(self):
+            return self.getToken(STIXPatternParser.IntPosLiteral, 0)
 
         def TIMES(self):
             return self.getToken(STIXPatternParser.TIMES, 0)
@@ -1351,7 +1410,11 @@ class STIXPatternParser(Parser):
             if hasattr(listener, "exitRepeatedQualifier"):
                 listener.exitRepeatedQualifier(self)
 
+
+
+
     def repeatedQualifier(self):
+
         localctx = STIXPatternParser.RepeatedQualifierContext(self, self._ctx, self.state)
         self.enterRule(localctx, 20, self.RULE_repeatedQualifier)
         try:
@@ -1359,7 +1422,7 @@ class STIXPatternParser(Parser):
             self.state = 179
             self.match(STIXPatternParser.REPEATS)
             self.state = 180
-            self.match(STIXPatternParser.IntLiteral)
+            self.match(STIXPatternParser.IntPosLiteral)
             self.state = 181
             self.match(STIXPatternParser.TIMES)
         except RecognitionException as re:
@@ -1377,16 +1440,19 @@ class STIXPatternParser(Parser):
             self.parser = parser
 
         def objectType(self):
-            return self.getTypedRuleContext(STIXPatternParser.ObjectTypeContext, 0)
+            return self.getTypedRuleContext(STIXPatternParser.ObjectTypeContext,0)
+
 
         def COLON(self):
             return self.getToken(STIXPatternParser.COLON, 0)
 
         def firstPathComponent(self):
-            return self.getTypedRuleContext(STIXPatternParser.FirstPathComponentContext, 0)
+            return self.getTypedRuleContext(STIXPatternParser.FirstPathComponentContext,0)
+
 
         def objectPathComponent(self):
-            return self.getTypedRuleContext(STIXPatternParser.ObjectPathComponentContext, 0)
+            return self.getTypedRuleContext(STIXPatternParser.ObjectPathComponentContext,0)
+
 
         def getRuleIndex(self):
             return STIXPatternParser.RULE_objectPath
@@ -1399,10 +1465,14 @@ class STIXPatternParser(Parser):
             if hasattr(listener, "exitObjectPath"):
                 listener.exitObjectPath(self)
 
+
+
+
     def objectPath(self):
+
         localctx = STIXPatternParser.ObjectPathContext(self, self._ctx, self.state)
         self.enterRule(localctx, 22, self.RULE_objectPath)
-        self._la = 0  # Token type
+        self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
             self.state = 183
@@ -1414,9 +1484,11 @@ class STIXPatternParser(Parser):
             self.state = 187
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la == STIXPatternParser.DOT or _la == STIXPatternParser.LBRACK:
+            if _la==STIXPatternParser.DOT or _la==STIXPatternParser.LBRACK:
                 self.state = 186
                 self.objectPathComponent(0)
+
+
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -1448,15 +1520,19 @@ class STIXPatternParser(Parser):
             if hasattr(listener, "exitObjectType"):
                 listener.exitObjectType(self)
 
+
+
+
     def objectType(self):
+
         localctx = STIXPatternParser.ObjectTypeContext(self, self._ctx, self.state)
         self.enterRule(localctx, 24, self.RULE_objectType)
-        self._la = 0  # Token type
+        self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
             self.state = 189
             _la = self._input.LA(1)
-            if not(_la == STIXPatternParser.IdentifierWithoutHyphen or _la == STIXPatternParser.IdentifierWithHyphen):
+            if not(_la==STIXPatternParser.IdentifierWithoutHyphen or _la==STIXPatternParser.IdentifierWithHyphen):
                 self._errHandler.recoverInline(self)
             else:
                 self._errHandler.reportMatch(self)
@@ -1492,15 +1568,19 @@ class STIXPatternParser(Parser):
             if hasattr(listener, "exitFirstPathComponent"):
                 listener.exitFirstPathComponent(self)
 
+
+
+
     def firstPathComponent(self):
+
         localctx = STIXPatternParser.FirstPathComponentContext(self, self._ctx, self.state)
         self.enterRule(localctx, 26, self.RULE_firstPathComponent)
-        self._la = 0  # Token type
+        self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
             self.state = 191
             _la = self._input.LA(1)
-            if not(_la == STIXPatternParser.StringLiteral or _la == STIXPatternParser.IdentifierWithoutHyphen):
+            if not(_la==STIXPatternParser.StringLiteral or _la==STIXPatternParser.IdentifierWithoutHyphen):
                 self._errHandler.recoverInline(self)
             else:
                 self._errHandler.reportMatch(self)
@@ -1519,27 +1599,29 @@ class STIXPatternParser(Parser):
             super(STIXPatternParser.ObjectPathComponentContext, self).__init__(parent, invokingState)
             self.parser = parser
 
+
         def getRuleIndex(self):
             return STIXPatternParser.RULE_objectPathComponent
 
+
         def copyFrom(self, ctx):
             super(STIXPatternParser.ObjectPathComponentContext, self).copyFrom(ctx)
 
+
     class IndexPathStepContext(ObjectPathComponentContext):
 
-        def __init__(self, parser, ctx):  # actually a STIXPatternParser.ObjectPathComponentContext)
+        def __init__(self, parser, ctx): # actually a STIXPatternParser.ObjectPathComponentContext)
             super(STIXPatternParser.IndexPathStepContext, self).__init__(parser)
             self.copyFrom(ctx)
 
         def LBRACK(self):
             return self.getToken(STIXPatternParser.LBRACK, 0)
-
         def RBRACK(self):
             return self.getToken(STIXPatternParser.RBRACK, 0)
-
-        def IntLiteral(self):
-            return self.getToken(STIXPatternParser.IntLiteral, 0)
-
+        def IntPosLiteral(self):
+            return self.getToken(STIXPatternParser.IntPosLiteral, 0)
+        def IntNegLiteral(self):
+            return self.getToken(STIXPatternParser.IntNegLiteral, 0)
         def ASTERISK(self):
             return self.getToken(STIXPatternParser.ASTERISK, 0)
 
@@ -1551,9 +1633,10 @@ class STIXPatternParser(Parser):
             if hasattr(listener, "exitIndexPathStep"):
                 listener.exitIndexPathStep(self)
 
+
     class PathStepContext(ObjectPathComponentContext):
 
-        def __init__(self, parser, ctx):  # actually a STIXPatternParser.ObjectPathComponentContext)
+        def __init__(self, parser, ctx): # actually a STIXPatternParser.ObjectPathComponentContext)
             super(STIXPatternParser.PathStepContext, self).__init__(parser)
             self.copyFrom(ctx)
 
@@ -1561,7 +1644,8 @@ class STIXPatternParser(Parser):
             if i is None:
                 return self.getTypedRuleContexts(STIXPatternParser.ObjectPathComponentContext)
             else:
-                return self.getTypedRuleContext(STIXPatternParser.ObjectPathComponentContext, i)
+                return self.getTypedRuleContext(STIXPatternParser.ObjectPathComponentContext,i)
+
 
         def enterRule(self, listener):
             if hasattr(listener, "enterPathStep"):
@@ -1571,15 +1655,15 @@ class STIXPatternParser(Parser):
             if hasattr(listener, "exitPathStep"):
                 listener.exitPathStep(self)
 
+
     class KeyPathStepContext(ObjectPathComponentContext):
 
-        def __init__(self, parser, ctx):  # actually a STIXPatternParser.ObjectPathComponentContext)
+        def __init__(self, parser, ctx): # actually a STIXPatternParser.ObjectPathComponentContext)
             super(STIXPatternParser.KeyPathStepContext, self).__init__(parser)
             self.copyFrom(ctx)
 
         def IdentifierWithoutHyphen(self):
             return self.getToken(STIXPatternParser.IdentifierWithoutHyphen, 0)
-
         def StringLiteral(self):
             return self.getToken(STIXPatternParser.StringLiteral, 0)
 
@@ -1591,13 +1675,16 @@ class STIXPatternParser(Parser):
             if hasattr(listener, "exitKeyPathStep"):
                 listener.exitKeyPathStep(self)
 
+
+
     def objectPathComponent(self, _p=0):
         _parentctx = self._ctx
         _parentState = self.state
         localctx = STIXPatternParser.ObjectPathComponentContext(self, self._ctx, _parentState)
+        _prevctx = localctx
         _startState = 28
         self.enterRecursionRule(localctx, 28, self.RULE_objectPathComponent, _p)
-        self._la = 0  # Token type
+        self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
             self.state = 199
@@ -1606,12 +1693,13 @@ class STIXPatternParser(Parser):
             if token in [STIXPatternParser.DOT]:
                 localctx = STIXPatternParser.KeyPathStepContext(self, localctx)
                 self._ctx = localctx
+                _prevctx = localctx
 
                 self.state = 194
                 self.match(STIXPatternParser.DOT)
                 self.state = 195
                 _la = self._input.LA(1)
-                if not(_la == STIXPatternParser.StringLiteral or _la == STIXPatternParser.IdentifierWithoutHyphen):
+                if not(_la==STIXPatternParser.StringLiteral or _la==STIXPatternParser.IdentifierWithoutHyphen):
                     self._errHandler.recoverInline(self)
                 else:
                     self._errHandler.reportMatch(self)
@@ -1620,11 +1708,12 @@ class STIXPatternParser(Parser):
             elif token in [STIXPatternParser.LBRACK]:
                 localctx = STIXPatternParser.IndexPathStepContext(self, localctx)
                 self._ctx = localctx
+                _prevctx = localctx
                 self.state = 196
                 self.match(STIXPatternParser.LBRACK)
                 self.state = 197
                 _la = self._input.LA(1)
-                if not(_la == STIXPatternParser.IntLiteral or _la == STIXPatternParser.ASTERISK):
+                if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << STIXPatternParser.IntNegLiteral) | (1 << STIXPatternParser.IntPosLiteral) | (1 << STIXPatternParser.ASTERISK))) != 0)):
                     self._errHandler.recoverInline(self)
                 else:
                     self._errHandler.reportMatch(self)
@@ -1638,11 +1727,12 @@ class STIXPatternParser(Parser):
             self._ctx.stop = self._input.LT(-1)
             self.state = 205
             self._errHandler.sync(self)
-            _alt = self._interp.adaptivePredict(self._input, 18, self._ctx)
-            while _alt != 2 and _alt != ATN.INVALID_ALT_NUMBER:
-                if _alt == 1:
+            _alt = self._interp.adaptivePredict(self._input,18,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
                     if self._parseListeners is not None:
                         self.triggerExitRuleEvent()
+                    _prevctx = localctx
                     localctx = STIXPatternParser.PathStepContext(self, STIXPatternParser.ObjectPathComponentContext(self, _parentctx, _parentState))
                     self.pushNewRecursionContext(localctx, _startState, self.RULE_objectPathComponent)
                     self.state = 201
@@ -1653,7 +1743,7 @@ class STIXPatternParser(Parser):
                     self.objectPathComponent(4)
                 self.state = 207
                 self._errHandler.sync(self)
-                _alt = self._interp.adaptivePredict(self._input, 18, self._ctx)
+                _alt = self._interp.adaptivePredict(self._input,18,self._ctx)
 
         except RecognitionException as re:
             localctx.exception = re
@@ -1679,7 +1769,8 @@ class STIXPatternParser(Parser):
             if i is None:
                 return self.getTypedRuleContexts(STIXPatternParser.PrimitiveLiteralContext)
             else:
-                return self.getTypedRuleContext(STIXPatternParser.PrimitiveLiteralContext, i)
+                return self.getTypedRuleContext(STIXPatternParser.PrimitiveLiteralContext,i)
+
 
         def COMMA(self, i=None):
             if i is None:
@@ -1698,14 +1789,18 @@ class STIXPatternParser(Parser):
             if hasattr(listener, "exitSetLiteral"):
                 listener.exitSetLiteral(self)
 
+
+
+
     def setLiteral(self):
+
         localctx = STIXPatternParser.SetLiteralContext(self, self._ctx, self.state)
         self.enterRule(localctx, 30, self.RULE_setLiteral)
-        self._la = 0  # Token type
+        self._la = 0 # Token type
         try:
             self.state = 221
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input, 20, self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,20,self._ctx)
             if la_ == 1:
                 self.enterOuterAlt(localctx, 1)
                 self.state = 208
@@ -1723,7 +1818,7 @@ class STIXPatternParser(Parser):
                 self.state = 216
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                while _la == STIXPatternParser.COMMA:
+                while _la==STIXPatternParser.COMMA:
                     self.state = 212
                     self.match(STIXPatternParser.COMMA)
                     self.state = 213
@@ -1736,6 +1831,7 @@ class STIXPatternParser(Parser):
                 self.match(STIXPatternParser.RPAREN)
                 pass
 
+
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -1751,7 +1847,8 @@ class STIXPatternParser(Parser):
             self.parser = parser
 
         def orderableLiteral(self):
-            return self.getTypedRuleContext(STIXPatternParser.OrderableLiteralContext, 0)
+            return self.getTypedRuleContext(STIXPatternParser.OrderableLiteralContext,0)
+
 
         def BoolLiteral(self):
             return self.getToken(STIXPatternParser.BoolLiteral, 0)
@@ -1767,19 +1864,18 @@ class STIXPatternParser(Parser):
             if hasattr(listener, "exitPrimitiveLiteral"):
                 listener.exitPrimitiveLiteral(self)
 
+
+
+
     def primitiveLiteral(self):
+
         localctx = STIXPatternParser.PrimitiveLiteralContext(self, self._ctx, self.state)
         self.enterRule(localctx, 32, self.RULE_primitiveLiteral)
         try:
             self.state = 225
             self._errHandler.sync(self)
             token = self._input.LA(1)
-            if token in [STIXPatternParser.IntLiteral,
-                         STIXPatternParser.FloatLiteral,
-                         STIXPatternParser.HexLiteral,
-                         STIXPatternParser.BinaryLiteral,
-                         STIXPatternParser.StringLiteral,
-                         STIXPatternParser.TimestampLiteral]:
+            if token in [STIXPatternParser.IntNegLiteral, STIXPatternParser.IntPosLiteral, STIXPatternParser.FloatNegLiteral, STIXPatternParser.FloatPosLiteral, STIXPatternParser.HexLiteral, STIXPatternParser.BinaryLiteral, STIXPatternParser.StringLiteral, STIXPatternParser.TimestampLiteral]:
                 self.enterOuterAlt(localctx, 1)
                 self.state = 223
                 self.orderableLiteral()
@@ -1791,6 +1887,7 @@ class STIXPatternParser(Parser):
                 pass
             else:
                 raise NoViableAltException(self)
+
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -1805,11 +1902,17 @@ class STIXPatternParser(Parser):
             super(STIXPatternParser.OrderableLiteralContext, self).__init__(parent, invokingState)
             self.parser = parser
 
-        def IntLiteral(self):
-            return self.getToken(STIXPatternParser.IntLiteral, 0)
+        def IntPosLiteral(self):
+            return self.getToken(STIXPatternParser.IntPosLiteral, 0)
+
+        def IntNegLiteral(self):
+            return self.getToken(STIXPatternParser.IntNegLiteral, 0)
 
-        def FloatLiteral(self):
-            return self.getToken(STIXPatternParser.FloatLiteral, 0)
+        def FloatPosLiteral(self):
+            return self.getToken(STIXPatternParser.FloatPosLiteral, 0)
+
+        def FloatNegLiteral(self):
+            return self.getToken(STIXPatternParser.FloatNegLiteral, 0)
 
         def StringLiteral(self):
             return self.getToken(STIXPatternParser.StringLiteral, 0)
@@ -1834,21 +1937,19 @@ class STIXPatternParser(Parser):
             if hasattr(listener, "exitOrderableLiteral"):
                 listener.exitOrderableLiteral(self)
 
+
+
+
     def orderableLiteral(self):
+
         localctx = STIXPatternParser.OrderableLiteralContext(self, self._ctx, self.state)
         self.enterRule(localctx, 34, self.RULE_orderableLiteral)
-        self._la = 0  # Token type
+        self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
             self.state = 227
             _la = self._input.LA(1)
-            if not ((((_la) & ~0x3f) == 0 and ((1 << _la) & (
-                    (1 << STIXPatternParser.IntLiteral) |
-                    (1 << STIXPatternParser.FloatLiteral) |
-                    (1 << STIXPatternParser.HexLiteral) |
-                    (1 << STIXPatternParser.BinaryLiteral) |
-                    (1 << STIXPatternParser.StringLiteral) |
-                    (1 << STIXPatternParser.TimestampLiteral))) != 0)):
+            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << STIXPatternParser.IntNegLiteral) | (1 << STIXPatternParser.IntPosLiteral) | (1 << STIXPatternParser.FloatNegLiteral) | (1 << STIXPatternParser.FloatPosLiteral) | (1 << STIXPatternParser.HexLiteral) | (1 << STIXPatternParser.BinaryLiteral) | (1 << STIXPatternParser.StringLiteral) | (1 << STIXPatternParser.TimestampLiteral))) != 0)):
                 self._errHandler.recoverInline(self)
             else:
                 self._errHandler.reportMatch(self)
@@ -1861,8 +1962,10 @@ class STIXPatternParser(Parser):
             self.exitRule()
         return localctx
 
+
+
     def sempred(self, localctx, ruleIndex, predIndex):
-        if self._predicates is None:
+        if self._predicates == None:
             self._predicates = dict()
         self._predicates[1] = self.observationExpressions_sempred
         self._predicates[2] = self.observationExpressionOr_sempred
@@ -1881,32 +1984,40 @@ class STIXPatternParser(Parser):
             if predIndex == 0:
                 return self.precpred(self._ctx, 2)
 
+
     def observationExpressionOr_sempred(self, localctx, predIndex):
             if predIndex == 1:
                 return self.precpred(self._ctx, 2)
 
+
     def observationExpressionAnd_sempred(self, localctx, predIndex):
             if predIndex == 2:
                 return self.precpred(self._ctx, 2)
 
+
     def observationExpression_sempred(self, localctx, predIndex):
             if predIndex == 3:
                 return self.precpred(self._ctx, 3)
 
+
             if predIndex == 4:
                 return self.precpred(self._ctx, 2)
 
+
             if predIndex == 5:
                 return self.precpred(self._ctx, 1)
 
+
     def comparisonExpression_sempred(self, localctx, predIndex):
             if predIndex == 6:
                 return self.precpred(self._ctx, 2)
 
+
     def comparisonExpressionAnd_sempred(self, localctx, predIndex):
             if predIndex == 7:
                 return self.precpred(self._ctx, 2)
 
+
     def objectPathComponent_sempred(self, localctx, predIndex):
             if predIndex == 8:
                 return self.precpred(self._ctx, 3)
diff --git a/stix2patterns/inspector.py b/stix2patterns/inspector.py
index c172ab7..faa77ec 100644
--- a/stix2patterns/inspector.py
+++ b/stix2patterns/inspector.py
@@ -73,14 +73,14 @@ class InspectionListener(STIXPatternListener):
     def exitWithinQualifier(self, ctx):
         self.__qualifiers.add(
             u"WITHIN {0} SECONDS".format(
-                ctx.IntLiteral() or ctx.FloatLiteral()
+                ctx.IntPosLiteral() or ctx.FloatPosLiteral()
             )
         )
 
     def exitRepeatedQualifier(self, ctx):
         self.__qualifiers.add(
             u"REPEATS {0} TIMES".format(
-                ctx.IntLiteral()
+                ctx.IntPosLiteral()
             )
         )
 
@@ -172,4 +172,4 @@ class InspectionListener(STIXPatternListener):
         if ctx.ASTERISK():
             self.__obj_path.append(INDEX_STAR)
         else:
-            self.__obj_path.append(int(ctx.IntLiteral().getText()))
+            self.__obj_path.append(int(ctx.IntPosLiteral().getText()))


Test patch:
diff --git a/stix2patterns/test/test_validator.py b/stix2patterns/test/test_validator.py
index 7ed81c7..2256e3e 100644
--- a/stix2patterns/test/test_validator.py
+++ b/stix2patterns/test/test_validator.py
@@ -32,11 +32,19 @@ FAIL_CASES = [
     ("[file:name MATCHES /.*\\.dll/]",  # Quotes around regular expression
         "FAIL: Error found at line 1:19. mismatched input '/' expecting StringLiteral"),
     ("[win-registry-key:key = 'hkey_local_machine\\\\foo\\\\bar'] WITHIN ]",  # Missing Qualifier value
-        "FAIL: Error found at line 1:63. mismatched input ']' expecting {IntLiteral, FloatLiteral}"),
+        "FAIL: Error found at line 1:63. mismatched input ']' expecting {IntPosLiteral, FloatPosLiteral}"),
     ("[win-registry-key:key = 'hkey_local_machine\\\\foo\\\\bar'] WITHIN 5 HOURS]",  # SECONDS is the only valid time unit
         "FAIL: Error found at line 1:65. mismatched input 'HOURS' expecting SECONDS"),
+    ("[win-registry-key:key = 'hkey_local_machine\\\\foo\\\\bar'] WITHIN -5 SECONDS]",  # Negative integer is invalid
+        "FAIL: Error found at line 1:63. mismatched input '-5' expecting {IntPosLiteral, FloatPosLiteral}"),
     ("[network-traffic:dst_ref.value ISSUBSET ]",  # Missing second Comparison operand
         "FAIL: Error found at line 1:40. missing StringLiteral at ']'"),
+    ("[file:hashes.MD5 =? 'cead3f77f6cda6ec00f57d76c9a6879f']",  # '=?' isn't a valid operator
+        "FAIL: Error found at line 1:18. extraneous input '?'"),
+    ("[x_whatever:detected == t'2457-73-22T32:81:84.1Z']",  # Not a valid date
+        "FAIL: Error found at line 1:24. extraneous input 't'"),
+    ("[artifact:payload_bin = b'====']",  # Not valid Base64
+        "FAIL: Error found at line 1:24. extraneous input 'b'"),
     # TODO: add more failing test cases.
 ]
 
@@ -69,6 +77,8 @@ PASS_CASES = [
     "[file:size IN (1024, 2048, 4096)]",
     "[network-connection:extended_properties[0].source_payload MATCHES 'dGVzdHRlc3R0ZXN0']",
     "[win-registry-key:key = 'hkey_local_machine\\\\foo\\\\bar'] WITHIN 5 SECONDS",
+    "[x_whatever:detected == t'2018-03-22T12:11:14.1Z']",
+    "[artifact:payload_bin = b'dGhpcyBpcyBhIHRlc3Q=']",
 ]