Repository: rigetticomputing/pyquil
Pull request #174 (2017-11-03 21:09:50)

Fix error with setup.py and add pi to parser


Patch:
diff --git a/pyquil/_parser/PyQuilListener.py b/pyquil/_parser/PyQuilListener.py
index 158c963..069adb7 100644
--- a/pyquil/_parser/PyQuilListener.py
+++ b/pyquil/_parser/PyQuilListener.py
@@ -2,6 +2,8 @@ import operator
 from typing import Any, List
 
 import sys
+
+import numpy as np
 from antlr4 import *
 from antlr4.IntervalSet import IntervalSet
 from antlr4.Token import CommonToken
@@ -283,6 +285,8 @@ def _number(number):
         return complex(0, _real(number.imaginaryN().realN()))
     elif number.I():
         return complex(0, 1)
+    elif number.PI():
+        return np.pi
     else:
         raise RuntimeError("Unexpected number: " + str(number))
 
diff --git a/pyquil/_parser/Quil.g4 b/pyquil/_parser/Quil.g4
index 7125faf..8d37a7d 100644
--- a/pyquil/_parser/Quil.g4
+++ b/pyquil/_parser/Quil.g4
@@ -4,7 +4,7 @@ grammar Quil;
 // PARSER
 ////////////////////
 
-quil                : allInstr (NEWLINE+ allInstr)* NEWLINE* EOF ;
+quil                : allInstr (NEWLINE+ allInstr)* EOF ;
 
 allInstr            : defGate
                     | defCircuit
@@ -114,7 +114,7 @@ function            : SIN | COS | SQRT | EXP | CIS ;
 // Numbers
 // We suffix -N onto these names so they don't conflict with already defined Python types
 
-number              : realN | imaginaryN | I ;
+number              : realN | imaginaryN | I | PI ;
 imaginaryN          : realN I ;
 realN               : floatN | intN ;
 
diff --git a/pyquil/_parser/gen2/QuilParser.py b/pyquil/_parser/gen2/QuilParser.py
index 3a721c7..cddd1b2 100644
--- a/pyquil/_parser/gen2/QuilParser.py
+++ b/pyquil/_parser/gen2/QuilParser.py
@@ -8,7 +8,7 @@ import sys
 def serializedATN():
     with StringIO() as buf:
         buf.write(u"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3")
-        buf.write(u"\66\u0184\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"\66\u017f\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\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4")
@@ -16,171 +16,166 @@ def serializedATN():
         buf.write(u"\t\35\4\36\t\36\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4")
         buf.write(u"$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t")
         buf.write(u",\3\2\3\2\6\2[\n\2\r\2\16\2\\\3\2\7\2`\n\2\f\2\16\2c")
-        buf.write(u"\13\2\3\2\7\2f\n\2\f\2\16\2i\13\2\3\2\3\2\3\3\3\3\3\3")
-        buf.write(u"\5\3p\n\3\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4")
-        buf.write(u"\3\4\3\4\3\4\5\4\u0080\n\4\3\5\3\5\3\5\3\5\3\5\7\5\u0087")
-        buf.write(u"\n\5\f\5\16\5\u008a\13\5\3\5\3\5\5\5\u008e\n\5\3\5\6")
-        buf.write(u"\5\u0091\n\5\r\5\16\5\u0092\3\6\3\6\3\7\3\7\3\b\3\b\5")
-        buf.write(u"\b\u009b\n\b\3\t\3\t\3\t\3\t\5\t\u00a1\n\t\3\t\3\t\3")
-        buf.write(u"\n\3\n\3\n\3\n\3\n\3\n\7\n\u00ab\n\n\f\n\16\n\u00ae\13")
-        buf.write(u"\n\3\n\3\n\5\n\u00b2\n\n\3\n\3\n\3\n\3\n\3\13\3\13\3")
-        buf.write(u"\13\3\f\3\f\3\f\7\f\u00be\n\f\f\f\16\f\u00c1\13\f\3\f")
-        buf.write(u"\3\f\3\r\3\r\3\r\3\r\7\r\u00c9\n\r\f\r\16\r\u00cc\13")
-        buf.write(u"\r\3\16\3\16\3\16\3\16\3\16\3\16\7\16\u00d4\n\16\f\16")
-        buf.write(u"\16\16\u00d7\13\16\3\16\3\16\5\16\u00db\n\16\3\16\7\16")
-        buf.write(u"\u00de\n\16\f\16\16\16\u00e1\13\16\3\16\3\16\3\16\3\16")
-        buf.write(u"\3\17\3\17\3\20\3\20\5\20\u00eb\n\20\3\21\3\21\3\21\3")
-        buf.write(u"\21\3\21\7\21\u00f2\n\21\f\21\16\21\u00f5\13\21\3\21")
-        buf.write(u"\3\21\5\21\u00f9\n\21\3\21\6\21\u00fc\n\21\r\21\16\21")
-        buf.write(u"\u00fd\3\22\3\22\5\22\u0102\n\22\3\23\3\23\3\23\3\23")
-        buf.write(u"\7\23\u0108\n\23\f\23\16\23\u010b\13\23\3\23\3\23\3\23")
-        buf.write(u"\3\24\3\24\3\24\5\24\u0113\n\24\3\25\3\25\3\25\3\25\3")
-        buf.write(u"\26\6\26\u011a\n\26\r\26\16\26\u011b\3\27\3\27\3\27\3")
-        buf.write(u"\30\3\30\3\30\3\31\3\31\3\32\3\32\3\32\3\33\3\33\3\33")
-        buf.write(u"\3\33\3\34\3\34\3\34\3\34\3\35\3\35\3\36\3\36\3\37\3")
-        buf.write(u"\37\3\37\3 \3 \3 \3 \3!\3!\3\"\3\"\3\"\3#\3#\3#\7#\u0144")
-        buf.write(u"\n#\f#\16#\u0147\13#\3#\5#\u014a\n#\3$\3$\3%\3%\3%\3")
-        buf.write(u"%\3%\3%\3%\3%\3%\3%\3%\3%\5%\u015a\n%\3%\3%\3%\3%\3%")
-        buf.write(u"\3%\3%\3%\3%\7%\u0165\n%\f%\16%\u0168\13%\3&\3&\3\'\3")
-        buf.write(u"\'\3\'\5\'\u016f\n\'\3(\3(\3(\3)\3)\5)\u0176\n)\3*\5")
-        buf.write(u"*\u0179\n*\3*\3*\3+\5+\u017e\n+\3+\3+\3,\3,\3,\2\3H-")
-        buf.write(u"\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62")
-        buf.write(u"\64\668:<>@BDFHJLNPRTV\2\b\3\2\20\22\3\2\23\26\3\2#$")
-        buf.write(u"\3\2 !\3\2\36\37\3\2\31\35\2\u018b\2X\3\2\2\2\4o\3\2")
-        buf.write(u"\2\2\6\177\3\2\2\2\b\u0081\3\2\2\2\n\u0094\3\2\2\2\f")
-        buf.write(u"\u0096\3\2\2\2\16\u009a\3\2\2\2\20\u009c\3\2\2\2\22\u00a4")
-        buf.write(u"\3\2\2\2\24\u00b7\3\2\2\2\26\u00bf\3\2\2\2\30\u00c4\3")
-        buf.write(u"\2\2\2\32\u00cd\3\2\2\2\34\u00e6\3\2\2\2\36\u00ea\3\2")
-        buf.write(u"\2\2 \u00ec\3\2\2\2\"\u0101\3\2\2\2$\u0109\3\2\2\2&\u010f")
-        buf.write(u"\3\2\2\2(\u0114\3\2\2\2*\u0119\3\2\2\2,\u011d\3\2\2\2")
-        buf.write(u".\u0120\3\2\2\2\60\u0123\3\2\2\2\62\u0125\3\2\2\2\64")
-        buf.write(u"\u0128\3\2\2\2\66\u012c\3\2\2\28\u0130\3\2\2\2:\u0132")
-        buf.write(u"\3\2\2\2<\u0134\3\2\2\2>\u0137\3\2\2\2@\u013b\3\2\2\2")
-        buf.write(u"B\u013d\3\2\2\2D\u0140\3\2\2\2F\u014b\3\2\2\2H\u0159")
-        buf.write(u"\3\2\2\2J\u0169\3\2\2\2L\u016e\3\2\2\2N\u0170\3\2\2\2")
-        buf.write(u"P\u0175\3\2\2\2R\u0178\3\2\2\2T\u017d\3\2\2\2V\u0181")
-        buf.write(u"\3\2\2\2Xa\5\4\3\2Y[\7\63\2\2ZY\3\2\2\2[\\\3\2\2\2\\")
-        buf.write(u"Z\3\2\2\2\\]\3\2\2\2]^\3\2\2\2^`\5\4\3\2_Z\3\2\2\2`c")
-        buf.write(u"\3\2\2\2a_\3\2\2\2ab\3\2\2\2bg\3\2\2\2ca\3\2\2\2df\7")
-        buf.write(u"\63\2\2ed\3\2\2\2fi\3\2\2\2ge\3\2\2\2gh\3\2\2\2hj\3\2")
-        buf.write(u"\2\2ig\3\2\2\2jk\7\2\2\3k\3\3\2\2\2lp\5\22\n\2mp\5\32")
-        buf.write(u"\16\2np\5\6\4\2ol\3\2\2\2om\3\2\2\2on\3\2\2\2p\5\3\2")
-        buf.write(u"\2\2q\u0080\5\b\5\2r\u0080\5&\24\2s\u0080\5,\27\2t\u0080")
-        buf.write(u"\5\60\31\2u\u0080\5\62\32\2v\u0080\5\64\33\2w\u0080\5")
-        buf.write(u"\66\34\2x\u0080\58\35\2y\u0080\5:\36\2z\u0080\5<\37\2")
-        buf.write(u"{\u0080\5> \2|\u0080\5@!\2}\u0080\5B\"\2~\u0080\5D#\2")
-        buf.write(u"\177q\3\2\2\2\177r\3\2\2\2\177s\3\2\2\2\177t\3\2\2\2")
-        buf.write(u"\177u\3\2\2\2\177v\3\2\2\2\177w\3\2\2\2\177x\3\2\2\2")
-        buf.write(u"\177y\3\2\2\2\177z\3\2\2\2\177{\3\2\2\2\177|\3\2\2\2")
-        buf.write(u"\177}\3\2\2\2\177~\3\2\2\2\u0080\7\3\2\2\2\u0081\u008d")
-        buf.write(u"\5\n\6\2\u0082\u0083\7)\2\2\u0083\u0088\5\16\b\2\u0084")
-        buf.write(u"\u0085\7(\2\2\u0085\u0087\5\16\b\2\u0086\u0084\3\2\2")
-        buf.write(u"\2\u0087\u008a\3\2\2\2\u0088\u0086\3\2\2\2\u0088\u0089")
-        buf.write(u"\3\2\2\2\u0089\u008b\3\2\2\2\u008a\u0088\3\2\2\2\u008b")
-        buf.write(u"\u008c\7*\2\2\u008c\u008e\3\2\2\2\u008d\u0082\3\2\2\2")
-        buf.write(u"\u008d\u008e\3\2\2\2\u008e\u0090\3\2\2\2\u008f\u0091")
-        buf.write(u"\5\f\7\2\u0090\u008f\3\2\2\2\u0091\u0092\3\2\2\2\u0092")
-        buf.write(u"\u0090\3\2\2\2\u0092\u0093\3\2\2\2\u0093\t\3\2\2\2\u0094")
-        buf.write(u"\u0095\7#\2\2\u0095\13\3\2\2\2\u0096\u0097\7$\2\2\u0097")
-        buf.write(u"\r\3\2\2\2\u0098\u009b\5\20\t\2\u0099\u009b\5H%\2\u009a")
-        buf.write(u"\u0098\3\2\2\2\u009a\u0099\3\2\2\2\u009b\17\3\2\2\2\u009c")
-        buf.write(u"\u009d\7+\2\2\u009d\u00a0\7$\2\2\u009e\u009f\7\37\2\2")
-        buf.write(u"\u009f\u00a1\7$\2\2\u00a0\u009e\3\2\2\2\u00a0\u00a1\3")
-        buf.write(u"\2\2\2\u00a1\u00a2\3\2\2\2\u00a2\u00a3\7,\2\2\u00a3\21")
-        buf.write(u"\3\2\2\2\u00a4\u00a5\7\3\2\2\u00a5\u00b1\5\n\6\2\u00a6")
-        buf.write(u"\u00a7\7)\2\2\u00a7\u00ac\5\24\13\2\u00a8\u00a9\7(\2")
-        buf.write(u"\2\u00a9\u00ab\5\24\13\2\u00aa\u00a8\3\2\2\2\u00ab\u00ae")
-        buf.write(u"\3\2\2\2\u00ac\u00aa\3\2\2\2\u00ac\u00ad\3\2\2\2\u00ad")
-        buf.write(u"\u00af\3\2\2\2\u00ae\u00ac\3\2\2\2\u00af\u00b0\7*\2\2")
-        buf.write(u"\u00b0\u00b2\3\2\2\2\u00b1\u00a6\3\2\2\2\u00b1\u00b2")
-        buf.write(u"\3\2\2\2\u00b2\u00b3\3\2\2\2\u00b3\u00b4\7-\2\2\u00b4")
-        buf.write(u"\u00b5\7\63\2\2\u00b5\u00b6\5\26\f\2\u00b6\23\3\2\2\2")
-        buf.write(u"\u00b7\u00b8\7.\2\2\u00b8\u00b9\7#\2\2\u00b9\25\3\2\2")
-        buf.write(u"\2\u00ba\u00bb\5\30\r\2\u00bb\u00bc\7\63\2\2\u00bc\u00be")
-        buf.write(u"\3\2\2\2\u00bd\u00ba\3\2\2\2\u00be\u00c1\3\2\2\2\u00bf")
-        buf.write(u"\u00bd\3\2\2\2\u00bf\u00c0\3\2\2\2\u00c0\u00c2\3\2\2")
-        buf.write(u"\2\u00c1\u00bf\3\2\2\2\u00c2\u00c3\5\30\r\2\u00c3\27")
-        buf.write(u"\3\2\2\2\u00c4\u00c5\7\62\2\2\u00c5\u00ca\5H%\2\u00c6")
-        buf.write(u"\u00c7\7(\2\2\u00c7\u00c9\5H%\2\u00c8\u00c6\3\2\2\2\u00c9")
-        buf.write(u"\u00cc\3\2\2\2\u00ca\u00c8\3\2\2\2\u00ca\u00cb\3\2\2")
-        buf.write(u"\2\u00cb\31\3\2\2\2\u00cc\u00ca\3\2\2\2\u00cd\u00ce\7")
-        buf.write(u"\4\2\2\u00ce\u00da\5\n\6\2\u00cf\u00d0\7)\2\2\u00d0\u00d5")
-        buf.write(u"\5\24\13\2\u00d1\u00d2\7(\2\2\u00d2\u00d4\5\24\13\2\u00d3")
-        buf.write(u"\u00d1\3\2\2\2\u00d4\u00d7\3\2\2\2\u00d5\u00d3\3\2\2")
-        buf.write(u"\2\u00d5\u00d6\3\2\2\2\u00d6\u00d8\3\2\2\2\u00d7\u00d5")
-        buf.write(u"\3\2\2\2\u00d8\u00d9\7*\2\2\u00d9\u00db\3\2\2\2\u00da")
-        buf.write(u"\u00cf\3\2\2\2\u00da\u00db\3\2\2\2\u00db\u00df\3\2\2")
-        buf.write(u"\2\u00dc\u00de\5\34\17\2\u00dd\u00dc\3\2\2\2\u00de\u00e1")
-        buf.write(u"\3\2\2\2\u00df\u00dd\3\2\2\2\u00df\u00e0\3\2\2\2\u00e0")
-        buf.write(u"\u00e2\3\2\2\2\u00e1\u00df\3\2\2\2\u00e2\u00e3\7-\2\2")
-        buf.write(u"\u00e3\u00e4\7\63\2\2\u00e4\u00e5\5$\23\2\u00e5\33\3")
-        buf.write(u"\2\2\2\u00e6\u00e7\7#\2\2\u00e7\35\3\2\2\2\u00e8\u00eb")
-        buf.write(u"\5\f\7\2\u00e9\u00eb\5\34\17\2\u00ea\u00e8\3\2\2\2\u00ea")
-        buf.write(u"\u00e9\3\2\2\2\u00eb\37\3\2\2\2\u00ec\u00f8\5\n\6\2\u00ed")
-        buf.write(u"\u00ee\7)\2\2\u00ee\u00f3\5\16\b\2\u00ef\u00f0\7(\2\2")
-        buf.write(u"\u00f0\u00f2\5\16\b\2\u00f1\u00ef\3\2\2\2\u00f2\u00f5")
-        buf.write(u"\3\2\2\2\u00f3\u00f1\3\2\2\2\u00f3\u00f4\3\2\2\2\u00f4")
-        buf.write(u"\u00f6\3\2\2\2\u00f5\u00f3\3\2\2\2\u00f6\u00f7\7*\2\2")
-        buf.write(u"\u00f7\u00f9\3\2\2\2\u00f8\u00ed\3\2\2\2\u00f8\u00f9")
-        buf.write(u"\3\2\2\2\u00f9\u00fb\3\2\2\2\u00fa\u00fc\5\36\20\2\u00fb")
-        buf.write(u"\u00fa\3\2\2\2\u00fc\u00fd\3\2\2\2\u00fd\u00fb\3\2\2")
-        buf.write(u"\2\u00fd\u00fe\3\2\2\2\u00fe!\3\2\2\2\u00ff\u0102\5 ")
-        buf.write(u"\21\2\u0100\u0102\5\6\4\2\u0101\u00ff\3\2\2\2\u0101\u0100")
-        buf.write(u"\3\2\2\2\u0102#\3\2\2\2\u0103\u0104\7\62\2\2\u0104\u0105")
-        buf.write(u"\5\"\22\2\u0105\u0106\7\63\2\2\u0106\u0108\3\2\2\2\u0107")
-        buf.write(u"\u0103\3\2\2\2\u0108\u010b\3\2\2\2\u0109\u0107\3\2\2")
-        buf.write(u"\2\u0109\u010a\3\2\2\2\u010a\u010c\3\2\2\2\u010b\u0109")
-        buf.write(u"\3\2\2\2\u010c\u010d\7\62\2\2\u010d\u010e\5\"\22\2\u010e")
-        buf.write(u"%\3\2\2\2\u010f\u0110\7\5\2\2\u0110\u0112\5\f\7\2\u0111")
-        buf.write(u"\u0113\5(\25\2\u0112\u0111\3\2\2\2\u0112\u0113\3\2\2")
-        buf.write(u"\2\u0113\'\3\2\2\2\u0114\u0115\7+\2\2\u0115\u0116\5*")
-        buf.write(u"\26\2\u0116\u0117\7,\2\2\u0117)\3\2\2\2\u0118\u011a\7")
-        buf.write(u"$\2\2\u0119\u0118\3\2\2\2\u011a\u011b\3\2\2\2\u011b\u0119")
-        buf.write(u"\3\2\2\2\u011b\u011c\3\2\2\2\u011c+\3\2\2\2\u011d\u011e")
-        buf.write(u"\7\6\2\2\u011e\u011f\5.\30\2\u011f-\3\2\2\2\u0120\u0121")
-        buf.write(u"\7/\2\2\u0121\u0122\7#\2\2\u0122/\3\2\2\2\u0123\u0124")
-        buf.write(u"\7\7\2\2\u0124\61\3\2\2\2\u0125\u0126\7\b\2\2\u0126\u0127")
-        buf.write(u"\5.\30\2\u0127\63\3\2\2\2\u0128\u0129\7\t\2\2\u0129\u012a")
-        buf.write(u"\5.\30\2\u012a\u012b\5(\25\2\u012b\65\3\2\2\2\u012c\u012d")
-        buf.write(u"\7\n\2\2\u012d\u012e\5.\30\2\u012e\u012f\5(\25\2\u012f")
-        buf.write(u"\67\3\2\2\2\u0130\u0131\7\13\2\2\u01319\3\2\2\2\u0132")
-        buf.write(u"\u0133\7\f\2\2\u0133;\3\2\2\2\u0134\u0135\t\2\2\2\u0135")
-        buf.write(u"\u0136\5(\25\2\u0136=\3\2\2\2\u0137\u0138\t\3\2\2\u0138")
-        buf.write(u"\u0139\5(\25\2\u0139\u013a\5(\25\2\u013a?\3\2\2\2\u013b")
-        buf.write(u"\u013c\7\r\2\2\u013cA\3\2\2\2\u013d\u013e\7\16\2\2\u013e")
-        buf.write(u"\u013f\7&\2\2\u013fC\3\2\2\2\u0140\u0141\7\17\2\2\u0141")
-        buf.write(u"\u0145\7#\2\2\u0142\u0144\5F$\2\u0143\u0142\3\2\2\2\u0144")
-        buf.write(u"\u0147\3\2\2\2\u0145\u0143\3\2\2\2\u0145\u0146\3\2\2")
-        buf.write(u"\2\u0146\u0149\3\2\2\2\u0147\u0145\3\2\2\2\u0148\u014a")
-        buf.write(u"\7&\2\2\u0149\u0148\3\2\2\2\u0149\u014a\3\2\2\2\u014a")
-        buf.write(u"E\3\2\2\2\u014b\u014c\t\4\2\2\u014cG\3\2\2\2\u014d\u014e")
-        buf.write(u"\b%\1\2\u014e\u014f\7)\2\2\u014f\u0150\5H%\2\u0150\u0151")
-        buf.write(u"\7*\2\2\u0151\u015a\3\2\2\2\u0152\u0153\5J&\2\u0153\u0154")
-        buf.write(u"\7)\2\2\u0154\u0155\5H%\2\u0155\u0156\7*\2\2\u0156\u015a")
-        buf.write(u"\3\2\2\2\u0157\u015a\5L\'\2\u0158\u015a\5\24\13\2\u0159")
-        buf.write(u"\u014d\3\2\2\2\u0159\u0152\3\2\2\2\u0159\u0157\3\2\2")
-        buf.write(u"\2\u0159\u0158\3\2\2\2\u015a\u0166\3\2\2\2\u015b\u015c")
-        buf.write(u"\f\b\2\2\u015c\u015d\7\"\2\2\u015d\u0165\5H%\b\u015e")
-        buf.write(u"\u015f\f\7\2\2\u015f\u0160\t\5\2\2\u0160\u0165\5H%\b")
-        buf.write(u"\u0161\u0162\f\6\2\2\u0162\u0163\t\6\2\2\u0163\u0165")
-        buf.write(u"\5H%\7\u0164\u015b\3\2\2\2\u0164\u015e\3\2\2\2\u0164")
-        buf.write(u"\u0161\3\2\2\2\u0165\u0168\3\2\2\2\u0166\u0164\3\2\2")
-        buf.write(u"\2\u0166\u0167\3\2\2\2\u0167I\3\2\2\2\u0168\u0166\3\2")
-        buf.write(u"\2\2\u0169\u016a\t\7\2\2\u016aK\3\2\2\2\u016b\u016f\5")
-        buf.write(u"P)\2\u016c\u016f\5N(\2\u016d\u016f\7\30\2\2\u016e\u016b")
-        buf.write(u"\3\2\2\2\u016e\u016c\3\2\2\2\u016e\u016d\3\2\2\2\u016f")
-        buf.write(u"M\3\2\2\2\u0170\u0171\5P)\2\u0171\u0172\7\30\2\2\u0172")
-        buf.write(u"O\3\2\2\2\u0173\u0176\5R*\2\u0174\u0176\5T+\2\u0175\u0173")
-        buf.write(u"\3\2\2\2\u0175\u0174\3\2\2\2\u0176Q\3\2\2\2\u0177\u0179")
-        buf.write(u"\5V,\2\u0178\u0177\3\2\2\2\u0178\u0179\3\2\2\2\u0179")
-        buf.write(u"\u017a\3\2\2\2\u017a\u017b\7%\2\2\u017bS\3\2\2\2\u017c")
-        buf.write(u"\u017e\5V,\2\u017d\u017c\3\2\2\2\u017d\u017e\3\2\2\2")
-        buf.write(u"\u017e\u017f\3\2\2\2\u017f\u0180\7$\2\2\u0180U\3\2\2")
-        buf.write(u"\2\u0181\u0182\t\6\2\2\u0182W\3\2\2\2$\\ago\177\u0088")
-        buf.write(u"\u008d\u0092\u009a\u00a0\u00ac\u00b1\u00bf\u00ca\u00d5")
-        buf.write(u"\u00da\u00df\u00ea\u00f3\u00f8\u00fd\u0101\u0109\u0112")
-        buf.write(u"\u011b\u0145\u0149\u0159\u0164\u0166\u016e\u0175\u0178")
-        buf.write(u"\u017d")
+        buf.write(u"\13\2\3\2\3\2\3\3\3\3\3\3\5\3j\n\3\3\4\3\4\3\4\3\4\3")
+        buf.write(u"\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\5\4z\n\4\3\5\3")
+        buf.write(u"\5\3\5\3\5\3\5\7\5\u0081\n\5\f\5\16\5\u0084\13\5\3\5")
+        buf.write(u"\3\5\5\5\u0088\n\5\3\5\6\5\u008b\n\5\r\5\16\5\u008c\3")
+        buf.write(u"\6\3\6\3\7\3\7\3\b\3\b\5\b\u0095\n\b\3\t\3\t\3\t\3\t")
+        buf.write(u"\5\t\u009b\n\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\n\7\n\u00a5")
+        buf.write(u"\n\n\f\n\16\n\u00a8\13\n\3\n\3\n\5\n\u00ac\n\n\3\n\3")
+        buf.write(u"\n\3\n\3\n\3\13\3\13\3\13\3\f\3\f\3\f\7\f\u00b8\n\f\f")
+        buf.write(u"\f\16\f\u00bb\13\f\3\f\3\f\3\r\3\r\3\r\3\r\7\r\u00c3")
+        buf.write(u"\n\r\f\r\16\r\u00c6\13\r\3\16\3\16\3\16\3\16\3\16\3\16")
+        buf.write(u"\7\16\u00ce\n\16\f\16\16\16\u00d1\13\16\3\16\3\16\5\16")
+        buf.write(u"\u00d5\n\16\3\16\7\16\u00d8\n\16\f\16\16\16\u00db\13")
+        buf.write(u"\16\3\16\3\16\3\16\3\16\3\17\3\17\3\20\3\20\5\20\u00e5")
+        buf.write(u"\n\20\3\21\3\21\3\21\3\21\3\21\7\21\u00ec\n\21\f\21\16")
+        buf.write(u"\21\u00ef\13\21\3\21\3\21\5\21\u00f3\n\21\3\21\6\21\u00f6")
+        buf.write(u"\n\21\r\21\16\21\u00f7\3\22\3\22\5\22\u00fc\n\22\3\23")
+        buf.write(u"\3\23\3\23\3\23\7\23\u0102\n\23\f\23\16\23\u0105\13\23")
+        buf.write(u"\3\23\3\23\3\23\3\24\3\24\3\24\5\24\u010d\n\24\3\25\3")
+        buf.write(u"\25\3\25\3\25\3\26\6\26\u0114\n\26\r\26\16\26\u0115\3")
+        buf.write(u"\27\3\27\3\27\3\30\3\30\3\30\3\31\3\31\3\32\3\32\3\32")
+        buf.write(u"\3\33\3\33\3\33\3\33\3\34\3\34\3\34\3\34\3\35\3\35\3")
+        buf.write(u"\36\3\36\3\37\3\37\3\37\3 \3 \3 \3 \3!\3!\3\"\3\"\3\"")
+        buf.write(u"\3#\3#\3#\7#\u013e\n#\f#\16#\u0141\13#\3#\5#\u0144\n")
+        buf.write(u"#\3$\3$\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\5%\u0154")
+        buf.write(u"\n%\3%\3%\3%\3%\3%\3%\3%\3%\3%\7%\u015f\n%\f%\16%\u0162")
+        buf.write(u"\13%\3&\3&\3\'\3\'\3\'\3\'\5\'\u016a\n\'\3(\3(\3(\3)")
+        buf.write(u"\3)\5)\u0171\n)\3*\5*\u0174\n*\3*\3*\3+\5+\u0179\n+\3")
+        buf.write(u"+\3+\3,\3,\3,\2\3H-\2\4\6\b\n\f\16\20\22\24\26\30\32")
+        buf.write(u"\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTV\2\b\3\2\20")
+        buf.write(u"\22\3\2\23\26\3\2#$\3\2 !\3\2\36\37\3\2\31\35\2\u0186")
+        buf.write(u"\2X\3\2\2\2\4i\3\2\2\2\6y\3\2\2\2\b{\3\2\2\2\n\u008e")
+        buf.write(u"\3\2\2\2\f\u0090\3\2\2\2\16\u0094\3\2\2\2\20\u0096\3")
+        buf.write(u"\2\2\2\22\u009e\3\2\2\2\24\u00b1\3\2\2\2\26\u00b9\3\2")
+        buf.write(u"\2\2\30\u00be\3\2\2\2\32\u00c7\3\2\2\2\34\u00e0\3\2\2")
+        buf.write(u"\2\36\u00e4\3\2\2\2 \u00e6\3\2\2\2\"\u00fb\3\2\2\2$\u0103")
+        buf.write(u"\3\2\2\2&\u0109\3\2\2\2(\u010e\3\2\2\2*\u0113\3\2\2\2")
+        buf.write(u",\u0117\3\2\2\2.\u011a\3\2\2\2\60\u011d\3\2\2\2\62\u011f")
+        buf.write(u"\3\2\2\2\64\u0122\3\2\2\2\66\u0126\3\2\2\28\u012a\3\2")
+        buf.write(u"\2\2:\u012c\3\2\2\2<\u012e\3\2\2\2>\u0131\3\2\2\2@\u0135")
+        buf.write(u"\3\2\2\2B\u0137\3\2\2\2D\u013a\3\2\2\2F\u0145\3\2\2\2")
+        buf.write(u"H\u0153\3\2\2\2J\u0163\3\2\2\2L\u0169\3\2\2\2N\u016b")
+        buf.write(u"\3\2\2\2P\u0170\3\2\2\2R\u0173\3\2\2\2T\u0178\3\2\2\2")
+        buf.write(u"V\u017c\3\2\2\2Xa\5\4\3\2Y[\7\63\2\2ZY\3\2\2\2[\\\3\2")
+        buf.write(u"\2\2\\Z\3\2\2\2\\]\3\2\2\2]^\3\2\2\2^`\5\4\3\2_Z\3\2")
+        buf.write(u"\2\2`c\3\2\2\2a_\3\2\2\2ab\3\2\2\2bd\3\2\2\2ca\3\2\2")
+        buf.write(u"\2de\7\2\2\3e\3\3\2\2\2fj\5\22\n\2gj\5\32\16\2hj\5\6")
+        buf.write(u"\4\2if\3\2\2\2ig\3\2\2\2ih\3\2\2\2j\5\3\2\2\2kz\5\b\5")
+        buf.write(u"\2lz\5&\24\2mz\5,\27\2nz\5\60\31\2oz\5\62\32\2pz\5\64")
+        buf.write(u"\33\2qz\5\66\34\2rz\58\35\2sz\5:\36\2tz\5<\37\2uz\5>")
+        buf.write(u" \2vz\5@!\2wz\5B\"\2xz\5D#\2yk\3\2\2\2yl\3\2\2\2ym\3")
+        buf.write(u"\2\2\2yn\3\2\2\2yo\3\2\2\2yp\3\2\2\2yq\3\2\2\2yr\3\2")
+        buf.write(u"\2\2ys\3\2\2\2yt\3\2\2\2yu\3\2\2\2yv\3\2\2\2yw\3\2\2")
+        buf.write(u"\2yx\3\2\2\2z\7\3\2\2\2{\u0087\5\n\6\2|}\7)\2\2}\u0082")
+        buf.write(u"\5\16\b\2~\177\7(\2\2\177\u0081\5\16\b\2\u0080~\3\2\2")
+        buf.write(u"\2\u0081\u0084\3\2\2\2\u0082\u0080\3\2\2\2\u0082\u0083")
+        buf.write(u"\3\2\2\2\u0083\u0085\3\2\2\2\u0084\u0082\3\2\2\2\u0085")
+        buf.write(u"\u0086\7*\2\2\u0086\u0088\3\2\2\2\u0087|\3\2\2\2\u0087")
+        buf.write(u"\u0088\3\2\2\2\u0088\u008a\3\2\2\2\u0089\u008b\5\f\7")
+        buf.write(u"\2\u008a\u0089\3\2\2\2\u008b\u008c\3\2\2\2\u008c\u008a")
+        buf.write(u"\3\2\2\2\u008c\u008d\3\2\2\2\u008d\t\3\2\2\2\u008e\u008f")
+        buf.write(u"\7#\2\2\u008f\13\3\2\2\2\u0090\u0091\7$\2\2\u0091\r\3")
+        buf.write(u"\2\2\2\u0092\u0095\5\20\t\2\u0093\u0095\5H%\2\u0094\u0092")
+        buf.write(u"\3\2\2\2\u0094\u0093\3\2\2\2\u0095\17\3\2\2\2\u0096\u0097")
+        buf.write(u"\7+\2\2\u0097\u009a\7$\2\2\u0098\u0099\7\37\2\2\u0099")
+        buf.write(u"\u009b\7$\2\2\u009a\u0098\3\2\2\2\u009a\u009b\3\2\2\2")
+        buf.write(u"\u009b\u009c\3\2\2\2\u009c\u009d\7,\2\2\u009d\21\3\2")
+        buf.write(u"\2\2\u009e\u009f\7\3\2\2\u009f\u00ab\5\n\6\2\u00a0\u00a1")
+        buf.write(u"\7)\2\2\u00a1\u00a6\5\24\13\2\u00a2\u00a3\7(\2\2\u00a3")
+        buf.write(u"\u00a5\5\24\13\2\u00a4\u00a2\3\2\2\2\u00a5\u00a8\3\2")
+        buf.write(u"\2\2\u00a6\u00a4\3\2\2\2\u00a6\u00a7\3\2\2\2\u00a7\u00a9")
+        buf.write(u"\3\2\2\2\u00a8\u00a6\3\2\2\2\u00a9\u00aa\7*\2\2\u00aa")
+        buf.write(u"\u00ac\3\2\2\2\u00ab\u00a0\3\2\2\2\u00ab\u00ac\3\2\2")
+        buf.write(u"\2\u00ac\u00ad\3\2\2\2\u00ad\u00ae\7-\2\2\u00ae\u00af")
+        buf.write(u"\7\63\2\2\u00af\u00b0\5\26\f\2\u00b0\23\3\2\2\2\u00b1")
+        buf.write(u"\u00b2\7.\2\2\u00b2\u00b3\7#\2\2\u00b3\25\3\2\2\2\u00b4")
+        buf.write(u"\u00b5\5\30\r\2\u00b5\u00b6\7\63\2\2\u00b6\u00b8\3\2")
+        buf.write(u"\2\2\u00b7\u00b4\3\2\2\2\u00b8\u00bb\3\2\2\2\u00b9\u00b7")
+        buf.write(u"\3\2\2\2\u00b9\u00ba\3\2\2\2\u00ba\u00bc\3\2\2\2\u00bb")
+        buf.write(u"\u00b9\3\2\2\2\u00bc\u00bd\5\30\r\2\u00bd\27\3\2\2\2")
+        buf.write(u"\u00be\u00bf\7\62\2\2\u00bf\u00c4\5H%\2\u00c0\u00c1\7")
+        buf.write(u"(\2\2\u00c1\u00c3\5H%\2\u00c2\u00c0\3\2\2\2\u00c3\u00c6")
+        buf.write(u"\3\2\2\2\u00c4\u00c2\3\2\2\2\u00c4\u00c5\3\2\2\2\u00c5")
+        buf.write(u"\31\3\2\2\2\u00c6\u00c4\3\2\2\2\u00c7\u00c8\7\4\2\2\u00c8")
+        buf.write(u"\u00d4\5\n\6\2\u00c9\u00ca\7)\2\2\u00ca\u00cf\5\24\13")
+        buf.write(u"\2\u00cb\u00cc\7(\2\2\u00cc\u00ce\5\24\13\2\u00cd\u00cb")
+        buf.write(u"\3\2\2\2\u00ce\u00d1\3\2\2\2\u00cf\u00cd\3\2\2\2\u00cf")
+        buf.write(u"\u00d0\3\2\2\2\u00d0\u00d2\3\2\2\2\u00d1\u00cf\3\2\2")
+        buf.write(u"\2\u00d2\u00d3\7*\2\2\u00d3\u00d5\3\2\2\2\u00d4\u00c9")
+        buf.write(u"\3\2\2\2\u00d4\u00d5\3\2\2\2\u00d5\u00d9\3\2\2\2\u00d6")
+        buf.write(u"\u00d8\5\34\17\2\u00d7\u00d6\3\2\2\2\u00d8\u00db\3\2")
+        buf.write(u"\2\2\u00d9\u00d7\3\2\2\2\u00d9\u00da\3\2\2\2\u00da\u00dc")
+        buf.write(u"\3\2\2\2\u00db\u00d9\3\2\2\2\u00dc\u00dd\7-\2\2\u00dd")
+        buf.write(u"\u00de\7\63\2\2\u00de\u00df\5$\23\2\u00df\33\3\2\2\2")
+        buf.write(u"\u00e0\u00e1\7#\2\2\u00e1\35\3\2\2\2\u00e2\u00e5\5\f")
+        buf.write(u"\7\2\u00e3\u00e5\5\34\17\2\u00e4\u00e2\3\2\2\2\u00e4")
+        buf.write(u"\u00e3\3\2\2\2\u00e5\37\3\2\2\2\u00e6\u00f2\5\n\6\2\u00e7")
+        buf.write(u"\u00e8\7)\2\2\u00e8\u00ed\5\16\b\2\u00e9\u00ea\7(\2\2")
+        buf.write(u"\u00ea\u00ec\5\16\b\2\u00eb\u00e9\3\2\2\2\u00ec\u00ef")
+        buf.write(u"\3\2\2\2\u00ed\u00eb\3\2\2\2\u00ed\u00ee\3\2\2\2\u00ee")
+        buf.write(u"\u00f0\3\2\2\2\u00ef\u00ed\3\2\2\2\u00f0\u00f1\7*\2\2")
+        buf.write(u"\u00f1\u00f3\3\2\2\2\u00f2\u00e7\3\2\2\2\u00f2\u00f3")
+        buf.write(u"\3\2\2\2\u00f3\u00f5\3\2\2\2\u00f4\u00f6\5\36\20\2\u00f5")
+        buf.write(u"\u00f4\3\2\2\2\u00f6\u00f7\3\2\2\2\u00f7\u00f5\3\2\2")
+        buf.write(u"\2\u00f7\u00f8\3\2\2\2\u00f8!\3\2\2\2\u00f9\u00fc\5 ")
+        buf.write(u"\21\2\u00fa\u00fc\5\6\4\2\u00fb\u00f9\3\2\2\2\u00fb\u00fa")
+        buf.write(u"\3\2\2\2\u00fc#\3\2\2\2\u00fd\u00fe\7\62\2\2\u00fe\u00ff")
+        buf.write(u"\5\"\22\2\u00ff\u0100\7\63\2\2\u0100\u0102\3\2\2\2\u0101")
+        buf.write(u"\u00fd\3\2\2\2\u0102\u0105\3\2\2\2\u0103\u0101\3\2\2")
+        buf.write(u"\2\u0103\u0104\3\2\2\2\u0104\u0106\3\2\2\2\u0105\u0103")
+        buf.write(u"\3\2\2\2\u0106\u0107\7\62\2\2\u0107\u0108\5\"\22\2\u0108")
+        buf.write(u"%\3\2\2\2\u0109\u010a\7\5\2\2\u010a\u010c\5\f\7\2\u010b")
+        buf.write(u"\u010d\5(\25\2\u010c\u010b\3\2\2\2\u010c\u010d\3\2\2")
+        buf.write(u"\2\u010d\'\3\2\2\2\u010e\u010f\7+\2\2\u010f\u0110\5*")
+        buf.write(u"\26\2\u0110\u0111\7,\2\2\u0111)\3\2\2\2\u0112\u0114\7")
+        buf.write(u"$\2\2\u0113\u0112\3\2\2\2\u0114\u0115\3\2\2\2\u0115\u0113")
+        buf.write(u"\3\2\2\2\u0115\u0116\3\2\2\2\u0116+\3\2\2\2\u0117\u0118")
+        buf.write(u"\7\6\2\2\u0118\u0119\5.\30\2\u0119-\3\2\2\2\u011a\u011b")
+        buf.write(u"\7/\2\2\u011b\u011c\7#\2\2\u011c/\3\2\2\2\u011d\u011e")
+        buf.write(u"\7\7\2\2\u011e\61\3\2\2\2\u011f\u0120\7\b\2\2\u0120\u0121")
+        buf.write(u"\5.\30\2\u0121\63\3\2\2\2\u0122\u0123\7\t\2\2\u0123\u0124")
+        buf.write(u"\5.\30\2\u0124\u0125\5(\25\2\u0125\65\3\2\2\2\u0126\u0127")
+        buf.write(u"\7\n\2\2\u0127\u0128\5.\30\2\u0128\u0129\5(\25\2\u0129")
+        buf.write(u"\67\3\2\2\2\u012a\u012b\7\13\2\2\u012b9\3\2\2\2\u012c")
+        buf.write(u"\u012d\7\f\2\2\u012d;\3\2\2\2\u012e\u012f\t\2\2\2\u012f")
+        buf.write(u"\u0130\5(\25\2\u0130=\3\2\2\2\u0131\u0132\t\3\2\2\u0132")
+        buf.write(u"\u0133\5(\25\2\u0133\u0134\5(\25\2\u0134?\3\2\2\2\u0135")
+        buf.write(u"\u0136\7\r\2\2\u0136A\3\2\2\2\u0137\u0138\7\16\2\2\u0138")
+        buf.write(u"\u0139\7&\2\2\u0139C\3\2\2\2\u013a\u013b\7\17\2\2\u013b")
+        buf.write(u"\u013f\7#\2\2\u013c\u013e\5F$\2\u013d\u013c\3\2\2\2\u013e")
+        buf.write(u"\u0141\3\2\2\2\u013f\u013d\3\2\2\2\u013f\u0140\3\2\2")
+        buf.write(u"\2\u0140\u0143\3\2\2\2\u0141\u013f\3\2\2\2\u0142\u0144")
+        buf.write(u"\7&\2\2\u0143\u0142\3\2\2\2\u0143\u0144\3\2\2\2\u0144")
+        buf.write(u"E\3\2\2\2\u0145\u0146\t\4\2\2\u0146G\3\2\2\2\u0147\u0148")
+        buf.write(u"\b%\1\2\u0148\u0149\7)\2\2\u0149\u014a\5H%\2\u014a\u014b")
+        buf.write(u"\7*\2\2\u014b\u0154\3\2\2\2\u014c\u014d\5J&\2\u014d\u014e")
+        buf.write(u"\7)\2\2\u014e\u014f\5H%\2\u014f\u0150\7*\2\2\u0150\u0154")
+        buf.write(u"\3\2\2\2\u0151\u0154\5L\'\2\u0152\u0154\5\24\13\2\u0153")
+        buf.write(u"\u0147\3\2\2\2\u0153\u014c\3\2\2\2\u0153\u0151\3\2\2")
+        buf.write(u"\2\u0153\u0152\3\2\2\2\u0154\u0160\3\2\2\2\u0155\u0156")
+        buf.write(u"\f\b\2\2\u0156\u0157\7\"\2\2\u0157\u015f\5H%\b\u0158")
+        buf.write(u"\u0159\f\7\2\2\u0159\u015a\t\5\2\2\u015a\u015f\5H%\b")
+        buf.write(u"\u015b\u015c\f\6\2\2\u015c\u015d\t\6\2\2\u015d\u015f")
+        buf.write(u"\5H%\7\u015e\u0155\3\2\2\2\u015e\u0158\3\2\2\2\u015e")
+        buf.write(u"\u015b\3\2\2\2\u015f\u0162\3\2\2\2\u0160\u015e\3\2\2")
+        buf.write(u"\2\u0160\u0161\3\2\2\2\u0161I\3\2\2\2\u0162\u0160\3\2")
+        buf.write(u"\2\2\u0163\u0164\t\7\2\2\u0164K\3\2\2\2\u0165\u016a\5")
+        buf.write(u"P)\2\u0166\u016a\5N(\2\u0167\u016a\7\30\2\2\u0168\u016a")
+        buf.write(u"\7\27\2\2\u0169\u0165\3\2\2\2\u0169\u0166\3\2\2\2\u0169")
+        buf.write(u"\u0167\3\2\2\2\u0169\u0168\3\2\2\2\u016aM\3\2\2\2\u016b")
+        buf.write(u"\u016c\5P)\2\u016c\u016d\7\30\2\2\u016dO\3\2\2\2\u016e")
+        buf.write(u"\u0171\5R*\2\u016f\u0171\5T+\2\u0170\u016e\3\2\2\2\u0170")
+        buf.write(u"\u016f\3\2\2\2\u0171Q\3\2\2\2\u0172\u0174\5V,\2\u0173")
+        buf.write(u"\u0172\3\2\2\2\u0173\u0174\3\2\2\2\u0174\u0175\3\2\2")
+        buf.write(u"\2\u0175\u0176\7%\2\2\u0176S\3\2\2\2\u0177\u0179\5V,")
+        buf.write(u"\2\u0178\u0177\3\2\2\2\u0178\u0179\3\2\2\2\u0179\u017a")
+        buf.write(u"\3\2\2\2\u017a\u017b\7$\2\2\u017bU\3\2\2\2\u017c\u017d")
+        buf.write(u"\t\6\2\2\u017dW\3\2\2\2#\\aiy\u0082\u0087\u008c\u0094")
+        buf.write(u"\u009a\u00a6\u00ab\u00b9\u00c4\u00cf\u00d4\u00d9\u00e4")
+        buf.write(u"\u00ed\u00f2\u00f7\u00fb\u0103\u010c\u0115\u013f\u0143")
+        buf.write(u"\u0153\u015e\u0160\u0169\u0170\u0173\u0178")
         return buf.getvalue()
 
 
@@ -381,38 +376,27 @@ class QuilParser ( Parser ):
             self.allInstr()
             self.state = 95
             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:
-                    self.state = 88 
+            _la = self._input.LA(1)
+            while _la==QuilParser.NEWLINE:
+                self.state = 88 
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                while True:
+                    self.state = 87
+                    self.match(QuilParser.NEWLINE)
+                    self.state = 90 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
-                    while True:
-                        self.state = 87
-                        self.match(QuilParser.NEWLINE)
-                        self.state = 90 
-                        self._errHandler.sync(self)
-                        _la = self._input.LA(1)
-                        if not (_la==QuilParser.NEWLINE):
-                            break
+                    if not (_la==QuilParser.NEWLINE):
+                        break
 
-                    self.state = 92
-                    self.allInstr() 
+                self.state = 92
+                self.allInstr()
                 self.state = 97
                 self._errHandler.sync(self)
-                _alt = self._interp.adaptivePredict(self._input,1,self._ctx)
-
-            self.state = 101
-            self._errHandler.sync(self)
-            _la = self._input.LA(1)
-            while _la==QuilParser.NEWLINE:
-                self.state = 98
-                self.match(QuilParser.NEWLINE)
-                self.state = 103
-                self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 104
+            self.state = 98
             self.match(QuilParser.EOF)
         except RecognitionException as re:
             localctx.exception = re
@@ -459,22 +443,22 @@ class QuilParser ( Parser ):
         localctx = QuilParser.AllInstrContext(self, self._ctx, self.state)
         self.enterRule(localctx, 2, self.RULE_allInstr)
         try:
-            self.state = 109
+            self.state = 103
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [QuilParser.DEFGATE]:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 106
+                self.state = 100
                 self.defGate()
                 pass
             elif token in [QuilParser.DEFCIRCUIT]:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 107
+                self.state = 101
                 self.defCircuit()
                 pass
             elif token in [QuilParser.MEASURE, QuilParser.LABEL, QuilParser.HALT, QuilParser.JUMP, QuilParser.JUMPWHEN, QuilParser.JUMPUNLESS, QuilParser.RESET, QuilParser.WAIT, QuilParser.NOP, QuilParser.INCLUDE, QuilParser.PRAGMA, QuilParser.FALSE, QuilParser.TRUE, QuilParser.NOT, QuilParser.AND, QuilParser.OR, QuilParser.MOVE, QuilParser.EXCHANGE, QuilParser.IDENTIFIER]:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 108
+                self.state = 102
                 self.instr()
                 pass
             else:
@@ -569,77 +553,77 @@ class QuilParser ( Parser ):
         localctx = QuilParser.InstrContext(self, self._ctx, self.state)
         self.enterRule(localctx, 4, self.RULE_instr)
         try:
-            self.state = 125
+            self.state = 119
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [QuilParser.IDENTIFIER]:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 111
+                self.state = 105
                 self.gate()
                 pass
             elif token in [QuilParser.MEASURE]:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 112
+                self.state = 106
                 self.measure()
                 pass
             elif token in [QuilParser.LABEL]:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 113
+                self.state = 107
                 self.defLabel()
                 pass
             elif token in [QuilParser.HALT]:
                 self.enterOuterAlt(localctx, 4)
-                self.state = 114
+                self.state = 108
                 self.halt()
                 pass
             elif token in [QuilParser.JUMP]:
                 self.enterOuterAlt(localctx, 5)
-                self.state = 115
+                self.state = 109
                 self.jump()
                 pass
             elif token in [QuilParser.JUMPWHEN]:
                 self.enterOuterAlt(localctx, 6)
-                self.state = 116
+                self.state = 110
                 self.jumpWhen()
                 pass
             elif token in [QuilParser.JUMPUNLESS]:
                 self.enterOuterAlt(localctx, 7)
-                self.state = 117
+                self.state = 111
                 self.jumpUnless()
                 pass
             elif token in [QuilParser.RESET]:
                 self.enterOuterAlt(localctx, 8)
-                self.state = 118
+                self.state = 112
                 self.resetState()
                 pass
             elif token in [QuilParser.WAIT]:
                 self.enterOuterAlt(localctx, 9)
-                self.state = 119
+                self.state = 113
                 self.wait()
                 pass
             elif token in [QuilParser.FALSE, QuilParser.TRUE, QuilParser.NOT]:
                 self.enterOuterAlt(localctx, 10)
-                self.state = 120
+                self.state = 114
                 self.classicalUnary()
                 pass
             elif token in [QuilParser.AND, QuilParser.OR, QuilParser.MOVE, QuilParser.EXCHANGE]:
                 self.enterOuterAlt(localctx, 11)
-                self.state = 121
+                self.state = 115
                 self.classicalBinary()
                 pass
             elif token in [QuilParser.NOP]:
                 self.enterOuterAlt(localctx, 12)
-                self.state = 122
+                self.state = 116
                 self.nop()
                 pass
             elif token in [QuilParser.INCLUDE]:
                 self.enterOuterAlt(localctx, 13)
-                self.state = 123
+                self.state = 117
                 self.include()
                 pass
             elif token in [QuilParser.PRAGMA]:
                 self.enterOuterAlt(localctx, 14)
-                self.state = 124
+                self.state = 118
                 self.pragma()
                 pass
             else:
@@ -710,39 +694,39 @@ class QuilParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 127
+            self.state = 121
             self.name()
-            self.state = 139
+            self.state = 133
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==QuilParser.LPAREN:
-                self.state = 128
+                self.state = 122
                 self.match(QuilParser.LPAREN)
-                self.state = 129
+                self.state = 123
                 self.param()
-                self.state = 134
+                self.state = 128
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while _la==QuilParser.COMMA:
-                    self.state = 130
+                    self.state = 124
                     self.match(QuilParser.COMMA)
-                    self.state = 131
+                    self.state = 125
                     self.param()
-                    self.state = 136
+                    self.state = 130
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
-                self.state = 137
+                self.state = 131
                 self.match(QuilParser.RPAREN)
 
 
-            self.state = 142 
+            self.state = 136 
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while True:
-                self.state = 141
+                self.state = 135
                 self.qubit()
-                self.state = 144 
+                self.state = 138 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if not (_la==QuilParser.UNSIGNED_INT):
@@ -785,7 +769,7 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 8, self.RULE_name)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 146
+            self.state = 140
             self.match(QuilParser.IDENTIFIER)
         except RecognitionException as re:
             localctx.exception = re
@@ -824,7 +808,7 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 10, self.RULE_qubit)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 148
+            self.state = 142
             self.match(QuilParser.UNSIGNED_INT)
         except RecognitionException as re:
             localctx.exception = re
@@ -867,17 +851,17 @@ class QuilParser ( Parser ):
         localctx = QuilParser.ParamContext(self, self._ctx, self.state)
         self.enterRule(localctx, 12, self.RULE_param)
         try:
-            self.state = 152
+            self.state = 146
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [QuilParser.LBRACKET]:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 150
+                self.state = 144
                 self.dynamicParam()
                 pass
-            elif token in [QuilParser.I, QuilParser.SIN, QuilParser.COS, QuilParser.SQRT, QuilParser.EXP, QuilParser.CIS, QuilParser.PLUS, QuilParser.MINUS, QuilParser.UNSIGNED_INT, QuilParser.UNSIGNED_FLOAT, QuilParser.LPAREN, QuilParser.PERCENTAGE]:
+            elif token in [QuilParser.PI, QuilParser.I, QuilParser.SIN, QuilParser.COS, QuilParser.SQRT, QuilParser.EXP, QuilParser.CIS, QuilParser.PLUS, QuilParser.MINUS, QuilParser.UNSIGNED_INT, QuilParser.UNSIGNED_FLOAT, QuilParser.LPAREN, QuilParser.PERCENTAGE]:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 151
+                self.state = 145
                 self.expression(0)
                 pass
             else:
@@ -933,21 +917,21 @@ class QuilParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 154
+            self.state = 148
             self.match(QuilParser.LBRACKET)
-            self.state = 155
+            self.state = 149
             self.match(QuilParser.UNSIGNED_INT)
-            self.state = 158
+            self.state = 152
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==QuilParser.MINUS:
-                self.state = 156
+                self.state = 150
                 self.match(QuilParser.MINUS)
-                self.state = 157
+                self.state = 151
                 self.match(QuilParser.UNSIGNED_INT)
 
 
-            self.state = 160
+            self.state = 154
             self.match(QuilParser.RBRACKET)
         except RecognitionException as re:
             localctx.exception = re
@@ -1020,39 +1004,39 @@ class QuilParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 162
+            self.state = 156
             self.match(QuilParser.DEFGATE)
-            self.state = 163
+            self.state = 157
             self.name()
-            self.state = 175
+            self.state = 169
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==QuilParser.LPAREN:
-                self.state = 164
+                self.state = 158
                 self.match(QuilParser.LPAREN)
-                self.state = 165
+                self.state = 159
                 self.variable()
-                self.state = 170
+                self.state = 164
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while _la==QuilParser.COMMA:
-                    self.state = 166
+                    self.state = 160
                     self.match(QuilParser.COMMA)
-                    self.state = 167
+                    self.state = 161
                     self.variable()
-                    self.state = 172
+                    self.state = 166
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
-                self.state = 173
+                self.state = 167
                 self.match(QuilParser.RPAREN)
 
 
-            self.state = 177
+            self.state = 171
             self.match(QuilParser.COLON)
-            self.state = 178
+            self.state = 172
             self.match(QuilParser.NEWLINE)
-            self.state = 179
+            self.state = 173
             self.matrix()
         except RecognitionException as re:
             localctx.exception = re
@@ -1094,9 +1078,9 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 18, self.RULE_variable)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 181
+            self.state = 175
             self.match(QuilParser.PERCENTAGE)
-            self.state = 182
+            self.state = 176
             self.match(QuilParser.IDENTIFIER)
         except RecognitionException as re:
             localctx.exception = re
@@ -1145,20 +1129,20 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 20, self.RULE_matrix)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 189
+            self.state = 183
             self._errHandler.sync(self)
-            _alt = self._interp.adaptivePredict(self._input,12,self._ctx)
+            _alt = self._interp.adaptivePredict(self._input,11,self._ctx)
             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                 if _alt==1:
-                    self.state = 184
+                    self.state = 178
                     self.matrixRow()
-                    self.state = 185
+                    self.state = 179
                     self.match(QuilParser.NEWLINE) 
-                self.state = 191
+                self.state = 185
                 self._errHandler.sync(self)
-                _alt = self._interp.adaptivePredict(self._input,12,self._ctx)
+                _alt = self._interp.adaptivePredict(self._input,11,self._ctx)
 
-            self.state = 192
+            self.state = 186
             self.matrixRow()
         except RecognitionException as re:
             localctx.exception = re
@@ -1211,19 +1195,19 @@ class QuilParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 194
+            self.state = 188
             self.match(QuilParser.TAB)
-            self.state = 195
+            self.state = 189
             self.expression(0)
-            self.state = 200
+            self.state = 194
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==QuilParser.COMMA:
-                self.state = 196
+                self.state = 190
                 self.match(QuilParser.COMMA)
-                self.state = 197
+                self.state = 191
                 self.expression(0)
-                self.state = 202
+                self.state = 196
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
@@ -1305,49 +1289,49 @@ class QuilParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 203
+            self.state = 197
             self.match(QuilParser.DEFCIRCUIT)
-            self.state = 204
+            self.state = 198
             self.name()
-            self.state = 216
+            self.state = 210
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==QuilParser.LPAREN:
-                self.state = 205
+                self.state = 199
                 self.match(QuilParser.LPAREN)
-                self.state = 206
+                self.state = 200
                 self.variable()
-                self.state = 211
+                self.state = 205
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while _la==QuilParser.COMMA:
-                    self.state = 207
+                    self.state = 201
                     self.match(QuilParser.COMMA)
-                    self.state = 208
+                    self.state = 202
                     self.variable()
-                    self.state = 213
+                    self.state = 207
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
-                self.state = 214
+                self.state = 208
                 self.match(QuilParser.RPAREN)
 
 
-            self.state = 221
+            self.state = 215
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==QuilParser.IDENTIFIER:
-                self.state = 218
+                self.state = 212
                 self.qubitVariable()
-                self.state = 223
+                self.state = 217
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 224
+            self.state = 218
             self.match(QuilParser.COLON)
-            self.state = 225
+            self.state = 219
             self.match(QuilParser.NEWLINE)
-            self.state = 226
+            self.state = 220
             self.circuit()
         except RecognitionException as re:
             localctx.exception = re
@@ -1386,7 +1370,7 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 26, self.RULE_qubitVariable)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 228
+            self.state = 222
             self.match(QuilParser.IDENTIFIER)
         except RecognitionException as re:
             localctx.exception = re
@@ -1429,17 +1413,17 @@ class QuilParser ( Parser ):
         localctx = QuilParser.CircuitQubitContext(self, self._ctx, self.state)
         self.enterRule(localctx, 28, self.RULE_circuitQubit)
         try:
-            self.state = 232
+            self.state = 226
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [QuilParser.UNSIGNED_INT]:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 230
+                self.state = 224
                 self.qubit()
                 pass
             elif token in [QuilParser.IDENTIFIER]:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 231
+                self.state = 225
                 self.qubitVariable()
                 pass
             else:
@@ -1510,39 +1494,39 @@ class QuilParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 234
+            self.state = 228
             self.name()
-            self.state = 246
+            self.state = 240
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==QuilParser.LPAREN:
-                self.state = 235
+                self.state = 229
                 self.match(QuilParser.LPAREN)
-                self.state = 236
+                self.state = 230
                 self.param()
-                self.state = 241
+                self.state = 235
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while _la==QuilParser.COMMA:
-                    self.state = 237
+                    self.state = 231
                     self.match(QuilParser.COMMA)
-                    self.state = 238
+                    self.state = 232
                     self.param()
-                    self.state = 243
+                    self.state = 237
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
-                self.state = 244
+                self.state = 238
                 self.match(QuilParser.RPAREN)
 
 
-            self.state = 249 
+            self.state = 243 
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while True:
-                self.state = 248
+                self.state = 242
                 self.circuitQubit()
-                self.state = 251 
+                self.state = 245 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if not (_la==QuilParser.IDENTIFIER or _la==QuilParser.UNSIGNED_INT):
@@ -1589,18 +1573,18 @@ class QuilParser ( Parser ):
         localctx = QuilParser.CircuitInstrContext(self, self._ctx, self.state)
         self.enterRule(localctx, 32, self.RULE_circuitInstr)
         try:
-            self.state = 255
+            self.state = 249
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,21,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,20,self._ctx)
             if la_ == 1:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 253
+                self.state = 247
                 self.circuitGate()
                 pass
 
             elif la_ == 2:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 254
+                self.state = 248
                 self.instr()
                 pass
 
@@ -1658,24 +1642,24 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 34, self.RULE_circuit)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 263
+            self.state = 257
             self._errHandler.sync(self)
-            _alt = self._interp.adaptivePredict(self._input,22,self._ctx)
+            _alt = self._interp.adaptivePredict(self._input,21,self._ctx)
             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                 if _alt==1:
-                    self.state = 257
+                    self.state = 251
                     self.match(QuilParser.TAB)
-                    self.state = 258
+                    self.state = 252
                     self.circuitInstr()
-                    self.state = 259
+                    self.state = 253
                     self.match(QuilParser.NEWLINE) 
-                self.state = 265
+                self.state = 259
                 self._errHandler.sync(self)
-                _alt = self._interp.adaptivePredict(self._input,22,self._ctx)
+                _alt = self._interp.adaptivePredict(self._input,21,self._ctx)
 
-            self.state = 266
+            self.state = 260
             self.match(QuilParser.TAB)
-            self.state = 267
+            self.state = 261
             self.circuitInstr()
         except RecognitionException as re:
             localctx.exception = re
@@ -1723,15 +1707,15 @@ class QuilParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 269
+            self.state = 263
             self.match(QuilParser.MEASURE)
-            self.state = 270
+            self.state = 264
             self.qubit()
-            self.state = 272
+            self.state = 266
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==QuilParser.LBRACKET:
-                self.state = 271
+                self.state = 265
                 self.addr()
 
 
@@ -1779,11 +1763,11 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 38, self.RULE_addr)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 274
+            self.state = 268
             self.match(QuilParser.LBRACKET)
-            self.state = 275
+            self.state = 269
             self.classicalBit()
-            self.state = 276
+            self.state = 270
             self.match(QuilParser.RBRACKET)
         except RecognitionException as re:
             localctx.exception = re
@@ -1826,13 +1810,13 @@ class QuilParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 279 
+            self.state = 273 
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while True:
-                self.state = 278
+                self.state = 272
                 self.match(QuilParser.UNSIGNED_INT)
-                self.state = 281 
+                self.state = 275 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if not (_la==QuilParser.UNSIGNED_INT):
@@ -1879,9 +1863,9 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 42, self.RULE_defLabel)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 283
+            self.state = 277
             self.match(QuilParser.LABEL)
-            self.state = 284
+            self.state = 278
             self.label()
         except RecognitionException as re:
             localctx.exception = re
@@ -1923,9 +1907,9 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 44, self.RULE_label)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 286
+            self.state = 280
             self.match(QuilParser.AT)
-            self.state = 287
+            self.state = 281
             self.match(QuilParser.IDENTIFIER)
         except RecognitionException as re:
             localctx.exception = re
@@ -1964,7 +1948,7 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 46, self.RULE_halt)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 289
+            self.state = 283
             self.match(QuilParser.HALT)
         except RecognitionException as re:
             localctx.exception = re
@@ -2007,9 +1991,9 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 48, self.RULE_jump)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 291
+            self.state = 285
             self.match(QuilParser.JUMP)
-            self.state = 292
+            self.state = 286
             self.label()
         except RecognitionException as re:
             localctx.exception = re
@@ -2056,11 +2040,11 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 50, self.RULE_jumpWhen)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 294
+            self.state = 288
             self.match(QuilParser.JUMPWHEN)
-            self.state = 295
+            self.state = 289
             self.label()
-            self.state = 296
+            self.state = 290
             self.addr()
         except RecognitionException as re:
             localctx.exception = re
@@ -2107,11 +2091,11 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 52, self.RULE_jumpUnless)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 298
+            self.state = 292
             self.match(QuilParser.JUMPUNLESS)
-            self.state = 299
+            self.state = 293
             self.label()
-            self.state = 300
+            self.state = 294
             self.addr()
         except RecognitionException as re:
             localctx.exception = re
@@ -2150,7 +2134,7 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 54, self.RULE_resetState)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 302
+            self.state = 296
             self.match(QuilParser.RESET)
         except RecognitionException as re:
             localctx.exception = re
@@ -2189,7 +2173,7 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 56, self.RULE_wait)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 304
+            self.state = 298
             self.match(QuilParser.WAIT)
         except RecognitionException as re:
             localctx.exception = re
@@ -2239,14 +2223,14 @@ class QuilParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 306
+            self.state = 300
             _la = self._input.LA(1)
             if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << QuilParser.FALSE) | (1 << QuilParser.TRUE) | (1 << QuilParser.NOT))) != 0)):
                 self._errHandler.recoverInline(self)
             else:
                 self._errHandler.reportMatch(self)
                 self.consume()
-            self.state = 307
+            self.state = 301
             self.addr()
         except RecognitionException as re:
             localctx.exception = re
@@ -2302,16 +2286,16 @@ class QuilParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 309
+            self.state = 303
             _la = self._input.LA(1)
             if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << QuilParser.AND) | (1 << QuilParser.OR) | (1 << QuilParser.MOVE) | (1 << QuilParser.EXCHANGE))) != 0)):
                 self._errHandler.recoverInline(self)
             else:
                 self._errHandler.reportMatch(self)
                 self.consume()
-            self.state = 310
+            self.state = 304
             self.addr()
-            self.state = 311
+            self.state = 305
             self.addr()
         except RecognitionException as re:
             localctx.exception = re
@@ -2350,7 +2334,7 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 62, self.RULE_nop)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 313
+            self.state = 307
             self.match(QuilParser.NOP)
         except RecognitionException as re:
             localctx.exception = re
@@ -2392,9 +2376,9 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 64, self.RULE_include)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 315
+            self.state = 309
             self.match(QuilParser.INCLUDE)
-            self.state = 316
+            self.state = 310
             self.match(QuilParser.STRING)
         except RecognitionException as re:
             localctx.exception = re
@@ -2447,25 +2431,25 @@ class QuilParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 318
+            self.state = 312
             self.match(QuilParser.PRAGMA)
-            self.state = 319
+            self.state = 313
             self.match(QuilParser.IDENTIFIER)
-            self.state = 323
+            self.state = 317
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==QuilParser.IDENTIFIER or _la==QuilParser.UNSIGNED_INT:
-                self.state = 320
+                self.state = 314
                 self.pragma_name()
-                self.state = 325
+                self.state = 319
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 327
+            self.state = 321
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==QuilParser.STRING:
-                self.state = 326
+                self.state = 320
                 self.match(QuilParser.STRING)
 
 
@@ -2510,7 +2494,7 @@ class QuilParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 329
+            self.state = 323
             _la = self._input.LA(1)
             if not(_la==QuilParser.IDENTIFIER or _la==QuilParser.UNSIGNED_INT):
                 self._errHandler.recoverInline(self)
@@ -2714,7 +2698,7 @@ class QuilParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 343
+            self.state = 337
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [QuilParser.LPAREN]:
@@ -2722,108 +2706,108 @@ class QuilParser ( Parser ):
                 self._ctx = localctx
                 _prevctx = localctx
 
-                self.state = 332
+                self.state = 326
                 self.match(QuilParser.LPAREN)
-                self.state = 333
+                self.state = 327
                 self.expression(0)
-                self.state = 334
+                self.state = 328
                 self.match(QuilParser.RPAREN)
                 pass
             elif token in [QuilParser.SIN, QuilParser.COS, QuilParser.SQRT, QuilParser.EXP, QuilParser.CIS]:
                 localctx = QuilParser.FunctionExpContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 336
+                self.state = 330
                 self.function()
-                self.state = 337
+                self.state = 331
                 self.match(QuilParser.LPAREN)
-                self.state = 338
+                self.state = 332
                 self.expression(0)
-                self.state = 339
+                self.state = 333
                 self.match(QuilParser.RPAREN)
                 pass
-            elif token in [QuilParser.I, QuilParser.PLUS, QuilParser.MINUS, QuilParser.UNSIGNED_INT, QuilParser.UNSIGNED_FLOAT]:
+            elif token in [QuilParser.PI, QuilParser.I, QuilParser.PLUS, QuilParser.MINUS, QuilParser.UNSIGNED_INT, QuilParser.UNSIGNED_FLOAT]:
                 localctx = QuilParser.NumberExpContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 341
+                self.state = 335
                 self.number()
                 pass
             elif token in [QuilParser.PERCENTAGE]:
                 localctx = QuilParser.VariableExpContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 342
+                self.state = 336
                 self.variable()
                 pass
             else:
                 raise NoViableAltException(self)
 
             self._ctx.stop = self._input.LT(-1)
-            self.state = 356
+            self.state = 350
             self._errHandler.sync(self)
-            _alt = self._interp.adaptivePredict(self._input,29,self._ctx)
+            _alt = self._interp.adaptivePredict(self._input,28,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 = 354
+                    self.state = 348
                     self._errHandler.sync(self)
-                    la_ = self._interp.adaptivePredict(self._input,28,self._ctx)
+                    la_ = self._interp.adaptivePredict(self._input,27,self._ctx)
                     if la_ == 1:
                         localctx = QuilParser.PowerExpContext(self, QuilParser.ExpressionContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
-                        self.state = 345
+                        self.state = 339
                         if not self.precpred(self._ctx, 6):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
-                        self.state = 346
+                        self.state = 340
                         self.match(QuilParser.POWER)
-                        self.state = 347
+                        self.state = 341
                         self.expression(6)
                         pass
 
                     elif la_ == 2:
                         localctx = QuilParser.MulDivExpContext(self, QuilParser.ExpressionContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
-                        self.state = 348
+                        self.state = 342
                         if not self.precpred(self._ctx, 5):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
-                        self.state = 349
+                        self.state = 343
                         _la = self._input.LA(1)
                         if not(_la==QuilParser.TIMES or _la==QuilParser.DIVIDE):
                             self._errHandler.recoverInline(self)
                         else:
                             self._errHandler.reportMatch(self)
                             self.consume()
-                        self.state = 350
+                        self.state = 344
                         self.expression(6)
                         pass
 
                     elif la_ == 3:
                         localctx = QuilParser.AddSubExpContext(self, QuilParser.ExpressionContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
-                        self.state = 351
+                        self.state = 345
                         if not self.precpred(self._ctx, 4):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
-                        self.state = 352
+                        self.state = 346
                         _la = self._input.LA(1)
                         if not(_la==QuilParser.PLUS or _la==QuilParser.MINUS):
                             self._errHandler.recoverInline(self)
                         else:
                             self._errHandler.reportMatch(self)
                             self.consume()
-                        self.state = 353
+                        self.state = 347
                         self.expression(5)
                         pass
 
              
-                self.state = 358
+                self.state = 352
                 self._errHandler.sync(self)
-                _alt = self._interp.adaptivePredict(self._input,29,self._ctx)
+                _alt = self._interp.adaptivePredict(self._input,28,self._ctx)
 
         except RecognitionException as re:
             localctx.exception = re
@@ -2875,7 +2859,7 @@ class QuilParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 359
+            self.state = 353
             _la = self._input.LA(1)
             if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << QuilParser.SIN) | (1 << QuilParser.COS) | (1 << QuilParser.SQRT) | (1 << QuilParser.EXP) | (1 << QuilParser.CIS))) != 0)):
                 self._errHandler.recoverInline(self)
@@ -2907,6 +2891,9 @@ class QuilParser ( Parser ):
         def I(self):
             return self.getToken(QuilParser.I, 0)
 
+        def PI(self):
+            return self.getToken(QuilParser.PI, 0)
+
         def getRuleIndex(self):
             return QuilParser.RULE_number
 
@@ -2926,27 +2913,33 @@ class QuilParser ( Parser ):
         localctx = QuilParser.NumberContext(self, self._ctx, self.state)
         self.enterRule(localctx, 74, self.RULE_number)
         try:
-            self.state = 364
+            self.state = 359
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,30,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,29,self._ctx)
             if la_ == 1:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 361
+                self.state = 355
                 self.realN()
                 pass
 
             elif la_ == 2:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 362
+                self.state = 356
                 self.imaginaryN()
                 pass
 
             elif la_ == 3:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 363
+                self.state = 357
                 self.match(QuilParser.I)
                 pass
 
+            elif la_ == 4:
+                self.enterOuterAlt(localctx, 4)
+                self.state = 358
+                self.match(QuilParser.PI)
+                pass
+
 
         except RecognitionException as re:
             localctx.exception = re
@@ -2989,9 +2982,9 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 76, self.RULE_imaginaryN)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 366
+            self.state = 361
             self.realN()
-            self.state = 367
+            self.state = 362
             self.match(QuilParser.I)
         except RecognitionException as re:
             localctx.exception = re
@@ -3034,18 +3027,18 @@ class QuilParser ( Parser ):
         localctx = QuilParser.RealNContext(self, self._ctx, self.state)
         self.enterRule(localctx, 78, self.RULE_realN)
         try:
-            self.state = 371
+            self.state = 366
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,31,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,30,self._ctx)
             if la_ == 1:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 369
+                self.state = 364
                 self.floatN()
                 pass
 
             elif la_ == 2:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 370
+                self.state = 365
                 self.intN()
                 pass
 
@@ -3092,15 +3085,15 @@ class QuilParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 374
+            self.state = 369
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==QuilParser.PLUS or _la==QuilParser.MINUS:
-                self.state = 373
+                self.state = 368
                 self.sign()
 
 
-            self.state = 376
+            self.state = 371
             self.match(QuilParser.UNSIGNED_FLOAT)
         except RecognitionException as re:
             localctx.exception = re
@@ -3144,15 +3137,15 @@ class QuilParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 379
+            self.state = 374
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==QuilParser.PLUS or _la==QuilParser.MINUS:
-                self.state = 378
+                self.state = 373
                 self.sign()
 
 
-            self.state = 381
+            self.state = 376
             self.match(QuilParser.UNSIGNED_INT)
         except RecognitionException as re:
             localctx.exception = re
@@ -3195,7 +3188,7 @@ class QuilParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 383
+            self.state = 378
             _la = self._input.LA(1)
             if not(_la==QuilParser.PLUS or _la==QuilParser.MINUS):
                 self._errHandler.recoverInline(self)
diff --git a/pyquil/_parser/gen3/QuilParser.py b/pyquil/_parser/gen3/QuilParser.py
index f17b05e..0dfa241 100644
--- a/pyquil/_parser/gen3/QuilParser.py
+++ b/pyquil/_parser/gen3/QuilParser.py
@@ -8,175 +8,172 @@ import sys
 def serializedATN():
     with StringIO() as buf:
         buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\66")
-        buf.write("\u0184\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
+        buf.write("\u017f\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
         buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
         buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
         buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
         buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
         buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t")
         buf.write("&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\3\2\3\2\6\2[\n")
-        buf.write("\2\r\2\16\2\\\3\2\7\2`\n\2\f\2\16\2c\13\2\3\2\7\2f\n\2")
-        buf.write("\f\2\16\2i\13\2\3\2\3\2\3\3\3\3\3\3\5\3p\n\3\3\4\3\4\3")
-        buf.write("\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\5\4\u0080")
-        buf.write("\n\4\3\5\3\5\3\5\3\5\3\5\7\5\u0087\n\5\f\5\16\5\u008a")
-        buf.write("\13\5\3\5\3\5\5\5\u008e\n\5\3\5\6\5\u0091\n\5\r\5\16\5")
-        buf.write("\u0092\3\6\3\6\3\7\3\7\3\b\3\b\5\b\u009b\n\b\3\t\3\t\3")
-        buf.write("\t\3\t\5\t\u00a1\n\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\n\7")
-        buf.write("\n\u00ab\n\n\f\n\16\n\u00ae\13\n\3\n\3\n\5\n\u00b2\n\n")
-        buf.write("\3\n\3\n\3\n\3\n\3\13\3\13\3\13\3\f\3\f\3\f\7\f\u00be")
-        buf.write("\n\f\f\f\16\f\u00c1\13\f\3\f\3\f\3\r\3\r\3\r\3\r\7\r\u00c9")
-        buf.write("\n\r\f\r\16\r\u00cc\13\r\3\16\3\16\3\16\3\16\3\16\3\16")
-        buf.write("\7\16\u00d4\n\16\f\16\16\16\u00d7\13\16\3\16\3\16\5\16")
-        buf.write("\u00db\n\16\3\16\7\16\u00de\n\16\f\16\16\16\u00e1\13\16")
-        buf.write("\3\16\3\16\3\16\3\16\3\17\3\17\3\20\3\20\5\20\u00eb\n")
-        buf.write("\20\3\21\3\21\3\21\3\21\3\21\7\21\u00f2\n\21\f\21\16\21")
-        buf.write("\u00f5\13\21\3\21\3\21\5\21\u00f9\n\21\3\21\6\21\u00fc")
-        buf.write("\n\21\r\21\16\21\u00fd\3\22\3\22\5\22\u0102\n\22\3\23")
-        buf.write("\3\23\3\23\3\23\7\23\u0108\n\23\f\23\16\23\u010b\13\23")
-        buf.write("\3\23\3\23\3\23\3\24\3\24\3\24\5\24\u0113\n\24\3\25\3")
-        buf.write("\25\3\25\3\25\3\26\6\26\u011a\n\26\r\26\16\26\u011b\3")
-        buf.write("\27\3\27\3\27\3\30\3\30\3\30\3\31\3\31\3\32\3\32\3\32")
-        buf.write("\3\33\3\33\3\33\3\33\3\34\3\34\3\34\3\34\3\35\3\35\3\36")
-        buf.write("\3\36\3\37\3\37\3\37\3 \3 \3 \3 \3!\3!\3\"\3\"\3\"\3#")
-        buf.write("\3#\3#\7#\u0144\n#\f#\16#\u0147\13#\3#\5#\u014a\n#\3$")
-        buf.write("\3$\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\3%\5%\u015a\n%\3")
-        buf.write("%\3%\3%\3%\3%\3%\3%\3%\3%\7%\u0165\n%\f%\16%\u0168\13")
-        buf.write("%\3&\3&\3\'\3\'\3\'\5\'\u016f\n\'\3(\3(\3(\3)\3)\5)\u0176")
-        buf.write("\n)\3*\5*\u0179\n*\3*\3*\3+\5+\u017e\n+\3+\3+\3,\3,\3")
-        buf.write(",\2\3H-\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*")
-        buf.write(",.\60\62\64\668:<>@BDFHJLNPRTV\2\b\3\2\20\22\3\2\23\26")
-        buf.write("\3\2#$\3\2 !\3\2\36\37\3\2\31\35\2\u018b\2X\3\2\2\2\4")
-        buf.write("o\3\2\2\2\6\177\3\2\2\2\b\u0081\3\2\2\2\n\u0094\3\2\2")
-        buf.write("\2\f\u0096\3\2\2\2\16\u009a\3\2\2\2\20\u009c\3\2\2\2\22")
-        buf.write("\u00a4\3\2\2\2\24\u00b7\3\2\2\2\26\u00bf\3\2\2\2\30\u00c4")
-        buf.write("\3\2\2\2\32\u00cd\3\2\2\2\34\u00e6\3\2\2\2\36\u00ea\3")
-        buf.write("\2\2\2 \u00ec\3\2\2\2\"\u0101\3\2\2\2$\u0109\3\2\2\2&")
-        buf.write("\u010f\3\2\2\2(\u0114\3\2\2\2*\u0119\3\2\2\2,\u011d\3")
-        buf.write("\2\2\2.\u0120\3\2\2\2\60\u0123\3\2\2\2\62\u0125\3\2\2")
-        buf.write("\2\64\u0128\3\2\2\2\66\u012c\3\2\2\28\u0130\3\2\2\2:\u0132")
-        buf.write("\3\2\2\2<\u0134\3\2\2\2>\u0137\3\2\2\2@\u013b\3\2\2\2")
-        buf.write("B\u013d\3\2\2\2D\u0140\3\2\2\2F\u014b\3\2\2\2H\u0159\3")
-        buf.write("\2\2\2J\u0169\3\2\2\2L\u016e\3\2\2\2N\u0170\3\2\2\2P\u0175")
-        buf.write("\3\2\2\2R\u0178\3\2\2\2T\u017d\3\2\2\2V\u0181\3\2\2\2")
-        buf.write("Xa\5\4\3\2Y[\7\63\2\2ZY\3\2\2\2[\\\3\2\2\2\\Z\3\2\2\2")
-        buf.write("\\]\3\2\2\2]^\3\2\2\2^`\5\4\3\2_Z\3\2\2\2`c\3\2\2\2a_")
-        buf.write("\3\2\2\2ab\3\2\2\2bg\3\2\2\2ca\3\2\2\2df\7\63\2\2ed\3")
-        buf.write("\2\2\2fi\3\2\2\2ge\3\2\2\2gh\3\2\2\2hj\3\2\2\2ig\3\2\2")
-        buf.write("\2jk\7\2\2\3k\3\3\2\2\2lp\5\22\n\2mp\5\32\16\2np\5\6\4")
-        buf.write("\2ol\3\2\2\2om\3\2\2\2on\3\2\2\2p\5\3\2\2\2q\u0080\5\b")
-        buf.write("\5\2r\u0080\5&\24\2s\u0080\5,\27\2t\u0080\5\60\31\2u\u0080")
-        buf.write("\5\62\32\2v\u0080\5\64\33\2w\u0080\5\66\34\2x\u0080\5")
-        buf.write("8\35\2y\u0080\5:\36\2z\u0080\5<\37\2{\u0080\5> \2|\u0080")
-        buf.write("\5@!\2}\u0080\5B\"\2~\u0080\5D#\2\177q\3\2\2\2\177r\3")
-        buf.write("\2\2\2\177s\3\2\2\2\177t\3\2\2\2\177u\3\2\2\2\177v\3\2")
-        buf.write("\2\2\177w\3\2\2\2\177x\3\2\2\2\177y\3\2\2\2\177z\3\2\2")
-        buf.write("\2\177{\3\2\2\2\177|\3\2\2\2\177}\3\2\2\2\177~\3\2\2\2")
-        buf.write("\u0080\7\3\2\2\2\u0081\u008d\5\n\6\2\u0082\u0083\7)\2")
-        buf.write("\2\u0083\u0088\5\16\b\2\u0084\u0085\7(\2\2\u0085\u0087")
-        buf.write("\5\16\b\2\u0086\u0084\3\2\2\2\u0087\u008a\3\2\2\2\u0088")
-        buf.write("\u0086\3\2\2\2\u0088\u0089\3\2\2\2\u0089\u008b\3\2\2\2")
-        buf.write("\u008a\u0088\3\2\2\2\u008b\u008c\7*\2\2\u008c\u008e\3")
-        buf.write("\2\2\2\u008d\u0082\3\2\2\2\u008d\u008e\3\2\2\2\u008e\u0090")
-        buf.write("\3\2\2\2\u008f\u0091\5\f\7\2\u0090\u008f\3\2\2\2\u0091")
-        buf.write("\u0092\3\2\2\2\u0092\u0090\3\2\2\2\u0092\u0093\3\2\2\2")
-        buf.write("\u0093\t\3\2\2\2\u0094\u0095\7#\2\2\u0095\13\3\2\2\2\u0096")
-        buf.write("\u0097\7$\2\2\u0097\r\3\2\2\2\u0098\u009b\5\20\t\2\u0099")
-        buf.write("\u009b\5H%\2\u009a\u0098\3\2\2\2\u009a\u0099\3\2\2\2\u009b")
-        buf.write("\17\3\2\2\2\u009c\u009d\7+\2\2\u009d\u00a0\7$\2\2\u009e")
-        buf.write("\u009f\7\37\2\2\u009f\u00a1\7$\2\2\u00a0\u009e\3\2\2\2")
-        buf.write("\u00a0\u00a1\3\2\2\2\u00a1\u00a2\3\2\2\2\u00a2\u00a3\7")
-        buf.write(",\2\2\u00a3\21\3\2\2\2\u00a4\u00a5\7\3\2\2\u00a5\u00b1")
-        buf.write("\5\n\6\2\u00a6\u00a7\7)\2\2\u00a7\u00ac\5\24\13\2\u00a8")
-        buf.write("\u00a9\7(\2\2\u00a9\u00ab\5\24\13\2\u00aa\u00a8\3\2\2")
-        buf.write("\2\u00ab\u00ae\3\2\2\2\u00ac\u00aa\3\2\2\2\u00ac\u00ad")
-        buf.write("\3\2\2\2\u00ad\u00af\3\2\2\2\u00ae\u00ac\3\2\2\2\u00af")
-        buf.write("\u00b0\7*\2\2\u00b0\u00b2\3\2\2\2\u00b1\u00a6\3\2\2\2")
-        buf.write("\u00b1\u00b2\3\2\2\2\u00b2\u00b3\3\2\2\2\u00b3\u00b4\7")
-        buf.write("-\2\2\u00b4\u00b5\7\63\2\2\u00b5\u00b6\5\26\f\2\u00b6")
-        buf.write("\23\3\2\2\2\u00b7\u00b8\7.\2\2\u00b8\u00b9\7#\2\2\u00b9")
-        buf.write("\25\3\2\2\2\u00ba\u00bb\5\30\r\2\u00bb\u00bc\7\63\2\2")
-        buf.write("\u00bc\u00be\3\2\2\2\u00bd\u00ba\3\2\2\2\u00be\u00c1\3")
-        buf.write("\2\2\2\u00bf\u00bd\3\2\2\2\u00bf\u00c0\3\2\2\2\u00c0\u00c2")
-        buf.write("\3\2\2\2\u00c1\u00bf\3\2\2\2\u00c2\u00c3\5\30\r\2\u00c3")
-        buf.write("\27\3\2\2\2\u00c4\u00c5\7\62\2\2\u00c5\u00ca\5H%\2\u00c6")
-        buf.write("\u00c7\7(\2\2\u00c7\u00c9\5H%\2\u00c8\u00c6\3\2\2\2\u00c9")
-        buf.write("\u00cc\3\2\2\2\u00ca\u00c8\3\2\2\2\u00ca\u00cb\3\2\2\2")
-        buf.write("\u00cb\31\3\2\2\2\u00cc\u00ca\3\2\2\2\u00cd\u00ce\7\4")
-        buf.write("\2\2\u00ce\u00da\5\n\6\2\u00cf\u00d0\7)\2\2\u00d0\u00d5")
-        buf.write("\5\24\13\2\u00d1\u00d2\7(\2\2\u00d2\u00d4\5\24\13\2\u00d3")
-        buf.write("\u00d1\3\2\2\2\u00d4\u00d7\3\2\2\2\u00d5\u00d3\3\2\2\2")
-        buf.write("\u00d5\u00d6\3\2\2\2\u00d6\u00d8\3\2\2\2\u00d7\u00d5\3")
-        buf.write("\2\2\2\u00d8\u00d9\7*\2\2\u00d9\u00db\3\2\2\2\u00da\u00cf")
-        buf.write("\3\2\2\2\u00da\u00db\3\2\2\2\u00db\u00df\3\2\2\2\u00dc")
-        buf.write("\u00de\5\34\17\2\u00dd\u00dc\3\2\2\2\u00de\u00e1\3\2\2")
-        buf.write("\2\u00df\u00dd\3\2\2\2\u00df\u00e0\3\2\2\2\u00e0\u00e2")
-        buf.write("\3\2\2\2\u00e1\u00df\3\2\2\2\u00e2\u00e3\7-\2\2\u00e3")
-        buf.write("\u00e4\7\63\2\2\u00e4\u00e5\5$\23\2\u00e5\33\3\2\2\2\u00e6")
-        buf.write("\u00e7\7#\2\2\u00e7\35\3\2\2\2\u00e8\u00eb\5\f\7\2\u00e9")
-        buf.write("\u00eb\5\34\17\2\u00ea\u00e8\3\2\2\2\u00ea\u00e9\3\2\2")
-        buf.write("\2\u00eb\37\3\2\2\2\u00ec\u00f8\5\n\6\2\u00ed\u00ee\7")
-        buf.write(")\2\2\u00ee\u00f3\5\16\b\2\u00ef\u00f0\7(\2\2\u00f0\u00f2")
-        buf.write("\5\16\b\2\u00f1\u00ef\3\2\2\2\u00f2\u00f5\3\2\2\2\u00f3")
-        buf.write("\u00f1\3\2\2\2\u00f3\u00f4\3\2\2\2\u00f4\u00f6\3\2\2\2")
-        buf.write("\u00f5\u00f3\3\2\2\2\u00f6\u00f7\7*\2\2\u00f7\u00f9\3")
-        buf.write("\2\2\2\u00f8\u00ed\3\2\2\2\u00f8\u00f9\3\2\2\2\u00f9\u00fb")
-        buf.write("\3\2\2\2\u00fa\u00fc\5\36\20\2\u00fb\u00fa\3\2\2\2\u00fc")
-        buf.write("\u00fd\3\2\2\2\u00fd\u00fb\3\2\2\2\u00fd\u00fe\3\2\2\2")
-        buf.write("\u00fe!\3\2\2\2\u00ff\u0102\5 \21\2\u0100\u0102\5\6\4")
-        buf.write("\2\u0101\u00ff\3\2\2\2\u0101\u0100\3\2\2\2\u0102#\3\2")
-        buf.write("\2\2\u0103\u0104\7\62\2\2\u0104\u0105\5\"\22\2\u0105\u0106")
-        buf.write("\7\63\2\2\u0106\u0108\3\2\2\2\u0107\u0103\3\2\2\2\u0108")
-        buf.write("\u010b\3\2\2\2\u0109\u0107\3\2\2\2\u0109\u010a\3\2\2\2")
-        buf.write("\u010a\u010c\3\2\2\2\u010b\u0109\3\2\2\2\u010c\u010d\7")
-        buf.write("\62\2\2\u010d\u010e\5\"\22\2\u010e%\3\2\2\2\u010f\u0110")
-        buf.write("\7\5\2\2\u0110\u0112\5\f\7\2\u0111\u0113\5(\25\2\u0112")
-        buf.write("\u0111\3\2\2\2\u0112\u0113\3\2\2\2\u0113\'\3\2\2\2\u0114")
-        buf.write("\u0115\7+\2\2\u0115\u0116\5*\26\2\u0116\u0117\7,\2\2\u0117")
-        buf.write(")\3\2\2\2\u0118\u011a\7$\2\2\u0119\u0118\3\2\2\2\u011a")
-        buf.write("\u011b\3\2\2\2\u011b\u0119\3\2\2\2\u011b\u011c\3\2\2\2")
-        buf.write("\u011c+\3\2\2\2\u011d\u011e\7\6\2\2\u011e\u011f\5.\30")
-        buf.write("\2\u011f-\3\2\2\2\u0120\u0121\7/\2\2\u0121\u0122\7#\2")
-        buf.write("\2\u0122/\3\2\2\2\u0123\u0124\7\7\2\2\u0124\61\3\2\2\2")
-        buf.write("\u0125\u0126\7\b\2\2\u0126\u0127\5.\30\2\u0127\63\3\2")
-        buf.write("\2\2\u0128\u0129\7\t\2\2\u0129\u012a\5.\30\2\u012a\u012b")
-        buf.write("\5(\25\2\u012b\65\3\2\2\2\u012c\u012d\7\n\2\2\u012d\u012e")
-        buf.write("\5.\30\2\u012e\u012f\5(\25\2\u012f\67\3\2\2\2\u0130\u0131")
-        buf.write("\7\13\2\2\u01319\3\2\2\2\u0132\u0133\7\f\2\2\u0133;\3")
-        buf.write("\2\2\2\u0134\u0135\t\2\2\2\u0135\u0136\5(\25\2\u0136=")
-        buf.write("\3\2\2\2\u0137\u0138\t\3\2\2\u0138\u0139\5(\25\2\u0139")
-        buf.write("\u013a\5(\25\2\u013a?\3\2\2\2\u013b\u013c\7\r\2\2\u013c")
-        buf.write("A\3\2\2\2\u013d\u013e\7\16\2\2\u013e\u013f\7&\2\2\u013f")
-        buf.write("C\3\2\2\2\u0140\u0141\7\17\2\2\u0141\u0145\7#\2\2\u0142")
-        buf.write("\u0144\5F$\2\u0143\u0142\3\2\2\2\u0144\u0147\3\2\2\2\u0145")
-        buf.write("\u0143\3\2\2\2\u0145\u0146\3\2\2\2\u0146\u0149\3\2\2\2")
-        buf.write("\u0147\u0145\3\2\2\2\u0148\u014a\7&\2\2\u0149\u0148\3")
-        buf.write("\2\2\2\u0149\u014a\3\2\2\2\u014aE\3\2\2\2\u014b\u014c")
-        buf.write("\t\4\2\2\u014cG\3\2\2\2\u014d\u014e\b%\1\2\u014e\u014f")
-        buf.write("\7)\2\2\u014f\u0150\5H%\2\u0150\u0151\7*\2\2\u0151\u015a")
-        buf.write("\3\2\2\2\u0152\u0153\5J&\2\u0153\u0154\7)\2\2\u0154\u0155")
-        buf.write("\5H%\2\u0155\u0156\7*\2\2\u0156\u015a\3\2\2\2\u0157\u015a")
-        buf.write("\5L\'\2\u0158\u015a\5\24\13\2\u0159\u014d\3\2\2\2\u0159")
-        buf.write("\u0152\3\2\2\2\u0159\u0157\3\2\2\2\u0159\u0158\3\2\2\2")
-        buf.write("\u015a\u0166\3\2\2\2\u015b\u015c\f\b\2\2\u015c\u015d\7")
-        buf.write("\"\2\2\u015d\u0165\5H%\b\u015e\u015f\f\7\2\2\u015f\u0160")
-        buf.write("\t\5\2\2\u0160\u0165\5H%\b\u0161\u0162\f\6\2\2\u0162\u0163")
-        buf.write("\t\6\2\2\u0163\u0165\5H%\7\u0164\u015b\3\2\2\2\u0164\u015e")
-        buf.write("\3\2\2\2\u0164\u0161\3\2\2\2\u0165\u0168\3\2\2\2\u0166")
-        buf.write("\u0164\3\2\2\2\u0166\u0167\3\2\2\2\u0167I\3\2\2\2\u0168")
-        buf.write("\u0166\3\2\2\2\u0169\u016a\t\7\2\2\u016aK\3\2\2\2\u016b")
-        buf.write("\u016f\5P)\2\u016c\u016f\5N(\2\u016d\u016f\7\30\2\2\u016e")
-        buf.write("\u016b\3\2\2\2\u016e\u016c\3\2\2\2\u016e\u016d\3\2\2\2")
-        buf.write("\u016fM\3\2\2\2\u0170\u0171\5P)\2\u0171\u0172\7\30\2\2")
-        buf.write("\u0172O\3\2\2\2\u0173\u0176\5R*\2\u0174\u0176\5T+\2\u0175")
-        buf.write("\u0173\3\2\2\2\u0175\u0174\3\2\2\2\u0176Q\3\2\2\2\u0177")
-        buf.write("\u0179\5V,\2\u0178\u0177\3\2\2\2\u0178\u0179\3\2\2\2\u0179")
-        buf.write("\u017a\3\2\2\2\u017a\u017b\7%\2\2\u017bS\3\2\2\2\u017c")
-        buf.write("\u017e\5V,\2\u017d\u017c\3\2\2\2\u017d\u017e\3\2\2\2\u017e")
-        buf.write("\u017f\3\2\2\2\u017f\u0180\7$\2\2\u0180U\3\2\2\2\u0181")
-        buf.write("\u0182\t\6\2\2\u0182W\3\2\2\2$\\ago\177\u0088\u008d\u0092")
-        buf.write("\u009a\u00a0\u00ac\u00b1\u00bf\u00ca\u00d5\u00da\u00df")
-        buf.write("\u00ea\u00f3\u00f8\u00fd\u0101\u0109\u0112\u011b\u0145")
-        buf.write("\u0149\u0159\u0164\u0166\u016e\u0175\u0178\u017d")
+        buf.write("\2\r\2\16\2\\\3\2\7\2`\n\2\f\2\16\2c\13\2\3\2\3\2\3\3")
+        buf.write("\3\3\3\3\5\3j\n\3\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4")
+        buf.write("\3\4\3\4\3\4\3\4\3\4\5\4z\n\4\3\5\3\5\3\5\3\5\3\5\7\5")
+        buf.write("\u0081\n\5\f\5\16\5\u0084\13\5\3\5\3\5\5\5\u0088\n\5\3")
+        buf.write("\5\6\5\u008b\n\5\r\5\16\5\u008c\3\6\3\6\3\7\3\7\3\b\3")
+        buf.write("\b\5\b\u0095\n\b\3\t\3\t\3\t\3\t\5\t\u009b\n\t\3\t\3\t")
+        buf.write("\3\n\3\n\3\n\3\n\3\n\3\n\7\n\u00a5\n\n\f\n\16\n\u00a8")
+        buf.write("\13\n\3\n\3\n\5\n\u00ac\n\n\3\n\3\n\3\n\3\n\3\13\3\13")
+        buf.write("\3\13\3\f\3\f\3\f\7\f\u00b8\n\f\f\f\16\f\u00bb\13\f\3")
+        buf.write("\f\3\f\3\r\3\r\3\r\3\r\7\r\u00c3\n\r\f\r\16\r\u00c6\13")
+        buf.write("\r\3\16\3\16\3\16\3\16\3\16\3\16\7\16\u00ce\n\16\f\16")
+        buf.write("\16\16\u00d1\13\16\3\16\3\16\5\16\u00d5\n\16\3\16\7\16")
+        buf.write("\u00d8\n\16\f\16\16\16\u00db\13\16\3\16\3\16\3\16\3\16")
+        buf.write("\3\17\3\17\3\20\3\20\5\20\u00e5\n\20\3\21\3\21\3\21\3")
+        buf.write("\21\3\21\7\21\u00ec\n\21\f\21\16\21\u00ef\13\21\3\21\3")
+        buf.write("\21\5\21\u00f3\n\21\3\21\6\21\u00f6\n\21\r\21\16\21\u00f7")
+        buf.write("\3\22\3\22\5\22\u00fc\n\22\3\23\3\23\3\23\3\23\7\23\u0102")
+        buf.write("\n\23\f\23\16\23\u0105\13\23\3\23\3\23\3\23\3\24\3\24")
+        buf.write("\3\24\5\24\u010d\n\24\3\25\3\25\3\25\3\25\3\26\6\26\u0114")
+        buf.write("\n\26\r\26\16\26\u0115\3\27\3\27\3\27\3\30\3\30\3\30\3")
+        buf.write("\31\3\31\3\32\3\32\3\32\3\33\3\33\3\33\3\33\3\34\3\34")
+        buf.write("\3\34\3\34\3\35\3\35\3\36\3\36\3\37\3\37\3\37\3 \3 \3")
+        buf.write(" \3 \3!\3!\3\"\3\"\3\"\3#\3#\3#\7#\u013e\n#\f#\16#\u0141")
+        buf.write("\13#\3#\5#\u0144\n#\3$\3$\3%\3%\3%\3%\3%\3%\3%\3%\3%\3")
+        buf.write("%\3%\3%\5%\u0154\n%\3%\3%\3%\3%\3%\3%\3%\3%\3%\7%\u015f")
+        buf.write("\n%\f%\16%\u0162\13%\3&\3&\3\'\3\'\3\'\3\'\5\'\u016a\n")
+        buf.write("\'\3(\3(\3(\3)\3)\5)\u0171\n)\3*\5*\u0174\n*\3*\3*\3+")
+        buf.write("\5+\u0179\n+\3+\3+\3,\3,\3,\2\3H-\2\4\6\b\n\f\16\20\22")
+        buf.write("\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPR")
+        buf.write("TV\2\b\3\2\20\22\3\2\23\26\3\2#$\3\2 !\3\2\36\37\3\2\31")
+        buf.write("\35\2\u0186\2X\3\2\2\2\4i\3\2\2\2\6y\3\2\2\2\b{\3\2\2")
+        buf.write("\2\n\u008e\3\2\2\2\f\u0090\3\2\2\2\16\u0094\3\2\2\2\20")
+        buf.write("\u0096\3\2\2\2\22\u009e\3\2\2\2\24\u00b1\3\2\2\2\26\u00b9")
+        buf.write("\3\2\2\2\30\u00be\3\2\2\2\32\u00c7\3\2\2\2\34\u00e0\3")
+        buf.write("\2\2\2\36\u00e4\3\2\2\2 \u00e6\3\2\2\2\"\u00fb\3\2\2\2")
+        buf.write("$\u0103\3\2\2\2&\u0109\3\2\2\2(\u010e\3\2\2\2*\u0113\3")
+        buf.write("\2\2\2,\u0117\3\2\2\2.\u011a\3\2\2\2\60\u011d\3\2\2\2")
+        buf.write("\62\u011f\3\2\2\2\64\u0122\3\2\2\2\66\u0126\3\2\2\28\u012a")
+        buf.write("\3\2\2\2:\u012c\3\2\2\2<\u012e\3\2\2\2>\u0131\3\2\2\2")
+        buf.write("@\u0135\3\2\2\2B\u0137\3\2\2\2D\u013a\3\2\2\2F\u0145\3")
+        buf.write("\2\2\2H\u0153\3\2\2\2J\u0163\3\2\2\2L\u0169\3\2\2\2N\u016b")
+        buf.write("\3\2\2\2P\u0170\3\2\2\2R\u0173\3\2\2\2T\u0178\3\2\2\2")
+        buf.write("V\u017c\3\2\2\2Xa\5\4\3\2Y[\7\63\2\2ZY\3\2\2\2[\\\3\2")
+        buf.write("\2\2\\Z\3\2\2\2\\]\3\2\2\2]^\3\2\2\2^`\5\4\3\2_Z\3\2\2")
+        buf.write("\2`c\3\2\2\2a_\3\2\2\2ab\3\2\2\2bd\3\2\2\2ca\3\2\2\2d")
+        buf.write("e\7\2\2\3e\3\3\2\2\2fj\5\22\n\2gj\5\32\16\2hj\5\6\4\2")
+        buf.write("if\3\2\2\2ig\3\2\2\2ih\3\2\2\2j\5\3\2\2\2kz\5\b\5\2lz")
+        buf.write("\5&\24\2mz\5,\27\2nz\5\60\31\2oz\5\62\32\2pz\5\64\33\2")
+        buf.write("qz\5\66\34\2rz\58\35\2sz\5:\36\2tz\5<\37\2uz\5> \2vz\5")
+        buf.write("@!\2wz\5B\"\2xz\5D#\2yk\3\2\2\2yl\3\2\2\2ym\3\2\2\2yn")
+        buf.write("\3\2\2\2yo\3\2\2\2yp\3\2\2\2yq\3\2\2\2yr\3\2\2\2ys\3\2")
+        buf.write("\2\2yt\3\2\2\2yu\3\2\2\2yv\3\2\2\2yw\3\2\2\2yx\3\2\2\2")
+        buf.write("z\7\3\2\2\2{\u0087\5\n\6\2|}\7)\2\2}\u0082\5\16\b\2~\177")
+        buf.write("\7(\2\2\177\u0081\5\16\b\2\u0080~\3\2\2\2\u0081\u0084")
+        buf.write("\3\2\2\2\u0082\u0080\3\2\2\2\u0082\u0083\3\2\2\2\u0083")
+        buf.write("\u0085\3\2\2\2\u0084\u0082\3\2\2\2\u0085\u0086\7*\2\2")
+        buf.write("\u0086\u0088\3\2\2\2\u0087|\3\2\2\2\u0087\u0088\3\2\2")
+        buf.write("\2\u0088\u008a\3\2\2\2\u0089\u008b\5\f\7\2\u008a\u0089")
+        buf.write("\3\2\2\2\u008b\u008c\3\2\2\2\u008c\u008a\3\2\2\2\u008c")
+        buf.write("\u008d\3\2\2\2\u008d\t\3\2\2\2\u008e\u008f\7#\2\2\u008f")
+        buf.write("\13\3\2\2\2\u0090\u0091\7$\2\2\u0091\r\3\2\2\2\u0092\u0095")
+        buf.write("\5\20\t\2\u0093\u0095\5H%\2\u0094\u0092\3\2\2\2\u0094")
+        buf.write("\u0093\3\2\2\2\u0095\17\3\2\2\2\u0096\u0097\7+\2\2\u0097")
+        buf.write("\u009a\7$\2\2\u0098\u0099\7\37\2\2\u0099\u009b\7$\2\2")
+        buf.write("\u009a\u0098\3\2\2\2\u009a\u009b\3\2\2\2\u009b\u009c\3")
+        buf.write("\2\2\2\u009c\u009d\7,\2\2\u009d\21\3\2\2\2\u009e\u009f")
+        buf.write("\7\3\2\2\u009f\u00ab\5\n\6\2\u00a0\u00a1\7)\2\2\u00a1")
+        buf.write("\u00a6\5\24\13\2\u00a2\u00a3\7(\2\2\u00a3\u00a5\5\24\13")
+        buf.write("\2\u00a4\u00a2\3\2\2\2\u00a5\u00a8\3\2\2\2\u00a6\u00a4")
+        buf.write("\3\2\2\2\u00a6\u00a7\3\2\2\2\u00a7\u00a9\3\2\2\2\u00a8")
+        buf.write("\u00a6\3\2\2\2\u00a9\u00aa\7*\2\2\u00aa\u00ac\3\2\2\2")
+        buf.write("\u00ab\u00a0\3\2\2\2\u00ab\u00ac\3\2\2\2\u00ac\u00ad\3")
+        buf.write("\2\2\2\u00ad\u00ae\7-\2\2\u00ae\u00af\7\63\2\2\u00af\u00b0")
+        buf.write("\5\26\f\2\u00b0\23\3\2\2\2\u00b1\u00b2\7.\2\2\u00b2\u00b3")
+        buf.write("\7#\2\2\u00b3\25\3\2\2\2\u00b4\u00b5\5\30\r\2\u00b5\u00b6")
+        buf.write("\7\63\2\2\u00b6\u00b8\3\2\2\2\u00b7\u00b4\3\2\2\2\u00b8")
+        buf.write("\u00bb\3\2\2\2\u00b9\u00b7\3\2\2\2\u00b9\u00ba\3\2\2\2")
+        buf.write("\u00ba\u00bc\3\2\2\2\u00bb\u00b9\3\2\2\2\u00bc\u00bd\5")
+        buf.write("\30\r\2\u00bd\27\3\2\2\2\u00be\u00bf\7\62\2\2\u00bf\u00c4")
+        buf.write("\5H%\2\u00c0\u00c1\7(\2\2\u00c1\u00c3\5H%\2\u00c2\u00c0")
+        buf.write("\3\2\2\2\u00c3\u00c6\3\2\2\2\u00c4\u00c2\3\2\2\2\u00c4")
+        buf.write("\u00c5\3\2\2\2\u00c5\31\3\2\2\2\u00c6\u00c4\3\2\2\2\u00c7")
+        buf.write("\u00c8\7\4\2\2\u00c8\u00d4\5\n\6\2\u00c9\u00ca\7)\2\2")
+        buf.write("\u00ca\u00cf\5\24\13\2\u00cb\u00cc\7(\2\2\u00cc\u00ce")
+        buf.write("\5\24\13\2\u00cd\u00cb\3\2\2\2\u00ce\u00d1\3\2\2\2\u00cf")
+        buf.write("\u00cd\3\2\2\2\u00cf\u00d0\3\2\2\2\u00d0\u00d2\3\2\2\2")
+        buf.write("\u00d1\u00cf\3\2\2\2\u00d2\u00d3\7*\2\2\u00d3\u00d5\3")
+        buf.write("\2\2\2\u00d4\u00c9\3\2\2\2\u00d4\u00d5\3\2\2\2\u00d5\u00d9")
+        buf.write("\3\2\2\2\u00d6\u00d8\5\34\17\2\u00d7\u00d6\3\2\2\2\u00d8")
+        buf.write("\u00db\3\2\2\2\u00d9\u00d7\3\2\2\2\u00d9\u00da\3\2\2\2")
+        buf.write("\u00da\u00dc\3\2\2\2\u00db\u00d9\3\2\2\2\u00dc\u00dd\7")
+        buf.write("-\2\2\u00dd\u00de\7\63\2\2\u00de\u00df\5$\23\2\u00df\33")
+        buf.write("\3\2\2\2\u00e0\u00e1\7#\2\2\u00e1\35\3\2\2\2\u00e2\u00e5")
+        buf.write("\5\f\7\2\u00e3\u00e5\5\34\17\2\u00e4\u00e2\3\2\2\2\u00e4")
+        buf.write("\u00e3\3\2\2\2\u00e5\37\3\2\2\2\u00e6\u00f2\5\n\6\2\u00e7")
+        buf.write("\u00e8\7)\2\2\u00e8\u00ed\5\16\b\2\u00e9\u00ea\7(\2\2")
+        buf.write("\u00ea\u00ec\5\16\b\2\u00eb\u00e9\3\2\2\2\u00ec\u00ef")
+        buf.write("\3\2\2\2\u00ed\u00eb\3\2\2\2\u00ed\u00ee\3\2\2\2\u00ee")
+        buf.write("\u00f0\3\2\2\2\u00ef\u00ed\3\2\2\2\u00f0\u00f1\7*\2\2")
+        buf.write("\u00f1\u00f3\3\2\2\2\u00f2\u00e7\3\2\2\2\u00f2\u00f3\3")
+        buf.write("\2\2\2\u00f3\u00f5\3\2\2\2\u00f4\u00f6\5\36\20\2\u00f5")
+        buf.write("\u00f4\3\2\2\2\u00f6\u00f7\3\2\2\2\u00f7\u00f5\3\2\2\2")
+        buf.write("\u00f7\u00f8\3\2\2\2\u00f8!\3\2\2\2\u00f9\u00fc\5 \21")
+        buf.write("\2\u00fa\u00fc\5\6\4\2\u00fb\u00f9\3\2\2\2\u00fb\u00fa")
+        buf.write("\3\2\2\2\u00fc#\3\2\2\2\u00fd\u00fe\7\62\2\2\u00fe\u00ff")
+        buf.write("\5\"\22\2\u00ff\u0100\7\63\2\2\u0100\u0102\3\2\2\2\u0101")
+        buf.write("\u00fd\3\2\2\2\u0102\u0105\3\2\2\2\u0103\u0101\3\2\2\2")
+        buf.write("\u0103\u0104\3\2\2\2\u0104\u0106\3\2\2\2\u0105\u0103\3")
+        buf.write("\2\2\2\u0106\u0107\7\62\2\2\u0107\u0108\5\"\22\2\u0108")
+        buf.write("%\3\2\2\2\u0109\u010a\7\5\2\2\u010a\u010c\5\f\7\2\u010b")
+        buf.write("\u010d\5(\25\2\u010c\u010b\3\2\2\2\u010c\u010d\3\2\2\2")
+        buf.write("\u010d\'\3\2\2\2\u010e\u010f\7+\2\2\u010f\u0110\5*\26")
+        buf.write("\2\u0110\u0111\7,\2\2\u0111)\3\2\2\2\u0112\u0114\7$\2")
+        buf.write("\2\u0113\u0112\3\2\2\2\u0114\u0115\3\2\2\2\u0115\u0113")
+        buf.write("\3\2\2\2\u0115\u0116\3\2\2\2\u0116+\3\2\2\2\u0117\u0118")
+        buf.write("\7\6\2\2\u0118\u0119\5.\30\2\u0119-\3\2\2\2\u011a\u011b")
+        buf.write("\7/\2\2\u011b\u011c\7#\2\2\u011c/\3\2\2\2\u011d\u011e")
+        buf.write("\7\7\2\2\u011e\61\3\2\2\2\u011f\u0120\7\b\2\2\u0120\u0121")
+        buf.write("\5.\30\2\u0121\63\3\2\2\2\u0122\u0123\7\t\2\2\u0123\u0124")
+        buf.write("\5.\30\2\u0124\u0125\5(\25\2\u0125\65\3\2\2\2\u0126\u0127")
+        buf.write("\7\n\2\2\u0127\u0128\5.\30\2\u0128\u0129\5(\25\2\u0129")
+        buf.write("\67\3\2\2\2\u012a\u012b\7\13\2\2\u012b9\3\2\2\2\u012c")
+        buf.write("\u012d\7\f\2\2\u012d;\3\2\2\2\u012e\u012f\t\2\2\2\u012f")
+        buf.write("\u0130\5(\25\2\u0130=\3\2\2\2\u0131\u0132\t\3\2\2\u0132")
+        buf.write("\u0133\5(\25\2\u0133\u0134\5(\25\2\u0134?\3\2\2\2\u0135")
+        buf.write("\u0136\7\r\2\2\u0136A\3\2\2\2\u0137\u0138\7\16\2\2\u0138")
+        buf.write("\u0139\7&\2\2\u0139C\3\2\2\2\u013a\u013b\7\17\2\2\u013b")
+        buf.write("\u013f\7#\2\2\u013c\u013e\5F$\2\u013d\u013c\3\2\2\2\u013e")
+        buf.write("\u0141\3\2\2\2\u013f\u013d\3\2\2\2\u013f\u0140\3\2\2\2")
+        buf.write("\u0140\u0143\3\2\2\2\u0141\u013f\3\2\2\2\u0142\u0144\7")
+        buf.write("&\2\2\u0143\u0142\3\2\2\2\u0143\u0144\3\2\2\2\u0144E\3")
+        buf.write("\2\2\2\u0145\u0146\t\4\2\2\u0146G\3\2\2\2\u0147\u0148")
+        buf.write("\b%\1\2\u0148\u0149\7)\2\2\u0149\u014a\5H%\2\u014a\u014b")
+        buf.write("\7*\2\2\u014b\u0154\3\2\2\2\u014c\u014d\5J&\2\u014d\u014e")
+        buf.write("\7)\2\2\u014e\u014f\5H%\2\u014f\u0150\7*\2\2\u0150\u0154")
+        buf.write("\3\2\2\2\u0151\u0154\5L\'\2\u0152\u0154\5\24\13\2\u0153")
+        buf.write("\u0147\3\2\2\2\u0153\u014c\3\2\2\2\u0153\u0151\3\2\2\2")
+        buf.write("\u0153\u0152\3\2\2\2\u0154\u0160\3\2\2\2\u0155\u0156\f")
+        buf.write("\b\2\2\u0156\u0157\7\"\2\2\u0157\u015f\5H%\b\u0158\u0159")
+        buf.write("\f\7\2\2\u0159\u015a\t\5\2\2\u015a\u015f\5H%\b\u015b\u015c")
+        buf.write("\f\6\2\2\u015c\u015d\t\6\2\2\u015d\u015f\5H%\7\u015e\u0155")
+        buf.write("\3\2\2\2\u015e\u0158\3\2\2\2\u015e\u015b\3\2\2\2\u015f")
+        buf.write("\u0162\3\2\2\2\u0160\u015e\3\2\2\2\u0160\u0161\3\2\2\2")
+        buf.write("\u0161I\3\2\2\2\u0162\u0160\3\2\2\2\u0163\u0164\t\7\2")
+        buf.write("\2\u0164K\3\2\2\2\u0165\u016a\5P)\2\u0166\u016a\5N(\2")
+        buf.write("\u0167\u016a\7\30\2\2\u0168\u016a\7\27\2\2\u0169\u0165")
+        buf.write("\3\2\2\2\u0169\u0166\3\2\2\2\u0169\u0167\3\2\2\2\u0169")
+        buf.write("\u0168\3\2\2\2\u016aM\3\2\2\2\u016b\u016c\5P)\2\u016c")
+        buf.write("\u016d\7\30\2\2\u016dO\3\2\2\2\u016e\u0171\5R*\2\u016f")
+        buf.write("\u0171\5T+\2\u0170\u016e\3\2\2\2\u0170\u016f\3\2\2\2\u0171")
+        buf.write("Q\3\2\2\2\u0172\u0174\5V,\2\u0173\u0172\3\2\2\2\u0173")
+        buf.write("\u0174\3\2\2\2\u0174\u0175\3\2\2\2\u0175\u0176\7%\2\2")
+        buf.write("\u0176S\3\2\2\2\u0177\u0179\5V,\2\u0178\u0177\3\2\2\2")
+        buf.write("\u0178\u0179\3\2\2\2\u0179\u017a\3\2\2\2\u017a\u017b\7")
+        buf.write("$\2\2\u017bU\3\2\2\2\u017c\u017d\t\6\2\2\u017dW\3\2\2")
+        buf.write("\2#\\aiy\u0082\u0087\u008c\u0094\u009a\u00a6\u00ab\u00b9")
+        buf.write("\u00c4\u00cf\u00d4\u00d9\u00e4\u00ed\u00f2\u00f7\u00fb")
+        buf.write("\u0103\u010c\u0115\u013f\u0143\u0153\u015e\u0160\u0169")
+        buf.write("\u0170\u0173\u0178")
         return buf.getvalue()
 
 
@@ -375,38 +372,27 @@ class QuilParser ( Parser ):
             self.allInstr()
             self.state = 95
             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:
-                    self.state = 88 
+            _la = self._input.LA(1)
+            while _la==QuilParser.NEWLINE:
+                self.state = 88 
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                while True:
+                    self.state = 87
+                    self.match(QuilParser.NEWLINE)
+                    self.state = 90 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
-                    while True:
-                        self.state = 87
-                        self.match(QuilParser.NEWLINE)
-                        self.state = 90 
-                        self._errHandler.sync(self)
-                        _la = self._input.LA(1)
-                        if not (_la==QuilParser.NEWLINE):
-                            break
+                    if not (_la==QuilParser.NEWLINE):
+                        break
 
-                    self.state = 92
-                    self.allInstr() 
+                self.state = 92
+                self.allInstr()
                 self.state = 97
                 self._errHandler.sync(self)
-                _alt = self._interp.adaptivePredict(self._input,1,self._ctx)
-
-            self.state = 101
-            self._errHandler.sync(self)
-            _la = self._input.LA(1)
-            while _la==QuilParser.NEWLINE:
-                self.state = 98
-                self.match(QuilParser.NEWLINE)
-                self.state = 103
-                self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 104
+            self.state = 98
             self.match(QuilParser.EOF)
         except RecognitionException as re:
             localctx.exception = re
@@ -453,22 +439,22 @@ class QuilParser ( Parser ):
         localctx = QuilParser.AllInstrContext(self, self._ctx, self.state)
         self.enterRule(localctx, 2, self.RULE_allInstr)
         try:
-            self.state = 109
+            self.state = 103
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [QuilParser.DEFGATE]:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 106
+                self.state = 100
                 self.defGate()
                 pass
             elif token in [QuilParser.DEFCIRCUIT]:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 107
+                self.state = 101
                 self.defCircuit()
                 pass
             elif token in [QuilParser.MEASURE, QuilParser.LABEL, QuilParser.HALT, QuilParser.JUMP, QuilParser.JUMPWHEN, QuilParser.JUMPUNLESS, QuilParser.RESET, QuilParser.WAIT, QuilParser.NOP, QuilParser.INCLUDE, QuilParser.PRAGMA, QuilParser.FALSE, QuilParser.TRUE, QuilParser.NOT, QuilParser.AND, QuilParser.OR, QuilParser.MOVE, QuilParser.EXCHANGE, QuilParser.IDENTIFIER]:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 108
+                self.state = 102
                 self.instr()
                 pass
             else:
@@ -563,77 +549,77 @@ class QuilParser ( Parser ):
         localctx = QuilParser.InstrContext(self, self._ctx, self.state)
         self.enterRule(localctx, 4, self.RULE_instr)
         try:
-            self.state = 125
+            self.state = 119
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [QuilParser.IDENTIFIER]:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 111
+                self.state = 105
                 self.gate()
                 pass
             elif token in [QuilParser.MEASURE]:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 112
+                self.state = 106
                 self.measure()
                 pass
             elif token in [QuilParser.LABEL]:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 113
+                self.state = 107
                 self.defLabel()
                 pass
             elif token in [QuilParser.HALT]:
                 self.enterOuterAlt(localctx, 4)
-                self.state = 114
+                self.state = 108
                 self.halt()
                 pass
             elif token in [QuilParser.JUMP]:
                 self.enterOuterAlt(localctx, 5)
-                self.state = 115
+                self.state = 109
                 self.jump()
                 pass
             elif token in [QuilParser.JUMPWHEN]:
                 self.enterOuterAlt(localctx, 6)
-                self.state = 116
+                self.state = 110
                 self.jumpWhen()
                 pass
             elif token in [QuilParser.JUMPUNLESS]:
                 self.enterOuterAlt(localctx, 7)
-                self.state = 117
+                self.state = 111
                 self.jumpUnless()
                 pass
             elif token in [QuilParser.RESET]:
                 self.enterOuterAlt(localctx, 8)
-                self.state = 118
+                self.state = 112
                 self.resetState()
                 pass
             elif token in [QuilParser.WAIT]:
                 self.enterOuterAlt(localctx, 9)
-                self.state = 119
+                self.state = 113
                 self.wait()
                 pass
             elif token in [QuilParser.FALSE, QuilParser.TRUE, QuilParser.NOT]:
                 self.enterOuterAlt(localctx, 10)
-                self.state = 120
+                self.state = 114
                 self.classicalUnary()
                 pass
             elif token in [QuilParser.AND, QuilParser.OR, QuilParser.MOVE, QuilParser.EXCHANGE]:
                 self.enterOuterAlt(localctx, 11)
-                self.state = 121
+                self.state = 115
                 self.classicalBinary()
                 pass
             elif token in [QuilParser.NOP]:
                 self.enterOuterAlt(localctx, 12)
-                self.state = 122
+                self.state = 116
                 self.nop()
                 pass
             elif token in [QuilParser.INCLUDE]:
                 self.enterOuterAlt(localctx, 13)
-                self.state = 123
+                self.state = 117
                 self.include()
                 pass
             elif token in [QuilParser.PRAGMA]:
                 self.enterOuterAlt(localctx, 14)
-                self.state = 124
+                self.state = 118
                 self.pragma()
                 pass
             else:
@@ -704,39 +690,39 @@ class QuilParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 127
+            self.state = 121
             self.name()
-            self.state = 139
+            self.state = 133
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==QuilParser.LPAREN:
-                self.state = 128
+                self.state = 122
                 self.match(QuilParser.LPAREN)
-                self.state = 129
+                self.state = 123
                 self.param()
-                self.state = 134
+                self.state = 128
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while _la==QuilParser.COMMA:
-                    self.state = 130
+                    self.state = 124
                     self.match(QuilParser.COMMA)
-                    self.state = 131
+                    self.state = 125
                     self.param()
-                    self.state = 136
+                    self.state = 130
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
-                self.state = 137
+                self.state = 131
                 self.match(QuilParser.RPAREN)
 
 
-            self.state = 142 
+            self.state = 136 
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while True:
-                self.state = 141
+                self.state = 135
                 self.qubit()
-                self.state = 144 
+                self.state = 138 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if not (_la==QuilParser.UNSIGNED_INT):
@@ -779,7 +765,7 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 8, self.RULE_name)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 146
+            self.state = 140
             self.match(QuilParser.IDENTIFIER)
         except RecognitionException as re:
             localctx.exception = re
@@ -818,7 +804,7 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 10, self.RULE_qubit)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 148
+            self.state = 142
             self.match(QuilParser.UNSIGNED_INT)
         except RecognitionException as re:
             localctx.exception = re
@@ -861,17 +847,17 @@ class QuilParser ( Parser ):
         localctx = QuilParser.ParamContext(self, self._ctx, self.state)
         self.enterRule(localctx, 12, self.RULE_param)
         try:
-            self.state = 152
+            self.state = 146
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [QuilParser.LBRACKET]:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 150
+                self.state = 144
                 self.dynamicParam()
                 pass
-            elif token in [QuilParser.I, QuilParser.SIN, QuilParser.COS, QuilParser.SQRT, QuilParser.EXP, QuilParser.CIS, QuilParser.PLUS, QuilParser.MINUS, QuilParser.UNSIGNED_INT, QuilParser.UNSIGNED_FLOAT, QuilParser.LPAREN, QuilParser.PERCENTAGE]:
+            elif token in [QuilParser.PI, QuilParser.I, QuilParser.SIN, QuilParser.COS, QuilParser.SQRT, QuilParser.EXP, QuilParser.CIS, QuilParser.PLUS, QuilParser.MINUS, QuilParser.UNSIGNED_INT, QuilParser.UNSIGNED_FLOAT, QuilParser.LPAREN, QuilParser.PERCENTAGE]:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 151
+                self.state = 145
                 self.expression(0)
                 pass
             else:
@@ -927,21 +913,21 @@ class QuilParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 154
+            self.state = 148
             self.match(QuilParser.LBRACKET)
-            self.state = 155
+            self.state = 149
             self.match(QuilParser.UNSIGNED_INT)
-            self.state = 158
+            self.state = 152
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==QuilParser.MINUS:
-                self.state = 156
+                self.state = 150
                 self.match(QuilParser.MINUS)
-                self.state = 157
+                self.state = 151
                 self.match(QuilParser.UNSIGNED_INT)
 
 
-            self.state = 160
+            self.state = 154
             self.match(QuilParser.RBRACKET)
         except RecognitionException as re:
             localctx.exception = re
@@ -1014,39 +1000,39 @@ class QuilParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 162
+            self.state = 156
             self.match(QuilParser.DEFGATE)
-            self.state = 163
+            self.state = 157
             self.name()
-            self.state = 175
+            self.state = 169
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==QuilParser.LPAREN:
-                self.state = 164
+                self.state = 158
                 self.match(QuilParser.LPAREN)
-                self.state = 165
+                self.state = 159
                 self.variable()
-                self.state = 170
+                self.state = 164
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while _la==QuilParser.COMMA:
-                    self.state = 166
+                    self.state = 160
                     self.match(QuilParser.COMMA)
-                    self.state = 167
+                    self.state = 161
                     self.variable()
-                    self.state = 172
+                    self.state = 166
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
-                self.state = 173
+                self.state = 167
                 self.match(QuilParser.RPAREN)
 
 
-            self.state = 177
+            self.state = 171
             self.match(QuilParser.COLON)
-            self.state = 178
+            self.state = 172
             self.match(QuilParser.NEWLINE)
-            self.state = 179
+            self.state = 173
             self.matrix()
         except RecognitionException as re:
             localctx.exception = re
@@ -1088,9 +1074,9 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 18, self.RULE_variable)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 181
+            self.state = 175
             self.match(QuilParser.PERCENTAGE)
-            self.state = 182
+            self.state = 176
             self.match(QuilParser.IDENTIFIER)
         except RecognitionException as re:
             localctx.exception = re
@@ -1139,20 +1125,20 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 20, self.RULE_matrix)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 189
+            self.state = 183
             self._errHandler.sync(self)
-            _alt = self._interp.adaptivePredict(self._input,12,self._ctx)
+            _alt = self._interp.adaptivePredict(self._input,11,self._ctx)
             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                 if _alt==1:
-                    self.state = 184
+                    self.state = 178
                     self.matrixRow()
-                    self.state = 185
+                    self.state = 179
                     self.match(QuilParser.NEWLINE) 
-                self.state = 191
+                self.state = 185
                 self._errHandler.sync(self)
-                _alt = self._interp.adaptivePredict(self._input,12,self._ctx)
+                _alt = self._interp.adaptivePredict(self._input,11,self._ctx)
 
-            self.state = 192
+            self.state = 186
             self.matrixRow()
         except RecognitionException as re:
             localctx.exception = re
@@ -1205,19 +1191,19 @@ class QuilParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 194
+            self.state = 188
             self.match(QuilParser.TAB)
-            self.state = 195
+            self.state = 189
             self.expression(0)
-            self.state = 200
+            self.state = 194
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==QuilParser.COMMA:
-                self.state = 196
+                self.state = 190
                 self.match(QuilParser.COMMA)
-                self.state = 197
+                self.state = 191
                 self.expression(0)
-                self.state = 202
+                self.state = 196
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
@@ -1299,49 +1285,49 @@ class QuilParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 203
+            self.state = 197
             self.match(QuilParser.DEFCIRCUIT)
-            self.state = 204
+            self.state = 198
             self.name()
-            self.state = 216
+            self.state = 210
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==QuilParser.LPAREN:
-                self.state = 205
+                self.state = 199
                 self.match(QuilParser.LPAREN)
-                self.state = 206
+                self.state = 200
                 self.variable()
-                self.state = 211
+                self.state = 205
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while _la==QuilParser.COMMA:
-                    self.state = 207
+                    self.state = 201
                     self.match(QuilParser.COMMA)
-                    self.state = 208
+                    self.state = 202
                     self.variable()
-                    self.state = 213
+                    self.state = 207
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
-                self.state = 214
+                self.state = 208
                 self.match(QuilParser.RPAREN)
 
 
-            self.state = 221
+            self.state = 215
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==QuilParser.IDENTIFIER:
-                self.state = 218
+                self.state = 212
                 self.qubitVariable()
-                self.state = 223
+                self.state = 217
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 224
+            self.state = 218
             self.match(QuilParser.COLON)
-            self.state = 225
+            self.state = 219
             self.match(QuilParser.NEWLINE)
-            self.state = 226
+            self.state = 220
             self.circuit()
         except RecognitionException as re:
             localctx.exception = re
@@ -1380,7 +1366,7 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 26, self.RULE_qubitVariable)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 228
+            self.state = 222
             self.match(QuilParser.IDENTIFIER)
         except RecognitionException as re:
             localctx.exception = re
@@ -1423,17 +1409,17 @@ class QuilParser ( Parser ):
         localctx = QuilParser.CircuitQubitContext(self, self._ctx, self.state)
         self.enterRule(localctx, 28, self.RULE_circuitQubit)
         try:
-            self.state = 232
+            self.state = 226
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [QuilParser.UNSIGNED_INT]:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 230
+                self.state = 224
                 self.qubit()
                 pass
             elif token in [QuilParser.IDENTIFIER]:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 231
+                self.state = 225
                 self.qubitVariable()
                 pass
             else:
@@ -1504,39 +1490,39 @@ class QuilParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 234
+            self.state = 228
             self.name()
-            self.state = 246
+            self.state = 240
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==QuilParser.LPAREN:
-                self.state = 235
+                self.state = 229
                 self.match(QuilParser.LPAREN)
-                self.state = 236
+                self.state = 230
                 self.param()
-                self.state = 241
+                self.state = 235
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while _la==QuilParser.COMMA:
-                    self.state = 237
+                    self.state = 231
                     self.match(QuilParser.COMMA)
-                    self.state = 238
+                    self.state = 232
                     self.param()
-                    self.state = 243
+                    self.state = 237
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
-                self.state = 244
+                self.state = 238
                 self.match(QuilParser.RPAREN)
 
 
-            self.state = 249 
+            self.state = 243 
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while True:
-                self.state = 248
+                self.state = 242
                 self.circuitQubit()
-                self.state = 251 
+                self.state = 245 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if not (_la==QuilParser.IDENTIFIER or _la==QuilParser.UNSIGNED_INT):
@@ -1583,18 +1569,18 @@ class QuilParser ( Parser ):
         localctx = QuilParser.CircuitInstrContext(self, self._ctx, self.state)
         self.enterRule(localctx, 32, self.RULE_circuitInstr)
         try:
-            self.state = 255
+            self.state = 249
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,21,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,20,self._ctx)
             if la_ == 1:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 253
+                self.state = 247
                 self.circuitGate()
                 pass
 
             elif la_ == 2:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 254
+                self.state = 248
                 self.instr()
                 pass
 
@@ -1652,24 +1638,24 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 34, self.RULE_circuit)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 263
+            self.state = 257
             self._errHandler.sync(self)
-            _alt = self._interp.adaptivePredict(self._input,22,self._ctx)
+            _alt = self._interp.adaptivePredict(self._input,21,self._ctx)
             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                 if _alt==1:
-                    self.state = 257
+                    self.state = 251
                     self.match(QuilParser.TAB)
-                    self.state = 258
+                    self.state = 252
                     self.circuitInstr()
-                    self.state = 259
+                    self.state = 253
                     self.match(QuilParser.NEWLINE) 
-                self.state = 265
+                self.state = 259
                 self._errHandler.sync(self)
-                _alt = self._interp.adaptivePredict(self._input,22,self._ctx)
+                _alt = self._interp.adaptivePredict(self._input,21,self._ctx)
 
-            self.state = 266
+            self.state = 260
             self.match(QuilParser.TAB)
-            self.state = 267
+            self.state = 261
             self.circuitInstr()
         except RecognitionException as re:
             localctx.exception = re
@@ -1717,15 +1703,15 @@ class QuilParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 269
+            self.state = 263
             self.match(QuilParser.MEASURE)
-            self.state = 270
+            self.state = 264
             self.qubit()
-            self.state = 272
+            self.state = 266
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==QuilParser.LBRACKET:
-                self.state = 271
+                self.state = 265
                 self.addr()
 
 
@@ -1773,11 +1759,11 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 38, self.RULE_addr)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 274
+            self.state = 268
             self.match(QuilParser.LBRACKET)
-            self.state = 275
+            self.state = 269
             self.classicalBit()
-            self.state = 276
+            self.state = 270
             self.match(QuilParser.RBRACKET)
         except RecognitionException as re:
             localctx.exception = re
@@ -1820,13 +1806,13 @@ class QuilParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 279 
+            self.state = 273 
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while True:
-                self.state = 278
+                self.state = 272
                 self.match(QuilParser.UNSIGNED_INT)
-                self.state = 281 
+                self.state = 275 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if not (_la==QuilParser.UNSIGNED_INT):
@@ -1873,9 +1859,9 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 42, self.RULE_defLabel)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 283
+            self.state = 277
             self.match(QuilParser.LABEL)
-            self.state = 284
+            self.state = 278
             self.label()
         except RecognitionException as re:
             localctx.exception = re
@@ -1917,9 +1903,9 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 44, self.RULE_label)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 286
+            self.state = 280
             self.match(QuilParser.AT)
-            self.state = 287
+            self.state = 281
             self.match(QuilParser.IDENTIFIER)
         except RecognitionException as re:
             localctx.exception = re
@@ -1958,7 +1944,7 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 46, self.RULE_halt)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 289
+            self.state = 283
             self.match(QuilParser.HALT)
         except RecognitionException as re:
             localctx.exception = re
@@ -2001,9 +1987,9 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 48, self.RULE_jump)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 291
+            self.state = 285
             self.match(QuilParser.JUMP)
-            self.state = 292
+            self.state = 286
             self.label()
         except RecognitionException as re:
             localctx.exception = re
@@ -2050,11 +2036,11 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 50, self.RULE_jumpWhen)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 294
+            self.state = 288
             self.match(QuilParser.JUMPWHEN)
-            self.state = 295
+            self.state = 289
             self.label()
-            self.state = 296
+            self.state = 290
             self.addr()
         except RecognitionException as re:
             localctx.exception = re
@@ -2101,11 +2087,11 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 52, self.RULE_jumpUnless)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 298
+            self.state = 292
             self.match(QuilParser.JUMPUNLESS)
-            self.state = 299
+            self.state = 293
             self.label()
-            self.state = 300
+            self.state = 294
             self.addr()
         except RecognitionException as re:
             localctx.exception = re
@@ -2144,7 +2130,7 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 54, self.RULE_resetState)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 302
+            self.state = 296
             self.match(QuilParser.RESET)
         except RecognitionException as re:
             localctx.exception = re
@@ -2183,7 +2169,7 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 56, self.RULE_wait)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 304
+            self.state = 298
             self.match(QuilParser.WAIT)
         except RecognitionException as re:
             localctx.exception = re
@@ -2233,14 +2219,14 @@ class QuilParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 306
+            self.state = 300
             _la = self._input.LA(1)
             if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << QuilParser.FALSE) | (1 << QuilParser.TRUE) | (1 << QuilParser.NOT))) != 0)):
                 self._errHandler.recoverInline(self)
             else:
                 self._errHandler.reportMatch(self)
                 self.consume()
-            self.state = 307
+            self.state = 301
             self.addr()
         except RecognitionException as re:
             localctx.exception = re
@@ -2296,16 +2282,16 @@ class QuilParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 309
+            self.state = 303
             _la = self._input.LA(1)
             if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << QuilParser.AND) | (1 << QuilParser.OR) | (1 << QuilParser.MOVE) | (1 << QuilParser.EXCHANGE))) != 0)):
                 self._errHandler.recoverInline(self)
             else:
                 self._errHandler.reportMatch(self)
                 self.consume()
-            self.state = 310
+            self.state = 304
             self.addr()
-            self.state = 311
+            self.state = 305
             self.addr()
         except RecognitionException as re:
             localctx.exception = re
@@ -2344,7 +2330,7 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 62, self.RULE_nop)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 313
+            self.state = 307
             self.match(QuilParser.NOP)
         except RecognitionException as re:
             localctx.exception = re
@@ -2386,9 +2372,9 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 64, self.RULE_include)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 315
+            self.state = 309
             self.match(QuilParser.INCLUDE)
-            self.state = 316
+            self.state = 310
             self.match(QuilParser.STRING)
         except RecognitionException as re:
             localctx.exception = re
@@ -2441,25 +2427,25 @@ class QuilParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 318
+            self.state = 312
             self.match(QuilParser.PRAGMA)
-            self.state = 319
+            self.state = 313
             self.match(QuilParser.IDENTIFIER)
-            self.state = 323
+            self.state = 317
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==QuilParser.IDENTIFIER or _la==QuilParser.UNSIGNED_INT:
-                self.state = 320
+                self.state = 314
                 self.pragma_name()
-                self.state = 325
+                self.state = 319
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 327
+            self.state = 321
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==QuilParser.STRING:
-                self.state = 326
+                self.state = 320
                 self.match(QuilParser.STRING)
 
 
@@ -2504,7 +2490,7 @@ class QuilParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 329
+            self.state = 323
             _la = self._input.LA(1)
             if not(_la==QuilParser.IDENTIFIER or _la==QuilParser.UNSIGNED_INT):
                 self._errHandler.recoverInline(self)
@@ -2708,7 +2694,7 @@ class QuilParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 343
+            self.state = 337
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [QuilParser.LPAREN]:
@@ -2716,108 +2702,108 @@ class QuilParser ( Parser ):
                 self._ctx = localctx
                 _prevctx = localctx
 
-                self.state = 332
+                self.state = 326
                 self.match(QuilParser.LPAREN)
-                self.state = 333
+                self.state = 327
                 self.expression(0)
-                self.state = 334
+                self.state = 328
                 self.match(QuilParser.RPAREN)
                 pass
             elif token in [QuilParser.SIN, QuilParser.COS, QuilParser.SQRT, QuilParser.EXP, QuilParser.CIS]:
                 localctx = QuilParser.FunctionExpContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 336
+                self.state = 330
                 self.function()
-                self.state = 337
+                self.state = 331
                 self.match(QuilParser.LPAREN)
-                self.state = 338
+                self.state = 332
                 self.expression(0)
-                self.state = 339
+                self.state = 333
                 self.match(QuilParser.RPAREN)
                 pass
-            elif token in [QuilParser.I, QuilParser.PLUS, QuilParser.MINUS, QuilParser.UNSIGNED_INT, QuilParser.UNSIGNED_FLOAT]:
+            elif token in [QuilParser.PI, QuilParser.I, QuilParser.PLUS, QuilParser.MINUS, QuilParser.UNSIGNED_INT, QuilParser.UNSIGNED_FLOAT]:
                 localctx = QuilParser.NumberExpContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 341
+                self.state = 335
                 self.number()
                 pass
             elif token in [QuilParser.PERCENTAGE]:
                 localctx = QuilParser.VariableExpContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 342
+                self.state = 336
                 self.variable()
                 pass
             else:
                 raise NoViableAltException(self)
 
             self._ctx.stop = self._input.LT(-1)
-            self.state = 356
+            self.state = 350
             self._errHandler.sync(self)
-            _alt = self._interp.adaptivePredict(self._input,29,self._ctx)
+            _alt = self._interp.adaptivePredict(self._input,28,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 = 354
+                    self.state = 348
                     self._errHandler.sync(self)
-                    la_ = self._interp.adaptivePredict(self._input,28,self._ctx)
+                    la_ = self._interp.adaptivePredict(self._input,27,self._ctx)
                     if la_ == 1:
                         localctx = QuilParser.PowerExpContext(self, QuilParser.ExpressionContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
-                        self.state = 345
+                        self.state = 339
                         if not self.precpred(self._ctx, 6):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
-                        self.state = 346
+                        self.state = 340
                         self.match(QuilParser.POWER)
-                        self.state = 347
+                        self.state = 341
                         self.expression(6)
                         pass
 
                     elif la_ == 2:
                         localctx = QuilParser.MulDivExpContext(self, QuilParser.ExpressionContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
-                        self.state = 348
+                        self.state = 342
                         if not self.precpred(self._ctx, 5):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 5)")
-                        self.state = 349
+                        self.state = 343
                         _la = self._input.LA(1)
                         if not(_la==QuilParser.TIMES or _la==QuilParser.DIVIDE):
                             self._errHandler.recoverInline(self)
                         else:
                             self._errHandler.reportMatch(self)
                             self.consume()
-                        self.state = 350
+                        self.state = 344
                         self.expression(6)
                         pass
 
                     elif la_ == 3:
                         localctx = QuilParser.AddSubExpContext(self, QuilParser.ExpressionContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expression)
-                        self.state = 351
+                        self.state = 345
                         if not self.precpred(self._ctx, 4):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 4)")
-                        self.state = 352
+                        self.state = 346
                         _la = self._input.LA(1)
                         if not(_la==QuilParser.PLUS or _la==QuilParser.MINUS):
                             self._errHandler.recoverInline(self)
                         else:
                             self._errHandler.reportMatch(self)
                             self.consume()
-                        self.state = 353
+                        self.state = 347
                         self.expression(5)
                         pass
 
              
-                self.state = 358
+                self.state = 352
                 self._errHandler.sync(self)
-                _alt = self._interp.adaptivePredict(self._input,29,self._ctx)
+                _alt = self._interp.adaptivePredict(self._input,28,self._ctx)
 
         except RecognitionException as re:
             localctx.exception = re
@@ -2869,7 +2855,7 @@ class QuilParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 359
+            self.state = 353
             _la = self._input.LA(1)
             if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << QuilParser.SIN) | (1 << QuilParser.COS) | (1 << QuilParser.SQRT) | (1 << QuilParser.EXP) | (1 << QuilParser.CIS))) != 0)):
                 self._errHandler.recoverInline(self)
@@ -2901,6 +2887,9 @@ class QuilParser ( Parser ):
         def I(self):
             return self.getToken(QuilParser.I, 0)
 
+        def PI(self):
+            return self.getToken(QuilParser.PI, 0)
+
         def getRuleIndex(self):
             return QuilParser.RULE_number
 
@@ -2920,27 +2909,33 @@ class QuilParser ( Parser ):
         localctx = QuilParser.NumberContext(self, self._ctx, self.state)
         self.enterRule(localctx, 74, self.RULE_number)
         try:
-            self.state = 364
+            self.state = 359
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,30,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,29,self._ctx)
             if la_ == 1:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 361
+                self.state = 355
                 self.realN()
                 pass
 
             elif la_ == 2:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 362
+                self.state = 356
                 self.imaginaryN()
                 pass
 
             elif la_ == 3:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 363
+                self.state = 357
                 self.match(QuilParser.I)
                 pass
 
+            elif la_ == 4:
+                self.enterOuterAlt(localctx, 4)
+                self.state = 358
+                self.match(QuilParser.PI)
+                pass
+
 
         except RecognitionException as re:
             localctx.exception = re
@@ -2983,9 +2978,9 @@ class QuilParser ( Parser ):
         self.enterRule(localctx, 76, self.RULE_imaginaryN)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 366
+            self.state = 361
             self.realN()
-            self.state = 367
+            self.state = 362
             self.match(QuilParser.I)
         except RecognitionException as re:
             localctx.exception = re
@@ -3028,18 +3023,18 @@ class QuilParser ( Parser ):
         localctx = QuilParser.RealNContext(self, self._ctx, self.state)
         self.enterRule(localctx, 78, self.RULE_realN)
         try:
-            self.state = 371
+            self.state = 366
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,31,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,30,self._ctx)
             if la_ == 1:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 369
+                self.state = 364
                 self.floatN()
                 pass
 
             elif la_ == 2:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 370
+                self.state = 365
                 self.intN()
                 pass
 
@@ -3086,15 +3081,15 @@ class QuilParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 374
+            self.state = 369
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==QuilParser.PLUS or _la==QuilParser.MINUS:
-                self.state = 373
+                self.state = 368
                 self.sign()
 
 
-            self.state = 376
+            self.state = 371
             self.match(QuilParser.UNSIGNED_FLOAT)
         except RecognitionException as re:
             localctx.exception = re
@@ -3138,15 +3133,15 @@ class QuilParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 379
+            self.state = 374
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==QuilParser.PLUS or _la==QuilParser.MINUS:
-                self.state = 378
+                self.state = 373
                 self.sign()
 
 
-            self.state = 381
+            self.state = 376
             self.match(QuilParser.UNSIGNED_INT)
         except RecognitionException as re:
             localctx.exception = re
@@ -3189,7 +3184,7 @@ class QuilParser ( Parser ):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 383
+            self.state = 378
             _la = self._input.LA(1)
             if not(_la==QuilParser.PLUS or _la==QuilParser.MINUS):
                 self._errHandler.recoverInline(self)
diff --git a/pyquil/parser.py b/pyquil/parser.py
index 99330e8..3fdf921 100644
--- a/pyquil/parser.py
+++ b/pyquil/parser.py
@@ -38,4 +38,4 @@ def parse(quil):
     :param str quil: a single or multiline Quil program
     :return: list of instructions
     """
-    return run_parser(quil)
+    return run_parser(quil.strip())
diff --git a/setup.py b/setup.py
index 1bd5767..675c091 100755
--- a/setup.py
+++ b/setup.py
@@ -25,7 +25,7 @@ setup(
     author_email="softapps@rigetti.com",
     description="A Python library to generate Quantum Instruction Language (Quil) Programs.",
     url="https://github.com/rigetticomputing/pyquil.git",
-    packages=['pyquil', 'pyquil.setup'],
+    packages=['pyquil', 'pyquil._parser', 'pyquil.setup'],
     license="LICENSE",
     install_requires=[
         'requests >= 2.4.2',


Test patch:
diff --git a/pyquil/tests/test_parser.py b/pyquil/tests/test_parser.py
index 5aacd91..6ef7e3e 100644
--- a/pyquil/tests/test_parser.py
+++ b/pyquil/tests/test_parser.py
@@ -88,6 +88,10 @@ def test_expressions():
     _expr("2i", complex(0, 2))
     _expr("1 ^ 2", 1)
 
+    # Pi
+    _expr("pi", np.pi)
+    _expr("pi / 2", np.pi / 2)
+
     # Expressions
     _expr("1+2", 3)
     _expr("1-2", -1)