rustlr 0.3.96

trace-level set to 3
parsing grammar from ./targetfs/students/todd.grammar
76 rules in grammar
computing Nullable set
computing First sets
Generating older LALR state machine for grammar todd...
state 0:
  (0) Stmts --> .StmtList  { EOF, }
  (3) StmtList --> .  { T_INT,Integer,LAMBDA,Float,T_VOID,PRINT,DEFINE,SEMICOLON,NEGATE,LCURLYB,WHILE,LPAREN,IF,LSQUAREB,EOF,NOT,T_FLOAT,T_STRING,LET,Var,StringLit, }
  (1) Stmts --> .StmtList NonBlockExpr  { EOF, }
  (4) StmtList --> .StmtList Stmt  { NEGATE,LSQUAREB,WHILE,StringLit,T_FLOAT,DEFINE,PRINT,LAMBDA,T_INT,LCURLYB,SEMICOLON,EOF,Var,NOT,LPAREN,IF,Float,T_STRING,LET,T_VOID,Integer, }
  (5) StmtList --> .StmtList SEMICOLON  { IF,DEFINE,T_INT,SEMICOLON,NOT,EOF,T_STRING,WHILE,T_VOID,LPAREN,Var,LET,LSQUAREB,LAMBDA,Integer,NEGATE,PRINT,StringLit,T_FLOAT,LCURLYB,Float, }
  (2) Stmts --> .StmtList DefineExpr  { EOF, }
  (75) START --> .Stmts  { EOF, }
state 1:
  (53) PlusExpr --> .PlusExpr CARET TimesExpr  { EOF,GREATER,EQ,AND,NEQ,GREATEREQ,PLUS,CARET,LESSEQ,MINUS,OR,LESS,RCURLYB,SEMICOLON, }
  (5) StmtList --> StmtList .SEMICOLON  { Float,LAMBDA,DEFINE,SEMICOLON,EOF,T_INT,PRINT,Integer,T_STRING,WHILE,T_FLOAT,LCURLYB,Var,LSQUAREB,T_VOID,IF,LET,LPAREN,NEGATE,RCURLYB,NOT,StringLit, }
  (47) CompExpr --> .CompExpr LESS PlusExpr  { RCURLYB,EQ,AND,GREATEREQ,SEMICOLON,LESS,NEQ,OR,EOF,LESSEQ,GREATER, }
  (43) OrExpr --> .OrExpr OR AndExpr  { SEMICOLON,OR,RCURLYB,EOF, }
  (74) Type --> .Type LSQUAREB RSQUAREB  { LAMBDA,LSQUAREB, }
  (38) PlusExpr --> .TimesExpr  { RCURLYB,LESS,GREATEREQ,LESSEQ,AND,GREATER,SEMICOLON,PLUS,MINUS,OR,EOF,CARET,NEQ,EQ, }
  (18) BlockExpr --> .WHILE Expr DO BlockExpr  { Integer,DEFINE,IF,T_STRING,EOF,Float,LSQUAREB,T_INT,Var,NOT,LPAREN,PRINT,LET,LAMBDA,StringLit,SEMICOLON,RCURLYB,T_VOID,WHILE,T_FLOAT,NEGATE,LCURLYB, }
  (26) NonBlockExpr --> .LAMBDA ParamList DOT Expr  { RCURLYB,EOF,SEMICOLON, }
  (1) Stmts --> StmtList .NonBlockExpr  { RCURLYB,EOF, }
  (51) PlusExpr --> .PlusExpr PLUS TimesExpr  { AND,MINUS,SEMICOLON,LESS,EQ,RCURLYB,OR,LESSEQ,GREATEREQ,EOF,GREATER,PLUS,NEQ,CARET, }
  (4) StmtList --> StmtList .Stmt  { LET,EOF,IF,SEMICOLON,PRINT,LAMBDA,DEFINE,RCURLYB,NEGATE,LSQUAREB,StringLit,LCURLYB,NOT,WHILE,T_INT,Float,Var,T_VOID,LPAREN,T_STRING,Integer,T_FLOAT, }
  (71) Type --> .T_INT  { LSQUAREB,LAMBDA, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { CARET,DIV,NEQ,GREATEREQ,RCURLYB,LPAREN,SEMICOLON,LESS,OR,TIMES,EOF,AND,LSQUAREB,MINUS,EQ,MOD,GREATER,LESSEQ,PLUS, }
  (2) Stmts --> StmtList .DefineExpr  { EOF,RCURLYB, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { GREATEREQ,AND,MINUS,LESS,EOF,GREATER,OR,PLUS,LPAREN,LSQUAREB,NEQ,EQ,RCURLYB,MOD,TIMES,LESSEQ,CARET,DIV,SEMICOLON, }
  (36) EqExpr --> .CompExpr  { EQ,EOF,RCURLYB,NEQ,AND,OR,SEMICOLON, }
  (6) BlockStmt --> .LCURLYB Stmts RCURLYB  { WHILE,Var,LPAREN,LAMBDA,T_VOID,RCURLYB,NEGATE,T_STRING,DEFINE,NOT,LSQUAREB,Float,T_FLOAT,SEMICOLON,IF,EOF,LET,PRINT,StringLit,LCURLYB,T_INT,Integer, }
  (55) TimesExpr --> .TimesExpr DIV UnaryExpr  { LESS,TIMES,MINUS,DIV,PLUS,CARET,GREATEREQ,RCURLYB,GREATER,NEQ,AND,EOF,OR,EQ,LESSEQ,MOD,SEMICOLON, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { SEMICOLON,LESSEQ,TIMES,DIV,LESS,PLUS,CARET,GREATEREQ,EQ,AND,RCURLYB,EOF,MINUS,GREATER,NEQ,OR,MOD,LSQUAREB,LPAREN, }
  (44) AndExpr --> .AndExpr AND EqExpr  { EOF,SEMICOLON,RCURLYB,OR,AND, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { LESSEQ,GREATER,TIMES,RCURLYB,LESS,CARET,GREATEREQ,DIV,MINUS,EOF,SEMICOLON,AND,MOD,EQ,OR,NEQ,PLUS, }
  (17) BlockExpr --> .IF Expr THEN Expr ELSE BlockExpr  { IF,T_STRING,LSQUAREB,SEMICOLON,StringLit,NEGATE,T_FLOAT,T_VOID,LCURLYB,LPAREN,PRINT,T_INT,Integer,Float,NOT,RCURLYB,Var,LET,LAMBDA,WHILE,DEFINE,EOF, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { LSQUAREB,LESSEQ,OR,CARET,TIMES,MINUS,PLUS,EQ,SEMICOLON,GREATEREQ,EOF,GREATER,NEQ,AND,RCURLYB,DIV,LPAREN,LESS,MOD, }
  (42) RValue --> .LPAREN Expr RPAREN  { LESSEQ,MOD,PLUS,AND,GREATER,SEMICOLON,RCURLYB,TIMES,NEQ,EQ,LESS,CARET,LSQUAREB,MINUS,OR,DIV,EOF,GREATEREQ,LPAREN, }
  (49) CompExpr --> .CompExpr LESSEQ PlusExpr  { GREATEREQ,LESS,EQ,RCURLYB,AND,SEMICOLON,EOF,OR,GREATER,NEQ,LESSEQ, }
  (31) ReturnType --> .T_VOID  { LAMBDA, }
  (67) RValue --> .Float  { DIV,EOF,GREATER,AND,PLUS,MOD,LESSEQ,GREATEREQ,TIMES,RCURLYB,SEMICOLON,NEQ,LESS,MINUS,LSQUAREB,CARET,OR,LPAREN,EQ, }
  (16) BlockExpr --> .BlockStmt  { PRINT,LCURLYB,IF,T_FLOAT,Float,LSQUAREB,SEMICOLON,NEGATE,LAMBDA,LPAREN,T_INT,EOF,DEFINE,RCURLYB,Integer,T_STRING,NOT,Var,T_VOID,LET,WHILE,StringLit, }
  (66) RValue --> .Integer  { NEQ,CARET,EQ,EOF,AND,MOD,LESSEQ,GREATER,PLUS,MINUS,TIMES,GREATEREQ,LPAREN,LESS,LSQUAREB,RCURLYB,DIV,SEMICOLON,OR, }
  (35) AndExpr --> .EqExpr  { SEMICOLON,EOF,AND,RCURLYB,OR, }
  (46) EqExpr --> .EqExpr NEQ CompExpr  { EOF,SEMICOLON,RCURLYB,OR,AND,NEQ,EQ, }
  (57) UnaryExpr --> .NOT UnaryExpr  { GREATER,OR,LESS,GREATEREQ,AND,SEMICOLON,DIV,EQ,CARET,MINUS,TIMES,RCURLYB,EOF,NEQ,PLUS,MOD,LESSEQ, }
  (20) NonBlockExpr --> .IF Expr THEN Expr ELSE NonBlockExpr  { SEMICOLON,EOF,RCURLYB, }
  (45) EqExpr --> .EqExpr EQ CompExpr  { OR,AND,NEQ,RCURLYB,EOF,SEMICOLON,EQ, }
  (21) NonBlockExpr --> .WHILE Expr DO NonBlockExpr  { RCURLYB,SEMICOLON,EOF, }
  (22) NonBlockExpr --> .LET Param ASSIGN Expr IN NonBlockExpr  { SEMICOLON,RCURLYB,EOF, }
  (39) TimesExpr --> .UnaryExpr  { TIMES,GREATEREQ,OR,GREATER,LESS,PLUS,DIV,EOF,CARET,AND,SEMICOLON,MOD,MINUS,EQ,LESSEQ,RCURLYB,NEQ, }
  (40) UnaryExpr --> .LValue  { LESS,NEQ,GREATER,PLUS,MINUS,CARET,TIMES,OR,GREATEREQ,SEMICOLON,MOD,RCURLYB,LESSEQ,AND,EOF,EQ,DIV, }
  (14) Stmt --> .DefineExpr SEMICOLON  { T_FLOAT,LSQUAREB,SEMICOLON,IF,T_INT,LET,RCURLYB,Var,LCURLYB,T_VOID,EOF,NOT,WHILE,Integer,StringLit,LPAREN,NEGATE,LAMBDA,PRINT,T_STRING,DEFINE,Float, }
  (52) PlusExpr --> .PlusExpr MINUS TimesExpr  { OR,NEQ,LESSEQ,RCURLYB,AND,PLUS,LESS,GREATER,GREATEREQ,CARET,EQ,EOF,SEMICOLON,MINUS, }
  (54) TimesExpr --> .TimesExpr TIMES UnaryExpr  { OR,NEQ,GREATER,MOD,GREATEREQ,AND,LESSEQ,MINUS,LESS,EOF,DIV,PLUS,SEMICOLON,CARET,RCURLYB,TIMES,EQ, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { SEMICOLON,MINUS,GREATEREQ,LESS,EOF,LESSEQ,MOD,AND,OR,NEQ,DIV,PLUS,RCURLYB,TIMES,GREATER,EQ,CARET, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { PLUS,LESSEQ,GREATER,CARET,SEMICOLON,RCURLYB,LESS,TIMES,DIV,OR,NEQ,EQ,LSQUAREB,MINUS,MOD,AND,GREATEREQ,LPAREN,EOF, }
  (73) Type --> .T_STRING  { LSQUAREB,LAMBDA, }
  (23) NonBlockExpr --> .LValue ASSIGN Expr  { EOF,SEMICOLON,RCURLYB, }
  (27) NonBlockExpr --> .ReturnType LAMBDA ParamList DOT Expr  { SEMICOLON,EOF,RCURLYB, }
  (34) OrExpr --> .AndExpr  { OR,EOF,SEMICOLON,RCURLYB, }
  (19) BlockExpr --> .LET Param ASSIGN Expr IN BlockExpr  { Var,LPAREN,PRINT,RCURLYB,LCURLYB,LAMBDA,NOT,LSQUAREB,IF,T_INT,T_VOID,NEGATE,Float,DEFINE,LET,T_STRING,EOF,StringLit,WHILE,T_FLOAT,SEMICOLON,Integer, }
  (37) CompExpr --> .PlusExpr  { SEMICOLON,NEQ,GREATEREQ,OR,RCURLYB,AND,EOF,GREATER,LESSEQ,EQ,LESS, }
  (56) TimesExpr --> .TimesExpr MOD UnaryExpr  { AND,MOD,LESS,LESSEQ,EQ,NEQ,OR,EOF,GREATEREQ,GREATER,DIV,MINUS,SEMICOLON,TIMES,PLUS,CARET,RCURLYB, }
  (15) DefineExpr --> .DEFINE Param ASSIGN Expr  { SEMICOLON,EOF,RCURLYB, }
  (33) NonBlockExpr --> .OrExpr  { SEMICOLON,RCURLYB,EOF, }
  (48) CompExpr --> .CompExpr GREATER PlusExpr  { OR,GREATEREQ,GREATER,LESS,NEQ,SEMICOLON,AND,EOF,RCURLYB,EQ,LESSEQ, }
  (0) Stmts --> StmtList .  { RCURLYB,EOF, }
  (10) Stmt --> .NonBlockExpr SEMICOLON  { Float,T_FLOAT,EOF,WHILE,RCURLYB,DEFINE,NEGATE,NOT,IF,LCURLYB,T_STRING,Var,StringLit,LET,T_VOID,Integer,SEMICOLON,PRINT,LPAREN,T_INT,LSQUAREB,LAMBDA, }
  (68) RValue --> .StringLit  { LESSEQ,MOD,EQ,GREATEREQ,CARET,GREATER,NEQ,AND,MINUS,LSQUAREB,TIMES,OR,PLUS,LESS,EOF,LPAREN,DIV,RCURLYB,SEMICOLON, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { PLUS,LESS,TIMES,MOD,DIV,EQ,ASSIGN,NEQ,EOF,MINUS,AND,LSQUAREB,CARET,LESSEQ,OR,GREATER,SEMICOLON,GREATEREQ,LPAREN,RCURLYB, }
  (72) Type --> .T_FLOAT  { LSQUAREB,LAMBDA, }
  (32) ReturnType --> .Type  { LAMBDA, }
  (50) CompExpr --> .CompExpr GREATEREQ PlusExpr  { GREATEREQ,RCURLYB,EQ,AND,EOF,GREATER,SEMICOLON,LESS,OR,NEQ,LESSEQ, }
  (41) UnaryExpr --> .RValue  { EOF,DIV,OR,RCURLYB,SEMICOLON,GREATEREQ,MOD,GREATER,PLUS,LESS,LESSEQ,AND,MINUS,EQ,CARET,TIMES,NEQ, }
  (24) LValue --> .Var  { EOF,OR,EQ,MOD,LPAREN,LESSEQ,DIV,LESS,GREATER,GREATEREQ,PLUS,ASSIGN,LSQUAREB,CARET,MINUS,AND,SEMICOLON,NEQ,RCURLYB,TIMES, }
  (9) Stmt --> .BlockExpr  { LSQUAREB,EOF,RCURLYB,SEMICOLON,NEGATE,LAMBDA,PRINT,LCURLYB,LET,IF,Var,WHILE,Integer,DEFINE,T_FLOAT,T_VOID,NOT,Float,T_INT,LPAREN,T_STRING,StringLit, }
state 2:
  (75) START --> Stmts .  { EOF, }
state 3:
  (5) StmtList --> StmtList SEMICOLON .  { EOF,SEMICOLON,DEFINE,LPAREN,T_VOID,LET,LAMBDA,Float,LSQUAREB,PRINT,Integer,IF,StringLit,Var,LCURLYB,T_FLOAT,T_STRING,T_INT,WHILE,NOT,RCURLYB,NEGATE, }
state 4:
  (14) Stmt --> DefineExpr .SEMICOLON  { SEMICOLON,WHILE,LET,T_STRING,EOF,T_INT,Integer,StringLit,Var,LCURLYB,RCURLYB,NEGATE,T_FLOAT,PRINT,LAMBDA,Float,NOT,DEFINE,T_VOID,LSQUAREB,IF,LPAREN, }
  (2) Stmts --> StmtList DefineExpr .  { EOF,RCURLYB, }
state 5:
  (40) UnaryExpr --> .LValue  { OR,MOD,GREATER,PLUS,EQ,MINUS,LESSEQ,CARET,TIMES,LESS,NEQ,AND,DO,DIV,GREATEREQ, }
  (24) LValue --> .Var  { TIMES,GREATEREQ,PLUS,GREATER,ASSIGN,LPAREN,DO,LESSEQ,AND,DIV,OR,EQ,LESS,MOD,NEQ,LSQUAREB,CARET,MINUS, }
  (7) Expr --> .BlockExpr  { DO, }
  (48) CompExpr --> .CompExpr GREATER PlusExpr  { EQ,LESS,GREATER,AND,DO,NEQ,GREATEREQ,LESSEQ,OR, }
  (6) BlockStmt --> .LCURLYB Stmts RCURLYB  { DO, }
  (51) PlusExpr --> .PlusExpr PLUS TimesExpr  { EQ,PLUS,NEQ,CARET,AND,LESSEQ,MINUS,LESS,GREATEREQ,OR,GREATER,DO, }
  (68) RValue --> .StringLit  { PLUS,EQ,NEQ,AND,CARET,TIMES,LESSEQ,LPAREN,MINUS,LESS,LSQUAREB,GREATEREQ,OR,GREATER,DIV,MOD,DO, }
  (52) PlusExpr --> .PlusExpr MINUS TimesExpr  { CARET,OR,NEQ,DO,GREATER,GREATEREQ,MINUS,LESS,AND,PLUS,EQ,LESSEQ, }
  (42) RValue --> .LPAREN Expr RPAREN  { EQ,MINUS,PLUS,LPAREN,AND,MOD,LESS,NEQ,OR,LESSEQ,DO,GREATER,TIMES,GREATEREQ,CARET,LSQUAREB,DIV, }
  (54) TimesExpr --> .TimesExpr TIMES UnaryExpr  { DIV,TIMES,GREATEREQ,MOD,MINUS,GREATER,LESSEQ,NEQ,EQ,OR,PLUS,LESS,CARET,DO,AND, }
  (50) CompExpr --> .CompExpr GREATEREQ PlusExpr  { OR,LESSEQ,AND,EQ,DO,GREATEREQ,GREATER,NEQ,LESS, }
  (32) ReturnType --> .Type  { LAMBDA, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { GREATEREQ,GREATER,OR,DIV,EQ,CARET,MOD,DO,LESSEQ,PLUS,NEQ,LESS,MINUS,AND,TIMES, }
  (22) NonBlockExpr --> .LET Param ASSIGN Expr IN NonBlockExpr  { DO, }
  (56) TimesExpr --> .TimesExpr MOD UnaryExpr  { CARET,NEQ,TIMES,EQ,PLUS,DIV,GREATER,OR,MINUS,LESSEQ,LESS,DO,GREATEREQ,MOD,AND, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { MINUS,MOD,DIV,EQ,GREATEREQ,LESS,LESSEQ,NEQ,CARET,GREATER,OR,PLUS,AND,DO,LPAREN,TIMES,LSQUAREB, }
  (66) RValue --> .Integer  { TIMES,MINUS,DIV,MOD,AND,GREATEREQ,OR,GREATER,LESS,NEQ,LPAREN,DO,EQ,PLUS,LSQUAREB,LESSEQ,CARET, }
  (49) CompExpr --> .CompExpr LESSEQ PlusExpr  { NEQ,GREATEREQ,LESSEQ,EQ,DO,GREATER,LESS,OR,AND, }
  (33) NonBlockExpr --> .OrExpr  { DO, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { EQ,CARET,OR,DO,TIMES,GREATER,LESS,MOD,LESSEQ,LSQUAREB,LPAREN,AND,GREATEREQ,DIV,NEQ,PLUS,MINUS, }
  (45) EqExpr --> .EqExpr EQ CompExpr  { EQ,DO,AND,OR,NEQ, }
  (71) Type --> .T_INT  { LSQUAREB,LAMBDA, }
  (72) Type --> .T_FLOAT  { LAMBDA,LSQUAREB, }
  (37) CompExpr --> .PlusExpr  { NEQ,AND,GREATER,DO,GREATEREQ,OR,LESSEQ,LESS,EQ, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { EQ,OR,GREATER,AND,NEQ,MOD,DIV,DO,TIMES,LSQUAREB,LESS,CARET,LPAREN,LESSEQ,PLUS,MINUS,GREATEREQ, }
  (41) UnaryExpr --> .RValue  { GREATER,MOD,EQ,CARET,PLUS,DIV,DO,AND,GREATEREQ,TIMES,LESS,MINUS,NEQ,OR,LESSEQ, }
  (46) EqExpr --> .EqExpr NEQ CompExpr  { DO,AND,OR,EQ,NEQ, }
  (21) NonBlockExpr --> WHILE .Expr DO NonBlockExpr  { COMMA,SEMICOLON,IN,RSQUAREB,RPAREN,EOF,ELSE,RCURLYB,DO,THEN, }
  (39) TimesExpr --> .UnaryExpr  { DIV,CARET,EQ,LESS,MOD,AND,DO,MINUS,PLUS,GREATEREQ,GREATER,LESSEQ,TIMES,OR,NEQ, }
  (26) NonBlockExpr --> .LAMBDA ParamList DOT Expr  { DO, }
  (20) NonBlockExpr --> .IF Expr THEN Expr ELSE NonBlockExpr  { DO, }
  (38) PlusExpr --> .TimesExpr  { NEQ,DO,CARET,AND,LESSEQ,GREATER,PLUS,GREATEREQ,EQ,MINUS,OR,LESS, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { AND,MINUS,LESSEQ,DIV,CARET,LESS,GREATER,EQ,GREATEREQ,OR,PLUS,DO,NEQ,TIMES,MOD, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { CARET,LSQUAREB,MINUS,TIMES,EQ,MOD,LESSEQ,OR,GREATEREQ,AND,PLUS,DIV,GREATER,LPAREN,LESS,NEQ,DO, }
  (19) BlockExpr --> .LET Param ASSIGN Expr IN BlockExpr  { DO, }
  (43) OrExpr --> .OrExpr OR AndExpr  { OR,DO, }
  (16) BlockExpr --> .BlockStmt  { DO, }
  (74) Type --> .Type LSQUAREB RSQUAREB  { LSQUAREB,LAMBDA, }
  (18) BlockExpr --> .WHILE Expr DO BlockExpr  { DO, }
  (73) Type --> .T_STRING  { LSQUAREB,LAMBDA, }
  (67) RValue --> .Float  { AND,LSQUAREB,GREATER,EQ,TIMES,NEQ,LESS,DO,MINUS,LESSEQ,MOD,DIV,GREATEREQ,CARET,LPAREN,OR,PLUS, }
  (44) AndExpr --> .AndExpr AND EqExpr  { DO,OR,AND, }
  (8) Expr --> .NonBlockExpr  { DO, }
  (34) OrExpr --> .AndExpr  { DO,OR, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { DIV,MOD,DO,AND,GREATER,LESS,LPAREN,LSQUAREB,TIMES,OR,LESSEQ,GREATEREQ,NEQ,CARET,MINUS,EQ,PLUS, }
  (47) CompExpr --> .CompExpr LESS PlusExpr  { AND,LESSEQ,OR,LESS,DO,GREATER,NEQ,GREATEREQ,EQ, }
  (53) PlusExpr --> .PlusExpr CARET TimesExpr  { AND,LESS,OR,GREATER,DO,PLUS,NEQ,CARET,MINUS,GREATEREQ,LESSEQ,EQ, }
  (55) TimesExpr --> .TimesExpr DIV UnaryExpr  { DO,PLUS,MOD,CARET,NEQ,AND,OR,TIMES,LESSEQ,GREATEREQ,GREATER,DIV,EQ,LESS,MINUS, }
  (27) NonBlockExpr --> .ReturnType LAMBDA ParamList DOT Expr  { DO, }
  (23) NonBlockExpr --> .LValue ASSIGN Expr  { DO, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { MINUS,NEQ,MOD,TIMES,CARET,LESSEQ,LSQUAREB,LESS,DIV,GREATEREQ,PLUS,ASSIGN,OR,AND,LPAREN,EQ,DO,GREATER, }
  (57) UnaryExpr --> .NOT UnaryExpr  { PLUS,MINUS,LESSEQ,DO,CARET,EQ,TIMES,AND,MOD,GREATEREQ,DIV,LESS,GREATER,OR,NEQ, }
  (36) EqExpr --> .CompExpr  { NEQ,EQ,OR,DO,AND, }
  (17) BlockExpr --> .IF Expr THEN Expr ELSE BlockExpr  { DO, }
  (18) BlockExpr --> WHILE .Expr DO BlockExpr  { NEGATE,LSQUAREB,IF,DO,RCURLYB,COMMA,IN,PRINT,RSQUAREB,Float,NOT,Var,Integer,StringLit,THEN,LCURLYB,WHILE,EOF,LET,LPAREN,LAMBDA,RPAREN,T_FLOAT,ELSE,SEMICOLON,T_VOID,DEFINE,T_STRING,T_INT, }
  (21) NonBlockExpr --> .WHILE Expr DO NonBlockExpr  { DO, }
  (31) ReturnType --> .T_VOID  { LAMBDA, }
  (35) AndExpr --> .EqExpr  { DO,OR,AND, }
state 6:
  (11) Param --> .Var  { ASSIGN, }
  (22) NonBlockExpr --> LET .Param ASSIGN Expr IN NonBlockExpr  { SEMICOLON,IN,RSQUAREB,RCURLYB,ELSE,EOF,RPAREN,COMMA,THEN,DO, }
  (12) Param --> .TypedParam  { ASSIGN, }
  (13) TypedParam --> .Var COLON Type  { ASSIGN, }
  (19) BlockExpr --> LET .Param ASSIGN Expr IN BlockExpr  { Float,RSQUAREB,EOF,RCURLYB,LPAREN,WHILE,LSQUAREB,NOT,LET,IN,PRINT,LCURLYB,DEFINE,T_STRING,T_FLOAT,NEGATE,IF,DO,ELSE,THEN,T_VOID,LAMBDA,Var,RPAREN,T_INT,Integer,StringLit,SEMICOLON,COMMA, }
state 7:
  (47) CompExpr --> CompExpr .LESS PlusExpr  { AND,RCURLYB,RPAREN,IN,GREATEREQ,COMMA,EQ,LESSEQ,LESS,NEQ,OR,RSQUAREB,SEMICOLON,DO,EOF,GREATER,THEN,ELSE, }
  (48) CompExpr --> CompExpr .GREATER PlusExpr  { AND,SEMICOLON,THEN,NEQ,RSQUAREB,LESSEQ,LESS,GREATEREQ,IN,DO,ELSE,EOF,EQ,GREATER,COMMA,RCURLYB,OR,RPAREN, }
  (50) CompExpr --> CompExpr .GREATEREQ PlusExpr  { DO,SEMICOLON,LESSEQ,THEN,EQ,ELSE,GREATER,NEQ,IN,LESS,RSQUAREB,AND,EOF,RCURLYB,COMMA,OR,RPAREN,GREATEREQ, }
  (49) CompExpr --> CompExpr .LESSEQ PlusExpr  { EOF,GREATER,EQ,LESS,SEMICOLON,LESSEQ,OR,AND,ELSE,DO,RCURLYB,RPAREN,RSQUAREB,GREATEREQ,THEN,COMMA,NEQ,IN, }
  (36) EqExpr --> CompExpr .  { THEN,NEQ,ELSE,RSQUAREB,COMMA,AND,EOF,RCURLYB,IN,OR,RPAREN,DO,SEMICOLON,EQ, }
state 8:
  (54) TimesExpr --> TimesExpr .TIMES UnaryExpr  { MOD,PLUS,RPAREN,MINUS,AND,NEQ,COMMA,EOF,OR,TIMES,ELSE,CARET,EQ,LESS,LESSEQ,GREATEREQ,SEMICOLON,THEN,GREATER,IN,RSQUAREB,RCURLYB,DIV,DO, }
  (56) TimesExpr --> TimesExpr .MOD UnaryExpr  { PLUS,CARET,LESSEQ,GREATEREQ,NEQ,EQ,TIMES,ELSE,THEN,RSQUAREB,RPAREN,LESS,SEMICOLON,AND,EOF,MOD,DIV,GREATER,OR,COMMA,IN,MINUS,RCURLYB,DO, }
  (55) TimesExpr --> TimesExpr .DIV UnaryExpr  { TIMES,RSQUAREB,IN,COMMA,ELSE,DIV,NEQ,CARET,MINUS,SEMICOLON,GREATER,THEN,RCURLYB,DO,OR,EOF,LESS,LESSEQ,GREATEREQ,RPAREN,AND,PLUS,EQ,MOD, }
  (38) PlusExpr --> TimesExpr .  { LESS,DO,COMMA,SEMICOLON,IN,GREATER,GREATEREQ,LESSEQ,NEQ,MINUS,CARET,AND,THEN,EQ,RSQUAREB,EOF,RPAREN,PLUS,ELSE,RCURLYB,OR, }
state 9:
  (61) RValue --> RValue .LPAREN ArgList RPAREN  { LPAREN,GREATEREQ,EQ,SEMICOLON,NEQ,DO,GREATER,LESS,DIV,LESSEQ,THEN,EOF,ELSE,TIMES,RPAREN,CARET,MOD,OR,PLUS,RCURLYB,MINUS,RSQUAREB,AND,LSQUAREB,COMMA,IN, }
  (41) UnaryExpr --> RValue .  { TIMES,NEQ,RSQUAREB,EOF,EQ,IN,LESSEQ,SEMICOLON,COMMA,THEN,RCURLYB,RPAREN,ELSE,MINUS,LESS,GREATER,DIV,GREATEREQ,OR,AND,DO,PLUS,MOD,CARET, }
  (62) RValue --> RValue .LSQUAREB Expr RSQUAREB  { SEMICOLON,MINUS,DO,LPAREN,NEQ,MOD,LSQUAREB,GREATEREQ,RCURLYB,OR,EOF,EQ,IN,AND,GREATER,LESS,CARET,LESSEQ,TIMES,DIV,RSQUAREB,ELSE,COMMA,PLUS,THEN,RPAREN, }
state 10:
  (35) AndExpr --> EqExpr .  { THEN,EOF,OR,IN,AND,RPAREN,RSQUAREB,ELSE,DO,SEMICOLON,RCURLYB,COMMA, }
  (46) EqExpr --> EqExpr .NEQ CompExpr  { NEQ,RSQUAREB,COMMA,RCURLYB,THEN,SEMICOLON,IN,EQ,RPAREN,AND,EOF,ELSE,DO,OR, }
  (45) EqExpr --> EqExpr .EQ CompExpr  { RSQUAREB,IN,THEN,SEMICOLON,ELSE,RCURLYB,AND,EQ,RPAREN,NEQ,EOF,DO,OR,COMMA, }
state 11:
  (34) OrExpr --> AndExpr .  { RPAREN,DO,ELSE,EOF,COMMA,IN,RCURLYB,THEN,SEMICOLON,OR,RSQUAREB, }
  (44) AndExpr --> AndExpr .AND EqExpr  { SEMICOLON,OR,EOF,IN,DO,ELSE,THEN,RSQUAREB,RCURLYB,COMMA,RPAREN,AND, }
state 12:
  (9) Stmt --> BlockExpr .  { T_STRING,LCURLYB,Integer,LET,SEMICOLON,DEFINE,T_INT,LSQUAREB,EOF,PRINT,RCURLYB,StringLit,T_FLOAT,Var,NOT,WHILE,T_VOID,Float,IF,LPAREN,LAMBDA,NEGATE, }
state 13:
  (68) RValue --> StringLit .  { SEMICOLON,THEN,OR,IN,LESS,MINUS,CARET,LESSEQ,COMMA,TIMES,EOF,RSQUAREB,EQ,ELSE,GREATEREQ,NEQ,RCURLYB,RPAREN,LSQUAREB,GREATER,DO,PLUS,AND,LPAREN,MOD,DIV, }
state 14:
  (40) UnaryExpr --> LValue .  { COMMA,CARET,EQ,SEMICOLON,LESSEQ,OR,ELSE,EOF,IN,RSQUAREB,RCURLYB,PLUS,DIV,LESS,MINUS,TIMES,RPAREN,AND,THEN,DO,MOD,GREATER,NEQ,GREATEREQ, }
  (25) LValue --> LValue .LSQUAREB Expr RSQUAREB  { OR,PLUS,GREATER,DO,AND,EQ,COMMA,MOD,LPAREN,EOF,DIV,RCURLYB,THEN,GREATEREQ,RPAREN,ELSE,IN,LSQUAREB,CARET,SEMICOLON,RSQUAREB,LESSEQ,LESS,NEQ,ASSIGN,TIMES,MINUS, }
  (60) RValue --> LValue .LPAREN ArgList RPAREN  { MINUS,MOD,EOF,THEN,RPAREN,GREATEREQ,OR,CARET,AND,ELSE,RSQUAREB,PLUS,GREATER,COMMA,NEQ,IN,SEMICOLON,DIV,LESSEQ,RCURLYB,TIMES,LESS,LPAREN,LSQUAREB,EQ,DO, }
  (23) NonBlockExpr --> LValue .ASSIGN Expr  { EOF,RCURLYB,SEMICOLON,IN,RSQUAREB,ELSE,THEN,RPAREN,DO,COMMA, }
state 15:
  (51) PlusExpr --> PlusExpr .PLUS TimesExpr  { RCURLYB,AND,RPAREN,EOF,DO,CARET,OR,LESS,ELSE,GREATEREQ,RSQUAREB,LESSEQ,PLUS,THEN,NEQ,EQ,IN,MINUS,GREATER,SEMICOLON,COMMA, }
  (53) PlusExpr --> PlusExpr .CARET TimesExpr  { LESSEQ,ELSE,OR,LESS,GREATEREQ,THEN,DO,GREATER,SEMICOLON,PLUS,AND,COMMA,CARET,RSQUAREB,EOF,EQ,MINUS,RPAREN,IN,RCURLYB,NEQ, }
  (37) CompExpr --> PlusExpr .  { GREATER,EQ,RPAREN,LESS,OR,RSQUAREB,EOF,COMMA,NEQ,ELSE,AND,IN,GREATEREQ,RCURLYB,SEMICOLON,DO,LESSEQ,THEN, }
  (52) PlusExpr --> PlusExpr .MINUS TimesExpr  { RSQUAREB,EOF,RCURLYB,SEMICOLON,DO,EQ,THEN,AND,IN,COMMA,GREATEREQ,CARET,NEQ,PLUS,GREATER,LESSEQ,LESS,MINUS,RPAREN,OR,ELSE, }
state 16:
  (45) EqExpr --> .EqExpr EQ CompExpr  { OR,RPAREN,NEQ,EQ,AND, }
  (41) UnaryExpr --> .RValue  { CARET,TIMES,MINUS,GREATER,MOD,DIV,LESSEQ,RPAREN,OR,PLUS,EQ,GREATEREQ,AND,NEQ,LESS, }
  (8) Expr --> .NonBlockExpr  { RPAREN, }
  (16) BlockExpr --> .BlockStmt  { RPAREN, }
  (48) CompExpr --> .CompExpr GREATER PlusExpr  { EQ,GREATER,LESS,GREATEREQ,NEQ,OR,RPAREN,LESSEQ,AND, }
  (34) OrExpr --> .AndExpr  { RPAREN,OR, }
  (74) Type --> .Type LSQUAREB RSQUAREB  { LSQUAREB,LAMBDA, }
  (53) PlusExpr --> .PlusExpr CARET TimesExpr  { CARET,PLUS,MINUS,OR,EQ,LESS,GREATEREQ,RPAREN,LESSEQ,NEQ,GREATER,AND, }
  (67) RValue --> .Float  { EQ,GREATEREQ,TIMES,LESS,GREATER,LESSEQ,CARET,LSQUAREB,MOD,NEQ,PLUS,AND,DIV,LPAREN,MINUS,OR,RPAREN, }
  (35) AndExpr --> .EqExpr  { AND,RPAREN,OR, }
  (23) NonBlockExpr --> .LValue ASSIGN Expr  { RPAREN, }
  (22) NonBlockExpr --> .LET Param ASSIGN Expr IN NonBlockExpr  { RPAREN, }
  (6) BlockStmt --> .LCURLYB Stmts RCURLYB  { RPAREN, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { RPAREN,NEQ,MOD,LSQUAREB,MINUS,PLUS,GREATER,AND,OR,LPAREN,GREATEREQ,LESS,CARET,EQ,TIMES,DIV,LESSEQ, }
  (73) Type --> .T_STRING  { LAMBDA,LSQUAREB, }
  (56) TimesExpr --> .TimesExpr MOD UnaryExpr  { GREATER,LESS,CARET,TIMES,LESSEQ,MINUS,DIV,AND,PLUS,GREATEREQ,OR,MOD,NEQ,EQ,RPAREN, }
  (72) Type --> .T_FLOAT  { LAMBDA,LSQUAREB, }
  (43) OrExpr --> .OrExpr OR AndExpr  { OR,RPAREN, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { RPAREN,LESSEQ,PLUS,MINUS,CARET,LESS,AND,DIV,NEQ,TIMES,OR,GREATER,EQ,MOD,GREATEREQ, }
  (47) CompExpr --> .CompExpr LESS PlusExpr  { GREATER,NEQ,OR,RPAREN,AND,LESSEQ,LESS,EQ,GREATEREQ, }
  (51) PlusExpr --> .PlusExpr PLUS TimesExpr  { CARET,PLUS,LESS,RPAREN,NEQ,GREATEREQ,OR,AND,MINUS,LESSEQ,EQ,GREATER, }
  (46) EqExpr --> .EqExpr NEQ CompExpr  { NEQ,OR,AND,EQ,RPAREN, }
  (24) LValue --> .Var  { LPAREN,TIMES,ASSIGN,MOD,DIV,GREATER,NEQ,AND,LESSEQ,OR,RPAREN,MINUS,LSQUAREB,PLUS,GREATEREQ,EQ,CARET,LESS, }
  (44) AndExpr --> .AndExpr AND EqExpr  { AND,RPAREN,OR, }
  (18) BlockExpr --> .WHILE Expr DO BlockExpr  { RPAREN, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { RPAREN,MOD,LPAREN,LESSEQ,TIMES,GREATEREQ,PLUS,MINUS,LESS,GREATER,DIV,EQ,CARET,AND,LSQUAREB,NEQ,OR, }
  (50) CompExpr --> .CompExpr GREATEREQ PlusExpr  { OR,LESS,RPAREN,NEQ,GREATEREQ,GREATER,LESSEQ,AND,EQ, }
  (39) TimesExpr --> .UnaryExpr  { LESS,GREATEREQ,AND,PLUS,CARET,MINUS,GREATER,RPAREN,DIV,EQ,LESSEQ,TIMES,OR,NEQ,MOD, }
  (71) Type --> .T_INT  { LAMBDA,LSQUAREB, }
  (52) PlusExpr --> .PlusExpr MINUS TimesExpr  { CARET,AND,MINUS,GREATEREQ,LESS,EQ,PLUS,OR,NEQ,GREATER,LESSEQ,RPAREN, }
  (26) NonBlockExpr --> .LAMBDA ParamList DOT Expr  { RPAREN, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { RPAREN,GREATER,LESS,DIV,CARET,LESSEQ,AND,NEQ,PLUS,MOD,TIMES,GREATEREQ,MINUS,EQ,LPAREN,OR,LSQUAREB, }
  (68) RValue --> .StringLit  { LPAREN,AND,LSQUAREB,LESS,MINUS,PLUS,LESSEQ,GREATER,DIV,RPAREN,TIMES,NEQ,GREATEREQ,OR,MOD,CARET,EQ, }
  (36) EqExpr --> .CompExpr  { NEQ,AND,EQ,OR,RPAREN, }
  (42) RValue --> LPAREN .Expr RPAREN  { RPAREN,MINUS,EQ,LESSEQ,DIV,GREATEREQ,SEMICOLON,TIMES,LPAREN,PLUS,OR,LESS,GREATER,COMMA,NEQ,AND,LSQUAREB,RSQUAREB,DO,RCURLYB,ELSE,MOD,THEN,EOF,CARET,IN, }
  (66) RValue --> .Integer  { LSQUAREB,TIMES,NEQ,CARET,LESSEQ,LPAREN,LESS,OR,GREATER,DIV,PLUS,MOD,MINUS,EQ,RPAREN,AND,GREATEREQ, }
  (20) NonBlockExpr --> .IF Expr THEN Expr ELSE NonBlockExpr  { RPAREN, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { RPAREN,MOD,NEQ,LESS,LPAREN,AND,GREATER,LSQUAREB,PLUS,EQ,MINUS,OR,DIV,CARET,LESSEQ,TIMES,GREATEREQ, }
  (33) NonBlockExpr --> .OrExpr  { RPAREN, }
  (54) TimesExpr --> .TimesExpr TIMES UnaryExpr  { NEQ,LESSEQ,RPAREN,TIMES,GREATEREQ,OR,LESS,EQ,MINUS,DIV,CARET,AND,MOD,PLUS,GREATER, }
  (57) UnaryExpr --> .NOT UnaryExpr  { PLUS,GREATEREQ,LESS,AND,MOD,EQ,MINUS,RPAREN,CARET,GREATER,LESSEQ,NEQ,DIV,OR,TIMES, }
  (7) Expr --> .BlockExpr  { RPAREN, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { DIV,MOD,LESSEQ,NEQ,EQ,LESS,CARET,MINUS,RPAREN,PLUS,TIMES,AND,GREATER,OR,GREATEREQ, }
  (19) BlockExpr --> .LET Param ASSIGN Expr IN BlockExpr  { RPAREN, }
  (17) BlockExpr --> .IF Expr THEN Expr ELSE BlockExpr  { RPAREN, }
  (32) ReturnType --> .Type  { LAMBDA, }
  (37) CompExpr --> .PlusExpr  { AND,GREATER,RPAREN,NEQ,EQ,GREATEREQ,LESS,OR,LESSEQ, }
  (49) CompExpr --> .CompExpr LESSEQ PlusExpr  { OR,AND,LESS,GREATER,EQ,GREATEREQ,RPAREN,NEQ,LESSEQ, }
  (31) ReturnType --> .T_VOID  { LAMBDA, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { DIV,LPAREN,GREATER,PLUS,ASSIGN,RPAREN,NEQ,TIMES,MOD,GREATEREQ,AND,LESS,OR,MINUS,LSQUAREB,CARET,LESSEQ,EQ, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { TIMES,GREATER,OR,MOD,AND,LSQUAREB,LESS,RPAREN,LESSEQ,LPAREN,GREATEREQ,EQ,NEQ,DIV,PLUS,MINUS,CARET, }
  (27) NonBlockExpr --> .ReturnType LAMBDA ParamList DOT Expr  { RPAREN, }
  (55) TimesExpr --> .TimesExpr DIV UnaryExpr  { RPAREN,EQ,NEQ,LESS,GREATEREQ,MINUS,TIMES,OR,GREATER,PLUS,MOD,AND,CARET,DIV,LESSEQ, }
  (21) NonBlockExpr --> .WHILE Expr DO NonBlockExpr  { RPAREN, }
  (40) UnaryExpr --> .LValue  { GREATEREQ,PLUS,LESSEQ,AND,DIV,MOD,EQ,NEQ,OR,TIMES,LESS,CARET,MINUS,GREATER,RPAREN, }
  (42) RValue --> .LPAREN Expr RPAREN  { MOD,RPAREN,MINUS,LSQUAREB,AND,LESS,OR,DIV,CARET,PLUS,LESSEQ,GREATER,NEQ,TIMES,EQ,GREATEREQ,LPAREN, }
  (38) PlusExpr --> .TimesExpr  { OR,NEQ,CARET,LESSEQ,RPAREN,MINUS,LESS,PLUS,EQ,AND,GREATEREQ,GREATER, }
state 17:
  (40) UnaryExpr --> .LValue  { MINUS,DIV,LESS,CARET,THEN,AND,PLUS,NEQ,MOD,GREATEREQ,GREATER,TIMES,EQ,LESSEQ,OR, }
  (56) TimesExpr --> .TimesExpr MOD UnaryExpr  { MINUS,TIMES,EQ,MOD,DIV,AND,NEQ,LESSEQ,CARET,THEN,OR,PLUS,LESS,GREATEREQ,GREATER, }
  (72) Type --> .T_FLOAT  { LSQUAREB,LAMBDA, }
  (55) TimesExpr --> .TimesExpr DIV UnaryExpr  { MINUS,CARET,LESSEQ,AND,NEQ,DIV,THEN,LESS,PLUS,MOD,TIMES,EQ,OR,GREATEREQ,GREATER, }
  (38) PlusExpr --> .TimesExpr  { OR,AND,NEQ,GREATEREQ,EQ,LESS,GREATER,PLUS,LESSEQ,THEN,MINUS,CARET, }
  (49) CompExpr --> .CompExpr LESSEQ PlusExpr  { NEQ,GREATER,LESS,OR,EQ,GREATEREQ,THEN,AND,LESSEQ, }
  (32) ReturnType --> .Type  { LAMBDA, }
  (35) AndExpr --> .EqExpr  { THEN,OR,AND, }
  (66) RValue --> .Integer  { OR,LPAREN,PLUS,NEQ,TIMES,CARET,LSQUAREB,GREATER,AND,DIV,LESS,MINUS,MOD,GREATEREQ,EQ,THEN,LESSEQ, }
  (73) Type --> .T_STRING  { LSQUAREB,LAMBDA, }
  (52) PlusExpr --> .PlusExpr MINUS TimesExpr  { CARET,GREATER,AND,EQ,MINUS,GREATEREQ,NEQ,LESS,OR,LESSEQ,THEN,PLUS, }
  (37) CompExpr --> .PlusExpr  { GREATER,EQ,NEQ,THEN,AND,GREATEREQ,OR,LESSEQ,LESS, }
  (67) RValue --> .Float  { MINUS,LSQUAREB,EQ,TIMES,GREATER,NEQ,GREATEREQ,LPAREN,CARET,MOD,LESSEQ,AND,LESS,PLUS,OR,DIV,THEN, }
  (31) ReturnType --> .T_VOID  { LAMBDA, }
  (41) UnaryExpr --> .RValue  { TIMES,THEN,NEQ,LESS,DIV,MOD,AND,OR,MINUS,GREATEREQ,EQ,CARET,LESSEQ,GREATER,PLUS, }
  (48) CompExpr --> .CompExpr GREATER PlusExpr  { GREATEREQ,LESS,LESSEQ,EQ,OR,AND,NEQ,GREATER,THEN, }
  (51) PlusExpr --> .PlusExpr PLUS TimesExpr  { THEN,EQ,OR,NEQ,LESS,LESSEQ,CARET,GREATEREQ,AND,GREATER,PLUS,MINUS, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { LESS,GREATEREQ,OR,TIMES,MINUS,LSQUAREB,MOD,EQ,NEQ,PLUS,LESSEQ,CARET,AND,THEN,LPAREN,DIV,GREATER, }
  (74) Type --> .Type LSQUAREB RSQUAREB  { LSQUAREB,LAMBDA, }
  (33) NonBlockExpr --> .OrExpr  { THEN, }
  (21) NonBlockExpr --> .WHILE Expr DO NonBlockExpr  { THEN, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { EQ,AND,LESSEQ,GREATEREQ,THEN,MOD,LSQUAREB,GREATER,OR,CARET,NEQ,LPAREN,PLUS,TIMES,LESS,DIV,MINUS, }
  (17) BlockExpr --> IF .Expr THEN Expr ELSE BlockExpr  { LSQUAREB,EOF,Var,SEMICOLON,ELSE,LPAREN,DEFINE,Float,StringLit,LET,IN,PRINT,DO,LAMBDA,T_VOID,IF,T_STRING,THEN,NEGATE,COMMA,NOT,Integer,T_INT,RSQUAREB,T_FLOAT,LCURLYB,WHILE,RCURLYB,RPAREN, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { LPAREN,MINUS,CARET,LSQUAREB,THEN,DIV,GREATER,TIMES,EQ,MOD,PLUS,OR,AND,LESS,GREATEREQ,LESSEQ,NEQ, }
  (57) UnaryExpr --> .NOT UnaryExpr  { DIV,TIMES,GREATER,GREATEREQ,OR,LESS,CARET,PLUS,MINUS,AND,NEQ,LESSEQ,THEN,EQ,MOD, }
  (50) CompExpr --> .CompExpr GREATEREQ PlusExpr  { AND,GREATER,NEQ,EQ,THEN,LESSEQ,LESS,OR,GREATEREQ, }
  (20) NonBlockExpr --> IF .Expr THEN Expr ELSE NonBlockExpr  { RSQUAREB,IN,THEN,SEMICOLON,RPAREN,DO,EOF,COMMA,RCURLYB,ELSE, }
  (6) BlockStmt --> .LCURLYB Stmts RCURLYB  { THEN, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { PLUS,LESS,GREATEREQ,NEQ,CARET,MOD,LESSEQ,THEN,GREATER,MINUS,AND,OR,TIMES,EQ,DIV, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { PLUS,GREATEREQ,CARET,MOD,OR,AND,LSQUAREB,GREATER,LESSEQ,DIV,LESS,NEQ,TIMES,MINUS,THEN,EQ,LPAREN, }
  (43) OrExpr --> .OrExpr OR AndExpr  { THEN,OR, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { GREATER,TIMES,DIV,CARET,AND,ASSIGN,PLUS,THEN,MINUS,LSQUAREB,LESSEQ,LESS,EQ,LPAREN,NEQ,OR,GREATEREQ,MOD, }
  (16) BlockExpr --> .BlockStmt  { THEN, }
  (34) OrExpr --> .AndExpr  { OR,THEN, }
  (71) Type --> .T_INT  { LAMBDA,LSQUAREB, }
  (45) EqExpr --> .EqExpr EQ CompExpr  { OR,AND,THEN,EQ,NEQ, }
  (17) BlockExpr --> .IF Expr THEN Expr ELSE BlockExpr  { THEN, }
  (24) LValue --> .Var  { DIV,AND,GREATEREQ,LPAREN,MINUS,LESSEQ,OR,MOD,EQ,ASSIGN,LSQUAREB,THEN,PLUS,TIMES,GREATER,LESS,NEQ,CARET, }
  (53) PlusExpr --> .PlusExpr CARET TimesExpr  { OR,GREATER,LESS,MINUS,PLUS,NEQ,CARET,THEN,AND,EQ,LESSEQ,GREATEREQ, }
  (54) TimesExpr --> .TimesExpr TIMES UnaryExpr  { MINUS,PLUS,MOD,CARET,THEN,NEQ,GREATER,LESSEQ,AND,EQ,OR,GREATEREQ,DIV,LESS,TIMES, }
  (27) NonBlockExpr --> .ReturnType LAMBDA ParamList DOT Expr  { THEN, }
  (7) Expr --> .BlockExpr  { THEN, }
  (26) NonBlockExpr --> .LAMBDA ParamList DOT Expr  { THEN, }
  (44) AndExpr --> .AndExpr AND EqExpr  { AND,THEN,OR, }
  (22) NonBlockExpr --> .LET Param ASSIGN Expr IN NonBlockExpr  { THEN, }
  (20) NonBlockExpr --> .IF Expr THEN Expr ELSE NonBlockExpr  { THEN, }
  (39) TimesExpr --> .UnaryExpr  { GREATER,LESSEQ,NEQ,AND,TIMES,MINUS,OR,THEN,LESS,EQ,MOD,GREATEREQ,DIV,PLUS,CARET, }
  (47) CompExpr --> .CompExpr LESS PlusExpr  { GREATEREQ,EQ,THEN,OR,AND,LESS,GREATER,NEQ,LESSEQ, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { CARET,MOD,GREATER,NEQ,LESS,OR,LESSEQ,PLUS,DIV,MINUS,AND,EQ,THEN,TIMES,GREATEREQ, }
  (19) BlockExpr --> .LET Param ASSIGN Expr IN BlockExpr  { THEN, }
  (36) EqExpr --> .CompExpr  { OR,EQ,NEQ,THEN,AND, }
  (68) RValue --> .StringLit  { THEN,CARET,LESSEQ,OR,NEQ,MOD,LESS,AND,GREATEREQ,TIMES,PLUS,LSQUAREB,MINUS,LPAREN,EQ,DIV,GREATER, }
  (18) BlockExpr --> .WHILE Expr DO BlockExpr  { THEN, }
  (8) Expr --> .NonBlockExpr  { THEN, }
  (46) EqExpr --> .EqExpr NEQ CompExpr  { EQ,AND,THEN,OR,NEQ, }
  (42) RValue --> .LPAREN Expr RPAREN  { MOD,TIMES,EQ,NEQ,OR,LPAREN,AND,LESSEQ,GREATER,THEN,PLUS,LESS,LSQUAREB,CARET,MINUS,GREATEREQ,DIV, }
  (23) NonBlockExpr --> .LValue ASSIGN Expr  { THEN, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { LESS,NEQ,LESSEQ,TIMES,MINUS,EQ,GREATER,THEN,AND,CARET,GREATEREQ,MOD,LPAREN,OR,LSQUAREB,PLUS,DIV, }
state 18:
  (16) BlockExpr --> .BlockStmt  { COMMA,RSQUAREB,SEMICOLON, }
  (44) AndExpr --> .AndExpr AND EqExpr  { SEMICOLON,OR,AND,COMMA,RSQUAREB, }
  (18) BlockExpr --> .WHILE Expr DO BlockExpr  { COMMA,RSQUAREB,SEMICOLON, }
  (20) NonBlockExpr --> .IF Expr THEN Expr ELSE NonBlockExpr  { SEMICOLON,COMMA,RSQUAREB, }
  (22) NonBlockExpr --> .LET Param ASSIGN Expr IN NonBlockExpr  { RSQUAREB,COMMA,SEMICOLON, }
  (39) TimesExpr --> .UnaryExpr  { LESSEQ,OR,AND,SEMICOLON,MINUS,GREATEREQ,EQ,PLUS,NEQ,TIMES,GREATER,COMMA,LESS,MOD,RSQUAREB,CARET,DIV, }
  (72) Type --> .T_FLOAT  { LSQUAREB,LAMBDA, }
  (53) PlusExpr --> .PlusExpr CARET TimesExpr  { CARET,RSQUAREB,GREATER,PLUS,SEMICOLON,EQ,NEQ,GREATEREQ,OR,MINUS,LESS,LESSEQ,COMMA,AND, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { GREATER,LESSEQ,AND,SEMICOLON,EQ,COMMA,GREATEREQ,RSQUAREB,MOD,DIV,CARET,NEQ,LESS,TIMES,PLUS,LPAREN,OR,LSQUAREB,MINUS, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { RSQUAREB,EQ,PLUS,MINUS,DIV,COMMA,MOD,OR,LESS,GREATEREQ,TIMES,LESSEQ,AND,SEMICOLON,CARET,NEQ,GREATER, }
  (43) OrExpr --> .OrExpr OR AndExpr  { COMMA,SEMICOLON,OR,RSQUAREB, }
  (52) PlusExpr --> .PlusExpr MINUS TimesExpr  { MINUS,OR,LESSEQ,PLUS,COMMA,SEMICOLON,EQ,LESS,GREATEREQ,RSQUAREB,AND,NEQ,GREATER,CARET, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { MOD,DIV,CARET,TIMES,COMMA,SEMICOLON,RSQUAREB,OR,PLUS,NEQ,AND,LESS,LPAREN,LESSEQ,EQ,LSQUAREB,GREATEREQ,GREATER,MINUS, }
  (71) Type --> .T_INT  { LSQUAREB,LAMBDA, }
  (46) EqExpr --> .EqExpr NEQ CompExpr  { SEMICOLON,AND,NEQ,OR,RSQUAREB,COMMA,EQ, }
  (65) ArgList --> .Expr COMMA ArgList  { RSQUAREB, }
  (51) PlusExpr --> .PlusExpr PLUS TimesExpr  { NEQ,GREATER,EQ,SEMICOLON,LESSEQ,LESS,GREATEREQ,AND,MINUS,CARET,COMMA,OR,RSQUAREB,PLUS, }
  (21) NonBlockExpr --> .WHILE Expr DO NonBlockExpr  { SEMICOLON,RSQUAREB,COMMA, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { NEQ,COMMA,MINUS,MOD,SEMICOLON,OR,LPAREN,PLUS,CARET,LESSEQ,DIV,RSQUAREB,GREATEREQ,LSQUAREB,AND,TIMES,LESS,EQ,GREATER, }
  (63) ArgList --> .  { RSQUAREB, }
  (26) NonBlockExpr --> .LAMBDA ParamList DOT Expr  { COMMA,RSQUAREB,SEMICOLON, }
  (57) UnaryExpr --> .NOT UnaryExpr  { MOD,PLUS,AND,DIV,COMMA,SEMICOLON,LESSEQ,OR,CARET,EQ,TIMES,LESS,GREATER,GREATEREQ,NEQ,RSQUAREB,MINUS, }
  (31) ReturnType --> .T_VOID  { LAMBDA, }
  (45) EqExpr --> .EqExpr EQ CompExpr  { RSQUAREB,NEQ,COMMA,OR,AND,EQ,SEMICOLON, }
  (24) LValue --> .Var  { TIMES,GREATER,PLUS,NEQ,COMMA,ASSIGN,AND,RSQUAREB,SEMICOLON,LSQUAREB,LESSEQ,OR,MINUS,MOD,EQ,DIV,LESS,GREATEREQ,LPAREN,CARET, }
  (8) Expr --> .NonBlockExpr  { COMMA,RSQUAREB,SEMICOLON, }
  (55) TimesExpr --> .TimesExpr DIV UnaryExpr  { MOD,SEMICOLON,MINUS,DIV,COMMA,CARET,TIMES,OR,PLUS,LESSEQ,EQ,GREATER,GREATEREQ,NEQ,RSQUAREB,LESS,AND, }
  (49) CompExpr --> .CompExpr LESSEQ PlusExpr  { AND,OR,COMMA,NEQ,GREATEREQ,EQ,LESS,LESSEQ,RSQUAREB,SEMICOLON,GREATER, }
  (35) AndExpr --> .EqExpr  { SEMICOLON,RSQUAREB,OR,COMMA,AND, }
  (40) UnaryExpr --> .LValue  { COMMA,MINUS,TIMES,NEQ,SEMICOLON,OR,EQ,GREATEREQ,RSQUAREB,MOD,AND,DIV,LESSEQ,GREATER,CARET,PLUS,LESS, }
  (47) CompExpr --> .CompExpr LESS PlusExpr  { GREATER,COMMA,RSQUAREB,NEQ,GREATEREQ,AND,SEMICOLON,EQ,OR,LESS,LESSEQ, }
  (68) RValue --> .StringLit  { MOD,MINUS,EQ,DIV,LSQUAREB,TIMES,AND,COMMA,PLUS,LESSEQ,GREATER,GREATEREQ,NEQ,OR,SEMICOLON,LESS,CARET,LPAREN,RSQUAREB, }
  (17) BlockExpr --> .IF Expr THEN Expr ELSE BlockExpr  { SEMICOLON,COMMA,RSQUAREB, }
  (70) RValue --> LSQUAREB .Expr SEMICOLON Expr RSQUAREB  { RSQUAREB,PLUS,MINUS,MOD,SEMICOLON,CARET,LSQUAREB,AND,GREATER,TIMES,ELSE,OR,DO,IN,NEQ,GREATEREQ,COMMA,LPAREN,THEN,EOF,RCURLYB,LESSEQ,RPAREN,LESS,DIV,EQ, }
  (7) Expr --> .BlockExpr  { SEMICOLON,COMMA,RSQUAREB, }
  (50) CompExpr --> .CompExpr GREATEREQ PlusExpr  { LESSEQ,SEMICOLON,GREATEREQ,OR,AND,EQ,LESS,COMMA,RSQUAREB,NEQ,GREATER, }
  (41) UnaryExpr --> .RValue  { COMMA,LESS,TIMES,MOD,CARET,EQ,AND,DIV,NEQ,GREATER,GREATEREQ,LESSEQ,OR,MINUS,PLUS,SEMICOLON,RSQUAREB, }
  (34) OrExpr --> .AndExpr  { SEMICOLON,OR,RSQUAREB,COMMA, }
  (27) NonBlockExpr --> .ReturnType LAMBDA ParamList DOT Expr  { RSQUAREB,COMMA,SEMICOLON, }
  (38) PlusExpr --> .TimesExpr  { MINUS,RSQUAREB,CARET,EQ,GREATEREQ,AND,OR,SEMICOLON,PLUS,NEQ,COMMA,LESSEQ,GREATER,LESS, }
  (32) ReturnType --> .Type  { LAMBDA, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { LESSEQ,OR,SEMICOLON,LESS,DIV,LSQUAREB,COMMA,MINUS,PLUS,MOD,EQ,NEQ,TIMES,GREATEREQ,RSQUAREB,AND,CARET,LPAREN,GREATER, }
  (19) BlockExpr --> .LET Param ASSIGN Expr IN BlockExpr  { SEMICOLON,COMMA,RSQUAREB, }
  (74) Type --> .Type LSQUAREB RSQUAREB  { LSQUAREB,LAMBDA, }
  (64) ArgList --> .Expr  { RSQUAREB, }
  (66) RValue --> .Integer  { RSQUAREB,EQ,SEMICOLON,TIMES,GREATEREQ,MOD,MINUS,NEQ,PLUS,COMMA,LESSEQ,OR,DIV,LSQUAREB,LPAREN,CARET,GREATER,LESS,AND, }
  (33) NonBlockExpr --> .OrExpr  { COMMA,SEMICOLON,RSQUAREB, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { RSQUAREB,SEMICOLON,NEQ,LSQUAREB,GREATEREQ,MOD,EQ,PLUS,DIV,LESSEQ,AND,CARET,GREATER,TIMES,LPAREN,ASSIGN,OR,MINUS,COMMA,LESS, }
  (67) RValue --> .Float  { PLUS,SEMICOLON,LPAREN,OR,MINUS,DIV,TIMES,RSQUAREB,GREATER,LESS,NEQ,COMMA,CARET,LESSEQ,LSQUAREB,MOD,AND,EQ,GREATEREQ, }
  (6) BlockStmt --> .LCURLYB Stmts RCURLYB  { COMMA,SEMICOLON,RSQUAREB, }
  (42) RValue --> .LPAREN Expr RPAREN  { PLUS,TIMES,LPAREN,COMMA,EQ,GREATER,LSQUAREB,DIV,NEQ,LESS,GREATEREQ,MOD,OR,MINUS,AND,CARET,LESSEQ,RSQUAREB,SEMICOLON, }
  (48) CompExpr --> .CompExpr GREATER PlusExpr  { LESS,RSQUAREB,COMMA,LESSEQ,AND,NEQ,OR,EQ,SEMICOLON,GREATEREQ,GREATER, }
  (23) NonBlockExpr --> .LValue ASSIGN Expr  { COMMA,RSQUAREB,SEMICOLON, }
  (37) CompExpr --> .PlusExpr  { NEQ,GREATEREQ,EQ,OR,AND,SEMICOLON,LESSEQ,COMMA,LESS,RSQUAREB,GREATER, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { LSQUAREB,AND,MINUS,RSQUAREB,CARET,MOD,PLUS,DIV,EQ,NEQ,LESSEQ,GREATEREQ,COMMA,GREATER,LPAREN,OR,SEMICOLON,TIMES,LESS, }
  (56) TimesExpr --> .TimesExpr MOD UnaryExpr  { NEQ,GREATEREQ,OR,LESS,PLUS,MOD,RSQUAREB,AND,LESSEQ,SEMICOLON,TIMES,EQ,DIV,COMMA,GREATER,MINUS,CARET, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { CARET,SEMICOLON,TIMES,MOD,DIV,NEQ,LESSEQ,AND,COMMA,EQ,GREATEREQ,RSQUAREB,LESS,PLUS,MINUS,GREATER,OR, }
  (73) Type --> .T_STRING  { LSQUAREB,LAMBDA, }
  (36) EqExpr --> .CompExpr  { EQ,COMMA,SEMICOLON,AND,NEQ,RSQUAREB,OR, }
  (69) RValue --> LSQUAREB .ArgList RSQUAREB  { EQ,CARET,MOD,PLUS,LESSEQ,NEQ,LESS,TIMES,DO,LSQUAREB,GREATEREQ,THEN,LPAREN,EOF,IN,MINUS,RPAREN,OR,ELSE,DIV,RSQUAREB,AND,RCURLYB,SEMICOLON,COMMA,GREATER, }
  (54) TimesExpr --> .TimesExpr TIMES UnaryExpr  { CARET,LESS,GREATEREQ,MOD,EQ,DIV,AND,LESSEQ,SEMICOLON,TIMES,MINUS,RSQUAREB,NEQ,PLUS,COMMA,OR,GREATER, }
state 19:
  (39) TimesExpr --> UnaryExpr .  { THEN,MINUS,IN,EQ,AND,GREATEREQ,EOF,RCURLYB,NEQ,ELSE,LESS,GREATER,DIV,DO,CARET,LESSEQ,COMMA,PLUS,RPAREN,TIMES,SEMICOLON,RSQUAREB,OR,MOD, }
state 20:
  (4) StmtList --> StmtList Stmt .  { NEGATE,RCURLYB,SEMICOLON,Var,LPAREN,IF,NOT,LCURLYB,EOF,Integer,T_VOID,LSQUAREB,Float,StringLit,T_STRING,T_INT,WHILE,DEFINE,PRINT,T_FLOAT,LAMBDA,LET, }
state 21:
  (10) Stmt --> NonBlockExpr .SEMICOLON  { WHILE,LSQUAREB,SEMICOLON,DEFINE,LCURLYB,NOT,StringLit,T_VOID,T_FLOAT,IF,LPAREN,LAMBDA,Integer,Var,RCURLYB,Float,EOF,LET,T_STRING,T_INT,NEGATE,PRINT, }
  (1) Stmts --> StmtList NonBlockExpr .  { RCURLYB,EOF, }
state 22:
  (2) Stmts --> .StmtList DefineExpr  { RCURLYB, }
  (4) StmtList --> .StmtList Stmt  { T_VOID,StringLit,T_INT,Var,LET,Integer,LCURLYB,T_FLOAT,LPAREN,PRINT,DEFINE,WHILE,T_STRING,Float,LSQUAREB,LAMBDA,RCURLYB,NOT,NEGATE,IF,SEMICOLON, }
  (3) StmtList --> .  { T_FLOAT,DEFINE,StringLit,LSQUAREB,NEGATE,IF,WHILE,Integer,Float,LCURLYB,T_VOID,SEMICOLON,Var,LPAREN,LET,LAMBDA,NOT,T_STRING,T_INT,RCURLYB,PRINT, }
  (1) Stmts --> .StmtList NonBlockExpr  { RCURLYB, }
  (6) BlockStmt --> LCURLYB .Stmts RCURLYB  { Var,RPAREN,Integer,WHILE,LPAREN,DEFINE,ELSE,NOT,T_INT,T_FLOAT,EOF,RCURLYB,PRINT,DO,COMMA,LSQUAREB,SEMICOLON,THEN,T_STRING,IF,LET,T_VOID,LAMBDA,StringLit,NEGATE,LCURLYB,RSQUAREB,Float,IN, }
  (0) Stmts --> .StmtList  { RCURLYB, }
  (5) StmtList --> .StmtList SEMICOLON  { LSQUAREB,PRINT,RCURLYB,LET,SEMICOLON,LAMBDA,WHILE,NEGATE,Float,DEFINE,T_STRING,T_VOID,Var,T_INT,LCURLYB,T_FLOAT,IF,StringLit,LPAREN,NOT,Integer, }
state 23:
  (33) NonBlockExpr --> OrExpr .  { SEMICOLON,IN,EOF,COMMA,ELSE,DO,RPAREN,RSQUAREB,THEN,RCURLYB, }
  (43) OrExpr --> OrExpr .OR AndExpr  { OR,ELSE,RPAREN,RSQUAREB,COMMA,EOF,SEMICOLON,RCURLYB,DO,THEN,IN, }
state 24:
  (68) RValue --> .StringLit  { LPAREN,MOD,IN,OR,SEMICOLON,DIV,EQ,GREATER,LESS,RPAREN,COMMA,LESSEQ,ELSE,MINUS,THEN,NEQ,EOF,TIMES,GREATEREQ,DO,AND,LSQUAREB,CARET,PLUS,RSQUAREB,RCURLYB, }
  (24) LValue --> .Var  { GREATEREQ,COMMA,RPAREN,IN,SEMICOLON,DO,RCURLYB,MOD,TIMES,THEN,LESSEQ,MINUS,LSQUAREB,GREATER,DIV,EOF,CARET,ELSE,OR,RSQUAREB,AND,PLUS,EQ,LPAREN,NEQ,LESS, }
  (66) RValue --> .Integer  { RSQUAREB,MINUS,GREATEREQ,DO,OR,MOD,IN,CARET,PLUS,ELSE,EQ,THEN,SEMICOLON,EOF,LSQUAREB,LESSEQ,AND,LESS,GREATER,COMMA,LPAREN,RPAREN,TIMES,NEQ,RCURLYB,DIV, }
  (57) UnaryExpr --> .NOT UnaryExpr  { CARET,EQ,IN,PLUS,NEQ,COMMA,SEMICOLON,ELSE,GREATEREQ,LESS,OR,DIV,MINUS,GREATER,RCURLYB,DO,EOF,TIMES,RPAREN,THEN,AND,LESSEQ,MOD,RSQUAREB, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { NEQ,DO,SEMICOLON,CARET,RCURLYB,IN,GREATER,LESSEQ,MOD,COMMA,LESS,MINUS,EQ,RPAREN,ELSE,TIMES,EOF,GREATEREQ,RSQUAREB,PLUS,DIV,AND,OR,THEN, }
  (67) RValue --> .Float  { MOD,DO,EOF,GREATER,RPAREN,IN,SEMICOLON,OR,AND,RCURLYB,LSQUAREB,LESS,GREATEREQ,CARET,COMMA,RSQUAREB,DIV,EQ,NEQ,LESSEQ,LPAREN,ELSE,MINUS,THEN,TIMES,PLUS, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { EOF,AND,DO,PLUS,LESS,GREATEREQ,LESSEQ,TIMES,NEQ,COMMA,THEN,SEMICOLON,LPAREN,IN,RCURLYB,EQ,DIV,RSQUAREB,GREATER,MINUS,ELSE,MOD,RPAREN,OR,CARET,LSQUAREB, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { ELSE,GREATEREQ,OR,MINUS,DO,EQ,NEQ,LPAREN,IN,DIV,THEN,RCURLYB,SEMICOLON,RPAREN,TIMES,GREATER,MOD,LSQUAREB,RSQUAREB,AND,CARET,COMMA,EOF,PLUS,LESSEQ,LESS, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { OR,EOF,LESS,TIMES,SEMICOLON,MINUS,CARET,DO,AND,LPAREN,COMMA,RPAREN,GREATER,MOD,RCURLYB,IN,LESSEQ,DIV,GREATEREQ,NEQ,EQ,PLUS,ELSE,RSQUAREB,THEN,LSQUAREB, }
  (41) UnaryExpr --> .RValue  { MINUS,EOF,LESS,COMMA,DO,ELSE,NEQ,TIMES,SEMICOLON,OR,RSQUAREB,LESSEQ,MOD,RPAREN,IN,PLUS,RCURLYB,AND,THEN,DIV,GREATEREQ,CARET,EQ,GREATER, }
  (40) UnaryExpr --> .LValue  { TIMES,GREATER,RCURLYB,DO,NEQ,THEN,DIV,GREATEREQ,CARET,IN,OR,PLUS,LESSEQ,COMMA,ELSE,RSQUAREB,EOF,EQ,AND,MINUS,LESS,MOD,RPAREN,SEMICOLON, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { DIV,COMMA,MINUS,NEQ,RCURLYB,RPAREN,AND,DO,GREATEREQ,SEMICOLON,ELSE,EOF,LPAREN,PLUS,EQ,LSQUAREB,OR,RSQUAREB,GREATER,CARET,TIMES,THEN,LESSEQ,MOD,IN,LESS, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { OR,EOF,THEN,DO,RSQUAREB,GREATER,RCURLYB,MINUS,LESS,SEMICOLON,IN,TIMES,NEQ,GREATEREQ,DIV,MOD,RPAREN,LESSEQ,AND,ELSE,EQ,PLUS,COMMA,CARET, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { GREATER,CARET,EOF,IN,DIV,LESSEQ,COMMA,AND,RSQUAREB,MOD,LPAREN,RPAREN,GREATEREQ,TIMES,OR,MINUS,SEMICOLON,RCURLYB,DO,PLUS,LSQUAREB,LESS,THEN,EQ,ELSE,NEQ, }
  (59) UnaryExpr --> PRINT .UnaryExpr  { DO,EQ,LESSEQ,LESS,ELSE,RPAREN,MINUS,SEMICOLON,PLUS,RCURLYB,THEN,AND,MOD,NEQ,EOF,CARET,TIMES,GREATEREQ,COMMA,OR,DIV,IN,GREATER,RSQUAREB, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { COMMA,DO,EOF,NEQ,LSQUAREB,RSQUAREB,MINUS,CARET,GREATEREQ,THEN,MOD,RPAREN,SEMICOLON,OR,DIV,AND,ELSE,LESSEQ,PLUS,RCURLYB,EQ,TIMES,GREATER,LPAREN,IN,LESS, }
  (42) RValue --> .LPAREN Expr RPAREN  { THEN,OR,IN,LSQUAREB,MINUS,RCURLYB,LESS,PLUS,COMMA,DO,CARET,TIMES,LPAREN,ELSE,LESSEQ,SEMICOLON,RPAREN,GREATEREQ,MOD,EOF,DIV,GREATER,AND,NEQ,RSQUAREB,EQ, }
state 25:
  (31) ReturnType --> T_VOID .  { LAMBDA, }
state 26:
  (59) UnaryExpr --> .PRINT UnaryExpr  { NEQ,EOF,SEMICOLON,THEN,OR,MINUS,MOD,EQ,TIMES,COMMA,GREATER,LESSEQ,RPAREN,CARET,RCURLYB,DIV,ELSE,DO,AND,RSQUAREB,PLUS,IN,GREATEREQ,LESS, }
  (57) UnaryExpr --> .NOT UnaryExpr  { PLUS,TIMES,DO,THEN,EOF,EQ,RSQUAREB,GREATER,CARET,LESSEQ,LESS,GREATEREQ,RPAREN,AND,IN,MINUS,RCURLYB,ELSE,OR,SEMICOLON,MOD,DIV,COMMA,NEQ, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { GREATEREQ,LESS,SEMICOLON,RPAREN,AND,IN,MOD,ELSE,CARET,NEQ,EQ,THEN,GREATER,LESSEQ,RSQUAREB,TIMES,OR,MINUS,DIV,EOF,PLUS,RCURLYB,DO,COMMA, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { MINUS,LESSEQ,RCURLYB,LPAREN,SEMICOLON,OR,DIV,NEQ,THEN,TIMES,EOF,IN,RPAREN,COMMA,GREATEREQ,EQ,LSQUAREB,AND,RSQUAREB,DO,MOD,GREATER,ELSE,PLUS,CARET,LESS, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { LPAREN,RSQUAREB,MOD,LSQUAREB,NEQ,EQ,OR,THEN,RPAREN,DO,AND,SEMICOLON,EOF,GREATEREQ,LESS,MINUS,RCURLYB,ELSE,CARET,IN,COMMA,DIV,LESSEQ,GREATER,TIMES,PLUS, }
  (40) UnaryExpr --> .LValue  { SEMICOLON,AND,NEQ,PLUS,LESSEQ,GREATER,LESS,MINUS,EOF,OR,IN,ELSE,GREATEREQ,CARET,DIV,DO,RCURLYB,MOD,RSQUAREB,THEN,EQ,TIMES,RPAREN,COMMA, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { RPAREN,GREATEREQ,GREATER,IN,CARET,MINUS,LESS,RCURLYB,NEQ,THEN,OR,DO,EOF,AND,ELSE,EQ,TIMES,DIV,LPAREN,MOD,PLUS,SEMICOLON,LESSEQ,LSQUAREB,RSQUAREB,COMMA, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { MINUS,RCURLYB,PLUS,THEN,GREATEREQ,RPAREN,SEMICOLON,RSQUAREB,MOD,AND,GREATER,DO,OR,LESS,ELSE,DIV,LESSEQ,EOF,COMMA,LPAREN,LSQUAREB,NEQ,CARET,IN,TIMES,EQ, }
  (68) RValue --> .StringLit  { GREATER,EQ,MINUS,EOF,THEN,LPAREN,TIMES,SEMICOLON,MOD,RSQUAREB,LESS,RCURLYB,COMMA,OR,CARET,AND,RPAREN,DIV,IN,DO,GREATEREQ,ELSE,NEQ,LESSEQ,PLUS,LSQUAREB, }
  (41) UnaryExpr --> .RValue  { EQ,AND,PLUS,GREATEREQ,THEN,ELSE,NEQ,MINUS,LESSEQ,OR,TIMES,LESS,RPAREN,GREATER,DO,EOF,COMMA,MOD,IN,SEMICOLON,DIV,CARET,RSQUAREB,RCURLYB, }
  (66) RValue --> .Integer  { EOF,COMMA,DIV,LPAREN,AND,THEN,OR,IN,GREATER,EQ,TIMES,CARET,LESS,NEQ,MOD,MINUS,DO,SEMICOLON,GREATEREQ,ELSE,LSQUAREB,LESSEQ,PLUS,RPAREN,RSQUAREB,RCURLYB, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { OR,LESSEQ,IN,COMMA,LSQUAREB,PLUS,MOD,EQ,RSQUAREB,LESS,CARET,EOF,TIMES,RPAREN,DO,AND,SEMICOLON,NEQ,DIV,GREATEREQ,ELSE,RCURLYB,THEN,GREATER,LPAREN,MINUS, }
  (42) RValue --> .LPAREN Expr RPAREN  { RCURLYB,NEQ,LESSEQ,COMMA,SEMICOLON,TIMES,OR,LSQUAREB,THEN,PLUS,AND,CARET,EQ,GREATEREQ,MOD,RPAREN,IN,EOF,GREATER,ELSE,RSQUAREB,DIV,LESS,LPAREN,MINUS,DO, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { LPAREN,EQ,GREATEREQ,EOF,MINUS,MOD,AND,IN,RPAREN,COMMA,DO,CARET,PLUS,TIMES,RSQUAREB,LESSEQ,NEQ,OR,LESS,RCURLYB,ELSE,LSQUAREB,DIV,THEN,SEMICOLON,GREATER, }
  (67) RValue --> .Float  { CARET,RCURLYB,THEN,LPAREN,RPAREN,OR,GREATEREQ,NEQ,DIV,MOD,AND,MINUS,LESSEQ,DO,ELSE,TIMES,GREATER,PLUS,LESS,EOF,COMMA,IN,LSQUAREB,RSQUAREB,SEMICOLON,EQ, }
  (58) UnaryExpr --> NEGATE .UnaryExpr  { PLUS,EQ,RPAREN,LESS,GREATER,SEMICOLON,DIV,THEN,MINUS,TIMES,OR,LESSEQ,NEQ,RSQUAREB,IN,COMMA,RCURLYB,EOF,ELSE,AND,MOD,GREATEREQ,DO,CARET, }
  (24) LValue --> .Var  { TIMES,MINUS,RPAREN,CARET,SEMICOLON,PLUS,DIV,NEQ,ELSE,GREATEREQ,DO,LESS,OR,AND,RSQUAREB,GREATER,LESSEQ,IN,LSQUAREB,EOF,COMMA,MOD,LPAREN,EQ,RCURLYB,THEN, }
state 27:
  (66) RValue --> Integer .  { CARET,PLUS,AND,THEN,LESS,LSQUAREB,NEQ,EQ,LPAREN,SEMICOLON,LESSEQ,RPAREN,RCURLYB,MOD,ELSE,MINUS,DIV,IN,TIMES,GREATER,GREATEREQ,COMMA,OR,RSQUAREB,DO,EOF, }
state 28:
  (28) ParamList --> .  { DOT, }
  (29) ParamList --> .TypedParam  { DOT, }
  (30) ParamList --> .TypedParam COMMA ParamList  { DOT, }
  (13) TypedParam --> .Var COLON Type  { COMMA,DOT, }
  (26) NonBlockExpr --> LAMBDA .ParamList DOT Expr  { EOF,DO,THEN,ELSE,IN,RCURLYB,COMMA,SEMICOLON,RPAREN,RSQUAREB, }
state 29:
  (24) LValue --> Var .  { AND,ELSE,GREATER,CARET,RSQUAREB,SEMICOLON,DO,LSQUAREB,RCURLYB,EOF,LESSEQ,MINUS,ASSIGN,LPAREN,GREATEREQ,MOD,IN,OR,THEN,TIMES,COMMA,DIV,PLUS,RPAREN,EQ,NEQ,LESS, }
state 30:
  (67) RValue --> Float .  { RPAREN,PLUS,OR,THEN,RSQUAREB,LESSEQ,MINUS,LPAREN,GREATEREQ,DIV,TIMES,COMMA,DO,LESS,SEMICOLON,RCURLYB,CARET,AND,EQ,GREATER,ELSE,LSQUAREB,NEQ,EOF,MOD,IN, }
state 31:
  (16) BlockExpr --> BlockStmt .  { EOF,WHILE,Var,T_FLOAT,LPAREN,NEGATE,T_STRING,T_INT,StringLit,RCURLYB,NOT,IN,THEN,IF,DEFINE,LET,DO,T_VOID,LCURLYB,RPAREN,ELSE,LSQUAREB,LAMBDA,PRINT,COMMA,Float,Integer,RSQUAREB,SEMICOLON, }
state 32:
  (73) Type --> T_STRING .  { LAMBDA,LSQUAREB,COMMA,DOT,ASSIGN, }
state 33:
  (72) Type --> T_FLOAT .  { COMMA,LAMBDA,ASSIGN,LSQUAREB,DOT, }
state 34:
  (27) NonBlockExpr --> ReturnType .LAMBDA ParamList DOT Expr  { SEMICOLON,ELSE,COMMA,THEN,RPAREN,EOF,RSQUAREB,RCURLYB,DO,IN, }
state 35:
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { ELSE,OR,SEMICOLON,IN,PLUS,TIMES,LESS,DIV,COMMA,NEQ,EOF,LESSEQ,GREATER,CARET,MOD,GREATEREQ,EQ,THEN,DO,LSQUAREB,AND,RSQUAREB,LPAREN,RCURLYB,MINUS,RPAREN, }
  (66) RValue --> .Integer  { LESSEQ,RCURLYB,PLUS,COMMA,MINUS,AND,ELSE,DIV,SEMICOLON,GREATER,OR,EQ,THEN,EOF,GREATEREQ,IN,NEQ,RSQUAREB,LSQUAREB,LPAREN,DO,LESS,TIMES,CARET,RPAREN,MOD, }
  (41) UnaryExpr --> .RValue  { MOD,LESS,RPAREN,LESSEQ,RCURLYB,COMMA,TIMES,THEN,GREATER,AND,ELSE,DIV,IN,NEQ,EQ,SEMICOLON,OR,CARET,PLUS,RSQUAREB,GREATEREQ,MINUS,EOF,DO, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { AND,RSQUAREB,TIMES,EOF,LESSEQ,NEQ,MINUS,LESS,LSQUAREB,DIV,LPAREN,DO,EQ,GREATER,SEMICOLON,PLUS,OR,GREATEREQ,RPAREN,RCURLYB,ELSE,THEN,IN,MOD,CARET,COMMA, }
  (67) RValue --> .Float  { ELSE,MINUS,MOD,LESS,TIMES,LPAREN,IN,RCURLYB,NEQ,PLUS,OR,EQ,THEN,EOF,LESSEQ,LSQUAREB,RSQUAREB,DO,SEMICOLON,DIV,GREATER,AND,COMMA,GREATEREQ,CARET,RPAREN, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { EQ,DO,LPAREN,AND,MINUS,RPAREN,SEMICOLON,LESS,NEQ,ELSE,IN,RSQUAREB,LSQUAREB,LESSEQ,GREATEREQ,COMMA,EOF,RCURLYB,TIMES,DIV,THEN,PLUS,OR,CARET,GREATER,MOD, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { MINUS,PLUS,MOD,LSQUAREB,COMMA,THEN,GREATER,NEQ,LESSEQ,LPAREN,LESS,CARET,OR,EOF,DO,DIV,GREATEREQ,ELSE,RSQUAREB,TIMES,EQ,RPAREN,IN,SEMICOLON,RCURLYB,AND, }
  (68) RValue --> .StringLit  { IN,CARET,TIMES,THEN,LPAREN,OR,RCURLYB,NEQ,DO,MINUS,LSQUAREB,RPAREN,LESS,EOF,AND,MOD,RSQUAREB,DIV,GREATER,PLUS,COMMA,SEMICOLON,ELSE,EQ,LESSEQ,GREATEREQ, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { LSQUAREB,TIMES,GREATEREQ,DIV,SEMICOLON,CARET,IN,RCURLYB,COMMA,LESSEQ,AND,RSQUAREB,THEN,GREATER,OR,RPAREN,MINUS,LESS,NEQ,ELSE,EOF,PLUS,LPAREN,EQ,DO,MOD, }
  (24) LValue --> .Var  { CARET,RCURLYB,MOD,THEN,LESSEQ,IN,TIMES,LPAREN,NEQ,DO,SEMICOLON,RPAREN,GREATEREQ,RSQUAREB,LESS,COMMA,GREATER,ELSE,EQ,AND,OR,PLUS,MINUS,DIV,LSQUAREB,EOF, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { LESS,RSQUAREB,CARET,ELSE,RPAREN,DO,LPAREN,LESSEQ,GREATEREQ,AND,SEMICOLON,DIV,NEQ,MOD,COMMA,IN,EQ,OR,EOF,THEN,RCURLYB,TIMES,MINUS,PLUS,GREATER,LSQUAREB, }
  (42) RValue --> .LPAREN Expr RPAREN  { RPAREN,LESS,ELSE,DIV,SEMICOLON,RSQUAREB,DO,RCURLYB,EQ,MINUS,NEQ,MOD,LSQUAREB,PLUS,COMMA,TIMES,GREATEREQ,EOF,THEN,IN,LPAREN,GREATER,CARET,AND,LESSEQ,OR, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { CARET,LESS,ELSE,IN,LESSEQ,GREATEREQ,RCURLYB,MINUS,PLUS,EQ,TIMES,DO,COMMA,RSQUAREB,NEQ,DIV,THEN,SEMICOLON,GREATER,OR,EOF,MOD,RPAREN,AND, }
  (40) UnaryExpr --> .LValue  { IN,EOF,COMMA,MOD,EQ,DO,GREATEREQ,SEMICOLON,RSQUAREB,OR,AND,GREATER,DIV,RPAREN,RCURLYB,MINUS,LESS,CARET,ELSE,TIMES,THEN,NEQ,LESSEQ,PLUS, }
  (57) UnaryExpr --> .NOT UnaryExpr  { MINUS,LESS,RCURLYB,NEQ,OR,LESSEQ,THEN,EOF,TIMES,AND,CARET,IN,MOD,ELSE,SEMICOLON,GREATEREQ,RPAREN,DO,GREATER,PLUS,DIV,RSQUAREB,COMMA,EQ, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { LESS,EOF,MOD,MINUS,RCURLYB,ELSE,DO,OR,IN,TIMES,THEN,GREATER,GREATEREQ,LESSEQ,DIV,CARET,SEMICOLON,AND,RSQUAREB,COMMA,NEQ,PLUS,EQ,RPAREN, }
  (57) UnaryExpr --> NOT .UnaryExpr  { GREATEREQ,ELSE,TIMES,DO,RPAREN,NEQ,AND,THEN,EOF,MOD,RSQUAREB,LESSEQ,GREATER,PLUS,COMMA,IN,SEMICOLON,CARET,RCURLYB,OR,LESS,DIV,EQ,MINUS, }
state 36:
  (74) Type --> Type .LSQUAREB RSQUAREB  { LSQUAREB,LAMBDA, }
  (32) ReturnType --> Type .  { LAMBDA, }
state 37:
  (13) TypedParam --> .Var COLON Type  { ASSIGN, }
  (15) DefineExpr --> DEFINE .Param ASSIGN Expr  { EOF,RCURLYB,SEMICOLON, }
  (11) Param --> .Var  { ASSIGN, }
  (12) Param --> .TypedParam  { ASSIGN, }
state 38:
  (71) Type --> T_INT .  { COMMA,DOT,LSQUAREB,LAMBDA,ASSIGN, }
state 39:
  (14) Stmt --> DefineExpr SEMICOLON .  { WHILE,EOF,Var,Integer,RCURLYB,PRINT,NOT,T_STRING,DEFINE,T_VOID,LSQUAREB,SEMICOLON,LCURLYB,LAMBDA,Float,LPAREN,NEGATE,T_INT,IF,StringLit,T_FLOAT,LET, }
state 40:
  (8) Expr --> NonBlockExpr .  { RCURLYB,DO,SEMICOLON,EOF,THEN,COMMA,RPAREN,ELSE,RSQUAREB,IN, }
state 41:
  (21) NonBlockExpr --> WHILE Expr .DO NonBlockExpr  { RSQUAREB,IN,ELSE,SEMICOLON,THEN,RCURLYB,EOF,RPAREN,COMMA,DO, }
  (18) BlockExpr --> WHILE Expr .DO BlockExpr  { DEFINE,ELSE,THEN,Float,IF,LPAREN,SEMICOLON,T_VOID,EOF,COMMA,DO,T_INT,LET,RPAREN,RCURLYB,StringLit,WHILE,IN,T_STRING,Var,NEGATE,T_FLOAT,PRINT,Integer,LSQUAREB,RSQUAREB,LAMBDA,LCURLYB,NOT, }
state 42:
  (7) Expr --> BlockExpr .  { THEN,COMMA,SEMICOLON,EOF,RPAREN,IN,DO,RCURLYB,ELSE,RSQUAREB, }
state 43:
  (19) BlockExpr --> LET Param .ASSIGN Expr IN BlockExpr  { RPAREN,SEMICOLON,EOF,COMMA,LCURLYB,NEGATE,Float,LAMBDA,StringLit,T_VOID,LET,DEFINE,Var,PRINT,IF,IN,T_INT,NOT,RSQUAREB,LSQUAREB,WHILE,T_FLOAT,T_STRING,LPAREN,RCURLYB,ELSE,Integer,DO,THEN, }
  (22) NonBlockExpr --> LET Param .ASSIGN Expr IN NonBlockExpr  { THEN,ELSE,DO,COMMA,RPAREN,IN,RCURLYB,EOF,RSQUAREB,SEMICOLON, }
state 44:
  (13) TypedParam --> Var .COLON Type  { ASSIGN, }
  (11) Param --> Var .  { ASSIGN, }
state 45:
  (12) Param --> TypedParam .  { ASSIGN, }
state 46:
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { OR,AND,LESSEQ,EOF,PLUS,NEQ,RCURLYB,GREATEREQ,LSQUAREB,RSQUAREB,COMMA,TIMES,RPAREN,EQ,CARET,DO,ELSE,DIV,LESS,MOD,LPAREN,SEMICOLON,MINUS,GREATER,IN,THEN, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { IN,LESSEQ,ELSE,GREATEREQ,RPAREN,LESS,THEN,GREATER,LSQUAREB,MINUS,OR,EQ,EOF,NEQ,LPAREN,AND,DIV,RCURLYB,MOD,RSQUAREB,TIMES,PLUS,SEMICOLON,DO,COMMA,CARET, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { EOF,RPAREN,AND,TIMES,DIV,THEN,RSQUAREB,MOD,SEMICOLON,GREATEREQ,NEQ,LESSEQ,GREATER,LSQUAREB,LPAREN,LESS,RCURLYB,ELSE,EQ,IN,CARET,OR,MINUS,PLUS,DO,COMMA, }
  (52) PlusExpr --> .PlusExpr MINUS TimesExpr  { AND,LESS,EOF,IN,THEN,GREATEREQ,GREATER,LESSEQ,OR,EQ,RCURLYB,PLUS,DO,CARET,RSQUAREB,ELSE,NEQ,MINUS,RPAREN,COMMA,SEMICOLON, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { OR,MOD,LESS,EQ,THEN,CARET,NEQ,IN,RSQUAREB,RPAREN,SEMICOLON,AND,ELSE,GREATER,MINUS,DO,EOF,DIV,COMMA,TIMES,PLUS,LESSEQ,RCURLYB,GREATEREQ, }
  (53) PlusExpr --> .PlusExpr CARET TimesExpr  { RCURLYB,MINUS,NEQ,CARET,EQ,ELSE,LESSEQ,LESS,RSQUAREB,RPAREN,SEMICOLON,GREATEREQ,COMMA,GREATER,THEN,AND,DO,PLUS,IN,OR,EOF, }
  (40) UnaryExpr --> .LValue  { MINUS,IN,COMMA,AND,LESSEQ,THEN,RCURLYB,MOD,RPAREN,EQ,SEMICOLON,LESS,TIMES,OR,EOF,DIV,NEQ,RSQUAREB,GREATEREQ,GREATER,ELSE,PLUS,CARET,DO, }
  (67) RValue --> .Float  { ELSE,EOF,LESS,THEN,CARET,NEQ,DIV,LESSEQ,COMMA,PLUS,MOD,IN,GREATEREQ,RPAREN,GREATER,RSQUAREB,LSQUAREB,MINUS,SEMICOLON,TIMES,OR,EQ,RCURLYB,AND,LPAREN,DO, }
  (24) LValue --> .Var  { GREATEREQ,MINUS,THEN,ELSE,RCURLYB,GREATER,NEQ,LPAREN,DO,COMMA,EOF,LESSEQ,MOD,LESS,DIV,RSQUAREB,CARET,IN,SEMICOLON,TIMES,PLUS,EQ,RPAREN,LSQUAREB,AND,OR, }
  (42) RValue --> .LPAREN Expr RPAREN  { GREATER,NEQ,CARET,RCURLYB,PLUS,RSQUAREB,LPAREN,EQ,LESSEQ,MOD,ELSE,LSQUAREB,DIV,DO,EOF,SEMICOLON,RPAREN,THEN,IN,TIMES,GREATEREQ,COMMA,LESS,MINUS,OR,AND, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { EOF,DIV,IN,RPAREN,RCURLYB,GREATER,TIMES,OR,AND,EQ,DO,GREATEREQ,THEN,NEQ,RSQUAREB,LESSEQ,MINUS,LESS,PLUS,SEMICOLON,MOD,COMMA,ELSE,CARET, }
  (66) RValue --> .Integer  { CARET,PLUS,SEMICOLON,RSQUAREB,EOF,EQ,NEQ,GREATER,LSQUAREB,THEN,DIV,GREATEREQ,AND,MOD,LESS,LPAREN,ELSE,LESSEQ,COMMA,RPAREN,IN,RCURLYB,OR,TIMES,MINUS,DO, }
  (51) PlusExpr --> .PlusExpr PLUS TimesExpr  { AND,LESSEQ,GREATEREQ,IN,PLUS,THEN,LESS,SEMICOLON,CARET,DO,RPAREN,ELSE,COMMA,EQ,MINUS,NEQ,RCURLYB,OR,GREATER,EOF,RSQUAREB, }
  (55) TimesExpr --> .TimesExpr DIV UnaryExpr  { CARET,DO,PLUS,SEMICOLON,RPAREN,COMMA,GREATEREQ,LESSEQ,RCURLYB,GREATER,LESS,MINUS,NEQ,MOD,EOF,RSQUAREB,THEN,ELSE,OR,TIMES,DIV,EQ,AND,IN, }
  (68) RValue --> .StringLit  { CARET,GREATEREQ,LPAREN,LESSEQ,ELSE,AND,RCURLYB,TIMES,DIV,NEQ,RSQUAREB,PLUS,SEMICOLON,EQ,RPAREN,LSQUAREB,LESS,DO,EOF,GREATER,COMMA,MINUS,IN,OR,THEN,MOD, }
  (47) CompExpr --> CompExpr LESS .PlusExpr  { GREATER,EQ,GREATEREQ,EOF,LESSEQ,RPAREN,DO,RCURLYB,THEN,RSQUAREB,IN,NEQ,SEMICOLON,AND,ELSE,LESS,COMMA,OR, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { MINUS,EOF,OR,LPAREN,RCURLYB,EQ,IN,COMMA,DO,ELSE,CARET,MOD,RSQUAREB,GREATER,LESSEQ,SEMICOLON,NEQ,GREATEREQ,PLUS,LESS,AND,LSQUAREB,THEN,TIMES,DIV,RPAREN, }
  (39) TimesExpr --> .UnaryExpr  { DIV,DO,OR,LESS,SEMICOLON,RPAREN,THEN,EOF,CARET,IN,LESSEQ,PLUS,NEQ,MINUS,MOD,AND,TIMES,GREATER,EQ,RSQUAREB,RCURLYB,COMMA,GREATEREQ,ELSE, }
  (38) PlusExpr --> .TimesExpr  { RPAREN,LESSEQ,THEN,RSQUAREB,OR,CARET,ELSE,MINUS,GREATEREQ,COMMA,RCURLYB,SEMICOLON,GREATER,LESS,EQ,DO,IN,EOF,NEQ,AND,PLUS, }
  (57) UnaryExpr --> .NOT UnaryExpr  { MINUS,LESSEQ,DO,ELSE,RPAREN,OR,NEQ,LESS,MOD,SEMICOLON,EQ,IN,RSQUAREB,GREATER,DIV,CARET,COMMA,RCURLYB,THEN,PLUS,TIMES,EOF,AND,GREATEREQ, }
  (41) UnaryExpr --> .RValue  { ELSE,THEN,EOF,RPAREN,IN,EQ,DIV,PLUS,TIMES,GREATEREQ,OR,RCURLYB,DO,COMMA,CARET,MOD,MINUS,SEMICOLON,NEQ,AND,LESSEQ,LESS,RSQUAREB,GREATER, }
  (54) TimesExpr --> .TimesExpr TIMES UnaryExpr  { EOF,DO,EQ,SEMICOLON,CARET,PLUS,GREATEREQ,IN,MOD,DIV,RCURLYB,OR,LESSEQ,COMMA,LESS,AND,RPAREN,NEQ,GREATER,TIMES,ELSE,THEN,RSQUAREB,MINUS, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { GREATER,LPAREN,SEMICOLON,EQ,DIV,AND,PLUS,EOF,LSQUAREB,IN,ELSE,CARET,DO,RSQUAREB,RCURLYB,THEN,GREATEREQ,OR,TIMES,LESSEQ,MOD,NEQ,COMMA,MINUS,RPAREN,LESS, }
  (56) TimesExpr --> .TimesExpr MOD UnaryExpr  { MINUS,IN,GREATER,LESSEQ,OR,ELSE,AND,RSQUAREB,LESS,DIV,THEN,DO,CARET,RPAREN,MOD,TIMES,NEQ,COMMA,GREATEREQ,EOF,PLUS,EQ,SEMICOLON,RCURLYB, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { DO,LESS,RPAREN,IN,GREATEREQ,NEQ,LSQUAREB,CARET,AND,LPAREN,RCURLYB,EQ,GREATER,COMMA,MOD,DIV,LESSEQ,TIMES,MINUS,OR,ELSE,SEMICOLON,EOF,THEN,RSQUAREB,PLUS, }
state 47:
  (67) RValue --> .Float  { MOD,DO,ELSE,IN,LESS,RCURLYB,EQ,DIV,TIMES,LESSEQ,GREATER,EOF,PLUS,RSQUAREB,LSQUAREB,COMMA,RPAREN,OR,LPAREN,CARET,GREATEREQ,THEN,MINUS,SEMICOLON,NEQ,AND, }
  (57) UnaryExpr --> .NOT UnaryExpr  { CARET,LESS,TIMES,GREATEREQ,AND,RSQUAREB,ELSE,SEMICOLON,RPAREN,LESSEQ,OR,THEN,GREATER,MOD,DIV,PLUS,DO,EOF,MINUS,EQ,NEQ,RCURLYB,COMMA,IN, }
  (42) RValue --> .LPAREN Expr RPAREN  { THEN,DIV,RPAREN,EOF,TIMES,LPAREN,SEMICOLON,EQ,GREATEREQ,NEQ,COMMA,RCURLYB,LSQUAREB,AND,IN,CARET,RSQUAREB,LESS,MOD,ELSE,DO,PLUS,MINUS,OR,LESSEQ,GREATER, }
  (52) PlusExpr --> .PlusExpr MINUS TimesExpr  { GREATER,CARET,EQ,GREATEREQ,IN,DO,PLUS,AND,LESS,MINUS,RPAREN,OR,ELSE,RCURLYB,THEN,SEMICOLON,NEQ,RSQUAREB,LESSEQ,EOF,COMMA, }
  (54) TimesExpr --> .TimesExpr TIMES UnaryExpr  { THEN,DIV,OR,TIMES,MOD,RPAREN,LESSEQ,IN,EOF,GREATER,PLUS,EQ,ELSE,CARET,RSQUAREB,NEQ,COMMA,LESS,DO,RCURLYB,GREATEREQ,MINUS,SEMICOLON,AND, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { OR,RPAREN,MOD,RSQUAREB,CARET,LSQUAREB,EQ,IN,DO,SEMICOLON,EOF,COMMA,LESS,LPAREN,THEN,AND,DIV,PLUS,LESSEQ,GREATER,RCURLYB,MINUS,GREATEREQ,TIMES,NEQ,ELSE, }
  (53) PlusExpr --> .PlusExpr CARET TimesExpr  { RCURLYB,COMMA,THEN,CARET,RPAREN,OR,DO,RSQUAREB,LESS,PLUS,NEQ,AND,MINUS,LESSEQ,GREATEREQ,GREATER,EOF,IN,EQ,SEMICOLON,ELSE, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { GREATEREQ,NEQ,TIMES,EQ,MOD,AND,DIV,LESS,ELSE,RPAREN,DO,LSQUAREB,EOF,THEN,GREATER,CARET,RCURLYB,IN,PLUS,OR,COMMA,LPAREN,SEMICOLON,RSQUAREB,LESSEQ,MINUS, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { RSQUAREB,IN,ELSE,LESSEQ,THEN,NEQ,LPAREN,RPAREN,SEMICOLON,DO,EOF,GREATER,PLUS,MINUS,LESS,EQ,TIMES,MOD,OR,DIV,RCURLYB,GREATEREQ,AND,CARET,LSQUAREB,COMMA, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { ELSE,GREATER,EOF,SEMICOLON,RPAREN,DIV,CARET,THEN,DO,MOD,LESSEQ,IN,LESS,OR,RCURLYB,RSQUAREB,PLUS,EQ,NEQ,COMMA,MINUS,GREATEREQ,TIMES,AND, }
  (68) RValue --> .StringLit  { GREATER,LESS,RSQUAREB,EOF,MOD,DIV,DO,RPAREN,MINUS,ELSE,LSQUAREB,THEN,CARET,COMMA,OR,SEMICOLON,NEQ,PLUS,AND,GREATEREQ,IN,LPAREN,EQ,TIMES,LESSEQ,RCURLYB, }
  (41) UnaryExpr --> .RValue  { GREATER,DIV,THEN,EQ,RSQUAREB,NEQ,RCURLYB,LESSEQ,COMMA,SEMICOLON,AND,OR,CARET,EOF,RPAREN,ELSE,DO,MINUS,PLUS,GREATEREQ,TIMES,LESS,IN,MOD, }
  (56) TimesExpr --> .TimesExpr MOD UnaryExpr  { LESS,EOF,SEMICOLON,EQ,MOD,RPAREN,RSQUAREB,MINUS,COMMA,OR,GREATEREQ,ELSE,NEQ,AND,PLUS,DO,CARET,THEN,DIV,TIMES,LESSEQ,GREATER,IN,RCURLYB, }
  (39) TimesExpr --> .UnaryExpr  { GREATEREQ,LESS,MINUS,AND,COMMA,ELSE,SEMICOLON,OR,EOF,RCURLYB,DO,RPAREN,CARET,TIMES,MOD,THEN,IN,DIV,RSQUAREB,GREATER,PLUS,LESSEQ,NEQ,EQ, }
  (55) TimesExpr --> .TimesExpr DIV UnaryExpr  { EQ,DIV,RCURLYB,COMMA,THEN,ELSE,RPAREN,PLUS,OR,AND,DO,TIMES,MINUS,MOD,LESSEQ,EOF,NEQ,SEMICOLON,RSQUAREB,GREATEREQ,GREATER,LESS,IN,CARET, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { NEQ,RSQUAREB,THEN,DO,GREATEREQ,PLUS,SEMICOLON,CARET,DIV,GREATER,TIMES,LESS,EOF,ELSE,RPAREN,MOD,RCURLYB,AND,LESSEQ,OR,IN,MINUS,COMMA,EQ, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { RCURLYB,OR,IN,AND,MOD,COMMA,ELSE,EQ,GREATEREQ,SEMICOLON,CARET,GREATER,THEN,LESSEQ,RSQUAREB,TIMES,MINUS,NEQ,DIV,EOF,RPAREN,LPAREN,LESS,PLUS,DO,LSQUAREB, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { MOD,ELSE,IN,LSQUAREB,RSQUAREB,THEN,DO,PLUS,CARET,OR,RPAREN,TIMES,LESS,GREATEREQ,MINUS,EOF,SEMICOLON,LESSEQ,COMMA,DIV,NEQ,GREATER,EQ,AND,LPAREN,RCURLYB, }
  (38) PlusExpr --> .TimesExpr  { NEQ,DO,RSQUAREB,SEMICOLON,OR,CARET,AND,RCURLYB,EQ,MINUS,IN,COMMA,EOF,PLUS,RPAREN,GREATEREQ,LESS,GREATER,LESSEQ,ELSE,THEN, }
  (24) LValue --> .Var  { LESS,MINUS,AND,CARET,TIMES,PLUS,SEMICOLON,LESSEQ,IN,COMMA,LPAREN,GREATEREQ,MOD,NEQ,OR,ELSE,EOF,LSQUAREB,THEN,GREATER,RPAREN,DO,RCURLYB,DIV,EQ,RSQUAREB, }
  (40) UnaryExpr --> .LValue  { OR,MINUS,EQ,COMMA,EOF,LESSEQ,RSQUAREB,SEMICOLON,RPAREN,LESS,THEN,PLUS,DO,RCURLYB,CARET,NEQ,DIV,IN,TIMES,GREATEREQ,AND,ELSE,MOD,GREATER, }
  (49) CompExpr --> CompExpr LESSEQ .PlusExpr  { DO,EQ,COMMA,RCURLYB,GREATEREQ,ELSE,THEN,SEMICOLON,OR,LESSEQ,AND,GREATER,IN,RPAREN,EOF,RSQUAREB,LESS,NEQ, }
  (51) PlusExpr --> .PlusExpr PLUS TimesExpr  { IN,THEN,RSQUAREB,GREATEREQ,MINUS,RCURLYB,ELSE,OR,NEQ,COMMA,LESSEQ,AND,LESS,EQ,DO,SEMICOLON,GREATER,CARET,EOF,PLUS,RPAREN, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { COMMA,RSQUAREB,MINUS,TIMES,IN,LESSEQ,GREATER,LSQUAREB,GREATEREQ,SEMICOLON,CARET,RCURLYB,OR,THEN,DIV,RPAREN,ELSE,DO,EQ,LESS,AND,EOF,NEQ,PLUS,LPAREN,MOD, }
  (66) RValue --> .Integer  { THEN,LESSEQ,COMMA,MINUS,EQ,OR,RCURLYB,LSQUAREB,GREATER,RPAREN,LPAREN,RSQUAREB,TIMES,IN,NEQ,DO,MOD,GREATEREQ,CARET,DIV,ELSE,AND,EOF,PLUS,LESS,SEMICOLON, }
state 48:
  (51) PlusExpr --> .PlusExpr PLUS TimesExpr  { RCURLYB,SEMICOLON,NEQ,RPAREN,COMMA,MINUS,THEN,EOF,DO,OR,LESS,CARET,EQ,RSQUAREB,ELSE,LESSEQ,PLUS,IN,GREATER,AND,GREATEREQ, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { LESS,COMMA,EQ,IN,PLUS,THEN,LESSEQ,LPAREN,AND,GREATEREQ,DIV,CARET,EOF,OR,SEMICOLON,RPAREN,MOD,GREATER,RSQUAREB,LSQUAREB,DO,MINUS,ELSE,NEQ,RCURLYB,TIMES, }
  (42) RValue --> .LPAREN Expr RPAREN  { IN,ELSE,GREATEREQ,RPAREN,RSQUAREB,MINUS,PLUS,LESSEQ,EOF,COMMA,OR,DO,CARET,MOD,LSQUAREB,RCURLYB,LESS,GREATER,SEMICOLON,DIV,AND,THEN,NEQ,TIMES,LPAREN,EQ, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { MOD,LPAREN,RPAREN,GREATEREQ,OR,LSQUAREB,ELSE,GREATER,DO,MINUS,LESSEQ,LESS,DIV,SEMICOLON,EOF,COMMA,THEN,PLUS,EQ,IN,NEQ,AND,RCURLYB,CARET,RSQUAREB,TIMES, }
  (53) PlusExpr --> .PlusExpr CARET TimesExpr  { GREATEREQ,EQ,NEQ,OR,RCURLYB,COMMA,DO,RPAREN,ELSE,AND,MINUS,SEMICOLON,THEN,GREATER,CARET,IN,PLUS,EOF,RSQUAREB,LESS,LESSEQ, }
  (24) LValue --> .Var  { RCURLYB,NEQ,LESS,EQ,COMMA,ELSE,DO,RPAREN,TIMES,RSQUAREB,MINUS,OR,MOD,PLUS,SEMICOLON,GREATER,CARET,LPAREN,GREATEREQ,LESSEQ,IN,THEN,LSQUAREB,DIV,AND,EOF, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { EQ,IN,COMMA,RCURLYB,LPAREN,SEMICOLON,DO,LESSEQ,GREATER,RPAREN,LESS,RSQUAREB,NEQ,LSQUAREB,CARET,TIMES,AND,OR,MINUS,PLUS,EOF,THEN,MOD,GREATEREQ,ELSE,DIV, }
  (52) PlusExpr --> .PlusExpr MINUS TimesExpr  { LESS,THEN,RPAREN,SEMICOLON,COMMA,LESSEQ,NEQ,PLUS,GREATEREQ,CARET,OR,ELSE,IN,DO,GREATER,EOF,AND,EQ,MINUS,RSQUAREB,RCURLYB, }
  (54) TimesExpr --> .TimesExpr TIMES UnaryExpr  { RPAREN,ELSE,EOF,DIV,CARET,SEMICOLON,THEN,LESSEQ,GREATEREQ,PLUS,GREATER,MINUS,EQ,IN,DO,MOD,RCURLYB,AND,COMMA,RSQUAREB,TIMES,NEQ,OR,LESS, }
  (41) UnaryExpr --> .RValue  { MINUS,EOF,CARET,TIMES,RCURLYB,THEN,SEMICOLON,GREATEREQ,DO,NEQ,LESS,EQ,LESSEQ,RSQUAREB,AND,IN,MOD,ELSE,OR,PLUS,DIV,COMMA,GREATER,RPAREN, }
  (66) RValue --> .Integer  { TIMES,OR,EOF,PLUS,GREATEREQ,NEQ,RCURLYB,RSQUAREB,COMMA,RPAREN,MINUS,AND,DO,EQ,LSQUAREB,LESS,DIV,LPAREN,GREATER,THEN,IN,LESSEQ,CARET,ELSE,MOD,SEMICOLON, }
  (56) TimesExpr --> .TimesExpr MOD UnaryExpr  { RSQUAREB,OR,MOD,THEN,EOF,EQ,CARET,RCURLYB,DO,MINUS,NEQ,TIMES,DIV,PLUS,COMMA,GREATER,ELSE,SEMICOLON,LESS,AND,GREATEREQ,IN,LESSEQ,RPAREN, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { OR,THEN,LESS,NEQ,LPAREN,GREATER,RCURLYB,RSQUAREB,MOD,ELSE,GREATEREQ,EQ,DIV,SEMICOLON,LSQUAREB,TIMES,IN,PLUS,AND,COMMA,RPAREN,LESSEQ,EOF,CARET,MINUS,DO, }
  (68) RValue --> .StringLit  { NEQ,DIV,RPAREN,LESSEQ,LSQUAREB,THEN,IN,MOD,RSQUAREB,SEMICOLON,LESS,TIMES,DO,ELSE,PLUS,CARET,EQ,GREATER,GREATEREQ,COMMA,MINUS,OR,RCURLYB,EOF,AND,LPAREN, }
  (38) PlusExpr --> .TimesExpr  { RSQUAREB,CARET,RCURLYB,IN,PLUS,LESS,AND,ELSE,LESSEQ,GREATEREQ,DO,NEQ,RPAREN,THEN,OR,EQ,GREATER,EOF,MINUS,SEMICOLON,COMMA, }
  (67) RValue --> .Float  { THEN,SEMICOLON,IN,GREATEREQ,LESSEQ,EOF,MOD,ELSE,LSQUAREB,RCURLYB,EQ,AND,PLUS,NEQ,RPAREN,COMMA,RSQUAREB,LPAREN,CARET,DIV,MINUS,GREATER,LESS,OR,DO,TIMES, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { LESS,CARET,GREATEREQ,ELSE,RCURLYB,GREATER,THEN,TIMES,RSQUAREB,DIV,EQ,AND,COMMA,MINUS,OR,LESSEQ,IN,SEMICOLON,EOF,NEQ,RPAREN,MOD,DO,PLUS, }
  (39) TimesExpr --> .UnaryExpr  { NEQ,MINUS,COMMA,RSQUAREB,GREATEREQ,DO,LESSEQ,RCURLYB,THEN,AND,GREATER,CARET,EOF,PLUS,OR,DIV,EQ,TIMES,LESS,ELSE,IN,MOD,SEMICOLON,RPAREN, }
  (55) TimesExpr --> .TimesExpr DIV UnaryExpr  { CARET,AND,ELSE,RPAREN,GREATEREQ,RCURLYB,NEQ,MINUS,EQ,MOD,DIV,LESS,OR,THEN,GREATER,PLUS,EOF,SEMICOLON,LESSEQ,RSQUAREB,DO,TIMES,IN,COMMA, }
  (57) UnaryExpr --> .NOT UnaryExpr  { RSQUAREB,EOF,SEMICOLON,TIMES,GREATEREQ,DIV,DO,THEN,GREATER,RPAREN,MINUS,CARET,COMMA,OR,MOD,NEQ,LESS,AND,EQ,PLUS,ELSE,LESSEQ,RCURLYB,IN, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { MOD,EQ,THEN,DIV,PLUS,LESSEQ,RCURLYB,GREATEREQ,RSQUAREB,EOF,RPAREN,NEQ,OR,IN,ELSE,AND,TIMES,CARET,LESS,COMMA,MINUS,GREATER,DO,SEMICOLON, }
  (50) CompExpr --> CompExpr GREATEREQ .PlusExpr  { GREATER,OR,RSQUAREB,IN,RCURLYB,RPAREN,THEN,SEMICOLON,COMMA,ELSE,DO,GREATEREQ,EOF,LESS,LESSEQ,AND,EQ,NEQ, }
  (40) UnaryExpr --> .LValue  { RPAREN,TIMES,GREATER,COMMA,LESS,CARET,DIV,SEMICOLON,GREATEREQ,RCURLYB,EOF,OR,IN,RSQUAREB,AND,DO,MOD,LESSEQ,EQ,THEN,MINUS,PLUS,ELSE,NEQ, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { MINUS,MOD,GREATER,PLUS,COMMA,RCURLYB,THEN,SEMICOLON,RPAREN,TIMES,CARET,IN,RSQUAREB,DO,LPAREN,DIV,NEQ,EQ,LESS,GREATEREQ,LESSEQ,EOF,OR,LSQUAREB,ELSE,AND, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { AND,DIV,GREATER,DO,RSQUAREB,COMMA,LESS,LPAREN,EOF,OR,NEQ,GREATEREQ,EQ,RPAREN,THEN,IN,ELSE,CARET,LSQUAREB,LESSEQ,TIMES,PLUS,MINUS,SEMICOLON,MOD,RCURLYB, }
state 49:
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { IN,AND,LESS,GREATER,LPAREN,COMMA,THEN,LESSEQ,OR,LSQUAREB,RCURLYB,MINUS,PLUS,EQ,DIV,EOF,TIMES,RSQUAREB,DO,CARET,MOD,GREATEREQ,SEMICOLON,RPAREN,ELSE,NEQ, }
  (55) TimesExpr --> .TimesExpr DIV UnaryExpr  { RPAREN,AND,LESS,GREATEREQ,EQ,MOD,EOF,RSQUAREB,LESSEQ,DO,OR,CARET,DIV,IN,ELSE,PLUS,THEN,COMMA,TIMES,NEQ,SEMICOLON,GREATER,RCURLYB,MINUS, }
  (24) LValue --> .Var  { AND,SEMICOLON,RPAREN,DO,PLUS,COMMA,LESS,RSQUAREB,RCURLYB,NEQ,CARET,LPAREN,OR,GREATEREQ,TIMES,MINUS,DIV,GREATER,LSQUAREB,ELSE,IN,EQ,LESSEQ,MOD,EOF,THEN, }
  (48) CompExpr --> CompExpr GREATER .PlusExpr  { RPAREN,COMMA,IN,GREATEREQ,RCURLYB,THEN,OR,EQ,ELSE,GREATER,SEMICOLON,NEQ,RSQUAREB,DO,EOF,LESSEQ,LESS,AND, }
  (38) PlusExpr --> .TimesExpr  { EOF,DO,ELSE,IN,MINUS,AND,THEN,GREATEREQ,RPAREN,COMMA,RCURLYB,SEMICOLON,PLUS,LESS,EQ,LESSEQ,RSQUAREB,NEQ,CARET,GREATER,OR, }
  (52) PlusExpr --> .PlusExpr MINUS TimesExpr  { SEMICOLON,AND,RCURLYB,CARET,GREATER,IN,RPAREN,LESS,GREATEREQ,NEQ,EQ,DO,EOF,RSQUAREB,ELSE,MINUS,THEN,COMMA,LESSEQ,PLUS,OR, }
  (68) RValue --> .StringLit  { PLUS,LPAREN,AND,IN,GREATEREQ,LSQUAREB,ELSE,MINUS,EQ,COMMA,RSQUAREB,RPAREN,DO,SEMICOLON,LESS,GREATER,THEN,OR,MOD,LESSEQ,RCURLYB,NEQ,DIV,CARET,EOF,TIMES, }
  (57) UnaryExpr --> .NOT UnaryExpr  { TIMES,MINUS,RCURLYB,DO,LESS,EQ,GREATEREQ,DIV,MOD,COMMA,NEQ,LESSEQ,SEMICOLON,RPAREN,ELSE,CARET,EOF,RSQUAREB,GREATER,IN,AND,PLUS,OR,THEN, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { GREATEREQ,GREATER,EOF,RSQUAREB,CARET,RPAREN,TIMES,RCURLYB,MOD,LSQUAREB,LPAREN,SEMICOLON,AND,EQ,COMMA,IN,NEQ,LESS,THEN,OR,ELSE,MINUS,DIV,DO,LESSEQ,PLUS, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { GREATER,SEMICOLON,ELSE,DIV,RCURLYB,AND,GREATEREQ,PLUS,NEQ,MOD,TIMES,OR,EQ,RPAREN,THEN,COMMA,DO,CARET,LESS,IN,LESSEQ,RSQUAREB,MINUS,EOF, }
  (53) PlusExpr --> .PlusExpr CARET TimesExpr  { NEQ,LESSEQ,GREATER,EQ,IN,ELSE,PLUS,AND,RCURLYB,THEN,RPAREN,COMMA,LESS,EOF,DO,OR,MINUS,SEMICOLON,RSQUAREB,GREATEREQ,CARET, }
  (41) UnaryExpr --> .RValue  { OR,SEMICOLON,TIMES,AND,THEN,RCURLYB,IN,RPAREN,EOF,DO,ELSE,EQ,MINUS,GREATEREQ,COMMA,DIV,MOD,RSQUAREB,LESS,PLUS,LESSEQ,GREATER,CARET,NEQ, }
  (39) TimesExpr --> .UnaryExpr  { GREATER,CARET,MINUS,PLUS,EQ,EOF,TIMES,MOD,IN,RPAREN,RSQUAREB,DO,DIV,LESSEQ,COMMA,SEMICOLON,ELSE,GREATEREQ,THEN,NEQ,LESS,RCURLYB,OR,AND, }
  (54) TimesExpr --> .TimesExpr TIMES UnaryExpr  { MINUS,DO,OR,CARET,DIV,ELSE,RPAREN,RSQUAREB,LESS,EQ,GREATEREQ,THEN,GREATER,TIMES,COMMA,IN,RCURLYB,AND,SEMICOLON,LESSEQ,MOD,EOF,PLUS,NEQ, }
  (40) UnaryExpr --> .LValue  { OR,GREATEREQ,MOD,EQ,IN,TIMES,RSQUAREB,RCURLYB,COMMA,SEMICOLON,EOF,DIV,LESS,ELSE,LESSEQ,RPAREN,DO,AND,NEQ,MINUS,PLUS,GREATER,CARET,THEN, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { PLUS,IN,RCURLYB,EQ,DIV,GREATER,LESS,MINUS,RSQUAREB,LPAREN,GREATEREQ,CARET,MOD,COMMA,DO,LSQUAREB,AND,ELSE,THEN,SEMICOLON,EOF,NEQ,OR,RPAREN,LESSEQ,TIMES, }
  (42) RValue --> .LPAREN Expr RPAREN  { EQ,ELSE,RCURLYB,MINUS,EOF,RPAREN,OR,GREATEREQ,PLUS,NEQ,COMMA,MOD,LESSEQ,DIV,LESS,GREATER,SEMICOLON,RSQUAREB,CARET,IN,LPAREN,LSQUAREB,AND,TIMES,THEN,DO, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { DO,IN,DIV,RSQUAREB,ELSE,THEN,GREATEREQ,CARET,OR,RPAREN,LPAREN,TIMES,LESSEQ,MOD,RCURLYB,COMMA,PLUS,MINUS,SEMICOLON,EOF,NEQ,LESS,GREATER,LSQUAREB,AND,EQ, }
  (56) TimesExpr --> .TimesExpr MOD UnaryExpr  { THEN,DO,RSQUAREB,OR,COMMA,LESSEQ,CARET,AND,EQ,MINUS,PLUS,DIV,NEQ,ELSE,TIMES,EOF,IN,SEMICOLON,RPAREN,RCURLYB,GREATER,MOD,LESS,GREATEREQ, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { LPAREN,EQ,OR,LSQUAREB,DIV,CARET,DO,AND,MOD,RPAREN,GREATER,LESS,PLUS,RCURLYB,IN,TIMES,COMMA,THEN,ELSE,GREATEREQ,MINUS,EOF,NEQ,LESSEQ,SEMICOLON,RSQUAREB, }
  (51) PlusExpr --> .PlusExpr PLUS TimesExpr  { LESSEQ,GREATER,NEQ,LESS,CARET,IN,RPAREN,GREATEREQ,EQ,ELSE,RSQUAREB,SEMICOLON,THEN,AND,MINUS,EOF,RCURLYB,DO,COMMA,OR,PLUS, }
  (66) RValue --> .Integer  { EOF,LESSEQ,SEMICOLON,DIV,OR,EQ,COMMA,RSQUAREB,LPAREN,MOD,IN,GREATEREQ,RCURLYB,GREATER,DO,RPAREN,PLUS,LESS,LSQUAREB,CARET,THEN,NEQ,TIMES,ELSE,MINUS,AND, }
  (67) RValue --> .Float  { DO,CARET,MINUS,GREATER,EOF,MOD,NEQ,EQ,THEN,IN,GREATEREQ,LPAREN,RCURLYB,LESS,LSQUAREB,AND,DIV,OR,TIMES,COMMA,RSQUAREB,PLUS,LESSEQ,SEMICOLON,ELSE,RPAREN, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { LESS,RCURLYB,MOD,RSQUAREB,COMMA,THEN,CARET,DO,AND,LPAREN,LSQUAREB,DIV,NEQ,PLUS,MINUS,TIMES,SEMICOLON,ELSE,EQ,EOF,RPAREN,LESSEQ,GREATEREQ,OR,IN,GREATER, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { MINUS,COMMA,NEQ,IN,EOF,TIMES,THEN,DIV,GREATER,LESSEQ,RSQUAREB,EQ,SEMICOLON,OR,RCURLYB,LESS,ELSE,RPAREN,CARET,MOD,PLUS,GREATEREQ,DO,AND, }
state 50:
  (66) RValue --> .Integer  { MOD,RCURLYB,LESSEQ,TIMES,AND,RPAREN,RSQUAREB,LPAREN,OR,DIV,EOF,IN,CARET,NEQ,DO,GREATER,EQ,GREATEREQ,THEN,ELSE,MINUS,LSQUAREB,PLUS,SEMICOLON,LESS,COMMA, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { MOD,GREATEREQ,PLUS,RPAREN,MINUS,EOF,CARET,LSQUAREB,DO,EQ,RCURLYB,LESSEQ,AND,SEMICOLON,RSQUAREB,LPAREN,OR,ELSE,TIMES,COMMA,DIV,THEN,GREATER,LESS,IN,NEQ, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { CARET,PLUS,MINUS,NEQ,OR,EQ,RPAREN,LESS,AND,THEN,ELSE,LSQUAREB,SEMICOLON,LPAREN,EOF,MOD,RCURLYB,LESSEQ,DIV,TIMES,COMMA,DO,RSQUAREB,IN,GREATEREQ,GREATER, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { NEQ,COMMA,AND,THEN,DO,RCURLYB,RPAREN,TIMES,GREATEREQ,DIV,EOF,EQ,RSQUAREB,OR,GREATER,LESS,LESSEQ,IN,PLUS,ELSE,MOD,CARET,MINUS,LPAREN,LSQUAREB,SEMICOLON, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { MOD,EQ,LESS,ELSE,LPAREN,RSQUAREB,RPAREN,SEMICOLON,GREATEREQ,MINUS,RCURLYB,TIMES,EOF,NEQ,DIV,IN,CARET,LESSEQ,AND,OR,PLUS,DO,COMMA,LSQUAREB,THEN,GREATER, }
  (42) RValue --> .LPAREN Expr RPAREN  { IN,GREATER,EQ,LESSEQ,AND,LPAREN,COMMA,RSQUAREB,LSQUAREB,CARET,SEMICOLON,MOD,DO,TIMES,RCURLYB,GREATEREQ,ELSE,OR,LESS,NEQ,RPAREN,THEN,DIV,PLUS,MINUS,EOF, }
  (67) RValue --> .Float  { THEN,GREATEREQ,ELSE,LESSEQ,LSQUAREB,TIMES,DO,MOD,DIV,AND,SEMICOLON,GREATER,COMMA,EQ,CARET,RCURLYB,LESS,NEQ,MINUS,RSQUAREB,PLUS,LPAREN,RPAREN,OR,IN,EOF, }
  (55) TimesExpr --> TimesExpr DIV .UnaryExpr  { CARET,DO,MOD,RSQUAREB,LESS,AND,EQ,COMMA,RPAREN,TIMES,LESSEQ,PLUS,DIV,IN,EOF,MINUS,ELSE,OR,GREATEREQ,GREATER,SEMICOLON,NEQ,THEN,RCURLYB, }
  (57) UnaryExpr --> .NOT UnaryExpr  { DO,RPAREN,COMMA,ELSE,THEN,RCURLYB,LESS,MINUS,TIMES,EOF,OR,GREATEREQ,DIV,AND,EQ,GREATER,SEMICOLON,CARET,LESSEQ,RSQUAREB,IN,MOD,PLUS,NEQ, }
  (41) UnaryExpr --> .RValue  { EOF,DIV,PLUS,MOD,MINUS,AND,RPAREN,OR,LESSEQ,GREATER,ELSE,GREATEREQ,DO,RSQUAREB,CARET,EQ,NEQ,THEN,RCURLYB,COMMA,IN,SEMICOLON,TIMES,LESS, }
  (68) RValue --> .StringLit  { LESSEQ,CARET,EOF,THEN,RCURLYB,EQ,LESS,NEQ,ELSE,TIMES,OR,IN,LPAREN,GREATEREQ,DIV,PLUS,RSQUAREB,SEMICOLON,MOD,COMMA,AND,RPAREN,GREATER,MINUS,DO,LSQUAREB, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { ELSE,OR,RSQUAREB,GREATER,RCURLYB,TIMES,PLUS,MINUS,AND,LESSEQ,DO,GREATEREQ,MOD,IN,CARET,DIV,THEN,EOF,COMMA,EQ,RPAREN,SEMICOLON,NEQ,LESS, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { MOD,SEMICOLON,PLUS,EOF,LPAREN,LSQUAREB,RCURLYB,ELSE,NEQ,MINUS,IN,DO,GREATER,RPAREN,DIV,OR,AND,LESS,EQ,TIMES,LESSEQ,COMMA,CARET,THEN,GREATEREQ,RSQUAREB, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { DO,CARET,COMMA,IN,MINUS,TIMES,SEMICOLON,GREATEREQ,RCURLYB,EOF,NEQ,RPAREN,LESSEQ,PLUS,THEN,DIV,RSQUAREB,ELSE,AND,MOD,GREATER,OR,EQ,LESS, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { RSQUAREB,LPAREN,EQ,DIV,TIMES,AND,SEMICOLON,GREATEREQ,RCURLYB,EOF,LSQUAREB,GREATER,PLUS,LESS,CARET,RPAREN,NEQ,MOD,MINUS,ELSE,COMMA,DO,THEN,IN,OR,LESSEQ, }
  (24) LValue --> .Var  { CARET,LPAREN,TIMES,THEN,RSQUAREB,RPAREN,GREATEREQ,DIV,GREATER,LSQUAREB,NEQ,COMMA,EOF,MOD,ELSE,OR,RCURLYB,AND,LESSEQ,LESS,EQ,PLUS,DO,SEMICOLON,IN,MINUS, }
  (40) UnaryExpr --> .LValue  { EQ,THEN,AND,CARET,DIV,MINUS,TIMES,COMMA,NEQ,RSQUAREB,DO,RCURLYB,LESSEQ,EOF,GREATER,RPAREN,GREATEREQ,IN,SEMICOLON,PLUS,LESS,ELSE,MOD,OR, }
state 51:
  (68) RValue --> .StringLit  { TIMES,AND,PLUS,MINUS,LESSEQ,RSQUAREB,LPAREN,MOD,COMMA,CARET,LESS,OR,GREATEREQ,RPAREN,ELSE,THEN,LSQUAREB,EOF,IN,DO,RCURLYB,NEQ,SEMICOLON,GREATER,EQ,DIV, }
  (24) LValue --> .Var  { GREATER,TIMES,MOD,MINUS,LESSEQ,LESS,LPAREN,THEN,CARET,AND,PLUS,EOF,GREATEREQ,RPAREN,LSQUAREB,RCURLYB,DO,RSQUAREB,SEMICOLON,NEQ,EQ,ELSE,OR,IN,COMMA,DIV, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { RSQUAREB,MOD,NEQ,RCURLYB,COMMA,EOF,THEN,CARET,GREATEREQ,DIV,AND,IN,TIMES,ELSE,MINUS,PLUS,DO,GREATER,LESSEQ,EQ,SEMICOLON,LESS,OR,RPAREN, }
  (42) RValue --> .LPAREN Expr RPAREN  { AND,SEMICOLON,RPAREN,LESSEQ,THEN,GREATEREQ,RSQUAREB,CARET,LSQUAREB,EQ,MINUS,ELSE,GREATER,RCURLYB,DIV,TIMES,PLUS,LESS,COMMA,OR,DO,NEQ,MOD,IN,LPAREN,EOF, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { EQ,SEMICOLON,LPAREN,LESS,ELSE,DIV,MINUS,CARET,RSQUAREB,GREATEREQ,NEQ,PLUS,TIMES,LESSEQ,EOF,THEN,OR,RCURLYB,RPAREN,IN,DO,LSQUAREB,GREATER,MOD,COMMA,AND, }
  (41) UnaryExpr --> .RValue  { LESSEQ,ELSE,GREATEREQ,PLUS,RCURLYB,NEQ,TIMES,IN,THEN,RSQUAREB,GREATER,MOD,CARET,DO,EOF,DIV,MINUS,EQ,LESS,SEMICOLON,RPAREN,OR,AND,COMMA, }
  (66) RValue --> .Integer  { ELSE,EOF,LESSEQ,CARET,MOD,OR,LPAREN,AND,RSQUAREB,LESS,GREATER,MINUS,COMMA,NEQ,GREATEREQ,DIV,DO,IN,TIMES,THEN,RPAREN,SEMICOLON,LSQUAREB,PLUS,EQ,RCURLYB, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { MINUS,AND,OR,SEMICOLON,IN,TIMES,EQ,PLUS,LSQUAREB,RPAREN,GREATEREQ,ELSE,THEN,DO,GREATER,NEQ,LPAREN,LESSEQ,RCURLYB,EOF,MOD,COMMA,LESS,DIV,CARET,RSQUAREB, }
  (40) UnaryExpr --> .LValue  { ELSE,MINUS,GREATEREQ,EQ,EOF,DO,IN,AND,NEQ,GREATER,SEMICOLON,RSQUAREB,TIMES,THEN,PLUS,MOD,LESSEQ,OR,RCURLYB,COMMA,DIV,RPAREN,CARET,LESS, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { DO,MOD,PLUS,RPAREN,LESS,OR,CARET,SEMICOLON,LSQUAREB,GREATER,IN,AND,EQ,COMMA,NEQ,RSQUAREB,EOF,MINUS,RCURLYB,TIMES,LESSEQ,THEN,GREATEREQ,DIV,LPAREN,ELSE, }
  (54) TimesExpr --> TimesExpr TIMES .UnaryExpr  { DO,AND,LESSEQ,EOF,RSQUAREB,RPAREN,IN,NEQ,LESS,GREATER,COMMA,ELSE,CARET,OR,EQ,GREATEREQ,DIV,RCURLYB,MOD,THEN,PLUS,SEMICOLON,TIMES,MINUS, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { RSQUAREB,EQ,MOD,LESSEQ,DO,NEQ,TIMES,MINUS,OR,RCURLYB,AND,PLUS,SEMICOLON,THEN,EOF,GREATEREQ,RPAREN,DIV,LESS,LSQUAREB,CARET,IN,COMMA,GREATER,ELSE,LPAREN, }
  (57) UnaryExpr --> .NOT UnaryExpr  { RCURLYB,RSQUAREB,ELSE,COMMA,MINUS,TIMES,GREATER,CARET,EOF,RPAREN,GREATEREQ,PLUS,SEMICOLON,NEQ,IN,THEN,EQ,LESSEQ,OR,AND,LESS,DO,MOD,DIV, }
  (67) RValue --> .Float  { MOD,COMMA,RPAREN,LESSEQ,CARET,LPAREN,ELSE,EQ,RSQUAREB,OR,DIV,SEMICOLON,TIMES,LESS,IN,EOF,AND,NEQ,DO,GREATER,PLUS,MINUS,RCURLYB,THEN,LSQUAREB,GREATEREQ, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { LESS,COMMA,THEN,OR,RCURLYB,EQ,DO,AND,RSQUAREB,EOF,CARET,ELSE,IN,LSQUAREB,NEQ,MOD,GREATER,LESSEQ,PLUS,LPAREN,DIV,SEMICOLON,MINUS,TIMES,GREATEREQ,RPAREN, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { SEMICOLON,OR,MINUS,LSQUAREB,TIMES,GREATEREQ,DIV,LESSEQ,RSQUAREB,NEQ,AND,RPAREN,GREATER,IN,LPAREN,LESS,CARET,EQ,RCURLYB,COMMA,MOD,DO,THEN,EOF,ELSE,PLUS, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { PLUS,ELSE,IN,RCURLYB,COMMA,CARET,MOD,RSQUAREB,MINUS,DO,DIV,LESS,NEQ,THEN,AND,EQ,SEMICOLON,TIMES,GREATER,OR,GREATEREQ,EOF,LESSEQ,RPAREN, }
state 52:
  (68) RValue --> .StringLit  { RSQUAREB,THEN,CARET,RCURLYB,DIV,SEMICOLON,ELSE,IN,DO,OR,EQ,LESS,AND,TIMES,GREATER,LSQUAREB,GREATEREQ,LESSEQ,MOD,NEQ,LPAREN,PLUS,EOF,COMMA,MINUS,RPAREN, }
  (66) RValue --> .Integer  { DO,LESS,RPAREN,EQ,GREATEREQ,LPAREN,THEN,ELSE,IN,PLUS,NEQ,LSQUAREB,COMMA,MINUS,AND,TIMES,CARET,GREATER,LESSEQ,SEMICOLON,EOF,RCURLYB,DIV,MOD,RSQUAREB,OR, }
  (56) TimesExpr --> TimesExpr MOD .UnaryExpr  { PLUS,GREATER,ELSE,GREATEREQ,SEMICOLON,RCURLYB,THEN,MOD,OR,LESS,LESSEQ,DO,AND,TIMES,MINUS,COMMA,EOF,DIV,NEQ,RSQUAREB,RPAREN,EQ,CARET,IN, }
  (42) RValue --> .LPAREN Expr RPAREN  { CARET,RPAREN,IN,EQ,TIMES,THEN,COMMA,GREATER,LSQUAREB,AND,LESS,DIV,SEMICOLON,LESSEQ,OR,MOD,PLUS,NEQ,DO,MINUS,GREATEREQ,RCURLYB,EOF,RSQUAREB,LPAREN,ELSE, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { SEMICOLON,EOF,AND,GREATEREQ,OR,RSQUAREB,EQ,LESS,IN,LSQUAREB,ELSE,THEN,LESSEQ,TIMES,RPAREN,NEQ,CARET,GREATER,DO,LPAREN,RCURLYB,DIV,MINUS,COMMA,PLUS,MOD, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { IN,SEMICOLON,THEN,OR,LSQUAREB,RSQUAREB,LESS,AND,EQ,LPAREN,GREATEREQ,TIMES,RPAREN,NEQ,DIV,RCURLYB,PLUS,EOF,MOD,ELSE,MINUS,CARET,LESSEQ,COMMA,DO,GREATER, }
  (24) LValue --> .Var  { GREATEREQ,LESS,SEMICOLON,DO,THEN,ELSE,CARET,GREATER,RSQUAREB,LSQUAREB,DIV,RPAREN,LPAREN,EQ,OR,MINUS,COMMA,TIMES,IN,LESSEQ,NEQ,MOD,AND,EOF,PLUS,RCURLYB, }
  (57) UnaryExpr --> .NOT UnaryExpr  { DIV,IN,RSQUAREB,GREATEREQ,SEMICOLON,NEQ,PLUS,THEN,COMMA,EOF,MOD,OR,EQ,TIMES,LESS,LESSEQ,DO,AND,RPAREN,RCURLYB,GREATER,CARET,ELSE,MINUS, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { DIV,LESS,MOD,THEN,LSQUAREB,RPAREN,LESSEQ,ELSE,AND,EQ,CARET,EOF,GREATER,DO,MINUS,TIMES,NEQ,PLUS,GREATEREQ,OR,COMMA,IN,LPAREN,RSQUAREB,SEMICOLON,RCURLYB, }
  (40) UnaryExpr --> .LValue  { CARET,DIV,LESS,EOF,OR,RSQUAREB,SEMICOLON,TIMES,ELSE,AND,MINUS,THEN,MOD,LESSEQ,COMMA,GREATEREQ,RCURLYB,DO,PLUS,GREATER,IN,NEQ,EQ,RPAREN, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { RPAREN,COMMA,IN,MOD,SEMICOLON,PLUS,RSQUAREB,MINUS,GREATEREQ,ELSE,LESS,AND,EOF,THEN,LESSEQ,DIV,RCURLYB,CARET,EQ,GREATER,OR,NEQ,DO,TIMES, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { LSQUAREB,IN,LESS,COMMA,SEMICOLON,RPAREN,DO,RSQUAREB,PLUS,MOD,CARET,THEN,EQ,LPAREN,RCURLYB,LESSEQ,OR,GREATER,AND,NEQ,ELSE,TIMES,GREATEREQ,MINUS,EOF,DIV, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { DO,RPAREN,DIV,ELSE,GREATEREQ,EOF,EQ,AND,COMMA,RSQUAREB,LESSEQ,MINUS,MOD,GREATER,THEN,IN,PLUS,CARET,NEQ,TIMES,SEMICOLON,OR,LESS,RCURLYB, }
  (67) RValue --> .Float  { IN,LESS,NEQ,COMMA,LESSEQ,AND,MINUS,GREATER,EQ,DO,ELSE,CARET,OR,THEN,LSQUAREB,DIV,SEMICOLON,LPAREN,TIMES,RCURLYB,EOF,RSQUAREB,RPAREN,GREATEREQ,MOD,PLUS, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { IN,THEN,LSQUAREB,PLUS,RSQUAREB,MOD,DO,LPAREN,CARET,LESS,OR,RCURLYB,AND,DIV,RPAREN,COMMA,NEQ,GREATER,ELSE,MINUS,GREATEREQ,TIMES,SEMICOLON,LESSEQ,EOF,EQ, }
  (41) UnaryExpr --> .RValue  { RCURLYB,COMMA,DIV,EOF,AND,GREATEREQ,OR,LESSEQ,TIMES,IN,GREATER,THEN,CARET,RSQUAREB,ELSE,SEMICOLON,DO,MOD,LESS,PLUS,EQ,RPAREN,NEQ,MINUS, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { DIV,LSQUAREB,THEN,AND,PLUS,ELSE,RPAREN,CARET,GREATER,EOF,LPAREN,MINUS,RCURLYB,COMMA,RSQUAREB,DO,IN,GREATEREQ,TIMES,EQ,OR,LESSEQ,LESS,MOD,NEQ,SEMICOLON, }
state 53:
  (23) NonBlockExpr --> .LValue ASSIGN Expr  { RSQUAREB, }
  (40) UnaryExpr --> .LValue  { MINUS,MOD,AND,OR,GREATEREQ,RSQUAREB,TIMES,PLUS,LESS,CARET,EQ,GREATER,DIV,NEQ,LESSEQ, }
  (32) ReturnType --> .Type  { LAMBDA, }
  (8) Expr --> .NonBlockExpr  { RSQUAREB, }
  (17) BlockExpr --> .IF Expr THEN Expr ELSE BlockExpr  { RSQUAREB, }
  (50) CompExpr --> .CompExpr GREATEREQ PlusExpr  { RSQUAREB,EQ,LESSEQ,AND,LESS,GREATEREQ,NEQ,GREATER,OR, }
  (45) EqExpr --> .EqExpr EQ CompExpr  { OR,AND,NEQ,RSQUAREB,EQ, }
  (37) CompExpr --> .PlusExpr  { RSQUAREB,LESS,AND,GREATEREQ,OR,GREATER,NEQ,LESSEQ,EQ, }
  (49) CompExpr --> .CompExpr LESSEQ PlusExpr  { OR,EQ,NEQ,GREATER,LESSEQ,GREATEREQ,RSQUAREB,AND,LESS, }
  (54) TimesExpr --> .TimesExpr TIMES UnaryExpr  { PLUS,EQ,AND,LESS,MOD,NEQ,TIMES,MINUS,RSQUAREB,GREATEREQ,GREATER,DIV,LESSEQ,CARET,OR, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { DIV,RSQUAREB,GREATEREQ,MINUS,NEQ,MOD,CARET,GREATER,LESS,PLUS,EQ,TIMES,LPAREN,LESSEQ,OR,AND,LSQUAREB, }
  (53) PlusExpr --> .PlusExpr CARET TimesExpr  { RSQUAREB,PLUS,GREATEREQ,MINUS,GREATER,NEQ,LESSEQ,AND,OR,EQ,LESS,CARET, }
  (43) OrExpr --> .OrExpr OR AndExpr  { OR,RSQUAREB, }
  (47) CompExpr --> .CompExpr LESS PlusExpr  { LESS,LESSEQ,NEQ,RSQUAREB,AND,EQ,OR,GREATEREQ,GREATER, }
  (38) PlusExpr --> .TimesExpr  { GREATER,OR,EQ,LESS,AND,LESSEQ,RSQUAREB,PLUS,MINUS,NEQ,CARET,GREATEREQ, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { ASSIGN,MINUS,LESSEQ,MOD,GREATER,NEQ,RSQUAREB,LPAREN,GREATEREQ,DIV,AND,CARET,EQ,TIMES,LESS,LSQUAREB,OR,PLUS, }
  (16) BlockExpr --> .BlockStmt  { RSQUAREB, }
  (56) TimesExpr --> .TimesExpr MOD UnaryExpr  { DIV,OR,MOD,GREATEREQ,PLUS,AND,CARET,LESSEQ,TIMES,NEQ,GREATER,EQ,RSQUAREB,LESS,MINUS, }
  (6) BlockStmt --> .LCURLYB Stmts RCURLYB  { RSQUAREB, }
  (48) CompExpr --> .CompExpr GREATER PlusExpr  { EQ,OR,LESSEQ,LESS,AND,GREATER,NEQ,RSQUAREB,GREATEREQ, }
  (33) NonBlockExpr --> .OrExpr  { RSQUAREB, }
  (42) RValue --> .LPAREN Expr RPAREN  { MOD,LESS,NEQ,MINUS,RSQUAREB,EQ,AND,CARET,DIV,TIMES,PLUS,LESSEQ,GREATEREQ,LPAREN,GREATER,LSQUAREB,OR, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { LESS,EQ,DIV,MINUS,LPAREN,MOD,OR,RSQUAREB,CARET,GREATEREQ,AND,GREATER,PLUS,LESSEQ,LSQUAREB,TIMES,NEQ, }
  (19) BlockExpr --> .LET Param ASSIGN Expr IN BlockExpr  { RSQUAREB, }
  (73) Type --> .T_STRING  { LAMBDA,LSQUAREB, }
  (44) AndExpr --> .AndExpr AND EqExpr  { RSQUAREB,OR,AND, }
  (68) RValue --> .StringLit  { GREATER,LESS,MINUS,LPAREN,CARET,LSQUAREB,GREATEREQ,AND,LESSEQ,EQ,MOD,PLUS,DIV,RSQUAREB,TIMES,OR,NEQ, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { MINUS,RSQUAREB,EQ,GREATEREQ,AND,PLUS,OR,MOD,NEQ,LESSEQ,LSQUAREB,GREATER,DIV,LESS,CARET,TIMES,LPAREN, }
  (57) UnaryExpr --> .NOT UnaryExpr  { OR,DIV,MOD,CARET,GREATER,NEQ,RSQUAREB,AND,LESSEQ,LESS,EQ,TIMES,GREATEREQ,PLUS,MINUS, }
  (46) EqExpr --> .EqExpr NEQ CompExpr  { OR,AND,EQ,NEQ,RSQUAREB, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { RSQUAREB,CARET,DIV,LPAREN,OR,TIMES,MINUS,LSQUAREB,GREATEREQ,MOD,PLUS,LESS,AND,GREATER,LESSEQ,EQ,NEQ, }
  (51) PlusExpr --> .PlusExpr PLUS TimesExpr  { GREATER,EQ,OR,MINUS,CARET,AND,GREATEREQ,RSQUAREB,NEQ,PLUS,LESSEQ,LESS, }
  (34) OrExpr --> .AndExpr  { RSQUAREB,OR, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { CARET,LESS,MINUS,AND,GREATER,RSQUAREB,TIMES,NEQ,LPAREN,MOD,EQ,LESSEQ,PLUS,OR,GREATEREQ,LSQUAREB,DIV, }
  (7) Expr --> .BlockExpr  { RSQUAREB, }
  (31) ReturnType --> .T_VOID  { LAMBDA, }
  (39) TimesExpr --> .UnaryExpr  { LESSEQ,EQ,GREATEREQ,NEQ,MOD,CARET,OR,MINUS,TIMES,PLUS,RSQUAREB,DIV,AND,LESS,GREATER, }
  (21) NonBlockExpr --> .WHILE Expr DO NonBlockExpr  { RSQUAREB, }
  (26) NonBlockExpr --> .LAMBDA ParamList DOT Expr  { RSQUAREB, }
  (36) EqExpr --> .CompExpr  { RSQUAREB,NEQ,AND,EQ,OR, }
  (27) NonBlockExpr --> .ReturnType LAMBDA ParamList DOT Expr  { RSQUAREB, }
  (71) Type --> .T_INT  { LAMBDA,LSQUAREB, }
  (41) UnaryExpr --> .RValue  { GREATER,AND,DIV,RSQUAREB,NEQ,EQ,LESS,CARET,PLUS,GREATEREQ,MINUS,OR,MOD,LESSEQ,TIMES, }
  (22) NonBlockExpr --> .LET Param ASSIGN Expr IN NonBlockExpr  { RSQUAREB, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { OR,TIMES,GREATEREQ,PLUS,CARET,LESSEQ,MINUS,GREATER,RSQUAREB,DIV,MOD,AND,EQ,LESS,NEQ, }
  (72) Type --> .T_FLOAT  { LAMBDA,LSQUAREB, }
  (18) BlockExpr --> .WHILE Expr DO BlockExpr  { RSQUAREB, }
  (35) AndExpr --> .EqExpr  { OR,RSQUAREB,AND, }
  (52) PlusExpr --> .PlusExpr MINUS TimesExpr  { GREATER,MINUS,GREATEREQ,AND,CARET,NEQ,EQ,PLUS,OR,LESSEQ,RSQUAREB,LESS, }
  (66) RValue --> .Integer  { MOD,NEQ,MINUS,DIV,GREATER,CARET,GREATEREQ,EQ,TIMES,LPAREN,LESSEQ,LESS,OR,AND,RSQUAREB,PLUS,LSQUAREB, }
  (67) RValue --> .Float  { DIV,MOD,EQ,RSQUAREB,LESSEQ,CARET,GREATEREQ,TIMES,MINUS,LPAREN,GREATER,NEQ,LESS,AND,PLUS,OR,LSQUAREB, }
  (24) LValue --> .Var  { OR,TIMES,AND,LSQUAREB,CARET,MINUS,LESSEQ,PLUS,MOD,NEQ,LESS,RSQUAREB,DIV,ASSIGN,GREATER,LPAREN,GREATEREQ,EQ, }
  (74) Type --> .Type LSQUAREB RSQUAREB  { LSQUAREB,LAMBDA, }
  (55) TimesExpr --> .TimesExpr DIV UnaryExpr  { LESSEQ,GREATEREQ,LESS,EQ,GREATER,DIV,OR,TIMES,CARET,MOD,PLUS,MINUS,NEQ,RSQUAREB,AND, }
  (20) NonBlockExpr --> .IF Expr THEN Expr ELSE NonBlockExpr  { RSQUAREB, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { LESS,TIMES,AND,OR,NEQ,PLUS,LESSEQ,MINUS,DIV,CARET,RSQUAREB,GREATEREQ,MOD,EQ,GREATER, }
  (62) RValue --> RValue LSQUAREB .Expr RSQUAREB  { RSQUAREB,DIV,DO,PLUS,MINUS,LPAREN,LESS,AND,NEQ,MOD,LESSEQ,LSQUAREB,RPAREN,TIMES,OR,EOF,THEN,ELSE,EQ,SEMICOLON,GREATER,CARET,COMMA,GREATEREQ,RCURLYB,IN, }
state 54:
  (53) PlusExpr --> .PlusExpr CARET TimesExpr  { EQ,MINUS,CARET,PLUS,NEQ,GREATEREQ,GREATER,LESSEQ,AND,RPAREN,LESS,COMMA,OR, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { PLUS,EQ,TIMES,CARET,RPAREN,NEQ,MOD,COMMA,GREATER,LESSEQ,LSQUAREB,LESS,GREATEREQ,LPAREN,DIV,MINUS,AND,OR, }
  (56) TimesExpr --> .TimesExpr MOD UnaryExpr  { LESSEQ,TIMES,GREATEREQ,OR,RPAREN,EQ,COMMA,MINUS,CARET,NEQ,AND,DIV,LESS,PLUS,MOD,GREATER, }
  (72) Type --> .T_FLOAT  { LSQUAREB,LAMBDA, }
  (47) CompExpr --> .CompExpr LESS PlusExpr  { GREATER,LESS,GREATEREQ,RPAREN,NEQ,OR,EQ,AND,LESSEQ,COMMA, }
  (21) NonBlockExpr --> .WHILE Expr DO NonBlockExpr  { COMMA,RPAREN, }
  (35) AndExpr --> .EqExpr  { RPAREN,OR,COMMA,AND, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { OR,TIMES,LESS,LESSEQ,MINUS,LPAREN,LSQUAREB,NEQ,PLUS,AND,RPAREN,EQ,MOD,COMMA,CARET,GREATER,GREATEREQ,DIV, }
  (36) EqExpr --> .CompExpr  { COMMA,NEQ,OR,EQ,RPAREN,AND, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { MINUS,OR,LSQUAREB,RPAREN,EQ,LESS,DIV,LPAREN,LESSEQ,CARET,GREATER,PLUS,COMMA,NEQ,TIMES,AND,GREATEREQ,MOD, }
  (55) TimesExpr --> .TimesExpr DIV UnaryExpr  { CARET,DIV,LESS,OR,PLUS,GREATER,COMMA,AND,GREATEREQ,MINUS,NEQ,TIMES,EQ,MOD,RPAREN,LESSEQ, }
  (27) NonBlockExpr --> .ReturnType LAMBDA ParamList DOT Expr  { COMMA,RPAREN, }
  (66) RValue --> .Integer  { MINUS,LPAREN,EQ,AND,PLUS,COMMA,DIV,NEQ,LESS,TIMES,RPAREN,LESSEQ,CARET,LSQUAREB,MOD,OR,GREATER,GREATEREQ, }
  (64) ArgList --> .Expr  { RPAREN, }
  (74) Type --> .Type LSQUAREB RSQUAREB  { LAMBDA,LSQUAREB, }
  (42) RValue --> .LPAREN Expr RPAREN  { MOD,COMMA,PLUS,AND,MINUS,LPAREN,EQ,NEQ,LESS,TIMES,RPAREN,DIV,GREATER,OR,GREATEREQ,LESSEQ,LSQUAREB,CARET, }
  (45) EqExpr --> .EqExpr EQ CompExpr  { RPAREN,AND,EQ,COMMA,OR,NEQ, }
  (41) UnaryExpr --> .RValue  { MINUS,LESSEQ,LESS,MOD,EQ,GREATER,AND,OR,GREATEREQ,DIV,TIMES,PLUS,NEQ,CARET,COMMA,RPAREN, }
  (17) BlockExpr --> .IF Expr THEN Expr ELSE BlockExpr  { RPAREN,COMMA, }
  (37) CompExpr --> .PlusExpr  { LESS,COMMA,EQ,OR,LESSEQ,GREATEREQ,AND,RPAREN,NEQ,GREATER, }
  (22) NonBlockExpr --> .LET Param ASSIGN Expr IN NonBlockExpr  { RPAREN,COMMA, }
  (34) OrExpr --> .AndExpr  { RPAREN,OR,COMMA, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { COMMA,RPAREN,MOD,PLUS,GREATEREQ,CARET,MINUS,LESS,LESSEQ,GREATER,EQ,AND,DIV,OR,TIMES,NEQ, }
  (31) ReturnType --> .T_VOID  { LAMBDA, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { LESSEQ,AND,EQ,TIMES,NEQ,GREATER,COMMA,PLUS,DIV,MINUS,OR,MOD,RPAREN,GREATEREQ,LESS,CARET, }
  (43) OrExpr --> .OrExpr OR AndExpr  { COMMA,RPAREN,OR, }
  (8) Expr --> .NonBlockExpr  { RPAREN,COMMA, }
  (71) Type --> .T_INT  { LAMBDA,LSQUAREB, }
  (20) NonBlockExpr --> .IF Expr THEN Expr ELSE NonBlockExpr  { COMMA,RPAREN, }
  (18) BlockExpr --> .WHILE Expr DO BlockExpr  { COMMA,RPAREN, }
  (16) BlockExpr --> .BlockStmt  { RPAREN,COMMA, }
  (7) Expr --> .BlockExpr  { COMMA,RPAREN, }
  (57) UnaryExpr --> .NOT UnaryExpr  { LESSEQ,MOD,GREATEREQ,RPAREN,NEQ,LESS,COMMA,CARET,OR,PLUS,AND,DIV,TIMES,EQ,GREATER,MINUS, }
  (63) ArgList --> .  { RPAREN, }
  (39) TimesExpr --> .UnaryExpr  { GREATER,OR,DIV,NEQ,EQ,LESS,PLUS,GREATEREQ,TIMES,CARET,RPAREN,LESSEQ,COMMA,MINUS,AND,MOD, }
  (24) LValue --> .Var  { LPAREN,ASSIGN,AND,EQ,DIV,MINUS,GREATER,TIMES,LSQUAREB,PLUS,NEQ,MOD,LESS,LESSEQ,CARET,OR,COMMA,GREATEREQ,RPAREN, }
  (33) NonBlockExpr --> .OrExpr  { RPAREN,COMMA, }
  (52) PlusExpr --> .PlusExpr MINUS TimesExpr  { CARET,LESS,GREATER,NEQ,PLUS,OR,RPAREN,GREATEREQ,AND,LESSEQ,MINUS,EQ,COMMA, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { MOD,EQ,LESSEQ,TIMES,OR,MINUS,PLUS,CARET,AND,RPAREN,LESS,COMMA,NEQ,GREATEREQ,GREATER,LPAREN,DIV,LSQUAREB, }
  (44) AndExpr --> .AndExpr AND EqExpr  { RPAREN,COMMA,AND,OR, }
  (23) NonBlockExpr --> .LValue ASSIGN Expr  { COMMA,RPAREN, }
  (32) ReturnType --> .Type  { LAMBDA, }
  (46) EqExpr --> .EqExpr NEQ CompExpr  { EQ,OR,AND,RPAREN,NEQ,COMMA, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { AND,LPAREN,NEQ,LESSEQ,GREATER,MOD,CARET,DIV,LSQUAREB,COMMA,OR,PLUS,EQ,TIMES,LESS,MINUS,RPAREN,GREATEREQ, }
  (65) ArgList --> .Expr COMMA ArgList  { RPAREN, }
  (67) RValue --> .Float  { DIV,MINUS,AND,EQ,GREATEREQ,CARET,PLUS,LESS,LESSEQ,COMMA,LPAREN,GREATER,MOD,LSQUAREB,RPAREN,OR,TIMES,NEQ, }
  (49) CompExpr --> .CompExpr LESSEQ PlusExpr  { GREATEREQ,LESSEQ,OR,RPAREN,EQ,GREATER,COMMA,LESS,AND,NEQ, }
  (40) UnaryExpr --> .LValue  { MOD,GREATEREQ,GREATER,EQ,NEQ,OR,LESSEQ,AND,PLUS,LESS,MINUS,COMMA,TIMES,DIV,CARET,RPAREN, }
  (38) PlusExpr --> .TimesExpr  { LESSEQ,PLUS,GREATEREQ,AND,LESS,GREATER,OR,EQ,COMMA,MINUS,CARET,NEQ,RPAREN, }
  (73) Type --> .T_STRING  { LAMBDA,LSQUAREB, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { LESS,NEQ,GREATER,LSQUAREB,EQ,ASSIGN,AND,LPAREN,GREATEREQ,DIV,MOD,COMMA,OR,TIMES,PLUS,RPAREN,LESSEQ,MINUS,CARET, }
  (6) BlockStmt --> .LCURLYB Stmts RCURLYB  { RPAREN,COMMA, }
  (26) NonBlockExpr --> .LAMBDA ParamList DOT Expr  { COMMA,RPAREN, }
  (50) CompExpr --> .CompExpr GREATEREQ PlusExpr  { NEQ,LESS,GREATEREQ,RPAREN,AND,GREATER,OR,COMMA,EQ,LESSEQ, }
  (68) RValue --> .StringLit  { LESSEQ,MINUS,COMMA,LSQUAREB,MOD,EQ,OR,AND,GREATEREQ,TIMES,NEQ,CARET,LESS,RPAREN,GREATER,PLUS,LPAREN,DIV, }
  (19) BlockExpr --> .LET Param ASSIGN Expr IN BlockExpr  { RPAREN,COMMA, }
  (54) TimesExpr --> .TimesExpr TIMES UnaryExpr  { GREATEREQ,CARET,COMMA,NEQ,GREATER,LESSEQ,LESS,TIMES,PLUS,MOD,MINUS,EQ,OR,RPAREN,DIV,AND, }
  (61) RValue --> RValue LPAREN .ArgList RPAREN  { NEQ,OR,LESS,RCURLYB,IN,ELSE,THEN,MOD,AND,MINUS,RSQUAREB,LESSEQ,TIMES,PLUS,SEMICOLON,EQ,LSQUAREB,DO,LPAREN,CARET,DIV,EOF,GREATER,RPAREN,GREATEREQ,COMMA, }
  (48) CompExpr --> .CompExpr GREATER PlusExpr  { EQ,NEQ,GREATEREQ,OR,GREATER,LESSEQ,AND,RPAREN,LESS,COMMA, }
  (51) PlusExpr --> .PlusExpr PLUS TimesExpr  { RPAREN,OR,GREATER,EQ,NEQ,LESS,MINUS,GREATEREQ,PLUS,AND,COMMA,LESSEQ,CARET, }
state 55:
  (40) UnaryExpr --> .LValue  { SEMICOLON,COMMA,ELSE,NEQ,DO,CARET,THEN,RCURLYB,GREATER,MINUS,LESSEQ,RPAREN,EOF,EQ,AND,GREATEREQ,IN,LESS,TIMES,RSQUAREB,MOD,PLUS,DIV,OR, }
  (51) PlusExpr --> .PlusExpr PLUS TimesExpr  { CARET,DO,IN,GREATEREQ,EQ,EOF,RCURLYB,GREATER,PLUS,AND,LESS,SEMICOLON,THEN,LESSEQ,RPAREN,MINUS,ELSE,OR,COMMA,RSQUAREB,NEQ, }
  (67) RValue --> .Float  { AND,MOD,EQ,LPAREN,GREATEREQ,COMMA,DO,TIMES,CARET,SEMICOLON,RPAREN,RSQUAREB,ELSE,RCURLYB,EOF,OR,PLUS,DIV,IN,GREATER,THEN,LSQUAREB,NEQ,LESS,MINUS,LESSEQ, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { OR,DO,LPAREN,DIV,LSQUAREB,GREATEREQ,ELSE,MINUS,CARET,PLUS,THEN,RPAREN,EOF,TIMES,NEQ,RSQUAREB,IN,AND,LESS,LESSEQ,SEMICOLON,MOD,RCURLYB,EQ,COMMA,GREATER, }
  (57) UnaryExpr --> .NOT UnaryExpr  { MOD,PLUS,GREATEREQ,LESSEQ,IN,EOF,ELSE,LESS,GREATER,RCURLYB,DIV,CARET,EQ,RPAREN,COMMA,OR,DO,RSQUAREB,TIMES,MINUS,AND,THEN,NEQ,SEMICOLON, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { LSQUAREB,COMMA,LESS,RPAREN,MOD,NEQ,MINUS,AND,SEMICOLON,RCURLYB,THEN,EOF,PLUS,TIMES,OR,RSQUAREB,DIV,GREATEREQ,ELSE,GREATER,IN,EQ,LPAREN,CARET,LESSEQ,DO, }
  (66) RValue --> .Integer  { MOD,LSQUAREB,LPAREN,MINUS,EOF,SEMICOLON,DIV,DO,CARET,EQ,LESSEQ,TIMES,NEQ,PLUS,RSQUAREB,AND,GREATER,LESS,ELSE,COMMA,RCURLYB,THEN,OR,IN,GREATEREQ,RPAREN, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { OR,RCURLYB,LESS,NEQ,CARET,IN,THEN,GREATEREQ,MOD,LSQUAREB,EQ,SEMICOLON,LESSEQ,GREATER,AND,DO,ELSE,COMMA,MINUS,PLUS,DIV,RPAREN,EOF,TIMES,LPAREN,RSQUAREB, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { AND,COMMA,LESS,DIV,TIMES,LSQUAREB,SEMICOLON,RSQUAREB,OR,RCURLYB,LPAREN,PLUS,MOD,LESSEQ,IN,GREATER,MINUS,THEN,DO,ELSE,RPAREN,NEQ,CARET,EOF,GREATEREQ,EQ, }
  (41) UnaryExpr --> .RValue  { COMMA,AND,OR,CARET,EQ,RPAREN,RSQUAREB,EOF,DIV,GREATEREQ,GREATER,LESSEQ,RCURLYB,PLUS,TIMES,DO,THEN,IN,MINUS,ELSE,NEQ,MOD,SEMICOLON,LESS, }
  (56) TimesExpr --> .TimesExpr MOD UnaryExpr  { RSQUAREB,AND,NEQ,COMMA,PLUS,DO,EOF,IN,EQ,MOD,MINUS,THEN,RPAREN,GREATER,GREATEREQ,LESSEQ,SEMICOLON,TIMES,RCURLYB,DIV,LESS,ELSE,OR,CARET, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { LESSEQ,CARET,MOD,ELSE,OR,PLUS,DIV,LESS,IN,DO,COMMA,AND,GREATEREQ,LSQUAREB,MINUS,EOF,SEMICOLON,TIMES,GREATER,NEQ,THEN,LPAREN,RCURLYB,RPAREN,EQ,RSQUAREB, }
  (24) LValue --> .Var  { AND,RPAREN,MOD,TIMES,ELSE,EQ,RCURLYB,GREATEREQ,NEQ,LPAREN,THEN,CARET,GREATER,SEMICOLON,OR,DO,LESS,MINUS,DIV,EOF,IN,COMMA,RSQUAREB,LSQUAREB,LESSEQ,PLUS, }
  (37) CompExpr --> .PlusExpr  { EOF,LESSEQ,RPAREN,OR,THEN,RSQUAREB,IN,LESS,EQ,SEMICOLON,NEQ,GREATER,ELSE,AND,GREATEREQ,DO,COMMA,RCURLYB, }
  (68) RValue --> .StringLit  { MINUS,CARET,COMMA,LSQUAREB,LPAREN,OR,EQ,GREATER,RSQUAREB,MOD,NEQ,IN,LESSEQ,GREATEREQ,TIMES,AND,DO,ELSE,SEMICOLON,PLUS,DIV,THEN,RCURLYB,EOF,LESS,RPAREN, }
  (47) CompExpr --> .CompExpr LESS PlusExpr  { OR,EOF,EQ,RSQUAREB,COMMA,NEQ,RCURLYB,DO,LESSEQ,LESS,THEN,GREATER,ELSE,SEMICOLON,AND,GREATEREQ,IN,RPAREN, }
  (49) CompExpr --> .CompExpr LESSEQ PlusExpr  { IN,LESS,AND,COMMA,EQ,GREATEREQ,RPAREN,LESSEQ,RSQUAREB,OR,SEMICOLON,GREATER,DO,ELSE,THEN,NEQ,RCURLYB,EOF, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { COMMA,RPAREN,LESSEQ,RCURLYB,TIMES,GREATER,PLUS,LESS,CARET,GREATEREQ,IN,AND,NEQ,RSQUAREB,EQ,SEMICOLON,ELSE,MINUS,OR,DO,EOF,THEN,MOD,DIV, }
  (54) TimesExpr --> .TimesExpr TIMES UnaryExpr  { ELSE,RPAREN,PLUS,MINUS,RCURLYB,DIV,DO,GREATEREQ,MOD,NEQ,SEMICOLON,CARET,IN,THEN,OR,EOF,TIMES,LESS,GREATER,COMMA,AND,EQ,RSQUAREB,LESSEQ, }
  (53) PlusExpr --> .PlusExpr CARET TimesExpr  { RSQUAREB,COMMA,NEQ,GREATEREQ,EQ,EOF,LESS,DO,IN,MINUS,ELSE,RPAREN,THEN,AND,LESSEQ,CARET,OR,PLUS,SEMICOLON,GREATER,RCURLYB, }
  (52) PlusExpr --> .PlusExpr MINUS TimesExpr  { RSQUAREB,PLUS,OR,GREATER,ELSE,SEMICOLON,EQ,GREATEREQ,CARET,IN,THEN,LESSEQ,MINUS,AND,EOF,DO,RCURLYB,COMMA,LESS,RPAREN,NEQ, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { DIV,PLUS,GREATEREQ,THEN,MOD,RSQUAREB,TIMES,OR,SEMICOLON,IN,LPAREN,EQ,EOF,RCURLYB,LSQUAREB,GREATER,AND,COMMA,ELSE,MINUS,LESSEQ,LESS,CARET,RPAREN,DO,NEQ, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { IN,DO,RCURLYB,TIMES,MINUS,NEQ,ELSE,AND,CARET,OR,PLUS,EOF,THEN,RSQUAREB,COMMA,EQ,GREATER,RPAREN,DIV,GREATEREQ,SEMICOLON,LESSEQ,LESS,MOD, }
  (45) EqExpr --> EqExpr EQ .CompExpr  { SEMICOLON,EOF,IN,EQ,THEN,DO,AND,COMMA,RPAREN,ELSE,OR,RSQUAREB,RCURLYB,NEQ, }
  (55) TimesExpr --> .TimesExpr DIV UnaryExpr  { MOD,LESSEQ,THEN,PLUS,GREATER,GREATEREQ,RSQUAREB,TIMES,CARET,DIV,AND,MINUS,SEMICOLON,OR,COMMA,RPAREN,IN,ELSE,RCURLYB,EOF,LESS,NEQ,EQ,DO, }
  (39) TimesExpr --> .UnaryExpr  { COMMA,DIV,MOD,PLUS,RSQUAREB,ELSE,TIMES,MINUS,NEQ,GREATER,OR,THEN,IN,CARET,EOF,SEMICOLON,GREATEREQ,DO,LESSEQ,EQ,RCURLYB,RPAREN,LESS,AND, }
  (48) CompExpr --> .CompExpr GREATER PlusExpr  { OR,IN,RSQUAREB,SEMICOLON,NEQ,RCURLYB,EQ,GREATEREQ,THEN,RPAREN,AND,LESS,LESSEQ,GREATER,ELSE,EOF,COMMA,DO, }
  (42) RValue --> .LPAREN Expr RPAREN  { EQ,GREATER,RSQUAREB,DO,LSQUAREB,PLUS,LPAREN,TIMES,AND,GREATEREQ,OR,EOF,LESSEQ,ELSE,SEMICOLON,CARET,IN,COMMA,LESS,DIV,RCURLYB,NEQ,THEN,MOD,RPAREN,MINUS, }
  (38) PlusExpr --> .TimesExpr  { LESSEQ,IN,RSQUAREB,OR,PLUS,AND,GREATEREQ,SEMICOLON,DO,RPAREN,MINUS,THEN,EOF,NEQ,EQ,GREATER,RCURLYB,COMMA,LESS,CARET,ELSE, }
  (50) CompExpr --> .CompExpr GREATEREQ PlusExpr  { ELSE,IN,GREATEREQ,THEN,NEQ,RPAREN,COMMA,RSQUAREB,OR,EOF,LESS,LESSEQ,AND,GREATER,RCURLYB,EQ,SEMICOLON,DO, }
state 56:
  (57) UnaryExpr --> .NOT UnaryExpr  { DIV,NEQ,LESS,MINUS,IN,RSQUAREB,EQ,DO,RCURLYB,ELSE,COMMA,SEMICOLON,CARET,AND,OR,MOD,LESSEQ,GREATER,EOF,PLUS,GREATEREQ,THEN,RPAREN,TIMES, }
  (68) RValue --> .StringLit  { EOF,OR,RSQUAREB,LESSEQ,LSQUAREB,GREATER,IN,ELSE,MOD,SEMICOLON,EQ,NEQ,RPAREN,GREATEREQ,DIV,COMMA,PLUS,LPAREN,THEN,DO,LESS,RCURLYB,CARET,AND,TIMES,MINUS, }
  (56) TimesExpr --> .TimesExpr MOD UnaryExpr  { TIMES,AND,DO,MINUS,COMMA,PLUS,NEQ,RSQUAREB,ELSE,LESSEQ,THEN,EQ,IN,CARET,MOD,SEMICOLON,GREATEREQ,DIV,GREATER,RPAREN,OR,EOF,RCURLYB,LESS, }
  (51) PlusExpr --> .PlusExpr PLUS TimesExpr  { MINUS,CARET,ELSE,RSQUAREB,IN,THEN,AND,PLUS,SEMICOLON,LESS,EQ,EOF,RCURLYB,NEQ,GREATEREQ,COMMA,DO,LESSEQ,OR,GREATER,RPAREN, }
  (38) PlusExpr --> .TimesExpr  { GREATER,DO,OR,LESSEQ,THEN,AND,RSQUAREB,RPAREN,EOF,MINUS,COMMA,CARET,PLUS,RCURLYB,NEQ,ELSE,EQ,SEMICOLON,IN,GREATEREQ,LESS, }
  (37) CompExpr --> .PlusExpr  { RCURLYB,EOF,EQ,LESSEQ,NEQ,RPAREN,RSQUAREB,GREATER,OR,AND,GREATEREQ,COMMA,LESS,THEN,DO,IN,SEMICOLON,ELSE, }
  (48) CompExpr --> .CompExpr GREATER PlusExpr  { IN,LESS,NEQ,ELSE,RPAREN,OR,GREATER,EQ,EOF,GREATEREQ,COMMA,THEN,AND,DO,LESSEQ,RCURLYB,RSQUAREB,SEMICOLON, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { EOF,CARET,DIV,NEQ,OR,GREATEREQ,RPAREN,RCURLYB,RSQUAREB,IN,LESSEQ,PLUS,EQ,LESS,DO,MOD,GREATER,MINUS,ELSE,COMMA,SEMICOLON,TIMES,LPAREN,THEN,AND,LSQUAREB, }
  (40) UnaryExpr --> .LValue  { DIV,EQ,EOF,TIMES,COMMA,MOD,RCURLYB,THEN,PLUS,RPAREN,NEQ,MINUS,GREATEREQ,DO,IN,CARET,AND,SEMICOLON,LESS,OR,GREATER,ELSE,LESSEQ,RSQUAREB, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { NEQ,TIMES,LESS,LSQUAREB,RCURLYB,MOD,MINUS,CARET,GREATER,DO,ELSE,LESSEQ,COMMA,LPAREN,OR,RSQUAREB,EOF,IN,PLUS,RPAREN,GREATEREQ,EQ,SEMICOLON,DIV,AND,THEN, }
  (66) RValue --> .Integer  { EOF,LESSEQ,ELSE,LESS,SEMICOLON,MOD,COMMA,LSQUAREB,TIMES,GREATER,LPAREN,EQ,CARET,IN,RPAREN,THEN,RCURLYB,DIV,PLUS,MINUS,AND,RSQUAREB,DO,GREATEREQ,OR,NEQ, }
  (41) UnaryExpr --> .RValue  { THEN,EOF,DO,TIMES,IN,PLUS,DIV,LESSEQ,MOD,SEMICOLON,LESS,RCURLYB,NEQ,RPAREN,OR,RSQUAREB,GREATER,MINUS,AND,CARET,COMMA,ELSE,EQ,GREATEREQ, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { SEMICOLON,IN,MINUS,NEQ,THEN,GREATEREQ,LPAREN,DIV,PLUS,DO,RCURLYB,RSQUAREB,ELSE,COMMA,AND,EQ,LESSEQ,EOF,MOD,TIMES,LESS,GREATER,CARET,OR,LSQUAREB,RPAREN, }
  (42) RValue --> .LPAREN Expr RPAREN  { RPAREN,LSQUAREB,AND,DO,DIV,EQ,SEMICOLON,MOD,ELSE,IN,CARET,GREATEREQ,LPAREN,OR,RSQUAREB,TIMES,PLUS,RCURLYB,COMMA,NEQ,MINUS,LESSEQ,EOF,LESS,THEN,GREATER, }
  (47) CompExpr --> .CompExpr LESS PlusExpr  { RCURLYB,LESSEQ,EOF,AND,NEQ,LESS,RPAREN,RSQUAREB,THEN,EQ,DO,GREATEREQ,ELSE,OR,GREATER,COMMA,IN,SEMICOLON, }
  (54) TimesExpr --> .TimesExpr TIMES UnaryExpr  { IN,EQ,LESSEQ,EOF,OR,COMMA,CARET,THEN,RSQUAREB,DO,MINUS,TIMES,GREATER,MOD,PLUS,GREATEREQ,RPAREN,ELSE,SEMICOLON,NEQ,AND,LESS,RCURLYB,DIV, }
  (55) TimesExpr --> .TimesExpr DIV UnaryExpr  { DIV,THEN,GREATER,RSQUAREB,GREATEREQ,PLUS,EQ,ELSE,EOF,OR,RPAREN,LESS,DO,NEQ,RCURLYB,SEMICOLON,AND,TIMES,CARET,MOD,MINUS,IN,LESSEQ,COMMA, }
  (50) CompExpr --> .CompExpr GREATEREQ PlusExpr  { OR,NEQ,LESSEQ,AND,EQ,LESS,THEN,RPAREN,SEMICOLON,ELSE,RCURLYB,EOF,DO,COMMA,GREATER,IN,GREATEREQ,RSQUAREB, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { DIV,OR,AND,GREATEREQ,DO,LESSEQ,NEQ,RPAREN,TIMES,PLUS,SEMICOLON,EQ,GREATER,COMMA,EOF,RCURLYB,THEN,LESS,IN,ELSE,MOD,CARET,RSQUAREB,MINUS, }
  (39) TimesExpr --> .UnaryExpr  { RCURLYB,LESSEQ,COMMA,RSQUAREB,IN,ELSE,NEQ,TIMES,CARET,MOD,THEN,AND,DO,EQ,DIV,EOF,LESS,GREATER,RPAREN,SEMICOLON,GREATEREQ,MINUS,PLUS,OR, }
  (49) CompExpr --> .CompExpr LESSEQ PlusExpr  { OR,LESS,RSQUAREB,SEMICOLON,THEN,IN,DO,COMMA,EQ,AND,ELSE,GREATER,GREATEREQ,LESSEQ,EOF,NEQ,RPAREN,RCURLYB, }
  (53) PlusExpr --> .PlusExpr CARET TimesExpr  { COMMA,DO,GREATER,NEQ,MINUS,LESSEQ,EOF,PLUS,RCURLYB,OR,AND,EQ,SEMICOLON,GREATEREQ,LESS,IN,RPAREN,CARET,ELSE,THEN,RSQUAREB, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { THEN,AND,RPAREN,LPAREN,LESSEQ,ELSE,RCURLYB,MINUS,COMMA,MOD,IN,GREATER,TIMES,LSQUAREB,DIV,GREATEREQ,RSQUAREB,OR,EQ,PLUS,DO,LESS,EOF,SEMICOLON,CARET,NEQ, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { RPAREN,EOF,SEMICOLON,TIMES,PLUS,GREATER,ELSE,LPAREN,AND,RSQUAREB,DIV,LESS,COMMA,OR,GREATEREQ,DO,MOD,LESSEQ,THEN,NEQ,EQ,MINUS,LSQUAREB,IN,RCURLYB,CARET, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { TIMES,LSQUAREB,SEMICOLON,RPAREN,EQ,OR,RSQUAREB,LPAREN,MOD,GREATEREQ,COMMA,LESSEQ,GREATER,RCURLYB,CARET,MINUS,DO,EOF,THEN,AND,NEQ,PLUS,IN,ELSE,LESS,DIV, }
  (52) PlusExpr --> .PlusExpr MINUS TimesExpr  { IN,EQ,COMMA,EOF,MINUS,RPAREN,DO,RSQUAREB,PLUS,GREATER,OR,AND,THEN,NEQ,GREATEREQ,CARET,RCURLYB,LESSEQ,ELSE,SEMICOLON,LESS, }
  (24) LValue --> .Var  { LPAREN,SEMICOLON,RPAREN,AND,GREATER,RSQUAREB,LESSEQ,OR,TIMES,DO,PLUS,ELSE,CARET,IN,MINUS,MOD,LESS,GREATEREQ,RCURLYB,LSQUAREB,EQ,NEQ,DIV,THEN,EOF,COMMA, }
  (46) EqExpr --> EqExpr NEQ .CompExpr  { COMMA,EOF,SEMICOLON,NEQ,DO,RPAREN,EQ,RCURLYB,AND,THEN,IN,RSQUAREB,OR,ELSE, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { MOD,MINUS,RPAREN,GREATEREQ,ELSE,THEN,DO,IN,COMMA,TIMES,SEMICOLON,LESSEQ,PLUS,EOF,LESS,RCURLYB,DIV,NEQ,EQ,GREATER,OR,AND,CARET,RSQUAREB, }
  (67) RValue --> .Float  { CARET,IN,DIV,ELSE,RSQUAREB,EOF,MINUS,RCURLYB,NEQ,RPAREN,SEMICOLON,EQ,TIMES,AND,LPAREN,COMMA,GREATEREQ,MOD,PLUS,LESSEQ,OR,LESS,GREATER,LSQUAREB,DO,THEN, }
state 57:
  (44) AndExpr --> AndExpr AND .EqExpr  { RSQUAREB,THEN,ELSE,RCURLYB,IN,RPAREN,AND,EOF,DO,OR,COMMA,SEMICOLON, }
  (40) UnaryExpr --> .LValue  { GREATEREQ,GREATER,LESSEQ,COMMA,EOF,DO,LESS,ELSE,AND,PLUS,RSQUAREB,EQ,DIV,OR,MINUS,SEMICOLON,MOD,IN,RPAREN,THEN,NEQ,RCURLYB,CARET,TIMES, }
  (67) RValue --> .Float  { EQ,THEN,OR,RSQUAREB,DIV,TIMES,COMMA,CARET,EOF,AND,LPAREN,LESS,GREATER,SEMICOLON,GREATEREQ,LESSEQ,LSQUAREB,MOD,RPAREN,MINUS,ELSE,IN,DO,NEQ,RCURLYB,PLUS, }
  (53) PlusExpr --> .PlusExpr CARET TimesExpr  { EQ,SEMICOLON,LESS,OR,GREATEREQ,COMMA,IN,RSQUAREB,LESSEQ,RCURLYB,MINUS,AND,RPAREN,ELSE,NEQ,THEN,PLUS,DO,EOF,CARET,GREATER, }
  (68) RValue --> .StringLit  { ELSE,OR,RCURLYB,TIMES,DO,PLUS,MOD,THEN,AND,CARET,RSQUAREB,LESSEQ,SEMICOLON,GREATEREQ,LESS,NEQ,EOF,MINUS,DIV,EQ,COMMA,RPAREN,LPAREN,IN,LSQUAREB,GREATER, }
  (54) TimesExpr --> .TimesExpr TIMES UnaryExpr  { DIV,TIMES,EOF,MOD,LESSEQ,RCURLYB,MINUS,THEN,GREATER,GREATEREQ,RSQUAREB,CARET,PLUS,OR,COMMA,ELSE,DO,SEMICOLON,NEQ,LESS,IN,AND,RPAREN,EQ, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { EQ,MOD,DO,GREATEREQ,COMMA,NEQ,RPAREN,MINUS,AND,EOF,IN,SEMICOLON,PLUS,GREATER,THEN,ELSE,RCURLYB,RSQUAREB,LPAREN,LESS,LESSEQ,TIMES,DIV,CARET,OR,LSQUAREB, }
  (52) PlusExpr --> .PlusExpr MINUS TimesExpr  { ELSE,RSQUAREB,GREATEREQ,COMMA,DO,LESSEQ,PLUS,THEN,SEMICOLON,RCURLYB,GREATER,NEQ,RPAREN,EQ,OR,CARET,MINUS,AND,EOF,IN,LESS, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { LESSEQ,OR,RPAREN,GREATEREQ,COMMA,LPAREN,AND,NEQ,CARET,ELSE,MOD,RCURLYB,EOF,DO,RSQUAREB,GREATER,SEMICOLON,LESS,IN,MINUS,DIV,TIMES,PLUS,THEN,EQ,LSQUAREB, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { TIMES,OR,RSQUAREB,THEN,MINUS,PLUS,LESS,COMMA,DO,NEQ,GREATER,EOF,GREATEREQ,RCURLYB,ELSE,CARET,RPAREN,LESSEQ,MOD,DIV,AND,SEMICOLON,EQ,IN, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { GREATEREQ,LSQUAREB,DIV,MOD,RSQUAREB,LPAREN,IN,DO,MINUS,EQ,GREATER,LESS,RCURLYB,EOF,AND,TIMES,COMMA,LESSEQ,THEN,ELSE,CARET,RPAREN,SEMICOLON,NEQ,PLUS,OR, }
  (56) TimesExpr --> .TimesExpr MOD UnaryExpr  { EOF,IN,RCURLYB,DIV,MOD,NEQ,DO,PLUS,GREATER,MINUS,RPAREN,ELSE,COMMA,OR,RSQUAREB,THEN,GREATEREQ,TIMES,AND,SEMICOLON,EQ,CARET,LESSEQ,LESS, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { NEQ,MINUS,EOF,EQ,THEN,RSQUAREB,OR,CARET,LESSEQ,ELSE,AND,SEMICOLON,DIV,COMMA,PLUS,LESS,RPAREN,GREATEREQ,IN,DO,GREATER,MOD,RCURLYB,TIMES, }
  (57) UnaryExpr --> .NOT UnaryExpr  { ELSE,RCURLYB,MINUS,AND,IN,PLUS,SEMICOLON,MOD,RSQUAREB,THEN,GREATER,LESS,CARET,RPAREN,NEQ,COMMA,DO,EOF,DIV,OR,EQ,GREATEREQ,LESSEQ,TIMES, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { IN,THEN,MOD,PLUS,MINUS,CARET,LESSEQ,COMMA,OR,EOF,RSQUAREB,AND,NEQ,EQ,RPAREN,DIV,RCURLYB,LSQUAREB,ELSE,TIMES,LPAREN,DO,SEMICOLON,LESS,GREATEREQ,GREATER, }
  (51) PlusExpr --> .PlusExpr PLUS TimesExpr  { CARET,EOF,NEQ,PLUS,EQ,LESSEQ,OR,LESS,DO,RPAREN,COMMA,RSQUAREB,ELSE,RCURLYB,THEN,MINUS,GREATER,GREATEREQ,IN,SEMICOLON,AND, }
  (49) CompExpr --> .CompExpr LESSEQ PlusExpr  { LESS,SEMICOLON,IN,THEN,AND,NEQ,COMMA,LESSEQ,EOF,RPAREN,GREATER,OR,RSQUAREB,ELSE,GREATEREQ,RCURLYB,EQ,DO, }
  (55) TimesExpr --> .TimesExpr DIV UnaryExpr  { DIV,COMMA,DO,THEN,MINUS,LESS,AND,RCURLYB,EQ,OR,MOD,CARET,IN,EOF,NEQ,GREATEREQ,GREATER,LESSEQ,PLUS,RPAREN,RSQUAREB,SEMICOLON,ELSE,TIMES, }
  (41) UnaryExpr --> .RValue  { LESSEQ,IN,RPAREN,LESS,EOF,DIV,EQ,SEMICOLON,OR,GREATEREQ,GREATER,CARET,AND,NEQ,DO,MINUS,ELSE,PLUS,THEN,COMMA,MOD,TIMES,RSQUAREB,RCURLYB, }
  (42) RValue --> .LPAREN Expr RPAREN  { PLUS,EQ,DO,LSQUAREB,RPAREN,OR,COMMA,GREATER,RCURLYB,LPAREN,SEMICOLON,LESSEQ,ELSE,AND,RSQUAREB,MOD,GREATEREQ,LESS,THEN,EOF,DIV,TIMES,IN,CARET,NEQ,MINUS, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { RCURLYB,DO,THEN,LSQUAREB,DIV,RPAREN,MOD,PLUS,CARET,LESSEQ,COMMA,GREATEREQ,EOF,OR,AND,IN,GREATER,LESS,NEQ,TIMES,ELSE,EQ,LPAREN,RSQUAREB,SEMICOLON,MINUS, }
  (50) CompExpr --> .CompExpr GREATEREQ PlusExpr  { GREATER,OR,LESS,NEQ,GREATEREQ,LESSEQ,EOF,DO,RCURLYB,THEN,AND,IN,EQ,ELSE,COMMA,RSQUAREB,SEMICOLON,RPAREN, }
  (66) RValue --> .Integer  { EOF,MOD,AND,OR,PLUS,ELSE,RCURLYB,LSQUAREB,GREATEREQ,SEMICOLON,LPAREN,TIMES,CARET,RSQUAREB,LESS,GREATER,RPAREN,THEN,NEQ,COMMA,DO,EQ,IN,DIV,MINUS,LESSEQ, }
  (47) CompExpr --> .CompExpr LESS PlusExpr  { RCURLYB,GREATER,GREATEREQ,THEN,AND,LESS,RPAREN,EOF,NEQ,IN,ELSE,RSQUAREB,COMMA,OR,DO,EQ,LESSEQ,SEMICOLON, }
  (38) PlusExpr --> .TimesExpr  { AND,COMMA,CARET,GREATEREQ,EQ,NEQ,EOF,PLUS,ELSE,DO,GREATER,LESSEQ,RPAREN,THEN,IN,SEMICOLON,RCURLYB,MINUS,LESS,OR,RSQUAREB, }
  (36) EqExpr --> .CompExpr  { RPAREN,OR,IN,DO,NEQ,EQ,THEN,EOF,RCURLYB,COMMA,RSQUAREB,SEMICOLON,AND,ELSE, }
  (37) CompExpr --> .PlusExpr  { DO,RCURLYB,EQ,IN,NEQ,ELSE,EOF,RSQUAREB,AND,THEN,GREATER,LESS,RPAREN,LESSEQ,SEMICOLON,COMMA,GREATEREQ,OR, }
  (39) TimesExpr --> .UnaryExpr  { AND,GREATEREQ,MINUS,GREATER,DO,EQ,OR,MOD,RCURLYB,PLUS,ELSE,RSQUAREB,LESS,THEN,NEQ,EOF,CARET,COMMA,DIV,SEMICOLON,LESSEQ,TIMES,IN,RPAREN, }
  (45) EqExpr --> .EqExpr EQ CompExpr  { NEQ,IN,AND,RSQUAREB,ELSE,OR,RPAREN,EQ,EOF,THEN,DO,RCURLYB,COMMA,SEMICOLON, }
  (24) LValue --> .Var  { LPAREN,RCURLYB,TIMES,MINUS,THEN,LESS,RPAREN,LSQUAREB,EOF,PLUS,RSQUAREB,DO,NEQ,DIV,GREATEREQ,OR,IN,GREATER,EQ,LESSEQ,MOD,CARET,ELSE,COMMA,SEMICOLON,AND, }
  (46) EqExpr --> .EqExpr NEQ CompExpr  { NEQ,COMMA,RPAREN,ELSE,OR,THEN,AND,EQ,DO,SEMICOLON,IN,RCURLYB,RSQUAREB,EOF, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { RCURLYB,AND,GREATER,NEQ,IN,LESSEQ,EOF,LPAREN,RSQUAREB,THEN,DO,MINUS,GREATEREQ,MOD,SEMICOLON,DIV,OR,EQ,TIMES,CARET,RPAREN,ELSE,LESS,COMMA,PLUS,LSQUAREB, }
  (48) CompExpr --> .CompExpr GREATER PlusExpr  { EQ,GREATER,COMMA,ELSE,LESSEQ,RPAREN,OR,GREATEREQ,SEMICOLON,AND,EOF,NEQ,IN,THEN,DO,RSQUAREB,RCURLYB,LESS, }
state 58:
  (47) CompExpr --> .CompExpr LESS PlusExpr  { EQ,OR,GREATER,LESSEQ,NEQ,GREATEREQ,RSQUAREB,AND,LESS, }
  (57) UnaryExpr --> .NOT UnaryExpr  { TIMES,MOD,EQ,LESSEQ,AND,PLUS,NEQ,RSQUAREB,OR,CARET,GREATEREQ,DIV,GREATER,LESS,MINUS, }
  (31) ReturnType --> .T_VOID  { LAMBDA, }
  (35) AndExpr --> .EqExpr  { RSQUAREB,OR,AND, }
  (21) NonBlockExpr --> .WHILE Expr DO NonBlockExpr  { RSQUAREB, }
  (72) Type --> .T_FLOAT  { LAMBDA,LSQUAREB, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { DIV,GREATEREQ,MINUS,LESSEQ,LSQUAREB,MOD,CARET,RSQUAREB,LPAREN,OR,NEQ,PLUS,TIMES,EQ,AND,LESS,GREATER, }
  (25) LValue --> LValue LSQUAREB .Expr RSQUAREB  { LSQUAREB,MINUS,ASSIGN,THEN,EQ,DIV,ELSE,SEMICOLON,AND,RPAREN,LESSEQ,RSQUAREB,COMMA,GREATER,EOF,DO,TIMES,IN,NEQ,LPAREN,OR,LESS,CARET,GREATEREQ,RCURLYB,PLUS,MOD, }
  (67) RValue --> .Float  { LESSEQ,TIMES,MOD,AND,CARET,LPAREN,LESS,OR,PLUS,EQ,GREATEREQ,DIV,RSQUAREB,MINUS,LSQUAREB,GREATER,NEQ, }
  (32) ReturnType --> .Type  { LAMBDA, }
  (73) Type --> .T_STRING  { LSQUAREB,LAMBDA, }
  (26) NonBlockExpr --> .LAMBDA ParamList DOT Expr  { RSQUAREB, }
  (49) CompExpr --> .CompExpr LESSEQ PlusExpr  { EQ,LESSEQ,NEQ,AND,GREATER,GREATEREQ,OR,LESS,RSQUAREB, }
  (7) Expr --> .BlockExpr  { RSQUAREB, }
  (55) TimesExpr --> .TimesExpr DIV UnaryExpr  { TIMES,AND,LESS,DIV,RSQUAREB,GREATER,MOD,NEQ,PLUS,CARET,EQ,OR,LESSEQ,MINUS,GREATEREQ, }
  (68) RValue --> .StringLit  { DIV,GREATEREQ,TIMES,CARET,AND,NEQ,GREATER,OR,LESS,MOD,EQ,LSQUAREB,MINUS,LPAREN,RSQUAREB,LESSEQ,PLUS, }
  (36) EqExpr --> .CompExpr  { AND,RSQUAREB,EQ,NEQ,OR, }
  (33) NonBlockExpr --> .OrExpr  { RSQUAREB, }
  (37) CompExpr --> .PlusExpr  { NEQ,GREATEREQ,OR,AND,LESSEQ,LESS,RSQUAREB,GREATER,EQ, }
  (23) NonBlockExpr --> .LValue ASSIGN Expr  { RSQUAREB, }
  (50) CompExpr --> .CompExpr GREATEREQ PlusExpr  { LESSEQ,GREATER,OR,AND,LESS,EQ,RSQUAREB,GREATEREQ,NEQ, }
  (17) BlockExpr --> .IF Expr THEN Expr ELSE BlockExpr  { RSQUAREB, }
  (46) EqExpr --> .EqExpr NEQ CompExpr  { EQ,RSQUAREB,AND,NEQ,OR, }
  (44) AndExpr --> .AndExpr AND EqExpr  { RSQUAREB,OR,AND, }
  (41) UnaryExpr --> .RValue  { CARET,MOD,GREATEREQ,RSQUAREB,PLUS,AND,LESSEQ,TIMES,GREATER,OR,NEQ,MINUS,EQ,DIV,LESS, }
  (48) CompExpr --> .CompExpr GREATER PlusExpr  { GREATER,OR,LESSEQ,EQ,NEQ,RSQUAREB,LESS,GREATEREQ,AND, }
  (45) EqExpr --> .EqExpr EQ CompExpr  { AND,NEQ,RSQUAREB,OR,EQ, }
  (51) PlusExpr --> .PlusExpr PLUS TimesExpr  { EQ,OR,MINUS,AND,GREATEREQ,LESSEQ,LESS,GREATER,RSQUAREB,CARET,NEQ,PLUS, }
  (66) RValue --> .Integer  { DIV,MOD,GREATER,EQ,OR,TIMES,LSQUAREB,AND,LPAREN,LESSEQ,LESS,GREATEREQ,PLUS,CARET,MINUS,NEQ,RSQUAREB, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { LSQUAREB,EQ,NEQ,GREATER,GREATEREQ,AND,CARET,MOD,MINUS,LESS,RSQUAREB,OR,LESSEQ,TIMES,PLUS,DIV,LPAREN, }
  (19) BlockExpr --> .LET Param ASSIGN Expr IN BlockExpr  { RSQUAREB, }
  (42) RValue --> .LPAREN Expr RPAREN  { PLUS,LESSEQ,OR,MOD,MINUS,LESS,AND,LSQUAREB,TIMES,LPAREN,GREATER,GREATEREQ,DIV,NEQ,RSQUAREB,CARET,EQ, }
  (43) OrExpr --> .OrExpr OR AndExpr  { OR,RSQUAREB, }
  (54) TimesExpr --> .TimesExpr TIMES UnaryExpr  { MINUS,EQ,OR,GREATER,CARET,MOD,RSQUAREB,NEQ,DIV,LESS,PLUS,LESSEQ,TIMES,GREATEREQ,AND, }
  (53) PlusExpr --> .PlusExpr CARET TimesExpr  { NEQ,LESS,PLUS,OR,MINUS,GREATEREQ,AND,LESSEQ,RSQUAREB,GREATER,CARET,EQ, }
  (24) LValue --> .Var  { EQ,PLUS,TIMES,AND,GREATER,RSQUAREB,DIV,MOD,LPAREN,CARET,ASSIGN,MINUS,LESSEQ,OR,LESS,NEQ,GREATEREQ,LSQUAREB, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { EQ,AND,OR,RSQUAREB,CARET,GREATER,MOD,NEQ,DIV,TIMES,GREATEREQ,LESSEQ,PLUS,LESS,MINUS, }
  (39) TimesExpr --> .UnaryExpr  { TIMES,GREATER,PLUS,OR,DIV,GREATEREQ,MINUS,NEQ,MOD,EQ,CARET,RSQUAREB,AND,LESSEQ,LESS, }
  (52) PlusExpr --> .PlusExpr MINUS TimesExpr  { OR,AND,CARET,MINUS,RSQUAREB,GREATEREQ,PLUS,GREATER,NEQ,EQ,LESSEQ,LESS, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { EQ,GREATER,DIV,TIMES,MINUS,GREATEREQ,AND,PLUS,LESSEQ,CARET,MOD,OR,RSQUAREB,NEQ,LESS, }
  (20) NonBlockExpr --> .IF Expr THEN Expr ELSE NonBlockExpr  { RSQUAREB, }
  (16) BlockExpr --> .BlockStmt  { RSQUAREB, }
  (18) BlockExpr --> .WHILE Expr DO BlockExpr  { RSQUAREB, }
  (74) Type --> .Type LSQUAREB RSQUAREB  { LSQUAREB,LAMBDA, }
  (56) TimesExpr --> .TimesExpr MOD UnaryExpr  { LESSEQ,RSQUAREB,LESS,PLUS,EQ,MOD,DIV,CARET,GREATEREQ,OR,AND,TIMES,NEQ,MINUS,GREATER, }
  (8) Expr --> .NonBlockExpr  { RSQUAREB, }
  (6) BlockStmt --> .LCURLYB Stmts RCURLYB  { RSQUAREB, }
  (71) Type --> .T_INT  { LAMBDA,LSQUAREB, }
  (40) UnaryExpr --> .LValue  { LESS,RSQUAREB,OR,LESSEQ,GREATEREQ,GREATER,EQ,CARET,NEQ,AND,MOD,MINUS,TIMES,PLUS,DIV, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { TIMES,MINUS,NEQ,OR,DIV,PLUS,EQ,LSQUAREB,RSQUAREB,MOD,GREATER,LESSEQ,AND,LPAREN,CARET,LESS,GREATEREQ, }
  (27) NonBlockExpr --> .ReturnType LAMBDA ParamList DOT Expr  { RSQUAREB, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { GREATER,ASSIGN,OR,RSQUAREB,LESS,MINUS,EQ,DIV,GREATEREQ,MOD,AND,LESSEQ,PLUS,TIMES,CARET,LPAREN,NEQ,LSQUAREB, }
  (22) NonBlockExpr --> .LET Param ASSIGN Expr IN NonBlockExpr  { RSQUAREB, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { PLUS,AND,RSQUAREB,EQ,OR,GREATEREQ,LSQUAREB,DIV,MOD,MINUS,NEQ,LESSEQ,LPAREN,TIMES,GREATER,CARET,LESS, }
  (38) PlusExpr --> .TimesExpr  { NEQ,EQ,LESS,AND,CARET,RSQUAREB,GREATEREQ,MINUS,OR,LESSEQ,GREATER,PLUS, }
  (34) OrExpr --> .AndExpr  { OR,RSQUAREB, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { PLUS,CARET,MOD,RSQUAREB,MINUS,DIV,AND,LESS,GREATER,LSQUAREB,OR,NEQ,TIMES,GREATEREQ,EQ,LESSEQ,LPAREN, }
state 59:
  (36) EqExpr --> .CompExpr  { COMMA,EQ,OR,RPAREN,NEQ,AND, }
  (16) BlockExpr --> .BlockStmt  { COMMA,RPAREN, }
  (64) ArgList --> .Expr  { RPAREN, }
  (56) TimesExpr --> .TimesExpr MOD UnaryExpr  { AND,LESSEQ,PLUS,MOD,NEQ,CARET,EQ,TIMES,DIV,RPAREN,OR,GREATEREQ,COMMA,GREATER,MINUS,LESS, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { EQ,GREATEREQ,COMMA,GREATER,PLUS,LESSEQ,OR,LESS,MINUS,RPAREN,LPAREN,AND,DIV,TIMES,MOD,LSQUAREB,CARET,NEQ, }
  (53) PlusExpr --> .PlusExpr CARET TimesExpr  { CARET,LESSEQ,OR,RPAREN,AND,GREATER,LESS,EQ,PLUS,GREATEREQ,NEQ,MINUS,COMMA, }
  (57) UnaryExpr --> .NOT UnaryExpr  { MOD,MINUS,EQ,AND,PLUS,CARET,LESSEQ,NEQ,GREATER,TIMES,DIV,RPAREN,OR,GREATEREQ,LESS,COMMA, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { EQ,LPAREN,LESS,GREATEREQ,LESSEQ,NEQ,PLUS,MINUS,OR,TIMES,GREATER,MOD,RPAREN,COMMA,LSQUAREB,CARET,DIV,AND, }
  (52) PlusExpr --> .PlusExpr MINUS TimesExpr  { AND,LESSEQ,OR,PLUS,EQ,NEQ,CARET,GREATER,LESS,COMMA,RPAREN,GREATEREQ,MINUS, }
  (42) RValue --> .LPAREN Expr RPAREN  { GREATER,EQ,PLUS,TIMES,LPAREN,LESS,AND,MINUS,COMMA,MOD,CARET,RPAREN,NEQ,GREATEREQ,OR,DIV,LESSEQ,LSQUAREB, }
  (72) Type --> .T_FLOAT  { LSQUAREB,LAMBDA, }
  (60) RValue --> LValue LPAREN .ArgList RPAREN  { MINUS,RSQUAREB,OR,LSQUAREB,RCURLYB,NEQ,EQ,CARET,PLUS,ELSE,COMMA,LESSEQ,DIV,LPAREN,TIMES,LESS,EOF,GREATEREQ,MOD,THEN,AND,SEMICOLON,DO,GREATER,RPAREN,IN, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { TIMES,LPAREN,COMMA,DIV,RPAREN,LSQUAREB,GREATEREQ,MOD,CARET,NEQ,AND,LESS,LESSEQ,MINUS,GREATER,OR,EQ,PLUS, }
  (73) Type --> .T_STRING  { LAMBDA,LSQUAREB, }
  (44) AndExpr --> .AndExpr AND EqExpr  { AND,RPAREN,COMMA,OR, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { COMMA,MINUS,GREATER,AND,TIMES,RPAREN,DIV,EQ,NEQ,LPAREN,MOD,LSQUAREB,PLUS,OR,LESS,CARET,GREATEREQ,LESSEQ, }
  (48) CompExpr --> .CompExpr GREATER PlusExpr  { GREATER,AND,NEQ,COMMA,RPAREN,LESS,LESSEQ,EQ,OR,GREATEREQ, }
  (21) NonBlockExpr --> .WHILE Expr DO NonBlockExpr  { COMMA,RPAREN, }
  (20) NonBlockExpr --> .IF Expr THEN Expr ELSE NonBlockExpr  { COMMA,RPAREN, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { COMMA,OR,PLUS,DIV,LSQUAREB,ASSIGN,TIMES,GREATEREQ,RPAREN,LPAREN,LESSEQ,EQ,MOD,AND,MINUS,CARET,GREATER,LESS,NEQ, }
  (45) EqExpr --> .EqExpr EQ CompExpr  { NEQ,OR,RPAREN,AND,COMMA,EQ, }
  (74) Type --> .Type LSQUAREB RSQUAREB  { LAMBDA,LSQUAREB, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { PLUS,GREATEREQ,EQ,LESS,MINUS,DIV,NEQ,AND,GREATER,OR,RPAREN,TIMES,CARET,LESSEQ,COMMA,MOD, }
  (32) ReturnType --> .Type  { LAMBDA, }
  (23) NonBlockExpr --> .LValue ASSIGN Expr  { RPAREN,COMMA, }
  (17) BlockExpr --> .IF Expr THEN Expr ELSE BlockExpr  { RPAREN,COMMA, }
  (55) TimesExpr --> .TimesExpr DIV UnaryExpr  { GREATEREQ,OR,CARET,LESSEQ,PLUS,TIMES,MOD,NEQ,GREATER,EQ,RPAREN,COMMA,MINUS,LESS,AND,DIV, }
  (39) TimesExpr --> .UnaryExpr  { TIMES,GREATEREQ,COMMA,CARET,LESS,GREATER,LESSEQ,MINUS,RPAREN,MOD,DIV,OR,PLUS,EQ,NEQ,AND, }
  (26) NonBlockExpr --> .LAMBDA ParamList DOT Expr  { COMMA,RPAREN, }
  (8) Expr --> .NonBlockExpr  { COMMA,RPAREN, }
  (54) TimesExpr --> .TimesExpr TIMES UnaryExpr  { MINUS,RPAREN,TIMES,GREATEREQ,CARET,EQ,COMMA,PLUS,AND,GREATER,NEQ,LESS,OR,DIV,MOD,LESSEQ, }
  (35) AndExpr --> .EqExpr  { AND,COMMA,OR,RPAREN, }
  (63) ArgList --> .  { RPAREN, }
  (38) PlusExpr --> .TimesExpr  { OR,GREATER,NEQ,PLUS,LESSEQ,COMMA,MINUS,GREATEREQ,CARET,EQ,RPAREN,AND,LESS, }
  (19) BlockExpr --> .LET Param ASSIGN Expr IN BlockExpr  { COMMA,RPAREN, }
  (49) CompExpr --> .CompExpr LESSEQ PlusExpr  { RPAREN,NEQ,EQ,GREATEREQ,COMMA,LESSEQ,GREATER,OR,AND,LESS, }
  (66) RValue --> .Integer  { EQ,RPAREN,LESSEQ,LESS,AND,DIV,CARET,NEQ,GREATEREQ,MOD,LPAREN,GREATER,PLUS,MINUS,OR,LSQUAREB,TIMES,COMMA, }
  (6) BlockStmt --> .LCURLYB Stmts RCURLYB  { COMMA,RPAREN, }
  (33) NonBlockExpr --> .OrExpr  { COMMA,RPAREN, }
  (51) PlusExpr --> .PlusExpr PLUS TimesExpr  { LESSEQ,LESS,GREATEREQ,COMMA,GREATER,NEQ,AND,MINUS,PLUS,OR,CARET,RPAREN,EQ, }
  (27) NonBlockExpr --> .ReturnType LAMBDA ParamList DOT Expr  { RPAREN,COMMA, }
  (37) CompExpr --> .PlusExpr  { GREATER,RPAREN,EQ,COMMA,LESSEQ,OR,NEQ,LESS,AND,GREATEREQ, }
  (65) ArgList --> .Expr COMMA ArgList  { RPAREN, }
  (7) Expr --> .BlockExpr  { COMMA,RPAREN, }
  (22) NonBlockExpr --> .LET Param ASSIGN Expr IN NonBlockExpr  { COMMA,RPAREN, }
  (46) EqExpr --> .EqExpr NEQ CompExpr  { NEQ,RPAREN,OR,AND,COMMA,EQ, }
  (18) BlockExpr --> .WHILE Expr DO BlockExpr  { RPAREN,COMMA, }
  (50) CompExpr --> .CompExpr GREATEREQ PlusExpr  { AND,GREATEREQ,COMMA,NEQ,RPAREN,OR,GREATER,LESS,EQ,LESSEQ, }
  (34) OrExpr --> .AndExpr  { COMMA,RPAREN,OR, }
  (41) UnaryExpr --> .RValue  { DIV,OR,EQ,MOD,TIMES,NEQ,CARET,GREATER,MINUS,LESS,COMMA,AND,PLUS,RPAREN,LESSEQ,GREATEREQ, }
  (47) CompExpr --> .CompExpr LESS PlusExpr  { LESS,RPAREN,LESSEQ,NEQ,AND,COMMA,EQ,OR,GREATER,GREATEREQ, }
  (40) UnaryExpr --> .LValue  { AND,NEQ,CARET,LESS,RPAREN,GREATER,COMMA,OR,MOD,LESSEQ,GREATEREQ,EQ,PLUS,MINUS,TIMES,DIV, }
  (43) OrExpr --> .OrExpr OR AndExpr  { COMMA,RPAREN,OR, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { COMMA,LESSEQ,MOD,EQ,NEQ,CARET,AND,TIMES,RPAREN,LPAREN,GREATER,GREATEREQ,LSQUAREB,LESS,PLUS,DIV,MINUS,OR, }
  (31) ReturnType --> .T_VOID  { LAMBDA, }
  (68) RValue --> .StringLit  { DIV,EQ,CARET,COMMA,RPAREN,NEQ,AND,LESS,GREATEREQ,LSQUAREB,TIMES,LESSEQ,GREATER,OR,PLUS,LPAREN,MINUS,MOD, }
  (71) Type --> .T_INT  { LSQUAREB,LAMBDA, }
  (67) RValue --> .Float  { GREATEREQ,DIV,AND,CARET,NEQ,LESS,MOD,LESSEQ,COMMA,MINUS,LPAREN,EQ,RPAREN,OR,TIMES,GREATER,PLUS,LSQUAREB, }
  (24) LValue --> .Var  { COMMA,NEQ,ASSIGN,OR,LSQUAREB,TIMES,DIV,RPAREN,GREATER,LPAREN,MOD,LESS,MINUS,LESSEQ,EQ,PLUS,CARET,GREATEREQ,AND, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { CARET,GREATER,OR,COMMA,AND,RPAREN,MOD,DIV,TIMES,LESS,NEQ,LESSEQ,PLUS,MINUS,EQ,GREATEREQ, }
state 60:
  (45) EqExpr --> .EqExpr EQ CompExpr  { AND,RPAREN,ELSE,EOF,COMMA,RCURLYB,NEQ,DO,IN,THEN,EQ,OR,RSQUAREB,SEMICOLON, }
  (35) AndExpr --> .EqExpr  { AND,EOF,SEMICOLON,RSQUAREB,ELSE,IN,RCURLYB,DO,COMMA,OR,THEN,RPAREN, }
  (20) NonBlockExpr --> .IF Expr THEN Expr ELSE NonBlockExpr  { EOF,RCURLYB,COMMA,IN,RSQUAREB,SEMICOLON,THEN,DO,ELSE,RPAREN, }
  (7) Expr --> .BlockExpr  { RCURLYB,IN,THEN,COMMA,DO,EOF,ELSE,SEMICOLON,RSQUAREB,RPAREN, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { PLUS,NEQ,COMMA,DO,IN,AND,LPAREN,EQ,OR,DIV,THEN,TIMES,GREATEREQ,MINUS,RPAREN,RSQUAREB,EOF,ELSE,LSQUAREB,LESS,MOD,SEMICOLON,GREATER,CARET,LESSEQ,RCURLYB, }
  (33) NonBlockExpr --> .OrExpr  { SEMICOLON,THEN,RPAREN,RCURLYB,RSQUAREB,IN,ELSE,COMMA,DO,EOF, }
  (23) NonBlockExpr --> LValue ASSIGN .Expr  { RSQUAREB,ELSE,EOF,IN,SEMICOLON,THEN,RCURLYB,DO,COMMA,RPAREN, }
  (18) BlockExpr --> .WHILE Expr DO BlockExpr  { DO,IN,RSQUAREB,ELSE,RPAREN,RCURLYB,COMMA,EOF,SEMICOLON,THEN, }
  (6) BlockStmt --> .LCURLYB Stmts RCURLYB  { THEN,DO,EOF,RSQUAREB,IN,RPAREN,ELSE,RCURLYB,COMMA,SEMICOLON, }
  (49) CompExpr --> .CompExpr LESSEQ PlusExpr  { COMMA,LESSEQ,DO,ELSE,RSQUAREB,GREATER,LESS,EQ,IN,THEN,GREATEREQ,SEMICOLON,EOF,RCURLYB,NEQ,AND,OR,RPAREN, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { PLUS,LSQUAREB,DIV,THEN,TIMES,OR,ELSE,AND,SEMICOLON,RSQUAREB,RCURLYB,EOF,LESSEQ,GREATEREQ,LESS,LPAREN,MINUS,EQ,COMMA,DO,MOD,RPAREN,GREATER,CARET,NEQ,IN, }
  (36) EqExpr --> .CompExpr  { SEMICOLON,ELSE,RCURLYB,AND,COMMA,OR,THEN,NEQ,DO,RPAREN,EOF,EQ,IN,RSQUAREB, }
  (41) UnaryExpr --> .RValue  { RPAREN,IN,MOD,RSQUAREB,LESSEQ,PLUS,COMMA,AND,EQ,CARET,GREATEREQ,ELSE,RCURLYB,THEN,NEQ,EOF,LESS,DO,OR,TIMES,SEMICOLON,DIV,GREATER,MINUS, }
  (67) RValue --> .Float  { EQ,IN,GREATER,EOF,COMMA,DIV,RCURLYB,PLUS,LESS,SEMICOLON,CARET,GREATEREQ,TIMES,LESSEQ,LPAREN,DO,AND,ELSE,OR,MOD,MINUS,RSQUAREB,LSQUAREB,NEQ,RPAREN,THEN, }
  (74) Type --> .Type LSQUAREB RSQUAREB  { LSQUAREB,LAMBDA, }
  (72) Type --> .T_FLOAT  { LSQUAREB,LAMBDA, }
  (47) CompExpr --> .CompExpr LESS PlusExpr  { RCURLYB,ELSE,RPAREN,SEMICOLON,COMMA,DO,IN,EQ,GREATER,AND,OR,RSQUAREB,GREATEREQ,LESS,NEQ,THEN,EOF,LESSEQ, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { LESSEQ,AND,RSQUAREB,DIV,RCURLYB,COMMA,LESS,CARET,TIMES,EOF,MINUS,IN,RPAREN,DO,GREATEREQ,ELSE,GREATER,MOD,SEMICOLON,EQ,THEN,NEQ,OR,PLUS, }
  (46) EqExpr --> .EqExpr NEQ CompExpr  { IN,COMMA,EOF,NEQ,SEMICOLON,RSQUAREB,OR,RPAREN,THEN,RCURLYB,ELSE,EQ,AND,DO, }
  (48) CompExpr --> .CompExpr GREATER PlusExpr  { GREATEREQ,LESSEQ,EOF,RSQUAREB,ELSE,NEQ,OR,AND,THEN,EQ,RCURLYB,RPAREN,COMMA,GREATER,SEMICOLON,IN,DO,LESS, }
  (34) OrExpr --> .AndExpr  { DO,SEMICOLON,THEN,ELSE,RSQUAREB,RCURLYB,COMMA,RPAREN,IN,OR,EOF, }
  (16) BlockExpr --> .BlockStmt  { RPAREN,DO,RCURLYB,IN,RSQUAREB,EOF,ELSE,SEMICOLON,COMMA,THEN, }
  (24) LValue --> .Var  { GREATER,DO,SEMICOLON,TIMES,PLUS,DIV,OR,LESS,EOF,MOD,IN,ELSE,RSQUAREB,LSQUAREB,COMMA,GREATEREQ,RCURLYB,AND,LESSEQ,CARET,RPAREN,MINUS,NEQ,THEN,EQ,LPAREN,ASSIGN, }
  (39) TimesExpr --> .UnaryExpr  { GREATER,THEN,RSQUAREB,LESSEQ,EQ,ELSE,MOD,IN,EOF,LESS,OR,DIV,AND,RCURLYB,RPAREN,DO,NEQ,COMMA,GREATEREQ,SEMICOLON,MINUS,PLUS,TIMES,CARET, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { GREATER,THEN,TIMES,LESSEQ,CARET,IN,MINUS,EQ,RPAREN,GREATEREQ,SEMICOLON,OR,DIV,DO,RSQUAREB,PLUS,NEQ,RCURLYB,AND,LESS,COMMA,ELSE,EOF,MOD, }
  (23) NonBlockExpr --> .LValue ASSIGN Expr  { RCURLYB,IN,SEMICOLON,RPAREN,COMMA,ELSE,RSQUAREB,DO,THEN,EOF, }
  (56) TimesExpr --> .TimesExpr MOD UnaryExpr  { GREATER,OR,DO,ELSE,PLUS,TIMES,MOD,THEN,SEMICOLON,COMMA,EOF,EQ,GREATEREQ,RPAREN,RCURLYB,IN,MINUS,NEQ,LESSEQ,AND,CARET,LESS,RSQUAREB,DIV, }
  (50) CompExpr --> .CompExpr GREATEREQ PlusExpr  { ELSE,OR,SEMICOLON,RPAREN,DO,RCURLYB,IN,AND,GREATER,LESSEQ,GREATEREQ,COMMA,THEN,RSQUAREB,EOF,LESS,EQ,NEQ, }
  (32) ReturnType --> .Type  { LAMBDA, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { MINUS,OR,DO,DIV,LPAREN,TIMES,GREATER,RCURLYB,EQ,GREATEREQ,THEN,IN,MOD,PLUS,COMMA,AND,LSQUAREB,LESS,SEMICOLON,LESSEQ,NEQ,RPAREN,RSQUAREB,CARET,ELSE,EOF, }
  (26) NonBlockExpr --> .LAMBDA ParamList DOT Expr  { DO,RPAREN,COMMA,EOF,RSQUAREB,THEN,SEMICOLON,IN,RCURLYB,ELSE, }
  (55) TimesExpr --> .TimesExpr DIV UnaryExpr  { THEN,GREATER,ELSE,NEQ,GREATEREQ,COMMA,LESS,MOD,RCURLYB,AND,OR,MINUS,LESSEQ,DO,RPAREN,CARET,EQ,RSQUAREB,IN,TIMES,DIV,EOF,PLUS,SEMICOLON, }
  (53) PlusExpr --> .PlusExpr CARET TimesExpr  { AND,COMMA,THEN,RPAREN,DO,LESS,GREATEREQ,EQ,IN,RCURLYB,CARET,RSQUAREB,OR,EOF,ELSE,GREATER,LESSEQ,SEMICOLON,MINUS,PLUS,NEQ, }
  (51) PlusExpr --> .PlusExpr PLUS TimesExpr  { THEN,NEQ,PLUS,LESSEQ,ELSE,RSQUAREB,DO,COMMA,AND,LESS,RCURLYB,GREATER,RPAREN,IN,OR,EQ,GREATEREQ,CARET,MINUS,EOF,SEMICOLON, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { LESSEQ,MINUS,ELSE,DO,PLUS,LSQUAREB,AND,COMMA,RCURLYB,MOD,RPAREN,NEQ,LPAREN,CARET,IN,DIV,THEN,EQ,RSQUAREB,EOF,TIMES,OR,GREATEREQ,LESS,SEMICOLON,GREATER, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { LESSEQ,SEMICOLON,IN,AND,THEN,EQ,CARET,PLUS,GREATER,RCURLYB,GREATEREQ,RPAREN,RSQUAREB,DO,OR,LPAREN,ELSE,LESS,LSQUAREB,DIV,MINUS,TIMES,EOF,COMMA,NEQ,MOD, }
  (21) NonBlockExpr --> .WHILE Expr DO NonBlockExpr  { RCURLYB,COMMA,EOF,IN,THEN,ELSE,RSQUAREB,DO,SEMICOLON,RPAREN, }
  (19) BlockExpr --> .LET Param ASSIGN Expr IN BlockExpr  { ELSE,COMMA,SEMICOLON,IN,EOF,DO,RSQUAREB,THEN,RCURLYB,RPAREN, }
  (8) Expr --> .NonBlockExpr  { RPAREN,RCURLYB,EOF,ELSE,SEMICOLON,RSQUAREB,DO,THEN,COMMA,IN, }
  (71) Type --> .T_INT  { LAMBDA,LSQUAREB, }
  (27) NonBlockExpr --> .ReturnType LAMBDA ParamList DOT Expr  { EOF,THEN,DO,COMMA,RCURLYB,IN,RSQUAREB,RPAREN,SEMICOLON,ELSE, }
  (22) NonBlockExpr --> .LET Param ASSIGN Expr IN NonBlockExpr  { EOF,SEMICOLON,ELSE,RPAREN,THEN,COMMA,DO,IN,RSQUAREB,RCURLYB, }
  (52) PlusExpr --> .PlusExpr MINUS TimesExpr  { LESSEQ,EQ,GREATER,COMMA,RSQUAREB,CARET,OR,RPAREN,NEQ,RCURLYB,IN,GREATEREQ,LESS,AND,PLUS,EOF,ELSE,SEMICOLON,THEN,MINUS,DO, }
  (73) Type --> .T_STRING  { LSQUAREB,LAMBDA, }
  (31) ReturnType --> .T_VOID  { LAMBDA, }
  (66) RValue --> .Integer  { DIV,IN,MOD,COMMA,TIMES,RCURLYB,LSQUAREB,RPAREN,GREATER,MINUS,NEQ,DO,LESS,THEN,EOF,GREATEREQ,EQ,SEMICOLON,AND,ELSE,RSQUAREB,CARET,PLUS,LPAREN,LESSEQ,OR, }
  (38) PlusExpr --> .TimesExpr  { GREATEREQ,MINUS,RPAREN,THEN,OR,EOF,LESS,PLUS,CARET,COMMA,EQ,ELSE,AND,NEQ,RCURLYB,IN,RSQUAREB,LESSEQ,SEMICOLON,DO,GREATER, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { GREATER,DIV,LESS,THEN,GREATEREQ,PLUS,AND,LESSEQ,EOF,ELSE,TIMES,RSQUAREB,RCURLYB,LPAREN,RPAREN,COMMA,MOD,OR,ASSIGN,SEMICOLON,EQ,DO,CARET,LSQUAREB,NEQ,IN,MINUS, }
  (54) TimesExpr --> .TimesExpr TIMES UnaryExpr  { THEN,RSQUAREB,MOD,TIMES,ELSE,SEMICOLON,COMMA,OR,PLUS,GREATEREQ,LESS,RCURLYB,NEQ,AND,DIV,EQ,GREATER,EOF,RPAREN,DO,IN,LESSEQ,CARET,MINUS, }
  (40) UnaryExpr --> .LValue  { DO,NEQ,OR,LESS,SEMICOLON,EOF,AND,DIV,MINUS,GREATEREQ,COMMA,MOD,TIMES,RCURLYB,LESSEQ,THEN,IN,CARET,RPAREN,RSQUAREB,ELSE,PLUS,GREATER,EQ, }
  (37) CompExpr --> .PlusExpr  { LESSEQ,AND,OR,DO,LESS,RSQUAREB,RCURLYB,THEN,IN,SEMICOLON,RPAREN,COMMA,GREATER,GREATEREQ,EQ,ELSE,NEQ,EOF, }
  (43) OrExpr --> .OrExpr OR AndExpr  { IN,RCURLYB,ELSE,DO,COMMA,SEMICOLON,OR,RSQUAREB,THEN,EOF,RPAREN, }
  (42) RValue --> .LPAREN Expr RPAREN  { GREATEREQ,IN,OR,EOF,LESSEQ,COMMA,AND,PLUS,DIV,LSQUAREB,DO,SEMICOLON,RPAREN,GREATER,EQ,LPAREN,MINUS,NEQ,CARET,LESS,MOD,THEN,TIMES,ELSE,RCURLYB,RSQUAREB, }
  (17) BlockExpr --> .IF Expr THEN Expr ELSE BlockExpr  { EOF,ELSE,SEMICOLON,THEN,RSQUAREB,DO,RCURLYB,IN,COMMA,RPAREN, }
  (57) UnaryExpr --> .NOT UnaryExpr  { DIV,RCURLYB,CARET,RSQUAREB,LESS,LESSEQ,THEN,NEQ,GREATER,MOD,DO,COMMA,OR,ELSE,EQ,TIMES,PLUS,SEMICOLON,GREATEREQ,AND,MINUS,RPAREN,IN,EOF, }
  (68) RValue --> .StringLit  { TIMES,EQ,RPAREN,CARET,SEMICOLON,DO,IN,RCURLYB,NEQ,GREATER,THEN,AND,RSQUAREB,LESS,LESSEQ,DIV,COMMA,MINUS,GREATEREQ,ELSE,LPAREN,PLUS,OR,MOD,LSQUAREB,EOF, }
  (44) AndExpr --> .AndExpr AND EqExpr  { AND,RSQUAREB,EOF,RPAREN,COMMA,RCURLYB,THEN,DO,ELSE,OR,SEMICOLON,IN, }
state 61:
  (41) UnaryExpr --> .RValue  { COMMA,ELSE,GREATEREQ,DIV,RCURLYB,AND,IN,EQ,SEMICOLON,DO,NEQ,RSQUAREB,LESSEQ,CARET,MINUS,EOF,OR,GREATER,PLUS,THEN,TIMES,RPAREN,MOD,LESS, }
  (42) RValue --> .LPAREN Expr RPAREN  { NEQ,LESS,TIMES,RCURLYB,COMMA,MOD,GREATEREQ,EOF,MINUS,SEMICOLON,AND,IN,GREATER,ELSE,LSQUAREB,CARET,EQ,PLUS,OR,LESSEQ,LPAREN,DO,RPAREN,RSQUAREB,THEN,DIV, }
  (67) RValue --> .Float  { MOD,LSQUAREB,LPAREN,LESSEQ,DIV,TIMES,EOF,PLUS,DO,ELSE,CARET,RPAREN,OR,LESS,NEQ,IN,RSQUAREB,GREATER,THEN,GREATEREQ,AND,SEMICOLON,EQ,COMMA,RCURLYB,MINUS, }
  (24) LValue --> .Var  { COMMA,TIMES,CARET,MINUS,EQ,MOD,ELSE,EOF,RCURLYB,PLUS,THEN,GREATER,LESS,AND,LESSEQ,SEMICOLON,RSQUAREB,DIV,OR,DO,LSQUAREB,GREATEREQ,LPAREN,NEQ,IN,RPAREN, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { RPAREN,OR,GREATER,GREATEREQ,COMMA,RSQUAREB,RCURLYB,PLUS,AND,NEQ,TIMES,LESS,MOD,EQ,DO,EOF,ELSE,LESSEQ,MINUS,SEMICOLON,IN,THEN,CARET,DIV, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { THEN,LPAREN,LESSEQ,GREATEREQ,TIMES,OR,NEQ,MOD,RPAREN,RSQUAREB,PLUS,SEMICOLON,LESS,AND,MINUS,RCURLYB,EQ,COMMA,EOF,CARET,LSQUAREB,DIV,DO,GREATER,IN,ELSE, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { NEQ,IN,GREATEREQ,LESSEQ,DIV,AND,CARET,RSQUAREB,COMMA,THEN,RPAREN,ELSE,SEMICOLON,PLUS,EOF,LESS,LSQUAREB,OR,LPAREN,RCURLYB,DO,GREATER,MOD,TIMES,MINUS,EQ, }
  (55) TimesExpr --> .TimesExpr DIV UnaryExpr  { PLUS,MINUS,ELSE,LESSEQ,GREATER,CARET,LESS,COMMA,SEMICOLON,OR,TIMES,GREATEREQ,EQ,DO,THEN,EOF,IN,RSQUAREB,MOD,NEQ,AND,RCURLYB,DIV,RPAREN, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { GREATER,TIMES,IN,LESS,DO,DIV,GREATEREQ,CARET,EQ,EOF,LSQUAREB,NEQ,THEN,MINUS,SEMICOLON,COMMA,RPAREN,LPAREN,MOD,AND,ELSE,LESSEQ,RCURLYB,OR,PLUS,RSQUAREB, }
  (54) TimesExpr --> .TimesExpr TIMES UnaryExpr  { THEN,RCURLYB,MOD,GREATEREQ,OR,RPAREN,IN,GREATER,COMMA,CARET,PLUS,SEMICOLON,DO,LESSEQ,MINUS,NEQ,AND,RSQUAREB,EOF,ELSE,TIMES,EQ,LESS,DIV, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { CARET,PLUS,LESSEQ,NEQ,LSQUAREB,IN,ELSE,EOF,SEMICOLON,MINUS,TIMES,OR,DIV,THEN,RCURLYB,GREATEREQ,COMMA,RSQUAREB,LESS,GREATER,LPAREN,RPAREN,AND,MOD,DO,EQ, }
  (56) TimesExpr --> .TimesExpr MOD UnaryExpr  { OR,LESS,DO,TIMES,DIV,MINUS,AND,RCURLYB,LESSEQ,GREATER,THEN,CARET,COMMA,PLUS,EOF,GREATEREQ,NEQ,ELSE,EQ,IN,RSQUAREB,RPAREN,SEMICOLON,MOD, }
  (52) PlusExpr --> PlusExpr MINUS .TimesExpr  { LESS,GREATER,CARET,RSQUAREB,MINUS,SEMICOLON,DO,NEQ,EOF,COMMA,RCURLYB,THEN,LESSEQ,PLUS,GREATEREQ,EQ,RPAREN,AND,ELSE,IN,OR, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { LESS,ELSE,RSQUAREB,CARET,SEMICOLON,THEN,MINUS,COMMA,NEQ,RCURLYB,EOF,PLUS,RPAREN,DIV,MOD,OR,IN,DO,TIMES,AND,GREATEREQ,LESSEQ,EQ,GREATER, }
  (57) UnaryExpr --> .NOT UnaryExpr  { COMMA,NEQ,LESSEQ,IN,AND,RSQUAREB,TIMES,EOF,RPAREN,SEMICOLON,GREATEREQ,PLUS,DIV,MOD,LESS,ELSE,DO,CARET,THEN,EQ,RCURLYB,GREATER,MINUS,OR, }
  (66) RValue --> .Integer  { ELSE,MOD,NEQ,EOF,IN,MINUS,GREATER,TIMES,LESS,CARET,RSQUAREB,EQ,RPAREN,LESSEQ,DIV,PLUS,DO,LSQUAREB,OR,THEN,RCURLYB,AND,LPAREN,SEMICOLON,GREATEREQ,COMMA, }
  (68) RValue --> .StringLit  { GREATER,LESS,NEQ,CARET,EOF,LPAREN,AND,LSQUAREB,DO,COMMA,RSQUAREB,EQ,ELSE,RCURLYB,IN,DIV,SEMICOLON,PLUS,MINUS,MOD,GREATEREQ,TIMES,RPAREN,THEN,OR,LESSEQ, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { LPAREN,GREATEREQ,GREATER,COMMA,ELSE,AND,RSQUAREB,SEMICOLON,TIMES,PLUS,OR,DO,EOF,CARET,LESSEQ,MOD,NEQ,THEN,MINUS,LSQUAREB,EQ,RCURLYB,IN,RPAREN,LESS,DIV, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { GREATER,SEMICOLON,DIV,CARET,OR,RSQUAREB,ELSE,COMMA,GREATEREQ,LESS,DO,LESSEQ,THEN,MOD,MINUS,AND,PLUS,RPAREN,EOF,TIMES,LPAREN,RCURLYB,LSQUAREB,NEQ,IN,EQ, }
  (39) TimesExpr --> .UnaryExpr  { LESSEQ,RCURLYB,GREATEREQ,IN,NEQ,AND,COMMA,ELSE,CARET,MINUS,OR,DO,EQ,EOF,THEN,GREATER,RPAREN,TIMES,DIV,RSQUAREB,PLUS,MOD,SEMICOLON,LESS, }
  (40) UnaryExpr --> .LValue  { RSQUAREB,LESSEQ,MINUS,EOF,EQ,CARET,NEQ,SEMICOLON,OR,ELSE,THEN,DIV,MOD,LESS,GREATEREQ,RCURLYB,AND,PLUS,DO,RPAREN,IN,COMMA,GREATER,TIMES, }
state 62:
  (58) UnaryExpr --> .NEGATE UnaryExpr  { LESS,EOF,TIMES,OR,EQ,RCURLYB,GREATER,CARET,THEN,ELSE,AND,MINUS,PLUS,SEMICOLON,IN,RPAREN,COMMA,GREATEREQ,LESSEQ,MOD,DIV,DO,RSQUAREB,NEQ, }
  (51) PlusExpr --> PlusExpr PLUS .TimesExpr  { EOF,ELSE,AND,MINUS,GREATEREQ,NEQ,RSQUAREB,IN,COMMA,LESS,SEMICOLON,RPAREN,CARET,PLUS,THEN,OR,DO,GREATER,RCURLYB,LESSEQ,EQ, }
  (39) TimesExpr --> .UnaryExpr  { ELSE,GREATEREQ,SEMICOLON,IN,EQ,OR,PLUS,RPAREN,THEN,TIMES,RSQUAREB,GREATER,COMMA,EOF,CARET,AND,MOD,MINUS,LESS,NEQ,LESSEQ,DIV,RCURLYB,DO, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { RPAREN,LSQUAREB,AND,OR,RSQUAREB,MINUS,THEN,RCURLYB,DIV,NEQ,EOF,GREATER,MOD,IN,LESSEQ,PLUS,GREATEREQ,TIMES,COMMA,DO,LESS,ELSE,CARET,EQ,LPAREN,SEMICOLON, }
  (54) TimesExpr --> .TimesExpr TIMES UnaryExpr  { MOD,ELSE,LESSEQ,GREATER,TIMES,LESS,DIV,OR,COMMA,THEN,NEQ,DO,SEMICOLON,RPAREN,EOF,GREATEREQ,EQ,IN,MINUS,CARET,PLUS,RSQUAREB,RCURLYB,AND, }
  (40) UnaryExpr --> .LValue  { GREATEREQ,SEMICOLON,MOD,RPAREN,THEN,LESSEQ,IN,RSQUAREB,TIMES,LESS,NEQ,DO,COMMA,CARET,EQ,EOF,RCURLYB,AND,DIV,OR,MINUS,PLUS,GREATER,ELSE, }
  (67) RValue --> .Float  { RSQUAREB,DO,EOF,SEMICOLON,NEQ,PLUS,MINUS,TIMES,IN,OR,DIV,CARET,LSQUAREB,RPAREN,RCURLYB,AND,GREATER,GREATEREQ,EQ,LESS,COMMA,THEN,MOD,LESSEQ,LPAREN,ELSE, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { EOF,CARET,LSQUAREB,EQ,GREATEREQ,OR,LPAREN,COMMA,TIMES,AND,SEMICOLON,LESS,MOD,RPAREN,GREATER,MINUS,NEQ,RSQUAREB,IN,DIV,PLUS,RCURLYB,ELSE,DO,THEN,LESSEQ, }
  (42) RValue --> .LPAREN Expr RPAREN  { RSQUAREB,AND,ELSE,TIMES,RCURLYB,THEN,OR,COMMA,LSQUAREB,IN,EOF,GREATER,DIV,MOD,EQ,SEMICOLON,GREATEREQ,RPAREN,LESS,CARET,DO,NEQ,LPAREN,LESSEQ,MINUS,PLUS, }
  (57) UnaryExpr --> .NOT UnaryExpr  { AND,DO,RCURLYB,THEN,PLUS,LESSEQ,COMMA,IN,MINUS,CARET,EQ,RPAREN,GREATEREQ,NEQ,DIV,OR,TIMES,SEMICOLON,RSQUAREB,MOD,LESS,ELSE,GREATER,EOF, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { CARET,RCURLYB,LSQUAREB,GREATER,DIV,PLUS,DO,AND,IN,ELSE,SEMICOLON,COMMA,RSQUAREB,THEN,MINUS,EQ,LESSEQ,MOD,TIMES,OR,LPAREN,RPAREN,NEQ,LESS,GREATEREQ,EOF, }
  (66) RValue --> .Integer  { LESS,THEN,RPAREN,LESSEQ,MINUS,RSQUAREB,LPAREN,OR,DIV,EQ,ELSE,CARET,LSQUAREB,GREATER,EOF,DO,MOD,COMMA,PLUS,SEMICOLON,IN,NEQ,RCURLYB,TIMES,AND,GREATEREQ, }
  (68) RValue --> .StringLit  { AND,SEMICOLON,COMMA,MOD,MINUS,PLUS,LSQUAREB,EOF,DO,GREATER,LPAREN,OR,LESSEQ,IN,THEN,EQ,ELSE,RCURLYB,RSQUAREB,LESS,TIMES,NEQ,RPAREN,CARET,GREATEREQ,DIV, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { LESSEQ,NEQ,OR,MINUS,DO,RSQUAREB,SEMICOLON,AND,LESS,DIV,RCURLYB,GREATER,PLUS,GREATEREQ,EQ,TIMES,CARET,IN,MOD,RPAREN,COMMA,EOF,THEN,ELSE, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { MINUS,NEQ,CARET,RSQUAREB,TIMES,COMMA,IN,EOF,MOD,DO,ELSE,LSQUAREB,THEN,PLUS,LPAREN,GREATEREQ,OR,SEMICOLON,RPAREN,GREATER,EQ,DIV,AND,LESS,LESSEQ,RCURLYB, }
  (24) LValue --> .Var  { DIV,CARET,RCURLYB,PLUS,LESS,EOF,RPAREN,ELSE,GREATEREQ,TIMES,NEQ,COMMA,RSQUAREB,MOD,EQ,GREATER,THEN,LPAREN,AND,DO,SEMICOLON,IN,OR,MINUS,LESSEQ,LSQUAREB, }
  (55) TimesExpr --> .TimesExpr DIV UnaryExpr  { SEMICOLON,AND,GREATEREQ,RSQUAREB,CARET,NEQ,DO,LESSEQ,MOD,TIMES,RCURLYB,RPAREN,OR,IN,EOF,MINUS,PLUS,ELSE,GREATER,COMMA,DIV,EQ,LESS,THEN, }
  (56) TimesExpr --> .TimesExpr MOD UnaryExpr  { DO,MOD,LESSEQ,LESS,DIV,ELSE,THEN,GREATEREQ,COMMA,RCURLYB,RSQUAREB,PLUS,OR,GREATER,AND,EQ,TIMES,IN,EOF,NEQ,RPAREN,MINUS,CARET,SEMICOLON, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { IN,NEQ,PLUS,COMMA,AND,OR,DIV,THEN,CARET,LESSEQ,GREATEREQ,RPAREN,EOF,EQ,RCURLYB,LSQUAREB,RSQUAREB,ELSE,LPAREN,LESS,SEMICOLON,MINUS,MOD,TIMES,DO,GREATER, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { LPAREN,MOD,LSQUAREB,RCURLYB,AND,GREATER,EQ,ELSE,DO,THEN,TIMES,IN,RSQUAREB,SEMICOLON,PLUS,NEQ,MINUS,LESS,DIV,GREATEREQ,OR,COMMA,LESSEQ,EOF,RPAREN,CARET, }
  (41) UnaryExpr --> .RValue  { PLUS,TIMES,SEMICOLON,GREATEREQ,GREATER,AND,LESS,OR,RCURLYB,RSQUAREB,IN,DO,MOD,MINUS,EOF,LESSEQ,CARET,ELSE,RPAREN,THEN,EQ,DIV,NEQ,COMMA, }
state 63:
  (54) TimesExpr --> .TimesExpr TIMES UnaryExpr  { RSQUAREB,EQ,OR,COMMA,EOF,NEQ,RPAREN,CARET,TIMES,AND,THEN,MINUS,IN,SEMICOLON,RCURLYB,LESSEQ,DO,PLUS,ELSE,LESS,DIV,GREATEREQ,GREATER,MOD, }
  (68) RValue --> .StringLit  { RPAREN,SEMICOLON,EOF,OR,DIV,COMMA,PLUS,THEN,LSQUAREB,DO,EQ,CARET,MINUS,GREATER,ELSE,LPAREN,AND,TIMES,IN,RSQUAREB,NEQ,LESS,MOD,RCURLYB,LESSEQ,GREATEREQ, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { OR,RCURLYB,SEMICOLON,MINUS,TIMES,ELSE,LPAREN,AND,EOF,COMMA,LSQUAREB,PLUS,LESSEQ,GREATER,MOD,NEQ,DO,IN,DIV,RPAREN,GREATEREQ,EQ,LESS,RSQUAREB,CARET,THEN, }
  (42) RValue --> .LPAREN Expr RPAREN  { THEN,SEMICOLON,DO,CARET,IN,EOF,MOD,EQ,OR,GREATER,RPAREN,RCURLYB,LSQUAREB,RSQUAREB,MINUS,GREATEREQ,LESSEQ,DIV,NEQ,COMMA,LESS,AND,PLUS,ELSE,TIMES,LPAREN, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { EQ,SEMICOLON,THEN,GREATEREQ,ELSE,GREATER,AND,DO,CARET,OR,LSQUAREB,MOD,COMMA,IN,DIV,LESSEQ,LESS,RCURLYB,TIMES,RSQUAREB,RPAREN,MINUS,PLUS,LPAREN,NEQ,EOF, }
  (40) UnaryExpr --> .LValue  { EOF,CARET,DO,DIV,THEN,ELSE,RPAREN,RSQUAREB,AND,SEMICOLON,COMMA,LESSEQ,TIMES,RCURLYB,PLUS,NEQ,EQ,GREATEREQ,MOD,GREATER,OR,LESS,MINUS,IN, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { CARET,RSQUAREB,MOD,PLUS,LSQUAREB,LESS,AND,EOF,DIV,RPAREN,SEMICOLON,EQ,RCURLYB,GREATER,IN,MINUS,GREATEREQ,COMMA,ELSE,LPAREN,THEN,TIMES,NEQ,OR,DO,LESSEQ, }
  (39) TimesExpr --> .UnaryExpr  { THEN,PLUS,OR,RPAREN,SEMICOLON,ELSE,GREATER,AND,COMMA,NEQ,MOD,IN,EOF,DIV,EQ,LESSEQ,RCURLYB,GREATEREQ,CARET,RSQUAREB,DO,MINUS,LESS,TIMES, }
  (57) UnaryExpr --> .NOT UnaryExpr  { AND,SEMICOLON,PLUS,OR,RCURLYB,LESSEQ,DIV,EOF,IN,MINUS,EQ,COMMA,ELSE,NEQ,LESS,DO,THEN,RSQUAREB,RPAREN,TIMES,MOD,GREATER,CARET,GREATEREQ, }
  (66) RValue --> .Integer  { RPAREN,THEN,GREATER,CARET,EOF,OR,RSQUAREB,EQ,PLUS,LESSEQ,RCURLYB,MINUS,GREATEREQ,TIMES,SEMICOLON,ELSE,AND,LPAREN,COMMA,DO,LESS,MOD,LSQUAREB,IN,NEQ,DIV, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { RCURLYB,OR,AND,MOD,IN,LSQUAREB,CARET,LPAREN,PLUS,DIV,TIMES,GREATEREQ,MINUS,DO,SEMICOLON,THEN,LESS,GREATER,ELSE,EQ,LESSEQ,NEQ,COMMA,RSQUAREB,EOF,RPAREN, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { EQ,DIV,EOF,LESSEQ,AND,NEQ,CARET,OR,GREATER,PLUS,LESS,THEN,IN,ELSE,LPAREN,RSQUAREB,RPAREN,RCURLYB,COMMA,LSQUAREB,MOD,TIMES,GREATEREQ,DO,SEMICOLON,MINUS, }
  (53) PlusExpr --> PlusExpr CARET .TimesExpr  { LESSEQ,EOF,PLUS,CARET,EQ,THEN,GREATER,IN,RCURLYB,AND,NEQ,ELSE,RSQUAREB,OR,COMMA,DO,RPAREN,GREATEREQ,SEMICOLON,MINUS,LESS, }
  (24) LValue --> .Var  { THEN,RSQUAREB,AND,GREATEREQ,TIMES,CARET,DIV,RCURLYB,DO,MINUS,EQ,NEQ,EOF,LESS,OR,COMMA,SEMICOLON,GREATER,PLUS,IN,MOD,ELSE,LPAREN,LESSEQ,LSQUAREB,RPAREN, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { DO,RPAREN,EQ,COMMA,RCURLYB,MOD,CARET,PLUS,IN,LESS,TIMES,GREATEREQ,AND,ELSE,DIV,OR,RSQUAREB,EOF,NEQ,MINUS,GREATER,LESSEQ,SEMICOLON,THEN, }
  (41) UnaryExpr --> .RValue  { CARET,AND,THEN,GREATEREQ,RPAREN,COMMA,DIV,GREATER,MINUS,RCURLYB,IN,EQ,NEQ,LESSEQ,OR,ELSE,EOF,DO,LESS,PLUS,MOD,TIMES,RSQUAREB,SEMICOLON, }
  (55) TimesExpr --> .TimesExpr DIV UnaryExpr  { TIMES,RSQUAREB,AND,IN,RCURLYB,COMMA,OR,ELSE,PLUS,SEMICOLON,DIV,CARET,NEQ,EOF,RPAREN,EQ,GREATEREQ,LESSEQ,GREATER,MOD,DO,MINUS,THEN,LESS, }
  (56) TimesExpr --> .TimesExpr MOD UnaryExpr  { EOF,DO,MINUS,NEQ,TIMES,COMMA,OR,PLUS,ELSE,MOD,AND,GREATEREQ,SEMICOLON,LESSEQ,IN,RCURLYB,RPAREN,CARET,LESS,THEN,RSQUAREB,EQ,GREATER,DIV, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { LESSEQ,RCURLYB,EOF,CARET,LESS,LSQUAREB,AND,GREATEREQ,MINUS,DO,GREATER,DIV,SEMICOLON,COMMA,OR,RSQUAREB,EQ,ELSE,NEQ,THEN,MOD,RPAREN,TIMES,LPAREN,IN,PLUS, }
  (67) RValue --> .Float  { LSQUAREB,SEMICOLON,MOD,TIMES,DO,PLUS,ELSE,EQ,RPAREN,LESS,COMMA,LESSEQ,MINUS,RCURLYB,CARET,LPAREN,DIV,OR,RSQUAREB,IN,GREATER,AND,NEQ,GREATEREQ,EOF,THEN, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { EOF,GREATEREQ,RSQUAREB,ELSE,IN,DO,TIMES,AND,SEMICOLON,DIV,MINUS,MOD,NEQ,EQ,RPAREN,PLUS,OR,RCURLYB,COMMA,CARET,LESS,LESSEQ,GREATER,THEN, }
state 64:
  (42) RValue --> LPAREN Expr .RPAREN  { OR,GREATER,COMMA,DO,LESS,MOD,THEN,LESSEQ,GREATEREQ,EQ,IN,RCURLYB,LPAREN,AND,RPAREN,PLUS,DIV,RSQUAREB,SEMICOLON,TIMES,NEQ,ELSE,LSQUAREB,EOF,MINUS,CARET, }
state 65:
  (17) BlockExpr --> IF Expr .THEN Expr ELSE BlockExpr  { IN,RCURLYB,LCURLYB,T_FLOAT,RSQUAREB,EOF,DEFINE,Var,LET,Integer,T_STRING,Float,LPAREN,COMMA,SEMICOLON,NEGATE,RPAREN,WHILE,LAMBDA,T_INT,LSQUAREB,T_VOID,NOT,DO,PRINT,THEN,StringLit,ELSE,IF, }
  (20) NonBlockExpr --> IF Expr .THEN Expr ELSE NonBlockExpr  { EOF,COMMA,RPAREN,THEN,RCURLYB,DO,RSQUAREB,IN,ELSE,SEMICOLON, }
state 66:
  (65) ArgList --> Expr .COMMA ArgList  { RSQUAREB, }
  (64) ArgList --> Expr .  { RSQUAREB, }
  (70) RValue --> LSQUAREB Expr .SEMICOLON Expr RSQUAREB  { RCURLYB,NEQ,SEMICOLON,EOF,COMMA,ELSE,LPAREN,LSQUAREB,LESS,PLUS,CARET,MOD,MINUS,EQ,OR,DO,AND,IN,GREATEREQ,THEN,TIMES,RSQUAREB,LESSEQ,DIV,RPAREN,GREATER, }
state 67:
  (69) RValue --> LSQUAREB ArgList .RSQUAREB  { RCURLYB,LPAREN,TIMES,EOF,LSQUAREB,OR,CARET,COMMA,SEMICOLON,GREATEREQ,LESS,LESSEQ,EQ,GREATER,MINUS,NEQ,RPAREN,RSQUAREB,PLUS,ELSE,IN,MOD,AND,DO,DIV,THEN, }
state 68:
  (10) Stmt --> NonBlockExpr SEMICOLON .  { LSQUAREB,DEFINE,RCURLYB,StringLit,NOT,SEMICOLON,LET,T_VOID,Var,T_STRING,T_INT,T_FLOAT,IF,EOF,Float,Integer,LCURLYB,PRINT,WHILE,LPAREN,LAMBDA,NEGATE, }
state 69:
  (6) BlockStmt --> LCURLYB Stmts .RCURLYB  { T_STRING,T_INT,Var,ELSE,WHILE,LSQUAREB,LPAREN,THEN,T_VOID,NEGATE,NOT,IF,DEFINE,Integer,StringLit,EOF,COMMA,T_FLOAT,RSQUAREB,RCURLYB,Float,DO,PRINT,LCURLYB,RPAREN,SEMICOLON,LET,LAMBDA,IN, }
state 70:
  (38) PlusExpr --> .TimesExpr  { SEMICOLON,CARET,DO,ELSE,COMMA,LESSEQ,RCURLYB,GREATER,NEQ,LESS,RSQUAREB,MINUS,THEN,IN,OR,PLUS,GREATEREQ,AND,RPAREN,EQ,EOF, }
  (35) AndExpr --> .EqExpr  { SEMICOLON,OR,RSQUAREB,COMMA,AND,RPAREN,THEN,DO,RCURLYB,ELSE,EOF,IN, }
  (44) AndExpr --> .AndExpr AND EqExpr  { AND,ELSE,SEMICOLON,THEN,IN,RPAREN,EOF,COMMA,RCURLYB,RSQUAREB,DO,OR, }
  (54) TimesExpr --> .TimesExpr TIMES UnaryExpr  { LESS,ELSE,OR,COMMA,MOD,THEN,LESSEQ,GREATEREQ,RPAREN,RCURLYB,AND,PLUS,TIMES,RSQUAREB,EOF,NEQ,IN,MINUS,EQ,SEMICOLON,CARET,DO,GREATER,DIV, }
  (68) RValue --> .StringLit  { EOF,RCURLYB,LESS,CARET,THEN,DO,GREATEREQ,SEMICOLON,LSQUAREB,RSQUAREB,ELSE,IN,PLUS,RPAREN,AND,OR,NEQ,DIV,COMMA,LESSEQ,LPAREN,TIMES,MINUS,GREATER,EQ,MOD, }
  (37) CompExpr --> .PlusExpr  { GREATEREQ,SEMICOLON,LESSEQ,RSQUAREB,LESS,OR,NEQ,AND,DO,IN,RCURLYB,RPAREN,GREATER,ELSE,EOF,COMMA,EQ,THEN, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { RCURLYB,RPAREN,DO,GREATER,LESS,IN,COMMA,TIMES,OR,AND,ELSE,THEN,SEMICOLON,EQ,PLUS,DIV,MINUS,CARET,NEQ,EOF,LESSEQ,GREATEREQ,RSQUAREB,MOD, }
  (40) UnaryExpr --> .LValue  { RSQUAREB,EQ,LESSEQ,DO,IN,THEN,CARET,ELSE,TIMES,MOD,RCURLYB,SEMICOLON,COMMA,DIV,RPAREN,GREATEREQ,LESS,AND,GREATER,OR,NEQ,EOF,MINUS,PLUS, }
  (57) UnaryExpr --> .NOT UnaryExpr  { IN,PLUS,ELSE,NEQ,EOF,LESS,COMMA,DO,RPAREN,GREATEREQ,MINUS,OR,THEN,DIV,RCURLYB,RSQUAREB,GREATER,MOD,SEMICOLON,TIMES,AND,EQ,CARET,LESSEQ, }
  (55) TimesExpr --> .TimesExpr DIV UnaryExpr  { LESS,DO,IN,NEQ,MOD,CARET,AND,PLUS,OR,EQ,COMMA,RSQUAREB,RCURLYB,TIMES,GREATEREQ,RPAREN,LESSEQ,ELSE,GREATER,SEMICOLON,DIV,THEN,MINUS,EOF, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { IN,GREATER,DIV,PLUS,GREATEREQ,LESSEQ,MINUS,NEQ,RCURLYB,SEMICOLON,MOD,TIMES,OR,ELSE,COMMA,THEN,RSQUAREB,LESS,RPAREN,AND,DO,EQ,EOF,CARET, }
  (39) TimesExpr --> .UnaryExpr  { SEMICOLON,EOF,GREATEREQ,LESS,MOD,LESSEQ,RSQUAREB,ELSE,IN,OR,AND,GREATER,TIMES,DO,THEN,CARET,PLUS,RCURLYB,MINUS,EQ,RPAREN,COMMA,DIV,NEQ, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { AND,LSQUAREB,CARET,SEMICOLON,DO,NEQ,MINUS,RCURLYB,IN,GREATER,COMMA,TIMES,RSQUAREB,EQ,GREATEREQ,DIV,EOF,PLUS,LESS,OR,LESSEQ,ELSE,RPAREN,LPAREN,THEN,MOD, }
  (36) EqExpr --> .CompExpr  { RPAREN,NEQ,ELSE,IN,COMMA,DO,RSQUAREB,EOF,EQ,SEMICOLON,AND,THEN,RCURLYB,OR, }
  (43) OrExpr --> OrExpr OR .AndExpr  { RCURLYB,COMMA,DO,RPAREN,RSQUAREB,THEN,SEMICOLON,EOF,IN,ELSE,OR, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { LSQUAREB,IN,SEMICOLON,NEQ,GREATER,MOD,EQ,PLUS,LESSEQ,COMMA,CARET,LPAREN,DIV,RCURLYB,MINUS,DO,ELSE,GREATEREQ,THEN,EOF,AND,RPAREN,LESS,RSQUAREB,TIMES,OR, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { GREATER,THEN,LSQUAREB,SEMICOLON,NEQ,CARET,DIV,PLUS,AND,MOD,MINUS,DO,ELSE,COMMA,EQ,TIMES,RSQUAREB,RCURLYB,OR,LPAREN,LESS,EOF,IN,LESSEQ,GREATEREQ,RPAREN, }
  (56) TimesExpr --> .TimesExpr MOD UnaryExpr  { MINUS,CARET,GREATEREQ,EQ,RCURLYB,DIV,EOF,COMMA,IN,SEMICOLON,NEQ,RPAREN,PLUS,THEN,TIMES,DO,ELSE,MOD,OR,AND,LESS,RSQUAREB,GREATER,LESSEQ, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { LESSEQ,GREATEREQ,COMMA,NEQ,RCURLYB,GREATER,LPAREN,SEMICOLON,LESS,ELSE,THEN,RSQUAREB,DO,OR,RPAREN,MINUS,EQ,DIV,PLUS,CARET,TIMES,IN,LSQUAREB,AND,EOF,MOD, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { SEMICOLON,AND,NEQ,COMMA,LPAREN,DO,THEN,GREATEREQ,EQ,RCURLYB,LSQUAREB,ELSE,MINUS,CARET,RPAREN,IN,OR,LESS,EOF,TIMES,DIV,MOD,RSQUAREB,GREATER,PLUS,LESSEQ, }
  (42) RValue --> .LPAREN Expr RPAREN  { DIV,LESS,AND,RCURLYB,OR,CARET,ELSE,LPAREN,NEQ,MOD,GREATER,EOF,LSQUAREB,DO,EQ,LESSEQ,RPAREN,PLUS,COMMA,TIMES,THEN,GREATEREQ,IN,SEMICOLON,MINUS,RSQUAREB, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { PLUS,LESS,RPAREN,DO,AND,SEMICOLON,COMMA,GREATEREQ,EQ,DIV,ELSE,MOD,THEN,CARET,IN,LESSEQ,RCURLYB,OR,RSQUAREB,EOF,LSQUAREB,NEQ,LPAREN,GREATER,TIMES,MINUS, }
  (52) PlusExpr --> .PlusExpr MINUS TimesExpr  { RSQUAREB,RCURLYB,DO,SEMICOLON,PLUS,LESSEQ,NEQ,GREATER,COMMA,EOF,CARET,THEN,OR,EQ,GREATEREQ,ELSE,IN,LESS,RPAREN,MINUS,AND, }
  (24) LValue --> .Var  { EQ,OR,DIV,LPAREN,RCURLYB,PLUS,DO,SEMICOLON,TIMES,GREATEREQ,EOF,LESSEQ,GREATER,AND,THEN,MINUS,ELSE,CARET,LSQUAREB,NEQ,IN,LESS,RSQUAREB,RPAREN,MOD,COMMA, }
  (45) EqExpr --> .EqExpr EQ CompExpr  { IN,DO,EQ,AND,RPAREN,COMMA,EOF,OR,ELSE,SEMICOLON,THEN,NEQ,RCURLYB,RSQUAREB, }
  (48) CompExpr --> .CompExpr GREATER PlusExpr  { EQ,SEMICOLON,LESS,OR,COMMA,NEQ,GREATER,RSQUAREB,THEN,AND,RCURLYB,ELSE,IN,GREATEREQ,RPAREN,DO,EOF,LESSEQ, }
  (49) CompExpr --> .CompExpr LESSEQ PlusExpr  { NEQ,RCURLYB,EQ,RPAREN,DO,GREATEREQ,GREATER,EOF,LESS,COMMA,RSQUAREB,IN,SEMICOLON,AND,OR,LESSEQ,ELSE,THEN, }
  (47) CompExpr --> .CompExpr LESS PlusExpr  { RSQUAREB,DO,EOF,IN,GREATEREQ,RPAREN,OR,THEN,EQ,GREATER,NEQ,SEMICOLON,LESSEQ,RCURLYB,AND,LESS,COMMA,ELSE, }
  (66) RValue --> .Integer  { RSQUAREB,LSQUAREB,THEN,CARET,DIV,COMMA,ELSE,TIMES,EOF,MINUS,GREATER,GREATEREQ,NEQ,LPAREN,IN,AND,OR,MOD,SEMICOLON,DO,PLUS,EQ,LESSEQ,LESS,RPAREN,RCURLYB, }
  (53) PlusExpr --> .PlusExpr CARET TimesExpr  { COMMA,RPAREN,EOF,GREATER,MINUS,PLUS,ELSE,IN,DO,LESSEQ,RCURLYB,LESS,SEMICOLON,NEQ,THEN,OR,RSQUAREB,AND,GREATEREQ,CARET,EQ, }
  (46) EqExpr --> .EqExpr NEQ CompExpr  { ELSE,NEQ,COMMA,RCURLYB,SEMICOLON,THEN,DO,EOF,IN,OR,RPAREN,EQ,AND,RSQUAREB, }
  (67) RValue --> .Float  { EQ,GREATER,GREATEREQ,LESS,OR,COMMA,RPAREN,DO,LSQUAREB,ELSE,RSQUAREB,LESSEQ,MOD,THEN,AND,LPAREN,RCURLYB,DIV,EOF,PLUS,MINUS,TIMES,SEMICOLON,IN,NEQ,CARET, }
  (41) UnaryExpr --> .RValue  { COMMA,AND,EOF,OR,EQ,GREATEREQ,DIV,CARET,LESS,NEQ,GREATER,MINUS,MOD,THEN,RPAREN,ELSE,DO,LESSEQ,IN,TIMES,PLUS,SEMICOLON,RCURLYB,RSQUAREB, }
  (50) CompExpr --> .CompExpr GREATEREQ PlusExpr  { EQ,GREATER,NEQ,GREATEREQ,AND,COMMA,LESSEQ,EOF,SEMICOLON,ELSE,IN,LESS,THEN,RSQUAREB,DO,RPAREN,OR,RCURLYB, }
  (51) PlusExpr --> .PlusExpr PLUS TimesExpr  { EOF,IN,LESSEQ,CARET,DO,THEN,GREATEREQ,EQ,MINUS,SEMICOLON,RSQUAREB,ELSE,AND,COMMA,OR,RCURLYB,GREATER,RPAREN,PLUS,NEQ,LESS, }
state 71:
  (25) LValue --> LValue .LSQUAREB Expr RSQUAREB  { THEN,RSQUAREB,EQ,LPAREN,PLUS,GREATEREQ,LSQUAREB,RCURLYB,CARET,GREATER,ELSE,OR,LESS,DIV,RPAREN,COMMA,SEMICOLON,IN,MOD,LESSEQ,NEQ,MINUS,DO,EOF,AND,TIMES, }
  (60) RValue --> LValue .LPAREN ArgList RPAREN  { LSQUAREB,COMMA,RSQUAREB,EOF,NEQ,GREATEREQ,DO,EQ,RCURLYB,THEN,TIMES,SEMICOLON,IN,AND,LESSEQ,LESS,LPAREN,ELSE,MINUS,OR,RPAREN,MOD,DIV,CARET,PLUS,GREATER, }
  (40) UnaryExpr --> LValue .  { EQ,MINUS,SEMICOLON,DIV,MOD,DO,RCURLYB,OR,IN,LESS,RPAREN,PLUS,AND,ELSE,RSQUAREB,TIMES,COMMA,LESSEQ,GREATER,CARET,EOF,NEQ,THEN,GREATEREQ, }
state 72:
  (59) UnaryExpr --> PRINT UnaryExpr .  { PLUS,RPAREN,RCURLYB,RSQUAREB,THEN,MINUS,MOD,COMMA,OR,LESS,CARET,LESSEQ,NEQ,ELSE,EQ,GREATER,DIV,GREATEREQ,DO,AND,SEMICOLON,EOF,TIMES,IN, }
state 73:
  (58) UnaryExpr --> NEGATE UnaryExpr .  { EOF,MINUS,OR,EQ,NEQ,COMMA,THEN,RCURLYB,DO,DIV,TIMES,LESS,AND,MOD,ELSE,GREATEREQ,SEMICOLON,RPAREN,GREATER,LESSEQ,IN,PLUS,RSQUAREB,CARET, }
state 74:
  (30) ParamList --> TypedParam .COMMA ParamList  { DOT, }
  (29) ParamList --> TypedParam .  { DOT, }
state 75:
  (13) TypedParam --> Var .COLON Type  { COMMA,DOT, }
state 76:
  (26) NonBlockExpr --> LAMBDA ParamList .DOT Expr  { THEN,ELSE,RPAREN,RSQUAREB,COMMA,IN,DO,SEMICOLON,EOF,RCURLYB, }
state 77:
  (27) NonBlockExpr --> ReturnType LAMBDA .ParamList DOT Expr  { RPAREN,RSQUAREB,DO,COMMA,EOF,RCURLYB,SEMICOLON,IN,THEN,ELSE, }
  (28) ParamList --> .  { DOT, }
  (29) ParamList --> .TypedParam  { DOT, }
  (13) TypedParam --> .Var COLON Type  { DOT,COMMA, }
  (30) ParamList --> .TypedParam COMMA ParamList  { DOT, }
state 78:
  (57) UnaryExpr --> NOT UnaryExpr .  { ELSE,LESS,RPAREN,COMMA,RSQUAREB,PLUS,TIMES,DIV,DO,RCURLYB,LESSEQ,GREATEREQ,EQ,MOD,THEN,GREATER,IN,CARET,OR,EOF,NEQ,AND,SEMICOLON,MINUS, }
state 79:
  (74) Type --> Type LSQUAREB .RSQUAREB  { DOT,LAMBDA,LSQUAREB,COMMA,ASSIGN, }
state 80:
  (15) DefineExpr --> DEFINE Param .ASSIGN Expr  { SEMICOLON,EOF,RCURLYB, }
state 81:
  (36) EqExpr --> .CompExpr  { SEMICOLON,IN,EQ,THEN,OR,EOF,COMMA,RCURLYB,RSQUAREB,ELSE,RPAREN,NEQ,DO,AND, }
  (22) NonBlockExpr --> .LET Param ASSIGN Expr IN NonBlockExpr  { SEMICOLON,IN,DO,COMMA,EOF,RSQUAREB,RPAREN,THEN,ELSE,RCURLYB, }
  (74) Type --> .Type LSQUAREB RSQUAREB  { LAMBDA,LSQUAREB, }
  (32) ReturnType --> .Type  { LAMBDA, }
  (43) OrExpr --> .OrExpr OR AndExpr  { RPAREN,DO,RCURLYB,RSQUAREB,OR,IN,COMMA,THEN,EOF,SEMICOLON,ELSE, }
  (57) UnaryExpr --> .NOT UnaryExpr  { COMMA,LESS,AND,LESSEQ,PLUS,DO,GREATER,RPAREN,RSQUAREB,CARET,MOD,IN,MINUS,GREATEREQ,EQ,OR,SEMICOLON,TIMES,EOF,THEN,RCURLYB,NEQ,ELSE,DIV, }
  (23) NonBlockExpr --> .LValue ASSIGN Expr  { IN,RPAREN,EOF,THEN,ELSE,DO,RSQUAREB,RCURLYB,SEMICOLON,COMMA, }
  (21) NonBlockExpr --> WHILE Expr DO .NonBlockExpr  { RSQUAREB,COMMA,THEN,ELSE,RPAREN,IN,DO,EOF,RCURLYB,SEMICOLON, }
  (42) RValue --> .LPAREN Expr RPAREN  { PLUS,ELSE,LSQUAREB,LESSEQ,LPAREN,EOF,RSQUAREB,MINUS,OR,RCURLYB,COMMA,NEQ,LESS,SEMICOLON,GREATEREQ,DO,EQ,IN,MOD,THEN,TIMES,CARET,GREATER,RPAREN,DIV,AND, }
  (21) NonBlockExpr --> .WHILE Expr DO NonBlockExpr  { EOF,ELSE,THEN,RPAREN,RCURLYB,DO,IN,SEMICOLON,COMMA,RSQUAREB, }
  (38) PlusExpr --> .TimesExpr  { PLUS,COMMA,GREATER,CARET,DO,SEMICOLON,EQ,RSQUAREB,ELSE,GREATEREQ,OR,RPAREN,AND,IN,THEN,MINUS,NEQ,EOF,LESS,RCURLYB,LESSEQ, }
  (53) PlusExpr --> .PlusExpr CARET TimesExpr  { GREATEREQ,IN,OR,RPAREN,NEQ,AND,GREATER,THEN,EQ,DO,RSQUAREB,SEMICOLON,LESS,EOF,PLUS,COMMA,CARET,LESSEQ,RCURLYB,MINUS,ELSE, }
  (68) RValue --> .StringLit  { RSQUAREB,TIMES,RPAREN,RCURLYB,IN,LESS,DIV,GREATEREQ,MOD,OR,MINUS,AND,COMMA,EQ,EOF,THEN,DO,LESSEQ,LPAREN,ELSE,CARET,LSQUAREB,NEQ,SEMICOLON,GREATER,PLUS, }
  (66) RValue --> .Integer  { RPAREN,MINUS,SEMICOLON,LESSEQ,GREATER,RCURLYB,PLUS,RSQUAREB,LPAREN,TIMES,IN,ELSE,EOF,DIV,THEN,GREATEREQ,COMMA,AND,CARET,OR,NEQ,MOD,DO,LSQUAREB,EQ,LESS, }
  (37) CompExpr --> .PlusExpr  { THEN,RPAREN,GREATER,OR,IN,EQ,COMMA,AND,RSQUAREB,ELSE,GREATEREQ,DO,NEQ,LESS,LESSEQ,SEMICOLON,EOF,RCURLYB, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { DO,LPAREN,MOD,RPAREN,PLUS,RSQUAREB,DIV,MINUS,AND,LSQUAREB,THEN,IN,LESS,LESSEQ,TIMES,COMMA,GREATER,ELSE,NEQ,SEMICOLON,OR,EOF,RCURLYB,CARET,GREATEREQ,EQ, }
  (40) UnaryExpr --> .LValue  { MOD,CARET,RCURLYB,ELSE,NEQ,DO,EQ,PLUS,COMMA,GREATER,GREATEREQ,RPAREN,SEMICOLON,MINUS,IN,TIMES,AND,DIV,RSQUAREB,LESSEQ,EOF,LESS,OR,THEN, }
  (6) BlockStmt --> .LCURLYB Stmts RCURLYB  { WHILE,LET,LSQUAREB,Float,DEFINE,Var,NEGATE,THEN,T_STRING,ELSE,LCURLYB,RPAREN,DO,IN,StringLit,EOF,LPAREN,T_VOID,PRINT,SEMICOLON,RCURLYB,LAMBDA,RSQUAREB,IF,NOT,Integer,T_INT,COMMA,T_FLOAT, }
  (52) PlusExpr --> .PlusExpr MINUS TimesExpr  { GREATER,MINUS,EOF,AND,SEMICOLON,IN,RSQUAREB,CARET,RCURLYB,EQ,OR,GREATEREQ,ELSE,LESS,PLUS,RPAREN,NEQ,THEN,COMMA,DO,LESSEQ, }
  (46) EqExpr --> .EqExpr NEQ CompExpr  { DO,COMMA,AND,RCURLYB,RSQUAREB,OR,RPAREN,EOF,THEN,ELSE,NEQ,EQ,IN,SEMICOLON, }
  (18) BlockExpr --> .WHILE Expr DO BlockExpr  { IN,T_FLOAT,EOF,RSQUAREB,NOT,NEGATE,COMMA,Integer,RCURLYB,Var,ELSE,DO,T_VOID,PRINT,IF,LSQUAREB,LET,SEMICOLON,WHILE,LCURLYB,LAMBDA,RPAREN,StringLit,LPAREN,DEFINE,T_STRING,T_INT,THEN,Float, }
  (73) Type --> .T_STRING  { LSQUAREB,LAMBDA, }
  (17) BlockExpr --> .IF Expr THEN Expr ELSE BlockExpr  { SEMICOLON,RSQUAREB,IN,LET,LSQUAREB,RCURLYB,T_VOID,Float,NOT,COMMA,WHILE,LAMBDA,NEGATE,IF,EOF,RPAREN,T_FLOAT,Integer,T_STRING,T_INT,DO,Var,PRINT,DEFINE,ELSE,THEN,LCURLYB,LPAREN,StringLit, }
  (51) PlusExpr --> .PlusExpr PLUS TimesExpr  { RCURLYB,DO,THEN,ELSE,GREATER,PLUS,OR,NEQ,MINUS,RPAREN,LESSEQ,SEMICOLON,AND,GREATEREQ,COMMA,RSQUAREB,LESS,EOF,EQ,CARET,IN, }
  (55) TimesExpr --> .TimesExpr DIV UnaryExpr  { NEQ,AND,MOD,RCURLYB,ELSE,GREATEREQ,RPAREN,RSQUAREB,OR,DIV,EQ,COMMA,LESS,EOF,IN,LESSEQ,DO,PLUS,TIMES,CARET,SEMICOLON,MINUS,GREATER,THEN, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { GREATER,PLUS,LPAREN,CARET,MOD,THEN,IN,DO,GREATEREQ,LSQUAREB,RSQUAREB,SEMICOLON,LESS,COMMA,NEQ,DIV,TIMES,OR,ELSE,MINUS,RCURLYB,EOF,LESSEQ,AND,EQ,RPAREN, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { DO,MOD,MINUS,SEMICOLON,AND,COMMA,TIMES,EOF,RPAREN,GREATER,CARET,THEN,PLUS,OR,DIV,ELSE,NEQ,IN,GREATEREQ,RSQUAREB,LESS,RCURLYB,EQ,LESSEQ, }
  (56) TimesExpr --> .TimesExpr MOD UnaryExpr  { GREATER,NEQ,RPAREN,ELSE,GREATEREQ,PLUS,THEN,COMMA,SEMICOLON,TIMES,CARET,LESSEQ,DO,DIV,IN,EOF,AND,RSQUAREB,MINUS,EQ,RCURLYB,LESS,OR,MOD, }
  (16) BlockExpr --> .BlockStmt  { LCURLYB,LET,StringLit,RPAREN,PRINT,DEFINE,WHILE,NEGATE,Integer,T_VOID,RSQUAREB,LAMBDA,Var,T_FLOAT,NOT,THEN,COMMA,Float,SEMICOLON,T_INT,IF,T_STRING,RCURLYB,LPAREN,EOF,IN,ELSE,LSQUAREB,DO, }
  (41) UnaryExpr --> .RValue  { DO,THEN,RSQUAREB,NEQ,EQ,PLUS,RCURLYB,AND,GREATEREQ,OR,DIV,RPAREN,LESSEQ,EOF,MINUS,LESS,IN,GREATER,CARET,SEMICOLON,MOD,ELSE,TIMES,COMMA, }
  (34) OrExpr --> .AndExpr  { RSQUAREB,THEN,OR,SEMICOLON,EOF,IN,COMMA,RCURLYB,RPAREN,DO,ELSE, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { GREATER,CARET,LESS,RSQUAREB,DIV,ELSE,IN,AND,EQ,SEMICOLON,MINUS,EOF,PLUS,RCURLYB,COMMA,TIMES,GREATEREQ,THEN,MOD,OR,DO,NEQ,RPAREN,LESSEQ, }
  (45) EqExpr --> .EqExpr EQ CompExpr  { OR,RSQUAREB,EOF,IN,DO,EQ,AND,NEQ,RPAREN,COMMA,ELSE,RCURLYB,SEMICOLON,THEN, }
  (50) CompExpr --> .CompExpr GREATEREQ PlusExpr  { OR,RPAREN,AND,LESSEQ,RCURLYB,COMMA,DO,EOF,NEQ,SEMICOLON,RSQUAREB,IN,GREATEREQ,EQ,ELSE,LESS,GREATER,THEN, }
  (39) TimesExpr --> .UnaryExpr  { SEMICOLON,DIV,COMMA,GREATEREQ,EQ,OR,ELSE,MOD,MINUS,RPAREN,GREATER,RCURLYB,AND,LESS,NEQ,THEN,TIMES,PLUS,EOF,RSQUAREB,DO,IN,CARET,LESSEQ, }
  (47) CompExpr --> .CompExpr LESS PlusExpr  { AND,RSQUAREB,NEQ,GREATEREQ,IN,OR,LESSEQ,RPAREN,DO,EQ,GREATER,RCURLYB,EOF,THEN,COMMA,SEMICOLON,LESS,ELSE, }
  (24) LValue --> .Var  { ASSIGN,DO,SEMICOLON,CARET,EOF,RPAREN,OR,MINUS,LESSEQ,MOD,LPAREN,AND,THEN,RCURLYB,TIMES,RSQUAREB,IN,ELSE,DIV,GREATER,NEQ,COMMA,EQ,LSQUAREB,LESS,PLUS,GREATEREQ, }
  (54) TimesExpr --> .TimesExpr TIMES UnaryExpr  { RPAREN,LESS,SEMICOLON,MINUS,NEQ,OR,PLUS,RCURLYB,CARET,ELSE,DIV,TIMES,DO,GREATER,THEN,IN,MOD,LESSEQ,GREATEREQ,AND,EQ,COMMA,RSQUAREB,EOF, }
  (31) ReturnType --> .T_VOID  { LAMBDA, }
  (20) NonBlockExpr --> .IF Expr THEN Expr ELSE NonBlockExpr  { COMMA,THEN,RPAREN,SEMICOLON,RSQUAREB,IN,EOF,DO,RCURLYB,ELSE, }
  (33) NonBlockExpr --> .OrExpr  { RPAREN,ELSE,IN,DO,RCURLYB,THEN,SEMICOLON,COMMA,EOF,RSQUAREB, }
  (18) BlockExpr --> WHILE Expr DO .BlockExpr  { PRINT,LSQUAREB,THEN,T_INT,T_VOID,ELSE,Integer,WHILE,COMMA,Var,IN,EOF,LCURLYB,NEGATE,LET,Float,RPAREN,NOT,LAMBDA,DEFINE,RCURLYB,DO,T_FLOAT,SEMICOLON,StringLit,RSQUAREB,T_STRING,LPAREN,IF, }
  (72) Type --> .T_FLOAT  { LSQUAREB,LAMBDA, }
  (26) NonBlockExpr --> .LAMBDA ParamList DOT Expr  { RCURLYB,ELSE,RSQUAREB,SEMICOLON,COMMA,DO,EOF,RPAREN,THEN,IN, }
  (35) AndExpr --> .EqExpr  { RSQUAREB,RPAREN,RCURLYB,THEN,SEMICOLON,AND,IN,COMMA,EOF,OR,DO,ELSE, }
  (49) CompExpr --> .CompExpr LESSEQ PlusExpr  { RCURLYB,EQ,ELSE,EOF,LESS,RPAREN,IN,GREATEREQ,OR,DO,COMMA,GREATER,LESSEQ,NEQ,RSQUAREB,THEN,SEMICOLON,AND, }
  (48) CompExpr --> .CompExpr GREATER PlusExpr  { LESSEQ,ELSE,RPAREN,NEQ,DO,COMMA,RSQUAREB,AND,LESS,GREATER,IN,EOF,OR,SEMICOLON,GREATEREQ,EQ,THEN,RCURLYB, }
  (71) Type --> .T_INT  { LAMBDA,LSQUAREB, }
  (27) NonBlockExpr --> .ReturnType LAMBDA ParamList DOT Expr  { COMMA,THEN,RPAREN,RSQUAREB,DO,EOF,RCURLYB,ELSE,IN,SEMICOLON, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { MINUS,OR,EOF,DIV,PLUS,TIMES,LPAREN,GREATEREQ,MOD,RSQUAREB,AND,EQ,IN,LESS,LSQUAREB,THEN,DO,GREATER,RPAREN,CARET,SEMICOLON,COMMA,LESSEQ,ELSE,NEQ,RCURLYB, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { SEMICOLON,AND,GREATER,RSQUAREB,DIV,LESS,THEN,ASSIGN,PLUS,GREATEREQ,ELSE,CARET,EOF,MOD,LSQUAREB,DO,LESSEQ,TIMES,RPAREN,IN,MINUS,LPAREN,RCURLYB,NEQ,OR,EQ,COMMA, }
  (44) AndExpr --> .AndExpr AND EqExpr  { EOF,SEMICOLON,RCURLYB,RPAREN,IN,AND,RSQUAREB,ELSE,DO,THEN,OR,COMMA, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { PLUS,NEQ,RSQUAREB,DO,IN,TIMES,LSQUAREB,COMMA,MINUS,THEN,LESS,RPAREN,OR,DIV,AND,LESSEQ,MOD,ELSE,EQ,LPAREN,GREATER,RCURLYB,SEMICOLON,EOF,GREATEREQ,CARET, }
  (19) BlockExpr --> .LET Param ASSIGN Expr IN BlockExpr  { IN,THEN,WHILE,LAMBDA,LCURLYB,LSQUAREB,T_STRING,RPAREN,NOT,SEMICOLON,ELSE,COMMA,T_FLOAT,PRINT,T_VOID,DEFINE,IF,RSQUAREB,RCURLYB,EOF,Var,Float,DO,Integer,LET,StringLit,LPAREN,NEGATE,T_INT, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { COMMA,NEQ,AND,LPAREN,TIMES,THEN,EOF,CARET,ELSE,MINUS,GREATER,IN,GREATEREQ,LSQUAREB,SEMICOLON,LESS,RSQUAREB,RPAREN,LESSEQ,DO,PLUS,EQ,DIV,MOD,RCURLYB,OR, }
  (67) RValue --> .Float  { OR,EQ,ELSE,THEN,CARET,RSQUAREB,COMMA,GREATEREQ,MOD,IN,DO,RPAREN,MINUS,LPAREN,LSQUAREB,LESS,EOF,PLUS,TIMES,LESSEQ,SEMICOLON,AND,DIV,NEQ,GREATER,RCURLYB, }
state 82:
  (50) CompExpr --> .CompExpr GREATEREQ PlusExpr  { NEQ,LESS,IN,GREATEREQ,GREATER,LESSEQ,EQ,AND,OR, }
  (71) Type --> .T_INT  { LAMBDA,LSQUAREB, }
  (33) NonBlockExpr --> .OrExpr  { IN, }
  (18) BlockExpr --> .WHILE Expr DO BlockExpr  { IN, }
  (23) NonBlockExpr --> .LValue ASSIGN Expr  { IN, }
  (42) RValue --> .LPAREN Expr RPAREN  { AND,EQ,IN,LPAREN,PLUS,MINUS,OR,GREATEREQ,LSQUAREB,DIV,GREATER,CARET,NEQ,LESS,TIMES,MOD,LESSEQ, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { GREATEREQ,EQ,IN,AND,TIMES,NEQ,OR,PLUS,CARET,LESSEQ,GREATER,MOD,DIV,LESS,MINUS, }
  (47) CompExpr --> .CompExpr LESS PlusExpr  { LESSEQ,LESS,GREATER,AND,GREATEREQ,EQ,IN,NEQ,OR, }
  (66) RValue --> .Integer  { NEQ,GREATEREQ,AND,IN,LSQUAREB,MOD,TIMES,CARET,GREATER,LPAREN,DIV,MINUS,LESSEQ,LESS,OR,PLUS,EQ, }
  (41) UnaryExpr --> .RValue  { PLUS,GREATEREQ,GREATER,TIMES,LESS,CARET,OR,IN,EQ,AND,LESSEQ,MOD,NEQ,DIV,MINUS, }
  (40) UnaryExpr --> .LValue  { OR,MOD,LESSEQ,IN,DIV,CARET,GREATER,AND,GREATEREQ,LESS,EQ,TIMES,MINUS,NEQ,PLUS, }
  (31) ReturnType --> .T_VOID  { LAMBDA, }
  (43) OrExpr --> .OrExpr OR AndExpr  { OR,IN, }
  (67) RValue --> .Float  { LESS,GREATER,IN,LPAREN,MINUS,NEQ,AND,LESSEQ,TIMES,LSQUAREB,OR,GREATEREQ,MOD,DIV,EQ,PLUS,CARET, }
  (32) ReturnType --> .Type  { LAMBDA, }
  (24) LValue --> .Var  { NEQ,LESSEQ,GREATER,IN,OR,TIMES,PLUS,LESS,LPAREN,MINUS,AND,MOD,DIV,LSQUAREB,EQ,GREATEREQ,ASSIGN,CARET, }
  (36) EqExpr --> .CompExpr  { OR,IN,EQ,NEQ,AND, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { PLUS,OR,GREATEREQ,EQ,CARET,IN,LESSEQ,LESS,GREATER,AND,MOD,MINUS,DIV,TIMES,NEQ, }
  (7) Expr --> .BlockExpr  { IN, }
  (39) TimesExpr --> .UnaryExpr  { CARET,GREATER,OR,TIMES,IN,LESS,LESSEQ,NEQ,EQ,MOD,AND,PLUS,GREATEREQ,DIV,MINUS, }
  (22) NonBlockExpr --> LET Param ASSIGN .Expr IN NonBlockExpr  { DO,THEN,RCURLYB,ELSE,COMMA,EOF,RPAREN,RSQUAREB,IN,SEMICOLON, }
  (51) PlusExpr --> .PlusExpr PLUS TimesExpr  { GREATEREQ,GREATER,AND,IN,LESS,LESSEQ,MINUS,CARET,NEQ,PLUS,OR,EQ, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { GREATER,TIMES,AND,LSQUAREB,PLUS,LPAREN,EQ,MINUS,OR,IN,NEQ,LESSEQ,GREATEREQ,LESS,MOD,DIV,CARET, }
  (38) PlusExpr --> .TimesExpr  { AND,LESS,LESSEQ,GREATEREQ,IN,NEQ,PLUS,EQ,GREATER,CARET,MINUS,OR, }
  (27) NonBlockExpr --> .ReturnType LAMBDA ParamList DOT Expr  { IN, }
  (55) TimesExpr --> .TimesExpr DIV UnaryExpr  { PLUS,DIV,EQ,GREATER,GREATEREQ,IN,NEQ,LESSEQ,OR,TIMES,MINUS,CARET,AND,MOD,LESS, }
  (46) EqExpr --> .EqExpr NEQ CompExpr  { EQ,OR,AND,NEQ,IN, }
  (34) OrExpr --> .AndExpr  { IN,OR, }
  (49) CompExpr --> .CompExpr LESSEQ PlusExpr  { EQ,AND,LESSEQ,LESS,IN,NEQ,GREATEREQ,OR,GREATER, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { LESS,OR,GREATER,MOD,NEQ,GREATEREQ,AND,ASSIGN,IN,TIMES,LPAREN,CARET,DIV,PLUS,MINUS,LSQUAREB,EQ,LESSEQ, }
  (19) BlockExpr --> LET Param ASSIGN .Expr IN BlockExpr  { NEGATE,PRINT,SEMICOLON,WHILE,LSQUAREB,DEFINE,Var,LCURLYB,RCURLYB,RSQUAREB,IN,StringLit,T_FLOAT,RPAREN,IF,LET,EOF,ELSE,NOT,DO,Integer,LPAREN,Float,T_INT,T_STRING,T_VOID,COMMA,THEN,LAMBDA, }
  (48) CompExpr --> .CompExpr GREATER PlusExpr  { NEQ,EQ,AND,GREATER,LESS,OR,LESSEQ,GREATEREQ,IN, }
  (35) AndExpr --> .EqExpr  { OR,AND,IN, }
  (45) EqExpr --> .EqExpr EQ CompExpr  { IN,OR,AND,NEQ,EQ, }
  (53) PlusExpr --> .PlusExpr CARET TimesExpr  { OR,CARET,GREATER,EQ,IN,LESS,PLUS,NEQ,AND,GREATEREQ,LESSEQ,MINUS, }
  (68) RValue --> .StringLit  { OR,IN,LESS,LSQUAREB,PLUS,CARET,DIV,EQ,LESSEQ,AND,MOD,TIMES,GREATEREQ,MINUS,GREATER,NEQ,LPAREN, }
  (52) PlusExpr --> .PlusExpr MINUS TimesExpr  { LESS,OR,EQ,LESSEQ,PLUS,IN,GREATEREQ,AND,GREATER,MINUS,CARET,NEQ, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { LESSEQ,NEQ,GREATEREQ,LSQUAREB,CARET,DIV,TIMES,AND,OR,LESS,MINUS,GREATER,IN,LPAREN,EQ,PLUS,MOD, }
  (8) Expr --> .NonBlockExpr  { IN, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { LPAREN,LSQUAREB,NEQ,PLUS,MOD,MINUS,LESS,GREATEREQ,AND,LESSEQ,TIMES,DIV,CARET,OR,GREATER,IN,EQ, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { MINUS,GREATER,LPAREN,DIV,LESSEQ,CARET,AND,GREATEREQ,LESS,NEQ,LSQUAREB,IN,MOD,TIMES,PLUS,OR,EQ, }
  (57) UnaryExpr --> .NOT UnaryExpr  { PLUS,EQ,NEQ,DIV,TIMES,LESSEQ,MOD,CARET,LESS,IN,GREATER,MINUS,AND,OR,GREATEREQ, }
  (6) BlockStmt --> .LCURLYB Stmts RCURLYB  { IN, }
  (56) TimesExpr --> .TimesExpr MOD UnaryExpr  { OR,LESSEQ,MINUS,AND,DIV,GREATER,PLUS,NEQ,GREATEREQ,EQ,CARET,MOD,IN,TIMES,LESS, }
  (72) Type --> .T_FLOAT  { LAMBDA,LSQUAREB, }
  (26) NonBlockExpr --> .LAMBDA ParamList DOT Expr  { IN, }
  (37) CompExpr --> .PlusExpr  { OR,GREATEREQ,GREATER,IN,NEQ,AND,LESS,EQ,LESSEQ, }
  (16) BlockExpr --> .BlockStmt  { IN, }
  (19) BlockExpr --> .LET Param ASSIGN Expr IN BlockExpr  { IN, }
  (17) BlockExpr --> .IF Expr THEN Expr ELSE BlockExpr  { IN, }
  (21) NonBlockExpr --> .WHILE Expr DO NonBlockExpr  { IN, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { EQ,DIV,PLUS,LPAREN,IN,NEQ,MOD,AND,MINUS,GREATER,CARET,GREATEREQ,OR,TIMES,LSQUAREB,LESSEQ,LESS, }
  (54) TimesExpr --> .TimesExpr TIMES UnaryExpr  { TIMES,DIV,NEQ,MOD,LESSEQ,IN,CARET,PLUS,EQ,OR,GREATEREQ,LESS,MINUS,GREATER,AND, }
  (74) Type --> .Type LSQUAREB RSQUAREB  { LAMBDA,LSQUAREB, }
  (44) AndExpr --> .AndExpr AND EqExpr  { IN,OR,AND, }
  (73) Type --> .T_STRING  { LAMBDA,LSQUAREB, }
  (22) NonBlockExpr --> .LET Param ASSIGN Expr IN NonBlockExpr  { IN, }
  (20) NonBlockExpr --> .IF Expr THEN Expr ELSE NonBlockExpr  { IN, }
state 83:
  (71) Type --> .T_INT  { COMMA,DOT,ASSIGN,LSQUAREB, }
  (74) Type --> .Type LSQUAREB RSQUAREB  { LSQUAREB,COMMA,ASSIGN,DOT, }
  (73) Type --> .T_STRING  { COMMA,ASSIGN,LSQUAREB,DOT, }
  (13) TypedParam --> Var COLON .Type  { ASSIGN,COMMA,DOT, }
  (72) Type --> .T_FLOAT  { ASSIGN,COMMA,LSQUAREB,DOT, }
state 84:
  (47) CompExpr --> CompExpr LESS PlusExpr .  { SEMICOLON,THEN,IN,ELSE,RCURLYB,RSQUAREB,OR,AND,NEQ,EOF,GREATEREQ,LESSEQ,COMMA,EQ,LESS,RPAREN,DO,GREATER, }
  (51) PlusExpr --> PlusExpr .PLUS TimesExpr  { RPAREN,RSQUAREB,LESSEQ,RCURLYB,PLUS,ELSE,LESS,COMMA,THEN,CARET,NEQ,DO,AND,GREATER,SEMICOLON,EOF,GREATEREQ,EQ,IN,MINUS,OR, }
  (53) PlusExpr --> PlusExpr .CARET TimesExpr  { OR,LESSEQ,RCURLYB,NEQ,PLUS,THEN,MINUS,EQ,CARET,AND,SEMICOLON,DO,IN,EOF,LESS,COMMA,ELSE,RSQUAREB,RPAREN,GREATEREQ,GREATER, }
  (52) PlusExpr --> PlusExpr .MINUS TimesExpr  { NEQ,SEMICOLON,AND,LESSEQ,LESS,GREATEREQ,RSQUAREB,EQ,THEN,GREATER,OR,MINUS,EOF,PLUS,RCURLYB,DO,ELSE,CARET,RPAREN,IN,COMMA, }
state 85:
  (49) CompExpr --> CompExpr LESSEQ PlusExpr .  { OR,GREATEREQ,THEN,COMMA,LESSEQ,RCURLYB,RPAREN,SEMICOLON,DO,EQ,NEQ,RSQUAREB,AND,ELSE,IN,EOF,LESS,GREATER, }
  (51) PlusExpr --> PlusExpr .PLUS TimesExpr  { SEMICOLON,IN,OR,PLUS,GREATER,GREATEREQ,COMMA,DO,MINUS,AND,LESSEQ,RSQUAREB,RPAREN,THEN,RCURLYB,CARET,LESS,EQ,ELSE,NEQ,EOF, }
  (53) PlusExpr --> PlusExpr .CARET TimesExpr  { OR,MINUS,ELSE,RPAREN,GREATEREQ,EQ,GREATER,PLUS,RCURLYB,LESSEQ,COMMA,SEMICOLON,NEQ,CARET,THEN,DO,AND,IN,RSQUAREB,EOF,LESS, }
  (52) PlusExpr --> PlusExpr .MINUS TimesExpr  { DO,NEQ,IN,PLUS,SEMICOLON,RCURLYB,EQ,LESSEQ,RPAREN,THEN,COMMA,ELSE,GREATER,LESS,AND,MINUS,GREATEREQ,CARET,OR,RSQUAREB,EOF, }
state 86:
  (51) PlusExpr --> PlusExpr .PLUS TimesExpr  { RPAREN,SEMICOLON,PLUS,LESSEQ,DO,COMMA,CARET,NEQ,EQ,ELSE,GREATEREQ,OR,AND,RSQUAREB,EOF,GREATER,RCURLYB,LESS,IN,MINUS,THEN, }
  (52) PlusExpr --> PlusExpr .MINUS TimesExpr  { RSQUAREB,DO,CARET,IN,LESSEQ,SEMICOLON,OR,THEN,PLUS,AND,RCURLYB,MINUS,ELSE,RPAREN,COMMA,GREATER,GREATEREQ,EQ,NEQ,LESS,EOF, }
  (50) CompExpr --> CompExpr GREATEREQ PlusExpr .  { COMMA,ELSE,LESSEQ,NEQ,SEMICOLON,RCURLYB,IN,GREATEREQ,RSQUAREB,LESS,RPAREN,OR,EOF,GREATER,THEN,AND,EQ,DO, }
  (53) PlusExpr --> PlusExpr .CARET TimesExpr  { DO,GREATER,RPAREN,EOF,PLUS,NEQ,ELSE,AND,CARET,SEMICOLON,IN,THEN,GREATEREQ,OR,RSQUAREB,LESS,EQ,RCURLYB,COMMA,LESSEQ,MINUS, }
state 87:
  (48) CompExpr --> CompExpr GREATER PlusExpr .  { DO,AND,RCURLYB,LESSEQ,ELSE,EOF,NEQ,SEMICOLON,EQ,LESS,COMMA,RSQUAREB,GREATER,GREATEREQ,OR,RPAREN,IN,THEN, }
  (53) PlusExpr --> PlusExpr .CARET TimesExpr  { EQ,IN,SEMICOLON,ELSE,DO,CARET,GREATEREQ,RPAREN,NEQ,OR,MINUS,EOF,RCURLYB,LESSEQ,AND,GREATER,RSQUAREB,PLUS,COMMA,THEN,LESS, }
  (52) PlusExpr --> PlusExpr .MINUS TimesExpr  { GREATEREQ,GREATER,IN,RPAREN,RSQUAREB,COMMA,AND,LESS,EOF,OR,THEN,MINUS,EQ,SEMICOLON,RCURLYB,CARET,NEQ,LESSEQ,PLUS,ELSE,DO, }
  (51) PlusExpr --> PlusExpr .PLUS TimesExpr  { RPAREN,NEQ,LESSEQ,LESS,MINUS,OR,DO,EOF,EQ,RCURLYB,PLUS,THEN,COMMA,RSQUAREB,GREATEREQ,SEMICOLON,ELSE,CARET,IN,GREATER,AND, }
state 88:
  (55) TimesExpr --> TimesExpr DIV UnaryExpr .  { NEQ,GREATEREQ,DIV,EQ,DO,SEMICOLON,LESSEQ,AND,EOF,GREATER,PLUS,MINUS,CARET,TIMES,RPAREN,RSQUAREB,LESS,OR,MOD,THEN,RCURLYB,IN,ELSE,COMMA, }
state 89:
  (54) TimesExpr --> TimesExpr TIMES UnaryExpr .  { NEQ,IN,GREATEREQ,GREATER,OR,DIV,DO,RPAREN,RSQUAREB,RCURLYB,LESSEQ,AND,TIMES,PLUS,LESS,ELSE,EQ,CARET,MINUS,EOF,COMMA,SEMICOLON,MOD,THEN, }
state 90:
  (56) TimesExpr --> TimesExpr MOD UnaryExpr .  { CARET,DO,GREATER,THEN,EOF,IN,RCURLYB,GREATEREQ,MOD,ELSE,COMMA,PLUS,RPAREN,LESSEQ,DIV,RSQUAREB,TIMES,LESS,MINUS,OR,SEMICOLON,NEQ,EQ,AND, }
state 91:
  (62) RValue --> RValue LSQUAREB Expr .RSQUAREB  { RPAREN,DIV,COMMA,EQ,MINUS,RSQUAREB,GREATEREQ,RCURLYB,OR,LSQUAREB,LPAREN,PLUS,DO,LESSEQ,IN,MOD,ELSE,AND,CARET,THEN,GREATER,SEMICOLON,TIMES,LESS,EOF,NEQ, }
state 92:
  (61) RValue --> RValue LPAREN ArgList .RPAREN  { NEQ,IN,GREATEREQ,MINUS,TIMES,GREATER,THEN,RPAREN,LESS,ELSE,PLUS,LPAREN,CARET,DIV,LSQUAREB,LESSEQ,MOD,RSQUAREB,COMMA,RCURLYB,DO,SEMICOLON,AND,EOF,EQ,OR, }
state 93:
  (65) ArgList --> Expr .COMMA ArgList  { RSQUAREB,RPAREN, }
  (64) ArgList --> Expr .  { RSQUAREB,RPAREN, }
state 94:
  (48) CompExpr --> CompExpr .GREATER PlusExpr  { RPAREN,LESS,AND,DO,IN,THEN,EOF,ELSE,COMMA,GREATEREQ,LESSEQ,SEMICOLON,RSQUAREB,RCURLYB,EQ,OR,NEQ,GREATER, }
  (45) EqExpr --> EqExpr EQ CompExpr .  { EOF,IN,NEQ,AND,RCURLYB,SEMICOLON,THEN,DO,RSQUAREB,OR,EQ,COMMA,RPAREN,ELSE, }
  (49) CompExpr --> CompExpr .LESSEQ PlusExpr  { RCURLYB,RPAREN,GREATER,DO,COMMA,RSQUAREB,EQ,IN,LESS,NEQ,EOF,AND,SEMICOLON,GREATEREQ,OR,THEN,LESSEQ,ELSE, }
  (47) CompExpr --> CompExpr .LESS PlusExpr  { GREATEREQ,OR,LESS,IN,COMMA,AND,RSQUAREB,RCURLYB,EQ,LESSEQ,DO,RPAREN,SEMICOLON,ELSE,NEQ,GREATER,THEN,EOF, }
  (50) CompExpr --> CompExpr .GREATEREQ PlusExpr  { IN,LESS,RCURLYB,DO,GREATEREQ,SEMICOLON,ELSE,OR,RPAREN,COMMA,EQ,EOF,NEQ,RSQUAREB,LESSEQ,THEN,AND,GREATER, }
state 95:
  (46) EqExpr --> EqExpr NEQ CompExpr .  { RPAREN,RCURLYB,DO,THEN,RSQUAREB,SEMICOLON,EQ,IN,ELSE,OR,AND,COMMA,EOF,NEQ, }
  (49) CompExpr --> CompExpr .LESSEQ PlusExpr  { LESSEQ,GREATER,DO,AND,OR,LESS,RPAREN,GREATEREQ,ELSE,NEQ,SEMICOLON,EOF,RCURLYB,RSQUAREB,COMMA,EQ,THEN,IN, }
  (47) CompExpr --> CompExpr .LESS PlusExpr  { COMMA,AND,DO,ELSE,OR,IN,NEQ,RSQUAREB,RPAREN,GREATEREQ,SEMICOLON,EOF,THEN,GREATER,LESSEQ,RCURLYB,LESS,EQ, }
  (48) CompExpr --> CompExpr .GREATER PlusExpr  { RPAREN,NEQ,EQ,SEMICOLON,GREATEREQ,IN,LESS,DO,AND,ELSE,OR,COMMA,LESSEQ,THEN,GREATER,EOF,RCURLYB,RSQUAREB, }
  (50) CompExpr --> CompExpr .GREATEREQ PlusExpr  { EOF,THEN,AND,OR,RSQUAREB,IN,NEQ,LESSEQ,EQ,COMMA,DO,RCURLYB,GREATEREQ,ELSE,GREATER,RPAREN,LESS,SEMICOLON, }
state 96:
  (46) EqExpr --> EqExpr .NEQ CompExpr  { RCURLYB,ELSE,IN,RPAREN,THEN,EOF,NEQ,RSQUAREB,COMMA,OR,AND,SEMICOLON,DO,EQ, }
  (45) EqExpr --> EqExpr .EQ CompExpr  { NEQ,DO,EOF,RCURLYB,OR,RPAREN,COMMA,THEN,SEMICOLON,IN,ELSE,EQ,RSQUAREB,AND, }
  (44) AndExpr --> AndExpr AND EqExpr .  { IN,COMMA,OR,EOF,THEN,SEMICOLON,RSQUAREB,RCURLYB,DO,ELSE,AND,RPAREN, }
state 97:
  (25) LValue --> LValue LSQUAREB Expr .RSQUAREB  { EQ,LSQUAREB,NEQ,RSQUAREB,TIMES,AND,ELSE,DO,DIV,GREATER,COMMA,MINUS,CARET,GREATEREQ,OR,LESSEQ,RCURLYB,THEN,IN,MOD,SEMICOLON,LPAREN,PLUS,RPAREN,ASSIGN,EOF,LESS, }
state 98:
  (60) RValue --> LValue LPAREN ArgList .RPAREN  { DO,LESS,EOF,OR,GREATEREQ,CARET,DIV,EQ,MINUS,THEN,ELSE,LESSEQ,MOD,IN,PLUS,LSQUAREB,LPAREN,TIMES,COMMA,NEQ,GREATER,AND,RCURLYB,RPAREN,RSQUAREB,SEMICOLON, }
state 99:
  (23) NonBlockExpr --> LValue ASSIGN Expr .  { ELSE,SEMICOLON,EOF,COMMA,IN,THEN,RCURLYB,DO,RPAREN,RSQUAREB, }
state 100:
  (52) PlusExpr --> PlusExpr MINUS TimesExpr .  { DO,LESSEQ,IN,ELSE,CARET,COMMA,SEMICOLON,PLUS,AND,LESS,EQ,NEQ,GREATER,MINUS,EOF,GREATEREQ,RPAREN,THEN,OR,RCURLYB,RSQUAREB, }
  (55) TimesExpr --> TimesExpr .DIV UnaryExpr  { TIMES,GREATER,IN,AND,OR,GREATEREQ,LESSEQ,DO,ELSE,RSQUAREB,PLUS,LESS,COMMA,NEQ,MOD,RCURLYB,SEMICOLON,THEN,RPAREN,EOF,DIV,CARET,MINUS,EQ, }
  (54) TimesExpr --> TimesExpr .TIMES UnaryExpr  { GREATER,LESSEQ,DO,CARET,PLUS,TIMES,EQ,ELSE,EOF,THEN,IN,GREATEREQ,RCURLYB,OR,AND,MINUS,MOD,LESS,DIV,RPAREN,COMMA,NEQ,SEMICOLON,RSQUAREB, }
  (56) TimesExpr --> TimesExpr .MOD UnaryExpr  { GREATEREQ,EQ,DO,GREATER,SEMICOLON,RSQUAREB,DIV,MINUS,ELSE,OR,AND,RPAREN,IN,LESS,TIMES,LESSEQ,CARET,THEN,PLUS,COMMA,NEQ,RCURLYB,MOD,EOF, }
state 101:
  (51) PlusExpr --> PlusExpr PLUS TimesExpr .  { RSQUAREB,DO,EOF,LESSEQ,SEMICOLON,EQ,AND,COMMA,RCURLYB,PLUS,GREATER,ELSE,NEQ,THEN,CARET,MINUS,LESS,OR,RPAREN,IN,GREATEREQ, }
  (56) TimesExpr --> TimesExpr .MOD UnaryExpr  { EQ,SEMICOLON,PLUS,IN,LESS,LESSEQ,RSQUAREB,AND,MINUS,EOF,ELSE,CARET,GREATER,NEQ,COMMA,DIV,OR,GREATEREQ,THEN,TIMES,DO,MOD,RPAREN,RCURLYB, }
  (54) TimesExpr --> TimesExpr .TIMES UnaryExpr  { MOD,SEMICOLON,DO,PLUS,AND,IN,EQ,OR,GREATEREQ,RCURLYB,LESS,GREATER,TIMES,THEN,RSQUAREB,NEQ,EOF,MINUS,COMMA,ELSE,RPAREN,LESSEQ,CARET,DIV, }
  (55) TimesExpr --> TimesExpr .DIV UnaryExpr  { SEMICOLON,DIV,IN,OR,MINUS,CARET,LESS,PLUS,RSQUAREB,EQ,TIMES,RPAREN,RCURLYB,THEN,GREATER,GREATEREQ,AND,NEQ,EOF,DO,LESSEQ,MOD,COMMA,ELSE, }
state 102:
  (55) TimesExpr --> TimesExpr .DIV UnaryExpr  { RSQUAREB,RCURLYB,MOD,LESS,EOF,OR,LESSEQ,AND,THEN,DIV,GREATEREQ,COMMA,DO,NEQ,GREATER,ELSE,TIMES,SEMICOLON,EQ,RPAREN,MINUS,PLUS,IN,CARET, }
  (56) TimesExpr --> TimesExpr .MOD UnaryExpr  { LESSEQ,EOF,GREATEREQ,RPAREN,GREATER,LESS,SEMICOLON,CARET,ELSE,RSQUAREB,DO,THEN,DIV,MOD,EQ,RCURLYB,AND,IN,PLUS,NEQ,MINUS,TIMES,OR,COMMA, }
  (53) PlusExpr --> PlusExpr CARET TimesExpr .  { EQ,OR,GREATEREQ,LESSEQ,AND,IN,ELSE,NEQ,RSQUAREB,THEN,LESS,RCURLYB,EOF,MINUS,SEMICOLON,CARET,COMMA,GREATER,DO,RPAREN,PLUS, }
  (54) TimesExpr --> TimesExpr .TIMES UnaryExpr  { MOD,RCURLYB,DIV,EQ,MINUS,NEQ,COMMA,RSQUAREB,EOF,THEN,TIMES,LESSEQ,GREATER,OR,IN,RPAREN,CARET,DO,ELSE,SEMICOLON,GREATEREQ,LESS,AND,PLUS, }
state 103:
  (42) RValue --> LPAREN Expr RPAREN .  { EQ,LESS,LSQUAREB,IN,DO,AND,CARET,RPAREN,NEQ,COMMA,PLUS,LESSEQ,THEN,SEMICOLON,ELSE,GREATER,DIV,RCURLYB,OR,LPAREN,RSQUAREB,MOD,GREATEREQ,EOF,MINUS,TIMES, }
state 104:
  (32) ReturnType --> .Type  { LAMBDA, }
  (34) OrExpr --> .AndExpr  { ELSE,OR, }
  (31) ReturnType --> .T_VOID  { LAMBDA, }
  (57) UnaryExpr --> .NOT UnaryExpr  { LESSEQ,TIMES,MINUS,AND,GREATEREQ,CARET,GREATER,DIV,NEQ,MOD,OR,ELSE,LESS,PLUS,EQ, }
  (24) LValue --> .Var  { MOD,MINUS,AND,OR,LSQUAREB,PLUS,NEQ,GREATEREQ,ASSIGN,LPAREN,ELSE,LESS,DIV,TIMES,CARET,GREATER,LESSEQ,EQ, }
  (52) PlusExpr --> .PlusExpr MINUS TimesExpr  { PLUS,AND,ELSE,NEQ,OR,CARET,GREATER,LESS,MINUS,GREATEREQ,EQ,LESSEQ, }
  (33) NonBlockExpr --> .OrExpr  { ELSE, }
  (17) BlockExpr --> IF Expr THEN .Expr ELSE BlockExpr  { DO,T_STRING,NEGATE,IN,RCURLYB,WHILE,SEMICOLON,ELSE,PRINT,THEN,NOT,Integer,LCURLYB,DEFINE,LAMBDA,IF,T_VOID,T_FLOAT,EOF,T_INT,COMMA,RSQUAREB,LPAREN,Float,LSQUAREB,LET,StringLit,Var,RPAREN, }
  (17) BlockExpr --> .IF Expr THEN Expr ELSE BlockExpr  { ELSE, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { AND,LESS,LESSEQ,GREATEREQ,GREATER,MINUS,OR,LPAREN,ELSE,EQ,NEQ,MOD,CARET,DIV,TIMES,LSQUAREB,PLUS, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { PLUS,LESSEQ,CARET,OR,NEQ,GREATER,LESS,ELSE,DIV,MOD,GREATEREQ,TIMES,AND,EQ,MINUS, }
  (43) OrExpr --> .OrExpr OR AndExpr  { OR,ELSE, }
  (45) EqExpr --> .EqExpr EQ CompExpr  { ELSE,EQ,OR,NEQ,AND, }
  (8) Expr --> .NonBlockExpr  { ELSE, }
  (38) PlusExpr --> .TimesExpr  { PLUS,AND,LESSEQ,CARET,GREATER,OR,MINUS,EQ,NEQ,GREATEREQ,LESS,ELSE, }
  (56) TimesExpr --> .TimesExpr MOD UnaryExpr  { GREATEREQ,TIMES,MOD,OR,LESSEQ,ELSE,DIV,NEQ,LESS,MINUS,PLUS,GREATER,CARET,EQ,AND, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { LESSEQ,AND,CARET,MINUS,PLUS,GREATEREQ,NEQ,GREATER,LPAREN,DIV,ELSE,EQ,TIMES,LESS,LSQUAREB,MOD,OR, }
  (51) PlusExpr --> .PlusExpr PLUS TimesExpr  { MINUS,LESSEQ,PLUS,AND,ELSE,OR,CARET,LESS,EQ,NEQ,GREATER,GREATEREQ, }
  (26) NonBlockExpr --> .LAMBDA ParamList DOT Expr  { ELSE, }
  (48) CompExpr --> .CompExpr GREATER PlusExpr  { ELSE,EQ,GREATER,GREATEREQ,NEQ,LESS,AND,LESSEQ,OR, }
  (27) NonBlockExpr --> .ReturnType LAMBDA ParamList DOT Expr  { ELSE, }
  (39) TimesExpr --> .UnaryExpr  { CARET,NEQ,OR,EQ,TIMES,LESSEQ,GREATER,GREATEREQ,LESS,ELSE,PLUS,AND,MOD,DIV,MINUS, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { MINUS,NEQ,EQ,LPAREN,AND,GREATEREQ,MOD,LSQUAREB,LESSEQ,CARET,GREATER,PLUS,LESS,TIMES,DIV,ELSE,OR, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { OR,DIV,PLUS,GREATER,CARET,GREATEREQ,TIMES,MOD,AND,LESSEQ,NEQ,MINUS,EQ,LESS,ELSE, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { AND,ASSIGN,DIV,OR,LESS,LESSEQ,NEQ,CARET,ELSE,TIMES,LSQUAREB,GREATEREQ,PLUS,MINUS,MOD,LPAREN,EQ,GREATER, }
  (74) Type --> .Type LSQUAREB RSQUAREB  { LAMBDA,LSQUAREB, }
  (66) RValue --> .Integer  { EQ,LSQUAREB,DIV,GREATEREQ,ELSE,LESS,MINUS,LPAREN,AND,NEQ,OR,TIMES,LESSEQ,CARET,PLUS,GREATER,MOD, }
  (47) CompExpr --> .CompExpr LESS PlusExpr  { EQ,LESSEQ,NEQ,ELSE,LESS,GREATEREQ,AND,GREATER,OR, }
  (18) BlockExpr --> .WHILE Expr DO BlockExpr  { ELSE, }
  (35) AndExpr --> .EqExpr  { OR,ELSE,AND, }
  (71) Type --> .T_INT  { LSQUAREB,LAMBDA, }
  (50) CompExpr --> .CompExpr GREATEREQ PlusExpr  { GREATEREQ,ELSE,LESSEQ,NEQ,AND,LESS,EQ,OR,GREATER, }
  (46) EqExpr --> .EqExpr NEQ CompExpr  { ELSE,AND,EQ,NEQ,OR, }
  (73) Type --> .T_STRING  { LAMBDA,LSQUAREB, }
  (23) NonBlockExpr --> .LValue ASSIGN Expr  { ELSE, }
  (7) Expr --> .BlockExpr  { ELSE, }
  (20) NonBlockExpr --> IF Expr THEN .Expr ELSE NonBlockExpr  { EOF,THEN,RPAREN,RSQUAREB,COMMA,ELSE,DO,RCURLYB,SEMICOLON,IN, }
  (53) PlusExpr --> .PlusExpr CARET TimesExpr  { LESS,GREATER,LESSEQ,GREATEREQ,ELSE,OR,MINUS,EQ,AND,NEQ,PLUS,CARET, }
  (44) AndExpr --> .AndExpr AND EqExpr  { AND,ELSE,OR, }
  (54) TimesExpr --> .TimesExpr TIMES UnaryExpr  { MOD,ELSE,LESSEQ,AND,GREATER,GREATEREQ,TIMES,DIV,OR,LESS,MINUS,NEQ,CARET,PLUS,EQ, }
  (72) Type --> .T_FLOAT  { LAMBDA,LSQUAREB, }
  (68) RValue --> .StringLit  { LPAREN,EQ,LSQUAREB,TIMES,GREATEREQ,ELSE,LESSEQ,AND,PLUS,LESS,DIV,CARET,MINUS,NEQ,OR,MOD,GREATER, }
  (67) RValue --> .Float  { MINUS,LESS,AND,LESSEQ,TIMES,DIV,LSQUAREB,EQ,LPAREN,OR,GREATEREQ,CARET,MOD,ELSE,NEQ,GREATER,PLUS, }
  (6) BlockStmt --> .LCURLYB Stmts RCURLYB  { ELSE, }
  (42) RValue --> .LPAREN Expr RPAREN  { OR,TIMES,LESS,EQ,DIV,LPAREN,LSQUAREB,GREATER,GREATEREQ,ELSE,LESSEQ,AND,PLUS,MOD,CARET,MINUS,NEQ, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { AND,MINUS,PLUS,GREATEREQ,MOD,EQ,CARET,GREATER,LESS,DIV,ELSE,OR,LPAREN,TIMES,LESSEQ,LSQUAREB,NEQ, }
  (37) CompExpr --> .PlusExpr  { ELSE,NEQ,EQ,LESSEQ,AND,LESS,GREATER,GREATEREQ,OR, }
  (49) CompExpr --> .CompExpr LESSEQ PlusExpr  { NEQ,GREATER,OR,ELSE,LESSEQ,LESS,GREATEREQ,EQ,AND, }
  (16) BlockExpr --> .BlockStmt  { ELSE, }
  (19) BlockExpr --> .LET Param ASSIGN Expr IN BlockExpr  { ELSE, }
  (36) EqExpr --> .CompExpr  { EQ,NEQ,AND,ELSE,OR, }
  (20) NonBlockExpr --> .IF Expr THEN Expr ELSE NonBlockExpr  { ELSE, }
  (55) TimesExpr --> .TimesExpr DIV UnaryExpr  { ELSE,CARET,DIV,MINUS,AND,GREATEREQ,EQ,NEQ,LESS,TIMES,LESSEQ,GREATER,OR,MOD,PLUS, }
  (22) NonBlockExpr --> .LET Param ASSIGN Expr IN NonBlockExpr  { ELSE, }
  (41) UnaryExpr --> .RValue  { LESSEQ,EQ,PLUS,ELSE,MINUS,TIMES,MOD,GREATEREQ,OR,DIV,AND,NEQ,CARET,GREATER,LESS, }
  (21) NonBlockExpr --> .WHILE Expr DO NonBlockExpr  { ELSE, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { NEQ,MINUS,TIMES,ELSE,GREATER,EQ,LSQUAREB,LESS,LESSEQ,AND,DIV,LPAREN,OR,GREATEREQ,MOD,CARET,PLUS, }
  (40) UnaryExpr --> .LValue  { LESS,TIMES,ELSE,DIV,GREATER,AND,LESSEQ,MOD,CARET,OR,PLUS,GREATEREQ,EQ,NEQ,MINUS, }
state 105:
  (67) RValue --> .Float  { EQ,RSQUAREB,AND,OR,LESSEQ,PLUS,GREATER,CARET,GREATEREQ,LESS,MINUS,DIV,NEQ,TIMES,LPAREN,LSQUAREB,MOD, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { EQ,OR,TIMES,LESS,MOD,GREATER,LSQUAREB,LPAREN,AND,CARET,GREATEREQ,PLUS,LESSEQ,NEQ,RSQUAREB,MINUS,DIV, }
  (66) RValue --> .Integer  { DIV,GREATER,RSQUAREB,LESS,LSQUAREB,LESSEQ,AND,GREATEREQ,MOD,MINUS,PLUS,EQ,OR,LPAREN,CARET,NEQ,TIMES, }
  (53) PlusExpr --> .PlusExpr CARET TimesExpr  { OR,RSQUAREB,LESSEQ,LESS,PLUS,EQ,NEQ,GREATEREQ,MINUS,GREATER,CARET,AND, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { TIMES,LPAREN,GREATEREQ,CARET,DIV,LESSEQ,EQ,LESS,RSQUAREB,MINUS,MOD,OR,LSQUAREB,PLUS,AND,GREATER,NEQ, }
  (72) Type --> .T_FLOAT  { LSQUAREB,LAMBDA, }
  (34) OrExpr --> .AndExpr  { OR,RSQUAREB, }
  (71) Type --> .T_INT  { LAMBDA,LSQUAREB, }
  (43) OrExpr --> .OrExpr OR AndExpr  { OR,RSQUAREB, }
  (55) TimesExpr --> .TimesExpr DIV UnaryExpr  { AND,LESS,RSQUAREB,TIMES,NEQ,GREATER,GREATEREQ,MINUS,LESSEQ,PLUS,EQ,MOD,CARET,OR,DIV, }
  (31) ReturnType --> .T_VOID  { LAMBDA, }
  (52) PlusExpr --> .PlusExpr MINUS TimesExpr  { EQ,RSQUAREB,GREATER,LESS,NEQ,MINUS,CARET,PLUS,OR,LESSEQ,GREATEREQ,AND, }
  (47) CompExpr --> .CompExpr LESS PlusExpr  { AND,EQ,GREATER,OR,NEQ,GREATEREQ,LESS,LESSEQ,RSQUAREB, }
  (32) ReturnType --> .Type  { LAMBDA, }
  (39) TimesExpr --> .UnaryExpr  { EQ,GREATER,MINUS,MOD,NEQ,DIV,CARET,TIMES,AND,LESS,PLUS,RSQUAREB,OR,LESSEQ,GREATEREQ, }
  (6) BlockStmt --> .LCURLYB Stmts RCURLYB  { RSQUAREB, }
  (73) Type --> .T_STRING  { LSQUAREB,LAMBDA, }
  (68) RValue --> .StringLit  { LPAREN,MINUS,PLUS,AND,LESS,NEQ,MOD,EQ,LESSEQ,OR,GREATEREQ,TIMES,RSQUAREB,GREATER,DIV,CARET,LSQUAREB, }
  (22) NonBlockExpr --> .LET Param ASSIGN Expr IN NonBlockExpr  { RSQUAREB, }
  (44) AndExpr --> .AndExpr AND EqExpr  { AND,RSQUAREB,OR, }
  (21) NonBlockExpr --> .WHILE Expr DO NonBlockExpr  { RSQUAREB, }
  (23) NonBlockExpr --> .LValue ASSIGN Expr  { RSQUAREB, }
  (70) RValue --> LSQUAREB Expr SEMICOLON .Expr RSQUAREB  { RCURLYB,SEMICOLON,GREATER,EOF,AND,ELSE,GREATEREQ,TIMES,RPAREN,LESSEQ,THEN,EQ,NEQ,OR,LESS,RSQUAREB,MOD,IN,MINUS,DO,COMMA,LPAREN,PLUS,DIV,CARET,LSQUAREB, }
  (46) EqExpr --> .EqExpr NEQ CompExpr  { RSQUAREB,NEQ,EQ,AND,OR, }
  (8) Expr --> .NonBlockExpr  { RSQUAREB, }
  (45) EqExpr --> .EqExpr EQ CompExpr  { OR,AND,RSQUAREB,NEQ,EQ, }
  (56) TimesExpr --> .TimesExpr MOD UnaryExpr  { LESSEQ,MINUS,GREATER,RSQUAREB,GREATEREQ,DIV,LESS,EQ,TIMES,OR,NEQ,CARET,MOD,AND,PLUS, }
  (37) CompExpr --> .PlusExpr  { LESS,OR,LESSEQ,EQ,GREATEREQ,GREATER,RSQUAREB,AND,NEQ, }
  (36) EqExpr --> .CompExpr  { NEQ,EQ,RSQUAREB,OR,AND, }
  (35) AndExpr --> .EqExpr  { AND,RSQUAREB,OR, }
  (74) Type --> .Type LSQUAREB RSQUAREB  { LSQUAREB,LAMBDA, }
  (19) BlockExpr --> .LET Param ASSIGN Expr IN BlockExpr  { RSQUAREB, }
  (42) RValue --> .LPAREN Expr RPAREN  { NEQ,TIMES,PLUS,GREATER,DIV,LESSEQ,MINUS,LPAREN,LESS,AND,EQ,RSQUAREB,GREATEREQ,OR,MOD,CARET,LSQUAREB, }
  (54) TimesExpr --> .TimesExpr TIMES UnaryExpr  { LESSEQ,DIV,GREATER,LESS,OR,TIMES,CARET,RSQUAREB,EQ,MOD,GREATEREQ,AND,PLUS,MINUS,NEQ, }
  (26) NonBlockExpr --> .LAMBDA ParamList DOT Expr  { RSQUAREB, }
  (40) UnaryExpr --> .LValue  { RSQUAREB,LESSEQ,LESS,EQ,GREATEREQ,AND,DIV,NEQ,OR,TIMES,MINUS,CARET,PLUS,GREATER,MOD, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { LPAREN,OR,MINUS,AND,GREATER,RSQUAREB,DIV,MOD,LSQUAREB,TIMES,PLUS,LESS,GREATEREQ,CARET,ASSIGN,LESSEQ,EQ,NEQ, }
  (41) UnaryExpr --> .RValue  { PLUS,NEQ,LESSEQ,RSQUAREB,DIV,MOD,GREATEREQ,TIMES,MINUS,LESS,GREATER,OR,EQ,AND,CARET, }
  (27) NonBlockExpr --> .ReturnType LAMBDA ParamList DOT Expr  { RSQUAREB, }
  (17) BlockExpr --> .IF Expr THEN Expr ELSE BlockExpr  { RSQUAREB, }
  (48) CompExpr --> .CompExpr GREATER PlusExpr  { GREATER,LESS,GREATEREQ,RSQUAREB,AND,LESSEQ,OR,EQ,NEQ, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { PLUS,GREATEREQ,GREATER,DIV,NEQ,LESSEQ,OR,TIMES,RSQUAREB,LSQUAREB,AND,MOD,MINUS,LPAREN,LESS,CARET,EQ, }
  (24) LValue --> .Var  { LPAREN,AND,OR,CARET,LESSEQ,GREATER,MINUS,TIMES,MOD,LSQUAREB,EQ,RSQUAREB,ASSIGN,LESS,PLUS,DIV,NEQ,GREATEREQ, }
  (33) NonBlockExpr --> .OrExpr  { RSQUAREB, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { TIMES,NEQ,OR,DIV,EQ,LESS,PLUS,LESSEQ,AND,GREATER,GREATEREQ,MOD,RSQUAREB,CARET,MINUS, }
  (16) BlockExpr --> .BlockStmt  { RSQUAREB, }
  (20) NonBlockExpr --> .IF Expr THEN Expr ELSE NonBlockExpr  { RSQUAREB, }
  (38) PlusExpr --> .TimesExpr  { NEQ,AND,LESSEQ,EQ,MINUS,PLUS,LESS,GREATER,RSQUAREB,CARET,GREATEREQ,OR, }
  (57) UnaryExpr --> .NOT UnaryExpr  { EQ,AND,OR,GREATEREQ,TIMES,CARET,PLUS,RSQUAREB,LESS,MINUS,DIV,MOD,NEQ,LESSEQ,GREATER, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { MOD,LPAREN,EQ,GREATEREQ,LESS,LSQUAREB,LESSEQ,NEQ,DIV,PLUS,GREATER,MINUS,TIMES,AND,CARET,RSQUAREB,OR, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { PLUS,LESS,DIV,CARET,RSQUAREB,GREATEREQ,OR,LESSEQ,EQ,NEQ,MINUS,MOD,AND,TIMES,GREATER, }
  (51) PlusExpr --> .PlusExpr PLUS TimesExpr  { PLUS,CARET,LESS,OR,EQ,NEQ,RSQUAREB,AND,GREATER,LESSEQ,MINUS,GREATEREQ, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { LPAREN,LESS,PLUS,AND,OR,LESSEQ,RSQUAREB,DIV,GREATEREQ,GREATER,LSQUAREB,CARET,NEQ,MOD,MINUS,EQ,TIMES, }
  (49) CompExpr --> .CompExpr LESSEQ PlusExpr  { RSQUAREB,LESSEQ,NEQ,EQ,OR,GREATEREQ,AND,LESS,GREATER, }
  (18) BlockExpr --> .WHILE Expr DO BlockExpr  { RSQUAREB, }
  (7) Expr --> .BlockExpr  { RSQUAREB, }
  (50) CompExpr --> .CompExpr GREATEREQ PlusExpr  { LESS,NEQ,GREATER,GREATEREQ,OR,LESSEQ,AND,EQ,RSQUAREB, }
state 106:
  (33) NonBlockExpr --> .OrExpr  { RPAREN,RSQUAREB,COMMA, }
  (48) CompExpr --> .CompExpr GREATER PlusExpr  { COMMA,OR,EQ,AND,LESS,NEQ,RSQUAREB,LESSEQ,RPAREN,GREATER,GREATEREQ, }
  (71) Type --> .T_INT  { LAMBDA,LSQUAREB, }
  (47) CompExpr --> .CompExpr LESS PlusExpr  { OR,EQ,NEQ,GREATEREQ,GREATER,RSQUAREB,RPAREN,COMMA,LESSEQ,LESS,AND, }
  (63) ArgList --> .  { RSQUAREB,RPAREN, }
  (72) Type --> .T_FLOAT  { LSQUAREB,LAMBDA, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { MINUS,LESSEQ,CARET,EQ,RSQUAREB,NEQ,TIMES,MOD,GREATEREQ,COMMA,RPAREN,OR,GREATER,LESS,AND,DIV,PLUS, }
  (50) CompExpr --> .CompExpr GREATEREQ PlusExpr  { OR,RSQUAREB,NEQ,EQ,GREATER,COMMA,GREATEREQ,LESSEQ,AND,LESS,RPAREN, }
  (21) NonBlockExpr --> .WHILE Expr DO NonBlockExpr  { COMMA,RSQUAREB,RPAREN, }
  (53) PlusExpr --> .PlusExpr CARET TimesExpr  { LESS,GREATEREQ,RPAREN,PLUS,GREATER,MINUS,CARET,COMMA,OR,LESSEQ,AND,RSQUAREB,NEQ,EQ, }
  (27) NonBlockExpr --> .ReturnType LAMBDA ParamList DOT Expr  { COMMA,RSQUAREB,RPAREN, }
  (65) ArgList --> Expr COMMA .ArgList  { RSQUAREB,RPAREN, }
  (49) CompExpr --> .CompExpr LESSEQ PlusExpr  { EQ,LESSEQ,COMMA,NEQ,LESS,RSQUAREB,OR,GREATEREQ,AND,RPAREN,GREATER, }
  (51) PlusExpr --> .PlusExpr PLUS TimesExpr  { GREATER,AND,GREATEREQ,COMMA,LESSEQ,MINUS,RPAREN,NEQ,PLUS,EQ,OR,LESS,RSQUAREB,CARET, }
  (35) AndExpr --> .EqExpr  { RSQUAREB,COMMA,RPAREN,AND,OR, }
  (65) ArgList --> .Expr COMMA ArgList  { RPAREN,RSQUAREB, }
  (38) PlusExpr --> .TimesExpr  { OR,RPAREN,LESSEQ,AND,LESS,MINUS,RSQUAREB,GREATER,PLUS,GREATEREQ,COMMA,EQ,CARET,NEQ, }
  (57) UnaryExpr --> .NOT UnaryExpr  { DIV,NEQ,GREATEREQ,RPAREN,LESSEQ,AND,LESS,CARET,EQ,MINUS,MOD,TIMES,OR,COMMA,PLUS,RSQUAREB,GREATER, }
  (43) OrExpr --> .OrExpr OR AndExpr  { RSQUAREB,OR,COMMA,RPAREN, }
  (6) BlockStmt --> .LCURLYB Stmts RCURLYB  { RPAREN,RSQUAREB,COMMA, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { GREATER,CARET,LESS,RPAREN,GREATEREQ,LSQUAREB,NEQ,LESSEQ,MOD,LPAREN,DIV,PLUS,TIMES,AND,RSQUAREB,COMMA,ASSIGN,MINUS,OR,EQ, }
  (19) BlockExpr --> .LET Param ASSIGN Expr IN BlockExpr  { RSQUAREB,RPAREN,COMMA, }
  (41) UnaryExpr --> .RValue  { GREATER,AND,EQ,COMMA,LESSEQ,MINUS,MOD,RPAREN,LESS,RSQUAREB,NEQ,TIMES,PLUS,CARET,DIV,OR,GREATEREQ, }
  (24) LValue --> .Var  { EQ,LESSEQ,OR,GREATER,ASSIGN,TIMES,RPAREN,NEQ,MOD,GREATEREQ,AND,RSQUAREB,LSQUAREB,DIV,CARET,COMMA,LESS,MINUS,PLUS,LPAREN, }
  (16) BlockExpr --> .BlockStmt  { RSQUAREB,COMMA,RPAREN, }
  (8) Expr --> .NonBlockExpr  { COMMA,RSQUAREB,RPAREN, }
  (37) CompExpr --> .PlusExpr  { GREATEREQ,LESSEQ,NEQ,GREATER,OR,RSQUAREB,COMMA,AND,RPAREN,EQ,LESS, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { RPAREN,OR,TIMES,RSQUAREB,CARET,MINUS,EQ,MOD,LESSEQ,DIV,GREATER,LSQUAREB,PLUS,COMMA,AND,LPAREN,LESS,NEQ,GREATEREQ, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { AND,GREATEREQ,RSQUAREB,RPAREN,MOD,LESS,LESSEQ,DIV,CARET,TIMES,PLUS,GREATER,EQ,OR,NEQ,MINUS,COMMA, }
  (17) BlockExpr --> .IF Expr THEN Expr ELSE BlockExpr  { COMMA,RSQUAREB,RPAREN, }
  (36) EqExpr --> .CompExpr  { RSQUAREB,EQ,AND,RPAREN,NEQ,COMMA,OR, }
  (64) ArgList --> .Expr  { RPAREN,RSQUAREB, }
  (22) NonBlockExpr --> .LET Param ASSIGN Expr IN NonBlockExpr  { COMMA,RPAREN,RSQUAREB, }
  (67) RValue --> .Float  { NEQ,MOD,LSQUAREB,MINUS,LESSEQ,COMMA,GREATER,AND,GREATEREQ,LESS,RPAREN,LPAREN,CARET,PLUS,DIV,TIMES,EQ,OR,RSQUAREB, }
  (74) Type --> .Type LSQUAREB RSQUAREB  { LSQUAREB,LAMBDA, }
  (40) UnaryExpr --> .LValue  { GREATEREQ,LESSEQ,COMMA,LESS,PLUS,MOD,GREATER,EQ,RSQUAREB,RPAREN,OR,CARET,MINUS,AND,DIV,NEQ,TIMES, }
  (34) OrExpr --> .AndExpr  { COMMA,RPAREN,RSQUAREB,OR, }
  (56) TimesExpr --> .TimesExpr MOD UnaryExpr  { TIMES,OR,MINUS,LESSEQ,MOD,GREATEREQ,CARET,GREATER,PLUS,AND,LESS,NEQ,RPAREN,COMMA,EQ,RSQUAREB,DIV, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { PLUS,LESSEQ,RPAREN,MOD,DIV,LSQUAREB,COMMA,RSQUAREB,LPAREN,MINUS,NEQ,OR,TIMES,AND,LESS,EQ,GREATER,CARET,GREATEREQ, }
  (20) NonBlockExpr --> .IF Expr THEN Expr ELSE NonBlockExpr  { RSQUAREB,RPAREN,COMMA, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { LESS,RSQUAREB,OR,PLUS,TIMES,GREATER,DIV,LSQUAREB,NEQ,RPAREN,COMMA,LPAREN,GREATEREQ,EQ,MINUS,AND,LESSEQ,CARET,MOD, }
  (26) NonBlockExpr --> .LAMBDA ParamList DOT Expr  { COMMA,RPAREN,RSQUAREB, }
  (44) AndExpr --> .AndExpr AND EqExpr  { COMMA,AND,RPAREN,OR,RSQUAREB, }
  (45) EqExpr --> .EqExpr EQ CompExpr  { OR,COMMA,EQ,NEQ,RSQUAREB,AND,RPAREN, }
  (7) Expr --> .BlockExpr  { COMMA,RSQUAREB,RPAREN, }
  (31) ReturnType --> .T_VOID  { LAMBDA, }
  (18) BlockExpr --> .WHILE Expr DO BlockExpr  { COMMA,RSQUAREB,RPAREN, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { CARET,OR,MOD,RSQUAREB,LESS,GREATEREQ,COMMA,LESSEQ,NEQ,LSQUAREB,EQ,GREATER,RPAREN,PLUS,LPAREN,TIMES,AND,MINUS,DIV, }
  (68) RValue --> .StringLit  { COMMA,RPAREN,MOD,PLUS,LPAREN,CARET,LESSEQ,GREATEREQ,GREATER,TIMES,DIV,MINUS,LSQUAREB,EQ,NEQ,LESS,AND,OR,RSQUAREB, }
  (23) NonBlockExpr --> .LValue ASSIGN Expr  { RSQUAREB,COMMA,RPAREN, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { MINUS,COMMA,LSQUAREB,MOD,RPAREN,DIV,GREATER,PLUS,LESS,RSQUAREB,AND,TIMES,CARET,GREATEREQ,EQ,LESSEQ,OR,LPAREN,NEQ, }
  (32) ReturnType --> .Type  { LAMBDA, }
  (42) RValue --> .LPAREN Expr RPAREN  { GREATEREQ,MINUS,LESS,GREATER,CARET,PLUS,LESSEQ,NEQ,TIMES,MOD,OR,COMMA,LSQUAREB,AND,EQ,DIV,RPAREN,RSQUAREB,LPAREN, }
  (73) Type --> .T_STRING  { LSQUAREB,LAMBDA, }
  (66) RValue --> .Integer  { RSQUAREB,COMMA,LSQUAREB,GREATER,DIV,NEQ,OR,CARET,LESSEQ,EQ,LESS,RPAREN,AND,MINUS,LPAREN,GREATEREQ,MOD,TIMES,PLUS, }
  (46) EqExpr --> .EqExpr NEQ CompExpr  { RPAREN,NEQ,COMMA,EQ,AND,OR,RSQUAREB, }
  (54) TimesExpr --> .TimesExpr TIMES UnaryExpr  { TIMES,AND,EQ,LESSEQ,NEQ,COMMA,OR,DIV,GREATEREQ,LESS,MOD,CARET,MINUS,RSQUAREB,PLUS,GREATER,RPAREN, }
  (52) PlusExpr --> .PlusExpr MINUS TimesExpr  { EQ,RSQUAREB,NEQ,RPAREN,PLUS,COMMA,LESS,LESSEQ,GREATEREQ,AND,OR,GREATER,MINUS,CARET, }
  (39) TimesExpr --> .UnaryExpr  { AND,EQ,RSQUAREB,OR,GREATEREQ,TIMES,MOD,CARET,PLUS,MINUS,DIV,RPAREN,COMMA,NEQ,GREATER,LESS,LESSEQ, }
  (55) TimesExpr --> .TimesExpr DIV UnaryExpr  { EQ,NEQ,GREATER,PLUS,LESS,TIMES,MOD,COMMA,GREATEREQ,OR,RSQUAREB,LESSEQ,AND,RPAREN,MINUS,DIV,CARET, }
state 107:
  (69) RValue --> LSQUAREB ArgList RSQUAREB .  { TIMES,LESSEQ,CARET,EQ,LESS,MOD,AND,COMMA,ELSE,LPAREN,RCURLYB,LSQUAREB,DIV,NEQ,THEN,GREATEREQ,OR,SEMICOLON,GREATER,MINUS,DO,RPAREN,EOF,PLUS,IN,RSQUAREB, }
state 108:
  (6) BlockStmt --> LCURLYB Stmts RCURLYB .  { ELSE,COMMA,IF,T_FLOAT,LET,StringLit,Var,LPAREN,RPAREN,WHILE,LAMBDA,Integer,SEMICOLON,T_STRING,T_INT,RSQUAREB,Float,PRINT,IN,LCURLYB,THEN,LSQUAREB,RCURLYB,T_VOID,DO,DEFINE,NOT,EOF,NEGATE, }
state 109:
  (44) AndExpr --> AndExpr .AND EqExpr  { RCURLYB,OR,COMMA,DO,THEN,ELSE,RPAREN,AND,IN,SEMICOLON,RSQUAREB,EOF, }
  (43) OrExpr --> OrExpr OR AndExpr .  { RPAREN,DO,ELSE,OR,THEN,IN,SEMICOLON,RCURLYB,COMMA,EOF,RSQUAREB, }
state 110:
  (30) ParamList --> TypedParam COMMA .ParamList  { DOT, }
  (30) ParamList --> .TypedParam COMMA ParamList  { DOT, }
  (13) TypedParam --> .Var COLON Type  { DOT,COMMA, }
  (28) ParamList --> .  { DOT, }
  (29) ParamList --> .TypedParam  { DOT, }
state 111:
  (23) NonBlockExpr --> .LValue ASSIGN Expr  { DO,EOF,THEN,RCURLYB,SEMICOLON,IN,COMMA,RPAREN,ELSE,RSQUAREB, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { GREATEREQ,NEQ,TIMES,RCURLYB,CARET,LESSEQ,AND,MINUS,RSQUAREB,IN,DO,LPAREN,PLUS,EOF,THEN,GREATER,RPAREN,LSQUAREB,OR,ELSE,COMMA,MOD,EQ,DIV,SEMICOLON,LESS, }
  (38) PlusExpr --> .TimesExpr  { OR,IN,LESS,SEMICOLON,MINUS,RPAREN,NEQ,EQ,RSQUAREB,PLUS,THEN,AND,ELSE,CARET,LESSEQ,DO,EOF,COMMA,GREATEREQ,RCURLYB,GREATER, }
  (73) Type --> .T_STRING  { LAMBDA,LSQUAREB, }
  (35) AndExpr --> .EqExpr  { THEN,RPAREN,OR,RSQUAREB,RCURLYB,SEMICOLON,EOF,COMMA,IN,DO,ELSE,AND, }
  (46) EqExpr --> .EqExpr NEQ CompExpr  { ELSE,EQ,NEQ,RPAREN,SEMICOLON,RSQUAREB,EOF,THEN,OR,DO,AND,RCURLYB,COMMA,IN, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { THEN,ELSE,EQ,GREATEREQ,IN,DIV,TIMES,LPAREN,RSQUAREB,SEMICOLON,LESS,OR,LSQUAREB,AND,RPAREN,NEQ,LESSEQ,GREATER,DO,PLUS,EOF,MOD,MINUS,CARET,COMMA,RCURLYB, }
  (66) RValue --> .Integer  { DIV,IN,RPAREN,COMMA,LPAREN,RCURLYB,MINUS,RSQUAREB,OR,EQ,SEMICOLON,LESSEQ,AND,TIMES,PLUS,NEQ,MOD,ELSE,CARET,THEN,GREATEREQ,LESS,DO,LSQUAREB,EOF,GREATER, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { GREATEREQ,TIMES,EOF,OR,DO,NEQ,EQ,RPAREN,SEMICOLON,AND,CARET,RSQUAREB,RCURLYB,LESSEQ,THEN,IN,ELSE,PLUS,MOD,COMMA,GREATER,MINUS,DIV,LESS, }
  (67) RValue --> .Float  { OR,ELSE,LSQUAREB,GREATER,LPAREN,EOF,COMMA,LESSEQ,NEQ,RCURLYB,DO,TIMES,LESS,DIV,GREATEREQ,IN,CARET,RSQUAREB,THEN,EQ,MOD,AND,PLUS,RPAREN,MINUS,SEMICOLON, }
  (54) TimesExpr --> .TimesExpr TIMES UnaryExpr  { AND,CARET,THEN,LESS,DO,MOD,GREATEREQ,DIV,ELSE,OR,RPAREN,TIMES,RCURLYB,NEQ,IN,EQ,RSQUAREB,GREATER,EOF,COMMA,MINUS,PLUS,SEMICOLON,LESSEQ, }
  (17) BlockExpr --> .IF Expr THEN Expr ELSE BlockExpr  { RCURLYB,EOF,COMMA,ELSE,RSQUAREB,RPAREN,THEN,SEMICOLON,IN,DO, }
  (55) TimesExpr --> .TimesExpr DIV UnaryExpr  { PLUS,RPAREN,LESSEQ,MOD,DO,GREATER,COMMA,OR,LESS,DIV,EOF,TIMES,SEMICOLON,THEN,AND,EQ,NEQ,ELSE,RSQUAREB,GREATEREQ,IN,RCURLYB,MINUS,CARET, }
  (27) NonBlockExpr --> .ReturnType LAMBDA ParamList DOT Expr  { RSQUAREB,RPAREN,COMMA,ELSE,SEMICOLON,EOF,DO,IN,RCURLYB,THEN, }
  (37) CompExpr --> .PlusExpr  { GREATER,ELSE,SEMICOLON,RCURLYB,AND,RSQUAREB,COMMA,EQ,RPAREN,NEQ,LESSEQ,OR,DO,EOF,THEN,IN,GREATEREQ,LESS, }
  (33) NonBlockExpr --> .OrExpr  { THEN,EOF,RSQUAREB,COMMA,SEMICOLON,RCURLYB,IN,DO,RPAREN,ELSE, }
  (22) NonBlockExpr --> .LET Param ASSIGN Expr IN NonBlockExpr  { RSQUAREB,RCURLYB,COMMA,ELSE,EOF,IN,RPAREN,DO,THEN,SEMICOLON, }
  (8) Expr --> .NonBlockExpr  { COMMA,IN,DO,ELSE,SEMICOLON,RSQUAREB,THEN,RPAREN,RCURLYB,EOF, }
  (18) BlockExpr --> .WHILE Expr DO BlockExpr  { COMMA,ELSE,SEMICOLON,IN,DO,RCURLYB,THEN,RSQUAREB,EOF,RPAREN, }
  (41) UnaryExpr --> .RValue  { CARET,LESS,DO,DIV,EOF,OR,PLUS,GREATEREQ,IN,NEQ,EQ,TIMES,MOD,MINUS,RPAREN,LESSEQ,SEMICOLON,RCURLYB,GREATER,COMMA,RSQUAREB,THEN,AND,ELSE, }
  (50) CompExpr --> .CompExpr GREATEREQ PlusExpr  { LESS,EQ,RSQUAREB,NEQ,AND,DO,ELSE,RPAREN,GREATEREQ,IN,SEMICOLON,EOF,LESSEQ,GREATER,THEN,OR,RCURLYB,COMMA, }
  (20) NonBlockExpr --> .IF Expr THEN Expr ELSE NonBlockExpr  { RCURLYB,DO,COMMA,ELSE,RPAREN,SEMICOLON,IN,RSQUAREB,THEN,EOF, }
  (43) OrExpr --> .OrExpr OR AndExpr  { RPAREN,EOF,IN,RSQUAREB,SEMICOLON,RCURLYB,DO,ELSE,THEN,COMMA,OR, }
  (53) PlusExpr --> .PlusExpr CARET TimesExpr  { IN,MINUS,EOF,NEQ,THEN,RSQUAREB,LESSEQ,OR,LESS,GREATEREQ,SEMICOLON,AND,DO,CARET,ELSE,EQ,GREATER,RPAREN,COMMA,PLUS,RCURLYB, }
  (6) BlockStmt --> .LCURLYB Stmts RCURLYB  { SEMICOLON,COMMA,RCURLYB,ELSE,IN,RSQUAREB,EOF,THEN,DO,RPAREN, }
  (49) CompExpr --> .CompExpr LESSEQ PlusExpr  { LESSEQ,OR,RSQUAREB,IN,RPAREN,GREATEREQ,COMMA,SEMICOLON,AND,GREATER,RCURLYB,DO,NEQ,ELSE,EOF,THEN,LESS,EQ, }
  (48) CompExpr --> .CompExpr GREATER PlusExpr  { OR,RPAREN,IN,RCURLYB,EOF,LESSEQ,LESS,COMMA,DO,GREATER,AND,EQ,RSQUAREB,ELSE,NEQ,SEMICOLON,THEN,GREATEREQ, }
  (56) TimesExpr --> .TimesExpr MOD UnaryExpr  { AND,OR,THEN,ELSE,RSQUAREB,GREATEREQ,DIV,PLUS,RCURLYB,GREATER,SEMICOLON,MOD,RPAREN,IN,EOF,TIMES,COMMA,EQ,LESS,CARET,DO,LESSEQ,MINUS,NEQ, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { RCURLYB,LPAREN,RSQUAREB,COMMA,MINUS,ASSIGN,EQ,DIV,GREATEREQ,EOF,TIMES,LSQUAREB,DO,THEN,AND,IN,MOD,OR,LESS,NEQ,PLUS,ELSE,CARET,SEMICOLON,GREATER,LESSEQ,RPAREN, }
  (19) BlockExpr --> .LET Param ASSIGN Expr IN BlockExpr  { SEMICOLON,THEN,RCURLYB,COMMA,RPAREN,EOF,RSQUAREB,IN,DO,ELSE, }
  (72) Type --> .T_FLOAT  { LSQUAREB,LAMBDA, }
  (34) OrExpr --> .AndExpr  { ELSE,DO,EOF,RPAREN,IN,COMMA,RCURLYB,THEN,OR,SEMICOLON,RSQUAREB, }
  (39) TimesExpr --> .UnaryExpr  { SEMICOLON,THEN,DO,GREATEREQ,OR,ELSE,CARET,RCURLYB,TIMES,LESS,DIV,PLUS,LESSEQ,EOF,GREATER,EQ,NEQ,AND,RSQUAREB,MOD,RPAREN,IN,MINUS,COMMA, }
  (47) CompExpr --> .CompExpr LESS PlusExpr  { EOF,LESS,RCURLYB,AND,GREATER,NEQ,RPAREN,SEMICOLON,OR,IN,COMMA,DO,GREATEREQ,ELSE,LESSEQ,RSQUAREB,EQ,THEN, }
  (31) ReturnType --> .T_VOID  { LAMBDA, }
  (74) Type --> .Type LSQUAREB RSQUAREB  { LSQUAREB,LAMBDA, }
  (51) PlusExpr --> .PlusExpr PLUS TimesExpr  { CARET,RCURLYB,DO,RPAREN,EQ,EOF,SEMICOLON,GREATER,IN,OR,THEN,LESSEQ,NEQ,AND,MINUS,COMMA,LESS,PLUS,RSQUAREB,GREATEREQ,ELSE, }
  (32) ReturnType --> .Type  { LAMBDA, }
  (42) RValue --> .LPAREN Expr RPAREN  { RSQUAREB,GREATEREQ,AND,GREATER,MOD,LESSEQ,RCURLYB,PLUS,LPAREN,TIMES,SEMICOLON,LSQUAREB,CARET,DIV,ELSE,RPAREN,MINUS,EOF,IN,LESS,EQ,NEQ,THEN,COMMA,DO,OR, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { LPAREN,MOD,LSQUAREB,EQ,ELSE,EOF,MINUS,COMMA,LESS,LESSEQ,RCURLYB,THEN,GREATEREQ,OR,NEQ,GREATER,SEMICOLON,AND,CARET,IN,PLUS,RSQUAREB,TIMES,DIV,DO,RPAREN, }
  (44) AndExpr --> .AndExpr AND EqExpr  { RPAREN,ELSE,RSQUAREB,DO,AND,OR,THEN,RCURLYB,SEMICOLON,EOF,COMMA,IN, }
  (45) EqExpr --> .EqExpr EQ CompExpr  { DO,RCURLYB,THEN,ELSE,AND,OR,IN,EQ,RSQUAREB,RPAREN,COMMA,EOF,SEMICOLON,NEQ, }
  (36) EqExpr --> .CompExpr  { SEMICOLON,OR,RSQUAREB,IN,EQ,ELSE,RPAREN,EOF,DO,RCURLYB,COMMA,AND,THEN,NEQ, }
  (52) PlusExpr --> .PlusExpr MINUS TimesExpr  { PLUS,CARET,DO,SEMICOLON,THEN,AND,GREATEREQ,EQ,IN,OR,RCURLYB,ELSE,COMMA,RSQUAREB,GREATER,MINUS,EOF,RPAREN,LESS,LESSEQ,NEQ, }
  (26) NonBlockExpr --> .LAMBDA ParamList DOT Expr  { ELSE,THEN,SEMICOLON,IN,RPAREN,RSQUAREB,DO,COMMA,EOF,RCURLYB, }
  (40) UnaryExpr --> .LValue  { SEMICOLON,TIMES,LESSEQ,DIV,CARET,MINUS,RPAREN,AND,NEQ,THEN,COMMA,LESS,OR,RCURLYB,DO,RSQUAREB,MOD,ELSE,EOF,GREATEREQ,EQ,GREATER,PLUS,IN, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { RPAREN,PLUS,RCURLYB,MOD,MINUS,EOF,LESS,IN,ELSE,TIMES,DO,CARET,THEN,SEMICOLON,DIV,RSQUAREB,COMMA,GREATEREQ,NEQ,LESSEQ,GREATER,OR,AND,EQ, }
  (68) RValue --> .StringLit  { ELSE,LESSEQ,DIV,RSQUAREB,CARET,AND,NEQ,THEN,PLUS,GREATEREQ,LSQUAREB,GREATER,SEMICOLON,MOD,TIMES,RCURLYB,EOF,OR,RPAREN,DO,IN,EQ,COMMA,LPAREN,LESS,MINUS, }
  (16) BlockExpr --> .BlockStmt  { RCURLYB,ELSE,DO,EOF,RPAREN,SEMICOLON,RSQUAREB,IN,THEN,COMMA, }
  (57) UnaryExpr --> .NOT UnaryExpr  { DIV,RPAREN,AND,OR,COMMA,DO,EOF,TIMES,MINUS,SEMICOLON,GREATEREQ,CARET,EQ,LESS,RSQUAREB,NEQ,MOD,PLUS,IN,ELSE,THEN,GREATER,LESSEQ,RCURLYB, }
  (21) NonBlockExpr --> .WHILE Expr DO NonBlockExpr  { RSQUAREB,ELSE,SEMICOLON,DO,THEN,RPAREN,IN,RCURLYB,EOF,COMMA, }
  (24) LValue --> .Var  { DO,OR,AND,DIV,LPAREN,ELSE,LSQUAREB,GREATEREQ,RPAREN,PLUS,THEN,IN,RCURLYB,NEQ,LESSEQ,CARET,COMMA,ASSIGN,MINUS,SEMICOLON,TIMES,MOD,EQ,RSQUAREB,GREATER,EOF,LESS, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { LESSEQ,IN,LSQUAREB,OR,EQ,ELSE,DIV,RCURLYB,CARET,LPAREN,NEQ,SEMICOLON,LESS,PLUS,THEN,MINUS,AND,COMMA,DO,RSQUAREB,EOF,GREATER,RPAREN,GREATEREQ,MOD,TIMES, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { IN,DIV,RCURLYB,CARET,GREATER,EQ,TIMES,LESS,COMMA,LESSEQ,EOF,PLUS,ELSE,THEN,SEMICOLON,LSQUAREB,RPAREN,OR,DO,GREATEREQ,MINUS,LPAREN,MOD,NEQ,RSQUAREB,AND, }
  (26) NonBlockExpr --> LAMBDA ParamList DOT .Expr  { COMMA,THEN,RCURLYB,ELSE,RSQUAREB,RPAREN,DO,SEMICOLON,EOF,IN, }
  (71) Type --> .T_INT  { LAMBDA,LSQUAREB, }
  (7) Expr --> .BlockExpr  { EOF,THEN,SEMICOLON,DO,ELSE,RCURLYB,COMMA,RPAREN,IN,RSQUAREB, }
state 112:
  (27) NonBlockExpr --> ReturnType LAMBDA ParamList .DOT Expr  { ELSE,IN,RCURLYB,DO,RSQUAREB,EOF,SEMICOLON,COMMA,RPAREN,THEN, }
state 113:
  (74) Type --> Type LSQUAREB RSQUAREB .  { ASSIGN,COMMA,LSQUAREB,LAMBDA,DOT, }
state 114:
  (74) Type --> .Type LSQUAREB RSQUAREB  { LAMBDA,LSQUAREB, }
  (46) EqExpr --> .EqExpr NEQ CompExpr  { AND,OR,NEQ,EQ,RCURLYB,SEMICOLON,EOF, }
  (17) BlockExpr --> .IF Expr THEN Expr ELSE BlockExpr  { SEMICOLON,EOF,RCURLYB, }
  (31) ReturnType --> .T_VOID  { LAMBDA, }
  (55) TimesExpr --> .TimesExpr DIV UnaryExpr  { LESS,EOF,PLUS,RCURLYB,GREATEREQ,OR,AND,LESSEQ,EQ,SEMICOLON,TIMES,DIV,MOD,CARET,GREATER,MINUS,NEQ, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { MINUS,OR,LPAREN,TIMES,LESS,PLUS,CARET,SEMICOLON,EQ,NEQ,LSQUAREB,MOD,GREATEREQ,GREATER,EOF,LESSEQ,RCURLYB,AND,DIV, }
  (72) Type --> .T_FLOAT  { LSQUAREB,LAMBDA, }
  (24) LValue --> .Var  { LPAREN,EQ,NEQ,LSQUAREB,OR,RCURLYB,DIV,TIMES,GREATER,ASSIGN,MOD,PLUS,CARET,LESSEQ,AND,SEMICOLON,GREATEREQ,EOF,MINUS,LESS, }
  (34) OrExpr --> .AndExpr  { RCURLYB,EOF,SEMICOLON,OR, }
  (73) Type --> .T_STRING  { LAMBDA,LSQUAREB, }
  (27) NonBlockExpr --> .ReturnType LAMBDA ParamList DOT Expr  { RCURLYB,SEMICOLON,EOF, }
  (19) BlockExpr --> .LET Param ASSIGN Expr IN BlockExpr  { RCURLYB,EOF,SEMICOLON, }
  (54) TimesExpr --> .TimesExpr TIMES UnaryExpr  { RCURLYB,EOF,PLUS,LESS,NEQ,CARET,EQ,DIV,AND,MINUS,GREATER,GREATEREQ,SEMICOLON,TIMES,LESSEQ,OR,MOD, }
  (32) ReturnType --> .Type  { LAMBDA, }
  (6) BlockStmt --> .LCURLYB Stmts RCURLYB  { EOF,RCURLYB,SEMICOLON, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { SEMICOLON,LESSEQ,LPAREN,MINUS,LSQUAREB,PLUS,DIV,EQ,TIMES,LESS,MOD,OR,CARET,GREATEREQ,EOF,AND,RCURLYB,NEQ,GREATER, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { NEQ,TIMES,DIV,LESSEQ,SEMICOLON,EOF,OR,EQ,AND,RCURLYB,GREATER,MINUS,CARET,MOD,LESS,PLUS,GREATEREQ, }
  (44) AndExpr --> .AndExpr AND EqExpr  { SEMICOLON,RCURLYB,AND,EOF,OR, }
  (38) PlusExpr --> .TimesExpr  { RCURLYB,LESS,EQ,MINUS,GREATEREQ,AND,LESSEQ,EOF,NEQ,SEMICOLON,CARET,GREATER,OR,PLUS, }
  (35) AndExpr --> .EqExpr  { AND,SEMICOLON,EOF,OR,RCURLYB, }
  (15) DefineExpr --> DEFINE Param ASSIGN .Expr  { EOF,RCURLYB,SEMICOLON, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { DIV,RCURLYB,GREATER,TIMES,CARET,LESS,PLUS,SEMICOLON,EOF,EQ,LSQUAREB,MINUS,LPAREN,ASSIGN,AND,MOD,NEQ,OR,GREATEREQ,LESSEQ, }
  (68) RValue --> .StringLit  { MOD,EQ,DIV,NEQ,LESS,LSQUAREB,GREATER,PLUS,RCURLYB,CARET,AND,EOF,SEMICOLON,LPAREN,MINUS,GREATEREQ,LESSEQ,TIMES,OR, }
  (22) NonBlockExpr --> .LET Param ASSIGN Expr IN NonBlockExpr  { EOF,SEMICOLON,RCURLYB, }
  (39) TimesExpr --> .UnaryExpr  { AND,DIV,NEQ,TIMES,RCURLYB,EOF,PLUS,MOD,GREATEREQ,OR,EQ,MINUS,CARET,SEMICOLON,LESS,GREATER,LESSEQ, }
  (47) CompExpr --> .CompExpr LESS PlusExpr  { LESS,OR,AND,RCURLYB,EQ,GREATEREQ,SEMICOLON,NEQ,GREATER,EOF,LESSEQ, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { CARET,GREATER,DIV,EOF,NEQ,GREATEREQ,LESS,PLUS,LPAREN,EQ,SEMICOLON,RCURLYB,LESSEQ,TIMES,MINUS,OR,MOD,AND,LSQUAREB, }
  (40) UnaryExpr --> .LValue  { OR,LESS,TIMES,AND,EQ,RCURLYB,GREATEREQ,PLUS,CARET,LESSEQ,NEQ,SEMICOLON,EOF,MINUS,DIV,GREATER,MOD, }
  (67) RValue --> .Float  { SEMICOLON,DIV,RCURLYB,MINUS,LESS,GREATER,GREATEREQ,LPAREN,CARET,NEQ,MOD,TIMES,EOF,LSQUAREB,PLUS,LESSEQ,AND,EQ,OR, }
  (50) CompExpr --> .CompExpr GREATEREQ PlusExpr  { RCURLYB,NEQ,SEMICOLON,LESS,OR,GREATER,LESSEQ,EQ,AND,GREATEREQ,EOF, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { GREATER,OR,DIV,CARET,AND,LSQUAREB,LPAREN,LESSEQ,GREATEREQ,EOF,LESS,SEMICOLON,NEQ,MINUS,MOD,RCURLYB,TIMES,PLUS,EQ, }
  (8) Expr --> .NonBlockExpr  { SEMICOLON,EOF,RCURLYB, }
  (57) UnaryExpr --> .NOT UnaryExpr  { MOD,CARET,NEQ,DIV,EOF,SEMICOLON,MINUS,EQ,RCURLYB,OR,GREATER,AND,LESSEQ,TIMES,GREATEREQ,LESS,PLUS, }
  (36) EqExpr --> .CompExpr  { AND,NEQ,EOF,EQ,SEMICOLON,RCURLYB,OR, }
  (41) UnaryExpr --> .RValue  { EOF,EQ,CARET,TIMES,SEMICOLON,GREATEREQ,OR,PLUS,DIV,NEQ,MOD,RCURLYB,LESS,LESSEQ,MINUS,AND,GREATER, }
  (21) NonBlockExpr --> .WHILE Expr DO NonBlockExpr  { SEMICOLON,RCURLYB,EOF, }
  (18) BlockExpr --> .WHILE Expr DO BlockExpr  { RCURLYB,EOF,SEMICOLON, }
  (52) PlusExpr --> .PlusExpr MINUS TimesExpr  { GREATEREQ,NEQ,MINUS,OR,EQ,EOF,SEMICOLON,LESSEQ,PLUS,GREATER,LESS,RCURLYB,AND,CARET, }
  (53) PlusExpr --> .PlusExpr CARET TimesExpr  { CARET,GREATEREQ,MINUS,PLUS,EQ,LESSEQ,GREATER,NEQ,AND,EOF,SEMICOLON,OR,LESS,RCURLYB, }
  (23) NonBlockExpr --> .LValue ASSIGN Expr  { SEMICOLON,RCURLYB,EOF, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { MOD,LESS,LSQUAREB,GREATER,EOF,TIMES,PLUS,MINUS,CARET,LESSEQ,SEMICOLON,NEQ,GREATEREQ,RCURLYB,DIV,LPAREN,AND,OR,EQ, }
  (56) TimesExpr --> .TimesExpr MOD UnaryExpr  { LESSEQ,EOF,DIV,OR,MOD,LESS,NEQ,EQ,MINUS,SEMICOLON,CARET,TIMES,PLUS,RCURLYB,GREATER,AND,GREATEREQ, }
  (7) Expr --> .BlockExpr  { EOF,SEMICOLON,RCURLYB, }
  (48) CompExpr --> .CompExpr GREATER PlusExpr  { GREATER,EQ,SEMICOLON,LESS,OR,RCURLYB,EOF,AND,GREATEREQ,NEQ,LESSEQ, }
  (16) BlockExpr --> .BlockStmt  { RCURLYB,SEMICOLON,EOF, }
  (37) CompExpr --> .PlusExpr  { LESSEQ,GREATER,EOF,AND,OR,GREATEREQ,EQ,LESS,SEMICOLON,NEQ,RCURLYB, }
  (71) Type --> .T_INT  { LSQUAREB,LAMBDA, }
  (49) CompExpr --> .CompExpr LESSEQ PlusExpr  { LESS,EQ,OR,LESSEQ,NEQ,GREATER,EOF,RCURLYB,GREATEREQ,AND,SEMICOLON, }
  (43) OrExpr --> .OrExpr OR AndExpr  { SEMICOLON,EOF,RCURLYB,OR, }
  (26) NonBlockExpr --> .LAMBDA ParamList DOT Expr  { RCURLYB,SEMICOLON,EOF, }
  (45) EqExpr --> .EqExpr EQ CompExpr  { NEQ,SEMICOLON,OR,EOF,EQ,AND,RCURLYB, }
  (42) RValue --> .LPAREN Expr RPAREN  { MINUS,SEMICOLON,CARET,EQ,MOD,OR,LESSEQ,LSQUAREB,DIV,GREATEREQ,PLUS,EOF,GREATER,NEQ,LESS,TIMES,LPAREN,RCURLYB,AND, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { EOF,RCURLYB,CARET,GREATER,NEQ,PLUS,DIV,SEMICOLON,TIMES,LESSEQ,GREATEREQ,OR,MOD,EQ,AND,MINUS,LESS, }
  (33) NonBlockExpr --> .OrExpr  { SEMICOLON,RCURLYB,EOF, }
  (20) NonBlockExpr --> .IF Expr THEN Expr ELSE NonBlockExpr  { RCURLYB,SEMICOLON,EOF, }
  (66) RValue --> .Integer  { RCURLYB,TIMES,DIV,MINUS,CARET,OR,PLUS,NEQ,AND,LESSEQ,LSQUAREB,MOD,EOF,GREATER,EQ,LPAREN,LESS,GREATEREQ,SEMICOLON, }
  (51) PlusExpr --> .PlusExpr PLUS TimesExpr  { PLUS,MINUS,SEMICOLON,EQ,EOF,GREATEREQ,NEQ,AND,LESS,GREATER,RCURLYB,LESSEQ,OR,CARET, }
state 115:
  (18) BlockExpr --> WHILE Expr DO BlockExpr .  { RPAREN,Var,LCURLYB,LPAREN,THEN,T_VOID,IN,PRINT,Integer,SEMICOLON,T_STRING,T_INT,NOT,Float,ELSE,RSQUAREB,NEGATE,DEFINE,RCURLYB,WHILE,LET,COMMA,LSQUAREB,IF,T_FLOAT,DO,StringLit,LAMBDA,EOF, }
state 116:
  (21) NonBlockExpr --> WHILE Expr DO NonBlockExpr .  { COMMA,RPAREN,RCURLYB,DO,IN,SEMICOLON,EOF,RSQUAREB,ELSE,THEN, }
state 117:
  (19) BlockExpr --> LET Param ASSIGN Expr .IN BlockExpr  { RCURLYB,StringLit,ELSE,LSQUAREB,SEMICOLON,DO,WHILE,T_INT,Integer,RPAREN,T_VOID,COMMA,THEN,PRINT,IN,T_STRING,LCURLYB,DEFINE,LAMBDA,Var,EOF,IF,LPAREN,Float,NEGATE,RSQUAREB,NOT,LET,T_FLOAT, }
  (22) NonBlockExpr --> LET Param ASSIGN Expr .IN NonBlockExpr  { RPAREN,EOF,RSQUAREB,SEMICOLON,THEN,ELSE,DO,COMMA,RCURLYB,IN, }
state 118:
  (13) TypedParam --> Var COLON Type .  { DOT,COMMA,ASSIGN, }
  (74) Type --> Type .LSQUAREB RSQUAREB  { DOT,ASSIGN,COMMA,LSQUAREB, }
state 119:
  (62) RValue --> RValue LSQUAREB Expr RSQUAREB .  { LPAREN,GREATEREQ,RPAREN,LSQUAREB,MOD,OR,EQ,PLUS,DO,EOF,SEMICOLON,ELSE,TIMES,AND,IN,RSQUAREB,CARET,NEQ,GREATER,COMMA,THEN,LESSEQ,RCURLYB,MINUS,DIV,LESS, }
state 120:
  (61) RValue --> RValue LPAREN ArgList RPAREN .  { NEQ,TIMES,DIV,MOD,SEMICOLON,MINUS,ELSE,LPAREN,LESSEQ,RCURLYB,OR,LESS,EOF,IN,CARET,EQ,RPAREN,PLUS,GREATEREQ,AND,GREATER,RSQUAREB,DO,THEN,LSQUAREB,COMMA, }
state 121:
  (25) LValue --> LValue LSQUAREB Expr RSQUAREB .  { IN,RCURLYB,GREATER,COMMA,RSQUAREB,DIV,NEQ,LESS,GREATEREQ,AND,OR,TIMES,RPAREN,ELSE,DO,THEN,LSQUAREB,ASSIGN,MOD,LPAREN,EQ,SEMICOLON,LESSEQ,EOF,PLUS,MINUS,CARET, }
state 122:
  (60) RValue --> LValue LPAREN ArgList RPAREN .  { EQ,LESS,LESSEQ,GREATER,TIMES,IN,AND,OR,DIV,RCURLYB,ELSE,MOD,SEMICOLON,LPAREN,GREATEREQ,RSQUAREB,THEN,COMMA,EOF,RPAREN,DO,MINUS,CARET,PLUS,LSQUAREB,NEQ, }
state 123:
  (20) NonBlockExpr --> IF Expr THEN Expr .ELSE NonBlockExpr  { RCURLYB,DO,SEMICOLON,RPAREN,RSQUAREB,COMMA,EOF,THEN,ELSE,IN, }
  (17) BlockExpr --> IF Expr THEN Expr .ELSE BlockExpr  { Float,RSQUAREB,LCURLYB,WHILE,NOT,PRINT,Var,LPAREN,THEN,StringLit,T_INT,RCURLYB,COMMA,EOF,RPAREN,LAMBDA,NEGATE,IF,ELSE,SEMICOLON,T_FLOAT,LET,T_STRING,DO,Integer,IN,LSQUAREB,T_VOID,DEFINE, }
state 124:
  (70) RValue --> LSQUAREB Expr SEMICOLON Expr .RSQUAREB  { THEN,GREATER,LSQUAREB,LPAREN,CARET,AND,OR,EOF,NEQ,MOD,MINUS,SEMICOLON,LESSEQ,RPAREN,LESS,DIV,ELSE,GREATEREQ,PLUS,RCURLYB,IN,TIMES,DO,COMMA,RSQUAREB,EQ, }
state 125:
  (65) ArgList --> Expr COMMA ArgList .  { RSQUAREB,RPAREN, }
state 126:
  (30) ParamList --> TypedParam COMMA ParamList .  { DOT, }
state 127:
  (26) NonBlockExpr --> LAMBDA ParamList DOT Expr .  { RCURLYB,RPAREN,SEMICOLON,EOF,ELSE,THEN,RSQUAREB,DO,COMMA,IN, }
state 128:
  (45) EqExpr --> .EqExpr EQ CompExpr  { DO,RPAREN,EQ,RCURLYB,COMMA,AND,SEMICOLON,RSQUAREB,NEQ,EOF,IN,ELSE,THEN,OR, }
  (43) OrExpr --> .OrExpr OR AndExpr  { RPAREN,ELSE,COMMA,RSQUAREB,SEMICOLON,EOF,OR,RCURLYB,IN,THEN,DO, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { ELSE,NEQ,DIV,MOD,CARET,LPAREN,EOF,DO,PLUS,MINUS,RPAREN,GREATER,TIMES,AND,COMMA,LESS,IN,LESSEQ,GREATEREQ,THEN,RCURLYB,OR,LSQUAREB,RSQUAREB,SEMICOLON,EQ, }
  (20) NonBlockExpr --> .IF Expr THEN Expr ELSE NonBlockExpr  { SEMICOLON,EOF,RCURLYB,RPAREN,ELSE,RSQUAREB,DO,IN,THEN,COMMA, }
  (18) BlockExpr --> .WHILE Expr DO BlockExpr  { EOF,RSQUAREB,IN,RCURLYB,RPAREN,COMMA,ELSE,THEN,SEMICOLON,DO, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { LESSEQ,COMMA,GREATEREQ,EQ,ELSE,SEMICOLON,NEQ,LPAREN,RCURLYB,DIV,OR,CARET,RPAREN,GREATER,RSQUAREB,IN,TIMES,EOF,MINUS,THEN,LESS,DO,MOD,LSQUAREB,AND,PLUS, }
  (40) UnaryExpr --> .LValue  { ELSE,SEMICOLON,RSQUAREB,DIV,LESS,PLUS,NEQ,MINUS,GREATEREQ,IN,RPAREN,GREATER,THEN,COMMA,CARET,LESSEQ,OR,MOD,TIMES,DO,RCURLYB,EQ,AND,EOF, }
  (8) Expr --> .NonBlockExpr  { RSQUAREB,DO,EOF,RPAREN,SEMICOLON,ELSE,RCURLYB,THEN,IN,COMMA, }
  (6) BlockStmt --> .LCURLYB Stmts RCURLYB  { RPAREN,RCURLYB,DO,THEN,EOF,SEMICOLON,ELSE,RSQUAREB,IN,COMMA, }
  (46) EqExpr --> .EqExpr NEQ CompExpr  { EOF,THEN,NEQ,COMMA,OR,ELSE,IN,SEMICOLON,AND,RCURLYB,EQ,RSQUAREB,RPAREN,DO, }
  (51) PlusExpr --> .PlusExpr PLUS TimesExpr  { RSQUAREB,GREATEREQ,LESSEQ,CARET,EQ,ELSE,SEMICOLON,IN,AND,DO,THEN,PLUS,MINUS,LESS,RPAREN,RCURLYB,NEQ,OR,COMMA,EOF,GREATER, }
  (33) NonBlockExpr --> .OrExpr  { DO,RPAREN,RSQUAREB,THEN,ELSE,COMMA,IN,RCURLYB,EOF,SEMICOLON, }
  (74) Type --> .Type LSQUAREB RSQUAREB  { LSQUAREB,LAMBDA, }
  (27) NonBlockExpr --> ReturnType LAMBDA ParamList DOT .Expr  { IN,ELSE,RPAREN,DO,RSQUAREB,EOF,RCURLYB,THEN,SEMICOLON,COMMA, }
  (21) NonBlockExpr --> .WHILE Expr DO NonBlockExpr  { COMMA,RSQUAREB,DO,SEMICOLON,RPAREN,THEN,EOF,IN,RCURLYB,ELSE, }
  (44) AndExpr --> .AndExpr AND EqExpr  { EOF,RSQUAREB,IN,THEN,ELSE,DO,OR,AND,COMMA,SEMICOLON,RCURLYB,RPAREN, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { MOD,AND,LESS,RCURLYB,DO,THEN,RPAREN,LSQUAREB,EOF,GREATEREQ,CARET,NEQ,OR,ELSE,PLUS,TIMES,MINUS,COMMA,DIV,GREATER,SEMICOLON,EQ,IN,LPAREN,LESSEQ,RSQUAREB, }
  (7) Expr --> .BlockExpr  { IN,THEN,EOF,SEMICOLON,RCURLYB,RPAREN,DO,ELSE,COMMA,RSQUAREB, }
  (37) CompExpr --> .PlusExpr  { THEN,SEMICOLON,LESS,IN,EOF,COMMA,EQ,ELSE,AND,RSQUAREB,OR,GREATEREQ,GREATER,LESSEQ,NEQ,RPAREN,RCURLYB,DO, }
  (38) PlusExpr --> .TimesExpr  { NEQ,THEN,IN,GREATER,MINUS,GREATEREQ,EOF,OR,COMMA,AND,PLUS,CARET,DO,LESSEQ,RCURLYB,RSQUAREB,RPAREN,ELSE,SEMICOLON,EQ,LESS, }
  (39) TimesExpr --> .UnaryExpr  { DIV,MINUS,EOF,EQ,NEQ,THEN,GREATEREQ,SEMICOLON,RPAREN,PLUS,RSQUAREB,COMMA,LESSEQ,CARET,MOD,IN,TIMES,AND,LESS,ELSE,GREATER,RCURLYB,DO,OR, }
  (53) PlusExpr --> .PlusExpr CARET TimesExpr  { IN,OR,GREATEREQ,AND,RCURLYB,LESS,LESSEQ,RPAREN,CARET,PLUS,NEQ,COMMA,RSQUAREB,ELSE,EOF,MINUS,SEMICOLON,DO,THEN,EQ,GREATER, }
  (27) NonBlockExpr --> .ReturnType LAMBDA ParamList DOT Expr  { SEMICOLON,EOF,DO,ELSE,IN,COMMA,RSQUAREB,RPAREN,RCURLYB,THEN, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { EOF,RSQUAREB,COMMA,RPAREN,EQ,LESSEQ,MINUS,MOD,THEN,AND,ELSE,GREATEREQ,LESS,TIMES,CARET,RCURLYB,NEQ,PLUS,GREATER,DIV,SEMICOLON,IN,OR,DO, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { EQ,PLUS,DO,ELSE,CARET,MINUS,LESSEQ,MOD,RSQUAREB,IN,COMMA,THEN,LPAREN,LESS,RCURLYB,GREATER,NEQ,AND,GREATEREQ,SEMICOLON,LSQUAREB,EOF,RPAREN,TIMES,OR,DIV, }
  (55) TimesExpr --> .TimesExpr DIV UnaryExpr  { LESS,OR,GREATER,RSQUAREB,NEQ,SEMICOLON,MOD,DO,DIV,THEN,CARET,EQ,ELSE,COMMA,EOF,RPAREN,RCURLYB,AND,IN,GREATEREQ,PLUS,TIMES,MINUS,LESSEQ, }
  (47) CompExpr --> .CompExpr LESS PlusExpr  { SEMICOLON,RSQUAREB,COMMA,EQ,OR,DO,THEN,GREATER,RPAREN,LESSEQ,EOF,ELSE,LESS,NEQ,IN,RCURLYB,AND,GREATEREQ, }
  (57) UnaryExpr --> .NOT UnaryExpr  { LESSEQ,RSQUAREB,TIMES,SEMICOLON,CARET,MOD,EOF,GREATER,DIV,RCURLYB,PLUS,DO,ELSE,AND,RPAREN,COMMA,IN,OR,MINUS,LESS,NEQ,EQ,GREATEREQ,THEN, }
  (54) TimesExpr --> .TimesExpr TIMES UnaryExpr  { ELSE,SEMICOLON,THEN,OR,LESSEQ,DIV,IN,PLUS,RCURLYB,MOD,RPAREN,DO,NEQ,CARET,TIMES,EOF,MINUS,RSQUAREB,LESS,AND,GREATER,COMMA,GREATEREQ,EQ, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { RSQUAREB,LESSEQ,MINUS,ELSE,GREATEREQ,THEN,RPAREN,EOF,DIV,PLUS,CARET,NEQ,GREATER,MOD,EQ,AND,COMMA,DO,IN,SEMICOLON,RCURLYB,LESS,TIMES,OR, }
  (31) ReturnType --> .T_VOID  { LAMBDA, }
  (22) NonBlockExpr --> .LET Param ASSIGN Expr IN NonBlockExpr  { THEN,EOF,DO,SEMICOLON,IN,RSQUAREB,RCURLYB,ELSE,COMMA,RPAREN, }
  (52) PlusExpr --> .PlusExpr MINUS TimesExpr  { THEN,EQ,NEQ,COMMA,GREATEREQ,RPAREN,MINUS,CARET,AND,OR,LESS,EOF,RCURLYB,DO,LESSEQ,ELSE,PLUS,SEMICOLON,RSQUAREB,IN,GREATER, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { LESSEQ,DO,MINUS,PLUS,RSQUAREB,LESS,DIV,ASSIGN,COMMA,EQ,RPAREN,CARET,EOF,AND,IN,SEMICOLON,MOD,GREATER,NEQ,GREATEREQ,LSQUAREB,ELSE,LPAREN,THEN,RCURLYB,OR,TIMES, }
  (23) NonBlockExpr --> .LValue ASSIGN Expr  { EOF,RPAREN,RCURLYB,SEMICOLON,THEN,IN,DO,RSQUAREB,COMMA,ELSE, }
  (41) UnaryExpr --> .RValue  { IN,DO,OR,SEMICOLON,COMMA,DIV,CARET,THEN,GREATER,AND,EQ,NEQ,RSQUAREB,LESS,MINUS,PLUS,GREATEREQ,LESSEQ,RPAREN,ELSE,EOF,RCURLYB,TIMES,MOD, }
  (19) BlockExpr --> .LET Param ASSIGN Expr IN BlockExpr  { RPAREN,RCURLYB,COMMA,RSQUAREB,SEMICOLON,DO,EOF,IN,ELSE,THEN, }
  (48) CompExpr --> .CompExpr GREATER PlusExpr  { GREATEREQ,SEMICOLON,DO,OR,GREATER,THEN,IN,LESSEQ,RPAREN,COMMA,ELSE,RCURLYB,RSQUAREB,NEQ,EQ,AND,EOF,LESS, }
  (24) LValue --> .Var  { ASSIGN,DIV,RCURLYB,COMMA,RSQUAREB,LSQUAREB,MINUS,THEN,EOF,OR,LESS,CARET,TIMES,ELSE,AND,DO,GREATER,EQ,SEMICOLON,LPAREN,LESSEQ,PLUS,IN,MOD,RPAREN,GREATEREQ,NEQ, }
  (49) CompExpr --> .CompExpr LESSEQ PlusExpr  { LESSEQ,THEN,GREATEREQ,GREATER,IN,DO,RSQUAREB,SEMICOLON,RCURLYB,NEQ,OR,AND,LESS,ELSE,RPAREN,COMMA,EQ,EOF, }
  (71) Type --> .T_INT  { LSQUAREB,LAMBDA, }
  (16) BlockExpr --> .BlockStmt  { IN,EOF,ELSE,THEN,RSQUAREB,COMMA,DO,RCURLYB,SEMICOLON,RPAREN, }
  (50) CompExpr --> .CompExpr GREATEREQ PlusExpr  { RCURLYB,EOF,GREATEREQ,EQ,RPAREN,NEQ,DO,THEN,COMMA,IN,OR,LESSEQ,RSQUAREB,SEMICOLON,GREATER,ELSE,LESS,AND, }
  (42) RValue --> .LPAREN Expr RPAREN  { RCURLYB,RPAREN,AND,GREATEREQ,MOD,COMMA,DIV,THEN,ELSE,GREATER,IN,EOF,TIMES,MINUS,LESSEQ,LESS,NEQ,LSQUAREB,RSQUAREB,LPAREN,OR,EQ,PLUS,DO,CARET,SEMICOLON, }
  (72) Type --> .T_FLOAT  { LSQUAREB,LAMBDA, }
  (67) RValue --> .Float  { LSQUAREB,RPAREN,OR,IN,GREATER,AND,MOD,RCURLYB,COMMA,EOF,LPAREN,NEQ,SEMICOLON,MINUS,CARET,DO,LESS,RSQUAREB,DIV,GREATEREQ,EQ,THEN,LESSEQ,PLUS,TIMES,ELSE, }
  (32) ReturnType --> .Type  { LAMBDA, }
  (35) AndExpr --> .EqExpr  { SEMICOLON,EOF,AND,THEN,RSQUAREB,COMMA,OR,RPAREN,RCURLYB,ELSE,DO,IN, }
  (17) BlockExpr --> .IF Expr THEN Expr ELSE BlockExpr  { DO,RCURLYB,EOF,THEN,IN,RPAREN,SEMICOLON,COMMA,ELSE,RSQUAREB, }
  (36) EqExpr --> .CompExpr  { EQ,AND,DO,IN,THEN,RSQUAREB,ELSE,SEMICOLON,NEQ,RPAREN,OR,EOF,COMMA,RCURLYB, }
  (26) NonBlockExpr --> .LAMBDA ParamList DOT Expr  { SEMICOLON,DO,THEN,RPAREN,EOF,COMMA,IN,RSQUAREB,ELSE,RCURLYB, }
  (56) TimesExpr --> .TimesExpr MOD UnaryExpr  { AND,LESSEQ,RSQUAREB,CARET,THEN,DO,NEQ,GREATEREQ,MOD,COMMA,EQ,EOF,RCURLYB,SEMICOLON,DIV,IN,RPAREN,OR,LESS,PLUS,ELSE,TIMES,GREATER,MINUS, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { GREATEREQ,MOD,RSQUAREB,ELSE,DO,RPAREN,CARET,LPAREN,RCURLYB,EQ,IN,SEMICOLON,DIV,NEQ,THEN,OR,GREATER,EOF,AND,PLUS,COMMA,MINUS,TIMES,LESSEQ,LSQUAREB,LESS, }
  (68) RValue --> .StringLit  { LSQUAREB,CARET,IN,NEQ,TIMES,RPAREN,SEMICOLON,RCURLYB,RSQUAREB,GREATER,DO,COMMA,MOD,OR,ELSE,LESS,GREATEREQ,LESSEQ,EOF,LPAREN,MINUS,EQ,DIV,PLUS,THEN,AND, }
  (66) RValue --> .Integer  { TIMES,RSQUAREB,THEN,EOF,GREATEREQ,NEQ,RCURLYB,EQ,DIV,LESSEQ,PLUS,OR,DO,AND,IN,COMMA,CARET,ELSE,MINUS,LESS,GREATER,SEMICOLON,LSQUAREB,LPAREN,MOD,RPAREN, }
  (34) OrExpr --> .AndExpr  { COMMA,OR,ELSE,THEN,SEMICOLON,RCURLYB,DO,RPAREN,RSQUAREB,EOF,IN, }
  (73) Type --> .T_STRING  { LAMBDA,LSQUAREB, }
state 129:
  (15) DefineExpr --> DEFINE Param ASSIGN Expr .  { SEMICOLON,RCURLYB,EOF, }
state 130:
  (41) UnaryExpr --> .RValue  { MOD,RCURLYB,CARET,GREATER,LESSEQ,AND,IN,DIV,MINUS,OR,LESS,RPAREN,SEMICOLON,ELSE,EOF,DO,EQ,PLUS,RSQUAREB,GREATEREQ,NEQ,THEN,COMMA,TIMES, }
  (17) BlockExpr --> .IF Expr THEN Expr ELSE BlockExpr  { ELSE,Integer,T_INT,SEMICOLON,PRINT,LCURLYB,NEGATE,T_FLOAT,COMMA,Var,LAMBDA,RSQUAREB,DO,NOT,EOF,WHILE,RPAREN,T_VOID,StringLit,LPAREN,LET,Float,T_STRING,LSQUAREB,IN,DEFINE,RCURLYB,THEN,IF, }
  (18) BlockExpr --> .WHILE Expr DO BlockExpr  { Integer,LSQUAREB,LET,DO,Float,WHILE,LPAREN,NOT,RPAREN,RCURLYB,DEFINE,NEGATE,COMMA,Var,T_FLOAT,T_VOID,StringLit,THEN,EOF,IF,RSQUAREB,T_INT,IN,ELSE,LCURLYB,SEMICOLON,LAMBDA,PRINT,T_STRING, }
  (6) BlockStmt --> .LCURLYB Stmts RCURLYB  { NEGATE,LCURLYB,PRINT,T_INT,ELSE,T_VOID,LET,RPAREN,LSQUAREB,NOT,RCURLYB,THEN,LPAREN,COMMA,WHILE,EOF,Integer,IF,DEFINE,LAMBDA,SEMICOLON,Float,StringLit,IN,RSQUAREB,T_FLOAT,T_STRING,Var,DO, }
  (20) NonBlockExpr --> .IF Expr THEN Expr ELSE NonBlockExpr  { RPAREN,RSQUAREB,DO,EOF,IN,SEMICOLON,ELSE,THEN,COMMA,RCURLYB, }
  (50) CompExpr --> .CompExpr GREATEREQ PlusExpr  { GREATEREQ,ELSE,AND,OR,EQ,EOF,THEN,RPAREN,DO,GREATER,NEQ,RSQUAREB,RCURLYB,COMMA,LESS,IN,SEMICOLON,LESSEQ, }
  (49) CompExpr --> .CompExpr LESSEQ PlusExpr  { OR,AND,COMMA,DO,IN,ELSE,LESS,GREATER,EOF,RCURLYB,THEN,GREATEREQ,EQ,SEMICOLON,LESSEQ,RPAREN,NEQ,RSQUAREB, }
  (31) ReturnType --> .T_VOID  { LAMBDA, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { GREATEREQ,RCURLYB,PLUS,GREATER,RPAREN,EOF,DIV,THEN,LESSEQ,AND,LESS,RSQUAREB,MOD,IN,MINUS,COMMA,NEQ,OR,ELSE,EQ,DO,TIMES,SEMICOLON,CARET, }
  (36) EqExpr --> .CompExpr  { THEN,COMMA,ELSE,DO,OR,RPAREN,SEMICOLON,NEQ,RSQUAREB,AND,IN,EOF,RCURLYB,EQ, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { RPAREN,RSQUAREB,DIV,LESS,NEQ,LPAREN,ELSE,TIMES,THEN,AND,OR,EOF,MINUS,SEMICOLON,MOD,DO,LESSEQ,GREATEREQ,LSQUAREB,GREATER,IN,COMMA,RCURLYB,EQ,PLUS,CARET, }
  (16) BlockExpr --> .BlockStmt  { LPAREN,DO,ELSE,Float,PRINT,LET,T_INT,LCURLYB,DEFINE,LAMBDA,COMMA,WHILE,LSQUAREB,THEN,StringLit,Var,RPAREN,T_FLOAT,IN,RCURLYB,RSQUAREB,SEMICOLON,EOF,Integer,T_VOID,IF,NOT,NEGATE,T_STRING, }
  (54) TimesExpr --> .TimesExpr TIMES UnaryExpr  { PLUS,OR,AND,LESS,TIMES,THEN,EQ,ELSE,MINUS,LESSEQ,DIV,RSQUAREB,DO,EOF,MOD,IN,SEMICOLON,GREATEREQ,RPAREN,GREATER,NEQ,COMMA,CARET,RCURLYB, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { LESSEQ,ELSE,AND,LSQUAREB,PLUS,EOF,LPAREN,RSQUAREB,LESS,THEN,MINUS,OR,SEMICOLON,GREATER,TIMES,DIV,GREATEREQ,CARET,EQ,NEQ,IN,RCURLYB,DO,COMMA,MOD,RPAREN, }
  (57) UnaryExpr --> .NOT UnaryExpr  { DO,LESSEQ,COMMA,MOD,PLUS,LESS,ELSE,RSQUAREB,DIV,IN,EQ,CARET,RPAREN,MINUS,GREATER,NEQ,EOF,TIMES,THEN,OR,AND,RCURLYB,SEMICOLON,GREATEREQ, }
  (24) LValue --> .Var  { SEMICOLON,TIMES,THEN,DO,GREATER,LESSEQ,ELSE,GREATEREQ,LSQUAREB,DIV,RSQUAREB,COMMA,RPAREN,EQ,OR,MOD,RCURLYB,AND,PLUS,EOF,CARET,IN,LESS,LPAREN,ASSIGN,NEQ,MINUS, }
  (38) PlusExpr --> .TimesExpr  { ELSE,THEN,MINUS,GREATER,PLUS,EOF,AND,EQ,RPAREN,RSQUAREB,LESS,NEQ,LESSEQ,DO,OR,COMMA,RCURLYB,CARET,GREATEREQ,SEMICOLON,IN, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { GREATEREQ,PLUS,RCURLYB,EQ,DO,LESS,LESSEQ,ELSE,GREATER,TIMES,CARET,MOD,AND,COMMA,DIV,THEN,OR,NEQ,LSQUAREB,MINUS,RSQUAREB,EOF,IN,SEMICOLON,RPAREN,LPAREN, }
  (21) NonBlockExpr --> .WHILE Expr DO NonBlockExpr  { IN,SEMICOLON,COMMA,EOF,RSQUAREB,DO,RPAREN,RCURLYB,THEN,ELSE, }
  (48) CompExpr --> .CompExpr GREATER PlusExpr  { OR,LESS,NEQ,DO,GREATER,SEMICOLON,RCURLYB,GREATEREQ,RSQUAREB,IN,EOF,EQ,ELSE,LESSEQ,COMMA,RPAREN,THEN,AND, }
  (66) RValue --> .Integer  { EQ,ELSE,NEQ,MINUS,LESSEQ,MOD,COMMA,RPAREN,AND,EOF,GREATEREQ,LSQUAREB,GREATER,RCURLYB,IN,CARET,SEMICOLON,LESS,RSQUAREB,LPAREN,DO,DIV,OR,THEN,TIMES,PLUS, }
  (67) RValue --> .Float  { OR,COMMA,DO,RSQUAREB,LESS,EOF,THEN,AND,NEQ,RPAREN,RCURLYB,SEMICOLON,TIMES,CARET,LPAREN,LESSEQ,DIV,EQ,PLUS,IN,GREATER,MINUS,ELSE,GREATEREQ,MOD,LSQUAREB, }
  (74) Type --> .Type LSQUAREB RSQUAREB  { LSQUAREB,LAMBDA, }
  (19) BlockExpr --> LET Param ASSIGN Expr IN .BlockExpr  { DO,LCURLYB,RCURLYB,THEN,LPAREN,LSQUAREB,Var,LAMBDA,IF,ELSE,StringLit,T_INT,Integer,T_FLOAT,NOT,EOF,LET,T_VOID,PRINT,WHILE,T_STRING,DEFINE,NEGATE,IN,COMMA,RPAREN,SEMICOLON,Float,RSQUAREB, }
  (72) Type --> .T_FLOAT  { LSQUAREB,LAMBDA, }
  (34) OrExpr --> .AndExpr  { COMMA,DO,ELSE,SEMICOLON,RSQUAREB,RCURLYB,RPAREN,THEN,OR,EOF,IN, }
  (32) ReturnType --> .Type  { LAMBDA, }
  (23) NonBlockExpr --> .LValue ASSIGN Expr  { COMMA,EOF,RSQUAREB,IN,RCURLYB,ELSE,SEMICOLON,DO,RPAREN,THEN, }
  (22) NonBlockExpr --> LET Param ASSIGN Expr IN .NonBlockExpr  { COMMA,RCURLYB,SEMICOLON,ELSE,IN,RSQUAREB,RPAREN,THEN,EOF,DO, }
  (44) AndExpr --> .AndExpr AND EqExpr  { RPAREN,DO,RSQUAREB,THEN,ELSE,AND,COMMA,OR,IN,SEMICOLON,RCURLYB,EOF, }
  (53) PlusExpr --> .PlusExpr CARET TimesExpr  { RSQUAREB,EQ,LESS,DO,THEN,RPAREN,SEMICOLON,NEQ,ELSE,MINUS,CARET,RCURLYB,IN,GREATER,OR,LESSEQ,PLUS,COMMA,GREATEREQ,AND,EOF, }
  (71) Type --> .T_INT  { LAMBDA,LSQUAREB, }
  (37) CompExpr --> .PlusExpr  { AND,SEMICOLON,NEQ,GREATER,LESS,GREATEREQ,DO,ELSE,RCURLYB,EQ,RSQUAREB,COMMA,OR,EOF,LESSEQ,IN,THEN,RPAREN, }
  (47) CompExpr --> .CompExpr LESS PlusExpr  { THEN,GREATER,COMMA,RSQUAREB,EQ,LESS,SEMICOLON,RPAREN,GREATEREQ,DO,AND,NEQ,RCURLYB,LESSEQ,OR,ELSE,EOF,IN, }
  (22) NonBlockExpr --> .LET Param ASSIGN Expr IN NonBlockExpr  { SEMICOLON,RSQUAREB,RCURLYB,RPAREN,THEN,ELSE,EOF,COMMA,DO,IN, }
  (19) BlockExpr --> .LET Param ASSIGN Expr IN BlockExpr  { ELSE,Var,T_INT,COMMA,RCURLYB,LET,T_STRING,T_VOID,Float,DEFINE,IF,T_FLOAT,THEN,DO,EOF,LCURLYB,NEGATE,PRINT,RPAREN,SEMICOLON,IN,Integer,LAMBDA,LPAREN,NOT,LSQUAREB,StringLit,RSQUAREB,WHILE, }
  (26) NonBlockExpr --> .LAMBDA ParamList DOT Expr  { RCURLYB,COMMA,ELSE,EOF,RSQUAREB,SEMICOLON,DO,RPAREN,IN,THEN, }
  (68) RValue --> .StringLit  { DO,AND,CARET,THEN,RPAREN,RSQUAREB,SEMICOLON,ELSE,GREATER,TIMES,IN,PLUS,LESS,NEQ,EOF,EQ,OR,RCURLYB,MOD,LSQUAREB,GREATEREQ,LESSEQ,DIV,LPAREN,MINUS,COMMA, }
  (56) TimesExpr --> .TimesExpr MOD UnaryExpr  { LESS,RPAREN,IN,RSQUAREB,DO,OR,DIV,GREATER,NEQ,THEN,LESSEQ,GREATEREQ,MINUS,PLUS,EQ,TIMES,RCURLYB,MOD,COMMA,AND,SEMICOLON,CARET,ELSE,EOF, }
  (73) Type --> .T_STRING  { LSQUAREB,LAMBDA, }
  (52) PlusExpr --> .PlusExpr MINUS TimesExpr  { LESS,THEN,RPAREN,AND,RCURLYB,GREATEREQ,IN,SEMICOLON,EOF,PLUS,COMMA,EQ,GREATER,LESSEQ,NEQ,MINUS,ELSE,DO,OR,CARET,RSQUAREB, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { RPAREN,COMMA,OR,DO,PLUS,MOD,GREATER,RSQUAREB,MINUS,TIMES,AND,THEN,LPAREN,SEMICOLON,NEQ,EQ,GREATEREQ,RCURLYB,ELSE,EOF,CARET,LSQUAREB,IN,LESSEQ,LESS,DIV, }
  (43) OrExpr --> .OrExpr OR AndExpr  { RSQUAREB,RCURLYB,RPAREN,COMMA,EOF,ELSE,OR,SEMICOLON,THEN,DO,IN, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { EQ,LESSEQ,RSQUAREB,MINUS,NEQ,IN,THEN,CARET,TIMES,RCURLYB,MOD,OR,GREATER,AND,RPAREN,PLUS,DO,DIV,EOF,COMMA,LESS,SEMICOLON,ELSE,GREATEREQ, }
  (33) NonBlockExpr --> .OrExpr  { DO,EOF,COMMA,ELSE,SEMICOLON,THEN,RSQUAREB,IN,RCURLYB,RPAREN, }
  (35) AndExpr --> .EqExpr  { DO,RPAREN,OR,RCURLYB,AND,RSQUAREB,EOF,THEN,IN,ELSE,SEMICOLON,COMMA, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { RPAREN,LESS,LESSEQ,NEQ,PLUS,ASSIGN,DIV,THEN,SEMICOLON,MINUS,CARET,COMMA,EQ,OR,MOD,LPAREN,TIMES,RSQUAREB,EOF,DO,ELSE,IN,GREATER,LSQUAREB,GREATEREQ,RCURLYB,AND, }
  (45) EqExpr --> .EqExpr EQ CompExpr  { IN,EOF,ELSE,COMMA,OR,RCURLYB,RSQUAREB,SEMICOLON,RPAREN,THEN,EQ,AND,DO,NEQ, }
  (42) RValue --> .LPAREN Expr RPAREN  { EQ,IN,TIMES,NEQ,ELSE,THEN,CARET,RSQUAREB,LSQUAREB,LESSEQ,LPAREN,RCURLYB,GREATEREQ,RPAREN,DIV,GREATER,AND,MOD,PLUS,EOF,DO,MINUS,SEMICOLON,OR,COMMA,LESS, }
  (55) TimesExpr --> .TimesExpr DIV UnaryExpr  { MOD,DO,GREATER,ELSE,CARET,GREATEREQ,IN,SEMICOLON,DIV,NEQ,EQ,AND,RSQUAREB,OR,LESS,PLUS,MINUS,RPAREN,EOF,TIMES,THEN,RCURLYB,COMMA,LESSEQ, }
  (46) EqExpr --> .EqExpr NEQ CompExpr  { RPAREN,EQ,OR,AND,IN,NEQ,SEMICOLON,THEN,RCURLYB,ELSE,EOF,RSQUAREB,DO,COMMA, }
  (40) UnaryExpr --> .LValue  { ELSE,NEQ,COMMA,RCURLYB,MOD,EOF,OR,PLUS,IN,SEMICOLON,GREATEREQ,EQ,DO,LESS,CARET,RSQUAREB,THEN,TIMES,AND,DIV,RPAREN,MINUS,GREATER,LESSEQ, }
  (51) PlusExpr --> .PlusExpr PLUS TimesExpr  { MINUS,IN,EQ,LESSEQ,PLUS,CARET,COMMA,OR,THEN,RCURLYB,AND,RPAREN,GREATEREQ,EOF,GREATER,DO,RSQUAREB,ELSE,SEMICOLON,NEQ,LESS, }
  (27) NonBlockExpr --> .ReturnType LAMBDA ParamList DOT Expr  { RSQUAREB,IN,DO,EOF,ELSE,THEN,RCURLYB,SEMICOLON,RPAREN,COMMA, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { LSQUAREB,IN,COMMA,PLUS,LESS,MOD,RPAREN,GREATER,DIV,AND,NEQ,LESSEQ,THEN,TIMES,DO,SEMICOLON,LPAREN,CARET,OR,RSQUAREB,EQ,ELSE,GREATEREQ,MINUS,RCURLYB,EOF, }
  (39) TimesExpr --> .UnaryExpr  { MINUS,TIMES,RPAREN,SEMICOLON,MOD,DIV,LESS,EOF,RCURLYB,OR,LESSEQ,COMMA,GREATER,AND,IN,DO,EQ,PLUS,ELSE,RSQUAREB,NEQ,CARET,GREATEREQ,THEN, }
state 131:
  (6) BlockStmt --> .LCURLYB Stmts RCURLYB  { Integer,Float,IF,IN,T_STRING,COMMA,NOT,LPAREN,ELSE,LET,RPAREN,THEN,T_INT,T_VOID,EOF,LCURLYB,WHILE,RSQUAREB,NEGATE,DO,DEFINE,StringLit,SEMICOLON,RCURLYB,PRINT,LSQUAREB,Var,T_FLOAT,LAMBDA, }
  (49) CompExpr --> .CompExpr LESSEQ PlusExpr  { GREATEREQ,DO,ELSE,RSQUAREB,IN,SEMICOLON,LESSEQ,EQ,RPAREN,GREATER,RCURLYB,NEQ,COMMA,OR,THEN,LESS,AND,EOF, }
  (31) ReturnType --> .T_VOID  { LAMBDA, }
  (42) RValue --> .LPAREN Expr RPAREN  { RCURLYB,MINUS,NEQ,AND,SEMICOLON,THEN,COMMA,ELSE,LESSEQ,PLUS,TIMES,LSQUAREB,DIV,MOD,LPAREN,GREATEREQ,GREATER,CARET,OR,LESS,EOF,IN,DO,RSQUAREB,EQ,RPAREN, }
  (56) TimesExpr --> .TimesExpr MOD UnaryExpr  { RSQUAREB,CARET,NEQ,LESS,TIMES,LESSEQ,COMMA,GREATEREQ,GREATER,RPAREN,ELSE,MOD,RCURLYB,EQ,EOF,IN,DO,MINUS,OR,SEMICOLON,PLUS,THEN,DIV,AND, }
  (39) TimesExpr --> .UnaryExpr  { TIMES,EOF,MINUS,GREATEREQ,COMMA,LESS,ELSE,EQ,OR,RCURLYB,NEQ,SEMICOLON,DIV,PLUS,MOD,THEN,RPAREN,GREATER,AND,DO,IN,RSQUAREB,CARET,LESSEQ, }
  (21) NonBlockExpr --> .WHILE Expr DO NonBlockExpr  { THEN,COMMA,EOF,RCURLYB,RSQUAREB,SEMICOLON,RPAREN,ELSE,IN,DO, }
  (61) RValue --> .RValue LPAREN ArgList RPAREN  { CARET,EOF,ELSE,GREATEREQ,LESS,RSQUAREB,DIV,MOD,RCURLYB,IN,RPAREN,LESSEQ,DO,PLUS,OR,LSQUAREB,TIMES,NEQ,EQ,SEMICOLON,AND,LPAREN,MINUS,THEN,GREATER,COMMA, }
  (67) RValue --> .Float  { DO,GREATER,LPAREN,AND,LESS,EQ,TIMES,PLUS,LSQUAREB,MINUS,COMMA,IN,RCURLYB,CARET,DIV,LESSEQ,EOF,ELSE,RPAREN,SEMICOLON,OR,MOD,THEN,RSQUAREB,GREATEREQ,NEQ, }
  (55) TimesExpr --> .TimesExpr DIV UnaryExpr  { COMMA,ELSE,EQ,RSQUAREB,THEN,AND,SEMICOLON,NEQ,LESS,PLUS,DO,GREATER,OR,GREATEREQ,CARET,LESSEQ,EOF,RPAREN,MINUS,TIMES,DIV,IN,MOD,RCURLYB, }
  (60) RValue --> .LValue LPAREN ArgList RPAREN  { TIMES,LSQUAREB,RCURLYB,AND,OR,MINUS,EQ,THEN,LESS,DO,COMMA,CARET,IN,SEMICOLON,ELSE,LESSEQ,LPAREN,PLUS,RPAREN,RSQUAREB,EOF,MOD,GREATEREQ,GREATER,NEQ,DIV, }
  (35) AndExpr --> .EqExpr  { OR,AND,IN,SEMICOLON,RSQUAREB,ELSE,THEN,RCURLYB,RPAREN,COMMA,DO,EOF, }
  (47) CompExpr --> .CompExpr LESS PlusExpr  { RCURLYB,GREATER,ELSE,NEQ,SEMICOLON,DO,THEN,EQ,OR,IN,COMMA,EOF,GREATEREQ,RSQUAREB,LESS,AND,LESSEQ,RPAREN, }
  (40) UnaryExpr --> .LValue  { AND,GREATER,RCURLYB,SEMICOLON,DIV,GREATEREQ,MOD,LESSEQ,CARET,TIMES,EQ,IN,THEN,RPAREN,ELSE,COMMA,OR,MINUS,RSQUAREB,NEQ,LESS,DO,PLUS,EOF, }
  (46) EqExpr --> .EqExpr NEQ CompExpr  { THEN,RCURLYB,SEMICOLON,OR,NEQ,DO,EOF,RSQUAREB,RPAREN,AND,IN,ELSE,EQ,COMMA, }
  (37) CompExpr --> .PlusExpr  { RCURLYB,EQ,OR,RPAREN,GREATEREQ,NEQ,RSQUAREB,THEN,GREATER,SEMICOLON,DO,ELSE,AND,COMMA,LESS,IN,EOF,LESSEQ, }
  (51) PlusExpr --> .PlusExpr PLUS TimesExpr  { COMMA,AND,GREATER,NEQ,GREATEREQ,MINUS,EQ,LESSEQ,SEMICOLON,RCURLYB,THEN,PLUS,RSQUAREB,ELSE,LESS,RPAREN,OR,CARET,EOF,IN,DO, }
  (24) LValue --> .Var  { COMMA,ASSIGN,DIV,RPAREN,THEN,MOD,GREATEREQ,AND,EQ,RSQUAREB,IN,LPAREN,LESS,LSQUAREB,GREATER,MINUS,SEMICOLON,DO,NEQ,PLUS,EOF,LESSEQ,OR,CARET,RCURLYB,ELSE,TIMES, }
  (52) PlusExpr --> .PlusExpr MINUS TimesExpr  { GREATEREQ,EOF,COMMA,LESSEQ,THEN,SEMICOLON,EQ,MINUS,RSQUAREB,CARET,OR,NEQ,AND,RPAREN,LESS,IN,ELSE,RCURLYB,DO,GREATER,PLUS, }
  (68) RValue --> .StringLit  { TIMES,OR,RSQUAREB,GREATEREQ,LESSEQ,LSQUAREB,LPAREN,SEMICOLON,ELSE,AND,LESS,DO,EOF,PLUS,GREATER,MOD,CARET,EQ,RPAREN,NEQ,THEN,MINUS,RCURLYB,DIV,IN,COMMA, }
  (57) UnaryExpr --> .NOT UnaryExpr  { EQ,MINUS,PLUS,GREATER,RSQUAREB,GREATEREQ,RCURLYB,NEQ,DO,DIV,LESS,RPAREN,THEN,COMMA,TIMES,SEMICOLON,IN,OR,CARET,AND,LESSEQ,EOF,MOD,ELSE, }
  (58) UnaryExpr --> .NEGATE UnaryExpr  { CARET,AND,LESS,EOF,MOD,OR,SEMICOLON,PLUS,THEN,TIMES,ELSE,LESSEQ,GREATEREQ,GREATER,RSQUAREB,MINUS,DIV,RCURLYB,EQ,DO,IN,RPAREN,NEQ,COMMA, }
  (26) NonBlockExpr --> .LAMBDA ParamList DOT Expr  { RSQUAREB,RPAREN,ELSE,COMMA,RCURLYB,SEMICOLON,DO,EOF,IN,THEN, }
  (16) BlockExpr --> .BlockStmt  { T_STRING,RSQUAREB,RPAREN,StringLit,LCURLYB,Float,IF,T_VOID,ELSE,LPAREN,THEN,Var,LET,Integer,COMMA,NOT,DO,EOF,LAMBDA,PRINT,RCURLYB,NEGATE,DEFINE,WHILE,SEMICOLON,IN,T_FLOAT,LSQUAREB,T_INT, }
  (38) PlusExpr --> .TimesExpr  { SEMICOLON,LESSEQ,MINUS,IN,COMMA,EQ,GREATER,CARET,NEQ,PLUS,LESS,THEN,ELSE,RSQUAREB,GREATEREQ,AND,OR,RPAREN,DO,EOF,RCURLYB, }
  (25) LValue --> .LValue LSQUAREB Expr RSQUAREB  { TIMES,DO,LESSEQ,LSQUAREB,EOF,THEN,EQ,RCURLYB,SEMICOLON,MINUS,ELSE,RPAREN,OR,NEQ,IN,MOD,AND,CARET,COMMA,GREATER,RSQUAREB,LPAREN,PLUS,GREATEREQ,LESS,ASSIGN,DIV, }
  (33) NonBlockExpr --> .OrExpr  { ELSE,THEN,DO,RPAREN,EOF,RSQUAREB,COMMA,RCURLYB,SEMICOLON,IN, }
  (50) CompExpr --> .CompExpr GREATEREQ PlusExpr  { RPAREN,COMMA,IN,ELSE,EQ,THEN,EOF,LESS,NEQ,AND,GREATER,GREATEREQ,SEMICOLON,LESSEQ,RCURLYB,RSQUAREB,DO,OR, }
  (45) EqExpr --> .EqExpr EQ CompExpr  { THEN,RSQUAREB,RCURLYB,EOF,IN,EQ,COMMA,NEQ,OR,SEMICOLON,DO,RPAREN,AND,ELSE, }
  (17) BlockExpr --> IF Expr THEN Expr ELSE .BlockExpr  { T_INT,T_VOID,PRINT,NOT,COMMA,LSQUAREB,Integer,WHILE,LCURLYB,ELSE,T_STRING,StringLit,RSQUAREB,SEMICOLON,T_FLOAT,RCURLYB,LPAREN,IF,RPAREN,DO,THEN,DEFINE,LET,IN,Float,EOF,Var,LAMBDA,NEGATE, }
  (17) BlockExpr --> .IF Expr THEN Expr ELSE BlockExpr  { T_VOID,Var,NOT,SEMICOLON,RCURLYB,NEGATE,PRINT,LAMBDA,T_STRING,Float,DO,THEN,LCURLYB,WHILE,EOF,LSQUAREB,IF,T_FLOAT,StringLit,DEFINE,LET,Integer,COMMA,ELSE,RPAREN,RSQUAREB,LPAREN,T_INT,IN, }
  (27) NonBlockExpr --> .ReturnType LAMBDA ParamList DOT Expr  { IN,EOF,SEMICOLON,ELSE,DO,RPAREN,COMMA,RCURLYB,RSQUAREB,THEN, }
  (62) RValue --> .RValue LSQUAREB Expr RSQUAREB  { GREATEREQ,DO,COMMA,GREATER,LSQUAREB,MINUS,IN,RCURLYB,DIV,LESS,AND,PLUS,TIMES,THEN,RPAREN,SEMICOLON,LESSEQ,ELSE,MOD,RSQUAREB,NEQ,OR,EQ,LPAREN,EOF,CARET, }
  (22) NonBlockExpr --> .LET Param ASSIGN Expr IN NonBlockExpr  { SEMICOLON,RSQUAREB,ELSE,IN,EOF,RPAREN,THEN,DO,RCURLYB,COMMA, }
  (32) ReturnType --> .Type  { LAMBDA, }
  (66) RValue --> .Integer  { LPAREN,TIMES,OR,LESSEQ,ELSE,CARET,EQ,GREATER,GREATEREQ,LSQUAREB,RPAREN,THEN,EOF,DO,IN,LESS,COMMA,SEMICOLON,RCURLYB,DIV,NEQ,PLUS,MOD,RSQUAREB,AND,MINUS, }
  (72) Type --> .T_FLOAT  { LSQUAREB,LAMBDA, }
  (71) Type --> .T_INT  { LAMBDA,LSQUAREB, }
  (23) NonBlockExpr --> .LValue ASSIGN Expr  { COMMA,SEMICOLON,EOF,THEN,RPAREN,RCURLYB,IN,ELSE,RSQUAREB,DO, }
  (69) RValue --> .LSQUAREB ArgList RSQUAREB  { THEN,LESSEQ,OR,ELSE,RCURLYB,LSQUAREB,GREATER,AND,MOD,EQ,DO,NEQ,SEMICOLON,TIMES,COMMA,EOF,DIV,LESS,RPAREN,RSQUAREB,PLUS,LPAREN,CARET,GREATEREQ,IN,MINUS, }
  (48) CompExpr --> .CompExpr GREATER PlusExpr  { RSQUAREB,LESSEQ,IN,OR,SEMICOLON,GREATER,AND,THEN,COMMA,DO,GREATEREQ,EQ,ELSE,EOF,LESS,RCURLYB,NEQ,RPAREN, }
  (36) EqExpr --> .CompExpr  { SEMICOLON,OR,DO,EOF,RPAREN,RSQUAREB,AND,NEQ,RCURLYB,COMMA,IN,ELSE,THEN,EQ, }
  (20) NonBlockExpr --> .IF Expr THEN Expr ELSE NonBlockExpr  { RSQUAREB,SEMICOLON,RCURLYB,DO,EOF,COMMA,ELSE,RPAREN,THEN,IN, }
  (70) RValue --> .LSQUAREB Expr SEMICOLON Expr RSQUAREB  { CARET,IN,THEN,TIMES,NEQ,LESS,EOF,OR,AND,DIV,DO,LESSEQ,RPAREN,LPAREN,EQ,GREATEREQ,RSQUAREB,MINUS,SEMICOLON,MOD,LSQUAREB,RCURLYB,ELSE,GREATER,COMMA,PLUS, }
  (54) TimesExpr --> .TimesExpr TIMES UnaryExpr  { IN,COMMA,THEN,GREATER,RPAREN,RCURLYB,ELSE,LESS,TIMES,PLUS,OR,LESSEQ,EQ,EOF,DIV,GREATEREQ,DO,MOD,CARET,RSQUAREB,AND,NEQ,SEMICOLON,MINUS, }
  (74) Type --> .Type LSQUAREB RSQUAREB  { LAMBDA,LSQUAREB, }
  (59) UnaryExpr --> .PRINT UnaryExpr  { GREATEREQ,IN,GREATER,LESS,EOF,RCURLYB,OR,EQ,PLUS,ELSE,MOD,DIV,COMMA,RSQUAREB,DO,CARET,SEMICOLON,THEN,LESSEQ,TIMES,RPAREN,NEQ,MINUS,AND, }
  (73) Type --> .T_STRING  { LAMBDA,LSQUAREB, }
  (41) UnaryExpr --> .RValue  { LESS,GREATEREQ,OR,EOF,RSQUAREB,THEN,NEQ,TIMES,AND,DO,DIV,COMMA,MINUS,PLUS,EQ,LESSEQ,GREATER,RPAREN,MOD,IN,ELSE,SEMICOLON,RCURLYB,CARET, }
  (20) NonBlockExpr --> IF Expr THEN Expr ELSE .NonBlockExpr  { RSQUAREB,IN,DO,COMMA,RCURLYB,RPAREN,THEN,EOF,ELSE,SEMICOLON, }
  (44) AndExpr --> .AndExpr AND EqExpr  { THEN,ELSE,EOF,SEMICOLON,RSQUAREB,OR,RPAREN,RCURLYB,COMMA,DO,IN,AND, }
  (43) OrExpr --> .OrExpr OR AndExpr  { SEMICOLON,RCURLYB,DO,THEN,RSQUAREB,IN,EOF,RPAREN,OR,COMMA,ELSE, }
  (18) BlockExpr --> .WHILE Expr DO BlockExpr  { T_STRING,EOF,SEMICOLON,DO,NOT,RCURLYB,PRINT,RSQUAREB,Float,ELSE,THEN,Integer,DEFINE,LCURLYB,LET,T_FLOAT,T_VOID,IF,COMMA,WHILE,StringLit,LPAREN,Var,NEGATE,T_INT,RPAREN,LSQUAREB,LAMBDA,IN, }
  (34) OrExpr --> .AndExpr  { SEMICOLON,OR,DO,COMMA,RPAREN,RCURLYB,ELSE,RSQUAREB,EOF,THEN,IN, }
  (19) BlockExpr --> .LET Param ASSIGN Expr IN BlockExpr  { T_VOID,IN,Var,WHILE,T_INT,StringLit,LET,DO,COMMA,THEN,T_FLOAT,T_STRING,Integer,ELSE,NOT,RSQUAREB,SEMICOLON,LAMBDA,DEFINE,NEGATE,LCURLYB,IF,LSQUAREB,LPAREN,PRINT,Float,RCURLYB,EOF,RPAREN, }
  (53) PlusExpr --> .PlusExpr CARET TimesExpr  { SEMICOLON,RCURLYB,RPAREN,IN,LESSEQ,ELSE,LESS,THEN,CARET,COMMA,DO,GREATER,AND,EQ,RSQUAREB,NEQ,OR,GREATEREQ,PLUS,MINUS,EOF, }
state 132:
  (70) RValue --> LSQUAREB Expr SEMICOLON Expr RSQUAREB .  { DIV,NEQ,MINUS,SEMICOLON,CARET,PLUS,IN,ELSE,LPAREN,COMMA,EQ,RCURLYB,LESS,THEN,MOD,GREATER,TIMES,GREATEREQ,RPAREN,DO,LSQUAREB,AND,OR,EOF,LESSEQ,RSQUAREB, }
state 133:
  (27) NonBlockExpr --> ReturnType LAMBDA ParamList DOT Expr .  { RPAREN,EOF,RSQUAREB,SEMICOLON,ELSE,DO,IN,THEN,COMMA,RCURLYB, }
state 134:
  (19) BlockExpr --> LET Param ASSIGN Expr IN BlockExpr .  { LET,SEMICOLON,DO,THEN,IN,Float,IF,RCURLYB,WHILE,RPAREN,LPAREN,NOT,COMMA,PRINT,Var,EOF,DEFINE,ELSE,T_STRING,T_FLOAT,RSQUAREB,NEGATE,LAMBDA,T_VOID,LSQUAREB,T_INT,StringLit,LCURLYB,Integer, }
state 135:
  (22) NonBlockExpr --> LET Param ASSIGN Expr IN NonBlockExpr .  { THEN,SEMICOLON,COMMA,RCURLYB,ELSE,IN,RPAREN,DO,EOF,RSQUAREB, }
state 136:
  (20) NonBlockExpr --> IF Expr THEN Expr ELSE NonBlockExpr .  { EOF,THEN,COMMA,IN,RPAREN,DO,SEMICOLON,ELSE,RCURLYB,RSQUAREB, }
state 137:
  (17) BlockExpr --> IF Expr THEN Expr ELSE BlockExpr .  { Var,Float,RPAREN,NEGATE,LSQUAREB,EOF,NOT,LPAREN,IN,LAMBDA,THEN,LET,SEMICOLON,IF,T_INT,RCURLYB,DO,T_FLOAT,T_STRING,DEFINE,StringLit,RSQUAREB,WHILE,Integer,COMMA,T_VOID,LCURLYB,PRINT,ELSE, }
2227 total state table entries
Created todd.lex
Parser saved in toddparser.fs