From f24652558d4d4b51f4e981f3b2529155fa9d6244 Mon Sep 17 00:00:00 2001
From: Logan Weber <weberlo@cs.washington.edu>
Date: Thu, 22 Aug 2019 23:04:31 -0700
Subject: [PATCH 01/29] Getting closer to having ADT defs

---
 include/tvm/relay/module.h                    |    7 +
 python/tvm/relay/_parser.py                   |   73 +-
 python/tvm/relay/grammar/Relay.g4             |   48 +-
 .../tvm/relay/grammar/RelayBaseListener.java  |  614 ++++
 python/tvm/relay/grammar/RelayLexer.java      |  249 ++
 python/tvm/relay/grammar/RelayListener.java   |  551 ++++
 python/tvm/relay/grammar/RelayParser.java     | 2786 +++++++++++++++++
 python/tvm/relay/grammar/py3/RelayLexer.py    |  352 ++-
 python/tvm/relay/grammar/py3/RelayParser.py   | 1980 +++++++-----
 python/tvm/relay/grammar/py3/RelayVisitor.py  |   54 +-
 python/tvm/relay/ty.py                        |    1 +
 src/relay/ir/alpha_equal.cc                   |   38 +-
 src/relay/ir/module.cc                        |    5 +
 src/relay/ir/pretty_printer.cc                |   56 +-
 tests/python/relay/test_ir_parser.py          |  126 +-
 tests/python/relay/test_ir_text_printer.py    |   31 +-
 16 files changed, 5987 insertions(+), 984 deletions(-)
 create mode 100644 python/tvm/relay/grammar/RelayBaseListener.java
 create mode 100644 python/tvm/relay/grammar/RelayLexer.java
 create mode 100644 python/tvm/relay/grammar/RelayListener.java
 create mode 100644 python/tvm/relay/grammar/RelayParser.java

diff --git a/include/tvm/relay/module.h b/include/tvm/relay/module.h
index 0b582514f5c3..136ec700aee3 100644
--- a/include/tvm/relay/module.h
+++ b/include/tvm/relay/module.h
@@ -164,6 +164,13 @@ class ModuleNode : public RelayNode {
    */
   TVM_DLL TypeData LookupDef(const std::string& var) const;
 
+  /*!
+   * \brief TODO
+   * \param TODO
+   * \return TODO
+   */
+  TVM_DLL bool HasDef(const std::string& var) const;
+
   /*!
    * \brief Look up a constructor by its tag.
    * \param tag The tag for the constructor.
diff --git a/python/tvm/relay/_parser.py b/python/tvm/relay/_parser.py
index f7024fe456a0..682096967753 100644
--- a/python/tvm/relay/_parser.py
+++ b/python/tvm/relay/_parser.py
@@ -28,6 +28,7 @@
 
 from . import module
 from .base import Span, SourceName
+from . import adt
 from . import expr
 from . import ty
 from . import op
@@ -191,10 +192,11 @@ def __init__(self, source_name):
         self.module = module.Module({})   # type: module.Module
 
         # Adding an empty scope allows naked lets without pain.
-        self.var_scopes = deque([deque()])          # type: Scopes[expr.Var]
-        self.global_var_scope = deque()             # type: Scope[expr.GlobalVar]
-        self.type_param_scopes = deque([deque()])   # type: Scopes[ty.TypeVar]
-        self.graph_expr = []                        # type: List[expr.Expr]
+        self.var_scopes = deque([deque()])                # type: Scopes[expr.Var]
+        self.global_var_scope = deque()                   # type: Scope[expr.GlobalVar]
+        self.type_param_scopes = deque([deque()])         # type: Scopes[ty.TypeVar]
+        self.global_type_param_scope = deque()            # type: Scope[expr.GlobalVar]
+        self.graph_expr = []                              # type: List[expr.Expr]
 
         super(ParseTreeToRelayIR, self).__init__()
 
@@ -202,19 +204,16 @@ def __init__(self, source_name):
     def enter_var_scope(self):
         # type: () -> None
         """Enter a new Var scope so it can be popped off later."""
-
         self.var_scopes.appendleft(deque())
 
     def exit_var_scope(self):
         # type: () -> Scope[expr.Var]
         """Pop off the current Var scope and return it."""
-
         return self.var_scopes.popleft()
 
     def mk_var(self, name, type_):
         # type: (str, ty.Type) -> expr.Var
         """Create a new Var and add it to the Var scope."""
-
         var = expr.Var(name, type_)
         self.var_scopes[0].appendleft((name, var))
         return var
@@ -222,7 +221,6 @@ def mk_var(self, name, type_):
     def mk_global_var(self, name):
         # type: (str) -> expr.GlobalVar
         """Create a new GlobalVar and add it to the GlobalVar scope."""
-
         var = expr.GlobalVar(name)
         self.global_var_scope.append((name, var))
         return var
@@ -230,36 +228,39 @@ def mk_global_var(self, name):
     def enter_type_param_scope(self):
         # type: () -> None
         """Enter a new TypeVar scope so it can be popped off later."""
-
         self.type_param_scopes.appendleft(deque())
 
     def exit_type_param_scope(self):
         # type: () -> Scope[ty.TypeVar]
         """Pop off the current TypeVar scope and return it."""
-
         return self.type_param_scopes.popleft()
 
     def mk_typ(self, name, kind):
         # (str, ty.Kind) -> ty.TypeVar
         """Create a new TypeVar and add it to the TypeVar scope."""
-
         typ = ty.TypeVar(name, kind)
         self.type_param_scopes[0].appendleft((name, typ))
         return typ
 
+    def mk_global_typ(self, name, kind):
+        # (str, ty.Kind) -> ty.GlobalTypeVar
+        """Create a new TypeVar and add it to the TypeVar scope."""
+        typ = ty.GlobalTypeVar(name, kind)
+        self.global_var_scope.append((name, typ))
+        return typ
+
     def visitProjection(self, ctx):
         return expr.TupleGetItem(self.visit(ctx.expr()), self.visit(ctx.NAT()))
 
     def visitTerminal(self, node):
         # type: (TerminalNode) -> Union[expr.Expr, int, float]
         """Visit lexer tokens that aren't ignored or visited by other functions."""
-
         node_type = node.getSymbol().type
         node_text = node.getText()
         name = node_text[1:]
 
         # variables
-        if node_type == RelayLexer.GLOBAL_VAR:
+        if node_type == RelayLexer.globalVar:
             return lookup(deque([self.global_var_scope]), node_text[1:])
         if node_type == RelayLexer.LOCAL_VAR:
             # Remove the leading '%' and lookup the name.
@@ -299,7 +300,6 @@ def visit_list(self, ctx_list):
     def getType_(self, ctx):
         # type: (Optional[RelayParser.Type_Context]) -> Optional[ty.Type]
         """Return a (possibly None) Relay type."""
-
         if ctx is None:
             return None
 
@@ -444,7 +444,6 @@ def visitMeta(self, ctx):
     def mk_func(self, ctx):
         # type: (Union[RelayParser.FuncContext, RelayParser.DefnContext]) -> expr.Function
         """Construct a function from either a Func or Defn."""
-
         # Enter var scope early to put params in scope.
         self.enter_var_scope()
         # Capture type params in params.
@@ -482,15 +481,45 @@ def visitFunc(self, ctx):
 
     # TODO: how to set spans for definitions?
     # @spanify
-    def visitDefn(self, ctx):
+    def visitFuncDefn(self, ctx):
         # type: (RelayParser.DefnContext) -> None
-        ident = ctx.ident().GLOBAL_VAR()
-        if ident is None:
-            raise ParseError("Only global ids may be used in `def`s.")
-        ident_name = ident.getText()[1:]
+        ident_name = ctx.globalVar().getText()[1:]
         ident = self.mk_global_var(ident_name)
         self.module[ident] = self.mk_func(ctx)
 
+    def visitAdtDefn(self, ctx):
+        glob_typ_var = ctx.globalTypeVar()
+        defn_name = glob_typ_var.children[0].getText()
+        typ_params = []
+
+        if len(glob_typ_var.children) > 1:
+            defn_name = glob_typ_var.children[0].getText()
+            typ_params = list(
+                map(
+                    ty.TypeVar,
+                    filter(
+                        lambda s: not s.startswith(','),
+                        map(lambda x: x.getText(), glob_typ_var.children[2:-1]))))
+        defn = self.mk_global_typ(defn_name, ty.Kind.AdtHandle)
+
+        constructors = []
+        for constructor in ctx.adtVariant():
+            inputs = []
+            for inp in constructor.type_():
+                print(inp)
+                inputs.append(self.visit(inp))
+
+            # inputs = [self.visit(inp) for inp in constructor.type_()]
+            constructors.append(adt.Constructor(constructor.variantName().getText(), inputs, defn))
+
+        self.module[defn] = adt.TypeData(defn, typ_params, constructors)
+
+    def visitGlobalTypeVarType(self, ctx):
+        print('SHIT WHETHER IT\'S A LOCAL OR GLOBAL TYPE VAR IS AMBIGUOUS, SO WE\'LL NEED TO DO SOME LOOKUPS')
+        print('cloobs')
+        import pdb; pdb.set_trace()
+        return None
+
     def visitCallNoAttr(self, ctx):
         return (self.visit_list(ctx.exprList().expr()), None)
 
@@ -553,9 +582,7 @@ def visitIncompleteType(self, ctx):
 
     def visitTypeIdent(self, ctx):
         # type: (RelayParser.TypeIdentContext) -> Union[ty.TensorType, str]
-        '''
-        Handle type identifier.
-        '''
+        """Handle type identifier."""
         type_ident = ctx.CNAME().getText()
 
         # Look through all type prefixes for a match
diff --git a/python/tvm/relay/grammar/Relay.g4 b/python/tvm/relay/grammar/Relay.g4
index 8830a4122e08..cd0943d7dbd9 100644
--- a/python/tvm/relay/grammar/Relay.g4
+++ b/python/tvm/relay/grammar/Relay.g4
@@ -17,7 +17,11 @@
  * under the License.
  */
 
-// list = *, seq = ?
+// TODO: We need some way of indicating to users that you need to enable
+// USE_ANTLR in config.cmake.
+/*
+ * NOTE: All upper-case rules are *lexer* rules and all lower-case rules are *parser* rules.
+ */
 
 grammar Relay;
 
@@ -49,11 +53,7 @@ BOOL_LIT
   | 'False'
   ;
 
-CNAME: ('_'|LETTER) ('_'|LETTER|DIGIT)* ('.' CNAME)*;
-opIdent: CNAME ;
-GLOBAL_VAR: '@' CNAME ;
-LOCAL_VAR: '%' CNAME;
-GRAPH_VAR: '%' NAT;
+CNAME: ('_'|LETTER) ('_'|LETTER|DIGIT)* ('.' CNAME)* ;
 
 DATATYPE : 'int64';
 // non-negative floats
@@ -72,9 +72,16 @@ METADATA: 'METADATA:' .*;
 // Parsing
 
 // A Relay program is a list of global definitions or an expression.
+// prog: SEMVER (defn+ | expr) METADATA? EOF ;
 prog: SEMVER (defn* | expr) METADATA? EOF ;
 
-// option: 'set' ident BOOL_LIT ;
+opIdent: CNAME ;
+globalVar: '@' CNAME ;
+localVar: '%' CNAME ;
+// TODO: For some reason, spaces aren't allowed between type params?
+globalTypeVar: CNAME ('[' typeVar (', ' typeVar)* ']')? ;
+typeVar: CNAME ;
+graphVar: '%' NAT ;
 
 exprList: (expr (',' expr)*)?;
 callList
@@ -106,7 +113,7 @@ expr
   | 'let' var '=' expr ';' expr               # let
   // sugar for let %_ = expr; expr
   | expr ';;' expr                            # let
-  | GRAPH_VAR '=' expr ';' expr               # graph
+  | graphVar '=' expr ';' expr                # graph
   | ident                                     # identExpr
   | scalar                                    # scalarExpr
   | meta                                      # metaExpr
@@ -114,7 +121,13 @@ expr
   ;
 
 func: 'fn'        typeParamList? '(' argList ')' ('->' type_)? body ;
-defn: 'def' ident typeParamList? '(' argList ')' ('->' type_)? body ;
+defn
+  : 'def' globalVar typeParamList? '(' argList ')' ('->' type_)? body  # funcDefn
+  | 'type' globalTypeVar '=' adtVariant+                               # adtDefn
+  ;
+
+adtVariant: '|' variantName ('(' type_ (', ' type_)* ')')? ;
+variantName: CNAME ;
 
 argList
   : varList              # argNoAttr
@@ -122,7 +135,7 @@ argList
   ;
 
 varList: (var (',' var)*)?;
-var: LOCAL_VAR (':' type_)?;
+var: localVar (':' type_)?;
 
 attrSeq: attr (',' attr)*;
 attr: CNAME '=' expr ;
@@ -132,11 +145,14 @@ typeParamList
   | '[' ident (',' ident)* ']'
   ;
 
+
 type_
   : '(' ')'                                                      # tupleType
   | '(' type_ ',' ')'                                            # tupleType
   | '(' type_ (',' type_)+ ')'                                   # tupleType
-  | typeIdent                                                    # typeIdentType
+  // TODO: When we uncomment this we get a grammar construction error
+  // | typeIdent                                                    # typeIdentType
+  | globalTypeVar                                                # globalTypeVarType
   | 'Tensor' '[' shapeList ',' type_ ']'                         # tensorType
   | 'fn' typeParamList? '(' (type_ (',' type_)*)? ')' '->' type_ # funcType
   | '_'                                                          # incompleteType
@@ -157,7 +173,7 @@ shape
   | NAT                                  # intShape
   ;
 
-typeIdent : CNAME;
+typeIdent: CNAME ;
 // int8, int16, int32, int64
 // uint8, uint16, uint32, uint64
 // float16, float32, float64
@@ -173,7 +189,9 @@ scalar
 
 ident
   : opIdent
-  | GLOBAL_VAR
-  | LOCAL_VAR
-  | GRAPH_VAR
+  | globalVar
+  | localVar
+  | globalTypeVar
+  | typeVar
+  | graphVar
   ;
diff --git a/python/tvm/relay/grammar/RelayBaseListener.java b/python/tvm/relay/grammar/RelayBaseListener.java
new file mode 100644
index 000000000000..ad739d57416b
--- /dev/null
+++ b/python/tvm/relay/grammar/RelayBaseListener.java
@@ -0,0 +1,614 @@
+// Generated from Relay.g4 by ANTLR 4.7.2
+
+import org.antlr.v4.runtime.ParserRuleContext;
+import org.antlr.v4.runtime.tree.ErrorNode;
+import org.antlr.v4.runtime.tree.TerminalNode;
+
+/**
+ * This class provides an empty implementation of {@link RelayListener},
+ * which can be extended to create a listener which only needs to handle a subset
+ * of the available methods.
+ */
+public class RelayBaseListener implements RelayListener {
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterOpIdent(RelayParser.OpIdentContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitOpIdent(RelayParser.OpIdentContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterProg(RelayParser.ProgContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitProg(RelayParser.ProgContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterExprList(RelayParser.ExprListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitExprList(RelayParser.ExprListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterCallNoAttr(RelayParser.CallNoAttrContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitCallNoAttr(RelayParser.CallNoAttrContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterCallWithAttr(RelayParser.CallWithAttrContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitCallWithAttr(RelayParser.CallWithAttrContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterFuncExpr(RelayParser.FuncExprContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitFuncExpr(RelayParser.FuncExprContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterMetaExpr(RelayParser.MetaExprContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitMetaExpr(RelayParser.MetaExprContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTensor(RelayParser.TensorContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTensor(RelayParser.TensorContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterGraph(RelayParser.GraphContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitGraph(RelayParser.GraphContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterIdentExpr(RelayParser.IdentExprContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitIdentExpr(RelayParser.IdentExprContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterStringExpr(RelayParser.StringExprContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitStringExpr(RelayParser.StringExprContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterCall(RelayParser.CallContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitCall(RelayParser.CallContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterNeg(RelayParser.NegContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitNeg(RelayParser.NegContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTuple(RelayParser.TupleContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTuple(RelayParser.TupleContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterParen(RelayParser.ParenContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitParen(RelayParser.ParenContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterScalarExpr(RelayParser.ScalarExprContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitScalarExpr(RelayParser.ScalarExprContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterLet(RelayParser.LetContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitLet(RelayParser.LetContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterProjection(RelayParser.ProjectionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitProjection(RelayParser.ProjectionContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterIfElse(RelayParser.IfElseContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitIfElse(RelayParser.IfElseContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterBinOp(RelayParser.BinOpContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitBinOp(RelayParser.BinOpContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterFunc(RelayParser.FuncContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitFunc(RelayParser.FuncContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterDefn(RelayParser.DefnContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitDefn(RelayParser.DefnContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterAdtDefn(RelayParser.AdtDefnContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitAdtDefn(RelayParser.AdtDefnContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterAdtVariant(RelayParser.AdtVariantContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitAdtVariant(RelayParser.AdtVariantContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterArgNoAttr(RelayParser.ArgNoAttrContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitArgNoAttr(RelayParser.ArgNoAttrContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterArgWithAttr(RelayParser.ArgWithAttrContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitArgWithAttr(RelayParser.ArgWithAttrContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterVarList(RelayParser.VarListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitVarList(RelayParser.VarListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterVar(RelayParser.VarContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitVar(RelayParser.VarContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterAttrSeq(RelayParser.AttrSeqContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitAttrSeq(RelayParser.AttrSeqContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterAttr(RelayParser.AttrContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitAttr(RelayParser.AttrContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTypeParamList(RelayParser.TypeParamListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTypeParamList(RelayParser.TypeParamListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTupleType(RelayParser.TupleTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTupleType(RelayParser.TupleTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTypeIdentType(RelayParser.TypeIdentTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTypeIdentType(RelayParser.TypeIdentTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTensorType(RelayParser.TensorTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTensorType(RelayParser.TensorTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterFuncType(RelayParser.FuncTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitFuncType(RelayParser.FuncTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterIncompleteType(RelayParser.IncompleteTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitIncompleteType(RelayParser.IncompleteTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterIntType(RelayParser.IntTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitIntType(RelayParser.IntTypeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterShapeList(RelayParser.ShapeListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitShapeList(RelayParser.ShapeListContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterMeta(RelayParser.MetaContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitMeta(RelayParser.MetaContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterMetaShape(RelayParser.MetaShapeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitMetaShape(RelayParser.MetaShapeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterParensShape(RelayParser.ParensShapeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitParensShape(RelayParser.ParensShapeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterIntShape(RelayParser.IntShapeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitIntShape(RelayParser.IntShapeContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterTypeIdent(RelayParser.TypeIdentContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitTypeIdent(RelayParser.TypeIdentContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterBody(RelayParser.BodyContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitBody(RelayParser.BodyContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterScalarFloat(RelayParser.ScalarFloatContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitScalarFloat(RelayParser.ScalarFloatContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterScalarInt(RelayParser.ScalarIntContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitScalarInt(RelayParser.ScalarIntContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterScalarBool(RelayParser.ScalarBoolContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitScalarBool(RelayParser.ScalarBoolContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterIdent(RelayParser.IdentContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitIdent(RelayParser.IdentContext ctx) { }
+
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void enterEveryRule(ParserRuleContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void exitEveryRule(ParserRuleContext ctx) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void visitTerminal(TerminalNode node) { }
+	/**
+	 * {@inheritDoc}
+	 *
+	 * <p>The default implementation does nothing.</p>
+	 */
+	@Override public void visitErrorNode(ErrorNode node) { }
+}
\ No newline at end of file
diff --git a/python/tvm/relay/grammar/RelayLexer.java b/python/tvm/relay/grammar/RelayLexer.java
new file mode 100644
index 000000000000..8d0584b36a54
--- /dev/null
+++ b/python/tvm/relay/grammar/RelayLexer.java
@@ -0,0 +1,249 @@
+// Generated from Relay.g4 by ANTLR 4.7.2
+import org.antlr.v4.runtime.Lexer;
+import org.antlr.v4.runtime.CharStream;
+import org.antlr.v4.runtime.Token;
+import org.antlr.v4.runtime.TokenStream;
+import org.antlr.v4.runtime.*;
+import org.antlr.v4.runtime.atn.*;
+import org.antlr.v4.runtime.dfa.DFA;
+import org.antlr.v4.runtime.misc.*;
+
+@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
+public class RelayLexer extends Lexer {
+	static { RuntimeMetaData.checkVersion("4.7.2", RuntimeMetaData.VERSION); }
+
+	protected static final DFA[] _decisionToDFA;
+	protected static final PredictionContextCache _sharedContextCache =
+		new PredictionContextCache();
+	public static final int
+		T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9, 
+		T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, T__14=15, T__15=16, T__16=17, 
+		T__17=18, T__18=19, T__19=20, T__20=21, T__21=22, T__22=23, T__23=24, 
+		SEMVER=25, COMMENT=26, WS=27, LINE_COMMENT=28, QUOTED_STRING=29, MUL=30, 
+		DIV=31, ADD=32, SUB=33, LT=34, GT=35, LE=36, GE=37, EQ=38, NE=39, BOOL_LIT=40, 
+		CNAME=41, GLOBAL_VAR=42, LOCAL_VAR=43, GRAPH_VAR=44, DATATYPE=45, FLOAT=46, 
+		NAT=47, METADATA=48;
+	public static String[] channelNames = {
+		"DEFAULT_TOKEN_CHANNEL", "HIDDEN"
+	};
+
+	public static String[] modeNames = {
+		"DEFAULT_MODE"
+	};
+
+	private static String[] makeRuleNames() {
+		return new String[] {
+			"T__0", "T__1", "T__2", "T__3", "T__4", "T__5", "T__6", "T__7", "T__8", 
+			"T__9", "T__10", "T__11", "T__12", "T__13", "T__14", "T__15", "T__16", 
+			"T__17", "T__18", "T__19", "T__20", "T__21", "T__22", "T__23", "SEMVER", 
+			"COMMENT", "WS", "LINE_COMMENT", "ESCAPED_QUOTE", "QUOTED_STRING", "MUL", 
+			"DIV", "ADD", "SUB", "LT", "GT", "LE", "GE", "EQ", "NE", "BOOL_LIT", 
+			"CNAME", "GLOBAL_VAR", "LOCAL_VAR", "GRAPH_VAR", "DATATYPE", "PREFLOAT", 
+			"FLOAT", "NAT", "EXP", "LETTER", "DIGIT", "METADATA"
+		};
+	}
+	public static final String[] ruleNames = makeRuleNames();
+
+	private static String[] makeLiteralNames() {
+		return new String[] {
+			null, "','", "'('", "')'", "'{'", "'}'", "'.'", "'['", "']'", "'if'", 
+			"'else'", "'let'", "'='", "';'", "';;'", "'fn'", "'->'", "'def'", "'type'", 
+			"'|'", "', '", "':'", "'Tensor'", "'_'", "'meta'", "'v0.0.3'", null, 
+			null, null, null, "'*'", "'/'", "'+'", "'-'", "'<'", "'>'", "'<='", "'>='", 
+			"'=='", "'!='", null, null, null, null, null, "'int64'"
+		};
+	}
+	private static final String[] _LITERAL_NAMES = makeLiteralNames();
+	private static String[] makeSymbolicNames() {
+		return new String[] {
+			null, null, null, null, null, null, null, null, null, null, null, null, 
+			null, null, null, null, null, null, null, null, null, null, null, null, 
+			null, "SEMVER", "COMMENT", "WS", "LINE_COMMENT", "QUOTED_STRING", "MUL", 
+			"DIV", "ADD", "SUB", "LT", "GT", "LE", "GE", "EQ", "NE", "BOOL_LIT", 
+			"CNAME", "GLOBAL_VAR", "LOCAL_VAR", "GRAPH_VAR", "DATATYPE", "FLOAT", 
+			"NAT", "METADATA"
+		};
+	}
+	private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
+	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
+
+	/**
+	 * @deprecated Use {@link #VOCABULARY} instead.
+	 */
+	@Deprecated
+	public static final String[] tokenNames;
+	static {
+		tokenNames = new String[_SYMBOLIC_NAMES.length];
+		for (int i = 0; i < tokenNames.length; i++) {
+			tokenNames[i] = VOCABULARY.getLiteralName(i);
+			if (tokenNames[i] == null) {
+				tokenNames[i] = VOCABULARY.getSymbolicName(i);
+			}
+
+			if (tokenNames[i] == null) {
+				tokenNames[i] = "<INVALID>";
+			}
+		}
+	}
+
+	@Override
+	@Deprecated
+	public String[] getTokenNames() {
+		return tokenNames;
+	}
+
+	@Override
+
+	public Vocabulary getVocabulary() {
+		return VOCABULARY;
+	}
+
+
+	public RelayLexer(CharStream input) {
+		super(input);
+		_interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
+	}
+
+	@Override
+	public String getGrammarFileName() { return "Relay.g4"; }
+
+	@Override
+	public String[] getRuleNames() { return ruleNames; }
+
+	@Override
+	public String getSerializedATN() { return _serializedATN; }
+
+	@Override
+	public String[] getChannelNames() { return channelNames; }
+
+	@Override
+	public String[] getModeNames() { return modeNames; }
+
+	@Override
+	public ATN getATN() { return _ATN; }
+
+	public static final String _serializedATN =
+		"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\62\u015a\b\1\4\2"+
+		"\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4"+
+		"\13\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22"+
+		"\t\22\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31"+
+		"\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t"+
+		" \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t"+
+		"+\4,\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64"+
+		"\t\64\4\65\t\65\4\66\t\66\3\2\3\2\3\3\3\3\3\4\3\4\3\5\3\5\3\6\3\6\3\7"+
+		"\3\7\3\b\3\b\3\t\3\t\3\n\3\n\3\n\3\13\3\13\3\13\3\13\3\13\3\f\3\f\3\f"+
+		"\3\f\3\r\3\r\3\16\3\16\3\17\3\17\3\17\3\20\3\20\3\20\3\21\3\21\3\21\3"+
+		"\22\3\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3\24\3\24\3\25\3\25\3\25\3"+
+		"\26\3\26\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\30\3\30\3\31\3\31\3\31\3"+
+		"\31\3\31\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\33\3\33\3\33\3\33\3\33\7"+
+		"\33\u00c1\n\33\f\33\16\33\u00c4\13\33\3\33\3\33\3\33\3\33\3\33\3\34\6"+
+		"\34\u00cc\n\34\r\34\16\34\u00cd\3\34\3\34\3\35\3\35\3\35\3\35\7\35\u00d6"+
+		"\n\35\f\35\16\35\u00d9\13\35\3\35\3\35\3\35\3\35\3\36\3\36\3\36\3\37\3"+
+		"\37\3\37\7\37\u00e5\n\37\f\37\16\37\u00e8\13\37\3\37\3\37\3 \3 \3!\3!"+
+		"\3\"\3\"\3#\3#\3$\3$\3%\3%\3&\3&\3&\3\'\3\'\3\'\3(\3(\3(\3)\3)\3)\3*\3"+
+		"*\3*\3*\3*\3*\3*\3*\3*\5*\u010d\n*\3+\3+\5+\u0111\n+\3+\3+\3+\7+\u0116"+
+		"\n+\f+\16+\u0119\13+\3+\3+\7+\u011d\n+\f+\16+\u0120\13+\3,\3,\3,\3-\3"+
+		"-\3-\3.\3.\3.\3/\3/\3/\3/\3/\3/\3\60\3\60\3\60\5\60\u0134\n\60\3\60\5"+
+		"\60\u0137\n\60\3\61\3\61\3\61\3\62\6\62\u013d\n\62\r\62\16\62\u013e\3"+
+		"\63\3\63\5\63\u0143\n\63\3\63\3\63\3\64\3\64\3\65\3\65\3\66\3\66\3\66"+
+		"\3\66\3\66\3\66\3\66\3\66\3\66\3\66\3\66\7\66\u0156\n\66\f\66\16\66\u0159"+
+		"\13\66\5\u00c2\u00d7\u00e6\2\67\3\3\5\4\7\5\t\6\13\7\r\b\17\t\21\n\23"+
+		"\13\25\f\27\r\31\16\33\17\35\20\37\21!\22#\23%\24\'\25)\26+\27-\30/\31"+
+		"\61\32\63\33\65\34\67\359\36;\2=\37? A!C\"E#G$I%K&M\'O(Q)S*U+W,Y-[.]/"+
+		"_\2a\60c\61e\2g\2i\2k\62\3\2\b\5\2\13\f\17\17\"\"\4\2\f\f\17\17\4\2GG"+
+		"gg\4\2--//\4\2C\\c|\3\2\62;\2\u0165\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3\2\2"+
+		"\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2\2\23"+
+		"\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2"+
+		"\2\2\2\37\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2\2\'\3\2\2\2\2)\3\2"+
+		"\2\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2\2\2\2\63\3\2\2\2\2\65\3"+
+		"\2\2\2\2\67\3\2\2\2\29\3\2\2\2\2=\3\2\2\2\2?\3\2\2\2\2A\3\2\2\2\2C\3\2"+
+		"\2\2\2E\3\2\2\2\2G\3\2\2\2\2I\3\2\2\2\2K\3\2\2\2\2M\3\2\2\2\2O\3\2\2\2"+
+		"\2Q\3\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2W\3\2\2\2\2Y\3\2\2\2\2[\3\2\2\2\2]"+
+		"\3\2\2\2\2a\3\2\2\2\2c\3\2\2\2\2k\3\2\2\2\3m\3\2\2\2\5o\3\2\2\2\7q\3\2"+
+		"\2\2\ts\3\2\2\2\13u\3\2\2\2\rw\3\2\2\2\17y\3\2\2\2\21{\3\2\2\2\23}\3\2"+
+		"\2\2\25\u0080\3\2\2\2\27\u0085\3\2\2\2\31\u0089\3\2\2\2\33\u008b\3\2\2"+
+		"\2\35\u008d\3\2\2\2\37\u0090\3\2\2\2!\u0093\3\2\2\2#\u0096\3\2\2\2%\u009a"+
+		"\3\2\2\2\'\u009f\3\2\2\2)\u00a1\3\2\2\2+\u00a4\3\2\2\2-\u00a6\3\2\2\2"+
+		"/\u00ad\3\2\2\2\61\u00af\3\2\2\2\63\u00b4\3\2\2\2\65\u00bb\3\2\2\2\67"+
+		"\u00cb\3\2\2\29\u00d1\3\2\2\2;\u00de\3\2\2\2=\u00e1\3\2\2\2?\u00eb\3\2"+
+		"\2\2A\u00ed\3\2\2\2C\u00ef\3\2\2\2E\u00f1\3\2\2\2G\u00f3\3\2\2\2I\u00f5"+
+		"\3\2\2\2K\u00f7\3\2\2\2M\u00fa\3\2\2\2O\u00fd\3\2\2\2Q\u0100\3\2\2\2S"+
+		"\u010c\3\2\2\2U\u0110\3\2\2\2W\u0121\3\2\2\2Y\u0124\3\2\2\2[\u0127\3\2"+
+		"\2\2]\u012a\3\2\2\2_\u0130\3\2\2\2a\u0138\3\2\2\2c\u013c\3\2\2\2e\u0140"+
+		"\3\2\2\2g\u0146\3\2\2\2i\u0148\3\2\2\2k\u014a\3\2\2\2mn\7.\2\2n\4\3\2"+
+		"\2\2op\7*\2\2p\6\3\2\2\2qr\7+\2\2r\b\3\2\2\2st\7}\2\2t\n\3\2\2\2uv\7\177"+
+		"\2\2v\f\3\2\2\2wx\7\60\2\2x\16\3\2\2\2yz\7]\2\2z\20\3\2\2\2{|\7_\2\2|"+
+		"\22\3\2\2\2}~\7k\2\2~\177\7h\2\2\177\24\3\2\2\2\u0080\u0081\7g\2\2\u0081"+
+		"\u0082\7n\2\2\u0082\u0083\7u\2\2\u0083\u0084\7g\2\2\u0084\26\3\2\2\2\u0085"+
+		"\u0086\7n\2\2\u0086\u0087\7g\2\2\u0087\u0088\7v\2\2\u0088\30\3\2\2\2\u0089"+
+		"\u008a\7?\2\2\u008a\32\3\2\2\2\u008b\u008c\7=\2\2\u008c\34\3\2\2\2\u008d"+
+		"\u008e\7=\2\2\u008e\u008f\7=\2\2\u008f\36\3\2\2\2\u0090\u0091\7h\2\2\u0091"+
+		"\u0092\7p\2\2\u0092 \3\2\2\2\u0093\u0094\7/\2\2\u0094\u0095\7@\2\2\u0095"+
+		"\"\3\2\2\2\u0096\u0097\7f\2\2\u0097\u0098\7g\2\2\u0098\u0099\7h\2\2\u0099"+
+		"$\3\2\2\2\u009a\u009b\7v\2\2\u009b\u009c\7{\2\2\u009c\u009d\7r\2\2\u009d"+
+		"\u009e\7g\2\2\u009e&\3\2\2\2\u009f\u00a0\7~\2\2\u00a0(\3\2\2\2\u00a1\u00a2"+
+		"\7.\2\2\u00a2\u00a3\7\"\2\2\u00a3*\3\2\2\2\u00a4\u00a5\7<\2\2\u00a5,\3"+
+		"\2\2\2\u00a6\u00a7\7V\2\2\u00a7\u00a8\7g\2\2\u00a8\u00a9\7p\2\2\u00a9"+
+		"\u00aa\7u\2\2\u00aa\u00ab\7q\2\2\u00ab\u00ac\7t\2\2\u00ac.\3\2\2\2\u00ad"+
+		"\u00ae\7a\2\2\u00ae\60\3\2\2\2\u00af\u00b0\7o\2\2\u00b0\u00b1\7g\2\2\u00b1"+
+		"\u00b2\7v\2\2\u00b2\u00b3\7c\2\2\u00b3\62\3\2\2\2\u00b4\u00b5\7x\2\2\u00b5"+
+		"\u00b6\7\62\2\2\u00b6\u00b7\7\60\2\2\u00b7\u00b8\7\62\2\2\u00b8\u00b9"+
+		"\7\60\2\2\u00b9\u00ba\7\65\2\2\u00ba\64\3\2\2\2\u00bb\u00bc\7\61\2\2\u00bc"+
+		"\u00bd\7,\2\2\u00bd\u00c2\3\2\2\2\u00be\u00c1\5\65\33\2\u00bf\u00c1\13"+
+		"\2\2\2\u00c0\u00be\3\2\2\2\u00c0\u00bf\3\2\2\2\u00c1\u00c4\3\2\2\2\u00c2"+
+		"\u00c3\3\2\2\2\u00c2\u00c0\3\2\2\2\u00c3\u00c5\3\2\2\2\u00c4\u00c2\3\2"+
+		"\2\2\u00c5\u00c6\7,\2\2\u00c6\u00c7\7\61\2\2\u00c7\u00c8\3\2\2\2\u00c8"+
+		"\u00c9\b\33\2\2\u00c9\66\3\2\2\2\u00ca\u00cc\t\2\2\2\u00cb\u00ca\3\2\2"+
+		"\2\u00cc\u00cd\3\2\2\2\u00cd\u00cb\3\2\2\2\u00cd\u00ce\3\2\2\2\u00ce\u00cf"+
+		"\3\2\2\2\u00cf\u00d0\b\34\2\2\u00d08\3\2\2\2\u00d1\u00d2\7\61\2\2\u00d2"+
+		"\u00d3\7\61\2\2\u00d3\u00d7\3\2\2\2\u00d4\u00d6\13\2\2\2\u00d5\u00d4\3"+
+		"\2\2\2\u00d6\u00d9\3\2\2\2\u00d7\u00d8\3\2\2\2\u00d7\u00d5\3\2\2\2\u00d8"+
+		"\u00da\3\2\2\2\u00d9\u00d7\3\2\2\2\u00da\u00db\7\f\2\2\u00db\u00dc\3\2"+
+		"\2\2\u00dc\u00dd\b\35\2\2\u00dd:\3\2\2\2\u00de\u00df\7^\2\2\u00df\u00e0"+
+		"\7$\2\2\u00e0<\3\2\2\2\u00e1\u00e6\7$\2\2\u00e2\u00e5\5;\36\2\u00e3\u00e5"+
+		"\n\3\2\2\u00e4\u00e2\3\2\2\2\u00e4\u00e3\3\2\2\2\u00e5\u00e8\3\2\2\2\u00e6"+
+		"\u00e7\3\2\2\2\u00e6\u00e4\3\2\2\2\u00e7\u00e9\3\2\2\2\u00e8\u00e6\3\2"+
+		"\2\2\u00e9\u00ea\7$\2\2\u00ea>\3\2\2\2\u00eb\u00ec\7,\2\2\u00ec@\3\2\2"+
+		"\2\u00ed\u00ee\7\61\2\2\u00eeB\3\2\2\2\u00ef\u00f0\7-\2\2\u00f0D\3\2\2"+
+		"\2\u00f1\u00f2\7/\2\2\u00f2F\3\2\2\2\u00f3\u00f4\7>\2\2\u00f4H\3\2\2\2"+
+		"\u00f5\u00f6\7@\2\2\u00f6J\3\2\2\2\u00f7\u00f8\7>\2\2\u00f8\u00f9\7?\2"+
+		"\2\u00f9L\3\2\2\2\u00fa\u00fb\7@\2\2\u00fb\u00fc\7?\2\2\u00fcN\3\2\2\2"+
+		"\u00fd\u00fe\7?\2\2\u00fe\u00ff\7?\2\2\u00ffP\3\2\2\2\u0100\u0101\7#\2"+
+		"\2\u0101\u0102\7?\2\2\u0102R\3\2\2\2\u0103\u0104\7V\2\2\u0104\u0105\7"+
+		"t\2\2\u0105\u0106\7w\2\2\u0106\u010d\7g\2\2\u0107\u0108\7H\2\2\u0108\u0109"+
+		"\7c\2\2\u0109\u010a\7n\2\2\u010a\u010b\7u\2\2\u010b\u010d\7g\2\2\u010c"+
+		"\u0103\3\2\2\2\u010c\u0107\3\2\2\2\u010dT\3\2\2\2\u010e\u0111\7a\2\2\u010f"+
+		"\u0111\5g\64\2\u0110\u010e\3\2\2\2\u0110\u010f\3\2\2\2\u0111\u0117\3\2"+
+		"\2\2\u0112\u0116\7a\2\2\u0113\u0116\5g\64\2\u0114\u0116\5i\65\2\u0115"+
+		"\u0112\3\2\2\2\u0115\u0113\3\2\2\2\u0115\u0114\3\2\2\2\u0116\u0119\3\2"+
+		"\2\2\u0117\u0115\3\2\2\2\u0117\u0118\3\2\2\2\u0118\u011e\3\2\2\2\u0119"+
+		"\u0117\3\2\2\2\u011a\u011b\7\60\2\2\u011b\u011d\5U+\2\u011c\u011a\3\2"+
+		"\2\2\u011d\u0120\3\2\2\2\u011e\u011c\3\2\2\2\u011e\u011f\3\2\2\2\u011f"+
+		"V\3\2\2\2\u0120\u011e\3\2\2\2\u0121\u0122\7B\2\2\u0122\u0123\5U+\2\u0123"+
+		"X\3\2\2\2\u0124\u0125\7\'\2\2\u0125\u0126\5U+\2\u0126Z\3\2\2\2\u0127\u0128"+
+		"\7\'\2\2\u0128\u0129\5c\62\2\u0129\\\3\2\2\2\u012a\u012b\7k\2\2\u012b"+
+		"\u012c\7p\2\2\u012c\u012d\7v\2\2\u012d\u012e\78\2\2\u012e\u012f\7\66\2"+
+		"\2\u012f^\3\2\2\2\u0130\u0133\5c\62\2\u0131\u0132\7\60\2\2\u0132\u0134"+
+		"\5c\62\2\u0133\u0131\3\2\2\2\u0133\u0134\3\2\2\2\u0134\u0136\3\2\2\2\u0135"+
+		"\u0137\5e\63\2\u0136\u0135\3\2\2\2\u0136\u0137\3\2\2\2\u0137`\3\2\2\2"+
+		"\u0138\u0139\5_\60\2\u0139\u013a\7h\2\2\u013ab\3\2\2\2\u013b\u013d\5i"+
+		"\65\2\u013c\u013b\3\2\2\2\u013d\u013e\3\2\2\2\u013e\u013c\3\2\2\2\u013e"+
+		"\u013f\3\2\2\2\u013fd\3\2\2\2\u0140\u0142\t\4\2\2\u0141\u0143\t\5\2\2"+
+		"\u0142\u0141\3\2\2\2\u0142\u0143\3\2\2\2\u0143\u0144\3\2\2\2\u0144\u0145"+
+		"\5c\62\2\u0145f\3\2\2\2\u0146\u0147\t\6\2\2\u0147h\3\2\2\2\u0148\u0149"+
+		"\t\7\2\2\u0149j\3\2\2\2\u014a\u014b\7O\2\2\u014b\u014c\7G\2\2\u014c\u014d"+
+		"\7V\2\2\u014d\u014e\7C\2\2\u014e\u014f\7F\2\2\u014f\u0150\7C\2\2\u0150"+
+		"\u0151\7V\2\2\u0151\u0152\7C\2\2\u0152\u0153\7<\2\2\u0153\u0157\3\2\2"+
+		"\2\u0154\u0156\13\2\2\2\u0155\u0154\3\2\2\2\u0156\u0159\3\2\2\2\u0157"+
+		"\u0155\3\2\2\2\u0157\u0158\3\2\2\2\u0158l\3\2\2\2\u0159\u0157\3\2\2\2"+
+		"\23\2\u00c0\u00c2\u00cd\u00d7\u00e4\u00e6\u010c\u0110\u0115\u0117\u011e"+
+		"\u0133\u0136\u013e\u0142\u0157\3\b\2\2";
+	public static final ATN _ATN =
+		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
+	static {
+		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
+		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
+			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
+		}
+	}
+}
\ No newline at end of file
diff --git a/python/tvm/relay/grammar/RelayListener.java b/python/tvm/relay/grammar/RelayListener.java
new file mode 100644
index 000000000000..3ba88ea2420a
--- /dev/null
+++ b/python/tvm/relay/grammar/RelayListener.java
@@ -0,0 +1,551 @@
+// Generated from Relay.g4 by ANTLR 4.7.2
+import org.antlr.v4.runtime.tree.ParseTreeListener;
+
+/**
+ * This interface defines a complete listener for a parse tree produced by
+ * {@link RelayParser}.
+ */
+public interface RelayListener extends ParseTreeListener {
+	/**
+	 * Enter a parse tree produced by {@link RelayParser#opIdent}.
+	 * @param ctx the parse tree
+	 */
+	void enterOpIdent(RelayParser.OpIdentContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link RelayParser#opIdent}.
+	 * @param ctx the parse tree
+	 */
+	void exitOpIdent(RelayParser.OpIdentContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link RelayParser#prog}.
+	 * @param ctx the parse tree
+	 */
+	void enterProg(RelayParser.ProgContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link RelayParser#prog}.
+	 * @param ctx the parse tree
+	 */
+	void exitProg(RelayParser.ProgContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link RelayParser#exprList}.
+	 * @param ctx the parse tree
+	 */
+	void enterExprList(RelayParser.ExprListContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link RelayParser#exprList}.
+	 * @param ctx the parse tree
+	 */
+	void exitExprList(RelayParser.ExprListContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code callNoAttr}
+	 * labeled alternative in {@link RelayParser#callList}.
+	 * @param ctx the parse tree
+	 */
+	void enterCallNoAttr(RelayParser.CallNoAttrContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code callNoAttr}
+	 * labeled alternative in {@link RelayParser#callList}.
+	 * @param ctx the parse tree
+	 */
+	void exitCallNoAttr(RelayParser.CallNoAttrContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code callWithAttr}
+	 * labeled alternative in {@link RelayParser#callList}.
+	 * @param ctx the parse tree
+	 */
+	void enterCallWithAttr(RelayParser.CallWithAttrContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code callWithAttr}
+	 * labeled alternative in {@link RelayParser#callList}.
+	 * @param ctx the parse tree
+	 */
+	void exitCallWithAttr(RelayParser.CallWithAttrContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code funcExpr}
+	 * labeled alternative in {@link RelayParser#expr}.
+	 * @param ctx the parse tree
+	 */
+	void enterFuncExpr(RelayParser.FuncExprContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code funcExpr}
+	 * labeled alternative in {@link RelayParser#expr}.
+	 * @param ctx the parse tree
+	 */
+	void exitFuncExpr(RelayParser.FuncExprContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code metaExpr}
+	 * labeled alternative in {@link RelayParser#expr}.
+	 * @param ctx the parse tree
+	 */
+	void enterMetaExpr(RelayParser.MetaExprContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code metaExpr}
+	 * labeled alternative in {@link RelayParser#expr}.
+	 * @param ctx the parse tree
+	 */
+	void exitMetaExpr(RelayParser.MetaExprContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code tensor}
+	 * labeled alternative in {@link RelayParser#expr}.
+	 * @param ctx the parse tree
+	 */
+	void enterTensor(RelayParser.TensorContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code tensor}
+	 * labeled alternative in {@link RelayParser#expr}.
+	 * @param ctx the parse tree
+	 */
+	void exitTensor(RelayParser.TensorContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code graph}
+	 * labeled alternative in {@link RelayParser#expr}.
+	 * @param ctx the parse tree
+	 */
+	void enterGraph(RelayParser.GraphContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code graph}
+	 * labeled alternative in {@link RelayParser#expr}.
+	 * @param ctx the parse tree
+	 */
+	void exitGraph(RelayParser.GraphContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code identExpr}
+	 * labeled alternative in {@link RelayParser#expr}.
+	 * @param ctx the parse tree
+	 */
+	void enterIdentExpr(RelayParser.IdentExprContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code identExpr}
+	 * labeled alternative in {@link RelayParser#expr}.
+	 * @param ctx the parse tree
+	 */
+	void exitIdentExpr(RelayParser.IdentExprContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code stringExpr}
+	 * labeled alternative in {@link RelayParser#expr}.
+	 * @param ctx the parse tree
+	 */
+	void enterStringExpr(RelayParser.StringExprContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code stringExpr}
+	 * labeled alternative in {@link RelayParser#expr}.
+	 * @param ctx the parse tree
+	 */
+	void exitStringExpr(RelayParser.StringExprContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code call}
+	 * labeled alternative in {@link RelayParser#expr}.
+	 * @param ctx the parse tree
+	 */
+	void enterCall(RelayParser.CallContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code call}
+	 * labeled alternative in {@link RelayParser#expr}.
+	 * @param ctx the parse tree
+	 */
+	void exitCall(RelayParser.CallContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code neg}
+	 * labeled alternative in {@link RelayParser#expr}.
+	 * @param ctx the parse tree
+	 */
+	void enterNeg(RelayParser.NegContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code neg}
+	 * labeled alternative in {@link RelayParser#expr}.
+	 * @param ctx the parse tree
+	 */
+	void exitNeg(RelayParser.NegContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code tuple}
+	 * labeled alternative in {@link RelayParser#expr}.
+	 * @param ctx the parse tree
+	 */
+	void enterTuple(RelayParser.TupleContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code tuple}
+	 * labeled alternative in {@link RelayParser#expr}.
+	 * @param ctx the parse tree
+	 */
+	void exitTuple(RelayParser.TupleContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code paren}
+	 * labeled alternative in {@link RelayParser#expr}.
+	 * @param ctx the parse tree
+	 */
+	void enterParen(RelayParser.ParenContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code paren}
+	 * labeled alternative in {@link RelayParser#expr}.
+	 * @param ctx the parse tree
+	 */
+	void exitParen(RelayParser.ParenContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code scalarExpr}
+	 * labeled alternative in {@link RelayParser#expr}.
+	 * @param ctx the parse tree
+	 */
+	void enterScalarExpr(RelayParser.ScalarExprContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code scalarExpr}
+	 * labeled alternative in {@link RelayParser#expr}.
+	 * @param ctx the parse tree
+	 */
+	void exitScalarExpr(RelayParser.ScalarExprContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code let}
+	 * labeled alternative in {@link RelayParser#expr}.
+	 * @param ctx the parse tree
+	 */
+	void enterLet(RelayParser.LetContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code let}
+	 * labeled alternative in {@link RelayParser#expr}.
+	 * @param ctx the parse tree
+	 */
+	void exitLet(RelayParser.LetContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code projection}
+	 * labeled alternative in {@link RelayParser#expr}.
+	 * @param ctx the parse tree
+	 */
+	void enterProjection(RelayParser.ProjectionContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code projection}
+	 * labeled alternative in {@link RelayParser#expr}.
+	 * @param ctx the parse tree
+	 */
+	void exitProjection(RelayParser.ProjectionContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code ifElse}
+	 * labeled alternative in {@link RelayParser#expr}.
+	 * @param ctx the parse tree
+	 */
+	void enterIfElse(RelayParser.IfElseContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code ifElse}
+	 * labeled alternative in {@link RelayParser#expr}.
+	 * @param ctx the parse tree
+	 */
+	void exitIfElse(RelayParser.IfElseContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code binOp}
+	 * labeled alternative in {@link RelayParser#expr}.
+	 * @param ctx the parse tree
+	 */
+	void enterBinOp(RelayParser.BinOpContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code binOp}
+	 * labeled alternative in {@link RelayParser#expr}.
+	 * @param ctx the parse tree
+	 */
+	void exitBinOp(RelayParser.BinOpContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link RelayParser#func}.
+	 * @param ctx the parse tree
+	 */
+	void enterFunc(RelayParser.FuncContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link RelayParser#func}.
+	 * @param ctx the parse tree
+	 */
+	void exitFunc(RelayParser.FuncContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link RelayParser#defn}.
+	 * @param ctx the parse tree
+	 */
+	void enterDefn(RelayParser.DefnContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link RelayParser#defn}.
+	 * @param ctx the parse tree
+	 */
+	void exitDefn(RelayParser.DefnContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link RelayParser#adtDefn}.
+	 * @param ctx the parse tree
+	 */
+	void enterAdtDefn(RelayParser.AdtDefnContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link RelayParser#adtDefn}.
+	 * @param ctx the parse tree
+	 */
+	void exitAdtDefn(RelayParser.AdtDefnContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link RelayParser#adtVariant}.
+	 * @param ctx the parse tree
+	 */
+	void enterAdtVariant(RelayParser.AdtVariantContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link RelayParser#adtVariant}.
+	 * @param ctx the parse tree
+	 */
+	void exitAdtVariant(RelayParser.AdtVariantContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code argNoAttr}
+	 * labeled alternative in {@link RelayParser#argList}.
+	 * @param ctx the parse tree
+	 */
+	void enterArgNoAttr(RelayParser.ArgNoAttrContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code argNoAttr}
+	 * labeled alternative in {@link RelayParser#argList}.
+	 * @param ctx the parse tree
+	 */
+	void exitArgNoAttr(RelayParser.ArgNoAttrContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code argWithAttr}
+	 * labeled alternative in {@link RelayParser#argList}.
+	 * @param ctx the parse tree
+	 */
+	void enterArgWithAttr(RelayParser.ArgWithAttrContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code argWithAttr}
+	 * labeled alternative in {@link RelayParser#argList}.
+	 * @param ctx the parse tree
+	 */
+	void exitArgWithAttr(RelayParser.ArgWithAttrContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link RelayParser#varList}.
+	 * @param ctx the parse tree
+	 */
+	void enterVarList(RelayParser.VarListContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link RelayParser#varList}.
+	 * @param ctx the parse tree
+	 */
+	void exitVarList(RelayParser.VarListContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link RelayParser#var}.
+	 * @param ctx the parse tree
+	 */
+	void enterVar(RelayParser.VarContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link RelayParser#var}.
+	 * @param ctx the parse tree
+	 */
+	void exitVar(RelayParser.VarContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link RelayParser#attrSeq}.
+	 * @param ctx the parse tree
+	 */
+	void enterAttrSeq(RelayParser.AttrSeqContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link RelayParser#attrSeq}.
+	 * @param ctx the parse tree
+	 */
+	void exitAttrSeq(RelayParser.AttrSeqContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link RelayParser#attr}.
+	 * @param ctx the parse tree
+	 */
+	void enterAttr(RelayParser.AttrContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link RelayParser#attr}.
+	 * @param ctx the parse tree
+	 */
+	void exitAttr(RelayParser.AttrContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link RelayParser#typeParamList}.
+	 * @param ctx the parse tree
+	 */
+	void enterTypeParamList(RelayParser.TypeParamListContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link RelayParser#typeParamList}.
+	 * @param ctx the parse tree
+	 */
+	void exitTypeParamList(RelayParser.TypeParamListContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code tupleType}
+	 * labeled alternative in {@link RelayParser#type_}.
+	 * @param ctx the parse tree
+	 */
+	void enterTupleType(RelayParser.TupleTypeContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code tupleType}
+	 * labeled alternative in {@link RelayParser#type_}.
+	 * @param ctx the parse tree
+	 */
+	void exitTupleType(RelayParser.TupleTypeContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code typeIdentType}
+	 * labeled alternative in {@link RelayParser#type_}.
+	 * @param ctx the parse tree
+	 */
+	void enterTypeIdentType(RelayParser.TypeIdentTypeContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code typeIdentType}
+	 * labeled alternative in {@link RelayParser#type_}.
+	 * @param ctx the parse tree
+	 */
+	void exitTypeIdentType(RelayParser.TypeIdentTypeContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code tensorType}
+	 * labeled alternative in {@link RelayParser#type_}.
+	 * @param ctx the parse tree
+	 */
+	void enterTensorType(RelayParser.TensorTypeContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code tensorType}
+	 * labeled alternative in {@link RelayParser#type_}.
+	 * @param ctx the parse tree
+	 */
+	void exitTensorType(RelayParser.TensorTypeContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code funcType}
+	 * labeled alternative in {@link RelayParser#type_}.
+	 * @param ctx the parse tree
+	 */
+	void enterFuncType(RelayParser.FuncTypeContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code funcType}
+	 * labeled alternative in {@link RelayParser#type_}.
+	 * @param ctx the parse tree
+	 */
+	void exitFuncType(RelayParser.FuncTypeContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code incompleteType}
+	 * labeled alternative in {@link RelayParser#type_}.
+	 * @param ctx the parse tree
+	 */
+	void enterIncompleteType(RelayParser.IncompleteTypeContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code incompleteType}
+	 * labeled alternative in {@link RelayParser#type_}.
+	 * @param ctx the parse tree
+	 */
+	void exitIncompleteType(RelayParser.IncompleteTypeContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code intType}
+	 * labeled alternative in {@link RelayParser#type_}.
+	 * @param ctx the parse tree
+	 */
+	void enterIntType(RelayParser.IntTypeContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code intType}
+	 * labeled alternative in {@link RelayParser#type_}.
+	 * @param ctx the parse tree
+	 */
+	void exitIntType(RelayParser.IntTypeContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link RelayParser#shapeList}.
+	 * @param ctx the parse tree
+	 */
+	void enterShapeList(RelayParser.ShapeListContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link RelayParser#shapeList}.
+	 * @param ctx the parse tree
+	 */
+	void exitShapeList(RelayParser.ShapeListContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link RelayParser#meta}.
+	 * @param ctx the parse tree
+	 */
+	void enterMeta(RelayParser.MetaContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link RelayParser#meta}.
+	 * @param ctx the parse tree
+	 */
+	void exitMeta(RelayParser.MetaContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code metaShape}
+	 * labeled alternative in {@link RelayParser#shape}.
+	 * @param ctx the parse tree
+	 */
+	void enterMetaShape(RelayParser.MetaShapeContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code metaShape}
+	 * labeled alternative in {@link RelayParser#shape}.
+	 * @param ctx the parse tree
+	 */
+	void exitMetaShape(RelayParser.MetaShapeContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code parensShape}
+	 * labeled alternative in {@link RelayParser#shape}.
+	 * @param ctx the parse tree
+	 */
+	void enterParensShape(RelayParser.ParensShapeContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code parensShape}
+	 * labeled alternative in {@link RelayParser#shape}.
+	 * @param ctx the parse tree
+	 */
+	void exitParensShape(RelayParser.ParensShapeContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code intShape}
+	 * labeled alternative in {@link RelayParser#shape}.
+	 * @param ctx the parse tree
+	 */
+	void enterIntShape(RelayParser.IntShapeContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code intShape}
+	 * labeled alternative in {@link RelayParser#shape}.
+	 * @param ctx the parse tree
+	 */
+	void exitIntShape(RelayParser.IntShapeContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link RelayParser#typeIdent}.
+	 * @param ctx the parse tree
+	 */
+	void enterTypeIdent(RelayParser.TypeIdentContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link RelayParser#typeIdent}.
+	 * @param ctx the parse tree
+	 */
+	void exitTypeIdent(RelayParser.TypeIdentContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link RelayParser#body}.
+	 * @param ctx the parse tree
+	 */
+	void enterBody(RelayParser.BodyContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link RelayParser#body}.
+	 * @param ctx the parse tree
+	 */
+	void exitBody(RelayParser.BodyContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code scalarFloat}
+	 * labeled alternative in {@link RelayParser#scalar}.
+	 * @param ctx the parse tree
+	 */
+	void enterScalarFloat(RelayParser.ScalarFloatContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code scalarFloat}
+	 * labeled alternative in {@link RelayParser#scalar}.
+	 * @param ctx the parse tree
+	 */
+	void exitScalarFloat(RelayParser.ScalarFloatContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code scalarInt}
+	 * labeled alternative in {@link RelayParser#scalar}.
+	 * @param ctx the parse tree
+	 */
+	void enterScalarInt(RelayParser.ScalarIntContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code scalarInt}
+	 * labeled alternative in {@link RelayParser#scalar}.
+	 * @param ctx the parse tree
+	 */
+	void exitScalarInt(RelayParser.ScalarIntContext ctx);
+	/**
+	 * Enter a parse tree produced by the {@code scalarBool}
+	 * labeled alternative in {@link RelayParser#scalar}.
+	 * @param ctx the parse tree
+	 */
+	void enterScalarBool(RelayParser.ScalarBoolContext ctx);
+	/**
+	 * Exit a parse tree produced by the {@code scalarBool}
+	 * labeled alternative in {@link RelayParser#scalar}.
+	 * @param ctx the parse tree
+	 */
+	void exitScalarBool(RelayParser.ScalarBoolContext ctx);
+	/**
+	 * Enter a parse tree produced by {@link RelayParser#ident}.
+	 * @param ctx the parse tree
+	 */
+	void enterIdent(RelayParser.IdentContext ctx);
+	/**
+	 * Exit a parse tree produced by {@link RelayParser#ident}.
+	 * @param ctx the parse tree
+	 */
+	void exitIdent(RelayParser.IdentContext ctx);
+}
\ No newline at end of file
diff --git a/python/tvm/relay/grammar/RelayParser.java b/python/tvm/relay/grammar/RelayParser.java
new file mode 100644
index 000000000000..44914d077034
--- /dev/null
+++ b/python/tvm/relay/grammar/RelayParser.java
@@ -0,0 +1,2786 @@
+// Generated from Relay.g4 by ANTLR 4.7.2
+import org.antlr.v4.runtime.atn.*;
+import org.antlr.v4.runtime.dfa.DFA;
+import org.antlr.v4.runtime.*;
+import org.antlr.v4.runtime.misc.*;
+import org.antlr.v4.runtime.tree.*;
+import java.util.List;
+import java.util.Iterator;
+import java.util.ArrayList;
+
+@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
+public class RelayParser extends Parser {
+	static { RuntimeMetaData.checkVersion("4.7.2", RuntimeMetaData.VERSION); }
+
+	protected static final DFA[] _decisionToDFA;
+	protected static final PredictionContextCache _sharedContextCache =
+		new PredictionContextCache();
+	public static final int
+		T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9, 
+		T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, T__14=15, T__15=16, T__16=17, 
+		T__17=18, T__18=19, T__19=20, T__20=21, T__21=22, T__22=23, T__23=24, 
+		SEMVER=25, COMMENT=26, WS=27, LINE_COMMENT=28, QUOTED_STRING=29, MUL=30, 
+		DIV=31, ADD=32, SUB=33, LT=34, GT=35, LE=36, GE=37, EQ=38, NE=39, BOOL_LIT=40, 
+		CNAME=41, GLOBAL_VAR=42, LOCAL_VAR=43, GRAPH_VAR=44, DATATYPE=45, FLOAT=46, 
+		NAT=47, METADATA=48;
+	public static final int
+		RULE_opIdent = 0, RULE_prog = 1, RULE_exprList = 2, RULE_callList = 3, 
+		RULE_expr = 4, RULE_func = 5, RULE_defn = 6, RULE_adtDefn = 7, RULE_adtVariant = 8, 
+		RULE_argList = 9, RULE_varList = 10, RULE_var = 11, RULE_attrSeq = 12, 
+		RULE_attr = 13, RULE_typeParamList = 14, RULE_type_ = 15, RULE_shapeList = 16, 
+		RULE_meta = 17, RULE_shape = 18, RULE_typeIdent = 19, RULE_body = 20, 
+		RULE_scalar = 21, RULE_ident = 22;
+	private static String[] makeRuleNames() {
+		return new String[] {
+			"opIdent", "prog", "exprList", "callList", "expr", "func", "defn", "adtDefn", 
+			"adtVariant", "argList", "varList", "var", "attrSeq", "attr", "typeParamList", 
+			"type_", "shapeList", "meta", "shape", "typeIdent", "body", "scalar", 
+			"ident"
+		};
+	}
+	public static final String[] ruleNames = makeRuleNames();
+
+	private static String[] makeLiteralNames() {
+		return new String[] {
+			null, "','", "'('", "')'", "'{'", "'}'", "'.'", "'['", "']'", "'if'", 
+			"'else'", "'let'", "'='", "';'", "';;'", "'fn'", "'->'", "'def'", "'type'", 
+			"'|'", "', '", "':'", "'Tensor'", "'_'", "'meta'", "'v0.0.3'", null, 
+			null, null, null, "'*'", "'/'", "'+'", "'-'", "'<'", "'>'", "'<='", "'>='", 
+			"'=='", "'!='", null, null, null, null, null, "'int64'"
+		};
+	}
+	private static final String[] _LITERAL_NAMES = makeLiteralNames();
+	private static String[] makeSymbolicNames() {
+		return new String[] {
+			null, null, null, null, null, null, null, null, null, null, null, null, 
+			null, null, null, null, null, null, null, null, null, null, null, null, 
+			null, "SEMVER", "COMMENT", "WS", "LINE_COMMENT", "QUOTED_STRING", "MUL", 
+			"DIV", "ADD", "SUB", "LT", "GT", "LE", "GE", "EQ", "NE", "BOOL_LIT", 
+			"CNAME", "GLOBAL_VAR", "LOCAL_VAR", "GRAPH_VAR", "DATATYPE", "FLOAT", 
+			"NAT", "METADATA"
+		};
+	}
+	private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
+	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
+
+	/**
+	 * @deprecated Use {@link #VOCABULARY} instead.
+	 */
+	@Deprecated
+	public static final String[] tokenNames;
+	static {
+		tokenNames = new String[_SYMBOLIC_NAMES.length];
+		for (int i = 0; i < tokenNames.length; i++) {
+			tokenNames[i] = VOCABULARY.getLiteralName(i);
+			if (tokenNames[i] == null) {
+				tokenNames[i] = VOCABULARY.getSymbolicName(i);
+			}
+
+			if (tokenNames[i] == null) {
+				tokenNames[i] = "<INVALID>";
+			}
+		}
+	}
+
+	@Override
+	@Deprecated
+	public String[] getTokenNames() {
+		return tokenNames;
+	}
+
+	@Override
+
+	public Vocabulary getVocabulary() {
+		return VOCABULARY;
+	}
+
+	@Override
+	public String getGrammarFileName() { return "Relay.g4"; }
+
+	@Override
+	public String[] getRuleNames() { return ruleNames; }
+
+	@Override
+	public String getSerializedATN() { return _serializedATN; }
+
+	@Override
+	public ATN getATN() { return _ATN; }
+
+	public RelayParser(TokenStream input) {
+		super(input);
+		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
+	}
+
+	public static class OpIdentContext extends ParserRuleContext {
+		public TerminalNode CNAME() { return getToken(RelayParser.CNAME, 0); }
+		public OpIdentContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_opIdent; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterOpIdent(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitOpIdent(this);
+		}
+	}
+
+	public final OpIdentContext opIdent() throws RecognitionException {
+		OpIdentContext _localctx = new OpIdentContext(_ctx, getState());
+		enterRule(_localctx, 0, RULE_opIdent);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(46);
+			match(CNAME);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ProgContext extends ParserRuleContext {
+		public TerminalNode SEMVER() { return getToken(RelayParser.SEMVER, 0); }
+		public TerminalNode EOF() { return getToken(RelayParser.EOF, 0); }
+		public ExprContext expr() {
+			return getRuleContext(ExprContext.class,0);
+		}
+		public TerminalNode METADATA() { return getToken(RelayParser.METADATA, 0); }
+		public List<DefnContext> defn() {
+			return getRuleContexts(DefnContext.class);
+		}
+		public DefnContext defn(int i) {
+			return getRuleContext(DefnContext.class,i);
+		}
+		public ProgContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_prog; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterProg(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitProg(this);
+		}
+	}
+
+	public final ProgContext prog() throws RecognitionException {
+		ProgContext _localctx = new ProgContext(_ctx, getState());
+		enterRule(_localctx, 2, RULE_prog);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(48);
+			match(SEMVER);
+			setState(56);
+			_errHandler.sync(this);
+			switch (_input.LA(1)) {
+			case EOF:
+			case T__16:
+			case T__17:
+			case METADATA:
+				{
+				setState(52);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+				while (_la==T__16 || _la==T__17) {
+					{
+					{
+					setState(49);
+					defn();
+					}
+					}
+					setState(54);
+					_errHandler.sync(this);
+					_la = _input.LA(1);
+				}
+				}
+				break;
+			case T__1:
+			case T__3:
+			case T__6:
+			case T__8:
+			case T__10:
+			case T__14:
+			case T__23:
+			case QUOTED_STRING:
+			case SUB:
+			case BOOL_LIT:
+			case CNAME:
+			case GLOBAL_VAR:
+			case LOCAL_VAR:
+			case GRAPH_VAR:
+			case FLOAT:
+			case NAT:
+				{
+				setState(55);
+				expr(0);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+			setState(59);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			if (_la==METADATA) {
+				{
+				setState(58);
+				match(METADATA);
+				}
+			}
+
+			setState(61);
+			match(EOF);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ExprListContext extends ParserRuleContext {
+		public List<ExprContext> expr() {
+			return getRuleContexts(ExprContext.class);
+		}
+		public ExprContext expr(int i) {
+			return getRuleContext(ExprContext.class,i);
+		}
+		public ExprListContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_exprList; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterExprList(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitExprList(this);
+		}
+	}
+
+	public final ExprListContext exprList() throws RecognitionException {
+		ExprListContext _localctx = new ExprListContext(_ctx, getState());
+		enterRule(_localctx, 4, RULE_exprList);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(71);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__1) | (1L << T__3) | (1L << T__6) | (1L << T__8) | (1L << T__10) | (1L << T__14) | (1L << T__23) | (1L << QUOTED_STRING) | (1L << SUB) | (1L << BOOL_LIT) | (1L << CNAME) | (1L << GLOBAL_VAR) | (1L << LOCAL_VAR) | (1L << GRAPH_VAR) | (1L << FLOAT) | (1L << NAT))) != 0)) {
+				{
+				setState(63);
+				expr(0);
+				setState(68);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+				while (_la==T__0) {
+					{
+					{
+					setState(64);
+					match(T__0);
+					setState(65);
+					expr(0);
+					}
+					}
+					setState(70);
+					_errHandler.sync(this);
+					_la = _input.LA(1);
+				}
+				}
+			}
+
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class CallListContext extends ParserRuleContext {
+		public CallListContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_callList; }
+	 
+		public CallListContext() { }
+		public void copyFrom(CallListContext ctx) {
+			super.copyFrom(ctx);
+		}
+	}
+	public static class CallWithAttrContext extends CallListContext {
+		public AttrSeqContext attrSeq() {
+			return getRuleContext(AttrSeqContext.class,0);
+		}
+		public List<ExprContext> expr() {
+			return getRuleContexts(ExprContext.class);
+		}
+		public ExprContext expr(int i) {
+			return getRuleContext(ExprContext.class,i);
+		}
+		public CallWithAttrContext(CallListContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterCallWithAttr(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitCallWithAttr(this);
+		}
+	}
+	public static class CallNoAttrContext extends CallListContext {
+		public ExprListContext exprList() {
+			return getRuleContext(ExprListContext.class,0);
+		}
+		public CallNoAttrContext(CallListContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterCallNoAttr(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitCallNoAttr(this);
+		}
+	}
+
+	public final CallListContext callList() throws RecognitionException {
+		CallListContext _localctx = new CallListContext(_ctx, getState());
+		enterRule(_localctx, 6, RULE_callList);
+		try {
+			int _alt;
+			setState(83);
+			_errHandler.sync(this);
+			switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
+			case 1:
+				_localctx = new CallNoAttrContext(_localctx);
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(73);
+				exprList();
+				}
+				break;
+			case 2:
+				_localctx = new CallWithAttrContext(_localctx);
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(79);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,5,_ctx);
+				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+					if ( _alt==1 ) {
+						{
+						{
+						setState(74);
+						expr(0);
+						setState(75);
+						match(T__0);
+						}
+						} 
+					}
+					setState(81);
+					_errHandler.sync(this);
+					_alt = getInterpreter().adaptivePredict(_input,5,_ctx);
+				}
+				setState(82);
+				attrSeq();
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ExprContext extends ParserRuleContext {
+		public ExprContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_expr; }
+	 
+		public ExprContext() { }
+		public void copyFrom(ExprContext ctx) {
+			super.copyFrom(ctx);
+		}
+	}
+	public static class FuncExprContext extends ExprContext {
+		public FuncContext func() {
+			return getRuleContext(FuncContext.class,0);
+		}
+		public FuncExprContext(ExprContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterFuncExpr(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitFuncExpr(this);
+		}
+	}
+	public static class MetaExprContext extends ExprContext {
+		public MetaContext meta() {
+			return getRuleContext(MetaContext.class,0);
+		}
+		public MetaExprContext(ExprContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterMetaExpr(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitMetaExpr(this);
+		}
+	}
+	public static class TensorContext extends ExprContext {
+		public List<ExprContext> expr() {
+			return getRuleContexts(ExprContext.class);
+		}
+		public ExprContext expr(int i) {
+			return getRuleContext(ExprContext.class,i);
+		}
+		public TensorContext(ExprContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterTensor(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitTensor(this);
+		}
+	}
+	public static class GraphContext extends ExprContext {
+		public TerminalNode GRAPH_VAR() { return getToken(RelayParser.GRAPH_VAR, 0); }
+		public List<ExprContext> expr() {
+			return getRuleContexts(ExprContext.class);
+		}
+		public ExprContext expr(int i) {
+			return getRuleContext(ExprContext.class,i);
+		}
+		public GraphContext(ExprContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterGraph(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitGraph(this);
+		}
+	}
+	public static class IdentExprContext extends ExprContext {
+		public IdentContext ident() {
+			return getRuleContext(IdentContext.class,0);
+		}
+		public IdentExprContext(ExprContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterIdentExpr(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitIdentExpr(this);
+		}
+	}
+	public static class StringExprContext extends ExprContext {
+		public TerminalNode QUOTED_STRING() { return getToken(RelayParser.QUOTED_STRING, 0); }
+		public StringExprContext(ExprContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterStringExpr(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitStringExpr(this);
+		}
+	}
+	public static class CallContext extends ExprContext {
+		public ExprContext expr() {
+			return getRuleContext(ExprContext.class,0);
+		}
+		public CallListContext callList() {
+			return getRuleContext(CallListContext.class,0);
+		}
+		public CallContext(ExprContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterCall(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitCall(this);
+		}
+	}
+	public static class NegContext extends ExprContext {
+		public TerminalNode SUB() { return getToken(RelayParser.SUB, 0); }
+		public ExprContext expr() {
+			return getRuleContext(ExprContext.class,0);
+		}
+		public NegContext(ExprContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterNeg(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitNeg(this);
+		}
+	}
+	public static class TupleContext extends ExprContext {
+		public List<ExprContext> expr() {
+			return getRuleContexts(ExprContext.class);
+		}
+		public ExprContext expr(int i) {
+			return getRuleContext(ExprContext.class,i);
+		}
+		public TupleContext(ExprContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterTuple(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitTuple(this);
+		}
+	}
+	public static class ParenContext extends ExprContext {
+		public ExprContext expr() {
+			return getRuleContext(ExprContext.class,0);
+		}
+		public ParenContext(ExprContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterParen(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitParen(this);
+		}
+	}
+	public static class ScalarExprContext extends ExprContext {
+		public ScalarContext scalar() {
+			return getRuleContext(ScalarContext.class,0);
+		}
+		public ScalarExprContext(ExprContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterScalarExpr(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitScalarExpr(this);
+		}
+	}
+	public static class LetContext extends ExprContext {
+		public VarContext var() {
+			return getRuleContext(VarContext.class,0);
+		}
+		public List<ExprContext> expr() {
+			return getRuleContexts(ExprContext.class);
+		}
+		public ExprContext expr(int i) {
+			return getRuleContext(ExprContext.class,i);
+		}
+		public LetContext(ExprContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterLet(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitLet(this);
+		}
+	}
+	public static class ProjectionContext extends ExprContext {
+		public ExprContext expr() {
+			return getRuleContext(ExprContext.class,0);
+		}
+		public TerminalNode NAT() { return getToken(RelayParser.NAT, 0); }
+		public ProjectionContext(ExprContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterProjection(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitProjection(this);
+		}
+	}
+	public static class IfElseContext extends ExprContext {
+		public ExprContext expr() {
+			return getRuleContext(ExprContext.class,0);
+		}
+		public List<BodyContext> body() {
+			return getRuleContexts(BodyContext.class);
+		}
+		public BodyContext body(int i) {
+			return getRuleContext(BodyContext.class,i);
+		}
+		public IfElseContext(ExprContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterIfElse(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitIfElse(this);
+		}
+	}
+	public static class BinOpContext extends ExprContext {
+		public Token op;
+		public List<ExprContext> expr() {
+			return getRuleContexts(ExprContext.class);
+		}
+		public ExprContext expr(int i) {
+			return getRuleContext(ExprContext.class,i);
+		}
+		public TerminalNode MUL() { return getToken(RelayParser.MUL, 0); }
+		public TerminalNode DIV() { return getToken(RelayParser.DIV, 0); }
+		public TerminalNode ADD() { return getToken(RelayParser.ADD, 0); }
+		public TerminalNode SUB() { return getToken(RelayParser.SUB, 0); }
+		public TerminalNode LT() { return getToken(RelayParser.LT, 0); }
+		public TerminalNode GT() { return getToken(RelayParser.GT, 0); }
+		public TerminalNode LE() { return getToken(RelayParser.LE, 0); }
+		public TerminalNode GE() { return getToken(RelayParser.GE, 0); }
+		public TerminalNode EQ() { return getToken(RelayParser.EQ, 0); }
+		public TerminalNode NE() { return getToken(RelayParser.NE, 0); }
+		public BinOpContext(ExprContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterBinOp(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitBinOp(this);
+		}
+	}
+
+	public final ExprContext expr() throws RecognitionException {
+		return expr(0);
+	}
+
+	private ExprContext expr(int _p) throws RecognitionException {
+		ParserRuleContext _parentctx = _ctx;
+		int _parentState = getState();
+		ExprContext _localctx = new ExprContext(_ctx, _parentState);
+		ExprContext _prevctx = _localctx;
+		int _startState = 8;
+		enterRecursionRule(_localctx, 8, RULE_expr, _p);
+		int _la;
+		try {
+			int _alt;
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(151);
+			_errHandler.sync(this);
+			switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
+			case 1:
+				{
+				_localctx = new ParenContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+
+				setState(86);
+				match(T__1);
+				setState(87);
+				expr(0);
+				setState(88);
+				match(T__2);
+				}
+				break;
+			case 2:
+				{
+				_localctx = new ParenContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(90);
+				match(T__3);
+				setState(91);
+				expr(0);
+				setState(92);
+				match(T__4);
+				}
+				break;
+			case 3:
+				{
+				_localctx = new NegContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(94);
+				match(SUB);
+				setState(95);
+				expr(19);
+				}
+				break;
+			case 4:
+				{
+				_localctx = new FuncExprContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(96);
+				func();
+				}
+				break;
+			case 5:
+				{
+				_localctx = new TupleContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(97);
+				match(T__1);
+				setState(98);
+				match(T__2);
+				}
+				break;
+			case 6:
+				{
+				_localctx = new TupleContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(99);
+				match(T__1);
+				setState(100);
+				expr(0);
+				setState(101);
+				match(T__0);
+				setState(102);
+				match(T__2);
+				}
+				break;
+			case 7:
+				{
+				_localctx = new TupleContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(104);
+				match(T__1);
+				setState(105);
+				expr(0);
+				setState(108); 
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+				do {
+					{
+					{
+					setState(106);
+					match(T__0);
+					setState(107);
+					expr(0);
+					}
+					}
+					setState(110); 
+					_errHandler.sync(this);
+					_la = _input.LA(1);
+				} while ( _la==T__0 );
+				setState(112);
+				match(T__2);
+				}
+				break;
+			case 8:
+				{
+				_localctx = new TensorContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(114);
+				match(T__6);
+				setState(123);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__1) | (1L << T__3) | (1L << T__6) | (1L << T__8) | (1L << T__10) | (1L << T__14) | (1L << T__23) | (1L << QUOTED_STRING) | (1L << SUB) | (1L << BOOL_LIT) | (1L << CNAME) | (1L << GLOBAL_VAR) | (1L << LOCAL_VAR) | (1L << GRAPH_VAR) | (1L << FLOAT) | (1L << NAT))) != 0)) {
+					{
+					setState(115);
+					expr(0);
+					setState(120);
+					_errHandler.sync(this);
+					_la = _input.LA(1);
+					while (_la==T__0) {
+						{
+						{
+						setState(116);
+						match(T__0);
+						setState(117);
+						expr(0);
+						}
+						}
+						setState(122);
+						_errHandler.sync(this);
+						_la = _input.LA(1);
+					}
+					}
+				}
+
+				setState(125);
+				match(T__7);
+				}
+				break;
+			case 9:
+				{
+				_localctx = new IfElseContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(126);
+				match(T__8);
+				setState(127);
+				match(T__1);
+				setState(128);
+				expr(0);
+				setState(129);
+				match(T__2);
+				setState(130);
+				body();
+				setState(131);
+				match(T__9);
+				setState(132);
+				body();
+				}
+				break;
+			case 10:
+				{
+				_localctx = new LetContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(134);
+				match(T__10);
+				setState(135);
+				var();
+				setState(136);
+				match(T__11);
+				setState(137);
+				expr(0);
+				setState(138);
+				match(T__12);
+				setState(139);
+				expr(7);
+				}
+				break;
+			case 11:
+				{
+				_localctx = new GraphContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(141);
+				match(GRAPH_VAR);
+				setState(142);
+				match(T__11);
+				setState(143);
+				expr(0);
+				setState(144);
+				match(T__12);
+				setState(145);
+				expr(5);
+				}
+				break;
+			case 12:
+				{
+				_localctx = new IdentExprContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(147);
+				ident();
+				}
+				break;
+			case 13:
+				{
+				_localctx = new ScalarExprContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(148);
+				scalar();
+				}
+				break;
+			case 14:
+				{
+				_localctx = new MetaExprContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(149);
+				meta();
+				}
+				break;
+			case 15:
+				{
+				_localctx = new StringExprContext(_localctx);
+				_ctx = _localctx;
+				_prevctx = _localctx;
+				setState(150);
+				match(QUOTED_STRING);
+				}
+				break;
+			}
+			_ctx.stop = _input.LT(-1);
+			setState(178);
+			_errHandler.sync(this);
+			_alt = getInterpreter().adaptivePredict(_input,12,_ctx);
+			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
+				if ( _alt==1 ) {
+					if ( _parseListeners!=null ) triggerExitRuleEvent();
+					_prevctx = _localctx;
+					{
+					setState(176);
+					_errHandler.sync(this);
+					switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
+					case 1:
+						{
+						_localctx = new BinOpContext(new ExprContext(_parentctx, _parentState));
+						pushNewRecursionContext(_localctx, _startState, RULE_expr);
+						setState(153);
+						if (!(precpred(_ctx, 18))) throw new FailedPredicateException(this, "precpred(_ctx, 18)");
+						setState(154);
+						((BinOpContext)_localctx).op = _input.LT(1);
+						_la = _input.LA(1);
+						if ( !(_la==MUL || _la==DIV) ) {
+							((BinOpContext)_localctx).op = (Token)_errHandler.recoverInline(this);
+						}
+						else {
+							if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
+							_errHandler.reportMatch(this);
+							consume();
+						}
+						setState(155);
+						expr(19);
+						}
+						break;
+					case 2:
+						{
+						_localctx = new BinOpContext(new ExprContext(_parentctx, _parentState));
+						pushNewRecursionContext(_localctx, _startState, RULE_expr);
+						setState(156);
+						if (!(precpred(_ctx, 17))) throw new FailedPredicateException(this, "precpred(_ctx, 17)");
+						setState(157);
+						((BinOpContext)_localctx).op = _input.LT(1);
+						_la = _input.LA(1);
+						if ( !(_la==ADD || _la==SUB) ) {
+							((BinOpContext)_localctx).op = (Token)_errHandler.recoverInline(this);
+						}
+						else {
+							if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
+							_errHandler.reportMatch(this);
+							consume();
+						}
+						setState(158);
+						expr(18);
+						}
+						break;
+					case 3:
+						{
+						_localctx = new BinOpContext(new ExprContext(_parentctx, _parentState));
+						pushNewRecursionContext(_localctx, _startState, RULE_expr);
+						setState(159);
+						if (!(precpred(_ctx, 16))) throw new FailedPredicateException(this, "precpred(_ctx, 16)");
+						setState(160);
+						((BinOpContext)_localctx).op = _input.LT(1);
+						_la = _input.LA(1);
+						if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LT) | (1L << GT) | (1L << LE) | (1L << GE))) != 0)) ) {
+							((BinOpContext)_localctx).op = (Token)_errHandler.recoverInline(this);
+						}
+						else {
+							if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
+							_errHandler.reportMatch(this);
+							consume();
+						}
+						setState(161);
+						expr(17);
+						}
+						break;
+					case 4:
+						{
+						_localctx = new BinOpContext(new ExprContext(_parentctx, _parentState));
+						pushNewRecursionContext(_localctx, _startState, RULE_expr);
+						setState(162);
+						if (!(precpred(_ctx, 15))) throw new FailedPredicateException(this, "precpred(_ctx, 15)");
+						setState(163);
+						((BinOpContext)_localctx).op = _input.LT(1);
+						_la = _input.LA(1);
+						if ( !(_la==EQ || _la==NE) ) {
+							((BinOpContext)_localctx).op = (Token)_errHandler.recoverInline(this);
+						}
+						else {
+							if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
+							_errHandler.reportMatch(this);
+							consume();
+						}
+						setState(164);
+						expr(16);
+						}
+						break;
+					case 5:
+						{
+						_localctx = new LetContext(new ExprContext(_parentctx, _parentState));
+						pushNewRecursionContext(_localctx, _startState, RULE_expr);
+						setState(165);
+						if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
+						setState(166);
+						match(T__13);
+						setState(167);
+						expr(7);
+						}
+						break;
+					case 6:
+						{
+						_localctx = new CallContext(new ExprContext(_parentctx, _parentState));
+						pushNewRecursionContext(_localctx, _startState, RULE_expr);
+						setState(168);
+						if (!(precpred(_ctx, 20))) throw new FailedPredicateException(this, "precpred(_ctx, 20)");
+						setState(169);
+						match(T__1);
+						setState(170);
+						callList();
+						setState(171);
+						match(T__2);
+						}
+						break;
+					case 7:
+						{
+						_localctx = new ProjectionContext(new ExprContext(_parentctx, _parentState));
+						pushNewRecursionContext(_localctx, _startState, RULE_expr);
+						setState(173);
+						if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)");
+						setState(174);
+						match(T__5);
+						setState(175);
+						match(NAT);
+						}
+						break;
+					}
+					} 
+				}
+				setState(180);
+				_errHandler.sync(this);
+				_alt = getInterpreter().adaptivePredict(_input,12,_ctx);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			unrollRecursionContexts(_parentctx);
+		}
+		return _localctx;
+	}
+
+	public static class FuncContext extends ParserRuleContext {
+		public ArgListContext argList() {
+			return getRuleContext(ArgListContext.class,0);
+		}
+		public BodyContext body() {
+			return getRuleContext(BodyContext.class,0);
+		}
+		public TypeParamListContext typeParamList() {
+			return getRuleContext(TypeParamListContext.class,0);
+		}
+		public Type_Context type_() {
+			return getRuleContext(Type_Context.class,0);
+		}
+		public FuncContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_func; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterFunc(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitFunc(this);
+		}
+	}
+
+	public final FuncContext func() throws RecognitionException {
+		FuncContext _localctx = new FuncContext(_ctx, getState());
+		enterRule(_localctx, 10, RULE_func);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(181);
+			match(T__14);
+			setState(183);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			if (_la==T__6) {
+				{
+				setState(182);
+				typeParamList();
+				}
+			}
+
+			setState(185);
+			match(T__1);
+			setState(186);
+			argList();
+			setState(187);
+			match(T__2);
+			setState(190);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			if (_la==T__15) {
+				{
+				setState(188);
+				match(T__15);
+				setState(189);
+				type_();
+				}
+			}
+
+			setState(192);
+			body();
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class DefnContext extends ParserRuleContext {
+		public IdentContext ident() {
+			return getRuleContext(IdentContext.class,0);
+		}
+		public ArgListContext argList() {
+			return getRuleContext(ArgListContext.class,0);
+		}
+		public BodyContext body() {
+			return getRuleContext(BodyContext.class,0);
+		}
+		public TypeParamListContext typeParamList() {
+			return getRuleContext(TypeParamListContext.class,0);
+		}
+		public Type_Context type_() {
+			return getRuleContext(Type_Context.class,0);
+		}
+		public AdtDefnContext adtDefn() {
+			return getRuleContext(AdtDefnContext.class,0);
+		}
+		public DefnContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_defn; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterDefn(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitDefn(this);
+		}
+	}
+
+	public final DefnContext defn() throws RecognitionException {
+		DefnContext _localctx = new DefnContext(_ctx, getState());
+		enterRule(_localctx, 12, RULE_defn);
+		int _la;
+		try {
+			setState(209);
+			_errHandler.sync(this);
+			switch (_input.LA(1)) {
+			case T__16:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(194);
+				match(T__16);
+				setState(195);
+				ident();
+				setState(197);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+				if (_la==T__6) {
+					{
+					setState(196);
+					typeParamList();
+					}
+				}
+
+				setState(199);
+				match(T__1);
+				setState(200);
+				argList();
+				setState(201);
+				match(T__2);
+				setState(204);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+				if (_la==T__15) {
+					{
+					setState(202);
+					match(T__15);
+					setState(203);
+					type_();
+					}
+				}
+
+				setState(206);
+				body();
+				}
+				break;
+			case T__17:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(208);
+				adtDefn();
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class AdtDefnContext extends ParserRuleContext {
+		public TypeIdentContext typeIdent() {
+			return getRuleContext(TypeIdentContext.class,0);
+		}
+		public List<TerminalNode> LOCAL_VAR() { return getTokens(RelayParser.LOCAL_VAR); }
+		public TerminalNode LOCAL_VAR(int i) {
+			return getToken(RelayParser.LOCAL_VAR, i);
+		}
+		public List<AdtVariantContext> adtVariant() {
+			return getRuleContexts(AdtVariantContext.class);
+		}
+		public AdtVariantContext adtVariant(int i) {
+			return getRuleContext(AdtVariantContext.class,i);
+		}
+		public AdtDefnContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_adtDefn; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterAdtDefn(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitAdtDefn(this);
+		}
+	}
+
+	public final AdtDefnContext adtDefn() throws RecognitionException {
+		AdtDefnContext _localctx = new AdtDefnContext(_ctx, getState());
+		enterRule(_localctx, 14, RULE_adtDefn);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(211);
+			match(T__17);
+			setState(212);
+			typeIdent();
+			setState(223);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			if (_la==T__6) {
+				{
+				setState(213);
+				match(T__6);
+				setState(214);
+				match(LOCAL_VAR);
+				setState(219);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+				while (_la==T__0) {
+					{
+					{
+					setState(215);
+					match(T__0);
+					setState(216);
+					match(LOCAL_VAR);
+					}
+					}
+					setState(221);
+					_errHandler.sync(this);
+					_la = _input.LA(1);
+				}
+				setState(222);
+				match(T__7);
+				}
+			}
+
+			setState(225);
+			match(T__11);
+			setState(227); 
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			do {
+				{
+				{
+				setState(226);
+				adtVariant();
+				}
+				}
+				setState(229); 
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			} while ( _la==T__18 );
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class AdtVariantContext extends ParserRuleContext {
+		public TypeIdentContext typeIdent() {
+			return getRuleContext(TypeIdentContext.class,0);
+		}
+		public List<Type_Context> type_() {
+			return getRuleContexts(Type_Context.class);
+		}
+		public Type_Context type_(int i) {
+			return getRuleContext(Type_Context.class,i);
+		}
+		public AdtVariantContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_adtVariant; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterAdtVariant(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitAdtVariant(this);
+		}
+	}
+
+	public final AdtVariantContext adtVariant() throws RecognitionException {
+		AdtVariantContext _localctx = new AdtVariantContext(_ctx, getState());
+		enterRule(_localctx, 16, RULE_adtVariant);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(231);
+			match(T__18);
+			setState(232);
+			typeIdent();
+			setState(244);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			if (_la==T__1) {
+				{
+				setState(233);
+				match(T__1);
+				setState(234);
+				type_();
+				setState(239);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+				while (_la==T__19) {
+					{
+					{
+					setState(235);
+					match(T__19);
+					setState(236);
+					type_();
+					}
+					}
+					setState(241);
+					_errHandler.sync(this);
+					_la = _input.LA(1);
+				}
+				setState(242);
+				match(T__2);
+				}
+			}
+
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ArgListContext extends ParserRuleContext {
+		public ArgListContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_argList; }
+	 
+		public ArgListContext() { }
+		public void copyFrom(ArgListContext ctx) {
+			super.copyFrom(ctx);
+		}
+	}
+	public static class ArgNoAttrContext extends ArgListContext {
+		public VarListContext varList() {
+			return getRuleContext(VarListContext.class,0);
+		}
+		public ArgNoAttrContext(ArgListContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterArgNoAttr(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitArgNoAttr(this);
+		}
+	}
+	public static class ArgWithAttrContext extends ArgListContext {
+		public AttrSeqContext attrSeq() {
+			return getRuleContext(AttrSeqContext.class,0);
+		}
+		public List<VarContext> var() {
+			return getRuleContexts(VarContext.class);
+		}
+		public VarContext var(int i) {
+			return getRuleContext(VarContext.class,i);
+		}
+		public ArgWithAttrContext(ArgListContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterArgWithAttr(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitArgWithAttr(this);
+		}
+	}
+
+	public final ArgListContext argList() throws RecognitionException {
+		ArgListContext _localctx = new ArgListContext(_ctx, getState());
+		enterRule(_localctx, 18, RULE_argList);
+		int _la;
+		try {
+			setState(256);
+			_errHandler.sync(this);
+			switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) {
+			case 1:
+				_localctx = new ArgNoAttrContext(_localctx);
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(246);
+				varList();
+				}
+				break;
+			case 2:
+				_localctx = new ArgWithAttrContext(_localctx);
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(252);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+				while (_la==LOCAL_VAR) {
+					{
+					{
+					setState(247);
+					var();
+					setState(248);
+					match(T__0);
+					}
+					}
+					setState(254);
+					_errHandler.sync(this);
+					_la = _input.LA(1);
+				}
+				setState(255);
+				attrSeq();
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class VarListContext extends ParserRuleContext {
+		public List<VarContext> var() {
+			return getRuleContexts(VarContext.class);
+		}
+		public VarContext var(int i) {
+			return getRuleContext(VarContext.class,i);
+		}
+		public VarListContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_varList; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterVarList(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitVarList(this);
+		}
+	}
+
+	public final VarListContext varList() throws RecognitionException {
+		VarListContext _localctx = new VarListContext(_ctx, getState());
+		enterRule(_localctx, 20, RULE_varList);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(266);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			if (_la==LOCAL_VAR) {
+				{
+				setState(258);
+				var();
+				setState(263);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+				while (_la==T__0) {
+					{
+					{
+					setState(259);
+					match(T__0);
+					setState(260);
+					var();
+					}
+					}
+					setState(265);
+					_errHandler.sync(this);
+					_la = _input.LA(1);
+				}
+				}
+			}
+
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class VarContext extends ParserRuleContext {
+		public TerminalNode LOCAL_VAR() { return getToken(RelayParser.LOCAL_VAR, 0); }
+		public Type_Context type_() {
+			return getRuleContext(Type_Context.class,0);
+		}
+		public VarContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_var; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterVar(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitVar(this);
+		}
+	}
+
+	public final VarContext var() throws RecognitionException {
+		VarContext _localctx = new VarContext(_ctx, getState());
+		enterRule(_localctx, 22, RULE_var);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(268);
+			match(LOCAL_VAR);
+			setState(271);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			if (_la==T__20) {
+				{
+				setState(269);
+				match(T__20);
+				setState(270);
+				type_();
+				}
+			}
+
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class AttrSeqContext extends ParserRuleContext {
+		public List<AttrContext> attr() {
+			return getRuleContexts(AttrContext.class);
+		}
+		public AttrContext attr(int i) {
+			return getRuleContext(AttrContext.class,i);
+		}
+		public AttrSeqContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_attrSeq; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterAttrSeq(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitAttrSeq(this);
+		}
+	}
+
+	public final AttrSeqContext attrSeq() throws RecognitionException {
+		AttrSeqContext _localctx = new AttrSeqContext(_ctx, getState());
+		enterRule(_localctx, 24, RULE_attrSeq);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(273);
+			attr();
+			setState(278);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==T__0) {
+				{
+				{
+				setState(274);
+				match(T__0);
+				setState(275);
+				attr();
+				}
+				}
+				setState(280);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class AttrContext extends ParserRuleContext {
+		public TerminalNode CNAME() { return getToken(RelayParser.CNAME, 0); }
+		public ExprContext expr() {
+			return getRuleContext(ExprContext.class,0);
+		}
+		public AttrContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_attr; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterAttr(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitAttr(this);
+		}
+	}
+
+	public final AttrContext attr() throws RecognitionException {
+		AttrContext _localctx = new AttrContext(_ctx, getState());
+		enterRule(_localctx, 26, RULE_attr);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(281);
+			match(CNAME);
+			setState(282);
+			match(T__11);
+			setState(283);
+			expr(0);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class TypeParamListContext extends ParserRuleContext {
+		public List<IdentContext> ident() {
+			return getRuleContexts(IdentContext.class);
+		}
+		public IdentContext ident(int i) {
+			return getRuleContext(IdentContext.class,i);
+		}
+		public TypeParamListContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_typeParamList; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterTypeParamList(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitTypeParamList(this);
+		}
+	}
+
+	public final TypeParamListContext typeParamList() throws RecognitionException {
+		TypeParamListContext _localctx = new TypeParamListContext(_ctx, getState());
+		enterRule(_localctx, 28, RULE_typeParamList);
+		int _la;
+		try {
+			setState(298);
+			_errHandler.sync(this);
+			switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(285);
+				match(T__6);
+				setState(286);
+				match(T__7);
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(287);
+				match(T__6);
+				setState(288);
+				ident();
+				setState(293);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+				while (_la==T__0) {
+					{
+					{
+					setState(289);
+					match(T__0);
+					setState(290);
+					ident();
+					}
+					}
+					setState(295);
+					_errHandler.sync(this);
+					_la = _input.LA(1);
+				}
+				setState(296);
+				match(T__7);
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class Type_Context extends ParserRuleContext {
+		public Type_Context(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_type_; }
+	 
+		public Type_Context() { }
+		public void copyFrom(Type_Context ctx) {
+			super.copyFrom(ctx);
+		}
+	}
+	public static class IntTypeContext extends Type_Context {
+		public TerminalNode NAT() { return getToken(RelayParser.NAT, 0); }
+		public IntTypeContext(Type_Context ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterIntType(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitIntType(this);
+		}
+	}
+	public static class TupleTypeContext extends Type_Context {
+		public List<Type_Context> type_() {
+			return getRuleContexts(Type_Context.class);
+		}
+		public Type_Context type_(int i) {
+			return getRuleContext(Type_Context.class,i);
+		}
+		public TupleTypeContext(Type_Context ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterTupleType(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitTupleType(this);
+		}
+	}
+	public static class TypeIdentTypeContext extends Type_Context {
+		public TypeIdentContext typeIdent() {
+			return getRuleContext(TypeIdentContext.class,0);
+		}
+		public TypeIdentTypeContext(Type_Context ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterTypeIdentType(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitTypeIdentType(this);
+		}
+	}
+	public static class IncompleteTypeContext extends Type_Context {
+		public IncompleteTypeContext(Type_Context ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterIncompleteType(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitIncompleteType(this);
+		}
+	}
+	public static class TensorTypeContext extends Type_Context {
+		public ShapeListContext shapeList() {
+			return getRuleContext(ShapeListContext.class,0);
+		}
+		public Type_Context type_() {
+			return getRuleContext(Type_Context.class,0);
+		}
+		public TensorTypeContext(Type_Context ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterTensorType(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitTensorType(this);
+		}
+	}
+	public static class FuncTypeContext extends Type_Context {
+		public List<Type_Context> type_() {
+			return getRuleContexts(Type_Context.class);
+		}
+		public Type_Context type_(int i) {
+			return getRuleContext(Type_Context.class,i);
+		}
+		public TypeParamListContext typeParamList() {
+			return getRuleContext(TypeParamListContext.class,0);
+		}
+		public FuncTypeContext(Type_Context ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterFuncType(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitFuncType(this);
+		}
+	}
+
+	public final Type_Context type_() throws RecognitionException {
+		Type_Context _localctx = new Type_Context(_ctx, getState());
+		enterRule(_localctx, 30, RULE_type_);
+		int _la;
+		try {
+			setState(345);
+			_errHandler.sync(this);
+			switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) {
+			case 1:
+				_localctx = new TupleTypeContext(_localctx);
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(300);
+				match(T__1);
+				setState(301);
+				match(T__2);
+				}
+				break;
+			case 2:
+				_localctx = new TupleTypeContext(_localctx);
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(302);
+				match(T__1);
+				setState(303);
+				type_();
+				setState(304);
+				match(T__0);
+				setState(305);
+				match(T__2);
+				}
+				break;
+			case 3:
+				_localctx = new TupleTypeContext(_localctx);
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(307);
+				match(T__1);
+				setState(308);
+				type_();
+				setState(311); 
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+				do {
+					{
+					{
+					setState(309);
+					match(T__0);
+					setState(310);
+					type_();
+					}
+					}
+					setState(313); 
+					_errHandler.sync(this);
+					_la = _input.LA(1);
+				} while ( _la==T__0 );
+				setState(315);
+				match(T__2);
+				}
+				break;
+			case 4:
+				_localctx = new TypeIdentTypeContext(_localctx);
+				enterOuterAlt(_localctx, 4);
+				{
+				setState(317);
+				typeIdent();
+				}
+				break;
+			case 5:
+				_localctx = new TensorTypeContext(_localctx);
+				enterOuterAlt(_localctx, 5);
+				{
+				setState(318);
+				match(T__21);
+				setState(319);
+				match(T__6);
+				setState(320);
+				shapeList();
+				setState(321);
+				match(T__0);
+				setState(322);
+				type_();
+				setState(323);
+				match(T__7);
+				}
+				break;
+			case 6:
+				_localctx = new FuncTypeContext(_localctx);
+				enterOuterAlt(_localctx, 6);
+				{
+				setState(325);
+				match(T__14);
+				setState(327);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+				if (_la==T__6) {
+					{
+					setState(326);
+					typeParamList();
+					}
+				}
+
+				setState(329);
+				match(T__1);
+				setState(338);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__1) | (1L << T__14) | (1L << T__21) | (1L << T__22) | (1L << CNAME) | (1L << NAT))) != 0)) {
+					{
+					setState(330);
+					type_();
+					setState(335);
+					_errHandler.sync(this);
+					_la = _input.LA(1);
+					while (_la==T__0) {
+						{
+						{
+						setState(331);
+						match(T__0);
+						setState(332);
+						type_();
+						}
+						}
+						setState(337);
+						_errHandler.sync(this);
+						_la = _input.LA(1);
+					}
+					}
+				}
+
+				setState(340);
+				match(T__2);
+				setState(341);
+				match(T__15);
+				setState(342);
+				type_();
+				}
+				break;
+			case 7:
+				_localctx = new IncompleteTypeContext(_localctx);
+				enterOuterAlt(_localctx, 7);
+				{
+				setState(343);
+				match(T__22);
+				}
+				break;
+			case 8:
+				_localctx = new IntTypeContext(_localctx);
+				enterOuterAlt(_localctx, 8);
+				{
+				setState(344);
+				match(NAT);
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ShapeListContext extends ParserRuleContext {
+		public List<ShapeContext> shape() {
+			return getRuleContexts(ShapeContext.class);
+		}
+		public ShapeContext shape(int i) {
+			return getRuleContext(ShapeContext.class,i);
+		}
+		public ShapeListContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_shapeList; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterShapeList(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitShapeList(this);
+		}
+	}
+
+	public final ShapeListContext shapeList() throws RecognitionException {
+		ShapeListContext _localctx = new ShapeListContext(_ctx, getState());
+		enterRule(_localctx, 32, RULE_shapeList);
+		int _la;
+		try {
+			setState(360);
+			_errHandler.sync(this);
+			switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) {
+			case 1:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(347);
+				match(T__1);
+				setState(348);
+				shape();
+				setState(351); 
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+				do {
+					{
+					{
+					setState(349);
+					match(T__0);
+					setState(350);
+					shape();
+					}
+					}
+					setState(353); 
+					_errHandler.sync(this);
+					_la = _input.LA(1);
+				} while ( _la==T__0 );
+				setState(355);
+				match(T__2);
+				}
+				break;
+			case 2:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(357);
+				match(T__1);
+				setState(358);
+				match(T__2);
+				}
+				break;
+			case 3:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(359);
+				shape();
+				}
+				break;
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class MetaContext extends ParserRuleContext {
+		public TerminalNode CNAME() { return getToken(RelayParser.CNAME, 0); }
+		public TerminalNode NAT() { return getToken(RelayParser.NAT, 0); }
+		public MetaContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_meta; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterMeta(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitMeta(this);
+		}
+	}
+
+	public final MetaContext meta() throws RecognitionException {
+		MetaContext _localctx = new MetaContext(_ctx, getState());
+		enterRule(_localctx, 34, RULE_meta);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(362);
+			match(T__23);
+			setState(363);
+			match(T__6);
+			setState(364);
+			match(CNAME);
+			setState(365);
+			match(T__7);
+			setState(366);
+			match(T__6);
+			setState(367);
+			match(NAT);
+			setState(368);
+			match(T__7);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ShapeContext extends ParserRuleContext {
+		public ShapeContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_shape; }
+	 
+		public ShapeContext() { }
+		public void copyFrom(ShapeContext ctx) {
+			super.copyFrom(ctx);
+		}
+	}
+	public static class ParensShapeContext extends ShapeContext {
+		public ShapeContext shape() {
+			return getRuleContext(ShapeContext.class,0);
+		}
+		public ParensShapeContext(ShapeContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterParensShape(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitParensShape(this);
+		}
+	}
+	public static class MetaShapeContext extends ShapeContext {
+		public MetaContext meta() {
+			return getRuleContext(MetaContext.class,0);
+		}
+		public MetaShapeContext(ShapeContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterMetaShape(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitMetaShape(this);
+		}
+	}
+	public static class IntShapeContext extends ShapeContext {
+		public TerminalNode NAT() { return getToken(RelayParser.NAT, 0); }
+		public IntShapeContext(ShapeContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterIntShape(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitIntShape(this);
+		}
+	}
+
+	public final ShapeContext shape() throws RecognitionException {
+		ShapeContext _localctx = new ShapeContext(_ctx, getState());
+		enterRule(_localctx, 36, RULE_shape);
+		try {
+			setState(376);
+			_errHandler.sync(this);
+			switch (_input.LA(1)) {
+			case T__23:
+				_localctx = new MetaShapeContext(_localctx);
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(370);
+				meta();
+				}
+				break;
+			case T__1:
+				_localctx = new ParensShapeContext(_localctx);
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(371);
+				match(T__1);
+				setState(372);
+				shape();
+				setState(373);
+				match(T__2);
+				}
+				break;
+			case NAT:
+				_localctx = new IntShapeContext(_localctx);
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(375);
+				match(NAT);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class TypeIdentContext extends ParserRuleContext {
+		public TerminalNode CNAME() { return getToken(RelayParser.CNAME, 0); }
+		public TypeIdentContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_typeIdent; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterTypeIdent(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitTypeIdent(this);
+		}
+	}
+
+	public final TypeIdentContext typeIdent() throws RecognitionException {
+		TypeIdentContext _localctx = new TypeIdentContext(_ctx, getState());
+		enterRule(_localctx, 38, RULE_typeIdent);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(378);
+			match(CNAME);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class BodyContext extends ParserRuleContext {
+		public ExprContext expr() {
+			return getRuleContext(ExprContext.class,0);
+		}
+		public BodyContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_body; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterBody(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitBody(this);
+		}
+	}
+
+	public final BodyContext body() throws RecognitionException {
+		BodyContext _localctx = new BodyContext(_ctx, getState());
+		enterRule(_localctx, 40, RULE_body);
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(380);
+			match(T__3);
+			setState(381);
+			expr(0);
+			setState(382);
+			match(T__4);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class ScalarContext extends ParserRuleContext {
+		public ScalarContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_scalar; }
+	 
+		public ScalarContext() { }
+		public void copyFrom(ScalarContext ctx) {
+			super.copyFrom(ctx);
+		}
+	}
+	public static class ScalarFloatContext extends ScalarContext {
+		public TerminalNode FLOAT() { return getToken(RelayParser.FLOAT, 0); }
+		public ScalarFloatContext(ScalarContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterScalarFloat(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitScalarFloat(this);
+		}
+	}
+	public static class ScalarBoolContext extends ScalarContext {
+		public TerminalNode BOOL_LIT() { return getToken(RelayParser.BOOL_LIT, 0); }
+		public ScalarBoolContext(ScalarContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterScalarBool(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitScalarBool(this);
+		}
+	}
+	public static class ScalarIntContext extends ScalarContext {
+		public TerminalNode NAT() { return getToken(RelayParser.NAT, 0); }
+		public ScalarIntContext(ScalarContext ctx) { copyFrom(ctx); }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterScalarInt(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitScalarInt(this);
+		}
+	}
+
+	public final ScalarContext scalar() throws RecognitionException {
+		ScalarContext _localctx = new ScalarContext(_ctx, getState());
+		enterRule(_localctx, 42, RULE_scalar);
+		try {
+			setState(387);
+			_errHandler.sync(this);
+			switch (_input.LA(1)) {
+			case FLOAT:
+				_localctx = new ScalarFloatContext(_localctx);
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(384);
+				match(FLOAT);
+				}
+				break;
+			case NAT:
+				_localctx = new ScalarIntContext(_localctx);
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(385);
+				match(NAT);
+				}
+				break;
+			case BOOL_LIT:
+				_localctx = new ScalarBoolContext(_localctx);
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(386);
+				match(BOOL_LIT);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public static class IdentContext extends ParserRuleContext {
+		public OpIdentContext opIdent() {
+			return getRuleContext(OpIdentContext.class,0);
+		}
+		public TerminalNode GLOBAL_VAR() { return getToken(RelayParser.GLOBAL_VAR, 0); }
+		public TerminalNode LOCAL_VAR() { return getToken(RelayParser.LOCAL_VAR, 0); }
+		public TerminalNode GRAPH_VAR() { return getToken(RelayParser.GRAPH_VAR, 0); }
+		public IdentContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_ident; }
+		@Override
+		public void enterRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterIdent(this);
+		}
+		@Override
+		public void exitRule(ParseTreeListener listener) {
+			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitIdent(this);
+		}
+	}
+
+	public final IdentContext ident() throws RecognitionException {
+		IdentContext _localctx = new IdentContext(_ctx, getState());
+		enterRule(_localctx, 44, RULE_ident);
+		try {
+			setState(393);
+			_errHandler.sync(this);
+			switch (_input.LA(1)) {
+			case CNAME:
+				enterOuterAlt(_localctx, 1);
+				{
+				setState(389);
+				opIdent();
+				}
+				break;
+			case GLOBAL_VAR:
+				enterOuterAlt(_localctx, 2);
+				{
+				setState(390);
+				match(GLOBAL_VAR);
+				}
+				break;
+			case LOCAL_VAR:
+				enterOuterAlt(_localctx, 3);
+				{
+				setState(391);
+				match(LOCAL_VAR);
+				}
+				break;
+			case GRAPH_VAR:
+				enterOuterAlt(_localctx, 4);
+				{
+				setState(392);
+				match(GRAPH_VAR);
+				}
+				break;
+			default:
+				throw new NoViableAltException(this);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
+	public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
+		switch (ruleIndex) {
+		case 4:
+			return expr_sempred((ExprContext)_localctx, predIndex);
+		}
+		return true;
+	}
+	private boolean expr_sempred(ExprContext _localctx, int predIndex) {
+		switch (predIndex) {
+		case 0:
+			return precpred(_ctx, 18);
+		case 1:
+			return precpred(_ctx, 17);
+		case 2:
+			return precpred(_ctx, 16);
+		case 3:
+			return precpred(_ctx, 15);
+		case 4:
+			return precpred(_ctx, 6);
+		case 5:
+			return precpred(_ctx, 20);
+		case 6:
+			return precpred(_ctx, 10);
+		}
+		return true;
+	}
+
+	public static final String _serializedATN =
+		"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\62\u018e\4\2\t\2"+
+		"\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+
+		"\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
+		"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\3\2\3\2\3"+
+		"\3\3\3\7\3\65\n\3\f\3\16\38\13\3\3\3\5\3;\n\3\3\3\5\3>\n\3\3\3\3\3\3\4"+
+		"\3\4\3\4\7\4E\n\4\f\4\16\4H\13\4\5\4J\n\4\3\5\3\5\3\5\3\5\7\5P\n\5\f\5"+
+		"\16\5S\13\5\3\5\5\5V\n\5\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3"+
+		"\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\6\6o\n\6\r\6\16\6p\3\6"+
+		"\3\6\3\6\3\6\3\6\3\6\7\6y\n\6\f\6\16\6|\13\6\5\6~\n\6\3\6\3\6\3\6\3\6"+
+		"\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3"+
+		"\6\3\6\3\6\3\6\3\6\5\6\u009a\n\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3"+
+		"\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\7\6\u00b3\n\6\f"+
+		"\6\16\6\u00b6\13\6\3\7\3\7\5\7\u00ba\n\7\3\7\3\7\3\7\3\7\3\7\5\7\u00c1"+
+		"\n\7\3\7\3\7\3\b\3\b\3\b\5\b\u00c8\n\b\3\b\3\b\3\b\3\b\3\b\5\b\u00cf\n"+
+		"\b\3\b\3\b\3\b\5\b\u00d4\n\b\3\t\3\t\3\t\3\t\3\t\3\t\7\t\u00dc\n\t\f\t"+
+		"\16\t\u00df\13\t\3\t\5\t\u00e2\n\t\3\t\3\t\6\t\u00e6\n\t\r\t\16\t\u00e7"+
+		"\3\n\3\n\3\n\3\n\3\n\3\n\7\n\u00f0\n\n\f\n\16\n\u00f3\13\n\3\n\3\n\5\n"+
+		"\u00f7\n\n\3\13\3\13\3\13\3\13\7\13\u00fd\n\13\f\13\16\13\u0100\13\13"+
+		"\3\13\5\13\u0103\n\13\3\f\3\f\3\f\7\f\u0108\n\f\f\f\16\f\u010b\13\f\5"+
+		"\f\u010d\n\f\3\r\3\r\3\r\5\r\u0112\n\r\3\16\3\16\3\16\7\16\u0117\n\16"+
+		"\f\16\16\16\u011a\13\16\3\17\3\17\3\17\3\17\3\20\3\20\3\20\3\20\3\20\3"+
+		"\20\7\20\u0126\n\20\f\20\16\20\u0129\13\20\3\20\3\20\5\20\u012d\n\20\3"+
+		"\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\6\21\u013a\n\21"+
+		"\r\21\16\21\u013b\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3"+
+		"\21\3\21\5\21\u014a\n\21\3\21\3\21\3\21\3\21\7\21\u0150\n\21\f\21\16\21"+
+		"\u0153\13\21\5\21\u0155\n\21\3\21\3\21\3\21\3\21\3\21\5\21\u015c\n\21"+
+		"\3\22\3\22\3\22\3\22\6\22\u0162\n\22\r\22\16\22\u0163\3\22\3\22\3\22\3"+
+		"\22\3\22\5\22\u016b\n\22\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\24"+
+		"\3\24\3\24\3\24\3\24\3\24\5\24\u017b\n\24\3\25\3\25\3\26\3\26\3\26\3\26"+
+		"\3\27\3\27\3\27\5\27\u0186\n\27\3\30\3\30\3\30\3\30\5\30\u018c\n\30\3"+
+		"\30\2\3\n\31\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\2\6\3\2 "+
+		"!\3\2\"#\3\2$\'\3\2()\2\u01bc\2\60\3\2\2\2\4\62\3\2\2\2\6I\3\2\2\2\bU"+
+		"\3\2\2\2\n\u0099\3\2\2\2\f\u00b7\3\2\2\2\16\u00d3\3\2\2\2\20\u00d5\3\2"+
+		"\2\2\22\u00e9\3\2\2\2\24\u0102\3\2\2\2\26\u010c\3\2\2\2\30\u010e\3\2\2"+
+		"\2\32\u0113\3\2\2\2\34\u011b\3\2\2\2\36\u012c\3\2\2\2 \u015b\3\2\2\2\""+
+		"\u016a\3\2\2\2$\u016c\3\2\2\2&\u017a\3\2\2\2(\u017c\3\2\2\2*\u017e\3\2"+
+		"\2\2,\u0185\3\2\2\2.\u018b\3\2\2\2\60\61\7+\2\2\61\3\3\2\2\2\62:\7\33"+
+		"\2\2\63\65\5\16\b\2\64\63\3\2\2\2\658\3\2\2\2\66\64\3\2\2\2\66\67\3\2"+
+		"\2\2\67;\3\2\2\28\66\3\2\2\29;\5\n\6\2:\66\3\2\2\2:9\3\2\2\2;=\3\2\2\2"+
+		"<>\7\62\2\2=<\3\2\2\2=>\3\2\2\2>?\3\2\2\2?@\7\2\2\3@\5\3\2\2\2AF\5\n\6"+
+		"\2BC\7\3\2\2CE\5\n\6\2DB\3\2\2\2EH\3\2\2\2FD\3\2\2\2FG\3\2\2\2GJ\3\2\2"+
+		"\2HF\3\2\2\2IA\3\2\2\2IJ\3\2\2\2J\7\3\2\2\2KV\5\6\4\2LM\5\n\6\2MN\7\3"+
+		"\2\2NP\3\2\2\2OL\3\2\2\2PS\3\2\2\2QO\3\2\2\2QR\3\2\2\2RT\3\2\2\2SQ\3\2"+
+		"\2\2TV\5\32\16\2UK\3\2\2\2UQ\3\2\2\2V\t\3\2\2\2WX\b\6\1\2XY\7\4\2\2YZ"+
+		"\5\n\6\2Z[\7\5\2\2[\u009a\3\2\2\2\\]\7\6\2\2]^\5\n\6\2^_\7\7\2\2_\u009a"+
+		"\3\2\2\2`a\7#\2\2a\u009a\5\n\6\25b\u009a\5\f\7\2cd\7\4\2\2d\u009a\7\5"+
+		"\2\2ef\7\4\2\2fg\5\n\6\2gh\7\3\2\2hi\7\5\2\2i\u009a\3\2\2\2jk\7\4\2\2"+
+		"kn\5\n\6\2lm\7\3\2\2mo\5\n\6\2nl\3\2\2\2op\3\2\2\2pn\3\2\2\2pq\3\2\2\2"+
+		"qr\3\2\2\2rs\7\5\2\2s\u009a\3\2\2\2t}\7\t\2\2uz\5\n\6\2vw\7\3\2\2wy\5"+
+		"\n\6\2xv\3\2\2\2y|\3\2\2\2zx\3\2\2\2z{\3\2\2\2{~\3\2\2\2|z\3\2\2\2}u\3"+
+		"\2\2\2}~\3\2\2\2~\177\3\2\2\2\177\u009a\7\n\2\2\u0080\u0081\7\13\2\2\u0081"+
+		"\u0082\7\4\2\2\u0082\u0083\5\n\6\2\u0083\u0084\7\5\2\2\u0084\u0085\5*"+
+		"\26\2\u0085\u0086\7\f\2\2\u0086\u0087\5*\26\2\u0087\u009a\3\2\2\2\u0088"+
+		"\u0089\7\r\2\2\u0089\u008a\5\30\r\2\u008a\u008b\7\16\2\2\u008b\u008c\5"+
+		"\n\6\2\u008c\u008d\7\17\2\2\u008d\u008e\5\n\6\t\u008e\u009a\3\2\2\2\u008f"+
+		"\u0090\7.\2\2\u0090\u0091\7\16\2\2\u0091\u0092\5\n\6\2\u0092\u0093\7\17"+
+		"\2\2\u0093\u0094\5\n\6\7\u0094\u009a\3\2\2\2\u0095\u009a\5.\30\2\u0096"+
+		"\u009a\5,\27\2\u0097\u009a\5$\23\2\u0098\u009a\7\37\2\2\u0099W\3\2\2\2"+
+		"\u0099\\\3\2\2\2\u0099`\3\2\2\2\u0099b\3\2\2\2\u0099c\3\2\2\2\u0099e\3"+
+		"\2\2\2\u0099j\3\2\2\2\u0099t\3\2\2\2\u0099\u0080\3\2\2\2\u0099\u0088\3"+
+		"\2\2\2\u0099\u008f\3\2\2\2\u0099\u0095\3\2\2\2\u0099\u0096\3\2\2\2\u0099"+
+		"\u0097\3\2\2\2\u0099\u0098\3\2\2\2\u009a\u00b4\3\2\2\2\u009b\u009c\f\24"+
+		"\2\2\u009c\u009d\t\2\2\2\u009d\u00b3\5\n\6\25\u009e\u009f\f\23\2\2\u009f"+
+		"\u00a0\t\3\2\2\u00a0\u00b3\5\n\6\24\u00a1\u00a2\f\22\2\2\u00a2\u00a3\t"+
+		"\4\2\2\u00a3\u00b3\5\n\6\23\u00a4\u00a5\f\21\2\2\u00a5\u00a6\t\5\2\2\u00a6"+
+		"\u00b3\5\n\6\22\u00a7\u00a8\f\b\2\2\u00a8\u00a9\7\20\2\2\u00a9\u00b3\5"+
+		"\n\6\t\u00aa\u00ab\f\26\2\2\u00ab\u00ac\7\4\2\2\u00ac\u00ad\5\b\5\2\u00ad"+
+		"\u00ae\7\5\2\2\u00ae\u00b3\3\2\2\2\u00af\u00b0\f\f\2\2\u00b0\u00b1\7\b"+
+		"\2\2\u00b1\u00b3\7\61\2\2\u00b2\u009b\3\2\2\2\u00b2\u009e\3\2\2\2\u00b2"+
+		"\u00a1\3\2\2\2\u00b2\u00a4\3\2\2\2\u00b2\u00a7\3\2\2\2\u00b2\u00aa\3\2"+
+		"\2\2\u00b2\u00af\3\2\2\2\u00b3\u00b6\3\2\2\2\u00b4\u00b2\3\2\2\2\u00b4"+
+		"\u00b5\3\2\2\2\u00b5\13\3\2\2\2\u00b6\u00b4\3\2\2\2\u00b7\u00b9\7\21\2"+
+		"\2\u00b8\u00ba\5\36\20\2\u00b9\u00b8\3\2\2\2\u00b9\u00ba\3\2\2\2\u00ba"+
+		"\u00bb\3\2\2\2\u00bb\u00bc\7\4\2\2\u00bc\u00bd\5\24\13\2\u00bd\u00c0\7"+
+		"\5\2\2\u00be\u00bf\7\22\2\2\u00bf\u00c1\5 \21\2\u00c0\u00be\3\2\2\2\u00c0"+
+		"\u00c1\3\2\2\2\u00c1\u00c2\3\2\2\2\u00c2\u00c3\5*\26\2\u00c3\r\3\2\2\2"+
+		"\u00c4\u00c5\7\23\2\2\u00c5\u00c7\5.\30\2\u00c6\u00c8\5\36\20\2\u00c7"+
+		"\u00c6\3\2\2\2\u00c7\u00c8\3\2\2\2\u00c8\u00c9\3\2\2\2\u00c9\u00ca\7\4"+
+		"\2\2\u00ca\u00cb\5\24\13\2\u00cb\u00ce\7\5\2\2\u00cc\u00cd\7\22\2\2\u00cd"+
+		"\u00cf\5 \21\2\u00ce\u00cc\3\2\2\2\u00ce\u00cf\3\2\2\2\u00cf\u00d0\3\2"+
+		"\2\2\u00d0\u00d1\5*\26\2\u00d1\u00d4\3\2\2\2\u00d2\u00d4\5\20\t\2\u00d3"+
+		"\u00c4\3\2\2\2\u00d3\u00d2\3\2\2\2\u00d4\17\3\2\2\2\u00d5\u00d6\7\24\2"+
+		"\2\u00d6\u00e1\5(\25\2\u00d7\u00d8\7\t\2\2\u00d8\u00dd\7-\2\2\u00d9\u00da"+
+		"\7\3\2\2\u00da\u00dc\7-\2\2\u00db\u00d9\3\2\2\2\u00dc\u00df\3\2\2\2\u00dd"+
+		"\u00db\3\2\2\2\u00dd\u00de\3\2\2\2\u00de\u00e0\3\2\2\2\u00df\u00dd\3\2"+
+		"\2\2\u00e0\u00e2\7\n\2\2\u00e1\u00d7\3\2\2\2\u00e1\u00e2\3\2\2\2\u00e2"+
+		"\u00e3\3\2\2\2\u00e3\u00e5\7\16\2\2\u00e4\u00e6\5\22\n\2\u00e5\u00e4\3"+
+		"\2\2\2\u00e6\u00e7\3\2\2\2\u00e7\u00e5\3\2\2\2\u00e7\u00e8\3\2\2\2\u00e8"+
+		"\21\3\2\2\2\u00e9\u00ea\7\25\2\2\u00ea\u00f6\5(\25\2\u00eb\u00ec\7\4\2"+
+		"\2\u00ec\u00f1\5 \21\2\u00ed\u00ee\7\26\2\2\u00ee\u00f0\5 \21\2\u00ef"+
+		"\u00ed\3\2\2\2\u00f0\u00f3\3\2\2\2\u00f1\u00ef\3\2\2\2\u00f1\u00f2\3\2"+
+		"\2\2\u00f2\u00f4\3\2\2\2\u00f3\u00f1\3\2\2\2\u00f4\u00f5\7\5\2\2\u00f5"+
+		"\u00f7\3\2\2\2\u00f6\u00eb\3\2\2\2\u00f6\u00f7\3\2\2\2\u00f7\23\3\2\2"+
+		"\2\u00f8\u0103\5\26\f\2\u00f9\u00fa\5\30\r\2\u00fa\u00fb\7\3\2\2\u00fb"+
+		"\u00fd\3\2\2\2\u00fc\u00f9\3\2\2\2\u00fd\u0100\3\2\2\2\u00fe\u00fc\3\2"+
+		"\2\2\u00fe\u00ff\3\2\2\2\u00ff\u0101\3\2\2\2\u0100\u00fe\3\2\2\2\u0101"+
+		"\u0103\5\32\16\2\u0102\u00f8\3\2\2\2\u0102\u00fe\3\2\2\2\u0103\25\3\2"+
+		"\2\2\u0104\u0109\5\30\r\2\u0105\u0106\7\3\2\2\u0106\u0108\5\30\r\2\u0107"+
+		"\u0105\3\2\2\2\u0108\u010b\3\2\2\2\u0109\u0107\3\2\2\2\u0109\u010a\3\2"+
+		"\2\2\u010a\u010d\3\2\2\2\u010b\u0109\3\2\2\2\u010c\u0104\3\2\2\2\u010c"+
+		"\u010d\3\2\2\2\u010d\27\3\2\2\2\u010e\u0111\7-\2\2\u010f\u0110\7\27\2"+
+		"\2\u0110\u0112\5 \21\2\u0111\u010f\3\2\2\2\u0111\u0112\3\2\2\2\u0112\31"+
+		"\3\2\2\2\u0113\u0118\5\34\17\2\u0114\u0115\7\3\2\2\u0115\u0117\5\34\17"+
+		"\2\u0116\u0114\3\2\2\2\u0117\u011a\3\2\2\2\u0118\u0116\3\2\2\2\u0118\u0119"+
+		"\3\2\2\2\u0119\33\3\2\2\2\u011a\u0118\3\2\2\2\u011b\u011c\7+\2\2\u011c"+
+		"\u011d\7\16\2\2\u011d\u011e\5\n\6\2\u011e\35\3\2\2\2\u011f\u0120\7\t\2"+
+		"\2\u0120\u012d\7\n\2\2\u0121\u0122\7\t\2\2\u0122\u0127\5.\30\2\u0123\u0124"+
+		"\7\3\2\2\u0124\u0126\5.\30\2\u0125\u0123\3\2\2\2\u0126\u0129\3\2\2\2\u0127"+
+		"\u0125\3\2\2\2\u0127\u0128\3\2\2\2\u0128\u012a\3\2\2\2\u0129\u0127\3\2"+
+		"\2\2\u012a\u012b\7\n\2\2\u012b\u012d\3\2\2\2\u012c\u011f\3\2\2\2\u012c"+
+		"\u0121\3\2\2\2\u012d\37\3\2\2\2\u012e\u012f\7\4\2\2\u012f\u015c\7\5\2"+
+		"\2\u0130\u0131\7\4\2\2\u0131\u0132\5 \21\2\u0132\u0133\7\3\2\2\u0133\u0134"+
+		"\7\5\2\2\u0134\u015c\3\2\2\2\u0135\u0136\7\4\2\2\u0136\u0139\5 \21\2\u0137"+
+		"\u0138\7\3\2\2\u0138\u013a\5 \21\2\u0139\u0137\3\2\2\2\u013a\u013b\3\2"+
+		"\2\2\u013b\u0139\3\2\2\2\u013b\u013c\3\2\2\2\u013c\u013d\3\2\2\2\u013d"+
+		"\u013e\7\5\2\2\u013e\u015c\3\2\2\2\u013f\u015c\5(\25\2\u0140\u0141\7\30"+
+		"\2\2\u0141\u0142\7\t\2\2\u0142\u0143\5\"\22\2\u0143\u0144\7\3\2\2\u0144"+
+		"\u0145\5 \21\2\u0145\u0146\7\n\2\2\u0146\u015c\3\2\2\2\u0147\u0149\7\21"+
+		"\2\2\u0148\u014a\5\36\20\2\u0149\u0148\3\2\2\2\u0149\u014a\3\2\2\2\u014a"+
+		"\u014b\3\2\2\2\u014b\u0154\7\4\2\2\u014c\u0151\5 \21\2\u014d\u014e\7\3"+
+		"\2\2\u014e\u0150\5 \21\2\u014f\u014d\3\2\2\2\u0150\u0153\3\2\2\2\u0151"+
+		"\u014f\3\2\2\2\u0151\u0152\3\2\2\2\u0152\u0155\3\2\2\2\u0153\u0151\3\2"+
+		"\2\2\u0154\u014c\3\2\2\2\u0154\u0155\3\2\2\2\u0155\u0156\3\2\2\2\u0156"+
+		"\u0157\7\5\2\2\u0157\u0158\7\22\2\2\u0158\u015c\5 \21\2\u0159\u015c\7"+
+		"\31\2\2\u015a\u015c\7\61\2\2\u015b\u012e\3\2\2\2\u015b\u0130\3\2\2\2\u015b"+
+		"\u0135\3\2\2\2\u015b\u013f\3\2\2\2\u015b\u0140\3\2\2\2\u015b\u0147\3\2"+
+		"\2\2\u015b\u0159\3\2\2\2\u015b\u015a\3\2\2\2\u015c!\3\2\2\2\u015d\u015e"+
+		"\7\4\2\2\u015e\u0161\5&\24\2\u015f\u0160\7\3\2\2\u0160\u0162\5&\24\2\u0161"+
+		"\u015f\3\2\2\2\u0162\u0163\3\2\2\2\u0163\u0161\3\2\2\2\u0163\u0164\3\2"+
+		"\2\2\u0164\u0165\3\2\2\2\u0165\u0166\7\5\2\2\u0166\u016b\3\2\2\2\u0167"+
+		"\u0168\7\4\2\2\u0168\u016b\7\5\2\2\u0169\u016b\5&\24\2\u016a\u015d\3\2"+
+		"\2\2\u016a\u0167\3\2\2\2\u016a\u0169\3\2\2\2\u016b#\3\2\2\2\u016c\u016d"+
+		"\7\32\2\2\u016d\u016e\7\t\2\2\u016e\u016f\7+\2\2\u016f\u0170\7\n\2\2\u0170"+
+		"\u0171\7\t\2\2\u0171\u0172\7\61\2\2\u0172\u0173\7\n\2\2\u0173%\3\2\2\2"+
+		"\u0174\u017b\5$\23\2\u0175\u0176\7\4\2\2\u0176\u0177\5&\24\2\u0177\u0178"+
+		"\7\5\2\2\u0178\u017b\3\2\2\2\u0179\u017b\7\61\2\2\u017a\u0174\3\2\2\2"+
+		"\u017a\u0175\3\2\2\2\u017a\u0179\3\2\2\2\u017b\'\3\2\2\2\u017c\u017d\7"+
+		"+\2\2\u017d)\3\2\2\2\u017e\u017f\7\6\2\2\u017f\u0180\5\n\6\2\u0180\u0181"+
+		"\7\7\2\2\u0181+\3\2\2\2\u0182\u0186\7\60\2\2\u0183\u0186\7\61\2\2\u0184"+
+		"\u0186\7*\2\2\u0185\u0182\3\2\2\2\u0185\u0183\3\2\2\2\u0185\u0184\3\2"+
+		"\2\2\u0186-\3\2\2\2\u0187\u018c\5\2\2\2\u0188\u018c\7,\2\2\u0189\u018c"+
+		"\7-\2\2\u018a\u018c\7.\2\2\u018b\u0187\3\2\2\2\u018b\u0188\3\2\2\2\u018b"+
+		"\u0189\3\2\2\2\u018b\u018a\3\2\2\2\u018c/\3\2\2\2+\66:=FIQUpz}\u0099\u00b2"+
+		"\u00b4\u00b9\u00c0\u00c7\u00ce\u00d3\u00dd\u00e1\u00e7\u00f1\u00f6\u00fe"+
+		"\u0102\u0109\u010c\u0111\u0118\u0127\u012c\u013b\u0149\u0151\u0154\u015b"+
+		"\u0163\u016a\u017a\u0185\u018b";
+	public static final ATN _ATN =
+		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
+	static {
+		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
+		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
+			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
+		}
+	}
+}
\ No newline at end of file
diff --git a/python/tvm/relay/grammar/py3/RelayLexer.py b/python/tvm/relay/grammar/py3/RelayLexer.py
index 80a0eba0db1a..57505ce0f752 100644
--- a/python/tvm/relay/grammar/py3/RelayLexer.py
+++ b/python/tvm/relay/grammar/py3/RelayLexer.py
@@ -1,153 +1,159 @@
-# Generated from /workspace/python/tvm/relay/grammar/Relay.g4 by ANTLR 4.7.1
+# Generated from /Users/doobs/Code/repo/sampl/tvm/python/tvm/relay/grammar/Relay.g4 by ANTLR 4.7.2
 from antlr4 import *
 from io import StringIO
 from typing.io import TextIO
 import sys
 
 
+
 def serializedATN():
     with StringIO() as buf:
-        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2/")
-        buf.write("\u014a\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7")
+        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\61")
+        buf.write("\u0153\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7")
         buf.write("\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r")
         buf.write("\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23")
         buf.write("\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30")
         buf.write("\4\31\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36")
         buf.write("\t\36\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%")
         buf.write("\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.")
-        buf.write("\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\3\2")
-        buf.write("\3\2\3\3\3\3\3\4\3\4\3\5\3\5\3\6\3\6\3\7\3\7\3\b\3\b\3")
-        buf.write("\t\3\t\3\n\3\n\3\n\3\13\3\13\3\13\3\13\3\13\3\f\3\f\3")
-        buf.write("\f\3\f\3\r\3\r\3\16\3\16\3\17\3\17\3\17\3\20\3\20\3\20")
-        buf.write("\3\21\3\21\3\21\3\22\3\22\3\22\3\22\3\23\3\23\3\24\3\24")
-        buf.write("\3\24\3\24\3\24\3\24\3\24\3\25\3\25\3\26\3\26\3\26\3\26")
-        buf.write("\3\26\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\30\3\30\3\30")
-        buf.write("\3\30\3\30\7\30\u00b1\n\30\f\30\16\30\u00b4\13\30\3\30")
-        buf.write("\3\30\3\30\3\30\3\30\3\31\6\31\u00bc\n\31\r\31\16\31\u00bd")
-        buf.write("\3\31\3\31\3\32\3\32\3\32\3\32\7\32\u00c6\n\32\f\32\16")
-        buf.write("\32\u00c9\13\32\3\32\3\32\3\32\3\32\3\33\3\33\3\33\3\34")
-        buf.write("\3\34\3\34\7\34\u00d5\n\34\f\34\16\34\u00d8\13\34\3\34")
-        buf.write("\3\34\3\35\3\35\3\36\3\36\3\37\3\37\3 \3 \3!\3!\3\"\3")
-        buf.write("\"\3#\3#\3#\3$\3$\3$\3%\3%\3%\3&\3&\3&\3\'\3\'\3\'\3\'")
-        buf.write("\3\'\3\'\3\'\3\'\3\'\5\'\u00fd\n\'\3(\3(\5(\u0101\n(\3")
-        buf.write("(\3(\3(\7(\u0106\n(\f(\16(\u0109\13(\3(\3(\7(\u010d\n")
-        buf.write("(\f(\16(\u0110\13(\3)\3)\3)\3*\3*\3*\3+\3+\3+\3,\3,\3")
-        buf.write(",\3,\3,\3,\3-\3-\3-\5-\u0124\n-\3-\5-\u0127\n-\3.\3.\3")
-        buf.write(".\3/\6/\u012d\n/\r/\16/\u012e\3\60\3\60\5\60\u0133\n\60")
-        buf.write("\3\60\3\60\3\61\3\61\3\62\3\62\3\63\3\63\3\63\3\63\3\63")
-        buf.write("\3\63\3\63\3\63\3\63\3\63\3\63\7\63\u0146\n\63\f\63\16")
-        buf.write("\63\u0149\13\63\5\u00b2\u00c7\u00d6\2\64\3\3\5\4\7\5\t")
-        buf.write("\6\13\7\r\b\17\t\21\n\23\13\25\f\27\r\31\16\33\17\35\20")
-        buf.write("\37\21!\22#\23%\24\'\25)\26+\27-\30/\31\61\32\63\33\65")
-        buf.write("\2\67\349\35;\36=\37? A!C\"E#G$I%K&M\'O(Q)S*U+W,Y\2[-")
-        buf.write("]._\2a\2c\2e/\3\2\b\5\2\13\f\17\17\"\"\4\2\f\f\17\17\4")
-        buf.write("\2GGgg\4\2--//\4\2C\\c|\3\2\62;\2\u0155\2\3\3\2\2\2\2")
-        buf.write("\5\3\2\2\2\2\7\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3")
-        buf.write("\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25\3\2")
-        buf.write("\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2\2")
-        buf.write("\2\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("\2\2\2\2)\3\2\2\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61")
-        buf.write("\3\2\2\2\2\63\3\2\2\2\2\67\3\2\2\2\29\3\2\2\2\2;\3\2\2")
-        buf.write("\2\2=\3\2\2\2\2?\3\2\2\2\2A\3\2\2\2\2C\3\2\2\2\2E\3\2")
-        buf.write("\2\2\2G\3\2\2\2\2I\3\2\2\2\2K\3\2\2\2\2M\3\2\2\2\2O\3")
-        buf.write("\2\2\2\2Q\3\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2W\3\2\2\2\2[")
-        buf.write("\3\2\2\2\2]\3\2\2\2\2e\3\2\2\2\3g\3\2\2\2\5i\3\2\2\2\7")
-        buf.write("k\3\2\2\2\tm\3\2\2\2\13o\3\2\2\2\rq\3\2\2\2\17s\3\2\2")
-        buf.write("\2\21u\3\2\2\2\23w\3\2\2\2\25z\3\2\2\2\27\177\3\2\2\2")
-        buf.write("\31\u0083\3\2\2\2\33\u0085\3\2\2\2\35\u0087\3\2\2\2\37")
-        buf.write("\u008a\3\2\2\2!\u008d\3\2\2\2#\u0090\3\2\2\2%\u0094\3")
-        buf.write("\2\2\2\'\u0096\3\2\2\2)\u009d\3\2\2\2+\u009f\3\2\2\2-")
-        buf.write("\u00a4\3\2\2\2/\u00ab\3\2\2\2\61\u00bb\3\2\2\2\63\u00c1")
-        buf.write("\3\2\2\2\65\u00ce\3\2\2\2\67\u00d1\3\2\2\29\u00db\3\2")
-        buf.write("\2\2;\u00dd\3\2\2\2=\u00df\3\2\2\2?\u00e1\3\2\2\2A\u00e3")
-        buf.write("\3\2\2\2C\u00e5\3\2\2\2E\u00e7\3\2\2\2G\u00ea\3\2\2\2")
-        buf.write("I\u00ed\3\2\2\2K\u00f0\3\2\2\2M\u00fc\3\2\2\2O\u0100\3")
-        buf.write("\2\2\2Q\u0111\3\2\2\2S\u0114\3\2\2\2U\u0117\3\2\2\2W\u011a")
-        buf.write("\3\2\2\2Y\u0120\3\2\2\2[\u0128\3\2\2\2]\u012c\3\2\2\2")
-        buf.write("_\u0130\3\2\2\2a\u0136\3\2\2\2c\u0138\3\2\2\2e\u013a\3")
-        buf.write("\2\2\2gh\7.\2\2h\4\3\2\2\2ij\7*\2\2j\6\3\2\2\2kl\7+\2")
-        buf.write("\2l\b\3\2\2\2mn\7}\2\2n\n\3\2\2\2op\7\177\2\2p\f\3\2\2")
-        buf.write("\2qr\7\60\2\2r\16\3\2\2\2st\7]\2\2t\20\3\2\2\2uv\7_\2")
-        buf.write("\2v\22\3\2\2\2wx\7k\2\2xy\7h\2\2y\24\3\2\2\2z{\7g\2\2")
-        buf.write("{|\7n\2\2|}\7u\2\2}~\7g\2\2~\26\3\2\2\2\177\u0080\7n\2")
-        buf.write("\2\u0080\u0081\7g\2\2\u0081\u0082\7v\2\2\u0082\30\3\2")
-        buf.write("\2\2\u0083\u0084\7?\2\2\u0084\32\3\2\2\2\u0085\u0086\7")
-        buf.write("=\2\2\u0086\34\3\2\2\2\u0087\u0088\7=\2\2\u0088\u0089")
-        buf.write("\7=\2\2\u0089\36\3\2\2\2\u008a\u008b\7h\2\2\u008b\u008c")
-        buf.write("\7p\2\2\u008c \3\2\2\2\u008d\u008e\7/\2\2\u008e\u008f")
-        buf.write("\7@\2\2\u008f\"\3\2\2\2\u0090\u0091\7f\2\2\u0091\u0092")
-        buf.write("\7g\2\2\u0092\u0093\7h\2\2\u0093$\3\2\2\2\u0094\u0095")
-        buf.write("\7<\2\2\u0095&\3\2\2\2\u0096\u0097\7V\2\2\u0097\u0098")
-        buf.write("\7g\2\2\u0098\u0099\7p\2\2\u0099\u009a\7u\2\2\u009a\u009b")
-        buf.write("\7q\2\2\u009b\u009c\7t\2\2\u009c(\3\2\2\2\u009d\u009e")
-        buf.write("\7a\2\2\u009e*\3\2\2\2\u009f\u00a0\7o\2\2\u00a0\u00a1")
-        buf.write("\7g\2\2\u00a1\u00a2\7v\2\2\u00a2\u00a3\7c\2\2\u00a3,\3")
-        buf.write("\2\2\2\u00a4\u00a5\7x\2\2\u00a5\u00a6\7\62\2\2\u00a6\u00a7")
-        buf.write("\7\60\2\2\u00a7\u00a8\7\62\2\2\u00a8\u00a9\7\60\2\2\u00a9")
-        buf.write("\u00aa\7\65\2\2\u00aa.\3\2\2\2\u00ab\u00ac\7\61\2\2\u00ac")
-        buf.write("\u00ad\7,\2\2\u00ad\u00b2\3\2\2\2\u00ae\u00b1\5/\30\2")
-        buf.write("\u00af\u00b1\13\2\2\2\u00b0\u00ae\3\2\2\2\u00b0\u00af")
-        buf.write("\3\2\2\2\u00b1\u00b4\3\2\2\2\u00b2\u00b3\3\2\2\2\u00b2")
-        buf.write("\u00b0\3\2\2\2\u00b3\u00b5\3\2\2\2\u00b4\u00b2\3\2\2\2")
-        buf.write("\u00b5\u00b6\7,\2\2\u00b6\u00b7\7\61\2\2\u00b7\u00b8\3")
-        buf.write("\2\2\2\u00b8\u00b9\b\30\2\2\u00b9\60\3\2\2\2\u00ba\u00bc")
-        buf.write("\t\2\2\2\u00bb\u00ba\3\2\2\2\u00bc\u00bd\3\2\2\2\u00bd")
-        buf.write("\u00bb\3\2\2\2\u00bd\u00be\3\2\2\2\u00be\u00bf\3\2\2\2")
-        buf.write("\u00bf\u00c0\b\31\2\2\u00c0\62\3\2\2\2\u00c1\u00c2\7\61")
-        buf.write("\2\2\u00c2\u00c3\7\61\2\2\u00c3\u00c7\3\2\2\2\u00c4\u00c6")
-        buf.write("\13\2\2\2\u00c5\u00c4\3\2\2\2\u00c6\u00c9\3\2\2\2\u00c7")
-        buf.write("\u00c8\3\2\2\2\u00c7\u00c5\3\2\2\2\u00c8\u00ca\3\2\2\2")
-        buf.write("\u00c9\u00c7\3\2\2\2\u00ca\u00cb\7\f\2\2\u00cb\u00cc\3")
-        buf.write("\2\2\2\u00cc\u00cd\b\32\2\2\u00cd\64\3\2\2\2\u00ce\u00cf")
-        buf.write("\7^\2\2\u00cf\u00d0\7$\2\2\u00d0\66\3\2\2\2\u00d1\u00d6")
-        buf.write("\7$\2\2\u00d2\u00d5\5\65\33\2\u00d3\u00d5\n\3\2\2\u00d4")
-        buf.write("\u00d2\3\2\2\2\u00d4\u00d3\3\2\2\2\u00d5\u00d8\3\2\2\2")
-        buf.write("\u00d6\u00d7\3\2\2\2\u00d6\u00d4\3\2\2\2\u00d7\u00d9\3")
-        buf.write("\2\2\2\u00d8\u00d6\3\2\2\2\u00d9\u00da\7$\2\2\u00da8\3")
-        buf.write("\2\2\2\u00db\u00dc\7,\2\2\u00dc:\3\2\2\2\u00dd\u00de\7")
-        buf.write("\61\2\2\u00de<\3\2\2\2\u00df\u00e0\7-\2\2\u00e0>\3\2\2")
-        buf.write("\2\u00e1\u00e2\7/\2\2\u00e2@\3\2\2\2\u00e3\u00e4\7>\2")
-        buf.write("\2\u00e4B\3\2\2\2\u00e5\u00e6\7@\2\2\u00e6D\3\2\2\2\u00e7")
-        buf.write("\u00e8\7>\2\2\u00e8\u00e9\7?\2\2\u00e9F\3\2\2\2\u00ea")
-        buf.write("\u00eb\7@\2\2\u00eb\u00ec\7?\2\2\u00ecH\3\2\2\2\u00ed")
-        buf.write("\u00ee\7?\2\2\u00ee\u00ef\7?\2\2\u00efJ\3\2\2\2\u00f0")
-        buf.write("\u00f1\7#\2\2\u00f1\u00f2\7?\2\2\u00f2L\3\2\2\2\u00f3")
-        buf.write("\u00f4\7V\2\2\u00f4\u00f5\7t\2\2\u00f5\u00f6\7w\2\2\u00f6")
-        buf.write("\u00fd\7g\2\2\u00f7\u00f8\7H\2\2\u00f8\u00f9\7c\2\2\u00f9")
-        buf.write("\u00fa\7n\2\2\u00fa\u00fb\7u\2\2\u00fb\u00fd\7g\2\2\u00fc")
-        buf.write("\u00f3\3\2\2\2\u00fc\u00f7\3\2\2\2\u00fdN\3\2\2\2\u00fe")
-        buf.write("\u0101\7a\2\2\u00ff\u0101\5a\61\2\u0100\u00fe\3\2\2\2")
-        buf.write("\u0100\u00ff\3\2\2\2\u0101\u0107\3\2\2\2\u0102\u0106\7")
-        buf.write("a\2\2\u0103\u0106\5a\61\2\u0104\u0106\5c\62\2\u0105\u0102")
-        buf.write("\3\2\2\2\u0105\u0103\3\2\2\2\u0105\u0104\3\2\2\2\u0106")
-        buf.write("\u0109\3\2\2\2\u0107\u0105\3\2\2\2\u0107\u0108\3\2\2\2")
-        buf.write("\u0108\u010e\3\2\2\2\u0109\u0107\3\2\2\2\u010a\u010b\7")
-        buf.write("\60\2\2\u010b\u010d\5O(\2\u010c\u010a\3\2\2\2\u010d\u0110")
-        buf.write("\3\2\2\2\u010e\u010c\3\2\2\2\u010e\u010f\3\2\2\2\u010f")
-        buf.write("P\3\2\2\2\u0110\u010e\3\2\2\2\u0111\u0112\7B\2\2\u0112")
-        buf.write("\u0113\5O(\2\u0113R\3\2\2\2\u0114\u0115\7\'\2\2\u0115")
-        buf.write("\u0116\5O(\2\u0116T\3\2\2\2\u0117\u0118\7\'\2\2\u0118")
-        buf.write("\u0119\5]/\2\u0119V\3\2\2\2\u011a\u011b\7k\2\2\u011b\u011c")
-        buf.write("\7p\2\2\u011c\u011d\7v\2\2\u011d\u011e\78\2\2\u011e\u011f")
-        buf.write("\7\66\2\2\u011fX\3\2\2\2\u0120\u0123\5]/\2\u0121\u0122")
-        buf.write("\7\60\2\2\u0122\u0124\5]/\2\u0123\u0121\3\2\2\2\u0123")
-        buf.write("\u0124\3\2\2\2\u0124\u0126\3\2\2\2\u0125\u0127\5_\60\2")
-        buf.write("\u0126\u0125\3\2\2\2\u0126\u0127\3\2\2\2\u0127Z\3\2\2")
-        buf.write("\2\u0128\u0129\5Y-\2\u0129\u012a\7h\2\2\u012a\\\3\2\2")
-        buf.write("\2\u012b\u012d\5c\62\2\u012c\u012b\3\2\2\2\u012d\u012e")
-        buf.write("\3\2\2\2\u012e\u012c\3\2\2\2\u012e\u012f\3\2\2\2\u012f")
-        buf.write("^\3\2\2\2\u0130\u0132\t\4\2\2\u0131\u0133\t\5\2\2\u0132")
-        buf.write("\u0131\3\2\2\2\u0132\u0133\3\2\2\2\u0133\u0134\3\2\2\2")
-        buf.write("\u0134\u0135\5]/\2\u0135`\3\2\2\2\u0136\u0137\t\6\2\2")
-        buf.write("\u0137b\3\2\2\2\u0138\u0139\t\7\2\2\u0139d\3\2\2\2\u013a")
-        buf.write("\u013b\7O\2\2\u013b\u013c\7G\2\2\u013c\u013d\7V\2\2\u013d")
-        buf.write("\u013e\7C\2\2\u013e\u013f\7F\2\2\u013f\u0140\7C\2\2\u0140")
-        buf.write("\u0141\7V\2\2\u0141\u0142\7C\2\2\u0142\u0143\7<\2\2\u0143")
-        buf.write("\u0147\3\2\2\2\u0144\u0146\13\2\2\2\u0145\u0144\3\2\2")
-        buf.write("\2\u0146\u0149\3\2\2\2\u0147\u0145\3\2\2\2\u0147\u0148")
-        buf.write("\3\2\2\2\u0148f\3\2\2\2\u0149\u0147\3\2\2\2\23\2\u00b0")
-        buf.write("\u00b2\u00bd\u00c7\u00d4\u00d6\u00fc\u0100\u0105\u0107")
-        buf.write("\u010e\u0123\u0126\u012e\u0132\u0147\3\b\2\2")
+        buf.write("\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64")
+        buf.write("\t\64\4\65\t\65\3\2\3\2\3\3\3\3\3\4\3\4\3\5\3\5\3\5\3")
+        buf.write("\6\3\6\3\7\3\7\3\b\3\b\3\t\3\t\3\n\3\n\3\13\3\13\3\f\3")
+        buf.write("\f\3\r\3\r\3\r\3\16\3\16\3\16\3\16\3\16\3\17\3\17\3\17")
+        buf.write("\3\17\3\20\3\20\3\21\3\21\3\22\3\22\3\22\3\23\3\23\3\23")
+        buf.write("\3\24\3\24\3\24\3\25\3\25\3\25\3\25\3\26\3\26\3\26\3\26")
+        buf.write("\3\26\3\27\3\27\3\30\3\30\3\31\3\31\3\31\3\31\3\31\3\31")
+        buf.write("\3\31\3\32\3\32\3\33\3\33\3\33\3\33\3\33\3\34\3\34\3\34")
+        buf.write("\3\34\3\34\3\34\3\34\3\35\3\35\3\35\3\35\3\35\7\35\u00c3")
+        buf.write("\n\35\f\35\16\35\u00c6\13\35\3\35\3\35\3\35\3\35\3\35")
+        buf.write("\3\36\6\36\u00ce\n\36\r\36\16\36\u00cf\3\36\3\36\3\37")
+        buf.write("\3\37\3\37\3\37\7\37\u00d8\n\37\f\37\16\37\u00db\13\37")
+        buf.write("\3\37\3\37\3\37\3\37\3 \3 \3 \3!\3!\3!\7!\u00e7\n!\f!")
+        buf.write("\16!\u00ea\13!\3!\3!\3\"\3\"\3#\3#\3$\3$\3%\3%\3&\3&\3")
+        buf.write("\'\3\'\3(\3(\3(\3)\3)\3)\3*\3*\3*\3+\3+\3+\3,\3,\3,\3")
+        buf.write(",\3,\3,\3,\3,\3,\5,\u010f\n,\3-\3-\5-\u0113\n-\3-\3-\3")
+        buf.write("-\7-\u0118\n-\f-\16-\u011b\13-\3-\3-\7-\u011f\n-\f-\16")
+        buf.write("-\u0122\13-\3.\3.\3.\3.\3.\3.\3/\3/\3/\5/\u012d\n/\3/")
+        buf.write("\5/\u0130\n/\3\60\3\60\3\60\3\61\6\61\u0136\n\61\r\61")
+        buf.write("\16\61\u0137\3\62\3\62\5\62\u013c\n\62\3\62\3\62\3\63")
+        buf.write("\3\63\3\64\3\64\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65")
+        buf.write("\3\65\3\65\3\65\7\65\u014f\n\65\f\65\16\65\u0152\13\65")
+        buf.write("\5\u00c4\u00d9\u00e8\2\66\3\3\5\4\7\5\t\6\13\7\r\b\17")
+        buf.write("\t\21\n\23\13\25\f\27\r\31\16\33\17\35\20\37\21!\22#\23")
+        buf.write("%\24\'\25)\26+\27-\30/\31\61\32\63\33\65\34\67\359\36")
+        buf.write(";\37= ?\2A!C\"E#G$I%K&M\'O(Q)S*U+W,Y-[.]\2_/a\60c\2e\2")
+        buf.write("g\2i\61\3\2\b\5\2\13\f\17\17\"\"\4\2\f\f\17\17\4\2GGg")
+        buf.write("g\4\2--//\4\2C\\c|\3\2\62;\2\u015e\2\3\3\2\2\2\2\5\3\2")
+        buf.write("\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("\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2")
+        buf.write("\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2\2\2\2\37")
+        buf.write("\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2\2\'\3\2\2\2")
+        buf.write("\2)\3\2\2\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2")
+        buf.write("\2\2\2\63\3\2\2\2\2\65\3\2\2\2\2\67\3\2\2\2\29\3\2\2\2")
+        buf.write("\2;\3\2\2\2\2=\3\2\2\2\2A\3\2\2\2\2C\3\2\2\2\2E\3\2\2")
+        buf.write("\2\2G\3\2\2\2\2I\3\2\2\2\2K\3\2\2\2\2M\3\2\2\2\2O\3\2")
+        buf.write("\2\2\2Q\3\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2W\3\2\2\2\2Y\3")
+        buf.write("\2\2\2\2[\3\2\2\2\2_\3\2\2\2\2a\3\2\2\2\2i\3\2\2\2\3k")
+        buf.write("\3\2\2\2\5m\3\2\2\2\7o\3\2\2\2\tq\3\2\2\2\13t\3\2\2\2")
+        buf.write("\rv\3\2\2\2\17x\3\2\2\2\21z\3\2\2\2\23|\3\2\2\2\25~\3")
+        buf.write("\2\2\2\27\u0080\3\2\2\2\31\u0082\3\2\2\2\33\u0085\3\2")
+        buf.write("\2\2\35\u008a\3\2\2\2\37\u008e\3\2\2\2!\u0090\3\2\2\2")
+        buf.write("#\u0092\3\2\2\2%\u0095\3\2\2\2\'\u0098\3\2\2\2)\u009b")
+        buf.write("\3\2\2\2+\u009f\3\2\2\2-\u00a4\3\2\2\2/\u00a6\3\2\2\2")
+        buf.write("\61\u00a8\3\2\2\2\63\u00af\3\2\2\2\65\u00b1\3\2\2\2\67")
+        buf.write("\u00b6\3\2\2\29\u00bd\3\2\2\2;\u00cd\3\2\2\2=\u00d3\3")
+        buf.write("\2\2\2?\u00e0\3\2\2\2A\u00e3\3\2\2\2C\u00ed\3\2\2\2E\u00ef")
+        buf.write("\3\2\2\2G\u00f1\3\2\2\2I\u00f3\3\2\2\2K\u00f5\3\2\2\2")
+        buf.write("M\u00f7\3\2\2\2O\u00f9\3\2\2\2Q\u00fc\3\2\2\2S\u00ff\3")
+        buf.write("\2\2\2U\u0102\3\2\2\2W\u010e\3\2\2\2Y\u0112\3\2\2\2[\u0123")
+        buf.write("\3\2\2\2]\u0129\3\2\2\2_\u0131\3\2\2\2a\u0135\3\2\2\2")
+        buf.write("c\u0139\3\2\2\2e\u013f\3\2\2\2g\u0141\3\2\2\2i\u0143\3")
+        buf.write("\2\2\2kl\7B\2\2l\4\3\2\2\2mn\7\'\2\2n\6\3\2\2\2op\7]\2")
+        buf.write("\2p\b\3\2\2\2qr\7.\2\2rs\7\"\2\2s\n\3\2\2\2tu\7_\2\2u")
+        buf.write("\f\3\2\2\2vw\7.\2\2w\16\3\2\2\2xy\7*\2\2y\20\3\2\2\2z")
+        buf.write("{\7+\2\2{\22\3\2\2\2|}\7}\2\2}\24\3\2\2\2~\177\7\177\2")
+        buf.write("\2\177\26\3\2\2\2\u0080\u0081\7\60\2\2\u0081\30\3\2\2")
+        buf.write("\2\u0082\u0083\7k\2\2\u0083\u0084\7h\2\2\u0084\32\3\2")
+        buf.write("\2\2\u0085\u0086\7g\2\2\u0086\u0087\7n\2\2\u0087\u0088")
+        buf.write("\7u\2\2\u0088\u0089\7g\2\2\u0089\34\3\2\2\2\u008a\u008b")
+        buf.write("\7n\2\2\u008b\u008c\7g\2\2\u008c\u008d\7v\2\2\u008d\36")
+        buf.write("\3\2\2\2\u008e\u008f\7?\2\2\u008f \3\2\2\2\u0090\u0091")
+        buf.write("\7=\2\2\u0091\"\3\2\2\2\u0092\u0093\7=\2\2\u0093\u0094")
+        buf.write("\7=\2\2\u0094$\3\2\2\2\u0095\u0096\7h\2\2\u0096\u0097")
+        buf.write("\7p\2\2\u0097&\3\2\2\2\u0098\u0099\7/\2\2\u0099\u009a")
+        buf.write("\7@\2\2\u009a(\3\2\2\2\u009b\u009c\7f\2\2\u009c\u009d")
+        buf.write("\7g\2\2\u009d\u009e\7h\2\2\u009e*\3\2\2\2\u009f\u00a0")
+        buf.write("\7v\2\2\u00a0\u00a1\7{\2\2\u00a1\u00a2\7r\2\2\u00a2\u00a3")
+        buf.write("\7g\2\2\u00a3,\3\2\2\2\u00a4\u00a5\7~\2\2\u00a5.\3\2\2")
+        buf.write("\2\u00a6\u00a7\7<\2\2\u00a7\60\3\2\2\2\u00a8\u00a9\7V")
+        buf.write("\2\2\u00a9\u00aa\7g\2\2\u00aa\u00ab\7p\2\2\u00ab\u00ac")
+        buf.write("\7u\2\2\u00ac\u00ad\7q\2\2\u00ad\u00ae\7t\2\2\u00ae\62")
+        buf.write("\3\2\2\2\u00af\u00b0\7a\2\2\u00b0\64\3\2\2\2\u00b1\u00b2")
+        buf.write("\7o\2\2\u00b2\u00b3\7g\2\2\u00b3\u00b4\7v\2\2\u00b4\u00b5")
+        buf.write("\7c\2\2\u00b5\66\3\2\2\2\u00b6\u00b7\7x\2\2\u00b7\u00b8")
+        buf.write("\7\62\2\2\u00b8\u00b9\7\60\2\2\u00b9\u00ba\7\62\2\2\u00ba")
+        buf.write("\u00bb\7\60\2\2\u00bb\u00bc\7\65\2\2\u00bc8\3\2\2\2\u00bd")
+        buf.write("\u00be\7\61\2\2\u00be\u00bf\7,\2\2\u00bf\u00c4\3\2\2\2")
+        buf.write("\u00c0\u00c3\59\35\2\u00c1\u00c3\13\2\2\2\u00c2\u00c0")
+        buf.write("\3\2\2\2\u00c2\u00c1\3\2\2\2\u00c3\u00c6\3\2\2\2\u00c4")
+        buf.write("\u00c5\3\2\2\2\u00c4\u00c2\3\2\2\2\u00c5\u00c7\3\2\2\2")
+        buf.write("\u00c6\u00c4\3\2\2\2\u00c7\u00c8\7,\2\2\u00c8\u00c9\7")
+        buf.write("\61\2\2\u00c9\u00ca\3\2\2\2\u00ca\u00cb\b\35\2\2\u00cb")
+        buf.write(":\3\2\2\2\u00cc\u00ce\t\2\2\2\u00cd\u00cc\3\2\2\2\u00ce")
+        buf.write("\u00cf\3\2\2\2\u00cf\u00cd\3\2\2\2\u00cf\u00d0\3\2\2\2")
+        buf.write("\u00d0\u00d1\3\2\2\2\u00d1\u00d2\b\36\2\2\u00d2<\3\2\2")
+        buf.write("\2\u00d3\u00d4\7\61\2\2\u00d4\u00d5\7\61\2\2\u00d5\u00d9")
+        buf.write("\3\2\2\2\u00d6\u00d8\13\2\2\2\u00d7\u00d6\3\2\2\2\u00d8")
+        buf.write("\u00db\3\2\2\2\u00d9\u00da\3\2\2\2\u00d9\u00d7\3\2\2\2")
+        buf.write("\u00da\u00dc\3\2\2\2\u00db\u00d9\3\2\2\2\u00dc\u00dd\7")
+        buf.write("\f\2\2\u00dd\u00de\3\2\2\2\u00de\u00df\b\37\2\2\u00df")
+        buf.write(">\3\2\2\2\u00e0\u00e1\7^\2\2\u00e1\u00e2\7$\2\2\u00e2")
+        buf.write("@\3\2\2\2\u00e3\u00e8\7$\2\2\u00e4\u00e7\5? \2\u00e5\u00e7")
+        buf.write("\n\3\2\2\u00e6\u00e4\3\2\2\2\u00e6\u00e5\3\2\2\2\u00e7")
+        buf.write("\u00ea\3\2\2\2\u00e8\u00e9\3\2\2\2\u00e8\u00e6\3\2\2\2")
+        buf.write("\u00e9\u00eb\3\2\2\2\u00ea\u00e8\3\2\2\2\u00eb\u00ec\7")
+        buf.write("$\2\2\u00ecB\3\2\2\2\u00ed\u00ee\7,\2\2\u00eeD\3\2\2\2")
+        buf.write("\u00ef\u00f0\7\61\2\2\u00f0F\3\2\2\2\u00f1\u00f2\7-\2")
+        buf.write("\2\u00f2H\3\2\2\2\u00f3\u00f4\7/\2\2\u00f4J\3\2\2\2\u00f5")
+        buf.write("\u00f6\7>\2\2\u00f6L\3\2\2\2\u00f7\u00f8\7@\2\2\u00f8")
+        buf.write("N\3\2\2\2\u00f9\u00fa\7>\2\2\u00fa\u00fb\7?\2\2\u00fb")
+        buf.write("P\3\2\2\2\u00fc\u00fd\7@\2\2\u00fd\u00fe\7?\2\2\u00fe")
+        buf.write("R\3\2\2\2\u00ff\u0100\7?\2\2\u0100\u0101\7?\2\2\u0101")
+        buf.write("T\3\2\2\2\u0102\u0103\7#\2\2\u0103\u0104\7?\2\2\u0104")
+        buf.write("V\3\2\2\2\u0105\u0106\7V\2\2\u0106\u0107\7t\2\2\u0107")
+        buf.write("\u0108\7w\2\2\u0108\u010f\7g\2\2\u0109\u010a\7H\2\2\u010a")
+        buf.write("\u010b\7c\2\2\u010b\u010c\7n\2\2\u010c\u010d\7u\2\2\u010d")
+        buf.write("\u010f\7g\2\2\u010e\u0105\3\2\2\2\u010e\u0109\3\2\2\2")
+        buf.write("\u010fX\3\2\2\2\u0110\u0113\7a\2\2\u0111\u0113\5e\63\2")
+        buf.write("\u0112\u0110\3\2\2\2\u0112\u0111\3\2\2\2\u0113\u0119\3")
+        buf.write("\2\2\2\u0114\u0118\7a\2\2\u0115\u0118\5e\63\2\u0116\u0118")
+        buf.write("\5g\64\2\u0117\u0114\3\2\2\2\u0117\u0115\3\2\2\2\u0117")
+        buf.write("\u0116\3\2\2\2\u0118\u011b\3\2\2\2\u0119\u0117\3\2\2\2")
+        buf.write("\u0119\u011a\3\2\2\2\u011a\u0120\3\2\2\2\u011b\u0119\3")
+        buf.write("\2\2\2\u011c\u011d\7\60\2\2\u011d\u011f\5Y-\2\u011e\u011c")
+        buf.write("\3\2\2\2\u011f\u0122\3\2\2\2\u0120\u011e\3\2\2\2\u0120")
+        buf.write("\u0121\3\2\2\2\u0121Z\3\2\2\2\u0122\u0120\3\2\2\2\u0123")
+        buf.write("\u0124\7k\2\2\u0124\u0125\7p\2\2\u0125\u0126\7v\2\2\u0126")
+        buf.write("\u0127\78\2\2\u0127\u0128\7\66\2\2\u0128\\\3\2\2\2\u0129")
+        buf.write("\u012c\5a\61\2\u012a\u012b\7\60\2\2\u012b\u012d\5a\61")
+        buf.write("\2\u012c\u012a\3\2\2\2\u012c\u012d\3\2\2\2\u012d\u012f")
+        buf.write("\3\2\2\2\u012e\u0130\5c\62\2\u012f\u012e\3\2\2\2\u012f")
+        buf.write("\u0130\3\2\2\2\u0130^\3\2\2\2\u0131\u0132\5]/\2\u0132")
+        buf.write("\u0133\7h\2\2\u0133`\3\2\2\2\u0134\u0136\5g\64\2\u0135")
+        buf.write("\u0134\3\2\2\2\u0136\u0137\3\2\2\2\u0137\u0135\3\2\2\2")
+        buf.write("\u0137\u0138\3\2\2\2\u0138b\3\2\2\2\u0139\u013b\t\4\2")
+        buf.write("\2\u013a\u013c\t\5\2\2\u013b\u013a\3\2\2\2\u013b\u013c")
+        buf.write("\3\2\2\2\u013c\u013d\3\2\2\2\u013d\u013e\5a\61\2\u013e")
+        buf.write("d\3\2\2\2\u013f\u0140\t\6\2\2\u0140f\3\2\2\2\u0141\u0142")
+        buf.write("\t\7\2\2\u0142h\3\2\2\2\u0143\u0144\7O\2\2\u0144\u0145")
+        buf.write("\7G\2\2\u0145\u0146\7V\2\2\u0146\u0147\7C\2\2\u0147\u0148")
+        buf.write("\7F\2\2\u0148\u0149\7C\2\2\u0149\u014a\7V\2\2\u014a\u014b")
+        buf.write("\7C\2\2\u014b\u014c\7<\2\2\u014c\u0150\3\2\2\2\u014d\u014f")
+        buf.write("\13\2\2\2\u014e\u014d\3\2\2\2\u014f\u0152\3\2\2\2\u0150")
+        buf.write("\u014e\3\2\2\2\u0150\u0151\3\2\2\2\u0151j\3\2\2\2\u0152")
+        buf.write("\u0150\3\2\2\2\23\2\u00c2\u00c4\u00cf\u00d9\u00e6\u00e8")
+        buf.write("\u010e\u0112\u0117\u0119\u0120\u012c\u012f\u0137\u013b")
+        buf.write("\u0150\3\b\2\2")
         return buf.getvalue()
 
 
@@ -178,62 +184,64 @@ class RelayLexer(Lexer):
     T__18 = 19
     T__19 = 20
     T__20 = 21
-    SEMVER = 22
-    COMMENT = 23
-    WS = 24
-    LINE_COMMENT = 25
-    QUOTED_STRING = 26
-    MUL = 27
-    DIV = 28
-    ADD = 29
-    SUB = 30
-    LT = 31
-    GT = 32
-    LE = 33
-    GE = 34
-    EQ = 35
-    NE = 36
-    BOOL_LIT = 37
-    CNAME = 38
-    GLOBAL_VAR = 39
-    LOCAL_VAR = 40
-    GRAPH_VAR = 41
-    DATATYPE = 42
-    FLOAT = 43
-    NAT = 44
-    METADATA = 45
+    T__21 = 22
+    T__22 = 23
+    T__23 = 24
+    T__24 = 25
+    T__25 = 26
+    SEMVER = 27
+    COMMENT = 28
+    WS = 29
+    LINE_COMMENT = 30
+    QUOTED_STRING = 31
+    MUL = 32
+    DIV = 33
+    ADD = 34
+    SUB = 35
+    LT = 36
+    GT = 37
+    LE = 38
+    GE = 39
+    EQ = 40
+    NE = 41
+    BOOL_LIT = 42
+    CNAME = 43
+    DATATYPE = 44
+    FLOAT = 45
+    NAT = 46
+    METADATA = 47
 
     channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ]
 
     modeNames = [ "DEFAULT_MODE" ]
 
     literalNames = [ "<INVALID>",
-            "','", "'('", "')'", "'{'", "'}'", "'.'", "'['", "']'", "'if'", 
-            "'else'", "'let'", "'='", "';'", "';;'", "'fn'", "'->'", "'def'", 
-            "':'", "'Tensor'", "'_'", "'meta'", "'v0.0.3'", "'*'", "'/'", 
-            "'+'", "'-'", "'<'", "'>'", "'<='", "'>='", "'=='", "'!='", 
-            "'int64'" ]
+            "'@'", "'%'", "'['", "', '", "']'", "','", "'('", "')'", "'{'", 
+            "'}'", "'.'", "'if'", "'else'", "'let'", "'='", "';'", "';;'", 
+            "'fn'", "'->'", "'def'", "'type'", "'|'", "':'", "'Tensor'", 
+            "'_'", "'meta'", "'v0.0.3'", "'*'", "'/'", "'+'", "'-'", "'<'", 
+            "'>'", "'<='", "'>='", "'=='", "'!='", "'int64'" ]
 
     symbolicNames = [ "<INVALID>",
             "SEMVER", "COMMENT", "WS", "LINE_COMMENT", "QUOTED_STRING", 
             "MUL", "DIV", "ADD", "SUB", "LT", "GT", "LE", "GE", "EQ", "NE", 
-            "BOOL_LIT", "CNAME", "GLOBAL_VAR", "LOCAL_VAR", "GRAPH_VAR", 
-            "DATATYPE", "FLOAT", "NAT", "METADATA" ]
+            "BOOL_LIT", "CNAME", "DATATYPE", "FLOAT", "NAT", "METADATA" ]
 
     ruleNames = [ "T__0", "T__1", "T__2", "T__3", "T__4", "T__5", "T__6", 
                   "T__7", "T__8", "T__9", "T__10", "T__11", "T__12", "T__13", 
                   "T__14", "T__15", "T__16", "T__17", "T__18", "T__19", 
-                  "T__20", "SEMVER", "COMMENT", "WS", "LINE_COMMENT", "ESCAPED_QUOTE", 
+                  "T__20", "T__21", "T__22", "T__23", "T__24", "T__25", 
+                  "SEMVER", "COMMENT", "WS", "LINE_COMMENT", "ESCAPED_QUOTE", 
                   "QUOTED_STRING", "MUL", "DIV", "ADD", "SUB", "LT", "GT", 
-                  "LE", "GE", "EQ", "NE", "BOOL_LIT", "CNAME", "GLOBAL_VAR", 
-                  "LOCAL_VAR", "GRAPH_VAR", "DATATYPE", "PREFLOAT", "FLOAT", 
-                  "NAT", "EXP", "LETTER", "DIGIT", "METADATA" ]
+                  "LE", "GE", "EQ", "NE", "BOOL_LIT", "CNAME", "DATATYPE", 
+                  "PREFLOAT", "FLOAT", "NAT", "EXP", "LETTER", "DIGIT", 
+                  "METADATA" ]
 
     grammarFileName = "Relay.g4"
 
     def __init__(self, input=None, output:TextIO = sys.stdout):
         super().__init__(input, output)
-        self.checkVersion("4.7.1")
+        self.checkVersion("4.7.2")
         self._interp = LexerATNSimulator(self, self.atn, self.decisionsToDFA, PredictionContextCache())
         self._actions = None
         self._predicates = None
diff --git a/python/tvm/relay/grammar/py3/RelayParser.py b/python/tvm/relay/grammar/py3/RelayParser.py
index a489580175d3..c6cf63a5ee25 100644
--- a/python/tvm/relay/grammar/py3/RelayParser.py
+++ b/python/tvm/relay/grammar/py3/RelayParser.py
@@ -1,179 +1,217 @@
-# Generated from /workspace/python/tvm/relay/grammar/Relay.g4 by ANTLR 4.7.1
+# Generated from /Users/doobs/Code/repo/sampl/tvm/python/tvm/relay/grammar/Relay.g4 by ANTLR 4.7.2
 # encoding: utf-8
 from antlr4 import *
 from io import StringIO
 from typing.io import TextIO
 import sys
 
+
 def serializedATN():
     with StringIO() as buf:
-        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3/")
-        buf.write("\u0164\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
+        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\61")
+        buf.write("\u01a8\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
         buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
         buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
-        buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\3\2\3\2\3\3\3\3\7\3\61")
-        buf.write("\n\3\f\3\16\3\64\13\3\3\3\5\3\67\n\3\3\3\5\3:\n\3\3\3")
-        buf.write("\3\3\3\4\3\4\3\4\7\4A\n\4\f\4\16\4D\13\4\5\4F\n\4\3\5")
-        buf.write("\3\5\3\5\3\5\7\5L\n\5\f\5\16\5O\13\5\3\5\5\5R\n\5\3\6")
-        buf.write("\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3")
-        buf.write("\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\6\6k\n\6\r\6\16\6l")
-        buf.write("\3\6\3\6\3\6\3\6\3\6\3\6\7\6u\n\6\f\6\16\6x\13\6\5\6z")
-        buf.write("\n\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3")
-        buf.write("\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6")
-        buf.write("\5\6\u0096\n\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6")
-        buf.write("\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\7")
-        buf.write("\6\u00af\n\6\f\6\16\6\u00b2\13\6\3\7\3\7\5\7\u00b6\n\7")
-        buf.write("\3\7\3\7\3\7\3\7\3\7\5\7\u00bd\n\7\3\7\3\7\3\b\3\b\3\b")
-        buf.write("\5\b\u00c4\n\b\3\b\3\b\3\b\3\b\3\b\5\b\u00cb\n\b\3\b\3")
-        buf.write("\b\3\t\3\t\3\t\3\t\7\t\u00d3\n\t\f\t\16\t\u00d6\13\t\3")
-        buf.write("\t\5\t\u00d9\n\t\3\n\3\n\3\n\7\n\u00de\n\n\f\n\16\n\u00e1")
-        buf.write("\13\n\5\n\u00e3\n\n\3\13\3\13\3\13\5\13\u00e8\n\13\3\f")
-        buf.write("\3\f\3\f\7\f\u00ed\n\f\f\f\16\f\u00f0\13\f\3\r\3\r\3\r")
-        buf.write("\3\r\3\16\3\16\3\16\3\16\3\16\3\16\7\16\u00fc\n\16\f\16")
-        buf.write("\16\16\u00ff\13\16\3\16\3\16\5\16\u0103\n\16\3\17\3\17")
-        buf.write("\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17\6\17\u0110")
-        buf.write("\n\17\r\17\16\17\u0111\3\17\3\17\3\17\3\17\3\17\3\17\3")
-        buf.write("\17\3\17\3\17\3\17\3\17\3\17\5\17\u0120\n\17\3\17\3\17")
-        buf.write("\3\17\3\17\7\17\u0126\n\17\f\17\16\17\u0129\13\17\5\17")
-        buf.write("\u012b\n\17\3\17\3\17\3\17\3\17\3\17\5\17\u0132\n\17\3")
-        buf.write("\20\3\20\3\20\3\20\6\20\u0138\n\20\r\20\16\20\u0139\3")
-        buf.write("\20\3\20\3\20\3\20\3\20\5\20\u0141\n\20\3\21\3\21\3\21")
-        buf.write("\3\21\3\21\3\21\3\21\3\21\3\22\3\22\3\22\3\22\3\22\3\22")
-        buf.write("\5\22\u0151\n\22\3\23\3\23\3\24\3\24\3\24\3\24\3\25\3")
-        buf.write("\25\3\25\5\25\u015c\n\25\3\26\3\26\3\26\3\26\5\26\u0162")
-        buf.write("\n\26\3\26\2\3\n\27\2\4\6\b\n\f\16\20\22\24\26\30\32\34")
-        buf.write("\36 \"$&(*\2\6\3\2\35\36\3\2\37 \3\2!$\3\2%&\2\u018e\2")
-        buf.write(",\3\2\2\2\4.\3\2\2\2\6E\3\2\2\2\bQ\3\2\2\2\n\u0095\3\2")
-        buf.write("\2\2\f\u00b3\3\2\2\2\16\u00c0\3\2\2\2\20\u00d8\3\2\2\2")
-        buf.write("\22\u00e2\3\2\2\2\24\u00e4\3\2\2\2\26\u00e9\3\2\2\2\30")
-        buf.write("\u00f1\3\2\2\2\32\u0102\3\2\2\2\34\u0131\3\2\2\2\36\u0140")
-        buf.write("\3\2\2\2 \u0142\3\2\2\2\"\u0150\3\2\2\2$\u0152\3\2\2\2")
-        buf.write("&\u0154\3\2\2\2(\u015b\3\2\2\2*\u0161\3\2\2\2,-\7(\2\2")
-        buf.write("-\3\3\2\2\2.\66\7\30\2\2/\61\5\16\b\2\60/\3\2\2\2\61\64")
-        buf.write("\3\2\2\2\62\60\3\2\2\2\62\63\3\2\2\2\63\67\3\2\2\2\64")
-        buf.write("\62\3\2\2\2\65\67\5\n\6\2\66\62\3\2\2\2\66\65\3\2\2\2")
-        buf.write("\679\3\2\2\28:\7/\2\298\3\2\2\29:\3\2\2\2:;\3\2\2\2;<")
-        buf.write("\7\2\2\3<\5\3\2\2\2=B\5\n\6\2>?\7\3\2\2?A\5\n\6\2@>\3")
-        buf.write("\2\2\2AD\3\2\2\2B@\3\2\2\2BC\3\2\2\2CF\3\2\2\2DB\3\2\2")
-        buf.write("\2E=\3\2\2\2EF\3\2\2\2F\7\3\2\2\2GR\5\6\4\2HI\5\n\6\2")
-        buf.write("IJ\7\3\2\2JL\3\2\2\2KH\3\2\2\2LO\3\2\2\2MK\3\2\2\2MN\3")
-        buf.write("\2\2\2NP\3\2\2\2OM\3\2\2\2PR\5\26\f\2QG\3\2\2\2QM\3\2")
-        buf.write("\2\2R\t\3\2\2\2ST\b\6\1\2TU\7\4\2\2UV\5\n\6\2VW\7\5\2")
-        buf.write("\2W\u0096\3\2\2\2XY\7\6\2\2YZ\5\n\6\2Z[\7\7\2\2[\u0096")
-        buf.write("\3\2\2\2\\]\7 \2\2]\u0096\5\n\6\25^\u0096\5\f\7\2_`\7")
-        buf.write("\4\2\2`\u0096\7\5\2\2ab\7\4\2\2bc\5\n\6\2cd\7\3\2\2de")
-        buf.write("\7\5\2\2e\u0096\3\2\2\2fg\7\4\2\2gj\5\n\6\2hi\7\3\2\2")
-        buf.write("ik\5\n\6\2jh\3\2\2\2kl\3\2\2\2lj\3\2\2\2lm\3\2\2\2mn\3")
-        buf.write("\2\2\2no\7\5\2\2o\u0096\3\2\2\2py\7\t\2\2qv\5\n\6\2rs")
-        buf.write("\7\3\2\2su\5\n\6\2tr\3\2\2\2ux\3\2\2\2vt\3\2\2\2vw\3\2")
-        buf.write("\2\2wz\3\2\2\2xv\3\2\2\2yq\3\2\2\2yz\3\2\2\2z{\3\2\2\2")
-        buf.write("{\u0096\7\n\2\2|}\7\13\2\2}~\7\4\2\2~\177\5\n\6\2\177")
-        buf.write("\u0080\7\5\2\2\u0080\u0081\5&\24\2\u0081\u0082\7\f\2\2")
-        buf.write("\u0082\u0083\5&\24\2\u0083\u0096\3\2\2\2\u0084\u0085\7")
-        buf.write("\r\2\2\u0085\u0086\5\24\13\2\u0086\u0087\7\16\2\2\u0087")
-        buf.write("\u0088\5\n\6\2\u0088\u0089\7\17\2\2\u0089\u008a\5\n\6")
-        buf.write("\t\u008a\u0096\3\2\2\2\u008b\u008c\7+\2\2\u008c\u008d")
-        buf.write("\7\16\2\2\u008d\u008e\5\n\6\2\u008e\u008f\7\17\2\2\u008f")
-        buf.write("\u0090\5\n\6\7\u0090\u0096\3\2\2\2\u0091\u0096\5*\26\2")
-        buf.write("\u0092\u0096\5(\25\2\u0093\u0096\5 \21\2\u0094\u0096\7")
-        buf.write("\34\2\2\u0095S\3\2\2\2\u0095X\3\2\2\2\u0095\\\3\2\2\2")
-        buf.write("\u0095^\3\2\2\2\u0095_\3\2\2\2\u0095a\3\2\2\2\u0095f\3")
-        buf.write("\2\2\2\u0095p\3\2\2\2\u0095|\3\2\2\2\u0095\u0084\3\2\2")
-        buf.write("\2\u0095\u008b\3\2\2\2\u0095\u0091\3\2\2\2\u0095\u0092")
-        buf.write("\3\2\2\2\u0095\u0093\3\2\2\2\u0095\u0094\3\2\2\2\u0096")
-        buf.write("\u00b0\3\2\2\2\u0097\u0098\f\24\2\2\u0098\u0099\t\2\2")
-        buf.write("\2\u0099\u00af\5\n\6\25\u009a\u009b\f\23\2\2\u009b\u009c")
-        buf.write("\t\3\2\2\u009c\u00af\5\n\6\24\u009d\u009e\f\22\2\2\u009e")
-        buf.write("\u009f\t\4\2\2\u009f\u00af\5\n\6\23\u00a0\u00a1\f\21\2")
-        buf.write("\2\u00a1\u00a2\t\5\2\2\u00a2\u00af\5\n\6\22\u00a3\u00a4")
-        buf.write("\f\b\2\2\u00a4\u00a5\7\20\2\2\u00a5\u00af\5\n\6\t\u00a6")
-        buf.write("\u00a7\f\26\2\2\u00a7\u00a8\7\4\2\2\u00a8\u00a9\5\b\5")
-        buf.write("\2\u00a9\u00aa\7\5\2\2\u00aa\u00af\3\2\2\2\u00ab\u00ac")
-        buf.write("\f\f\2\2\u00ac\u00ad\7\b\2\2\u00ad\u00af\7.\2\2\u00ae")
-        buf.write("\u0097\3\2\2\2\u00ae\u009a\3\2\2\2\u00ae\u009d\3\2\2\2")
-        buf.write("\u00ae\u00a0\3\2\2\2\u00ae\u00a3\3\2\2\2\u00ae\u00a6\3")
-        buf.write("\2\2\2\u00ae\u00ab\3\2\2\2\u00af\u00b2\3\2\2\2\u00b0\u00ae")
-        buf.write("\3\2\2\2\u00b0\u00b1\3\2\2\2\u00b1\13\3\2\2\2\u00b2\u00b0")
-        buf.write("\3\2\2\2\u00b3\u00b5\7\21\2\2\u00b4\u00b6\5\32\16\2\u00b5")
-        buf.write("\u00b4\3\2\2\2\u00b5\u00b6\3\2\2\2\u00b6\u00b7\3\2\2\2")
-        buf.write("\u00b7\u00b8\7\4\2\2\u00b8\u00b9\5\20\t\2\u00b9\u00bc")
-        buf.write("\7\5\2\2\u00ba\u00bb\7\22\2\2\u00bb\u00bd\5\34\17\2\u00bc")
-        buf.write("\u00ba\3\2\2\2\u00bc\u00bd\3\2\2\2\u00bd\u00be\3\2\2\2")
-        buf.write("\u00be\u00bf\5&\24\2\u00bf\r\3\2\2\2\u00c0\u00c1\7\23")
-        buf.write("\2\2\u00c1\u00c3\5*\26\2\u00c2\u00c4\5\32\16\2\u00c3\u00c2")
-        buf.write("\3\2\2\2\u00c3\u00c4\3\2\2\2\u00c4\u00c5\3\2\2\2\u00c5")
-        buf.write("\u00c6\7\4\2\2\u00c6\u00c7\5\20\t\2\u00c7\u00ca\7\5\2")
-        buf.write("\2\u00c8\u00c9\7\22\2\2\u00c9\u00cb\5\34\17\2\u00ca\u00c8")
-        buf.write("\3\2\2\2\u00ca\u00cb\3\2\2\2\u00cb\u00cc\3\2\2\2\u00cc")
-        buf.write("\u00cd\5&\24\2\u00cd\17\3\2\2\2\u00ce\u00d9\5\22\n\2\u00cf")
-        buf.write("\u00d0\5\24\13\2\u00d0\u00d1\7\3\2\2\u00d1\u00d3\3\2\2")
-        buf.write("\2\u00d2\u00cf\3\2\2\2\u00d3\u00d6\3\2\2\2\u00d4\u00d2")
-        buf.write("\3\2\2\2\u00d4\u00d5\3\2\2\2\u00d5\u00d7\3\2\2\2\u00d6")
-        buf.write("\u00d4\3\2\2\2\u00d7\u00d9\5\26\f\2\u00d8\u00ce\3\2\2")
-        buf.write("\2\u00d8\u00d4\3\2\2\2\u00d9\21\3\2\2\2\u00da\u00df\5")
-        buf.write("\24\13\2\u00db\u00dc\7\3\2\2\u00dc\u00de\5\24\13\2\u00dd")
-        buf.write("\u00db\3\2\2\2\u00de\u00e1\3\2\2\2\u00df\u00dd\3\2\2\2")
-        buf.write("\u00df\u00e0\3\2\2\2\u00e0\u00e3\3\2\2\2\u00e1\u00df\3")
-        buf.write("\2\2\2\u00e2\u00da\3\2\2\2\u00e2\u00e3\3\2\2\2\u00e3\23")
-        buf.write("\3\2\2\2\u00e4\u00e7\7*\2\2\u00e5\u00e6\7\24\2\2\u00e6")
-        buf.write("\u00e8\5\34\17\2\u00e7\u00e5\3\2\2\2\u00e7\u00e8\3\2\2")
-        buf.write("\2\u00e8\25\3\2\2\2\u00e9\u00ee\5\30\r\2\u00ea\u00eb\7")
-        buf.write("\3\2\2\u00eb\u00ed\5\30\r\2\u00ec\u00ea\3\2\2\2\u00ed")
-        buf.write("\u00f0\3\2\2\2\u00ee\u00ec\3\2\2\2\u00ee\u00ef\3\2\2\2")
-        buf.write("\u00ef\27\3\2\2\2\u00f0\u00ee\3\2\2\2\u00f1\u00f2\7(\2")
-        buf.write("\2\u00f2\u00f3\7\16\2\2\u00f3\u00f4\5\n\6\2\u00f4\31\3")
-        buf.write("\2\2\2\u00f5\u00f6\7\t\2\2\u00f6\u0103\7\n\2\2\u00f7\u00f8")
-        buf.write("\7\t\2\2\u00f8\u00fd\5*\26\2\u00f9\u00fa\7\3\2\2\u00fa")
-        buf.write("\u00fc\5*\26\2\u00fb\u00f9\3\2\2\2\u00fc\u00ff\3\2\2\2")
-        buf.write("\u00fd\u00fb\3\2\2\2\u00fd\u00fe\3\2\2\2\u00fe\u0100\3")
-        buf.write("\2\2\2\u00ff\u00fd\3\2\2\2\u0100\u0101\7\n\2\2\u0101\u0103")
-        buf.write("\3\2\2\2\u0102\u00f5\3\2\2\2\u0102\u00f7\3\2\2\2\u0103")
-        buf.write("\33\3\2\2\2\u0104\u0105\7\4\2\2\u0105\u0132\7\5\2\2\u0106")
-        buf.write("\u0107\7\4\2\2\u0107\u0108\5\34\17\2\u0108\u0109\7\3\2")
-        buf.write("\2\u0109\u010a\7\5\2\2\u010a\u0132\3\2\2\2\u010b\u010c")
-        buf.write("\7\4\2\2\u010c\u010f\5\34\17\2\u010d\u010e\7\3\2\2\u010e")
-        buf.write("\u0110\5\34\17\2\u010f\u010d\3\2\2\2\u0110\u0111\3\2\2")
-        buf.write("\2\u0111\u010f\3\2\2\2\u0111\u0112\3\2\2\2\u0112\u0113")
-        buf.write("\3\2\2\2\u0113\u0114\7\5\2\2\u0114\u0132\3\2\2\2\u0115")
-        buf.write("\u0132\5$\23\2\u0116\u0117\7\25\2\2\u0117\u0118\7\t\2")
-        buf.write("\2\u0118\u0119\5\36\20\2\u0119\u011a\7\3\2\2\u011a\u011b")
-        buf.write("\5\34\17\2\u011b\u011c\7\n\2\2\u011c\u0132\3\2\2\2\u011d")
-        buf.write("\u011f\7\21\2\2\u011e\u0120\5\32\16\2\u011f\u011e\3\2")
-        buf.write("\2\2\u011f\u0120\3\2\2\2\u0120\u0121\3\2\2\2\u0121\u012a")
-        buf.write("\7\4\2\2\u0122\u0127\5\34\17\2\u0123\u0124\7\3\2\2\u0124")
-        buf.write("\u0126\5\34\17\2\u0125\u0123\3\2\2\2\u0126\u0129\3\2\2")
-        buf.write("\2\u0127\u0125\3\2\2\2\u0127\u0128\3\2\2\2\u0128\u012b")
-        buf.write("\3\2\2\2\u0129\u0127\3\2\2\2\u012a\u0122\3\2\2\2\u012a")
-        buf.write("\u012b\3\2\2\2\u012b\u012c\3\2\2\2\u012c\u012d\7\5\2\2")
-        buf.write("\u012d\u012e\7\22\2\2\u012e\u0132\5\34\17\2\u012f\u0132")
-        buf.write("\7\26\2\2\u0130\u0132\7.\2\2\u0131\u0104\3\2\2\2\u0131")
-        buf.write("\u0106\3\2\2\2\u0131\u010b\3\2\2\2\u0131\u0115\3\2\2\2")
-        buf.write("\u0131\u0116\3\2\2\2\u0131\u011d\3\2\2\2\u0131\u012f\3")
-        buf.write("\2\2\2\u0131\u0130\3\2\2\2\u0132\35\3\2\2\2\u0133\u0134")
-        buf.write("\7\4\2\2\u0134\u0137\5\"\22\2\u0135\u0136\7\3\2\2\u0136")
-        buf.write("\u0138\5\"\22\2\u0137\u0135\3\2\2\2\u0138\u0139\3\2\2")
-        buf.write("\2\u0139\u0137\3\2\2\2\u0139\u013a\3\2\2\2\u013a\u013b")
-        buf.write("\3\2\2\2\u013b\u013c\7\5\2\2\u013c\u0141\3\2\2\2\u013d")
-        buf.write("\u013e\7\4\2\2\u013e\u0141\7\5\2\2\u013f\u0141\5\"\22")
-        buf.write("\2\u0140\u0133\3\2\2\2\u0140\u013d\3\2\2\2\u0140\u013f")
-        buf.write("\3\2\2\2\u0141\37\3\2\2\2\u0142\u0143\7\27\2\2\u0143\u0144")
-        buf.write("\7\t\2\2\u0144\u0145\7(\2\2\u0145\u0146\7\n\2\2\u0146")
-        buf.write("\u0147\7\t\2\2\u0147\u0148\7.\2\2\u0148\u0149\7\n\2\2")
-        buf.write("\u0149!\3\2\2\2\u014a\u0151\5 \21\2\u014b\u014c\7\4\2")
-        buf.write("\2\u014c\u014d\5\"\22\2\u014d\u014e\7\5\2\2\u014e\u0151")
-        buf.write("\3\2\2\2\u014f\u0151\7.\2\2\u0150\u014a\3\2\2\2\u0150")
-        buf.write("\u014b\3\2\2\2\u0150\u014f\3\2\2\2\u0151#\3\2\2\2\u0152")
-        buf.write("\u0153\7(\2\2\u0153%\3\2\2\2\u0154\u0155\7\6\2\2\u0155")
-        buf.write("\u0156\5\n\6\2\u0156\u0157\7\7\2\2\u0157\'\3\2\2\2\u0158")
-        buf.write("\u015c\7-\2\2\u0159\u015c\7.\2\2\u015a\u015c\7\'\2\2\u015b")
-        buf.write("\u0158\3\2\2\2\u015b\u0159\3\2\2\2\u015b\u015a\3\2\2\2")
-        buf.write("\u015c)\3\2\2\2\u015d\u0162\5\2\2\2\u015e\u0162\7)\2\2")
-        buf.write("\u015f\u0162\7*\2\2\u0160\u0162\7+\2\2\u0161\u015d\3\2")
-        buf.write("\2\2\u0161\u015e\3\2\2\2\u0161\u015f\3\2\2\2\u0161\u0160")
-        buf.write("\3\2\2\2\u0162+\3\2\2\2%\62\669BEMQlvy\u0095\u00ae\u00b0")
-        buf.write("\u00b5\u00bc\u00c3\u00ca\u00d4\u00d8\u00df\u00e2\u00e7")
-        buf.write("\u00ee\u00fd\u0102\u0111\u011f\u0127\u012a\u0131\u0139")
-        buf.write("\u0140\u0150\u015b\u0161")
+        buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
+        buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\3\2\3\2")
+        buf.write("\7\2=\n\2\f\2\16\2@\13\2\3\2\5\2C\n\2\3\2\5\2F\n\2\3\2")
+        buf.write("\3\2\3\3\3\3\3\4\3\4\3\4\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3")
+        buf.write("\6\7\6W\n\6\f\6\16\6Z\13\6\3\6\3\6\5\6^\n\6\3\7\3\7\3")
+        buf.write("\b\3\b\3\b\3\t\3\t\3\t\7\th\n\t\f\t\16\tk\13\t\5\tm\n")
+        buf.write("\t\3\n\3\n\3\n\3\n\7\ns\n\n\f\n\16\nv\13\n\3\n\5\ny\n")
+        buf.write("\n\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3")
+        buf.write("\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13")
+        buf.write("\3\13\3\13\6\13\u0092\n\13\r\13\16\13\u0093\3\13\3\13")
+        buf.write("\3\13\3\13\3\13\3\13\7\13\u009c\n\13\f\13\16\13\u009f")
+        buf.write("\13\13\5\13\u00a1\n\13\3\13\3\13\3\13\3\13\3\13\3\13\3")
+        buf.write("\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13")
+        buf.write("\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\5\13\u00bd")
+        buf.write("\n\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13")
+        buf.write("\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13")
+        buf.write("\3\13\3\13\7\13\u00d6\n\13\f\13\16\13\u00d9\13\13\3\f")
+        buf.write("\3\f\5\f\u00dd\n\f\3\f\3\f\3\f\3\f\3\f\5\f\u00e4\n\f\3")
+        buf.write("\f\3\f\3\r\3\r\3\r\5\r\u00eb\n\r\3\r\3\r\3\r\3\r\3\r\5")
+        buf.write("\r\u00f2\n\r\3\r\3\r\3\r\3\r\3\r\3\r\6\r\u00fa\n\r\r\r")
+        buf.write("\16\r\u00fb\5\r\u00fe\n\r\3\16\3\16\3\16\3\16\3\16\3\16")
+        buf.write("\7\16\u0106\n\16\f\16\16\16\u0109\13\16\3\16\3\16\5\16")
+        buf.write("\u010d\n\16\3\17\3\17\3\20\3\20\3\20\3\20\7\20\u0115\n")
+        buf.write("\20\f\20\16\20\u0118\13\20\3\20\5\20\u011b\n\20\3\21\3")
+        buf.write("\21\3\21\7\21\u0120\n\21\f\21\16\21\u0123\13\21\5\21\u0125")
+        buf.write("\n\21\3\22\3\22\3\22\5\22\u012a\n\22\3\23\3\23\3\23\7")
+        buf.write("\23\u012f\n\23\f\23\16\23\u0132\13\23\3\24\3\24\3\24\3")
+        buf.write("\24\3\25\3\25\3\25\3\25\3\25\3\25\7\25\u013e\n\25\f\25")
+        buf.write("\16\25\u0141\13\25\3\25\3\25\5\25\u0145\n\25\3\26\3\26")
+        buf.write("\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\6\26\u0152")
+        buf.write("\n\26\r\26\16\26\u0153\3\26\3\26\3\26\3\26\3\26\3\26\3")
+        buf.write("\26\3\26\3\26\3\26\3\26\3\26\5\26\u0162\n\26\3\26\3\26")
+        buf.write("\3\26\3\26\7\26\u0168\n\26\f\26\16\26\u016b\13\26\5\26")
+        buf.write("\u016d\n\26\3\26\3\26\3\26\3\26\3\26\5\26\u0174\n\26\3")
+        buf.write("\27\3\27\3\27\3\27\6\27\u017a\n\27\r\27\16\27\u017b\3")
+        buf.write("\27\3\27\3\27\3\27\3\27\5\27\u0183\n\27\3\30\3\30\3\30")
+        buf.write("\3\30\3\30\3\30\3\30\3\30\3\31\3\31\3\31\3\31\3\31\3\31")
+        buf.write("\5\31\u0193\n\31\3\32\3\32\3\33\3\33\3\33\3\33\3\34\3")
+        buf.write("\34\3\34\5\34\u019e\n\34\3\35\3\35\3\35\3\35\3\35\3\35")
+        buf.write("\5\35\u01a6\n\35\3\35\2\3\24\36\2\4\6\b\n\f\16\20\22\24")
+        buf.write("\26\30\32\34\36 \"$&(*,.\60\62\64\668\2\6\3\2\"#\3\2$")
+        buf.write("%\3\2&)\3\2*+\2\u01d3\2:\3\2\2\2\4I\3\2\2\2\6K\3\2\2\2")
+        buf.write("\bN\3\2\2\2\nQ\3\2\2\2\f_\3\2\2\2\16a\3\2\2\2\20l\3\2")
+        buf.write("\2\2\22x\3\2\2\2\24\u00bc\3\2\2\2\26\u00da\3\2\2\2\30")
+        buf.write("\u00fd\3\2\2\2\32\u00ff\3\2\2\2\34\u010e\3\2\2\2\36\u011a")
+        buf.write("\3\2\2\2 \u0124\3\2\2\2\"\u0126\3\2\2\2$\u012b\3\2\2\2")
+        buf.write("&\u0133\3\2\2\2(\u0144\3\2\2\2*\u0173\3\2\2\2,\u0182\3")
+        buf.write("\2\2\2.\u0184\3\2\2\2\60\u0192\3\2\2\2\62\u0194\3\2\2")
+        buf.write("\2\64\u0196\3\2\2\2\66\u019d\3\2\2\28\u01a5\3\2\2\2:B")
+        buf.write("\7\35\2\2;=\5\30\r\2<;\3\2\2\2=@\3\2\2\2><\3\2\2\2>?\3")
+        buf.write("\2\2\2?C\3\2\2\2@>\3\2\2\2AC\5\24\13\2B>\3\2\2\2BA\3\2")
+        buf.write("\2\2CE\3\2\2\2DF\7\61\2\2ED\3\2\2\2EF\3\2\2\2FG\3\2\2")
+        buf.write("\2GH\7\2\2\3H\3\3\2\2\2IJ\7-\2\2J\5\3\2\2\2KL\7\3\2\2")
+        buf.write("LM\7-\2\2M\7\3\2\2\2NO\7\4\2\2OP\7-\2\2P\t\3\2\2\2Q]\7")
+        buf.write("-\2\2RS\7\5\2\2SX\5\f\7\2TU\7\6\2\2UW\5\f\7\2VT\3\2\2")
+        buf.write("\2WZ\3\2\2\2XV\3\2\2\2XY\3\2\2\2Y[\3\2\2\2ZX\3\2\2\2[")
+        buf.write("\\\7\7\2\2\\^\3\2\2\2]R\3\2\2\2]^\3\2\2\2^\13\3\2\2\2")
+        buf.write("_`\7-\2\2`\r\3\2\2\2ab\7\4\2\2bc\7\60\2\2c\17\3\2\2\2")
+        buf.write("di\5\24\13\2ef\7\b\2\2fh\5\24\13\2ge\3\2\2\2hk\3\2\2\2")
+        buf.write("ig\3\2\2\2ij\3\2\2\2jm\3\2\2\2ki\3\2\2\2ld\3\2\2\2lm\3")
+        buf.write("\2\2\2m\21\3\2\2\2ny\5\20\t\2op\5\24\13\2pq\7\b\2\2qs")
+        buf.write("\3\2\2\2ro\3\2\2\2sv\3\2\2\2tr\3\2\2\2tu\3\2\2\2uw\3\2")
+        buf.write("\2\2vt\3\2\2\2wy\5$\23\2xn\3\2\2\2xt\3\2\2\2y\23\3\2\2")
+        buf.write("\2z{\b\13\1\2{|\7\t\2\2|}\5\24\13\2}~\7\n\2\2~\u00bd\3")
+        buf.write("\2\2\2\177\u0080\7\13\2\2\u0080\u0081\5\24\13\2\u0081")
+        buf.write("\u0082\7\f\2\2\u0082\u00bd\3\2\2\2\u0083\u0084\7%\2\2")
+        buf.write("\u0084\u00bd\5\24\13\25\u0085\u00bd\5\26\f\2\u0086\u0087")
+        buf.write("\7\t\2\2\u0087\u00bd\7\n\2\2\u0088\u0089\7\t\2\2\u0089")
+        buf.write("\u008a\5\24\13\2\u008a\u008b\7\b\2\2\u008b\u008c\7\n\2")
+        buf.write("\2\u008c\u00bd\3\2\2\2\u008d\u008e\7\t\2\2\u008e\u0091")
+        buf.write("\5\24\13\2\u008f\u0090\7\b\2\2\u0090\u0092\5\24\13\2\u0091")
+        buf.write("\u008f\3\2\2\2\u0092\u0093\3\2\2\2\u0093\u0091\3\2\2\2")
+        buf.write("\u0093\u0094\3\2\2\2\u0094\u0095\3\2\2\2\u0095\u0096\7")
+        buf.write("\n\2\2\u0096\u00bd\3\2\2\2\u0097\u00a0\7\5\2\2\u0098\u009d")
+        buf.write("\5\24\13\2\u0099\u009a\7\b\2\2\u009a\u009c\5\24\13\2\u009b")
+        buf.write("\u0099\3\2\2\2\u009c\u009f\3\2\2\2\u009d\u009b\3\2\2\2")
+        buf.write("\u009d\u009e\3\2\2\2\u009e\u00a1\3\2\2\2\u009f\u009d\3")
+        buf.write("\2\2\2\u00a0\u0098\3\2\2\2\u00a0\u00a1\3\2\2\2\u00a1\u00a2")
+        buf.write("\3\2\2\2\u00a2\u00bd\7\7\2\2\u00a3\u00a4\7\16\2\2\u00a4")
+        buf.write("\u00a5\7\t\2\2\u00a5\u00a6\5\24\13\2\u00a6\u00a7\7\n\2")
+        buf.write("\2\u00a7\u00a8\5\64\33\2\u00a8\u00a9\7\17\2\2\u00a9\u00aa")
+        buf.write("\5\64\33\2\u00aa\u00bd\3\2\2\2\u00ab\u00ac\7\20\2\2\u00ac")
+        buf.write("\u00ad\5\"\22\2\u00ad\u00ae\7\21\2\2\u00ae\u00af\5\24")
+        buf.write("\13\2\u00af\u00b0\7\22\2\2\u00b0\u00b1\5\24\13\t\u00b1")
+        buf.write("\u00bd\3\2\2\2\u00b2\u00b3\5\16\b\2\u00b3\u00b4\7\21\2")
+        buf.write("\2\u00b4\u00b5\5\24\13\2\u00b5\u00b6\7\22\2\2\u00b6\u00b7")
+        buf.write("\5\24\13\7\u00b7\u00bd\3\2\2\2\u00b8\u00bd\58\35\2\u00b9")
+        buf.write("\u00bd\5\66\34\2\u00ba\u00bd\5.\30\2\u00bb\u00bd\7!\2")
+        buf.write("\2\u00bcz\3\2\2\2\u00bc\177\3\2\2\2\u00bc\u0083\3\2\2")
+        buf.write("\2\u00bc\u0085\3\2\2\2\u00bc\u0086\3\2\2\2\u00bc\u0088")
+        buf.write("\3\2\2\2\u00bc\u008d\3\2\2\2\u00bc\u0097\3\2\2\2\u00bc")
+        buf.write("\u00a3\3\2\2\2\u00bc\u00ab\3\2\2\2\u00bc\u00b2\3\2\2\2")
+        buf.write("\u00bc\u00b8\3\2\2\2\u00bc\u00b9\3\2\2\2\u00bc\u00ba\3")
+        buf.write("\2\2\2\u00bc\u00bb\3\2\2\2\u00bd\u00d7\3\2\2\2\u00be\u00bf")
+        buf.write("\f\24\2\2\u00bf\u00c0\t\2\2\2\u00c0\u00d6\5\24\13\25\u00c1")
+        buf.write("\u00c2\f\23\2\2\u00c2\u00c3\t\3\2\2\u00c3\u00d6\5\24\13")
+        buf.write("\24\u00c4\u00c5\f\22\2\2\u00c5\u00c6\t\4\2\2\u00c6\u00d6")
+        buf.write("\5\24\13\23\u00c7\u00c8\f\21\2\2\u00c8\u00c9\t\5\2\2\u00c9")
+        buf.write("\u00d6\5\24\13\22\u00ca\u00cb\f\b\2\2\u00cb\u00cc\7\23")
+        buf.write("\2\2\u00cc\u00d6\5\24\13\t\u00cd\u00ce\f\26\2\2\u00ce")
+        buf.write("\u00cf\7\t\2\2\u00cf\u00d0\5\22\n\2\u00d0\u00d1\7\n\2")
+        buf.write("\2\u00d1\u00d6\3\2\2\2\u00d2\u00d3\f\f\2\2\u00d3\u00d4")
+        buf.write("\7\r\2\2\u00d4\u00d6\7\60\2\2\u00d5\u00be\3\2\2\2\u00d5")
+        buf.write("\u00c1\3\2\2\2\u00d5\u00c4\3\2\2\2\u00d5\u00c7\3\2\2\2")
+        buf.write("\u00d5\u00ca\3\2\2\2\u00d5\u00cd\3\2\2\2\u00d5\u00d2\3")
+        buf.write("\2\2\2\u00d6\u00d9\3\2\2\2\u00d7\u00d5\3\2\2\2\u00d7\u00d8")
+        buf.write("\3\2\2\2\u00d8\25\3\2\2\2\u00d9\u00d7\3\2\2\2\u00da\u00dc")
+        buf.write("\7\24\2\2\u00db\u00dd\5(\25\2\u00dc\u00db\3\2\2\2\u00dc")
+        buf.write("\u00dd\3\2\2\2\u00dd\u00de\3\2\2\2\u00de\u00df\7\t\2\2")
+        buf.write("\u00df\u00e0\5\36\20\2\u00e0\u00e3\7\n\2\2\u00e1\u00e2")
+        buf.write("\7\25\2\2\u00e2\u00e4\5*\26\2\u00e3\u00e1\3\2\2\2\u00e3")
+        buf.write("\u00e4\3\2\2\2\u00e4\u00e5\3\2\2\2\u00e5\u00e6\5\64\33")
+        buf.write("\2\u00e6\27\3\2\2\2\u00e7\u00e8\7\26\2\2\u00e8\u00ea\5")
+        buf.write("\6\4\2\u00e9\u00eb\5(\25\2\u00ea\u00e9\3\2\2\2\u00ea\u00eb")
+        buf.write("\3\2\2\2\u00eb\u00ec\3\2\2\2\u00ec\u00ed\7\t\2\2\u00ed")
+        buf.write("\u00ee\5\36\20\2\u00ee\u00f1\7\n\2\2\u00ef\u00f0\7\25")
+        buf.write("\2\2\u00f0\u00f2\5*\26\2\u00f1\u00ef\3\2\2\2\u00f1\u00f2")
+        buf.write("\3\2\2\2\u00f2\u00f3\3\2\2\2\u00f3\u00f4\5\64\33\2\u00f4")
+        buf.write("\u00fe\3\2\2\2\u00f5\u00f6\7\27\2\2\u00f6\u00f7\5\n\6")
+        buf.write("\2\u00f7\u00f9\7\21\2\2\u00f8\u00fa\5\32\16\2\u00f9\u00f8")
+        buf.write("\3\2\2\2\u00fa\u00fb\3\2\2\2\u00fb\u00f9\3\2\2\2\u00fb")
+        buf.write("\u00fc\3\2\2\2\u00fc\u00fe\3\2\2\2\u00fd\u00e7\3\2\2\2")
+        buf.write("\u00fd\u00f5\3\2\2\2\u00fe\31\3\2\2\2\u00ff\u0100\7\30")
+        buf.write("\2\2\u0100\u010c\5\34\17\2\u0101\u0102\7\t\2\2\u0102\u0107")
+        buf.write("\5*\26\2\u0103\u0104\7\6\2\2\u0104\u0106\5*\26\2\u0105")
+        buf.write("\u0103\3\2\2\2\u0106\u0109\3\2\2\2\u0107\u0105\3\2\2\2")
+        buf.write("\u0107\u0108\3\2\2\2\u0108\u010a\3\2\2\2\u0109\u0107\3")
+        buf.write("\2\2\2\u010a\u010b\7\n\2\2\u010b\u010d\3\2\2\2\u010c\u0101")
+        buf.write("\3\2\2\2\u010c\u010d\3\2\2\2\u010d\33\3\2\2\2\u010e\u010f")
+        buf.write("\7-\2\2\u010f\35\3\2\2\2\u0110\u011b\5 \21\2\u0111\u0112")
+        buf.write("\5\"\22\2\u0112\u0113\7\b\2\2\u0113\u0115\3\2\2\2\u0114")
+        buf.write("\u0111\3\2\2\2\u0115\u0118\3\2\2\2\u0116\u0114\3\2\2\2")
+        buf.write("\u0116\u0117\3\2\2\2\u0117\u0119\3\2\2\2\u0118\u0116\3")
+        buf.write("\2\2\2\u0119\u011b\5$\23\2\u011a\u0110\3\2\2\2\u011a\u0116")
+        buf.write("\3\2\2\2\u011b\37\3\2\2\2\u011c\u0121\5\"\22\2\u011d\u011e")
+        buf.write("\7\b\2\2\u011e\u0120\5\"\22\2\u011f\u011d\3\2\2\2\u0120")
+        buf.write("\u0123\3\2\2\2\u0121\u011f\3\2\2\2\u0121\u0122\3\2\2\2")
+        buf.write("\u0122\u0125\3\2\2\2\u0123\u0121\3\2\2\2\u0124\u011c\3")
+        buf.write("\2\2\2\u0124\u0125\3\2\2\2\u0125!\3\2\2\2\u0126\u0129")
+        buf.write("\5\b\5\2\u0127\u0128\7\31\2\2\u0128\u012a\5*\26\2\u0129")
+        buf.write("\u0127\3\2\2\2\u0129\u012a\3\2\2\2\u012a#\3\2\2\2\u012b")
+        buf.write("\u0130\5&\24\2\u012c\u012d\7\b\2\2\u012d\u012f\5&\24\2")
+        buf.write("\u012e\u012c\3\2\2\2\u012f\u0132\3\2\2\2\u0130\u012e\3")
+        buf.write("\2\2\2\u0130\u0131\3\2\2\2\u0131%\3\2\2\2\u0132\u0130")
+        buf.write("\3\2\2\2\u0133\u0134\7-\2\2\u0134\u0135\7\21\2\2\u0135")
+        buf.write("\u0136\5\24\13\2\u0136\'\3\2\2\2\u0137\u0138\7\5\2\2\u0138")
+        buf.write("\u0145\7\7\2\2\u0139\u013a\7\5\2\2\u013a\u013f\58\35\2")
+        buf.write("\u013b\u013c\7\b\2\2\u013c\u013e\58\35\2\u013d\u013b\3")
+        buf.write("\2\2\2\u013e\u0141\3\2\2\2\u013f\u013d\3\2\2\2\u013f\u0140")
+        buf.write("\3\2\2\2\u0140\u0142\3\2\2\2\u0141\u013f\3\2\2\2\u0142")
+        buf.write("\u0143\7\7\2\2\u0143\u0145\3\2\2\2\u0144\u0137\3\2\2\2")
+        buf.write("\u0144\u0139\3\2\2\2\u0145)\3\2\2\2\u0146\u0147\7\t\2")
+        buf.write("\2\u0147\u0174\7\n\2\2\u0148\u0149\7\t\2\2\u0149\u014a")
+        buf.write("\5*\26\2\u014a\u014b\7\b\2\2\u014b\u014c\7\n\2\2\u014c")
+        buf.write("\u0174\3\2\2\2\u014d\u014e\7\t\2\2\u014e\u0151\5*\26\2")
+        buf.write("\u014f\u0150\7\b\2\2\u0150\u0152\5*\26\2\u0151\u014f\3")
+        buf.write("\2\2\2\u0152\u0153\3\2\2\2\u0153\u0151\3\2\2\2\u0153\u0154")
+        buf.write("\3\2\2\2\u0154\u0155\3\2\2\2\u0155\u0156\7\n\2\2\u0156")
+        buf.write("\u0174\3\2\2\2\u0157\u0174\5\n\6\2\u0158\u0159\7\32\2")
+        buf.write("\2\u0159\u015a\7\5\2\2\u015a\u015b\5,\27\2\u015b\u015c")
+        buf.write("\7\b\2\2\u015c\u015d\5*\26\2\u015d\u015e\7\7\2\2\u015e")
+        buf.write("\u0174\3\2\2\2\u015f\u0161\7\24\2\2\u0160\u0162\5(\25")
+        buf.write("\2\u0161\u0160\3\2\2\2\u0161\u0162\3\2\2\2\u0162\u0163")
+        buf.write("\3\2\2\2\u0163\u016c\7\t\2\2\u0164\u0169\5*\26\2\u0165")
+        buf.write("\u0166\7\b\2\2\u0166\u0168\5*\26\2\u0167\u0165\3\2\2\2")
+        buf.write("\u0168\u016b\3\2\2\2\u0169\u0167\3\2\2\2\u0169\u016a\3")
+        buf.write("\2\2\2\u016a\u016d\3\2\2\2\u016b\u0169\3\2\2\2\u016c\u0164")
+        buf.write("\3\2\2\2\u016c\u016d\3\2\2\2\u016d\u016e\3\2\2\2\u016e")
+        buf.write("\u016f\7\n\2\2\u016f\u0170\7\25\2\2\u0170\u0174\5*\26")
+        buf.write("\2\u0171\u0174\7\33\2\2\u0172\u0174\7\60\2\2\u0173\u0146")
+        buf.write("\3\2\2\2\u0173\u0148\3\2\2\2\u0173\u014d\3\2\2\2\u0173")
+        buf.write("\u0157\3\2\2\2\u0173\u0158\3\2\2\2\u0173\u015f\3\2\2\2")
+        buf.write("\u0173\u0171\3\2\2\2\u0173\u0172\3\2\2\2\u0174+\3\2\2")
+        buf.write("\2\u0175\u0176\7\t\2\2\u0176\u0179\5\60\31\2\u0177\u0178")
+        buf.write("\7\b\2\2\u0178\u017a\5\60\31\2\u0179\u0177\3\2\2\2\u017a")
+        buf.write("\u017b\3\2\2\2\u017b\u0179\3\2\2\2\u017b\u017c\3\2\2\2")
+        buf.write("\u017c\u017d\3\2\2\2\u017d\u017e\7\n\2\2\u017e\u0183\3")
+        buf.write("\2\2\2\u017f\u0180\7\t\2\2\u0180\u0183\7\n\2\2\u0181\u0183")
+        buf.write("\5\60\31\2\u0182\u0175\3\2\2\2\u0182\u017f\3\2\2\2\u0182")
+        buf.write("\u0181\3\2\2\2\u0183-\3\2\2\2\u0184\u0185\7\34\2\2\u0185")
+        buf.write("\u0186\7\5\2\2\u0186\u0187\7-\2\2\u0187\u0188\7\7\2\2")
+        buf.write("\u0188\u0189\7\5\2\2\u0189\u018a\7\60\2\2\u018a\u018b")
+        buf.write("\7\7\2\2\u018b/\3\2\2\2\u018c\u0193\5.\30\2\u018d\u018e")
+        buf.write("\7\t\2\2\u018e\u018f\5\60\31\2\u018f\u0190\7\n\2\2\u0190")
+        buf.write("\u0193\3\2\2\2\u0191\u0193\7\60\2\2\u0192\u018c\3\2\2")
+        buf.write("\2\u0192\u018d\3\2\2\2\u0192\u0191\3\2\2\2\u0193\61\3")
+        buf.write("\2\2\2\u0194\u0195\7-\2\2\u0195\63\3\2\2\2\u0196\u0197")
+        buf.write("\7\13\2\2\u0197\u0198\5\24\13\2\u0198\u0199\7\f\2\2\u0199")
+        buf.write("\65\3\2\2\2\u019a\u019e\7/\2\2\u019b\u019e\7\60\2\2\u019c")
+        buf.write("\u019e\7,\2\2\u019d\u019a\3\2\2\2\u019d\u019b\3\2\2\2")
+        buf.write("\u019d\u019c\3\2\2\2\u019e\67\3\2\2\2\u019f\u01a6\5\4")
+        buf.write("\3\2\u01a0\u01a6\5\6\4\2\u01a1\u01a6\5\b\5\2\u01a2\u01a6")
+        buf.write("\5\n\6\2\u01a3\u01a6\5\f\7\2\u01a4\u01a6\5\16\b\2\u01a5")
+        buf.write("\u019f\3\2\2\2\u01a5\u01a0\3\2\2\2\u01a5\u01a1\3\2\2\2")
+        buf.write("\u01a5\u01a2\3\2\2\2\u01a5\u01a3\3\2\2\2\u01a5\u01a4\3")
+        buf.write("\2\2\2\u01a69\3\2\2\2+>BEX]iltx\u0093\u009d\u00a0\u00bc")
+        buf.write("\u00d5\u00d7\u00dc\u00e3\u00ea\u00f1\u00fb\u00fd\u0107")
+        buf.write("\u010c\u0116\u011a\u0121\u0124\u0129\u0130\u013f\u0144")
+        buf.write("\u0153\u0161\u0169\u016c\u0173\u017b\u0182\u0192\u019d")
+        buf.write("\u01a5")
         return buf.getvalue()
 
 
@@ -187,13 +225,13 @@ class RelayParser ( Parser ):
 
     sharedContextCache = PredictionContextCache()
 
-    literalNames = [ "<INVALID>", "','", "'('", "')'", "'{'", "'}'", "'.'", 
-                     "'['", "']'", "'if'", "'else'", "'let'", "'='", "';'", 
-                     "';;'", "'fn'", "'->'", "'def'", "':'", "'Tensor'", 
-                     "'_'", "'meta'", "'v0.0.3'", "<INVALID>", "<INVALID>", 
-                     "<INVALID>", "<INVALID>", "'*'", "'/'", "'+'", "'-'", 
-                     "'<'", "'>'", "'<='", "'>='", "'=='", "'!='", "<INVALID>", 
-                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
+    literalNames = [ "<INVALID>", "'@'", "'%'", "'['", "', '", "']'", "','", 
+                     "'('", "')'", "'{'", "'}'", "'.'", "'if'", "'else'", 
+                     "'let'", "'='", "';'", "';;'", "'fn'", "'->'", "'def'", 
+                     "'type'", "'|'", "':'", "'Tensor'", "'_'", "'meta'", 
+                     "'v0.0.3'", "<INVALID>", "<INVALID>", "<INVALID>", 
+                     "<INVALID>", "'*'", "'/'", "'+'", "'-'", "'<'", "'>'", 
+                     "'<='", "'>='", "'=='", "'!='", "<INVALID>", "<INVALID>", 
                      "'int64'" ]
 
     symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
@@ -201,38 +239,47 @@ class RelayParser ( Parser ):
                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
-                      "<INVALID>", "<INVALID>", "SEMVER", "COMMENT", "WS", 
-                      "LINE_COMMENT", "QUOTED_STRING", "MUL", "DIV", "ADD", 
-                      "SUB", "LT", "GT", "LE", "GE", "EQ", "NE", "BOOL_LIT", 
-                      "CNAME", "GLOBAL_VAR", "LOCAL_VAR", "GRAPH_VAR", "DATATYPE", 
-                      "FLOAT", "NAT", "METADATA" ]
-
-    RULE_opIdent = 0
-    RULE_prog = 1
-    RULE_exprList = 2
-    RULE_callList = 3
-    RULE_expr = 4
-    RULE_func = 5
-    RULE_defn = 6
-    RULE_argList = 7
-    RULE_varList = 8
-    RULE_var = 9
-    RULE_attrSeq = 10
-    RULE_attr = 11
-    RULE_typeParamList = 12
-    RULE_type_ = 13
-    RULE_shapeList = 14
-    RULE_meta = 15
-    RULE_shape = 16
-    RULE_typeIdent = 17
-    RULE_body = 18
-    RULE_scalar = 19
-    RULE_ident = 20
-
-    ruleNames =  [ "opIdent", "prog", "exprList", "callList", "expr", "func", 
-                   "defn", "argList", "varList", "var", "attrSeq", "attr", 
-                   "typeParamList", "type_", "shapeList", "meta", "shape", 
-                   "typeIdent", "body", "scalar", "ident" ]
+                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
+                      "<INVALID>", "<INVALID>", "<INVALID>", "SEMVER", "COMMENT", 
+                      "WS", "LINE_COMMENT", "QUOTED_STRING", "MUL", "DIV", 
+                      "ADD", "SUB", "LT", "GT", "LE", "GE", "EQ", "NE", 
+                      "BOOL_LIT", "CNAME", "DATATYPE", "FLOAT", "NAT", "METADATA" ]
+
+    RULE_prog = 0
+    RULE_opIdent = 1
+    RULE_globalVar = 2
+    RULE_localVar = 3
+    RULE_globalTypeVar = 4
+    RULE_typeVar = 5
+    RULE_graphVar = 6
+    RULE_exprList = 7
+    RULE_callList = 8
+    RULE_expr = 9
+    RULE_func = 10
+    RULE_defn = 11
+    RULE_adtVariant = 12
+    RULE_variantName = 13
+    RULE_argList = 14
+    RULE_varList = 15
+    RULE_var = 16
+    RULE_attrSeq = 17
+    RULE_attr = 18
+    RULE_typeParamList = 19
+    RULE_type_ = 20
+    RULE_shapeList = 21
+    RULE_meta = 22
+    RULE_shape = 23
+    RULE_typeIdent = 24
+    RULE_body = 25
+    RULE_scalar = 26
+    RULE_ident = 27
+
+    ruleNames =  [ "prog", "opIdent", "globalVar", "localVar", "globalTypeVar", 
+                   "typeVar", "graphVar", "exprList", "callList", "expr", 
+                   "func", "defn", "adtVariant", "variantName", "argList", 
+                   "varList", "var", "attrSeq", "attr", "typeParamList", 
+                   "type_", "shapeList", "meta", "shape", "typeIdent", "body", 
+                   "scalar", "ident" ]
 
     EOF = Token.EOF
     T__0=1
@@ -256,39 +303,130 @@ class RelayParser ( Parser ):
     T__18=19
     T__19=20
     T__20=21
-    SEMVER=22
-    COMMENT=23
-    WS=24
-    LINE_COMMENT=25
-    QUOTED_STRING=26
-    MUL=27
-    DIV=28
-    ADD=29
-    SUB=30
-    LT=31
-    GT=32
-    LE=33
-    GE=34
-    EQ=35
-    NE=36
-    BOOL_LIT=37
-    CNAME=38
-    GLOBAL_VAR=39
-    LOCAL_VAR=40
-    GRAPH_VAR=41
-    DATATYPE=42
-    FLOAT=43
-    NAT=44
-    METADATA=45
+    T__21=22
+    T__22=23
+    T__23=24
+    T__24=25
+    T__25=26
+    SEMVER=27
+    COMMENT=28
+    WS=29
+    LINE_COMMENT=30
+    QUOTED_STRING=31
+    MUL=32
+    DIV=33
+    ADD=34
+    SUB=35
+    LT=36
+    GT=37
+    LE=38
+    GE=39
+    EQ=40
+    NE=41
+    BOOL_LIT=42
+    CNAME=43
+    DATATYPE=44
+    FLOAT=45
+    NAT=46
+    METADATA=47
 
     def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
         super().__init__(input, output)
-        self.checkVersion("4.7.1")
+        self.checkVersion("4.7.2")
         self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)
         self._predicates = None
 
 
 
+
+    class ProgContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def SEMVER(self):
+            return self.getToken(RelayParser.SEMVER, 0)
+
+        def EOF(self):
+            return self.getToken(RelayParser.EOF, 0)
+
+        def expr(self):
+            return self.getTypedRuleContext(RelayParser.ExprContext,0)
+
+
+        def METADATA(self):
+            return self.getToken(RelayParser.METADATA, 0)
+
+        def defn(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(RelayParser.DefnContext)
+            else:
+                return self.getTypedRuleContext(RelayParser.DefnContext,i)
+
+
+        def getRuleIndex(self):
+            return RelayParser.RULE_prog
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitProg" ):
+                return visitor.visitProg(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def prog(self):
+
+        localctx = RelayParser.ProgContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 0, self.RULE_prog)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 56
+            self.match(RelayParser.SEMVER)
+            self.state = 64
+            self._errHandler.sync(self)
+            token = self._input.LA(1)
+            if token in [RelayParser.EOF, RelayParser.T__19, RelayParser.T__20, RelayParser.METADATA]:
+                self.state = 60
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                while _la==RelayParser.T__19 or _la==RelayParser.T__20:
+                    self.state = 57
+                    self.defn()
+                    self.state = 62
+                    self._errHandler.sync(self)
+                    _la = self._input.LA(1)
+
+                pass
+            elif token in [RelayParser.T__0, RelayParser.T__1, RelayParser.T__2, RelayParser.T__6, RelayParser.T__8, RelayParser.T__11, RelayParser.T__13, RelayParser.T__17, RelayParser.T__25, RelayParser.QUOTED_STRING, RelayParser.SUB, RelayParser.BOOL_LIT, RelayParser.CNAME, RelayParser.FLOAT, RelayParser.NAT]:
+                self.state = 63
+                self.expr(0)
+                pass
+            else:
+                raise NoViableAltException(self)
+
+            self.state = 67
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            if _la==RelayParser.METADATA:
+                self.state = 66
+                self.match(RelayParser.METADATA)
+
+
+            self.state = 69
+            self.match(RelayParser.EOF)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
     class OpIdentContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
@@ -313,10 +451,10 @@ def accept(self, visitor:ParseTreeVisitor):
     def opIdent(self):
 
         localctx = RelayParser.OpIdentContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 0, self.RULE_opIdent)
+        self.enterRule(localctx, 2, self.RULE_opIdent)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 42
+            self.state = 71
             self.match(RelayParser.CNAME)
         except RecognitionException as re:
             localctx.exception = re
@@ -326,85 +464,186 @@ def opIdent(self):
             self.exitRule()
         return localctx
 
-    class ProgContext(ParserRuleContext):
+
+    class GlobalVarContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
             super().__init__(parent, invokingState)
             self.parser = parser
 
-        def SEMVER(self):
-            return self.getToken(RelayParser.SEMVER, 0)
+        def CNAME(self):
+            return self.getToken(RelayParser.CNAME, 0)
 
-        def EOF(self):
-            return self.getToken(RelayParser.EOF, 0)
+        def getRuleIndex(self):
+            return RelayParser.RULE_globalVar
 
-        def expr(self):
-            return self.getTypedRuleContext(RelayParser.ExprContext,0)
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitGlobalVar" ):
+                return visitor.visitGlobalVar(self)
+            else:
+                return visitor.visitChildren(self)
 
 
-        def METADATA(self):
-            return self.getToken(RelayParser.METADATA, 0)
 
-        def defn(self, i:int=None):
+
+    def globalVar(self):
+
+        localctx = RelayParser.GlobalVarContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 4, self.RULE_globalVar)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 73
+            self.match(RelayParser.T__0)
+            self.state = 74
+            self.match(RelayParser.CNAME)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class LocalVarContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def CNAME(self):
+            return self.getToken(RelayParser.CNAME, 0)
+
+        def getRuleIndex(self):
+            return RelayParser.RULE_localVar
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitLocalVar" ):
+                return visitor.visitLocalVar(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def localVar(self):
+
+        localctx = RelayParser.LocalVarContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 6, self.RULE_localVar)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 76
+            self.match(RelayParser.T__1)
+            self.state = 77
+            self.match(RelayParser.CNAME)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class GlobalTypeVarContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def CNAME(self):
+            return self.getToken(RelayParser.CNAME, 0)
+
+        def typeVar(self, i:int=None):
             if i is None:
-                return self.getTypedRuleContexts(RelayParser.DefnContext)
+                return self.getTypedRuleContexts(RelayParser.TypeVarContext)
             else:
-                return self.getTypedRuleContext(RelayParser.DefnContext,i)
+                return self.getTypedRuleContext(RelayParser.TypeVarContext,i)
 
 
         def getRuleIndex(self):
-            return RelayParser.RULE_prog
+            return RelayParser.RULE_globalTypeVar
 
         def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitProg" ):
-                return visitor.visitProg(self)
+            if hasattr( visitor, "visitGlobalTypeVar" ):
+                return visitor.visitGlobalTypeVar(self)
             else:
                 return visitor.visitChildren(self)
 
 
 
 
-    def prog(self):
+    def globalTypeVar(self):
 
-        localctx = RelayParser.ProgContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 2, self.RULE_prog)
+        localctx = RelayParser.GlobalTypeVarContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 8, self.RULE_globalTypeVar)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 44
-            self.match(RelayParser.SEMVER)
-            self.state = 52
+            self.state = 79
+            self.match(RelayParser.CNAME)
+            self.state = 91
             self._errHandler.sync(self)
-            token = self._input.LA(1)
-            if token in [RelayParser.EOF, RelayParser.T__16, RelayParser.METADATA]:
-                self.state = 48
+            la_ = self._interp.adaptivePredict(self._input,4,self._ctx)
+            if la_ == 1:
+                self.state = 80
+                self.match(RelayParser.T__2)
+                self.state = 81
+                self.typeVar()
+                self.state = 86
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                while _la==RelayParser.T__16:
-                    self.state = 45
-                    self.defn()
-                    self.state = 50
+                while _la==RelayParser.T__3:
+                    self.state = 82
+                    self.match(RelayParser.T__3)
+                    self.state = 83
+                    self.typeVar()
+                    self.state = 88
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
-                pass
-            elif token in [RelayParser.T__1, RelayParser.T__3, RelayParser.T__6, RelayParser.T__8, RelayParser.T__10, RelayParser.T__14, RelayParser.T__20, RelayParser.QUOTED_STRING, RelayParser.SUB, RelayParser.BOOL_LIT, RelayParser.CNAME, RelayParser.GLOBAL_VAR, RelayParser.LOCAL_VAR, RelayParser.GRAPH_VAR, RelayParser.FLOAT, RelayParser.NAT]:
-                self.state = 51
-                self.expr(0)
-                pass
+                self.state = 89
+                self.match(RelayParser.T__4)
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class TypeVarContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def CNAME(self):
+            return self.getToken(RelayParser.CNAME, 0)
+
+        def getRuleIndex(self):
+            return RelayParser.RULE_typeVar
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitTypeVar" ):
+                return visitor.visitTypeVar(self)
             else:
-                raise NoViableAltException(self)
+                return visitor.visitChildren(self)
 
-            self.state = 55
-            self._errHandler.sync(self)
-            _la = self._input.LA(1)
-            if _la==RelayParser.METADATA:
-                self.state = 54
-                self.match(RelayParser.METADATA)
 
 
-            self.state = 57
-            self.match(RelayParser.EOF)
+
+    def typeVar(self):
+
+        localctx = RelayParser.TypeVarContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 10, self.RULE_typeVar)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 93
+            self.match(RelayParser.CNAME)
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -413,6 +652,47 @@ def prog(self):
             self.exitRule()
         return localctx
 
+
+    class GraphVarContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def NAT(self):
+            return self.getToken(RelayParser.NAT, 0)
+
+        def getRuleIndex(self):
+            return RelayParser.RULE_graphVar
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitGraphVar" ):
+                return visitor.visitGraphVar(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def graphVar(self):
+
+        localctx = RelayParser.GraphVarContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 12, self.RULE_graphVar)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 95
+            self.match(RelayParser.T__1)
+            self.state = 96
+            self.match(RelayParser.NAT)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
     class ExprListContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
@@ -441,25 +721,25 @@ def accept(self, visitor:ParseTreeVisitor):
     def exprList(self):
 
         localctx = RelayParser.ExprListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 4, self.RULE_exprList)
+        self.enterRule(localctx, 14, self.RULE_exprList)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 67
+            self.state = 106
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__1) | (1 << RelayParser.T__3) | (1 << RelayParser.T__6) | (1 << RelayParser.T__8) | (1 << RelayParser.T__10) | (1 << RelayParser.T__14) | (1 << RelayParser.T__20) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.CNAME) | (1 << RelayParser.GLOBAL_VAR) | (1 << RelayParser.LOCAL_VAR) | (1 << RelayParser.GRAPH_VAR) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
-                self.state = 59
+            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__0) | (1 << RelayParser.T__1) | (1 << RelayParser.T__2) | (1 << RelayParser.T__6) | (1 << RelayParser.T__8) | (1 << RelayParser.T__11) | (1 << RelayParser.T__13) | (1 << RelayParser.T__17) | (1 << RelayParser.T__25) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
+                self.state = 98
                 self.expr(0)
-                self.state = 64
+                self.state = 103
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                while _la==RelayParser.T__0:
-                    self.state = 60
-                    self.match(RelayParser.T__0)
-                    self.state = 61
+                while _la==RelayParser.T__5:
+                    self.state = 99
+                    self.match(RelayParser.T__5)
+                    self.state = 100
                     self.expr(0)
-                    self.state = 66
+                    self.state = 105
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
@@ -473,6 +753,7 @@ def exprList(self):
             self.exitRule()
         return localctx
 
+
     class CallListContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
@@ -533,35 +814,35 @@ def accept(self, visitor:ParseTreeVisitor):
     def callList(self):
 
         localctx = RelayParser.CallListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 6, self.RULE_callList)
+        self.enterRule(localctx, 16, self.RULE_callList)
         try:
-            self.state = 79
+            self.state = 118
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,6,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,8,self._ctx)
             if la_ == 1:
                 localctx = RelayParser.CallNoAttrContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 69
+                self.state = 108
                 self.exprList()
                 pass
 
             elif la_ == 2:
                 localctx = RelayParser.CallWithAttrContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 75
+                self.state = 114
                 self._errHandler.sync(self)
-                _alt = self._interp.adaptivePredict(self._input,5,self._ctx)
+                _alt = self._interp.adaptivePredict(self._input,7,self._ctx)
                 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                     if _alt==1:
-                        self.state = 70
+                        self.state = 109
                         self.expr(0)
-                        self.state = 71
-                        self.match(RelayParser.T__0) 
-                    self.state = 77
+                        self.state = 110
+                        self.match(RelayParser.T__5) 
+                    self.state = 116
                     self._errHandler.sync(self)
-                    _alt = self._interp.adaptivePredict(self._input,5,self._ctx)
+                    _alt = self._interp.adaptivePredict(self._input,7,self._ctx)
 
-                self.state = 78
+                self.state = 117
                 self.attrSeq()
                 pass
 
@@ -574,6 +855,7 @@ def callList(self):
             self.exitRule()
         return localctx
 
+
     class ExprContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
@@ -649,8 +931,9 @@ def __init__(self, parser, ctx:ParserRuleContext): # actually a RelayParser.Expr
             super().__init__(parser)
             self.copyFrom(ctx)
 
-        def GRAPH_VAR(self):
-            return self.getToken(RelayParser.GRAPH_VAR, 0)
+        def graphVar(self):
+            return self.getTypedRuleContext(RelayParser.GraphVarContext,0)
+
         def expr(self, i:int=None):
             if i is None:
                 return self.getTypedRuleContexts(RelayParser.ExprContext)
@@ -724,6 +1007,8 @@ def __init__(self, parser, ctx:ParserRuleContext): # actually a RelayParser.Expr
             super().__init__(parser)
             self.copyFrom(ctx)
 
+        def SUB(self):
+            return self.getToken(RelayParser.SUB, 0)
         def expr(self):
             return self.getTypedRuleContext(RelayParser.ExprContext,0)
 
@@ -867,6 +1152,26 @@ def expr(self, i:int=None):
             else:
                 return self.getTypedRuleContext(RelayParser.ExprContext,i)
 
+        def MUL(self):
+            return self.getToken(RelayParser.MUL, 0)
+        def DIV(self):
+            return self.getToken(RelayParser.DIV, 0)
+        def ADD(self):
+            return self.getToken(RelayParser.ADD, 0)
+        def SUB(self):
+            return self.getToken(RelayParser.SUB, 0)
+        def LT(self):
+            return self.getToken(RelayParser.LT, 0)
+        def GT(self):
+            return self.getToken(RelayParser.GT, 0)
+        def LE(self):
+            return self.getToken(RelayParser.LE, 0)
+        def GE(self):
+            return self.getToken(RelayParser.GE, 0)
+        def EQ(self):
+            return self.getToken(RelayParser.EQ, 0)
+        def NE(self):
+            return self.getToken(RelayParser.NE, 0)
 
         def accept(self, visitor:ParseTreeVisitor):
             if hasattr( visitor, "visitBinOp" ):
@@ -881,46 +1186,46 @@ def expr(self, _p:int=0):
         _parentState = self.state
         localctx = RelayParser.ExprContext(self, self._ctx, _parentState)
         _prevctx = localctx
-        _startState = 8
-        self.enterRecursionRule(localctx, 8, self.RULE_expr, _p)
+        _startState = 18
+        self.enterRecursionRule(localctx, 18, self.RULE_expr, _p)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 147
+            self.state = 186
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,10,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,12,self._ctx)
             if la_ == 1:
                 localctx = RelayParser.ParenContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
 
-                self.state = 82
-                self.match(RelayParser.T__1)
-                self.state = 83
+                self.state = 121
+                self.match(RelayParser.T__6)
+                self.state = 122
                 self.expr(0)
-                self.state = 84
-                self.match(RelayParser.T__2)
+                self.state = 123
+                self.match(RelayParser.T__7)
                 pass
 
             elif la_ == 2:
                 localctx = RelayParser.ParenContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 86
-                self.match(RelayParser.T__3)
-                self.state = 87
+                self.state = 125
+                self.match(RelayParser.T__8)
+                self.state = 126
                 self.expr(0)
-                self.state = 88
-                self.match(RelayParser.T__4)
+                self.state = 127
+                self.match(RelayParser.T__9)
                 pass
 
             elif la_ == 3:
                 localctx = RelayParser.NegContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 90
+                self.state = 129
                 self.match(RelayParser.SUB)
-                self.state = 91
+                self.state = 130
                 self.expr(19)
                 pass
 
@@ -928,7 +1233,7 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.FuncExprContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 92
+                self.state = 131
                 self.func()
                 pass
 
@@ -936,99 +1241,99 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.TupleContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 93
-                self.match(RelayParser.T__1)
-                self.state = 94
-                self.match(RelayParser.T__2)
+                self.state = 132
+                self.match(RelayParser.T__6)
+                self.state = 133
+                self.match(RelayParser.T__7)
                 pass
 
             elif la_ == 6:
                 localctx = RelayParser.TupleContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 95
-                self.match(RelayParser.T__1)
-                self.state = 96
+                self.state = 134
+                self.match(RelayParser.T__6)
+                self.state = 135
                 self.expr(0)
-                self.state = 97
-                self.match(RelayParser.T__0)
-                self.state = 98
-                self.match(RelayParser.T__2)
+                self.state = 136
+                self.match(RelayParser.T__5)
+                self.state = 137
+                self.match(RelayParser.T__7)
                 pass
 
             elif la_ == 7:
                 localctx = RelayParser.TupleContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 100
-                self.match(RelayParser.T__1)
-                self.state = 101
+                self.state = 139
+                self.match(RelayParser.T__6)
+                self.state = 140
                 self.expr(0)
-                self.state = 104 
+                self.state = 143 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while True:
-                    self.state = 102
-                    self.match(RelayParser.T__0)
-                    self.state = 103
+                    self.state = 141
+                    self.match(RelayParser.T__5)
+                    self.state = 142
                     self.expr(0)
-                    self.state = 106 
+                    self.state = 145 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
-                    if not (_la==RelayParser.T__0):
+                    if not (_la==RelayParser.T__5):
                         break
 
-                self.state = 108
-                self.match(RelayParser.T__2)
+                self.state = 147
+                self.match(RelayParser.T__7)
                 pass
 
             elif la_ == 8:
                 localctx = RelayParser.TensorContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 110
-                self.match(RelayParser.T__6)
-                self.state = 119
+                self.state = 149
+                self.match(RelayParser.T__2)
+                self.state = 158
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__1) | (1 << RelayParser.T__3) | (1 << RelayParser.T__6) | (1 << RelayParser.T__8) | (1 << RelayParser.T__10) | (1 << RelayParser.T__14) | (1 << RelayParser.T__20) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.CNAME) | (1 << RelayParser.GLOBAL_VAR) | (1 << RelayParser.LOCAL_VAR) | (1 << RelayParser.GRAPH_VAR) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
-                    self.state = 111
+                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__0) | (1 << RelayParser.T__1) | (1 << RelayParser.T__2) | (1 << RelayParser.T__6) | (1 << RelayParser.T__8) | (1 << RelayParser.T__11) | (1 << RelayParser.T__13) | (1 << RelayParser.T__17) | (1 << RelayParser.T__25) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
+                    self.state = 150
                     self.expr(0)
-                    self.state = 116
+                    self.state = 155
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
-                    while _la==RelayParser.T__0:
-                        self.state = 112
-                        self.match(RelayParser.T__0)
-                        self.state = 113
+                    while _la==RelayParser.T__5:
+                        self.state = 151
+                        self.match(RelayParser.T__5)
+                        self.state = 152
                         self.expr(0)
-                        self.state = 118
+                        self.state = 157
                         self._errHandler.sync(self)
                         _la = self._input.LA(1)
 
 
 
-                self.state = 121
-                self.match(RelayParser.T__7)
+                self.state = 160
+                self.match(RelayParser.T__4)
                 pass
 
             elif la_ == 9:
                 localctx = RelayParser.IfElseContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 122
-                self.match(RelayParser.T__8)
-                self.state = 123
-                self.match(RelayParser.T__1)
-                self.state = 124
+                self.state = 161
+                self.match(RelayParser.T__11)
+                self.state = 162
+                self.match(RelayParser.T__6)
+                self.state = 163
                 self.expr(0)
-                self.state = 125
-                self.match(RelayParser.T__2)
-                self.state = 126
+                self.state = 164
+                self.match(RelayParser.T__7)
+                self.state = 165
                 self.body()
-                self.state = 127
-                self.match(RelayParser.T__9)
-                self.state = 128
+                self.state = 166
+                self.match(RelayParser.T__12)
+                self.state = 167
                 self.body()
                 pass
 
@@ -1036,17 +1341,17 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.LetContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 130
-                self.match(RelayParser.T__10)
-                self.state = 131
+                self.state = 169
+                self.match(RelayParser.T__13)
+                self.state = 170
                 self.var()
-                self.state = 132
-                self.match(RelayParser.T__11)
-                self.state = 133
+                self.state = 171
+                self.match(RelayParser.T__14)
+                self.state = 172
                 self.expr(0)
-                self.state = 134
-                self.match(RelayParser.T__12)
-                self.state = 135
+                self.state = 173
+                self.match(RelayParser.T__15)
+                self.state = 174
                 self.expr(7)
                 pass
 
@@ -1054,15 +1359,15 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.GraphContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 137
-                self.match(RelayParser.GRAPH_VAR)
-                self.state = 138
-                self.match(RelayParser.T__11)
-                self.state = 139
+                self.state = 176
+                self.graphVar()
+                self.state = 177
+                self.match(RelayParser.T__14)
+                self.state = 178
                 self.expr(0)
-                self.state = 140
-                self.match(RelayParser.T__12)
-                self.state = 141
+                self.state = 179
+                self.match(RelayParser.T__15)
+                self.state = 180
                 self.expr(5)
                 pass
 
@@ -1070,7 +1375,7 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.IdentExprContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 143
+                self.state = 182
                 self.ident()
                 pass
 
@@ -1078,7 +1383,7 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.ScalarExprContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 144
+                self.state = 183
                 self.scalar()
                 pass
 
@@ -1086,7 +1391,7 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.MetaExprContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 145
+                self.state = 184
                 self.meta()
                 pass
 
@@ -1094,31 +1399,31 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.StringExprContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 146
+                self.state = 185
                 self.match(RelayParser.QUOTED_STRING)
                 pass
 
 
             self._ctx.stop = self._input.LT(-1)
-            self.state = 174
+            self.state = 213
             self._errHandler.sync(self)
-            _alt = self._interp.adaptivePredict(self._input,12,self._ctx)
+            _alt = self._interp.adaptivePredict(self._input,14,self._ctx)
             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                 if _alt==1:
                     if self._parseListeners is not None:
                         self.triggerExitRuleEvent()
                     _prevctx = localctx
-                    self.state = 172
+                    self.state = 211
                     self._errHandler.sync(self)
-                    la_ = self._interp.adaptivePredict(self._input,11,self._ctx)
+                    la_ = self._interp.adaptivePredict(self._input,13,self._ctx)
                     if la_ == 1:
                         localctx = RelayParser.BinOpContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 149
+                        self.state = 188
                         if not self.precpred(self._ctx, 18):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 18)")
-                        self.state = 150
+                        self.state = 189
                         localctx.op = self._input.LT(1)
                         _la = self._input.LA(1)
                         if not(_la==RelayParser.MUL or _la==RelayParser.DIV):
@@ -1126,18 +1431,18 @@ def expr(self, _p:int=0):
                         else:
                             self._errHandler.reportMatch(self)
                             self.consume()
-                        self.state = 151
+                        self.state = 190
                         self.expr(19)
                         pass
 
                     elif la_ == 2:
                         localctx = RelayParser.BinOpContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 152
+                        self.state = 191
                         if not self.precpred(self._ctx, 17):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 17)")
-                        self.state = 153
+                        self.state = 192
                         localctx.op = self._input.LT(1)
                         _la = self._input.LA(1)
                         if not(_la==RelayParser.ADD or _la==RelayParser.SUB):
@@ -1145,18 +1450,18 @@ def expr(self, _p:int=0):
                         else:
                             self._errHandler.reportMatch(self)
                             self.consume()
-                        self.state = 154
+                        self.state = 193
                         self.expr(18)
                         pass
 
                     elif la_ == 3:
                         localctx = RelayParser.BinOpContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 155
+                        self.state = 194
                         if not self.precpred(self._ctx, 16):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 16)")
-                        self.state = 156
+                        self.state = 195
                         localctx.op = self._input.LT(1)
                         _la = self._input.LA(1)
                         if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.LT) | (1 << RelayParser.GT) | (1 << RelayParser.LE) | (1 << RelayParser.GE))) != 0)):
@@ -1164,18 +1469,18 @@ def expr(self, _p:int=0):
                         else:
                             self._errHandler.reportMatch(self)
                             self.consume()
-                        self.state = 157
+                        self.state = 196
                         self.expr(17)
                         pass
 
                     elif la_ == 4:
                         localctx = RelayParser.BinOpContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 158
+                        self.state = 197
                         if not self.precpred(self._ctx, 15):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 15)")
-                        self.state = 159
+                        self.state = 198
                         localctx.op = self._input.LT(1)
                         _la = self._input.LA(1)
                         if not(_la==RelayParser.EQ or _la==RelayParser.NE):
@@ -1183,133 +1488,353 @@ def expr(self, _p:int=0):
                         else:
                             self._errHandler.reportMatch(self)
                             self.consume()
-                        self.state = 160
+                        self.state = 199
                         self.expr(16)
                         pass
 
                     elif la_ == 5:
                         localctx = RelayParser.LetContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 161
+                        self.state = 200
                         if not self.precpred(self._ctx, 6):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
-                        self.state = 162
-                        self.match(RelayParser.T__13)
-                        self.state = 163
+                        self.state = 201
+                        self.match(RelayParser.T__16)
+                        self.state = 202
                         self.expr(7)
                         pass
 
                     elif la_ == 6:
                         localctx = RelayParser.CallContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 164
+                        self.state = 203
                         if not self.precpred(self._ctx, 20):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 20)")
-                        self.state = 165
-                        self.match(RelayParser.T__1)
-                        self.state = 166
+                        self.state = 204
+                        self.match(RelayParser.T__6)
+                        self.state = 205
                         self.callList()
-                        self.state = 167
-                        self.match(RelayParser.T__2)
+                        self.state = 206
+                        self.match(RelayParser.T__7)
+                        pass
+
+                    elif la_ == 7:
+                        localctx = RelayParser.ProjectionContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
+                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
+                        self.state = 208
+                        if not self.precpred(self._ctx, 10):
+                            from antlr4.error.Errors import FailedPredicateException
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 10)")
+                        self.state = 209
+                        self.match(RelayParser.T__10)
+                        self.state = 210
+                        self.match(RelayParser.NAT)
                         pass
 
-                    elif la_ == 7:
-                        localctx = RelayParser.ProjectionContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
-                        self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 169
-                        if not self.precpred(self._ctx, 10):
-                            from antlr4.error.Errors import FailedPredicateException
-                            raise FailedPredicateException(self, "self.precpred(self._ctx, 10)")
-                        self.state = 170
-                        self.match(RelayParser.T__5)
-                        self.state = 171
-                        self.match(RelayParser.NAT)
-                        pass
+             
+                self.state = 215
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,14,self._ctx)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.unrollRecursionContexts(_parentctx)
+        return localctx
+
+
+    class FuncContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def argList(self):
+            return self.getTypedRuleContext(RelayParser.ArgListContext,0)
+
+
+        def body(self):
+            return self.getTypedRuleContext(RelayParser.BodyContext,0)
+
+
+        def typeParamList(self):
+            return self.getTypedRuleContext(RelayParser.TypeParamListContext,0)
+
+
+        def type_(self):
+            return self.getTypedRuleContext(RelayParser.Type_Context,0)
+
+
+        def getRuleIndex(self):
+            return RelayParser.RULE_func
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitFunc" ):
+                return visitor.visitFunc(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def func(self):
+
+        localctx = RelayParser.FuncContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 20, self.RULE_func)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 216
+            self.match(RelayParser.T__17)
+            self.state = 218
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            if _la==RelayParser.T__2:
+                self.state = 217
+                self.typeParamList()
+
+
+            self.state = 220
+            self.match(RelayParser.T__6)
+            self.state = 221
+            self.argList()
+            self.state = 222
+            self.match(RelayParser.T__7)
+            self.state = 225
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            if _la==RelayParser.T__18:
+                self.state = 223
+                self.match(RelayParser.T__18)
+                self.state = 224
+                self.type_()
+
+
+            self.state = 227
+            self.body()
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class DefnContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+
+        def getRuleIndex(self):
+            return RelayParser.RULE_defn
+
+     
+        def copyFrom(self, ctx:ParserRuleContext):
+            super().copyFrom(ctx)
+
+
+
+    class FuncDefnContext(DefnContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a RelayParser.DefnContext
+            super().__init__(parser)
+            self.copyFrom(ctx)
+
+        def globalVar(self):
+            return self.getTypedRuleContext(RelayParser.GlobalVarContext,0)
+
+        def argList(self):
+            return self.getTypedRuleContext(RelayParser.ArgListContext,0)
+
+        def body(self):
+            return self.getTypedRuleContext(RelayParser.BodyContext,0)
+
+        def typeParamList(self):
+            return self.getTypedRuleContext(RelayParser.TypeParamListContext,0)
+
+        def type_(self):
+            return self.getTypedRuleContext(RelayParser.Type_Context,0)
+
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitFuncDefn" ):
+                return visitor.visitFuncDefn(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+    class AdtDefnContext(DefnContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a RelayParser.DefnContext
+            super().__init__(parser)
+            self.copyFrom(ctx)
+
+        def globalTypeVar(self):
+            return self.getTypedRuleContext(RelayParser.GlobalTypeVarContext,0)
+
+        def adtVariant(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(RelayParser.AdtVariantContext)
+            else:
+                return self.getTypedRuleContext(RelayParser.AdtVariantContext,i)
+
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitAdtDefn" ):
+                return visitor.visitAdtDefn(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+    def defn(self):
+
+        localctx = RelayParser.DefnContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 22, self.RULE_defn)
+        self._la = 0 # Token type
+        try:
+            self.state = 251
+            self._errHandler.sync(self)
+            token = self._input.LA(1)
+            if token in [RelayParser.T__19]:
+                localctx = RelayParser.FuncDefnContext(self, localctx)
+                self.enterOuterAlt(localctx, 1)
+                self.state = 229
+                self.match(RelayParser.T__19)
+                self.state = 230
+                self.globalVar()
+                self.state = 232
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                if _la==RelayParser.T__2:
+                    self.state = 231
+                    self.typeParamList()
+
+
+                self.state = 234
+                self.match(RelayParser.T__6)
+                self.state = 235
+                self.argList()
+                self.state = 236
+                self.match(RelayParser.T__7)
+                self.state = 239
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                if _la==RelayParser.T__18:
+                    self.state = 237
+                    self.match(RelayParser.T__18)
+                    self.state = 238
+                    self.type_()
+
 
-             
-                self.state = 176
+                self.state = 241
+                self.body()
+                pass
+            elif token in [RelayParser.T__20]:
+                localctx = RelayParser.AdtDefnContext(self, localctx)
+                self.enterOuterAlt(localctx, 2)
+                self.state = 243
+                self.match(RelayParser.T__20)
+                self.state = 244
+                self.globalTypeVar()
+                self.state = 245
+                self.match(RelayParser.T__14)
+                self.state = 247 
                 self._errHandler.sync(self)
-                _alt = self._interp.adaptivePredict(self._input,12,self._ctx)
+                _la = self._input.LA(1)
+                while True:
+                    self.state = 246
+                    self.adtVariant()
+                    self.state = 249 
+                    self._errHandler.sync(self)
+                    _la = self._input.LA(1)
+                    if not (_la==RelayParser.T__21):
+                        break
+
+                pass
+            else:
+                raise NoViableAltException(self)
 
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
             self._errHandler.recover(self, re)
         finally:
-            self.unrollRecursionContexts(_parentctx)
+            self.exitRule()
         return localctx
 
-    class FuncContext(ParserRuleContext):
+
+    class AdtVariantContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
             super().__init__(parent, invokingState)
             self.parser = parser
 
-        def argList(self):
-            return self.getTypedRuleContext(RelayParser.ArgListContext,0)
-
-
-        def body(self):
-            return self.getTypedRuleContext(RelayParser.BodyContext,0)
-
-
-        def typeParamList(self):
-            return self.getTypedRuleContext(RelayParser.TypeParamListContext,0)
+        def variantName(self):
+            return self.getTypedRuleContext(RelayParser.VariantNameContext,0)
 
 
-        def type_(self):
-            return self.getTypedRuleContext(RelayParser.Type_Context,0)
+        def type_(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(RelayParser.Type_Context)
+            else:
+                return self.getTypedRuleContext(RelayParser.Type_Context,i)
 
 
         def getRuleIndex(self):
-            return RelayParser.RULE_func
+            return RelayParser.RULE_adtVariant
 
         def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitFunc" ):
-                return visitor.visitFunc(self)
+            if hasattr( visitor, "visitAdtVariant" ):
+                return visitor.visitAdtVariant(self)
             else:
                 return visitor.visitChildren(self)
 
 
 
 
-    def func(self):
+    def adtVariant(self):
 
-        localctx = RelayParser.FuncContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 10, self.RULE_func)
+        localctx = RelayParser.AdtVariantContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 24, self.RULE_adtVariant)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 177
-            self.match(RelayParser.T__14)
-            self.state = 179
+            self.state = 253
+            self.match(RelayParser.T__21)
+            self.state = 254
+            self.variantName()
+            self.state = 266
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==RelayParser.T__6:
-                self.state = 178
-                self.typeParamList()
-
-
-            self.state = 181
-            self.match(RelayParser.T__1)
-            self.state = 182
-            self.argList()
-            self.state = 183
-            self.match(RelayParser.T__2)
-            self.state = 186
-            self._errHandler.sync(self)
-            _la = self._input.LA(1)
-            if _la==RelayParser.T__15:
-                self.state = 184
-                self.match(RelayParser.T__15)
-                self.state = 185
+                self.state = 255
+                self.match(RelayParser.T__6)
+                self.state = 256
                 self.type_()
+                self.state = 261
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                while _la==RelayParser.T__3:
+                    self.state = 257
+                    self.match(RelayParser.T__3)
+                    self.state = 258
+                    self.type_()
+                    self.state = 263
+                    self._errHandler.sync(self)
+                    _la = self._input.LA(1)
+
+                self.state = 264
+                self.match(RelayParser.T__7)
 
 
-            self.state = 188
-            self.body()
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -1318,81 +1843,36 @@ def func(self):
             self.exitRule()
         return localctx
 
-    class DefnContext(ParserRuleContext):
+
+    class VariantNameContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
             super().__init__(parent, invokingState)
             self.parser = parser
 
-        def ident(self):
-            return self.getTypedRuleContext(RelayParser.IdentContext,0)
-
-
-        def argList(self):
-            return self.getTypedRuleContext(RelayParser.ArgListContext,0)
-
-
-        def body(self):
-            return self.getTypedRuleContext(RelayParser.BodyContext,0)
-
-
-        def typeParamList(self):
-            return self.getTypedRuleContext(RelayParser.TypeParamListContext,0)
-
-
-        def type_(self):
-            return self.getTypedRuleContext(RelayParser.Type_Context,0)
-
+        def CNAME(self):
+            return self.getToken(RelayParser.CNAME, 0)
 
         def getRuleIndex(self):
-            return RelayParser.RULE_defn
+            return RelayParser.RULE_variantName
 
         def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitDefn" ):
-                return visitor.visitDefn(self)
+            if hasattr( visitor, "visitVariantName" ):
+                return visitor.visitVariantName(self)
             else:
                 return visitor.visitChildren(self)
 
 
 
 
-    def defn(self):
+    def variantName(self):
 
-        localctx = RelayParser.DefnContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 12, self.RULE_defn)
-        self._la = 0 # Token type
+        localctx = RelayParser.VariantNameContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 26, self.RULE_variantName)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 190
-            self.match(RelayParser.T__16)
-            self.state = 191
-            self.ident()
-            self.state = 193
-            self._errHandler.sync(self)
-            _la = self._input.LA(1)
-            if _la==RelayParser.T__6:
-                self.state = 192
-                self.typeParamList()
-
-
-            self.state = 195
-            self.match(RelayParser.T__1)
-            self.state = 196
-            self.argList()
-            self.state = 197
-            self.match(RelayParser.T__2)
-            self.state = 200
-            self._errHandler.sync(self)
-            _la = self._input.LA(1)
-            if _la==RelayParser.T__15:
-                self.state = 198
-                self.match(RelayParser.T__15)
-                self.state = 199
-                self.type_()
-
-
-            self.state = 202
-            self.body()
+            self.state = 268
+            self.match(RelayParser.CNAME)
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -1401,6 +1881,7 @@ def defn(self):
             self.exitRule()
         return localctx
 
+
     class ArgListContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
@@ -1461,35 +1942,35 @@ def accept(self, visitor:ParseTreeVisitor):
     def argList(self):
 
         localctx = RelayParser.ArgListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 14, self.RULE_argList)
+        self.enterRule(localctx, 28, self.RULE_argList)
         self._la = 0 # Token type
         try:
-            self.state = 214
+            self.state = 280
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,18,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,24,self._ctx)
             if la_ == 1:
                 localctx = RelayParser.ArgNoAttrContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 204
+                self.state = 270
                 self.varList()
                 pass
 
             elif la_ == 2:
                 localctx = RelayParser.ArgWithAttrContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 210
+                self.state = 276
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                while _la==RelayParser.LOCAL_VAR:
-                    self.state = 205
+                while _la==RelayParser.T__1:
+                    self.state = 271
                     self.var()
-                    self.state = 206
-                    self.match(RelayParser.T__0)
-                    self.state = 212
+                    self.state = 272
+                    self.match(RelayParser.T__5)
+                    self.state = 278
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
-                self.state = 213
+                self.state = 279
                 self.attrSeq()
                 pass
 
@@ -1502,6 +1983,7 @@ def argList(self):
             self.exitRule()
         return localctx
 
+
     class VarListContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
@@ -1530,25 +2012,25 @@ def accept(self, visitor:ParseTreeVisitor):
     def varList(self):
 
         localctx = RelayParser.VarListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 16, self.RULE_varList)
+        self.enterRule(localctx, 30, self.RULE_varList)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 224
+            self.state = 290
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==RelayParser.LOCAL_VAR:
-                self.state = 216
+            if _la==RelayParser.T__1:
+                self.state = 282
                 self.var()
-                self.state = 221
+                self.state = 287
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                while _la==RelayParser.T__0:
-                    self.state = 217
-                    self.match(RelayParser.T__0)
-                    self.state = 218
+                while _la==RelayParser.T__5:
+                    self.state = 283
+                    self.match(RelayParser.T__5)
+                    self.state = 284
                     self.var()
-                    self.state = 223
+                    self.state = 289
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
@@ -1562,14 +2044,16 @@ def varList(self):
             self.exitRule()
         return localctx
 
+
     class VarContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
             super().__init__(parent, invokingState)
             self.parser = parser
 
-        def LOCAL_VAR(self):
-            return self.getToken(RelayParser.LOCAL_VAR, 0)
+        def localVar(self):
+            return self.getTypedRuleContext(RelayParser.LocalVarContext,0)
+
 
         def type_(self):
             return self.getTypedRuleContext(RelayParser.Type_Context,0)
@@ -1590,19 +2074,19 @@ def accept(self, visitor:ParseTreeVisitor):
     def var(self):
 
         localctx = RelayParser.VarContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 18, self.RULE_var)
+        self.enterRule(localctx, 32, self.RULE_var)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 226
-            self.match(RelayParser.LOCAL_VAR)
-            self.state = 229
+            self.state = 292
+            self.localVar()
+            self.state = 295
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==RelayParser.T__17:
-                self.state = 227
-                self.match(RelayParser.T__17)
-                self.state = 228
+            if _la==RelayParser.T__22:
+                self.state = 293
+                self.match(RelayParser.T__22)
+                self.state = 294
                 self.type_()
 
 
@@ -1614,6 +2098,7 @@ def var(self):
             self.exitRule()
         return localctx
 
+
     class AttrSeqContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
@@ -1642,21 +2127,21 @@ def accept(self, visitor:ParseTreeVisitor):
     def attrSeq(self):
 
         localctx = RelayParser.AttrSeqContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 20, self.RULE_attrSeq)
+        self.enterRule(localctx, 34, self.RULE_attrSeq)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 231
+            self.state = 297
             self.attr()
-            self.state = 236
+            self.state = 302
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            while _la==RelayParser.T__0:
-                self.state = 232
-                self.match(RelayParser.T__0)
-                self.state = 233
+            while _la==RelayParser.T__5:
+                self.state = 298
+                self.match(RelayParser.T__5)
+                self.state = 299
                 self.attr()
-                self.state = 238
+                self.state = 304
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
@@ -1668,6 +2153,7 @@ def attrSeq(self):
             self.exitRule()
         return localctx
 
+
     class AttrContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
@@ -1696,14 +2182,14 @@ def accept(self, visitor:ParseTreeVisitor):
     def attr(self):
 
         localctx = RelayParser.AttrContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 22, self.RULE_attr)
+        self.enterRule(localctx, 36, self.RULE_attr)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 239
+            self.state = 305
             self.match(RelayParser.CNAME)
-            self.state = 240
-            self.match(RelayParser.T__11)
-            self.state = 241
+            self.state = 306
+            self.match(RelayParser.T__14)
+            self.state = 307
             self.expr(0)
         except RecognitionException as re:
             localctx.exception = re
@@ -1713,6 +2199,7 @@ def attr(self):
             self.exitRule()
         return localctx
 
+
     class TypeParamListContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
@@ -1741,40 +2228,40 @@ def accept(self, visitor:ParseTreeVisitor):
     def typeParamList(self):
 
         localctx = RelayParser.TypeParamListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 24, self.RULE_typeParamList)
+        self.enterRule(localctx, 38, self.RULE_typeParamList)
         self._la = 0 # Token type
         try:
-            self.state = 256
+            self.state = 322
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,24,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,30,self._ctx)
             if la_ == 1:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 243
-                self.match(RelayParser.T__6)
-                self.state = 244
-                self.match(RelayParser.T__7)
+                self.state = 309
+                self.match(RelayParser.T__2)
+                self.state = 310
+                self.match(RelayParser.T__4)
                 pass
 
             elif la_ == 2:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 245
-                self.match(RelayParser.T__6)
-                self.state = 246
+                self.state = 311
+                self.match(RelayParser.T__2)
+                self.state = 312
                 self.ident()
-                self.state = 251
+                self.state = 317
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                while _la==RelayParser.T__0:
-                    self.state = 247
-                    self.match(RelayParser.T__0)
-                    self.state = 248
+                while _la==RelayParser.T__5:
+                    self.state = 313
+                    self.match(RelayParser.T__5)
+                    self.state = 314
                     self.ident()
-                    self.state = 253
+                    self.state = 319
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
-                self.state = 254
-                self.match(RelayParser.T__7)
+                self.state = 320
+                self.match(RelayParser.T__4)
                 pass
 
 
@@ -1786,6 +2273,7 @@ def typeParamList(self):
             self.exitRule()
         return localctx
 
+
     class Type_Context(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
@@ -1838,19 +2326,19 @@ def accept(self, visitor:ParseTreeVisitor):
                 return visitor.visitChildren(self)
 
 
-    class TypeIdentTypeContext(Type_Context):
+    class GlobalTypeVarTypeContext(Type_Context):
 
         def __init__(self, parser, ctx:ParserRuleContext): # actually a RelayParser.Type_Context
             super().__init__(parser)
             self.copyFrom(ctx)
 
-        def typeIdent(self):
-            return self.getTypedRuleContext(RelayParser.TypeIdentContext,0)
+        def globalTypeVar(self):
+            return self.getTypedRuleContext(RelayParser.GlobalTypeVarContext,0)
 
 
         def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitTypeIdentType" ):
-                return visitor.visitTypeIdentType(self)
+            if hasattr( visitor, "visitGlobalTypeVarType" ):
+                return visitor.visitGlobalTypeVarType(self)
             else:
                 return visitor.visitChildren(self)
 
@@ -1916,137 +2404,137 @@ def accept(self, visitor:ParseTreeVisitor):
     def type_(self):
 
         localctx = RelayParser.Type_Context(self, self._ctx, self.state)
-        self.enterRule(localctx, 26, self.RULE_type_)
+        self.enterRule(localctx, 40, self.RULE_type_)
         self._la = 0 # Token type
         try:
-            self.state = 303
+            self.state = 369
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,29,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
             if la_ == 1:
                 localctx = RelayParser.TupleTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 258
-                self.match(RelayParser.T__1)
-                self.state = 259
-                self.match(RelayParser.T__2)
+                self.state = 324
+                self.match(RelayParser.T__6)
+                self.state = 325
+                self.match(RelayParser.T__7)
                 pass
 
             elif la_ == 2:
                 localctx = RelayParser.TupleTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 260
-                self.match(RelayParser.T__1)
-                self.state = 261
+                self.state = 326
+                self.match(RelayParser.T__6)
+                self.state = 327
                 self.type_()
-                self.state = 262
-                self.match(RelayParser.T__0)
-                self.state = 263
-                self.match(RelayParser.T__2)
+                self.state = 328
+                self.match(RelayParser.T__5)
+                self.state = 329
+                self.match(RelayParser.T__7)
                 pass
 
             elif la_ == 3:
                 localctx = RelayParser.TupleTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 3)
-                self.state = 265
-                self.match(RelayParser.T__1)
-                self.state = 266
+                self.state = 331
+                self.match(RelayParser.T__6)
+                self.state = 332
                 self.type_()
-                self.state = 269 
+                self.state = 335 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while True:
-                    self.state = 267
-                    self.match(RelayParser.T__0)
-                    self.state = 268
+                    self.state = 333
+                    self.match(RelayParser.T__5)
+                    self.state = 334
                     self.type_()
-                    self.state = 271 
+                    self.state = 337 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
-                    if not (_la==RelayParser.T__0):
+                    if not (_la==RelayParser.T__5):
                         break
 
-                self.state = 273
-                self.match(RelayParser.T__2)
+                self.state = 339
+                self.match(RelayParser.T__7)
                 pass
 
             elif la_ == 4:
-                localctx = RelayParser.TypeIdentTypeContext(self, localctx)
+                localctx = RelayParser.GlobalTypeVarTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 4)
-                self.state = 275
-                self.typeIdent()
+                self.state = 341
+                self.globalTypeVar()
                 pass
 
             elif la_ == 5:
                 localctx = RelayParser.TensorTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 5)
-                self.state = 276
-                self.match(RelayParser.T__18)
-                self.state = 277
-                self.match(RelayParser.T__6)
-                self.state = 278
+                self.state = 342
+                self.match(RelayParser.T__23)
+                self.state = 343
+                self.match(RelayParser.T__2)
+                self.state = 344
                 self.shapeList()
-                self.state = 279
-                self.match(RelayParser.T__0)
-                self.state = 280
+                self.state = 345
+                self.match(RelayParser.T__5)
+                self.state = 346
                 self.type_()
-                self.state = 281
-                self.match(RelayParser.T__7)
+                self.state = 347
+                self.match(RelayParser.T__4)
                 pass
 
             elif la_ == 6:
                 localctx = RelayParser.FuncTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 6)
-                self.state = 283
-                self.match(RelayParser.T__14)
-                self.state = 285
+                self.state = 349
+                self.match(RelayParser.T__17)
+                self.state = 351
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if _la==RelayParser.T__6:
-                    self.state = 284
+                if _la==RelayParser.T__2:
+                    self.state = 350
                     self.typeParamList()
 
 
-                self.state = 287
-                self.match(RelayParser.T__1)
-                self.state = 296
+                self.state = 353
+                self.match(RelayParser.T__6)
+                self.state = 362
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__1) | (1 << RelayParser.T__14) | (1 << RelayParser.T__18) | (1 << RelayParser.T__19) | (1 << RelayParser.CNAME) | (1 << RelayParser.NAT))) != 0):
-                    self.state = 288
+                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__6) | (1 << RelayParser.T__17) | (1 << RelayParser.T__23) | (1 << RelayParser.T__24) | (1 << RelayParser.CNAME) | (1 << RelayParser.NAT))) != 0):
+                    self.state = 354
                     self.type_()
-                    self.state = 293
+                    self.state = 359
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
-                    while _la==RelayParser.T__0:
-                        self.state = 289
-                        self.match(RelayParser.T__0)
-                        self.state = 290
+                    while _la==RelayParser.T__5:
+                        self.state = 355
+                        self.match(RelayParser.T__5)
+                        self.state = 356
                         self.type_()
-                        self.state = 295
+                        self.state = 361
                         self._errHandler.sync(self)
                         _la = self._input.LA(1)
 
 
 
-                self.state = 298
-                self.match(RelayParser.T__2)
-                self.state = 299
-                self.match(RelayParser.T__15)
-                self.state = 300
+                self.state = 364
+                self.match(RelayParser.T__7)
+                self.state = 365
+                self.match(RelayParser.T__18)
+                self.state = 366
                 self.type_()
                 pass
 
             elif la_ == 7:
                 localctx = RelayParser.IncompleteTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 7)
-                self.state = 301
-                self.match(RelayParser.T__19)
+                self.state = 367
+                self.match(RelayParser.T__24)
                 pass
 
             elif la_ == 8:
                 localctx = RelayParser.IntTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 8)
-                self.state = 302
+                self.state = 368
                 self.match(RelayParser.NAT)
                 pass
 
@@ -2059,6 +2547,7 @@ def type_(self):
             self.exitRule()
         return localctx
 
+
     class ShapeListContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
@@ -2087,47 +2576,47 @@ def accept(self, visitor:ParseTreeVisitor):
     def shapeList(self):
 
         localctx = RelayParser.ShapeListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 28, self.RULE_shapeList)
+        self.enterRule(localctx, 42, self.RULE_shapeList)
         self._la = 0 # Token type
         try:
-            self.state = 318
+            self.state = 384
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,31,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,37,self._ctx)
             if la_ == 1:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 305
-                self.match(RelayParser.T__1)
-                self.state = 306
+                self.state = 371
+                self.match(RelayParser.T__6)
+                self.state = 372
                 self.shape()
-                self.state = 309 
+                self.state = 375 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while True:
-                    self.state = 307
-                    self.match(RelayParser.T__0)
-                    self.state = 308
+                    self.state = 373
+                    self.match(RelayParser.T__5)
+                    self.state = 374
                     self.shape()
-                    self.state = 311 
+                    self.state = 377 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
-                    if not (_la==RelayParser.T__0):
+                    if not (_la==RelayParser.T__5):
                         break
 
-                self.state = 313
-                self.match(RelayParser.T__2)
+                self.state = 379
+                self.match(RelayParser.T__7)
                 pass
 
             elif la_ == 2:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 315
-                self.match(RelayParser.T__1)
-                self.state = 316
-                self.match(RelayParser.T__2)
+                self.state = 381
+                self.match(RelayParser.T__6)
+                self.state = 382
+                self.match(RelayParser.T__7)
                 pass
 
             elif la_ == 3:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 317
+                self.state = 383
                 self.shape()
                 pass
 
@@ -2140,6 +2629,7 @@ def shapeList(self):
             self.exitRule()
         return localctx
 
+
     class MetaContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
@@ -2167,23 +2657,23 @@ def accept(self, visitor:ParseTreeVisitor):
     def meta(self):
 
         localctx = RelayParser.MetaContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 30, self.RULE_meta)
+        self.enterRule(localctx, 44, self.RULE_meta)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 320
-            self.match(RelayParser.T__20)
-            self.state = 321
-            self.match(RelayParser.T__6)
-            self.state = 322
+            self.state = 386
+            self.match(RelayParser.T__25)
+            self.state = 387
+            self.match(RelayParser.T__2)
+            self.state = 388
             self.match(RelayParser.CNAME)
-            self.state = 323
-            self.match(RelayParser.T__7)
-            self.state = 324
-            self.match(RelayParser.T__6)
-            self.state = 325
+            self.state = 389
+            self.match(RelayParser.T__4)
+            self.state = 390
+            self.match(RelayParser.T__2)
+            self.state = 391
             self.match(RelayParser.NAT)
-            self.state = 326
-            self.match(RelayParser.T__7)
+            self.state = 392
+            self.match(RelayParser.T__4)
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -2192,6 +2682,7 @@ def meta(self):
             self.exitRule()
         return localctx
 
+
     class ShapeContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
@@ -2262,31 +2753,31 @@ def accept(self, visitor:ParseTreeVisitor):
     def shape(self):
 
         localctx = RelayParser.ShapeContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 32, self.RULE_shape)
+        self.enterRule(localctx, 46, self.RULE_shape)
         try:
-            self.state = 334
+            self.state = 400
             self._errHandler.sync(self)
             token = self._input.LA(1)
-            if token in [RelayParser.T__20]:
+            if token in [RelayParser.T__25]:
                 localctx = RelayParser.MetaShapeContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 328
+                self.state = 394
                 self.meta()
                 pass
-            elif token in [RelayParser.T__1]:
+            elif token in [RelayParser.T__6]:
                 localctx = RelayParser.ParensShapeContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 329
-                self.match(RelayParser.T__1)
-                self.state = 330
+                self.state = 395
+                self.match(RelayParser.T__6)
+                self.state = 396
                 self.shape()
-                self.state = 331
-                self.match(RelayParser.T__2)
+                self.state = 397
+                self.match(RelayParser.T__7)
                 pass
             elif token in [RelayParser.NAT]:
                 localctx = RelayParser.IntShapeContext(self, localctx)
                 self.enterOuterAlt(localctx, 3)
-                self.state = 333
+                self.state = 399
                 self.match(RelayParser.NAT)
                 pass
             else:
@@ -2300,6 +2791,7 @@ def shape(self):
             self.exitRule()
         return localctx
 
+
     class TypeIdentContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
@@ -2324,10 +2816,10 @@ def accept(self, visitor:ParseTreeVisitor):
     def typeIdent(self):
 
         localctx = RelayParser.TypeIdentContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 34, self.RULE_typeIdent)
+        self.enterRule(localctx, 48, self.RULE_typeIdent)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 336
+            self.state = 402
             self.match(RelayParser.CNAME)
         except RecognitionException as re:
             localctx.exception = re
@@ -2337,6 +2829,7 @@ def typeIdent(self):
             self.exitRule()
         return localctx
 
+
     class BodyContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
@@ -2362,15 +2855,15 @@ def accept(self, visitor:ParseTreeVisitor):
     def body(self):
 
         localctx = RelayParser.BodyContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 36, self.RULE_body)
+        self.enterRule(localctx, 50, self.RULE_body)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 338
-            self.match(RelayParser.T__3)
-            self.state = 339
+            self.state = 404
+            self.match(RelayParser.T__8)
+            self.state = 405
             self.expr(0)
-            self.state = 340
-            self.match(RelayParser.T__4)
+            self.state = 406
+            self.match(RelayParser.T__9)
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -2379,6 +2872,7 @@ def body(self):
             self.exitRule()
         return localctx
 
+
     class ScalarContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
@@ -2447,27 +2941,27 @@ def accept(self, visitor:ParseTreeVisitor):
     def scalar(self):
 
         localctx = RelayParser.ScalarContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 38, self.RULE_scalar)
+        self.enterRule(localctx, 52, self.RULE_scalar)
         try:
-            self.state = 345
+            self.state = 411
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [RelayParser.FLOAT]:
                 localctx = RelayParser.ScalarFloatContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 342
+                self.state = 408
                 self.match(RelayParser.FLOAT)
                 pass
             elif token in [RelayParser.NAT]:
                 localctx = RelayParser.ScalarIntContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 343
+                self.state = 409
                 self.match(RelayParser.NAT)
                 pass
             elif token in [RelayParser.BOOL_LIT]:
                 localctx = RelayParser.ScalarBoolContext(self, localctx)
                 self.enterOuterAlt(localctx, 3)
-                self.state = 344
+                self.state = 410
                 self.match(RelayParser.BOOL_LIT)
                 pass
             else:
@@ -2481,6 +2975,7 @@ def scalar(self):
             self.exitRule()
         return localctx
 
+
     class IdentContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
@@ -2491,14 +2986,25 @@ def opIdent(self):
             return self.getTypedRuleContext(RelayParser.OpIdentContext,0)
 
 
-        def GLOBAL_VAR(self):
-            return self.getToken(RelayParser.GLOBAL_VAR, 0)
+        def globalVar(self):
+            return self.getTypedRuleContext(RelayParser.GlobalVarContext,0)
+
+
+        def localVar(self):
+            return self.getTypedRuleContext(RelayParser.LocalVarContext,0)
+
+
+        def globalTypeVar(self):
+            return self.getTypedRuleContext(RelayParser.GlobalTypeVarContext,0)
 
-        def LOCAL_VAR(self):
-            return self.getToken(RelayParser.LOCAL_VAR, 0)
 
-        def GRAPH_VAR(self):
-            return self.getToken(RelayParser.GRAPH_VAR, 0)
+        def typeVar(self):
+            return self.getTypedRuleContext(RelayParser.TypeVarContext,0)
+
+
+        def graphVar(self):
+            return self.getTypedRuleContext(RelayParser.GraphVarContext,0)
+
 
         def getRuleIndex(self):
             return RelayParser.RULE_ident
@@ -2515,33 +3021,47 @@ def accept(self, visitor:ParseTreeVisitor):
     def ident(self):
 
         localctx = RelayParser.IdentContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 40, self.RULE_ident)
+        self.enterRule(localctx, 54, self.RULE_ident)
         try:
-            self.state = 351
+            self.state = 419
             self._errHandler.sync(self)
-            token = self._input.LA(1)
-            if token in [RelayParser.CNAME]:
+            la_ = self._interp.adaptivePredict(self._input,40,self._ctx)
+            if la_ == 1:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 347
+                self.state = 413
                 self.opIdent()
                 pass
-            elif token in [RelayParser.GLOBAL_VAR]:
+
+            elif la_ == 2:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 348
-                self.match(RelayParser.GLOBAL_VAR)
+                self.state = 414
+                self.globalVar()
                 pass
-            elif token in [RelayParser.LOCAL_VAR]:
+
+            elif la_ == 3:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 349
-                self.match(RelayParser.LOCAL_VAR)
+                self.state = 415
+                self.localVar()
                 pass
-            elif token in [RelayParser.GRAPH_VAR]:
+
+            elif la_ == 4:
                 self.enterOuterAlt(localctx, 4)
-                self.state = 350
-                self.match(RelayParser.GRAPH_VAR)
+                self.state = 416
+                self.globalTypeVar()
                 pass
-            else:
-                raise NoViableAltException(self)
+
+            elif la_ == 5:
+                self.enterOuterAlt(localctx, 5)
+                self.state = 417
+                self.typeVar()
+                pass
+
+            elif la_ == 6:
+                self.enterOuterAlt(localctx, 6)
+                self.state = 418
+                self.graphVar()
+                pass
+
 
         except RecognitionException as re:
             localctx.exception = re
@@ -2556,7 +3076,7 @@ def ident(self):
     def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
         if self._predicates == None:
             self._predicates = dict()
-        self._predicates[4] = self.expr_sempred
+        self._predicates[9] = self.expr_sempred
         pred = self._predicates.get(ruleIndex, None)
         if pred is None:
             raise Exception("No predicate with index:" + str(ruleIndex))
diff --git a/python/tvm/relay/grammar/py3/RelayVisitor.py b/python/tvm/relay/grammar/py3/RelayVisitor.py
index 30c802255c94..ca3a36a9fadf 100644
--- a/python/tvm/relay/grammar/py3/RelayVisitor.py
+++ b/python/tvm/relay/grammar/py3/RelayVisitor.py
@@ -1,4 +1,4 @@
-# Generated from /workspace/python/tvm/relay/grammar/Relay.g4 by ANTLR 4.7.1
+# Generated from /Users/doobs/Code/repo/sampl/tvm/python/tvm/relay/grammar/Relay.g4 by ANTLR 4.7.2
 from antlr4 import *
 if __name__ is not None and "." in __name__:
     from .RelayParser import RelayParser
@@ -9,13 +9,38 @@
 
 class RelayVisitor(ParseTreeVisitor):
 
+    # Visit a parse tree produced by RelayParser#prog.
+    def visitProg(self, ctx:RelayParser.ProgContext):
+        return self.visitChildren(ctx)
+
+
     # Visit a parse tree produced by RelayParser#opIdent.
     def visitOpIdent(self, ctx:RelayParser.OpIdentContext):
         return self.visitChildren(ctx)
 
 
-    # Visit a parse tree produced by RelayParser#prog.
-    def visitProg(self, ctx:RelayParser.ProgContext):
+    # Visit a parse tree produced by RelayParser#globalVar.
+    def visitGlobalVar(self, ctx:RelayParser.GlobalVarContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by RelayParser#localVar.
+    def visitLocalVar(self, ctx:RelayParser.LocalVarContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by RelayParser#globalTypeVar.
+    def visitGlobalTypeVar(self, ctx:RelayParser.GlobalTypeVarContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by RelayParser#typeVar.
+    def visitTypeVar(self, ctx:RelayParser.TypeVarContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by RelayParser#graphVar.
+    def visitGraphVar(self, ctx:RelayParser.GraphVarContext):
         return self.visitChildren(ctx)
 
 
@@ -114,8 +139,23 @@ def visitFunc(self, ctx:RelayParser.FuncContext):
         return self.visitChildren(ctx)
 
 
-    # Visit a parse tree produced by RelayParser#defn.
-    def visitDefn(self, ctx:RelayParser.DefnContext):
+    # Visit a parse tree produced by RelayParser#funcDefn.
+    def visitFuncDefn(self, ctx:RelayParser.FuncDefnContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by RelayParser#adtDefn.
+    def visitAdtDefn(self, ctx:RelayParser.AdtDefnContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by RelayParser#adtVariant.
+    def visitAdtVariant(self, ctx:RelayParser.AdtVariantContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by RelayParser#variantName.
+    def visitVariantName(self, ctx:RelayParser.VariantNameContext):
         return self.visitChildren(ctx)
 
 
@@ -159,8 +199,8 @@ def visitTupleType(self, ctx:RelayParser.TupleTypeContext):
         return self.visitChildren(ctx)
 
 
-    # Visit a parse tree produced by RelayParser#typeIdentType.
-    def visitTypeIdentType(self, ctx:RelayParser.TypeIdentTypeContext):
+    # Visit a parse tree produced by RelayParser#globalTypeVarType.
+    def visitGlobalTypeVarType(self, ctx:RelayParser.GlobalTypeVarTypeContext):
         return self.visitChildren(ctx)
 
 
diff --git a/python/tvm/relay/ty.py b/python/tvm/relay/ty.py
index 7e190fc405da..3b2ec565ce33 100644
--- a/python/tvm/relay/ty.py
+++ b/python/tvm/relay/ty.py
@@ -107,6 +107,7 @@ class Kind(IntEnum):
     Shape = 3
     Constraint = 4
     AdtHandle = 5
+    # TODO: This is never used.  Remove it?
     TypeData = 6
 
 @register_relay_node
diff --git a/src/relay/ir/alpha_equal.cc b/src/relay/ir/alpha_equal.cc
index 2c23f0fdf68f..b4ef7a5ebf03 100644
--- a/src/relay/ir/alpha_equal.cc
+++ b/src/relay/ir/alpha_equal.cc
@@ -70,7 +70,10 @@ class AlphaEqualHandler:
       }
       if (lhsm->type_definitions.size() != rhsm->type_definitions.size()) return false;
       for (const auto& p : lhsm->type_definitions) {
-        if (!Equal(p.second, rhsm->LookupDef(p.first->var->name_hint))) return false;
+        if (!rhsm->HasDef(p.first->var->name_hint) ||
+            !Equal(p.second, rhsm->LookupDef(p.first->var->name_hint))) {
+          return false;
+        }
       }
       return true;
     }
@@ -288,7 +291,11 @@ class AlphaEqualHandler:
   }
 
   bool VisitType_(const GlobalTypeVarNode* lhs, const Type& other) final {
-    return GetRef<Type>(lhs) == other;
+    if (const GlobalTypeVarNode* rhs = other.as<GlobalTypeVarNode>()) {
+      // use name equality for global var for now.
+      return lhs->var->name_hint == rhs->var->name_hint;
+    }
+    return false;
   }
 
   bool VisitType_(const TypeCallNode* lhs, const Type& other) final {
@@ -307,6 +314,28 @@ class AlphaEqualHandler:
     return true;
   }
 
+  bool VisitType_(const TypeDataNode* lhs, const Type& other) final {
+    const TypeDataNode* rhs = other.as<TypeDataNode>();
+    bool result = true;
+    result |= rhs == nullptr;
+    result |= lhs->type_vars.size() != rhs->type_vars.size();
+    result |= !TypeEqual(lhs->header, rhs->header);
+    if (!result) {
+      return false;
+    }
+    for (size_t i = 0; i < lhs->type_vars.size(); ++i) {
+      if (!TypeEqual(lhs->type_vars[i], rhs->type_vars[i])) {
+        return false;
+      }
+    }
+    for (size_t i = 0; i < lhs->constructors.size(); ++i) {
+      if (!ExprEqual(lhs->constructors[i], rhs->constructors[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+
   // Expr equal checking.
   bool NDArrayEqual(const runtime::NDArray& lhs,
                     const runtime::NDArray& rhs) {
@@ -485,7 +514,10 @@ class AlphaEqualHandler:
   }
 
   bool VisitExpr_(const ConstructorNode* lhs, const Expr& other) final {
-    return GetRef<Expr>(lhs) == other;
+    if (const ConstructorNode* rhs = other.as<ConstructorNode>()) {
+      return lhs->name_hint == rhs->name_hint;
+    }
+    return false;
   }
 
   bool ClauseEqual(const Clause& lhs, const Clause& rhs) {
diff --git a/src/relay/ir/module.cc b/src/relay/ir/module.cc
index 4af6149f431e..dbaea7f02fc7 100644
--- a/src/relay/ir/module.cc
+++ b/src/relay/ir/module.cc
@@ -206,6 +206,11 @@ TypeData ModuleNode::LookupDef(const std::string& name) const {
   return this->LookupDef(id);
 }
 
+bool ModuleNode::HasDef(const std::string& name) const {
+  auto it = global_type_var_map_.find(name);
+  return it != global_type_var_map_.end();
+}
+
 Constructor ModuleNode::LookupTag(const int32_t tag) {
   auto it = constructor_tag_map_.find(tag);
   CHECK(it != constructor_tag_map_.end())
diff --git a/src/relay/ir/pretty_printer.cc b/src/relay/ir/pretty_printer.cc
index 5197414992f9..e95052d265b7 100644
--- a/src/relay/ir/pretty_printer.cc
+++ b/src/relay/ir/pretty_printer.cc
@@ -347,13 +347,18 @@ class PrettyPrinter :
   }
 
   bool IsUnique(const Expr& expr) {
-    return !(dg_.expr_node.at(expr)->parents.head &&
-             dg_.expr_node.at(expr)->parents.head->next);
+    auto it = dg_.expr_node.find(expr);
+    if (it == dg_.expr_node.end()) {
+      return true;
+    } else {
+      return !(it->second->parents.head && it->second->parents.head->next);
+    }
   }
 
+  // TODO(weberlo): Consolidate this method and `IsAtomic` in `pass_util.h`?
   bool AlwaysInline(const Expr& expr) {
     return expr.as<GlobalVarNode>() || expr.as<ConstantNode>() ||
-           expr.as<OpNode>() || expr.as<VarNode>();
+           expr.as<OpNode>() || expr.as<VarNode>() || expr.as<ConstructorNode>();
   }
 
   //------------------------------------
@@ -510,6 +515,15 @@ class PrettyPrinter :
   Doc PrintMod(const Module& mod) {
     Doc doc;
     int counter = 0;
+    // type definitions
+    for (const auto& kv : mod->type_definitions) {
+      if (counter++ != 0) {
+        doc << PrintNewLine();
+      }
+      doc << Print(kv.second);
+      doc << PrintNewLine();
+    }
+    // functions
     for (const auto& kv : mod->functions) {
       dg_ = DependencyGraph::Create(&arena_, kv.second);
 
@@ -598,7 +612,17 @@ class PrettyPrinter :
   }
 
   Doc VisitExpr_(const ConstructorNode* n) final {
-    return Doc(n->name_hint);
+    Doc doc;
+    doc << n->name_hint;
+    if (n->inputs.size() != 0) {
+      doc << "(";
+      std::vector<Doc> inputs;
+      for (Type input : n->inputs) {
+        inputs.push_back(Print(input));
+      }
+      doc << PrintSep(inputs) << ")";
+    }
+    return doc;
   }
 
   //------------------------------------
@@ -695,6 +719,30 @@ class PrettyPrinter :
     return doc << "ref(" << Print(node->value) << ")";
   }
 
+  Doc VisitType_(const TypeDataNode* node) final {
+    Doc doc;
+    doc << "type " << Print(node->header);
+
+    // type args
+    if (node->type_vars.size() != 0) {
+      doc << "[";
+      std::vector<Doc> type_vars;
+      for (Type type_var : node->type_vars) {
+        type_vars.push_back(Print(type_var));
+      }
+      doc << PrintSep(type_vars) << "]";
+    }
+    doc << " =";
+
+    // ADT variants
+    for (Constructor variant : node->constructors) {
+      doc << PrintNewLine() << "  | " << Print(variant, /* meta */ false, /* try_inline */ true);
+    }
+
+    return doc;
+  }
+
+
   //------------------------------------
   // Overload of Attr printing functions
   //------------------------------------
diff --git a/tests/python/relay/test_ir_parser.py b/tests/python/relay/test_ir_parser.py
index 26742cd4bf8d..937b0590c05c 100644
--- a/tests/python/relay/test_ir_parser.py
+++ b/tests/python/relay/test_ir_parser.py
@@ -66,14 +66,22 @@ def roundtrip(expr):
 
 
 def parse_text(code):
-    x = relay.fromtext(SEMVER + "\n" + code)
-    roundtrip(x)
-    return x
+    print('original is:')
+    print(SEMVER + "\n" + code)
+    expr = relay.fromtext(SEMVER + "\n" + code)
+    print('pretty printed is:')
+    print(str(expr))
+    roundtrip(expr)
+    return expr
 
 
 def parses_as(code, expr):
     # type: (str, relay.Expr) -> bool
-    return alpha_equal(parse_text(code), expr)
+    parsed = parse_text(code)
+    print('biz')
+    result = alpha_equal(parsed, expr)
+    print('fiz')
+    return result
 
 def get_scalar(x):
     # type: (relay.Constant) -> (Union[float, int, bool])
@@ -632,26 +640,92 @@ def test_tuple_type():
         )
     )
 
+
+def test_adt_defn():
+    glob_typ_var = relay.GlobalTypeVar("Ayy")
+    prog = relay.TypeData(
+            glob_typ_var,
+            [],
+            [relay.Constructor("Nil", [], glob_typ_var)])
+    mod = relay.Module()
+    mod[glob_typ_var] = prog
+    assert parses_as(
+        """
+        type Ayy =
+          | Nil
+        """,
+        mod
+    )
+
+
+def test_multiple_variants():
+    glob_typ_var = relay.GlobalTypeVar("List")
+    typ_var = relay.TypeVar("A")
+    prog = relay.TypeData(
+            glob_typ_var,
+            [typ_var],
+            [
+                relay.Constructor("Cons", [typ_var, glob_typ_var(typ_var)], glob_typ_var),
+                relay.Constructor("Nil", [], glob_typ_var),
+            ])
+    mod = relay.Module()
+    mod[glob_typ_var] = prog
+    assert parses_as(
+        """
+        type List[A] =
+        | Cons(A, List[A])
+        | Nil
+        """,
+        mod
+    )
+
+
+def test_multiple_type_params():
+    glob_typ_var = relay.GlobalTypeVar("list")
+    typ_var_a = relay.TypeVar("A")
+    typ_var_b = relay.TypeVar("B")
+    prog = relay.TypeData(
+            glob_typ_var,
+            [typ_var_a, typ_var_b],
+            [
+                relay.Constructor("Left", [typ_var_a], glob_typ_var),
+                relay.Constructor("Right", [typ_var_b], glob_typ_var),
+            ])
+    mod = relay.Module()
+    mod[glob_typ_var] = prog
+    assert parses_as(
+        """
+        type Either[A, B] =
+        | Left(A)
+        | Right(B)
+        """,
+        mod
+    )
+
+
 if __name__ == "__main__":
-    test_comments()
-    test_int_literal()
-    test_float_literal()
-    test_bool_literal()
-    test_negative()
-    test_bin_op()
-    test_parens()
-    test_op_assoc()
-    test_let()
-    test_seq()
-    test_graph()
-    test_tuple()
-    test_func()
-    test_defn()
-    test_recursive_call()
-    test_ifelse()
-    test_call()
-    test_incomplete_type()
-    test_builtin_types()
-    test_tensor_type()
-    test_function_type()
-    test_tuple_type()
+    # test_comments()
+    # test_int_literal()
+    # test_float_literal()
+    # test_bool_literal()
+    # test_negative()
+    # test_bin_op()
+    # test_parens()
+    # test_op_assoc()
+    # test_let()
+    # test_seq()
+    # test_graph()
+    # test_tuple()
+    # test_func()
+    # test_defn()
+    # test_recursive_call()
+    # test_ifelse()
+    # test_call()
+    # test_incomplete_type()
+    # test_builtin_types()
+    # test_tensor_type()
+    # test_function_type()
+    # test_tuple_type()
+    # test_adt_defn()
+    # test_multiple_variants()
+    test_multiple_type_params()
diff --git a/tests/python/relay/test_ir_text_printer.py b/tests/python/relay/test_ir_text_printer.py
index c6f59d9438af..7c1ff13f1184 100644
--- a/tests/python/relay/test_ir_text_printer.py
+++ b/tests/python/relay/test_ir_text_printer.py
@@ -21,19 +21,29 @@
 from tvm.relay import Expr
 from tvm.relay.analysis import alpha_equal, assert_alpha_equal, assert_graph_equal, free_vars
 
+from tvm.relay.ty import GlobalTypeVar, TypeVar, FuncType, TupleType, scalar_type
+from tvm.relay.expr import Var, Function, GlobalVar, Let, If, Tuple, TupleGetItem, const
+from tvm.relay.op.tensor import add, subtract, equal
+from tvm.relay.adt import Constructor, TypeData, Clause, Match
+from tvm.relay.adt import PatternConstructor, PatternVar, PatternWildcard
+
 do_print = [False]
 
 SEMVER = "v0.0.3\n"
 
-def astext(p, graph_equal=False):
+def astext(p, unify_free_vars=False):
     txt = p.astext()
     if isinstance(p, Expr) and free_vars(p):
         return txt
+    print('BEFORE PARSE')
     x = relay.fromtext(txt)
-    if graph_equal:
+    print('AFTER PARSE')
+    if unify_free_vars:
         assert_graph_equal(x, p)
     else:
         assert_alpha_equal(x, p)
+    # TODO: Unify two assert methods into the one below
+    # assert_alpha_equal(x, p, unify_free_vars)
     return txt
 
 def show(text):
@@ -78,7 +88,7 @@ def test_meta_data():
                         padding=(1, 1),
                         channels=2)
     f = relay.Function([x, w], z)
-    text = astext(f, graph_equal=True)
+    text = astext(f, unify_free_vars=True)
     text_no_meta = str(f)
     assert "channels=2" in text
     assert "channels=2" in text_no_meta
@@ -216,7 +226,18 @@ def test_let_inlining():
 
 def test_zeros():
     x = relay.op.zeros([], "float32")
-    astext(x)
+    show(astext(x))
+
+def test_adt_defn():
+    adt_var = GlobalTypeVar("list")
+    a = TypeVar("a")
+    nil_cons = Constructor("nil", [], adt_var)
+    cons_cons = Constructor("cons", [a, adt_var(a)], adt_var)
+    list_adt = TypeData(adt_var, [a], [nil_cons, cons_cons])
+    show(astext(list_adt))
+
+def test_match():
+    pass
 
 
 def test_cast():
@@ -247,4 +268,6 @@ def test_cast():
     test_let_if_scope()
     test_variable_name()
     test_call_node_order()
+    test_adt_defn()
+    test_match()
     test_cast()

From 511865cf6ae425957afc74208524f4c37b3351ad Mon Sep 17 00:00:00 2001
From: Logan Weber <weberlo@cs.washington.edu>
Date: Fri, 23 Aug 2019 16:17:36 -0700
Subject: [PATCH 02/29] ADT defs working probly

---
 python/tvm/relay/_parser.py                  |  120 +-
 python/tvm/relay/grammar/Relay.g4            |   42 +-
 python/tvm/relay/grammar/py3/RelayLexer.py   |  340 ++--
 python/tvm/relay/grammar/py3/RelayParser.py  | 1716 ++++++++----------
 python/tvm/relay/grammar/py3/RelayVisitor.py |   31 +-
 src/relay/ir/alpha_equal.cc                  |    3 +-
 src/relay/ir/pretty_printer.cc               |    2 +-
 tests/python/relay/test_ir_parser.py         |   12 +-
 tests/python/relay/test_ir_text_printer.py   |    8 +-
 9 files changed, 1097 insertions(+), 1177 deletions(-)

diff --git a/python/tvm/relay/_parser.py b/python/tvm/relay/_parser.py
index 682096967753..5068388066e0 100644
--- a/python/tvm/relay/_parser.py
+++ b/python/tvm/relay/_parser.py
@@ -246,7 +246,7 @@ def mk_global_typ(self, name, kind):
         # (str, ty.Kind) -> ty.GlobalTypeVar
         """Create a new TypeVar and add it to the TypeVar scope."""
         typ = ty.GlobalTypeVar(name, kind)
-        self.global_var_scope.append((name, typ))
+        self.global_type_param_scope.append((name, typ))
         return typ
 
     def visitProjection(self, ctx):
@@ -488,37 +488,79 @@ def visitFuncDefn(self, ctx):
         self.module[ident] = self.mk_func(ctx)
 
     def visitAdtDefn(self, ctx):
-        glob_typ_var = ctx.globalTypeVar()
-        defn_name = glob_typ_var.children[0].getText()
-        typ_params = []
-
-        if len(glob_typ_var.children) > 1:
-            defn_name = glob_typ_var.children[0].getText()
-            typ_params = list(
-                map(
-                    ty.TypeVar,
-                    filter(
-                        lambda s: not s.startswith(','),
-                        map(lambda x: x.getText(), glob_typ_var.children[2:-1]))))
-        defn = self.mk_global_typ(defn_name, ty.Kind.AdtHandle)
+        adt_handle = self.mk_global_typ(ctx.typeIdent().getText(), ty.Kind.AdtHandle)
+
+        self.enter_type_param_scope()
+
+        type_params = ctx.typeParamList()
+        if type_params is None:
+            type_params = []
+        else:
+            type_params = [self.mk_typ(type_ident.getText(), ty.Kind.Type)
+                           for type_ident in type_params.typeIdent()]
+        # defn_name = glob_typ_var.children[0].getText()
+        # type_params = []
+
+        # if len(glob_typ_var.children) > 1:
+        #     defn_name = glob_typ_var.children[0].getText()
+        #     type_params = list(
+        #         map(
+        #             lambda s: self.mk_typ(s, ty.Kind.Type),
+        #             filter(
+        #                 lambda s: not s.startswith(','),
+        #                 map(lambda x: x.getText(), glob_typ_var.children[2:-1]))))
+        #     print('TYPE PARAMS')
+        #     import pdb; pdb.set_trace()
+        #     print(glob_typ_var.children[2:-1])
+        #     print(list(map(lambda x: x.getText(), glob_typ_var.children[2:-1])))
+        #     print(filter(
+        #                 lambda s: not s.startswith(','),
+        #                 map(lambda x: x.getText(), glob_typ_var.children[2:-1])))
+        # defn = self.mk_global_typ(defn_name, ty.Kind.AdtHandle)
 
         constructors = []
         for constructor in ctx.adtVariant():
-            inputs = []
-            for inp in constructor.type_():
-                print(inp)
-                inputs.append(self.visit(inp))
+            inputs = [self.visit(inp) for inp in constructor.typeExpr()]
+            constructors.append(adt.Constructor(constructor.variantName().getText(), inputs, adt_handle))
 
-            # inputs = [self.visit(inp) for inp in constructor.type_()]
-            constructors.append(adt.Constructor(constructor.variantName().getText(), inputs, defn))
+        self.module[adt_handle] = adt.TypeData(adt_handle, type_params, constructors)
 
-        self.module[defn] = adt.TypeData(defn, typ_params, constructors)
+        self.exit_type_param_scope()
 
-    def visitGlobalTypeVarType(self, ctx):
-        print('SHIT WHETHER IT\'S A LOCAL OR GLOBAL TYPE VAR IS AMBIGUOUS, SO WE\'LL NEED TO DO SOME LOOKUPS')
-        print('cloobs')
+    def visitTypeExprType(self, ctx):
         import pdb; pdb.set_trace()
-        return None
+        type_params = ctx.typeParams()
+        print(ctx.getText())
+        if type_params is None:
+            print('ayy')
+        else:
+            print('lmao')
+        print()
+        # TODO: We need to handle arbitrarily nested type calls (e.g., `Maybe[List[Either[Int, Bool]]]`)
+        def _parse_typ_var(name):
+            typ_var = lookup(self.type_param_scopes, name)
+            if typ_var is None:
+                typ_var = lookup(self.global_type_param_scope, name)
+                if typ_var is None:
+                    # TODO: raise parse error?
+                    raise RuntimeError(f'unbound var "{name}"')
+            return typ_var
+
+        name = ctx.getText()
+        type_params = None
+        if '[' in name:
+            param_start_idx = name.find('[')
+            type_params = list(map(lambda s: s.strip(), name[param_start_idx+1:-1].split(',')))
+            name = name[:param_start_idx]
+
+        typ_var = _parse_typ_var(name)
+
+        if type_params:
+            return ty.TypeCall(typ_var, type_params)
+        else:
+            return typ_var
+
+
 
     def visitCallNoAttr(self, ctx):
         return (self.visit_list(ctx.exprList().expr()), None)
@@ -580,21 +622,31 @@ def visitIncompleteType(self, ctx):
         # type (RelayParser.IncompleteTypeContext) -> None:
         return None
 
+    # TODO: convert all this to mypy format
     def visitTypeIdent(self, ctx):
         # type: (RelayParser.TypeIdentContext) -> Union[ty.TensorType, str]
         """Handle type identifier."""
-        type_ident = ctx.CNAME().getText()
+        type_name = ctx.CNAME().getText()
 
         # Look through all type prefixes for a match
         for type_prefix in TYPE_PREFIXES:
-            if type_ident.startswith(type_prefix):
-                return ty.scalar_type(type_ident)
-
-        type_param = lookup(self.type_param_scopes, type_ident)
-        if type_param is not None:
-            return type_param
-
-        raise ParseError("Unknown builtin type: {}".format(type_ident))
+            if type_name.startswith(type_prefix):
+                return ty.scalar_type(type_name)
+
+        # Next, look it up in the local then global type params
+        type_param = lookup(self.type_param_scopes, type_name)
+        if type_param is None:
+            type_param = lookup([self.global_type_param_scope], type_name)
+            if type_param is None:
+                # TODO: raise parse error?
+                raise RuntimeError(f'unbound var "{type_name}"')
+
+        return type_param
+
+    def visitTypeCallType(self, ctx):
+        func = self.visit(ctx.typeIdent())
+        args = [self.visit(arg) for arg in ctx.typeParamList().typeIdent()]
+        return ty.TypeCall(func, args)
 
     # def visitCallType(self, ctx):
     #     # type: (RelayParser.CallTypeContext) -> Union[expr.Expr, ty.TensorType]
diff --git a/python/tvm/relay/grammar/Relay.g4 b/python/tvm/relay/grammar/Relay.g4
index cd0943d7dbd9..2eb4c2f9804b 100644
--- a/python/tvm/relay/grammar/Relay.g4
+++ b/python/tvm/relay/grammar/Relay.g4
@@ -78,9 +78,7 @@ prog: SEMVER (defn* | expr) METADATA? EOF ;
 opIdent: CNAME ;
 globalVar: '@' CNAME ;
 localVar: '%' CNAME ;
-// TODO: For some reason, spaces aren't allowed between type params?
-globalTypeVar: CNAME ('[' typeVar (', ' typeVar)* ']')? ;
-typeVar: CNAME ;
+typeIdent: CNAME ;
 graphVar: '%' NAT ;
 
 exprList: (expr (',' expr)*)?;
@@ -120,13 +118,13 @@ expr
   | QUOTED_STRING                             # stringExpr
   ;
 
-func: 'fn'        typeParamList? '(' argList ')' ('->' type_)? body ;
+func: 'fn'        typeParamList? '(' argList ')' ('->' typeExpr)? body ;
 defn
-  : 'def' globalVar typeParamList? '(' argList ')' ('->' type_)? body  # funcDefn
-  | 'type' globalTypeVar '=' adtVariant+                               # adtDefn
+  : 'def' globalVar typeParamList? '(' argList ')' ('->' typeExpr)? body  # funcDefn
+  | 'type' typeIdent typeParamList? '=' adtVariant+                               # adtDefn
   ;
 
-adtVariant: '|' variantName ('(' type_ (', ' type_)* ')')? ;
+adtVariant: '|' variantName ('(' typeExpr (',' typeExpr)* ')')? ;
 variantName: CNAME ;
 
 argList
@@ -135,30 +133,26 @@ argList
   ;
 
 varList: (var (',' var)*)?;
-var: localVar (':' type_)?;
+var: localVar (':' typeExpr)?;
 
 attrSeq: attr (',' attr)*;
 attr: CNAME '=' expr ;
 
-typeParamList
-  : '[' ']'
-  | '[' ident (',' ident)* ']'
-  ;
-
-
-type_
+typeExpr
   : '(' ')'                                                      # tupleType
-  | '(' type_ ',' ')'                                            # tupleType
-  | '(' type_ (',' type_)+ ')'                                   # tupleType
-  // TODO: When we uncomment this we get a grammar construction error
-  // | typeIdent                                                    # typeIdentType
-  | globalTypeVar                                                # globalTypeVarType
-  | 'Tensor' '[' shapeList ',' type_ ']'                         # tensorType
-  | 'fn' typeParamList? '(' (type_ (',' type_)*)? ')' '->' type_ # funcType
+  | '(' typeExpr ',' ')'                                            # tupleType
+  | '(' typeExpr (',' typeExpr)+ ')'                                   # tupleType
+  | typeIdent typeParamList                                     # typeCallType
+  | typeIdent                                                    # typeIdentType
+  | 'Tensor' '[' shapeList ',' typeExpr ']'                         # tensorType
+  | 'fn' typeParamList? '(' (typeExpr (',' typeExpr)*)? ')' '->' typeExpr # funcType
   | '_'                                                          # incompleteType
   | NAT                                                          # intType
   ;
 
+// TODO: For some reason, spaces aren't allowed between type params?
+typeParamList: '[' typeIdent (',' typeIdent)* ']' ;
+
 shapeList
   : '(' shape (',' shape)+ ')'
   | '(' ')'
@@ -173,7 +167,6 @@ shape
   | NAT                                  # intShape
   ;
 
-typeIdent: CNAME ;
 // int8, int16, int32, int64
 // uint8, uint16, uint32, uint64
 // float16, float32, float64
@@ -191,7 +184,6 @@ ident
   : opIdent
   | globalVar
   | localVar
-  | globalTypeVar
-  | typeVar
+  | typeExpr
   | graphVar
   ;
diff --git a/python/tvm/relay/grammar/py3/RelayLexer.py b/python/tvm/relay/grammar/py3/RelayLexer.py
index 57505ce0f752..a0d2e90df171 100644
--- a/python/tvm/relay/grammar/py3/RelayLexer.py
+++ b/python/tvm/relay/grammar/py3/RelayLexer.py
@@ -8,8 +8,8 @@
 
 def serializedATN():
     with StringIO() as buf:
-        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\61")
-        buf.write("\u0153\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7")
+        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\60")
+        buf.write("\u014e\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7")
         buf.write("\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r")
         buf.write("\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23")
         buf.write("\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30")
@@ -17,143 +17,141 @@ def serializedATN():
         buf.write("\t\36\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%")
         buf.write("\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.")
         buf.write("\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64")
-        buf.write("\t\64\4\65\t\65\3\2\3\2\3\3\3\3\3\4\3\4\3\5\3\5\3\5\3")
-        buf.write("\6\3\6\3\7\3\7\3\b\3\b\3\t\3\t\3\n\3\n\3\13\3\13\3\f\3")
-        buf.write("\f\3\r\3\r\3\r\3\16\3\16\3\16\3\16\3\16\3\17\3\17\3\17")
-        buf.write("\3\17\3\20\3\20\3\21\3\21\3\22\3\22\3\22\3\23\3\23\3\23")
-        buf.write("\3\24\3\24\3\24\3\25\3\25\3\25\3\25\3\26\3\26\3\26\3\26")
-        buf.write("\3\26\3\27\3\27\3\30\3\30\3\31\3\31\3\31\3\31\3\31\3\31")
-        buf.write("\3\31\3\32\3\32\3\33\3\33\3\33\3\33\3\33\3\34\3\34\3\34")
-        buf.write("\3\34\3\34\3\34\3\34\3\35\3\35\3\35\3\35\3\35\7\35\u00c3")
-        buf.write("\n\35\f\35\16\35\u00c6\13\35\3\35\3\35\3\35\3\35\3\35")
-        buf.write("\3\36\6\36\u00ce\n\36\r\36\16\36\u00cf\3\36\3\36\3\37")
-        buf.write("\3\37\3\37\3\37\7\37\u00d8\n\37\f\37\16\37\u00db\13\37")
-        buf.write("\3\37\3\37\3\37\3\37\3 \3 \3 \3!\3!\3!\7!\u00e7\n!\f!")
-        buf.write("\16!\u00ea\13!\3!\3!\3\"\3\"\3#\3#\3$\3$\3%\3%\3&\3&\3")
-        buf.write("\'\3\'\3(\3(\3(\3)\3)\3)\3*\3*\3*\3+\3+\3+\3,\3,\3,\3")
-        buf.write(",\3,\3,\3,\3,\3,\5,\u010f\n,\3-\3-\5-\u0113\n-\3-\3-\3")
-        buf.write("-\7-\u0118\n-\f-\16-\u011b\13-\3-\3-\7-\u011f\n-\f-\16")
-        buf.write("-\u0122\13-\3.\3.\3.\3.\3.\3.\3/\3/\3/\5/\u012d\n/\3/")
-        buf.write("\5/\u0130\n/\3\60\3\60\3\60\3\61\6\61\u0136\n\61\r\61")
-        buf.write("\16\61\u0137\3\62\3\62\5\62\u013c\n\62\3\62\3\62\3\63")
-        buf.write("\3\63\3\64\3\64\3\65\3\65\3\65\3\65\3\65\3\65\3\65\3\65")
-        buf.write("\3\65\3\65\3\65\7\65\u014f\n\65\f\65\16\65\u0152\13\65")
-        buf.write("\5\u00c4\u00d9\u00e8\2\66\3\3\5\4\7\5\t\6\13\7\r\b\17")
-        buf.write("\t\21\n\23\13\25\f\27\r\31\16\33\17\35\20\37\21!\22#\23")
-        buf.write("%\24\'\25)\26+\27-\30/\31\61\32\63\33\65\34\67\359\36")
-        buf.write(";\37= ?\2A!C\"E#G$I%K&M\'O(Q)S*U+W,Y-[.]\2_/a\60c\2e\2")
-        buf.write("g\2i\61\3\2\b\5\2\13\f\17\17\"\"\4\2\f\f\17\17\4\2GGg")
-        buf.write("g\4\2--//\4\2C\\c|\3\2\62;\2\u015e\2\3\3\2\2\2\2\5\3\2")
-        buf.write("\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("\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2")
-        buf.write("\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2\2\2\2\37")
-        buf.write("\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2\2\'\3\2\2\2")
-        buf.write("\2)\3\2\2\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2")
-        buf.write("\2\2\2\63\3\2\2\2\2\65\3\2\2\2\2\67\3\2\2\2\29\3\2\2\2")
-        buf.write("\2;\3\2\2\2\2=\3\2\2\2\2A\3\2\2\2\2C\3\2\2\2\2E\3\2\2")
-        buf.write("\2\2G\3\2\2\2\2I\3\2\2\2\2K\3\2\2\2\2M\3\2\2\2\2O\3\2")
-        buf.write("\2\2\2Q\3\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2W\3\2\2\2\2Y\3")
-        buf.write("\2\2\2\2[\3\2\2\2\2_\3\2\2\2\2a\3\2\2\2\2i\3\2\2\2\3k")
-        buf.write("\3\2\2\2\5m\3\2\2\2\7o\3\2\2\2\tq\3\2\2\2\13t\3\2\2\2")
-        buf.write("\rv\3\2\2\2\17x\3\2\2\2\21z\3\2\2\2\23|\3\2\2\2\25~\3")
-        buf.write("\2\2\2\27\u0080\3\2\2\2\31\u0082\3\2\2\2\33\u0085\3\2")
-        buf.write("\2\2\35\u008a\3\2\2\2\37\u008e\3\2\2\2!\u0090\3\2\2\2")
-        buf.write("#\u0092\3\2\2\2%\u0095\3\2\2\2\'\u0098\3\2\2\2)\u009b")
-        buf.write("\3\2\2\2+\u009f\3\2\2\2-\u00a4\3\2\2\2/\u00a6\3\2\2\2")
-        buf.write("\61\u00a8\3\2\2\2\63\u00af\3\2\2\2\65\u00b1\3\2\2\2\67")
-        buf.write("\u00b6\3\2\2\29\u00bd\3\2\2\2;\u00cd\3\2\2\2=\u00d3\3")
-        buf.write("\2\2\2?\u00e0\3\2\2\2A\u00e3\3\2\2\2C\u00ed\3\2\2\2E\u00ef")
-        buf.write("\3\2\2\2G\u00f1\3\2\2\2I\u00f3\3\2\2\2K\u00f5\3\2\2\2")
-        buf.write("M\u00f7\3\2\2\2O\u00f9\3\2\2\2Q\u00fc\3\2\2\2S\u00ff\3")
-        buf.write("\2\2\2U\u0102\3\2\2\2W\u010e\3\2\2\2Y\u0112\3\2\2\2[\u0123")
-        buf.write("\3\2\2\2]\u0129\3\2\2\2_\u0131\3\2\2\2a\u0135\3\2\2\2")
-        buf.write("c\u0139\3\2\2\2e\u013f\3\2\2\2g\u0141\3\2\2\2i\u0143\3")
-        buf.write("\2\2\2kl\7B\2\2l\4\3\2\2\2mn\7\'\2\2n\6\3\2\2\2op\7]\2")
-        buf.write("\2p\b\3\2\2\2qr\7.\2\2rs\7\"\2\2s\n\3\2\2\2tu\7_\2\2u")
-        buf.write("\f\3\2\2\2vw\7.\2\2w\16\3\2\2\2xy\7*\2\2y\20\3\2\2\2z")
-        buf.write("{\7+\2\2{\22\3\2\2\2|}\7}\2\2}\24\3\2\2\2~\177\7\177\2")
-        buf.write("\2\177\26\3\2\2\2\u0080\u0081\7\60\2\2\u0081\30\3\2\2")
-        buf.write("\2\u0082\u0083\7k\2\2\u0083\u0084\7h\2\2\u0084\32\3\2")
-        buf.write("\2\2\u0085\u0086\7g\2\2\u0086\u0087\7n\2\2\u0087\u0088")
-        buf.write("\7u\2\2\u0088\u0089\7g\2\2\u0089\34\3\2\2\2\u008a\u008b")
-        buf.write("\7n\2\2\u008b\u008c\7g\2\2\u008c\u008d\7v\2\2\u008d\36")
-        buf.write("\3\2\2\2\u008e\u008f\7?\2\2\u008f \3\2\2\2\u0090\u0091")
-        buf.write("\7=\2\2\u0091\"\3\2\2\2\u0092\u0093\7=\2\2\u0093\u0094")
-        buf.write("\7=\2\2\u0094$\3\2\2\2\u0095\u0096\7h\2\2\u0096\u0097")
-        buf.write("\7p\2\2\u0097&\3\2\2\2\u0098\u0099\7/\2\2\u0099\u009a")
-        buf.write("\7@\2\2\u009a(\3\2\2\2\u009b\u009c\7f\2\2\u009c\u009d")
-        buf.write("\7g\2\2\u009d\u009e\7h\2\2\u009e*\3\2\2\2\u009f\u00a0")
-        buf.write("\7v\2\2\u00a0\u00a1\7{\2\2\u00a1\u00a2\7r\2\2\u00a2\u00a3")
-        buf.write("\7g\2\2\u00a3,\3\2\2\2\u00a4\u00a5\7~\2\2\u00a5.\3\2\2")
-        buf.write("\2\u00a6\u00a7\7<\2\2\u00a7\60\3\2\2\2\u00a8\u00a9\7V")
-        buf.write("\2\2\u00a9\u00aa\7g\2\2\u00aa\u00ab\7p\2\2\u00ab\u00ac")
-        buf.write("\7u\2\2\u00ac\u00ad\7q\2\2\u00ad\u00ae\7t\2\2\u00ae\62")
-        buf.write("\3\2\2\2\u00af\u00b0\7a\2\2\u00b0\64\3\2\2\2\u00b1\u00b2")
-        buf.write("\7o\2\2\u00b2\u00b3\7g\2\2\u00b3\u00b4\7v\2\2\u00b4\u00b5")
-        buf.write("\7c\2\2\u00b5\66\3\2\2\2\u00b6\u00b7\7x\2\2\u00b7\u00b8")
-        buf.write("\7\62\2\2\u00b8\u00b9\7\60\2\2\u00b9\u00ba\7\62\2\2\u00ba")
-        buf.write("\u00bb\7\60\2\2\u00bb\u00bc\7\65\2\2\u00bc8\3\2\2\2\u00bd")
-        buf.write("\u00be\7\61\2\2\u00be\u00bf\7,\2\2\u00bf\u00c4\3\2\2\2")
-        buf.write("\u00c0\u00c3\59\35\2\u00c1\u00c3\13\2\2\2\u00c2\u00c0")
-        buf.write("\3\2\2\2\u00c2\u00c1\3\2\2\2\u00c3\u00c6\3\2\2\2\u00c4")
-        buf.write("\u00c5\3\2\2\2\u00c4\u00c2\3\2\2\2\u00c5\u00c7\3\2\2\2")
-        buf.write("\u00c6\u00c4\3\2\2\2\u00c7\u00c8\7,\2\2\u00c8\u00c9\7")
-        buf.write("\61\2\2\u00c9\u00ca\3\2\2\2\u00ca\u00cb\b\35\2\2\u00cb")
-        buf.write(":\3\2\2\2\u00cc\u00ce\t\2\2\2\u00cd\u00cc\3\2\2\2\u00ce")
-        buf.write("\u00cf\3\2\2\2\u00cf\u00cd\3\2\2\2\u00cf\u00d0\3\2\2\2")
-        buf.write("\u00d0\u00d1\3\2\2\2\u00d1\u00d2\b\36\2\2\u00d2<\3\2\2")
-        buf.write("\2\u00d3\u00d4\7\61\2\2\u00d4\u00d5\7\61\2\2\u00d5\u00d9")
-        buf.write("\3\2\2\2\u00d6\u00d8\13\2\2\2\u00d7\u00d6\3\2\2\2\u00d8")
-        buf.write("\u00db\3\2\2\2\u00d9\u00da\3\2\2\2\u00d9\u00d7\3\2\2\2")
-        buf.write("\u00da\u00dc\3\2\2\2\u00db\u00d9\3\2\2\2\u00dc\u00dd\7")
-        buf.write("\f\2\2\u00dd\u00de\3\2\2\2\u00de\u00df\b\37\2\2\u00df")
-        buf.write(">\3\2\2\2\u00e0\u00e1\7^\2\2\u00e1\u00e2\7$\2\2\u00e2")
-        buf.write("@\3\2\2\2\u00e3\u00e8\7$\2\2\u00e4\u00e7\5? \2\u00e5\u00e7")
-        buf.write("\n\3\2\2\u00e6\u00e4\3\2\2\2\u00e6\u00e5\3\2\2\2\u00e7")
-        buf.write("\u00ea\3\2\2\2\u00e8\u00e9\3\2\2\2\u00e8\u00e6\3\2\2\2")
-        buf.write("\u00e9\u00eb\3\2\2\2\u00ea\u00e8\3\2\2\2\u00eb\u00ec\7")
-        buf.write("$\2\2\u00ecB\3\2\2\2\u00ed\u00ee\7,\2\2\u00eeD\3\2\2\2")
-        buf.write("\u00ef\u00f0\7\61\2\2\u00f0F\3\2\2\2\u00f1\u00f2\7-\2")
-        buf.write("\2\u00f2H\3\2\2\2\u00f3\u00f4\7/\2\2\u00f4J\3\2\2\2\u00f5")
-        buf.write("\u00f6\7>\2\2\u00f6L\3\2\2\2\u00f7\u00f8\7@\2\2\u00f8")
-        buf.write("N\3\2\2\2\u00f9\u00fa\7>\2\2\u00fa\u00fb\7?\2\2\u00fb")
-        buf.write("P\3\2\2\2\u00fc\u00fd\7@\2\2\u00fd\u00fe\7?\2\2\u00fe")
-        buf.write("R\3\2\2\2\u00ff\u0100\7?\2\2\u0100\u0101\7?\2\2\u0101")
-        buf.write("T\3\2\2\2\u0102\u0103\7#\2\2\u0103\u0104\7?\2\2\u0104")
-        buf.write("V\3\2\2\2\u0105\u0106\7V\2\2\u0106\u0107\7t\2\2\u0107")
-        buf.write("\u0108\7w\2\2\u0108\u010f\7g\2\2\u0109\u010a\7H\2\2\u010a")
-        buf.write("\u010b\7c\2\2\u010b\u010c\7n\2\2\u010c\u010d\7u\2\2\u010d")
-        buf.write("\u010f\7g\2\2\u010e\u0105\3\2\2\2\u010e\u0109\3\2\2\2")
-        buf.write("\u010fX\3\2\2\2\u0110\u0113\7a\2\2\u0111\u0113\5e\63\2")
-        buf.write("\u0112\u0110\3\2\2\2\u0112\u0111\3\2\2\2\u0113\u0119\3")
-        buf.write("\2\2\2\u0114\u0118\7a\2\2\u0115\u0118\5e\63\2\u0116\u0118")
-        buf.write("\5g\64\2\u0117\u0114\3\2\2\2\u0117\u0115\3\2\2\2\u0117")
-        buf.write("\u0116\3\2\2\2\u0118\u011b\3\2\2\2\u0119\u0117\3\2\2\2")
-        buf.write("\u0119\u011a\3\2\2\2\u011a\u0120\3\2\2\2\u011b\u0119\3")
-        buf.write("\2\2\2\u011c\u011d\7\60\2\2\u011d\u011f\5Y-\2\u011e\u011c")
-        buf.write("\3\2\2\2\u011f\u0122\3\2\2\2\u0120\u011e\3\2\2\2\u0120")
-        buf.write("\u0121\3\2\2\2\u0121Z\3\2\2\2\u0122\u0120\3\2\2\2\u0123")
-        buf.write("\u0124\7k\2\2\u0124\u0125\7p\2\2\u0125\u0126\7v\2\2\u0126")
-        buf.write("\u0127\78\2\2\u0127\u0128\7\66\2\2\u0128\\\3\2\2\2\u0129")
-        buf.write("\u012c\5a\61\2\u012a\u012b\7\60\2\2\u012b\u012d\5a\61")
-        buf.write("\2\u012c\u012a\3\2\2\2\u012c\u012d\3\2\2\2\u012d\u012f")
-        buf.write("\3\2\2\2\u012e\u0130\5c\62\2\u012f\u012e\3\2\2\2\u012f")
-        buf.write("\u0130\3\2\2\2\u0130^\3\2\2\2\u0131\u0132\5]/\2\u0132")
-        buf.write("\u0133\7h\2\2\u0133`\3\2\2\2\u0134\u0136\5g\64\2\u0135")
-        buf.write("\u0134\3\2\2\2\u0136\u0137\3\2\2\2\u0137\u0135\3\2\2\2")
-        buf.write("\u0137\u0138\3\2\2\2\u0138b\3\2\2\2\u0139\u013b\t\4\2")
-        buf.write("\2\u013a\u013c\t\5\2\2\u013b\u013a\3\2\2\2\u013b\u013c")
-        buf.write("\3\2\2\2\u013c\u013d\3\2\2\2\u013d\u013e\5a\61\2\u013e")
-        buf.write("d\3\2\2\2\u013f\u0140\t\6\2\2\u0140f\3\2\2\2\u0141\u0142")
-        buf.write("\t\7\2\2\u0142h\3\2\2\2\u0143\u0144\7O\2\2\u0144\u0145")
-        buf.write("\7G\2\2\u0145\u0146\7V\2\2\u0146\u0147\7C\2\2\u0147\u0148")
-        buf.write("\7F\2\2\u0148\u0149\7C\2\2\u0149\u014a\7V\2\2\u014a\u014b")
-        buf.write("\7C\2\2\u014b\u014c\7<\2\2\u014c\u0150\3\2\2\2\u014d\u014f")
-        buf.write("\13\2\2\2\u014e\u014d\3\2\2\2\u014f\u0152\3\2\2\2\u0150")
-        buf.write("\u014e\3\2\2\2\u0150\u0151\3\2\2\2\u0151j\3\2\2\2\u0152")
-        buf.write("\u0150\3\2\2\2\23\2\u00c2\u00c4\u00cf\u00d9\u00e6\u00e8")
-        buf.write("\u010e\u0112\u0117\u0119\u0120\u012c\u012f\u0137\u013b")
-        buf.write("\u0150\3\b\2\2")
+        buf.write("\t\64\3\2\3\2\3\3\3\3\3\4\3\4\3\5\3\5\3\6\3\6\3\7\3\7")
+        buf.write("\3\b\3\b\3\t\3\t\3\n\3\n\3\13\3\13\3\f\3\f\3\f\3\r\3\r")
+        buf.write("\3\r\3\r\3\r\3\16\3\16\3\16\3\16\3\17\3\17\3\20\3\20\3")
+        buf.write("\21\3\21\3\21\3\22\3\22\3\22\3\23\3\23\3\23\3\24\3\24")
+        buf.write("\3\24\3\24\3\25\3\25\3\25\3\25\3\25\3\26\3\26\3\27\3\27")
+        buf.write("\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\31\3\31\3\32\3\32")
+        buf.write("\3\32\3\32\3\32\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\34")
+        buf.write("\3\34\3\34\3\34\3\34\7\34\u00be\n\34\f\34\16\34\u00c1")
+        buf.write("\13\34\3\34\3\34\3\34\3\34\3\34\3\35\6\35\u00c9\n\35\r")
+        buf.write("\35\16\35\u00ca\3\35\3\35\3\36\3\36\3\36\3\36\7\36\u00d3")
+        buf.write("\n\36\f\36\16\36\u00d6\13\36\3\36\3\36\3\36\3\36\3\37")
+        buf.write("\3\37\3\37\3 \3 \3 \7 \u00e2\n \f \16 \u00e5\13 \3 \3")
+        buf.write(" \3!\3!\3\"\3\"\3#\3#\3$\3$\3%\3%\3&\3&\3\'\3\'\3\'\3")
+        buf.write("(\3(\3(\3)\3)\3)\3*\3*\3*\3+\3+\3+\3+\3+\3+\3+\3+\3+\5")
+        buf.write("+\u010a\n+\3,\3,\5,\u010e\n,\3,\3,\3,\7,\u0113\n,\f,\16")
+        buf.write(",\u0116\13,\3,\3,\7,\u011a\n,\f,\16,\u011d\13,\3-\3-\3")
+        buf.write("-\3-\3-\3-\3.\3.\3.\5.\u0128\n.\3.\5.\u012b\n.\3/\3/\3")
+        buf.write("/\3\60\6\60\u0131\n\60\r\60\16\60\u0132\3\61\3\61\5\61")
+        buf.write("\u0137\n\61\3\61\3\61\3\62\3\62\3\63\3\63\3\64\3\64\3")
+        buf.write("\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\7\64\u014a")
+        buf.write("\n\64\f\64\16\64\u014d\13\64\5\u00bf\u00d4\u00e3\2\65")
+        buf.write("\3\3\5\4\7\5\t\6\13\7\r\b\17\t\21\n\23\13\25\f\27\r\31")
+        buf.write("\16\33\17\35\20\37\21!\22#\23%\24\'\25)\26+\27-\30/\31")
+        buf.write("\61\32\63\33\65\34\67\359\36;\37=\2? A!C\"E#G$I%K&M\'")
+        buf.write("O(Q)S*U+W,Y-[\2]._/a\2c\2e\2g\60\3\2\b\5\2\13\f\17\17")
+        buf.write("\"\"\4\2\f\f\17\17\4\2GGgg\4\2--//\4\2C\\c|\3\2\62;\2")
+        buf.write("\u0159\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3\2\2\2\2\t\3\2\2\2")
+        buf.write("\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2\2")
+        buf.write("\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33")
+        buf.write("\3\2\2\2\2\35\3\2\2\2\2\37\3\2\2\2\2!\3\2\2\2\2#\3\2\2")
+        buf.write("\2\2%\3\2\2\2\2\'\3\2\2\2\2)\3\2\2\2\2+\3\2\2\2\2-\3\2")
+        buf.write("\2\2\2/\3\2\2\2\2\61\3\2\2\2\2\63\3\2\2\2\2\65\3\2\2\2")
+        buf.write("\2\67\3\2\2\2\29\3\2\2\2\2;\3\2\2\2\2?\3\2\2\2\2A\3\2")
+        buf.write("\2\2\2C\3\2\2\2\2E\3\2\2\2\2G\3\2\2\2\2I\3\2\2\2\2K\3")
+        buf.write("\2\2\2\2M\3\2\2\2\2O\3\2\2\2\2Q\3\2\2\2\2S\3\2\2\2\2U")
+        buf.write("\3\2\2\2\2W\3\2\2\2\2Y\3\2\2\2\2]\3\2\2\2\2_\3\2\2\2\2")
+        buf.write("g\3\2\2\2\3i\3\2\2\2\5k\3\2\2\2\7m\3\2\2\2\to\3\2\2\2")
+        buf.write("\13q\3\2\2\2\rs\3\2\2\2\17u\3\2\2\2\21w\3\2\2\2\23y\3")
+        buf.write("\2\2\2\25{\3\2\2\2\27}\3\2\2\2\31\u0080\3\2\2\2\33\u0085")
+        buf.write("\3\2\2\2\35\u0089\3\2\2\2\37\u008b\3\2\2\2!\u008d\3\2")
+        buf.write("\2\2#\u0090\3\2\2\2%\u0093\3\2\2\2\'\u0096\3\2\2\2)\u009a")
+        buf.write("\3\2\2\2+\u009f\3\2\2\2-\u00a1\3\2\2\2/\u00a3\3\2\2\2")
+        buf.write("\61\u00aa\3\2\2\2\63\u00ac\3\2\2\2\65\u00b1\3\2\2\2\67")
+        buf.write("\u00b8\3\2\2\29\u00c8\3\2\2\2;\u00ce\3\2\2\2=\u00db\3")
+        buf.write("\2\2\2?\u00de\3\2\2\2A\u00e8\3\2\2\2C\u00ea\3\2\2\2E\u00ec")
+        buf.write("\3\2\2\2G\u00ee\3\2\2\2I\u00f0\3\2\2\2K\u00f2\3\2\2\2")
+        buf.write("M\u00f4\3\2\2\2O\u00f7\3\2\2\2Q\u00fa\3\2\2\2S\u00fd\3")
+        buf.write("\2\2\2U\u0109\3\2\2\2W\u010d\3\2\2\2Y\u011e\3\2\2\2[\u0124")
+        buf.write("\3\2\2\2]\u012c\3\2\2\2_\u0130\3\2\2\2a\u0134\3\2\2\2")
+        buf.write("c\u013a\3\2\2\2e\u013c\3\2\2\2g\u013e\3\2\2\2ij\7B\2\2")
+        buf.write("j\4\3\2\2\2kl\7\'\2\2l\6\3\2\2\2mn\7.\2\2n\b\3\2\2\2o")
+        buf.write("p\7*\2\2p\n\3\2\2\2qr\7+\2\2r\f\3\2\2\2st\7}\2\2t\16\3")
+        buf.write("\2\2\2uv\7\177\2\2v\20\3\2\2\2wx\7\60\2\2x\22\3\2\2\2")
+        buf.write("yz\7]\2\2z\24\3\2\2\2{|\7_\2\2|\26\3\2\2\2}~\7k\2\2~\177")
+        buf.write("\7h\2\2\177\30\3\2\2\2\u0080\u0081\7g\2\2\u0081\u0082")
+        buf.write("\7n\2\2\u0082\u0083\7u\2\2\u0083\u0084\7g\2\2\u0084\32")
+        buf.write("\3\2\2\2\u0085\u0086\7n\2\2\u0086\u0087\7g\2\2\u0087\u0088")
+        buf.write("\7v\2\2\u0088\34\3\2\2\2\u0089\u008a\7?\2\2\u008a\36\3")
+        buf.write("\2\2\2\u008b\u008c\7=\2\2\u008c \3\2\2\2\u008d\u008e\7")
+        buf.write("=\2\2\u008e\u008f\7=\2\2\u008f\"\3\2\2\2\u0090\u0091\7")
+        buf.write("h\2\2\u0091\u0092\7p\2\2\u0092$\3\2\2\2\u0093\u0094\7")
+        buf.write("/\2\2\u0094\u0095\7@\2\2\u0095&\3\2\2\2\u0096\u0097\7")
+        buf.write("f\2\2\u0097\u0098\7g\2\2\u0098\u0099\7h\2\2\u0099(\3\2")
+        buf.write("\2\2\u009a\u009b\7v\2\2\u009b\u009c\7{\2\2\u009c\u009d")
+        buf.write("\7r\2\2\u009d\u009e\7g\2\2\u009e*\3\2\2\2\u009f\u00a0")
+        buf.write("\7~\2\2\u00a0,\3\2\2\2\u00a1\u00a2\7<\2\2\u00a2.\3\2\2")
+        buf.write("\2\u00a3\u00a4\7V\2\2\u00a4\u00a5\7g\2\2\u00a5\u00a6\7")
+        buf.write("p\2\2\u00a6\u00a7\7u\2\2\u00a7\u00a8\7q\2\2\u00a8\u00a9")
+        buf.write("\7t\2\2\u00a9\60\3\2\2\2\u00aa\u00ab\7a\2\2\u00ab\62\3")
+        buf.write("\2\2\2\u00ac\u00ad\7o\2\2\u00ad\u00ae\7g\2\2\u00ae\u00af")
+        buf.write("\7v\2\2\u00af\u00b0\7c\2\2\u00b0\64\3\2\2\2\u00b1\u00b2")
+        buf.write("\7x\2\2\u00b2\u00b3\7\62\2\2\u00b3\u00b4\7\60\2\2\u00b4")
+        buf.write("\u00b5\7\62\2\2\u00b5\u00b6\7\60\2\2\u00b6\u00b7\7\65")
+        buf.write("\2\2\u00b7\66\3\2\2\2\u00b8\u00b9\7\61\2\2\u00b9\u00ba")
+        buf.write("\7,\2\2\u00ba\u00bf\3\2\2\2\u00bb\u00be\5\67\34\2\u00bc")
+        buf.write("\u00be\13\2\2\2\u00bd\u00bb\3\2\2\2\u00bd\u00bc\3\2\2")
+        buf.write("\2\u00be\u00c1\3\2\2\2\u00bf\u00c0\3\2\2\2\u00bf\u00bd")
+        buf.write("\3\2\2\2\u00c0\u00c2\3\2\2\2\u00c1\u00bf\3\2\2\2\u00c2")
+        buf.write("\u00c3\7,\2\2\u00c3\u00c4\7\61\2\2\u00c4\u00c5\3\2\2\2")
+        buf.write("\u00c5\u00c6\b\34\2\2\u00c68\3\2\2\2\u00c7\u00c9\t\2\2")
+        buf.write("\2\u00c8\u00c7\3\2\2\2\u00c9\u00ca\3\2\2\2\u00ca\u00c8")
+        buf.write("\3\2\2\2\u00ca\u00cb\3\2\2\2\u00cb\u00cc\3\2\2\2\u00cc")
+        buf.write("\u00cd\b\35\2\2\u00cd:\3\2\2\2\u00ce\u00cf\7\61\2\2\u00cf")
+        buf.write("\u00d0\7\61\2\2\u00d0\u00d4\3\2\2\2\u00d1\u00d3\13\2\2")
+        buf.write("\2\u00d2\u00d1\3\2\2\2\u00d3\u00d6\3\2\2\2\u00d4\u00d5")
+        buf.write("\3\2\2\2\u00d4\u00d2\3\2\2\2\u00d5\u00d7\3\2\2\2\u00d6")
+        buf.write("\u00d4\3\2\2\2\u00d7\u00d8\7\f\2\2\u00d8\u00d9\3\2\2\2")
+        buf.write("\u00d9\u00da\b\36\2\2\u00da<\3\2\2\2\u00db\u00dc\7^\2")
+        buf.write("\2\u00dc\u00dd\7$\2\2\u00dd>\3\2\2\2\u00de\u00e3\7$\2")
+        buf.write("\2\u00df\u00e2\5=\37\2\u00e0\u00e2\n\3\2\2\u00e1\u00df")
+        buf.write("\3\2\2\2\u00e1\u00e0\3\2\2\2\u00e2\u00e5\3\2\2\2\u00e3")
+        buf.write("\u00e4\3\2\2\2\u00e3\u00e1\3\2\2\2\u00e4\u00e6\3\2\2\2")
+        buf.write("\u00e5\u00e3\3\2\2\2\u00e6\u00e7\7$\2\2\u00e7@\3\2\2\2")
+        buf.write("\u00e8\u00e9\7,\2\2\u00e9B\3\2\2\2\u00ea\u00eb\7\61\2")
+        buf.write("\2\u00ebD\3\2\2\2\u00ec\u00ed\7-\2\2\u00edF\3\2\2\2\u00ee")
+        buf.write("\u00ef\7/\2\2\u00efH\3\2\2\2\u00f0\u00f1\7>\2\2\u00f1")
+        buf.write("J\3\2\2\2\u00f2\u00f3\7@\2\2\u00f3L\3\2\2\2\u00f4\u00f5")
+        buf.write("\7>\2\2\u00f5\u00f6\7?\2\2\u00f6N\3\2\2\2\u00f7\u00f8")
+        buf.write("\7@\2\2\u00f8\u00f9\7?\2\2\u00f9P\3\2\2\2\u00fa\u00fb")
+        buf.write("\7?\2\2\u00fb\u00fc\7?\2\2\u00fcR\3\2\2\2\u00fd\u00fe")
+        buf.write("\7#\2\2\u00fe\u00ff\7?\2\2\u00ffT\3\2\2\2\u0100\u0101")
+        buf.write("\7V\2\2\u0101\u0102\7t\2\2\u0102\u0103\7w\2\2\u0103\u010a")
+        buf.write("\7g\2\2\u0104\u0105\7H\2\2\u0105\u0106\7c\2\2\u0106\u0107")
+        buf.write("\7n\2\2\u0107\u0108\7u\2\2\u0108\u010a\7g\2\2\u0109\u0100")
+        buf.write("\3\2\2\2\u0109\u0104\3\2\2\2\u010aV\3\2\2\2\u010b\u010e")
+        buf.write("\7a\2\2\u010c\u010e\5c\62\2\u010d\u010b\3\2\2\2\u010d")
+        buf.write("\u010c\3\2\2\2\u010e\u0114\3\2\2\2\u010f\u0113\7a\2\2")
+        buf.write("\u0110\u0113\5c\62\2\u0111\u0113\5e\63\2\u0112\u010f\3")
+        buf.write("\2\2\2\u0112\u0110\3\2\2\2\u0112\u0111\3\2\2\2\u0113\u0116")
+        buf.write("\3\2\2\2\u0114\u0112\3\2\2\2\u0114\u0115\3\2\2\2\u0115")
+        buf.write("\u011b\3\2\2\2\u0116\u0114\3\2\2\2\u0117\u0118\7\60\2")
+        buf.write("\2\u0118\u011a\5W,\2\u0119\u0117\3\2\2\2\u011a\u011d\3")
+        buf.write("\2\2\2\u011b\u0119\3\2\2\2\u011b\u011c\3\2\2\2\u011cX")
+        buf.write("\3\2\2\2\u011d\u011b\3\2\2\2\u011e\u011f\7k\2\2\u011f")
+        buf.write("\u0120\7p\2\2\u0120\u0121\7v\2\2\u0121\u0122\78\2\2\u0122")
+        buf.write("\u0123\7\66\2\2\u0123Z\3\2\2\2\u0124\u0127\5_\60\2\u0125")
+        buf.write("\u0126\7\60\2\2\u0126\u0128\5_\60\2\u0127\u0125\3\2\2")
+        buf.write("\2\u0127\u0128\3\2\2\2\u0128\u012a\3\2\2\2\u0129\u012b")
+        buf.write("\5a\61\2\u012a\u0129\3\2\2\2\u012a\u012b\3\2\2\2\u012b")
+        buf.write("\\\3\2\2\2\u012c\u012d\5[.\2\u012d\u012e\7h\2\2\u012e")
+        buf.write("^\3\2\2\2\u012f\u0131\5e\63\2\u0130\u012f\3\2\2\2\u0131")
+        buf.write("\u0132\3\2\2\2\u0132\u0130\3\2\2\2\u0132\u0133\3\2\2\2")
+        buf.write("\u0133`\3\2\2\2\u0134\u0136\t\4\2\2\u0135\u0137\t\5\2")
+        buf.write("\2\u0136\u0135\3\2\2\2\u0136\u0137\3\2\2\2\u0137\u0138")
+        buf.write("\3\2\2\2\u0138\u0139\5_\60\2\u0139b\3\2\2\2\u013a\u013b")
+        buf.write("\t\6\2\2\u013bd\3\2\2\2\u013c\u013d\t\7\2\2\u013df\3\2")
+        buf.write("\2\2\u013e\u013f\7O\2\2\u013f\u0140\7G\2\2\u0140\u0141")
+        buf.write("\7V\2\2\u0141\u0142\7C\2\2\u0142\u0143\7F\2\2\u0143\u0144")
+        buf.write("\7C\2\2\u0144\u0145\7V\2\2\u0145\u0146\7C\2\2\u0146\u0147")
+        buf.write("\7<\2\2\u0147\u014b\3\2\2\2\u0148\u014a\13\2\2\2\u0149")
+        buf.write("\u0148\3\2\2\2\u014a\u014d\3\2\2\2\u014b\u0149\3\2\2\2")
+        buf.write("\u014b\u014c\3\2\2\2\u014ch\3\2\2\2\u014d\u014b\3\2\2")
+        buf.write("\2\23\2\u00bd\u00bf\u00ca\u00d4\u00e1\u00e3\u0109\u010d")
+        buf.write("\u0112\u0114\u011b\u0127\u012a\u0132\u0136\u014b\3\b\2")
+        buf.write("\2")
         return buf.getvalue()
 
 
@@ -188,39 +186,38 @@ class RelayLexer(Lexer):
     T__22 = 23
     T__23 = 24
     T__24 = 25
-    T__25 = 26
-    SEMVER = 27
-    COMMENT = 28
-    WS = 29
-    LINE_COMMENT = 30
-    QUOTED_STRING = 31
-    MUL = 32
-    DIV = 33
-    ADD = 34
-    SUB = 35
-    LT = 36
-    GT = 37
-    LE = 38
-    GE = 39
-    EQ = 40
-    NE = 41
-    BOOL_LIT = 42
-    CNAME = 43
-    DATATYPE = 44
-    FLOAT = 45
-    NAT = 46
-    METADATA = 47
+    SEMVER = 26
+    COMMENT = 27
+    WS = 28
+    LINE_COMMENT = 29
+    QUOTED_STRING = 30
+    MUL = 31
+    DIV = 32
+    ADD = 33
+    SUB = 34
+    LT = 35
+    GT = 36
+    LE = 37
+    GE = 38
+    EQ = 39
+    NE = 40
+    BOOL_LIT = 41
+    CNAME = 42
+    DATATYPE = 43
+    FLOAT = 44
+    NAT = 45
+    METADATA = 46
 
     channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ]
 
     modeNames = [ "DEFAULT_MODE" ]
 
     literalNames = [ "<INVALID>",
-            "'@'", "'%'", "'['", "', '", "']'", "','", "'('", "')'", "'{'", 
-            "'}'", "'.'", "'if'", "'else'", "'let'", "'='", "';'", "';;'", 
-            "'fn'", "'->'", "'def'", "'type'", "'|'", "':'", "'Tensor'", 
-            "'_'", "'meta'", "'v0.0.3'", "'*'", "'/'", "'+'", "'-'", "'<'", 
-            "'>'", "'<='", "'>='", "'=='", "'!='", "'int64'" ]
+            "'@'", "'%'", "','", "'('", "')'", "'{'", "'}'", "'.'", "'['", 
+            "']'", "'if'", "'else'", "'let'", "'='", "';'", "';;'", "'fn'", 
+            "'->'", "'def'", "'type'", "'|'", "':'", "'Tensor'", "'_'", 
+            "'meta'", "'v0.0.3'", "'*'", "'/'", "'+'", "'-'", "'<'", "'>'", 
+            "'<='", "'>='", "'=='", "'!='", "'int64'" ]
 
     symbolicNames = [ "<INVALID>",
             "SEMVER", "COMMENT", "WS", "LINE_COMMENT", "QUOTED_STRING", 
@@ -230,12 +227,11 @@ class RelayLexer(Lexer):
     ruleNames = [ "T__0", "T__1", "T__2", "T__3", "T__4", "T__5", "T__6", 
                   "T__7", "T__8", "T__9", "T__10", "T__11", "T__12", "T__13", 
                   "T__14", "T__15", "T__16", "T__17", "T__18", "T__19", 
-                  "T__20", "T__21", "T__22", "T__23", "T__24", "T__25", 
-                  "SEMVER", "COMMENT", "WS", "LINE_COMMENT", "ESCAPED_QUOTE", 
-                  "QUOTED_STRING", "MUL", "DIV", "ADD", "SUB", "LT", "GT", 
-                  "LE", "GE", "EQ", "NE", "BOOL_LIT", "CNAME", "DATATYPE", 
-                  "PREFLOAT", "FLOAT", "NAT", "EXP", "LETTER", "DIGIT", 
-                  "METADATA" ]
+                  "T__20", "T__21", "T__22", "T__23", "T__24", "SEMVER", 
+                  "COMMENT", "WS", "LINE_COMMENT", "ESCAPED_QUOTE", "QUOTED_STRING", 
+                  "MUL", "DIV", "ADD", "SUB", "LT", "GT", "LE", "GE", "EQ", 
+                  "NE", "BOOL_LIT", "CNAME", "DATATYPE", "PREFLOAT", "FLOAT", 
+                  "NAT", "EXP", "LETTER", "DIGIT", "METADATA" ]
 
     grammarFileName = "Relay.g4"
 
diff --git a/python/tvm/relay/grammar/py3/RelayParser.py b/python/tvm/relay/grammar/py3/RelayParser.py
index c6cf63a5ee25..4db03c14e784 100644
--- a/python/tvm/relay/grammar/py3/RelayParser.py
+++ b/python/tvm/relay/grammar/py3/RelayParser.py
@@ -8,210 +8,198 @@
 
 def serializedATN():
     with StringIO() as buf:
-        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\61")
-        buf.write("\u01a8\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
+        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\60")
+        buf.write("\u0195\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
         buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
         buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
         buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
-        buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\3\2\3\2")
-        buf.write("\7\2=\n\2\f\2\16\2@\13\2\3\2\5\2C\n\2\3\2\5\2F\n\2\3\2")
-        buf.write("\3\2\3\3\3\3\3\4\3\4\3\4\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3")
-        buf.write("\6\7\6W\n\6\f\6\16\6Z\13\6\3\6\3\6\5\6^\n\6\3\7\3\7\3")
-        buf.write("\b\3\b\3\b\3\t\3\t\3\t\7\th\n\t\f\t\16\tk\13\t\5\tm\n")
-        buf.write("\t\3\n\3\n\3\n\3\n\7\ns\n\n\f\n\16\nv\13\n\3\n\5\ny\n")
-        buf.write("\n\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3")
-        buf.write("\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13")
-        buf.write("\3\13\3\13\6\13\u0092\n\13\r\13\16\13\u0093\3\13\3\13")
-        buf.write("\3\13\3\13\3\13\3\13\7\13\u009c\n\13\f\13\16\13\u009f")
-        buf.write("\13\13\5\13\u00a1\n\13\3\13\3\13\3\13\3\13\3\13\3\13\3")
-        buf.write("\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13")
-        buf.write("\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\5\13\u00bd")
-        buf.write("\n\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13")
-        buf.write("\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13")
-        buf.write("\3\13\3\13\7\13\u00d6\n\13\f\13\16\13\u00d9\13\13\3\f")
-        buf.write("\3\f\5\f\u00dd\n\f\3\f\3\f\3\f\3\f\3\f\5\f\u00e4\n\f\3")
-        buf.write("\f\3\f\3\r\3\r\3\r\5\r\u00eb\n\r\3\r\3\r\3\r\3\r\3\r\5")
-        buf.write("\r\u00f2\n\r\3\r\3\r\3\r\3\r\3\r\3\r\6\r\u00fa\n\r\r\r")
-        buf.write("\16\r\u00fb\5\r\u00fe\n\r\3\16\3\16\3\16\3\16\3\16\3\16")
-        buf.write("\7\16\u0106\n\16\f\16\16\16\u0109\13\16\3\16\3\16\5\16")
-        buf.write("\u010d\n\16\3\17\3\17\3\20\3\20\3\20\3\20\7\20\u0115\n")
-        buf.write("\20\f\20\16\20\u0118\13\20\3\20\5\20\u011b\n\20\3\21\3")
-        buf.write("\21\3\21\7\21\u0120\n\21\f\21\16\21\u0123\13\21\5\21\u0125")
-        buf.write("\n\21\3\22\3\22\3\22\5\22\u012a\n\22\3\23\3\23\3\23\7")
-        buf.write("\23\u012f\n\23\f\23\16\23\u0132\13\23\3\24\3\24\3\24\3")
-        buf.write("\24\3\25\3\25\3\25\3\25\3\25\3\25\7\25\u013e\n\25\f\25")
-        buf.write("\16\25\u0141\13\25\3\25\3\25\5\25\u0145\n\25\3\26\3\26")
-        buf.write("\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\3\26\6\26\u0152")
-        buf.write("\n\26\r\26\16\26\u0153\3\26\3\26\3\26\3\26\3\26\3\26\3")
-        buf.write("\26\3\26\3\26\3\26\3\26\3\26\5\26\u0162\n\26\3\26\3\26")
-        buf.write("\3\26\3\26\7\26\u0168\n\26\f\26\16\26\u016b\13\26\5\26")
-        buf.write("\u016d\n\26\3\26\3\26\3\26\3\26\3\26\5\26\u0174\n\26\3")
-        buf.write("\27\3\27\3\27\3\27\6\27\u017a\n\27\r\27\16\27\u017b\3")
-        buf.write("\27\3\27\3\27\3\27\3\27\5\27\u0183\n\27\3\30\3\30\3\30")
-        buf.write("\3\30\3\30\3\30\3\30\3\30\3\31\3\31\3\31\3\31\3\31\3\31")
-        buf.write("\5\31\u0193\n\31\3\32\3\32\3\33\3\33\3\33\3\33\3\34\3")
-        buf.write("\34\3\34\5\34\u019e\n\34\3\35\3\35\3\35\3\35\3\35\3\35")
-        buf.write("\5\35\u01a6\n\35\3\35\2\3\24\36\2\4\6\b\n\f\16\20\22\24")
-        buf.write("\26\30\32\34\36 \"$&(*,.\60\62\64\668\2\6\3\2\"#\3\2$")
-        buf.write("%\3\2&)\3\2*+\2\u01d3\2:\3\2\2\2\4I\3\2\2\2\6K\3\2\2\2")
-        buf.write("\bN\3\2\2\2\nQ\3\2\2\2\f_\3\2\2\2\16a\3\2\2\2\20l\3\2")
-        buf.write("\2\2\22x\3\2\2\2\24\u00bc\3\2\2\2\26\u00da\3\2\2\2\30")
-        buf.write("\u00fd\3\2\2\2\32\u00ff\3\2\2\2\34\u010e\3\2\2\2\36\u011a")
-        buf.write("\3\2\2\2 \u0124\3\2\2\2\"\u0126\3\2\2\2$\u012b\3\2\2\2")
-        buf.write("&\u0133\3\2\2\2(\u0144\3\2\2\2*\u0173\3\2\2\2,\u0182\3")
-        buf.write("\2\2\2.\u0184\3\2\2\2\60\u0192\3\2\2\2\62\u0194\3\2\2")
-        buf.write("\2\64\u0196\3\2\2\2\66\u019d\3\2\2\28\u01a5\3\2\2\2:B")
-        buf.write("\7\35\2\2;=\5\30\r\2<;\3\2\2\2=@\3\2\2\2><\3\2\2\2>?\3")
-        buf.write("\2\2\2?C\3\2\2\2@>\3\2\2\2AC\5\24\13\2B>\3\2\2\2BA\3\2")
-        buf.write("\2\2CE\3\2\2\2DF\7\61\2\2ED\3\2\2\2EF\3\2\2\2FG\3\2\2")
-        buf.write("\2GH\7\2\2\3H\3\3\2\2\2IJ\7-\2\2J\5\3\2\2\2KL\7\3\2\2")
-        buf.write("LM\7-\2\2M\7\3\2\2\2NO\7\4\2\2OP\7-\2\2P\t\3\2\2\2Q]\7")
-        buf.write("-\2\2RS\7\5\2\2SX\5\f\7\2TU\7\6\2\2UW\5\f\7\2VT\3\2\2")
-        buf.write("\2WZ\3\2\2\2XV\3\2\2\2XY\3\2\2\2Y[\3\2\2\2ZX\3\2\2\2[")
-        buf.write("\\\7\7\2\2\\^\3\2\2\2]R\3\2\2\2]^\3\2\2\2^\13\3\2\2\2")
-        buf.write("_`\7-\2\2`\r\3\2\2\2ab\7\4\2\2bc\7\60\2\2c\17\3\2\2\2")
-        buf.write("di\5\24\13\2ef\7\b\2\2fh\5\24\13\2ge\3\2\2\2hk\3\2\2\2")
-        buf.write("ig\3\2\2\2ij\3\2\2\2jm\3\2\2\2ki\3\2\2\2ld\3\2\2\2lm\3")
-        buf.write("\2\2\2m\21\3\2\2\2ny\5\20\t\2op\5\24\13\2pq\7\b\2\2qs")
-        buf.write("\3\2\2\2ro\3\2\2\2sv\3\2\2\2tr\3\2\2\2tu\3\2\2\2uw\3\2")
-        buf.write("\2\2vt\3\2\2\2wy\5$\23\2xn\3\2\2\2xt\3\2\2\2y\23\3\2\2")
-        buf.write("\2z{\b\13\1\2{|\7\t\2\2|}\5\24\13\2}~\7\n\2\2~\u00bd\3")
-        buf.write("\2\2\2\177\u0080\7\13\2\2\u0080\u0081\5\24\13\2\u0081")
-        buf.write("\u0082\7\f\2\2\u0082\u00bd\3\2\2\2\u0083\u0084\7%\2\2")
-        buf.write("\u0084\u00bd\5\24\13\25\u0085\u00bd\5\26\f\2\u0086\u0087")
-        buf.write("\7\t\2\2\u0087\u00bd\7\n\2\2\u0088\u0089\7\t\2\2\u0089")
-        buf.write("\u008a\5\24\13\2\u008a\u008b\7\b\2\2\u008b\u008c\7\n\2")
-        buf.write("\2\u008c\u00bd\3\2\2\2\u008d\u008e\7\t\2\2\u008e\u0091")
-        buf.write("\5\24\13\2\u008f\u0090\7\b\2\2\u0090\u0092\5\24\13\2\u0091")
-        buf.write("\u008f\3\2\2\2\u0092\u0093\3\2\2\2\u0093\u0091\3\2\2\2")
-        buf.write("\u0093\u0094\3\2\2\2\u0094\u0095\3\2\2\2\u0095\u0096\7")
-        buf.write("\n\2\2\u0096\u00bd\3\2\2\2\u0097\u00a0\7\5\2\2\u0098\u009d")
-        buf.write("\5\24\13\2\u0099\u009a\7\b\2\2\u009a\u009c\5\24\13\2\u009b")
-        buf.write("\u0099\3\2\2\2\u009c\u009f\3\2\2\2\u009d\u009b\3\2\2\2")
-        buf.write("\u009d\u009e\3\2\2\2\u009e\u00a1\3\2\2\2\u009f\u009d\3")
-        buf.write("\2\2\2\u00a0\u0098\3\2\2\2\u00a0\u00a1\3\2\2\2\u00a1\u00a2")
-        buf.write("\3\2\2\2\u00a2\u00bd\7\7\2\2\u00a3\u00a4\7\16\2\2\u00a4")
-        buf.write("\u00a5\7\t\2\2\u00a5\u00a6\5\24\13\2\u00a6\u00a7\7\n\2")
-        buf.write("\2\u00a7\u00a8\5\64\33\2\u00a8\u00a9\7\17\2\2\u00a9\u00aa")
-        buf.write("\5\64\33\2\u00aa\u00bd\3\2\2\2\u00ab\u00ac\7\20\2\2\u00ac")
-        buf.write("\u00ad\5\"\22\2\u00ad\u00ae\7\21\2\2\u00ae\u00af\5\24")
-        buf.write("\13\2\u00af\u00b0\7\22\2\2\u00b0\u00b1\5\24\13\t\u00b1")
-        buf.write("\u00bd\3\2\2\2\u00b2\u00b3\5\16\b\2\u00b3\u00b4\7\21\2")
-        buf.write("\2\u00b4\u00b5\5\24\13\2\u00b5\u00b6\7\22\2\2\u00b6\u00b7")
-        buf.write("\5\24\13\7\u00b7\u00bd\3\2\2\2\u00b8\u00bd\58\35\2\u00b9")
-        buf.write("\u00bd\5\66\34\2\u00ba\u00bd\5.\30\2\u00bb\u00bd\7!\2")
-        buf.write("\2\u00bcz\3\2\2\2\u00bc\177\3\2\2\2\u00bc\u0083\3\2\2")
-        buf.write("\2\u00bc\u0085\3\2\2\2\u00bc\u0086\3\2\2\2\u00bc\u0088")
-        buf.write("\3\2\2\2\u00bc\u008d\3\2\2\2\u00bc\u0097\3\2\2\2\u00bc")
-        buf.write("\u00a3\3\2\2\2\u00bc\u00ab\3\2\2\2\u00bc\u00b2\3\2\2\2")
-        buf.write("\u00bc\u00b8\3\2\2\2\u00bc\u00b9\3\2\2\2\u00bc\u00ba\3")
-        buf.write("\2\2\2\u00bc\u00bb\3\2\2\2\u00bd\u00d7\3\2\2\2\u00be\u00bf")
-        buf.write("\f\24\2\2\u00bf\u00c0\t\2\2\2\u00c0\u00d6\5\24\13\25\u00c1")
-        buf.write("\u00c2\f\23\2\2\u00c2\u00c3\t\3\2\2\u00c3\u00d6\5\24\13")
-        buf.write("\24\u00c4\u00c5\f\22\2\2\u00c5\u00c6\t\4\2\2\u00c6\u00d6")
-        buf.write("\5\24\13\23\u00c7\u00c8\f\21\2\2\u00c8\u00c9\t\5\2\2\u00c9")
-        buf.write("\u00d6\5\24\13\22\u00ca\u00cb\f\b\2\2\u00cb\u00cc\7\23")
-        buf.write("\2\2\u00cc\u00d6\5\24\13\t\u00cd\u00ce\f\26\2\2\u00ce")
-        buf.write("\u00cf\7\t\2\2\u00cf\u00d0\5\22\n\2\u00d0\u00d1\7\n\2")
-        buf.write("\2\u00d1\u00d6\3\2\2\2\u00d2\u00d3\f\f\2\2\u00d3\u00d4")
-        buf.write("\7\r\2\2\u00d4\u00d6\7\60\2\2\u00d5\u00be\3\2\2\2\u00d5")
-        buf.write("\u00c1\3\2\2\2\u00d5\u00c4\3\2\2\2\u00d5\u00c7\3\2\2\2")
-        buf.write("\u00d5\u00ca\3\2\2\2\u00d5\u00cd\3\2\2\2\u00d5\u00d2\3")
-        buf.write("\2\2\2\u00d6\u00d9\3\2\2\2\u00d7\u00d5\3\2\2\2\u00d7\u00d8")
-        buf.write("\3\2\2\2\u00d8\25\3\2\2\2\u00d9\u00d7\3\2\2\2\u00da\u00dc")
-        buf.write("\7\24\2\2\u00db\u00dd\5(\25\2\u00dc\u00db\3\2\2\2\u00dc")
-        buf.write("\u00dd\3\2\2\2\u00dd\u00de\3\2\2\2\u00de\u00df\7\t\2\2")
-        buf.write("\u00df\u00e0\5\36\20\2\u00e0\u00e3\7\n\2\2\u00e1\u00e2")
-        buf.write("\7\25\2\2\u00e2\u00e4\5*\26\2\u00e3\u00e1\3\2\2\2\u00e3")
-        buf.write("\u00e4\3\2\2\2\u00e4\u00e5\3\2\2\2\u00e5\u00e6\5\64\33")
-        buf.write("\2\u00e6\27\3\2\2\2\u00e7\u00e8\7\26\2\2\u00e8\u00ea\5")
-        buf.write("\6\4\2\u00e9\u00eb\5(\25\2\u00ea\u00e9\3\2\2\2\u00ea\u00eb")
-        buf.write("\3\2\2\2\u00eb\u00ec\3\2\2\2\u00ec\u00ed\7\t\2\2\u00ed")
-        buf.write("\u00ee\5\36\20\2\u00ee\u00f1\7\n\2\2\u00ef\u00f0\7\25")
-        buf.write("\2\2\u00f0\u00f2\5*\26\2\u00f1\u00ef\3\2\2\2\u00f1\u00f2")
-        buf.write("\3\2\2\2\u00f2\u00f3\3\2\2\2\u00f3\u00f4\5\64\33\2\u00f4")
-        buf.write("\u00fe\3\2\2\2\u00f5\u00f6\7\27\2\2\u00f6\u00f7\5\n\6")
-        buf.write("\2\u00f7\u00f9\7\21\2\2\u00f8\u00fa\5\32\16\2\u00f9\u00f8")
-        buf.write("\3\2\2\2\u00fa\u00fb\3\2\2\2\u00fb\u00f9\3\2\2\2\u00fb")
-        buf.write("\u00fc\3\2\2\2\u00fc\u00fe\3\2\2\2\u00fd\u00e7\3\2\2\2")
-        buf.write("\u00fd\u00f5\3\2\2\2\u00fe\31\3\2\2\2\u00ff\u0100\7\30")
-        buf.write("\2\2\u0100\u010c\5\34\17\2\u0101\u0102\7\t\2\2\u0102\u0107")
-        buf.write("\5*\26\2\u0103\u0104\7\6\2\2\u0104\u0106\5*\26\2\u0105")
-        buf.write("\u0103\3\2\2\2\u0106\u0109\3\2\2\2\u0107\u0105\3\2\2\2")
+        buf.write("\t\31\4\32\t\32\4\33\t\33\3\2\3\2\7\29\n\2\f\2\16\2<\13")
+        buf.write("\2\3\2\5\2?\n\2\3\2\5\2B\n\2\3\2\3\2\3\3\3\3\3\4\3\4\3")
+        buf.write("\4\3\5\3\5\3\5\3\6\3\6\3\7\3\7\3\7\3\b\3\b\3\b\7\bV\n")
+        buf.write("\b\f\b\16\bY\13\b\5\b[\n\b\3\t\3\t\3\t\3\t\7\ta\n\t\f")
+        buf.write("\t\16\td\13\t\3\t\5\tg\n\t\3\n\3\n\3\n\3\n\3\n\3\n\3\n")
+        buf.write("\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3")
+        buf.write("\n\3\n\3\n\6\n\u0080\n\n\r\n\16\n\u0081\3\n\3\n\3\n\3")
+        buf.write("\n\3\n\3\n\7\n\u008a\n\n\f\n\16\n\u008d\13\n\5\n\u008f")
+        buf.write("\n\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3")
+        buf.write("\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n")
+        buf.write("\5\n\u00ab\n\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n")
+        buf.write("\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\7")
+        buf.write("\n\u00c4\n\n\f\n\16\n\u00c7\13\n\3\13\3\13\5\13\u00cb")
+        buf.write("\n\13\3\13\3\13\3\13\3\13\3\13\5\13\u00d2\n\13\3\13\3")
+        buf.write("\13\3\f\3\f\3\f\5\f\u00d9\n\f\3\f\3\f\3\f\3\f\3\f\5\f")
+        buf.write("\u00e0\n\f\3\f\3\f\3\f\3\f\3\f\5\f\u00e7\n\f\3\f\3\f\6")
+        buf.write("\f\u00eb\n\f\r\f\16\f\u00ec\5\f\u00ef\n\f\3\r\3\r\3\r")
+        buf.write("\3\r\3\r\3\r\7\r\u00f7\n\r\f\r\16\r\u00fa\13\r\3\r\3\r")
+        buf.write("\5\r\u00fe\n\r\3\16\3\16\3\17\3\17\3\17\3\17\7\17\u0106")
+        buf.write("\n\17\f\17\16\17\u0109\13\17\3\17\5\17\u010c\n\17\3\20")
+        buf.write("\3\20\3\20\7\20\u0111\n\20\f\20\16\20\u0114\13\20\5\20")
+        buf.write("\u0116\n\20\3\21\3\21\3\21\5\21\u011b\n\21\3\22\3\22\3")
+        buf.write("\22\7\22\u0120\n\22\f\22\16\22\u0123\13\22\3\23\3\23\3")
+        buf.write("\23\3\23\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24")
+        buf.write("\3\24\3\24\6\24\u0134\n\24\r\24\16\24\u0135\3\24\3\24")
+        buf.write("\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24")
+        buf.write("\3\24\3\24\5\24\u0147\n\24\3\24\3\24\3\24\3\24\7\24\u014d")
+        buf.write("\n\24\f\24\16\24\u0150\13\24\5\24\u0152\n\24\3\24\3\24")
+        buf.write("\3\24\3\24\3\24\5\24\u0159\n\24\3\25\3\25\3\25\3\25\7")
+        buf.write("\25\u015f\n\25\f\25\16\25\u0162\13\25\3\25\3\25\3\26\3")
+        buf.write("\26\3\26\3\26\6\26\u016a\n\26\r\26\16\26\u016b\3\26\3")
+        buf.write("\26\3\26\3\26\3\26\5\26\u0173\n\26\3\27\3\27\3\27\3\27")
+        buf.write("\3\27\3\27\3\27\3\27\3\30\3\30\3\30\3\30\3\30\3\30\5\30")
+        buf.write("\u0183\n\30\3\31\3\31\3\31\3\31\3\32\3\32\3\32\5\32\u018c")
+        buf.write("\n\32\3\33\3\33\3\33\3\33\3\33\5\33\u0193\n\33\3\33\2")
+        buf.write("\3\22\34\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(")
+        buf.write("*,.\60\62\64\2\6\3\2!\"\3\2#$\3\2%(\3\2)*\2\u01c0\2\66")
+        buf.write("\3\2\2\2\4E\3\2\2\2\6G\3\2\2\2\bJ\3\2\2\2\nM\3\2\2\2\f")
+        buf.write("O\3\2\2\2\16Z\3\2\2\2\20f\3\2\2\2\22\u00aa\3\2\2\2\24")
+        buf.write("\u00c8\3\2\2\2\26\u00ee\3\2\2\2\30\u00f0\3\2\2\2\32\u00ff")
+        buf.write("\3\2\2\2\34\u010b\3\2\2\2\36\u0115\3\2\2\2 \u0117\3\2")
+        buf.write("\2\2\"\u011c\3\2\2\2$\u0124\3\2\2\2&\u0158\3\2\2\2(\u015a")
+        buf.write("\3\2\2\2*\u0172\3\2\2\2,\u0174\3\2\2\2.\u0182\3\2\2\2")
+        buf.write("\60\u0184\3\2\2\2\62\u018b\3\2\2\2\64\u0192\3\2\2\2\66")
+        buf.write(">\7\34\2\2\679\5\26\f\28\67\3\2\2\29<\3\2\2\2:8\3\2\2")
+        buf.write("\2:;\3\2\2\2;?\3\2\2\2<:\3\2\2\2=?\5\22\n\2>:\3\2\2\2")
+        buf.write(">=\3\2\2\2?A\3\2\2\2@B\7\60\2\2A@\3\2\2\2AB\3\2\2\2BC")
+        buf.write("\3\2\2\2CD\7\2\2\3D\3\3\2\2\2EF\7,\2\2F\5\3\2\2\2GH\7")
+        buf.write("\3\2\2HI\7,\2\2I\7\3\2\2\2JK\7\4\2\2KL\7,\2\2L\t\3\2\2")
+        buf.write("\2MN\7,\2\2N\13\3\2\2\2OP\7\4\2\2PQ\7/\2\2Q\r\3\2\2\2")
+        buf.write("RW\5\22\n\2ST\7\5\2\2TV\5\22\n\2US\3\2\2\2VY\3\2\2\2W")
+        buf.write("U\3\2\2\2WX\3\2\2\2X[\3\2\2\2YW\3\2\2\2ZR\3\2\2\2Z[\3")
+        buf.write("\2\2\2[\17\3\2\2\2\\g\5\16\b\2]^\5\22\n\2^_\7\5\2\2_a")
+        buf.write("\3\2\2\2`]\3\2\2\2ad\3\2\2\2b`\3\2\2\2bc\3\2\2\2ce\3\2")
+        buf.write("\2\2db\3\2\2\2eg\5\"\22\2f\\\3\2\2\2fb\3\2\2\2g\21\3\2")
+        buf.write("\2\2hi\b\n\1\2ij\7\6\2\2jk\5\22\n\2kl\7\7\2\2l\u00ab\3")
+        buf.write("\2\2\2mn\7\b\2\2no\5\22\n\2op\7\t\2\2p\u00ab\3\2\2\2q")
+        buf.write("r\7$\2\2r\u00ab\5\22\n\25s\u00ab\5\24\13\2tu\7\6\2\2u")
+        buf.write("\u00ab\7\7\2\2vw\7\6\2\2wx\5\22\n\2xy\7\5\2\2yz\7\7\2")
+        buf.write("\2z\u00ab\3\2\2\2{|\7\6\2\2|\177\5\22\n\2}~\7\5\2\2~\u0080")
+        buf.write("\5\22\n\2\177}\3\2\2\2\u0080\u0081\3\2\2\2\u0081\177\3")
+        buf.write("\2\2\2\u0081\u0082\3\2\2\2\u0082\u0083\3\2\2\2\u0083\u0084")
+        buf.write("\7\7\2\2\u0084\u00ab\3\2\2\2\u0085\u008e\7\13\2\2\u0086")
+        buf.write("\u008b\5\22\n\2\u0087\u0088\7\5\2\2\u0088\u008a\5\22\n")
+        buf.write("\2\u0089\u0087\3\2\2\2\u008a\u008d\3\2\2\2\u008b\u0089")
+        buf.write("\3\2\2\2\u008b\u008c\3\2\2\2\u008c\u008f\3\2\2\2\u008d")
+        buf.write("\u008b\3\2\2\2\u008e\u0086\3\2\2\2\u008e\u008f\3\2\2\2")
+        buf.write("\u008f\u0090\3\2\2\2\u0090\u00ab\7\f\2\2\u0091\u0092\7")
+        buf.write("\r\2\2\u0092\u0093\7\6\2\2\u0093\u0094\5\22\n\2\u0094")
+        buf.write("\u0095\7\7\2\2\u0095\u0096\5\60\31\2\u0096\u0097\7\16")
+        buf.write("\2\2\u0097\u0098\5\60\31\2\u0098\u00ab\3\2\2\2\u0099\u009a")
+        buf.write("\7\17\2\2\u009a\u009b\5 \21\2\u009b\u009c\7\20\2\2\u009c")
+        buf.write("\u009d\5\22\n\2\u009d\u009e\7\21\2\2\u009e\u009f\5\22")
+        buf.write("\n\t\u009f\u00ab\3\2\2\2\u00a0\u00a1\5\f\7\2\u00a1\u00a2")
+        buf.write("\7\20\2\2\u00a2\u00a3\5\22\n\2\u00a3\u00a4\7\21\2\2\u00a4")
+        buf.write("\u00a5\5\22\n\7\u00a5\u00ab\3\2\2\2\u00a6\u00ab\5\64\33")
+        buf.write("\2\u00a7\u00ab\5\62\32\2\u00a8\u00ab\5,\27\2\u00a9\u00ab")
+        buf.write("\7 \2\2\u00aah\3\2\2\2\u00aam\3\2\2\2\u00aaq\3\2\2\2\u00aa")
+        buf.write("s\3\2\2\2\u00aat\3\2\2\2\u00aav\3\2\2\2\u00aa{\3\2\2\2")
+        buf.write("\u00aa\u0085\3\2\2\2\u00aa\u0091\3\2\2\2\u00aa\u0099\3")
+        buf.write("\2\2\2\u00aa\u00a0\3\2\2\2\u00aa\u00a6\3\2\2\2\u00aa\u00a7")
+        buf.write("\3\2\2\2\u00aa\u00a8\3\2\2\2\u00aa\u00a9\3\2\2\2\u00ab")
+        buf.write("\u00c5\3\2\2\2\u00ac\u00ad\f\24\2\2\u00ad\u00ae\t\2\2")
+        buf.write("\2\u00ae\u00c4\5\22\n\25\u00af\u00b0\f\23\2\2\u00b0\u00b1")
+        buf.write("\t\3\2\2\u00b1\u00c4\5\22\n\24\u00b2\u00b3\f\22\2\2\u00b3")
+        buf.write("\u00b4\t\4\2\2\u00b4\u00c4\5\22\n\23\u00b5\u00b6\f\21")
+        buf.write("\2\2\u00b6\u00b7\t\5\2\2\u00b7\u00c4\5\22\n\22\u00b8\u00b9")
+        buf.write("\f\b\2\2\u00b9\u00ba\7\22\2\2\u00ba\u00c4\5\22\n\t\u00bb")
+        buf.write("\u00bc\f\26\2\2\u00bc\u00bd\7\6\2\2\u00bd\u00be\5\20\t")
+        buf.write("\2\u00be\u00bf\7\7\2\2\u00bf\u00c4\3\2\2\2\u00c0\u00c1")
+        buf.write("\f\f\2\2\u00c1\u00c2\7\n\2\2\u00c2\u00c4\7/\2\2\u00c3")
+        buf.write("\u00ac\3\2\2\2\u00c3\u00af\3\2\2\2\u00c3\u00b2\3\2\2\2")
+        buf.write("\u00c3\u00b5\3\2\2\2\u00c3\u00b8\3\2\2\2\u00c3\u00bb\3")
+        buf.write("\2\2\2\u00c3\u00c0\3\2\2\2\u00c4\u00c7\3\2\2\2\u00c5\u00c3")
+        buf.write("\3\2\2\2\u00c5\u00c6\3\2\2\2\u00c6\23\3\2\2\2\u00c7\u00c5")
+        buf.write("\3\2\2\2\u00c8\u00ca\7\23\2\2\u00c9\u00cb\5(\25\2\u00ca")
+        buf.write("\u00c9\3\2\2\2\u00ca\u00cb\3\2\2\2\u00cb\u00cc\3\2\2\2")
+        buf.write("\u00cc\u00cd\7\6\2\2\u00cd\u00ce\5\34\17\2\u00ce\u00d1")
+        buf.write("\7\7\2\2\u00cf\u00d0\7\24\2\2\u00d0\u00d2\5&\24\2\u00d1")
+        buf.write("\u00cf\3\2\2\2\u00d1\u00d2\3\2\2\2\u00d2\u00d3\3\2\2\2")
+        buf.write("\u00d3\u00d4\5\60\31\2\u00d4\25\3\2\2\2\u00d5\u00d6\7")
+        buf.write("\25\2\2\u00d6\u00d8\5\6\4\2\u00d7\u00d9\5(\25\2\u00d8")
+        buf.write("\u00d7\3\2\2\2\u00d8\u00d9\3\2\2\2\u00d9\u00da\3\2\2\2")
+        buf.write("\u00da\u00db\7\6\2\2\u00db\u00dc\5\34\17\2\u00dc\u00df")
+        buf.write("\7\7\2\2\u00dd\u00de\7\24\2\2\u00de\u00e0\5&\24\2\u00df")
+        buf.write("\u00dd\3\2\2\2\u00df\u00e0\3\2\2\2\u00e0\u00e1\3\2\2\2")
+        buf.write("\u00e1\u00e2\5\60\31\2\u00e2\u00ef\3\2\2\2\u00e3\u00e4")
+        buf.write("\7\26\2\2\u00e4\u00e6\5\n\6\2\u00e5\u00e7\5(\25\2\u00e6")
+        buf.write("\u00e5\3\2\2\2\u00e6\u00e7\3\2\2\2\u00e7\u00e8\3\2\2\2")
+        buf.write("\u00e8\u00ea\7\20\2\2\u00e9\u00eb\5\30\r\2\u00ea\u00e9")
+        buf.write("\3\2\2\2\u00eb\u00ec\3\2\2\2\u00ec\u00ea\3\2\2\2\u00ec")
+        buf.write("\u00ed\3\2\2\2\u00ed\u00ef\3\2\2\2\u00ee\u00d5\3\2\2\2")
+        buf.write("\u00ee\u00e3\3\2\2\2\u00ef\27\3\2\2\2\u00f0\u00f1\7\27")
+        buf.write("\2\2\u00f1\u00fd\5\32\16\2\u00f2\u00f3\7\6\2\2\u00f3\u00f8")
+        buf.write("\5&\24\2\u00f4\u00f5\7\5\2\2\u00f5\u00f7\5&\24\2\u00f6")
+        buf.write("\u00f4\3\2\2\2\u00f7\u00fa\3\2\2\2\u00f8\u00f6\3\2\2\2")
+        buf.write("\u00f8\u00f9\3\2\2\2\u00f9\u00fb\3\2\2\2\u00fa\u00f8\3")
+        buf.write("\2\2\2\u00fb\u00fc\7\7\2\2\u00fc\u00fe\3\2\2\2\u00fd\u00f2")
+        buf.write("\3\2\2\2\u00fd\u00fe\3\2\2\2\u00fe\31\3\2\2\2\u00ff\u0100")
+        buf.write("\7,\2\2\u0100\33\3\2\2\2\u0101\u010c\5\36\20\2\u0102\u0103")
+        buf.write("\5 \21\2\u0103\u0104\7\5\2\2\u0104\u0106\3\2\2\2\u0105")
+        buf.write("\u0102\3\2\2\2\u0106\u0109\3\2\2\2\u0107\u0105\3\2\2\2")
         buf.write("\u0107\u0108\3\2\2\2\u0108\u010a\3\2\2\2\u0109\u0107\3")
-        buf.write("\2\2\2\u010a\u010b\7\n\2\2\u010b\u010d\3\2\2\2\u010c\u0101")
-        buf.write("\3\2\2\2\u010c\u010d\3\2\2\2\u010d\33\3\2\2\2\u010e\u010f")
-        buf.write("\7-\2\2\u010f\35\3\2\2\2\u0110\u011b\5 \21\2\u0111\u0112")
-        buf.write("\5\"\22\2\u0112\u0113\7\b\2\2\u0113\u0115\3\2\2\2\u0114")
-        buf.write("\u0111\3\2\2\2\u0115\u0118\3\2\2\2\u0116\u0114\3\2\2\2")
-        buf.write("\u0116\u0117\3\2\2\2\u0117\u0119\3\2\2\2\u0118\u0116\3")
-        buf.write("\2\2\2\u0119\u011b\5$\23\2\u011a\u0110\3\2\2\2\u011a\u0116")
-        buf.write("\3\2\2\2\u011b\37\3\2\2\2\u011c\u0121\5\"\22\2\u011d\u011e")
-        buf.write("\7\b\2\2\u011e\u0120\5\"\22\2\u011f\u011d\3\2\2\2\u0120")
-        buf.write("\u0123\3\2\2\2\u0121\u011f\3\2\2\2\u0121\u0122\3\2\2\2")
-        buf.write("\u0122\u0125\3\2\2\2\u0123\u0121\3\2\2\2\u0124\u011c\3")
-        buf.write("\2\2\2\u0124\u0125\3\2\2\2\u0125!\3\2\2\2\u0126\u0129")
-        buf.write("\5\b\5\2\u0127\u0128\7\31\2\2\u0128\u012a\5*\26\2\u0129")
-        buf.write("\u0127\3\2\2\2\u0129\u012a\3\2\2\2\u012a#\3\2\2\2\u012b")
-        buf.write("\u0130\5&\24\2\u012c\u012d\7\b\2\2\u012d\u012f\5&\24\2")
-        buf.write("\u012e\u012c\3\2\2\2\u012f\u0132\3\2\2\2\u0130\u012e\3")
-        buf.write("\2\2\2\u0130\u0131\3\2\2\2\u0131%\3\2\2\2\u0132\u0130")
-        buf.write("\3\2\2\2\u0133\u0134\7-\2\2\u0134\u0135\7\21\2\2\u0135")
-        buf.write("\u0136\5\24\13\2\u0136\'\3\2\2\2\u0137\u0138\7\5\2\2\u0138")
-        buf.write("\u0145\7\7\2\2\u0139\u013a\7\5\2\2\u013a\u013f\58\35\2")
-        buf.write("\u013b\u013c\7\b\2\2\u013c\u013e\58\35\2\u013d\u013b\3")
-        buf.write("\2\2\2\u013e\u0141\3\2\2\2\u013f\u013d\3\2\2\2\u013f\u0140")
-        buf.write("\3\2\2\2\u0140\u0142\3\2\2\2\u0141\u013f\3\2\2\2\u0142")
-        buf.write("\u0143\7\7\2\2\u0143\u0145\3\2\2\2\u0144\u0137\3\2\2\2")
-        buf.write("\u0144\u0139\3\2\2\2\u0145)\3\2\2\2\u0146\u0147\7\t\2")
-        buf.write("\2\u0147\u0174\7\n\2\2\u0148\u0149\7\t\2\2\u0149\u014a")
-        buf.write("\5*\26\2\u014a\u014b\7\b\2\2\u014b\u014c\7\n\2\2\u014c")
-        buf.write("\u0174\3\2\2\2\u014d\u014e\7\t\2\2\u014e\u0151\5*\26\2")
-        buf.write("\u014f\u0150\7\b\2\2\u0150\u0152\5*\26\2\u0151\u014f\3")
-        buf.write("\2\2\2\u0152\u0153\3\2\2\2\u0153\u0151\3\2\2\2\u0153\u0154")
-        buf.write("\3\2\2\2\u0154\u0155\3\2\2\2\u0155\u0156\7\n\2\2\u0156")
-        buf.write("\u0174\3\2\2\2\u0157\u0174\5\n\6\2\u0158\u0159\7\32\2")
-        buf.write("\2\u0159\u015a\7\5\2\2\u015a\u015b\5,\27\2\u015b\u015c")
-        buf.write("\7\b\2\2\u015c\u015d\5*\26\2\u015d\u015e\7\7\2\2\u015e")
-        buf.write("\u0174\3\2\2\2\u015f\u0161\7\24\2\2\u0160\u0162\5(\25")
-        buf.write("\2\u0161\u0160\3\2\2\2\u0161\u0162\3\2\2\2\u0162\u0163")
-        buf.write("\3\2\2\2\u0163\u016c\7\t\2\2\u0164\u0169\5*\26\2\u0165")
-        buf.write("\u0166\7\b\2\2\u0166\u0168\5*\26\2\u0167\u0165\3\2\2\2")
-        buf.write("\u0168\u016b\3\2\2\2\u0169\u0167\3\2\2\2\u0169\u016a\3")
-        buf.write("\2\2\2\u016a\u016d\3\2\2\2\u016b\u0169\3\2\2\2\u016c\u0164")
-        buf.write("\3\2\2\2\u016c\u016d\3\2\2\2\u016d\u016e\3\2\2\2\u016e")
-        buf.write("\u016f\7\n\2\2\u016f\u0170\7\25\2\2\u0170\u0174\5*\26")
-        buf.write("\2\u0171\u0174\7\33\2\2\u0172\u0174\7\60\2\2\u0173\u0146")
-        buf.write("\3\2\2\2\u0173\u0148\3\2\2\2\u0173\u014d\3\2\2\2\u0173")
-        buf.write("\u0157\3\2\2\2\u0173\u0158\3\2\2\2\u0173\u015f\3\2\2\2")
-        buf.write("\u0173\u0171\3\2\2\2\u0173\u0172\3\2\2\2\u0174+\3\2\2")
-        buf.write("\2\u0175\u0176\7\t\2\2\u0176\u0179\5\60\31\2\u0177\u0178")
-        buf.write("\7\b\2\2\u0178\u017a\5\60\31\2\u0179\u0177\3\2\2\2\u017a")
-        buf.write("\u017b\3\2\2\2\u017b\u0179\3\2\2\2\u017b\u017c\3\2\2\2")
-        buf.write("\u017c\u017d\3\2\2\2\u017d\u017e\7\n\2\2\u017e\u0183\3")
-        buf.write("\2\2\2\u017f\u0180\7\t\2\2\u0180\u0183\7\n\2\2\u0181\u0183")
-        buf.write("\5\60\31\2\u0182\u0175\3\2\2\2\u0182\u017f\3\2\2\2\u0182")
-        buf.write("\u0181\3\2\2\2\u0183-\3\2\2\2\u0184\u0185\7\34\2\2\u0185")
-        buf.write("\u0186\7\5\2\2\u0186\u0187\7-\2\2\u0187\u0188\7\7\2\2")
-        buf.write("\u0188\u0189\7\5\2\2\u0189\u018a\7\60\2\2\u018a\u018b")
-        buf.write("\7\7\2\2\u018b/\3\2\2\2\u018c\u0193\5.\30\2\u018d\u018e")
-        buf.write("\7\t\2\2\u018e\u018f\5\60\31\2\u018f\u0190\7\n\2\2\u0190")
-        buf.write("\u0193\3\2\2\2\u0191\u0193\7\60\2\2\u0192\u018c\3\2\2")
-        buf.write("\2\u0192\u018d\3\2\2\2\u0192\u0191\3\2\2\2\u0193\61\3")
-        buf.write("\2\2\2\u0194\u0195\7-\2\2\u0195\63\3\2\2\2\u0196\u0197")
-        buf.write("\7\13\2\2\u0197\u0198\5\24\13\2\u0198\u0199\7\f\2\2\u0199")
-        buf.write("\65\3\2\2\2\u019a\u019e\7/\2\2\u019b\u019e\7\60\2\2\u019c")
-        buf.write("\u019e\7,\2\2\u019d\u019a\3\2\2\2\u019d\u019b\3\2\2\2")
-        buf.write("\u019d\u019c\3\2\2\2\u019e\67\3\2\2\2\u019f\u01a6\5\4")
-        buf.write("\3\2\u01a0\u01a6\5\6\4\2\u01a1\u01a6\5\b\5\2\u01a2\u01a6")
-        buf.write("\5\n\6\2\u01a3\u01a6\5\f\7\2\u01a4\u01a6\5\16\b\2\u01a5")
-        buf.write("\u019f\3\2\2\2\u01a5\u01a0\3\2\2\2\u01a5\u01a1\3\2\2\2")
-        buf.write("\u01a5\u01a2\3\2\2\2\u01a5\u01a3\3\2\2\2\u01a5\u01a4\3")
-        buf.write("\2\2\2\u01a69\3\2\2\2+>BEX]iltx\u0093\u009d\u00a0\u00bc")
-        buf.write("\u00d5\u00d7\u00dc\u00e3\u00ea\u00f1\u00fb\u00fd\u0107")
-        buf.write("\u010c\u0116\u011a\u0121\u0124\u0129\u0130\u013f\u0144")
-        buf.write("\u0153\u0161\u0169\u016c\u0173\u017b\u0182\u0192\u019d")
-        buf.write("\u01a5")
+        buf.write("\2\2\2\u010a\u010c\5\"\22\2\u010b\u0101\3\2\2\2\u010b")
+        buf.write("\u0107\3\2\2\2\u010c\35\3\2\2\2\u010d\u0112\5 \21\2\u010e")
+        buf.write("\u010f\7\5\2\2\u010f\u0111\5 \21\2\u0110\u010e\3\2\2\2")
+        buf.write("\u0111\u0114\3\2\2\2\u0112\u0110\3\2\2\2\u0112\u0113\3")
+        buf.write("\2\2\2\u0113\u0116\3\2\2\2\u0114\u0112\3\2\2\2\u0115\u010d")
+        buf.write("\3\2\2\2\u0115\u0116\3\2\2\2\u0116\37\3\2\2\2\u0117\u011a")
+        buf.write("\5\b\5\2\u0118\u0119\7\30\2\2\u0119\u011b\5&\24\2\u011a")
+        buf.write("\u0118\3\2\2\2\u011a\u011b\3\2\2\2\u011b!\3\2\2\2\u011c")
+        buf.write("\u0121\5$\23\2\u011d\u011e\7\5\2\2\u011e\u0120\5$\23\2")
+        buf.write("\u011f\u011d\3\2\2\2\u0120\u0123\3\2\2\2\u0121\u011f\3")
+        buf.write("\2\2\2\u0121\u0122\3\2\2\2\u0122#\3\2\2\2\u0123\u0121")
+        buf.write("\3\2\2\2\u0124\u0125\7,\2\2\u0125\u0126\7\20\2\2\u0126")
+        buf.write("\u0127\5\22\n\2\u0127%\3\2\2\2\u0128\u0129\7\6\2\2\u0129")
+        buf.write("\u0159\7\7\2\2\u012a\u012b\7\6\2\2\u012b\u012c\5&\24\2")
+        buf.write("\u012c\u012d\7\5\2\2\u012d\u012e\7\7\2\2\u012e\u0159\3")
+        buf.write("\2\2\2\u012f\u0130\7\6\2\2\u0130\u0133\5&\24\2\u0131\u0132")
+        buf.write("\7\5\2\2\u0132\u0134\5&\24\2\u0133\u0131\3\2\2\2\u0134")
+        buf.write("\u0135\3\2\2\2\u0135\u0133\3\2\2\2\u0135\u0136\3\2\2\2")
+        buf.write("\u0136\u0137\3\2\2\2\u0137\u0138\7\7\2\2\u0138\u0159\3")
+        buf.write("\2\2\2\u0139\u013a\5\n\6\2\u013a\u013b\5(\25\2\u013b\u0159")
+        buf.write("\3\2\2\2\u013c\u0159\5\n\6\2\u013d\u013e\7\31\2\2\u013e")
+        buf.write("\u013f\7\13\2\2\u013f\u0140\5*\26\2\u0140\u0141\7\5\2")
+        buf.write("\2\u0141\u0142\5&\24\2\u0142\u0143\7\f\2\2\u0143\u0159")
+        buf.write("\3\2\2\2\u0144\u0146\7\23\2\2\u0145\u0147\5(\25\2\u0146")
+        buf.write("\u0145\3\2\2\2\u0146\u0147\3\2\2\2\u0147\u0148\3\2\2\2")
+        buf.write("\u0148\u0151\7\6\2\2\u0149\u014e\5&\24\2\u014a\u014b\7")
+        buf.write("\5\2\2\u014b\u014d\5&\24\2\u014c\u014a\3\2\2\2\u014d\u0150")
+        buf.write("\3\2\2\2\u014e\u014c\3\2\2\2\u014e\u014f\3\2\2\2\u014f")
+        buf.write("\u0152\3\2\2\2\u0150\u014e\3\2\2\2\u0151\u0149\3\2\2\2")
+        buf.write("\u0151\u0152\3\2\2\2\u0152\u0153\3\2\2\2\u0153\u0154\7")
+        buf.write("\7\2\2\u0154\u0155\7\24\2\2\u0155\u0159\5&\24\2\u0156")
+        buf.write("\u0159\7\32\2\2\u0157\u0159\7/\2\2\u0158\u0128\3\2\2\2")
+        buf.write("\u0158\u012a\3\2\2\2\u0158\u012f\3\2\2\2\u0158\u0139\3")
+        buf.write("\2\2\2\u0158\u013c\3\2\2\2\u0158\u013d\3\2\2\2\u0158\u0144")
+        buf.write("\3\2\2\2\u0158\u0156\3\2\2\2\u0158\u0157\3\2\2\2\u0159")
+        buf.write("\'\3\2\2\2\u015a\u015b\7\13\2\2\u015b\u0160\5\n\6\2\u015c")
+        buf.write("\u015d\7\5\2\2\u015d\u015f\5\n\6\2\u015e\u015c\3\2\2\2")
+        buf.write("\u015f\u0162\3\2\2\2\u0160\u015e\3\2\2\2\u0160\u0161\3")
+        buf.write("\2\2\2\u0161\u0163\3\2\2\2\u0162\u0160\3\2\2\2\u0163\u0164")
+        buf.write("\7\f\2\2\u0164)\3\2\2\2\u0165\u0166\7\6\2\2\u0166\u0169")
+        buf.write("\5.\30\2\u0167\u0168\7\5\2\2\u0168\u016a\5.\30\2\u0169")
+        buf.write("\u0167\3\2\2\2\u016a\u016b\3\2\2\2\u016b\u0169\3\2\2\2")
+        buf.write("\u016b\u016c\3\2\2\2\u016c\u016d\3\2\2\2\u016d\u016e\7")
+        buf.write("\7\2\2\u016e\u0173\3\2\2\2\u016f\u0170\7\6\2\2\u0170\u0173")
+        buf.write("\7\7\2\2\u0171\u0173\5.\30\2\u0172\u0165\3\2\2\2\u0172")
+        buf.write("\u016f\3\2\2\2\u0172\u0171\3\2\2\2\u0173+\3\2\2\2\u0174")
+        buf.write("\u0175\7\33\2\2\u0175\u0176\7\13\2\2\u0176\u0177\7,\2")
+        buf.write("\2\u0177\u0178\7\f\2\2\u0178\u0179\7\13\2\2\u0179\u017a")
+        buf.write("\7/\2\2\u017a\u017b\7\f\2\2\u017b-\3\2\2\2\u017c\u0183")
+        buf.write("\5,\27\2\u017d\u017e\7\6\2\2\u017e\u017f\5.\30\2\u017f")
+        buf.write("\u0180\7\7\2\2\u0180\u0183\3\2\2\2\u0181\u0183\7/\2\2")
+        buf.write("\u0182\u017c\3\2\2\2\u0182\u017d\3\2\2\2\u0182\u0181\3")
+        buf.write("\2\2\2\u0183/\3\2\2\2\u0184\u0185\7\b\2\2\u0185\u0186")
+        buf.write("\5\22\n\2\u0186\u0187\7\t\2\2\u0187\61\3\2\2\2\u0188\u018c")
+        buf.write("\7.\2\2\u0189\u018c\7/\2\2\u018a\u018c\7+\2\2\u018b\u0188")
+        buf.write("\3\2\2\2\u018b\u0189\3\2\2\2\u018b\u018a\3\2\2\2\u018c")
+        buf.write("\63\3\2\2\2\u018d\u0193\5\4\3\2\u018e\u0193\5\6\4\2\u018f")
+        buf.write("\u0193\5\b\5\2\u0190\u0193\5&\24\2\u0191\u0193\5\f\7\2")
+        buf.write("\u0192\u018d\3\2\2\2\u0192\u018e\3\2\2\2\u0192\u018f\3")
+        buf.write("\2\2\2\u0192\u0190\3\2\2\2\u0192\u0191\3\2\2\2\u0193\65")
+        buf.write("\3\2\2\2):>AWZbf\u0081\u008b\u008e\u00aa\u00c3\u00c5\u00ca")
+        buf.write("\u00d1\u00d8\u00df\u00e6\u00ec\u00ee\u00f8\u00fd\u0107")
+        buf.write("\u010b\u0112\u0115\u011a\u0121\u0135\u0146\u014e\u0151")
+        buf.write("\u0158\u0160\u016b\u0172\u0182\u018b\u0192")
         return buf.getvalue()
 
 
@@ -225,14 +213,13 @@ class RelayParser ( Parser ):
 
     sharedContextCache = PredictionContextCache()
 
-    literalNames = [ "<INVALID>", "'@'", "'%'", "'['", "', '", "']'", "','", 
-                     "'('", "')'", "'{'", "'}'", "'.'", "'if'", "'else'", 
-                     "'let'", "'='", "';'", "';;'", "'fn'", "'->'", "'def'", 
-                     "'type'", "'|'", "':'", "'Tensor'", "'_'", "'meta'", 
-                     "'v0.0.3'", "<INVALID>", "<INVALID>", "<INVALID>", 
-                     "<INVALID>", "'*'", "'/'", "'+'", "'-'", "'<'", "'>'", 
-                     "'<='", "'>='", "'=='", "'!='", "<INVALID>", "<INVALID>", 
-                     "'int64'" ]
+    literalNames = [ "<INVALID>", "'@'", "'%'", "','", "'('", "')'", "'{'", 
+                     "'}'", "'.'", "'['", "']'", "'if'", "'else'", "'let'", 
+                     "'='", "';'", "';;'", "'fn'", "'->'", "'def'", "'type'", 
+                     "'|'", "':'", "'Tensor'", "'_'", "'meta'", "'v0.0.3'", 
+                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
+                     "'*'", "'/'", "'+'", "'-'", "'<'", "'>'", "'<='", "'>='", 
+                     "'=='", "'!='", "<INVALID>", "<INVALID>", "'int64'" ]
 
     symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
@@ -240,46 +227,43 @@ class RelayParser ( Parser ):
                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
-                      "<INVALID>", "<INVALID>", "<INVALID>", "SEMVER", "COMMENT", 
-                      "WS", "LINE_COMMENT", "QUOTED_STRING", "MUL", "DIV", 
-                      "ADD", "SUB", "LT", "GT", "LE", "GE", "EQ", "NE", 
-                      "BOOL_LIT", "CNAME", "DATATYPE", "FLOAT", "NAT", "METADATA" ]
+                      "<INVALID>", "<INVALID>", "SEMVER", "COMMENT", "WS", 
+                      "LINE_COMMENT", "QUOTED_STRING", "MUL", "DIV", "ADD", 
+                      "SUB", "LT", "GT", "LE", "GE", "EQ", "NE", "BOOL_LIT", 
+                      "CNAME", "DATATYPE", "FLOAT", "NAT", "METADATA" ]
 
     RULE_prog = 0
     RULE_opIdent = 1
     RULE_globalVar = 2
     RULE_localVar = 3
-    RULE_globalTypeVar = 4
-    RULE_typeVar = 5
-    RULE_graphVar = 6
-    RULE_exprList = 7
-    RULE_callList = 8
-    RULE_expr = 9
-    RULE_func = 10
-    RULE_defn = 11
-    RULE_adtVariant = 12
-    RULE_variantName = 13
-    RULE_argList = 14
-    RULE_varList = 15
-    RULE_var = 16
-    RULE_attrSeq = 17
-    RULE_attr = 18
+    RULE_typeIdent = 4
+    RULE_graphVar = 5
+    RULE_exprList = 6
+    RULE_callList = 7
+    RULE_expr = 8
+    RULE_func = 9
+    RULE_defn = 10
+    RULE_adtVariant = 11
+    RULE_variantName = 12
+    RULE_argList = 13
+    RULE_varList = 14
+    RULE_var = 15
+    RULE_attrSeq = 16
+    RULE_attr = 17
+    RULE_typeExpr = 18
     RULE_typeParamList = 19
-    RULE_type_ = 20
-    RULE_shapeList = 21
-    RULE_meta = 22
-    RULE_shape = 23
-    RULE_typeIdent = 24
-    RULE_body = 25
-    RULE_scalar = 26
-    RULE_ident = 27
-
-    ruleNames =  [ "prog", "opIdent", "globalVar", "localVar", "globalTypeVar", 
-                   "typeVar", "graphVar", "exprList", "callList", "expr", 
-                   "func", "defn", "adtVariant", "variantName", "argList", 
-                   "varList", "var", "attrSeq", "attr", "typeParamList", 
-                   "type_", "shapeList", "meta", "shape", "typeIdent", "body", 
-                   "scalar", "ident" ]
+    RULE_shapeList = 20
+    RULE_meta = 21
+    RULE_shape = 22
+    RULE_body = 23
+    RULE_scalar = 24
+    RULE_ident = 25
+
+    ruleNames =  [ "prog", "opIdent", "globalVar", "localVar", "typeIdent", 
+                   "graphVar", "exprList", "callList", "expr", "func", "defn", 
+                   "adtVariant", "variantName", "argList", "varList", "var", 
+                   "attrSeq", "attr", "typeExpr", "typeParamList", "shapeList", 
+                   "meta", "shape", "body", "scalar", "ident" ]
 
     EOF = Token.EOF
     T__0=1
@@ -307,28 +291,27 @@ class RelayParser ( Parser ):
     T__22=23
     T__23=24
     T__24=25
-    T__25=26
-    SEMVER=27
-    COMMENT=28
-    WS=29
-    LINE_COMMENT=30
-    QUOTED_STRING=31
-    MUL=32
-    DIV=33
-    ADD=34
-    SUB=35
-    LT=36
-    GT=37
-    LE=38
-    GE=39
-    EQ=40
-    NE=41
-    BOOL_LIT=42
-    CNAME=43
-    DATATYPE=44
-    FLOAT=45
-    NAT=46
-    METADATA=47
+    SEMVER=26
+    COMMENT=27
+    WS=28
+    LINE_COMMENT=29
+    QUOTED_STRING=30
+    MUL=31
+    DIV=32
+    ADD=33
+    SUB=34
+    LT=35
+    GT=36
+    LE=37
+    GE=38
+    EQ=39
+    NE=40
+    BOOL_LIT=41
+    CNAME=42
+    DATATYPE=43
+    FLOAT=44
+    NAT=45
+    METADATA=46
 
     def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
         super().__init__(input, output)
@@ -384,39 +367,39 @@ def prog(self):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 56
+            self.state = 52
             self.match(RelayParser.SEMVER)
-            self.state = 64
+            self.state = 60
             self._errHandler.sync(self)
             token = self._input.LA(1)
-            if token in [RelayParser.EOF, RelayParser.T__19, RelayParser.T__20, RelayParser.METADATA]:
-                self.state = 60
+            if token in [RelayParser.EOF, RelayParser.T__18, RelayParser.T__19, RelayParser.METADATA]:
+                self.state = 56
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                while _la==RelayParser.T__19 or _la==RelayParser.T__20:
-                    self.state = 57
+                while _la==RelayParser.T__18 or _la==RelayParser.T__19:
+                    self.state = 53
                     self.defn()
-                    self.state = 62
+                    self.state = 58
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
                 pass
-            elif token in [RelayParser.T__0, RelayParser.T__1, RelayParser.T__2, RelayParser.T__6, RelayParser.T__8, RelayParser.T__11, RelayParser.T__13, RelayParser.T__17, RelayParser.T__25, RelayParser.QUOTED_STRING, RelayParser.SUB, RelayParser.BOOL_LIT, RelayParser.CNAME, RelayParser.FLOAT, RelayParser.NAT]:
-                self.state = 63
+            elif token in [RelayParser.T__0, RelayParser.T__1, RelayParser.T__3, RelayParser.T__5, RelayParser.T__8, RelayParser.T__10, RelayParser.T__12, RelayParser.T__16, RelayParser.T__22, RelayParser.T__23, RelayParser.T__24, RelayParser.QUOTED_STRING, RelayParser.SUB, RelayParser.BOOL_LIT, RelayParser.CNAME, RelayParser.FLOAT, RelayParser.NAT]:
+                self.state = 59
                 self.expr(0)
                 pass
             else:
                 raise NoViableAltException(self)
 
-            self.state = 67
+            self.state = 63
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==RelayParser.METADATA:
-                self.state = 66
+                self.state = 62
                 self.match(RelayParser.METADATA)
 
 
-            self.state = 69
+            self.state = 65
             self.match(RelayParser.EOF)
         except RecognitionException as re:
             localctx.exception = re
@@ -454,7 +437,7 @@ def opIdent(self):
         self.enterRule(localctx, 2, self.RULE_opIdent)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 71
+            self.state = 67
             self.match(RelayParser.CNAME)
         except RecognitionException as re:
             localctx.exception = re
@@ -492,9 +475,9 @@ def globalVar(self):
         self.enterRule(localctx, 4, self.RULE_globalVar)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 73
+            self.state = 69
             self.match(RelayParser.T__0)
-            self.state = 74
+            self.state = 70
             self.match(RelayParser.CNAME)
         except RecognitionException as re:
             localctx.exception = re
@@ -532,80 +515,10 @@ def localVar(self):
         self.enterRule(localctx, 6, self.RULE_localVar)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 76
+            self.state = 72
             self.match(RelayParser.T__1)
-            self.state = 77
-            self.match(RelayParser.CNAME)
-        except RecognitionException as re:
-            localctx.exception = re
-            self._errHandler.reportError(self, re)
-            self._errHandler.recover(self, re)
-        finally:
-            self.exitRule()
-        return localctx
-
-
-    class GlobalTypeVarContext(ParserRuleContext):
-
-        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
-            super().__init__(parent, invokingState)
-            self.parser = parser
-
-        def CNAME(self):
-            return self.getToken(RelayParser.CNAME, 0)
-
-        def typeVar(self, i:int=None):
-            if i is None:
-                return self.getTypedRuleContexts(RelayParser.TypeVarContext)
-            else:
-                return self.getTypedRuleContext(RelayParser.TypeVarContext,i)
-
-
-        def getRuleIndex(self):
-            return RelayParser.RULE_globalTypeVar
-
-        def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitGlobalTypeVar" ):
-                return visitor.visitGlobalTypeVar(self)
-            else:
-                return visitor.visitChildren(self)
-
-
-
-
-    def globalTypeVar(self):
-
-        localctx = RelayParser.GlobalTypeVarContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 8, self.RULE_globalTypeVar)
-        self._la = 0 # Token type
-        try:
-            self.enterOuterAlt(localctx, 1)
-            self.state = 79
+            self.state = 73
             self.match(RelayParser.CNAME)
-            self.state = 91
-            self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,4,self._ctx)
-            if la_ == 1:
-                self.state = 80
-                self.match(RelayParser.T__2)
-                self.state = 81
-                self.typeVar()
-                self.state = 86
-                self._errHandler.sync(self)
-                _la = self._input.LA(1)
-                while _la==RelayParser.T__3:
-                    self.state = 82
-                    self.match(RelayParser.T__3)
-                    self.state = 83
-                    self.typeVar()
-                    self.state = 88
-                    self._errHandler.sync(self)
-                    _la = self._input.LA(1)
-
-                self.state = 89
-                self.match(RelayParser.T__4)
-
-
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -615,7 +528,7 @@ def globalTypeVar(self):
         return localctx
 
 
-    class TypeVarContext(ParserRuleContext):
+    class TypeIdentContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
             super().__init__(parent, invokingState)
@@ -625,24 +538,24 @@ def CNAME(self):
             return self.getToken(RelayParser.CNAME, 0)
 
         def getRuleIndex(self):
-            return RelayParser.RULE_typeVar
+            return RelayParser.RULE_typeIdent
 
         def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitTypeVar" ):
-                return visitor.visitTypeVar(self)
+            if hasattr( visitor, "visitTypeIdent" ):
+                return visitor.visitTypeIdent(self)
             else:
                 return visitor.visitChildren(self)
 
 
 
 
-    def typeVar(self):
+    def typeIdent(self):
 
-        localctx = RelayParser.TypeVarContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 10, self.RULE_typeVar)
+        localctx = RelayParser.TypeIdentContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 8, self.RULE_typeIdent)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 93
+            self.state = 75
             self.match(RelayParser.CNAME)
         except RecognitionException as re:
             localctx.exception = re
@@ -677,12 +590,12 @@ def accept(self, visitor:ParseTreeVisitor):
     def graphVar(self):
 
         localctx = RelayParser.GraphVarContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 12, self.RULE_graphVar)
+        self.enterRule(localctx, 10, self.RULE_graphVar)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 95
+            self.state = 77
             self.match(RelayParser.T__1)
-            self.state = 96
+            self.state = 78
             self.match(RelayParser.NAT)
         except RecognitionException as re:
             localctx.exception = re
@@ -721,25 +634,25 @@ def accept(self, visitor:ParseTreeVisitor):
     def exprList(self):
 
         localctx = RelayParser.ExprListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 14, self.RULE_exprList)
+        self.enterRule(localctx, 12, self.RULE_exprList)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 106
+            self.state = 88
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__0) | (1 << RelayParser.T__1) | (1 << RelayParser.T__2) | (1 << RelayParser.T__6) | (1 << RelayParser.T__8) | (1 << RelayParser.T__11) | (1 << RelayParser.T__13) | (1 << RelayParser.T__17) | (1 << RelayParser.T__25) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
-                self.state = 98
+            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__0) | (1 << RelayParser.T__1) | (1 << RelayParser.T__3) | (1 << RelayParser.T__5) | (1 << RelayParser.T__8) | (1 << RelayParser.T__10) | (1 << RelayParser.T__12) | (1 << RelayParser.T__16) | (1 << RelayParser.T__22) | (1 << RelayParser.T__23) | (1 << RelayParser.T__24) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
+                self.state = 80
                 self.expr(0)
-                self.state = 103
+                self.state = 85
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                while _la==RelayParser.T__5:
-                    self.state = 99
-                    self.match(RelayParser.T__5)
-                    self.state = 100
+                while _la==RelayParser.T__2:
+                    self.state = 81
+                    self.match(RelayParser.T__2)
+                    self.state = 82
                     self.expr(0)
-                    self.state = 105
+                    self.state = 87
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
@@ -814,35 +727,35 @@ def accept(self, visitor:ParseTreeVisitor):
     def callList(self):
 
         localctx = RelayParser.CallListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 16, self.RULE_callList)
+        self.enterRule(localctx, 14, self.RULE_callList)
         try:
-            self.state = 118
+            self.state = 100
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,8,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,6,self._ctx)
             if la_ == 1:
                 localctx = RelayParser.CallNoAttrContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 108
+                self.state = 90
                 self.exprList()
                 pass
 
             elif la_ == 2:
                 localctx = RelayParser.CallWithAttrContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 114
+                self.state = 96
                 self._errHandler.sync(self)
-                _alt = self._interp.adaptivePredict(self._input,7,self._ctx)
+                _alt = self._interp.adaptivePredict(self._input,5,self._ctx)
                 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                     if _alt==1:
-                        self.state = 109
+                        self.state = 91
                         self.expr(0)
-                        self.state = 110
-                        self.match(RelayParser.T__5) 
-                    self.state = 116
+                        self.state = 92
+                        self.match(RelayParser.T__2) 
+                    self.state = 98
                     self._errHandler.sync(self)
-                    _alt = self._interp.adaptivePredict(self._input,7,self._ctx)
+                    _alt = self._interp.adaptivePredict(self._input,5,self._ctx)
 
-                self.state = 117
+                self.state = 99
                 self.attrSeq()
                 pass
 
@@ -1186,46 +1099,46 @@ def expr(self, _p:int=0):
         _parentState = self.state
         localctx = RelayParser.ExprContext(self, self._ctx, _parentState)
         _prevctx = localctx
-        _startState = 18
-        self.enterRecursionRule(localctx, 18, self.RULE_expr, _p)
+        _startState = 16
+        self.enterRecursionRule(localctx, 16, self.RULE_expr, _p)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 186
+            self.state = 168
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,12,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,10,self._ctx)
             if la_ == 1:
                 localctx = RelayParser.ParenContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
 
-                self.state = 121
-                self.match(RelayParser.T__6)
-                self.state = 122
+                self.state = 103
+                self.match(RelayParser.T__3)
+                self.state = 104
                 self.expr(0)
-                self.state = 123
-                self.match(RelayParser.T__7)
+                self.state = 105
+                self.match(RelayParser.T__4)
                 pass
 
             elif la_ == 2:
                 localctx = RelayParser.ParenContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 125
-                self.match(RelayParser.T__8)
-                self.state = 126
+                self.state = 107
+                self.match(RelayParser.T__5)
+                self.state = 108
                 self.expr(0)
-                self.state = 127
-                self.match(RelayParser.T__9)
+                self.state = 109
+                self.match(RelayParser.T__6)
                 pass
 
             elif la_ == 3:
                 localctx = RelayParser.NegContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 129
+                self.state = 111
                 self.match(RelayParser.SUB)
-                self.state = 130
+                self.state = 112
                 self.expr(19)
                 pass
 
@@ -1233,7 +1146,7 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.FuncExprContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 131
+                self.state = 113
                 self.func()
                 pass
 
@@ -1241,99 +1154,99 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.TupleContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 132
-                self.match(RelayParser.T__6)
-                self.state = 133
-                self.match(RelayParser.T__7)
+                self.state = 114
+                self.match(RelayParser.T__3)
+                self.state = 115
+                self.match(RelayParser.T__4)
                 pass
 
             elif la_ == 6:
                 localctx = RelayParser.TupleContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 134
-                self.match(RelayParser.T__6)
-                self.state = 135
+                self.state = 116
+                self.match(RelayParser.T__3)
+                self.state = 117
                 self.expr(0)
-                self.state = 136
-                self.match(RelayParser.T__5)
-                self.state = 137
-                self.match(RelayParser.T__7)
+                self.state = 118
+                self.match(RelayParser.T__2)
+                self.state = 119
+                self.match(RelayParser.T__4)
                 pass
 
             elif la_ == 7:
                 localctx = RelayParser.TupleContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 139
-                self.match(RelayParser.T__6)
-                self.state = 140
+                self.state = 121
+                self.match(RelayParser.T__3)
+                self.state = 122
                 self.expr(0)
-                self.state = 143 
+                self.state = 125 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while True:
-                    self.state = 141
-                    self.match(RelayParser.T__5)
-                    self.state = 142
+                    self.state = 123
+                    self.match(RelayParser.T__2)
+                    self.state = 124
                     self.expr(0)
-                    self.state = 145 
+                    self.state = 127 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
-                    if not (_la==RelayParser.T__5):
+                    if not (_la==RelayParser.T__2):
                         break
 
-                self.state = 147
-                self.match(RelayParser.T__7)
+                self.state = 129
+                self.match(RelayParser.T__4)
                 pass
 
             elif la_ == 8:
                 localctx = RelayParser.TensorContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 149
-                self.match(RelayParser.T__2)
-                self.state = 158
+                self.state = 131
+                self.match(RelayParser.T__8)
+                self.state = 140
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__0) | (1 << RelayParser.T__1) | (1 << RelayParser.T__2) | (1 << RelayParser.T__6) | (1 << RelayParser.T__8) | (1 << RelayParser.T__11) | (1 << RelayParser.T__13) | (1 << RelayParser.T__17) | (1 << RelayParser.T__25) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
-                    self.state = 150
+                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__0) | (1 << RelayParser.T__1) | (1 << RelayParser.T__3) | (1 << RelayParser.T__5) | (1 << RelayParser.T__8) | (1 << RelayParser.T__10) | (1 << RelayParser.T__12) | (1 << RelayParser.T__16) | (1 << RelayParser.T__22) | (1 << RelayParser.T__23) | (1 << RelayParser.T__24) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
+                    self.state = 132
                     self.expr(0)
-                    self.state = 155
+                    self.state = 137
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
-                    while _la==RelayParser.T__5:
-                        self.state = 151
-                        self.match(RelayParser.T__5)
-                        self.state = 152
+                    while _la==RelayParser.T__2:
+                        self.state = 133
+                        self.match(RelayParser.T__2)
+                        self.state = 134
                         self.expr(0)
-                        self.state = 157
+                        self.state = 139
                         self._errHandler.sync(self)
                         _la = self._input.LA(1)
 
 
 
-                self.state = 160
-                self.match(RelayParser.T__4)
+                self.state = 142
+                self.match(RelayParser.T__9)
                 pass
 
             elif la_ == 9:
                 localctx = RelayParser.IfElseContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 161
-                self.match(RelayParser.T__11)
-                self.state = 162
-                self.match(RelayParser.T__6)
-                self.state = 163
+                self.state = 143
+                self.match(RelayParser.T__10)
+                self.state = 144
+                self.match(RelayParser.T__3)
+                self.state = 145
                 self.expr(0)
-                self.state = 164
-                self.match(RelayParser.T__7)
-                self.state = 165
+                self.state = 146
+                self.match(RelayParser.T__4)
+                self.state = 147
                 self.body()
-                self.state = 166
-                self.match(RelayParser.T__12)
-                self.state = 167
+                self.state = 148
+                self.match(RelayParser.T__11)
+                self.state = 149
                 self.body()
                 pass
 
@@ -1341,17 +1254,17 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.LetContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 169
-                self.match(RelayParser.T__13)
-                self.state = 170
+                self.state = 151
+                self.match(RelayParser.T__12)
+                self.state = 152
                 self.var()
-                self.state = 171
-                self.match(RelayParser.T__14)
-                self.state = 172
+                self.state = 153
+                self.match(RelayParser.T__13)
+                self.state = 154
                 self.expr(0)
-                self.state = 173
-                self.match(RelayParser.T__15)
-                self.state = 174
+                self.state = 155
+                self.match(RelayParser.T__14)
+                self.state = 156
                 self.expr(7)
                 pass
 
@@ -1359,15 +1272,15 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.GraphContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 176
+                self.state = 158
                 self.graphVar()
-                self.state = 177
-                self.match(RelayParser.T__14)
-                self.state = 178
+                self.state = 159
+                self.match(RelayParser.T__13)
+                self.state = 160
                 self.expr(0)
-                self.state = 179
-                self.match(RelayParser.T__15)
-                self.state = 180
+                self.state = 161
+                self.match(RelayParser.T__14)
+                self.state = 162
                 self.expr(5)
                 pass
 
@@ -1375,7 +1288,7 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.IdentExprContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 182
+                self.state = 164
                 self.ident()
                 pass
 
@@ -1383,7 +1296,7 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.ScalarExprContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 183
+                self.state = 165
                 self.scalar()
                 pass
 
@@ -1391,7 +1304,7 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.MetaExprContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 184
+                self.state = 166
                 self.meta()
                 pass
 
@@ -1399,31 +1312,31 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.StringExprContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 185
+                self.state = 167
                 self.match(RelayParser.QUOTED_STRING)
                 pass
 
 
             self._ctx.stop = self._input.LT(-1)
-            self.state = 213
+            self.state = 195
             self._errHandler.sync(self)
-            _alt = self._interp.adaptivePredict(self._input,14,self._ctx)
+            _alt = self._interp.adaptivePredict(self._input,12,self._ctx)
             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                 if _alt==1:
                     if self._parseListeners is not None:
                         self.triggerExitRuleEvent()
                     _prevctx = localctx
-                    self.state = 211
+                    self.state = 193
                     self._errHandler.sync(self)
-                    la_ = self._interp.adaptivePredict(self._input,13,self._ctx)
+                    la_ = self._interp.adaptivePredict(self._input,11,self._ctx)
                     if la_ == 1:
                         localctx = RelayParser.BinOpContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 188
+                        self.state = 170
                         if not self.precpred(self._ctx, 18):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 18)")
-                        self.state = 189
+                        self.state = 171
                         localctx.op = self._input.LT(1)
                         _la = self._input.LA(1)
                         if not(_la==RelayParser.MUL or _la==RelayParser.DIV):
@@ -1431,18 +1344,18 @@ def expr(self, _p:int=0):
                         else:
                             self._errHandler.reportMatch(self)
                             self.consume()
-                        self.state = 190
+                        self.state = 172
                         self.expr(19)
                         pass
 
                     elif la_ == 2:
                         localctx = RelayParser.BinOpContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 191
+                        self.state = 173
                         if not self.precpred(self._ctx, 17):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 17)")
-                        self.state = 192
+                        self.state = 174
                         localctx.op = self._input.LT(1)
                         _la = self._input.LA(1)
                         if not(_la==RelayParser.ADD or _la==RelayParser.SUB):
@@ -1450,18 +1363,18 @@ def expr(self, _p:int=0):
                         else:
                             self._errHandler.reportMatch(self)
                             self.consume()
-                        self.state = 193
+                        self.state = 175
                         self.expr(18)
                         pass
 
                     elif la_ == 3:
                         localctx = RelayParser.BinOpContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 194
+                        self.state = 176
                         if not self.precpred(self._ctx, 16):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 16)")
-                        self.state = 195
+                        self.state = 177
                         localctx.op = self._input.LT(1)
                         _la = self._input.LA(1)
                         if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.LT) | (1 << RelayParser.GT) | (1 << RelayParser.LE) | (1 << RelayParser.GE))) != 0)):
@@ -1469,18 +1382,18 @@ def expr(self, _p:int=0):
                         else:
                             self._errHandler.reportMatch(self)
                             self.consume()
-                        self.state = 196
+                        self.state = 178
                         self.expr(17)
                         pass
 
                     elif la_ == 4:
                         localctx = RelayParser.BinOpContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 197
+                        self.state = 179
                         if not self.precpred(self._ctx, 15):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 15)")
-                        self.state = 198
+                        self.state = 180
                         localctx.op = self._input.LT(1)
                         _la = self._input.LA(1)
                         if not(_la==RelayParser.EQ or _la==RelayParser.NE):
@@ -1488,55 +1401,55 @@ def expr(self, _p:int=0):
                         else:
                             self._errHandler.reportMatch(self)
                             self.consume()
-                        self.state = 199
+                        self.state = 181
                         self.expr(16)
                         pass
 
                     elif la_ == 5:
                         localctx = RelayParser.LetContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 200
+                        self.state = 182
                         if not self.precpred(self._ctx, 6):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
-                        self.state = 201
-                        self.match(RelayParser.T__16)
-                        self.state = 202
+                        self.state = 183
+                        self.match(RelayParser.T__15)
+                        self.state = 184
                         self.expr(7)
                         pass
 
                     elif la_ == 6:
                         localctx = RelayParser.CallContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 203
+                        self.state = 185
                         if not self.precpred(self._ctx, 20):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 20)")
-                        self.state = 204
-                        self.match(RelayParser.T__6)
-                        self.state = 205
+                        self.state = 186
+                        self.match(RelayParser.T__3)
+                        self.state = 187
                         self.callList()
-                        self.state = 206
-                        self.match(RelayParser.T__7)
+                        self.state = 188
+                        self.match(RelayParser.T__4)
                         pass
 
                     elif la_ == 7:
                         localctx = RelayParser.ProjectionContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 208
+                        self.state = 190
                         if not self.precpred(self._ctx, 10):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 10)")
-                        self.state = 209
-                        self.match(RelayParser.T__10)
-                        self.state = 210
+                        self.state = 191
+                        self.match(RelayParser.T__7)
+                        self.state = 192
                         self.match(RelayParser.NAT)
                         pass
 
              
-                self.state = 215
+                self.state = 197
                 self._errHandler.sync(self)
-                _alt = self._interp.adaptivePredict(self._input,14,self._ctx)
+                _alt = self._interp.adaptivePredict(self._input,12,self._ctx)
 
         except RecognitionException as re:
             localctx.exception = re
@@ -1565,8 +1478,8 @@ def typeParamList(self):
             return self.getTypedRuleContext(RelayParser.TypeParamListContext,0)
 
 
-        def type_(self):
-            return self.getTypedRuleContext(RelayParser.Type_Context,0)
+        def typeExpr(self):
+            return self.getTypedRuleContext(RelayParser.TypeExprContext,0)
 
 
         def getRuleIndex(self):
@@ -1584,37 +1497,37 @@ def accept(self, visitor:ParseTreeVisitor):
     def func(self):
 
         localctx = RelayParser.FuncContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 20, self.RULE_func)
+        self.enterRule(localctx, 18, self.RULE_func)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 216
-            self.match(RelayParser.T__17)
-            self.state = 218
+            self.state = 198
+            self.match(RelayParser.T__16)
+            self.state = 200
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==RelayParser.T__2:
-                self.state = 217
+            if _la==RelayParser.T__8:
+                self.state = 199
                 self.typeParamList()
 
 
-            self.state = 220
-            self.match(RelayParser.T__6)
-            self.state = 221
+            self.state = 202
+            self.match(RelayParser.T__3)
+            self.state = 203
             self.argList()
-            self.state = 222
-            self.match(RelayParser.T__7)
-            self.state = 225
+            self.state = 204
+            self.match(RelayParser.T__4)
+            self.state = 207
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==RelayParser.T__18:
-                self.state = 223
-                self.match(RelayParser.T__18)
-                self.state = 224
-                self.type_()
+            if _la==RelayParser.T__17:
+                self.state = 205
+                self.match(RelayParser.T__17)
+                self.state = 206
+                self.typeExpr()
 
 
-            self.state = 227
+            self.state = 209
             self.body()
         except RecognitionException as re:
             localctx.exception = re
@@ -1659,8 +1572,8 @@ def body(self):
         def typeParamList(self):
             return self.getTypedRuleContext(RelayParser.TypeParamListContext,0)
 
-        def type_(self):
-            return self.getTypedRuleContext(RelayParser.Type_Context,0)
+        def typeExpr(self):
+            return self.getTypedRuleContext(RelayParser.TypeExprContext,0)
 
 
         def accept(self, visitor:ParseTreeVisitor):
@@ -1676,8 +1589,11 @@ def __init__(self, parser, ctx:ParserRuleContext): # actually a RelayParser.Defn
             super().__init__(parser)
             self.copyFrom(ctx)
 
-        def globalTypeVar(self):
-            return self.getTypedRuleContext(RelayParser.GlobalTypeVarContext,0)
+        def typeIdent(self):
+            return self.getTypedRuleContext(RelayParser.TypeIdentContext,0)
+
+        def typeParamList(self):
+            return self.getTypedRuleContext(RelayParser.TypeParamListContext,0)
 
         def adtVariant(self, i:int=None):
             if i is None:
@@ -1697,65 +1613,73 @@ def accept(self, visitor:ParseTreeVisitor):
     def defn(self):
 
         localctx = RelayParser.DefnContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 22, self.RULE_defn)
+        self.enterRule(localctx, 20, self.RULE_defn)
         self._la = 0 # Token type
         try:
-            self.state = 251
+            self.state = 236
             self._errHandler.sync(self)
             token = self._input.LA(1)
-            if token in [RelayParser.T__19]:
+            if token in [RelayParser.T__18]:
                 localctx = RelayParser.FuncDefnContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 229
-                self.match(RelayParser.T__19)
-                self.state = 230
+                self.state = 211
+                self.match(RelayParser.T__18)
+                self.state = 212
                 self.globalVar()
-                self.state = 232
+                self.state = 214
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if _la==RelayParser.T__2:
-                    self.state = 231
+                if _la==RelayParser.T__8:
+                    self.state = 213
                     self.typeParamList()
 
 
-                self.state = 234
-                self.match(RelayParser.T__6)
-                self.state = 235
+                self.state = 216
+                self.match(RelayParser.T__3)
+                self.state = 217
                 self.argList()
-                self.state = 236
-                self.match(RelayParser.T__7)
-                self.state = 239
+                self.state = 218
+                self.match(RelayParser.T__4)
+                self.state = 221
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if _la==RelayParser.T__18:
-                    self.state = 237
-                    self.match(RelayParser.T__18)
-                    self.state = 238
-                    self.type_()
+                if _la==RelayParser.T__17:
+                    self.state = 219
+                    self.match(RelayParser.T__17)
+                    self.state = 220
+                    self.typeExpr()
 
 
-                self.state = 241
+                self.state = 223
                 self.body()
                 pass
-            elif token in [RelayParser.T__20]:
+            elif token in [RelayParser.T__19]:
                 localctx = RelayParser.AdtDefnContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 243
-                self.match(RelayParser.T__20)
-                self.state = 244
-                self.globalTypeVar()
-                self.state = 245
-                self.match(RelayParser.T__14)
-                self.state = 247 
+                self.state = 225
+                self.match(RelayParser.T__19)
+                self.state = 226
+                self.typeIdent()
+                self.state = 228
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                if _la==RelayParser.T__8:
+                    self.state = 227
+                    self.typeParamList()
+
+
+                self.state = 230
+                self.match(RelayParser.T__13)
+                self.state = 232 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while True:
-                    self.state = 246
+                    self.state = 231
                     self.adtVariant()
-                    self.state = 249 
+                    self.state = 234 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
-                    if not (_la==RelayParser.T__21):
+                    if not (_la==RelayParser.T__20):
                         break
 
                 pass
@@ -1781,11 +1705,11 @@ def variantName(self):
             return self.getTypedRuleContext(RelayParser.VariantNameContext,0)
 
 
-        def type_(self, i:int=None):
+        def typeExpr(self, i:int=None):
             if i is None:
-                return self.getTypedRuleContexts(RelayParser.Type_Context)
+                return self.getTypedRuleContexts(RelayParser.TypeExprContext)
             else:
-                return self.getTypedRuleContext(RelayParser.Type_Context,i)
+                return self.getTypedRuleContext(RelayParser.TypeExprContext,i)
 
 
         def getRuleIndex(self):
@@ -1803,36 +1727,36 @@ def accept(self, visitor:ParseTreeVisitor):
     def adtVariant(self):
 
         localctx = RelayParser.AdtVariantContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 24, self.RULE_adtVariant)
+        self.enterRule(localctx, 22, self.RULE_adtVariant)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 253
-            self.match(RelayParser.T__21)
-            self.state = 254
+            self.state = 238
+            self.match(RelayParser.T__20)
+            self.state = 239
             self.variantName()
-            self.state = 266
+            self.state = 251
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==RelayParser.T__6:
-                self.state = 255
-                self.match(RelayParser.T__6)
-                self.state = 256
-                self.type_()
-                self.state = 261
+            if _la==RelayParser.T__3:
+                self.state = 240
+                self.match(RelayParser.T__3)
+                self.state = 241
+                self.typeExpr()
+                self.state = 246
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                while _la==RelayParser.T__3:
-                    self.state = 257
-                    self.match(RelayParser.T__3)
-                    self.state = 258
-                    self.type_()
-                    self.state = 263
+                while _la==RelayParser.T__2:
+                    self.state = 242
+                    self.match(RelayParser.T__2)
+                    self.state = 243
+                    self.typeExpr()
+                    self.state = 248
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
-                self.state = 264
-                self.match(RelayParser.T__7)
+                self.state = 249
+                self.match(RelayParser.T__4)
 
 
         except RecognitionException as re:
@@ -1868,10 +1792,10 @@ def accept(self, visitor:ParseTreeVisitor):
     def variantName(self):
 
         localctx = RelayParser.VariantNameContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 26, self.RULE_variantName)
+        self.enterRule(localctx, 24, self.RULE_variantName)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 268
+            self.state = 253
             self.match(RelayParser.CNAME)
         except RecognitionException as re:
             localctx.exception = re
@@ -1942,35 +1866,35 @@ def accept(self, visitor:ParseTreeVisitor):
     def argList(self):
 
         localctx = RelayParser.ArgListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 28, self.RULE_argList)
+        self.enterRule(localctx, 26, self.RULE_argList)
         self._la = 0 # Token type
         try:
-            self.state = 280
+            self.state = 265
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,24,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,23,self._ctx)
             if la_ == 1:
                 localctx = RelayParser.ArgNoAttrContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 270
+                self.state = 255
                 self.varList()
                 pass
 
             elif la_ == 2:
                 localctx = RelayParser.ArgWithAttrContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 276
+                self.state = 261
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while _la==RelayParser.T__1:
-                    self.state = 271
+                    self.state = 256
                     self.var()
-                    self.state = 272
-                    self.match(RelayParser.T__5)
-                    self.state = 278
+                    self.state = 257
+                    self.match(RelayParser.T__2)
+                    self.state = 263
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
-                self.state = 279
+                self.state = 264
                 self.attrSeq()
                 pass
 
@@ -2012,25 +1936,25 @@ def accept(self, visitor:ParseTreeVisitor):
     def varList(self):
 
         localctx = RelayParser.VarListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 30, self.RULE_varList)
+        self.enterRule(localctx, 28, self.RULE_varList)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 290
+            self.state = 275
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==RelayParser.T__1:
-                self.state = 282
+                self.state = 267
                 self.var()
-                self.state = 287
+                self.state = 272
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                while _la==RelayParser.T__5:
-                    self.state = 283
-                    self.match(RelayParser.T__5)
-                    self.state = 284
+                while _la==RelayParser.T__2:
+                    self.state = 268
+                    self.match(RelayParser.T__2)
+                    self.state = 269
                     self.var()
-                    self.state = 289
+                    self.state = 274
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
@@ -2055,8 +1979,8 @@ def localVar(self):
             return self.getTypedRuleContext(RelayParser.LocalVarContext,0)
 
 
-        def type_(self):
-            return self.getTypedRuleContext(RelayParser.Type_Context,0)
+        def typeExpr(self):
+            return self.getTypedRuleContext(RelayParser.TypeExprContext,0)
 
 
         def getRuleIndex(self):
@@ -2074,20 +1998,20 @@ def accept(self, visitor:ParseTreeVisitor):
     def var(self):
 
         localctx = RelayParser.VarContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 32, self.RULE_var)
+        self.enterRule(localctx, 30, self.RULE_var)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 292
+            self.state = 277
             self.localVar()
-            self.state = 295
+            self.state = 280
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==RelayParser.T__22:
-                self.state = 293
-                self.match(RelayParser.T__22)
-                self.state = 294
-                self.type_()
+            if _la==RelayParser.T__21:
+                self.state = 278
+                self.match(RelayParser.T__21)
+                self.state = 279
+                self.typeExpr()
 
 
         except RecognitionException as re:
@@ -2127,21 +2051,21 @@ def accept(self, visitor:ParseTreeVisitor):
     def attrSeq(self):
 
         localctx = RelayParser.AttrSeqContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 34, self.RULE_attrSeq)
+        self.enterRule(localctx, 32, self.RULE_attrSeq)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 297
+            self.state = 282
             self.attr()
-            self.state = 302
+            self.state = 287
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            while _la==RelayParser.T__5:
-                self.state = 298
-                self.match(RelayParser.T__5)
-                self.state = 299
+            while _la==RelayParser.T__2:
+                self.state = 283
+                self.match(RelayParser.T__2)
+                self.state = 284
                 self.attr()
-                self.state = 304
+                self.state = 289
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
@@ -2182,14 +2106,14 @@ def accept(self, visitor:ParseTreeVisitor):
     def attr(self):
 
         localctx = RelayParser.AttrContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 36, self.RULE_attr)
+        self.enterRule(localctx, 34, self.RULE_attr)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 305
+            self.state = 290
             self.match(RelayParser.CNAME)
-            self.state = 306
-            self.match(RelayParser.T__14)
-            self.state = 307
+            self.state = 291
+            self.match(RelayParser.T__13)
+            self.state = 292
             self.expr(0)
         except RecognitionException as re:
             localctx.exception = re
@@ -2200,89 +2124,15 @@ def attr(self):
         return localctx
 
 
-    class TypeParamListContext(ParserRuleContext):
+    class TypeExprContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
             super().__init__(parent, invokingState)
             self.parser = parser
 
-        def ident(self, i:int=None):
-            if i is None:
-                return self.getTypedRuleContexts(RelayParser.IdentContext)
-            else:
-                return self.getTypedRuleContext(RelayParser.IdentContext,i)
-
 
         def getRuleIndex(self):
-            return RelayParser.RULE_typeParamList
-
-        def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitTypeParamList" ):
-                return visitor.visitTypeParamList(self)
-            else:
-                return visitor.visitChildren(self)
-
-
-
-
-    def typeParamList(self):
-
-        localctx = RelayParser.TypeParamListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 38, self.RULE_typeParamList)
-        self._la = 0 # Token type
-        try:
-            self.state = 322
-            self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,30,self._ctx)
-            if la_ == 1:
-                self.enterOuterAlt(localctx, 1)
-                self.state = 309
-                self.match(RelayParser.T__2)
-                self.state = 310
-                self.match(RelayParser.T__4)
-                pass
-
-            elif la_ == 2:
-                self.enterOuterAlt(localctx, 2)
-                self.state = 311
-                self.match(RelayParser.T__2)
-                self.state = 312
-                self.ident()
-                self.state = 317
-                self._errHandler.sync(self)
-                _la = self._input.LA(1)
-                while _la==RelayParser.T__5:
-                    self.state = 313
-                    self.match(RelayParser.T__5)
-                    self.state = 314
-                    self.ident()
-                    self.state = 319
-                    self._errHandler.sync(self)
-                    _la = self._input.LA(1)
-
-                self.state = 320
-                self.match(RelayParser.T__4)
-                pass
-
-
-        except RecognitionException as re:
-            localctx.exception = re
-            self._errHandler.reportError(self, re)
-            self._errHandler.recover(self, re)
-        finally:
-            self.exitRule()
-        return localctx
-
-
-    class Type_Context(ParserRuleContext):
-
-        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
-            super().__init__(parent, invokingState)
-            self.parser = parser
-
-
-        def getRuleIndex(self):
-            return RelayParser.RULE_type_
+            return RelayParser.RULE_typeExpr
 
      
         def copyFrom(self, ctx:ParserRuleContext):
@@ -2290,9 +2140,9 @@ def copyFrom(self, ctx:ParserRuleContext):
 
 
 
-    class IntTypeContext(Type_Context):
+    class IntTypeContext(TypeExprContext):
 
-        def __init__(self, parser, ctx:ParserRuleContext): # actually a RelayParser.Type_Context
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a RelayParser.TypeExprContext
             super().__init__(parser)
             self.copyFrom(ctx)
 
@@ -2306,17 +2156,17 @@ def accept(self, visitor:ParseTreeVisitor):
                 return visitor.visitChildren(self)
 
 
-    class TupleTypeContext(Type_Context):
+    class TupleTypeContext(TypeExprContext):
 
-        def __init__(self, parser, ctx:ParserRuleContext): # actually a RelayParser.Type_Context
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a RelayParser.TypeExprContext
             super().__init__(parser)
             self.copyFrom(ctx)
 
-        def type_(self, i:int=None):
+        def typeExpr(self, i:int=None):
             if i is None:
-                return self.getTypedRuleContexts(RelayParser.Type_Context)
+                return self.getTypedRuleContexts(RelayParser.TypeExprContext)
             else:
-                return self.getTypedRuleContext(RelayParser.Type_Context,i)
+                return self.getTypedRuleContext(RelayParser.TypeExprContext,i)
 
 
         def accept(self, visitor:ParseTreeVisitor):
@@ -2326,26 +2176,46 @@ def accept(self, visitor:ParseTreeVisitor):
                 return visitor.visitChildren(self)
 
 
-    class GlobalTypeVarTypeContext(Type_Context):
+    class TypeCallTypeContext(TypeExprContext):
 
-        def __init__(self, parser, ctx:ParserRuleContext): # actually a RelayParser.Type_Context
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a RelayParser.TypeExprContext
             super().__init__(parser)
             self.copyFrom(ctx)
 
-        def globalTypeVar(self):
-            return self.getTypedRuleContext(RelayParser.GlobalTypeVarContext,0)
+        def typeIdent(self):
+            return self.getTypedRuleContext(RelayParser.TypeIdentContext,0)
+
+        def typeParamList(self):
+            return self.getTypedRuleContext(RelayParser.TypeParamListContext,0)
 
 
         def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitGlobalTypeVarType" ):
-                return visitor.visitGlobalTypeVarType(self)
+            if hasattr( visitor, "visitTypeCallType" ):
+                return visitor.visitTypeCallType(self)
             else:
                 return visitor.visitChildren(self)
 
 
-    class IncompleteTypeContext(Type_Context):
+    class TypeIdentTypeContext(TypeExprContext):
 
-        def __init__(self, parser, ctx:ParserRuleContext): # actually a RelayParser.Type_Context
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a RelayParser.TypeExprContext
+            super().__init__(parser)
+            self.copyFrom(ctx)
+
+        def typeIdent(self):
+            return self.getTypedRuleContext(RelayParser.TypeIdentContext,0)
+
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitTypeIdentType" ):
+                return visitor.visitTypeIdentType(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+    class IncompleteTypeContext(TypeExprContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a RelayParser.TypeExprContext
             super().__init__(parser)
             self.copyFrom(ctx)
 
@@ -2357,17 +2227,17 @@ def accept(self, visitor:ParseTreeVisitor):
                 return visitor.visitChildren(self)
 
 
-    class TensorTypeContext(Type_Context):
+    class TensorTypeContext(TypeExprContext):
 
-        def __init__(self, parser, ctx:ParserRuleContext): # actually a RelayParser.Type_Context
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a RelayParser.TypeExprContext
             super().__init__(parser)
             self.copyFrom(ctx)
 
         def shapeList(self):
             return self.getTypedRuleContext(RelayParser.ShapeListContext,0)
 
-        def type_(self):
-            return self.getTypedRuleContext(RelayParser.Type_Context,0)
+        def typeExpr(self):
+            return self.getTypedRuleContext(RelayParser.TypeExprContext,0)
 
 
         def accept(self, visitor:ParseTreeVisitor):
@@ -2377,17 +2247,17 @@ def accept(self, visitor:ParseTreeVisitor):
                 return visitor.visitChildren(self)
 
 
-    class FuncTypeContext(Type_Context):
+    class FuncTypeContext(TypeExprContext):
 
-        def __init__(self, parser, ctx:ParserRuleContext): # actually a RelayParser.Type_Context
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a RelayParser.TypeExprContext
             super().__init__(parser)
             self.copyFrom(ctx)
 
-        def type_(self, i:int=None):
+        def typeExpr(self, i:int=None):
             if i is None:
-                return self.getTypedRuleContexts(RelayParser.Type_Context)
+                return self.getTypedRuleContexts(RelayParser.TypeExprContext)
             else:
-                return self.getTypedRuleContext(RelayParser.Type_Context,i)
+                return self.getTypedRuleContext(RelayParser.TypeExprContext,i)
 
         def typeParamList(self):
             return self.getTypedRuleContext(RelayParser.TypeParamListContext,0)
@@ -2401,140 +2271,149 @@ def accept(self, visitor:ParseTreeVisitor):
 
 
 
-    def type_(self):
+    def typeExpr(self):
 
-        localctx = RelayParser.Type_Context(self, self._ctx, self.state)
-        self.enterRule(localctx, 40, self.RULE_type_)
+        localctx = RelayParser.TypeExprContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 36, self.RULE_typeExpr)
         self._la = 0 # Token type
         try:
-            self.state = 369
+            self.state = 342
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,32,self._ctx)
             if la_ == 1:
                 localctx = RelayParser.TupleTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 324
-                self.match(RelayParser.T__6)
-                self.state = 325
-                self.match(RelayParser.T__7)
+                self.state = 294
+                self.match(RelayParser.T__3)
+                self.state = 295
+                self.match(RelayParser.T__4)
                 pass
 
             elif la_ == 2:
                 localctx = RelayParser.TupleTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 326
-                self.match(RelayParser.T__6)
-                self.state = 327
-                self.type_()
-                self.state = 328
-                self.match(RelayParser.T__5)
-                self.state = 329
-                self.match(RelayParser.T__7)
+                self.state = 296
+                self.match(RelayParser.T__3)
+                self.state = 297
+                self.typeExpr()
+                self.state = 298
+                self.match(RelayParser.T__2)
+                self.state = 299
+                self.match(RelayParser.T__4)
                 pass
 
             elif la_ == 3:
                 localctx = RelayParser.TupleTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 3)
-                self.state = 331
-                self.match(RelayParser.T__6)
-                self.state = 332
-                self.type_()
-                self.state = 335 
+                self.state = 301
+                self.match(RelayParser.T__3)
+                self.state = 302
+                self.typeExpr()
+                self.state = 305 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while True:
-                    self.state = 333
-                    self.match(RelayParser.T__5)
-                    self.state = 334
-                    self.type_()
-                    self.state = 337 
+                    self.state = 303
+                    self.match(RelayParser.T__2)
+                    self.state = 304
+                    self.typeExpr()
+                    self.state = 307 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
-                    if not (_la==RelayParser.T__5):
+                    if not (_la==RelayParser.T__2):
                         break
 
-                self.state = 339
-                self.match(RelayParser.T__7)
+                self.state = 309
+                self.match(RelayParser.T__4)
                 pass
 
             elif la_ == 4:
-                localctx = RelayParser.GlobalTypeVarTypeContext(self, localctx)
+                localctx = RelayParser.TypeCallTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 4)
-                self.state = 341
-                self.globalTypeVar()
+                self.state = 311
+                self.typeIdent()
+                self.state = 312
+                self.typeParamList()
                 pass
 
             elif la_ == 5:
-                localctx = RelayParser.TensorTypeContext(self, localctx)
+                localctx = RelayParser.TypeIdentTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 5)
-                self.state = 342
-                self.match(RelayParser.T__23)
-                self.state = 343
-                self.match(RelayParser.T__2)
-                self.state = 344
-                self.shapeList()
-                self.state = 345
-                self.match(RelayParser.T__5)
-                self.state = 346
-                self.type_()
-                self.state = 347
-                self.match(RelayParser.T__4)
+                self.state = 314
+                self.typeIdent()
                 pass
 
             elif la_ == 6:
-                localctx = RelayParser.FuncTypeContext(self, localctx)
+                localctx = RelayParser.TensorTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 6)
-                self.state = 349
-                self.match(RelayParser.T__17)
-                self.state = 351
+                self.state = 315
+                self.match(RelayParser.T__22)
+                self.state = 316
+                self.match(RelayParser.T__8)
+                self.state = 317
+                self.shapeList()
+                self.state = 318
+                self.match(RelayParser.T__2)
+                self.state = 319
+                self.typeExpr()
+                self.state = 320
+                self.match(RelayParser.T__9)
+                pass
+
+            elif la_ == 7:
+                localctx = RelayParser.FuncTypeContext(self, localctx)
+                self.enterOuterAlt(localctx, 7)
+                self.state = 322
+                self.match(RelayParser.T__16)
+                self.state = 324
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if _la==RelayParser.T__2:
-                    self.state = 350
+                if _la==RelayParser.T__8:
+                    self.state = 323
                     self.typeParamList()
 
 
-                self.state = 353
-                self.match(RelayParser.T__6)
-                self.state = 362
+                self.state = 326
+                self.match(RelayParser.T__3)
+                self.state = 335
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__6) | (1 << RelayParser.T__17) | (1 << RelayParser.T__23) | (1 << RelayParser.T__24) | (1 << RelayParser.CNAME) | (1 << RelayParser.NAT))) != 0):
-                    self.state = 354
-                    self.type_()
-                    self.state = 359
+                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__3) | (1 << RelayParser.T__16) | (1 << RelayParser.T__22) | (1 << RelayParser.T__23) | (1 << RelayParser.CNAME) | (1 << RelayParser.NAT))) != 0):
+                    self.state = 327
+                    self.typeExpr()
+                    self.state = 332
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
-                    while _la==RelayParser.T__5:
-                        self.state = 355
-                        self.match(RelayParser.T__5)
-                        self.state = 356
-                        self.type_()
-                        self.state = 361
+                    while _la==RelayParser.T__2:
+                        self.state = 328
+                        self.match(RelayParser.T__2)
+                        self.state = 329
+                        self.typeExpr()
+                        self.state = 334
                         self._errHandler.sync(self)
                         _la = self._input.LA(1)
 
 
 
-                self.state = 364
-                self.match(RelayParser.T__7)
-                self.state = 365
-                self.match(RelayParser.T__18)
-                self.state = 366
-                self.type_()
+                self.state = 337
+                self.match(RelayParser.T__4)
+                self.state = 338
+                self.match(RelayParser.T__17)
+                self.state = 339
+                self.typeExpr()
                 pass
 
-            elif la_ == 7:
+            elif la_ == 8:
                 localctx = RelayParser.IncompleteTypeContext(self, localctx)
-                self.enterOuterAlt(localctx, 7)
-                self.state = 367
-                self.match(RelayParser.T__24)
+                self.enterOuterAlt(localctx, 8)
+                self.state = 340
+                self.match(RelayParser.T__23)
                 pass
 
-            elif la_ == 8:
+            elif la_ == 9:
                 localctx = RelayParser.IntTypeContext(self, localctx)
-                self.enterOuterAlt(localctx, 8)
-                self.state = 368
+                self.enterOuterAlt(localctx, 9)
+                self.state = 341
                 self.match(RelayParser.NAT)
                 pass
 
@@ -2548,6 +2427,65 @@ def type_(self):
         return localctx
 
 
+    class TypeParamListContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def typeIdent(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(RelayParser.TypeIdentContext)
+            else:
+                return self.getTypedRuleContext(RelayParser.TypeIdentContext,i)
+
+
+        def getRuleIndex(self):
+            return RelayParser.RULE_typeParamList
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitTypeParamList" ):
+                return visitor.visitTypeParamList(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def typeParamList(self):
+
+        localctx = RelayParser.TypeParamListContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 38, self.RULE_typeParamList)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 344
+            self.match(RelayParser.T__8)
+            self.state = 345
+            self.typeIdent()
+            self.state = 350
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            while _la==RelayParser.T__2:
+                self.state = 346
+                self.match(RelayParser.T__2)
+                self.state = 347
+                self.typeIdent()
+                self.state = 352
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+
+            self.state = 353
+            self.match(RelayParser.T__9)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
     class ShapeListContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
@@ -2576,47 +2514,47 @@ def accept(self, visitor:ParseTreeVisitor):
     def shapeList(self):
 
         localctx = RelayParser.ShapeListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 42, self.RULE_shapeList)
+        self.enterRule(localctx, 40, self.RULE_shapeList)
         self._la = 0 # Token type
         try:
-            self.state = 384
+            self.state = 368
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,37,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
             if la_ == 1:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 371
-                self.match(RelayParser.T__6)
-                self.state = 372
+                self.state = 355
+                self.match(RelayParser.T__3)
+                self.state = 356
                 self.shape()
-                self.state = 375 
+                self.state = 359 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while True:
-                    self.state = 373
-                    self.match(RelayParser.T__5)
-                    self.state = 374
+                    self.state = 357
+                    self.match(RelayParser.T__2)
+                    self.state = 358
                     self.shape()
-                    self.state = 377 
+                    self.state = 361 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
-                    if not (_la==RelayParser.T__5):
+                    if not (_la==RelayParser.T__2):
                         break
 
-                self.state = 379
-                self.match(RelayParser.T__7)
+                self.state = 363
+                self.match(RelayParser.T__4)
                 pass
 
             elif la_ == 2:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 381
-                self.match(RelayParser.T__6)
-                self.state = 382
-                self.match(RelayParser.T__7)
+                self.state = 365
+                self.match(RelayParser.T__3)
+                self.state = 366
+                self.match(RelayParser.T__4)
                 pass
 
             elif la_ == 3:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 383
+                self.state = 367
                 self.shape()
                 pass
 
@@ -2657,23 +2595,23 @@ def accept(self, visitor:ParseTreeVisitor):
     def meta(self):
 
         localctx = RelayParser.MetaContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 44, self.RULE_meta)
+        self.enterRule(localctx, 42, self.RULE_meta)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 386
-            self.match(RelayParser.T__25)
-            self.state = 387
-            self.match(RelayParser.T__2)
-            self.state = 388
+            self.state = 370
+            self.match(RelayParser.T__24)
+            self.state = 371
+            self.match(RelayParser.T__8)
+            self.state = 372
             self.match(RelayParser.CNAME)
-            self.state = 389
-            self.match(RelayParser.T__4)
-            self.state = 390
-            self.match(RelayParser.T__2)
-            self.state = 391
+            self.state = 373
+            self.match(RelayParser.T__9)
+            self.state = 374
+            self.match(RelayParser.T__8)
+            self.state = 375
             self.match(RelayParser.NAT)
-            self.state = 392
-            self.match(RelayParser.T__4)
+            self.state = 376
+            self.match(RelayParser.T__9)
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -2753,31 +2691,31 @@ def accept(self, visitor:ParseTreeVisitor):
     def shape(self):
 
         localctx = RelayParser.ShapeContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 46, self.RULE_shape)
+        self.enterRule(localctx, 44, self.RULE_shape)
         try:
-            self.state = 400
+            self.state = 384
             self._errHandler.sync(self)
             token = self._input.LA(1)
-            if token in [RelayParser.T__25]:
+            if token in [RelayParser.T__24]:
                 localctx = RelayParser.MetaShapeContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 394
+                self.state = 378
                 self.meta()
                 pass
-            elif token in [RelayParser.T__6]:
+            elif token in [RelayParser.T__3]:
                 localctx = RelayParser.ParensShapeContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 395
-                self.match(RelayParser.T__6)
-                self.state = 396
+                self.state = 379
+                self.match(RelayParser.T__3)
+                self.state = 380
                 self.shape()
-                self.state = 397
-                self.match(RelayParser.T__7)
+                self.state = 381
+                self.match(RelayParser.T__4)
                 pass
             elif token in [RelayParser.NAT]:
                 localctx = RelayParser.IntShapeContext(self, localctx)
                 self.enterOuterAlt(localctx, 3)
-                self.state = 399
+                self.state = 383
                 self.match(RelayParser.NAT)
                 pass
             else:
@@ -2792,44 +2730,6 @@ def shape(self):
         return localctx
 
 
-    class TypeIdentContext(ParserRuleContext):
-
-        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
-            super().__init__(parent, invokingState)
-            self.parser = parser
-
-        def CNAME(self):
-            return self.getToken(RelayParser.CNAME, 0)
-
-        def getRuleIndex(self):
-            return RelayParser.RULE_typeIdent
-
-        def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitTypeIdent" ):
-                return visitor.visitTypeIdent(self)
-            else:
-                return visitor.visitChildren(self)
-
-
-
-
-    def typeIdent(self):
-
-        localctx = RelayParser.TypeIdentContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 48, self.RULE_typeIdent)
-        try:
-            self.enterOuterAlt(localctx, 1)
-            self.state = 402
-            self.match(RelayParser.CNAME)
-        except RecognitionException as re:
-            localctx.exception = re
-            self._errHandler.reportError(self, re)
-            self._errHandler.recover(self, re)
-        finally:
-            self.exitRule()
-        return localctx
-
-
     class BodyContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
@@ -2855,15 +2755,15 @@ def accept(self, visitor:ParseTreeVisitor):
     def body(self):
 
         localctx = RelayParser.BodyContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 50, self.RULE_body)
+        self.enterRule(localctx, 46, self.RULE_body)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 404
-            self.match(RelayParser.T__8)
-            self.state = 405
+            self.state = 386
+            self.match(RelayParser.T__5)
+            self.state = 387
             self.expr(0)
-            self.state = 406
-            self.match(RelayParser.T__9)
+            self.state = 388
+            self.match(RelayParser.T__6)
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -2941,27 +2841,27 @@ def accept(self, visitor:ParseTreeVisitor):
     def scalar(self):
 
         localctx = RelayParser.ScalarContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 52, self.RULE_scalar)
+        self.enterRule(localctx, 48, self.RULE_scalar)
         try:
-            self.state = 411
+            self.state = 393
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [RelayParser.FLOAT]:
                 localctx = RelayParser.ScalarFloatContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 408
+                self.state = 390
                 self.match(RelayParser.FLOAT)
                 pass
             elif token in [RelayParser.NAT]:
                 localctx = RelayParser.ScalarIntContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 409
+                self.state = 391
                 self.match(RelayParser.NAT)
                 pass
             elif token in [RelayParser.BOOL_LIT]:
                 localctx = RelayParser.ScalarBoolContext(self, localctx)
                 self.enterOuterAlt(localctx, 3)
-                self.state = 410
+                self.state = 392
                 self.match(RelayParser.BOOL_LIT)
                 pass
             else:
@@ -2994,12 +2894,8 @@ def localVar(self):
             return self.getTypedRuleContext(RelayParser.LocalVarContext,0)
 
 
-        def globalTypeVar(self):
-            return self.getTypedRuleContext(RelayParser.GlobalTypeVarContext,0)
-
-
-        def typeVar(self):
-            return self.getTypedRuleContext(RelayParser.TypeVarContext,0)
+        def typeExpr(self):
+            return self.getTypedRuleContext(RelayParser.TypeExprContext,0)
 
 
         def graphVar(self):
@@ -3021,44 +2917,38 @@ def accept(self, visitor:ParseTreeVisitor):
     def ident(self):
 
         localctx = RelayParser.IdentContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 54, self.RULE_ident)
+        self.enterRule(localctx, 50, self.RULE_ident)
         try:
-            self.state = 419
+            self.state = 400
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,40,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,38,self._ctx)
             if la_ == 1:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 413
+                self.state = 395
                 self.opIdent()
                 pass
 
             elif la_ == 2:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 414
+                self.state = 396
                 self.globalVar()
                 pass
 
             elif la_ == 3:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 415
+                self.state = 397
                 self.localVar()
                 pass
 
             elif la_ == 4:
                 self.enterOuterAlt(localctx, 4)
-                self.state = 416
-                self.globalTypeVar()
+                self.state = 398
+                self.typeExpr()
                 pass
 
             elif la_ == 5:
                 self.enterOuterAlt(localctx, 5)
-                self.state = 417
-                self.typeVar()
-                pass
-
-            elif la_ == 6:
-                self.enterOuterAlt(localctx, 6)
-                self.state = 418
+                self.state = 399
                 self.graphVar()
                 pass
 
@@ -3076,7 +2966,7 @@ def ident(self):
     def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
         if self._predicates == None:
             self._predicates = dict()
-        self._predicates[9] = self.expr_sempred
+        self._predicates[8] = self.expr_sempred
         pred = self._predicates.get(ruleIndex, None)
         if pred is None:
             raise Exception("No predicate with index:" + str(ruleIndex))
diff --git a/python/tvm/relay/grammar/py3/RelayVisitor.py b/python/tvm/relay/grammar/py3/RelayVisitor.py
index ca3a36a9fadf..56817e6f8e66 100644
--- a/python/tvm/relay/grammar/py3/RelayVisitor.py
+++ b/python/tvm/relay/grammar/py3/RelayVisitor.py
@@ -29,13 +29,8 @@ def visitLocalVar(self, ctx:RelayParser.LocalVarContext):
         return self.visitChildren(ctx)
 
 
-    # Visit a parse tree produced by RelayParser#globalTypeVar.
-    def visitGlobalTypeVar(self, ctx:RelayParser.GlobalTypeVarContext):
-        return self.visitChildren(ctx)
-
-
-    # Visit a parse tree produced by RelayParser#typeVar.
-    def visitTypeVar(self, ctx:RelayParser.TypeVarContext):
+    # Visit a parse tree produced by RelayParser#typeIdent.
+    def visitTypeIdent(self, ctx:RelayParser.TypeIdentContext):
         return self.visitChildren(ctx)
 
 
@@ -189,18 +184,18 @@ def visitAttr(self, ctx:RelayParser.AttrContext):
         return self.visitChildren(ctx)
 
 
-    # Visit a parse tree produced by RelayParser#typeParamList.
-    def visitTypeParamList(self, ctx:RelayParser.TypeParamListContext):
+    # Visit a parse tree produced by RelayParser#tupleType.
+    def visitTupleType(self, ctx:RelayParser.TupleTypeContext):
         return self.visitChildren(ctx)
 
 
-    # Visit a parse tree produced by RelayParser#tupleType.
-    def visitTupleType(self, ctx:RelayParser.TupleTypeContext):
+    # Visit a parse tree produced by RelayParser#typeCallType.
+    def visitTypeCallType(self, ctx:RelayParser.TypeCallTypeContext):
         return self.visitChildren(ctx)
 
 
-    # Visit a parse tree produced by RelayParser#globalTypeVarType.
-    def visitGlobalTypeVarType(self, ctx:RelayParser.GlobalTypeVarTypeContext):
+    # Visit a parse tree produced by RelayParser#typeIdentType.
+    def visitTypeIdentType(self, ctx:RelayParser.TypeIdentTypeContext):
         return self.visitChildren(ctx)
 
 
@@ -224,6 +219,11 @@ def visitIntType(self, ctx:RelayParser.IntTypeContext):
         return self.visitChildren(ctx)
 
 
+    # Visit a parse tree produced by RelayParser#typeParamList.
+    def visitTypeParamList(self, ctx:RelayParser.TypeParamListContext):
+        return self.visitChildren(ctx)
+
+
     # Visit a parse tree produced by RelayParser#shapeList.
     def visitShapeList(self, ctx:RelayParser.ShapeListContext):
         return self.visitChildren(ctx)
@@ -249,11 +249,6 @@ def visitIntShape(self, ctx:RelayParser.IntShapeContext):
         return self.visitChildren(ctx)
 
 
-    # Visit a parse tree produced by RelayParser#typeIdent.
-    def visitTypeIdent(self, ctx:RelayParser.TypeIdentContext):
-        return self.visitChildren(ctx)
-
-
     # Visit a parse tree produced by RelayParser#body.
     def visitBody(self, ctx:RelayParser.BodyContext):
         return self.visitChildren(ctx)
diff --git a/src/relay/ir/alpha_equal.cc b/src/relay/ir/alpha_equal.cc
index b4ef7a5ebf03..06a94f17623b 100644
--- a/src/relay/ir/alpha_equal.cc
+++ b/src/relay/ir/alpha_equal.cc
@@ -218,7 +218,8 @@ class AlphaEqualHandler:
   bool VisitType_(const TypeVarNode* lhs, const Type& other) final {
     if (const TypeVarNode* rhs = other.as<TypeVarNode>()) {
       if (lhs->kind != rhs->kind) return false;
-      return LeafNodeEqual(GetRef<NodeRef>(lhs), other);
+      // return LeafNodeEqual(GetRef<NodeRef>(lhs), other);
+      return lhs->var->name_hint == rhs->var->name_hint;
     } else {
       return false;
     }
diff --git a/src/relay/ir/pretty_printer.cc b/src/relay/ir/pretty_printer.cc
index e95052d265b7..5a6551c26aaf 100644
--- a/src/relay/ir/pretty_printer.cc
+++ b/src/relay/ir/pretty_printer.cc
@@ -313,7 +313,7 @@ class PrettyPrinter :
     if (name.length() == 0 || !std::isalpha(name[0])) {
       name = "t" + name;
     }
-    Doc val = GetUniqueName("%" + name);
+    Doc val = GetUniqueName(name);
     memo_type_[var] = val;
     if (var->kind != kType) {
       val << ": " << Print(var->kind);
diff --git a/tests/python/relay/test_ir_parser.py b/tests/python/relay/test_ir_parser.py
index 937b0590c05c..7e33a817925e 100644
--- a/tests/python/relay/test_ir_parser.py
+++ b/tests/python/relay/test_ir_parser.py
@@ -66,11 +66,7 @@ def roundtrip(expr):
 
 
 def parse_text(code):
-    print('original is:')
-    print(SEMVER + "\n" + code)
     expr = relay.fromtext(SEMVER + "\n" + code)
-    print('pretty printed is:')
-    print(str(expr))
     roundtrip(expr)
     return expr
 
@@ -78,9 +74,7 @@ def parse_text(code):
 def parses_as(code, expr):
     # type: (str, relay.Expr) -> bool
     parsed = parse_text(code)
-    print('biz')
     result = alpha_equal(parsed, expr)
-    print('fiz')
     return result
 
 def get_scalar(x):
@@ -681,7 +675,7 @@ def test_multiple_variants():
 
 
 def test_multiple_type_params():
-    glob_typ_var = relay.GlobalTypeVar("list")
+    glob_typ_var = relay.GlobalTypeVar("Either")
     typ_var_a = relay.TypeVar("A")
     typ_var_b = relay.TypeVar("B")
     prog = relay.TypeData(
@@ -726,6 +720,6 @@ def test_multiple_type_params():
     # test_tensor_type()
     # test_function_type()
     # test_tuple_type()
-    # test_adt_defn()
-    # test_multiple_variants()
+    test_adt_defn()
+    test_multiple_variants()
     test_multiple_type_params()
diff --git a/tests/python/relay/test_ir_text_printer.py b/tests/python/relay/test_ir_text_printer.py
index 7c1ff13f1184..d4d6c8a0688d 100644
--- a/tests/python/relay/test_ir_text_printer.py
+++ b/tests/python/relay/test_ir_text_printer.py
@@ -229,10 +229,10 @@ def test_zeros():
     show(astext(x))
 
 def test_adt_defn():
-    adt_var = GlobalTypeVar("list")
-    a = TypeVar("a")
-    nil_cons = Constructor("nil", [], adt_var)
-    cons_cons = Constructor("cons", [a, adt_var(a)], adt_var)
+    adt_var = GlobalTypeVar("List")
+    a = TypeVar("A")
+    nil_cons = Constructor("Nil", [], adt_var)
+    cons_cons = Constructor("Cons", [a, adt_var(a)], adt_var)
     list_adt = TypeData(adt_var, [a], [nil_cons, cons_cons])
     show(astext(list_adt))
 

From 6df1be34525736285448647883b12a21d8517acf Mon Sep 17 00:00:00 2001
From: Logan Weber <weberlo@cs.washington.edu>
Date: Sun, 25 Aug 2019 15:03:12 -0700
Subject: [PATCH 03/29] Match parsing basipally done

---
 python/tvm/relay/_parser.py                  |  139 +-
 python/tvm/relay/grammar/Relay.g4            |   22 +-
 python/tvm/relay/grammar/py3/RelayLexer.py   |  350 ++--
 python/tvm/relay/grammar/py3/RelayParser.py  | 1499 +++++++++++-------
 python/tvm/relay/grammar/py3/RelayVisitor.py |   38 +-
 tests/python/relay/test_ir_parser.py         |   81 +-
 6 files changed, 1278 insertions(+), 851 deletions(-)

diff --git a/python/tvm/relay/_parser.py b/python/tvm/relay/_parser.py
index 5068388066e0..a5837df0e3f6 100644
--- a/python/tvm/relay/_parser.py
+++ b/python/tvm/relay/_parser.py
@@ -197,6 +197,7 @@ def __init__(self, source_name):
         self.type_param_scopes = deque([deque()])         # type: Scopes[ty.TypeVar]
         self.global_type_param_scope = deque()            # type: Scope[expr.GlobalVar]
         self.graph_expr = []                              # type: List[expr.Expr]
+        self.adts = {}
 
         super(ParseTreeToRelayIR, self).__init__()
 
@@ -211,10 +212,10 @@ def exit_var_scope(self):
         """Pop off the current Var scope and return it."""
         return self.var_scopes.popleft()
 
-    def mk_var(self, name, type_):
+    def mk_var(self, name, typ=None):
         # type: (str, ty.Type) -> expr.Var
         """Create a new Var and add it to the Var scope."""
-        var = expr.Var(name, type_)
+        var = expr.Var(name, typ)
         self.var_scopes[0].appendleft((name, var))
         return var
 
@@ -259,21 +260,6 @@ def visitTerminal(self, node):
         node_text = node.getText()
         name = node_text[1:]
 
-        # variables
-        if node_type == RelayLexer.globalVar:
-            return lookup(deque([self.global_var_scope]), node_text[1:])
-        if node_type == RelayLexer.LOCAL_VAR:
-            # Remove the leading '%' and lookup the name.
-            var = lookup(self.var_scopes, name)
-            if var is None:
-                raise ParseError("Couldn't resolve `{}`.".format(name))
-            return var
-        if node_type == RelayLexer.GRAPH_VAR:
-            try:
-                return self.graph_expr[int(name)]
-            except IndexError:
-                raise ParseError("Couldn't resolve `{}`".format(name))
-
         # data types
         if node_type == RelayLexer.NAT:
             return int(node_text)
@@ -290,6 +276,20 @@ def visitTerminal(self, node):
 
         raise ParseError("todo: `{}`".format(node_text))
 
+    def visitGlobalVar(self, ctx):
+        var_name = ctx.CNAME().getText()
+        global_var = lookup([self.global_var_scope], var_name)
+        if global_var is None:
+            raise ParseError(f'unbound global var "{var_name}""')
+        return global_var
+
+    def visitLocalVar(self, ctx):
+        var_name = ctx.CNAME().getText()
+        local_var = lookup(self.var_scopes, var_name)
+        if local_var is None:
+            raise ParseError(f'unbound local var "{var_name}""')
+        return local_var
+
     def visit_list(self, ctx_list):
         # type: (List[ParserRuleContext]) -> List[Any]
         """"Visit a list of contexts."""
@@ -297,7 +297,7 @@ def visit_list(self, ctx_list):
 
         return [self.visit(ctx) for ctx in ctx_list]
 
-    def getType_(self, ctx):
+    def getTypeExpr(self, ctx):
         # type: (Optional[RelayParser.Type_Context]) -> Optional[ty.Type]
         """Return a (possibly None) Relay type."""
         if ctx is None:
@@ -372,8 +372,8 @@ def visitLet(self, ctx):
         if ctx.var() is None:
             # anonymous identity
             ident = "_"
-            type_ = None
-            var = self.mk_var(ident, type_)
+            typ = None
+            var = self.mk_var(ident, typ)
         else:
             var = self.visitVar(ctx.var())
 
@@ -400,14 +400,14 @@ def visitBinOp(self, ctx):
     def visitVar(self, ctx):
         # type: (RelayParser.VarContext) -> expr.Var
         """Visit a single variable."""
-        ident = ctx.LOCAL_VAR()
+        ident = ctx.localVar()
 
         if ident is None:
             raise ParseError("Only local ids may be used in vars.")
 
-        type_ = self.getType_(ctx.type_())
+        typeExpr = self.getTypeExpr(ctx.typeExpr())
 
-        return self.mk_var(ident.getText()[1:], type_)
+        return self.mk_var(ident.getText()[1:], typeExpr)
 
     def visitVarList(self, ctx):
         # type: (RelayParser.VarListContext) -> List[expr.Var]
@@ -451,7 +451,7 @@ def mk_func(self, ctx):
         type_params = ctx.typeParamList()
 
         if type_params is not None:
-            type_params = type_params.ident()
+            type_params = type_params.typeIdent()
             assert type_params
             for ty_param in type_params:
                 name = ty_param.getText()
@@ -460,7 +460,7 @@ def mk_func(self, ctx):
         var_list, attr_list = self.visit(ctx.argList())
         if var_list is None:
             var_list = []
-        ret_type = self.getType_(ctx.type_())
+        ret_type = self.getTypeExpr(ctx.typeExpr())
 
         body = self.visit(ctx.body())
         # NB(@jroesch): you must stay in the type parameter scope until
@@ -488,45 +488,82 @@ def visitFuncDefn(self, ctx):
         self.module[ident] = self.mk_func(ctx)
 
     def visitAdtDefn(self, ctx):
-        adt_handle = self.mk_global_typ(ctx.typeIdent().getText(), ty.Kind.AdtHandle)
-
+        adt_name = ctx.typeIdent().getText()
+        adt_handle = self.mk_global_typ(adt_name, ty.Kind.AdtHandle)
         self.enter_type_param_scope()
 
+        # parse type params
         type_params = ctx.typeParamList()
         if type_params is None:
             type_params = []
         else:
             type_params = [self.mk_typ(type_ident.getText(), ty.Kind.Type)
                            for type_ident in type_params.typeIdent()]
-        # defn_name = glob_typ_var.children[0].getText()
-        # type_params = []
-
-        # if len(glob_typ_var.children) > 1:
-        #     defn_name = glob_typ_var.children[0].getText()
-        #     type_params = list(
-        #         map(
-        #             lambda s: self.mk_typ(s, ty.Kind.Type),
-        #             filter(
-        #                 lambda s: not s.startswith(','),
-        #                 map(lambda x: x.getText(), glob_typ_var.children[2:-1]))))
-        #     print('TYPE PARAMS')
-        #     import pdb; pdb.set_trace()
-        #     print(glob_typ_var.children[2:-1])
-        #     print(list(map(lambda x: x.getText(), glob_typ_var.children[2:-1])))
-        #     print(filter(
-        #                 lambda s: not s.startswith(','),
-        #                 map(lambda x: x.getText(), glob_typ_var.children[2:-1])))
-        # defn = self.mk_global_typ(defn_name, ty.Kind.AdtHandle)
-
-        constructors = []
-        for constructor in ctx.adtVariant():
+
+        # parse constructors
+        name_to_cons = {}
+        for constructor in ctx.adtConstructor():
             inputs = [self.visit(inp) for inp in constructor.typeExpr()]
-            constructors.append(adt.Constructor(constructor.variantName().getText(), inputs, adt_handle))
+            constructor_name = constructor.constructorName().getText()
+            constructor = adt.Constructor(constructor_name, inputs, adt_handle)
 
-        self.module[adt_handle] = adt.TypeData(adt_handle, type_params, constructors)
+            name_to_cons[constructor_name] = constructor
+
+        # update internal bookkeeping
+        if adt_name in self.adts:
+            raise ParseError(f'duplicate ADT definition "{adt_name}"')
+        self.adts[adt_name] = name_to_cons
+        # update module being built
+        self.module[adt_handle] = adt.TypeData(adt_handle, type_params, list(name_to_cons.values()))
 
         self.exit_type_param_scope()
 
+    def visitMatch(self, ctx):
+        match_type = ctx.matchType().getText()
+        if match_type == 'match':
+            complete_match = True
+        elif match_type == 'match?':
+            complete_match = False
+        else:
+            raise RuntimeError(f"unknown match type {match_type}")
+
+        # TODO: Will need some kind of type checking to know which ADT is being
+        # matched on.
+        match_data = self.visit(ctx.expr())
+        # For now, we'll assume it's an annotated var and just grab its type.
+        constructors = self.adts[match_data.type_annotation.func.var.name]
+        clauses = []
+        for clause in ctx.matchClause():
+            constructor_name = clause.constructorName().getText()
+            constructor = constructors[constructor_name]
+            self.enter_var_scope()
+            patternList = clause.patternList()
+            if patternList is None:
+                patterns = []
+            else:
+                patterns = [self.visit(pattern) for pattern in patternList.pattern()]
+            clause_body = self.visit(clause.expr())
+            self.exit_var_scope()
+            # TODO: Do we need to pass `None` if it's a 0-arity cons, or is an empty list fine?
+            clauses.append(adt.Clause(
+                adt.PatternConstructor(
+                    constructor,
+                    patterns
+                ),
+                clause_body
+            ))
+        return adt.Match(match_data, clauses, complete=complete_match)
+
+    def visitPattern(self, ctx):
+        text = ctx.getText()
+        if text == '_':
+            return adt.PatternWildcard()
+        elif text.startswith('%'):
+            var = self.mk_var(text[1:])
+            return adt.PatternVar(var)
+        else:
+            raise ParseError(f'invalid pattern syntax "{text}"')
+
     def visitTypeExprType(self, ctx):
         import pdb; pdb.set_trace()
         type_params = ctx.typeParams()
diff --git a/python/tvm/relay/grammar/Relay.g4 b/python/tvm/relay/grammar/Relay.g4
index 2eb4c2f9804b..0e0013a8c161 100644
--- a/python/tvm/relay/grammar/Relay.g4
+++ b/python/tvm/relay/grammar/Relay.g4
@@ -104,9 +104,10 @@ expr
   | '(' ')'                                   # tuple
   | '(' expr ',' ')'                          # tuple
   | '(' expr (',' expr)+ ')'                  # tuple
-  | expr '.' NAT                              # projection
   | '[' (expr (',' expr)*)? ']'               # tensor
   | 'if' '(' expr ')' body 'else' body        # ifElse
+  | matchType '(' expr ')' '{' matchClause+ '}'    # match
+  | expr '.' NAT                              # projection
   // sequencing
   | 'let' var '=' expr ';' expr               # let
   // sugar for let %_ = expr; expr
@@ -121,11 +122,21 @@ expr
 func: 'fn'        typeParamList? '(' argList ')' ('->' typeExpr)? body ;
 defn
   : 'def' globalVar typeParamList? '(' argList ')' ('->' typeExpr)? body  # funcDefn
-  | 'type' typeIdent typeParamList? '=' adtVariant+                               # adtDefn
+  | 'type' typeIdent typeParamList? '=' adtConstructor+                               # adtDefn
+  ;
+
+adtConstructor: '|' constructorName ('(' typeExpr (',' typeExpr)* ')')? ;
+matchClause: '|' constructorName patternList? '=>' expr ;
+matchType : 'match' | 'match?' ;
+
+// TODO: Will need to make this recursive
+patternList: '(' pattern (',' pattern)* ')';
+pattern
+  : '_'
+  | localVar
   ;
 
-adtVariant: '|' variantName ('(' typeExpr (',' typeExpr)* ')')? ;
-variantName: CNAME ;
+constructorName: CNAME ;
 
 argList
   : varList              # argNoAttr
@@ -147,7 +158,8 @@ typeExpr
   | 'Tensor' '[' shapeList ',' typeExpr ']'                         # tensorType
   | 'fn' typeParamList? '(' (typeExpr (',' typeExpr)*)? ')' '->' typeExpr # funcType
   | '_'                                                          # incompleteType
-  | NAT                                                          # intType
+  // TODO: Why the fuck does this rule exist?
+  // | NAT                                                          # intType
   ;
 
 // TODO: For some reason, spaces aren't allowed between type params?
diff --git a/python/tvm/relay/grammar/py3/RelayLexer.py b/python/tvm/relay/grammar/py3/RelayLexer.py
index a0d2e90df171..2fe21f1881d3 100644
--- a/python/tvm/relay/grammar/py3/RelayLexer.py
+++ b/python/tvm/relay/grammar/py3/RelayLexer.py
@@ -8,8 +8,8 @@
 
 def serializedATN():
     with StringIO() as buf:
-        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\60")
-        buf.write("\u014e\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7")
+        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\63")
+        buf.write("\u0164\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7")
         buf.write("\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r")
         buf.write("\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23")
         buf.write("\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30")
@@ -17,141 +17,150 @@ def serializedATN():
         buf.write("\t\36\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%")
         buf.write("\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.")
         buf.write("\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64")
-        buf.write("\t\64\3\2\3\2\3\3\3\3\3\4\3\4\3\5\3\5\3\6\3\6\3\7\3\7")
-        buf.write("\3\b\3\b\3\t\3\t\3\n\3\n\3\13\3\13\3\f\3\f\3\f\3\r\3\r")
-        buf.write("\3\r\3\r\3\r\3\16\3\16\3\16\3\16\3\17\3\17\3\20\3\20\3")
-        buf.write("\21\3\21\3\21\3\22\3\22\3\22\3\23\3\23\3\23\3\24\3\24")
-        buf.write("\3\24\3\24\3\25\3\25\3\25\3\25\3\25\3\26\3\26\3\27\3\27")
-        buf.write("\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\31\3\31\3\32\3\32")
-        buf.write("\3\32\3\32\3\32\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\34")
-        buf.write("\3\34\3\34\3\34\3\34\7\34\u00be\n\34\f\34\16\34\u00c1")
-        buf.write("\13\34\3\34\3\34\3\34\3\34\3\34\3\35\6\35\u00c9\n\35\r")
-        buf.write("\35\16\35\u00ca\3\35\3\35\3\36\3\36\3\36\3\36\7\36\u00d3")
-        buf.write("\n\36\f\36\16\36\u00d6\13\36\3\36\3\36\3\36\3\36\3\37")
-        buf.write("\3\37\3\37\3 \3 \3 \7 \u00e2\n \f \16 \u00e5\13 \3 \3")
-        buf.write(" \3!\3!\3\"\3\"\3#\3#\3$\3$\3%\3%\3&\3&\3\'\3\'\3\'\3")
-        buf.write("(\3(\3(\3)\3)\3)\3*\3*\3*\3+\3+\3+\3+\3+\3+\3+\3+\3+\5")
-        buf.write("+\u010a\n+\3,\3,\5,\u010e\n,\3,\3,\3,\7,\u0113\n,\f,\16")
-        buf.write(",\u0116\13,\3,\3,\7,\u011a\n,\f,\16,\u011d\13,\3-\3-\3")
-        buf.write("-\3-\3-\3-\3.\3.\3.\5.\u0128\n.\3.\5.\u012b\n.\3/\3/\3")
-        buf.write("/\3\60\6\60\u0131\n\60\r\60\16\60\u0132\3\61\3\61\5\61")
-        buf.write("\u0137\n\61\3\61\3\61\3\62\3\62\3\63\3\63\3\64\3\64\3")
-        buf.write("\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\3\64\7\64\u014a")
-        buf.write("\n\64\f\64\16\64\u014d\13\64\5\u00bf\u00d4\u00e3\2\65")
-        buf.write("\3\3\5\4\7\5\t\6\13\7\r\b\17\t\21\n\23\13\25\f\27\r\31")
-        buf.write("\16\33\17\35\20\37\21!\22#\23%\24\'\25)\26+\27-\30/\31")
-        buf.write("\61\32\63\33\65\34\67\359\36;\37=\2? A!C\"E#G$I%K&M\'")
-        buf.write("O(Q)S*U+W,Y-[\2]._/a\2c\2e\2g\60\3\2\b\5\2\13\f\17\17")
-        buf.write("\"\"\4\2\f\f\17\17\4\2GGgg\4\2--//\4\2C\\c|\3\2\62;\2")
-        buf.write("\u0159\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3\2\2\2\2\t\3\2\2\2")
-        buf.write("\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2\2")
-        buf.write("\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33")
-        buf.write("\3\2\2\2\2\35\3\2\2\2\2\37\3\2\2\2\2!\3\2\2\2\2#\3\2\2")
-        buf.write("\2\2%\3\2\2\2\2\'\3\2\2\2\2)\3\2\2\2\2+\3\2\2\2\2-\3\2")
-        buf.write("\2\2\2/\3\2\2\2\2\61\3\2\2\2\2\63\3\2\2\2\2\65\3\2\2\2")
-        buf.write("\2\67\3\2\2\2\29\3\2\2\2\2;\3\2\2\2\2?\3\2\2\2\2A\3\2")
-        buf.write("\2\2\2C\3\2\2\2\2E\3\2\2\2\2G\3\2\2\2\2I\3\2\2\2\2K\3")
-        buf.write("\2\2\2\2M\3\2\2\2\2O\3\2\2\2\2Q\3\2\2\2\2S\3\2\2\2\2U")
-        buf.write("\3\2\2\2\2W\3\2\2\2\2Y\3\2\2\2\2]\3\2\2\2\2_\3\2\2\2\2")
-        buf.write("g\3\2\2\2\3i\3\2\2\2\5k\3\2\2\2\7m\3\2\2\2\to\3\2\2\2")
-        buf.write("\13q\3\2\2\2\rs\3\2\2\2\17u\3\2\2\2\21w\3\2\2\2\23y\3")
-        buf.write("\2\2\2\25{\3\2\2\2\27}\3\2\2\2\31\u0080\3\2\2\2\33\u0085")
-        buf.write("\3\2\2\2\35\u0089\3\2\2\2\37\u008b\3\2\2\2!\u008d\3\2")
-        buf.write("\2\2#\u0090\3\2\2\2%\u0093\3\2\2\2\'\u0096\3\2\2\2)\u009a")
-        buf.write("\3\2\2\2+\u009f\3\2\2\2-\u00a1\3\2\2\2/\u00a3\3\2\2\2")
-        buf.write("\61\u00aa\3\2\2\2\63\u00ac\3\2\2\2\65\u00b1\3\2\2\2\67")
-        buf.write("\u00b8\3\2\2\29\u00c8\3\2\2\2;\u00ce\3\2\2\2=\u00db\3")
-        buf.write("\2\2\2?\u00de\3\2\2\2A\u00e8\3\2\2\2C\u00ea\3\2\2\2E\u00ec")
-        buf.write("\3\2\2\2G\u00ee\3\2\2\2I\u00f0\3\2\2\2K\u00f2\3\2\2\2")
-        buf.write("M\u00f4\3\2\2\2O\u00f7\3\2\2\2Q\u00fa\3\2\2\2S\u00fd\3")
-        buf.write("\2\2\2U\u0109\3\2\2\2W\u010d\3\2\2\2Y\u011e\3\2\2\2[\u0124")
-        buf.write("\3\2\2\2]\u012c\3\2\2\2_\u0130\3\2\2\2a\u0134\3\2\2\2")
-        buf.write("c\u013a\3\2\2\2e\u013c\3\2\2\2g\u013e\3\2\2\2ij\7B\2\2")
-        buf.write("j\4\3\2\2\2kl\7\'\2\2l\6\3\2\2\2mn\7.\2\2n\b\3\2\2\2o")
-        buf.write("p\7*\2\2p\n\3\2\2\2qr\7+\2\2r\f\3\2\2\2st\7}\2\2t\16\3")
-        buf.write("\2\2\2uv\7\177\2\2v\20\3\2\2\2wx\7\60\2\2x\22\3\2\2\2")
-        buf.write("yz\7]\2\2z\24\3\2\2\2{|\7_\2\2|\26\3\2\2\2}~\7k\2\2~\177")
-        buf.write("\7h\2\2\177\30\3\2\2\2\u0080\u0081\7g\2\2\u0081\u0082")
-        buf.write("\7n\2\2\u0082\u0083\7u\2\2\u0083\u0084\7g\2\2\u0084\32")
-        buf.write("\3\2\2\2\u0085\u0086\7n\2\2\u0086\u0087\7g\2\2\u0087\u0088")
-        buf.write("\7v\2\2\u0088\34\3\2\2\2\u0089\u008a\7?\2\2\u008a\36\3")
-        buf.write("\2\2\2\u008b\u008c\7=\2\2\u008c \3\2\2\2\u008d\u008e\7")
-        buf.write("=\2\2\u008e\u008f\7=\2\2\u008f\"\3\2\2\2\u0090\u0091\7")
-        buf.write("h\2\2\u0091\u0092\7p\2\2\u0092$\3\2\2\2\u0093\u0094\7")
-        buf.write("/\2\2\u0094\u0095\7@\2\2\u0095&\3\2\2\2\u0096\u0097\7")
-        buf.write("f\2\2\u0097\u0098\7g\2\2\u0098\u0099\7h\2\2\u0099(\3\2")
-        buf.write("\2\2\u009a\u009b\7v\2\2\u009b\u009c\7{\2\2\u009c\u009d")
-        buf.write("\7r\2\2\u009d\u009e\7g\2\2\u009e*\3\2\2\2\u009f\u00a0")
-        buf.write("\7~\2\2\u00a0,\3\2\2\2\u00a1\u00a2\7<\2\2\u00a2.\3\2\2")
-        buf.write("\2\u00a3\u00a4\7V\2\2\u00a4\u00a5\7g\2\2\u00a5\u00a6\7")
-        buf.write("p\2\2\u00a6\u00a7\7u\2\2\u00a7\u00a8\7q\2\2\u00a8\u00a9")
-        buf.write("\7t\2\2\u00a9\60\3\2\2\2\u00aa\u00ab\7a\2\2\u00ab\62\3")
-        buf.write("\2\2\2\u00ac\u00ad\7o\2\2\u00ad\u00ae\7g\2\2\u00ae\u00af")
-        buf.write("\7v\2\2\u00af\u00b0\7c\2\2\u00b0\64\3\2\2\2\u00b1\u00b2")
-        buf.write("\7x\2\2\u00b2\u00b3\7\62\2\2\u00b3\u00b4\7\60\2\2\u00b4")
-        buf.write("\u00b5\7\62\2\2\u00b5\u00b6\7\60\2\2\u00b6\u00b7\7\65")
-        buf.write("\2\2\u00b7\66\3\2\2\2\u00b8\u00b9\7\61\2\2\u00b9\u00ba")
-        buf.write("\7,\2\2\u00ba\u00bf\3\2\2\2\u00bb\u00be\5\67\34\2\u00bc")
-        buf.write("\u00be\13\2\2\2\u00bd\u00bb\3\2\2\2\u00bd\u00bc\3\2\2")
-        buf.write("\2\u00be\u00c1\3\2\2\2\u00bf\u00c0\3\2\2\2\u00bf\u00bd")
-        buf.write("\3\2\2\2\u00c0\u00c2\3\2\2\2\u00c1\u00bf\3\2\2\2\u00c2")
-        buf.write("\u00c3\7,\2\2\u00c3\u00c4\7\61\2\2\u00c4\u00c5\3\2\2\2")
-        buf.write("\u00c5\u00c6\b\34\2\2\u00c68\3\2\2\2\u00c7\u00c9\t\2\2")
-        buf.write("\2\u00c8\u00c7\3\2\2\2\u00c9\u00ca\3\2\2\2\u00ca\u00c8")
-        buf.write("\3\2\2\2\u00ca\u00cb\3\2\2\2\u00cb\u00cc\3\2\2\2\u00cc")
-        buf.write("\u00cd\b\35\2\2\u00cd:\3\2\2\2\u00ce\u00cf\7\61\2\2\u00cf")
-        buf.write("\u00d0\7\61\2\2\u00d0\u00d4\3\2\2\2\u00d1\u00d3\13\2\2")
-        buf.write("\2\u00d2\u00d1\3\2\2\2\u00d3\u00d6\3\2\2\2\u00d4\u00d5")
-        buf.write("\3\2\2\2\u00d4\u00d2\3\2\2\2\u00d5\u00d7\3\2\2\2\u00d6")
-        buf.write("\u00d4\3\2\2\2\u00d7\u00d8\7\f\2\2\u00d8\u00d9\3\2\2\2")
-        buf.write("\u00d9\u00da\b\36\2\2\u00da<\3\2\2\2\u00db\u00dc\7^\2")
-        buf.write("\2\u00dc\u00dd\7$\2\2\u00dd>\3\2\2\2\u00de\u00e3\7$\2")
-        buf.write("\2\u00df\u00e2\5=\37\2\u00e0\u00e2\n\3\2\2\u00e1\u00df")
-        buf.write("\3\2\2\2\u00e1\u00e0\3\2\2\2\u00e2\u00e5\3\2\2\2\u00e3")
-        buf.write("\u00e4\3\2\2\2\u00e3\u00e1\3\2\2\2\u00e4\u00e6\3\2\2\2")
-        buf.write("\u00e5\u00e3\3\2\2\2\u00e6\u00e7\7$\2\2\u00e7@\3\2\2\2")
-        buf.write("\u00e8\u00e9\7,\2\2\u00e9B\3\2\2\2\u00ea\u00eb\7\61\2")
-        buf.write("\2\u00ebD\3\2\2\2\u00ec\u00ed\7-\2\2\u00edF\3\2\2\2\u00ee")
-        buf.write("\u00ef\7/\2\2\u00efH\3\2\2\2\u00f0\u00f1\7>\2\2\u00f1")
-        buf.write("J\3\2\2\2\u00f2\u00f3\7@\2\2\u00f3L\3\2\2\2\u00f4\u00f5")
-        buf.write("\7>\2\2\u00f5\u00f6\7?\2\2\u00f6N\3\2\2\2\u00f7\u00f8")
-        buf.write("\7@\2\2\u00f8\u00f9\7?\2\2\u00f9P\3\2\2\2\u00fa\u00fb")
-        buf.write("\7?\2\2\u00fb\u00fc\7?\2\2\u00fcR\3\2\2\2\u00fd\u00fe")
-        buf.write("\7#\2\2\u00fe\u00ff\7?\2\2\u00ffT\3\2\2\2\u0100\u0101")
-        buf.write("\7V\2\2\u0101\u0102\7t\2\2\u0102\u0103\7w\2\2\u0103\u010a")
-        buf.write("\7g\2\2\u0104\u0105\7H\2\2\u0105\u0106\7c\2\2\u0106\u0107")
-        buf.write("\7n\2\2\u0107\u0108\7u\2\2\u0108\u010a\7g\2\2\u0109\u0100")
-        buf.write("\3\2\2\2\u0109\u0104\3\2\2\2\u010aV\3\2\2\2\u010b\u010e")
-        buf.write("\7a\2\2\u010c\u010e\5c\62\2\u010d\u010b\3\2\2\2\u010d")
-        buf.write("\u010c\3\2\2\2\u010e\u0114\3\2\2\2\u010f\u0113\7a\2\2")
-        buf.write("\u0110\u0113\5c\62\2\u0111\u0113\5e\63\2\u0112\u010f\3")
-        buf.write("\2\2\2\u0112\u0110\3\2\2\2\u0112\u0111\3\2\2\2\u0113\u0116")
-        buf.write("\3\2\2\2\u0114\u0112\3\2\2\2\u0114\u0115\3\2\2\2\u0115")
-        buf.write("\u011b\3\2\2\2\u0116\u0114\3\2\2\2\u0117\u0118\7\60\2")
-        buf.write("\2\u0118\u011a\5W,\2\u0119\u0117\3\2\2\2\u011a\u011d\3")
-        buf.write("\2\2\2\u011b\u0119\3\2\2\2\u011b\u011c\3\2\2\2\u011cX")
-        buf.write("\3\2\2\2\u011d\u011b\3\2\2\2\u011e\u011f\7k\2\2\u011f")
-        buf.write("\u0120\7p\2\2\u0120\u0121\7v\2\2\u0121\u0122\78\2\2\u0122")
-        buf.write("\u0123\7\66\2\2\u0123Z\3\2\2\2\u0124\u0127\5_\60\2\u0125")
-        buf.write("\u0126\7\60\2\2\u0126\u0128\5_\60\2\u0127\u0125\3\2\2")
-        buf.write("\2\u0127\u0128\3\2\2\2\u0128\u012a\3\2\2\2\u0129\u012b")
-        buf.write("\5a\61\2\u012a\u0129\3\2\2\2\u012a\u012b\3\2\2\2\u012b")
-        buf.write("\\\3\2\2\2\u012c\u012d\5[.\2\u012d\u012e\7h\2\2\u012e")
-        buf.write("^\3\2\2\2\u012f\u0131\5e\63\2\u0130\u012f\3\2\2\2\u0131")
-        buf.write("\u0132\3\2\2\2\u0132\u0130\3\2\2\2\u0132\u0133\3\2\2\2")
-        buf.write("\u0133`\3\2\2\2\u0134\u0136\t\4\2\2\u0135\u0137\t\5\2")
-        buf.write("\2\u0136\u0135\3\2\2\2\u0136\u0137\3\2\2\2\u0137\u0138")
-        buf.write("\3\2\2\2\u0138\u0139\5_\60\2\u0139b\3\2\2\2\u013a\u013b")
-        buf.write("\t\6\2\2\u013bd\3\2\2\2\u013c\u013d\t\7\2\2\u013df\3\2")
-        buf.write("\2\2\u013e\u013f\7O\2\2\u013f\u0140\7G\2\2\u0140\u0141")
-        buf.write("\7V\2\2\u0141\u0142\7C\2\2\u0142\u0143\7F\2\2\u0143\u0144")
-        buf.write("\7C\2\2\u0144\u0145\7V\2\2\u0145\u0146\7C\2\2\u0146\u0147")
-        buf.write("\7<\2\2\u0147\u014b\3\2\2\2\u0148\u014a\13\2\2\2\u0149")
-        buf.write("\u0148\3\2\2\2\u014a\u014d\3\2\2\2\u014b\u0149\3\2\2\2")
-        buf.write("\u014b\u014c\3\2\2\2\u014ch\3\2\2\2\u014d\u014b\3\2\2")
-        buf.write("\2\23\2\u00bd\u00bf\u00ca\u00d4\u00e1\u00e3\u0109\u010d")
-        buf.write("\u0112\u0114\u011b\u0127\u012a\u0132\u0136\u014b\3\b\2")
-        buf.write("\2")
+        buf.write("\t\64\4\65\t\65\4\66\t\66\4\67\t\67\3\2\3\2\3\3\3\3\3")
+        buf.write("\4\3\4\3\5\3\5\3\6\3\6\3\7\3\7\3\b\3\b\3\t\3\t\3\n\3\n")
+        buf.write("\3\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\3\r\3\r\3\16\3\16")
+        buf.write("\3\16\3\16\3\17\3\17\3\20\3\20\3\21\3\21\3\21\3\22\3\22")
+        buf.write("\3\22\3\23\3\23\3\23\3\24\3\24\3\24\3\24\3\25\3\25\3\25")
+        buf.write("\3\25\3\25\3\26\3\26\3\27\3\27\3\27\3\30\3\30\3\30\3\30")
+        buf.write("\3\30\3\30\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\32\3\32")
+        buf.write("\3\33\3\33\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\35\3\35")
+        buf.write("\3\35\3\35\3\35\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\37")
+        buf.write("\3\37\3\37\3\37\3\37\7\37\u00d4\n\37\f\37\16\37\u00d7")
+        buf.write("\13\37\3\37\3\37\3\37\3\37\3\37\3 \6 \u00df\n \r \16 ")
+        buf.write("\u00e0\3 \3 \3!\3!\3!\3!\7!\u00e9\n!\f!\16!\u00ec\13!")
+        buf.write("\3!\3!\3!\3!\3\"\3\"\3\"\3#\3#\3#\7#\u00f8\n#\f#\16#\u00fb")
+        buf.write("\13#\3#\3#\3$\3$\3%\3%\3&\3&\3\'\3\'\3(\3(\3)\3)\3*\3")
+        buf.write("*\3*\3+\3+\3+\3,\3,\3,\3-\3-\3-\3.\3.\3.\3.\3.\3.\3.\3")
+        buf.write(".\3.\5.\u0120\n.\3/\3/\5/\u0124\n/\3/\3/\3/\7/\u0129\n")
+        buf.write("/\f/\16/\u012c\13/\3/\3/\7/\u0130\n/\f/\16/\u0133\13/")
+        buf.write("\3\60\3\60\3\60\3\60\3\60\3\60\3\61\3\61\3\61\5\61\u013e")
+        buf.write("\n\61\3\61\5\61\u0141\n\61\3\62\3\62\3\62\3\63\6\63\u0147")
+        buf.write("\n\63\r\63\16\63\u0148\3\64\3\64\5\64\u014d\n\64\3\64")
+        buf.write("\3\64\3\65\3\65\3\66\3\66\3\67\3\67\3\67\3\67\3\67\3\67")
+        buf.write("\3\67\3\67\3\67\3\67\3\67\7\67\u0160\n\67\f\67\16\67\u0163")
+        buf.write("\13\67\5\u00d5\u00ea\u00f9\28\3\3\5\4\7\5\t\6\13\7\r\b")
+        buf.write("\17\t\21\n\23\13\25\f\27\r\31\16\33\17\35\20\37\21!\22")
+        buf.write("#\23%\24\'\25)\26+\27-\30/\31\61\32\63\33\65\34\67\35")
+        buf.write("9\36;\37= ?!A\"C\2E#G$I%K&M\'O(Q)S*U+W,Y-[.]/_\60a\2c")
+        buf.write("\61e\62g\2i\2k\2m\63\3\2\b\5\2\13\f\17\17\"\"\4\2\f\f")
+        buf.write("\17\17\4\2GGgg\4\2--//\4\2C\\c|\3\2\62;\2\u016f\2\3\3")
+        buf.write("\2\2\2\2\5\3\2\2\2\2\7\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2")
+        buf.write("\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2\2")
+        buf.write("\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2\2")
+        buf.write("\35\3\2\2\2\2\37\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2%\3\2")
+        buf.write("\2\2\2\'\3\2\2\2\2)\3\2\2\2\2+\3\2\2\2\2-\3\2\2\2\2/\3")
+        buf.write("\2\2\2\2\61\3\2\2\2\2\63\3\2\2\2\2\65\3\2\2\2\2\67\3\2")
+        buf.write("\2\2\29\3\2\2\2\2;\3\2\2\2\2=\3\2\2\2\2?\3\2\2\2\2A\3")
+        buf.write("\2\2\2\2E\3\2\2\2\2G\3\2\2\2\2I\3\2\2\2\2K\3\2\2\2\2M")
+        buf.write("\3\2\2\2\2O\3\2\2\2\2Q\3\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2")
+        buf.write("W\3\2\2\2\2Y\3\2\2\2\2[\3\2\2\2\2]\3\2\2\2\2_\3\2\2\2")
+        buf.write("\2c\3\2\2\2\2e\3\2\2\2\2m\3\2\2\2\3o\3\2\2\2\5q\3\2\2")
+        buf.write("\2\7s\3\2\2\2\tu\3\2\2\2\13w\3\2\2\2\ry\3\2\2\2\17{\3")
+        buf.write("\2\2\2\21}\3\2\2\2\23\177\3\2\2\2\25\u0081\3\2\2\2\27")
+        buf.write("\u0084\3\2\2\2\31\u0089\3\2\2\2\33\u008b\3\2\2\2\35\u008f")
+        buf.write("\3\2\2\2\37\u0091\3\2\2\2!\u0093\3\2\2\2#\u0096\3\2\2")
+        buf.write("\2%\u0099\3\2\2\2\'\u009c\3\2\2\2)\u00a0\3\2\2\2+\u00a5")
+        buf.write("\3\2\2\2-\u00a7\3\2\2\2/\u00aa\3\2\2\2\61\u00b0\3\2\2")
+        buf.write("\2\63\u00b7\3\2\2\2\65\u00b9\3\2\2\2\67\u00bb\3\2\2\2")
+        buf.write("9\u00c2\3\2\2\2;\u00c7\3\2\2\2=\u00ce\3\2\2\2?\u00de\3")
+        buf.write("\2\2\2A\u00e4\3\2\2\2C\u00f1\3\2\2\2E\u00f4\3\2\2\2G\u00fe")
+        buf.write("\3\2\2\2I\u0100\3\2\2\2K\u0102\3\2\2\2M\u0104\3\2\2\2")
+        buf.write("O\u0106\3\2\2\2Q\u0108\3\2\2\2S\u010a\3\2\2\2U\u010d\3")
+        buf.write("\2\2\2W\u0110\3\2\2\2Y\u0113\3\2\2\2[\u011f\3\2\2\2]\u0123")
+        buf.write("\3\2\2\2_\u0134\3\2\2\2a\u013a\3\2\2\2c\u0142\3\2\2\2")
+        buf.write("e\u0146\3\2\2\2g\u014a\3\2\2\2i\u0150\3\2\2\2k\u0152\3")
+        buf.write("\2\2\2m\u0154\3\2\2\2op\7B\2\2p\4\3\2\2\2qr\7\'\2\2r\6")
+        buf.write("\3\2\2\2st\7.\2\2t\b\3\2\2\2uv\7*\2\2v\n\3\2\2\2wx\7+")
+        buf.write("\2\2x\f\3\2\2\2yz\7}\2\2z\16\3\2\2\2{|\7\177\2\2|\20\3")
+        buf.write("\2\2\2}~\7]\2\2~\22\3\2\2\2\177\u0080\7_\2\2\u0080\24")
+        buf.write("\3\2\2\2\u0081\u0082\7k\2\2\u0082\u0083\7h\2\2\u0083\26")
+        buf.write("\3\2\2\2\u0084\u0085\7g\2\2\u0085\u0086\7n\2\2\u0086\u0087")
+        buf.write("\7u\2\2\u0087\u0088\7g\2\2\u0088\30\3\2\2\2\u0089\u008a")
+        buf.write("\7\60\2\2\u008a\32\3\2\2\2\u008b\u008c\7n\2\2\u008c\u008d")
+        buf.write("\7g\2\2\u008d\u008e\7v\2\2\u008e\34\3\2\2\2\u008f\u0090")
+        buf.write("\7?\2\2\u0090\36\3\2\2\2\u0091\u0092\7=\2\2\u0092 \3\2")
+        buf.write("\2\2\u0093\u0094\7=\2\2\u0094\u0095\7=\2\2\u0095\"\3\2")
+        buf.write("\2\2\u0096\u0097\7h\2\2\u0097\u0098\7p\2\2\u0098$\3\2")
+        buf.write("\2\2\u0099\u009a\7/\2\2\u009a\u009b\7@\2\2\u009b&\3\2")
+        buf.write("\2\2\u009c\u009d\7f\2\2\u009d\u009e\7g\2\2\u009e\u009f")
+        buf.write("\7h\2\2\u009f(\3\2\2\2\u00a0\u00a1\7v\2\2\u00a1\u00a2")
+        buf.write("\7{\2\2\u00a2\u00a3\7r\2\2\u00a3\u00a4\7g\2\2\u00a4*\3")
+        buf.write("\2\2\2\u00a5\u00a6\7~\2\2\u00a6,\3\2\2\2\u00a7\u00a8\7")
+        buf.write("?\2\2\u00a8\u00a9\7@\2\2\u00a9.\3\2\2\2\u00aa\u00ab\7")
+        buf.write("o\2\2\u00ab\u00ac\7c\2\2\u00ac\u00ad\7v\2\2\u00ad\u00ae")
+        buf.write("\7e\2\2\u00ae\u00af\7j\2\2\u00af\60\3\2\2\2\u00b0\u00b1")
+        buf.write("\7o\2\2\u00b1\u00b2\7c\2\2\u00b2\u00b3\7v\2\2\u00b3\u00b4")
+        buf.write("\7e\2\2\u00b4\u00b5\7j\2\2\u00b5\u00b6\7A\2\2\u00b6\62")
+        buf.write("\3\2\2\2\u00b7\u00b8\7a\2\2\u00b8\64\3\2\2\2\u00b9\u00ba")
+        buf.write("\7<\2\2\u00ba\66\3\2\2\2\u00bb\u00bc\7V\2\2\u00bc\u00bd")
+        buf.write("\7g\2\2\u00bd\u00be\7p\2\2\u00be\u00bf\7u\2\2\u00bf\u00c0")
+        buf.write("\7q\2\2\u00c0\u00c1\7t\2\2\u00c18\3\2\2\2\u00c2\u00c3")
+        buf.write("\7o\2\2\u00c3\u00c4\7g\2\2\u00c4\u00c5\7v\2\2\u00c5\u00c6")
+        buf.write("\7c\2\2\u00c6:\3\2\2\2\u00c7\u00c8\7x\2\2\u00c8\u00c9")
+        buf.write("\7\62\2\2\u00c9\u00ca\7\60\2\2\u00ca\u00cb\7\62\2\2\u00cb")
+        buf.write("\u00cc\7\60\2\2\u00cc\u00cd\7\65\2\2\u00cd<\3\2\2\2\u00ce")
+        buf.write("\u00cf\7\61\2\2\u00cf\u00d0\7,\2\2\u00d0\u00d5\3\2\2\2")
+        buf.write("\u00d1\u00d4\5=\37\2\u00d2\u00d4\13\2\2\2\u00d3\u00d1")
+        buf.write("\3\2\2\2\u00d3\u00d2\3\2\2\2\u00d4\u00d7\3\2\2\2\u00d5")
+        buf.write("\u00d6\3\2\2\2\u00d5\u00d3\3\2\2\2\u00d6\u00d8\3\2\2\2")
+        buf.write("\u00d7\u00d5\3\2\2\2\u00d8\u00d9\7,\2\2\u00d9\u00da\7")
+        buf.write("\61\2\2\u00da\u00db\3\2\2\2\u00db\u00dc\b\37\2\2\u00dc")
+        buf.write(">\3\2\2\2\u00dd\u00df\t\2\2\2\u00de\u00dd\3\2\2\2\u00df")
+        buf.write("\u00e0\3\2\2\2\u00e0\u00de\3\2\2\2\u00e0\u00e1\3\2\2\2")
+        buf.write("\u00e1\u00e2\3\2\2\2\u00e2\u00e3\b \2\2\u00e3@\3\2\2\2")
+        buf.write("\u00e4\u00e5\7\61\2\2\u00e5\u00e6\7\61\2\2\u00e6\u00ea")
+        buf.write("\3\2\2\2\u00e7\u00e9\13\2\2\2\u00e8\u00e7\3\2\2\2\u00e9")
+        buf.write("\u00ec\3\2\2\2\u00ea\u00eb\3\2\2\2\u00ea\u00e8\3\2\2\2")
+        buf.write("\u00eb\u00ed\3\2\2\2\u00ec\u00ea\3\2\2\2\u00ed\u00ee\7")
+        buf.write("\f\2\2\u00ee\u00ef\3\2\2\2\u00ef\u00f0\b!\2\2\u00f0B\3")
+        buf.write("\2\2\2\u00f1\u00f2\7^\2\2\u00f2\u00f3\7$\2\2\u00f3D\3")
+        buf.write("\2\2\2\u00f4\u00f9\7$\2\2\u00f5\u00f8\5C\"\2\u00f6\u00f8")
+        buf.write("\n\3\2\2\u00f7\u00f5\3\2\2\2\u00f7\u00f6\3\2\2\2\u00f8")
+        buf.write("\u00fb\3\2\2\2\u00f9\u00fa\3\2\2\2\u00f9\u00f7\3\2\2\2")
+        buf.write("\u00fa\u00fc\3\2\2\2\u00fb\u00f9\3\2\2\2\u00fc\u00fd\7")
+        buf.write("$\2\2\u00fdF\3\2\2\2\u00fe\u00ff\7,\2\2\u00ffH\3\2\2\2")
+        buf.write("\u0100\u0101\7\61\2\2\u0101J\3\2\2\2\u0102\u0103\7-\2")
+        buf.write("\2\u0103L\3\2\2\2\u0104\u0105\7/\2\2\u0105N\3\2\2\2\u0106")
+        buf.write("\u0107\7>\2\2\u0107P\3\2\2\2\u0108\u0109\7@\2\2\u0109")
+        buf.write("R\3\2\2\2\u010a\u010b\7>\2\2\u010b\u010c\7?\2\2\u010c")
+        buf.write("T\3\2\2\2\u010d\u010e\7@\2\2\u010e\u010f\7?\2\2\u010f")
+        buf.write("V\3\2\2\2\u0110\u0111\7?\2\2\u0111\u0112\7?\2\2\u0112")
+        buf.write("X\3\2\2\2\u0113\u0114\7#\2\2\u0114\u0115\7?\2\2\u0115")
+        buf.write("Z\3\2\2\2\u0116\u0117\7V\2\2\u0117\u0118\7t\2\2\u0118")
+        buf.write("\u0119\7w\2\2\u0119\u0120\7g\2\2\u011a\u011b\7H\2\2\u011b")
+        buf.write("\u011c\7c\2\2\u011c\u011d\7n\2\2\u011d\u011e\7u\2\2\u011e")
+        buf.write("\u0120\7g\2\2\u011f\u0116\3\2\2\2\u011f\u011a\3\2\2\2")
+        buf.write("\u0120\\\3\2\2\2\u0121\u0124\7a\2\2\u0122\u0124\5i\65")
+        buf.write("\2\u0123\u0121\3\2\2\2\u0123\u0122\3\2\2\2\u0124\u012a")
+        buf.write("\3\2\2\2\u0125\u0129\7a\2\2\u0126\u0129\5i\65\2\u0127")
+        buf.write("\u0129\5k\66\2\u0128\u0125\3\2\2\2\u0128\u0126\3\2\2\2")
+        buf.write("\u0128\u0127\3\2\2\2\u0129\u012c\3\2\2\2\u012a\u0128\3")
+        buf.write("\2\2\2\u012a\u012b\3\2\2\2\u012b\u0131\3\2\2\2\u012c\u012a")
+        buf.write("\3\2\2\2\u012d\u012e\7\60\2\2\u012e\u0130\5]/\2\u012f")
+        buf.write("\u012d\3\2\2\2\u0130\u0133\3\2\2\2\u0131\u012f\3\2\2\2")
+        buf.write("\u0131\u0132\3\2\2\2\u0132^\3\2\2\2\u0133\u0131\3\2\2")
+        buf.write("\2\u0134\u0135\7k\2\2\u0135\u0136\7p\2\2\u0136\u0137\7")
+        buf.write("v\2\2\u0137\u0138\78\2\2\u0138\u0139\7\66\2\2\u0139`\3")
+        buf.write("\2\2\2\u013a\u013d\5e\63\2\u013b\u013c\7\60\2\2\u013c")
+        buf.write("\u013e\5e\63\2\u013d\u013b\3\2\2\2\u013d\u013e\3\2\2\2")
+        buf.write("\u013e\u0140\3\2\2\2\u013f\u0141\5g\64\2\u0140\u013f\3")
+        buf.write("\2\2\2\u0140\u0141\3\2\2\2\u0141b\3\2\2\2\u0142\u0143")
+        buf.write("\5a\61\2\u0143\u0144\7h\2\2\u0144d\3\2\2\2\u0145\u0147")
+        buf.write("\5k\66\2\u0146\u0145\3\2\2\2\u0147\u0148\3\2\2\2\u0148")
+        buf.write("\u0146\3\2\2\2\u0148\u0149\3\2\2\2\u0149f\3\2\2\2\u014a")
+        buf.write("\u014c\t\4\2\2\u014b\u014d\t\5\2\2\u014c\u014b\3\2\2\2")
+        buf.write("\u014c\u014d\3\2\2\2\u014d\u014e\3\2\2\2\u014e\u014f\5")
+        buf.write("e\63\2\u014fh\3\2\2\2\u0150\u0151\t\6\2\2\u0151j\3\2\2")
+        buf.write("\2\u0152\u0153\t\7\2\2\u0153l\3\2\2\2\u0154\u0155\7O\2")
+        buf.write("\2\u0155\u0156\7G\2\2\u0156\u0157\7V\2\2\u0157\u0158\7")
+        buf.write("C\2\2\u0158\u0159\7F\2\2\u0159\u015a\7C\2\2\u015a\u015b")
+        buf.write("\7V\2\2\u015b\u015c\7C\2\2\u015c\u015d\7<\2\2\u015d\u0161")
+        buf.write("\3\2\2\2\u015e\u0160\13\2\2\2\u015f\u015e\3\2\2\2\u0160")
+        buf.write("\u0163\3\2\2\2\u0161\u015f\3\2\2\2\u0161\u0162\3\2\2\2")
+        buf.write("\u0162n\3\2\2\2\u0163\u0161\3\2\2\2\23\2\u00d3\u00d5\u00e0")
+        buf.write("\u00ea\u00f7\u00f9\u011f\u0123\u0128\u012a\u0131\u013d")
+        buf.write("\u0140\u0148\u014c\u0161\3\b\2\2")
         return buf.getvalue()
 
 
@@ -186,38 +195,42 @@ class RelayLexer(Lexer):
     T__22 = 23
     T__23 = 24
     T__24 = 25
-    SEMVER = 26
-    COMMENT = 27
-    WS = 28
-    LINE_COMMENT = 29
-    QUOTED_STRING = 30
-    MUL = 31
-    DIV = 32
-    ADD = 33
-    SUB = 34
-    LT = 35
-    GT = 36
-    LE = 37
-    GE = 38
-    EQ = 39
-    NE = 40
-    BOOL_LIT = 41
-    CNAME = 42
-    DATATYPE = 43
-    FLOAT = 44
-    NAT = 45
-    METADATA = 46
+    T__25 = 26
+    T__26 = 27
+    T__27 = 28
+    SEMVER = 29
+    COMMENT = 30
+    WS = 31
+    LINE_COMMENT = 32
+    QUOTED_STRING = 33
+    MUL = 34
+    DIV = 35
+    ADD = 36
+    SUB = 37
+    LT = 38
+    GT = 39
+    LE = 40
+    GE = 41
+    EQ = 42
+    NE = 43
+    BOOL_LIT = 44
+    CNAME = 45
+    DATATYPE = 46
+    FLOAT = 47
+    NAT = 48
+    METADATA = 49
 
     channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ]
 
     modeNames = [ "DEFAULT_MODE" ]
 
     literalNames = [ "<INVALID>",
-            "'@'", "'%'", "','", "'('", "')'", "'{'", "'}'", "'.'", "'['", 
-            "']'", "'if'", "'else'", "'let'", "'='", "';'", "';;'", "'fn'", 
-            "'->'", "'def'", "'type'", "'|'", "':'", "'Tensor'", "'_'", 
-            "'meta'", "'v0.0.3'", "'*'", "'/'", "'+'", "'-'", "'<'", "'>'", 
-            "'<='", "'>='", "'=='", "'!='", "'int64'" ]
+            "'@'", "'%'", "','", "'('", "')'", "'{'", "'}'", "'['", "']'", 
+            "'if'", "'else'", "'.'", "'let'", "'='", "';'", "';;'", "'fn'", 
+            "'->'", "'def'", "'type'", "'|'", "'=>'", "'match'", "'match?'", 
+            "'_'", "':'", "'Tensor'", "'meta'", "'v0.0.3'", "'*'", "'/'", 
+            "'+'", "'-'", "'<'", "'>'", "'<='", "'>='", "'=='", "'!='", 
+            "'int64'" ]
 
     symbolicNames = [ "<INVALID>",
             "SEMVER", "COMMENT", "WS", "LINE_COMMENT", "QUOTED_STRING", 
@@ -227,11 +240,12 @@ class RelayLexer(Lexer):
     ruleNames = [ "T__0", "T__1", "T__2", "T__3", "T__4", "T__5", "T__6", 
                   "T__7", "T__8", "T__9", "T__10", "T__11", "T__12", "T__13", 
                   "T__14", "T__15", "T__16", "T__17", "T__18", "T__19", 
-                  "T__20", "T__21", "T__22", "T__23", "T__24", "SEMVER", 
-                  "COMMENT", "WS", "LINE_COMMENT", "ESCAPED_QUOTE", "QUOTED_STRING", 
-                  "MUL", "DIV", "ADD", "SUB", "LT", "GT", "LE", "GE", "EQ", 
-                  "NE", "BOOL_LIT", "CNAME", "DATATYPE", "PREFLOAT", "FLOAT", 
-                  "NAT", "EXP", "LETTER", "DIGIT", "METADATA" ]
+                  "T__20", "T__21", "T__22", "T__23", "T__24", "T__25", 
+                  "T__26", "T__27", "SEMVER", "COMMENT", "WS", "LINE_COMMENT", 
+                  "ESCAPED_QUOTE", "QUOTED_STRING", "MUL", "DIV", "ADD", 
+                  "SUB", "LT", "GT", "LE", "GE", "EQ", "NE", "BOOL_LIT", 
+                  "CNAME", "DATATYPE", "PREFLOAT", "FLOAT", "NAT", "EXP", 
+                  "LETTER", "DIGIT", "METADATA" ]
 
     grammarFileName = "Relay.g4"
 
diff --git a/python/tvm/relay/grammar/py3/RelayParser.py b/python/tvm/relay/grammar/py3/RelayParser.py
index 4db03c14e784..6f84a5572e7d 100644
--- a/python/tvm/relay/grammar/py3/RelayParser.py
+++ b/python/tvm/relay/grammar/py3/RelayParser.py
@@ -8,198 +8,221 @@
 
 def serializedATN():
     with StringIO() as buf:
-        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\60")
-        buf.write("\u0195\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
+        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\63")
+        buf.write("\u01c1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
         buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
         buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
         buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
-        buf.write("\t\31\4\32\t\32\4\33\t\33\3\2\3\2\7\29\n\2\f\2\16\2<\13")
-        buf.write("\2\3\2\5\2?\n\2\3\2\5\2B\n\2\3\2\3\2\3\3\3\3\3\4\3\4\3")
-        buf.write("\4\3\5\3\5\3\5\3\6\3\6\3\7\3\7\3\7\3\b\3\b\3\b\7\bV\n")
-        buf.write("\b\f\b\16\bY\13\b\5\b[\n\b\3\t\3\t\3\t\3\t\7\ta\n\t\f")
-        buf.write("\t\16\td\13\t\3\t\5\tg\n\t\3\n\3\n\3\n\3\n\3\n\3\n\3\n")
-        buf.write("\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3")
-        buf.write("\n\3\n\3\n\6\n\u0080\n\n\r\n\16\n\u0081\3\n\3\n\3\n\3")
-        buf.write("\n\3\n\3\n\7\n\u008a\n\n\f\n\16\n\u008d\13\n\5\n\u008f")
-        buf.write("\n\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3")
-        buf.write("\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n")
-        buf.write("\5\n\u00ab\n\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n")
-        buf.write("\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\7")
-        buf.write("\n\u00c4\n\n\f\n\16\n\u00c7\13\n\3\13\3\13\5\13\u00cb")
-        buf.write("\n\13\3\13\3\13\3\13\3\13\3\13\5\13\u00d2\n\13\3\13\3")
-        buf.write("\13\3\f\3\f\3\f\5\f\u00d9\n\f\3\f\3\f\3\f\3\f\3\f\5\f")
-        buf.write("\u00e0\n\f\3\f\3\f\3\f\3\f\3\f\5\f\u00e7\n\f\3\f\3\f\6")
-        buf.write("\f\u00eb\n\f\r\f\16\f\u00ec\5\f\u00ef\n\f\3\r\3\r\3\r")
-        buf.write("\3\r\3\r\3\r\7\r\u00f7\n\r\f\r\16\r\u00fa\13\r\3\r\3\r")
-        buf.write("\5\r\u00fe\n\r\3\16\3\16\3\17\3\17\3\17\3\17\7\17\u0106")
-        buf.write("\n\17\f\17\16\17\u0109\13\17\3\17\5\17\u010c\n\17\3\20")
-        buf.write("\3\20\3\20\7\20\u0111\n\20\f\20\16\20\u0114\13\20\5\20")
-        buf.write("\u0116\n\20\3\21\3\21\3\21\5\21\u011b\n\21\3\22\3\22\3")
-        buf.write("\22\7\22\u0120\n\22\f\22\16\22\u0123\13\22\3\23\3\23\3")
-        buf.write("\23\3\23\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24")
-        buf.write("\3\24\3\24\6\24\u0134\n\24\r\24\16\24\u0135\3\24\3\24")
-        buf.write("\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24")
-        buf.write("\3\24\3\24\5\24\u0147\n\24\3\24\3\24\3\24\3\24\7\24\u014d")
-        buf.write("\n\24\f\24\16\24\u0150\13\24\5\24\u0152\n\24\3\24\3\24")
-        buf.write("\3\24\3\24\3\24\5\24\u0159\n\24\3\25\3\25\3\25\3\25\7")
-        buf.write("\25\u015f\n\25\f\25\16\25\u0162\13\25\3\25\3\25\3\26\3")
-        buf.write("\26\3\26\3\26\6\26\u016a\n\26\r\26\16\26\u016b\3\26\3")
-        buf.write("\26\3\26\3\26\3\26\5\26\u0173\n\26\3\27\3\27\3\27\3\27")
-        buf.write("\3\27\3\27\3\27\3\27\3\30\3\30\3\30\3\30\3\30\3\30\5\30")
-        buf.write("\u0183\n\30\3\31\3\31\3\31\3\31\3\32\3\32\3\32\5\32\u018c")
-        buf.write("\n\32\3\33\3\33\3\33\3\33\3\33\5\33\u0193\n\33\3\33\2")
-        buf.write("\3\22\34\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(")
-        buf.write("*,.\60\62\64\2\6\3\2!\"\3\2#$\3\2%(\3\2)*\2\u01c0\2\66")
-        buf.write("\3\2\2\2\4E\3\2\2\2\6G\3\2\2\2\bJ\3\2\2\2\nM\3\2\2\2\f")
-        buf.write("O\3\2\2\2\16Z\3\2\2\2\20f\3\2\2\2\22\u00aa\3\2\2\2\24")
-        buf.write("\u00c8\3\2\2\2\26\u00ee\3\2\2\2\30\u00f0\3\2\2\2\32\u00ff")
-        buf.write("\3\2\2\2\34\u010b\3\2\2\2\36\u0115\3\2\2\2 \u0117\3\2")
-        buf.write("\2\2\"\u011c\3\2\2\2$\u0124\3\2\2\2&\u0158\3\2\2\2(\u015a")
-        buf.write("\3\2\2\2*\u0172\3\2\2\2,\u0174\3\2\2\2.\u0182\3\2\2\2")
-        buf.write("\60\u0184\3\2\2\2\62\u018b\3\2\2\2\64\u0192\3\2\2\2\66")
-        buf.write(">\7\34\2\2\679\5\26\f\28\67\3\2\2\29<\3\2\2\2:8\3\2\2")
-        buf.write("\2:;\3\2\2\2;?\3\2\2\2<:\3\2\2\2=?\5\22\n\2>:\3\2\2\2")
-        buf.write(">=\3\2\2\2?A\3\2\2\2@B\7\60\2\2A@\3\2\2\2AB\3\2\2\2BC")
-        buf.write("\3\2\2\2CD\7\2\2\3D\3\3\2\2\2EF\7,\2\2F\5\3\2\2\2GH\7")
-        buf.write("\3\2\2HI\7,\2\2I\7\3\2\2\2JK\7\4\2\2KL\7,\2\2L\t\3\2\2")
-        buf.write("\2MN\7,\2\2N\13\3\2\2\2OP\7\4\2\2PQ\7/\2\2Q\r\3\2\2\2")
-        buf.write("RW\5\22\n\2ST\7\5\2\2TV\5\22\n\2US\3\2\2\2VY\3\2\2\2W")
-        buf.write("U\3\2\2\2WX\3\2\2\2X[\3\2\2\2YW\3\2\2\2ZR\3\2\2\2Z[\3")
-        buf.write("\2\2\2[\17\3\2\2\2\\g\5\16\b\2]^\5\22\n\2^_\7\5\2\2_a")
-        buf.write("\3\2\2\2`]\3\2\2\2ad\3\2\2\2b`\3\2\2\2bc\3\2\2\2ce\3\2")
-        buf.write("\2\2db\3\2\2\2eg\5\"\22\2f\\\3\2\2\2fb\3\2\2\2g\21\3\2")
-        buf.write("\2\2hi\b\n\1\2ij\7\6\2\2jk\5\22\n\2kl\7\7\2\2l\u00ab\3")
-        buf.write("\2\2\2mn\7\b\2\2no\5\22\n\2op\7\t\2\2p\u00ab\3\2\2\2q")
-        buf.write("r\7$\2\2r\u00ab\5\22\n\25s\u00ab\5\24\13\2tu\7\6\2\2u")
-        buf.write("\u00ab\7\7\2\2vw\7\6\2\2wx\5\22\n\2xy\7\5\2\2yz\7\7\2")
-        buf.write("\2z\u00ab\3\2\2\2{|\7\6\2\2|\177\5\22\n\2}~\7\5\2\2~\u0080")
-        buf.write("\5\22\n\2\177}\3\2\2\2\u0080\u0081\3\2\2\2\u0081\177\3")
-        buf.write("\2\2\2\u0081\u0082\3\2\2\2\u0082\u0083\3\2\2\2\u0083\u0084")
-        buf.write("\7\7\2\2\u0084\u00ab\3\2\2\2\u0085\u008e\7\13\2\2\u0086")
-        buf.write("\u008b\5\22\n\2\u0087\u0088\7\5\2\2\u0088\u008a\5\22\n")
-        buf.write("\2\u0089\u0087\3\2\2\2\u008a\u008d\3\2\2\2\u008b\u0089")
-        buf.write("\3\2\2\2\u008b\u008c\3\2\2\2\u008c\u008f\3\2\2\2\u008d")
-        buf.write("\u008b\3\2\2\2\u008e\u0086\3\2\2\2\u008e\u008f\3\2\2\2")
-        buf.write("\u008f\u0090\3\2\2\2\u0090\u00ab\7\f\2\2\u0091\u0092\7")
-        buf.write("\r\2\2\u0092\u0093\7\6\2\2\u0093\u0094\5\22\n\2\u0094")
-        buf.write("\u0095\7\7\2\2\u0095\u0096\5\60\31\2\u0096\u0097\7\16")
-        buf.write("\2\2\u0097\u0098\5\60\31\2\u0098\u00ab\3\2\2\2\u0099\u009a")
-        buf.write("\7\17\2\2\u009a\u009b\5 \21\2\u009b\u009c\7\20\2\2\u009c")
-        buf.write("\u009d\5\22\n\2\u009d\u009e\7\21\2\2\u009e\u009f\5\22")
-        buf.write("\n\t\u009f\u00ab\3\2\2\2\u00a0\u00a1\5\f\7\2\u00a1\u00a2")
-        buf.write("\7\20\2\2\u00a2\u00a3\5\22\n\2\u00a3\u00a4\7\21\2\2\u00a4")
-        buf.write("\u00a5\5\22\n\7\u00a5\u00ab\3\2\2\2\u00a6\u00ab\5\64\33")
-        buf.write("\2\u00a7\u00ab\5\62\32\2\u00a8\u00ab\5,\27\2\u00a9\u00ab")
-        buf.write("\7 \2\2\u00aah\3\2\2\2\u00aam\3\2\2\2\u00aaq\3\2\2\2\u00aa")
-        buf.write("s\3\2\2\2\u00aat\3\2\2\2\u00aav\3\2\2\2\u00aa{\3\2\2\2")
-        buf.write("\u00aa\u0085\3\2\2\2\u00aa\u0091\3\2\2\2\u00aa\u0099\3")
-        buf.write("\2\2\2\u00aa\u00a0\3\2\2\2\u00aa\u00a6\3\2\2\2\u00aa\u00a7")
-        buf.write("\3\2\2\2\u00aa\u00a8\3\2\2\2\u00aa\u00a9\3\2\2\2\u00ab")
-        buf.write("\u00c5\3\2\2\2\u00ac\u00ad\f\24\2\2\u00ad\u00ae\t\2\2")
-        buf.write("\2\u00ae\u00c4\5\22\n\25\u00af\u00b0\f\23\2\2\u00b0\u00b1")
-        buf.write("\t\3\2\2\u00b1\u00c4\5\22\n\24\u00b2\u00b3\f\22\2\2\u00b3")
-        buf.write("\u00b4\t\4\2\2\u00b4\u00c4\5\22\n\23\u00b5\u00b6\f\21")
-        buf.write("\2\2\u00b6\u00b7\t\5\2\2\u00b7\u00c4\5\22\n\22\u00b8\u00b9")
-        buf.write("\f\b\2\2\u00b9\u00ba\7\22\2\2\u00ba\u00c4\5\22\n\t\u00bb")
-        buf.write("\u00bc\f\26\2\2\u00bc\u00bd\7\6\2\2\u00bd\u00be\5\20\t")
-        buf.write("\2\u00be\u00bf\7\7\2\2\u00bf\u00c4\3\2\2\2\u00c0\u00c1")
-        buf.write("\f\f\2\2\u00c1\u00c2\7\n\2\2\u00c2\u00c4\7/\2\2\u00c3")
-        buf.write("\u00ac\3\2\2\2\u00c3\u00af\3\2\2\2\u00c3\u00b2\3\2\2\2")
-        buf.write("\u00c3\u00b5\3\2\2\2\u00c3\u00b8\3\2\2\2\u00c3\u00bb\3")
-        buf.write("\2\2\2\u00c3\u00c0\3\2\2\2\u00c4\u00c7\3\2\2\2\u00c5\u00c3")
-        buf.write("\3\2\2\2\u00c5\u00c6\3\2\2\2\u00c6\23\3\2\2\2\u00c7\u00c5")
-        buf.write("\3\2\2\2\u00c8\u00ca\7\23\2\2\u00c9\u00cb\5(\25\2\u00ca")
-        buf.write("\u00c9\3\2\2\2\u00ca\u00cb\3\2\2\2\u00cb\u00cc\3\2\2\2")
-        buf.write("\u00cc\u00cd\7\6\2\2\u00cd\u00ce\5\34\17\2\u00ce\u00d1")
-        buf.write("\7\7\2\2\u00cf\u00d0\7\24\2\2\u00d0\u00d2\5&\24\2\u00d1")
-        buf.write("\u00cf\3\2\2\2\u00d1\u00d2\3\2\2\2\u00d2\u00d3\3\2\2\2")
-        buf.write("\u00d3\u00d4\5\60\31\2\u00d4\25\3\2\2\2\u00d5\u00d6\7")
-        buf.write("\25\2\2\u00d6\u00d8\5\6\4\2\u00d7\u00d9\5(\25\2\u00d8")
-        buf.write("\u00d7\3\2\2\2\u00d8\u00d9\3\2\2\2\u00d9\u00da\3\2\2\2")
-        buf.write("\u00da\u00db\7\6\2\2\u00db\u00dc\5\34\17\2\u00dc\u00df")
-        buf.write("\7\7\2\2\u00dd\u00de\7\24\2\2\u00de\u00e0\5&\24\2\u00df")
-        buf.write("\u00dd\3\2\2\2\u00df\u00e0\3\2\2\2\u00e0\u00e1\3\2\2\2")
-        buf.write("\u00e1\u00e2\5\60\31\2\u00e2\u00ef\3\2\2\2\u00e3\u00e4")
-        buf.write("\7\26\2\2\u00e4\u00e6\5\n\6\2\u00e5\u00e7\5(\25\2\u00e6")
-        buf.write("\u00e5\3\2\2\2\u00e6\u00e7\3\2\2\2\u00e7\u00e8\3\2\2\2")
-        buf.write("\u00e8\u00ea\7\20\2\2\u00e9\u00eb\5\30\r\2\u00ea\u00e9")
-        buf.write("\3\2\2\2\u00eb\u00ec\3\2\2\2\u00ec\u00ea\3\2\2\2\u00ec")
-        buf.write("\u00ed\3\2\2\2\u00ed\u00ef\3\2\2\2\u00ee\u00d5\3\2\2\2")
-        buf.write("\u00ee\u00e3\3\2\2\2\u00ef\27\3\2\2\2\u00f0\u00f1\7\27")
-        buf.write("\2\2\u00f1\u00fd\5\32\16\2\u00f2\u00f3\7\6\2\2\u00f3\u00f8")
-        buf.write("\5&\24\2\u00f4\u00f5\7\5\2\2\u00f5\u00f7\5&\24\2\u00f6")
-        buf.write("\u00f4\3\2\2\2\u00f7\u00fa\3\2\2\2\u00f8\u00f6\3\2\2\2")
-        buf.write("\u00f8\u00f9\3\2\2\2\u00f9\u00fb\3\2\2\2\u00fa\u00f8\3")
-        buf.write("\2\2\2\u00fb\u00fc\7\7\2\2\u00fc\u00fe\3\2\2\2\u00fd\u00f2")
-        buf.write("\3\2\2\2\u00fd\u00fe\3\2\2\2\u00fe\31\3\2\2\2\u00ff\u0100")
-        buf.write("\7,\2\2\u0100\33\3\2\2\2\u0101\u010c\5\36\20\2\u0102\u0103")
-        buf.write("\5 \21\2\u0103\u0104\7\5\2\2\u0104\u0106\3\2\2\2\u0105")
-        buf.write("\u0102\3\2\2\2\u0106\u0109\3\2\2\2\u0107\u0105\3\2\2\2")
-        buf.write("\u0107\u0108\3\2\2\2\u0108\u010a\3\2\2\2\u0109\u0107\3")
-        buf.write("\2\2\2\u010a\u010c\5\"\22\2\u010b\u0101\3\2\2\2\u010b")
-        buf.write("\u0107\3\2\2\2\u010c\35\3\2\2\2\u010d\u0112\5 \21\2\u010e")
-        buf.write("\u010f\7\5\2\2\u010f\u0111\5 \21\2\u0110\u010e\3\2\2\2")
-        buf.write("\u0111\u0114\3\2\2\2\u0112\u0110\3\2\2\2\u0112\u0113\3")
-        buf.write("\2\2\2\u0113\u0116\3\2\2\2\u0114\u0112\3\2\2\2\u0115\u010d")
-        buf.write("\3\2\2\2\u0115\u0116\3\2\2\2\u0116\37\3\2\2\2\u0117\u011a")
-        buf.write("\5\b\5\2\u0118\u0119\7\30\2\2\u0119\u011b\5&\24\2\u011a")
-        buf.write("\u0118\3\2\2\2\u011a\u011b\3\2\2\2\u011b!\3\2\2\2\u011c")
-        buf.write("\u0121\5$\23\2\u011d\u011e\7\5\2\2\u011e\u0120\5$\23\2")
-        buf.write("\u011f\u011d\3\2\2\2\u0120\u0123\3\2\2\2\u0121\u011f\3")
-        buf.write("\2\2\2\u0121\u0122\3\2\2\2\u0122#\3\2\2\2\u0123\u0121")
-        buf.write("\3\2\2\2\u0124\u0125\7,\2\2\u0125\u0126\7\20\2\2\u0126")
-        buf.write("\u0127\5\22\n\2\u0127%\3\2\2\2\u0128\u0129\7\6\2\2\u0129")
-        buf.write("\u0159\7\7\2\2\u012a\u012b\7\6\2\2\u012b\u012c\5&\24\2")
-        buf.write("\u012c\u012d\7\5\2\2\u012d\u012e\7\7\2\2\u012e\u0159\3")
-        buf.write("\2\2\2\u012f\u0130\7\6\2\2\u0130\u0133\5&\24\2\u0131\u0132")
-        buf.write("\7\5\2\2\u0132\u0134\5&\24\2\u0133\u0131\3\2\2\2\u0134")
-        buf.write("\u0135\3\2\2\2\u0135\u0133\3\2\2\2\u0135\u0136\3\2\2\2")
-        buf.write("\u0136\u0137\3\2\2\2\u0137\u0138\7\7\2\2\u0138\u0159\3")
-        buf.write("\2\2\2\u0139\u013a\5\n\6\2\u013a\u013b\5(\25\2\u013b\u0159")
-        buf.write("\3\2\2\2\u013c\u0159\5\n\6\2\u013d\u013e\7\31\2\2\u013e")
-        buf.write("\u013f\7\13\2\2\u013f\u0140\5*\26\2\u0140\u0141\7\5\2")
-        buf.write("\2\u0141\u0142\5&\24\2\u0142\u0143\7\f\2\2\u0143\u0159")
-        buf.write("\3\2\2\2\u0144\u0146\7\23\2\2\u0145\u0147\5(\25\2\u0146")
-        buf.write("\u0145\3\2\2\2\u0146\u0147\3\2\2\2\u0147\u0148\3\2\2\2")
-        buf.write("\u0148\u0151\7\6\2\2\u0149\u014e\5&\24\2\u014a\u014b\7")
-        buf.write("\5\2\2\u014b\u014d\5&\24\2\u014c\u014a\3\2\2\2\u014d\u0150")
-        buf.write("\3\2\2\2\u014e\u014c\3\2\2\2\u014e\u014f\3\2\2\2\u014f")
-        buf.write("\u0152\3\2\2\2\u0150\u014e\3\2\2\2\u0151\u0149\3\2\2\2")
-        buf.write("\u0151\u0152\3\2\2\2\u0152\u0153\3\2\2\2\u0153\u0154\7")
-        buf.write("\7\2\2\u0154\u0155\7\24\2\2\u0155\u0159\5&\24\2\u0156")
-        buf.write("\u0159\7\32\2\2\u0157\u0159\7/\2\2\u0158\u0128\3\2\2\2")
-        buf.write("\u0158\u012a\3\2\2\2\u0158\u012f\3\2\2\2\u0158\u0139\3")
-        buf.write("\2\2\2\u0158\u013c\3\2\2\2\u0158\u013d\3\2\2\2\u0158\u0144")
-        buf.write("\3\2\2\2\u0158\u0156\3\2\2\2\u0158\u0157\3\2\2\2\u0159")
-        buf.write("\'\3\2\2\2\u015a\u015b\7\13\2\2\u015b\u0160\5\n\6\2\u015c")
-        buf.write("\u015d\7\5\2\2\u015d\u015f\5\n\6\2\u015e\u015c\3\2\2\2")
-        buf.write("\u015f\u0162\3\2\2\2\u0160\u015e\3\2\2\2\u0160\u0161\3")
-        buf.write("\2\2\2\u0161\u0163\3\2\2\2\u0162\u0160\3\2\2\2\u0163\u0164")
-        buf.write("\7\f\2\2\u0164)\3\2\2\2\u0165\u0166\7\6\2\2\u0166\u0169")
-        buf.write("\5.\30\2\u0167\u0168\7\5\2\2\u0168\u016a\5.\30\2\u0169")
-        buf.write("\u0167\3\2\2\2\u016a\u016b\3\2\2\2\u016b\u0169\3\2\2\2")
-        buf.write("\u016b\u016c\3\2\2\2\u016c\u016d\3\2\2\2\u016d\u016e\7")
-        buf.write("\7\2\2\u016e\u0173\3\2\2\2\u016f\u0170\7\6\2\2\u0170\u0173")
-        buf.write("\7\7\2\2\u0171\u0173\5.\30\2\u0172\u0165\3\2\2\2\u0172")
-        buf.write("\u016f\3\2\2\2\u0172\u0171\3\2\2\2\u0173+\3\2\2\2\u0174")
-        buf.write("\u0175\7\33\2\2\u0175\u0176\7\13\2\2\u0176\u0177\7,\2")
-        buf.write("\2\u0177\u0178\7\f\2\2\u0178\u0179\7\13\2\2\u0179\u017a")
-        buf.write("\7/\2\2\u017a\u017b\7\f\2\2\u017b-\3\2\2\2\u017c\u0183")
-        buf.write("\5,\27\2\u017d\u017e\7\6\2\2\u017e\u017f\5.\30\2\u017f")
-        buf.write("\u0180\7\7\2\2\u0180\u0183\3\2\2\2\u0181\u0183\7/\2\2")
-        buf.write("\u0182\u017c\3\2\2\2\u0182\u017d\3\2\2\2\u0182\u0181\3")
-        buf.write("\2\2\2\u0183/\3\2\2\2\u0184\u0185\7\b\2\2\u0185\u0186")
-        buf.write("\5\22\n\2\u0186\u0187\7\t\2\2\u0187\61\3\2\2\2\u0188\u018c")
-        buf.write("\7.\2\2\u0189\u018c\7/\2\2\u018a\u018c\7+\2\2\u018b\u0188")
-        buf.write("\3\2\2\2\u018b\u0189\3\2\2\2\u018b\u018a\3\2\2\2\u018c")
-        buf.write("\63\3\2\2\2\u018d\u0193\5\4\3\2\u018e\u0193\5\6\4\2\u018f")
-        buf.write("\u0193\5\b\5\2\u0190\u0193\5&\24\2\u0191\u0193\5\f\7\2")
-        buf.write("\u0192\u018d\3\2\2\2\u0192\u018e\3\2\2\2\u0192\u018f\3")
-        buf.write("\2\2\2\u0192\u0190\3\2\2\2\u0192\u0191\3\2\2\2\u0193\65")
-        buf.write("\3\2\2\2):>AWZbf\u0081\u008b\u008e\u00aa\u00c3\u00c5\u00ca")
-        buf.write("\u00d1\u00d8\u00df\u00e6\u00ec\u00ee\u00f8\u00fd\u0107")
-        buf.write("\u010b\u0112\u0115\u011a\u0121\u0135\u0146\u014e\u0151")
-        buf.write("\u0158\u0160\u016b\u0172\u0182\u018b\u0192")
+        buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
+        buf.write("\4\37\t\37\3\2\3\2\7\2A\n\2\f\2\16\2D\13\2\3\2\5\2G\n")
+        buf.write("\2\3\2\5\2J\n\2\3\2\3\2\3\3\3\3\3\4\3\4\3\4\3\5\3\5\3")
+        buf.write("\5\3\6\3\6\3\7\3\7\3\7\3\b\3\b\3\b\7\b^\n\b\f\b\16\ba")
+        buf.write("\13\b\5\bc\n\b\3\t\3\t\3\t\3\t\7\ti\n\t\f\t\16\tl\13\t")
+        buf.write("\3\t\5\to\n\t\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n")
+        buf.write("\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\6")
+        buf.write("\n\u0088\n\n\r\n\16\n\u0089\3\n\3\n\3\n\3\n\3\n\3\n\7")
+        buf.write("\n\u0092\n\n\f\n\16\n\u0095\13\n\5\n\u0097\n\n\3\n\3\n")
+        buf.write("\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\6")
+        buf.write("\n\u00a8\n\n\r\n\16\n\u00a9\3\n\3\n\3\n\3\n\3\n\3\n\3")
+        buf.write("\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\5\n")
+        buf.write("\u00bf\n\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n")
+        buf.write("\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\7\n\u00d8")
+        buf.write("\n\n\f\n\16\n\u00db\13\n\3\13\3\13\5\13\u00df\n\13\3\13")
+        buf.write("\3\13\3\13\3\13\3\13\5\13\u00e6\n\13\3\13\3\13\3\f\3\f")
+        buf.write("\3\f\5\f\u00ed\n\f\3\f\3\f\3\f\3\f\3\f\5\f\u00f4\n\f\3")
+        buf.write("\f\3\f\3\f\3\f\3\f\5\f\u00fb\n\f\3\f\3\f\6\f\u00ff\n\f")
+        buf.write("\r\f\16\f\u0100\5\f\u0103\n\f\3\r\3\r\3\r\3\r\3\r\3\r")
+        buf.write("\7\r\u010b\n\r\f\r\16\r\u010e\13\r\3\r\3\r\5\r\u0112\n")
+        buf.write("\r\3\16\3\16\3\16\5\16\u0117\n\16\3\16\3\16\3\16\3\17")
+        buf.write("\3\17\3\20\3\20\3\20\3\20\7\20\u0122\n\20\f\20\16\20\u0125")
+        buf.write("\13\20\3\20\3\20\3\21\3\21\5\21\u012b\n\21\3\22\3\22\3")
+        buf.write("\23\3\23\3\23\3\23\7\23\u0133\n\23\f\23\16\23\u0136\13")
+        buf.write("\23\3\23\5\23\u0139\n\23\3\24\3\24\3\24\7\24\u013e\n\24")
+        buf.write("\f\24\16\24\u0141\13\24\5\24\u0143\n\24\3\25\3\25\3\25")
+        buf.write("\5\25\u0148\n\25\3\26\3\26\3\26\7\26\u014d\n\26\f\26\16")
+        buf.write("\26\u0150\13\26\3\27\3\27\3\27\3\27\3\30\3\30\3\30\3\30")
+        buf.write("\3\30\3\30\3\30\3\30\3\30\3\30\3\30\6\30\u0161\n\30\r")
+        buf.write("\30\16\30\u0162\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30")
+        buf.write("\3\30\3\30\3\30\3\30\3\30\3\30\3\30\5\30\u0174\n\30\3")
+        buf.write("\30\3\30\3\30\3\30\7\30\u017a\n\30\f\30\16\30\u017d\13")
+        buf.write("\30\5\30\u017f\n\30\3\30\3\30\3\30\3\30\5\30\u0185\n\30")
+        buf.write("\3\31\3\31\3\31\3\31\7\31\u018b\n\31\f\31\16\31\u018e")
+        buf.write("\13\31\3\31\3\31\3\32\3\32\3\32\3\32\6\32\u0196\n\32\r")
+        buf.write("\32\16\32\u0197\3\32\3\32\3\32\3\32\3\32\5\32\u019f\n")
+        buf.write("\32\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\34\3\34")
+        buf.write("\3\34\3\34\3\34\3\34\5\34\u01af\n\34\3\35\3\35\3\35\3")
+        buf.write("\35\3\36\3\36\3\36\5\36\u01b8\n\36\3\37\3\37\3\37\3\37")
+        buf.write("\3\37\5\37\u01bf\n\37\3\37\2\3\22 \2\4\6\b\n\f\16\20\22")
+        buf.write("\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<\2\7\3\2$%\3")
+        buf.write("\2&\'\3\2(+\3\2,-\3\2\31\32\2\u01ec\2>\3\2\2\2\4M\3\2")
+        buf.write("\2\2\6O\3\2\2\2\bR\3\2\2\2\nU\3\2\2\2\fW\3\2\2\2\16b\3")
+        buf.write("\2\2\2\20n\3\2\2\2\22\u00be\3\2\2\2\24\u00dc\3\2\2\2\26")
+        buf.write("\u0102\3\2\2\2\30\u0104\3\2\2\2\32\u0113\3\2\2\2\34\u011b")
+        buf.write("\3\2\2\2\36\u011d\3\2\2\2 \u012a\3\2\2\2\"\u012c\3\2\2")
+        buf.write("\2$\u0138\3\2\2\2&\u0142\3\2\2\2(\u0144\3\2\2\2*\u0149")
+        buf.write("\3\2\2\2,\u0151\3\2\2\2.\u0184\3\2\2\2\60\u0186\3\2\2")
+        buf.write("\2\62\u019e\3\2\2\2\64\u01a0\3\2\2\2\66\u01ae\3\2\2\2")
+        buf.write("8\u01b0\3\2\2\2:\u01b7\3\2\2\2<\u01be\3\2\2\2>F\7\37\2")
+        buf.write("\2?A\5\26\f\2@?\3\2\2\2AD\3\2\2\2B@\3\2\2\2BC\3\2\2\2")
+        buf.write("CG\3\2\2\2DB\3\2\2\2EG\5\22\n\2FB\3\2\2\2FE\3\2\2\2GI")
+        buf.write("\3\2\2\2HJ\7\63\2\2IH\3\2\2\2IJ\3\2\2\2JK\3\2\2\2KL\7")
+        buf.write("\2\2\3L\3\3\2\2\2MN\7/\2\2N\5\3\2\2\2OP\7\3\2\2PQ\7/\2")
+        buf.write("\2Q\7\3\2\2\2RS\7\4\2\2ST\7/\2\2T\t\3\2\2\2UV\7/\2\2V")
+        buf.write("\13\3\2\2\2WX\7\4\2\2XY\7\62\2\2Y\r\3\2\2\2Z_\5\22\n\2")
+        buf.write("[\\\7\5\2\2\\^\5\22\n\2][\3\2\2\2^a\3\2\2\2_]\3\2\2\2")
+        buf.write("_`\3\2\2\2`c\3\2\2\2a_\3\2\2\2bZ\3\2\2\2bc\3\2\2\2c\17")
+        buf.write("\3\2\2\2do\5\16\b\2ef\5\22\n\2fg\7\5\2\2gi\3\2\2\2he\3")
+        buf.write("\2\2\2il\3\2\2\2jh\3\2\2\2jk\3\2\2\2km\3\2\2\2lj\3\2\2")
+        buf.write("\2mo\5*\26\2nd\3\2\2\2nj\3\2\2\2o\21\3\2\2\2pq\b\n\1\2")
+        buf.write("qr\7\6\2\2rs\5\22\n\2st\7\7\2\2t\u00bf\3\2\2\2uv\7\b\2")
+        buf.write("\2vw\5\22\n\2wx\7\t\2\2x\u00bf\3\2\2\2yz\7\'\2\2z\u00bf")
+        buf.write("\5\22\n\26{\u00bf\5\24\13\2|}\7\6\2\2}\u00bf\7\7\2\2~")
+        buf.write("\177\7\6\2\2\177\u0080\5\22\n\2\u0080\u0081\7\5\2\2\u0081")
+        buf.write("\u0082\7\7\2\2\u0082\u00bf\3\2\2\2\u0083\u0084\7\6\2\2")
+        buf.write("\u0084\u0087\5\22\n\2\u0085\u0086\7\5\2\2\u0086\u0088")
+        buf.write("\5\22\n\2\u0087\u0085\3\2\2\2\u0088\u0089\3\2\2\2\u0089")
+        buf.write("\u0087\3\2\2\2\u0089\u008a\3\2\2\2\u008a\u008b\3\2\2\2")
+        buf.write("\u008b\u008c\7\7\2\2\u008c\u00bf\3\2\2\2\u008d\u0096\7")
+        buf.write("\n\2\2\u008e\u0093\5\22\n\2\u008f\u0090\7\5\2\2\u0090")
+        buf.write("\u0092\5\22\n\2\u0091\u008f\3\2\2\2\u0092\u0095\3\2\2")
+        buf.write("\2\u0093\u0091\3\2\2\2\u0093\u0094\3\2\2\2\u0094\u0097")
+        buf.write("\3\2\2\2\u0095\u0093\3\2\2\2\u0096\u008e\3\2\2\2\u0096")
+        buf.write("\u0097\3\2\2\2\u0097\u0098\3\2\2\2\u0098\u00bf\7\13\2")
+        buf.write("\2\u0099\u009a\7\f\2\2\u009a\u009b\7\6\2\2\u009b\u009c")
+        buf.write("\5\22\n\2\u009c\u009d\7\7\2\2\u009d\u009e\58\35\2\u009e")
+        buf.write("\u009f\7\r\2\2\u009f\u00a0\58\35\2\u00a0\u00bf\3\2\2\2")
+        buf.write("\u00a1\u00a2\5\34\17\2\u00a2\u00a3\7\6\2\2\u00a3\u00a4")
+        buf.write("\5\22\n\2\u00a4\u00a5\7\7\2\2\u00a5\u00a7\7\b\2\2\u00a6")
+        buf.write("\u00a8\5\32\16\2\u00a7\u00a6\3\2\2\2\u00a8\u00a9\3\2\2")
+        buf.write("\2\u00a9\u00a7\3\2\2\2\u00a9\u00aa\3\2\2\2\u00aa\u00ab")
+        buf.write("\3\2\2\2\u00ab\u00ac\7\t\2\2\u00ac\u00bf\3\2\2\2\u00ad")
+        buf.write("\u00ae\7\17\2\2\u00ae\u00af\5(\25\2\u00af\u00b0\7\20\2")
+        buf.write("\2\u00b0\u00b1\5\22\n\2\u00b1\u00b2\7\21\2\2\u00b2\u00b3")
+        buf.write("\5\22\n\t\u00b3\u00bf\3\2\2\2\u00b4\u00b5\5\f\7\2\u00b5")
+        buf.write("\u00b6\7\20\2\2\u00b6\u00b7\5\22\n\2\u00b7\u00b8\7\21")
+        buf.write("\2\2\u00b8\u00b9\5\22\n\7\u00b9\u00bf\3\2\2\2\u00ba\u00bf")
+        buf.write("\5<\37\2\u00bb\u00bf\5:\36\2\u00bc\u00bf\5\64\33\2\u00bd")
+        buf.write("\u00bf\7#\2\2\u00bep\3\2\2\2\u00beu\3\2\2\2\u00bey\3\2")
+        buf.write("\2\2\u00be{\3\2\2\2\u00be|\3\2\2\2\u00be~\3\2\2\2\u00be")
+        buf.write("\u0083\3\2\2\2\u00be\u008d\3\2\2\2\u00be\u0099\3\2\2\2")
+        buf.write("\u00be\u00a1\3\2\2\2\u00be\u00ad\3\2\2\2\u00be\u00b4\3")
+        buf.write("\2\2\2\u00be\u00ba\3\2\2\2\u00be\u00bb\3\2\2\2\u00be\u00bc")
+        buf.write("\3\2\2\2\u00be\u00bd\3\2\2\2\u00bf\u00d9\3\2\2\2\u00c0")
+        buf.write("\u00c1\f\25\2\2\u00c1\u00c2\t\2\2\2\u00c2\u00d8\5\22\n")
+        buf.write("\26\u00c3\u00c4\f\24\2\2\u00c4\u00c5\t\3\2\2\u00c5\u00d8")
+        buf.write("\5\22\n\25\u00c6\u00c7\f\23\2\2\u00c7\u00c8\t\4\2\2\u00c8")
+        buf.write("\u00d8\5\22\n\24\u00c9\u00ca\f\22\2\2\u00ca\u00cb\t\5")
+        buf.write("\2\2\u00cb\u00d8\5\22\n\23\u00cc\u00cd\f\b\2\2\u00cd\u00ce")
+        buf.write("\7\22\2\2\u00ce\u00d8\5\22\n\t\u00cf\u00d0\f\27\2\2\u00d0")
+        buf.write("\u00d1\7\6\2\2\u00d1\u00d2\5\20\t\2\u00d2\u00d3\7\7\2")
+        buf.write("\2\u00d3\u00d8\3\2\2\2\u00d4\u00d5\f\n\2\2\u00d5\u00d6")
+        buf.write("\7\16\2\2\u00d6\u00d8\7\62\2\2\u00d7\u00c0\3\2\2\2\u00d7")
+        buf.write("\u00c3\3\2\2\2\u00d7\u00c6\3\2\2\2\u00d7\u00c9\3\2\2\2")
+        buf.write("\u00d7\u00cc\3\2\2\2\u00d7\u00cf\3\2\2\2\u00d7\u00d4\3")
+        buf.write("\2\2\2\u00d8\u00db\3\2\2\2\u00d9\u00d7\3\2\2\2\u00d9\u00da")
+        buf.write("\3\2\2\2\u00da\23\3\2\2\2\u00db\u00d9\3\2\2\2\u00dc\u00de")
+        buf.write("\7\23\2\2\u00dd\u00df\5\60\31\2\u00de\u00dd\3\2\2\2\u00de")
+        buf.write("\u00df\3\2\2\2\u00df\u00e0\3\2\2\2\u00e0\u00e1\7\6\2\2")
+        buf.write("\u00e1\u00e2\5$\23\2\u00e2\u00e5\7\7\2\2\u00e3\u00e4\7")
+        buf.write("\24\2\2\u00e4\u00e6\5.\30\2\u00e5\u00e3\3\2\2\2\u00e5")
+        buf.write("\u00e6\3\2\2\2\u00e6\u00e7\3\2\2\2\u00e7\u00e8\58\35\2")
+        buf.write("\u00e8\25\3\2\2\2\u00e9\u00ea\7\25\2\2\u00ea\u00ec\5\6")
+        buf.write("\4\2\u00eb\u00ed\5\60\31\2\u00ec\u00eb\3\2\2\2\u00ec\u00ed")
+        buf.write("\3\2\2\2\u00ed\u00ee\3\2\2\2\u00ee\u00ef\7\6\2\2\u00ef")
+        buf.write("\u00f0\5$\23\2\u00f0\u00f3\7\7\2\2\u00f1\u00f2\7\24\2")
+        buf.write("\2\u00f2\u00f4\5.\30\2\u00f3\u00f1\3\2\2\2\u00f3\u00f4")
+        buf.write("\3\2\2\2\u00f4\u00f5\3\2\2\2\u00f5\u00f6\58\35\2\u00f6")
+        buf.write("\u0103\3\2\2\2\u00f7\u00f8\7\26\2\2\u00f8\u00fa\5\n\6")
+        buf.write("\2\u00f9\u00fb\5\60\31\2\u00fa\u00f9\3\2\2\2\u00fa\u00fb")
+        buf.write("\3\2\2\2\u00fb\u00fc\3\2\2\2\u00fc\u00fe\7\20\2\2\u00fd")
+        buf.write("\u00ff\5\30\r\2\u00fe\u00fd\3\2\2\2\u00ff\u0100\3\2\2")
+        buf.write("\2\u0100\u00fe\3\2\2\2\u0100\u0101\3\2\2\2\u0101\u0103")
+        buf.write("\3\2\2\2\u0102\u00e9\3\2\2\2\u0102\u00f7\3\2\2\2\u0103")
+        buf.write("\27\3\2\2\2\u0104\u0105\7\27\2\2\u0105\u0111\5\"\22\2")
+        buf.write("\u0106\u0107\7\6\2\2\u0107\u010c\5.\30\2\u0108\u0109\7")
+        buf.write("\5\2\2\u0109\u010b\5.\30\2\u010a\u0108\3\2\2\2\u010b\u010e")
+        buf.write("\3\2\2\2\u010c\u010a\3\2\2\2\u010c\u010d\3\2\2\2\u010d")
+        buf.write("\u010f\3\2\2\2\u010e\u010c\3\2\2\2\u010f\u0110\7\7\2\2")
+        buf.write("\u0110\u0112\3\2\2\2\u0111\u0106\3\2\2\2\u0111\u0112\3")
+        buf.write("\2\2\2\u0112\31\3\2\2\2\u0113\u0114\7\27\2\2\u0114\u0116")
+        buf.write("\5\"\22\2\u0115\u0117\5\36\20\2\u0116\u0115\3\2\2\2\u0116")
+        buf.write("\u0117\3\2\2\2\u0117\u0118\3\2\2\2\u0118\u0119\7\30\2")
+        buf.write("\2\u0119\u011a\5\22\n\2\u011a\33\3\2\2\2\u011b\u011c\t")
+        buf.write("\6\2\2\u011c\35\3\2\2\2\u011d\u011e\7\6\2\2\u011e\u0123")
+        buf.write("\5 \21\2\u011f\u0120\7\5\2\2\u0120\u0122\5 \21\2\u0121")
+        buf.write("\u011f\3\2\2\2\u0122\u0125\3\2\2\2\u0123\u0121\3\2\2\2")
+        buf.write("\u0123\u0124\3\2\2\2\u0124\u0126\3\2\2\2\u0125\u0123\3")
+        buf.write("\2\2\2\u0126\u0127\7\7\2\2\u0127\37\3\2\2\2\u0128\u012b")
+        buf.write("\7\33\2\2\u0129\u012b\5\b\5\2\u012a\u0128\3\2\2\2\u012a")
+        buf.write("\u0129\3\2\2\2\u012b!\3\2\2\2\u012c\u012d\7/\2\2\u012d")
+        buf.write("#\3\2\2\2\u012e\u0139\5&\24\2\u012f\u0130\5(\25\2\u0130")
+        buf.write("\u0131\7\5\2\2\u0131\u0133\3\2\2\2\u0132\u012f\3\2\2\2")
+        buf.write("\u0133\u0136\3\2\2\2\u0134\u0132\3\2\2\2\u0134\u0135\3")
+        buf.write("\2\2\2\u0135\u0137\3\2\2\2\u0136\u0134\3\2\2\2\u0137\u0139")
+        buf.write("\5*\26\2\u0138\u012e\3\2\2\2\u0138\u0134\3\2\2\2\u0139")
+        buf.write("%\3\2\2\2\u013a\u013f\5(\25\2\u013b\u013c\7\5\2\2\u013c")
+        buf.write("\u013e\5(\25\2\u013d\u013b\3\2\2\2\u013e\u0141\3\2\2\2")
+        buf.write("\u013f\u013d\3\2\2\2\u013f\u0140\3\2\2\2\u0140\u0143\3")
+        buf.write("\2\2\2\u0141\u013f\3\2\2\2\u0142\u013a\3\2\2\2\u0142\u0143")
+        buf.write("\3\2\2\2\u0143\'\3\2\2\2\u0144\u0147\5\b\5\2\u0145\u0146")
+        buf.write("\7\34\2\2\u0146\u0148\5.\30\2\u0147\u0145\3\2\2\2\u0147")
+        buf.write("\u0148\3\2\2\2\u0148)\3\2\2\2\u0149\u014e\5,\27\2\u014a")
+        buf.write("\u014b\7\5\2\2\u014b\u014d\5,\27\2\u014c\u014a\3\2\2\2")
+        buf.write("\u014d\u0150\3\2\2\2\u014e\u014c\3\2\2\2\u014e\u014f\3")
+        buf.write("\2\2\2\u014f+\3\2\2\2\u0150\u014e\3\2\2\2\u0151\u0152")
+        buf.write("\7/\2\2\u0152\u0153\7\20\2\2\u0153\u0154\5\22\n\2\u0154")
+        buf.write("-\3\2\2\2\u0155\u0156\7\6\2\2\u0156\u0185\7\7\2\2\u0157")
+        buf.write("\u0158\7\6\2\2\u0158\u0159\5.\30\2\u0159\u015a\7\5\2\2")
+        buf.write("\u015a\u015b\7\7\2\2\u015b\u0185\3\2\2\2\u015c\u015d\7")
+        buf.write("\6\2\2\u015d\u0160\5.\30\2\u015e\u015f\7\5\2\2\u015f\u0161")
+        buf.write("\5.\30\2\u0160\u015e\3\2\2\2\u0161\u0162\3\2\2\2\u0162")
+        buf.write("\u0160\3\2\2\2\u0162\u0163\3\2\2\2\u0163\u0164\3\2\2\2")
+        buf.write("\u0164\u0165\7\7\2\2\u0165\u0185\3\2\2\2\u0166\u0167\5")
+        buf.write("\n\6\2\u0167\u0168\5\60\31\2\u0168\u0185\3\2\2\2\u0169")
+        buf.write("\u0185\5\n\6\2\u016a\u016b\7\35\2\2\u016b\u016c\7\n\2")
+        buf.write("\2\u016c\u016d\5\62\32\2\u016d\u016e\7\5\2\2\u016e\u016f")
+        buf.write("\5.\30\2\u016f\u0170\7\13\2\2\u0170\u0185\3\2\2\2\u0171")
+        buf.write("\u0173\7\23\2\2\u0172\u0174\5\60\31\2\u0173\u0172\3\2")
+        buf.write("\2\2\u0173\u0174\3\2\2\2\u0174\u0175\3\2\2\2\u0175\u017e")
+        buf.write("\7\6\2\2\u0176\u017b\5.\30\2\u0177\u0178\7\5\2\2\u0178")
+        buf.write("\u017a\5.\30\2\u0179\u0177\3\2\2\2\u017a\u017d\3\2\2\2")
+        buf.write("\u017b\u0179\3\2\2\2\u017b\u017c\3\2\2\2\u017c\u017f\3")
+        buf.write("\2\2\2\u017d\u017b\3\2\2\2\u017e\u0176\3\2\2\2\u017e\u017f")
+        buf.write("\3\2\2\2\u017f\u0180\3\2\2\2\u0180\u0181\7\7\2\2\u0181")
+        buf.write("\u0182\7\24\2\2\u0182\u0185\5.\30\2\u0183\u0185\7\33\2")
+        buf.write("\2\u0184\u0155\3\2\2\2\u0184\u0157\3\2\2\2\u0184\u015c")
+        buf.write("\3\2\2\2\u0184\u0166\3\2\2\2\u0184\u0169\3\2\2\2\u0184")
+        buf.write("\u016a\3\2\2\2\u0184\u0171\3\2\2\2\u0184\u0183\3\2\2\2")
+        buf.write("\u0185/\3\2\2\2\u0186\u0187\7\n\2\2\u0187\u018c\5\n\6")
+        buf.write("\2\u0188\u0189\7\5\2\2\u0189\u018b\5\n\6\2\u018a\u0188")
+        buf.write("\3\2\2\2\u018b\u018e\3\2\2\2\u018c\u018a\3\2\2\2\u018c")
+        buf.write("\u018d\3\2\2\2\u018d\u018f\3\2\2\2\u018e\u018c\3\2\2\2")
+        buf.write("\u018f\u0190\7\13\2\2\u0190\61\3\2\2\2\u0191\u0192\7\6")
+        buf.write("\2\2\u0192\u0195\5\66\34\2\u0193\u0194\7\5\2\2\u0194\u0196")
+        buf.write("\5\66\34\2\u0195\u0193\3\2\2\2\u0196\u0197\3\2\2\2\u0197")
+        buf.write("\u0195\3\2\2\2\u0197\u0198\3\2\2\2\u0198\u0199\3\2\2\2")
+        buf.write("\u0199\u019a\7\7\2\2\u019a\u019f\3\2\2\2\u019b\u019c\7")
+        buf.write("\6\2\2\u019c\u019f\7\7\2\2\u019d\u019f\5\66\34\2\u019e")
+        buf.write("\u0191\3\2\2\2\u019e\u019b\3\2\2\2\u019e\u019d\3\2\2\2")
+        buf.write("\u019f\63\3\2\2\2\u01a0\u01a1\7\36\2\2\u01a1\u01a2\7\n")
+        buf.write("\2\2\u01a2\u01a3\7/\2\2\u01a3\u01a4\7\13\2\2\u01a4\u01a5")
+        buf.write("\7\n\2\2\u01a5\u01a6\7\62\2\2\u01a6\u01a7\7\13\2\2\u01a7")
+        buf.write("\65\3\2\2\2\u01a8\u01af\5\64\33\2\u01a9\u01aa\7\6\2\2")
+        buf.write("\u01aa\u01ab\5\66\34\2\u01ab\u01ac\7\7\2\2\u01ac\u01af")
+        buf.write("\3\2\2\2\u01ad\u01af\7\62\2\2\u01ae\u01a8\3\2\2\2\u01ae")
+        buf.write("\u01a9\3\2\2\2\u01ae\u01ad\3\2\2\2\u01af\67\3\2\2\2\u01b0")
+        buf.write("\u01b1\7\b\2\2\u01b1\u01b2\5\22\n\2\u01b2\u01b3\7\t\2")
+        buf.write("\2\u01b39\3\2\2\2\u01b4\u01b8\7\61\2\2\u01b5\u01b8\7\62")
+        buf.write("\2\2\u01b6\u01b8\7.\2\2\u01b7\u01b4\3\2\2\2\u01b7\u01b5")
+        buf.write("\3\2\2\2\u01b7\u01b6\3\2\2\2\u01b8;\3\2\2\2\u01b9\u01bf")
+        buf.write("\5\4\3\2\u01ba\u01bf\5\6\4\2\u01bb\u01bf\5\b\5\2\u01bc")
+        buf.write("\u01bf\5.\30\2\u01bd\u01bf\5\f\7\2\u01be\u01b9\3\2\2\2")
+        buf.write("\u01be\u01ba\3\2\2\2\u01be\u01bb\3\2\2\2\u01be\u01bc\3")
+        buf.write("\2\2\2\u01be\u01bd\3\2\2\2\u01bf=\3\2\2\2-BFI_bjn\u0089")
+        buf.write("\u0093\u0096\u00a9\u00be\u00d7\u00d9\u00de\u00e5\u00ec")
+        buf.write("\u00f3\u00fa\u0100\u0102\u010c\u0111\u0116\u0123\u012a")
+        buf.write("\u0134\u0138\u013f\u0142\u0147\u014e\u0162\u0173\u017b")
+        buf.write("\u017e\u0184\u018c\u0197\u019e\u01ae\u01b7\u01be")
         return buf.getvalue()
 
 
@@ -214,12 +237,13 @@ class RelayParser ( Parser ):
     sharedContextCache = PredictionContextCache()
 
     literalNames = [ "<INVALID>", "'@'", "'%'", "','", "'('", "')'", "'{'", 
-                     "'}'", "'.'", "'['", "']'", "'if'", "'else'", "'let'", 
+                     "'}'", "'['", "']'", "'if'", "'else'", "'.'", "'let'", 
                      "'='", "';'", "';;'", "'fn'", "'->'", "'def'", "'type'", 
-                     "'|'", "':'", "'Tensor'", "'_'", "'meta'", "'v0.0.3'", 
-                     "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
-                     "'*'", "'/'", "'+'", "'-'", "'<'", "'>'", "'<='", "'>='", 
-                     "'=='", "'!='", "<INVALID>", "<INVALID>", "'int64'" ]
+                     "'|'", "'=>'", "'match'", "'match?'", "'_'", "':'", 
+                     "'Tensor'", "'meta'", "'v0.0.3'", "<INVALID>", "<INVALID>", 
+                     "<INVALID>", "<INVALID>", "'*'", "'/'", "'+'", "'-'", 
+                     "'<'", "'>'", "'<='", "'>='", "'=='", "'!='", "<INVALID>", 
+                     "<INVALID>", "'int64'" ]
 
     symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
@@ -227,10 +251,11 @@ class RelayParser ( Parser ):
                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
-                      "<INVALID>", "<INVALID>", "SEMVER", "COMMENT", "WS", 
-                      "LINE_COMMENT", "QUOTED_STRING", "MUL", "DIV", "ADD", 
-                      "SUB", "LT", "GT", "LE", "GE", "EQ", "NE", "BOOL_LIT", 
-                      "CNAME", "DATATYPE", "FLOAT", "NAT", "METADATA" ]
+                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
+                      "<INVALID>", "SEMVER", "COMMENT", "WS", "LINE_COMMENT", 
+                      "QUOTED_STRING", "MUL", "DIV", "ADD", "SUB", "LT", 
+                      "GT", "LE", "GE", "EQ", "NE", "BOOL_LIT", "CNAME", 
+                      "DATATYPE", "FLOAT", "NAT", "METADATA" ]
 
     RULE_prog = 0
     RULE_opIdent = 1
@@ -243,25 +268,30 @@ class RelayParser ( Parser ):
     RULE_expr = 8
     RULE_func = 9
     RULE_defn = 10
-    RULE_adtVariant = 11
-    RULE_variantName = 12
-    RULE_argList = 13
-    RULE_varList = 14
-    RULE_var = 15
-    RULE_attrSeq = 16
-    RULE_attr = 17
-    RULE_typeExpr = 18
-    RULE_typeParamList = 19
-    RULE_shapeList = 20
-    RULE_meta = 21
-    RULE_shape = 22
-    RULE_body = 23
-    RULE_scalar = 24
-    RULE_ident = 25
+    RULE_adtConstructor = 11
+    RULE_matchClause = 12
+    RULE_matchType = 13
+    RULE_patternList = 14
+    RULE_pattern = 15
+    RULE_constructorName = 16
+    RULE_argList = 17
+    RULE_varList = 18
+    RULE_var = 19
+    RULE_attrSeq = 20
+    RULE_attr = 21
+    RULE_typeExpr = 22
+    RULE_typeParamList = 23
+    RULE_shapeList = 24
+    RULE_meta = 25
+    RULE_shape = 26
+    RULE_body = 27
+    RULE_scalar = 28
+    RULE_ident = 29
 
     ruleNames =  [ "prog", "opIdent", "globalVar", "localVar", "typeIdent", 
                    "graphVar", "exprList", "callList", "expr", "func", "defn", 
-                   "adtVariant", "variantName", "argList", "varList", "var", 
+                   "adtConstructor", "matchClause", "matchType", "patternList", 
+                   "pattern", "constructorName", "argList", "varList", "var", 
                    "attrSeq", "attr", "typeExpr", "typeParamList", "shapeList", 
                    "meta", "shape", "body", "scalar", "ident" ]
 
@@ -291,27 +321,30 @@ class RelayParser ( Parser ):
     T__22=23
     T__23=24
     T__24=25
-    SEMVER=26
-    COMMENT=27
-    WS=28
-    LINE_COMMENT=29
-    QUOTED_STRING=30
-    MUL=31
-    DIV=32
-    ADD=33
-    SUB=34
-    LT=35
-    GT=36
-    LE=37
-    GE=38
-    EQ=39
-    NE=40
-    BOOL_LIT=41
-    CNAME=42
-    DATATYPE=43
-    FLOAT=44
-    NAT=45
-    METADATA=46
+    T__25=26
+    T__26=27
+    T__27=28
+    SEMVER=29
+    COMMENT=30
+    WS=31
+    LINE_COMMENT=32
+    QUOTED_STRING=33
+    MUL=34
+    DIV=35
+    ADD=36
+    SUB=37
+    LT=38
+    GT=39
+    LE=40
+    GE=41
+    EQ=42
+    NE=43
+    BOOL_LIT=44
+    CNAME=45
+    DATATYPE=46
+    FLOAT=47
+    NAT=48
+    METADATA=49
 
     def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
         super().__init__(input, output)
@@ -367,39 +400,39 @@ def prog(self):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 52
-            self.match(RelayParser.SEMVER)
             self.state = 60
+            self.match(RelayParser.SEMVER)
+            self.state = 68
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [RelayParser.EOF, RelayParser.T__18, RelayParser.T__19, RelayParser.METADATA]:
-                self.state = 56
+                self.state = 64
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while _la==RelayParser.T__18 or _la==RelayParser.T__19:
-                    self.state = 53
+                    self.state = 61
                     self.defn()
-                    self.state = 58
+                    self.state = 66
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
                 pass
-            elif token in [RelayParser.T__0, RelayParser.T__1, RelayParser.T__3, RelayParser.T__5, RelayParser.T__8, RelayParser.T__10, RelayParser.T__12, RelayParser.T__16, RelayParser.T__22, RelayParser.T__23, RelayParser.T__24, RelayParser.QUOTED_STRING, RelayParser.SUB, RelayParser.BOOL_LIT, RelayParser.CNAME, RelayParser.FLOAT, RelayParser.NAT]:
-                self.state = 59
+            elif token in [RelayParser.T__0, RelayParser.T__1, RelayParser.T__3, RelayParser.T__5, RelayParser.T__7, RelayParser.T__9, RelayParser.T__12, RelayParser.T__16, RelayParser.T__22, RelayParser.T__23, RelayParser.T__24, RelayParser.T__26, RelayParser.T__27, RelayParser.QUOTED_STRING, RelayParser.SUB, RelayParser.BOOL_LIT, RelayParser.CNAME, RelayParser.FLOAT, RelayParser.NAT]:
+                self.state = 67
                 self.expr(0)
                 pass
             else:
                 raise NoViableAltException(self)
 
-            self.state = 63
+            self.state = 71
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==RelayParser.METADATA:
-                self.state = 62
+                self.state = 70
                 self.match(RelayParser.METADATA)
 
 
-            self.state = 65
+            self.state = 73
             self.match(RelayParser.EOF)
         except RecognitionException as re:
             localctx.exception = re
@@ -437,7 +470,7 @@ def opIdent(self):
         self.enterRule(localctx, 2, self.RULE_opIdent)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 67
+            self.state = 75
             self.match(RelayParser.CNAME)
         except RecognitionException as re:
             localctx.exception = re
@@ -475,9 +508,9 @@ def globalVar(self):
         self.enterRule(localctx, 4, self.RULE_globalVar)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 69
+            self.state = 77
             self.match(RelayParser.T__0)
-            self.state = 70
+            self.state = 78
             self.match(RelayParser.CNAME)
         except RecognitionException as re:
             localctx.exception = re
@@ -515,9 +548,9 @@ def localVar(self):
         self.enterRule(localctx, 6, self.RULE_localVar)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 72
+            self.state = 80
             self.match(RelayParser.T__1)
-            self.state = 73
+            self.state = 81
             self.match(RelayParser.CNAME)
         except RecognitionException as re:
             localctx.exception = re
@@ -555,7 +588,7 @@ def typeIdent(self):
         self.enterRule(localctx, 8, self.RULE_typeIdent)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 75
+            self.state = 83
             self.match(RelayParser.CNAME)
         except RecognitionException as re:
             localctx.exception = re
@@ -593,9 +626,9 @@ def graphVar(self):
         self.enterRule(localctx, 10, self.RULE_graphVar)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 77
+            self.state = 85
             self.match(RelayParser.T__1)
-            self.state = 78
+            self.state = 86
             self.match(RelayParser.NAT)
         except RecognitionException as re:
             localctx.exception = re
@@ -638,21 +671,21 @@ def exprList(self):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 88
+            self.state = 96
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__0) | (1 << RelayParser.T__1) | (1 << RelayParser.T__3) | (1 << RelayParser.T__5) | (1 << RelayParser.T__8) | (1 << RelayParser.T__10) | (1 << RelayParser.T__12) | (1 << RelayParser.T__16) | (1 << RelayParser.T__22) | (1 << RelayParser.T__23) | (1 << RelayParser.T__24) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
-                self.state = 80
+            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__0) | (1 << RelayParser.T__1) | (1 << RelayParser.T__3) | (1 << RelayParser.T__5) | (1 << RelayParser.T__7) | (1 << RelayParser.T__9) | (1 << RelayParser.T__12) | (1 << RelayParser.T__16) | (1 << RelayParser.T__22) | (1 << RelayParser.T__23) | (1 << RelayParser.T__24) | (1 << RelayParser.T__26) | (1 << RelayParser.T__27) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
+                self.state = 88
                 self.expr(0)
-                self.state = 85
+                self.state = 93
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while _la==RelayParser.T__2:
-                    self.state = 81
+                    self.state = 89
                     self.match(RelayParser.T__2)
-                    self.state = 82
+                    self.state = 90
                     self.expr(0)
-                    self.state = 87
+                    self.state = 95
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
@@ -729,33 +762,33 @@ def callList(self):
         localctx = RelayParser.CallListContext(self, self._ctx, self.state)
         self.enterRule(localctx, 14, self.RULE_callList)
         try:
-            self.state = 100
+            self.state = 108
             self._errHandler.sync(self)
             la_ = self._interp.adaptivePredict(self._input,6,self._ctx)
             if la_ == 1:
                 localctx = RelayParser.CallNoAttrContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 90
+                self.state = 98
                 self.exprList()
                 pass
 
             elif la_ == 2:
                 localctx = RelayParser.CallWithAttrContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 96
+                self.state = 104
                 self._errHandler.sync(self)
                 _alt = self._interp.adaptivePredict(self._input,5,self._ctx)
                 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                     if _alt==1:
-                        self.state = 91
+                        self.state = 99
                         self.expr(0)
-                        self.state = 92
+                        self.state = 100
                         self.match(RelayParser.T__2) 
-                    self.state = 98
+                    self.state = 106
                     self._errHandler.sync(self)
                     _alt = self._interp.adaptivePredict(self._input,5,self._ctx)
 
-                self.state = 99
+                self.state = 107
                 self.attrSeq()
                 pass
 
@@ -818,6 +851,32 @@ def accept(self, visitor:ParseTreeVisitor):
                 return visitor.visitChildren(self)
 
 
+    class MatchContext(ExprContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a RelayParser.ExprContext
+            super().__init__(parser)
+            self.copyFrom(ctx)
+
+        def matchType(self):
+            return self.getTypedRuleContext(RelayParser.MatchTypeContext,0)
+
+        def expr(self):
+            return self.getTypedRuleContext(RelayParser.ExprContext,0)
+
+        def matchClause(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(RelayParser.MatchClauseContext)
+            else:
+                return self.getTypedRuleContext(RelayParser.MatchClauseContext,i)
+
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitMatch" ):
+                return visitor.visitMatch(self)
+            else:
+                return visitor.visitChildren(self)
+
+
     class TensorContext(ExprContext):
 
         def __init__(self, parser, ctx:ParserRuleContext): # actually a RelayParser.ExprContext
@@ -1104,19 +1163,19 @@ def expr(self, _p:int=0):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 168
+            self.state = 188
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,10,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,11,self._ctx)
             if la_ == 1:
                 localctx = RelayParser.ParenContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
 
-                self.state = 103
+                self.state = 111
                 self.match(RelayParser.T__3)
-                self.state = 104
+                self.state = 112
                 self.expr(0)
-                self.state = 105
+                self.state = 113
                 self.match(RelayParser.T__4)
                 pass
 
@@ -1124,11 +1183,11 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.ParenContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 107
+                self.state = 115
                 self.match(RelayParser.T__5)
-                self.state = 108
+                self.state = 116
                 self.expr(0)
-                self.state = 109
+                self.state = 117
                 self.match(RelayParser.T__6)
                 pass
 
@@ -1136,17 +1195,17 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.NegContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 111
+                self.state = 119
                 self.match(RelayParser.SUB)
-                self.state = 112
-                self.expr(19)
+                self.state = 120
+                self.expr(20)
                 pass
 
             elif la_ == 4:
                 localctx = RelayParser.FuncExprContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 113
+                self.state = 121
                 self.func()
                 pass
 
@@ -1154,9 +1213,9 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.TupleContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 114
+                self.state = 122
                 self.match(RelayParser.T__3)
-                self.state = 115
+                self.state = 123
                 self.match(RelayParser.T__4)
                 pass
 
@@ -1164,13 +1223,13 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.TupleContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 116
+                self.state = 124
                 self.match(RelayParser.T__3)
-                self.state = 117
+                self.state = 125
                 self.expr(0)
-                self.state = 118
+                self.state = 126
                 self.match(RelayParser.T__2)
-                self.state = 119
+                self.state = 127
                 self.match(RelayParser.T__4)
                 pass
 
@@ -1178,25 +1237,25 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.TupleContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 121
+                self.state = 129
                 self.match(RelayParser.T__3)
-                self.state = 122
+                self.state = 130
                 self.expr(0)
-                self.state = 125 
+                self.state = 133 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while True:
-                    self.state = 123
+                    self.state = 131
                     self.match(RelayParser.T__2)
-                    self.state = 124
+                    self.state = 132
                     self.expr(0)
-                    self.state = 127 
+                    self.state = 135 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
                     if not (_la==RelayParser.T__2):
                         break
 
-                self.state = 129
+                self.state = 137
                 self.match(RelayParser.T__4)
                 pass
 
@@ -1204,139 +1263,169 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.TensorContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 131
-                self.match(RelayParser.T__8)
-                self.state = 140
+                self.state = 139
+                self.match(RelayParser.T__7)
+                self.state = 148
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__0) | (1 << RelayParser.T__1) | (1 << RelayParser.T__3) | (1 << RelayParser.T__5) | (1 << RelayParser.T__8) | (1 << RelayParser.T__10) | (1 << RelayParser.T__12) | (1 << RelayParser.T__16) | (1 << RelayParser.T__22) | (1 << RelayParser.T__23) | (1 << RelayParser.T__24) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
-                    self.state = 132
+                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__0) | (1 << RelayParser.T__1) | (1 << RelayParser.T__3) | (1 << RelayParser.T__5) | (1 << RelayParser.T__7) | (1 << RelayParser.T__9) | (1 << RelayParser.T__12) | (1 << RelayParser.T__16) | (1 << RelayParser.T__22) | (1 << RelayParser.T__23) | (1 << RelayParser.T__24) | (1 << RelayParser.T__26) | (1 << RelayParser.T__27) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
+                    self.state = 140
                     self.expr(0)
-                    self.state = 137
+                    self.state = 145
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
                     while _la==RelayParser.T__2:
-                        self.state = 133
+                        self.state = 141
                         self.match(RelayParser.T__2)
-                        self.state = 134
+                        self.state = 142
                         self.expr(0)
-                        self.state = 139
+                        self.state = 147
                         self._errHandler.sync(self)
                         _la = self._input.LA(1)
 
 
 
-                self.state = 142
-                self.match(RelayParser.T__9)
+                self.state = 150
+                self.match(RelayParser.T__8)
                 pass
 
             elif la_ == 9:
                 localctx = RelayParser.IfElseContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 143
-                self.match(RelayParser.T__10)
-                self.state = 144
+                self.state = 151
+                self.match(RelayParser.T__9)
+                self.state = 152
                 self.match(RelayParser.T__3)
-                self.state = 145
+                self.state = 153
                 self.expr(0)
-                self.state = 146
+                self.state = 154
                 self.match(RelayParser.T__4)
-                self.state = 147
+                self.state = 155
                 self.body()
-                self.state = 148
-                self.match(RelayParser.T__11)
-                self.state = 149
+                self.state = 156
+                self.match(RelayParser.T__10)
+                self.state = 157
                 self.body()
                 pass
 
             elif la_ == 10:
+                localctx = RelayParser.MatchContext(self, localctx)
+                self._ctx = localctx
+                _prevctx = localctx
+                self.state = 159
+                self.matchType()
+                self.state = 160
+                self.match(RelayParser.T__3)
+                self.state = 161
+                self.expr(0)
+                self.state = 162
+                self.match(RelayParser.T__4)
+                self.state = 163
+                self.match(RelayParser.T__5)
+                self.state = 165 
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                while True:
+                    self.state = 164
+                    self.matchClause()
+                    self.state = 167 
+                    self._errHandler.sync(self)
+                    _la = self._input.LA(1)
+                    if not (_la==RelayParser.T__20):
+                        break
+
+                self.state = 169
+                self.match(RelayParser.T__6)
+                pass
+
+            elif la_ == 11:
                 localctx = RelayParser.LetContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 151
+                self.state = 171
                 self.match(RelayParser.T__12)
-                self.state = 152
+                self.state = 172
                 self.var()
-                self.state = 153
+                self.state = 173
                 self.match(RelayParser.T__13)
-                self.state = 154
+                self.state = 174
                 self.expr(0)
-                self.state = 155
+                self.state = 175
                 self.match(RelayParser.T__14)
-                self.state = 156
+                self.state = 176
                 self.expr(7)
                 pass
 
-            elif la_ == 11:
+            elif la_ == 12:
                 localctx = RelayParser.GraphContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 158
+                self.state = 178
                 self.graphVar()
-                self.state = 159
+                self.state = 179
                 self.match(RelayParser.T__13)
-                self.state = 160
+                self.state = 180
                 self.expr(0)
-                self.state = 161
+                self.state = 181
                 self.match(RelayParser.T__14)
-                self.state = 162
+                self.state = 182
                 self.expr(5)
                 pass
 
-            elif la_ == 12:
+            elif la_ == 13:
                 localctx = RelayParser.IdentExprContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 164
+                self.state = 184
                 self.ident()
                 pass
 
-            elif la_ == 13:
+            elif la_ == 14:
                 localctx = RelayParser.ScalarExprContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 165
+                self.state = 185
                 self.scalar()
                 pass
 
-            elif la_ == 14:
+            elif la_ == 15:
                 localctx = RelayParser.MetaExprContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 166
+                self.state = 186
                 self.meta()
                 pass
 
-            elif la_ == 15:
+            elif la_ == 16:
                 localctx = RelayParser.StringExprContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 167
+                self.state = 187
                 self.match(RelayParser.QUOTED_STRING)
                 pass
 
 
             self._ctx.stop = self._input.LT(-1)
-            self.state = 195
+            self.state = 215
             self._errHandler.sync(self)
-            _alt = self._interp.adaptivePredict(self._input,12,self._ctx)
+            _alt = self._interp.adaptivePredict(self._input,13,self._ctx)
             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                 if _alt==1:
                     if self._parseListeners is not None:
                         self.triggerExitRuleEvent()
                     _prevctx = localctx
-                    self.state = 193
+                    self.state = 213
                     self._errHandler.sync(self)
-                    la_ = self._interp.adaptivePredict(self._input,11,self._ctx)
+                    la_ = self._interp.adaptivePredict(self._input,12,self._ctx)
                     if la_ == 1:
                         localctx = RelayParser.BinOpContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 170
-                        if not self.precpred(self._ctx, 18):
+                        self.state = 190
+                        if not self.precpred(self._ctx, 19):
                             from antlr4.error.Errors import FailedPredicateException
-                            raise FailedPredicateException(self, "self.precpred(self._ctx, 18)")
-                        self.state = 171
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 19)")
+                        self.state = 191
                         localctx.op = self._input.LT(1)
                         _la = self._input.LA(1)
                         if not(_la==RelayParser.MUL or _la==RelayParser.DIV):
@@ -1344,18 +1433,18 @@ def expr(self, _p:int=0):
                         else:
                             self._errHandler.reportMatch(self)
                             self.consume()
-                        self.state = 172
-                        self.expr(19)
+                        self.state = 192
+                        self.expr(20)
                         pass
 
                     elif la_ == 2:
                         localctx = RelayParser.BinOpContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 173
-                        if not self.precpred(self._ctx, 17):
+                        self.state = 193
+                        if not self.precpred(self._ctx, 18):
                             from antlr4.error.Errors import FailedPredicateException
-                            raise FailedPredicateException(self, "self.precpred(self._ctx, 17)")
-                        self.state = 174
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 18)")
+                        self.state = 194
                         localctx.op = self._input.LT(1)
                         _la = self._input.LA(1)
                         if not(_la==RelayParser.ADD or _la==RelayParser.SUB):
@@ -1363,18 +1452,18 @@ def expr(self, _p:int=0):
                         else:
                             self._errHandler.reportMatch(self)
                             self.consume()
-                        self.state = 175
-                        self.expr(18)
+                        self.state = 195
+                        self.expr(19)
                         pass
 
                     elif la_ == 3:
                         localctx = RelayParser.BinOpContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 176
-                        if not self.precpred(self._ctx, 16):
+                        self.state = 196
+                        if not self.precpred(self._ctx, 17):
                             from antlr4.error.Errors import FailedPredicateException
-                            raise FailedPredicateException(self, "self.precpred(self._ctx, 16)")
-                        self.state = 177
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 17)")
+                        self.state = 197
                         localctx.op = self._input.LT(1)
                         _la = self._input.LA(1)
                         if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.LT) | (1 << RelayParser.GT) | (1 << RelayParser.LE) | (1 << RelayParser.GE))) != 0)):
@@ -1382,18 +1471,18 @@ def expr(self, _p:int=0):
                         else:
                             self._errHandler.reportMatch(self)
                             self.consume()
-                        self.state = 178
-                        self.expr(17)
+                        self.state = 198
+                        self.expr(18)
                         pass
 
                     elif la_ == 4:
                         localctx = RelayParser.BinOpContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 179
-                        if not self.precpred(self._ctx, 15):
+                        self.state = 199
+                        if not self.precpred(self._ctx, 16):
                             from antlr4.error.Errors import FailedPredicateException
-                            raise FailedPredicateException(self, "self.precpred(self._ctx, 15)")
-                        self.state = 180
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 16)")
+                        self.state = 200
                         localctx.op = self._input.LT(1)
                         _la = self._input.LA(1)
                         if not(_la==RelayParser.EQ or _la==RelayParser.NE):
@@ -1401,55 +1490,55 @@ def expr(self, _p:int=0):
                         else:
                             self._errHandler.reportMatch(self)
                             self.consume()
-                        self.state = 181
-                        self.expr(16)
+                        self.state = 201
+                        self.expr(17)
                         pass
 
                     elif la_ == 5:
                         localctx = RelayParser.LetContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 182
+                        self.state = 202
                         if not self.precpred(self._ctx, 6):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
-                        self.state = 183
+                        self.state = 203
                         self.match(RelayParser.T__15)
-                        self.state = 184
+                        self.state = 204
                         self.expr(7)
                         pass
 
                     elif la_ == 6:
                         localctx = RelayParser.CallContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 185
-                        if not self.precpred(self._ctx, 20):
+                        self.state = 205
+                        if not self.precpred(self._ctx, 21):
                             from antlr4.error.Errors import FailedPredicateException
-                            raise FailedPredicateException(self, "self.precpred(self._ctx, 20)")
-                        self.state = 186
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 21)")
+                        self.state = 206
                         self.match(RelayParser.T__3)
-                        self.state = 187
+                        self.state = 207
                         self.callList()
-                        self.state = 188
+                        self.state = 208
                         self.match(RelayParser.T__4)
                         pass
 
                     elif la_ == 7:
                         localctx = RelayParser.ProjectionContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 190
-                        if not self.precpred(self._ctx, 10):
+                        self.state = 210
+                        if not self.precpred(self._ctx, 8):
                             from antlr4.error.Errors import FailedPredicateException
-                            raise FailedPredicateException(self, "self.precpred(self._ctx, 10)")
-                        self.state = 191
-                        self.match(RelayParser.T__7)
-                        self.state = 192
+                            raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
+                        self.state = 211
+                        self.match(RelayParser.T__11)
+                        self.state = 212
                         self.match(RelayParser.NAT)
                         pass
 
              
-                self.state = 197
+                self.state = 217
                 self._errHandler.sync(self)
-                _alt = self._interp.adaptivePredict(self._input,12,self._ctx)
+                _alt = self._interp.adaptivePredict(self._input,13,self._ctx)
 
         except RecognitionException as re:
             localctx.exception = re
@@ -1501,33 +1590,33 @@ def func(self):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 198
+            self.state = 218
             self.match(RelayParser.T__16)
-            self.state = 200
+            self.state = 220
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==RelayParser.T__8:
-                self.state = 199
+            if _la==RelayParser.T__7:
+                self.state = 219
                 self.typeParamList()
 
 
-            self.state = 202
+            self.state = 222
             self.match(RelayParser.T__3)
-            self.state = 203
+            self.state = 223
             self.argList()
-            self.state = 204
+            self.state = 224
             self.match(RelayParser.T__4)
-            self.state = 207
+            self.state = 227
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==RelayParser.T__17:
-                self.state = 205
+                self.state = 225
                 self.match(RelayParser.T__17)
-                self.state = 206
+                self.state = 226
                 self.typeExpr()
 
 
-            self.state = 209
+            self.state = 229
             self.body()
         except RecognitionException as re:
             localctx.exception = re
@@ -1595,11 +1684,11 @@ def typeIdent(self):
         def typeParamList(self):
             return self.getTypedRuleContext(RelayParser.TypeParamListContext,0)
 
-        def adtVariant(self, i:int=None):
+        def adtConstructor(self, i:int=None):
             if i is None:
-                return self.getTypedRuleContexts(RelayParser.AdtVariantContext)
+                return self.getTypedRuleContexts(RelayParser.AdtConstructorContext)
             else:
-                return self.getTypedRuleContext(RelayParser.AdtVariantContext,i)
+                return self.getTypedRuleContext(RelayParser.AdtConstructorContext,i)
 
 
         def accept(self, visitor:ParseTreeVisitor):
@@ -1616,67 +1705,67 @@ def defn(self):
         self.enterRule(localctx, 20, self.RULE_defn)
         self._la = 0 # Token type
         try:
-            self.state = 236
+            self.state = 256
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [RelayParser.T__18]:
                 localctx = RelayParser.FuncDefnContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 211
+                self.state = 231
                 self.match(RelayParser.T__18)
-                self.state = 212
+                self.state = 232
                 self.globalVar()
-                self.state = 214
+                self.state = 234
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if _la==RelayParser.T__8:
-                    self.state = 213
+                if _la==RelayParser.T__7:
+                    self.state = 233
                     self.typeParamList()
 
 
-                self.state = 216
+                self.state = 236
                 self.match(RelayParser.T__3)
-                self.state = 217
+                self.state = 237
                 self.argList()
-                self.state = 218
+                self.state = 238
                 self.match(RelayParser.T__4)
-                self.state = 221
+                self.state = 241
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if _la==RelayParser.T__17:
-                    self.state = 219
+                    self.state = 239
                     self.match(RelayParser.T__17)
-                    self.state = 220
+                    self.state = 240
                     self.typeExpr()
 
 
-                self.state = 223
+                self.state = 243
                 self.body()
                 pass
             elif token in [RelayParser.T__19]:
                 localctx = RelayParser.AdtDefnContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 225
+                self.state = 245
                 self.match(RelayParser.T__19)
-                self.state = 226
+                self.state = 246
                 self.typeIdent()
-                self.state = 228
+                self.state = 248
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if _la==RelayParser.T__8:
-                    self.state = 227
+                if _la==RelayParser.T__7:
+                    self.state = 247
                     self.typeParamList()
 
 
-                self.state = 230
+                self.state = 250
                 self.match(RelayParser.T__13)
-                self.state = 232 
+                self.state = 252 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while True:
-                    self.state = 231
-                    self.adtVariant()
-                    self.state = 234 
+                    self.state = 251
+                    self.adtConstructor()
+                    self.state = 254 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
                     if not (_la==RelayParser.T__20):
@@ -1695,14 +1784,14 @@ def defn(self):
         return localctx
 
 
-    class AdtVariantContext(ParserRuleContext):
+    class AdtConstructorContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
             super().__init__(parent, invokingState)
             self.parser = parser
 
-        def variantName(self):
-            return self.getTypedRuleContext(RelayParser.VariantNameContext,0)
+        def constructorName(self):
+            return self.getTypedRuleContext(RelayParser.ConstructorNameContext,0)
 
 
         def typeExpr(self, i:int=None):
@@ -1713,49 +1802,49 @@ def typeExpr(self, i:int=None):
 
 
         def getRuleIndex(self):
-            return RelayParser.RULE_adtVariant
+            return RelayParser.RULE_adtConstructor
 
         def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitAdtVariant" ):
-                return visitor.visitAdtVariant(self)
+            if hasattr( visitor, "visitAdtConstructor" ):
+                return visitor.visitAdtConstructor(self)
             else:
                 return visitor.visitChildren(self)
 
 
 
 
-    def adtVariant(self):
+    def adtConstructor(self):
 
-        localctx = RelayParser.AdtVariantContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 22, self.RULE_adtVariant)
+        localctx = RelayParser.AdtConstructorContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 22, self.RULE_adtConstructor)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 238
+            self.state = 258
             self.match(RelayParser.T__20)
-            self.state = 239
-            self.variantName()
-            self.state = 251
+            self.state = 259
+            self.constructorName()
+            self.state = 271
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==RelayParser.T__3:
-                self.state = 240
+                self.state = 260
                 self.match(RelayParser.T__3)
-                self.state = 241
+                self.state = 261
                 self.typeExpr()
-                self.state = 246
+                self.state = 266
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while _la==RelayParser.T__2:
-                    self.state = 242
+                    self.state = 262
                     self.match(RelayParser.T__2)
-                    self.state = 243
+                    self.state = 263
                     self.typeExpr()
-                    self.state = 248
+                    self.state = 268
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
-                self.state = 249
+                self.state = 269
                 self.match(RelayParser.T__4)
 
 
@@ -1768,7 +1857,222 @@ def adtVariant(self):
         return localctx
 
 
-    class VariantNameContext(ParserRuleContext):
+    class MatchClauseContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def constructorName(self):
+            return self.getTypedRuleContext(RelayParser.ConstructorNameContext,0)
+
+
+        def expr(self):
+            return self.getTypedRuleContext(RelayParser.ExprContext,0)
+
+
+        def patternList(self):
+            return self.getTypedRuleContext(RelayParser.PatternListContext,0)
+
+
+        def getRuleIndex(self):
+            return RelayParser.RULE_matchClause
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitMatchClause" ):
+                return visitor.visitMatchClause(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def matchClause(self):
+
+        localctx = RelayParser.MatchClauseContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 24, self.RULE_matchClause)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 273
+            self.match(RelayParser.T__20)
+            self.state = 274
+            self.constructorName()
+            self.state = 276
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            if _la==RelayParser.T__3:
+                self.state = 275
+                self.patternList()
+
+
+            self.state = 278
+            self.match(RelayParser.T__21)
+            self.state = 279
+            self.expr(0)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class MatchTypeContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+
+        def getRuleIndex(self):
+            return RelayParser.RULE_matchType
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitMatchType" ):
+                return visitor.visitMatchType(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def matchType(self):
+
+        localctx = RelayParser.MatchTypeContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 26, self.RULE_matchType)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 281
+            _la = self._input.LA(1)
+            if not(_la==RelayParser.T__22 or _la==RelayParser.T__23):
+                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 PatternListContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def pattern(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(RelayParser.PatternContext)
+            else:
+                return self.getTypedRuleContext(RelayParser.PatternContext,i)
+
+
+        def getRuleIndex(self):
+            return RelayParser.RULE_patternList
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitPatternList" ):
+                return visitor.visitPatternList(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def patternList(self):
+
+        localctx = RelayParser.PatternListContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 28, self.RULE_patternList)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 283
+            self.match(RelayParser.T__3)
+            self.state = 284
+            self.pattern()
+            self.state = 289
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            while _la==RelayParser.T__2:
+                self.state = 285
+                self.match(RelayParser.T__2)
+                self.state = 286
+                self.pattern()
+                self.state = 291
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+
+            self.state = 292
+            self.match(RelayParser.T__4)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class PatternContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def localVar(self):
+            return self.getTypedRuleContext(RelayParser.LocalVarContext,0)
+
+
+        def getRuleIndex(self):
+            return RelayParser.RULE_pattern
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitPattern" ):
+                return visitor.visitPattern(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def pattern(self):
+
+        localctx = RelayParser.PatternContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 30, self.RULE_pattern)
+        try:
+            self.state = 296
+            self._errHandler.sync(self)
+            token = self._input.LA(1)
+            if token in [RelayParser.T__24]:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 294
+                self.match(RelayParser.T__24)
+                pass
+            elif token in [RelayParser.T__1]:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 295
+                self.localVar()
+                pass
+            else:
+                raise NoViableAltException(self)
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class ConstructorNameContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
             super().__init__(parent, invokingState)
@@ -1778,24 +2082,24 @@ def CNAME(self):
             return self.getToken(RelayParser.CNAME, 0)
 
         def getRuleIndex(self):
-            return RelayParser.RULE_variantName
+            return RelayParser.RULE_constructorName
 
         def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitVariantName" ):
-                return visitor.visitVariantName(self)
+            if hasattr( visitor, "visitConstructorName" ):
+                return visitor.visitConstructorName(self)
             else:
                 return visitor.visitChildren(self)
 
 
 
 
-    def variantName(self):
+    def constructorName(self):
 
-        localctx = RelayParser.VariantNameContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 24, self.RULE_variantName)
+        localctx = RelayParser.ConstructorNameContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 32, self.RULE_constructorName)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 253
+            self.state = 298
             self.match(RelayParser.CNAME)
         except RecognitionException as re:
             localctx.exception = re
@@ -1866,35 +2170,35 @@ def accept(self, visitor:ParseTreeVisitor):
     def argList(self):
 
         localctx = RelayParser.ArgListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 26, self.RULE_argList)
+        self.enterRule(localctx, 34, self.RULE_argList)
         self._la = 0 # Token type
         try:
-            self.state = 265
+            self.state = 310
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,23,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,27,self._ctx)
             if la_ == 1:
                 localctx = RelayParser.ArgNoAttrContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 255
+                self.state = 300
                 self.varList()
                 pass
 
             elif la_ == 2:
                 localctx = RelayParser.ArgWithAttrContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 261
+                self.state = 306
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while _la==RelayParser.T__1:
-                    self.state = 256
+                    self.state = 301
                     self.var()
-                    self.state = 257
+                    self.state = 302
                     self.match(RelayParser.T__2)
-                    self.state = 263
+                    self.state = 308
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
-                self.state = 264
+                self.state = 309
                 self.attrSeq()
                 pass
 
@@ -1936,25 +2240,25 @@ def accept(self, visitor:ParseTreeVisitor):
     def varList(self):
 
         localctx = RelayParser.VarListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 28, self.RULE_varList)
+        self.enterRule(localctx, 36, self.RULE_varList)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 275
+            self.state = 320
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==RelayParser.T__1:
-                self.state = 267
+                self.state = 312
                 self.var()
-                self.state = 272
+                self.state = 317
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while _la==RelayParser.T__2:
-                    self.state = 268
+                    self.state = 313
                     self.match(RelayParser.T__2)
-                    self.state = 269
+                    self.state = 314
                     self.var()
-                    self.state = 274
+                    self.state = 319
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
@@ -1998,19 +2302,19 @@ def accept(self, visitor:ParseTreeVisitor):
     def var(self):
 
         localctx = RelayParser.VarContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 30, self.RULE_var)
+        self.enterRule(localctx, 38, self.RULE_var)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 277
+            self.state = 322
             self.localVar()
-            self.state = 280
+            self.state = 325
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==RelayParser.T__21:
-                self.state = 278
-                self.match(RelayParser.T__21)
-                self.state = 279
+            if _la==RelayParser.T__25:
+                self.state = 323
+                self.match(RelayParser.T__25)
+                self.state = 324
                 self.typeExpr()
 
 
@@ -2051,21 +2355,21 @@ def accept(self, visitor:ParseTreeVisitor):
     def attrSeq(self):
 
         localctx = RelayParser.AttrSeqContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 32, self.RULE_attrSeq)
+        self.enterRule(localctx, 40, self.RULE_attrSeq)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 282
+            self.state = 327
             self.attr()
-            self.state = 287
+            self.state = 332
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==RelayParser.T__2:
-                self.state = 283
+                self.state = 328
                 self.match(RelayParser.T__2)
-                self.state = 284
+                self.state = 329
                 self.attr()
-                self.state = 289
+                self.state = 334
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
@@ -2106,14 +2410,14 @@ def accept(self, visitor:ParseTreeVisitor):
     def attr(self):
 
         localctx = RelayParser.AttrContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 34, self.RULE_attr)
+        self.enterRule(localctx, 42, self.RULE_attr)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 290
+            self.state = 335
             self.match(RelayParser.CNAME)
-            self.state = 291
+            self.state = 336
             self.match(RelayParser.T__13)
-            self.state = 292
+            self.state = 337
             self.expr(0)
         except RecognitionException as re:
             localctx.exception = re
@@ -2140,22 +2444,6 @@ def copyFrom(self, ctx:ParserRuleContext):
 
 
 
-    class IntTypeContext(TypeExprContext):
-
-        def __init__(self, parser, ctx:ParserRuleContext): # actually a RelayParser.TypeExprContext
-            super().__init__(parser)
-            self.copyFrom(ctx)
-
-        def NAT(self):
-            return self.getToken(RelayParser.NAT, 0)
-
-        def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitIntType" ):
-                return visitor.visitIntType(self)
-            else:
-                return visitor.visitChildren(self)
-
-
     class TupleTypeContext(TypeExprContext):
 
         def __init__(self, parser, ctx:ParserRuleContext): # actually a RelayParser.TypeExprContext
@@ -2274,147 +2562,140 @@ def accept(self, visitor:ParseTreeVisitor):
     def typeExpr(self):
 
         localctx = RelayParser.TypeExprContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 36, self.RULE_typeExpr)
+        self.enterRule(localctx, 44, self.RULE_typeExpr)
         self._la = 0 # Token type
         try:
-            self.state = 342
+            self.state = 386
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,32,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,36,self._ctx)
             if la_ == 1:
                 localctx = RelayParser.TupleTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 294
+                self.state = 339
                 self.match(RelayParser.T__3)
-                self.state = 295
+                self.state = 340
                 self.match(RelayParser.T__4)
                 pass
 
             elif la_ == 2:
                 localctx = RelayParser.TupleTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 296
+                self.state = 341
                 self.match(RelayParser.T__3)
-                self.state = 297
+                self.state = 342
                 self.typeExpr()
-                self.state = 298
+                self.state = 343
                 self.match(RelayParser.T__2)
-                self.state = 299
+                self.state = 344
                 self.match(RelayParser.T__4)
                 pass
 
             elif la_ == 3:
                 localctx = RelayParser.TupleTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 3)
-                self.state = 301
+                self.state = 346
                 self.match(RelayParser.T__3)
-                self.state = 302
+                self.state = 347
                 self.typeExpr()
-                self.state = 305 
+                self.state = 350 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while True:
-                    self.state = 303
+                    self.state = 348
                     self.match(RelayParser.T__2)
-                    self.state = 304
+                    self.state = 349
                     self.typeExpr()
-                    self.state = 307 
+                    self.state = 352 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
                     if not (_la==RelayParser.T__2):
                         break
 
-                self.state = 309
+                self.state = 354
                 self.match(RelayParser.T__4)
                 pass
 
             elif la_ == 4:
                 localctx = RelayParser.TypeCallTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 4)
-                self.state = 311
+                self.state = 356
                 self.typeIdent()
-                self.state = 312
+                self.state = 357
                 self.typeParamList()
                 pass
 
             elif la_ == 5:
                 localctx = RelayParser.TypeIdentTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 5)
-                self.state = 314
+                self.state = 359
                 self.typeIdent()
                 pass
 
             elif la_ == 6:
                 localctx = RelayParser.TensorTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 6)
-                self.state = 315
-                self.match(RelayParser.T__22)
-                self.state = 316
-                self.match(RelayParser.T__8)
-                self.state = 317
+                self.state = 360
+                self.match(RelayParser.T__26)
+                self.state = 361
+                self.match(RelayParser.T__7)
+                self.state = 362
                 self.shapeList()
-                self.state = 318
+                self.state = 363
                 self.match(RelayParser.T__2)
-                self.state = 319
+                self.state = 364
                 self.typeExpr()
-                self.state = 320
-                self.match(RelayParser.T__9)
+                self.state = 365
+                self.match(RelayParser.T__8)
                 pass
 
             elif la_ == 7:
                 localctx = RelayParser.FuncTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 7)
-                self.state = 322
+                self.state = 367
                 self.match(RelayParser.T__16)
-                self.state = 324
+                self.state = 369
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if _la==RelayParser.T__8:
-                    self.state = 323
+                if _la==RelayParser.T__7:
+                    self.state = 368
                     self.typeParamList()
 
 
-                self.state = 326
+                self.state = 371
                 self.match(RelayParser.T__3)
-                self.state = 335
+                self.state = 380
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__3) | (1 << RelayParser.T__16) | (1 << RelayParser.T__22) | (1 << RelayParser.T__23) | (1 << RelayParser.CNAME) | (1 << RelayParser.NAT))) != 0):
-                    self.state = 327
+                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__3) | (1 << RelayParser.T__16) | (1 << RelayParser.T__24) | (1 << RelayParser.T__26) | (1 << RelayParser.CNAME))) != 0):
+                    self.state = 372
                     self.typeExpr()
-                    self.state = 332
+                    self.state = 377
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
                     while _la==RelayParser.T__2:
-                        self.state = 328
+                        self.state = 373
                         self.match(RelayParser.T__2)
-                        self.state = 329
+                        self.state = 374
                         self.typeExpr()
-                        self.state = 334
+                        self.state = 379
                         self._errHandler.sync(self)
                         _la = self._input.LA(1)
 
 
 
-                self.state = 337
+                self.state = 382
                 self.match(RelayParser.T__4)
-                self.state = 338
+                self.state = 383
                 self.match(RelayParser.T__17)
-                self.state = 339
+                self.state = 384
                 self.typeExpr()
                 pass
 
             elif la_ == 8:
                 localctx = RelayParser.IncompleteTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 8)
-                self.state = 340
-                self.match(RelayParser.T__23)
-                pass
-
-            elif la_ == 9:
-                localctx = RelayParser.IntTypeContext(self, localctx)
-                self.enterOuterAlt(localctx, 9)
-                self.state = 341
-                self.match(RelayParser.NAT)
+                self.state = 385
+                self.match(RelayParser.T__24)
                 pass
 
 
@@ -2455,28 +2736,28 @@ def accept(self, visitor:ParseTreeVisitor):
     def typeParamList(self):
 
         localctx = RelayParser.TypeParamListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 38, self.RULE_typeParamList)
+        self.enterRule(localctx, 46, self.RULE_typeParamList)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 344
-            self.match(RelayParser.T__8)
-            self.state = 345
+            self.state = 388
+            self.match(RelayParser.T__7)
+            self.state = 389
             self.typeIdent()
-            self.state = 350
+            self.state = 394
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==RelayParser.T__2:
-                self.state = 346
+                self.state = 390
                 self.match(RelayParser.T__2)
-                self.state = 347
+                self.state = 391
                 self.typeIdent()
-                self.state = 352
+                self.state = 396
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 353
-            self.match(RelayParser.T__9)
+            self.state = 397
+            self.match(RelayParser.T__8)
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -2514,47 +2795,47 @@ def accept(self, visitor:ParseTreeVisitor):
     def shapeList(self):
 
         localctx = RelayParser.ShapeListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 40, self.RULE_shapeList)
+        self.enterRule(localctx, 48, self.RULE_shapeList)
         self._la = 0 # Token type
         try:
-            self.state = 368
+            self.state = 412
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,35,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,39,self._ctx)
             if la_ == 1:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 355
+                self.state = 399
                 self.match(RelayParser.T__3)
-                self.state = 356
+                self.state = 400
                 self.shape()
-                self.state = 359 
+                self.state = 403 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while True:
-                    self.state = 357
+                    self.state = 401
                     self.match(RelayParser.T__2)
-                    self.state = 358
+                    self.state = 402
                     self.shape()
-                    self.state = 361 
+                    self.state = 405 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
                     if not (_la==RelayParser.T__2):
                         break
 
-                self.state = 363
+                self.state = 407
                 self.match(RelayParser.T__4)
                 pass
 
             elif la_ == 2:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 365
+                self.state = 409
                 self.match(RelayParser.T__3)
-                self.state = 366
+                self.state = 410
                 self.match(RelayParser.T__4)
                 pass
 
             elif la_ == 3:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 367
+                self.state = 411
                 self.shape()
                 pass
 
@@ -2595,23 +2876,23 @@ def accept(self, visitor:ParseTreeVisitor):
     def meta(self):
 
         localctx = RelayParser.MetaContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 42, self.RULE_meta)
+        self.enterRule(localctx, 50, self.RULE_meta)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 370
-            self.match(RelayParser.T__24)
-            self.state = 371
-            self.match(RelayParser.T__8)
-            self.state = 372
+            self.state = 414
+            self.match(RelayParser.T__27)
+            self.state = 415
+            self.match(RelayParser.T__7)
+            self.state = 416
             self.match(RelayParser.CNAME)
-            self.state = 373
-            self.match(RelayParser.T__9)
-            self.state = 374
+            self.state = 417
             self.match(RelayParser.T__8)
-            self.state = 375
+            self.state = 418
+            self.match(RelayParser.T__7)
+            self.state = 419
             self.match(RelayParser.NAT)
-            self.state = 376
-            self.match(RelayParser.T__9)
+            self.state = 420
+            self.match(RelayParser.T__8)
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -2691,31 +2972,31 @@ def accept(self, visitor:ParseTreeVisitor):
     def shape(self):
 
         localctx = RelayParser.ShapeContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 44, self.RULE_shape)
+        self.enterRule(localctx, 52, self.RULE_shape)
         try:
-            self.state = 384
+            self.state = 428
             self._errHandler.sync(self)
             token = self._input.LA(1)
-            if token in [RelayParser.T__24]:
+            if token in [RelayParser.T__27]:
                 localctx = RelayParser.MetaShapeContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 378
+                self.state = 422
                 self.meta()
                 pass
             elif token in [RelayParser.T__3]:
                 localctx = RelayParser.ParensShapeContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 379
+                self.state = 423
                 self.match(RelayParser.T__3)
-                self.state = 380
+                self.state = 424
                 self.shape()
-                self.state = 381
+                self.state = 425
                 self.match(RelayParser.T__4)
                 pass
             elif token in [RelayParser.NAT]:
                 localctx = RelayParser.IntShapeContext(self, localctx)
                 self.enterOuterAlt(localctx, 3)
-                self.state = 383
+                self.state = 427
                 self.match(RelayParser.NAT)
                 pass
             else:
@@ -2755,14 +3036,14 @@ def accept(self, visitor:ParseTreeVisitor):
     def body(self):
 
         localctx = RelayParser.BodyContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 46, self.RULE_body)
+        self.enterRule(localctx, 54, self.RULE_body)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 386
+            self.state = 430
             self.match(RelayParser.T__5)
-            self.state = 387
+            self.state = 431
             self.expr(0)
-            self.state = 388
+            self.state = 432
             self.match(RelayParser.T__6)
         except RecognitionException as re:
             localctx.exception = re
@@ -2841,27 +3122,27 @@ def accept(self, visitor:ParseTreeVisitor):
     def scalar(self):
 
         localctx = RelayParser.ScalarContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 48, self.RULE_scalar)
+        self.enterRule(localctx, 56, self.RULE_scalar)
         try:
-            self.state = 393
+            self.state = 437
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [RelayParser.FLOAT]:
                 localctx = RelayParser.ScalarFloatContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 390
+                self.state = 434
                 self.match(RelayParser.FLOAT)
                 pass
             elif token in [RelayParser.NAT]:
                 localctx = RelayParser.ScalarIntContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 391
+                self.state = 435
                 self.match(RelayParser.NAT)
                 pass
             elif token in [RelayParser.BOOL_LIT]:
                 localctx = RelayParser.ScalarBoolContext(self, localctx)
                 self.enterOuterAlt(localctx, 3)
-                self.state = 392
+                self.state = 436
                 self.match(RelayParser.BOOL_LIT)
                 pass
             else:
@@ -2917,38 +3198,38 @@ def accept(self, visitor:ParseTreeVisitor):
     def ident(self):
 
         localctx = RelayParser.IdentContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 50, self.RULE_ident)
+        self.enterRule(localctx, 58, self.RULE_ident)
         try:
-            self.state = 400
+            self.state = 444
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,38,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,42,self._ctx)
             if la_ == 1:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 395
+                self.state = 439
                 self.opIdent()
                 pass
 
             elif la_ == 2:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 396
+                self.state = 440
                 self.globalVar()
                 pass
 
             elif la_ == 3:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 397
+                self.state = 441
                 self.localVar()
                 pass
 
             elif la_ == 4:
                 self.enterOuterAlt(localctx, 4)
-                self.state = 398
+                self.state = 442
                 self.typeExpr()
                 pass
 
             elif la_ == 5:
                 self.enterOuterAlt(localctx, 5)
-                self.state = 399
+                self.state = 443
                 self.graphVar()
                 pass
 
@@ -2975,19 +3256,19 @@ def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
 
     def expr_sempred(self, localctx:ExprContext, predIndex:int):
             if predIndex == 0:
-                return self.precpred(self._ctx, 18)
+                return self.precpred(self._ctx, 19)
          
 
             if predIndex == 1:
-                return self.precpred(self._ctx, 17)
+                return self.precpred(self._ctx, 18)
          
 
             if predIndex == 2:
-                return self.precpred(self._ctx, 16)
+                return self.precpred(self._ctx, 17)
          
 
             if predIndex == 3:
-                return self.precpred(self._ctx, 15)
+                return self.precpred(self._ctx, 16)
          
 
             if predIndex == 4:
@@ -2995,11 +3276,11 @@ def expr_sempred(self, localctx:ExprContext, predIndex:int):
          
 
             if predIndex == 5:
-                return self.precpred(self._ctx, 20)
+                return self.precpred(self._ctx, 21)
          
 
             if predIndex == 6:
-                return self.precpred(self._ctx, 10)
+                return self.precpred(self._ctx, 8)
          
 
 
diff --git a/python/tvm/relay/grammar/py3/RelayVisitor.py b/python/tvm/relay/grammar/py3/RelayVisitor.py
index 56817e6f8e66..fbb008f1b4d1 100644
--- a/python/tvm/relay/grammar/py3/RelayVisitor.py
+++ b/python/tvm/relay/grammar/py3/RelayVisitor.py
@@ -64,6 +64,11 @@ def visitMetaExpr(self, ctx:RelayParser.MetaExprContext):
         return self.visitChildren(ctx)
 
 
+    # Visit a parse tree produced by RelayParser#match.
+    def visitMatch(self, ctx:RelayParser.MatchContext):
+        return self.visitChildren(ctx)
+
+
     # Visit a parse tree produced by RelayParser#tensor.
     def visitTensor(self, ctx:RelayParser.TensorContext):
         return self.visitChildren(ctx)
@@ -144,13 +149,33 @@ def visitAdtDefn(self, ctx:RelayParser.AdtDefnContext):
         return self.visitChildren(ctx)
 
 
-    # Visit a parse tree produced by RelayParser#adtVariant.
-    def visitAdtVariant(self, ctx:RelayParser.AdtVariantContext):
+    # Visit a parse tree produced by RelayParser#adtConstructor.
+    def visitAdtConstructor(self, ctx:RelayParser.AdtConstructorContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by RelayParser#matchClause.
+    def visitMatchClause(self, ctx:RelayParser.MatchClauseContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by RelayParser#matchType.
+    def visitMatchType(self, ctx:RelayParser.MatchTypeContext):
         return self.visitChildren(ctx)
 
 
-    # Visit a parse tree produced by RelayParser#variantName.
-    def visitVariantName(self, ctx:RelayParser.VariantNameContext):
+    # Visit a parse tree produced by RelayParser#patternList.
+    def visitPatternList(self, ctx:RelayParser.PatternListContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by RelayParser#pattern.
+    def visitPattern(self, ctx:RelayParser.PatternContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by RelayParser#constructorName.
+    def visitConstructorName(self, ctx:RelayParser.ConstructorNameContext):
         return self.visitChildren(ctx)
 
 
@@ -214,11 +239,6 @@ def visitIncompleteType(self, ctx:RelayParser.IncompleteTypeContext):
         return self.visitChildren(ctx)
 
 
-    # Visit a parse tree produced by RelayParser#intType.
-    def visitIntType(self, ctx:RelayParser.IntTypeContext):
-        return self.visitChildren(ctx)
-
-
     # Visit a parse tree produced by RelayParser#typeParamList.
     def visitTypeParamList(self, ctx:RelayParser.TypeParamListContext):
         return self.visitChildren(ctx)
diff --git a/tests/python/relay/test_ir_parser.py b/tests/python/relay/test_ir_parser.py
index 7e33a817925e..f09a1ea4bdde 100644
--- a/tests/python/relay/test_ir_parser.py
+++ b/tests/python/relay/test_ir_parser.py
@@ -73,7 +73,11 @@ def parse_text(code):
 
 def parses_as(code, expr):
     # type: (str, relay.Expr) -> bool
+    print('[ORIGINAL]')
+    print(code)
     parsed = parse_text(code)
+    print('[PRINTED]')
+    print(str(parsed))
     result = alpha_equal(parsed, expr)
     return result
 
@@ -636,12 +640,13 @@ def test_tuple_type():
 
 
 def test_adt_defn():
+    mod = relay.Module()
+
     glob_typ_var = relay.GlobalTypeVar("Ayy")
     prog = relay.TypeData(
             glob_typ_var,
             [],
             [relay.Constructor("Nil", [], glob_typ_var)])
-    mod = relay.Module()
     mod[glob_typ_var] = prog
     assert parses_as(
         """
@@ -653,6 +658,8 @@ def test_adt_defn():
 
 
 def test_multiple_variants():
+    mod = relay.Module()
+
     glob_typ_var = relay.GlobalTypeVar("List")
     typ_var = relay.TypeVar("A")
     prog = relay.TypeData(
@@ -662,13 +669,12 @@ def test_multiple_variants():
                 relay.Constructor("Cons", [typ_var, glob_typ_var(typ_var)], glob_typ_var),
                 relay.Constructor("Nil", [], glob_typ_var),
             ])
-    mod = relay.Module()
     mod[glob_typ_var] = prog
     assert parses_as(
         """
         type List[A] =
-        | Cons(A, List[A])
-        | Nil
+          | Cons(A, List[A])
+          | Nil
         """,
         mod
     )
@@ -690,8 +696,64 @@ def test_multiple_type_params():
     assert parses_as(
         """
         type Either[A, B] =
-        | Left(A)
-        | Right(B)
+          | Left(A)
+          | Right(B)
+        """,
+        mod
+    )
+
+
+def test_match():
+    mod = relay.Module()
+
+    list_var = relay.GlobalTypeVar("List")
+    typ_var = relay.TypeVar("A")
+    cons_constructor = relay.Constructor(
+        "Cons", [typ_var, list_var(typ_var)], list_var)
+    nil_constructor = relay.Constructor("Nil", [], list_var)
+    list_def = relay.TypeData(
+        list_var,
+        [typ_var],
+        [cons_constructor, nil_constructor])
+    mod[list_var] = list_def
+
+    length_var = relay.GlobalVar("length")
+    typ_var = relay.TypeVar("A")
+    input_type = list_var(typ_var)
+    input_var = relay.Var("xs", input_type)
+    rest_var = relay.Var("rest")
+    body = relay.Match(input_var,
+        [relay.Clause(
+            relay.PatternConstructor(
+                cons_constructor,
+                [relay.PatternWildcard(), relay.PatternVar(rest_var)]),
+            relay.add(relay.const(1), relay.Call(length_var, [rest_var]))
+            ),
+         relay.Clause(
+             relay.PatternConstructor(nil_constructor, []),
+             relay.const(0))]
+    )
+    length_func = relay.Function(
+        [input_var],
+        body,
+        int32,
+        [typ_var]
+    )
+    mod[length_var] = length_func
+
+    print('WEEEE')
+    assert parses_as(
+        """
+        type List[A] =
+          | Cons(A, List[A])
+          | Nil
+
+        def @length[A](%xs: List[A]) -> int32 {
+          match (%xs) {
+            | Cons(_, %rest) => 1 + @length(%rest)
+            | Nil => 0
+          }
+        }
         """,
         mod
     )
@@ -720,6 +782,7 @@ def test_multiple_type_params():
     # test_tensor_type()
     # test_function_type()
     # test_tuple_type()
-    test_adt_defn()
-    test_multiple_variants()
-    test_multiple_type_params()
+    # test_adt_defn()
+    # test_multiple_variants()
+    # test_multiple_type_params()
+    test_match()

From 0f27b2205d764016eb517aca7468b0c32126529a Mon Sep 17 00:00:00 2001
From: Logan Weber <weberlo@cs.washington.edu>
Date: Mon, 26 Aug 2019 11:13:08 -0700
Subject: [PATCH 04/29] came to earth in a silver chrome UFO

---
 include/tvm/relay/adt.h                      |   2 +-
 python/tvm/relay/grammar/Relay.g4            |  18 +-
 python/tvm/relay/grammar/py3/RelayLexer.py   | 305 ++++++++--------
 python/tvm/relay/grammar/py3/RelayParser.py  | 361 +++++++++----------
 python/tvm/relay/grammar/py3/RelayVisitor.py |   5 -
 src/relay/ir/pretty_printer.cc               |  61 +++-
 tests/python/relay/test_ir_parser.py         |   4 +-
 7 files changed, 387 insertions(+), 369 deletions(-)

diff --git a/include/tvm/relay/adt.h b/include/tvm/relay/adt.h
index b6343614c5c8..df7943dcb004 100644
--- a/include/tvm/relay/adt.h
+++ b/include/tvm/relay/adt.h
@@ -241,7 +241,7 @@ class MatchNode : public ExprNode {
   /*! \brief The match node clauses. */
   tvm::Array<Clause> clauses;
 
-  /*! \brief Should this match be complete (cover all cases)? 
+  /*! \brief Should this match be complete (cover all cases)?
    *  If yes, the type checker will generate an error if there are any missing cases.
    */
   bool complete;
diff --git a/python/tvm/relay/grammar/Relay.g4 b/python/tvm/relay/grammar/Relay.g4
index 0e0013a8c161..d6defd2edbf8 100644
--- a/python/tvm/relay/grammar/Relay.g4
+++ b/python/tvm/relay/grammar/Relay.g4
@@ -53,18 +53,24 @@ BOOL_LIT
   | 'False'
   ;
 
+// START_UPPER_CNAME: UPPER_LETTER ('_'|LETTER|DIGIT)*;
+// START_LOWER_CNAME: LOWER_LETTER ('_'|LETTER|DIGIT)*;
 CNAME: ('_'|LETTER) ('_'|LETTER|DIGIT)* ('.' CNAME)* ;
 
-DATATYPE : 'int64';
 // non-negative floats
 fragment PREFLOAT : NAT ('.' NAT)? EXP?; // 1.35, 1.35E-9, 0.3, 4.5, 1, 1e10 3e4
 
 FLOAT : PREFLOAT 'f';
 
+// BASE_TYPE : ('int'|'uint'|'float'|'bool') DIGIT*;
+BASE_TYPE : 'int32' ;
+
 // non-negative ints
 NAT: DIGIT+ ;
 fragment EXP: [eE] [+\-]? NAT ; // \- since - means "range" inside [...]
 
+fragment LOWER_LETTER: [a-z];
+fragment UPPER_LETTER: [A-Z];
 fragment LETTER: [a-zA-Z];
 fragment DIGIT: [0-9];
 
@@ -78,6 +84,9 @@ prog: SEMVER (defn* | expr) METADATA? EOF ;
 opIdent: CNAME ;
 globalVar: '@' CNAME ;
 localVar: '%' CNAME ;
+// TODO(weberlo): why does 'int32` generate a parse error when it's literally a
+// lexer token?
+// typeIdent: BASE_TYPE | START_UPPER_NAME ;
 typeIdent: CNAME ;
 graphVar: '%' NAT ;
 
@@ -122,7 +131,7 @@ expr
 func: 'fn'        typeParamList? '(' argList ')' ('->' typeExpr)? body ;
 defn
   : 'def' globalVar typeParamList? '(' argList ')' ('->' typeExpr)? body  # funcDefn
-  | 'type' typeIdent typeParamList? '=' adtConstructor+                               # adtDefn
+  | 'type' typeIdent typeParamList? '=' adtConstructor+                   # adtDefn
   ;
 
 adtConstructor: '|' constructorName ('(' typeExpr (',' typeExpr)* ')')? ;
@@ -136,6 +145,7 @@ pattern
   | localVar
   ;
 
+// constructorName: typeIdent ;
 constructorName: CNAME ;
 
 argList
@@ -147,6 +157,7 @@ varList: (var (',' var)*)?;
 var: localVar (':' typeExpr)?;
 
 attrSeq: attr (',' attr)*;
+// attr: LOWER_NAME '=' expr ;
 attr: CNAME '=' expr ;
 
 typeExpr
@@ -157,7 +168,7 @@ typeExpr
   | typeIdent                                                    # typeIdentType
   | 'Tensor' '[' shapeList ',' typeExpr ']'                         # tensorType
   | 'fn' typeParamList? '(' (typeExpr (',' typeExpr)*)? ')' '->' typeExpr # funcType
-  | '_'                                                          # incompleteType
+  // | '_'                                                          # incompleteType
   // TODO: Why the fuck does this rule exist?
   // | NAT                                                          # intType
   ;
@@ -171,6 +182,7 @@ shapeList
   | shape
   ;
 
+// meta : 'meta' '[' LOWER_NAME ']' '[' NAT ']';
 meta : 'meta' '[' CNAME ']' '[' NAT ']';
 
 shape
diff --git a/python/tvm/relay/grammar/py3/RelayLexer.py b/python/tvm/relay/grammar/py3/RelayLexer.py
index 2fe21f1881d3..8ea1abb81a48 100644
--- a/python/tvm/relay/grammar/py3/RelayLexer.py
+++ b/python/tvm/relay/grammar/py3/RelayLexer.py
@@ -9,7 +9,7 @@
 def serializedATN():
     with StringIO() as buf:
         buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\63")
-        buf.write("\u0164\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7")
+        buf.write("\u016c\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7")
         buf.write("\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r")
         buf.write("\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23")
         buf.write("\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30")
@@ -17,150 +17,153 @@ def serializedATN():
         buf.write("\t\36\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%")
         buf.write("\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.")
         buf.write("\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64")
-        buf.write("\t\64\4\65\t\65\4\66\t\66\4\67\t\67\3\2\3\2\3\3\3\3\3")
-        buf.write("\4\3\4\3\5\3\5\3\6\3\6\3\7\3\7\3\b\3\b\3\t\3\t\3\n\3\n")
-        buf.write("\3\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\3\r\3\r\3\16\3\16")
-        buf.write("\3\16\3\16\3\17\3\17\3\20\3\20\3\21\3\21\3\21\3\22\3\22")
-        buf.write("\3\22\3\23\3\23\3\23\3\24\3\24\3\24\3\24\3\25\3\25\3\25")
-        buf.write("\3\25\3\25\3\26\3\26\3\27\3\27\3\27\3\30\3\30\3\30\3\30")
-        buf.write("\3\30\3\30\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\32\3\32")
-        buf.write("\3\33\3\33\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\35\3\35")
-        buf.write("\3\35\3\35\3\35\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\37")
-        buf.write("\3\37\3\37\3\37\3\37\7\37\u00d4\n\37\f\37\16\37\u00d7")
-        buf.write("\13\37\3\37\3\37\3\37\3\37\3\37\3 \6 \u00df\n \r \16 ")
-        buf.write("\u00e0\3 \3 \3!\3!\3!\3!\7!\u00e9\n!\f!\16!\u00ec\13!")
-        buf.write("\3!\3!\3!\3!\3\"\3\"\3\"\3#\3#\3#\7#\u00f8\n#\f#\16#\u00fb")
-        buf.write("\13#\3#\3#\3$\3$\3%\3%\3&\3&\3\'\3\'\3(\3(\3)\3)\3*\3")
-        buf.write("*\3*\3+\3+\3+\3,\3,\3,\3-\3-\3-\3.\3.\3.\3.\3.\3.\3.\3")
-        buf.write(".\3.\5.\u0120\n.\3/\3/\5/\u0124\n/\3/\3/\3/\7/\u0129\n")
-        buf.write("/\f/\16/\u012c\13/\3/\3/\7/\u0130\n/\f/\16/\u0133\13/")
-        buf.write("\3\60\3\60\3\60\3\60\3\60\3\60\3\61\3\61\3\61\5\61\u013e")
-        buf.write("\n\61\3\61\5\61\u0141\n\61\3\62\3\62\3\62\3\63\6\63\u0147")
-        buf.write("\n\63\r\63\16\63\u0148\3\64\3\64\5\64\u014d\n\64\3\64")
-        buf.write("\3\64\3\65\3\65\3\66\3\66\3\67\3\67\3\67\3\67\3\67\3\67")
-        buf.write("\3\67\3\67\3\67\3\67\3\67\7\67\u0160\n\67\f\67\16\67\u0163")
-        buf.write("\13\67\5\u00d5\u00ea\u00f9\28\3\3\5\4\7\5\t\6\13\7\r\b")
-        buf.write("\17\t\21\n\23\13\25\f\27\r\31\16\33\17\35\20\37\21!\22")
-        buf.write("#\23%\24\'\25)\26+\27-\30/\31\61\32\63\33\65\34\67\35")
-        buf.write("9\36;\37= ?!A\"C\2E#G$I%K&M\'O(Q)S*U+W,Y-[.]/_\60a\2c")
-        buf.write("\61e\62g\2i\2k\2m\63\3\2\b\5\2\13\f\17\17\"\"\4\2\f\f")
-        buf.write("\17\17\4\2GGgg\4\2--//\4\2C\\c|\3\2\62;\2\u016f\2\3\3")
-        buf.write("\2\2\2\2\5\3\2\2\2\2\7\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2")
-        buf.write("\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2\2")
-        buf.write("\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2\2")
-        buf.write("\35\3\2\2\2\2\37\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2%\3\2")
-        buf.write("\2\2\2\'\3\2\2\2\2)\3\2\2\2\2+\3\2\2\2\2-\3\2\2\2\2/\3")
-        buf.write("\2\2\2\2\61\3\2\2\2\2\63\3\2\2\2\2\65\3\2\2\2\2\67\3\2")
-        buf.write("\2\2\29\3\2\2\2\2;\3\2\2\2\2=\3\2\2\2\2?\3\2\2\2\2A\3")
-        buf.write("\2\2\2\2E\3\2\2\2\2G\3\2\2\2\2I\3\2\2\2\2K\3\2\2\2\2M")
-        buf.write("\3\2\2\2\2O\3\2\2\2\2Q\3\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2")
-        buf.write("W\3\2\2\2\2Y\3\2\2\2\2[\3\2\2\2\2]\3\2\2\2\2_\3\2\2\2")
-        buf.write("\2c\3\2\2\2\2e\3\2\2\2\2m\3\2\2\2\3o\3\2\2\2\5q\3\2\2")
-        buf.write("\2\7s\3\2\2\2\tu\3\2\2\2\13w\3\2\2\2\ry\3\2\2\2\17{\3")
-        buf.write("\2\2\2\21}\3\2\2\2\23\177\3\2\2\2\25\u0081\3\2\2\2\27")
-        buf.write("\u0084\3\2\2\2\31\u0089\3\2\2\2\33\u008b\3\2\2\2\35\u008f")
-        buf.write("\3\2\2\2\37\u0091\3\2\2\2!\u0093\3\2\2\2#\u0096\3\2\2")
-        buf.write("\2%\u0099\3\2\2\2\'\u009c\3\2\2\2)\u00a0\3\2\2\2+\u00a5")
-        buf.write("\3\2\2\2-\u00a7\3\2\2\2/\u00aa\3\2\2\2\61\u00b0\3\2\2")
-        buf.write("\2\63\u00b7\3\2\2\2\65\u00b9\3\2\2\2\67\u00bb\3\2\2\2")
-        buf.write("9\u00c2\3\2\2\2;\u00c7\3\2\2\2=\u00ce\3\2\2\2?\u00de\3")
-        buf.write("\2\2\2A\u00e4\3\2\2\2C\u00f1\3\2\2\2E\u00f4\3\2\2\2G\u00fe")
-        buf.write("\3\2\2\2I\u0100\3\2\2\2K\u0102\3\2\2\2M\u0104\3\2\2\2")
-        buf.write("O\u0106\3\2\2\2Q\u0108\3\2\2\2S\u010a\3\2\2\2U\u010d\3")
-        buf.write("\2\2\2W\u0110\3\2\2\2Y\u0113\3\2\2\2[\u011f\3\2\2\2]\u0123")
-        buf.write("\3\2\2\2_\u0134\3\2\2\2a\u013a\3\2\2\2c\u0142\3\2\2\2")
-        buf.write("e\u0146\3\2\2\2g\u014a\3\2\2\2i\u0150\3\2\2\2k\u0152\3")
-        buf.write("\2\2\2m\u0154\3\2\2\2op\7B\2\2p\4\3\2\2\2qr\7\'\2\2r\6")
-        buf.write("\3\2\2\2st\7.\2\2t\b\3\2\2\2uv\7*\2\2v\n\3\2\2\2wx\7+")
-        buf.write("\2\2x\f\3\2\2\2yz\7}\2\2z\16\3\2\2\2{|\7\177\2\2|\20\3")
-        buf.write("\2\2\2}~\7]\2\2~\22\3\2\2\2\177\u0080\7_\2\2\u0080\24")
-        buf.write("\3\2\2\2\u0081\u0082\7k\2\2\u0082\u0083\7h\2\2\u0083\26")
-        buf.write("\3\2\2\2\u0084\u0085\7g\2\2\u0085\u0086\7n\2\2\u0086\u0087")
-        buf.write("\7u\2\2\u0087\u0088\7g\2\2\u0088\30\3\2\2\2\u0089\u008a")
-        buf.write("\7\60\2\2\u008a\32\3\2\2\2\u008b\u008c\7n\2\2\u008c\u008d")
-        buf.write("\7g\2\2\u008d\u008e\7v\2\2\u008e\34\3\2\2\2\u008f\u0090")
-        buf.write("\7?\2\2\u0090\36\3\2\2\2\u0091\u0092\7=\2\2\u0092 \3\2")
-        buf.write("\2\2\u0093\u0094\7=\2\2\u0094\u0095\7=\2\2\u0095\"\3\2")
-        buf.write("\2\2\u0096\u0097\7h\2\2\u0097\u0098\7p\2\2\u0098$\3\2")
-        buf.write("\2\2\u0099\u009a\7/\2\2\u009a\u009b\7@\2\2\u009b&\3\2")
-        buf.write("\2\2\u009c\u009d\7f\2\2\u009d\u009e\7g\2\2\u009e\u009f")
-        buf.write("\7h\2\2\u009f(\3\2\2\2\u00a0\u00a1\7v\2\2\u00a1\u00a2")
-        buf.write("\7{\2\2\u00a2\u00a3\7r\2\2\u00a3\u00a4\7g\2\2\u00a4*\3")
-        buf.write("\2\2\2\u00a5\u00a6\7~\2\2\u00a6,\3\2\2\2\u00a7\u00a8\7")
-        buf.write("?\2\2\u00a8\u00a9\7@\2\2\u00a9.\3\2\2\2\u00aa\u00ab\7")
-        buf.write("o\2\2\u00ab\u00ac\7c\2\2\u00ac\u00ad\7v\2\2\u00ad\u00ae")
-        buf.write("\7e\2\2\u00ae\u00af\7j\2\2\u00af\60\3\2\2\2\u00b0\u00b1")
-        buf.write("\7o\2\2\u00b1\u00b2\7c\2\2\u00b2\u00b3\7v\2\2\u00b3\u00b4")
-        buf.write("\7e\2\2\u00b4\u00b5\7j\2\2\u00b5\u00b6\7A\2\2\u00b6\62")
-        buf.write("\3\2\2\2\u00b7\u00b8\7a\2\2\u00b8\64\3\2\2\2\u00b9\u00ba")
-        buf.write("\7<\2\2\u00ba\66\3\2\2\2\u00bb\u00bc\7V\2\2\u00bc\u00bd")
-        buf.write("\7g\2\2\u00bd\u00be\7p\2\2\u00be\u00bf\7u\2\2\u00bf\u00c0")
-        buf.write("\7q\2\2\u00c0\u00c1\7t\2\2\u00c18\3\2\2\2\u00c2\u00c3")
-        buf.write("\7o\2\2\u00c3\u00c4\7g\2\2\u00c4\u00c5\7v\2\2\u00c5\u00c6")
-        buf.write("\7c\2\2\u00c6:\3\2\2\2\u00c7\u00c8\7x\2\2\u00c8\u00c9")
-        buf.write("\7\62\2\2\u00c9\u00ca\7\60\2\2\u00ca\u00cb\7\62\2\2\u00cb")
-        buf.write("\u00cc\7\60\2\2\u00cc\u00cd\7\65\2\2\u00cd<\3\2\2\2\u00ce")
-        buf.write("\u00cf\7\61\2\2\u00cf\u00d0\7,\2\2\u00d0\u00d5\3\2\2\2")
-        buf.write("\u00d1\u00d4\5=\37\2\u00d2\u00d4\13\2\2\2\u00d3\u00d1")
-        buf.write("\3\2\2\2\u00d3\u00d2\3\2\2\2\u00d4\u00d7\3\2\2\2\u00d5")
-        buf.write("\u00d6\3\2\2\2\u00d5\u00d3\3\2\2\2\u00d6\u00d8\3\2\2\2")
-        buf.write("\u00d7\u00d5\3\2\2\2\u00d8\u00d9\7,\2\2\u00d9\u00da\7")
-        buf.write("\61\2\2\u00da\u00db\3\2\2\2\u00db\u00dc\b\37\2\2\u00dc")
-        buf.write(">\3\2\2\2\u00dd\u00df\t\2\2\2\u00de\u00dd\3\2\2\2\u00df")
-        buf.write("\u00e0\3\2\2\2\u00e0\u00de\3\2\2\2\u00e0\u00e1\3\2\2\2")
-        buf.write("\u00e1\u00e2\3\2\2\2\u00e2\u00e3\b \2\2\u00e3@\3\2\2\2")
-        buf.write("\u00e4\u00e5\7\61\2\2\u00e5\u00e6\7\61\2\2\u00e6\u00ea")
-        buf.write("\3\2\2\2\u00e7\u00e9\13\2\2\2\u00e8\u00e7\3\2\2\2\u00e9")
-        buf.write("\u00ec\3\2\2\2\u00ea\u00eb\3\2\2\2\u00ea\u00e8\3\2\2\2")
-        buf.write("\u00eb\u00ed\3\2\2\2\u00ec\u00ea\3\2\2\2\u00ed\u00ee\7")
-        buf.write("\f\2\2\u00ee\u00ef\3\2\2\2\u00ef\u00f0\b!\2\2\u00f0B\3")
-        buf.write("\2\2\2\u00f1\u00f2\7^\2\2\u00f2\u00f3\7$\2\2\u00f3D\3")
-        buf.write("\2\2\2\u00f4\u00f9\7$\2\2\u00f5\u00f8\5C\"\2\u00f6\u00f8")
-        buf.write("\n\3\2\2\u00f7\u00f5\3\2\2\2\u00f7\u00f6\3\2\2\2\u00f8")
-        buf.write("\u00fb\3\2\2\2\u00f9\u00fa\3\2\2\2\u00f9\u00f7\3\2\2\2")
-        buf.write("\u00fa\u00fc\3\2\2\2\u00fb\u00f9\3\2\2\2\u00fc\u00fd\7")
-        buf.write("$\2\2\u00fdF\3\2\2\2\u00fe\u00ff\7,\2\2\u00ffH\3\2\2\2")
-        buf.write("\u0100\u0101\7\61\2\2\u0101J\3\2\2\2\u0102\u0103\7-\2")
-        buf.write("\2\u0103L\3\2\2\2\u0104\u0105\7/\2\2\u0105N\3\2\2\2\u0106")
-        buf.write("\u0107\7>\2\2\u0107P\3\2\2\2\u0108\u0109\7@\2\2\u0109")
-        buf.write("R\3\2\2\2\u010a\u010b\7>\2\2\u010b\u010c\7?\2\2\u010c")
-        buf.write("T\3\2\2\2\u010d\u010e\7@\2\2\u010e\u010f\7?\2\2\u010f")
-        buf.write("V\3\2\2\2\u0110\u0111\7?\2\2\u0111\u0112\7?\2\2\u0112")
-        buf.write("X\3\2\2\2\u0113\u0114\7#\2\2\u0114\u0115\7?\2\2\u0115")
-        buf.write("Z\3\2\2\2\u0116\u0117\7V\2\2\u0117\u0118\7t\2\2\u0118")
-        buf.write("\u0119\7w\2\2\u0119\u0120\7g\2\2\u011a\u011b\7H\2\2\u011b")
-        buf.write("\u011c\7c\2\2\u011c\u011d\7n\2\2\u011d\u011e\7u\2\2\u011e")
-        buf.write("\u0120\7g\2\2\u011f\u0116\3\2\2\2\u011f\u011a\3\2\2\2")
-        buf.write("\u0120\\\3\2\2\2\u0121\u0124\7a\2\2\u0122\u0124\5i\65")
-        buf.write("\2\u0123\u0121\3\2\2\2\u0123\u0122\3\2\2\2\u0124\u012a")
-        buf.write("\3\2\2\2\u0125\u0129\7a\2\2\u0126\u0129\5i\65\2\u0127")
-        buf.write("\u0129\5k\66\2\u0128\u0125\3\2\2\2\u0128\u0126\3\2\2\2")
-        buf.write("\u0128\u0127\3\2\2\2\u0129\u012c\3\2\2\2\u012a\u0128\3")
-        buf.write("\2\2\2\u012a\u012b\3\2\2\2\u012b\u0131\3\2\2\2\u012c\u012a")
-        buf.write("\3\2\2\2\u012d\u012e\7\60\2\2\u012e\u0130\5]/\2\u012f")
-        buf.write("\u012d\3\2\2\2\u0130\u0133\3\2\2\2\u0131\u012f\3\2\2\2")
-        buf.write("\u0131\u0132\3\2\2\2\u0132^\3\2\2\2\u0133\u0131\3\2\2")
-        buf.write("\2\u0134\u0135\7k\2\2\u0135\u0136\7p\2\2\u0136\u0137\7")
-        buf.write("v\2\2\u0137\u0138\78\2\2\u0138\u0139\7\66\2\2\u0139`\3")
-        buf.write("\2\2\2\u013a\u013d\5e\63\2\u013b\u013c\7\60\2\2\u013c")
-        buf.write("\u013e\5e\63\2\u013d\u013b\3\2\2\2\u013d\u013e\3\2\2\2")
-        buf.write("\u013e\u0140\3\2\2\2\u013f\u0141\5g\64\2\u0140\u013f\3")
-        buf.write("\2\2\2\u0140\u0141\3\2\2\2\u0141b\3\2\2\2\u0142\u0143")
-        buf.write("\5a\61\2\u0143\u0144\7h\2\2\u0144d\3\2\2\2\u0145\u0147")
-        buf.write("\5k\66\2\u0146\u0145\3\2\2\2\u0147\u0148\3\2\2\2\u0148")
-        buf.write("\u0146\3\2\2\2\u0148\u0149\3\2\2\2\u0149f\3\2\2\2\u014a")
-        buf.write("\u014c\t\4\2\2\u014b\u014d\t\5\2\2\u014c\u014b\3\2\2\2")
-        buf.write("\u014c\u014d\3\2\2\2\u014d\u014e\3\2\2\2\u014e\u014f\5")
-        buf.write("e\63\2\u014fh\3\2\2\2\u0150\u0151\t\6\2\2\u0151j\3\2\2")
-        buf.write("\2\u0152\u0153\t\7\2\2\u0153l\3\2\2\2\u0154\u0155\7O\2")
-        buf.write("\2\u0155\u0156\7G\2\2\u0156\u0157\7V\2\2\u0157\u0158\7")
-        buf.write("C\2\2\u0158\u0159\7F\2\2\u0159\u015a\7C\2\2\u015a\u015b")
-        buf.write("\7V\2\2\u015b\u015c\7C\2\2\u015c\u015d\7<\2\2\u015d\u0161")
-        buf.write("\3\2\2\2\u015e\u0160\13\2\2\2\u015f\u015e\3\2\2\2\u0160")
-        buf.write("\u0163\3\2\2\2\u0161\u015f\3\2\2\2\u0161\u0162\3\2\2\2")
-        buf.write("\u0162n\3\2\2\2\u0163\u0161\3\2\2\2\23\2\u00d3\u00d5\u00e0")
-        buf.write("\u00ea\u00f7\u00f9\u011f\u0123\u0128\u012a\u0131\u013d")
-        buf.write("\u0140\u0148\u014c\u0161\3\b\2\2")
+        buf.write("\t\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\3\2\3")
+        buf.write("\2\3\3\3\3\3\4\3\4\3\5\3\5\3\6\3\6\3\7\3\7\3\b\3\b\3\t")
+        buf.write("\3\t\3\n\3\n\3\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\3\r\3")
+        buf.write("\r\3\16\3\16\3\16\3\16\3\17\3\17\3\20\3\20\3\21\3\21\3")
+        buf.write("\21\3\22\3\22\3\22\3\23\3\23\3\23\3\24\3\24\3\24\3\24")
+        buf.write("\3\25\3\25\3\25\3\25\3\25\3\26\3\26\3\27\3\27\3\27\3\30")
+        buf.write("\3\30\3\30\3\30\3\30\3\30\3\31\3\31\3\31\3\31\3\31\3\31")
+        buf.write("\3\31\3\32\3\32\3\33\3\33\3\34\3\34\3\34\3\34\3\34\3\34")
+        buf.write("\3\34\3\35\3\35\3\35\3\35\3\35\3\36\3\36\3\36\3\36\3\36")
+        buf.write("\3\36\3\36\3\37\3\37\3\37\3\37\3\37\7\37\u00d8\n\37\f")
+        buf.write("\37\16\37\u00db\13\37\3\37\3\37\3\37\3\37\3\37\3 \6 \u00e3")
+        buf.write("\n \r \16 \u00e4\3 \3 \3!\3!\3!\3!\7!\u00ed\n!\f!\16!")
+        buf.write("\u00f0\13!\3!\3!\3!\3!\3\"\3\"\3\"\3#\3#\3#\7#\u00fc\n")
+        buf.write("#\f#\16#\u00ff\13#\3#\3#\3$\3$\3%\3%\3&\3&\3\'\3\'\3(")
+        buf.write("\3(\3)\3)\3*\3*\3*\3+\3+\3+\3,\3,\3,\3-\3-\3-\3.\3.\3")
+        buf.write(".\3.\3.\3.\3.\3.\3.\5.\u0124\n.\3/\3/\5/\u0128\n/\3/\3")
+        buf.write("/\3/\7/\u012d\n/\f/\16/\u0130\13/\3/\3/\7/\u0134\n/\f")
+        buf.write("/\16/\u0137\13/\3\60\3\60\3\60\5\60\u013c\n\60\3\60\5")
+        buf.write("\60\u013f\n\60\3\61\3\61\3\61\3\62\3\62\3\62\3\62\3\62")
+        buf.write("\3\62\3\63\6\63\u014b\n\63\r\63\16\63\u014c\3\64\3\64")
+        buf.write("\5\64\u0151\n\64\3\64\3\64\3\65\3\65\3\66\3\66\3\67\3")
+        buf.write("\67\38\38\39\39\39\39\39\39\39\39\39\39\39\79\u0168\n")
+        buf.write("9\f9\169\u016b\139\5\u00d9\u00ee\u00fd\2:\3\3\5\4\7\5")
+        buf.write("\t\6\13\7\r\b\17\t\21\n\23\13\25\f\27\r\31\16\33\17\35")
+        buf.write("\20\37\21!\22#\23%\24\'\25)\26+\27-\30/\31\61\32\63\33")
+        buf.write("\65\34\67\359\36;\37= ?!A\"C\2E#G$I%K&M\'O(Q)S*U+W,Y-")
+        buf.write("[.]/_\2a\60c\61e\62g\2i\2k\2m\2o\2q\63\3\2\n\5\2\13\f")
+        buf.write("\17\17\"\"\4\2\f\f\17\17\4\2GGgg\4\2--//\3\2c|\3\2C\\")
+        buf.write("\4\2C\\c|\3\2\62;\2\u0175\2\3\3\2\2\2\2\5\3\2\2\2\2\7")
+        buf.write("\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2")
+        buf.write("\2\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2")
+        buf.write("\2\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2\2\2\2\37\3\2\2\2")
+        buf.write("\2!\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("\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2\2\2\2\63")
+        buf.write("\3\2\2\2\2\65\3\2\2\2\2\67\3\2\2\2\29\3\2\2\2\2;\3\2\2")
+        buf.write("\2\2=\3\2\2\2\2?\3\2\2\2\2A\3\2\2\2\2E\3\2\2\2\2G\3\2")
+        buf.write("\2\2\2I\3\2\2\2\2K\3\2\2\2\2M\3\2\2\2\2O\3\2\2\2\2Q\3")
+        buf.write("\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2W\3\2\2\2\2Y\3\2\2\2\2[")
+        buf.write("\3\2\2\2\2]\3\2\2\2\2a\3\2\2\2\2c\3\2\2\2\2e\3\2\2\2\2")
+        buf.write("q\3\2\2\2\3s\3\2\2\2\5u\3\2\2\2\7w\3\2\2\2\ty\3\2\2\2")
+        buf.write("\13{\3\2\2\2\r}\3\2\2\2\17\177\3\2\2\2\21\u0081\3\2\2")
+        buf.write("\2\23\u0083\3\2\2\2\25\u0085\3\2\2\2\27\u0088\3\2\2\2")
+        buf.write("\31\u008d\3\2\2\2\33\u008f\3\2\2\2\35\u0093\3\2\2\2\37")
+        buf.write("\u0095\3\2\2\2!\u0097\3\2\2\2#\u009a\3\2\2\2%\u009d\3")
+        buf.write("\2\2\2\'\u00a0\3\2\2\2)\u00a4\3\2\2\2+\u00a9\3\2\2\2-")
+        buf.write("\u00ab\3\2\2\2/\u00ae\3\2\2\2\61\u00b4\3\2\2\2\63\u00bb")
+        buf.write("\3\2\2\2\65\u00bd\3\2\2\2\67\u00bf\3\2\2\29\u00c6\3\2")
+        buf.write("\2\2;\u00cb\3\2\2\2=\u00d2\3\2\2\2?\u00e2\3\2\2\2A\u00e8")
+        buf.write("\3\2\2\2C\u00f5\3\2\2\2E\u00f8\3\2\2\2G\u0102\3\2\2\2")
+        buf.write("I\u0104\3\2\2\2K\u0106\3\2\2\2M\u0108\3\2\2\2O\u010a\3")
+        buf.write("\2\2\2Q\u010c\3\2\2\2S\u010e\3\2\2\2U\u0111\3\2\2\2W\u0114")
+        buf.write("\3\2\2\2Y\u0117\3\2\2\2[\u0123\3\2\2\2]\u0127\3\2\2\2")
+        buf.write("_\u0138\3\2\2\2a\u0140\3\2\2\2c\u0143\3\2\2\2e\u014a\3")
+        buf.write("\2\2\2g\u014e\3\2\2\2i\u0154\3\2\2\2k\u0156\3\2\2\2m\u0158")
+        buf.write("\3\2\2\2o\u015a\3\2\2\2q\u015c\3\2\2\2st\7B\2\2t\4\3\2")
+        buf.write("\2\2uv\7\'\2\2v\6\3\2\2\2wx\7.\2\2x\b\3\2\2\2yz\7*\2\2")
+        buf.write("z\n\3\2\2\2{|\7+\2\2|\f\3\2\2\2}~\7}\2\2~\16\3\2\2\2\177")
+        buf.write("\u0080\7\177\2\2\u0080\20\3\2\2\2\u0081\u0082\7]\2\2\u0082")
+        buf.write("\22\3\2\2\2\u0083\u0084\7_\2\2\u0084\24\3\2\2\2\u0085")
+        buf.write("\u0086\7k\2\2\u0086\u0087\7h\2\2\u0087\26\3\2\2\2\u0088")
+        buf.write("\u0089\7g\2\2\u0089\u008a\7n\2\2\u008a\u008b\7u\2\2\u008b")
+        buf.write("\u008c\7g\2\2\u008c\30\3\2\2\2\u008d\u008e\7\60\2\2\u008e")
+        buf.write("\32\3\2\2\2\u008f\u0090\7n\2\2\u0090\u0091\7g\2\2\u0091")
+        buf.write("\u0092\7v\2\2\u0092\34\3\2\2\2\u0093\u0094\7?\2\2\u0094")
+        buf.write("\36\3\2\2\2\u0095\u0096\7=\2\2\u0096 \3\2\2\2\u0097\u0098")
+        buf.write("\7=\2\2\u0098\u0099\7=\2\2\u0099\"\3\2\2\2\u009a\u009b")
+        buf.write("\7h\2\2\u009b\u009c\7p\2\2\u009c$\3\2\2\2\u009d\u009e")
+        buf.write("\7/\2\2\u009e\u009f\7@\2\2\u009f&\3\2\2\2\u00a0\u00a1")
+        buf.write("\7f\2\2\u00a1\u00a2\7g\2\2\u00a2\u00a3\7h\2\2\u00a3(\3")
+        buf.write("\2\2\2\u00a4\u00a5\7v\2\2\u00a5\u00a6\7{\2\2\u00a6\u00a7")
+        buf.write("\7r\2\2\u00a7\u00a8\7g\2\2\u00a8*\3\2\2\2\u00a9\u00aa")
+        buf.write("\7~\2\2\u00aa,\3\2\2\2\u00ab\u00ac\7?\2\2\u00ac\u00ad")
+        buf.write("\7@\2\2\u00ad.\3\2\2\2\u00ae\u00af\7o\2\2\u00af\u00b0")
+        buf.write("\7c\2\2\u00b0\u00b1\7v\2\2\u00b1\u00b2\7e\2\2\u00b2\u00b3")
+        buf.write("\7j\2\2\u00b3\60\3\2\2\2\u00b4\u00b5\7o\2\2\u00b5\u00b6")
+        buf.write("\7c\2\2\u00b6\u00b7\7v\2\2\u00b7\u00b8\7e\2\2\u00b8\u00b9")
+        buf.write("\7j\2\2\u00b9\u00ba\7A\2\2\u00ba\62\3\2\2\2\u00bb\u00bc")
+        buf.write("\7a\2\2\u00bc\64\3\2\2\2\u00bd\u00be\7<\2\2\u00be\66\3")
+        buf.write("\2\2\2\u00bf\u00c0\7V\2\2\u00c0\u00c1\7g\2\2\u00c1\u00c2")
+        buf.write("\7p\2\2\u00c2\u00c3\7u\2\2\u00c3\u00c4\7q\2\2\u00c4\u00c5")
+        buf.write("\7t\2\2\u00c58\3\2\2\2\u00c6\u00c7\7o\2\2\u00c7\u00c8")
+        buf.write("\7g\2\2\u00c8\u00c9\7v\2\2\u00c9\u00ca\7c\2\2\u00ca:\3")
+        buf.write("\2\2\2\u00cb\u00cc\7x\2\2\u00cc\u00cd\7\62\2\2\u00cd\u00ce")
+        buf.write("\7\60\2\2\u00ce\u00cf\7\62\2\2\u00cf\u00d0\7\60\2\2\u00d0")
+        buf.write("\u00d1\7\65\2\2\u00d1<\3\2\2\2\u00d2\u00d3\7\61\2\2\u00d3")
+        buf.write("\u00d4\7,\2\2\u00d4\u00d9\3\2\2\2\u00d5\u00d8\5=\37\2")
+        buf.write("\u00d6\u00d8\13\2\2\2\u00d7\u00d5\3\2\2\2\u00d7\u00d6")
+        buf.write("\3\2\2\2\u00d8\u00db\3\2\2\2\u00d9\u00da\3\2\2\2\u00d9")
+        buf.write("\u00d7\3\2\2\2\u00da\u00dc\3\2\2\2\u00db\u00d9\3\2\2\2")
+        buf.write("\u00dc\u00dd\7,\2\2\u00dd\u00de\7\61\2\2\u00de\u00df\3")
+        buf.write("\2\2\2\u00df\u00e0\b\37\2\2\u00e0>\3\2\2\2\u00e1\u00e3")
+        buf.write("\t\2\2\2\u00e2\u00e1\3\2\2\2\u00e3\u00e4\3\2\2\2\u00e4")
+        buf.write("\u00e2\3\2\2\2\u00e4\u00e5\3\2\2\2\u00e5\u00e6\3\2\2\2")
+        buf.write("\u00e6\u00e7\b \2\2\u00e7@\3\2\2\2\u00e8\u00e9\7\61\2")
+        buf.write("\2\u00e9\u00ea\7\61\2\2\u00ea\u00ee\3\2\2\2\u00eb\u00ed")
+        buf.write("\13\2\2\2\u00ec\u00eb\3\2\2\2\u00ed\u00f0\3\2\2\2\u00ee")
+        buf.write("\u00ef\3\2\2\2\u00ee\u00ec\3\2\2\2\u00ef\u00f1\3\2\2\2")
+        buf.write("\u00f0\u00ee\3\2\2\2\u00f1\u00f2\7\f\2\2\u00f2\u00f3\3")
+        buf.write("\2\2\2\u00f3\u00f4\b!\2\2\u00f4B\3\2\2\2\u00f5\u00f6\7")
+        buf.write("^\2\2\u00f6\u00f7\7$\2\2\u00f7D\3\2\2\2\u00f8\u00fd\7")
+        buf.write("$\2\2\u00f9\u00fc\5C\"\2\u00fa\u00fc\n\3\2\2\u00fb\u00f9")
+        buf.write("\3\2\2\2\u00fb\u00fa\3\2\2\2\u00fc\u00ff\3\2\2\2\u00fd")
+        buf.write("\u00fe\3\2\2\2\u00fd\u00fb\3\2\2\2\u00fe\u0100\3\2\2\2")
+        buf.write("\u00ff\u00fd\3\2\2\2\u0100\u0101\7$\2\2\u0101F\3\2\2\2")
+        buf.write("\u0102\u0103\7,\2\2\u0103H\3\2\2\2\u0104\u0105\7\61\2")
+        buf.write("\2\u0105J\3\2\2\2\u0106\u0107\7-\2\2\u0107L\3\2\2\2\u0108")
+        buf.write("\u0109\7/\2\2\u0109N\3\2\2\2\u010a\u010b\7>\2\2\u010b")
+        buf.write("P\3\2\2\2\u010c\u010d\7@\2\2\u010dR\3\2\2\2\u010e\u010f")
+        buf.write("\7>\2\2\u010f\u0110\7?\2\2\u0110T\3\2\2\2\u0111\u0112")
+        buf.write("\7@\2\2\u0112\u0113\7?\2\2\u0113V\3\2\2\2\u0114\u0115")
+        buf.write("\7?\2\2\u0115\u0116\7?\2\2\u0116X\3\2\2\2\u0117\u0118")
+        buf.write("\7#\2\2\u0118\u0119\7?\2\2\u0119Z\3\2\2\2\u011a\u011b")
+        buf.write("\7V\2\2\u011b\u011c\7t\2\2\u011c\u011d\7w\2\2\u011d\u0124")
+        buf.write("\7g\2\2\u011e\u011f\7H\2\2\u011f\u0120\7c\2\2\u0120\u0121")
+        buf.write("\7n\2\2\u0121\u0122\7u\2\2\u0122\u0124\7g\2\2\u0123\u011a")
+        buf.write("\3\2\2\2\u0123\u011e\3\2\2\2\u0124\\\3\2\2\2\u0125\u0128")
+        buf.write("\7a\2\2\u0126\u0128\5m\67\2\u0127\u0125\3\2\2\2\u0127")
+        buf.write("\u0126\3\2\2\2\u0128\u012e\3\2\2\2\u0129\u012d\7a\2\2")
+        buf.write("\u012a\u012d\5m\67\2\u012b\u012d\5o8\2\u012c\u0129\3\2")
+        buf.write("\2\2\u012c\u012a\3\2\2\2\u012c\u012b\3\2\2\2\u012d\u0130")
+        buf.write("\3\2\2\2\u012e\u012c\3\2\2\2\u012e\u012f\3\2\2\2\u012f")
+        buf.write("\u0135\3\2\2\2\u0130\u012e\3\2\2\2\u0131\u0132\7\60\2")
+        buf.write("\2\u0132\u0134\5]/\2\u0133\u0131\3\2\2\2\u0134\u0137\3")
+        buf.write("\2\2\2\u0135\u0133\3\2\2\2\u0135\u0136\3\2\2\2\u0136^")
+        buf.write("\3\2\2\2\u0137\u0135\3\2\2\2\u0138\u013b\5e\63\2\u0139")
+        buf.write("\u013a\7\60\2\2\u013a\u013c\5e\63\2\u013b\u0139\3\2\2")
+        buf.write("\2\u013b\u013c\3\2\2\2\u013c\u013e\3\2\2\2\u013d\u013f")
+        buf.write("\5g\64\2\u013e\u013d\3\2\2\2\u013e\u013f\3\2\2\2\u013f")
+        buf.write("`\3\2\2\2\u0140\u0141\5_\60\2\u0141\u0142\7h\2\2\u0142")
+        buf.write("b\3\2\2\2\u0143\u0144\7k\2\2\u0144\u0145\7p\2\2\u0145")
+        buf.write("\u0146\7v\2\2\u0146\u0147\7\65\2\2\u0147\u0148\7\64\2")
+        buf.write("\2\u0148d\3\2\2\2\u0149\u014b\5o8\2\u014a\u0149\3\2\2")
+        buf.write("\2\u014b\u014c\3\2\2\2\u014c\u014a\3\2\2\2\u014c\u014d")
+        buf.write("\3\2\2\2\u014df\3\2\2\2\u014e\u0150\t\4\2\2\u014f\u0151")
+        buf.write("\t\5\2\2\u0150\u014f\3\2\2\2\u0150\u0151\3\2\2\2\u0151")
+        buf.write("\u0152\3\2\2\2\u0152\u0153\5e\63\2\u0153h\3\2\2\2\u0154")
+        buf.write("\u0155\t\6\2\2\u0155j\3\2\2\2\u0156\u0157\t\7\2\2\u0157")
+        buf.write("l\3\2\2\2\u0158\u0159\t\b\2\2\u0159n\3\2\2\2\u015a\u015b")
+        buf.write("\t\t\2\2\u015bp\3\2\2\2\u015c\u015d\7O\2\2\u015d\u015e")
+        buf.write("\7G\2\2\u015e\u015f\7V\2\2\u015f\u0160\7C\2\2\u0160\u0161")
+        buf.write("\7F\2\2\u0161\u0162\7C\2\2\u0162\u0163\7V\2\2\u0163\u0164")
+        buf.write("\7C\2\2\u0164\u0165\7<\2\2\u0165\u0169\3\2\2\2\u0166\u0168")
+        buf.write("\13\2\2\2\u0167\u0166\3\2\2\2\u0168\u016b\3\2\2\2\u0169")
+        buf.write("\u0167\3\2\2\2\u0169\u016a\3\2\2\2\u016ar\3\2\2\2\u016b")
+        buf.write("\u0169\3\2\2\2\23\2\u00d7\u00d9\u00e4\u00ee\u00fb\u00fd")
+        buf.write("\u0123\u0127\u012c\u012e\u0135\u013b\u013e\u014c\u0150")
+        buf.write("\u0169\3\b\2\2")
         return buf.getvalue()
 
 
@@ -215,8 +218,8 @@ class RelayLexer(Lexer):
     NE = 43
     BOOL_LIT = 44
     CNAME = 45
-    DATATYPE = 46
-    FLOAT = 47
+    FLOAT = 46
+    BASE_TYPE = 47
     NAT = 48
     METADATA = 49
 
@@ -230,12 +233,12 @@ class RelayLexer(Lexer):
             "'->'", "'def'", "'type'", "'|'", "'=>'", "'match'", "'match?'", 
             "'_'", "':'", "'Tensor'", "'meta'", "'v0.0.3'", "'*'", "'/'", 
             "'+'", "'-'", "'<'", "'>'", "'<='", "'>='", "'=='", "'!='", 
-            "'int64'" ]
+            "'int32'" ]
 
     symbolicNames = [ "<INVALID>",
             "SEMVER", "COMMENT", "WS", "LINE_COMMENT", "QUOTED_STRING", 
             "MUL", "DIV", "ADD", "SUB", "LT", "GT", "LE", "GE", "EQ", "NE", 
-            "BOOL_LIT", "CNAME", "DATATYPE", "FLOAT", "NAT", "METADATA" ]
+            "BOOL_LIT", "CNAME", "FLOAT", "BASE_TYPE", "NAT", "METADATA" ]
 
     ruleNames = [ "T__0", "T__1", "T__2", "T__3", "T__4", "T__5", "T__6", 
                   "T__7", "T__8", "T__9", "T__10", "T__11", "T__12", "T__13", 
@@ -244,8 +247,8 @@ class RelayLexer(Lexer):
                   "T__26", "T__27", "SEMVER", "COMMENT", "WS", "LINE_COMMENT", 
                   "ESCAPED_QUOTE", "QUOTED_STRING", "MUL", "DIV", "ADD", 
                   "SUB", "LT", "GT", "LE", "GE", "EQ", "NE", "BOOL_LIT", 
-                  "CNAME", "DATATYPE", "PREFLOAT", "FLOAT", "NAT", "EXP", 
-                  "LETTER", "DIGIT", "METADATA" ]
+                  "CNAME", "PREFLOAT", "FLOAT", "BASE_TYPE", "NAT", "EXP", 
+                  "LOWER_LETTER", "UPPER_LETTER", "LETTER", "DIGIT", "METADATA" ]
 
     grammarFileName = "Relay.g4"
 
diff --git a/python/tvm/relay/grammar/py3/RelayParser.py b/python/tvm/relay/grammar/py3/RelayParser.py
index 6f84a5572e7d..00b54f23f569 100644
--- a/python/tvm/relay/grammar/py3/RelayParser.py
+++ b/python/tvm/relay/grammar/py3/RelayParser.py
@@ -9,7 +9,7 @@
 def serializedATN():
     with StringIO() as buf:
         buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\63")
-        buf.write("\u01c1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
+        buf.write("\u01c0\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
         buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
         buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
         buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
@@ -45,82 +45,82 @@ def serializedATN():
         buf.write("\30\16\30\u0162\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30")
         buf.write("\3\30\3\30\3\30\3\30\3\30\3\30\3\30\5\30\u0174\n\30\3")
         buf.write("\30\3\30\3\30\3\30\7\30\u017a\n\30\f\30\16\30\u017d\13")
-        buf.write("\30\5\30\u017f\n\30\3\30\3\30\3\30\3\30\5\30\u0185\n\30")
-        buf.write("\3\31\3\31\3\31\3\31\7\31\u018b\n\31\f\31\16\31\u018e")
-        buf.write("\13\31\3\31\3\31\3\32\3\32\3\32\3\32\6\32\u0196\n\32\r")
-        buf.write("\32\16\32\u0197\3\32\3\32\3\32\3\32\3\32\5\32\u019f\n")
-        buf.write("\32\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\34\3\34")
-        buf.write("\3\34\3\34\3\34\3\34\5\34\u01af\n\34\3\35\3\35\3\35\3")
-        buf.write("\35\3\36\3\36\3\36\5\36\u01b8\n\36\3\37\3\37\3\37\3\37")
-        buf.write("\3\37\5\37\u01bf\n\37\3\37\2\3\22 \2\4\6\b\n\f\16\20\22")
-        buf.write("\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<\2\7\3\2$%\3")
-        buf.write("\2&\'\3\2(+\3\2,-\3\2\31\32\2\u01ec\2>\3\2\2\2\4M\3\2")
-        buf.write("\2\2\6O\3\2\2\2\bR\3\2\2\2\nU\3\2\2\2\fW\3\2\2\2\16b\3")
-        buf.write("\2\2\2\20n\3\2\2\2\22\u00be\3\2\2\2\24\u00dc\3\2\2\2\26")
-        buf.write("\u0102\3\2\2\2\30\u0104\3\2\2\2\32\u0113\3\2\2\2\34\u011b")
-        buf.write("\3\2\2\2\36\u011d\3\2\2\2 \u012a\3\2\2\2\"\u012c\3\2\2")
-        buf.write("\2$\u0138\3\2\2\2&\u0142\3\2\2\2(\u0144\3\2\2\2*\u0149")
-        buf.write("\3\2\2\2,\u0151\3\2\2\2.\u0184\3\2\2\2\60\u0186\3\2\2")
-        buf.write("\2\62\u019e\3\2\2\2\64\u01a0\3\2\2\2\66\u01ae\3\2\2\2")
-        buf.write("8\u01b0\3\2\2\2:\u01b7\3\2\2\2<\u01be\3\2\2\2>F\7\37\2")
-        buf.write("\2?A\5\26\f\2@?\3\2\2\2AD\3\2\2\2B@\3\2\2\2BC\3\2\2\2")
-        buf.write("CG\3\2\2\2DB\3\2\2\2EG\5\22\n\2FB\3\2\2\2FE\3\2\2\2GI")
-        buf.write("\3\2\2\2HJ\7\63\2\2IH\3\2\2\2IJ\3\2\2\2JK\3\2\2\2KL\7")
-        buf.write("\2\2\3L\3\3\2\2\2MN\7/\2\2N\5\3\2\2\2OP\7\3\2\2PQ\7/\2")
-        buf.write("\2Q\7\3\2\2\2RS\7\4\2\2ST\7/\2\2T\t\3\2\2\2UV\7/\2\2V")
-        buf.write("\13\3\2\2\2WX\7\4\2\2XY\7\62\2\2Y\r\3\2\2\2Z_\5\22\n\2")
-        buf.write("[\\\7\5\2\2\\^\5\22\n\2][\3\2\2\2^a\3\2\2\2_]\3\2\2\2")
-        buf.write("_`\3\2\2\2`c\3\2\2\2a_\3\2\2\2bZ\3\2\2\2bc\3\2\2\2c\17")
-        buf.write("\3\2\2\2do\5\16\b\2ef\5\22\n\2fg\7\5\2\2gi\3\2\2\2he\3")
-        buf.write("\2\2\2il\3\2\2\2jh\3\2\2\2jk\3\2\2\2km\3\2\2\2lj\3\2\2")
-        buf.write("\2mo\5*\26\2nd\3\2\2\2nj\3\2\2\2o\21\3\2\2\2pq\b\n\1\2")
-        buf.write("qr\7\6\2\2rs\5\22\n\2st\7\7\2\2t\u00bf\3\2\2\2uv\7\b\2")
-        buf.write("\2vw\5\22\n\2wx\7\t\2\2x\u00bf\3\2\2\2yz\7\'\2\2z\u00bf")
-        buf.write("\5\22\n\26{\u00bf\5\24\13\2|}\7\6\2\2}\u00bf\7\7\2\2~")
-        buf.write("\177\7\6\2\2\177\u0080\5\22\n\2\u0080\u0081\7\5\2\2\u0081")
-        buf.write("\u0082\7\7\2\2\u0082\u00bf\3\2\2\2\u0083\u0084\7\6\2\2")
-        buf.write("\u0084\u0087\5\22\n\2\u0085\u0086\7\5\2\2\u0086\u0088")
-        buf.write("\5\22\n\2\u0087\u0085\3\2\2\2\u0088\u0089\3\2\2\2\u0089")
-        buf.write("\u0087\3\2\2\2\u0089\u008a\3\2\2\2\u008a\u008b\3\2\2\2")
-        buf.write("\u008b\u008c\7\7\2\2\u008c\u00bf\3\2\2\2\u008d\u0096\7")
-        buf.write("\n\2\2\u008e\u0093\5\22\n\2\u008f\u0090\7\5\2\2\u0090")
-        buf.write("\u0092\5\22\n\2\u0091\u008f\3\2\2\2\u0092\u0095\3\2\2")
-        buf.write("\2\u0093\u0091\3\2\2\2\u0093\u0094\3\2\2\2\u0094\u0097")
-        buf.write("\3\2\2\2\u0095\u0093\3\2\2\2\u0096\u008e\3\2\2\2\u0096")
-        buf.write("\u0097\3\2\2\2\u0097\u0098\3\2\2\2\u0098\u00bf\7\13\2")
-        buf.write("\2\u0099\u009a\7\f\2\2\u009a\u009b\7\6\2\2\u009b\u009c")
-        buf.write("\5\22\n\2\u009c\u009d\7\7\2\2\u009d\u009e\58\35\2\u009e")
-        buf.write("\u009f\7\r\2\2\u009f\u00a0\58\35\2\u00a0\u00bf\3\2\2\2")
-        buf.write("\u00a1\u00a2\5\34\17\2\u00a2\u00a3\7\6\2\2\u00a3\u00a4")
-        buf.write("\5\22\n\2\u00a4\u00a5\7\7\2\2\u00a5\u00a7\7\b\2\2\u00a6")
-        buf.write("\u00a8\5\32\16\2\u00a7\u00a6\3\2\2\2\u00a8\u00a9\3\2\2")
-        buf.write("\2\u00a9\u00a7\3\2\2\2\u00a9\u00aa\3\2\2\2\u00aa\u00ab")
-        buf.write("\3\2\2\2\u00ab\u00ac\7\t\2\2\u00ac\u00bf\3\2\2\2\u00ad")
-        buf.write("\u00ae\7\17\2\2\u00ae\u00af\5(\25\2\u00af\u00b0\7\20\2")
-        buf.write("\2\u00b0\u00b1\5\22\n\2\u00b1\u00b2\7\21\2\2\u00b2\u00b3")
-        buf.write("\5\22\n\t\u00b3\u00bf\3\2\2\2\u00b4\u00b5\5\f\7\2\u00b5")
-        buf.write("\u00b6\7\20\2\2\u00b6\u00b7\5\22\n\2\u00b7\u00b8\7\21")
-        buf.write("\2\2\u00b8\u00b9\5\22\n\7\u00b9\u00bf\3\2\2\2\u00ba\u00bf")
-        buf.write("\5<\37\2\u00bb\u00bf\5:\36\2\u00bc\u00bf\5\64\33\2\u00bd")
-        buf.write("\u00bf\7#\2\2\u00bep\3\2\2\2\u00beu\3\2\2\2\u00bey\3\2")
-        buf.write("\2\2\u00be{\3\2\2\2\u00be|\3\2\2\2\u00be~\3\2\2\2\u00be")
-        buf.write("\u0083\3\2\2\2\u00be\u008d\3\2\2\2\u00be\u0099\3\2\2\2")
-        buf.write("\u00be\u00a1\3\2\2\2\u00be\u00ad\3\2\2\2\u00be\u00b4\3")
-        buf.write("\2\2\2\u00be\u00ba\3\2\2\2\u00be\u00bb\3\2\2\2\u00be\u00bc")
-        buf.write("\3\2\2\2\u00be\u00bd\3\2\2\2\u00bf\u00d9\3\2\2\2\u00c0")
-        buf.write("\u00c1\f\25\2\2\u00c1\u00c2\t\2\2\2\u00c2\u00d8\5\22\n")
-        buf.write("\26\u00c3\u00c4\f\24\2\2\u00c4\u00c5\t\3\2\2\u00c5\u00d8")
-        buf.write("\5\22\n\25\u00c6\u00c7\f\23\2\2\u00c7\u00c8\t\4\2\2\u00c8")
-        buf.write("\u00d8\5\22\n\24\u00c9\u00ca\f\22\2\2\u00ca\u00cb\t\5")
-        buf.write("\2\2\u00cb\u00d8\5\22\n\23\u00cc\u00cd\f\b\2\2\u00cd\u00ce")
-        buf.write("\7\22\2\2\u00ce\u00d8\5\22\n\t\u00cf\u00d0\f\27\2\2\u00d0")
-        buf.write("\u00d1\7\6\2\2\u00d1\u00d2\5\20\t\2\u00d2\u00d3\7\7\2")
-        buf.write("\2\u00d3\u00d8\3\2\2\2\u00d4\u00d5\f\n\2\2\u00d5\u00d6")
-        buf.write("\7\16\2\2\u00d6\u00d8\7\62\2\2\u00d7\u00c0\3\2\2\2\u00d7")
-        buf.write("\u00c3\3\2\2\2\u00d7\u00c6\3\2\2\2\u00d7\u00c9\3\2\2\2")
-        buf.write("\u00d7\u00cc\3\2\2\2\u00d7\u00cf\3\2\2\2\u00d7\u00d4\3")
-        buf.write("\2\2\2\u00d8\u00db\3\2\2\2\u00d9\u00d7\3\2\2\2\u00d9\u00da")
-        buf.write("\3\2\2\2\u00da\23\3\2\2\2\u00db\u00d9\3\2\2\2\u00dc\u00de")
+        buf.write("\30\5\30\u017f\n\30\3\30\3\30\3\30\5\30\u0184\n\30\3\31")
+        buf.write("\3\31\3\31\3\31\7\31\u018a\n\31\f\31\16\31\u018d\13\31")
+        buf.write("\3\31\3\31\3\32\3\32\3\32\3\32\6\32\u0195\n\32\r\32\16")
+        buf.write("\32\u0196\3\32\3\32\3\32\3\32\3\32\5\32\u019e\n\32\3\33")
+        buf.write("\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\34\3\34\3\34\3\34")
+        buf.write("\3\34\3\34\5\34\u01ae\n\34\3\35\3\35\3\35\3\35\3\36\3")
+        buf.write("\36\3\36\5\36\u01b7\n\36\3\37\3\37\3\37\3\37\3\37\5\37")
+        buf.write("\u01be\n\37\3\37\2\3\22 \2\4\6\b\n\f\16\20\22\24\26\30")
+        buf.write("\32\34\36 \"$&(*,.\60\62\64\668:<\2\7\3\2$%\3\2&\'\3\2")
+        buf.write("(+\3\2,-\3\2\31\32\2\u01ea\2>\3\2\2\2\4M\3\2\2\2\6O\3")
+        buf.write("\2\2\2\bR\3\2\2\2\nU\3\2\2\2\fW\3\2\2\2\16b\3\2\2\2\20")
+        buf.write("n\3\2\2\2\22\u00be\3\2\2\2\24\u00dc\3\2\2\2\26\u0102\3")
+        buf.write("\2\2\2\30\u0104\3\2\2\2\32\u0113\3\2\2\2\34\u011b\3\2")
+        buf.write("\2\2\36\u011d\3\2\2\2 \u012a\3\2\2\2\"\u012c\3\2\2\2$")
+        buf.write("\u0138\3\2\2\2&\u0142\3\2\2\2(\u0144\3\2\2\2*\u0149\3")
+        buf.write("\2\2\2,\u0151\3\2\2\2.\u0183\3\2\2\2\60\u0185\3\2\2\2")
+        buf.write("\62\u019d\3\2\2\2\64\u019f\3\2\2\2\66\u01ad\3\2\2\28\u01af")
+        buf.write("\3\2\2\2:\u01b6\3\2\2\2<\u01bd\3\2\2\2>F\7\37\2\2?A\5")
+        buf.write("\26\f\2@?\3\2\2\2AD\3\2\2\2B@\3\2\2\2BC\3\2\2\2CG\3\2")
+        buf.write("\2\2DB\3\2\2\2EG\5\22\n\2FB\3\2\2\2FE\3\2\2\2GI\3\2\2")
+        buf.write("\2HJ\7\63\2\2IH\3\2\2\2IJ\3\2\2\2JK\3\2\2\2KL\7\2\2\3")
+        buf.write("L\3\3\2\2\2MN\7/\2\2N\5\3\2\2\2OP\7\3\2\2PQ\7/\2\2Q\7")
+        buf.write("\3\2\2\2RS\7\4\2\2ST\7/\2\2T\t\3\2\2\2UV\7/\2\2V\13\3")
+        buf.write("\2\2\2WX\7\4\2\2XY\7\62\2\2Y\r\3\2\2\2Z_\5\22\n\2[\\\7")
+        buf.write("\5\2\2\\^\5\22\n\2][\3\2\2\2^a\3\2\2\2_]\3\2\2\2_`\3\2")
+        buf.write("\2\2`c\3\2\2\2a_\3\2\2\2bZ\3\2\2\2bc\3\2\2\2c\17\3\2\2")
+        buf.write("\2do\5\16\b\2ef\5\22\n\2fg\7\5\2\2gi\3\2\2\2he\3\2\2\2")
+        buf.write("il\3\2\2\2jh\3\2\2\2jk\3\2\2\2km\3\2\2\2lj\3\2\2\2mo\5")
+        buf.write("*\26\2nd\3\2\2\2nj\3\2\2\2o\21\3\2\2\2pq\b\n\1\2qr\7\6")
+        buf.write("\2\2rs\5\22\n\2st\7\7\2\2t\u00bf\3\2\2\2uv\7\b\2\2vw\5")
+        buf.write("\22\n\2wx\7\t\2\2x\u00bf\3\2\2\2yz\7\'\2\2z\u00bf\5\22")
+        buf.write("\n\26{\u00bf\5\24\13\2|}\7\6\2\2}\u00bf\7\7\2\2~\177\7")
+        buf.write("\6\2\2\177\u0080\5\22\n\2\u0080\u0081\7\5\2\2\u0081\u0082")
+        buf.write("\7\7\2\2\u0082\u00bf\3\2\2\2\u0083\u0084\7\6\2\2\u0084")
+        buf.write("\u0087\5\22\n\2\u0085\u0086\7\5\2\2\u0086\u0088\5\22\n")
+        buf.write("\2\u0087\u0085\3\2\2\2\u0088\u0089\3\2\2\2\u0089\u0087")
+        buf.write("\3\2\2\2\u0089\u008a\3\2\2\2\u008a\u008b\3\2\2\2\u008b")
+        buf.write("\u008c\7\7\2\2\u008c\u00bf\3\2\2\2\u008d\u0096\7\n\2\2")
+        buf.write("\u008e\u0093\5\22\n\2\u008f\u0090\7\5\2\2\u0090\u0092")
+        buf.write("\5\22\n\2\u0091\u008f\3\2\2\2\u0092\u0095\3\2\2\2\u0093")
+        buf.write("\u0091\3\2\2\2\u0093\u0094\3\2\2\2\u0094\u0097\3\2\2\2")
+        buf.write("\u0095\u0093\3\2\2\2\u0096\u008e\3\2\2\2\u0096\u0097\3")
+        buf.write("\2\2\2\u0097\u0098\3\2\2\2\u0098\u00bf\7\13\2\2\u0099")
+        buf.write("\u009a\7\f\2\2\u009a\u009b\7\6\2\2\u009b\u009c\5\22\n")
+        buf.write("\2\u009c\u009d\7\7\2\2\u009d\u009e\58\35\2\u009e\u009f")
+        buf.write("\7\r\2\2\u009f\u00a0\58\35\2\u00a0\u00bf\3\2\2\2\u00a1")
+        buf.write("\u00a2\5\34\17\2\u00a2\u00a3\7\6\2\2\u00a3\u00a4\5\22")
+        buf.write("\n\2\u00a4\u00a5\7\7\2\2\u00a5\u00a7\7\b\2\2\u00a6\u00a8")
+        buf.write("\5\32\16\2\u00a7\u00a6\3\2\2\2\u00a8\u00a9\3\2\2\2\u00a9")
+        buf.write("\u00a7\3\2\2\2\u00a9\u00aa\3\2\2\2\u00aa\u00ab\3\2\2\2")
+        buf.write("\u00ab\u00ac\7\t\2\2\u00ac\u00bf\3\2\2\2\u00ad\u00ae\7")
+        buf.write("\17\2\2\u00ae\u00af\5(\25\2\u00af\u00b0\7\20\2\2\u00b0")
+        buf.write("\u00b1\5\22\n\2\u00b1\u00b2\7\21\2\2\u00b2\u00b3\5\22")
+        buf.write("\n\t\u00b3\u00bf\3\2\2\2\u00b4\u00b5\5\f\7\2\u00b5\u00b6")
+        buf.write("\7\20\2\2\u00b6\u00b7\5\22\n\2\u00b7\u00b8\7\21\2\2\u00b8")
+        buf.write("\u00b9\5\22\n\7\u00b9\u00bf\3\2\2\2\u00ba\u00bf\5<\37")
+        buf.write("\2\u00bb\u00bf\5:\36\2\u00bc\u00bf\5\64\33\2\u00bd\u00bf")
+        buf.write("\7#\2\2\u00bep\3\2\2\2\u00beu\3\2\2\2\u00bey\3\2\2\2\u00be")
+        buf.write("{\3\2\2\2\u00be|\3\2\2\2\u00be~\3\2\2\2\u00be\u0083\3")
+        buf.write("\2\2\2\u00be\u008d\3\2\2\2\u00be\u0099\3\2\2\2\u00be\u00a1")
+        buf.write("\3\2\2\2\u00be\u00ad\3\2\2\2\u00be\u00b4\3\2\2\2\u00be")
+        buf.write("\u00ba\3\2\2\2\u00be\u00bb\3\2\2\2\u00be\u00bc\3\2\2\2")
+        buf.write("\u00be\u00bd\3\2\2\2\u00bf\u00d9\3\2\2\2\u00c0\u00c1\f")
+        buf.write("\25\2\2\u00c1\u00c2\t\2\2\2\u00c2\u00d8\5\22\n\26\u00c3")
+        buf.write("\u00c4\f\24\2\2\u00c4\u00c5\t\3\2\2\u00c5\u00d8\5\22\n")
+        buf.write("\25\u00c6\u00c7\f\23\2\2\u00c7\u00c8\t\4\2\2\u00c8\u00d8")
+        buf.write("\5\22\n\24\u00c9\u00ca\f\22\2\2\u00ca\u00cb\t\5\2\2\u00cb")
+        buf.write("\u00d8\5\22\n\23\u00cc\u00cd\f\b\2\2\u00cd\u00ce\7\22")
+        buf.write("\2\2\u00ce\u00d8\5\22\n\t\u00cf\u00d0\f\27\2\2\u00d0\u00d1")
+        buf.write("\7\6\2\2\u00d1\u00d2\5\20\t\2\u00d2\u00d3\7\7\2\2\u00d3")
+        buf.write("\u00d8\3\2\2\2\u00d4\u00d5\f\n\2\2\u00d5\u00d6\7\16\2")
+        buf.write("\2\u00d6\u00d8\7\62\2\2\u00d7\u00c0\3\2\2\2\u00d7\u00c3")
+        buf.write("\3\2\2\2\u00d7\u00c6\3\2\2\2\u00d7\u00c9\3\2\2\2\u00d7")
+        buf.write("\u00cc\3\2\2\2\u00d7\u00cf\3\2\2\2\u00d7\u00d4\3\2\2\2")
+        buf.write("\u00d8\u00db\3\2\2\2\u00d9\u00d7\3\2\2\2\u00d9\u00da\3")
+        buf.write("\2\2\2\u00da\23\3\2\2\2\u00db\u00d9\3\2\2\2\u00dc\u00de")
         buf.write("\7\23\2\2\u00dd\u00df\5\60\31\2\u00de\u00dd\3\2\2\2\u00de")
         buf.write("\u00df\3\2\2\2\u00df\u00e0\3\2\2\2\u00e0\u00e1\7\6\2\2")
         buf.write("\u00e1\u00e2\5$\23\2\u00e2\u00e5\7\7\2\2\u00e3\u00e4\7")
@@ -171,17 +171,17 @@ def serializedATN():
         buf.write("\u014d\u0150\3\2\2\2\u014e\u014c\3\2\2\2\u014e\u014f\3")
         buf.write("\2\2\2\u014f+\3\2\2\2\u0150\u014e\3\2\2\2\u0151\u0152")
         buf.write("\7/\2\2\u0152\u0153\7\20\2\2\u0153\u0154\5\22\n\2\u0154")
-        buf.write("-\3\2\2\2\u0155\u0156\7\6\2\2\u0156\u0185\7\7\2\2\u0157")
+        buf.write("-\3\2\2\2\u0155\u0156\7\6\2\2\u0156\u0184\7\7\2\2\u0157")
         buf.write("\u0158\7\6\2\2\u0158\u0159\5.\30\2\u0159\u015a\7\5\2\2")
-        buf.write("\u015a\u015b\7\7\2\2\u015b\u0185\3\2\2\2\u015c\u015d\7")
+        buf.write("\u015a\u015b\7\7\2\2\u015b\u0184\3\2\2\2\u015c\u015d\7")
         buf.write("\6\2\2\u015d\u0160\5.\30\2\u015e\u015f\7\5\2\2\u015f\u0161")
         buf.write("\5.\30\2\u0160\u015e\3\2\2\2\u0161\u0162\3\2\2\2\u0162")
         buf.write("\u0160\3\2\2\2\u0162\u0163\3\2\2\2\u0163\u0164\3\2\2\2")
-        buf.write("\u0164\u0165\7\7\2\2\u0165\u0185\3\2\2\2\u0166\u0167\5")
-        buf.write("\n\6\2\u0167\u0168\5\60\31\2\u0168\u0185\3\2\2\2\u0169")
-        buf.write("\u0185\5\n\6\2\u016a\u016b\7\35\2\2\u016b\u016c\7\n\2")
+        buf.write("\u0164\u0165\7\7\2\2\u0165\u0184\3\2\2\2\u0166\u0167\5")
+        buf.write("\n\6\2\u0167\u0168\5\60\31\2\u0168\u0184\3\2\2\2\u0169")
+        buf.write("\u0184\5\n\6\2\u016a\u016b\7\35\2\2\u016b\u016c\7\n\2")
         buf.write("\2\u016c\u016d\5\62\32\2\u016d\u016e\7\5\2\2\u016e\u016f")
-        buf.write("\5.\30\2\u016f\u0170\7\13\2\2\u0170\u0185\3\2\2\2\u0171")
+        buf.write("\5.\30\2\u016f\u0170\7\13\2\2\u0170\u0184\3\2\2\2\u0171")
         buf.write("\u0173\7\23\2\2\u0172\u0174\5\60\31\2\u0173\u0172\3\2")
         buf.write("\2\2\u0173\u0174\3\2\2\2\u0174\u0175\3\2\2\2\u0175\u017e")
         buf.write("\7\6\2\2\u0176\u017b\5.\30\2\u0177\u0178\7\5\2\2\u0178")
@@ -189,40 +189,40 @@ def serializedATN():
         buf.write("\u017b\u0179\3\2\2\2\u017b\u017c\3\2\2\2\u017c\u017f\3")
         buf.write("\2\2\2\u017d\u017b\3\2\2\2\u017e\u0176\3\2\2\2\u017e\u017f")
         buf.write("\3\2\2\2\u017f\u0180\3\2\2\2\u0180\u0181\7\7\2\2\u0181")
-        buf.write("\u0182\7\24\2\2\u0182\u0185\5.\30\2\u0183\u0185\7\33\2")
-        buf.write("\2\u0184\u0155\3\2\2\2\u0184\u0157\3\2\2\2\u0184\u015c")
-        buf.write("\3\2\2\2\u0184\u0166\3\2\2\2\u0184\u0169\3\2\2\2\u0184")
-        buf.write("\u016a\3\2\2\2\u0184\u0171\3\2\2\2\u0184\u0183\3\2\2\2")
-        buf.write("\u0185/\3\2\2\2\u0186\u0187\7\n\2\2\u0187\u018c\5\n\6")
-        buf.write("\2\u0188\u0189\7\5\2\2\u0189\u018b\5\n\6\2\u018a\u0188")
-        buf.write("\3\2\2\2\u018b\u018e\3\2\2\2\u018c\u018a\3\2\2\2\u018c")
-        buf.write("\u018d\3\2\2\2\u018d\u018f\3\2\2\2\u018e\u018c\3\2\2\2")
-        buf.write("\u018f\u0190\7\13\2\2\u0190\61\3\2\2\2\u0191\u0192\7\6")
-        buf.write("\2\2\u0192\u0195\5\66\34\2\u0193\u0194\7\5\2\2\u0194\u0196")
-        buf.write("\5\66\34\2\u0195\u0193\3\2\2\2\u0196\u0197\3\2\2\2\u0197")
-        buf.write("\u0195\3\2\2\2\u0197\u0198\3\2\2\2\u0198\u0199\3\2\2\2")
-        buf.write("\u0199\u019a\7\7\2\2\u019a\u019f\3\2\2\2\u019b\u019c\7")
-        buf.write("\6\2\2\u019c\u019f\7\7\2\2\u019d\u019f\5\66\34\2\u019e")
-        buf.write("\u0191\3\2\2\2\u019e\u019b\3\2\2\2\u019e\u019d\3\2\2\2")
-        buf.write("\u019f\63\3\2\2\2\u01a0\u01a1\7\36\2\2\u01a1\u01a2\7\n")
-        buf.write("\2\2\u01a2\u01a3\7/\2\2\u01a3\u01a4\7\13\2\2\u01a4\u01a5")
-        buf.write("\7\n\2\2\u01a5\u01a6\7\62\2\2\u01a6\u01a7\7\13\2\2\u01a7")
-        buf.write("\65\3\2\2\2\u01a8\u01af\5\64\33\2\u01a9\u01aa\7\6\2\2")
-        buf.write("\u01aa\u01ab\5\66\34\2\u01ab\u01ac\7\7\2\2\u01ac\u01af")
-        buf.write("\3\2\2\2\u01ad\u01af\7\62\2\2\u01ae\u01a8\3\2\2\2\u01ae")
-        buf.write("\u01a9\3\2\2\2\u01ae\u01ad\3\2\2\2\u01af\67\3\2\2\2\u01b0")
-        buf.write("\u01b1\7\b\2\2\u01b1\u01b2\5\22\n\2\u01b2\u01b3\7\t\2")
-        buf.write("\2\u01b39\3\2\2\2\u01b4\u01b8\7\61\2\2\u01b5\u01b8\7\62")
-        buf.write("\2\2\u01b6\u01b8\7.\2\2\u01b7\u01b4\3\2\2\2\u01b7\u01b5")
-        buf.write("\3\2\2\2\u01b7\u01b6\3\2\2\2\u01b8;\3\2\2\2\u01b9\u01bf")
-        buf.write("\5\4\3\2\u01ba\u01bf\5\6\4\2\u01bb\u01bf\5\b\5\2\u01bc")
-        buf.write("\u01bf\5.\30\2\u01bd\u01bf\5\f\7\2\u01be\u01b9\3\2\2\2")
-        buf.write("\u01be\u01ba\3\2\2\2\u01be\u01bb\3\2\2\2\u01be\u01bc\3")
-        buf.write("\2\2\2\u01be\u01bd\3\2\2\2\u01bf=\3\2\2\2-BFI_bjn\u0089")
-        buf.write("\u0093\u0096\u00a9\u00be\u00d7\u00d9\u00de\u00e5\u00ec")
-        buf.write("\u00f3\u00fa\u0100\u0102\u010c\u0111\u0116\u0123\u012a")
-        buf.write("\u0134\u0138\u013f\u0142\u0147\u014e\u0162\u0173\u017b")
-        buf.write("\u017e\u0184\u018c\u0197\u019e\u01ae\u01b7\u01be")
+        buf.write("\u0182\7\24\2\2\u0182\u0184\5.\30\2\u0183\u0155\3\2\2")
+        buf.write("\2\u0183\u0157\3\2\2\2\u0183\u015c\3\2\2\2\u0183\u0166")
+        buf.write("\3\2\2\2\u0183\u0169\3\2\2\2\u0183\u016a\3\2\2\2\u0183")
+        buf.write("\u0171\3\2\2\2\u0184/\3\2\2\2\u0185\u0186\7\n\2\2\u0186")
+        buf.write("\u018b\5\n\6\2\u0187\u0188\7\5\2\2\u0188\u018a\5\n\6\2")
+        buf.write("\u0189\u0187\3\2\2\2\u018a\u018d\3\2\2\2\u018b\u0189\3")
+        buf.write("\2\2\2\u018b\u018c\3\2\2\2\u018c\u018e\3\2\2\2\u018d\u018b")
+        buf.write("\3\2\2\2\u018e\u018f\7\13\2\2\u018f\61\3\2\2\2\u0190\u0191")
+        buf.write("\7\6\2\2\u0191\u0194\5\66\34\2\u0192\u0193\7\5\2\2\u0193")
+        buf.write("\u0195\5\66\34\2\u0194\u0192\3\2\2\2\u0195\u0196\3\2\2")
+        buf.write("\2\u0196\u0194\3\2\2\2\u0196\u0197\3\2\2\2\u0197\u0198")
+        buf.write("\3\2\2\2\u0198\u0199\7\7\2\2\u0199\u019e\3\2\2\2\u019a")
+        buf.write("\u019b\7\6\2\2\u019b\u019e\7\7\2\2\u019c\u019e\5\66\34")
+        buf.write("\2\u019d\u0190\3\2\2\2\u019d\u019a\3\2\2\2\u019d\u019c")
+        buf.write("\3\2\2\2\u019e\63\3\2\2\2\u019f\u01a0\7\36\2\2\u01a0\u01a1")
+        buf.write("\7\n\2\2\u01a1\u01a2\7/\2\2\u01a2\u01a3\7\13\2\2\u01a3")
+        buf.write("\u01a4\7\n\2\2\u01a4\u01a5\7\62\2\2\u01a5\u01a6\7\13\2")
+        buf.write("\2\u01a6\65\3\2\2\2\u01a7\u01ae\5\64\33\2\u01a8\u01a9")
+        buf.write("\7\6\2\2\u01a9\u01aa\5\66\34\2\u01aa\u01ab\7\7\2\2\u01ab")
+        buf.write("\u01ae\3\2\2\2\u01ac\u01ae\7\62\2\2\u01ad\u01a7\3\2\2")
+        buf.write("\2\u01ad\u01a8\3\2\2\2\u01ad\u01ac\3\2\2\2\u01ae\67\3")
+        buf.write("\2\2\2\u01af\u01b0\7\b\2\2\u01b0\u01b1\5\22\n\2\u01b1")
+        buf.write("\u01b2\7\t\2\2\u01b29\3\2\2\2\u01b3\u01b7\7\60\2\2\u01b4")
+        buf.write("\u01b7\7\62\2\2\u01b5\u01b7\7.\2\2\u01b6\u01b3\3\2\2\2")
+        buf.write("\u01b6\u01b4\3\2\2\2\u01b6\u01b5\3\2\2\2\u01b7;\3\2\2")
+        buf.write("\2\u01b8\u01be\5\4\3\2\u01b9\u01be\5\6\4\2\u01ba\u01be")
+        buf.write("\5\b\5\2\u01bb\u01be\5.\30\2\u01bc\u01be\5\f\7\2\u01bd")
+        buf.write("\u01b8\3\2\2\2\u01bd\u01b9\3\2\2\2\u01bd\u01ba\3\2\2\2")
+        buf.write("\u01bd\u01bb\3\2\2\2\u01bd\u01bc\3\2\2\2\u01be=\3\2\2")
+        buf.write("\2-BFI_bjn\u0089\u0093\u0096\u00a9\u00be\u00d7\u00d9\u00de")
+        buf.write("\u00e5\u00ec\u00f3\u00fa\u0100\u0102\u010c\u0111\u0116")
+        buf.write("\u0123\u012a\u0134\u0138\u013f\u0142\u0147\u014e\u0162")
+        buf.write("\u0173\u017b\u017e\u0183\u018b\u0196\u019d\u01ad\u01b6")
+        buf.write("\u01bd")
         return buf.getvalue()
 
 
@@ -243,7 +243,7 @@ class RelayParser ( Parser ):
                      "'Tensor'", "'meta'", "'v0.0.3'", "<INVALID>", "<INVALID>", 
                      "<INVALID>", "<INVALID>", "'*'", "'/'", "'+'", "'-'", 
                      "'<'", "'>'", "'<='", "'>='", "'=='", "'!='", "<INVALID>", 
-                     "<INVALID>", "'int64'" ]
+                     "<INVALID>", "<INVALID>", "'int32'" ]
 
     symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
@@ -255,7 +255,7 @@ class RelayParser ( Parser ):
                       "<INVALID>", "SEMVER", "COMMENT", "WS", "LINE_COMMENT", 
                       "QUOTED_STRING", "MUL", "DIV", "ADD", "SUB", "LT", 
                       "GT", "LE", "GE", "EQ", "NE", "BOOL_LIT", "CNAME", 
-                      "DATATYPE", "FLOAT", "NAT", "METADATA" ]
+                      "FLOAT", "BASE_TYPE", "NAT", "METADATA" ]
 
     RULE_prog = 0
     RULE_opIdent = 1
@@ -341,8 +341,8 @@ class RelayParser ( Parser ):
     NE=43
     BOOL_LIT=44
     CNAME=45
-    DATATYPE=46
-    FLOAT=47
+    FLOAT=46
+    BASE_TYPE=47
     NAT=48
     METADATA=49
 
@@ -417,7 +417,7 @@ def prog(self):
                     _la = self._input.LA(1)
 
                 pass
-            elif token in [RelayParser.T__0, RelayParser.T__1, RelayParser.T__3, RelayParser.T__5, RelayParser.T__7, RelayParser.T__9, RelayParser.T__12, RelayParser.T__16, RelayParser.T__22, RelayParser.T__23, RelayParser.T__24, RelayParser.T__26, RelayParser.T__27, RelayParser.QUOTED_STRING, RelayParser.SUB, RelayParser.BOOL_LIT, RelayParser.CNAME, RelayParser.FLOAT, RelayParser.NAT]:
+            elif token in [RelayParser.T__0, RelayParser.T__1, RelayParser.T__3, RelayParser.T__5, RelayParser.T__7, RelayParser.T__9, RelayParser.T__12, RelayParser.T__16, RelayParser.T__22, RelayParser.T__23, RelayParser.T__26, RelayParser.T__27, RelayParser.QUOTED_STRING, RelayParser.SUB, RelayParser.BOOL_LIT, RelayParser.CNAME, RelayParser.FLOAT, RelayParser.NAT]:
                 self.state = 67
                 self.expr(0)
                 pass
@@ -674,7 +674,7 @@ def exprList(self):
             self.state = 96
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__0) | (1 << RelayParser.T__1) | (1 << RelayParser.T__3) | (1 << RelayParser.T__5) | (1 << RelayParser.T__7) | (1 << RelayParser.T__9) | (1 << RelayParser.T__12) | (1 << RelayParser.T__16) | (1 << RelayParser.T__22) | (1 << RelayParser.T__23) | (1 << RelayParser.T__24) | (1 << RelayParser.T__26) | (1 << RelayParser.T__27) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
+            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__0) | (1 << RelayParser.T__1) | (1 << RelayParser.T__3) | (1 << RelayParser.T__5) | (1 << RelayParser.T__7) | (1 << RelayParser.T__9) | (1 << RelayParser.T__12) | (1 << RelayParser.T__16) | (1 << RelayParser.T__22) | (1 << RelayParser.T__23) | (1 << RelayParser.T__26) | (1 << RelayParser.T__27) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
                 self.state = 88
                 self.expr(0)
                 self.state = 93
@@ -1268,7 +1268,7 @@ def expr(self, _p:int=0):
                 self.state = 148
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__0) | (1 << RelayParser.T__1) | (1 << RelayParser.T__3) | (1 << RelayParser.T__5) | (1 << RelayParser.T__7) | (1 << RelayParser.T__9) | (1 << RelayParser.T__12) | (1 << RelayParser.T__16) | (1 << RelayParser.T__22) | (1 << RelayParser.T__23) | (1 << RelayParser.T__24) | (1 << RelayParser.T__26) | (1 << RelayParser.T__27) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
+                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__0) | (1 << RelayParser.T__1) | (1 << RelayParser.T__3) | (1 << RelayParser.T__5) | (1 << RelayParser.T__7) | (1 << RelayParser.T__9) | (1 << RelayParser.T__12) | (1 << RelayParser.T__16) | (1 << RelayParser.T__22) | (1 << RelayParser.T__23) | (1 << RelayParser.T__26) | (1 << RelayParser.T__27) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
                     self.state = 140
                     self.expr(0)
                     self.state = 145
@@ -2501,20 +2501,6 @@ def accept(self, visitor:ParseTreeVisitor):
                 return visitor.visitChildren(self)
 
 
-    class IncompleteTypeContext(TypeExprContext):
-
-        def __init__(self, parser, ctx:ParserRuleContext): # actually a RelayParser.TypeExprContext
-            super().__init__(parser)
-            self.copyFrom(ctx)
-
-
-        def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitIncompleteType" ):
-                return visitor.visitIncompleteType(self)
-            else:
-                return visitor.visitChildren(self)
-
-
     class TensorTypeContext(TypeExprContext):
 
         def __init__(self, parser, ctx:ParserRuleContext): # actually a RelayParser.TypeExprContext
@@ -2565,7 +2551,7 @@ def typeExpr(self):
         self.enterRule(localctx, 44, self.RULE_typeExpr)
         self._la = 0 # Token type
         try:
-            self.state = 386
+            self.state = 385
             self._errHandler.sync(self)
             la_ = self._interp.adaptivePredict(self._input,36,self._ctx)
             if la_ == 1:
@@ -2666,7 +2652,7 @@ def typeExpr(self):
                 self.state = 380
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__3) | (1 << RelayParser.T__16) | (1 << RelayParser.T__24) | (1 << RelayParser.T__26) | (1 << RelayParser.CNAME))) != 0):
+                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__3) | (1 << RelayParser.T__16) | (1 << RelayParser.T__26) | (1 << RelayParser.CNAME))) != 0):
                     self.state = 372
                     self.typeExpr()
                     self.state = 377
@@ -2691,13 +2677,6 @@ def typeExpr(self):
                 self.typeExpr()
                 pass
 
-            elif la_ == 8:
-                localctx = RelayParser.IncompleteTypeContext(self, localctx)
-                self.enterOuterAlt(localctx, 8)
-                self.state = 385
-                self.match(RelayParser.T__24)
-                pass
-
 
         except RecognitionException as re:
             localctx.exception = re
@@ -2740,23 +2719,23 @@ def typeParamList(self):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 388
+            self.state = 387
             self.match(RelayParser.T__7)
-            self.state = 389
+            self.state = 388
             self.typeIdent()
-            self.state = 394
+            self.state = 393
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==RelayParser.T__2:
-                self.state = 390
+                self.state = 389
                 self.match(RelayParser.T__2)
-                self.state = 391
+                self.state = 390
                 self.typeIdent()
-                self.state = 396
+                self.state = 395
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 397
+            self.state = 396
             self.match(RelayParser.T__8)
         except RecognitionException as re:
             localctx.exception = re
@@ -2798,44 +2777,44 @@ def shapeList(self):
         self.enterRule(localctx, 48, self.RULE_shapeList)
         self._la = 0 # Token type
         try:
-            self.state = 412
+            self.state = 411
             self._errHandler.sync(self)
             la_ = self._interp.adaptivePredict(self._input,39,self._ctx)
             if la_ == 1:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 399
+                self.state = 398
                 self.match(RelayParser.T__3)
-                self.state = 400
+                self.state = 399
                 self.shape()
-                self.state = 403 
+                self.state = 402 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while True:
-                    self.state = 401
+                    self.state = 400
                     self.match(RelayParser.T__2)
-                    self.state = 402
+                    self.state = 401
                     self.shape()
-                    self.state = 405 
+                    self.state = 404 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
                     if not (_la==RelayParser.T__2):
                         break
 
-                self.state = 407
+                self.state = 406
                 self.match(RelayParser.T__4)
                 pass
 
             elif la_ == 2:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 409
+                self.state = 408
                 self.match(RelayParser.T__3)
-                self.state = 410
+                self.state = 409
                 self.match(RelayParser.T__4)
                 pass
 
             elif la_ == 3:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 411
+                self.state = 410
                 self.shape()
                 pass
 
@@ -2879,19 +2858,19 @@ def meta(self):
         self.enterRule(localctx, 50, self.RULE_meta)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 414
+            self.state = 413
             self.match(RelayParser.T__27)
-            self.state = 415
+            self.state = 414
             self.match(RelayParser.T__7)
-            self.state = 416
+            self.state = 415
             self.match(RelayParser.CNAME)
-            self.state = 417
+            self.state = 416
             self.match(RelayParser.T__8)
-            self.state = 418
+            self.state = 417
             self.match(RelayParser.T__7)
-            self.state = 419
+            self.state = 418
             self.match(RelayParser.NAT)
-            self.state = 420
+            self.state = 419
             self.match(RelayParser.T__8)
         except RecognitionException as re:
             localctx.exception = re
@@ -2974,29 +2953,29 @@ def shape(self):
         localctx = RelayParser.ShapeContext(self, self._ctx, self.state)
         self.enterRule(localctx, 52, self.RULE_shape)
         try:
-            self.state = 428
+            self.state = 427
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [RelayParser.T__27]:
                 localctx = RelayParser.MetaShapeContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 422
+                self.state = 421
                 self.meta()
                 pass
             elif token in [RelayParser.T__3]:
                 localctx = RelayParser.ParensShapeContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 423
+                self.state = 422
                 self.match(RelayParser.T__3)
-                self.state = 424
+                self.state = 423
                 self.shape()
-                self.state = 425
+                self.state = 424
                 self.match(RelayParser.T__4)
                 pass
             elif token in [RelayParser.NAT]:
                 localctx = RelayParser.IntShapeContext(self, localctx)
                 self.enterOuterAlt(localctx, 3)
-                self.state = 427
+                self.state = 426
                 self.match(RelayParser.NAT)
                 pass
             else:
@@ -3039,11 +3018,11 @@ def body(self):
         self.enterRule(localctx, 54, self.RULE_body)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 430
+            self.state = 429
             self.match(RelayParser.T__5)
-            self.state = 431
+            self.state = 430
             self.expr(0)
-            self.state = 432
+            self.state = 431
             self.match(RelayParser.T__6)
         except RecognitionException as re:
             localctx.exception = re
@@ -3124,25 +3103,25 @@ def scalar(self):
         localctx = RelayParser.ScalarContext(self, self._ctx, self.state)
         self.enterRule(localctx, 56, self.RULE_scalar)
         try:
-            self.state = 437
+            self.state = 436
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [RelayParser.FLOAT]:
                 localctx = RelayParser.ScalarFloatContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 434
+                self.state = 433
                 self.match(RelayParser.FLOAT)
                 pass
             elif token in [RelayParser.NAT]:
                 localctx = RelayParser.ScalarIntContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 435
+                self.state = 434
                 self.match(RelayParser.NAT)
                 pass
             elif token in [RelayParser.BOOL_LIT]:
                 localctx = RelayParser.ScalarBoolContext(self, localctx)
                 self.enterOuterAlt(localctx, 3)
-                self.state = 436
+                self.state = 435
                 self.match(RelayParser.BOOL_LIT)
                 pass
             else:
@@ -3200,36 +3179,36 @@ def ident(self):
         localctx = RelayParser.IdentContext(self, self._ctx, self.state)
         self.enterRule(localctx, 58, self.RULE_ident)
         try:
-            self.state = 444
+            self.state = 443
             self._errHandler.sync(self)
             la_ = self._interp.adaptivePredict(self._input,42,self._ctx)
             if la_ == 1:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 439
+                self.state = 438
                 self.opIdent()
                 pass
 
             elif la_ == 2:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 440
+                self.state = 439
                 self.globalVar()
                 pass
 
             elif la_ == 3:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 441
+                self.state = 440
                 self.localVar()
                 pass
 
             elif la_ == 4:
                 self.enterOuterAlt(localctx, 4)
-                self.state = 442
+                self.state = 441
                 self.typeExpr()
                 pass
 
             elif la_ == 5:
                 self.enterOuterAlt(localctx, 5)
-                self.state = 443
+                self.state = 442
                 self.graphVar()
                 pass
 
diff --git a/python/tvm/relay/grammar/py3/RelayVisitor.py b/python/tvm/relay/grammar/py3/RelayVisitor.py
index fbb008f1b4d1..ac662b79a118 100644
--- a/python/tvm/relay/grammar/py3/RelayVisitor.py
+++ b/python/tvm/relay/grammar/py3/RelayVisitor.py
@@ -234,11 +234,6 @@ def visitFuncType(self, ctx:RelayParser.FuncTypeContext):
         return self.visitChildren(ctx)
 
 
-    # Visit a parse tree produced by RelayParser#incompleteType.
-    def visitIncompleteType(self, ctx:RelayParser.IncompleteTypeContext):
-        return self.visitChildren(ctx)
-
-
     # Visit a parse tree produced by RelayParser#typeParamList.
     def visitTypeParamList(self, ctx:RelayParser.TypeParamListContext):
         return self.visitChildren(ctx)
diff --git a/src/relay/ir/pretty_printer.cc b/src/relay/ir/pretty_printer.cc
index 5a6551c26aaf..7e9f35942b06 100644
--- a/src/relay/ir/pretty_printer.cc
+++ b/src/relay/ir/pretty_printer.cc
@@ -239,6 +239,8 @@ class PrettyPrinter :
       return PrintExpr(Downcast<Expr>(node), meta, try_inline);
     } else if (node.as_derived<TypeNode>()) {
       return PrintType(Downcast<Type>(node), meta);
+    } else if (node.as_derived<PatternNode>()) {
+      return PrintPattern(Downcast<Pattern>(node), meta);
     } else if (node.as_derived<ModuleNode>()) {
       return PrintMod(Downcast<Module>(node));
     } else {
@@ -488,13 +490,13 @@ class PrettyPrinter :
     Doc doc;
     doc << prefix;
     if (fn->type_params.size() > 0) {
-      doc << "<";
+      doc << "[";
       std::vector<Doc> type_params;
       for (const TypeVar& tv : fn->type_params) {
-        type_params.push_back(AllocTypeVar(tv));
+        type_params.push_back(Doc(tv->var->name_hint));
       }
       doc << PrintSep(type_params);
-      doc << ">";
+      doc << "]";
     }
     doc << "(";
     std::vector<Doc> params;
@@ -584,27 +586,54 @@ class PrettyPrinter :
     // TODO(jmp): Lots of code duplication here because PrintBody and PrintScope don't accept Docs.
     Doc doc;
     Doc body;
-    doc << "match " << Print(op->data) << " ";
-    doc << "{";
+    doc << "match";
+    if (!op->complete) {
+      doc << "?";
+    }
+    doc << " (" << Print(op->data) << ") {";
     std::vector<Doc> clauses;
     for (const auto& clause : op->clauses) {
       Doc clause_doc;
-      clauses.push_back(clause_doc << Print(clause->lhs) << " -> "
-                                   << Print(clause->rhs));
+      clause_doc << "| " << Print(clause->lhs) << " => " << Print(clause->rhs);
+      clauses.push_back(clause_doc);
     }
     doc << Indent(2, body << PrintNewLine() << PrintSep(clauses, PrintNewLine())) << PrintNewLine();
     doc << "}";
     return doc;
   }
 
+  Doc PrintPattern(const Pattern& pattern, bool meta) {
+    // auto it = memo_type_.find(type);
+    // if (it != memo_type_.end()) return it->second;
+    // Doc printed_type;
+    // if (meta) {
+    //   printed_type = meta_.GetMetaNode(GetRef<NodeRef>(type.get()));
+    // } else {
+    //   printed_type = VisitType(type);
+    // }
+    // memo_type_[type] = printed_type;
+    // return printed_type;
+
+    // TODO(weberlo): memoize?
+    return VisitPattern(pattern);
+  }
+
   Doc VisitPattern_(const PatternConstructorNode* p) final {
     Doc doc;
-    doc << p->constructor->name_hint << "(";
-    std::vector<Doc> pats;
-    for (const auto& pat : p->patterns) {
-      pats.push_back(Print(pat));
+    doc << p->constructor->name_hint;
+    if (!p->patterns.empty()) {
+      doc << "(";
+      std::vector<Doc> pats;
+      for (const auto& pat : p->patterns) {
+        pats.push_back(Print(pat));
+      }
+      doc << PrintSep(pats) << ")";
     }
-    return doc << PrintSep(pats) << ")";
+    return doc;
+  }
+
+  Doc VisitPattern_(const PatternWildcardNode* pw) final {
+    return Doc("_");
   }
 
   Doc VisitPattern_(const PatternVarNode* pv) final {
@@ -647,7 +676,8 @@ class PrettyPrinter :
   }
 
   Doc VisitType_(const TypeVarNode* node) final {
-    return AllocTypeVar(GetRef<TypeVar>(node));
+    // return AllocTypeVar(GetRef<TypeVar>(node));
+    return Doc(node->var->name_hint);
   }
 
   Doc VisitType_(const GlobalTypeVarNode* node) final {
@@ -699,13 +729,13 @@ class PrettyPrinter :
     Doc doc;
     doc << "fn ";
     if (node->type_params.size() != 0) {
-      doc << "<";
+      doc << "[";
       std::vector<Doc> type_params;
       for (Type type_param : node->type_params) {
         type_params.push_back(Print(type_param));
       }
       doc << PrintSep(type_params);
-      doc << ">";
+      doc << "]";
     }
     std::vector<Doc> arg_types;
     for (Type arg_type : node->arg_types) {
@@ -742,7 +772,6 @@ class PrettyPrinter :
     return doc;
   }
 
-
   //------------------------------------
   // Overload of Attr printing functions
   //------------------------------------
diff --git a/tests/python/relay/test_ir_parser.py b/tests/python/relay/test_ir_parser.py
index f09a1ea4bdde..2aaa4c181a8f 100644
--- a/tests/python/relay/test_ir_parser.py
+++ b/tests/python/relay/test_ir_parser.py
@@ -741,7 +741,7 @@ def test_match():
     )
     mod[length_var] = length_func
 
-    print('WEEEE')
+    # TODO: Put these back in
     assert parses_as(
         """
         type List[A] =
@@ -749,7 +749,7 @@ def test_match():
           | Nil
 
         def @length[A](%xs: List[A]) -> int32 {
-          match (%xs) {
+          match? (%xs) {
             | Cons(_, %rest) => 1 + @length(%rest)
             | Nil => 0
           }

From ca9037b497deefdfd51df497cb0a2add2bdf174d Mon Sep 17 00:00:00 2001
From: Logan Weber <weberlo@cs.washington.edu>
Date: Mon, 26 Aug 2019 11:13:33 -0700
Subject: [PATCH 05/29] match finished?

---
 python/tvm/relay/_parser.py                  |   22 +-
 python/tvm/relay/grammar/Relay.g4            |   24 +-
 python/tvm/relay/grammar/py3/RelayLexer.py   |  349 ++--
 python/tvm/relay/grammar/py3/RelayParser.py  | 1611 ++++++++++--------
 python/tvm/relay/grammar/py3/RelayVisitor.py |    5 +
 src/relay/ir/alpha_equal.cc                  |    6 +
 src/relay/ir/pretty_printer.cc               |   17 +-
 tests/python/relay/test_ir_parser.py         |   23 +-
 8 files changed, 1090 insertions(+), 967 deletions(-)

diff --git a/python/tvm/relay/_parser.py b/python/tvm/relay/_parser.py
index a5837df0e3f6..e5be1cd99e7b 100644
--- a/python/tvm/relay/_parser.py
+++ b/python/tvm/relay/_parser.py
@@ -277,14 +277,14 @@ def visitTerminal(self, node):
         raise ParseError("todo: `{}`".format(node_text))
 
     def visitGlobalVar(self, ctx):
-        var_name = ctx.CNAME().getText()
+        var_name = ctx.START_LOWER_CNAME().getText()
         global_var = lookup([self.global_var_scope], var_name)
         if global_var is None:
             raise ParseError(f'unbound global var "{var_name}""')
         return global_var
 
     def visitLocalVar(self, ctx):
-        var_name = ctx.CNAME().getText()
+        var_name = ctx.START_LOWER_CNAME().getText()
         local_var = lookup(self.var_scopes, var_name)
         if local_var is None:
             raise ParseError(f'unbound local var "{var_name}""')
@@ -324,7 +324,7 @@ def visitProg(self, ctx):
     # Exprs
     def visitOpIdent(self, ctx):
         # type: (RelayParser.OpIdentContext) -> op.Op
-        op_name = ctx.CNAME().getText()
+        op_name = '.'.join([name.getText() for name in ctx.START_LOWER_CNAME()])
         if op_name in FUNC_OPS:
             return FuncOp(FUNC_OPS[op_name])
         return ExprOp(op.get(op_name))
@@ -559,13 +559,16 @@ def visitPattern(self, ctx):
         if text == '_':
             return adt.PatternWildcard()
         elif text.startswith('%'):
-            var = self.mk_var(text[1:])
+            text = ctx.localVar().getText()
+            typ = ctx.typeExpr()
+            if typ is not None:
+                typ = self.visit(typ)
+            var = self.mk_var(text[1:], typ=typ)
             return adt.PatternVar(var)
         else:
             raise ParseError(f'invalid pattern syntax "{text}"')
 
     def visitTypeExprType(self, ctx):
-        import pdb; pdb.set_trace()
         type_params = ctx.typeParams()
         print(ctx.getText())
         if type_params is None:
@@ -597,8 +600,6 @@ def _parse_typ_var(name):
         else:
             return typ_var
 
-
-
     def visitCallNoAttr(self, ctx):
         return (self.visit_list(ctx.exprList().expr()), None)
 
@@ -637,7 +638,8 @@ def visitIfElse(self, ctx):
     def visitGraph(self, ctx):
         # type: (RelayParser.GraphContext) -> expr.Expr
         """Visit a graph variable assignment."""
-        graph_nid = int(ctx.GRAPH_VAR().getText()[1:])
+        import pdb; pdb.set_trace()
+        graph_nid = int(ctx.graphVar().getText()[1:])
 
         self.enter_var_scope()
         value = self.visit(ctx.expr(0))
@@ -663,7 +665,7 @@ def visitIncompleteType(self, ctx):
     def visitTypeIdent(self, ctx):
         # type: (RelayParser.TypeIdentContext) -> Union[ty.TensorType, str]
         """Handle type identifier."""
-        type_name = ctx.CNAME().getText()
+        type_name = ctx.getText()
 
         # Look through all type prefixes for a match
         for type_prefix in TYPE_PREFIXES:
@@ -676,7 +678,7 @@ def visitTypeIdent(self, ctx):
             type_param = lookup([self.global_type_param_scope], type_name)
             if type_param is None:
                 # TODO: raise parse error?
-                raise RuntimeError(f'unbound var "{type_name}"')
+                raise ParseError(f'unbound var "{type_name}"')
 
         return type_param
 
diff --git a/python/tvm/relay/grammar/Relay.g4 b/python/tvm/relay/grammar/Relay.g4
index d6defd2edbf8..10aab799666e 100644
--- a/python/tvm/relay/grammar/Relay.g4
+++ b/python/tvm/relay/grammar/Relay.g4
@@ -53,9 +53,9 @@ BOOL_LIT
   | 'False'
   ;
 
-// START_UPPER_CNAME: UPPER_LETTER ('_'|LETTER|DIGIT)*;
-// START_LOWER_CNAME: LOWER_LETTER ('_'|LETTER|DIGIT)*;
-CNAME: ('_'|LETTER) ('_'|LETTER|DIGIT)* ('.' CNAME)* ;
+START_UPPER_CNAME: UPPER_LETTER ('_'|LETTER|DIGIT)*;
+START_LOWER_CNAME: LOWER_LETTER ('_'|LETTER|DIGIT)*;
+// CNAME: ('_'|LETTER) ('_'|LETTER|DIGIT)* ('.' CNAME)* ;
 
 // non-negative floats
 fragment PREFLOAT : NAT ('.' NAT)? EXP?; // 1.35, 1.35E-9, 0.3, 4.5, 1, 1e10 3e4
@@ -63,7 +63,7 @@ fragment PREFLOAT : NAT ('.' NAT)? EXP?; // 1.35, 1.35E-9, 0.3, 4.5, 1, 1e10 3e4
 FLOAT : PREFLOAT 'f';
 
 // BASE_TYPE : ('int'|'uint'|'float'|'bool') DIGIT*;
-BASE_TYPE : 'int32' ;
+baseType : 'int32' ;
 
 // non-negative ints
 NAT: DIGIT+ ;
@@ -81,13 +81,13 @@ METADATA: 'METADATA:' .*;
 // prog: SEMVER (defn+ | expr) METADATA? EOF ;
 prog: SEMVER (defn* | expr) METADATA? EOF ;
 
-opIdent: CNAME ;
-globalVar: '@' CNAME ;
-localVar: '%' CNAME ;
+opIdent: START_LOWER_CNAME ('.' START_LOWER_CNAME)*;
+globalVar: '@' START_LOWER_CNAME ;
+localVar: '%' START_LOWER_CNAME ;
 // TODO(weberlo): why does 'int32` generate a parse error when it's literally a
 // lexer token?
 // typeIdent: BASE_TYPE | START_UPPER_NAME ;
-typeIdent: CNAME ;
+typeIdent: (baseType | START_UPPER_CNAME) ;
 graphVar: '%' NAT ;
 
 exprList: (expr (',' expr)*)?;
@@ -142,11 +142,11 @@ matchType : 'match' | 'match?' ;
 patternList: '(' pattern (',' pattern)* ')';
 pattern
   : '_'
-  | localVar
+  | localVar (':' typeExpr)?
   ;
 
 // constructorName: typeIdent ;
-constructorName: CNAME ;
+constructorName: START_UPPER_CNAME ;
 
 argList
   : varList              # argNoAttr
@@ -158,7 +158,7 @@ var: localVar (':' typeExpr)?;
 
 attrSeq: attr (',' attr)*;
 // attr: LOWER_NAME '=' expr ;
-attr: CNAME '=' expr ;
+attr: START_LOWER_CNAME '=' expr ;
 
 typeExpr
   : '(' ')'                                                      # tupleType
@@ -183,7 +183,7 @@ shapeList
   ;
 
 // meta : 'meta' '[' LOWER_NAME ']' '[' NAT ']';
-meta : 'meta' '[' CNAME ']' '[' NAT ']';
+meta : 'meta' '[' START_LOWER_CNAME ']' '[' NAT ']';
 
 shape
   : meta # metaShape
diff --git a/python/tvm/relay/grammar/py3/RelayLexer.py b/python/tvm/relay/grammar/py3/RelayLexer.py
index 8ea1abb81a48..02e1b2596794 100644
--- a/python/tvm/relay/grammar/py3/RelayLexer.py
+++ b/python/tvm/relay/grammar/py3/RelayLexer.py
@@ -8,8 +8,8 @@
 
 def serializedATN():
     with StringIO() as buf:
-        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\63")
-        buf.write("\u016c\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7")
+        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\64")
+        buf.write("\u016d\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7")
         buf.write("\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r")
         buf.write("\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23")
         buf.write("\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30")
@@ -17,153 +17,153 @@ def serializedATN():
         buf.write("\t\36\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%")
         buf.write("\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.")
         buf.write("\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64")
-        buf.write("\t\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\3\2\3")
-        buf.write("\2\3\3\3\3\3\4\3\4\3\5\3\5\3\6\3\6\3\7\3\7\3\b\3\b\3\t")
-        buf.write("\3\t\3\n\3\n\3\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\3\r\3")
-        buf.write("\r\3\16\3\16\3\16\3\16\3\17\3\17\3\20\3\20\3\21\3\21\3")
-        buf.write("\21\3\22\3\22\3\22\3\23\3\23\3\23\3\24\3\24\3\24\3\24")
-        buf.write("\3\25\3\25\3\25\3\25\3\25\3\26\3\26\3\27\3\27\3\27\3\30")
-        buf.write("\3\30\3\30\3\30\3\30\3\30\3\31\3\31\3\31\3\31\3\31\3\31")
-        buf.write("\3\31\3\32\3\32\3\33\3\33\3\34\3\34\3\34\3\34\3\34\3\34")
-        buf.write("\3\34\3\35\3\35\3\35\3\35\3\35\3\36\3\36\3\36\3\36\3\36")
-        buf.write("\3\36\3\36\3\37\3\37\3\37\3\37\3\37\7\37\u00d8\n\37\f")
-        buf.write("\37\16\37\u00db\13\37\3\37\3\37\3\37\3\37\3\37\3 \6 \u00e3")
-        buf.write("\n \r \16 \u00e4\3 \3 \3!\3!\3!\3!\7!\u00ed\n!\f!\16!")
-        buf.write("\u00f0\13!\3!\3!\3!\3!\3\"\3\"\3\"\3#\3#\3#\7#\u00fc\n")
-        buf.write("#\f#\16#\u00ff\13#\3#\3#\3$\3$\3%\3%\3&\3&\3\'\3\'\3(")
-        buf.write("\3(\3)\3)\3*\3*\3*\3+\3+\3+\3,\3,\3,\3-\3-\3-\3.\3.\3")
-        buf.write(".\3.\3.\3.\3.\3.\3.\5.\u0124\n.\3/\3/\5/\u0128\n/\3/\3")
-        buf.write("/\3/\7/\u012d\n/\f/\16/\u0130\13/\3/\3/\7/\u0134\n/\f")
-        buf.write("/\16/\u0137\13/\3\60\3\60\3\60\5\60\u013c\n\60\3\60\5")
-        buf.write("\60\u013f\n\60\3\61\3\61\3\61\3\62\3\62\3\62\3\62\3\62")
-        buf.write("\3\62\3\63\6\63\u014b\n\63\r\63\16\63\u014c\3\64\3\64")
-        buf.write("\5\64\u0151\n\64\3\64\3\64\3\65\3\65\3\66\3\66\3\67\3")
-        buf.write("\67\38\38\39\39\39\39\39\39\39\39\39\39\39\79\u0168\n")
-        buf.write("9\f9\169\u016b\139\5\u00d9\u00ee\u00fd\2:\3\3\5\4\7\5")
-        buf.write("\t\6\13\7\r\b\17\t\21\n\23\13\25\f\27\r\31\16\33\17\35")
-        buf.write("\20\37\21!\22#\23%\24\'\25)\26+\27-\30/\31\61\32\63\33")
-        buf.write("\65\34\67\359\36;\37= ?!A\"C\2E#G$I%K&M\'O(Q)S*U+W,Y-")
-        buf.write("[.]/_\2a\60c\61e\62g\2i\2k\2m\2o\2q\63\3\2\n\5\2\13\f")
+        buf.write("\t\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:")
+        buf.write("\3\2\3\2\3\2\3\2\3\2\3\2\3\3\3\3\3\4\3\4\3\5\3\5\3\6\3")
+        buf.write("\6\3\7\3\7\3\b\3\b\3\t\3\t\3\n\3\n\3\13\3\13\3\f\3\f\3")
+        buf.write("\r\3\r\3\r\3\16\3\16\3\16\3\16\3\16\3\17\3\17\3\17\3\17")
+        buf.write("\3\20\3\20\3\21\3\21\3\22\3\22\3\22\3\23\3\23\3\23\3\24")
+        buf.write("\3\24\3\24\3\25\3\25\3\25\3\25\3\26\3\26\3\26\3\26\3\26")
+        buf.write("\3\27\3\27\3\30\3\30\3\30\3\31\3\31\3\31\3\31\3\31\3\31")
+        buf.write("\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\33\3\33\3\34\3\34")
+        buf.write("\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\36\3\36\3\36\3\36")
+        buf.write("\3\36\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3 \3 \3 \3 \3")
+        buf.write(" \7 \u00e0\n \f \16 \u00e3\13 \3 \3 \3 \3 \3 \3!\6!\u00eb")
+        buf.write("\n!\r!\16!\u00ec\3!\3!\3\"\3\"\3\"\3\"\7\"\u00f5\n\"\f")
+        buf.write("\"\16\"\u00f8\13\"\3\"\3\"\3\"\3\"\3#\3#\3#\3$\3$\3$\7")
+        buf.write("$\u0104\n$\f$\16$\u0107\13$\3$\3$\3%\3%\3&\3&\3\'\3\'")
+        buf.write("\3(\3(\3)\3)\3*\3*\3+\3+\3+\3,\3,\3,\3-\3-\3-\3.\3.\3")
+        buf.write(".\3/\3/\3/\3/\3/\3/\3/\3/\3/\5/\u012c\n/\3\60\3\60\3\60")
+        buf.write("\3\60\7\60\u0132\n\60\f\60\16\60\u0135\13\60\3\61\3\61")
+        buf.write("\3\61\3\61\7\61\u013b\n\61\f\61\16\61\u013e\13\61\3\62")
+        buf.write("\3\62\3\62\5\62\u0143\n\62\3\62\5\62\u0146\n\62\3\63\3")
+        buf.write("\63\3\63\3\64\6\64\u014c\n\64\r\64\16\64\u014d\3\65\3")
+        buf.write("\65\5\65\u0152\n\65\3\65\3\65\3\66\3\66\3\67\3\67\38\3")
+        buf.write("8\39\39\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\7:\u0169\n:\f")
+        buf.write(":\16:\u016c\13:\5\u00e1\u00f6\u0105\2;\3\3\5\4\7\5\t\6")
+        buf.write("\13\7\r\b\17\t\21\n\23\13\25\f\27\r\31\16\33\17\35\20")
+        buf.write("\37\21!\22#\23%\24\'\25)\26+\27-\30/\31\61\32\63\33\65")
+        buf.write("\34\67\359\36;\37= ?!A\"C#E\2G$I%K&M\'O(Q)S*U+W,Y-[.]")
+        buf.write("/_\60a\61c\2e\62g\63i\2k\2m\2o\2q\2s\64\3\2\n\5\2\13\f")
         buf.write("\17\17\"\"\4\2\f\f\17\17\4\2GGgg\4\2--//\3\2c|\3\2C\\")
-        buf.write("\4\2C\\c|\3\2\62;\2\u0175\2\3\3\2\2\2\2\5\3\2\2\2\2\7")
+        buf.write("\4\2C\\c|\3\2\62;\2\u0177\2\3\3\2\2\2\2\5\3\2\2\2\2\7")
         buf.write("\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2")
         buf.write("\2\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2")
         buf.write("\2\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2\2\2\2\37\3\2\2\2")
         buf.write("\2!\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("\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2\2\2\2\63")
         buf.write("\3\2\2\2\2\65\3\2\2\2\2\67\3\2\2\2\29\3\2\2\2\2;\3\2\2")
-        buf.write("\2\2=\3\2\2\2\2?\3\2\2\2\2A\3\2\2\2\2E\3\2\2\2\2G\3\2")
+        buf.write("\2\2=\3\2\2\2\2?\3\2\2\2\2A\3\2\2\2\2C\3\2\2\2\2G\3\2")
         buf.write("\2\2\2I\3\2\2\2\2K\3\2\2\2\2M\3\2\2\2\2O\3\2\2\2\2Q\3")
         buf.write("\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2W\3\2\2\2\2Y\3\2\2\2\2[")
-        buf.write("\3\2\2\2\2]\3\2\2\2\2a\3\2\2\2\2c\3\2\2\2\2e\3\2\2\2\2")
-        buf.write("q\3\2\2\2\3s\3\2\2\2\5u\3\2\2\2\7w\3\2\2\2\ty\3\2\2\2")
-        buf.write("\13{\3\2\2\2\r}\3\2\2\2\17\177\3\2\2\2\21\u0081\3\2\2")
-        buf.write("\2\23\u0083\3\2\2\2\25\u0085\3\2\2\2\27\u0088\3\2\2\2")
-        buf.write("\31\u008d\3\2\2\2\33\u008f\3\2\2\2\35\u0093\3\2\2\2\37")
-        buf.write("\u0095\3\2\2\2!\u0097\3\2\2\2#\u009a\3\2\2\2%\u009d\3")
-        buf.write("\2\2\2\'\u00a0\3\2\2\2)\u00a4\3\2\2\2+\u00a9\3\2\2\2-")
-        buf.write("\u00ab\3\2\2\2/\u00ae\3\2\2\2\61\u00b4\3\2\2\2\63\u00bb")
-        buf.write("\3\2\2\2\65\u00bd\3\2\2\2\67\u00bf\3\2\2\29\u00c6\3\2")
-        buf.write("\2\2;\u00cb\3\2\2\2=\u00d2\3\2\2\2?\u00e2\3\2\2\2A\u00e8")
-        buf.write("\3\2\2\2C\u00f5\3\2\2\2E\u00f8\3\2\2\2G\u0102\3\2\2\2")
-        buf.write("I\u0104\3\2\2\2K\u0106\3\2\2\2M\u0108\3\2\2\2O\u010a\3")
-        buf.write("\2\2\2Q\u010c\3\2\2\2S\u010e\3\2\2\2U\u0111\3\2\2\2W\u0114")
-        buf.write("\3\2\2\2Y\u0117\3\2\2\2[\u0123\3\2\2\2]\u0127\3\2\2\2")
-        buf.write("_\u0138\3\2\2\2a\u0140\3\2\2\2c\u0143\3\2\2\2e\u014a\3")
-        buf.write("\2\2\2g\u014e\3\2\2\2i\u0154\3\2\2\2k\u0156\3\2\2\2m\u0158")
-        buf.write("\3\2\2\2o\u015a\3\2\2\2q\u015c\3\2\2\2st\7B\2\2t\4\3\2")
-        buf.write("\2\2uv\7\'\2\2v\6\3\2\2\2wx\7.\2\2x\b\3\2\2\2yz\7*\2\2")
-        buf.write("z\n\3\2\2\2{|\7+\2\2|\f\3\2\2\2}~\7}\2\2~\16\3\2\2\2\177")
-        buf.write("\u0080\7\177\2\2\u0080\20\3\2\2\2\u0081\u0082\7]\2\2\u0082")
-        buf.write("\22\3\2\2\2\u0083\u0084\7_\2\2\u0084\24\3\2\2\2\u0085")
-        buf.write("\u0086\7k\2\2\u0086\u0087\7h\2\2\u0087\26\3\2\2\2\u0088")
-        buf.write("\u0089\7g\2\2\u0089\u008a\7n\2\2\u008a\u008b\7u\2\2\u008b")
-        buf.write("\u008c\7g\2\2\u008c\30\3\2\2\2\u008d\u008e\7\60\2\2\u008e")
-        buf.write("\32\3\2\2\2\u008f\u0090\7n\2\2\u0090\u0091\7g\2\2\u0091")
-        buf.write("\u0092\7v\2\2\u0092\34\3\2\2\2\u0093\u0094\7?\2\2\u0094")
-        buf.write("\36\3\2\2\2\u0095\u0096\7=\2\2\u0096 \3\2\2\2\u0097\u0098")
-        buf.write("\7=\2\2\u0098\u0099\7=\2\2\u0099\"\3\2\2\2\u009a\u009b")
-        buf.write("\7h\2\2\u009b\u009c\7p\2\2\u009c$\3\2\2\2\u009d\u009e")
-        buf.write("\7/\2\2\u009e\u009f\7@\2\2\u009f&\3\2\2\2\u00a0\u00a1")
-        buf.write("\7f\2\2\u00a1\u00a2\7g\2\2\u00a2\u00a3\7h\2\2\u00a3(\3")
-        buf.write("\2\2\2\u00a4\u00a5\7v\2\2\u00a5\u00a6\7{\2\2\u00a6\u00a7")
-        buf.write("\7r\2\2\u00a7\u00a8\7g\2\2\u00a8*\3\2\2\2\u00a9\u00aa")
-        buf.write("\7~\2\2\u00aa,\3\2\2\2\u00ab\u00ac\7?\2\2\u00ac\u00ad")
-        buf.write("\7@\2\2\u00ad.\3\2\2\2\u00ae\u00af\7o\2\2\u00af\u00b0")
-        buf.write("\7c\2\2\u00b0\u00b1\7v\2\2\u00b1\u00b2\7e\2\2\u00b2\u00b3")
-        buf.write("\7j\2\2\u00b3\60\3\2\2\2\u00b4\u00b5\7o\2\2\u00b5\u00b6")
-        buf.write("\7c\2\2\u00b6\u00b7\7v\2\2\u00b7\u00b8\7e\2\2\u00b8\u00b9")
-        buf.write("\7j\2\2\u00b9\u00ba\7A\2\2\u00ba\62\3\2\2\2\u00bb\u00bc")
-        buf.write("\7a\2\2\u00bc\64\3\2\2\2\u00bd\u00be\7<\2\2\u00be\66\3")
-        buf.write("\2\2\2\u00bf\u00c0\7V\2\2\u00c0\u00c1\7g\2\2\u00c1\u00c2")
-        buf.write("\7p\2\2\u00c2\u00c3\7u\2\2\u00c3\u00c4\7q\2\2\u00c4\u00c5")
-        buf.write("\7t\2\2\u00c58\3\2\2\2\u00c6\u00c7\7o\2\2\u00c7\u00c8")
-        buf.write("\7g\2\2\u00c8\u00c9\7v\2\2\u00c9\u00ca\7c\2\2\u00ca:\3")
-        buf.write("\2\2\2\u00cb\u00cc\7x\2\2\u00cc\u00cd\7\62\2\2\u00cd\u00ce")
-        buf.write("\7\60\2\2\u00ce\u00cf\7\62\2\2\u00cf\u00d0\7\60\2\2\u00d0")
-        buf.write("\u00d1\7\65\2\2\u00d1<\3\2\2\2\u00d2\u00d3\7\61\2\2\u00d3")
-        buf.write("\u00d4\7,\2\2\u00d4\u00d9\3\2\2\2\u00d5\u00d8\5=\37\2")
-        buf.write("\u00d6\u00d8\13\2\2\2\u00d7\u00d5\3\2\2\2\u00d7\u00d6")
-        buf.write("\3\2\2\2\u00d8\u00db\3\2\2\2\u00d9\u00da\3\2\2\2\u00d9")
-        buf.write("\u00d7\3\2\2\2\u00da\u00dc\3\2\2\2\u00db\u00d9\3\2\2\2")
-        buf.write("\u00dc\u00dd\7,\2\2\u00dd\u00de\7\61\2\2\u00de\u00df\3")
-        buf.write("\2\2\2\u00df\u00e0\b\37\2\2\u00e0>\3\2\2\2\u00e1\u00e3")
-        buf.write("\t\2\2\2\u00e2\u00e1\3\2\2\2\u00e3\u00e4\3\2\2\2\u00e4")
-        buf.write("\u00e2\3\2\2\2\u00e4\u00e5\3\2\2\2\u00e5\u00e6\3\2\2\2")
-        buf.write("\u00e6\u00e7\b \2\2\u00e7@\3\2\2\2\u00e8\u00e9\7\61\2")
-        buf.write("\2\u00e9\u00ea\7\61\2\2\u00ea\u00ee\3\2\2\2\u00eb\u00ed")
-        buf.write("\13\2\2\2\u00ec\u00eb\3\2\2\2\u00ed\u00f0\3\2\2\2\u00ee")
-        buf.write("\u00ef\3\2\2\2\u00ee\u00ec\3\2\2\2\u00ef\u00f1\3\2\2\2")
-        buf.write("\u00f0\u00ee\3\2\2\2\u00f1\u00f2\7\f\2\2\u00f2\u00f3\3")
-        buf.write("\2\2\2\u00f3\u00f4\b!\2\2\u00f4B\3\2\2\2\u00f5\u00f6\7")
-        buf.write("^\2\2\u00f6\u00f7\7$\2\2\u00f7D\3\2\2\2\u00f8\u00fd\7")
-        buf.write("$\2\2\u00f9\u00fc\5C\"\2\u00fa\u00fc\n\3\2\2\u00fb\u00f9")
-        buf.write("\3\2\2\2\u00fb\u00fa\3\2\2\2\u00fc\u00ff\3\2\2\2\u00fd")
-        buf.write("\u00fe\3\2\2\2\u00fd\u00fb\3\2\2\2\u00fe\u0100\3\2\2\2")
-        buf.write("\u00ff\u00fd\3\2\2\2\u0100\u0101\7$\2\2\u0101F\3\2\2\2")
-        buf.write("\u0102\u0103\7,\2\2\u0103H\3\2\2\2\u0104\u0105\7\61\2")
-        buf.write("\2\u0105J\3\2\2\2\u0106\u0107\7-\2\2\u0107L\3\2\2\2\u0108")
-        buf.write("\u0109\7/\2\2\u0109N\3\2\2\2\u010a\u010b\7>\2\2\u010b")
-        buf.write("P\3\2\2\2\u010c\u010d\7@\2\2\u010dR\3\2\2\2\u010e\u010f")
-        buf.write("\7>\2\2\u010f\u0110\7?\2\2\u0110T\3\2\2\2\u0111\u0112")
-        buf.write("\7@\2\2\u0112\u0113\7?\2\2\u0113V\3\2\2\2\u0114\u0115")
-        buf.write("\7?\2\2\u0115\u0116\7?\2\2\u0116X\3\2\2\2\u0117\u0118")
-        buf.write("\7#\2\2\u0118\u0119\7?\2\2\u0119Z\3\2\2\2\u011a\u011b")
-        buf.write("\7V\2\2\u011b\u011c\7t\2\2\u011c\u011d\7w\2\2\u011d\u0124")
-        buf.write("\7g\2\2\u011e\u011f\7H\2\2\u011f\u0120\7c\2\2\u0120\u0121")
-        buf.write("\7n\2\2\u0121\u0122\7u\2\2\u0122\u0124\7g\2\2\u0123\u011a")
-        buf.write("\3\2\2\2\u0123\u011e\3\2\2\2\u0124\\\3\2\2\2\u0125\u0128")
-        buf.write("\7a\2\2\u0126\u0128\5m\67\2\u0127\u0125\3\2\2\2\u0127")
-        buf.write("\u0126\3\2\2\2\u0128\u012e\3\2\2\2\u0129\u012d\7a\2\2")
-        buf.write("\u012a\u012d\5m\67\2\u012b\u012d\5o8\2\u012c\u0129\3\2")
-        buf.write("\2\2\u012c\u012a\3\2\2\2\u012c\u012b\3\2\2\2\u012d\u0130")
-        buf.write("\3\2\2\2\u012e\u012c\3\2\2\2\u012e\u012f\3\2\2\2\u012f")
-        buf.write("\u0135\3\2\2\2\u0130\u012e\3\2\2\2\u0131\u0132\7\60\2")
-        buf.write("\2\u0132\u0134\5]/\2\u0133\u0131\3\2\2\2\u0134\u0137\3")
-        buf.write("\2\2\2\u0135\u0133\3\2\2\2\u0135\u0136\3\2\2\2\u0136^")
-        buf.write("\3\2\2\2\u0137\u0135\3\2\2\2\u0138\u013b\5e\63\2\u0139")
-        buf.write("\u013a\7\60\2\2\u013a\u013c\5e\63\2\u013b\u0139\3\2\2")
-        buf.write("\2\u013b\u013c\3\2\2\2\u013c\u013e\3\2\2\2\u013d\u013f")
-        buf.write("\5g\64\2\u013e\u013d\3\2\2\2\u013e\u013f\3\2\2\2\u013f")
-        buf.write("`\3\2\2\2\u0140\u0141\5_\60\2\u0141\u0142\7h\2\2\u0142")
-        buf.write("b\3\2\2\2\u0143\u0144\7k\2\2\u0144\u0145\7p\2\2\u0145")
-        buf.write("\u0146\7v\2\2\u0146\u0147\7\65\2\2\u0147\u0148\7\64\2")
-        buf.write("\2\u0148d\3\2\2\2\u0149\u014b\5o8\2\u014a\u0149\3\2\2")
-        buf.write("\2\u014b\u014c\3\2\2\2\u014c\u014a\3\2\2\2\u014c\u014d")
-        buf.write("\3\2\2\2\u014df\3\2\2\2\u014e\u0150\t\4\2\2\u014f\u0151")
-        buf.write("\t\5\2\2\u0150\u014f\3\2\2\2\u0150\u0151\3\2\2\2\u0151")
-        buf.write("\u0152\3\2\2\2\u0152\u0153\5e\63\2\u0153h\3\2\2\2\u0154")
-        buf.write("\u0155\t\6\2\2\u0155j\3\2\2\2\u0156\u0157\t\7\2\2\u0157")
-        buf.write("l\3\2\2\2\u0158\u0159\t\b\2\2\u0159n\3\2\2\2\u015a\u015b")
-        buf.write("\t\t\2\2\u015bp\3\2\2\2\u015c\u015d\7O\2\2\u015d\u015e")
-        buf.write("\7G\2\2\u015e\u015f\7V\2\2\u015f\u0160\7C\2\2\u0160\u0161")
-        buf.write("\7F\2\2\u0161\u0162\7C\2\2\u0162\u0163\7V\2\2\u0163\u0164")
-        buf.write("\7C\2\2\u0164\u0165\7<\2\2\u0165\u0169\3\2\2\2\u0166\u0168")
-        buf.write("\13\2\2\2\u0167\u0166\3\2\2\2\u0168\u016b\3\2\2\2\u0169")
-        buf.write("\u0167\3\2\2\2\u0169\u016a\3\2\2\2\u016ar\3\2\2\2\u016b")
-        buf.write("\u0169\3\2\2\2\23\2\u00d7\u00d9\u00e4\u00ee\u00fb\u00fd")
-        buf.write("\u0123\u0127\u012c\u012e\u0135\u013b\u013e\u014c\u0150")
-        buf.write("\u0169\3\b\2\2")
+        buf.write("\3\2\2\2\2]\3\2\2\2\2_\3\2\2\2\2a\3\2\2\2\2e\3\2\2\2\2")
+        buf.write("g\3\2\2\2\2s\3\2\2\2\3u\3\2\2\2\5{\3\2\2\2\7}\3\2\2\2")
+        buf.write("\t\177\3\2\2\2\13\u0081\3\2\2\2\r\u0083\3\2\2\2\17\u0085")
+        buf.write("\3\2\2\2\21\u0087\3\2\2\2\23\u0089\3\2\2\2\25\u008b\3")
+        buf.write("\2\2\2\27\u008d\3\2\2\2\31\u008f\3\2\2\2\33\u0092\3\2")
+        buf.write("\2\2\35\u0097\3\2\2\2\37\u009b\3\2\2\2!\u009d\3\2\2\2")
+        buf.write("#\u009f\3\2\2\2%\u00a2\3\2\2\2\'\u00a5\3\2\2\2)\u00a8")
+        buf.write("\3\2\2\2+\u00ac\3\2\2\2-\u00b1\3\2\2\2/\u00b3\3\2\2\2")
+        buf.write("\61\u00b6\3\2\2\2\63\u00bc\3\2\2\2\65\u00c3\3\2\2\2\67")
+        buf.write("\u00c5\3\2\2\29\u00c7\3\2\2\2;\u00ce\3\2\2\2=\u00d3\3")
+        buf.write("\2\2\2?\u00da\3\2\2\2A\u00ea\3\2\2\2C\u00f0\3\2\2\2E\u00fd")
+        buf.write("\3\2\2\2G\u0100\3\2\2\2I\u010a\3\2\2\2K\u010c\3\2\2\2")
+        buf.write("M\u010e\3\2\2\2O\u0110\3\2\2\2Q\u0112\3\2\2\2S\u0114\3")
+        buf.write("\2\2\2U\u0116\3\2\2\2W\u0119\3\2\2\2Y\u011c\3\2\2\2[\u011f")
+        buf.write("\3\2\2\2]\u012b\3\2\2\2_\u012d\3\2\2\2a\u0136\3\2\2\2")
+        buf.write("c\u013f\3\2\2\2e\u0147\3\2\2\2g\u014b\3\2\2\2i\u014f\3")
+        buf.write("\2\2\2k\u0155\3\2\2\2m\u0157\3\2\2\2o\u0159\3\2\2\2q\u015b")
+        buf.write("\3\2\2\2s\u015d\3\2\2\2uv\7k\2\2vw\7p\2\2wx\7v\2\2xy\7")
+        buf.write("\65\2\2yz\7\64\2\2z\4\3\2\2\2{|\7\60\2\2|\6\3\2\2\2}~")
+        buf.write("\7B\2\2~\b\3\2\2\2\177\u0080\7\'\2\2\u0080\n\3\2\2\2\u0081")
+        buf.write("\u0082\7.\2\2\u0082\f\3\2\2\2\u0083\u0084\7*\2\2\u0084")
+        buf.write("\16\3\2\2\2\u0085\u0086\7+\2\2\u0086\20\3\2\2\2\u0087")
+        buf.write("\u0088\7}\2\2\u0088\22\3\2\2\2\u0089\u008a\7\177\2\2\u008a")
+        buf.write("\24\3\2\2\2\u008b\u008c\7]\2\2\u008c\26\3\2\2\2\u008d")
+        buf.write("\u008e\7_\2\2\u008e\30\3\2\2\2\u008f\u0090\7k\2\2\u0090")
+        buf.write("\u0091\7h\2\2\u0091\32\3\2\2\2\u0092\u0093\7g\2\2\u0093")
+        buf.write("\u0094\7n\2\2\u0094\u0095\7u\2\2\u0095\u0096\7g\2\2\u0096")
+        buf.write("\34\3\2\2\2\u0097\u0098\7n\2\2\u0098\u0099\7g\2\2\u0099")
+        buf.write("\u009a\7v\2\2\u009a\36\3\2\2\2\u009b\u009c\7?\2\2\u009c")
+        buf.write(" \3\2\2\2\u009d\u009e\7=\2\2\u009e\"\3\2\2\2\u009f\u00a0")
+        buf.write("\7=\2\2\u00a0\u00a1\7=\2\2\u00a1$\3\2\2\2\u00a2\u00a3")
+        buf.write("\7h\2\2\u00a3\u00a4\7p\2\2\u00a4&\3\2\2\2\u00a5\u00a6")
+        buf.write("\7/\2\2\u00a6\u00a7\7@\2\2\u00a7(\3\2\2\2\u00a8\u00a9")
+        buf.write("\7f\2\2\u00a9\u00aa\7g\2\2\u00aa\u00ab\7h\2\2\u00ab*\3")
+        buf.write("\2\2\2\u00ac\u00ad\7v\2\2\u00ad\u00ae\7{\2\2\u00ae\u00af")
+        buf.write("\7r\2\2\u00af\u00b0\7g\2\2\u00b0,\3\2\2\2\u00b1\u00b2")
+        buf.write("\7~\2\2\u00b2.\3\2\2\2\u00b3\u00b4\7?\2\2\u00b4\u00b5")
+        buf.write("\7@\2\2\u00b5\60\3\2\2\2\u00b6\u00b7\7o\2\2\u00b7\u00b8")
+        buf.write("\7c\2\2\u00b8\u00b9\7v\2\2\u00b9\u00ba\7e\2\2\u00ba\u00bb")
+        buf.write("\7j\2\2\u00bb\62\3\2\2\2\u00bc\u00bd\7o\2\2\u00bd\u00be")
+        buf.write("\7c\2\2\u00be\u00bf\7v\2\2\u00bf\u00c0\7e\2\2\u00c0\u00c1")
+        buf.write("\7j\2\2\u00c1\u00c2\7A\2\2\u00c2\64\3\2\2\2\u00c3\u00c4")
+        buf.write("\7a\2\2\u00c4\66\3\2\2\2\u00c5\u00c6\7<\2\2\u00c68\3\2")
+        buf.write("\2\2\u00c7\u00c8\7V\2\2\u00c8\u00c9\7g\2\2\u00c9\u00ca")
+        buf.write("\7p\2\2\u00ca\u00cb\7u\2\2\u00cb\u00cc\7q\2\2\u00cc\u00cd")
+        buf.write("\7t\2\2\u00cd:\3\2\2\2\u00ce\u00cf\7o\2\2\u00cf\u00d0")
+        buf.write("\7g\2\2\u00d0\u00d1\7v\2\2\u00d1\u00d2\7c\2\2\u00d2<\3")
+        buf.write("\2\2\2\u00d3\u00d4\7x\2\2\u00d4\u00d5\7\62\2\2\u00d5\u00d6")
+        buf.write("\7\60\2\2\u00d6\u00d7\7\62\2\2\u00d7\u00d8\7\60\2\2\u00d8")
+        buf.write("\u00d9\7\65\2\2\u00d9>\3\2\2\2\u00da\u00db\7\61\2\2\u00db")
+        buf.write("\u00dc\7,\2\2\u00dc\u00e1\3\2\2\2\u00dd\u00e0\5? \2\u00de")
+        buf.write("\u00e0\13\2\2\2\u00df\u00dd\3\2\2\2\u00df\u00de\3\2\2")
+        buf.write("\2\u00e0\u00e3\3\2\2\2\u00e1\u00e2\3\2\2\2\u00e1\u00df")
+        buf.write("\3\2\2\2\u00e2\u00e4\3\2\2\2\u00e3\u00e1\3\2\2\2\u00e4")
+        buf.write("\u00e5\7,\2\2\u00e5\u00e6\7\61\2\2\u00e6\u00e7\3\2\2\2")
+        buf.write("\u00e7\u00e8\b \2\2\u00e8@\3\2\2\2\u00e9\u00eb\t\2\2\2")
+        buf.write("\u00ea\u00e9\3\2\2\2\u00eb\u00ec\3\2\2\2\u00ec\u00ea\3")
+        buf.write("\2\2\2\u00ec\u00ed\3\2\2\2\u00ed\u00ee\3\2\2\2\u00ee\u00ef")
+        buf.write("\b!\2\2\u00efB\3\2\2\2\u00f0\u00f1\7\61\2\2\u00f1\u00f2")
+        buf.write("\7\61\2\2\u00f2\u00f6\3\2\2\2\u00f3\u00f5\13\2\2\2\u00f4")
+        buf.write("\u00f3\3\2\2\2\u00f5\u00f8\3\2\2\2\u00f6\u00f7\3\2\2\2")
+        buf.write("\u00f6\u00f4\3\2\2\2\u00f7\u00f9\3\2\2\2\u00f8\u00f6\3")
+        buf.write("\2\2\2\u00f9\u00fa\7\f\2\2\u00fa\u00fb\3\2\2\2\u00fb\u00fc")
+        buf.write("\b\"\2\2\u00fcD\3\2\2\2\u00fd\u00fe\7^\2\2\u00fe\u00ff")
+        buf.write("\7$\2\2\u00ffF\3\2\2\2\u0100\u0105\7$\2\2\u0101\u0104")
+        buf.write("\5E#\2\u0102\u0104\n\3\2\2\u0103\u0101\3\2\2\2\u0103\u0102")
+        buf.write("\3\2\2\2\u0104\u0107\3\2\2\2\u0105\u0106\3\2\2\2\u0105")
+        buf.write("\u0103\3\2\2\2\u0106\u0108\3\2\2\2\u0107\u0105\3\2\2\2")
+        buf.write("\u0108\u0109\7$\2\2\u0109H\3\2\2\2\u010a\u010b\7,\2\2")
+        buf.write("\u010bJ\3\2\2\2\u010c\u010d\7\61\2\2\u010dL\3\2\2\2\u010e")
+        buf.write("\u010f\7-\2\2\u010fN\3\2\2\2\u0110\u0111\7/\2\2\u0111")
+        buf.write("P\3\2\2\2\u0112\u0113\7>\2\2\u0113R\3\2\2\2\u0114\u0115")
+        buf.write("\7@\2\2\u0115T\3\2\2\2\u0116\u0117\7>\2\2\u0117\u0118")
+        buf.write("\7?\2\2\u0118V\3\2\2\2\u0119\u011a\7@\2\2\u011a\u011b")
+        buf.write("\7?\2\2\u011bX\3\2\2\2\u011c\u011d\7?\2\2\u011d\u011e")
+        buf.write("\7?\2\2\u011eZ\3\2\2\2\u011f\u0120\7#\2\2\u0120\u0121")
+        buf.write("\7?\2\2\u0121\\\3\2\2\2\u0122\u0123\7V\2\2\u0123\u0124")
+        buf.write("\7t\2\2\u0124\u0125\7w\2\2\u0125\u012c\7g\2\2\u0126\u0127")
+        buf.write("\7H\2\2\u0127\u0128\7c\2\2\u0128\u0129\7n\2\2\u0129\u012a")
+        buf.write("\7u\2\2\u012a\u012c\7g\2\2\u012b\u0122\3\2\2\2\u012b\u0126")
+        buf.write("\3\2\2\2\u012c^\3\2\2\2\u012d\u0133\5m\67\2\u012e\u0132")
+        buf.write("\7a\2\2\u012f\u0132\5o8\2\u0130\u0132\5q9\2\u0131\u012e")
+        buf.write("\3\2\2\2\u0131\u012f\3\2\2\2\u0131\u0130\3\2\2\2\u0132")
+        buf.write("\u0135\3\2\2\2\u0133\u0131\3\2\2\2\u0133\u0134\3\2\2\2")
+        buf.write("\u0134`\3\2\2\2\u0135\u0133\3\2\2\2\u0136\u013c\5k\66")
+        buf.write("\2\u0137\u013b\7a\2\2\u0138\u013b\5o8\2\u0139\u013b\5")
+        buf.write("q9\2\u013a\u0137\3\2\2\2\u013a\u0138\3\2\2\2\u013a\u0139")
+        buf.write("\3\2\2\2\u013b\u013e\3\2\2\2\u013c\u013a\3\2\2\2\u013c")
+        buf.write("\u013d\3\2\2\2\u013db\3\2\2\2\u013e\u013c\3\2\2\2\u013f")
+        buf.write("\u0142\5g\64\2\u0140\u0141\7\60\2\2\u0141\u0143\5g\64")
+        buf.write("\2\u0142\u0140\3\2\2\2\u0142\u0143\3\2\2\2\u0143\u0145")
+        buf.write("\3\2\2\2\u0144\u0146\5i\65\2\u0145\u0144\3\2\2\2\u0145")
+        buf.write("\u0146\3\2\2\2\u0146d\3\2\2\2\u0147\u0148\5c\62\2\u0148")
+        buf.write("\u0149\7h\2\2\u0149f\3\2\2\2\u014a\u014c\5q9\2\u014b\u014a")
+        buf.write("\3\2\2\2\u014c\u014d\3\2\2\2\u014d\u014b\3\2\2\2\u014d")
+        buf.write("\u014e\3\2\2\2\u014eh\3\2\2\2\u014f\u0151\t\4\2\2\u0150")
+        buf.write("\u0152\t\5\2\2\u0151\u0150\3\2\2\2\u0151\u0152\3\2\2\2")
+        buf.write("\u0152\u0153\3\2\2\2\u0153\u0154\5g\64\2\u0154j\3\2\2")
+        buf.write("\2\u0155\u0156\t\6\2\2\u0156l\3\2\2\2\u0157\u0158\t\7")
+        buf.write("\2\2\u0158n\3\2\2\2\u0159\u015a\t\b\2\2\u015ap\3\2\2\2")
+        buf.write("\u015b\u015c\t\t\2\2\u015cr\3\2\2\2\u015d\u015e\7O\2\2")
+        buf.write("\u015e\u015f\7G\2\2\u015f\u0160\7V\2\2\u0160\u0161\7C")
+        buf.write("\2\2\u0161\u0162\7F\2\2\u0162\u0163\7C\2\2\u0163\u0164")
+        buf.write("\7V\2\2\u0164\u0165\7C\2\2\u0165\u0166\7<\2\2\u0166\u016a")
+        buf.write("\3\2\2\2\u0167\u0169\13\2\2\2\u0168\u0167\3\2\2\2\u0169")
+        buf.write("\u016c\3\2\2\2\u016a\u0168\3\2\2\2\u016a\u016b\3\2\2\2")
+        buf.write("\u016bt\3\2\2\2\u016c\u016a\3\2\2\2\23\2\u00df\u00e1\u00ec")
+        buf.write("\u00f6\u0103\u0105\u012b\u0131\u0133\u013a\u013c\u0142")
+        buf.write("\u0145\u014d\u0151\u016a\3\b\2\2")
         return buf.getvalue()
 
 
@@ -201,54 +201,57 @@ class RelayLexer(Lexer):
     T__25 = 26
     T__26 = 27
     T__27 = 28
-    SEMVER = 29
-    COMMENT = 30
-    WS = 31
-    LINE_COMMENT = 32
-    QUOTED_STRING = 33
-    MUL = 34
-    DIV = 35
-    ADD = 36
-    SUB = 37
-    LT = 38
-    GT = 39
-    LE = 40
-    GE = 41
-    EQ = 42
-    NE = 43
-    BOOL_LIT = 44
-    CNAME = 45
-    FLOAT = 46
-    BASE_TYPE = 47
-    NAT = 48
-    METADATA = 49
+    T__28 = 29
+    SEMVER = 30
+    COMMENT = 31
+    WS = 32
+    LINE_COMMENT = 33
+    QUOTED_STRING = 34
+    MUL = 35
+    DIV = 36
+    ADD = 37
+    SUB = 38
+    LT = 39
+    GT = 40
+    LE = 41
+    GE = 42
+    EQ = 43
+    NE = 44
+    BOOL_LIT = 45
+    START_UPPER_CNAME = 46
+    START_LOWER_CNAME = 47
+    FLOAT = 48
+    NAT = 49
+    METADATA = 50
 
     channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ]
 
     modeNames = [ "DEFAULT_MODE" ]
 
     literalNames = [ "<INVALID>",
-            "'@'", "'%'", "','", "'('", "')'", "'{'", "'}'", "'['", "']'", 
-            "'if'", "'else'", "'.'", "'let'", "'='", "';'", "';;'", "'fn'", 
-            "'->'", "'def'", "'type'", "'|'", "'=>'", "'match'", "'match?'", 
-            "'_'", "':'", "'Tensor'", "'meta'", "'v0.0.3'", "'*'", "'/'", 
-            "'+'", "'-'", "'<'", "'>'", "'<='", "'>='", "'=='", "'!='", 
-            "'int32'" ]
+            "'int32'", "'.'", "'@'", "'%'", "','", "'('", "')'", "'{'", 
+            "'}'", "'['", "']'", "'if'", "'else'", "'let'", "'='", "';'", 
+            "';;'", "'fn'", "'->'", "'def'", "'type'", "'|'", "'=>'", "'match'", 
+            "'match?'", "'_'", "':'", "'Tensor'", "'meta'", "'v0.0.3'", 
+            "'*'", "'/'", "'+'", "'-'", "'<'", "'>'", "'<='", "'>='", "'=='", 
+            "'!='" ]
 
     symbolicNames = [ "<INVALID>",
             "SEMVER", "COMMENT", "WS", "LINE_COMMENT", "QUOTED_STRING", 
             "MUL", "DIV", "ADD", "SUB", "LT", "GT", "LE", "GE", "EQ", "NE", 
-            "BOOL_LIT", "CNAME", "FLOAT", "BASE_TYPE", "NAT", "METADATA" ]
+            "BOOL_LIT", "START_UPPER_CNAME", "START_LOWER_CNAME", "FLOAT", 
+            "NAT", "METADATA" ]
 
     ruleNames = [ "T__0", "T__1", "T__2", "T__3", "T__4", "T__5", "T__6", 
                   "T__7", "T__8", "T__9", "T__10", "T__11", "T__12", "T__13", 
                   "T__14", "T__15", "T__16", "T__17", "T__18", "T__19", 
                   "T__20", "T__21", "T__22", "T__23", "T__24", "T__25", 
-                  "T__26", "T__27", "SEMVER", "COMMENT", "WS", "LINE_COMMENT", 
-                  "ESCAPED_QUOTE", "QUOTED_STRING", "MUL", "DIV", "ADD", 
-                  "SUB", "LT", "GT", "LE", "GE", "EQ", "NE", "BOOL_LIT", 
-                  "CNAME", "PREFLOAT", "FLOAT", "BASE_TYPE", "NAT", "EXP", 
-                  "LOWER_LETTER", "UPPER_LETTER", "LETTER", "DIGIT", "METADATA" ]
+                  "T__26", "T__27", "T__28", "SEMVER", "COMMENT", "WS", 
+                  "LINE_COMMENT", "ESCAPED_QUOTE", "QUOTED_STRING", "MUL", 
+                  "DIV", "ADD", "SUB", "LT", "GT", "LE", "GE", "EQ", "NE", 
+                  "BOOL_LIT", "START_UPPER_CNAME", "START_LOWER_CNAME", 
+                  "PREFLOAT", "FLOAT", "NAT", "EXP", "LOWER_LETTER", "UPPER_LETTER", 
+                  "LETTER", "DIGIT", "METADATA" ]
 
     grammarFileName = "Relay.g4"
 
diff --git a/python/tvm/relay/grammar/py3/RelayParser.py b/python/tvm/relay/grammar/py3/RelayParser.py
index 00b54f23f569..c26e0b20f085 100644
--- a/python/tvm/relay/grammar/py3/RelayParser.py
+++ b/python/tvm/relay/grammar/py3/RelayParser.py
@@ -8,221 +8,232 @@
 
 def serializedATN():
     with StringIO() as buf:
-        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\63")
-        buf.write("\u01c0\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
+        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\64")
+        buf.write("\u01d0\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
         buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
         buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
         buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
         buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
-        buf.write("\4\37\t\37\3\2\3\2\7\2A\n\2\f\2\16\2D\13\2\3\2\5\2G\n")
-        buf.write("\2\3\2\5\2J\n\2\3\2\3\2\3\3\3\3\3\4\3\4\3\4\3\5\3\5\3")
-        buf.write("\5\3\6\3\6\3\7\3\7\3\7\3\b\3\b\3\b\7\b^\n\b\f\b\16\ba")
-        buf.write("\13\b\5\bc\n\b\3\t\3\t\3\t\3\t\7\ti\n\t\f\t\16\tl\13\t")
-        buf.write("\3\t\5\to\n\t\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n")
-        buf.write("\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\6")
-        buf.write("\n\u0088\n\n\r\n\16\n\u0089\3\n\3\n\3\n\3\n\3\n\3\n\7")
-        buf.write("\n\u0092\n\n\f\n\16\n\u0095\13\n\5\n\u0097\n\n\3\n\3\n")
-        buf.write("\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\6")
-        buf.write("\n\u00a8\n\n\r\n\16\n\u00a9\3\n\3\n\3\n\3\n\3\n\3\n\3")
-        buf.write("\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\5\n")
-        buf.write("\u00bf\n\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n")
-        buf.write("\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\7\n\u00d8")
-        buf.write("\n\n\f\n\16\n\u00db\13\n\3\13\3\13\5\13\u00df\n\13\3\13")
-        buf.write("\3\13\3\13\3\13\3\13\5\13\u00e6\n\13\3\13\3\13\3\f\3\f")
-        buf.write("\3\f\5\f\u00ed\n\f\3\f\3\f\3\f\3\f\3\f\5\f\u00f4\n\f\3")
-        buf.write("\f\3\f\3\f\3\f\3\f\5\f\u00fb\n\f\3\f\3\f\6\f\u00ff\n\f")
-        buf.write("\r\f\16\f\u0100\5\f\u0103\n\f\3\r\3\r\3\r\3\r\3\r\3\r")
-        buf.write("\7\r\u010b\n\r\f\r\16\r\u010e\13\r\3\r\3\r\5\r\u0112\n")
-        buf.write("\r\3\16\3\16\3\16\5\16\u0117\n\16\3\16\3\16\3\16\3\17")
-        buf.write("\3\17\3\20\3\20\3\20\3\20\7\20\u0122\n\20\f\20\16\20\u0125")
-        buf.write("\13\20\3\20\3\20\3\21\3\21\5\21\u012b\n\21\3\22\3\22\3")
-        buf.write("\23\3\23\3\23\3\23\7\23\u0133\n\23\f\23\16\23\u0136\13")
-        buf.write("\23\3\23\5\23\u0139\n\23\3\24\3\24\3\24\7\24\u013e\n\24")
-        buf.write("\f\24\16\24\u0141\13\24\5\24\u0143\n\24\3\25\3\25\3\25")
-        buf.write("\5\25\u0148\n\25\3\26\3\26\3\26\7\26\u014d\n\26\f\26\16")
-        buf.write("\26\u0150\13\26\3\27\3\27\3\27\3\27\3\30\3\30\3\30\3\30")
-        buf.write("\3\30\3\30\3\30\3\30\3\30\3\30\3\30\6\30\u0161\n\30\r")
-        buf.write("\30\16\30\u0162\3\30\3\30\3\30\3\30\3\30\3\30\3\30\3\30")
-        buf.write("\3\30\3\30\3\30\3\30\3\30\3\30\3\30\5\30\u0174\n\30\3")
-        buf.write("\30\3\30\3\30\3\30\7\30\u017a\n\30\f\30\16\30\u017d\13")
-        buf.write("\30\5\30\u017f\n\30\3\30\3\30\3\30\5\30\u0184\n\30\3\31")
-        buf.write("\3\31\3\31\3\31\7\31\u018a\n\31\f\31\16\31\u018d\13\31")
-        buf.write("\3\31\3\31\3\32\3\32\3\32\3\32\6\32\u0195\n\32\r\32\16")
-        buf.write("\32\u0196\3\32\3\32\3\32\3\32\3\32\5\32\u019e\n\32\3\33")
-        buf.write("\3\33\3\33\3\33\3\33\3\33\3\33\3\33\3\34\3\34\3\34\3\34")
-        buf.write("\3\34\3\34\5\34\u01ae\n\34\3\35\3\35\3\35\3\35\3\36\3")
-        buf.write("\36\3\36\5\36\u01b7\n\36\3\37\3\37\3\37\3\37\3\37\5\37")
-        buf.write("\u01be\n\37\3\37\2\3\22 \2\4\6\b\n\f\16\20\22\24\26\30")
-        buf.write("\32\34\36 \"$&(*,.\60\62\64\668:<\2\7\3\2$%\3\2&\'\3\2")
-        buf.write("(+\3\2,-\3\2\31\32\2\u01ea\2>\3\2\2\2\4M\3\2\2\2\6O\3")
-        buf.write("\2\2\2\bR\3\2\2\2\nU\3\2\2\2\fW\3\2\2\2\16b\3\2\2\2\20")
-        buf.write("n\3\2\2\2\22\u00be\3\2\2\2\24\u00dc\3\2\2\2\26\u0102\3")
-        buf.write("\2\2\2\30\u0104\3\2\2\2\32\u0113\3\2\2\2\34\u011b\3\2")
-        buf.write("\2\2\36\u011d\3\2\2\2 \u012a\3\2\2\2\"\u012c\3\2\2\2$")
-        buf.write("\u0138\3\2\2\2&\u0142\3\2\2\2(\u0144\3\2\2\2*\u0149\3")
-        buf.write("\2\2\2,\u0151\3\2\2\2.\u0183\3\2\2\2\60\u0185\3\2\2\2")
-        buf.write("\62\u019d\3\2\2\2\64\u019f\3\2\2\2\66\u01ad\3\2\2\28\u01af")
-        buf.write("\3\2\2\2:\u01b6\3\2\2\2<\u01bd\3\2\2\2>F\7\37\2\2?A\5")
-        buf.write("\26\f\2@?\3\2\2\2AD\3\2\2\2B@\3\2\2\2BC\3\2\2\2CG\3\2")
-        buf.write("\2\2DB\3\2\2\2EG\5\22\n\2FB\3\2\2\2FE\3\2\2\2GI\3\2\2")
-        buf.write("\2HJ\7\63\2\2IH\3\2\2\2IJ\3\2\2\2JK\3\2\2\2KL\7\2\2\3")
-        buf.write("L\3\3\2\2\2MN\7/\2\2N\5\3\2\2\2OP\7\3\2\2PQ\7/\2\2Q\7")
-        buf.write("\3\2\2\2RS\7\4\2\2ST\7/\2\2T\t\3\2\2\2UV\7/\2\2V\13\3")
-        buf.write("\2\2\2WX\7\4\2\2XY\7\62\2\2Y\r\3\2\2\2Z_\5\22\n\2[\\\7")
-        buf.write("\5\2\2\\^\5\22\n\2][\3\2\2\2^a\3\2\2\2_]\3\2\2\2_`\3\2")
-        buf.write("\2\2`c\3\2\2\2a_\3\2\2\2bZ\3\2\2\2bc\3\2\2\2c\17\3\2\2")
-        buf.write("\2do\5\16\b\2ef\5\22\n\2fg\7\5\2\2gi\3\2\2\2he\3\2\2\2")
-        buf.write("il\3\2\2\2jh\3\2\2\2jk\3\2\2\2km\3\2\2\2lj\3\2\2\2mo\5")
-        buf.write("*\26\2nd\3\2\2\2nj\3\2\2\2o\21\3\2\2\2pq\b\n\1\2qr\7\6")
-        buf.write("\2\2rs\5\22\n\2st\7\7\2\2t\u00bf\3\2\2\2uv\7\b\2\2vw\5")
-        buf.write("\22\n\2wx\7\t\2\2x\u00bf\3\2\2\2yz\7\'\2\2z\u00bf\5\22")
-        buf.write("\n\26{\u00bf\5\24\13\2|}\7\6\2\2}\u00bf\7\7\2\2~\177\7")
-        buf.write("\6\2\2\177\u0080\5\22\n\2\u0080\u0081\7\5\2\2\u0081\u0082")
-        buf.write("\7\7\2\2\u0082\u00bf\3\2\2\2\u0083\u0084\7\6\2\2\u0084")
-        buf.write("\u0087\5\22\n\2\u0085\u0086\7\5\2\2\u0086\u0088\5\22\n")
-        buf.write("\2\u0087\u0085\3\2\2\2\u0088\u0089\3\2\2\2\u0089\u0087")
-        buf.write("\3\2\2\2\u0089\u008a\3\2\2\2\u008a\u008b\3\2\2\2\u008b")
-        buf.write("\u008c\7\7\2\2\u008c\u00bf\3\2\2\2\u008d\u0096\7\n\2\2")
-        buf.write("\u008e\u0093\5\22\n\2\u008f\u0090\7\5\2\2\u0090\u0092")
-        buf.write("\5\22\n\2\u0091\u008f\3\2\2\2\u0092\u0095\3\2\2\2\u0093")
-        buf.write("\u0091\3\2\2\2\u0093\u0094\3\2\2\2\u0094\u0097\3\2\2\2")
-        buf.write("\u0095\u0093\3\2\2\2\u0096\u008e\3\2\2\2\u0096\u0097\3")
-        buf.write("\2\2\2\u0097\u0098\3\2\2\2\u0098\u00bf\7\13\2\2\u0099")
-        buf.write("\u009a\7\f\2\2\u009a\u009b\7\6\2\2\u009b\u009c\5\22\n")
-        buf.write("\2\u009c\u009d\7\7\2\2\u009d\u009e\58\35\2\u009e\u009f")
-        buf.write("\7\r\2\2\u009f\u00a0\58\35\2\u00a0\u00bf\3\2\2\2\u00a1")
-        buf.write("\u00a2\5\34\17\2\u00a2\u00a3\7\6\2\2\u00a3\u00a4\5\22")
-        buf.write("\n\2\u00a4\u00a5\7\7\2\2\u00a5\u00a7\7\b\2\2\u00a6\u00a8")
-        buf.write("\5\32\16\2\u00a7\u00a6\3\2\2\2\u00a8\u00a9\3\2\2\2\u00a9")
-        buf.write("\u00a7\3\2\2\2\u00a9\u00aa\3\2\2\2\u00aa\u00ab\3\2\2\2")
-        buf.write("\u00ab\u00ac\7\t\2\2\u00ac\u00bf\3\2\2\2\u00ad\u00ae\7")
-        buf.write("\17\2\2\u00ae\u00af\5(\25\2\u00af\u00b0\7\20\2\2\u00b0")
-        buf.write("\u00b1\5\22\n\2\u00b1\u00b2\7\21\2\2\u00b2\u00b3\5\22")
-        buf.write("\n\t\u00b3\u00bf\3\2\2\2\u00b4\u00b5\5\f\7\2\u00b5\u00b6")
-        buf.write("\7\20\2\2\u00b6\u00b7\5\22\n\2\u00b7\u00b8\7\21\2\2\u00b8")
-        buf.write("\u00b9\5\22\n\7\u00b9\u00bf\3\2\2\2\u00ba\u00bf\5<\37")
-        buf.write("\2\u00bb\u00bf\5:\36\2\u00bc\u00bf\5\64\33\2\u00bd\u00bf")
-        buf.write("\7#\2\2\u00bep\3\2\2\2\u00beu\3\2\2\2\u00bey\3\2\2\2\u00be")
-        buf.write("{\3\2\2\2\u00be|\3\2\2\2\u00be~\3\2\2\2\u00be\u0083\3")
-        buf.write("\2\2\2\u00be\u008d\3\2\2\2\u00be\u0099\3\2\2\2\u00be\u00a1")
-        buf.write("\3\2\2\2\u00be\u00ad\3\2\2\2\u00be\u00b4\3\2\2\2\u00be")
-        buf.write("\u00ba\3\2\2\2\u00be\u00bb\3\2\2\2\u00be\u00bc\3\2\2\2")
-        buf.write("\u00be\u00bd\3\2\2\2\u00bf\u00d9\3\2\2\2\u00c0\u00c1\f")
-        buf.write("\25\2\2\u00c1\u00c2\t\2\2\2\u00c2\u00d8\5\22\n\26\u00c3")
-        buf.write("\u00c4\f\24\2\2\u00c4\u00c5\t\3\2\2\u00c5\u00d8\5\22\n")
-        buf.write("\25\u00c6\u00c7\f\23\2\2\u00c7\u00c8\t\4\2\2\u00c8\u00d8")
-        buf.write("\5\22\n\24\u00c9\u00ca\f\22\2\2\u00ca\u00cb\t\5\2\2\u00cb")
-        buf.write("\u00d8\5\22\n\23\u00cc\u00cd\f\b\2\2\u00cd\u00ce\7\22")
-        buf.write("\2\2\u00ce\u00d8\5\22\n\t\u00cf\u00d0\f\27\2\2\u00d0\u00d1")
-        buf.write("\7\6\2\2\u00d1\u00d2\5\20\t\2\u00d2\u00d3\7\7\2\2\u00d3")
-        buf.write("\u00d8\3\2\2\2\u00d4\u00d5\f\n\2\2\u00d5\u00d6\7\16\2")
-        buf.write("\2\u00d6\u00d8\7\62\2\2\u00d7\u00c0\3\2\2\2\u00d7\u00c3")
-        buf.write("\3\2\2\2\u00d7\u00c6\3\2\2\2\u00d7\u00c9\3\2\2\2\u00d7")
-        buf.write("\u00cc\3\2\2\2\u00d7\u00cf\3\2\2\2\u00d7\u00d4\3\2\2\2")
-        buf.write("\u00d8\u00db\3\2\2\2\u00d9\u00d7\3\2\2\2\u00d9\u00da\3")
-        buf.write("\2\2\2\u00da\23\3\2\2\2\u00db\u00d9\3\2\2\2\u00dc\u00de")
-        buf.write("\7\23\2\2\u00dd\u00df\5\60\31\2\u00de\u00dd\3\2\2\2\u00de")
-        buf.write("\u00df\3\2\2\2\u00df\u00e0\3\2\2\2\u00e0\u00e1\7\6\2\2")
-        buf.write("\u00e1\u00e2\5$\23\2\u00e2\u00e5\7\7\2\2\u00e3\u00e4\7")
-        buf.write("\24\2\2\u00e4\u00e6\5.\30\2\u00e5\u00e3\3\2\2\2\u00e5")
-        buf.write("\u00e6\3\2\2\2\u00e6\u00e7\3\2\2\2\u00e7\u00e8\58\35\2")
-        buf.write("\u00e8\25\3\2\2\2\u00e9\u00ea\7\25\2\2\u00ea\u00ec\5\6")
-        buf.write("\4\2\u00eb\u00ed\5\60\31\2\u00ec\u00eb\3\2\2\2\u00ec\u00ed")
-        buf.write("\3\2\2\2\u00ed\u00ee\3\2\2\2\u00ee\u00ef\7\6\2\2\u00ef")
-        buf.write("\u00f0\5$\23\2\u00f0\u00f3\7\7\2\2\u00f1\u00f2\7\24\2")
-        buf.write("\2\u00f2\u00f4\5.\30\2\u00f3\u00f1\3\2\2\2\u00f3\u00f4")
-        buf.write("\3\2\2\2\u00f4\u00f5\3\2\2\2\u00f5\u00f6\58\35\2\u00f6")
-        buf.write("\u0103\3\2\2\2\u00f7\u00f8\7\26\2\2\u00f8\u00fa\5\n\6")
-        buf.write("\2\u00f9\u00fb\5\60\31\2\u00fa\u00f9\3\2\2\2\u00fa\u00fb")
-        buf.write("\3\2\2\2\u00fb\u00fc\3\2\2\2\u00fc\u00fe\7\20\2\2\u00fd")
-        buf.write("\u00ff\5\30\r\2\u00fe\u00fd\3\2\2\2\u00ff\u0100\3\2\2")
-        buf.write("\2\u0100\u00fe\3\2\2\2\u0100\u0101\3\2\2\2\u0101\u0103")
-        buf.write("\3\2\2\2\u0102\u00e9\3\2\2\2\u0102\u00f7\3\2\2\2\u0103")
-        buf.write("\27\3\2\2\2\u0104\u0105\7\27\2\2\u0105\u0111\5\"\22\2")
-        buf.write("\u0106\u0107\7\6\2\2\u0107\u010c\5.\30\2\u0108\u0109\7")
-        buf.write("\5\2\2\u0109\u010b\5.\30\2\u010a\u0108\3\2\2\2\u010b\u010e")
-        buf.write("\3\2\2\2\u010c\u010a\3\2\2\2\u010c\u010d\3\2\2\2\u010d")
-        buf.write("\u010f\3\2\2\2\u010e\u010c\3\2\2\2\u010f\u0110\7\7\2\2")
-        buf.write("\u0110\u0112\3\2\2\2\u0111\u0106\3\2\2\2\u0111\u0112\3")
-        buf.write("\2\2\2\u0112\31\3\2\2\2\u0113\u0114\7\27\2\2\u0114\u0116")
-        buf.write("\5\"\22\2\u0115\u0117\5\36\20\2\u0116\u0115\3\2\2\2\u0116")
-        buf.write("\u0117\3\2\2\2\u0117\u0118\3\2\2\2\u0118\u0119\7\30\2")
-        buf.write("\2\u0119\u011a\5\22\n\2\u011a\33\3\2\2\2\u011b\u011c\t")
-        buf.write("\6\2\2\u011c\35\3\2\2\2\u011d\u011e\7\6\2\2\u011e\u0123")
-        buf.write("\5 \21\2\u011f\u0120\7\5\2\2\u0120\u0122\5 \21\2\u0121")
-        buf.write("\u011f\3\2\2\2\u0122\u0125\3\2\2\2\u0123\u0121\3\2\2\2")
-        buf.write("\u0123\u0124\3\2\2\2\u0124\u0126\3\2\2\2\u0125\u0123\3")
-        buf.write("\2\2\2\u0126\u0127\7\7\2\2\u0127\37\3\2\2\2\u0128\u012b")
-        buf.write("\7\33\2\2\u0129\u012b\5\b\5\2\u012a\u0128\3\2\2\2\u012a")
-        buf.write("\u0129\3\2\2\2\u012b!\3\2\2\2\u012c\u012d\7/\2\2\u012d")
-        buf.write("#\3\2\2\2\u012e\u0139\5&\24\2\u012f\u0130\5(\25\2\u0130")
-        buf.write("\u0131\7\5\2\2\u0131\u0133\3\2\2\2\u0132\u012f\3\2\2\2")
-        buf.write("\u0133\u0136\3\2\2\2\u0134\u0132\3\2\2\2\u0134\u0135\3")
-        buf.write("\2\2\2\u0135\u0137\3\2\2\2\u0136\u0134\3\2\2\2\u0137\u0139")
-        buf.write("\5*\26\2\u0138\u012e\3\2\2\2\u0138\u0134\3\2\2\2\u0139")
-        buf.write("%\3\2\2\2\u013a\u013f\5(\25\2\u013b\u013c\7\5\2\2\u013c")
-        buf.write("\u013e\5(\25\2\u013d\u013b\3\2\2\2\u013e\u0141\3\2\2\2")
-        buf.write("\u013f\u013d\3\2\2\2\u013f\u0140\3\2\2\2\u0140\u0143\3")
-        buf.write("\2\2\2\u0141\u013f\3\2\2\2\u0142\u013a\3\2\2\2\u0142\u0143")
-        buf.write("\3\2\2\2\u0143\'\3\2\2\2\u0144\u0147\5\b\5\2\u0145\u0146")
-        buf.write("\7\34\2\2\u0146\u0148\5.\30\2\u0147\u0145\3\2\2\2\u0147")
-        buf.write("\u0148\3\2\2\2\u0148)\3\2\2\2\u0149\u014e\5,\27\2\u014a")
-        buf.write("\u014b\7\5\2\2\u014b\u014d\5,\27\2\u014c\u014a\3\2\2\2")
-        buf.write("\u014d\u0150\3\2\2\2\u014e\u014c\3\2\2\2\u014e\u014f\3")
-        buf.write("\2\2\2\u014f+\3\2\2\2\u0150\u014e\3\2\2\2\u0151\u0152")
-        buf.write("\7/\2\2\u0152\u0153\7\20\2\2\u0153\u0154\5\22\n\2\u0154")
-        buf.write("-\3\2\2\2\u0155\u0156\7\6\2\2\u0156\u0184\7\7\2\2\u0157")
-        buf.write("\u0158\7\6\2\2\u0158\u0159\5.\30\2\u0159\u015a\7\5\2\2")
-        buf.write("\u015a\u015b\7\7\2\2\u015b\u0184\3\2\2\2\u015c\u015d\7")
-        buf.write("\6\2\2\u015d\u0160\5.\30\2\u015e\u015f\7\5\2\2\u015f\u0161")
-        buf.write("\5.\30\2\u0160\u015e\3\2\2\2\u0161\u0162\3\2\2\2\u0162")
-        buf.write("\u0160\3\2\2\2\u0162\u0163\3\2\2\2\u0163\u0164\3\2\2\2")
-        buf.write("\u0164\u0165\7\7\2\2\u0165\u0184\3\2\2\2\u0166\u0167\5")
-        buf.write("\n\6\2\u0167\u0168\5\60\31\2\u0168\u0184\3\2\2\2\u0169")
-        buf.write("\u0184\5\n\6\2\u016a\u016b\7\35\2\2\u016b\u016c\7\n\2")
-        buf.write("\2\u016c\u016d\5\62\32\2\u016d\u016e\7\5\2\2\u016e\u016f")
-        buf.write("\5.\30\2\u016f\u0170\7\13\2\2\u0170\u0184\3\2\2\2\u0171")
-        buf.write("\u0173\7\23\2\2\u0172\u0174\5\60\31\2\u0173\u0172\3\2")
-        buf.write("\2\2\u0173\u0174\3\2\2\2\u0174\u0175\3\2\2\2\u0175\u017e")
-        buf.write("\7\6\2\2\u0176\u017b\5.\30\2\u0177\u0178\7\5\2\2\u0178")
-        buf.write("\u017a\5.\30\2\u0179\u0177\3\2\2\2\u017a\u017d\3\2\2\2")
-        buf.write("\u017b\u0179\3\2\2\2\u017b\u017c\3\2\2\2\u017c\u017f\3")
-        buf.write("\2\2\2\u017d\u017b\3\2\2\2\u017e\u0176\3\2\2\2\u017e\u017f")
-        buf.write("\3\2\2\2\u017f\u0180\3\2\2\2\u0180\u0181\7\7\2\2\u0181")
-        buf.write("\u0182\7\24\2\2\u0182\u0184\5.\30\2\u0183\u0155\3\2\2")
-        buf.write("\2\u0183\u0157\3\2\2\2\u0183\u015c\3\2\2\2\u0183\u0166")
-        buf.write("\3\2\2\2\u0183\u0169\3\2\2\2\u0183\u016a\3\2\2\2\u0183")
-        buf.write("\u0171\3\2\2\2\u0184/\3\2\2\2\u0185\u0186\7\n\2\2\u0186")
-        buf.write("\u018b\5\n\6\2\u0187\u0188\7\5\2\2\u0188\u018a\5\n\6\2")
-        buf.write("\u0189\u0187\3\2\2\2\u018a\u018d\3\2\2\2\u018b\u0189\3")
-        buf.write("\2\2\2\u018b\u018c\3\2\2\2\u018c\u018e\3\2\2\2\u018d\u018b")
-        buf.write("\3\2\2\2\u018e\u018f\7\13\2\2\u018f\61\3\2\2\2\u0190\u0191")
-        buf.write("\7\6\2\2\u0191\u0194\5\66\34\2\u0192\u0193\7\5\2\2\u0193")
-        buf.write("\u0195\5\66\34\2\u0194\u0192\3\2\2\2\u0195\u0196\3\2\2")
-        buf.write("\2\u0196\u0194\3\2\2\2\u0196\u0197\3\2\2\2\u0197\u0198")
-        buf.write("\3\2\2\2\u0198\u0199\7\7\2\2\u0199\u019e\3\2\2\2\u019a")
-        buf.write("\u019b\7\6\2\2\u019b\u019e\7\7\2\2\u019c\u019e\5\66\34")
-        buf.write("\2\u019d\u0190\3\2\2\2\u019d\u019a\3\2\2\2\u019d\u019c")
-        buf.write("\3\2\2\2\u019e\63\3\2\2\2\u019f\u01a0\7\36\2\2\u01a0\u01a1")
-        buf.write("\7\n\2\2\u01a1\u01a2\7/\2\2\u01a2\u01a3\7\13\2\2\u01a3")
-        buf.write("\u01a4\7\n\2\2\u01a4\u01a5\7\62\2\2\u01a5\u01a6\7\13\2")
-        buf.write("\2\u01a6\65\3\2\2\2\u01a7\u01ae\5\64\33\2\u01a8\u01a9")
-        buf.write("\7\6\2\2\u01a9\u01aa\5\66\34\2\u01aa\u01ab\7\7\2\2\u01ab")
-        buf.write("\u01ae\3\2\2\2\u01ac\u01ae\7\62\2\2\u01ad\u01a7\3\2\2")
-        buf.write("\2\u01ad\u01a8\3\2\2\2\u01ad\u01ac\3\2\2\2\u01ae\67\3")
-        buf.write("\2\2\2\u01af\u01b0\7\b\2\2\u01b0\u01b1\5\22\n\2\u01b1")
-        buf.write("\u01b2\7\t\2\2\u01b29\3\2\2\2\u01b3\u01b7\7\60\2\2\u01b4")
-        buf.write("\u01b7\7\62\2\2\u01b5\u01b7\7.\2\2\u01b6\u01b3\3\2\2\2")
-        buf.write("\u01b6\u01b4\3\2\2\2\u01b6\u01b5\3\2\2\2\u01b7;\3\2\2")
-        buf.write("\2\u01b8\u01be\5\4\3\2\u01b9\u01be\5\6\4\2\u01ba\u01be")
-        buf.write("\5\b\5\2\u01bb\u01be\5.\30\2\u01bc\u01be\5\f\7\2\u01bd")
-        buf.write("\u01b8\3\2\2\2\u01bd\u01b9\3\2\2\2\u01bd\u01ba\3\2\2\2")
-        buf.write("\u01bd\u01bb\3\2\2\2\u01bd\u01bc\3\2\2\2\u01be=\3\2\2")
-        buf.write("\2-BFI_bjn\u0089\u0093\u0096\u00a9\u00be\u00d7\u00d9\u00de")
-        buf.write("\u00e5\u00ec\u00f3\u00fa\u0100\u0102\u010c\u0111\u0116")
-        buf.write("\u0123\u012a\u0134\u0138\u013f\u0142\u0147\u014e\u0162")
-        buf.write("\u0173\u017b\u017e\u0183\u018b\u0196\u019d\u01ad\u01b6")
-        buf.write("\u01bd")
+        buf.write("\4\37\t\37\4 \t \3\2\3\2\3\3\3\3\7\3E\n\3\f\3\16\3H\13")
+        buf.write("\3\3\3\5\3K\n\3\3\3\5\3N\n\3\3\3\3\3\3\4\3\4\3\4\7\4U")
+        buf.write("\n\4\f\4\16\4X\13\4\3\5\3\5\3\5\3\6\3\6\3\6\3\7\3\7\5")
+        buf.write("\7b\n\7\3\b\3\b\3\b\3\t\3\t\3\t\7\tj\n\t\f\t\16\tm\13")
+        buf.write("\t\5\to\n\t\3\n\3\n\3\n\3\n\7\nu\n\n\f\n\16\nx\13\n\3")
+        buf.write("\n\5\n{\n\n\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3")
+        buf.write("\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13")
+        buf.write("\3\13\3\13\3\13\3\13\6\13\u0094\n\13\r\13\16\13\u0095")
+        buf.write("\3\13\3\13\3\13\3\13\3\13\3\13\7\13\u009e\n\13\f\13\16")
+        buf.write("\13\u00a1\13\13\5\13\u00a3\n\13\3\13\3\13\3\13\3\13\3")
+        buf.write("\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13")
+        buf.write("\6\13\u00b4\n\13\r\13\16\13\u00b5\3\13\3\13\3\13\3\13")
+        buf.write("\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13")
+        buf.write("\3\13\3\13\3\13\3\13\5\13\u00cb\n\13\3\13\3\13\3\13\3")
+        buf.write("\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13")
+        buf.write("\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\7\13\u00e4")
+        buf.write("\n\13\f\13\16\13\u00e7\13\13\3\f\3\f\5\f\u00eb\n\f\3\f")
+        buf.write("\3\f\3\f\3\f\3\f\5\f\u00f2\n\f\3\f\3\f\3\r\3\r\3\r\5\r")
+        buf.write("\u00f9\n\r\3\r\3\r\3\r\3\r\3\r\5\r\u0100\n\r\3\r\3\r\3")
+        buf.write("\r\3\r\3\r\5\r\u0107\n\r\3\r\3\r\6\r\u010b\n\r\r\r\16")
+        buf.write("\r\u010c\5\r\u010f\n\r\3\16\3\16\3\16\3\16\3\16\3\16\7")
+        buf.write("\16\u0117\n\16\f\16\16\16\u011a\13\16\3\16\3\16\5\16\u011e")
+        buf.write("\n\16\3\17\3\17\3\17\5\17\u0123\n\17\3\17\3\17\3\17\3")
+        buf.write("\20\3\20\3\21\3\21\3\21\3\21\7\21\u012e\n\21\f\21\16\21")
+        buf.write("\u0131\13\21\3\21\3\21\3\22\3\22\3\22\3\22\5\22\u0139")
+        buf.write("\n\22\5\22\u013b\n\22\3\23\3\23\3\24\3\24\3\24\3\24\7")
+        buf.write("\24\u0143\n\24\f\24\16\24\u0146\13\24\3\24\5\24\u0149")
+        buf.write("\n\24\3\25\3\25\3\25\7\25\u014e\n\25\f\25\16\25\u0151")
+        buf.write("\13\25\5\25\u0153\n\25\3\26\3\26\3\26\5\26\u0158\n\26")
+        buf.write("\3\27\3\27\3\27\7\27\u015d\n\27\f\27\16\27\u0160\13\27")
+        buf.write("\3\30\3\30\3\30\3\30\3\31\3\31\3\31\3\31\3\31\3\31\3\31")
+        buf.write("\3\31\3\31\3\31\3\31\6\31\u0171\n\31\r\31\16\31\u0172")
+        buf.write("\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31")
+        buf.write("\3\31\3\31\3\31\3\31\5\31\u0184\n\31\3\31\3\31\3\31\3")
+        buf.write("\31\7\31\u018a\n\31\f\31\16\31\u018d\13\31\5\31\u018f")
+        buf.write("\n\31\3\31\3\31\3\31\5\31\u0194\n\31\3\32\3\32\3\32\3")
+        buf.write("\32\7\32\u019a\n\32\f\32\16\32\u019d\13\32\3\32\3\32\3")
+        buf.write("\33\3\33\3\33\3\33\6\33\u01a5\n\33\r\33\16\33\u01a6\3")
+        buf.write("\33\3\33\3\33\3\33\3\33\5\33\u01ae\n\33\3\34\3\34\3\34")
+        buf.write("\3\34\3\34\3\34\3\34\3\34\3\35\3\35\3\35\3\35\3\35\3\35")
+        buf.write("\5\35\u01be\n\35\3\36\3\36\3\36\3\36\3\37\3\37\3\37\5")
+        buf.write("\37\u01c7\n\37\3 \3 \3 \3 \3 \5 \u01ce\n \3 \2\3\24!\2")
+        buf.write("\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64")
+        buf.write("\668:<>\2\7\3\2%&\3\2\'(\3\2),\3\2-.\3\2\32\33\2\u01fc")
+        buf.write("\2@\3\2\2\2\4B\3\2\2\2\6Q\3\2\2\2\bY\3\2\2\2\n\\\3\2\2")
+        buf.write("\2\fa\3\2\2\2\16c\3\2\2\2\20n\3\2\2\2\22z\3\2\2\2\24\u00ca")
+        buf.write("\3\2\2\2\26\u00e8\3\2\2\2\30\u010e\3\2\2\2\32\u0110\3")
+        buf.write("\2\2\2\34\u011f\3\2\2\2\36\u0127\3\2\2\2 \u0129\3\2\2")
+        buf.write("\2\"\u013a\3\2\2\2$\u013c\3\2\2\2&\u0148\3\2\2\2(\u0152")
+        buf.write("\3\2\2\2*\u0154\3\2\2\2,\u0159\3\2\2\2.\u0161\3\2\2\2")
+        buf.write("\60\u0193\3\2\2\2\62\u0195\3\2\2\2\64\u01ad\3\2\2\2\66")
+        buf.write("\u01af\3\2\2\28\u01bd\3\2\2\2:\u01bf\3\2\2\2<\u01c6\3")
+        buf.write("\2\2\2>\u01cd\3\2\2\2@A\7\3\2\2A\3\3\2\2\2BJ\7 \2\2CE")
+        buf.write("\5\30\r\2DC\3\2\2\2EH\3\2\2\2FD\3\2\2\2FG\3\2\2\2GK\3")
+        buf.write("\2\2\2HF\3\2\2\2IK\5\24\13\2JF\3\2\2\2JI\3\2\2\2KM\3\2")
+        buf.write("\2\2LN\7\64\2\2ML\3\2\2\2MN\3\2\2\2NO\3\2\2\2OP\7\2\2")
+        buf.write("\3P\5\3\2\2\2QV\7\61\2\2RS\7\4\2\2SU\7\61\2\2TR\3\2\2")
+        buf.write("\2UX\3\2\2\2VT\3\2\2\2VW\3\2\2\2W\7\3\2\2\2XV\3\2\2\2")
+        buf.write("YZ\7\5\2\2Z[\7\61\2\2[\t\3\2\2\2\\]\7\6\2\2]^\7\61\2\2")
+        buf.write("^\13\3\2\2\2_b\5\2\2\2`b\7\60\2\2a_\3\2\2\2a`\3\2\2\2")
+        buf.write("b\r\3\2\2\2cd\7\6\2\2de\7\63\2\2e\17\3\2\2\2fk\5\24\13")
+        buf.write("\2gh\7\7\2\2hj\5\24\13\2ig\3\2\2\2jm\3\2\2\2ki\3\2\2\2")
+        buf.write("kl\3\2\2\2lo\3\2\2\2mk\3\2\2\2nf\3\2\2\2no\3\2\2\2o\21")
+        buf.write("\3\2\2\2p{\5\20\t\2qr\5\24\13\2rs\7\7\2\2su\3\2\2\2tq")
+        buf.write("\3\2\2\2ux\3\2\2\2vt\3\2\2\2vw\3\2\2\2wy\3\2\2\2xv\3\2")
+        buf.write("\2\2y{\5,\27\2zp\3\2\2\2zv\3\2\2\2{\23\3\2\2\2|}\b\13")
+        buf.write("\1\2}~\7\b\2\2~\177\5\24\13\2\177\u0080\7\t\2\2\u0080")
+        buf.write("\u00cb\3\2\2\2\u0081\u0082\7\n\2\2\u0082\u0083\5\24\13")
+        buf.write("\2\u0083\u0084\7\13\2\2\u0084\u00cb\3\2\2\2\u0085\u0086")
+        buf.write("\7(\2\2\u0086\u00cb\5\24\13\26\u0087\u00cb\5\26\f\2\u0088")
+        buf.write("\u0089\7\b\2\2\u0089\u00cb\7\t\2\2\u008a\u008b\7\b\2\2")
+        buf.write("\u008b\u008c\5\24\13\2\u008c\u008d\7\7\2\2\u008d\u008e")
+        buf.write("\7\t\2\2\u008e\u00cb\3\2\2\2\u008f\u0090\7\b\2\2\u0090")
+        buf.write("\u0093\5\24\13\2\u0091\u0092\7\7\2\2\u0092\u0094\5\24")
+        buf.write("\13\2\u0093\u0091\3\2\2\2\u0094\u0095\3\2\2\2\u0095\u0093")
+        buf.write("\3\2\2\2\u0095\u0096\3\2\2\2\u0096\u0097\3\2\2\2\u0097")
+        buf.write("\u0098\7\t\2\2\u0098\u00cb\3\2\2\2\u0099\u00a2\7\f\2\2")
+        buf.write("\u009a\u009f\5\24\13\2\u009b\u009c\7\7\2\2\u009c\u009e")
+        buf.write("\5\24\13\2\u009d\u009b\3\2\2\2\u009e\u00a1\3\2\2\2\u009f")
+        buf.write("\u009d\3\2\2\2\u009f\u00a0\3\2\2\2\u00a0\u00a3\3\2\2\2")
+        buf.write("\u00a1\u009f\3\2\2\2\u00a2\u009a\3\2\2\2\u00a2\u00a3\3")
+        buf.write("\2\2\2\u00a3\u00a4\3\2\2\2\u00a4\u00cb\7\r\2\2\u00a5\u00a6")
+        buf.write("\7\16\2\2\u00a6\u00a7\7\b\2\2\u00a7\u00a8\5\24\13\2\u00a8")
+        buf.write("\u00a9\7\t\2\2\u00a9\u00aa\5:\36\2\u00aa\u00ab\7\17\2")
+        buf.write("\2\u00ab\u00ac\5:\36\2\u00ac\u00cb\3\2\2\2\u00ad\u00ae")
+        buf.write("\5\36\20\2\u00ae\u00af\7\b\2\2\u00af\u00b0\5\24\13\2\u00b0")
+        buf.write("\u00b1\7\t\2\2\u00b1\u00b3\7\n\2\2\u00b2\u00b4\5\34\17")
+        buf.write("\2\u00b3\u00b2\3\2\2\2\u00b4\u00b5\3\2\2\2\u00b5\u00b3")
+        buf.write("\3\2\2\2\u00b5\u00b6\3\2\2\2\u00b6\u00b7\3\2\2\2\u00b7")
+        buf.write("\u00b8\7\13\2\2\u00b8\u00cb\3\2\2\2\u00b9\u00ba\7\20\2")
+        buf.write("\2\u00ba\u00bb\5*\26\2\u00bb\u00bc\7\21\2\2\u00bc\u00bd")
+        buf.write("\5\24\13\2\u00bd\u00be\7\22\2\2\u00be\u00bf\5\24\13\t")
+        buf.write("\u00bf\u00cb\3\2\2\2\u00c0\u00c1\5\16\b\2\u00c1\u00c2")
+        buf.write("\7\21\2\2\u00c2\u00c3\5\24\13\2\u00c3\u00c4\7\22\2\2\u00c4")
+        buf.write("\u00c5\5\24\13\7\u00c5\u00cb\3\2\2\2\u00c6\u00cb\5> \2")
+        buf.write("\u00c7\u00cb\5<\37\2\u00c8\u00cb\5\66\34\2\u00c9\u00cb")
+        buf.write("\7$\2\2\u00ca|\3\2\2\2\u00ca\u0081\3\2\2\2\u00ca\u0085")
+        buf.write("\3\2\2\2\u00ca\u0087\3\2\2\2\u00ca\u0088\3\2\2\2\u00ca")
+        buf.write("\u008a\3\2\2\2\u00ca\u008f\3\2\2\2\u00ca\u0099\3\2\2\2")
+        buf.write("\u00ca\u00a5\3\2\2\2\u00ca\u00ad\3\2\2\2\u00ca\u00b9\3")
+        buf.write("\2\2\2\u00ca\u00c0\3\2\2\2\u00ca\u00c6\3\2\2\2\u00ca\u00c7")
+        buf.write("\3\2\2\2\u00ca\u00c8\3\2\2\2\u00ca\u00c9\3\2\2\2\u00cb")
+        buf.write("\u00e5\3\2\2\2\u00cc\u00cd\f\25\2\2\u00cd\u00ce\t\2\2")
+        buf.write("\2\u00ce\u00e4\5\24\13\26\u00cf\u00d0\f\24\2\2\u00d0\u00d1")
+        buf.write("\t\3\2\2\u00d1\u00e4\5\24\13\25\u00d2\u00d3\f\23\2\2\u00d3")
+        buf.write("\u00d4\t\4\2\2\u00d4\u00e4\5\24\13\24\u00d5\u00d6\f\22")
+        buf.write("\2\2\u00d6\u00d7\t\5\2\2\u00d7\u00e4\5\24\13\23\u00d8")
+        buf.write("\u00d9\f\b\2\2\u00d9\u00da\7\23\2\2\u00da\u00e4\5\24\13")
+        buf.write("\t\u00db\u00dc\f\27\2\2\u00dc\u00dd\7\b\2\2\u00dd\u00de")
+        buf.write("\5\22\n\2\u00de\u00df\7\t\2\2\u00df\u00e4\3\2\2\2\u00e0")
+        buf.write("\u00e1\f\n\2\2\u00e1\u00e2\7\4\2\2\u00e2\u00e4\7\63\2")
+        buf.write("\2\u00e3\u00cc\3\2\2\2\u00e3\u00cf\3\2\2\2\u00e3\u00d2")
+        buf.write("\3\2\2\2\u00e3\u00d5\3\2\2\2\u00e3\u00d8\3\2\2\2\u00e3")
+        buf.write("\u00db\3\2\2\2\u00e3\u00e0\3\2\2\2\u00e4\u00e7\3\2\2\2")
+        buf.write("\u00e5\u00e3\3\2\2\2\u00e5\u00e6\3\2\2\2\u00e6\25\3\2")
+        buf.write("\2\2\u00e7\u00e5\3\2\2\2\u00e8\u00ea\7\24\2\2\u00e9\u00eb")
+        buf.write("\5\62\32\2\u00ea\u00e9\3\2\2\2\u00ea\u00eb\3\2\2\2\u00eb")
+        buf.write("\u00ec\3\2\2\2\u00ec\u00ed\7\b\2\2\u00ed\u00ee\5&\24\2")
+        buf.write("\u00ee\u00f1\7\t\2\2\u00ef\u00f0\7\25\2\2\u00f0\u00f2")
+        buf.write("\5\60\31\2\u00f1\u00ef\3\2\2\2\u00f1\u00f2\3\2\2\2\u00f2")
+        buf.write("\u00f3\3\2\2\2\u00f3\u00f4\5:\36\2\u00f4\27\3\2\2\2\u00f5")
+        buf.write("\u00f6\7\26\2\2\u00f6\u00f8\5\b\5\2\u00f7\u00f9\5\62\32")
+        buf.write("\2\u00f8\u00f7\3\2\2\2\u00f8\u00f9\3\2\2\2\u00f9\u00fa")
+        buf.write("\3\2\2\2\u00fa\u00fb\7\b\2\2\u00fb\u00fc\5&\24\2\u00fc")
+        buf.write("\u00ff\7\t\2\2\u00fd\u00fe\7\25\2\2\u00fe\u0100\5\60\31")
+        buf.write("\2\u00ff\u00fd\3\2\2\2\u00ff\u0100\3\2\2\2\u0100\u0101")
+        buf.write("\3\2\2\2\u0101\u0102\5:\36\2\u0102\u010f\3\2\2\2\u0103")
+        buf.write("\u0104\7\27\2\2\u0104\u0106\5\f\7\2\u0105\u0107\5\62\32")
+        buf.write("\2\u0106\u0105\3\2\2\2\u0106\u0107\3\2\2\2\u0107\u0108")
+        buf.write("\3\2\2\2\u0108\u010a\7\21\2\2\u0109\u010b\5\32\16\2\u010a")
+        buf.write("\u0109\3\2\2\2\u010b\u010c\3\2\2\2\u010c\u010a\3\2\2\2")
+        buf.write("\u010c\u010d\3\2\2\2\u010d\u010f\3\2\2\2\u010e\u00f5\3")
+        buf.write("\2\2\2\u010e\u0103\3\2\2\2\u010f\31\3\2\2\2\u0110\u0111")
+        buf.write("\7\30\2\2\u0111\u011d\5$\23\2\u0112\u0113\7\b\2\2\u0113")
+        buf.write("\u0118\5\60\31\2\u0114\u0115\7\7\2\2\u0115\u0117\5\60")
+        buf.write("\31\2\u0116\u0114\3\2\2\2\u0117\u011a\3\2\2\2\u0118\u0116")
+        buf.write("\3\2\2\2\u0118\u0119\3\2\2\2\u0119\u011b\3\2\2\2\u011a")
+        buf.write("\u0118\3\2\2\2\u011b\u011c\7\t\2\2\u011c\u011e\3\2\2\2")
+        buf.write("\u011d\u0112\3\2\2\2\u011d\u011e\3\2\2\2\u011e\33\3\2")
+        buf.write("\2\2\u011f\u0120\7\30\2\2\u0120\u0122\5$\23\2\u0121\u0123")
+        buf.write("\5 \21\2\u0122\u0121\3\2\2\2\u0122\u0123\3\2\2\2\u0123")
+        buf.write("\u0124\3\2\2\2\u0124\u0125\7\31\2\2\u0125\u0126\5\24\13")
+        buf.write("\2\u0126\35\3\2\2\2\u0127\u0128\t\6\2\2\u0128\37\3\2\2")
+        buf.write("\2\u0129\u012a\7\b\2\2\u012a\u012f\5\"\22\2\u012b\u012c")
+        buf.write("\7\7\2\2\u012c\u012e\5\"\22\2\u012d\u012b\3\2\2\2\u012e")
+        buf.write("\u0131\3\2\2\2\u012f\u012d\3\2\2\2\u012f\u0130\3\2\2\2")
+        buf.write("\u0130\u0132\3\2\2\2\u0131\u012f\3\2\2\2\u0132\u0133\7")
+        buf.write("\t\2\2\u0133!\3\2\2\2\u0134\u013b\7\34\2\2\u0135\u0138")
+        buf.write("\5\n\6\2\u0136\u0137\7\35\2\2\u0137\u0139\5\60\31\2\u0138")
+        buf.write("\u0136\3\2\2\2\u0138\u0139\3\2\2\2\u0139\u013b\3\2\2\2")
+        buf.write("\u013a\u0134\3\2\2\2\u013a\u0135\3\2\2\2\u013b#\3\2\2")
+        buf.write("\2\u013c\u013d\7\60\2\2\u013d%\3\2\2\2\u013e\u0149\5(")
+        buf.write("\25\2\u013f\u0140\5*\26\2\u0140\u0141\7\7\2\2\u0141\u0143")
+        buf.write("\3\2\2\2\u0142\u013f\3\2\2\2\u0143\u0146\3\2\2\2\u0144")
+        buf.write("\u0142\3\2\2\2\u0144\u0145\3\2\2\2\u0145\u0147\3\2\2\2")
+        buf.write("\u0146\u0144\3\2\2\2\u0147\u0149\5,\27\2\u0148\u013e\3")
+        buf.write("\2\2\2\u0148\u0144\3\2\2\2\u0149\'\3\2\2\2\u014a\u014f")
+        buf.write("\5*\26\2\u014b\u014c\7\7\2\2\u014c\u014e\5*\26\2\u014d")
+        buf.write("\u014b\3\2\2\2\u014e\u0151\3\2\2\2\u014f\u014d\3\2\2\2")
+        buf.write("\u014f\u0150\3\2\2\2\u0150\u0153\3\2\2\2\u0151\u014f\3")
+        buf.write("\2\2\2\u0152\u014a\3\2\2\2\u0152\u0153\3\2\2\2\u0153)")
+        buf.write("\3\2\2\2\u0154\u0157\5\n\6\2\u0155\u0156\7\35\2\2\u0156")
+        buf.write("\u0158\5\60\31\2\u0157\u0155\3\2\2\2\u0157\u0158\3\2\2")
+        buf.write("\2\u0158+\3\2\2\2\u0159\u015e\5.\30\2\u015a\u015b\7\7")
+        buf.write("\2\2\u015b\u015d\5.\30\2\u015c\u015a\3\2\2\2\u015d\u0160")
+        buf.write("\3\2\2\2\u015e\u015c\3\2\2\2\u015e\u015f\3\2\2\2\u015f")
+        buf.write("-\3\2\2\2\u0160\u015e\3\2\2\2\u0161\u0162\7\61\2\2\u0162")
+        buf.write("\u0163\7\21\2\2\u0163\u0164\5\24\13\2\u0164/\3\2\2\2\u0165")
+        buf.write("\u0166\7\b\2\2\u0166\u0194\7\t\2\2\u0167\u0168\7\b\2\2")
+        buf.write("\u0168\u0169\5\60\31\2\u0169\u016a\7\7\2\2\u016a\u016b")
+        buf.write("\7\t\2\2\u016b\u0194\3\2\2\2\u016c\u016d\7\b\2\2\u016d")
+        buf.write("\u0170\5\60\31\2\u016e\u016f\7\7\2\2\u016f\u0171\5\60")
+        buf.write("\31\2\u0170\u016e\3\2\2\2\u0171\u0172\3\2\2\2\u0172\u0170")
+        buf.write("\3\2\2\2\u0172\u0173\3\2\2\2\u0173\u0174\3\2\2\2\u0174")
+        buf.write("\u0175\7\t\2\2\u0175\u0194\3\2\2\2\u0176\u0177\5\f\7\2")
+        buf.write("\u0177\u0178\5\62\32\2\u0178\u0194\3\2\2\2\u0179\u0194")
+        buf.write("\5\f\7\2\u017a\u017b\7\36\2\2\u017b\u017c\7\f\2\2\u017c")
+        buf.write("\u017d\5\64\33\2\u017d\u017e\7\7\2\2\u017e\u017f\5\60")
+        buf.write("\31\2\u017f\u0180\7\r\2\2\u0180\u0194\3\2\2\2\u0181\u0183")
+        buf.write("\7\24\2\2\u0182\u0184\5\62\32\2\u0183\u0182\3\2\2\2\u0183")
+        buf.write("\u0184\3\2\2\2\u0184\u0185\3\2\2\2\u0185\u018e\7\b\2\2")
+        buf.write("\u0186\u018b\5\60\31\2\u0187\u0188\7\7\2\2\u0188\u018a")
+        buf.write("\5\60\31\2\u0189\u0187\3\2\2\2\u018a\u018d\3\2\2\2\u018b")
+        buf.write("\u0189\3\2\2\2\u018b\u018c\3\2\2\2\u018c\u018f\3\2\2\2")
+        buf.write("\u018d\u018b\3\2\2\2\u018e\u0186\3\2\2\2\u018e\u018f\3")
+        buf.write("\2\2\2\u018f\u0190\3\2\2\2\u0190\u0191\7\t\2\2\u0191\u0192")
+        buf.write("\7\25\2\2\u0192\u0194\5\60\31\2\u0193\u0165\3\2\2\2\u0193")
+        buf.write("\u0167\3\2\2\2\u0193\u016c\3\2\2\2\u0193\u0176\3\2\2\2")
+        buf.write("\u0193\u0179\3\2\2\2\u0193\u017a\3\2\2\2\u0193\u0181\3")
+        buf.write("\2\2\2\u0194\61\3\2\2\2\u0195\u0196\7\f\2\2\u0196\u019b")
+        buf.write("\5\f\7\2\u0197\u0198\7\7\2\2\u0198\u019a\5\f\7\2\u0199")
+        buf.write("\u0197\3\2\2\2\u019a\u019d\3\2\2\2\u019b\u0199\3\2\2\2")
+        buf.write("\u019b\u019c\3\2\2\2\u019c\u019e\3\2\2\2\u019d\u019b\3")
+        buf.write("\2\2\2\u019e\u019f\7\r\2\2\u019f\63\3\2\2\2\u01a0\u01a1")
+        buf.write("\7\b\2\2\u01a1\u01a4\58\35\2\u01a2\u01a3\7\7\2\2\u01a3")
+        buf.write("\u01a5\58\35\2\u01a4\u01a2\3\2\2\2\u01a5\u01a6\3\2\2\2")
+        buf.write("\u01a6\u01a4\3\2\2\2\u01a6\u01a7\3\2\2\2\u01a7\u01a8\3")
+        buf.write("\2\2\2\u01a8\u01a9\7\t\2\2\u01a9\u01ae\3\2\2\2\u01aa\u01ab")
+        buf.write("\7\b\2\2\u01ab\u01ae\7\t\2\2\u01ac\u01ae\58\35\2\u01ad")
+        buf.write("\u01a0\3\2\2\2\u01ad\u01aa\3\2\2\2\u01ad\u01ac\3\2\2\2")
+        buf.write("\u01ae\65\3\2\2\2\u01af\u01b0\7\37\2\2\u01b0\u01b1\7\f")
+        buf.write("\2\2\u01b1\u01b2\7\61\2\2\u01b2\u01b3\7\r\2\2\u01b3\u01b4")
+        buf.write("\7\f\2\2\u01b4\u01b5\7\63\2\2\u01b5\u01b6\7\r\2\2\u01b6")
+        buf.write("\67\3\2\2\2\u01b7\u01be\5\66\34\2\u01b8\u01b9\7\b\2\2")
+        buf.write("\u01b9\u01ba\58\35\2\u01ba\u01bb\7\t\2\2\u01bb\u01be\3")
+        buf.write("\2\2\2\u01bc\u01be\7\63\2\2\u01bd\u01b7\3\2\2\2\u01bd")
+        buf.write("\u01b8\3\2\2\2\u01bd\u01bc\3\2\2\2\u01be9\3\2\2\2\u01bf")
+        buf.write("\u01c0\7\n\2\2\u01c0\u01c1\5\24\13\2\u01c1\u01c2\7\13")
+        buf.write("\2\2\u01c2;\3\2\2\2\u01c3\u01c7\7\62\2\2\u01c4\u01c7\7")
+        buf.write("\63\2\2\u01c5\u01c7\7/\2\2\u01c6\u01c3\3\2\2\2\u01c6\u01c4")
+        buf.write("\3\2\2\2\u01c6\u01c5\3\2\2\2\u01c7=\3\2\2\2\u01c8\u01ce")
+        buf.write("\5\6\4\2\u01c9\u01ce\5\b\5\2\u01ca\u01ce\5\n\6\2\u01cb")
+        buf.write("\u01ce\5\60\31\2\u01cc\u01ce\5\16\b\2\u01cd\u01c8\3\2")
+        buf.write("\2\2\u01cd\u01c9\3\2\2\2\u01cd\u01ca\3\2\2\2\u01cd\u01cb")
+        buf.write("\3\2\2\2\u01cd\u01cc\3\2\2\2\u01ce?\3\2\2\2\60FJMVakn")
+        buf.write("vz\u0095\u009f\u00a2\u00b5\u00ca\u00e3\u00e5\u00ea\u00f1")
+        buf.write("\u00f8\u00ff\u0106\u010c\u010e\u0118\u011d\u0122\u012f")
+        buf.write("\u0138\u013a\u0144\u0148\u014f\u0152\u0157\u015e\u0172")
+        buf.write("\u0183\u018b\u018e\u0193\u019b\u01a6\u01ad\u01bd\u01c6")
+        buf.write("\u01cd")
         return buf.getvalue()
 
 
@@ -236,14 +247,14 @@ class RelayParser ( Parser ):
 
     sharedContextCache = PredictionContextCache()
 
-    literalNames = [ "<INVALID>", "'@'", "'%'", "','", "'('", "')'", "'{'", 
-                     "'}'", "'['", "']'", "'if'", "'else'", "'.'", "'let'", 
-                     "'='", "';'", "';;'", "'fn'", "'->'", "'def'", "'type'", 
-                     "'|'", "'=>'", "'match'", "'match?'", "'_'", "':'", 
-                     "'Tensor'", "'meta'", "'v0.0.3'", "<INVALID>", "<INVALID>", 
-                     "<INVALID>", "<INVALID>", "'*'", "'/'", "'+'", "'-'", 
-                     "'<'", "'>'", "'<='", "'>='", "'=='", "'!='", "<INVALID>", 
-                     "<INVALID>", "<INVALID>", "'int32'" ]
+    literalNames = [ "<INVALID>", "'int32'", "'.'", "'@'", "'%'", "','", 
+                     "'('", "')'", "'{'", "'}'", "'['", "']'", "'if'", "'else'", 
+                     "'let'", "'='", "';'", "';;'", "'fn'", "'->'", "'def'", 
+                     "'type'", "'|'", "'=>'", "'match'", "'match?'", "'_'", 
+                     "':'", "'Tensor'", "'meta'", "'v0.0.3'", "<INVALID>", 
+                     "<INVALID>", "<INVALID>", "<INVALID>", "'*'", "'/'", 
+                     "'+'", "'-'", "'<'", "'>'", "'<='", "'>='", "'=='", 
+                     "'!='" ]
 
     symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
@@ -252,48 +263,50 @@ class RelayParser ( Parser ):
                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
-                      "<INVALID>", "SEMVER", "COMMENT", "WS", "LINE_COMMENT", 
-                      "QUOTED_STRING", "MUL", "DIV", "ADD", "SUB", "LT", 
-                      "GT", "LE", "GE", "EQ", "NE", "BOOL_LIT", "CNAME", 
-                      "FLOAT", "BASE_TYPE", "NAT", "METADATA" ]
-
-    RULE_prog = 0
-    RULE_opIdent = 1
-    RULE_globalVar = 2
-    RULE_localVar = 3
-    RULE_typeIdent = 4
-    RULE_graphVar = 5
-    RULE_exprList = 6
-    RULE_callList = 7
-    RULE_expr = 8
-    RULE_func = 9
-    RULE_defn = 10
-    RULE_adtConstructor = 11
-    RULE_matchClause = 12
-    RULE_matchType = 13
-    RULE_patternList = 14
-    RULE_pattern = 15
-    RULE_constructorName = 16
-    RULE_argList = 17
-    RULE_varList = 18
-    RULE_var = 19
-    RULE_attrSeq = 20
-    RULE_attr = 21
-    RULE_typeExpr = 22
-    RULE_typeParamList = 23
-    RULE_shapeList = 24
-    RULE_meta = 25
-    RULE_shape = 26
-    RULE_body = 27
-    RULE_scalar = 28
-    RULE_ident = 29
-
-    ruleNames =  [ "prog", "opIdent", "globalVar", "localVar", "typeIdent", 
-                   "graphVar", "exprList", "callList", "expr", "func", "defn", 
-                   "adtConstructor", "matchClause", "matchType", "patternList", 
-                   "pattern", "constructorName", "argList", "varList", "var", 
-                   "attrSeq", "attr", "typeExpr", "typeParamList", "shapeList", 
-                   "meta", "shape", "body", "scalar", "ident" ]
+                      "<INVALID>", "<INVALID>", "SEMVER", "COMMENT", "WS", 
+                      "LINE_COMMENT", "QUOTED_STRING", "MUL", "DIV", "ADD", 
+                      "SUB", "LT", "GT", "LE", "GE", "EQ", "NE", "BOOL_LIT", 
+                      "START_UPPER_CNAME", "START_LOWER_CNAME", "FLOAT", 
+                      "NAT", "METADATA" ]
+
+    RULE_baseType = 0
+    RULE_prog = 1
+    RULE_opIdent = 2
+    RULE_globalVar = 3
+    RULE_localVar = 4
+    RULE_typeIdent = 5
+    RULE_graphVar = 6
+    RULE_exprList = 7
+    RULE_callList = 8
+    RULE_expr = 9
+    RULE_func = 10
+    RULE_defn = 11
+    RULE_adtConstructor = 12
+    RULE_matchClause = 13
+    RULE_matchType = 14
+    RULE_patternList = 15
+    RULE_pattern = 16
+    RULE_constructorName = 17
+    RULE_argList = 18
+    RULE_varList = 19
+    RULE_var = 20
+    RULE_attrSeq = 21
+    RULE_attr = 22
+    RULE_typeExpr = 23
+    RULE_typeParamList = 24
+    RULE_shapeList = 25
+    RULE_meta = 26
+    RULE_shape = 27
+    RULE_body = 28
+    RULE_scalar = 29
+    RULE_ident = 30
+
+    ruleNames =  [ "baseType", "prog", "opIdent", "globalVar", "localVar", 
+                   "typeIdent", "graphVar", "exprList", "callList", "expr", 
+                   "func", "defn", "adtConstructor", "matchClause", "matchType", 
+                   "patternList", "pattern", "constructorName", "argList", 
+                   "varList", "var", "attrSeq", "attr", "typeExpr", "typeParamList", 
+                   "shapeList", "meta", "shape", "body", "scalar", "ident" ]
 
     EOF = Token.EOF
     T__0=1
@@ -324,27 +337,28 @@ class RelayParser ( Parser ):
     T__25=26
     T__26=27
     T__27=28
-    SEMVER=29
-    COMMENT=30
-    WS=31
-    LINE_COMMENT=32
-    QUOTED_STRING=33
-    MUL=34
-    DIV=35
-    ADD=36
-    SUB=37
-    LT=38
-    GT=39
-    LE=40
-    GE=41
-    EQ=42
-    NE=43
-    BOOL_LIT=44
-    CNAME=45
-    FLOAT=46
-    BASE_TYPE=47
-    NAT=48
-    METADATA=49
+    T__28=29
+    SEMVER=30
+    COMMENT=31
+    WS=32
+    LINE_COMMENT=33
+    QUOTED_STRING=34
+    MUL=35
+    DIV=36
+    ADD=37
+    SUB=38
+    LT=39
+    GT=40
+    LE=41
+    GE=42
+    EQ=43
+    NE=44
+    BOOL_LIT=45
+    START_UPPER_CNAME=46
+    START_LOWER_CNAME=47
+    FLOAT=48
+    NAT=49
+    METADATA=50
 
     def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
         super().__init__(input, output)
@@ -355,6 +369,42 @@ def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
 
 
 
+    class BaseTypeContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+
+        def getRuleIndex(self):
+            return RelayParser.RULE_baseType
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitBaseType" ):
+                return visitor.visitBaseType(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def baseType(self):
+
+        localctx = RelayParser.BaseTypeContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 0, self.RULE_baseType)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 62
+            self.match(RelayParser.T__0)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
     class ProgContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
@@ -396,43 +446,43 @@ def accept(self, visitor:ParseTreeVisitor):
     def prog(self):
 
         localctx = RelayParser.ProgContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 0, self.RULE_prog)
+        self.enterRule(localctx, 2, self.RULE_prog)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 60
+            self.state = 64
             self.match(RelayParser.SEMVER)
-            self.state = 68
+            self.state = 72
             self._errHandler.sync(self)
             token = self._input.LA(1)
-            if token in [RelayParser.EOF, RelayParser.T__18, RelayParser.T__19, RelayParser.METADATA]:
-                self.state = 64
+            if token in [RelayParser.EOF, RelayParser.T__19, RelayParser.T__20, RelayParser.METADATA]:
+                self.state = 68
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                while _la==RelayParser.T__18 or _la==RelayParser.T__19:
-                    self.state = 61
+                while _la==RelayParser.T__19 or _la==RelayParser.T__20:
+                    self.state = 65
                     self.defn()
-                    self.state = 66
+                    self.state = 70
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
                 pass
-            elif token in [RelayParser.T__0, RelayParser.T__1, RelayParser.T__3, RelayParser.T__5, RelayParser.T__7, RelayParser.T__9, RelayParser.T__12, RelayParser.T__16, RelayParser.T__22, RelayParser.T__23, RelayParser.T__26, RelayParser.T__27, RelayParser.QUOTED_STRING, RelayParser.SUB, RelayParser.BOOL_LIT, RelayParser.CNAME, RelayParser.FLOAT, RelayParser.NAT]:
-                self.state = 67
+            elif token in [RelayParser.T__0, RelayParser.T__2, RelayParser.T__3, RelayParser.T__5, RelayParser.T__7, RelayParser.T__9, RelayParser.T__11, RelayParser.T__13, RelayParser.T__17, RelayParser.T__23, RelayParser.T__24, RelayParser.T__27, RelayParser.T__28, RelayParser.QUOTED_STRING, RelayParser.SUB, RelayParser.BOOL_LIT, RelayParser.START_UPPER_CNAME, RelayParser.START_LOWER_CNAME, RelayParser.FLOAT, RelayParser.NAT]:
+                self.state = 71
                 self.expr(0)
                 pass
             else:
                 raise NoViableAltException(self)
 
-            self.state = 71
+            self.state = 75
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==RelayParser.METADATA:
-                self.state = 70
+                self.state = 74
                 self.match(RelayParser.METADATA)
 
 
-            self.state = 73
+            self.state = 77
             self.match(RelayParser.EOF)
         except RecognitionException as re:
             localctx.exception = re
@@ -449,8 +499,11 @@ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
             super().__init__(parent, invokingState)
             self.parser = parser
 
-        def CNAME(self):
-            return self.getToken(RelayParser.CNAME, 0)
+        def START_LOWER_CNAME(self, i:int=None):
+            if i is None:
+                return self.getTokens(RelayParser.START_LOWER_CNAME)
+            else:
+                return self.getToken(RelayParser.START_LOWER_CNAME, i)
 
         def getRuleIndex(self):
             return RelayParser.RULE_opIdent
@@ -467,11 +520,24 @@ def accept(self, visitor:ParseTreeVisitor):
     def opIdent(self):
 
         localctx = RelayParser.OpIdentContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 2, self.RULE_opIdent)
+        self.enterRule(localctx, 4, self.RULE_opIdent)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 75
-            self.match(RelayParser.CNAME)
+            self.state = 79
+            self.match(RelayParser.START_LOWER_CNAME)
+            self.state = 84
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,3,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    self.state = 80
+                    self.match(RelayParser.T__1)
+                    self.state = 81
+                    self.match(RelayParser.START_LOWER_CNAME) 
+                self.state = 86
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,3,self._ctx)
+
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -487,8 +553,8 @@ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
             super().__init__(parent, invokingState)
             self.parser = parser
 
-        def CNAME(self):
-            return self.getToken(RelayParser.CNAME, 0)
+        def START_LOWER_CNAME(self):
+            return self.getToken(RelayParser.START_LOWER_CNAME, 0)
 
         def getRuleIndex(self):
             return RelayParser.RULE_globalVar
@@ -505,13 +571,13 @@ def accept(self, visitor:ParseTreeVisitor):
     def globalVar(self):
 
         localctx = RelayParser.GlobalVarContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 4, self.RULE_globalVar)
+        self.enterRule(localctx, 6, self.RULE_globalVar)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 77
-            self.match(RelayParser.T__0)
-            self.state = 78
-            self.match(RelayParser.CNAME)
+            self.state = 87
+            self.match(RelayParser.T__2)
+            self.state = 88
+            self.match(RelayParser.START_LOWER_CNAME)
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -527,8 +593,8 @@ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
             super().__init__(parent, invokingState)
             self.parser = parser
 
-        def CNAME(self):
-            return self.getToken(RelayParser.CNAME, 0)
+        def START_LOWER_CNAME(self):
+            return self.getToken(RelayParser.START_LOWER_CNAME, 0)
 
         def getRuleIndex(self):
             return RelayParser.RULE_localVar
@@ -545,13 +611,13 @@ def accept(self, visitor:ParseTreeVisitor):
     def localVar(self):
 
         localctx = RelayParser.LocalVarContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 6, self.RULE_localVar)
+        self.enterRule(localctx, 8, self.RULE_localVar)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 80
-            self.match(RelayParser.T__1)
-            self.state = 81
-            self.match(RelayParser.CNAME)
+            self.state = 90
+            self.match(RelayParser.T__3)
+            self.state = 91
+            self.match(RelayParser.START_LOWER_CNAME)
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -567,8 +633,12 @@ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
             super().__init__(parent, invokingState)
             self.parser = parser
 
-        def CNAME(self):
-            return self.getToken(RelayParser.CNAME, 0)
+        def baseType(self):
+            return self.getTypedRuleContext(RelayParser.BaseTypeContext,0)
+
+
+        def START_UPPER_CNAME(self):
+            return self.getToken(RelayParser.START_UPPER_CNAME, 0)
 
         def getRuleIndex(self):
             return RelayParser.RULE_typeIdent
@@ -585,11 +655,23 @@ def accept(self, visitor:ParseTreeVisitor):
     def typeIdent(self):
 
         localctx = RelayParser.TypeIdentContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 8, self.RULE_typeIdent)
+        self.enterRule(localctx, 10, self.RULE_typeIdent)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 83
-            self.match(RelayParser.CNAME)
+            self.state = 95
+            self._errHandler.sync(self)
+            token = self._input.LA(1)
+            if token in [RelayParser.T__0]:
+                self.state = 93
+                self.baseType()
+                pass
+            elif token in [RelayParser.START_UPPER_CNAME]:
+                self.state = 94
+                self.match(RelayParser.START_UPPER_CNAME)
+                pass
+            else:
+                raise NoViableAltException(self)
+
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -623,12 +705,12 @@ def accept(self, visitor:ParseTreeVisitor):
     def graphVar(self):
 
         localctx = RelayParser.GraphVarContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 10, self.RULE_graphVar)
+        self.enterRule(localctx, 12, self.RULE_graphVar)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 85
-            self.match(RelayParser.T__1)
-            self.state = 86
+            self.state = 97
+            self.match(RelayParser.T__3)
+            self.state = 98
             self.match(RelayParser.NAT)
         except RecognitionException as re:
             localctx.exception = re
@@ -667,25 +749,25 @@ def accept(self, visitor:ParseTreeVisitor):
     def exprList(self):
 
         localctx = RelayParser.ExprListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 12, self.RULE_exprList)
+        self.enterRule(localctx, 14, self.RULE_exprList)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 96
+            self.state = 108
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__0) | (1 << RelayParser.T__1) | (1 << RelayParser.T__3) | (1 << RelayParser.T__5) | (1 << RelayParser.T__7) | (1 << RelayParser.T__9) | (1 << RelayParser.T__12) | (1 << RelayParser.T__16) | (1 << RelayParser.T__22) | (1 << RelayParser.T__23) | (1 << RelayParser.T__26) | (1 << RelayParser.T__27) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
-                self.state = 88
+            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__0) | (1 << RelayParser.T__2) | (1 << RelayParser.T__3) | (1 << RelayParser.T__5) | (1 << RelayParser.T__7) | (1 << RelayParser.T__9) | (1 << RelayParser.T__11) | (1 << RelayParser.T__13) | (1 << RelayParser.T__17) | (1 << RelayParser.T__23) | (1 << RelayParser.T__24) | (1 << RelayParser.T__27) | (1 << RelayParser.T__28) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.START_UPPER_CNAME) | (1 << RelayParser.START_LOWER_CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
+                self.state = 100
                 self.expr(0)
-                self.state = 93
+                self.state = 105
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                while _la==RelayParser.T__2:
-                    self.state = 89
-                    self.match(RelayParser.T__2)
-                    self.state = 90
+                while _la==RelayParser.T__4:
+                    self.state = 101
+                    self.match(RelayParser.T__4)
+                    self.state = 102
                     self.expr(0)
-                    self.state = 95
+                    self.state = 107
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
@@ -760,35 +842,35 @@ def accept(self, visitor:ParseTreeVisitor):
     def callList(self):
 
         localctx = RelayParser.CallListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 14, self.RULE_callList)
+        self.enterRule(localctx, 16, self.RULE_callList)
         try:
-            self.state = 108
+            self.state = 120
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,6,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,8,self._ctx)
             if la_ == 1:
                 localctx = RelayParser.CallNoAttrContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 98
+                self.state = 110
                 self.exprList()
                 pass
 
             elif la_ == 2:
                 localctx = RelayParser.CallWithAttrContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 104
+                self.state = 116
                 self._errHandler.sync(self)
-                _alt = self._interp.adaptivePredict(self._input,5,self._ctx)
+                _alt = self._interp.adaptivePredict(self._input,7,self._ctx)
                 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                     if _alt==1:
-                        self.state = 99
+                        self.state = 111
                         self.expr(0)
-                        self.state = 100
-                        self.match(RelayParser.T__2) 
-                    self.state = 106
+                        self.state = 112
+                        self.match(RelayParser.T__4) 
+                    self.state = 118
                     self._errHandler.sync(self)
-                    _alt = self._interp.adaptivePredict(self._input,5,self._ctx)
+                    _alt = self._interp.adaptivePredict(self._input,7,self._ctx)
 
-                self.state = 107
+                self.state = 119
                 self.attrSeq()
                 pass
 
@@ -1158,46 +1240,46 @@ def expr(self, _p:int=0):
         _parentState = self.state
         localctx = RelayParser.ExprContext(self, self._ctx, _parentState)
         _prevctx = localctx
-        _startState = 16
-        self.enterRecursionRule(localctx, 16, self.RULE_expr, _p)
+        _startState = 18
+        self.enterRecursionRule(localctx, 18, self.RULE_expr, _p)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 188
+            self.state = 200
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,11,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,13,self._ctx)
             if la_ == 1:
                 localctx = RelayParser.ParenContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
 
-                self.state = 111
-                self.match(RelayParser.T__3)
-                self.state = 112
+                self.state = 123
+                self.match(RelayParser.T__5)
+                self.state = 124
                 self.expr(0)
-                self.state = 113
-                self.match(RelayParser.T__4)
+                self.state = 125
+                self.match(RelayParser.T__6)
                 pass
 
             elif la_ == 2:
                 localctx = RelayParser.ParenContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 115
-                self.match(RelayParser.T__5)
-                self.state = 116
+                self.state = 127
+                self.match(RelayParser.T__7)
+                self.state = 128
                 self.expr(0)
-                self.state = 117
-                self.match(RelayParser.T__6)
+                self.state = 129
+                self.match(RelayParser.T__8)
                 pass
 
             elif la_ == 3:
                 localctx = RelayParser.NegContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 119
+                self.state = 131
                 self.match(RelayParser.SUB)
-                self.state = 120
+                self.state = 132
                 self.expr(20)
                 pass
 
@@ -1205,7 +1287,7 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.FuncExprContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 121
+                self.state = 133
                 self.func()
                 pass
 
@@ -1213,99 +1295,99 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.TupleContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 122
-                self.match(RelayParser.T__3)
-                self.state = 123
-                self.match(RelayParser.T__4)
+                self.state = 134
+                self.match(RelayParser.T__5)
+                self.state = 135
+                self.match(RelayParser.T__6)
                 pass
 
             elif la_ == 6:
                 localctx = RelayParser.TupleContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 124
-                self.match(RelayParser.T__3)
-                self.state = 125
+                self.state = 136
+                self.match(RelayParser.T__5)
+                self.state = 137
                 self.expr(0)
-                self.state = 126
-                self.match(RelayParser.T__2)
-                self.state = 127
+                self.state = 138
                 self.match(RelayParser.T__4)
+                self.state = 139
+                self.match(RelayParser.T__6)
                 pass
 
             elif la_ == 7:
                 localctx = RelayParser.TupleContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 129
-                self.match(RelayParser.T__3)
-                self.state = 130
+                self.state = 141
+                self.match(RelayParser.T__5)
+                self.state = 142
                 self.expr(0)
-                self.state = 133 
+                self.state = 145 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while True:
-                    self.state = 131
-                    self.match(RelayParser.T__2)
-                    self.state = 132
+                    self.state = 143
+                    self.match(RelayParser.T__4)
+                    self.state = 144
                     self.expr(0)
-                    self.state = 135 
+                    self.state = 147 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
-                    if not (_la==RelayParser.T__2):
+                    if not (_la==RelayParser.T__4):
                         break
 
-                self.state = 137
-                self.match(RelayParser.T__4)
+                self.state = 149
+                self.match(RelayParser.T__6)
                 pass
 
             elif la_ == 8:
                 localctx = RelayParser.TensorContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 139
-                self.match(RelayParser.T__7)
-                self.state = 148
+                self.state = 151
+                self.match(RelayParser.T__9)
+                self.state = 160
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__0) | (1 << RelayParser.T__1) | (1 << RelayParser.T__3) | (1 << RelayParser.T__5) | (1 << RelayParser.T__7) | (1 << RelayParser.T__9) | (1 << RelayParser.T__12) | (1 << RelayParser.T__16) | (1 << RelayParser.T__22) | (1 << RelayParser.T__23) | (1 << RelayParser.T__26) | (1 << RelayParser.T__27) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
-                    self.state = 140
+                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__0) | (1 << RelayParser.T__2) | (1 << RelayParser.T__3) | (1 << RelayParser.T__5) | (1 << RelayParser.T__7) | (1 << RelayParser.T__9) | (1 << RelayParser.T__11) | (1 << RelayParser.T__13) | (1 << RelayParser.T__17) | (1 << RelayParser.T__23) | (1 << RelayParser.T__24) | (1 << RelayParser.T__27) | (1 << RelayParser.T__28) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.START_UPPER_CNAME) | (1 << RelayParser.START_LOWER_CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
+                    self.state = 152
                     self.expr(0)
-                    self.state = 145
+                    self.state = 157
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
-                    while _la==RelayParser.T__2:
-                        self.state = 141
-                        self.match(RelayParser.T__2)
-                        self.state = 142
+                    while _la==RelayParser.T__4:
+                        self.state = 153
+                        self.match(RelayParser.T__4)
+                        self.state = 154
                         self.expr(0)
-                        self.state = 147
+                        self.state = 159
                         self._errHandler.sync(self)
                         _la = self._input.LA(1)
 
 
 
-                self.state = 150
-                self.match(RelayParser.T__8)
+                self.state = 162
+                self.match(RelayParser.T__10)
                 pass
 
             elif la_ == 9:
                 localctx = RelayParser.IfElseContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 151
-                self.match(RelayParser.T__9)
-                self.state = 152
-                self.match(RelayParser.T__3)
-                self.state = 153
+                self.state = 163
+                self.match(RelayParser.T__11)
+                self.state = 164
+                self.match(RelayParser.T__5)
+                self.state = 165
                 self.expr(0)
-                self.state = 154
-                self.match(RelayParser.T__4)
-                self.state = 155
+                self.state = 166
+                self.match(RelayParser.T__6)
+                self.state = 167
                 self.body()
-                self.state = 156
-                self.match(RelayParser.T__10)
-                self.state = 157
+                self.state = 168
+                self.match(RelayParser.T__12)
+                self.state = 169
                 self.body()
                 pass
 
@@ -1313,47 +1395,47 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.MatchContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 159
+                self.state = 171
                 self.matchType()
-                self.state = 160
-                self.match(RelayParser.T__3)
-                self.state = 161
-                self.expr(0)
-                self.state = 162
-                self.match(RelayParser.T__4)
-                self.state = 163
+                self.state = 172
                 self.match(RelayParser.T__5)
-                self.state = 165 
+                self.state = 173
+                self.expr(0)
+                self.state = 174
+                self.match(RelayParser.T__6)
+                self.state = 175
+                self.match(RelayParser.T__7)
+                self.state = 177 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while True:
-                    self.state = 164
+                    self.state = 176
                     self.matchClause()
-                    self.state = 167 
+                    self.state = 179 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
-                    if not (_la==RelayParser.T__20):
+                    if not (_la==RelayParser.T__21):
                         break
 
-                self.state = 169
-                self.match(RelayParser.T__6)
+                self.state = 181
+                self.match(RelayParser.T__8)
                 pass
 
             elif la_ == 11:
                 localctx = RelayParser.LetContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 171
-                self.match(RelayParser.T__12)
-                self.state = 172
-                self.var()
-                self.state = 173
+                self.state = 183
                 self.match(RelayParser.T__13)
-                self.state = 174
-                self.expr(0)
-                self.state = 175
+                self.state = 184
+                self.var()
+                self.state = 185
                 self.match(RelayParser.T__14)
-                self.state = 176
+                self.state = 186
+                self.expr(0)
+                self.state = 187
+                self.match(RelayParser.T__15)
+                self.state = 188
                 self.expr(7)
                 pass
 
@@ -1361,15 +1443,15 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.GraphContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 178
+                self.state = 190
                 self.graphVar()
-                self.state = 179
-                self.match(RelayParser.T__13)
-                self.state = 180
-                self.expr(0)
-                self.state = 181
+                self.state = 191
                 self.match(RelayParser.T__14)
-                self.state = 182
+                self.state = 192
+                self.expr(0)
+                self.state = 193
+                self.match(RelayParser.T__15)
+                self.state = 194
                 self.expr(5)
                 pass
 
@@ -1377,7 +1459,7 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.IdentExprContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 184
+                self.state = 196
                 self.ident()
                 pass
 
@@ -1385,7 +1467,7 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.ScalarExprContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 185
+                self.state = 197
                 self.scalar()
                 pass
 
@@ -1393,7 +1475,7 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.MetaExprContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 186
+                self.state = 198
                 self.meta()
                 pass
 
@@ -1401,31 +1483,31 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.StringExprContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 187
+                self.state = 199
                 self.match(RelayParser.QUOTED_STRING)
                 pass
 
 
             self._ctx.stop = self._input.LT(-1)
-            self.state = 215
+            self.state = 227
             self._errHandler.sync(self)
-            _alt = self._interp.adaptivePredict(self._input,13,self._ctx)
+            _alt = self._interp.adaptivePredict(self._input,15,self._ctx)
             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                 if _alt==1:
                     if self._parseListeners is not None:
                         self.triggerExitRuleEvent()
                     _prevctx = localctx
-                    self.state = 213
+                    self.state = 225
                     self._errHandler.sync(self)
-                    la_ = self._interp.adaptivePredict(self._input,12,self._ctx)
+                    la_ = self._interp.adaptivePredict(self._input,14,self._ctx)
                     if la_ == 1:
                         localctx = RelayParser.BinOpContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 190
+                        self.state = 202
                         if not self.precpred(self._ctx, 19):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 19)")
-                        self.state = 191
+                        self.state = 203
                         localctx.op = self._input.LT(1)
                         _la = self._input.LA(1)
                         if not(_la==RelayParser.MUL or _la==RelayParser.DIV):
@@ -1433,18 +1515,18 @@ def expr(self, _p:int=0):
                         else:
                             self._errHandler.reportMatch(self)
                             self.consume()
-                        self.state = 192
+                        self.state = 204
                         self.expr(20)
                         pass
 
                     elif la_ == 2:
                         localctx = RelayParser.BinOpContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 193
+                        self.state = 205
                         if not self.precpred(self._ctx, 18):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 18)")
-                        self.state = 194
+                        self.state = 206
                         localctx.op = self._input.LT(1)
                         _la = self._input.LA(1)
                         if not(_la==RelayParser.ADD or _la==RelayParser.SUB):
@@ -1452,18 +1534,18 @@ def expr(self, _p:int=0):
                         else:
                             self._errHandler.reportMatch(self)
                             self.consume()
-                        self.state = 195
+                        self.state = 207
                         self.expr(19)
                         pass
 
                     elif la_ == 3:
                         localctx = RelayParser.BinOpContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 196
+                        self.state = 208
                         if not self.precpred(self._ctx, 17):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 17)")
-                        self.state = 197
+                        self.state = 209
                         localctx.op = self._input.LT(1)
                         _la = self._input.LA(1)
                         if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.LT) | (1 << RelayParser.GT) | (1 << RelayParser.LE) | (1 << RelayParser.GE))) != 0)):
@@ -1471,18 +1553,18 @@ def expr(self, _p:int=0):
                         else:
                             self._errHandler.reportMatch(self)
                             self.consume()
-                        self.state = 198
+                        self.state = 210
                         self.expr(18)
                         pass
 
                     elif la_ == 4:
                         localctx = RelayParser.BinOpContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 199
+                        self.state = 211
                         if not self.precpred(self._ctx, 16):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 16)")
-                        self.state = 200
+                        self.state = 212
                         localctx.op = self._input.LT(1)
                         _la = self._input.LA(1)
                         if not(_la==RelayParser.EQ or _la==RelayParser.NE):
@@ -1490,55 +1572,55 @@ def expr(self, _p:int=0):
                         else:
                             self._errHandler.reportMatch(self)
                             self.consume()
-                        self.state = 201
+                        self.state = 213
                         self.expr(17)
                         pass
 
                     elif la_ == 5:
                         localctx = RelayParser.LetContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 202
+                        self.state = 214
                         if not self.precpred(self._ctx, 6):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
-                        self.state = 203
-                        self.match(RelayParser.T__15)
-                        self.state = 204
+                        self.state = 215
+                        self.match(RelayParser.T__16)
+                        self.state = 216
                         self.expr(7)
                         pass
 
                     elif la_ == 6:
                         localctx = RelayParser.CallContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 205
+                        self.state = 217
                         if not self.precpred(self._ctx, 21):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 21)")
-                        self.state = 206
-                        self.match(RelayParser.T__3)
-                        self.state = 207
+                        self.state = 218
+                        self.match(RelayParser.T__5)
+                        self.state = 219
                         self.callList()
-                        self.state = 208
-                        self.match(RelayParser.T__4)
+                        self.state = 220
+                        self.match(RelayParser.T__6)
                         pass
 
                     elif la_ == 7:
                         localctx = RelayParser.ProjectionContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 210
+                        self.state = 222
                         if not self.precpred(self._ctx, 8):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
-                        self.state = 211
-                        self.match(RelayParser.T__11)
-                        self.state = 212
+                        self.state = 223
+                        self.match(RelayParser.T__1)
+                        self.state = 224
                         self.match(RelayParser.NAT)
                         pass
 
              
-                self.state = 217
+                self.state = 229
                 self._errHandler.sync(self)
-                _alt = self._interp.adaptivePredict(self._input,13,self._ctx)
+                _alt = self._interp.adaptivePredict(self._input,15,self._ctx)
 
         except RecognitionException as re:
             localctx.exception = re
@@ -1586,37 +1668,37 @@ def accept(self, visitor:ParseTreeVisitor):
     def func(self):
 
         localctx = RelayParser.FuncContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 18, self.RULE_func)
+        self.enterRule(localctx, 20, self.RULE_func)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 218
-            self.match(RelayParser.T__16)
-            self.state = 220
+            self.state = 230
+            self.match(RelayParser.T__17)
+            self.state = 232
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==RelayParser.T__7:
-                self.state = 219
+            if _la==RelayParser.T__9:
+                self.state = 231
                 self.typeParamList()
 
 
-            self.state = 222
-            self.match(RelayParser.T__3)
-            self.state = 223
+            self.state = 234
+            self.match(RelayParser.T__5)
+            self.state = 235
             self.argList()
-            self.state = 224
-            self.match(RelayParser.T__4)
-            self.state = 227
+            self.state = 236
+            self.match(RelayParser.T__6)
+            self.state = 239
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==RelayParser.T__17:
-                self.state = 225
-                self.match(RelayParser.T__17)
-                self.state = 226
+            if _la==RelayParser.T__18:
+                self.state = 237
+                self.match(RelayParser.T__18)
+                self.state = 238
                 self.typeExpr()
 
 
-            self.state = 229
+            self.state = 241
             self.body()
         except RecognitionException as re:
             localctx.exception = re
@@ -1702,73 +1784,73 @@ def accept(self, visitor:ParseTreeVisitor):
     def defn(self):
 
         localctx = RelayParser.DefnContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 20, self.RULE_defn)
+        self.enterRule(localctx, 22, self.RULE_defn)
         self._la = 0 # Token type
         try:
-            self.state = 256
+            self.state = 268
             self._errHandler.sync(self)
             token = self._input.LA(1)
-            if token in [RelayParser.T__18]:
+            if token in [RelayParser.T__19]:
                 localctx = RelayParser.FuncDefnContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 231
-                self.match(RelayParser.T__18)
-                self.state = 232
+                self.state = 243
+                self.match(RelayParser.T__19)
+                self.state = 244
                 self.globalVar()
-                self.state = 234
+                self.state = 246
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if _la==RelayParser.T__7:
-                    self.state = 233
+                if _la==RelayParser.T__9:
+                    self.state = 245
                     self.typeParamList()
 
 
-                self.state = 236
-                self.match(RelayParser.T__3)
-                self.state = 237
+                self.state = 248
+                self.match(RelayParser.T__5)
+                self.state = 249
                 self.argList()
-                self.state = 238
-                self.match(RelayParser.T__4)
-                self.state = 241
+                self.state = 250
+                self.match(RelayParser.T__6)
+                self.state = 253
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if _la==RelayParser.T__17:
-                    self.state = 239
-                    self.match(RelayParser.T__17)
-                    self.state = 240
+                if _la==RelayParser.T__18:
+                    self.state = 251
+                    self.match(RelayParser.T__18)
+                    self.state = 252
                     self.typeExpr()
 
 
-                self.state = 243
+                self.state = 255
                 self.body()
                 pass
-            elif token in [RelayParser.T__19]:
+            elif token in [RelayParser.T__20]:
                 localctx = RelayParser.AdtDefnContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 245
-                self.match(RelayParser.T__19)
-                self.state = 246
+                self.state = 257
+                self.match(RelayParser.T__20)
+                self.state = 258
                 self.typeIdent()
-                self.state = 248
+                self.state = 260
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if _la==RelayParser.T__7:
-                    self.state = 247
+                if _la==RelayParser.T__9:
+                    self.state = 259
                     self.typeParamList()
 
 
-                self.state = 250
-                self.match(RelayParser.T__13)
-                self.state = 252 
+                self.state = 262
+                self.match(RelayParser.T__14)
+                self.state = 264 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while True:
-                    self.state = 251
+                    self.state = 263
                     self.adtConstructor()
-                    self.state = 254 
+                    self.state = 266 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
-                    if not (_la==RelayParser.T__20):
+                    if not (_la==RelayParser.T__21):
                         break
 
                 pass
@@ -1816,36 +1898,36 @@ def accept(self, visitor:ParseTreeVisitor):
     def adtConstructor(self):
 
         localctx = RelayParser.AdtConstructorContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 22, self.RULE_adtConstructor)
+        self.enterRule(localctx, 24, self.RULE_adtConstructor)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 258
-            self.match(RelayParser.T__20)
-            self.state = 259
-            self.constructorName()
+            self.state = 270
+            self.match(RelayParser.T__21)
             self.state = 271
+            self.constructorName()
+            self.state = 283
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==RelayParser.T__3:
-                self.state = 260
-                self.match(RelayParser.T__3)
-                self.state = 261
+            if _la==RelayParser.T__5:
+                self.state = 272
+                self.match(RelayParser.T__5)
+                self.state = 273
                 self.typeExpr()
-                self.state = 266
+                self.state = 278
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                while _la==RelayParser.T__2:
-                    self.state = 262
-                    self.match(RelayParser.T__2)
-                    self.state = 263
+                while _la==RelayParser.T__4:
+                    self.state = 274
+                    self.match(RelayParser.T__4)
+                    self.state = 275
                     self.typeExpr()
-                    self.state = 268
+                    self.state = 280
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
-                self.state = 269
-                self.match(RelayParser.T__4)
+                self.state = 281
+                self.match(RelayParser.T__6)
 
 
         except RecognitionException as re:
@@ -1890,25 +1972,25 @@ def accept(self, visitor:ParseTreeVisitor):
     def matchClause(self):
 
         localctx = RelayParser.MatchClauseContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 24, self.RULE_matchClause)
+        self.enterRule(localctx, 26, self.RULE_matchClause)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 273
-            self.match(RelayParser.T__20)
-            self.state = 274
+            self.state = 285
+            self.match(RelayParser.T__21)
+            self.state = 286
             self.constructorName()
-            self.state = 276
+            self.state = 288
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==RelayParser.T__3:
-                self.state = 275
+            if _la==RelayParser.T__5:
+                self.state = 287
                 self.patternList()
 
 
-            self.state = 278
-            self.match(RelayParser.T__21)
-            self.state = 279
+            self.state = 290
+            self.match(RelayParser.T__22)
+            self.state = 291
             self.expr(0)
         except RecognitionException as re:
             localctx.exception = re
@@ -1941,13 +2023,13 @@ def accept(self, visitor:ParseTreeVisitor):
     def matchType(self):
 
         localctx = RelayParser.MatchTypeContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 26, self.RULE_matchType)
+        self.enterRule(localctx, 28, self.RULE_matchType)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 281
+            self.state = 293
             _la = self._input.LA(1)
-            if not(_la==RelayParser.T__22 or _la==RelayParser.T__23):
+            if not(_la==RelayParser.T__23 or _la==RelayParser.T__24):
                 self._errHandler.recoverInline(self)
             else:
                 self._errHandler.reportMatch(self)
@@ -1989,28 +2071,28 @@ def accept(self, visitor:ParseTreeVisitor):
     def patternList(self):
 
         localctx = RelayParser.PatternListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 28, self.RULE_patternList)
+        self.enterRule(localctx, 30, self.RULE_patternList)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 283
-            self.match(RelayParser.T__3)
-            self.state = 284
+            self.state = 295
+            self.match(RelayParser.T__5)
+            self.state = 296
             self.pattern()
-            self.state = 289
+            self.state = 301
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            while _la==RelayParser.T__2:
-                self.state = 285
-                self.match(RelayParser.T__2)
-                self.state = 286
+            while _la==RelayParser.T__4:
+                self.state = 297
+                self.match(RelayParser.T__4)
+                self.state = 298
                 self.pattern()
-                self.state = 291
+                self.state = 303
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 292
-            self.match(RelayParser.T__4)
+            self.state = 304
+            self.match(RelayParser.T__6)
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -2030,6 +2112,10 @@ def localVar(self):
             return self.getTypedRuleContext(RelayParser.LocalVarContext,0)
 
 
+        def typeExpr(self):
+            return self.getTypedRuleContext(RelayParser.TypeExprContext,0)
+
+
         def getRuleIndex(self):
             return RelayParser.RULE_pattern
 
@@ -2045,20 +2131,31 @@ def accept(self, visitor:ParseTreeVisitor):
     def pattern(self):
 
         localctx = RelayParser.PatternContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 30, self.RULE_pattern)
+        self.enterRule(localctx, 32, self.RULE_pattern)
+        self._la = 0 # Token type
         try:
-            self.state = 296
+            self.state = 312
             self._errHandler.sync(self)
             token = self._input.LA(1)
-            if token in [RelayParser.T__24]:
+            if token in [RelayParser.T__25]:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 294
-                self.match(RelayParser.T__24)
+                self.state = 306
+                self.match(RelayParser.T__25)
                 pass
-            elif token in [RelayParser.T__1]:
+            elif token in [RelayParser.T__3]:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 295
+                self.state = 307
                 self.localVar()
+                self.state = 310
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                if _la==RelayParser.T__26:
+                    self.state = 308
+                    self.match(RelayParser.T__26)
+                    self.state = 309
+                    self.typeExpr()
+
+
                 pass
             else:
                 raise NoViableAltException(self)
@@ -2078,8 +2175,8 @@ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
             super().__init__(parent, invokingState)
             self.parser = parser
 
-        def CNAME(self):
-            return self.getToken(RelayParser.CNAME, 0)
+        def START_UPPER_CNAME(self):
+            return self.getToken(RelayParser.START_UPPER_CNAME, 0)
 
         def getRuleIndex(self):
             return RelayParser.RULE_constructorName
@@ -2096,11 +2193,11 @@ def accept(self, visitor:ParseTreeVisitor):
     def constructorName(self):
 
         localctx = RelayParser.ConstructorNameContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 32, self.RULE_constructorName)
+        self.enterRule(localctx, 34, self.RULE_constructorName)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 298
-            self.match(RelayParser.CNAME)
+            self.state = 314
+            self.match(RelayParser.START_UPPER_CNAME)
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -2170,35 +2267,35 @@ def accept(self, visitor:ParseTreeVisitor):
     def argList(self):
 
         localctx = RelayParser.ArgListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 34, self.RULE_argList)
+        self.enterRule(localctx, 36, self.RULE_argList)
         self._la = 0 # Token type
         try:
-            self.state = 310
+            self.state = 326
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,27,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,30,self._ctx)
             if la_ == 1:
                 localctx = RelayParser.ArgNoAttrContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 300
+                self.state = 316
                 self.varList()
                 pass
 
             elif la_ == 2:
                 localctx = RelayParser.ArgWithAttrContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 306
+                self.state = 322
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                while _la==RelayParser.T__1:
-                    self.state = 301
+                while _la==RelayParser.T__3:
+                    self.state = 317
                     self.var()
-                    self.state = 302
-                    self.match(RelayParser.T__2)
-                    self.state = 308
+                    self.state = 318
+                    self.match(RelayParser.T__4)
+                    self.state = 324
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
-                self.state = 309
+                self.state = 325
                 self.attrSeq()
                 pass
 
@@ -2240,25 +2337,25 @@ def accept(self, visitor:ParseTreeVisitor):
     def varList(self):
 
         localctx = RelayParser.VarListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 36, self.RULE_varList)
+        self.enterRule(localctx, 38, self.RULE_varList)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 320
+            self.state = 336
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==RelayParser.T__1:
-                self.state = 312
+            if _la==RelayParser.T__3:
+                self.state = 328
                 self.var()
-                self.state = 317
+                self.state = 333
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                while _la==RelayParser.T__2:
-                    self.state = 313
-                    self.match(RelayParser.T__2)
-                    self.state = 314
+                while _la==RelayParser.T__4:
+                    self.state = 329
+                    self.match(RelayParser.T__4)
+                    self.state = 330
                     self.var()
-                    self.state = 319
+                    self.state = 335
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
@@ -2302,19 +2399,19 @@ def accept(self, visitor:ParseTreeVisitor):
     def var(self):
 
         localctx = RelayParser.VarContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 38, self.RULE_var)
+        self.enterRule(localctx, 40, self.RULE_var)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 322
+            self.state = 338
             self.localVar()
-            self.state = 325
+            self.state = 341
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==RelayParser.T__25:
-                self.state = 323
-                self.match(RelayParser.T__25)
-                self.state = 324
+            if _la==RelayParser.T__26:
+                self.state = 339
+                self.match(RelayParser.T__26)
+                self.state = 340
                 self.typeExpr()
 
 
@@ -2355,21 +2452,21 @@ def accept(self, visitor:ParseTreeVisitor):
     def attrSeq(self):
 
         localctx = RelayParser.AttrSeqContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 40, self.RULE_attrSeq)
+        self.enterRule(localctx, 42, self.RULE_attrSeq)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 327
+            self.state = 343
             self.attr()
-            self.state = 332
+            self.state = 348
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            while _la==RelayParser.T__2:
-                self.state = 328
-                self.match(RelayParser.T__2)
-                self.state = 329
+            while _la==RelayParser.T__4:
+                self.state = 344
+                self.match(RelayParser.T__4)
+                self.state = 345
                 self.attr()
-                self.state = 334
+                self.state = 350
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
@@ -2388,8 +2485,8 @@ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
             super().__init__(parent, invokingState)
             self.parser = parser
 
-        def CNAME(self):
-            return self.getToken(RelayParser.CNAME, 0)
+        def START_LOWER_CNAME(self):
+            return self.getToken(RelayParser.START_LOWER_CNAME, 0)
 
         def expr(self):
             return self.getTypedRuleContext(RelayParser.ExprContext,0)
@@ -2410,14 +2507,14 @@ def accept(self, visitor:ParseTreeVisitor):
     def attr(self):
 
         localctx = RelayParser.AttrContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 42, self.RULE_attr)
+        self.enterRule(localctx, 44, self.RULE_attr)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 335
-            self.match(RelayParser.CNAME)
-            self.state = 336
-            self.match(RelayParser.T__13)
-            self.state = 337
+            self.state = 351
+            self.match(RelayParser.START_LOWER_CNAME)
+            self.state = 352
+            self.match(RelayParser.T__14)
+            self.state = 353
             self.expr(0)
         except RecognitionException as re:
             localctx.exception = re
@@ -2548,132 +2645,132 @@ def accept(self, visitor:ParseTreeVisitor):
     def typeExpr(self):
 
         localctx = RelayParser.TypeExprContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 44, self.RULE_typeExpr)
+        self.enterRule(localctx, 46, self.RULE_typeExpr)
         self._la = 0 # Token type
         try:
-            self.state = 385
+            self.state = 401
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,36,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,39,self._ctx)
             if la_ == 1:
                 localctx = RelayParser.TupleTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 339
-                self.match(RelayParser.T__3)
-                self.state = 340
-                self.match(RelayParser.T__4)
+                self.state = 355
+                self.match(RelayParser.T__5)
+                self.state = 356
+                self.match(RelayParser.T__6)
                 pass
 
             elif la_ == 2:
                 localctx = RelayParser.TupleTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 341
-                self.match(RelayParser.T__3)
-                self.state = 342
+                self.state = 357
+                self.match(RelayParser.T__5)
+                self.state = 358
                 self.typeExpr()
-                self.state = 343
-                self.match(RelayParser.T__2)
-                self.state = 344
+                self.state = 359
                 self.match(RelayParser.T__4)
+                self.state = 360
+                self.match(RelayParser.T__6)
                 pass
 
             elif la_ == 3:
                 localctx = RelayParser.TupleTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 3)
-                self.state = 346
-                self.match(RelayParser.T__3)
-                self.state = 347
+                self.state = 362
+                self.match(RelayParser.T__5)
+                self.state = 363
                 self.typeExpr()
-                self.state = 350 
+                self.state = 366 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while True:
-                    self.state = 348
-                    self.match(RelayParser.T__2)
-                    self.state = 349
+                    self.state = 364
+                    self.match(RelayParser.T__4)
+                    self.state = 365
                     self.typeExpr()
-                    self.state = 352 
+                    self.state = 368 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
-                    if not (_la==RelayParser.T__2):
+                    if not (_la==RelayParser.T__4):
                         break
 
-                self.state = 354
-                self.match(RelayParser.T__4)
+                self.state = 370
+                self.match(RelayParser.T__6)
                 pass
 
             elif la_ == 4:
                 localctx = RelayParser.TypeCallTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 4)
-                self.state = 356
+                self.state = 372
                 self.typeIdent()
-                self.state = 357
+                self.state = 373
                 self.typeParamList()
                 pass
 
             elif la_ == 5:
                 localctx = RelayParser.TypeIdentTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 5)
-                self.state = 359
+                self.state = 375
                 self.typeIdent()
                 pass
 
             elif la_ == 6:
                 localctx = RelayParser.TensorTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 6)
-                self.state = 360
-                self.match(RelayParser.T__26)
-                self.state = 361
-                self.match(RelayParser.T__7)
-                self.state = 362
+                self.state = 376
+                self.match(RelayParser.T__27)
+                self.state = 377
+                self.match(RelayParser.T__9)
+                self.state = 378
                 self.shapeList()
-                self.state = 363
-                self.match(RelayParser.T__2)
-                self.state = 364
+                self.state = 379
+                self.match(RelayParser.T__4)
+                self.state = 380
                 self.typeExpr()
-                self.state = 365
-                self.match(RelayParser.T__8)
+                self.state = 381
+                self.match(RelayParser.T__10)
                 pass
 
             elif la_ == 7:
                 localctx = RelayParser.FuncTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 7)
-                self.state = 367
-                self.match(RelayParser.T__16)
-                self.state = 369
+                self.state = 383
+                self.match(RelayParser.T__17)
+                self.state = 385
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if _la==RelayParser.T__7:
-                    self.state = 368
+                if _la==RelayParser.T__9:
+                    self.state = 384
                     self.typeParamList()
 
 
-                self.state = 371
-                self.match(RelayParser.T__3)
-                self.state = 380
+                self.state = 387
+                self.match(RelayParser.T__5)
+                self.state = 396
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__3) | (1 << RelayParser.T__16) | (1 << RelayParser.T__26) | (1 << RelayParser.CNAME))) != 0):
-                    self.state = 372
+                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__0) | (1 << RelayParser.T__5) | (1 << RelayParser.T__17) | (1 << RelayParser.T__27) | (1 << RelayParser.START_UPPER_CNAME))) != 0):
+                    self.state = 388
                     self.typeExpr()
-                    self.state = 377
+                    self.state = 393
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
-                    while _la==RelayParser.T__2:
-                        self.state = 373
-                        self.match(RelayParser.T__2)
-                        self.state = 374
+                    while _la==RelayParser.T__4:
+                        self.state = 389
+                        self.match(RelayParser.T__4)
+                        self.state = 390
                         self.typeExpr()
-                        self.state = 379
+                        self.state = 395
                         self._errHandler.sync(self)
                         _la = self._input.LA(1)
 
 
 
-                self.state = 382
-                self.match(RelayParser.T__4)
-                self.state = 383
-                self.match(RelayParser.T__17)
-                self.state = 384
+                self.state = 398
+                self.match(RelayParser.T__6)
+                self.state = 399
+                self.match(RelayParser.T__18)
+                self.state = 400
                 self.typeExpr()
                 pass
 
@@ -2715,28 +2812,28 @@ def accept(self, visitor:ParseTreeVisitor):
     def typeParamList(self):
 
         localctx = RelayParser.TypeParamListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 46, self.RULE_typeParamList)
+        self.enterRule(localctx, 48, self.RULE_typeParamList)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 387
-            self.match(RelayParser.T__7)
-            self.state = 388
+            self.state = 403
+            self.match(RelayParser.T__9)
+            self.state = 404
             self.typeIdent()
-            self.state = 393
+            self.state = 409
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            while _la==RelayParser.T__2:
-                self.state = 389
-                self.match(RelayParser.T__2)
-                self.state = 390
+            while _la==RelayParser.T__4:
+                self.state = 405
+                self.match(RelayParser.T__4)
+                self.state = 406
                 self.typeIdent()
-                self.state = 395
+                self.state = 411
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 396
-            self.match(RelayParser.T__8)
+            self.state = 412
+            self.match(RelayParser.T__10)
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -2774,47 +2871,47 @@ def accept(self, visitor:ParseTreeVisitor):
     def shapeList(self):
 
         localctx = RelayParser.ShapeListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 48, self.RULE_shapeList)
+        self.enterRule(localctx, 50, self.RULE_shapeList)
         self._la = 0 # Token type
         try:
-            self.state = 411
+            self.state = 427
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,39,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,42,self._ctx)
             if la_ == 1:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 398
-                self.match(RelayParser.T__3)
-                self.state = 399
+                self.state = 414
+                self.match(RelayParser.T__5)
+                self.state = 415
                 self.shape()
-                self.state = 402 
+                self.state = 418 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while True:
-                    self.state = 400
-                    self.match(RelayParser.T__2)
-                    self.state = 401
+                    self.state = 416
+                    self.match(RelayParser.T__4)
+                    self.state = 417
                     self.shape()
-                    self.state = 404 
+                    self.state = 420 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
-                    if not (_la==RelayParser.T__2):
+                    if not (_la==RelayParser.T__4):
                         break
 
-                self.state = 406
-                self.match(RelayParser.T__4)
+                self.state = 422
+                self.match(RelayParser.T__6)
                 pass
 
             elif la_ == 2:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 408
-                self.match(RelayParser.T__3)
-                self.state = 409
-                self.match(RelayParser.T__4)
+                self.state = 424
+                self.match(RelayParser.T__5)
+                self.state = 425
+                self.match(RelayParser.T__6)
                 pass
 
             elif la_ == 3:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 410
+                self.state = 426
                 self.shape()
                 pass
 
@@ -2834,8 +2931,8 @@ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
             super().__init__(parent, invokingState)
             self.parser = parser
 
-        def CNAME(self):
-            return self.getToken(RelayParser.CNAME, 0)
+        def START_LOWER_CNAME(self):
+            return self.getToken(RelayParser.START_LOWER_CNAME, 0)
 
         def NAT(self):
             return self.getToken(RelayParser.NAT, 0)
@@ -2855,23 +2952,23 @@ def accept(self, visitor:ParseTreeVisitor):
     def meta(self):
 
         localctx = RelayParser.MetaContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 50, self.RULE_meta)
+        self.enterRule(localctx, 52, self.RULE_meta)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 413
-            self.match(RelayParser.T__27)
-            self.state = 414
-            self.match(RelayParser.T__7)
-            self.state = 415
-            self.match(RelayParser.CNAME)
-            self.state = 416
-            self.match(RelayParser.T__8)
-            self.state = 417
-            self.match(RelayParser.T__7)
-            self.state = 418
+            self.state = 429
+            self.match(RelayParser.T__28)
+            self.state = 430
+            self.match(RelayParser.T__9)
+            self.state = 431
+            self.match(RelayParser.START_LOWER_CNAME)
+            self.state = 432
+            self.match(RelayParser.T__10)
+            self.state = 433
+            self.match(RelayParser.T__9)
+            self.state = 434
             self.match(RelayParser.NAT)
-            self.state = 419
-            self.match(RelayParser.T__8)
+            self.state = 435
+            self.match(RelayParser.T__10)
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -2951,31 +3048,31 @@ def accept(self, visitor:ParseTreeVisitor):
     def shape(self):
 
         localctx = RelayParser.ShapeContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 52, self.RULE_shape)
+        self.enterRule(localctx, 54, self.RULE_shape)
         try:
-            self.state = 427
+            self.state = 443
             self._errHandler.sync(self)
             token = self._input.LA(1)
-            if token in [RelayParser.T__27]:
+            if token in [RelayParser.T__28]:
                 localctx = RelayParser.MetaShapeContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 421
+                self.state = 437
                 self.meta()
                 pass
-            elif token in [RelayParser.T__3]:
+            elif token in [RelayParser.T__5]:
                 localctx = RelayParser.ParensShapeContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 422
-                self.match(RelayParser.T__3)
-                self.state = 423
+                self.state = 438
+                self.match(RelayParser.T__5)
+                self.state = 439
                 self.shape()
-                self.state = 424
-                self.match(RelayParser.T__4)
+                self.state = 440
+                self.match(RelayParser.T__6)
                 pass
             elif token in [RelayParser.NAT]:
                 localctx = RelayParser.IntShapeContext(self, localctx)
                 self.enterOuterAlt(localctx, 3)
-                self.state = 426
+                self.state = 442
                 self.match(RelayParser.NAT)
                 pass
             else:
@@ -3015,15 +3112,15 @@ def accept(self, visitor:ParseTreeVisitor):
     def body(self):
 
         localctx = RelayParser.BodyContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 54, self.RULE_body)
+        self.enterRule(localctx, 56, self.RULE_body)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 429
-            self.match(RelayParser.T__5)
-            self.state = 430
+            self.state = 445
+            self.match(RelayParser.T__7)
+            self.state = 446
             self.expr(0)
-            self.state = 431
-            self.match(RelayParser.T__6)
+            self.state = 447
+            self.match(RelayParser.T__8)
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -3101,27 +3198,27 @@ def accept(self, visitor:ParseTreeVisitor):
     def scalar(self):
 
         localctx = RelayParser.ScalarContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 56, self.RULE_scalar)
+        self.enterRule(localctx, 58, self.RULE_scalar)
         try:
-            self.state = 436
+            self.state = 452
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [RelayParser.FLOAT]:
                 localctx = RelayParser.ScalarFloatContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 433
+                self.state = 449
                 self.match(RelayParser.FLOAT)
                 pass
             elif token in [RelayParser.NAT]:
                 localctx = RelayParser.ScalarIntContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 434
+                self.state = 450
                 self.match(RelayParser.NAT)
                 pass
             elif token in [RelayParser.BOOL_LIT]:
                 localctx = RelayParser.ScalarBoolContext(self, localctx)
                 self.enterOuterAlt(localctx, 3)
-                self.state = 435
+                self.state = 451
                 self.match(RelayParser.BOOL_LIT)
                 pass
             else:
@@ -3177,38 +3274,38 @@ def accept(self, visitor:ParseTreeVisitor):
     def ident(self):
 
         localctx = RelayParser.IdentContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 58, self.RULE_ident)
+        self.enterRule(localctx, 60, self.RULE_ident)
         try:
-            self.state = 443
+            self.state = 459
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,42,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,45,self._ctx)
             if la_ == 1:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 438
+                self.state = 454
                 self.opIdent()
                 pass
 
             elif la_ == 2:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 439
+                self.state = 455
                 self.globalVar()
                 pass
 
             elif la_ == 3:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 440
+                self.state = 456
                 self.localVar()
                 pass
 
             elif la_ == 4:
                 self.enterOuterAlt(localctx, 4)
-                self.state = 441
+                self.state = 457
                 self.typeExpr()
                 pass
 
             elif la_ == 5:
                 self.enterOuterAlt(localctx, 5)
-                self.state = 442
+                self.state = 458
                 self.graphVar()
                 pass
 
@@ -3226,7 +3323,7 @@ def ident(self):
     def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
         if self._predicates == None:
             self._predicates = dict()
-        self._predicates[8] = self.expr_sempred
+        self._predicates[9] = self.expr_sempred
         pred = self._predicates.get(ruleIndex, None)
         if pred is None:
             raise Exception("No predicate with index:" + str(ruleIndex))
diff --git a/python/tvm/relay/grammar/py3/RelayVisitor.py b/python/tvm/relay/grammar/py3/RelayVisitor.py
index ac662b79a118..19e04fe99283 100644
--- a/python/tvm/relay/grammar/py3/RelayVisitor.py
+++ b/python/tvm/relay/grammar/py3/RelayVisitor.py
@@ -9,6 +9,11 @@
 
 class RelayVisitor(ParseTreeVisitor):
 
+    # Visit a parse tree produced by RelayParser#baseType.
+    def visitBaseType(self, ctx:RelayParser.BaseTypeContext):
+        return self.visitChildren(ctx)
+
+
     # Visit a parse tree produced by RelayParser#prog.
     def visitProg(self, ctx:RelayParser.ProgContext):
         return self.visitChildren(ctx)
diff --git a/src/relay/ir/alpha_equal.cc b/src/relay/ir/alpha_equal.cc
index 06a94f17623b..7ed8d1eb9c2b 100644
--- a/src/relay/ir/alpha_equal.cc
+++ b/src/relay/ir/alpha_equal.cc
@@ -563,14 +563,20 @@ class AlphaEqualHandler:
         || !ExprEqual(lhs->data, rhs->data)
         || lhs->clauses.size() != rhs->clauses.size()
         || lhs->complete != rhs->complete) {
+      std::cout << "AYY" << std::endl;
+      std::cout << ExprEqual(lhs->data, rhs->data) << std::endl;
+      std::cout << lhs->clauses.size() << "," << rhs->clauses.size() << std::endl;
+      std::cout << lhs->complete << "," << rhs->complete << std::endl;
       return false;
     }
 
     for (size_t i = 0; i < lhs->clauses.size(); ++i) {
       if (!ClauseEqual(lhs->clauses[i], rhs->clauses[i])) {
+        std::cout << "LMAO" << std::endl;
         return false;
       }
     }
+    std::cout << "WAZ" << std::endl;
     return true;
   }
 
diff --git a/src/relay/ir/pretty_printer.cc b/src/relay/ir/pretty_printer.cc
index 7e9f35942b06..0a8371074e40 100644
--- a/src/relay/ir/pretty_printer.cc
+++ b/src/relay/ir/pretty_printer.cc
@@ -255,6 +255,7 @@ class PrettyPrinter :
   }
 
   Doc AllocTemp() {
+    std::cout << "HWERE WITH " << std::endl;
     return TempVar(temp_var_counter_++);
   }
 
@@ -372,11 +373,17 @@ class PrettyPrinter :
     // for it. Every subsequent time we can just use its assigned variable.
     // This works since hashing uses pointer equality.
 
+    // TODO: we need to somehow carry the `try_inline` preference through the
+    // recursion.
+    // bool old_try_inline = try_inline_;
+    // try_inline_ = try_inline;
+
     // determine whether to inline
-    bool inline_expr = AlwaysInline(expr);
-    if (try_inline) {
-      inline_expr |= IsUnique(expr);
-    }
+    bool inline_expr = true;
+    // bool inline_expr = AlwaysInline(expr);
+    // if (try_inline) {
+    //   inline_expr |= IsUnique(expr);
+    // }
 
     auto it = memo_.find(expr);
     if (it != memo_.end()) return it->second;
@@ -594,7 +601,7 @@ class PrettyPrinter :
     std::vector<Doc> clauses;
     for (const auto& clause : op->clauses) {
       Doc clause_doc;
-      clause_doc << "| " << Print(clause->lhs) << " => " << Print(clause->rhs);
+      clause_doc << "| " << Print(clause->lhs) << " => " << Print(clause->rhs, false, true);
       clauses.push_back(clause_doc);
     }
     doc << Indent(2, body << PrintNewLine() << PrintSep(clauses, PrintNewLine())) << PrintNewLine();
diff --git a/tests/python/relay/test_ir_parser.py b/tests/python/relay/test_ir_parser.py
index 2aaa4c181a8f..4ce3e506b0bc 100644
--- a/tests/python/relay/test_ir_parser.py
+++ b/tests/python/relay/test_ir_parser.py
@@ -67,6 +67,8 @@ def roundtrip(expr):
 
 def parse_text(code):
     expr = relay.fromtext(SEMVER + "\n" + code)
+    print('[PRETTY-PRINTED]')
+    print(expr)
     roundtrip(expr)
     return expr
 
@@ -76,9 +78,9 @@ def parses_as(code, expr):
     print('[ORIGINAL]')
     print(code)
     parsed = parse_text(code)
-    print('[PRINTED]')
-    print(str(parsed))
+    print('[CHECKING EQULALALAALLALTYI]')
     result = alpha_equal(parsed, expr)
+    print('[FINISEHEHSHSHSED CHEKCIGN EEQUALTY]')
     return result
 
 def get_scalar(x):
@@ -660,16 +662,16 @@ def test_adt_defn():
 def test_multiple_variants():
     mod = relay.Module()
 
-    glob_typ_var = relay.GlobalTypeVar("List")
+    list_var = relay.GlobalTypeVar("List")
     typ_var = relay.TypeVar("A")
     prog = relay.TypeData(
-            glob_typ_var,
+            list_var,
             [typ_var],
             [
-                relay.Constructor("Cons", [typ_var, glob_typ_var(typ_var)], glob_typ_var),
-                relay.Constructor("Nil", [], glob_typ_var),
+                relay.Constructor("Cons", [typ_var, list_var(typ_var)], list_var),
+                relay.Constructor("Nil", [], list_var),
             ])
-    mod[glob_typ_var] = prog
+    mod[list_var] = prog
     assert parses_as(
         """
         type List[A] =
@@ -722,6 +724,7 @@ def test_match():
     input_type = list_var(typ_var)
     input_var = relay.Var("xs", input_type)
     rest_var = relay.Var("rest")
+    # TODO: THIS IS WHAT'S NOT EQUAL
     body = relay.Match(input_var,
         [relay.Clause(
             relay.PatternConstructor(
@@ -731,7 +734,8 @@ def test_match():
             ),
          relay.Clause(
              relay.PatternConstructor(nil_constructor, []),
-             relay.const(0))]
+             relay.const(0))],
+        complete=False
     )
     length_func = relay.Function(
         [input_var],
@@ -741,7 +745,6 @@ def test_match():
     )
     mod[length_var] = length_func
 
-    # TODO: Put these back in
     assert parses_as(
         """
         type List[A] =
@@ -783,6 +786,6 @@ def @length[A](%xs: List[A]) -> int32 {
     # test_function_type()
     # test_tuple_type()
     # test_adt_defn()
-    # test_multiple_variants()
+    test_multiple_variants()
     # test_multiple_type_params()
     test_match()

From c1f3be8e255017c046964b8b589d272947658c0a Mon Sep 17 00:00:00 2001
From: Logan Weber <weberlo@cs.washington.edu>
Date: Mon, 26 Aug 2019 14:41:34 -0700
Subject: [PATCH 06/29] All tests but newest are passing

---
 python/tvm/relay/_parser.py                  |  12 +-
 python/tvm/relay/grammar/Relay.g4            |  19 +-
 python/tvm/relay/grammar/py3/RelayLexer.py   | 430 ++++++----
 python/tvm/relay/grammar/py3/RelayParser.py  | 838 ++++++++++---------
 python/tvm/relay/grammar/py3/RelayVisitor.py |   5 +
 tests/python/relay/test_ir_parser.py         | 101 ++-
 6 files changed, 785 insertions(+), 620 deletions(-)

diff --git a/python/tvm/relay/_parser.py b/python/tvm/relay/_parser.py
index e5be1cd99e7b..4aeb74490aec 100644
--- a/python/tvm/relay/_parser.py
+++ b/python/tvm/relay/_parser.py
@@ -290,6 +290,9 @@ def visitLocalVar(self, ctx):
             raise ParseError(f'unbound local var "{var_name}""')
         return local_var
 
+    def visitGraphVar(self, ctx):
+        return self.graph_expr[int(ctx.NAT().getText())]
+
     def visit_list(self, ctx_list):
         # type: (List[ParserRuleContext]) -> List[Any]
         """"Visit a list of contexts."""
@@ -416,7 +419,7 @@ def visitVarList(self, ctx):
     # TODO: support a larger class of values than just Relay exprs
     def visitAttr(self, ctx):
         # type: (RelayParser.AttrContext) -> Tuple[str, expr.Expr]
-        return (ctx.CNAME().getText(), self.visit(ctx.expr()))
+        return (ctx.START_LOWER_CNAME().getText(), self.visit(ctx.expr()))
 
     def visitArgNoAttr(self, ctx):
         return (self.visit_list(ctx.varList().var()), None)
@@ -638,7 +641,6 @@ def visitIfElse(self, ctx):
     def visitGraph(self, ctx):
         # type: (RelayParser.GraphContext) -> expr.Expr
         """Visit a graph variable assignment."""
-        import pdb; pdb.set_trace()
         graph_nid = int(ctx.graphVar().getText()[1:])
 
         self.enter_var_scope()
@@ -719,7 +721,7 @@ def visitTensorType(self, ctx):
         """Create a simple tensor type. No generics."""
 
         shape = self.visit(ctx.shapeList())
-        dtype = self.visit(ctx.type_())
+        dtype = self.visit(ctx.typeExpr())
 
         if not isinstance(dtype, ty.TensorType):
             raise ParseError("Expected dtype to be a Relay base type.")
@@ -730,11 +732,11 @@ def visitTensorType(self, ctx):
 
     def visitTupleType(self, ctx):
         # type: (RelayParser.TupleTypeContext) -> ty.TupleType
-        return ty.TupleType(self.visit_list(ctx.type_()))
+        return ty.TupleType(self.visit_list(ctx.typeExpr()))
 
     def visitFuncType(self, ctx):
         # type: (RelayParser.FuncTypeContext) -> ty.FuncType
-        types = self.visit_list(ctx.type_())
+        types = self.visit_list(ctx.typeExpr())
 
         arg_types = types[:-1]
         ret_type = types[-1]
diff --git a/python/tvm/relay/grammar/Relay.g4 b/python/tvm/relay/grammar/Relay.g4
index 10aab799666e..367b376926b9 100644
--- a/python/tvm/relay/grammar/Relay.g4
+++ b/python/tvm/relay/grammar/Relay.g4
@@ -62,8 +62,13 @@ fragment PREFLOAT : NAT ('.' NAT)? EXP?; // 1.35, 1.35E-9, 0.3, 4.5, 1, 1e10 3e4
 
 FLOAT : PREFLOAT 'f';
 
-// BASE_TYPE : ('int'|'uint'|'float'|'bool') DIGIT*;
-baseType : 'int32' ;
+baseType
+  : 'int8' | 'int16' | 'int32' | 'int64'
+  | 'uint8' | 'uint16' | 'uint32' | 'uint64'
+  | 'float16' | 'float32' | 'float64'
+  | 'bool'
+  | 'int8x4' | 'uint1x4' | 'float16x4'
+  ;
 
 // non-negative ints
 NAT: DIGIT+ ;
@@ -83,7 +88,7 @@ prog: SEMVER (defn* | expr) METADATA? EOF ;
 
 opIdent: START_LOWER_CNAME ('.' START_LOWER_CNAME)*;
 globalVar: '@' START_LOWER_CNAME ;
-localVar: '%' START_LOWER_CNAME ;
+localVar: '%' ('_' | START_LOWER_CNAME) ;
 // TODO(weberlo): why does 'int32` generate a parse error when it's literally a
 // lexer token?
 // typeIdent: BASE_TYPE | START_UPPER_NAME ;
@@ -168,7 +173,7 @@ typeExpr
   | typeIdent                                                    # typeIdentType
   | 'Tensor' '[' shapeList ',' typeExpr ']'                         # tensorType
   | 'fn' typeParamList? '(' (typeExpr (',' typeExpr)*)? ')' '->' typeExpr # funcType
-  // | '_'                                                          # incompleteType
+  | '_'                                                          # incompleteType
   // TODO: Why the fuck does this rule exist?
   // | NAT                                                          # intType
   ;
@@ -177,8 +182,8 @@ typeExpr
 typeParamList: '[' typeIdent (',' typeIdent)* ']' ;
 
 shapeList
-  : '(' shape (',' shape)+ ')'
-  | '(' ')'
+  : '(' ')'
+  | '(' shape (',' shape)+ ')'
   | shape
   ;
 
@@ -208,6 +213,6 @@ ident
   : opIdent
   | globalVar
   | localVar
-  | typeExpr
+  // | typeExpr
   | graphVar
   ;
diff --git a/python/tvm/relay/grammar/py3/RelayLexer.py b/python/tvm/relay/grammar/py3/RelayLexer.py
index 02e1b2596794..da53004e092c 100644
--- a/python/tvm/relay/grammar/py3/RelayLexer.py
+++ b/python/tvm/relay/grammar/py3/RelayLexer.py
@@ -8,8 +8,8 @@
 
 def serializedATN():
     with StringIO() as buf:
-        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\64")
-        buf.write("\u016d\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7")
+        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2B")
+        buf.write("\u01eb\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7")
         buf.write("\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r")
         buf.write("\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23")
         buf.write("\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30")
@@ -18,152 +18,206 @@ def serializedATN():
         buf.write("\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.")
         buf.write("\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64")
         buf.write("\t\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:")
-        buf.write("\3\2\3\2\3\2\3\2\3\2\3\2\3\3\3\3\3\4\3\4\3\5\3\5\3\6\3")
-        buf.write("\6\3\7\3\7\3\b\3\b\3\t\3\t\3\n\3\n\3\13\3\13\3\f\3\f\3")
-        buf.write("\r\3\r\3\r\3\16\3\16\3\16\3\16\3\16\3\17\3\17\3\17\3\17")
-        buf.write("\3\20\3\20\3\21\3\21\3\22\3\22\3\22\3\23\3\23\3\23\3\24")
-        buf.write("\3\24\3\24\3\25\3\25\3\25\3\25\3\26\3\26\3\26\3\26\3\26")
-        buf.write("\3\27\3\27\3\30\3\30\3\30\3\31\3\31\3\31\3\31\3\31\3\31")
-        buf.write("\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\33\3\33\3\34\3\34")
-        buf.write("\3\35\3\35\3\35\3\35\3\35\3\35\3\35\3\36\3\36\3\36\3\36")
-        buf.write("\3\36\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3 \3 \3 \3 \3")
-        buf.write(" \7 \u00e0\n \f \16 \u00e3\13 \3 \3 \3 \3 \3 \3!\6!\u00eb")
-        buf.write("\n!\r!\16!\u00ec\3!\3!\3\"\3\"\3\"\3\"\7\"\u00f5\n\"\f")
-        buf.write("\"\16\"\u00f8\13\"\3\"\3\"\3\"\3\"\3#\3#\3#\3$\3$\3$\7")
-        buf.write("$\u0104\n$\f$\16$\u0107\13$\3$\3$\3%\3%\3&\3&\3\'\3\'")
-        buf.write("\3(\3(\3)\3)\3*\3*\3+\3+\3+\3,\3,\3,\3-\3-\3-\3.\3.\3")
-        buf.write(".\3/\3/\3/\3/\3/\3/\3/\3/\3/\5/\u012c\n/\3\60\3\60\3\60")
-        buf.write("\3\60\7\60\u0132\n\60\f\60\16\60\u0135\13\60\3\61\3\61")
-        buf.write("\3\61\3\61\7\61\u013b\n\61\f\61\16\61\u013e\13\61\3\62")
-        buf.write("\3\62\3\62\5\62\u0143\n\62\3\62\5\62\u0146\n\62\3\63\3")
-        buf.write("\63\3\63\3\64\6\64\u014c\n\64\r\64\16\64\u014d\3\65\3")
-        buf.write("\65\5\65\u0152\n\65\3\65\3\65\3\66\3\66\3\67\3\67\38\3")
-        buf.write("8\39\39\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\3:\7:\u0169\n:\f")
-        buf.write(":\16:\u016c\13:\5\u00e1\u00f6\u0105\2;\3\3\5\4\7\5\t\6")
-        buf.write("\13\7\r\b\17\t\21\n\23\13\25\f\27\r\31\16\33\17\35\20")
-        buf.write("\37\21!\22#\23%\24\'\25)\26+\27-\30/\31\61\32\63\33\65")
-        buf.write("\34\67\359\36;\37= ?!A\"C#E\2G$I%K&M\'O(Q)S*U+W,Y-[.]")
-        buf.write("/_\60a\61c\2e\62g\63i\2k\2m\2o\2q\2s\64\3\2\n\5\2\13\f")
-        buf.write("\17\17\"\"\4\2\f\f\17\17\4\2GGgg\4\2--//\3\2c|\3\2C\\")
-        buf.write("\4\2C\\c|\3\2\62;\2\u0177\2\3\3\2\2\2\2\5\3\2\2\2\2\7")
-        buf.write("\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2")
-        buf.write("\2\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2")
-        buf.write("\2\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2\2\2\2\37\3\2\2\2")
-        buf.write("\2!\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("\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2\2\2\2\63")
-        buf.write("\3\2\2\2\2\65\3\2\2\2\2\67\3\2\2\2\29\3\2\2\2\2;\3\2\2")
-        buf.write("\2\2=\3\2\2\2\2?\3\2\2\2\2A\3\2\2\2\2C\3\2\2\2\2G\3\2")
-        buf.write("\2\2\2I\3\2\2\2\2K\3\2\2\2\2M\3\2\2\2\2O\3\2\2\2\2Q\3")
-        buf.write("\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2W\3\2\2\2\2Y\3\2\2\2\2[")
-        buf.write("\3\2\2\2\2]\3\2\2\2\2_\3\2\2\2\2a\3\2\2\2\2e\3\2\2\2\2")
-        buf.write("g\3\2\2\2\2s\3\2\2\2\3u\3\2\2\2\5{\3\2\2\2\7}\3\2\2\2")
-        buf.write("\t\177\3\2\2\2\13\u0081\3\2\2\2\r\u0083\3\2\2\2\17\u0085")
-        buf.write("\3\2\2\2\21\u0087\3\2\2\2\23\u0089\3\2\2\2\25\u008b\3")
-        buf.write("\2\2\2\27\u008d\3\2\2\2\31\u008f\3\2\2\2\33\u0092\3\2")
-        buf.write("\2\2\35\u0097\3\2\2\2\37\u009b\3\2\2\2!\u009d\3\2\2\2")
-        buf.write("#\u009f\3\2\2\2%\u00a2\3\2\2\2\'\u00a5\3\2\2\2)\u00a8")
-        buf.write("\3\2\2\2+\u00ac\3\2\2\2-\u00b1\3\2\2\2/\u00b3\3\2\2\2")
-        buf.write("\61\u00b6\3\2\2\2\63\u00bc\3\2\2\2\65\u00c3\3\2\2\2\67")
-        buf.write("\u00c5\3\2\2\29\u00c7\3\2\2\2;\u00ce\3\2\2\2=\u00d3\3")
-        buf.write("\2\2\2?\u00da\3\2\2\2A\u00ea\3\2\2\2C\u00f0\3\2\2\2E\u00fd")
-        buf.write("\3\2\2\2G\u0100\3\2\2\2I\u010a\3\2\2\2K\u010c\3\2\2\2")
-        buf.write("M\u010e\3\2\2\2O\u0110\3\2\2\2Q\u0112\3\2\2\2S\u0114\3")
-        buf.write("\2\2\2U\u0116\3\2\2\2W\u0119\3\2\2\2Y\u011c\3\2\2\2[\u011f")
-        buf.write("\3\2\2\2]\u012b\3\2\2\2_\u012d\3\2\2\2a\u0136\3\2\2\2")
-        buf.write("c\u013f\3\2\2\2e\u0147\3\2\2\2g\u014b\3\2\2\2i\u014f\3")
-        buf.write("\2\2\2k\u0155\3\2\2\2m\u0157\3\2\2\2o\u0159\3\2\2\2q\u015b")
-        buf.write("\3\2\2\2s\u015d\3\2\2\2uv\7k\2\2vw\7p\2\2wx\7v\2\2xy\7")
-        buf.write("\65\2\2yz\7\64\2\2z\4\3\2\2\2{|\7\60\2\2|\6\3\2\2\2}~")
-        buf.write("\7B\2\2~\b\3\2\2\2\177\u0080\7\'\2\2\u0080\n\3\2\2\2\u0081")
-        buf.write("\u0082\7.\2\2\u0082\f\3\2\2\2\u0083\u0084\7*\2\2\u0084")
-        buf.write("\16\3\2\2\2\u0085\u0086\7+\2\2\u0086\20\3\2\2\2\u0087")
-        buf.write("\u0088\7}\2\2\u0088\22\3\2\2\2\u0089\u008a\7\177\2\2\u008a")
-        buf.write("\24\3\2\2\2\u008b\u008c\7]\2\2\u008c\26\3\2\2\2\u008d")
-        buf.write("\u008e\7_\2\2\u008e\30\3\2\2\2\u008f\u0090\7k\2\2\u0090")
-        buf.write("\u0091\7h\2\2\u0091\32\3\2\2\2\u0092\u0093\7g\2\2\u0093")
-        buf.write("\u0094\7n\2\2\u0094\u0095\7u\2\2\u0095\u0096\7g\2\2\u0096")
-        buf.write("\34\3\2\2\2\u0097\u0098\7n\2\2\u0098\u0099\7g\2\2\u0099")
-        buf.write("\u009a\7v\2\2\u009a\36\3\2\2\2\u009b\u009c\7?\2\2\u009c")
-        buf.write(" \3\2\2\2\u009d\u009e\7=\2\2\u009e\"\3\2\2\2\u009f\u00a0")
-        buf.write("\7=\2\2\u00a0\u00a1\7=\2\2\u00a1$\3\2\2\2\u00a2\u00a3")
-        buf.write("\7h\2\2\u00a3\u00a4\7p\2\2\u00a4&\3\2\2\2\u00a5\u00a6")
-        buf.write("\7/\2\2\u00a6\u00a7\7@\2\2\u00a7(\3\2\2\2\u00a8\u00a9")
-        buf.write("\7f\2\2\u00a9\u00aa\7g\2\2\u00aa\u00ab\7h\2\2\u00ab*\3")
-        buf.write("\2\2\2\u00ac\u00ad\7v\2\2\u00ad\u00ae\7{\2\2\u00ae\u00af")
-        buf.write("\7r\2\2\u00af\u00b0\7g\2\2\u00b0,\3\2\2\2\u00b1\u00b2")
-        buf.write("\7~\2\2\u00b2.\3\2\2\2\u00b3\u00b4\7?\2\2\u00b4\u00b5")
-        buf.write("\7@\2\2\u00b5\60\3\2\2\2\u00b6\u00b7\7o\2\2\u00b7\u00b8")
-        buf.write("\7c\2\2\u00b8\u00b9\7v\2\2\u00b9\u00ba\7e\2\2\u00ba\u00bb")
-        buf.write("\7j\2\2\u00bb\62\3\2\2\2\u00bc\u00bd\7o\2\2\u00bd\u00be")
-        buf.write("\7c\2\2\u00be\u00bf\7v\2\2\u00bf\u00c0\7e\2\2\u00c0\u00c1")
-        buf.write("\7j\2\2\u00c1\u00c2\7A\2\2\u00c2\64\3\2\2\2\u00c3\u00c4")
-        buf.write("\7a\2\2\u00c4\66\3\2\2\2\u00c5\u00c6\7<\2\2\u00c68\3\2")
-        buf.write("\2\2\u00c7\u00c8\7V\2\2\u00c8\u00c9\7g\2\2\u00c9\u00ca")
-        buf.write("\7p\2\2\u00ca\u00cb\7u\2\2\u00cb\u00cc\7q\2\2\u00cc\u00cd")
-        buf.write("\7t\2\2\u00cd:\3\2\2\2\u00ce\u00cf\7o\2\2\u00cf\u00d0")
-        buf.write("\7g\2\2\u00d0\u00d1\7v\2\2\u00d1\u00d2\7c\2\2\u00d2<\3")
-        buf.write("\2\2\2\u00d3\u00d4\7x\2\2\u00d4\u00d5\7\62\2\2\u00d5\u00d6")
-        buf.write("\7\60\2\2\u00d6\u00d7\7\62\2\2\u00d7\u00d8\7\60\2\2\u00d8")
-        buf.write("\u00d9\7\65\2\2\u00d9>\3\2\2\2\u00da\u00db\7\61\2\2\u00db")
-        buf.write("\u00dc\7,\2\2\u00dc\u00e1\3\2\2\2\u00dd\u00e0\5? \2\u00de")
-        buf.write("\u00e0\13\2\2\2\u00df\u00dd\3\2\2\2\u00df\u00de\3\2\2")
-        buf.write("\2\u00e0\u00e3\3\2\2\2\u00e1\u00e2\3\2\2\2\u00e1\u00df")
-        buf.write("\3\2\2\2\u00e2\u00e4\3\2\2\2\u00e3\u00e1\3\2\2\2\u00e4")
-        buf.write("\u00e5\7,\2\2\u00e5\u00e6\7\61\2\2\u00e6\u00e7\3\2\2\2")
-        buf.write("\u00e7\u00e8\b \2\2\u00e8@\3\2\2\2\u00e9\u00eb\t\2\2\2")
-        buf.write("\u00ea\u00e9\3\2\2\2\u00eb\u00ec\3\2\2\2\u00ec\u00ea\3")
-        buf.write("\2\2\2\u00ec\u00ed\3\2\2\2\u00ed\u00ee\3\2\2\2\u00ee\u00ef")
-        buf.write("\b!\2\2\u00efB\3\2\2\2\u00f0\u00f1\7\61\2\2\u00f1\u00f2")
-        buf.write("\7\61\2\2\u00f2\u00f6\3\2\2\2\u00f3\u00f5\13\2\2\2\u00f4")
-        buf.write("\u00f3\3\2\2\2\u00f5\u00f8\3\2\2\2\u00f6\u00f7\3\2\2\2")
-        buf.write("\u00f6\u00f4\3\2\2\2\u00f7\u00f9\3\2\2\2\u00f8\u00f6\3")
-        buf.write("\2\2\2\u00f9\u00fa\7\f\2\2\u00fa\u00fb\3\2\2\2\u00fb\u00fc")
-        buf.write("\b\"\2\2\u00fcD\3\2\2\2\u00fd\u00fe\7^\2\2\u00fe\u00ff")
-        buf.write("\7$\2\2\u00ffF\3\2\2\2\u0100\u0105\7$\2\2\u0101\u0104")
-        buf.write("\5E#\2\u0102\u0104\n\3\2\2\u0103\u0101\3\2\2\2\u0103\u0102")
-        buf.write("\3\2\2\2\u0104\u0107\3\2\2\2\u0105\u0106\3\2\2\2\u0105")
-        buf.write("\u0103\3\2\2\2\u0106\u0108\3\2\2\2\u0107\u0105\3\2\2\2")
-        buf.write("\u0108\u0109\7$\2\2\u0109H\3\2\2\2\u010a\u010b\7,\2\2")
-        buf.write("\u010bJ\3\2\2\2\u010c\u010d\7\61\2\2\u010dL\3\2\2\2\u010e")
-        buf.write("\u010f\7-\2\2\u010fN\3\2\2\2\u0110\u0111\7/\2\2\u0111")
-        buf.write("P\3\2\2\2\u0112\u0113\7>\2\2\u0113R\3\2\2\2\u0114\u0115")
-        buf.write("\7@\2\2\u0115T\3\2\2\2\u0116\u0117\7>\2\2\u0117\u0118")
-        buf.write("\7?\2\2\u0118V\3\2\2\2\u0119\u011a\7@\2\2\u011a\u011b")
-        buf.write("\7?\2\2\u011bX\3\2\2\2\u011c\u011d\7?\2\2\u011d\u011e")
-        buf.write("\7?\2\2\u011eZ\3\2\2\2\u011f\u0120\7#\2\2\u0120\u0121")
-        buf.write("\7?\2\2\u0121\\\3\2\2\2\u0122\u0123\7V\2\2\u0123\u0124")
-        buf.write("\7t\2\2\u0124\u0125\7w\2\2\u0125\u012c\7g\2\2\u0126\u0127")
-        buf.write("\7H\2\2\u0127\u0128\7c\2\2\u0128\u0129\7n\2\2\u0129\u012a")
-        buf.write("\7u\2\2\u012a\u012c\7g\2\2\u012b\u0122\3\2\2\2\u012b\u0126")
-        buf.write("\3\2\2\2\u012c^\3\2\2\2\u012d\u0133\5m\67\2\u012e\u0132")
-        buf.write("\7a\2\2\u012f\u0132\5o8\2\u0130\u0132\5q9\2\u0131\u012e")
-        buf.write("\3\2\2\2\u0131\u012f\3\2\2\2\u0131\u0130\3\2\2\2\u0132")
-        buf.write("\u0135\3\2\2\2\u0133\u0131\3\2\2\2\u0133\u0134\3\2\2\2")
-        buf.write("\u0134`\3\2\2\2\u0135\u0133\3\2\2\2\u0136\u013c\5k\66")
-        buf.write("\2\u0137\u013b\7a\2\2\u0138\u013b\5o8\2\u0139\u013b\5")
-        buf.write("q9\2\u013a\u0137\3\2\2\2\u013a\u0138\3\2\2\2\u013a\u0139")
-        buf.write("\3\2\2\2\u013b\u013e\3\2\2\2\u013c\u013a\3\2\2\2\u013c")
-        buf.write("\u013d\3\2\2\2\u013db\3\2\2\2\u013e\u013c\3\2\2\2\u013f")
-        buf.write("\u0142\5g\64\2\u0140\u0141\7\60\2\2\u0141\u0143\5g\64")
-        buf.write("\2\u0142\u0140\3\2\2\2\u0142\u0143\3\2\2\2\u0143\u0145")
-        buf.write("\3\2\2\2\u0144\u0146\5i\65\2\u0145\u0144\3\2\2\2\u0145")
-        buf.write("\u0146\3\2\2\2\u0146d\3\2\2\2\u0147\u0148\5c\62\2\u0148")
-        buf.write("\u0149\7h\2\2\u0149f\3\2\2\2\u014a\u014c\5q9\2\u014b\u014a")
-        buf.write("\3\2\2\2\u014c\u014d\3\2\2\2\u014d\u014b\3\2\2\2\u014d")
-        buf.write("\u014e\3\2\2\2\u014eh\3\2\2\2\u014f\u0151\t\4\2\2\u0150")
-        buf.write("\u0152\t\5\2\2\u0151\u0150\3\2\2\2\u0151\u0152\3\2\2\2")
-        buf.write("\u0152\u0153\3\2\2\2\u0153\u0154\5g\64\2\u0154j\3\2\2")
-        buf.write("\2\u0155\u0156\t\6\2\2\u0156l\3\2\2\2\u0157\u0158\t\7")
-        buf.write("\2\2\u0158n\3\2\2\2\u0159\u015a\t\b\2\2\u015ap\3\2\2\2")
-        buf.write("\u015b\u015c\t\t\2\2\u015cr\3\2\2\2\u015d\u015e\7O\2\2")
-        buf.write("\u015e\u015f\7G\2\2\u015f\u0160\7V\2\2\u0160\u0161\7C")
-        buf.write("\2\2\u0161\u0162\7F\2\2\u0162\u0163\7C\2\2\u0163\u0164")
-        buf.write("\7V\2\2\u0164\u0165\7C\2\2\u0165\u0166\7<\2\2\u0166\u016a")
-        buf.write("\3\2\2\2\u0167\u0169\13\2\2\2\u0168\u0167\3\2\2\2\u0169")
-        buf.write("\u016c\3\2\2\2\u016a\u0168\3\2\2\2\u016a\u016b\3\2\2\2")
-        buf.write("\u016bt\3\2\2\2\u016c\u016a\3\2\2\2\23\2\u00df\u00e1\u00ec")
-        buf.write("\u00f6\u0103\u0105\u012b\u0131\u0133\u013a\u013c\u0142")
-        buf.write("\u0145\u014d\u0151\u016a\3\b\2\2")
+        buf.write("\4;\t;\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\t")
+        buf.write("C\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\3\2\3\2\3\2\3\2\3\2\3")
+        buf.write("\3\3\3\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3\4\3\4\3\4\3\5\3\5")
+        buf.write("\3\5\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\3\6\3\7\3\7\3\7\3")
+        buf.write("\7\3\7\3\7\3\7\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\t\3\t\3\t")
+        buf.write("\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\13")
+        buf.write("\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\f\3")
+        buf.write("\f\3\f\3\f\3\f\3\r\3\r\3\r\3\r\3\r\3\16\3\16\3\16\3\16")
+        buf.write("\3\16\3\16\3\16\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17")
+        buf.write("\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\21")
+        buf.write("\3\21\3\22\3\22\3\23\3\23\3\24\3\24\3\25\3\25\3\26\3\26")
+        buf.write("\3\27\3\27\3\30\3\30\3\31\3\31\3\32\3\32\3\33\3\33\3\34")
+        buf.write("\3\34\3\34\3\35\3\35\3\35\3\35\3\35\3\36\3\36\3\36\3\36")
+        buf.write("\3\37\3\37\3 \3 \3!\3!\3!\3\"\3\"\3\"\3#\3#\3#\3$\3$\3")
+        buf.write("$\3$\3%\3%\3%\3%\3%\3&\3&\3\'\3\'\3\'\3(\3(\3(\3(\3(\3")
+        buf.write("(\3)\3)\3)\3)\3)\3)\3)\3*\3*\3+\3+\3+\3+\3+\3+\3+\3,\3")
+        buf.write(",\3,\3,\3,\3-\3-\3-\3-\3-\3-\3-\3.\3.\3.\3.\3.\7.\u015e")
+        buf.write("\n.\f.\16.\u0161\13.\3.\3.\3.\3.\3.\3/\6/\u0169\n/\r/")
+        buf.write("\16/\u016a\3/\3/\3\60\3\60\3\60\3\60\7\60\u0173\n\60\f")
+        buf.write("\60\16\60\u0176\13\60\3\60\3\60\3\60\3\60\3\61\3\61\3")
+        buf.write("\61\3\62\3\62\3\62\7\62\u0182\n\62\f\62\16\62\u0185\13")
+        buf.write("\62\3\62\3\62\3\63\3\63\3\64\3\64\3\65\3\65\3\66\3\66")
+        buf.write("\3\67\3\67\38\38\39\39\39\3:\3:\3:\3;\3;\3;\3<\3<\3<\3")
+        buf.write("=\3=\3=\3=\3=\3=\3=\3=\3=\5=\u01aa\n=\3>\3>\3>\3>\7>\u01b0")
+        buf.write("\n>\f>\16>\u01b3\13>\3?\3?\3?\3?\7?\u01b9\n?\f?\16?\u01bc")
+        buf.write("\13?\3@\3@\3@\5@\u01c1\n@\3@\5@\u01c4\n@\3A\3A\3A\3B\6")
+        buf.write("B\u01ca\nB\rB\16B\u01cb\3C\3C\5C\u01d0\nC\3C\3C\3D\3D")
+        buf.write("\3E\3E\3F\3F\3G\3G\3H\3H\3H\3H\3H\3H\3H\3H\3H\3H\3H\7")
+        buf.write("H\u01e7\nH\fH\16H\u01ea\13H\5\u015f\u0174\u0183\2I\3\3")
+        buf.write("\5\4\7\5\t\6\13\7\r\b\17\t\21\n\23\13\25\f\27\r\31\16")
+        buf.write("\33\17\35\20\37\21!\22#\23%\24\'\25)\26+\27-\30/\31\61")
+        buf.write("\32\63\33\65\34\67\359\36;\37= ?!A\"C#E$G%I&K\'M(O)Q*")
+        buf.write("S+U,W-Y.[/]\60_\61a\2c\62e\63g\64i\65k\66m\67o8q9s:u;")
+        buf.write("w<y={>}?\177\2\u0081@\u0083A\u0085\2\u0087\2\u0089\2\u008b")
+        buf.write("\2\u008d\2\u008fB\3\2\n\5\2\13\f\17\17\"\"\4\2\f\f\17")
+        buf.write("\17\4\2GGgg\4\2--//\3\2c|\3\2C\\\4\2C\\c|\3\2\62;\2\u01f5")
+        buf.write("\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3\2\2\2\2\t\3\2\2\2\2\13")
+        buf.write("\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3")
+        buf.write("\2\2\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2")
+        buf.write("\2\2\2\35\3\2\2\2\2\37\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2")
+        buf.write("%\3\2\2\2\2\'\3\2\2\2\2)\3\2\2\2\2+\3\2\2\2\2-\3\2\2\2")
+        buf.write("\2/\3\2\2\2\2\61\3\2\2\2\2\63\3\2\2\2\2\65\3\2\2\2\2\67")
+        buf.write("\3\2\2\2\29\3\2\2\2\2;\3\2\2\2\2=\3\2\2\2\2?\3\2\2\2\2")
+        buf.write("A\3\2\2\2\2C\3\2\2\2\2E\3\2\2\2\2G\3\2\2\2\2I\3\2\2\2")
+        buf.write("\2K\3\2\2\2\2M\3\2\2\2\2O\3\2\2\2\2Q\3\2\2\2\2S\3\2\2")
+        buf.write("\2\2U\3\2\2\2\2W\3\2\2\2\2Y\3\2\2\2\2[\3\2\2\2\2]\3\2")
+        buf.write("\2\2\2_\3\2\2\2\2c\3\2\2\2\2e\3\2\2\2\2g\3\2\2\2\2i\3")
+        buf.write("\2\2\2\2k\3\2\2\2\2m\3\2\2\2\2o\3\2\2\2\2q\3\2\2\2\2s")
+        buf.write("\3\2\2\2\2u\3\2\2\2\2w\3\2\2\2\2y\3\2\2\2\2{\3\2\2\2\2")
+        buf.write("}\3\2\2\2\2\u0081\3\2\2\2\2\u0083\3\2\2\2\2\u008f\3\2")
+        buf.write("\2\2\3\u0091\3\2\2\2\5\u0096\3\2\2\2\7\u009c\3\2\2\2\t")
+        buf.write("\u00a2\3\2\2\2\13\u00a8\3\2\2\2\r\u00ae\3\2\2\2\17\u00b5")
+        buf.write("\3\2\2\2\21\u00bc\3\2\2\2\23\u00c3\3\2\2\2\25\u00cb\3")
+        buf.write("\2\2\2\27\u00d3\3\2\2\2\31\u00db\3\2\2\2\33\u00e0\3\2")
+        buf.write("\2\2\35\u00e7\3\2\2\2\37\u00ef\3\2\2\2!\u00f9\3\2\2\2")
+        buf.write("#\u00fb\3\2\2\2%\u00fd\3\2\2\2\'\u00ff\3\2\2\2)\u0101")
+        buf.write("\3\2\2\2+\u0103\3\2\2\2-\u0105\3\2\2\2/\u0107\3\2\2\2")
+        buf.write("\61\u0109\3\2\2\2\63\u010b\3\2\2\2\65\u010d\3\2\2\2\67")
+        buf.write("\u010f\3\2\2\29\u0112\3\2\2\2;\u0117\3\2\2\2=\u011b\3")
+        buf.write("\2\2\2?\u011d\3\2\2\2A\u011f\3\2\2\2C\u0122\3\2\2\2E\u0125")
+        buf.write("\3\2\2\2G\u0128\3\2\2\2I\u012c\3\2\2\2K\u0131\3\2\2\2")
+        buf.write("M\u0133\3\2\2\2O\u0136\3\2\2\2Q\u013c\3\2\2\2S\u0143\3")
+        buf.write("\2\2\2U\u0145\3\2\2\2W\u014c\3\2\2\2Y\u0151\3\2\2\2[\u0158")
+        buf.write("\3\2\2\2]\u0168\3\2\2\2_\u016e\3\2\2\2a\u017b\3\2\2\2")
+        buf.write("c\u017e\3\2\2\2e\u0188\3\2\2\2g\u018a\3\2\2\2i\u018c\3")
+        buf.write("\2\2\2k\u018e\3\2\2\2m\u0190\3\2\2\2o\u0192\3\2\2\2q\u0194")
+        buf.write("\3\2\2\2s\u0197\3\2\2\2u\u019a\3\2\2\2w\u019d\3\2\2\2")
+        buf.write("y\u01a9\3\2\2\2{\u01ab\3\2\2\2}\u01b4\3\2\2\2\177\u01bd")
+        buf.write("\3\2\2\2\u0081\u01c5\3\2\2\2\u0083\u01c9\3\2\2\2\u0085")
+        buf.write("\u01cd\3\2\2\2\u0087\u01d3\3\2\2\2\u0089\u01d5\3\2\2\2")
+        buf.write("\u008b\u01d7\3\2\2\2\u008d\u01d9\3\2\2\2\u008f\u01db\3")
+        buf.write("\2\2\2\u0091\u0092\7k\2\2\u0092\u0093\7p\2\2\u0093\u0094")
+        buf.write("\7v\2\2\u0094\u0095\7:\2\2\u0095\4\3\2\2\2\u0096\u0097")
+        buf.write("\7k\2\2\u0097\u0098\7p\2\2\u0098\u0099\7v\2\2\u0099\u009a")
+        buf.write("\7\63\2\2\u009a\u009b\78\2\2\u009b\6\3\2\2\2\u009c\u009d")
+        buf.write("\7k\2\2\u009d\u009e\7p\2\2\u009e\u009f\7v\2\2\u009f\u00a0")
+        buf.write("\7\65\2\2\u00a0\u00a1\7\64\2\2\u00a1\b\3\2\2\2\u00a2\u00a3")
+        buf.write("\7k\2\2\u00a3\u00a4\7p\2\2\u00a4\u00a5\7v\2\2\u00a5\u00a6")
+        buf.write("\78\2\2\u00a6\u00a7\7\66\2\2\u00a7\n\3\2\2\2\u00a8\u00a9")
+        buf.write("\7w\2\2\u00a9\u00aa\7k\2\2\u00aa\u00ab\7p\2\2\u00ab\u00ac")
+        buf.write("\7v\2\2\u00ac\u00ad\7:\2\2\u00ad\f\3\2\2\2\u00ae\u00af")
+        buf.write("\7w\2\2\u00af\u00b0\7k\2\2\u00b0\u00b1\7p\2\2\u00b1\u00b2")
+        buf.write("\7v\2\2\u00b2\u00b3\7\63\2\2\u00b3\u00b4\78\2\2\u00b4")
+        buf.write("\16\3\2\2\2\u00b5\u00b6\7w\2\2\u00b6\u00b7\7k\2\2\u00b7")
+        buf.write("\u00b8\7p\2\2\u00b8\u00b9\7v\2\2\u00b9\u00ba\7\65\2\2")
+        buf.write("\u00ba\u00bb\7\64\2\2\u00bb\20\3\2\2\2\u00bc\u00bd\7w")
+        buf.write("\2\2\u00bd\u00be\7k\2\2\u00be\u00bf\7p\2\2\u00bf\u00c0")
+        buf.write("\7v\2\2\u00c0\u00c1\78\2\2\u00c1\u00c2\7\66\2\2\u00c2")
+        buf.write("\22\3\2\2\2\u00c3\u00c4\7h\2\2\u00c4\u00c5\7n\2\2\u00c5")
+        buf.write("\u00c6\7q\2\2\u00c6\u00c7\7c\2\2\u00c7\u00c8\7v\2\2\u00c8")
+        buf.write("\u00c9\7\63\2\2\u00c9\u00ca\78\2\2\u00ca\24\3\2\2\2\u00cb")
+        buf.write("\u00cc\7h\2\2\u00cc\u00cd\7n\2\2\u00cd\u00ce\7q\2\2\u00ce")
+        buf.write("\u00cf\7c\2\2\u00cf\u00d0\7v\2\2\u00d0\u00d1\7\65\2\2")
+        buf.write("\u00d1\u00d2\7\64\2\2\u00d2\26\3\2\2\2\u00d3\u00d4\7h")
+        buf.write("\2\2\u00d4\u00d5\7n\2\2\u00d5\u00d6\7q\2\2\u00d6\u00d7")
+        buf.write("\7c\2\2\u00d7\u00d8\7v\2\2\u00d8\u00d9\78\2\2\u00d9\u00da")
+        buf.write("\7\66\2\2\u00da\30\3\2\2\2\u00db\u00dc\7d\2\2\u00dc\u00dd")
+        buf.write("\7q\2\2\u00dd\u00de\7q\2\2\u00de\u00df\7n\2\2\u00df\32")
+        buf.write("\3\2\2\2\u00e0\u00e1\7k\2\2\u00e1\u00e2\7p\2\2\u00e2\u00e3")
+        buf.write("\7v\2\2\u00e3\u00e4\7:\2\2\u00e4\u00e5\7z\2\2\u00e5\u00e6")
+        buf.write("\7\66\2\2\u00e6\34\3\2\2\2\u00e7\u00e8\7w\2\2\u00e8\u00e9")
+        buf.write("\7k\2\2\u00e9\u00ea\7p\2\2\u00ea\u00eb\7v\2\2\u00eb\u00ec")
+        buf.write("\7\63\2\2\u00ec\u00ed\7z\2\2\u00ed\u00ee\7\66\2\2\u00ee")
+        buf.write("\36\3\2\2\2\u00ef\u00f0\7h\2\2\u00f0\u00f1\7n\2\2\u00f1")
+        buf.write("\u00f2\7q\2\2\u00f2\u00f3\7c\2\2\u00f3\u00f4\7v\2\2\u00f4")
+        buf.write("\u00f5\7\63\2\2\u00f5\u00f6\78\2\2\u00f6\u00f7\7z\2\2")
+        buf.write("\u00f7\u00f8\7\66\2\2\u00f8 \3\2\2\2\u00f9\u00fa\7\60")
+        buf.write("\2\2\u00fa\"\3\2\2\2\u00fb\u00fc\7B\2\2\u00fc$\3\2\2\2")
+        buf.write("\u00fd\u00fe\7\'\2\2\u00fe&\3\2\2\2\u00ff\u0100\7a\2\2")
+        buf.write("\u0100(\3\2\2\2\u0101\u0102\7.\2\2\u0102*\3\2\2\2\u0103")
+        buf.write("\u0104\7*\2\2\u0104,\3\2\2\2\u0105\u0106\7+\2\2\u0106")
+        buf.write(".\3\2\2\2\u0107\u0108\7}\2\2\u0108\60\3\2\2\2\u0109\u010a")
+        buf.write("\7\177\2\2\u010a\62\3\2\2\2\u010b\u010c\7]\2\2\u010c\64")
+        buf.write("\3\2\2\2\u010d\u010e\7_\2\2\u010e\66\3\2\2\2\u010f\u0110")
+        buf.write("\7k\2\2\u0110\u0111\7h\2\2\u01118\3\2\2\2\u0112\u0113")
+        buf.write("\7g\2\2\u0113\u0114\7n\2\2\u0114\u0115\7u\2\2\u0115\u0116")
+        buf.write("\7g\2\2\u0116:\3\2\2\2\u0117\u0118\7n\2\2\u0118\u0119")
+        buf.write("\7g\2\2\u0119\u011a\7v\2\2\u011a<\3\2\2\2\u011b\u011c")
+        buf.write("\7?\2\2\u011c>\3\2\2\2\u011d\u011e\7=\2\2\u011e@\3\2\2")
+        buf.write("\2\u011f\u0120\7=\2\2\u0120\u0121\7=\2\2\u0121B\3\2\2")
+        buf.write("\2\u0122\u0123\7h\2\2\u0123\u0124\7p\2\2\u0124D\3\2\2")
+        buf.write("\2\u0125\u0126\7/\2\2\u0126\u0127\7@\2\2\u0127F\3\2\2")
+        buf.write("\2\u0128\u0129\7f\2\2\u0129\u012a\7g\2\2\u012a\u012b\7")
+        buf.write("h\2\2\u012bH\3\2\2\2\u012c\u012d\7v\2\2\u012d\u012e\7")
+        buf.write("{\2\2\u012e\u012f\7r\2\2\u012f\u0130\7g\2\2\u0130J\3\2")
+        buf.write("\2\2\u0131\u0132\7~\2\2\u0132L\3\2\2\2\u0133\u0134\7?")
+        buf.write("\2\2\u0134\u0135\7@\2\2\u0135N\3\2\2\2\u0136\u0137\7o")
+        buf.write("\2\2\u0137\u0138\7c\2\2\u0138\u0139\7v\2\2\u0139\u013a")
+        buf.write("\7e\2\2\u013a\u013b\7j\2\2\u013bP\3\2\2\2\u013c\u013d")
+        buf.write("\7o\2\2\u013d\u013e\7c\2\2\u013e\u013f\7v\2\2\u013f\u0140")
+        buf.write("\7e\2\2\u0140\u0141\7j\2\2\u0141\u0142\7A\2\2\u0142R\3")
+        buf.write("\2\2\2\u0143\u0144\7<\2\2\u0144T\3\2\2\2\u0145\u0146\7")
+        buf.write("V\2\2\u0146\u0147\7g\2\2\u0147\u0148\7p\2\2\u0148\u0149")
+        buf.write("\7u\2\2\u0149\u014a\7q\2\2\u014a\u014b\7t\2\2\u014bV\3")
+        buf.write("\2\2\2\u014c\u014d\7o\2\2\u014d\u014e\7g\2\2\u014e\u014f")
+        buf.write("\7v\2\2\u014f\u0150\7c\2\2\u0150X\3\2\2\2\u0151\u0152")
+        buf.write("\7x\2\2\u0152\u0153\7\62\2\2\u0153\u0154\7\60\2\2\u0154")
+        buf.write("\u0155\7\62\2\2\u0155\u0156\7\60\2\2\u0156\u0157\7\65")
+        buf.write("\2\2\u0157Z\3\2\2\2\u0158\u0159\7\61\2\2\u0159\u015a\7")
+        buf.write(",\2\2\u015a\u015f\3\2\2\2\u015b\u015e\5[.\2\u015c\u015e")
+        buf.write("\13\2\2\2\u015d\u015b\3\2\2\2\u015d\u015c\3\2\2\2\u015e")
+        buf.write("\u0161\3\2\2\2\u015f\u0160\3\2\2\2\u015f\u015d\3\2\2\2")
+        buf.write("\u0160\u0162\3\2\2\2\u0161\u015f\3\2\2\2\u0162\u0163\7")
+        buf.write(",\2\2\u0163\u0164\7\61\2\2\u0164\u0165\3\2\2\2\u0165\u0166")
+        buf.write("\b.\2\2\u0166\\\3\2\2\2\u0167\u0169\t\2\2\2\u0168\u0167")
+        buf.write("\3\2\2\2\u0169\u016a\3\2\2\2\u016a\u0168\3\2\2\2\u016a")
+        buf.write("\u016b\3\2\2\2\u016b\u016c\3\2\2\2\u016c\u016d\b/\2\2")
+        buf.write("\u016d^\3\2\2\2\u016e\u016f\7\61\2\2\u016f\u0170\7\61")
+        buf.write("\2\2\u0170\u0174\3\2\2\2\u0171\u0173\13\2\2\2\u0172\u0171")
+        buf.write("\3\2\2\2\u0173\u0176\3\2\2\2\u0174\u0175\3\2\2\2\u0174")
+        buf.write("\u0172\3\2\2\2\u0175\u0177\3\2\2\2\u0176\u0174\3\2\2\2")
+        buf.write("\u0177\u0178\7\f\2\2\u0178\u0179\3\2\2\2\u0179\u017a\b")
+        buf.write("\60\2\2\u017a`\3\2\2\2\u017b\u017c\7^\2\2\u017c\u017d")
+        buf.write("\7$\2\2\u017db\3\2\2\2\u017e\u0183\7$\2\2\u017f\u0182")
+        buf.write("\5a\61\2\u0180\u0182\n\3\2\2\u0181\u017f\3\2\2\2\u0181")
+        buf.write("\u0180\3\2\2\2\u0182\u0185\3\2\2\2\u0183\u0184\3\2\2\2")
+        buf.write("\u0183\u0181\3\2\2\2\u0184\u0186\3\2\2\2\u0185\u0183\3")
+        buf.write("\2\2\2\u0186\u0187\7$\2\2\u0187d\3\2\2\2\u0188\u0189\7")
+        buf.write(",\2\2\u0189f\3\2\2\2\u018a\u018b\7\61\2\2\u018bh\3\2\2")
+        buf.write("\2\u018c\u018d\7-\2\2\u018dj\3\2\2\2\u018e\u018f\7/\2")
+        buf.write("\2\u018fl\3\2\2\2\u0190\u0191\7>\2\2\u0191n\3\2\2\2\u0192")
+        buf.write("\u0193\7@\2\2\u0193p\3\2\2\2\u0194\u0195\7>\2\2\u0195")
+        buf.write("\u0196\7?\2\2\u0196r\3\2\2\2\u0197\u0198\7@\2\2\u0198")
+        buf.write("\u0199\7?\2\2\u0199t\3\2\2\2\u019a\u019b\7?\2\2\u019b")
+        buf.write("\u019c\7?\2\2\u019cv\3\2\2\2\u019d\u019e\7#\2\2\u019e")
+        buf.write("\u019f\7?\2\2\u019fx\3\2\2\2\u01a0\u01a1\7V\2\2\u01a1")
+        buf.write("\u01a2\7t\2\2\u01a2\u01a3\7w\2\2\u01a3\u01aa\7g\2\2\u01a4")
+        buf.write("\u01a5\7H\2\2\u01a5\u01a6\7c\2\2\u01a6\u01a7\7n\2\2\u01a7")
+        buf.write("\u01a8\7u\2\2\u01a8\u01aa\7g\2\2\u01a9\u01a0\3\2\2\2\u01a9")
+        buf.write("\u01a4\3\2\2\2\u01aaz\3\2\2\2\u01ab\u01b1\5\u0089E\2\u01ac")
+        buf.write("\u01b0\7a\2\2\u01ad\u01b0\5\u008bF\2\u01ae\u01b0\5\u008d")
+        buf.write("G\2\u01af\u01ac\3\2\2\2\u01af\u01ad\3\2\2\2\u01af\u01ae")
+        buf.write("\3\2\2\2\u01b0\u01b3\3\2\2\2\u01b1\u01af\3\2\2\2\u01b1")
+        buf.write("\u01b2\3\2\2\2\u01b2|\3\2\2\2\u01b3\u01b1\3\2\2\2\u01b4")
+        buf.write("\u01ba\5\u0087D\2\u01b5\u01b9\7a\2\2\u01b6\u01b9\5\u008b")
+        buf.write("F\2\u01b7\u01b9\5\u008dG\2\u01b8\u01b5\3\2\2\2\u01b8\u01b6")
+        buf.write("\3\2\2\2\u01b8\u01b7\3\2\2\2\u01b9\u01bc\3\2\2\2\u01ba")
+        buf.write("\u01b8\3\2\2\2\u01ba\u01bb\3\2\2\2\u01bb~\3\2\2\2\u01bc")
+        buf.write("\u01ba\3\2\2\2\u01bd\u01c0\5\u0083B\2\u01be\u01bf\7\60")
+        buf.write("\2\2\u01bf\u01c1\5\u0083B\2\u01c0\u01be\3\2\2\2\u01c0")
+        buf.write("\u01c1\3\2\2\2\u01c1\u01c3\3\2\2\2\u01c2\u01c4\5\u0085")
+        buf.write("C\2\u01c3\u01c2\3\2\2\2\u01c3\u01c4\3\2\2\2\u01c4\u0080")
+        buf.write("\3\2\2\2\u01c5\u01c6\5\177@\2\u01c6\u01c7\7h\2\2\u01c7")
+        buf.write("\u0082\3\2\2\2\u01c8\u01ca\5\u008dG\2\u01c9\u01c8\3\2")
+        buf.write("\2\2\u01ca\u01cb\3\2\2\2\u01cb\u01c9\3\2\2\2\u01cb\u01cc")
+        buf.write("\3\2\2\2\u01cc\u0084\3\2\2\2\u01cd\u01cf\t\4\2\2\u01ce")
+        buf.write("\u01d0\t\5\2\2\u01cf\u01ce\3\2\2\2\u01cf\u01d0\3\2\2\2")
+        buf.write("\u01d0\u01d1\3\2\2\2\u01d1\u01d2\5\u0083B\2\u01d2\u0086")
+        buf.write("\3\2\2\2\u01d3\u01d4\t\6\2\2\u01d4\u0088\3\2\2\2\u01d5")
+        buf.write("\u01d6\t\7\2\2\u01d6\u008a\3\2\2\2\u01d7\u01d8\t\b\2\2")
+        buf.write("\u01d8\u008c\3\2\2\2\u01d9\u01da\t\t\2\2\u01da\u008e\3")
+        buf.write("\2\2\2\u01db\u01dc\7O\2\2\u01dc\u01dd\7G\2\2\u01dd\u01de")
+        buf.write("\7V\2\2\u01de\u01df\7C\2\2\u01df\u01e0\7F\2\2\u01e0\u01e1")
+        buf.write("\7C\2\2\u01e1\u01e2\7V\2\2\u01e2\u01e3\7C\2\2\u01e3\u01e4")
+        buf.write("\7<\2\2\u01e4\u01e8\3\2\2\2\u01e5\u01e7\13\2\2\2\u01e6")
+        buf.write("\u01e5\3\2\2\2\u01e7\u01ea\3\2\2\2\u01e8\u01e6\3\2\2\2")
+        buf.write("\u01e8\u01e9\3\2\2\2\u01e9\u0090\3\2\2\2\u01ea\u01e8\3")
+        buf.write("\2\2\2\23\2\u015d\u015f\u016a\u0174\u0181\u0183\u01a9")
+        buf.write("\u01af\u01b1\u01b8\u01ba\u01c0\u01c3\u01cb\u01cf\u01e8")
+        buf.write("\3\b\2\2")
         return buf.getvalue()
 
 
@@ -202,39 +256,55 @@ class RelayLexer(Lexer):
     T__26 = 27
     T__27 = 28
     T__28 = 29
-    SEMVER = 30
-    COMMENT = 31
-    WS = 32
-    LINE_COMMENT = 33
-    QUOTED_STRING = 34
-    MUL = 35
-    DIV = 36
-    ADD = 37
-    SUB = 38
-    LT = 39
-    GT = 40
-    LE = 41
-    GE = 42
-    EQ = 43
-    NE = 44
-    BOOL_LIT = 45
-    START_UPPER_CNAME = 46
-    START_LOWER_CNAME = 47
-    FLOAT = 48
-    NAT = 49
-    METADATA = 50
+    T__29 = 30
+    T__30 = 31
+    T__31 = 32
+    T__32 = 33
+    T__33 = 34
+    T__34 = 35
+    T__35 = 36
+    T__36 = 37
+    T__37 = 38
+    T__38 = 39
+    T__39 = 40
+    T__40 = 41
+    T__41 = 42
+    T__42 = 43
+    SEMVER = 44
+    COMMENT = 45
+    WS = 46
+    LINE_COMMENT = 47
+    QUOTED_STRING = 48
+    MUL = 49
+    DIV = 50
+    ADD = 51
+    SUB = 52
+    LT = 53
+    GT = 54
+    LE = 55
+    GE = 56
+    EQ = 57
+    NE = 58
+    BOOL_LIT = 59
+    START_UPPER_CNAME = 60
+    START_LOWER_CNAME = 61
+    FLOAT = 62
+    NAT = 63
+    METADATA = 64
 
     channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ]
 
     modeNames = [ "DEFAULT_MODE" ]
 
     literalNames = [ "<INVALID>",
-            "'int32'", "'.'", "'@'", "'%'", "','", "'('", "')'", "'{'", 
-            "'}'", "'['", "']'", "'if'", "'else'", "'let'", "'='", "';'", 
-            "';;'", "'fn'", "'->'", "'def'", "'type'", "'|'", "'=>'", "'match'", 
-            "'match?'", "'_'", "':'", "'Tensor'", "'meta'", "'v0.0.3'", 
-            "'*'", "'/'", "'+'", "'-'", "'<'", "'>'", "'<='", "'>='", "'=='", 
-            "'!='" ]
+            "'int8'", "'int16'", "'int32'", "'int64'", "'uint8'", "'uint16'", 
+            "'uint32'", "'uint64'", "'float16'", "'float32'", "'float64'", 
+            "'bool'", "'int8x4'", "'uint1x4'", "'float16x4'", "'.'", "'@'", 
+            "'%'", "'_'", "','", "'('", "')'", "'{'", "'}'", "'['", "']'", 
+            "'if'", "'else'", "'let'", "'='", "';'", "';;'", "'fn'", "'->'", 
+            "'def'", "'type'", "'|'", "'=>'", "'match'", "'match?'", "':'", 
+            "'Tensor'", "'meta'", "'v0.0.3'", "'*'", "'/'", "'+'", "'-'", 
+            "'<'", "'>'", "'<='", "'>='", "'=='", "'!='" ]
 
     symbolicNames = [ "<INVALID>",
             "SEMVER", "COMMENT", "WS", "LINE_COMMENT", "QUOTED_STRING", 
@@ -246,10 +316,12 @@ class RelayLexer(Lexer):
                   "T__7", "T__8", "T__9", "T__10", "T__11", "T__12", "T__13", 
                   "T__14", "T__15", "T__16", "T__17", "T__18", "T__19", 
                   "T__20", "T__21", "T__22", "T__23", "T__24", "T__25", 
-                  "T__26", "T__27", "T__28", "SEMVER", "COMMENT", "WS", 
-                  "LINE_COMMENT", "ESCAPED_QUOTE", "QUOTED_STRING", "MUL", 
-                  "DIV", "ADD", "SUB", "LT", "GT", "LE", "GE", "EQ", "NE", 
-                  "BOOL_LIT", "START_UPPER_CNAME", "START_LOWER_CNAME", 
+                  "T__26", "T__27", "T__28", "T__29", "T__30", "T__31", 
+                  "T__32", "T__33", "T__34", "T__35", "T__36", "T__37", 
+                  "T__38", "T__39", "T__40", "T__41", "T__42", "SEMVER", 
+                  "COMMENT", "WS", "LINE_COMMENT", "ESCAPED_QUOTE", "QUOTED_STRING", 
+                  "MUL", "DIV", "ADD", "SUB", "LT", "GT", "LE", "GE", "EQ", 
+                  "NE", "BOOL_LIT", "START_UPPER_CNAME", "START_LOWER_CNAME", 
                   "PREFLOAT", "FLOAT", "NAT", "EXP", "LOWER_LETTER", "UPPER_LETTER", 
                   "LETTER", "DIGIT", "METADATA" ]
 
diff --git a/python/tvm/relay/grammar/py3/RelayParser.py b/python/tvm/relay/grammar/py3/RelayParser.py
index c26e0b20f085..bb0b858841da 100644
--- a/python/tvm/relay/grammar/py3/RelayParser.py
+++ b/python/tvm/relay/grammar/py3/RelayParser.py
@@ -8,7 +8,7 @@
 
 def serializedATN():
     with StringIO() as buf:
-        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\64")
+        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3B")
         buf.write("\u01d0\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
         buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
         buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
@@ -49,191 +49,191 @@ def serializedATN():
         buf.write("\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31")
         buf.write("\3\31\3\31\3\31\3\31\5\31\u0184\n\31\3\31\3\31\3\31\3")
         buf.write("\31\7\31\u018a\n\31\f\31\16\31\u018d\13\31\5\31\u018f")
-        buf.write("\n\31\3\31\3\31\3\31\5\31\u0194\n\31\3\32\3\32\3\32\3")
-        buf.write("\32\7\32\u019a\n\32\f\32\16\32\u019d\13\32\3\32\3\32\3")
-        buf.write("\33\3\33\3\33\3\33\6\33\u01a5\n\33\r\33\16\33\u01a6\3")
-        buf.write("\33\3\33\3\33\3\33\3\33\5\33\u01ae\n\33\3\34\3\34\3\34")
-        buf.write("\3\34\3\34\3\34\3\34\3\34\3\35\3\35\3\35\3\35\3\35\3\35")
-        buf.write("\5\35\u01be\n\35\3\36\3\36\3\36\3\36\3\37\3\37\3\37\5")
-        buf.write("\37\u01c7\n\37\3 \3 \3 \3 \3 \5 \u01ce\n \3 \2\3\24!\2")
-        buf.write("\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64")
-        buf.write("\668:<>\2\7\3\2%&\3\2\'(\3\2),\3\2-.\3\2\32\33\2\u01fc")
-        buf.write("\2@\3\2\2\2\4B\3\2\2\2\6Q\3\2\2\2\bY\3\2\2\2\n\\\3\2\2")
-        buf.write("\2\fa\3\2\2\2\16c\3\2\2\2\20n\3\2\2\2\22z\3\2\2\2\24\u00ca")
-        buf.write("\3\2\2\2\26\u00e8\3\2\2\2\30\u010e\3\2\2\2\32\u0110\3")
-        buf.write("\2\2\2\34\u011f\3\2\2\2\36\u0127\3\2\2\2 \u0129\3\2\2")
-        buf.write("\2\"\u013a\3\2\2\2$\u013c\3\2\2\2&\u0148\3\2\2\2(\u0152")
-        buf.write("\3\2\2\2*\u0154\3\2\2\2,\u0159\3\2\2\2.\u0161\3\2\2\2")
-        buf.write("\60\u0193\3\2\2\2\62\u0195\3\2\2\2\64\u01ad\3\2\2\2\66")
-        buf.write("\u01af\3\2\2\28\u01bd\3\2\2\2:\u01bf\3\2\2\2<\u01c6\3")
-        buf.write("\2\2\2>\u01cd\3\2\2\2@A\7\3\2\2A\3\3\2\2\2BJ\7 \2\2CE")
-        buf.write("\5\30\r\2DC\3\2\2\2EH\3\2\2\2FD\3\2\2\2FG\3\2\2\2GK\3")
-        buf.write("\2\2\2HF\3\2\2\2IK\5\24\13\2JF\3\2\2\2JI\3\2\2\2KM\3\2")
-        buf.write("\2\2LN\7\64\2\2ML\3\2\2\2MN\3\2\2\2NO\3\2\2\2OP\7\2\2")
-        buf.write("\3P\5\3\2\2\2QV\7\61\2\2RS\7\4\2\2SU\7\61\2\2TR\3\2\2")
-        buf.write("\2UX\3\2\2\2VT\3\2\2\2VW\3\2\2\2W\7\3\2\2\2XV\3\2\2\2")
-        buf.write("YZ\7\5\2\2Z[\7\61\2\2[\t\3\2\2\2\\]\7\6\2\2]^\7\61\2\2")
-        buf.write("^\13\3\2\2\2_b\5\2\2\2`b\7\60\2\2a_\3\2\2\2a`\3\2\2\2")
-        buf.write("b\r\3\2\2\2cd\7\6\2\2de\7\63\2\2e\17\3\2\2\2fk\5\24\13")
-        buf.write("\2gh\7\7\2\2hj\5\24\13\2ig\3\2\2\2jm\3\2\2\2ki\3\2\2\2")
-        buf.write("kl\3\2\2\2lo\3\2\2\2mk\3\2\2\2nf\3\2\2\2no\3\2\2\2o\21")
-        buf.write("\3\2\2\2p{\5\20\t\2qr\5\24\13\2rs\7\7\2\2su\3\2\2\2tq")
-        buf.write("\3\2\2\2ux\3\2\2\2vt\3\2\2\2vw\3\2\2\2wy\3\2\2\2xv\3\2")
-        buf.write("\2\2y{\5,\27\2zp\3\2\2\2zv\3\2\2\2{\23\3\2\2\2|}\b\13")
-        buf.write("\1\2}~\7\b\2\2~\177\5\24\13\2\177\u0080\7\t\2\2\u0080")
-        buf.write("\u00cb\3\2\2\2\u0081\u0082\7\n\2\2\u0082\u0083\5\24\13")
-        buf.write("\2\u0083\u0084\7\13\2\2\u0084\u00cb\3\2\2\2\u0085\u0086")
-        buf.write("\7(\2\2\u0086\u00cb\5\24\13\26\u0087\u00cb\5\26\f\2\u0088")
-        buf.write("\u0089\7\b\2\2\u0089\u00cb\7\t\2\2\u008a\u008b\7\b\2\2")
-        buf.write("\u008b\u008c\5\24\13\2\u008c\u008d\7\7\2\2\u008d\u008e")
-        buf.write("\7\t\2\2\u008e\u00cb\3\2\2\2\u008f\u0090\7\b\2\2\u0090")
-        buf.write("\u0093\5\24\13\2\u0091\u0092\7\7\2\2\u0092\u0094\5\24")
-        buf.write("\13\2\u0093\u0091\3\2\2\2\u0094\u0095\3\2\2\2\u0095\u0093")
-        buf.write("\3\2\2\2\u0095\u0096\3\2\2\2\u0096\u0097\3\2\2\2\u0097")
-        buf.write("\u0098\7\t\2\2\u0098\u00cb\3\2\2\2\u0099\u00a2\7\f\2\2")
-        buf.write("\u009a\u009f\5\24\13\2\u009b\u009c\7\7\2\2\u009c\u009e")
-        buf.write("\5\24\13\2\u009d\u009b\3\2\2\2\u009e\u00a1\3\2\2\2\u009f")
-        buf.write("\u009d\3\2\2\2\u009f\u00a0\3\2\2\2\u00a0\u00a3\3\2\2\2")
-        buf.write("\u00a1\u009f\3\2\2\2\u00a2\u009a\3\2\2\2\u00a2\u00a3\3")
-        buf.write("\2\2\2\u00a3\u00a4\3\2\2\2\u00a4\u00cb\7\r\2\2\u00a5\u00a6")
-        buf.write("\7\16\2\2\u00a6\u00a7\7\b\2\2\u00a7\u00a8\5\24\13\2\u00a8")
-        buf.write("\u00a9\7\t\2\2\u00a9\u00aa\5:\36\2\u00aa\u00ab\7\17\2")
-        buf.write("\2\u00ab\u00ac\5:\36\2\u00ac\u00cb\3\2\2\2\u00ad\u00ae")
-        buf.write("\5\36\20\2\u00ae\u00af\7\b\2\2\u00af\u00b0\5\24\13\2\u00b0")
-        buf.write("\u00b1\7\t\2\2\u00b1\u00b3\7\n\2\2\u00b2\u00b4\5\34\17")
-        buf.write("\2\u00b3\u00b2\3\2\2\2\u00b4\u00b5\3\2\2\2\u00b5\u00b3")
-        buf.write("\3\2\2\2\u00b5\u00b6\3\2\2\2\u00b6\u00b7\3\2\2\2\u00b7")
-        buf.write("\u00b8\7\13\2\2\u00b8\u00cb\3\2\2\2\u00b9\u00ba\7\20\2")
-        buf.write("\2\u00ba\u00bb\5*\26\2\u00bb\u00bc\7\21\2\2\u00bc\u00bd")
-        buf.write("\5\24\13\2\u00bd\u00be\7\22\2\2\u00be\u00bf\5\24\13\t")
-        buf.write("\u00bf\u00cb\3\2\2\2\u00c0\u00c1\5\16\b\2\u00c1\u00c2")
-        buf.write("\7\21\2\2\u00c2\u00c3\5\24\13\2\u00c3\u00c4\7\22\2\2\u00c4")
-        buf.write("\u00c5\5\24\13\7\u00c5\u00cb\3\2\2\2\u00c6\u00cb\5> \2")
-        buf.write("\u00c7\u00cb\5<\37\2\u00c8\u00cb\5\66\34\2\u00c9\u00cb")
-        buf.write("\7$\2\2\u00ca|\3\2\2\2\u00ca\u0081\3\2\2\2\u00ca\u0085")
-        buf.write("\3\2\2\2\u00ca\u0087\3\2\2\2\u00ca\u0088\3\2\2\2\u00ca")
-        buf.write("\u008a\3\2\2\2\u00ca\u008f\3\2\2\2\u00ca\u0099\3\2\2\2")
-        buf.write("\u00ca\u00a5\3\2\2\2\u00ca\u00ad\3\2\2\2\u00ca\u00b9\3")
-        buf.write("\2\2\2\u00ca\u00c0\3\2\2\2\u00ca\u00c6\3\2\2\2\u00ca\u00c7")
-        buf.write("\3\2\2\2\u00ca\u00c8\3\2\2\2\u00ca\u00c9\3\2\2\2\u00cb")
-        buf.write("\u00e5\3\2\2\2\u00cc\u00cd\f\25\2\2\u00cd\u00ce\t\2\2")
-        buf.write("\2\u00ce\u00e4\5\24\13\26\u00cf\u00d0\f\24\2\2\u00d0\u00d1")
-        buf.write("\t\3\2\2\u00d1\u00e4\5\24\13\25\u00d2\u00d3\f\23\2\2\u00d3")
-        buf.write("\u00d4\t\4\2\2\u00d4\u00e4\5\24\13\24\u00d5\u00d6\f\22")
-        buf.write("\2\2\u00d6\u00d7\t\5\2\2\u00d7\u00e4\5\24\13\23\u00d8")
-        buf.write("\u00d9\f\b\2\2\u00d9\u00da\7\23\2\2\u00da\u00e4\5\24\13")
-        buf.write("\t\u00db\u00dc\f\27\2\2\u00dc\u00dd\7\b\2\2\u00dd\u00de")
-        buf.write("\5\22\n\2\u00de\u00df\7\t\2\2\u00df\u00e4\3\2\2\2\u00e0")
-        buf.write("\u00e1\f\n\2\2\u00e1\u00e2\7\4\2\2\u00e2\u00e4\7\63\2")
-        buf.write("\2\u00e3\u00cc\3\2\2\2\u00e3\u00cf\3\2\2\2\u00e3\u00d2")
-        buf.write("\3\2\2\2\u00e3\u00d5\3\2\2\2\u00e3\u00d8\3\2\2\2\u00e3")
-        buf.write("\u00db\3\2\2\2\u00e3\u00e0\3\2\2\2\u00e4\u00e7\3\2\2\2")
-        buf.write("\u00e5\u00e3\3\2\2\2\u00e5\u00e6\3\2\2\2\u00e6\25\3\2")
-        buf.write("\2\2\u00e7\u00e5\3\2\2\2\u00e8\u00ea\7\24\2\2\u00e9\u00eb")
-        buf.write("\5\62\32\2\u00ea\u00e9\3\2\2\2\u00ea\u00eb\3\2\2\2\u00eb")
-        buf.write("\u00ec\3\2\2\2\u00ec\u00ed\7\b\2\2\u00ed\u00ee\5&\24\2")
-        buf.write("\u00ee\u00f1\7\t\2\2\u00ef\u00f0\7\25\2\2\u00f0\u00f2")
-        buf.write("\5\60\31\2\u00f1\u00ef\3\2\2\2\u00f1\u00f2\3\2\2\2\u00f2")
-        buf.write("\u00f3\3\2\2\2\u00f3\u00f4\5:\36\2\u00f4\27\3\2\2\2\u00f5")
-        buf.write("\u00f6\7\26\2\2\u00f6\u00f8\5\b\5\2\u00f7\u00f9\5\62\32")
-        buf.write("\2\u00f8\u00f7\3\2\2\2\u00f8\u00f9\3\2\2\2\u00f9\u00fa")
-        buf.write("\3\2\2\2\u00fa\u00fb\7\b\2\2\u00fb\u00fc\5&\24\2\u00fc")
-        buf.write("\u00ff\7\t\2\2\u00fd\u00fe\7\25\2\2\u00fe\u0100\5\60\31")
-        buf.write("\2\u00ff\u00fd\3\2\2\2\u00ff\u0100\3\2\2\2\u0100\u0101")
-        buf.write("\3\2\2\2\u0101\u0102\5:\36\2\u0102\u010f\3\2\2\2\u0103")
-        buf.write("\u0104\7\27\2\2\u0104\u0106\5\f\7\2\u0105\u0107\5\62\32")
-        buf.write("\2\u0106\u0105\3\2\2\2\u0106\u0107\3\2\2\2\u0107\u0108")
-        buf.write("\3\2\2\2\u0108\u010a\7\21\2\2\u0109\u010b\5\32\16\2\u010a")
-        buf.write("\u0109\3\2\2\2\u010b\u010c\3\2\2\2\u010c\u010a\3\2\2\2")
-        buf.write("\u010c\u010d\3\2\2\2\u010d\u010f\3\2\2\2\u010e\u00f5\3")
-        buf.write("\2\2\2\u010e\u0103\3\2\2\2\u010f\31\3\2\2\2\u0110\u0111")
-        buf.write("\7\30\2\2\u0111\u011d\5$\23\2\u0112\u0113\7\b\2\2\u0113")
-        buf.write("\u0118\5\60\31\2\u0114\u0115\7\7\2\2\u0115\u0117\5\60")
-        buf.write("\31\2\u0116\u0114\3\2\2\2\u0117\u011a\3\2\2\2\u0118\u0116")
-        buf.write("\3\2\2\2\u0118\u0119\3\2\2\2\u0119\u011b\3\2\2\2\u011a")
-        buf.write("\u0118\3\2\2\2\u011b\u011c\7\t\2\2\u011c\u011e\3\2\2\2")
-        buf.write("\u011d\u0112\3\2\2\2\u011d\u011e\3\2\2\2\u011e\33\3\2")
-        buf.write("\2\2\u011f\u0120\7\30\2\2\u0120\u0122\5$\23\2\u0121\u0123")
-        buf.write("\5 \21\2\u0122\u0121\3\2\2\2\u0122\u0123\3\2\2\2\u0123")
-        buf.write("\u0124\3\2\2\2\u0124\u0125\7\31\2\2\u0125\u0126\5\24\13")
-        buf.write("\2\u0126\35\3\2\2\2\u0127\u0128\t\6\2\2\u0128\37\3\2\2")
-        buf.write("\2\u0129\u012a\7\b\2\2\u012a\u012f\5\"\22\2\u012b\u012c")
-        buf.write("\7\7\2\2\u012c\u012e\5\"\22\2\u012d\u012b\3\2\2\2\u012e")
-        buf.write("\u0131\3\2\2\2\u012f\u012d\3\2\2\2\u012f\u0130\3\2\2\2")
-        buf.write("\u0130\u0132\3\2\2\2\u0131\u012f\3\2\2\2\u0132\u0133\7")
-        buf.write("\t\2\2\u0133!\3\2\2\2\u0134\u013b\7\34\2\2\u0135\u0138")
-        buf.write("\5\n\6\2\u0136\u0137\7\35\2\2\u0137\u0139\5\60\31\2\u0138")
-        buf.write("\u0136\3\2\2\2\u0138\u0139\3\2\2\2\u0139\u013b\3\2\2\2")
-        buf.write("\u013a\u0134\3\2\2\2\u013a\u0135\3\2\2\2\u013b#\3\2\2")
-        buf.write("\2\u013c\u013d\7\60\2\2\u013d%\3\2\2\2\u013e\u0149\5(")
-        buf.write("\25\2\u013f\u0140\5*\26\2\u0140\u0141\7\7\2\2\u0141\u0143")
-        buf.write("\3\2\2\2\u0142\u013f\3\2\2\2\u0143\u0146\3\2\2\2\u0144")
-        buf.write("\u0142\3\2\2\2\u0144\u0145\3\2\2\2\u0145\u0147\3\2\2\2")
-        buf.write("\u0146\u0144\3\2\2\2\u0147\u0149\5,\27\2\u0148\u013e\3")
-        buf.write("\2\2\2\u0148\u0144\3\2\2\2\u0149\'\3\2\2\2\u014a\u014f")
-        buf.write("\5*\26\2\u014b\u014c\7\7\2\2\u014c\u014e\5*\26\2\u014d")
+        buf.write("\n\31\3\31\3\31\3\31\3\31\5\31\u0195\n\31\3\32\3\32\3")
+        buf.write("\32\3\32\7\32\u019b\n\32\f\32\16\32\u019e\13\32\3\32\3")
+        buf.write("\32\3\33\3\33\3\33\3\33\3\33\3\33\6\33\u01a8\n\33\r\33")
+        buf.write("\16\33\u01a9\3\33\3\33\3\33\5\33\u01af\n\33\3\34\3\34")
+        buf.write("\3\34\3\34\3\34\3\34\3\34\3\34\3\35\3\35\3\35\3\35\3\35")
+        buf.write("\3\35\5\35\u01bf\n\35\3\36\3\36\3\36\3\36\3\37\3\37\3")
+        buf.write("\37\5\37\u01c8\n\37\3 \3 \3 \3 \5 \u01ce\n \3 \2\3\24")
+        buf.write("!\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62")
+        buf.write("\64\668:<>\2\t\3\2\3\21\4\2\25\25??\3\2\63\64\3\2\65\66")
+        buf.write("\3\2\67:\3\2;<\3\2)*\2\u01fc\2@\3\2\2\2\4B\3\2\2\2\6Q")
+        buf.write("\3\2\2\2\bY\3\2\2\2\n\\\3\2\2\2\fa\3\2\2\2\16c\3\2\2\2")
+        buf.write("\20n\3\2\2\2\22z\3\2\2\2\24\u00ca\3\2\2\2\26\u00e8\3\2")
+        buf.write("\2\2\30\u010e\3\2\2\2\32\u0110\3\2\2\2\34\u011f\3\2\2")
+        buf.write("\2\36\u0127\3\2\2\2 \u0129\3\2\2\2\"\u013a\3\2\2\2$\u013c")
+        buf.write("\3\2\2\2&\u0148\3\2\2\2(\u0152\3\2\2\2*\u0154\3\2\2\2")
+        buf.write(",\u0159\3\2\2\2.\u0161\3\2\2\2\60\u0194\3\2\2\2\62\u0196")
+        buf.write("\3\2\2\2\64\u01ae\3\2\2\2\66\u01b0\3\2\2\28\u01be\3\2")
+        buf.write("\2\2:\u01c0\3\2\2\2<\u01c7\3\2\2\2>\u01cd\3\2\2\2@A\t")
+        buf.write("\2\2\2A\3\3\2\2\2BJ\7.\2\2CE\5\30\r\2DC\3\2\2\2EH\3\2")
+        buf.write("\2\2FD\3\2\2\2FG\3\2\2\2GK\3\2\2\2HF\3\2\2\2IK\5\24\13")
+        buf.write("\2JF\3\2\2\2JI\3\2\2\2KM\3\2\2\2LN\7B\2\2ML\3\2\2\2MN")
+        buf.write("\3\2\2\2NO\3\2\2\2OP\7\2\2\3P\5\3\2\2\2QV\7?\2\2RS\7\22")
+        buf.write("\2\2SU\7?\2\2TR\3\2\2\2UX\3\2\2\2VT\3\2\2\2VW\3\2\2\2")
+        buf.write("W\7\3\2\2\2XV\3\2\2\2YZ\7\23\2\2Z[\7?\2\2[\t\3\2\2\2\\")
+        buf.write("]\7\24\2\2]^\t\3\2\2^\13\3\2\2\2_b\5\2\2\2`b\7>\2\2a_")
+        buf.write("\3\2\2\2a`\3\2\2\2b\r\3\2\2\2cd\7\24\2\2de\7A\2\2e\17")
+        buf.write("\3\2\2\2fk\5\24\13\2gh\7\26\2\2hj\5\24\13\2ig\3\2\2\2")
+        buf.write("jm\3\2\2\2ki\3\2\2\2kl\3\2\2\2lo\3\2\2\2mk\3\2\2\2nf\3")
+        buf.write("\2\2\2no\3\2\2\2o\21\3\2\2\2p{\5\20\t\2qr\5\24\13\2rs")
+        buf.write("\7\26\2\2su\3\2\2\2tq\3\2\2\2ux\3\2\2\2vt\3\2\2\2vw\3")
+        buf.write("\2\2\2wy\3\2\2\2xv\3\2\2\2y{\5,\27\2zp\3\2\2\2zv\3\2\2")
+        buf.write("\2{\23\3\2\2\2|}\b\13\1\2}~\7\27\2\2~\177\5\24\13\2\177")
+        buf.write("\u0080\7\30\2\2\u0080\u00cb\3\2\2\2\u0081\u0082\7\31\2")
+        buf.write("\2\u0082\u0083\5\24\13\2\u0083\u0084\7\32\2\2\u0084\u00cb")
+        buf.write("\3\2\2\2\u0085\u0086\7\66\2\2\u0086\u00cb\5\24\13\26\u0087")
+        buf.write("\u00cb\5\26\f\2\u0088\u0089\7\27\2\2\u0089\u00cb\7\30")
+        buf.write("\2\2\u008a\u008b\7\27\2\2\u008b\u008c\5\24\13\2\u008c")
+        buf.write("\u008d\7\26\2\2\u008d\u008e\7\30\2\2\u008e\u00cb\3\2\2")
+        buf.write("\2\u008f\u0090\7\27\2\2\u0090\u0093\5\24\13\2\u0091\u0092")
+        buf.write("\7\26\2\2\u0092\u0094\5\24\13\2\u0093\u0091\3\2\2\2\u0094")
+        buf.write("\u0095\3\2\2\2\u0095\u0093\3\2\2\2\u0095\u0096\3\2\2\2")
+        buf.write("\u0096\u0097\3\2\2\2\u0097\u0098\7\30\2\2\u0098\u00cb")
+        buf.write("\3\2\2\2\u0099\u00a2\7\33\2\2\u009a\u009f\5\24\13\2\u009b")
+        buf.write("\u009c\7\26\2\2\u009c\u009e\5\24\13\2\u009d\u009b\3\2")
+        buf.write("\2\2\u009e\u00a1\3\2\2\2\u009f\u009d\3\2\2\2\u009f\u00a0")
+        buf.write("\3\2\2\2\u00a0\u00a3\3\2\2\2\u00a1\u009f\3\2\2\2\u00a2")
+        buf.write("\u009a\3\2\2\2\u00a2\u00a3\3\2\2\2\u00a3\u00a4\3\2\2\2")
+        buf.write("\u00a4\u00cb\7\34\2\2\u00a5\u00a6\7\35\2\2\u00a6\u00a7")
+        buf.write("\7\27\2\2\u00a7\u00a8\5\24\13\2\u00a8\u00a9\7\30\2\2\u00a9")
+        buf.write("\u00aa\5:\36\2\u00aa\u00ab\7\36\2\2\u00ab\u00ac\5:\36")
+        buf.write("\2\u00ac\u00cb\3\2\2\2\u00ad\u00ae\5\36\20\2\u00ae\u00af")
+        buf.write("\7\27\2\2\u00af\u00b0\5\24\13\2\u00b0\u00b1\7\30\2\2\u00b1")
+        buf.write("\u00b3\7\31\2\2\u00b2\u00b4\5\34\17\2\u00b3\u00b2\3\2")
+        buf.write("\2\2\u00b4\u00b5\3\2\2\2\u00b5\u00b3\3\2\2\2\u00b5\u00b6")
+        buf.write("\3\2\2\2\u00b6\u00b7\3\2\2\2\u00b7\u00b8\7\32\2\2\u00b8")
+        buf.write("\u00cb\3\2\2\2\u00b9\u00ba\7\37\2\2\u00ba\u00bb\5*\26")
+        buf.write("\2\u00bb\u00bc\7 \2\2\u00bc\u00bd\5\24\13\2\u00bd\u00be")
+        buf.write("\7!\2\2\u00be\u00bf\5\24\13\t\u00bf\u00cb\3\2\2\2\u00c0")
+        buf.write("\u00c1\5\16\b\2\u00c1\u00c2\7 \2\2\u00c2\u00c3\5\24\13")
+        buf.write("\2\u00c3\u00c4\7!\2\2\u00c4\u00c5\5\24\13\7\u00c5\u00cb")
+        buf.write("\3\2\2\2\u00c6\u00cb\5> \2\u00c7\u00cb\5<\37\2\u00c8\u00cb")
+        buf.write("\5\66\34\2\u00c9\u00cb\7\62\2\2\u00ca|\3\2\2\2\u00ca\u0081")
+        buf.write("\3\2\2\2\u00ca\u0085\3\2\2\2\u00ca\u0087\3\2\2\2\u00ca")
+        buf.write("\u0088\3\2\2\2\u00ca\u008a\3\2\2\2\u00ca\u008f\3\2\2\2")
+        buf.write("\u00ca\u0099\3\2\2\2\u00ca\u00a5\3\2\2\2\u00ca\u00ad\3")
+        buf.write("\2\2\2\u00ca\u00b9\3\2\2\2\u00ca\u00c0\3\2\2\2\u00ca\u00c6")
+        buf.write("\3\2\2\2\u00ca\u00c7\3\2\2\2\u00ca\u00c8\3\2\2\2\u00ca")
+        buf.write("\u00c9\3\2\2\2\u00cb\u00e5\3\2\2\2\u00cc\u00cd\f\25\2")
+        buf.write("\2\u00cd\u00ce\t\4\2\2\u00ce\u00e4\5\24\13\26\u00cf\u00d0")
+        buf.write("\f\24\2\2\u00d0\u00d1\t\5\2\2\u00d1\u00e4\5\24\13\25\u00d2")
+        buf.write("\u00d3\f\23\2\2\u00d3\u00d4\t\6\2\2\u00d4\u00e4\5\24\13")
+        buf.write("\24\u00d5\u00d6\f\22\2\2\u00d6\u00d7\t\7\2\2\u00d7\u00e4")
+        buf.write("\5\24\13\23\u00d8\u00d9\f\b\2\2\u00d9\u00da\7\"\2\2\u00da")
+        buf.write("\u00e4\5\24\13\t\u00db\u00dc\f\27\2\2\u00dc\u00dd\7\27")
+        buf.write("\2\2\u00dd\u00de\5\22\n\2\u00de\u00df\7\30\2\2\u00df\u00e4")
+        buf.write("\3\2\2\2\u00e0\u00e1\f\n\2\2\u00e1\u00e2\7\22\2\2\u00e2")
+        buf.write("\u00e4\7A\2\2\u00e3\u00cc\3\2\2\2\u00e3\u00cf\3\2\2\2")
+        buf.write("\u00e3\u00d2\3\2\2\2\u00e3\u00d5\3\2\2\2\u00e3\u00d8\3")
+        buf.write("\2\2\2\u00e3\u00db\3\2\2\2\u00e3\u00e0\3\2\2\2\u00e4\u00e7")
+        buf.write("\3\2\2\2\u00e5\u00e3\3\2\2\2\u00e5\u00e6\3\2\2\2\u00e6")
+        buf.write("\25\3\2\2\2\u00e7\u00e5\3\2\2\2\u00e8\u00ea\7#\2\2\u00e9")
+        buf.write("\u00eb\5\62\32\2\u00ea\u00e9\3\2\2\2\u00ea\u00eb\3\2\2")
+        buf.write("\2\u00eb\u00ec\3\2\2\2\u00ec\u00ed\7\27\2\2\u00ed\u00ee")
+        buf.write("\5&\24\2\u00ee\u00f1\7\30\2\2\u00ef\u00f0\7$\2\2\u00f0")
+        buf.write("\u00f2\5\60\31\2\u00f1\u00ef\3\2\2\2\u00f1\u00f2\3\2\2")
+        buf.write("\2\u00f2\u00f3\3\2\2\2\u00f3\u00f4\5:\36\2\u00f4\27\3")
+        buf.write("\2\2\2\u00f5\u00f6\7%\2\2\u00f6\u00f8\5\b\5\2\u00f7\u00f9")
+        buf.write("\5\62\32\2\u00f8\u00f7\3\2\2\2\u00f8\u00f9\3\2\2\2\u00f9")
+        buf.write("\u00fa\3\2\2\2\u00fa\u00fb\7\27\2\2\u00fb\u00fc\5&\24")
+        buf.write("\2\u00fc\u00ff\7\30\2\2\u00fd\u00fe\7$\2\2\u00fe\u0100")
+        buf.write("\5\60\31\2\u00ff\u00fd\3\2\2\2\u00ff\u0100\3\2\2\2\u0100")
+        buf.write("\u0101\3\2\2\2\u0101\u0102\5:\36\2\u0102\u010f\3\2\2\2")
+        buf.write("\u0103\u0104\7&\2\2\u0104\u0106\5\f\7\2\u0105\u0107\5")
+        buf.write("\62\32\2\u0106\u0105\3\2\2\2\u0106\u0107\3\2\2\2\u0107")
+        buf.write("\u0108\3\2\2\2\u0108\u010a\7 \2\2\u0109\u010b\5\32\16")
+        buf.write("\2\u010a\u0109\3\2\2\2\u010b\u010c\3\2\2\2\u010c\u010a")
+        buf.write("\3\2\2\2\u010c\u010d\3\2\2\2\u010d\u010f\3\2\2\2\u010e")
+        buf.write("\u00f5\3\2\2\2\u010e\u0103\3\2\2\2\u010f\31\3\2\2\2\u0110")
+        buf.write("\u0111\7\'\2\2\u0111\u011d\5$\23\2\u0112\u0113\7\27\2")
+        buf.write("\2\u0113\u0118\5\60\31\2\u0114\u0115\7\26\2\2\u0115\u0117")
+        buf.write("\5\60\31\2\u0116\u0114\3\2\2\2\u0117\u011a\3\2\2\2\u0118")
+        buf.write("\u0116\3\2\2\2\u0118\u0119\3\2\2\2\u0119\u011b\3\2\2\2")
+        buf.write("\u011a\u0118\3\2\2\2\u011b\u011c\7\30\2\2\u011c\u011e")
+        buf.write("\3\2\2\2\u011d\u0112\3\2\2\2\u011d\u011e\3\2\2\2\u011e")
+        buf.write("\33\3\2\2\2\u011f\u0120\7\'\2\2\u0120\u0122\5$\23\2\u0121")
+        buf.write("\u0123\5 \21\2\u0122\u0121\3\2\2\2\u0122\u0123\3\2\2\2")
+        buf.write("\u0123\u0124\3\2\2\2\u0124\u0125\7(\2\2\u0125\u0126\5")
+        buf.write("\24\13\2\u0126\35\3\2\2\2\u0127\u0128\t\b\2\2\u0128\37")
+        buf.write("\3\2\2\2\u0129\u012a\7\27\2\2\u012a\u012f\5\"\22\2\u012b")
+        buf.write("\u012c\7\26\2\2\u012c\u012e\5\"\22\2\u012d\u012b\3\2\2")
+        buf.write("\2\u012e\u0131\3\2\2\2\u012f\u012d\3\2\2\2\u012f\u0130")
+        buf.write("\3\2\2\2\u0130\u0132\3\2\2\2\u0131\u012f\3\2\2\2\u0132")
+        buf.write("\u0133\7\30\2\2\u0133!\3\2\2\2\u0134\u013b\7\25\2\2\u0135")
+        buf.write("\u0138\5\n\6\2\u0136\u0137\7+\2\2\u0137\u0139\5\60\31")
+        buf.write("\2\u0138\u0136\3\2\2\2\u0138\u0139\3\2\2\2\u0139\u013b")
+        buf.write("\3\2\2\2\u013a\u0134\3\2\2\2\u013a\u0135\3\2\2\2\u013b")
+        buf.write("#\3\2\2\2\u013c\u013d\7>\2\2\u013d%\3\2\2\2\u013e\u0149")
+        buf.write("\5(\25\2\u013f\u0140\5*\26\2\u0140\u0141\7\26\2\2\u0141")
+        buf.write("\u0143\3\2\2\2\u0142\u013f\3\2\2\2\u0143\u0146\3\2\2\2")
+        buf.write("\u0144\u0142\3\2\2\2\u0144\u0145\3\2\2\2\u0145\u0147\3")
+        buf.write("\2\2\2\u0146\u0144\3\2\2\2\u0147\u0149\5,\27\2\u0148\u013e")
+        buf.write("\3\2\2\2\u0148\u0144\3\2\2\2\u0149\'\3\2\2\2\u014a\u014f")
+        buf.write("\5*\26\2\u014b\u014c\7\26\2\2\u014c\u014e\5*\26\2\u014d")
         buf.write("\u014b\3\2\2\2\u014e\u0151\3\2\2\2\u014f\u014d\3\2\2\2")
         buf.write("\u014f\u0150\3\2\2\2\u0150\u0153\3\2\2\2\u0151\u014f\3")
         buf.write("\2\2\2\u0152\u014a\3\2\2\2\u0152\u0153\3\2\2\2\u0153)")
-        buf.write("\3\2\2\2\u0154\u0157\5\n\6\2\u0155\u0156\7\35\2\2\u0156")
+        buf.write("\3\2\2\2\u0154\u0157\5\n\6\2\u0155\u0156\7+\2\2\u0156")
         buf.write("\u0158\5\60\31\2\u0157\u0155\3\2\2\2\u0157\u0158\3\2\2")
-        buf.write("\2\u0158+\3\2\2\2\u0159\u015e\5.\30\2\u015a\u015b\7\7")
+        buf.write("\2\u0158+\3\2\2\2\u0159\u015e\5.\30\2\u015a\u015b\7\26")
         buf.write("\2\2\u015b\u015d\5.\30\2\u015c\u015a\3\2\2\2\u015d\u0160")
         buf.write("\3\2\2\2\u015e\u015c\3\2\2\2\u015e\u015f\3\2\2\2\u015f")
-        buf.write("-\3\2\2\2\u0160\u015e\3\2\2\2\u0161\u0162\7\61\2\2\u0162")
-        buf.write("\u0163\7\21\2\2\u0163\u0164\5\24\13\2\u0164/\3\2\2\2\u0165")
-        buf.write("\u0166\7\b\2\2\u0166\u0194\7\t\2\2\u0167\u0168\7\b\2\2")
-        buf.write("\u0168\u0169\5\60\31\2\u0169\u016a\7\7\2\2\u016a\u016b")
-        buf.write("\7\t\2\2\u016b\u0194\3\2\2\2\u016c\u016d\7\b\2\2\u016d")
-        buf.write("\u0170\5\60\31\2\u016e\u016f\7\7\2\2\u016f\u0171\5\60")
-        buf.write("\31\2\u0170\u016e\3\2\2\2\u0171\u0172\3\2\2\2\u0172\u0170")
-        buf.write("\3\2\2\2\u0172\u0173\3\2\2\2\u0173\u0174\3\2\2\2\u0174")
-        buf.write("\u0175\7\t\2\2\u0175\u0194\3\2\2\2\u0176\u0177\5\f\7\2")
-        buf.write("\u0177\u0178\5\62\32\2\u0178\u0194\3\2\2\2\u0179\u0194")
-        buf.write("\5\f\7\2\u017a\u017b\7\36\2\2\u017b\u017c\7\f\2\2\u017c")
-        buf.write("\u017d\5\64\33\2\u017d\u017e\7\7\2\2\u017e\u017f\5\60")
-        buf.write("\31\2\u017f\u0180\7\r\2\2\u0180\u0194\3\2\2\2\u0181\u0183")
-        buf.write("\7\24\2\2\u0182\u0184\5\62\32\2\u0183\u0182\3\2\2\2\u0183")
-        buf.write("\u0184\3\2\2\2\u0184\u0185\3\2\2\2\u0185\u018e\7\b\2\2")
-        buf.write("\u0186\u018b\5\60\31\2\u0187\u0188\7\7\2\2\u0188\u018a")
-        buf.write("\5\60\31\2\u0189\u0187\3\2\2\2\u018a\u018d\3\2\2\2\u018b")
-        buf.write("\u0189\3\2\2\2\u018b\u018c\3\2\2\2\u018c\u018f\3\2\2\2")
-        buf.write("\u018d\u018b\3\2\2\2\u018e\u0186\3\2\2\2\u018e\u018f\3")
-        buf.write("\2\2\2\u018f\u0190\3\2\2\2\u0190\u0191\7\t\2\2\u0191\u0192")
-        buf.write("\7\25\2\2\u0192\u0194\5\60\31\2\u0193\u0165\3\2\2\2\u0193")
-        buf.write("\u0167\3\2\2\2\u0193\u016c\3\2\2\2\u0193\u0176\3\2\2\2")
-        buf.write("\u0193\u0179\3\2\2\2\u0193\u017a\3\2\2\2\u0193\u0181\3")
-        buf.write("\2\2\2\u0194\61\3\2\2\2\u0195\u0196\7\f\2\2\u0196\u019b")
-        buf.write("\5\f\7\2\u0197\u0198\7\7\2\2\u0198\u019a\5\f\7\2\u0199")
-        buf.write("\u0197\3\2\2\2\u019a\u019d\3\2\2\2\u019b\u0199\3\2\2\2")
-        buf.write("\u019b\u019c\3\2\2\2\u019c\u019e\3\2\2\2\u019d\u019b\3")
-        buf.write("\2\2\2\u019e\u019f\7\r\2\2\u019f\63\3\2\2\2\u01a0\u01a1")
-        buf.write("\7\b\2\2\u01a1\u01a4\58\35\2\u01a2\u01a3\7\7\2\2\u01a3")
-        buf.write("\u01a5\58\35\2\u01a4\u01a2\3\2\2\2\u01a5\u01a6\3\2\2\2")
-        buf.write("\u01a6\u01a4\3\2\2\2\u01a6\u01a7\3\2\2\2\u01a7\u01a8\3")
-        buf.write("\2\2\2\u01a8\u01a9\7\t\2\2\u01a9\u01ae\3\2\2\2\u01aa\u01ab")
-        buf.write("\7\b\2\2\u01ab\u01ae\7\t\2\2\u01ac\u01ae\58\35\2\u01ad")
-        buf.write("\u01a0\3\2\2\2\u01ad\u01aa\3\2\2\2\u01ad\u01ac\3\2\2\2")
-        buf.write("\u01ae\65\3\2\2\2\u01af\u01b0\7\37\2\2\u01b0\u01b1\7\f")
-        buf.write("\2\2\u01b1\u01b2\7\61\2\2\u01b2\u01b3\7\r\2\2\u01b3\u01b4")
-        buf.write("\7\f\2\2\u01b4\u01b5\7\63\2\2\u01b5\u01b6\7\r\2\2\u01b6")
-        buf.write("\67\3\2\2\2\u01b7\u01be\5\66\34\2\u01b8\u01b9\7\b\2\2")
-        buf.write("\u01b9\u01ba\58\35\2\u01ba\u01bb\7\t\2\2\u01bb\u01be\3")
-        buf.write("\2\2\2\u01bc\u01be\7\63\2\2\u01bd\u01b7\3\2\2\2\u01bd")
-        buf.write("\u01b8\3\2\2\2\u01bd\u01bc\3\2\2\2\u01be9\3\2\2\2\u01bf")
-        buf.write("\u01c0\7\n\2\2\u01c0\u01c1\5\24\13\2\u01c1\u01c2\7\13")
-        buf.write("\2\2\u01c2;\3\2\2\2\u01c3\u01c7\7\62\2\2\u01c4\u01c7\7")
-        buf.write("\63\2\2\u01c5\u01c7\7/\2\2\u01c6\u01c3\3\2\2\2\u01c6\u01c4")
-        buf.write("\3\2\2\2\u01c6\u01c5\3\2\2\2\u01c7=\3\2\2\2\u01c8\u01ce")
-        buf.write("\5\6\4\2\u01c9\u01ce\5\b\5\2\u01ca\u01ce\5\n\6\2\u01cb")
-        buf.write("\u01ce\5\60\31\2\u01cc\u01ce\5\16\b\2\u01cd\u01c8\3\2")
-        buf.write("\2\2\u01cd\u01c9\3\2\2\2\u01cd\u01ca\3\2\2\2\u01cd\u01cb")
-        buf.write("\3\2\2\2\u01cd\u01cc\3\2\2\2\u01ce?\3\2\2\2\60FJMVakn")
-        buf.write("vz\u0095\u009f\u00a2\u00b5\u00ca\u00e3\u00e5\u00ea\u00f1")
-        buf.write("\u00f8\u00ff\u0106\u010c\u010e\u0118\u011d\u0122\u012f")
-        buf.write("\u0138\u013a\u0144\u0148\u014f\u0152\u0157\u015e\u0172")
-        buf.write("\u0183\u018b\u018e\u0193\u019b\u01a6\u01ad\u01bd\u01c6")
-        buf.write("\u01cd")
+        buf.write("-\3\2\2\2\u0160\u015e\3\2\2\2\u0161\u0162\7?\2\2\u0162")
+        buf.write("\u0163\7 \2\2\u0163\u0164\5\24\13\2\u0164/\3\2\2\2\u0165")
+        buf.write("\u0166\7\27\2\2\u0166\u0195\7\30\2\2\u0167\u0168\7\27")
+        buf.write("\2\2\u0168\u0169\5\60\31\2\u0169\u016a\7\26\2\2\u016a")
+        buf.write("\u016b\7\30\2\2\u016b\u0195\3\2\2\2\u016c\u016d\7\27\2")
+        buf.write("\2\u016d\u0170\5\60\31\2\u016e\u016f\7\26\2\2\u016f\u0171")
+        buf.write("\5\60\31\2\u0170\u016e\3\2\2\2\u0171\u0172\3\2\2\2\u0172")
+        buf.write("\u0170\3\2\2\2\u0172\u0173\3\2\2\2\u0173\u0174\3\2\2\2")
+        buf.write("\u0174\u0175\7\30\2\2\u0175\u0195\3\2\2\2\u0176\u0177")
+        buf.write("\5\f\7\2\u0177\u0178\5\62\32\2\u0178\u0195\3\2\2\2\u0179")
+        buf.write("\u0195\5\f\7\2\u017a\u017b\7,\2\2\u017b\u017c\7\33\2\2")
+        buf.write("\u017c\u017d\5\64\33\2\u017d\u017e\7\26\2\2\u017e\u017f")
+        buf.write("\5\60\31\2\u017f\u0180\7\34\2\2\u0180\u0195\3\2\2\2\u0181")
+        buf.write("\u0183\7#\2\2\u0182\u0184\5\62\32\2\u0183\u0182\3\2\2")
+        buf.write("\2\u0183\u0184\3\2\2\2\u0184\u0185\3\2\2\2\u0185\u018e")
+        buf.write("\7\27\2\2\u0186\u018b\5\60\31\2\u0187\u0188\7\26\2\2\u0188")
+        buf.write("\u018a\5\60\31\2\u0189\u0187\3\2\2\2\u018a\u018d\3\2\2")
+        buf.write("\2\u018b\u0189\3\2\2\2\u018b\u018c\3\2\2\2\u018c\u018f")
+        buf.write("\3\2\2\2\u018d\u018b\3\2\2\2\u018e\u0186\3\2\2\2\u018e")
+        buf.write("\u018f\3\2\2\2\u018f\u0190\3\2\2\2\u0190\u0191\7\30\2")
+        buf.write("\2\u0191\u0192\7$\2\2\u0192\u0195\5\60\31\2\u0193\u0195")
+        buf.write("\7\25\2\2\u0194\u0165\3\2\2\2\u0194\u0167\3\2\2\2\u0194")
+        buf.write("\u016c\3\2\2\2\u0194\u0176\3\2\2\2\u0194\u0179\3\2\2\2")
+        buf.write("\u0194\u017a\3\2\2\2\u0194\u0181\3\2\2\2\u0194\u0193\3")
+        buf.write("\2\2\2\u0195\61\3\2\2\2\u0196\u0197\7\33\2\2\u0197\u019c")
+        buf.write("\5\f\7\2\u0198\u0199\7\26\2\2\u0199\u019b\5\f\7\2\u019a")
+        buf.write("\u0198\3\2\2\2\u019b\u019e\3\2\2\2\u019c\u019a\3\2\2\2")
+        buf.write("\u019c\u019d\3\2\2\2\u019d\u019f\3\2\2\2\u019e\u019c\3")
+        buf.write("\2\2\2\u019f\u01a0\7\34\2\2\u01a0\63\3\2\2\2\u01a1\u01a2")
+        buf.write("\7\27\2\2\u01a2\u01af\7\30\2\2\u01a3\u01a4\7\27\2\2\u01a4")
+        buf.write("\u01a7\58\35\2\u01a5\u01a6\7\26\2\2\u01a6\u01a8\58\35")
+        buf.write("\2\u01a7\u01a5\3\2\2\2\u01a8\u01a9\3\2\2\2\u01a9\u01a7")
+        buf.write("\3\2\2\2\u01a9\u01aa\3\2\2\2\u01aa\u01ab\3\2\2\2\u01ab")
+        buf.write("\u01ac\7\30\2\2\u01ac\u01af\3\2\2\2\u01ad\u01af\58\35")
+        buf.write("\2\u01ae\u01a1\3\2\2\2\u01ae\u01a3\3\2\2\2\u01ae\u01ad")
+        buf.write("\3\2\2\2\u01af\65\3\2\2\2\u01b0\u01b1\7-\2\2\u01b1\u01b2")
+        buf.write("\7\33\2\2\u01b2\u01b3\7?\2\2\u01b3\u01b4\7\34\2\2\u01b4")
+        buf.write("\u01b5\7\33\2\2\u01b5\u01b6\7A\2\2\u01b6\u01b7\7\34\2")
+        buf.write("\2\u01b7\67\3\2\2\2\u01b8\u01bf\5\66\34\2\u01b9\u01ba")
+        buf.write("\7\27\2\2\u01ba\u01bb\58\35\2\u01bb\u01bc\7\30\2\2\u01bc")
+        buf.write("\u01bf\3\2\2\2\u01bd\u01bf\7A\2\2\u01be\u01b8\3\2\2\2")
+        buf.write("\u01be\u01b9\3\2\2\2\u01be\u01bd\3\2\2\2\u01bf9\3\2\2")
+        buf.write("\2\u01c0\u01c1\7\31\2\2\u01c1\u01c2\5\24\13\2\u01c2\u01c3")
+        buf.write("\7\32\2\2\u01c3;\3\2\2\2\u01c4\u01c8\7@\2\2\u01c5\u01c8")
+        buf.write("\7A\2\2\u01c6\u01c8\7=\2\2\u01c7\u01c4\3\2\2\2\u01c7\u01c5")
+        buf.write("\3\2\2\2\u01c7\u01c6\3\2\2\2\u01c8=\3\2\2\2\u01c9\u01ce")
+        buf.write("\5\6\4\2\u01ca\u01ce\5\b\5\2\u01cb\u01ce\5\n\6\2\u01cc")
+        buf.write("\u01ce\5\16\b\2\u01cd\u01c9\3\2\2\2\u01cd\u01ca\3\2\2")
+        buf.write("\2\u01cd\u01cb\3\2\2\2\u01cd\u01cc\3\2\2\2\u01ce?\3\2")
+        buf.write("\2\2\60FJMVaknvz\u0095\u009f\u00a2\u00b5\u00ca\u00e3\u00e5")
+        buf.write("\u00ea\u00f1\u00f8\u00ff\u0106\u010c\u010e\u0118\u011d")
+        buf.write("\u0122\u012f\u0138\u013a\u0144\u0148\u014f\u0152\u0157")
+        buf.write("\u015e\u0172\u0183\u018b\u018e\u0194\u019c\u01a9\u01ae")
+        buf.write("\u01be\u01c7\u01cd")
         return buf.getvalue()
 
 
@@ -247,14 +247,16 @@ class RelayParser ( Parser ):
 
     sharedContextCache = PredictionContextCache()
 
-    literalNames = [ "<INVALID>", "'int32'", "'.'", "'@'", "'%'", "','", 
-                     "'('", "')'", "'{'", "'}'", "'['", "']'", "'if'", "'else'", 
+    literalNames = [ "<INVALID>", "'int8'", "'int16'", "'int32'", "'int64'", 
+                     "'uint8'", "'uint16'", "'uint32'", "'uint64'", "'float16'", 
+                     "'float32'", "'float64'", "'bool'", "'int8x4'", "'uint1x4'", 
+                     "'float16x4'", "'.'", "'@'", "'%'", "'_'", "','", "'('", 
+                     "')'", "'{'", "'}'", "'['", "']'", "'if'", "'else'", 
                      "'let'", "'='", "';'", "';;'", "'fn'", "'->'", "'def'", 
-                     "'type'", "'|'", "'=>'", "'match'", "'match?'", "'_'", 
-                     "':'", "'Tensor'", "'meta'", "'v0.0.3'", "<INVALID>", 
-                     "<INVALID>", "<INVALID>", "<INVALID>", "'*'", "'/'", 
-                     "'+'", "'-'", "'<'", "'>'", "'<='", "'>='", "'=='", 
-                     "'!='" ]
+                     "'type'", "'|'", "'=>'", "'match'", "'match?'", "':'", 
+                     "'Tensor'", "'meta'", "'v0.0.3'", "<INVALID>", "<INVALID>", 
+                     "<INVALID>", "<INVALID>", "'*'", "'/'", "'+'", "'-'", 
+                     "'<'", "'>'", "'<='", "'>='", "'=='", "'!='" ]
 
     symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
@@ -263,11 +265,14 @@ class RelayParser ( Parser ):
                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
-                      "<INVALID>", "<INVALID>", "SEMVER", "COMMENT", "WS", 
-                      "LINE_COMMENT", "QUOTED_STRING", "MUL", "DIV", "ADD", 
-                      "SUB", "LT", "GT", "LE", "GE", "EQ", "NE", "BOOL_LIT", 
-                      "START_UPPER_CNAME", "START_LOWER_CNAME", "FLOAT", 
-                      "NAT", "METADATA" ]
+                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
+                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
+                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
+                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
+                      "SEMVER", "COMMENT", "WS", "LINE_COMMENT", "QUOTED_STRING", 
+                      "MUL", "DIV", "ADD", "SUB", "LT", "GT", "LE", "GE", 
+                      "EQ", "NE", "BOOL_LIT", "START_UPPER_CNAME", "START_LOWER_CNAME", 
+                      "FLOAT", "NAT", "METADATA" ]
 
     RULE_baseType = 0
     RULE_prog = 1
@@ -338,27 +343,41 @@ class RelayParser ( Parser ):
     T__26=27
     T__27=28
     T__28=29
-    SEMVER=30
-    COMMENT=31
-    WS=32
-    LINE_COMMENT=33
-    QUOTED_STRING=34
-    MUL=35
-    DIV=36
-    ADD=37
-    SUB=38
-    LT=39
-    GT=40
-    LE=41
-    GE=42
-    EQ=43
-    NE=44
-    BOOL_LIT=45
-    START_UPPER_CNAME=46
-    START_LOWER_CNAME=47
-    FLOAT=48
-    NAT=49
-    METADATA=50
+    T__29=30
+    T__30=31
+    T__31=32
+    T__32=33
+    T__33=34
+    T__34=35
+    T__35=36
+    T__36=37
+    T__37=38
+    T__38=39
+    T__39=40
+    T__40=41
+    T__41=42
+    T__42=43
+    SEMVER=44
+    COMMENT=45
+    WS=46
+    LINE_COMMENT=47
+    QUOTED_STRING=48
+    MUL=49
+    DIV=50
+    ADD=51
+    SUB=52
+    LT=53
+    GT=54
+    LE=55
+    GE=56
+    EQ=57
+    NE=58
+    BOOL_LIT=59
+    START_UPPER_CNAME=60
+    START_LOWER_CNAME=61
+    FLOAT=62
+    NAT=63
+    METADATA=64
 
     def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
         super().__init__(input, output)
@@ -392,10 +411,16 @@ def baseType(self):
 
         localctx = RelayParser.BaseTypeContext(self, self._ctx, self.state)
         self.enterRule(localctx, 0, self.RULE_baseType)
+        self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
             self.state = 62
-            self.match(RelayParser.T__0)
+            _la = self._input.LA(1)
+            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__0) | (1 << RelayParser.T__1) | (1 << RelayParser.T__2) | (1 << RelayParser.T__3) | (1 << RelayParser.T__4) | (1 << RelayParser.T__5) | (1 << RelayParser.T__6) | (1 << RelayParser.T__7) | (1 << RelayParser.T__8) | (1 << RelayParser.T__9) | (1 << RelayParser.T__10) | (1 << RelayParser.T__11) | (1 << RelayParser.T__12) | (1 << RelayParser.T__13) | (1 << RelayParser.T__14))) != 0)):
+                self._errHandler.recoverInline(self)
+            else:
+                self._errHandler.reportMatch(self)
+                self.consume()
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -455,11 +480,11 @@ def prog(self):
             self.state = 72
             self._errHandler.sync(self)
             token = self._input.LA(1)
-            if token in [RelayParser.EOF, RelayParser.T__19, RelayParser.T__20, RelayParser.METADATA]:
+            if token in [RelayParser.EOF, RelayParser.T__34, RelayParser.T__35, RelayParser.METADATA]:
                 self.state = 68
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                while _la==RelayParser.T__19 or _la==RelayParser.T__20:
+                while _la==RelayParser.T__34 or _la==RelayParser.T__35:
                     self.state = 65
                     self.defn()
                     self.state = 70
@@ -467,7 +492,7 @@ def prog(self):
                     _la = self._input.LA(1)
 
                 pass
-            elif token in [RelayParser.T__0, RelayParser.T__2, RelayParser.T__3, RelayParser.T__5, RelayParser.T__7, RelayParser.T__9, RelayParser.T__11, RelayParser.T__13, RelayParser.T__17, RelayParser.T__23, RelayParser.T__24, RelayParser.T__27, RelayParser.T__28, RelayParser.QUOTED_STRING, RelayParser.SUB, RelayParser.BOOL_LIT, RelayParser.START_UPPER_CNAME, RelayParser.START_LOWER_CNAME, RelayParser.FLOAT, RelayParser.NAT]:
+            elif token in [RelayParser.T__16, RelayParser.T__17, RelayParser.T__20, RelayParser.T__22, RelayParser.T__24, RelayParser.T__26, RelayParser.T__28, RelayParser.T__32, RelayParser.T__38, RelayParser.T__39, RelayParser.T__42, RelayParser.QUOTED_STRING, RelayParser.SUB, RelayParser.BOOL_LIT, RelayParser.START_LOWER_CNAME, RelayParser.FLOAT, RelayParser.NAT]:
                 self.state = 71
                 self.expr(0)
                 pass
@@ -531,7 +556,7 @@ def opIdent(self):
             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                 if _alt==1:
                     self.state = 80
-                    self.match(RelayParser.T__1)
+                    self.match(RelayParser.T__15)
                     self.state = 81
                     self.match(RelayParser.START_LOWER_CNAME) 
                 self.state = 86
@@ -575,7 +600,7 @@ def globalVar(self):
         try:
             self.enterOuterAlt(localctx, 1)
             self.state = 87
-            self.match(RelayParser.T__2)
+            self.match(RelayParser.T__16)
             self.state = 88
             self.match(RelayParser.START_LOWER_CNAME)
         except RecognitionException as re:
@@ -612,12 +637,18 @@ def localVar(self):
 
         localctx = RelayParser.LocalVarContext(self, self._ctx, self.state)
         self.enterRule(localctx, 8, self.RULE_localVar)
+        self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
             self.state = 90
-            self.match(RelayParser.T__3)
+            self.match(RelayParser.T__17)
             self.state = 91
-            self.match(RelayParser.START_LOWER_CNAME)
+            _la = self._input.LA(1)
+            if not(_la==RelayParser.T__18 or _la==RelayParser.START_LOWER_CNAME):
+                self._errHandler.recoverInline(self)
+            else:
+                self._errHandler.reportMatch(self)
+                self.consume()
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -661,7 +692,7 @@ def typeIdent(self):
             self.state = 95
             self._errHandler.sync(self)
             token = self._input.LA(1)
-            if token in [RelayParser.T__0]:
+            if token in [RelayParser.T__0, RelayParser.T__1, RelayParser.T__2, RelayParser.T__3, RelayParser.T__4, RelayParser.T__5, RelayParser.T__6, RelayParser.T__7, RelayParser.T__8, RelayParser.T__9, RelayParser.T__10, RelayParser.T__11, RelayParser.T__12, RelayParser.T__13, RelayParser.T__14]:
                 self.state = 93
                 self.baseType()
                 pass
@@ -709,7 +740,7 @@ def graphVar(self):
         try:
             self.enterOuterAlt(localctx, 1)
             self.state = 97
-            self.match(RelayParser.T__3)
+            self.match(RelayParser.T__17)
             self.state = 98
             self.match(RelayParser.NAT)
         except RecognitionException as re:
@@ -756,15 +787,15 @@ def exprList(self):
             self.state = 108
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__0) | (1 << RelayParser.T__2) | (1 << RelayParser.T__3) | (1 << RelayParser.T__5) | (1 << RelayParser.T__7) | (1 << RelayParser.T__9) | (1 << RelayParser.T__11) | (1 << RelayParser.T__13) | (1 << RelayParser.T__17) | (1 << RelayParser.T__23) | (1 << RelayParser.T__24) | (1 << RelayParser.T__27) | (1 << RelayParser.T__28) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.START_UPPER_CNAME) | (1 << RelayParser.START_LOWER_CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
+            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__16) | (1 << RelayParser.T__17) | (1 << RelayParser.T__20) | (1 << RelayParser.T__22) | (1 << RelayParser.T__24) | (1 << RelayParser.T__26) | (1 << RelayParser.T__28) | (1 << RelayParser.T__32) | (1 << RelayParser.T__38) | (1 << RelayParser.T__39) | (1 << RelayParser.T__42) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.START_LOWER_CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
                 self.state = 100
                 self.expr(0)
                 self.state = 105
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                while _la==RelayParser.T__4:
+                while _la==RelayParser.T__19:
                     self.state = 101
-                    self.match(RelayParser.T__4)
+                    self.match(RelayParser.T__19)
                     self.state = 102
                     self.expr(0)
                     self.state = 107
@@ -865,7 +896,7 @@ def callList(self):
                         self.state = 111
                         self.expr(0)
                         self.state = 112
-                        self.match(RelayParser.T__4) 
+                        self.match(RelayParser.T__19) 
                     self.state = 118
                     self._errHandler.sync(self)
                     _alt = self._interp.adaptivePredict(self._input,7,self._ctx)
@@ -1254,11 +1285,11 @@ def expr(self, _p:int=0):
                 _prevctx = localctx
 
                 self.state = 123
-                self.match(RelayParser.T__5)
+                self.match(RelayParser.T__20)
                 self.state = 124
                 self.expr(0)
                 self.state = 125
-                self.match(RelayParser.T__6)
+                self.match(RelayParser.T__21)
                 pass
 
             elif la_ == 2:
@@ -1266,11 +1297,11 @@ def expr(self, _p:int=0):
                 self._ctx = localctx
                 _prevctx = localctx
                 self.state = 127
-                self.match(RelayParser.T__7)
+                self.match(RelayParser.T__22)
                 self.state = 128
                 self.expr(0)
                 self.state = 129
-                self.match(RelayParser.T__8)
+                self.match(RelayParser.T__23)
                 pass
 
             elif la_ == 3:
@@ -1296,9 +1327,9 @@ def expr(self, _p:int=0):
                 self._ctx = localctx
                 _prevctx = localctx
                 self.state = 134
-                self.match(RelayParser.T__5)
+                self.match(RelayParser.T__20)
                 self.state = 135
-                self.match(RelayParser.T__6)
+                self.match(RelayParser.T__21)
                 pass
 
             elif la_ == 6:
@@ -1306,13 +1337,13 @@ def expr(self, _p:int=0):
                 self._ctx = localctx
                 _prevctx = localctx
                 self.state = 136
-                self.match(RelayParser.T__5)
+                self.match(RelayParser.T__20)
                 self.state = 137
                 self.expr(0)
                 self.state = 138
-                self.match(RelayParser.T__4)
+                self.match(RelayParser.T__19)
                 self.state = 139
-                self.match(RelayParser.T__6)
+                self.match(RelayParser.T__21)
                 pass
 
             elif la_ == 7:
@@ -1320,7 +1351,7 @@ def expr(self, _p:int=0):
                 self._ctx = localctx
                 _prevctx = localctx
                 self.state = 141
-                self.match(RelayParser.T__5)
+                self.match(RelayParser.T__20)
                 self.state = 142
                 self.expr(0)
                 self.state = 145 
@@ -1328,17 +1359,17 @@ def expr(self, _p:int=0):
                 _la = self._input.LA(1)
                 while True:
                     self.state = 143
-                    self.match(RelayParser.T__4)
+                    self.match(RelayParser.T__19)
                     self.state = 144
                     self.expr(0)
                     self.state = 147 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
-                    if not (_la==RelayParser.T__4):
+                    if not (_la==RelayParser.T__19):
                         break
 
                 self.state = 149
-                self.match(RelayParser.T__6)
+                self.match(RelayParser.T__21)
                 pass
 
             elif la_ == 8:
@@ -1346,19 +1377,19 @@ def expr(self, _p:int=0):
                 self._ctx = localctx
                 _prevctx = localctx
                 self.state = 151
-                self.match(RelayParser.T__9)
+                self.match(RelayParser.T__24)
                 self.state = 160
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__0) | (1 << RelayParser.T__2) | (1 << RelayParser.T__3) | (1 << RelayParser.T__5) | (1 << RelayParser.T__7) | (1 << RelayParser.T__9) | (1 << RelayParser.T__11) | (1 << RelayParser.T__13) | (1 << RelayParser.T__17) | (1 << RelayParser.T__23) | (1 << RelayParser.T__24) | (1 << RelayParser.T__27) | (1 << RelayParser.T__28) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.START_UPPER_CNAME) | (1 << RelayParser.START_LOWER_CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
+                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__16) | (1 << RelayParser.T__17) | (1 << RelayParser.T__20) | (1 << RelayParser.T__22) | (1 << RelayParser.T__24) | (1 << RelayParser.T__26) | (1 << RelayParser.T__28) | (1 << RelayParser.T__32) | (1 << RelayParser.T__38) | (1 << RelayParser.T__39) | (1 << RelayParser.T__42) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.START_LOWER_CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
                     self.state = 152
                     self.expr(0)
                     self.state = 157
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
-                    while _la==RelayParser.T__4:
+                    while _la==RelayParser.T__19:
                         self.state = 153
-                        self.match(RelayParser.T__4)
+                        self.match(RelayParser.T__19)
                         self.state = 154
                         self.expr(0)
                         self.state = 159
@@ -1368,7 +1399,7 @@ def expr(self, _p:int=0):
 
 
                 self.state = 162
-                self.match(RelayParser.T__10)
+                self.match(RelayParser.T__25)
                 pass
 
             elif la_ == 9:
@@ -1376,17 +1407,17 @@ def expr(self, _p:int=0):
                 self._ctx = localctx
                 _prevctx = localctx
                 self.state = 163
-                self.match(RelayParser.T__11)
+                self.match(RelayParser.T__26)
                 self.state = 164
-                self.match(RelayParser.T__5)
+                self.match(RelayParser.T__20)
                 self.state = 165
                 self.expr(0)
                 self.state = 166
-                self.match(RelayParser.T__6)
+                self.match(RelayParser.T__21)
                 self.state = 167
                 self.body()
                 self.state = 168
-                self.match(RelayParser.T__12)
+                self.match(RelayParser.T__27)
                 self.state = 169
                 self.body()
                 pass
@@ -1398,13 +1429,13 @@ def expr(self, _p:int=0):
                 self.state = 171
                 self.matchType()
                 self.state = 172
-                self.match(RelayParser.T__5)
+                self.match(RelayParser.T__20)
                 self.state = 173
                 self.expr(0)
                 self.state = 174
-                self.match(RelayParser.T__6)
+                self.match(RelayParser.T__21)
                 self.state = 175
-                self.match(RelayParser.T__7)
+                self.match(RelayParser.T__22)
                 self.state = 177 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
@@ -1414,11 +1445,11 @@ def expr(self, _p:int=0):
                     self.state = 179 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
-                    if not (_la==RelayParser.T__21):
+                    if not (_la==RelayParser.T__36):
                         break
 
                 self.state = 181
-                self.match(RelayParser.T__8)
+                self.match(RelayParser.T__23)
                 pass
 
             elif la_ == 11:
@@ -1426,15 +1457,15 @@ def expr(self, _p:int=0):
                 self._ctx = localctx
                 _prevctx = localctx
                 self.state = 183
-                self.match(RelayParser.T__13)
+                self.match(RelayParser.T__28)
                 self.state = 184
                 self.var()
                 self.state = 185
-                self.match(RelayParser.T__14)
+                self.match(RelayParser.T__29)
                 self.state = 186
                 self.expr(0)
                 self.state = 187
-                self.match(RelayParser.T__15)
+                self.match(RelayParser.T__30)
                 self.state = 188
                 self.expr(7)
                 pass
@@ -1446,11 +1477,11 @@ def expr(self, _p:int=0):
                 self.state = 190
                 self.graphVar()
                 self.state = 191
-                self.match(RelayParser.T__14)
+                self.match(RelayParser.T__29)
                 self.state = 192
                 self.expr(0)
                 self.state = 193
-                self.match(RelayParser.T__15)
+                self.match(RelayParser.T__30)
                 self.state = 194
                 self.expr(5)
                 pass
@@ -1584,7 +1615,7 @@ def expr(self, _p:int=0):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
                         self.state = 215
-                        self.match(RelayParser.T__16)
+                        self.match(RelayParser.T__31)
                         self.state = 216
                         self.expr(7)
                         pass
@@ -1597,11 +1628,11 @@ def expr(self, _p:int=0):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 21)")
                         self.state = 218
-                        self.match(RelayParser.T__5)
+                        self.match(RelayParser.T__20)
                         self.state = 219
                         self.callList()
                         self.state = 220
-                        self.match(RelayParser.T__6)
+                        self.match(RelayParser.T__21)
                         pass
 
                     elif la_ == 7:
@@ -1612,7 +1643,7 @@ def expr(self, _p:int=0):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
                         self.state = 223
-                        self.match(RelayParser.T__1)
+                        self.match(RelayParser.T__15)
                         self.state = 224
                         self.match(RelayParser.NAT)
                         pass
@@ -1673,27 +1704,27 @@ def func(self):
         try:
             self.enterOuterAlt(localctx, 1)
             self.state = 230
-            self.match(RelayParser.T__17)
+            self.match(RelayParser.T__32)
             self.state = 232
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==RelayParser.T__9:
+            if _la==RelayParser.T__24:
                 self.state = 231
                 self.typeParamList()
 
 
             self.state = 234
-            self.match(RelayParser.T__5)
+            self.match(RelayParser.T__20)
             self.state = 235
             self.argList()
             self.state = 236
-            self.match(RelayParser.T__6)
+            self.match(RelayParser.T__21)
             self.state = 239
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==RelayParser.T__18:
+            if _la==RelayParser.T__33:
                 self.state = 237
-                self.match(RelayParser.T__18)
+                self.match(RelayParser.T__33)
                 self.state = 238
                 self.typeExpr()
 
@@ -1790,33 +1821,33 @@ def defn(self):
             self.state = 268
             self._errHandler.sync(self)
             token = self._input.LA(1)
-            if token in [RelayParser.T__19]:
+            if token in [RelayParser.T__34]:
                 localctx = RelayParser.FuncDefnContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
                 self.state = 243
-                self.match(RelayParser.T__19)
+                self.match(RelayParser.T__34)
                 self.state = 244
                 self.globalVar()
                 self.state = 246
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if _la==RelayParser.T__9:
+                if _la==RelayParser.T__24:
                     self.state = 245
                     self.typeParamList()
 
 
                 self.state = 248
-                self.match(RelayParser.T__5)
+                self.match(RelayParser.T__20)
                 self.state = 249
                 self.argList()
                 self.state = 250
-                self.match(RelayParser.T__6)
+                self.match(RelayParser.T__21)
                 self.state = 253
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if _la==RelayParser.T__18:
+                if _la==RelayParser.T__33:
                     self.state = 251
-                    self.match(RelayParser.T__18)
+                    self.match(RelayParser.T__33)
                     self.state = 252
                     self.typeExpr()
 
@@ -1824,23 +1855,23 @@ def defn(self):
                 self.state = 255
                 self.body()
                 pass
-            elif token in [RelayParser.T__20]:
+            elif token in [RelayParser.T__35]:
                 localctx = RelayParser.AdtDefnContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
                 self.state = 257
-                self.match(RelayParser.T__20)
+                self.match(RelayParser.T__35)
                 self.state = 258
                 self.typeIdent()
                 self.state = 260
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if _la==RelayParser.T__9:
+                if _la==RelayParser.T__24:
                     self.state = 259
                     self.typeParamList()
 
 
                 self.state = 262
-                self.match(RelayParser.T__14)
+                self.match(RelayParser.T__29)
                 self.state = 264 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
@@ -1850,7 +1881,7 @@ def defn(self):
                     self.state = 266 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
-                    if not (_la==RelayParser.T__21):
+                    if not (_la==RelayParser.T__36):
                         break
 
                 pass
@@ -1903,23 +1934,23 @@ def adtConstructor(self):
         try:
             self.enterOuterAlt(localctx, 1)
             self.state = 270
-            self.match(RelayParser.T__21)
+            self.match(RelayParser.T__36)
             self.state = 271
             self.constructorName()
             self.state = 283
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==RelayParser.T__5:
+            if _la==RelayParser.T__20:
                 self.state = 272
-                self.match(RelayParser.T__5)
+                self.match(RelayParser.T__20)
                 self.state = 273
                 self.typeExpr()
                 self.state = 278
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                while _la==RelayParser.T__4:
+                while _la==RelayParser.T__19:
                     self.state = 274
-                    self.match(RelayParser.T__4)
+                    self.match(RelayParser.T__19)
                     self.state = 275
                     self.typeExpr()
                     self.state = 280
@@ -1927,7 +1958,7 @@ def adtConstructor(self):
                     _la = self._input.LA(1)
 
                 self.state = 281
-                self.match(RelayParser.T__6)
+                self.match(RelayParser.T__21)
 
 
         except RecognitionException as re:
@@ -1977,19 +2008,19 @@ def matchClause(self):
         try:
             self.enterOuterAlt(localctx, 1)
             self.state = 285
-            self.match(RelayParser.T__21)
+            self.match(RelayParser.T__36)
             self.state = 286
             self.constructorName()
             self.state = 288
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==RelayParser.T__5:
+            if _la==RelayParser.T__20:
                 self.state = 287
                 self.patternList()
 
 
             self.state = 290
-            self.match(RelayParser.T__22)
+            self.match(RelayParser.T__37)
             self.state = 291
             self.expr(0)
         except RecognitionException as re:
@@ -2029,7 +2060,7 @@ def matchType(self):
             self.enterOuterAlt(localctx, 1)
             self.state = 293
             _la = self._input.LA(1)
-            if not(_la==RelayParser.T__23 or _la==RelayParser.T__24):
+            if not(_la==RelayParser.T__38 or _la==RelayParser.T__39):
                 self._errHandler.recoverInline(self)
             else:
                 self._errHandler.reportMatch(self)
@@ -2076,15 +2107,15 @@ def patternList(self):
         try:
             self.enterOuterAlt(localctx, 1)
             self.state = 295
-            self.match(RelayParser.T__5)
+            self.match(RelayParser.T__20)
             self.state = 296
             self.pattern()
             self.state = 301
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            while _la==RelayParser.T__4:
+            while _la==RelayParser.T__19:
                 self.state = 297
-                self.match(RelayParser.T__4)
+                self.match(RelayParser.T__19)
                 self.state = 298
                 self.pattern()
                 self.state = 303
@@ -2092,7 +2123,7 @@ def patternList(self):
                 _la = self._input.LA(1)
 
             self.state = 304
-            self.match(RelayParser.T__6)
+            self.match(RelayParser.T__21)
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -2137,21 +2168,21 @@ def pattern(self):
             self.state = 312
             self._errHandler.sync(self)
             token = self._input.LA(1)
-            if token in [RelayParser.T__25]:
+            if token in [RelayParser.T__18]:
                 self.enterOuterAlt(localctx, 1)
                 self.state = 306
-                self.match(RelayParser.T__25)
+                self.match(RelayParser.T__18)
                 pass
-            elif token in [RelayParser.T__3]:
+            elif token in [RelayParser.T__17]:
                 self.enterOuterAlt(localctx, 2)
                 self.state = 307
                 self.localVar()
                 self.state = 310
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if _la==RelayParser.T__26:
+                if _la==RelayParser.T__40:
                     self.state = 308
-                    self.match(RelayParser.T__26)
+                    self.match(RelayParser.T__40)
                     self.state = 309
                     self.typeExpr()
 
@@ -2286,11 +2317,11 @@ def argList(self):
                 self.state = 322
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                while _la==RelayParser.T__3:
+                while _la==RelayParser.T__17:
                     self.state = 317
                     self.var()
                     self.state = 318
-                    self.match(RelayParser.T__4)
+                    self.match(RelayParser.T__19)
                     self.state = 324
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
@@ -2344,15 +2375,15 @@ def varList(self):
             self.state = 336
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==RelayParser.T__3:
+            if _la==RelayParser.T__17:
                 self.state = 328
                 self.var()
                 self.state = 333
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                while _la==RelayParser.T__4:
+                while _la==RelayParser.T__19:
                     self.state = 329
-                    self.match(RelayParser.T__4)
+                    self.match(RelayParser.T__19)
                     self.state = 330
                     self.var()
                     self.state = 335
@@ -2408,9 +2439,9 @@ def var(self):
             self.state = 341
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==RelayParser.T__26:
+            if _la==RelayParser.T__40:
                 self.state = 339
-                self.match(RelayParser.T__26)
+                self.match(RelayParser.T__40)
                 self.state = 340
                 self.typeExpr()
 
@@ -2461,9 +2492,9 @@ def attrSeq(self):
             self.state = 348
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            while _la==RelayParser.T__4:
+            while _la==RelayParser.T__19:
                 self.state = 344
-                self.match(RelayParser.T__4)
+                self.match(RelayParser.T__19)
                 self.state = 345
                 self.attr()
                 self.state = 350
@@ -2513,7 +2544,7 @@ def attr(self):
             self.state = 351
             self.match(RelayParser.START_LOWER_CNAME)
             self.state = 352
-            self.match(RelayParser.T__14)
+            self.match(RelayParser.T__29)
             self.state = 353
             self.expr(0)
         except RecognitionException as re:
@@ -2598,6 +2629,20 @@ def accept(self, visitor:ParseTreeVisitor):
                 return visitor.visitChildren(self)
 
 
+    class IncompleteTypeContext(TypeExprContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a RelayParser.TypeExprContext
+            super().__init__(parser)
+            self.copyFrom(ctx)
+
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitIncompleteType" ):
+                return visitor.visitIncompleteType(self)
+            else:
+                return visitor.visitChildren(self)
+
+
     class TensorTypeContext(TypeExprContext):
 
         def __init__(self, parser, ctx:ParserRuleContext): # actually a RelayParser.TypeExprContext
@@ -2648,36 +2693,36 @@ def typeExpr(self):
         self.enterRule(localctx, 46, self.RULE_typeExpr)
         self._la = 0 # Token type
         try:
-            self.state = 401
+            self.state = 402
             self._errHandler.sync(self)
             la_ = self._interp.adaptivePredict(self._input,39,self._ctx)
             if la_ == 1:
                 localctx = RelayParser.TupleTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
                 self.state = 355
-                self.match(RelayParser.T__5)
+                self.match(RelayParser.T__20)
                 self.state = 356
-                self.match(RelayParser.T__6)
+                self.match(RelayParser.T__21)
                 pass
 
             elif la_ == 2:
                 localctx = RelayParser.TupleTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
                 self.state = 357
-                self.match(RelayParser.T__5)
+                self.match(RelayParser.T__20)
                 self.state = 358
                 self.typeExpr()
                 self.state = 359
-                self.match(RelayParser.T__4)
+                self.match(RelayParser.T__19)
                 self.state = 360
-                self.match(RelayParser.T__6)
+                self.match(RelayParser.T__21)
                 pass
 
             elif la_ == 3:
                 localctx = RelayParser.TupleTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 3)
                 self.state = 362
-                self.match(RelayParser.T__5)
+                self.match(RelayParser.T__20)
                 self.state = 363
                 self.typeExpr()
                 self.state = 366 
@@ -2685,17 +2730,17 @@ def typeExpr(self):
                 _la = self._input.LA(1)
                 while True:
                     self.state = 364
-                    self.match(RelayParser.T__4)
+                    self.match(RelayParser.T__19)
                     self.state = 365
                     self.typeExpr()
                     self.state = 368 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
-                    if not (_la==RelayParser.T__4):
+                    if not (_la==RelayParser.T__19):
                         break
 
                 self.state = 370
-                self.match(RelayParser.T__6)
+                self.match(RelayParser.T__21)
                 pass
 
             elif la_ == 4:
@@ -2718,46 +2763,46 @@ def typeExpr(self):
                 localctx = RelayParser.TensorTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 6)
                 self.state = 376
-                self.match(RelayParser.T__27)
+                self.match(RelayParser.T__41)
                 self.state = 377
-                self.match(RelayParser.T__9)
+                self.match(RelayParser.T__24)
                 self.state = 378
                 self.shapeList()
                 self.state = 379
-                self.match(RelayParser.T__4)
+                self.match(RelayParser.T__19)
                 self.state = 380
                 self.typeExpr()
                 self.state = 381
-                self.match(RelayParser.T__10)
+                self.match(RelayParser.T__25)
                 pass
 
             elif la_ == 7:
                 localctx = RelayParser.FuncTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 7)
                 self.state = 383
-                self.match(RelayParser.T__17)
+                self.match(RelayParser.T__32)
                 self.state = 385
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if _la==RelayParser.T__9:
+                if _la==RelayParser.T__24:
                     self.state = 384
                     self.typeParamList()
 
 
                 self.state = 387
-                self.match(RelayParser.T__5)
+                self.match(RelayParser.T__20)
                 self.state = 396
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__0) | (1 << RelayParser.T__5) | (1 << RelayParser.T__17) | (1 << RelayParser.T__27) | (1 << RelayParser.START_UPPER_CNAME))) != 0):
+                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__0) | (1 << RelayParser.T__1) | (1 << RelayParser.T__2) | (1 << RelayParser.T__3) | (1 << RelayParser.T__4) | (1 << RelayParser.T__5) | (1 << RelayParser.T__6) | (1 << RelayParser.T__7) | (1 << RelayParser.T__8) | (1 << RelayParser.T__9) | (1 << RelayParser.T__10) | (1 << RelayParser.T__11) | (1 << RelayParser.T__12) | (1 << RelayParser.T__13) | (1 << RelayParser.T__14) | (1 << RelayParser.T__18) | (1 << RelayParser.T__20) | (1 << RelayParser.T__32) | (1 << RelayParser.T__41) | (1 << RelayParser.START_UPPER_CNAME))) != 0):
                     self.state = 388
                     self.typeExpr()
                     self.state = 393
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
-                    while _la==RelayParser.T__4:
+                    while _la==RelayParser.T__19:
                         self.state = 389
-                        self.match(RelayParser.T__4)
+                        self.match(RelayParser.T__19)
                         self.state = 390
                         self.typeExpr()
                         self.state = 395
@@ -2767,13 +2812,20 @@ def typeExpr(self):
 
 
                 self.state = 398
-                self.match(RelayParser.T__6)
+                self.match(RelayParser.T__21)
                 self.state = 399
-                self.match(RelayParser.T__18)
+                self.match(RelayParser.T__33)
                 self.state = 400
                 self.typeExpr()
                 pass
 
+            elif la_ == 8:
+                localctx = RelayParser.IncompleteTypeContext(self, localctx)
+                self.enterOuterAlt(localctx, 8)
+                self.state = 401
+                self.match(RelayParser.T__18)
+                pass
+
 
         except RecognitionException as re:
             localctx.exception = re
@@ -2816,24 +2868,24 @@ def typeParamList(self):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 403
-            self.match(RelayParser.T__9)
             self.state = 404
+            self.match(RelayParser.T__24)
+            self.state = 405
             self.typeIdent()
-            self.state = 409
+            self.state = 410
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            while _la==RelayParser.T__4:
-                self.state = 405
-                self.match(RelayParser.T__4)
+            while _la==RelayParser.T__19:
                 self.state = 406
+                self.match(RelayParser.T__19)
+                self.state = 407
                 self.typeIdent()
-                self.state = 411
+                self.state = 412
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 412
-            self.match(RelayParser.T__10)
+            self.state = 413
+            self.match(RelayParser.T__25)
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -2874,44 +2926,44 @@ def shapeList(self):
         self.enterRule(localctx, 50, self.RULE_shapeList)
         self._la = 0 # Token type
         try:
-            self.state = 427
+            self.state = 428
             self._errHandler.sync(self)
             la_ = self._interp.adaptivePredict(self._input,42,self._ctx)
             if la_ == 1:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 414
-                self.match(RelayParser.T__5)
                 self.state = 415
+                self.match(RelayParser.T__20)
+                self.state = 416
+                self.match(RelayParser.T__21)
+                pass
+
+            elif la_ == 2:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 417
+                self.match(RelayParser.T__20)
+                self.state = 418
                 self.shape()
-                self.state = 418 
+                self.state = 421 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while True:
-                    self.state = 416
-                    self.match(RelayParser.T__4)
-                    self.state = 417
+                    self.state = 419
+                    self.match(RelayParser.T__19)
+                    self.state = 420
                     self.shape()
-                    self.state = 420 
+                    self.state = 423 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
-                    if not (_la==RelayParser.T__4):
+                    if not (_la==RelayParser.T__19):
                         break
 
-                self.state = 422
-                self.match(RelayParser.T__6)
-                pass
-
-            elif la_ == 2:
-                self.enterOuterAlt(localctx, 2)
-                self.state = 424
-                self.match(RelayParser.T__5)
                 self.state = 425
-                self.match(RelayParser.T__6)
+                self.match(RelayParser.T__21)
                 pass
 
             elif la_ == 3:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 426
+                self.state = 427
                 self.shape()
                 pass
 
@@ -2955,20 +3007,20 @@ def meta(self):
         self.enterRule(localctx, 52, self.RULE_meta)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 429
-            self.match(RelayParser.T__28)
             self.state = 430
-            self.match(RelayParser.T__9)
+            self.match(RelayParser.T__42)
             self.state = 431
-            self.match(RelayParser.START_LOWER_CNAME)
+            self.match(RelayParser.T__24)
             self.state = 432
-            self.match(RelayParser.T__10)
+            self.match(RelayParser.START_LOWER_CNAME)
             self.state = 433
-            self.match(RelayParser.T__9)
+            self.match(RelayParser.T__25)
             self.state = 434
-            self.match(RelayParser.NAT)
+            self.match(RelayParser.T__24)
             self.state = 435
-            self.match(RelayParser.T__10)
+            self.match(RelayParser.NAT)
+            self.state = 436
+            self.match(RelayParser.T__25)
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -3050,29 +3102,29 @@ def shape(self):
         localctx = RelayParser.ShapeContext(self, self._ctx, self.state)
         self.enterRule(localctx, 54, self.RULE_shape)
         try:
-            self.state = 443
+            self.state = 444
             self._errHandler.sync(self)
             token = self._input.LA(1)
-            if token in [RelayParser.T__28]:
+            if token in [RelayParser.T__42]:
                 localctx = RelayParser.MetaShapeContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 437
+                self.state = 438
                 self.meta()
                 pass
-            elif token in [RelayParser.T__5]:
+            elif token in [RelayParser.T__20]:
                 localctx = RelayParser.ParensShapeContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 438
-                self.match(RelayParser.T__5)
                 self.state = 439
-                self.shape()
+                self.match(RelayParser.T__20)
                 self.state = 440
-                self.match(RelayParser.T__6)
+                self.shape()
+                self.state = 441
+                self.match(RelayParser.T__21)
                 pass
             elif token in [RelayParser.NAT]:
                 localctx = RelayParser.IntShapeContext(self, localctx)
                 self.enterOuterAlt(localctx, 3)
-                self.state = 442
+                self.state = 443
                 self.match(RelayParser.NAT)
                 pass
             else:
@@ -3115,12 +3167,12 @@ def body(self):
         self.enterRule(localctx, 56, self.RULE_body)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 445
-            self.match(RelayParser.T__7)
             self.state = 446
-            self.expr(0)
+            self.match(RelayParser.T__22)
             self.state = 447
-            self.match(RelayParser.T__8)
+            self.expr(0)
+            self.state = 448
+            self.match(RelayParser.T__23)
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -3200,25 +3252,25 @@ def scalar(self):
         localctx = RelayParser.ScalarContext(self, self._ctx, self.state)
         self.enterRule(localctx, 58, self.RULE_scalar)
         try:
-            self.state = 452
+            self.state = 453
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [RelayParser.FLOAT]:
                 localctx = RelayParser.ScalarFloatContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 449
+                self.state = 450
                 self.match(RelayParser.FLOAT)
                 pass
             elif token in [RelayParser.NAT]:
                 localctx = RelayParser.ScalarIntContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 450
+                self.state = 451
                 self.match(RelayParser.NAT)
                 pass
             elif token in [RelayParser.BOOL_LIT]:
                 localctx = RelayParser.ScalarBoolContext(self, localctx)
                 self.enterOuterAlt(localctx, 3)
-                self.state = 451
+                self.state = 452
                 self.match(RelayParser.BOOL_LIT)
                 pass
             else:
@@ -3251,10 +3303,6 @@ def localVar(self):
             return self.getTypedRuleContext(RelayParser.LocalVarContext,0)
 
 
-        def typeExpr(self):
-            return self.getTypedRuleContext(RelayParser.TypeExprContext,0)
-
-
         def graphVar(self):
             return self.getTypedRuleContext(RelayParser.GraphVarContext,0)
 
@@ -3281,30 +3329,24 @@ def ident(self):
             la_ = self._interp.adaptivePredict(self._input,45,self._ctx)
             if la_ == 1:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 454
+                self.state = 455
                 self.opIdent()
                 pass
 
             elif la_ == 2:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 455
+                self.state = 456
                 self.globalVar()
                 pass
 
             elif la_ == 3:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 456
+                self.state = 457
                 self.localVar()
                 pass
 
             elif la_ == 4:
                 self.enterOuterAlt(localctx, 4)
-                self.state = 457
-                self.typeExpr()
-                pass
-
-            elif la_ == 5:
-                self.enterOuterAlt(localctx, 5)
                 self.state = 458
                 self.graphVar()
                 pass
diff --git a/python/tvm/relay/grammar/py3/RelayVisitor.py b/python/tvm/relay/grammar/py3/RelayVisitor.py
index 19e04fe99283..2bcaeff63cf5 100644
--- a/python/tvm/relay/grammar/py3/RelayVisitor.py
+++ b/python/tvm/relay/grammar/py3/RelayVisitor.py
@@ -239,6 +239,11 @@ def visitFuncType(self, ctx:RelayParser.FuncTypeContext):
         return self.visitChildren(ctx)
 
 
+    # Visit a parse tree produced by RelayParser#incompleteType.
+    def visitIncompleteType(self, ctx:RelayParser.IncompleteTypeContext):
+        return self.visitChildren(ctx)
+
+
     # Visit a parse tree produced by RelayParser#typeParamList.
     def visitTypeParamList(self, ctx:RelayParser.TypeParamListContext):
         return self.visitChildren(ctx)
diff --git a/tests/python/relay/test_ir_parser.py b/tests/python/relay/test_ir_parser.py
index 4ce3e506b0bc..b6638779cd5e 100644
--- a/tests/python/relay/test_ir_parser.py
+++ b/tests/python/relay/test_ir_parser.py
@@ -257,13 +257,13 @@ def test_seq():
 
 
 def test_graph():
+    code = "%0 = (); %1 = 1; (%0, %0, %1)"
     assert parses_as(
-        "%0 = (); %1 = 1; (%0, %0, %1)",
+        code,
         relay.Tuple([UNIT, UNIT, relay.const(1)])
     )
-
     assert not parses_as(
-        "%0 = (); %1 = 1; (%0, %0, %1)",
+        code,
         relay.Tuple([relay.Tuple([]), relay.Tuple([]), relay.const(1)])
     )
 
@@ -659,7 +659,7 @@ def test_adt_defn():
     )
 
 
-def test_multiple_variants():
+def test_multiple_cons_defn():
     mod = relay.Module()
 
     list_var = relay.GlobalTypeVar("List")
@@ -682,7 +682,7 @@ def test_multiple_variants():
     )
 
 
-def test_multiple_type_params():
+def test_multiple_type_param_defn():
     glob_typ_var = relay.GlobalTypeVar("Either")
     typ_var_a = relay.TypeVar("A")
     typ_var_b = relay.TypeVar("B")
@@ -724,7 +724,6 @@ def test_match():
     input_type = list_var(typ_var)
     input_var = relay.Var("xs", input_type)
     rest_var = relay.Var("rest")
-    # TODO: THIS IS WHAT'S NOT EQUAL
     body = relay.Match(input_var,
         [relay.Clause(
             relay.PatternConstructor(
@@ -762,30 +761,70 @@ def @length[A](%xs: List[A]) -> int32 {
     )
 
 
+def test_adt_cons_expr():
+    mod = relay.Module()
+
+    list_var = relay.GlobalTypeVar("List")
+    typ_var = relay.TypeVar("A")
+    cons_constructor = relay.Constructor(
+        "Cons", [typ_var, list_var(typ_var)], list_var)
+    nil_constructor = relay.Constructor("Nil", [], list_var)
+    list_def = relay.TypeData(
+        list_var,
+        [typ_var],
+        [cons_constructor, nil_constructor])
+    mod[list_var] = list_def
+
+    make_singleton_var = relay.GlobalVar("make_singleton")
+    input_var = relay.Var("x", int32)
+    rest_var = relay.Var("rest")
+    length_func = relay.Function(
+        [input_var],
+        cons_constructor([input_var, nil_constructor()]),
+        list_var(int32),
+        [typ_var]
+    )
+    mod[make_singleton_var] = length_func
+
+    assert parses_as(
+        """
+        type List[A] =
+          | Cons(A, List[A])
+          | Nil
+
+        def @make_singleton(%x: int32) -> List[int32] {
+          Cons(%x, Nil)
+        }
+        """,
+        mod
+    )
+
+
 if __name__ == "__main__":
-    # test_comments()
-    # test_int_literal()
-    # test_float_literal()
-    # test_bool_literal()
-    # test_negative()
-    # test_bin_op()
-    # test_parens()
-    # test_op_assoc()
-    # test_let()
-    # test_seq()
-    # test_graph()
-    # test_tuple()
-    # test_func()
-    # test_defn()
-    # test_recursive_call()
-    # test_ifelse()
-    # test_call()
-    # test_incomplete_type()
-    # test_builtin_types()
-    # test_tensor_type()
-    # test_function_type()
-    # test_tuple_type()
-    # test_adt_defn()
-    test_multiple_variants()
-    # test_multiple_type_params()
+    test_comments()
+    test_int_literal()
+    test_float_literal()
+    test_bool_literal()
+    test_negative()
+    test_bin_op()
+    test_parens()
+    test_op_assoc()
+    test_let()
+    test_seq()
+    test_graph()
+    test_tuple()
+    test_func()
+    test_defn()
+    test_recursive_call()
+    test_ifelse()
+    test_call()
+    test_incomplete_type()
+    test_builtin_types()
+    test_tensor_type()
+    test_function_type()
+    test_tuple_type()
+    test_adt_defn()
+    test_multiple_cons_defn()
+    test_multiple_type_param_defn()
     test_match()
+    # test_adt_cons_expr()

From 259a686363fa20039a0df7cf1c179a489532bdfd Mon Sep 17 00:00:00 2001
From: Logan Weber <weberlo@cs.washington.edu>
Date: Mon, 26 Aug 2019 20:01:34 -0700
Subject: [PATCH 07/29] ADT constructors work

now cleanup?
---
 python/tvm/relay/_parser.py                  |   80 +-
 python/tvm/relay/grammar/Relay.g4            |   71 +-
 python/tvm/relay/grammar/py3/RelayParser.py  | 1348 ++++++++++--------
 python/tvm/relay/grammar/py3/RelayVisitor.py |   23 +-
 src/relay/ir/alpha_equal.cc                  |    4 -
 src/relay/ir/pretty_printer.cc               |    7 +-
 src/relay/pass/type_infer.cc                 |    1 -
 tests/python/relay/test_ir_parser.py         |   67 +-
 8 files changed, 907 insertions(+), 694 deletions(-)

diff --git a/python/tvm/relay/_parser.py b/python/tvm/relay/_parser.py
index 4aeb74490aec..8032e08e11dd 100644
--- a/python/tvm/relay/_parser.py
+++ b/python/tvm/relay/_parser.py
@@ -189,15 +189,14 @@ class ParseTreeToRelayIR(RelayVisitor):
     def __init__(self, source_name):
         # type: (str) -> None
         self.source_name = source_name
-        self.module = module.Module({})   # type: module.Module
+        self.module = module.Module({})  # type: module.Module
 
         # Adding an empty scope allows naked lets without pain.
-        self.var_scopes = deque([deque()])                # type: Scopes[expr.Var]
-        self.global_var_scope = deque()                   # type: Scope[expr.GlobalVar]
-        self.type_param_scopes = deque([deque()])         # type: Scopes[ty.TypeVar]
-        self.global_type_param_scope = deque()            # type: Scope[expr.GlobalVar]
-        self.graph_expr = []                              # type: List[expr.Expr]
-        self.adts = {}
+        self.var_scopes = deque([deque()])       # type: Scopes[expr.Var]
+        self.global_var_scope = deque()          # type: Scope[expr.GlobalVar]
+        self.type_var_scopes = deque([deque()])  # type: Scopes[ty.TypeVar]
+        self.global_type_var_scope = deque()     # type: Scope[expr.GlobalVar]
+        self.graph_expr = []                     # type: List[expr.Expr]
 
         super(ParseTreeToRelayIR, self).__init__()
 
@@ -229,27 +228,35 @@ def mk_global_var(self, name):
     def enter_type_param_scope(self):
         # type: () -> None
         """Enter a new TypeVar scope so it can be popped off later."""
-        self.type_param_scopes.appendleft(deque())
+        self.type_var_scopes.appendleft(deque())
 
     def exit_type_param_scope(self):
         # type: () -> Scope[ty.TypeVar]
         """Pop off the current TypeVar scope and return it."""
-        return self.type_param_scopes.popleft()
+        return self.type_var_scopes.popleft()
 
     def mk_typ(self, name, kind):
         # (str, ty.Kind) -> ty.TypeVar
         """Create a new TypeVar and add it to the TypeVar scope."""
         typ = ty.TypeVar(name, kind)
-        self.type_param_scopes[0].appendleft((name, typ))
+        self.type_var_scopes[0].appendleft((name, typ))
         return typ
 
-    def mk_global_typ(self, name, kind):
+    def mk_global_typ_var(self, name, kind):
         # (str, ty.Kind) -> ty.GlobalTypeVar
         """Create a new TypeVar and add it to the TypeVar scope."""
         typ = ty.GlobalTypeVar(name, kind)
-        self.global_type_param_scope.append((name, typ))
+        self.global_type_var_scope.append((name, typ))
         return typ
 
+    # TODO: rethink whether we should have type constructors mixed with type vars.
+    def mk_global_typ_cons(self, name, cons):
+        if name in self.global_type_var_scope:
+            existing_cons = lookup([self.global_type_var_scope], name)
+            raise ParseError(
+                f'duplicate ADT definition "{name}" found in "{cons.belong_to.name}" and "{existing_cons.belong_to.name}"')
+        self.global_type_var_scope.append((name, cons))
+
     def visitProjection(self, ctx):
         return expr.TupleGetItem(self.visit(ctx.expr()), self.visit(ctx.NAT()))
 
@@ -492,7 +499,7 @@ def visitFuncDefn(self, ctx):
 
     def visitAdtDefn(self, ctx):
         adt_name = ctx.typeIdent().getText()
-        adt_handle = self.mk_global_typ(adt_name, ty.Kind.AdtHandle)
+        adt_handle = self.mk_global_typ_var(adt_name, ty.Kind.AdtHandle)
         self.enter_type_param_scope()
 
         # parse type params
@@ -504,20 +511,16 @@ def visitAdtDefn(self, ctx):
                            for type_ident in type_params.typeIdent()]
 
         # parse constructors
-        name_to_cons = {}
-        for constructor in ctx.adtConstructor():
-            inputs = [self.visit(inp) for inp in constructor.typeExpr()]
-            constructor_name = constructor.constructorName().getText()
-            constructor = adt.Constructor(constructor_name, inputs, adt_handle)
-
-            name_to_cons[constructor_name] = constructor
-
-        # update internal bookkeeping
-        if adt_name in self.adts:
-            raise ParseError(f'duplicate ADT definition "{adt_name}"')
-        self.adts[adt_name] = name_to_cons
+        constructors = []
+        for cons_defn in ctx.adtConsDefn():
+            inputs = [self.visit(inp) for inp in cons_defn.typeExpr()]
+            cons_defn_name = cons_defn.constructorName().getText()
+            cons_defn = adt.Constructor(cons_defn_name, inputs, adt_handle)
+            self.mk_global_typ_cons(cons_defn_name, cons_defn)
+            constructors.append(cons_defn)
+
         # update module being built
-        self.module[adt_handle] = adt.TypeData(adt_handle, type_params, list(name_to_cons.values()))
+        self.module[adt_handle] = adt.TypeData(adt_handle, type_params, constructors)
 
         self.exit_type_param_scope()
 
@@ -533,12 +536,10 @@ def visitMatch(self, ctx):
         # TODO: Will need some kind of type checking to know which ADT is being
         # matched on.
         match_data = self.visit(ctx.expr())
-        # For now, we'll assume it's an annotated var and just grab its type.
-        constructors = self.adts[match_data.type_annotation.func.var.name]
         clauses = []
         for clause in ctx.matchClause():
             constructor_name = clause.constructorName().getText()
-            constructor = constructors[constructor_name]
+            constructor = lookup([self.global_type_var_scope], constructor_name)
             self.enter_var_scope()
             patternList = clause.patternList()
             if patternList is None:
@@ -571,6 +572,9 @@ def visitPattern(self, ctx):
         else:
             raise ParseError(f'invalid pattern syntax "{text}"')
 
+    def visitAdtCons(self, ctx):
+        import pdb; pdb.set_trace()
+
     def visitTypeExprType(self, ctx):
         type_params = ctx.typeParams()
         print(ctx.getText())
@@ -581,9 +585,9 @@ def visitTypeExprType(self, ctx):
         print()
         # TODO: We need to handle arbitrarily nested type calls (e.g., `Maybe[List[Either[Int, Bool]]]`)
         def _parse_typ_var(name):
-            typ_var = lookup(self.type_param_scopes, name)
+            typ_var = lookup(self.type_var_scopes, name)
             if typ_var is None:
-                typ_var = lookup(self.global_type_param_scope, name)
+                typ_var = lookup(self.global_type_var_scope, name)
                 if typ_var is None:
                     # TODO: raise parse error?
                     raise RuntimeError(f'unbound var "{name}"')
@@ -612,14 +616,19 @@ def visitCallWithAttr(self, ctx):
     def call(self, func, args, attrs, type_args):
         if isinstance(func, OpWrapper):
             return func(args, attrs, type_args)
-        return expr.Call(func, args, attrs, type_args)
+        elif isinstance(func, adt.Constructor):
+            return func(*args)
+        else:
+            return expr.Call(func, args, attrs, type_args)
 
     @spanify
     def visitCall(self, ctx):
         # type: (RelayParser.CallContext) -> expr.Call
         func = self.visit(ctx.expr())
         args, attrs = self.visit(ctx.callList())
-        return self.call(func, args, attrs, [])
+        res = self.call(func, args, attrs, [])
+        import pdb; pdb.set_trace()
+        return res
 
     @spanify
     def visitIfElse(self, ctx):
@@ -675,11 +684,10 @@ def visitTypeIdent(self, ctx):
                 return ty.scalar_type(type_name)
 
         # Next, look it up in the local then global type params
-        type_param = lookup(self.type_param_scopes, type_name)
+        type_param = lookup(self.type_var_scopes, type_name)
         if type_param is None:
-            type_param = lookup([self.global_type_param_scope], type_name)
+            type_param = lookup([self.global_type_var_scope], type_name)
             if type_param is None:
-                # TODO: raise parse error?
                 raise ParseError(f'unbound var "{type_name}"')
 
         return type_param
diff --git a/python/tvm/relay/grammar/Relay.g4 b/python/tvm/relay/grammar/Relay.g4
index 367b376926b9..311e17a5c275 100644
--- a/python/tvm/relay/grammar/Relay.g4
+++ b/python/tvm/relay/grammar/Relay.g4
@@ -83,15 +83,11 @@ METADATA: 'METADATA:' .*;
 // Parsing
 
 // A Relay program is a list of global definitions or an expression.
-// prog: SEMVER (defn+ | expr) METADATA? EOF ;
 prog: SEMVER (defn* | expr) METADATA? EOF ;
 
 opIdent: START_LOWER_CNAME ('.' START_LOWER_CNAME)*;
 globalVar: '@' START_LOWER_CNAME ;
 localVar: '%' ('_' | START_LOWER_CNAME) ;
-// TODO(weberlo): why does 'int32` generate a parse error when it's literally a
-// lexer token?
-// typeIdent: BASE_TYPE | START_UPPER_NAME ;
 typeIdent: (baseType | START_UPPER_CNAME) ;
 graphVar: '%' NAT ;
 
@@ -103,43 +99,47 @@ callList
 
 expr
   // operators
-  : '(' expr ')'                              # paren
-  | '{' expr '}'                              # paren
+  : '(' expr ')'                                 # paren
+  | '{' expr '}'                                 # paren
+  // | adtCons                                      # adtConsExpr
   // function application
-  | expr '(' callList ')'                     # call
-  | '-' expr                                  # neg
-  | expr op=('*'|'/') expr                    # binOp
-  | expr op=('+'|'-') expr                    # binOp
-  | expr op=('<'|'>'|'<='|'>=') expr          # binOp
-  | expr op=('=='|'!=') expr                  # binOp
+  // TODO: Just make the adt constructor part of the func app case. disambiguate during parsing.
+  | expr '(' callList ')'                        # call
+  | '-' expr                                     # neg
+  | expr op=('*'|'/') expr                       # binOp
+  | expr op=('+'|'-') expr                       # binOp
+  | expr op=('<'|'>'|'<='|'>=') expr             # binOp
+  | expr op=('=='|'!=') expr                     # binOp
   // function definition
-  | func                                      # funcExpr
+  | func                                         # funcExpr
   // tuples and tensors
-  | '(' ')'                                   # tuple
-  | '(' expr ',' ')'                          # tuple
-  | '(' expr (',' expr)+ ')'                  # tuple
-  | '[' (expr (',' expr)*)? ']'               # tensor
-  | 'if' '(' expr ')' body 'else' body        # ifElse
-  | matchType '(' expr ')' '{' matchClause+ '}'    # match
-  | expr '.' NAT                              # projection
+  | '(' ')'                                      # tuple
+  | '(' expr ',' ')'                             # tuple
+  | '(' expr (',' expr)+ ')'                     # tuple
+  | '[' (expr (',' expr)*)? ']'                  # tensor
+  | 'if' '(' expr ')' body 'else' body           # ifElse
+  | matchType '(' expr ')' '{' matchClause+ '}'  # match
+  | expr '.' NAT                                 # projection
   // sequencing
-  | 'let' var '=' expr ';' expr               # let
+  | 'let' var '=' expr ';' expr                  # let
   // sugar for let %_ = expr; expr
-  | expr ';;' expr                            # let
-  | graphVar '=' expr ';' expr                # graph
-  | ident                                     # identExpr
-  | scalar                                    # scalarExpr
-  | meta                                      # metaExpr
-  | QUOTED_STRING                             # stringExpr
+  | expr ';;' expr                               # let
+  | graphVar '=' expr ';' expr                   # graph
+  | ident                                        # identExpr
+  | scalar                                       # scalarExpr
+  | meta                                         # metaExpr
+  | QUOTED_STRING                                # stringExpr
   ;
 
 func: 'fn'        typeParamList? '(' argList ')' ('->' typeExpr)? body ;
 defn
   : 'def' globalVar typeParamList? '(' argList ')' ('->' typeExpr)? body  # funcDefn
-  | 'type' typeIdent typeParamList? '=' adtConstructor+                   # adtDefn
+  | 'type' typeIdent typeParamList? '=' adtConsDefn+                      # adtDefn
   ;
 
-adtConstructor: '|' constructorName ('(' typeExpr (',' typeExpr)* ')')? ;
+constructorName: START_UPPER_CNAME ;
+
+adtConsDefn: '|' constructorName ('(' typeExpr (',' typeExpr)* ')')? ;
 matchClause: '|' constructorName patternList? '=>' expr ;
 matchType : 'match' | 'match?' ;
 
@@ -150,8 +150,10 @@ pattern
   | localVar (':' typeExpr)?
   ;
 
-// constructorName: typeIdent ;
-constructorName: START_UPPER_CNAME ;
+// TODO: Making the param list optional makes the grammar ambiguous.
+adtCons: constructorName adtConsParamList? ;
+adtConsParamList: '(' adtConsParam (',' adtConsParam)* ')' ;
+adtConsParam: localVar | constructorName ;
 
 argList
   : varList              # argNoAttr
@@ -196,11 +198,6 @@ shape
   | NAT                                  # intShape
   ;
 
-// int8, int16, int32, int64
-// uint8, uint16, uint32, uint64
-// float16, float32, float64
-// bool
-
 body: '{' expr '}' ;
 
 scalar
@@ -213,6 +210,6 @@ ident
   : opIdent
   | globalVar
   | localVar
-  // | typeExpr
+  | typeIdent
   | graphVar
   ;
diff --git a/python/tvm/relay/grammar/py3/RelayParser.py b/python/tvm/relay/grammar/py3/RelayParser.py
index bb0b858841da..97f865bec216 100644
--- a/python/tvm/relay/grammar/py3/RelayParser.py
+++ b/python/tvm/relay/grammar/py3/RelayParser.py
@@ -9,231 +9,244 @@
 def serializedATN():
     with StringIO() as buf:
         buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3B")
-        buf.write("\u01d0\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
+        buf.write("\u01ea\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
         buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
         buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
         buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
         buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
-        buf.write("\4\37\t\37\4 \t \3\2\3\2\3\3\3\3\7\3E\n\3\f\3\16\3H\13")
-        buf.write("\3\3\3\5\3K\n\3\3\3\5\3N\n\3\3\3\3\3\3\4\3\4\3\4\7\4U")
-        buf.write("\n\4\f\4\16\4X\13\4\3\5\3\5\3\5\3\6\3\6\3\6\3\7\3\7\5")
-        buf.write("\7b\n\7\3\b\3\b\3\b\3\t\3\t\3\t\7\tj\n\t\f\t\16\tm\13")
-        buf.write("\t\5\to\n\t\3\n\3\n\3\n\3\n\7\nu\n\n\f\n\16\nx\13\n\3")
-        buf.write("\n\5\n{\n\n\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3")
-        buf.write("\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13")
-        buf.write("\3\13\3\13\3\13\3\13\6\13\u0094\n\13\r\13\16\13\u0095")
-        buf.write("\3\13\3\13\3\13\3\13\3\13\3\13\7\13\u009e\n\13\f\13\16")
-        buf.write("\13\u00a1\13\13\5\13\u00a3\n\13\3\13\3\13\3\13\3\13\3")
-        buf.write("\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13")
-        buf.write("\6\13\u00b4\n\13\r\13\16\13\u00b5\3\13\3\13\3\13\3\13")
+        buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\3\2\3\2\3\3\3\3\7")
+        buf.write("\3K\n\3\f\3\16\3N\13\3\3\3\5\3Q\n\3\3\3\5\3T\n\3\3\3\3")
+        buf.write("\3\3\4\3\4\3\4\7\4[\n\4\f\4\16\4^\13\4\3\5\3\5\3\5\3\6")
+        buf.write("\3\6\3\6\3\7\3\7\5\7h\n\7\3\b\3\b\3\b\3\t\3\t\3\t\7\t")
+        buf.write("p\n\t\f\t\16\ts\13\t\5\tu\n\t\3\n\3\n\3\n\3\n\7\n{\n\n")
+        buf.write("\f\n\16\n~\13\n\3\n\5\n\u0081\n\n\3\13\3\13\3\13\3\13")
+        buf.write("\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13")
+        buf.write("\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\6\13\u009a\n")
+        buf.write("\13\r\13\16\13\u009b\3\13\3\13\3\13\3\13\3\13\3\13\7\13")
+        buf.write("\u00a4\n\13\f\13\16\13\u00a7\13\13\5\13\u00a9\n\13\3\13")
         buf.write("\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13")
-        buf.write("\3\13\3\13\3\13\3\13\5\13\u00cb\n\13\3\13\3\13\3\13\3")
+        buf.write("\3\13\3\13\3\13\6\13\u00ba\n\13\r\13\16\13\u00bb\3\13")
+        buf.write("\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13")
+        buf.write("\3\13\3\13\3\13\3\13\3\13\3\13\3\13\5\13\u00d1\n\13\3")
         buf.write("\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13")
-        buf.write("\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\7\13\u00e4")
-        buf.write("\n\13\f\13\16\13\u00e7\13\13\3\f\3\f\5\f\u00eb\n\f\3\f")
-        buf.write("\3\f\3\f\3\f\3\f\5\f\u00f2\n\f\3\f\3\f\3\r\3\r\3\r\5\r")
-        buf.write("\u00f9\n\r\3\r\3\r\3\r\3\r\3\r\5\r\u0100\n\r\3\r\3\r\3")
-        buf.write("\r\3\r\3\r\5\r\u0107\n\r\3\r\3\r\6\r\u010b\n\r\r\r\16")
-        buf.write("\r\u010c\5\r\u010f\n\r\3\16\3\16\3\16\3\16\3\16\3\16\7")
-        buf.write("\16\u0117\n\16\f\16\16\16\u011a\13\16\3\16\3\16\5\16\u011e")
-        buf.write("\n\16\3\17\3\17\3\17\5\17\u0123\n\17\3\17\3\17\3\17\3")
-        buf.write("\20\3\20\3\21\3\21\3\21\3\21\7\21\u012e\n\21\f\21\16\21")
-        buf.write("\u0131\13\21\3\21\3\21\3\22\3\22\3\22\3\22\5\22\u0139")
-        buf.write("\n\22\5\22\u013b\n\22\3\23\3\23\3\24\3\24\3\24\3\24\7")
-        buf.write("\24\u0143\n\24\f\24\16\24\u0146\13\24\3\24\5\24\u0149")
-        buf.write("\n\24\3\25\3\25\3\25\7\25\u014e\n\25\f\25\16\25\u0151")
-        buf.write("\13\25\5\25\u0153\n\25\3\26\3\26\3\26\5\26\u0158\n\26")
-        buf.write("\3\27\3\27\3\27\7\27\u015d\n\27\f\27\16\27\u0160\13\27")
-        buf.write("\3\30\3\30\3\30\3\30\3\31\3\31\3\31\3\31\3\31\3\31\3\31")
-        buf.write("\3\31\3\31\3\31\3\31\6\31\u0171\n\31\r\31\16\31\u0172")
-        buf.write("\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31\3\31")
-        buf.write("\3\31\3\31\3\31\3\31\5\31\u0184\n\31\3\31\3\31\3\31\3")
-        buf.write("\31\7\31\u018a\n\31\f\31\16\31\u018d\13\31\5\31\u018f")
-        buf.write("\n\31\3\31\3\31\3\31\3\31\5\31\u0195\n\31\3\32\3\32\3")
-        buf.write("\32\3\32\7\32\u019b\n\32\f\32\16\32\u019e\13\32\3\32\3")
-        buf.write("\32\3\33\3\33\3\33\3\33\3\33\3\33\6\33\u01a8\n\33\r\33")
-        buf.write("\16\33\u01a9\3\33\3\33\3\33\5\33\u01af\n\33\3\34\3\34")
-        buf.write("\3\34\3\34\3\34\3\34\3\34\3\34\3\35\3\35\3\35\3\35\3\35")
-        buf.write("\3\35\5\35\u01bf\n\35\3\36\3\36\3\36\3\36\3\37\3\37\3")
-        buf.write("\37\5\37\u01c8\n\37\3 \3 \3 \3 \5 \u01ce\n \3 \2\3\24")
-        buf.write("!\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62")
-        buf.write("\64\668:<>\2\t\3\2\3\21\4\2\25\25??\3\2\63\64\3\2\65\66")
-        buf.write("\3\2\67:\3\2;<\3\2)*\2\u01fc\2@\3\2\2\2\4B\3\2\2\2\6Q")
-        buf.write("\3\2\2\2\bY\3\2\2\2\n\\\3\2\2\2\fa\3\2\2\2\16c\3\2\2\2")
-        buf.write("\20n\3\2\2\2\22z\3\2\2\2\24\u00ca\3\2\2\2\26\u00e8\3\2")
-        buf.write("\2\2\30\u010e\3\2\2\2\32\u0110\3\2\2\2\34\u011f\3\2\2")
-        buf.write("\2\36\u0127\3\2\2\2 \u0129\3\2\2\2\"\u013a\3\2\2\2$\u013c")
-        buf.write("\3\2\2\2&\u0148\3\2\2\2(\u0152\3\2\2\2*\u0154\3\2\2\2")
-        buf.write(",\u0159\3\2\2\2.\u0161\3\2\2\2\60\u0194\3\2\2\2\62\u0196")
-        buf.write("\3\2\2\2\64\u01ae\3\2\2\2\66\u01b0\3\2\2\28\u01be\3\2")
-        buf.write("\2\2:\u01c0\3\2\2\2<\u01c7\3\2\2\2>\u01cd\3\2\2\2@A\t")
-        buf.write("\2\2\2A\3\3\2\2\2BJ\7.\2\2CE\5\30\r\2DC\3\2\2\2EH\3\2")
-        buf.write("\2\2FD\3\2\2\2FG\3\2\2\2GK\3\2\2\2HF\3\2\2\2IK\5\24\13")
-        buf.write("\2JF\3\2\2\2JI\3\2\2\2KM\3\2\2\2LN\7B\2\2ML\3\2\2\2MN")
-        buf.write("\3\2\2\2NO\3\2\2\2OP\7\2\2\3P\5\3\2\2\2QV\7?\2\2RS\7\22")
-        buf.write("\2\2SU\7?\2\2TR\3\2\2\2UX\3\2\2\2VT\3\2\2\2VW\3\2\2\2")
-        buf.write("W\7\3\2\2\2XV\3\2\2\2YZ\7\23\2\2Z[\7?\2\2[\t\3\2\2\2\\")
-        buf.write("]\7\24\2\2]^\t\3\2\2^\13\3\2\2\2_b\5\2\2\2`b\7>\2\2a_")
-        buf.write("\3\2\2\2a`\3\2\2\2b\r\3\2\2\2cd\7\24\2\2de\7A\2\2e\17")
-        buf.write("\3\2\2\2fk\5\24\13\2gh\7\26\2\2hj\5\24\13\2ig\3\2\2\2")
-        buf.write("jm\3\2\2\2ki\3\2\2\2kl\3\2\2\2lo\3\2\2\2mk\3\2\2\2nf\3")
-        buf.write("\2\2\2no\3\2\2\2o\21\3\2\2\2p{\5\20\t\2qr\5\24\13\2rs")
-        buf.write("\7\26\2\2su\3\2\2\2tq\3\2\2\2ux\3\2\2\2vt\3\2\2\2vw\3")
-        buf.write("\2\2\2wy\3\2\2\2xv\3\2\2\2y{\5,\27\2zp\3\2\2\2zv\3\2\2")
-        buf.write("\2{\23\3\2\2\2|}\b\13\1\2}~\7\27\2\2~\177\5\24\13\2\177")
-        buf.write("\u0080\7\30\2\2\u0080\u00cb\3\2\2\2\u0081\u0082\7\31\2")
-        buf.write("\2\u0082\u0083\5\24\13\2\u0083\u0084\7\32\2\2\u0084\u00cb")
-        buf.write("\3\2\2\2\u0085\u0086\7\66\2\2\u0086\u00cb\5\24\13\26\u0087")
-        buf.write("\u00cb\5\26\f\2\u0088\u0089\7\27\2\2\u0089\u00cb\7\30")
-        buf.write("\2\2\u008a\u008b\7\27\2\2\u008b\u008c\5\24\13\2\u008c")
-        buf.write("\u008d\7\26\2\2\u008d\u008e\7\30\2\2\u008e\u00cb\3\2\2")
-        buf.write("\2\u008f\u0090\7\27\2\2\u0090\u0093\5\24\13\2\u0091\u0092")
-        buf.write("\7\26\2\2\u0092\u0094\5\24\13\2\u0093\u0091\3\2\2\2\u0094")
-        buf.write("\u0095\3\2\2\2\u0095\u0093\3\2\2\2\u0095\u0096\3\2\2\2")
-        buf.write("\u0096\u0097\3\2\2\2\u0097\u0098\7\30\2\2\u0098\u00cb")
-        buf.write("\3\2\2\2\u0099\u00a2\7\33\2\2\u009a\u009f\5\24\13\2\u009b")
-        buf.write("\u009c\7\26\2\2\u009c\u009e\5\24\13\2\u009d\u009b\3\2")
-        buf.write("\2\2\u009e\u00a1\3\2\2\2\u009f\u009d\3\2\2\2\u009f\u00a0")
-        buf.write("\3\2\2\2\u00a0\u00a3\3\2\2\2\u00a1\u009f\3\2\2\2\u00a2")
-        buf.write("\u009a\3\2\2\2\u00a2\u00a3\3\2\2\2\u00a3\u00a4\3\2\2\2")
-        buf.write("\u00a4\u00cb\7\34\2\2\u00a5\u00a6\7\35\2\2\u00a6\u00a7")
-        buf.write("\7\27\2\2\u00a7\u00a8\5\24\13\2\u00a8\u00a9\7\30\2\2\u00a9")
-        buf.write("\u00aa\5:\36\2\u00aa\u00ab\7\36\2\2\u00ab\u00ac\5:\36")
-        buf.write("\2\u00ac\u00cb\3\2\2\2\u00ad\u00ae\5\36\20\2\u00ae\u00af")
-        buf.write("\7\27\2\2\u00af\u00b0\5\24\13\2\u00b0\u00b1\7\30\2\2\u00b1")
-        buf.write("\u00b3\7\31\2\2\u00b2\u00b4\5\34\17\2\u00b3\u00b2\3\2")
-        buf.write("\2\2\u00b4\u00b5\3\2\2\2\u00b5\u00b3\3\2\2\2\u00b5\u00b6")
-        buf.write("\3\2\2\2\u00b6\u00b7\3\2\2\2\u00b7\u00b8\7\32\2\2\u00b8")
-        buf.write("\u00cb\3\2\2\2\u00b9\u00ba\7\37\2\2\u00ba\u00bb\5*\26")
-        buf.write("\2\u00bb\u00bc\7 \2\2\u00bc\u00bd\5\24\13\2\u00bd\u00be")
-        buf.write("\7!\2\2\u00be\u00bf\5\24\13\t\u00bf\u00cb\3\2\2\2\u00c0")
-        buf.write("\u00c1\5\16\b\2\u00c1\u00c2\7 \2\2\u00c2\u00c3\5\24\13")
-        buf.write("\2\u00c3\u00c4\7!\2\2\u00c4\u00c5\5\24\13\7\u00c5\u00cb")
-        buf.write("\3\2\2\2\u00c6\u00cb\5> \2\u00c7\u00cb\5<\37\2\u00c8\u00cb")
-        buf.write("\5\66\34\2\u00c9\u00cb\7\62\2\2\u00ca|\3\2\2\2\u00ca\u0081")
-        buf.write("\3\2\2\2\u00ca\u0085\3\2\2\2\u00ca\u0087\3\2\2\2\u00ca")
-        buf.write("\u0088\3\2\2\2\u00ca\u008a\3\2\2\2\u00ca\u008f\3\2\2\2")
-        buf.write("\u00ca\u0099\3\2\2\2\u00ca\u00a5\3\2\2\2\u00ca\u00ad\3")
-        buf.write("\2\2\2\u00ca\u00b9\3\2\2\2\u00ca\u00c0\3\2\2\2\u00ca\u00c6")
-        buf.write("\3\2\2\2\u00ca\u00c7\3\2\2\2\u00ca\u00c8\3\2\2\2\u00ca")
-        buf.write("\u00c9\3\2\2\2\u00cb\u00e5\3\2\2\2\u00cc\u00cd\f\25\2")
-        buf.write("\2\u00cd\u00ce\t\4\2\2\u00ce\u00e4\5\24\13\26\u00cf\u00d0")
-        buf.write("\f\24\2\2\u00d0\u00d1\t\5\2\2\u00d1\u00e4\5\24\13\25\u00d2")
-        buf.write("\u00d3\f\23\2\2\u00d3\u00d4\t\6\2\2\u00d4\u00e4\5\24\13")
-        buf.write("\24\u00d5\u00d6\f\22\2\2\u00d6\u00d7\t\7\2\2\u00d7\u00e4")
-        buf.write("\5\24\13\23\u00d8\u00d9\f\b\2\2\u00d9\u00da\7\"\2\2\u00da")
-        buf.write("\u00e4\5\24\13\t\u00db\u00dc\f\27\2\2\u00dc\u00dd\7\27")
-        buf.write("\2\2\u00dd\u00de\5\22\n\2\u00de\u00df\7\30\2\2\u00df\u00e4")
-        buf.write("\3\2\2\2\u00e0\u00e1\f\n\2\2\u00e1\u00e2\7\22\2\2\u00e2")
-        buf.write("\u00e4\7A\2\2\u00e3\u00cc\3\2\2\2\u00e3\u00cf\3\2\2\2")
-        buf.write("\u00e3\u00d2\3\2\2\2\u00e3\u00d5\3\2\2\2\u00e3\u00d8\3")
-        buf.write("\2\2\2\u00e3\u00db\3\2\2\2\u00e3\u00e0\3\2\2\2\u00e4\u00e7")
-        buf.write("\3\2\2\2\u00e5\u00e3\3\2\2\2\u00e5\u00e6\3\2\2\2\u00e6")
-        buf.write("\25\3\2\2\2\u00e7\u00e5\3\2\2\2\u00e8\u00ea\7#\2\2\u00e9")
-        buf.write("\u00eb\5\62\32\2\u00ea\u00e9\3\2\2\2\u00ea\u00eb\3\2\2")
-        buf.write("\2\u00eb\u00ec\3\2\2\2\u00ec\u00ed\7\27\2\2\u00ed\u00ee")
-        buf.write("\5&\24\2\u00ee\u00f1\7\30\2\2\u00ef\u00f0\7$\2\2\u00f0")
-        buf.write("\u00f2\5\60\31\2\u00f1\u00ef\3\2\2\2\u00f1\u00f2\3\2\2")
-        buf.write("\2\u00f2\u00f3\3\2\2\2\u00f3\u00f4\5:\36\2\u00f4\27\3")
-        buf.write("\2\2\2\u00f5\u00f6\7%\2\2\u00f6\u00f8\5\b\5\2\u00f7\u00f9")
-        buf.write("\5\62\32\2\u00f8\u00f7\3\2\2\2\u00f8\u00f9\3\2\2\2\u00f9")
-        buf.write("\u00fa\3\2\2\2\u00fa\u00fb\7\27\2\2\u00fb\u00fc\5&\24")
-        buf.write("\2\u00fc\u00ff\7\30\2\2\u00fd\u00fe\7$\2\2\u00fe\u0100")
-        buf.write("\5\60\31\2\u00ff\u00fd\3\2\2\2\u00ff\u0100\3\2\2\2\u0100")
-        buf.write("\u0101\3\2\2\2\u0101\u0102\5:\36\2\u0102\u010f\3\2\2\2")
-        buf.write("\u0103\u0104\7&\2\2\u0104\u0106\5\f\7\2\u0105\u0107\5")
-        buf.write("\62\32\2\u0106\u0105\3\2\2\2\u0106\u0107\3\2\2\2\u0107")
-        buf.write("\u0108\3\2\2\2\u0108\u010a\7 \2\2\u0109\u010b\5\32\16")
-        buf.write("\2\u010a\u0109\3\2\2\2\u010b\u010c\3\2\2\2\u010c\u010a")
-        buf.write("\3\2\2\2\u010c\u010d\3\2\2\2\u010d\u010f\3\2\2\2\u010e")
-        buf.write("\u00f5\3\2\2\2\u010e\u0103\3\2\2\2\u010f\31\3\2\2\2\u0110")
-        buf.write("\u0111\7\'\2\2\u0111\u011d\5$\23\2\u0112\u0113\7\27\2")
-        buf.write("\2\u0113\u0118\5\60\31\2\u0114\u0115\7\26\2\2\u0115\u0117")
-        buf.write("\5\60\31\2\u0116\u0114\3\2\2\2\u0117\u011a\3\2\2\2\u0118")
-        buf.write("\u0116\3\2\2\2\u0118\u0119\3\2\2\2\u0119\u011b\3\2\2\2")
-        buf.write("\u011a\u0118\3\2\2\2\u011b\u011c\7\30\2\2\u011c\u011e")
-        buf.write("\3\2\2\2\u011d\u0112\3\2\2\2\u011d\u011e\3\2\2\2\u011e")
-        buf.write("\33\3\2\2\2\u011f\u0120\7\'\2\2\u0120\u0122\5$\23\2\u0121")
-        buf.write("\u0123\5 \21\2\u0122\u0121\3\2\2\2\u0122\u0123\3\2\2\2")
-        buf.write("\u0123\u0124\3\2\2\2\u0124\u0125\7(\2\2\u0125\u0126\5")
-        buf.write("\24\13\2\u0126\35\3\2\2\2\u0127\u0128\t\b\2\2\u0128\37")
-        buf.write("\3\2\2\2\u0129\u012a\7\27\2\2\u012a\u012f\5\"\22\2\u012b")
-        buf.write("\u012c\7\26\2\2\u012c\u012e\5\"\22\2\u012d\u012b\3\2\2")
-        buf.write("\2\u012e\u0131\3\2\2\2\u012f\u012d\3\2\2\2\u012f\u0130")
-        buf.write("\3\2\2\2\u0130\u0132\3\2\2\2\u0131\u012f\3\2\2\2\u0132")
-        buf.write("\u0133\7\30\2\2\u0133!\3\2\2\2\u0134\u013b\7\25\2\2\u0135")
-        buf.write("\u0138\5\n\6\2\u0136\u0137\7+\2\2\u0137\u0139\5\60\31")
-        buf.write("\2\u0138\u0136\3\2\2\2\u0138\u0139\3\2\2\2\u0139\u013b")
-        buf.write("\3\2\2\2\u013a\u0134\3\2\2\2\u013a\u0135\3\2\2\2\u013b")
-        buf.write("#\3\2\2\2\u013c\u013d\7>\2\2\u013d%\3\2\2\2\u013e\u0149")
-        buf.write("\5(\25\2\u013f\u0140\5*\26\2\u0140\u0141\7\26\2\2\u0141")
-        buf.write("\u0143\3\2\2\2\u0142\u013f\3\2\2\2\u0143\u0146\3\2\2\2")
-        buf.write("\u0144\u0142\3\2\2\2\u0144\u0145\3\2\2\2\u0145\u0147\3")
-        buf.write("\2\2\2\u0146\u0144\3\2\2\2\u0147\u0149\5,\27\2\u0148\u013e")
-        buf.write("\3\2\2\2\u0148\u0144\3\2\2\2\u0149\'\3\2\2\2\u014a\u014f")
-        buf.write("\5*\26\2\u014b\u014c\7\26\2\2\u014c\u014e\5*\26\2\u014d")
-        buf.write("\u014b\3\2\2\2\u014e\u0151\3\2\2\2\u014f\u014d\3\2\2\2")
-        buf.write("\u014f\u0150\3\2\2\2\u0150\u0153\3\2\2\2\u0151\u014f\3")
-        buf.write("\2\2\2\u0152\u014a\3\2\2\2\u0152\u0153\3\2\2\2\u0153)")
-        buf.write("\3\2\2\2\u0154\u0157\5\n\6\2\u0155\u0156\7+\2\2\u0156")
-        buf.write("\u0158\5\60\31\2\u0157\u0155\3\2\2\2\u0157\u0158\3\2\2")
-        buf.write("\2\u0158+\3\2\2\2\u0159\u015e\5.\30\2\u015a\u015b\7\26")
-        buf.write("\2\2\u015b\u015d\5.\30\2\u015c\u015a\3\2\2\2\u015d\u0160")
-        buf.write("\3\2\2\2\u015e\u015c\3\2\2\2\u015e\u015f\3\2\2\2\u015f")
-        buf.write("-\3\2\2\2\u0160\u015e\3\2\2\2\u0161\u0162\7?\2\2\u0162")
-        buf.write("\u0163\7 \2\2\u0163\u0164\5\24\13\2\u0164/\3\2\2\2\u0165")
-        buf.write("\u0166\7\27\2\2\u0166\u0195\7\30\2\2\u0167\u0168\7\27")
-        buf.write("\2\2\u0168\u0169\5\60\31\2\u0169\u016a\7\26\2\2\u016a")
-        buf.write("\u016b\7\30\2\2\u016b\u0195\3\2\2\2\u016c\u016d\7\27\2")
-        buf.write("\2\u016d\u0170\5\60\31\2\u016e\u016f\7\26\2\2\u016f\u0171")
-        buf.write("\5\60\31\2\u0170\u016e\3\2\2\2\u0171\u0172\3\2\2\2\u0172")
-        buf.write("\u0170\3\2\2\2\u0172\u0173\3\2\2\2\u0173\u0174\3\2\2\2")
-        buf.write("\u0174\u0175\7\30\2\2\u0175\u0195\3\2\2\2\u0176\u0177")
-        buf.write("\5\f\7\2\u0177\u0178\5\62\32\2\u0178\u0195\3\2\2\2\u0179")
-        buf.write("\u0195\5\f\7\2\u017a\u017b\7,\2\2\u017b\u017c\7\33\2\2")
-        buf.write("\u017c\u017d\5\64\33\2\u017d\u017e\7\26\2\2\u017e\u017f")
-        buf.write("\5\60\31\2\u017f\u0180\7\34\2\2\u0180\u0195\3\2\2\2\u0181")
-        buf.write("\u0183\7#\2\2\u0182\u0184\5\62\32\2\u0183\u0182\3\2\2")
-        buf.write("\2\u0183\u0184\3\2\2\2\u0184\u0185\3\2\2\2\u0185\u018e")
-        buf.write("\7\27\2\2\u0186\u018b\5\60\31\2\u0187\u0188\7\26\2\2\u0188")
-        buf.write("\u018a\5\60\31\2\u0189\u0187\3\2\2\2\u018a\u018d\3\2\2")
-        buf.write("\2\u018b\u0189\3\2\2\2\u018b\u018c\3\2\2\2\u018c\u018f")
-        buf.write("\3\2\2\2\u018d\u018b\3\2\2\2\u018e\u0186\3\2\2\2\u018e")
-        buf.write("\u018f\3\2\2\2\u018f\u0190\3\2\2\2\u0190\u0191\7\30\2")
-        buf.write("\2\u0191\u0192\7$\2\2\u0192\u0195\5\60\31\2\u0193\u0195")
-        buf.write("\7\25\2\2\u0194\u0165\3\2\2\2\u0194\u0167\3\2\2\2\u0194")
-        buf.write("\u016c\3\2\2\2\u0194\u0176\3\2\2\2\u0194\u0179\3\2\2\2")
-        buf.write("\u0194\u017a\3\2\2\2\u0194\u0181\3\2\2\2\u0194\u0193\3")
-        buf.write("\2\2\2\u0195\61\3\2\2\2\u0196\u0197\7\33\2\2\u0197\u019c")
-        buf.write("\5\f\7\2\u0198\u0199\7\26\2\2\u0199\u019b\5\f\7\2\u019a")
-        buf.write("\u0198\3\2\2\2\u019b\u019e\3\2\2\2\u019c\u019a\3\2\2\2")
-        buf.write("\u019c\u019d\3\2\2\2\u019d\u019f\3\2\2\2\u019e\u019c\3")
-        buf.write("\2\2\2\u019f\u01a0\7\34\2\2\u01a0\63\3\2\2\2\u01a1\u01a2")
-        buf.write("\7\27\2\2\u01a2\u01af\7\30\2\2\u01a3\u01a4\7\27\2\2\u01a4")
-        buf.write("\u01a7\58\35\2\u01a5\u01a6\7\26\2\2\u01a6\u01a8\58\35")
-        buf.write("\2\u01a7\u01a5\3\2\2\2\u01a8\u01a9\3\2\2\2\u01a9\u01a7")
-        buf.write("\3\2\2\2\u01a9\u01aa\3\2\2\2\u01aa\u01ab\3\2\2\2\u01ab")
-        buf.write("\u01ac\7\30\2\2\u01ac\u01af\3\2\2\2\u01ad\u01af\58\35")
-        buf.write("\2\u01ae\u01a1\3\2\2\2\u01ae\u01a3\3\2\2\2\u01ae\u01ad")
-        buf.write("\3\2\2\2\u01af\65\3\2\2\2\u01b0\u01b1\7-\2\2\u01b1\u01b2")
-        buf.write("\7\33\2\2\u01b2\u01b3\7?\2\2\u01b3\u01b4\7\34\2\2\u01b4")
-        buf.write("\u01b5\7\33\2\2\u01b5\u01b6\7A\2\2\u01b6\u01b7\7\34\2")
-        buf.write("\2\u01b7\67\3\2\2\2\u01b8\u01bf\5\66\34\2\u01b9\u01ba")
-        buf.write("\7\27\2\2\u01ba\u01bb\58\35\2\u01bb\u01bc\7\30\2\2\u01bc")
-        buf.write("\u01bf\3\2\2\2\u01bd\u01bf\7A\2\2\u01be\u01b8\3\2\2\2")
-        buf.write("\u01be\u01b9\3\2\2\2\u01be\u01bd\3\2\2\2\u01bf9\3\2\2")
-        buf.write("\2\u01c0\u01c1\7\31\2\2\u01c1\u01c2\5\24\13\2\u01c2\u01c3")
-        buf.write("\7\32\2\2\u01c3;\3\2\2\2\u01c4\u01c8\7@\2\2\u01c5\u01c8")
-        buf.write("\7A\2\2\u01c6\u01c8\7=\2\2\u01c7\u01c4\3\2\2\2\u01c7\u01c5")
-        buf.write("\3\2\2\2\u01c7\u01c6\3\2\2\2\u01c8=\3\2\2\2\u01c9\u01ce")
-        buf.write("\5\6\4\2\u01ca\u01ce\5\b\5\2\u01cb\u01ce\5\n\6\2\u01cc")
-        buf.write("\u01ce\5\16\b\2\u01cd\u01c9\3\2\2\2\u01cd\u01ca\3\2\2")
-        buf.write("\2\u01cd\u01cb\3\2\2\2\u01cd\u01cc\3\2\2\2\u01ce?\3\2")
-        buf.write("\2\2\60FJMVaknvz\u0095\u009f\u00a2\u00b5\u00ca\u00e3\u00e5")
-        buf.write("\u00ea\u00f1\u00f8\u00ff\u0106\u010c\u010e\u0118\u011d")
-        buf.write("\u0122\u012f\u0138\u013a\u0144\u0148\u014f\u0152\u0157")
-        buf.write("\u015e\u0172\u0183\u018b\u018e\u0194\u019c\u01a9\u01ae")
-        buf.write("\u01be\u01c7\u01cd")
+        buf.write("\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13")
+        buf.write("\3\13\7\13\u00ea\n\13\f\13\16\13\u00ed\13\13\3\f\3\f\5")
+        buf.write("\f\u00f1\n\f\3\f\3\f\3\f\3\f\3\f\5\f\u00f8\n\f\3\f\3\f")
+        buf.write("\3\r\3\r\3\r\5\r\u00ff\n\r\3\r\3\r\3\r\3\r\3\r\5\r\u0106")
+        buf.write("\n\r\3\r\3\r\3\r\3\r\3\r\5\r\u010d\n\r\3\r\3\r\6\r\u0111")
+        buf.write("\n\r\r\r\16\r\u0112\5\r\u0115\n\r\3\16\3\16\3\17\3\17")
+        buf.write("\3\17\3\17\3\17\3\17\7\17\u011f\n\17\f\17\16\17\u0122")
+        buf.write("\13\17\3\17\3\17\5\17\u0126\n\17\3\20\3\20\3\20\5\20\u012b")
+        buf.write("\n\20\3\20\3\20\3\20\3\21\3\21\3\22\3\22\3\22\3\22\7\22")
+        buf.write("\u0136\n\22\f\22\16\22\u0139\13\22\3\22\3\22\3\23\3\23")
+        buf.write("\3\23\3\23\5\23\u0141\n\23\5\23\u0143\n\23\3\24\3\24\5")
+        buf.write("\24\u0147\n\24\3\25\3\25\3\25\3\25\7\25\u014d\n\25\f\25")
+        buf.write("\16\25\u0150\13\25\3\25\3\25\3\26\3\26\5\26\u0156\n\26")
+        buf.write("\3\27\3\27\3\27\3\27\7\27\u015c\n\27\f\27\16\27\u015f")
+        buf.write("\13\27\3\27\5\27\u0162\n\27\3\30\3\30\3\30\7\30\u0167")
+        buf.write("\n\30\f\30\16\30\u016a\13\30\5\30\u016c\n\30\3\31\3\31")
+        buf.write("\3\31\5\31\u0171\n\31\3\32\3\32\3\32\7\32\u0176\n\32\f")
+        buf.write("\32\16\32\u0179\13\32\3\33\3\33\3\33\3\33\3\34\3\34\3")
+        buf.write("\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\6\34\u018a")
+        buf.write("\n\34\r\34\16\34\u018b\3\34\3\34\3\34\3\34\3\34\3\34\3")
+        buf.write("\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\5\34\u019d")
+        buf.write("\n\34\3\34\3\34\3\34\3\34\7\34\u01a3\n\34\f\34\16\34\u01a6")
+        buf.write("\13\34\5\34\u01a8\n\34\3\34\3\34\3\34\3\34\5\34\u01ae")
+        buf.write("\n\34\3\35\3\35\3\35\3\35\7\35\u01b4\n\35\f\35\16\35\u01b7")
+        buf.write("\13\35\3\35\3\35\3\36\3\36\3\36\3\36\3\36\3\36\6\36\u01c1")
+        buf.write("\n\36\r\36\16\36\u01c2\3\36\3\36\3\36\5\36\u01c8\n\36")
+        buf.write("\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3 \3 \3 \3 \3")
+        buf.write(" \3 \5 \u01d8\n \3!\3!\3!\3!\3\"\3\"\3\"\5\"\u01e1\n\"")
+        buf.write("\3#\3#\3#\3#\3#\5#\u01e8\n#\3#\2\3\24$\2\4\6\b\n\f\16")
+        buf.write("\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BD\2")
+        buf.write("\t\3\2\3\21\4\2\25\25??\3\2\63\64\3\2\65\66\3\2\67:\3")
+        buf.write("\2;<\3\2)*\2\u0217\2F\3\2\2\2\4H\3\2\2\2\6W\3\2\2\2\b")
+        buf.write("_\3\2\2\2\nb\3\2\2\2\fg\3\2\2\2\16i\3\2\2\2\20t\3\2\2")
+        buf.write("\2\22\u0080\3\2\2\2\24\u00d0\3\2\2\2\26\u00ee\3\2\2\2")
+        buf.write("\30\u0114\3\2\2\2\32\u0116\3\2\2\2\34\u0118\3\2\2\2\36")
+        buf.write("\u0127\3\2\2\2 \u012f\3\2\2\2\"\u0131\3\2\2\2$\u0142\3")
+        buf.write("\2\2\2&\u0144\3\2\2\2(\u0148\3\2\2\2*\u0155\3\2\2\2,\u0161")
+        buf.write("\3\2\2\2.\u016b\3\2\2\2\60\u016d\3\2\2\2\62\u0172\3\2")
+        buf.write("\2\2\64\u017a\3\2\2\2\66\u01ad\3\2\2\28\u01af\3\2\2\2")
+        buf.write(":\u01c7\3\2\2\2<\u01c9\3\2\2\2>\u01d7\3\2\2\2@\u01d9\3")
+        buf.write("\2\2\2B\u01e0\3\2\2\2D\u01e7\3\2\2\2FG\t\2\2\2G\3\3\2")
+        buf.write("\2\2HP\7.\2\2IK\5\30\r\2JI\3\2\2\2KN\3\2\2\2LJ\3\2\2\2")
+        buf.write("LM\3\2\2\2MQ\3\2\2\2NL\3\2\2\2OQ\5\24\13\2PL\3\2\2\2P")
+        buf.write("O\3\2\2\2QS\3\2\2\2RT\7B\2\2SR\3\2\2\2ST\3\2\2\2TU\3\2")
+        buf.write("\2\2UV\7\2\2\3V\5\3\2\2\2W\\\7?\2\2XY\7\22\2\2Y[\7?\2")
+        buf.write("\2ZX\3\2\2\2[^\3\2\2\2\\Z\3\2\2\2\\]\3\2\2\2]\7\3\2\2")
+        buf.write("\2^\\\3\2\2\2_`\7\23\2\2`a\7?\2\2a\t\3\2\2\2bc\7\24\2")
+        buf.write("\2cd\t\3\2\2d\13\3\2\2\2eh\5\2\2\2fh\7>\2\2ge\3\2\2\2")
+        buf.write("gf\3\2\2\2h\r\3\2\2\2ij\7\24\2\2jk\7A\2\2k\17\3\2\2\2")
+        buf.write("lq\5\24\13\2mn\7\26\2\2np\5\24\13\2om\3\2\2\2ps\3\2\2")
+        buf.write("\2qo\3\2\2\2qr\3\2\2\2ru\3\2\2\2sq\3\2\2\2tl\3\2\2\2t")
+        buf.write("u\3\2\2\2u\21\3\2\2\2v\u0081\5\20\t\2wx\5\24\13\2xy\7")
+        buf.write("\26\2\2y{\3\2\2\2zw\3\2\2\2{~\3\2\2\2|z\3\2\2\2|}\3\2")
+        buf.write("\2\2}\177\3\2\2\2~|\3\2\2\2\177\u0081\5\62\32\2\u0080")
+        buf.write("v\3\2\2\2\u0080|\3\2\2\2\u0081\23\3\2\2\2\u0082\u0083")
+        buf.write("\b\13\1\2\u0083\u0084\7\27\2\2\u0084\u0085\5\24\13\2\u0085")
+        buf.write("\u0086\7\30\2\2\u0086\u00d1\3\2\2\2\u0087\u0088\7\31\2")
+        buf.write("\2\u0088\u0089\5\24\13\2\u0089\u008a\7\32\2\2\u008a\u00d1")
+        buf.write("\3\2\2\2\u008b\u008c\7\66\2\2\u008c\u00d1\5\24\13\26\u008d")
+        buf.write("\u00d1\5\26\f\2\u008e\u008f\7\27\2\2\u008f\u00d1\7\30")
+        buf.write("\2\2\u0090\u0091\7\27\2\2\u0091\u0092\5\24\13\2\u0092")
+        buf.write("\u0093\7\26\2\2\u0093\u0094\7\30\2\2\u0094\u00d1\3\2\2")
+        buf.write("\2\u0095\u0096\7\27\2\2\u0096\u0099\5\24\13\2\u0097\u0098")
+        buf.write("\7\26\2\2\u0098\u009a\5\24\13\2\u0099\u0097\3\2\2\2\u009a")
+        buf.write("\u009b\3\2\2\2\u009b\u0099\3\2\2\2\u009b\u009c\3\2\2\2")
+        buf.write("\u009c\u009d\3\2\2\2\u009d\u009e\7\30\2\2\u009e\u00d1")
+        buf.write("\3\2\2\2\u009f\u00a8\7\33\2\2\u00a0\u00a5\5\24\13\2\u00a1")
+        buf.write("\u00a2\7\26\2\2\u00a2\u00a4\5\24\13\2\u00a3\u00a1\3\2")
+        buf.write("\2\2\u00a4\u00a7\3\2\2\2\u00a5\u00a3\3\2\2\2\u00a5\u00a6")
+        buf.write("\3\2\2\2\u00a6\u00a9\3\2\2\2\u00a7\u00a5\3\2\2\2\u00a8")
+        buf.write("\u00a0\3\2\2\2\u00a8\u00a9\3\2\2\2\u00a9\u00aa\3\2\2\2")
+        buf.write("\u00aa\u00d1\7\34\2\2\u00ab\u00ac\7\35\2\2\u00ac\u00ad")
+        buf.write("\7\27\2\2\u00ad\u00ae\5\24\13\2\u00ae\u00af\7\30\2\2\u00af")
+        buf.write("\u00b0\5@!\2\u00b0\u00b1\7\36\2\2\u00b1\u00b2\5@!\2\u00b2")
+        buf.write("\u00d1\3\2\2\2\u00b3\u00b4\5 \21\2\u00b4\u00b5\7\27\2")
+        buf.write("\2\u00b5\u00b6\5\24\13\2\u00b6\u00b7\7\30\2\2\u00b7\u00b9")
+        buf.write("\7\31\2\2\u00b8\u00ba\5\36\20\2\u00b9\u00b8\3\2\2\2\u00ba")
+        buf.write("\u00bb\3\2\2\2\u00bb\u00b9\3\2\2\2\u00bb\u00bc\3\2\2\2")
+        buf.write("\u00bc\u00bd\3\2\2\2\u00bd\u00be\7\32\2\2\u00be\u00d1")
+        buf.write("\3\2\2\2\u00bf\u00c0\7\37\2\2\u00c0\u00c1\5\60\31\2\u00c1")
+        buf.write("\u00c2\7 \2\2\u00c2\u00c3\5\24\13\2\u00c3\u00c4\7!\2\2")
+        buf.write("\u00c4\u00c5\5\24\13\t\u00c5\u00d1\3\2\2\2\u00c6\u00c7")
+        buf.write("\5\16\b\2\u00c7\u00c8\7 \2\2\u00c8\u00c9\5\24\13\2\u00c9")
+        buf.write("\u00ca\7!\2\2\u00ca\u00cb\5\24\13\7\u00cb\u00d1\3\2\2")
+        buf.write("\2\u00cc\u00d1\5D#\2\u00cd\u00d1\5B\"\2\u00ce\u00d1\5")
+        buf.write("<\37\2\u00cf\u00d1\7\62\2\2\u00d0\u0082\3\2\2\2\u00d0")
+        buf.write("\u0087\3\2\2\2\u00d0\u008b\3\2\2\2\u00d0\u008d\3\2\2\2")
+        buf.write("\u00d0\u008e\3\2\2\2\u00d0\u0090\3\2\2\2\u00d0\u0095\3")
+        buf.write("\2\2\2\u00d0\u009f\3\2\2\2\u00d0\u00ab\3\2\2\2\u00d0\u00b3")
+        buf.write("\3\2\2\2\u00d0\u00bf\3\2\2\2\u00d0\u00c6\3\2\2\2\u00d0")
+        buf.write("\u00cc\3\2\2\2\u00d0\u00cd\3\2\2\2\u00d0\u00ce\3\2\2\2")
+        buf.write("\u00d0\u00cf\3\2\2\2\u00d1\u00eb\3\2\2\2\u00d2\u00d3\f")
+        buf.write("\25\2\2\u00d3\u00d4\t\4\2\2\u00d4\u00ea\5\24\13\26\u00d5")
+        buf.write("\u00d6\f\24\2\2\u00d6\u00d7\t\5\2\2\u00d7\u00ea\5\24\13")
+        buf.write("\25\u00d8\u00d9\f\23\2\2\u00d9\u00da\t\6\2\2\u00da\u00ea")
+        buf.write("\5\24\13\24\u00db\u00dc\f\22\2\2\u00dc\u00dd\t\7\2\2\u00dd")
+        buf.write("\u00ea\5\24\13\23\u00de\u00df\f\b\2\2\u00df\u00e0\7\"")
+        buf.write("\2\2\u00e0\u00ea\5\24\13\t\u00e1\u00e2\f\27\2\2\u00e2")
+        buf.write("\u00e3\7\27\2\2\u00e3\u00e4\5\22\n\2\u00e4\u00e5\7\30")
+        buf.write("\2\2\u00e5\u00ea\3\2\2\2\u00e6\u00e7\f\n\2\2\u00e7\u00e8")
+        buf.write("\7\22\2\2\u00e8\u00ea\7A\2\2\u00e9\u00d2\3\2\2\2\u00e9")
+        buf.write("\u00d5\3\2\2\2\u00e9\u00d8\3\2\2\2\u00e9\u00db\3\2\2\2")
+        buf.write("\u00e9\u00de\3\2\2\2\u00e9\u00e1\3\2\2\2\u00e9\u00e6\3")
+        buf.write("\2\2\2\u00ea\u00ed\3\2\2\2\u00eb\u00e9\3\2\2\2\u00eb\u00ec")
+        buf.write("\3\2\2\2\u00ec\25\3\2\2\2\u00ed\u00eb\3\2\2\2\u00ee\u00f0")
+        buf.write("\7#\2\2\u00ef\u00f1\58\35\2\u00f0\u00ef\3\2\2\2\u00f0")
+        buf.write("\u00f1\3\2\2\2\u00f1\u00f2\3\2\2\2\u00f2\u00f3\7\27\2")
+        buf.write("\2\u00f3\u00f4\5,\27\2\u00f4\u00f7\7\30\2\2\u00f5\u00f6")
+        buf.write("\7$\2\2\u00f6\u00f8\5\66\34\2\u00f7\u00f5\3\2\2\2\u00f7")
+        buf.write("\u00f8\3\2\2\2\u00f8\u00f9\3\2\2\2\u00f9\u00fa\5@!\2\u00fa")
+        buf.write("\27\3\2\2\2\u00fb\u00fc\7%\2\2\u00fc\u00fe\5\b\5\2\u00fd")
+        buf.write("\u00ff\58\35\2\u00fe\u00fd\3\2\2\2\u00fe\u00ff\3\2\2\2")
+        buf.write("\u00ff\u0100\3\2\2\2\u0100\u0101\7\27\2\2\u0101\u0102")
+        buf.write("\5,\27\2\u0102\u0105\7\30\2\2\u0103\u0104\7$\2\2\u0104")
+        buf.write("\u0106\5\66\34\2\u0105\u0103\3\2\2\2\u0105\u0106\3\2\2")
+        buf.write("\2\u0106\u0107\3\2\2\2\u0107\u0108\5@!\2\u0108\u0115\3")
+        buf.write("\2\2\2\u0109\u010a\7&\2\2\u010a\u010c\5\f\7\2\u010b\u010d")
+        buf.write("\58\35\2\u010c\u010b\3\2\2\2\u010c\u010d\3\2\2\2\u010d")
+        buf.write("\u010e\3\2\2\2\u010e\u0110\7 \2\2\u010f\u0111\5\34\17")
+        buf.write("\2\u0110\u010f\3\2\2\2\u0111\u0112\3\2\2\2\u0112\u0110")
+        buf.write("\3\2\2\2\u0112\u0113\3\2\2\2\u0113\u0115\3\2\2\2\u0114")
+        buf.write("\u00fb\3\2\2\2\u0114\u0109\3\2\2\2\u0115\31\3\2\2\2\u0116")
+        buf.write("\u0117\7>\2\2\u0117\33\3\2\2\2\u0118\u0119\7\'\2\2\u0119")
+        buf.write("\u0125\5\32\16\2\u011a\u011b\7\27\2\2\u011b\u0120\5\66")
+        buf.write("\34\2\u011c\u011d\7\26\2\2\u011d\u011f\5\66\34\2\u011e")
+        buf.write("\u011c\3\2\2\2\u011f\u0122\3\2\2\2\u0120\u011e\3\2\2\2")
+        buf.write("\u0120\u0121\3\2\2\2\u0121\u0123\3\2\2\2\u0122\u0120\3")
+        buf.write("\2\2\2\u0123\u0124\7\30\2\2\u0124\u0126\3\2\2\2\u0125")
+        buf.write("\u011a\3\2\2\2\u0125\u0126\3\2\2\2\u0126\35\3\2\2\2\u0127")
+        buf.write("\u0128\7\'\2\2\u0128\u012a\5\32\16\2\u0129\u012b\5\"\22")
+        buf.write("\2\u012a\u0129\3\2\2\2\u012a\u012b\3\2\2\2\u012b\u012c")
+        buf.write("\3\2\2\2\u012c\u012d\7(\2\2\u012d\u012e\5\24\13\2\u012e")
+        buf.write("\37\3\2\2\2\u012f\u0130\t\b\2\2\u0130!\3\2\2\2\u0131\u0132")
+        buf.write("\7\27\2\2\u0132\u0137\5$\23\2\u0133\u0134\7\26\2\2\u0134")
+        buf.write("\u0136\5$\23\2\u0135\u0133\3\2\2\2\u0136\u0139\3\2\2\2")
+        buf.write("\u0137\u0135\3\2\2\2\u0137\u0138\3\2\2\2\u0138\u013a\3")
+        buf.write("\2\2\2\u0139\u0137\3\2\2\2\u013a\u013b\7\30\2\2\u013b")
+        buf.write("#\3\2\2\2\u013c\u0143\7\25\2\2\u013d\u0140\5\n\6\2\u013e")
+        buf.write("\u013f\7+\2\2\u013f\u0141\5\66\34\2\u0140\u013e\3\2\2")
+        buf.write("\2\u0140\u0141\3\2\2\2\u0141\u0143\3\2\2\2\u0142\u013c")
+        buf.write("\3\2\2\2\u0142\u013d\3\2\2\2\u0143%\3\2\2\2\u0144\u0146")
+        buf.write("\5\32\16\2\u0145\u0147\5(\25\2\u0146\u0145\3\2\2\2\u0146")
+        buf.write("\u0147\3\2\2\2\u0147\'\3\2\2\2\u0148\u0149\7\27\2\2\u0149")
+        buf.write("\u014e\5*\26\2\u014a\u014b\7\26\2\2\u014b\u014d\5*\26")
+        buf.write("\2\u014c\u014a\3\2\2\2\u014d\u0150\3\2\2\2\u014e\u014c")
+        buf.write("\3\2\2\2\u014e\u014f\3\2\2\2\u014f\u0151\3\2\2\2\u0150")
+        buf.write("\u014e\3\2\2\2\u0151\u0152\7\30\2\2\u0152)\3\2\2\2\u0153")
+        buf.write("\u0156\5\n\6\2\u0154\u0156\5\32\16\2\u0155\u0153\3\2\2")
+        buf.write("\2\u0155\u0154\3\2\2\2\u0156+\3\2\2\2\u0157\u0162\5.\30")
+        buf.write("\2\u0158\u0159\5\60\31\2\u0159\u015a\7\26\2\2\u015a\u015c")
+        buf.write("\3\2\2\2\u015b\u0158\3\2\2\2\u015c\u015f\3\2\2\2\u015d")
+        buf.write("\u015b\3\2\2\2\u015d\u015e\3\2\2\2\u015e\u0160\3\2\2\2")
+        buf.write("\u015f\u015d\3\2\2\2\u0160\u0162\5\62\32\2\u0161\u0157")
+        buf.write("\3\2\2\2\u0161\u015d\3\2\2\2\u0162-\3\2\2\2\u0163\u0168")
+        buf.write("\5\60\31\2\u0164\u0165\7\26\2\2\u0165\u0167\5\60\31\2")
+        buf.write("\u0166\u0164\3\2\2\2\u0167\u016a\3\2\2\2\u0168\u0166\3")
+        buf.write("\2\2\2\u0168\u0169\3\2\2\2\u0169\u016c\3\2\2\2\u016a\u0168")
+        buf.write("\3\2\2\2\u016b\u0163\3\2\2\2\u016b\u016c\3\2\2\2\u016c")
+        buf.write("/\3\2\2\2\u016d\u0170\5\n\6\2\u016e\u016f\7+\2\2\u016f")
+        buf.write("\u0171\5\66\34\2\u0170\u016e\3\2\2\2\u0170\u0171\3\2\2")
+        buf.write("\2\u0171\61\3\2\2\2\u0172\u0177\5\64\33\2\u0173\u0174")
+        buf.write("\7\26\2\2\u0174\u0176\5\64\33\2\u0175\u0173\3\2\2\2\u0176")
+        buf.write("\u0179\3\2\2\2\u0177\u0175\3\2\2\2\u0177\u0178\3\2\2\2")
+        buf.write("\u0178\63\3\2\2\2\u0179\u0177\3\2\2\2\u017a\u017b\7?\2")
+        buf.write("\2\u017b\u017c\7 \2\2\u017c\u017d\5\24\13\2\u017d\65\3")
+        buf.write("\2\2\2\u017e\u017f\7\27\2\2\u017f\u01ae\7\30\2\2\u0180")
+        buf.write("\u0181\7\27\2\2\u0181\u0182\5\66\34\2\u0182\u0183\7\26")
+        buf.write("\2\2\u0183\u0184\7\30\2\2\u0184\u01ae\3\2\2\2\u0185\u0186")
+        buf.write("\7\27\2\2\u0186\u0189\5\66\34\2\u0187\u0188\7\26\2\2\u0188")
+        buf.write("\u018a\5\66\34\2\u0189\u0187\3\2\2\2\u018a\u018b\3\2\2")
+        buf.write("\2\u018b\u0189\3\2\2\2\u018b\u018c\3\2\2\2\u018c\u018d")
+        buf.write("\3\2\2\2\u018d\u018e\7\30\2\2\u018e\u01ae\3\2\2\2\u018f")
+        buf.write("\u0190\5\f\7\2\u0190\u0191\58\35\2\u0191\u01ae\3\2\2\2")
+        buf.write("\u0192\u01ae\5\f\7\2\u0193\u0194\7,\2\2\u0194\u0195\7")
+        buf.write("\33\2\2\u0195\u0196\5:\36\2\u0196\u0197\7\26\2\2\u0197")
+        buf.write("\u0198\5\66\34\2\u0198\u0199\7\34\2\2\u0199\u01ae\3\2")
+        buf.write("\2\2\u019a\u019c\7#\2\2\u019b\u019d\58\35\2\u019c\u019b")
+        buf.write("\3\2\2\2\u019c\u019d\3\2\2\2\u019d\u019e\3\2\2\2\u019e")
+        buf.write("\u01a7\7\27\2\2\u019f\u01a4\5\66\34\2\u01a0\u01a1\7\26")
+        buf.write("\2\2\u01a1\u01a3\5\66\34\2\u01a2\u01a0\3\2\2\2\u01a3\u01a6")
+        buf.write("\3\2\2\2\u01a4\u01a2\3\2\2\2\u01a4\u01a5\3\2\2\2\u01a5")
+        buf.write("\u01a8\3\2\2\2\u01a6\u01a4\3\2\2\2\u01a7\u019f\3\2\2\2")
+        buf.write("\u01a7\u01a8\3\2\2\2\u01a8\u01a9\3\2\2\2\u01a9\u01aa\7")
+        buf.write("\30\2\2\u01aa\u01ab\7$\2\2\u01ab\u01ae\5\66\34\2\u01ac")
+        buf.write("\u01ae\7\25\2\2\u01ad\u017e\3\2\2\2\u01ad\u0180\3\2\2")
+        buf.write("\2\u01ad\u0185\3\2\2\2\u01ad\u018f\3\2\2\2\u01ad\u0192")
+        buf.write("\3\2\2\2\u01ad\u0193\3\2\2\2\u01ad\u019a\3\2\2\2\u01ad")
+        buf.write("\u01ac\3\2\2\2\u01ae\67\3\2\2\2\u01af\u01b0\7\33\2\2\u01b0")
+        buf.write("\u01b5\5\f\7\2\u01b1\u01b2\7\26\2\2\u01b2\u01b4\5\f\7")
+        buf.write("\2\u01b3\u01b1\3\2\2\2\u01b4\u01b7\3\2\2\2\u01b5\u01b3")
+        buf.write("\3\2\2\2\u01b5\u01b6\3\2\2\2\u01b6\u01b8\3\2\2\2\u01b7")
+        buf.write("\u01b5\3\2\2\2\u01b8\u01b9\7\34\2\2\u01b99\3\2\2\2\u01ba")
+        buf.write("\u01bb\7\27\2\2\u01bb\u01c8\7\30\2\2\u01bc\u01bd\7\27")
+        buf.write("\2\2\u01bd\u01c0\5> \2\u01be\u01bf\7\26\2\2\u01bf\u01c1")
+        buf.write("\5> \2\u01c0\u01be\3\2\2\2\u01c1\u01c2\3\2\2\2\u01c2\u01c0")
+        buf.write("\3\2\2\2\u01c2\u01c3\3\2\2\2\u01c3\u01c4\3\2\2\2\u01c4")
+        buf.write("\u01c5\7\30\2\2\u01c5\u01c8\3\2\2\2\u01c6\u01c8\5> \2")
+        buf.write("\u01c7\u01ba\3\2\2\2\u01c7\u01bc\3\2\2\2\u01c7\u01c6\3")
+        buf.write("\2\2\2\u01c8;\3\2\2\2\u01c9\u01ca\7-\2\2\u01ca\u01cb\7")
+        buf.write("\33\2\2\u01cb\u01cc\7?\2\2\u01cc\u01cd\7\34\2\2\u01cd")
+        buf.write("\u01ce\7\33\2\2\u01ce\u01cf\7A\2\2\u01cf\u01d0\7\34\2")
+        buf.write("\2\u01d0=\3\2\2\2\u01d1\u01d8\5<\37\2\u01d2\u01d3\7\27")
+        buf.write("\2\2\u01d3\u01d4\5> \2\u01d4\u01d5\7\30\2\2\u01d5\u01d8")
+        buf.write("\3\2\2\2\u01d6\u01d8\7A\2\2\u01d7\u01d1\3\2\2\2\u01d7")
+        buf.write("\u01d2\3\2\2\2\u01d7\u01d6\3\2\2\2\u01d8?\3\2\2\2\u01d9")
+        buf.write("\u01da\7\31\2\2\u01da\u01db\5\24\13\2\u01db\u01dc\7\32")
+        buf.write("\2\2\u01dcA\3\2\2\2\u01dd\u01e1\7@\2\2\u01de\u01e1\7A")
+        buf.write("\2\2\u01df\u01e1\7=\2\2\u01e0\u01dd\3\2\2\2\u01e0\u01de")
+        buf.write("\3\2\2\2\u01e0\u01df\3\2\2\2\u01e1C\3\2\2\2\u01e2\u01e8")
+        buf.write("\5\6\4\2\u01e3\u01e8\5\b\5\2\u01e4\u01e8\5\n\6\2\u01e5")
+        buf.write("\u01e8\5\f\7\2\u01e6\u01e8\5\16\b\2\u01e7\u01e2\3\2\2")
+        buf.write("\2\u01e7\u01e3\3\2\2\2\u01e7\u01e4\3\2\2\2\u01e7\u01e5")
+        buf.write("\3\2\2\2\u01e7\u01e6\3\2\2\2\u01e8E\3\2\2\2\63LPS\\gq")
+        buf.write("t|\u0080\u009b\u00a5\u00a8\u00bb\u00d0\u00e9\u00eb\u00f0")
+        buf.write("\u00f7\u00fe\u0105\u010c\u0112\u0114\u0120\u0125\u012a")
+        buf.write("\u0137\u0140\u0142\u0146\u014e\u0155\u015d\u0161\u0168")
+        buf.write("\u016b\u0170\u0177\u018b\u019c\u01a4\u01a7\u01ad\u01b5")
+        buf.write("\u01c2\u01c7\u01d7\u01e0\u01e7")
         return buf.getvalue()
 
 
@@ -286,32 +299,36 @@ class RelayParser ( Parser ):
     RULE_expr = 9
     RULE_func = 10
     RULE_defn = 11
-    RULE_adtConstructor = 12
-    RULE_matchClause = 13
-    RULE_matchType = 14
-    RULE_patternList = 15
-    RULE_pattern = 16
-    RULE_constructorName = 17
-    RULE_argList = 18
-    RULE_varList = 19
-    RULE_var = 20
-    RULE_attrSeq = 21
-    RULE_attr = 22
-    RULE_typeExpr = 23
-    RULE_typeParamList = 24
-    RULE_shapeList = 25
-    RULE_meta = 26
-    RULE_shape = 27
-    RULE_body = 28
-    RULE_scalar = 29
-    RULE_ident = 30
+    RULE_constructorName = 12
+    RULE_adtConsDefn = 13
+    RULE_matchClause = 14
+    RULE_matchType = 15
+    RULE_patternList = 16
+    RULE_pattern = 17
+    RULE_adtCons = 18
+    RULE_adtConsParamList = 19
+    RULE_adtConsParam = 20
+    RULE_argList = 21
+    RULE_varList = 22
+    RULE_var = 23
+    RULE_attrSeq = 24
+    RULE_attr = 25
+    RULE_typeExpr = 26
+    RULE_typeParamList = 27
+    RULE_shapeList = 28
+    RULE_meta = 29
+    RULE_shape = 30
+    RULE_body = 31
+    RULE_scalar = 32
+    RULE_ident = 33
 
     ruleNames =  [ "baseType", "prog", "opIdent", "globalVar", "localVar", 
                    "typeIdent", "graphVar", "exprList", "callList", "expr", 
-                   "func", "defn", "adtConstructor", "matchClause", "matchType", 
-                   "patternList", "pattern", "constructorName", "argList", 
-                   "varList", "var", "attrSeq", "attr", "typeExpr", "typeParamList", 
-                   "shapeList", "meta", "shape", "body", "scalar", "ident" ]
+                   "func", "defn", "constructorName", "adtConsDefn", "matchClause", 
+                   "matchType", "patternList", "pattern", "adtCons", "adtConsParamList", 
+                   "adtConsParam", "argList", "varList", "var", "attrSeq", 
+                   "attr", "typeExpr", "typeParamList", "shapeList", "meta", 
+                   "shape", "body", "scalar", "ident" ]
 
     EOF = Token.EOF
     T__0=1
@@ -414,7 +431,7 @@ def baseType(self):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 62
+            self.state = 68
             _la = self._input.LA(1)
             if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__0) | (1 << RelayParser.T__1) | (1 << RelayParser.T__2) | (1 << RelayParser.T__3) | (1 << RelayParser.T__4) | (1 << RelayParser.T__5) | (1 << RelayParser.T__6) | (1 << RelayParser.T__7) | (1 << RelayParser.T__8) | (1 << RelayParser.T__9) | (1 << RelayParser.T__10) | (1 << RelayParser.T__11) | (1 << RelayParser.T__12) | (1 << RelayParser.T__13) | (1 << RelayParser.T__14))) != 0)):
                 self._errHandler.recoverInline(self)
@@ -475,39 +492,39 @@ def prog(self):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 64
+            self.state = 70
             self.match(RelayParser.SEMVER)
-            self.state = 72
+            self.state = 78
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [RelayParser.EOF, RelayParser.T__34, RelayParser.T__35, RelayParser.METADATA]:
-                self.state = 68
+                self.state = 74
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while _la==RelayParser.T__34 or _la==RelayParser.T__35:
-                    self.state = 65
+                    self.state = 71
                     self.defn()
-                    self.state = 70
+                    self.state = 76
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
                 pass
-            elif token in [RelayParser.T__16, RelayParser.T__17, RelayParser.T__20, RelayParser.T__22, RelayParser.T__24, RelayParser.T__26, RelayParser.T__28, RelayParser.T__32, RelayParser.T__38, RelayParser.T__39, RelayParser.T__42, RelayParser.QUOTED_STRING, RelayParser.SUB, RelayParser.BOOL_LIT, RelayParser.START_LOWER_CNAME, RelayParser.FLOAT, RelayParser.NAT]:
-                self.state = 71
+            elif token in [RelayParser.T__0, RelayParser.T__1, RelayParser.T__2, RelayParser.T__3, RelayParser.T__4, RelayParser.T__5, RelayParser.T__6, RelayParser.T__7, RelayParser.T__8, RelayParser.T__9, RelayParser.T__10, RelayParser.T__11, RelayParser.T__12, RelayParser.T__13, RelayParser.T__14, RelayParser.T__16, RelayParser.T__17, RelayParser.T__20, RelayParser.T__22, RelayParser.T__24, RelayParser.T__26, RelayParser.T__28, RelayParser.T__32, RelayParser.T__38, RelayParser.T__39, RelayParser.T__42, RelayParser.QUOTED_STRING, RelayParser.SUB, RelayParser.BOOL_LIT, RelayParser.START_UPPER_CNAME, RelayParser.START_LOWER_CNAME, RelayParser.FLOAT, RelayParser.NAT]:
+                self.state = 77
                 self.expr(0)
                 pass
             else:
                 raise NoViableAltException(self)
 
-            self.state = 75
+            self.state = 81
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==RelayParser.METADATA:
-                self.state = 74
+                self.state = 80
                 self.match(RelayParser.METADATA)
 
 
-            self.state = 77
+            self.state = 83
             self.match(RelayParser.EOF)
         except RecognitionException as re:
             localctx.exception = re
@@ -548,18 +565,18 @@ def opIdent(self):
         self.enterRule(localctx, 4, self.RULE_opIdent)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 79
+            self.state = 85
             self.match(RelayParser.START_LOWER_CNAME)
-            self.state = 84
+            self.state = 90
             self._errHandler.sync(self)
             _alt = self._interp.adaptivePredict(self._input,3,self._ctx)
             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                 if _alt==1:
-                    self.state = 80
+                    self.state = 86
                     self.match(RelayParser.T__15)
-                    self.state = 81
+                    self.state = 87
                     self.match(RelayParser.START_LOWER_CNAME) 
-                self.state = 86
+                self.state = 92
                 self._errHandler.sync(self)
                 _alt = self._interp.adaptivePredict(self._input,3,self._ctx)
 
@@ -599,9 +616,9 @@ def globalVar(self):
         self.enterRule(localctx, 6, self.RULE_globalVar)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 87
+            self.state = 93
             self.match(RelayParser.T__16)
-            self.state = 88
+            self.state = 94
             self.match(RelayParser.START_LOWER_CNAME)
         except RecognitionException as re:
             localctx.exception = re
@@ -640,9 +657,9 @@ def localVar(self):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 90
+            self.state = 96
             self.match(RelayParser.T__17)
-            self.state = 91
+            self.state = 97
             _la = self._input.LA(1)
             if not(_la==RelayParser.T__18 or _la==RelayParser.START_LOWER_CNAME):
                 self._errHandler.recoverInline(self)
@@ -689,15 +706,15 @@ def typeIdent(self):
         self.enterRule(localctx, 10, self.RULE_typeIdent)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 95
+            self.state = 101
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [RelayParser.T__0, RelayParser.T__1, RelayParser.T__2, RelayParser.T__3, RelayParser.T__4, RelayParser.T__5, RelayParser.T__6, RelayParser.T__7, RelayParser.T__8, RelayParser.T__9, RelayParser.T__10, RelayParser.T__11, RelayParser.T__12, RelayParser.T__13, RelayParser.T__14]:
-                self.state = 93
+                self.state = 99
                 self.baseType()
                 pass
             elif token in [RelayParser.START_UPPER_CNAME]:
-                self.state = 94
+                self.state = 100
                 self.match(RelayParser.START_UPPER_CNAME)
                 pass
             else:
@@ -739,9 +756,9 @@ def graphVar(self):
         self.enterRule(localctx, 12, self.RULE_graphVar)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 97
+            self.state = 103
             self.match(RelayParser.T__17)
-            self.state = 98
+            self.state = 104
             self.match(RelayParser.NAT)
         except RecognitionException as re:
             localctx.exception = re
@@ -784,21 +801,21 @@ def exprList(self):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 108
+            self.state = 114
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__16) | (1 << RelayParser.T__17) | (1 << RelayParser.T__20) | (1 << RelayParser.T__22) | (1 << RelayParser.T__24) | (1 << RelayParser.T__26) | (1 << RelayParser.T__28) | (1 << RelayParser.T__32) | (1 << RelayParser.T__38) | (1 << RelayParser.T__39) | (1 << RelayParser.T__42) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.START_LOWER_CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
-                self.state = 100
+            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__0) | (1 << RelayParser.T__1) | (1 << RelayParser.T__2) | (1 << RelayParser.T__3) | (1 << RelayParser.T__4) | (1 << RelayParser.T__5) | (1 << RelayParser.T__6) | (1 << RelayParser.T__7) | (1 << RelayParser.T__8) | (1 << RelayParser.T__9) | (1 << RelayParser.T__10) | (1 << RelayParser.T__11) | (1 << RelayParser.T__12) | (1 << RelayParser.T__13) | (1 << RelayParser.T__14) | (1 << RelayParser.T__16) | (1 << RelayParser.T__17) | (1 << RelayParser.T__20) | (1 << RelayParser.T__22) | (1 << RelayParser.T__24) | (1 << RelayParser.T__26) | (1 << RelayParser.T__28) | (1 << RelayParser.T__32) | (1 << RelayParser.T__38) | (1 << RelayParser.T__39) | (1 << RelayParser.T__42) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.START_UPPER_CNAME) | (1 << RelayParser.START_LOWER_CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
+                self.state = 106
                 self.expr(0)
-                self.state = 105
+                self.state = 111
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while _la==RelayParser.T__19:
-                    self.state = 101
+                    self.state = 107
                     self.match(RelayParser.T__19)
-                    self.state = 102
+                    self.state = 108
                     self.expr(0)
-                    self.state = 107
+                    self.state = 113
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
@@ -875,33 +892,33 @@ def callList(self):
         localctx = RelayParser.CallListContext(self, self._ctx, self.state)
         self.enterRule(localctx, 16, self.RULE_callList)
         try:
-            self.state = 120
+            self.state = 126
             self._errHandler.sync(self)
             la_ = self._interp.adaptivePredict(self._input,8,self._ctx)
             if la_ == 1:
                 localctx = RelayParser.CallNoAttrContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 110
+                self.state = 116
                 self.exprList()
                 pass
 
             elif la_ == 2:
                 localctx = RelayParser.CallWithAttrContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 116
+                self.state = 122
                 self._errHandler.sync(self)
                 _alt = self._interp.adaptivePredict(self._input,7,self._ctx)
                 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                     if _alt==1:
-                        self.state = 111
+                        self.state = 117
                         self.expr(0)
-                        self.state = 112
+                        self.state = 118
                         self.match(RelayParser.T__19) 
-                    self.state = 118
+                    self.state = 124
                     self._errHandler.sync(self)
                     _alt = self._interp.adaptivePredict(self._input,7,self._ctx)
 
-                self.state = 119
+                self.state = 125
                 self.attrSeq()
                 pass
 
@@ -1276,7 +1293,7 @@ def expr(self, _p:int=0):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 200
+            self.state = 206
             self._errHandler.sync(self)
             la_ = self._interp.adaptivePredict(self._input,13,self._ctx)
             if la_ == 1:
@@ -1284,11 +1301,11 @@ def expr(self, _p:int=0):
                 self._ctx = localctx
                 _prevctx = localctx
 
-                self.state = 123
+                self.state = 129
                 self.match(RelayParser.T__20)
-                self.state = 124
+                self.state = 130
                 self.expr(0)
-                self.state = 125
+                self.state = 131
                 self.match(RelayParser.T__21)
                 pass
 
@@ -1296,11 +1313,11 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.ParenContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 127
+                self.state = 133
                 self.match(RelayParser.T__22)
-                self.state = 128
+                self.state = 134
                 self.expr(0)
-                self.state = 129
+                self.state = 135
                 self.match(RelayParser.T__23)
                 pass
 
@@ -1308,9 +1325,9 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.NegContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 131
+                self.state = 137
                 self.match(RelayParser.SUB)
-                self.state = 132
+                self.state = 138
                 self.expr(20)
                 pass
 
@@ -1318,7 +1335,7 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.FuncExprContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 133
+                self.state = 139
                 self.func()
                 pass
 
@@ -1326,9 +1343,9 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.TupleContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 134
+                self.state = 140
                 self.match(RelayParser.T__20)
-                self.state = 135
+                self.state = 141
                 self.match(RelayParser.T__21)
                 pass
 
@@ -1336,13 +1353,13 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.TupleContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 136
+                self.state = 142
                 self.match(RelayParser.T__20)
-                self.state = 137
+                self.state = 143
                 self.expr(0)
-                self.state = 138
+                self.state = 144
                 self.match(RelayParser.T__19)
-                self.state = 139
+                self.state = 145
                 self.match(RelayParser.T__21)
                 pass
 
@@ -1350,25 +1367,25 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.TupleContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 141
+                self.state = 147
                 self.match(RelayParser.T__20)
-                self.state = 142
+                self.state = 148
                 self.expr(0)
-                self.state = 145 
+                self.state = 151 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while True:
-                    self.state = 143
+                    self.state = 149
                     self.match(RelayParser.T__19)
-                    self.state = 144
+                    self.state = 150
                     self.expr(0)
-                    self.state = 147 
+                    self.state = 153 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
                     if not (_la==RelayParser.T__19):
                         break
 
-                self.state = 149
+                self.state = 155
                 self.match(RelayParser.T__21)
                 pass
 
@@ -1376,29 +1393,29 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.TensorContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 151
+                self.state = 157
                 self.match(RelayParser.T__24)
-                self.state = 160
+                self.state = 166
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__16) | (1 << RelayParser.T__17) | (1 << RelayParser.T__20) | (1 << RelayParser.T__22) | (1 << RelayParser.T__24) | (1 << RelayParser.T__26) | (1 << RelayParser.T__28) | (1 << RelayParser.T__32) | (1 << RelayParser.T__38) | (1 << RelayParser.T__39) | (1 << RelayParser.T__42) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.START_LOWER_CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
-                    self.state = 152
+                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__0) | (1 << RelayParser.T__1) | (1 << RelayParser.T__2) | (1 << RelayParser.T__3) | (1 << RelayParser.T__4) | (1 << RelayParser.T__5) | (1 << RelayParser.T__6) | (1 << RelayParser.T__7) | (1 << RelayParser.T__8) | (1 << RelayParser.T__9) | (1 << RelayParser.T__10) | (1 << RelayParser.T__11) | (1 << RelayParser.T__12) | (1 << RelayParser.T__13) | (1 << RelayParser.T__14) | (1 << RelayParser.T__16) | (1 << RelayParser.T__17) | (1 << RelayParser.T__20) | (1 << RelayParser.T__22) | (1 << RelayParser.T__24) | (1 << RelayParser.T__26) | (1 << RelayParser.T__28) | (1 << RelayParser.T__32) | (1 << RelayParser.T__38) | (1 << RelayParser.T__39) | (1 << RelayParser.T__42) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.START_UPPER_CNAME) | (1 << RelayParser.START_LOWER_CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
+                    self.state = 158
                     self.expr(0)
-                    self.state = 157
+                    self.state = 163
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
                     while _la==RelayParser.T__19:
-                        self.state = 153
+                        self.state = 159
                         self.match(RelayParser.T__19)
-                        self.state = 154
+                        self.state = 160
                         self.expr(0)
-                        self.state = 159
+                        self.state = 165
                         self._errHandler.sync(self)
                         _la = self._input.LA(1)
 
 
 
-                self.state = 162
+                self.state = 168
                 self.match(RelayParser.T__25)
                 pass
 
@@ -1406,19 +1423,19 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.IfElseContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 163
+                self.state = 169
                 self.match(RelayParser.T__26)
-                self.state = 164
+                self.state = 170
                 self.match(RelayParser.T__20)
-                self.state = 165
+                self.state = 171
                 self.expr(0)
-                self.state = 166
+                self.state = 172
                 self.match(RelayParser.T__21)
-                self.state = 167
+                self.state = 173
                 self.body()
-                self.state = 168
+                self.state = 174
                 self.match(RelayParser.T__27)
-                self.state = 169
+                self.state = 175
                 self.body()
                 pass
 
@@ -1426,29 +1443,29 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.MatchContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 171
+                self.state = 177
                 self.matchType()
-                self.state = 172
+                self.state = 178
                 self.match(RelayParser.T__20)
-                self.state = 173
+                self.state = 179
                 self.expr(0)
-                self.state = 174
+                self.state = 180
                 self.match(RelayParser.T__21)
-                self.state = 175
+                self.state = 181
                 self.match(RelayParser.T__22)
-                self.state = 177 
+                self.state = 183 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while True:
-                    self.state = 176
+                    self.state = 182
                     self.matchClause()
-                    self.state = 179 
+                    self.state = 185 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
                     if not (_la==RelayParser.T__36):
                         break
 
-                self.state = 181
+                self.state = 187
                 self.match(RelayParser.T__23)
                 pass
 
@@ -1456,17 +1473,17 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.LetContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 183
+                self.state = 189
                 self.match(RelayParser.T__28)
-                self.state = 184
+                self.state = 190
                 self.var()
-                self.state = 185
+                self.state = 191
                 self.match(RelayParser.T__29)
-                self.state = 186
+                self.state = 192
                 self.expr(0)
-                self.state = 187
+                self.state = 193
                 self.match(RelayParser.T__30)
-                self.state = 188
+                self.state = 194
                 self.expr(7)
                 pass
 
@@ -1474,15 +1491,15 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.GraphContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 190
+                self.state = 196
                 self.graphVar()
-                self.state = 191
+                self.state = 197
                 self.match(RelayParser.T__29)
-                self.state = 192
+                self.state = 198
                 self.expr(0)
-                self.state = 193
+                self.state = 199
                 self.match(RelayParser.T__30)
-                self.state = 194
+                self.state = 200
                 self.expr(5)
                 pass
 
@@ -1490,7 +1507,7 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.IdentExprContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 196
+                self.state = 202
                 self.ident()
                 pass
 
@@ -1498,7 +1515,7 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.ScalarExprContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 197
+                self.state = 203
                 self.scalar()
                 pass
 
@@ -1506,7 +1523,7 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.MetaExprContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 198
+                self.state = 204
                 self.meta()
                 pass
 
@@ -1514,13 +1531,13 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.StringExprContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 199
+                self.state = 205
                 self.match(RelayParser.QUOTED_STRING)
                 pass
 
 
             self._ctx.stop = self._input.LT(-1)
-            self.state = 227
+            self.state = 233
             self._errHandler.sync(self)
             _alt = self._interp.adaptivePredict(self._input,15,self._ctx)
             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
@@ -1528,17 +1545,17 @@ def expr(self, _p:int=0):
                     if self._parseListeners is not None:
                         self.triggerExitRuleEvent()
                     _prevctx = localctx
-                    self.state = 225
+                    self.state = 231
                     self._errHandler.sync(self)
                     la_ = self._interp.adaptivePredict(self._input,14,self._ctx)
                     if la_ == 1:
                         localctx = RelayParser.BinOpContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 202
+                        self.state = 208
                         if not self.precpred(self._ctx, 19):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 19)")
-                        self.state = 203
+                        self.state = 209
                         localctx.op = self._input.LT(1)
                         _la = self._input.LA(1)
                         if not(_la==RelayParser.MUL or _la==RelayParser.DIV):
@@ -1546,18 +1563,18 @@ def expr(self, _p:int=0):
                         else:
                             self._errHandler.reportMatch(self)
                             self.consume()
-                        self.state = 204
+                        self.state = 210
                         self.expr(20)
                         pass
 
                     elif la_ == 2:
                         localctx = RelayParser.BinOpContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 205
+                        self.state = 211
                         if not self.precpred(self._ctx, 18):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 18)")
-                        self.state = 206
+                        self.state = 212
                         localctx.op = self._input.LT(1)
                         _la = self._input.LA(1)
                         if not(_la==RelayParser.ADD or _la==RelayParser.SUB):
@@ -1565,18 +1582,18 @@ def expr(self, _p:int=0):
                         else:
                             self._errHandler.reportMatch(self)
                             self.consume()
-                        self.state = 207
+                        self.state = 213
                         self.expr(19)
                         pass
 
                     elif la_ == 3:
                         localctx = RelayParser.BinOpContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 208
+                        self.state = 214
                         if not self.precpred(self._ctx, 17):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 17)")
-                        self.state = 209
+                        self.state = 215
                         localctx.op = self._input.LT(1)
                         _la = self._input.LA(1)
                         if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.LT) | (1 << RelayParser.GT) | (1 << RelayParser.LE) | (1 << RelayParser.GE))) != 0)):
@@ -1584,18 +1601,18 @@ def expr(self, _p:int=0):
                         else:
                             self._errHandler.reportMatch(self)
                             self.consume()
-                        self.state = 210
+                        self.state = 216
                         self.expr(18)
                         pass
 
                     elif la_ == 4:
                         localctx = RelayParser.BinOpContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 211
+                        self.state = 217
                         if not self.precpred(self._ctx, 16):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 16)")
-                        self.state = 212
+                        self.state = 218
                         localctx.op = self._input.LT(1)
                         _la = self._input.LA(1)
                         if not(_la==RelayParser.EQ or _la==RelayParser.NE):
@@ -1603,53 +1620,53 @@ def expr(self, _p:int=0):
                         else:
                             self._errHandler.reportMatch(self)
                             self.consume()
-                        self.state = 213
+                        self.state = 219
                         self.expr(17)
                         pass
 
                     elif la_ == 5:
                         localctx = RelayParser.LetContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 214
+                        self.state = 220
                         if not self.precpred(self._ctx, 6):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
-                        self.state = 215
+                        self.state = 221
                         self.match(RelayParser.T__31)
-                        self.state = 216
+                        self.state = 222
                         self.expr(7)
                         pass
 
                     elif la_ == 6:
                         localctx = RelayParser.CallContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 217
+                        self.state = 223
                         if not self.precpred(self._ctx, 21):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 21)")
-                        self.state = 218
+                        self.state = 224
                         self.match(RelayParser.T__20)
-                        self.state = 219
+                        self.state = 225
                         self.callList()
-                        self.state = 220
+                        self.state = 226
                         self.match(RelayParser.T__21)
                         pass
 
                     elif la_ == 7:
                         localctx = RelayParser.ProjectionContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 222
+                        self.state = 228
                         if not self.precpred(self._ctx, 8):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
-                        self.state = 223
+                        self.state = 229
                         self.match(RelayParser.T__15)
-                        self.state = 224
+                        self.state = 230
                         self.match(RelayParser.NAT)
                         pass
 
              
-                self.state = 229
+                self.state = 235
                 self._errHandler.sync(self)
                 _alt = self._interp.adaptivePredict(self._input,15,self._ctx)
 
@@ -1703,33 +1720,33 @@ def func(self):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 230
+            self.state = 236
             self.match(RelayParser.T__32)
-            self.state = 232
+            self.state = 238
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==RelayParser.T__24:
-                self.state = 231
+                self.state = 237
                 self.typeParamList()
 
 
-            self.state = 234
+            self.state = 240
             self.match(RelayParser.T__20)
-            self.state = 235
+            self.state = 241
             self.argList()
-            self.state = 236
+            self.state = 242
             self.match(RelayParser.T__21)
-            self.state = 239
+            self.state = 245
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==RelayParser.T__33:
-                self.state = 237
+                self.state = 243
                 self.match(RelayParser.T__33)
-                self.state = 238
+                self.state = 244
                 self.typeExpr()
 
 
-            self.state = 241
+            self.state = 247
             self.body()
         except RecognitionException as re:
             localctx.exception = re
@@ -1797,11 +1814,11 @@ def typeIdent(self):
         def typeParamList(self):
             return self.getTypedRuleContext(RelayParser.TypeParamListContext,0)
 
-        def adtConstructor(self, i:int=None):
+        def adtConsDefn(self, i:int=None):
             if i is None:
-                return self.getTypedRuleContexts(RelayParser.AdtConstructorContext)
+                return self.getTypedRuleContexts(RelayParser.AdtConsDefnContext)
             else:
-                return self.getTypedRuleContext(RelayParser.AdtConstructorContext,i)
+                return self.getTypedRuleContext(RelayParser.AdtConsDefnContext,i)
 
 
         def accept(self, visitor:ParseTreeVisitor):
@@ -1818,67 +1835,67 @@ def defn(self):
         self.enterRule(localctx, 22, self.RULE_defn)
         self._la = 0 # Token type
         try:
-            self.state = 268
+            self.state = 274
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [RelayParser.T__34]:
                 localctx = RelayParser.FuncDefnContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 243
+                self.state = 249
                 self.match(RelayParser.T__34)
-                self.state = 244
+                self.state = 250
                 self.globalVar()
-                self.state = 246
+                self.state = 252
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if _la==RelayParser.T__24:
-                    self.state = 245
+                    self.state = 251
                     self.typeParamList()
 
 
-                self.state = 248
+                self.state = 254
                 self.match(RelayParser.T__20)
-                self.state = 249
+                self.state = 255
                 self.argList()
-                self.state = 250
+                self.state = 256
                 self.match(RelayParser.T__21)
-                self.state = 253
+                self.state = 259
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if _la==RelayParser.T__33:
-                    self.state = 251
+                    self.state = 257
                     self.match(RelayParser.T__33)
-                    self.state = 252
+                    self.state = 258
                     self.typeExpr()
 
 
-                self.state = 255
+                self.state = 261
                 self.body()
                 pass
             elif token in [RelayParser.T__35]:
                 localctx = RelayParser.AdtDefnContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 257
+                self.state = 263
                 self.match(RelayParser.T__35)
-                self.state = 258
+                self.state = 264
                 self.typeIdent()
-                self.state = 260
+                self.state = 266
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if _la==RelayParser.T__24:
-                    self.state = 259
+                    self.state = 265
                     self.typeParamList()
 
 
-                self.state = 262
+                self.state = 268
                 self.match(RelayParser.T__29)
-                self.state = 264 
+                self.state = 270 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while True:
-                    self.state = 263
-                    self.adtConstructor()
-                    self.state = 266 
+                    self.state = 269
+                    self.adtConsDefn()
+                    self.state = 272 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
                     if not (_la==RelayParser.T__36):
@@ -1897,7 +1914,45 @@ def defn(self):
         return localctx
 
 
-    class AdtConstructorContext(ParserRuleContext):
+    class ConstructorNameContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def START_UPPER_CNAME(self):
+            return self.getToken(RelayParser.START_UPPER_CNAME, 0)
+
+        def getRuleIndex(self):
+            return RelayParser.RULE_constructorName
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitConstructorName" ):
+                return visitor.visitConstructorName(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def constructorName(self):
+
+        localctx = RelayParser.ConstructorNameContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 24, self.RULE_constructorName)
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 276
+            self.match(RelayParser.START_UPPER_CNAME)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class AdtConsDefnContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
             super().__init__(parent, invokingState)
@@ -1915,49 +1970,49 @@ def typeExpr(self, i:int=None):
 
 
         def getRuleIndex(self):
-            return RelayParser.RULE_adtConstructor
+            return RelayParser.RULE_adtConsDefn
 
         def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitAdtConstructor" ):
-                return visitor.visitAdtConstructor(self)
+            if hasattr( visitor, "visitAdtConsDefn" ):
+                return visitor.visitAdtConsDefn(self)
             else:
                 return visitor.visitChildren(self)
 
 
 
 
-    def adtConstructor(self):
+    def adtConsDefn(self):
 
-        localctx = RelayParser.AdtConstructorContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 24, self.RULE_adtConstructor)
+        localctx = RelayParser.AdtConsDefnContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 26, self.RULE_adtConsDefn)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 270
+            self.state = 278
             self.match(RelayParser.T__36)
-            self.state = 271
+            self.state = 279
             self.constructorName()
-            self.state = 283
+            self.state = 291
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==RelayParser.T__20:
-                self.state = 272
+                self.state = 280
                 self.match(RelayParser.T__20)
-                self.state = 273
+                self.state = 281
                 self.typeExpr()
-                self.state = 278
+                self.state = 286
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while _la==RelayParser.T__19:
-                    self.state = 274
+                    self.state = 282
                     self.match(RelayParser.T__19)
-                    self.state = 275
+                    self.state = 283
                     self.typeExpr()
-                    self.state = 280
+                    self.state = 288
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
-                self.state = 281
+                self.state = 289
                 self.match(RelayParser.T__21)
 
 
@@ -2003,25 +2058,25 @@ def accept(self, visitor:ParseTreeVisitor):
     def matchClause(self):
 
         localctx = RelayParser.MatchClauseContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 26, self.RULE_matchClause)
+        self.enterRule(localctx, 28, self.RULE_matchClause)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 285
+            self.state = 293
             self.match(RelayParser.T__36)
-            self.state = 286
+            self.state = 294
             self.constructorName()
-            self.state = 288
+            self.state = 296
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==RelayParser.T__20:
-                self.state = 287
+                self.state = 295
                 self.patternList()
 
 
-            self.state = 290
+            self.state = 298
             self.match(RelayParser.T__37)
-            self.state = 291
+            self.state = 299
             self.expr(0)
         except RecognitionException as re:
             localctx.exception = re
@@ -2054,11 +2109,11 @@ def accept(self, visitor:ParseTreeVisitor):
     def matchType(self):
 
         localctx = RelayParser.MatchTypeContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 28, self.RULE_matchType)
+        self.enterRule(localctx, 30, self.RULE_matchType)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 293
+            self.state = 301
             _la = self._input.LA(1)
             if not(_la==RelayParser.T__38 or _la==RelayParser.T__39):
                 self._errHandler.recoverInline(self)
@@ -2102,27 +2157,27 @@ def accept(self, visitor:ParseTreeVisitor):
     def patternList(self):
 
         localctx = RelayParser.PatternListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 30, self.RULE_patternList)
+        self.enterRule(localctx, 32, self.RULE_patternList)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 295
+            self.state = 303
             self.match(RelayParser.T__20)
-            self.state = 296
+            self.state = 304
             self.pattern()
-            self.state = 301
+            self.state = 309
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==RelayParser.T__19:
-                self.state = 297
+                self.state = 305
                 self.match(RelayParser.T__19)
-                self.state = 298
+                self.state = 306
                 self.pattern()
-                self.state = 303
+                self.state = 311
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 304
+            self.state = 312
             self.match(RelayParser.T__21)
         except RecognitionException as re:
             localctx.exception = re
@@ -2162,28 +2217,28 @@ def accept(self, visitor:ParseTreeVisitor):
     def pattern(self):
 
         localctx = RelayParser.PatternContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 32, self.RULE_pattern)
+        self.enterRule(localctx, 34, self.RULE_pattern)
         self._la = 0 # Token type
         try:
-            self.state = 312
+            self.state = 320
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [RelayParser.T__18]:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 306
+                self.state = 314
                 self.match(RelayParser.T__18)
                 pass
             elif token in [RelayParser.T__17]:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 307
+                self.state = 315
                 self.localVar()
-                self.state = 310
+                self.state = 318
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if _la==RelayParser.T__40:
-                    self.state = 308
+                    self.state = 316
                     self.match(RelayParser.T__40)
-                    self.state = 309
+                    self.state = 317
                     self.typeExpr()
 
 
@@ -2200,35 +2255,164 @@ def pattern(self):
         return localctx
 
 
-    class ConstructorNameContext(ParserRuleContext):
+    class AdtConsContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
             super().__init__(parent, invokingState)
             self.parser = parser
 
-        def START_UPPER_CNAME(self):
-            return self.getToken(RelayParser.START_UPPER_CNAME, 0)
+        def constructorName(self):
+            return self.getTypedRuleContext(RelayParser.ConstructorNameContext,0)
+
+
+        def adtConsParamList(self):
+            return self.getTypedRuleContext(RelayParser.AdtConsParamListContext,0)
+
 
         def getRuleIndex(self):
-            return RelayParser.RULE_constructorName
+            return RelayParser.RULE_adtCons
 
         def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitConstructorName" ):
-                return visitor.visitConstructorName(self)
+            if hasattr( visitor, "visitAdtCons" ):
+                return visitor.visitAdtCons(self)
             else:
                 return visitor.visitChildren(self)
 
 
 
 
-    def constructorName(self):
+    def adtCons(self):
 
-        localctx = RelayParser.ConstructorNameContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 34, self.RULE_constructorName)
+        localctx = RelayParser.AdtConsContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 36, self.RULE_adtCons)
+        self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 314
-            self.match(RelayParser.START_UPPER_CNAME)
+            self.state = 322
+            self.constructorName()
+            self.state = 324
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            if _la==RelayParser.T__20:
+                self.state = 323
+                self.adtConsParamList()
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class AdtConsParamListContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def adtConsParam(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(RelayParser.AdtConsParamContext)
+            else:
+                return self.getTypedRuleContext(RelayParser.AdtConsParamContext,i)
+
+
+        def getRuleIndex(self):
+            return RelayParser.RULE_adtConsParamList
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitAdtConsParamList" ):
+                return visitor.visitAdtConsParamList(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def adtConsParamList(self):
+
+        localctx = RelayParser.AdtConsParamListContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 38, self.RULE_adtConsParamList)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 326
+            self.match(RelayParser.T__20)
+            self.state = 327
+            self.adtConsParam()
+            self.state = 332
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            while _la==RelayParser.T__19:
+                self.state = 328
+                self.match(RelayParser.T__19)
+                self.state = 329
+                self.adtConsParam()
+                self.state = 334
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+
+            self.state = 335
+            self.match(RelayParser.T__21)
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
+    class AdtConsParamContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def localVar(self):
+            return self.getTypedRuleContext(RelayParser.LocalVarContext,0)
+
+
+        def constructorName(self):
+            return self.getTypedRuleContext(RelayParser.ConstructorNameContext,0)
+
+
+        def getRuleIndex(self):
+            return RelayParser.RULE_adtConsParam
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitAdtConsParam" ):
+                return visitor.visitAdtConsParam(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def adtConsParam(self):
+
+        localctx = RelayParser.AdtConsParamContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 40, self.RULE_adtConsParam)
+        try:
+            self.state = 339
+            self._errHandler.sync(self)
+            token = self._input.LA(1)
+            if token in [RelayParser.T__17]:
+                self.enterOuterAlt(localctx, 1)
+                self.state = 337
+                self.localVar()
+                pass
+            elif token in [RelayParser.START_UPPER_CNAME]:
+                self.enterOuterAlt(localctx, 2)
+                self.state = 338
+                self.constructorName()
+                pass
+            else:
+                raise NoViableAltException(self)
+
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -2298,35 +2482,35 @@ def accept(self, visitor:ParseTreeVisitor):
     def argList(self):
 
         localctx = RelayParser.ArgListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 36, self.RULE_argList)
+        self.enterRule(localctx, 42, self.RULE_argList)
         self._la = 0 # Token type
         try:
-            self.state = 326
+            self.state = 351
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,30,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,33,self._ctx)
             if la_ == 1:
                 localctx = RelayParser.ArgNoAttrContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 316
+                self.state = 341
                 self.varList()
                 pass
 
             elif la_ == 2:
                 localctx = RelayParser.ArgWithAttrContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 322
+                self.state = 347
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while _la==RelayParser.T__17:
-                    self.state = 317
+                    self.state = 342
                     self.var()
-                    self.state = 318
+                    self.state = 343
                     self.match(RelayParser.T__19)
-                    self.state = 324
+                    self.state = 349
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
-                self.state = 325
+                self.state = 350
                 self.attrSeq()
                 pass
 
@@ -2368,25 +2552,25 @@ def accept(self, visitor:ParseTreeVisitor):
     def varList(self):
 
         localctx = RelayParser.VarListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 38, self.RULE_varList)
+        self.enterRule(localctx, 44, self.RULE_varList)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 336
+            self.state = 361
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==RelayParser.T__17:
-                self.state = 328
+                self.state = 353
                 self.var()
-                self.state = 333
+                self.state = 358
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while _la==RelayParser.T__19:
-                    self.state = 329
+                    self.state = 354
                     self.match(RelayParser.T__19)
-                    self.state = 330
+                    self.state = 355
                     self.var()
-                    self.state = 335
+                    self.state = 360
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
@@ -2430,19 +2614,19 @@ def accept(self, visitor:ParseTreeVisitor):
     def var(self):
 
         localctx = RelayParser.VarContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 40, self.RULE_var)
+        self.enterRule(localctx, 46, self.RULE_var)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 338
+            self.state = 363
             self.localVar()
-            self.state = 341
+            self.state = 366
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==RelayParser.T__40:
-                self.state = 339
+                self.state = 364
                 self.match(RelayParser.T__40)
-                self.state = 340
+                self.state = 365
                 self.typeExpr()
 
 
@@ -2483,21 +2667,21 @@ def accept(self, visitor:ParseTreeVisitor):
     def attrSeq(self):
 
         localctx = RelayParser.AttrSeqContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 42, self.RULE_attrSeq)
+        self.enterRule(localctx, 48, self.RULE_attrSeq)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 343
+            self.state = 368
             self.attr()
-            self.state = 348
+            self.state = 373
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==RelayParser.T__19:
-                self.state = 344
+                self.state = 369
                 self.match(RelayParser.T__19)
-                self.state = 345
+                self.state = 370
                 self.attr()
-                self.state = 350
+                self.state = 375
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
@@ -2538,14 +2722,14 @@ def accept(self, visitor:ParseTreeVisitor):
     def attr(self):
 
         localctx = RelayParser.AttrContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 44, self.RULE_attr)
+        self.enterRule(localctx, 50, self.RULE_attr)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 351
+            self.state = 376
             self.match(RelayParser.START_LOWER_CNAME)
-            self.state = 352
+            self.state = 377
             self.match(RelayParser.T__29)
-            self.state = 353
+            self.state = 378
             self.expr(0)
         except RecognitionException as re:
             localctx.exception = re
@@ -2690,139 +2874,139 @@ def accept(self, visitor:ParseTreeVisitor):
     def typeExpr(self):
 
         localctx = RelayParser.TypeExprContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 46, self.RULE_typeExpr)
+        self.enterRule(localctx, 52, self.RULE_typeExpr)
         self._la = 0 # Token type
         try:
-            self.state = 402
+            self.state = 427
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,39,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,42,self._ctx)
             if la_ == 1:
                 localctx = RelayParser.TupleTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 355
+                self.state = 380
                 self.match(RelayParser.T__20)
-                self.state = 356
+                self.state = 381
                 self.match(RelayParser.T__21)
                 pass
 
             elif la_ == 2:
                 localctx = RelayParser.TupleTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 357
+                self.state = 382
                 self.match(RelayParser.T__20)
-                self.state = 358
+                self.state = 383
                 self.typeExpr()
-                self.state = 359
+                self.state = 384
                 self.match(RelayParser.T__19)
-                self.state = 360
+                self.state = 385
                 self.match(RelayParser.T__21)
                 pass
 
             elif la_ == 3:
                 localctx = RelayParser.TupleTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 3)
-                self.state = 362
+                self.state = 387
                 self.match(RelayParser.T__20)
-                self.state = 363
+                self.state = 388
                 self.typeExpr()
-                self.state = 366 
+                self.state = 391 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while True:
-                    self.state = 364
+                    self.state = 389
                     self.match(RelayParser.T__19)
-                    self.state = 365
+                    self.state = 390
                     self.typeExpr()
-                    self.state = 368 
+                    self.state = 393 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
                     if not (_la==RelayParser.T__19):
                         break
 
-                self.state = 370
+                self.state = 395
                 self.match(RelayParser.T__21)
                 pass
 
             elif la_ == 4:
                 localctx = RelayParser.TypeCallTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 4)
-                self.state = 372
+                self.state = 397
                 self.typeIdent()
-                self.state = 373
+                self.state = 398
                 self.typeParamList()
                 pass
 
             elif la_ == 5:
                 localctx = RelayParser.TypeIdentTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 5)
-                self.state = 375
+                self.state = 400
                 self.typeIdent()
                 pass
 
             elif la_ == 6:
                 localctx = RelayParser.TensorTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 6)
-                self.state = 376
+                self.state = 401
                 self.match(RelayParser.T__41)
-                self.state = 377
+                self.state = 402
                 self.match(RelayParser.T__24)
-                self.state = 378
+                self.state = 403
                 self.shapeList()
-                self.state = 379
+                self.state = 404
                 self.match(RelayParser.T__19)
-                self.state = 380
+                self.state = 405
                 self.typeExpr()
-                self.state = 381
+                self.state = 406
                 self.match(RelayParser.T__25)
                 pass
 
             elif la_ == 7:
                 localctx = RelayParser.FuncTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 7)
-                self.state = 383
+                self.state = 408
                 self.match(RelayParser.T__32)
-                self.state = 385
+                self.state = 410
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if _la==RelayParser.T__24:
-                    self.state = 384
+                    self.state = 409
                     self.typeParamList()
 
 
-                self.state = 387
+                self.state = 412
                 self.match(RelayParser.T__20)
-                self.state = 396
+                self.state = 421
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__0) | (1 << RelayParser.T__1) | (1 << RelayParser.T__2) | (1 << RelayParser.T__3) | (1 << RelayParser.T__4) | (1 << RelayParser.T__5) | (1 << RelayParser.T__6) | (1 << RelayParser.T__7) | (1 << RelayParser.T__8) | (1 << RelayParser.T__9) | (1 << RelayParser.T__10) | (1 << RelayParser.T__11) | (1 << RelayParser.T__12) | (1 << RelayParser.T__13) | (1 << RelayParser.T__14) | (1 << RelayParser.T__18) | (1 << RelayParser.T__20) | (1 << RelayParser.T__32) | (1 << RelayParser.T__41) | (1 << RelayParser.START_UPPER_CNAME))) != 0):
-                    self.state = 388
+                    self.state = 413
                     self.typeExpr()
-                    self.state = 393
+                    self.state = 418
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
                     while _la==RelayParser.T__19:
-                        self.state = 389
+                        self.state = 414
                         self.match(RelayParser.T__19)
-                        self.state = 390
+                        self.state = 415
                         self.typeExpr()
-                        self.state = 395
+                        self.state = 420
                         self._errHandler.sync(self)
                         _la = self._input.LA(1)
 
 
 
-                self.state = 398
+                self.state = 423
                 self.match(RelayParser.T__21)
-                self.state = 399
+                self.state = 424
                 self.match(RelayParser.T__33)
-                self.state = 400
+                self.state = 425
                 self.typeExpr()
                 pass
 
             elif la_ == 8:
                 localctx = RelayParser.IncompleteTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 8)
-                self.state = 401
+                self.state = 426
                 self.match(RelayParser.T__18)
                 pass
 
@@ -2864,27 +3048,27 @@ def accept(self, visitor:ParseTreeVisitor):
     def typeParamList(self):
 
         localctx = RelayParser.TypeParamListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 48, self.RULE_typeParamList)
+        self.enterRule(localctx, 54, self.RULE_typeParamList)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 404
+            self.state = 429
             self.match(RelayParser.T__24)
-            self.state = 405
+            self.state = 430
             self.typeIdent()
-            self.state = 410
+            self.state = 435
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==RelayParser.T__19:
-                self.state = 406
+                self.state = 431
                 self.match(RelayParser.T__19)
-                self.state = 407
+                self.state = 432
                 self.typeIdent()
-                self.state = 412
+                self.state = 437
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 413
+            self.state = 438
             self.match(RelayParser.T__25)
         except RecognitionException as re:
             localctx.exception = re
@@ -2923,47 +3107,47 @@ def accept(self, visitor:ParseTreeVisitor):
     def shapeList(self):
 
         localctx = RelayParser.ShapeListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 50, self.RULE_shapeList)
+        self.enterRule(localctx, 56, self.RULE_shapeList)
         self._la = 0 # Token type
         try:
-            self.state = 428
+            self.state = 453
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,42,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,45,self._ctx)
             if la_ == 1:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 415
+                self.state = 440
                 self.match(RelayParser.T__20)
-                self.state = 416
+                self.state = 441
                 self.match(RelayParser.T__21)
                 pass
 
             elif la_ == 2:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 417
+                self.state = 442
                 self.match(RelayParser.T__20)
-                self.state = 418
+                self.state = 443
                 self.shape()
-                self.state = 421 
+                self.state = 446 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while True:
-                    self.state = 419
+                    self.state = 444
                     self.match(RelayParser.T__19)
-                    self.state = 420
+                    self.state = 445
                     self.shape()
-                    self.state = 423 
+                    self.state = 448 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
                     if not (_la==RelayParser.T__19):
                         break
 
-                self.state = 425
+                self.state = 450
                 self.match(RelayParser.T__21)
                 pass
 
             elif la_ == 3:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 427
+                self.state = 452
                 self.shape()
                 pass
 
@@ -3004,22 +3188,22 @@ def accept(self, visitor:ParseTreeVisitor):
     def meta(self):
 
         localctx = RelayParser.MetaContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 52, self.RULE_meta)
+        self.enterRule(localctx, 58, self.RULE_meta)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 430
+            self.state = 455
             self.match(RelayParser.T__42)
-            self.state = 431
+            self.state = 456
             self.match(RelayParser.T__24)
-            self.state = 432
+            self.state = 457
             self.match(RelayParser.START_LOWER_CNAME)
-            self.state = 433
+            self.state = 458
             self.match(RelayParser.T__25)
-            self.state = 434
+            self.state = 459
             self.match(RelayParser.T__24)
-            self.state = 435
+            self.state = 460
             self.match(RelayParser.NAT)
-            self.state = 436
+            self.state = 461
             self.match(RelayParser.T__25)
         except RecognitionException as re:
             localctx.exception = re
@@ -3100,31 +3284,31 @@ def accept(self, visitor:ParseTreeVisitor):
     def shape(self):
 
         localctx = RelayParser.ShapeContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 54, self.RULE_shape)
+        self.enterRule(localctx, 60, self.RULE_shape)
         try:
-            self.state = 444
+            self.state = 469
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [RelayParser.T__42]:
                 localctx = RelayParser.MetaShapeContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 438
+                self.state = 463
                 self.meta()
                 pass
             elif token in [RelayParser.T__20]:
                 localctx = RelayParser.ParensShapeContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 439
+                self.state = 464
                 self.match(RelayParser.T__20)
-                self.state = 440
+                self.state = 465
                 self.shape()
-                self.state = 441
+                self.state = 466
                 self.match(RelayParser.T__21)
                 pass
             elif token in [RelayParser.NAT]:
                 localctx = RelayParser.IntShapeContext(self, localctx)
                 self.enterOuterAlt(localctx, 3)
-                self.state = 443
+                self.state = 468
                 self.match(RelayParser.NAT)
                 pass
             else:
@@ -3164,14 +3348,14 @@ def accept(self, visitor:ParseTreeVisitor):
     def body(self):
 
         localctx = RelayParser.BodyContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 56, self.RULE_body)
+        self.enterRule(localctx, 62, self.RULE_body)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 446
+            self.state = 471
             self.match(RelayParser.T__22)
-            self.state = 447
+            self.state = 472
             self.expr(0)
-            self.state = 448
+            self.state = 473
             self.match(RelayParser.T__23)
         except RecognitionException as re:
             localctx.exception = re
@@ -3250,27 +3434,27 @@ def accept(self, visitor:ParseTreeVisitor):
     def scalar(self):
 
         localctx = RelayParser.ScalarContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 58, self.RULE_scalar)
+        self.enterRule(localctx, 64, self.RULE_scalar)
         try:
-            self.state = 453
+            self.state = 478
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [RelayParser.FLOAT]:
                 localctx = RelayParser.ScalarFloatContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 450
+                self.state = 475
                 self.match(RelayParser.FLOAT)
                 pass
             elif token in [RelayParser.NAT]:
                 localctx = RelayParser.ScalarIntContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 451
+                self.state = 476
                 self.match(RelayParser.NAT)
                 pass
             elif token in [RelayParser.BOOL_LIT]:
                 localctx = RelayParser.ScalarBoolContext(self, localctx)
                 self.enterOuterAlt(localctx, 3)
-                self.state = 452
+                self.state = 477
                 self.match(RelayParser.BOOL_LIT)
                 pass
             else:
@@ -3303,6 +3487,10 @@ def localVar(self):
             return self.getTypedRuleContext(RelayParser.LocalVarContext,0)
 
 
+        def typeIdent(self):
+            return self.getTypedRuleContext(RelayParser.TypeIdentContext,0)
+
+
         def graphVar(self):
             return self.getTypedRuleContext(RelayParser.GraphVarContext,0)
 
@@ -3322,32 +3510,38 @@ def accept(self, visitor:ParseTreeVisitor):
     def ident(self):
 
         localctx = RelayParser.IdentContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 60, self.RULE_ident)
+        self.enterRule(localctx, 66, self.RULE_ident)
         try:
-            self.state = 459
+            self.state = 485
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,45,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,48,self._ctx)
             if la_ == 1:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 455
+                self.state = 480
                 self.opIdent()
                 pass
 
             elif la_ == 2:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 456
+                self.state = 481
                 self.globalVar()
                 pass
 
             elif la_ == 3:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 457
+                self.state = 482
                 self.localVar()
                 pass
 
             elif la_ == 4:
                 self.enterOuterAlt(localctx, 4)
-                self.state = 458
+                self.state = 483
+                self.typeIdent()
+                pass
+
+            elif la_ == 5:
+                self.enterOuterAlt(localctx, 5)
+                self.state = 484
                 self.graphVar()
                 pass
 
diff --git a/python/tvm/relay/grammar/py3/RelayVisitor.py b/python/tvm/relay/grammar/py3/RelayVisitor.py
index 2bcaeff63cf5..e33757f3e456 100644
--- a/python/tvm/relay/grammar/py3/RelayVisitor.py
+++ b/python/tvm/relay/grammar/py3/RelayVisitor.py
@@ -154,8 +154,13 @@ def visitAdtDefn(self, ctx:RelayParser.AdtDefnContext):
         return self.visitChildren(ctx)
 
 
-    # Visit a parse tree produced by RelayParser#adtConstructor.
-    def visitAdtConstructor(self, ctx:RelayParser.AdtConstructorContext):
+    # Visit a parse tree produced by RelayParser#constructorName.
+    def visitConstructorName(self, ctx:RelayParser.ConstructorNameContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by RelayParser#adtConsDefn.
+    def visitAdtConsDefn(self, ctx:RelayParser.AdtConsDefnContext):
         return self.visitChildren(ctx)
 
 
@@ -179,8 +184,18 @@ def visitPattern(self, ctx:RelayParser.PatternContext):
         return self.visitChildren(ctx)
 
 
-    # Visit a parse tree produced by RelayParser#constructorName.
-    def visitConstructorName(self, ctx:RelayParser.ConstructorNameContext):
+    # Visit a parse tree produced by RelayParser#adtCons.
+    def visitAdtCons(self, ctx:RelayParser.AdtConsContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by RelayParser#adtConsParamList.
+    def visitAdtConsParamList(self, ctx:RelayParser.AdtConsParamListContext):
+        return self.visitChildren(ctx)
+
+
+    # Visit a parse tree produced by RelayParser#adtConsParam.
+    def visitAdtConsParam(self, ctx:RelayParser.AdtConsParamContext):
         return self.visitChildren(ctx)
 
 
diff --git a/src/relay/ir/alpha_equal.cc b/src/relay/ir/alpha_equal.cc
index 7ed8d1eb9c2b..6b7c4f633e5e 100644
--- a/src/relay/ir/alpha_equal.cc
+++ b/src/relay/ir/alpha_equal.cc
@@ -563,10 +563,6 @@ class AlphaEqualHandler:
         || !ExprEqual(lhs->data, rhs->data)
         || lhs->clauses.size() != rhs->clauses.size()
         || lhs->complete != rhs->complete) {
-      std::cout << "AYY" << std::endl;
-      std::cout << ExprEqual(lhs->data, rhs->data) << std::endl;
-      std::cout << lhs->clauses.size() << "," << rhs->clauses.size() << std::endl;
-      std::cout << lhs->complete << "," << rhs->complete << std::endl;
       return false;
     }
 
diff --git a/src/relay/ir/pretty_printer.cc b/src/relay/ir/pretty_printer.cc
index 0a8371074e40..41e576f8b52d 100644
--- a/src/relay/ir/pretty_printer.cc
+++ b/src/relay/ir/pretty_printer.cc
@@ -570,7 +570,12 @@ class PrettyPrinter :
     for (const Doc& d : PrintCallAttrs(op->attrs, op->op)) {
       args.push_back(d);
     }
-    doc << Print(op->op);
+    const auto* cons_node = op->op.as<ConstructorNode>();
+    if (cons_node) {
+      doc << cons_node->name_hint;
+    } else {
+      doc << Print(op->op);
+    }
     return doc << "(" << PrintSep(args) << ")";
   }
 
diff --git a/src/relay/pass/type_infer.cc b/src/relay/pass/type_infer.cc
index 1d10651f5c27..8d602616c8a4 100644
--- a/src/relay/pass/type_infer.cc
+++ b/src/relay/pass/type_infer.cc
@@ -753,7 +753,6 @@ class TypeInferencer::Resolver : public ExprMutator, PatternMutator {
   bool update_missing_type_annotation_{true};
 };
 
-
 Expr TypeInferencer::Infer(Expr expr) {
   // Step 1: Populate the constraints.
   GetType(expr);
diff --git a/tests/python/relay/test_ir_parser.py b/tests/python/relay/test_ir_parser.py
index b6638779cd5e..ea52f68a1802 100644
--- a/tests/python/relay/test_ir_parser.py
+++ b/tests/python/relay/test_ir_parser.py
@@ -66,6 +66,7 @@ def roundtrip(expr):
 
 
 def parse_text(code):
+    print('[BEFORE PARSE]')
     expr = relay.fromtext(SEMVER + "\n" + code)
     print('[PRETTY-PRINTED]')
     print(expr)
@@ -777,14 +778,12 @@ def test_adt_cons_expr():
 
     make_singleton_var = relay.GlobalVar("make_singleton")
     input_var = relay.Var("x", int32)
-    rest_var = relay.Var("rest")
-    length_func = relay.Function(
+    make_singleton_func = relay.Function(
         [input_var],
-        cons_constructor([input_var, nil_constructor()]),
-        list_var(int32),
-        [typ_var]
+        cons_constructor(input_var, nil_constructor()),
+        list_var(int32)
     )
-    mod[make_singleton_var] = length_func
+    mod[make_singleton_var] = make_singleton_func
 
     assert parses_as(
         """
@@ -793,7 +792,7 @@ def test_adt_cons_expr():
           | Nil
 
         def @make_singleton(%x: int32) -> List[int32] {
-          Cons(%x, Nil)
+          Cons(%x, Nil())
         }
         """,
         mod
@@ -801,30 +800,30 @@ def @make_singleton(%x: int32) -> List[int32] {
 
 
 if __name__ == "__main__":
-    test_comments()
-    test_int_literal()
-    test_float_literal()
-    test_bool_literal()
-    test_negative()
-    test_bin_op()
-    test_parens()
-    test_op_assoc()
-    test_let()
-    test_seq()
-    test_graph()
-    test_tuple()
-    test_func()
-    test_defn()
-    test_recursive_call()
-    test_ifelse()
-    test_call()
-    test_incomplete_type()
-    test_builtin_types()
-    test_tensor_type()
-    test_function_type()
-    test_tuple_type()
-    test_adt_defn()
-    test_multiple_cons_defn()
-    test_multiple_type_param_defn()
-    test_match()
-    # test_adt_cons_expr()
+    # test_comments()
+    # test_int_literal()
+    # test_float_literal()
+    # test_bool_literal()
+    # test_negative()
+    # test_bin_op()
+    # test_parens()
+    # test_op_assoc()
+    # test_let()
+    # test_seq()
+    # test_graph()
+    # test_tuple()
+    # test_func()
+    # test_defn()
+    # test_recursive_call()
+    # test_ifelse()
+    # test_call()
+    # test_incomplete_type()
+    # test_builtin_types()
+    # test_tensor_type()
+    # test_function_type()
+    # test_tuple_type()
+    # test_adt_defn()
+    # test_multiple_cons_defn()
+    # test_multiple_type_param_defn()
+    # test_match()
+    test_adt_cons_expr()

From 8a0be595f47cac776e21db529ebc9024c2219df6 Mon Sep 17 00:00:00 2001
From: Logan Weber <weberlo@cs.washington.edu>
Date: Tue, 27 Aug 2019 13:36:52 -0700
Subject: [PATCH 08/29] Cleanup round 1

---
 python/tvm/relay/_parser.py          |  80 +++++++------------
 src/relay/ir/alpha_equal.cc          |   2 -
 tests/python/relay/test_ir_parser.py | 113 +++++++++++++++++++--------
 3 files changed, 109 insertions(+), 86 deletions(-)

diff --git a/python/tvm/relay/_parser.py b/python/tvm/relay/_parser.py
index 8032e08e11dd..89fb70b4f015 100644
--- a/python/tvm/relay/_parser.py
+++ b/python/tvm/relay/_parser.py
@@ -54,8 +54,7 @@
 class ParseError(Exception):
     """Exception type for parse errors."""
 
-    def __init__(self, message):
-        # type: (str) -> None
+    def __init__(self, message: str) -> None:
         super(ParseError, self).__init__()
         self.message = message
 
@@ -193,9 +192,9 @@ def __init__(self, source_name):
 
         # Adding an empty scope allows naked lets without pain.
         self.var_scopes = deque([deque()])       # type: Scopes[expr.Var]
-        self.global_var_scope = deque()          # type: Scope[expr.GlobalVar]
+        self.global_vars = {}               # type: Scope[expr.GlobalVar]
         self.type_var_scopes = deque([deque()])  # type: Scopes[ty.TypeVar]
-        self.global_type_var_scope = deque()     # type: Scope[expr.GlobalVar]
+        self.global_type_vars = {}          # type: Scope[expr.GlobalVar]
         self.graph_expr = []                     # type: List[expr.Expr]
 
         super(ParseTreeToRelayIR, self).__init__()
@@ -221,8 +220,10 @@ def mk_var(self, name, typ=None):
     def mk_global_var(self, name):
         # type: (str) -> expr.GlobalVar
         """Create a new GlobalVar and add it to the GlobalVar scope."""
+        if name in self.global_vars:
+            raise ParseError(f'duplicate global var "{name}"')
         var = expr.GlobalVar(name)
-        self.global_var_scope.append((name, var))
+        self.global_vars[name] = var
         return var
 
     def enter_type_param_scope(self):
@@ -246,16 +247,29 @@ def mk_global_typ_var(self, name, kind):
         # (str, ty.Kind) -> ty.GlobalTypeVar
         """Create a new TypeVar and add it to the TypeVar scope."""
         typ = ty.GlobalTypeVar(name, kind)
-        self.global_type_var_scope.append((name, typ))
+        self._check_existing_typ_expr(name, typ)
+        self.global_type_vars[name] = typ
         return typ
 
     # TODO: rethink whether we should have type constructors mixed with type vars.
     def mk_global_typ_cons(self, name, cons):
-        if name in self.global_type_var_scope:
-            existing_cons = lookup([self.global_type_var_scope], name)
+        self._check_existing_typ_expr(name, cons)
+        self.global_type_vars[name] = cons
+
+    def _check_existing_typ_expr(self, name, new_expr):
+        if name in self.global_type_vars:
+            new_typ_name = self._type_expr_name(new_expr)
+            existing_typ_name = self._type_expr_name(self.global_type_vars[name])
             raise ParseError(
-                f'duplicate ADT definition "{name}" found in "{cons.belong_to.name}" and "{existing_cons.belong_to.name}"')
-        self.global_type_var_scope.append((name, cons))
+                f'{new_typ_name} `{name}` conflicts with existing {existing_typ_name}')
+
+    def _type_expr_name(self, expr):
+        if isinstance(expr, adt.Constructor):
+            return f'`{expr.belong_to.var.name}` ADT constructor'
+        elif isinstance(expr, ty.GlobalTypeVar):
+            if expr.kind == ty.Kind.AdtHandle:
+                return f'ADT definition'
+        return 'function definition'
 
     def visitProjection(self, ctx):
         return expr.TupleGetItem(self.visit(ctx.expr()), self.visit(ctx.NAT()))
@@ -285,16 +299,16 @@ def visitTerminal(self, node):
 
     def visitGlobalVar(self, ctx):
         var_name = ctx.START_LOWER_CNAME().getText()
-        global_var = lookup([self.global_var_scope], var_name)
+        global_var = self.global_vars.get(var_name, None)
         if global_var is None:
-            raise ParseError(f'unbound global var "{var_name}""')
+            raise ParseError(f'unbound global var `{var_name}`')
         return global_var
 
     def visitLocalVar(self, ctx):
         var_name = ctx.START_LOWER_CNAME().getText()
         local_var = lookup(self.var_scopes, var_name)
         if local_var is None:
-            raise ParseError(f'unbound local var "{var_name}""')
+            raise ParseError(f'unbound local var `{var_name}`')
         return local_var
 
     def visitGraphVar(self, ctx):
@@ -539,7 +553,7 @@ def visitMatch(self, ctx):
         clauses = []
         for clause in ctx.matchClause():
             constructor_name = clause.constructorName().getText()
-            constructor = lookup([self.global_type_var_scope], constructor_name)
+            constructor = self.global_type_vars[constructor_name]
             self.enter_var_scope()
             patternList = clause.patternList()
             if patternList is None:
@@ -572,41 +586,6 @@ def visitPattern(self, ctx):
         else:
             raise ParseError(f'invalid pattern syntax "{text}"')
 
-    def visitAdtCons(self, ctx):
-        import pdb; pdb.set_trace()
-
-    def visitTypeExprType(self, ctx):
-        type_params = ctx.typeParams()
-        print(ctx.getText())
-        if type_params is None:
-            print('ayy')
-        else:
-            print('lmao')
-        print()
-        # TODO: We need to handle arbitrarily nested type calls (e.g., `Maybe[List[Either[Int, Bool]]]`)
-        def _parse_typ_var(name):
-            typ_var = lookup(self.type_var_scopes, name)
-            if typ_var is None:
-                typ_var = lookup(self.global_type_var_scope, name)
-                if typ_var is None:
-                    # TODO: raise parse error?
-                    raise RuntimeError(f'unbound var "{name}"')
-            return typ_var
-
-        name = ctx.getText()
-        type_params = None
-        if '[' in name:
-            param_start_idx = name.find('[')
-            type_params = list(map(lambda s: s.strip(), name[param_start_idx+1:-1].split(',')))
-            name = name[:param_start_idx]
-
-        typ_var = _parse_typ_var(name)
-
-        if type_params:
-            return ty.TypeCall(typ_var, type_params)
-        else:
-            return typ_var
-
     def visitCallNoAttr(self, ctx):
         return (self.visit_list(ctx.exprList().expr()), None)
 
@@ -627,7 +606,6 @@ def visitCall(self, ctx):
         func = self.visit(ctx.expr())
         args, attrs = self.visit(ctx.callList())
         res = self.call(func, args, attrs, [])
-        import pdb; pdb.set_trace()
         return res
 
     @spanify
@@ -686,7 +664,7 @@ def visitTypeIdent(self, ctx):
         # Next, look it up in the local then global type params
         type_param = lookup(self.type_var_scopes, type_name)
         if type_param is None:
-            type_param = lookup([self.global_type_var_scope], type_name)
+            type_param = self.global_type_vars.get(type_name, None)
             if type_param is None:
                 raise ParseError(f'unbound var "{type_name}"')
 
diff --git a/src/relay/ir/alpha_equal.cc b/src/relay/ir/alpha_equal.cc
index 6b7c4f633e5e..06a94f17623b 100644
--- a/src/relay/ir/alpha_equal.cc
+++ b/src/relay/ir/alpha_equal.cc
@@ -568,11 +568,9 @@ class AlphaEqualHandler:
 
     for (size_t i = 0; i < lhs->clauses.size(); ++i) {
       if (!ClauseEqual(lhs->clauses[i], rhs->clauses[i])) {
-        std::cout << "LMAO" << std::endl;
         return false;
       }
     }
-    std::cout << "WAZ" << std::endl;
     return true;
   }
 
diff --git a/tests/python/relay/test_ir_parser.py b/tests/python/relay/test_ir_parser.py
index ea52f68a1802..e364040f47ae 100644
--- a/tests/python/relay/test_ir_parser.py
+++ b/tests/python/relay/test_ir_parser.py
@@ -66,22 +66,15 @@ def roundtrip(expr):
 
 
 def parse_text(code):
-    print('[BEFORE PARSE]')
     expr = relay.fromtext(SEMVER + "\n" + code)
-    print('[PRETTY-PRINTED]')
-    print(expr)
     roundtrip(expr)
     return expr
 
 
 def parses_as(code, expr):
     # type: (str, relay.Expr) -> bool
-    print('[ORIGINAL]')
-    print(code)
     parsed = parse_text(code)
-    print('[CHECKING EQULALALAALLALTYI]')
     result = alpha_equal(parsed, expr)
-    print('[FINISEHEHSHSHSED CHEKCIGN EEQUALTY]')
     return result
 
 def get_scalar(x):
@@ -798,32 +791,86 @@ def @make_singleton(%x: int32) -> List[int32] {
         mod
     )
 
+@raises_parse_error
+def test_duplicate_adt_defn():
+    parse_text(
+        """
+        type List[A] =
+          | Cons(A, List[A])
+          | Nil
+
+        type List[A] =
+          | Cons(A, List[A])
+          | Nil
+        """
+    )
+
+
+@raises_parse_error
+def test_duplicate_adt_cons():
+    parse_text(
+        """
+        type Ayy =
+          | Lmao
+
+        type Haha =
+          | Lmao
+        """
+    )
+
+
+@raises_parse_error
+def test_duplicate_adt_cons_defn():
+    parse_text(
+        """
+        type Ayy =
+          | Lmao
+
+        type Lmao =
+          | Ayy
+        """
+    )
+
+
+@raises_parse_error
+def test_duplicate_global_var():
+    parse_text(
+        """
+        def @id[A](%x: A) -> A { x }
+        def @id[A](%x: A) -> A { x }
+        """
+    )
+
 
 if __name__ == "__main__":
-    # test_comments()
-    # test_int_literal()
-    # test_float_literal()
-    # test_bool_literal()
-    # test_negative()
-    # test_bin_op()
-    # test_parens()
-    # test_op_assoc()
-    # test_let()
-    # test_seq()
-    # test_graph()
-    # test_tuple()
-    # test_func()
-    # test_defn()
-    # test_recursive_call()
-    # test_ifelse()
-    # test_call()
-    # test_incomplete_type()
-    # test_builtin_types()
-    # test_tensor_type()
-    # test_function_type()
-    # test_tuple_type()
-    # test_adt_defn()
-    # test_multiple_cons_defn()
-    # test_multiple_type_param_defn()
-    # test_match()
+    test_comments()
+    test_int_literal()
+    test_float_literal()
+    test_bool_literal()
+    test_negative()
+    test_bin_op()
+    test_parens()
+    test_op_assoc()
+    test_let()
+    test_seq()
+    test_graph()
+    test_tuple()
+    test_func()
+    test_defn()
+    test_recursive_call()
+    test_ifelse()
+    test_call()
+    test_incomplete_type()
+    test_builtin_types()
+    test_tensor_type()
+    test_function_type()
+    test_tuple_type()
+    test_adt_defn()
+    test_multiple_cons_defn()
+    test_multiple_type_param_defn()
+    test_match()
     test_adt_cons_expr()
+    test_duplicate_adt_defn()
+    test_duplicate_adt_cons()
+    test_duplicate_adt_cons_defn()
+    test_duplicate_global_var()

From 2ac4e9385d216f3e6ccde015daab3069fa9bc6ae Mon Sep 17 00:00:00 2001
From: Logan Weber <weberlo@cs.washington.edu>
Date: Wed, 28 Aug 2019 22:12:24 -0700
Subject: [PATCH 09/29] Cleanup round 2

---
 python/tvm/relay/grammar/Relay.g4          |  3 +--
 src/relay/ir/alpha_equal.cc                |  4 ++--
 tests/python/relay/test_ir_text_printer.py | 24 ----------------------
 3 files changed, 3 insertions(+), 28 deletions(-)

diff --git a/python/tvm/relay/grammar/Relay.g4 b/python/tvm/relay/grammar/Relay.g4
index 311e17a5c275..e327edced427 100644
--- a/python/tvm/relay/grammar/Relay.g4
+++ b/python/tvm/relay/grammar/Relay.g4
@@ -17,7 +17,7 @@
  * under the License.
  */
 
-// TODO: We need some way of indicating to users that you need to enable
+// TODO(weberlo): We need some way of indicating to users that you need to enable
 // USE_ANTLR in config.cmake.
 /*
  * NOTE: All upper-case rules are *lexer* rules and all lower-case rules are *parser* rules.
@@ -164,7 +164,6 @@ varList: (var (',' var)*)?;
 var: localVar (':' typeExpr)?;
 
 attrSeq: attr (',' attr)*;
-// attr: LOWER_NAME '=' expr ;
 attr: START_LOWER_CNAME '=' expr ;
 
 typeExpr
diff --git a/src/relay/ir/alpha_equal.cc b/src/relay/ir/alpha_equal.cc
index 06a94f17623b..eb923b41d02b 100644
--- a/src/relay/ir/alpha_equal.cc
+++ b/src/relay/ir/alpha_equal.cc
@@ -600,7 +600,7 @@ TVM_REGISTER_API("relay._make._alpha_equal")
 TVM_REGISTER_API("relay._make._assert_alpha_equal")
 .set_body_typed<void(NodeRef, NodeRef)>([](NodeRef a, NodeRef b) {
   bool alpha_equal = AlphaEqualHandler(false, true).Equal(a, b);
-  CHECK(alpha_equal) << AsText(a, true) << " and " << AsText(b, true) << " is not alpha equal";
+  CHECK(alpha_equal) << AsText(a, true) << " and " << AsText(b, true) << " are not alpha equal";
 });
 
 TVM_REGISTER_API("relay._make._graph_equal")
@@ -611,7 +611,7 @@ TVM_REGISTER_API("relay._make._graph_equal")
 TVM_REGISTER_API("relay._make._assert_graph_equal")
 .set_body_typed<void(NodeRef, NodeRef)>([](NodeRef a, NodeRef b) {
   bool graph_equal = AlphaEqualHandler(true, true).Equal(a, b);
-  CHECK(graph_equal) << AsText(a, true) << " and " << AsText(b, true) << " is not graph equal";
+  CHECK(graph_equal) << AsText(a, true) << " and " << AsText(b, true) << " are not graph equal";
 });
 
 }  // namespace relay
diff --git a/tests/python/relay/test_ir_text_printer.py b/tests/python/relay/test_ir_text_printer.py
index d4d6c8a0688d..4f6f202ea034 100644
--- a/tests/python/relay/test_ir_text_printer.py
+++ b/tests/python/relay/test_ir_text_printer.py
@@ -35,9 +35,7 @@ def astext(p, unify_free_vars=False):
     txt = p.astext()
     if isinstance(p, Expr) and free_vars(p):
         return txt
-    print('BEFORE PARSE')
     x = relay.fromtext(txt)
-    print('AFTER PARSE')
     if unify_free_vars:
         assert_graph_equal(x, p)
     else:
@@ -228,25 +226,6 @@ def test_zeros():
     x = relay.op.zeros([], "float32")
     show(astext(x))
 
-def test_adt_defn():
-    adt_var = GlobalTypeVar("List")
-    a = TypeVar("A")
-    nil_cons = Constructor("Nil", [], adt_var)
-    cons_cons = Constructor("Cons", [a, adt_var(a)], adt_var)
-    list_adt = TypeData(adt_var, [a], [nil_cons, cons_cons])
-    show(astext(list_adt))
-
-def test_match():
-    pass
-
-
-def test_cast():
-    data = relay.var('data', dtype='float32')
-    fp16_cast = relay.cast(data, dtype='float16')
-    cast_func = relay.Function(relay.analysis.free_vars(fp16_cast), fp16_cast)
-    astext(cast_func)
-
-
 if __name__ == "__main__":
     do_print[0] = True
     test_lstm()
@@ -268,6 +247,3 @@ def test_cast():
     test_let_if_scope()
     test_variable_name()
     test_call_node_order()
-    test_adt_defn()
-    test_match()
-    test_cast()

From 5d30aedf44276f6ec17457e8d1d002cf3df634d0 Mon Sep 17 00:00:00 2001
From: Logan Weber <weberlo@cs.washington.edu>
Date: Wed, 28 Aug 2019 22:53:48 -0700
Subject: [PATCH 10/29] Cleanup round 3

---
 include/tvm/relay/module.h                  |  6 ++---
 python/tvm/relay/_parser.py                 |  2 +-
 python/tvm/relay/grammar/Relay.g4           |  2 +-
 python/tvm/relay/grammar/py3/RelayParser.py |  8 +++----
 src/relay/ir/alpha_equal.cc                 |  8 ++-----
 src/relay/ir/pretty_printer.cc              | 26 ++++++++++-----------
 6 files changed, 23 insertions(+), 29 deletions(-)

diff --git a/include/tvm/relay/module.h b/include/tvm/relay/module.h
index 136ec700aee3..3496c8815467 100644
--- a/include/tvm/relay/module.h
+++ b/include/tvm/relay/module.h
@@ -165,9 +165,9 @@ class ModuleNode : public RelayNode {
   TVM_DLL TypeData LookupDef(const std::string& var) const;
 
   /*!
-   * \brief TODO
-   * \param TODO
-   * \return TODO
+   * \brief Check if a global type definition exists
+   * \param var The name of the global type definition.
+   * \return Whether the definition exists.
    */
   TVM_DLL bool HasDef(const std::string& var) const;
 
diff --git a/python/tvm/relay/_parser.py b/python/tvm/relay/_parser.py
index 89fb70b4f015..f1ff778e8721 100644
--- a/python/tvm/relay/_parser.py
+++ b/python/tvm/relay/_parser.py
@@ -461,7 +461,7 @@ def visitArgList(self,
         return (var_list, attr_list)
 
     def visitMeta(self, ctx):
-        type_key = str(ctx.CNAME())
+        type_key = str(ctx.START_UPPER_CNAME())
         index = int(self.visit(ctx.NAT()))
         return self.meta[type_key][index]
 
diff --git a/python/tvm/relay/grammar/Relay.g4 b/python/tvm/relay/grammar/Relay.g4
index e327edced427..9f8e066649af 100644
--- a/python/tvm/relay/grammar/Relay.g4
+++ b/python/tvm/relay/grammar/Relay.g4
@@ -189,7 +189,7 @@ shapeList
   ;
 
 // meta : 'meta' '[' LOWER_NAME ']' '[' NAT ']';
-meta : 'meta' '[' START_LOWER_CNAME ']' '[' NAT ']';
+meta : 'meta' '[' START_UPPER_CNAME ']' '[' NAT ']';
 
 shape
   : meta # metaShape
diff --git a/python/tvm/relay/grammar/py3/RelayParser.py b/python/tvm/relay/grammar/py3/RelayParser.py
index 97f865bec216..dc93d9c835b5 100644
--- a/python/tvm/relay/grammar/py3/RelayParser.py
+++ b/python/tvm/relay/grammar/py3/RelayParser.py
@@ -228,7 +228,7 @@ def serializedATN():
         buf.write("\u01c5\7\30\2\2\u01c5\u01c8\3\2\2\2\u01c6\u01c8\5> \2")
         buf.write("\u01c7\u01ba\3\2\2\2\u01c7\u01bc\3\2\2\2\u01c7\u01c6\3")
         buf.write("\2\2\2\u01c8;\3\2\2\2\u01c9\u01ca\7-\2\2\u01ca\u01cb\7")
-        buf.write("\33\2\2\u01cb\u01cc\7?\2\2\u01cc\u01cd\7\34\2\2\u01cd")
+        buf.write("\33\2\2\u01cb\u01cc\7>\2\2\u01cc\u01cd\7\34\2\2\u01cd")
         buf.write("\u01ce\7\33\2\2\u01ce\u01cf\7A\2\2\u01cf\u01d0\7\34\2")
         buf.write("\2\u01d0=\3\2\2\2\u01d1\u01d8\5<\37\2\u01d2\u01d3\7\27")
         buf.write("\2\2\u01d3\u01d4\5> \2\u01d4\u01d5\7\30\2\2\u01d5\u01d8")
@@ -3167,8 +3167,8 @@ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
             super().__init__(parent, invokingState)
             self.parser = parser
 
-        def START_LOWER_CNAME(self):
-            return self.getToken(RelayParser.START_LOWER_CNAME, 0)
+        def START_UPPER_CNAME(self):
+            return self.getToken(RelayParser.START_UPPER_CNAME, 0)
 
         def NAT(self):
             return self.getToken(RelayParser.NAT, 0)
@@ -3196,7 +3196,7 @@ def meta(self):
             self.state = 456
             self.match(RelayParser.T__24)
             self.state = 457
-            self.match(RelayParser.START_LOWER_CNAME)
+            self.match(RelayParser.START_UPPER_CNAME)
             self.state = 458
             self.match(RelayParser.T__25)
             self.state = 459
diff --git a/src/relay/ir/alpha_equal.cc b/src/relay/ir/alpha_equal.cc
index eb923b41d02b..572da77850c8 100644
--- a/src/relay/ir/alpha_equal.cc
+++ b/src/relay/ir/alpha_equal.cc
@@ -218,7 +218,6 @@ class AlphaEqualHandler:
   bool VisitType_(const TypeVarNode* lhs, const Type& other) final {
     if (const TypeVarNode* rhs = other.as<TypeVarNode>()) {
       if (lhs->kind != rhs->kind) return false;
-      // return LeafNodeEqual(GetRef<NodeRef>(lhs), other);
       return lhs->var->name_hint == rhs->var->name_hint;
     } else {
       return false;
@@ -317,11 +316,8 @@ class AlphaEqualHandler:
 
   bool VisitType_(const TypeDataNode* lhs, const Type& other) final {
     const TypeDataNode* rhs = other.as<TypeDataNode>();
-    bool result = true;
-    result |= rhs == nullptr;
-    result |= lhs->type_vars.size() != rhs->type_vars.size();
-    result |= !TypeEqual(lhs->header, rhs->header);
-    if (!result) {
+    if (rhs == nullptr || lhs->type_vars.size() != rhs->type_vars.size()
+        || !TypeEqual(lhs->header, rhs->header)) {
       return false;
     }
     for (size_t i = 0; i < lhs->type_vars.size(); ++i) {
diff --git a/src/relay/ir/pretty_printer.cc b/src/relay/ir/pretty_printer.cc
index 41e576f8b52d..8c1b426fd5df 100644
--- a/src/relay/ir/pretty_printer.cc
+++ b/src/relay/ir/pretty_printer.cc
@@ -255,7 +255,6 @@ class PrettyPrinter :
   }
 
   Doc AllocTemp() {
-    std::cout << "HWERE WITH " << std::endl;
     return TempVar(temp_var_counter_++);
   }
 
@@ -615,19 +614,16 @@ class PrettyPrinter :
   }
 
   Doc PrintPattern(const Pattern& pattern, bool meta) {
-    // auto it = memo_type_.find(type);
-    // if (it != memo_type_.end()) return it->second;
-    // Doc printed_type;
-    // if (meta) {
-    //   printed_type = meta_.GetMetaNode(GetRef<NodeRef>(type.get()));
-    // } else {
-    //   printed_type = VisitType(type);
-    // }
-    // memo_type_[type] = printed_type;
-    // return printed_type;
-
-    // TODO(weberlo): memoize?
-    return VisitPattern(pattern);
+    auto it = memo_pattern_.find(pattern);
+    if (it != memo_pattern_.end()) return it->second;
+    Doc printed_pattern;
+    if (meta) {
+      printed_pattern = meta_.GetMetaNode(GetRef<NodeRef>(pattern.get()));
+    } else {
+      printed_pattern = VisitPattern(pattern);
+    }
+    memo_pattern_[pattern] = printed_pattern;
+    return printed_pattern;
   }
 
   Doc VisitPattern_(const PatternConstructorNode* p) final {
@@ -847,6 +843,8 @@ class PrettyPrinter :
   std::unordered_map<Expr, Doc, NodeHash, NodeEqual> memo_;
   /*! \brief Map from Type to Doc */
   std::unordered_map<Type, Doc, NodeHash, NodeEqual> memo_type_;
+  /*! \brief Map from Type to Doc */
+  std::unordered_map<Pattern, Doc, NodeHash, NodeEqual> memo_pattern_;
   /*! \brief name allocation map */
   std::unordered_map<std::string, int> name_alloc_map_;
   /*! \brief meta data context */

From b66e917dc453bbddd846a240c619970ba557cc83 Mon Sep 17 00:00:00 2001
From: Logan Weber <weberlo@cs.washington.edu>
Date: Thu, 29 Aug 2019 23:57:52 -0700
Subject: [PATCH 11/29] Cleanup round 4

---
 python/tvm/relay/_parser.py                  |   38 +-
 python/tvm/relay/grammar/Relay.g4            |   82 +-
 python/tvm/relay/grammar/py3/RelayLexer.py   |  431 ++---
 python/tvm/relay/grammar/py3/RelayParser.py  | 1783 ++++++++----------
 python/tvm/relay/grammar/py3/RelayVisitor.py |   14 +-
 src/relay/ir/pretty_printer.cc               |   14 +-
 6 files changed, 1064 insertions(+), 1298 deletions(-)

diff --git a/python/tvm/relay/_parser.py b/python/tvm/relay/_parser.py
index f1ff778e8721..51d0dbc165f1 100644
--- a/python/tvm/relay/_parser.py
+++ b/python/tvm/relay/_parser.py
@@ -297,15 +297,33 @@ def visitTerminal(self, node):
 
         raise ParseError("todo: `{}`".format(node_text))
 
+    def visitGeneralIdent(self, ctx):
+        name = ctx.getText()
+        # Look through all type prefixes for a match.
+        for type_prefix in TYPE_PREFIXES:
+            if name.startswith(type_prefix):
+                return ty.scalar_type(name)
+        # Next, look it up in the local then global type params.
+        type_param = lookup(self.type_var_scopes, name)
+        if type_param is None:
+            type_param = self.global_type_vars.get(name, None)
+        if type_param is not None:
+            return type_param
+        # Check if it's an operator.
+        op_name = '.'.join([name.getText() for name in ctx.CNAME()])
+        if op_name in FUNC_OPS:
+            return FuncOp(FUNC_OPS[op_name])
+        return ExprOp(op.get(op_name))
+
     def visitGlobalVar(self, ctx):
-        var_name = ctx.START_LOWER_CNAME().getText()
+        var_name = ctx.CNAME().getText()
         global_var = self.global_vars.get(var_name, None)
         if global_var is None:
             raise ParseError(f'unbound global var `{var_name}`')
         return global_var
 
     def visitLocalVar(self, ctx):
-        var_name = ctx.START_LOWER_CNAME().getText()
+        var_name = ctx.CNAME().getText()
         local_var = lookup(self.var_scopes, var_name)
         if local_var is None:
             raise ParseError(f'unbound local var `{var_name}`')
@@ -348,7 +366,7 @@ def visitProg(self, ctx):
     # Exprs
     def visitOpIdent(self, ctx):
         # type: (RelayParser.OpIdentContext) -> op.Op
-        op_name = '.'.join([name.getText() for name in ctx.START_LOWER_CNAME()])
+        op_name = '.'.join([name.getText() for name in ctx.CNAME()])
         if op_name in FUNC_OPS:
             return FuncOp(FUNC_OPS[op_name])
         return ExprOp(op.get(op_name))
@@ -440,7 +458,7 @@ def visitVarList(self, ctx):
     # TODO: support a larger class of values than just Relay exprs
     def visitAttr(self, ctx):
         # type: (RelayParser.AttrContext) -> Tuple[str, expr.Expr]
-        return (ctx.START_LOWER_CNAME().getText(), self.visit(ctx.expr()))
+        return (ctx.CNAME().getText(), self.visit(ctx.expr()))
 
     def visitArgNoAttr(self, ctx):
         return (self.visit_list(ctx.varList().var()), None)
@@ -461,7 +479,7 @@ def visitArgList(self,
         return (var_list, attr_list)
 
     def visitMeta(self, ctx):
-        type_key = str(ctx.START_UPPER_CNAME())
+        type_key = str(ctx.CNAME())
         index = int(self.visit(ctx.NAT()))
         return self.meta[type_key][index]
 
@@ -475,7 +493,7 @@ def mk_func(self, ctx):
         type_params = ctx.typeParamList()
 
         if type_params is not None:
-            type_params = type_params.typeIdent()
+            type_params = type_params.generalIdent()
             assert type_params
             for ty_param in type_params:
                 name = ty_param.getText()
@@ -512,7 +530,7 @@ def visitFuncDefn(self, ctx):
         self.module[ident] = self.mk_func(ctx)
 
     def visitAdtDefn(self, ctx):
-        adt_name = ctx.typeIdent().getText()
+        adt_name = ctx.generalIdent().getText()
         adt_handle = self.mk_global_typ_var(adt_name, ty.Kind.AdtHandle)
         self.enter_type_param_scope()
 
@@ -522,7 +540,7 @@ def visitAdtDefn(self, ctx):
             type_params = []
         else:
             type_params = [self.mk_typ(type_ident.getText(), ty.Kind.Type)
-                           for type_ident in type_params.typeIdent()]
+                           for type_ident in type_params.generalIdent()]
 
         # parse constructors
         constructors = []
@@ -671,8 +689,8 @@ def visitTypeIdent(self, ctx):
         return type_param
 
     def visitTypeCallType(self, ctx):
-        func = self.visit(ctx.typeIdent())
-        args = [self.visit(arg) for arg in ctx.typeParamList().typeIdent()]
+        func = self.visit(ctx.generalIdent())
+        args = [self.visit(arg) for arg in ctx.typeParamList().generalIdent()]
         return ty.TypeCall(func, args)
 
     # def visitCallType(self, ctx):
diff --git a/python/tvm/relay/grammar/Relay.g4 b/python/tvm/relay/grammar/Relay.g4
index 9f8e066649af..7272b53fb5a6 100644
--- a/python/tvm/relay/grammar/Relay.g4
+++ b/python/tvm/relay/grammar/Relay.g4
@@ -53,29 +53,17 @@ BOOL_LIT
   | 'False'
   ;
 
-START_UPPER_CNAME: UPPER_LETTER ('_'|LETTER|DIGIT)*;
-START_LOWER_CNAME: LOWER_LETTER ('_'|LETTER|DIGIT)*;
-// CNAME: ('_'|LETTER) ('_'|LETTER|DIGIT)* ('.' CNAME)* ;
+CNAME: ('_'|LETTER) ('_'|LETTER|DIGIT)* ('.' CNAME)* ;
 
 // non-negative floats
 fragment PREFLOAT : NAT ('.' NAT)? EXP?; // 1.35, 1.35E-9, 0.3, 4.5, 1, 1e10 3e4
 
 FLOAT : PREFLOAT 'f';
 
-baseType
-  : 'int8' | 'int16' | 'int32' | 'int64'
-  | 'uint8' | 'uint16' | 'uint32' | 'uint64'
-  | 'float16' | 'float32' | 'float64'
-  | 'bool'
-  | 'int8x4' | 'uint1x4' | 'float16x4'
-  ;
-
 // non-negative ints
 NAT: DIGIT+ ;
 fragment EXP: [eE] [+\-]? NAT ; // \- since - means "range" inside [...]
 
-fragment LOWER_LETTER: [a-z];
-fragment UPPER_LETTER: [A-Z];
 fragment LETTER: [a-zA-Z];
 fragment DIGIT: [0-9];
 
@@ -85,25 +73,23 @@ METADATA: 'METADATA:' .*;
 // A Relay program is a list of global definitions or an expression.
 prog: SEMVER (defn* | expr) METADATA? EOF ;
 
-opIdent: START_LOWER_CNAME ('.' START_LOWER_CNAME)*;
-globalVar: '@' START_LOWER_CNAME ;
-localVar: '%' ('_' | START_LOWER_CNAME) ;
-typeIdent: (baseType | START_UPPER_CNAME) ;
+// Covers both operator and type idents
+generalIdent: CNAME ('.' CNAME)*;
+globalVar: '@' CNAME ;
+localVar: '%' ('_' | CNAME) ;
 graphVar: '%' NAT ;
 
 exprList: (expr (',' expr)*)?;
 callList
-  : exprList            # callNoAttr
-  | (expr ',')* attrSeq # callWithAttr
+  : exprList             # callNoAttr
+  | (expr ',')* attrSeq  # callWithAttr
   ;
 
 expr
   // operators
   : '(' expr ')'                                 # paren
   | '{' expr '}'                                 # paren
-  // | adtCons                                      # adtConsExpr
   // function application
-  // TODO: Just make the adt constructor part of the func app case. disambiguate during parsing.
   | expr '(' callList ')'                        # call
   | '-' expr                                     # neg
   | expr op=('*'|'/') expr                       # binOp
@@ -134,10 +120,10 @@ expr
 func: 'fn'        typeParamList? '(' argList ')' ('->' typeExpr)? body ;
 defn
   : 'def' globalVar typeParamList? '(' argList ')' ('->' typeExpr)? body  # funcDefn
-  | 'type' typeIdent typeParamList? '=' adtConsDefn+                      # adtDefn
+  | 'type' generalIdent typeParamList? '=' adtConsDefn+                      # adtDefn
   ;
 
-constructorName: START_UPPER_CNAME ;
+constructorName: CNAME ;
 
 adtConsDefn: '|' constructorName ('(' typeExpr (',' typeExpr)* ')')? ;
 matchClause: '|' constructorName patternList? '=>' expr ;
@@ -156,31 +142,29 @@ adtConsParamList: '(' adtConsParam (',' adtConsParam)* ')' ;
 adtConsParam: localVar | constructorName ;
 
 argList
-  : varList              # argNoAttr
-  | (var ',')* attrSeq   # argWithAttr
+  : varList             # argNoAttr
+  | (var ',')* attrSeq  # argWithAttr
   ;
 
-varList: (var (',' var)*)?;
-var: localVar (':' typeExpr)?;
+varList: (var (',' var)*)? ;
+var: localVar (':' typeExpr)? ;
 
-attrSeq: attr (',' attr)*;
-attr: START_LOWER_CNAME '=' expr ;
+attrSeq: attr (',' attr)* ;
+attr: CNAME '=' expr ;
 
 typeExpr
-  : '(' ')'                                                      # tupleType
-  | '(' typeExpr ',' ')'                                            # tupleType
-  | '(' typeExpr (',' typeExpr)+ ')'                                   # tupleType
-  | typeIdent typeParamList                                     # typeCallType
-  | typeIdent                                                    # typeIdentType
-  | 'Tensor' '[' shapeList ',' typeExpr ']'                         # tensorType
-  | 'fn' typeParamList? '(' (typeExpr (',' typeExpr)*)? ')' '->' typeExpr # funcType
-  | '_'                                                          # incompleteType
-  // TODO: Why the fuck does this rule exist?
-  // | NAT                                                          # intType
+  : '(' ')'                                                                # tupleType
+  | '(' typeExpr ',' ')'                                                   # tupleType
+  | '(' typeExpr (',' typeExpr)+ ')'                                       # tupleType
+  | generalIdent typeParamList                                             # typeCallType
+  | generalIdent                                                           # typeIdentType
+  | 'Tensor' '[' shapeList ',' typeExpr ']'                                # tensorType
+  | 'fn' typeParamList? '(' (typeExpr (',' typeExpr)*)? ')' '->' typeExpr  # funcType
+  | '_'                                                                    # incompleteType
   ;
 
 // TODO: For some reason, spaces aren't allowed between type params?
-typeParamList: '[' typeIdent (',' typeIdent)* ']' ;
+typeParamList: '[' generalIdent (',' generalIdent)* ']' ;
 
 shapeList
   : '(' ')'
@@ -188,27 +172,25 @@ shapeList
   | shape
   ;
 
-// meta : 'meta' '[' LOWER_NAME ']' '[' NAT ']';
-meta : 'meta' '[' START_UPPER_CNAME ']' '[' NAT ']';
+meta : 'meta' '[' CNAME ']' '[' NAT ']';
 
 shape
-  : meta # metaShape
-  | '(' shape ')'                        # parensShape
-  | NAT                                  # intShape
+  : meta           # metaShape
+  | '(' shape ')'  # parensShape
+  | NAT            # intShape
   ;
 
 body: '{' expr '}' ;
 
 scalar
-  : FLOAT    # scalarFloat
-  | NAT      # scalarInt
-  | BOOL_LIT # scalarBool
+  : FLOAT     # scalarFloat
+  | NAT       # scalarInt
+  | BOOL_LIT  # scalarBool
   ;
 
 ident
-  : opIdent
+  : generalIdent
   | globalVar
   | localVar
-  | typeIdent
   | graphVar
   ;
diff --git a/python/tvm/relay/grammar/py3/RelayLexer.py b/python/tvm/relay/grammar/py3/RelayLexer.py
index da53004e092c..177491a19018 100644
--- a/python/tvm/relay/grammar/py3/RelayLexer.py
+++ b/python/tvm/relay/grammar/py3/RelayLexer.py
@@ -8,8 +8,8 @@
 
 def serializedATN():
     with StringIO() as buf:
-        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2B")
-        buf.write("\u01eb\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7")
+        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\62")
+        buf.write("\u015c\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7")
         buf.write("\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r")
         buf.write("\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23")
         buf.write("\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30")
@@ -17,207 +17,147 @@ def serializedATN():
         buf.write("\t\36\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%")
         buf.write("\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.")
         buf.write("\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64")
-        buf.write("\t\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:")
-        buf.write("\4;\t;\4<\t<\4=\t=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\t")
-        buf.write("C\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\3\2\3\2\3\2\3\2\3\2\3")
-        buf.write("\3\3\3\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3\4\3\4\3\4\3\5\3\5")
-        buf.write("\3\5\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\3\6\3\7\3\7\3\7\3")
-        buf.write("\7\3\7\3\7\3\7\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\t\3\t\3\t")
-        buf.write("\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\13")
-        buf.write("\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\f\3")
-        buf.write("\f\3\f\3\f\3\f\3\r\3\r\3\r\3\r\3\r\3\16\3\16\3\16\3\16")
-        buf.write("\3\16\3\16\3\16\3\17\3\17\3\17\3\17\3\17\3\17\3\17\3\17")
-        buf.write("\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\20\3\21")
-        buf.write("\3\21\3\22\3\22\3\23\3\23\3\24\3\24\3\25\3\25\3\26\3\26")
-        buf.write("\3\27\3\27\3\30\3\30\3\31\3\31\3\32\3\32\3\33\3\33\3\34")
-        buf.write("\3\34\3\34\3\35\3\35\3\35\3\35\3\35\3\36\3\36\3\36\3\36")
-        buf.write("\3\37\3\37\3 \3 \3!\3!\3!\3\"\3\"\3\"\3#\3#\3#\3$\3$\3")
-        buf.write("$\3$\3%\3%\3%\3%\3%\3&\3&\3\'\3\'\3\'\3(\3(\3(\3(\3(\3")
-        buf.write("(\3)\3)\3)\3)\3)\3)\3)\3*\3*\3+\3+\3+\3+\3+\3+\3+\3,\3")
-        buf.write(",\3,\3,\3,\3-\3-\3-\3-\3-\3-\3-\3.\3.\3.\3.\3.\7.\u015e")
-        buf.write("\n.\f.\16.\u0161\13.\3.\3.\3.\3.\3.\3/\6/\u0169\n/\r/")
-        buf.write("\16/\u016a\3/\3/\3\60\3\60\3\60\3\60\7\60\u0173\n\60\f")
-        buf.write("\60\16\60\u0176\13\60\3\60\3\60\3\60\3\60\3\61\3\61\3")
-        buf.write("\61\3\62\3\62\3\62\7\62\u0182\n\62\f\62\16\62\u0185\13")
-        buf.write("\62\3\62\3\62\3\63\3\63\3\64\3\64\3\65\3\65\3\66\3\66")
-        buf.write("\3\67\3\67\38\38\39\39\39\3:\3:\3:\3;\3;\3;\3<\3<\3<\3")
-        buf.write("=\3=\3=\3=\3=\3=\3=\3=\3=\5=\u01aa\n=\3>\3>\3>\3>\7>\u01b0")
-        buf.write("\n>\f>\16>\u01b3\13>\3?\3?\3?\3?\7?\u01b9\n?\f?\16?\u01bc")
-        buf.write("\13?\3@\3@\3@\5@\u01c1\n@\3@\5@\u01c4\n@\3A\3A\3A\3B\6")
-        buf.write("B\u01ca\nB\rB\16B\u01cb\3C\3C\5C\u01d0\nC\3C\3C\3D\3D")
-        buf.write("\3E\3E\3F\3F\3G\3G\3H\3H\3H\3H\3H\3H\3H\3H\3H\3H\3H\7")
-        buf.write("H\u01e7\nH\fH\16H\u01ea\13H\5\u015f\u0174\u0183\2I\3\3")
-        buf.write("\5\4\7\5\t\6\13\7\r\b\17\t\21\n\23\13\25\f\27\r\31\16")
-        buf.write("\33\17\35\20\37\21!\22#\23%\24\'\25)\26+\27-\30/\31\61")
-        buf.write("\32\63\33\65\34\67\359\36;\37= ?!A\"C#E$G%I&K\'M(O)Q*")
-        buf.write("S+U,W-Y.[/]\60_\61a\2c\62e\63g\64i\65k\66m\67o8q9s:u;")
-        buf.write("w<y={>}?\177\2\u0081@\u0083A\u0085\2\u0087\2\u0089\2\u008b")
-        buf.write("\2\u008d\2\u008fB\3\2\n\5\2\13\f\17\17\"\"\4\2\f\f\17")
-        buf.write("\17\4\2GGgg\4\2--//\3\2c|\3\2C\\\4\2C\\c|\3\2\62;\2\u01f5")
-        buf.write("\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3\2\2\2\2\t\3\2\2\2\2\13")
-        buf.write("\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3")
-        buf.write("\2\2\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2")
-        buf.write("\2\2\2\35\3\2\2\2\2\37\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2")
-        buf.write("%\3\2\2\2\2\'\3\2\2\2\2)\3\2\2\2\2+\3\2\2\2\2-\3\2\2\2")
-        buf.write("\2/\3\2\2\2\2\61\3\2\2\2\2\63\3\2\2\2\2\65\3\2\2\2\2\67")
-        buf.write("\3\2\2\2\29\3\2\2\2\2;\3\2\2\2\2=\3\2\2\2\2?\3\2\2\2\2")
-        buf.write("A\3\2\2\2\2C\3\2\2\2\2E\3\2\2\2\2G\3\2\2\2\2I\3\2\2\2")
-        buf.write("\2K\3\2\2\2\2M\3\2\2\2\2O\3\2\2\2\2Q\3\2\2\2\2S\3\2\2")
-        buf.write("\2\2U\3\2\2\2\2W\3\2\2\2\2Y\3\2\2\2\2[\3\2\2\2\2]\3\2")
-        buf.write("\2\2\2_\3\2\2\2\2c\3\2\2\2\2e\3\2\2\2\2g\3\2\2\2\2i\3")
-        buf.write("\2\2\2\2k\3\2\2\2\2m\3\2\2\2\2o\3\2\2\2\2q\3\2\2\2\2s")
-        buf.write("\3\2\2\2\2u\3\2\2\2\2w\3\2\2\2\2y\3\2\2\2\2{\3\2\2\2\2")
-        buf.write("}\3\2\2\2\2\u0081\3\2\2\2\2\u0083\3\2\2\2\2\u008f\3\2")
-        buf.write("\2\2\3\u0091\3\2\2\2\5\u0096\3\2\2\2\7\u009c\3\2\2\2\t")
-        buf.write("\u00a2\3\2\2\2\13\u00a8\3\2\2\2\r\u00ae\3\2\2\2\17\u00b5")
-        buf.write("\3\2\2\2\21\u00bc\3\2\2\2\23\u00c3\3\2\2\2\25\u00cb\3")
-        buf.write("\2\2\2\27\u00d3\3\2\2\2\31\u00db\3\2\2\2\33\u00e0\3\2")
-        buf.write("\2\2\35\u00e7\3\2\2\2\37\u00ef\3\2\2\2!\u00f9\3\2\2\2")
-        buf.write("#\u00fb\3\2\2\2%\u00fd\3\2\2\2\'\u00ff\3\2\2\2)\u0101")
-        buf.write("\3\2\2\2+\u0103\3\2\2\2-\u0105\3\2\2\2/\u0107\3\2\2\2")
-        buf.write("\61\u0109\3\2\2\2\63\u010b\3\2\2\2\65\u010d\3\2\2\2\67")
-        buf.write("\u010f\3\2\2\29\u0112\3\2\2\2;\u0117\3\2\2\2=\u011b\3")
-        buf.write("\2\2\2?\u011d\3\2\2\2A\u011f\3\2\2\2C\u0122\3\2\2\2E\u0125")
-        buf.write("\3\2\2\2G\u0128\3\2\2\2I\u012c\3\2\2\2K\u0131\3\2\2\2")
-        buf.write("M\u0133\3\2\2\2O\u0136\3\2\2\2Q\u013c\3\2\2\2S\u0143\3")
-        buf.write("\2\2\2U\u0145\3\2\2\2W\u014c\3\2\2\2Y\u0151\3\2\2\2[\u0158")
-        buf.write("\3\2\2\2]\u0168\3\2\2\2_\u016e\3\2\2\2a\u017b\3\2\2\2")
-        buf.write("c\u017e\3\2\2\2e\u0188\3\2\2\2g\u018a\3\2\2\2i\u018c\3")
-        buf.write("\2\2\2k\u018e\3\2\2\2m\u0190\3\2\2\2o\u0192\3\2\2\2q\u0194")
-        buf.write("\3\2\2\2s\u0197\3\2\2\2u\u019a\3\2\2\2w\u019d\3\2\2\2")
-        buf.write("y\u01a9\3\2\2\2{\u01ab\3\2\2\2}\u01b4\3\2\2\2\177\u01bd")
-        buf.write("\3\2\2\2\u0081\u01c5\3\2\2\2\u0083\u01c9\3\2\2\2\u0085")
-        buf.write("\u01cd\3\2\2\2\u0087\u01d3\3\2\2\2\u0089\u01d5\3\2\2\2")
-        buf.write("\u008b\u01d7\3\2\2\2\u008d\u01d9\3\2\2\2\u008f\u01db\3")
-        buf.write("\2\2\2\u0091\u0092\7k\2\2\u0092\u0093\7p\2\2\u0093\u0094")
-        buf.write("\7v\2\2\u0094\u0095\7:\2\2\u0095\4\3\2\2\2\u0096\u0097")
-        buf.write("\7k\2\2\u0097\u0098\7p\2\2\u0098\u0099\7v\2\2\u0099\u009a")
-        buf.write("\7\63\2\2\u009a\u009b\78\2\2\u009b\6\3\2\2\2\u009c\u009d")
-        buf.write("\7k\2\2\u009d\u009e\7p\2\2\u009e\u009f\7v\2\2\u009f\u00a0")
-        buf.write("\7\65\2\2\u00a0\u00a1\7\64\2\2\u00a1\b\3\2\2\2\u00a2\u00a3")
-        buf.write("\7k\2\2\u00a3\u00a4\7p\2\2\u00a4\u00a5\7v\2\2\u00a5\u00a6")
-        buf.write("\78\2\2\u00a6\u00a7\7\66\2\2\u00a7\n\3\2\2\2\u00a8\u00a9")
-        buf.write("\7w\2\2\u00a9\u00aa\7k\2\2\u00aa\u00ab\7p\2\2\u00ab\u00ac")
-        buf.write("\7v\2\2\u00ac\u00ad\7:\2\2\u00ad\f\3\2\2\2\u00ae\u00af")
-        buf.write("\7w\2\2\u00af\u00b0\7k\2\2\u00b0\u00b1\7p\2\2\u00b1\u00b2")
-        buf.write("\7v\2\2\u00b2\u00b3\7\63\2\2\u00b3\u00b4\78\2\2\u00b4")
-        buf.write("\16\3\2\2\2\u00b5\u00b6\7w\2\2\u00b6\u00b7\7k\2\2\u00b7")
-        buf.write("\u00b8\7p\2\2\u00b8\u00b9\7v\2\2\u00b9\u00ba\7\65\2\2")
-        buf.write("\u00ba\u00bb\7\64\2\2\u00bb\20\3\2\2\2\u00bc\u00bd\7w")
-        buf.write("\2\2\u00bd\u00be\7k\2\2\u00be\u00bf\7p\2\2\u00bf\u00c0")
-        buf.write("\7v\2\2\u00c0\u00c1\78\2\2\u00c1\u00c2\7\66\2\2\u00c2")
-        buf.write("\22\3\2\2\2\u00c3\u00c4\7h\2\2\u00c4\u00c5\7n\2\2\u00c5")
-        buf.write("\u00c6\7q\2\2\u00c6\u00c7\7c\2\2\u00c7\u00c8\7v\2\2\u00c8")
-        buf.write("\u00c9\7\63\2\2\u00c9\u00ca\78\2\2\u00ca\24\3\2\2\2\u00cb")
-        buf.write("\u00cc\7h\2\2\u00cc\u00cd\7n\2\2\u00cd\u00ce\7q\2\2\u00ce")
-        buf.write("\u00cf\7c\2\2\u00cf\u00d0\7v\2\2\u00d0\u00d1\7\65\2\2")
-        buf.write("\u00d1\u00d2\7\64\2\2\u00d2\26\3\2\2\2\u00d3\u00d4\7h")
-        buf.write("\2\2\u00d4\u00d5\7n\2\2\u00d5\u00d6\7q\2\2\u00d6\u00d7")
-        buf.write("\7c\2\2\u00d7\u00d8\7v\2\2\u00d8\u00d9\78\2\2\u00d9\u00da")
-        buf.write("\7\66\2\2\u00da\30\3\2\2\2\u00db\u00dc\7d\2\2\u00dc\u00dd")
-        buf.write("\7q\2\2\u00dd\u00de\7q\2\2\u00de\u00df\7n\2\2\u00df\32")
-        buf.write("\3\2\2\2\u00e0\u00e1\7k\2\2\u00e1\u00e2\7p\2\2\u00e2\u00e3")
-        buf.write("\7v\2\2\u00e3\u00e4\7:\2\2\u00e4\u00e5\7z\2\2\u00e5\u00e6")
-        buf.write("\7\66\2\2\u00e6\34\3\2\2\2\u00e7\u00e8\7w\2\2\u00e8\u00e9")
-        buf.write("\7k\2\2\u00e9\u00ea\7p\2\2\u00ea\u00eb\7v\2\2\u00eb\u00ec")
-        buf.write("\7\63\2\2\u00ec\u00ed\7z\2\2\u00ed\u00ee\7\66\2\2\u00ee")
-        buf.write("\36\3\2\2\2\u00ef\u00f0\7h\2\2\u00f0\u00f1\7n\2\2\u00f1")
-        buf.write("\u00f2\7q\2\2\u00f2\u00f3\7c\2\2\u00f3\u00f4\7v\2\2\u00f4")
-        buf.write("\u00f5\7\63\2\2\u00f5\u00f6\78\2\2\u00f6\u00f7\7z\2\2")
-        buf.write("\u00f7\u00f8\7\66\2\2\u00f8 \3\2\2\2\u00f9\u00fa\7\60")
-        buf.write("\2\2\u00fa\"\3\2\2\2\u00fb\u00fc\7B\2\2\u00fc$\3\2\2\2")
-        buf.write("\u00fd\u00fe\7\'\2\2\u00fe&\3\2\2\2\u00ff\u0100\7a\2\2")
-        buf.write("\u0100(\3\2\2\2\u0101\u0102\7.\2\2\u0102*\3\2\2\2\u0103")
-        buf.write("\u0104\7*\2\2\u0104,\3\2\2\2\u0105\u0106\7+\2\2\u0106")
-        buf.write(".\3\2\2\2\u0107\u0108\7}\2\2\u0108\60\3\2\2\2\u0109\u010a")
-        buf.write("\7\177\2\2\u010a\62\3\2\2\2\u010b\u010c\7]\2\2\u010c\64")
-        buf.write("\3\2\2\2\u010d\u010e\7_\2\2\u010e\66\3\2\2\2\u010f\u0110")
-        buf.write("\7k\2\2\u0110\u0111\7h\2\2\u01118\3\2\2\2\u0112\u0113")
-        buf.write("\7g\2\2\u0113\u0114\7n\2\2\u0114\u0115\7u\2\2\u0115\u0116")
-        buf.write("\7g\2\2\u0116:\3\2\2\2\u0117\u0118\7n\2\2\u0118\u0119")
-        buf.write("\7g\2\2\u0119\u011a\7v\2\2\u011a<\3\2\2\2\u011b\u011c")
-        buf.write("\7?\2\2\u011c>\3\2\2\2\u011d\u011e\7=\2\2\u011e@\3\2\2")
-        buf.write("\2\u011f\u0120\7=\2\2\u0120\u0121\7=\2\2\u0121B\3\2\2")
-        buf.write("\2\u0122\u0123\7h\2\2\u0123\u0124\7p\2\2\u0124D\3\2\2")
-        buf.write("\2\u0125\u0126\7/\2\2\u0126\u0127\7@\2\2\u0127F\3\2\2")
-        buf.write("\2\u0128\u0129\7f\2\2\u0129\u012a\7g\2\2\u012a\u012b\7")
-        buf.write("h\2\2\u012bH\3\2\2\2\u012c\u012d\7v\2\2\u012d\u012e\7")
-        buf.write("{\2\2\u012e\u012f\7r\2\2\u012f\u0130\7g\2\2\u0130J\3\2")
-        buf.write("\2\2\u0131\u0132\7~\2\2\u0132L\3\2\2\2\u0133\u0134\7?")
-        buf.write("\2\2\u0134\u0135\7@\2\2\u0135N\3\2\2\2\u0136\u0137\7o")
-        buf.write("\2\2\u0137\u0138\7c\2\2\u0138\u0139\7v\2\2\u0139\u013a")
-        buf.write("\7e\2\2\u013a\u013b\7j\2\2\u013bP\3\2\2\2\u013c\u013d")
-        buf.write("\7o\2\2\u013d\u013e\7c\2\2\u013e\u013f\7v\2\2\u013f\u0140")
-        buf.write("\7e\2\2\u0140\u0141\7j\2\2\u0141\u0142\7A\2\2\u0142R\3")
-        buf.write("\2\2\2\u0143\u0144\7<\2\2\u0144T\3\2\2\2\u0145\u0146\7")
-        buf.write("V\2\2\u0146\u0147\7g\2\2\u0147\u0148\7p\2\2\u0148\u0149")
-        buf.write("\7u\2\2\u0149\u014a\7q\2\2\u014a\u014b\7t\2\2\u014bV\3")
-        buf.write("\2\2\2\u014c\u014d\7o\2\2\u014d\u014e\7g\2\2\u014e\u014f")
-        buf.write("\7v\2\2\u014f\u0150\7c\2\2\u0150X\3\2\2\2\u0151\u0152")
-        buf.write("\7x\2\2\u0152\u0153\7\62\2\2\u0153\u0154\7\60\2\2\u0154")
-        buf.write("\u0155\7\62\2\2\u0155\u0156\7\60\2\2\u0156\u0157\7\65")
-        buf.write("\2\2\u0157Z\3\2\2\2\u0158\u0159\7\61\2\2\u0159\u015a\7")
-        buf.write(",\2\2\u015a\u015f\3\2\2\2\u015b\u015e\5[.\2\u015c\u015e")
-        buf.write("\13\2\2\2\u015d\u015b\3\2\2\2\u015d\u015c\3\2\2\2\u015e")
-        buf.write("\u0161\3\2\2\2\u015f\u0160\3\2\2\2\u015f\u015d\3\2\2\2")
-        buf.write("\u0160\u0162\3\2\2\2\u0161\u015f\3\2\2\2\u0162\u0163\7")
-        buf.write(",\2\2\u0163\u0164\7\61\2\2\u0164\u0165\3\2\2\2\u0165\u0166")
-        buf.write("\b.\2\2\u0166\\\3\2\2\2\u0167\u0169\t\2\2\2\u0168\u0167")
-        buf.write("\3\2\2\2\u0169\u016a\3\2\2\2\u016a\u0168\3\2\2\2\u016a")
-        buf.write("\u016b\3\2\2\2\u016b\u016c\3\2\2\2\u016c\u016d\b/\2\2")
-        buf.write("\u016d^\3\2\2\2\u016e\u016f\7\61\2\2\u016f\u0170\7\61")
-        buf.write("\2\2\u0170\u0174\3\2\2\2\u0171\u0173\13\2\2\2\u0172\u0171")
-        buf.write("\3\2\2\2\u0173\u0176\3\2\2\2\u0174\u0175\3\2\2\2\u0174")
-        buf.write("\u0172\3\2\2\2\u0175\u0177\3\2\2\2\u0176\u0174\3\2\2\2")
-        buf.write("\u0177\u0178\7\f\2\2\u0178\u0179\3\2\2\2\u0179\u017a\b")
-        buf.write("\60\2\2\u017a`\3\2\2\2\u017b\u017c\7^\2\2\u017c\u017d")
-        buf.write("\7$\2\2\u017db\3\2\2\2\u017e\u0183\7$\2\2\u017f\u0182")
-        buf.write("\5a\61\2\u0180\u0182\n\3\2\2\u0181\u017f\3\2\2\2\u0181")
-        buf.write("\u0180\3\2\2\2\u0182\u0185\3\2\2\2\u0183\u0184\3\2\2\2")
-        buf.write("\u0183\u0181\3\2\2\2\u0184\u0186\3\2\2\2\u0185\u0183\3")
-        buf.write("\2\2\2\u0186\u0187\7$\2\2\u0187d\3\2\2\2\u0188\u0189\7")
-        buf.write(",\2\2\u0189f\3\2\2\2\u018a\u018b\7\61\2\2\u018bh\3\2\2")
-        buf.write("\2\u018c\u018d\7-\2\2\u018dj\3\2\2\2\u018e\u018f\7/\2")
-        buf.write("\2\u018fl\3\2\2\2\u0190\u0191\7>\2\2\u0191n\3\2\2\2\u0192")
-        buf.write("\u0193\7@\2\2\u0193p\3\2\2\2\u0194\u0195\7>\2\2\u0195")
-        buf.write("\u0196\7?\2\2\u0196r\3\2\2\2\u0197\u0198\7@\2\2\u0198")
-        buf.write("\u0199\7?\2\2\u0199t\3\2\2\2\u019a\u019b\7?\2\2\u019b")
-        buf.write("\u019c\7?\2\2\u019cv\3\2\2\2\u019d\u019e\7#\2\2\u019e")
-        buf.write("\u019f\7?\2\2\u019fx\3\2\2\2\u01a0\u01a1\7V\2\2\u01a1")
-        buf.write("\u01a2\7t\2\2\u01a2\u01a3\7w\2\2\u01a3\u01aa\7g\2\2\u01a4")
-        buf.write("\u01a5\7H\2\2\u01a5\u01a6\7c\2\2\u01a6\u01a7\7n\2\2\u01a7")
-        buf.write("\u01a8\7u\2\2\u01a8\u01aa\7g\2\2\u01a9\u01a0\3\2\2\2\u01a9")
-        buf.write("\u01a4\3\2\2\2\u01aaz\3\2\2\2\u01ab\u01b1\5\u0089E\2\u01ac")
-        buf.write("\u01b0\7a\2\2\u01ad\u01b0\5\u008bF\2\u01ae\u01b0\5\u008d")
-        buf.write("G\2\u01af\u01ac\3\2\2\2\u01af\u01ad\3\2\2\2\u01af\u01ae")
-        buf.write("\3\2\2\2\u01b0\u01b3\3\2\2\2\u01b1\u01af\3\2\2\2\u01b1")
-        buf.write("\u01b2\3\2\2\2\u01b2|\3\2\2\2\u01b3\u01b1\3\2\2\2\u01b4")
-        buf.write("\u01ba\5\u0087D\2\u01b5\u01b9\7a\2\2\u01b6\u01b9\5\u008b")
-        buf.write("F\2\u01b7\u01b9\5\u008dG\2\u01b8\u01b5\3\2\2\2\u01b8\u01b6")
-        buf.write("\3\2\2\2\u01b8\u01b7\3\2\2\2\u01b9\u01bc\3\2\2\2\u01ba")
-        buf.write("\u01b8\3\2\2\2\u01ba\u01bb\3\2\2\2\u01bb~\3\2\2\2\u01bc")
-        buf.write("\u01ba\3\2\2\2\u01bd\u01c0\5\u0083B\2\u01be\u01bf\7\60")
-        buf.write("\2\2\u01bf\u01c1\5\u0083B\2\u01c0\u01be\3\2\2\2\u01c0")
-        buf.write("\u01c1\3\2\2\2\u01c1\u01c3\3\2\2\2\u01c2\u01c4\5\u0085")
-        buf.write("C\2\u01c3\u01c2\3\2\2\2\u01c3\u01c4\3\2\2\2\u01c4\u0080")
-        buf.write("\3\2\2\2\u01c5\u01c6\5\177@\2\u01c6\u01c7\7h\2\2\u01c7")
-        buf.write("\u0082\3\2\2\2\u01c8\u01ca\5\u008dG\2\u01c9\u01c8\3\2")
-        buf.write("\2\2\u01ca\u01cb\3\2\2\2\u01cb\u01c9\3\2\2\2\u01cb\u01cc")
-        buf.write("\3\2\2\2\u01cc\u0084\3\2\2\2\u01cd\u01cf\t\4\2\2\u01ce")
-        buf.write("\u01d0\t\5\2\2\u01cf\u01ce\3\2\2\2\u01cf\u01d0\3\2\2\2")
-        buf.write("\u01d0\u01d1\3\2\2\2\u01d1\u01d2\5\u0083B\2\u01d2\u0086")
-        buf.write("\3\2\2\2\u01d3\u01d4\t\6\2\2\u01d4\u0088\3\2\2\2\u01d5")
-        buf.write("\u01d6\t\7\2\2\u01d6\u008a\3\2\2\2\u01d7\u01d8\t\b\2\2")
-        buf.write("\u01d8\u008c\3\2\2\2\u01d9\u01da\t\t\2\2\u01da\u008e\3")
-        buf.write("\2\2\2\u01db\u01dc\7O\2\2\u01dc\u01dd\7G\2\2\u01dd\u01de")
-        buf.write("\7V\2\2\u01de\u01df\7C\2\2\u01df\u01e0\7F\2\2\u01e0\u01e1")
-        buf.write("\7C\2\2\u01e1\u01e2\7V\2\2\u01e2\u01e3\7C\2\2\u01e3\u01e4")
-        buf.write("\7<\2\2\u01e4\u01e8\3\2\2\2\u01e5\u01e7\13\2\2\2\u01e6")
-        buf.write("\u01e5\3\2\2\2\u01e7\u01ea\3\2\2\2\u01e8\u01e6\3\2\2\2")
-        buf.write("\u01e8\u01e9\3\2\2\2\u01e9\u0090\3\2\2\2\u01ea\u01e8\3")
-        buf.write("\2\2\2\23\2\u015d\u015f\u016a\u0174\u0181\u0183\u01a9")
-        buf.write("\u01af\u01b1\u01b8\u01ba\u01c0\u01c3\u01cb\u01cf\u01e8")
-        buf.write("\3\b\2\2")
+        buf.write("\t\64\4\65\t\65\4\66\t\66\3\2\3\2\3\3\3\3\3\4\3\4\3\5")
+        buf.write("\3\5\3\6\3\6\3\7\3\7\3\b\3\b\3\t\3\t\3\n\3\n\3\13\3\13")
+        buf.write("\3\f\3\f\3\r\3\r\3\r\3\16\3\16\3\16\3\16\3\16\3\17\3\17")
+        buf.write("\3\17\3\17\3\20\3\20\3\21\3\21\3\22\3\22\3\22\3\23\3\23")
+        buf.write("\3\23\3\24\3\24\3\24\3\25\3\25\3\25\3\25\3\26\3\26\3\26")
+        buf.write("\3\26\3\26\3\27\3\27\3\30\3\30\3\30\3\31\3\31\3\31\3\31")
+        buf.write("\3\31\3\31\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\33\3\33")
+        buf.write("\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\35\3\35\3\35\3\35")
+        buf.write("\3\35\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\37\3\37\3\37")
+        buf.write("\3\37\3\37\7\37\u00d2\n\37\f\37\16\37\u00d5\13\37\3\37")
+        buf.write("\3\37\3\37\3\37\3\37\3 \6 \u00dd\n \r \16 \u00de\3 \3")
+        buf.write(" \3!\3!\3!\3!\7!\u00e7\n!\f!\16!\u00ea\13!\3!\3!\3!\3")
+        buf.write("!\3\"\3\"\3\"\3#\3#\3#\7#\u00f6\n#\f#\16#\u00f9\13#\3")
+        buf.write("#\3#\3$\3$\3%\3%\3&\3&\3\'\3\'\3(\3(\3)\3)\3*\3*\3*\3")
+        buf.write("+\3+\3+\3,\3,\3,\3-\3-\3-\3.\3.\3.\3.\3.\3.\3.\3.\3.\5")
+        buf.write(".\u011e\n.\3/\3/\5/\u0122\n/\3/\3/\3/\7/\u0127\n/\f/\16")
+        buf.write("/\u012a\13/\3/\3/\7/\u012e\n/\f/\16/\u0131\13/\3\60\3")
+        buf.write("\60\3\60\5\60\u0136\n\60\3\60\5\60\u0139\n\60\3\61\3\61")
+        buf.write("\3\61\3\62\6\62\u013f\n\62\r\62\16\62\u0140\3\63\3\63")
+        buf.write("\5\63\u0145\n\63\3\63\3\63\3\64\3\64\3\65\3\65\3\66\3")
+        buf.write("\66\3\66\3\66\3\66\3\66\3\66\3\66\3\66\3\66\3\66\7\66")
+        buf.write("\u0158\n\66\f\66\16\66\u015b\13\66\5\u00d3\u00e8\u00f7")
+        buf.write("\2\67\3\3\5\4\7\5\t\6\13\7\r\b\17\t\21\n\23\13\25\f\27")
+        buf.write("\r\31\16\33\17\35\20\37\21!\22#\23%\24\'\25)\26+\27-\30")
+        buf.write("/\31\61\32\63\33\65\34\67\359\36;\37= ?!A\"C\2E#G$I%K")
+        buf.write("&M\'O(Q)S*U+W,Y-[.]/_\2a\60c\61e\2g\2i\2k\62\3\2\b\5\2")
+        buf.write("\13\f\17\17\"\"\4\2\f\f\17\17\4\2GGgg\4\2--//\4\2C\\c")
+        buf.write("|\3\2\62;\2\u0167\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3\2\2\2")
+        buf.write("\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21")
+        buf.write("\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3")
+        buf.write("\2\2\2\2\33\3\2\2\2\2\35\3\2\2\2\2\37\3\2\2\2\2!\3\2\2")
+        buf.write("\2\2#\3\2\2\2\2%\3\2\2\2\2\'\3\2\2\2\2)\3\2\2\2\2+\3\2")
+        buf.write("\2\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("\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("\2\2\2?\3\2\2\2\2A\3\2\2\2\2E\3\2\2\2\2G\3\2\2\2\2I\3")
+        buf.write("\2\2\2\2K\3\2\2\2\2M\3\2\2\2\2O\3\2\2\2\2Q\3\2\2\2\2S")
+        buf.write("\3\2\2\2\2U\3\2\2\2\2W\3\2\2\2\2Y\3\2\2\2\2[\3\2\2\2\2")
+        buf.write("]\3\2\2\2\2a\3\2\2\2\2c\3\2\2\2\2k\3\2\2\2\3m\3\2\2\2")
+        buf.write("\5o\3\2\2\2\7q\3\2\2\2\ts\3\2\2\2\13u\3\2\2\2\rw\3\2\2")
+        buf.write("\2\17y\3\2\2\2\21{\3\2\2\2\23}\3\2\2\2\25\177\3\2\2\2")
+        buf.write("\27\u0081\3\2\2\2\31\u0083\3\2\2\2\33\u0086\3\2\2\2\35")
+        buf.write("\u008b\3\2\2\2\37\u008f\3\2\2\2!\u0091\3\2\2\2#\u0093")
+        buf.write("\3\2\2\2%\u0096\3\2\2\2\'\u0099\3\2\2\2)\u009c\3\2\2\2")
+        buf.write("+\u00a0\3\2\2\2-\u00a5\3\2\2\2/\u00a7\3\2\2\2\61\u00aa")
+        buf.write("\3\2\2\2\63\u00b0\3\2\2\2\65\u00b7\3\2\2\2\67\u00b9\3")
+        buf.write("\2\2\29\u00c0\3\2\2\2;\u00c5\3\2\2\2=\u00cc\3\2\2\2?\u00dc")
+        buf.write("\3\2\2\2A\u00e2\3\2\2\2C\u00ef\3\2\2\2E\u00f2\3\2\2\2")
+        buf.write("G\u00fc\3\2\2\2I\u00fe\3\2\2\2K\u0100\3\2\2\2M\u0102\3")
+        buf.write("\2\2\2O\u0104\3\2\2\2Q\u0106\3\2\2\2S\u0108\3\2\2\2U\u010b")
+        buf.write("\3\2\2\2W\u010e\3\2\2\2Y\u0111\3\2\2\2[\u011d\3\2\2\2")
+        buf.write("]\u0121\3\2\2\2_\u0132\3\2\2\2a\u013a\3\2\2\2c\u013e\3")
+        buf.write("\2\2\2e\u0142\3\2\2\2g\u0148\3\2\2\2i\u014a\3\2\2\2k\u014c")
+        buf.write("\3\2\2\2mn\7\60\2\2n\4\3\2\2\2op\7B\2\2p\6\3\2\2\2qr\7")
+        buf.write("\'\2\2r\b\3\2\2\2st\7a\2\2t\n\3\2\2\2uv\7.\2\2v\f\3\2")
+        buf.write("\2\2wx\7*\2\2x\16\3\2\2\2yz\7+\2\2z\20\3\2\2\2{|\7}\2")
+        buf.write("\2|\22\3\2\2\2}~\7\177\2\2~\24\3\2\2\2\177\u0080\7]\2")
+        buf.write("\2\u0080\26\3\2\2\2\u0081\u0082\7_\2\2\u0082\30\3\2\2")
+        buf.write("\2\u0083\u0084\7k\2\2\u0084\u0085\7h\2\2\u0085\32\3\2")
+        buf.write("\2\2\u0086\u0087\7g\2\2\u0087\u0088\7n\2\2\u0088\u0089")
+        buf.write("\7u\2\2\u0089\u008a\7g\2\2\u008a\34\3\2\2\2\u008b\u008c")
+        buf.write("\7n\2\2\u008c\u008d\7g\2\2\u008d\u008e\7v\2\2\u008e\36")
+        buf.write("\3\2\2\2\u008f\u0090\7?\2\2\u0090 \3\2\2\2\u0091\u0092")
+        buf.write("\7=\2\2\u0092\"\3\2\2\2\u0093\u0094\7=\2\2\u0094\u0095")
+        buf.write("\7=\2\2\u0095$\3\2\2\2\u0096\u0097\7h\2\2\u0097\u0098")
+        buf.write("\7p\2\2\u0098&\3\2\2\2\u0099\u009a\7/\2\2\u009a\u009b")
+        buf.write("\7@\2\2\u009b(\3\2\2\2\u009c\u009d\7f\2\2\u009d\u009e")
+        buf.write("\7g\2\2\u009e\u009f\7h\2\2\u009f*\3\2\2\2\u00a0\u00a1")
+        buf.write("\7v\2\2\u00a1\u00a2\7{\2\2\u00a2\u00a3\7r\2\2\u00a3\u00a4")
+        buf.write("\7g\2\2\u00a4,\3\2\2\2\u00a5\u00a6\7~\2\2\u00a6.\3\2\2")
+        buf.write("\2\u00a7\u00a8\7?\2\2\u00a8\u00a9\7@\2\2\u00a9\60\3\2")
+        buf.write("\2\2\u00aa\u00ab\7o\2\2\u00ab\u00ac\7c\2\2\u00ac\u00ad")
+        buf.write("\7v\2\2\u00ad\u00ae\7e\2\2\u00ae\u00af\7j\2\2\u00af\62")
+        buf.write("\3\2\2\2\u00b0\u00b1\7o\2\2\u00b1\u00b2\7c\2\2\u00b2\u00b3")
+        buf.write("\7v\2\2\u00b3\u00b4\7e\2\2\u00b4\u00b5\7j\2\2\u00b5\u00b6")
+        buf.write("\7A\2\2\u00b6\64\3\2\2\2\u00b7\u00b8\7<\2\2\u00b8\66\3")
+        buf.write("\2\2\2\u00b9\u00ba\7V\2\2\u00ba\u00bb\7g\2\2\u00bb\u00bc")
+        buf.write("\7p\2\2\u00bc\u00bd\7u\2\2\u00bd\u00be\7q\2\2\u00be\u00bf")
+        buf.write("\7t\2\2\u00bf8\3\2\2\2\u00c0\u00c1\7o\2\2\u00c1\u00c2")
+        buf.write("\7g\2\2\u00c2\u00c3\7v\2\2\u00c3\u00c4\7c\2\2\u00c4:\3")
+        buf.write("\2\2\2\u00c5\u00c6\7x\2\2\u00c6\u00c7\7\62\2\2\u00c7\u00c8")
+        buf.write("\7\60\2\2\u00c8\u00c9\7\62\2\2\u00c9\u00ca\7\60\2\2\u00ca")
+        buf.write("\u00cb\7\65\2\2\u00cb<\3\2\2\2\u00cc\u00cd\7\61\2\2\u00cd")
+        buf.write("\u00ce\7,\2\2\u00ce\u00d3\3\2\2\2\u00cf\u00d2\5=\37\2")
+        buf.write("\u00d0\u00d2\13\2\2\2\u00d1\u00cf\3\2\2\2\u00d1\u00d0")
+        buf.write("\3\2\2\2\u00d2\u00d5\3\2\2\2\u00d3\u00d4\3\2\2\2\u00d3")
+        buf.write("\u00d1\3\2\2\2\u00d4\u00d6\3\2\2\2\u00d5\u00d3\3\2\2\2")
+        buf.write("\u00d6\u00d7\7,\2\2\u00d7\u00d8\7\61\2\2\u00d8\u00d9\3")
+        buf.write("\2\2\2\u00d9\u00da\b\37\2\2\u00da>\3\2\2\2\u00db\u00dd")
+        buf.write("\t\2\2\2\u00dc\u00db\3\2\2\2\u00dd\u00de\3\2\2\2\u00de")
+        buf.write("\u00dc\3\2\2\2\u00de\u00df\3\2\2\2\u00df\u00e0\3\2\2\2")
+        buf.write("\u00e0\u00e1\b \2\2\u00e1@\3\2\2\2\u00e2\u00e3\7\61\2")
+        buf.write("\2\u00e3\u00e4\7\61\2\2\u00e4\u00e8\3\2\2\2\u00e5\u00e7")
+        buf.write("\13\2\2\2\u00e6\u00e5\3\2\2\2\u00e7\u00ea\3\2\2\2\u00e8")
+        buf.write("\u00e9\3\2\2\2\u00e8\u00e6\3\2\2\2\u00e9\u00eb\3\2\2\2")
+        buf.write("\u00ea\u00e8\3\2\2\2\u00eb\u00ec\7\f\2\2\u00ec\u00ed\3")
+        buf.write("\2\2\2\u00ed\u00ee\b!\2\2\u00eeB\3\2\2\2\u00ef\u00f0\7")
+        buf.write("^\2\2\u00f0\u00f1\7$\2\2\u00f1D\3\2\2\2\u00f2\u00f7\7")
+        buf.write("$\2\2\u00f3\u00f6\5C\"\2\u00f4\u00f6\n\3\2\2\u00f5\u00f3")
+        buf.write("\3\2\2\2\u00f5\u00f4\3\2\2\2\u00f6\u00f9\3\2\2\2\u00f7")
+        buf.write("\u00f8\3\2\2\2\u00f7\u00f5\3\2\2\2\u00f8\u00fa\3\2\2\2")
+        buf.write("\u00f9\u00f7\3\2\2\2\u00fa\u00fb\7$\2\2\u00fbF\3\2\2\2")
+        buf.write("\u00fc\u00fd\7,\2\2\u00fdH\3\2\2\2\u00fe\u00ff\7\61\2")
+        buf.write("\2\u00ffJ\3\2\2\2\u0100\u0101\7-\2\2\u0101L\3\2\2\2\u0102")
+        buf.write("\u0103\7/\2\2\u0103N\3\2\2\2\u0104\u0105\7>\2\2\u0105")
+        buf.write("P\3\2\2\2\u0106\u0107\7@\2\2\u0107R\3\2\2\2\u0108\u0109")
+        buf.write("\7>\2\2\u0109\u010a\7?\2\2\u010aT\3\2\2\2\u010b\u010c")
+        buf.write("\7@\2\2\u010c\u010d\7?\2\2\u010dV\3\2\2\2\u010e\u010f")
+        buf.write("\7?\2\2\u010f\u0110\7?\2\2\u0110X\3\2\2\2\u0111\u0112")
+        buf.write("\7#\2\2\u0112\u0113\7?\2\2\u0113Z\3\2\2\2\u0114\u0115")
+        buf.write("\7V\2\2\u0115\u0116\7t\2\2\u0116\u0117\7w\2\2\u0117\u011e")
+        buf.write("\7g\2\2\u0118\u0119\7H\2\2\u0119\u011a\7c\2\2\u011a\u011b")
+        buf.write("\7n\2\2\u011b\u011c\7u\2\2\u011c\u011e\7g\2\2\u011d\u0114")
+        buf.write("\3\2\2\2\u011d\u0118\3\2\2\2\u011e\\\3\2\2\2\u011f\u0122")
+        buf.write("\7a\2\2\u0120\u0122\5g\64\2\u0121\u011f\3\2\2\2\u0121")
+        buf.write("\u0120\3\2\2\2\u0122\u0128\3\2\2\2\u0123\u0127\7a\2\2")
+        buf.write("\u0124\u0127\5g\64\2\u0125\u0127\5i\65\2\u0126\u0123\3")
+        buf.write("\2\2\2\u0126\u0124\3\2\2\2\u0126\u0125\3\2\2\2\u0127\u012a")
+        buf.write("\3\2\2\2\u0128\u0126\3\2\2\2\u0128\u0129\3\2\2\2\u0129")
+        buf.write("\u012f\3\2\2\2\u012a\u0128\3\2\2\2\u012b\u012c\7\60\2")
+        buf.write("\2\u012c\u012e\5]/\2\u012d\u012b\3\2\2\2\u012e\u0131\3")
+        buf.write("\2\2\2\u012f\u012d\3\2\2\2\u012f\u0130\3\2\2\2\u0130^")
+        buf.write("\3\2\2\2\u0131\u012f\3\2\2\2\u0132\u0135\5c\62\2\u0133")
+        buf.write("\u0134\7\60\2\2\u0134\u0136\5c\62\2\u0135\u0133\3\2\2")
+        buf.write("\2\u0135\u0136\3\2\2\2\u0136\u0138\3\2\2\2\u0137\u0139")
+        buf.write("\5e\63\2\u0138\u0137\3\2\2\2\u0138\u0139\3\2\2\2\u0139")
+        buf.write("`\3\2\2\2\u013a\u013b\5_\60\2\u013b\u013c\7h\2\2\u013c")
+        buf.write("b\3\2\2\2\u013d\u013f\5i\65\2\u013e\u013d\3\2\2\2\u013f")
+        buf.write("\u0140\3\2\2\2\u0140\u013e\3\2\2\2\u0140\u0141\3\2\2\2")
+        buf.write("\u0141d\3\2\2\2\u0142\u0144\t\4\2\2\u0143\u0145\t\5\2")
+        buf.write("\2\u0144\u0143\3\2\2\2\u0144\u0145\3\2\2\2\u0145\u0146")
+        buf.write("\3\2\2\2\u0146\u0147\5c\62\2\u0147f\3\2\2\2\u0148\u0149")
+        buf.write("\t\6\2\2\u0149h\3\2\2\2\u014a\u014b\t\7\2\2\u014bj\3\2")
+        buf.write("\2\2\u014c\u014d\7O\2\2\u014d\u014e\7G\2\2\u014e\u014f")
+        buf.write("\7V\2\2\u014f\u0150\7C\2\2\u0150\u0151\7F\2\2\u0151\u0152")
+        buf.write("\7C\2\2\u0152\u0153\7V\2\2\u0153\u0154\7C\2\2\u0154\u0155")
+        buf.write("\7<\2\2\u0155\u0159\3\2\2\2\u0156\u0158\13\2\2\2\u0157")
+        buf.write("\u0156\3\2\2\2\u0158\u015b\3\2\2\2\u0159\u0157\3\2\2\2")
+        buf.write("\u0159\u015a\3\2\2\2\u015al\3\2\2\2\u015b\u0159\3\2\2")
+        buf.write("\2\23\2\u00d1\u00d3\u00de\u00e8\u00f5\u00f7\u011d\u0121")
+        buf.write("\u0126\u0128\u012f\u0135\u0138\u0140\u0144\u0159\3\b\2")
+        buf.write("\2")
         return buf.getvalue()
 
 
@@ -255,75 +195,52 @@ class RelayLexer(Lexer):
     T__25 = 26
     T__26 = 27
     T__27 = 28
-    T__28 = 29
-    T__29 = 30
-    T__30 = 31
-    T__31 = 32
-    T__32 = 33
-    T__33 = 34
-    T__34 = 35
-    T__35 = 36
-    T__36 = 37
-    T__37 = 38
-    T__38 = 39
-    T__39 = 40
-    T__40 = 41
-    T__41 = 42
-    T__42 = 43
-    SEMVER = 44
-    COMMENT = 45
-    WS = 46
-    LINE_COMMENT = 47
-    QUOTED_STRING = 48
-    MUL = 49
-    DIV = 50
-    ADD = 51
-    SUB = 52
-    LT = 53
-    GT = 54
-    LE = 55
-    GE = 56
-    EQ = 57
-    NE = 58
-    BOOL_LIT = 59
-    START_UPPER_CNAME = 60
-    START_LOWER_CNAME = 61
-    FLOAT = 62
-    NAT = 63
-    METADATA = 64
+    SEMVER = 29
+    COMMENT = 30
+    WS = 31
+    LINE_COMMENT = 32
+    QUOTED_STRING = 33
+    MUL = 34
+    DIV = 35
+    ADD = 36
+    SUB = 37
+    LT = 38
+    GT = 39
+    LE = 40
+    GE = 41
+    EQ = 42
+    NE = 43
+    BOOL_LIT = 44
+    CNAME = 45
+    FLOAT = 46
+    NAT = 47
+    METADATA = 48
 
     channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ]
 
     modeNames = [ "DEFAULT_MODE" ]
 
     literalNames = [ "<INVALID>",
-            "'int8'", "'int16'", "'int32'", "'int64'", "'uint8'", "'uint16'", 
-            "'uint32'", "'uint64'", "'float16'", "'float32'", "'float64'", 
-            "'bool'", "'int8x4'", "'uint1x4'", "'float16x4'", "'.'", "'@'", 
-            "'%'", "'_'", "','", "'('", "')'", "'{'", "'}'", "'['", "']'", 
-            "'if'", "'else'", "'let'", "'='", "';'", "';;'", "'fn'", "'->'", 
-            "'def'", "'type'", "'|'", "'=>'", "'match'", "'match?'", "':'", 
-            "'Tensor'", "'meta'", "'v0.0.3'", "'*'", "'/'", "'+'", "'-'", 
-            "'<'", "'>'", "'<='", "'>='", "'=='", "'!='" ]
+            "'.'", "'@'", "'%'", "'_'", "','", "'('", "')'", "'{'", "'}'", 
+            "'['", "']'", "'if'", "'else'", "'let'", "'='", "';'", "';;'", 
+            "'fn'", "'->'", "'def'", "'type'", "'|'", "'=>'", "'match'", 
+            "'match?'", "':'", "'Tensor'", "'meta'", "'v0.0.3'", "'*'", 
+            "'/'", "'+'", "'-'", "'<'", "'>'", "'<='", "'>='", "'=='", "'!='" ]
 
     symbolicNames = [ "<INVALID>",
             "SEMVER", "COMMENT", "WS", "LINE_COMMENT", "QUOTED_STRING", 
             "MUL", "DIV", "ADD", "SUB", "LT", "GT", "LE", "GE", "EQ", "NE", 
-            "BOOL_LIT", "START_UPPER_CNAME", "START_LOWER_CNAME", "FLOAT", 
-            "NAT", "METADATA" ]
+            "BOOL_LIT", "CNAME", "FLOAT", "NAT", "METADATA" ]
 
     ruleNames = [ "T__0", "T__1", "T__2", "T__3", "T__4", "T__5", "T__6", 
                   "T__7", "T__8", "T__9", "T__10", "T__11", "T__12", "T__13", 
                   "T__14", "T__15", "T__16", "T__17", "T__18", "T__19", 
                   "T__20", "T__21", "T__22", "T__23", "T__24", "T__25", 
-                  "T__26", "T__27", "T__28", "T__29", "T__30", "T__31", 
-                  "T__32", "T__33", "T__34", "T__35", "T__36", "T__37", 
-                  "T__38", "T__39", "T__40", "T__41", "T__42", "SEMVER", 
-                  "COMMENT", "WS", "LINE_COMMENT", "ESCAPED_QUOTE", "QUOTED_STRING", 
-                  "MUL", "DIV", "ADD", "SUB", "LT", "GT", "LE", "GE", "EQ", 
-                  "NE", "BOOL_LIT", "START_UPPER_CNAME", "START_LOWER_CNAME", 
-                  "PREFLOAT", "FLOAT", "NAT", "EXP", "LOWER_LETTER", "UPPER_LETTER", 
-                  "LETTER", "DIGIT", "METADATA" ]
+                  "T__26", "T__27", "SEMVER", "COMMENT", "WS", "LINE_COMMENT", 
+                  "ESCAPED_QUOTE", "QUOTED_STRING", "MUL", "DIV", "ADD", 
+                  "SUB", "LT", "GT", "LE", "GE", "EQ", "NE", "BOOL_LIT", 
+                  "CNAME", "PREFLOAT", "FLOAT", "NAT", "EXP", "LETTER", 
+                  "DIGIT", "METADATA" ]
 
     grammarFileName = "Relay.g4"
 
diff --git a/python/tvm/relay/grammar/py3/RelayParser.py b/python/tvm/relay/grammar/py3/RelayParser.py
index dc93d9c835b5..03b162d93c60 100644
--- a/python/tvm/relay/grammar/py3/RelayParser.py
+++ b/python/tvm/relay/grammar/py3/RelayParser.py
@@ -8,245 +8,237 @@
 
 def serializedATN():
     with StringIO() as buf:
-        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3B")
-        buf.write("\u01ea\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
+        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\62")
+        buf.write("\u01df\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
         buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
         buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
         buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
         buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
-        buf.write("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\3\2\3\2\3\3\3\3\7")
-        buf.write("\3K\n\3\f\3\16\3N\13\3\3\3\5\3Q\n\3\3\3\5\3T\n\3\3\3\3")
-        buf.write("\3\3\4\3\4\3\4\7\4[\n\4\f\4\16\4^\13\4\3\5\3\5\3\5\3\6")
-        buf.write("\3\6\3\6\3\7\3\7\5\7h\n\7\3\b\3\b\3\b\3\t\3\t\3\t\7\t")
-        buf.write("p\n\t\f\t\16\ts\13\t\5\tu\n\t\3\n\3\n\3\n\3\n\7\n{\n\n")
-        buf.write("\f\n\16\n~\13\n\3\n\5\n\u0081\n\n\3\13\3\13\3\13\3\13")
-        buf.write("\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13")
-        buf.write("\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\6\13\u009a\n")
-        buf.write("\13\r\13\16\13\u009b\3\13\3\13\3\13\3\13\3\13\3\13\7\13")
-        buf.write("\u00a4\n\13\f\13\16\13\u00a7\13\13\5\13\u00a9\n\13\3\13")
-        buf.write("\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13")
-        buf.write("\3\13\3\13\3\13\6\13\u00ba\n\13\r\13\16\13\u00bb\3\13")
-        buf.write("\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13")
-        buf.write("\3\13\3\13\3\13\3\13\3\13\3\13\3\13\5\13\u00d1\n\13\3")
-        buf.write("\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13")
-        buf.write("\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13")
-        buf.write("\3\13\7\13\u00ea\n\13\f\13\16\13\u00ed\13\13\3\f\3\f\5")
-        buf.write("\f\u00f1\n\f\3\f\3\f\3\f\3\f\3\f\5\f\u00f8\n\f\3\f\3\f")
-        buf.write("\3\r\3\r\3\r\5\r\u00ff\n\r\3\r\3\r\3\r\3\r\3\r\5\r\u0106")
-        buf.write("\n\r\3\r\3\r\3\r\3\r\3\r\5\r\u010d\n\r\3\r\3\r\6\r\u0111")
-        buf.write("\n\r\r\r\16\r\u0112\5\r\u0115\n\r\3\16\3\16\3\17\3\17")
-        buf.write("\3\17\3\17\3\17\3\17\7\17\u011f\n\17\f\17\16\17\u0122")
-        buf.write("\13\17\3\17\3\17\5\17\u0126\n\17\3\20\3\20\3\20\5\20\u012b")
-        buf.write("\n\20\3\20\3\20\3\20\3\21\3\21\3\22\3\22\3\22\3\22\7\22")
-        buf.write("\u0136\n\22\f\22\16\22\u0139\13\22\3\22\3\22\3\23\3\23")
-        buf.write("\3\23\3\23\5\23\u0141\n\23\5\23\u0143\n\23\3\24\3\24\5")
-        buf.write("\24\u0147\n\24\3\25\3\25\3\25\3\25\7\25\u014d\n\25\f\25")
-        buf.write("\16\25\u0150\13\25\3\25\3\25\3\26\3\26\5\26\u0156\n\26")
-        buf.write("\3\27\3\27\3\27\3\27\7\27\u015c\n\27\f\27\16\27\u015f")
-        buf.write("\13\27\3\27\5\27\u0162\n\27\3\30\3\30\3\30\7\30\u0167")
-        buf.write("\n\30\f\30\16\30\u016a\13\30\5\30\u016c\n\30\3\31\3\31")
-        buf.write("\3\31\5\31\u0171\n\31\3\32\3\32\3\32\7\32\u0176\n\32\f")
-        buf.write("\32\16\32\u0179\13\32\3\33\3\33\3\33\3\33\3\34\3\34\3")
-        buf.write("\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\6\34\u018a")
-        buf.write("\n\34\r\34\16\34\u018b\3\34\3\34\3\34\3\34\3\34\3\34\3")
-        buf.write("\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\5\34\u019d")
-        buf.write("\n\34\3\34\3\34\3\34\3\34\7\34\u01a3\n\34\f\34\16\34\u01a6")
-        buf.write("\13\34\5\34\u01a8\n\34\3\34\3\34\3\34\3\34\5\34\u01ae")
-        buf.write("\n\34\3\35\3\35\3\35\3\35\7\35\u01b4\n\35\f\35\16\35\u01b7")
-        buf.write("\13\35\3\35\3\35\3\36\3\36\3\36\3\36\3\36\3\36\6\36\u01c1")
-        buf.write("\n\36\r\36\16\36\u01c2\3\36\3\36\3\36\5\36\u01c8\n\36")
-        buf.write("\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3 \3 \3 \3 \3")
-        buf.write(" \3 \5 \u01d8\n \3!\3!\3!\3!\3\"\3\"\3\"\5\"\u01e1\n\"")
-        buf.write("\3#\3#\3#\3#\3#\5#\u01e8\n#\3#\2\3\24$\2\4\6\b\n\f\16")
-        buf.write("\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BD\2")
-        buf.write("\t\3\2\3\21\4\2\25\25??\3\2\63\64\3\2\65\66\3\2\67:\3")
-        buf.write("\2;<\3\2)*\2\u0217\2F\3\2\2\2\4H\3\2\2\2\6W\3\2\2\2\b")
-        buf.write("_\3\2\2\2\nb\3\2\2\2\fg\3\2\2\2\16i\3\2\2\2\20t\3\2\2")
-        buf.write("\2\22\u0080\3\2\2\2\24\u00d0\3\2\2\2\26\u00ee\3\2\2\2")
-        buf.write("\30\u0114\3\2\2\2\32\u0116\3\2\2\2\34\u0118\3\2\2\2\36")
-        buf.write("\u0127\3\2\2\2 \u012f\3\2\2\2\"\u0131\3\2\2\2$\u0142\3")
-        buf.write("\2\2\2&\u0144\3\2\2\2(\u0148\3\2\2\2*\u0155\3\2\2\2,\u0161")
-        buf.write("\3\2\2\2.\u016b\3\2\2\2\60\u016d\3\2\2\2\62\u0172\3\2")
-        buf.write("\2\2\64\u017a\3\2\2\2\66\u01ad\3\2\2\28\u01af\3\2\2\2")
-        buf.write(":\u01c7\3\2\2\2<\u01c9\3\2\2\2>\u01d7\3\2\2\2@\u01d9\3")
-        buf.write("\2\2\2B\u01e0\3\2\2\2D\u01e7\3\2\2\2FG\t\2\2\2G\3\3\2")
-        buf.write("\2\2HP\7.\2\2IK\5\30\r\2JI\3\2\2\2KN\3\2\2\2LJ\3\2\2\2")
-        buf.write("LM\3\2\2\2MQ\3\2\2\2NL\3\2\2\2OQ\5\24\13\2PL\3\2\2\2P")
-        buf.write("O\3\2\2\2QS\3\2\2\2RT\7B\2\2SR\3\2\2\2ST\3\2\2\2TU\3\2")
-        buf.write("\2\2UV\7\2\2\3V\5\3\2\2\2W\\\7?\2\2XY\7\22\2\2Y[\7?\2")
-        buf.write("\2ZX\3\2\2\2[^\3\2\2\2\\Z\3\2\2\2\\]\3\2\2\2]\7\3\2\2")
-        buf.write("\2^\\\3\2\2\2_`\7\23\2\2`a\7?\2\2a\t\3\2\2\2bc\7\24\2")
-        buf.write("\2cd\t\3\2\2d\13\3\2\2\2eh\5\2\2\2fh\7>\2\2ge\3\2\2\2")
-        buf.write("gf\3\2\2\2h\r\3\2\2\2ij\7\24\2\2jk\7A\2\2k\17\3\2\2\2")
-        buf.write("lq\5\24\13\2mn\7\26\2\2np\5\24\13\2om\3\2\2\2ps\3\2\2")
-        buf.write("\2qo\3\2\2\2qr\3\2\2\2ru\3\2\2\2sq\3\2\2\2tl\3\2\2\2t")
-        buf.write("u\3\2\2\2u\21\3\2\2\2v\u0081\5\20\t\2wx\5\24\13\2xy\7")
-        buf.write("\26\2\2y{\3\2\2\2zw\3\2\2\2{~\3\2\2\2|z\3\2\2\2|}\3\2")
-        buf.write("\2\2}\177\3\2\2\2~|\3\2\2\2\177\u0081\5\62\32\2\u0080")
-        buf.write("v\3\2\2\2\u0080|\3\2\2\2\u0081\23\3\2\2\2\u0082\u0083")
-        buf.write("\b\13\1\2\u0083\u0084\7\27\2\2\u0084\u0085\5\24\13\2\u0085")
-        buf.write("\u0086\7\30\2\2\u0086\u00d1\3\2\2\2\u0087\u0088\7\31\2")
-        buf.write("\2\u0088\u0089\5\24\13\2\u0089\u008a\7\32\2\2\u008a\u00d1")
-        buf.write("\3\2\2\2\u008b\u008c\7\66\2\2\u008c\u00d1\5\24\13\26\u008d")
-        buf.write("\u00d1\5\26\f\2\u008e\u008f\7\27\2\2\u008f\u00d1\7\30")
-        buf.write("\2\2\u0090\u0091\7\27\2\2\u0091\u0092\5\24\13\2\u0092")
-        buf.write("\u0093\7\26\2\2\u0093\u0094\7\30\2\2\u0094\u00d1\3\2\2")
-        buf.write("\2\u0095\u0096\7\27\2\2\u0096\u0099\5\24\13\2\u0097\u0098")
-        buf.write("\7\26\2\2\u0098\u009a\5\24\13\2\u0099\u0097\3\2\2\2\u009a")
-        buf.write("\u009b\3\2\2\2\u009b\u0099\3\2\2\2\u009b\u009c\3\2\2\2")
-        buf.write("\u009c\u009d\3\2\2\2\u009d\u009e\7\30\2\2\u009e\u00d1")
-        buf.write("\3\2\2\2\u009f\u00a8\7\33\2\2\u00a0\u00a5\5\24\13\2\u00a1")
-        buf.write("\u00a2\7\26\2\2\u00a2\u00a4\5\24\13\2\u00a3\u00a1\3\2")
-        buf.write("\2\2\u00a4\u00a7\3\2\2\2\u00a5\u00a3\3\2\2\2\u00a5\u00a6")
-        buf.write("\3\2\2\2\u00a6\u00a9\3\2\2\2\u00a7\u00a5\3\2\2\2\u00a8")
-        buf.write("\u00a0\3\2\2\2\u00a8\u00a9\3\2\2\2\u00a9\u00aa\3\2\2\2")
-        buf.write("\u00aa\u00d1\7\34\2\2\u00ab\u00ac\7\35\2\2\u00ac\u00ad")
-        buf.write("\7\27\2\2\u00ad\u00ae\5\24\13\2\u00ae\u00af\7\30\2\2\u00af")
-        buf.write("\u00b0\5@!\2\u00b0\u00b1\7\36\2\2\u00b1\u00b2\5@!\2\u00b2")
-        buf.write("\u00d1\3\2\2\2\u00b3\u00b4\5 \21\2\u00b4\u00b5\7\27\2")
-        buf.write("\2\u00b5\u00b6\5\24\13\2\u00b6\u00b7\7\30\2\2\u00b7\u00b9")
-        buf.write("\7\31\2\2\u00b8\u00ba\5\36\20\2\u00b9\u00b8\3\2\2\2\u00ba")
-        buf.write("\u00bb\3\2\2\2\u00bb\u00b9\3\2\2\2\u00bb\u00bc\3\2\2\2")
-        buf.write("\u00bc\u00bd\3\2\2\2\u00bd\u00be\7\32\2\2\u00be\u00d1")
-        buf.write("\3\2\2\2\u00bf\u00c0\7\37\2\2\u00c0\u00c1\5\60\31\2\u00c1")
-        buf.write("\u00c2\7 \2\2\u00c2\u00c3\5\24\13\2\u00c3\u00c4\7!\2\2")
-        buf.write("\u00c4\u00c5\5\24\13\t\u00c5\u00d1\3\2\2\2\u00c6\u00c7")
-        buf.write("\5\16\b\2\u00c7\u00c8\7 \2\2\u00c8\u00c9\5\24\13\2\u00c9")
-        buf.write("\u00ca\7!\2\2\u00ca\u00cb\5\24\13\7\u00cb\u00d1\3\2\2")
-        buf.write("\2\u00cc\u00d1\5D#\2\u00cd\u00d1\5B\"\2\u00ce\u00d1\5")
-        buf.write("<\37\2\u00cf\u00d1\7\62\2\2\u00d0\u0082\3\2\2\2\u00d0")
-        buf.write("\u0087\3\2\2\2\u00d0\u008b\3\2\2\2\u00d0\u008d\3\2\2\2")
-        buf.write("\u00d0\u008e\3\2\2\2\u00d0\u0090\3\2\2\2\u00d0\u0095\3")
-        buf.write("\2\2\2\u00d0\u009f\3\2\2\2\u00d0\u00ab\3\2\2\2\u00d0\u00b3")
-        buf.write("\3\2\2\2\u00d0\u00bf\3\2\2\2\u00d0\u00c6\3\2\2\2\u00d0")
-        buf.write("\u00cc\3\2\2\2\u00d0\u00cd\3\2\2\2\u00d0\u00ce\3\2\2\2")
-        buf.write("\u00d0\u00cf\3\2\2\2\u00d1\u00eb\3\2\2\2\u00d2\u00d3\f")
-        buf.write("\25\2\2\u00d3\u00d4\t\4\2\2\u00d4\u00ea\5\24\13\26\u00d5")
-        buf.write("\u00d6\f\24\2\2\u00d6\u00d7\t\5\2\2\u00d7\u00ea\5\24\13")
-        buf.write("\25\u00d8\u00d9\f\23\2\2\u00d9\u00da\t\6\2\2\u00da\u00ea")
-        buf.write("\5\24\13\24\u00db\u00dc\f\22\2\2\u00dc\u00dd\t\7\2\2\u00dd")
-        buf.write("\u00ea\5\24\13\23\u00de\u00df\f\b\2\2\u00df\u00e0\7\"")
-        buf.write("\2\2\u00e0\u00ea\5\24\13\t\u00e1\u00e2\f\27\2\2\u00e2")
-        buf.write("\u00e3\7\27\2\2\u00e3\u00e4\5\22\n\2\u00e4\u00e5\7\30")
-        buf.write("\2\2\u00e5\u00ea\3\2\2\2\u00e6\u00e7\f\n\2\2\u00e7\u00e8")
-        buf.write("\7\22\2\2\u00e8\u00ea\7A\2\2\u00e9\u00d2\3\2\2\2\u00e9")
-        buf.write("\u00d5\3\2\2\2\u00e9\u00d8\3\2\2\2\u00e9\u00db\3\2\2\2")
-        buf.write("\u00e9\u00de\3\2\2\2\u00e9\u00e1\3\2\2\2\u00e9\u00e6\3")
-        buf.write("\2\2\2\u00ea\u00ed\3\2\2\2\u00eb\u00e9\3\2\2\2\u00eb\u00ec")
-        buf.write("\3\2\2\2\u00ec\25\3\2\2\2\u00ed\u00eb\3\2\2\2\u00ee\u00f0")
-        buf.write("\7#\2\2\u00ef\u00f1\58\35\2\u00f0\u00ef\3\2\2\2\u00f0")
-        buf.write("\u00f1\3\2\2\2\u00f1\u00f2\3\2\2\2\u00f2\u00f3\7\27\2")
-        buf.write("\2\u00f3\u00f4\5,\27\2\u00f4\u00f7\7\30\2\2\u00f5\u00f6")
-        buf.write("\7$\2\2\u00f6\u00f8\5\66\34\2\u00f7\u00f5\3\2\2\2\u00f7")
-        buf.write("\u00f8\3\2\2\2\u00f8\u00f9\3\2\2\2\u00f9\u00fa\5@!\2\u00fa")
-        buf.write("\27\3\2\2\2\u00fb\u00fc\7%\2\2\u00fc\u00fe\5\b\5\2\u00fd")
-        buf.write("\u00ff\58\35\2\u00fe\u00fd\3\2\2\2\u00fe\u00ff\3\2\2\2")
-        buf.write("\u00ff\u0100\3\2\2\2\u0100\u0101\7\27\2\2\u0101\u0102")
-        buf.write("\5,\27\2\u0102\u0105\7\30\2\2\u0103\u0104\7$\2\2\u0104")
-        buf.write("\u0106\5\66\34\2\u0105\u0103\3\2\2\2\u0105\u0106\3\2\2")
-        buf.write("\2\u0106\u0107\3\2\2\2\u0107\u0108\5@!\2\u0108\u0115\3")
-        buf.write("\2\2\2\u0109\u010a\7&\2\2\u010a\u010c\5\f\7\2\u010b\u010d")
-        buf.write("\58\35\2\u010c\u010b\3\2\2\2\u010c\u010d\3\2\2\2\u010d")
-        buf.write("\u010e\3\2\2\2\u010e\u0110\7 \2\2\u010f\u0111\5\34\17")
-        buf.write("\2\u0110\u010f\3\2\2\2\u0111\u0112\3\2\2\2\u0112\u0110")
-        buf.write("\3\2\2\2\u0112\u0113\3\2\2\2\u0113\u0115\3\2\2\2\u0114")
-        buf.write("\u00fb\3\2\2\2\u0114\u0109\3\2\2\2\u0115\31\3\2\2\2\u0116")
-        buf.write("\u0117\7>\2\2\u0117\33\3\2\2\2\u0118\u0119\7\'\2\2\u0119")
-        buf.write("\u0125\5\32\16\2\u011a\u011b\7\27\2\2\u011b\u0120\5\66")
-        buf.write("\34\2\u011c\u011d\7\26\2\2\u011d\u011f\5\66\34\2\u011e")
-        buf.write("\u011c\3\2\2\2\u011f\u0122\3\2\2\2\u0120\u011e\3\2\2\2")
-        buf.write("\u0120\u0121\3\2\2\2\u0121\u0123\3\2\2\2\u0122\u0120\3")
-        buf.write("\2\2\2\u0123\u0124\7\30\2\2\u0124\u0126\3\2\2\2\u0125")
-        buf.write("\u011a\3\2\2\2\u0125\u0126\3\2\2\2\u0126\35\3\2\2\2\u0127")
-        buf.write("\u0128\7\'\2\2\u0128\u012a\5\32\16\2\u0129\u012b\5\"\22")
-        buf.write("\2\u012a\u0129\3\2\2\2\u012a\u012b\3\2\2\2\u012b\u012c")
-        buf.write("\3\2\2\2\u012c\u012d\7(\2\2\u012d\u012e\5\24\13\2\u012e")
-        buf.write("\37\3\2\2\2\u012f\u0130\t\b\2\2\u0130!\3\2\2\2\u0131\u0132")
-        buf.write("\7\27\2\2\u0132\u0137\5$\23\2\u0133\u0134\7\26\2\2\u0134")
-        buf.write("\u0136\5$\23\2\u0135\u0133\3\2\2\2\u0136\u0139\3\2\2\2")
-        buf.write("\u0137\u0135\3\2\2\2\u0137\u0138\3\2\2\2\u0138\u013a\3")
-        buf.write("\2\2\2\u0139\u0137\3\2\2\2\u013a\u013b\7\30\2\2\u013b")
-        buf.write("#\3\2\2\2\u013c\u0143\7\25\2\2\u013d\u0140\5\n\6\2\u013e")
-        buf.write("\u013f\7+\2\2\u013f\u0141\5\66\34\2\u0140\u013e\3\2\2")
-        buf.write("\2\u0140\u0141\3\2\2\2\u0141\u0143\3\2\2\2\u0142\u013c")
-        buf.write("\3\2\2\2\u0142\u013d\3\2\2\2\u0143%\3\2\2\2\u0144\u0146")
-        buf.write("\5\32\16\2\u0145\u0147\5(\25\2\u0146\u0145\3\2\2\2\u0146")
-        buf.write("\u0147\3\2\2\2\u0147\'\3\2\2\2\u0148\u0149\7\27\2\2\u0149")
-        buf.write("\u014e\5*\26\2\u014a\u014b\7\26\2\2\u014b\u014d\5*\26")
-        buf.write("\2\u014c\u014a\3\2\2\2\u014d\u0150\3\2\2\2\u014e\u014c")
-        buf.write("\3\2\2\2\u014e\u014f\3\2\2\2\u014f\u0151\3\2\2\2\u0150")
-        buf.write("\u014e\3\2\2\2\u0151\u0152\7\30\2\2\u0152)\3\2\2\2\u0153")
-        buf.write("\u0156\5\n\6\2\u0154\u0156\5\32\16\2\u0155\u0153\3\2\2")
-        buf.write("\2\u0155\u0154\3\2\2\2\u0156+\3\2\2\2\u0157\u0162\5.\30")
-        buf.write("\2\u0158\u0159\5\60\31\2\u0159\u015a\7\26\2\2\u015a\u015c")
-        buf.write("\3\2\2\2\u015b\u0158\3\2\2\2\u015c\u015f\3\2\2\2\u015d")
-        buf.write("\u015b\3\2\2\2\u015d\u015e\3\2\2\2\u015e\u0160\3\2\2\2")
-        buf.write("\u015f\u015d\3\2\2\2\u0160\u0162\5\62\32\2\u0161\u0157")
-        buf.write("\3\2\2\2\u0161\u015d\3\2\2\2\u0162-\3\2\2\2\u0163\u0168")
-        buf.write("\5\60\31\2\u0164\u0165\7\26\2\2\u0165\u0167\5\60\31\2")
-        buf.write("\u0166\u0164\3\2\2\2\u0167\u016a\3\2\2\2\u0168\u0166\3")
-        buf.write("\2\2\2\u0168\u0169\3\2\2\2\u0169\u016c\3\2\2\2\u016a\u0168")
-        buf.write("\3\2\2\2\u016b\u0163\3\2\2\2\u016b\u016c\3\2\2\2\u016c")
-        buf.write("/\3\2\2\2\u016d\u0170\5\n\6\2\u016e\u016f\7+\2\2\u016f")
-        buf.write("\u0171\5\66\34\2\u0170\u016e\3\2\2\2\u0170\u0171\3\2\2")
-        buf.write("\2\u0171\61\3\2\2\2\u0172\u0177\5\64\33\2\u0173\u0174")
-        buf.write("\7\26\2\2\u0174\u0176\5\64\33\2\u0175\u0173\3\2\2\2\u0176")
-        buf.write("\u0179\3\2\2\2\u0177\u0175\3\2\2\2\u0177\u0178\3\2\2\2")
-        buf.write("\u0178\63\3\2\2\2\u0179\u0177\3\2\2\2\u017a\u017b\7?\2")
-        buf.write("\2\u017b\u017c\7 \2\2\u017c\u017d\5\24\13\2\u017d\65\3")
-        buf.write("\2\2\2\u017e\u017f\7\27\2\2\u017f\u01ae\7\30\2\2\u0180")
-        buf.write("\u0181\7\27\2\2\u0181\u0182\5\66\34\2\u0182\u0183\7\26")
-        buf.write("\2\2\u0183\u0184\7\30\2\2\u0184\u01ae\3\2\2\2\u0185\u0186")
-        buf.write("\7\27\2\2\u0186\u0189\5\66\34\2\u0187\u0188\7\26\2\2\u0188")
-        buf.write("\u018a\5\66\34\2\u0189\u0187\3\2\2\2\u018a\u018b\3\2\2")
-        buf.write("\2\u018b\u0189\3\2\2\2\u018b\u018c\3\2\2\2\u018c\u018d")
-        buf.write("\3\2\2\2\u018d\u018e\7\30\2\2\u018e\u01ae\3\2\2\2\u018f")
-        buf.write("\u0190\5\f\7\2\u0190\u0191\58\35\2\u0191\u01ae\3\2\2\2")
-        buf.write("\u0192\u01ae\5\f\7\2\u0193\u0194\7,\2\2\u0194\u0195\7")
-        buf.write("\33\2\2\u0195\u0196\5:\36\2\u0196\u0197\7\26\2\2\u0197")
-        buf.write("\u0198\5\66\34\2\u0198\u0199\7\34\2\2\u0199\u01ae\3\2")
-        buf.write("\2\2\u019a\u019c\7#\2\2\u019b\u019d\58\35\2\u019c\u019b")
-        buf.write("\3\2\2\2\u019c\u019d\3\2\2\2\u019d\u019e\3\2\2\2\u019e")
-        buf.write("\u01a7\7\27\2\2\u019f\u01a4\5\66\34\2\u01a0\u01a1\7\26")
-        buf.write("\2\2\u01a1\u01a3\5\66\34\2\u01a2\u01a0\3\2\2\2\u01a3\u01a6")
-        buf.write("\3\2\2\2\u01a4\u01a2\3\2\2\2\u01a4\u01a5\3\2\2\2\u01a5")
-        buf.write("\u01a8\3\2\2\2\u01a6\u01a4\3\2\2\2\u01a7\u019f\3\2\2\2")
-        buf.write("\u01a7\u01a8\3\2\2\2\u01a8\u01a9\3\2\2\2\u01a9\u01aa\7")
-        buf.write("\30\2\2\u01aa\u01ab\7$\2\2\u01ab\u01ae\5\66\34\2\u01ac")
-        buf.write("\u01ae\7\25\2\2\u01ad\u017e\3\2\2\2\u01ad\u0180\3\2\2")
-        buf.write("\2\u01ad\u0185\3\2\2\2\u01ad\u018f\3\2\2\2\u01ad\u0192")
-        buf.write("\3\2\2\2\u01ad\u0193\3\2\2\2\u01ad\u019a\3\2\2\2\u01ad")
-        buf.write("\u01ac\3\2\2\2\u01ae\67\3\2\2\2\u01af\u01b0\7\33\2\2\u01b0")
-        buf.write("\u01b5\5\f\7\2\u01b1\u01b2\7\26\2\2\u01b2\u01b4\5\f\7")
-        buf.write("\2\u01b3\u01b1\3\2\2\2\u01b4\u01b7\3\2\2\2\u01b5\u01b3")
-        buf.write("\3\2\2\2\u01b5\u01b6\3\2\2\2\u01b6\u01b8\3\2\2\2\u01b7")
-        buf.write("\u01b5\3\2\2\2\u01b8\u01b9\7\34\2\2\u01b99\3\2\2\2\u01ba")
-        buf.write("\u01bb\7\27\2\2\u01bb\u01c8\7\30\2\2\u01bc\u01bd\7\27")
-        buf.write("\2\2\u01bd\u01c0\5> \2\u01be\u01bf\7\26\2\2\u01bf\u01c1")
-        buf.write("\5> \2\u01c0\u01be\3\2\2\2\u01c1\u01c2\3\2\2\2\u01c2\u01c0")
-        buf.write("\3\2\2\2\u01c2\u01c3\3\2\2\2\u01c3\u01c4\3\2\2\2\u01c4")
-        buf.write("\u01c5\7\30\2\2\u01c5\u01c8\3\2\2\2\u01c6\u01c8\5> \2")
-        buf.write("\u01c7\u01ba\3\2\2\2\u01c7\u01bc\3\2\2\2\u01c7\u01c6\3")
-        buf.write("\2\2\2\u01c8;\3\2\2\2\u01c9\u01ca\7-\2\2\u01ca\u01cb\7")
-        buf.write("\33\2\2\u01cb\u01cc\7>\2\2\u01cc\u01cd\7\34\2\2\u01cd")
-        buf.write("\u01ce\7\33\2\2\u01ce\u01cf\7A\2\2\u01cf\u01d0\7\34\2")
-        buf.write("\2\u01d0=\3\2\2\2\u01d1\u01d8\5<\37\2\u01d2\u01d3\7\27")
-        buf.write("\2\2\u01d3\u01d4\5> \2\u01d4\u01d5\7\30\2\2\u01d5\u01d8")
-        buf.write("\3\2\2\2\u01d6\u01d8\7A\2\2\u01d7\u01d1\3\2\2\2\u01d7")
-        buf.write("\u01d2\3\2\2\2\u01d7\u01d6\3\2\2\2\u01d8?\3\2\2\2\u01d9")
-        buf.write("\u01da\7\31\2\2\u01da\u01db\5\24\13\2\u01db\u01dc\7\32")
-        buf.write("\2\2\u01dcA\3\2\2\2\u01dd\u01e1\7@\2\2\u01de\u01e1\7A")
-        buf.write("\2\2\u01df\u01e1\7=\2\2\u01e0\u01dd\3\2\2\2\u01e0\u01de")
-        buf.write("\3\2\2\2\u01e0\u01df\3\2\2\2\u01e1C\3\2\2\2\u01e2\u01e8")
-        buf.write("\5\6\4\2\u01e3\u01e8\5\b\5\2\u01e4\u01e8\5\n\6\2\u01e5")
-        buf.write("\u01e8\5\f\7\2\u01e6\u01e8\5\16\b\2\u01e7\u01e2\3\2\2")
-        buf.write("\2\u01e7\u01e3\3\2\2\2\u01e7\u01e4\3\2\2\2\u01e7\u01e5")
-        buf.write("\3\2\2\2\u01e7\u01e6\3\2\2\2\u01e8E\3\2\2\2\63LPS\\gq")
-        buf.write("t|\u0080\u009b\u00a5\u00a8\u00bb\u00d0\u00e9\u00eb\u00f0")
-        buf.write("\u00f7\u00fe\u0105\u010c\u0112\u0114\u0120\u0125\u012a")
-        buf.write("\u0137\u0140\u0142\u0146\u014e\u0155\u015d\u0161\u0168")
-        buf.write("\u016b\u0170\u0177\u018b\u019c\u01a4\u01a7\u01ad\u01b5")
-        buf.write("\u01c2\u01c7\u01d7\u01e0\u01e7")
+        buf.write("\4\37\t\37\4 \t \4!\t!\3\2\3\2\7\2E\n\2\f\2\16\2H\13\2")
+        buf.write("\3\2\5\2K\n\2\3\2\5\2N\n\2\3\2\3\2\3\3\3\3\3\3\7\3U\n")
+        buf.write("\3\f\3\16\3X\13\3\3\4\3\4\3\4\3\5\3\5\3\5\3\6\3\6\3\6")
+        buf.write("\3\7\3\7\3\7\7\7f\n\7\f\7\16\7i\13\7\5\7k\n\7\3\b\3\b")
+        buf.write("\3\b\3\b\7\bq\n\b\f\b\16\bt\13\b\3\b\5\bw\n\b\3\t\3\t")
+        buf.write("\3\t\3\t\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("\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\6\t\u0090\n\t\r\t\16\t")
+        buf.write("\u0091\3\t\3\t\3\t\3\t\3\t\3\t\7\t\u009a\n\t\f\t\16\t")
+        buf.write("\u009d\13\t\5\t\u009f\n\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t")
+        buf.write("\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\6\t\u00b0\n\t\r\t\16")
+        buf.write("\t\u00b1\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("\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\5\t\u00c7\n\t\3\t\3\t\3")
+        buf.write("\t\3\t\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("\3\t\3\t\3\t\3\t\3\t\3\t\3\t\7\t\u00e0\n\t\f\t\16\t\u00e3")
+        buf.write("\13\t\3\n\3\n\5\n\u00e7\n\n\3\n\3\n\3\n\3\n\3\n\5\n\u00ee")
+        buf.write("\n\n\3\n\3\n\3\13\3\13\3\13\5\13\u00f5\n\13\3\13\3\13")
+        buf.write("\3\13\3\13\3\13\5\13\u00fc\n\13\3\13\3\13\3\13\3\13\3")
+        buf.write("\13\5\13\u0103\n\13\3\13\3\13\6\13\u0107\n\13\r\13\16")
+        buf.write("\13\u0108\5\13\u010b\n\13\3\f\3\f\3\r\3\r\3\r\3\r\3\r")
+        buf.write("\3\r\7\r\u0115\n\r\f\r\16\r\u0118\13\r\3\r\3\r\5\r\u011c")
+        buf.write("\n\r\3\16\3\16\3\16\5\16\u0121\n\16\3\16\3\16\3\16\3\17")
+        buf.write("\3\17\3\20\3\20\3\20\3\20\7\20\u012c\n\20\f\20\16\20\u012f")
+        buf.write("\13\20\3\20\3\20\3\21\3\21\3\21\3\21\5\21\u0137\n\21\5")
+        buf.write("\21\u0139\n\21\3\22\3\22\5\22\u013d\n\22\3\23\3\23\3\23")
+        buf.write("\3\23\7\23\u0143\n\23\f\23\16\23\u0146\13\23\3\23\3\23")
+        buf.write("\3\24\3\24\5\24\u014c\n\24\3\25\3\25\3\25\3\25\7\25\u0152")
+        buf.write("\n\25\f\25\16\25\u0155\13\25\3\25\5\25\u0158\n\25\3\26")
+        buf.write("\3\26\3\26\7\26\u015d\n\26\f\26\16\26\u0160\13\26\5\26")
+        buf.write("\u0162\n\26\3\27\3\27\3\27\5\27\u0167\n\27\3\30\3\30\3")
+        buf.write("\30\7\30\u016c\n\30\f\30\16\30\u016f\13\30\3\31\3\31\3")
+        buf.write("\31\3\31\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32")
+        buf.write("\3\32\3\32\6\32\u0180\n\32\r\32\16\32\u0181\3\32\3\32")
+        buf.write("\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32")
+        buf.write("\3\32\3\32\5\32\u0193\n\32\3\32\3\32\3\32\3\32\7\32\u0199")
+        buf.write("\n\32\f\32\16\32\u019c\13\32\5\32\u019e\n\32\3\32\3\32")
+        buf.write("\3\32\3\32\5\32\u01a4\n\32\3\33\3\33\3\33\3\33\7\33\u01aa")
+        buf.write("\n\33\f\33\16\33\u01ad\13\33\3\33\3\33\3\34\3\34\3\34")
+        buf.write("\3\34\3\34\3\34\6\34\u01b7\n\34\r\34\16\34\u01b8\3\34")
+        buf.write("\3\34\3\34\5\34\u01be\n\34\3\35\3\35\3\35\3\35\3\35\3")
+        buf.write("\35\3\35\3\35\3\36\3\36\3\36\3\36\3\36\3\36\5\36\u01ce")
+        buf.write("\n\36\3\37\3\37\3\37\3\37\3 \3 \3 \5 \u01d7\n \3!\3!\3")
+        buf.write("!\3!\5!\u01dd\n!\3!\2\3\20\"\2\4\6\b\n\f\16\20\22\24\26")
+        buf.write("\30\32\34\36 \"$&(*,.\60\62\64\668:<>@\2\b\4\2\6\6//\3")
+        buf.write("\2$%\3\2&\'\3\2(+\3\2,-\3\2\32\33\2\u020c\2B\3\2\2\2\4")
+        buf.write("Q\3\2\2\2\6Y\3\2\2\2\b\\\3\2\2\2\n_\3\2\2\2\fj\3\2\2\2")
+        buf.write("\16v\3\2\2\2\20\u00c6\3\2\2\2\22\u00e4\3\2\2\2\24\u010a")
+        buf.write("\3\2\2\2\26\u010c\3\2\2\2\30\u010e\3\2\2\2\32\u011d\3")
+        buf.write("\2\2\2\34\u0125\3\2\2\2\36\u0127\3\2\2\2 \u0138\3\2\2")
+        buf.write("\2\"\u013a\3\2\2\2$\u013e\3\2\2\2&\u014b\3\2\2\2(\u0157")
+        buf.write("\3\2\2\2*\u0161\3\2\2\2,\u0163\3\2\2\2.\u0168\3\2\2\2")
+        buf.write("\60\u0170\3\2\2\2\62\u01a3\3\2\2\2\64\u01a5\3\2\2\2\66")
+        buf.write("\u01bd\3\2\2\28\u01bf\3\2\2\2:\u01cd\3\2\2\2<\u01cf\3")
+        buf.write("\2\2\2>\u01d6\3\2\2\2@\u01dc\3\2\2\2BJ\7\37\2\2CE\5\24")
+        buf.write("\13\2DC\3\2\2\2EH\3\2\2\2FD\3\2\2\2FG\3\2\2\2GK\3\2\2")
+        buf.write("\2HF\3\2\2\2IK\5\20\t\2JF\3\2\2\2JI\3\2\2\2KM\3\2\2\2")
+        buf.write("LN\7\62\2\2ML\3\2\2\2MN\3\2\2\2NO\3\2\2\2OP\7\2\2\3P\3")
+        buf.write("\3\2\2\2QV\7/\2\2RS\7\3\2\2SU\7/\2\2TR\3\2\2\2UX\3\2\2")
+        buf.write("\2VT\3\2\2\2VW\3\2\2\2W\5\3\2\2\2XV\3\2\2\2YZ\7\4\2\2")
+        buf.write("Z[\7/\2\2[\7\3\2\2\2\\]\7\5\2\2]^\t\2\2\2^\t\3\2\2\2_")
+        buf.write("`\7\5\2\2`a\7\61\2\2a\13\3\2\2\2bg\5\20\t\2cd\7\7\2\2")
+        buf.write("df\5\20\t\2ec\3\2\2\2fi\3\2\2\2ge\3\2\2\2gh\3\2\2\2hk")
+        buf.write("\3\2\2\2ig\3\2\2\2jb\3\2\2\2jk\3\2\2\2k\r\3\2\2\2lw\5")
+        buf.write("\f\7\2mn\5\20\t\2no\7\7\2\2oq\3\2\2\2pm\3\2\2\2qt\3\2")
+        buf.write("\2\2rp\3\2\2\2rs\3\2\2\2su\3\2\2\2tr\3\2\2\2uw\5.\30\2")
+        buf.write("vl\3\2\2\2vr\3\2\2\2w\17\3\2\2\2xy\b\t\1\2yz\7\b\2\2z")
+        buf.write("{\5\20\t\2{|\7\t\2\2|\u00c7\3\2\2\2}~\7\n\2\2~\177\5\20")
+        buf.write("\t\2\177\u0080\7\13\2\2\u0080\u00c7\3\2\2\2\u0081\u0082")
+        buf.write("\7\'\2\2\u0082\u00c7\5\20\t\26\u0083\u00c7\5\22\n\2\u0084")
+        buf.write("\u0085\7\b\2\2\u0085\u00c7\7\t\2\2\u0086\u0087\7\b\2\2")
+        buf.write("\u0087\u0088\5\20\t\2\u0088\u0089\7\7\2\2\u0089\u008a")
+        buf.write("\7\t\2\2\u008a\u00c7\3\2\2\2\u008b\u008c\7\b\2\2\u008c")
+        buf.write("\u008f\5\20\t\2\u008d\u008e\7\7\2\2\u008e\u0090\5\20\t")
+        buf.write("\2\u008f\u008d\3\2\2\2\u0090\u0091\3\2\2\2\u0091\u008f")
+        buf.write("\3\2\2\2\u0091\u0092\3\2\2\2\u0092\u0093\3\2\2\2\u0093")
+        buf.write("\u0094\7\t\2\2\u0094\u00c7\3\2\2\2\u0095\u009e\7\f\2\2")
+        buf.write("\u0096\u009b\5\20\t\2\u0097\u0098\7\7\2\2\u0098\u009a")
+        buf.write("\5\20\t\2\u0099\u0097\3\2\2\2\u009a\u009d\3\2\2\2\u009b")
+        buf.write("\u0099\3\2\2\2\u009b\u009c\3\2\2\2\u009c\u009f\3\2\2\2")
+        buf.write("\u009d\u009b\3\2\2\2\u009e\u0096\3\2\2\2\u009e\u009f\3")
+        buf.write("\2\2\2\u009f\u00a0\3\2\2\2\u00a0\u00c7\7\r\2\2\u00a1\u00a2")
+        buf.write("\7\16\2\2\u00a2\u00a3\7\b\2\2\u00a3\u00a4\5\20\t\2\u00a4")
+        buf.write("\u00a5\7\t\2\2\u00a5\u00a6\5<\37\2\u00a6\u00a7\7\17\2")
+        buf.write("\2\u00a7\u00a8\5<\37\2\u00a8\u00c7\3\2\2\2\u00a9\u00aa")
+        buf.write("\5\34\17\2\u00aa\u00ab\7\b\2\2\u00ab\u00ac\5\20\t\2\u00ac")
+        buf.write("\u00ad\7\t\2\2\u00ad\u00af\7\n\2\2\u00ae\u00b0\5\32\16")
+        buf.write("\2\u00af\u00ae\3\2\2\2\u00b0\u00b1\3\2\2\2\u00b1\u00af")
+        buf.write("\3\2\2\2\u00b1\u00b2\3\2\2\2\u00b2\u00b3\3\2\2\2\u00b3")
+        buf.write("\u00b4\7\13\2\2\u00b4\u00c7\3\2\2\2\u00b5\u00b6\7\20\2")
+        buf.write("\2\u00b6\u00b7\5,\27\2\u00b7\u00b8\7\21\2\2\u00b8\u00b9")
+        buf.write("\5\20\t\2\u00b9\u00ba\7\22\2\2\u00ba\u00bb\5\20\t\t\u00bb")
+        buf.write("\u00c7\3\2\2\2\u00bc\u00bd\5\n\6\2\u00bd\u00be\7\21\2")
+        buf.write("\2\u00be\u00bf\5\20\t\2\u00bf\u00c0\7\22\2\2\u00c0\u00c1")
+        buf.write("\5\20\t\7\u00c1\u00c7\3\2\2\2\u00c2\u00c7\5@!\2\u00c3")
+        buf.write("\u00c7\5> \2\u00c4\u00c7\58\35\2\u00c5\u00c7\7#\2\2\u00c6")
+        buf.write("x\3\2\2\2\u00c6}\3\2\2\2\u00c6\u0081\3\2\2\2\u00c6\u0083")
+        buf.write("\3\2\2\2\u00c6\u0084\3\2\2\2\u00c6\u0086\3\2\2\2\u00c6")
+        buf.write("\u008b\3\2\2\2\u00c6\u0095\3\2\2\2\u00c6\u00a1\3\2\2\2")
+        buf.write("\u00c6\u00a9\3\2\2\2\u00c6\u00b5\3\2\2\2\u00c6\u00bc\3")
+        buf.write("\2\2\2\u00c6\u00c2\3\2\2\2\u00c6\u00c3\3\2\2\2\u00c6\u00c4")
+        buf.write("\3\2\2\2\u00c6\u00c5\3\2\2\2\u00c7\u00e1\3\2\2\2\u00c8")
+        buf.write("\u00c9\f\25\2\2\u00c9\u00ca\t\3\2\2\u00ca\u00e0\5\20\t")
+        buf.write("\26\u00cb\u00cc\f\24\2\2\u00cc\u00cd\t\4\2\2\u00cd\u00e0")
+        buf.write("\5\20\t\25\u00ce\u00cf\f\23\2\2\u00cf\u00d0\t\5\2\2\u00d0")
+        buf.write("\u00e0\5\20\t\24\u00d1\u00d2\f\22\2\2\u00d2\u00d3\t\6")
+        buf.write("\2\2\u00d3\u00e0\5\20\t\23\u00d4\u00d5\f\b\2\2\u00d5\u00d6")
+        buf.write("\7\23\2\2\u00d6\u00e0\5\20\t\t\u00d7\u00d8\f\27\2\2\u00d8")
+        buf.write("\u00d9\7\b\2\2\u00d9\u00da\5\16\b\2\u00da\u00db\7\t\2")
+        buf.write("\2\u00db\u00e0\3\2\2\2\u00dc\u00dd\f\n\2\2\u00dd\u00de")
+        buf.write("\7\3\2\2\u00de\u00e0\7\61\2\2\u00df\u00c8\3\2\2\2\u00df")
+        buf.write("\u00cb\3\2\2\2\u00df\u00ce\3\2\2\2\u00df\u00d1\3\2\2\2")
+        buf.write("\u00df\u00d4\3\2\2\2\u00df\u00d7\3\2\2\2\u00df\u00dc\3")
+        buf.write("\2\2\2\u00e0\u00e3\3\2\2\2\u00e1\u00df\3\2\2\2\u00e1\u00e2")
+        buf.write("\3\2\2\2\u00e2\21\3\2\2\2\u00e3\u00e1\3\2\2\2\u00e4\u00e6")
+        buf.write("\7\24\2\2\u00e5\u00e7\5\64\33\2\u00e6\u00e5\3\2\2\2\u00e6")
+        buf.write("\u00e7\3\2\2\2\u00e7\u00e8\3\2\2\2\u00e8\u00e9\7\b\2\2")
+        buf.write("\u00e9\u00ea\5(\25\2\u00ea\u00ed\7\t\2\2\u00eb\u00ec\7")
+        buf.write("\25\2\2\u00ec\u00ee\5\62\32\2\u00ed\u00eb\3\2\2\2\u00ed")
+        buf.write("\u00ee\3\2\2\2\u00ee\u00ef\3\2\2\2\u00ef\u00f0\5<\37\2")
+        buf.write("\u00f0\23\3\2\2\2\u00f1\u00f2\7\26\2\2\u00f2\u00f4\5\6")
+        buf.write("\4\2\u00f3\u00f5\5\64\33\2\u00f4\u00f3\3\2\2\2\u00f4\u00f5")
+        buf.write("\3\2\2\2\u00f5\u00f6\3\2\2\2\u00f6\u00f7\7\b\2\2\u00f7")
+        buf.write("\u00f8\5(\25\2\u00f8\u00fb\7\t\2\2\u00f9\u00fa\7\25\2")
+        buf.write("\2\u00fa\u00fc\5\62\32\2\u00fb\u00f9\3\2\2\2\u00fb\u00fc")
+        buf.write("\3\2\2\2\u00fc\u00fd\3\2\2\2\u00fd\u00fe\5<\37\2\u00fe")
+        buf.write("\u010b\3\2\2\2\u00ff\u0100\7\27\2\2\u0100\u0102\5\4\3")
+        buf.write("\2\u0101\u0103\5\64\33\2\u0102\u0101\3\2\2\2\u0102\u0103")
+        buf.write("\3\2\2\2\u0103\u0104\3\2\2\2\u0104\u0106\7\21\2\2\u0105")
+        buf.write("\u0107\5\30\r\2\u0106\u0105\3\2\2\2\u0107\u0108\3\2\2")
+        buf.write("\2\u0108\u0106\3\2\2\2\u0108\u0109\3\2\2\2\u0109\u010b")
+        buf.write("\3\2\2\2\u010a\u00f1\3\2\2\2\u010a\u00ff\3\2\2\2\u010b")
+        buf.write("\25\3\2\2\2\u010c\u010d\7/\2\2\u010d\27\3\2\2\2\u010e")
+        buf.write("\u010f\7\30\2\2\u010f\u011b\5\26\f\2\u0110\u0111\7\b\2")
+        buf.write("\2\u0111\u0116\5\62\32\2\u0112\u0113\7\7\2\2\u0113\u0115")
+        buf.write("\5\62\32\2\u0114\u0112\3\2\2\2\u0115\u0118\3\2\2\2\u0116")
+        buf.write("\u0114\3\2\2\2\u0116\u0117\3\2\2\2\u0117\u0119\3\2\2\2")
+        buf.write("\u0118\u0116\3\2\2\2\u0119\u011a\7\t\2\2\u011a\u011c\3")
+        buf.write("\2\2\2\u011b\u0110\3\2\2\2\u011b\u011c\3\2\2\2\u011c\31")
+        buf.write("\3\2\2\2\u011d\u011e\7\30\2\2\u011e\u0120\5\26\f\2\u011f")
+        buf.write("\u0121\5\36\20\2\u0120\u011f\3\2\2\2\u0120\u0121\3\2\2")
+        buf.write("\2\u0121\u0122\3\2\2\2\u0122\u0123\7\31\2\2\u0123\u0124")
+        buf.write("\5\20\t\2\u0124\33\3\2\2\2\u0125\u0126\t\7\2\2\u0126\35")
+        buf.write("\3\2\2\2\u0127\u0128\7\b\2\2\u0128\u012d\5 \21\2\u0129")
+        buf.write("\u012a\7\7\2\2\u012a\u012c\5 \21\2\u012b\u0129\3\2\2\2")
+        buf.write("\u012c\u012f\3\2\2\2\u012d\u012b\3\2\2\2\u012d\u012e\3")
+        buf.write("\2\2\2\u012e\u0130\3\2\2\2\u012f\u012d\3\2\2\2\u0130\u0131")
+        buf.write("\7\t\2\2\u0131\37\3\2\2\2\u0132\u0139\7\6\2\2\u0133\u0136")
+        buf.write("\5\b\5\2\u0134\u0135\7\34\2\2\u0135\u0137\5\62\32\2\u0136")
+        buf.write("\u0134\3\2\2\2\u0136\u0137\3\2\2\2\u0137\u0139\3\2\2\2")
+        buf.write("\u0138\u0132\3\2\2\2\u0138\u0133\3\2\2\2\u0139!\3\2\2")
+        buf.write("\2\u013a\u013c\5\26\f\2\u013b\u013d\5$\23\2\u013c\u013b")
+        buf.write("\3\2\2\2\u013c\u013d\3\2\2\2\u013d#\3\2\2\2\u013e\u013f")
+        buf.write("\7\b\2\2\u013f\u0144\5&\24\2\u0140\u0141\7\7\2\2\u0141")
+        buf.write("\u0143\5&\24\2\u0142\u0140\3\2\2\2\u0143\u0146\3\2\2\2")
+        buf.write("\u0144\u0142\3\2\2\2\u0144\u0145\3\2\2\2\u0145\u0147\3")
+        buf.write("\2\2\2\u0146\u0144\3\2\2\2\u0147\u0148\7\t\2\2\u0148%")
+        buf.write("\3\2\2\2\u0149\u014c\5\b\5\2\u014a\u014c\5\26\f\2\u014b")
+        buf.write("\u0149\3\2\2\2\u014b\u014a\3\2\2\2\u014c\'\3\2\2\2\u014d")
+        buf.write("\u0158\5*\26\2\u014e\u014f\5,\27\2\u014f\u0150\7\7\2\2")
+        buf.write("\u0150\u0152\3\2\2\2\u0151\u014e\3\2\2\2\u0152\u0155\3")
+        buf.write("\2\2\2\u0153\u0151\3\2\2\2\u0153\u0154\3\2\2\2\u0154\u0156")
+        buf.write("\3\2\2\2\u0155\u0153\3\2\2\2\u0156\u0158\5.\30\2\u0157")
+        buf.write("\u014d\3\2\2\2\u0157\u0153\3\2\2\2\u0158)\3\2\2\2\u0159")
+        buf.write("\u015e\5,\27\2\u015a\u015b\7\7\2\2\u015b\u015d\5,\27\2")
+        buf.write("\u015c\u015a\3\2\2\2\u015d\u0160\3\2\2\2\u015e\u015c\3")
+        buf.write("\2\2\2\u015e\u015f\3\2\2\2\u015f\u0162\3\2\2\2\u0160\u015e")
+        buf.write("\3\2\2\2\u0161\u0159\3\2\2\2\u0161\u0162\3\2\2\2\u0162")
+        buf.write("+\3\2\2\2\u0163\u0166\5\b\5\2\u0164\u0165\7\34\2\2\u0165")
+        buf.write("\u0167\5\62\32\2\u0166\u0164\3\2\2\2\u0166\u0167\3\2\2")
+        buf.write("\2\u0167-\3\2\2\2\u0168\u016d\5\60\31\2\u0169\u016a\7")
+        buf.write("\7\2\2\u016a\u016c\5\60\31\2\u016b\u0169\3\2\2\2\u016c")
+        buf.write("\u016f\3\2\2\2\u016d\u016b\3\2\2\2\u016d\u016e\3\2\2\2")
+        buf.write("\u016e/\3\2\2\2\u016f\u016d\3\2\2\2\u0170\u0171\7/\2\2")
+        buf.write("\u0171\u0172\7\21\2\2\u0172\u0173\5\20\t\2\u0173\61\3")
+        buf.write("\2\2\2\u0174\u0175\7\b\2\2\u0175\u01a4\7\t\2\2\u0176\u0177")
+        buf.write("\7\b\2\2\u0177\u0178\5\62\32\2\u0178\u0179\7\7\2\2\u0179")
+        buf.write("\u017a\7\t\2\2\u017a\u01a4\3\2\2\2\u017b\u017c\7\b\2\2")
+        buf.write("\u017c\u017f\5\62\32\2\u017d\u017e\7\7\2\2\u017e\u0180")
+        buf.write("\5\62\32\2\u017f\u017d\3\2\2\2\u0180\u0181\3\2\2\2\u0181")
+        buf.write("\u017f\3\2\2\2\u0181\u0182\3\2\2\2\u0182\u0183\3\2\2\2")
+        buf.write("\u0183\u0184\7\t\2\2\u0184\u01a4\3\2\2\2\u0185\u0186\5")
+        buf.write("\4\3\2\u0186\u0187\5\64\33\2\u0187\u01a4\3\2\2\2\u0188")
+        buf.write("\u01a4\5\4\3\2\u0189\u018a\7\35\2\2\u018a\u018b\7\f\2")
+        buf.write("\2\u018b\u018c\5\66\34\2\u018c\u018d\7\7\2\2\u018d\u018e")
+        buf.write("\5\62\32\2\u018e\u018f\7\r\2\2\u018f\u01a4\3\2\2\2\u0190")
+        buf.write("\u0192\7\24\2\2\u0191\u0193\5\64\33\2\u0192\u0191\3\2")
+        buf.write("\2\2\u0192\u0193\3\2\2\2\u0193\u0194\3\2\2\2\u0194\u019d")
+        buf.write("\7\b\2\2\u0195\u019a\5\62\32\2\u0196\u0197\7\7\2\2\u0197")
+        buf.write("\u0199\5\62\32\2\u0198\u0196\3\2\2\2\u0199\u019c\3\2\2")
+        buf.write("\2\u019a\u0198\3\2\2\2\u019a\u019b\3\2\2\2\u019b\u019e")
+        buf.write("\3\2\2\2\u019c\u019a\3\2\2\2\u019d\u0195\3\2\2\2\u019d")
+        buf.write("\u019e\3\2\2\2\u019e\u019f\3\2\2\2\u019f\u01a0\7\t\2\2")
+        buf.write("\u01a0\u01a1\7\25\2\2\u01a1\u01a4\5\62\32\2\u01a2\u01a4")
+        buf.write("\7\6\2\2\u01a3\u0174\3\2\2\2\u01a3\u0176\3\2\2\2\u01a3")
+        buf.write("\u017b\3\2\2\2\u01a3\u0185\3\2\2\2\u01a3\u0188\3\2\2\2")
+        buf.write("\u01a3\u0189\3\2\2\2\u01a3\u0190\3\2\2\2\u01a3\u01a2\3")
+        buf.write("\2\2\2\u01a4\63\3\2\2\2\u01a5\u01a6\7\f\2\2\u01a6\u01ab")
+        buf.write("\5\4\3\2\u01a7\u01a8\7\7\2\2\u01a8\u01aa\5\4\3\2\u01a9")
+        buf.write("\u01a7\3\2\2\2\u01aa\u01ad\3\2\2\2\u01ab\u01a9\3\2\2\2")
+        buf.write("\u01ab\u01ac\3\2\2\2\u01ac\u01ae\3\2\2\2\u01ad\u01ab\3")
+        buf.write("\2\2\2\u01ae\u01af\7\r\2\2\u01af\65\3\2\2\2\u01b0\u01b1")
+        buf.write("\7\b\2\2\u01b1\u01be\7\t\2\2\u01b2\u01b3\7\b\2\2\u01b3")
+        buf.write("\u01b6\5:\36\2\u01b4\u01b5\7\7\2\2\u01b5\u01b7\5:\36\2")
+        buf.write("\u01b6\u01b4\3\2\2\2\u01b7\u01b8\3\2\2\2\u01b8\u01b6\3")
+        buf.write("\2\2\2\u01b8\u01b9\3\2\2\2\u01b9\u01ba\3\2\2\2\u01ba\u01bb")
+        buf.write("\7\t\2\2\u01bb\u01be\3\2\2\2\u01bc\u01be\5:\36\2\u01bd")
+        buf.write("\u01b0\3\2\2\2\u01bd\u01b2\3\2\2\2\u01bd\u01bc\3\2\2\2")
+        buf.write("\u01be\67\3\2\2\2\u01bf\u01c0\7\36\2\2\u01c0\u01c1\7\f")
+        buf.write("\2\2\u01c1\u01c2\7/\2\2\u01c2\u01c3\7\r\2\2\u01c3\u01c4")
+        buf.write("\7\f\2\2\u01c4\u01c5\7\61\2\2\u01c5\u01c6\7\r\2\2\u01c6")
+        buf.write("9\3\2\2\2\u01c7\u01ce\58\35\2\u01c8\u01c9\7\b\2\2\u01c9")
+        buf.write("\u01ca\5:\36\2\u01ca\u01cb\7\t\2\2\u01cb\u01ce\3\2\2\2")
+        buf.write("\u01cc\u01ce\7\61\2\2\u01cd\u01c7\3\2\2\2\u01cd\u01c8")
+        buf.write("\3\2\2\2\u01cd\u01cc\3\2\2\2\u01ce;\3\2\2\2\u01cf\u01d0")
+        buf.write("\7\n\2\2\u01d0\u01d1\5\20\t\2\u01d1\u01d2\7\13\2\2\u01d2")
+        buf.write("=\3\2\2\2\u01d3\u01d7\7\60\2\2\u01d4\u01d7\7\61\2\2\u01d5")
+        buf.write("\u01d7\7.\2\2\u01d6\u01d3\3\2\2\2\u01d6\u01d4\3\2\2\2")
+        buf.write("\u01d6\u01d5\3\2\2\2\u01d7?\3\2\2\2\u01d8\u01dd\5\4\3")
+        buf.write("\2\u01d9\u01dd\5\6\4\2\u01da\u01dd\5\b\5\2\u01db\u01dd")
+        buf.write("\5\n\6\2\u01dc\u01d8\3\2\2\2\u01dc\u01d9\3\2\2\2\u01dc")
+        buf.write("\u01da\3\2\2\2\u01dc\u01db\3\2\2\2\u01ddA\3\2\2\2\62F")
+        buf.write("JMVgjrv\u0091\u009b\u009e\u00b1\u00c6\u00df\u00e1\u00e6")
+        buf.write("\u00ed\u00f4\u00fb\u0102\u0108\u010a\u0116\u011b\u0120")
+        buf.write("\u012d\u0136\u0138\u013c\u0144\u014b\u0153\u0157\u015e")
+        buf.write("\u0161\u0166\u016d\u0181\u0192\u019a\u019d\u01a3\u01ab")
+        buf.write("\u01b8\u01bd\u01cd\u01d6\u01dc")
         return buf.getvalue()
 
 
@@ -260,10 +252,7 @@ class RelayParser ( Parser ):
 
     sharedContextCache = PredictionContextCache()
 
-    literalNames = [ "<INVALID>", "'int8'", "'int16'", "'int32'", "'int64'", 
-                     "'uint8'", "'uint16'", "'uint32'", "'uint64'", "'float16'", 
-                     "'float32'", "'float64'", "'bool'", "'int8x4'", "'uint1x4'", 
-                     "'float16x4'", "'.'", "'@'", "'%'", "'_'", "','", "'('", 
+    literalNames = [ "<INVALID>", "'.'", "'@'", "'%'", "'_'", "','", "'('", 
                      "')'", "'{'", "'}'", "'['", "']'", "'if'", "'else'", 
                      "'let'", "'='", "';'", "';;'", "'fn'", "'->'", "'def'", 
                      "'type'", "'|'", "'=>'", "'match'", "'match?'", "':'", 
@@ -278,57 +267,51 @@ class RelayParser ( Parser ):
                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
-                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
-                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
-                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
-                      "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
-                      "SEMVER", "COMMENT", "WS", "LINE_COMMENT", "QUOTED_STRING", 
-                      "MUL", "DIV", "ADD", "SUB", "LT", "GT", "LE", "GE", 
-                      "EQ", "NE", "BOOL_LIT", "START_UPPER_CNAME", "START_LOWER_CNAME", 
+                      "<INVALID>", "SEMVER", "COMMENT", "WS", "LINE_COMMENT", 
+                      "QUOTED_STRING", "MUL", "DIV", "ADD", "SUB", "LT", 
+                      "GT", "LE", "GE", "EQ", "NE", "BOOL_LIT", "CNAME", 
                       "FLOAT", "NAT", "METADATA" ]
 
-    RULE_baseType = 0
-    RULE_prog = 1
-    RULE_opIdent = 2
-    RULE_globalVar = 3
-    RULE_localVar = 4
-    RULE_typeIdent = 5
-    RULE_graphVar = 6
-    RULE_exprList = 7
-    RULE_callList = 8
-    RULE_expr = 9
-    RULE_func = 10
-    RULE_defn = 11
-    RULE_constructorName = 12
-    RULE_adtConsDefn = 13
-    RULE_matchClause = 14
-    RULE_matchType = 15
-    RULE_patternList = 16
-    RULE_pattern = 17
-    RULE_adtCons = 18
-    RULE_adtConsParamList = 19
-    RULE_adtConsParam = 20
-    RULE_argList = 21
-    RULE_varList = 22
-    RULE_var = 23
-    RULE_attrSeq = 24
-    RULE_attr = 25
-    RULE_typeExpr = 26
-    RULE_typeParamList = 27
-    RULE_shapeList = 28
-    RULE_meta = 29
-    RULE_shape = 30
-    RULE_body = 31
-    RULE_scalar = 32
-    RULE_ident = 33
-
-    ruleNames =  [ "baseType", "prog", "opIdent", "globalVar", "localVar", 
-                   "typeIdent", "graphVar", "exprList", "callList", "expr", 
-                   "func", "defn", "constructorName", "adtConsDefn", "matchClause", 
-                   "matchType", "patternList", "pattern", "adtCons", "adtConsParamList", 
-                   "adtConsParam", "argList", "varList", "var", "attrSeq", 
-                   "attr", "typeExpr", "typeParamList", "shapeList", "meta", 
-                   "shape", "body", "scalar", "ident" ]
+    RULE_prog = 0
+    RULE_generalIdent = 1
+    RULE_globalVar = 2
+    RULE_localVar = 3
+    RULE_graphVar = 4
+    RULE_exprList = 5
+    RULE_callList = 6
+    RULE_expr = 7
+    RULE_func = 8
+    RULE_defn = 9
+    RULE_constructorName = 10
+    RULE_adtConsDefn = 11
+    RULE_matchClause = 12
+    RULE_matchType = 13
+    RULE_patternList = 14
+    RULE_pattern = 15
+    RULE_adtCons = 16
+    RULE_adtConsParamList = 17
+    RULE_adtConsParam = 18
+    RULE_argList = 19
+    RULE_varList = 20
+    RULE_var = 21
+    RULE_attrSeq = 22
+    RULE_attr = 23
+    RULE_typeExpr = 24
+    RULE_typeParamList = 25
+    RULE_shapeList = 26
+    RULE_meta = 27
+    RULE_shape = 28
+    RULE_body = 29
+    RULE_scalar = 30
+    RULE_ident = 31
+
+    ruleNames =  [ "prog", "generalIdent", "globalVar", "localVar", "graphVar", 
+                   "exprList", "callList", "expr", "func", "defn", "constructorName", 
+                   "adtConsDefn", "matchClause", "matchType", "patternList", 
+                   "pattern", "adtCons", "adtConsParamList", "adtConsParam", 
+                   "argList", "varList", "var", "attrSeq", "attr", "typeExpr", 
+                   "typeParamList", "shapeList", "meta", "shape", "body", 
+                   "scalar", "ident" ]
 
     EOF = Token.EOF
     T__0=1
@@ -359,42 +342,26 @@ class RelayParser ( Parser ):
     T__25=26
     T__26=27
     T__27=28
-    T__28=29
-    T__29=30
-    T__30=31
-    T__31=32
-    T__32=33
-    T__33=34
-    T__34=35
-    T__35=36
-    T__36=37
-    T__37=38
-    T__38=39
-    T__39=40
-    T__40=41
-    T__41=42
-    T__42=43
-    SEMVER=44
-    COMMENT=45
-    WS=46
-    LINE_COMMENT=47
-    QUOTED_STRING=48
-    MUL=49
-    DIV=50
-    ADD=51
-    SUB=52
-    LT=53
-    GT=54
-    LE=55
-    GE=56
-    EQ=57
-    NE=58
-    BOOL_LIT=59
-    START_UPPER_CNAME=60
-    START_LOWER_CNAME=61
-    FLOAT=62
-    NAT=63
-    METADATA=64
+    SEMVER=29
+    COMMENT=30
+    WS=31
+    LINE_COMMENT=32
+    QUOTED_STRING=33
+    MUL=34
+    DIV=35
+    ADD=36
+    SUB=37
+    LT=38
+    GT=39
+    LE=40
+    GE=41
+    EQ=42
+    NE=43
+    BOOL_LIT=44
+    CNAME=45
+    FLOAT=46
+    NAT=47
+    METADATA=48
 
     def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
         super().__init__(input, output)
@@ -405,48 +372,6 @@ def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
 
 
 
-    class BaseTypeContext(ParserRuleContext):
-
-        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
-            super().__init__(parent, invokingState)
-            self.parser = parser
-
-
-        def getRuleIndex(self):
-            return RelayParser.RULE_baseType
-
-        def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitBaseType" ):
-                return visitor.visitBaseType(self)
-            else:
-                return visitor.visitChildren(self)
-
-
-
-
-    def baseType(self):
-
-        localctx = RelayParser.BaseTypeContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 0, self.RULE_baseType)
-        self._la = 0 # Token type
-        try:
-            self.enterOuterAlt(localctx, 1)
-            self.state = 68
-            _la = self._input.LA(1)
-            if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__0) | (1 << RelayParser.T__1) | (1 << RelayParser.T__2) | (1 << RelayParser.T__3) | (1 << RelayParser.T__4) | (1 << RelayParser.T__5) | (1 << RelayParser.T__6) | (1 << RelayParser.T__7) | (1 << RelayParser.T__8) | (1 << RelayParser.T__9) | (1 << RelayParser.T__10) | (1 << RelayParser.T__11) | (1 << RelayParser.T__12) | (1 << RelayParser.T__13) | (1 << RelayParser.T__14))) != 0)):
-                self._errHandler.recoverInline(self)
-            else:
-                self._errHandler.reportMatch(self)
-                self.consume()
-        except RecognitionException as re:
-            localctx.exception = re
-            self._errHandler.reportError(self, re)
-            self._errHandler.recover(self, re)
-        finally:
-            self.exitRule()
-        return localctx
-
-
     class ProgContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
@@ -488,43 +413,43 @@ def accept(self, visitor:ParseTreeVisitor):
     def prog(self):
 
         localctx = RelayParser.ProgContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 2, self.RULE_prog)
+        self.enterRule(localctx, 0, self.RULE_prog)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 70
+            self.state = 64
             self.match(RelayParser.SEMVER)
-            self.state = 78
+            self.state = 72
             self._errHandler.sync(self)
             token = self._input.LA(1)
-            if token in [RelayParser.EOF, RelayParser.T__34, RelayParser.T__35, RelayParser.METADATA]:
-                self.state = 74
+            if token in [RelayParser.EOF, RelayParser.T__19, RelayParser.T__20, RelayParser.METADATA]:
+                self.state = 68
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                while _la==RelayParser.T__34 or _la==RelayParser.T__35:
-                    self.state = 71
+                while _la==RelayParser.T__19 or _la==RelayParser.T__20:
+                    self.state = 65
                     self.defn()
-                    self.state = 76
+                    self.state = 70
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
                 pass
-            elif token in [RelayParser.T__0, RelayParser.T__1, RelayParser.T__2, RelayParser.T__3, RelayParser.T__4, RelayParser.T__5, RelayParser.T__6, RelayParser.T__7, RelayParser.T__8, RelayParser.T__9, RelayParser.T__10, RelayParser.T__11, RelayParser.T__12, RelayParser.T__13, RelayParser.T__14, RelayParser.T__16, RelayParser.T__17, RelayParser.T__20, RelayParser.T__22, RelayParser.T__24, RelayParser.T__26, RelayParser.T__28, RelayParser.T__32, RelayParser.T__38, RelayParser.T__39, RelayParser.T__42, RelayParser.QUOTED_STRING, RelayParser.SUB, RelayParser.BOOL_LIT, RelayParser.START_UPPER_CNAME, RelayParser.START_LOWER_CNAME, RelayParser.FLOAT, RelayParser.NAT]:
-                self.state = 77
+            elif token in [RelayParser.T__1, RelayParser.T__2, RelayParser.T__5, RelayParser.T__7, RelayParser.T__9, RelayParser.T__11, RelayParser.T__13, RelayParser.T__17, RelayParser.T__23, RelayParser.T__24, RelayParser.T__27, RelayParser.QUOTED_STRING, RelayParser.SUB, RelayParser.BOOL_LIT, RelayParser.CNAME, RelayParser.FLOAT, RelayParser.NAT]:
+                self.state = 71
                 self.expr(0)
                 pass
             else:
                 raise NoViableAltException(self)
 
-            self.state = 81
+            self.state = 75
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==RelayParser.METADATA:
-                self.state = 80
+                self.state = 74
                 self.match(RelayParser.METADATA)
 
 
-            self.state = 83
+            self.state = 77
             self.match(RelayParser.EOF)
         except RecognitionException as re:
             localctx.exception = re
@@ -535,48 +460,48 @@ def prog(self):
         return localctx
 
 
-    class OpIdentContext(ParserRuleContext):
+    class GeneralIdentContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
             super().__init__(parent, invokingState)
             self.parser = parser
 
-        def START_LOWER_CNAME(self, i:int=None):
+        def CNAME(self, i:int=None):
             if i is None:
-                return self.getTokens(RelayParser.START_LOWER_CNAME)
+                return self.getTokens(RelayParser.CNAME)
             else:
-                return self.getToken(RelayParser.START_LOWER_CNAME, i)
+                return self.getToken(RelayParser.CNAME, i)
 
         def getRuleIndex(self):
-            return RelayParser.RULE_opIdent
+            return RelayParser.RULE_generalIdent
 
         def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitOpIdent" ):
-                return visitor.visitOpIdent(self)
+            if hasattr( visitor, "visitGeneralIdent" ):
+                return visitor.visitGeneralIdent(self)
             else:
                 return visitor.visitChildren(self)
 
 
 
 
-    def opIdent(self):
+    def generalIdent(self):
 
-        localctx = RelayParser.OpIdentContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 4, self.RULE_opIdent)
+        localctx = RelayParser.GeneralIdentContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 2, self.RULE_generalIdent)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 85
-            self.match(RelayParser.START_LOWER_CNAME)
-            self.state = 90
+            self.state = 79
+            self.match(RelayParser.CNAME)
+            self.state = 84
             self._errHandler.sync(self)
             _alt = self._interp.adaptivePredict(self._input,3,self._ctx)
             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                 if _alt==1:
-                    self.state = 86
-                    self.match(RelayParser.T__15)
-                    self.state = 87
-                    self.match(RelayParser.START_LOWER_CNAME) 
-                self.state = 92
+                    self.state = 80
+                    self.match(RelayParser.T__0)
+                    self.state = 81
+                    self.match(RelayParser.CNAME) 
+                self.state = 86
                 self._errHandler.sync(self)
                 _alt = self._interp.adaptivePredict(self._input,3,self._ctx)
 
@@ -595,8 +520,8 @@ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
             super().__init__(parent, invokingState)
             self.parser = parser
 
-        def START_LOWER_CNAME(self):
-            return self.getToken(RelayParser.START_LOWER_CNAME, 0)
+        def CNAME(self):
+            return self.getToken(RelayParser.CNAME, 0)
 
         def getRuleIndex(self):
             return RelayParser.RULE_globalVar
@@ -613,13 +538,13 @@ def accept(self, visitor:ParseTreeVisitor):
     def globalVar(self):
 
         localctx = RelayParser.GlobalVarContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 6, self.RULE_globalVar)
+        self.enterRule(localctx, 4, self.RULE_globalVar)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 93
-            self.match(RelayParser.T__16)
-            self.state = 94
-            self.match(RelayParser.START_LOWER_CNAME)
+            self.state = 87
+            self.match(RelayParser.T__1)
+            self.state = 88
+            self.match(RelayParser.CNAME)
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -635,8 +560,8 @@ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
             super().__init__(parent, invokingState)
             self.parser = parser
 
-        def START_LOWER_CNAME(self):
-            return self.getToken(RelayParser.START_LOWER_CNAME, 0)
+        def CNAME(self):
+            return self.getToken(RelayParser.CNAME, 0)
 
         def getRuleIndex(self):
             return RelayParser.RULE_localVar
@@ -653,15 +578,15 @@ def accept(self, visitor:ParseTreeVisitor):
     def localVar(self):
 
         localctx = RelayParser.LocalVarContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 8, self.RULE_localVar)
+        self.enterRule(localctx, 6, self.RULE_localVar)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 96
-            self.match(RelayParser.T__17)
-            self.state = 97
+            self.state = 90
+            self.match(RelayParser.T__2)
+            self.state = 91
             _la = self._input.LA(1)
-            if not(_la==RelayParser.T__18 or _la==RelayParser.START_LOWER_CNAME):
+            if not(_la==RelayParser.T__3 or _la==RelayParser.CNAME):
                 self._errHandler.recoverInline(self)
             else:
                 self._errHandler.reportMatch(self)
@@ -675,60 +600,6 @@ def localVar(self):
         return localctx
 
 
-    class TypeIdentContext(ParserRuleContext):
-
-        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
-            super().__init__(parent, invokingState)
-            self.parser = parser
-
-        def baseType(self):
-            return self.getTypedRuleContext(RelayParser.BaseTypeContext,0)
-
-
-        def START_UPPER_CNAME(self):
-            return self.getToken(RelayParser.START_UPPER_CNAME, 0)
-
-        def getRuleIndex(self):
-            return RelayParser.RULE_typeIdent
-
-        def accept(self, visitor:ParseTreeVisitor):
-            if hasattr( visitor, "visitTypeIdent" ):
-                return visitor.visitTypeIdent(self)
-            else:
-                return visitor.visitChildren(self)
-
-
-
-
-    def typeIdent(self):
-
-        localctx = RelayParser.TypeIdentContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 10, self.RULE_typeIdent)
-        try:
-            self.enterOuterAlt(localctx, 1)
-            self.state = 101
-            self._errHandler.sync(self)
-            token = self._input.LA(1)
-            if token in [RelayParser.T__0, RelayParser.T__1, RelayParser.T__2, RelayParser.T__3, RelayParser.T__4, RelayParser.T__5, RelayParser.T__6, RelayParser.T__7, RelayParser.T__8, RelayParser.T__9, RelayParser.T__10, RelayParser.T__11, RelayParser.T__12, RelayParser.T__13, RelayParser.T__14]:
-                self.state = 99
-                self.baseType()
-                pass
-            elif token in [RelayParser.START_UPPER_CNAME]:
-                self.state = 100
-                self.match(RelayParser.START_UPPER_CNAME)
-                pass
-            else:
-                raise NoViableAltException(self)
-
-        except RecognitionException as re:
-            localctx.exception = re
-            self._errHandler.reportError(self, re)
-            self._errHandler.recover(self, re)
-        finally:
-            self.exitRule()
-        return localctx
-
-
     class GraphVarContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
@@ -753,12 +624,12 @@ def accept(self, visitor:ParseTreeVisitor):
     def graphVar(self):
 
         localctx = RelayParser.GraphVarContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 12, self.RULE_graphVar)
+        self.enterRule(localctx, 8, self.RULE_graphVar)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 103
-            self.match(RelayParser.T__17)
-            self.state = 104
+            self.state = 93
+            self.match(RelayParser.T__2)
+            self.state = 94
             self.match(RelayParser.NAT)
         except RecognitionException as re:
             localctx.exception = re
@@ -797,25 +668,25 @@ def accept(self, visitor:ParseTreeVisitor):
     def exprList(self):
 
         localctx = RelayParser.ExprListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 14, self.RULE_exprList)
+        self.enterRule(localctx, 10, self.RULE_exprList)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 114
+            self.state = 104
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__0) | (1 << RelayParser.T__1) | (1 << RelayParser.T__2) | (1 << RelayParser.T__3) | (1 << RelayParser.T__4) | (1 << RelayParser.T__5) | (1 << RelayParser.T__6) | (1 << RelayParser.T__7) | (1 << RelayParser.T__8) | (1 << RelayParser.T__9) | (1 << RelayParser.T__10) | (1 << RelayParser.T__11) | (1 << RelayParser.T__12) | (1 << RelayParser.T__13) | (1 << RelayParser.T__14) | (1 << RelayParser.T__16) | (1 << RelayParser.T__17) | (1 << RelayParser.T__20) | (1 << RelayParser.T__22) | (1 << RelayParser.T__24) | (1 << RelayParser.T__26) | (1 << RelayParser.T__28) | (1 << RelayParser.T__32) | (1 << RelayParser.T__38) | (1 << RelayParser.T__39) | (1 << RelayParser.T__42) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.START_UPPER_CNAME) | (1 << RelayParser.START_LOWER_CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
-                self.state = 106
+            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__1) | (1 << RelayParser.T__2) | (1 << RelayParser.T__5) | (1 << RelayParser.T__7) | (1 << RelayParser.T__9) | (1 << RelayParser.T__11) | (1 << RelayParser.T__13) | (1 << RelayParser.T__17) | (1 << RelayParser.T__23) | (1 << RelayParser.T__24) | (1 << RelayParser.T__27) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
+                self.state = 96
                 self.expr(0)
-                self.state = 111
+                self.state = 101
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                while _la==RelayParser.T__19:
-                    self.state = 107
-                    self.match(RelayParser.T__19)
-                    self.state = 108
+                while _la==RelayParser.T__4:
+                    self.state = 97
+                    self.match(RelayParser.T__4)
+                    self.state = 98
                     self.expr(0)
-                    self.state = 113
+                    self.state = 103
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
@@ -890,35 +761,35 @@ def accept(self, visitor:ParseTreeVisitor):
     def callList(self):
 
         localctx = RelayParser.CallListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 16, self.RULE_callList)
+        self.enterRule(localctx, 12, self.RULE_callList)
         try:
-            self.state = 126
+            self.state = 116
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,8,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,7,self._ctx)
             if la_ == 1:
                 localctx = RelayParser.CallNoAttrContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 116
+                self.state = 106
                 self.exprList()
                 pass
 
             elif la_ == 2:
                 localctx = RelayParser.CallWithAttrContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 122
+                self.state = 112
                 self._errHandler.sync(self)
-                _alt = self._interp.adaptivePredict(self._input,7,self._ctx)
+                _alt = self._interp.adaptivePredict(self._input,6,self._ctx)
                 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                     if _alt==1:
-                        self.state = 117
+                        self.state = 107
                         self.expr(0)
-                        self.state = 118
-                        self.match(RelayParser.T__19) 
-                    self.state = 124
+                        self.state = 108
+                        self.match(RelayParser.T__4) 
+                    self.state = 114
                     self._errHandler.sync(self)
-                    _alt = self._interp.adaptivePredict(self._input,7,self._ctx)
+                    _alt = self._interp.adaptivePredict(self._input,6,self._ctx)
 
-                self.state = 125
+                self.state = 115
                 self.attrSeq()
                 pass
 
@@ -1288,46 +1159,46 @@ def expr(self, _p:int=0):
         _parentState = self.state
         localctx = RelayParser.ExprContext(self, self._ctx, _parentState)
         _prevctx = localctx
-        _startState = 18
-        self.enterRecursionRule(localctx, 18, self.RULE_expr, _p)
+        _startState = 14
+        self.enterRecursionRule(localctx, 14, self.RULE_expr, _p)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 206
+            self.state = 196
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,13,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,12,self._ctx)
             if la_ == 1:
                 localctx = RelayParser.ParenContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
 
-                self.state = 129
-                self.match(RelayParser.T__20)
-                self.state = 130
+                self.state = 119
+                self.match(RelayParser.T__5)
+                self.state = 120
                 self.expr(0)
-                self.state = 131
-                self.match(RelayParser.T__21)
+                self.state = 121
+                self.match(RelayParser.T__6)
                 pass
 
             elif la_ == 2:
                 localctx = RelayParser.ParenContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 133
-                self.match(RelayParser.T__22)
-                self.state = 134
+                self.state = 123
+                self.match(RelayParser.T__7)
+                self.state = 124
                 self.expr(0)
-                self.state = 135
-                self.match(RelayParser.T__23)
+                self.state = 125
+                self.match(RelayParser.T__8)
                 pass
 
             elif la_ == 3:
                 localctx = RelayParser.NegContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 137
+                self.state = 127
                 self.match(RelayParser.SUB)
-                self.state = 138
+                self.state = 128
                 self.expr(20)
                 pass
 
@@ -1335,7 +1206,7 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.FuncExprContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 139
+                self.state = 129
                 self.func()
                 pass
 
@@ -1343,99 +1214,99 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.TupleContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 140
-                self.match(RelayParser.T__20)
-                self.state = 141
-                self.match(RelayParser.T__21)
+                self.state = 130
+                self.match(RelayParser.T__5)
+                self.state = 131
+                self.match(RelayParser.T__6)
                 pass
 
             elif la_ == 6:
                 localctx = RelayParser.TupleContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 142
-                self.match(RelayParser.T__20)
-                self.state = 143
+                self.state = 132
+                self.match(RelayParser.T__5)
+                self.state = 133
                 self.expr(0)
-                self.state = 144
-                self.match(RelayParser.T__19)
-                self.state = 145
-                self.match(RelayParser.T__21)
+                self.state = 134
+                self.match(RelayParser.T__4)
+                self.state = 135
+                self.match(RelayParser.T__6)
                 pass
 
             elif la_ == 7:
                 localctx = RelayParser.TupleContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 147
-                self.match(RelayParser.T__20)
-                self.state = 148
+                self.state = 137
+                self.match(RelayParser.T__5)
+                self.state = 138
                 self.expr(0)
-                self.state = 151 
+                self.state = 141 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while True:
-                    self.state = 149
-                    self.match(RelayParser.T__19)
-                    self.state = 150
+                    self.state = 139
+                    self.match(RelayParser.T__4)
+                    self.state = 140
                     self.expr(0)
-                    self.state = 153 
+                    self.state = 143 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
-                    if not (_la==RelayParser.T__19):
+                    if not (_la==RelayParser.T__4):
                         break
 
-                self.state = 155
-                self.match(RelayParser.T__21)
+                self.state = 145
+                self.match(RelayParser.T__6)
                 pass
 
             elif la_ == 8:
                 localctx = RelayParser.TensorContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 157
-                self.match(RelayParser.T__24)
-                self.state = 166
+                self.state = 147
+                self.match(RelayParser.T__9)
+                self.state = 156
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__0) | (1 << RelayParser.T__1) | (1 << RelayParser.T__2) | (1 << RelayParser.T__3) | (1 << RelayParser.T__4) | (1 << RelayParser.T__5) | (1 << RelayParser.T__6) | (1 << RelayParser.T__7) | (1 << RelayParser.T__8) | (1 << RelayParser.T__9) | (1 << RelayParser.T__10) | (1 << RelayParser.T__11) | (1 << RelayParser.T__12) | (1 << RelayParser.T__13) | (1 << RelayParser.T__14) | (1 << RelayParser.T__16) | (1 << RelayParser.T__17) | (1 << RelayParser.T__20) | (1 << RelayParser.T__22) | (1 << RelayParser.T__24) | (1 << RelayParser.T__26) | (1 << RelayParser.T__28) | (1 << RelayParser.T__32) | (1 << RelayParser.T__38) | (1 << RelayParser.T__39) | (1 << RelayParser.T__42) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.START_UPPER_CNAME) | (1 << RelayParser.START_LOWER_CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
-                    self.state = 158
+                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__1) | (1 << RelayParser.T__2) | (1 << RelayParser.T__5) | (1 << RelayParser.T__7) | (1 << RelayParser.T__9) | (1 << RelayParser.T__11) | (1 << RelayParser.T__13) | (1 << RelayParser.T__17) | (1 << RelayParser.T__23) | (1 << RelayParser.T__24) | (1 << RelayParser.T__27) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
+                    self.state = 148
                     self.expr(0)
-                    self.state = 163
+                    self.state = 153
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
-                    while _la==RelayParser.T__19:
-                        self.state = 159
-                        self.match(RelayParser.T__19)
-                        self.state = 160
+                    while _la==RelayParser.T__4:
+                        self.state = 149
+                        self.match(RelayParser.T__4)
+                        self.state = 150
                         self.expr(0)
-                        self.state = 165
+                        self.state = 155
                         self._errHandler.sync(self)
                         _la = self._input.LA(1)
 
 
 
-                self.state = 168
-                self.match(RelayParser.T__25)
+                self.state = 158
+                self.match(RelayParser.T__10)
                 pass
 
             elif la_ == 9:
                 localctx = RelayParser.IfElseContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 169
-                self.match(RelayParser.T__26)
-                self.state = 170
-                self.match(RelayParser.T__20)
-                self.state = 171
+                self.state = 159
+                self.match(RelayParser.T__11)
+                self.state = 160
+                self.match(RelayParser.T__5)
+                self.state = 161
                 self.expr(0)
-                self.state = 172
-                self.match(RelayParser.T__21)
-                self.state = 173
+                self.state = 162
+                self.match(RelayParser.T__6)
+                self.state = 163
                 self.body()
-                self.state = 174
-                self.match(RelayParser.T__27)
-                self.state = 175
+                self.state = 164
+                self.match(RelayParser.T__12)
+                self.state = 165
                 self.body()
                 pass
 
@@ -1443,47 +1314,47 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.MatchContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 177
+                self.state = 167
                 self.matchType()
-                self.state = 178
-                self.match(RelayParser.T__20)
-                self.state = 179
+                self.state = 168
+                self.match(RelayParser.T__5)
+                self.state = 169
                 self.expr(0)
-                self.state = 180
-                self.match(RelayParser.T__21)
-                self.state = 181
-                self.match(RelayParser.T__22)
-                self.state = 183 
+                self.state = 170
+                self.match(RelayParser.T__6)
+                self.state = 171
+                self.match(RelayParser.T__7)
+                self.state = 173 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while True:
-                    self.state = 182
+                    self.state = 172
                     self.matchClause()
-                    self.state = 185 
+                    self.state = 175 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
-                    if not (_la==RelayParser.T__36):
+                    if not (_la==RelayParser.T__21):
                         break
 
-                self.state = 187
-                self.match(RelayParser.T__23)
+                self.state = 177
+                self.match(RelayParser.T__8)
                 pass
 
             elif la_ == 11:
                 localctx = RelayParser.LetContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 189
-                self.match(RelayParser.T__28)
-                self.state = 190
+                self.state = 179
+                self.match(RelayParser.T__13)
+                self.state = 180
                 self.var()
-                self.state = 191
-                self.match(RelayParser.T__29)
-                self.state = 192
+                self.state = 181
+                self.match(RelayParser.T__14)
+                self.state = 182
                 self.expr(0)
-                self.state = 193
-                self.match(RelayParser.T__30)
-                self.state = 194
+                self.state = 183
+                self.match(RelayParser.T__15)
+                self.state = 184
                 self.expr(7)
                 pass
 
@@ -1491,15 +1362,15 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.GraphContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 196
+                self.state = 186
                 self.graphVar()
-                self.state = 197
-                self.match(RelayParser.T__29)
-                self.state = 198
+                self.state = 187
+                self.match(RelayParser.T__14)
+                self.state = 188
                 self.expr(0)
-                self.state = 199
-                self.match(RelayParser.T__30)
-                self.state = 200
+                self.state = 189
+                self.match(RelayParser.T__15)
+                self.state = 190
                 self.expr(5)
                 pass
 
@@ -1507,7 +1378,7 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.IdentExprContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 202
+                self.state = 192
                 self.ident()
                 pass
 
@@ -1515,7 +1386,7 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.ScalarExprContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 203
+                self.state = 193
                 self.scalar()
                 pass
 
@@ -1523,7 +1394,7 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.MetaExprContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 204
+                self.state = 194
                 self.meta()
                 pass
 
@@ -1531,31 +1402,31 @@ def expr(self, _p:int=0):
                 localctx = RelayParser.StringExprContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 205
+                self.state = 195
                 self.match(RelayParser.QUOTED_STRING)
                 pass
 
 
             self._ctx.stop = self._input.LT(-1)
-            self.state = 233
+            self.state = 223
             self._errHandler.sync(self)
-            _alt = self._interp.adaptivePredict(self._input,15,self._ctx)
+            _alt = self._interp.adaptivePredict(self._input,14,self._ctx)
             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                 if _alt==1:
                     if self._parseListeners is not None:
                         self.triggerExitRuleEvent()
                     _prevctx = localctx
-                    self.state = 231
+                    self.state = 221
                     self._errHandler.sync(self)
-                    la_ = self._interp.adaptivePredict(self._input,14,self._ctx)
+                    la_ = self._interp.adaptivePredict(self._input,13,self._ctx)
                     if la_ == 1:
                         localctx = RelayParser.BinOpContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 208
+                        self.state = 198
                         if not self.precpred(self._ctx, 19):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 19)")
-                        self.state = 209
+                        self.state = 199
                         localctx.op = self._input.LT(1)
                         _la = self._input.LA(1)
                         if not(_la==RelayParser.MUL or _la==RelayParser.DIV):
@@ -1563,18 +1434,18 @@ def expr(self, _p:int=0):
                         else:
                             self._errHandler.reportMatch(self)
                             self.consume()
-                        self.state = 210
+                        self.state = 200
                         self.expr(20)
                         pass
 
                     elif la_ == 2:
                         localctx = RelayParser.BinOpContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 211
+                        self.state = 201
                         if not self.precpred(self._ctx, 18):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 18)")
-                        self.state = 212
+                        self.state = 202
                         localctx.op = self._input.LT(1)
                         _la = self._input.LA(1)
                         if not(_la==RelayParser.ADD or _la==RelayParser.SUB):
@@ -1582,18 +1453,18 @@ def expr(self, _p:int=0):
                         else:
                             self._errHandler.reportMatch(self)
                             self.consume()
-                        self.state = 213
+                        self.state = 203
                         self.expr(19)
                         pass
 
                     elif la_ == 3:
                         localctx = RelayParser.BinOpContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 214
+                        self.state = 204
                         if not self.precpred(self._ctx, 17):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 17)")
-                        self.state = 215
+                        self.state = 205
                         localctx.op = self._input.LT(1)
                         _la = self._input.LA(1)
                         if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.LT) | (1 << RelayParser.GT) | (1 << RelayParser.LE) | (1 << RelayParser.GE))) != 0)):
@@ -1601,18 +1472,18 @@ def expr(self, _p:int=0):
                         else:
                             self._errHandler.reportMatch(self)
                             self.consume()
-                        self.state = 216
+                        self.state = 206
                         self.expr(18)
                         pass
 
                     elif la_ == 4:
                         localctx = RelayParser.BinOpContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 217
+                        self.state = 207
                         if not self.precpred(self._ctx, 16):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 16)")
-                        self.state = 218
+                        self.state = 208
                         localctx.op = self._input.LT(1)
                         _la = self._input.LA(1)
                         if not(_la==RelayParser.EQ or _la==RelayParser.NE):
@@ -1620,55 +1491,55 @@ def expr(self, _p:int=0):
                         else:
                             self._errHandler.reportMatch(self)
                             self.consume()
-                        self.state = 219
+                        self.state = 209
                         self.expr(17)
                         pass
 
                     elif la_ == 5:
                         localctx = RelayParser.LetContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 220
+                        self.state = 210
                         if not self.precpred(self._ctx, 6):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
-                        self.state = 221
-                        self.match(RelayParser.T__31)
-                        self.state = 222
+                        self.state = 211
+                        self.match(RelayParser.T__16)
+                        self.state = 212
                         self.expr(7)
                         pass
 
                     elif la_ == 6:
                         localctx = RelayParser.CallContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 223
+                        self.state = 213
                         if not self.precpred(self._ctx, 21):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 21)")
-                        self.state = 224
-                        self.match(RelayParser.T__20)
-                        self.state = 225
+                        self.state = 214
+                        self.match(RelayParser.T__5)
+                        self.state = 215
                         self.callList()
-                        self.state = 226
-                        self.match(RelayParser.T__21)
+                        self.state = 216
+                        self.match(RelayParser.T__6)
                         pass
 
                     elif la_ == 7:
                         localctx = RelayParser.ProjectionContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 228
+                        self.state = 218
                         if not self.precpred(self._ctx, 8):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
-                        self.state = 229
-                        self.match(RelayParser.T__15)
-                        self.state = 230
+                        self.state = 219
+                        self.match(RelayParser.T__0)
+                        self.state = 220
                         self.match(RelayParser.NAT)
                         pass
 
              
-                self.state = 235
+                self.state = 225
                 self._errHandler.sync(self)
-                _alt = self._interp.adaptivePredict(self._input,15,self._ctx)
+                _alt = self._interp.adaptivePredict(self._input,14,self._ctx)
 
         except RecognitionException as re:
             localctx.exception = re
@@ -1716,37 +1587,37 @@ def accept(self, visitor:ParseTreeVisitor):
     def func(self):
 
         localctx = RelayParser.FuncContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 20, self.RULE_func)
+        self.enterRule(localctx, 16, self.RULE_func)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 236
-            self.match(RelayParser.T__32)
-            self.state = 238
+            self.state = 226
+            self.match(RelayParser.T__17)
+            self.state = 228
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==RelayParser.T__24:
-                self.state = 237
+            if _la==RelayParser.T__9:
+                self.state = 227
                 self.typeParamList()
 
 
-            self.state = 240
-            self.match(RelayParser.T__20)
-            self.state = 241
+            self.state = 230
+            self.match(RelayParser.T__5)
+            self.state = 231
             self.argList()
-            self.state = 242
-            self.match(RelayParser.T__21)
-            self.state = 245
+            self.state = 232
+            self.match(RelayParser.T__6)
+            self.state = 235
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==RelayParser.T__33:
-                self.state = 243
-                self.match(RelayParser.T__33)
-                self.state = 244
+            if _la==RelayParser.T__18:
+                self.state = 233
+                self.match(RelayParser.T__18)
+                self.state = 234
                 self.typeExpr()
 
 
-            self.state = 247
+            self.state = 237
             self.body()
         except RecognitionException as re:
             localctx.exception = re
@@ -1808,8 +1679,8 @@ def __init__(self, parser, ctx:ParserRuleContext): # actually a RelayParser.Defn
             super().__init__(parser)
             self.copyFrom(ctx)
 
-        def typeIdent(self):
-            return self.getTypedRuleContext(RelayParser.TypeIdentContext,0)
+        def generalIdent(self):
+            return self.getTypedRuleContext(RelayParser.GeneralIdentContext,0)
 
         def typeParamList(self):
             return self.getTypedRuleContext(RelayParser.TypeParamListContext,0)
@@ -1832,73 +1703,73 @@ def accept(self, visitor:ParseTreeVisitor):
     def defn(self):
 
         localctx = RelayParser.DefnContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 22, self.RULE_defn)
+        self.enterRule(localctx, 18, self.RULE_defn)
         self._la = 0 # Token type
         try:
-            self.state = 274
+            self.state = 264
             self._errHandler.sync(self)
             token = self._input.LA(1)
-            if token in [RelayParser.T__34]:
+            if token in [RelayParser.T__19]:
                 localctx = RelayParser.FuncDefnContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 249
-                self.match(RelayParser.T__34)
-                self.state = 250
+                self.state = 239
+                self.match(RelayParser.T__19)
+                self.state = 240
                 self.globalVar()
-                self.state = 252
+                self.state = 242
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if _la==RelayParser.T__24:
-                    self.state = 251
+                if _la==RelayParser.T__9:
+                    self.state = 241
                     self.typeParamList()
 
 
-                self.state = 254
-                self.match(RelayParser.T__20)
-                self.state = 255
+                self.state = 244
+                self.match(RelayParser.T__5)
+                self.state = 245
                 self.argList()
-                self.state = 256
-                self.match(RelayParser.T__21)
-                self.state = 259
+                self.state = 246
+                self.match(RelayParser.T__6)
+                self.state = 249
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if _la==RelayParser.T__33:
-                    self.state = 257
-                    self.match(RelayParser.T__33)
-                    self.state = 258
+                if _la==RelayParser.T__18:
+                    self.state = 247
+                    self.match(RelayParser.T__18)
+                    self.state = 248
                     self.typeExpr()
 
 
-                self.state = 261
+                self.state = 251
                 self.body()
                 pass
-            elif token in [RelayParser.T__35]:
+            elif token in [RelayParser.T__20]:
                 localctx = RelayParser.AdtDefnContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 263
-                self.match(RelayParser.T__35)
-                self.state = 264
-                self.typeIdent()
-                self.state = 266
+                self.state = 253
+                self.match(RelayParser.T__20)
+                self.state = 254
+                self.generalIdent()
+                self.state = 256
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if _la==RelayParser.T__24:
-                    self.state = 265
+                if _la==RelayParser.T__9:
+                    self.state = 255
                     self.typeParamList()
 
 
-                self.state = 268
-                self.match(RelayParser.T__29)
-                self.state = 270 
+                self.state = 258
+                self.match(RelayParser.T__14)
+                self.state = 260 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while True:
-                    self.state = 269
+                    self.state = 259
                     self.adtConsDefn()
-                    self.state = 272 
+                    self.state = 262 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
-                    if not (_la==RelayParser.T__36):
+                    if not (_la==RelayParser.T__21):
                         break
 
                 pass
@@ -1920,8 +1791,8 @@ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
             super().__init__(parent, invokingState)
             self.parser = parser
 
-        def START_UPPER_CNAME(self):
-            return self.getToken(RelayParser.START_UPPER_CNAME, 0)
+        def CNAME(self):
+            return self.getToken(RelayParser.CNAME, 0)
 
         def getRuleIndex(self):
             return RelayParser.RULE_constructorName
@@ -1938,11 +1809,11 @@ def accept(self, visitor:ParseTreeVisitor):
     def constructorName(self):
 
         localctx = RelayParser.ConstructorNameContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 24, self.RULE_constructorName)
+        self.enterRule(localctx, 20, self.RULE_constructorName)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 276
-            self.match(RelayParser.START_UPPER_CNAME)
+            self.state = 266
+            self.match(RelayParser.CNAME)
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -1984,36 +1855,36 @@ def accept(self, visitor:ParseTreeVisitor):
     def adtConsDefn(self):
 
         localctx = RelayParser.AdtConsDefnContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 26, self.RULE_adtConsDefn)
+        self.enterRule(localctx, 22, self.RULE_adtConsDefn)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 278
-            self.match(RelayParser.T__36)
-            self.state = 279
+            self.state = 268
+            self.match(RelayParser.T__21)
+            self.state = 269
             self.constructorName()
-            self.state = 291
+            self.state = 281
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==RelayParser.T__20:
-                self.state = 280
-                self.match(RelayParser.T__20)
-                self.state = 281
+            if _la==RelayParser.T__5:
+                self.state = 270
+                self.match(RelayParser.T__5)
+                self.state = 271
                 self.typeExpr()
-                self.state = 286
+                self.state = 276
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                while _la==RelayParser.T__19:
-                    self.state = 282
-                    self.match(RelayParser.T__19)
-                    self.state = 283
+                while _la==RelayParser.T__4:
+                    self.state = 272
+                    self.match(RelayParser.T__4)
+                    self.state = 273
                     self.typeExpr()
-                    self.state = 288
+                    self.state = 278
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
-                self.state = 289
-                self.match(RelayParser.T__21)
+                self.state = 279
+                self.match(RelayParser.T__6)
 
 
         except RecognitionException as re:
@@ -2058,25 +1929,25 @@ def accept(self, visitor:ParseTreeVisitor):
     def matchClause(self):
 
         localctx = RelayParser.MatchClauseContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 28, self.RULE_matchClause)
+        self.enterRule(localctx, 24, self.RULE_matchClause)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 293
-            self.match(RelayParser.T__36)
-            self.state = 294
+            self.state = 283
+            self.match(RelayParser.T__21)
+            self.state = 284
             self.constructorName()
-            self.state = 296
+            self.state = 286
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==RelayParser.T__20:
-                self.state = 295
+            if _la==RelayParser.T__5:
+                self.state = 285
                 self.patternList()
 
 
-            self.state = 298
-            self.match(RelayParser.T__37)
-            self.state = 299
+            self.state = 288
+            self.match(RelayParser.T__22)
+            self.state = 289
             self.expr(0)
         except RecognitionException as re:
             localctx.exception = re
@@ -2109,13 +1980,13 @@ def accept(self, visitor:ParseTreeVisitor):
     def matchType(self):
 
         localctx = RelayParser.MatchTypeContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 30, self.RULE_matchType)
+        self.enterRule(localctx, 26, self.RULE_matchType)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 301
+            self.state = 291
             _la = self._input.LA(1)
-            if not(_la==RelayParser.T__38 or _la==RelayParser.T__39):
+            if not(_la==RelayParser.T__23 or _la==RelayParser.T__24):
                 self._errHandler.recoverInline(self)
             else:
                 self._errHandler.reportMatch(self)
@@ -2157,28 +2028,28 @@ def accept(self, visitor:ParseTreeVisitor):
     def patternList(self):
 
         localctx = RelayParser.PatternListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 32, self.RULE_patternList)
+        self.enterRule(localctx, 28, self.RULE_patternList)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 303
-            self.match(RelayParser.T__20)
-            self.state = 304
+            self.state = 293
+            self.match(RelayParser.T__5)
+            self.state = 294
             self.pattern()
-            self.state = 309
+            self.state = 299
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            while _la==RelayParser.T__19:
-                self.state = 305
-                self.match(RelayParser.T__19)
-                self.state = 306
+            while _la==RelayParser.T__4:
+                self.state = 295
+                self.match(RelayParser.T__4)
+                self.state = 296
                 self.pattern()
-                self.state = 311
+                self.state = 301
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 312
-            self.match(RelayParser.T__21)
+            self.state = 302
+            self.match(RelayParser.T__6)
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -2217,28 +2088,28 @@ def accept(self, visitor:ParseTreeVisitor):
     def pattern(self):
 
         localctx = RelayParser.PatternContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 34, self.RULE_pattern)
+        self.enterRule(localctx, 30, self.RULE_pattern)
         self._la = 0 # Token type
         try:
-            self.state = 320
+            self.state = 310
             self._errHandler.sync(self)
             token = self._input.LA(1)
-            if token in [RelayParser.T__18]:
+            if token in [RelayParser.T__3]:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 314
-                self.match(RelayParser.T__18)
+                self.state = 304
+                self.match(RelayParser.T__3)
                 pass
-            elif token in [RelayParser.T__17]:
+            elif token in [RelayParser.T__2]:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 315
+                self.state = 305
                 self.localVar()
-                self.state = 318
+                self.state = 308
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if _la==RelayParser.T__40:
-                    self.state = 316
-                    self.match(RelayParser.T__40)
-                    self.state = 317
+                if _la==RelayParser.T__25:
+                    self.state = 306
+                    self.match(RelayParser.T__25)
+                    self.state = 307
                     self.typeExpr()
 
 
@@ -2284,17 +2155,17 @@ def accept(self, visitor:ParseTreeVisitor):
     def adtCons(self):
 
         localctx = RelayParser.AdtConsContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 36, self.RULE_adtCons)
+        self.enterRule(localctx, 32, self.RULE_adtCons)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 322
+            self.state = 312
             self.constructorName()
-            self.state = 324
+            self.state = 314
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==RelayParser.T__20:
-                self.state = 323
+            if _la==RelayParser.T__5:
+                self.state = 313
                 self.adtConsParamList()
 
 
@@ -2335,28 +2206,28 @@ def accept(self, visitor:ParseTreeVisitor):
     def adtConsParamList(self):
 
         localctx = RelayParser.AdtConsParamListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 38, self.RULE_adtConsParamList)
+        self.enterRule(localctx, 34, self.RULE_adtConsParamList)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 326
-            self.match(RelayParser.T__20)
-            self.state = 327
+            self.state = 316
+            self.match(RelayParser.T__5)
+            self.state = 317
             self.adtConsParam()
-            self.state = 332
+            self.state = 322
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            while _la==RelayParser.T__19:
-                self.state = 328
-                self.match(RelayParser.T__19)
-                self.state = 329
+            while _la==RelayParser.T__4:
+                self.state = 318
+                self.match(RelayParser.T__4)
+                self.state = 319
                 self.adtConsParam()
-                self.state = 334
+                self.state = 324
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 335
-            self.match(RelayParser.T__21)
+            self.state = 325
+            self.match(RelayParser.T__6)
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -2395,19 +2266,19 @@ def accept(self, visitor:ParseTreeVisitor):
     def adtConsParam(self):
 
         localctx = RelayParser.AdtConsParamContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 40, self.RULE_adtConsParam)
+        self.enterRule(localctx, 36, self.RULE_adtConsParam)
         try:
-            self.state = 339
+            self.state = 329
             self._errHandler.sync(self)
             token = self._input.LA(1)
-            if token in [RelayParser.T__17]:
+            if token in [RelayParser.T__2]:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 337
+                self.state = 327
                 self.localVar()
                 pass
-            elif token in [RelayParser.START_UPPER_CNAME]:
+            elif token in [RelayParser.CNAME]:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 338
+                self.state = 328
                 self.constructorName()
                 pass
             else:
@@ -2482,35 +2353,35 @@ def accept(self, visitor:ParseTreeVisitor):
     def argList(self):
 
         localctx = RelayParser.ArgListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 42, self.RULE_argList)
+        self.enterRule(localctx, 38, self.RULE_argList)
         self._la = 0 # Token type
         try:
-            self.state = 351
+            self.state = 341
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,33,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,32,self._ctx)
             if la_ == 1:
                 localctx = RelayParser.ArgNoAttrContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 341
+                self.state = 331
                 self.varList()
                 pass
 
             elif la_ == 2:
                 localctx = RelayParser.ArgWithAttrContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 347
+                self.state = 337
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                while _la==RelayParser.T__17:
-                    self.state = 342
+                while _la==RelayParser.T__2:
+                    self.state = 332
                     self.var()
-                    self.state = 343
-                    self.match(RelayParser.T__19)
-                    self.state = 349
+                    self.state = 333
+                    self.match(RelayParser.T__4)
+                    self.state = 339
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
-                self.state = 350
+                self.state = 340
                 self.attrSeq()
                 pass
 
@@ -2552,25 +2423,25 @@ def accept(self, visitor:ParseTreeVisitor):
     def varList(self):
 
         localctx = RelayParser.VarListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 44, self.RULE_varList)
+        self.enterRule(localctx, 40, self.RULE_varList)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 361
+            self.state = 351
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==RelayParser.T__17:
-                self.state = 353
+            if _la==RelayParser.T__2:
+                self.state = 343
                 self.var()
-                self.state = 358
+                self.state = 348
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                while _la==RelayParser.T__19:
-                    self.state = 354
-                    self.match(RelayParser.T__19)
-                    self.state = 355
+                while _la==RelayParser.T__4:
+                    self.state = 344
+                    self.match(RelayParser.T__4)
+                    self.state = 345
                     self.var()
-                    self.state = 360
+                    self.state = 350
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
@@ -2614,19 +2485,19 @@ def accept(self, visitor:ParseTreeVisitor):
     def var(self):
 
         localctx = RelayParser.VarContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 46, self.RULE_var)
+        self.enterRule(localctx, 42, self.RULE_var)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 363
+            self.state = 353
             self.localVar()
-            self.state = 366
+            self.state = 356
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==RelayParser.T__40:
-                self.state = 364
-                self.match(RelayParser.T__40)
-                self.state = 365
+            if _la==RelayParser.T__25:
+                self.state = 354
+                self.match(RelayParser.T__25)
+                self.state = 355
                 self.typeExpr()
 
 
@@ -2667,21 +2538,21 @@ def accept(self, visitor:ParseTreeVisitor):
     def attrSeq(self):
 
         localctx = RelayParser.AttrSeqContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 48, self.RULE_attrSeq)
+        self.enterRule(localctx, 44, self.RULE_attrSeq)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 368
+            self.state = 358
             self.attr()
-            self.state = 373
+            self.state = 363
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            while _la==RelayParser.T__19:
-                self.state = 369
-                self.match(RelayParser.T__19)
-                self.state = 370
+            while _la==RelayParser.T__4:
+                self.state = 359
+                self.match(RelayParser.T__4)
+                self.state = 360
                 self.attr()
-                self.state = 375
+                self.state = 365
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
@@ -2700,8 +2571,8 @@ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
             super().__init__(parent, invokingState)
             self.parser = parser
 
-        def START_LOWER_CNAME(self):
-            return self.getToken(RelayParser.START_LOWER_CNAME, 0)
+        def CNAME(self):
+            return self.getToken(RelayParser.CNAME, 0)
 
         def expr(self):
             return self.getTypedRuleContext(RelayParser.ExprContext,0)
@@ -2722,14 +2593,14 @@ def accept(self, visitor:ParseTreeVisitor):
     def attr(self):
 
         localctx = RelayParser.AttrContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 50, self.RULE_attr)
+        self.enterRule(localctx, 46, self.RULE_attr)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 376
-            self.match(RelayParser.START_LOWER_CNAME)
-            self.state = 377
-            self.match(RelayParser.T__29)
-            self.state = 378
+            self.state = 366
+            self.match(RelayParser.CNAME)
+            self.state = 367
+            self.match(RelayParser.T__14)
+            self.state = 368
             self.expr(0)
         except RecognitionException as re:
             localctx.exception = re
@@ -2782,8 +2653,8 @@ def __init__(self, parser, ctx:ParserRuleContext): # actually a RelayParser.Type
             super().__init__(parser)
             self.copyFrom(ctx)
 
-        def typeIdent(self):
-            return self.getTypedRuleContext(RelayParser.TypeIdentContext,0)
+        def generalIdent(self):
+            return self.getTypedRuleContext(RelayParser.GeneralIdentContext,0)
 
         def typeParamList(self):
             return self.getTypedRuleContext(RelayParser.TypeParamListContext,0)
@@ -2802,8 +2673,8 @@ def __init__(self, parser, ctx:ParserRuleContext): # actually a RelayParser.Type
             super().__init__(parser)
             self.copyFrom(ctx)
 
-        def typeIdent(self):
-            return self.getTypedRuleContext(RelayParser.TypeIdentContext,0)
+        def generalIdent(self):
+            return self.getTypedRuleContext(RelayParser.GeneralIdentContext,0)
 
 
         def accept(self, visitor:ParseTreeVisitor):
@@ -2874,140 +2745,140 @@ def accept(self, visitor:ParseTreeVisitor):
     def typeExpr(self):
 
         localctx = RelayParser.TypeExprContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 52, self.RULE_typeExpr)
+        self.enterRule(localctx, 48, self.RULE_typeExpr)
         self._la = 0 # Token type
         try:
-            self.state = 427
+            self.state = 417
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,42,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,41,self._ctx)
             if la_ == 1:
                 localctx = RelayParser.TupleTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 380
-                self.match(RelayParser.T__20)
-                self.state = 381
-                self.match(RelayParser.T__21)
+                self.state = 370
+                self.match(RelayParser.T__5)
+                self.state = 371
+                self.match(RelayParser.T__6)
                 pass
 
             elif la_ == 2:
                 localctx = RelayParser.TupleTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 382
-                self.match(RelayParser.T__20)
-                self.state = 383
+                self.state = 372
+                self.match(RelayParser.T__5)
+                self.state = 373
                 self.typeExpr()
-                self.state = 384
-                self.match(RelayParser.T__19)
-                self.state = 385
-                self.match(RelayParser.T__21)
+                self.state = 374
+                self.match(RelayParser.T__4)
+                self.state = 375
+                self.match(RelayParser.T__6)
                 pass
 
             elif la_ == 3:
                 localctx = RelayParser.TupleTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 3)
-                self.state = 387
-                self.match(RelayParser.T__20)
-                self.state = 388
+                self.state = 377
+                self.match(RelayParser.T__5)
+                self.state = 378
                 self.typeExpr()
-                self.state = 391 
+                self.state = 381 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while True:
-                    self.state = 389
-                    self.match(RelayParser.T__19)
-                    self.state = 390
+                    self.state = 379
+                    self.match(RelayParser.T__4)
+                    self.state = 380
                     self.typeExpr()
-                    self.state = 393 
+                    self.state = 383 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
-                    if not (_la==RelayParser.T__19):
+                    if not (_la==RelayParser.T__4):
                         break
 
-                self.state = 395
-                self.match(RelayParser.T__21)
+                self.state = 385
+                self.match(RelayParser.T__6)
                 pass
 
             elif la_ == 4:
                 localctx = RelayParser.TypeCallTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 4)
-                self.state = 397
-                self.typeIdent()
-                self.state = 398
+                self.state = 387
+                self.generalIdent()
+                self.state = 388
                 self.typeParamList()
                 pass
 
             elif la_ == 5:
                 localctx = RelayParser.TypeIdentTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 5)
-                self.state = 400
-                self.typeIdent()
+                self.state = 390
+                self.generalIdent()
                 pass
 
             elif la_ == 6:
                 localctx = RelayParser.TensorTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 6)
-                self.state = 401
-                self.match(RelayParser.T__41)
-                self.state = 402
-                self.match(RelayParser.T__24)
-                self.state = 403
+                self.state = 391
+                self.match(RelayParser.T__26)
+                self.state = 392
+                self.match(RelayParser.T__9)
+                self.state = 393
                 self.shapeList()
-                self.state = 404
-                self.match(RelayParser.T__19)
-                self.state = 405
+                self.state = 394
+                self.match(RelayParser.T__4)
+                self.state = 395
                 self.typeExpr()
-                self.state = 406
-                self.match(RelayParser.T__25)
+                self.state = 396
+                self.match(RelayParser.T__10)
                 pass
 
             elif la_ == 7:
                 localctx = RelayParser.FuncTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 7)
-                self.state = 408
-                self.match(RelayParser.T__32)
-                self.state = 410
+                self.state = 398
+                self.match(RelayParser.T__17)
+                self.state = 400
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if _la==RelayParser.T__24:
-                    self.state = 409
+                if _la==RelayParser.T__9:
+                    self.state = 399
                     self.typeParamList()
 
 
-                self.state = 412
-                self.match(RelayParser.T__20)
-                self.state = 421
+                self.state = 402
+                self.match(RelayParser.T__5)
+                self.state = 411
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__0) | (1 << RelayParser.T__1) | (1 << RelayParser.T__2) | (1 << RelayParser.T__3) | (1 << RelayParser.T__4) | (1 << RelayParser.T__5) | (1 << RelayParser.T__6) | (1 << RelayParser.T__7) | (1 << RelayParser.T__8) | (1 << RelayParser.T__9) | (1 << RelayParser.T__10) | (1 << RelayParser.T__11) | (1 << RelayParser.T__12) | (1 << RelayParser.T__13) | (1 << RelayParser.T__14) | (1 << RelayParser.T__18) | (1 << RelayParser.T__20) | (1 << RelayParser.T__32) | (1 << RelayParser.T__41) | (1 << RelayParser.START_UPPER_CNAME))) != 0):
-                    self.state = 413
+                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__3) | (1 << RelayParser.T__5) | (1 << RelayParser.T__17) | (1 << RelayParser.T__26) | (1 << RelayParser.CNAME))) != 0):
+                    self.state = 403
                     self.typeExpr()
-                    self.state = 418
+                    self.state = 408
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
-                    while _la==RelayParser.T__19:
-                        self.state = 414
-                        self.match(RelayParser.T__19)
-                        self.state = 415
+                    while _la==RelayParser.T__4:
+                        self.state = 404
+                        self.match(RelayParser.T__4)
+                        self.state = 405
                         self.typeExpr()
-                        self.state = 420
+                        self.state = 410
                         self._errHandler.sync(self)
                         _la = self._input.LA(1)
 
 
 
-                self.state = 423
-                self.match(RelayParser.T__21)
-                self.state = 424
-                self.match(RelayParser.T__33)
-                self.state = 425
+                self.state = 413
+                self.match(RelayParser.T__6)
+                self.state = 414
+                self.match(RelayParser.T__18)
+                self.state = 415
                 self.typeExpr()
                 pass
 
             elif la_ == 8:
                 localctx = RelayParser.IncompleteTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 8)
-                self.state = 426
-                self.match(RelayParser.T__18)
+                self.state = 416
+                self.match(RelayParser.T__3)
                 pass
 
 
@@ -3026,11 +2897,11 @@ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
             super().__init__(parent, invokingState)
             self.parser = parser
 
-        def typeIdent(self, i:int=None):
+        def generalIdent(self, i:int=None):
             if i is None:
-                return self.getTypedRuleContexts(RelayParser.TypeIdentContext)
+                return self.getTypedRuleContexts(RelayParser.GeneralIdentContext)
             else:
-                return self.getTypedRuleContext(RelayParser.TypeIdentContext,i)
+                return self.getTypedRuleContext(RelayParser.GeneralIdentContext,i)
 
 
         def getRuleIndex(self):
@@ -3048,28 +2919,28 @@ def accept(self, visitor:ParseTreeVisitor):
     def typeParamList(self):
 
         localctx = RelayParser.TypeParamListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 54, self.RULE_typeParamList)
+        self.enterRule(localctx, 50, self.RULE_typeParamList)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 429
-            self.match(RelayParser.T__24)
-            self.state = 430
-            self.typeIdent()
-            self.state = 435
+            self.state = 419
+            self.match(RelayParser.T__9)
+            self.state = 420
+            self.generalIdent()
+            self.state = 425
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            while _la==RelayParser.T__19:
-                self.state = 431
-                self.match(RelayParser.T__19)
-                self.state = 432
-                self.typeIdent()
-                self.state = 437
+            while _la==RelayParser.T__4:
+                self.state = 421
+                self.match(RelayParser.T__4)
+                self.state = 422
+                self.generalIdent()
+                self.state = 427
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 438
-            self.match(RelayParser.T__25)
+            self.state = 428
+            self.match(RelayParser.T__10)
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -3107,47 +2978,47 @@ def accept(self, visitor:ParseTreeVisitor):
     def shapeList(self):
 
         localctx = RelayParser.ShapeListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 56, self.RULE_shapeList)
+        self.enterRule(localctx, 52, self.RULE_shapeList)
         self._la = 0 # Token type
         try:
-            self.state = 453
+            self.state = 443
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,45,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,44,self._ctx)
             if la_ == 1:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 440
-                self.match(RelayParser.T__20)
-                self.state = 441
-                self.match(RelayParser.T__21)
+                self.state = 430
+                self.match(RelayParser.T__5)
+                self.state = 431
+                self.match(RelayParser.T__6)
                 pass
 
             elif la_ == 2:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 442
-                self.match(RelayParser.T__20)
-                self.state = 443
+                self.state = 432
+                self.match(RelayParser.T__5)
+                self.state = 433
                 self.shape()
-                self.state = 446 
+                self.state = 436 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while True:
-                    self.state = 444
-                    self.match(RelayParser.T__19)
-                    self.state = 445
+                    self.state = 434
+                    self.match(RelayParser.T__4)
+                    self.state = 435
                     self.shape()
-                    self.state = 448 
+                    self.state = 438 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
-                    if not (_la==RelayParser.T__19):
+                    if not (_la==RelayParser.T__4):
                         break
 
-                self.state = 450
-                self.match(RelayParser.T__21)
+                self.state = 440
+                self.match(RelayParser.T__6)
                 pass
 
             elif la_ == 3:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 452
+                self.state = 442
                 self.shape()
                 pass
 
@@ -3167,8 +3038,8 @@ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
             super().__init__(parent, invokingState)
             self.parser = parser
 
-        def START_UPPER_CNAME(self):
-            return self.getToken(RelayParser.START_UPPER_CNAME, 0)
+        def CNAME(self):
+            return self.getToken(RelayParser.CNAME, 0)
 
         def NAT(self):
             return self.getToken(RelayParser.NAT, 0)
@@ -3188,23 +3059,23 @@ def accept(self, visitor:ParseTreeVisitor):
     def meta(self):
 
         localctx = RelayParser.MetaContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 58, self.RULE_meta)
+        self.enterRule(localctx, 54, self.RULE_meta)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 455
-            self.match(RelayParser.T__42)
-            self.state = 456
-            self.match(RelayParser.T__24)
-            self.state = 457
-            self.match(RelayParser.START_UPPER_CNAME)
-            self.state = 458
-            self.match(RelayParser.T__25)
-            self.state = 459
-            self.match(RelayParser.T__24)
-            self.state = 460
+            self.state = 445
+            self.match(RelayParser.T__27)
+            self.state = 446
+            self.match(RelayParser.T__9)
+            self.state = 447
+            self.match(RelayParser.CNAME)
+            self.state = 448
+            self.match(RelayParser.T__10)
+            self.state = 449
+            self.match(RelayParser.T__9)
+            self.state = 450
             self.match(RelayParser.NAT)
-            self.state = 461
-            self.match(RelayParser.T__25)
+            self.state = 451
+            self.match(RelayParser.T__10)
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -3284,31 +3155,31 @@ def accept(self, visitor:ParseTreeVisitor):
     def shape(self):
 
         localctx = RelayParser.ShapeContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 60, self.RULE_shape)
+        self.enterRule(localctx, 56, self.RULE_shape)
         try:
-            self.state = 469
+            self.state = 459
             self._errHandler.sync(self)
             token = self._input.LA(1)
-            if token in [RelayParser.T__42]:
+            if token in [RelayParser.T__27]:
                 localctx = RelayParser.MetaShapeContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 463
+                self.state = 453
                 self.meta()
                 pass
-            elif token in [RelayParser.T__20]:
+            elif token in [RelayParser.T__5]:
                 localctx = RelayParser.ParensShapeContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 464
-                self.match(RelayParser.T__20)
-                self.state = 465
+                self.state = 454
+                self.match(RelayParser.T__5)
+                self.state = 455
                 self.shape()
-                self.state = 466
-                self.match(RelayParser.T__21)
+                self.state = 456
+                self.match(RelayParser.T__6)
                 pass
             elif token in [RelayParser.NAT]:
                 localctx = RelayParser.IntShapeContext(self, localctx)
                 self.enterOuterAlt(localctx, 3)
-                self.state = 468
+                self.state = 458
                 self.match(RelayParser.NAT)
                 pass
             else:
@@ -3348,15 +3219,15 @@ def accept(self, visitor:ParseTreeVisitor):
     def body(self):
 
         localctx = RelayParser.BodyContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 62, self.RULE_body)
+        self.enterRule(localctx, 58, self.RULE_body)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 471
-            self.match(RelayParser.T__22)
-            self.state = 472
+            self.state = 461
+            self.match(RelayParser.T__7)
+            self.state = 462
             self.expr(0)
-            self.state = 473
-            self.match(RelayParser.T__23)
+            self.state = 463
+            self.match(RelayParser.T__8)
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -3434,27 +3305,27 @@ def accept(self, visitor:ParseTreeVisitor):
     def scalar(self):
 
         localctx = RelayParser.ScalarContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 64, self.RULE_scalar)
+        self.enterRule(localctx, 60, self.RULE_scalar)
         try:
-            self.state = 478
+            self.state = 468
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [RelayParser.FLOAT]:
                 localctx = RelayParser.ScalarFloatContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 475
+                self.state = 465
                 self.match(RelayParser.FLOAT)
                 pass
             elif token in [RelayParser.NAT]:
                 localctx = RelayParser.ScalarIntContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 476
+                self.state = 466
                 self.match(RelayParser.NAT)
                 pass
             elif token in [RelayParser.BOOL_LIT]:
                 localctx = RelayParser.ScalarBoolContext(self, localctx)
                 self.enterOuterAlt(localctx, 3)
-                self.state = 477
+                self.state = 467
                 self.match(RelayParser.BOOL_LIT)
                 pass
             else:
@@ -3475,8 +3346,8 @@ def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
             super().__init__(parent, invokingState)
             self.parser = parser
 
-        def opIdent(self):
-            return self.getTypedRuleContext(RelayParser.OpIdentContext,0)
+        def generalIdent(self):
+            return self.getTypedRuleContext(RelayParser.GeneralIdentContext,0)
 
 
         def globalVar(self):
@@ -3487,10 +3358,6 @@ def localVar(self):
             return self.getTypedRuleContext(RelayParser.LocalVarContext,0)
 
 
-        def typeIdent(self):
-            return self.getTypedRuleContext(RelayParser.TypeIdentContext,0)
-
-
         def graphVar(self):
             return self.getTypedRuleContext(RelayParser.GraphVarContext,0)
 
@@ -3510,38 +3377,32 @@ def accept(self, visitor:ParseTreeVisitor):
     def ident(self):
 
         localctx = RelayParser.IdentContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 66, self.RULE_ident)
+        self.enterRule(localctx, 62, self.RULE_ident)
         try:
-            self.state = 485
+            self.state = 474
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,48,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,47,self._ctx)
             if la_ == 1:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 480
-                self.opIdent()
+                self.state = 470
+                self.generalIdent()
                 pass
 
             elif la_ == 2:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 481
+                self.state = 471
                 self.globalVar()
                 pass
 
             elif la_ == 3:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 482
+                self.state = 472
                 self.localVar()
                 pass
 
             elif la_ == 4:
                 self.enterOuterAlt(localctx, 4)
-                self.state = 483
-                self.typeIdent()
-                pass
-
-            elif la_ == 5:
-                self.enterOuterAlt(localctx, 5)
-                self.state = 484
+                self.state = 473
                 self.graphVar()
                 pass
 
@@ -3559,7 +3420,7 @@ def ident(self):
     def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):
         if self._predicates == None:
             self._predicates = dict()
-        self._predicates[9] = self.expr_sempred
+        self._predicates[7] = self.expr_sempred
         pred = self._predicates.get(ruleIndex, None)
         if pred is None:
             raise Exception("No predicate with index:" + str(ruleIndex))
diff --git a/python/tvm/relay/grammar/py3/RelayVisitor.py b/python/tvm/relay/grammar/py3/RelayVisitor.py
index e33757f3e456..02dc8eebfda2 100644
--- a/python/tvm/relay/grammar/py3/RelayVisitor.py
+++ b/python/tvm/relay/grammar/py3/RelayVisitor.py
@@ -9,18 +9,13 @@
 
 class RelayVisitor(ParseTreeVisitor):
 
-    # Visit a parse tree produced by RelayParser#baseType.
-    def visitBaseType(self, ctx:RelayParser.BaseTypeContext):
-        return self.visitChildren(ctx)
-
-
     # Visit a parse tree produced by RelayParser#prog.
     def visitProg(self, ctx:RelayParser.ProgContext):
         return self.visitChildren(ctx)
 
 
-    # Visit a parse tree produced by RelayParser#opIdent.
-    def visitOpIdent(self, ctx:RelayParser.OpIdentContext):
+    # Visit a parse tree produced by RelayParser#generalIdent.
+    def visitGeneralIdent(self, ctx:RelayParser.GeneralIdentContext):
         return self.visitChildren(ctx)
 
 
@@ -34,11 +29,6 @@ def visitLocalVar(self, ctx:RelayParser.LocalVarContext):
         return self.visitChildren(ctx)
 
 
-    # Visit a parse tree produced by RelayParser#typeIdent.
-    def visitTypeIdent(self, ctx:RelayParser.TypeIdentContext):
-        return self.visitChildren(ctx)
-
-
     # Visit a parse tree produced by RelayParser#graphVar.
     def visitGraphVar(self, ctx:RelayParser.GraphVarContext):
         return self.visitChildren(ctx)
diff --git a/src/relay/ir/pretty_printer.cc b/src/relay/ir/pretty_printer.cc
index 8c1b426fd5df..710a5bf2f720 100644
--- a/src/relay/ir/pretty_printer.cc
+++ b/src/relay/ir/pretty_printer.cc
@@ -359,8 +359,8 @@ class PrettyPrinter :
 
   // TODO(weberlo): Consolidate this method and `IsAtomic` in `pass_util.h`?
   bool AlwaysInline(const Expr& expr) {
-    return expr.as<GlobalVarNode>() || expr.as<ConstantNode>() ||
-           expr.as<OpNode>() || expr.as<VarNode>() || expr.as<ConstructorNode>();
+    return expr.as<GlobalVarNode>() || expr.as<ConstantNode>() || expr.as<OpNode>() ||
+           expr.as<VarNode>() || expr.as<ConstructorNode>() || expr.as<MatchNode>();
   }
 
   //------------------------------------
@@ -372,12 +372,9 @@ class PrettyPrinter :
     // for it. Every subsequent time we can just use its assigned variable.
     // This works since hashing uses pointer equality.
 
-    // TODO: we need to somehow carry the `try_inline` preference through the
-    // recursion.
-    // bool old_try_inline = try_inline_;
-    // try_inline_ = try_inline;
-
     // determine whether to inline
+    // TODO(weberlo): Graph vars created when not inlining exprs cause issues
+    // with scoping in clauses of match exprs.
     bool inline_expr = true;
     // bool inline_expr = AlwaysInline(expr);
     // if (try_inline) {
@@ -605,7 +602,8 @@ class PrettyPrinter :
     std::vector<Doc> clauses;
     for (const auto& clause : op->clauses) {
       Doc clause_doc;
-      clause_doc << "| " << Print(clause->lhs) << " => " << Print(clause->rhs, false, true);
+      clause_doc << "| " << PrintPattern(clause->lhs, false) << " => "
+                 << PrintExpr(clause->rhs, false, true);
       clauses.push_back(clause_doc);
     }
     doc << Indent(2, body << PrintNewLine() << PrintSep(clauses, PrintNewLine())) << PrintNewLine();

From 3424198af894014e035aa85d21f06b3f694700bf Mon Sep 17 00:00:00 2001
From: Logan Weber <weberlo@cs.washington.edu>
Date: Fri, 30 Aug 2019 13:40:31 -0700
Subject: [PATCH 12/29] Cleanup round 6

---
 python/tvm/relay/_parser.py | 214 +++++++++++++-----------------------
 1 file changed, 74 insertions(+), 140 deletions(-)

diff --git a/python/tvm/relay/_parser.py b/python/tvm/relay/_parser.py
index 51d0dbc165f1..cf75f1084afd 100644
--- a/python/tvm/relay/_parser.py
+++ b/python/tvm/relay/_parser.py
@@ -21,7 +21,7 @@
 
 import sys
 from ast import literal_eval
-
+from typing import Any, Deque, Dict, List, Optional, TypeVar, Tuple, Union
 from collections import deque
 
 import tvm
@@ -143,12 +143,11 @@ def __call__(self, args, attrs, type_args):
     "bool",
 ]
 
-T = ty.TypeVar("T")
-# Scope = Deque[Tuple[str, T]]
-# Scopes = Deque[Scope[T]]
+T = TypeVar("T")
+Scope = Deque[Tuple[str, T]]
+Scopes = Deque[Scope[T]]
 
-def lookup(scopes, name):
-    # type: (Scopes[T], str) -> Optional[T]
+def lookup(scopes: Scopes[T], name: str) -> Optional[T]:
     """Look up `name` in `scopes`."""
 
     for scope in scopes:
@@ -185,59 +184,51 @@ def _wrapper(*args, **kwargs):
 class ParseTreeToRelayIR(RelayVisitor):
     """Parse Relay text format into Relay IR."""
 
-    def __init__(self, source_name):
-        # type: (str) -> None
+    def __init__(self, source_name: str) -> None:
         self.source_name = source_name
         self.module = module.Module({})  # type: module.Module
 
         # Adding an empty scope allows naked lets without pain.
         self.var_scopes = deque([deque()])       # type: Scopes[expr.Var]
-        self.global_vars = {}               # type: Scope[expr.GlobalVar]
+        self.global_vars = {}                    # type: Scope[expr.GlobalVar]
         self.type_var_scopes = deque([deque()])  # type: Scopes[ty.TypeVar]
-        self.global_type_vars = {}          # type: Scope[expr.GlobalVar]
+        self.global_type_vars = {}               # type: Scope[expr.GlobalVar]
         self.graph_expr = []                     # type: List[expr.Expr]
 
         super(ParseTreeToRelayIR, self).__init__()
 
 
-    def enter_var_scope(self):
-        # type: () -> None
+    def enter_var_scope(self) -> None:
         """Enter a new Var scope so it can be popped off later."""
         self.var_scopes.appendleft(deque())
 
-    def exit_var_scope(self):
-        # type: () -> Scope[expr.Var]
+    def exit_var_scope(self) -> Scope[expr.Var]:
         """Pop off the current Var scope and return it."""
         return self.var_scopes.popleft()
 
-    def mk_var(self, name, typ=None):
-        # type: (str, ty.Type) -> expr.Var
+    def mk_var(self, name: str, typ: ty.Type=None):
         """Create a new Var and add it to the Var scope."""
         var = expr.Var(name, typ)
         self.var_scopes[0].appendleft((name, var))
         return var
 
-    def mk_global_var(self, name):
-        # type: (str) -> expr.GlobalVar
+    def mk_global_var(self, name: str) -> expr.GlobalVar:
         """Create a new GlobalVar and add it to the GlobalVar scope."""
         if name in self.global_vars:
-            raise ParseError(f'duplicate global var "{name}"')
+            raise ParseError(f"duplicate global var \"{name}\"")
         var = expr.GlobalVar(name)
         self.global_vars[name] = var
         return var
 
-    def enter_type_param_scope(self):
-        # type: () -> None
+    def enter_type_param_scope(self) -> None:
         """Enter a new TypeVar scope so it can be popped off later."""
         self.type_var_scopes.appendleft(deque())
 
-    def exit_type_param_scope(self):
-        # type: () -> Scope[ty.TypeVar]
+    def exit_type_param_scope(self) -> Scope[ty.TypeVar]:
         """Pop off the current TypeVar scope and return it."""
         return self.type_var_scopes.popleft()
 
-    def mk_typ(self, name, kind):
-        # (str, ty.Kind) -> ty.TypeVar
+    def mk_typ(self, name: str, kind: ty.Kind) -> ty.TypeVar:
         """Create a new TypeVar and add it to the TypeVar scope."""
         typ = ty.TypeVar(name, kind)
         self.type_var_scopes[0].appendleft((name, typ))
@@ -261,21 +252,20 @@ def _check_existing_typ_expr(self, name, new_expr):
             new_typ_name = self._type_expr_name(new_expr)
             existing_typ_name = self._type_expr_name(self.global_type_vars[name])
             raise ParseError(
-                f'{new_typ_name} `{name}` conflicts with existing {existing_typ_name}')
+                f"{new_typ_name} `{name}` conflicts with existing {existing_typ_name}")
 
     def _type_expr_name(self, expr):
         if isinstance(expr, adt.Constructor):
-            return f'`{expr.belong_to.var.name}` ADT constructor'
+            return f"`{expr.belong_to.var.name}` ADT constructor"
         elif isinstance(expr, ty.GlobalTypeVar):
             if expr.kind == ty.Kind.AdtHandle:
-                return f'ADT definition'
-        return 'function definition'
+                return f"ADT definition"
+        return "function definition"
 
     def visitProjection(self, ctx):
         return expr.TupleGetItem(self.visit(ctx.expr()), self.visit(ctx.NAT()))
 
-    def visitTerminal(self, node):
-        # type: (TerminalNode) -> Union[expr.Expr, int, float]
+    def visitTerminal(self, node) -> Union[expr.Expr, int, float]:
         """Visit lexer tokens that aren't ignored or visited by other functions."""
         node_type = node.getSymbol().type
         node_text = node.getText()
@@ -310,7 +300,7 @@ def visitGeneralIdent(self, ctx):
         if type_param is not None:
             return type_param
         # Check if it's an operator.
-        op_name = '.'.join([name.getText() for name in ctx.CNAME()])
+        op_name = ".".join([name.getText() for name in ctx.CNAME()])
         if op_name in FUNC_OPS:
             return FuncOp(FUNC_OPS[op_name])
         return ExprOp(op.get(op_name))
@@ -319,41 +309,40 @@ def visitGlobalVar(self, ctx):
         var_name = ctx.CNAME().getText()
         global_var = self.global_vars.get(var_name, None)
         if global_var is None:
-            raise ParseError(f'unbound global var `{var_name}`')
+            raise ParseError(f"unbound global var `{var_name}`")
         return global_var
 
     def visitLocalVar(self, ctx):
         var_name = ctx.CNAME().getText()
         local_var = lookup(self.var_scopes, var_name)
         if local_var is None:
-            raise ParseError(f'unbound local var `{var_name}`')
+            raise ParseError(f"unbound local var `{var_name}`")
         return local_var
 
     def visitGraphVar(self, ctx):
         return self.graph_expr[int(ctx.NAT().getText())]
 
-    def visit_list(self, ctx_list):
-        # type: (List[ParserRuleContext]) -> List[Any]
+    def visit_list(self, ctx_list) -> List[Any]:
         """"Visit a list of contexts."""
+        # type: RelayParser.ContextParserRuleContext
         assert isinstance(ctx_list, list)
 
         return [self.visit(ctx) for ctx in ctx_list]
 
-    def getTypeExpr(self, ctx):
-        # type: (Optional[RelayParser.Type_Context]) -> Optional[ty.Type]
+    def getTypeExpr(self, ctx) -> Optional[ty.Type]:
         """Return a (possibly None) Relay type."""
+        # type: : Optional[RelayParser.Type_Context]
         if ctx is None:
             return None
 
         return self.visit(ctx)
 
-    def visitProg(self, ctx):
+    def visitProg(self, ctx: RelayParser.ProgContext) -> Union[expr.Expr, module.Module]:
         self.meta = None
         if ctx.METADATA():
-            header, data = str(ctx.METADATA()).split('\n', 1)
+            header, data = str(ctx.METADATA()).split("\n", 1)
             assert header == "METADATA:"
             self.meta = tvm.load_json(data)
-        # type: (RelayParser.ProgContext) -> Union[expr.Expr, module.Module]
         if ctx.defn():
             self.visit_list(ctx.defn())
             return self.module
@@ -364,37 +353,30 @@ def visitProg(self, ctx):
         return self.module
 
     # Exprs
-    def visitOpIdent(self, ctx):
-        # type: (RelayParser.OpIdentContext) -> op.Op
-        op_name = '.'.join([name.getText() for name in ctx.CNAME()])
+    def visitOpIdent(self, ctx) -> op.Op:
+        op_name = ".".join([name.getText() for name in ctx.CNAME()])
         if op_name in FUNC_OPS:
             return FuncOp(FUNC_OPS[op_name])
         return ExprOp(op.get(op_name))
 
     # pass through
-    def visitParen(self, ctx):
-        # type: (RelayParser.ParenContext) -> expr.Expr
+    def visitParen(self, ctx: RelayParser.ParenContext) -> expr.Expr:
         return self.visit(ctx.expr())
 
     # pass through
-    def visitBody(self, ctx):
-        # type: (RelayParser.BodyContext) -> expr.Expr
+    def visitBody(self, ctx: RelayParser.BodyContext) -> expr.Expr:
         return self.visit(ctx.expr())
 
-    def visitScalarFloat(self, ctx):
-        # type: (RelayParser.ScalarFloatContext) -> expr.Constant
+    def visitScalarFloat(self, ctx: RelayParser.ScalarFloatContext) -> expr.Constant:
         return expr.const(self.visit(ctx.FLOAT()))
 
-    def visitScalarInt(self, ctx):
-        # type: (RelayParser.ScalarIntContext) -> expr.Constant
+    def visitScalarInt(self, ctx: RelayParser.ScalarIntContext) -> expr.Constant:
         return expr.const(self.visit(ctx.NAT()))
 
-    def visitScalarBool(self, ctx):
-        # type: (RelayParser.ScalarBoolContext) -> expr.Constant
+    def visitScalarBool(self, ctx: RelayParser.ScalarBoolContext) -> expr.Constant:
         return expr.const(self.visit(ctx.BOOL_LIT()))
 
-    def visitNeg(self, ctx):
-        # type: (RelayParser.NegContext) -> Union[expr.Constant, expr.Call]
+    def visitNeg(self, ctx: RelayParser.NegContext) -> Union[expr.Constant, expr.Call]:
         val = self.visit(ctx.expr())
         if isinstance(val, expr.Constant) and val.data.asnumpy().ndim == 0:
             # fold Neg in for scalars
@@ -402,13 +384,11 @@ def visitNeg(self, ctx):
 
         return op.negative(val)
 
-    def visitTuple(self, ctx):
-        # type: (RelayParser.TupleContext) -> expr.Tuple
+    def visitTuple(self, ctx: RelayParser.TupleContext) -> expr.Tuple:
         tup = self.visit_list(ctx.expr())
         return expr.Tuple(tup)
 
-    def visitLet(self, ctx):
-        # type: (RelayParser.SeqContext) -> expr.Let
+    def visitLet(self, ctx: RelayParser.LetContext) -> expr.Let:
         """Desugar various sequence constructs to Relay Let nodes."""
 
         if ctx.var() is None:
@@ -427,8 +407,7 @@ def visitLet(self, ctx):
 
         return expr.Let(var, value, body)
 
-    def visitBinOp(self, ctx):
-        # type: (RelayParser.BinOpContext) -> expr.Call
+    def visitBinOp(self, ctx: RelayParser.BinOpContext) -> expr.Call:
         """Desugar binary operators."""
         arg0, arg1 = self.visit_list(ctx.expr())
         relay_op = BINARY_OPS.get(ctx.op.type)
@@ -439,8 +418,7 @@ def visitBinOp(self, ctx):
         return relay_op(arg0, arg1)
 
     @spanify
-    def visitVar(self, ctx):
-        # type: (RelayParser.VarContext) -> expr.Var
+    def visitVar(self, ctx: RelayParser.VarContext) -> expr.Var:
         """Visit a single variable."""
         ident = ctx.localVar()
 
@@ -451,40 +429,34 @@ def visitVar(self, ctx):
 
         return self.mk_var(ident.getText()[1:], typeExpr)
 
-    def visitVarList(self, ctx):
-        # type: (RelayParser.VarListContext) -> List[expr.Var]
+    def visitVarList(self, ctx: RelayParser.VarListContext) -> List[expr.Var]:
         return self.visit_list(ctx.var())
 
     # TODO: support a larger class of values than just Relay exprs
-    def visitAttr(self, ctx):
-        # type: (RelayParser.AttrContext) -> Tuple[str, expr.Expr]
+    def visitAttr(self, ctx: RelayParser.AttrContext) -> Tuple[str, expr.Expr]:
         return (ctx.CNAME().getText(), self.visit(ctx.expr()))
 
-    def visitArgNoAttr(self, ctx):
+    def visitArgNoAttr(self, ctx: RelayParser.ArgNoAttrContext):
         return (self.visit_list(ctx.varList().var()), None)
 
-    def visitAttrSeq(self, ctx):
-        # type: (RelayParser.AttrListContext) -> Dict[str, expr.Expr]
+    def visitAttrSeq(self, ctx: RelayParser.AttrSeqContext) -> Dict[str, expr.Expr]:
         return dict(self.visit_list(ctx.attr()))
 
-    def visitArgWithAttr(self, ctx):
+    def visitArgWithAttr(self, ctx: RelayParser.AttrSeqContext) -> Tuple[List[expr.Var], Dict[str, expr.Expr]]:
         return (self.visit_list(ctx.var()), self.visitAttrSeq(ctx.attrSeq()))
 
-    def visitArgList(self,
-                     ctx    # type: RelayParser.ArgListContext
-                    ):
-        # type: (...) -> Tuple[Optional[List[expr.Var]], Optional[Dict[str, expr.Expr]]]
+    def visitArgList(self, ctx: RelayParser.ArgListContext) -> Tuple[Optional[List[expr.Var]], \
+                                                                     Optional[Dict[str, expr.Expr]]]:
         var_list = self.visit(ctx.varList()) if ctx.varList() else None
         attr_list = self.visit(ctx.attrList()) if ctx.attrList() else None
         return (var_list, attr_list)
 
-    def visitMeta(self, ctx):
+    def visitMeta(self, ctx: RelayParser.MetaContext):
         type_key = str(ctx.CNAME())
         index = int(self.visit(ctx.NAT()))
         return self.meta[type_key][index]
 
-    def mk_func(self, ctx):
-        # type: (Union[RelayParser.FuncContext, RelayParser.DefnContext]) -> expr.Function
+    def mk_func(self, ctx: Union[RelayParser.FuncContext, RelayParser.DefnContext]) -> expr.Function:
         """Construct a function from either a Func or Defn."""
         # Enter var scope early to put params in scope.
         self.enter_var_scope()
@@ -517,19 +489,17 @@ def mk_func(self, ctx):
         return expr.Function(var_list, body, ret_type, type_params, attrs)
 
     @spanify
-    def visitFunc(self, ctx):
-        # type: (RelayParser.FuncContext) -> expr.Function
+    def visitFunc(self, ctx: RelayParser.FuncContext) -> expr.Function:
         return self.mk_func(ctx)
 
     # TODO: how to set spans for definitions?
     # @spanify
-    def visitFuncDefn(self, ctx):
-        # type: (RelayParser.DefnContext) -> None
+    def visitFuncDefn(self, ctx: RelayParser.DefnContext) -> None:
         ident_name = ctx.globalVar().getText()[1:]
         ident = self.mk_global_var(ident_name)
         self.module[ident] = self.mk_func(ctx)
 
-    def visitAdtDefn(self, ctx):
+    def visitAdtDefn(self, ctx: RelayParser.AdtDefnContext):
         adt_name = ctx.generalIdent().getText()
         adt_handle = self.mk_global_typ_var(adt_name, ty.Kind.AdtHandle)
         self.enter_type_param_scope()
@@ -556,11 +526,11 @@ def visitAdtDefn(self, ctx):
 
         self.exit_type_param_scope()
 
-    def visitMatch(self, ctx):
+    def visitMatch(self, ctx: RelayParser.MatchContext):
         match_type = ctx.matchType().getText()
-        if match_type == 'match':
+        if match_type == "match":
             complete_match = True
-        elif match_type == 'match?':
+        elif match_type == "match?":
             complete_match = False
         else:
             raise RuntimeError(f"unknown match type {match_type}")
@@ -590,11 +560,11 @@ def visitMatch(self, ctx):
             ))
         return adt.Match(match_data, clauses, complete=complete_match)
 
-    def visitPattern(self, ctx):
+    def visitPattern(self, ctx: RelayParser.PatternContext):
         text = ctx.getText()
-        if text == '_':
+        if text == "_":
             return adt.PatternWildcard()
-        elif text.startswith('%'):
+        elif text.startswith("%"):
             text = ctx.localVar().getText()
             typ = ctx.typeExpr()
             if typ is not None:
@@ -602,12 +572,12 @@ def visitPattern(self, ctx):
             var = self.mk_var(text[1:], typ=typ)
             return adt.PatternVar(var)
         else:
-            raise ParseError(f'invalid pattern syntax "{text}"')
+            raise ParseError(f"invalid pattern syntax \"{text}\"")
 
-    def visitCallNoAttr(self, ctx):
+    def visitCallNoAttr(self, ctx: RelayParser.CallNoAttrContext):
         return (self.visit_list(ctx.exprList().expr()), None)
 
-    def visitCallWithAttr(self, ctx):
+    def visitCallWithAttr(self, ctx: RelayParser.CallWithAttrContext):
         return (self.visit_list(ctx.expr()), self.visit(ctx.attrSeq()))
 
     def call(self, func, args, attrs, type_args):
@@ -619,7 +589,7 @@ def call(self, func, args, attrs, type_args):
             return expr.Call(func, args, attrs, type_args)
 
     @spanify
-    def visitCall(self, ctx):
+    def visitCall(self, ctx: RelayParser.CallContext):
         # type: (RelayParser.CallContext) -> expr.Call
         func = self.visit(ctx.expr())
         args, attrs = self.visit(ctx.callList())
@@ -627,7 +597,7 @@ def visitCall(self, ctx):
         return res
 
     @spanify
-    def visitIfElse(self, ctx):
+    def visitIfElse(self, ctx: RelayParser.IfElseContext):
         # type: (RelayParser.IfElseContext) -> expr.If
         """Construct a Relay If node. Creates a new scope for each branch."""
         cond = self.visit(ctx.expr())
@@ -643,7 +613,7 @@ def visitIfElse(self, ctx):
         return expr.If(cond, true_branch, false_branch)
 
     @spanify
-    def visitGraph(self, ctx):
+    def visitGraph(self, ctx: RelayParser.GraphContext):
         # type: (RelayParser.GraphContext) -> expr.Expr
         """Visit a graph variable assignment."""
         graph_nid = int(ctx.graphVar().getText()[1:])
@@ -664,63 +634,27 @@ def visitGraph(self, ctx):
     # Types
 
     # pylint: disable=unused-argument
-    def visitIncompleteType(self, ctx):
+    def visitIncompleteType(self, ctx: RelayParser.IncompleteTypeContext):
         # type (RelayParser.IncompleteTypeContext) -> None:
         return None
 
-    # TODO: convert all this to mypy format
-    def visitTypeIdent(self, ctx):
-        # type: (RelayParser.TypeIdentContext) -> Union[ty.TensorType, str]
-        """Handle type identifier."""
-        type_name = ctx.getText()
-
-        # Look through all type prefixes for a match
-        for type_prefix in TYPE_PREFIXES:
-            if type_name.startswith(type_prefix):
-                return ty.scalar_type(type_name)
-
-        # Next, look it up in the local then global type params
-        type_param = lookup(self.type_var_scopes, type_name)
-        if type_param is None:
-            type_param = self.global_type_vars.get(type_name, None)
-            if type_param is None:
-                raise ParseError(f'unbound var "{type_name}"')
-
-        return type_param
-
-    def visitTypeCallType(self, ctx):
+    def visitTypeCallType(self, ctx: RelayParser.TypeCallTypeContext):
         func = self.visit(ctx.generalIdent())
         args = [self.visit(arg) for arg in ctx.typeParamList().generalIdent()]
         return ty.TypeCall(func, args)
 
-    # def visitCallType(self, ctx):
-    #     # type: (RelayParser.CallTypeContext) -> Union[expr.Expr, ty.TensorType]
-    #     ident_type = ctx.identType().CNAME().getText()
-
-    #     args = self.visit_list(ctx.type_())
-
-    #     if not args:
-    #         raise ParseError("Type-level functions must have arguments!")
-
-    #     func_type = TYPE_FUNCS.get(ident_type)(args)
-
-    #     if func_type is None:
-    #         raise ParseError("Unknown type-level function: `{}`".format(ident_type))
-    #     else:
-    #         return func_type
-
-    def visitParensShape(self, ctx):
+    def visitParensShape(self, ctx: RelayParser.ParensShapeContext):
         # type: (RelayParser.ParensShapeContext) -> int
         return self.visit(ctx.shape())
 
-    def visitShapeList(self, ctx):
+    def visitShapeList(self, ctx: RelayParser.ShapeListContext):
         # type: (RelayParser.ShapeListContext) -> List[int]
         return self.visit_list(ctx.shape())
 
-    def visitTensor(self, ctx):
+    def visitTensor(self, ctx: RelayParser.TensorContext):
         return tuple(self.visit_list(ctx.expr()))
 
-    def visitTensorType(self, ctx):
+    def visitTensorType(self, ctx: RelayParser.TensorTypeContext):
         # type: (RelayParser.TensorTypeContext) -> ty.TensorType
         """Create a simple tensor type. No generics."""
 
@@ -734,11 +668,11 @@ def visitTensorType(self, ctx):
 
         return ty.TensorType(shape, dtype)
 
-    def visitTupleType(self, ctx):
+    def visitTupleType(self, ctx: RelayParser.TupleTypeContext):
         # type: (RelayParser.TupleTypeContext) -> ty.TupleType
         return ty.TupleType(self.visit_list(ctx.typeExpr()))
 
-    def visitFuncType(self, ctx):
+    def visitFuncType(self, ctx: RelayParser.FuncTypeContext):
         # type: (RelayParser.FuncTypeContext) -> ty.FuncType
         types = self.visit_list(ctx.typeExpr())
 

From 950ac0e53674a96afa310fd0015532dad921f1ba Mon Sep 17 00:00:00 2001
From: Logan Weber <weberlo@cs.washington.edu>
Date: Fri, 30 Aug 2019 13:47:01 -0700
Subject: [PATCH 13/29] Cleanup round 7

---
 python/tvm/relay/grammar/Relay.g4          | 5 +----
 src/relay/ir/pretty_printer.cc             | 6 ++----
 tests/python/relay/test_ir_text_printer.py | 2 --
 3 files changed, 3 insertions(+), 10 deletions(-)

diff --git a/python/tvm/relay/grammar/Relay.g4 b/python/tvm/relay/grammar/Relay.g4
index 7272b53fb5a6..f727a3e894d8 100644
--- a/python/tvm/relay/grammar/Relay.g4
+++ b/python/tvm/relay/grammar/Relay.g4
@@ -20,7 +20,7 @@
 // TODO(weberlo): We need some way of indicating to users that you need to enable
 // USE_ANTLR in config.cmake.
 /*
- * NOTE: All upper-case rules are *lexer* rules and all lower-case rules are *parser* rules.
+ * NOTE: All upper-case rules are *lexer* rules and all camel-case rules are *parser* rules.
  */
 
 grammar Relay;
@@ -129,14 +129,12 @@ adtConsDefn: '|' constructorName ('(' typeExpr (',' typeExpr)* ')')? ;
 matchClause: '|' constructorName patternList? '=>' expr ;
 matchType : 'match' | 'match?' ;
 
-// TODO: Will need to make this recursive
 patternList: '(' pattern (',' pattern)* ')';
 pattern
   : '_'
   | localVar (':' typeExpr)?
   ;
 
-// TODO: Making the param list optional makes the grammar ambiguous.
 adtCons: constructorName adtConsParamList? ;
 adtConsParamList: '(' adtConsParam (',' adtConsParam)* ')' ;
 adtConsParam: localVar | constructorName ;
@@ -163,7 +161,6 @@ typeExpr
   | '_'                                                                    # incompleteType
   ;
 
-// TODO: For some reason, spaces aren't allowed between type params?
 typeParamList: '[' generalIdent (',' generalIdent)* ']' ;
 
 shapeList
diff --git a/src/relay/ir/pretty_printer.cc b/src/relay/ir/pretty_printer.cc
index 710a5bf2f720..eba295dba751 100644
--- a/src/relay/ir/pretty_printer.cc
+++ b/src/relay/ir/pretty_printer.cc
@@ -682,7 +682,6 @@ class PrettyPrinter :
   }
 
   Doc VisitType_(const TypeVarNode* node) final {
-    // return AllocTypeVar(GetRef<TypeVar>(node));
     return Doc(node->var->name_hint);
   }
 
@@ -770,9 +769,8 @@ class PrettyPrinter :
     }
     doc << " =";
 
-    // ADT variants
-    for (Constructor variant : node->constructors) {
-      doc << PrintNewLine() << "  | " << Print(variant, /* meta */ false, /* try_inline */ true);
+    for (Constructor constructor : node->constructors) {
+      doc << PrintNewLine() << "  | " << Print(constructor, /* meta */ false, /* try_inline */ true);
     }
 
     return doc;
diff --git a/tests/python/relay/test_ir_text_printer.py b/tests/python/relay/test_ir_text_printer.py
index 4f6f202ea034..082245ff74a5 100644
--- a/tests/python/relay/test_ir_text_printer.py
+++ b/tests/python/relay/test_ir_text_printer.py
@@ -40,8 +40,6 @@ def astext(p, unify_free_vars=False):
         assert_graph_equal(x, p)
     else:
         assert_alpha_equal(x, p)
-    # TODO: Unify two assert methods into the one below
-    # assert_alpha_equal(x, p, unify_free_vars)
     return txt
 
 def show(text):

From bcb90bcce3e6ebb3b2944bb159acaca675d837c1 Mon Sep 17 00:00:00 2001
From: Logan Weber <weberlo@cs.washington.edu>
Date: Fri, 30 Aug 2019 14:58:19 -0700
Subject: [PATCH 14/29] Lil grammar fix

---
 python/tvm/relay/grammar/Relay.g4 | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/python/tvm/relay/grammar/Relay.g4 b/python/tvm/relay/grammar/Relay.g4
index f727a3e894d8..e4c5d66dfb6a 100644
--- a/python/tvm/relay/grammar/Relay.g4
+++ b/python/tvm/relay/grammar/Relay.g4
@@ -117,7 +117,7 @@ expr
   | QUOTED_STRING                                # stringExpr
   ;
 
-func: 'fn'        typeParamList? '(' argList ')' ('->' typeExpr)? body ;
+func: 'fn' typeParamList? '(' argList ')' ('->' typeExpr)? body ;
 defn
   : 'def' globalVar typeParamList? '(' argList ')' ('->' typeExpr)? body  # funcDefn
   | 'type' generalIdent typeParamList? '=' adtConsDefn+                      # adtDefn

From 9feb3beacb950ec03ed13725826949bbb328af62 Mon Sep 17 00:00:00 2001
From: Logan Weber <weberlo@cs.washington.edu>
Date: Fri, 30 Aug 2019 14:58:40 -0700
Subject: [PATCH 15/29] Remove ANTLR Java files

---
 .../tvm/relay/grammar/RelayBaseListener.java  |  614 ----
 python/tvm/relay/grammar/RelayLexer.java      |  249 --
 python/tvm/relay/grammar/RelayListener.java   |  551 ----
 python/tvm/relay/grammar/RelayParser.java     | 2786 -----------------
 4 files changed, 4200 deletions(-)
 delete mode 100644 python/tvm/relay/grammar/RelayBaseListener.java
 delete mode 100644 python/tvm/relay/grammar/RelayLexer.java
 delete mode 100644 python/tvm/relay/grammar/RelayListener.java
 delete mode 100644 python/tvm/relay/grammar/RelayParser.java

diff --git a/python/tvm/relay/grammar/RelayBaseListener.java b/python/tvm/relay/grammar/RelayBaseListener.java
deleted file mode 100644
index ad739d57416b..000000000000
--- a/python/tvm/relay/grammar/RelayBaseListener.java
+++ /dev/null
@@ -1,614 +0,0 @@
-// Generated from Relay.g4 by ANTLR 4.7.2
-
-import org.antlr.v4.runtime.ParserRuleContext;
-import org.antlr.v4.runtime.tree.ErrorNode;
-import org.antlr.v4.runtime.tree.TerminalNode;
-
-/**
- * This class provides an empty implementation of {@link RelayListener},
- * which can be extended to create a listener which only needs to handle a subset
- * of the available methods.
- */
-public class RelayBaseListener implements RelayListener {
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterOpIdent(RelayParser.OpIdentContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitOpIdent(RelayParser.OpIdentContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterProg(RelayParser.ProgContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitProg(RelayParser.ProgContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterExprList(RelayParser.ExprListContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitExprList(RelayParser.ExprListContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterCallNoAttr(RelayParser.CallNoAttrContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitCallNoAttr(RelayParser.CallNoAttrContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterCallWithAttr(RelayParser.CallWithAttrContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitCallWithAttr(RelayParser.CallWithAttrContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterFuncExpr(RelayParser.FuncExprContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitFuncExpr(RelayParser.FuncExprContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterMetaExpr(RelayParser.MetaExprContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitMetaExpr(RelayParser.MetaExprContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterTensor(RelayParser.TensorContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitTensor(RelayParser.TensorContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterGraph(RelayParser.GraphContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitGraph(RelayParser.GraphContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterIdentExpr(RelayParser.IdentExprContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitIdentExpr(RelayParser.IdentExprContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterStringExpr(RelayParser.StringExprContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitStringExpr(RelayParser.StringExprContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterCall(RelayParser.CallContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitCall(RelayParser.CallContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterNeg(RelayParser.NegContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitNeg(RelayParser.NegContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterTuple(RelayParser.TupleContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitTuple(RelayParser.TupleContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterParen(RelayParser.ParenContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitParen(RelayParser.ParenContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterScalarExpr(RelayParser.ScalarExprContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitScalarExpr(RelayParser.ScalarExprContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterLet(RelayParser.LetContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitLet(RelayParser.LetContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterProjection(RelayParser.ProjectionContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitProjection(RelayParser.ProjectionContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterIfElse(RelayParser.IfElseContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitIfElse(RelayParser.IfElseContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterBinOp(RelayParser.BinOpContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitBinOp(RelayParser.BinOpContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterFunc(RelayParser.FuncContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitFunc(RelayParser.FuncContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterDefn(RelayParser.DefnContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitDefn(RelayParser.DefnContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterAdtDefn(RelayParser.AdtDefnContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitAdtDefn(RelayParser.AdtDefnContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterAdtVariant(RelayParser.AdtVariantContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitAdtVariant(RelayParser.AdtVariantContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterArgNoAttr(RelayParser.ArgNoAttrContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitArgNoAttr(RelayParser.ArgNoAttrContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterArgWithAttr(RelayParser.ArgWithAttrContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitArgWithAttr(RelayParser.ArgWithAttrContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterVarList(RelayParser.VarListContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitVarList(RelayParser.VarListContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterVar(RelayParser.VarContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitVar(RelayParser.VarContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterAttrSeq(RelayParser.AttrSeqContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitAttrSeq(RelayParser.AttrSeqContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterAttr(RelayParser.AttrContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitAttr(RelayParser.AttrContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterTypeParamList(RelayParser.TypeParamListContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitTypeParamList(RelayParser.TypeParamListContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterTupleType(RelayParser.TupleTypeContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitTupleType(RelayParser.TupleTypeContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterTypeIdentType(RelayParser.TypeIdentTypeContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitTypeIdentType(RelayParser.TypeIdentTypeContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterTensorType(RelayParser.TensorTypeContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitTensorType(RelayParser.TensorTypeContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterFuncType(RelayParser.FuncTypeContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitFuncType(RelayParser.FuncTypeContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterIncompleteType(RelayParser.IncompleteTypeContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitIncompleteType(RelayParser.IncompleteTypeContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterIntType(RelayParser.IntTypeContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitIntType(RelayParser.IntTypeContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterShapeList(RelayParser.ShapeListContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitShapeList(RelayParser.ShapeListContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterMeta(RelayParser.MetaContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitMeta(RelayParser.MetaContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterMetaShape(RelayParser.MetaShapeContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitMetaShape(RelayParser.MetaShapeContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterParensShape(RelayParser.ParensShapeContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitParensShape(RelayParser.ParensShapeContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterIntShape(RelayParser.IntShapeContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitIntShape(RelayParser.IntShapeContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterTypeIdent(RelayParser.TypeIdentContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitTypeIdent(RelayParser.TypeIdentContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterBody(RelayParser.BodyContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitBody(RelayParser.BodyContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterScalarFloat(RelayParser.ScalarFloatContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitScalarFloat(RelayParser.ScalarFloatContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterScalarInt(RelayParser.ScalarIntContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitScalarInt(RelayParser.ScalarIntContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterScalarBool(RelayParser.ScalarBoolContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitScalarBool(RelayParser.ScalarBoolContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterIdent(RelayParser.IdentContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitIdent(RelayParser.IdentContext ctx) { }
-
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void enterEveryRule(ParserRuleContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void exitEveryRule(ParserRuleContext ctx) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void visitTerminal(TerminalNode node) { }
-	/**
-	 * {@inheritDoc}
-	 *
-	 * <p>The default implementation does nothing.</p>
-	 */
-	@Override public void visitErrorNode(ErrorNode node) { }
-}
\ No newline at end of file
diff --git a/python/tvm/relay/grammar/RelayLexer.java b/python/tvm/relay/grammar/RelayLexer.java
deleted file mode 100644
index 8d0584b36a54..000000000000
--- a/python/tvm/relay/grammar/RelayLexer.java
+++ /dev/null
@@ -1,249 +0,0 @@
-// Generated from Relay.g4 by ANTLR 4.7.2
-import org.antlr.v4.runtime.Lexer;
-import org.antlr.v4.runtime.CharStream;
-import org.antlr.v4.runtime.Token;
-import org.antlr.v4.runtime.TokenStream;
-import org.antlr.v4.runtime.*;
-import org.antlr.v4.runtime.atn.*;
-import org.antlr.v4.runtime.dfa.DFA;
-import org.antlr.v4.runtime.misc.*;
-
-@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
-public class RelayLexer extends Lexer {
-	static { RuntimeMetaData.checkVersion("4.7.2", RuntimeMetaData.VERSION); }
-
-	protected static final DFA[] _decisionToDFA;
-	protected static final PredictionContextCache _sharedContextCache =
-		new PredictionContextCache();
-	public static final int
-		T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9, 
-		T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, T__14=15, T__15=16, T__16=17, 
-		T__17=18, T__18=19, T__19=20, T__20=21, T__21=22, T__22=23, T__23=24, 
-		SEMVER=25, COMMENT=26, WS=27, LINE_COMMENT=28, QUOTED_STRING=29, MUL=30, 
-		DIV=31, ADD=32, SUB=33, LT=34, GT=35, LE=36, GE=37, EQ=38, NE=39, BOOL_LIT=40, 
-		CNAME=41, GLOBAL_VAR=42, LOCAL_VAR=43, GRAPH_VAR=44, DATATYPE=45, FLOAT=46, 
-		NAT=47, METADATA=48;
-	public static String[] channelNames = {
-		"DEFAULT_TOKEN_CHANNEL", "HIDDEN"
-	};
-
-	public static String[] modeNames = {
-		"DEFAULT_MODE"
-	};
-
-	private static String[] makeRuleNames() {
-		return new String[] {
-			"T__0", "T__1", "T__2", "T__3", "T__4", "T__5", "T__6", "T__7", "T__8", 
-			"T__9", "T__10", "T__11", "T__12", "T__13", "T__14", "T__15", "T__16", 
-			"T__17", "T__18", "T__19", "T__20", "T__21", "T__22", "T__23", "SEMVER", 
-			"COMMENT", "WS", "LINE_COMMENT", "ESCAPED_QUOTE", "QUOTED_STRING", "MUL", 
-			"DIV", "ADD", "SUB", "LT", "GT", "LE", "GE", "EQ", "NE", "BOOL_LIT", 
-			"CNAME", "GLOBAL_VAR", "LOCAL_VAR", "GRAPH_VAR", "DATATYPE", "PREFLOAT", 
-			"FLOAT", "NAT", "EXP", "LETTER", "DIGIT", "METADATA"
-		};
-	}
-	public static final String[] ruleNames = makeRuleNames();
-
-	private static String[] makeLiteralNames() {
-		return new String[] {
-			null, "','", "'('", "')'", "'{'", "'}'", "'.'", "'['", "']'", "'if'", 
-			"'else'", "'let'", "'='", "';'", "';;'", "'fn'", "'->'", "'def'", "'type'", 
-			"'|'", "', '", "':'", "'Tensor'", "'_'", "'meta'", "'v0.0.3'", null, 
-			null, null, null, "'*'", "'/'", "'+'", "'-'", "'<'", "'>'", "'<='", "'>='", 
-			"'=='", "'!='", null, null, null, null, null, "'int64'"
-		};
-	}
-	private static final String[] _LITERAL_NAMES = makeLiteralNames();
-	private static String[] makeSymbolicNames() {
-		return new String[] {
-			null, null, null, null, null, null, null, null, null, null, null, null, 
-			null, null, null, null, null, null, null, null, null, null, null, null, 
-			null, "SEMVER", "COMMENT", "WS", "LINE_COMMENT", "QUOTED_STRING", "MUL", 
-			"DIV", "ADD", "SUB", "LT", "GT", "LE", "GE", "EQ", "NE", "BOOL_LIT", 
-			"CNAME", "GLOBAL_VAR", "LOCAL_VAR", "GRAPH_VAR", "DATATYPE", "FLOAT", 
-			"NAT", "METADATA"
-		};
-	}
-	private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
-	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
-
-	/**
-	 * @deprecated Use {@link #VOCABULARY} instead.
-	 */
-	@Deprecated
-	public static final String[] tokenNames;
-	static {
-		tokenNames = new String[_SYMBOLIC_NAMES.length];
-		for (int i = 0; i < tokenNames.length; i++) {
-			tokenNames[i] = VOCABULARY.getLiteralName(i);
-			if (tokenNames[i] == null) {
-				tokenNames[i] = VOCABULARY.getSymbolicName(i);
-			}
-
-			if (tokenNames[i] == null) {
-				tokenNames[i] = "<INVALID>";
-			}
-		}
-	}
-
-	@Override
-	@Deprecated
-	public String[] getTokenNames() {
-		return tokenNames;
-	}
-
-	@Override
-
-	public Vocabulary getVocabulary() {
-		return VOCABULARY;
-	}
-
-
-	public RelayLexer(CharStream input) {
-		super(input);
-		_interp = new LexerATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
-	}
-
-	@Override
-	public String getGrammarFileName() { return "Relay.g4"; }
-
-	@Override
-	public String[] getRuleNames() { return ruleNames; }
-
-	@Override
-	public String getSerializedATN() { return _serializedATN; }
-
-	@Override
-	public String[] getChannelNames() { return channelNames; }
-
-	@Override
-	public String[] getModeNames() { return modeNames; }
-
-	@Override
-	public ATN getATN() { return _ATN; }
-
-	public static final String _serializedATN =
-		"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\62\u015a\b\1\4\2"+
-		"\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4"+
-		"\13\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22"+
-		"\t\22\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31"+
-		"\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t"+
-		" \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t"+
-		"+\4,\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64"+
-		"\t\64\4\65\t\65\4\66\t\66\3\2\3\2\3\3\3\3\3\4\3\4\3\5\3\5\3\6\3\6\3\7"+
-		"\3\7\3\b\3\b\3\t\3\t\3\n\3\n\3\n\3\13\3\13\3\13\3\13\3\13\3\f\3\f\3\f"+
-		"\3\f\3\r\3\r\3\16\3\16\3\17\3\17\3\17\3\20\3\20\3\20\3\21\3\21\3\21\3"+
-		"\22\3\22\3\22\3\22\3\23\3\23\3\23\3\23\3\23\3\24\3\24\3\25\3\25\3\25\3"+
-		"\26\3\26\3\27\3\27\3\27\3\27\3\27\3\27\3\27\3\30\3\30\3\31\3\31\3\31\3"+
-		"\31\3\31\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\33\3\33\3\33\3\33\3\33\7"+
-		"\33\u00c1\n\33\f\33\16\33\u00c4\13\33\3\33\3\33\3\33\3\33\3\33\3\34\6"+
-		"\34\u00cc\n\34\r\34\16\34\u00cd\3\34\3\34\3\35\3\35\3\35\3\35\7\35\u00d6"+
-		"\n\35\f\35\16\35\u00d9\13\35\3\35\3\35\3\35\3\35\3\36\3\36\3\36\3\37\3"+
-		"\37\3\37\7\37\u00e5\n\37\f\37\16\37\u00e8\13\37\3\37\3\37\3 \3 \3!\3!"+
-		"\3\"\3\"\3#\3#\3$\3$\3%\3%\3&\3&\3&\3\'\3\'\3\'\3(\3(\3(\3)\3)\3)\3*\3"+
-		"*\3*\3*\3*\3*\3*\3*\3*\5*\u010d\n*\3+\3+\5+\u0111\n+\3+\3+\3+\7+\u0116"+
-		"\n+\f+\16+\u0119\13+\3+\3+\7+\u011d\n+\f+\16+\u0120\13+\3,\3,\3,\3-\3"+
-		"-\3-\3.\3.\3.\3/\3/\3/\3/\3/\3/\3\60\3\60\3\60\5\60\u0134\n\60\3\60\5"+
-		"\60\u0137\n\60\3\61\3\61\3\61\3\62\6\62\u013d\n\62\r\62\16\62\u013e\3"+
-		"\63\3\63\5\63\u0143\n\63\3\63\3\63\3\64\3\64\3\65\3\65\3\66\3\66\3\66"+
-		"\3\66\3\66\3\66\3\66\3\66\3\66\3\66\3\66\7\66\u0156\n\66\f\66\16\66\u0159"+
-		"\13\66\5\u00c2\u00d7\u00e6\2\67\3\3\5\4\7\5\t\6\13\7\r\b\17\t\21\n\23"+
-		"\13\25\f\27\r\31\16\33\17\35\20\37\21!\22#\23%\24\'\25)\26+\27-\30/\31"+
-		"\61\32\63\33\65\34\67\359\36;\2=\37? A!C\"E#G$I%K&M\'O(Q)S*U+W,Y-[.]/"+
-		"_\2a\60c\61e\2g\2i\2k\62\3\2\b\5\2\13\f\17\17\"\"\4\2\f\f\17\17\4\2GG"+
-		"gg\4\2--//\4\2C\\c|\3\2\62;\2\u0165\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3\2\2"+
-		"\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2\2\23"+
-		"\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2"+
-		"\2\2\2\37\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2\2\'\3\2\2\2\2)\3\2"+
-		"\2\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2\2\2\2\63\3\2\2\2\2\65\3"+
-		"\2\2\2\2\67\3\2\2\2\29\3\2\2\2\2=\3\2\2\2\2?\3\2\2\2\2A\3\2\2\2\2C\3\2"+
-		"\2\2\2E\3\2\2\2\2G\3\2\2\2\2I\3\2\2\2\2K\3\2\2\2\2M\3\2\2\2\2O\3\2\2\2"+
-		"\2Q\3\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2W\3\2\2\2\2Y\3\2\2\2\2[\3\2\2\2\2]"+
-		"\3\2\2\2\2a\3\2\2\2\2c\3\2\2\2\2k\3\2\2\2\3m\3\2\2\2\5o\3\2\2\2\7q\3\2"+
-		"\2\2\ts\3\2\2\2\13u\3\2\2\2\rw\3\2\2\2\17y\3\2\2\2\21{\3\2\2\2\23}\3\2"+
-		"\2\2\25\u0080\3\2\2\2\27\u0085\3\2\2\2\31\u0089\3\2\2\2\33\u008b\3\2\2"+
-		"\2\35\u008d\3\2\2\2\37\u0090\3\2\2\2!\u0093\3\2\2\2#\u0096\3\2\2\2%\u009a"+
-		"\3\2\2\2\'\u009f\3\2\2\2)\u00a1\3\2\2\2+\u00a4\3\2\2\2-\u00a6\3\2\2\2"+
-		"/\u00ad\3\2\2\2\61\u00af\3\2\2\2\63\u00b4\3\2\2\2\65\u00bb\3\2\2\2\67"+
-		"\u00cb\3\2\2\29\u00d1\3\2\2\2;\u00de\3\2\2\2=\u00e1\3\2\2\2?\u00eb\3\2"+
-		"\2\2A\u00ed\3\2\2\2C\u00ef\3\2\2\2E\u00f1\3\2\2\2G\u00f3\3\2\2\2I\u00f5"+
-		"\3\2\2\2K\u00f7\3\2\2\2M\u00fa\3\2\2\2O\u00fd\3\2\2\2Q\u0100\3\2\2\2S"+
-		"\u010c\3\2\2\2U\u0110\3\2\2\2W\u0121\3\2\2\2Y\u0124\3\2\2\2[\u0127\3\2"+
-		"\2\2]\u012a\3\2\2\2_\u0130\3\2\2\2a\u0138\3\2\2\2c\u013c\3\2\2\2e\u0140"+
-		"\3\2\2\2g\u0146\3\2\2\2i\u0148\3\2\2\2k\u014a\3\2\2\2mn\7.\2\2n\4\3\2"+
-		"\2\2op\7*\2\2p\6\3\2\2\2qr\7+\2\2r\b\3\2\2\2st\7}\2\2t\n\3\2\2\2uv\7\177"+
-		"\2\2v\f\3\2\2\2wx\7\60\2\2x\16\3\2\2\2yz\7]\2\2z\20\3\2\2\2{|\7_\2\2|"+
-		"\22\3\2\2\2}~\7k\2\2~\177\7h\2\2\177\24\3\2\2\2\u0080\u0081\7g\2\2\u0081"+
-		"\u0082\7n\2\2\u0082\u0083\7u\2\2\u0083\u0084\7g\2\2\u0084\26\3\2\2\2\u0085"+
-		"\u0086\7n\2\2\u0086\u0087\7g\2\2\u0087\u0088\7v\2\2\u0088\30\3\2\2\2\u0089"+
-		"\u008a\7?\2\2\u008a\32\3\2\2\2\u008b\u008c\7=\2\2\u008c\34\3\2\2\2\u008d"+
-		"\u008e\7=\2\2\u008e\u008f\7=\2\2\u008f\36\3\2\2\2\u0090\u0091\7h\2\2\u0091"+
-		"\u0092\7p\2\2\u0092 \3\2\2\2\u0093\u0094\7/\2\2\u0094\u0095\7@\2\2\u0095"+
-		"\"\3\2\2\2\u0096\u0097\7f\2\2\u0097\u0098\7g\2\2\u0098\u0099\7h\2\2\u0099"+
-		"$\3\2\2\2\u009a\u009b\7v\2\2\u009b\u009c\7{\2\2\u009c\u009d\7r\2\2\u009d"+
-		"\u009e\7g\2\2\u009e&\3\2\2\2\u009f\u00a0\7~\2\2\u00a0(\3\2\2\2\u00a1\u00a2"+
-		"\7.\2\2\u00a2\u00a3\7\"\2\2\u00a3*\3\2\2\2\u00a4\u00a5\7<\2\2\u00a5,\3"+
-		"\2\2\2\u00a6\u00a7\7V\2\2\u00a7\u00a8\7g\2\2\u00a8\u00a9\7p\2\2\u00a9"+
-		"\u00aa\7u\2\2\u00aa\u00ab\7q\2\2\u00ab\u00ac\7t\2\2\u00ac.\3\2\2\2\u00ad"+
-		"\u00ae\7a\2\2\u00ae\60\3\2\2\2\u00af\u00b0\7o\2\2\u00b0\u00b1\7g\2\2\u00b1"+
-		"\u00b2\7v\2\2\u00b2\u00b3\7c\2\2\u00b3\62\3\2\2\2\u00b4\u00b5\7x\2\2\u00b5"+
-		"\u00b6\7\62\2\2\u00b6\u00b7\7\60\2\2\u00b7\u00b8\7\62\2\2\u00b8\u00b9"+
-		"\7\60\2\2\u00b9\u00ba\7\65\2\2\u00ba\64\3\2\2\2\u00bb\u00bc\7\61\2\2\u00bc"+
-		"\u00bd\7,\2\2\u00bd\u00c2\3\2\2\2\u00be\u00c1\5\65\33\2\u00bf\u00c1\13"+
-		"\2\2\2\u00c0\u00be\3\2\2\2\u00c0\u00bf\3\2\2\2\u00c1\u00c4\3\2\2\2\u00c2"+
-		"\u00c3\3\2\2\2\u00c2\u00c0\3\2\2\2\u00c3\u00c5\3\2\2\2\u00c4\u00c2\3\2"+
-		"\2\2\u00c5\u00c6\7,\2\2\u00c6\u00c7\7\61\2\2\u00c7\u00c8\3\2\2\2\u00c8"+
-		"\u00c9\b\33\2\2\u00c9\66\3\2\2\2\u00ca\u00cc\t\2\2\2\u00cb\u00ca\3\2\2"+
-		"\2\u00cc\u00cd\3\2\2\2\u00cd\u00cb\3\2\2\2\u00cd\u00ce\3\2\2\2\u00ce\u00cf"+
-		"\3\2\2\2\u00cf\u00d0\b\34\2\2\u00d08\3\2\2\2\u00d1\u00d2\7\61\2\2\u00d2"+
-		"\u00d3\7\61\2\2\u00d3\u00d7\3\2\2\2\u00d4\u00d6\13\2\2\2\u00d5\u00d4\3"+
-		"\2\2\2\u00d6\u00d9\3\2\2\2\u00d7\u00d8\3\2\2\2\u00d7\u00d5\3\2\2\2\u00d8"+
-		"\u00da\3\2\2\2\u00d9\u00d7\3\2\2\2\u00da\u00db\7\f\2\2\u00db\u00dc\3\2"+
-		"\2\2\u00dc\u00dd\b\35\2\2\u00dd:\3\2\2\2\u00de\u00df\7^\2\2\u00df\u00e0"+
-		"\7$\2\2\u00e0<\3\2\2\2\u00e1\u00e6\7$\2\2\u00e2\u00e5\5;\36\2\u00e3\u00e5"+
-		"\n\3\2\2\u00e4\u00e2\3\2\2\2\u00e4\u00e3\3\2\2\2\u00e5\u00e8\3\2\2\2\u00e6"+
-		"\u00e7\3\2\2\2\u00e6\u00e4\3\2\2\2\u00e7\u00e9\3\2\2\2\u00e8\u00e6\3\2"+
-		"\2\2\u00e9\u00ea\7$\2\2\u00ea>\3\2\2\2\u00eb\u00ec\7,\2\2\u00ec@\3\2\2"+
-		"\2\u00ed\u00ee\7\61\2\2\u00eeB\3\2\2\2\u00ef\u00f0\7-\2\2\u00f0D\3\2\2"+
-		"\2\u00f1\u00f2\7/\2\2\u00f2F\3\2\2\2\u00f3\u00f4\7>\2\2\u00f4H\3\2\2\2"+
-		"\u00f5\u00f6\7@\2\2\u00f6J\3\2\2\2\u00f7\u00f8\7>\2\2\u00f8\u00f9\7?\2"+
-		"\2\u00f9L\3\2\2\2\u00fa\u00fb\7@\2\2\u00fb\u00fc\7?\2\2\u00fcN\3\2\2\2"+
-		"\u00fd\u00fe\7?\2\2\u00fe\u00ff\7?\2\2\u00ffP\3\2\2\2\u0100\u0101\7#\2"+
-		"\2\u0101\u0102\7?\2\2\u0102R\3\2\2\2\u0103\u0104\7V\2\2\u0104\u0105\7"+
-		"t\2\2\u0105\u0106\7w\2\2\u0106\u010d\7g\2\2\u0107\u0108\7H\2\2\u0108\u0109"+
-		"\7c\2\2\u0109\u010a\7n\2\2\u010a\u010b\7u\2\2\u010b\u010d\7g\2\2\u010c"+
-		"\u0103\3\2\2\2\u010c\u0107\3\2\2\2\u010dT\3\2\2\2\u010e\u0111\7a\2\2\u010f"+
-		"\u0111\5g\64\2\u0110\u010e\3\2\2\2\u0110\u010f\3\2\2\2\u0111\u0117\3\2"+
-		"\2\2\u0112\u0116\7a\2\2\u0113\u0116\5g\64\2\u0114\u0116\5i\65\2\u0115"+
-		"\u0112\3\2\2\2\u0115\u0113\3\2\2\2\u0115\u0114\3\2\2\2\u0116\u0119\3\2"+
-		"\2\2\u0117\u0115\3\2\2\2\u0117\u0118\3\2\2\2\u0118\u011e\3\2\2\2\u0119"+
-		"\u0117\3\2\2\2\u011a\u011b\7\60\2\2\u011b\u011d\5U+\2\u011c\u011a\3\2"+
-		"\2\2\u011d\u0120\3\2\2\2\u011e\u011c\3\2\2\2\u011e\u011f\3\2\2\2\u011f"+
-		"V\3\2\2\2\u0120\u011e\3\2\2\2\u0121\u0122\7B\2\2\u0122\u0123\5U+\2\u0123"+
-		"X\3\2\2\2\u0124\u0125\7\'\2\2\u0125\u0126\5U+\2\u0126Z\3\2\2\2\u0127\u0128"+
-		"\7\'\2\2\u0128\u0129\5c\62\2\u0129\\\3\2\2\2\u012a\u012b\7k\2\2\u012b"+
-		"\u012c\7p\2\2\u012c\u012d\7v\2\2\u012d\u012e\78\2\2\u012e\u012f\7\66\2"+
-		"\2\u012f^\3\2\2\2\u0130\u0133\5c\62\2\u0131\u0132\7\60\2\2\u0132\u0134"+
-		"\5c\62\2\u0133\u0131\3\2\2\2\u0133\u0134\3\2\2\2\u0134\u0136\3\2\2\2\u0135"+
-		"\u0137\5e\63\2\u0136\u0135\3\2\2\2\u0136\u0137\3\2\2\2\u0137`\3\2\2\2"+
-		"\u0138\u0139\5_\60\2\u0139\u013a\7h\2\2\u013ab\3\2\2\2\u013b\u013d\5i"+
-		"\65\2\u013c\u013b\3\2\2\2\u013d\u013e\3\2\2\2\u013e\u013c\3\2\2\2\u013e"+
-		"\u013f\3\2\2\2\u013fd\3\2\2\2\u0140\u0142\t\4\2\2\u0141\u0143\t\5\2\2"+
-		"\u0142\u0141\3\2\2\2\u0142\u0143\3\2\2\2\u0143\u0144\3\2\2\2\u0144\u0145"+
-		"\5c\62\2\u0145f\3\2\2\2\u0146\u0147\t\6\2\2\u0147h\3\2\2\2\u0148\u0149"+
-		"\t\7\2\2\u0149j\3\2\2\2\u014a\u014b\7O\2\2\u014b\u014c\7G\2\2\u014c\u014d"+
-		"\7V\2\2\u014d\u014e\7C\2\2\u014e\u014f\7F\2\2\u014f\u0150\7C\2\2\u0150"+
-		"\u0151\7V\2\2\u0151\u0152\7C\2\2\u0152\u0153\7<\2\2\u0153\u0157\3\2\2"+
-		"\2\u0154\u0156\13\2\2\2\u0155\u0154\3\2\2\2\u0156\u0159\3\2\2\2\u0157"+
-		"\u0155\3\2\2\2\u0157\u0158\3\2\2\2\u0158l\3\2\2\2\u0159\u0157\3\2\2\2"+
-		"\23\2\u00c0\u00c2\u00cd\u00d7\u00e4\u00e6\u010c\u0110\u0115\u0117\u011e"+
-		"\u0133\u0136\u013e\u0142\u0157\3\b\2\2";
-	public static final ATN _ATN =
-		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
-	static {
-		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
-		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
-			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
-		}
-	}
-}
\ No newline at end of file
diff --git a/python/tvm/relay/grammar/RelayListener.java b/python/tvm/relay/grammar/RelayListener.java
deleted file mode 100644
index 3ba88ea2420a..000000000000
--- a/python/tvm/relay/grammar/RelayListener.java
+++ /dev/null
@@ -1,551 +0,0 @@
-// Generated from Relay.g4 by ANTLR 4.7.2
-import org.antlr.v4.runtime.tree.ParseTreeListener;
-
-/**
- * This interface defines a complete listener for a parse tree produced by
- * {@link RelayParser}.
- */
-public interface RelayListener extends ParseTreeListener {
-	/**
-	 * Enter a parse tree produced by {@link RelayParser#opIdent}.
-	 * @param ctx the parse tree
-	 */
-	void enterOpIdent(RelayParser.OpIdentContext ctx);
-	/**
-	 * Exit a parse tree produced by {@link RelayParser#opIdent}.
-	 * @param ctx the parse tree
-	 */
-	void exitOpIdent(RelayParser.OpIdentContext ctx);
-	/**
-	 * Enter a parse tree produced by {@link RelayParser#prog}.
-	 * @param ctx the parse tree
-	 */
-	void enterProg(RelayParser.ProgContext ctx);
-	/**
-	 * Exit a parse tree produced by {@link RelayParser#prog}.
-	 * @param ctx the parse tree
-	 */
-	void exitProg(RelayParser.ProgContext ctx);
-	/**
-	 * Enter a parse tree produced by {@link RelayParser#exprList}.
-	 * @param ctx the parse tree
-	 */
-	void enterExprList(RelayParser.ExprListContext ctx);
-	/**
-	 * Exit a parse tree produced by {@link RelayParser#exprList}.
-	 * @param ctx the parse tree
-	 */
-	void exitExprList(RelayParser.ExprListContext ctx);
-	/**
-	 * Enter a parse tree produced by the {@code callNoAttr}
-	 * labeled alternative in {@link RelayParser#callList}.
-	 * @param ctx the parse tree
-	 */
-	void enterCallNoAttr(RelayParser.CallNoAttrContext ctx);
-	/**
-	 * Exit a parse tree produced by the {@code callNoAttr}
-	 * labeled alternative in {@link RelayParser#callList}.
-	 * @param ctx the parse tree
-	 */
-	void exitCallNoAttr(RelayParser.CallNoAttrContext ctx);
-	/**
-	 * Enter a parse tree produced by the {@code callWithAttr}
-	 * labeled alternative in {@link RelayParser#callList}.
-	 * @param ctx the parse tree
-	 */
-	void enterCallWithAttr(RelayParser.CallWithAttrContext ctx);
-	/**
-	 * Exit a parse tree produced by the {@code callWithAttr}
-	 * labeled alternative in {@link RelayParser#callList}.
-	 * @param ctx the parse tree
-	 */
-	void exitCallWithAttr(RelayParser.CallWithAttrContext ctx);
-	/**
-	 * Enter a parse tree produced by the {@code funcExpr}
-	 * labeled alternative in {@link RelayParser#expr}.
-	 * @param ctx the parse tree
-	 */
-	void enterFuncExpr(RelayParser.FuncExprContext ctx);
-	/**
-	 * Exit a parse tree produced by the {@code funcExpr}
-	 * labeled alternative in {@link RelayParser#expr}.
-	 * @param ctx the parse tree
-	 */
-	void exitFuncExpr(RelayParser.FuncExprContext ctx);
-	/**
-	 * Enter a parse tree produced by the {@code metaExpr}
-	 * labeled alternative in {@link RelayParser#expr}.
-	 * @param ctx the parse tree
-	 */
-	void enterMetaExpr(RelayParser.MetaExprContext ctx);
-	/**
-	 * Exit a parse tree produced by the {@code metaExpr}
-	 * labeled alternative in {@link RelayParser#expr}.
-	 * @param ctx the parse tree
-	 */
-	void exitMetaExpr(RelayParser.MetaExprContext ctx);
-	/**
-	 * Enter a parse tree produced by the {@code tensor}
-	 * labeled alternative in {@link RelayParser#expr}.
-	 * @param ctx the parse tree
-	 */
-	void enterTensor(RelayParser.TensorContext ctx);
-	/**
-	 * Exit a parse tree produced by the {@code tensor}
-	 * labeled alternative in {@link RelayParser#expr}.
-	 * @param ctx the parse tree
-	 */
-	void exitTensor(RelayParser.TensorContext ctx);
-	/**
-	 * Enter a parse tree produced by the {@code graph}
-	 * labeled alternative in {@link RelayParser#expr}.
-	 * @param ctx the parse tree
-	 */
-	void enterGraph(RelayParser.GraphContext ctx);
-	/**
-	 * Exit a parse tree produced by the {@code graph}
-	 * labeled alternative in {@link RelayParser#expr}.
-	 * @param ctx the parse tree
-	 */
-	void exitGraph(RelayParser.GraphContext ctx);
-	/**
-	 * Enter a parse tree produced by the {@code identExpr}
-	 * labeled alternative in {@link RelayParser#expr}.
-	 * @param ctx the parse tree
-	 */
-	void enterIdentExpr(RelayParser.IdentExprContext ctx);
-	/**
-	 * Exit a parse tree produced by the {@code identExpr}
-	 * labeled alternative in {@link RelayParser#expr}.
-	 * @param ctx the parse tree
-	 */
-	void exitIdentExpr(RelayParser.IdentExprContext ctx);
-	/**
-	 * Enter a parse tree produced by the {@code stringExpr}
-	 * labeled alternative in {@link RelayParser#expr}.
-	 * @param ctx the parse tree
-	 */
-	void enterStringExpr(RelayParser.StringExprContext ctx);
-	/**
-	 * Exit a parse tree produced by the {@code stringExpr}
-	 * labeled alternative in {@link RelayParser#expr}.
-	 * @param ctx the parse tree
-	 */
-	void exitStringExpr(RelayParser.StringExprContext ctx);
-	/**
-	 * Enter a parse tree produced by the {@code call}
-	 * labeled alternative in {@link RelayParser#expr}.
-	 * @param ctx the parse tree
-	 */
-	void enterCall(RelayParser.CallContext ctx);
-	/**
-	 * Exit a parse tree produced by the {@code call}
-	 * labeled alternative in {@link RelayParser#expr}.
-	 * @param ctx the parse tree
-	 */
-	void exitCall(RelayParser.CallContext ctx);
-	/**
-	 * Enter a parse tree produced by the {@code neg}
-	 * labeled alternative in {@link RelayParser#expr}.
-	 * @param ctx the parse tree
-	 */
-	void enterNeg(RelayParser.NegContext ctx);
-	/**
-	 * Exit a parse tree produced by the {@code neg}
-	 * labeled alternative in {@link RelayParser#expr}.
-	 * @param ctx the parse tree
-	 */
-	void exitNeg(RelayParser.NegContext ctx);
-	/**
-	 * Enter a parse tree produced by the {@code tuple}
-	 * labeled alternative in {@link RelayParser#expr}.
-	 * @param ctx the parse tree
-	 */
-	void enterTuple(RelayParser.TupleContext ctx);
-	/**
-	 * Exit a parse tree produced by the {@code tuple}
-	 * labeled alternative in {@link RelayParser#expr}.
-	 * @param ctx the parse tree
-	 */
-	void exitTuple(RelayParser.TupleContext ctx);
-	/**
-	 * Enter a parse tree produced by the {@code paren}
-	 * labeled alternative in {@link RelayParser#expr}.
-	 * @param ctx the parse tree
-	 */
-	void enterParen(RelayParser.ParenContext ctx);
-	/**
-	 * Exit a parse tree produced by the {@code paren}
-	 * labeled alternative in {@link RelayParser#expr}.
-	 * @param ctx the parse tree
-	 */
-	void exitParen(RelayParser.ParenContext ctx);
-	/**
-	 * Enter a parse tree produced by the {@code scalarExpr}
-	 * labeled alternative in {@link RelayParser#expr}.
-	 * @param ctx the parse tree
-	 */
-	void enterScalarExpr(RelayParser.ScalarExprContext ctx);
-	/**
-	 * Exit a parse tree produced by the {@code scalarExpr}
-	 * labeled alternative in {@link RelayParser#expr}.
-	 * @param ctx the parse tree
-	 */
-	void exitScalarExpr(RelayParser.ScalarExprContext ctx);
-	/**
-	 * Enter a parse tree produced by the {@code let}
-	 * labeled alternative in {@link RelayParser#expr}.
-	 * @param ctx the parse tree
-	 */
-	void enterLet(RelayParser.LetContext ctx);
-	/**
-	 * Exit a parse tree produced by the {@code let}
-	 * labeled alternative in {@link RelayParser#expr}.
-	 * @param ctx the parse tree
-	 */
-	void exitLet(RelayParser.LetContext ctx);
-	/**
-	 * Enter a parse tree produced by the {@code projection}
-	 * labeled alternative in {@link RelayParser#expr}.
-	 * @param ctx the parse tree
-	 */
-	void enterProjection(RelayParser.ProjectionContext ctx);
-	/**
-	 * Exit a parse tree produced by the {@code projection}
-	 * labeled alternative in {@link RelayParser#expr}.
-	 * @param ctx the parse tree
-	 */
-	void exitProjection(RelayParser.ProjectionContext ctx);
-	/**
-	 * Enter a parse tree produced by the {@code ifElse}
-	 * labeled alternative in {@link RelayParser#expr}.
-	 * @param ctx the parse tree
-	 */
-	void enterIfElse(RelayParser.IfElseContext ctx);
-	/**
-	 * Exit a parse tree produced by the {@code ifElse}
-	 * labeled alternative in {@link RelayParser#expr}.
-	 * @param ctx the parse tree
-	 */
-	void exitIfElse(RelayParser.IfElseContext ctx);
-	/**
-	 * Enter a parse tree produced by the {@code binOp}
-	 * labeled alternative in {@link RelayParser#expr}.
-	 * @param ctx the parse tree
-	 */
-	void enterBinOp(RelayParser.BinOpContext ctx);
-	/**
-	 * Exit a parse tree produced by the {@code binOp}
-	 * labeled alternative in {@link RelayParser#expr}.
-	 * @param ctx the parse tree
-	 */
-	void exitBinOp(RelayParser.BinOpContext ctx);
-	/**
-	 * Enter a parse tree produced by {@link RelayParser#func}.
-	 * @param ctx the parse tree
-	 */
-	void enterFunc(RelayParser.FuncContext ctx);
-	/**
-	 * Exit a parse tree produced by {@link RelayParser#func}.
-	 * @param ctx the parse tree
-	 */
-	void exitFunc(RelayParser.FuncContext ctx);
-	/**
-	 * Enter a parse tree produced by {@link RelayParser#defn}.
-	 * @param ctx the parse tree
-	 */
-	void enterDefn(RelayParser.DefnContext ctx);
-	/**
-	 * Exit a parse tree produced by {@link RelayParser#defn}.
-	 * @param ctx the parse tree
-	 */
-	void exitDefn(RelayParser.DefnContext ctx);
-	/**
-	 * Enter a parse tree produced by {@link RelayParser#adtDefn}.
-	 * @param ctx the parse tree
-	 */
-	void enterAdtDefn(RelayParser.AdtDefnContext ctx);
-	/**
-	 * Exit a parse tree produced by {@link RelayParser#adtDefn}.
-	 * @param ctx the parse tree
-	 */
-	void exitAdtDefn(RelayParser.AdtDefnContext ctx);
-	/**
-	 * Enter a parse tree produced by {@link RelayParser#adtVariant}.
-	 * @param ctx the parse tree
-	 */
-	void enterAdtVariant(RelayParser.AdtVariantContext ctx);
-	/**
-	 * Exit a parse tree produced by {@link RelayParser#adtVariant}.
-	 * @param ctx the parse tree
-	 */
-	void exitAdtVariant(RelayParser.AdtVariantContext ctx);
-	/**
-	 * Enter a parse tree produced by the {@code argNoAttr}
-	 * labeled alternative in {@link RelayParser#argList}.
-	 * @param ctx the parse tree
-	 */
-	void enterArgNoAttr(RelayParser.ArgNoAttrContext ctx);
-	/**
-	 * Exit a parse tree produced by the {@code argNoAttr}
-	 * labeled alternative in {@link RelayParser#argList}.
-	 * @param ctx the parse tree
-	 */
-	void exitArgNoAttr(RelayParser.ArgNoAttrContext ctx);
-	/**
-	 * Enter a parse tree produced by the {@code argWithAttr}
-	 * labeled alternative in {@link RelayParser#argList}.
-	 * @param ctx the parse tree
-	 */
-	void enterArgWithAttr(RelayParser.ArgWithAttrContext ctx);
-	/**
-	 * Exit a parse tree produced by the {@code argWithAttr}
-	 * labeled alternative in {@link RelayParser#argList}.
-	 * @param ctx the parse tree
-	 */
-	void exitArgWithAttr(RelayParser.ArgWithAttrContext ctx);
-	/**
-	 * Enter a parse tree produced by {@link RelayParser#varList}.
-	 * @param ctx the parse tree
-	 */
-	void enterVarList(RelayParser.VarListContext ctx);
-	/**
-	 * Exit a parse tree produced by {@link RelayParser#varList}.
-	 * @param ctx the parse tree
-	 */
-	void exitVarList(RelayParser.VarListContext ctx);
-	/**
-	 * Enter a parse tree produced by {@link RelayParser#var}.
-	 * @param ctx the parse tree
-	 */
-	void enterVar(RelayParser.VarContext ctx);
-	/**
-	 * Exit a parse tree produced by {@link RelayParser#var}.
-	 * @param ctx the parse tree
-	 */
-	void exitVar(RelayParser.VarContext ctx);
-	/**
-	 * Enter a parse tree produced by {@link RelayParser#attrSeq}.
-	 * @param ctx the parse tree
-	 */
-	void enterAttrSeq(RelayParser.AttrSeqContext ctx);
-	/**
-	 * Exit a parse tree produced by {@link RelayParser#attrSeq}.
-	 * @param ctx the parse tree
-	 */
-	void exitAttrSeq(RelayParser.AttrSeqContext ctx);
-	/**
-	 * Enter a parse tree produced by {@link RelayParser#attr}.
-	 * @param ctx the parse tree
-	 */
-	void enterAttr(RelayParser.AttrContext ctx);
-	/**
-	 * Exit a parse tree produced by {@link RelayParser#attr}.
-	 * @param ctx the parse tree
-	 */
-	void exitAttr(RelayParser.AttrContext ctx);
-	/**
-	 * Enter a parse tree produced by {@link RelayParser#typeParamList}.
-	 * @param ctx the parse tree
-	 */
-	void enterTypeParamList(RelayParser.TypeParamListContext ctx);
-	/**
-	 * Exit a parse tree produced by {@link RelayParser#typeParamList}.
-	 * @param ctx the parse tree
-	 */
-	void exitTypeParamList(RelayParser.TypeParamListContext ctx);
-	/**
-	 * Enter a parse tree produced by the {@code tupleType}
-	 * labeled alternative in {@link RelayParser#type_}.
-	 * @param ctx the parse tree
-	 */
-	void enterTupleType(RelayParser.TupleTypeContext ctx);
-	/**
-	 * Exit a parse tree produced by the {@code tupleType}
-	 * labeled alternative in {@link RelayParser#type_}.
-	 * @param ctx the parse tree
-	 */
-	void exitTupleType(RelayParser.TupleTypeContext ctx);
-	/**
-	 * Enter a parse tree produced by the {@code typeIdentType}
-	 * labeled alternative in {@link RelayParser#type_}.
-	 * @param ctx the parse tree
-	 */
-	void enterTypeIdentType(RelayParser.TypeIdentTypeContext ctx);
-	/**
-	 * Exit a parse tree produced by the {@code typeIdentType}
-	 * labeled alternative in {@link RelayParser#type_}.
-	 * @param ctx the parse tree
-	 */
-	void exitTypeIdentType(RelayParser.TypeIdentTypeContext ctx);
-	/**
-	 * Enter a parse tree produced by the {@code tensorType}
-	 * labeled alternative in {@link RelayParser#type_}.
-	 * @param ctx the parse tree
-	 */
-	void enterTensorType(RelayParser.TensorTypeContext ctx);
-	/**
-	 * Exit a parse tree produced by the {@code tensorType}
-	 * labeled alternative in {@link RelayParser#type_}.
-	 * @param ctx the parse tree
-	 */
-	void exitTensorType(RelayParser.TensorTypeContext ctx);
-	/**
-	 * Enter a parse tree produced by the {@code funcType}
-	 * labeled alternative in {@link RelayParser#type_}.
-	 * @param ctx the parse tree
-	 */
-	void enterFuncType(RelayParser.FuncTypeContext ctx);
-	/**
-	 * Exit a parse tree produced by the {@code funcType}
-	 * labeled alternative in {@link RelayParser#type_}.
-	 * @param ctx the parse tree
-	 */
-	void exitFuncType(RelayParser.FuncTypeContext ctx);
-	/**
-	 * Enter a parse tree produced by the {@code incompleteType}
-	 * labeled alternative in {@link RelayParser#type_}.
-	 * @param ctx the parse tree
-	 */
-	void enterIncompleteType(RelayParser.IncompleteTypeContext ctx);
-	/**
-	 * Exit a parse tree produced by the {@code incompleteType}
-	 * labeled alternative in {@link RelayParser#type_}.
-	 * @param ctx the parse tree
-	 */
-	void exitIncompleteType(RelayParser.IncompleteTypeContext ctx);
-	/**
-	 * Enter a parse tree produced by the {@code intType}
-	 * labeled alternative in {@link RelayParser#type_}.
-	 * @param ctx the parse tree
-	 */
-	void enterIntType(RelayParser.IntTypeContext ctx);
-	/**
-	 * Exit a parse tree produced by the {@code intType}
-	 * labeled alternative in {@link RelayParser#type_}.
-	 * @param ctx the parse tree
-	 */
-	void exitIntType(RelayParser.IntTypeContext ctx);
-	/**
-	 * Enter a parse tree produced by {@link RelayParser#shapeList}.
-	 * @param ctx the parse tree
-	 */
-	void enterShapeList(RelayParser.ShapeListContext ctx);
-	/**
-	 * Exit a parse tree produced by {@link RelayParser#shapeList}.
-	 * @param ctx the parse tree
-	 */
-	void exitShapeList(RelayParser.ShapeListContext ctx);
-	/**
-	 * Enter a parse tree produced by {@link RelayParser#meta}.
-	 * @param ctx the parse tree
-	 */
-	void enterMeta(RelayParser.MetaContext ctx);
-	/**
-	 * Exit a parse tree produced by {@link RelayParser#meta}.
-	 * @param ctx the parse tree
-	 */
-	void exitMeta(RelayParser.MetaContext ctx);
-	/**
-	 * Enter a parse tree produced by the {@code metaShape}
-	 * labeled alternative in {@link RelayParser#shape}.
-	 * @param ctx the parse tree
-	 */
-	void enterMetaShape(RelayParser.MetaShapeContext ctx);
-	/**
-	 * Exit a parse tree produced by the {@code metaShape}
-	 * labeled alternative in {@link RelayParser#shape}.
-	 * @param ctx the parse tree
-	 */
-	void exitMetaShape(RelayParser.MetaShapeContext ctx);
-	/**
-	 * Enter a parse tree produced by the {@code parensShape}
-	 * labeled alternative in {@link RelayParser#shape}.
-	 * @param ctx the parse tree
-	 */
-	void enterParensShape(RelayParser.ParensShapeContext ctx);
-	/**
-	 * Exit a parse tree produced by the {@code parensShape}
-	 * labeled alternative in {@link RelayParser#shape}.
-	 * @param ctx the parse tree
-	 */
-	void exitParensShape(RelayParser.ParensShapeContext ctx);
-	/**
-	 * Enter a parse tree produced by the {@code intShape}
-	 * labeled alternative in {@link RelayParser#shape}.
-	 * @param ctx the parse tree
-	 */
-	void enterIntShape(RelayParser.IntShapeContext ctx);
-	/**
-	 * Exit a parse tree produced by the {@code intShape}
-	 * labeled alternative in {@link RelayParser#shape}.
-	 * @param ctx the parse tree
-	 */
-	void exitIntShape(RelayParser.IntShapeContext ctx);
-	/**
-	 * Enter a parse tree produced by {@link RelayParser#typeIdent}.
-	 * @param ctx the parse tree
-	 */
-	void enterTypeIdent(RelayParser.TypeIdentContext ctx);
-	/**
-	 * Exit a parse tree produced by {@link RelayParser#typeIdent}.
-	 * @param ctx the parse tree
-	 */
-	void exitTypeIdent(RelayParser.TypeIdentContext ctx);
-	/**
-	 * Enter a parse tree produced by {@link RelayParser#body}.
-	 * @param ctx the parse tree
-	 */
-	void enterBody(RelayParser.BodyContext ctx);
-	/**
-	 * Exit a parse tree produced by {@link RelayParser#body}.
-	 * @param ctx the parse tree
-	 */
-	void exitBody(RelayParser.BodyContext ctx);
-	/**
-	 * Enter a parse tree produced by the {@code scalarFloat}
-	 * labeled alternative in {@link RelayParser#scalar}.
-	 * @param ctx the parse tree
-	 */
-	void enterScalarFloat(RelayParser.ScalarFloatContext ctx);
-	/**
-	 * Exit a parse tree produced by the {@code scalarFloat}
-	 * labeled alternative in {@link RelayParser#scalar}.
-	 * @param ctx the parse tree
-	 */
-	void exitScalarFloat(RelayParser.ScalarFloatContext ctx);
-	/**
-	 * Enter a parse tree produced by the {@code scalarInt}
-	 * labeled alternative in {@link RelayParser#scalar}.
-	 * @param ctx the parse tree
-	 */
-	void enterScalarInt(RelayParser.ScalarIntContext ctx);
-	/**
-	 * Exit a parse tree produced by the {@code scalarInt}
-	 * labeled alternative in {@link RelayParser#scalar}.
-	 * @param ctx the parse tree
-	 */
-	void exitScalarInt(RelayParser.ScalarIntContext ctx);
-	/**
-	 * Enter a parse tree produced by the {@code scalarBool}
-	 * labeled alternative in {@link RelayParser#scalar}.
-	 * @param ctx the parse tree
-	 */
-	void enterScalarBool(RelayParser.ScalarBoolContext ctx);
-	/**
-	 * Exit a parse tree produced by the {@code scalarBool}
-	 * labeled alternative in {@link RelayParser#scalar}.
-	 * @param ctx the parse tree
-	 */
-	void exitScalarBool(RelayParser.ScalarBoolContext ctx);
-	/**
-	 * Enter a parse tree produced by {@link RelayParser#ident}.
-	 * @param ctx the parse tree
-	 */
-	void enterIdent(RelayParser.IdentContext ctx);
-	/**
-	 * Exit a parse tree produced by {@link RelayParser#ident}.
-	 * @param ctx the parse tree
-	 */
-	void exitIdent(RelayParser.IdentContext ctx);
-}
\ No newline at end of file
diff --git a/python/tvm/relay/grammar/RelayParser.java b/python/tvm/relay/grammar/RelayParser.java
deleted file mode 100644
index 44914d077034..000000000000
--- a/python/tvm/relay/grammar/RelayParser.java
+++ /dev/null
@@ -1,2786 +0,0 @@
-// Generated from Relay.g4 by ANTLR 4.7.2
-import org.antlr.v4.runtime.atn.*;
-import org.antlr.v4.runtime.dfa.DFA;
-import org.antlr.v4.runtime.*;
-import org.antlr.v4.runtime.misc.*;
-import org.antlr.v4.runtime.tree.*;
-import java.util.List;
-import java.util.Iterator;
-import java.util.ArrayList;
-
-@SuppressWarnings({"all", "warnings", "unchecked", "unused", "cast"})
-public class RelayParser extends Parser {
-	static { RuntimeMetaData.checkVersion("4.7.2", RuntimeMetaData.VERSION); }
-
-	protected static final DFA[] _decisionToDFA;
-	protected static final PredictionContextCache _sharedContextCache =
-		new PredictionContextCache();
-	public static final int
-		T__0=1, T__1=2, T__2=3, T__3=4, T__4=5, T__5=6, T__6=7, T__7=8, T__8=9, 
-		T__9=10, T__10=11, T__11=12, T__12=13, T__13=14, T__14=15, T__15=16, T__16=17, 
-		T__17=18, T__18=19, T__19=20, T__20=21, T__21=22, T__22=23, T__23=24, 
-		SEMVER=25, COMMENT=26, WS=27, LINE_COMMENT=28, QUOTED_STRING=29, MUL=30, 
-		DIV=31, ADD=32, SUB=33, LT=34, GT=35, LE=36, GE=37, EQ=38, NE=39, BOOL_LIT=40, 
-		CNAME=41, GLOBAL_VAR=42, LOCAL_VAR=43, GRAPH_VAR=44, DATATYPE=45, FLOAT=46, 
-		NAT=47, METADATA=48;
-	public static final int
-		RULE_opIdent = 0, RULE_prog = 1, RULE_exprList = 2, RULE_callList = 3, 
-		RULE_expr = 4, RULE_func = 5, RULE_defn = 6, RULE_adtDefn = 7, RULE_adtVariant = 8, 
-		RULE_argList = 9, RULE_varList = 10, RULE_var = 11, RULE_attrSeq = 12, 
-		RULE_attr = 13, RULE_typeParamList = 14, RULE_type_ = 15, RULE_shapeList = 16, 
-		RULE_meta = 17, RULE_shape = 18, RULE_typeIdent = 19, RULE_body = 20, 
-		RULE_scalar = 21, RULE_ident = 22;
-	private static String[] makeRuleNames() {
-		return new String[] {
-			"opIdent", "prog", "exprList", "callList", "expr", "func", "defn", "adtDefn", 
-			"adtVariant", "argList", "varList", "var", "attrSeq", "attr", "typeParamList", 
-			"type_", "shapeList", "meta", "shape", "typeIdent", "body", "scalar", 
-			"ident"
-		};
-	}
-	public static final String[] ruleNames = makeRuleNames();
-
-	private static String[] makeLiteralNames() {
-		return new String[] {
-			null, "','", "'('", "')'", "'{'", "'}'", "'.'", "'['", "']'", "'if'", 
-			"'else'", "'let'", "'='", "';'", "';;'", "'fn'", "'->'", "'def'", "'type'", 
-			"'|'", "', '", "':'", "'Tensor'", "'_'", "'meta'", "'v0.0.3'", null, 
-			null, null, null, "'*'", "'/'", "'+'", "'-'", "'<'", "'>'", "'<='", "'>='", 
-			"'=='", "'!='", null, null, null, null, null, "'int64'"
-		};
-	}
-	private static final String[] _LITERAL_NAMES = makeLiteralNames();
-	private static String[] makeSymbolicNames() {
-		return new String[] {
-			null, null, null, null, null, null, null, null, null, null, null, null, 
-			null, null, null, null, null, null, null, null, null, null, null, null, 
-			null, "SEMVER", "COMMENT", "WS", "LINE_COMMENT", "QUOTED_STRING", "MUL", 
-			"DIV", "ADD", "SUB", "LT", "GT", "LE", "GE", "EQ", "NE", "BOOL_LIT", 
-			"CNAME", "GLOBAL_VAR", "LOCAL_VAR", "GRAPH_VAR", "DATATYPE", "FLOAT", 
-			"NAT", "METADATA"
-		};
-	}
-	private static final String[] _SYMBOLIC_NAMES = makeSymbolicNames();
-	public static final Vocabulary VOCABULARY = new VocabularyImpl(_LITERAL_NAMES, _SYMBOLIC_NAMES);
-
-	/**
-	 * @deprecated Use {@link #VOCABULARY} instead.
-	 */
-	@Deprecated
-	public static final String[] tokenNames;
-	static {
-		tokenNames = new String[_SYMBOLIC_NAMES.length];
-		for (int i = 0; i < tokenNames.length; i++) {
-			tokenNames[i] = VOCABULARY.getLiteralName(i);
-			if (tokenNames[i] == null) {
-				tokenNames[i] = VOCABULARY.getSymbolicName(i);
-			}
-
-			if (tokenNames[i] == null) {
-				tokenNames[i] = "<INVALID>";
-			}
-		}
-	}
-
-	@Override
-	@Deprecated
-	public String[] getTokenNames() {
-		return tokenNames;
-	}
-
-	@Override
-
-	public Vocabulary getVocabulary() {
-		return VOCABULARY;
-	}
-
-	@Override
-	public String getGrammarFileName() { return "Relay.g4"; }
-
-	@Override
-	public String[] getRuleNames() { return ruleNames; }
-
-	@Override
-	public String getSerializedATN() { return _serializedATN; }
-
-	@Override
-	public ATN getATN() { return _ATN; }
-
-	public RelayParser(TokenStream input) {
-		super(input);
-		_interp = new ParserATNSimulator(this,_ATN,_decisionToDFA,_sharedContextCache);
-	}
-
-	public static class OpIdentContext extends ParserRuleContext {
-		public TerminalNode CNAME() { return getToken(RelayParser.CNAME, 0); }
-		public OpIdentContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_opIdent; }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterOpIdent(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitOpIdent(this);
-		}
-	}
-
-	public final OpIdentContext opIdent() throws RecognitionException {
-		OpIdentContext _localctx = new OpIdentContext(_ctx, getState());
-		enterRule(_localctx, 0, RULE_opIdent);
-		try {
-			enterOuterAlt(_localctx, 1);
-			{
-			setState(46);
-			match(CNAME);
-			}
-		}
-		catch (RecognitionException re) {
-			_localctx.exception = re;
-			_errHandler.reportError(this, re);
-			_errHandler.recover(this, re);
-		}
-		finally {
-			exitRule();
-		}
-		return _localctx;
-	}
-
-	public static class ProgContext extends ParserRuleContext {
-		public TerminalNode SEMVER() { return getToken(RelayParser.SEMVER, 0); }
-		public TerminalNode EOF() { return getToken(RelayParser.EOF, 0); }
-		public ExprContext expr() {
-			return getRuleContext(ExprContext.class,0);
-		}
-		public TerminalNode METADATA() { return getToken(RelayParser.METADATA, 0); }
-		public List<DefnContext> defn() {
-			return getRuleContexts(DefnContext.class);
-		}
-		public DefnContext defn(int i) {
-			return getRuleContext(DefnContext.class,i);
-		}
-		public ProgContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_prog; }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterProg(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitProg(this);
-		}
-	}
-
-	public final ProgContext prog() throws RecognitionException {
-		ProgContext _localctx = new ProgContext(_ctx, getState());
-		enterRule(_localctx, 2, RULE_prog);
-		int _la;
-		try {
-			enterOuterAlt(_localctx, 1);
-			{
-			setState(48);
-			match(SEMVER);
-			setState(56);
-			_errHandler.sync(this);
-			switch (_input.LA(1)) {
-			case EOF:
-			case T__16:
-			case T__17:
-			case METADATA:
-				{
-				setState(52);
-				_errHandler.sync(this);
-				_la = _input.LA(1);
-				while (_la==T__16 || _la==T__17) {
-					{
-					{
-					setState(49);
-					defn();
-					}
-					}
-					setState(54);
-					_errHandler.sync(this);
-					_la = _input.LA(1);
-				}
-				}
-				break;
-			case T__1:
-			case T__3:
-			case T__6:
-			case T__8:
-			case T__10:
-			case T__14:
-			case T__23:
-			case QUOTED_STRING:
-			case SUB:
-			case BOOL_LIT:
-			case CNAME:
-			case GLOBAL_VAR:
-			case LOCAL_VAR:
-			case GRAPH_VAR:
-			case FLOAT:
-			case NAT:
-				{
-				setState(55);
-				expr(0);
-				}
-				break;
-			default:
-				throw new NoViableAltException(this);
-			}
-			setState(59);
-			_errHandler.sync(this);
-			_la = _input.LA(1);
-			if (_la==METADATA) {
-				{
-				setState(58);
-				match(METADATA);
-				}
-			}
-
-			setState(61);
-			match(EOF);
-			}
-		}
-		catch (RecognitionException re) {
-			_localctx.exception = re;
-			_errHandler.reportError(this, re);
-			_errHandler.recover(this, re);
-		}
-		finally {
-			exitRule();
-		}
-		return _localctx;
-	}
-
-	public static class ExprListContext extends ParserRuleContext {
-		public List<ExprContext> expr() {
-			return getRuleContexts(ExprContext.class);
-		}
-		public ExprContext expr(int i) {
-			return getRuleContext(ExprContext.class,i);
-		}
-		public ExprListContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_exprList; }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterExprList(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitExprList(this);
-		}
-	}
-
-	public final ExprListContext exprList() throws RecognitionException {
-		ExprListContext _localctx = new ExprListContext(_ctx, getState());
-		enterRule(_localctx, 4, RULE_exprList);
-		int _la;
-		try {
-			enterOuterAlt(_localctx, 1);
-			{
-			setState(71);
-			_errHandler.sync(this);
-			_la = _input.LA(1);
-			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__1) | (1L << T__3) | (1L << T__6) | (1L << T__8) | (1L << T__10) | (1L << T__14) | (1L << T__23) | (1L << QUOTED_STRING) | (1L << SUB) | (1L << BOOL_LIT) | (1L << CNAME) | (1L << GLOBAL_VAR) | (1L << LOCAL_VAR) | (1L << GRAPH_VAR) | (1L << FLOAT) | (1L << NAT))) != 0)) {
-				{
-				setState(63);
-				expr(0);
-				setState(68);
-				_errHandler.sync(this);
-				_la = _input.LA(1);
-				while (_la==T__0) {
-					{
-					{
-					setState(64);
-					match(T__0);
-					setState(65);
-					expr(0);
-					}
-					}
-					setState(70);
-					_errHandler.sync(this);
-					_la = _input.LA(1);
-				}
-				}
-			}
-
-			}
-		}
-		catch (RecognitionException re) {
-			_localctx.exception = re;
-			_errHandler.reportError(this, re);
-			_errHandler.recover(this, re);
-		}
-		finally {
-			exitRule();
-		}
-		return _localctx;
-	}
-
-	public static class CallListContext extends ParserRuleContext {
-		public CallListContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_callList; }
-	 
-		public CallListContext() { }
-		public void copyFrom(CallListContext ctx) {
-			super.copyFrom(ctx);
-		}
-	}
-	public static class CallWithAttrContext extends CallListContext {
-		public AttrSeqContext attrSeq() {
-			return getRuleContext(AttrSeqContext.class,0);
-		}
-		public List<ExprContext> expr() {
-			return getRuleContexts(ExprContext.class);
-		}
-		public ExprContext expr(int i) {
-			return getRuleContext(ExprContext.class,i);
-		}
-		public CallWithAttrContext(CallListContext ctx) { copyFrom(ctx); }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterCallWithAttr(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitCallWithAttr(this);
-		}
-	}
-	public static class CallNoAttrContext extends CallListContext {
-		public ExprListContext exprList() {
-			return getRuleContext(ExprListContext.class,0);
-		}
-		public CallNoAttrContext(CallListContext ctx) { copyFrom(ctx); }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterCallNoAttr(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitCallNoAttr(this);
-		}
-	}
-
-	public final CallListContext callList() throws RecognitionException {
-		CallListContext _localctx = new CallListContext(_ctx, getState());
-		enterRule(_localctx, 6, RULE_callList);
-		try {
-			int _alt;
-			setState(83);
-			_errHandler.sync(this);
-			switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
-			case 1:
-				_localctx = new CallNoAttrContext(_localctx);
-				enterOuterAlt(_localctx, 1);
-				{
-				setState(73);
-				exprList();
-				}
-				break;
-			case 2:
-				_localctx = new CallWithAttrContext(_localctx);
-				enterOuterAlt(_localctx, 2);
-				{
-				setState(79);
-				_errHandler.sync(this);
-				_alt = getInterpreter().adaptivePredict(_input,5,_ctx);
-				while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
-					if ( _alt==1 ) {
-						{
-						{
-						setState(74);
-						expr(0);
-						setState(75);
-						match(T__0);
-						}
-						} 
-					}
-					setState(81);
-					_errHandler.sync(this);
-					_alt = getInterpreter().adaptivePredict(_input,5,_ctx);
-				}
-				setState(82);
-				attrSeq();
-				}
-				break;
-			}
-		}
-		catch (RecognitionException re) {
-			_localctx.exception = re;
-			_errHandler.reportError(this, re);
-			_errHandler.recover(this, re);
-		}
-		finally {
-			exitRule();
-		}
-		return _localctx;
-	}
-
-	public static class ExprContext extends ParserRuleContext {
-		public ExprContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_expr; }
-	 
-		public ExprContext() { }
-		public void copyFrom(ExprContext ctx) {
-			super.copyFrom(ctx);
-		}
-	}
-	public static class FuncExprContext extends ExprContext {
-		public FuncContext func() {
-			return getRuleContext(FuncContext.class,0);
-		}
-		public FuncExprContext(ExprContext ctx) { copyFrom(ctx); }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterFuncExpr(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitFuncExpr(this);
-		}
-	}
-	public static class MetaExprContext extends ExprContext {
-		public MetaContext meta() {
-			return getRuleContext(MetaContext.class,0);
-		}
-		public MetaExprContext(ExprContext ctx) { copyFrom(ctx); }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterMetaExpr(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitMetaExpr(this);
-		}
-	}
-	public static class TensorContext extends ExprContext {
-		public List<ExprContext> expr() {
-			return getRuleContexts(ExprContext.class);
-		}
-		public ExprContext expr(int i) {
-			return getRuleContext(ExprContext.class,i);
-		}
-		public TensorContext(ExprContext ctx) { copyFrom(ctx); }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterTensor(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitTensor(this);
-		}
-	}
-	public static class GraphContext extends ExprContext {
-		public TerminalNode GRAPH_VAR() { return getToken(RelayParser.GRAPH_VAR, 0); }
-		public List<ExprContext> expr() {
-			return getRuleContexts(ExprContext.class);
-		}
-		public ExprContext expr(int i) {
-			return getRuleContext(ExprContext.class,i);
-		}
-		public GraphContext(ExprContext ctx) { copyFrom(ctx); }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterGraph(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitGraph(this);
-		}
-	}
-	public static class IdentExprContext extends ExprContext {
-		public IdentContext ident() {
-			return getRuleContext(IdentContext.class,0);
-		}
-		public IdentExprContext(ExprContext ctx) { copyFrom(ctx); }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterIdentExpr(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitIdentExpr(this);
-		}
-	}
-	public static class StringExprContext extends ExprContext {
-		public TerminalNode QUOTED_STRING() { return getToken(RelayParser.QUOTED_STRING, 0); }
-		public StringExprContext(ExprContext ctx) { copyFrom(ctx); }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterStringExpr(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitStringExpr(this);
-		}
-	}
-	public static class CallContext extends ExprContext {
-		public ExprContext expr() {
-			return getRuleContext(ExprContext.class,0);
-		}
-		public CallListContext callList() {
-			return getRuleContext(CallListContext.class,0);
-		}
-		public CallContext(ExprContext ctx) { copyFrom(ctx); }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterCall(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitCall(this);
-		}
-	}
-	public static class NegContext extends ExprContext {
-		public TerminalNode SUB() { return getToken(RelayParser.SUB, 0); }
-		public ExprContext expr() {
-			return getRuleContext(ExprContext.class,0);
-		}
-		public NegContext(ExprContext ctx) { copyFrom(ctx); }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterNeg(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitNeg(this);
-		}
-	}
-	public static class TupleContext extends ExprContext {
-		public List<ExprContext> expr() {
-			return getRuleContexts(ExprContext.class);
-		}
-		public ExprContext expr(int i) {
-			return getRuleContext(ExprContext.class,i);
-		}
-		public TupleContext(ExprContext ctx) { copyFrom(ctx); }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterTuple(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitTuple(this);
-		}
-	}
-	public static class ParenContext extends ExprContext {
-		public ExprContext expr() {
-			return getRuleContext(ExprContext.class,0);
-		}
-		public ParenContext(ExprContext ctx) { copyFrom(ctx); }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterParen(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitParen(this);
-		}
-	}
-	public static class ScalarExprContext extends ExprContext {
-		public ScalarContext scalar() {
-			return getRuleContext(ScalarContext.class,0);
-		}
-		public ScalarExprContext(ExprContext ctx) { copyFrom(ctx); }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterScalarExpr(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitScalarExpr(this);
-		}
-	}
-	public static class LetContext extends ExprContext {
-		public VarContext var() {
-			return getRuleContext(VarContext.class,0);
-		}
-		public List<ExprContext> expr() {
-			return getRuleContexts(ExprContext.class);
-		}
-		public ExprContext expr(int i) {
-			return getRuleContext(ExprContext.class,i);
-		}
-		public LetContext(ExprContext ctx) { copyFrom(ctx); }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterLet(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitLet(this);
-		}
-	}
-	public static class ProjectionContext extends ExprContext {
-		public ExprContext expr() {
-			return getRuleContext(ExprContext.class,0);
-		}
-		public TerminalNode NAT() { return getToken(RelayParser.NAT, 0); }
-		public ProjectionContext(ExprContext ctx) { copyFrom(ctx); }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterProjection(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitProjection(this);
-		}
-	}
-	public static class IfElseContext extends ExprContext {
-		public ExprContext expr() {
-			return getRuleContext(ExprContext.class,0);
-		}
-		public List<BodyContext> body() {
-			return getRuleContexts(BodyContext.class);
-		}
-		public BodyContext body(int i) {
-			return getRuleContext(BodyContext.class,i);
-		}
-		public IfElseContext(ExprContext ctx) { copyFrom(ctx); }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterIfElse(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitIfElse(this);
-		}
-	}
-	public static class BinOpContext extends ExprContext {
-		public Token op;
-		public List<ExprContext> expr() {
-			return getRuleContexts(ExprContext.class);
-		}
-		public ExprContext expr(int i) {
-			return getRuleContext(ExprContext.class,i);
-		}
-		public TerminalNode MUL() { return getToken(RelayParser.MUL, 0); }
-		public TerminalNode DIV() { return getToken(RelayParser.DIV, 0); }
-		public TerminalNode ADD() { return getToken(RelayParser.ADD, 0); }
-		public TerminalNode SUB() { return getToken(RelayParser.SUB, 0); }
-		public TerminalNode LT() { return getToken(RelayParser.LT, 0); }
-		public TerminalNode GT() { return getToken(RelayParser.GT, 0); }
-		public TerminalNode LE() { return getToken(RelayParser.LE, 0); }
-		public TerminalNode GE() { return getToken(RelayParser.GE, 0); }
-		public TerminalNode EQ() { return getToken(RelayParser.EQ, 0); }
-		public TerminalNode NE() { return getToken(RelayParser.NE, 0); }
-		public BinOpContext(ExprContext ctx) { copyFrom(ctx); }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterBinOp(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitBinOp(this);
-		}
-	}
-
-	public final ExprContext expr() throws RecognitionException {
-		return expr(0);
-	}
-
-	private ExprContext expr(int _p) throws RecognitionException {
-		ParserRuleContext _parentctx = _ctx;
-		int _parentState = getState();
-		ExprContext _localctx = new ExprContext(_ctx, _parentState);
-		ExprContext _prevctx = _localctx;
-		int _startState = 8;
-		enterRecursionRule(_localctx, 8, RULE_expr, _p);
-		int _la;
-		try {
-			int _alt;
-			enterOuterAlt(_localctx, 1);
-			{
-			setState(151);
-			_errHandler.sync(this);
-			switch ( getInterpreter().adaptivePredict(_input,10,_ctx) ) {
-			case 1:
-				{
-				_localctx = new ParenContext(_localctx);
-				_ctx = _localctx;
-				_prevctx = _localctx;
-
-				setState(86);
-				match(T__1);
-				setState(87);
-				expr(0);
-				setState(88);
-				match(T__2);
-				}
-				break;
-			case 2:
-				{
-				_localctx = new ParenContext(_localctx);
-				_ctx = _localctx;
-				_prevctx = _localctx;
-				setState(90);
-				match(T__3);
-				setState(91);
-				expr(0);
-				setState(92);
-				match(T__4);
-				}
-				break;
-			case 3:
-				{
-				_localctx = new NegContext(_localctx);
-				_ctx = _localctx;
-				_prevctx = _localctx;
-				setState(94);
-				match(SUB);
-				setState(95);
-				expr(19);
-				}
-				break;
-			case 4:
-				{
-				_localctx = new FuncExprContext(_localctx);
-				_ctx = _localctx;
-				_prevctx = _localctx;
-				setState(96);
-				func();
-				}
-				break;
-			case 5:
-				{
-				_localctx = new TupleContext(_localctx);
-				_ctx = _localctx;
-				_prevctx = _localctx;
-				setState(97);
-				match(T__1);
-				setState(98);
-				match(T__2);
-				}
-				break;
-			case 6:
-				{
-				_localctx = new TupleContext(_localctx);
-				_ctx = _localctx;
-				_prevctx = _localctx;
-				setState(99);
-				match(T__1);
-				setState(100);
-				expr(0);
-				setState(101);
-				match(T__0);
-				setState(102);
-				match(T__2);
-				}
-				break;
-			case 7:
-				{
-				_localctx = new TupleContext(_localctx);
-				_ctx = _localctx;
-				_prevctx = _localctx;
-				setState(104);
-				match(T__1);
-				setState(105);
-				expr(0);
-				setState(108); 
-				_errHandler.sync(this);
-				_la = _input.LA(1);
-				do {
-					{
-					{
-					setState(106);
-					match(T__0);
-					setState(107);
-					expr(0);
-					}
-					}
-					setState(110); 
-					_errHandler.sync(this);
-					_la = _input.LA(1);
-				} while ( _la==T__0 );
-				setState(112);
-				match(T__2);
-				}
-				break;
-			case 8:
-				{
-				_localctx = new TensorContext(_localctx);
-				_ctx = _localctx;
-				_prevctx = _localctx;
-				setState(114);
-				match(T__6);
-				setState(123);
-				_errHandler.sync(this);
-				_la = _input.LA(1);
-				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__1) | (1L << T__3) | (1L << T__6) | (1L << T__8) | (1L << T__10) | (1L << T__14) | (1L << T__23) | (1L << QUOTED_STRING) | (1L << SUB) | (1L << BOOL_LIT) | (1L << CNAME) | (1L << GLOBAL_VAR) | (1L << LOCAL_VAR) | (1L << GRAPH_VAR) | (1L << FLOAT) | (1L << NAT))) != 0)) {
-					{
-					setState(115);
-					expr(0);
-					setState(120);
-					_errHandler.sync(this);
-					_la = _input.LA(1);
-					while (_la==T__0) {
-						{
-						{
-						setState(116);
-						match(T__0);
-						setState(117);
-						expr(0);
-						}
-						}
-						setState(122);
-						_errHandler.sync(this);
-						_la = _input.LA(1);
-					}
-					}
-				}
-
-				setState(125);
-				match(T__7);
-				}
-				break;
-			case 9:
-				{
-				_localctx = new IfElseContext(_localctx);
-				_ctx = _localctx;
-				_prevctx = _localctx;
-				setState(126);
-				match(T__8);
-				setState(127);
-				match(T__1);
-				setState(128);
-				expr(0);
-				setState(129);
-				match(T__2);
-				setState(130);
-				body();
-				setState(131);
-				match(T__9);
-				setState(132);
-				body();
-				}
-				break;
-			case 10:
-				{
-				_localctx = new LetContext(_localctx);
-				_ctx = _localctx;
-				_prevctx = _localctx;
-				setState(134);
-				match(T__10);
-				setState(135);
-				var();
-				setState(136);
-				match(T__11);
-				setState(137);
-				expr(0);
-				setState(138);
-				match(T__12);
-				setState(139);
-				expr(7);
-				}
-				break;
-			case 11:
-				{
-				_localctx = new GraphContext(_localctx);
-				_ctx = _localctx;
-				_prevctx = _localctx;
-				setState(141);
-				match(GRAPH_VAR);
-				setState(142);
-				match(T__11);
-				setState(143);
-				expr(0);
-				setState(144);
-				match(T__12);
-				setState(145);
-				expr(5);
-				}
-				break;
-			case 12:
-				{
-				_localctx = new IdentExprContext(_localctx);
-				_ctx = _localctx;
-				_prevctx = _localctx;
-				setState(147);
-				ident();
-				}
-				break;
-			case 13:
-				{
-				_localctx = new ScalarExprContext(_localctx);
-				_ctx = _localctx;
-				_prevctx = _localctx;
-				setState(148);
-				scalar();
-				}
-				break;
-			case 14:
-				{
-				_localctx = new MetaExprContext(_localctx);
-				_ctx = _localctx;
-				_prevctx = _localctx;
-				setState(149);
-				meta();
-				}
-				break;
-			case 15:
-				{
-				_localctx = new StringExprContext(_localctx);
-				_ctx = _localctx;
-				_prevctx = _localctx;
-				setState(150);
-				match(QUOTED_STRING);
-				}
-				break;
-			}
-			_ctx.stop = _input.LT(-1);
-			setState(178);
-			_errHandler.sync(this);
-			_alt = getInterpreter().adaptivePredict(_input,12,_ctx);
-			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
-				if ( _alt==1 ) {
-					if ( _parseListeners!=null ) triggerExitRuleEvent();
-					_prevctx = _localctx;
-					{
-					setState(176);
-					_errHandler.sync(this);
-					switch ( getInterpreter().adaptivePredict(_input,11,_ctx) ) {
-					case 1:
-						{
-						_localctx = new BinOpContext(new ExprContext(_parentctx, _parentState));
-						pushNewRecursionContext(_localctx, _startState, RULE_expr);
-						setState(153);
-						if (!(precpred(_ctx, 18))) throw new FailedPredicateException(this, "precpred(_ctx, 18)");
-						setState(154);
-						((BinOpContext)_localctx).op = _input.LT(1);
-						_la = _input.LA(1);
-						if ( !(_la==MUL || _la==DIV) ) {
-							((BinOpContext)_localctx).op = (Token)_errHandler.recoverInline(this);
-						}
-						else {
-							if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
-							_errHandler.reportMatch(this);
-							consume();
-						}
-						setState(155);
-						expr(19);
-						}
-						break;
-					case 2:
-						{
-						_localctx = new BinOpContext(new ExprContext(_parentctx, _parentState));
-						pushNewRecursionContext(_localctx, _startState, RULE_expr);
-						setState(156);
-						if (!(precpred(_ctx, 17))) throw new FailedPredicateException(this, "precpred(_ctx, 17)");
-						setState(157);
-						((BinOpContext)_localctx).op = _input.LT(1);
-						_la = _input.LA(1);
-						if ( !(_la==ADD || _la==SUB) ) {
-							((BinOpContext)_localctx).op = (Token)_errHandler.recoverInline(this);
-						}
-						else {
-							if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
-							_errHandler.reportMatch(this);
-							consume();
-						}
-						setState(158);
-						expr(18);
-						}
-						break;
-					case 3:
-						{
-						_localctx = new BinOpContext(new ExprContext(_parentctx, _parentState));
-						pushNewRecursionContext(_localctx, _startState, RULE_expr);
-						setState(159);
-						if (!(precpred(_ctx, 16))) throw new FailedPredicateException(this, "precpred(_ctx, 16)");
-						setState(160);
-						((BinOpContext)_localctx).op = _input.LT(1);
-						_la = _input.LA(1);
-						if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << LT) | (1L << GT) | (1L << LE) | (1L << GE))) != 0)) ) {
-							((BinOpContext)_localctx).op = (Token)_errHandler.recoverInline(this);
-						}
-						else {
-							if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
-							_errHandler.reportMatch(this);
-							consume();
-						}
-						setState(161);
-						expr(17);
-						}
-						break;
-					case 4:
-						{
-						_localctx = new BinOpContext(new ExprContext(_parentctx, _parentState));
-						pushNewRecursionContext(_localctx, _startState, RULE_expr);
-						setState(162);
-						if (!(precpred(_ctx, 15))) throw new FailedPredicateException(this, "precpred(_ctx, 15)");
-						setState(163);
-						((BinOpContext)_localctx).op = _input.LT(1);
-						_la = _input.LA(1);
-						if ( !(_la==EQ || _la==NE) ) {
-							((BinOpContext)_localctx).op = (Token)_errHandler.recoverInline(this);
-						}
-						else {
-							if ( _input.LA(1)==Token.EOF ) matchedEOF = true;
-							_errHandler.reportMatch(this);
-							consume();
-						}
-						setState(164);
-						expr(16);
-						}
-						break;
-					case 5:
-						{
-						_localctx = new LetContext(new ExprContext(_parentctx, _parentState));
-						pushNewRecursionContext(_localctx, _startState, RULE_expr);
-						setState(165);
-						if (!(precpred(_ctx, 6))) throw new FailedPredicateException(this, "precpred(_ctx, 6)");
-						setState(166);
-						match(T__13);
-						setState(167);
-						expr(7);
-						}
-						break;
-					case 6:
-						{
-						_localctx = new CallContext(new ExprContext(_parentctx, _parentState));
-						pushNewRecursionContext(_localctx, _startState, RULE_expr);
-						setState(168);
-						if (!(precpred(_ctx, 20))) throw new FailedPredicateException(this, "precpred(_ctx, 20)");
-						setState(169);
-						match(T__1);
-						setState(170);
-						callList();
-						setState(171);
-						match(T__2);
-						}
-						break;
-					case 7:
-						{
-						_localctx = new ProjectionContext(new ExprContext(_parentctx, _parentState));
-						pushNewRecursionContext(_localctx, _startState, RULE_expr);
-						setState(173);
-						if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)");
-						setState(174);
-						match(T__5);
-						setState(175);
-						match(NAT);
-						}
-						break;
-					}
-					} 
-				}
-				setState(180);
-				_errHandler.sync(this);
-				_alt = getInterpreter().adaptivePredict(_input,12,_ctx);
-			}
-			}
-		}
-		catch (RecognitionException re) {
-			_localctx.exception = re;
-			_errHandler.reportError(this, re);
-			_errHandler.recover(this, re);
-		}
-		finally {
-			unrollRecursionContexts(_parentctx);
-		}
-		return _localctx;
-	}
-
-	public static class FuncContext extends ParserRuleContext {
-		public ArgListContext argList() {
-			return getRuleContext(ArgListContext.class,0);
-		}
-		public BodyContext body() {
-			return getRuleContext(BodyContext.class,0);
-		}
-		public TypeParamListContext typeParamList() {
-			return getRuleContext(TypeParamListContext.class,0);
-		}
-		public Type_Context type_() {
-			return getRuleContext(Type_Context.class,0);
-		}
-		public FuncContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_func; }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterFunc(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitFunc(this);
-		}
-	}
-
-	public final FuncContext func() throws RecognitionException {
-		FuncContext _localctx = new FuncContext(_ctx, getState());
-		enterRule(_localctx, 10, RULE_func);
-		int _la;
-		try {
-			enterOuterAlt(_localctx, 1);
-			{
-			setState(181);
-			match(T__14);
-			setState(183);
-			_errHandler.sync(this);
-			_la = _input.LA(1);
-			if (_la==T__6) {
-				{
-				setState(182);
-				typeParamList();
-				}
-			}
-
-			setState(185);
-			match(T__1);
-			setState(186);
-			argList();
-			setState(187);
-			match(T__2);
-			setState(190);
-			_errHandler.sync(this);
-			_la = _input.LA(1);
-			if (_la==T__15) {
-				{
-				setState(188);
-				match(T__15);
-				setState(189);
-				type_();
-				}
-			}
-
-			setState(192);
-			body();
-			}
-		}
-		catch (RecognitionException re) {
-			_localctx.exception = re;
-			_errHandler.reportError(this, re);
-			_errHandler.recover(this, re);
-		}
-		finally {
-			exitRule();
-		}
-		return _localctx;
-	}
-
-	public static class DefnContext extends ParserRuleContext {
-		public IdentContext ident() {
-			return getRuleContext(IdentContext.class,0);
-		}
-		public ArgListContext argList() {
-			return getRuleContext(ArgListContext.class,0);
-		}
-		public BodyContext body() {
-			return getRuleContext(BodyContext.class,0);
-		}
-		public TypeParamListContext typeParamList() {
-			return getRuleContext(TypeParamListContext.class,0);
-		}
-		public Type_Context type_() {
-			return getRuleContext(Type_Context.class,0);
-		}
-		public AdtDefnContext adtDefn() {
-			return getRuleContext(AdtDefnContext.class,0);
-		}
-		public DefnContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_defn; }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterDefn(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitDefn(this);
-		}
-	}
-
-	public final DefnContext defn() throws RecognitionException {
-		DefnContext _localctx = new DefnContext(_ctx, getState());
-		enterRule(_localctx, 12, RULE_defn);
-		int _la;
-		try {
-			setState(209);
-			_errHandler.sync(this);
-			switch (_input.LA(1)) {
-			case T__16:
-				enterOuterAlt(_localctx, 1);
-				{
-				setState(194);
-				match(T__16);
-				setState(195);
-				ident();
-				setState(197);
-				_errHandler.sync(this);
-				_la = _input.LA(1);
-				if (_la==T__6) {
-					{
-					setState(196);
-					typeParamList();
-					}
-				}
-
-				setState(199);
-				match(T__1);
-				setState(200);
-				argList();
-				setState(201);
-				match(T__2);
-				setState(204);
-				_errHandler.sync(this);
-				_la = _input.LA(1);
-				if (_la==T__15) {
-					{
-					setState(202);
-					match(T__15);
-					setState(203);
-					type_();
-					}
-				}
-
-				setState(206);
-				body();
-				}
-				break;
-			case T__17:
-				enterOuterAlt(_localctx, 2);
-				{
-				setState(208);
-				adtDefn();
-				}
-				break;
-			default:
-				throw new NoViableAltException(this);
-			}
-		}
-		catch (RecognitionException re) {
-			_localctx.exception = re;
-			_errHandler.reportError(this, re);
-			_errHandler.recover(this, re);
-		}
-		finally {
-			exitRule();
-		}
-		return _localctx;
-	}
-
-	public static class AdtDefnContext extends ParserRuleContext {
-		public TypeIdentContext typeIdent() {
-			return getRuleContext(TypeIdentContext.class,0);
-		}
-		public List<TerminalNode> LOCAL_VAR() { return getTokens(RelayParser.LOCAL_VAR); }
-		public TerminalNode LOCAL_VAR(int i) {
-			return getToken(RelayParser.LOCAL_VAR, i);
-		}
-		public List<AdtVariantContext> adtVariant() {
-			return getRuleContexts(AdtVariantContext.class);
-		}
-		public AdtVariantContext adtVariant(int i) {
-			return getRuleContext(AdtVariantContext.class,i);
-		}
-		public AdtDefnContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_adtDefn; }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterAdtDefn(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitAdtDefn(this);
-		}
-	}
-
-	public final AdtDefnContext adtDefn() throws RecognitionException {
-		AdtDefnContext _localctx = new AdtDefnContext(_ctx, getState());
-		enterRule(_localctx, 14, RULE_adtDefn);
-		int _la;
-		try {
-			enterOuterAlt(_localctx, 1);
-			{
-			setState(211);
-			match(T__17);
-			setState(212);
-			typeIdent();
-			setState(223);
-			_errHandler.sync(this);
-			_la = _input.LA(1);
-			if (_la==T__6) {
-				{
-				setState(213);
-				match(T__6);
-				setState(214);
-				match(LOCAL_VAR);
-				setState(219);
-				_errHandler.sync(this);
-				_la = _input.LA(1);
-				while (_la==T__0) {
-					{
-					{
-					setState(215);
-					match(T__0);
-					setState(216);
-					match(LOCAL_VAR);
-					}
-					}
-					setState(221);
-					_errHandler.sync(this);
-					_la = _input.LA(1);
-				}
-				setState(222);
-				match(T__7);
-				}
-			}
-
-			setState(225);
-			match(T__11);
-			setState(227); 
-			_errHandler.sync(this);
-			_la = _input.LA(1);
-			do {
-				{
-				{
-				setState(226);
-				adtVariant();
-				}
-				}
-				setState(229); 
-				_errHandler.sync(this);
-				_la = _input.LA(1);
-			} while ( _la==T__18 );
-			}
-		}
-		catch (RecognitionException re) {
-			_localctx.exception = re;
-			_errHandler.reportError(this, re);
-			_errHandler.recover(this, re);
-		}
-		finally {
-			exitRule();
-		}
-		return _localctx;
-	}
-
-	public static class AdtVariantContext extends ParserRuleContext {
-		public TypeIdentContext typeIdent() {
-			return getRuleContext(TypeIdentContext.class,0);
-		}
-		public List<Type_Context> type_() {
-			return getRuleContexts(Type_Context.class);
-		}
-		public Type_Context type_(int i) {
-			return getRuleContext(Type_Context.class,i);
-		}
-		public AdtVariantContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_adtVariant; }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterAdtVariant(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitAdtVariant(this);
-		}
-	}
-
-	public final AdtVariantContext adtVariant() throws RecognitionException {
-		AdtVariantContext _localctx = new AdtVariantContext(_ctx, getState());
-		enterRule(_localctx, 16, RULE_adtVariant);
-		int _la;
-		try {
-			enterOuterAlt(_localctx, 1);
-			{
-			setState(231);
-			match(T__18);
-			setState(232);
-			typeIdent();
-			setState(244);
-			_errHandler.sync(this);
-			_la = _input.LA(1);
-			if (_la==T__1) {
-				{
-				setState(233);
-				match(T__1);
-				setState(234);
-				type_();
-				setState(239);
-				_errHandler.sync(this);
-				_la = _input.LA(1);
-				while (_la==T__19) {
-					{
-					{
-					setState(235);
-					match(T__19);
-					setState(236);
-					type_();
-					}
-					}
-					setState(241);
-					_errHandler.sync(this);
-					_la = _input.LA(1);
-				}
-				setState(242);
-				match(T__2);
-				}
-			}
-
-			}
-		}
-		catch (RecognitionException re) {
-			_localctx.exception = re;
-			_errHandler.reportError(this, re);
-			_errHandler.recover(this, re);
-		}
-		finally {
-			exitRule();
-		}
-		return _localctx;
-	}
-
-	public static class ArgListContext extends ParserRuleContext {
-		public ArgListContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_argList; }
-	 
-		public ArgListContext() { }
-		public void copyFrom(ArgListContext ctx) {
-			super.copyFrom(ctx);
-		}
-	}
-	public static class ArgNoAttrContext extends ArgListContext {
-		public VarListContext varList() {
-			return getRuleContext(VarListContext.class,0);
-		}
-		public ArgNoAttrContext(ArgListContext ctx) { copyFrom(ctx); }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterArgNoAttr(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitArgNoAttr(this);
-		}
-	}
-	public static class ArgWithAttrContext extends ArgListContext {
-		public AttrSeqContext attrSeq() {
-			return getRuleContext(AttrSeqContext.class,0);
-		}
-		public List<VarContext> var() {
-			return getRuleContexts(VarContext.class);
-		}
-		public VarContext var(int i) {
-			return getRuleContext(VarContext.class,i);
-		}
-		public ArgWithAttrContext(ArgListContext ctx) { copyFrom(ctx); }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterArgWithAttr(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitArgWithAttr(this);
-		}
-	}
-
-	public final ArgListContext argList() throws RecognitionException {
-		ArgListContext _localctx = new ArgListContext(_ctx, getState());
-		enterRule(_localctx, 18, RULE_argList);
-		int _la;
-		try {
-			setState(256);
-			_errHandler.sync(this);
-			switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) {
-			case 1:
-				_localctx = new ArgNoAttrContext(_localctx);
-				enterOuterAlt(_localctx, 1);
-				{
-				setState(246);
-				varList();
-				}
-				break;
-			case 2:
-				_localctx = new ArgWithAttrContext(_localctx);
-				enterOuterAlt(_localctx, 2);
-				{
-				setState(252);
-				_errHandler.sync(this);
-				_la = _input.LA(1);
-				while (_la==LOCAL_VAR) {
-					{
-					{
-					setState(247);
-					var();
-					setState(248);
-					match(T__0);
-					}
-					}
-					setState(254);
-					_errHandler.sync(this);
-					_la = _input.LA(1);
-				}
-				setState(255);
-				attrSeq();
-				}
-				break;
-			}
-		}
-		catch (RecognitionException re) {
-			_localctx.exception = re;
-			_errHandler.reportError(this, re);
-			_errHandler.recover(this, re);
-		}
-		finally {
-			exitRule();
-		}
-		return _localctx;
-	}
-
-	public static class VarListContext extends ParserRuleContext {
-		public List<VarContext> var() {
-			return getRuleContexts(VarContext.class);
-		}
-		public VarContext var(int i) {
-			return getRuleContext(VarContext.class,i);
-		}
-		public VarListContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_varList; }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterVarList(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitVarList(this);
-		}
-	}
-
-	public final VarListContext varList() throws RecognitionException {
-		VarListContext _localctx = new VarListContext(_ctx, getState());
-		enterRule(_localctx, 20, RULE_varList);
-		int _la;
-		try {
-			enterOuterAlt(_localctx, 1);
-			{
-			setState(266);
-			_errHandler.sync(this);
-			_la = _input.LA(1);
-			if (_la==LOCAL_VAR) {
-				{
-				setState(258);
-				var();
-				setState(263);
-				_errHandler.sync(this);
-				_la = _input.LA(1);
-				while (_la==T__0) {
-					{
-					{
-					setState(259);
-					match(T__0);
-					setState(260);
-					var();
-					}
-					}
-					setState(265);
-					_errHandler.sync(this);
-					_la = _input.LA(1);
-				}
-				}
-			}
-
-			}
-		}
-		catch (RecognitionException re) {
-			_localctx.exception = re;
-			_errHandler.reportError(this, re);
-			_errHandler.recover(this, re);
-		}
-		finally {
-			exitRule();
-		}
-		return _localctx;
-	}
-
-	public static class VarContext extends ParserRuleContext {
-		public TerminalNode LOCAL_VAR() { return getToken(RelayParser.LOCAL_VAR, 0); }
-		public Type_Context type_() {
-			return getRuleContext(Type_Context.class,0);
-		}
-		public VarContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_var; }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterVar(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitVar(this);
-		}
-	}
-
-	public final VarContext var() throws RecognitionException {
-		VarContext _localctx = new VarContext(_ctx, getState());
-		enterRule(_localctx, 22, RULE_var);
-		int _la;
-		try {
-			enterOuterAlt(_localctx, 1);
-			{
-			setState(268);
-			match(LOCAL_VAR);
-			setState(271);
-			_errHandler.sync(this);
-			_la = _input.LA(1);
-			if (_la==T__20) {
-				{
-				setState(269);
-				match(T__20);
-				setState(270);
-				type_();
-				}
-			}
-
-			}
-		}
-		catch (RecognitionException re) {
-			_localctx.exception = re;
-			_errHandler.reportError(this, re);
-			_errHandler.recover(this, re);
-		}
-		finally {
-			exitRule();
-		}
-		return _localctx;
-	}
-
-	public static class AttrSeqContext extends ParserRuleContext {
-		public List<AttrContext> attr() {
-			return getRuleContexts(AttrContext.class);
-		}
-		public AttrContext attr(int i) {
-			return getRuleContext(AttrContext.class,i);
-		}
-		public AttrSeqContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_attrSeq; }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterAttrSeq(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitAttrSeq(this);
-		}
-	}
-
-	public final AttrSeqContext attrSeq() throws RecognitionException {
-		AttrSeqContext _localctx = new AttrSeqContext(_ctx, getState());
-		enterRule(_localctx, 24, RULE_attrSeq);
-		int _la;
-		try {
-			enterOuterAlt(_localctx, 1);
-			{
-			setState(273);
-			attr();
-			setState(278);
-			_errHandler.sync(this);
-			_la = _input.LA(1);
-			while (_la==T__0) {
-				{
-				{
-				setState(274);
-				match(T__0);
-				setState(275);
-				attr();
-				}
-				}
-				setState(280);
-				_errHandler.sync(this);
-				_la = _input.LA(1);
-			}
-			}
-		}
-		catch (RecognitionException re) {
-			_localctx.exception = re;
-			_errHandler.reportError(this, re);
-			_errHandler.recover(this, re);
-		}
-		finally {
-			exitRule();
-		}
-		return _localctx;
-	}
-
-	public static class AttrContext extends ParserRuleContext {
-		public TerminalNode CNAME() { return getToken(RelayParser.CNAME, 0); }
-		public ExprContext expr() {
-			return getRuleContext(ExprContext.class,0);
-		}
-		public AttrContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_attr; }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterAttr(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitAttr(this);
-		}
-	}
-
-	public final AttrContext attr() throws RecognitionException {
-		AttrContext _localctx = new AttrContext(_ctx, getState());
-		enterRule(_localctx, 26, RULE_attr);
-		try {
-			enterOuterAlt(_localctx, 1);
-			{
-			setState(281);
-			match(CNAME);
-			setState(282);
-			match(T__11);
-			setState(283);
-			expr(0);
-			}
-		}
-		catch (RecognitionException re) {
-			_localctx.exception = re;
-			_errHandler.reportError(this, re);
-			_errHandler.recover(this, re);
-		}
-		finally {
-			exitRule();
-		}
-		return _localctx;
-	}
-
-	public static class TypeParamListContext extends ParserRuleContext {
-		public List<IdentContext> ident() {
-			return getRuleContexts(IdentContext.class);
-		}
-		public IdentContext ident(int i) {
-			return getRuleContext(IdentContext.class,i);
-		}
-		public TypeParamListContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_typeParamList; }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterTypeParamList(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitTypeParamList(this);
-		}
-	}
-
-	public final TypeParamListContext typeParamList() throws RecognitionException {
-		TypeParamListContext _localctx = new TypeParamListContext(_ctx, getState());
-		enterRule(_localctx, 28, RULE_typeParamList);
-		int _la;
-		try {
-			setState(298);
-			_errHandler.sync(this);
-			switch ( getInterpreter().adaptivePredict(_input,30,_ctx) ) {
-			case 1:
-				enterOuterAlt(_localctx, 1);
-				{
-				setState(285);
-				match(T__6);
-				setState(286);
-				match(T__7);
-				}
-				break;
-			case 2:
-				enterOuterAlt(_localctx, 2);
-				{
-				setState(287);
-				match(T__6);
-				setState(288);
-				ident();
-				setState(293);
-				_errHandler.sync(this);
-				_la = _input.LA(1);
-				while (_la==T__0) {
-					{
-					{
-					setState(289);
-					match(T__0);
-					setState(290);
-					ident();
-					}
-					}
-					setState(295);
-					_errHandler.sync(this);
-					_la = _input.LA(1);
-				}
-				setState(296);
-				match(T__7);
-				}
-				break;
-			}
-		}
-		catch (RecognitionException re) {
-			_localctx.exception = re;
-			_errHandler.reportError(this, re);
-			_errHandler.recover(this, re);
-		}
-		finally {
-			exitRule();
-		}
-		return _localctx;
-	}
-
-	public static class Type_Context extends ParserRuleContext {
-		public Type_Context(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_type_; }
-	 
-		public Type_Context() { }
-		public void copyFrom(Type_Context ctx) {
-			super.copyFrom(ctx);
-		}
-	}
-	public static class IntTypeContext extends Type_Context {
-		public TerminalNode NAT() { return getToken(RelayParser.NAT, 0); }
-		public IntTypeContext(Type_Context ctx) { copyFrom(ctx); }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterIntType(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitIntType(this);
-		}
-	}
-	public static class TupleTypeContext extends Type_Context {
-		public List<Type_Context> type_() {
-			return getRuleContexts(Type_Context.class);
-		}
-		public Type_Context type_(int i) {
-			return getRuleContext(Type_Context.class,i);
-		}
-		public TupleTypeContext(Type_Context ctx) { copyFrom(ctx); }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterTupleType(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitTupleType(this);
-		}
-	}
-	public static class TypeIdentTypeContext extends Type_Context {
-		public TypeIdentContext typeIdent() {
-			return getRuleContext(TypeIdentContext.class,0);
-		}
-		public TypeIdentTypeContext(Type_Context ctx) { copyFrom(ctx); }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterTypeIdentType(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitTypeIdentType(this);
-		}
-	}
-	public static class IncompleteTypeContext extends Type_Context {
-		public IncompleteTypeContext(Type_Context ctx) { copyFrom(ctx); }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterIncompleteType(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitIncompleteType(this);
-		}
-	}
-	public static class TensorTypeContext extends Type_Context {
-		public ShapeListContext shapeList() {
-			return getRuleContext(ShapeListContext.class,0);
-		}
-		public Type_Context type_() {
-			return getRuleContext(Type_Context.class,0);
-		}
-		public TensorTypeContext(Type_Context ctx) { copyFrom(ctx); }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterTensorType(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitTensorType(this);
-		}
-	}
-	public static class FuncTypeContext extends Type_Context {
-		public List<Type_Context> type_() {
-			return getRuleContexts(Type_Context.class);
-		}
-		public Type_Context type_(int i) {
-			return getRuleContext(Type_Context.class,i);
-		}
-		public TypeParamListContext typeParamList() {
-			return getRuleContext(TypeParamListContext.class,0);
-		}
-		public FuncTypeContext(Type_Context ctx) { copyFrom(ctx); }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterFuncType(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitFuncType(this);
-		}
-	}
-
-	public final Type_Context type_() throws RecognitionException {
-		Type_Context _localctx = new Type_Context(_ctx, getState());
-		enterRule(_localctx, 30, RULE_type_);
-		int _la;
-		try {
-			setState(345);
-			_errHandler.sync(this);
-			switch ( getInterpreter().adaptivePredict(_input,35,_ctx) ) {
-			case 1:
-				_localctx = new TupleTypeContext(_localctx);
-				enterOuterAlt(_localctx, 1);
-				{
-				setState(300);
-				match(T__1);
-				setState(301);
-				match(T__2);
-				}
-				break;
-			case 2:
-				_localctx = new TupleTypeContext(_localctx);
-				enterOuterAlt(_localctx, 2);
-				{
-				setState(302);
-				match(T__1);
-				setState(303);
-				type_();
-				setState(304);
-				match(T__0);
-				setState(305);
-				match(T__2);
-				}
-				break;
-			case 3:
-				_localctx = new TupleTypeContext(_localctx);
-				enterOuterAlt(_localctx, 3);
-				{
-				setState(307);
-				match(T__1);
-				setState(308);
-				type_();
-				setState(311); 
-				_errHandler.sync(this);
-				_la = _input.LA(1);
-				do {
-					{
-					{
-					setState(309);
-					match(T__0);
-					setState(310);
-					type_();
-					}
-					}
-					setState(313); 
-					_errHandler.sync(this);
-					_la = _input.LA(1);
-				} while ( _la==T__0 );
-				setState(315);
-				match(T__2);
-				}
-				break;
-			case 4:
-				_localctx = new TypeIdentTypeContext(_localctx);
-				enterOuterAlt(_localctx, 4);
-				{
-				setState(317);
-				typeIdent();
-				}
-				break;
-			case 5:
-				_localctx = new TensorTypeContext(_localctx);
-				enterOuterAlt(_localctx, 5);
-				{
-				setState(318);
-				match(T__21);
-				setState(319);
-				match(T__6);
-				setState(320);
-				shapeList();
-				setState(321);
-				match(T__0);
-				setState(322);
-				type_();
-				setState(323);
-				match(T__7);
-				}
-				break;
-			case 6:
-				_localctx = new FuncTypeContext(_localctx);
-				enterOuterAlt(_localctx, 6);
-				{
-				setState(325);
-				match(T__14);
-				setState(327);
-				_errHandler.sync(this);
-				_la = _input.LA(1);
-				if (_la==T__6) {
-					{
-					setState(326);
-					typeParamList();
-					}
-				}
-
-				setState(329);
-				match(T__1);
-				setState(338);
-				_errHandler.sync(this);
-				_la = _input.LA(1);
-				if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__1) | (1L << T__14) | (1L << T__21) | (1L << T__22) | (1L << CNAME) | (1L << NAT))) != 0)) {
-					{
-					setState(330);
-					type_();
-					setState(335);
-					_errHandler.sync(this);
-					_la = _input.LA(1);
-					while (_la==T__0) {
-						{
-						{
-						setState(331);
-						match(T__0);
-						setState(332);
-						type_();
-						}
-						}
-						setState(337);
-						_errHandler.sync(this);
-						_la = _input.LA(1);
-					}
-					}
-				}
-
-				setState(340);
-				match(T__2);
-				setState(341);
-				match(T__15);
-				setState(342);
-				type_();
-				}
-				break;
-			case 7:
-				_localctx = new IncompleteTypeContext(_localctx);
-				enterOuterAlt(_localctx, 7);
-				{
-				setState(343);
-				match(T__22);
-				}
-				break;
-			case 8:
-				_localctx = new IntTypeContext(_localctx);
-				enterOuterAlt(_localctx, 8);
-				{
-				setState(344);
-				match(NAT);
-				}
-				break;
-			}
-		}
-		catch (RecognitionException re) {
-			_localctx.exception = re;
-			_errHandler.reportError(this, re);
-			_errHandler.recover(this, re);
-		}
-		finally {
-			exitRule();
-		}
-		return _localctx;
-	}
-
-	public static class ShapeListContext extends ParserRuleContext {
-		public List<ShapeContext> shape() {
-			return getRuleContexts(ShapeContext.class);
-		}
-		public ShapeContext shape(int i) {
-			return getRuleContext(ShapeContext.class,i);
-		}
-		public ShapeListContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_shapeList; }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterShapeList(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitShapeList(this);
-		}
-	}
-
-	public final ShapeListContext shapeList() throws RecognitionException {
-		ShapeListContext _localctx = new ShapeListContext(_ctx, getState());
-		enterRule(_localctx, 32, RULE_shapeList);
-		int _la;
-		try {
-			setState(360);
-			_errHandler.sync(this);
-			switch ( getInterpreter().adaptivePredict(_input,37,_ctx) ) {
-			case 1:
-				enterOuterAlt(_localctx, 1);
-				{
-				setState(347);
-				match(T__1);
-				setState(348);
-				shape();
-				setState(351); 
-				_errHandler.sync(this);
-				_la = _input.LA(1);
-				do {
-					{
-					{
-					setState(349);
-					match(T__0);
-					setState(350);
-					shape();
-					}
-					}
-					setState(353); 
-					_errHandler.sync(this);
-					_la = _input.LA(1);
-				} while ( _la==T__0 );
-				setState(355);
-				match(T__2);
-				}
-				break;
-			case 2:
-				enterOuterAlt(_localctx, 2);
-				{
-				setState(357);
-				match(T__1);
-				setState(358);
-				match(T__2);
-				}
-				break;
-			case 3:
-				enterOuterAlt(_localctx, 3);
-				{
-				setState(359);
-				shape();
-				}
-				break;
-			}
-		}
-		catch (RecognitionException re) {
-			_localctx.exception = re;
-			_errHandler.reportError(this, re);
-			_errHandler.recover(this, re);
-		}
-		finally {
-			exitRule();
-		}
-		return _localctx;
-	}
-
-	public static class MetaContext extends ParserRuleContext {
-		public TerminalNode CNAME() { return getToken(RelayParser.CNAME, 0); }
-		public TerminalNode NAT() { return getToken(RelayParser.NAT, 0); }
-		public MetaContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_meta; }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterMeta(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitMeta(this);
-		}
-	}
-
-	public final MetaContext meta() throws RecognitionException {
-		MetaContext _localctx = new MetaContext(_ctx, getState());
-		enterRule(_localctx, 34, RULE_meta);
-		try {
-			enterOuterAlt(_localctx, 1);
-			{
-			setState(362);
-			match(T__23);
-			setState(363);
-			match(T__6);
-			setState(364);
-			match(CNAME);
-			setState(365);
-			match(T__7);
-			setState(366);
-			match(T__6);
-			setState(367);
-			match(NAT);
-			setState(368);
-			match(T__7);
-			}
-		}
-		catch (RecognitionException re) {
-			_localctx.exception = re;
-			_errHandler.reportError(this, re);
-			_errHandler.recover(this, re);
-		}
-		finally {
-			exitRule();
-		}
-		return _localctx;
-	}
-
-	public static class ShapeContext extends ParserRuleContext {
-		public ShapeContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_shape; }
-	 
-		public ShapeContext() { }
-		public void copyFrom(ShapeContext ctx) {
-			super.copyFrom(ctx);
-		}
-	}
-	public static class ParensShapeContext extends ShapeContext {
-		public ShapeContext shape() {
-			return getRuleContext(ShapeContext.class,0);
-		}
-		public ParensShapeContext(ShapeContext ctx) { copyFrom(ctx); }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterParensShape(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitParensShape(this);
-		}
-	}
-	public static class MetaShapeContext extends ShapeContext {
-		public MetaContext meta() {
-			return getRuleContext(MetaContext.class,0);
-		}
-		public MetaShapeContext(ShapeContext ctx) { copyFrom(ctx); }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterMetaShape(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitMetaShape(this);
-		}
-	}
-	public static class IntShapeContext extends ShapeContext {
-		public TerminalNode NAT() { return getToken(RelayParser.NAT, 0); }
-		public IntShapeContext(ShapeContext ctx) { copyFrom(ctx); }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterIntShape(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitIntShape(this);
-		}
-	}
-
-	public final ShapeContext shape() throws RecognitionException {
-		ShapeContext _localctx = new ShapeContext(_ctx, getState());
-		enterRule(_localctx, 36, RULE_shape);
-		try {
-			setState(376);
-			_errHandler.sync(this);
-			switch (_input.LA(1)) {
-			case T__23:
-				_localctx = new MetaShapeContext(_localctx);
-				enterOuterAlt(_localctx, 1);
-				{
-				setState(370);
-				meta();
-				}
-				break;
-			case T__1:
-				_localctx = new ParensShapeContext(_localctx);
-				enterOuterAlt(_localctx, 2);
-				{
-				setState(371);
-				match(T__1);
-				setState(372);
-				shape();
-				setState(373);
-				match(T__2);
-				}
-				break;
-			case NAT:
-				_localctx = new IntShapeContext(_localctx);
-				enterOuterAlt(_localctx, 3);
-				{
-				setState(375);
-				match(NAT);
-				}
-				break;
-			default:
-				throw new NoViableAltException(this);
-			}
-		}
-		catch (RecognitionException re) {
-			_localctx.exception = re;
-			_errHandler.reportError(this, re);
-			_errHandler.recover(this, re);
-		}
-		finally {
-			exitRule();
-		}
-		return _localctx;
-	}
-
-	public static class TypeIdentContext extends ParserRuleContext {
-		public TerminalNode CNAME() { return getToken(RelayParser.CNAME, 0); }
-		public TypeIdentContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_typeIdent; }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterTypeIdent(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitTypeIdent(this);
-		}
-	}
-
-	public final TypeIdentContext typeIdent() throws RecognitionException {
-		TypeIdentContext _localctx = new TypeIdentContext(_ctx, getState());
-		enterRule(_localctx, 38, RULE_typeIdent);
-		try {
-			enterOuterAlt(_localctx, 1);
-			{
-			setState(378);
-			match(CNAME);
-			}
-		}
-		catch (RecognitionException re) {
-			_localctx.exception = re;
-			_errHandler.reportError(this, re);
-			_errHandler.recover(this, re);
-		}
-		finally {
-			exitRule();
-		}
-		return _localctx;
-	}
-
-	public static class BodyContext extends ParserRuleContext {
-		public ExprContext expr() {
-			return getRuleContext(ExprContext.class,0);
-		}
-		public BodyContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_body; }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterBody(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitBody(this);
-		}
-	}
-
-	public final BodyContext body() throws RecognitionException {
-		BodyContext _localctx = new BodyContext(_ctx, getState());
-		enterRule(_localctx, 40, RULE_body);
-		try {
-			enterOuterAlt(_localctx, 1);
-			{
-			setState(380);
-			match(T__3);
-			setState(381);
-			expr(0);
-			setState(382);
-			match(T__4);
-			}
-		}
-		catch (RecognitionException re) {
-			_localctx.exception = re;
-			_errHandler.reportError(this, re);
-			_errHandler.recover(this, re);
-		}
-		finally {
-			exitRule();
-		}
-		return _localctx;
-	}
-
-	public static class ScalarContext extends ParserRuleContext {
-		public ScalarContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_scalar; }
-	 
-		public ScalarContext() { }
-		public void copyFrom(ScalarContext ctx) {
-			super.copyFrom(ctx);
-		}
-	}
-	public static class ScalarFloatContext extends ScalarContext {
-		public TerminalNode FLOAT() { return getToken(RelayParser.FLOAT, 0); }
-		public ScalarFloatContext(ScalarContext ctx) { copyFrom(ctx); }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterScalarFloat(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitScalarFloat(this);
-		}
-	}
-	public static class ScalarBoolContext extends ScalarContext {
-		public TerminalNode BOOL_LIT() { return getToken(RelayParser.BOOL_LIT, 0); }
-		public ScalarBoolContext(ScalarContext ctx) { copyFrom(ctx); }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterScalarBool(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitScalarBool(this);
-		}
-	}
-	public static class ScalarIntContext extends ScalarContext {
-		public TerminalNode NAT() { return getToken(RelayParser.NAT, 0); }
-		public ScalarIntContext(ScalarContext ctx) { copyFrom(ctx); }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterScalarInt(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitScalarInt(this);
-		}
-	}
-
-	public final ScalarContext scalar() throws RecognitionException {
-		ScalarContext _localctx = new ScalarContext(_ctx, getState());
-		enterRule(_localctx, 42, RULE_scalar);
-		try {
-			setState(387);
-			_errHandler.sync(this);
-			switch (_input.LA(1)) {
-			case FLOAT:
-				_localctx = new ScalarFloatContext(_localctx);
-				enterOuterAlt(_localctx, 1);
-				{
-				setState(384);
-				match(FLOAT);
-				}
-				break;
-			case NAT:
-				_localctx = new ScalarIntContext(_localctx);
-				enterOuterAlt(_localctx, 2);
-				{
-				setState(385);
-				match(NAT);
-				}
-				break;
-			case BOOL_LIT:
-				_localctx = new ScalarBoolContext(_localctx);
-				enterOuterAlt(_localctx, 3);
-				{
-				setState(386);
-				match(BOOL_LIT);
-				}
-				break;
-			default:
-				throw new NoViableAltException(this);
-			}
-		}
-		catch (RecognitionException re) {
-			_localctx.exception = re;
-			_errHandler.reportError(this, re);
-			_errHandler.recover(this, re);
-		}
-		finally {
-			exitRule();
-		}
-		return _localctx;
-	}
-
-	public static class IdentContext extends ParserRuleContext {
-		public OpIdentContext opIdent() {
-			return getRuleContext(OpIdentContext.class,0);
-		}
-		public TerminalNode GLOBAL_VAR() { return getToken(RelayParser.GLOBAL_VAR, 0); }
-		public TerminalNode LOCAL_VAR() { return getToken(RelayParser.LOCAL_VAR, 0); }
-		public TerminalNode GRAPH_VAR() { return getToken(RelayParser.GRAPH_VAR, 0); }
-		public IdentContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_ident; }
-		@Override
-		public void enterRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).enterIdent(this);
-		}
-		@Override
-		public void exitRule(ParseTreeListener listener) {
-			if ( listener instanceof RelayListener ) ((RelayListener)listener).exitIdent(this);
-		}
-	}
-
-	public final IdentContext ident() throws RecognitionException {
-		IdentContext _localctx = new IdentContext(_ctx, getState());
-		enterRule(_localctx, 44, RULE_ident);
-		try {
-			setState(393);
-			_errHandler.sync(this);
-			switch (_input.LA(1)) {
-			case CNAME:
-				enterOuterAlt(_localctx, 1);
-				{
-				setState(389);
-				opIdent();
-				}
-				break;
-			case GLOBAL_VAR:
-				enterOuterAlt(_localctx, 2);
-				{
-				setState(390);
-				match(GLOBAL_VAR);
-				}
-				break;
-			case LOCAL_VAR:
-				enterOuterAlt(_localctx, 3);
-				{
-				setState(391);
-				match(LOCAL_VAR);
-				}
-				break;
-			case GRAPH_VAR:
-				enterOuterAlt(_localctx, 4);
-				{
-				setState(392);
-				match(GRAPH_VAR);
-				}
-				break;
-			default:
-				throw new NoViableAltException(this);
-			}
-		}
-		catch (RecognitionException re) {
-			_localctx.exception = re;
-			_errHandler.reportError(this, re);
-			_errHandler.recover(this, re);
-		}
-		finally {
-			exitRule();
-		}
-		return _localctx;
-	}
-
-	public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
-		switch (ruleIndex) {
-		case 4:
-			return expr_sempred((ExprContext)_localctx, predIndex);
-		}
-		return true;
-	}
-	private boolean expr_sempred(ExprContext _localctx, int predIndex) {
-		switch (predIndex) {
-		case 0:
-			return precpred(_ctx, 18);
-		case 1:
-			return precpred(_ctx, 17);
-		case 2:
-			return precpred(_ctx, 16);
-		case 3:
-			return precpred(_ctx, 15);
-		case 4:
-			return precpred(_ctx, 6);
-		case 5:
-			return precpred(_ctx, 20);
-		case 6:
-			return precpred(_ctx, 10);
-		}
-		return true;
-	}
-
-	public static final String _serializedATN =
-		"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\62\u018e\4\2\t\2"+
-		"\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+
-		"\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
-		"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\3\2\3\2\3"+
-		"\3\3\3\7\3\65\n\3\f\3\16\38\13\3\3\3\5\3;\n\3\3\3\5\3>\n\3\3\3\3\3\3\4"+
-		"\3\4\3\4\7\4E\n\4\f\4\16\4H\13\4\5\4J\n\4\3\5\3\5\3\5\3\5\7\5P\n\5\f\5"+
-		"\16\5S\13\5\3\5\5\5V\n\5\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3"+
-		"\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\6\6o\n\6\r\6\16\6p\3\6"+
-		"\3\6\3\6\3\6\3\6\3\6\7\6y\n\6\f\6\16\6|\13\6\5\6~\n\6\3\6\3\6\3\6\3\6"+
-		"\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3"+
-		"\6\3\6\3\6\3\6\3\6\5\6\u009a\n\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3"+
-		"\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\7\6\u00b3\n\6\f"+
-		"\6\16\6\u00b6\13\6\3\7\3\7\5\7\u00ba\n\7\3\7\3\7\3\7\3\7\3\7\5\7\u00c1"+
-		"\n\7\3\7\3\7\3\b\3\b\3\b\5\b\u00c8\n\b\3\b\3\b\3\b\3\b\3\b\5\b\u00cf\n"+
-		"\b\3\b\3\b\3\b\5\b\u00d4\n\b\3\t\3\t\3\t\3\t\3\t\3\t\7\t\u00dc\n\t\f\t"+
-		"\16\t\u00df\13\t\3\t\5\t\u00e2\n\t\3\t\3\t\6\t\u00e6\n\t\r\t\16\t\u00e7"+
-		"\3\n\3\n\3\n\3\n\3\n\3\n\7\n\u00f0\n\n\f\n\16\n\u00f3\13\n\3\n\3\n\5\n"+
-		"\u00f7\n\n\3\13\3\13\3\13\3\13\7\13\u00fd\n\13\f\13\16\13\u0100\13\13"+
-		"\3\13\5\13\u0103\n\13\3\f\3\f\3\f\7\f\u0108\n\f\f\f\16\f\u010b\13\f\5"+
-		"\f\u010d\n\f\3\r\3\r\3\r\5\r\u0112\n\r\3\16\3\16\3\16\7\16\u0117\n\16"+
-		"\f\16\16\16\u011a\13\16\3\17\3\17\3\17\3\17\3\20\3\20\3\20\3\20\3\20\3"+
-		"\20\7\20\u0126\n\20\f\20\16\20\u0129\13\20\3\20\3\20\5\20\u012d\n\20\3"+
-		"\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\6\21\u013a\n\21"+
-		"\r\21\16\21\u013b\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3"+
-		"\21\3\21\5\21\u014a\n\21\3\21\3\21\3\21\3\21\7\21\u0150\n\21\f\21\16\21"+
-		"\u0153\13\21\5\21\u0155\n\21\3\21\3\21\3\21\3\21\3\21\5\21\u015c\n\21"+
-		"\3\22\3\22\3\22\3\22\6\22\u0162\n\22\r\22\16\22\u0163\3\22\3\22\3\22\3"+
-		"\22\3\22\5\22\u016b\n\22\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\23\3\24"+
-		"\3\24\3\24\3\24\3\24\3\24\5\24\u017b\n\24\3\25\3\25\3\26\3\26\3\26\3\26"+
-		"\3\27\3\27\3\27\5\27\u0186\n\27\3\30\3\30\3\30\3\30\5\30\u018c\n\30\3"+
-		"\30\2\3\n\31\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\2\6\3\2 "+
-		"!\3\2\"#\3\2$\'\3\2()\2\u01bc\2\60\3\2\2\2\4\62\3\2\2\2\6I\3\2\2\2\bU"+
-		"\3\2\2\2\n\u0099\3\2\2\2\f\u00b7\3\2\2\2\16\u00d3\3\2\2\2\20\u00d5\3\2"+
-		"\2\2\22\u00e9\3\2\2\2\24\u0102\3\2\2\2\26\u010c\3\2\2\2\30\u010e\3\2\2"+
-		"\2\32\u0113\3\2\2\2\34\u011b\3\2\2\2\36\u012c\3\2\2\2 \u015b\3\2\2\2\""+
-		"\u016a\3\2\2\2$\u016c\3\2\2\2&\u017a\3\2\2\2(\u017c\3\2\2\2*\u017e\3\2"+
-		"\2\2,\u0185\3\2\2\2.\u018b\3\2\2\2\60\61\7+\2\2\61\3\3\2\2\2\62:\7\33"+
-		"\2\2\63\65\5\16\b\2\64\63\3\2\2\2\658\3\2\2\2\66\64\3\2\2\2\66\67\3\2"+
-		"\2\2\67;\3\2\2\28\66\3\2\2\29;\5\n\6\2:\66\3\2\2\2:9\3\2\2\2;=\3\2\2\2"+
-		"<>\7\62\2\2=<\3\2\2\2=>\3\2\2\2>?\3\2\2\2?@\7\2\2\3@\5\3\2\2\2AF\5\n\6"+
-		"\2BC\7\3\2\2CE\5\n\6\2DB\3\2\2\2EH\3\2\2\2FD\3\2\2\2FG\3\2\2\2GJ\3\2\2"+
-		"\2HF\3\2\2\2IA\3\2\2\2IJ\3\2\2\2J\7\3\2\2\2KV\5\6\4\2LM\5\n\6\2MN\7\3"+
-		"\2\2NP\3\2\2\2OL\3\2\2\2PS\3\2\2\2QO\3\2\2\2QR\3\2\2\2RT\3\2\2\2SQ\3\2"+
-		"\2\2TV\5\32\16\2UK\3\2\2\2UQ\3\2\2\2V\t\3\2\2\2WX\b\6\1\2XY\7\4\2\2YZ"+
-		"\5\n\6\2Z[\7\5\2\2[\u009a\3\2\2\2\\]\7\6\2\2]^\5\n\6\2^_\7\7\2\2_\u009a"+
-		"\3\2\2\2`a\7#\2\2a\u009a\5\n\6\25b\u009a\5\f\7\2cd\7\4\2\2d\u009a\7\5"+
-		"\2\2ef\7\4\2\2fg\5\n\6\2gh\7\3\2\2hi\7\5\2\2i\u009a\3\2\2\2jk\7\4\2\2"+
-		"kn\5\n\6\2lm\7\3\2\2mo\5\n\6\2nl\3\2\2\2op\3\2\2\2pn\3\2\2\2pq\3\2\2\2"+
-		"qr\3\2\2\2rs\7\5\2\2s\u009a\3\2\2\2t}\7\t\2\2uz\5\n\6\2vw\7\3\2\2wy\5"+
-		"\n\6\2xv\3\2\2\2y|\3\2\2\2zx\3\2\2\2z{\3\2\2\2{~\3\2\2\2|z\3\2\2\2}u\3"+
-		"\2\2\2}~\3\2\2\2~\177\3\2\2\2\177\u009a\7\n\2\2\u0080\u0081\7\13\2\2\u0081"+
-		"\u0082\7\4\2\2\u0082\u0083\5\n\6\2\u0083\u0084\7\5\2\2\u0084\u0085\5*"+
-		"\26\2\u0085\u0086\7\f\2\2\u0086\u0087\5*\26\2\u0087\u009a\3\2\2\2\u0088"+
-		"\u0089\7\r\2\2\u0089\u008a\5\30\r\2\u008a\u008b\7\16\2\2\u008b\u008c\5"+
-		"\n\6\2\u008c\u008d\7\17\2\2\u008d\u008e\5\n\6\t\u008e\u009a\3\2\2\2\u008f"+
-		"\u0090\7.\2\2\u0090\u0091\7\16\2\2\u0091\u0092\5\n\6\2\u0092\u0093\7\17"+
-		"\2\2\u0093\u0094\5\n\6\7\u0094\u009a\3\2\2\2\u0095\u009a\5.\30\2\u0096"+
-		"\u009a\5,\27\2\u0097\u009a\5$\23\2\u0098\u009a\7\37\2\2\u0099W\3\2\2\2"+
-		"\u0099\\\3\2\2\2\u0099`\3\2\2\2\u0099b\3\2\2\2\u0099c\3\2\2\2\u0099e\3"+
-		"\2\2\2\u0099j\3\2\2\2\u0099t\3\2\2\2\u0099\u0080\3\2\2\2\u0099\u0088\3"+
-		"\2\2\2\u0099\u008f\3\2\2\2\u0099\u0095\3\2\2\2\u0099\u0096\3\2\2\2\u0099"+
-		"\u0097\3\2\2\2\u0099\u0098\3\2\2\2\u009a\u00b4\3\2\2\2\u009b\u009c\f\24"+
-		"\2\2\u009c\u009d\t\2\2\2\u009d\u00b3\5\n\6\25\u009e\u009f\f\23\2\2\u009f"+
-		"\u00a0\t\3\2\2\u00a0\u00b3\5\n\6\24\u00a1\u00a2\f\22\2\2\u00a2\u00a3\t"+
-		"\4\2\2\u00a3\u00b3\5\n\6\23\u00a4\u00a5\f\21\2\2\u00a5\u00a6\t\5\2\2\u00a6"+
-		"\u00b3\5\n\6\22\u00a7\u00a8\f\b\2\2\u00a8\u00a9\7\20\2\2\u00a9\u00b3\5"+
-		"\n\6\t\u00aa\u00ab\f\26\2\2\u00ab\u00ac\7\4\2\2\u00ac\u00ad\5\b\5\2\u00ad"+
-		"\u00ae\7\5\2\2\u00ae\u00b3\3\2\2\2\u00af\u00b0\f\f\2\2\u00b0\u00b1\7\b"+
-		"\2\2\u00b1\u00b3\7\61\2\2\u00b2\u009b\3\2\2\2\u00b2\u009e\3\2\2\2\u00b2"+
-		"\u00a1\3\2\2\2\u00b2\u00a4\3\2\2\2\u00b2\u00a7\3\2\2\2\u00b2\u00aa\3\2"+
-		"\2\2\u00b2\u00af\3\2\2\2\u00b3\u00b6\3\2\2\2\u00b4\u00b2\3\2\2\2\u00b4"+
-		"\u00b5\3\2\2\2\u00b5\13\3\2\2\2\u00b6\u00b4\3\2\2\2\u00b7\u00b9\7\21\2"+
-		"\2\u00b8\u00ba\5\36\20\2\u00b9\u00b8\3\2\2\2\u00b9\u00ba\3\2\2\2\u00ba"+
-		"\u00bb\3\2\2\2\u00bb\u00bc\7\4\2\2\u00bc\u00bd\5\24\13\2\u00bd\u00c0\7"+
-		"\5\2\2\u00be\u00bf\7\22\2\2\u00bf\u00c1\5 \21\2\u00c0\u00be\3\2\2\2\u00c0"+
-		"\u00c1\3\2\2\2\u00c1\u00c2\3\2\2\2\u00c2\u00c3\5*\26\2\u00c3\r\3\2\2\2"+
-		"\u00c4\u00c5\7\23\2\2\u00c5\u00c7\5.\30\2\u00c6\u00c8\5\36\20\2\u00c7"+
-		"\u00c6\3\2\2\2\u00c7\u00c8\3\2\2\2\u00c8\u00c9\3\2\2\2\u00c9\u00ca\7\4"+
-		"\2\2\u00ca\u00cb\5\24\13\2\u00cb\u00ce\7\5\2\2\u00cc\u00cd\7\22\2\2\u00cd"+
-		"\u00cf\5 \21\2\u00ce\u00cc\3\2\2\2\u00ce\u00cf\3\2\2\2\u00cf\u00d0\3\2"+
-		"\2\2\u00d0\u00d1\5*\26\2\u00d1\u00d4\3\2\2\2\u00d2\u00d4\5\20\t\2\u00d3"+
-		"\u00c4\3\2\2\2\u00d3\u00d2\3\2\2\2\u00d4\17\3\2\2\2\u00d5\u00d6\7\24\2"+
-		"\2\u00d6\u00e1\5(\25\2\u00d7\u00d8\7\t\2\2\u00d8\u00dd\7-\2\2\u00d9\u00da"+
-		"\7\3\2\2\u00da\u00dc\7-\2\2\u00db\u00d9\3\2\2\2\u00dc\u00df\3\2\2\2\u00dd"+
-		"\u00db\3\2\2\2\u00dd\u00de\3\2\2\2\u00de\u00e0\3\2\2\2\u00df\u00dd\3\2"+
-		"\2\2\u00e0\u00e2\7\n\2\2\u00e1\u00d7\3\2\2\2\u00e1\u00e2\3\2\2\2\u00e2"+
-		"\u00e3\3\2\2\2\u00e3\u00e5\7\16\2\2\u00e4\u00e6\5\22\n\2\u00e5\u00e4\3"+
-		"\2\2\2\u00e6\u00e7\3\2\2\2\u00e7\u00e5\3\2\2\2\u00e7\u00e8\3\2\2\2\u00e8"+
-		"\21\3\2\2\2\u00e9\u00ea\7\25\2\2\u00ea\u00f6\5(\25\2\u00eb\u00ec\7\4\2"+
-		"\2\u00ec\u00f1\5 \21\2\u00ed\u00ee\7\26\2\2\u00ee\u00f0\5 \21\2\u00ef"+
-		"\u00ed\3\2\2\2\u00f0\u00f3\3\2\2\2\u00f1\u00ef\3\2\2\2\u00f1\u00f2\3\2"+
-		"\2\2\u00f2\u00f4\3\2\2\2\u00f3\u00f1\3\2\2\2\u00f4\u00f5\7\5\2\2\u00f5"+
-		"\u00f7\3\2\2\2\u00f6\u00eb\3\2\2\2\u00f6\u00f7\3\2\2\2\u00f7\23\3\2\2"+
-		"\2\u00f8\u0103\5\26\f\2\u00f9\u00fa\5\30\r\2\u00fa\u00fb\7\3\2\2\u00fb"+
-		"\u00fd\3\2\2\2\u00fc\u00f9\3\2\2\2\u00fd\u0100\3\2\2\2\u00fe\u00fc\3\2"+
-		"\2\2\u00fe\u00ff\3\2\2\2\u00ff\u0101\3\2\2\2\u0100\u00fe\3\2\2\2\u0101"+
-		"\u0103\5\32\16\2\u0102\u00f8\3\2\2\2\u0102\u00fe\3\2\2\2\u0103\25\3\2"+
-		"\2\2\u0104\u0109\5\30\r\2\u0105\u0106\7\3\2\2\u0106\u0108\5\30\r\2\u0107"+
-		"\u0105\3\2\2\2\u0108\u010b\3\2\2\2\u0109\u0107\3\2\2\2\u0109\u010a\3\2"+
-		"\2\2\u010a\u010d\3\2\2\2\u010b\u0109\3\2\2\2\u010c\u0104\3\2\2\2\u010c"+
-		"\u010d\3\2\2\2\u010d\27\3\2\2\2\u010e\u0111\7-\2\2\u010f\u0110\7\27\2"+
-		"\2\u0110\u0112\5 \21\2\u0111\u010f\3\2\2\2\u0111\u0112\3\2\2\2\u0112\31"+
-		"\3\2\2\2\u0113\u0118\5\34\17\2\u0114\u0115\7\3\2\2\u0115\u0117\5\34\17"+
-		"\2\u0116\u0114\3\2\2\2\u0117\u011a\3\2\2\2\u0118\u0116\3\2\2\2\u0118\u0119"+
-		"\3\2\2\2\u0119\33\3\2\2\2\u011a\u0118\3\2\2\2\u011b\u011c\7+\2\2\u011c"+
-		"\u011d\7\16\2\2\u011d\u011e\5\n\6\2\u011e\35\3\2\2\2\u011f\u0120\7\t\2"+
-		"\2\u0120\u012d\7\n\2\2\u0121\u0122\7\t\2\2\u0122\u0127\5.\30\2\u0123\u0124"+
-		"\7\3\2\2\u0124\u0126\5.\30\2\u0125\u0123\3\2\2\2\u0126\u0129\3\2\2\2\u0127"+
-		"\u0125\3\2\2\2\u0127\u0128\3\2\2\2\u0128\u012a\3\2\2\2\u0129\u0127\3\2"+
-		"\2\2\u012a\u012b\7\n\2\2\u012b\u012d\3\2\2\2\u012c\u011f\3\2\2\2\u012c"+
-		"\u0121\3\2\2\2\u012d\37\3\2\2\2\u012e\u012f\7\4\2\2\u012f\u015c\7\5\2"+
-		"\2\u0130\u0131\7\4\2\2\u0131\u0132\5 \21\2\u0132\u0133\7\3\2\2\u0133\u0134"+
-		"\7\5\2\2\u0134\u015c\3\2\2\2\u0135\u0136\7\4\2\2\u0136\u0139\5 \21\2\u0137"+
-		"\u0138\7\3\2\2\u0138\u013a\5 \21\2\u0139\u0137\3\2\2\2\u013a\u013b\3\2"+
-		"\2\2\u013b\u0139\3\2\2\2\u013b\u013c\3\2\2\2\u013c\u013d\3\2\2\2\u013d"+
-		"\u013e\7\5\2\2\u013e\u015c\3\2\2\2\u013f\u015c\5(\25\2\u0140\u0141\7\30"+
-		"\2\2\u0141\u0142\7\t\2\2\u0142\u0143\5\"\22\2\u0143\u0144\7\3\2\2\u0144"+
-		"\u0145\5 \21\2\u0145\u0146\7\n\2\2\u0146\u015c\3\2\2\2\u0147\u0149\7\21"+
-		"\2\2\u0148\u014a\5\36\20\2\u0149\u0148\3\2\2\2\u0149\u014a\3\2\2\2\u014a"+
-		"\u014b\3\2\2\2\u014b\u0154\7\4\2\2\u014c\u0151\5 \21\2\u014d\u014e\7\3"+
-		"\2\2\u014e\u0150\5 \21\2\u014f\u014d\3\2\2\2\u0150\u0153\3\2\2\2\u0151"+
-		"\u014f\3\2\2\2\u0151\u0152\3\2\2\2\u0152\u0155\3\2\2\2\u0153\u0151\3\2"+
-		"\2\2\u0154\u014c\3\2\2\2\u0154\u0155\3\2\2\2\u0155\u0156\3\2\2\2\u0156"+
-		"\u0157\7\5\2\2\u0157\u0158\7\22\2\2\u0158\u015c\5 \21\2\u0159\u015c\7"+
-		"\31\2\2\u015a\u015c\7\61\2\2\u015b\u012e\3\2\2\2\u015b\u0130\3\2\2\2\u015b"+
-		"\u0135\3\2\2\2\u015b\u013f\3\2\2\2\u015b\u0140\3\2\2\2\u015b\u0147\3\2"+
-		"\2\2\u015b\u0159\3\2\2\2\u015b\u015a\3\2\2\2\u015c!\3\2\2\2\u015d\u015e"+
-		"\7\4\2\2\u015e\u0161\5&\24\2\u015f\u0160\7\3\2\2\u0160\u0162\5&\24\2\u0161"+
-		"\u015f\3\2\2\2\u0162\u0163\3\2\2\2\u0163\u0161\3\2\2\2\u0163\u0164\3\2"+
-		"\2\2\u0164\u0165\3\2\2\2\u0165\u0166\7\5\2\2\u0166\u016b\3\2\2\2\u0167"+
-		"\u0168\7\4\2\2\u0168\u016b\7\5\2\2\u0169\u016b\5&\24\2\u016a\u015d\3\2"+
-		"\2\2\u016a\u0167\3\2\2\2\u016a\u0169\3\2\2\2\u016b#\3\2\2\2\u016c\u016d"+
-		"\7\32\2\2\u016d\u016e\7\t\2\2\u016e\u016f\7+\2\2\u016f\u0170\7\n\2\2\u0170"+
-		"\u0171\7\t\2\2\u0171\u0172\7\61\2\2\u0172\u0173\7\n\2\2\u0173%\3\2\2\2"+
-		"\u0174\u017b\5$\23\2\u0175\u0176\7\4\2\2\u0176\u0177\5&\24\2\u0177\u0178"+
-		"\7\5\2\2\u0178\u017b\3\2\2\2\u0179\u017b\7\61\2\2\u017a\u0174\3\2\2\2"+
-		"\u017a\u0175\3\2\2\2\u017a\u0179\3\2\2\2\u017b\'\3\2\2\2\u017c\u017d\7"+
-		"+\2\2\u017d)\3\2\2\2\u017e\u017f\7\6\2\2\u017f\u0180\5\n\6\2\u0180\u0181"+
-		"\7\7\2\2\u0181+\3\2\2\2\u0182\u0186\7\60\2\2\u0183\u0186\7\61\2\2\u0184"+
-		"\u0186\7*\2\2\u0185\u0182\3\2\2\2\u0185\u0183\3\2\2\2\u0185\u0184\3\2"+
-		"\2\2\u0186-\3\2\2\2\u0187\u018c\5\2\2\2\u0188\u018c\7,\2\2\u0189\u018c"+
-		"\7-\2\2\u018a\u018c\7.\2\2\u018b\u0187\3\2\2\2\u018b\u0188\3\2\2\2\u018b"+
-		"\u0189\3\2\2\2\u018b\u018a\3\2\2\2\u018c/\3\2\2\2+\66:=FIQUpz}\u0099\u00b2"+
-		"\u00b4\u00b9\u00c0\u00c7\u00ce\u00d3\u00dd\u00e1\u00e7\u00f1\u00f6\u00fe"+
-		"\u0102\u0109\u010c\u0111\u0118\u0127\u012c\u013b\u0149\u0151\u0154\u015b"+
-		"\u0163\u016a\u017a\u0185\u018b";
-	public static final ATN _ATN =
-		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
-	static {
-		_decisionToDFA = new DFA[_ATN.getNumberOfDecisions()];
-		for (int i = 0; i < _ATN.getNumberOfDecisions(); i++) {
-			_decisionToDFA[i] = new DFA(_ATN.getDecisionState(i), i);
-		}
-	}
-}
\ No newline at end of file

From 95b9a9df4196342181c8a5f67a865ecef0073fbd Mon Sep 17 00:00:00 2001
From: Logan Weber <weberlo@cs.washington.edu>
Date: Fri, 30 Aug 2019 17:20:31 -0700
Subject: [PATCH 16/29] Lint roller

---
 src/relay/ir/pretty_printer.cc | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/relay/ir/pretty_printer.cc b/src/relay/ir/pretty_printer.cc
index eba295dba751..97e33e6b67c2 100644
--- a/src/relay/ir/pretty_printer.cc
+++ b/src/relay/ir/pretty_printer.cc
@@ -770,7 +770,8 @@ class PrettyPrinter :
     doc << " =";
 
     for (Constructor constructor : node->constructors) {
-      doc << PrintNewLine() << "  | " << Print(constructor, /* meta */ false, /* try_inline */ true);
+      doc << PrintNewLine() << "  | "
+          << Print(constructor, /* meta */ false, /* try_inline */ true);
     }
 
     return doc;

From 39fecdd02d8c5edeff9021243be53afb399d2809 Mon Sep 17 00:00:00 2001
From: Logan Weber <weberlo@cs.washington.edu>
Date: Fri, 30 Aug 2019 19:09:33 -0700
Subject: [PATCH 17/29] Lint roller

---
 python/tvm/relay/_parser.py | 44 ++++++++++++++++++-------------------
 1 file changed, 22 insertions(+), 22 deletions(-)

diff --git a/python/tvm/relay/_parser.py b/python/tvm/relay/_parser.py
index cf75f1084afd..24a645093f7a 100644
--- a/python/tvm/relay/_parser.py
+++ b/python/tvm/relay/_parser.py
@@ -206,7 +206,7 @@ def exit_var_scope(self) -> Scope[expr.Var]:
         """Pop off the current Var scope and return it."""
         return self.var_scopes.popleft()
 
-    def mk_var(self, name: str, typ: ty.Type=None):
+    def mk_var(self, name: str, typ: ty.Type = None):
         """Create a new Var and add it to the Var scope."""
         var = expr.Var(name, typ)
         self.var_scopes[0].appendleft((name, var))
@@ -254,11 +254,11 @@ def _check_existing_typ_expr(self, name, new_expr):
             raise ParseError(
                 f"{new_typ_name} `{name}` conflicts with existing {existing_typ_name}")
 
-    def _type_expr_name(self, expr):
-        if isinstance(expr, adt.Constructor):
-            return f"`{expr.belong_to.var.name}` ADT constructor"
-        elif isinstance(expr, ty.GlobalTypeVar):
-            if expr.kind == ty.Kind.AdtHandle:
+    def _type_expr_name(self, e):
+        if isinstance(e, adt.Constructor):
+            return f"`{e.belong_to.var.name}` ADT constructor"
+        elif isinstance(e, ty.GlobalTypeVar):
+            if e.kind == ty.Kind.AdtHandle:
                 return f"ADT definition"
         return "function definition"
 
@@ -269,9 +269,7 @@ def visitTerminal(self, node) -> Union[expr.Expr, int, float]:
         """Visit lexer tokens that aren't ignored or visited by other functions."""
         node_type = node.getSymbol().type
         node_text = node.getText()
-        name = node_text[1:]
 
-        # data types
         if node_type == RelayLexer.NAT:
             return int(node_text)
         if node_type == RelayLexer.FLOAT:
@@ -281,11 +279,10 @@ def visitTerminal(self, node) -> Union[expr.Expr, int, float]:
                 return True
             if node_text == "False":
                 return False
-            raise ParseError("Unrecognized BOOL_LIT: `{}`".format(node_text))
+            raise ParseError("unrecognized BOOL_LIT: `{}`".format(node_text))
         if node_type == RelayLexer.QUOTED_STRING:
             return literal_eval(node_text)
-
-        raise ParseError("todo: `{}`".format(node_text))
+        raise ParseError(f"unhandled terminal \"{node_text}\" of type `{node_type}`")
 
     def visitGeneralIdent(self, ctx):
         name = ctx.getText()
@@ -413,7 +410,7 @@ def visitBinOp(self, ctx: RelayParser.BinOpContext) -> expr.Call:
         relay_op = BINARY_OPS.get(ctx.op.type)
 
         if relay_op is None:
-            raise ParseError("Unimplemented binary op.")
+            raise ParseError("unimplemented binary op.")
 
         return relay_op(arg0, arg1)
 
@@ -423,7 +420,7 @@ def visitVar(self, ctx: RelayParser.VarContext) -> expr.Var:
         ident = ctx.localVar()
 
         if ident is None:
-            raise ParseError("Only local ids may be used in vars.")
+            raise ParseError("only local ids may be used in vars.")
 
         typeExpr = self.getTypeExpr(ctx.typeExpr())
 
@@ -442,11 +439,12 @@ def visitArgNoAttr(self, ctx: RelayParser.ArgNoAttrContext):
     def visitAttrSeq(self, ctx: RelayParser.AttrSeqContext) -> Dict[str, expr.Expr]:
         return dict(self.visit_list(ctx.attr()))
 
-    def visitArgWithAttr(self, ctx: RelayParser.AttrSeqContext) -> Tuple[List[expr.Var], Dict[str, expr.Expr]]:
+    def visitArgWithAttr(self, ctx: RelayParser.AttrSeqContext) \
+        -> Tuple[List[expr.Var], Dict[str, expr.Expr]]:
         return (self.visit_list(ctx.var()), self.visitAttrSeq(ctx.attrSeq()))
 
-    def visitArgList(self, ctx: RelayParser.ArgListContext) -> Tuple[Optional[List[expr.Var]], \
-                                                                     Optional[Dict[str, expr.Expr]]]:
+    def visitArgList(self, ctx: RelayParser.ArgListContext) \
+            -> Tuple[Optional[List[expr.Var]], Optional[Dict[str, expr.Expr]]]:
         var_list = self.visit(ctx.varList()) if ctx.varList() else None
         attr_list = self.visit(ctx.attrList()) if ctx.attrList() else None
         return (var_list, attr_list)
@@ -456,7 +454,10 @@ def visitMeta(self, ctx: RelayParser.MetaContext):
         index = int(self.visit(ctx.NAT()))
         return self.meta[type_key][index]
 
-    def mk_func(self, ctx: Union[RelayParser.FuncContext, RelayParser.DefnContext]) -> expr.Function:
+    def mk_func(
+        self,
+        ctx: Union[RelayParser.FuncContext, RelayParser.DefnContext]) \
+            -> expr.Function:
         """Construct a function from either a Func or Defn."""
         # Enter var scope early to put params in scope.
         self.enter_var_scope()
@@ -585,8 +586,7 @@ def call(self, func, args, attrs, type_args):
             return func(args, attrs, type_args)
         elif isinstance(func, adt.Constructor):
             return func(*args)
-        else:
-            return expr.Call(func, args, attrs, type_args)
+        return expr.Call(func, args, attrs, type_args)
 
     @spanify
     def visitCall(self, ctx: RelayParser.CallContext):
@@ -624,7 +624,7 @@ def visitGraph(self, ctx: RelayParser.GraphContext):
 
         if graph_nid != len(self.graph_expr):
             raise ParseError(
-                "Expected new graph variable to be `%{}`,".format(len(self.graph_expr)) + \
+                "expected new graph variable to be `%{}`,".format(len(self.graph_expr)) + \
                 "but got `%{}`".format(graph_nid))
         self.graph_expr.append(value)
 
@@ -662,7 +662,7 @@ def visitTensorType(self, ctx: RelayParser.TensorTypeContext):
         dtype = self.visit(ctx.typeExpr())
 
         if not isinstance(dtype, ty.TensorType):
-            raise ParseError("Expected dtype to be a Relay base type.")
+            raise ParseError("expected dtype to be a Relay base type.")
 
         dtype = dtype.dtype
 
@@ -721,7 +721,7 @@ def fromtext(data, source_name=None):
     # type: (str, str) -> Union[expr.Expr, module.Module]
     """Parse a Relay program."""
     if data == "":
-        raise ParseError("Cannot parse the empty string.")
+        raise ParseError("cannot parse the empty string.")
 
     global __source_name_counter__
 

From a8e128fa7d93009b0fe24d85086faf0764fcd956 Mon Sep 17 00:00:00 2001
From: Logan Weber <weberlo@cs.washington.edu>
Date: Fri, 30 Aug 2019 19:15:42 -0700
Subject: [PATCH 18/29] Address feedback

---
 python/tvm/relay/grammar/Relay.g4 | 4 ++--
 python/tvm/relay/ty.py            | 1 -
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/python/tvm/relay/grammar/Relay.g4 b/python/tvm/relay/grammar/Relay.g4
index e4c5d66dfb6a..84180b14dabd 100644
--- a/python/tvm/relay/grammar/Relay.g4
+++ b/python/tvm/relay/grammar/Relay.g4
@@ -17,9 +17,9 @@
  * under the License.
  */
 
-// TODO(weberlo): We need some way of indicating to users that you need to enable
-// USE_ANTLR in config.cmake.
 /*
+ * NOTE: The `USE_ANTLR` option in `config.cmake` must be enabled in order for
+ * changes in this file to be reflected by the parser.
  * NOTE: All upper-case rules are *lexer* rules and all camel-case rules are *parser* rules.
  */
 
diff --git a/python/tvm/relay/ty.py b/python/tvm/relay/ty.py
index 3b2ec565ce33..7e190fc405da 100644
--- a/python/tvm/relay/ty.py
+++ b/python/tvm/relay/ty.py
@@ -107,7 +107,6 @@ class Kind(IntEnum):
     Shape = 3
     Constraint = 4
     AdtHandle = 5
-    # TODO: This is never used.  Remove it?
     TypeData = 6
 
 @register_relay_node

From d31f6252732e2c6a978384f44a20841787df6a8e Mon Sep 17 00:00:00 2001
From: Logan Weber <weberlo@cs.washington.edu>
Date: Fri, 30 Aug 2019 20:01:49 -0700
Subject: [PATCH 19/29] Test completeness in match test

---
 python/tvm/relay/grammar/Relay.g4    |   1 +
 tests/python/relay/test_ir_parser.py | 107 ++++++++++++++-------------
 2 files changed, 56 insertions(+), 52 deletions(-)

diff --git a/python/tvm/relay/grammar/Relay.g4 b/python/tvm/relay/grammar/Relay.g4
index 84180b14dabd..3d5280d4fd94 100644
--- a/python/tvm/relay/grammar/Relay.g4
+++ b/python/tvm/relay/grammar/Relay.g4
@@ -127,6 +127,7 @@ constructorName: CNAME ;
 
 adtConsDefn: '|' constructorName ('(' typeExpr (',' typeExpr)* ')')? ;
 matchClause: '|' constructorName patternList? '=>' expr ;
+// complete or incomplete match, respectively
 matchType : 'match' | 'match?' ;
 
 patternList: '(' pattern (',' pattern)* ')';
diff --git a/tests/python/relay/test_ir_parser.py b/tests/python/relay/test_ir_parser.py
index e364040f47ae..23bcedf3dd38 100644
--- a/tests/python/relay/test_ir_parser.py
+++ b/tests/python/relay/test_ir_parser.py
@@ -700,59 +700,62 @@ def test_multiple_type_param_defn():
 
 
 def test_match():
-    mod = relay.Module()
-
-    list_var = relay.GlobalTypeVar("List")
-    typ_var = relay.TypeVar("A")
-    cons_constructor = relay.Constructor(
-        "Cons", [typ_var, list_var(typ_var)], list_var)
-    nil_constructor = relay.Constructor("Nil", [], list_var)
-    list_def = relay.TypeData(
-        list_var,
-        [typ_var],
-        [cons_constructor, nil_constructor])
-    mod[list_var] = list_def
-
-    length_var = relay.GlobalVar("length")
-    typ_var = relay.TypeVar("A")
-    input_type = list_var(typ_var)
-    input_var = relay.Var("xs", input_type)
-    rest_var = relay.Var("rest")
-    body = relay.Match(input_var,
-        [relay.Clause(
-            relay.PatternConstructor(
-                cons_constructor,
-                [relay.PatternWildcard(), relay.PatternVar(rest_var)]),
-            relay.add(relay.const(1), relay.Call(length_var, [rest_var]))
-            ),
-         relay.Clause(
-             relay.PatternConstructor(nil_constructor, []),
-             relay.const(0))],
-        complete=False
-    )
-    length_func = relay.Function(
-        [input_var],
-        body,
-        int32,
-        [typ_var]
-    )
-    mod[length_var] = length_func
-
-    assert parses_as(
-        """
-        type List[A] =
-          | Cons(A, List[A])
-          | Nil
+    # pair each match keyword with whether it specifies a complete match or not
+    match_keywords = [("match", True), ("match?", False)]
+    for (match_keyword, is_complete) in match_keywords:
+        mod = relay.Module()
+
+        list_var = relay.GlobalTypeVar("List")
+        typ_var = relay.TypeVar("A")
+        cons_constructor = relay.Constructor(
+            "Cons", [typ_var, list_var(typ_var)], list_var)
+        nil_constructor = relay.Constructor("Nil", [], list_var)
+        list_def = relay.TypeData(
+            list_var,
+            [typ_var],
+            [cons_constructor, nil_constructor])
+        mod[list_var] = list_def
+
+        length_var = relay.GlobalVar("length")
+        typ_var = relay.TypeVar("A")
+        input_type = list_var(typ_var)
+        input_var = relay.Var("xs", input_type)
+        rest_var = relay.Var("rest")
+        body = relay.Match(input_var,
+            [relay.Clause(
+                relay.PatternConstructor(
+                    cons_constructor,
+                    [relay.PatternWildcard(), relay.PatternVar(rest_var)]),
+                relay.add(relay.const(1), relay.Call(length_var, [rest_var]))
+                ),
+            relay.Clause(
+                relay.PatternConstructor(nil_constructor, []),
+                relay.const(0))],
+            complete=is_complete
+        )
+        length_func = relay.Function(
+            [input_var],
+            body,
+            int32,
+            [typ_var]
+        )
+        mod[length_var] = length_func
 
-        def @length[A](%xs: List[A]) -> int32 {
-          match? (%xs) {
-            | Cons(_, %rest) => 1 + @length(%rest)
-            | Nil => 0
-          }
-        }
-        """,
-        mod
-    )
+        assert parses_as(
+            """
+            type List[A] =
+            | Cons(A, List[A])
+            | Nil
+
+            def @length[A](%%xs: List[A]) -> int32 {
+            %s (%%xs) {
+                | Cons(_, %%rest) => 1 + @length(%%rest)
+                | Nil => 0
+            }
+            }
+            """ % match_keyword,
+            mod
+        )
 
 
 def test_adt_cons_expr():

From 1def01985bd5248cf0a3f784b362fa129f37e2f6 Mon Sep 17 00:00:00 2001
From: Logan Weber <weberlo@cs.washington.edu>
Date: Fri, 30 Aug 2019 20:03:58 -0700
Subject: [PATCH 20/29] Remove unused imports

---
 tests/python/relay/test_ir_text_printer.py | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/tests/python/relay/test_ir_text_printer.py b/tests/python/relay/test_ir_text_printer.py
index 082245ff74a5..a45273854985 100644
--- a/tests/python/relay/test_ir_text_printer.py
+++ b/tests/python/relay/test_ir_text_printer.py
@@ -21,12 +21,6 @@
 from tvm.relay import Expr
 from tvm.relay.analysis import alpha_equal, assert_alpha_equal, assert_graph_equal, free_vars
 
-from tvm.relay.ty import GlobalTypeVar, TypeVar, FuncType, TupleType, scalar_type
-from tvm.relay.expr import Var, Function, GlobalVar, Let, If, Tuple, TupleGetItem, const
-from tvm.relay.op.tensor import add, subtract, equal
-from tvm.relay.adt import Constructor, TypeData, Clause, Match
-from tvm.relay.adt import PatternConstructor, PatternVar, PatternWildcard
-
 do_print = [False]
 
 SEMVER = "v0.0.3\n"

From e1462d97f28a1a4a4c8d5c73765fca8c177f24fc Mon Sep 17 00:00:00 2001
From: Logan Weber <weberlo@cs.washington.edu>
Date: Sun, 1 Sep 2019 19:30:00 -0700
Subject: [PATCH 21/29] Lint roller

---
 python/tvm/relay/_parser.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/python/tvm/relay/_parser.py b/python/tvm/relay/_parser.py
index 24a645093f7a..a1c3238c95a6 100644
--- a/python/tvm/relay/_parser.py
+++ b/python/tvm/relay/_parser.py
@@ -455,8 +455,8 @@ def visitMeta(self, ctx: RelayParser.MetaContext):
         return self.meta[type_key][index]
 
     def mk_func(
-        self,
-        ctx: Union[RelayParser.FuncContext, RelayParser.DefnContext]) \
+            self,
+            ctx: Union[RelayParser.FuncContext, RelayParser.DefnContext]) \
             -> expr.Function:
         """Construct a function from either a Func or Defn."""
         # Enter var scope early to put params in scope.

From a5beffad12126e8b32089602f5aa3afa9f7c993f Mon Sep 17 00:00:00 2001
From: Logan Weber <weberlo@cs.washington.edu>
Date: Tue, 3 Sep 2019 13:09:38 -0700
Subject: [PATCH 22/29] Switch to Rust-style ADT syntax

---
 python/tvm/relay/_parser.py                  |   26 +-
 python/tvm/relay/analysis.py                 |    8 +-
 python/tvm/relay/grammar/Relay.g4            |   55 +-
 python/tvm/relay/grammar/py3/RelayLexer.py   |  342 +++--
 python/tvm/relay/grammar/py3/RelayParser.py  | 1420 ++++++++++--------
 python/tvm/relay/grammar/py3/RelayVisitor.py |   10 +
 src/relay/ir/alpha_equal.cc                  |   19 +-
 src/relay/ir/pretty_printer.cc               |   32 +-
 tests/python/relay/test_ir_parser.py         |  105 +-
 9 files changed, 1082 insertions(+), 935 deletions(-)

diff --git a/python/tvm/relay/_parser.py b/python/tvm/relay/_parser.py
index a1c3238c95a6..f21e367f39e3 100644
--- a/python/tvm/relay/_parser.py
+++ b/python/tvm/relay/_parser.py
@@ -514,16 +514,21 @@ def visitAdtDefn(self, ctx: RelayParser.AdtDefnContext):
                            for type_ident in type_params.generalIdent()]
 
         # parse constructors
-        constructors = []
-        for cons_defn in ctx.adtConsDefn():
+        adt_cons_defns = ctx.adtConsDefnList()
+        if adt_cons_defns is None:
+            adt_cons_defns = []
+        else:
+            adt_cons_defns = adt_cons_defns.adtConsDefn()
+        parsed_constructors = []
+        for cons_defn in adt_cons_defns:
             inputs = [self.visit(inp) for inp in cons_defn.typeExpr()]
             cons_defn_name = cons_defn.constructorName().getText()
             cons_defn = adt.Constructor(cons_defn_name, inputs, adt_handle)
             self.mk_global_typ_cons(cons_defn_name, cons_defn)
-            constructors.append(cons_defn)
+            parsed_constructors.append(cons_defn)
 
         # update module being built
-        self.module[adt_handle] = adt.TypeData(adt_handle, type_params, constructors)
+        self.module[adt_handle] = adt.TypeData(adt_handle, type_params, parsed_constructors)
 
         self.exit_type_param_scope()
 
@@ -539,8 +544,13 @@ def visitMatch(self, ctx: RelayParser.MatchContext):
         # TODO: Will need some kind of type checking to know which ADT is being
         # matched on.
         match_data = self.visit(ctx.expr())
-        clauses = []
-        for clause in ctx.matchClause():
+        match_clauses = ctx.matchClauseList()
+        if match_clauses is None:
+            match_clauses = []
+        else:
+            match_clauses = match_clauses.matchClause()
+        parsed_clauses = []
+        for clause in match_clauses:
             constructor_name = clause.constructorName().getText()
             constructor = self.global_type_vars[constructor_name]
             self.enter_var_scope()
@@ -552,14 +562,14 @@ def visitMatch(self, ctx: RelayParser.MatchContext):
             clause_body = self.visit(clause.expr())
             self.exit_var_scope()
             # TODO: Do we need to pass `None` if it's a 0-arity cons, or is an empty list fine?
-            clauses.append(adt.Clause(
+            parsed_clauses.append(adt.Clause(
                 adt.PatternConstructor(
                     constructor,
                     patterns
                 ),
                 clause_body
             ))
-        return adt.Match(match_data, clauses, complete=complete_match)
+        return adt.Match(match_data, parsed_clauses, complete=complete_match)
 
     def visitPattern(self, ctx: RelayParser.PatternContext):
         text = ctx.getText()
diff --git a/python/tvm/relay/analysis.py b/python/tvm/relay/analysis.py
index 7372fcdadd17..d4086f014e9a 100644
--- a/python/tvm/relay/analysis.py
+++ b/python/tvm/relay/analysis.py
@@ -254,7 +254,7 @@ def assert_alpha_equal(lhs, rhs):
     _make._assert_alpha_equal(lhs, rhs)
 
 
-def graph_equal(lhs, rhs):
+def is_unifiable(lhs, rhs):
     """Compare two Relay expr for data-flow equivalence.
     The difference between this and alpha-equality is that
     variables are not expected to match between lhs and rhs;
@@ -273,10 +273,10 @@ def graph_equal(lhs, rhs):
     result : bool
       True iff lhs is data-flow equivalent to rhs.
     """
-    return bool(_make._graph_equal(lhs, rhs))
+    return bool(_make._is_unifiable(lhs, rhs))
 
 
-def assert_graph_equal(lhs, rhs):
+def assert_is_unifiable(lhs, rhs):
     """Compare two Relay expr for data-flow equivalence.
     The difference between this and alpha-equality is that
     variables are not expected to match between lhs and rhs;
@@ -290,7 +290,7 @@ def assert_graph_equal(lhs, rhs):
     rhs : tvm.relay.Expr
       One of the input Expression.
     """
-    _make._assert_graph_equal(lhs, rhs)
+    _make._assert_is_unifiable(lhs, rhs)
 
 
 def collect_device_info(expr):
diff --git a/python/tvm/relay/grammar/Relay.g4 b/python/tvm/relay/grammar/Relay.g4
index 3d5280d4fd94..158df639eb9a 100644
--- a/python/tvm/relay/grammar/Relay.g4
+++ b/python/tvm/relay/grammar/Relay.g4
@@ -25,7 +25,7 @@
 
 grammar Relay;
 
-SEMVER: 'v0.0.3' ;
+SEMVER: 'v0.0.4' ;
 
 // Lexing
 // comments
@@ -87,46 +87,47 @@ callList
 
 expr
   // operators
-  : '(' expr ')'                                 # paren
-  | '{' expr '}'                                 # paren
+  : '(' expr ')'                                     # paren
   // function application
-  | expr '(' callList ')'                        # call
-  | '-' expr                                     # neg
-  | expr op=('*'|'/') expr                       # binOp
-  | expr op=('+'|'-') expr                       # binOp
-  | expr op=('<'|'>'|'<='|'>=') expr             # binOp
-  | expr op=('=='|'!=') expr                     # binOp
+  | expr '(' callList ')'                            # call
+  | '-' expr                                         # neg
+  | expr op=('*'|'/') expr                           # binOp
+  | expr op=('+'|'-') expr                           # binOp
+  | expr op=('<'|'>'|'<='|'>=') expr                 # binOp
+  | expr op=('=='|'!=') expr                         # binOp
   // function definition
-  | func                                         # funcExpr
+  | func                                             # funcExpr
   // tuples and tensors
-  | '(' ')'                                      # tuple
-  | '(' expr ',' ')'                             # tuple
-  | '(' expr (',' expr)+ ')'                     # tuple
-  | '[' (expr (',' expr)*)? ']'                  # tensor
-  | 'if' '(' expr ')' body 'else' body           # ifElse
-  | matchType '(' expr ')' '{' matchClause+ '}'  # match
-  | expr '.' NAT                                 # projection
+  | '(' ')'                                          # tuple
+  | '(' expr ',' ')'                                 # tuple
+  | '(' expr (',' expr)+ ')'                         # tuple
+  | '[' (expr (',' expr)*)? ']'                      # tensor
+  | 'if' '(' expr ')' body 'else' body               # ifElse
+  | matchType '(' expr ')' '{' matchClauseList? '}'  # match
+  | expr '.' NAT                                     # projection
   // sequencing
-  | 'let' var '=' expr ';' expr                  # let
+  | 'let' var '=' expr ';' expr                      # let
   // sugar for let %_ = expr; expr
-  | expr ';;' expr                               # let
-  | graphVar '=' expr ';' expr                   # graph
-  | ident                                        # identExpr
-  | scalar                                       # scalarExpr
-  | meta                                         # metaExpr
-  | QUOTED_STRING                                # stringExpr
+  | expr ';;' expr                                   # let
+  | graphVar '=' expr ';' expr                       # graph
+  | ident                                            # identExpr
+  | scalar                                           # scalarExpr
+  | meta                                             # metaExpr
+  | QUOTED_STRING                                    # stringExpr
   ;
 
 func: 'fn' typeParamList? '(' argList ')' ('->' typeExpr)? body ;
 defn
   : 'def' globalVar typeParamList? '(' argList ')' ('->' typeExpr)? body  # funcDefn
-  | 'type' generalIdent typeParamList? '=' adtConsDefn+                      # adtDefn
+  | 'type' generalIdent typeParamList? '{' adtConsDefnList? '}'           # adtDefn
   ;
 
 constructorName: CNAME ;
 
-adtConsDefn: '|' constructorName ('(' typeExpr (',' typeExpr)* ')')? ;
-matchClause: '|' constructorName patternList? '=>' expr ;
+adtConsDefnList: adtConsDefn (',' adtConsDefn)* ','? ;
+adtConsDefn: constructorName ('(' typeExpr (',' typeExpr)* ')')? ;
+matchClauseList: matchClause (',' matchClause)* ','? ;
+matchClause: constructorName patternList? '=>' ('{' expr '}' | expr) ;
 // complete or incomplete match, respectively
 matchType : 'match' | 'match?' ;
 
diff --git a/python/tvm/relay/grammar/py3/RelayLexer.py b/python/tvm/relay/grammar/py3/RelayLexer.py
index 177491a19018..bd4617852e30 100644
--- a/python/tvm/relay/grammar/py3/RelayLexer.py
+++ b/python/tvm/relay/grammar/py3/RelayLexer.py
@@ -8,8 +8,8 @@
 
 def serializedATN():
     with StringIO() as buf:
-        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\62")
-        buf.write("\u015c\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7")
+        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\61")
+        buf.write("\u0158\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7")
         buf.write("\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r")
         buf.write("\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23")
         buf.write("\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30")
@@ -17,146 +17,144 @@ def serializedATN():
         buf.write("\t\36\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%")
         buf.write("\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.")
         buf.write("\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64")
-        buf.write("\t\64\4\65\t\65\4\66\t\66\3\2\3\2\3\3\3\3\3\4\3\4\3\5")
-        buf.write("\3\5\3\6\3\6\3\7\3\7\3\b\3\b\3\t\3\t\3\n\3\n\3\13\3\13")
-        buf.write("\3\f\3\f\3\r\3\r\3\r\3\16\3\16\3\16\3\16\3\16\3\17\3\17")
-        buf.write("\3\17\3\17\3\20\3\20\3\21\3\21\3\22\3\22\3\22\3\23\3\23")
-        buf.write("\3\23\3\24\3\24\3\24\3\25\3\25\3\25\3\25\3\26\3\26\3\26")
-        buf.write("\3\26\3\26\3\27\3\27\3\30\3\30\3\30\3\31\3\31\3\31\3\31")
-        buf.write("\3\31\3\31\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\33\3\33")
-        buf.write("\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\35\3\35\3\35\3\35")
-        buf.write("\3\35\3\36\3\36\3\36\3\36\3\36\3\36\3\36\3\37\3\37\3\37")
-        buf.write("\3\37\3\37\7\37\u00d2\n\37\f\37\16\37\u00d5\13\37\3\37")
-        buf.write("\3\37\3\37\3\37\3\37\3 \6 \u00dd\n \r \16 \u00de\3 \3")
-        buf.write(" \3!\3!\3!\3!\7!\u00e7\n!\f!\16!\u00ea\13!\3!\3!\3!\3")
-        buf.write("!\3\"\3\"\3\"\3#\3#\3#\7#\u00f6\n#\f#\16#\u00f9\13#\3")
-        buf.write("#\3#\3$\3$\3%\3%\3&\3&\3\'\3\'\3(\3(\3)\3)\3*\3*\3*\3")
-        buf.write("+\3+\3+\3,\3,\3,\3-\3-\3-\3.\3.\3.\3.\3.\3.\3.\3.\3.\5")
-        buf.write(".\u011e\n.\3/\3/\5/\u0122\n/\3/\3/\3/\7/\u0127\n/\f/\16")
-        buf.write("/\u012a\13/\3/\3/\7/\u012e\n/\f/\16/\u0131\13/\3\60\3")
-        buf.write("\60\3\60\5\60\u0136\n\60\3\60\5\60\u0139\n\60\3\61\3\61")
-        buf.write("\3\61\3\62\6\62\u013f\n\62\r\62\16\62\u0140\3\63\3\63")
-        buf.write("\5\63\u0145\n\63\3\63\3\63\3\64\3\64\3\65\3\65\3\66\3")
-        buf.write("\66\3\66\3\66\3\66\3\66\3\66\3\66\3\66\3\66\3\66\7\66")
-        buf.write("\u0158\n\66\f\66\16\66\u015b\13\66\5\u00d3\u00e8\u00f7")
-        buf.write("\2\67\3\3\5\4\7\5\t\6\13\7\r\b\17\t\21\n\23\13\25\f\27")
-        buf.write("\r\31\16\33\17\35\20\37\21!\22#\23%\24\'\25)\26+\27-\30")
-        buf.write("/\31\61\32\63\33\65\34\67\359\36;\37= ?!A\"C\2E#G$I%K")
-        buf.write("&M\'O(Q)S*U+W,Y-[.]/_\2a\60c\61e\2g\2i\2k\62\3\2\b\5\2")
-        buf.write("\13\f\17\17\"\"\4\2\f\f\17\17\4\2GGgg\4\2--//\4\2C\\c")
-        buf.write("|\3\2\62;\2\u0167\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3\2\2\2")
-        buf.write("\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21")
-        buf.write("\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3")
-        buf.write("\2\2\2\2\33\3\2\2\2\2\35\3\2\2\2\2\37\3\2\2\2\2!\3\2\2")
-        buf.write("\2\2#\3\2\2\2\2%\3\2\2\2\2\'\3\2\2\2\2)\3\2\2\2\2+\3\2")
-        buf.write("\2\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("\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("\2\2\2?\3\2\2\2\2A\3\2\2\2\2E\3\2\2\2\2G\3\2\2\2\2I\3")
-        buf.write("\2\2\2\2K\3\2\2\2\2M\3\2\2\2\2O\3\2\2\2\2Q\3\2\2\2\2S")
-        buf.write("\3\2\2\2\2U\3\2\2\2\2W\3\2\2\2\2Y\3\2\2\2\2[\3\2\2\2\2")
-        buf.write("]\3\2\2\2\2a\3\2\2\2\2c\3\2\2\2\2k\3\2\2\2\3m\3\2\2\2")
-        buf.write("\5o\3\2\2\2\7q\3\2\2\2\ts\3\2\2\2\13u\3\2\2\2\rw\3\2\2")
-        buf.write("\2\17y\3\2\2\2\21{\3\2\2\2\23}\3\2\2\2\25\177\3\2\2\2")
-        buf.write("\27\u0081\3\2\2\2\31\u0083\3\2\2\2\33\u0086\3\2\2\2\35")
-        buf.write("\u008b\3\2\2\2\37\u008f\3\2\2\2!\u0091\3\2\2\2#\u0093")
-        buf.write("\3\2\2\2%\u0096\3\2\2\2\'\u0099\3\2\2\2)\u009c\3\2\2\2")
-        buf.write("+\u00a0\3\2\2\2-\u00a5\3\2\2\2/\u00a7\3\2\2\2\61\u00aa")
-        buf.write("\3\2\2\2\63\u00b0\3\2\2\2\65\u00b7\3\2\2\2\67\u00b9\3")
-        buf.write("\2\2\29\u00c0\3\2\2\2;\u00c5\3\2\2\2=\u00cc\3\2\2\2?\u00dc")
-        buf.write("\3\2\2\2A\u00e2\3\2\2\2C\u00ef\3\2\2\2E\u00f2\3\2\2\2")
-        buf.write("G\u00fc\3\2\2\2I\u00fe\3\2\2\2K\u0100\3\2\2\2M\u0102\3")
-        buf.write("\2\2\2O\u0104\3\2\2\2Q\u0106\3\2\2\2S\u0108\3\2\2\2U\u010b")
-        buf.write("\3\2\2\2W\u010e\3\2\2\2Y\u0111\3\2\2\2[\u011d\3\2\2\2")
-        buf.write("]\u0121\3\2\2\2_\u0132\3\2\2\2a\u013a\3\2\2\2c\u013e\3")
-        buf.write("\2\2\2e\u0142\3\2\2\2g\u0148\3\2\2\2i\u014a\3\2\2\2k\u014c")
-        buf.write("\3\2\2\2mn\7\60\2\2n\4\3\2\2\2op\7B\2\2p\6\3\2\2\2qr\7")
-        buf.write("\'\2\2r\b\3\2\2\2st\7a\2\2t\n\3\2\2\2uv\7.\2\2v\f\3\2")
-        buf.write("\2\2wx\7*\2\2x\16\3\2\2\2yz\7+\2\2z\20\3\2\2\2{|\7}\2")
-        buf.write("\2|\22\3\2\2\2}~\7\177\2\2~\24\3\2\2\2\177\u0080\7]\2")
-        buf.write("\2\u0080\26\3\2\2\2\u0081\u0082\7_\2\2\u0082\30\3\2\2")
-        buf.write("\2\u0083\u0084\7k\2\2\u0084\u0085\7h\2\2\u0085\32\3\2")
-        buf.write("\2\2\u0086\u0087\7g\2\2\u0087\u0088\7n\2\2\u0088\u0089")
-        buf.write("\7u\2\2\u0089\u008a\7g\2\2\u008a\34\3\2\2\2\u008b\u008c")
-        buf.write("\7n\2\2\u008c\u008d\7g\2\2\u008d\u008e\7v\2\2\u008e\36")
-        buf.write("\3\2\2\2\u008f\u0090\7?\2\2\u0090 \3\2\2\2\u0091\u0092")
-        buf.write("\7=\2\2\u0092\"\3\2\2\2\u0093\u0094\7=\2\2\u0094\u0095")
-        buf.write("\7=\2\2\u0095$\3\2\2\2\u0096\u0097\7h\2\2\u0097\u0098")
-        buf.write("\7p\2\2\u0098&\3\2\2\2\u0099\u009a\7/\2\2\u009a\u009b")
-        buf.write("\7@\2\2\u009b(\3\2\2\2\u009c\u009d\7f\2\2\u009d\u009e")
-        buf.write("\7g\2\2\u009e\u009f\7h\2\2\u009f*\3\2\2\2\u00a0\u00a1")
-        buf.write("\7v\2\2\u00a1\u00a2\7{\2\2\u00a2\u00a3\7r\2\2\u00a3\u00a4")
-        buf.write("\7g\2\2\u00a4,\3\2\2\2\u00a5\u00a6\7~\2\2\u00a6.\3\2\2")
-        buf.write("\2\u00a7\u00a8\7?\2\2\u00a8\u00a9\7@\2\2\u00a9\60\3\2")
-        buf.write("\2\2\u00aa\u00ab\7o\2\2\u00ab\u00ac\7c\2\2\u00ac\u00ad")
-        buf.write("\7v\2\2\u00ad\u00ae\7e\2\2\u00ae\u00af\7j\2\2\u00af\62")
-        buf.write("\3\2\2\2\u00b0\u00b1\7o\2\2\u00b1\u00b2\7c\2\2\u00b2\u00b3")
-        buf.write("\7v\2\2\u00b3\u00b4\7e\2\2\u00b4\u00b5\7j\2\2\u00b5\u00b6")
-        buf.write("\7A\2\2\u00b6\64\3\2\2\2\u00b7\u00b8\7<\2\2\u00b8\66\3")
-        buf.write("\2\2\2\u00b9\u00ba\7V\2\2\u00ba\u00bb\7g\2\2\u00bb\u00bc")
-        buf.write("\7p\2\2\u00bc\u00bd\7u\2\2\u00bd\u00be\7q\2\2\u00be\u00bf")
-        buf.write("\7t\2\2\u00bf8\3\2\2\2\u00c0\u00c1\7o\2\2\u00c1\u00c2")
-        buf.write("\7g\2\2\u00c2\u00c3\7v\2\2\u00c3\u00c4\7c\2\2\u00c4:\3")
-        buf.write("\2\2\2\u00c5\u00c6\7x\2\2\u00c6\u00c7\7\62\2\2\u00c7\u00c8")
-        buf.write("\7\60\2\2\u00c8\u00c9\7\62\2\2\u00c9\u00ca\7\60\2\2\u00ca")
-        buf.write("\u00cb\7\65\2\2\u00cb<\3\2\2\2\u00cc\u00cd\7\61\2\2\u00cd")
-        buf.write("\u00ce\7,\2\2\u00ce\u00d3\3\2\2\2\u00cf\u00d2\5=\37\2")
-        buf.write("\u00d0\u00d2\13\2\2\2\u00d1\u00cf\3\2\2\2\u00d1\u00d0")
-        buf.write("\3\2\2\2\u00d2\u00d5\3\2\2\2\u00d3\u00d4\3\2\2\2\u00d3")
-        buf.write("\u00d1\3\2\2\2\u00d4\u00d6\3\2\2\2\u00d5\u00d3\3\2\2\2")
-        buf.write("\u00d6\u00d7\7,\2\2\u00d7\u00d8\7\61\2\2\u00d8\u00d9\3")
-        buf.write("\2\2\2\u00d9\u00da\b\37\2\2\u00da>\3\2\2\2\u00db\u00dd")
-        buf.write("\t\2\2\2\u00dc\u00db\3\2\2\2\u00dd\u00de\3\2\2\2\u00de")
-        buf.write("\u00dc\3\2\2\2\u00de\u00df\3\2\2\2\u00df\u00e0\3\2\2\2")
-        buf.write("\u00e0\u00e1\b \2\2\u00e1@\3\2\2\2\u00e2\u00e3\7\61\2")
-        buf.write("\2\u00e3\u00e4\7\61\2\2\u00e4\u00e8\3\2\2\2\u00e5\u00e7")
-        buf.write("\13\2\2\2\u00e6\u00e5\3\2\2\2\u00e7\u00ea\3\2\2\2\u00e8")
-        buf.write("\u00e9\3\2\2\2\u00e8\u00e6\3\2\2\2\u00e9\u00eb\3\2\2\2")
-        buf.write("\u00ea\u00e8\3\2\2\2\u00eb\u00ec\7\f\2\2\u00ec\u00ed\3")
-        buf.write("\2\2\2\u00ed\u00ee\b!\2\2\u00eeB\3\2\2\2\u00ef\u00f0\7")
-        buf.write("^\2\2\u00f0\u00f1\7$\2\2\u00f1D\3\2\2\2\u00f2\u00f7\7")
-        buf.write("$\2\2\u00f3\u00f6\5C\"\2\u00f4\u00f6\n\3\2\2\u00f5\u00f3")
-        buf.write("\3\2\2\2\u00f5\u00f4\3\2\2\2\u00f6\u00f9\3\2\2\2\u00f7")
-        buf.write("\u00f8\3\2\2\2\u00f7\u00f5\3\2\2\2\u00f8\u00fa\3\2\2\2")
-        buf.write("\u00f9\u00f7\3\2\2\2\u00fa\u00fb\7$\2\2\u00fbF\3\2\2\2")
-        buf.write("\u00fc\u00fd\7,\2\2\u00fdH\3\2\2\2\u00fe\u00ff\7\61\2")
-        buf.write("\2\u00ffJ\3\2\2\2\u0100\u0101\7-\2\2\u0101L\3\2\2\2\u0102")
-        buf.write("\u0103\7/\2\2\u0103N\3\2\2\2\u0104\u0105\7>\2\2\u0105")
-        buf.write("P\3\2\2\2\u0106\u0107\7@\2\2\u0107R\3\2\2\2\u0108\u0109")
-        buf.write("\7>\2\2\u0109\u010a\7?\2\2\u010aT\3\2\2\2\u010b\u010c")
-        buf.write("\7@\2\2\u010c\u010d\7?\2\2\u010dV\3\2\2\2\u010e\u010f")
-        buf.write("\7?\2\2\u010f\u0110\7?\2\2\u0110X\3\2\2\2\u0111\u0112")
-        buf.write("\7#\2\2\u0112\u0113\7?\2\2\u0113Z\3\2\2\2\u0114\u0115")
-        buf.write("\7V\2\2\u0115\u0116\7t\2\2\u0116\u0117\7w\2\2\u0117\u011e")
-        buf.write("\7g\2\2\u0118\u0119\7H\2\2\u0119\u011a\7c\2\2\u011a\u011b")
-        buf.write("\7n\2\2\u011b\u011c\7u\2\2\u011c\u011e\7g\2\2\u011d\u0114")
-        buf.write("\3\2\2\2\u011d\u0118\3\2\2\2\u011e\\\3\2\2\2\u011f\u0122")
-        buf.write("\7a\2\2\u0120\u0122\5g\64\2\u0121\u011f\3\2\2\2\u0121")
-        buf.write("\u0120\3\2\2\2\u0122\u0128\3\2\2\2\u0123\u0127\7a\2\2")
-        buf.write("\u0124\u0127\5g\64\2\u0125\u0127\5i\65\2\u0126\u0123\3")
-        buf.write("\2\2\2\u0126\u0124\3\2\2\2\u0126\u0125\3\2\2\2\u0127\u012a")
-        buf.write("\3\2\2\2\u0128\u0126\3\2\2\2\u0128\u0129\3\2\2\2\u0129")
-        buf.write("\u012f\3\2\2\2\u012a\u0128\3\2\2\2\u012b\u012c\7\60\2")
-        buf.write("\2\u012c\u012e\5]/\2\u012d\u012b\3\2\2\2\u012e\u0131\3")
-        buf.write("\2\2\2\u012f\u012d\3\2\2\2\u012f\u0130\3\2\2\2\u0130^")
-        buf.write("\3\2\2\2\u0131\u012f\3\2\2\2\u0132\u0135\5c\62\2\u0133")
-        buf.write("\u0134\7\60\2\2\u0134\u0136\5c\62\2\u0135\u0133\3\2\2")
-        buf.write("\2\u0135\u0136\3\2\2\2\u0136\u0138\3\2\2\2\u0137\u0139")
-        buf.write("\5e\63\2\u0138\u0137\3\2\2\2\u0138\u0139\3\2\2\2\u0139")
-        buf.write("`\3\2\2\2\u013a\u013b\5_\60\2\u013b\u013c\7h\2\2\u013c")
-        buf.write("b\3\2\2\2\u013d\u013f\5i\65\2\u013e\u013d\3\2\2\2\u013f")
-        buf.write("\u0140\3\2\2\2\u0140\u013e\3\2\2\2\u0140\u0141\3\2\2\2")
-        buf.write("\u0141d\3\2\2\2\u0142\u0144\t\4\2\2\u0143\u0145\t\5\2")
-        buf.write("\2\u0144\u0143\3\2\2\2\u0144\u0145\3\2\2\2\u0145\u0146")
-        buf.write("\3\2\2\2\u0146\u0147\5c\62\2\u0147f\3\2\2\2\u0148\u0149")
-        buf.write("\t\6\2\2\u0149h\3\2\2\2\u014a\u014b\t\7\2\2\u014bj\3\2")
-        buf.write("\2\2\u014c\u014d\7O\2\2\u014d\u014e\7G\2\2\u014e\u014f")
-        buf.write("\7V\2\2\u014f\u0150\7C\2\2\u0150\u0151\7F\2\2\u0151\u0152")
-        buf.write("\7C\2\2\u0152\u0153\7V\2\2\u0153\u0154\7C\2\2\u0154\u0155")
-        buf.write("\7<\2\2\u0155\u0159\3\2\2\2\u0156\u0158\13\2\2\2\u0157")
-        buf.write("\u0156\3\2\2\2\u0158\u015b\3\2\2\2\u0159\u0157\3\2\2\2")
-        buf.write("\u0159\u015a\3\2\2\2\u015al\3\2\2\2\u015b\u0159\3\2\2")
-        buf.write("\2\23\2\u00d1\u00d3\u00de\u00e8\u00f5\u00f7\u011d\u0121")
-        buf.write("\u0126\u0128\u012f\u0135\u0138\u0140\u0144\u0159\3\b\2")
+        buf.write("\t\64\4\65\t\65\3\2\3\2\3\3\3\3\3\4\3\4\3\5\3\5\3\6\3")
+        buf.write("\6\3\7\3\7\3\b\3\b\3\t\3\t\3\n\3\n\3\13\3\13\3\13\3\f")
+        buf.write("\3\f\3\f\3\f\3\f\3\r\3\r\3\16\3\16\3\17\3\17\3\17\3\17")
+        buf.write("\3\20\3\20\3\21\3\21\3\22\3\22\3\22\3\23\3\23\3\23\3\24")
+        buf.write("\3\24\3\24\3\25\3\25\3\25\3\25\3\26\3\26\3\26\3\26\3\26")
+        buf.write("\3\27\3\27\3\27\3\30\3\30\3\30\3\30\3\30\3\30\3\31\3\31")
+        buf.write("\3\31\3\31\3\31\3\31\3\31\3\32\3\32\3\33\3\33\3\33\3\33")
+        buf.write("\3\33\3\33\3\33\3\34\3\34\3\34\3\34\3\34\3\35\3\35\3\35")
+        buf.write("\3\35\3\35\3\35\3\35\3\36\3\36\3\36\3\36\3\36\7\36\u00ce")
+        buf.write("\n\36\f\36\16\36\u00d1\13\36\3\36\3\36\3\36\3\36\3\36")
+        buf.write("\3\37\6\37\u00d9\n\37\r\37\16\37\u00da\3\37\3\37\3 \3")
+        buf.write(" \3 \3 \7 \u00e3\n \f \16 \u00e6\13 \3 \3 \3 \3 \3!\3")
+        buf.write("!\3!\3\"\3\"\3\"\7\"\u00f2\n\"\f\"\16\"\u00f5\13\"\3\"")
+        buf.write("\3\"\3#\3#\3$\3$\3%\3%\3&\3&\3\'\3\'\3(\3(\3)\3)\3)\3")
+        buf.write("*\3*\3*\3+\3+\3+\3,\3,\3,\3-\3-\3-\3-\3-\3-\3-\3-\3-\5")
+        buf.write("-\u011a\n-\3.\3.\5.\u011e\n.\3.\3.\3.\7.\u0123\n.\f.\16")
+        buf.write(".\u0126\13.\3.\3.\7.\u012a\n.\f.\16.\u012d\13.\3/\3/\3")
+        buf.write("/\5/\u0132\n/\3/\5/\u0135\n/\3\60\3\60\3\60\3\61\6\61")
+        buf.write("\u013b\n\61\r\61\16\61\u013c\3\62\3\62\5\62\u0141\n\62")
+        buf.write("\3\62\3\62\3\63\3\63\3\64\3\64\3\65\3\65\3\65\3\65\3\65")
+        buf.write("\3\65\3\65\3\65\3\65\3\65\3\65\7\65\u0154\n\65\f\65\16")
+        buf.write("\65\u0157\13\65\5\u00cf\u00e4\u00f3\2\66\3\3\5\4\7\5\t")
+        buf.write("\6\13\7\r\b\17\t\21\n\23\13\25\f\27\r\31\16\33\17\35\20")
+        buf.write("\37\21!\22#\23%\24\'\25)\26+\27-\30/\31\61\32\63\33\65")
+        buf.write("\34\67\359\36;\37= ?!A\2C\"E#G$I%K&M\'O(Q)S*U+W,Y-[.]")
+        buf.write("\2_/a\60c\2e\2g\2i\61\3\2\b\5\2\13\f\17\17\"\"\4\2\f\f")
+        buf.write("\17\17\4\2GGgg\4\2--//\4\2C\\c|\3\2\62;\2\u0163\2\3\3")
+        buf.write("\2\2\2\2\5\3\2\2\2\2\7\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2")
+        buf.write("\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2\2")
+        buf.write("\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2\2")
+        buf.write("\35\3\2\2\2\2\37\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2%\3\2")
+        buf.write("\2\2\2\'\3\2\2\2\2)\3\2\2\2\2+\3\2\2\2\2-\3\2\2\2\2/\3")
+        buf.write("\2\2\2\2\61\3\2\2\2\2\63\3\2\2\2\2\65\3\2\2\2\2\67\3\2")
+        buf.write("\2\2\29\3\2\2\2\2;\3\2\2\2\2=\3\2\2\2\2?\3\2\2\2\2C\3")
+        buf.write("\2\2\2\2E\3\2\2\2\2G\3\2\2\2\2I\3\2\2\2\2K\3\2\2\2\2M")
+        buf.write("\3\2\2\2\2O\3\2\2\2\2Q\3\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2")
+        buf.write("W\3\2\2\2\2Y\3\2\2\2\2[\3\2\2\2\2_\3\2\2\2\2a\3\2\2\2")
+        buf.write("\2i\3\2\2\2\3k\3\2\2\2\5m\3\2\2\2\7o\3\2\2\2\tq\3\2\2")
+        buf.write("\2\13s\3\2\2\2\ru\3\2\2\2\17w\3\2\2\2\21y\3\2\2\2\23{")
+        buf.write("\3\2\2\2\25}\3\2\2\2\27\u0080\3\2\2\2\31\u0085\3\2\2\2")
+        buf.write("\33\u0087\3\2\2\2\35\u0089\3\2\2\2\37\u008d\3\2\2\2!\u008f")
+        buf.write("\3\2\2\2#\u0091\3\2\2\2%\u0094\3\2\2\2\'\u0097\3\2\2\2")
+        buf.write(")\u009a\3\2\2\2+\u009e\3\2\2\2-\u00a3\3\2\2\2/\u00a6\3")
+        buf.write("\2\2\2\61\u00ac\3\2\2\2\63\u00b3\3\2\2\2\65\u00b5\3\2")
+        buf.write("\2\2\67\u00bc\3\2\2\29\u00c1\3\2\2\2;\u00c8\3\2\2\2=\u00d8")
+        buf.write("\3\2\2\2?\u00de\3\2\2\2A\u00eb\3\2\2\2C\u00ee\3\2\2\2")
+        buf.write("E\u00f8\3\2\2\2G\u00fa\3\2\2\2I\u00fc\3\2\2\2K\u00fe\3")
+        buf.write("\2\2\2M\u0100\3\2\2\2O\u0102\3\2\2\2Q\u0104\3\2\2\2S\u0107")
+        buf.write("\3\2\2\2U\u010a\3\2\2\2W\u010d\3\2\2\2Y\u0119\3\2\2\2")
+        buf.write("[\u011d\3\2\2\2]\u012e\3\2\2\2_\u0136\3\2\2\2a\u013a\3")
+        buf.write("\2\2\2c\u013e\3\2\2\2e\u0144\3\2\2\2g\u0146\3\2\2\2i\u0148")
+        buf.write("\3\2\2\2kl\7\60\2\2l\4\3\2\2\2mn\7B\2\2n\6\3\2\2\2op\7")
+        buf.write("\'\2\2p\b\3\2\2\2qr\7a\2\2r\n\3\2\2\2st\7.\2\2t\f\3\2")
+        buf.write("\2\2uv\7*\2\2v\16\3\2\2\2wx\7+\2\2x\20\3\2\2\2yz\7]\2")
+        buf.write("\2z\22\3\2\2\2{|\7_\2\2|\24\3\2\2\2}~\7k\2\2~\177\7h\2")
+        buf.write("\2\177\26\3\2\2\2\u0080\u0081\7g\2\2\u0081\u0082\7n\2")
+        buf.write("\2\u0082\u0083\7u\2\2\u0083\u0084\7g\2\2\u0084\30\3\2")
+        buf.write("\2\2\u0085\u0086\7}\2\2\u0086\32\3\2\2\2\u0087\u0088\7")
+        buf.write("\177\2\2\u0088\34\3\2\2\2\u0089\u008a\7n\2\2\u008a\u008b")
+        buf.write("\7g\2\2\u008b\u008c\7v\2\2\u008c\36\3\2\2\2\u008d\u008e")
+        buf.write("\7?\2\2\u008e \3\2\2\2\u008f\u0090\7=\2\2\u0090\"\3\2")
+        buf.write("\2\2\u0091\u0092\7=\2\2\u0092\u0093\7=\2\2\u0093$\3\2")
+        buf.write("\2\2\u0094\u0095\7h\2\2\u0095\u0096\7p\2\2\u0096&\3\2")
+        buf.write("\2\2\u0097\u0098\7/\2\2\u0098\u0099\7@\2\2\u0099(\3\2")
+        buf.write("\2\2\u009a\u009b\7f\2\2\u009b\u009c\7g\2\2\u009c\u009d")
+        buf.write("\7h\2\2\u009d*\3\2\2\2\u009e\u009f\7v\2\2\u009f\u00a0")
+        buf.write("\7{\2\2\u00a0\u00a1\7r\2\2\u00a1\u00a2\7g\2\2\u00a2,\3")
+        buf.write("\2\2\2\u00a3\u00a4\7?\2\2\u00a4\u00a5\7@\2\2\u00a5.\3")
+        buf.write("\2\2\2\u00a6\u00a7\7o\2\2\u00a7\u00a8\7c\2\2\u00a8\u00a9")
+        buf.write("\7v\2\2\u00a9\u00aa\7e\2\2\u00aa\u00ab\7j\2\2\u00ab\60")
+        buf.write("\3\2\2\2\u00ac\u00ad\7o\2\2\u00ad\u00ae\7c\2\2\u00ae\u00af")
+        buf.write("\7v\2\2\u00af\u00b0\7e\2\2\u00b0\u00b1\7j\2\2\u00b1\u00b2")
+        buf.write("\7A\2\2\u00b2\62\3\2\2\2\u00b3\u00b4\7<\2\2\u00b4\64\3")
+        buf.write("\2\2\2\u00b5\u00b6\7V\2\2\u00b6\u00b7\7g\2\2\u00b7\u00b8")
+        buf.write("\7p\2\2\u00b8\u00b9\7u\2\2\u00b9\u00ba\7q\2\2\u00ba\u00bb")
+        buf.write("\7t\2\2\u00bb\66\3\2\2\2\u00bc\u00bd\7o\2\2\u00bd\u00be")
+        buf.write("\7g\2\2\u00be\u00bf\7v\2\2\u00bf\u00c0\7c\2\2\u00c08\3")
+        buf.write("\2\2\2\u00c1\u00c2\7x\2\2\u00c2\u00c3\7\62\2\2\u00c3\u00c4")
+        buf.write("\7\60\2\2\u00c4\u00c5\7\62\2\2\u00c5\u00c6\7\60\2\2\u00c6")
+        buf.write("\u00c7\7\66\2\2\u00c7:\3\2\2\2\u00c8\u00c9\7\61\2\2\u00c9")
+        buf.write("\u00ca\7,\2\2\u00ca\u00cf\3\2\2\2\u00cb\u00ce\5;\36\2")
+        buf.write("\u00cc\u00ce\13\2\2\2\u00cd\u00cb\3\2\2\2\u00cd\u00cc")
+        buf.write("\3\2\2\2\u00ce\u00d1\3\2\2\2\u00cf\u00d0\3\2\2\2\u00cf")
+        buf.write("\u00cd\3\2\2\2\u00d0\u00d2\3\2\2\2\u00d1\u00cf\3\2\2\2")
+        buf.write("\u00d2\u00d3\7,\2\2\u00d3\u00d4\7\61\2\2\u00d4\u00d5\3")
+        buf.write("\2\2\2\u00d5\u00d6\b\36\2\2\u00d6<\3\2\2\2\u00d7\u00d9")
+        buf.write("\t\2\2\2\u00d8\u00d7\3\2\2\2\u00d9\u00da\3\2\2\2\u00da")
+        buf.write("\u00d8\3\2\2\2\u00da\u00db\3\2\2\2\u00db\u00dc\3\2\2\2")
+        buf.write("\u00dc\u00dd\b\37\2\2\u00dd>\3\2\2\2\u00de\u00df\7\61")
+        buf.write("\2\2\u00df\u00e0\7\61\2\2\u00e0\u00e4\3\2\2\2\u00e1\u00e3")
+        buf.write("\13\2\2\2\u00e2\u00e1\3\2\2\2\u00e3\u00e6\3\2\2\2\u00e4")
+        buf.write("\u00e5\3\2\2\2\u00e4\u00e2\3\2\2\2\u00e5\u00e7\3\2\2\2")
+        buf.write("\u00e6\u00e4\3\2\2\2\u00e7\u00e8\7\f\2\2\u00e8\u00e9\3")
+        buf.write("\2\2\2\u00e9\u00ea\b \2\2\u00ea@\3\2\2\2\u00eb\u00ec\7")
+        buf.write("^\2\2\u00ec\u00ed\7$\2\2\u00edB\3\2\2\2\u00ee\u00f3\7")
+        buf.write("$\2\2\u00ef\u00f2\5A!\2\u00f0\u00f2\n\3\2\2\u00f1\u00ef")
+        buf.write("\3\2\2\2\u00f1\u00f0\3\2\2\2\u00f2\u00f5\3\2\2\2\u00f3")
+        buf.write("\u00f4\3\2\2\2\u00f3\u00f1\3\2\2\2\u00f4\u00f6\3\2\2\2")
+        buf.write("\u00f5\u00f3\3\2\2\2\u00f6\u00f7\7$\2\2\u00f7D\3\2\2\2")
+        buf.write("\u00f8\u00f9\7,\2\2\u00f9F\3\2\2\2\u00fa\u00fb\7\61\2")
+        buf.write("\2\u00fbH\3\2\2\2\u00fc\u00fd\7-\2\2\u00fdJ\3\2\2\2\u00fe")
+        buf.write("\u00ff\7/\2\2\u00ffL\3\2\2\2\u0100\u0101\7>\2\2\u0101")
+        buf.write("N\3\2\2\2\u0102\u0103\7@\2\2\u0103P\3\2\2\2\u0104\u0105")
+        buf.write("\7>\2\2\u0105\u0106\7?\2\2\u0106R\3\2\2\2\u0107\u0108")
+        buf.write("\7@\2\2\u0108\u0109\7?\2\2\u0109T\3\2\2\2\u010a\u010b")
+        buf.write("\7?\2\2\u010b\u010c\7?\2\2\u010cV\3\2\2\2\u010d\u010e")
+        buf.write("\7#\2\2\u010e\u010f\7?\2\2\u010fX\3\2\2\2\u0110\u0111")
+        buf.write("\7V\2\2\u0111\u0112\7t\2\2\u0112\u0113\7w\2\2\u0113\u011a")
+        buf.write("\7g\2\2\u0114\u0115\7H\2\2\u0115\u0116\7c\2\2\u0116\u0117")
+        buf.write("\7n\2\2\u0117\u0118\7u\2\2\u0118\u011a\7g\2\2\u0119\u0110")
+        buf.write("\3\2\2\2\u0119\u0114\3\2\2\2\u011aZ\3\2\2\2\u011b\u011e")
+        buf.write("\7a\2\2\u011c\u011e\5e\63\2\u011d\u011b\3\2\2\2\u011d")
+        buf.write("\u011c\3\2\2\2\u011e\u0124\3\2\2\2\u011f\u0123\7a\2\2")
+        buf.write("\u0120\u0123\5e\63\2\u0121\u0123\5g\64\2\u0122\u011f\3")
+        buf.write("\2\2\2\u0122\u0120\3\2\2\2\u0122\u0121\3\2\2\2\u0123\u0126")
+        buf.write("\3\2\2\2\u0124\u0122\3\2\2\2\u0124\u0125\3\2\2\2\u0125")
+        buf.write("\u012b\3\2\2\2\u0126\u0124\3\2\2\2\u0127\u0128\7\60\2")
+        buf.write("\2\u0128\u012a\5[.\2\u0129\u0127\3\2\2\2\u012a\u012d\3")
+        buf.write("\2\2\2\u012b\u0129\3\2\2\2\u012b\u012c\3\2\2\2\u012c\\")
+        buf.write("\3\2\2\2\u012d\u012b\3\2\2\2\u012e\u0131\5a\61\2\u012f")
+        buf.write("\u0130\7\60\2\2\u0130\u0132\5a\61\2\u0131\u012f\3\2\2")
+        buf.write("\2\u0131\u0132\3\2\2\2\u0132\u0134\3\2\2\2\u0133\u0135")
+        buf.write("\5c\62\2\u0134\u0133\3\2\2\2\u0134\u0135\3\2\2\2\u0135")
+        buf.write("^\3\2\2\2\u0136\u0137\5]/\2\u0137\u0138\7h\2\2\u0138`")
+        buf.write("\3\2\2\2\u0139\u013b\5g\64\2\u013a\u0139\3\2\2\2\u013b")
+        buf.write("\u013c\3\2\2\2\u013c\u013a\3\2\2\2\u013c\u013d\3\2\2\2")
+        buf.write("\u013db\3\2\2\2\u013e\u0140\t\4\2\2\u013f\u0141\t\5\2")
+        buf.write("\2\u0140\u013f\3\2\2\2\u0140\u0141\3\2\2\2\u0141\u0142")
+        buf.write("\3\2\2\2\u0142\u0143\5a\61\2\u0143d\3\2\2\2\u0144\u0145")
+        buf.write("\t\6\2\2\u0145f\3\2\2\2\u0146\u0147\t\7\2\2\u0147h\3\2")
+        buf.write("\2\2\u0148\u0149\7O\2\2\u0149\u014a\7G\2\2\u014a\u014b")
+        buf.write("\7V\2\2\u014b\u014c\7C\2\2\u014c\u014d\7F\2\2\u014d\u014e")
+        buf.write("\7C\2\2\u014e\u014f\7V\2\2\u014f\u0150\7C\2\2\u0150\u0151")
+        buf.write("\7<\2\2\u0151\u0155\3\2\2\2\u0152\u0154\13\2\2\2\u0153")
+        buf.write("\u0152\3\2\2\2\u0154\u0157\3\2\2\2\u0155\u0153\3\2\2\2")
+        buf.write("\u0155\u0156\3\2\2\2\u0156j\3\2\2\2\u0157\u0155\3\2\2")
+        buf.write("\2\23\2\u00cd\u00cf\u00da\u00e4\u00f1\u00f3\u0119\u011d")
+        buf.write("\u0122\u0124\u012b\u0131\u0134\u013c\u0140\u0155\3\b\2")
         buf.write("\2")
         return buf.getvalue()
 
@@ -194,38 +192,37 @@ class RelayLexer(Lexer):
     T__24 = 25
     T__25 = 26
     T__26 = 27
-    T__27 = 28
-    SEMVER = 29
-    COMMENT = 30
-    WS = 31
-    LINE_COMMENT = 32
-    QUOTED_STRING = 33
-    MUL = 34
-    DIV = 35
-    ADD = 36
-    SUB = 37
-    LT = 38
-    GT = 39
-    LE = 40
-    GE = 41
-    EQ = 42
-    NE = 43
-    BOOL_LIT = 44
-    CNAME = 45
-    FLOAT = 46
-    NAT = 47
-    METADATA = 48
+    SEMVER = 28
+    COMMENT = 29
+    WS = 30
+    LINE_COMMENT = 31
+    QUOTED_STRING = 32
+    MUL = 33
+    DIV = 34
+    ADD = 35
+    SUB = 36
+    LT = 37
+    GT = 38
+    LE = 39
+    GE = 40
+    EQ = 41
+    NE = 42
+    BOOL_LIT = 43
+    CNAME = 44
+    FLOAT = 45
+    NAT = 46
+    METADATA = 47
 
     channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ]
 
     modeNames = [ "DEFAULT_MODE" ]
 
     literalNames = [ "<INVALID>",
-            "'.'", "'@'", "'%'", "'_'", "','", "'('", "')'", "'{'", "'}'", 
-            "'['", "']'", "'if'", "'else'", "'let'", "'='", "';'", "';;'", 
-            "'fn'", "'->'", "'def'", "'type'", "'|'", "'=>'", "'match'", 
-            "'match?'", "':'", "'Tensor'", "'meta'", "'v0.0.3'", "'*'", 
-            "'/'", "'+'", "'-'", "'<'", "'>'", "'<='", "'>='", "'=='", "'!='" ]
+            "'.'", "'@'", "'%'", "'_'", "','", "'('", "')'", "'['", "']'", 
+            "'if'", "'else'", "'{'", "'}'", "'let'", "'='", "';'", "';;'", 
+            "'fn'", "'->'", "'def'", "'type'", "'=>'", "'match'", "'match?'", 
+            "':'", "'Tensor'", "'meta'", "'v0.0.4'", "'*'", "'/'", "'+'", 
+            "'-'", "'<'", "'>'", "'<='", "'>='", "'=='", "'!='" ]
 
     symbolicNames = [ "<INVALID>",
             "SEMVER", "COMMENT", "WS", "LINE_COMMENT", "QUOTED_STRING", 
@@ -236,11 +233,10 @@ class RelayLexer(Lexer):
                   "T__7", "T__8", "T__9", "T__10", "T__11", "T__12", "T__13", 
                   "T__14", "T__15", "T__16", "T__17", "T__18", "T__19", 
                   "T__20", "T__21", "T__22", "T__23", "T__24", "T__25", 
-                  "T__26", "T__27", "SEMVER", "COMMENT", "WS", "LINE_COMMENT", 
-                  "ESCAPED_QUOTE", "QUOTED_STRING", "MUL", "DIV", "ADD", 
-                  "SUB", "LT", "GT", "LE", "GE", "EQ", "NE", "BOOL_LIT", 
-                  "CNAME", "PREFLOAT", "FLOAT", "NAT", "EXP", "LETTER", 
-                  "DIGIT", "METADATA" ]
+                  "T__26", "SEMVER", "COMMENT", "WS", "LINE_COMMENT", "ESCAPED_QUOTE", 
+                  "QUOTED_STRING", "MUL", "DIV", "ADD", "SUB", "LT", "GT", 
+                  "LE", "GE", "EQ", "NE", "BOOL_LIT", "CNAME", "PREFLOAT", 
+                  "FLOAT", "NAT", "EXP", "LETTER", "DIGIT", "METADATA" ]
 
     grammarFileName = "Relay.g4"
 
diff --git a/python/tvm/relay/grammar/py3/RelayParser.py b/python/tvm/relay/grammar/py3/RelayParser.py
index 03b162d93c60..1fb9ca555601 100644
--- a/python/tvm/relay/grammar/py3/RelayParser.py
+++ b/python/tvm/relay/grammar/py3/RelayParser.py
@@ -8,237 +8,249 @@
 
 def serializedATN():
     with StringIO() as buf:
-        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\62")
-        buf.write("\u01df\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
+        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\61")
+        buf.write("\u01f6\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
         buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
         buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
         buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
         buf.write("\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36")
-        buf.write("\4\37\t\37\4 \t \4!\t!\3\2\3\2\7\2E\n\2\f\2\16\2H\13\2")
-        buf.write("\3\2\5\2K\n\2\3\2\5\2N\n\2\3\2\3\2\3\3\3\3\3\3\7\3U\n")
-        buf.write("\3\f\3\16\3X\13\3\3\4\3\4\3\4\3\5\3\5\3\5\3\6\3\6\3\6")
-        buf.write("\3\7\3\7\3\7\7\7f\n\7\f\7\16\7i\13\7\5\7k\n\7\3\b\3\b")
-        buf.write("\3\b\3\b\7\bq\n\b\f\b\16\bt\13\b\3\b\5\bw\n\b\3\t\3\t")
-        buf.write("\3\t\3\t\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("\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\3\2\3\2\7\2I\n\2")
+        buf.write("\f\2\16\2L\13\2\3\2\5\2O\n\2\3\2\5\2R\n\2\3\2\3\2\3\3")
+        buf.write("\3\3\3\3\7\3Y\n\3\f\3\16\3\\\13\3\3\4\3\4\3\4\3\5\3\5")
+        buf.write("\3\5\3\6\3\6\3\6\3\7\3\7\3\7\7\7j\n\7\f\7\16\7m\13\7\5")
+        buf.write("\7o\n\7\3\b\3\b\3\b\3\b\7\bu\n\b\f\b\16\bx\13\b\3\b\5")
+        buf.write("\b{\n\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("\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\6\t\u0090\n\t\r\t\16\t")
         buf.write("\u0091\3\t\3\t\3\t\3\t\3\t\3\t\7\t\u009a\n\t\f\t\16\t")
         buf.write("\u009d\13\t\5\t\u009f\n\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t")
-        buf.write("\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\6\t\u00b0\n\t\r\t\16")
-        buf.write("\t\u00b1\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("\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\5\t\u00c7\n\t\3\t\3\t\3")
+        buf.write("\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\5\t\u00b0\n\t\3\t\3\t")
+        buf.write("\3\t\3\t\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("\t\3\t\3\t\3\t\5\t\u00c5\n\t\3\t\3\t\3\t\3\t\3\t\3\t\3")
         buf.write("\t\3\t\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("\3\t\3\t\3\t\3\t\3\t\3\t\3\t\7\t\u00e0\n\t\f\t\16\t\u00e3")
-        buf.write("\13\t\3\n\3\n\5\n\u00e7\n\n\3\n\3\n\3\n\3\n\3\n\5\n\u00ee")
-        buf.write("\n\n\3\n\3\n\3\13\3\13\3\13\5\13\u00f5\n\13\3\13\3\13")
-        buf.write("\3\13\3\13\3\13\5\13\u00fc\n\13\3\13\3\13\3\13\3\13\3")
-        buf.write("\13\5\13\u0103\n\13\3\13\3\13\6\13\u0107\n\13\r\13\16")
-        buf.write("\13\u0108\5\13\u010b\n\13\3\f\3\f\3\r\3\r\3\r\3\r\3\r")
-        buf.write("\3\r\7\r\u0115\n\r\f\r\16\r\u0118\13\r\3\r\3\r\5\r\u011c")
-        buf.write("\n\r\3\16\3\16\3\16\5\16\u0121\n\16\3\16\3\16\3\16\3\17")
-        buf.write("\3\17\3\20\3\20\3\20\3\20\7\20\u012c\n\20\f\20\16\20\u012f")
-        buf.write("\13\20\3\20\3\20\3\21\3\21\3\21\3\21\5\21\u0137\n\21\5")
-        buf.write("\21\u0139\n\21\3\22\3\22\5\22\u013d\n\22\3\23\3\23\3\23")
-        buf.write("\3\23\7\23\u0143\n\23\f\23\16\23\u0146\13\23\3\23\3\23")
-        buf.write("\3\24\3\24\5\24\u014c\n\24\3\25\3\25\3\25\3\25\7\25\u0152")
-        buf.write("\n\25\f\25\16\25\u0155\13\25\3\25\5\25\u0158\n\25\3\26")
-        buf.write("\3\26\3\26\7\26\u015d\n\26\f\26\16\26\u0160\13\26\5\26")
-        buf.write("\u0162\n\26\3\27\3\27\3\27\5\27\u0167\n\27\3\30\3\30\3")
-        buf.write("\30\7\30\u016c\n\30\f\30\16\30\u016f\13\30\3\31\3\31\3")
-        buf.write("\31\3\31\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32")
-        buf.write("\3\32\3\32\6\32\u0180\n\32\r\32\16\32\u0181\3\32\3\32")
-        buf.write("\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32\3\32")
-        buf.write("\3\32\3\32\5\32\u0193\n\32\3\32\3\32\3\32\3\32\7\32\u0199")
-        buf.write("\n\32\f\32\16\32\u019c\13\32\5\32\u019e\n\32\3\32\3\32")
-        buf.write("\3\32\3\32\5\32\u01a4\n\32\3\33\3\33\3\33\3\33\7\33\u01aa")
-        buf.write("\n\33\f\33\16\33\u01ad\13\33\3\33\3\33\3\34\3\34\3\34")
-        buf.write("\3\34\3\34\3\34\6\34\u01b7\n\34\r\34\16\34\u01b8\3\34")
-        buf.write("\3\34\3\34\5\34\u01be\n\34\3\35\3\35\3\35\3\35\3\35\3")
-        buf.write("\35\3\35\3\35\3\36\3\36\3\36\3\36\3\36\3\36\5\36\u01ce")
-        buf.write("\n\36\3\37\3\37\3\37\3\37\3 \3 \3 \5 \u01d7\n \3!\3!\3")
-        buf.write("!\3!\5!\u01dd\n!\3!\2\3\20\"\2\4\6\b\n\f\16\20\22\24\26")
-        buf.write("\30\32\34\36 \"$&(*,.\60\62\64\668:<>@\2\b\4\2\6\6//\3")
-        buf.write("\2$%\3\2&\'\3\2(+\3\2,-\3\2\32\33\2\u020c\2B\3\2\2\2\4")
-        buf.write("Q\3\2\2\2\6Y\3\2\2\2\b\\\3\2\2\2\n_\3\2\2\2\fj\3\2\2\2")
-        buf.write("\16v\3\2\2\2\20\u00c6\3\2\2\2\22\u00e4\3\2\2\2\24\u010a")
-        buf.write("\3\2\2\2\26\u010c\3\2\2\2\30\u010e\3\2\2\2\32\u011d\3")
-        buf.write("\2\2\2\34\u0125\3\2\2\2\36\u0127\3\2\2\2 \u0138\3\2\2")
-        buf.write("\2\"\u013a\3\2\2\2$\u013e\3\2\2\2&\u014b\3\2\2\2(\u0157")
-        buf.write("\3\2\2\2*\u0161\3\2\2\2,\u0163\3\2\2\2.\u0168\3\2\2\2")
-        buf.write("\60\u0170\3\2\2\2\62\u01a3\3\2\2\2\64\u01a5\3\2\2\2\66")
-        buf.write("\u01bd\3\2\2\28\u01bf\3\2\2\2:\u01cd\3\2\2\2<\u01cf\3")
-        buf.write("\2\2\2>\u01d6\3\2\2\2@\u01dc\3\2\2\2BJ\7\37\2\2CE\5\24")
-        buf.write("\13\2DC\3\2\2\2EH\3\2\2\2FD\3\2\2\2FG\3\2\2\2GK\3\2\2")
-        buf.write("\2HF\3\2\2\2IK\5\20\t\2JF\3\2\2\2JI\3\2\2\2KM\3\2\2\2")
-        buf.write("LN\7\62\2\2ML\3\2\2\2MN\3\2\2\2NO\3\2\2\2OP\7\2\2\3P\3")
-        buf.write("\3\2\2\2QV\7/\2\2RS\7\3\2\2SU\7/\2\2TR\3\2\2\2UX\3\2\2")
-        buf.write("\2VT\3\2\2\2VW\3\2\2\2W\5\3\2\2\2XV\3\2\2\2YZ\7\4\2\2")
-        buf.write("Z[\7/\2\2[\7\3\2\2\2\\]\7\5\2\2]^\t\2\2\2^\t\3\2\2\2_")
-        buf.write("`\7\5\2\2`a\7\61\2\2a\13\3\2\2\2bg\5\20\t\2cd\7\7\2\2")
-        buf.write("df\5\20\t\2ec\3\2\2\2fi\3\2\2\2ge\3\2\2\2gh\3\2\2\2hk")
-        buf.write("\3\2\2\2ig\3\2\2\2jb\3\2\2\2jk\3\2\2\2k\r\3\2\2\2lw\5")
-        buf.write("\f\7\2mn\5\20\t\2no\7\7\2\2oq\3\2\2\2pm\3\2\2\2qt\3\2")
-        buf.write("\2\2rp\3\2\2\2rs\3\2\2\2su\3\2\2\2tr\3\2\2\2uw\5.\30\2")
-        buf.write("vl\3\2\2\2vr\3\2\2\2w\17\3\2\2\2xy\b\t\1\2yz\7\b\2\2z")
-        buf.write("{\5\20\t\2{|\7\t\2\2|\u00c7\3\2\2\2}~\7\n\2\2~\177\5\20")
-        buf.write("\t\2\177\u0080\7\13\2\2\u0080\u00c7\3\2\2\2\u0081\u0082")
-        buf.write("\7\'\2\2\u0082\u00c7\5\20\t\26\u0083\u00c7\5\22\n\2\u0084")
-        buf.write("\u0085\7\b\2\2\u0085\u00c7\7\t\2\2\u0086\u0087\7\b\2\2")
-        buf.write("\u0087\u0088\5\20\t\2\u0088\u0089\7\7\2\2\u0089\u008a")
-        buf.write("\7\t\2\2\u008a\u00c7\3\2\2\2\u008b\u008c\7\b\2\2\u008c")
-        buf.write("\u008f\5\20\t\2\u008d\u008e\7\7\2\2\u008e\u0090\5\20\t")
-        buf.write("\2\u008f\u008d\3\2\2\2\u0090\u0091\3\2\2\2\u0091\u008f")
-        buf.write("\3\2\2\2\u0091\u0092\3\2\2\2\u0092\u0093\3\2\2\2\u0093")
-        buf.write("\u0094\7\t\2\2\u0094\u00c7\3\2\2\2\u0095\u009e\7\f\2\2")
-        buf.write("\u0096\u009b\5\20\t\2\u0097\u0098\7\7\2\2\u0098\u009a")
-        buf.write("\5\20\t\2\u0099\u0097\3\2\2\2\u009a\u009d\3\2\2\2\u009b")
-        buf.write("\u0099\3\2\2\2\u009b\u009c\3\2\2\2\u009c\u009f\3\2\2\2")
-        buf.write("\u009d\u009b\3\2\2\2\u009e\u0096\3\2\2\2\u009e\u009f\3")
-        buf.write("\2\2\2\u009f\u00a0\3\2\2\2\u00a0\u00c7\7\r\2\2\u00a1\u00a2")
-        buf.write("\7\16\2\2\u00a2\u00a3\7\b\2\2\u00a3\u00a4\5\20\t\2\u00a4")
-        buf.write("\u00a5\7\t\2\2\u00a5\u00a6\5<\37\2\u00a6\u00a7\7\17\2")
-        buf.write("\2\u00a7\u00a8\5<\37\2\u00a8\u00c7\3\2\2\2\u00a9\u00aa")
-        buf.write("\5\34\17\2\u00aa\u00ab\7\b\2\2\u00ab\u00ac\5\20\t\2\u00ac")
-        buf.write("\u00ad\7\t\2\2\u00ad\u00af\7\n\2\2\u00ae\u00b0\5\32\16")
-        buf.write("\2\u00af\u00ae\3\2\2\2\u00b0\u00b1\3\2\2\2\u00b1\u00af")
-        buf.write("\3\2\2\2\u00b1\u00b2\3\2\2\2\u00b2\u00b3\3\2\2\2\u00b3")
-        buf.write("\u00b4\7\13\2\2\u00b4\u00c7\3\2\2\2\u00b5\u00b6\7\20\2")
-        buf.write("\2\u00b6\u00b7\5,\27\2\u00b7\u00b8\7\21\2\2\u00b8\u00b9")
-        buf.write("\5\20\t\2\u00b9\u00ba\7\22\2\2\u00ba\u00bb\5\20\t\t\u00bb")
-        buf.write("\u00c7\3\2\2\2\u00bc\u00bd\5\n\6\2\u00bd\u00be\7\21\2")
-        buf.write("\2\u00be\u00bf\5\20\t\2\u00bf\u00c0\7\22\2\2\u00c0\u00c1")
-        buf.write("\5\20\t\7\u00c1\u00c7\3\2\2\2\u00c2\u00c7\5@!\2\u00c3")
-        buf.write("\u00c7\5> \2\u00c4\u00c7\58\35\2\u00c5\u00c7\7#\2\2\u00c6")
-        buf.write("x\3\2\2\2\u00c6}\3\2\2\2\u00c6\u0081\3\2\2\2\u00c6\u0083")
-        buf.write("\3\2\2\2\u00c6\u0084\3\2\2\2\u00c6\u0086\3\2\2\2\u00c6")
-        buf.write("\u008b\3\2\2\2\u00c6\u0095\3\2\2\2\u00c6\u00a1\3\2\2\2")
-        buf.write("\u00c6\u00a9\3\2\2\2\u00c6\u00b5\3\2\2\2\u00c6\u00bc\3")
-        buf.write("\2\2\2\u00c6\u00c2\3\2\2\2\u00c6\u00c3\3\2\2\2\u00c6\u00c4")
-        buf.write("\3\2\2\2\u00c6\u00c5\3\2\2\2\u00c7\u00e1\3\2\2\2\u00c8")
-        buf.write("\u00c9\f\25\2\2\u00c9\u00ca\t\3\2\2\u00ca\u00e0\5\20\t")
-        buf.write("\26\u00cb\u00cc\f\24\2\2\u00cc\u00cd\t\4\2\2\u00cd\u00e0")
-        buf.write("\5\20\t\25\u00ce\u00cf\f\23\2\2\u00cf\u00d0\t\5\2\2\u00d0")
-        buf.write("\u00e0\5\20\t\24\u00d1\u00d2\f\22\2\2\u00d2\u00d3\t\6")
-        buf.write("\2\2\u00d3\u00e0\5\20\t\23\u00d4\u00d5\f\b\2\2\u00d5\u00d6")
-        buf.write("\7\23\2\2\u00d6\u00e0\5\20\t\t\u00d7\u00d8\f\27\2\2\u00d8")
-        buf.write("\u00d9\7\b\2\2\u00d9\u00da\5\16\b\2\u00da\u00db\7\t\2")
-        buf.write("\2\u00db\u00e0\3\2\2\2\u00dc\u00dd\f\n\2\2\u00dd\u00de")
-        buf.write("\7\3\2\2\u00de\u00e0\7\61\2\2\u00df\u00c8\3\2\2\2\u00df")
-        buf.write("\u00cb\3\2\2\2\u00df\u00ce\3\2\2\2\u00df\u00d1\3\2\2\2")
-        buf.write("\u00df\u00d4\3\2\2\2\u00df\u00d7\3\2\2\2\u00df\u00dc\3")
-        buf.write("\2\2\2\u00e0\u00e3\3\2\2\2\u00e1\u00df\3\2\2\2\u00e1\u00e2")
-        buf.write("\3\2\2\2\u00e2\21\3\2\2\2\u00e3\u00e1\3\2\2\2\u00e4\u00e6")
-        buf.write("\7\24\2\2\u00e5\u00e7\5\64\33\2\u00e6\u00e5\3\2\2\2\u00e6")
-        buf.write("\u00e7\3\2\2\2\u00e7\u00e8\3\2\2\2\u00e8\u00e9\7\b\2\2")
-        buf.write("\u00e9\u00ea\5(\25\2\u00ea\u00ed\7\t\2\2\u00eb\u00ec\7")
-        buf.write("\25\2\2\u00ec\u00ee\5\62\32\2\u00ed\u00eb\3\2\2\2\u00ed")
-        buf.write("\u00ee\3\2\2\2\u00ee\u00ef\3\2\2\2\u00ef\u00f0\5<\37\2")
-        buf.write("\u00f0\23\3\2\2\2\u00f1\u00f2\7\26\2\2\u00f2\u00f4\5\6")
-        buf.write("\4\2\u00f3\u00f5\5\64\33\2\u00f4\u00f3\3\2\2\2\u00f4\u00f5")
-        buf.write("\3\2\2\2\u00f5\u00f6\3\2\2\2\u00f6\u00f7\7\b\2\2\u00f7")
-        buf.write("\u00f8\5(\25\2\u00f8\u00fb\7\t\2\2\u00f9\u00fa\7\25\2")
-        buf.write("\2\u00fa\u00fc\5\62\32\2\u00fb\u00f9\3\2\2\2\u00fb\u00fc")
-        buf.write("\3\2\2\2\u00fc\u00fd\3\2\2\2\u00fd\u00fe\5<\37\2\u00fe")
-        buf.write("\u010b\3\2\2\2\u00ff\u0100\7\27\2\2\u0100\u0102\5\4\3")
-        buf.write("\2\u0101\u0103\5\64\33\2\u0102\u0101\3\2\2\2\u0102\u0103")
-        buf.write("\3\2\2\2\u0103\u0104\3\2\2\2\u0104\u0106\7\21\2\2\u0105")
-        buf.write("\u0107\5\30\r\2\u0106\u0105\3\2\2\2\u0107\u0108\3\2\2")
-        buf.write("\2\u0108\u0106\3\2\2\2\u0108\u0109\3\2\2\2\u0109\u010b")
-        buf.write("\3\2\2\2\u010a\u00f1\3\2\2\2\u010a\u00ff\3\2\2\2\u010b")
-        buf.write("\25\3\2\2\2\u010c\u010d\7/\2\2\u010d\27\3\2\2\2\u010e")
-        buf.write("\u010f\7\30\2\2\u010f\u011b\5\26\f\2\u0110\u0111\7\b\2")
-        buf.write("\2\u0111\u0116\5\62\32\2\u0112\u0113\7\7\2\2\u0113\u0115")
-        buf.write("\5\62\32\2\u0114\u0112\3\2\2\2\u0115\u0118\3\2\2\2\u0116")
-        buf.write("\u0114\3\2\2\2\u0116\u0117\3\2\2\2\u0117\u0119\3\2\2\2")
-        buf.write("\u0118\u0116\3\2\2\2\u0119\u011a\7\t\2\2\u011a\u011c\3")
-        buf.write("\2\2\2\u011b\u0110\3\2\2\2\u011b\u011c\3\2\2\2\u011c\31")
-        buf.write("\3\2\2\2\u011d\u011e\7\30\2\2\u011e\u0120\5\26\f\2\u011f")
-        buf.write("\u0121\5\36\20\2\u0120\u011f\3\2\2\2\u0120\u0121\3\2\2")
-        buf.write("\2\u0121\u0122\3\2\2\2\u0122\u0123\7\31\2\2\u0123\u0124")
-        buf.write("\5\20\t\2\u0124\33\3\2\2\2\u0125\u0126\t\7\2\2\u0126\35")
-        buf.write("\3\2\2\2\u0127\u0128\7\b\2\2\u0128\u012d\5 \21\2\u0129")
-        buf.write("\u012a\7\7\2\2\u012a\u012c\5 \21\2\u012b\u0129\3\2\2\2")
-        buf.write("\u012c\u012f\3\2\2\2\u012d\u012b\3\2\2\2\u012d\u012e\3")
-        buf.write("\2\2\2\u012e\u0130\3\2\2\2\u012f\u012d\3\2\2\2\u0130\u0131")
-        buf.write("\7\t\2\2\u0131\37\3\2\2\2\u0132\u0139\7\6\2\2\u0133\u0136")
-        buf.write("\5\b\5\2\u0134\u0135\7\34\2\2\u0135\u0137\5\62\32\2\u0136")
-        buf.write("\u0134\3\2\2\2\u0136\u0137\3\2\2\2\u0137\u0139\3\2\2\2")
-        buf.write("\u0138\u0132\3\2\2\2\u0138\u0133\3\2\2\2\u0139!\3\2\2")
-        buf.write("\2\u013a\u013c\5\26\f\2\u013b\u013d\5$\23\2\u013c\u013b")
-        buf.write("\3\2\2\2\u013c\u013d\3\2\2\2\u013d#\3\2\2\2\u013e\u013f")
-        buf.write("\7\b\2\2\u013f\u0144\5&\24\2\u0140\u0141\7\7\2\2\u0141")
-        buf.write("\u0143\5&\24\2\u0142\u0140\3\2\2\2\u0143\u0146\3\2\2\2")
-        buf.write("\u0144\u0142\3\2\2\2\u0144\u0145\3\2\2\2\u0145\u0147\3")
-        buf.write("\2\2\2\u0146\u0144\3\2\2\2\u0147\u0148\7\t\2\2\u0148%")
-        buf.write("\3\2\2\2\u0149\u014c\5\b\5\2\u014a\u014c\5\26\f\2\u014b")
-        buf.write("\u0149\3\2\2\2\u014b\u014a\3\2\2\2\u014c\'\3\2\2\2\u014d")
-        buf.write("\u0158\5*\26\2\u014e\u014f\5,\27\2\u014f\u0150\7\7\2\2")
-        buf.write("\u0150\u0152\3\2\2\2\u0151\u014e\3\2\2\2\u0152\u0155\3")
-        buf.write("\2\2\2\u0153\u0151\3\2\2\2\u0153\u0154\3\2\2\2\u0154\u0156")
-        buf.write("\3\2\2\2\u0155\u0153\3\2\2\2\u0156\u0158\5.\30\2\u0157")
-        buf.write("\u014d\3\2\2\2\u0157\u0153\3\2\2\2\u0158)\3\2\2\2\u0159")
-        buf.write("\u015e\5,\27\2\u015a\u015b\7\7\2\2\u015b\u015d\5,\27\2")
-        buf.write("\u015c\u015a\3\2\2\2\u015d\u0160\3\2\2\2\u015e\u015c\3")
-        buf.write("\2\2\2\u015e\u015f\3\2\2\2\u015f\u0162\3\2\2\2\u0160\u015e")
-        buf.write("\3\2\2\2\u0161\u0159\3\2\2\2\u0161\u0162\3\2\2\2\u0162")
-        buf.write("+\3\2\2\2\u0163\u0166\5\b\5\2\u0164\u0165\7\34\2\2\u0165")
-        buf.write("\u0167\5\62\32\2\u0166\u0164\3\2\2\2\u0166\u0167\3\2\2")
-        buf.write("\2\u0167-\3\2\2\2\u0168\u016d\5\60\31\2\u0169\u016a\7")
-        buf.write("\7\2\2\u016a\u016c\5\60\31\2\u016b\u0169\3\2\2\2\u016c")
-        buf.write("\u016f\3\2\2\2\u016d\u016b\3\2\2\2\u016d\u016e\3\2\2\2")
-        buf.write("\u016e/\3\2\2\2\u016f\u016d\3\2\2\2\u0170\u0171\7/\2\2")
-        buf.write("\u0171\u0172\7\21\2\2\u0172\u0173\5\20\t\2\u0173\61\3")
-        buf.write("\2\2\2\u0174\u0175\7\b\2\2\u0175\u01a4\7\t\2\2\u0176\u0177")
-        buf.write("\7\b\2\2\u0177\u0178\5\62\32\2\u0178\u0179\7\7\2\2\u0179")
-        buf.write("\u017a\7\t\2\2\u017a\u01a4\3\2\2\2\u017b\u017c\7\b\2\2")
-        buf.write("\u017c\u017f\5\62\32\2\u017d\u017e\7\7\2\2\u017e\u0180")
-        buf.write("\5\62\32\2\u017f\u017d\3\2\2\2\u0180\u0181\3\2\2\2\u0181")
-        buf.write("\u017f\3\2\2\2\u0181\u0182\3\2\2\2\u0182\u0183\3\2\2\2")
-        buf.write("\u0183\u0184\7\t\2\2\u0184\u01a4\3\2\2\2\u0185\u0186\5")
-        buf.write("\4\3\2\u0186\u0187\5\64\33\2\u0187\u01a4\3\2\2\2\u0188")
-        buf.write("\u01a4\5\4\3\2\u0189\u018a\7\35\2\2\u018a\u018b\7\f\2")
-        buf.write("\2\u018b\u018c\5\66\34\2\u018c\u018d\7\7\2\2\u018d\u018e")
-        buf.write("\5\62\32\2\u018e\u018f\7\r\2\2\u018f\u01a4\3\2\2\2\u0190")
-        buf.write("\u0192\7\24\2\2\u0191\u0193\5\64\33\2\u0192\u0191\3\2")
-        buf.write("\2\2\u0192\u0193\3\2\2\2\u0193\u0194\3\2\2\2\u0194\u019d")
-        buf.write("\7\b\2\2\u0195\u019a\5\62\32\2\u0196\u0197\7\7\2\2\u0197")
-        buf.write("\u0199\5\62\32\2\u0198\u0196\3\2\2\2\u0199\u019c\3\2\2")
-        buf.write("\2\u019a\u0198\3\2\2\2\u019a\u019b\3\2\2\2\u019b\u019e")
-        buf.write("\3\2\2\2\u019c\u019a\3\2\2\2\u019d\u0195\3\2\2\2\u019d")
-        buf.write("\u019e\3\2\2\2\u019e\u019f\3\2\2\2\u019f\u01a0\7\t\2\2")
-        buf.write("\u01a0\u01a1\7\25\2\2\u01a1\u01a4\5\62\32\2\u01a2\u01a4")
-        buf.write("\7\6\2\2\u01a3\u0174\3\2\2\2\u01a3\u0176\3\2\2\2\u01a3")
-        buf.write("\u017b\3\2\2\2\u01a3\u0185\3\2\2\2\u01a3\u0188\3\2\2\2")
-        buf.write("\u01a3\u0189\3\2\2\2\u01a3\u0190\3\2\2\2\u01a3\u01a2\3")
-        buf.write("\2\2\2\u01a4\63\3\2\2\2\u01a5\u01a6\7\f\2\2\u01a6\u01ab")
-        buf.write("\5\4\3\2\u01a7\u01a8\7\7\2\2\u01a8\u01aa\5\4\3\2\u01a9")
-        buf.write("\u01a7\3\2\2\2\u01aa\u01ad\3\2\2\2\u01ab\u01a9\3\2\2\2")
-        buf.write("\u01ab\u01ac\3\2\2\2\u01ac\u01ae\3\2\2\2\u01ad\u01ab\3")
-        buf.write("\2\2\2\u01ae\u01af\7\r\2\2\u01af\65\3\2\2\2\u01b0\u01b1")
-        buf.write("\7\b\2\2\u01b1\u01be\7\t\2\2\u01b2\u01b3\7\b\2\2\u01b3")
-        buf.write("\u01b6\5:\36\2\u01b4\u01b5\7\7\2\2\u01b5\u01b7\5:\36\2")
-        buf.write("\u01b6\u01b4\3\2\2\2\u01b7\u01b8\3\2\2\2\u01b8\u01b6\3")
-        buf.write("\2\2\2\u01b8\u01b9\3\2\2\2\u01b9\u01ba\3\2\2\2\u01ba\u01bb")
-        buf.write("\7\t\2\2\u01bb\u01be\3\2\2\2\u01bc\u01be\5:\36\2\u01bd")
-        buf.write("\u01b0\3\2\2\2\u01bd\u01b2\3\2\2\2\u01bd\u01bc\3\2\2\2")
-        buf.write("\u01be\67\3\2\2\2\u01bf\u01c0\7\36\2\2\u01c0\u01c1\7\f")
-        buf.write("\2\2\u01c1\u01c2\7/\2\2\u01c2\u01c3\7\r\2\2\u01c3\u01c4")
-        buf.write("\7\f\2\2\u01c4\u01c5\7\61\2\2\u01c5\u01c6\7\r\2\2\u01c6")
-        buf.write("9\3\2\2\2\u01c7\u01ce\58\35\2\u01c8\u01c9\7\b\2\2\u01c9")
-        buf.write("\u01ca\5:\36\2\u01ca\u01cb\7\t\2\2\u01cb\u01ce\3\2\2\2")
-        buf.write("\u01cc\u01ce\7\61\2\2\u01cd\u01c7\3\2\2\2\u01cd\u01c8")
-        buf.write("\3\2\2\2\u01cd\u01cc\3\2\2\2\u01ce;\3\2\2\2\u01cf\u01d0")
-        buf.write("\7\n\2\2\u01d0\u01d1\5\20\t\2\u01d1\u01d2\7\13\2\2\u01d2")
-        buf.write("=\3\2\2\2\u01d3\u01d7\7\60\2\2\u01d4\u01d7\7\61\2\2\u01d5")
-        buf.write("\u01d7\7.\2\2\u01d6\u01d3\3\2\2\2\u01d6\u01d4\3\2\2\2")
-        buf.write("\u01d6\u01d5\3\2\2\2\u01d7?\3\2\2\2\u01d8\u01dd\5\4\3")
-        buf.write("\2\u01d9\u01dd\5\6\4\2\u01da\u01dd\5\b\5\2\u01db\u01dd")
-        buf.write("\5\n\6\2\u01dc\u01d8\3\2\2\2\u01dc\u01d9\3\2\2\2\u01dc")
-        buf.write("\u01da\3\2\2\2\u01dc\u01db\3\2\2\2\u01ddA\3\2\2\2\62F")
-        buf.write("JMVgjrv\u0091\u009b\u009e\u00b1\u00c6\u00df\u00e1\u00e6")
-        buf.write("\u00ed\u00f4\u00fb\u0102\u0108\u010a\u0116\u011b\u0120")
-        buf.write("\u012d\u0136\u0138\u013c\u0144\u014b\u0153\u0157\u015e")
-        buf.write("\u0161\u0166\u016d\u0181\u0192\u019a\u019d\u01a3\u01ab")
-        buf.write("\u01b8\u01bd\u01cd\u01d6\u01dc")
+        buf.write("\3\t\3\t\3\t\7\t\u00de\n\t\f\t\16\t\u00e1\13\t\3\n\3\n")
+        buf.write("\5\n\u00e5\n\n\3\n\3\n\3\n\3\n\3\n\5\n\u00ec\n\n\3\n\3")
+        buf.write("\n\3\13\3\13\3\13\5\13\u00f3\n\13\3\13\3\13\3\13\3\13")
+        buf.write("\3\13\5\13\u00fa\n\13\3\13\3\13\3\13\3\13\3\13\5\13\u0101")
+        buf.write("\n\13\3\13\3\13\5\13\u0105\n\13\3\13\3\13\5\13\u0109\n")
+        buf.write("\13\3\f\3\f\3\r\3\r\3\r\7\r\u0110\n\r\f\r\16\r\u0113\13")
+        buf.write("\r\3\r\5\r\u0116\n\r\3\16\3\16\3\16\3\16\3\16\7\16\u011d")
+        buf.write("\n\16\f\16\16\16\u0120\13\16\3\16\3\16\5\16\u0124\n\16")
+        buf.write("\3\17\3\17\3\17\7\17\u0129\n\17\f\17\16\17\u012c\13\17")
+        buf.write("\3\17\5\17\u012f\n\17\3\20\3\20\5\20\u0133\n\20\3\20\3")
+        buf.write("\20\3\20\3\20\3\20\3\20\5\20\u013b\n\20\3\21\3\21\3\22")
+        buf.write("\3\22\3\22\3\22\7\22\u0143\n\22\f\22\16\22\u0146\13\22")
+        buf.write("\3\22\3\22\3\23\3\23\3\23\3\23\5\23\u014e\n\23\5\23\u0150")
+        buf.write("\n\23\3\24\3\24\5\24\u0154\n\24\3\25\3\25\3\25\3\25\7")
+        buf.write("\25\u015a\n\25\f\25\16\25\u015d\13\25\3\25\3\25\3\26\3")
+        buf.write("\26\5\26\u0163\n\26\3\27\3\27\3\27\3\27\7\27\u0169\n\27")
+        buf.write("\f\27\16\27\u016c\13\27\3\27\5\27\u016f\n\27\3\30\3\30")
+        buf.write("\3\30\7\30\u0174\n\30\f\30\16\30\u0177\13\30\5\30\u0179")
+        buf.write("\n\30\3\31\3\31\3\31\5\31\u017e\n\31\3\32\3\32\3\32\7")
+        buf.write("\32\u0183\n\32\f\32\16\32\u0186\13\32\3\33\3\33\3\33\3")
+        buf.write("\33\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34")
+        buf.write("\3\34\6\34\u0197\n\34\r\34\16\34\u0198\3\34\3\34\3\34")
+        buf.write("\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34")
+        buf.write("\3\34\5\34\u01aa\n\34\3\34\3\34\3\34\3\34\7\34\u01b0\n")
+        buf.write("\34\f\34\16\34\u01b3\13\34\5\34\u01b5\n\34\3\34\3\34\3")
+        buf.write("\34\3\34\5\34\u01bb\n\34\3\35\3\35\3\35\3\35\7\35\u01c1")
+        buf.write("\n\35\f\35\16\35\u01c4\13\35\3\35\3\35\3\36\3\36\3\36")
+        buf.write("\3\36\3\36\3\36\6\36\u01ce\n\36\r\36\16\36\u01cf\3\36")
+        buf.write("\3\36\3\36\5\36\u01d5\n\36\3\37\3\37\3\37\3\37\3\37\3")
+        buf.write("\37\3\37\3\37\3 \3 \3 \3 \3 \3 \5 \u01e5\n \3!\3!\3!\3")
+        buf.write("!\3\"\3\"\3\"\5\"\u01ee\n\"\3#\3#\3#\3#\5#\u01f4\n#\3")
+        buf.write("#\2\3\20$\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&")
+        buf.write("(*,.\60\62\64\668:<>@BD\2\b\4\2\6\6..\3\2#$\3\2%&\3\2")
+        buf.write("\'*\3\2+,\3\2\31\32\2\u0225\2F\3\2\2\2\4U\3\2\2\2\6]\3")
+        buf.write("\2\2\2\b`\3\2\2\2\nc\3\2\2\2\fn\3\2\2\2\16z\3\2\2\2\20")
+        buf.write("\u00c4\3\2\2\2\22\u00e2\3\2\2\2\24\u0108\3\2\2\2\26\u010a")
+        buf.write("\3\2\2\2\30\u010c\3\2\2\2\32\u0117\3\2\2\2\34\u0125\3")
+        buf.write("\2\2\2\36\u0130\3\2\2\2 \u013c\3\2\2\2\"\u013e\3\2\2\2")
+        buf.write("$\u014f\3\2\2\2&\u0151\3\2\2\2(\u0155\3\2\2\2*\u0162\3")
+        buf.write("\2\2\2,\u016e\3\2\2\2.\u0178\3\2\2\2\60\u017a\3\2\2\2")
+        buf.write("\62\u017f\3\2\2\2\64\u0187\3\2\2\2\66\u01ba\3\2\2\28\u01bc")
+        buf.write("\3\2\2\2:\u01d4\3\2\2\2<\u01d6\3\2\2\2>\u01e4\3\2\2\2")
+        buf.write("@\u01e6\3\2\2\2B\u01ed\3\2\2\2D\u01f3\3\2\2\2FN\7\36\2")
+        buf.write("\2GI\5\24\13\2HG\3\2\2\2IL\3\2\2\2JH\3\2\2\2JK\3\2\2\2")
+        buf.write("KO\3\2\2\2LJ\3\2\2\2MO\5\20\t\2NJ\3\2\2\2NM\3\2\2\2OQ")
+        buf.write("\3\2\2\2PR\7\61\2\2QP\3\2\2\2QR\3\2\2\2RS\3\2\2\2ST\7")
+        buf.write("\2\2\3T\3\3\2\2\2UZ\7.\2\2VW\7\3\2\2WY\7.\2\2XV\3\2\2")
+        buf.write("\2Y\\\3\2\2\2ZX\3\2\2\2Z[\3\2\2\2[\5\3\2\2\2\\Z\3\2\2")
+        buf.write("\2]^\7\4\2\2^_\7.\2\2_\7\3\2\2\2`a\7\5\2\2ab\t\2\2\2b")
+        buf.write("\t\3\2\2\2cd\7\5\2\2de\7\60\2\2e\13\3\2\2\2fk\5\20\t\2")
+        buf.write("gh\7\7\2\2hj\5\20\t\2ig\3\2\2\2jm\3\2\2\2ki\3\2\2\2kl")
+        buf.write("\3\2\2\2lo\3\2\2\2mk\3\2\2\2nf\3\2\2\2no\3\2\2\2o\r\3")
+        buf.write("\2\2\2p{\5\f\7\2qr\5\20\t\2rs\7\7\2\2su\3\2\2\2tq\3\2")
+        buf.write("\2\2ux\3\2\2\2vt\3\2\2\2vw\3\2\2\2wy\3\2\2\2xv\3\2\2\2")
+        buf.write("y{\5\62\32\2zp\3\2\2\2zv\3\2\2\2{\17\3\2\2\2|}\b\t\1\2")
+        buf.write("}~\7\b\2\2~\177\5\20\t\2\177\u0080\7\t\2\2\u0080\u00c5")
+        buf.write("\3\2\2\2\u0081\u0082\7&\2\2\u0082\u00c5\5\20\t\26\u0083")
+        buf.write("\u00c5\5\22\n\2\u0084\u0085\7\b\2\2\u0085\u00c5\7\t\2")
+        buf.write("\2\u0086\u0087\7\b\2\2\u0087\u0088\5\20\t\2\u0088\u0089")
+        buf.write("\7\7\2\2\u0089\u008a\7\t\2\2\u008a\u00c5\3\2\2\2\u008b")
+        buf.write("\u008c\7\b\2\2\u008c\u008f\5\20\t\2\u008d\u008e\7\7\2")
+        buf.write("\2\u008e\u0090\5\20\t\2\u008f\u008d\3\2\2\2\u0090\u0091")
+        buf.write("\3\2\2\2\u0091\u008f\3\2\2\2\u0091\u0092\3\2\2\2\u0092")
+        buf.write("\u0093\3\2\2\2\u0093\u0094\7\t\2\2\u0094\u00c5\3\2\2\2")
+        buf.write("\u0095\u009e\7\n\2\2\u0096\u009b\5\20\t\2\u0097\u0098")
+        buf.write("\7\7\2\2\u0098\u009a\5\20\t\2\u0099\u0097\3\2\2\2\u009a")
+        buf.write("\u009d\3\2\2\2\u009b\u0099\3\2\2\2\u009b\u009c\3\2\2\2")
+        buf.write("\u009c\u009f\3\2\2\2\u009d\u009b\3\2\2\2\u009e\u0096\3")
+        buf.write("\2\2\2\u009e\u009f\3\2\2\2\u009f\u00a0\3\2\2\2\u00a0\u00c5")
+        buf.write("\7\13\2\2\u00a1\u00a2\7\f\2\2\u00a2\u00a3\7\b\2\2\u00a3")
+        buf.write("\u00a4\5\20\t\2\u00a4\u00a5\7\t\2\2\u00a5\u00a6\5@!\2")
+        buf.write("\u00a6\u00a7\7\r\2\2\u00a7\u00a8\5@!\2\u00a8\u00c5\3\2")
+        buf.write("\2\2\u00a9\u00aa\5 \21\2\u00aa\u00ab\7\b\2\2\u00ab\u00ac")
+        buf.write("\5\20\t\2\u00ac\u00ad\7\t\2\2\u00ad\u00af\7\16\2\2\u00ae")
+        buf.write("\u00b0\5\34\17\2\u00af\u00ae\3\2\2\2\u00af\u00b0\3\2\2")
+        buf.write("\2\u00b0\u00b1\3\2\2\2\u00b1\u00b2\7\17\2\2\u00b2\u00c5")
+        buf.write("\3\2\2\2\u00b3\u00b4\7\20\2\2\u00b4\u00b5\5\60\31\2\u00b5")
+        buf.write("\u00b6\7\21\2\2\u00b6\u00b7\5\20\t\2\u00b7\u00b8\7\22")
+        buf.write("\2\2\u00b8\u00b9\5\20\t\t\u00b9\u00c5\3\2\2\2\u00ba\u00bb")
+        buf.write("\5\n\6\2\u00bb\u00bc\7\21\2\2\u00bc\u00bd\5\20\t\2\u00bd")
+        buf.write("\u00be\7\22\2\2\u00be\u00bf\5\20\t\7\u00bf\u00c5\3\2\2")
+        buf.write("\2\u00c0\u00c5\5D#\2\u00c1\u00c5\5B\"\2\u00c2\u00c5\5")
+        buf.write("<\37\2\u00c3\u00c5\7\"\2\2\u00c4|\3\2\2\2\u00c4\u0081")
+        buf.write("\3\2\2\2\u00c4\u0083\3\2\2\2\u00c4\u0084\3\2\2\2\u00c4")
+        buf.write("\u0086\3\2\2\2\u00c4\u008b\3\2\2\2\u00c4\u0095\3\2\2\2")
+        buf.write("\u00c4\u00a1\3\2\2\2\u00c4\u00a9\3\2\2\2\u00c4\u00b3\3")
+        buf.write("\2\2\2\u00c4\u00ba\3\2\2\2\u00c4\u00c0\3\2\2\2\u00c4\u00c1")
+        buf.write("\3\2\2\2\u00c4\u00c2\3\2\2\2\u00c4\u00c3\3\2\2\2\u00c5")
+        buf.write("\u00df\3\2\2\2\u00c6\u00c7\f\25\2\2\u00c7\u00c8\t\3\2")
+        buf.write("\2\u00c8\u00de\5\20\t\26\u00c9\u00ca\f\24\2\2\u00ca\u00cb")
+        buf.write("\t\4\2\2\u00cb\u00de\5\20\t\25\u00cc\u00cd\f\23\2\2\u00cd")
+        buf.write("\u00ce\t\5\2\2\u00ce\u00de\5\20\t\24\u00cf\u00d0\f\22")
+        buf.write("\2\2\u00d0\u00d1\t\6\2\2\u00d1\u00de\5\20\t\23\u00d2\u00d3")
+        buf.write("\f\b\2\2\u00d3\u00d4\7\23\2\2\u00d4\u00de\5\20\t\t\u00d5")
+        buf.write("\u00d6\f\27\2\2\u00d6\u00d7\7\b\2\2\u00d7\u00d8\5\16\b")
+        buf.write("\2\u00d8\u00d9\7\t\2\2\u00d9\u00de\3\2\2\2\u00da\u00db")
+        buf.write("\f\n\2\2\u00db\u00dc\7\3\2\2\u00dc\u00de\7\60\2\2\u00dd")
+        buf.write("\u00c6\3\2\2\2\u00dd\u00c9\3\2\2\2\u00dd\u00cc\3\2\2\2")
+        buf.write("\u00dd\u00cf\3\2\2\2\u00dd\u00d2\3\2\2\2\u00dd\u00d5\3")
+        buf.write("\2\2\2\u00dd\u00da\3\2\2\2\u00de\u00e1\3\2\2\2\u00df\u00dd")
+        buf.write("\3\2\2\2\u00df\u00e0\3\2\2\2\u00e0\21\3\2\2\2\u00e1\u00df")
+        buf.write("\3\2\2\2\u00e2\u00e4\7\24\2\2\u00e3\u00e5\58\35\2\u00e4")
+        buf.write("\u00e3\3\2\2\2\u00e4\u00e5\3\2\2\2\u00e5\u00e6\3\2\2\2")
+        buf.write("\u00e6\u00e7\7\b\2\2\u00e7\u00e8\5,\27\2\u00e8\u00eb\7")
+        buf.write("\t\2\2\u00e9\u00ea\7\25\2\2\u00ea\u00ec\5\66\34\2\u00eb")
+        buf.write("\u00e9\3\2\2\2\u00eb\u00ec\3\2\2\2\u00ec\u00ed\3\2\2\2")
+        buf.write("\u00ed\u00ee\5@!\2\u00ee\23\3\2\2\2\u00ef\u00f0\7\26\2")
+        buf.write("\2\u00f0\u00f2\5\6\4\2\u00f1\u00f3\58\35\2\u00f2\u00f1")
+        buf.write("\3\2\2\2\u00f2\u00f3\3\2\2\2\u00f3\u00f4\3\2\2\2\u00f4")
+        buf.write("\u00f5\7\b\2\2\u00f5\u00f6\5,\27\2\u00f6\u00f9\7\t\2\2")
+        buf.write("\u00f7\u00f8\7\25\2\2\u00f8\u00fa\5\66\34\2\u00f9\u00f7")
+        buf.write("\3\2\2\2\u00f9\u00fa\3\2\2\2\u00fa\u00fb\3\2\2\2\u00fb")
+        buf.write("\u00fc\5@!\2\u00fc\u0109\3\2\2\2\u00fd\u00fe\7\27\2\2")
+        buf.write("\u00fe\u0100\5\4\3\2\u00ff\u0101\58\35\2\u0100\u00ff\3")
+        buf.write("\2\2\2\u0100\u0101\3\2\2\2\u0101\u0102\3\2\2\2\u0102\u0104")
+        buf.write("\7\16\2\2\u0103\u0105\5\30\r\2\u0104\u0103\3\2\2\2\u0104")
+        buf.write("\u0105\3\2\2\2\u0105\u0106\3\2\2\2\u0106\u0107\7\17\2")
+        buf.write("\2\u0107\u0109\3\2\2\2\u0108\u00ef\3\2\2\2\u0108\u00fd")
+        buf.write("\3\2\2\2\u0109\25\3\2\2\2\u010a\u010b\7.\2\2\u010b\27")
+        buf.write("\3\2\2\2\u010c\u0111\5\32\16\2\u010d\u010e\7\7\2\2\u010e")
+        buf.write("\u0110\5\32\16\2\u010f\u010d\3\2\2\2\u0110\u0113\3\2\2")
+        buf.write("\2\u0111\u010f\3\2\2\2\u0111\u0112\3\2\2\2\u0112\u0115")
+        buf.write("\3\2\2\2\u0113\u0111\3\2\2\2\u0114\u0116\7\7\2\2\u0115")
+        buf.write("\u0114\3\2\2\2\u0115\u0116\3\2\2\2\u0116\31\3\2\2\2\u0117")
+        buf.write("\u0123\5\26\f\2\u0118\u0119\7\b\2\2\u0119\u011e\5\66\34")
+        buf.write("\2\u011a\u011b\7\7\2\2\u011b\u011d\5\66\34\2\u011c\u011a")
+        buf.write("\3\2\2\2\u011d\u0120\3\2\2\2\u011e\u011c\3\2\2\2\u011e")
+        buf.write("\u011f\3\2\2\2\u011f\u0121\3\2\2\2\u0120\u011e\3\2\2\2")
+        buf.write("\u0121\u0122\7\t\2\2\u0122\u0124\3\2\2\2\u0123\u0118\3")
+        buf.write("\2\2\2\u0123\u0124\3\2\2\2\u0124\33\3\2\2\2\u0125\u012a")
+        buf.write("\5\36\20\2\u0126\u0127\7\7\2\2\u0127\u0129\5\36\20\2\u0128")
+        buf.write("\u0126\3\2\2\2\u0129\u012c\3\2\2\2\u012a\u0128\3\2\2\2")
+        buf.write("\u012a\u012b\3\2\2\2\u012b\u012e\3\2\2\2\u012c\u012a\3")
+        buf.write("\2\2\2\u012d\u012f\7\7\2\2\u012e\u012d\3\2\2\2\u012e\u012f")
+        buf.write("\3\2\2\2\u012f\35\3\2\2\2\u0130\u0132\5\26\f\2\u0131\u0133")
+        buf.write("\5\"\22\2\u0132\u0131\3\2\2\2\u0132\u0133\3\2\2\2\u0133")
+        buf.write("\u0134\3\2\2\2\u0134\u013a\7\30\2\2\u0135\u0136\7\16\2")
+        buf.write("\2\u0136\u0137\5\20\t\2\u0137\u0138\7\17\2\2\u0138\u013b")
+        buf.write("\3\2\2\2\u0139\u013b\5\20\t\2\u013a\u0135\3\2\2\2\u013a")
+        buf.write("\u0139\3\2\2\2\u013b\37\3\2\2\2\u013c\u013d\t\7\2\2\u013d")
+        buf.write("!\3\2\2\2\u013e\u013f\7\b\2\2\u013f\u0144\5$\23\2\u0140")
+        buf.write("\u0141\7\7\2\2\u0141\u0143\5$\23\2\u0142\u0140\3\2\2\2")
+        buf.write("\u0143\u0146\3\2\2\2\u0144\u0142\3\2\2\2\u0144\u0145\3")
+        buf.write("\2\2\2\u0145\u0147\3\2\2\2\u0146\u0144\3\2\2\2\u0147\u0148")
+        buf.write("\7\t\2\2\u0148#\3\2\2\2\u0149\u0150\7\6\2\2\u014a\u014d")
+        buf.write("\5\b\5\2\u014b\u014c\7\33\2\2\u014c\u014e\5\66\34\2\u014d")
+        buf.write("\u014b\3\2\2\2\u014d\u014e\3\2\2\2\u014e\u0150\3\2\2\2")
+        buf.write("\u014f\u0149\3\2\2\2\u014f\u014a\3\2\2\2\u0150%\3\2\2")
+        buf.write("\2\u0151\u0153\5\26\f\2\u0152\u0154\5(\25\2\u0153\u0152")
+        buf.write("\3\2\2\2\u0153\u0154\3\2\2\2\u0154\'\3\2\2\2\u0155\u0156")
+        buf.write("\7\b\2\2\u0156\u015b\5*\26\2\u0157\u0158\7\7\2\2\u0158")
+        buf.write("\u015a\5*\26\2\u0159\u0157\3\2\2\2\u015a\u015d\3\2\2\2")
+        buf.write("\u015b\u0159\3\2\2\2\u015b\u015c\3\2\2\2\u015c\u015e\3")
+        buf.write("\2\2\2\u015d\u015b\3\2\2\2\u015e\u015f\7\t\2\2\u015f)")
+        buf.write("\3\2\2\2\u0160\u0163\5\b\5\2\u0161\u0163\5\26\f\2\u0162")
+        buf.write("\u0160\3\2\2\2\u0162\u0161\3\2\2\2\u0163+\3\2\2\2\u0164")
+        buf.write("\u016f\5.\30\2\u0165\u0166\5\60\31\2\u0166\u0167\7\7\2")
+        buf.write("\2\u0167\u0169\3\2\2\2\u0168\u0165\3\2\2\2\u0169\u016c")
+        buf.write("\3\2\2\2\u016a\u0168\3\2\2\2\u016a\u016b\3\2\2\2\u016b")
+        buf.write("\u016d\3\2\2\2\u016c\u016a\3\2\2\2\u016d\u016f\5\62\32")
+        buf.write("\2\u016e\u0164\3\2\2\2\u016e\u016a\3\2\2\2\u016f-\3\2")
+        buf.write("\2\2\u0170\u0175\5\60\31\2\u0171\u0172\7\7\2\2\u0172\u0174")
+        buf.write("\5\60\31\2\u0173\u0171\3\2\2\2\u0174\u0177\3\2\2\2\u0175")
+        buf.write("\u0173\3\2\2\2\u0175\u0176\3\2\2\2\u0176\u0179\3\2\2\2")
+        buf.write("\u0177\u0175\3\2\2\2\u0178\u0170\3\2\2\2\u0178\u0179\3")
+        buf.write("\2\2\2\u0179/\3\2\2\2\u017a\u017d\5\b\5\2\u017b\u017c")
+        buf.write("\7\33\2\2\u017c\u017e\5\66\34\2\u017d\u017b\3\2\2\2\u017d")
+        buf.write("\u017e\3\2\2\2\u017e\61\3\2\2\2\u017f\u0184\5\64\33\2")
+        buf.write("\u0180\u0181\7\7\2\2\u0181\u0183\5\64\33\2\u0182\u0180")
+        buf.write("\3\2\2\2\u0183\u0186\3\2\2\2\u0184\u0182\3\2\2\2\u0184")
+        buf.write("\u0185\3\2\2\2\u0185\63\3\2\2\2\u0186\u0184\3\2\2\2\u0187")
+        buf.write("\u0188\7.\2\2\u0188\u0189\7\21\2\2\u0189\u018a\5\20\t")
+        buf.write("\2\u018a\65\3\2\2\2\u018b\u018c\7\b\2\2\u018c\u01bb\7")
+        buf.write("\t\2\2\u018d\u018e\7\b\2\2\u018e\u018f\5\66\34\2\u018f")
+        buf.write("\u0190\7\7\2\2\u0190\u0191\7\t\2\2\u0191\u01bb\3\2\2\2")
+        buf.write("\u0192\u0193\7\b\2\2\u0193\u0196\5\66\34\2\u0194\u0195")
+        buf.write("\7\7\2\2\u0195\u0197\5\66\34\2\u0196\u0194\3\2\2\2\u0197")
+        buf.write("\u0198\3\2\2\2\u0198\u0196\3\2\2\2\u0198\u0199\3\2\2\2")
+        buf.write("\u0199\u019a\3\2\2\2\u019a\u019b\7\t\2\2\u019b\u01bb\3")
+        buf.write("\2\2\2\u019c\u019d\5\4\3\2\u019d\u019e\58\35\2\u019e\u01bb")
+        buf.write("\3\2\2\2\u019f\u01bb\5\4\3\2\u01a0\u01a1\7\34\2\2\u01a1")
+        buf.write("\u01a2\7\n\2\2\u01a2\u01a3\5:\36\2\u01a3\u01a4\7\7\2\2")
+        buf.write("\u01a4\u01a5\5\66\34\2\u01a5\u01a6\7\13\2\2\u01a6\u01bb")
+        buf.write("\3\2\2\2\u01a7\u01a9\7\24\2\2\u01a8\u01aa\58\35\2\u01a9")
+        buf.write("\u01a8\3\2\2\2\u01a9\u01aa\3\2\2\2\u01aa\u01ab\3\2\2\2")
+        buf.write("\u01ab\u01b4\7\b\2\2\u01ac\u01b1\5\66\34\2\u01ad\u01ae")
+        buf.write("\7\7\2\2\u01ae\u01b0\5\66\34\2\u01af\u01ad\3\2\2\2\u01b0")
+        buf.write("\u01b3\3\2\2\2\u01b1\u01af\3\2\2\2\u01b1\u01b2\3\2\2\2")
+        buf.write("\u01b2\u01b5\3\2\2\2\u01b3\u01b1\3\2\2\2\u01b4\u01ac\3")
+        buf.write("\2\2\2\u01b4\u01b5\3\2\2\2\u01b5\u01b6\3\2\2\2\u01b6\u01b7")
+        buf.write("\7\t\2\2\u01b7\u01b8\7\25\2\2\u01b8\u01bb\5\66\34\2\u01b9")
+        buf.write("\u01bb\7\6\2\2\u01ba\u018b\3\2\2\2\u01ba\u018d\3\2\2\2")
+        buf.write("\u01ba\u0192\3\2\2\2\u01ba\u019c\3\2\2\2\u01ba\u019f\3")
+        buf.write("\2\2\2\u01ba\u01a0\3\2\2\2\u01ba\u01a7\3\2\2\2\u01ba\u01b9")
+        buf.write("\3\2\2\2\u01bb\67\3\2\2\2\u01bc\u01bd\7\n\2\2\u01bd\u01c2")
+        buf.write("\5\4\3\2\u01be\u01bf\7\7\2\2\u01bf\u01c1\5\4\3\2\u01c0")
+        buf.write("\u01be\3\2\2\2\u01c1\u01c4\3\2\2\2\u01c2\u01c0\3\2\2\2")
+        buf.write("\u01c2\u01c3\3\2\2\2\u01c3\u01c5\3\2\2\2\u01c4\u01c2\3")
+        buf.write("\2\2\2\u01c5\u01c6\7\13\2\2\u01c69\3\2\2\2\u01c7\u01c8")
+        buf.write("\7\b\2\2\u01c8\u01d5\7\t\2\2\u01c9\u01ca\7\b\2\2\u01ca")
+        buf.write("\u01cd\5> \2\u01cb\u01cc\7\7\2\2\u01cc\u01ce\5> \2\u01cd")
+        buf.write("\u01cb\3\2\2\2\u01ce\u01cf\3\2\2\2\u01cf\u01cd\3\2\2\2")
+        buf.write("\u01cf\u01d0\3\2\2\2\u01d0\u01d1\3\2\2\2\u01d1\u01d2\7")
+        buf.write("\t\2\2\u01d2\u01d5\3\2\2\2\u01d3\u01d5\5> \2\u01d4\u01c7")
+        buf.write("\3\2\2\2\u01d4\u01c9\3\2\2\2\u01d4\u01d3\3\2\2\2\u01d5")
+        buf.write(";\3\2\2\2\u01d6\u01d7\7\35\2\2\u01d7\u01d8\7\n\2\2\u01d8")
+        buf.write("\u01d9\7.\2\2\u01d9\u01da\7\13\2\2\u01da\u01db\7\n\2\2")
+        buf.write("\u01db\u01dc\7\60\2\2\u01dc\u01dd\7\13\2\2\u01dd=\3\2")
+        buf.write("\2\2\u01de\u01e5\5<\37\2\u01df\u01e0\7\b\2\2\u01e0\u01e1")
+        buf.write("\5> \2\u01e1\u01e2\7\t\2\2\u01e2\u01e5\3\2\2\2\u01e3\u01e5")
+        buf.write("\7\60\2\2\u01e4\u01de\3\2\2\2\u01e4\u01df\3\2\2\2\u01e4")
+        buf.write("\u01e3\3\2\2\2\u01e5?\3\2\2\2\u01e6\u01e7\7\16\2\2\u01e7")
+        buf.write("\u01e8\5\20\t\2\u01e8\u01e9\7\17\2\2\u01e9A\3\2\2\2\u01ea")
+        buf.write("\u01ee\7/\2\2\u01eb\u01ee\7\60\2\2\u01ec\u01ee\7-\2\2")
+        buf.write("\u01ed\u01ea\3\2\2\2\u01ed\u01eb\3\2\2\2\u01ed\u01ec\3")
+        buf.write("\2\2\2\u01eeC\3\2\2\2\u01ef\u01f4\5\4\3\2\u01f0\u01f4")
+        buf.write("\5\6\4\2\u01f1\u01f4\5\b\5\2\u01f2\u01f4\5\n\6\2\u01f3")
+        buf.write("\u01ef\3\2\2\2\u01f3\u01f0\3\2\2\2\u01f3\u01f1\3\2\2\2")
+        buf.write("\u01f3\u01f2\3\2\2\2\u01f4E\3\2\2\2\67JNQZknvz\u0091\u009b")
+        buf.write("\u009e\u00af\u00c4\u00dd\u00df\u00e4\u00eb\u00f2\u00f9")
+        buf.write("\u0100\u0104\u0108\u0111\u0115\u011e\u0123\u012a\u012e")
+        buf.write("\u0132\u013a\u0144\u014d\u014f\u0153\u015b\u0162\u016a")
+        buf.write("\u016e\u0175\u0178\u017d\u0184\u0198\u01a9\u01b1\u01b4")
+        buf.write("\u01ba\u01c2\u01cf\u01d4\u01e4\u01ed\u01f3")
         return buf.getvalue()
 
 
@@ -253,12 +265,12 @@ class RelayParser ( Parser ):
     sharedContextCache = PredictionContextCache()
 
     literalNames = [ "<INVALID>", "'.'", "'@'", "'%'", "'_'", "','", "'('", 
-                     "')'", "'{'", "'}'", "'['", "']'", "'if'", "'else'", 
+                     "')'", "'['", "']'", "'if'", "'else'", "'{'", "'}'", 
                      "'let'", "'='", "';'", "';;'", "'fn'", "'->'", "'def'", 
-                     "'type'", "'|'", "'=>'", "'match'", "'match?'", "':'", 
-                     "'Tensor'", "'meta'", "'v0.0.3'", "<INVALID>", "<INVALID>", 
-                     "<INVALID>", "<INVALID>", "'*'", "'/'", "'+'", "'-'", 
-                     "'<'", "'>'", "'<='", "'>='", "'=='", "'!='" ]
+                     "'type'", "'=>'", "'match'", "'match?'", "':'", "'Tensor'", 
+                     "'meta'", "'v0.0.4'", "<INVALID>", "<INVALID>", "<INVALID>", 
+                     "<INVALID>", "'*'", "'/'", "'+'", "'-'", "'<'", "'>'", 
+                     "'<='", "'>='", "'=='", "'!='" ]
 
     symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
@@ -267,10 +279,9 @@ class RelayParser ( Parser ):
                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
-                      "<INVALID>", "SEMVER", "COMMENT", "WS", "LINE_COMMENT", 
-                      "QUOTED_STRING", "MUL", "DIV", "ADD", "SUB", "LT", 
-                      "GT", "LE", "GE", "EQ", "NE", "BOOL_LIT", "CNAME", 
-                      "FLOAT", "NAT", "METADATA" ]
+                      "SEMVER", "COMMENT", "WS", "LINE_COMMENT", "QUOTED_STRING", 
+                      "MUL", "DIV", "ADD", "SUB", "LT", "GT", "LE", "GE", 
+                      "EQ", "NE", "BOOL_LIT", "CNAME", "FLOAT", "NAT", "METADATA" ]
 
     RULE_prog = 0
     RULE_generalIdent = 1
@@ -283,35 +294,37 @@ class RelayParser ( Parser ):
     RULE_func = 8
     RULE_defn = 9
     RULE_constructorName = 10
-    RULE_adtConsDefn = 11
-    RULE_matchClause = 12
-    RULE_matchType = 13
-    RULE_patternList = 14
-    RULE_pattern = 15
-    RULE_adtCons = 16
-    RULE_adtConsParamList = 17
-    RULE_adtConsParam = 18
-    RULE_argList = 19
-    RULE_varList = 20
-    RULE_var = 21
-    RULE_attrSeq = 22
-    RULE_attr = 23
-    RULE_typeExpr = 24
-    RULE_typeParamList = 25
-    RULE_shapeList = 26
-    RULE_meta = 27
-    RULE_shape = 28
-    RULE_body = 29
-    RULE_scalar = 30
-    RULE_ident = 31
+    RULE_adtConsDefnList = 11
+    RULE_adtConsDefn = 12
+    RULE_matchClauseList = 13
+    RULE_matchClause = 14
+    RULE_matchType = 15
+    RULE_patternList = 16
+    RULE_pattern = 17
+    RULE_adtCons = 18
+    RULE_adtConsParamList = 19
+    RULE_adtConsParam = 20
+    RULE_argList = 21
+    RULE_varList = 22
+    RULE_var = 23
+    RULE_attrSeq = 24
+    RULE_attr = 25
+    RULE_typeExpr = 26
+    RULE_typeParamList = 27
+    RULE_shapeList = 28
+    RULE_meta = 29
+    RULE_shape = 30
+    RULE_body = 31
+    RULE_scalar = 32
+    RULE_ident = 33
 
     ruleNames =  [ "prog", "generalIdent", "globalVar", "localVar", "graphVar", 
                    "exprList", "callList", "expr", "func", "defn", "constructorName", 
-                   "adtConsDefn", "matchClause", "matchType", "patternList", 
-                   "pattern", "adtCons", "adtConsParamList", "adtConsParam", 
-                   "argList", "varList", "var", "attrSeq", "attr", "typeExpr", 
-                   "typeParamList", "shapeList", "meta", "shape", "body", 
-                   "scalar", "ident" ]
+                   "adtConsDefnList", "adtConsDefn", "matchClauseList", 
+                   "matchClause", "matchType", "patternList", "pattern", 
+                   "adtCons", "adtConsParamList", "adtConsParam", "argList", 
+                   "varList", "var", "attrSeq", "attr", "typeExpr", "typeParamList", 
+                   "shapeList", "meta", "shape", "body", "scalar", "ident" ]
 
     EOF = Token.EOF
     T__0=1
@@ -341,27 +354,26 @@ class RelayParser ( Parser ):
     T__24=25
     T__25=26
     T__26=27
-    T__27=28
-    SEMVER=29
-    COMMENT=30
-    WS=31
-    LINE_COMMENT=32
-    QUOTED_STRING=33
-    MUL=34
-    DIV=35
-    ADD=36
-    SUB=37
-    LT=38
-    GT=39
-    LE=40
-    GE=41
-    EQ=42
-    NE=43
-    BOOL_LIT=44
-    CNAME=45
-    FLOAT=46
-    NAT=47
-    METADATA=48
+    SEMVER=28
+    COMMENT=29
+    WS=30
+    LINE_COMMENT=31
+    QUOTED_STRING=32
+    MUL=33
+    DIV=34
+    ADD=35
+    SUB=36
+    LT=37
+    GT=38
+    LE=39
+    GE=40
+    EQ=41
+    NE=42
+    BOOL_LIT=43
+    CNAME=44
+    FLOAT=45
+    NAT=46
+    METADATA=47
 
     def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
         super().__init__(input, output)
@@ -417,39 +429,39 @@ def prog(self):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 64
+            self.state = 68
             self.match(RelayParser.SEMVER)
-            self.state = 72
+            self.state = 76
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [RelayParser.EOF, RelayParser.T__19, RelayParser.T__20, RelayParser.METADATA]:
-                self.state = 68
+                self.state = 72
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while _la==RelayParser.T__19 or _la==RelayParser.T__20:
-                    self.state = 65
+                    self.state = 69
                     self.defn()
-                    self.state = 70
+                    self.state = 74
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
                 pass
-            elif token in [RelayParser.T__1, RelayParser.T__2, RelayParser.T__5, RelayParser.T__7, RelayParser.T__9, RelayParser.T__11, RelayParser.T__13, RelayParser.T__17, RelayParser.T__23, RelayParser.T__24, RelayParser.T__27, RelayParser.QUOTED_STRING, RelayParser.SUB, RelayParser.BOOL_LIT, RelayParser.CNAME, RelayParser.FLOAT, RelayParser.NAT]:
-                self.state = 71
+            elif token in [RelayParser.T__1, RelayParser.T__2, RelayParser.T__5, RelayParser.T__7, RelayParser.T__9, RelayParser.T__13, RelayParser.T__17, RelayParser.T__22, RelayParser.T__23, RelayParser.T__26, RelayParser.QUOTED_STRING, RelayParser.SUB, RelayParser.BOOL_LIT, RelayParser.CNAME, RelayParser.FLOAT, RelayParser.NAT]:
+                self.state = 75
                 self.expr(0)
                 pass
             else:
                 raise NoViableAltException(self)
 
-            self.state = 75
+            self.state = 79
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==RelayParser.METADATA:
-                self.state = 74
+                self.state = 78
                 self.match(RelayParser.METADATA)
 
 
-            self.state = 77
+            self.state = 81
             self.match(RelayParser.EOF)
         except RecognitionException as re:
             localctx.exception = re
@@ -490,18 +502,18 @@ def generalIdent(self):
         self.enterRule(localctx, 2, self.RULE_generalIdent)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 79
+            self.state = 83
             self.match(RelayParser.CNAME)
-            self.state = 84
+            self.state = 88
             self._errHandler.sync(self)
             _alt = self._interp.adaptivePredict(self._input,3,self._ctx)
             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                 if _alt==1:
-                    self.state = 80
+                    self.state = 84
                     self.match(RelayParser.T__0)
-                    self.state = 81
+                    self.state = 85
                     self.match(RelayParser.CNAME) 
-                self.state = 86
+                self.state = 90
                 self._errHandler.sync(self)
                 _alt = self._interp.adaptivePredict(self._input,3,self._ctx)
 
@@ -541,9 +553,9 @@ def globalVar(self):
         self.enterRule(localctx, 4, self.RULE_globalVar)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 87
+            self.state = 91
             self.match(RelayParser.T__1)
-            self.state = 88
+            self.state = 92
             self.match(RelayParser.CNAME)
         except RecognitionException as re:
             localctx.exception = re
@@ -582,9 +594,9 @@ def localVar(self):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 90
+            self.state = 94
             self.match(RelayParser.T__2)
-            self.state = 91
+            self.state = 95
             _la = self._input.LA(1)
             if not(_la==RelayParser.T__3 or _la==RelayParser.CNAME):
                 self._errHandler.recoverInline(self)
@@ -627,9 +639,9 @@ def graphVar(self):
         self.enterRule(localctx, 8, self.RULE_graphVar)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 93
+            self.state = 97
             self.match(RelayParser.T__2)
-            self.state = 94
+            self.state = 98
             self.match(RelayParser.NAT)
         except RecognitionException as re:
             localctx.exception = re
@@ -672,21 +684,21 @@ def exprList(self):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 104
+            self.state = 108
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__1) | (1 << RelayParser.T__2) | (1 << RelayParser.T__5) | (1 << RelayParser.T__7) | (1 << RelayParser.T__9) | (1 << RelayParser.T__11) | (1 << RelayParser.T__13) | (1 << RelayParser.T__17) | (1 << RelayParser.T__23) | (1 << RelayParser.T__24) | (1 << RelayParser.T__27) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
-                self.state = 96
+            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__1) | (1 << RelayParser.T__2) | (1 << RelayParser.T__5) | (1 << RelayParser.T__7) | (1 << RelayParser.T__9) | (1 << RelayParser.T__13) | (1 << RelayParser.T__17) | (1 << RelayParser.T__22) | (1 << RelayParser.T__23) | (1 << RelayParser.T__26) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
+                self.state = 100
                 self.expr(0)
-                self.state = 101
+                self.state = 105
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while _la==RelayParser.T__4:
-                    self.state = 97
+                    self.state = 101
                     self.match(RelayParser.T__4)
-                    self.state = 98
+                    self.state = 102
                     self.expr(0)
-                    self.state = 103
+                    self.state = 107
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
@@ -763,33 +775,33 @@ def callList(self):
         localctx = RelayParser.CallListContext(self, self._ctx, self.state)
         self.enterRule(localctx, 12, self.RULE_callList)
         try:
-            self.state = 116
+            self.state = 120
             self._errHandler.sync(self)
             la_ = self._interp.adaptivePredict(self._input,7,self._ctx)
             if la_ == 1:
                 localctx = RelayParser.CallNoAttrContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 106
+                self.state = 110
                 self.exprList()
                 pass
 
             elif la_ == 2:
                 localctx = RelayParser.CallWithAttrContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 112
+                self.state = 116
                 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 = 107
+                        self.state = 111
                         self.expr(0)
-                        self.state = 108
+                        self.state = 112
                         self.match(RelayParser.T__4) 
-                    self.state = 114
+                    self.state = 118
                     self._errHandler.sync(self)
                     _alt = self._interp.adaptivePredict(self._input,6,self._ctx)
 
-                self.state = 115
+                self.state = 119
                 self.attrSeq()
                 pass
 
@@ -864,11 +876,8 @@ def matchType(self):
         def expr(self):
             return self.getTypedRuleContext(RelayParser.ExprContext,0)
 
-        def matchClause(self, i:int=None):
-            if i is None:
-                return self.getTypedRuleContexts(RelayParser.MatchClauseContext)
-            else:
-                return self.getTypedRuleContext(RelayParser.MatchClauseContext,i)
+        def matchClauseList(self):
+            return self.getTypedRuleContext(RelayParser.MatchClauseListContext,0)
 
 
         def accept(self, visitor:ParseTreeVisitor):
@@ -1164,7 +1173,7 @@ def expr(self, _p:int=0):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 196
+            self.state = 194
             self._errHandler.sync(self)
             la_ = self._interp.adaptivePredict(self._input,12,self._ctx)
             if la_ == 1:
@@ -1172,27 +1181,15 @@ def expr(self, _p:int=0):
                 self._ctx = localctx
                 _prevctx = localctx
 
-                self.state = 119
-                self.match(RelayParser.T__5)
-                self.state = 120
-                self.expr(0)
-                self.state = 121
-                self.match(RelayParser.T__6)
-                pass
-
-            elif la_ == 2:
-                localctx = RelayParser.ParenContext(self, localctx)
-                self._ctx = localctx
-                _prevctx = localctx
                 self.state = 123
-                self.match(RelayParser.T__7)
+                self.match(RelayParser.T__5)
                 self.state = 124
                 self.expr(0)
                 self.state = 125
-                self.match(RelayParser.T__8)
+                self.match(RelayParser.T__6)
                 pass
 
-            elif la_ == 3:
+            elif la_ == 2:
                 localctx = RelayParser.NegContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
@@ -1202,7 +1199,7 @@ def expr(self, _p:int=0):
                 self.expr(20)
                 pass
 
-            elif la_ == 4:
+            elif la_ == 3:
                 localctx = RelayParser.FuncExprContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
@@ -1210,7 +1207,7 @@ def expr(self, _p:int=0):
                 self.func()
                 pass
 
-            elif la_ == 5:
+            elif la_ == 4:
                 localctx = RelayParser.TupleContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
@@ -1220,7 +1217,7 @@ def expr(self, _p:int=0):
                 self.match(RelayParser.T__6)
                 pass
 
-            elif la_ == 6:
+            elif la_ == 5:
                 localctx = RelayParser.TupleContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
@@ -1234,7 +1231,7 @@ def expr(self, _p:int=0):
                 self.match(RelayParser.T__6)
                 pass
 
-            elif la_ == 7:
+            elif la_ == 6:
                 localctx = RelayParser.TupleContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
@@ -1260,16 +1257,16 @@ def expr(self, _p:int=0):
                 self.match(RelayParser.T__6)
                 pass
 
-            elif la_ == 8:
+            elif la_ == 7:
                 localctx = RelayParser.TensorContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
                 self.state = 147
-                self.match(RelayParser.T__9)
+                self.match(RelayParser.T__7)
                 self.state = 156
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__1) | (1 << RelayParser.T__2) | (1 << RelayParser.T__5) | (1 << RelayParser.T__7) | (1 << RelayParser.T__9) | (1 << RelayParser.T__11) | (1 << RelayParser.T__13) | (1 << RelayParser.T__17) | (1 << RelayParser.T__23) | (1 << RelayParser.T__24) | (1 << RelayParser.T__27) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
+                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__1) | (1 << RelayParser.T__2) | (1 << RelayParser.T__5) | (1 << RelayParser.T__7) | (1 << RelayParser.T__9) | (1 << RelayParser.T__13) | (1 << RelayParser.T__17) | (1 << RelayParser.T__22) | (1 << RelayParser.T__23) | (1 << RelayParser.T__26) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
                     self.state = 148
                     self.expr(0)
                     self.state = 153
@@ -1287,15 +1284,15 @@ def expr(self, _p:int=0):
 
 
                 self.state = 158
-                self.match(RelayParser.T__10)
+                self.match(RelayParser.T__8)
                 pass
 
-            elif la_ == 9:
+            elif la_ == 8:
                 localctx = RelayParser.IfElseContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
                 self.state = 159
-                self.match(RelayParser.T__11)
+                self.match(RelayParser.T__9)
                 self.state = 160
                 self.match(RelayParser.T__5)
                 self.state = 161
@@ -1305,12 +1302,12 @@ def expr(self, _p:int=0):
                 self.state = 163
                 self.body()
                 self.state = 164
-                self.match(RelayParser.T__12)
+                self.match(RelayParser.T__10)
                 self.state = 165
                 self.body()
                 pass
 
-            elif la_ == 10:
+            elif la_ == 9:
                 localctx = RelayParser.MatchContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
@@ -1323,92 +1320,88 @@ def expr(self, _p:int=0):
                 self.state = 170
                 self.match(RelayParser.T__6)
                 self.state = 171
-                self.match(RelayParser.T__7)
-                self.state = 173 
+                self.match(RelayParser.T__11)
+                self.state = 173
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                while True:
+                if _la==RelayParser.CNAME:
                     self.state = 172
-                    self.matchClause()
-                    self.state = 175 
-                    self._errHandler.sync(self)
-                    _la = self._input.LA(1)
-                    if not (_la==RelayParser.T__21):
-                        break
+                    self.matchClauseList()
 
-                self.state = 177
-                self.match(RelayParser.T__8)
+
+                self.state = 175
+                self.match(RelayParser.T__12)
                 pass
 
-            elif la_ == 11:
+            elif la_ == 10:
                 localctx = RelayParser.LetContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 179
+                self.state = 177
                 self.match(RelayParser.T__13)
-                self.state = 180
+                self.state = 178
                 self.var()
-                self.state = 181
+                self.state = 179
                 self.match(RelayParser.T__14)
-                self.state = 182
+                self.state = 180
                 self.expr(0)
-                self.state = 183
+                self.state = 181
                 self.match(RelayParser.T__15)
-                self.state = 184
+                self.state = 182
                 self.expr(7)
                 pass
 
-            elif la_ == 12:
+            elif la_ == 11:
                 localctx = RelayParser.GraphContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 186
+                self.state = 184
                 self.graphVar()
-                self.state = 187
+                self.state = 185
                 self.match(RelayParser.T__14)
-                self.state = 188
+                self.state = 186
                 self.expr(0)
-                self.state = 189
+                self.state = 187
                 self.match(RelayParser.T__15)
-                self.state = 190
+                self.state = 188
                 self.expr(5)
                 pass
 
-            elif la_ == 13:
+            elif la_ == 12:
                 localctx = RelayParser.IdentExprContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 192
+                self.state = 190
                 self.ident()
                 pass
 
-            elif la_ == 14:
+            elif la_ == 13:
                 localctx = RelayParser.ScalarExprContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 193
+                self.state = 191
                 self.scalar()
                 pass
 
-            elif la_ == 15:
+            elif la_ == 14:
                 localctx = RelayParser.MetaExprContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 194
+                self.state = 192
                 self.meta()
                 pass
 
-            elif la_ == 16:
+            elif la_ == 15:
                 localctx = RelayParser.StringExprContext(self, localctx)
                 self._ctx = localctx
                 _prevctx = localctx
-                self.state = 195
+                self.state = 193
                 self.match(RelayParser.QUOTED_STRING)
                 pass
 
 
             self._ctx.stop = self._input.LT(-1)
-            self.state = 223
+            self.state = 221
             self._errHandler.sync(self)
             _alt = self._interp.adaptivePredict(self._input,14,self._ctx)
             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
@@ -1416,17 +1409,17 @@ def expr(self, _p:int=0):
                     if self._parseListeners is not None:
                         self.triggerExitRuleEvent()
                     _prevctx = localctx
-                    self.state = 221
+                    self.state = 219
                     self._errHandler.sync(self)
                     la_ = self._interp.adaptivePredict(self._input,13,self._ctx)
                     if la_ == 1:
                         localctx = RelayParser.BinOpContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 198
+                        self.state = 196
                         if not self.precpred(self._ctx, 19):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 19)")
-                        self.state = 199
+                        self.state = 197
                         localctx.op = self._input.LT(1)
                         _la = self._input.LA(1)
                         if not(_la==RelayParser.MUL or _la==RelayParser.DIV):
@@ -1434,18 +1427,18 @@ def expr(self, _p:int=0):
                         else:
                             self._errHandler.reportMatch(self)
                             self.consume()
-                        self.state = 200
+                        self.state = 198
                         self.expr(20)
                         pass
 
                     elif la_ == 2:
                         localctx = RelayParser.BinOpContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 201
+                        self.state = 199
                         if not self.precpred(self._ctx, 18):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 18)")
-                        self.state = 202
+                        self.state = 200
                         localctx.op = self._input.LT(1)
                         _la = self._input.LA(1)
                         if not(_la==RelayParser.ADD or _la==RelayParser.SUB):
@@ -1453,18 +1446,18 @@ def expr(self, _p:int=0):
                         else:
                             self._errHandler.reportMatch(self)
                             self.consume()
-                        self.state = 203
+                        self.state = 201
                         self.expr(19)
                         pass
 
                     elif la_ == 3:
                         localctx = RelayParser.BinOpContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 204
+                        self.state = 202
                         if not self.precpred(self._ctx, 17):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 17)")
-                        self.state = 205
+                        self.state = 203
                         localctx.op = self._input.LT(1)
                         _la = self._input.LA(1)
                         if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.LT) | (1 << RelayParser.GT) | (1 << RelayParser.LE) | (1 << RelayParser.GE))) != 0)):
@@ -1472,18 +1465,18 @@ def expr(self, _p:int=0):
                         else:
                             self._errHandler.reportMatch(self)
                             self.consume()
-                        self.state = 206
+                        self.state = 204
                         self.expr(18)
                         pass
 
                     elif la_ == 4:
                         localctx = RelayParser.BinOpContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 207
+                        self.state = 205
                         if not self.precpred(self._ctx, 16):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 16)")
-                        self.state = 208
+                        self.state = 206
                         localctx.op = self._input.LT(1)
                         _la = self._input.LA(1)
                         if not(_la==RelayParser.EQ or _la==RelayParser.NE):
@@ -1491,53 +1484,53 @@ def expr(self, _p:int=0):
                         else:
                             self._errHandler.reportMatch(self)
                             self.consume()
-                        self.state = 209
+                        self.state = 207
                         self.expr(17)
                         pass
 
                     elif la_ == 5:
                         localctx = RelayParser.LetContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 210
+                        self.state = 208
                         if not self.precpred(self._ctx, 6):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 6)")
-                        self.state = 211
+                        self.state = 209
                         self.match(RelayParser.T__16)
-                        self.state = 212
+                        self.state = 210
                         self.expr(7)
                         pass
 
                     elif la_ == 6:
                         localctx = RelayParser.CallContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 213
+                        self.state = 211
                         if not self.precpred(self._ctx, 21):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 21)")
-                        self.state = 214
+                        self.state = 212
                         self.match(RelayParser.T__5)
-                        self.state = 215
+                        self.state = 213
                         self.callList()
-                        self.state = 216
+                        self.state = 214
                         self.match(RelayParser.T__6)
                         pass
 
                     elif la_ == 7:
                         localctx = RelayParser.ProjectionContext(self, RelayParser.ExprContext(self, _parentctx, _parentState))
                         self.pushNewRecursionContext(localctx, _startState, self.RULE_expr)
-                        self.state = 218
+                        self.state = 216
                         if not self.precpred(self._ctx, 8):
                             from antlr4.error.Errors import FailedPredicateException
                             raise FailedPredicateException(self, "self.precpred(self._ctx, 8)")
-                        self.state = 219
+                        self.state = 217
                         self.match(RelayParser.T__0)
-                        self.state = 220
+                        self.state = 218
                         self.match(RelayParser.NAT)
                         pass
 
              
-                self.state = 225
+                self.state = 223
                 self._errHandler.sync(self)
                 _alt = self._interp.adaptivePredict(self._input,14,self._ctx)
 
@@ -1591,33 +1584,33 @@ def func(self):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 226
+            self.state = 224
             self.match(RelayParser.T__17)
-            self.state = 228
+            self.state = 226
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==RelayParser.T__9:
-                self.state = 227
+            if _la==RelayParser.T__7:
+                self.state = 225
                 self.typeParamList()
 
 
-            self.state = 230
+            self.state = 228
             self.match(RelayParser.T__5)
-            self.state = 231
+            self.state = 229
             self.argList()
-            self.state = 232
+            self.state = 230
             self.match(RelayParser.T__6)
-            self.state = 235
+            self.state = 233
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==RelayParser.T__18:
-                self.state = 233
+                self.state = 231
                 self.match(RelayParser.T__18)
-                self.state = 234
+                self.state = 232
                 self.typeExpr()
 
 
-            self.state = 237
+            self.state = 235
             self.body()
         except RecognitionException as re:
             localctx.exception = re
@@ -1685,11 +1678,8 @@ def generalIdent(self):
         def typeParamList(self):
             return self.getTypedRuleContext(RelayParser.TypeParamListContext,0)
 
-        def adtConsDefn(self, i:int=None):
-            if i is None:
-                return self.getTypedRuleContexts(RelayParser.AdtConsDefnContext)
-            else:
-                return self.getTypedRuleContext(RelayParser.AdtConsDefnContext,i)
+        def adtConsDefnList(self):
+            return self.getTypedRuleContext(RelayParser.AdtConsDefnListContext,0)
 
 
         def accept(self, visitor:ParseTreeVisitor):
@@ -1706,72 +1696,70 @@ def defn(self):
         self.enterRule(localctx, 18, self.RULE_defn)
         self._la = 0 # Token type
         try:
-            self.state = 264
+            self.state = 262
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [RelayParser.T__19]:
                 localctx = RelayParser.FuncDefnContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 239
+                self.state = 237
                 self.match(RelayParser.T__19)
-                self.state = 240
+                self.state = 238
                 self.globalVar()
-                self.state = 242
+                self.state = 240
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if _la==RelayParser.T__9:
-                    self.state = 241
+                if _la==RelayParser.T__7:
+                    self.state = 239
                     self.typeParamList()
 
 
-                self.state = 244
+                self.state = 242
                 self.match(RelayParser.T__5)
-                self.state = 245
+                self.state = 243
                 self.argList()
-                self.state = 246
+                self.state = 244
                 self.match(RelayParser.T__6)
-                self.state = 249
+                self.state = 247
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if _la==RelayParser.T__18:
-                    self.state = 247
+                    self.state = 245
                     self.match(RelayParser.T__18)
-                    self.state = 248
+                    self.state = 246
                     self.typeExpr()
 
 
-                self.state = 251
+                self.state = 249
                 self.body()
                 pass
             elif token in [RelayParser.T__20]:
                 localctx = RelayParser.AdtDefnContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 253
+                self.state = 251
                 self.match(RelayParser.T__20)
-                self.state = 254
+                self.state = 252
                 self.generalIdent()
-                self.state = 256
+                self.state = 254
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if _la==RelayParser.T__9:
-                    self.state = 255
+                if _la==RelayParser.T__7:
+                    self.state = 253
                     self.typeParamList()
 
 
+                self.state = 256
+                self.match(RelayParser.T__11)
                 self.state = 258
-                self.match(RelayParser.T__14)
-                self.state = 260 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                while True:
-                    self.state = 259
-                    self.adtConsDefn()
-                    self.state = 262 
-                    self._errHandler.sync(self)
-                    _la = self._input.LA(1)
-                    if not (_la==RelayParser.T__21):
-                        break
+                if _la==RelayParser.CNAME:
+                    self.state = 257
+                    self.adtConsDefnList()
+
 
+                self.state = 260
+                self.match(RelayParser.T__12)
                 pass
             else:
                 raise NoViableAltException(self)
@@ -1812,7 +1800,7 @@ def constructorName(self):
         self.enterRule(localctx, 20, self.RULE_constructorName)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 266
+            self.state = 264
             self.match(RelayParser.CNAME)
         except RecognitionException as re:
             localctx.exception = re
@@ -1823,6 +1811,70 @@ def constructorName(self):
         return localctx
 
 
+    class AdtConsDefnListContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def adtConsDefn(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(RelayParser.AdtConsDefnContext)
+            else:
+                return self.getTypedRuleContext(RelayParser.AdtConsDefnContext,i)
+
+
+        def getRuleIndex(self):
+            return RelayParser.RULE_adtConsDefnList
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitAdtConsDefnList" ):
+                return visitor.visitAdtConsDefnList(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def adtConsDefnList(self):
+
+        localctx = RelayParser.AdtConsDefnListContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 22, self.RULE_adtConsDefnList)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 266
+            self.adtConsDefn()
+            self.state = 271
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,22,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    self.state = 267
+                    self.match(RelayParser.T__4)
+                    self.state = 268
+                    self.adtConsDefn() 
+                self.state = 273
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,22,self._ctx)
+
+            self.state = 275
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            if _la==RelayParser.T__4:
+                self.state = 274
+                self.match(RelayParser.T__4)
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
     class AdtConsDefnContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
@@ -1855,35 +1907,33 @@ def accept(self, visitor:ParseTreeVisitor):
     def adtConsDefn(self):
 
         localctx = RelayParser.AdtConsDefnContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 22, self.RULE_adtConsDefn)
+        self.enterRule(localctx, 24, self.RULE_adtConsDefn)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 268
-            self.match(RelayParser.T__21)
-            self.state = 269
+            self.state = 277
             self.constructorName()
-            self.state = 281
+            self.state = 289
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==RelayParser.T__5:
-                self.state = 270
+                self.state = 278
                 self.match(RelayParser.T__5)
-                self.state = 271
+                self.state = 279
                 self.typeExpr()
-                self.state = 276
+                self.state = 284
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while _la==RelayParser.T__4:
-                    self.state = 272
+                    self.state = 280
                     self.match(RelayParser.T__4)
-                    self.state = 273
+                    self.state = 281
                     self.typeExpr()
-                    self.state = 278
+                    self.state = 286
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
-                self.state = 279
+                self.state = 287
                 self.match(RelayParser.T__6)
 
 
@@ -1896,6 +1946,70 @@ def adtConsDefn(self):
         return localctx
 
 
+    class MatchClauseListContext(ParserRuleContext):
+
+        def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
+            super().__init__(parent, invokingState)
+            self.parser = parser
+
+        def matchClause(self, i:int=None):
+            if i is None:
+                return self.getTypedRuleContexts(RelayParser.MatchClauseContext)
+            else:
+                return self.getTypedRuleContext(RelayParser.MatchClauseContext,i)
+
+
+        def getRuleIndex(self):
+            return RelayParser.RULE_matchClauseList
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitMatchClauseList" ):
+                return visitor.visitMatchClauseList(self)
+            else:
+                return visitor.visitChildren(self)
+
+
+
+
+    def matchClauseList(self):
+
+        localctx = RelayParser.MatchClauseListContext(self, self._ctx, self.state)
+        self.enterRule(localctx, 26, self.RULE_matchClauseList)
+        self._la = 0 # Token type
+        try:
+            self.enterOuterAlt(localctx, 1)
+            self.state = 291
+            self.matchClause()
+            self.state = 296
+            self._errHandler.sync(self)
+            _alt = self._interp.adaptivePredict(self._input,26,self._ctx)
+            while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
+                if _alt==1:
+                    self.state = 292
+                    self.match(RelayParser.T__4)
+                    self.state = 293
+                    self.matchClause() 
+                self.state = 298
+                self._errHandler.sync(self)
+                _alt = self._interp.adaptivePredict(self._input,26,self._ctx)
+
+            self.state = 300
+            self._errHandler.sync(self)
+            _la = self._input.LA(1)
+            if _la==RelayParser.T__4:
+                self.state = 299
+                self.match(RelayParser.T__4)
+
+
+        except RecognitionException as re:
+            localctx.exception = re
+            self._errHandler.reportError(self, re)
+            self._errHandler.recover(self, re)
+        finally:
+            self.exitRule()
+        return localctx
+
+
     class MatchClauseContext(ParserRuleContext):
 
         def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):
@@ -1929,26 +2043,40 @@ def accept(self, visitor:ParseTreeVisitor):
     def matchClause(self):
 
         localctx = RelayParser.MatchClauseContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 24, self.RULE_matchClause)
+        self.enterRule(localctx, 28, self.RULE_matchClause)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 283
-            self.match(RelayParser.T__21)
-            self.state = 284
+            self.state = 302
             self.constructorName()
-            self.state = 286
+            self.state = 304
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==RelayParser.T__5:
-                self.state = 285
+                self.state = 303
                 self.patternList()
 
 
-            self.state = 288
-            self.match(RelayParser.T__22)
-            self.state = 289
-            self.expr(0)
+            self.state = 306
+            self.match(RelayParser.T__21)
+            self.state = 312
+            self._errHandler.sync(self)
+            token = self._input.LA(1)
+            if token in [RelayParser.T__11]:
+                self.state = 307
+                self.match(RelayParser.T__11)
+                self.state = 308
+                self.expr(0)
+                self.state = 309
+                self.match(RelayParser.T__12)
+                pass
+            elif token in [RelayParser.T__1, RelayParser.T__2, RelayParser.T__5, RelayParser.T__7, RelayParser.T__9, RelayParser.T__13, RelayParser.T__17, RelayParser.T__22, RelayParser.T__23, RelayParser.T__26, RelayParser.QUOTED_STRING, RelayParser.SUB, RelayParser.BOOL_LIT, RelayParser.CNAME, RelayParser.FLOAT, RelayParser.NAT]:
+                self.state = 311
+                self.expr(0)
+                pass
+            else:
+                raise NoViableAltException(self)
+
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -1980,13 +2108,13 @@ def accept(self, visitor:ParseTreeVisitor):
     def matchType(self):
 
         localctx = RelayParser.MatchTypeContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 26, self.RULE_matchType)
+        self.enterRule(localctx, 30, self.RULE_matchType)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 291
+            self.state = 314
             _la = self._input.LA(1)
-            if not(_la==RelayParser.T__23 or _la==RelayParser.T__24):
+            if not(_la==RelayParser.T__22 or _la==RelayParser.T__23):
                 self._errHandler.recoverInline(self)
             else:
                 self._errHandler.reportMatch(self)
@@ -2028,27 +2156,27 @@ def accept(self, visitor:ParseTreeVisitor):
     def patternList(self):
 
         localctx = RelayParser.PatternListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 28, self.RULE_patternList)
+        self.enterRule(localctx, 32, self.RULE_patternList)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 293
+            self.state = 316
             self.match(RelayParser.T__5)
-            self.state = 294
+            self.state = 317
             self.pattern()
-            self.state = 299
+            self.state = 322
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==RelayParser.T__4:
-                self.state = 295
+                self.state = 318
                 self.match(RelayParser.T__4)
-                self.state = 296
+                self.state = 319
                 self.pattern()
-                self.state = 301
+                self.state = 324
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 302
+            self.state = 325
             self.match(RelayParser.T__6)
         except RecognitionException as re:
             localctx.exception = re
@@ -2088,28 +2216,28 @@ def accept(self, visitor:ParseTreeVisitor):
     def pattern(self):
 
         localctx = RelayParser.PatternContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 30, self.RULE_pattern)
+        self.enterRule(localctx, 34, self.RULE_pattern)
         self._la = 0 # Token type
         try:
-            self.state = 310
+            self.state = 333
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [RelayParser.T__3]:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 304
+                self.state = 327
                 self.match(RelayParser.T__3)
                 pass
             elif token in [RelayParser.T__2]:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 305
+                self.state = 328
                 self.localVar()
-                self.state = 308
+                self.state = 331
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if _la==RelayParser.T__25:
-                    self.state = 306
-                    self.match(RelayParser.T__25)
-                    self.state = 307
+                if _la==RelayParser.T__24:
+                    self.state = 329
+                    self.match(RelayParser.T__24)
+                    self.state = 330
                     self.typeExpr()
 
 
@@ -2155,17 +2283,17 @@ def accept(self, visitor:ParseTreeVisitor):
     def adtCons(self):
 
         localctx = RelayParser.AdtConsContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 32, self.RULE_adtCons)
+        self.enterRule(localctx, 36, self.RULE_adtCons)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 312
+            self.state = 335
             self.constructorName()
-            self.state = 314
+            self.state = 337
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==RelayParser.T__5:
-                self.state = 313
+                self.state = 336
                 self.adtConsParamList()
 
 
@@ -2206,27 +2334,27 @@ def accept(self, visitor:ParseTreeVisitor):
     def adtConsParamList(self):
 
         localctx = RelayParser.AdtConsParamListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 34, self.RULE_adtConsParamList)
+        self.enterRule(localctx, 38, self.RULE_adtConsParamList)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 316
+            self.state = 339
             self.match(RelayParser.T__5)
-            self.state = 317
+            self.state = 340
             self.adtConsParam()
-            self.state = 322
+            self.state = 345
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==RelayParser.T__4:
-                self.state = 318
+                self.state = 341
                 self.match(RelayParser.T__4)
-                self.state = 319
+                self.state = 342
                 self.adtConsParam()
-                self.state = 324
+                self.state = 347
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 325
+            self.state = 348
             self.match(RelayParser.T__6)
         except RecognitionException as re:
             localctx.exception = re
@@ -2266,19 +2394,19 @@ def accept(self, visitor:ParseTreeVisitor):
     def adtConsParam(self):
 
         localctx = RelayParser.AdtConsParamContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 36, self.RULE_adtConsParam)
+        self.enterRule(localctx, 40, self.RULE_adtConsParam)
         try:
-            self.state = 329
+            self.state = 352
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [RelayParser.T__2]:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 327
+                self.state = 350
                 self.localVar()
                 pass
             elif token in [RelayParser.CNAME]:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 328
+                self.state = 351
                 self.constructorName()
                 pass
             else:
@@ -2353,35 +2481,35 @@ def accept(self, visitor:ParseTreeVisitor):
     def argList(self):
 
         localctx = RelayParser.ArgListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 38, self.RULE_argList)
+        self.enterRule(localctx, 42, self.RULE_argList)
         self._la = 0 # Token type
         try:
-            self.state = 341
+            self.state = 364
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,32,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,37,self._ctx)
             if la_ == 1:
                 localctx = RelayParser.ArgNoAttrContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 331
+                self.state = 354
                 self.varList()
                 pass
 
             elif la_ == 2:
                 localctx = RelayParser.ArgWithAttrContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 337
+                self.state = 360
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while _la==RelayParser.T__2:
-                    self.state = 332
+                    self.state = 355
                     self.var()
-                    self.state = 333
+                    self.state = 356
                     self.match(RelayParser.T__4)
-                    self.state = 339
+                    self.state = 362
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
-                self.state = 340
+                self.state = 363
                 self.attrSeq()
                 pass
 
@@ -2423,25 +2551,25 @@ def accept(self, visitor:ParseTreeVisitor):
     def varList(self):
 
         localctx = RelayParser.VarListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 40, self.RULE_varList)
+        self.enterRule(localctx, 44, self.RULE_varList)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 351
+            self.state = 374
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==RelayParser.T__2:
-                self.state = 343
+                self.state = 366
                 self.var()
-                self.state = 348
+                self.state = 371
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while _la==RelayParser.T__4:
-                    self.state = 344
+                    self.state = 367
                     self.match(RelayParser.T__4)
-                    self.state = 345
+                    self.state = 368
                     self.var()
-                    self.state = 350
+                    self.state = 373
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
@@ -2485,19 +2613,19 @@ def accept(self, visitor:ParseTreeVisitor):
     def var(self):
 
         localctx = RelayParser.VarContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 42, self.RULE_var)
+        self.enterRule(localctx, 46, self.RULE_var)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 353
+            self.state = 376
             self.localVar()
-            self.state = 356
+            self.state = 379
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==RelayParser.T__25:
-                self.state = 354
-                self.match(RelayParser.T__25)
-                self.state = 355
+            if _la==RelayParser.T__24:
+                self.state = 377
+                self.match(RelayParser.T__24)
+                self.state = 378
                 self.typeExpr()
 
 
@@ -2538,21 +2666,21 @@ def accept(self, visitor:ParseTreeVisitor):
     def attrSeq(self):
 
         localctx = RelayParser.AttrSeqContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 44, self.RULE_attrSeq)
+        self.enterRule(localctx, 48, self.RULE_attrSeq)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 358
+            self.state = 381
             self.attr()
-            self.state = 363
+            self.state = 386
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==RelayParser.T__4:
-                self.state = 359
+                self.state = 382
                 self.match(RelayParser.T__4)
-                self.state = 360
+                self.state = 383
                 self.attr()
-                self.state = 365
+                self.state = 388
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
@@ -2593,14 +2721,14 @@ def accept(self, visitor:ParseTreeVisitor):
     def attr(self):
 
         localctx = RelayParser.AttrContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 46, self.RULE_attr)
+        self.enterRule(localctx, 50, self.RULE_attr)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 366
+            self.state = 389
             self.match(RelayParser.CNAME)
-            self.state = 367
+            self.state = 390
             self.match(RelayParser.T__14)
-            self.state = 368
+            self.state = 391
             self.expr(0)
         except RecognitionException as re:
             localctx.exception = re
@@ -2745,139 +2873,139 @@ def accept(self, visitor:ParseTreeVisitor):
     def typeExpr(self):
 
         localctx = RelayParser.TypeExprContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 48, self.RULE_typeExpr)
+        self.enterRule(localctx, 52, self.RULE_typeExpr)
         self._la = 0 # Token type
         try:
-            self.state = 417
+            self.state = 440
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,41,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,46,self._ctx)
             if la_ == 1:
                 localctx = RelayParser.TupleTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 370
+                self.state = 393
                 self.match(RelayParser.T__5)
-                self.state = 371
+                self.state = 394
                 self.match(RelayParser.T__6)
                 pass
 
             elif la_ == 2:
                 localctx = RelayParser.TupleTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 372
+                self.state = 395
                 self.match(RelayParser.T__5)
-                self.state = 373
+                self.state = 396
                 self.typeExpr()
-                self.state = 374
+                self.state = 397
                 self.match(RelayParser.T__4)
-                self.state = 375
+                self.state = 398
                 self.match(RelayParser.T__6)
                 pass
 
             elif la_ == 3:
                 localctx = RelayParser.TupleTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 3)
-                self.state = 377
+                self.state = 400
                 self.match(RelayParser.T__5)
-                self.state = 378
+                self.state = 401
                 self.typeExpr()
-                self.state = 381 
+                self.state = 404 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while True:
-                    self.state = 379
+                    self.state = 402
                     self.match(RelayParser.T__4)
-                    self.state = 380
+                    self.state = 403
                     self.typeExpr()
-                    self.state = 383 
+                    self.state = 406 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
                     if not (_la==RelayParser.T__4):
                         break
 
-                self.state = 385
+                self.state = 408
                 self.match(RelayParser.T__6)
                 pass
 
             elif la_ == 4:
                 localctx = RelayParser.TypeCallTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 4)
-                self.state = 387
+                self.state = 410
                 self.generalIdent()
-                self.state = 388
+                self.state = 411
                 self.typeParamList()
                 pass
 
             elif la_ == 5:
                 localctx = RelayParser.TypeIdentTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 5)
-                self.state = 390
+                self.state = 413
                 self.generalIdent()
                 pass
 
             elif la_ == 6:
                 localctx = RelayParser.TensorTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 6)
-                self.state = 391
-                self.match(RelayParser.T__26)
-                self.state = 392
-                self.match(RelayParser.T__9)
-                self.state = 393
+                self.state = 414
+                self.match(RelayParser.T__25)
+                self.state = 415
+                self.match(RelayParser.T__7)
+                self.state = 416
                 self.shapeList()
-                self.state = 394
+                self.state = 417
                 self.match(RelayParser.T__4)
-                self.state = 395
+                self.state = 418
                 self.typeExpr()
-                self.state = 396
-                self.match(RelayParser.T__10)
+                self.state = 419
+                self.match(RelayParser.T__8)
                 pass
 
             elif la_ == 7:
                 localctx = RelayParser.FuncTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 7)
-                self.state = 398
+                self.state = 421
                 self.match(RelayParser.T__17)
-                self.state = 400
+                self.state = 423
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if _la==RelayParser.T__9:
-                    self.state = 399
+                if _la==RelayParser.T__7:
+                    self.state = 422
                     self.typeParamList()
 
 
-                self.state = 402
+                self.state = 425
                 self.match(RelayParser.T__5)
-                self.state = 411
+                self.state = 434
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__3) | (1 << RelayParser.T__5) | (1 << RelayParser.T__17) | (1 << RelayParser.T__26) | (1 << RelayParser.CNAME))) != 0):
-                    self.state = 403
+                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__3) | (1 << RelayParser.T__5) | (1 << RelayParser.T__17) | (1 << RelayParser.T__25) | (1 << RelayParser.CNAME))) != 0):
+                    self.state = 426
                     self.typeExpr()
-                    self.state = 408
+                    self.state = 431
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
                     while _la==RelayParser.T__4:
-                        self.state = 404
+                        self.state = 427
                         self.match(RelayParser.T__4)
-                        self.state = 405
+                        self.state = 428
                         self.typeExpr()
-                        self.state = 410
+                        self.state = 433
                         self._errHandler.sync(self)
                         _la = self._input.LA(1)
 
 
 
-                self.state = 413
+                self.state = 436
                 self.match(RelayParser.T__6)
-                self.state = 414
+                self.state = 437
                 self.match(RelayParser.T__18)
-                self.state = 415
+                self.state = 438
                 self.typeExpr()
                 pass
 
             elif la_ == 8:
                 localctx = RelayParser.IncompleteTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 8)
-                self.state = 416
+                self.state = 439
                 self.match(RelayParser.T__3)
                 pass
 
@@ -2919,28 +3047,28 @@ def accept(self, visitor:ParseTreeVisitor):
     def typeParamList(self):
 
         localctx = RelayParser.TypeParamListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 50, self.RULE_typeParamList)
+        self.enterRule(localctx, 54, self.RULE_typeParamList)
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 419
-            self.match(RelayParser.T__9)
-            self.state = 420
+            self.state = 442
+            self.match(RelayParser.T__7)
+            self.state = 443
             self.generalIdent()
-            self.state = 425
+            self.state = 448
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==RelayParser.T__4:
-                self.state = 421
+                self.state = 444
                 self.match(RelayParser.T__4)
-                self.state = 422
+                self.state = 445
                 self.generalIdent()
-                self.state = 427
+                self.state = 450
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 428
-            self.match(RelayParser.T__10)
+            self.state = 451
+            self.match(RelayParser.T__8)
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -2978,47 +3106,47 @@ def accept(self, visitor:ParseTreeVisitor):
     def shapeList(self):
 
         localctx = RelayParser.ShapeListContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 52, self.RULE_shapeList)
+        self.enterRule(localctx, 56, self.RULE_shapeList)
         self._la = 0 # Token type
         try:
-            self.state = 443
+            self.state = 466
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,44,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,49,self._ctx)
             if la_ == 1:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 430
+                self.state = 453
                 self.match(RelayParser.T__5)
-                self.state = 431
+                self.state = 454
                 self.match(RelayParser.T__6)
                 pass
 
             elif la_ == 2:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 432
+                self.state = 455
                 self.match(RelayParser.T__5)
-                self.state = 433
+                self.state = 456
                 self.shape()
-                self.state = 436 
+                self.state = 459 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while True:
-                    self.state = 434
+                    self.state = 457
                     self.match(RelayParser.T__4)
-                    self.state = 435
+                    self.state = 458
                     self.shape()
-                    self.state = 438 
+                    self.state = 461 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
                     if not (_la==RelayParser.T__4):
                         break
 
-                self.state = 440
+                self.state = 463
                 self.match(RelayParser.T__6)
                 pass
 
             elif la_ == 3:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 442
+                self.state = 465
                 self.shape()
                 pass
 
@@ -3059,23 +3187,23 @@ def accept(self, visitor:ParseTreeVisitor):
     def meta(self):
 
         localctx = RelayParser.MetaContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 54, self.RULE_meta)
+        self.enterRule(localctx, 58, self.RULE_meta)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 445
-            self.match(RelayParser.T__27)
-            self.state = 446
-            self.match(RelayParser.T__9)
-            self.state = 447
+            self.state = 468
+            self.match(RelayParser.T__26)
+            self.state = 469
+            self.match(RelayParser.T__7)
+            self.state = 470
             self.match(RelayParser.CNAME)
-            self.state = 448
-            self.match(RelayParser.T__10)
-            self.state = 449
-            self.match(RelayParser.T__9)
-            self.state = 450
+            self.state = 471
+            self.match(RelayParser.T__8)
+            self.state = 472
+            self.match(RelayParser.T__7)
+            self.state = 473
             self.match(RelayParser.NAT)
-            self.state = 451
-            self.match(RelayParser.T__10)
+            self.state = 474
+            self.match(RelayParser.T__8)
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -3155,31 +3283,31 @@ def accept(self, visitor:ParseTreeVisitor):
     def shape(self):
 
         localctx = RelayParser.ShapeContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 56, self.RULE_shape)
+        self.enterRule(localctx, 60, self.RULE_shape)
         try:
-            self.state = 459
+            self.state = 482
             self._errHandler.sync(self)
             token = self._input.LA(1)
-            if token in [RelayParser.T__27]:
+            if token in [RelayParser.T__26]:
                 localctx = RelayParser.MetaShapeContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 453
+                self.state = 476
                 self.meta()
                 pass
             elif token in [RelayParser.T__5]:
                 localctx = RelayParser.ParensShapeContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 454
+                self.state = 477
                 self.match(RelayParser.T__5)
-                self.state = 455
+                self.state = 478
                 self.shape()
-                self.state = 456
+                self.state = 479
                 self.match(RelayParser.T__6)
                 pass
             elif token in [RelayParser.NAT]:
                 localctx = RelayParser.IntShapeContext(self, localctx)
                 self.enterOuterAlt(localctx, 3)
-                self.state = 458
+                self.state = 481
                 self.match(RelayParser.NAT)
                 pass
             else:
@@ -3219,15 +3347,15 @@ def accept(self, visitor:ParseTreeVisitor):
     def body(self):
 
         localctx = RelayParser.BodyContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 58, self.RULE_body)
+        self.enterRule(localctx, 62, self.RULE_body)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 461
-            self.match(RelayParser.T__7)
-            self.state = 462
+            self.state = 484
+            self.match(RelayParser.T__11)
+            self.state = 485
             self.expr(0)
-            self.state = 463
-            self.match(RelayParser.T__8)
+            self.state = 486
+            self.match(RelayParser.T__12)
         except RecognitionException as re:
             localctx.exception = re
             self._errHandler.reportError(self, re)
@@ -3305,27 +3433,27 @@ def accept(self, visitor:ParseTreeVisitor):
     def scalar(self):
 
         localctx = RelayParser.ScalarContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 60, self.RULE_scalar)
+        self.enterRule(localctx, 64, self.RULE_scalar)
         try:
-            self.state = 468
+            self.state = 491
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [RelayParser.FLOAT]:
                 localctx = RelayParser.ScalarFloatContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 465
+                self.state = 488
                 self.match(RelayParser.FLOAT)
                 pass
             elif token in [RelayParser.NAT]:
                 localctx = RelayParser.ScalarIntContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 466
+                self.state = 489
                 self.match(RelayParser.NAT)
                 pass
             elif token in [RelayParser.BOOL_LIT]:
                 localctx = RelayParser.ScalarBoolContext(self, localctx)
                 self.enterOuterAlt(localctx, 3)
-                self.state = 467
+                self.state = 490
                 self.match(RelayParser.BOOL_LIT)
                 pass
             else:
@@ -3377,32 +3505,32 @@ def accept(self, visitor:ParseTreeVisitor):
     def ident(self):
 
         localctx = RelayParser.IdentContext(self, self._ctx, self.state)
-        self.enterRule(localctx, 62, self.RULE_ident)
+        self.enterRule(localctx, 66, self.RULE_ident)
         try:
-            self.state = 474
+            self.state = 497
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,47,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,52,self._ctx)
             if la_ == 1:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 470
+                self.state = 493
                 self.generalIdent()
                 pass
 
             elif la_ == 2:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 471
+                self.state = 494
                 self.globalVar()
                 pass
 
             elif la_ == 3:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 472
+                self.state = 495
                 self.localVar()
                 pass
 
             elif la_ == 4:
                 self.enterOuterAlt(localctx, 4)
-                self.state = 473
+                self.state = 496
                 self.graphVar()
                 pass
 
diff --git a/python/tvm/relay/grammar/py3/RelayVisitor.py b/python/tvm/relay/grammar/py3/RelayVisitor.py
index 02dc8eebfda2..0488e2a46596 100644
--- a/python/tvm/relay/grammar/py3/RelayVisitor.py
+++ b/python/tvm/relay/grammar/py3/RelayVisitor.py
@@ -149,11 +149,21 @@ def visitConstructorName(self, ctx:RelayParser.ConstructorNameContext):
         return self.visitChildren(ctx)
 
 
+    # Visit a parse tree produced by RelayParser#adtConsDefnList.
+    def visitAdtConsDefnList(self, ctx:RelayParser.AdtConsDefnListContext):
+        return self.visitChildren(ctx)
+
+
     # Visit a parse tree produced by RelayParser#adtConsDefn.
     def visitAdtConsDefn(self, ctx:RelayParser.AdtConsDefnContext):
         return self.visitChildren(ctx)
 
 
+    # Visit a parse tree produced by RelayParser#matchClauseList.
+    def visitMatchClauseList(self, ctx:RelayParser.MatchClauseListContext):
+        return self.visitChildren(ctx)
+
+
     # Visit a parse tree produced by RelayParser#matchClause.
     def visitMatchClause(self, ctx:RelayParser.MatchClauseContext):
         return self.visitChildren(ctx)
diff --git a/src/relay/ir/alpha_equal.cc b/src/relay/ir/alpha_equal.cc
index 572da77850c8..6e8b28e46dc2 100644
--- a/src/relay/ir/alpha_equal.cc
+++ b/src/relay/ir/alpha_equal.cc
@@ -218,7 +218,7 @@ class AlphaEqualHandler:
   bool VisitType_(const TypeVarNode* lhs, const Type& other) final {
     if (const TypeVarNode* rhs = other.as<TypeVarNode>()) {
       if (lhs->kind != rhs->kind) return false;
-      return lhs->var->name_hint == rhs->var->name_hint;
+      return LeafNodeEqual(GetRef<NodeRef>(lhs), other);
     } else {
       return false;
     }
@@ -291,11 +291,7 @@ class AlphaEqualHandler:
   }
 
   bool VisitType_(const GlobalTypeVarNode* lhs, const Type& other) final {
-    if (const GlobalTypeVarNode* rhs = other.as<GlobalTypeVarNode>()) {
-      // use name equality for global var for now.
-      return lhs->var->name_hint == rhs->var->name_hint;
-    }
-    return false;
+    return LeafNodeEqual(GetRef<NodeRef>(lhs), other);
   }
 
   bool VisitType_(const TypeCallNode* lhs, const Type& other) final {
@@ -316,7 +312,8 @@ class AlphaEqualHandler:
 
   bool VisitType_(const TypeDataNode* lhs, const Type& other) final {
     const TypeDataNode* rhs = other.as<TypeDataNode>();
-    if (rhs == nullptr || lhs->type_vars.size() != rhs->type_vars.size()
+    if (rhs == nullptr
+        || lhs->type_vars.size() != rhs->type_vars.size()
         || !TypeEqual(lhs->header, rhs->header)) {
       return false;
     }
@@ -599,15 +596,15 @@ TVM_REGISTER_API("relay._make._assert_alpha_equal")
   CHECK(alpha_equal) << AsText(a, true) << " and " << AsText(b, true) << " are not alpha equal";
 });
 
-TVM_REGISTER_API("relay._make._graph_equal")
+TVM_REGISTER_API("relay._make._is_unifiable")
 .set_body_typed<bool(NodeRef, NodeRef)>([](NodeRef a, NodeRef b) {
   return AlphaEqualHandler(true, false).Equal(a, b);
 });
 
-TVM_REGISTER_API("relay._make._assert_graph_equal")
+TVM_REGISTER_API("relay._make._assert_is_unifiable")
 .set_body_typed<void(NodeRef, NodeRef)>([](NodeRef a, NodeRef b) {
-  bool graph_equal = AlphaEqualHandler(true, true).Equal(a, b);
-  CHECK(graph_equal) << AsText(a, true) << " and " << AsText(b, true) << " are not graph equal";
+  bool is_unifiable = AlphaEqualHandler(true, true).Equal(a, b);
+  CHECK(is_unifiable) << AsText(a, true) << " and " << AsText(b, true) << " are not graph equal";
 });
 
 }  // namespace relay
diff --git a/src/relay/ir/pretty_printer.cc b/src/relay/ir/pretty_printer.cc
index 97e33e6b67c2..d327f17aeb29 100644
--- a/src/relay/ir/pretty_printer.cc
+++ b/src/relay/ir/pretty_printer.cc
@@ -44,6 +44,8 @@
 namespace tvm {
 namespace relay {
 
+static const char* kSemVer = "v0.0.4";
+
 Doc Brace(const Doc& d,
           const std::string& open = "{",
           const std::string& close = "}",
@@ -599,15 +601,20 @@ class PrettyPrinter :
       doc << "?";
     }
     doc << " (" << Print(op->data) << ") {";
-    std::vector<Doc> clauses;
+    std::vector<Doc> clause_docs;
     for (const auto& clause : op->clauses) {
       Doc clause_doc;
-      clause_doc << "| " << PrintPattern(clause->lhs, false) << " => "
-                 << PrintExpr(clause->rhs, false, true);
-      clauses.push_back(clause_doc);
+      clause_doc << PrintPattern(clause->lhs, false) << " => ";
+      Doc rhs_doc = PrintExpr(clause->rhs, false, true);
+      if (clause->rhs.as<LetNode>()) {
+        // only add braces if there are multiple lines on the rhs
+        rhs_doc = Brace(rhs_doc);
+      }
+      clause_doc << rhs_doc << ",";
+      clause_docs.push_back(clause_doc);
     }
-    doc << Indent(2, body << PrintNewLine() << PrintSep(clauses, PrintNewLine())) << PrintNewLine();
-    doc << "}";
+    doc << Indent(2, body << PrintNewLine() << PrintSep(clause_docs, PrintNewLine()))
+        << PrintNewLine() << "}";
     return doc;
   }
 
@@ -758,7 +765,7 @@ class PrettyPrinter :
     Doc doc;
     doc << "type " << Print(node->header);
 
-    // type args
+    // type vars
     if (node->type_vars.size() != 0) {
       doc << "[";
       std::vector<Doc> type_vars;
@@ -767,12 +774,15 @@ class PrettyPrinter :
       }
       doc << PrintSep(type_vars) << "]";
     }
-    doc << " =";
+    doc << " ";
 
+    std::vector<Doc> constructor_docs;
     for (Constructor constructor : node->constructors) {
-      doc << PrintNewLine() << "  | "
-          << Print(constructor, /* meta */ false, /* try_inline */ true);
+      constructor_docs.push_back(Print(constructor, /* meta */ false, /* try_inline */ true));
     }
+    Doc separator;
+    separator << "," << PrintNewLine();
+    doc << Brace(PrintSep(constructor_docs, separator) << ",");
 
     return doc;
   }
@@ -945,7 +955,7 @@ std::string PrettyPrint_(const NodeRef& node,
                          bool show_meta_data,
                          runtime::TypedPackedFunc<std::string(Expr)> annotate) {
   Doc doc;
-  doc << "v0.0.3" << PrintNewLine()
+  doc << kSemVer << PrintNewLine()
       << PrettyPrinter(show_meta_data, annotate).PrintFinal(node);
   return doc.str();
 }
diff --git a/tests/python/relay/test_ir_parser.py b/tests/python/relay/test_ir_parser.py
index 23bcedf3dd38..f924137645d4 100644
--- a/tests/python/relay/test_ir_parser.py
+++ b/tests/python/relay/test_ir_parser.py
@@ -16,14 +16,14 @@
 # under the License.
 import tvm
 from tvm import relay
-from tvm.relay.analysis import alpha_equal, assert_alpha_equal
+from tvm.relay.analysis import is_unifiable, assert_is_unifiable
 from nose.tools import nottest, raises
 from numpy import isclose
 from typing import Union
 from functools import wraps
 raises_parse_error = raises(tvm._ffi.base.TVMError)
 
-SEMVER = "v0.0.3"
+SEMVER = "v0.0.4"
 
 BINARY_OPS = {
     "*": relay.multiply,
@@ -60,9 +60,16 @@
     "float16x4",
 }
 
+LIST_DEFN = """
+type List[A] {
+    Cons(A, List[A]),
+    Nil,
+}
+"""
+
 def roundtrip(expr):
     x = relay.fromtext(str(expr))
-    assert_alpha_equal(x, expr)
+    assert_is_unifiable(x, expr)
 
 
 def parse_text(code):
@@ -74,7 +81,7 @@ def parse_text(code):
 def parses_as(code, expr):
     # type: (str, relay.Expr) -> bool
     parsed = parse_text(code)
-    result = alpha_equal(parsed, expr)
+    result = is_unifiable(parsed, expr)
     return result
 
 def get_scalar(x):
@@ -170,13 +177,13 @@ def test_bin_op():
 
 
 def test_parens():
-    assert alpha_equal(parse_text("1 * 1 + 1"), parse_text("(1 * 1) + 1"))
-    assert not alpha_equal(parse_text("1 * 1 + 1"), parse_text("1 * (1 + 1)"))
+    assert is_unifiable(parse_text("1 * 1 + 1"), parse_text("(1 * 1) + 1"))
+    assert not is_unifiable(parse_text("1 * 1 + 1"), parse_text("1 * (1 + 1)"))
 
 
 def test_op_assoc():
-    assert alpha_equal(parse_text("1 * 1 + 1 < 1 == 1"), parse_text("(((1 * 1) + 1) < 1) == 1"))
-    assert alpha_equal(parse_text("1 == 1 < 1 + 1 * 1"), parse_text("1 == (1 < (1 + (1 * 1)))"))
+    assert is_unifiable(parse_text("1 * 1 + 1 < 1 == 1"), parse_text("(((1 * 1) + 1) < 1) == 1"))
+    assert is_unifiable(parse_text("1 == 1 < 1 + 1 * 1"), parse_text("1 == (1 < (1 + (1 * 1)))"))
 
 
 @nottest
@@ -241,7 +248,7 @@ def test_seq():
     )
 
     assert parses_as(
-        "let %_ = { 1 }; ()",
+        "let %_ = 1; ()",
         relay.Let(
             X,
             relay.const(1),
@@ -646,8 +653,7 @@ def test_adt_defn():
     mod[glob_typ_var] = prog
     assert parses_as(
         """
-        type Ayy =
-          | Nil
+        type Ayy { Nil }
         """,
         mod
     )
@@ -666,14 +672,7 @@ def test_multiple_cons_defn():
                 relay.Constructor("Nil", [], list_var),
             ])
     mod[list_var] = prog
-    assert parses_as(
-        """
-        type List[A] =
-          | Cons(A, List[A])
-          | Nil
-        """,
-        mod
-    )
+    assert parses_as(LIST_DEFN, mod)
 
 
 def test_multiple_type_param_defn():
@@ -691,9 +690,10 @@ def test_multiple_type_param_defn():
     mod[glob_typ_var] = prog
     assert parses_as(
         """
-        type Either[A, B] =
-          | Left(A)
-          | Right(B)
+        type Either[A, B] {
+          Left(A),
+          Right(B),
+        }
         """,
         mod
     )
@@ -721,13 +721,16 @@ def test_match():
         input_type = list_var(typ_var)
         input_var = relay.Var("xs", input_type)
         rest_var = relay.Var("rest")
+        cons_case = relay.Let(
+            _,
+            UNIT,
+            relay.add(relay.const(1), relay.Call(length_var, [rest_var])))
         body = relay.Match(input_var,
             [relay.Clause(
                 relay.PatternConstructor(
                     cons_constructor,
                     [relay.PatternWildcard(), relay.PatternVar(rest_var)]),
-                relay.add(relay.const(1), relay.Call(length_var, [rest_var]))
-                ),
+                cons_case),
             relay.Clause(
                 relay.PatternConstructor(nil_constructor, []),
                 relay.const(0))],
@@ -743,17 +746,18 @@ def test_match():
 
         assert parses_as(
             """
-            type List[A] =
-            | Cons(A, List[A])
-            | Nil
+            %s
 
             def @length[A](%%xs: List[A]) -> int32 {
-            %s (%%xs) {
-                | Cons(_, %%rest) => 1 + @length(%%rest)
-                | Nil => 0
+              %s (%%xs) {
+                Cons(_, %%rest) => {
+                  ();;
+                  1 + @length(%%rest)
+                },
+                Nil => 0,
+              }
             }
-            }
-            """ % match_keyword,
+            """ % (LIST_DEFN, match_keyword),
             mod
         )
 
@@ -783,14 +787,12 @@ def test_adt_cons_expr():
 
     assert parses_as(
         """
-        type List[A] =
-          | Cons(A, List[A])
-          | Nil
+        %s
 
-        def @make_singleton(%x: int32) -> List[int32] {
-          Cons(%x, Nil())
+        def @make_singleton(%%x: int32) -> List[int32] {
+          Cons(%%x, Nil())
         }
-        """,
+        """ % LIST_DEFN,
         mod
     )
 
@@ -798,14 +800,13 @@ def @make_singleton(%x: int32) -> List[int32] {
 def test_duplicate_adt_defn():
     parse_text(
         """
-        type List[A] =
-          | Cons(A, List[A])
-          | Nil
+        %s
 
-        type List[A] =
-          | Cons(A, List[A])
-          | Nil
-        """
+        type List[A] {
+          Cons(A, List[A]),
+          Nil,
+        }
+        """ % LIST_DEFN
     )
 
 
@@ -813,11 +814,8 @@ def test_duplicate_adt_defn():
 def test_duplicate_adt_cons():
     parse_text(
         """
-        type Ayy =
-          | Lmao
-
-        type Haha =
-          | Lmao
+        type Ayy { Lmao }
+        type Haha { Lmao }
         """
     )
 
@@ -826,11 +824,8 @@ def test_duplicate_adt_cons():
 def test_duplicate_adt_cons_defn():
     parse_text(
         """
-        type Ayy =
-          | Lmao
-
-        type Lmao =
-          | Ayy
+        type Ayy { Lmao }
+        type Lmao { Ayy }
         """
     )
 

From 947a0492cf969581feac577aae4cf1dd0cab08db Mon Sep 17 00:00:00 2001
From: Logan Weber <weberlo@cs.washington.edu>
Date: Tue, 3 Sep 2019 13:12:39 -0700
Subject: [PATCH 23/29] Lil fix

---
 tests/python/relay/test_ir_text_printer.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/python/relay/test_ir_text_printer.py b/tests/python/relay/test_ir_text_printer.py
index a45273854985..6b64ef9b48d4 100644
--- a/tests/python/relay/test_ir_text_printer.py
+++ b/tests/python/relay/test_ir_text_printer.py
@@ -216,7 +216,7 @@ def test_let_inlining():
 
 def test_zeros():
     x = relay.op.zeros([], "float32")
-    show(astext(x))
+    astext(x)
 
 if __name__ == "__main__":
     do_print[0] = True

From e85433fc5920eb1c9943d2ec88d520e89dc1e7bc Mon Sep 17 00:00:00 2001
From: Logan Weber <weberlo@cs.washington.edu>
Date: Tue, 3 Sep 2019 17:03:21 -0700
Subject: [PATCH 24/29] Add dummy `extern type` handler

---
 python/tvm/relay/_parser.py                  |  27 +-
 python/tvm/relay/grammar/Relay.g4            |   1 +
 python/tvm/relay/grammar/py3/RelayLexer.py   | 340 +++----
 python/tvm/relay/grammar/py3/RelayParser.py  | 935 ++++++++++---------
 python/tvm/relay/grammar/py3/RelayVisitor.py |   5 +
 src/relay/ir/pretty_printer.cc               |   9 +-
 tests/python/relay/test_ir_parser.py         |  32 +
 7 files changed, 727 insertions(+), 622 deletions(-)

diff --git a/python/tvm/relay/_parser.py b/python/tvm/relay/_parser.py
index f21e367f39e3..8a969e95081e 100644
--- a/python/tvm/relay/_parser.py
+++ b/python/tvm/relay/_parser.py
@@ -500,11 +500,12 @@ def visitFuncDefn(self, ctx: RelayParser.DefnContext) -> None:
         ident = self.mk_global_var(ident_name)
         self.module[ident] = self.mk_func(ctx)
 
-    def visitAdtDefn(self, ctx: RelayParser.AdtDefnContext):
+    def handle_adt_header(
+            self,
+            ctx: Union[RelayParser.ExternAdtDefnContext, RelayParser.AdtDefnContext]):
+        """Handles parsing of the name and type params of an ADT definition."""
         adt_name = ctx.generalIdent().getText()
-        adt_handle = self.mk_global_typ_var(adt_name, ty.Kind.AdtHandle)
-        self.enter_type_param_scope()
-
+        adt_var = self.mk_global_typ_var(adt_name, ty.Kind.AdtHandle)
         # parse type params
         type_params = ctx.typeParamList()
         if type_params is None:
@@ -512,7 +513,19 @@ def visitAdtDefn(self, ctx: RelayParser.AdtDefnContext):
         else:
             type_params = [self.mk_typ(type_ident.getText(), ty.Kind.Type)
                            for type_ident in type_params.generalIdent()]
+        return adt_var, type_params
+
+    def visitExternAdtDefn(self, ctx: RelayParser.ExternAdtDefnContext):
+        # TODO(weberlo): update this handler once extern is implemented
+        self.enter_type_param_scope()
+        adt_var, type_params = self.handle_adt_header(ctx)
+        # update module being built
+        self.module[adt_var] = adt.TypeData(adt_var, type_params, [])
+        self.exit_type_param_scope()
 
+    def visitAdtDefn(self, ctx: RelayParser.AdtDefnContext):
+        self.enter_type_param_scope()
+        adt_var, type_params = self.handle_adt_header(ctx)
         # parse constructors
         adt_cons_defns = ctx.adtConsDefnList()
         if adt_cons_defns is None:
@@ -523,13 +536,11 @@ def visitAdtDefn(self, ctx: RelayParser.AdtDefnContext):
         for cons_defn in adt_cons_defns:
             inputs = [self.visit(inp) for inp in cons_defn.typeExpr()]
             cons_defn_name = cons_defn.constructorName().getText()
-            cons_defn = adt.Constructor(cons_defn_name, inputs, adt_handle)
+            cons_defn = adt.Constructor(cons_defn_name, inputs, adt_var)
             self.mk_global_typ_cons(cons_defn_name, cons_defn)
             parsed_constructors.append(cons_defn)
-
         # update module being built
-        self.module[adt_handle] = adt.TypeData(adt_handle, type_params, parsed_constructors)
-
+        self.module[adt_var] = adt.TypeData(adt_var, type_params, parsed_constructors)
         self.exit_type_param_scope()
 
     def visitMatch(self, ctx: RelayParser.MatchContext):
diff --git a/python/tvm/relay/grammar/Relay.g4 b/python/tvm/relay/grammar/Relay.g4
index 158df639eb9a..b3269fb113fd 100644
--- a/python/tvm/relay/grammar/Relay.g4
+++ b/python/tvm/relay/grammar/Relay.g4
@@ -119,6 +119,7 @@ expr
 func: 'fn' typeParamList? '(' argList ')' ('->' typeExpr)? body ;
 defn
   : 'def' globalVar typeParamList? '(' argList ')' ('->' typeExpr)? body  # funcDefn
+  | 'extern' 'type' generalIdent typeParamList?                           # externAdtDefn
   | 'type' generalIdent typeParamList? '{' adtConsDefnList? '}'           # adtDefn
   ;
 
diff --git a/python/tvm/relay/grammar/py3/RelayLexer.py b/python/tvm/relay/grammar/py3/RelayLexer.py
index bd4617852e30..76e988b45418 100644
--- a/python/tvm/relay/grammar/py3/RelayLexer.py
+++ b/python/tvm/relay/grammar/py3/RelayLexer.py
@@ -8,8 +8,8 @@
 
 def serializedATN():
     with StringIO() as buf:
-        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\61")
-        buf.write("\u0158\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7")
+        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\62")
+        buf.write("\u0161\b\1\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7")
         buf.write("\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r")
         buf.write("\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23")
         buf.write("\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30")
@@ -17,144 +17,148 @@ def serializedATN():
         buf.write("\t\36\4\37\t\37\4 \t \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%")
         buf.write("\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4,\t,\4-\t-\4.")
         buf.write("\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64")
-        buf.write("\t\64\4\65\t\65\3\2\3\2\3\3\3\3\3\4\3\4\3\5\3\5\3\6\3")
-        buf.write("\6\3\7\3\7\3\b\3\b\3\t\3\t\3\n\3\n\3\13\3\13\3\13\3\f")
-        buf.write("\3\f\3\f\3\f\3\f\3\r\3\r\3\16\3\16\3\17\3\17\3\17\3\17")
-        buf.write("\3\20\3\20\3\21\3\21\3\22\3\22\3\22\3\23\3\23\3\23\3\24")
-        buf.write("\3\24\3\24\3\25\3\25\3\25\3\25\3\26\3\26\3\26\3\26\3\26")
-        buf.write("\3\27\3\27\3\27\3\30\3\30\3\30\3\30\3\30\3\30\3\31\3\31")
-        buf.write("\3\31\3\31\3\31\3\31\3\31\3\32\3\32\3\33\3\33\3\33\3\33")
-        buf.write("\3\33\3\33\3\33\3\34\3\34\3\34\3\34\3\34\3\35\3\35\3\35")
-        buf.write("\3\35\3\35\3\35\3\35\3\36\3\36\3\36\3\36\3\36\7\36\u00ce")
-        buf.write("\n\36\f\36\16\36\u00d1\13\36\3\36\3\36\3\36\3\36\3\36")
-        buf.write("\3\37\6\37\u00d9\n\37\r\37\16\37\u00da\3\37\3\37\3 \3")
-        buf.write(" \3 \3 \7 \u00e3\n \f \16 \u00e6\13 \3 \3 \3 \3 \3!\3")
-        buf.write("!\3!\3\"\3\"\3\"\7\"\u00f2\n\"\f\"\16\"\u00f5\13\"\3\"")
-        buf.write("\3\"\3#\3#\3$\3$\3%\3%\3&\3&\3\'\3\'\3(\3(\3)\3)\3)\3")
-        buf.write("*\3*\3*\3+\3+\3+\3,\3,\3,\3-\3-\3-\3-\3-\3-\3-\3-\3-\5")
-        buf.write("-\u011a\n-\3.\3.\5.\u011e\n.\3.\3.\3.\7.\u0123\n.\f.\16")
-        buf.write(".\u0126\13.\3.\3.\7.\u012a\n.\f.\16.\u012d\13.\3/\3/\3")
-        buf.write("/\5/\u0132\n/\3/\5/\u0135\n/\3\60\3\60\3\60\3\61\6\61")
-        buf.write("\u013b\n\61\r\61\16\61\u013c\3\62\3\62\5\62\u0141\n\62")
-        buf.write("\3\62\3\62\3\63\3\63\3\64\3\64\3\65\3\65\3\65\3\65\3\65")
-        buf.write("\3\65\3\65\3\65\3\65\3\65\3\65\7\65\u0154\n\65\f\65\16")
-        buf.write("\65\u0157\13\65\5\u00cf\u00e4\u00f3\2\66\3\3\5\4\7\5\t")
-        buf.write("\6\13\7\r\b\17\t\21\n\23\13\25\f\27\r\31\16\33\17\35\20")
-        buf.write("\37\21!\22#\23%\24\'\25)\26+\27-\30/\31\61\32\63\33\65")
-        buf.write("\34\67\359\36;\37= ?!A\2C\"E#G$I%K&M\'O(Q)S*U+W,Y-[.]")
-        buf.write("\2_/a\60c\2e\2g\2i\61\3\2\b\5\2\13\f\17\17\"\"\4\2\f\f")
-        buf.write("\17\17\4\2GGgg\4\2--//\4\2C\\c|\3\2\62;\2\u0163\2\3\3")
-        buf.write("\2\2\2\2\5\3\2\2\2\2\7\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2")
-        buf.write("\2\2\r\3\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2\2")
-        buf.write("\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2\2")
-        buf.write("\35\3\2\2\2\2\37\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2%\3\2")
-        buf.write("\2\2\2\'\3\2\2\2\2)\3\2\2\2\2+\3\2\2\2\2-\3\2\2\2\2/\3")
-        buf.write("\2\2\2\2\61\3\2\2\2\2\63\3\2\2\2\2\65\3\2\2\2\2\67\3\2")
-        buf.write("\2\2\29\3\2\2\2\2;\3\2\2\2\2=\3\2\2\2\2?\3\2\2\2\2C\3")
-        buf.write("\2\2\2\2E\3\2\2\2\2G\3\2\2\2\2I\3\2\2\2\2K\3\2\2\2\2M")
-        buf.write("\3\2\2\2\2O\3\2\2\2\2Q\3\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2")
-        buf.write("W\3\2\2\2\2Y\3\2\2\2\2[\3\2\2\2\2_\3\2\2\2\2a\3\2\2\2")
-        buf.write("\2i\3\2\2\2\3k\3\2\2\2\5m\3\2\2\2\7o\3\2\2\2\tq\3\2\2")
-        buf.write("\2\13s\3\2\2\2\ru\3\2\2\2\17w\3\2\2\2\21y\3\2\2\2\23{")
-        buf.write("\3\2\2\2\25}\3\2\2\2\27\u0080\3\2\2\2\31\u0085\3\2\2\2")
-        buf.write("\33\u0087\3\2\2\2\35\u0089\3\2\2\2\37\u008d\3\2\2\2!\u008f")
-        buf.write("\3\2\2\2#\u0091\3\2\2\2%\u0094\3\2\2\2\'\u0097\3\2\2\2")
-        buf.write(")\u009a\3\2\2\2+\u009e\3\2\2\2-\u00a3\3\2\2\2/\u00a6\3")
-        buf.write("\2\2\2\61\u00ac\3\2\2\2\63\u00b3\3\2\2\2\65\u00b5\3\2")
-        buf.write("\2\2\67\u00bc\3\2\2\29\u00c1\3\2\2\2;\u00c8\3\2\2\2=\u00d8")
-        buf.write("\3\2\2\2?\u00de\3\2\2\2A\u00eb\3\2\2\2C\u00ee\3\2\2\2")
-        buf.write("E\u00f8\3\2\2\2G\u00fa\3\2\2\2I\u00fc\3\2\2\2K\u00fe\3")
-        buf.write("\2\2\2M\u0100\3\2\2\2O\u0102\3\2\2\2Q\u0104\3\2\2\2S\u0107")
-        buf.write("\3\2\2\2U\u010a\3\2\2\2W\u010d\3\2\2\2Y\u0119\3\2\2\2")
-        buf.write("[\u011d\3\2\2\2]\u012e\3\2\2\2_\u0136\3\2\2\2a\u013a\3")
-        buf.write("\2\2\2c\u013e\3\2\2\2e\u0144\3\2\2\2g\u0146\3\2\2\2i\u0148")
-        buf.write("\3\2\2\2kl\7\60\2\2l\4\3\2\2\2mn\7B\2\2n\6\3\2\2\2op\7")
-        buf.write("\'\2\2p\b\3\2\2\2qr\7a\2\2r\n\3\2\2\2st\7.\2\2t\f\3\2")
-        buf.write("\2\2uv\7*\2\2v\16\3\2\2\2wx\7+\2\2x\20\3\2\2\2yz\7]\2")
-        buf.write("\2z\22\3\2\2\2{|\7_\2\2|\24\3\2\2\2}~\7k\2\2~\177\7h\2")
-        buf.write("\2\177\26\3\2\2\2\u0080\u0081\7g\2\2\u0081\u0082\7n\2")
-        buf.write("\2\u0082\u0083\7u\2\2\u0083\u0084\7g\2\2\u0084\30\3\2")
-        buf.write("\2\2\u0085\u0086\7}\2\2\u0086\32\3\2\2\2\u0087\u0088\7")
-        buf.write("\177\2\2\u0088\34\3\2\2\2\u0089\u008a\7n\2\2\u008a\u008b")
-        buf.write("\7g\2\2\u008b\u008c\7v\2\2\u008c\36\3\2\2\2\u008d\u008e")
-        buf.write("\7?\2\2\u008e \3\2\2\2\u008f\u0090\7=\2\2\u0090\"\3\2")
-        buf.write("\2\2\u0091\u0092\7=\2\2\u0092\u0093\7=\2\2\u0093$\3\2")
-        buf.write("\2\2\u0094\u0095\7h\2\2\u0095\u0096\7p\2\2\u0096&\3\2")
-        buf.write("\2\2\u0097\u0098\7/\2\2\u0098\u0099\7@\2\2\u0099(\3\2")
-        buf.write("\2\2\u009a\u009b\7f\2\2\u009b\u009c\7g\2\2\u009c\u009d")
-        buf.write("\7h\2\2\u009d*\3\2\2\2\u009e\u009f\7v\2\2\u009f\u00a0")
-        buf.write("\7{\2\2\u00a0\u00a1\7r\2\2\u00a1\u00a2\7g\2\2\u00a2,\3")
-        buf.write("\2\2\2\u00a3\u00a4\7?\2\2\u00a4\u00a5\7@\2\2\u00a5.\3")
-        buf.write("\2\2\2\u00a6\u00a7\7o\2\2\u00a7\u00a8\7c\2\2\u00a8\u00a9")
-        buf.write("\7v\2\2\u00a9\u00aa\7e\2\2\u00aa\u00ab\7j\2\2\u00ab\60")
-        buf.write("\3\2\2\2\u00ac\u00ad\7o\2\2\u00ad\u00ae\7c\2\2\u00ae\u00af")
-        buf.write("\7v\2\2\u00af\u00b0\7e\2\2\u00b0\u00b1\7j\2\2\u00b1\u00b2")
-        buf.write("\7A\2\2\u00b2\62\3\2\2\2\u00b3\u00b4\7<\2\2\u00b4\64\3")
-        buf.write("\2\2\2\u00b5\u00b6\7V\2\2\u00b6\u00b7\7g\2\2\u00b7\u00b8")
-        buf.write("\7p\2\2\u00b8\u00b9\7u\2\2\u00b9\u00ba\7q\2\2\u00ba\u00bb")
-        buf.write("\7t\2\2\u00bb\66\3\2\2\2\u00bc\u00bd\7o\2\2\u00bd\u00be")
-        buf.write("\7g\2\2\u00be\u00bf\7v\2\2\u00bf\u00c0\7c\2\2\u00c08\3")
-        buf.write("\2\2\2\u00c1\u00c2\7x\2\2\u00c2\u00c3\7\62\2\2\u00c3\u00c4")
-        buf.write("\7\60\2\2\u00c4\u00c5\7\62\2\2\u00c5\u00c6\7\60\2\2\u00c6")
-        buf.write("\u00c7\7\66\2\2\u00c7:\3\2\2\2\u00c8\u00c9\7\61\2\2\u00c9")
-        buf.write("\u00ca\7,\2\2\u00ca\u00cf\3\2\2\2\u00cb\u00ce\5;\36\2")
-        buf.write("\u00cc\u00ce\13\2\2\2\u00cd\u00cb\3\2\2\2\u00cd\u00cc")
-        buf.write("\3\2\2\2\u00ce\u00d1\3\2\2\2\u00cf\u00d0\3\2\2\2\u00cf")
-        buf.write("\u00cd\3\2\2\2\u00d0\u00d2\3\2\2\2\u00d1\u00cf\3\2\2\2")
-        buf.write("\u00d2\u00d3\7,\2\2\u00d3\u00d4\7\61\2\2\u00d4\u00d5\3")
-        buf.write("\2\2\2\u00d5\u00d6\b\36\2\2\u00d6<\3\2\2\2\u00d7\u00d9")
-        buf.write("\t\2\2\2\u00d8\u00d7\3\2\2\2\u00d9\u00da\3\2\2\2\u00da")
-        buf.write("\u00d8\3\2\2\2\u00da\u00db\3\2\2\2\u00db\u00dc\3\2\2\2")
-        buf.write("\u00dc\u00dd\b\37\2\2\u00dd>\3\2\2\2\u00de\u00df\7\61")
-        buf.write("\2\2\u00df\u00e0\7\61\2\2\u00e0\u00e4\3\2\2\2\u00e1\u00e3")
-        buf.write("\13\2\2\2\u00e2\u00e1\3\2\2\2\u00e3\u00e6\3\2\2\2\u00e4")
-        buf.write("\u00e5\3\2\2\2\u00e4\u00e2\3\2\2\2\u00e5\u00e7\3\2\2\2")
-        buf.write("\u00e6\u00e4\3\2\2\2\u00e7\u00e8\7\f\2\2\u00e8\u00e9\3")
-        buf.write("\2\2\2\u00e9\u00ea\b \2\2\u00ea@\3\2\2\2\u00eb\u00ec\7")
-        buf.write("^\2\2\u00ec\u00ed\7$\2\2\u00edB\3\2\2\2\u00ee\u00f3\7")
-        buf.write("$\2\2\u00ef\u00f2\5A!\2\u00f0\u00f2\n\3\2\2\u00f1\u00ef")
-        buf.write("\3\2\2\2\u00f1\u00f0\3\2\2\2\u00f2\u00f5\3\2\2\2\u00f3")
-        buf.write("\u00f4\3\2\2\2\u00f3\u00f1\3\2\2\2\u00f4\u00f6\3\2\2\2")
-        buf.write("\u00f5\u00f3\3\2\2\2\u00f6\u00f7\7$\2\2\u00f7D\3\2\2\2")
-        buf.write("\u00f8\u00f9\7,\2\2\u00f9F\3\2\2\2\u00fa\u00fb\7\61\2")
-        buf.write("\2\u00fbH\3\2\2\2\u00fc\u00fd\7-\2\2\u00fdJ\3\2\2\2\u00fe")
-        buf.write("\u00ff\7/\2\2\u00ffL\3\2\2\2\u0100\u0101\7>\2\2\u0101")
-        buf.write("N\3\2\2\2\u0102\u0103\7@\2\2\u0103P\3\2\2\2\u0104\u0105")
-        buf.write("\7>\2\2\u0105\u0106\7?\2\2\u0106R\3\2\2\2\u0107\u0108")
-        buf.write("\7@\2\2\u0108\u0109\7?\2\2\u0109T\3\2\2\2\u010a\u010b")
-        buf.write("\7?\2\2\u010b\u010c\7?\2\2\u010cV\3\2\2\2\u010d\u010e")
-        buf.write("\7#\2\2\u010e\u010f\7?\2\2\u010fX\3\2\2\2\u0110\u0111")
-        buf.write("\7V\2\2\u0111\u0112\7t\2\2\u0112\u0113\7w\2\2\u0113\u011a")
-        buf.write("\7g\2\2\u0114\u0115\7H\2\2\u0115\u0116\7c\2\2\u0116\u0117")
-        buf.write("\7n\2\2\u0117\u0118\7u\2\2\u0118\u011a\7g\2\2\u0119\u0110")
-        buf.write("\3\2\2\2\u0119\u0114\3\2\2\2\u011aZ\3\2\2\2\u011b\u011e")
-        buf.write("\7a\2\2\u011c\u011e\5e\63\2\u011d\u011b\3\2\2\2\u011d")
-        buf.write("\u011c\3\2\2\2\u011e\u0124\3\2\2\2\u011f\u0123\7a\2\2")
-        buf.write("\u0120\u0123\5e\63\2\u0121\u0123\5g\64\2\u0122\u011f\3")
-        buf.write("\2\2\2\u0122\u0120\3\2\2\2\u0122\u0121\3\2\2\2\u0123\u0126")
-        buf.write("\3\2\2\2\u0124\u0122\3\2\2\2\u0124\u0125\3\2\2\2\u0125")
-        buf.write("\u012b\3\2\2\2\u0126\u0124\3\2\2\2\u0127\u0128\7\60\2")
-        buf.write("\2\u0128\u012a\5[.\2\u0129\u0127\3\2\2\2\u012a\u012d\3")
-        buf.write("\2\2\2\u012b\u0129\3\2\2\2\u012b\u012c\3\2\2\2\u012c\\")
-        buf.write("\3\2\2\2\u012d\u012b\3\2\2\2\u012e\u0131\5a\61\2\u012f")
-        buf.write("\u0130\7\60\2\2\u0130\u0132\5a\61\2\u0131\u012f\3\2\2")
-        buf.write("\2\u0131\u0132\3\2\2\2\u0132\u0134\3\2\2\2\u0133\u0135")
-        buf.write("\5c\62\2\u0134\u0133\3\2\2\2\u0134\u0135\3\2\2\2\u0135")
-        buf.write("^\3\2\2\2\u0136\u0137\5]/\2\u0137\u0138\7h\2\2\u0138`")
-        buf.write("\3\2\2\2\u0139\u013b\5g\64\2\u013a\u0139\3\2\2\2\u013b")
-        buf.write("\u013c\3\2\2\2\u013c\u013a\3\2\2\2\u013c\u013d\3\2\2\2")
-        buf.write("\u013db\3\2\2\2\u013e\u0140\t\4\2\2\u013f\u0141\t\5\2")
-        buf.write("\2\u0140\u013f\3\2\2\2\u0140\u0141\3\2\2\2\u0141\u0142")
-        buf.write("\3\2\2\2\u0142\u0143\5a\61\2\u0143d\3\2\2\2\u0144\u0145")
-        buf.write("\t\6\2\2\u0145f\3\2\2\2\u0146\u0147\t\7\2\2\u0147h\3\2")
-        buf.write("\2\2\u0148\u0149\7O\2\2\u0149\u014a\7G\2\2\u014a\u014b")
-        buf.write("\7V\2\2\u014b\u014c\7C\2\2\u014c\u014d\7F\2\2\u014d\u014e")
-        buf.write("\7C\2\2\u014e\u014f\7V\2\2\u014f\u0150\7C\2\2\u0150\u0151")
-        buf.write("\7<\2\2\u0151\u0155\3\2\2\2\u0152\u0154\13\2\2\2\u0153")
-        buf.write("\u0152\3\2\2\2\u0154\u0157\3\2\2\2\u0155\u0153\3\2\2\2")
-        buf.write("\u0155\u0156\3\2\2\2\u0156j\3\2\2\2\u0157\u0155\3\2\2")
-        buf.write("\2\23\2\u00cd\u00cf\u00da\u00e4\u00f1\u00f3\u0119\u011d")
-        buf.write("\u0122\u0124\u012b\u0131\u0134\u013c\u0140\u0155\3\b\2")
+        buf.write("\t\64\4\65\t\65\4\66\t\66\3\2\3\2\3\3\3\3\3\4\3\4\3\5")
+        buf.write("\3\5\3\6\3\6\3\7\3\7\3\b\3\b\3\t\3\t\3\n\3\n\3\13\3\13")
+        buf.write("\3\13\3\f\3\f\3\f\3\f\3\f\3\r\3\r\3\16\3\16\3\17\3\17")
+        buf.write("\3\17\3\17\3\20\3\20\3\21\3\21\3\22\3\22\3\22\3\23\3\23")
+        buf.write("\3\23\3\24\3\24\3\24\3\25\3\25\3\25\3\25\3\26\3\26\3\26")
+        buf.write("\3\26\3\26\3\26\3\26\3\27\3\27\3\27\3\27\3\27\3\30\3\30")
+        buf.write("\3\30\3\31\3\31\3\31\3\31\3\31\3\31\3\32\3\32\3\32\3\32")
+        buf.write("\3\32\3\32\3\32\3\33\3\33\3\34\3\34\3\34\3\34\3\34\3\34")
+        buf.write("\3\34\3\35\3\35\3\35\3\35\3\35\3\36\3\36\3\36\3\36\3\36")
+        buf.write("\3\36\3\36\3\37\3\37\3\37\3\37\3\37\7\37\u00d7\n\37\f")
+        buf.write("\37\16\37\u00da\13\37\3\37\3\37\3\37\3\37\3\37\3 \6 \u00e2")
+        buf.write("\n \r \16 \u00e3\3 \3 \3!\3!\3!\3!\7!\u00ec\n!\f!\16!")
+        buf.write("\u00ef\13!\3!\3!\3!\3!\3\"\3\"\3\"\3#\3#\3#\7#\u00fb\n")
+        buf.write("#\f#\16#\u00fe\13#\3#\3#\3$\3$\3%\3%\3&\3&\3\'\3\'\3(")
+        buf.write("\3(\3)\3)\3*\3*\3*\3+\3+\3+\3,\3,\3,\3-\3-\3-\3.\3.\3")
+        buf.write(".\3.\3.\3.\3.\3.\3.\5.\u0123\n.\3/\3/\5/\u0127\n/\3/\3")
+        buf.write("/\3/\7/\u012c\n/\f/\16/\u012f\13/\3/\3/\7/\u0133\n/\f")
+        buf.write("/\16/\u0136\13/\3\60\3\60\3\60\5\60\u013b\n\60\3\60\5")
+        buf.write("\60\u013e\n\60\3\61\3\61\3\61\3\62\6\62\u0144\n\62\r\62")
+        buf.write("\16\62\u0145\3\63\3\63\5\63\u014a\n\63\3\63\3\63\3\64")
+        buf.write("\3\64\3\65\3\65\3\66\3\66\3\66\3\66\3\66\3\66\3\66\3\66")
+        buf.write("\3\66\3\66\3\66\7\66\u015d\n\66\f\66\16\66\u0160\13\66")
+        buf.write("\5\u00d8\u00ed\u00fc\2\67\3\3\5\4\7\5\t\6\13\7\r\b\17")
+        buf.write("\t\21\n\23\13\25\f\27\r\31\16\33\17\35\20\37\21!\22#\23")
+        buf.write("%\24\'\25)\26+\27-\30/\31\61\32\63\33\65\34\67\359\36")
+        buf.write(";\37= ?!A\"C\2E#G$I%K&M\'O(Q)S*U+W,Y-[.]/_\2a\60c\61e")
+        buf.write("\2g\2i\2k\62\3\2\b\5\2\13\f\17\17\"\"\4\2\f\f\17\17\4")
+        buf.write("\2GGgg\4\2--//\4\2C\\c|\3\2\62;\2\u016c\2\3\3\2\2\2\2")
+        buf.write("\5\3\2\2\2\2\7\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3")
+        buf.write("\2\2\2\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25\3\2")
+        buf.write("\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2\2")
+        buf.write("\2\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("\2\2\2\2)\3\2\2\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61")
+        buf.write("\3\2\2\2\2\63\3\2\2\2\2\65\3\2\2\2\2\67\3\2\2\2\29\3\2")
+        buf.write("\2\2\2;\3\2\2\2\2=\3\2\2\2\2?\3\2\2\2\2A\3\2\2\2\2E\3")
+        buf.write("\2\2\2\2G\3\2\2\2\2I\3\2\2\2\2K\3\2\2\2\2M\3\2\2\2\2O")
+        buf.write("\3\2\2\2\2Q\3\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2W\3\2\2\2\2")
+        buf.write("Y\3\2\2\2\2[\3\2\2\2\2]\3\2\2\2\2a\3\2\2\2\2c\3\2\2\2")
+        buf.write("\2k\3\2\2\2\3m\3\2\2\2\5o\3\2\2\2\7q\3\2\2\2\ts\3\2\2")
+        buf.write("\2\13u\3\2\2\2\rw\3\2\2\2\17y\3\2\2\2\21{\3\2\2\2\23}")
+        buf.write("\3\2\2\2\25\177\3\2\2\2\27\u0082\3\2\2\2\31\u0087\3\2")
+        buf.write("\2\2\33\u0089\3\2\2\2\35\u008b\3\2\2\2\37\u008f\3\2\2")
+        buf.write("\2!\u0091\3\2\2\2#\u0093\3\2\2\2%\u0096\3\2\2\2\'\u0099")
+        buf.write("\3\2\2\2)\u009c\3\2\2\2+\u00a0\3\2\2\2-\u00a7\3\2\2\2")
+        buf.write("/\u00ac\3\2\2\2\61\u00af\3\2\2\2\63\u00b5\3\2\2\2\65\u00bc")
+        buf.write("\3\2\2\2\67\u00be\3\2\2\29\u00c5\3\2\2\2;\u00ca\3\2\2")
+        buf.write("\2=\u00d1\3\2\2\2?\u00e1\3\2\2\2A\u00e7\3\2\2\2C\u00f4")
+        buf.write("\3\2\2\2E\u00f7\3\2\2\2G\u0101\3\2\2\2I\u0103\3\2\2\2")
+        buf.write("K\u0105\3\2\2\2M\u0107\3\2\2\2O\u0109\3\2\2\2Q\u010b\3")
+        buf.write("\2\2\2S\u010d\3\2\2\2U\u0110\3\2\2\2W\u0113\3\2\2\2Y\u0116")
+        buf.write("\3\2\2\2[\u0122\3\2\2\2]\u0126\3\2\2\2_\u0137\3\2\2\2")
+        buf.write("a\u013f\3\2\2\2c\u0143\3\2\2\2e\u0147\3\2\2\2g\u014d\3")
+        buf.write("\2\2\2i\u014f\3\2\2\2k\u0151\3\2\2\2mn\7\60\2\2n\4\3\2")
+        buf.write("\2\2op\7B\2\2p\6\3\2\2\2qr\7\'\2\2r\b\3\2\2\2st\7a\2\2")
+        buf.write("t\n\3\2\2\2uv\7.\2\2v\f\3\2\2\2wx\7*\2\2x\16\3\2\2\2y")
+        buf.write("z\7+\2\2z\20\3\2\2\2{|\7]\2\2|\22\3\2\2\2}~\7_\2\2~\24")
+        buf.write("\3\2\2\2\177\u0080\7k\2\2\u0080\u0081\7h\2\2\u0081\26")
+        buf.write("\3\2\2\2\u0082\u0083\7g\2\2\u0083\u0084\7n\2\2\u0084\u0085")
+        buf.write("\7u\2\2\u0085\u0086\7g\2\2\u0086\30\3\2\2\2\u0087\u0088")
+        buf.write("\7}\2\2\u0088\32\3\2\2\2\u0089\u008a\7\177\2\2\u008a\34")
+        buf.write("\3\2\2\2\u008b\u008c\7n\2\2\u008c\u008d\7g\2\2\u008d\u008e")
+        buf.write("\7v\2\2\u008e\36\3\2\2\2\u008f\u0090\7?\2\2\u0090 \3\2")
+        buf.write("\2\2\u0091\u0092\7=\2\2\u0092\"\3\2\2\2\u0093\u0094\7")
+        buf.write("=\2\2\u0094\u0095\7=\2\2\u0095$\3\2\2\2\u0096\u0097\7")
+        buf.write("h\2\2\u0097\u0098\7p\2\2\u0098&\3\2\2\2\u0099\u009a\7")
+        buf.write("/\2\2\u009a\u009b\7@\2\2\u009b(\3\2\2\2\u009c\u009d\7")
+        buf.write("f\2\2\u009d\u009e\7g\2\2\u009e\u009f\7h\2\2\u009f*\3\2")
+        buf.write("\2\2\u00a0\u00a1\7g\2\2\u00a1\u00a2\7z\2\2\u00a2\u00a3")
+        buf.write("\7v\2\2\u00a3\u00a4\7g\2\2\u00a4\u00a5\7t\2\2\u00a5\u00a6")
+        buf.write("\7p\2\2\u00a6,\3\2\2\2\u00a7\u00a8\7v\2\2\u00a8\u00a9")
+        buf.write("\7{\2\2\u00a9\u00aa\7r\2\2\u00aa\u00ab\7g\2\2\u00ab.\3")
+        buf.write("\2\2\2\u00ac\u00ad\7?\2\2\u00ad\u00ae\7@\2\2\u00ae\60")
+        buf.write("\3\2\2\2\u00af\u00b0\7o\2\2\u00b0\u00b1\7c\2\2\u00b1\u00b2")
+        buf.write("\7v\2\2\u00b2\u00b3\7e\2\2\u00b3\u00b4\7j\2\2\u00b4\62")
+        buf.write("\3\2\2\2\u00b5\u00b6\7o\2\2\u00b6\u00b7\7c\2\2\u00b7\u00b8")
+        buf.write("\7v\2\2\u00b8\u00b9\7e\2\2\u00b9\u00ba\7j\2\2\u00ba\u00bb")
+        buf.write("\7A\2\2\u00bb\64\3\2\2\2\u00bc\u00bd\7<\2\2\u00bd\66\3")
+        buf.write("\2\2\2\u00be\u00bf\7V\2\2\u00bf\u00c0\7g\2\2\u00c0\u00c1")
+        buf.write("\7p\2\2\u00c1\u00c2\7u\2\2\u00c2\u00c3\7q\2\2\u00c3\u00c4")
+        buf.write("\7t\2\2\u00c48\3\2\2\2\u00c5\u00c6\7o\2\2\u00c6\u00c7")
+        buf.write("\7g\2\2\u00c7\u00c8\7v\2\2\u00c8\u00c9\7c\2\2\u00c9:\3")
+        buf.write("\2\2\2\u00ca\u00cb\7x\2\2\u00cb\u00cc\7\62\2\2\u00cc\u00cd")
+        buf.write("\7\60\2\2\u00cd\u00ce\7\62\2\2\u00ce\u00cf\7\60\2\2\u00cf")
+        buf.write("\u00d0\7\66\2\2\u00d0<\3\2\2\2\u00d1\u00d2\7\61\2\2\u00d2")
+        buf.write("\u00d3\7,\2\2\u00d3\u00d8\3\2\2\2\u00d4\u00d7\5=\37\2")
+        buf.write("\u00d5\u00d7\13\2\2\2\u00d6\u00d4\3\2\2\2\u00d6\u00d5")
+        buf.write("\3\2\2\2\u00d7\u00da\3\2\2\2\u00d8\u00d9\3\2\2\2\u00d8")
+        buf.write("\u00d6\3\2\2\2\u00d9\u00db\3\2\2\2\u00da\u00d8\3\2\2\2")
+        buf.write("\u00db\u00dc\7,\2\2\u00dc\u00dd\7\61\2\2\u00dd\u00de\3")
+        buf.write("\2\2\2\u00de\u00df\b\37\2\2\u00df>\3\2\2\2\u00e0\u00e2")
+        buf.write("\t\2\2\2\u00e1\u00e0\3\2\2\2\u00e2\u00e3\3\2\2\2\u00e3")
+        buf.write("\u00e1\3\2\2\2\u00e3\u00e4\3\2\2\2\u00e4\u00e5\3\2\2\2")
+        buf.write("\u00e5\u00e6\b \2\2\u00e6@\3\2\2\2\u00e7\u00e8\7\61\2")
+        buf.write("\2\u00e8\u00e9\7\61\2\2\u00e9\u00ed\3\2\2\2\u00ea\u00ec")
+        buf.write("\13\2\2\2\u00eb\u00ea\3\2\2\2\u00ec\u00ef\3\2\2\2\u00ed")
+        buf.write("\u00ee\3\2\2\2\u00ed\u00eb\3\2\2\2\u00ee\u00f0\3\2\2\2")
+        buf.write("\u00ef\u00ed\3\2\2\2\u00f0\u00f1\7\f\2\2\u00f1\u00f2\3")
+        buf.write("\2\2\2\u00f2\u00f3\b!\2\2\u00f3B\3\2\2\2\u00f4\u00f5\7")
+        buf.write("^\2\2\u00f5\u00f6\7$\2\2\u00f6D\3\2\2\2\u00f7\u00fc\7")
+        buf.write("$\2\2\u00f8\u00fb\5C\"\2\u00f9\u00fb\n\3\2\2\u00fa\u00f8")
+        buf.write("\3\2\2\2\u00fa\u00f9\3\2\2\2\u00fb\u00fe\3\2\2\2\u00fc")
+        buf.write("\u00fd\3\2\2\2\u00fc\u00fa\3\2\2\2\u00fd\u00ff\3\2\2\2")
+        buf.write("\u00fe\u00fc\3\2\2\2\u00ff\u0100\7$\2\2\u0100F\3\2\2\2")
+        buf.write("\u0101\u0102\7,\2\2\u0102H\3\2\2\2\u0103\u0104\7\61\2")
+        buf.write("\2\u0104J\3\2\2\2\u0105\u0106\7-\2\2\u0106L\3\2\2\2\u0107")
+        buf.write("\u0108\7/\2\2\u0108N\3\2\2\2\u0109\u010a\7>\2\2\u010a")
+        buf.write("P\3\2\2\2\u010b\u010c\7@\2\2\u010cR\3\2\2\2\u010d\u010e")
+        buf.write("\7>\2\2\u010e\u010f\7?\2\2\u010fT\3\2\2\2\u0110\u0111")
+        buf.write("\7@\2\2\u0111\u0112\7?\2\2\u0112V\3\2\2\2\u0113\u0114")
+        buf.write("\7?\2\2\u0114\u0115\7?\2\2\u0115X\3\2\2\2\u0116\u0117")
+        buf.write("\7#\2\2\u0117\u0118\7?\2\2\u0118Z\3\2\2\2\u0119\u011a")
+        buf.write("\7V\2\2\u011a\u011b\7t\2\2\u011b\u011c\7w\2\2\u011c\u0123")
+        buf.write("\7g\2\2\u011d\u011e\7H\2\2\u011e\u011f\7c\2\2\u011f\u0120")
+        buf.write("\7n\2\2\u0120\u0121\7u\2\2\u0121\u0123\7g\2\2\u0122\u0119")
+        buf.write("\3\2\2\2\u0122\u011d\3\2\2\2\u0123\\\3\2\2\2\u0124\u0127")
+        buf.write("\7a\2\2\u0125\u0127\5g\64\2\u0126\u0124\3\2\2\2\u0126")
+        buf.write("\u0125\3\2\2\2\u0127\u012d\3\2\2\2\u0128\u012c\7a\2\2")
+        buf.write("\u0129\u012c\5g\64\2\u012a\u012c\5i\65\2\u012b\u0128\3")
+        buf.write("\2\2\2\u012b\u0129\3\2\2\2\u012b\u012a\3\2\2\2\u012c\u012f")
+        buf.write("\3\2\2\2\u012d\u012b\3\2\2\2\u012d\u012e\3\2\2\2\u012e")
+        buf.write("\u0134\3\2\2\2\u012f\u012d\3\2\2\2\u0130\u0131\7\60\2")
+        buf.write("\2\u0131\u0133\5]/\2\u0132\u0130\3\2\2\2\u0133\u0136\3")
+        buf.write("\2\2\2\u0134\u0132\3\2\2\2\u0134\u0135\3\2\2\2\u0135^")
+        buf.write("\3\2\2\2\u0136\u0134\3\2\2\2\u0137\u013a\5c\62\2\u0138")
+        buf.write("\u0139\7\60\2\2\u0139\u013b\5c\62\2\u013a\u0138\3\2\2")
+        buf.write("\2\u013a\u013b\3\2\2\2\u013b\u013d\3\2\2\2\u013c\u013e")
+        buf.write("\5e\63\2\u013d\u013c\3\2\2\2\u013d\u013e\3\2\2\2\u013e")
+        buf.write("`\3\2\2\2\u013f\u0140\5_\60\2\u0140\u0141\7h\2\2\u0141")
+        buf.write("b\3\2\2\2\u0142\u0144\5i\65\2\u0143\u0142\3\2\2\2\u0144")
+        buf.write("\u0145\3\2\2\2\u0145\u0143\3\2\2\2\u0145\u0146\3\2\2\2")
+        buf.write("\u0146d\3\2\2\2\u0147\u0149\t\4\2\2\u0148\u014a\t\5\2")
+        buf.write("\2\u0149\u0148\3\2\2\2\u0149\u014a\3\2\2\2\u014a\u014b")
+        buf.write("\3\2\2\2\u014b\u014c\5c\62\2\u014cf\3\2\2\2\u014d\u014e")
+        buf.write("\t\6\2\2\u014eh\3\2\2\2\u014f\u0150\t\7\2\2\u0150j\3\2")
+        buf.write("\2\2\u0151\u0152\7O\2\2\u0152\u0153\7G\2\2\u0153\u0154")
+        buf.write("\7V\2\2\u0154\u0155\7C\2\2\u0155\u0156\7F\2\2\u0156\u0157")
+        buf.write("\7C\2\2\u0157\u0158\7V\2\2\u0158\u0159\7C\2\2\u0159\u015a")
+        buf.write("\7<\2\2\u015a\u015e\3\2\2\2\u015b\u015d\13\2\2\2\u015c")
+        buf.write("\u015b\3\2\2\2\u015d\u0160\3\2\2\2\u015e\u015c\3\2\2\2")
+        buf.write("\u015e\u015f\3\2\2\2\u015fl\3\2\2\2\u0160\u015e\3\2\2")
+        buf.write("\2\23\2\u00d6\u00d8\u00e3\u00ed\u00fa\u00fc\u0122\u0126")
+        buf.write("\u012b\u012d\u0134\u013a\u013d\u0145\u0149\u015e\3\b\2")
         buf.write("\2")
         return buf.getvalue()
 
@@ -192,26 +196,27 @@ class RelayLexer(Lexer):
     T__24 = 25
     T__25 = 26
     T__26 = 27
-    SEMVER = 28
-    COMMENT = 29
-    WS = 30
-    LINE_COMMENT = 31
-    QUOTED_STRING = 32
-    MUL = 33
-    DIV = 34
-    ADD = 35
-    SUB = 36
-    LT = 37
-    GT = 38
-    LE = 39
-    GE = 40
-    EQ = 41
-    NE = 42
-    BOOL_LIT = 43
-    CNAME = 44
-    FLOAT = 45
-    NAT = 46
-    METADATA = 47
+    T__27 = 28
+    SEMVER = 29
+    COMMENT = 30
+    WS = 31
+    LINE_COMMENT = 32
+    QUOTED_STRING = 33
+    MUL = 34
+    DIV = 35
+    ADD = 36
+    SUB = 37
+    LT = 38
+    GT = 39
+    LE = 40
+    GE = 41
+    EQ = 42
+    NE = 43
+    BOOL_LIT = 44
+    CNAME = 45
+    FLOAT = 46
+    NAT = 47
+    METADATA = 48
 
     channelNames = [ u"DEFAULT_TOKEN_CHANNEL", u"HIDDEN" ]
 
@@ -220,9 +225,9 @@ class RelayLexer(Lexer):
     literalNames = [ "<INVALID>",
             "'.'", "'@'", "'%'", "'_'", "','", "'('", "')'", "'['", "']'", 
             "'if'", "'else'", "'{'", "'}'", "'let'", "'='", "';'", "';;'", 
-            "'fn'", "'->'", "'def'", "'type'", "'=>'", "'match'", "'match?'", 
-            "':'", "'Tensor'", "'meta'", "'v0.0.4'", "'*'", "'/'", "'+'", 
-            "'-'", "'<'", "'>'", "'<='", "'>='", "'=='", "'!='" ]
+            "'fn'", "'->'", "'def'", "'extern'", "'type'", "'=>'", "'match'", 
+            "'match?'", "':'", "'Tensor'", "'meta'", "'v0.0.4'", "'*'", 
+            "'/'", "'+'", "'-'", "'<'", "'>'", "'<='", "'>='", "'=='", "'!='" ]
 
     symbolicNames = [ "<INVALID>",
             "SEMVER", "COMMENT", "WS", "LINE_COMMENT", "QUOTED_STRING", 
@@ -233,10 +238,11 @@ class RelayLexer(Lexer):
                   "T__7", "T__8", "T__9", "T__10", "T__11", "T__12", "T__13", 
                   "T__14", "T__15", "T__16", "T__17", "T__18", "T__19", 
                   "T__20", "T__21", "T__22", "T__23", "T__24", "T__25", 
-                  "T__26", "SEMVER", "COMMENT", "WS", "LINE_COMMENT", "ESCAPED_QUOTE", 
-                  "QUOTED_STRING", "MUL", "DIV", "ADD", "SUB", "LT", "GT", 
-                  "LE", "GE", "EQ", "NE", "BOOL_LIT", "CNAME", "PREFLOAT", 
-                  "FLOAT", "NAT", "EXP", "LETTER", "DIGIT", "METADATA" ]
+                  "T__26", "T__27", "SEMVER", "COMMENT", "WS", "LINE_COMMENT", 
+                  "ESCAPED_QUOTE", "QUOTED_STRING", "MUL", "DIV", "ADD", 
+                  "SUB", "LT", "GT", "LE", "GE", "EQ", "NE", "BOOL_LIT", 
+                  "CNAME", "PREFLOAT", "FLOAT", "NAT", "EXP", "LETTER", 
+                  "DIGIT", "METADATA" ]
 
     grammarFileName = "Relay.g4"
 
diff --git a/python/tvm/relay/grammar/py3/RelayParser.py b/python/tvm/relay/grammar/py3/RelayParser.py
index 1fb9ca555601..91fde4c04114 100644
--- a/python/tvm/relay/grammar/py3/RelayParser.py
+++ b/python/tvm/relay/grammar/py3/RelayParser.py
@@ -8,8 +8,8 @@
 
 def serializedATN():
     with StringIO() as buf:
-        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\61")
-        buf.write("\u01f6\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
+        buf.write("\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\62")
+        buf.write("\u01fc\4\2\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7")
         buf.write("\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t\13\4\f\t\f\4\r\t\r\4\16")
         buf.write("\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22\4\23\t\23")
         buf.write("\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31")
@@ -30,227 +30,231 @@ def serializedATN():
         buf.write("\3\t\3\t\3\t\7\t\u00de\n\t\f\t\16\t\u00e1\13\t\3\n\3\n")
         buf.write("\5\n\u00e5\n\n\3\n\3\n\3\n\3\n\3\n\5\n\u00ec\n\n\3\n\3")
         buf.write("\n\3\13\3\13\3\13\5\13\u00f3\n\13\3\13\3\13\3\13\3\13")
-        buf.write("\3\13\5\13\u00fa\n\13\3\13\3\13\3\13\3\13\3\13\5\13\u0101")
-        buf.write("\n\13\3\13\3\13\5\13\u0105\n\13\3\13\3\13\5\13\u0109\n")
-        buf.write("\13\3\f\3\f\3\r\3\r\3\r\7\r\u0110\n\r\f\r\16\r\u0113\13")
-        buf.write("\r\3\r\5\r\u0116\n\r\3\16\3\16\3\16\3\16\3\16\7\16\u011d")
-        buf.write("\n\16\f\16\16\16\u0120\13\16\3\16\3\16\5\16\u0124\n\16")
-        buf.write("\3\17\3\17\3\17\7\17\u0129\n\17\f\17\16\17\u012c\13\17")
-        buf.write("\3\17\5\17\u012f\n\17\3\20\3\20\5\20\u0133\n\20\3\20\3")
-        buf.write("\20\3\20\3\20\3\20\3\20\5\20\u013b\n\20\3\21\3\21\3\22")
-        buf.write("\3\22\3\22\3\22\7\22\u0143\n\22\f\22\16\22\u0146\13\22")
-        buf.write("\3\22\3\22\3\23\3\23\3\23\3\23\5\23\u014e\n\23\5\23\u0150")
-        buf.write("\n\23\3\24\3\24\5\24\u0154\n\24\3\25\3\25\3\25\3\25\7")
-        buf.write("\25\u015a\n\25\f\25\16\25\u015d\13\25\3\25\3\25\3\26\3")
-        buf.write("\26\5\26\u0163\n\26\3\27\3\27\3\27\3\27\7\27\u0169\n\27")
-        buf.write("\f\27\16\27\u016c\13\27\3\27\5\27\u016f\n\27\3\30\3\30")
-        buf.write("\3\30\7\30\u0174\n\30\f\30\16\30\u0177\13\30\5\30\u0179")
-        buf.write("\n\30\3\31\3\31\3\31\5\31\u017e\n\31\3\32\3\32\3\32\7")
-        buf.write("\32\u0183\n\32\f\32\16\32\u0186\13\32\3\33\3\33\3\33\3")
-        buf.write("\33\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34")
-        buf.write("\3\34\6\34\u0197\n\34\r\34\16\34\u0198\3\34\3\34\3\34")
-        buf.write("\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34")
-        buf.write("\3\34\5\34\u01aa\n\34\3\34\3\34\3\34\3\34\7\34\u01b0\n")
-        buf.write("\34\f\34\16\34\u01b3\13\34\5\34\u01b5\n\34\3\34\3\34\3")
-        buf.write("\34\3\34\5\34\u01bb\n\34\3\35\3\35\3\35\3\35\7\35\u01c1")
-        buf.write("\n\35\f\35\16\35\u01c4\13\35\3\35\3\35\3\36\3\36\3\36")
-        buf.write("\3\36\3\36\3\36\6\36\u01ce\n\36\r\36\16\36\u01cf\3\36")
-        buf.write("\3\36\3\36\5\36\u01d5\n\36\3\37\3\37\3\37\3\37\3\37\3")
-        buf.write("\37\3\37\3\37\3 \3 \3 \3 \3 \3 \5 \u01e5\n \3!\3!\3!\3")
-        buf.write("!\3\"\3\"\3\"\5\"\u01ee\n\"\3#\3#\3#\3#\5#\u01f4\n#\3")
-        buf.write("#\2\3\20$\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&")
-        buf.write("(*,.\60\62\64\668:<>@BD\2\b\4\2\6\6..\3\2#$\3\2%&\3\2")
-        buf.write("\'*\3\2+,\3\2\31\32\2\u0225\2F\3\2\2\2\4U\3\2\2\2\6]\3")
-        buf.write("\2\2\2\b`\3\2\2\2\nc\3\2\2\2\fn\3\2\2\2\16z\3\2\2\2\20")
-        buf.write("\u00c4\3\2\2\2\22\u00e2\3\2\2\2\24\u0108\3\2\2\2\26\u010a")
-        buf.write("\3\2\2\2\30\u010c\3\2\2\2\32\u0117\3\2\2\2\34\u0125\3")
-        buf.write("\2\2\2\36\u0130\3\2\2\2 \u013c\3\2\2\2\"\u013e\3\2\2\2")
-        buf.write("$\u014f\3\2\2\2&\u0151\3\2\2\2(\u0155\3\2\2\2*\u0162\3")
-        buf.write("\2\2\2,\u016e\3\2\2\2.\u0178\3\2\2\2\60\u017a\3\2\2\2")
-        buf.write("\62\u017f\3\2\2\2\64\u0187\3\2\2\2\66\u01ba\3\2\2\28\u01bc")
-        buf.write("\3\2\2\2:\u01d4\3\2\2\2<\u01d6\3\2\2\2>\u01e4\3\2\2\2")
-        buf.write("@\u01e6\3\2\2\2B\u01ed\3\2\2\2D\u01f3\3\2\2\2FN\7\36\2")
-        buf.write("\2GI\5\24\13\2HG\3\2\2\2IL\3\2\2\2JH\3\2\2\2JK\3\2\2\2")
-        buf.write("KO\3\2\2\2LJ\3\2\2\2MO\5\20\t\2NJ\3\2\2\2NM\3\2\2\2OQ")
-        buf.write("\3\2\2\2PR\7\61\2\2QP\3\2\2\2QR\3\2\2\2RS\3\2\2\2ST\7")
-        buf.write("\2\2\3T\3\3\2\2\2UZ\7.\2\2VW\7\3\2\2WY\7.\2\2XV\3\2\2")
-        buf.write("\2Y\\\3\2\2\2ZX\3\2\2\2Z[\3\2\2\2[\5\3\2\2\2\\Z\3\2\2")
-        buf.write("\2]^\7\4\2\2^_\7.\2\2_\7\3\2\2\2`a\7\5\2\2ab\t\2\2\2b")
-        buf.write("\t\3\2\2\2cd\7\5\2\2de\7\60\2\2e\13\3\2\2\2fk\5\20\t\2")
-        buf.write("gh\7\7\2\2hj\5\20\t\2ig\3\2\2\2jm\3\2\2\2ki\3\2\2\2kl")
-        buf.write("\3\2\2\2lo\3\2\2\2mk\3\2\2\2nf\3\2\2\2no\3\2\2\2o\r\3")
-        buf.write("\2\2\2p{\5\f\7\2qr\5\20\t\2rs\7\7\2\2su\3\2\2\2tq\3\2")
-        buf.write("\2\2ux\3\2\2\2vt\3\2\2\2vw\3\2\2\2wy\3\2\2\2xv\3\2\2\2")
-        buf.write("y{\5\62\32\2zp\3\2\2\2zv\3\2\2\2{\17\3\2\2\2|}\b\t\1\2")
-        buf.write("}~\7\b\2\2~\177\5\20\t\2\177\u0080\7\t\2\2\u0080\u00c5")
-        buf.write("\3\2\2\2\u0081\u0082\7&\2\2\u0082\u00c5\5\20\t\26\u0083")
-        buf.write("\u00c5\5\22\n\2\u0084\u0085\7\b\2\2\u0085\u00c5\7\t\2")
-        buf.write("\2\u0086\u0087\7\b\2\2\u0087\u0088\5\20\t\2\u0088\u0089")
-        buf.write("\7\7\2\2\u0089\u008a\7\t\2\2\u008a\u00c5\3\2\2\2\u008b")
-        buf.write("\u008c\7\b\2\2\u008c\u008f\5\20\t\2\u008d\u008e\7\7\2")
-        buf.write("\2\u008e\u0090\5\20\t\2\u008f\u008d\3\2\2\2\u0090\u0091")
-        buf.write("\3\2\2\2\u0091\u008f\3\2\2\2\u0091\u0092\3\2\2\2\u0092")
-        buf.write("\u0093\3\2\2\2\u0093\u0094\7\t\2\2\u0094\u00c5\3\2\2\2")
-        buf.write("\u0095\u009e\7\n\2\2\u0096\u009b\5\20\t\2\u0097\u0098")
-        buf.write("\7\7\2\2\u0098\u009a\5\20\t\2\u0099\u0097\3\2\2\2\u009a")
-        buf.write("\u009d\3\2\2\2\u009b\u0099\3\2\2\2\u009b\u009c\3\2\2\2")
-        buf.write("\u009c\u009f\3\2\2\2\u009d\u009b\3\2\2\2\u009e\u0096\3")
-        buf.write("\2\2\2\u009e\u009f\3\2\2\2\u009f\u00a0\3\2\2\2\u00a0\u00c5")
-        buf.write("\7\13\2\2\u00a1\u00a2\7\f\2\2\u00a2\u00a3\7\b\2\2\u00a3")
-        buf.write("\u00a4\5\20\t\2\u00a4\u00a5\7\t\2\2\u00a5\u00a6\5@!\2")
-        buf.write("\u00a6\u00a7\7\r\2\2\u00a7\u00a8\5@!\2\u00a8\u00c5\3\2")
-        buf.write("\2\2\u00a9\u00aa\5 \21\2\u00aa\u00ab\7\b\2\2\u00ab\u00ac")
-        buf.write("\5\20\t\2\u00ac\u00ad\7\t\2\2\u00ad\u00af\7\16\2\2\u00ae")
-        buf.write("\u00b0\5\34\17\2\u00af\u00ae\3\2\2\2\u00af\u00b0\3\2\2")
-        buf.write("\2\u00b0\u00b1\3\2\2\2\u00b1\u00b2\7\17\2\2\u00b2\u00c5")
-        buf.write("\3\2\2\2\u00b3\u00b4\7\20\2\2\u00b4\u00b5\5\60\31\2\u00b5")
-        buf.write("\u00b6\7\21\2\2\u00b6\u00b7\5\20\t\2\u00b7\u00b8\7\22")
-        buf.write("\2\2\u00b8\u00b9\5\20\t\t\u00b9\u00c5\3\2\2\2\u00ba\u00bb")
-        buf.write("\5\n\6\2\u00bb\u00bc\7\21\2\2\u00bc\u00bd\5\20\t\2\u00bd")
-        buf.write("\u00be\7\22\2\2\u00be\u00bf\5\20\t\7\u00bf\u00c5\3\2\2")
-        buf.write("\2\u00c0\u00c5\5D#\2\u00c1\u00c5\5B\"\2\u00c2\u00c5\5")
-        buf.write("<\37\2\u00c3\u00c5\7\"\2\2\u00c4|\3\2\2\2\u00c4\u0081")
-        buf.write("\3\2\2\2\u00c4\u0083\3\2\2\2\u00c4\u0084\3\2\2\2\u00c4")
-        buf.write("\u0086\3\2\2\2\u00c4\u008b\3\2\2\2\u00c4\u0095\3\2\2\2")
-        buf.write("\u00c4\u00a1\3\2\2\2\u00c4\u00a9\3\2\2\2\u00c4\u00b3\3")
-        buf.write("\2\2\2\u00c4\u00ba\3\2\2\2\u00c4\u00c0\3\2\2\2\u00c4\u00c1")
-        buf.write("\3\2\2\2\u00c4\u00c2\3\2\2\2\u00c4\u00c3\3\2\2\2\u00c5")
-        buf.write("\u00df\3\2\2\2\u00c6\u00c7\f\25\2\2\u00c7\u00c8\t\3\2")
-        buf.write("\2\u00c8\u00de\5\20\t\26\u00c9\u00ca\f\24\2\2\u00ca\u00cb")
-        buf.write("\t\4\2\2\u00cb\u00de\5\20\t\25\u00cc\u00cd\f\23\2\2\u00cd")
-        buf.write("\u00ce\t\5\2\2\u00ce\u00de\5\20\t\24\u00cf\u00d0\f\22")
-        buf.write("\2\2\u00d0\u00d1\t\6\2\2\u00d1\u00de\5\20\t\23\u00d2\u00d3")
-        buf.write("\f\b\2\2\u00d3\u00d4\7\23\2\2\u00d4\u00de\5\20\t\t\u00d5")
-        buf.write("\u00d6\f\27\2\2\u00d6\u00d7\7\b\2\2\u00d7\u00d8\5\16\b")
-        buf.write("\2\u00d8\u00d9\7\t\2\2\u00d9\u00de\3\2\2\2\u00da\u00db")
-        buf.write("\f\n\2\2\u00db\u00dc\7\3\2\2\u00dc\u00de\7\60\2\2\u00dd")
-        buf.write("\u00c6\3\2\2\2\u00dd\u00c9\3\2\2\2\u00dd\u00cc\3\2\2\2")
-        buf.write("\u00dd\u00cf\3\2\2\2\u00dd\u00d2\3\2\2\2\u00dd\u00d5\3")
-        buf.write("\2\2\2\u00dd\u00da\3\2\2\2\u00de\u00e1\3\2\2\2\u00df\u00dd")
-        buf.write("\3\2\2\2\u00df\u00e0\3\2\2\2\u00e0\21\3\2\2\2\u00e1\u00df")
-        buf.write("\3\2\2\2\u00e2\u00e4\7\24\2\2\u00e3\u00e5\58\35\2\u00e4")
-        buf.write("\u00e3\3\2\2\2\u00e4\u00e5\3\2\2\2\u00e5\u00e6\3\2\2\2")
-        buf.write("\u00e6\u00e7\7\b\2\2\u00e7\u00e8\5,\27\2\u00e8\u00eb\7")
-        buf.write("\t\2\2\u00e9\u00ea\7\25\2\2\u00ea\u00ec\5\66\34\2\u00eb")
-        buf.write("\u00e9\3\2\2\2\u00eb\u00ec\3\2\2\2\u00ec\u00ed\3\2\2\2")
-        buf.write("\u00ed\u00ee\5@!\2\u00ee\23\3\2\2\2\u00ef\u00f0\7\26\2")
-        buf.write("\2\u00f0\u00f2\5\6\4\2\u00f1\u00f3\58\35\2\u00f2\u00f1")
-        buf.write("\3\2\2\2\u00f2\u00f3\3\2\2\2\u00f3\u00f4\3\2\2\2\u00f4")
-        buf.write("\u00f5\7\b\2\2\u00f5\u00f6\5,\27\2\u00f6\u00f9\7\t\2\2")
-        buf.write("\u00f7\u00f8\7\25\2\2\u00f8\u00fa\5\66\34\2\u00f9\u00f7")
-        buf.write("\3\2\2\2\u00f9\u00fa\3\2\2\2\u00fa\u00fb\3\2\2\2\u00fb")
-        buf.write("\u00fc\5@!\2\u00fc\u0109\3\2\2\2\u00fd\u00fe\7\27\2\2")
-        buf.write("\u00fe\u0100\5\4\3\2\u00ff\u0101\58\35\2\u0100\u00ff\3")
-        buf.write("\2\2\2\u0100\u0101\3\2\2\2\u0101\u0102\3\2\2\2\u0102\u0104")
-        buf.write("\7\16\2\2\u0103\u0105\5\30\r\2\u0104\u0103\3\2\2\2\u0104")
-        buf.write("\u0105\3\2\2\2\u0105\u0106\3\2\2\2\u0106\u0107\7\17\2")
-        buf.write("\2\u0107\u0109\3\2\2\2\u0108\u00ef\3\2\2\2\u0108\u00fd")
-        buf.write("\3\2\2\2\u0109\25\3\2\2\2\u010a\u010b\7.\2\2\u010b\27")
-        buf.write("\3\2\2\2\u010c\u0111\5\32\16\2\u010d\u010e\7\7\2\2\u010e")
-        buf.write("\u0110\5\32\16\2\u010f\u010d\3\2\2\2\u0110\u0113\3\2\2")
-        buf.write("\2\u0111\u010f\3\2\2\2\u0111\u0112\3\2\2\2\u0112\u0115")
-        buf.write("\3\2\2\2\u0113\u0111\3\2\2\2\u0114\u0116\7\7\2\2\u0115")
-        buf.write("\u0114\3\2\2\2\u0115\u0116\3\2\2\2\u0116\31\3\2\2\2\u0117")
-        buf.write("\u0123\5\26\f\2\u0118\u0119\7\b\2\2\u0119\u011e\5\66\34")
-        buf.write("\2\u011a\u011b\7\7\2\2\u011b\u011d\5\66\34\2\u011c\u011a")
-        buf.write("\3\2\2\2\u011d\u0120\3\2\2\2\u011e\u011c\3\2\2\2\u011e")
-        buf.write("\u011f\3\2\2\2\u011f\u0121\3\2\2\2\u0120\u011e\3\2\2\2")
-        buf.write("\u0121\u0122\7\t\2\2\u0122\u0124\3\2\2\2\u0123\u0118\3")
-        buf.write("\2\2\2\u0123\u0124\3\2\2\2\u0124\33\3\2\2\2\u0125\u012a")
-        buf.write("\5\36\20\2\u0126\u0127\7\7\2\2\u0127\u0129\5\36\20\2\u0128")
-        buf.write("\u0126\3\2\2\2\u0129\u012c\3\2\2\2\u012a\u0128\3\2\2\2")
-        buf.write("\u012a\u012b\3\2\2\2\u012b\u012e\3\2\2\2\u012c\u012a\3")
-        buf.write("\2\2\2\u012d\u012f\7\7\2\2\u012e\u012d\3\2\2\2\u012e\u012f")
-        buf.write("\3\2\2\2\u012f\35\3\2\2\2\u0130\u0132\5\26\f\2\u0131\u0133")
-        buf.write("\5\"\22\2\u0132\u0131\3\2\2\2\u0132\u0133\3\2\2\2\u0133")
-        buf.write("\u0134\3\2\2\2\u0134\u013a\7\30\2\2\u0135\u0136\7\16\2")
-        buf.write("\2\u0136\u0137\5\20\t\2\u0137\u0138\7\17\2\2\u0138\u013b")
-        buf.write("\3\2\2\2\u0139\u013b\5\20\t\2\u013a\u0135\3\2\2\2\u013a")
-        buf.write("\u0139\3\2\2\2\u013b\37\3\2\2\2\u013c\u013d\t\7\2\2\u013d")
-        buf.write("!\3\2\2\2\u013e\u013f\7\b\2\2\u013f\u0144\5$\23\2\u0140")
-        buf.write("\u0141\7\7\2\2\u0141\u0143\5$\23\2\u0142\u0140\3\2\2\2")
-        buf.write("\u0143\u0146\3\2\2\2\u0144\u0142\3\2\2\2\u0144\u0145\3")
-        buf.write("\2\2\2\u0145\u0147\3\2\2\2\u0146\u0144\3\2\2\2\u0147\u0148")
-        buf.write("\7\t\2\2\u0148#\3\2\2\2\u0149\u0150\7\6\2\2\u014a\u014d")
-        buf.write("\5\b\5\2\u014b\u014c\7\33\2\2\u014c\u014e\5\66\34\2\u014d")
-        buf.write("\u014b\3\2\2\2\u014d\u014e\3\2\2\2\u014e\u0150\3\2\2\2")
-        buf.write("\u014f\u0149\3\2\2\2\u014f\u014a\3\2\2\2\u0150%\3\2\2")
-        buf.write("\2\u0151\u0153\5\26\f\2\u0152\u0154\5(\25\2\u0153\u0152")
-        buf.write("\3\2\2\2\u0153\u0154\3\2\2\2\u0154\'\3\2\2\2\u0155\u0156")
-        buf.write("\7\b\2\2\u0156\u015b\5*\26\2\u0157\u0158\7\7\2\2\u0158")
-        buf.write("\u015a\5*\26\2\u0159\u0157\3\2\2\2\u015a\u015d\3\2\2\2")
-        buf.write("\u015b\u0159\3\2\2\2\u015b\u015c\3\2\2\2\u015c\u015e\3")
-        buf.write("\2\2\2\u015d\u015b\3\2\2\2\u015e\u015f\7\t\2\2\u015f)")
-        buf.write("\3\2\2\2\u0160\u0163\5\b\5\2\u0161\u0163\5\26\f\2\u0162")
-        buf.write("\u0160\3\2\2\2\u0162\u0161\3\2\2\2\u0163+\3\2\2\2\u0164")
-        buf.write("\u016f\5.\30\2\u0165\u0166\5\60\31\2\u0166\u0167\7\7\2")
-        buf.write("\2\u0167\u0169\3\2\2\2\u0168\u0165\3\2\2\2\u0169\u016c")
-        buf.write("\3\2\2\2\u016a\u0168\3\2\2\2\u016a\u016b\3\2\2\2\u016b")
-        buf.write("\u016d\3\2\2\2\u016c\u016a\3\2\2\2\u016d\u016f\5\62\32")
-        buf.write("\2\u016e\u0164\3\2\2\2\u016e\u016a\3\2\2\2\u016f-\3\2")
-        buf.write("\2\2\u0170\u0175\5\60\31\2\u0171\u0172\7\7\2\2\u0172\u0174")
-        buf.write("\5\60\31\2\u0173\u0171\3\2\2\2\u0174\u0177\3\2\2\2\u0175")
-        buf.write("\u0173\3\2\2\2\u0175\u0176\3\2\2\2\u0176\u0179\3\2\2\2")
-        buf.write("\u0177\u0175\3\2\2\2\u0178\u0170\3\2\2\2\u0178\u0179\3")
-        buf.write("\2\2\2\u0179/\3\2\2\2\u017a\u017d\5\b\5\2\u017b\u017c")
-        buf.write("\7\33\2\2\u017c\u017e\5\66\34\2\u017d\u017b\3\2\2\2\u017d")
-        buf.write("\u017e\3\2\2\2\u017e\61\3\2\2\2\u017f\u0184\5\64\33\2")
-        buf.write("\u0180\u0181\7\7\2\2\u0181\u0183\5\64\33\2\u0182\u0180")
-        buf.write("\3\2\2\2\u0183\u0186\3\2\2\2\u0184\u0182\3\2\2\2\u0184")
-        buf.write("\u0185\3\2\2\2\u0185\63\3\2\2\2\u0186\u0184\3\2\2\2\u0187")
-        buf.write("\u0188\7.\2\2\u0188\u0189\7\21\2\2\u0189\u018a\5\20\t")
-        buf.write("\2\u018a\65\3\2\2\2\u018b\u018c\7\b\2\2\u018c\u01bb\7")
-        buf.write("\t\2\2\u018d\u018e\7\b\2\2\u018e\u018f\5\66\34\2\u018f")
-        buf.write("\u0190\7\7\2\2\u0190\u0191\7\t\2\2\u0191\u01bb\3\2\2\2")
-        buf.write("\u0192\u0193\7\b\2\2\u0193\u0196\5\66\34\2\u0194\u0195")
-        buf.write("\7\7\2\2\u0195\u0197\5\66\34\2\u0196\u0194\3\2\2\2\u0197")
-        buf.write("\u0198\3\2\2\2\u0198\u0196\3\2\2\2\u0198\u0199\3\2\2\2")
-        buf.write("\u0199\u019a\3\2\2\2\u019a\u019b\7\t\2\2\u019b\u01bb\3")
-        buf.write("\2\2\2\u019c\u019d\5\4\3\2\u019d\u019e\58\35\2\u019e\u01bb")
-        buf.write("\3\2\2\2\u019f\u01bb\5\4\3\2\u01a0\u01a1\7\34\2\2\u01a1")
-        buf.write("\u01a2\7\n\2\2\u01a2\u01a3\5:\36\2\u01a3\u01a4\7\7\2\2")
-        buf.write("\u01a4\u01a5\5\66\34\2\u01a5\u01a6\7\13\2\2\u01a6\u01bb")
-        buf.write("\3\2\2\2\u01a7\u01a9\7\24\2\2\u01a8\u01aa\58\35\2\u01a9")
-        buf.write("\u01a8\3\2\2\2\u01a9\u01aa\3\2\2\2\u01aa\u01ab\3\2\2\2")
-        buf.write("\u01ab\u01b4\7\b\2\2\u01ac\u01b1\5\66\34\2\u01ad\u01ae")
-        buf.write("\7\7\2\2\u01ae\u01b0\5\66\34\2\u01af\u01ad\3\2\2\2\u01b0")
-        buf.write("\u01b3\3\2\2\2\u01b1\u01af\3\2\2\2\u01b1\u01b2\3\2\2\2")
-        buf.write("\u01b2\u01b5\3\2\2\2\u01b3\u01b1\3\2\2\2\u01b4\u01ac\3")
-        buf.write("\2\2\2\u01b4\u01b5\3\2\2\2\u01b5\u01b6\3\2\2\2\u01b6\u01b7")
-        buf.write("\7\t\2\2\u01b7\u01b8\7\25\2\2\u01b8\u01bb\5\66\34\2\u01b9")
-        buf.write("\u01bb\7\6\2\2\u01ba\u018b\3\2\2\2\u01ba\u018d\3\2\2\2")
-        buf.write("\u01ba\u0192\3\2\2\2\u01ba\u019c\3\2\2\2\u01ba\u019f\3")
-        buf.write("\2\2\2\u01ba\u01a0\3\2\2\2\u01ba\u01a7\3\2\2\2\u01ba\u01b9")
-        buf.write("\3\2\2\2\u01bb\67\3\2\2\2\u01bc\u01bd\7\n\2\2\u01bd\u01c2")
-        buf.write("\5\4\3\2\u01be\u01bf\7\7\2\2\u01bf\u01c1\5\4\3\2\u01c0")
-        buf.write("\u01be\3\2\2\2\u01c1\u01c4\3\2\2\2\u01c2\u01c0\3\2\2\2")
-        buf.write("\u01c2\u01c3\3\2\2\2\u01c3\u01c5\3\2\2\2\u01c4\u01c2\3")
-        buf.write("\2\2\2\u01c5\u01c6\7\13\2\2\u01c69\3\2\2\2\u01c7\u01c8")
-        buf.write("\7\b\2\2\u01c8\u01d5\7\t\2\2\u01c9\u01ca\7\b\2\2\u01ca")
-        buf.write("\u01cd\5> \2\u01cb\u01cc\7\7\2\2\u01cc\u01ce\5> \2\u01cd")
-        buf.write("\u01cb\3\2\2\2\u01ce\u01cf\3\2\2\2\u01cf\u01cd\3\2\2\2")
-        buf.write("\u01cf\u01d0\3\2\2\2\u01d0\u01d1\3\2\2\2\u01d1\u01d2\7")
-        buf.write("\t\2\2\u01d2\u01d5\3\2\2\2\u01d3\u01d5\5> \2\u01d4\u01c7")
-        buf.write("\3\2\2\2\u01d4\u01c9\3\2\2\2\u01d4\u01d3\3\2\2\2\u01d5")
-        buf.write(";\3\2\2\2\u01d6\u01d7\7\35\2\2\u01d7\u01d8\7\n\2\2\u01d8")
-        buf.write("\u01d9\7.\2\2\u01d9\u01da\7\13\2\2\u01da\u01db\7\n\2\2")
-        buf.write("\u01db\u01dc\7\60\2\2\u01dc\u01dd\7\13\2\2\u01dd=\3\2")
-        buf.write("\2\2\u01de\u01e5\5<\37\2\u01df\u01e0\7\b\2\2\u01e0\u01e1")
-        buf.write("\5> \2\u01e1\u01e2\7\t\2\2\u01e2\u01e5\3\2\2\2\u01e3\u01e5")
-        buf.write("\7\60\2\2\u01e4\u01de\3\2\2\2\u01e4\u01df\3\2\2\2\u01e4")
-        buf.write("\u01e3\3\2\2\2\u01e5?\3\2\2\2\u01e6\u01e7\7\16\2\2\u01e7")
-        buf.write("\u01e8\5\20\t\2\u01e8\u01e9\7\17\2\2\u01e9A\3\2\2\2\u01ea")
-        buf.write("\u01ee\7/\2\2\u01eb\u01ee\7\60\2\2\u01ec\u01ee\7-\2\2")
-        buf.write("\u01ed\u01ea\3\2\2\2\u01ed\u01eb\3\2\2\2\u01ed\u01ec\3")
-        buf.write("\2\2\2\u01eeC\3\2\2\2\u01ef\u01f4\5\4\3\2\u01f0\u01f4")
-        buf.write("\5\6\4\2\u01f1\u01f4\5\b\5\2\u01f2\u01f4\5\n\6\2\u01f3")
-        buf.write("\u01ef\3\2\2\2\u01f3\u01f0\3\2\2\2\u01f3\u01f1\3\2\2\2")
-        buf.write("\u01f3\u01f2\3\2\2\2\u01f4E\3\2\2\2\67JNQZknvz\u0091\u009b")
+        buf.write("\3\13\5\13\u00fa\n\13\3\13\3\13\3\13\3\13\3\13\3\13\5")
+        buf.write("\13\u0102\n\13\3\13\3\13\3\13\5\13\u0107\n\13\3\13\3\13")
+        buf.write("\5\13\u010b\n\13\3\13\3\13\5\13\u010f\n\13\3\f\3\f\3\r")
+        buf.write("\3\r\3\r\7\r\u0116\n\r\f\r\16\r\u0119\13\r\3\r\5\r\u011c")
+        buf.write("\n\r\3\16\3\16\3\16\3\16\3\16\7\16\u0123\n\16\f\16\16")
+        buf.write("\16\u0126\13\16\3\16\3\16\5\16\u012a\n\16\3\17\3\17\3")
+        buf.write("\17\7\17\u012f\n\17\f\17\16\17\u0132\13\17\3\17\5\17\u0135")
+        buf.write("\n\17\3\20\3\20\5\20\u0139\n\20\3\20\3\20\3\20\3\20\3")
+        buf.write("\20\3\20\5\20\u0141\n\20\3\21\3\21\3\22\3\22\3\22\3\22")
+        buf.write("\7\22\u0149\n\22\f\22\16\22\u014c\13\22\3\22\3\22\3\23")
+        buf.write("\3\23\3\23\3\23\5\23\u0154\n\23\5\23\u0156\n\23\3\24\3")
+        buf.write("\24\5\24\u015a\n\24\3\25\3\25\3\25\3\25\7\25\u0160\n\25")
+        buf.write("\f\25\16\25\u0163\13\25\3\25\3\25\3\26\3\26\5\26\u0169")
+        buf.write("\n\26\3\27\3\27\3\27\3\27\7\27\u016f\n\27\f\27\16\27\u0172")
+        buf.write("\13\27\3\27\5\27\u0175\n\27\3\30\3\30\3\30\7\30\u017a")
+        buf.write("\n\30\f\30\16\30\u017d\13\30\5\30\u017f\n\30\3\31\3\31")
+        buf.write("\3\31\5\31\u0184\n\31\3\32\3\32\3\32\7\32\u0189\n\32\f")
+        buf.write("\32\16\32\u018c\13\32\3\33\3\33\3\33\3\33\3\34\3\34\3")
+        buf.write("\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\6\34\u019d")
+        buf.write("\n\34\r\34\16\34\u019e\3\34\3\34\3\34\3\34\3\34\3\34\3")
+        buf.write("\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\3\34\5\34\u01b0")
+        buf.write("\n\34\3\34\3\34\3\34\3\34\7\34\u01b6\n\34\f\34\16\34\u01b9")
+        buf.write("\13\34\5\34\u01bb\n\34\3\34\3\34\3\34\3\34\5\34\u01c1")
+        buf.write("\n\34\3\35\3\35\3\35\3\35\7\35\u01c7\n\35\f\35\16\35\u01ca")
+        buf.write("\13\35\3\35\3\35\3\36\3\36\3\36\3\36\3\36\3\36\6\36\u01d4")
+        buf.write("\n\36\r\36\16\36\u01d5\3\36\3\36\3\36\5\36\u01db\n\36")
+        buf.write("\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3\37\3 \3 \3 \3 \3")
+        buf.write(" \3 \5 \u01eb\n \3!\3!\3!\3!\3\"\3\"\3\"\5\"\u01f4\n\"")
+        buf.write("\3#\3#\3#\3#\5#\u01fa\n#\3#\2\3\20$\2\4\6\b\n\f\16\20")
+        buf.write("\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BD\2\b")
+        buf.write("\4\2\6\6//\3\2$%\3\2&\'\3\2(+\3\2,-\3\2\32\33\2\u022d")
+        buf.write("\2F\3\2\2\2\4U\3\2\2\2\6]\3\2\2\2\b`\3\2\2\2\nc\3\2\2")
+        buf.write("\2\fn\3\2\2\2\16z\3\2\2\2\20\u00c4\3\2\2\2\22\u00e2\3")
+        buf.write("\2\2\2\24\u010e\3\2\2\2\26\u0110\3\2\2\2\30\u0112\3\2")
+        buf.write("\2\2\32\u011d\3\2\2\2\34\u012b\3\2\2\2\36\u0136\3\2\2")
+        buf.write("\2 \u0142\3\2\2\2\"\u0144\3\2\2\2$\u0155\3\2\2\2&\u0157")
+        buf.write("\3\2\2\2(\u015b\3\2\2\2*\u0168\3\2\2\2,\u0174\3\2\2\2")
+        buf.write(".\u017e\3\2\2\2\60\u0180\3\2\2\2\62\u0185\3\2\2\2\64\u018d")
+        buf.write("\3\2\2\2\66\u01c0\3\2\2\28\u01c2\3\2\2\2:\u01da\3\2\2")
+        buf.write("\2<\u01dc\3\2\2\2>\u01ea\3\2\2\2@\u01ec\3\2\2\2B\u01f3")
+        buf.write("\3\2\2\2D\u01f9\3\2\2\2FN\7\37\2\2GI\5\24\13\2HG\3\2\2")
+        buf.write("\2IL\3\2\2\2JH\3\2\2\2JK\3\2\2\2KO\3\2\2\2LJ\3\2\2\2M")
+        buf.write("O\5\20\t\2NJ\3\2\2\2NM\3\2\2\2OQ\3\2\2\2PR\7\62\2\2QP")
+        buf.write("\3\2\2\2QR\3\2\2\2RS\3\2\2\2ST\7\2\2\3T\3\3\2\2\2UZ\7")
+        buf.write("/\2\2VW\7\3\2\2WY\7/\2\2XV\3\2\2\2Y\\\3\2\2\2ZX\3\2\2")
+        buf.write("\2Z[\3\2\2\2[\5\3\2\2\2\\Z\3\2\2\2]^\7\4\2\2^_\7/\2\2")
+        buf.write("_\7\3\2\2\2`a\7\5\2\2ab\t\2\2\2b\t\3\2\2\2cd\7\5\2\2d")
+        buf.write("e\7\61\2\2e\13\3\2\2\2fk\5\20\t\2gh\7\7\2\2hj\5\20\t\2")
+        buf.write("ig\3\2\2\2jm\3\2\2\2ki\3\2\2\2kl\3\2\2\2lo\3\2\2\2mk\3")
+        buf.write("\2\2\2nf\3\2\2\2no\3\2\2\2o\r\3\2\2\2p{\5\f\7\2qr\5\20")
+        buf.write("\t\2rs\7\7\2\2su\3\2\2\2tq\3\2\2\2ux\3\2\2\2vt\3\2\2\2")
+        buf.write("vw\3\2\2\2wy\3\2\2\2xv\3\2\2\2y{\5\62\32\2zp\3\2\2\2z")
+        buf.write("v\3\2\2\2{\17\3\2\2\2|}\b\t\1\2}~\7\b\2\2~\177\5\20\t")
+        buf.write("\2\177\u0080\7\t\2\2\u0080\u00c5\3\2\2\2\u0081\u0082\7")
+        buf.write("\'\2\2\u0082\u00c5\5\20\t\26\u0083\u00c5\5\22\n\2\u0084")
+        buf.write("\u0085\7\b\2\2\u0085\u00c5\7\t\2\2\u0086\u0087\7\b\2\2")
+        buf.write("\u0087\u0088\5\20\t\2\u0088\u0089\7\7\2\2\u0089\u008a")
+        buf.write("\7\t\2\2\u008a\u00c5\3\2\2\2\u008b\u008c\7\b\2\2\u008c")
+        buf.write("\u008f\5\20\t\2\u008d\u008e\7\7\2\2\u008e\u0090\5\20\t")
+        buf.write("\2\u008f\u008d\3\2\2\2\u0090\u0091\3\2\2\2\u0091\u008f")
+        buf.write("\3\2\2\2\u0091\u0092\3\2\2\2\u0092\u0093\3\2\2\2\u0093")
+        buf.write("\u0094\7\t\2\2\u0094\u00c5\3\2\2\2\u0095\u009e\7\n\2\2")
+        buf.write("\u0096\u009b\5\20\t\2\u0097\u0098\7\7\2\2\u0098\u009a")
+        buf.write("\5\20\t\2\u0099\u0097\3\2\2\2\u009a\u009d\3\2\2\2\u009b")
+        buf.write("\u0099\3\2\2\2\u009b\u009c\3\2\2\2\u009c\u009f\3\2\2\2")
+        buf.write("\u009d\u009b\3\2\2\2\u009e\u0096\3\2\2\2\u009e\u009f\3")
+        buf.write("\2\2\2\u009f\u00a0\3\2\2\2\u00a0\u00c5\7\13\2\2\u00a1")
+        buf.write("\u00a2\7\f\2\2\u00a2\u00a3\7\b\2\2\u00a3\u00a4\5\20\t")
+        buf.write("\2\u00a4\u00a5\7\t\2\2\u00a5\u00a6\5@!\2\u00a6\u00a7\7")
+        buf.write("\r\2\2\u00a7\u00a8\5@!\2\u00a8\u00c5\3\2\2\2\u00a9\u00aa")
+        buf.write("\5 \21\2\u00aa\u00ab\7\b\2\2\u00ab\u00ac\5\20\t\2\u00ac")
+        buf.write("\u00ad\7\t\2\2\u00ad\u00af\7\16\2\2\u00ae\u00b0\5\34\17")
+        buf.write("\2\u00af\u00ae\3\2\2\2\u00af\u00b0\3\2\2\2\u00b0\u00b1")
+        buf.write("\3\2\2\2\u00b1\u00b2\7\17\2\2\u00b2\u00c5\3\2\2\2\u00b3")
+        buf.write("\u00b4\7\20\2\2\u00b4\u00b5\5\60\31\2\u00b5\u00b6\7\21")
+        buf.write("\2\2\u00b6\u00b7\5\20\t\2\u00b7\u00b8\7\22\2\2\u00b8\u00b9")
+        buf.write("\5\20\t\t\u00b9\u00c5\3\2\2\2\u00ba\u00bb\5\n\6\2\u00bb")
+        buf.write("\u00bc\7\21\2\2\u00bc\u00bd\5\20\t\2\u00bd\u00be\7\22")
+        buf.write("\2\2\u00be\u00bf\5\20\t\7\u00bf\u00c5\3\2\2\2\u00c0\u00c5")
+        buf.write("\5D#\2\u00c1\u00c5\5B\"\2\u00c2\u00c5\5<\37\2\u00c3\u00c5")
+        buf.write("\7#\2\2\u00c4|\3\2\2\2\u00c4\u0081\3\2\2\2\u00c4\u0083")
+        buf.write("\3\2\2\2\u00c4\u0084\3\2\2\2\u00c4\u0086\3\2\2\2\u00c4")
+        buf.write("\u008b\3\2\2\2\u00c4\u0095\3\2\2\2\u00c4\u00a1\3\2\2\2")
+        buf.write("\u00c4\u00a9\3\2\2\2\u00c4\u00b3\3\2\2\2\u00c4\u00ba\3")
+        buf.write("\2\2\2\u00c4\u00c0\3\2\2\2\u00c4\u00c1\3\2\2\2\u00c4\u00c2")
+        buf.write("\3\2\2\2\u00c4\u00c3\3\2\2\2\u00c5\u00df\3\2\2\2\u00c6")
+        buf.write("\u00c7\f\25\2\2\u00c7\u00c8\t\3\2\2\u00c8\u00de\5\20\t")
+        buf.write("\26\u00c9\u00ca\f\24\2\2\u00ca\u00cb\t\4\2\2\u00cb\u00de")
+        buf.write("\5\20\t\25\u00cc\u00cd\f\23\2\2\u00cd\u00ce\t\5\2\2\u00ce")
+        buf.write("\u00de\5\20\t\24\u00cf\u00d0\f\22\2\2\u00d0\u00d1\t\6")
+        buf.write("\2\2\u00d1\u00de\5\20\t\23\u00d2\u00d3\f\b\2\2\u00d3\u00d4")
+        buf.write("\7\23\2\2\u00d4\u00de\5\20\t\t\u00d5\u00d6\f\27\2\2\u00d6")
+        buf.write("\u00d7\7\b\2\2\u00d7\u00d8\5\16\b\2\u00d8\u00d9\7\t\2")
+        buf.write("\2\u00d9\u00de\3\2\2\2\u00da\u00db\f\n\2\2\u00db\u00dc")
+        buf.write("\7\3\2\2\u00dc\u00de\7\61\2\2\u00dd\u00c6\3\2\2\2\u00dd")
+        buf.write("\u00c9\3\2\2\2\u00dd\u00cc\3\2\2\2\u00dd\u00cf\3\2\2\2")
+        buf.write("\u00dd\u00d2\3\2\2\2\u00dd\u00d5\3\2\2\2\u00dd\u00da\3")
+        buf.write("\2\2\2\u00de\u00e1\3\2\2\2\u00df\u00dd\3\2\2\2\u00df\u00e0")
+        buf.write("\3\2\2\2\u00e0\21\3\2\2\2\u00e1\u00df\3\2\2\2\u00e2\u00e4")
+        buf.write("\7\24\2\2\u00e3\u00e5\58\35\2\u00e4\u00e3\3\2\2\2\u00e4")
+        buf.write("\u00e5\3\2\2\2\u00e5\u00e6\3\2\2\2\u00e6\u00e7\7\b\2\2")
+        buf.write("\u00e7\u00e8\5,\27\2\u00e8\u00eb\7\t\2\2\u00e9\u00ea\7")
+        buf.write("\25\2\2\u00ea\u00ec\5\66\34\2\u00eb\u00e9\3\2\2\2\u00eb")
+        buf.write("\u00ec\3\2\2\2\u00ec\u00ed\3\2\2\2\u00ed\u00ee\5@!\2\u00ee")
+        buf.write("\23\3\2\2\2\u00ef\u00f0\7\26\2\2\u00f0\u00f2\5\6\4\2\u00f1")
+        buf.write("\u00f3\58\35\2\u00f2\u00f1\3\2\2\2\u00f2\u00f3\3\2\2\2")
+        buf.write("\u00f3\u00f4\3\2\2\2\u00f4\u00f5\7\b\2\2\u00f5\u00f6\5")
+        buf.write(",\27\2\u00f6\u00f9\7\t\2\2\u00f7\u00f8\7\25\2\2\u00f8")
+        buf.write("\u00fa\5\66\34\2\u00f9\u00f7\3\2\2\2\u00f9\u00fa\3\2\2")
+        buf.write("\2\u00fa\u00fb\3\2\2\2\u00fb\u00fc\5@!\2\u00fc\u010f\3")
+        buf.write("\2\2\2\u00fd\u00fe\7\27\2\2\u00fe\u00ff\7\30\2\2\u00ff")
+        buf.write("\u0101\5\4\3\2\u0100\u0102\58\35\2\u0101\u0100\3\2\2\2")
+        buf.write("\u0101\u0102\3\2\2\2\u0102\u010f\3\2\2\2\u0103\u0104\7")
+        buf.write("\30\2\2\u0104\u0106\5\4\3\2\u0105\u0107\58\35\2\u0106")
+        buf.write("\u0105\3\2\2\2\u0106\u0107\3\2\2\2\u0107\u0108\3\2\2\2")
+        buf.write("\u0108\u010a\7\16\2\2\u0109\u010b\5\30\r\2\u010a\u0109")
+        buf.write("\3\2\2\2\u010a\u010b\3\2\2\2\u010b\u010c\3\2\2\2\u010c")
+        buf.write("\u010d\7\17\2\2\u010d\u010f\3\2\2\2\u010e\u00ef\3\2\2")
+        buf.write("\2\u010e\u00fd\3\2\2\2\u010e\u0103\3\2\2\2\u010f\25\3")
+        buf.write("\2\2\2\u0110\u0111\7/\2\2\u0111\27\3\2\2\2\u0112\u0117")
+        buf.write("\5\32\16\2\u0113\u0114\7\7\2\2\u0114\u0116\5\32\16\2\u0115")
+        buf.write("\u0113\3\2\2\2\u0116\u0119\3\2\2\2\u0117\u0115\3\2\2\2")
+        buf.write("\u0117\u0118\3\2\2\2\u0118\u011b\3\2\2\2\u0119\u0117\3")
+        buf.write("\2\2\2\u011a\u011c\7\7\2\2\u011b\u011a\3\2\2\2\u011b\u011c")
+        buf.write("\3\2\2\2\u011c\31\3\2\2\2\u011d\u0129\5\26\f\2\u011e\u011f")
+        buf.write("\7\b\2\2\u011f\u0124\5\66\34\2\u0120\u0121\7\7\2\2\u0121")
+        buf.write("\u0123\5\66\34\2\u0122\u0120\3\2\2\2\u0123\u0126\3\2\2")
+        buf.write("\2\u0124\u0122\3\2\2\2\u0124\u0125\3\2\2\2\u0125\u0127")
+        buf.write("\3\2\2\2\u0126\u0124\3\2\2\2\u0127\u0128\7\t\2\2\u0128")
+        buf.write("\u012a\3\2\2\2\u0129\u011e\3\2\2\2\u0129\u012a\3\2\2\2")
+        buf.write("\u012a\33\3\2\2\2\u012b\u0130\5\36\20\2\u012c\u012d\7")
+        buf.write("\7\2\2\u012d\u012f\5\36\20\2\u012e\u012c\3\2\2\2\u012f")
+        buf.write("\u0132\3\2\2\2\u0130\u012e\3\2\2\2\u0130\u0131\3\2\2\2")
+        buf.write("\u0131\u0134\3\2\2\2\u0132\u0130\3\2\2\2\u0133\u0135\7")
+        buf.write("\7\2\2\u0134\u0133\3\2\2\2\u0134\u0135\3\2\2\2\u0135\35")
+        buf.write("\3\2\2\2\u0136\u0138\5\26\f\2\u0137\u0139\5\"\22\2\u0138")
+        buf.write("\u0137\3\2\2\2\u0138\u0139\3\2\2\2\u0139\u013a\3\2\2\2")
+        buf.write("\u013a\u0140\7\31\2\2\u013b\u013c\7\16\2\2\u013c\u013d")
+        buf.write("\5\20\t\2\u013d\u013e\7\17\2\2\u013e\u0141\3\2\2\2\u013f")
+        buf.write("\u0141\5\20\t\2\u0140\u013b\3\2\2\2\u0140\u013f\3\2\2")
+        buf.write("\2\u0141\37\3\2\2\2\u0142\u0143\t\7\2\2\u0143!\3\2\2\2")
+        buf.write("\u0144\u0145\7\b\2\2\u0145\u014a\5$\23\2\u0146\u0147\7")
+        buf.write("\7\2\2\u0147\u0149\5$\23\2\u0148\u0146\3\2\2\2\u0149\u014c")
+        buf.write("\3\2\2\2\u014a\u0148\3\2\2\2\u014a\u014b\3\2\2\2\u014b")
+        buf.write("\u014d\3\2\2\2\u014c\u014a\3\2\2\2\u014d\u014e\7\t\2\2")
+        buf.write("\u014e#\3\2\2\2\u014f\u0156\7\6\2\2\u0150\u0153\5\b\5")
+        buf.write("\2\u0151\u0152\7\34\2\2\u0152\u0154\5\66\34\2\u0153\u0151")
+        buf.write("\3\2\2\2\u0153\u0154\3\2\2\2\u0154\u0156\3\2\2\2\u0155")
+        buf.write("\u014f\3\2\2\2\u0155\u0150\3\2\2\2\u0156%\3\2\2\2\u0157")
+        buf.write("\u0159\5\26\f\2\u0158\u015a\5(\25\2\u0159\u0158\3\2\2")
+        buf.write("\2\u0159\u015a\3\2\2\2\u015a\'\3\2\2\2\u015b\u015c\7\b")
+        buf.write("\2\2\u015c\u0161\5*\26\2\u015d\u015e\7\7\2\2\u015e\u0160")
+        buf.write("\5*\26\2\u015f\u015d\3\2\2\2\u0160\u0163\3\2\2\2\u0161")
+        buf.write("\u015f\3\2\2\2\u0161\u0162\3\2\2\2\u0162\u0164\3\2\2\2")
+        buf.write("\u0163\u0161\3\2\2\2\u0164\u0165\7\t\2\2\u0165)\3\2\2")
+        buf.write("\2\u0166\u0169\5\b\5\2\u0167\u0169\5\26\f\2\u0168\u0166")
+        buf.write("\3\2\2\2\u0168\u0167\3\2\2\2\u0169+\3\2\2\2\u016a\u0175")
+        buf.write("\5.\30\2\u016b\u016c\5\60\31\2\u016c\u016d\7\7\2\2\u016d")
+        buf.write("\u016f\3\2\2\2\u016e\u016b\3\2\2\2\u016f\u0172\3\2\2\2")
+        buf.write("\u0170\u016e\3\2\2\2\u0170\u0171\3\2\2\2\u0171\u0173\3")
+        buf.write("\2\2\2\u0172\u0170\3\2\2\2\u0173\u0175\5\62\32\2\u0174")
+        buf.write("\u016a\3\2\2\2\u0174\u0170\3\2\2\2\u0175-\3\2\2\2\u0176")
+        buf.write("\u017b\5\60\31\2\u0177\u0178\7\7\2\2\u0178\u017a\5\60")
+        buf.write("\31\2\u0179\u0177\3\2\2\2\u017a\u017d\3\2\2\2\u017b\u0179")
+        buf.write("\3\2\2\2\u017b\u017c\3\2\2\2\u017c\u017f\3\2\2\2\u017d")
+        buf.write("\u017b\3\2\2\2\u017e\u0176\3\2\2\2\u017e\u017f\3\2\2\2")
+        buf.write("\u017f/\3\2\2\2\u0180\u0183\5\b\5\2\u0181\u0182\7\34\2")
+        buf.write("\2\u0182\u0184\5\66\34\2\u0183\u0181\3\2\2\2\u0183\u0184")
+        buf.write("\3\2\2\2\u0184\61\3\2\2\2\u0185\u018a\5\64\33\2\u0186")
+        buf.write("\u0187\7\7\2\2\u0187\u0189\5\64\33\2\u0188\u0186\3\2\2")
+        buf.write("\2\u0189\u018c\3\2\2\2\u018a\u0188\3\2\2\2\u018a\u018b")
+        buf.write("\3\2\2\2\u018b\63\3\2\2\2\u018c\u018a\3\2\2\2\u018d\u018e")
+        buf.write("\7/\2\2\u018e\u018f\7\21\2\2\u018f\u0190\5\20\t\2\u0190")
+        buf.write("\65\3\2\2\2\u0191\u0192\7\b\2\2\u0192\u01c1\7\t\2\2\u0193")
+        buf.write("\u0194\7\b\2\2\u0194\u0195\5\66\34\2\u0195\u0196\7\7\2")
+        buf.write("\2\u0196\u0197\7\t\2\2\u0197\u01c1\3\2\2\2\u0198\u0199")
+        buf.write("\7\b\2\2\u0199\u019c\5\66\34\2\u019a\u019b\7\7\2\2\u019b")
+        buf.write("\u019d\5\66\34\2\u019c\u019a\3\2\2\2\u019d\u019e\3\2\2")
+        buf.write("\2\u019e\u019c\3\2\2\2\u019e\u019f\3\2\2\2\u019f\u01a0")
+        buf.write("\3\2\2\2\u01a0\u01a1\7\t\2\2\u01a1\u01c1\3\2\2\2\u01a2")
+        buf.write("\u01a3\5\4\3\2\u01a3\u01a4\58\35\2\u01a4\u01c1\3\2\2\2")
+        buf.write("\u01a5\u01c1\5\4\3\2\u01a6\u01a7\7\35\2\2\u01a7\u01a8")
+        buf.write("\7\n\2\2\u01a8\u01a9\5:\36\2\u01a9\u01aa\7\7\2\2\u01aa")
+        buf.write("\u01ab\5\66\34\2\u01ab\u01ac\7\13\2\2\u01ac\u01c1\3\2")
+        buf.write("\2\2\u01ad\u01af\7\24\2\2\u01ae\u01b0\58\35\2\u01af\u01ae")
+        buf.write("\3\2\2\2\u01af\u01b0\3\2\2\2\u01b0\u01b1\3\2\2\2\u01b1")
+        buf.write("\u01ba\7\b\2\2\u01b2\u01b7\5\66\34\2\u01b3\u01b4\7\7\2")
+        buf.write("\2\u01b4\u01b6\5\66\34\2\u01b5\u01b3\3\2\2\2\u01b6\u01b9")
+        buf.write("\3\2\2\2\u01b7\u01b5\3\2\2\2\u01b7\u01b8\3\2\2\2\u01b8")
+        buf.write("\u01bb\3\2\2\2\u01b9\u01b7\3\2\2\2\u01ba\u01b2\3\2\2\2")
+        buf.write("\u01ba\u01bb\3\2\2\2\u01bb\u01bc\3\2\2\2\u01bc\u01bd\7")
+        buf.write("\t\2\2\u01bd\u01be\7\25\2\2\u01be\u01c1\5\66\34\2\u01bf")
+        buf.write("\u01c1\7\6\2\2\u01c0\u0191\3\2\2\2\u01c0\u0193\3\2\2\2")
+        buf.write("\u01c0\u0198\3\2\2\2\u01c0\u01a2\3\2\2\2\u01c0\u01a5\3")
+        buf.write("\2\2\2\u01c0\u01a6\3\2\2\2\u01c0\u01ad\3\2\2\2\u01c0\u01bf")
+        buf.write("\3\2\2\2\u01c1\67\3\2\2\2\u01c2\u01c3\7\n\2\2\u01c3\u01c8")
+        buf.write("\5\4\3\2\u01c4\u01c5\7\7\2\2\u01c5\u01c7\5\4\3\2\u01c6")
+        buf.write("\u01c4\3\2\2\2\u01c7\u01ca\3\2\2\2\u01c8\u01c6\3\2\2\2")
+        buf.write("\u01c8\u01c9\3\2\2\2\u01c9\u01cb\3\2\2\2\u01ca\u01c8\3")
+        buf.write("\2\2\2\u01cb\u01cc\7\13\2\2\u01cc9\3\2\2\2\u01cd\u01ce")
+        buf.write("\7\b\2\2\u01ce\u01db\7\t\2\2\u01cf\u01d0\7\b\2\2\u01d0")
+        buf.write("\u01d3\5> \2\u01d1\u01d2\7\7\2\2\u01d2\u01d4\5> \2\u01d3")
+        buf.write("\u01d1\3\2\2\2\u01d4\u01d5\3\2\2\2\u01d5\u01d3\3\2\2\2")
+        buf.write("\u01d5\u01d6\3\2\2\2\u01d6\u01d7\3\2\2\2\u01d7\u01d8\7")
+        buf.write("\t\2\2\u01d8\u01db\3\2\2\2\u01d9\u01db\5> \2\u01da\u01cd")
+        buf.write("\3\2\2\2\u01da\u01cf\3\2\2\2\u01da\u01d9\3\2\2\2\u01db")
+        buf.write(";\3\2\2\2\u01dc\u01dd\7\36\2\2\u01dd\u01de\7\n\2\2\u01de")
+        buf.write("\u01df\7/\2\2\u01df\u01e0\7\13\2\2\u01e0\u01e1\7\n\2\2")
+        buf.write("\u01e1\u01e2\7\61\2\2\u01e2\u01e3\7\13\2\2\u01e3=\3\2")
+        buf.write("\2\2\u01e4\u01eb\5<\37\2\u01e5\u01e6\7\b\2\2\u01e6\u01e7")
+        buf.write("\5> \2\u01e7\u01e8\7\t\2\2\u01e8\u01eb\3\2\2\2\u01e9\u01eb")
+        buf.write("\7\61\2\2\u01ea\u01e4\3\2\2\2\u01ea\u01e5\3\2\2\2\u01ea")
+        buf.write("\u01e9\3\2\2\2\u01eb?\3\2\2\2\u01ec\u01ed\7\16\2\2\u01ed")
+        buf.write("\u01ee\5\20\t\2\u01ee\u01ef\7\17\2\2\u01efA\3\2\2\2\u01f0")
+        buf.write("\u01f4\7\60\2\2\u01f1\u01f4\7\61\2\2\u01f2\u01f4\7.\2")
+        buf.write("\2\u01f3\u01f0\3\2\2\2\u01f3\u01f1\3\2\2\2\u01f3\u01f2")
+        buf.write("\3\2\2\2\u01f4C\3\2\2\2\u01f5\u01fa\5\4\3\2\u01f6\u01fa")
+        buf.write("\5\6\4\2\u01f7\u01fa\5\b\5\2\u01f8\u01fa\5\n\6\2\u01f9")
+        buf.write("\u01f5\3\2\2\2\u01f9\u01f6\3\2\2\2\u01f9\u01f7\3\2\2\2")
+        buf.write("\u01f9\u01f8\3\2\2\2\u01faE\3\2\2\28JNQZknvz\u0091\u009b")
         buf.write("\u009e\u00af\u00c4\u00dd\u00df\u00e4\u00eb\u00f2\u00f9")
-        buf.write("\u0100\u0104\u0108\u0111\u0115\u011e\u0123\u012a\u012e")
-        buf.write("\u0132\u013a\u0144\u014d\u014f\u0153\u015b\u0162\u016a")
-        buf.write("\u016e\u0175\u0178\u017d\u0184\u0198\u01a9\u01b1\u01b4")
-        buf.write("\u01ba\u01c2\u01cf\u01d4\u01e4\u01ed\u01f3")
+        buf.write("\u0101\u0106\u010a\u010e\u0117\u011b\u0124\u0129\u0130")
+        buf.write("\u0134\u0138\u0140\u014a\u0153\u0155\u0159\u0161\u0168")
+        buf.write("\u0170\u0174\u017b\u017e\u0183\u018a\u019e\u01af\u01b7")
+        buf.write("\u01ba\u01c0\u01c8\u01d5\u01da\u01ea\u01f3\u01f9")
         return buf.getvalue()
 
 
@@ -267,10 +271,11 @@ class RelayParser ( Parser ):
     literalNames = [ "<INVALID>", "'.'", "'@'", "'%'", "'_'", "','", "'('", 
                      "')'", "'['", "']'", "'if'", "'else'", "'{'", "'}'", 
                      "'let'", "'='", "';'", "';;'", "'fn'", "'->'", "'def'", 
-                     "'type'", "'=>'", "'match'", "'match?'", "':'", "'Tensor'", 
-                     "'meta'", "'v0.0.4'", "<INVALID>", "<INVALID>", "<INVALID>", 
-                     "<INVALID>", "'*'", "'/'", "'+'", "'-'", "'<'", "'>'", 
-                     "'<='", "'>='", "'=='", "'!='" ]
+                     "'extern'", "'type'", "'=>'", "'match'", "'match?'", 
+                     "':'", "'Tensor'", "'meta'", "'v0.0.4'", "<INVALID>", 
+                     "<INVALID>", "<INVALID>", "<INVALID>", "'*'", "'/'", 
+                     "'+'", "'-'", "'<'", "'>'", "'<='", "'>='", "'=='", 
+                     "'!='" ]
 
     symbolicNames = [ "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
@@ -279,9 +284,10 @@ class RelayParser ( Parser ):
                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
                       "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>", 
-                      "SEMVER", "COMMENT", "WS", "LINE_COMMENT", "QUOTED_STRING", 
-                      "MUL", "DIV", "ADD", "SUB", "LT", "GT", "LE", "GE", 
-                      "EQ", "NE", "BOOL_LIT", "CNAME", "FLOAT", "NAT", "METADATA" ]
+                      "<INVALID>", "SEMVER", "COMMENT", "WS", "LINE_COMMENT", 
+                      "QUOTED_STRING", "MUL", "DIV", "ADD", "SUB", "LT", 
+                      "GT", "LE", "GE", "EQ", "NE", "BOOL_LIT", "CNAME", 
+                      "FLOAT", "NAT", "METADATA" ]
 
     RULE_prog = 0
     RULE_generalIdent = 1
@@ -354,26 +360,27 @@ class RelayParser ( Parser ):
     T__24=25
     T__25=26
     T__26=27
-    SEMVER=28
-    COMMENT=29
-    WS=30
-    LINE_COMMENT=31
-    QUOTED_STRING=32
-    MUL=33
-    DIV=34
-    ADD=35
-    SUB=36
-    LT=37
-    GT=38
-    LE=39
-    GE=40
-    EQ=41
-    NE=42
-    BOOL_LIT=43
-    CNAME=44
-    FLOAT=45
-    NAT=46
-    METADATA=47
+    T__27=28
+    SEMVER=29
+    COMMENT=30
+    WS=31
+    LINE_COMMENT=32
+    QUOTED_STRING=33
+    MUL=34
+    DIV=35
+    ADD=36
+    SUB=37
+    LT=38
+    GT=39
+    LE=40
+    GE=41
+    EQ=42
+    NE=43
+    BOOL_LIT=44
+    CNAME=45
+    FLOAT=46
+    NAT=47
+    METADATA=48
 
     def __init__(self, input:TokenStream, output:TextIO = sys.stdout):
         super().__init__(input, output)
@@ -434,11 +441,11 @@ def prog(self):
             self.state = 76
             self._errHandler.sync(self)
             token = self._input.LA(1)
-            if token in [RelayParser.EOF, RelayParser.T__19, RelayParser.T__20, RelayParser.METADATA]:
+            if token in [RelayParser.EOF, RelayParser.T__19, RelayParser.T__20, RelayParser.T__21, RelayParser.METADATA]:
                 self.state = 72
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                while _la==RelayParser.T__19 or _la==RelayParser.T__20:
+                while (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__19) | (1 << RelayParser.T__20) | (1 << RelayParser.T__21))) != 0):
                     self.state = 69
                     self.defn()
                     self.state = 74
@@ -446,7 +453,7 @@ def prog(self):
                     _la = self._input.LA(1)
 
                 pass
-            elif token in [RelayParser.T__1, RelayParser.T__2, RelayParser.T__5, RelayParser.T__7, RelayParser.T__9, RelayParser.T__13, RelayParser.T__17, RelayParser.T__22, RelayParser.T__23, RelayParser.T__26, RelayParser.QUOTED_STRING, RelayParser.SUB, RelayParser.BOOL_LIT, RelayParser.CNAME, RelayParser.FLOAT, RelayParser.NAT]:
+            elif token in [RelayParser.T__1, RelayParser.T__2, RelayParser.T__5, RelayParser.T__7, RelayParser.T__9, RelayParser.T__13, RelayParser.T__17, RelayParser.T__23, RelayParser.T__24, RelayParser.T__27, RelayParser.QUOTED_STRING, RelayParser.SUB, RelayParser.BOOL_LIT, RelayParser.CNAME, RelayParser.FLOAT, RelayParser.NAT]:
                 self.state = 75
                 self.expr(0)
                 pass
@@ -687,7 +694,7 @@ def exprList(self):
             self.state = 108
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__1) | (1 << RelayParser.T__2) | (1 << RelayParser.T__5) | (1 << RelayParser.T__7) | (1 << RelayParser.T__9) | (1 << RelayParser.T__13) | (1 << RelayParser.T__17) | (1 << RelayParser.T__22) | (1 << RelayParser.T__23) | (1 << RelayParser.T__26) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
+            if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__1) | (1 << RelayParser.T__2) | (1 << RelayParser.T__5) | (1 << RelayParser.T__7) | (1 << RelayParser.T__9) | (1 << RelayParser.T__13) | (1 << RelayParser.T__17) | (1 << RelayParser.T__23) | (1 << RelayParser.T__24) | (1 << RelayParser.T__27) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
                 self.state = 100
                 self.expr(0)
                 self.state = 105
@@ -1266,7 +1273,7 @@ def expr(self, _p:int=0):
                 self.state = 156
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__1) | (1 << RelayParser.T__2) | (1 << RelayParser.T__5) | (1 << RelayParser.T__7) | (1 << RelayParser.T__9) | (1 << RelayParser.T__13) | (1 << RelayParser.T__17) | (1 << RelayParser.T__22) | (1 << RelayParser.T__23) | (1 << RelayParser.T__26) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
+                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__1) | (1 << RelayParser.T__2) | (1 << RelayParser.T__5) | (1 << RelayParser.T__7) | (1 << RelayParser.T__9) | (1 << RelayParser.T__13) | (1 << RelayParser.T__17) | (1 << RelayParser.T__23) | (1 << RelayParser.T__24) | (1 << RelayParser.T__27) | (1 << RelayParser.QUOTED_STRING) | (1 << RelayParser.SUB) | (1 << RelayParser.BOOL_LIT) | (1 << RelayParser.CNAME) | (1 << RelayParser.FLOAT) | (1 << RelayParser.NAT))) != 0):
                     self.state = 148
                     self.expr(0)
                     self.state = 153
@@ -1637,6 +1644,26 @@ def copyFrom(self, ctx:ParserRuleContext):
 
 
 
+    class ExternAdtDefnContext(DefnContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a RelayParser.DefnContext
+            super().__init__(parser)
+            self.copyFrom(ctx)
+
+        def generalIdent(self):
+            return self.getTypedRuleContext(RelayParser.GeneralIdentContext,0)
+
+        def typeParamList(self):
+            return self.getTypedRuleContext(RelayParser.TypeParamListContext,0)
+
+
+        def accept(self, visitor:ParseTreeVisitor):
+            if hasattr( visitor, "visitExternAdtDefn" ):
+                return visitor.visitExternAdtDefn(self)
+            else:
+                return visitor.visitChildren(self)
+
+
     class FuncDefnContext(DefnContext):
 
         def __init__(self, parser, ctx:ParserRuleContext): # actually a RelayParser.DefnContext
@@ -1696,7 +1723,7 @@ def defn(self):
         self.enterRule(localctx, 18, self.RULE_defn)
         self._la = 0 # Token type
         try:
-            self.state = 262
+            self.state = 268
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [RelayParser.T__19]:
@@ -1734,31 +1761,49 @@ def defn(self):
                 self.body()
                 pass
             elif token in [RelayParser.T__20]:
-                localctx = RelayParser.AdtDefnContext(self, localctx)
+                localctx = RelayParser.ExternAdtDefnContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
                 self.state = 251
                 self.match(RelayParser.T__20)
                 self.state = 252
+                self.match(RelayParser.T__21)
+                self.state = 253
                 self.generalIdent()
-                self.state = 254
+                self.state = 255
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if _la==RelayParser.T__7:
-                    self.state = 253
+                    self.state = 254
                     self.typeParamList()
 
 
-                self.state = 256
-                self.match(RelayParser.T__11)
+                pass
+            elif token in [RelayParser.T__21]:
+                localctx = RelayParser.AdtDefnContext(self, localctx)
+                self.enterOuterAlt(localctx, 3)
+                self.state = 257
+                self.match(RelayParser.T__21)
                 self.state = 258
+                self.generalIdent()
+                self.state = 260
+                self._errHandler.sync(self)
+                _la = self._input.LA(1)
+                if _la==RelayParser.T__7:
+                    self.state = 259
+                    self.typeParamList()
+
+
+                self.state = 262
+                self.match(RelayParser.T__11)
+                self.state = 264
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if _la==RelayParser.CNAME:
-                    self.state = 257
+                    self.state = 263
                     self.adtConsDefnList()
 
 
-                self.state = 260
+                self.state = 266
                 self.match(RelayParser.T__12)
                 pass
             else:
@@ -1800,7 +1845,7 @@ def constructorName(self):
         self.enterRule(localctx, 20, self.RULE_constructorName)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 264
+            self.state = 270
             self.match(RelayParser.CNAME)
         except RecognitionException as re:
             localctx.exception = re
@@ -1843,26 +1888,26 @@ def adtConsDefnList(self):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 266
+            self.state = 272
             self.adtConsDefn()
-            self.state = 271
+            self.state = 277
             self._errHandler.sync(self)
-            _alt = self._interp.adaptivePredict(self._input,22,self._ctx)
+            _alt = self._interp.adaptivePredict(self._input,23,self._ctx)
             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                 if _alt==1:
-                    self.state = 267
+                    self.state = 273
                     self.match(RelayParser.T__4)
-                    self.state = 268
+                    self.state = 274
                     self.adtConsDefn() 
-                self.state = 273
+                self.state = 279
                 self._errHandler.sync(self)
-                _alt = self._interp.adaptivePredict(self._input,22,self._ctx)
+                _alt = self._interp.adaptivePredict(self._input,23,self._ctx)
 
-            self.state = 275
+            self.state = 281
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==RelayParser.T__4:
-                self.state = 274
+                self.state = 280
                 self.match(RelayParser.T__4)
 
 
@@ -1911,29 +1956,29 @@ def adtConsDefn(self):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 277
+            self.state = 283
             self.constructorName()
-            self.state = 289
+            self.state = 295
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==RelayParser.T__5:
-                self.state = 278
+                self.state = 284
                 self.match(RelayParser.T__5)
-                self.state = 279
+                self.state = 285
                 self.typeExpr()
-                self.state = 284
+                self.state = 290
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while _la==RelayParser.T__4:
-                    self.state = 280
+                    self.state = 286
                     self.match(RelayParser.T__4)
-                    self.state = 281
+                    self.state = 287
                     self.typeExpr()
-                    self.state = 286
+                    self.state = 292
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
-                self.state = 287
+                self.state = 293
                 self.match(RelayParser.T__6)
 
 
@@ -1978,26 +2023,26 @@ def matchClauseList(self):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 291
+            self.state = 297
             self.matchClause()
-            self.state = 296
+            self.state = 302
             self._errHandler.sync(self)
-            _alt = self._interp.adaptivePredict(self._input,26,self._ctx)
+            _alt = self._interp.adaptivePredict(self._input,27,self._ctx)
             while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:
                 if _alt==1:
-                    self.state = 292
+                    self.state = 298
                     self.match(RelayParser.T__4)
-                    self.state = 293
+                    self.state = 299
                     self.matchClause() 
-                self.state = 298
+                self.state = 304
                 self._errHandler.sync(self)
-                _alt = self._interp.adaptivePredict(self._input,26,self._ctx)
+                _alt = self._interp.adaptivePredict(self._input,27,self._ctx)
 
-            self.state = 300
+            self.state = 306
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==RelayParser.T__4:
-                self.state = 299
+                self.state = 305
                 self.match(RelayParser.T__4)
 
 
@@ -2047,31 +2092,31 @@ def matchClause(self):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 302
+            self.state = 308
             self.constructorName()
-            self.state = 304
+            self.state = 310
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==RelayParser.T__5:
-                self.state = 303
+                self.state = 309
                 self.patternList()
 
 
-            self.state = 306
-            self.match(RelayParser.T__21)
             self.state = 312
+            self.match(RelayParser.T__22)
+            self.state = 318
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [RelayParser.T__11]:
-                self.state = 307
+                self.state = 313
                 self.match(RelayParser.T__11)
-                self.state = 308
+                self.state = 314
                 self.expr(0)
-                self.state = 309
+                self.state = 315
                 self.match(RelayParser.T__12)
                 pass
-            elif token in [RelayParser.T__1, RelayParser.T__2, RelayParser.T__5, RelayParser.T__7, RelayParser.T__9, RelayParser.T__13, RelayParser.T__17, RelayParser.T__22, RelayParser.T__23, RelayParser.T__26, RelayParser.QUOTED_STRING, RelayParser.SUB, RelayParser.BOOL_LIT, RelayParser.CNAME, RelayParser.FLOAT, RelayParser.NAT]:
-                self.state = 311
+            elif token in [RelayParser.T__1, RelayParser.T__2, RelayParser.T__5, RelayParser.T__7, RelayParser.T__9, RelayParser.T__13, RelayParser.T__17, RelayParser.T__23, RelayParser.T__24, RelayParser.T__27, RelayParser.QUOTED_STRING, RelayParser.SUB, RelayParser.BOOL_LIT, RelayParser.CNAME, RelayParser.FLOAT, RelayParser.NAT]:
+                self.state = 317
                 self.expr(0)
                 pass
             else:
@@ -2112,9 +2157,9 @@ def matchType(self):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 314
+            self.state = 320
             _la = self._input.LA(1)
-            if not(_la==RelayParser.T__22 or _la==RelayParser.T__23):
+            if not(_la==RelayParser.T__23 or _la==RelayParser.T__24):
                 self._errHandler.recoverInline(self)
             else:
                 self._errHandler.reportMatch(self)
@@ -2160,23 +2205,23 @@ def patternList(self):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 316
+            self.state = 322
             self.match(RelayParser.T__5)
-            self.state = 317
+            self.state = 323
             self.pattern()
-            self.state = 322
+            self.state = 328
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==RelayParser.T__4:
-                self.state = 318
+                self.state = 324
                 self.match(RelayParser.T__4)
-                self.state = 319
+                self.state = 325
                 self.pattern()
-                self.state = 324
+                self.state = 330
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 325
+            self.state = 331
             self.match(RelayParser.T__6)
         except RecognitionException as re:
             localctx.exception = re
@@ -2219,25 +2264,25 @@ def pattern(self):
         self.enterRule(localctx, 34, self.RULE_pattern)
         self._la = 0 # Token type
         try:
-            self.state = 333
+            self.state = 339
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [RelayParser.T__3]:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 327
+                self.state = 333
                 self.match(RelayParser.T__3)
                 pass
             elif token in [RelayParser.T__2]:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 328
+                self.state = 334
                 self.localVar()
-                self.state = 331
+                self.state = 337
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if _la==RelayParser.T__24:
-                    self.state = 329
-                    self.match(RelayParser.T__24)
-                    self.state = 330
+                if _la==RelayParser.T__25:
+                    self.state = 335
+                    self.match(RelayParser.T__25)
+                    self.state = 336
                     self.typeExpr()
 
 
@@ -2287,13 +2332,13 @@ def adtCons(self):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 335
+            self.state = 341
             self.constructorName()
-            self.state = 337
+            self.state = 343
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==RelayParser.T__5:
-                self.state = 336
+                self.state = 342
                 self.adtConsParamList()
 
 
@@ -2338,23 +2383,23 @@ def adtConsParamList(self):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 339
+            self.state = 345
             self.match(RelayParser.T__5)
-            self.state = 340
+            self.state = 346
             self.adtConsParam()
-            self.state = 345
+            self.state = 351
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==RelayParser.T__4:
-                self.state = 341
+                self.state = 347
                 self.match(RelayParser.T__4)
-                self.state = 342
+                self.state = 348
                 self.adtConsParam()
-                self.state = 347
+                self.state = 353
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 348
+            self.state = 354
             self.match(RelayParser.T__6)
         except RecognitionException as re:
             localctx.exception = re
@@ -2396,17 +2441,17 @@ def adtConsParam(self):
         localctx = RelayParser.AdtConsParamContext(self, self._ctx, self.state)
         self.enterRule(localctx, 40, self.RULE_adtConsParam)
         try:
-            self.state = 352
+            self.state = 358
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [RelayParser.T__2]:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 350
+                self.state = 356
                 self.localVar()
                 pass
             elif token in [RelayParser.CNAME]:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 351
+                self.state = 357
                 self.constructorName()
                 pass
             else:
@@ -2484,32 +2529,32 @@ def argList(self):
         self.enterRule(localctx, 42, self.RULE_argList)
         self._la = 0 # Token type
         try:
-            self.state = 364
+            self.state = 370
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,37,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,38,self._ctx)
             if la_ == 1:
                 localctx = RelayParser.ArgNoAttrContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 354
+                self.state = 360
                 self.varList()
                 pass
 
             elif la_ == 2:
                 localctx = RelayParser.ArgWithAttrContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 360
+                self.state = 366
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while _la==RelayParser.T__2:
-                    self.state = 355
+                    self.state = 361
                     self.var()
-                    self.state = 356
-                    self.match(RelayParser.T__4)
                     self.state = 362
+                    self.match(RelayParser.T__4)
+                    self.state = 368
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
-                self.state = 363
+                self.state = 369
                 self.attrSeq()
                 pass
 
@@ -2555,21 +2600,21 @@ def varList(self):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 374
+            self.state = 380
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             if _la==RelayParser.T__2:
-                self.state = 366
+                self.state = 372
                 self.var()
-                self.state = 371
+                self.state = 377
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while _la==RelayParser.T__4:
-                    self.state = 367
+                    self.state = 373
                     self.match(RelayParser.T__4)
-                    self.state = 368
+                    self.state = 374
                     self.var()
-                    self.state = 373
+                    self.state = 379
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
 
@@ -2617,15 +2662,15 @@ def var(self):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 376
+            self.state = 382
             self.localVar()
-            self.state = 379
+            self.state = 385
             self._errHandler.sync(self)
             _la = self._input.LA(1)
-            if _la==RelayParser.T__24:
-                self.state = 377
-                self.match(RelayParser.T__24)
-                self.state = 378
+            if _la==RelayParser.T__25:
+                self.state = 383
+                self.match(RelayParser.T__25)
+                self.state = 384
                 self.typeExpr()
 
 
@@ -2670,17 +2715,17 @@ def attrSeq(self):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 381
+            self.state = 387
             self.attr()
-            self.state = 386
+            self.state = 392
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==RelayParser.T__4:
-                self.state = 382
+                self.state = 388
                 self.match(RelayParser.T__4)
-                self.state = 383
+                self.state = 389
                 self.attr()
-                self.state = 388
+                self.state = 394
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
@@ -2724,11 +2769,11 @@ def attr(self):
         self.enterRule(localctx, 50, self.RULE_attr)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 389
+            self.state = 395
             self.match(RelayParser.CNAME)
-            self.state = 390
+            self.state = 396
             self.match(RelayParser.T__14)
-            self.state = 391
+            self.state = 397
             self.expr(0)
         except RecognitionException as re:
             localctx.exception = re
@@ -2876,136 +2921,136 @@ def typeExpr(self):
         self.enterRule(localctx, 52, self.RULE_typeExpr)
         self._la = 0 # Token type
         try:
-            self.state = 440
+            self.state = 446
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,46,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,47,self._ctx)
             if la_ == 1:
                 localctx = RelayParser.TupleTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 393
+                self.state = 399
                 self.match(RelayParser.T__5)
-                self.state = 394
+                self.state = 400
                 self.match(RelayParser.T__6)
                 pass
 
             elif la_ == 2:
                 localctx = RelayParser.TupleTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 395
+                self.state = 401
                 self.match(RelayParser.T__5)
-                self.state = 396
+                self.state = 402
                 self.typeExpr()
-                self.state = 397
+                self.state = 403
                 self.match(RelayParser.T__4)
-                self.state = 398
+                self.state = 404
                 self.match(RelayParser.T__6)
                 pass
 
             elif la_ == 3:
                 localctx = RelayParser.TupleTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 3)
-                self.state = 400
+                self.state = 406
                 self.match(RelayParser.T__5)
-                self.state = 401
+                self.state = 407
                 self.typeExpr()
-                self.state = 404 
+                self.state = 410 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while True:
-                    self.state = 402
+                    self.state = 408
                     self.match(RelayParser.T__4)
-                    self.state = 403
+                    self.state = 409
                     self.typeExpr()
-                    self.state = 406 
+                    self.state = 412 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
                     if not (_la==RelayParser.T__4):
                         break
 
-                self.state = 408
+                self.state = 414
                 self.match(RelayParser.T__6)
                 pass
 
             elif la_ == 4:
                 localctx = RelayParser.TypeCallTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 4)
-                self.state = 410
+                self.state = 416
                 self.generalIdent()
-                self.state = 411
+                self.state = 417
                 self.typeParamList()
                 pass
 
             elif la_ == 5:
                 localctx = RelayParser.TypeIdentTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 5)
-                self.state = 413
+                self.state = 419
                 self.generalIdent()
                 pass
 
             elif la_ == 6:
                 localctx = RelayParser.TensorTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 6)
-                self.state = 414
-                self.match(RelayParser.T__25)
-                self.state = 415
+                self.state = 420
+                self.match(RelayParser.T__26)
+                self.state = 421
                 self.match(RelayParser.T__7)
-                self.state = 416
+                self.state = 422
                 self.shapeList()
-                self.state = 417
+                self.state = 423
                 self.match(RelayParser.T__4)
-                self.state = 418
+                self.state = 424
                 self.typeExpr()
-                self.state = 419
+                self.state = 425
                 self.match(RelayParser.T__8)
                 pass
 
             elif la_ == 7:
                 localctx = RelayParser.FuncTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 7)
-                self.state = 421
+                self.state = 427
                 self.match(RelayParser.T__17)
-                self.state = 423
+                self.state = 429
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 if _la==RelayParser.T__7:
-                    self.state = 422
+                    self.state = 428
                     self.typeParamList()
 
 
-                self.state = 425
+                self.state = 431
                 self.match(RelayParser.T__5)
-                self.state = 434
+                self.state = 440
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
-                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__3) | (1 << RelayParser.T__5) | (1 << RelayParser.T__17) | (1 << RelayParser.T__25) | (1 << RelayParser.CNAME))) != 0):
-                    self.state = 426
+                if (((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << RelayParser.T__3) | (1 << RelayParser.T__5) | (1 << RelayParser.T__17) | (1 << RelayParser.T__26) | (1 << RelayParser.CNAME))) != 0):
+                    self.state = 432
                     self.typeExpr()
-                    self.state = 431
+                    self.state = 437
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
                     while _la==RelayParser.T__4:
-                        self.state = 427
+                        self.state = 433
                         self.match(RelayParser.T__4)
-                        self.state = 428
+                        self.state = 434
                         self.typeExpr()
-                        self.state = 433
+                        self.state = 439
                         self._errHandler.sync(self)
                         _la = self._input.LA(1)
 
 
 
-                self.state = 436
+                self.state = 442
                 self.match(RelayParser.T__6)
-                self.state = 437
+                self.state = 443
                 self.match(RelayParser.T__18)
-                self.state = 438
+                self.state = 444
                 self.typeExpr()
                 pass
 
             elif la_ == 8:
                 localctx = RelayParser.IncompleteTypeContext(self, localctx)
                 self.enterOuterAlt(localctx, 8)
-                self.state = 439
+                self.state = 445
                 self.match(RelayParser.T__3)
                 pass
 
@@ -3051,23 +3096,23 @@ def typeParamList(self):
         self._la = 0 # Token type
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 442
+            self.state = 448
             self.match(RelayParser.T__7)
-            self.state = 443
+            self.state = 449
             self.generalIdent()
-            self.state = 448
+            self.state = 454
             self._errHandler.sync(self)
             _la = self._input.LA(1)
             while _la==RelayParser.T__4:
-                self.state = 444
+                self.state = 450
                 self.match(RelayParser.T__4)
-                self.state = 445
+                self.state = 451
                 self.generalIdent()
-                self.state = 450
+                self.state = 456
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
 
-            self.state = 451
+            self.state = 457
             self.match(RelayParser.T__8)
         except RecognitionException as re:
             localctx.exception = re
@@ -3109,44 +3154,44 @@ def shapeList(self):
         self.enterRule(localctx, 56, self.RULE_shapeList)
         self._la = 0 # Token type
         try:
-            self.state = 466
+            self.state = 472
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,49,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,50,self._ctx)
             if la_ == 1:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 453
+                self.state = 459
                 self.match(RelayParser.T__5)
-                self.state = 454
+                self.state = 460
                 self.match(RelayParser.T__6)
                 pass
 
             elif la_ == 2:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 455
+                self.state = 461
                 self.match(RelayParser.T__5)
-                self.state = 456
+                self.state = 462
                 self.shape()
-                self.state = 459 
+                self.state = 465 
                 self._errHandler.sync(self)
                 _la = self._input.LA(1)
                 while True:
-                    self.state = 457
+                    self.state = 463
                     self.match(RelayParser.T__4)
-                    self.state = 458
+                    self.state = 464
                     self.shape()
-                    self.state = 461 
+                    self.state = 467 
                     self._errHandler.sync(self)
                     _la = self._input.LA(1)
                     if not (_la==RelayParser.T__4):
                         break
 
-                self.state = 463
+                self.state = 469
                 self.match(RelayParser.T__6)
                 pass
 
             elif la_ == 3:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 465
+                self.state = 471
                 self.shape()
                 pass
 
@@ -3190,19 +3235,19 @@ def meta(self):
         self.enterRule(localctx, 58, self.RULE_meta)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 468
-            self.match(RelayParser.T__26)
-            self.state = 469
+            self.state = 474
+            self.match(RelayParser.T__27)
+            self.state = 475
             self.match(RelayParser.T__7)
-            self.state = 470
+            self.state = 476
             self.match(RelayParser.CNAME)
-            self.state = 471
+            self.state = 477
             self.match(RelayParser.T__8)
-            self.state = 472
+            self.state = 478
             self.match(RelayParser.T__7)
-            self.state = 473
+            self.state = 479
             self.match(RelayParser.NAT)
-            self.state = 474
+            self.state = 480
             self.match(RelayParser.T__8)
         except RecognitionException as re:
             localctx.exception = re
@@ -3285,29 +3330,29 @@ def shape(self):
         localctx = RelayParser.ShapeContext(self, self._ctx, self.state)
         self.enterRule(localctx, 60, self.RULE_shape)
         try:
-            self.state = 482
+            self.state = 488
             self._errHandler.sync(self)
             token = self._input.LA(1)
-            if token in [RelayParser.T__26]:
+            if token in [RelayParser.T__27]:
                 localctx = RelayParser.MetaShapeContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 476
+                self.state = 482
                 self.meta()
                 pass
             elif token in [RelayParser.T__5]:
                 localctx = RelayParser.ParensShapeContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 477
+                self.state = 483
                 self.match(RelayParser.T__5)
-                self.state = 478
+                self.state = 484
                 self.shape()
-                self.state = 479
+                self.state = 485
                 self.match(RelayParser.T__6)
                 pass
             elif token in [RelayParser.NAT]:
                 localctx = RelayParser.IntShapeContext(self, localctx)
                 self.enterOuterAlt(localctx, 3)
-                self.state = 481
+                self.state = 487
                 self.match(RelayParser.NAT)
                 pass
             else:
@@ -3350,11 +3395,11 @@ def body(self):
         self.enterRule(localctx, 62, self.RULE_body)
         try:
             self.enterOuterAlt(localctx, 1)
-            self.state = 484
+            self.state = 490
             self.match(RelayParser.T__11)
-            self.state = 485
+            self.state = 491
             self.expr(0)
-            self.state = 486
+            self.state = 492
             self.match(RelayParser.T__12)
         except RecognitionException as re:
             localctx.exception = re
@@ -3435,25 +3480,25 @@ def scalar(self):
         localctx = RelayParser.ScalarContext(self, self._ctx, self.state)
         self.enterRule(localctx, 64, self.RULE_scalar)
         try:
-            self.state = 491
+            self.state = 497
             self._errHandler.sync(self)
             token = self._input.LA(1)
             if token in [RelayParser.FLOAT]:
                 localctx = RelayParser.ScalarFloatContext(self, localctx)
                 self.enterOuterAlt(localctx, 1)
-                self.state = 488
+                self.state = 494
                 self.match(RelayParser.FLOAT)
                 pass
             elif token in [RelayParser.NAT]:
                 localctx = RelayParser.ScalarIntContext(self, localctx)
                 self.enterOuterAlt(localctx, 2)
-                self.state = 489
+                self.state = 495
                 self.match(RelayParser.NAT)
                 pass
             elif token in [RelayParser.BOOL_LIT]:
                 localctx = RelayParser.ScalarBoolContext(self, localctx)
                 self.enterOuterAlt(localctx, 3)
-                self.state = 490
+                self.state = 496
                 self.match(RelayParser.BOOL_LIT)
                 pass
             else:
@@ -3507,30 +3552,30 @@ def ident(self):
         localctx = RelayParser.IdentContext(self, self._ctx, self.state)
         self.enterRule(localctx, 66, self.RULE_ident)
         try:
-            self.state = 497
+            self.state = 503
             self._errHandler.sync(self)
-            la_ = self._interp.adaptivePredict(self._input,52,self._ctx)
+            la_ = self._interp.adaptivePredict(self._input,53,self._ctx)
             if la_ == 1:
                 self.enterOuterAlt(localctx, 1)
-                self.state = 493
+                self.state = 499
                 self.generalIdent()
                 pass
 
             elif la_ == 2:
                 self.enterOuterAlt(localctx, 2)
-                self.state = 494
+                self.state = 500
                 self.globalVar()
                 pass
 
             elif la_ == 3:
                 self.enterOuterAlt(localctx, 3)
-                self.state = 495
+                self.state = 501
                 self.localVar()
                 pass
 
             elif la_ == 4:
                 self.enterOuterAlt(localctx, 4)
-                self.state = 496
+                self.state = 502
                 self.graphVar()
                 pass
 
diff --git a/python/tvm/relay/grammar/py3/RelayVisitor.py b/python/tvm/relay/grammar/py3/RelayVisitor.py
index 0488e2a46596..98dd09fef669 100644
--- a/python/tvm/relay/grammar/py3/RelayVisitor.py
+++ b/python/tvm/relay/grammar/py3/RelayVisitor.py
@@ -139,6 +139,11 @@ def visitFuncDefn(self, ctx:RelayParser.FuncDefnContext):
         return self.visitChildren(ctx)
 
 
+    # Visit a parse tree produced by RelayParser#externAdtDefn.
+    def visitExternAdtDefn(self, ctx:RelayParser.ExternAdtDefnContext):
+        return self.visitChildren(ctx)
+
+
     # Visit a parse tree produced by RelayParser#adtDefn.
     def visitAdtDefn(self, ctx:RelayParser.AdtDefnContext):
         return self.visitChildren(ctx)
diff --git a/src/relay/ir/pretty_printer.cc b/src/relay/ir/pretty_printer.cc
index d327f17aeb29..0754f027fd74 100644
--- a/src/relay/ir/pretty_printer.cc
+++ b/src/relay/ir/pretty_printer.cc
@@ -782,8 +782,13 @@ class PrettyPrinter :
     }
     Doc separator;
     separator << "," << PrintNewLine();
-    doc << Brace(PrintSep(constructor_docs, separator) << ",");
-
+    Doc adt_body;
+    adt_body << PrintSep(constructor_docs, separator);
+    // add trailing comma if there are any constructors
+    if (!constructor_docs.empty()) {
+      adt_body << ",";
+    }
+    doc << Brace(adt_body);
     return doc;
   }
 
diff --git a/tests/python/relay/test_ir_parser.py b/tests/python/relay/test_ir_parser.py
index f924137645d4..321bf6690ae9 100644
--- a/tests/python/relay/test_ir_parser.py
+++ b/tests/python/relay/test_ir_parser.py
@@ -659,6 +659,20 @@ def test_adt_defn():
     )
 
 
+def test_empty_adt_defn():
+    mod = relay.Module()
+
+    glob_typ_var = relay.GlobalTypeVar("Ayy")
+    prog = relay.TypeData(glob_typ_var, [], [])
+    mod[glob_typ_var] = prog
+    assert parses_as(
+        """
+        type Ayy { }
+        """,
+        mod
+    )
+
+
 def test_multiple_cons_defn():
     mod = relay.Module()
 
@@ -840,6 +854,22 @@ def @id[A](%x: A) -> A { x }
     )
 
 
+def test_extern_adt_defn():
+    # TODO(weberlo): update this test once extern is implemented
+    mod = relay.Module()
+
+    extern_var = relay.GlobalTypeVar("T")
+    extern_def = relay.TypeData(extern_var, [], [])
+    mod[extern_var] = extern_def
+
+    assert parses_as(
+        """
+        extern type T
+        """,
+        mod
+    )
+
+
 if __name__ == "__main__":
     test_comments()
     test_int_literal()
@@ -864,6 +894,7 @@ def @id[A](%x: A) -> A { x }
     test_function_type()
     test_tuple_type()
     test_adt_defn()
+    test_empty_adt_defn()
     test_multiple_cons_defn()
     test_multiple_type_param_defn()
     test_match()
@@ -872,3 +903,4 @@ def @id[A](%x: A) -> A { x }
     test_duplicate_adt_cons()
     test_duplicate_adt_cons_defn()
     test_duplicate_global_var()
+    test_extern_adt_defn()

From cab55ded1a834e99fe93edcd51e5dc839487e4bc Mon Sep 17 00:00:00 2001
From: Logan Weber <weberlo@cs.washington.edu>
Date: Tue, 3 Sep 2019 18:52:17 -0700
Subject: [PATCH 25/29] Add type arg to test

---
 tests/python/relay/test_ir_parser.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/python/relay/test_ir_parser.py b/tests/python/relay/test_ir_parser.py
index 321bf6690ae9..de3ac872f998 100644
--- a/tests/python/relay/test_ir_parser.py
+++ b/tests/python/relay/test_ir_parser.py
@@ -864,7 +864,7 @@ def test_extern_adt_defn():
 
     assert parses_as(
         """
-        extern type T
+        extern type T[A]
         """,
         mod
     )

From eb43056be979d3d80584cfe7da923b62d6976a2c Mon Sep 17 00:00:00 2001
From: Logan Weber <weberlo@cs.washington.edu>
Date: Wed, 4 Sep 2019 12:20:17 -0700
Subject: [PATCH 26/29] Update prelude semantic version

---
 python/tvm/relay/prelude.rly | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/python/tvm/relay/prelude.rly b/python/tvm/relay/prelude.rly
index b0da33e66a4a..6b6047c1b0a7 100644
--- a/python/tvm/relay/prelude.rly
+++ b/python/tvm/relay/prelude.rly
@@ -16,7 +16,7 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-v0.0.3
+v0.0.4
 
 def @id[a](%x: a) -> a {
     %x

From dfd53e10c058e8a2b8cb0d10fd4b1bd1a13d23c6 Mon Sep 17 00:00:00 2001
From: Logan Weber <weberlo@cs.washington.edu>
Date: Wed, 4 Sep 2019 12:20:34 -0700
Subject: [PATCH 27/29] Repair test

---
 tests/python/relay/test_ir_parser.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/python/relay/test_ir_parser.py b/tests/python/relay/test_ir_parser.py
index de3ac872f998..198743e9eec0 100644
--- a/tests/python/relay/test_ir_parser.py
+++ b/tests/python/relay/test_ir_parser.py
@@ -859,7 +859,8 @@ def test_extern_adt_defn():
     mod = relay.Module()
 
     extern_var = relay.GlobalTypeVar("T")
-    extern_def = relay.TypeData(extern_var, [], [])
+    typ_var = relay.TypeVar("A")
+    extern_def = relay.TypeData(extern_var, [typ_var], [])
     mod[extern_var] = extern_def
 
     assert parses_as(

From 02b8150bb85091fd6edc3cb59faf82fef53aa537 Mon Sep 17 00:00:00 2001
From: Logan Weber <weberlo@cs.washington.edu>
Date: Wed, 4 Sep 2019 23:46:21 -0700
Subject: [PATCH 28/29] Fix graph var handling in match

---
 src/relay/ir/pretty_printer.cc             | 20 ++++++++------------
 tests/python/relay/test_ir_text_printer.py |  8 ++++----
 2 files changed, 12 insertions(+), 16 deletions(-)

diff --git a/src/relay/ir/pretty_printer.cc b/src/relay/ir/pretty_printer.cc
index 0754f027fd74..22bdbcbb2d6a 100644
--- a/src/relay/ir/pretty_printer.cc
+++ b/src/relay/ir/pretty_printer.cc
@@ -359,10 +359,9 @@ class PrettyPrinter :
     }
   }
 
-  // TODO(weberlo): Consolidate this method and `IsAtomic` in `pass_util.h`?
   bool AlwaysInline(const Expr& expr) {
     return expr.as<GlobalVarNode>() || expr.as<ConstantNode>() || expr.as<OpNode>() ||
-           expr.as<VarNode>() || expr.as<ConstructorNode>() || expr.as<MatchNode>();
+           expr.as<VarNode>() || expr.as<ConstructorNode>();
   }
 
   //------------------------------------
@@ -375,13 +374,10 @@ class PrettyPrinter :
     // This works since hashing uses pointer equality.
 
     // determine whether to inline
-    // TODO(weberlo): Graph vars created when not inlining exprs cause issues
-    // with scoping in clauses of match exprs.
-    bool inline_expr = true;
-    // bool inline_expr = AlwaysInline(expr);
-    // if (try_inline) {
-    //   inline_expr |= IsUnique(expr);
-    // }
+    bool inline_expr = AlwaysInline(expr);
+    if (try_inline) {
+      inline_expr |= IsUnique(expr);
+    }
 
     auto it = memo_.find(expr);
     if (it != memo_.end()) return it->second;
@@ -392,9 +388,9 @@ class PrettyPrinter :
     } else if (!inline_expr && expr.as<LetNode>()) {
       // wrap GNFed let in brackets
       Doc body;
-      printed_expr << "{";
+      printed_expr << "(";
       printed_expr << Indent(2, body << PrintNewLine() << VisitExpr(expr)) << PrintNewLine();
-      printed_expr << "}";
+      printed_expr << ")";
     } else {
       printed_expr = VisitExpr(expr);
     }
@@ -605,7 +601,7 @@ class PrettyPrinter :
     for (const auto& clause : op->clauses) {
       Doc clause_doc;
       clause_doc << PrintPattern(clause->lhs, false) << " => ";
-      Doc rhs_doc = PrintExpr(clause->rhs, false, true);
+      Doc rhs_doc = PrintScope(clause->rhs);
       if (clause->rhs.as<LetNode>()) {
         // only add braces if there are multiple lines on the rhs
         rhs_doc = Brace(rhs_doc);
diff --git a/tests/python/relay/test_ir_text_printer.py b/tests/python/relay/test_ir_text_printer.py
index 6b64ef9b48d4..a2d165b9c60b 100644
--- a/tests/python/relay/test_ir_text_printer.py
+++ b/tests/python/relay/test_ir_text_printer.py
@@ -19,11 +19,11 @@
 import tvm.relay.testing
 import numpy as np
 from tvm.relay import Expr
-from tvm.relay.analysis import alpha_equal, assert_alpha_equal, assert_graph_equal, free_vars
+from tvm.relay.analysis import alpha_equal, assert_alpha_equal, assert_is_unifiable, free_vars
 
 do_print = [False]
 
-SEMVER = "v0.0.3\n"
+SEMVER = "v0.0.4\n"
 
 def astext(p, unify_free_vars=False):
     txt = p.astext()
@@ -31,7 +31,7 @@ def astext(p, unify_free_vars=False):
         return txt
     x = relay.fromtext(txt)
     if unify_free_vars:
-        assert_graph_equal(x, p)
+        assert_is_unifiable(x, p)
     else:
         assert_alpha_equal(x, p)
     return txt
@@ -122,7 +122,7 @@ def test_let_if_scope():
 
     f = relay.Function([x, y, cond], result)
     text = astext(f)
-    assert text.count("{") == 4
+    assert text.count("{") == 3
     assert "%cond: bool" in text
     show(astext(f))
 

From 0ea68702d85fc3a1ef462ba0bb5a574d4e340141 Mon Sep 17 00:00:00 2001
From: Logan Weber <weberlo@cs.washington.edu>
Date: Thu, 5 Sep 2019 11:43:08 -0700
Subject: [PATCH 29/29] Revert 's/graph_equal/is_unifiable' change

---
 python/tvm/relay/analysis.py               |  8 ++++----
 src/relay/ir/alpha_equal.cc                |  8 ++++----
 tests/python/relay/test_ir_parser.py       | 14 +++++++-------
 tests/python/relay/test_ir_text_printer.py |  4 ++--
 4 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/python/tvm/relay/analysis.py b/python/tvm/relay/analysis.py
index d4086f014e9a..7372fcdadd17 100644
--- a/python/tvm/relay/analysis.py
+++ b/python/tvm/relay/analysis.py
@@ -254,7 +254,7 @@ def assert_alpha_equal(lhs, rhs):
     _make._assert_alpha_equal(lhs, rhs)
 
 
-def is_unifiable(lhs, rhs):
+def graph_equal(lhs, rhs):
     """Compare two Relay expr for data-flow equivalence.
     The difference between this and alpha-equality is that
     variables are not expected to match between lhs and rhs;
@@ -273,10 +273,10 @@ def is_unifiable(lhs, rhs):
     result : bool
       True iff lhs is data-flow equivalent to rhs.
     """
-    return bool(_make._is_unifiable(lhs, rhs))
+    return bool(_make._graph_equal(lhs, rhs))
 
 
-def assert_is_unifiable(lhs, rhs):
+def assert_graph_equal(lhs, rhs):
     """Compare two Relay expr for data-flow equivalence.
     The difference between this and alpha-equality is that
     variables are not expected to match between lhs and rhs;
@@ -290,7 +290,7 @@ def assert_is_unifiable(lhs, rhs):
     rhs : tvm.relay.Expr
       One of the input Expression.
     """
-    _make._assert_is_unifiable(lhs, rhs)
+    _make._assert_graph_equal(lhs, rhs)
 
 
 def collect_device_info(expr):
diff --git a/src/relay/ir/alpha_equal.cc b/src/relay/ir/alpha_equal.cc
index 6e8b28e46dc2..1f0ce80eda83 100644
--- a/src/relay/ir/alpha_equal.cc
+++ b/src/relay/ir/alpha_equal.cc
@@ -596,15 +596,15 @@ TVM_REGISTER_API("relay._make._assert_alpha_equal")
   CHECK(alpha_equal) << AsText(a, true) << " and " << AsText(b, true) << " are not alpha equal";
 });
 
-TVM_REGISTER_API("relay._make._is_unifiable")
+TVM_REGISTER_API("relay._make._graph_equal")
 .set_body_typed<bool(NodeRef, NodeRef)>([](NodeRef a, NodeRef b) {
   return AlphaEqualHandler(true, false).Equal(a, b);
 });
 
-TVM_REGISTER_API("relay._make._assert_is_unifiable")
+TVM_REGISTER_API("relay._make._assert_graph_equal")
 .set_body_typed<void(NodeRef, NodeRef)>([](NodeRef a, NodeRef b) {
-  bool is_unifiable = AlphaEqualHandler(true, true).Equal(a, b);
-  CHECK(is_unifiable) << AsText(a, true) << " and " << AsText(b, true) << " are not graph equal";
+  bool graph_equal = AlphaEqualHandler(true, true).Equal(a, b);
+  CHECK(graph_equal) << AsText(a, true) << " and " << AsText(b, true) << " are not graph equal";
 });
 
 }  // namespace relay
diff --git a/tests/python/relay/test_ir_parser.py b/tests/python/relay/test_ir_parser.py
index 198743e9eec0..cb764f1464a7 100644
--- a/tests/python/relay/test_ir_parser.py
+++ b/tests/python/relay/test_ir_parser.py
@@ -16,7 +16,7 @@
 # under the License.
 import tvm
 from tvm import relay
-from tvm.relay.analysis import is_unifiable, assert_is_unifiable
+from tvm.relay.analysis import graph_equal, assert_graph_equal
 from nose.tools import nottest, raises
 from numpy import isclose
 from typing import Union
@@ -69,7 +69,7 @@
 
 def roundtrip(expr):
     x = relay.fromtext(str(expr))
-    assert_is_unifiable(x, expr)
+    assert_graph_equal(x, expr)
 
 
 def parse_text(code):
@@ -81,7 +81,7 @@ def parse_text(code):
 def parses_as(code, expr):
     # type: (str, relay.Expr) -> bool
     parsed = parse_text(code)
-    result = is_unifiable(parsed, expr)
+    result = graph_equal(parsed, expr)
     return result
 
 def get_scalar(x):
@@ -177,13 +177,13 @@ def test_bin_op():
 
 
 def test_parens():
-    assert is_unifiable(parse_text("1 * 1 + 1"), parse_text("(1 * 1) + 1"))
-    assert not is_unifiable(parse_text("1 * 1 + 1"), parse_text("1 * (1 + 1)"))
+    assert graph_equal(parse_text("1 * 1 + 1"), parse_text("(1 * 1) + 1"))
+    assert not graph_equal(parse_text("1 * 1 + 1"), parse_text("1 * (1 + 1)"))
 
 
 def test_op_assoc():
-    assert is_unifiable(parse_text("1 * 1 + 1 < 1 == 1"), parse_text("(((1 * 1) + 1) < 1) == 1"))
-    assert is_unifiable(parse_text("1 == 1 < 1 + 1 * 1"), parse_text("1 == (1 < (1 + (1 * 1)))"))
+    assert graph_equal(parse_text("1 * 1 + 1 < 1 == 1"), parse_text("(((1 * 1) + 1) < 1) == 1"))
+    assert graph_equal(parse_text("1 == 1 < 1 + 1 * 1"), parse_text("1 == (1 < (1 + (1 * 1)))"))
 
 
 @nottest
diff --git a/tests/python/relay/test_ir_text_printer.py b/tests/python/relay/test_ir_text_printer.py
index a2d165b9c60b..0d6a02e6c8e4 100644
--- a/tests/python/relay/test_ir_text_printer.py
+++ b/tests/python/relay/test_ir_text_printer.py
@@ -19,7 +19,7 @@
 import tvm.relay.testing
 import numpy as np
 from tvm.relay import Expr
-from tvm.relay.analysis import alpha_equal, assert_alpha_equal, assert_is_unifiable, free_vars
+from tvm.relay.analysis import alpha_equal, assert_alpha_equal, assert_graph_equal, free_vars
 
 do_print = [False]
 
@@ -31,7 +31,7 @@ def astext(p, unify_free_vars=False):
         return txt
     x = relay.fromtext(txt)
     if unify_free_vars:
-        assert_is_unifiable(x, p)
+        assert_graph_equal(x, p)
     else:
         assert_alpha_equal(x, p)
     return txt