Repository: sympy/sympy

Issue:
FiniteSet not Value False
A=FiniteSet(1,2)
B=(FiniteSet(1,2),FiniteSet(1))

{1} in A
AttributeError                            Traceback (most recent call last)
<ipython-input-80-becd25ec8a42> in <module>()
----> 1 {1} in A

/usr/lib/python3/dist-packages/sympy/sets/sets.py in __contains__(self, other)
    577 
    578     def __contains__(self, other):
--> 579         symb = sympify(self.contains(other))
    580         if not (symb is S.true or symb is S.false):
    581             raise TypeError('contains did not evaluate to a bool: %r' % symb)

/usr/lib/python3/dist-packages/sympy/sets/sets.py in contains(self, other)
    305         """
    306         other = sympify(other, strict=True)
--> 307         ret = sympify(self._contains(other))
    308         if ret is None:
    309             ret = Contains(other, self, evaluate=False)

/usr/lib/python3/dist-packages/sympy/sets/sets.py in _contains(self, other)
   2001         r = false
   2002         for e in self._elements:
-> 2003             t = Eq(e, other, evaluate=True)
   2004             if isinstance(t, Eq):
   2005                 t = t.simplify()

/usr/lib/python3/dist-packages/sympy/core/relational.py in __new__(cls, lhs, rhs, **options)
    302                     return r
    303             if hasattr(rhs, '_eval_Eq'):
--> 304                 r = rhs._eval_Eq(lhs)
    305                 if r is not None:
    306                     return r

/usr/lib/python3/dist-packages/sympy/sets/sets.py in _eval_Eq(self, other)
   1899 
   1900     def _eval_Eq(self, other):
-> 1901         if not other.is_FiniteSet:
   1902             if (other.is_Union or other.is_Complement or
   1903                 other.is_Intersection or other.is_Produ

Discussion:
sympy-bot: :white_check_mark:

Hi, I am the [SymPy bot](https://github.com/sympy/sympy-bot) (v161). I'm here to help you write a release notes entry. Please read the [guide on how to write release notes](https://github.com/sympy/sympy/wiki/Writing-Release-Notes).



Your release notes are in good order.

Here is what the release notes will look like:
* core
  - Earlier expr and sets were treated equal which gave incorrect output for some set functions(mainly : - in, is_subset), made sets and expr not to be equal ([#20208](https://github.com/sympy/sympy/pull/20208) by [@sidhu1012](https://github.com/sidhu1012))

This will be added to https://github.com/sympy/sympy/wiki/Release-Notes-for-1.7.

<details><summary>Click here to see the pull request description that was parsed.</summary>

    <!-- Your title above should be a short description of what
    was changed. Do not include the issue number in the title. -->

    #### References to other Issues or PRs
    <!-- If this pull request fixes an issue, write "Fixes #NNNN" in that exact
    format, e.g. "Fixes #1234" (see
    https://tinyurl.com/auto-closing for more information). Also, please
    write a comment on that issue linking back to this pull request once it is
    open. -->
    Fixes #20089 

    #### Brief description of what is fixed or changed
    Earlier #in #subset gave wrong output due to inconsistency of #Eq with sets and expr

    #### Other comments


    #### Release Notes

    <!-- Write the release notes for this release below. See
    https://github.com/sympy/sympy/wiki/Writing-Release-Notes for more information
    on how to write release notes. The bot will check your release notes
    automatically to see if they are formatted correctly. -->

    <!-- BEGIN RELEASE NOTES -->
    - core
         - Earlier expr and sets were treated equal which gave incorrect output for some set functions(mainly : - in, is_subset), made sets and expr not to be equal
    <!-- END RELEASE NOTES -->

</details><p>

codecov[bot]: # [Codecov](https://codecov.io/gh/sympy/sympy/pull/20208?src=pr&el=h1) Report
> Merging [#20208](https://codecov.io/gh/sympy/sympy/pull/20208?src=pr&el=desc) into [master](https://codecov.io/gh/sympy/sympy/commit/8ce3dd865b191326f5c8344aa28cc93e2cb0e272?el=desc) will **increase** coverage by `31.405%`.
> The diff coverage is `100.000%`.

```diff
@@              Coverage Diff               @@
##            master    #20208        +/-   ##
==============================================
+ Coverage   44.413%   75.819%   +31.405%     
==============================================
  Files          671       671                
  Lines       173799    173809        +10     
  Branches     41067     41071         +4     
==============================================
+ Hits         77191    131781     +54590     
+ Misses       90709     36274     -54435     
+ Partials      5899      5754       -145     
```

sidhu1012: Pls review
sidhu1012: @oscarbenjamin Review pls

Patch:
diff --git a/sympy/parsing/latex/LaTeX.g4 b/sympy/parsing/latex/LaTeX.g4
index f963a96d94..c126c24310 100644
--- a/sympy/parsing/latex/LaTeX.g4
+++ b/sympy/parsing/latex/LaTeX.g4
@@ -1,22 +1,25 @@
 /*
- ANTLR4 LaTeX Math Grammar
- 
- Ported from latex2sympy by @augustt198 https://github.com/augustt198/latex2sympy See license in
- LICENSE.txt
- */
+  ANTLR4 LaTeX Math Grammar
+
+  Ported from latex2sympy by @augustt198
+  https://github.com/augustt198/latex2sympy
+  See license in LICENSE.txt
+*/
 
 /*
- After changing this file, it is necessary to run `python setup.py antlr` in the root directory of
- the repository. This will regenerate the code in `sympy/parsing/latex/_antlr/*.py`.
- */
+  After changing this file, it is necessary to run `python setup.py antlr`
+  in the root directory of the repository. This will regenerate the code in
+  `sympy/parsing/latex/_antlr/*.py`.
+*/
 
 grammar LaTeX;
 
 options {
-	language = Python2;
+    language=Python2;
 }
 
 WS: [ \t\r\n]+ -> skip;
+
 THINSPACE: ('\\,' | '\\thinspace') -> skip;
 MEDSPACE: ('\\:' | '\\medspace') -> skip;
 THICKSPACE: ('\\;' | '\\thickspace') -> skip;
@@ -25,25 +28,6 @@ QQUAD: '\\qquad' -> skip;
 NEGTHINSPACE: ('\\!' | '\\negthinspace') -> skip;
 NEGMEDSPACE: '\\negmedspace' -> skip;
 NEGTHICKSPACE: '\\negthickspace' -> skip;
-CMD_LEFT: '\\left' -> skip;
-CMD_RIGHT: '\\right' -> skip;
-
-IGNORE:
-	(
-		'\\vrule'
-		| '\\vcenter'
-		| '\\vbox'
-		| '\\vskip'
-		| '\\vspace'
-		| '\\hfil'
-		| '\\*'
-		| '\\-'
-		| '\\.'
-		| '\\/'
-		| '\\"'
-		| '\\('
-		| '\\='
-	) -> skip;
 
 ADD: '+';
 SUB: '-';
@@ -58,34 +42,26 @@ L_BRACE_LITERAL: '\\{';
 R_BRACE_LITERAL: '\\}';
 L_BRACKET: '[';
 R_BRACKET: ']';
+CMD_LEFT: '\\left' -> skip;
+CMD_RIGHT: '\\right' -> skip;
 
 BAR: '|';
 
-R_BAR: '\\right|';
-L_BAR: '\\left|';
-
-L_ANGLE: '\\langle';
-R_ANGLE: '\\rangle';
-FUNC_LIM: '\\lim';
-LIM_APPROACH_SYM:
-	'\\to'
-	| '\\rightarrow'
-	| '\\Rightarrow'
-	| '\\longrightarrow'
-	| '\\Longrightarrow';
-FUNC_INT: '\\int';
-FUNC_SUM: '\\sum';
+FUNC_LIM:  '\\lim';
+LIM_APPROACH_SYM: '\\to' | '\\rightarrow' | '\\Rightarrow' | '\\longrightarrow' | '\\Longrightarrow';
+FUNC_INT:  '\\int';
+FUNC_SUM:  '\\sum';
 FUNC_PROD: '\\prod';
 
-FUNC_EXP: '\\exp';
-FUNC_LOG: '\\log';
-FUNC_LN: '\\ln';
-FUNC_SIN: '\\sin';
-FUNC_COS: '\\cos';
-FUNC_TAN: '\\tan';
-FUNC_CSC: '\\csc';
-FUNC_SEC: '\\sec';
-FUNC_COT: '\\cot';
+FUNC_EXP:  '\\exp';
+FUNC_LOG:  '\\log';
+FUNC_LN:   '\\ln';
+FUNC_SIN:  '\\sin';
+FUNC_COS:  '\\cos';
+FUNC_TAN:  '\\tan';
+FUNC_CSC:  '\\csc';
+FUNC_SEC:  '\\sec';
+FUNC_COT:  '\\cot';
 
 FUNC_ARCSIN: '\\arcsin';
 FUNC_ARCCOS: '\\arccos';
@@ -101,17 +77,12 @@ FUNC_ARSINH: '\\arsinh';
 FUNC_ARCOSH: '\\arcosh';
 FUNC_ARTANH: '\\artanh';
 
-L_FLOOR: '\\lfloor';
-R_FLOOR: '\\rfloor';
-L_CEIL: '\\lceil';
-R_CEIL: '\\rceil';
-
 FUNC_SQRT: '\\sqrt';
 
 CMD_TIMES: '\\times';
-CMD_CDOT: '\\cdot';
-CMD_DIV: '\\div';
-CMD_FRAC: '\\frac';
+CMD_CDOT:  '\\cdot';
+CMD_DIV:   '\\div';
+CMD_FRAC:  '\\frac';
 CMD_BINOM: '\\binom';
 CMD_DBINOM: '\\dbinom';
 CMD_TBINOM: '\\tbinom';
@@ -128,19 +99,19 @@ DIFFERENTIAL: 'd' WS_CHAR*? ([a-zA-Z] | '\\' [a-zA-Z]+);
 LETTER: [a-zA-Z];
 fragment DIGIT: [0-9];
 NUMBER:
-	DIGIT+ (',' DIGIT DIGIT DIGIT)*
-	| DIGIT* (',' DIGIT DIGIT DIGIT)* '.' DIGIT+;
+    DIGIT+ (',' DIGIT DIGIT DIGIT)*
+    | DIGIT* (',' DIGIT DIGIT DIGIT)* '.' DIGIT+;
 
-EQUAL: (('&' WS_CHAR*?)? '=') | ('=' (WS_CHAR*? '&')?);
+EQUAL: '=';
 NEQ: '\\neq';
 
 LT: '<';
-LTE: ('\\leq' | '\\le' | LTE_Q | LTE_S);
+LTE: ('\\leq' | 'le' | LTE_Q | LTE_S);
 LTE_Q: '\\leqq';
 LTE_S: '\\leqslant';
 
 GT: '>';
-GTE: ('\\geq' | '\\ge' | GTE_Q | GTE_S);
+GTE: ('\\geq' | 'ge' | GTE_Q | GTE_S);
 GTE_Q: '\\geqq';
 GTE_S: '\\geqslant';
 
@@ -151,148 +122,140 @@ SYMBOL: '\\' [a-zA-Z]+;
 math: relation;
 
 relation:
-	relation (EQUAL | LT | LTE | GT | GTE | NEQ) relation
-	| expr;
+    relation (EQUAL | LT | LTE | GT | GTE | NEQ) relation
+    | expr;
 
-equality: expr EQUAL expr;
+equality:
+    expr EQUAL expr;
 
 expr: additive;
 
-additive: additive (ADD | SUB) additive | mp;
+additive:
+    additive (ADD | SUB) additive
+    | mp;
 
 // mult part
 mp:
-	mp (MUL | CMD_TIMES | CMD_CDOT | DIV | CMD_DIV | COLON) mp
-	| unary;
+    mp (MUL | CMD_TIMES | CMD_CDOT | DIV | CMD_DIV | COLON) mp
+    | unary;
 
 mp_nofunc:
-	mp_nofunc (
-		MUL
-		| CMD_TIMES
-		| CMD_CDOT
-		| DIV
-		| CMD_DIV
-		| COLON
-	) mp_nofunc
-	| unary_nofunc;
-
-unary: (ADD | SUB) unary | postfix+;
+    mp_nofunc (MUL | CMD_TIMES | CMD_CDOT | DIV | CMD_DIV | COLON) mp_nofunc
+    | unary_nofunc;
+
+unary:
+    (ADD | SUB) unary
+    | postfix+;
 
 unary_nofunc:
-	(ADD | SUB) unary_nofunc
-	| postfix postfix_nofunc*;
+    (ADD | SUB) unary_nofunc
+    | postfix postfix_nofunc*;
 
 postfix: exp postfix_op*;
 postfix_nofunc: exp_nofunc postfix_op*;
 postfix_op: BANG | eval_at;
 
 eval_at:
-	BAR (eval_at_sup | eval_at_sub | eval_at_sup eval_at_sub);
+    BAR (eval_at_sup | eval_at_sub | eval_at_sup eval_at_sub);
 
-eval_at_sub: UNDERSCORE L_BRACE (expr | equality) R_BRACE;
+eval_at_sub:
+    UNDERSCORE L_BRACE
+    (expr | equality)
+    R_BRACE;
 
-eval_at_sup: CARET L_BRACE (expr | equality) R_BRACE;
+eval_at_sup:
+    CARET L_BRACE
+    (expr | equality)
+    R_BRACE;
 
-exp: exp CARET (atom | L_BRACE expr R_BRACE) subexpr? | comp;
+exp:
+    exp CARET (atom | L_BRACE expr R_BRACE) subexpr?
+    | comp;
 
 exp_nofunc:
-	exp_nofunc CARET (atom | L_BRACE expr R_BRACE) subexpr?
-	| comp_nofunc;
+    exp_nofunc CARET (atom | L_BRACE expr R_BRACE) subexpr?
+    | comp_nofunc;
 
 comp:
-	group
-	| abs_group
-	| func
-	| atom
-	| frac
-	| binom
-	| floor
-	| ceil;
+    group
+    | abs_group
+    | func
+    | atom
+    | frac
+    | binom;
 
 comp_nofunc:
-	group
-	| abs_group
-	| atom
-	| frac
-	| binom
-	| floor
-	| ceil;
+    group
+    | abs_group
+    | atom
+    | frac
+    | binom;
 
 group:
-	L_PAREN expr R_PAREN
-	| L_BRACKET expr R_BRACKET
-	| L_BRACE expr R_BRACE
-	| L_BRACE_LITERAL expr R_BRACE_LITERAL;
+    L_PAREN expr R_PAREN
+    | L_BRACKET expr R_BRACKET
+    | L_BRACE expr R_BRACE
+    | L_BRACE_LITERAL expr R_BRACE_LITERAL;
 
 abs_group: BAR expr BAR;
 
-atom: (LETTER | SYMBOL) subexpr?
-	| NUMBER
-	| DIFFERENTIAL
-	| mathit
-	| bra
-	| ket;
-
-bra: L_ANGLE expr (R_BAR | BAR);
-ket: (L_BAR | BAR) expr R_ANGLE;
+atom: (LETTER | SYMBOL) subexpr? | NUMBER | DIFFERENTIAL | mathit;
 
 mathit: CMD_MATHIT L_BRACE mathit_text R_BRACE;
 mathit_text: LETTER*;
 
 frac:
-	CMD_FRAC L_BRACE upper = expr R_BRACE L_BRACE lower = expr R_BRACE;
+    CMD_FRAC L_BRACE
+    upper=expr
+    R_BRACE L_BRACE
+    lower=expr
+    R_BRACE;
 
 binom:
-	(CMD_BINOM | CMD_DBINOM | CMD_TBINOM) L_BRACE n = expr R_BRACE L_BRACE k = expr R_BRACE;
-
-floor: L_FLOOR val = expr R_FLOOR;
-ceil: L_CEIL val = expr R_CEIL;
+    (CMD_BINOM | CMD_DBINOM | CMD_TBINOM) L_BRACE
+    n=expr
+    R_BRACE L_BRACE
+    k=expr
+    R_BRACE;
 
 func_normal:
-	FUNC_EXP
-	| FUNC_LOG
-	| FUNC_LN
-	| FUNC_SIN
-	| FUNC_COS
-	| FUNC_TAN
-	| FUNC_CSC
-	| FUNC_SEC
-	| FUNC_COT
-	| FUNC_ARCSIN
-	| FUNC_ARCCOS
-	| FUNC_ARCTAN
-	| FUNC_ARCCSC
-	| FUNC_ARCSEC
-	| FUNC_ARCCOT
-	| FUNC_SINH
-	| FUNC_COSH
-	| FUNC_TANH
-	| FUNC_ARSINH
-	| FUNC_ARCOSH
-	| FUNC_ARTANH;
+    FUNC_EXP | FUNC_LOG | FUNC_LN
+    | FUNC_SIN | FUNC_COS | FUNC_TAN
+    | FUNC_CSC | FUNC_SEC | FUNC_COT
+    | FUNC_ARCSIN | FUNC_ARCCOS | FUNC_ARCTAN
+    | FUNC_ARCCSC | FUNC_ARCSEC | FUNC_ARCCOT
+    | FUNC_SINH | FUNC_COSH | FUNC_TANH
+    | FUNC_ARSINH | FUNC_ARCOSH | FUNC_ARTANH;
 
 func:
-	func_normal (subexpr? supexpr? | supexpr? subexpr?) (
-		L_PAREN func_arg R_PAREN
-		| func_arg_noparens
-	)
-	| (LETTER | SYMBOL) subexpr? // e.g. f(x)
-	L_PAREN args R_PAREN
-	| FUNC_INT (subexpr supexpr | supexpr subexpr)? (
-		additive? DIFFERENTIAL
-		| frac
-		| additive
-	)
-	| FUNC_SQRT (L_BRACKET root = expr R_BRACKET)? L_BRACE base = expr R_BRACE
-	| (FUNC_SUM | FUNC_PROD) (subeq supexpr | supexpr subeq) mp
-	| FUNC_LIM limit_sub mp;
+    func_normal
+    (subexpr? supexpr? | supexpr? subexpr?)
+    (L_PAREN func_arg R_PAREN | func_arg_noparens)
+
+    | (LETTER | SYMBOL) subexpr? // e.g. f(x)
+    L_PAREN args R_PAREN
+
+    | FUNC_INT
+    (subexpr supexpr | supexpr subexpr)?
+    (additive? DIFFERENTIAL | frac | additive)
+
+    | FUNC_SQRT
+    (L_BRACKET root=expr R_BRACKET)?
+    L_BRACE base=expr R_BRACE
+
+    | (FUNC_SUM | FUNC_PROD)
+    (subeq supexpr | supexpr subeq)
+    mp
+    | FUNC_LIM limit_sub mp;
 
 args: (expr ',' args) | expr;
 
 limit_sub:
-	UNDERSCORE L_BRACE (LETTER | SYMBOL) LIM_APPROACH_SYM expr (
-		CARET L_BRACE (ADD | SUB) R_BRACE
-	)? R_BRACE;
+    UNDERSCORE L_BRACE
+    (LETTER | SYMBOL)
+    LIM_APPROACH_SYM
+    expr (CARET L_BRACE (ADD | SUB) R_BRACE)?
+    R_BRACE;
 
 func_arg: expr | (expr ',' func_arg);
 func_arg_noparens: mp_nofunc;
diff --git a/sympy/parsing/latex/_antlr/latexlexer.py b/sympy/parsing/latex/_antlr/latexlexer.py
index 5e40d145c5..762565bfb9 100644
--- a/sympy/parsing/latex/_antlr/latexlexer.py
+++ b/sympy/parsing/latex/_antlr/latexlexer.py
@@ -20,7 +20,7 @@
 def serializedATN():
     with StringIO() as buf:
         buf.write(u"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2")
-        buf.write(u"Y\u0384\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4")
+        buf.write(u"P\u02e8\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4")
         buf.write(u"\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r")
         buf.write(u"\t\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")
@@ -31,390 +31,316 @@ def serializedATN():
         buf.write(u"\t\63\4\64\t\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\4")
         buf.write(u"9\t9\4:\t:\4;\t;\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA")
         buf.write(u"\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I\tI\4J\t")
-        buf.write(u"J\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S")
-        buf.write(u"\tS\4T\tT\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\3\2\3\2")
-        buf.write(u"\3\3\6\3\u00b9\n\3\r\3\16\3\u00ba\3\3\3\3\3\4\3\4\3\4")
-        buf.write(u"\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\5\4\u00cb\n\4\3")
-        buf.write(u"\4\3\4\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\5")
-        buf.write(u"\5\u00da\n\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6")
-        buf.write(u"\3\6\3\6\3\6\3\6\3\6\5\6\u00eb\n\6\3\6\3\6\3\7\3\7\3")
-        buf.write(u"\7\3\7\3\7\3\7\3\7\3\7\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3")
-        buf.write(u"\b\3\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3")
-        buf.write(u"\t\3\t\3\t\3\t\5\t\u010f\n\t\3\t\3\t\3\n\3\n\3\n\3\n")
-        buf.write(u"\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\13\3\13")
+        buf.write(u"J\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\3\2\3\2\3")
+        buf.write(u"\3\6\3\u00a7\n\3\r\3\16\3\u00a8\3\3\3\3\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\5\4\u00b9\n\4\3\4")
+        buf.write(u"\3\4\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\5\5")
+        buf.write(u"\u00c8\n\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3")
+        buf.write(u"\6\3\6\3\6\3\6\3\6\5\6\u00d9\n\6\3\6\3\6\3\7\3\7\3\7")
+        buf.write(u"\3\7\3\7\3\7\3\7\3\7\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b")
+        buf.write(u"\3\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t")
+        buf.write(u"\3\t\3\t\3\t\5\t\u00fd\n\t\3\t\3\t\3\n\3\n\3\n\3\n\3")
+        buf.write(u"\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\13\3\13")
         buf.write(u"\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3")
-        buf.write(u"\13\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3")
-        buf.write(u"\f\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\r\3\16\3\16\3\16")
-        buf.write(u"\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3")
-        buf.write(u"\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16")
-        buf.write(u"\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3")
-        buf.write(u"\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16\3\16")
-        buf.write(u"\3\16\3\16\3\16\3\16\3\16\3\16\5\16\u0177\n\16\3\16\3")
-        buf.write(u"\16\3\17\3\17\3\20\3\20\3\21\3\21\3\22\3\22\3\23\3\23")
-        buf.write(u"\3\24\3\24\3\25\3\25\3\26\3\26\3\27\3\27\3\27\3\30\3")
-        buf.write(u"\30\3\30\3\31\3\31\3\32\3\32\3\33\3\33\3\34\3\34\3\34")
-        buf.write(u"\3\34\3\34\3\34\3\34\3\34\3\35\3\35\3\35\3\35\3\35\3")
-        buf.write(u"\35\3\35\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\37")
-        buf.write(u"\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3 \3 \3 \3 \3 \3")
-        buf.write(u"!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!")
-        buf.write(u"\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3")
-        buf.write(u"!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!")
-        buf.write(u"\3!\3!\5!\u01f2\n!\3\"\3\"\3\"\3\"\3\"\3#\3#\3#\3#\3")
-        buf.write(u"#\3$\3$\3$\3$\3$\3$\3%\3%\3%\3%\3%\3&\3&\3&\3&\3&\3\'")
-        buf.write(u"\3\'\3\'\3\'\3(\3(\3(\3(\3(\3)\3)\3)\3)\3)\3*\3*\3*\3")
-        buf.write(u"*\3*\3+\3+\3+\3+\3+\3,\3,\3,\3,\3,\3-\3-\3-\3-\3-\3.")
-        buf.write(u"\3.\3.\3.\3.\3.\3.\3.\3/\3/\3/\3/\3/\3/\3/\3/\3\60\3")
-        buf.write(u"\60\3\60\3\60\3\60\3\60\3\60\3\60\3\61\3\61\3\61\3\61")
-        buf.write(u"\3\61\3\61\3\61\3\61\3\62\3\62\3\62\3\62\3\62\3\62\3")
-        buf.write(u"\62\3\62\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\63\3\64")
-        buf.write(u"\3\64\3\64\3\64\3\64\3\64\3\65\3\65\3\65\3\65\3\65\3")
-        buf.write(u"\65\3\66\3\66\3\66\3\66\3\66\3\66\3\67\3\67\3\67\3\67")
-        buf.write(u"\3\67\3\67\3\67\3\67\38\38\38\38\38\38\38\38\39\39\3")
-        buf.write(u"9\39\39\39\39\39\3:\3:\3:\3:\3:\3:\3:\3:\3;\3;\3;\3;")
-        buf.write(u"\3;\3;\3;\3;\3<\3<\3<\3<\3<\3<\3<\3=\3=\3=\3=\3=\3=\3")
-        buf.write(u"=\3>\3>\3>\3>\3>\3>\3?\3?\3?\3?\3?\3?\3?\3@\3@\3@\3@")
-        buf.write(u"\3@\3@\3A\3A\3A\3A\3A\3B\3B\3B\3B\3B\3B\3C\3C\3C\3C\3")
-        buf.write(u"C\3C\3C\3D\3D\3D\3D\3D\3D\3D\3D\3E\3E\3E\3E\3E\3E\3E")
-        buf.write(u"\3E\3F\3F\3F\3F\3F\3F\3F\3F\3G\3G\3H\3H\3I\3I\3J\3J\3")
-        buf.write(u"K\3K\7K\u02ef\nK\fK\16K\u02f2\13K\3K\3K\3K\6K\u02f7\n")
-        buf.write(u"K\rK\16K\u02f8\5K\u02fb\nK\3L\3L\3M\3M\3N\6N\u0302\n")
-        buf.write(u"N\rN\16N\u0303\3N\3N\3N\3N\3N\7N\u030b\nN\fN\16N\u030e")
-        buf.write(u"\13N\3N\7N\u0311\nN\fN\16N\u0314\13N\3N\3N\3N\3N\3N\7")
-        buf.write(u"N\u031b\nN\fN\16N\u031e\13N\3N\3N\6N\u0322\nN\rN\16N")
-        buf.write(u"\u0323\5N\u0326\nN\3O\3O\7O\u032a\nO\fO\16O\u032d\13")
-        buf.write(u"O\5O\u032f\nO\3O\3O\3O\7O\u0334\nO\fO\16O\u0337\13O\3")
-        buf.write(u"O\5O\u033a\nO\5O\u033c\nO\3P\3P\3P\3P\3P\3Q\3Q\3R\3R")
-        buf.write(u"\3R\3R\3R\3R\3R\3R\3R\5R\u034e\nR\3S\3S\3S\3S\3S\3S\3")
-        buf.write(u"T\3T\3T\3T\3T\3T\3T\3T\3T\3T\3U\3U\3V\3V\3V\3V\3V\3V")
-        buf.write(u"\3V\3V\3V\5V\u036b\nV\3W\3W\3W\3W\3W\3W\3X\3X\3X\3X\3")
-        buf.write(u"X\3X\3X\3X\3X\3X\3Y\3Y\3Z\3Z\6Z\u0381\nZ\rZ\16Z\u0382")
-        buf.write(u"\5\u02f0\u032b\u0335\2[\3\3\5\4\7\5\t\6\13\7\r\b\17\t")
-        buf.write(u"\21\n\23\13\25\f\27\r\31\16\33\17\35\20\37\21!\22#\23")
-        buf.write(u"%\24\'\25)\26+\27-\30/\31\61\32\63\33\65\34\67\359\36")
-        buf.write(u";\37= ?!A\"C#E$G%I&K\'M(O)Q*S+U,W-Y.[/]\60_\61a\62c\63")
-        buf.write(u"e\64g\65i\66k\67m8o9q:s;u<w=y>{?}@\177A\u0081B\u0083")
-        buf.write(u"C\u0085D\u0087E\u0089F\u008bG\u008dH\u008fI\u0091J\u0093")
-        buf.write(u"\2\u0095K\u0097L\u0099\2\u009bM\u009dN\u009fO\u00a1P")
-        buf.write(u"\u00a3Q\u00a5R\u00a7S\u00a9T\u00abU\u00adV\u00afW\u00b1")
-        buf.write(u"X\u00b3Y\3\2\5\5\2\13\f\17\17\"\"\4\2C\\c|\3\2\62;\2")
-        buf.write(u"\u03ab\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3\2\2\2\2\t\3\2\2")
-        buf.write(u"\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2")
-        buf.write(u"\2\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2")
-        buf.write(u"\2\33\3\2\2\2\2\35\3\2\2\2\2\37\3\2\2\2\2!\3\2\2\2\2")
-        buf.write(u"#\3\2\2\2\2%\3\2\2\2\2\'\3\2\2\2\2)\3\2\2\2\2+\3\2\2")
-        buf.write(u"\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2\2\2\2\63\3\2\2\2\2")
-        buf.write(u"\65\3\2\2\2\2\67\3\2\2\2\29\3\2\2\2\2;\3\2\2\2\2=\3\2")
-        buf.write(u"\2\2\2?\3\2\2\2\2A\3\2\2\2\2C\3\2\2\2\2E\3\2\2\2\2G\3")
-        buf.write(u"\2\2\2\2I\3\2\2\2\2K\3\2\2\2\2M\3\2\2\2\2O\3\2\2\2\2")
-        buf.write(u"Q\3\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2W\3\2\2\2\2Y\3\2\2\2")
-        buf.write(u"\2[\3\2\2\2\2]\3\2\2\2\2_\3\2\2\2\2a\3\2\2\2\2c\3\2\2")
-        buf.write(u"\2\2e\3\2\2\2\2g\3\2\2\2\2i\3\2\2\2\2k\3\2\2\2\2m\3\2")
-        buf.write(u"\2\2\2o\3\2\2\2\2q\3\2\2\2\2s\3\2\2\2\2u\3\2\2\2\2w\3")
-        buf.write(u"\2\2\2\2y\3\2\2\2\2{\3\2\2\2\2}\3\2\2\2\2\177\3\2\2\2")
-        buf.write(u"\2\u0081\3\2\2\2\2\u0083\3\2\2\2\2\u0085\3\2\2\2\2\u0087")
-        buf.write(u"\3\2\2\2\2\u0089\3\2\2\2\2\u008b\3\2\2\2\2\u008d\3\2")
-        buf.write(u"\2\2\2\u008f\3\2\2\2\2\u0091\3\2\2\2\2\u0095\3\2\2\2")
-        buf.write(u"\2\u0097\3\2\2\2\2\u009b\3\2\2\2\2\u009d\3\2\2\2\2\u009f")
-        buf.write(u"\3\2\2\2\2\u00a1\3\2\2\2\2\u00a3\3\2\2\2\2\u00a5\3\2")
-        buf.write(u"\2\2\2\u00a7\3\2\2\2\2\u00a9\3\2\2\2\2\u00ab\3\2\2\2")
-        buf.write(u"\2\u00ad\3\2\2\2\2\u00af\3\2\2\2\2\u00b1\3\2\2\2\2\u00b3")
-        buf.write(u"\3\2\2\2\3\u00b5\3\2\2\2\5\u00b8\3\2\2\2\7\u00ca\3\2")
-        buf.write(u"\2\2\t\u00d9\3\2\2\2\13\u00ea\3\2\2\2\r\u00ee\3\2\2\2")
-        buf.write(u"\17\u00f6\3\2\2\2\21\u010e\3\2\2\2\23\u0112\3\2\2\2\25")
-        buf.write(u"\u0121\3\2\2\2\27\u0132\3\2\2\2\31\u013a\3\2\2\2\33\u0176")
-        buf.write(u"\3\2\2\2\35\u017a\3\2\2\2\37\u017c\3\2\2\2!\u017e\3\2")
-        buf.write(u"\2\2#\u0180\3\2\2\2%\u0182\3\2\2\2\'\u0184\3\2\2\2)\u0186")
-        buf.write(u"\3\2\2\2+\u0188\3\2\2\2-\u018a\3\2\2\2/\u018d\3\2\2\2")
-        buf.write(u"\61\u0190\3\2\2\2\63\u0192\3\2\2\2\65\u0194\3\2\2\2\67")
-        buf.write(u"\u0196\3\2\2\29\u019e\3\2\2\2;\u01a5\3\2\2\2=\u01ad\3")
-        buf.write(u"\2\2\2?\u01b5\3\2\2\2A\u01f1\3\2\2\2C\u01f3\3\2\2\2E")
-        buf.write(u"\u01f8\3\2\2\2G\u01fd\3\2\2\2I\u0203\3\2\2\2K\u0208\3")
-        buf.write(u"\2\2\2M\u020d\3\2\2\2O\u0211\3\2\2\2Q\u0216\3\2\2\2S")
-        buf.write(u"\u021b\3\2\2\2U\u0220\3\2\2\2W\u0225\3\2\2\2Y\u022a\3")
-        buf.write(u"\2\2\2[\u022f\3\2\2\2]\u0237\3\2\2\2_\u023f\3\2\2\2a")
-        buf.write(u"\u0247\3\2\2\2c\u024f\3\2\2\2e\u0257\3\2\2\2g\u025f\3")
-        buf.write(u"\2\2\2i\u0265\3\2\2\2k\u026b\3\2\2\2m\u0271\3\2\2\2o")
-        buf.write(u"\u0279\3\2\2\2q\u0281\3\2\2\2s\u0289\3\2\2\2u\u0291\3")
-        buf.write(u"\2\2\2w\u0299\3\2\2\2y\u02a0\3\2\2\2{\u02a7\3\2\2\2}")
-        buf.write(u"\u02ad\3\2\2\2\177\u02b4\3\2\2\2\u0081\u02ba\3\2\2\2")
-        buf.write(u"\u0083\u02bf\3\2\2\2\u0085\u02c5\3\2\2\2\u0087\u02cc")
-        buf.write(u"\3\2\2\2\u0089\u02d4\3\2\2\2\u008b\u02dc\3\2\2\2\u008d")
-        buf.write(u"\u02e4\3\2\2\2\u008f\u02e6\3\2\2\2\u0091\u02e8\3\2\2")
-        buf.write(u"\2\u0093\u02ea\3\2\2\2\u0095\u02ec\3\2\2\2\u0097\u02fc")
-        buf.write(u"\3\2\2\2\u0099\u02fe\3\2\2\2\u009b\u0325\3\2\2\2\u009d")
-        buf.write(u"\u033b\3\2\2\2\u009f\u033d\3\2\2\2\u00a1\u0342\3\2\2")
-        buf.write(u"\2\u00a3\u034d\3\2\2\2\u00a5\u034f\3\2\2\2\u00a7\u0355")
-        buf.write(u"\3\2\2\2\u00a9\u035f\3\2\2\2\u00ab\u036a\3\2\2\2\u00ad")
-        buf.write(u"\u036c\3\2\2\2\u00af\u0372\3\2\2\2\u00b1\u037c\3\2\2")
-        buf.write(u"\2\u00b3\u037e\3\2\2\2\u00b5\u00b6\7.\2\2\u00b6\4\3\2")
-        buf.write(u"\2\2\u00b7\u00b9\t\2\2\2\u00b8\u00b7\3\2\2\2\u00b9\u00ba")
-        buf.write(u"\3\2\2\2\u00ba\u00b8\3\2\2\2\u00ba\u00bb\3\2\2\2\u00bb")
-        buf.write(u"\u00bc\3\2\2\2\u00bc\u00bd\b\3\2\2\u00bd\6\3\2\2\2\u00be")
-        buf.write(u"\u00bf\7^\2\2\u00bf\u00cb\7.\2\2\u00c0\u00c1\7^\2\2\u00c1")
-        buf.write(u"\u00c2\7v\2\2\u00c2\u00c3\7j\2\2\u00c3\u00c4\7k\2\2\u00c4")
-        buf.write(u"\u00c5\7p\2\2\u00c5\u00c6\7u\2\2\u00c6\u00c7\7r\2\2\u00c7")
-        buf.write(u"\u00c8\7c\2\2\u00c8\u00c9\7e\2\2\u00c9\u00cb\7g\2\2\u00ca")
-        buf.write(u"\u00be\3\2\2\2\u00ca\u00c0\3\2\2\2\u00cb\u00cc\3\2\2")
-        buf.write(u"\2\u00cc\u00cd\b\4\2\2\u00cd\b\3\2\2\2\u00ce\u00cf\7")
-        buf.write(u"^\2\2\u00cf\u00da\7<\2\2\u00d0\u00d1\7^\2\2\u00d1\u00d2")
-        buf.write(u"\7o\2\2\u00d2\u00d3\7g\2\2\u00d3\u00d4\7f\2\2\u00d4\u00d5")
-        buf.write(u"\7u\2\2\u00d5\u00d6\7r\2\2\u00d6\u00d7\7c\2\2\u00d7\u00d8")
-        buf.write(u"\7e\2\2\u00d8\u00da\7g\2\2\u00d9\u00ce\3\2\2\2\u00d9")
-        buf.write(u"\u00d0\3\2\2\2\u00da\u00db\3\2\2\2\u00db\u00dc\b\5\2")
-        buf.write(u"\2\u00dc\n\3\2\2\2\u00dd\u00de\7^\2\2\u00de\u00eb\7=")
-        buf.write(u"\2\2\u00df\u00e0\7^\2\2\u00e0\u00e1\7v\2\2\u00e1\u00e2")
-        buf.write(u"\7j\2\2\u00e2\u00e3\7k\2\2\u00e3\u00e4\7e\2\2\u00e4\u00e5")
-        buf.write(u"\7m\2\2\u00e5\u00e6\7u\2\2\u00e6\u00e7\7r\2\2\u00e7\u00e8")
-        buf.write(u"\7c\2\2\u00e8\u00e9\7e\2\2\u00e9\u00eb\7g\2\2\u00ea\u00dd")
-        buf.write(u"\3\2\2\2\u00ea\u00df\3\2\2\2\u00eb\u00ec\3\2\2\2\u00ec")
-        buf.write(u"\u00ed\b\6\2\2\u00ed\f\3\2\2\2\u00ee\u00ef\7^\2\2\u00ef")
-        buf.write(u"\u00f0\7s\2\2\u00f0\u00f1\7w\2\2\u00f1\u00f2\7c\2\2\u00f2")
-        buf.write(u"\u00f3\7f\2\2\u00f3\u00f4\3\2\2\2\u00f4\u00f5\b\7\2\2")
-        buf.write(u"\u00f5\16\3\2\2\2\u00f6\u00f7\7^\2\2\u00f7\u00f8\7s\2")
-        buf.write(u"\2\u00f8\u00f9\7s\2\2\u00f9\u00fa\7w\2\2\u00fa\u00fb")
-        buf.write(u"\7c\2\2\u00fb\u00fc\7f\2\2\u00fc\u00fd\3\2\2\2\u00fd")
-        buf.write(u"\u00fe\b\b\2\2\u00fe\20\3\2\2\2\u00ff\u0100\7^\2\2\u0100")
-        buf.write(u"\u010f\7#\2\2\u0101\u0102\7^\2\2\u0102\u0103\7p\2\2\u0103")
-        buf.write(u"\u0104\7g\2\2\u0104\u0105\7i\2\2\u0105\u0106\7v\2\2\u0106")
-        buf.write(u"\u0107\7j\2\2\u0107\u0108\7k\2\2\u0108\u0109\7p\2\2\u0109")
-        buf.write(u"\u010a\7u\2\2\u010a\u010b\7r\2\2\u010b\u010c\7c\2\2\u010c")
-        buf.write(u"\u010d\7e\2\2\u010d\u010f\7g\2\2\u010e\u00ff\3\2\2\2")
-        buf.write(u"\u010e\u0101\3\2\2\2\u010f\u0110\3\2\2\2\u0110\u0111")
-        buf.write(u"\b\t\2\2\u0111\22\3\2\2\2\u0112\u0113\7^\2\2\u0113\u0114")
-        buf.write(u"\7p\2\2\u0114\u0115\7g\2\2\u0115\u0116\7i\2\2\u0116\u0117")
-        buf.write(u"\7o\2\2\u0117\u0118\7g\2\2\u0118\u0119\7f\2\2\u0119\u011a")
-        buf.write(u"\7u\2\2\u011a\u011b\7r\2\2\u011b\u011c\7c\2\2\u011c\u011d")
-        buf.write(u"\7e\2\2\u011d\u011e\7g\2\2\u011e\u011f\3\2\2\2\u011f")
-        buf.write(u"\u0120\b\n\2\2\u0120\24\3\2\2\2\u0121\u0122\7^\2\2\u0122")
-        buf.write(u"\u0123\7p\2\2\u0123\u0124\7g\2\2\u0124\u0125\7i\2\2\u0125")
-        buf.write(u"\u0126\7v\2\2\u0126\u0127\7j\2\2\u0127\u0128\7k\2\2\u0128")
-        buf.write(u"\u0129\7e\2\2\u0129\u012a\7m\2\2\u012a\u012b\7u\2\2\u012b")
-        buf.write(u"\u012c\7r\2\2\u012c\u012d\7c\2\2\u012d\u012e\7e\2\2\u012e")
-        buf.write(u"\u012f\7g\2\2\u012f\u0130\3\2\2\2\u0130\u0131\b\13\2")
-        buf.write(u"\2\u0131\26\3\2\2\2\u0132\u0133\7^\2\2\u0133\u0134\7")
-        buf.write(u"n\2\2\u0134\u0135\7g\2\2\u0135\u0136\7h\2\2\u0136\u0137")
-        buf.write(u"\7v\2\2\u0137\u0138\3\2\2\2\u0138\u0139\b\f\2\2\u0139")
-        buf.write(u"\30\3\2\2\2\u013a\u013b\7^\2\2\u013b\u013c\7t\2\2\u013c")
-        buf.write(u"\u013d\7k\2\2\u013d\u013e\7i\2\2\u013e\u013f\7j\2\2\u013f")
-        buf.write(u"\u0140\7v\2\2\u0140\u0141\3\2\2\2\u0141\u0142\b\r\2\2")
-        buf.write(u"\u0142\32\3\2\2\2\u0143\u0144\7^\2\2\u0144\u0145\7x\2")
-        buf.write(u"\2\u0145\u0146\7t\2\2\u0146\u0147\7w\2\2\u0147\u0148")
-        buf.write(u"\7n\2\2\u0148\u0177\7g\2\2\u0149\u014a\7^\2\2\u014a\u014b")
-        buf.write(u"\7x\2\2\u014b\u014c\7e\2\2\u014c\u014d\7g\2\2\u014d\u014e")
-        buf.write(u"\7p\2\2\u014e\u014f\7v\2\2\u014f\u0150\7g\2\2\u0150\u0177")
-        buf.write(u"\7t\2\2\u0151\u0152\7^\2\2\u0152\u0153\7x\2\2\u0153\u0154")
-        buf.write(u"\7d\2\2\u0154\u0155\7q\2\2\u0155\u0177\7z\2\2\u0156\u0157")
-        buf.write(u"\7^\2\2\u0157\u0158\7x\2\2\u0158\u0159\7u\2\2\u0159\u015a")
-        buf.write(u"\7m\2\2\u015a\u015b\7k\2\2\u015b\u0177\7r\2\2\u015c\u015d")
-        buf.write(u"\7^\2\2\u015d\u015e\7x\2\2\u015e\u015f\7u\2\2\u015f\u0160")
-        buf.write(u"\7r\2\2\u0160\u0161\7c\2\2\u0161\u0162\7e\2\2\u0162\u0177")
-        buf.write(u"\7g\2\2\u0163\u0164\7^\2\2\u0164\u0165\7j\2\2\u0165\u0166")
-        buf.write(u"\7h\2\2\u0166\u0167\7k\2\2\u0167\u0177\7n\2\2\u0168\u0169")
-        buf.write(u"\7^\2\2\u0169\u0177\7,\2\2\u016a\u016b\7^\2\2\u016b\u0177")
-        buf.write(u"\7/\2\2\u016c\u016d\7^\2\2\u016d\u0177\7\60\2\2\u016e")
-        buf.write(u"\u016f\7^\2\2\u016f\u0177\7\61\2\2\u0170\u0171\7^\2\2")
-        buf.write(u"\u0171\u0177\7$\2\2\u0172\u0173\7^\2\2\u0173\u0177\7")
-        buf.write(u"*\2\2\u0174\u0175\7^\2\2\u0175\u0177\7?\2\2\u0176\u0143")
-        buf.write(u"\3\2\2\2\u0176\u0149\3\2\2\2\u0176\u0151\3\2\2\2\u0176")
-        buf.write(u"\u0156\3\2\2\2\u0176\u015c\3\2\2\2\u0176\u0163\3\2\2")
-        buf.write(u"\2\u0176\u0168\3\2\2\2\u0176\u016a\3\2\2\2\u0176\u016c")
-        buf.write(u"\3\2\2\2\u0176\u016e\3\2\2\2\u0176\u0170\3\2\2\2\u0176")
-        buf.write(u"\u0172\3\2\2\2\u0176\u0174\3\2\2\2\u0177\u0178\3\2\2")
-        buf.write(u"\2\u0178\u0179\b\16\2\2\u0179\34\3\2\2\2\u017a\u017b")
-        buf.write(u"\7-\2\2\u017b\36\3\2\2\2\u017c\u017d\7/\2\2\u017d \3")
-        buf.write(u"\2\2\2\u017e\u017f\7,\2\2\u017f\"\3\2\2\2\u0180\u0181")
-        buf.write(u"\7\61\2\2\u0181$\3\2\2\2\u0182\u0183\7*\2\2\u0183&\3")
-        buf.write(u"\2\2\2\u0184\u0185\7+\2\2\u0185(\3\2\2\2\u0186\u0187")
-        buf.write(u"\7}\2\2\u0187*\3\2\2\2\u0188\u0189\7\177\2\2\u0189,\3")
-        buf.write(u"\2\2\2\u018a\u018b\7^\2\2\u018b\u018c\7}\2\2\u018c.\3")
-        buf.write(u"\2\2\2\u018d\u018e\7^\2\2\u018e\u018f\7\177\2\2\u018f")
-        buf.write(u"\60\3\2\2\2\u0190\u0191\7]\2\2\u0191\62\3\2\2\2\u0192")
-        buf.write(u"\u0193\7_\2\2\u0193\64\3\2\2\2\u0194\u0195\7~\2\2\u0195")
-        buf.write(u"\66\3\2\2\2\u0196\u0197\7^\2\2\u0197\u0198\7t\2\2\u0198")
-        buf.write(u"\u0199\7k\2\2\u0199\u019a\7i\2\2\u019a\u019b\7j\2\2\u019b")
-        buf.write(u"\u019c\7v\2\2\u019c\u019d\7~\2\2\u019d8\3\2\2\2\u019e")
-        buf.write(u"\u019f\7^\2\2\u019f\u01a0\7n\2\2\u01a0\u01a1\7g\2\2\u01a1")
-        buf.write(u"\u01a2\7h\2\2\u01a2\u01a3\7v\2\2\u01a3\u01a4\7~\2\2\u01a4")
-        buf.write(u":\3\2\2\2\u01a5\u01a6\7^\2\2\u01a6\u01a7\7n\2\2\u01a7")
-        buf.write(u"\u01a8\7c\2\2\u01a8\u01a9\7p\2\2\u01a9\u01aa\7i\2\2\u01aa")
-        buf.write(u"\u01ab\7n\2\2\u01ab\u01ac\7g\2\2\u01ac<\3\2\2\2\u01ad")
-        buf.write(u"\u01ae\7^\2\2\u01ae\u01af\7t\2\2\u01af\u01b0\7c\2\2\u01b0")
-        buf.write(u"\u01b1\7p\2\2\u01b1\u01b2\7i\2\2\u01b2\u01b3\7n\2\2\u01b3")
-        buf.write(u"\u01b4\7g\2\2\u01b4>\3\2\2\2\u01b5\u01b6\7^\2\2\u01b6")
-        buf.write(u"\u01b7\7n\2\2\u01b7\u01b8\7k\2\2\u01b8\u01b9\7o\2\2\u01b9")
-        buf.write(u"@\3\2\2\2\u01ba\u01bb\7^\2\2\u01bb\u01bc\7v\2\2\u01bc")
-        buf.write(u"\u01f2\7q\2\2\u01bd\u01be\7^\2\2\u01be\u01bf\7t\2\2\u01bf")
-        buf.write(u"\u01c0\7k\2\2\u01c0\u01c1\7i\2\2\u01c1\u01c2\7j\2\2\u01c2")
-        buf.write(u"\u01c3\7v\2\2\u01c3\u01c4\7c\2\2\u01c4\u01c5\7t\2\2\u01c5")
-        buf.write(u"\u01c6\7t\2\2\u01c6\u01c7\7q\2\2\u01c7\u01f2\7y\2\2\u01c8")
-        buf.write(u"\u01c9\7^\2\2\u01c9\u01ca\7T\2\2\u01ca\u01cb\7k\2\2\u01cb")
-        buf.write(u"\u01cc\7i\2\2\u01cc\u01cd\7j\2\2\u01cd\u01ce\7v\2\2\u01ce")
-        buf.write(u"\u01cf\7c\2\2\u01cf\u01d0\7t\2\2\u01d0\u01d1\7t\2\2\u01d1")
-        buf.write(u"\u01d2\7q\2\2\u01d2\u01f2\7y\2\2\u01d3\u01d4\7^\2\2\u01d4")
-        buf.write(u"\u01d5\7n\2\2\u01d5\u01d6\7q\2\2\u01d6\u01d7\7p\2\2\u01d7")
-        buf.write(u"\u01d8\7i\2\2\u01d8\u01d9\7t\2\2\u01d9\u01da\7k\2\2\u01da")
-        buf.write(u"\u01db\7i\2\2\u01db\u01dc\7j\2\2\u01dc\u01dd\7v\2\2\u01dd")
-        buf.write(u"\u01de\7c\2\2\u01de\u01df\7t\2\2\u01df\u01e0\7t\2\2\u01e0")
-        buf.write(u"\u01e1\7q\2\2\u01e1\u01f2\7y\2\2\u01e2\u01e3\7^\2\2\u01e3")
-        buf.write(u"\u01e4\7N\2\2\u01e4\u01e5\7q\2\2\u01e5\u01e6\7p\2\2\u01e6")
-        buf.write(u"\u01e7\7i\2\2\u01e7\u01e8\7t\2\2\u01e8\u01e9\7k\2\2\u01e9")
-        buf.write(u"\u01ea\7i\2\2\u01ea\u01eb\7j\2\2\u01eb\u01ec\7v\2\2\u01ec")
-        buf.write(u"\u01ed\7c\2\2\u01ed\u01ee\7t\2\2\u01ee\u01ef\7t\2\2\u01ef")
-        buf.write(u"\u01f0\7q\2\2\u01f0\u01f2\7y\2\2\u01f1\u01ba\3\2\2\2")
-        buf.write(u"\u01f1\u01bd\3\2\2\2\u01f1\u01c8\3\2\2\2\u01f1\u01d3")
-        buf.write(u"\3\2\2\2\u01f1\u01e2\3\2\2\2\u01f2B\3\2\2\2\u01f3\u01f4")
-        buf.write(u"\7^\2\2\u01f4\u01f5\7k\2\2\u01f5\u01f6\7p\2\2\u01f6\u01f7")
-        buf.write(u"\7v\2\2\u01f7D\3\2\2\2\u01f8\u01f9\7^\2\2\u01f9\u01fa")
-        buf.write(u"\7u\2\2\u01fa\u01fb\7w\2\2\u01fb\u01fc\7o\2\2\u01fcF")
-        buf.write(u"\3\2\2\2\u01fd\u01fe\7^\2\2\u01fe\u01ff\7r\2\2\u01ff")
-        buf.write(u"\u0200\7t\2\2\u0200\u0201\7q\2\2\u0201\u0202\7f\2\2\u0202")
-        buf.write(u"H\3\2\2\2\u0203\u0204\7^\2\2\u0204\u0205\7g\2\2\u0205")
-        buf.write(u"\u0206\7z\2\2\u0206\u0207\7r\2\2\u0207J\3\2\2\2\u0208")
-        buf.write(u"\u0209\7^\2\2\u0209\u020a\7n\2\2\u020a\u020b\7q\2\2\u020b")
-        buf.write(u"\u020c\7i\2\2\u020cL\3\2\2\2\u020d\u020e\7^\2\2\u020e")
-        buf.write(u"\u020f\7n\2\2\u020f\u0210\7p\2\2\u0210N\3\2\2\2\u0211")
-        buf.write(u"\u0212\7^\2\2\u0212\u0213\7u\2\2\u0213\u0214\7k\2\2\u0214")
-        buf.write(u"\u0215\7p\2\2\u0215P\3\2\2\2\u0216\u0217\7^\2\2\u0217")
-        buf.write(u"\u0218\7e\2\2\u0218\u0219\7q\2\2\u0219\u021a\7u\2\2\u021a")
-        buf.write(u"R\3\2\2\2\u021b\u021c\7^\2\2\u021c\u021d\7v\2\2\u021d")
-        buf.write(u"\u021e\7c\2\2\u021e\u021f\7p\2\2\u021fT\3\2\2\2\u0220")
-        buf.write(u"\u0221\7^\2\2\u0221\u0222\7e\2\2\u0222\u0223\7u\2\2\u0223")
-        buf.write(u"\u0224\7e\2\2\u0224V\3\2\2\2\u0225\u0226\7^\2\2\u0226")
-        buf.write(u"\u0227\7u\2\2\u0227\u0228\7g\2\2\u0228\u0229\7e\2\2\u0229")
-        buf.write(u"X\3\2\2\2\u022a\u022b\7^\2\2\u022b\u022c\7e\2\2\u022c")
-        buf.write(u"\u022d\7q\2\2\u022d\u022e\7v\2\2\u022eZ\3\2\2\2\u022f")
-        buf.write(u"\u0230\7^\2\2\u0230\u0231\7c\2\2\u0231\u0232\7t\2\2\u0232")
-        buf.write(u"\u0233\7e\2\2\u0233\u0234\7u\2\2\u0234\u0235\7k\2\2\u0235")
-        buf.write(u"\u0236\7p\2\2\u0236\\\3\2\2\2\u0237\u0238\7^\2\2\u0238")
-        buf.write(u"\u0239\7c\2\2\u0239\u023a\7t\2\2\u023a\u023b\7e\2\2\u023b")
-        buf.write(u"\u023c\7e\2\2\u023c\u023d\7q\2\2\u023d\u023e\7u\2\2\u023e")
-        buf.write(u"^\3\2\2\2\u023f\u0240\7^\2\2\u0240\u0241\7c\2\2\u0241")
-        buf.write(u"\u0242\7t\2\2\u0242\u0243\7e\2\2\u0243\u0244\7v\2\2\u0244")
-        buf.write(u"\u0245\7c\2\2\u0245\u0246\7p\2\2\u0246`\3\2\2\2\u0247")
-        buf.write(u"\u0248\7^\2\2\u0248\u0249\7c\2\2\u0249\u024a\7t\2\2\u024a")
-        buf.write(u"\u024b\7e\2\2\u024b\u024c\7e\2\2\u024c\u024d\7u\2\2\u024d")
-        buf.write(u"\u024e\7e\2\2\u024eb\3\2\2\2\u024f\u0250\7^\2\2\u0250")
-        buf.write(u"\u0251\7c\2\2\u0251\u0252\7t\2\2\u0252\u0253\7e\2\2\u0253")
-        buf.write(u"\u0254\7u\2\2\u0254\u0255\7g\2\2\u0255\u0256\7e\2\2\u0256")
-        buf.write(u"d\3\2\2\2\u0257\u0258\7^\2\2\u0258\u0259\7c\2\2\u0259")
-        buf.write(u"\u025a\7t\2\2\u025a\u025b\7e\2\2\u025b\u025c\7e\2\2\u025c")
-        buf.write(u"\u025d\7q\2\2\u025d\u025e\7v\2\2\u025ef\3\2\2\2\u025f")
-        buf.write(u"\u0260\7^\2\2\u0260\u0261\7u\2\2\u0261\u0262\7k\2\2\u0262")
-        buf.write(u"\u0263\7p\2\2\u0263\u0264\7j\2\2\u0264h\3\2\2\2\u0265")
-        buf.write(u"\u0266\7^\2\2\u0266\u0267\7e\2\2\u0267\u0268\7q\2\2\u0268")
-        buf.write(u"\u0269\7u\2\2\u0269\u026a\7j\2\2\u026aj\3\2\2\2\u026b")
-        buf.write(u"\u026c\7^\2\2\u026c\u026d\7v\2\2\u026d\u026e\7c\2\2\u026e")
-        buf.write(u"\u026f\7p\2\2\u026f\u0270\7j\2\2\u0270l\3\2\2\2\u0271")
-        buf.write(u"\u0272\7^\2\2\u0272\u0273\7c\2\2\u0273\u0274\7t\2\2\u0274")
-        buf.write(u"\u0275\7u\2\2\u0275\u0276\7k\2\2\u0276\u0277\7p\2\2\u0277")
-        buf.write(u"\u0278\7j\2\2\u0278n\3\2\2\2\u0279\u027a\7^\2\2\u027a")
-        buf.write(u"\u027b\7c\2\2\u027b\u027c\7t\2\2\u027c\u027d\7e\2\2\u027d")
-        buf.write(u"\u027e\7q\2\2\u027e\u027f\7u\2\2\u027f\u0280\7j\2\2\u0280")
-        buf.write(u"p\3\2\2\2\u0281\u0282\7^\2\2\u0282\u0283\7c\2\2\u0283")
-        buf.write(u"\u0284\7t\2\2\u0284\u0285\7v\2\2\u0285\u0286\7c\2\2\u0286")
-        buf.write(u"\u0287\7p\2\2\u0287\u0288\7j\2\2\u0288r\3\2\2\2\u0289")
-        buf.write(u"\u028a\7^\2\2\u028a\u028b\7n\2\2\u028b\u028c\7h\2\2\u028c")
-        buf.write(u"\u028d\7n\2\2\u028d\u028e\7q\2\2\u028e\u028f\7q\2\2\u028f")
-        buf.write(u"\u0290\7t\2\2\u0290t\3\2\2\2\u0291\u0292\7^\2\2\u0292")
-        buf.write(u"\u0293\7t\2\2\u0293\u0294\7h\2\2\u0294\u0295\7n\2\2\u0295")
-        buf.write(u"\u0296\7q\2\2\u0296\u0297\7q\2\2\u0297\u0298\7t\2\2\u0298")
-        buf.write(u"v\3\2\2\2\u0299\u029a\7^\2\2\u029a\u029b\7n\2\2\u029b")
-        buf.write(u"\u029c\7e\2\2\u029c\u029d\7g\2\2\u029d\u029e\7k\2\2\u029e")
-        buf.write(u"\u029f\7n\2\2\u029fx\3\2\2\2\u02a0\u02a1\7^\2\2\u02a1")
-        buf.write(u"\u02a2\7t\2\2\u02a2\u02a3\7e\2\2\u02a3\u02a4\7g\2\2\u02a4")
-        buf.write(u"\u02a5\7k\2\2\u02a5\u02a6\7n\2\2\u02a6z\3\2\2\2\u02a7")
-        buf.write(u"\u02a8\7^\2\2\u02a8\u02a9\7u\2\2\u02a9\u02aa\7s\2\2\u02aa")
-        buf.write(u"\u02ab\7t\2\2\u02ab\u02ac\7v\2\2\u02ac|\3\2\2\2\u02ad")
-        buf.write(u"\u02ae\7^\2\2\u02ae\u02af\7v\2\2\u02af\u02b0\7k\2\2\u02b0")
-        buf.write(u"\u02b1\7o\2\2\u02b1\u02b2\7g\2\2\u02b2\u02b3\7u\2\2\u02b3")
-        buf.write(u"~\3\2\2\2\u02b4\u02b5\7^\2\2\u02b5\u02b6\7e\2\2\u02b6")
-        buf.write(u"\u02b7\7f\2\2\u02b7\u02b8\7q\2\2\u02b8\u02b9\7v\2\2\u02b9")
-        buf.write(u"\u0080\3\2\2\2\u02ba\u02bb\7^\2\2\u02bb\u02bc\7f\2\2")
-        buf.write(u"\u02bc\u02bd\7k\2\2\u02bd\u02be\7x\2\2\u02be\u0082\3")
-        buf.write(u"\2\2\2\u02bf\u02c0\7^\2\2\u02c0\u02c1\7h\2\2\u02c1\u02c2")
-        buf.write(u"\7t\2\2\u02c2\u02c3\7c\2\2\u02c3\u02c4\7e\2\2\u02c4\u0084")
-        buf.write(u"\3\2\2\2\u02c5\u02c6\7^\2\2\u02c6\u02c7\7d\2\2\u02c7")
-        buf.write(u"\u02c8\7k\2\2\u02c8\u02c9\7p\2\2\u02c9\u02ca\7q\2\2\u02ca")
-        buf.write(u"\u02cb\7o\2\2\u02cb\u0086\3\2\2\2\u02cc\u02cd\7^\2\2")
-        buf.write(u"\u02cd\u02ce\7f\2\2\u02ce\u02cf\7d\2\2\u02cf\u02d0\7")
-        buf.write(u"k\2\2\u02d0\u02d1\7p\2\2\u02d1\u02d2\7q\2\2\u02d2\u02d3")
-        buf.write(u"\7o\2\2\u02d3\u0088\3\2\2\2\u02d4\u02d5\7^\2\2\u02d5")
-        buf.write(u"\u02d6\7v\2\2\u02d6\u02d7\7d\2\2\u02d7\u02d8\7k\2\2\u02d8")
-        buf.write(u"\u02d9\7p\2\2\u02d9\u02da\7q\2\2\u02da\u02db\7o\2\2\u02db")
-        buf.write(u"\u008a\3\2\2\2\u02dc\u02dd\7^\2\2\u02dd\u02de\7o\2\2")
-        buf.write(u"\u02de\u02df\7c\2\2\u02df\u02e0\7v\2\2\u02e0\u02e1\7")
-        buf.write(u"j\2\2\u02e1\u02e2\7k\2\2\u02e2\u02e3\7v\2\2\u02e3\u008c")
-        buf.write(u"\3\2\2\2\u02e4\u02e5\7a\2\2\u02e5\u008e\3\2\2\2\u02e6")
-        buf.write(u"\u02e7\7`\2\2\u02e7\u0090\3\2\2\2\u02e8\u02e9\7<\2\2")
-        buf.write(u"\u02e9\u0092\3\2\2\2\u02ea\u02eb\t\2\2\2\u02eb\u0094")
-        buf.write(u"\3\2\2\2\u02ec\u02f0\7f\2\2\u02ed\u02ef\5\u0093J\2\u02ee")
-        buf.write(u"\u02ed\3\2\2\2\u02ef\u02f2\3\2\2\2\u02f0\u02f1\3\2\2")
-        buf.write(u"\2\u02f0\u02ee\3\2\2\2\u02f1\u02fa\3\2\2\2\u02f2\u02f0")
-        buf.write(u"\3\2\2\2\u02f3\u02fb\t\3\2\2\u02f4\u02f6\7^\2\2\u02f5")
-        buf.write(u"\u02f7\t\3\2\2\u02f6\u02f5\3\2\2\2\u02f7\u02f8\3\2\2")
-        buf.write(u"\2\u02f8\u02f6\3\2\2\2\u02f8\u02f9\3\2\2\2\u02f9\u02fb")
-        buf.write(u"\3\2\2\2\u02fa\u02f3\3\2\2\2\u02fa\u02f4\3\2\2\2\u02fb")
-        buf.write(u"\u0096\3\2\2\2\u02fc\u02fd\t\3\2\2\u02fd\u0098\3\2\2")
-        buf.write(u"\2\u02fe\u02ff\t\4\2\2\u02ff\u009a\3\2\2\2\u0300\u0302")
-        buf.write(u"\5\u0099M\2\u0301\u0300\3\2\2\2\u0302\u0303\3\2\2\2\u0303")
-        buf.write(u"\u0301\3\2\2\2\u0303\u0304\3\2\2\2\u0304\u030c\3\2\2")
-        buf.write(u"\2\u0305\u0306\7.\2\2\u0306\u0307\5\u0099M\2\u0307\u0308")
-        buf.write(u"\5\u0099M\2\u0308\u0309\5\u0099M\2\u0309\u030b\3\2\2")
-        buf.write(u"\2\u030a\u0305\3\2\2\2\u030b\u030e\3\2\2\2\u030c\u030a")
-        buf.write(u"\3\2\2\2\u030c\u030d\3\2\2\2\u030d\u0326\3\2\2\2\u030e")
-        buf.write(u"\u030c\3\2\2\2\u030f\u0311\5\u0099M\2\u0310\u030f\3\2")
-        buf.write(u"\2\2\u0311\u0314\3\2\2\2\u0312\u0310\3\2\2\2\u0312\u0313")
-        buf.write(u"\3\2\2\2\u0313\u031c\3\2\2\2\u0314\u0312\3\2\2\2\u0315")
-        buf.write(u"\u0316\7.\2\2\u0316\u0317\5\u0099M\2\u0317\u0318\5\u0099")
-        buf.write(u"M\2\u0318\u0319\5\u0099M\2\u0319\u031b\3\2\2\2\u031a")
-        buf.write(u"\u0315\3\2\2\2\u031b\u031e\3\2\2\2\u031c\u031a\3\2\2")
-        buf.write(u"\2\u031c\u031d\3\2\2\2\u031d\u031f\3\2\2\2\u031e\u031c")
-        buf.write(u"\3\2\2\2\u031f\u0321\7\60\2\2\u0320\u0322\5\u0099M\2")
-        buf.write(u"\u0321\u0320\3\2\2\2\u0322\u0323\3\2\2\2\u0323\u0321")
-        buf.write(u"\3\2\2\2\u0323\u0324\3\2\2\2\u0324\u0326\3\2\2\2\u0325")
-        buf.write(u"\u0301\3\2\2\2\u0325\u0312\3\2\2\2\u0326\u009c\3\2\2")
-        buf.write(u"\2\u0327\u032b\7(\2\2\u0328\u032a\5\u0093J\2\u0329\u0328")
-        buf.write(u"\3\2\2\2\u032a\u032d\3\2\2\2\u032b\u032c\3\2\2\2\u032b")
-        buf.write(u"\u0329\3\2\2\2\u032c\u032f\3\2\2\2\u032d\u032b\3\2\2")
-        buf.write(u"\2\u032e\u0327\3\2\2\2\u032e\u032f\3\2\2\2\u032f\u0330")
-        buf.write(u"\3\2\2\2\u0330\u033c\7?\2\2\u0331\u0339\7?\2\2\u0332")
-        buf.write(u"\u0334\5\u0093J\2\u0333\u0332\3\2\2\2\u0334\u0337\3\2")
-        buf.write(u"\2\2\u0335\u0336\3\2\2\2\u0335\u0333\3\2\2\2\u0336\u0338")
-        buf.write(u"\3\2\2\2\u0337\u0335\3\2\2\2\u0338\u033a\7(\2\2\u0339")
-        buf.write(u"\u0335\3\2\2\2\u0339\u033a\3\2\2\2\u033a\u033c\3\2\2")
-        buf.write(u"\2\u033b\u032e\3\2\2\2\u033b\u0331\3\2\2\2\u033c\u009e")
-        buf.write(u"\3\2\2\2\u033d\u033e\7^\2\2\u033e\u033f\7p\2\2\u033f")
-        buf.write(u"\u0340\7g\2\2\u0340\u0341\7s\2\2\u0341\u00a0\3\2\2\2")
-        buf.write(u"\u0342\u0343\7>\2\2\u0343\u00a2\3\2\2\2\u0344\u0345\7")
-        buf.write(u"^\2\2\u0345\u0346\7n\2\2\u0346\u0347\7g\2\2\u0347\u034e")
-        buf.write(u"\7s\2\2\u0348\u0349\7^\2\2\u0349\u034a\7n\2\2\u034a\u034e")
-        buf.write(u"\7g\2\2\u034b\u034e\5\u00a5S\2\u034c\u034e\5\u00a7T\2")
-        buf.write(u"\u034d\u0344\3\2\2\2\u034d\u0348\3\2\2\2\u034d\u034b")
-        buf.write(u"\3\2\2\2\u034d\u034c\3\2\2\2\u034e\u00a4\3\2\2\2\u034f")
-        buf.write(u"\u0350\7^\2\2\u0350\u0351\7n\2\2\u0351\u0352\7g\2\2\u0352")
-        buf.write(u"\u0353\7s\2\2\u0353\u0354\7s\2\2\u0354\u00a6\3\2\2\2")
-        buf.write(u"\u0355\u0356\7^\2\2\u0356\u0357\7n\2\2\u0357\u0358\7")
-        buf.write(u"g\2\2\u0358\u0359\7s\2\2\u0359\u035a\7u\2\2\u035a\u035b")
-        buf.write(u"\7n\2\2\u035b\u035c\7c\2\2\u035c\u035d\7p\2\2\u035d\u035e")
-        buf.write(u"\7v\2\2\u035e\u00a8\3\2\2\2\u035f\u0360\7@\2\2\u0360")
-        buf.write(u"\u00aa\3\2\2\2\u0361\u0362\7^\2\2\u0362\u0363\7i\2\2")
-        buf.write(u"\u0363\u0364\7g\2\2\u0364\u036b\7s\2\2\u0365\u0366\7")
-        buf.write(u"^\2\2\u0366\u0367\7i\2\2\u0367\u036b\7g\2\2\u0368\u036b")
-        buf.write(u"\5\u00adW\2\u0369\u036b\5\u00afX\2\u036a\u0361\3\2\2")
-        buf.write(u"\2\u036a\u0365\3\2\2\2\u036a\u0368\3\2\2\2\u036a\u0369")
-        buf.write(u"\3\2\2\2\u036b\u00ac\3\2\2\2\u036c\u036d\7^\2\2\u036d")
-        buf.write(u"\u036e\7i\2\2\u036e\u036f\7g\2\2\u036f\u0370\7s\2\2\u0370")
-        buf.write(u"\u0371\7s\2\2\u0371\u00ae\3\2\2\2\u0372\u0373\7^\2\2")
-        buf.write(u"\u0373\u0374\7i\2\2\u0374\u0375\7g\2\2\u0375\u0376\7")
-        buf.write(u"s\2\2\u0376\u0377\7u\2\2\u0377\u0378\7n\2\2\u0378\u0379")
-        buf.write(u"\7c\2\2\u0379\u037a\7p\2\2\u037a\u037b\7v\2\2\u037b\u00b0")
-        buf.write(u"\3\2\2\2\u037c\u037d\7#\2\2\u037d\u00b2\3\2\2\2\u037e")
-        buf.write(u"\u0380\7^\2\2\u037f\u0381\t\3\2\2\u0380\u037f\3\2\2\2")
-        buf.write(u"\u0381\u0382\3\2\2\2\u0382\u0380\3\2\2\2\u0382\u0383")
-        buf.write(u"\3\2\2\2\u0383\u00b4\3\2\2\2\33\2\u00ba\u00ca\u00d9\u00ea")
-        buf.write(u"\u010e\u0176\u01f1\u02f0\u02f8\u02fa\u0303\u030c\u0312")
-        buf.write(u"\u031c\u0323\u0325\u032b\u032e\u0335\u0339\u033b\u034d")
-        buf.write(u"\u036a\u0382\3\b\2\2")
+        buf.write(u"\13\3\13\3\13\3\13\3\13\3\f\3\f\3\r\3\r\3\16\3\16\3\17")
+        buf.write(u"\3\17\3\20\3\20\3\21\3\21\3\22\3\22\3\23\3\23\3\24\3")
+        buf.write(u"\24\3\24\3\25\3\25\3\25\3\26\3\26\3\27\3\27\3\30\3\30")
+        buf.write(u"\3\30\3\30\3\30\3\30\3\30\3\30\3\31\3\31\3\31\3\31\3")
+        buf.write(u"\31\3\31\3\31\3\31\3\31\3\32\3\32\3\33\3\33\3\33\3\33")
+        buf.write(u"\3\33\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3")
+        buf.write(u"\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34")
+        buf.write(u"\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3")
+        buf.write(u"\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34")
+        buf.write(u"\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3")
+        buf.write(u"\34\3\34\3\34\3\34\5\34\u018a\n\34\3\35\3\35\3\35\3\35")
+        buf.write(u"\3\35\3\36\3\36\3\36\3\36\3\36\3\37\3\37\3\37\3\37\3")
+        buf.write(u"\37\3\37\3 \3 \3 \3 \3 \3!\3!\3!\3!\3!\3\"\3\"\3\"\3")
+        buf.write(u"\"\3#\3#\3#\3#\3#\3$\3$\3$\3$\3$\3%\3%\3%\3%\3%\3&\3")
+        buf.write(u"&\3&\3&\3&\3\'\3\'\3\'\3\'\3\'\3(\3(\3(\3(\3(\3)\3)\3")
+        buf.write(u")\3)\3)\3)\3)\3)\3*\3*\3*\3*\3*\3*\3*\3*\3+\3+\3+\3+")
+        buf.write(u"\3+\3+\3+\3+\3,\3,\3,\3,\3,\3,\3,\3,\3-\3-\3-\3-\3-\3")
+        buf.write(u"-\3-\3-\3.\3.\3.\3.\3.\3.\3.\3.\3/\3/\3/\3/\3/\3/\3\60")
+        buf.write(u"\3\60\3\60\3\60\3\60\3\60\3\61\3\61\3\61\3\61\3\61\3")
+        buf.write(u"\61\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\62\3\63\3\63")
+        buf.write(u"\3\63\3\63\3\63\3\63\3\63\3\63\3\64\3\64\3\64\3\64\3")
+        buf.write(u"\64\3\64\3\64\3\64\3\65\3\65\3\65\3\65\3\65\3\65\3\66")
+        buf.write(u"\3\66\3\66\3\66\3\66\3\66\3\66\3\67\3\67\3\67\3\67\3")
+        buf.write(u"\67\3\67\38\38\38\38\38\39\39\39\39\39\39\3:\3:\3:\3")
+        buf.write(u":\3:\3:\3:\3;\3;\3;\3;\3;\3;\3;\3;\3<\3<\3<\3<\3<\3<")
+        buf.write(u"\3<\3<\3=\3=\3=\3=\3=\3=\3=\3=\3>\3>\3?\3?\3@\3@\3A\3")
+        buf.write(u"A\3B\3B\7B\u0269\nB\fB\16B\u026c\13B\3B\3B\3B\6B\u0271")
+        buf.write(u"\nB\rB\16B\u0272\5B\u0275\nB\3C\3C\3D\3D\3E\6E\u027c")
+        buf.write(u"\nE\rE\16E\u027d\3E\3E\3E\3E\3E\7E\u0285\nE\fE\16E\u0288")
+        buf.write(u"\13E\3E\7E\u028b\nE\fE\16E\u028e\13E\3E\3E\3E\3E\3E\7")
+        buf.write(u"E\u0295\nE\fE\16E\u0298\13E\3E\3E\6E\u029c\nE\rE\16E")
+        buf.write(u"\u029d\5E\u02a0\nE\3F\3F\3G\3G\3G\3G\3G\3H\3H\3I\3I\3")
+        buf.write(u"I\3I\3I\3I\3I\3I\5I\u02b3\nI\3J\3J\3J\3J\3J\3J\3K\3K")
+        buf.write(u"\3K\3K\3K\3K\3K\3K\3K\3K\3L\3L\3M\3M\3M\3M\3M\3M\3M\3")
+        buf.write(u"M\5M\u02cf\nM\3N\3N\3N\3N\3N\3N\3O\3O\3O\3O\3O\3O\3O")
+        buf.write(u"\3O\3O\3O\3P\3P\3Q\3Q\6Q\u02e5\nQ\rQ\16Q\u02e6\3\u026a")
+        buf.write(u"\2R\3\3\5\4\7\5\t\6\13\7\r\b\17\t\21\n\23\13\25\f\27")
+        buf.write(u"\r\31\16\33\17\35\20\37\21!\22#\23%\24\'\25)\26+\27-")
+        buf.write(u"\30/\31\61\32\63\33\65\34\67\359\36;\37= ?!A\"C#E$G%")
+        buf.write(u"I&K\'M(O)Q*S+U,W-Y.[/]\60_\61a\62c\63e\64g\65i\66k\67")
+        buf.write(u"m8o9q:s;u<w=y>{?}@\177A\u0081\2\u0083B\u0085C\u0087\2")
+        buf.write(u"\u0089D\u008bE\u008dF\u008fG\u0091H\u0093I\u0095J\u0097")
+        buf.write(u"K\u0099L\u009bM\u009dN\u009fO\u00a1P\3\2\5\5\2\13\f\17")
+        buf.write(u"\17\"\"\4\2C\\c|\3\2\62;\2\u02fe\2\3\3\2\2\2\2\5\3\2")
+        buf.write(u"\2\2\2\7\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2")
+        buf.write(u"\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2")
+        buf.write(u"\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2\2\2")
+        buf.write(u"\2\37\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2\2\'\3")
+        buf.write(u"\2\2\2\2)\3\2\2\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2")
+        buf.write(u"\61\3\2\2\2\2\63\3\2\2\2\2\65\3\2\2\2\2\67\3\2\2\2\2")
+        buf.write(u"9\3\2\2\2\2;\3\2\2\2\2=\3\2\2\2\2?\3\2\2\2\2A\3\2\2\2")
+        buf.write(u"\2C\3\2\2\2\2E\3\2\2\2\2G\3\2\2\2\2I\3\2\2\2\2K\3\2\2")
+        buf.write(u"\2\2M\3\2\2\2\2O\3\2\2\2\2Q\3\2\2\2\2S\3\2\2\2\2U\3\2")
+        buf.write(u"\2\2\2W\3\2\2\2\2Y\3\2\2\2\2[\3\2\2\2\2]\3\2\2\2\2_\3")
+        buf.write(u"\2\2\2\2a\3\2\2\2\2c\3\2\2\2\2e\3\2\2\2\2g\3\2\2\2\2")
+        buf.write(u"i\3\2\2\2\2k\3\2\2\2\2m\3\2\2\2\2o\3\2\2\2\2q\3\2\2\2")
+        buf.write(u"\2s\3\2\2\2\2u\3\2\2\2\2w\3\2\2\2\2y\3\2\2\2\2{\3\2\2")
+        buf.write(u"\2\2}\3\2\2\2\2\177\3\2\2\2\2\u0083\3\2\2\2\2\u0085\3")
+        buf.write(u"\2\2\2\2\u0089\3\2\2\2\2\u008b\3\2\2\2\2\u008d\3\2\2")
+        buf.write(u"\2\2\u008f\3\2\2\2\2\u0091\3\2\2\2\2\u0093\3\2\2\2\2")
+        buf.write(u"\u0095\3\2\2\2\2\u0097\3\2\2\2\2\u0099\3\2\2\2\2\u009b")
+        buf.write(u"\3\2\2\2\2\u009d\3\2\2\2\2\u009f\3\2\2\2\2\u00a1\3\2")
+        buf.write(u"\2\2\3\u00a3\3\2\2\2\5\u00a6\3\2\2\2\7\u00b8\3\2\2\2")
+        buf.write(u"\t\u00c7\3\2\2\2\13\u00d8\3\2\2\2\r\u00dc\3\2\2\2\17")
+        buf.write(u"\u00e4\3\2\2\2\21\u00fc\3\2\2\2\23\u0100\3\2\2\2\25\u010f")
+        buf.write(u"\3\2\2\2\27\u0120\3\2\2\2\31\u0122\3\2\2\2\33\u0124\3")
+        buf.write(u"\2\2\2\35\u0126\3\2\2\2\37\u0128\3\2\2\2!\u012a\3\2\2")
+        buf.write(u"\2#\u012c\3\2\2\2%\u012e\3\2\2\2\'\u0130\3\2\2\2)\u0133")
+        buf.write(u"\3\2\2\2+\u0136\3\2\2\2-\u0138\3\2\2\2/\u013a\3\2\2\2")
+        buf.write(u"\61\u0142\3\2\2\2\63\u014b\3\2\2\2\65\u014d\3\2\2\2\67")
+        buf.write(u"\u0189\3\2\2\29\u018b\3\2\2\2;\u0190\3\2\2\2=\u0195\3")
+        buf.write(u"\2\2\2?\u019b\3\2\2\2A\u01a0\3\2\2\2C\u01a5\3\2\2\2E")
+        buf.write(u"\u01a9\3\2\2\2G\u01ae\3\2\2\2I\u01b3\3\2\2\2K\u01b8\3")
+        buf.write(u"\2\2\2M\u01bd\3\2\2\2O\u01c2\3\2\2\2Q\u01c7\3\2\2\2S")
+        buf.write(u"\u01cf\3\2\2\2U\u01d7\3\2\2\2W\u01df\3\2\2\2Y\u01e7\3")
+        buf.write(u"\2\2\2[\u01ef\3\2\2\2]\u01f7\3\2\2\2_\u01fd\3\2\2\2a")
+        buf.write(u"\u0203\3\2\2\2c\u0209\3\2\2\2e\u0211\3\2\2\2g\u0219\3")
+        buf.write(u"\2\2\2i\u0221\3\2\2\2k\u0227\3\2\2\2m\u022e\3\2\2\2o")
+        buf.write(u"\u0234\3\2\2\2q\u0239\3\2\2\2s\u023f\3\2\2\2u\u0246\3")
+        buf.write(u"\2\2\2w\u024e\3\2\2\2y\u0256\3\2\2\2{\u025e\3\2\2\2}")
+        buf.write(u"\u0260\3\2\2\2\177\u0262\3\2\2\2\u0081\u0264\3\2\2\2")
+        buf.write(u"\u0083\u0266\3\2\2\2\u0085\u0276\3\2\2\2\u0087\u0278")
+        buf.write(u"\3\2\2\2\u0089\u029f\3\2\2\2\u008b\u02a1\3\2\2\2\u008d")
+        buf.write(u"\u02a3\3\2\2\2\u008f\u02a8\3\2\2\2\u0091\u02b2\3\2\2")
+        buf.write(u"\2\u0093\u02b4\3\2\2\2\u0095\u02ba\3\2\2\2\u0097\u02c4")
+        buf.write(u"\3\2\2\2\u0099\u02ce\3\2\2\2\u009b\u02d0\3\2\2\2\u009d")
+        buf.write(u"\u02d6\3\2\2\2\u009f\u02e0\3\2\2\2\u00a1\u02e2\3\2\2")
+        buf.write(u"\2\u00a3\u00a4\7.\2\2\u00a4\4\3\2\2\2\u00a5\u00a7\t\2")
+        buf.write(u"\2\2\u00a6\u00a5\3\2\2\2\u00a7\u00a8\3\2\2\2\u00a8\u00a6")
+        buf.write(u"\3\2\2\2\u00a8\u00a9\3\2\2\2\u00a9\u00aa\3\2\2\2\u00aa")
+        buf.write(u"\u00ab\b\3\2\2\u00ab\6\3\2\2\2\u00ac\u00ad\7^\2\2\u00ad")
+        buf.write(u"\u00b9\7.\2\2\u00ae\u00af\7^\2\2\u00af\u00b0\7v\2\2\u00b0")
+        buf.write(u"\u00b1\7j\2\2\u00b1\u00b2\7k\2\2\u00b2\u00b3\7p\2\2\u00b3")
+        buf.write(u"\u00b4\7u\2\2\u00b4\u00b5\7r\2\2\u00b5\u00b6\7c\2\2\u00b6")
+        buf.write(u"\u00b7\7e\2\2\u00b7\u00b9\7g\2\2\u00b8\u00ac\3\2\2\2")
+        buf.write(u"\u00b8\u00ae\3\2\2\2\u00b9\u00ba\3\2\2\2\u00ba\u00bb")
+        buf.write(u"\b\4\2\2\u00bb\b\3\2\2\2\u00bc\u00bd\7^\2\2\u00bd\u00c8")
+        buf.write(u"\7<\2\2\u00be\u00bf\7^\2\2\u00bf\u00c0\7o\2\2\u00c0\u00c1")
+        buf.write(u"\7g\2\2\u00c1\u00c2\7f\2\2\u00c2\u00c3\7u\2\2\u00c3\u00c4")
+        buf.write(u"\7r\2\2\u00c4\u00c5\7c\2\2\u00c5\u00c6\7e\2\2\u00c6\u00c8")
+        buf.write(u"\7g\2\2\u00c7\u00bc\3\2\2\2\u00c7\u00be\3\2\2\2\u00c8")
+        buf.write(u"\u00c9\3\2\2\2\u00c9\u00ca\b\5\2\2\u00ca\n\3\2\2\2\u00cb")
+        buf.write(u"\u00cc\7^\2\2\u00cc\u00d9\7=\2\2\u00cd\u00ce\7^\2\2\u00ce")
+        buf.write(u"\u00cf\7v\2\2\u00cf\u00d0\7j\2\2\u00d0\u00d1\7k\2\2\u00d1")
+        buf.write(u"\u00d2\7e\2\2\u00d2\u00d3\7m\2\2\u00d3\u00d4\7u\2\2\u00d4")
+        buf.write(u"\u00d5\7r\2\2\u00d5\u00d6\7c\2\2\u00d6\u00d7\7e\2\2\u00d7")
+        buf.write(u"\u00d9\7g\2\2\u00d8\u00cb\3\2\2\2\u00d8\u00cd\3\2\2\2")
+        buf.write(u"\u00d9\u00da\3\2\2\2\u00da\u00db\b\6\2\2\u00db\f\3\2")
+        buf.write(u"\2\2\u00dc\u00dd\7^\2\2\u00dd\u00de\7s\2\2\u00de\u00df")
+        buf.write(u"\7w\2\2\u00df\u00e0\7c\2\2\u00e0\u00e1\7f\2\2\u00e1\u00e2")
+        buf.write(u"\3\2\2\2\u00e2\u00e3\b\7\2\2\u00e3\16\3\2\2\2\u00e4\u00e5")
+        buf.write(u"\7^\2\2\u00e5\u00e6\7s\2\2\u00e6\u00e7\7s\2\2\u00e7\u00e8")
+        buf.write(u"\7w\2\2\u00e8\u00e9\7c\2\2\u00e9\u00ea\7f\2\2\u00ea\u00eb")
+        buf.write(u"\3\2\2\2\u00eb\u00ec\b\b\2\2\u00ec\20\3\2\2\2\u00ed\u00ee")
+        buf.write(u"\7^\2\2\u00ee\u00fd\7#\2\2\u00ef\u00f0\7^\2\2\u00f0\u00f1")
+        buf.write(u"\7p\2\2\u00f1\u00f2\7g\2\2\u00f2\u00f3\7i\2\2\u00f3\u00f4")
+        buf.write(u"\7v\2\2\u00f4\u00f5\7j\2\2\u00f5\u00f6\7k\2\2\u00f6\u00f7")
+        buf.write(u"\7p\2\2\u00f7\u00f8\7u\2\2\u00f8\u00f9\7r\2\2\u00f9\u00fa")
+        buf.write(u"\7c\2\2\u00fa\u00fb\7e\2\2\u00fb\u00fd\7g\2\2\u00fc\u00ed")
+        buf.write(u"\3\2\2\2\u00fc\u00ef\3\2\2\2\u00fd\u00fe\3\2\2\2\u00fe")
+        buf.write(u"\u00ff\b\t\2\2\u00ff\22\3\2\2\2\u0100\u0101\7^\2\2\u0101")
+        buf.write(u"\u0102\7p\2\2\u0102\u0103\7g\2\2\u0103\u0104\7i\2\2\u0104")
+        buf.write(u"\u0105\7o\2\2\u0105\u0106\7g\2\2\u0106\u0107\7f\2\2\u0107")
+        buf.write(u"\u0108\7u\2\2\u0108\u0109\7r\2\2\u0109\u010a\7c\2\2\u010a")
+        buf.write(u"\u010b\7e\2\2\u010b\u010c\7g\2\2\u010c\u010d\3\2\2\2")
+        buf.write(u"\u010d\u010e\b\n\2\2\u010e\24\3\2\2\2\u010f\u0110\7^")
+        buf.write(u"\2\2\u0110\u0111\7p\2\2\u0111\u0112\7g\2\2\u0112\u0113")
+        buf.write(u"\7i\2\2\u0113\u0114\7v\2\2\u0114\u0115\7j\2\2\u0115\u0116")
+        buf.write(u"\7k\2\2\u0116\u0117\7e\2\2\u0117\u0118\7m\2\2\u0118\u0119")
+        buf.write(u"\7u\2\2\u0119\u011a\7r\2\2\u011a\u011b\7c\2\2\u011b\u011c")
+        buf.write(u"\7e\2\2\u011c\u011d\7g\2\2\u011d\u011e\3\2\2\2\u011e")
+        buf.write(u"\u011f\b\13\2\2\u011f\26\3\2\2\2\u0120\u0121\7-\2\2\u0121")
+        buf.write(u"\30\3\2\2\2\u0122\u0123\7/\2\2\u0123\32\3\2\2\2\u0124")
+        buf.write(u"\u0125\7,\2\2\u0125\34\3\2\2\2\u0126\u0127\7\61\2\2\u0127")
+        buf.write(u"\36\3\2\2\2\u0128\u0129\7*\2\2\u0129 \3\2\2\2\u012a\u012b")
+        buf.write(u"\7+\2\2\u012b\"\3\2\2\2\u012c\u012d\7}\2\2\u012d$\3\2")
+        buf.write(u"\2\2\u012e\u012f\7\177\2\2\u012f&\3\2\2\2\u0130\u0131")
+        buf.write(u"\7^\2\2\u0131\u0132\7}\2\2\u0132(\3\2\2\2\u0133\u0134")
+        buf.write(u"\7^\2\2\u0134\u0135\7\177\2\2\u0135*\3\2\2\2\u0136\u0137")
+        buf.write(u"\7]\2\2\u0137,\3\2\2\2\u0138\u0139\7_\2\2\u0139.\3\2")
+        buf.write(u"\2\2\u013a\u013b\7^\2\2\u013b\u013c\7n\2\2\u013c\u013d")
+        buf.write(u"\7g\2\2\u013d\u013e\7h\2\2\u013e\u013f\7v\2\2\u013f\u0140")
+        buf.write(u"\3\2\2\2\u0140\u0141\b\30\2\2\u0141\60\3\2\2\2\u0142")
+        buf.write(u"\u0143\7^\2\2\u0143\u0144\7t\2\2\u0144\u0145\7k\2\2\u0145")
+        buf.write(u"\u0146\7i\2\2\u0146\u0147\7j\2\2\u0147\u0148\7v\2\2\u0148")
+        buf.write(u"\u0149\3\2\2\2\u0149\u014a\b\31\2\2\u014a\62\3\2\2\2")
+        buf.write(u"\u014b\u014c\7~\2\2\u014c\64\3\2\2\2\u014d\u014e\7^\2")
+        buf.write(u"\2\u014e\u014f\7n\2\2\u014f\u0150\7k\2\2\u0150\u0151")
+        buf.write(u"\7o\2\2\u0151\66\3\2\2\2\u0152\u0153\7^\2\2\u0153\u0154")
+        buf.write(u"\7v\2\2\u0154\u018a\7q\2\2\u0155\u0156\7^\2\2\u0156\u0157")
+        buf.write(u"\7t\2\2\u0157\u0158\7k\2\2\u0158\u0159\7i\2\2\u0159\u015a")
+        buf.write(u"\7j\2\2\u015a\u015b\7v\2\2\u015b\u015c\7c\2\2\u015c\u015d")
+        buf.write(u"\7t\2\2\u015d\u015e\7t\2\2\u015e\u015f\7q\2\2\u015f\u018a")
+        buf.write(u"\7y\2\2\u0160\u0161\7^\2\2\u0161\u0162\7T\2\2\u0162\u0163")
+        buf.write(u"\7k\2\2\u0163\u0164\7i\2\2\u0164\u0165\7j\2\2\u0165\u0166")
+        buf.write(u"\7v\2\2\u0166\u0167\7c\2\2\u0167\u0168\7t\2\2\u0168\u0169")
+        buf.write(u"\7t\2\2\u0169\u016a\7q\2\2\u016a\u018a\7y\2\2\u016b\u016c")
+        buf.write(u"\7^\2\2\u016c\u016d\7n\2\2\u016d\u016e\7q\2\2\u016e\u016f")
+        buf.write(u"\7p\2\2\u016f\u0170\7i\2\2\u0170\u0171\7t\2\2\u0171\u0172")
+        buf.write(u"\7k\2\2\u0172\u0173\7i\2\2\u0173\u0174\7j\2\2\u0174\u0175")
+        buf.write(u"\7v\2\2\u0175\u0176\7c\2\2\u0176\u0177\7t\2\2\u0177\u0178")
+        buf.write(u"\7t\2\2\u0178\u0179\7q\2\2\u0179\u018a\7y\2\2\u017a\u017b")
+        buf.write(u"\7^\2\2\u017b\u017c\7N\2\2\u017c\u017d\7q\2\2\u017d\u017e")
+        buf.write(u"\7p\2\2\u017e\u017f\7i\2\2\u017f\u0180\7t\2\2\u0180\u0181")
+        buf.write(u"\7k\2\2\u0181\u0182\7i\2\2\u0182\u0183\7j\2\2\u0183\u0184")
+        buf.write(u"\7v\2\2\u0184\u0185\7c\2\2\u0185\u0186\7t\2\2\u0186\u0187")
+        buf.write(u"\7t\2\2\u0187\u0188\7q\2\2\u0188\u018a\7y\2\2\u0189\u0152")
+        buf.write(u"\3\2\2\2\u0189\u0155\3\2\2\2\u0189\u0160\3\2\2\2\u0189")
+        buf.write(u"\u016b\3\2\2\2\u0189\u017a\3\2\2\2\u018a8\3\2\2\2\u018b")
+        buf.write(u"\u018c\7^\2\2\u018c\u018d\7k\2\2\u018d\u018e\7p\2\2\u018e")
+        buf.write(u"\u018f\7v\2\2\u018f:\3\2\2\2\u0190\u0191\7^\2\2\u0191")
+        buf.write(u"\u0192\7u\2\2\u0192\u0193\7w\2\2\u0193\u0194\7o\2\2\u0194")
+        buf.write(u"<\3\2\2\2\u0195\u0196\7^\2\2\u0196\u0197\7r\2\2\u0197")
+        buf.write(u"\u0198\7t\2\2\u0198\u0199\7q\2\2\u0199\u019a\7f\2\2\u019a")
+        buf.write(u">\3\2\2\2\u019b\u019c\7^\2\2\u019c\u019d\7g\2\2\u019d")
+        buf.write(u"\u019e\7z\2\2\u019e\u019f\7r\2\2\u019f@\3\2\2\2\u01a0")
+        buf.write(u"\u01a1\7^\2\2\u01a1\u01a2\7n\2\2\u01a2\u01a3\7q\2\2\u01a3")
+        buf.write(u"\u01a4\7i\2\2\u01a4B\3\2\2\2\u01a5\u01a6\7^\2\2\u01a6")
+        buf.write(u"\u01a7\7n\2\2\u01a7\u01a8\7p\2\2\u01a8D\3\2\2\2\u01a9")
+        buf.write(u"\u01aa\7^\2\2\u01aa\u01ab\7u\2\2\u01ab\u01ac\7k\2\2\u01ac")
+        buf.write(u"\u01ad\7p\2\2\u01adF\3\2\2\2\u01ae\u01af\7^\2\2\u01af")
+        buf.write(u"\u01b0\7e\2\2\u01b0\u01b1\7q\2\2\u01b1\u01b2\7u\2\2\u01b2")
+        buf.write(u"H\3\2\2\2\u01b3\u01b4\7^\2\2\u01b4\u01b5\7v\2\2\u01b5")
+        buf.write(u"\u01b6\7c\2\2\u01b6\u01b7\7p\2\2\u01b7J\3\2\2\2\u01b8")
+        buf.write(u"\u01b9\7^\2\2\u01b9\u01ba\7e\2\2\u01ba\u01bb\7u\2\2\u01bb")
+        buf.write(u"\u01bc\7e\2\2\u01bcL\3\2\2\2\u01bd\u01be\7^\2\2\u01be")
+        buf.write(u"\u01bf\7u\2\2\u01bf\u01c0\7g\2\2\u01c0\u01c1\7e\2\2\u01c1")
+        buf.write(u"N\3\2\2\2\u01c2\u01c3\7^\2\2\u01c3\u01c4\7e\2\2\u01c4")
+        buf.write(u"\u01c5\7q\2\2\u01c5\u01c6\7v\2\2\u01c6P\3\2\2\2\u01c7")
+        buf.write(u"\u01c8\7^\2\2\u01c8\u01c9\7c\2\2\u01c9\u01ca\7t\2\2\u01ca")
+        buf.write(u"\u01cb\7e\2\2\u01cb\u01cc\7u\2\2\u01cc\u01cd\7k\2\2\u01cd")
+        buf.write(u"\u01ce\7p\2\2\u01ceR\3\2\2\2\u01cf\u01d0\7^\2\2\u01d0")
+        buf.write(u"\u01d1\7c\2\2\u01d1\u01d2\7t\2\2\u01d2\u01d3\7e\2\2\u01d3")
+        buf.write(u"\u01d4\7e\2\2\u01d4\u01d5\7q\2\2\u01d5\u01d6\7u\2\2\u01d6")
+        buf.write(u"T\3\2\2\2\u01d7\u01d8\7^\2\2\u01d8\u01d9\7c\2\2\u01d9")
+        buf.write(u"\u01da\7t\2\2\u01da\u01db\7e\2\2\u01db\u01dc\7v\2\2\u01dc")
+        buf.write(u"\u01dd\7c\2\2\u01dd\u01de\7p\2\2\u01deV\3\2\2\2\u01df")
+        buf.write(u"\u01e0\7^\2\2\u01e0\u01e1\7c\2\2\u01e1\u01e2\7t\2\2\u01e2")
+        buf.write(u"\u01e3\7e\2\2\u01e3\u01e4\7e\2\2\u01e4\u01e5\7u\2\2\u01e5")
+        buf.write(u"\u01e6\7e\2\2\u01e6X\3\2\2\2\u01e7\u01e8\7^\2\2\u01e8")
+        buf.write(u"\u01e9\7c\2\2\u01e9\u01ea\7t\2\2\u01ea\u01eb\7e\2\2\u01eb")
+        buf.write(u"\u01ec\7u\2\2\u01ec\u01ed\7g\2\2\u01ed\u01ee\7e\2\2\u01ee")
+        buf.write(u"Z\3\2\2\2\u01ef\u01f0\7^\2\2\u01f0\u01f1\7c\2\2\u01f1")
+        buf.write(u"\u01f2\7t\2\2\u01f2\u01f3\7e\2\2\u01f3\u01f4\7e\2\2\u01f4")
+        buf.write(u"\u01f5\7q\2\2\u01f5\u01f6\7v\2\2\u01f6\\\3\2\2\2\u01f7")
+        buf.write(u"\u01f8\7^\2\2\u01f8\u01f9\7u\2\2\u01f9\u01fa\7k\2\2\u01fa")
+        buf.write(u"\u01fb\7p\2\2\u01fb\u01fc\7j\2\2\u01fc^\3\2\2\2\u01fd")
+        buf.write(u"\u01fe\7^\2\2\u01fe\u01ff\7e\2\2\u01ff\u0200\7q\2\2\u0200")
+        buf.write(u"\u0201\7u\2\2\u0201\u0202\7j\2\2\u0202`\3\2\2\2\u0203")
+        buf.write(u"\u0204\7^\2\2\u0204\u0205\7v\2\2\u0205\u0206\7c\2\2\u0206")
+        buf.write(u"\u0207\7p\2\2\u0207\u0208\7j\2\2\u0208b\3\2\2\2\u0209")
+        buf.write(u"\u020a\7^\2\2\u020a\u020b\7c\2\2\u020b\u020c\7t\2\2\u020c")
+        buf.write(u"\u020d\7u\2\2\u020d\u020e\7k\2\2\u020e\u020f\7p\2\2\u020f")
+        buf.write(u"\u0210\7j\2\2\u0210d\3\2\2\2\u0211\u0212\7^\2\2\u0212")
+        buf.write(u"\u0213\7c\2\2\u0213\u0214\7t\2\2\u0214\u0215\7e\2\2\u0215")
+        buf.write(u"\u0216\7q\2\2\u0216\u0217\7u\2\2\u0217\u0218\7j\2\2\u0218")
+        buf.write(u"f\3\2\2\2\u0219\u021a\7^\2\2\u021a\u021b\7c\2\2\u021b")
+        buf.write(u"\u021c\7t\2\2\u021c\u021d\7v\2\2\u021d\u021e\7c\2\2\u021e")
+        buf.write(u"\u021f\7p\2\2\u021f\u0220\7j\2\2\u0220h\3\2\2\2\u0221")
+        buf.write(u"\u0222\7^\2\2\u0222\u0223\7u\2\2\u0223\u0224\7s\2\2\u0224")
+        buf.write(u"\u0225\7t\2\2\u0225\u0226\7v\2\2\u0226j\3\2\2\2\u0227")
+        buf.write(u"\u0228\7^\2\2\u0228\u0229\7v\2\2\u0229\u022a\7k\2\2\u022a")
+        buf.write(u"\u022b\7o\2\2\u022b\u022c\7g\2\2\u022c\u022d\7u\2\2\u022d")
+        buf.write(u"l\3\2\2\2\u022e\u022f\7^\2\2\u022f\u0230\7e\2\2\u0230")
+        buf.write(u"\u0231\7f\2\2\u0231\u0232\7q\2\2\u0232\u0233\7v\2\2\u0233")
+        buf.write(u"n\3\2\2\2\u0234\u0235\7^\2\2\u0235\u0236\7f\2\2\u0236")
+        buf.write(u"\u0237\7k\2\2\u0237\u0238\7x\2\2\u0238p\3\2\2\2\u0239")
+        buf.write(u"\u023a\7^\2\2\u023a\u023b\7h\2\2\u023b\u023c\7t\2\2\u023c")
+        buf.write(u"\u023d\7c\2\2\u023d\u023e\7e\2\2\u023er\3\2\2\2\u023f")
+        buf.write(u"\u0240\7^\2\2\u0240\u0241\7d\2\2\u0241\u0242\7k\2\2\u0242")
+        buf.write(u"\u0243\7p\2\2\u0243\u0244\7q\2\2\u0244\u0245\7o\2\2\u0245")
+        buf.write(u"t\3\2\2\2\u0246\u0247\7^\2\2\u0247\u0248\7f\2\2\u0248")
+        buf.write(u"\u0249\7d\2\2\u0249\u024a\7k\2\2\u024a\u024b\7p\2\2\u024b")
+        buf.write(u"\u024c\7q\2\2\u024c\u024d\7o\2\2\u024dv\3\2\2\2\u024e")
+        buf.write(u"\u024f\7^\2\2\u024f\u0250\7v\2\2\u0250\u0251\7d\2\2\u0251")
+        buf.write(u"\u0252\7k\2\2\u0252\u0253\7p\2\2\u0253\u0254\7q\2\2\u0254")
+        buf.write(u"\u0255\7o\2\2\u0255x\3\2\2\2\u0256\u0257\7^\2\2\u0257")
+        buf.write(u"\u0258\7o\2\2\u0258\u0259\7c\2\2\u0259\u025a\7v\2\2\u025a")
+        buf.write(u"\u025b\7j\2\2\u025b\u025c\7k\2\2\u025c\u025d\7v\2\2\u025d")
+        buf.write(u"z\3\2\2\2\u025e\u025f\7a\2\2\u025f|\3\2\2\2\u0260\u0261")
+        buf.write(u"\7`\2\2\u0261~\3\2\2\2\u0262\u0263\7<\2\2\u0263\u0080")
+        buf.write(u"\3\2\2\2\u0264\u0265\t\2\2\2\u0265\u0082\3\2\2\2\u0266")
+        buf.write(u"\u026a\7f\2\2\u0267\u0269\5\u0081A\2\u0268\u0267\3\2")
+        buf.write(u"\2\2\u0269\u026c\3\2\2\2\u026a\u026b\3\2\2\2\u026a\u0268")
+        buf.write(u"\3\2\2\2\u026b\u0274\3\2\2\2\u026c\u026a\3\2\2\2\u026d")
+        buf.write(u"\u0275\t\3\2\2\u026e\u0270\7^\2\2\u026f\u0271\t\3\2\2")
+        buf.write(u"\u0270\u026f\3\2\2\2\u0271\u0272\3\2\2\2\u0272\u0270")
+        buf.write(u"\3\2\2\2\u0272\u0273\3\2\2\2\u0273\u0275\3\2\2\2\u0274")
+        buf.write(u"\u026d\3\2\2\2\u0274\u026e\3\2\2\2\u0275\u0084\3\2\2")
+        buf.write(u"\2\u0276\u0277\t\3\2\2\u0277\u0086\3\2\2\2\u0278\u0279")
+        buf.write(u"\t\4\2\2\u0279\u0088\3\2\2\2\u027a\u027c\5\u0087D\2\u027b")
+        buf.write(u"\u027a\3\2\2\2\u027c\u027d\3\2\2\2\u027d\u027b\3\2\2")
+        buf.write(u"\2\u027d\u027e\3\2\2\2\u027e\u0286\3\2\2\2\u027f\u0280")
+        buf.write(u"\7.\2\2\u0280\u0281\5\u0087D\2\u0281\u0282\5\u0087D\2")
+        buf.write(u"\u0282\u0283\5\u0087D\2\u0283\u0285\3\2\2\2\u0284\u027f")
+        buf.write(u"\3\2\2\2\u0285\u0288\3\2\2\2\u0286\u0284\3\2\2\2\u0286")
+        buf.write(u"\u0287\3\2\2\2\u0287\u02a0\3\2\2\2\u0288\u0286\3\2\2")
+        buf.write(u"\2\u0289\u028b\5\u0087D\2\u028a\u0289\3\2\2\2\u028b\u028e")
+        buf.write(u"\3\2\2\2\u028c\u028a\3\2\2\2\u028c\u028d\3\2\2\2\u028d")
+        buf.write(u"\u0296\3\2\2\2\u028e\u028c\3\2\2\2\u028f\u0290\7.\2\2")
+        buf.write(u"\u0290\u0291\5\u0087D\2\u0291\u0292\5\u0087D\2\u0292")
+        buf.write(u"\u0293\5\u0087D\2\u0293\u0295\3\2\2\2\u0294\u028f\3\2")
+        buf.write(u"\2\2\u0295\u0298\3\2\2\2\u0296\u0294\3\2\2\2\u0296\u0297")
+        buf.write(u"\3\2\2\2\u0297\u0299\3\2\2\2\u0298\u0296\3\2\2\2\u0299")
+        buf.write(u"\u029b\7\60\2\2\u029a\u029c\5\u0087D\2\u029b\u029a\3")
+        buf.write(u"\2\2\2\u029c\u029d\3\2\2\2\u029d\u029b\3\2\2\2\u029d")
+        buf.write(u"\u029e\3\2\2\2\u029e\u02a0\3\2\2\2\u029f\u027b\3\2\2")
+        buf.write(u"\2\u029f\u028c\3\2\2\2\u02a0\u008a\3\2\2\2\u02a1\u02a2")
+        buf.write(u"\7?\2\2\u02a2\u008c\3\2\2\2\u02a3\u02a4\7^\2\2\u02a4")
+        buf.write(u"\u02a5\7p\2\2\u02a5\u02a6\7g\2\2\u02a6\u02a7\7s\2\2\u02a7")
+        buf.write(u"\u008e\3\2\2\2\u02a8\u02a9\7>\2\2\u02a9\u0090\3\2\2\2")
+        buf.write(u"\u02aa\u02ab\7^\2\2\u02ab\u02ac\7n\2\2\u02ac\u02ad\7")
+        buf.write(u"g\2\2\u02ad\u02b3\7s\2\2\u02ae\u02af\7n\2\2\u02af\u02b3")
+        buf.write(u"\7g\2\2\u02b0\u02b3\5\u0093J\2\u02b1\u02b3\5\u0095K\2")
+        buf.write(u"\u02b2\u02aa\3\2\2\2\u02b2\u02ae\3\2\2\2\u02b2\u02b0")
+        buf.write(u"\3\2\2\2\u02b2\u02b1\3\2\2\2\u02b3\u0092\3\2\2\2\u02b4")
+        buf.write(u"\u02b5\7^\2\2\u02b5\u02b6\7n\2\2\u02b6\u02b7\7g\2\2\u02b7")
+        buf.write(u"\u02b8\7s\2\2\u02b8\u02b9\7s\2\2\u02b9\u0094\3\2\2\2")
+        buf.write(u"\u02ba\u02bb\7^\2\2\u02bb\u02bc\7n\2\2\u02bc\u02bd\7")
+        buf.write(u"g\2\2\u02bd\u02be\7s\2\2\u02be\u02bf\7u\2\2\u02bf\u02c0")
+        buf.write(u"\7n\2\2\u02c0\u02c1\7c\2\2\u02c1\u02c2\7p\2\2\u02c2\u02c3")
+        buf.write(u"\7v\2\2\u02c3\u0096\3\2\2\2\u02c4\u02c5\7@\2\2\u02c5")
+        buf.write(u"\u0098\3\2\2\2\u02c6\u02c7\7^\2\2\u02c7\u02c8\7i\2\2")
+        buf.write(u"\u02c8\u02c9\7g\2\2\u02c9\u02cf\7s\2\2\u02ca\u02cb\7")
+        buf.write(u"i\2\2\u02cb\u02cf\7g\2\2\u02cc\u02cf\5\u009bN\2\u02cd")
+        buf.write(u"\u02cf\5\u009dO\2\u02ce\u02c6\3\2\2\2\u02ce\u02ca\3\2")
+        buf.write(u"\2\2\u02ce\u02cc\3\2\2\2\u02ce\u02cd\3\2\2\2\u02cf\u009a")
+        buf.write(u"\3\2\2\2\u02d0\u02d1\7^\2\2\u02d1\u02d2\7i\2\2\u02d2")
+        buf.write(u"\u02d3\7g\2\2\u02d3\u02d4\7s\2\2\u02d4\u02d5\7s\2\2\u02d5")
+        buf.write(u"\u009c\3\2\2\2\u02d6\u02d7\7^\2\2\u02d7\u02d8\7i\2\2")
+        buf.write(u"\u02d8\u02d9\7g\2\2\u02d9\u02da\7s\2\2\u02da\u02db\7")
+        buf.write(u"u\2\2\u02db\u02dc\7n\2\2\u02dc\u02dd\7c\2\2\u02dd\u02de")
+        buf.write(u"\7p\2\2\u02de\u02df\7v\2\2\u02df\u009e\3\2\2\2\u02e0")
+        buf.write(u"\u02e1\7#\2\2\u02e1\u00a0\3\2\2\2\u02e2\u02e4\7^\2\2")
+        buf.write(u"\u02e3\u02e5\t\3\2\2\u02e4\u02e3\3\2\2\2\u02e5\u02e6")
+        buf.write(u"\3\2\2\2\u02e6\u02e4\3\2\2\2\u02e6\u02e7\3\2\2\2\u02e7")
+        buf.write(u"\u00a2\3\2\2\2\25\2\u00a8\u00b8\u00c7\u00d8\u00fc\u0189")
+        buf.write(u"\u026a\u0272\u0274\u027d\u0286\u028c\u0296\u029d\u029f")
+        buf.write(u"\u02b2\u02ce\u02e6\3\b\2\2")
         return buf.getvalue()
 
 
@@ -434,83 +360,74 @@ class LaTeXLexer(Lexer):
     NEGTHINSPACE = 8
     NEGMEDSPACE = 9
     NEGTHICKSPACE = 10
-    CMD_LEFT = 11
-    CMD_RIGHT = 12
-    IGNORE = 13
-    ADD = 14
-    SUB = 15
-    MUL = 16
-    DIV = 17
-    L_PAREN = 18
-    R_PAREN = 19
-    L_BRACE = 20
-    R_BRACE = 21
-    L_BRACE_LITERAL = 22
-    R_BRACE_LITERAL = 23
-    L_BRACKET = 24
-    R_BRACKET = 25
-    BAR = 26
-    R_BAR = 27
-    L_BAR = 28
-    L_ANGLE = 29
-    R_ANGLE = 30
-    FUNC_LIM = 31
-    LIM_APPROACH_SYM = 32
-    FUNC_INT = 33
-    FUNC_SUM = 34
-    FUNC_PROD = 35
-    FUNC_EXP = 36
-    FUNC_LOG = 37
-    FUNC_LN = 38
-    FUNC_SIN = 39
-    FUNC_COS = 40
-    FUNC_TAN = 41
-    FUNC_CSC = 42
-    FUNC_SEC = 43
-    FUNC_COT = 44
-    FUNC_ARCSIN = 45
-    FUNC_ARCCOS = 46
-    FUNC_ARCTAN = 47
-    FUNC_ARCCSC = 48
-    FUNC_ARCSEC = 49
-    FUNC_ARCCOT = 50
-    FUNC_SINH = 51
-    FUNC_COSH = 52
-    FUNC_TANH = 53
-    FUNC_ARSINH = 54
-    FUNC_ARCOSH = 55
-    FUNC_ARTANH = 56
-    L_FLOOR = 57
-    R_FLOOR = 58
-    L_CEIL = 59
-    R_CEIL = 60
-    FUNC_SQRT = 61
-    CMD_TIMES = 62
-    CMD_CDOT = 63
-    CMD_DIV = 64
-    CMD_FRAC = 65
-    CMD_BINOM = 66
-    CMD_DBINOM = 67
-    CMD_TBINOM = 68
-    CMD_MATHIT = 69
-    UNDERSCORE = 70
-    CARET = 71
-    COLON = 72
-    DIFFERENTIAL = 73
-    LETTER = 74
-    NUMBER = 75
-    EQUAL = 76
-    NEQ = 77
-    LT = 78
-    LTE = 79
-    LTE_Q = 80
-    LTE_S = 81
-    GT = 82
-    GTE = 83
-    GTE_Q = 84
-    GTE_S = 85
-    BANG = 86
-    SYMBOL = 87
+    ADD = 11
+    SUB = 12
+    MUL = 13
+    DIV = 14
+    L_PAREN = 15
+    R_PAREN = 16
+    L_BRACE = 17
+    R_BRACE = 18
+    L_BRACE_LITERAL = 19
+    R_BRACE_LITERAL = 20
+    L_BRACKET = 21
+    R_BRACKET = 22
+    CMD_LEFT = 23
+    CMD_RIGHT = 24
+    BAR = 25
+    FUNC_LIM = 26
+    LIM_APPROACH_SYM = 27
+    FUNC_INT = 28
+    FUNC_SUM = 29
+    FUNC_PROD = 30
+    FUNC_EXP = 31
+    FUNC_LOG = 32
+    FUNC_LN = 33
+    FUNC_SIN = 34
+    FUNC_COS = 35
+    FUNC_TAN = 36
+    FUNC_CSC = 37
+    FUNC_SEC = 38
+    FUNC_COT = 39
+    FUNC_ARCSIN = 40
+    FUNC_ARCCOS = 41
+    FUNC_ARCTAN = 42
+    FUNC_ARCCSC = 43
+    FUNC_ARCSEC = 44
+    FUNC_ARCCOT = 45
+    FUNC_SINH = 46
+    FUNC_COSH = 47
+    FUNC_TANH = 48
+    FUNC_ARSINH = 49
+    FUNC_ARCOSH = 50
+    FUNC_ARTANH = 51
+    FUNC_SQRT = 52
+    CMD_TIMES = 53
+    CMD_CDOT = 54
+    CMD_DIV = 55
+    CMD_FRAC = 56
+    CMD_BINOM = 57
+    CMD_DBINOM = 58
+    CMD_TBINOM = 59
+    CMD_MATHIT = 60
+    UNDERSCORE = 61
+    CARET = 62
+    COLON = 63
+    DIFFERENTIAL = 64
+    LETTER = 65
+    NUMBER = 66
+    EQUAL = 67
+    NEQ = 68
+    LT = 69
+    LTE = 70
+    LTE_Q = 71
+    LTE_S = 72
+    GT = 73
+    GTE = 74
+    GTE_Q = 75
+    GTE_S = 76
+    BANG = 77
+    SYMBOL = 78
 
     channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ]
 
@@ -518,58 +435,53 @@ class LaTeXLexer(Lexer):
 
     literalNames = [ u"<INVALID>",
             u"','", u"'\\quad'", u"'\\qquad'", u"'\\negmedspace'", u"'\\negthickspace'",
-            u"'\\left'", u"'\\right'", u"'+'", u"'-'", u"'*'", u"'/'", u"'('",
-            u"')'", u"'{'", u"'}'", u"'\\{'", u"'\\}'", u"'['", u"']'",
-            u"'|'", u"'\\right|'", u"'\\left|'", u"'\\langle'", u"'\\rangle'",
-            u"'\\lim'", u"'\\int'", u"'\\sum'", u"'\\prod'", u"'\\exp'",
+            u"'+'", u"'-'", u"'*'", u"'/'", u"'('", u"')'", u"'{'", u"'}'",
+            u"'\\{'", u"'\\}'", u"'['", u"']'", u"'\\left'", u"'\\right'",
+            u"'|'", u"'\\lim'", u"'\\int'", u"'\\sum'", u"'\\prod'", u"'\\exp'",
             u"'\\log'", u"'\\ln'", u"'\\sin'", u"'\\cos'", u"'\\tan'", u"'\\csc'",
             u"'\\sec'", u"'\\cot'", u"'\\arcsin'", u"'\\arccos'", u"'\\arctan'",
             u"'\\arccsc'", u"'\\arcsec'", u"'\\arccot'", u"'\\sinh'", u"'\\cosh'",
-            u"'\\tanh'", u"'\\arsinh'", u"'\\arcosh'", u"'\\artanh'", u"'\\lfloor'",
-            u"'\\rfloor'", u"'\\lceil'", u"'\\rceil'", u"'\\sqrt'", u"'\\times'",
-            u"'\\cdot'", u"'\\div'", u"'\\frac'", u"'\\binom'", u"'\\dbinom'",
-            u"'\\tbinom'", u"'\\mathit'", u"'_'", u"'^'", u"':'", u"'\\neq'",
-            u"'<'", u"'\\leqq'", u"'\\leqslant'", u"'>'", u"'\\geqq'", u"'\\geqslant'",
-            u"'!'" ]
+            u"'\\tanh'", u"'\\arsinh'", u"'\\arcosh'", u"'\\artanh'", u"'\\sqrt'",
+            u"'\\times'", u"'\\cdot'", u"'\\div'", u"'\\frac'", u"'\\binom'",
+            u"'\\dbinom'", u"'\\tbinom'", u"'\\mathit'", u"'_'", u"'^'",
+            u"':'", u"'='", u"'\\neq'", u"'<'", u"'\\leqq'", u"'\\leqslant'",
+            u"'>'", u"'\\geqq'", u"'\\geqslant'", u"'!'" ]
 
     symbolicNames = [ u"<INVALID>",
             u"WS", u"THINSPACE", u"MEDSPACE", u"THICKSPACE", u"QUAD", u"QQUAD",
-            u"NEGTHINSPACE", u"NEGMEDSPACE", u"NEGTHICKSPACE", u"CMD_LEFT",
-            u"CMD_RIGHT", u"IGNORE", u"ADD", u"SUB", u"MUL", u"DIV", u"L_PAREN",
-            u"R_PAREN", u"L_BRACE", u"R_BRACE", u"L_BRACE_LITERAL", u"R_BRACE_LITERAL",
-            u"L_BRACKET", u"R_BRACKET", u"BAR", u"R_BAR", u"L_BAR", u"L_ANGLE",
-            u"R_ANGLE", u"FUNC_LIM", u"LIM_APPROACH_SYM", u"FUNC_INT", u"FUNC_SUM",
-            u"FUNC_PROD", u"FUNC_EXP", u"FUNC_LOG", u"FUNC_LN", u"FUNC_SIN",
-            u"FUNC_COS", u"FUNC_TAN", u"FUNC_CSC", u"FUNC_SEC", u"FUNC_COT",
-            u"FUNC_ARCSIN", u"FUNC_ARCCOS", u"FUNC_ARCTAN", u"FUNC_ARCCSC",
-            u"FUNC_ARCSEC", u"FUNC_ARCCOT", u"FUNC_SINH", u"FUNC_COSH",
-            u"FUNC_TANH", u"FUNC_ARSINH", u"FUNC_ARCOSH", u"FUNC_ARTANH",
-            u"L_FLOOR", u"R_FLOOR", u"L_CEIL", u"R_CEIL", u"FUNC_SQRT",
-            u"CMD_TIMES", u"CMD_CDOT", u"CMD_DIV", u"CMD_FRAC", u"CMD_BINOM",
-            u"CMD_DBINOM", u"CMD_TBINOM", u"CMD_MATHIT", u"UNDERSCORE",
-            u"CARET", u"COLON", u"DIFFERENTIAL", u"LETTER", u"NUMBER", u"EQUAL",
-            u"NEQ", u"LT", u"LTE", u"LTE_Q", u"LTE_S", u"GT", u"GTE", u"GTE_Q",
-            u"GTE_S", u"BANG", u"SYMBOL" ]
+            u"NEGTHINSPACE", u"NEGMEDSPACE", u"NEGTHICKSPACE", u"ADD", u"SUB",
+            u"MUL", u"DIV", u"L_PAREN", u"R_PAREN", u"L_BRACE", u"R_BRACE",
+            u"L_BRACE_LITERAL", u"R_BRACE_LITERAL", u"L_BRACKET", u"R_BRACKET",
+            u"CMD_LEFT", u"CMD_RIGHT", u"BAR", u"FUNC_LIM", u"LIM_APPROACH_SYM",
+            u"FUNC_INT", u"FUNC_SUM", u"FUNC_PROD", u"FUNC_EXP", u"FUNC_LOG",
+            u"FUNC_LN", u"FUNC_SIN", u"FUNC_COS", u"FUNC_TAN", u"FUNC_CSC",
+            u"FUNC_SEC", u"FUNC_COT", u"FUNC_ARCSIN", u"FUNC_ARCCOS", u"FUNC_ARCTAN",
+            u"FUNC_ARCCSC", u"FUNC_ARCSEC", u"FUNC_ARCCOT", u"FUNC_SINH",
+            u"FUNC_COSH", u"FUNC_TANH", u"FUNC_ARSINH", u"FUNC_ARCOSH",
+            u"FUNC_ARTANH", u"FUNC_SQRT", u"CMD_TIMES", u"CMD_CDOT", u"CMD_DIV",
+            u"CMD_FRAC", u"CMD_BINOM", u"CMD_DBINOM", u"CMD_TBINOM", u"CMD_MATHIT",
+            u"UNDERSCORE", u"CARET", u"COLON", u"DIFFERENTIAL", u"LETTER",
+            u"NUMBER", u"EQUAL", u"NEQ", u"LT", u"LTE", u"LTE_Q", u"LTE_S",
+            u"GT", u"GTE", u"GTE_Q", u"GTE_S", u"BANG", u"SYMBOL" ]
 
     ruleNames = [ u"T__0", u"WS", u"THINSPACE", u"MEDSPACE", u"THICKSPACE",
                   u"QUAD", u"QQUAD", u"NEGTHINSPACE", u"NEGMEDSPACE", u"NEGTHICKSPACE",
-                  u"CMD_LEFT", u"CMD_RIGHT", u"IGNORE", u"ADD", u"SUB",
-                  u"MUL", u"DIV", u"L_PAREN", u"R_PAREN", u"L_BRACE", u"R_BRACE",
-                  u"L_BRACE_LITERAL", u"R_BRACE_LITERAL", u"L_BRACKET",
-                  u"R_BRACKET", u"BAR", u"R_BAR", u"L_BAR", u"L_ANGLE",
-                  u"R_ANGLE", u"FUNC_LIM", u"LIM_APPROACH_SYM", u"FUNC_INT",
+                  u"ADD", u"SUB", u"MUL", u"DIV", u"L_PAREN", u"R_PAREN",
+                  u"L_BRACE", u"R_BRACE", u"L_BRACE_LITERAL", u"R_BRACE_LITERAL",
+                  u"L_BRACKET", u"R_BRACKET", u"CMD_LEFT", u"CMD_RIGHT",
+                  u"BAR", u"FUNC_LIM", u"LIM_APPROACH_SYM", u"FUNC_INT",
                   u"FUNC_SUM", u"FUNC_PROD", u"FUNC_EXP", u"FUNC_LOG", u"FUNC_LN",
                   u"FUNC_SIN", u"FUNC_COS", u"FUNC_TAN", u"FUNC_CSC", u"FUNC_SEC",
                   u"FUNC_COT", u"FUNC_ARCSIN", u"FUNC_ARCCOS", u"FUNC_ARCTAN",
                   u"FUNC_ARCCSC", u"FUNC_ARCSEC", u"FUNC_ARCCOT", u"FUNC_SINH",
                   u"FUNC_COSH", u"FUNC_TANH", u"FUNC_ARSINH", u"FUNC_ARCOSH",
-                  u"FUNC_ARTANH", u"L_FLOOR", u"R_FLOOR", u"L_CEIL", u"R_CEIL",
-                  u"FUNC_SQRT", u"CMD_TIMES", u"CMD_CDOT", u"CMD_DIV", u"CMD_FRAC",
-                  u"CMD_BINOM", u"CMD_DBINOM", u"CMD_TBINOM", u"CMD_MATHIT",
-                  u"UNDERSCORE", u"CARET", u"COLON", u"WS_CHAR", u"DIFFERENTIAL",
-                  u"LETTER", u"DIGIT", u"NUMBER", u"EQUAL", u"NEQ", u"LT",
-                  u"LTE", u"LTE_Q", u"LTE_S", u"GT", u"GTE", u"GTE_Q", u"GTE_S",
-                  u"BANG", u"SYMBOL" ]
+                  u"FUNC_ARTANH", u"FUNC_SQRT", u"CMD_TIMES", u"CMD_CDOT",
+                  u"CMD_DIV", u"CMD_FRAC", u"CMD_BINOM", u"CMD_DBINOM",
+                  u"CMD_TBINOM", u"CMD_MATHIT", u"UNDERSCORE", u"CARET",
+                  u"COLON", u"WS_CHAR", u"DIFFERENTIAL", u"LETTER", u"DIGIT",
+                  u"NUMBER", u"EQUAL", u"NEQ", u"LT", u"LTE", u"LTE_Q",
+                  u"LTE_S", u"GT", u"GTE", u"GTE_Q", u"GTE_S", u"BANG",
+                  u"SYMBOL" ]
 
     grammarFileName = u"LaTeX.g4"
 
diff --git a/sympy/parsing/latex/_antlr/latexparser.py b/sympy/parsing/latex/_antlr/latexparser.py
index 704339b832..c78289915d 100644
--- a/sympy/parsing/latex/_antlr/latexparser.py
+++ b/sympy/parsing/latex/_antlr/latexparser.py
@@ -19,225 +19,213 @@
 def serializedATN():
     with StringIO() as buf:
         buf.write(u"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3")
-        buf.write(u"Y\u01d0\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t")
+        buf.write(u"P\u01b2\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t")
         buf.write(u"\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r")
         buf.write(u"\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4")
         buf.write(u"\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30")
         buf.write(u"\t\30\4\31\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t")
         buf.write(u"\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)\3\2\3\2\3\3\3\3\3")
-        buf.write(u"\3\3\3\3\3\3\3\7\3[\n\3\f\3\16\3^\13\3\3\4\3\4\3\4\3")
-        buf.write(u"\4\3\5\3\5\3\6\3\6\3\6\3\6\3\6\3\6\7\6l\n\6\f\6\16\6")
-        buf.write(u"o\13\6\3\7\3\7\3\7\3\7\3\7\3\7\7\7w\n\7\f\7\16\7z\13")
-        buf.write(u"\7\3\b\3\b\3\b\3\b\3\b\3\b\7\b\u0082\n\b\f\b\16\b\u0085")
-        buf.write(u"\13\b\3\t\3\t\3\t\6\t\u008a\n\t\r\t\16\t\u008b\5\t\u008e")
-        buf.write(u"\n\t\3\n\3\n\3\n\3\n\7\n\u0094\n\n\f\n\16\n\u0097\13")
-        buf.write(u"\n\5\n\u0099\n\n\3\13\3\13\7\13\u009d\n\13\f\13\16\13")
-        buf.write(u"\u00a0\13\13\3\f\3\f\7\f\u00a4\n\f\f\f\16\f\u00a7\13")
-        buf.write(u"\f\3\r\3\r\5\r\u00ab\n\r\3\16\3\16\3\16\3\16\3\16\3\16")
-        buf.write(u"\5\16\u00b3\n\16\3\17\3\17\3\17\3\17\5\17\u00b9\n\17")
-        buf.write(u"\3\17\3\17\3\20\3\20\3\20\3\20\5\20\u00c1\n\20\3\20\3")
-        buf.write(u"\20\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21")
-        buf.write(u"\5\21\u00cf\n\21\3\21\5\21\u00d2\n\21\7\21\u00d4\n\21")
-        buf.write(u"\f\21\16\21\u00d7\13\21\3\22\3\22\3\22\3\22\3\22\3\22")
-        buf.write(u"\3\22\3\22\3\22\3\22\5\22\u00e3\n\22\3\22\5\22\u00e6")
-        buf.write(u"\n\22\7\22\u00e8\n\22\f\22\16\22\u00eb\13\22\3\23\3\23")
-        buf.write(u"\3\23\3\23\3\23\3\23\3\23\3\23\5\23\u00f5\n\23\3\24\3")
-        buf.write(u"\24\3\24\3\24\3\24\3\24\3\24\5\24\u00fe\n\24\3\25\3\25")
-        buf.write(u"\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3")
-        buf.write(u"\25\3\25\3\25\3\25\5\25\u0110\n\25\3\26\3\26\3\26\3\26")
-        buf.write(u"\3\27\3\27\5\27\u0118\n\27\3\27\3\27\3\27\3\27\3\27\5")
-        buf.write(u"\27\u011f\n\27\3\30\3\30\3\30\3\30\3\31\3\31\3\31\3\31")
-        buf.write(u"\3\32\3\32\3\32\3\32\3\32\3\33\7\33\u012f\n\33\f\33\16")
-        buf.write(u"\33\u0132\13\33\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3")
-        buf.write(u"\34\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\36\3\36")
-        buf.write(u"\3\36\3\36\3\37\3\37\3\37\3\37\3 \3 \3!\3!\5!\u0150\n")
-        buf.write(u"!\3!\5!\u0153\n!\3!\5!\u0156\n!\3!\5!\u0159\n!\5!\u015b")
-        buf.write(u"\n!\3!\3!\3!\3!\3!\5!\u0162\n!\3!\3!\5!\u0166\n!\3!\3")
-        buf.write(u"!\3!\3!\3!\3!\3!\3!\3!\3!\3!\5!\u0173\n!\3!\5!\u0176")
-        buf.write(u"\n!\3!\3!\3!\5!\u017b\n!\3!\3!\3!\3!\3!\5!\u0182\n!\3")
-        buf.write(u"!\3!\3!\3!\3!\3!\3!\3!\3!\3!\3!\5!\u018f\n!\3!\3!\3!")
-        buf.write(u"\3!\3!\3!\5!\u0197\n!\3\"\3\"\3\"\3\"\3\"\5\"\u019e\n")
-        buf.write(u"\"\3#\3#\3#\3#\3#\3#\3#\3#\3#\5#\u01a9\n#\3#\3#\3$\3")
-        buf.write(u"$\3$\3$\3$\5$\u01b2\n$\3%\3%\3&\3&\3&\3&\3&\3&\5&\u01bc")
-        buf.write(u"\n&\3\'\3\'\3\'\3\'\3\'\3\'\5\'\u01c4\n\'\3(\3(\3(\3")
-        buf.write(u"(\3(\3)\3)\3)\3)\3)\3)\2\b\4\n\f\16 \"*\2\4\6\b\n\f\16")
-        buf.write(u"\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BD")
-        buf.write(u"FHJLNP\2\13\4\2NQTU\3\2\20\21\5\2\22\23@BJJ\4\2LLYY\3")
-        buf.write(u"\2\34\35\4\2\34\34\36\36\3\2DF\3\2&:\3\2$%\2\u01eb\2")
-        buf.write(u"R\3\2\2\2\4T\3\2\2\2\6_\3\2\2\2\bc\3\2\2\2\ne\3\2\2\2")
-        buf.write(u"\fp\3\2\2\2\16{\3\2\2\2\20\u008d\3\2\2\2\22\u0098\3\2")
-        buf.write(u"\2\2\24\u009a\3\2\2\2\26\u00a1\3\2\2\2\30\u00aa\3\2\2")
-        buf.write(u"\2\32\u00ac\3\2\2\2\34\u00b4\3\2\2\2\36\u00bc\3\2\2\2")
-        buf.write(u" \u00c4\3\2\2\2\"\u00d8\3\2\2\2$\u00f4\3\2\2\2&\u00fd")
-        buf.write(u"\3\2\2\2(\u010f\3\2\2\2*\u0111\3\2\2\2,\u011e\3\2\2\2")
-        buf.write(u".\u0120\3\2\2\2\60\u0124\3\2\2\2\62\u0128\3\2\2\2\64")
-        buf.write(u"\u0130\3\2\2\2\66\u0133\3\2\2\28\u013b\3\2\2\2:\u0143")
-        buf.write(u"\3\2\2\2<\u0147\3\2\2\2>\u014b\3\2\2\2@\u0196\3\2\2\2")
-        buf.write(u"B\u019d\3\2\2\2D\u019f\3\2\2\2F\u01b1\3\2\2\2H\u01b3")
-        buf.write(u"\3\2\2\2J\u01b5\3\2\2\2L\u01bd\3\2\2\2N\u01c5\3\2\2\2")
-        buf.write(u"P\u01ca\3\2\2\2RS\5\4\3\2S\3\3\2\2\2TU\b\3\1\2UV\5\b")
-        buf.write(u"\5\2V\\\3\2\2\2WX\f\4\2\2XY\t\2\2\2Y[\5\4\3\5ZW\3\2\2")
-        buf.write(u"\2[^\3\2\2\2\\Z\3\2\2\2\\]\3\2\2\2]\5\3\2\2\2^\\\3\2")
-        buf.write(u"\2\2_`\5\b\5\2`a\7N\2\2ab\5\b\5\2b\7\3\2\2\2cd\5\n\6")
-        buf.write(u"\2d\t\3\2\2\2ef\b\6\1\2fg\5\f\7\2gm\3\2\2\2hi\f\4\2\2")
-        buf.write(u"ij\t\3\2\2jl\5\n\6\5kh\3\2\2\2lo\3\2\2\2mk\3\2\2\2mn")
-        buf.write(u"\3\2\2\2n\13\3\2\2\2om\3\2\2\2pq\b\7\1\2qr\5\20\t\2r")
-        buf.write(u"x\3\2\2\2st\f\4\2\2tu\t\4\2\2uw\5\f\7\5vs\3\2\2\2wz\3")
-        buf.write(u"\2\2\2xv\3\2\2\2xy\3\2\2\2y\r\3\2\2\2zx\3\2\2\2{|\b\b")
-        buf.write(u"\1\2|}\5\22\n\2}\u0083\3\2\2\2~\177\f\4\2\2\177\u0080")
-        buf.write(u"\t\4\2\2\u0080\u0082\5\16\b\5\u0081~\3\2\2\2\u0082\u0085")
-        buf.write(u"\3\2\2\2\u0083\u0081\3\2\2\2\u0083\u0084\3\2\2\2\u0084")
-        buf.write(u"\17\3\2\2\2\u0085\u0083\3\2\2\2\u0086\u0087\t\3\2\2\u0087")
-        buf.write(u"\u008e\5\20\t\2\u0088\u008a\5\24\13\2\u0089\u0088\3\2")
-        buf.write(u"\2\2\u008a\u008b\3\2\2\2\u008b\u0089\3\2\2\2\u008b\u008c")
-        buf.write(u"\3\2\2\2\u008c\u008e\3\2\2\2\u008d\u0086\3\2\2\2\u008d")
-        buf.write(u"\u0089\3\2\2\2\u008e\21\3\2\2\2\u008f\u0090\t\3\2\2\u0090")
-        buf.write(u"\u0099\5\22\n\2\u0091\u0095\5\24\13\2\u0092\u0094\5\26")
-        buf.write(u"\f\2\u0093\u0092\3\2\2\2\u0094\u0097\3\2\2\2\u0095\u0093")
-        buf.write(u"\3\2\2\2\u0095\u0096\3\2\2\2\u0096\u0099\3\2\2\2\u0097")
-        buf.write(u"\u0095\3\2\2\2\u0098\u008f\3\2\2\2\u0098\u0091\3\2\2")
-        buf.write(u"\2\u0099\23\3\2\2\2\u009a\u009e\5 \21\2\u009b\u009d\5")
-        buf.write(u"\30\r\2\u009c\u009b\3\2\2\2\u009d\u00a0\3\2\2\2\u009e")
-        buf.write(u"\u009c\3\2\2\2\u009e\u009f\3\2\2\2\u009f\25\3\2\2\2\u00a0")
-        buf.write(u"\u009e\3\2\2\2\u00a1\u00a5\5\"\22\2\u00a2\u00a4\5\30")
-        buf.write(u"\r\2\u00a3\u00a2\3\2\2\2\u00a4\u00a7\3\2\2\2\u00a5\u00a3")
-        buf.write(u"\3\2\2\2\u00a5\u00a6\3\2\2\2\u00a6\27\3\2\2\2\u00a7\u00a5")
-        buf.write(u"\3\2\2\2\u00a8\u00ab\7X\2\2\u00a9\u00ab\5\32\16\2\u00aa")
-        buf.write(u"\u00a8\3\2\2\2\u00aa\u00a9\3\2\2\2\u00ab\31\3\2\2\2\u00ac")
-        buf.write(u"\u00b2\7\34\2\2\u00ad\u00b3\5\36\20\2\u00ae\u00b3\5\34")
-        buf.write(u"\17\2\u00af\u00b0\5\36\20\2\u00b0\u00b1\5\34\17\2\u00b1")
-        buf.write(u"\u00b3\3\2\2\2\u00b2\u00ad\3\2\2\2\u00b2\u00ae\3\2\2")
-        buf.write(u"\2\u00b2\u00af\3\2\2\2\u00b3\33\3\2\2\2\u00b4\u00b5\7")
-        buf.write(u"H\2\2\u00b5\u00b8\7\26\2\2\u00b6\u00b9\5\b\5\2\u00b7")
+        buf.write(u"\t$\4%\t%\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\3\7\3S\n\3\f")
+        buf.write(u"\3\16\3V\13\3\3\4\3\4\3\4\3\4\3\5\3\5\3\6\3\6\3\6\3\6")
+        buf.write(u"\3\6\3\6\7\6d\n\6\f\6\16\6g\13\6\3\7\3\7\3\7\3\7\3\7")
+        buf.write(u"\3\7\7\7o\n\7\f\7\16\7r\13\7\3\b\3\b\3\b\3\b\3\b\3\b")
+        buf.write(u"\7\bz\n\b\f\b\16\b}\13\b\3\t\3\t\3\t\6\t\u0082\n\t\r")
+        buf.write(u"\t\16\t\u0083\5\t\u0086\n\t\3\n\3\n\3\n\3\n\7\n\u008c")
+        buf.write(u"\n\n\f\n\16\n\u008f\13\n\5\n\u0091\n\n\3\13\3\13\7\13")
+        buf.write(u"\u0095\n\13\f\13\16\13\u0098\13\13\3\f\3\f\7\f\u009c")
+        buf.write(u"\n\f\f\f\16\f\u009f\13\f\3\r\3\r\5\r\u00a3\n\r\3\16\3")
+        buf.write(u"\16\3\16\3\16\3\16\3\16\5\16\u00ab\n\16\3\17\3\17\3\17")
+        buf.write(u"\3\17\5\17\u00b1\n\17\3\17\3\17\3\20\3\20\3\20\3\20\5")
+        buf.write(u"\20\u00b9\n\20\3\20\3\20\3\21\3\21\3\21\3\21\3\21\3\21")
+        buf.write(u"\3\21\3\21\3\21\3\21\5\21\u00c7\n\21\3\21\5\21\u00ca")
+        buf.write(u"\n\21\7\21\u00cc\n\21\f\21\16\21\u00cf\13\21\3\22\3\22")
+        buf.write(u"\3\22\3\22\3\22\3\22\3\22\3\22\3\22\3\22\5\22\u00db\n")
+        buf.write(u"\22\3\22\5\22\u00de\n\22\7\22\u00e0\n\22\f\22\16\22\u00e3")
+        buf.write(u"\13\22\3\23\3\23\3\23\3\23\3\23\3\23\5\23\u00eb\n\23")
+        buf.write(u"\3\24\3\24\3\24\3\24\3\24\5\24\u00f2\n\24\3\25\3\25\3")
+        buf.write(u"\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25")
+        buf.write(u"\3\25\3\25\3\25\5\25\u0104\n\25\3\26\3\26\3\26\3\26\3")
+        buf.write(u"\27\3\27\5\27\u010c\n\27\3\27\3\27\3\27\5\27\u0111\n")
+        buf.write(u"\27\3\30\3\30\3\30\3\30\3\30\3\31\7\31\u0119\n\31\f\31")
+        buf.write(u"\16\31\u011c\13\31\3\32\3\32\3\32\3\32\3\32\3\32\3\32")
+        buf.write(u"\3\32\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\34\3")
+        buf.write(u"\34\3\35\3\35\5\35\u0132\n\35\3\35\5\35\u0135\n\35\3")
+        buf.write(u"\35\5\35\u0138\n\35\3\35\5\35\u013b\n\35\5\35\u013d\n")
+        buf.write(u"\35\3\35\3\35\3\35\3\35\3\35\5\35\u0144\n\35\3\35\3\35")
+        buf.write(u"\5\35\u0148\n\35\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3")
+        buf.write(u"\35\3\35\3\35\3\35\5\35\u0155\n\35\3\35\5\35\u0158\n")
+        buf.write(u"\35\3\35\3\35\3\35\5\35\u015d\n\35\3\35\3\35\3\35\3\35")
+        buf.write(u"\3\35\5\35\u0164\n\35\3\35\3\35\3\35\3\35\3\35\3\35\3")
+        buf.write(u"\35\3\35\3\35\3\35\3\35\5\35\u0171\n\35\3\35\3\35\3\35")
+        buf.write(u"\3\35\3\35\3\35\5\35\u0179\n\35\3\36\3\36\3\36\3\36\3")
+        buf.write(u"\36\5\36\u0180\n\36\3\37\3\37\3\37\3\37\3\37\3\37\3\37")
+        buf.write(u"\3\37\3\37\5\37\u018b\n\37\3\37\3\37\3 \3 \3 \3 \3 \5")
+        buf.write(u" \u0194\n \3!\3!\3\"\3\"\3\"\3\"\3\"\3\"\5\"\u019e\n")
+        buf.write(u"\"\3#\3#\3#\3#\3#\3#\5#\u01a6\n#\3$\3$\3$\3$\3$\3%\3")
+        buf.write(u"%\3%\3%\3%\3%\2\b\4\n\f\16 \"&\2\4\6\b\n\f\16\20\22\24")
+        buf.write(u"\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFH\2\t\4\2")
+        buf.write(u"EHKL\3\2\r\16\5\2\17\20\679AA\4\2CCPP\3\2;=\3\2!\65\3")
+        buf.write(u"\2\37 \2\u01cb\2J\3\2\2\2\4L\3\2\2\2\6W\3\2\2\2\b[\3")
+        buf.write(u"\2\2\2\n]\3\2\2\2\fh\3\2\2\2\16s\3\2\2\2\20\u0085\3\2")
+        buf.write(u"\2\2\22\u0090\3\2\2\2\24\u0092\3\2\2\2\26\u0099\3\2\2")
+        buf.write(u"\2\30\u00a2\3\2\2\2\32\u00a4\3\2\2\2\34\u00ac\3\2\2\2")
+        buf.write(u"\36\u00b4\3\2\2\2 \u00bc\3\2\2\2\"\u00d0\3\2\2\2$\u00ea")
+        buf.write(u"\3\2\2\2&\u00f1\3\2\2\2(\u0103\3\2\2\2*\u0105\3\2\2\2")
+        buf.write(u",\u0110\3\2\2\2.\u0112\3\2\2\2\60\u011a\3\2\2\2\62\u011d")
+        buf.write(u"\3\2\2\2\64\u0125\3\2\2\2\66\u012d\3\2\2\28\u0178\3\2")
+        buf.write(u"\2\2:\u017f\3\2\2\2<\u0181\3\2\2\2>\u0193\3\2\2\2@\u0195")
+        buf.write(u"\3\2\2\2B\u0197\3\2\2\2D\u019f\3\2\2\2F\u01a7\3\2\2\2")
+        buf.write(u"H\u01ac\3\2\2\2JK\5\4\3\2K\3\3\2\2\2LM\b\3\1\2MN\5\b")
+        buf.write(u"\5\2NT\3\2\2\2OP\f\4\2\2PQ\t\2\2\2QS\5\4\3\5RO\3\2\2")
+        buf.write(u"\2SV\3\2\2\2TR\3\2\2\2TU\3\2\2\2U\5\3\2\2\2VT\3\2\2\2")
+        buf.write(u"WX\5\b\5\2XY\7E\2\2YZ\5\b\5\2Z\7\3\2\2\2[\\\5\n\6\2\\")
+        buf.write(u"\t\3\2\2\2]^\b\6\1\2^_\5\f\7\2_e\3\2\2\2`a\f\4\2\2ab")
+        buf.write(u"\t\3\2\2bd\5\n\6\5c`\3\2\2\2dg\3\2\2\2ec\3\2\2\2ef\3")
+        buf.write(u"\2\2\2f\13\3\2\2\2ge\3\2\2\2hi\b\7\1\2ij\5\20\t\2jp\3")
+        buf.write(u"\2\2\2kl\f\4\2\2lm\t\4\2\2mo\5\f\7\5nk\3\2\2\2or\3\2")
+        buf.write(u"\2\2pn\3\2\2\2pq\3\2\2\2q\r\3\2\2\2rp\3\2\2\2st\b\b\1")
+        buf.write(u"\2tu\5\22\n\2u{\3\2\2\2vw\f\4\2\2wx\t\4\2\2xz\5\16\b")
+        buf.write(u"\5yv\3\2\2\2z}\3\2\2\2{y\3\2\2\2{|\3\2\2\2|\17\3\2\2")
+        buf.write(u"\2}{\3\2\2\2~\177\t\3\2\2\177\u0086\5\20\t\2\u0080\u0082")
+        buf.write(u"\5\24\13\2\u0081\u0080\3\2\2\2\u0082\u0083\3\2\2\2\u0083")
+        buf.write(u"\u0081\3\2\2\2\u0083\u0084\3\2\2\2\u0084\u0086\3\2\2")
+        buf.write(u"\2\u0085~\3\2\2\2\u0085\u0081\3\2\2\2\u0086\21\3\2\2")
+        buf.write(u"\2\u0087\u0088\t\3\2\2\u0088\u0091\5\22\n\2\u0089\u008d")
+        buf.write(u"\5\24\13\2\u008a\u008c\5\26\f\2\u008b\u008a\3\2\2\2\u008c")
+        buf.write(u"\u008f\3\2\2\2\u008d\u008b\3\2\2\2\u008d\u008e\3\2\2")
+        buf.write(u"\2\u008e\u0091\3\2\2\2\u008f\u008d\3\2\2\2\u0090\u0087")
+        buf.write(u"\3\2\2\2\u0090\u0089\3\2\2\2\u0091\23\3\2\2\2\u0092\u0096")
+        buf.write(u"\5 \21\2\u0093\u0095\5\30\r\2\u0094\u0093\3\2\2\2\u0095")
+        buf.write(u"\u0098\3\2\2\2\u0096\u0094\3\2\2\2\u0096\u0097\3\2\2")
+        buf.write(u"\2\u0097\25\3\2\2\2\u0098\u0096\3\2\2\2\u0099\u009d\5")
+        buf.write(u"\"\22\2\u009a\u009c\5\30\r\2\u009b\u009a\3\2\2\2\u009c")
+        buf.write(u"\u009f\3\2\2\2\u009d\u009b\3\2\2\2\u009d\u009e\3\2\2")
+        buf.write(u"\2\u009e\27\3\2\2\2\u009f\u009d\3\2\2\2\u00a0\u00a3\7")
+        buf.write(u"O\2\2\u00a1\u00a3\5\32\16\2\u00a2\u00a0\3\2\2\2\u00a2")
+        buf.write(u"\u00a1\3\2\2\2\u00a3\31\3\2\2\2\u00a4\u00aa\7\33\2\2")
+        buf.write(u"\u00a5\u00ab\5\36\20\2\u00a6\u00ab\5\34\17\2\u00a7\u00a8")
+        buf.write(u"\5\36\20\2\u00a8\u00a9\5\34\17\2\u00a9\u00ab\3\2\2\2")
+        buf.write(u"\u00aa\u00a5\3\2\2\2\u00aa\u00a6\3\2\2\2\u00aa\u00a7")
+        buf.write(u"\3\2\2\2\u00ab\33\3\2\2\2\u00ac\u00ad\7?\2\2\u00ad\u00b0")
+        buf.write(u"\7\23\2\2\u00ae\u00b1\5\b\5\2\u00af\u00b1\5\6\4\2\u00b0")
+        buf.write(u"\u00ae\3\2\2\2\u00b0\u00af\3\2\2\2\u00b1\u00b2\3\2\2")
+        buf.write(u"\2\u00b2\u00b3\7\24\2\2\u00b3\35\3\2\2\2\u00b4\u00b5")
+        buf.write(u"\7@\2\2\u00b5\u00b8\7\23\2\2\u00b6\u00b9\5\b\5\2\u00b7")
         buf.write(u"\u00b9\5\6\4\2\u00b8\u00b6\3\2\2\2\u00b8\u00b7\3\2\2")
-        buf.write(u"\2\u00b9\u00ba\3\2\2\2\u00ba\u00bb\7\27\2\2\u00bb\35")
-        buf.write(u"\3\2\2\2\u00bc\u00bd\7I\2\2\u00bd\u00c0\7\26\2\2\u00be")
-        buf.write(u"\u00c1\5\b\5\2\u00bf\u00c1\5\6\4\2\u00c0\u00be\3\2\2")
-        buf.write(u"\2\u00c0\u00bf\3\2\2\2\u00c1\u00c2\3\2\2\2\u00c2\u00c3")
-        buf.write(u"\7\27\2\2\u00c3\37\3\2\2\2\u00c4\u00c5\b\21\1\2\u00c5")
-        buf.write(u"\u00c6\5$\23\2\u00c6\u00d5\3\2\2\2\u00c7\u00c8\f\4\2")
-        buf.write(u"\2\u00c8\u00ce\7I\2\2\u00c9\u00cf\5,\27\2\u00ca\u00cb")
-        buf.write(u"\7\26\2\2\u00cb\u00cc\5\b\5\2\u00cc\u00cd\7\27\2\2\u00cd")
-        buf.write(u"\u00cf\3\2\2\2\u00ce\u00c9\3\2\2\2\u00ce\u00ca\3\2\2")
-        buf.write(u"\2\u00cf\u00d1\3\2\2\2\u00d0\u00d2\5J&\2\u00d1\u00d0")
-        buf.write(u"\3\2\2\2\u00d1\u00d2\3\2\2\2\u00d2\u00d4\3\2\2\2\u00d3")
-        buf.write(u"\u00c7\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!\3\2\2\2\u00d7\u00d5\3\2")
-        buf.write(u"\2\2\u00d8\u00d9\b\22\1\2\u00d9\u00da\5&\24\2\u00da\u00e9")
-        buf.write(u"\3\2\2\2\u00db\u00dc\f\4\2\2\u00dc\u00e2\7I\2\2\u00dd")
-        buf.write(u"\u00e3\5,\27\2\u00de\u00df\7\26\2\2\u00df\u00e0\5\b\5")
-        buf.write(u"\2\u00e0\u00e1\7\27\2\2\u00e1\u00e3\3\2\2\2\u00e2\u00dd")
-        buf.write(u"\3\2\2\2\u00e2\u00de\3\2\2\2\u00e3\u00e5\3\2\2\2\u00e4")
-        buf.write(u"\u00e6\5J&\2\u00e5\u00e4\3\2\2\2\u00e5\u00e6\3\2\2\2")
-        buf.write(u"\u00e6\u00e8\3\2\2\2\u00e7\u00db\3\2\2\2\u00e8\u00eb")
-        buf.write(u"\3\2\2\2\u00e9\u00e7\3\2\2\2\u00e9\u00ea\3\2\2\2\u00ea")
-        buf.write(u"#\3\2\2\2\u00eb\u00e9\3\2\2\2\u00ec\u00f5\5(\25\2\u00ed")
-        buf.write(u"\u00f5\5*\26\2\u00ee\u00f5\5@!\2\u00ef\u00f5\5,\27\2")
-        buf.write(u"\u00f0\u00f5\5\66\34\2\u00f1\u00f5\58\35\2\u00f2\u00f5")
-        buf.write(u"\5:\36\2\u00f3\u00f5\5<\37\2\u00f4\u00ec\3\2\2\2\u00f4")
-        buf.write(u"\u00ed\3\2\2\2\u00f4\u00ee\3\2\2\2\u00f4\u00ef\3\2\2")
-        buf.write(u"\2\u00f4\u00f0\3\2\2\2\u00f4\u00f1\3\2\2\2\u00f4\u00f2")
-        buf.write(u"\3\2\2\2\u00f4\u00f3\3\2\2\2\u00f5%\3\2\2\2\u00f6\u00fe")
-        buf.write(u"\5(\25\2\u00f7\u00fe\5*\26\2\u00f8\u00fe\5,\27\2\u00f9")
-        buf.write(u"\u00fe\5\66\34\2\u00fa\u00fe\58\35\2\u00fb\u00fe\5:\36")
-        buf.write(u"\2\u00fc\u00fe\5<\37\2\u00fd\u00f6\3\2\2\2\u00fd\u00f7")
-        buf.write(u"\3\2\2\2\u00fd\u00f8\3\2\2\2\u00fd\u00f9\3\2\2\2\u00fd")
-        buf.write(u"\u00fa\3\2\2\2\u00fd\u00fb\3\2\2\2\u00fd\u00fc\3\2\2")
-        buf.write(u"\2\u00fe\'\3\2\2\2\u00ff\u0100\7\24\2\2\u0100\u0101\5")
-        buf.write(u"\b\5\2\u0101\u0102\7\25\2\2\u0102\u0110\3\2\2\2\u0103")
-        buf.write(u"\u0104\7\32\2\2\u0104\u0105\5\b\5\2\u0105\u0106\7\33")
-        buf.write(u"\2\2\u0106\u0110\3\2\2\2\u0107\u0108\7\26\2\2\u0108\u0109")
-        buf.write(u"\5\b\5\2\u0109\u010a\7\27\2\2\u010a\u0110\3\2\2\2\u010b")
-        buf.write(u"\u010c\7\30\2\2\u010c\u010d\5\b\5\2\u010d\u010e\7\31")
-        buf.write(u"\2\2\u010e\u0110\3\2\2\2\u010f\u00ff\3\2\2\2\u010f\u0103")
-        buf.write(u"\3\2\2\2\u010f\u0107\3\2\2\2\u010f\u010b\3\2\2\2\u0110")
-        buf.write(u")\3\2\2\2\u0111\u0112\7\34\2\2\u0112\u0113\5\b\5\2\u0113")
-        buf.write(u"\u0114\7\34\2\2\u0114+\3\2\2\2\u0115\u0117\t\5\2\2\u0116")
-        buf.write(u"\u0118\5J&\2\u0117\u0116\3\2\2\2\u0117\u0118\3\2\2\2")
-        buf.write(u"\u0118\u011f\3\2\2\2\u0119\u011f\7M\2\2\u011a\u011f\7")
-        buf.write(u"K\2\2\u011b\u011f\5\62\32\2\u011c\u011f\5.\30\2\u011d")
-        buf.write(u"\u011f\5\60\31\2\u011e\u0115\3\2\2\2\u011e\u0119\3\2")
-        buf.write(u"\2\2\u011e\u011a\3\2\2\2\u011e\u011b\3\2\2\2\u011e\u011c")
-        buf.write(u"\3\2\2\2\u011e\u011d\3\2\2\2\u011f-\3\2\2\2\u0120\u0121")
-        buf.write(u"\7\37\2\2\u0121\u0122\5\b\5\2\u0122\u0123\t\6\2\2\u0123")
-        buf.write(u"/\3\2\2\2\u0124\u0125\t\7\2\2\u0125\u0126\5\b\5\2\u0126")
-        buf.write(u"\u0127\7 \2\2\u0127\61\3\2\2\2\u0128\u0129\7G\2\2\u0129")
-        buf.write(u"\u012a\7\26\2\2\u012a\u012b\5\64\33\2\u012b\u012c\7\27")
-        buf.write(u"\2\2\u012c\63\3\2\2\2\u012d\u012f\7L\2\2\u012e\u012d")
-        buf.write(u"\3\2\2\2\u012f\u0132\3\2\2\2\u0130\u012e\3\2\2\2\u0130")
-        buf.write(u"\u0131\3\2\2\2\u0131\65\3\2\2\2\u0132\u0130\3\2\2\2\u0133")
-        buf.write(u"\u0134\7C\2\2\u0134\u0135\7\26\2\2\u0135\u0136\5\b\5")
-        buf.write(u"\2\u0136\u0137\7\27\2\2\u0137\u0138\7\26\2\2\u0138\u0139")
-        buf.write(u"\5\b\5\2\u0139\u013a\7\27\2\2\u013a\67\3\2\2\2\u013b")
-        buf.write(u"\u013c\t\b\2\2\u013c\u013d\7\26\2\2\u013d\u013e\5\b\5")
-        buf.write(u"\2\u013e\u013f\7\27\2\2\u013f\u0140\7\26\2\2\u0140\u0141")
-        buf.write(u"\5\b\5\2\u0141\u0142\7\27\2\2\u01429\3\2\2\2\u0143\u0144")
-        buf.write(u"\7;\2\2\u0144\u0145\5\b\5\2\u0145\u0146\7<\2\2\u0146")
-        buf.write(u";\3\2\2\2\u0147\u0148\7=\2\2\u0148\u0149\5\b\5\2\u0149")
-        buf.write(u"\u014a\7>\2\2\u014a=\3\2\2\2\u014b\u014c\t\t\2\2\u014c")
-        buf.write(u"?\3\2\2\2\u014d\u015a\5> \2\u014e\u0150\5J&\2\u014f\u014e")
-        buf.write(u"\3\2\2\2\u014f\u0150\3\2\2\2\u0150\u0152\3\2\2\2\u0151")
-        buf.write(u"\u0153\5L\'\2\u0152\u0151\3\2\2\2\u0152\u0153\3\2\2\2")
-        buf.write(u"\u0153\u015b\3\2\2\2\u0154\u0156\5L\'\2\u0155\u0154\3")
-        buf.write(u"\2\2\2\u0155\u0156\3\2\2\2\u0156\u0158\3\2\2\2\u0157")
-        buf.write(u"\u0159\5J&\2\u0158\u0157\3\2\2\2\u0158\u0159\3\2\2\2")
-        buf.write(u"\u0159\u015b\3\2\2\2\u015a\u014f\3\2\2\2\u015a\u0155")
-        buf.write(u"\3\2\2\2\u015b\u0161\3\2\2\2\u015c\u015d\7\24\2\2\u015d")
-        buf.write(u"\u015e\5F$\2\u015e\u015f\7\25\2\2\u015f\u0162\3\2\2\2")
-        buf.write(u"\u0160\u0162\5H%\2\u0161\u015c\3\2\2\2\u0161\u0160\3")
-        buf.write(u"\2\2\2\u0162\u0197\3\2\2\2\u0163\u0165\t\5\2\2\u0164")
-        buf.write(u"\u0166\5J&\2\u0165\u0164\3\2\2\2\u0165\u0166\3\2\2\2")
-        buf.write(u"\u0166\u0167\3\2\2\2\u0167\u0168\7\24\2\2\u0168\u0169")
-        buf.write(u"\5B\"\2\u0169\u016a\7\25\2\2\u016a\u0197\3\2\2\2\u016b")
-        buf.write(u"\u0172\7#\2\2\u016c\u016d\5J&\2\u016d\u016e\5L\'\2\u016e")
-        buf.write(u"\u0173\3\2\2\2\u016f\u0170\5L\'\2\u0170\u0171\5J&\2\u0171")
-        buf.write(u"\u0173\3\2\2\2\u0172\u016c\3\2\2\2\u0172\u016f\3\2\2")
-        buf.write(u"\2\u0172\u0173\3\2\2\2\u0173\u017a\3\2\2\2\u0174\u0176")
-        buf.write(u"\5\n\6\2\u0175\u0174\3\2\2\2\u0175\u0176\3\2\2\2\u0176")
-        buf.write(u"\u0177\3\2\2\2\u0177\u017b\7K\2\2\u0178\u017b\5\66\34")
-        buf.write(u"\2\u0179\u017b\5\n\6\2\u017a\u0175\3\2\2\2\u017a\u0178")
-        buf.write(u"\3\2\2\2\u017a\u0179\3\2\2\2\u017b\u0197\3\2\2\2\u017c")
-        buf.write(u"\u0181\7?\2\2\u017d\u017e\7\32\2\2\u017e\u017f\5\b\5")
-        buf.write(u"\2\u017f\u0180\7\33\2\2\u0180\u0182\3\2\2\2\u0181\u017d")
-        buf.write(u"\3\2\2\2\u0181\u0182\3\2\2\2\u0182\u0183\3\2\2\2\u0183")
-        buf.write(u"\u0184\7\26\2\2\u0184\u0185\5\b\5\2\u0185\u0186\7\27")
-        buf.write(u"\2\2\u0186\u0197\3\2\2\2\u0187\u018e\t\n\2\2\u0188\u0189")
-        buf.write(u"\5N(\2\u0189\u018a\5L\'\2\u018a\u018f\3\2\2\2\u018b\u018c")
-        buf.write(u"\5L\'\2\u018c\u018d\5N(\2\u018d\u018f\3\2\2\2\u018e\u0188")
-        buf.write(u"\3\2\2\2\u018e\u018b\3\2\2\2\u018f\u0190\3\2\2\2\u0190")
-        buf.write(u"\u0191\5\f\7\2\u0191\u0197\3\2\2\2\u0192\u0193\7!\2\2")
-        buf.write(u"\u0193\u0194\5D#\2\u0194\u0195\5\f\7\2\u0195\u0197\3")
-        buf.write(u"\2\2\2\u0196\u014d\3\2\2\2\u0196\u0163\3\2\2\2\u0196")
-        buf.write(u"\u016b\3\2\2\2\u0196\u017c\3\2\2\2\u0196\u0187\3\2\2")
-        buf.write(u"\2\u0196\u0192\3\2\2\2\u0197A\3\2\2\2\u0198\u0199\5\b")
-        buf.write(u"\5\2\u0199\u019a\7\3\2\2\u019a\u019b\5B\"\2\u019b\u019e")
-        buf.write(u"\3\2\2\2\u019c\u019e\5\b\5\2\u019d\u0198\3\2\2\2\u019d")
-        buf.write(u"\u019c\3\2\2\2\u019eC\3\2\2\2\u019f\u01a0\7H\2\2\u01a0")
-        buf.write(u"\u01a1\7\26\2\2\u01a1\u01a2\t\5\2\2\u01a2\u01a3\7\"\2")
-        buf.write(u"\2\u01a3\u01a8\5\b\5\2\u01a4\u01a5\7I\2\2\u01a5\u01a6")
-        buf.write(u"\7\26\2\2\u01a6\u01a7\t\3\2\2\u01a7\u01a9\7\27\2\2\u01a8")
-        buf.write(u"\u01a4\3\2\2\2\u01a8\u01a9\3\2\2\2\u01a9\u01aa\3\2\2")
-        buf.write(u"\2\u01aa\u01ab\7\27\2\2\u01abE\3\2\2\2\u01ac\u01b2\5")
-        buf.write(u"\b\5\2\u01ad\u01ae\5\b\5\2\u01ae\u01af\7\3\2\2\u01af")
-        buf.write(u"\u01b0\5F$\2\u01b0\u01b2\3\2\2\2\u01b1\u01ac\3\2\2\2")
-        buf.write(u"\u01b1\u01ad\3\2\2\2\u01b2G\3\2\2\2\u01b3\u01b4\5\16")
-        buf.write(u"\b\2\u01b4I\3\2\2\2\u01b5\u01bb\7H\2\2\u01b6\u01bc\5")
-        buf.write(u",\27\2\u01b7\u01b8\7\26\2\2\u01b8\u01b9\5\b\5\2\u01b9")
-        buf.write(u"\u01ba\7\27\2\2\u01ba\u01bc\3\2\2\2\u01bb\u01b6\3\2\2")
-        buf.write(u"\2\u01bb\u01b7\3\2\2\2\u01bcK\3\2\2\2\u01bd\u01c3\7I")
-        buf.write(u"\2\2\u01be\u01c4\5,\27\2\u01bf\u01c0\7\26\2\2\u01c0\u01c1")
-        buf.write(u"\5\b\5\2\u01c1\u01c2\7\27\2\2\u01c2\u01c4\3\2\2\2\u01c3")
-        buf.write(u"\u01be\3\2\2\2\u01c3\u01bf\3\2\2\2\u01c4M\3\2\2\2\u01c5")
-        buf.write(u"\u01c6\7H\2\2\u01c6\u01c7\7\26\2\2\u01c7\u01c8\5\6\4")
-        buf.write(u"\2\u01c8\u01c9\7\27\2\2\u01c9O\3\2\2\2\u01ca\u01cb\7")
-        buf.write(u"H\2\2\u01cb\u01cc\7\26\2\2\u01cc\u01cd\5\6\4\2\u01cd")
-        buf.write(u"\u01ce\7\27\2\2\u01ceQ\3\2\2\2.\\mx\u0083\u008b\u008d")
-        buf.write(u"\u0095\u0098\u009e\u00a5\u00aa\u00b2\u00b8\u00c0\u00ce")
-        buf.write(u"\u00d1\u00d5\u00e2\u00e5\u00e9\u00f4\u00fd\u010f\u0117")
-        buf.write(u"\u011e\u0130\u014f\u0152\u0155\u0158\u015a\u0161\u0165")
-        buf.write(u"\u0172\u0175\u017a\u0181\u018e\u0196\u019d\u01a8\u01b1")
-        buf.write(u"\u01bb\u01c3")
+        buf.write(u"\2\u00b9\u00ba\3\2\2\2\u00ba\u00bb\7\24\2\2\u00bb\37")
+        buf.write(u"\3\2\2\2\u00bc\u00bd\b\21\1\2\u00bd\u00be\5$\23\2\u00be")
+        buf.write(u"\u00cd\3\2\2\2\u00bf\u00c0\f\4\2\2\u00c0\u00c6\7@\2\2")
+        buf.write(u"\u00c1\u00c7\5,\27\2\u00c2\u00c3\7\23\2\2\u00c3\u00c4")
+        buf.write(u"\5\b\5\2\u00c4\u00c5\7\24\2\2\u00c5\u00c7\3\2\2\2\u00c6")
+        buf.write(u"\u00c1\3\2\2\2\u00c6\u00c2\3\2\2\2\u00c7\u00c9\3\2\2")
+        buf.write(u"\2\u00c8\u00ca\5B\"\2\u00c9\u00c8\3\2\2\2\u00c9\u00ca")
+        buf.write(u"\3\2\2\2\u00ca\u00cc\3\2\2\2\u00cb\u00bf\3\2\2\2\u00cc")
+        buf.write(u"\u00cf\3\2\2\2\u00cd\u00cb\3\2\2\2\u00cd\u00ce\3\2\2")
+        buf.write(u"\2\u00ce!\3\2\2\2\u00cf\u00cd\3\2\2\2\u00d0\u00d1\b\22")
+        buf.write(u"\1\2\u00d1\u00d2\5&\24\2\u00d2\u00e1\3\2\2\2\u00d3\u00d4")
+        buf.write(u"\f\4\2\2\u00d4\u00da\7@\2\2\u00d5\u00db\5,\27\2\u00d6")
+        buf.write(u"\u00d7\7\23\2\2\u00d7\u00d8\5\b\5\2\u00d8\u00d9\7\24")
+        buf.write(u"\2\2\u00d9\u00db\3\2\2\2\u00da\u00d5\3\2\2\2\u00da\u00d6")
+        buf.write(u"\3\2\2\2\u00db\u00dd\3\2\2\2\u00dc\u00de\5B\"\2\u00dd")
+        buf.write(u"\u00dc\3\2\2\2\u00dd\u00de\3\2\2\2\u00de\u00e0\3\2\2")
+        buf.write(u"\2\u00df\u00d3\3\2\2\2\u00e0\u00e3\3\2\2\2\u00e1\u00df")
+        buf.write(u"\3\2\2\2\u00e1\u00e2\3\2\2\2\u00e2#\3\2\2\2\u00e3\u00e1")
+        buf.write(u"\3\2\2\2\u00e4\u00eb\5(\25\2\u00e5\u00eb\5*\26\2\u00e6")
+        buf.write(u"\u00eb\58\35\2\u00e7\u00eb\5,\27\2\u00e8\u00eb\5\62\32")
+        buf.write(u"\2\u00e9\u00eb\5\64\33\2\u00ea\u00e4\3\2\2\2\u00ea\u00e5")
+        buf.write(u"\3\2\2\2\u00ea\u00e6\3\2\2\2\u00ea\u00e7\3\2\2\2\u00ea")
+        buf.write(u"\u00e8\3\2\2\2\u00ea\u00e9\3\2\2\2\u00eb%\3\2\2\2\u00ec")
+        buf.write(u"\u00f2\5(\25\2\u00ed\u00f2\5*\26\2\u00ee\u00f2\5,\27")
+        buf.write(u"\2\u00ef\u00f2\5\62\32\2\u00f0\u00f2\5\64\33\2\u00f1")
+        buf.write(u"\u00ec\3\2\2\2\u00f1\u00ed\3\2\2\2\u00f1\u00ee\3\2\2")
+        buf.write(u"\2\u00f1\u00ef\3\2\2\2\u00f1\u00f0\3\2\2\2\u00f2\'\3")
+        buf.write(u"\2\2\2\u00f3\u00f4\7\21\2\2\u00f4\u00f5\5\b\5\2\u00f5")
+        buf.write(u"\u00f6\7\22\2\2\u00f6\u0104\3\2\2\2\u00f7\u00f8\7\27")
+        buf.write(u"\2\2\u00f8\u00f9\5\b\5\2\u00f9\u00fa\7\30\2\2\u00fa\u0104")
+        buf.write(u"\3\2\2\2\u00fb\u00fc\7\23\2\2\u00fc\u00fd\5\b\5\2\u00fd")
+        buf.write(u"\u00fe\7\24\2\2\u00fe\u0104\3\2\2\2\u00ff\u0100\7\25")
+        buf.write(u"\2\2\u0100\u0101\5\b\5\2\u0101\u0102\7\26\2\2\u0102\u0104")
+        buf.write(u"\3\2\2\2\u0103\u00f3\3\2\2\2\u0103\u00f7\3\2\2\2\u0103")
+        buf.write(u"\u00fb\3\2\2\2\u0103\u00ff\3\2\2\2\u0104)\3\2\2\2\u0105")
+        buf.write(u"\u0106\7\33\2\2\u0106\u0107\5\b\5\2\u0107\u0108\7\33")
+        buf.write(u"\2\2\u0108+\3\2\2\2\u0109\u010b\t\5\2\2\u010a\u010c\5")
+        buf.write(u"B\"\2\u010b\u010a\3\2\2\2\u010b\u010c\3\2\2\2\u010c\u0111")
+        buf.write(u"\3\2\2\2\u010d\u0111\7D\2\2\u010e\u0111\7B\2\2\u010f")
+        buf.write(u"\u0111\5.\30\2\u0110\u0109\3\2\2\2\u0110\u010d\3\2\2")
+        buf.write(u"\2\u0110\u010e\3\2\2\2\u0110\u010f\3\2\2\2\u0111-\3\2")
+        buf.write(u"\2\2\u0112\u0113\7>\2\2\u0113\u0114\7\23\2\2\u0114\u0115")
+        buf.write(u"\5\60\31\2\u0115\u0116\7\24\2\2\u0116/\3\2\2\2\u0117")
+        buf.write(u"\u0119\7C\2\2\u0118\u0117\3\2\2\2\u0119\u011c\3\2\2\2")
+        buf.write(u"\u011a\u0118\3\2\2\2\u011a\u011b\3\2\2\2\u011b\61\3\2")
+        buf.write(u"\2\2\u011c\u011a\3\2\2\2\u011d\u011e\7:\2\2\u011e\u011f")
+        buf.write(u"\7\23\2\2\u011f\u0120\5\b\5\2\u0120\u0121\7\24\2\2\u0121")
+        buf.write(u"\u0122\7\23\2\2\u0122\u0123\5\b\5\2\u0123\u0124\7\24")
+        buf.write(u"\2\2\u0124\63\3\2\2\2\u0125\u0126\t\6\2\2\u0126\u0127")
+        buf.write(u"\7\23\2\2\u0127\u0128\5\b\5\2\u0128\u0129\7\24\2\2\u0129")
+        buf.write(u"\u012a\7\23\2\2\u012a\u012b\5\b\5\2\u012b\u012c\7\24")
+        buf.write(u"\2\2\u012c\65\3\2\2\2\u012d\u012e\t\7\2\2\u012e\67\3")
+        buf.write(u"\2\2\2\u012f\u013c\5\66\34\2\u0130\u0132\5B\"\2\u0131")
+        buf.write(u"\u0130\3\2\2\2\u0131\u0132\3\2\2\2\u0132\u0134\3\2\2")
+        buf.write(u"\2\u0133\u0135\5D#\2\u0134\u0133\3\2\2\2\u0134\u0135")
+        buf.write(u"\3\2\2\2\u0135\u013d\3\2\2\2\u0136\u0138\5D#\2\u0137")
+        buf.write(u"\u0136\3\2\2\2\u0137\u0138\3\2\2\2\u0138\u013a\3\2\2")
+        buf.write(u"\2\u0139\u013b\5B\"\2\u013a\u0139\3\2\2\2\u013a\u013b")
+        buf.write(u"\3\2\2\2\u013b\u013d\3\2\2\2\u013c\u0131\3\2\2\2\u013c")
+        buf.write(u"\u0137\3\2\2\2\u013d\u0143\3\2\2\2\u013e\u013f\7\21\2")
+        buf.write(u"\2\u013f\u0140\5> \2\u0140\u0141\7\22\2\2\u0141\u0144")
+        buf.write(u"\3\2\2\2\u0142\u0144\5@!\2\u0143\u013e\3\2\2\2\u0143")
+        buf.write(u"\u0142\3\2\2\2\u0144\u0179\3\2\2\2\u0145\u0147\t\5\2")
+        buf.write(u"\2\u0146\u0148\5B\"\2\u0147\u0146\3\2\2\2\u0147\u0148")
+        buf.write(u"\3\2\2\2\u0148\u0149\3\2\2\2\u0149\u014a\7\21\2\2\u014a")
+        buf.write(u"\u014b\5:\36\2\u014b\u014c\7\22\2\2\u014c\u0179\3\2\2")
+        buf.write(u"\2\u014d\u0154\7\36\2\2\u014e\u014f\5B\"\2\u014f\u0150")
+        buf.write(u"\5D#\2\u0150\u0155\3\2\2\2\u0151\u0152\5D#\2\u0152\u0153")
+        buf.write(u"\5B\"\2\u0153\u0155\3\2\2\2\u0154\u014e\3\2\2\2\u0154")
+        buf.write(u"\u0151\3\2\2\2\u0154\u0155\3\2\2\2\u0155\u015c\3\2\2")
+        buf.write(u"\2\u0156\u0158\5\n\6\2\u0157\u0156\3\2\2\2\u0157\u0158")
+        buf.write(u"\3\2\2\2\u0158\u0159\3\2\2\2\u0159\u015d\7B\2\2\u015a")
+        buf.write(u"\u015d\5\62\32\2\u015b\u015d\5\n\6\2\u015c\u0157\3\2")
+        buf.write(u"\2\2\u015c\u015a\3\2\2\2\u015c\u015b\3\2\2\2\u015d\u0179")
+        buf.write(u"\3\2\2\2\u015e\u0163\7\66\2\2\u015f\u0160\7\27\2\2\u0160")
+        buf.write(u"\u0161\5\b\5\2\u0161\u0162\7\30\2\2\u0162\u0164\3\2\2")
+        buf.write(u"\2\u0163\u015f\3\2\2\2\u0163\u0164\3\2\2\2\u0164\u0165")
+        buf.write(u"\3\2\2\2\u0165\u0166\7\23\2\2\u0166\u0167\5\b\5\2\u0167")
+        buf.write(u"\u0168\7\24\2\2\u0168\u0179\3\2\2\2\u0169\u0170\t\b\2")
+        buf.write(u"\2\u016a\u016b\5F$\2\u016b\u016c\5D#\2\u016c\u0171\3")
+        buf.write(u"\2\2\2\u016d\u016e\5D#\2\u016e\u016f\5F$\2\u016f\u0171")
+        buf.write(u"\3\2\2\2\u0170\u016a\3\2\2\2\u0170\u016d\3\2\2\2\u0171")
+        buf.write(u"\u0172\3\2\2\2\u0172\u0173\5\f\7\2\u0173\u0179\3\2\2")
+        buf.write(u"\2\u0174\u0175\7\34\2\2\u0175\u0176\5<\37\2\u0176\u0177")
+        buf.write(u"\5\f\7\2\u0177\u0179\3\2\2\2\u0178\u012f\3\2\2\2\u0178")
+        buf.write(u"\u0145\3\2\2\2\u0178\u014d\3\2\2\2\u0178\u015e\3\2\2")
+        buf.write(u"\2\u0178\u0169\3\2\2\2\u0178\u0174\3\2\2\2\u01799\3\2")
+        buf.write(u"\2\2\u017a\u017b\5\b\5\2\u017b\u017c\7\3\2\2\u017c\u017d")
+        buf.write(u"\5:\36\2\u017d\u0180\3\2\2\2\u017e\u0180\5\b\5\2\u017f")
+        buf.write(u"\u017a\3\2\2\2\u017f\u017e\3\2\2\2\u0180;\3\2\2\2\u0181")
+        buf.write(u"\u0182\7?\2\2\u0182\u0183\7\23\2\2\u0183\u0184\t\5\2")
+        buf.write(u"\2\u0184\u0185\7\35\2\2\u0185\u018a\5\b\5\2\u0186\u0187")
+        buf.write(u"\7@\2\2\u0187\u0188\7\23\2\2\u0188\u0189\t\3\2\2\u0189")
+        buf.write(u"\u018b\7\24\2\2\u018a\u0186\3\2\2\2\u018a\u018b\3\2\2")
+        buf.write(u"\2\u018b\u018c\3\2\2\2\u018c\u018d\7\24\2\2\u018d=\3")
+        buf.write(u"\2\2\2\u018e\u0194\5\b\5\2\u018f\u0190\5\b\5\2\u0190")
+        buf.write(u"\u0191\7\3\2\2\u0191\u0192\5> \2\u0192\u0194\3\2\2\2")
+        buf.write(u"\u0193\u018e\3\2\2\2\u0193\u018f\3\2\2\2\u0194?\3\2\2")
+        buf.write(u"\2\u0195\u0196\5\16\b\2\u0196A\3\2\2\2\u0197\u019d\7")
+        buf.write(u"?\2\2\u0198\u019e\5,\27\2\u0199\u019a\7\23\2\2\u019a")
+        buf.write(u"\u019b\5\b\5\2\u019b\u019c\7\24\2\2\u019c\u019e\3\2\2")
+        buf.write(u"\2\u019d\u0198\3\2\2\2\u019d\u0199\3\2\2\2\u019eC\3\2")
+        buf.write(u"\2\2\u019f\u01a5\7@\2\2\u01a0\u01a6\5,\27\2\u01a1\u01a2")
+        buf.write(u"\7\23\2\2\u01a2\u01a3\5\b\5\2\u01a3\u01a4\7\24\2\2\u01a4")
+        buf.write(u"\u01a6\3\2\2\2\u01a5\u01a0\3\2\2\2\u01a5\u01a1\3\2\2")
+        buf.write(u"\2\u01a6E\3\2\2\2\u01a7\u01a8\7?\2\2\u01a8\u01a9\7\23")
+        buf.write(u"\2\2\u01a9\u01aa\5\6\4\2\u01aa\u01ab\7\24\2\2\u01abG")
+        buf.write(u"\3\2\2\2\u01ac\u01ad\7?\2\2\u01ad\u01ae\7\23\2\2\u01ae")
+        buf.write(u"\u01af\5\6\4\2\u01af\u01b0\7\24\2\2\u01b0I\3\2\2\2.T")
+        buf.write(u"ep{\u0083\u0085\u008d\u0090\u0096\u009d\u00a2\u00aa\u00b0")
+        buf.write(u"\u00b8\u00c6\u00c9\u00cd\u00da\u00dd\u00e1\u00ea\u00f1")
+        buf.write(u"\u0103\u010b\u0110\u011a\u0131\u0134\u0137\u013a\u013c")
+        buf.write(u"\u0143\u0147\u0154\u0157\u015c\u0163\u0170\u0178\u017f")
+        buf.write(u"\u018a\u0193\u019d\u01a5")
         return buf.getvalue()
 
 
@@ -253,45 +241,41 @@ class LaTeXParser ( Parser ):
 
     literalNames = [ u"<INVALID>", u"','", u"<INVALID>", u"<INVALID>", u"<INVALID>",
                      u"<INVALID>", u"'\\quad'", u"'\\qquad'", u"<INVALID>",
-                     u"'\\negmedspace'", u"'\\negthickspace'", u"'\\left'",
-                     u"'\\right'", u"<INVALID>", u"'+'", u"'-'", u"'*'",
-                     u"'/'", u"'('", u"')'", u"'{'", u"'}'", u"'\\{'", u"'\\}'",
-                     u"'['", u"']'", u"'|'", u"'\\right|'", u"'\\left|'",
-                     u"'\\langle'", u"'\\rangle'", u"'\\lim'", u"<INVALID>",
-                     u"'\\int'", u"'\\sum'", u"'\\prod'", u"'\\exp'", u"'\\log'",
-                     u"'\\ln'", u"'\\sin'", u"'\\cos'", u"'\\tan'", u"'\\csc'",
-                     u"'\\sec'", u"'\\cot'", u"'\\arcsin'", u"'\\arccos'",
-                     u"'\\arctan'", u"'\\arccsc'", u"'\\arcsec'", u"'\\arccot'",
-                     u"'\\sinh'", u"'\\cosh'", u"'\\tanh'", u"'\\arsinh'",
-                     u"'\\arcosh'", u"'\\artanh'", u"'\\lfloor'", u"'\\rfloor'",
-                     u"'\\lceil'", u"'\\rceil'", u"'\\sqrt'", u"'\\times'",
-                     u"'\\cdot'", u"'\\div'", u"'\\frac'", u"'\\binom'",
-                     u"'\\dbinom'", u"'\\tbinom'", u"'\\mathit'", u"'_'",
-                     u"'^'", u"':'", u"<INVALID>", u"<INVALID>", u"<INVALID>",
-                     u"<INVALID>", u"'\\neq'", u"'<'", u"<INVALID>", u"'\\leqq'",
-                     u"'\\leqslant'", u"'>'", u"<INVALID>", u"'\\geqq'",
-                     u"'\\geqslant'", u"'!'" ]
+                     u"'\\negmedspace'", u"'\\negthickspace'", u"'+'", u"'-'",
+                     u"'*'", u"'/'", u"'('", u"')'", u"'{'", u"'}'", u"'\\{'",
+                     u"'\\}'", u"'['", u"']'", u"'\\left'", u"'\\right'",
+                     u"'|'", u"'\\lim'", u"<INVALID>", u"'\\int'", u"'\\sum'",
+                     u"'\\prod'", u"'\\exp'", u"'\\log'", u"'\\ln'", u"'\\sin'",
+                     u"'\\cos'", u"'\\tan'", u"'\\csc'", u"'\\sec'", u"'\\cot'",
+                     u"'\\arcsin'", u"'\\arccos'", u"'\\arctan'", u"'\\arccsc'",
+                     u"'\\arcsec'", u"'\\arccot'", u"'\\sinh'", u"'\\cosh'",
+                     u"'\\tanh'", u"'\\arsinh'", u"'\\arcosh'", u"'\\artanh'",
+                     u"'\\sqrt'", u"'\\times'", u"'\\cdot'", u"'\\div'",
+                     u"'\\frac'", u"'\\binom'", u"'\\dbinom'", u"'\\tbinom'",
+                     u"'\\mathit'", u"'_'", u"'^'", u"':'", u"<INVALID>",
+                     u"<INVALID>", u"<INVALID>", u"'='", u"'\\neq'", u"'<'",
+                     u"<INVALID>", u"'\\leqq'", u"'\\leqslant'", u"'>'",
+                     u"<INVALID>", u"'\\geqq'", u"'\\geqslant'", u"'!'" ]
 
     symbolicNames = [ u"<INVALID>", u"<INVALID>", u"WS", u"THINSPACE", u"MEDSPACE",
                       u"THICKSPACE", u"QUAD", u"QQUAD", u"NEGTHINSPACE",
-                      u"NEGMEDSPACE", u"NEGTHICKSPACE", u"CMD_LEFT", u"CMD_RIGHT",
-                      u"IGNORE", u"ADD", u"SUB", u"MUL", u"DIV", u"L_PAREN",
-                      u"R_PAREN", u"L_BRACE", u"R_BRACE", u"L_BRACE_LITERAL",
-                      u"R_BRACE_LITERAL", u"L_BRACKET", u"R_BRACKET", u"BAR",
-                      u"R_BAR", u"L_BAR", u"L_ANGLE", u"R_ANGLE", u"FUNC_LIM",
-                      u"LIM_APPROACH_SYM", u"FUNC_INT", u"FUNC_SUM", u"FUNC_PROD",
-                      u"FUNC_EXP", u"FUNC_LOG", u"FUNC_LN", u"FUNC_SIN",
-                      u"FUNC_COS", u"FUNC_TAN", u"FUNC_CSC", u"FUNC_SEC",
-                      u"FUNC_COT", u"FUNC_ARCSIN", u"FUNC_ARCCOS", u"FUNC_ARCTAN",
-                      u"FUNC_ARCCSC", u"FUNC_ARCSEC", u"FUNC_ARCCOT", u"FUNC_SINH",
-                      u"FUNC_COSH", u"FUNC_TANH", u"FUNC_ARSINH", u"FUNC_ARCOSH",
-                      u"FUNC_ARTANH", u"L_FLOOR", u"R_FLOOR", u"L_CEIL",
-                      u"R_CEIL", u"FUNC_SQRT", u"CMD_TIMES", u"CMD_CDOT",
-                      u"CMD_DIV", u"CMD_FRAC", u"CMD_BINOM", u"CMD_DBINOM",
-                      u"CMD_TBINOM", u"CMD_MATHIT", u"UNDERSCORE", u"CARET",
-                      u"COLON", u"DIFFERENTIAL", u"LETTER", u"NUMBER", u"EQUAL",
-                      u"NEQ", u"LT", u"LTE", u"LTE_Q", u"LTE_S", u"GT",
-                      u"GTE", u"GTE_Q", u"GTE_S", u"BANG", u"SYMBOL" ]
+                      u"NEGMEDSPACE", u"NEGTHICKSPACE", u"ADD", u"SUB",
+                      u"MUL", u"DIV", u"L_PAREN", u"R_PAREN", u"L_BRACE",
+                      u"R_BRACE", u"L_BRACE_LITERAL", u"R_BRACE_LITERAL",
+                      u"L_BRACKET", u"R_BRACKET", u"CMD_LEFT", u"CMD_RIGHT",
+                      u"BAR", u"FUNC_LIM", u"LIM_APPROACH_SYM", u"FUNC_INT",
+                      u"FUNC_SUM", u"FUNC_PROD", u"FUNC_EXP", u"FUNC_LOG",
+                      u"FUNC_LN", u"FUNC_SIN", u"FUNC_COS", u"FUNC_TAN",
+                      u"FUNC_CSC", u"FUNC_SEC", u"FUNC_COT", u"FUNC_ARCSIN",
+                      u"FUNC_ARCCOS", u"FUNC_ARCTAN", u"FUNC_ARCCSC", u"FUNC_ARCSEC",
+                      u"FUNC_ARCCOT", u"FUNC_SINH", u"FUNC_COSH", u"FUNC_TANH",
+                      u"FUNC_ARSINH", u"FUNC_ARCOSH", u"FUNC_ARTANH", u"FUNC_SQRT",
+                      u"CMD_TIMES", u"CMD_CDOT", u"CMD_DIV", u"CMD_FRAC",
+                      u"CMD_BINOM", u"CMD_DBINOM", u"CMD_TBINOM", u"CMD_MATHIT",
+                      u"UNDERSCORE", u"CARET", u"COLON", u"DIFFERENTIAL",
+                      u"LETTER", u"NUMBER", u"EQUAL", u"NEQ", u"LT", u"LTE",
+                      u"LTE_Q", u"LTE_S", u"GT", u"GTE", u"GTE_Q", u"GTE_S",
+                      u"BANG", u"SYMBOL" ]
 
     RULE_math = 0
     RULE_relation = 1
@@ -315,34 +299,29 @@ class LaTeXParser ( Parser ):
     RULE_group = 19
     RULE_abs_group = 20
     RULE_atom = 21
-    RULE_bra = 22
-    RULE_ket = 23
-    RULE_mathit = 24
-    RULE_mathit_text = 25
-    RULE_frac = 26
-    RULE_binom = 27
-    RULE_floor = 28
-    RULE_ceil = 29
-    RULE_func_normal = 30
-    RULE_func = 31
-    RULE_args = 32
-    RULE_limit_sub = 33
-    RULE_func_arg = 34
-    RULE_func_arg_noparens = 35
-    RULE_subexpr = 36
-    RULE_supexpr = 37
-    RULE_subeq = 38
-    RULE_supeq = 39
+    RULE_mathit = 22
+    RULE_mathit_text = 23
+    RULE_frac = 24
+    RULE_binom = 25
+    RULE_func_normal = 26
+    RULE_func = 27
+    RULE_args = 28
+    RULE_limit_sub = 29
+    RULE_func_arg = 30
+    RULE_func_arg_noparens = 31
+    RULE_subexpr = 32
+    RULE_supexpr = 33
+    RULE_subeq = 34
+    RULE_supeq = 35
 
     ruleNames =  [ u"math", u"relation", u"equality", u"expr", u"additive",
                    u"mp", u"mp_nofunc", u"unary", u"unary_nofunc", u"postfix",
                    u"postfix_nofunc", u"postfix_op", u"eval_at", u"eval_at_sub",
                    u"eval_at_sup", u"exp", u"exp_nofunc", u"comp", u"comp_nofunc",
-                   u"group", u"abs_group", u"atom", u"bra", u"ket", u"mathit",
-                   u"mathit_text", u"frac", u"binom", u"floor", u"ceil",
-                   u"func_normal", u"func", u"args", u"limit_sub", u"func_arg",
-                   u"func_arg_noparens", u"subexpr", u"supexpr", u"subeq",
-                   u"supeq" ]
+                   u"group", u"abs_group", u"atom", u"mathit", u"mathit_text",
+                   u"frac", u"binom", u"func_normal", u"func", u"args",
+                   u"limit_sub", u"func_arg", u"func_arg_noparens", u"subexpr",
+                   u"supexpr", u"subeq", u"supeq" ]
 
     EOF = Token.EOF
     T__0=1
@@ -355,83 +334,74 @@ class LaTeXParser ( Parser ):
     NEGTHINSPACE=8
     NEGMEDSPACE=9
     NEGTHICKSPACE=10
-    CMD_LEFT=11
-    CMD_RIGHT=12
-    IGNORE=13
-    ADD=14
-    SUB=15
-    MUL=16
-    DIV=17
-    L_PAREN=18
-    R_PAREN=19
-    L_BRACE=20
-    R_BRACE=21
-    L_BRACE_LITERAL=22
-    R_BRACE_LITERAL=23
-    L_BRACKET=24
-    R_BRACKET=25
-    BAR=26
-    R_BAR=27
-    L_BAR=28
-    L_ANGLE=29
-    R_ANGLE=30
-    FUNC_LIM=31
-    LIM_APPROACH_SYM=32
-    FUNC_INT=33
-    FUNC_SUM=34
-    FUNC_PROD=35
-    FUNC_EXP=36
-    FUNC_LOG=37
-    FUNC_LN=38
-    FUNC_SIN=39
-    FUNC_COS=40
-    FUNC_TAN=41
-    FUNC_CSC=42
-    FUNC_SEC=43
-    FUNC_COT=44
-    FUNC_ARCSIN=45
-    FUNC_ARCCOS=46
-    FUNC_ARCTAN=47
-    FUNC_ARCCSC=48
-    FUNC_ARCSEC=49
-    FUNC_ARCCOT=50
-    FUNC_SINH=51
-    FUNC_COSH=52
-    FUNC_TANH=53
-    FUNC_ARSINH=54
-    FUNC_ARCOSH=55
-    FUNC_ARTANH=56
-    L_FLOOR=57
-    R_FLOOR=58
-    L_CEIL=59
-    R_CEIL=60
-    FUNC_SQRT=61
-    CMD_TIMES=62
-    CMD_CDOT=63
-    CMD_DIV=64
-    CMD_FRAC=65
-    CMD_BINOM=66
-    CMD_DBINOM=67
-    CMD_TBINOM=68
-    CMD_MATHIT=69
-    UNDERSCORE=70
-    CARET=71
-    COLON=72
-    DIFFERENTIAL=73
-    LETTER=74
-    NUMBER=75
-    EQUAL=76
-    NEQ=77
-    LT=78
-    LTE=79
-    LTE_Q=80
-    LTE_S=81
-    GT=82
-    GTE=83
-    GTE_Q=84
-    GTE_S=85
-    BANG=86
-    SYMBOL=87
+    ADD=11
+    SUB=12
+    MUL=13
+    DIV=14
+    L_PAREN=15
+    R_PAREN=16
+    L_BRACE=17
+    R_BRACE=18
+    L_BRACE_LITERAL=19
+    R_BRACE_LITERAL=20
+    L_BRACKET=21
+    R_BRACKET=22
+    CMD_LEFT=23
+    CMD_RIGHT=24
+    BAR=25
+    FUNC_LIM=26
+    LIM_APPROACH_SYM=27
+    FUNC_INT=28
+    FUNC_SUM=29
+    FUNC_PROD=30
+    FUNC_EXP=31
+    FUNC_LOG=32
+    FUNC_LN=33
+    FUNC_SIN=34
+    FUNC_COS=35
+    FUNC_TAN=36
+    FUNC_CSC=37
+    FUNC_SEC=38
+    FUNC_COT=39
+    FUNC_ARCSIN=40
+    FUNC_ARCCOS=41
+    FUNC_ARCTAN=42
+    FUNC_ARCCSC=43
+    FUNC_ARCSEC=44
+    FUNC_ARCCOT=45
+    FUNC_SINH=46
+    FUNC_COSH=47
+    FUNC_TANH=48
+    FUNC_ARSINH=49
+    FUNC_ARCOSH=50
+    FUNC_ARTANH=51
+    FUNC_SQRT=52
+    CMD_TIMES=53
+    CMD_CDOT=54
+    CMD_DIV=55
+    CMD_FRAC=56
+    CMD_BINOM=57
+    CMD_DBINOM=58
+    CMD_TBINOM=59
+    CMD_MATHIT=60
+    UNDERSCORE=61
+    CARET=62
+    COLON=63
+    DIFFERENTIAL=64
+    LETTER=65
+    NUMBER=66
+    EQUAL=67
+    NEQ=68
+    LT=69
+    LTE=70
+    LTE_Q=71
+    LTE_S=72
+    GT=73
+    GTE=74
+    GTE_Q=75
+    GTE_S=76
+    BANG=77
+    SYMBOL=78
 
     def __init__(self, input, output=sys.stdout):
         super(LaTeXParser, self).__init__(input, output=output)
@@ -464,7 +434,7 @@ def math(self):
         self.enterRule(localctx, 0, self.RULE_math)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 80
+            self.state = 72
             self.relation(0)
         except RecognitionException as re:
             localctx.exception = re
@@ -525,10 +495,10 @@ def relation(self, _p=0):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 83
+            self.state = 75
             self.expr()
             self._ctx.stop = self._input.LT(-1)
-            self.state = 90
+            self.state = 82
             self._errHandler.sync(self)
             _alt = self._interp.adaptivePredict(self._input,0,self._ctx)
             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
@@ -538,20 +508,20 @@ def relation(self, _p=0):
                     _prevctx = localctx
                     localctx = LaTeXParser.RelationContext(self, _parentctx, _parentState)
                     self.pushNewRecursionContext(localctx, _startState, self.RULE_relation)
-                    self.state = 85
+                    self.state = 77
                     if not self.precpred(self._ctx, 2):
                         from antlr4.error.Errors import FailedPredicateException
                         raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
-                    self.state = 86
+                    self.state = 78
                     _la = self._input.LA(1)
-                    if not(((((_la - 76)) & ~0x3f) == 0 and ((1 << (_la - 76)) & ((1 << (LaTeXParser.EQUAL - 76)) | (1 << (LaTeXParser.NEQ - 76)) | (1 << (LaTeXParser.LT - 76)) | (1 << (LaTeXParser.LTE - 76)) | (1 << (LaTeXParser.GT - 76)) | (1 << (LaTeXParser.GTE - 76)))) != 0)):
+                    if not(((((_la - 67)) & ~0x3f) == 0 and ((1 << (_la - 67)) & ((1 << (LaTeXParser.EQUAL - 67)) | (1 << (LaTeXParser.NEQ - 67)) | (1 << (LaTeXParser.LT - 67)) | (1 << (LaTeXParser.LTE - 67)) | (1 << (LaTeXParser.GT - 67)) | (1 << (LaTeXParser.GTE - 67)))) != 0)):
                         self._errHandler.recoverInline(self)
                     else:
                         self._errHandler.reportMatch(self)
                         self.consume()
-                    self.state = 87
+                    self.state = 79
                     self.relation(3)
-                self.state = 92
+                self.state = 84
                 self._errHandler.sync(self)
                 _alt = self._interp.adaptivePredict(self._input,0,self._ctx)
 
@@ -592,11 +562,11 @@ def equality(self):
         self.enterRule(localctx, 4, self.RULE_equality)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 93
+            self.state = 85
             self.expr()
-            self.state = 94
+            self.state = 86
             self.match(LaTeXParser.EQUAL)
-            self.state = 95
+            self.state = 87
             self.expr()
         except RecognitionException as re:
             localctx.exception = re
@@ -629,7 +599,7 @@ def expr(self):
         self.enterRule(localctx, 6, self.RULE_expr)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 97
+            self.state = 89
             self.additive(0)
         except RecognitionException as re:
             localctx.exception = re
@@ -678,10 +648,10 @@ def additive(self, _p=0):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 100
+            self.state = 92
             self.mp(0)
             self._ctx.stop = self._input.LT(-1)
-            self.state = 107
+            self.state = 99
             self._errHandler.sync(self)
             _alt = self._interp.adaptivePredict(self._input,1,self._ctx)
             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
@@ -691,20 +661,20 @@ def additive(self, _p=0):
                     _prevctx = localctx
                     localctx = LaTeXParser.AdditiveContext(self, _parentctx, _parentState)
                     self.pushNewRecursionContext(localctx, _startState, self.RULE_additive)
-                    self.state = 102
+                    self.state = 94
                     if not self.precpred(self._ctx, 2):
                         from antlr4.error.Errors import FailedPredicateException
                         raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
-                    self.state = 103
+                    self.state = 95
                     _la = self._input.LA(1)
                     if not(_la==LaTeXParser.ADD or _la==LaTeXParser.SUB):
                         self._errHandler.recoverInline(self)
                     else:
                         self._errHandler.reportMatch(self)
                         self.consume()
-                    self.state = 104
+                    self.state = 96
                     self.additive(3)
-                self.state = 109
+                self.state = 101
                 self._errHandler.sync(self)
                 _alt = self._interp.adaptivePredict(self._input,1,self._ctx)
 
@@ -767,10 +737,10 @@ def mp(self, _p=0):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 111
+            self.state = 103
             self.unary()
             self._ctx.stop = self._input.LT(-1)
-            self.state = 118
+            self.state = 110
             self._errHandler.sync(self)
             _alt = self._interp.adaptivePredict(self._input,2,self._ctx)
             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
@@ -780,20 +750,20 @@ def mp(self, _p=0):
                     _prevctx = localctx
                     localctx = LaTeXParser.MpContext(self, _parentctx, _parentState)
                     self.pushNewRecursionContext(localctx, _startState, self.RULE_mp)
-                    self.state = 113
+                    self.state = 105
                     if not self.precpred(self._ctx, 2):
                         from antlr4.error.Errors import FailedPredicateException
                         raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
-                    self.state = 114
+                    self.state = 106
                     _la = self._input.LA(1)
-                    if not(((((_la - 16)) & ~0x3f) == 0 and ((1 << (_la - 16)) & ((1 << (LaTeXParser.MUL - 16)) | (1 << (LaTeXParser.DIV - 16)) | (1 << (LaTeXParser.CMD_TIMES - 16)) | (1 << (LaTeXParser.CMD_CDOT - 16)) | (1 << (LaTeXParser.CMD_DIV - 16)) | (1 << (LaTeXParser.COLON - 16)))) != 0)):
+                    if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << LaTeXParser.MUL) | (1 << LaTeXParser.DIV) | (1 << LaTeXParser.CMD_TIMES) | (1 << LaTeXParser.CMD_CDOT) | (1 << LaTeXParser.CMD_DIV) | (1 << LaTeXParser.COLON))) != 0)):
                         self._errHandler.recoverInline(self)
                     else:
                         self._errHandler.reportMatch(self)
                         self.consume()
-                    self.state = 115
+                    self.state = 107
                     self.mp(3)
-                self.state = 120
+                self.state = 112
                 self._errHandler.sync(self)
                 _alt = self._interp.adaptivePredict(self._input,2,self._ctx)
 
@@ -856,10 +826,10 @@ def mp_nofunc(self, _p=0):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 122
+            self.state = 114
             self.unary_nofunc()
             self._ctx.stop = self._input.LT(-1)
-            self.state = 129
+            self.state = 121
             self._errHandler.sync(self)
             _alt = self._interp.adaptivePredict(self._input,3,self._ctx)
             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
@@ -869,20 +839,20 @@ def mp_nofunc(self, _p=0):
                     _prevctx = localctx
                     localctx = LaTeXParser.Mp_nofuncContext(self, _parentctx, _parentState)
                     self.pushNewRecursionContext(localctx, _startState, self.RULE_mp_nofunc)
-                    self.state = 124
+                    self.state = 116
                     if not self.precpred(self._ctx, 2):
                         from antlr4.error.Errors import FailedPredicateException
                         raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
-                    self.state = 125
+                    self.state = 117
                     _la = self._input.LA(1)
-                    if not(((((_la - 16)) & ~0x3f) == 0 and ((1 << (_la - 16)) & ((1 << (LaTeXParser.MUL - 16)) | (1 << (LaTeXParser.DIV - 16)) | (1 << (LaTeXParser.CMD_TIMES - 16)) | (1 << (LaTeXParser.CMD_CDOT - 16)) | (1 << (LaTeXParser.CMD_DIV - 16)) | (1 << (LaTeXParser.COLON - 16)))) != 0)):
+                    if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << LaTeXParser.MUL) | (1 << LaTeXParser.DIV) | (1 << LaTeXParser.CMD_TIMES) | (1 << LaTeXParser.CMD_CDOT) | (1 << LaTeXParser.CMD_DIV) | (1 << LaTeXParser.COLON))) != 0)):
                         self._errHandler.recoverInline(self)
                     else:
                         self._errHandler.reportMatch(self)
                         self.consume()
-                    self.state = 126
+                    self.state = 118
                     self.mp_nofunc(3)
-                self.state = 131
+                self.state = 123
                 self._errHandler.sync(self)
                 _alt = self._interp.adaptivePredict(self._input,3,self._ctx)
 
@@ -930,34 +900,34 @@ def unary(self):
         self.enterRule(localctx, 14, self.RULE_unary)
         self._la = 0 # Token type
         try:
-            self.state = 139
+            self.state = 131
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [LaTeXParser.ADD, LaTeXParser.SUB]:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 132
+                self.state = 124
                 _la = self._input.LA(1)
                 if not(_la==LaTeXParser.ADD or _la==LaTeXParser.SUB):
                     self._errHandler.recoverInline(self)
                 else:
                     self._errHandler.reportMatch(self)
                     self.consume()
-                self.state = 133
+                self.state = 125
                 self.unary()
                 pass
-            elif token in [LaTeXParser.L_PAREN, LaTeXParser.L_BRACE, LaTeXParser.L_BRACE_LITERAL, LaTeXParser.L_BRACKET, LaTeXParser.BAR, LaTeXParser.L_BAR, LaTeXParser.L_ANGLE, LaTeXParser.FUNC_LIM, LaTeXParser.FUNC_INT, LaTeXParser.FUNC_SUM, LaTeXParser.FUNC_PROD, LaTeXParser.FUNC_EXP, LaTeXParser.FUNC_LOG, LaTeXParser.FUNC_LN, LaTeXParser.FUNC_SIN, LaTeXParser.FUNC_COS, LaTeXParser.FUNC_TAN, LaTeXParser.FUNC_CSC, LaTeXParser.FUNC_SEC, LaTeXParser.FUNC_COT, LaTeXParser.FUNC_ARCSIN, LaTeXParser.FUNC_ARCCOS, LaTeXParser.FUNC_ARCTAN, LaTeXParser.FUNC_ARCCSC, LaTeXParser.FUNC_ARCSEC, LaTeXParser.FUNC_ARCCOT, LaTeXParser.FUNC_SINH, LaTeXParser.FUNC_COSH, LaTeXParser.FUNC_TANH, LaTeXParser.FUNC_ARSINH, LaTeXParser.FUNC_ARCOSH, LaTeXParser.FUNC_ARTANH, LaTeXParser.L_FLOOR, LaTeXParser.L_CEIL, LaTeXParser.FUNC_SQRT, LaTeXParser.CMD_FRAC, LaTeXParser.CMD_BINOM, LaTeXParser.CMD_DBINOM, LaTeXParser.CMD_TBINOM, LaTeXParser.CMD_MATHIT, LaTeXParser.DIFFERENTIAL, LaTeXParser.LETTER, LaTeXParser.NUMBER, LaTeXParser.SYMBOL]:
+            elif token in [LaTeXParser.L_PAREN, LaTeXParser.L_BRACE, LaTeXParser.L_BRACE_LITERAL, LaTeXParser.L_BRACKET, LaTeXParser.BAR, LaTeXParser.FUNC_LIM, LaTeXParser.FUNC_INT, LaTeXParser.FUNC_SUM, LaTeXParser.FUNC_PROD, LaTeXParser.FUNC_EXP, LaTeXParser.FUNC_LOG, LaTeXParser.FUNC_LN, LaTeXParser.FUNC_SIN, LaTeXParser.FUNC_COS, LaTeXParser.FUNC_TAN, LaTeXParser.FUNC_CSC, LaTeXParser.FUNC_SEC, LaTeXParser.FUNC_COT, LaTeXParser.FUNC_ARCSIN, LaTeXParser.FUNC_ARCCOS, LaTeXParser.FUNC_ARCTAN, LaTeXParser.FUNC_ARCCSC, LaTeXParser.FUNC_ARCSEC, LaTeXParser.FUNC_ARCCOT, LaTeXParser.FUNC_SINH, LaTeXParser.FUNC_COSH, LaTeXParser.FUNC_TANH, LaTeXParser.FUNC_ARSINH, LaTeXParser.FUNC_ARCOSH, LaTeXParser.FUNC_ARTANH, LaTeXParser.FUNC_SQRT, LaTeXParser.CMD_FRAC, LaTeXParser.CMD_BINOM, LaTeXParser.CMD_DBINOM, LaTeXParser.CMD_TBINOM, LaTeXParser.CMD_MATHIT, LaTeXParser.DIFFERENTIAL, LaTeXParser.LETTER, LaTeXParser.NUMBER, LaTeXParser.SYMBOL]:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 135
+                self.state = 127
                 self._errHandler.sync(self)
                 _alt = 1
                 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                     if _alt == 1:
-                        self.state = 134
+                        self.state = 126
                         self.postfix()
 
                     else:
                         raise NoViableAltException(self)
-                    self.state = 137
+                    self.state = 129
                     self._errHandler.sync(self)
                     _alt = self._interp.adaptivePredict(self._input,4,self._ctx)
 
@@ -1013,33 +983,33 @@ def unary_nofunc(self):
         self.enterRule(localctx, 16, self.RULE_unary_nofunc)
         self._la = 0 # Token type
         try:
-            self.state = 150
+            self.state = 142
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [LaTeXParser.ADD, LaTeXParser.SUB]:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 141
+                self.state = 133
                 _la = self._input.LA(1)
                 if not(_la==LaTeXParser.ADD or _la==LaTeXParser.SUB):
                     self._errHandler.recoverInline(self)
                 else:
                     self._errHandler.reportMatch(self)
                     self.consume()
-                self.state = 142
+                self.state = 134
                 self.unary_nofunc()
                 pass
-            elif token in [LaTeXParser.L_PAREN, LaTeXParser.L_BRACE, LaTeXParser.L_BRACE_LITERAL, LaTeXParser.L_BRACKET, LaTeXParser.BAR, LaTeXParser.L_BAR, LaTeXParser.L_ANGLE, LaTeXParser.FUNC_LIM, LaTeXParser.FUNC_INT, LaTeXParser.FUNC_SUM, LaTeXParser.FUNC_PROD, LaTeXParser.FUNC_EXP, LaTeXParser.FUNC_LOG, LaTeXParser.FUNC_LN, LaTeXParser.FUNC_SIN, LaTeXParser.FUNC_COS, LaTeXParser.FUNC_TAN, LaTeXParser.FUNC_CSC, LaTeXParser.FUNC_SEC, LaTeXParser.FUNC_COT, LaTeXParser.FUNC_ARCSIN, LaTeXParser.FUNC_ARCCOS, LaTeXParser.FUNC_ARCTAN, LaTeXParser.FUNC_ARCCSC, LaTeXParser.FUNC_ARCSEC, LaTeXParser.FUNC_ARCCOT, LaTeXParser.FUNC_SINH, LaTeXParser.FUNC_COSH, LaTeXParser.FUNC_TANH, LaTeXParser.FUNC_ARSINH, LaTeXParser.FUNC_ARCOSH, LaTeXParser.FUNC_ARTANH, LaTeXParser.L_FLOOR, LaTeXParser.L_CEIL, LaTeXParser.FUNC_SQRT, LaTeXParser.CMD_FRAC, LaTeXParser.CMD_BINOM, LaTeXParser.CMD_DBINOM, LaTeXParser.CMD_TBINOM, LaTeXParser.CMD_MATHIT, LaTeXParser.DIFFERENTIAL, LaTeXParser.LETTER, LaTeXParser.NUMBER, LaTeXParser.SYMBOL]:
+            elif token in [LaTeXParser.L_PAREN, LaTeXParser.L_BRACE, LaTeXParser.L_BRACE_LITERAL, LaTeXParser.L_BRACKET, LaTeXParser.BAR, LaTeXParser.FUNC_LIM, LaTeXParser.FUNC_INT, LaTeXParser.FUNC_SUM, LaTeXParser.FUNC_PROD, LaTeXParser.FUNC_EXP, LaTeXParser.FUNC_LOG, LaTeXParser.FUNC_LN, LaTeXParser.FUNC_SIN, LaTeXParser.FUNC_COS, LaTeXParser.FUNC_TAN, LaTeXParser.FUNC_CSC, LaTeXParser.FUNC_SEC, LaTeXParser.FUNC_COT, LaTeXParser.FUNC_ARCSIN, LaTeXParser.FUNC_ARCCOS, LaTeXParser.FUNC_ARCTAN, LaTeXParser.FUNC_ARCCSC, LaTeXParser.FUNC_ARCSEC, LaTeXParser.FUNC_ARCCOT, LaTeXParser.FUNC_SINH, LaTeXParser.FUNC_COSH, LaTeXParser.FUNC_TANH, LaTeXParser.FUNC_ARSINH, LaTeXParser.FUNC_ARCOSH, LaTeXParser.FUNC_ARTANH, LaTeXParser.FUNC_SQRT, LaTeXParser.CMD_FRAC, LaTeXParser.CMD_BINOM, LaTeXParser.CMD_DBINOM, LaTeXParser.CMD_TBINOM, LaTeXParser.CMD_MATHIT, LaTeXParser.DIFFERENTIAL, LaTeXParser.LETTER, LaTeXParser.NUMBER, LaTeXParser.SYMBOL]:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 143
+                self.state = 135
                 self.postfix()
-                self.state = 147
+                self.state = 139
                 self._errHandler.sync(self)
                 _alt = self._interp.adaptivePredict(self._input,6,self._ctx)
                 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                     if _alt==1:
-                        self.state = 144
+                        self.state = 136
                         self.postfix_nofunc()
-                    self.state = 149
+                    self.state = 141
                     self._errHandler.sync(self)
                     _alt = self._interp.adaptivePredict(self._input,6,self._ctx)
 
@@ -1085,16 +1055,16 @@ def postfix(self):
         self.enterRule(localctx, 18, self.RULE_postfix)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 152
+            self.state = 144
             self.exp(0)
-            self.state = 156
+            self.state = 148
             self._errHandler.sync(self)
             _alt = self._interp.adaptivePredict(self._input,8,self._ctx)
             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                 if _alt==1:
-                    self.state = 153
+                    self.state = 145
                     self.postfix_op()
-                self.state = 158
+                self.state = 150
                 self._errHandler.sync(self)
                 _alt = self._interp.adaptivePredict(self._input,8,self._ctx)
 
@@ -1136,16 +1106,16 @@ def postfix_nofunc(self):
         self.enterRule(localctx, 20, self.RULE_postfix_nofunc)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 159
+            self.state = 151
             self.exp_nofunc(0)
-            self.state = 163
+            self.state = 155
             self._errHandler.sync(self)
             _alt = self._interp.adaptivePredict(self._input,9,self._ctx)
             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                 if _alt==1:
-                    self.state = 160
+                    self.state = 152
                     self.postfix_op()
-                self.state = 165
+                self.state = 157
                 self._errHandler.sync(self)
                 _alt = self._interp.adaptivePredict(self._input,9,self._ctx)
 
@@ -1182,17 +1152,17 @@ def postfix_op(self):
         localctx = LaTeXParser.Postfix_opContext(self, self._ctx, self.state)
         self.enterRule(localctx, 22, self.RULE_postfix_op)
         try:
-            self.state = 168
+            self.state = 160
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [LaTeXParser.BANG]:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 166
+                self.state = 158
                 self.match(LaTeXParser.BANG)
                 pass
             elif token in [LaTeXParser.BAR]:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 167
+                self.state = 159
                 self.eval_at()
                 pass
             else:
@@ -1236,25 +1206,25 @@ def eval_at(self):
         self.enterRule(localctx, 24, self.RULE_eval_at)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 170
+            self.state = 162
             self.match(LaTeXParser.BAR)
-            self.state = 176
+            self.state = 168
             self._errHandler.sync(self)
             la_ = self._interp.adaptivePredict(self._input,11,self._ctx)
             if la_ == 1:
-                self.state = 171
+                self.state = 163
                 self.eval_at_sup()
                 pass
 
             elif la_ == 2:
-                self.state = 172
+                self.state = 164
                 self.eval_at_sub()
                 pass
 
             elif la_ == 3:
-                self.state = 173
+                self.state = 165
                 self.eval_at_sup()
-                self.state = 174
+                self.state = 166
                 self.eval_at_sub()
                 pass
 
@@ -1303,25 +1273,25 @@ def eval_at_sub(self):
         self.enterRule(localctx, 26, self.RULE_eval_at_sub)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 178
+            self.state = 170
             self.match(LaTeXParser.UNDERSCORE)
-            self.state = 179
+            self.state = 171
             self.match(LaTeXParser.L_BRACE)
-            self.state = 182
+            self.state = 174
             self._errHandler.sync(self)
             la_ = self._interp.adaptivePredict(self._input,12,self._ctx)
             if la_ == 1:
-                self.state = 180
+                self.state = 172
                 self.expr()
                 pass
 
             elif la_ == 2:
-                self.state = 181
+                self.state = 173
                 self.equality()
                 pass
 
 
-            self.state = 184
+            self.state = 176
             self.match(LaTeXParser.R_BRACE)
         except RecognitionException as re:
             localctx.exception = re
@@ -1367,25 +1337,25 @@ def eval_at_sup(self):
         self.enterRule(localctx, 28, self.RULE_eval_at_sup)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 186
+            self.state = 178
             self.match(LaTeXParser.CARET)
-            self.state = 187
+            self.state = 179
             self.match(LaTeXParser.L_BRACE)
-            self.state = 190
+            self.state = 182
             self._errHandler.sync(self)
             la_ = self._interp.adaptivePredict(self._input,13,self._ctx)
             if la_ == 1:
-                self.state = 188
+                self.state = 180
                 self.expr()
                 pass
 
             elif la_ == 2:
-                self.state = 189
+                self.state = 181
                 self.equality()
                 pass
 
 
-            self.state = 192
+            self.state = 184
             self.match(LaTeXParser.R_BRACE)
         except RecognitionException as re:
             localctx.exception = re
@@ -1445,10 +1415,10 @@ def exp(self, _p=0):
         self.enterRecursionRule(localctx, 30, self.RULE_exp, _p)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 195
+            self.state = 187
             self.comp()
             self._ctx.stop = self._input.LT(-1)
-            self.state = 211
+            self.state = 203
             self._errHandler.sync(self)
             _alt = self._interp.adaptivePredict(self._input,16,self._ctx)
             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
@@ -1458,39 +1428,39 @@ def exp(self, _p=0):
                     _prevctx = localctx
                     localctx = LaTeXParser.ExpContext(self, _parentctx, _parentState)
                     self.pushNewRecursionContext(localctx, _startState, self.RULE_exp)
-                    self.state = 197
+                    self.state = 189
                     if not self.precpred(self._ctx, 2):
                         from antlr4.error.Errors import FailedPredicateException
                         raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
-                    self.state = 198
+                    self.state = 190
                     self.match(LaTeXParser.CARET)
-                    self.state = 204
+                    self.state = 196
                     self._errHandler.sync(self)
                     token = self._input.LA(1)
-                    if token in [LaTeXParser.BAR, LaTeXParser.L_BAR, LaTeXParser.L_ANGLE, LaTeXParser.CMD_MATHIT, LaTeXParser.DIFFERENTIAL, LaTeXParser.LETTER, LaTeXParser.NUMBER, LaTeXParser.SYMBOL]:
-                        self.state = 199
+                    if token in [LaTeXParser.CMD_MATHIT, LaTeXParser.DIFFERENTIAL, LaTeXParser.LETTER, LaTeXParser.NUMBER, LaTeXParser.SYMBOL]:
+                        self.state = 191
                         self.atom()
                         pass
                     elif token in [LaTeXParser.L_BRACE]:
-                        self.state = 200
+                        self.state = 192
                         self.match(LaTeXParser.L_BRACE)
-                        self.state = 201
+                        self.state = 193
                         self.expr()
-                        self.state = 202
+                        self.state = 194
                         self.match(LaTeXParser.R_BRACE)
                         pass
                     else:
                         raise NoViableAltException(self)
 
-                    self.state = 207
+                    self.state = 199
                     self._errHandler.sync(self)
                     la_ = self._interp.adaptivePredict(self._input,15,self._ctx)
                     if la_ == 1:
-                        self.state = 206
+                        self.state = 198
                         self.subexpr()
 
 
-                self.state = 213
+                self.state = 205
                 self._errHandler.sync(self)
                 _alt = self._interp.adaptivePredict(self._input,16,self._ctx)
 
@@ -1552,10 +1522,10 @@ def exp_nofunc(self, _p=0):
         self.enterRecursionRule(localctx, 32, self.RULE_exp_nofunc, _p)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 215
+            self.state = 207
             self.comp_nofunc()
             self._ctx.stop = self._input.LT(-1)
-            self.state = 231
+            self.state = 223
             self._errHandler.sync(self)
             _alt = self._interp.adaptivePredict(self._input,19,self._ctx)
             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
@@ -1565,39 +1535,39 @@ def exp_nofunc(self, _p=0):
                     _prevctx = localctx
                     localctx = LaTeXParser.Exp_nofuncContext(self, _parentctx, _parentState)
                     self.pushNewRecursionContext(localctx, _startState, self.RULE_exp_nofunc)
-                    self.state = 217
+                    self.state = 209
                     if not self.precpred(self._ctx, 2):
                         from antlr4.error.Errors import FailedPredicateException
                         raise FailedPredicateException(self, "self.precpred(self._ctx, 2)")
-                    self.state = 218
+                    self.state = 210
                     self.match(LaTeXParser.CARET)
-                    self.state = 224
+                    self.state = 216
                     self._errHandler.sync(self)
                     token = self._input.LA(1)
-                    if token in [LaTeXParser.BAR, LaTeXParser.L_BAR, LaTeXParser.L_ANGLE, LaTeXParser.CMD_MATHIT, LaTeXParser.DIFFERENTIAL, LaTeXParser.LETTER, LaTeXParser.NUMBER, LaTeXParser.SYMBOL]:
-                        self.state = 219
+                    if token in [LaTeXParser.CMD_MATHIT, LaTeXParser.DIFFERENTIAL, LaTeXParser.LETTER, LaTeXParser.NUMBER, LaTeXParser.SYMBOL]:
+                        self.state = 211
                         self.atom()
                         pass
                     elif token in [LaTeXParser.L_BRACE]:
-                        self.state = 220
+                        self.state = 212
                         self.match(LaTeXParser.L_BRACE)
-                        self.state = 221
+                        self.state = 213
                         self.expr()
-                        self.state = 222
+                        self.state = 214
                         self.match(LaTeXParser.R_BRACE)
                         pass
                     else:
                         raise NoViableAltException(self)
 
-                    self.state = 227
+                    self.state = 219
                     self._errHandler.sync(self)
                     la_ = self._interp.adaptivePredict(self._input,18,self._ctx)
                     if la_ == 1:
-                        self.state = 226
+                        self.state = 218
                         self.subexpr()
 
 
-                self.state = 233
+                self.state = 225
                 self._errHandler.sync(self)
                 _alt = self._interp.adaptivePredict(self._input,19,self._ctx)
 
@@ -1640,14 +1610,6 @@ def binom(self):
             return self.getTypedRuleContext(LaTeXParser.BinomContext,0)
 
 
-        def floor(self):
-            return self.getTypedRuleContext(LaTeXParser.FloorContext,0)
-
-
-        def ceil(self):
-            return self.getTypedRuleContext(LaTeXParser.CeilContext,0)
-
-
         def getRuleIndex(self):
             return LaTeXParser.RULE_comp
 
@@ -1659,57 +1621,45 @@ def comp(self):
         localctx = LaTeXParser.CompContext(self, self._ctx, self.state)
         self.enterRule(localctx, 34, self.RULE_comp)
         try:
-            self.state = 242
+            self.state = 232
             self._errHandler.sync(self)
             la_ = self._interp.adaptivePredict(self._input,20,self._ctx)
             if la_ == 1:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 234
+                self.state = 226
                 self.group()
                 pass
 
             elif la_ == 2:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 235
+                self.state = 227
                 self.abs_group()
                 pass
 
             elif la_ == 3:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 236
+                self.state = 228
                 self.func()
                 pass
 
             elif la_ == 4:
                 self.enterOuterAlt(localctx, 4)
-                self.state = 237
+                self.state = 229
                 self.atom()
                 pass
 
             elif la_ == 5:
                 self.enterOuterAlt(localctx, 5)
-                self.state = 238
+                self.state = 230
                 self.frac()
                 pass
 
             elif la_ == 6:
                 self.enterOuterAlt(localctx, 6)
-                self.state = 239
+                self.state = 231
                 self.binom()
                 pass
 
-            elif la_ == 7:
-                self.enterOuterAlt(localctx, 7)
-                self.state = 240
-                self.floor()
-                pass
-
-            elif la_ == 8:
-                self.enterOuterAlt(localctx, 8)
-                self.state = 241
-                self.ceil()
-                pass
-
 
         except RecognitionException as re:
             localctx.exception = re
@@ -1746,14 +1696,6 @@ def binom(self):
             return self.getTypedRuleContext(LaTeXParser.BinomContext,0)
 
 
-        def floor(self):
-            return self.getTypedRuleContext(LaTeXParser.FloorContext,0)
-
-
-        def ceil(self):
-            return self.getTypedRuleContext(LaTeXParser.CeilContext,0)
-
-
         def getRuleIndex(self):
             return LaTeXParser.RULE_comp_nofunc
 
@@ -1765,51 +1707,36 @@ def comp_nofunc(self):
         localctx = LaTeXParser.Comp_nofuncContext(self, self._ctx, self.state)
         self.enterRule(localctx, 36, self.RULE_comp_nofunc)
         try:
-            self.state = 251
+            self.state = 239
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,21,self._ctx)
-            if la_ == 1:
+            token = self._input.LA(1)
+            if token in [LaTeXParser.L_PAREN, LaTeXParser.L_BRACE, LaTeXParser.L_BRACE_LITERAL, LaTeXParser.L_BRACKET]:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 244
+                self.state = 234
                 self.group()
                 pass
-
-            elif la_ == 2:
+            elif token in [LaTeXParser.BAR]:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 245
+                self.state = 235
                 self.abs_group()
                 pass
-
-            elif la_ == 3:
+            elif token in [LaTeXParser.CMD_MATHIT, LaTeXParser.DIFFERENTIAL, LaTeXParser.LETTER, LaTeXParser.NUMBER, LaTeXParser.SYMBOL]:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 246
+                self.state = 236
                 self.atom()
                 pass
-
-            elif la_ == 4:
+            elif token in [LaTeXParser.CMD_FRAC]:
                 self.enterOuterAlt(localctx, 4)
-                self.state = 247
+                self.state = 237
                 self.frac()
                 pass
-
-            elif la_ == 5:
+            elif token in [LaTeXParser.CMD_BINOM, LaTeXParser.CMD_DBINOM, LaTeXParser.CMD_TBINOM]:
                 self.enterOuterAlt(localctx, 5)
-                self.state = 248
+                self.state = 238
                 self.binom()
                 pass
-
-            elif la_ == 6:
-                self.enterOuterAlt(localctx, 6)
-                self.state = 249
-                self.floor()
-                pass
-
-            elif la_ == 7:
-                self.enterOuterAlt(localctx, 7)
-                self.state = 250
-                self.ceil()
-                pass
-
+            else:
+                raise NoViableAltException(self)
 
         except RecognitionException as re:
             localctx.exception = re
@@ -1865,43 +1792,43 @@ def group(self):
         localctx = LaTeXParser.GroupContext(self, self._ctx, self.state)
         self.enterRule(localctx, 38, self.RULE_group)
         try:
-            self.state = 269
+            self.state = 257
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [LaTeXParser.L_PAREN]:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 253
+                self.state = 241
                 self.match(LaTeXParser.L_PAREN)
-                self.state = 254
+                self.state = 242
                 self.expr()
-                self.state = 255
+                self.state = 243
                 self.match(LaTeXParser.R_PAREN)
                 pass
             elif token in [LaTeXParser.L_BRACKET]:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 257
+                self.state = 245
                 self.match(LaTeXParser.L_BRACKET)
-                self.state = 258
+                self.state = 246
                 self.expr()
-                self.state = 259
+                self.state = 247
                 self.match(LaTeXParser.R_BRACKET)
                 pass
             elif token in [LaTeXParser.L_BRACE]:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 261
+                self.state = 249
                 self.match(LaTeXParser.L_BRACE)
-                self.state = 262
+                self.state = 250
                 self.expr()
-                self.state = 263
+                self.state = 251
                 self.match(LaTeXParser.R_BRACE)
                 pass
             elif token in [LaTeXParser.L_BRACE_LITERAL]:
                 self.enterOuterAlt(localctx, 4)
-                self.state = 265
+                self.state = 253
                 self.match(LaTeXParser.L_BRACE_LITERAL)
-                self.state = 266
+                self.state = 254
                 self.expr()
-                self.state = 267
+                self.state = 255
                 self.match(LaTeXParser.R_BRACE_LITERAL)
                 pass
             else:
@@ -1944,11 +1871,11 @@ def abs_group(self):
         self.enterRule(localctx, 40, self.RULE_abs_group)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 271
+            self.state = 259
             self.match(LaTeXParser.BAR)
-            self.state = 272
+            self.state = 260
             self.expr()
-            self.state = 273
+            self.state = 261
             self.match(LaTeXParser.BAR)
         except RecognitionException as re:
             localctx.exception = re
@@ -1985,14 +1912,6 @@ def mathit(self):
             return self.getTypedRuleContext(LaTeXParser.MathitContext,0)
 
 
-        def bra(self):
-            return self.getTypedRuleContext(LaTeXParser.BraContext,0)
-
-
-        def ket(self):
-            return self.getTypedRuleContext(LaTeXParser.KetContext,0)
-
-
         def getRuleIndex(self):
             return LaTeXParser.RULE_atom
 
@@ -2005,52 +1924,42 @@ def atom(self):
         self.enterRule(localctx, 42, self.RULE_atom)
         self._la = 0 # Token type
         try:
-            self.state = 284
+            self.state = 270
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [LaTeXParser.LETTER, LaTeXParser.SYMBOL]:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 275
+                self.state = 263
                 _la = self._input.LA(1)
                 if not(_la==LaTeXParser.LETTER or _la==LaTeXParser.SYMBOL):
                     self._errHandler.recoverInline(self)
                 else:
                     self._errHandler.reportMatch(self)
                     self.consume()
-                self.state = 277
+                self.state = 265
                 self._errHandler.sync(self)
                 la_ = self._interp.adaptivePredict(self._input,23,self._ctx)
                 if la_ == 1:
-                    self.state = 276
+                    self.state = 264
                     self.subexpr()
 
 
                 pass
             elif token in [LaTeXParser.NUMBER]:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 279
+                self.state = 267
                 self.match(LaTeXParser.NUMBER)
                 pass
             elif token in [LaTeXParser.DIFFERENTIAL]:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 280
+                self.state = 268
                 self.match(LaTeXParser.DIFFERENTIAL)
                 pass
             elif token in [LaTeXParser.CMD_MATHIT]:
                 self.enterOuterAlt(localctx, 4)
-                self.state = 281
+                self.state = 269
                 self.mathit()
                 pass
-            elif token in [LaTeXParser.L_ANGLE]:
-                self.enterOuterAlt(localctx, 5)
-                self.state = 282
-                self.bra()
-                pass
-            elif token in [LaTeXParser.BAR, LaTeXParser.L_BAR]:
-                self.enterOuterAlt(localctx, 6)
-                self.state = 283
-                self.ket()
-                pass
             else:
                 raise NoViableAltException(self)
 
@@ -2063,110 +1972,6 @@ def atom(self):
         return localctx
 
 
-    class BraContext(ParserRuleContext):
-
-        def __init__(self, parser, parent=None, invokingState=-1):
-            super(LaTeXParser.BraContext, self).__init__(parent, invokingState)
-            self.parser = parser
-
-        def L_ANGLE(self):
-            return self.getToken(LaTeXParser.L_ANGLE, 0)
-
-        def expr(self):
-            return self.getTypedRuleContext(LaTeXParser.ExprContext,0)
-
-
-        def R_BAR(self):
-            return self.getToken(LaTeXParser.R_BAR, 0)
-
-        def BAR(self):
-            return self.getToken(LaTeXParser.BAR, 0)
-
-        def getRuleIndex(self):
-            return LaTeXParser.RULE_bra
-
-
-
-
-    def bra(self):
-
-        localctx = LaTeXParser.BraContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 44, self.RULE_bra)
-        self._la = 0 # Token type
-        try:
-            self.enterOuterAlt(localctx, 1)
-            self.state = 286
-            self.match(LaTeXParser.L_ANGLE)
-            self.state = 287
-            self.expr()
-            self.state = 288
-            _la = self._input.LA(1)
-            if not(_la==LaTeXParser.BAR or _la==LaTeXParser.R_BAR):
-                self._errHandler.recoverInline(self)
-            else:
-                self._errHandler.reportMatch(self)
-                self.consume()
-        except RecognitionException as re:
-            localctx.exception = re
-            self._errHandler.reportError(self, re)
-            self._errHandler.recover(self, re)
-        finally:
-            self.exitRule()
-        return localctx
-
-
-    class KetContext(ParserRuleContext):
-
-        def __init__(self, parser, parent=None, invokingState=-1):
-            super(LaTeXParser.KetContext, self).__init__(parent, invokingState)
-            self.parser = parser
-
-        def expr(self):
-            return self.getTypedRuleContext(LaTeXParser.ExprContext,0)
-
-
-        def R_ANGLE(self):
-            return self.getToken(LaTeXParser.R_ANGLE, 0)
-
-        def L_BAR(self):
-            return self.getToken(LaTeXParser.L_BAR, 0)
-
-        def BAR(self):
-            return self.getToken(LaTeXParser.BAR, 0)
-
-        def getRuleIndex(self):
-            return LaTeXParser.RULE_ket
-
-
-
-
-    def ket(self):
-
-        localctx = LaTeXParser.KetContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 46, self.RULE_ket)
-        self._la = 0 # Token type
-        try:
-            self.enterOuterAlt(localctx, 1)
-            self.state = 290
-            _la = self._input.LA(1)
-            if not(_la==LaTeXParser.BAR or _la==LaTeXParser.L_BAR):
-                self._errHandler.recoverInline(self)
-            else:
-                self._errHandler.reportMatch(self)
-                self.consume()
-            self.state = 291
-            self.expr()
-            self.state = 292
-            self.match(LaTeXParser.R_ANGLE)
-        except RecognitionException as re:
-            localctx.exception = re
-            self._errHandler.reportError(self, re)
-            self._errHandler.recover(self, re)
-        finally:
-            self.exitRule()
-        return localctx
-
-
     class MathitContext(ParserRuleContext):
 
         def __init__(self, parser, parent=None, invokingState=-1):
@@ -2195,16 +2000,16 @@ def getRuleIndex(self):
     def mathit(self):
 
         localctx = LaTeXParser.MathitContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 48, self.RULE_mathit)
+        self.enterRule(localctx, 44, self.RULE_mathit)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 294
+            self.state = 272
             self.match(LaTeXParser.CMD_MATHIT)
-            self.state = 295
+            self.state = 273
             self.match(LaTeXParser.L_BRACE)
-            self.state = 296
+            self.state = 274
             self.mathit_text()
-            self.state = 297
+            self.state = 275
             self.match(LaTeXParser.R_BRACE)
         except RecognitionException as re:
             localctx.exception = re
@@ -2236,17 +2041,17 @@ def getRuleIndex(self):
     def mathit_text(self):
 
         localctx = LaTeXParser.Mathit_textContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 50, self.RULE_mathit_text)
+        self.enterRule(localctx, 46, self.RULE_mathit_text)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 302
+            self.state = 280
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==LaTeXParser.LETTER:
-                self.state = 299
+                self.state = 277
                 self.match(LaTeXParser.LETTER)
-                self.state = 304
+                self.state = 282
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
@@ -2298,22 +2103,22 @@ def getRuleIndex(self):
     def frac(self):
 
         localctx = LaTeXParser.FracContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 52, self.RULE_frac)
+        self.enterRule(localctx, 48, self.RULE_frac)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 305
+            self.state = 283
             self.match(LaTeXParser.CMD_FRAC)
-            self.state = 306
+            self.state = 284
             self.match(LaTeXParser.L_BRACE)
-            self.state = 307
+            self.state = 285
             localctx.upper = self.expr()
-            self.state = 308
+            self.state = 286
             self.match(LaTeXParser.R_BRACE)
-            self.state = 309
+            self.state = 287
             self.match(LaTeXParser.L_BRACE)
-            self.state = 310
+            self.state = 288
             localctx.lower = self.expr()
-            self.state = 311
+            self.state = 289
             self.match(LaTeXParser.R_BRACE)
         except RecognitionException as re:
             localctx.exception = re
@@ -2369,28 +2174,28 @@ def getRuleIndex(self):
     def binom(self):
 
         localctx = LaTeXParser.BinomContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 54, self.RULE_binom)
+        self.enterRule(localctx, 50, self.RULE_binom)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 313
+            self.state = 291
             _la = self._input.LA(1)
-            if not(((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (LaTeXParser.CMD_BINOM - 66)) | (1 << (LaTeXParser.CMD_DBINOM - 66)) | (1 << (LaTeXParser.CMD_TBINOM - 66)))) != 0)):
+            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << LaTeXParser.CMD_BINOM) | (1 << LaTeXParser.CMD_DBINOM) | (1 << LaTeXParser.CMD_TBINOM))) != 0)):
                 self._errHandler.recoverInline(self)
             else:
                 self._errHandler.reportMatch(self)
                 self.consume()
-            self.state = 314
+            self.state = 292
             self.match(LaTeXParser.L_BRACE)
-            self.state = 315
+            self.state = 293
             localctx.n = self.expr()
-            self.state = 316
+            self.state = 294
             self.match(LaTeXParser.R_BRACE)
-            self.state = 317
+            self.state = 295
             self.match(LaTeXParser.L_BRACE)
-            self.state = 318
+            self.state = 296
             localctx.k = self.expr()
-            self.state = 319
+            self.state = 297
             self.match(LaTeXParser.R_BRACE)
         except RecognitionException as re:
             localctx.exception = re
@@ -2401,94 +2206,6 @@ def binom(self):
         return localctx
 
 
-    class FloorContext(ParserRuleContext):
-
-        def __init__(self, parser, parent=None, invokingState=-1):
-            super(LaTeXParser.FloorContext, self).__init__(parent, invokingState)
-            self.parser = parser
-            self.val = None # ExprContext
-
-        def L_FLOOR(self):
-            return self.getToken(LaTeXParser.L_FLOOR, 0)
-
-        def R_FLOOR(self):
-            return self.getToken(LaTeXParser.R_FLOOR, 0)
-
-        def expr(self):
-            return self.getTypedRuleContext(LaTeXParser.ExprContext,0)
-
-
-        def getRuleIndex(self):
-            return LaTeXParser.RULE_floor
-
-
-
-
-    def floor(self):
-
-        localctx = LaTeXParser.FloorContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 56, self.RULE_floor)
-        try:
-            self.enterOuterAlt(localctx, 1)
-            self.state = 321
-            self.match(LaTeXParser.L_FLOOR)
-            self.state = 322
-            localctx.val = self.expr()
-            self.state = 323
-            self.match(LaTeXParser.R_FLOOR)
-        except RecognitionException as re:
-            localctx.exception = re
-            self._errHandler.reportError(self, re)
-            self._errHandler.recover(self, re)
-        finally:
-            self.exitRule()
-        return localctx
-
-
-    class CeilContext(ParserRuleContext):
-
-        def __init__(self, parser, parent=None, invokingState=-1):
-            super(LaTeXParser.CeilContext, self).__init__(parent, invokingState)
-            self.parser = parser
-            self.val = None # ExprContext
-
-        def L_CEIL(self):
-            return self.getToken(LaTeXParser.L_CEIL, 0)
-
-        def R_CEIL(self):
-            return self.getToken(LaTeXParser.R_CEIL, 0)
-
-        def expr(self):
-            return self.getTypedRuleContext(LaTeXParser.ExprContext,0)
-
-
-        def getRuleIndex(self):
-            return LaTeXParser.RULE_ceil
-
-
-
-
-    def ceil(self):
-
-        localctx = LaTeXParser.CeilContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 58, self.RULE_ceil)
-        try:
-            self.enterOuterAlt(localctx, 1)
-            self.state = 325
-            self.match(LaTeXParser.L_CEIL)
-            self.state = 326
-            localctx.val = self.expr()
-            self.state = 327
-            self.match(LaTeXParser.R_CEIL)
-        except RecognitionException as re:
-            localctx.exception = re
-            self._errHandler.reportError(self, re)
-            self._errHandler.recover(self, re)
-        finally:
-            self.exitRule()
-        return localctx
-
-
     class Func_normalContext(ParserRuleContext):
 
         def __init__(self, parser, parent=None, invokingState=-1):
@@ -2567,11 +2284,11 @@ def getRuleIndex(self):
     def func_normal(self):
 
         localctx = LaTeXParser.Func_normalContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 60, self.RULE_func_normal)
+        self.enterRule(localctx, 52, self.RULE_func_normal)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 329
+            self.state = 299
             _la = self._input.LA(1)
             if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << LaTeXParser.FUNC_EXP) | (1 << LaTeXParser.FUNC_LOG) | (1 << LaTeXParser.FUNC_LN) | (1 << LaTeXParser.FUNC_SIN) | (1 << LaTeXParser.FUNC_COS) | (1 << LaTeXParser.FUNC_TAN) | (1 << LaTeXParser.FUNC_CSC) | (1 << LaTeXParser.FUNC_SEC) | (1 << LaTeXParser.FUNC_COT) | (1 << LaTeXParser.FUNC_ARCSIN) | (1 << LaTeXParser.FUNC_ARCCOS) | (1 << LaTeXParser.FUNC_ARCTAN) | (1 << LaTeXParser.FUNC_ARCCSC) | (1 << LaTeXParser.FUNC_ARCSEC) | (1 << LaTeXParser.FUNC_ARCCOT) | (1 << LaTeXParser.FUNC_SINH) | (1 << LaTeXParser.FUNC_COSH) | (1 << LaTeXParser.FUNC_TANH) | (1 << LaTeXParser.FUNC_ARSINH) | (1 << LaTeXParser.FUNC_ARCOSH) | (1 << LaTeXParser.FUNC_ARTANH))) != 0)):
                 self._errHandler.recoverInline(self)
@@ -2697,72 +2414,72 @@ def getRuleIndex(self):
     def func(self):
 
         localctx = LaTeXParser.FuncContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 62, self.RULE_func)
+        self.enterRule(localctx, 54, self.RULE_func)
         self._la = 0 # Token type
         try:
-            self.state = 404
+            self.state = 374
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [LaTeXParser.FUNC_EXP, LaTeXParser.FUNC_LOG, LaTeXParser.FUNC_LN, LaTeXParser.FUNC_SIN, LaTeXParser.FUNC_COS, LaTeXParser.FUNC_TAN, LaTeXParser.FUNC_CSC, LaTeXParser.FUNC_SEC, LaTeXParser.FUNC_COT, LaTeXParser.FUNC_ARCSIN, LaTeXParser.FUNC_ARCCOS, LaTeXParser.FUNC_ARCTAN, LaTeXParser.FUNC_ARCCSC, LaTeXParser.FUNC_ARCSEC, LaTeXParser.FUNC_ARCCOT, LaTeXParser.FUNC_SINH, LaTeXParser.FUNC_COSH, LaTeXParser.FUNC_TANH, LaTeXParser.FUNC_ARSINH, LaTeXParser.FUNC_ARCOSH, LaTeXParser.FUNC_ARTANH]:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 331
+                self.state = 301
                 self.func_normal()
-                self.state = 344
+                self.state = 314
                 self._errHandler.sync(self)
                 la_ = self._interp.adaptivePredict(self._input,30,self._ctx)
                 if la_ == 1:
-                    self.state = 333
+                    self.state = 303
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
                     if _la==LaTeXParser.UNDERSCORE:
-                        self.state = 332
+                        self.state = 302
                         self.subexpr()
 
 
-                    self.state = 336
+                    self.state = 306
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
                     if _la==LaTeXParser.CARET:
-                        self.state = 335
+                        self.state = 305
                         self.supexpr()
 
 
                     pass
 
                 elif la_ == 2:
-                    self.state = 339
+                    self.state = 309
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
                     if _la==LaTeXParser.CARET:
-                        self.state = 338
+                        self.state = 308
                         self.supexpr()
 
 
-                    self.state = 342
+                    self.state = 312
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
                     if _la==LaTeXParser.UNDERSCORE:
-                        self.state = 341
+                        self.state = 311
                         self.subexpr()
 
 
                     pass
 
 
-                self.state = 351
+                self.state = 321
                 self._errHandler.sync(self)
                 la_ = self._interp.adaptivePredict(self._input,31,self._ctx)
                 if la_ == 1:
-                    self.state = 346
+                    self.state = 316
                     self.match(LaTeXParser.L_PAREN)
-                    self.state = 347
+                    self.state = 317
                     self.func_arg()
-                    self.state = 348
+                    self.state = 318
                     self.match(LaTeXParser.R_PAREN)
                     pass
 
                 elif la_ == 2:
-                    self.state = 350
+                    self.state = 320
                     self.func_arg_noparens()
                     pass
 
@@ -2770,74 +2487,74 @@ def func(self):
                 pass
             elif token in [LaTeXParser.LETTER, LaTeXParser.SYMBOL]:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 353
+                self.state = 323
                 _la = self._input.LA(1)
                 if not(_la==LaTeXParser.LETTER or _la==LaTeXParser.SYMBOL):
                     self._errHandler.recoverInline(self)
                 else:
                     self._errHandler.reportMatch(self)
                     self.consume()
-                self.state = 355
+                self.state = 325
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if _la==LaTeXParser.UNDERSCORE:
-                    self.state = 354
+                    self.state = 324
                     self.subexpr()
 
 
-                self.state = 357
+                self.state = 327
                 self.match(LaTeXParser.L_PAREN)
-                self.state = 358
+                self.state = 328
                 self.args()
-                self.state = 359
+                self.state = 329
                 self.match(LaTeXParser.R_PAREN)
                 pass
             elif token in [LaTeXParser.FUNC_INT]:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 361
+                self.state = 331
                 self.match(LaTeXParser.FUNC_INT)
-                self.state = 368
+                self.state = 338
                 self._errHandler.sync(self)
                 token = self._input.LA(1)
                 if token in [LaTeXParser.UNDERSCORE]:
-                    self.state = 362
+                    self.state = 332
                     self.subexpr()
-                    self.state = 363
+                    self.state = 333
                     self.supexpr()
                     pass
                 elif token in [LaTeXParser.CARET]:
-                    self.state = 365
+                    self.state = 335
                     self.supexpr()
-                    self.state = 366
+                    self.state = 336
                     self.subexpr()
                     pass
-                elif token in [LaTeXParser.ADD, LaTeXParser.SUB, LaTeXParser.L_PAREN, LaTeXParser.L_BRACE, LaTeXParser.L_BRACE_LITERAL, LaTeXParser.L_BRACKET, LaTeXParser.BAR, LaTeXParser.L_BAR, LaTeXParser.L_ANGLE, LaTeXParser.FUNC_LIM, LaTeXParser.FUNC_INT, LaTeXParser.FUNC_SUM, LaTeXParser.FUNC_PROD, LaTeXParser.FUNC_EXP, LaTeXParser.FUNC_LOG, LaTeXParser.FUNC_LN, LaTeXParser.FUNC_SIN, LaTeXParser.FUNC_COS, LaTeXParser.FUNC_TAN, LaTeXParser.FUNC_CSC, LaTeXParser.FUNC_SEC, LaTeXParser.FUNC_COT, LaTeXParser.FUNC_ARCSIN, LaTeXParser.FUNC_ARCCOS, LaTeXParser.FUNC_ARCTAN, LaTeXParser.FUNC_ARCCSC, LaTeXParser.FUNC_ARCSEC, LaTeXParser.FUNC_ARCCOT, LaTeXParser.FUNC_SINH, LaTeXParser.FUNC_COSH, LaTeXParser.FUNC_TANH, LaTeXParser.FUNC_ARSINH, LaTeXParser.FUNC_ARCOSH, LaTeXParser.FUNC_ARTANH, LaTeXParser.L_FLOOR, LaTeXParser.L_CEIL, LaTeXParser.FUNC_SQRT, LaTeXParser.CMD_FRAC, LaTeXParser.CMD_BINOM, LaTeXParser.CMD_DBINOM, LaTeXParser.CMD_TBINOM, LaTeXParser.CMD_MATHIT, LaTeXParser.DIFFERENTIAL, LaTeXParser.LETTER, LaTeXParser.NUMBER, LaTeXParser.SYMBOL]:
+                elif token in [LaTeXParser.ADD, LaTeXParser.SUB, LaTeXParser.L_PAREN, LaTeXParser.L_BRACE, LaTeXParser.L_BRACE_LITERAL, LaTeXParser.L_BRACKET, LaTeXParser.BAR, LaTeXParser.FUNC_LIM, LaTeXParser.FUNC_INT, LaTeXParser.FUNC_SUM, LaTeXParser.FUNC_PROD, LaTeXParser.FUNC_EXP, LaTeXParser.FUNC_LOG, LaTeXParser.FUNC_LN, LaTeXParser.FUNC_SIN, LaTeXParser.FUNC_COS, LaTeXParser.FUNC_TAN, LaTeXParser.FUNC_CSC, LaTeXParser.FUNC_SEC, LaTeXParser.FUNC_COT, LaTeXParser.FUNC_ARCSIN, LaTeXParser.FUNC_ARCCOS, LaTeXParser.FUNC_ARCTAN, LaTeXParser.FUNC_ARCCSC, LaTeXParser.FUNC_ARCSEC, LaTeXParser.FUNC_ARCCOT, LaTeXParser.FUNC_SINH, LaTeXParser.FUNC_COSH, LaTeXParser.FUNC_TANH, LaTeXParser.FUNC_ARSINH, LaTeXParser.FUNC_ARCOSH, LaTeXParser.FUNC_ARTANH, LaTeXParser.FUNC_SQRT, LaTeXParser.CMD_FRAC, LaTeXParser.CMD_BINOM, LaTeXParser.CMD_DBINOM, LaTeXParser.CMD_TBINOM, LaTeXParser.CMD_MATHIT, LaTeXParser.DIFFERENTIAL, LaTeXParser.LETTER, LaTeXParser.NUMBER, LaTeXParser.SYMBOL]:
                     pass
                 else:
                     pass
-                self.state = 376
+                self.state = 346
                 self._errHandler.sync(self)
                 la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
                 if la_ == 1:
-                    self.state = 371
+                    self.state = 341
                     self._errHandler.sync(self)
                     la_ = self._interp.adaptivePredict(self._input,34,self._ctx)
                     if la_ == 1:
-                        self.state = 370
+                        self.state = 340
                         self.additive(0)
 
 
-                    self.state = 373
+                    self.state = 343
                     self.match(LaTeXParser.DIFFERENTIAL)
                     pass
 
                 elif la_ == 2:
-                    self.state = 374
+                    self.state = 344
                     self.frac()
                     pass
 
                 elif la_ == 3:
-                    self.state = 375
+                    self.state = 345
                     self.additive(0)
                     pass
 
@@ -2845,64 +2562,64 @@ def func(self):
                 pass
             elif token in [LaTeXParser.FUNC_SQRT]:
                 self.enterOuterAlt(localctx, 4)
-                self.state = 378
+                self.state = 348
                 self.match(LaTeXParser.FUNC_SQRT)
-                self.state = 383
+                self.state = 353
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if _la==LaTeXParser.L_BRACKET:
-                    self.state = 379
+                    self.state = 349
                     self.match(LaTeXParser.L_BRACKET)
-                    self.state = 380
+                    self.state = 350
                     localctx.root = self.expr()
-                    self.state = 381
+                    self.state = 351
                     self.match(LaTeXParser.R_BRACKET)
 
 
-                self.state = 385
+                self.state = 355
                 self.match(LaTeXParser.L_BRACE)
-                self.state = 386
+                self.state = 356
                 localctx.base = self.expr()
-                self.state = 387
+                self.state = 357
                 self.match(LaTeXParser.R_BRACE)
                 pass
             elif token in [LaTeXParser.FUNC_SUM, LaTeXParser.FUNC_PROD]:
                 self.enterOuterAlt(localctx, 5)
-                self.state = 389
+                self.state = 359
                 _la = self._input.LA(1)
                 if not(_la==LaTeXParser.FUNC_SUM or _la==LaTeXParser.FUNC_PROD):
                     self._errHandler.recoverInline(self)
                 else:
                     self._errHandler.reportMatch(self)
                     self.consume()
-                self.state = 396
+                self.state = 366
                 self._errHandler.sync(self)
                 token = self._input.LA(1)
                 if token in [LaTeXParser.UNDERSCORE]:
-                    self.state = 390
+                    self.state = 360
                     self.subeq()
-                    self.state = 391
+                    self.state = 361
                     self.supexpr()
                     pass
                 elif token in [LaTeXParser.CARET]:
-                    self.state = 393
+                    self.state = 363
                     self.supexpr()
-                    self.state = 394
+                    self.state = 364
                     self.subeq()
                     pass
                 else:
                     raise NoViableAltException(self)
 
-                self.state = 398
+                self.state = 368
                 self.mp(0)
                 pass
             elif token in [LaTeXParser.FUNC_LIM]:
                 self.enterOuterAlt(localctx, 6)
-                self.state = 400
+                self.state = 370
                 self.match(LaTeXParser.FUNC_LIM)
-                self.state = 401
+                self.state = 371
                 self.limit_sub()
-                self.state = 402
+                self.state = 372
                 self.mp(0)
                 pass
             else:
@@ -2940,24 +2657,24 @@ def getRuleIndex(self):
     def args(self):
 
         localctx = LaTeXParser.ArgsContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 64, self.RULE_args)
+        self.enterRule(localctx, 56, self.RULE_args)
         try:
-            self.state = 411
+            self.state = 381
             self._errHandler.sync(self)
             la_ = self._interp.adaptivePredict(self._input,39,self._ctx)
             if la_ == 1:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 406
+                self.state = 376
                 self.expr()
-                self.state = 407
+                self.state = 377
                 self.match(LaTeXParser.T__0)
-                self.state = 408
+                self.state = 378
                 self.args()
                 pass
 
             elif la_ == 2:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 410
+                self.state = 380
                 self.expr()
                 pass
 
@@ -3023,45 +2740,45 @@ def getRuleIndex(self):
     def limit_sub(self):
 
         localctx = LaTeXParser.Limit_subContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 66, self.RULE_limit_sub)
+        self.enterRule(localctx, 58, self.RULE_limit_sub)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 413
+            self.state = 383
             self.match(LaTeXParser.UNDERSCORE)
-            self.state = 414
+            self.state = 384
             self.match(LaTeXParser.L_BRACE)
-            self.state = 415
+            self.state = 385
             _la = self._input.LA(1)
             if not(_la==LaTeXParser.LETTER or _la==LaTeXParser.SYMBOL):
                 self._errHandler.recoverInline(self)
             else:
                 self._errHandler.reportMatch(self)
                 self.consume()
-            self.state = 416
+            self.state = 386
             self.match(LaTeXParser.LIM_APPROACH_SYM)
-            self.state = 417
+            self.state = 387
             self.expr()
-            self.state = 422
+            self.state = 392
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==LaTeXParser.CARET:
-                self.state = 418
+                self.state = 388
                 self.match(LaTeXParser.CARET)
-                self.state = 419
+                self.state = 389
                 self.match(LaTeXParser.L_BRACE)
-                self.state = 420
+                self.state = 390
                 _la = self._input.LA(1)
                 if not(_la==LaTeXParser.ADD or _la==LaTeXParser.SUB):
                     self._errHandler.recoverInline(self)
                 else:
                     self._errHandler.reportMatch(self)
                     self.consume()
-                self.state = 421
+                self.state = 391
                 self.match(LaTeXParser.R_BRACE)
 
 
-            self.state = 424
+            self.state = 394
             self.match(LaTeXParser.R_BRACE)
         except RecognitionException as re:
             localctx.exception = re
@@ -3095,24 +2812,24 @@ def getRuleIndex(self):
     def func_arg(self):
 
         localctx = LaTeXParser.Func_argContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 68, self.RULE_func_arg)
+        self.enterRule(localctx, 60, self.RULE_func_arg)
         try:
-            self.state = 431
+            self.state = 401
             self._errHandler.sync(self)
             la_ = self._interp.adaptivePredict(self._input,41,self._ctx)
             if la_ == 1:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 426
+                self.state = 396
                 self.expr()
                 pass
 
             elif la_ == 2:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 427
+                self.state = 397
                 self.expr()
-                self.state = 428
+                self.state = 398
                 self.match(LaTeXParser.T__0)
-                self.state = 429
+                self.state = 399
                 self.func_arg()
                 pass
 
@@ -3145,10 +2862,10 @@ def getRuleIndex(self):
     def func_arg_noparens(self):
 
         localctx = LaTeXParser.Func_arg_noparensContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 70, self.RULE_func_arg_noparens)
+        self.enterRule(localctx, 62, self.RULE_func_arg_noparens)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 433
+            self.state = 403
             self.mp_nofunc(0)
         except RecognitionException as re:
             localctx.exception = re
@@ -3191,24 +2908,24 @@ def getRuleIndex(self):
     def subexpr(self):
 
         localctx = LaTeXParser.SubexprContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 72, self.RULE_subexpr)
+        self.enterRule(localctx, 64, self.RULE_subexpr)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 435
+            self.state = 405
             self.match(LaTeXParser.UNDERSCORE)
-            self.state = 441
+            self.state = 411
             self._errHandler.sync(self)
             token = self._input.LA(1)
-            if token in [LaTeXParser.BAR, LaTeXParser.L_BAR, LaTeXParser.L_ANGLE, LaTeXParser.CMD_MATHIT, LaTeXParser.DIFFERENTIAL, LaTeXParser.LETTER, LaTeXParser.NUMBER, LaTeXParser.SYMBOL]:
-                self.state = 436
+            if token in [LaTeXParser.CMD_MATHIT, LaTeXParser.DIFFERENTIAL, LaTeXParser.LETTER, LaTeXParser.NUMBER, LaTeXParser.SYMBOL]:
+                self.state = 406
                 self.atom()
                 pass
             elif token in [LaTeXParser.L_BRACE]:
-                self.state = 437
+                self.state = 407
                 self.match(LaTeXParser.L_BRACE)
-                self.state = 438
+                self.state = 408
                 self.expr()
-                self.state = 439
+                self.state = 409
                 self.match(LaTeXParser.R_BRACE)
                 pass
             else:
@@ -3255,24 +2972,24 @@ def getRuleIndex(self):
     def supexpr(self):
 
         localctx = LaTeXParser.SupexprContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 74, self.RULE_supexpr)
+        self.enterRule(localctx, 66, self.RULE_supexpr)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 443
+            self.state = 413
             self.match(LaTeXParser.CARET)
-            self.state = 449
+            self.state = 419
             self._errHandler.sync(self)
             token = self._input.LA(1)
-            if token in [LaTeXParser.BAR, LaTeXParser.L_BAR, LaTeXParser.L_ANGLE, LaTeXParser.CMD_MATHIT, LaTeXParser.DIFFERENTIAL, LaTeXParser.LETTER, LaTeXParser.NUMBER, LaTeXParser.SYMBOL]:
-                self.state = 444
+            if token in [LaTeXParser.CMD_MATHIT, LaTeXParser.DIFFERENTIAL, LaTeXParser.LETTER, LaTeXParser.NUMBER, LaTeXParser.SYMBOL]:
+                self.state = 414
                 self.atom()
                 pass
             elif token in [LaTeXParser.L_BRACE]:
-                self.state = 445
+                self.state = 415
                 self.match(LaTeXParser.L_BRACE)
-                self.state = 446
+                self.state = 416
                 self.expr()
-                self.state = 447
+                self.state = 417
                 self.match(LaTeXParser.R_BRACE)
                 pass
             else:
@@ -3315,16 +3032,16 @@ def getRuleIndex(self):
     def subeq(self):
 
         localctx = LaTeXParser.SubeqContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 76, self.RULE_subeq)
+        self.enterRule(localctx, 68, self.RULE_subeq)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 451
+            self.state = 421
             self.match(LaTeXParser.UNDERSCORE)
-            self.state = 452
+            self.state = 422
             self.match(LaTeXParser.L_BRACE)
-            self.state = 453
+            self.state = 423
             self.equality()
-            self.state = 454
+            self.state = 424
             self.match(LaTeXParser.R_BRACE)
         except RecognitionException as re:
             localctx.exception = re
@@ -3363,16 +3080,16 @@ def getRuleIndex(self):
     def supeq(self):
 
         localctx = LaTeXParser.SupeqContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 78, self.RULE_supeq)
+        self.enterRule(localctx, 70, self.RULE_supeq)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 456
+            self.state = 426
             self.match(LaTeXParser.UNDERSCORE)
-            self.state = 457
+            self.state = 427
             self.match(LaTeXParser.L_BRACE)
-            self.state = 458
+            self.state = 428
             self.equality()
-            self.state = 459
+            self.state = 429
             self.match(LaTeXParser.R_BRACE)
         except RecognitionException as re:
             localctx.exception = re
diff --git a/sympy/parsing/latex/_parse_latex_antlr.py b/sympy/parsing/latex/_parse_latex_antlr.py
index 0cc0ae8106..ed808188de 100644
--- a/sympy/parsing/latex/_parse_latex_antlr.py
+++ b/sympy/parsing/latex/_parse_latex_antlr.py
@@ -5,7 +5,6 @@
 import sympy
 from sympy.external import import_module
 from sympy.printing.str import StrPrinter
-from sympy.physics.quantum.state import Bra, Ket
 
 from .errors import LaTeXParsingError
 
@@ -284,10 +283,6 @@ def convert_comp(comp):
         return convert_frac(comp.frac())
     elif comp.binom():
         return convert_binom(comp.binom())
-    elif comp.floor():
-        return convert_floor(comp.floor())
-    elif comp.ceil():
-        return convert_ceil(comp.ceil())
     elif comp.func():
         return convert_func(comp.func())
 
@@ -326,12 +321,6 @@ def convert_atom(atom):
     elif atom.mathit():
         text = rule2text(atom.mathit().mathit_text())
         return sympy.Symbol(text)
-    elif atom.bra():
-        val = convert_expr(atom.bra().expr())
-        return Bra(val)
-    elif atom.ket():
-        val = convert_expr(atom.ket().expr())
-        return Ket(val)
 
 
 def rule2text(ctx):
@@ -395,14 +384,6 @@ def convert_binom(binom):
     expr_k = convert_expr(binom.k)
     return sympy.binomial(expr_n, expr_k, evaluate=False)
 
-def convert_floor(floor):
-    val = convert_expr(floor.val)
-    return sympy.floor(val, evaluate=False)
-
-def convert_ceil(ceil):
-    val = convert_expr(ceil.val)
-    return sympy.ceiling(val, evaluate=False)
-
 def convert_func(func):
     if func.func_normal():
         if func.L_PAREN():  # function called with parenthesis
diff --git a/sympy/sets/handlers/comparison.py b/sympy/sets/handlers/comparison.py
index e21ab30b43..6f7a19fccf 100644
--- a/sympy/sets/handlers/comparison.py
+++ b/sympy/sets/handlers/comparison.py
@@ -1,8 +1,9 @@
 from sympy.core.relational import Eq, is_eq
+from sympy.core.basic import Basic
 from sympy.core.logic import fuzzy_and, fuzzy_bool
 from sympy.logic.boolalg import And
 from sympy.multipledispatch import dispatch
-from sympy.sets.sets import tfn, ProductSet, Interval, FiniteSet
+from sympy.sets.sets import tfn, ProductSet, Interval, FiniteSet, Set
 
 
 @dispatch(Interval, FiniteSet) # type:ignore
@@ -46,3 +47,13 @@ def _eval_is_eq(lhs, rhs): # noqa: F811
 
     eqs = (is_eq(x, y) for x, y in zip(lhs.sets, rhs.sets))
     return tfn[fuzzy_and(map(fuzzy_bool, eqs))]
+
+
+@dispatch(Set, Basic) # type:ignore
+def _eval_is_eq(lhs, rhs): # noqa: F811
+    return False
+
+
+@dispatch(Set, Set) # type:ignore
+def _eval_is_eq(lhs, rhs): # noqa: F811
+    return None
diff --git a/sympy/stats/crv.py b/sympy/stats/crv.py
index f599486dd5..4411c5c758 100644
--- a/sympy/stats/crv.py
+++ b/sympy/stats/crv.py
@@ -332,7 +332,7 @@ def compute_characteristic_function(self, **kwargs):
         """
         x, t = symbols('x, t', real=True, cls=Dummy)
         pdf = self.pdf(x)
-        cf = integrate(exp(I*t*x)*pdf, (x, self.set))
+        cf = integrate(exp(I*t*x)*pdf, (x, -oo, oo))
         return Lambda(t, cf)
 
     def _characteristic_function(self, t):
@@ -354,7 +354,7 @@ def compute_moment_generating_function(self, **kwargs):
         """
         x, t = symbols('x, t', real=True, cls=Dummy)
         pdf = self.pdf(x)
-        mgf = integrate(exp(t * x) * pdf, (x, self.set))
+        mgf = integrate(exp(t * x) * pdf, (x, -oo, oo))
         return Lambda(t, mgf)
 
     def _moment_generating_function(self, t):
diff --git a/sympy/stats/crv_types.py b/sympy/stats/crv_types.py
index 31b7f67b6c..8c5777f01a 100644
--- a/sympy/stats/crv_types.py
+++ b/sympy/stats/crv_types.py
@@ -126,11 +126,10 @@
 def _(x):
     return any([is_random(i) for i in x])
 
-def rv(symbol, cls, args, **kwargs):
+def rv(symbol, cls, args):
     args = list(map(sympify, args))
     dist = cls(*args)
-    if kwargs.pop('check', True):
-        dist.check(*args)
+    dist.check(*args)
     pspace = SingleContinuousPSpace(symbol, dist)
     if any(is_random(arg) for arg in args):
         from sympy.stats.compound_rv import CompoundPSpace, CompoundDistribution
@@ -152,10 +151,10 @@ def set(self):
     def check(pdf, set):
         x = Dummy('x')
         val = integrate(pdf(x), (x, set))
-        _value_check(Eq(val, 1) != S.false, "The pdf on the given set is incorrect.")
+        _value_check(val == S.One, "The pdf on the given set is incorrect.")
 
 
-def ContinuousRV(symbol, density, set=Interval(-oo, oo), **kwargs):
+def ContinuousRV(symbol, density, set=Interval(-oo, oo)):
     """
     Create a Continuous Random Variable given the following:
 
@@ -168,11 +167,6 @@ def ContinuousRV(symbol, density, set=Interval(-oo, oo), **kwargs):
         Represents probability density function.
     set : set/Interval
         Represents the region where the pdf is valid, by default is real line.
-    check : bool
-        If True, it will check whether the given density
-        integrates to 1 over the given set. If False, it
-        will not perform this check. Default is False.
-
 
     Returns
     =======
@@ -201,9 +195,7 @@ def ContinuousRV(symbol, density, set=Interval(-oo, oo), **kwargs):
     """
     pdf = Piecewise((density, set.as_relational(symbol)), (0, True))
     pdf = Lambda(symbol, pdf)
-    # have a default of False while `rv` should have a default of True
-    kwargs['check'] = kwargs.pop('check', False)
-    return rv(symbol.name, ContinuousDistributionHandmade, (pdf, set), **kwargs)
+    return rv(symbol.name, ContinuousDistributionHandmade, (pdf, set))
 
 ########################################
 # Continuous Probability Distributions #
diff --git a/sympy/stats/drv_types.py b/sympy/stats/drv_types.py
index d085df3140..8ad6c25976 100644
--- a/sympy/stats/drv_types.py
+++ b/sympy/stats/drv_types.py
@@ -16,7 +16,7 @@
 
 from sympy import (Basic, factorial, exp, S, sympify, I, zeta, polylog, log, beta,
                    hyper, binomial, Piecewise, floor, besseli, sqrt, Sum, Dummy,
-                   Lambda, Eq)
+                   Lambda)
 from sympy.stats.drv import SingleDiscreteDistribution, SingleDiscretePSpace
 from sympy.stats.rv import _value_check, is_random
 
@@ -32,11 +32,10 @@
 ]
 
 
-def rv(symbol, cls, *args, **kwargs):
+def rv(symbol, cls, *args):
     args = list(map(sympify, args))
     dist = cls(*args)
-    if kwargs.pop('check', True):
-        dist.check(*args)
+    dist.check(*args)
     pspace = SingleDiscretePSpace(symbol, dist)
     if any(is_random(arg) for arg in args):
         from sympy.stats.compound_rv import CompoundPSpace, CompoundDistribution
@@ -58,9 +57,9 @@ def set(self):
     def check(pdf, set):
         x = Dummy('x')
         val = Sum(pdf(x), (x, set._inf, set._sup)).doit()
-        _value_check(Eq(val, 1) != S.false, "The pdf is incorrect on the given set.")
+        _value_check(val == S.One, "The pdf is incorrect on the given set.")
 
-def DiscreteRV(symbol, density, set=S.Integers, **kwargs):
+def DiscreteRV(symbol, density, set=S.Integers):
     """
     Create a Discrete Random Variable given the following:
 
@@ -73,10 +72,6 @@ def DiscreteRV(symbol, density, set=S.Integers, **kwargs):
         Represents probability density function.
     set : set
         Represents the region where the pdf is valid, by default is real line.
-    check : bool
-        If True, it will check whether the given density
-        integrates to 1 over the given set. If False, it
-        will not perform this check. Default is False.
 
     Examples
     ========
@@ -101,9 +96,7 @@ def DiscreteRV(symbol, density, set=S.Integers, **kwargs):
     set = sympify(set)
     pdf = Piecewise((density, set.as_relational(symbol)), (0, True))
     pdf = Lambda(symbol, pdf)
-    # have a default of False while `rv` should have a default of True
-    kwargs['check'] = kwargs.pop('check', False)
-    return rv(symbol.name, DiscreteDistributionHandmade, pdf, set, **kwargs)
+    return rv(symbol.name, DiscreteDistributionHandmade, pdf, set)
 
 
 #-------------------------------------------------------------------------------
diff --git a/sympy/stats/frv_types.py b/sympy/stats/frv_types.py
index c3425e2edc..229fb59d78 100644
--- a/sympy/stats/frv_types.py
+++ b/sympy/stats/frv_types.py
@@ -35,11 +35,10 @@
 'Rademacher'
 ]
 
-def rv(name, cls, *args, **kwargs):
+def rv(name, cls, *args):
     args = list(map(sympify, args))
     dist = cls(*args)
-    if kwargs.pop('check', True):
-        dist.check(*args)
+    dist.check(*args)
     pspace = SingleFinitePSpace(name, dist)
     if any(is_random(arg) for arg in args):
         from sympy.stats.compound_rv import CompoundPSpace, CompoundDistribution
@@ -66,24 +65,17 @@ def check(density):
         for p in density.values():
             _value_check((p >= 0, p <= 1),
                         "Probability at a point must be between 0 and 1.")
-        val = sum(density.values())
-        _value_check(Eq(val, 1) != S.false, "Total Probability must be 1.")
+        _value_check(Eq(sum(density.values()), 1), "Total Probability must be 1.")
 
-def FiniteRV(name, density, **kwargs):
+def FiniteRV(name, density):
     r"""
     Create a Finite Random Variable given a dict representing the density.
 
     Parameters
     ==========
 
-    name : Symbol
-        Represents name of the random variable.
     density: A dict
         Dictionary conatining the pdf of finite distribution
-    check : bool
-        If True, it will check whether the given density
-        integrates to 1 over the given set. If False, it
-        will not perform this check. Default is False.
 
     Examples
     ========
@@ -104,9 +96,7 @@ def FiniteRV(name, density, **kwargs):
     RandomSymbol
 
     """
-    # have a default of False while `rv` should have a default of True
-    kwargs['check'] = kwargs.pop('check', False)
-    return rv(name, FiniteDistributionHandmade, density, **kwargs)
+    return rv(name, FiniteDistributionHandmade, density)
 
 class DiscreteUniformDistribution(SingleFiniteDistribution):
 
diff --git a/sympy/stats/stochastic_process_types.py b/sympy/stats/stochastic_process_types.py
index a0da210c2a..7bc012c532 100644
--- a/sympy/stats/stochastic_process_types.py
+++ b/sympy/stats/stochastic_process_types.py
@@ -1,10 +1,10 @@
 import random
 
 import itertools
-from typing import Sequence as tSequence, Union as tUnion, List as tList, Tuple as tTuple
+from typing import Sequence as tSequence, Union as tUnion
 
 from sympy import (Matrix, MatrixSymbol, S, Indexed, Basic, Tuple, Range,
-                   Set, And, Eq, FiniteSet, ImmutableMatrix, Integer, igcd,
+                   Set, And, Eq, FiniteSet, ImmutableMatrix, Integer,
                    Lambda, Mul, Dummy, IndexedBase, Add, Interval, oo,
                    linsolve, eye, Or, Not, Intersection, factorial, Contains,
                    Union, Expr, Function, exp, cacheit, sqrt, pi, gamma,
@@ -13,7 +13,6 @@
 from sympy.core.relational import Relational
 from sympy.logic.boolalg import Boolean
 from sympy.utilities.exceptions import SymPyDeprecationWarning
-from sympy.utilities.iterables import strongly_connected_components
 from sympy.stats.joint_rv import JointDistribution
 from sympy.stats.joint_rv_types import JointDistributionHandmade
 from sympy.stats.rv import (RandomIndexedSymbol, random_symbols, RandomSymbol,
@@ -836,134 +835,6 @@ def _transient2absorbing(self):
 
         return ImmutableMatrix(t2a)
 
-    def communication_classes(self) -> tList[tTuple[tList[Basic], Boolean, Integer]]:
-        """
-        Returns the list of communication classes that partition
-        the states of the markov chain.
-
-        A communication class is defined to be a set of states
-        such that every state in that set is reachable from
-        every other state in that set. Due to its properties
-        this forms a class in the mathematical sense.
-        Communication classes are also known as recurrence
-        classes.
-
-        Returns
-        =======
-
-        classes : List of Tuple of List, Boolean, Intger
-            The ``classes`` are a list of tuples. Each
-            tuple represents a single communication class
-            with its properties. The first element in the
-            tuple is the list of states in the class, the
-            second element is whether the class is recurrent
-            and the third element is the period of the
-            communication class.
-
-        Examples
-        ========
-
-        >>> from sympy.stats import DiscreteMarkovChain
-        >>> from sympy import Matrix
-        >>> T = Matrix([[0, 1, 0],
-        ...             [1, 0, 0],
-        ...             [1, 0, 0]])
-        >>> X = DiscreteMarkovChain('X', [1, 2, 3], T)
-        >>> classes = X.communication_classes()
-        >>> for states, is_recurrent, period in classes:
-        ...     states, is_recurrent, period
-        ([1, 2], True, 2)
-        ([3], False, 1)
-
-        From this we can see that states ``1`` and ``2``
-        communicate, are recurrent and have a period
-        of 2. We can also see state ``3`` is transient
-        with a period of 1.
-
-        Notes
-        =====
-
-        The algorithm used is of order ``O(n**2)`` where
-        ``n`` is the number of states in the markov chain.
-        It uses Tarjan's algorithm to find the classes
-        themselves and then it uses a breadth-first search
-        algorithm to find each class's periodicity.
-        Most of the algorithm's components approach ``O(n)``
-        as the matrix becomes more and more sparse.
-
-        References
-        ==========
-
-        .. [1] http://www.columbia.edu/~ww2040/4701Sum07/4701-06-Notes-MCII.pdf
-        .. [2] http://cecas.clemson.edu/~shierd/Shier/markov.pdf
-        .. [3] https://ujcontent.uj.ac.za/vital/access/services/Download/uj:7506/CONTENT1
-        .. [4] https://www.mathworks.com/help/econ/dtmc.classify.html
-        """
-        n = self.number_of_states
-        T = self.transition_probabilities
-
-        # begin Tarjan's algorithm
-        V = Range(n)
-        # don't use state names. Rather use state
-        # indexes since we use them for matrix
-        # indexing here and later onward
-        E = [(i, j) for i in V for j in V if T[i, j] != 0]
-        classes = strongly_connected_components((V, E))
-        # end Tarjan's algorithm
-
-        recurrence = []
-        periods = []
-        for class_ in classes:
-            # begin recurrent check (similar to self._check_trans_probs())
-            submatrix = T[class_, class_]  # get the submatrix with those states
-            is_recurrent = S.true
-            rows = submatrix.tolist()
-            for row in rows:
-                if (sum(row) - 1) != 0:
-                    is_recurrent = S.false
-                    break
-            recurrence.append(is_recurrent)
-            # end recurrent check
-
-            # begin breadth-first search
-            non_tree_edge_values = set()
-            visited = {class_[0]}
-            newly_visited = {class_[0]}
-            level = {class_[0]: 0}
-            current_level = 0
-            done = False  # imitate a do-while loop
-            while not done:  # runs at most len(class_) times
-                done = len(visited) == len(class_)
-                current_level += 1
-
-                # this loop and the while loop above run a combined len(class_) number of times.
-                # so this triple nested loop runs through each of the n states once.
-                for i in newly_visited:
-
-                    # the loop below runs len(class_) number of times
-                    # complexity is around about O(n * avg(len(class_)))
-                    newly_visited = {j for j in class_ if T[i, j] != 0}
-
-                    new_tree_edges = newly_visited.difference(visited)
-                    for j in new_tree_edges:
-                        level[j] = current_level
-
-                    new_non_tree_edges = newly_visited.intersection(visited)
-                    new_non_tree_edge_values = {level[i]-level[j]+1 for j in new_non_tree_edges}
-
-                    non_tree_edge_values = non_tree_edge_values.union(new_non_tree_edge_values)
-                    visited = visited.union(new_tree_edges)
-
-            # igcd needs at least 2 arguments
-            g = igcd(len(class_), len(class_), *{val_e for val_e in non_tree_edge_values if val_e > 0})
-            periods.append(g)
-            # end breadth-first search
-
-        # convert back to the user's state names
-        classes = [[self._state_index[i] for i in class_] for class_ in classes]
-
-        return sympify(list(zip(classes, recurrence, periods)))
-
     def fundamental_matrix(self):
         Q = self._transient2transient()
         if Q == None:


Test patch:
diff --git a/sympy/parsing/tests/test_latex.py b/sympy/parsing/tests/test_latex.py
index 2eeddb0dc2..2a1a55450b 100644
--- a/sympy/parsing/tests/test_latex.py
+++ b/sympy/parsing/tests/test_latex.py
@@ -2,14 +2,12 @@
 from sympy.external import import_module
 
 from sympy import (
-    Symbol, Mul, Add, Abs, sin, asin, cos, Pow,
+    Symbol, Mul, Add, Eq, Abs, sin, asin, cos, Pow,
     csc, sec, Limit, oo, Derivative, Integral, factorial,
     sqrt, root, StrictLessThan, LessThan, StrictGreaterThan,
     GreaterThan, Sum, Product, E, log, tan, Function, binomial, exp,
-    floor, ceiling, Unequality
+    Unequality,
 )
-from sympy.core.relational import Eq, Ne, Lt, Le, Gt, Ge
-from sympy.physics.quantum.state import Bra, Ket
 from sympy.abc import x, y, z, a, b, c, t, k, n
 antlr4 = import_module("antlr4")
 
@@ -91,18 +89,6 @@ def test_import():
     ("0+1", Add(0, 1, evaluate=False)),
     ("1*2", Mul(1, 2, evaluate=False)),
     ("0*1", Mul(0, 1, evaluate=False)),
-    ("x = y", Eq(x, y)),
-    ("x \\neq y", Ne(x, y)),
-    ("x < y", Lt(x, y)),
-    ("x > y", Gt(x, y)),
-    ("x \\leq y", Le(x, y)),
-    ("x \\geq y", Ge(x, y)),
-    ("x \\le y", Le(x, y)),
-    ("x \\ge y", Ge(x, y)),
-    ("\\lfloor x \\rfloor", floor(x)),
-    ("\\lceil x \\rceil", ceiling(x)),
-    ("\\langle x |", Bra('x')),
-    ("| x \\rangle", Ket('x')),
     ("\\sin \\theta", sin(theta)),
     ("\\sin(\\theta)", sin(theta)),
     ("\\sin^{-1} a", asin(a)),
diff --git a/sympy/sets/tests/test_sets.py b/sympy/sets/tests/test_sets.py
index e92cb1f23f..f20860a462 100644
--- a/sympy/sets/tests/test_sets.py
+++ b/sympy/sets/tests/test_sets.py
@@ -1581,3 +1581,18 @@ def test_DisjointUnion_len():
     assert len(DisjointUnion(FiniteSet(3, 5, 7, 9), FiniteSet(x, y, z))) == 7
     assert len(DisjointUnion(S.EmptySet, S.EmptySet, FiniteSet(x, y, z), S.EmptySet)) == 3
     raises(ValueError, lambda: len(DisjointUnion(Interval(0, 1), S.EmptySet)))
+
+def test_issue_20089():
+    B = FiniteSet(FiniteSet(1, 2), FiniteSet(1))
+    assert not 1 in B
+    assert not 1.0 in B
+    assert not Eq(1, FiniteSet(1, 2))
+    assert FiniteSet(1) in B
+    A = FiniteSet(1, 2)
+    assert A in B
+    assert B.issubset(B)
+    assert not A.issubset(B)
+    assert 1 in A
+    C = FiniteSet(FiniteSet(1, 2), FiniteSet(1), 1, 2)
+    assert A.issubset(C)
+    assert B.issubset(C)
diff --git a/sympy/stats/tests/test_continuous_rv.py b/sympy/stats/tests/test_continuous_rv.py
index 14a71a9be8..e671bed912 100644
--- a/sympy/stats/tests/test_continuous_rv.py
+++ b/sympy/stats/tests/test_continuous_rv.py
@@ -337,7 +337,7 @@ def test_sample_continuous():
 def test_ContinuousRV():
     pdf = sqrt(2)*exp(-x**2/2)/(2*sqrt(pi))  # Normal distribution
     # X and Y should be equivalent
-    X = ContinuousRV(x, pdf, check=True)
+    X = ContinuousRV(x, pdf)
     Y = Normal('y', 0, 1)
 
     assert variance(X) == variance(Y)
@@ -346,16 +346,7 @@ def test_ContinuousRV():
     assert Z.pspace.domain.set == Interval(0, oo)
     assert E(Z) == 1
     assert P(Z > 5) == exp(-5)
-    raises(ValueError, lambda: ContinuousRV(z, exp(-z), set=Interval(0, 10), check=True))
-
-    # the correct pdf for Gamma(k, theta) but the integral in `check`
-    # integrates to something equivalent to 1 and not to 1 exactly
-    _x, k, theta = symbols("x k theta", positive=True)
-    pdf = 1/(gamma(k)*theta**k)*_x**(k-1)*exp(-_x/theta)
-    X = ContinuousRV(_x, pdf, set=Interval(0, oo))
-    Y = Gamma('y', k, theta)
-    assert (E(X) - E(Y)).simplify() == 0
-    assert (variance(X) - variance(Y)).simplify() == 0
+    raises(ValueError, lambda: ContinuousRV(z, exp(-z), set=Interval(0, 10)))
 
 
 def test_arcsin():
diff --git a/sympy/stats/tests/test_discrete_rv.py b/sympy/stats/tests/test_discrete_rv.py
index 4321587b42..30388483e6 100644
--- a/sympy/stats/tests/test_discrete_rv.py
+++ b/sympy/stats/tests/test_discrete_rv.py
@@ -178,17 +178,11 @@ def test_DiscreteRV():
     p = S(1)/2
     x = Symbol('x', integer=True, positive=True)
     pdf = p*(1 - p)**(x - 1) # pdf of Geometric Distribution
-    D = DiscreteRV(x, pdf, set=S.Naturals, check=True)
+    D = DiscreteRV(x, pdf, set=S.Naturals)
     assert E(D) == E(Geometric('G', S(1)/2)) == 2
     assert P(D > 3) == S(1)/8
     assert D.pspace.domain.set == S.Naturals
-    raises(ValueError, lambda: DiscreteRV(x, x, FiniteSet(*range(4)), check=True))
-
-    # purposeful invalid pmf but it should not raise since check=False
-    # see test_drv_types.test_ContinuousRV for explanation
-    X = DiscreteRV(x, 1/x, S.Naturals)
-    assert P(X < 2) == 1
-    assert E(X) == oo
+    raises(ValueError, lambda: DiscreteRV(x, x, FiniteSet(*range(4))))
 
 def test_precomputed_characteristic_functions():
     import mpmath
diff --git a/sympy/stats/tests/test_finite_rv.py b/sympy/stats/tests/test_finite_rv.py
index 699476a7bb..e095aaba86 100644
--- a/sympy/stats/tests/test_finite_rv.py
+++ b/sympy/stats/tests/test_finite_rv.py
@@ -383,7 +383,7 @@ def test_rademacher():
 
 
 def test_FiniteRV():
-    F = FiniteRV('F', {1: S.Half, 2: Rational(1, 4), 3: Rational(1, 4)}, check=True)
+    F = FiniteRV('F', {1: S.Half, 2: Rational(1, 4), 3: Rational(1, 4)})
     p = Symbol("p", positive=True)
 
     assert dict(density(F).items()) == {S.One: S.Half, S(2): Rational(1, 4), S(3): Rational(1, 4)}
@@ -395,16 +395,10 @@ def test_FiniteRV():
         *[Eq(F.symbol, i) for i in [1, 2, 3]])
 
     assert F.pspace.domain.set == FiniteSet(1, 2, 3)
-    raises(ValueError, lambda: FiniteRV('F', {1: S.Half, 2: S.Half, 3: S.Half}, check=True))
-    raises(ValueError, lambda: FiniteRV('F', {1: S.Half, 2: Rational(-1, 2), 3: S.One}, check=True))
+    raises(ValueError, lambda: FiniteRV('F', {1: S.Half, 2: S.Half, 3: S.Half}))
+    raises(ValueError, lambda: FiniteRV('F', {1: S.Half, 2: Rational(-1, 2), 3: S.One}))
     raises(ValueError, lambda: FiniteRV('F', {1: S.One, 2: Rational(3, 2), 3: S.Zero,\
-        4: Rational(-1, 2), 5: Rational(-3, 4), 6: Rational(-1, 4)}, check=True))
-
-    # purposeful invalid pmf but it should not raise since check=False
-    # see test_drv_types.test_ContinuousRV for explanation
-    X = FiniteRV('X', {1: 1, 2: 2})
-    assert E(X) == 5
-    assert P(X <= 2) + P(X > 2) != 1
+        4: Rational(-1, 2), 5: Rational(-3, 4), 6: Rational(-1, 4)}))
 
 def test_density_call():
     from sympy.abc import p
diff --git a/sympy/stats/tests/test_stochastic_process.py b/sympy/stats/tests/test_stochastic_process.py
index 3abd19a46e..74fd6172b2 100644
--- a/sympy/stats/tests/test_stochastic_process.py
+++ b/sympy/stats/tests/test_stochastic_process.py
@@ -138,59 +138,6 @@ def test_DiscreteMarkovChain():
     assert Y6.fundamental_matrix() == ImmutableMatrix([[Rational(3, 2), S.One, S.Half], [S.One, S(2), S.One], [S.Half, S.One, Rational(3, 2)]])
     assert Y6.absorbing_probabilities() == ImmutableMatrix([[Rational(3, 4), Rational(1, 4)], [S.Half, S.Half], [Rational(1, 4), Rational(3, 4)]])
 
-    # test communication_class
-    # see https://drive.google.com/drive/folders/1HbxLlwwn2b3U8Lj7eb_ASIUb5vYaNIjg?usp=sharing
-    # tutorial 2.pdf
-    TO7 = Matrix([[0, 5, 5, 0, 0],
-                  [0, 0, 0, 10, 0],
-                  [5, 0, 5, 0, 0],
-                  [0, 10, 0, 0, 0],
-                  [0, 3, 0, 3, 4]])/10
-    Y7 = DiscreteMarkovChain('Y', trans_probs=TO7)
-    tuples = Y7.communication_classes()
-    classes, recurrence, periods = list(zip(*tuples))
-    assert classes == ([1, 3], [0, 2], [4])
-    assert recurrence == (True, False, False)
-    assert periods == (2, 1, 1)
-
-    TO8 = Matrix([[0, 0, 0, 10, 0, 0],
-                  [5, 0, 5, 0, 0, 0],
-                  [0, 4, 0, 0, 0, 6],
-                  [10, 0, 0, 0, 0, 0],
-                  [0, 10, 0, 0, 0, 0],
-                  [0, 0, 0, 5, 5, 0]])/10
-    Y8 = DiscreteMarkovChain('Y', trans_probs=TO8)
-    tuples = Y8.communication_classes()
-    classes, recurrence, periods = list(zip(*tuples))
-    assert classes == ([0, 3], [1, 2, 5, 4])
-    assert recurrence == (True, False)
-    assert periods == (2, 2)
-
-    TO9 = Matrix([[2, 0, 0, 3, 0, 0, 3, 2, 0, 0],
-                  [0, 10, 0, 0, 0, 0, 0, 0, 0, 0],
-                  [0, 2, 2, 0, 0, 0, 0, 0, 3, 3],
-                  [0, 0, 0, 3, 0, 0, 6, 1, 0, 0],
-                  [0, 0, 0, 0, 5, 5, 0, 0, 0, 0],
-                  [0, 0, 0, 0, 0, 10, 0, 0, 0, 0],
-                  [4, 0, 0, 5, 0, 0, 1, 0, 0, 0],
-                  [2, 0, 0, 4, 0, 0, 2, 2, 0, 0],
-                  [3, 0, 1, 0, 0, 0, 0, 0, 4, 2],
-                  [0, 0, 4, 0, 0, 0, 0, 0, 3, 3]])/10
-    Y9 = DiscreteMarkovChain('Y', trans_probs=TO9)
-    tuples = Y9.communication_classes()
-    classes, recurrence, periods = list(zip(*tuples))
-    assert classes == ([0, 3, 6, 7], [1], [2, 8, 9], [5], [4])
-    assert recurrence == (True, True, False, True, False)
-    assert periods == (1, 1, 1, 1, 1)
-
-    # test custom state space
-    Y10 = DiscreteMarkovChain('Y', [1, 2, 3], TO2)
-    tuples = Y10.communication_classes()
-    classes, recurrence, periods = list(zip(*tuples))
-    assert classes == ([1], [2, 3])
-    assert recurrence == (True, False)
-    assert periods == (1, 1)
-
     # testing miscellaneous queries
     T = Matrix([[S.Half, Rational(1, 4), Rational(1, 4)],
                 [Rational(1, 3), 0, Rational(2, 3)],