rustlr 0.2.1

trace-level set to 4
parsing grammar from mg.grammar
computing Nullable set
computing First sets
Generating LALR state machine for grammar mg...
Reduce-Reduce Conflict conflicted detected between rules 18 and 7, resolved in favor of 7
  (Rule 7) E --> E - E  , lookahead &&
  (Rule 18) E --> - E  , lookahead &&
Reduce-Reduce Conflict conflicted detected between rules 18 and 7, resolved in favor of 7
  (Rule 7) E --> E - E  , lookahead OROR
  (Rule 18) E --> - E  , lookahead OROR
Reduce-Reduce Conflict conflicted detected between rules 7 and 18, resolved in favor of 7
  (Rule 18) E --> - E  , lookahead <=
  (Rule 7) E --> E - E  , lookahead <=
Reduce-Reduce Conflict conflicted detected between rules 18 and 7, resolved in favor of 7
  (Rule 7) E --> E - E  , lookahead ;
  (Rule 18) E --> - E  , lookahead ;
Reduce-Reduce Conflict conflicted detected between rules 7 and 18, resolved in favor of 7
  (Rule 18) E --> - E  , lookahead +
  (Rule 7) E --> E - E  , lookahead +
Reduce-Reduce Conflict conflicted detected between rules 18 and 7, resolved in favor of 7
  (Rule 7) E --> E - E  , lookahead %
  (Rule 18) E --> - E  , lookahead %
Reduce-Reduce Conflict conflicted detected between rules 18 and 7, resolved in favor of 7
  (Rule 7) E --> E - E  , lookahead /
  (Rule 18) E --> - E  , lookahead /
Reduce-Reduce Conflict conflicted detected between rules 18 and 7, resolved in favor of 7
  (Rule 7) E --> E - E  , lookahead ==
  (Rule 18) E --> - E  , lookahead ==
Reduce-Reduce Conflict conflicted detected between rules 7 and 18, resolved in favor of 7
  (Rule 18) E --> - E  , lookahead ^
  (Rule 7) E --> E - E  , lookahead ^
Reduce-Reduce Conflict conflicted detected between rules 7 and 18, resolved in favor of 7
  (Rule 18) E --> - E  , lookahead -
  (Rule 7) E --> E - E  , lookahead -
Reduce-Reduce Conflict conflicted detected between rules 18 and 7, resolved in favor of 7
  (Rule 7) E --> E - E  , lookahead <
  (Rule 18) E --> - E  , lookahead <
Reduce-Reduce Conflict conflicted detected between rules 7 and 18, resolved in favor of 7
  (Rule 18) E --> - E  , lookahead *
  (Rule 7) E --> E - E  , lookahead *
Reduce-Reduce Conflict conflicted detected between rules 24 and 26, resolved in favor of 24
  (Rule 26) ES --> E ; ES  , lookahead *
  (Rule 24) E --> E ; ES  , lookahead *
Reduce-Reduce Conflict conflicted detected between rules 26 and 24, resolved in favor of 24
  (Rule 24) E --> E ; ES  , lookahead ^
  (Rule 26) ES --> E ; ES  , lookahead ^
Reduce-Reduce Conflict conflicted detected between rules 26 and 24, resolved in favor of 24
  (Rule 24) E --> E ; ES  , lookahead %
  (Rule 26) ES --> E ; ES  , lookahead %
Reduce-Reduce Conflict conflicted detected between rules 24 and 26, resolved in favor of 24
  (Rule 26) ES --> E ; ES  , lookahead <=
  (Rule 24) E --> E ; ES  , lookahead <=
Reduce-Reduce Conflict conflicted detected between rules 24 and 26, resolved in favor of 24
  (Rule 26) ES --> E ; ES  , lookahead +
  (Rule 24) E --> E ; ES  , lookahead +
Reduce-Reduce Conflict conflicted detected between rules 24 and 26, resolved in favor of 24
  (Rule 26) ES --> E ; ES  , lookahead ;
  (Rule 24) E --> E ; ES  , lookahead ;
Reduce-Reduce Conflict conflicted detected between rules 24 and 26, resolved in favor of 24
  (Rule 26) ES --> E ; ES  , lookahead <
  (Rule 24) E --> E ; ES  , lookahead <
Reduce-Reduce Conflict conflicted detected between rules 24 and 26, resolved in favor of 24
  (Rule 26) ES --> E ; ES  , lookahead /
  (Rule 24) E --> E ; ES  , lookahead /
Reduce-Reduce Conflict conflicted detected between rules 24 and 26, resolved in favor of 24
  (Rule 26) ES --> E ; ES  , lookahead OROR
  (Rule 24) E --> E ; ES  , lookahead OROR
Reduce-Reduce Conflict conflicted detected between rules 24 and 26, resolved in favor of 24
  (Rule 26) ES --> E ; ES  , lookahead &&
  (Rule 24) E --> E ; ES  , lookahead &&
Reduce-Reduce Conflict conflicted detected between rules 26 and 24, resolved in favor of 24
  (Rule 24) E --> E ; ES  , lookahead ==
  (Rule 26) ES --> E ; ES  , lookahead ==
Reduce-Reduce Conflict conflicted detected between rules 24 and 26, resolved in favor of 24
  (Rule 26) ES --> E ; ES  , lookahead -
  (Rule 24) E --> E ; ES  , lookahead -
Reduce-Reduce Conflict conflicted detected between rules 24 and 26, resolved in favor of 24
  (Rule 26) ES --> E ; ES  , lookahead ==
  (Rule 24) E --> E ; ES  , lookahead ==
Reduce-Reduce Conflict conflicted detected between rules 24 and 26, resolved in favor of 24
  (Rule 26) ES --> E ; ES  , lookahead -
  (Rule 24) E --> E ; ES  , lookahead -
Reduce-Reduce Conflict conflicted detected between rules 24 and 26, resolved in favor of 24
  (Rule 26) ES --> E ; ES  , lookahead +
  (Rule 24) E --> E ; ES  , lookahead +
Reduce-Reduce Conflict conflicted detected between rules 24 and 26, resolved in favor of 24
  (Rule 26) ES --> E ; ES  , lookahead ^
  (Rule 24) E --> E ; ES  , lookahead ^
Reduce-Reduce Conflict conflicted detected between rules 24 and 26, resolved in favor of 24
  (Rule 26) ES --> E ; ES  , lookahead &&
  (Rule 24) E --> E ; ES  , lookahead &&
Reduce-Reduce Conflict conflicted detected between rules 24 and 26, resolved in favor of 24
  (Rule 26) ES --> E ; ES  , lookahead /
  (Rule 24) E --> E ; ES  , lookahead /
Reduce-Reduce Conflict conflicted detected between rules 24 and 26, resolved in favor of 24
  (Rule 26) ES --> E ; ES  , lookahead ;
  (Rule 24) E --> E ; ES  , lookahead ;
Reduce-Reduce Conflict conflicted detected between rules 24 and 26, resolved in favor of 24
  (Rule 26) ES --> E ; ES  , lookahead %
  (Rule 24) E --> E ; ES  , lookahead %
Reduce-Reduce Conflict conflicted detected between rules 24 and 26, resolved in favor of 24
  (Rule 26) ES --> E ; ES  , lookahead OROR
  (Rule 24) E --> E ; ES  , lookahead OROR
Reduce-Reduce Conflict conflicted detected between rules 24 and 26, resolved in favor of 24
  (Rule 26) ES --> E ; ES  , lookahead <=
  (Rule 24) E --> E ; ES  , lookahead <=
Reduce-Reduce Conflict conflicted detected between rules 24 and 26, resolved in favor of 24
  (Rule 26) ES --> E ; ES  , lookahead *
  (Rule 24) E --> E ; ES  , lookahead *
Reduce-Reduce Conflict conflicted detected between rules 24 and 26, resolved in favor of 24
  (Rule 26) ES --> E ; ES  , lookahead <
  (Rule 24) E --> E ; ES  , lookahead <
Reduce-Reduce Conflict conflicted detected between rules 24 and 26, resolved in favor of 24
  (Rule 26) ES --> E ; ES  , lookahead <=
  (Rule 24) E --> E ; ES  , lookahead <=
Reduce-Reduce Conflict conflicted detected between rules 24 and 26, resolved in favor of 24
  (Rule 26) ES --> E ; ES  , lookahead &&
  (Rule 24) E --> E ; ES  , lookahead &&
Reduce-Reduce Conflict conflicted detected between rules 24 and 26, resolved in favor of 24
  (Rule 26) ES --> E ; ES  , lookahead +
  (Rule 24) E --> E ; ES  , lookahead +
Reduce-Reduce Conflict conflicted detected between rules 24 and 26, resolved in favor of 24
  (Rule 26) ES --> E ; ES  , lookahead ^
  (Rule 24) E --> E ; ES  , lookahead ^
Reduce-Reduce Conflict conflicted detected between rules 24 and 26, resolved in favor of 24
  (Rule 26) ES --> E ; ES  , lookahead ==
  (Rule 24) E --> E ; ES  , lookahead ==
Reduce-Reduce Conflict conflicted detected between rules 24 and 26, resolved in favor of 24
  (Rule 26) ES --> E ; ES  , lookahead OROR
  (Rule 24) E --> E ; ES  , lookahead OROR
Reduce-Reduce Conflict conflicted detected between rules 24 and 26, resolved in favor of 24
  (Rule 26) ES --> E ; ES  , lookahead %
  (Rule 24) E --> E ; ES  , lookahead %
Reduce-Reduce Conflict conflicted detected between rules 24 and 26, resolved in favor of 24
  (Rule 26) ES --> E ; ES  , lookahead ;
  (Rule 24) E --> E ; ES  , lookahead ;
Reduce-Reduce Conflict conflicted detected between rules 24 and 26, resolved in favor of 24
  (Rule 26) ES --> E ; ES  , lookahead /
  (Rule 24) E --> E ; ES  , lookahead /
Reduce-Reduce Conflict conflicted detected between rules 24 and 26, resolved in favor of 24
  (Rule 26) ES --> E ; ES  , lookahead <
  (Rule 24) E --> E ; ES  , lookahead <
Reduce-Reduce Conflict conflicted detected between rules 24 and 26, resolved in favor of 24
  (Rule 26) ES --> E ; ES  , lookahead -
  (Rule 24) E --> E ; ES  , lookahead -
Reduce-Reduce Conflict conflicted detected between rules 24 and 26, resolved in favor of 24
  (Rule 26) ES --> E ; ES  , lookahead *
  (Rule 24) E --> E ; ES  , lookahead *
state 0:
  (14) E --> .E <= E   { *,;,<=,-,EOF,/,+,OROR,==,^,<,%,&&, }
  (17) E --> .E OROR E   { ^,OROR,%,==,<,*,+,;,EOF,&&,/,<=,-, }
  (15) E --> .while ( E ) E   { ^,+,-,EOF,==,OROR,;,*,<,%,&&,/,<=, }
  (5) E --> .cout E   { ^,;,EOF,<,&&,*,/,OROR,%,-,<=,==,+, }
  (8) E --> .E * E   { -,*,OROR,<,/,EOF,+,&&,^,;,<=,==,%, }
  (16) E --> .E && E   { ;,<,+,%,==,/,&&,OROR,EOF,*,<=,-,^, }
  (20) E --> .let Var = E COLON E   { -,&&,*,^,OROR,/,<=,%,;,==,<,EOF,+, }
  (18) E --> .- E   { +,/,%,EOF,^,<,*,==,OROR,;,-,&&,<=, }
  (9) E --> .E / E   { %,OROR,^,==,EOF,;,-,*,&&,/,<,<=,+, }
  (22) E --> .lambda Var . E   { ==,%,EOF,<,^,&&,OROR,;,-,+,*,<=,/, }
  (12) E --> .E == E   { ==,OROR,<=,<,&&,EOF,^,%,*,+,-,/,;, }
  (21) E --> .Var = E   { OROR,+,-,&&,<,<=,*,EOF,/,^,%,;,==, }
  (6) E --> .E + E   { ^,*,==,;,EOF,&&,<=,OROR,+,<,/,%,-, }
  (3) E --> .cin   { *,OROR,<=,%,==,;,+,EOF,-,<,^,/,&&, }
  (7) E --> .E - E   { *,%,<,-,/,+,OROR,==,^,&&,EOF,<=,;, }
  (2) E --> .( Var E )   { ;,/,<,+,==,%,EOF,*,&&,^,OROR,<=,-, }
  (23) E --> .if E E else E   { <,EOF,-,==,;,%,^,&&,+,OROR,/,*,<=, }
  (13) E --> .E < E   { %,<,&&,-,==,/,;,<=,+,*,OROR,EOF,^, }
  (28) START --> .E   { EOF, }
  (19) E --> .! E   { OROR,;,==,&&,^,<,%,<=,EOF,*,-,+,/, }
  (0) E --> .Val   { EOF,*,<=,^,OROR,==,&&,;,/,-,<,+,%, }
  (1) E --> .( E )   { OROR,;,==,*,+,/,-,^,&&,<,%,<=,EOF, }
  (11) E --> .E ^ E   { +,EOF,OROR,==,*,/,<=,^,;,<,%,&&,-, }
  (24) E --> .E ; ES   { /,<,%,+,&&,;,-,==,*,^,OROR,<=,EOF, }
  (10) E --> .E % E   { /,-,==,%,<,&&,;,<=,*,EOF,OROR,^,+, }
  (4) E --> .cout Str   { <,OROR,;,^,EOF,/,==,-,<=,&&,*,%,+, }
  (27) E --> .Var   { -,^,EOF,<,;,==,+,<=,%,*,&&,/,OROR, }
state 1:
  (11) E --> E .^ E   { <=,-,+,==,;,/,EOF,%,&&,^,OROR,<,*, }
  (8) E --> E .* E   { %,/,<=,EOF,*,-,<,==,OROR,+,&&,;,^, }
  (7) E --> E .- E   { ;,OROR,&&,EOF,<,==,^,%,<=,-,+,*,/, }
  (12) E --> E .== E   { <=,EOF,==,%,+,-,*,<,&&,/,^,;,OROR, }
  (6) E --> E .+ E   { -,%,^,/,&&,<,EOF,OROR,*,==,;,<=,+, }
  (24) E --> E .; ES   { +,/,&&,*,;,==,%,EOF,<,^,OROR,-,<=, }
  (16) E --> E .&& E   { ==,EOF,<=,^,+,*,/,OROR,;,<,%,&&,-, }
  (13) E --> E .< E   { +,&&,*,<,^,==,%,OROR,EOF,;,-,/,<=, }
  (10) E --> E .% E   { ^,<,&&,;,<=,OROR,==,EOF,/,*,-,+,%, }
  (17) E --> E .OROR E   { OROR,/,%,;,<,<=,*,==,+,EOF,-,&&,^, }
  (9) E --> E ./ E   { %,&&,-,<=,OROR,+,;,^,<,==,/,EOF,*, }
  (14) E --> E .<= E   { &&,;,-,%,EOF,/,==,OROR,^,*,+,<=,<, }
  (28) START --> E .   { EOF, }
state 2:
  (22) E --> lambda .Var . E   { EOF,COLON,Var,&&,cin,<,OROR,^,lambda,<=,let,else,cout,;,if,*,-,%,/,Val,(,while,==,),+,!, }
state 3:
  (2) E --> .( Var E )   { lambda,+,while,==,OROR,else,%,(,let,^,COLON,/,cin,if,<=,-,cout,Var,<,*,Val,),&&,;,!,EOF, }
  (22) E --> .lambda Var . E   { if,^,-,while,%,!,Val,+,Var,OROR,(,==,<,/,cout,lambda,<=,;,let,COLON,cin,*,&&,),else,EOF, }
  (5) E --> .cout E   { <=,),*,^,lambda,Val,+,let,Var,if,&&,EOF,cin,while,(,/,<,!,COLON,OROR,-,==,%,cout,else,;, }
  (24) E --> .E ; ES   { if,<=,&&,;,),==,%,Val,lambda,Var,(,-,while,else,/,cout,^,EOF,<,!,+,*,let,cin,OROR,COLON, }
  (4) E --> .cout Str   { Var,<,OROR,<=,+,%,lambda,cout,-,!,let,==,if,^,;,COLON,cin,),(,&&,*,Val,while,else,EOF,/, }
  (20) E --> .let Var = E COLON E   { OROR,lambda,Val,==,COLON,/,let,cin,;,+,while,%,else,&&,!,if,<=,cout,(,-,*,Var,EOF,<,),^, }
  (23) E --> .if E E else E   { (,else,==,EOF,-,Var,<=,COLON,),*,cout,if,Val,&&,let,<,cin,^,OROR,lambda,+,;,%,while,/,!, }
  (21) E --> .Var = E   { OROR,),==,<,&&,let,;,cin,while,*,/,COLON,lambda,(,EOF,%,^,+,else,Var,if,!,cout,<=,Val,-, }
  (11) E --> .E ^ E   { lambda,if,COLON,+,Var,EOF,let,OROR,),<=,-,(,!,else,^,cin,Val,cout,<,%,/,;,while,==,&&,*, }
  (10) E --> .E % E   { cin,(,),cout,OROR,<=,&&,;,/,EOF,lambda,*,%,^,!,Var,Val,else,COLON,let,-,while,<,==,+,if, }
  (13) E --> .E < E   { if,&&,else,==,*,%,cout,/,cin,OROR,EOF,COLON,while,),(,Var,<=,+,^,Val,-,!,;,<,let,lambda, }
  (0) E --> .Val   { if,<=,cin,&&,!,Var,Val,-,+,lambda,),(,COLON,EOF,OROR,while,%,cout,^,else,<,==,let,;,*,/, }
  (19) E --> ! .E   { <,EOF,*,-,Var,&&,OROR,^,),%,<=,+,while,cout,!,else,==,COLON,cin,;,Val,lambda,(,/,if,let, }
  (6) E --> .E + E   { ^,let,Val,<=,==,EOF,+,else,<,while,COLON,cout,Var,lambda,-,!,&&,if,),/,OROR,cin,*,(,;,%, }
  (9) E --> .E / E   { cin,cout,%,Var,!,-,if,^,<,(,while,*,COLON,;,<=,),+,else,/,&&,==,OROR,lambda,Val,EOF,let, }
  (14) E --> .E <= E   { -,OROR,Val,cin,*,^,lambda,<=,Var,&&,%,if,!,(,<,while,COLON,),EOF,+,/,;,cout,let,else,==, }
  (17) E --> .E OROR E   { OROR,;,<,*,%,lambda,Var,while,+,(,&&,if,cin,COLON,cout,else,!,^,-,EOF,Val,let,/,),<=,==, }
  (18) E --> .- E   { while,;,(,),*,let,Var,Val,<,^,&&,==,COLON,/,OROR,if,cin,-,<=,EOF,+,!,%,lambda,cout,else, }
  (27) E --> .Var   { -,&&,==,*,;,cin,%,cout,^,Var,<=,else,COLON,+,EOF,lambda,let,/,while,),(,!,Val,if,OROR,<, }
  (16) E --> .E && E   { /,&&,%,*,EOF,cout,!,if,COLON,(,;,-,==,let,Val,OROR,cin,^,lambda,else,while,+,),<,<=,Var, }
  (3) E --> .cin   { EOF,COLON,if,-,&&,<=,^,cin,Var,else,+,Val,while,!,<,%,let,cout,lambda,OROR,;,),(,==,/,*, }
  (12) E --> .E == E   { ==,%,^,+,OROR,while,Val,),Var,<,(,&&,/,if,COLON,let,cin,-,<=,lambda,cout,;,EOF,*,!,else, }
  (19) E --> .! E   { EOF,cin,OROR,else,lambda,Val,*,;,cout,Var,==,if,^,&&,(,-,COLON,%,/,!,let,),<=,<,while,+, }
  (8) E --> .E * E   { OROR,EOF,==,%,Var,+,!,Val,while,cin,^,lambda,-,else,*,if,&&,/,<=,let,<,;,COLON,(,cout,), }
  (7) E --> .E - E   { ;,(,if,cout,while,+,^,Var,Val,/,cin,EOF,%,<=,),&&,OROR,<,COLON,*,let,else,-,==,!,lambda, }
  (15) E --> .while ( E ) E   { &&,<=,!,<,+,/,cin,(,Var,lambda,-,;,COLON,while,EOF,%,),if,^,OROR,==,cout,else,Val,*,let, }
  (1) E --> .( E )   { cin,if,while,Val,<=,-,let,/,;,&&,+,cout,EOF,Var,==,COLON,),(,%,*,<,else,lambda,!,^,OROR, }
state 4:
  (1) E --> .( E )   { lambda,let,+,Val,;,-,&&,<=,cout,if,(,^,%,Var,<,!,*,while,/,OROR,cin,==, }
  (6) E --> .E + E   { Val,<=,+,-,while,cin,*,lambda,<,/,cout,&&,;,==,Var,!,OROR,^,(,if,let,%, }
  (17) E --> .E OROR E   { +,==,Val,^,if,<=,Var,;,cin,<,!,OROR,let,%,(,cout,*,&&,-,lambda,while,/, }
  (27) E --> .Var   { *,while,+,cout,<,Var,^,cin,;,%,==,!,OROR,(,if,Val,lambda,<=,/,-,let,&&, }
  (13) E --> .E < E   { Var,<=,%,!,OROR,^,(,cout,;,while,/,<,let,cin,-,*,if,&&,Val,+,==,lambda, }
  (9) E --> .E / E   { !,if,;,==,-,cout,%,&&,*,cin,/,Val,while,OROR,<=,^,<,Var,let,(,lambda,+, }
  (12) E --> .E == E   { if,!,/,-,OROR,(,cin,lambda,let,*,;,cout,%,<,+,Val,while,Var,==,^,&&,<=, }
  (14) E --> .E <= E   { OROR,/,==,cout,(,+,&&,while,<,lambda,cin,<=,*,if,;,^,Var,!,Val,-,%,let, }
  (8) E --> .E * E   { ;,<=,(,<,+,if,-,lambda,cin,&&,*,Var,Val,^,let,cout,while,==,!,OROR,%,/, }
  (20) E --> .let Var = E COLON E   { !,Val,*,^,+,Var,;,<,(,&&,cout,==,%,let,/,lambda,-,OROR,<=,while,if,cin, }
  (7) E --> .E - E   { &&,^,Val,%,<=,OROR,let,cout,;,if,!,/,<,Var,*,-,while,+,==,(,cin,lambda, }
  (21) E --> .Var = E   { -,;,OROR,Val,/,Var,<=,lambda,(,^,if,cout,cin,==,!,&&,while,%,<,*,let,+, }
  (4) E --> .cout Str   { <=,Val,Var,lambda,==,while,+,!,<,cout,&&,;,*,if,/,OROR,-,cin,(,^,%,let, }
  (22) E --> .lambda Var . E   { cout,+,Var,<,-,(,!,if,cin,while,;,*,let,/,&&,<=,OROR,Val,^,%,==,lambda, }
  (0) E --> .Val   { (,==,*,-,+,<,lambda,/,;,while,Val,let,%,if,&&,cout,cin,!,<=,OROR,Var,^, }
  (3) E --> .cin   { Val,if,lambda,Var,%,+,*,let,==,!,cout,/,cin,<,-,OROR,^,;,&&,while,<=,(, }
  (23) E --> .if E E else E   { &&,<,cin,+,let,if,Val,*,;,(,/,-,while,OROR,lambda,!,^,<=,%,Var,==,cout, }
  (5) E --> .cout E   { Val,;,<,while,^,==,&&,+,/,(,if,<=,*,let,Var,OROR,lambda,cout,-,!,cin,%, }
  (23) E --> if .E E else E   { ),*,!,cout,+,/,;,while,Val,lambda,(,%,let,else,COLON,EOF,if,^,-,cin,==,Var,<,<=,&&,OROR, }
  (18) E --> .- E   { !,Var,==,*,<=,<,;,Val,cin,/,%,while,&&,cout,lambda,(,+,OROR,-,if,let,^, }
  (15) E --> .while ( E ) E   { lambda,/,<=,<,(,;,==,*,-,cout,if,OROR,^,+,%,&&,!,Val,while,Var,cin,let, }
  (19) E --> .! E   { +,<,cout,;,Val,==,*,<=,while,Var,^,!,lambda,&&,if,cin,-,let,(,/,OROR,%, }
  (16) E --> .E && E   { cin,let,OROR,;,+,<=,*,(,!,-,if,%,&&,lambda,^,Var,/,Val,cout,while,==,<, }
  (2) E --> .( Var E )   { /,*,==,(,<,cin,Var,;,&&,!,Val,if,let,^,<=,cout,+,-,OROR,%,lambda,while, }
  (10) E --> .E % E   { let,/,^,-,<,!,OROR,%,while,Var,==,(,cout,lambda,+,*,if,<=,Val,;,cin,&&, }
  (24) E --> .E ; ES   { cout,==,&&,<=,while,%,;,<,let,^,!,OROR,/,-,+,lambda,if,Var,cin,Val,*,(, }
  (11) E --> .E ^ E   { &&,%,^,-,/,let,(,cout,<,+,==,OROR,if,Val,cin,*,while,<=,;,!,Var,lambda, }
state 5:
  (27) E --> .Var   { COLON,;,+,lambda,*,!,Var,(,OROR,<,/,let,else,EOF,<=,),==,-,if,%,cin,cout,Val,^,while,&&, }
  (13) E --> .E < E   { cin,Val,^,!,OROR,-,),==,COLON,lambda,Var,<,*,&&,else,%,<=,EOF,+,if,while,/,(,let,cout,;, }
  (18) E --> - .E   { %,;,cout,lambda,/,==,if,Val,let,OROR,cin,*,+,(,while,COLON,!,&&,<=,-,^,EOF,Var,),<,else, }
  (23) E --> .if E E else E   { EOF,COLON,%,/,cin,!,cout,&&,+,while,Var,;,<=,==,lambda,),if,let,(,-,*,Val,^,else,<,OROR, }
  (9) E --> .E / E   { +,;,==,%,cout,lambda,Val,<,COLON,EOF,let,!,<=,*,),if,(,else,&&,^,-,/,Var,OROR,cin,while, }
  (7) E --> .E - E   { %,cout,-,if,),lambda,!,cin,let,&&,while,/,<,Var,==,COLON,;,*,else,<=,EOF,Val,OROR,(,^,+, }
  (21) E --> .Var = E   { lambda,EOF,<,OROR,COLON,<=,),let,&&,else,-,!,(,*,+,if,/,^,==,Val,cout,;,cin,Var,%,while, }
  (14) E --> .E <= E   { Var,-,EOF,while,<=,%,!,/,cin,),<,let,Val,else,&&,;,COLON,OROR,+,lambda,(,cout,*,if,^,==, }
  (16) E --> .E && E   { Var,<,else,while,Val,EOF,cin,if,COLON,;,),+,^,&&,<=,!,lambda,%,cout,==,OROR,let,(,-,*,/, }
  (19) E --> .! E   { COLON,Var,Val,lambda,^,OROR,-,(,<,),*,while,/,else,let,cout,<=,;,+,%,&&,EOF,!,if,cin,==, }
  (15) E --> .while ( E ) E   { cout,EOF,cin,),<=,==,^,lambda,OROR,Val,/,!,let,Var,else,while,;,-,+,&&,COLON,<,*,(,if,%, }
  (8) E --> .E * E   { !,lambda,while,if,else,==,%,cout,(,&&,^,Var,*,OROR,EOF,-,+,<=,let,cin,;,/,<,),COLON,Val, }
  (18) E --> .- E   { if,==,lambda,&&,!,(,EOF,*,COLON,while,),Val,-,;,%,+,Var,<=,let,cout,<,cin,^,/,else,OROR, }
  (6) E --> .E + E   { <=,%,(,-,==,<,lambda,Var,),^,OROR,else,;,while,!,+,if,&&,Val,*,COLON,/,EOF,cin,let,cout, }
  (5) E --> .cout E   { else,),<=,if,!,cin,EOF,COLON,-,==,%,/,while,Val,&&,*,^,;,OROR,Var,+,let,lambda,<,(,cout, }
  (4) E --> .cout Str   { Val,==,&&,Var,-,else,^,;,),if,<=,*,+,COLON,let,!,/,cin,cout,OROR,EOF,lambda,%,<,while,(, }
  (0) E --> .Val   { <,let,OROR,==,/,cout,(,;,%,!,EOF,if,<=,Var,Val,else,lambda,COLON,cin,-,while,*,+,^,&&,), }
  (10) E --> .E % E   { let,Val,lambda,<=,&&,else,^,cin,;,),Var,!,==,+,while,/,cout,%,COLON,*,if,(,<,-,EOF,OROR, }
  (22) E --> .lambda Var . E   { %,while,else,!,==,COLON,Val,+,OROR,cout,(,<,if,^,EOF,cin,),Var,;,<=,lambda,-,*,&&,let,/, }
  (20) E --> .let Var = E COLON E   { -,if,OROR,^,while,;,cin,&&,(,else,let,Val,==,<=,),!,cout,COLON,/,%,Var,+,lambda,<,EOF,*, }
  (1) E --> .( E )   { cin,OROR,cout,while,-,if,Val,(,*,lambda,&&,EOF,%,Var,!,+,let,),/,==,^,<=,COLON,else,;,<, }
  (12) E --> .E == E   { ;,let,else,(,<=,OROR,-,^,&&,/,Val,%,cin,COLON,while,EOF,==,),cout,*,if,+,!,<,Var,lambda, }
  (3) E --> .cin   { !,==,OROR,while,EOF,lambda,let,/,if,Var,;,+,else,&&,),^,cin,COLON,<,(,cout,%,<=,Val,*,-, }
  (24) E --> .E ; ES   { *,(,^,cin,let,Val,),OROR,!,cout,<,-,else,;,<=,+,==,&&,lambda,/,EOF,Var,while,COLON,%,if, }
  (17) E --> .E OROR E   { &&,OROR,<,*,Var,;,if,-,!,+,COLON,cin,lambda,(,cout,%,/,EOF,^,let,),==,Val,<=,else,while, }
  (2) E --> .( Var E )   { %,(,cin,!,cout,<=,),-,<,&&,while,==,if,else,Var,^,+,EOF,;,OROR,/,*,let,lambda,Val,COLON, }
  (11) E --> .E ^ E   { cin,;,OROR,^,(,&&,%,<=,if,Val,-,*,COLON,let,EOF,==,else,cout,/,lambda,!,Var,<,),while,+, }
state 6:
  (0) E --> Val .   { !,;,^,<=,(,let,*,lambda,-,OROR,==,if,Var,EOF,<,/,+,),while,Val,COLON,cout,%,else,cin,&&, }
state 7:
  (27) E --> Var .   { !,COLON,/,Var,<,else,+,EOF,^,<=,;,(,while,if,cin,Val,OROR,==,-,lambda,cout,),%,&&,*,let, }
  (21) E --> Var .= E   { ==,cout,-,EOF,COLON,Var,/,OROR,cin,+,while,<,*,%,Val,else,let,),(,^,;,if,<=,&&,!,lambda, }
state 8:
  (15) E --> while .( E ) E   { else,+,Val,Var,<,COLON,-,;,lambda,OROR,while,<=,let,&&,cin,),cout,/,^,%,==,EOF,!,if,(,*, }
state 9:
  (4) E --> cout .Str   { ;,(,Val,if,lambda,cin,!,^,%,<,==,let,+,while,cout,-,&&,Var,COLON,*,),EOF,else,/,OROR,<=, }
  (0) E --> .Val   { <,%,Val,!,-,cout,<=,if,+,),cin,&&,OROR,COLON,/,;,*,let,EOF,else,^,lambda,==,while,(,Var, }
  (8) E --> .E * E   { %,OROR,let,EOF,lambda,!,(,if,==,),*,<,&&,else,^,;,+,<=,/,cin,COLON,Var,cout,while,Val,-, }
  (9) E --> .E / E   { let,+,while,*,==,COLON,else,<=,/,(,),Val,cout,%,Var,OROR,if,&&,;,EOF,-,<,^,cin,lambda,!, }
  (5) E --> .cout E   { COLON,),while,==,Val,!,cout,if,&&,<,-,else,(,cin,Var,OROR,%,^,/,+,let,lambda,EOF,;,<=,*, }
  (2) E --> .( Var E )   { Var,EOF,<=,+,),else,cin,while,(,!,if,%,/,lambda,-,==,COLON,^,cout,;,&&,let,Val,*,OROR,<, }
  (24) E --> .E ; ES   { +,EOF,else,Var,if,!,==,cout,;,/,<,OROR,*,Val,^,while,cin,<=,&&,),-,lambda,%,let,(,COLON, }
  (11) E --> .E ^ E   { &&,Val,==,let,else,/,-,),+,;,COLON,*,!,EOF,Var,while,cin,(,if,%,^,<,<=,OROR,lambda,cout, }
  (13) E --> .E < E   { while,cout,COLON,let,&&,Var,),+,%,;,(,^,==,-,EOF,*,!,else,if,OROR,<,<=,lambda,/,Val,cin, }
  (23) E --> .if E E else E   { else,<,cin,Var,<=,-,if,(,lambda,Val,let,cout,/,OROR,+,EOF,^,),while,!,==,*,;,&&,COLON,%, }
  (4) E --> .cout Str   { lambda,;,<=,let,if,+,<,(,Var,!,COLON,EOF,cout,/,while,-,Val,%,^,*,),OROR,==,&&,else,cin, }
  (10) E --> .E % E   { !,^,*,%,if,EOF,else,&&,/,let,<,while,OROR,lambda,Var,==,Val,-,;,cin,cout,+,<=,(,COLON,), }
  (5) E --> cout .E   { !,COLON,Var,Val,(,-,<=,OROR,%,+,lambda,while,else,cout,),EOF,if,^,let,*,==,<,cin,/,&&,;, }
  (19) E --> .! E   { ^,(,+,lambda,while,COLON,<,cout,-,;,Val,if,),else,Var,EOF,/,OROR,&&,==,%,!,*,<=,let,cin, }
  (6) E --> .E + E   { else,*,/,==,OROR,<,%,;,&&,while,),Val,Var,EOF,let,<=,COLON,+,if,lambda,^,cout,-,cin,!,(, }
  (15) E --> .while ( E ) E   { lambda,if,else,),Val,&&,%,cin,<,^,<=,EOF,(,/,OROR,+,COLON,==,Var,let,while,;,!,*,-,cout, }
  (20) E --> .let Var = E COLON E   { -,EOF,+,if,<=,&&,/,while,!,),^,cout,OROR,else,==,Var,Val,%,(,cin,COLON,let,lambda,<,;,*, }
  (3) E --> .cin   { Val,OROR,cout,*,EOF,;,<=,),-,%,/,<,if,Var,!,lambda,^,let,while,==,cin,&&,(,COLON,else,+, }
  (18) E --> .- E   { cout,-,&&,cin,!,(,lambda,<,+,let,<=,while,Var,OROR,*,==,%,EOF,else,Val,/,COLON,^,;,),if, }
  (21) E --> .Var = E   { &&,let,COLON,+,-,(,lambda,^,if,else,;,<=,cout,Var,==,*,<,cin,!,%,Val,while,),OROR,/,EOF, }
  (17) E --> .E OROR E   { +,&&,Var,!,cout,Val,lambda,),EOF,/,%,cin,else,while,COLON,let,OROR,*,;,<=,==,-,<,if,(,^, }
  (12) E --> .E == E   { EOF,while,Var,%,<,(,+,OROR,COLON,lambda,!,^,*,==,cin,let,;,&&,cout,<=,else,/,-,Val,if,), }
  (16) E --> .E && E   { *,+,while,else,!,Var,==,%,&&,<,EOF,^,(,Val,if,cout,-,/,),OROR,cin,COLON,<=,lambda,let,;, }
  (27) E --> .Var   { %,;,let,==,(,&&,),cin,while,else,+,cout,EOF,<=,Val,lambda,<,Var,if,OROR,COLON,-,^,!,/,*, }
  (22) E --> .lambda Var . E   { let,<=,Var,cin,^,<,),/,lambda,if,-,COLON,(,;,%,else,==,&&,*,Val,EOF,!,cout,while,+,OROR, }
  (14) E --> .E <= E   { &&,else,OROR,if,-,Var,Val,+,),<,!,EOF,/,COLON,<=,while,cin,;,%,let,==,lambda,^,(,cout,*, }
  (7) E --> .E - E   { else,*,<,OROR,^,%,-,lambda,;,),cout,COLON,Var,Val,&&,==,/,+,!,EOF,cin,<=,if,(,let,while, }
  (1) E --> .( E )   { let,),lambda,else,OROR,^,/,==,(,<,-,%,Var,EOF,cout,if,COLON,Val,while,*,!,;,cin,<=,+,&&, }
state 10:
  (3) E --> cin .   { &&,<,lambda,<=,else,==,),COLON,^,EOF,+,;,cin,OROR,while,!,let,/,Val,if,*,-,%,Var,(,cout, }
state 11:
  (1) E --> .( E )   { ^,%,==,-,),<,&&,<=,*,+,OROR,/,;, }
  (8) E --> .E * E   { <,;,-,==,+,),*,<=,OROR,^,%,&&,/, }
  (22) E --> .lambda Var . E   { -,&&,;,/,<,^,),==,OROR,*,%,+,<=, }
  (19) E --> .! E   { *,),==,;,<,<=,OROR,&&,/,-,+,%,^, }
  (16) E --> .E && E   { ),<=,%,;,-,/,+,<,^,*,OROR,&&,==, }
  (4) E --> .cout Str   { <=,*,OROR,<,==,+,%,&&,/,^,;,-,), }
  (14) E --> .E <= E   { %,+,&&,-,),<=,OROR,<,==,^,*,/,;, }
  (18) E --> .- E   { &&,<,<=,*,-,==,^,/,;,OROR,),+,%, }
  (21) E --> .Var = E   { +,<=,<,&&,),%,;,OROR,-,==,^,*,/, }
  (6) E --> .E + E   { ;,+,OROR,*,),<,^,&&,==,/,-,%,<=, }
  (23) E --> .if E E else E   { +,OROR,-,==,%,<=,*,<,;,),/,&&,^, }
  (1) E --> ( .E )   { %,-,cout,<=,if,==,/,while,else,(,^,),cin,+,*,OROR,EOF,Val,lambda,&&,let,Var,!,COLON,;,<, }
  (17) E --> .E OROR E   { ),OROR,+,;,/,^,==,*,%,<=,-,<,&&, }
  (12) E --> .E == E   { ==,OROR,<,<=,;,-,+,&&,%,^,*,/,), }
  (9) E --> .E / E   { &&,<=,-,*,==,/,OROR,;,<,^,),%,+, }
  (5) E --> .cout E   { ;,<=,/,+,==,*,&&,-,^,%,<,),OROR, }
  (20) E --> .let Var = E COLON E   { ==,*,&&,OROR,<=,-,<,+,/,;,^,%,), }
  (13) E --> .E < E   { OROR,%,+,*,==,<=,^,&&,),-,;,/,<, }
  (7) E --> .E - E   { <=,-,;,OROR,),*,^,%,==,&&,+,/,<, }
  (11) E --> .E ^ E   { %,<,+,/,;,),*,&&,^,-,==,OROR,<=, }
  (15) E --> .while ( E ) E   { <,-,<=,*,/,;,==,OROR,&&,%,^,),+, }
  (2) E --> .( Var E )   { ;,&&,/,-,*,),+,%,<,OROR,<=,==,^, }
  (0) E --> .Val   { OROR,-,*,+,==,%,<=,;,/,&&,),<,^, }
  (27) E --> .Var   { +,==,<=,OROR,<,%,;,-,*,/,&&,^,), }
  (3) E --> .cin   { -,&&,*,<=,==,;,OROR,%,+,),<,^,/, }
  (24) E --> .E ; ES   { /,OROR,<=,<,+,;,%,^,),*,==,&&,-, }
  (10) E --> .E % E   { ;,-,&&,*,%,^,<,),/,+,==,<=,OROR, }
  (2) E --> ( .Var E )   { /,;,EOF,==,cin,),COLON,lambda,<=,&&,cout,!,*,^,Val,%,Var,(,<,while,OROR,-,else,if,+,let, }
state 12:
  (20) E --> let .Var = E COLON E   { Val,EOF,COLON,+,!,cout,let,lambda,OROR,),<=,else,;,==,while,%,if,<,-,&&,/,cin,(,*,^,Var, }
state 13:
  (27) E --> .Var   { %,+,^,while,Val,!,COLON,&&,else,<=,cout,==,lambda,<,*,if,;,OROR,),-,cin,let,(,/,Var,EOF, }
  (7) E --> .E - E   { %,!,<=,<,else,-,lambda,EOF,^,OROR,Var,cin,let,/,cout,;,while,+,Val,&&,(,),if,COLON,*,==, }
  (8) E --> E * .E   { Var,while,/,&&,if,cin,cout,==,+,;,OROR,(,^,COLON,%,else,),lambda,<,-,<=,EOF,let,*,!,Val, }
  (13) E --> .E < E   { %,while,-,&&,==,<=,;,(,),COLON,/,EOF,cin,let,^,!,cout,*,+,if,<,else,lambda,OROR,Var,Val, }
  (15) E --> .while ( E ) E   { *,lambda,/,+,if,^,!,Val,==,<,;,while,&&,-,cin,%,COLON,EOF,cout,),(,OROR,Var,let,<=,else, }
  (8) E --> .E * E   { while,OROR,Var,+,<,),lambda,==,cout,Val,;,cin,&&,*,<=,COLON,(,^,if,else,-,let,%,/,!,EOF, }
  (2) E --> .( Var E )   { cout,;,<,lambda,while,OROR,cin,<=,if,(,Var,COLON,Val,+,%,!,-,EOF,let,==,/,),else,^,&&,*, }
  (6) E --> .E + E   { cout,;,cin,EOF,-,while,==,!,Val,COLON,^,OROR,else,(,*,if,let,lambda,%,&&,+,<=,/,<,),Var, }
  (23) E --> .if E E else E   { *,^,OROR,EOF,cin,+,==,/,&&,-,lambda,Var,if,%,cout,<,Val,;,else,!,<=,let,(,),while,COLON, }
  (18) E --> .- E   { (,%,cout,lambda,Var,;,while,-,*,==,&&,/,),<=,!,^,cin,if,<,Val,EOF,+,else,COLON,let,OROR, }
  (3) E --> .cin   { <=,lambda,^,/,else,cin,<,!,%,&&,COLON,+,;,==,-,EOF,Var,),cout,if,OROR,*,let,while,(,Val, }
  (22) E --> .lambda Var . E   { Val,<,(,else,EOF,lambda,OROR,Var,*,let,%,cin,COLON,),while,!,cout,if,==,-,^,+,;,&&,<=,/, }
  (5) E --> .cout E   { if,(,else,Val,<,;,%,COLON,cout,),^,while,Var,<=,==,*,EOF,lambda,&&,!,/,OROR,let,+,cin,-, }
  (19) E --> .! E   { let,COLON,else,Val,/,Var,lambda,*,^,if,cout,(,!,+,-,&&,EOF,cin,<=,<,%,==,),while,OROR,;, }
  (4) E --> .cout Str   { *,cout,while,;,lambda,&&,COLON,<,<=,+,cin,if,%,^,==,OROR,(,!,/,Val,-,let,),Var,else,EOF, }
  (9) E --> .E / E   { if,+,lambda,OROR,(,%,^,/,Val,let,),else,while,==,<,cout,*,<=,cin,!,EOF,&&,Var,;,COLON,-, }
  (21) E --> .Var = E   { let,while,if,cin,COLON,OROR,<=,-,&&,*,lambda,else,Var,==,(,cout,%,Val,<,+,/,^,!,),;,EOF, }
  (1) E --> .( E )   { ==,lambda,+,OROR,(,Val,/,!,COLON,while,),let,&&,if,<=,EOF,else,%,-,^,<,cout,*,cin,;,Var, }
  (20) E --> .let Var = E COLON E   { if,*,%,cin,<,-,+,Val,(,COLON,!,/,<=,^,;,==,Var,),cout,EOF,while,OROR,lambda,let,&&,else, }
  (11) E --> .E ^ E   { (,!,cin,;,Var,Val,while,<=,),%,else,==,/,lambda,^,EOF,<,+,let,COLON,*,cout,&&,-,if,OROR, }
  (17) E --> .E OROR E   { *,(,while,Val,+,&&,-,<=,OROR,!,COLON,EOF,/,<,cout,),==,if,%,cin,;,let,else,Var,lambda,^, }
  (12) E --> .E == E   { ;,cin,),Val,cout,EOF,while,<=,&&,==,Var,COLON,lambda,^,OROR,%,*,!,let,(,-,<,/,if,else,+, }
  (10) E --> .E % E   { &&,(,),!,;,-,/,OROR,if,let,while,==,cin,*,cout,Var,+,%,<=,^,<,else,Val,EOF,COLON,lambda, }
  (24) E --> .E ; ES   { Var,cin,OROR,/,cout,),;,<=,*,while,Val,<,(,lambda,+,&&,%,!,COLON,^,-,else,let,==,if,EOF, }
  (0) E --> .Val   { /,Var,%,COLON,<=,&&,;,while,let,),+,else,(,OROR,<,^,==,-,Val,cin,cout,if,EOF,*,!,lambda, }
  (16) E --> .E && E   { ;,OROR,(,if,^,while,<,==,let,/,&&,*,-,Val,<=,EOF,else,Var,COLON,lambda,!,),+,cout,cin,%, }
  (14) E --> .E <= E   { /,&&,else,(,Val,+,let,),if,OROR,cin,*,EOF,Var,-,^,;,COLON,!,while,<,==,lambda,%,<=,cout, }
state 14:
  (2) E --> .( Var E )   { lambda,OROR,cout,*,cin,!,COLON,/,%,&&,+,<,),Val,EOF,let,(,;,if,-,else,while,Var,^,<=,==, }
  (4) E --> .cout Str   { let,*,-,if,+,<,<=,lambda,Val,EOF,;,(,%,==,^,!,OROR,cin,),&&,while,Var,/,else,cout,COLON, }
  (15) E --> .while ( E ) E   { &&,cout,<=,/,^,Var,+,Val,*,else,EOF,%,while,if,let,;,COLON,lambda,cin,-,<,),OROR,!,(,==, }
  (9) E --> .E / E   { %,),EOF,;,!,-,^,COLON,==,&&,if,+,cout,lambda,Var,cin,*,OROR,else,<=,Val,<,/,(,let,while, }
  (7) E --> .E - E   { EOF,),lambda,<,;,+,-,%,==,(,while,^,cout,cin,OROR,if,COLON,!,<=,let,/,Var,Val,else,&&,*, }
  (12) E --> .E == E   { ),(,else,/,cout,OROR,%,EOF,*,+,while,COLON,cin,&&,if,Val,let,^,!,==,Var,lambda,-,<,<=,;, }
  (3) E --> .cin   { -,lambda,),<,Val,if,&&,!,%,<=,OROR,*,/,+,==,Var,(,let,cout,else,;,^,while,cin,COLON,EOF, }
  (21) E --> .Var = E   { *,let,-,^,;,else,lambda,),COLON,(,/,<=,if,Val,%,==,cout,!,OROR,while,cin,EOF,Var,<,+,&&, }
  (10) E --> .E % E   { ),Val,COLON,/,OROR,<,if,cin,-,%,while,&&,;,EOF,==,cout,lambda,^,!,+,*,let,<=,Var,else,(, }
  (22) E --> .lambda Var . E   { if,^,Var,Val,(,%,&&,cin,<=,cout,COLON,/,while,OROR,;,let,),lambda,-,EOF,==,else,!,+,<,*, }
  (6) E --> .E + E   { cin,cout,else,COLON,(,-,<,lambda,==,&&,^,),Var,EOF,;,*,Val,<=,%,+,OROR,let,/,if,while,!, }
  (17) E --> .E OROR E   { ==,Var,*,OROR,else,&&,-,if,EOF,cin,COLON,<=,/,while,let,(,!,lambda,cout,%,<,+,;,^,),Val, }
  (13) E --> .E < E   { &&,(,-,*,else,;,lambda,^,%,cin,/,cout,COLON,let,),OROR,!,Var,+,<=,while,==,Val,<,if,EOF, }
  (8) E --> .E * E   { cin,==,+,-,%,),Var,EOF,<,OROR,if,*,else,while,^,&&,/,cout,;,(,lambda,<=,COLON,Val,let,!, }
  (11) E --> .E ^ E   { <=,==,%,/,),else,Var,-,;,^,<,cin,(,lambda,!,EOF,*,+,let,&&,Val,if,cout,COLON,OROR,while, }
  (23) E --> .if E E else E   { +,COLON,cin,let,(,!,Val,if,),Var,/,*,OROR,;,cout,==,-,&&,<=,<,^,%,EOF,while,lambda,else, }
  (16) E --> .E && E   { ),cout,^,COLON,else,lambda,(,-,+,<=,;,cin,EOF,Val,while,<,*,OROR,Var,!,%,&&,/,==,if,let, }
  (24) E --> .E ; ES   { Var,Val,cout,+,(,%,lambda,cin,),;,else,&&,^,!,<=,while,==,if,<,EOF,/,OROR,let,-,*,COLON, }
  (1) E --> .( E )   { while,;,+,cin,Var,else,<,Val,(,),if,-,lambda,&&,OROR,<=,!,cout,%,==,COLON,let,^,/,*,EOF, }
  (27) E --> .Var   { Var,*,while,cout,<,-,!,),lambda,COLON,+,Val,OROR,&&,/,EOF,let,%,else,(,;,<=,cin,if,==,^, }
  (5) E --> .cout E   { lambda,let,-,!,+,COLON,cin,),&&,while,*,%,^,cout,/,<,if,Var,Val,;,(,==,else,OROR,<=,EOF, }
  (20) E --> .let Var = E COLON E   { OROR,if,cin,let,<,lambda,(,while,-,%,^,*,),<=,COLON,cout,EOF,/,!,Var,;,==,+,Val,else,&&, }
  (0) E --> .Val   { Var,if,let,while,==,+,COLON,-,EOF,/,!,*,lambda,;,cout,OROR,%,<=,<,cin,else,(,^,&&,),Val, }
  (19) E --> .! E   { cin,^,<,&&,else,EOF,-,if,COLON,cout,Var,!,Val,/,<=,),*,let,+,(,==,while,;,OROR,lambda,%, }
  (12) E --> E == .E   { /,^,&&,Val,<=,*,==,COLON,cout,-,;,<,!,Var,let,EOF,if,),%,(,while,cin,+,else,OROR,lambda, }
  (14) E --> .E <= E   { Val,!,<=,else,%,;,Var,+,while,),&&,-,lambda,EOF,==,if,*,^,cin,cout,/,OROR,(,let,<,COLON, }
  (18) E --> .- E   { <=,<,/,*,else,COLON,!,%,^,&&,),;,+,lambda,cin,Var,let,==,if,cout,-,EOF,Val,OROR,(,while, }
state 15:
  (7) E --> .E - E   { ^,),%,(,/,;,cin,*,EOF,OROR,if,cout,let,<=,COLON,lambda,Var,while,==,<,-,+,&&,!,Val,else, }
  (3) E --> .cin   { Val,(,*,),/,cin,Var,;,<=,^,while,COLON,&&,OROR,!,-,==,let,%,EOF,<,cout,+,lambda,if,else, }
  (2) E --> .( Var E )   { EOF,%,-,(,if,COLON,<,lambda,Val,!,^,let,Var,==,;,cin,while,*,cout,+,else,),/,OROR,<=,&&, }
  (0) E --> .Val   { EOF,cout,%,lambda,/,if,Var,<,cin,;,&&,let,while,^,*,-,OROR,Val,),else,+,!,<=,==,(,COLON, }
  (24) E --> .E ; ES   { -,EOF,%,(,;,lambda,Val,<=,&&,==,let,<,cin,else,!,if,*,Var,),OROR,cout,COLON,while,+,^,/, }
  (16) E --> .E && E   { Val,COLON,if,-,(,+,lambda,/,<,^,*,let,),EOF,cin,OROR,%,cout,!,else,Var,==,<=,&&,;,while, }
  (13) E --> .E < E   { ^,/,cout,while,if,%,Val,-,;,Var,COLON,cin,lambda,),*,<=,OROR,else,(,==,&&,!,EOF,<,let,+, }
  (21) E --> .Var = E   { if,OROR,==,*,let,COLON,;,^,cout,!,/,Var,cin,-,while,<,<=,+,lambda,%,(,Val,),EOF,else,&&, }
  (10) E --> .E % E   { (,<,==,!,Val,else,),/,Var,OROR,;,EOF,let,+,&&,%,while,COLON,<=,cin,-,*,^,lambda,if,cout, }
  (6) E --> .E + E   { while,/,^,&&,;,(,),COLON,cout,Var,EOF,%,cin,+,lambda,<=,OROR,if,==,-,else,*,<,let,Val,!, }
  (15) E --> .while ( E ) E   { %,let,Val,Var,cin,cout,lambda,<=,OROR,-,),^,==,;,+,(,&&,*,while,/,<,COLON,!,if,EOF,else, }
  (14) E --> .E <= E   { ),cout,==,&&,cin,lambda,OROR,if,/,let,else,Var,<,-,*,;,%,^,+,(,while,!,<=,EOF,COLON,Val, }
  (9) E --> .E / E   { Val,OROR,let,!,/,EOF,==,&&,<,+,while,COLON,if,-,;,cout,(,lambda,%,cin,Var,<=,),else,*,^, }
  (4) E --> .cout Str   { cout,&&,OROR,while,lambda,^,EOF,%,!,if,*,<=,else,cin,let,Val,/,COLON,==,;,-,+,),<,Var,(, }
  (27) E --> .Var   { while,*,&&,(,!,),^,<,%,+,let,Var,/,if,cout,else,lambda,EOF,cin,==,;,OROR,Val,COLON,-,<=, }
  (1) E --> .( E )   { <=,else,EOF,+,==,cout,<,*,cin,&&,while,lambda,/,if,OROR,Var,%,;,(,let,-,!,^,Val,),COLON, }
  (19) E --> .! E   { cout,<=,%,lambda,+,==,/,COLON,;,cin,OROR,while,<,else,*,Val,),^,!,&&,if,Var,-,let,(,EOF, }
  (14) E --> E <= .E   { else,Var,<=,while,/,if,!,lambda,;,(,COLON,==,&&,),EOF,-,+,Val,^,cout,<,let,*,cin,OROR,%, }
  (11) E --> .E ^ E   { %,lambda,let,<=,cin,!,),EOF,^,;,OROR,COLON,else,<,*,while,(,if,Var,Val,==,cout,+,/,-,&&, }
  (20) E --> .let Var = E COLON E   { OROR,(,Var,&&,-,<,%,+,lambda,Val,;,!,if,/,else,),while,^,cout,*,let,COLON,<=,cin,EOF,==, }
  (18) E --> .- E   { COLON,^,Val,*,lambda,if,),<,cin,EOF,Var,OROR,/,&&,==,%,;,cout,<=,!,else,let,-,while,(,+, }
  (12) E --> .E == E   { +,),COLON,else,lambda,==,Val,cout,*,<,-,while,EOF,!,OROR,;,/,(,&&,<=,cin,^,Var,%,if,let, }
  (23) E --> .if E E else E   { &&,!,<=,;,<,^,cin,/,OROR,==,let,%,COLON,+,Val,Var,lambda,if,*,-,),(,EOF,else,cout,while, }
  (5) E --> .cout E   { lambda,),while,let,COLON,Val,if,&&,!,^,<,/,(,cin,;,+,Var,else,OROR,cout,%,-,<=,==,*,EOF, }
  (8) E --> .E * E   { *,let,OROR,(,<=,^,&&,==,COLON,),EOF,+,else,Val,!,cin,;,/,while,Var,if,lambda,-,cout,%,<, }
  (17) E --> .E OROR E   { OROR,else,let,/,!,while,),&&,+,if,Var,cout,EOF,(,^,COLON,%,lambda,<=,<,*,Val,-,cin,;,==, }
  (22) E --> .lambda Var . E   { if,&&,EOF,cin,OROR,!,^,else,let,%,Val,cout,(,),-,while,COLON,*,+,;,==,<=,/,Var,lambda,<, }
state 16:
  (13) E --> .E < E   { else,+,COLON,&&,^,let,%,cout,!,*,;,EOF,<,==,cin,),Val,Var,<=,-,while,OROR,(,if,/,lambda, }
  (11) E --> .E ^ E   { +,*,(,COLON,while,!,if,EOF,),let,==,cout,-,<,Val,<=,cin,^,&&,/,OROR,else,lambda,;,Var,%, }
  (4) E --> .cout Str   { let,Var,-,while,),==,COLON,lambda,/,if,;,EOF,cout,OROR,Val,^,+,%,&&,else,*,!,(,<=,<,cin, }
  (10) E --> .E % E   { lambda,%,-,cout,let,EOF,if,+,COLON,Var,*,&&,else,(,<,!,cin,==,^,while,Val,<=,),;,/,OROR, }
  (7) E --> .E - E   { lambda,cout,EOF,&&,+,!,==,while,^,cin,let,-,<=,),*,OROR,COLON,;,if,else,(,%,Var,/,Val,<, }
  (5) E --> .cout E   { COLON,^,lambda,!,+,if,;,(,let,<=,-,*,/,EOF,else,==,&&,<,%,Var,OROR,Val,cout,while,cin,), }
  (16) E --> .E && E   { ;,COLON,while,OROR,),<,(,*,EOF,cin,/,Val,else,!,cout,if,%,==,lambda,&&,Var,^,<=,+,let,-, }
  (23) E --> .if E E else E   { &&,Val,let,lambda,),while,<=,!,+,EOF,COLON,-,cout,Var,(,cin,^,/,<,;,OROR,*,if,==,else,%, }
  (7) E --> E - .E   { EOF,let,%,COLON,Val,else,&&,/,Var,*,<=,-,;,OROR,while,lambda,cout,!,(,),==,^,<,+,if,cin, }
  (12) E --> .E == E   { (,!,lambda,/,<=,Var,cin,),<,else,^,&&,COLON,*,EOF,while,let,==,if,Val,cout,%,OROR,+,;,-, }
  (1) E --> .( E )   { /,),*,!,if,%,OROR,else,<=,(,lambda,cin,&&,;,EOF,let,==,cout,<,^,Val,Var,COLON,+,-,while, }
  (27) E --> .Var   { ),*,-,==,<,cin,Var,let,!,EOF,+,%,/,cout,else,lambda,(,<=,OROR,COLON,Val,while,;,if,&&,^, }
  (17) E --> .E OROR E   { &&,if,%,<=,+,Val,),^,lambda,-,!,cout,<,EOF,==,COLON,else,(,cin,;,let,*,while,OROR,Var,/, }
  (2) E --> .( Var E )   { /,while,OROR,<,*,;,),COLON,^,Val,+,==,%,cout,<=,lambda,cin,if,!,(,else,-,EOF,Var,&&,let, }
  (24) E --> .E ; ES   { ^,EOF,Val,/,while,*,(,else,COLON,-,lambda,%,+,;,cin,if,&&,<,let,OROR,Var,),cout,!,==,<=, }
  (14) E --> .E <= E   { Val,*,cout,&&,lambda,-,if,^,while,cin,<,%,COLON,let,else,Var,OROR,;,),EOF,==,+,(,/,<=,!, }
  (22) E --> .lambda Var . E   { COLON,(,*,),if,OROR,==,&&,%,<=,else,<,let,;,Val,cin,Var,lambda,/,+,!,-,EOF,cout,^,while, }
  (21) E --> .Var = E   { %,Var,;,COLON,let,OROR,),<,Val,(,*,while,^,lambda,cout,<=,-,if,/,EOF,else,cin,==,&&,+,!, }
  (3) E --> .cin   { let,OROR,-,while,;,COLON,+,Val,/,EOF,cin,Var,<,<=,(,&&,cout,),else,if,==,!,*,%,^,lambda, }
  (9) E --> .E / E   { *,COLON,cout,+,cin,!,EOF,Val,-,&&,let,/,(,lambda,<,<=,else,while,^,%,;,OROR,if,Var,==,), }
  (0) E --> .Val   { *,COLON,&&,while,OROR,(,;,let,cout,),^,EOF,<,<=,%,else,!,-,/,==,Var,lambda,+,Val,if,cin, }
  (6) E --> .E + E   { OROR,else,%,while,&&,<,EOF,cout,^,if,;,-,!,),Var,Val,==,+,(,lambda,cin,<=,COLON,let,*,/, }
  (19) E --> .! E   { *,Val,COLON,else,),-,<,==,+,EOF,/,if,&&,;,!,while,cout,<=,^,let,Var,(,OROR,%,lambda,cin, }
  (8) E --> .E * E   { COLON,cin,EOF,^,*,-,Val,lambda,let,+,),/,else,==,Var,!,&&,OROR,(,;,<,%,<=,if,while,cout, }
  (15) E --> .while ( E ) E   { Var,!,let,%,),EOF,while,/,(,&&,<,^,else,+,Val,-,cin,==,if,COLON,lambda,OROR,<=,*,cout,;, }
  (18) E --> .- E   { !,%,<,COLON,(,cout,if,Var,==,lambda,cin,else,+,let,^,&&,/,OROR,*,EOF,-,while,Val,<=,;,), }
  (20) E --> .let Var = E COLON E   { let,<=,/,&&,*,lambda,%,-,),Var,if,(,!,COLON,EOF,else,<,==,^,+,cin,Val,;,cout,OROR,while, }
state 17:
  (1) E --> .( E )   { ;,/,EOF,==,lambda,<,Var,Val,if,!,&&,*,<=,cout,(,cin,let,OROR,^,else,+,COLON,%,-,while,), }
  (16) E --> .E && E   { COLON,cout,/,%,<,OROR,EOF,(,Val,while,&&,lambda,+,*,let,),else,if,<=,^,==,-,Var,;,!,cin, }
  (14) E --> .E <= E   { ;,lambda,%,==,Var,else,cout,EOF,<,-,&&,cin,!,/,COLON,while,if,*,Val,(,OROR,^,let,+,<=,), }
  (27) E --> .Var   { (,/,OROR,<=,cout,else,Val,+,!,<,EOF,%,^,lambda,-,cin,COLON,*,Var,;,if,),let,&&,==,while, }
  (2) E --> .( Var E )   { ^,<=,else,cin,+,!,;,<,),let,EOF,/,(,OROR,*,Var,Val,==,lambda,-,COLON,while,if,&&,%,cout, }
  (5) E --> .cout E   { -,^,<=,(,<,let,COLON,/,cout,else,lambda,+,Val,&&,!,*,cin,;,%,if,while,Var,EOF,==,OROR,), }
  (13) E --> E < .E   { ^,OROR,+,-,lambda,if,;,%,Val,&&,*,==,<,COLON,let,!,while,<=,),(,/,else,Var,EOF,cin,cout, }
  (24) E --> .E ; ES   { (,==,EOF,while,<=,lambda,*,COLON,Var,<,%,^,Val,let,/,cout,),;,cin,!,&&,OROR,if,+,-,else, }
  (18) E --> .- E   { !,cout,==,&&,(,lambda,EOF,<,let,;,*,if,Val,+,OROR,Var,-,COLON,^,while,/,cin,<=,else,),%, }
  (7) E --> .E - E   { ;,/,else,-,+,!,Var,^,(,EOF,*,COLON,cin,<,lambda,OROR,<=,&&,let,%,==,if,),Val,cout,while, }
  (10) E --> .E % E   { !,%,*,;,lambda,let,Val,Var,else,&&,(,while,<=,^,==,cin,-,<,EOF,COLON,if,/,OROR,cout,),+, }
  (12) E --> .E == E   { /,*,lambda,cin,COLON,<=,),if,else,while,==,;,&&,%,^,<,(,-,EOF,+,!,OROR,let,Var,Val,cout, }
  (8) E --> .E * E   { Val,;,let,%,<,==,cin,else,*,+,),if,&&,cout,Var,EOF,while,(,/,COLON,lambda,^,OROR,<=,!,-, }
  (22) E --> .lambda Var . E   { <,COLON,!,EOF,Var,&&,-,/,;,cin,else,cout,while,if,(,%,lambda,<=,^,OROR,),*,let,Val,==,+, }
  (20) E --> .let Var = E COLON E   { lambda,&&,Val,cout,-,^,;,while,+,let,Var,if,<,COLON,),!,==,<=,else,(,cin,*,%,EOF,OROR,/, }
  (6) E --> .E + E   { COLON,let,<,<=,*,;,),%,(,lambda,Val,EOF,cout,!,^,if,OROR,else,==,Var,cin,&&,while,-,+,/, }
  (4) E --> .cout Str   { ^,(,==,%,),/,;,-,&&,OROR,if,cin,*,Val,let,Var,while,!,<=,EOF,+,cout,lambda,<,COLON,else, }
  (17) E --> .E OROR E   { cin,<=,COLON,Val,lambda,while,else,;,),OROR,==,^,Var,EOF,-,let,if,!,/,<,%,+,(,cout,*,&&, }
  (3) E --> .cin   { ==,EOF,if,!,Var,Val,COLON,-,lambda,<,<=,),%,else,cin,+,/,^,&&,;,while,let,(,cout,OROR,*, }
  (21) E --> .Var = E   { ^,<=,),!,let,*,cout,while,+,else,Var,/,-,COLON,;,EOF,if,<,cin,Val,==,%,lambda,(,OROR,&&, }
  (9) E --> .E / E   { ),COLON,cout,Var,EOF,+,^,==,*,/,(,while,OROR,;,lambda,-,else,%,!,<,&&,Val,cin,if,<=,let, }
  (19) E --> .! E   { cin,==,/,),*,!,^,OROR,while,&&,else,lambda,COLON,+,%,Var,Val,let,if,<=,<,EOF,-,cout,;,(, }
  (0) E --> .Val   { ;,%,<=,lambda,/,EOF,COLON,<,),^,-,(,cin,Var,OROR,if,*,Val,&&,cout,while,+,!,==,let,else, }
  (11) E --> .E ^ E   { cout,!,Var,<,if,lambda,^,Val,cin,*,==,else,(,+,while,%,;,OROR,/,-,COLON,EOF,let,&&,<=,), }
  (15) E --> .while ( E ) E   { if,(,),!,OROR,lambda,<,<=,Val,/,while,let,COLON,-,==,EOF,&&,Var,cin,+,*,%,^,cout,else,;, }
  (23) E --> .if E E else E   { /,<=,^,EOF,Val,;,-,if,*,COLON,Var,<,==,else,cout,+,let,while,(,),lambda,!,OROR,cin,%,&&, }
  (13) E --> .E < E   { ;,/,COLON,cout,+,Var,else,&&,lambda,while,==,^,OROR,%,cin,),Val,-,<=,<,if,EOF,*,!,let,(, }
state 18:
  (17) E --> .E OROR E   { COLON,cin,&&,%,cout,lambda,Val,;,==,!,+,/,Var,),^,<=,else,let,OROR,<,EOF,while,if,*,-,(, }
  (3) E --> .cin   { &&,/,;,COLON,OROR,!,while,cin,-,),^,if,%,<=,Var,+,lambda,Val,else,<,let,==,EOF,cout,*,(, }
  (15) E --> .while ( E ) E   { &&,cin,),Var,Val,;,lambda,EOF,while,<=,/,<,==,cout,(,^,else,-,if,OROR,*,let,%,!,+,COLON, }
  (6) E --> .E + E   { cout,%,OROR,(,Val,),else,Var,<,+,^,if,*,while,;,-,lambda,==,EOF,COLON,&&,cin,let,/,<=,!, }
  (22) E --> .lambda Var . E   { cout,+,<=,if,let,Var,),^,(,COLON,<,%,cin,EOF,OROR,==,&&,*,while,;,else,Val,lambda,!,/,-, }
  (1) E --> .( E )   { ;,(,==,cout,lambda,-,else,let,%,/,if,&&,cin,EOF,+,!,Val,COLON,while,^,<,*,),OROR,Var,<=, }
  (2) E --> .( Var E )   { -,EOF,<,%,==,if,Val,;,OROR,&&,),+,*,/,lambda,^,let,cout,(,cin,COLON,else,while,!,<=,Var, }
  (27) E --> .Var   { cin,-,else,(,^,while,+,OROR,<=,/,),EOF,*,if,%,Val,cout,COLON,;,==,&&,!,<,Var,let,lambda, }
  (13) E --> .E < E   { cin,/,&&,<=,let,OROR,+,COLON,(,if,else,while,==,^,Val,;,Var,cout,-,lambda,!,),EOF,*,%,<, }
  (7) E --> .E - E   { while,cout,%,<,!,if,==,+,-,else,^,Val,COLON,/,),cin,lambda,let,&&,<=,;,(,EOF,Var,*,OROR, }
  (16) E --> .E && E   { !,Var,;,let,<=,EOF,%,while,),cout,==,+,Val,(,else,if,cin,^,COLON,/,lambda,<,*,-,&&,OROR, }
  (4) E --> .cout Str   { <,%,lambda,!,;,Val,cin,-,<=,cout,*,Var,/,OROR,),let,&&,if,EOF,==,+,COLON,while,(,else,^, }
  (18) E --> .- E   { OROR,-,(,&&,else,while,/,),+,Val,cin,;,cout,COLON,!,^,<=,%,EOF,let,*,<,lambda,Var,==,if, }
  (21) E --> .Var = E   { ),let,if,<,*,else,cout,<=,(,EOF,==,COLON,+,lambda,cin,;,&&,-,!,^,OROR,while,%,Var,/,Val, }
  (16) E --> E && .E   { +,),;,&&,-,/,(,else,OROR,==,!,Val,cout,while,%,COLON,<,EOF,*,<=,cin,^,if,Var,lambda,let, }
  (5) E --> .cout E   { (,cout,<,while,!,-,%,if,Val,Var,/,+,else,),==,lambda,*,let,&&,<=,OROR,cin,;,COLON,^,EOF, }
  (12) E --> .E == E   { if,let,cout,EOF,==,cin,-,/,OROR,Var,<=,(,Val,else,%,COLON,^,<,&&,while,;,!,*,lambda,+,), }
  (11) E --> .E ^ E   { else,*,cout,EOF,!,Var,<,Val,==,if,;,<=,cin,%,lambda,),/,^,OROR,let,while,&&,(,+,COLON,-, }
  (8) E --> .E * E   { else,&&,cin,+,^,let,while,),OROR,lambda,*,<,(,Var,-,Val,EOF,COLON,!,/,;,%,==,if,cout,<=, }
  (0) E --> .Val   { EOF,*,^,&&,%,),+,-,<=,OROR,Val,COLON,cin,!,;,lambda,==,let,while,Var,cout,else,/,if,(,<, }
  (10) E --> .E % E   { else,<,),EOF,OROR,let,<=,cout,COLON,(,if,+,;,lambda,==,&&,%,*,Var,-,^,/,while,!,Val,cin, }
  (20) E --> .let Var = E COLON E   { ==,+,*,COLON,lambda,if,;,<,<=,),OROR,%,while,/,-,else,cin,let,EOF,cout,&&,Var,Val,!,^,(, }
  (23) E --> .if E E else E   { Var,<,let,if,-,while,+,*,cout,/,!,&&,),else,EOF,^,==,Val,%,lambda,OROR,;,COLON,(,<=,cin, }
  (19) E --> .! E   { (,EOF,while,Val,;,/,else,!,OROR,cin,),if,&&,<,Var,==,cout,<=,let,-,%,COLON,*,+,^,lambda, }
  (14) E --> .E <= E   { ;,+,let,EOF,*,COLON,),if,-,&&,Var,else,while,<,Val,==,cin,<=,OROR,!,cout,^,/,%,(,lambda, }
  (9) E --> .E / E   { *,;,COLON,cout,+,(,Val,Var,!,cin,<,else,^,lambda,EOF,if,&&,OROR,let,%,),==,<=,/,-,while, }
  (24) E --> .E ; ES   { cout,lambda,cin,<,+,while,!,else,EOF,/,^,-,(,Var,),COLON,if,Val,let,%,*,==,;,<=,&&,OROR, }
state 19:
  (13) E --> .E < E   { !,COLON,^,Var,<=,EOF,/,while,%,cout,*,lambda,;,<,else,-,Val,cin,let,+,OROR,&&,==,),(,if, }
  (11) E --> .E ^ E   { +,COLON,lambda,if,/,%,<,;,while,<=,OROR,EOF,Var,cout,(,),^,let,-,else,&&,Val,!,==,cin,*, }
  (9) E --> .E / E   { %,==,*,else,OROR,(,/,<=,let,^,while,;,COLON,<,+,cin,&&,!,EOF,),lambda,cout,-,Var,Val,if, }
  (3) E --> .cin   { %,<,(,let,+,-,!,while,lambda,&&,OROR,*,),<=,^,COLON,/,==,if,else,Val,cout,Var,cin,EOF,;, }
  (5) E --> .cout E   { ==,),<,COLON,if,^,+,&&,while,Var,EOF,cout,%,;,let,OROR,*,else,!,(,cin,lambda,-,<=,/,Val, }
  (10) E --> E % .E   { cout,;,else,let,==,cin,while,/,*,OROR,%,if,COLON,),EOF,Val,<=,^,+,-,lambda,<,&&,!,(,Var, }
  (1) E --> .( E )   { +,<=,if,;,EOF,Val,(,lambda,else,-,*,),&&,!,<,COLON,cout,%,^,Var,cin,==,while,let,OROR,/, }
  (23) E --> .if E E else E   { ;,),/,(,!,OROR,while,==,cin,<=,if,COLON,cout,<,let,Var,-,Val,EOF,+,&&,else,^,%,lambda,*, }
  (18) E --> .- E   { ;,Var,/,OROR,cin,Val,EOF,cout,COLON,%,if,let,-,&&,(,while,!,),+,<=,==,lambda,else,<,*,^, }
  (21) E --> .Var = E   { ;,if,),cin,/,<,EOF,let,+,(,Var,!,==,COLON,*,<=,&&,lambda,-,OROR,cout,while,^,else,Val,%, }
  (14) E --> .E <= E   { cout,%,let,),Var,==,&&,/,lambda,EOF,^,<,!,;,if,(,*,COLON,OROR,Val,+,-,while,else,<=,cin, }
  (15) E --> .while ( E ) E   { ),OROR,Var,Val,let,&&,==,!,while,+,lambda,cin,cout,else,(,-,;,COLON,EOF,*,%,^,/,if,<,<=, }
  (20) E --> .let Var = E COLON E   { %,(,*,-,),else,EOF,/,!,Var,OROR,lambda,;,&&,==,COLON,^,while,<=,<,+,cin,let,cout,Val,if, }
  (10) E --> .E % E   { *,lambda,<=,Val,<,OROR,&&,cout,%,Var,(,!,COLON,EOF,;,/,let,+,-,),cin,^,==,if,while,else, }
  (24) E --> .E ; ES   { Var,EOF,while,<,else,/,Val,;,(,&&,!,^,cin,let,==,OROR,*,<=,cout,-,lambda,COLON,if,+,),%, }
  (12) E --> .E == E   { ),else,lambda,!,;,/,%,+,cin,let,==,^,&&,EOF,<=,if,COLON,-,*,Var,<,OROR,(,Val,cout,while, }
  (6) E --> .E + E   { *,lambda,Val,EOF,(,<,while,-,OROR,cin,if,else,%,+,/,),let,<=,^,COLON,;,==,!,Var,cout,&&, }
  (0) E --> .Val   { else,!,<=,&&,if,cout,*,cin,+,==,^,let,Val,lambda,;,EOF,-,/,Var,while,),(,OROR,COLON,%,<, }
  (7) E --> .E - E   { OROR,Val,else,+,(,COLON,<=,;,let,/,if,&&,-,==,cout,<,EOF,!,*,while,cin,%,^,),Var,lambda, }
  (16) E --> .E && E   { ),else,-,lambda,COLON,;,/,<,%,Val,if,+,OROR,^,while,&&,!,cout,==,EOF,(,Var,*,let,cin,<=, }
  (2) E --> .( Var E )   { Val,let,while,OROR,==,if,EOF,+,<,!,lambda,cout,<=,&&,*,;,(,-,COLON,%,^,/,cin,),else,Var, }
  (8) E --> .E * E   { Val,(,Var,),let,<,COLON,;,*,cin,OROR,==,cout,else,EOF,while,+,&&,%,<=,-,/,!,^,lambda,if, }
  (17) E --> .E OROR E   { COLON,<,cin,else,lambda,while,if,OROR,cout,*,^,EOF,!,&&,Var,let,==,Val,%,-,(,),+,;,<=,/, }
  (19) E --> .! E   { %,cout,(,let,^,/,*,<=,+,;,Var,EOF,while,Val,<,cin,==,-,&&,),lambda,OROR,else,if,!,COLON, }
  (22) E --> .lambda Var . E   { else,!,-,/,&&,Val,Var,OROR,;,*,lambda,+,^,cout,while,COLON,cin,==,),(,%,<=,let,if,<,EOF, }
  (4) E --> .cout Str   { *,;,cout,else,<,Var,while,Val,(,+,!,lambda,EOF,==,let,OROR,&&,-,/,%,if,),^,<=,COLON,cin, }
  (27) E --> .Var   { COLON,while,Val,;,-,lambda,/,<=,let,OROR,*,if,cout,^,!,),Var,&&,else,<,==,cin,%,+,(,EOF, }
state 20:
  (11) E --> .E ^ E   { +,&&,%,;,<,^,/,OROR,<=,==,-,*, }
  (6) E --> .E + E   { ^,%,<,/,OROR,+,==,;,-,*,<=,&&, }
  (12) E --> .E == E   { ;,%,&&,*,-,OROR,/,==,^,<,+,<=, }
  (17) E --> .E OROR E   { ;,&&,OROR,-,<,%,<=,/,*,^,==,+, }
  (27) E --> .Var   { <,/,;,&&,==,OROR,-,^,*,+,<=,%, }
  (10) E --> .E % E   { +,==,/,<=,;,^,-,*,%,OROR,&&,<, }
  (24) E --> .E ; ES   { %,<=,+,OROR,==,/,-,<,^,&&,*,;, }
  (15) E --> .while ( E ) E   { ==,*,%,<,-,&&,^,OROR,<=,/,;,+, }
  (22) E --> .lambda Var . E   { *,<=,%,<,-,^,==,/,OROR,;,&&,+, }
  (21) E --> .Var = E   { ==,*,<=,OROR,+,%,;,^,/,&&,<,-, }
  (18) E --> .- E   { *,OROR,<=,/,+,;,<,%,-,^,==,&&, }
  (9) E --> .E / E   { %,==,<,*,/,-,&&,OROR,^,+,<=,;, }
  (24) E --> E ; .ES   { cin,(,while,<=,if,<,!,+,-,^,lambda,/,;,),EOF,let,%,Var,==,OROR,*,Val,else,&&,COLON,cout, }
  (0) E --> .Val   { ^,<,-,/,+,OROR,==,<=,&&,;,*,%, }
  (23) E --> .if E E else E   { OROR,<,&&,/,==,^,+,%,*,;,-,<=, }
  (19) E --> .! E   { <,;,+,&&,OROR,/,*,<=,%,^,==,-, }
  (26) ES --> .E ; ES   { ==,(,lambda,cin,<=,^,-,<,Val,else,Var,),let,COLON,;,!,while,OROR,EOF,*,if,&&,/,+,%,cout, }
  (1) E --> .( E )   { -,OROR,+,==,*,/,;,<,^,&&,%,<=, }
  (8) E --> .E * E   { OROR,==,;,*,^,-,<=,<,&&,/,%,+, }
  (16) E --> .E && E   { &&,<=,;,<,+,^,OROR,-,==,/,%,*, }
  (3) E --> .cin   { &&,-,<,OROR,<=,*,/,==,%,^,;,+, }
  (25) ES --> .   { ;,cin,OROR,),if,(,&&,Val,^,/,==,COLON,cout,let,lambda,Var,!,else,EOF,<,while,*,+,%,<=,-, }
  (14) E --> .E <= E   { <,&&,*,<=,;,-,==,OROR,/,+,%,^, }
  (4) E --> .cout Str   { <,-,;,&&,*,<=,==,/,+,%,OROR,^, }
  (20) E --> .let Var = E COLON E   { OROR,-,/,*,&&,<=,;,==,^,+,<,%, }
  (2) E --> .( Var E )   { *,+,OROR,-,^,/,;,<=,==,%,<,&&, }
  (5) E --> .cout E   { <=,OROR,-,+,*,/,%,^,;,<,&&,==, }
  (13) E --> .E < E   { /,^,&&,+,<=,-,<,OROR,==,;,%,*, }
  (7) E --> .E - E   { OROR,&&,/,;,*,+,-,<,==,^,<=,%, }
state 21:
  (16) E --> .E && E   { EOF,;,(,+,-,while,cin,*,%,OROR,),Val,/,if,^,Var,<=,<,let,else,cout,&&,==,COLON,lambda,!, }
  (7) E --> .E - E   { cin,==,else,Var,%,/,EOF,<=,lambda,while,Val,&&,^,),+,!,-,if,(,let,<,cout,OROR,*,COLON,;, }
  (10) E --> .E % E   { !,%,if,&&,while,^,lambda,<=,let,/,OROR,COLON,;,cout,cin,(,*,EOF,Val,<,==,-,+,else,),Var, }
  (14) E --> .E <= E   { (,<=,if,==,!,OROR,COLON,;,let,^,cout,&&,cin,/,Var,else,Val,lambda,),EOF,%,*,<,-,+,while, }
  (11) E --> .E ^ E   { *,cin,<=,+,!,lambda,;,if,/,Val,<,cout,),-,else,==,%,let,^,(,&&,Var,OROR,COLON,while,EOF, }
  (2) E --> .( Var E )   { else,&&,EOF,%,Val,(,*,lambda,),Var,<,OROR,while,==,^,;,!,cin,let,-,cout,<=,+,COLON,if,/, }
  (19) E --> .! E   { +,==,let,cin,<,^,if,),else,cout,OROR,(,%,*,Var,/,COLON,;,while,EOF,Val,-,!,<=,&&,lambda, }
  (23) E --> .if E E else E   { -,Var,cout,<,<=,&&,OROR,let,cin,lambda,if,;,EOF,%,/,(,),else,==,*,while,COLON,+,!,^,Val, }
  (12) E --> .E == E   { /,^,(,EOF,cin,),lambda,&&,;,==,else,let,-,COLON,*,if,while,%,OROR,+,Val,Var,cout,<,!,<=, }
  (13) E --> .E < E   { EOF,%,while,+,Var,OROR,cin,-,if,*,(,/,cout,lambda,&&,let,;,==,!,Val,<=,COLON,^,else,),<, }
  (8) E --> .E * E   { lambda,&&,%,while,<,COLON,let,Var,cin,-,+,else,!,==,/,EOF,cout,;,*,),Val,^,if,OROR,(,<=, }
  (5) E --> .cout E   { %,Val,cout,while,cin,let,==,Var,/,-,(,*,if,^,!,lambda,<,),&&,EOF,else,COLON,OROR,;,+,<=, }
  (0) E --> .Val   { COLON,&&,<=,-,(,while,if,;,*,/,!,lambda,%,OROR,else,^,Val,Var,),+,EOF,<,let,cout,cin,==, }
  (15) E --> .while ( E ) E   { ;,%,EOF,Val,if,cout,-,(,&&,while,<=,^,*,/,lambda,cin,),<,==,COLON,Var,+,OROR,!,let,else, }
  (4) E --> .cout Str   { <=,else,EOF,cout,!,==,;,),<,+,OROR,^,Var,Val,/,COLON,&&,while,let,%,lambda,-,*,(,if,cin, }
  (24) E --> .E ; ES   { COLON,if,while,cout,OROR,%,&&,;,<,Var,==,!,),lambda,^,+,*,EOF,/,<=,else,(,let,cin,Val,-, }
  (3) E --> .cin   { let,Val,lambda,EOF,-,(,OROR,<,cout,cin,==,&&,else,%,+,if,/,COLON,Var,while,^,*,!,<=,),;, }
  (27) E --> .Var   { -,^,lambda,let,Var,while,&&,!,<,%,==,(,EOF,cout,<=,/,if,Val,cin,OROR,COLON,*,else,),+,;, }
  (18) E --> .- E   { ^,+,cout,<=,<,Var,Val,else,if,),(,*,;,-,!,EOF,let,==,while,cin,OROR,/,lambda,&&,%,COLON, }
  (6) E --> .E + E   { ^,cin,EOF,/,*,&&,lambda,COLON,Val,<=,+,-,Var,while,!,else,(,if,==,cout,;,let,<,OROR,),%, }
  (17) E --> .E OROR E   { <,cout,!,==,/,else,^,-,cin,COLON,EOF,(,*,&&,let,if,lambda,%,Val,<=,Var,;,+,OROR,while,), }
  (1) E --> .( E )   { else,%,COLON,*,lambda,<,EOF,),&&,/,if,Var,while,Val,(,!,<=,;,+,-,cin,^,==,cout,let,OROR, }
  (17) E --> E OROR .E   { ),let,<,==,<=,&&,OROR,while,/,cin,!,EOF,lambda,Var,^,Val,cout,%,else,+,-,*,;,(,if,COLON, }
  (21) E --> .Var = E   { ),*,let,if,!,^,Var,<,==,EOF,cout,COLON,cin,/,Val,&&,+,lambda,<=,else,%,(,OROR,;,-,while, }
  (9) E --> .E / E   { if,OROR,!,==,else,),/,Var,Val,COLON,cout,EOF,lambda,-,*,<,while,%,&&,(,<=,^,cin,+,let,;, }
  (20) E --> .let Var = E COLON E   { ^,==,COLON,(,let,+,<,else,),;,Var,*,cout,if,<=,EOF,Val,&&,while,!,cin,-,/,lambda,%,OROR, }
  (22) E --> .lambda Var . E   { ),if,/,else,EOF,;,<=,+,%,&&,OROR,lambda,^,*,while,let,!,==,Val,Var,COLON,cout,<,-,cin,(, }
state 22:
  (17) E --> .E OROR E   { *,lambda,/,while,&&,else,;,cin,==,^,EOF,),<,(,let,!,-,if,<=,COLON,Val,Var,+,OROR,%,cout, }
  (15) E --> .while ( E ) E   { (,%,let,^,else,EOF,Val,),cout,COLON,*,while,!,<=,OROR,lambda,+,-,if,==,;,Var,/,cin,&&,<, }
  (18) E --> .- E   { ^,;,%,if,lambda,while,OROR,<,+,EOF,cin,!,-,(,Var,else,COLON,let,/,&&,*,<=,cout,==,),Val, }
  (1) E --> .( E )   { &&,!,;,cout,==,^,),Var,%,<,Val,(,/,lambda,EOF,while,*,COLON,+,cin,<=,if,-,else,let,OROR, }
  (20) E --> .let Var = E COLON E   { COLON,+,if,cout,<=,*,&&,!,<,==,else,Var,lambda,),while,/,;,OROR,%,EOF,Val,cin,-,(,let,^, }
  (12) E --> .E == E   { !,(,%,),;,==,OROR,COLON,let,^,cin,while,*,EOF,+,<=,Val,else,/,&&,cout,-,<,if,lambda,Var, }
  (27) E --> .Var   { !,^,%,&&,-,/,*,EOF,let,lambda,while,else,cout,<,if,==,(,OROR,),COLON,+,<=,Val,cin,Var,;, }
  (14) E --> .E <= E   { if,<,==,<=,cin,+,!,Var,OROR,else,while,&&,-,EOF,let,%,lambda,*,;,COLON,(,Val,^,),cout,/, }
  (3) E --> .cin   { else,*,cout,if,-,!,;,lambda,^,&&,(,Var,COLON,<,+,let,EOF,%,cin,<=,==,/,OROR,Val,while,), }
  (9) E --> .E / E   { OROR,;,EOF,(,),-,else,*,cout,%,cin,Val,let,&&,!,while,^,<,/,if,==,COLON,+,Var,<=,lambda, }
  (6) E --> .E + E   { Val,+,;,cout,while,&&,==,EOF,^,!,(,-,%,else,if,Var,<=,OROR,COLON,),*,let,lambda,<,cin,/, }
  (5) E --> .cout E   { -,/,let,<=,if,Val,OROR,<,;,==,while,cin,!,cout,COLON,+,else,),EOF,^,(,&&,*,%,Var,lambda, }
  (13) E --> .E < E   { ==,&&,(,Var,while,cin,COLON,OROR,<,%,;,if,^,Val,+,!,else,*,<=,cout,),/,let,lambda,EOF,-, }
  (10) E --> .E % E   { ^,*,%,cin,),else,EOF,<,let,if,==,(,!,<=,while,-,;,COLON,Var,cout,Val,&&,/,lambda,OROR,+, }
  (22) E --> .lambda Var . E   { +,lambda,&&,<,else,Var,<=,),-,let,^,;,(,==,cin,!,cout,COLON,*,/,OROR,%,if,EOF,while,Val, }
  (4) E --> .cout Str   { -,/,!,let,==,if,COLON,),+,&&,<,Val,OROR,cout,(,<=,EOF,%,^,;,lambda,while,cin,Var,*,else, }
  (21) E --> .Var = E   { ^,Var,+,/,Val,<,OROR,lambda,;,cout,-,else,EOF,let,cin,%,*,COLON,==,if,(,),!,&&,while,<=, }
  (7) E --> .E - E   { <=,),+,if,EOF,%,-,;,let,&&,<,while,lambda,Val,==,else,OROR,Var,!,cin,*,cout,COLON,(,^,/, }
  (24) E --> .E ; ES   { -,==,else,COLON,/,lambda,if,;,*,<,while,EOF,+,cin,&&,),let,^,Var,OROR,cout,<=,!,Val,(,%, }
  (11) E --> .E ^ E   { /,<=,Var,if,cout,;,<,%,&&,lambda,COLON,else,let,),!,-,^,*,cin,OROR,==,+,(,EOF,Val,while, }
  (23) E --> .if E E else E   { <,if,/,COLON,while,),;,Val,OROR,!,Var,cin,-,*,^,(,cout,&&,<=,==,+,lambda,EOF,let,%,else, }
  (16) E --> .E && E   { COLON,else,;,Var,let,while,^,!,OROR,<=,lambda,),Val,%,+,cin,(,&&,-,cout,*,if,/,EOF,<,==, }
  (2) E --> .( Var E )   { while,!,/,EOF,&&,cin,*,<=,Val,+,COLON,(,Var,lambda,==,let,if,%,OROR,),<,;,cout,-,^,else, }
  (0) E --> .Val   { cout,<,/,EOF,!,COLON,),Val,*,+,else,if,(,&&,cin,OROR,==,-,let,lambda,;,%,Var,^,<=,while, }
  (8) E --> .E * E   { ==,/,),cin,else,let,;,while,COLON,&&,cout,%,<,OROR,<=,!,EOF,Val,(,+,-,^,lambda,if,*,Var, }
  (19) E --> .! E   { !,^,let,),Val,*,lambda,OROR,;,<,Var,+,cin,EOF,cout,&&,(,<=,%,-,/,while,else,if,COLON,==, }
  (11) E --> E ^ .E   { else,<=,EOF,<,OROR,&&,==,*,COLON,-,let,%,cout,),lambda,^,cin,+,Var,;,if,(,Val,/,while,!, }
state 23:
  (4) E --> .cout Str   { if,-,),<=,!,Val,let,/,==,*,+,COLON,while,cout,else,Var,^,;,EOF,lambda,<,cin,OROR,%,&&,(, }
  (1) E --> .( E )   { ==,else,Val,<,(,),EOF,Var,;,^,lambda,while,+,&&,cout,let,OROR,%,cin,COLON,if,/,!,*,-,<=, }
  (11) E --> .E ^ E   { ^,<=,let,!,if,while,Var,/,*,OROR,cout,),%,lambda,;,Val,&&,<,cin,-,EOF,==,(,+,else,COLON, }
  (12) E --> .E == E   { <,let,COLON,EOF,lambda,*,^,),cout,!,Var,OROR,+,while,Val,if,(,;,-,<=,==,&&,%,else,cin,/, }
  (24) E --> .E ; ES   { ),cout,;,else,*,OROR,cin,+,EOF,Var,lambda,COLON,^,(,-,/,<,<=,==,while,!,if,let,Val,%,&&, }
  (22) E --> .lambda Var . E   { *,else,lambda,cout,%,COLON,&&,(,let,),if,<,/,==,EOF,OROR,+,^,cin,Var,!,while,-,;,Val,<=, }
  (5) E --> .cout E   { Val,==,cout,Var,(,EOF,*,while,COLON,<=,%,<,!,if,lambda,&&,-,OROR,cin,;,else,^,let,+,/,), }
  (9) E --> E / .E   { ;,^,!,OROR,Val,let,/,-,Var,EOF,),+,lambda,if,cout,while,else,==,&&,<,(,cin,%,*,<=,COLON, }
  (6) E --> .E + E   { if,(,EOF,COLON,!,*,Val,Var,cout,else,while,%,+,^,-,lambda,let,==,&&,OROR,<,cin,/,;,),<=, }
  (14) E --> .E <= E   { %,Var,cin,!,else,OROR,while,==,;,let,Val,*,<=,^,<,(,lambda,COLON,-,+,/,),if,&&,EOF,cout, }
  (18) E --> .- E   { /,else,;,(,<=,Val,<,OROR,lambda,&&,+,cin,^,Var,EOF,!,*,COLON,==,let,if,-,),%,while,cout, }
  (15) E --> .while ( E ) E   { else,^,if,Var,!,*,&&,+,COLON,EOF,-,let,),cin,while,;,/,lambda,cout,%,<,==,OROR,<=,Val,(, }
  (27) E --> .Var   { <,COLON,;,+,-,!,EOF,),/,OROR,else,Val,^,<=,while,cout,==,cin,(,%,&&,*,let,lambda,if,Var, }
  (3) E --> .cin   { *,Val,cout,if,==,(,<,-,let,&&,!,Var,/,OROR,COLON,lambda,+,cin,EOF,<=,),^,while,%,;,else, }
  (9) E --> .E / E   { cin,&&,%,let,;,(,else,lambda,),OROR,Val,!,==,Var,<=,/,cout,+,-,COLON,while,^,*,<,EOF,if, }
  (23) E --> .if E E else E   { COLON,),&&,while,==,^,else,!,%,let,lambda,if,<,Var,;,EOF,*,/,+,<=,(,Val,OROR,-,cout,cin, }
  (10) E --> .E % E   { ),+,lambda,;,^,%,*,-,cin,while,(,&&,!,OROR,COLON,Var,EOF,let,if,==,/,cout,<=,else,Val,<, }
  (21) E --> .Var = E   { !,while,lambda,+,Var,else,(,%,cin,<,<=,),Val,;,/,==,-,*,OROR,let,cout,if,&&,COLON,^,EOF, }
  (0) E --> .Val   { *,^,Val,<,OROR,+,/,lambda,<=,cin,(,Var,while,;,if,-,EOF,),==,&&,COLON,cout,else,%,!,let, }
  (20) E --> .let Var = E COLON E   { OROR,^,EOF,let,+,<=,/,else,cout,*,Var,cin,-,while,&&,Val,),COLON,(,;,==,<,if,%,lambda,!, }
  (7) E --> .E - E   { ==,%,else,let,<,while,-,OROR,&&,;,!,Var,EOF,*,if,Val,^,cin,+,<=,lambda,(,/,COLON,cout,), }
  (16) E --> .E && E   { /,lambda,+,while,Val,cout,&&,<=,==,Var,-,let,*,if,%,else,!,^,COLON,cin,),;,OROR,(,<,EOF, }
  (2) E --> .( Var E )   { COLON,&&,if,+,-,%,cout,Val,!,^,*,<=,cin,<,),else,EOF,/,(,lambda,==,while,Var,;,OROR,let, }
  (13) E --> .E < E   { -,<,let,;,Val,cin,while,<=,*,!,^,cout,%,),&&,==,lambda,Var,EOF,if,else,OROR,COLON,/,+,(, }
  (19) E --> .! E   { <,OROR,cin,),-,Var,else,^,EOF,!,cout,&&,==,;,%,(,lambda,COLON,if,/,+,*,Val,let,while,<=, }
  (17) E --> .E OROR E   { else,if,^,COLON,Val,EOF,+,OROR,let,==,%,/,Var,(,;,*,cout,while,!,),&&,-,cin,<,lambda,<=, }
  (8) E --> .E * E   { cin,Val,;,-,while,if,^,OROR,<=,let,lambda,(,EOF,&&,==,*,%,else,cout,Var,+,/,<,!,COLON,), }
state 24:
  (3) E --> .cin   { OROR,else,+,==,/,while,;,),lambda,<=,Var,*,COLON,&&,^,!,(,-,cin,EOF,%,let,Val,<,if,cout, }
  (19) E --> .! E   { %,EOF,cin,<=,if,*,+,!,OROR,let,else,^,lambda,cout,<,while,/,COLON,Val,-,==,;,&&,(,Var,), }
  (8) E --> .E * E   { /,while,else,cout,let,+,Val,EOF,*,if,cin,;,COLON,!,<,Var,<=,==,&&,%,^,lambda,-,OROR,(,), }
  (2) E --> .( Var E )   { EOF,cin,lambda,%,OROR,else,let,&&,Val,COLON,if,cout,while,(,-,Var,<=,),!,<,;,+,*,^,/,==, }
  (15) E --> .while ( E ) E   { while,cout,/,<,&&,-,!,),Val,*,;,%,else,+,Var,if,==,OROR,lambda,cin,EOF,let,<=,(,COLON,^, }
  (12) E --> .E == E   { /,!,else,%,if,let,while,cin,),-,<,<=,+,(,;,&&,lambda,cout,Var,==,*,EOF,Val,COLON,^,OROR, }
  (21) E --> .Var = E   { %,&&,+,else,/,^,cin,*,lambda,(,-,<,while,==,!,),cout,COLON,<=,let,Var,;,if,EOF,OROR,Val, }
  (16) E --> .E && E   { OROR,*,==,COLON,Val,!,%,let,),EOF,&&,<=,Var,;,(,if,-,+,^,lambda,cout,cin,else,/,<,while, }
  (1) E --> .( E )   { ^,OROR,%,&&,-,;,/,(,lambda,let,if,!,EOF,*,cin,while,else,<=,+,COLON,),Val,==,Var,cout,<, }
  (27) E --> .Var   { lambda,else,OROR,==,while,/,-,let,!,),Var,^,+,<,Val,(,%,cin,COLON,&&,if,*,;,EOF,<=,cout, }
  (18) E --> .- E   { -,*,;,lambda,else,%,),while,OROR,/,Var,&&,COLON,(,EOF,!,if,cout,^,cin,<,+,Val,<=,let,==, }
  (6) E --> .E + E   { ^,+,OROR,lambda,while,==,EOF,*,%,if,let,Val,else,cout,-,;,COLON,<,(,),/,!,&&,Var,<=,cin, }
  (11) E --> .E ^ E   { *,cin,let,if,==,+,!,),/,while,(,cout,Val,else,EOF,^,<=,Var,&&,lambda,;,-,%,OROR,COLON,<, }
  (24) E --> .E ; ES   { ),;,cout,(,+,%,-,Val,lambda,let,cin,==,while,COLON,*,<=,Var,else,EOF,!,&&,if,/,OROR,<,^, }
  (0) E --> .Val   { COLON,/,;,cin,^,%,Var,EOF,+,let,if,else,OROR,!,),-,==,cout,<=,&&,Val,<,(,lambda,while,*, }
  (14) E --> .E <= E   { while,let,lambda,if,;,<=,&&,/,+,!,cout,<,EOF,-,%,cin,COLON,OROR,Var,else,Val,==,^,),(,*, }
  (7) E --> .E - E   { ;,*,/,Val,EOF,Var,if,!,-,let,while,else,==,lambda,<=,%,),^,cout,COLON,<,(,OROR,&&,+,cin, }
  (10) E --> .E % E   { if,==,!,+,*,let,&&,;,%,else,<,COLON,OROR,cin,-,(,),EOF,^,<=,while,cout,/,Var,lambda,Val, }
  (22) E --> .lambda Var . E   { <=,<,else,while,+,cout,^,cin,&&,EOF,(,OROR,==,if,/,lambda,-,%,!,Val,;,*,),Var,COLON,let, }
  (4) E --> .cout Str   { cin,OROR,else,lambda,/,+,cout,&&,==,^,while,EOF,%,if,Var,Val,;,(,),let,<=,COLON,-,<,!,*, }
  (5) E --> .cout E   { while,==,lambda,),OROR,COLON,;,let,*,Val,else,cout,(,cin,-,EOF,&&,Var,/,if,<=,^,!,%,<,+, }
  (17) E --> .E OROR E   { *,<=,&&,(,Val,!,==,),;,while,OROR,EOF,%,COLON,-,let,cout,^,Var,/,cin,if,lambda,else,<,+, }
  (23) E --> .if E E else E   { +,==,%,OROR,lambda,^,let,&&,EOF,Val,COLON,/,cin,else,-,cout,),while,Var,<=,*,(,!,<,;,if, }
  (13) E --> .E < E   { +,EOF,if,;,Val,COLON,/,<=,<,==,(,%,while,!,),&&,else,-,*,OROR,Var,cin,lambda,cout,let,^, }
  (9) E --> .E / E   { cin,while,!,else,Var,OROR,/,),<=,if,==,*,COLON,-,cout,let,+,&&,<,(,%,EOF,^,lambda,;,Val, }
  (20) E --> .let Var = E COLON E   { ^,(,*,),else,!,-,let,%,lambda,Val,Var,if,cout,+,EOF,OROR,;,&&,while,COLON,==,<=,cin,/,<, }
  (6) E --> E + .E   { !,EOF,OROR,if,while,*,else,<=,),cout,<,&&,/,%,Var,COLON,let,+,^,;,cin,-,(,==,Val,lambda, }
state 25:
  (22) E --> lambda Var .. E   { OROR,else,Val,;,&&,==,^,EOF,cout,(,Var,+,-,<,*,<=,COLON,let,cin,lambda,%,),if,/,while,!, }
state 26:
  (16) E --> E .&& E   { Var,while,COLON,==,<=,-,%,*,cin,),;,lambda,EOF,+,^,cout,let,&&,/,else,OROR,<,Val,if,(,!, }
  (6) E --> E .+ E   { cout,+,<,/,&&,else,;,(,==,lambda,^,EOF,Val,COLON,cin,if,let,<=,OROR,Var,while,),-,*,!,%, }
  (12) E --> E .== E   { <=,),cin,*,COLON,!,OROR,==,;,%,else,let,<,/,EOF,Val,&&,Var,(,-,+,while,if,lambda,^,cout, }
  (10) E --> E .% E   { (,^,-,<=,COLON,else,EOF,%,if,cout,;,Val,lambda,==,Var,let,+,while,OROR,),*,cin,!,<,/,&&, }
  (11) E --> E .^ E   { COLON,<=,cin,<,;,OROR,+,Var,let,(,),&&,^,else,!,if,while,%,EOF,*,lambda,Val,/,==,cout,-, }
  (13) E --> E .< E   { <,/,Var,if,EOF,OROR,+,%,*,while,),cout,COLON,let,!,<=,==,else,;,lambda,-,(,^,cin,Val,&&, }
  (9) E --> E ./ E   { -,lambda,==,while,<,else,<=,),cin,/,let,;,Var,+,OROR,COLON,%,EOF,&&,Val,cout,(,*,^,if,!, }
  (19) E --> ! E .   { (,*,!,EOF,+,OROR,while,cout,==,<,<=,&&,cin,else,%,),COLON,/,;,^,if,lambda,Var,-,Val,let, }
  (17) E --> E .OROR E   { cin,==,while,let,*,<,;,+,COLON,EOF,/,),if,OROR,Val,-,else,lambda,^,!,(,cout,<=,Var,&&,%, }
  (8) E --> E .* E   { *,;,<=,&&,lambda,-,Val,(,%,!,if,),OROR,==,/,COLON,<,Var,+,cout,while,cin,let,EOF,else,^, }
  (14) E --> E .<= E   { *,^,COLON,EOF,(,if,),cin,!,Val,Var,<,==,while,+,else,cout,&&,OROR,<=,;,%,/,-,lambda,let, }
  (7) E --> E .- E   { cout,;,^,!,/,Var,&&,%,cin,Val,+,OROR,<,==,(,while,let,COLON,-,EOF,*,lambda,else,<=,if,), }
  (24) E --> E .; ES   { if,let,;,(,==,Val,lambda,else,/,^,+,EOF,cout,&&,!,COLON,*,OROR,<=,),-,cin,Var,<,%,while, }
state 27:
  (16) E --> E .&& E   { lambda,cout,&&,+,(,*,Val,cin,!,/,while,^,;,<=,OROR,%,==,<,Var,let,if,-, }
  (24) E --> E .; ES   { !,*,cout,;,==,&&,Val,if,+,<,lambda,%,<=,-,let,/,^,cin,OROR,(,Var,while, }
  (5) E --> .cout E   { ^,==,/,*,&&,;,+,<=,else,OROR,<,-,%, }
  (3) E --> .cin   { OROR,%,^,*,==,<,+,/,<=,else,-,&&,;, }
  (14) E --> E .<= E   { &&,Var,<,*,lambda,cin,-,!,if,/,(,^,==,;,while,%,+,<=,Val,cout,let,OROR, }
  (8) E --> E .* E   { <,while,let,cin,/,==,if,-,Var,*,Val,<=,(,+,&&,%,;,!,^,lambda,cout,OROR, }
  (7) E --> E .- E   { /,if,cout,&&,cin,Var,-,+,!,(,%,;,while,Val,*,OROR,==,^,<,let,lambda,<=, }
  (6) E --> .E + E   { ^,;,/,<,-,else,==,&&,OROR,%,<=,+,*, }
  (22) E --> .lambda Var . E   { +,OROR,<=,/,<,==,&&,*,^,else,-,%,;, }
  (14) E --> .E <= E   { -,<=,%,==,OROR,<,;,*,+,else,/,&&,^, }
  (23) E --> .if E E else E   { <=,-,OROR,&&,;,+,<,%,/,^,else,==,*, }
  (9) E --> .E / E   { ;,+,*,^,OROR,<=,else,<,/,==,-,%,&&, }
  (4) E --> .cout Str   { /,==,;,<=,^,&&,+,-,%,<,else,OROR,*, }
  (8) E --> .E * E   { else,*,-,==,+,^,<,/,&&,;,%,<=,OROR, }
  (7) E --> .E - E   { ==,else,+,%,<=,OROR,;,<,^,-,/,&&,*, }
  (20) E --> .let Var = E COLON E   { ;,+,-,/,*,<=,&&,else,<,OROR,%,^,==, }
  (18) E --> .- E   { <,==,^,;,-,%,*,<=,/,&&,else,+,OROR, }
  (17) E --> .E OROR E   { ;,==,else,<=,/,%,-,^,OROR,&&,<,+,*, }
  (0) E --> .Val   { &&,*,;,-,==,%,<,+,else,^,/,<=,OROR, }
  (11) E --> .E ^ E   { ==,-,<=,&&,%,^,<,OROR,/,+,else,;,*, }
  (12) E --> E .== E   { lambda,cout,;,^,-,while,<,cin,(,Val,+,OROR,/,&&,if,%,*,!,let,==,Var,<=, }
  (21) E --> .Var = E   { <,+,&&,^,/,%,==,*,-,<=,else,OROR,;, }
  (6) E --> E .+ E   { ;,<,if,-,!,Var,let,cin,Val,/,&&,lambda,while,<=,%,cout,*,==,^,OROR,(,+, }
  (24) E --> .E ; ES   { -,<,OROR,+,;,%,<=,==,/,*,&&,else,^, }
  (12) E --> .E == E   { &&,-,;,%,+,<=,^,<,==,OROR,/,else,*, }
  (10) E --> .E % E   { +,OROR,&&,else,^,;,/,==,<,<=,*,-,%, }
  (23) E --> if E .E else E   { lambda,cin,!,+,^,==,*,Val,&&,while,<,EOF,),-,let,Var,<=,OROR,cout,%,else,/,COLON,if,(,;, }
  (19) E --> .! E   { %,;,*,<,&&,-,+,<=,==,OROR,^,else,/, }
  (11) E --> E .^ E   { cout,-,Var,^,+,while,(,<=,/,if,;,!,==,<,let,%,cin,*,lambda,Val,&&,OROR, }
  (9) E --> E ./ E   { /,!,Var,==,*,%,lambda,<,^,-,Val,let,<=,+,cin,;,if,OROR,(,cout,&&,while, }
  (13) E --> .E < E   { ;,/,<=,-,&&,%,<,else,+,OROR,==,*,^, }
  (10) E --> E .% E   { !,if,lambda,-,^,/,;,Val,<=,(,let,+,<,cin,%,*,OROR,==,cout,Var,while,&&, }
  (16) E --> .E && E   { <,^,-,<=,&&,==,+,else,OROR,*,%,;,/, }
  (17) E --> E .OROR E   { ^,Var,;,/,*,Val,%,lambda,(,&&,<=,let,<,OROR,==,cout,cin,+,!,-,if,while, }
  (1) E --> .( E )   { <=,&&,/,+,;,^,OROR,%,*,-,==,<,else, }
  (15) E --> .while ( E ) E   { +,&&,/,-,OROR,==,<=,else,%,^,;,*,<, }
  (2) E --> .( Var E )   { ==,^,*,OROR,/,&&,<=,%,<,else,+,-,;, }
  (27) E --> .Var   { <=,*,==,%,<,-,+,&&,;,OROR,^,/,else, }
  (13) E --> E .< E   { Var,Val,<=,while,-,let,lambda,+,&&,*,cout,!,/,(,<,cin,==,%,if,^,;,OROR, }
state 28:
  (18) E --> - E .   { *,COLON,==,while,(,Var,lambda,if,%,cin,<=,Val,cout,),EOF,;,/,<,OROR,^,-,!,let,else,+,&&, }
  (10) E --> E .% E   { COLON,<=,!,^,<,(,while,cin,&&,Val,),if,;,lambda,OROR,let,%,Var,EOF,+,cout,else,==,/,*,-, }
  (12) E --> E .== E   { else,cout,cin,!,/,(,let,^,-,%,if,COLON,Var,&&,<,==,+,while,),lambda,;,<=,OROR,Val,EOF,*, }
  (7) E --> E .- E   { cout,(,-,EOF,!,lambda,<=,^,if,<,*,;,==,OROR,/,),COLON,while,%,else,cin,Var,&&,let,+,Val, }
  (6) E --> E .+ E   { <=,+,lambda,/,Val,COLON,%,while,Var,let,!,*,else,(,cin,;,<,cout,OROR,==,EOF,&&,if,^,-,), }
  (9) E --> E ./ E   { else,&&,COLON,),let,!,%,cin,;,cout,Var,Val,lambda,(,/,<,*,^,while,OROR,==,EOF,if,<=,-,+, }
  (17) E --> E .OROR E   { cout,lambda,cin,==,!,<=,),(,OROR,COLON,/,let,+,EOF,%,Var,&&,while,<,Val,else,if,-,^,*,;, }
  (8) E --> E .* E   { ;,+,),cin,-,==,let,else,Val,/,Var,!,<,&&,*,<=,EOF,cout,lambda,OROR,if,COLON,while,^,%,(, }
  (24) E --> E .; ES   { !,-,==,(,let,<=,cout,else,*,if,+,<,%,&&,/,),cin,^,while,Var,;,OROR,EOF,COLON,lambda,Val, }
  (14) E --> E .<= E   { Val,^,==,if,cin,else,EOF,cout,<=,<,*,&&,lambda,while,!,let,(,-,;,Var,OROR,/,%,),+,COLON, }
  (11) E --> E .^ E   { /,(,<=,-,if,*,cout,lambda,==,;,let,!,OROR,EOF,&&,else,%,),+,while,COLON,<,Var,cin,^,Val, }
  (13) E --> E .< E   { <,<=,!,(,;,Var,cin,/,),==,let,lambda,+,if,-,EOF,*,else,Val,^,OROR,cout,COLON,&&,%,while, }
  (16) E --> E .&& E   { ==,%,if,^,;,),&&,-,cin,(,let,cout,*,/,EOF,COLON,<,<=,+,while,Val,Var,!,lambda,else,OROR, }
state 29:
  (27) E --> .Var   { +,else,==,&&,EOF,Val,<=,cin,(,/,^,lambda,-,let,;,Var,if,!,),cout,while,<,%,*,COLON,OROR, }
  (24) E --> .E ; ES   { Val,if,<=,OROR,),&&,==,cout,;,<,else,Var,*,(,while,^,COLON,EOF,/,-,let,!,cin,lambda,%,+, }
  (16) E --> .E && E   { <=,OROR,%,cin,else,(,if,*,+,cout,;,while,),==,&&,Var,/,!,-,let,lambda,Val,<,EOF,COLON,^, }
  (21) E --> Var = .E   { EOF,!,cout,<=,/,&&,%,^,;,),while,cin,let,COLON,OROR,else,==,*,lambda,-,Val,(,<,if,+,Var, }
  (3) E --> .cin   { Val,EOF,&&,==,(,COLON,+,else,while,lambda,cin,-,!,if,),;,let,cout,%,<,Var,<=,OROR,^,/,*, }
  (14) E --> .E <= E   { /,Val,OROR,while,!,else,if,),<=,&&,COLON,cout,lambda,Var,(,cin,let,+,%,<,;,EOF,==,^,*,-, }
  (11) E --> .E ^ E   { while,Val,+,*,COLON,cin,==,let,!,if,&&,else,;,(,<,/,^,cout,lambda,<=,Var,OROR,),%,-,EOF, }
  (13) E --> .E < E   { lambda,while,-,),==,cout,&&,else,(,+,let,!,<,<=,OROR,*,COLON,cin,/,Val,;,if,%,EOF,Var,^, }
  (17) E --> .E OROR E   { %,/,-,(,Var,lambda,while,<=,EOF,<,COLON,let,),^,;,cout,&&,*,!,+,OROR,Val,cin,if,==,else, }
  (8) E --> .E * E   { COLON,let,+,;,OROR,^,lambda,cin,(,cout,<,EOF,while,!,Val,Var,*,-,),/,%,==,if,&&,else,<=, }
  (6) E --> .E + E   { -,OROR,<,/,cin,+,EOF,==,%,Var,),!,*,lambda,;,Val,cout,&&,while,else,(,if,^,<=,let,COLON, }
  (0) E --> .Val   { <=,Val,else,/,),EOF,cout,-,cin,OROR,;,%,Var,let,<,while,lambda,==,COLON,^,!,*,+,(,&&,if, }
  (15) E --> .while ( E ) E   { Var,<,OROR,;,cin,Val,-,cout,<=,COLON,EOF,),while,(,lambda,if,*,let,else,+,!,^,==,/,%,&&, }
  (4) E --> .cout Str   { COLON,cout,Val,/,==,(,else,if,%,<=,^,EOF,OROR,-,;,+,*,cin,!,Var,),&&,while,lambda,<,let, }
  (9) E --> .E / E   { -,),!,*,;,cin,else,<,EOF,Var,(,%,OROR,&&,lambda,^,while,if,==,<=,let,/,Val,+,COLON,cout, }
  (7) E --> .E - E   { Val,^,<,COLON,cout,<=,;,lambda,OROR,*,+,(,Var,%,while,!,else,-,),if,==,let,/,&&,cin,EOF, }
  (19) E --> .! E   { if,cin,cout,*,%,),EOF,while,^,lambda,OROR,-,/,(,Var,<,&&,+,Val,!,==,COLON,<=,;,let,else, }
  (22) E --> .lambda Var . E   { Var,if,let,&&,COLON,/,Val,-,),EOF,OROR,while,*,else,<,cout,cin,%,<=,!,;,(,+,^,==,lambda, }
  (1) E --> .( E )   { EOF,==,*,&&,),let,+,(,else,cin,!,if,%,/,while,<=,^,Var,cout,Val,;,<,lambda,OROR,-,COLON, }
  (18) E --> .- E   { /,!,lambda,OROR,<=,while,EOF,-,cout,<,Val,;,%,==,^,if,let,Var,),COLON,&&,cin,else,+,*,(, }
  (23) E --> .if E E else E   { <,COLON,^,let,OROR,Var,lambda,-,+,if,),==,;,*,%,/,Val,<=,cout,!,while,&&,cin,else,EOF,(, }
  (5) E --> .cout E   { /,<=,-,!,Val,else,<,Var,*,%,+,cout,OROR,while,;,COLON,EOF,let,(,lambda,if,),&&,cin,^,==, }
  (20) E --> .let Var = E COLON E   { while,cout,lambda,Var,if,!,let,Val,else,(,<=,<,==,/,COLON,+,cin,EOF,^,;,),%,-,&&,OROR,*, }
  (10) E --> .E % E   { EOF,cout,lambda,^,),-,Val,/,cin,<,!,%,OROR,else,if,+,COLON,;,&&,Var,while,==,<=,*,(,let, }
  (12) E --> .E == E   { EOF,cin,<,COLON,Val,else,<=,*,(,cout,+,while,==,-,&&,OROR,lambda,let,%,Var,if,;,^,!,),/, }
  (2) E --> .( Var E )   { ==,Val,Var,EOF,<,!,while,lambda,-,),;,else,(,cout,OROR,if,+,COLON,&&,let,%,/,*,cin,^,<=, }
  (21) E --> .Var = E   { !,else,==,Var,lambda,-,if,%,EOF,COLON,),/,cin,<=,cout,(,while,;,*,<,^,let,Val,+,&&,OROR, }
state 30:
  (14) E --> .E <= E   { +,<=,),==,&&,*,<,^,%,OROR,/,-,;, }
  (20) E --> .let Var = E COLON E   { *,<=,&&,/,^,==,+,%,-,),OROR,;,<, }
  (5) E --> .cout E   { +,==,),OROR,;,&&,-,%,<=,*,^,<,/, }
  (4) E --> .cout Str   { ^,&&,==,<=,;,),<,-,%,+,*,/,OROR, }
  (17) E --> .E OROR E   { -,),*,^,/,<=,;,+,%,==,OROR,&&,<, }
  (13) E --> .E < E   { ^,;,),<=,==,/,OROR,&&,<,-,%,+,*, }
  (9) E --> .E / E   { &&,+,OROR,%,^,<=,;,*,/,==,<,-,), }
  (6) E --> .E + E   { OROR,<,==,*,<=,;,^,/,+,%,),-,&&, }
  (1) E --> .( E )   { &&,-,/,<=,^,),*,==,;,+,%,<,OROR, }
  (7) E --> .E - E   { %,^,<=,/,<,),&&,*,+,-,OROR,;,==, }
  (15) E --> .while ( E ) E   { ;,OROR,+,/,&&,<,*,<=,-,^,),%,==, }
  (11) E --> .E ^ E   { ;,+,<=,&&,-,%,/,==,*,<,OROR,^,), }
  (18) E --> .- E   { <=,+,/,-,==,OROR,&&,<,*,),;,%,^, }
  (22) E --> .lambda Var . E   { OROR,),/,;,+,<=,&&,<,-,*,^,%,==, }
  (23) E --> .if E E else E   { ;,^,&&,OROR,*,),<,+,<=,%,/,-,==, }
  (0) E --> .Val   { +,&&,OROR,-,<=,;,==,*,<,%,^,),/, }
  (15) E --> while ( .E ) E   { +,!,<=,Val,&&,let,*,else,COLON,/,if,<,),^,cin,==,(,while,Var,EOF,;,OROR,cout,lambda,%,-, }
  (21) E --> .Var = E   { /,+,<,^,&&,),OROR,<=,-,;,*,%,==, }
  (12) E --> .E == E   { +,%,^,<=,*,),&&,OROR,-,/,<,;,==, }
  (10) E --> .E % E   { ;,%,&&,+,/,==,<,^,<=,OROR,*,-,), }
  (3) E --> .cin   { <,OROR,^,+,<=,),-,;,&&,==,/,*,%, }
  (19) E --> .! E   { ;,==,<,OROR,%,&&,+,^,-,/,<=,),*, }
  (24) E --> .E ; ES   { ),+,;,&&,OROR,*,<,/,%,<=,==,^,-, }
  (2) E --> .( Var E )   { ;,/,<,<=,==,*,),OROR,+,-,^,&&,%, }
  (8) E --> .E * E   { <,+,/,==,),&&,*,%,<=,-,^,;,OROR, }
  (27) E --> .Var   { ),*,OROR,-,==,<=,^,;,/,<,&&,+,%, }
  (16) E --> .E && E   { -,;,),*,==,&&,<=,/,^,OROR,+,%,<, }
state 31:
  (14) E --> E .<= E   { ==,*,if,let,^,%,;,lambda,OROR,),(,<=,+,EOF,&&,cin,while,Var,cout,<,else,COLON,Val,-,!,/, }
  (12) E --> E .== E   { OROR,/,*,&&,cin,==,+,-,^,lambda,!,%,<=,else,while,cout,EOF,;,),let,(,COLON,if,Val,Var,<, }
  (17) E --> E .OROR E   { OROR,!,Val,Var,cout,;,else,-,while,),<=,EOF,COLON,%,cin,let,*,+,<,&&,lambda,if,/,^,(,==, }
  (8) E --> E .* E   { ),;,OROR,else,%,-,^,!,+,Var,&&,cout,Val,let,lambda,cin,(,<=,/,<,if,EOF,==,while,COLON,*, }
  (9) E --> E ./ E   { &&,),==,while,cin,;,-,Val,if,^,+,lambda,(,Var,*,<=,/,!,EOF,COLON,let,%,OROR,else,cout,<, }
  (6) E --> E .+ E   { &&,Val,OROR,%,let,EOF,if,^,cout,cin,else,<,COLON,lambda,),-,while,(,==,/,Var,+,*,<=,;,!, }
  (13) E --> E .< E   { <=,Val,while,(,*,-,COLON,&&,cout,let,Var,!,/,+,==,if,;,OROR,lambda,EOF,cin,<,else,%,^,), }
  (5) E --> cout E .   { *,;,+,lambda,-,<=,cout,!,/,else,Val,&&,^,while,OROR,if,%,Var,==,COLON,EOF,<,(,),let,cin, }
  (24) E --> E .; ES   { (,/,EOF,-,!,<,*,let,;,cin,+,),Var,if,<=,%,COLON,lambda,&&,Val,else,while,==,cout,^,OROR, }
  (10) E --> E .% E   { +,lambda,(,while,COLON,!,Val,*,<=,),else,&&,OROR,^,let,-,cin,cout,Var,<,EOF,==,/,%,if,;, }
  (16) E --> E .&& E   { *,else,/,==,lambda,-,OROR,Var,<=,let,cin,EOF,!,<,+,%,;,COLON,if,while,Val,^,),&&,cout,(, }
  (7) E --> E .- E   { cout,let,),+,lambda,EOF,!,OROR,*,Var,^,while,&&,<,else,cin,<=,-,Val,if,COLON,==,/,%,(,;, }
  (11) E --> E .^ E   { OROR,if,EOF,(,cin,cout,<,<=,%,let,;,!,while,COLON,==,-,Var,*,^,/,lambda,Val,+,else,&&,), }
state 32:
  (4) E --> cout Str .   { Var,OROR,EOF,COLON,if,Val,cin,&&,%,<=,/,^,lambda,let,while,;,),!,*,<,(,else,-,cout,+,==, }
state 33:
  (21) E --> Var .= E   { <,OROR,<=,+,;,^,/,%,*,),==,&&,-, }
  (6) E --> .E + E   { ^,OROR,-,&&,<,;,*,/,==,%,<=,+,), }
  (15) E --> .while ( E ) E   { <,&&,%,),OROR,/,-,<=,^,;,+,==,*, }
  (27) E --> .Var   { ^,OROR,&&,<,*,/,-,<=,%,==,+,),;, }
  (24) E --> .E ; ES   { ==,;,/,*,-,<,),OROR,%,+,^,&&,<=, }
  (1) E --> .( E )   { <,==,*,<=,-,&&,%,+,OROR,/,^,;,), }
  (2) E --> ( Var .E )   { &&,let,),Val,EOF,+,;,<=,<,else,^,Var,%,*,while,-,/,(,cout,COLON,cin,==,if,OROR,!,lambda, }
  (7) E --> .E - E   { ^,*,+,/,&&,%,<=,<,),OROR,==,;,-, }
  (8) E --> .E * E   { &&,/,OROR,+,^,<=,*,),;,==,%,<,-, }
  (5) E --> .cout E   { ^,;,<=,-,+,==,OROR,),<,&&,%,/,*, }
  (27) E --> Var .   { %,;,<=,-,^,<,==,OROR,&&,),/,*,+, }
  (19) E --> .! E   { ^,-,+,&&,OROR,;,==,<,<=,%,/,),*, }
  (12) E --> .E == E   { ^,+,&&,==,OROR,-,<=,),%,<,*,;,/, }
  (0) E --> .Val   { *,%,+,),&&,==,<,-,^,OROR,;,<=,/, }
  (18) E --> .- E   { -,<,+,),%,;,&&,==,^,*,/,<=,OROR, }
  (17) E --> .E OROR E   { ),+,^,OROR,<=,%,;,<,&&,==,*,-,/, }
  (21) E --> .Var = E   { -,+,%,^,<=,*,==,;,&&,),OROR,<,/, }
  (3) E --> .cin   { /,),;,+,<,OROR,^,<=,-,==,&&,%,*, }
  (14) E --> .E <= E   { ^,&&,<,),;,/,-,<=,+,OROR,%,*,==, }
  (20) E --> .let Var = E COLON E   { <=,),<,-,==,^,&&,%,+,*,/,OROR,;, }
  (10) E --> .E % E   { +,OROR,/,%,==,<,;,-,<=,^,&&,*,), }
  (11) E --> .E ^ E   { -,/,==,OROR,<,%,),+,&&,;,<=,^,*, }
  (2) E --> .( Var E )   { *,==,&&,-,<=,^,%,+,/,OROR,),;,<, }
  (16) E --> .E && E   { &&,+,;,<,-,^,%,),/,==,*,OROR,<=, }
  (22) E --> .lambda Var . E   { OROR,<,<=,),%,+,*,^,/,==,-,&&,;, }
  (9) E --> .E / E   { <,*,^,+,%,;,-,),OROR,<=,&&,==,/, }
  (23) E --> .if E E else E   { ==,&&,<=,/,;,<,+,*,),-,^,OROR,%, }
  (13) E --> .E < E   { /,%,<,-,&&,),*,^,OROR,+,;,<=,==, }
  (4) E --> .cout Str   { *,%,<,;,<=,OROR,&&,/,^,+,),==,-, }
state 34:
  (16) E --> E .&& E   { <,;,-,OROR,==,^,<=,/,%,&&,*,),+, }
  (11) E --> E .^ E   { <=,==,^,;,<,&&,+,/,OROR,),-,*,%, }
  (17) E --> E .OROR E   { ;,%,*,<,&&,+,<=,),==,OROR,/,^,-, }
  (24) E --> E .; ES   { /,<=,+,%,),;,<,*,==,^,-,&&,OROR, }
  (12) E --> E .== E   { ^,*,/,<,+,-,&&,),OROR,%,<=,==,;, }
  (1) E --> ( E .)   { OROR,Val,!,/,else,%,*,let,<=,),lambda,Var,cout,(,+,&&,^,==,if,EOF,cin,;,-,<,while,COLON, }
  (10) E --> E .% E   { <,),OROR,&&,^,%,-,+,;,==,<=,*,/, }
  (6) E --> E .+ E   { /,^,%,<=,<,OROR,;,*,+,==,-,),&&, }
  (14) E --> E .<= E   { -,;,+,OROR,&&,/,%,==,*,),<,^,<=, }
  (7) E --> E .- E   { &&,*,<,==,^,/,;,-,OROR,),+,<=,%, }
  (13) E --> E .< E   { <=,%,-,*,;,+,OROR,==,&&,),<,/,^, }
  (9) E --> E ./ E   { ),<=,OROR,+,*,==,/,<,%,-,;,^,&&, }
  (8) E --> E .* E   { <,==,+,;,/,&&,),%,^,-,*,OROR,<=, }
state 35:
  (20) E --> let Var .= E COLON E   { ^,+,<=,lambda,cin,&&,<,%,Var,*,if,cout,while,==,let,!,OROR,COLON,/,-,else,EOF,;,(,Val,), }
state 36:
  (14) E --> E .<= E   { COLON,+,OROR,cin,(,while,<,let,*,;,EOF,),Var,&&,else,lambda,Val,!,/,%,^,cout,==,if,<=,-, }
  (6) E --> E .+ E   { <=,^,%,COLON,==,+,cout,(,*,Val,&&,-,;,OROR,Var,/,EOF,lambda,while,if,),!,cin,else,let,<, }
  (10) E --> E .% E   { /,cout,-,&&,<=,;,EOF,!,+,^,),lambda,*,Val,%,let,Var,if,(,while,OROR,else,<,COLON,cin,==, }
  (11) E --> E .^ E   { (,/,%,+,==,OROR,cout,!,Var,if,^,),*,&&,let,EOF,<=,COLON,while,;,Val,cin,-,<,lambda,else, }
  (9) E --> E ./ E   { -,OROR,let,==,+,lambda,Val,),COLON,if,%,(,<=,Var,;,<,^,EOF,cout,!,&&,/,*,else,cin,while, }
  (7) E --> E .- E   { cin,+,<,;,else,cout,/,),lambda,%,<=,Val,&&,COLON,while,^,OROR,*,if,!,(,Var,==,-,EOF,let, }
  (8) E --> E * E .   { ),+,Val,if,-,!,^,;,let,*,while,COLON,(,<,%,EOF,&&,<=,/,else,OROR,==,cin,lambda,Var,cout, }
  (17) E --> E .OROR E   { cin,%,Var,while,if,),^,<,<=,OROR,(,+,&&,*,lambda,EOF,==,/,let,Val,else,-,cout,COLON,!,;, }
  (12) E --> E .== E   { ),&&,if,let,else,OROR,^,cin,COLON,Var,/,;,-,lambda,while,(,==,EOF,*,<=,<,+,%,!,Val,cout, }
  (8) E --> E .* E   { lambda,cin,<,else,+,if,/,<=,!,COLON,(,==,*,cout,;,),let,^,while,EOF,Val,Var,%,-,OROR,&&, }
  (13) E --> E .< E   { EOF,%,;,if,&&,/,!,cout,<,^,+,OROR,-,Var,while,else,*,(,==,lambda,),Val,<=,cin,COLON,let, }
  (16) E --> E .&& E   { else,Var,if,COLON,let,!,<=,cout,Val,==,(,+,-,;,lambda,EOF,OROR,&&,cin,),<,/,^,*,while,%, }
  (24) E --> E .; ES   { !,(,<=,cout,^,;,%,OROR,Val,),cin,if,lambda,while,*,Var,==,let,else,&&,COLON,+,<,-,/,EOF, }
state 37:
  (13) E --> E .< E   { if,+,cout,let,<=,Val,!,<,while,OROR,-,),&&,else,cin,==,EOF,%,*,;,^,/,lambda,Var,COLON,(, }
  (12) E --> E == E .   { &&,cout,while,COLON,cin,(,if,==,lambda,/,Val,OROR,let,EOF,<=,;,*,),<,else,%,Var,+,^,-,!, }
  (11) E --> E .^ E   { ),EOF,let,*,if,COLON,!,/,+,(,OROR,^,<,-,cout,lambda,<=,;,else,cin,Val,while,Var,&&,==,%, }
  (12) E --> E .== E   { Val,==,*,&&,(,),OROR,else,lambda,Var,/,if,%,while,!,cout,<,^,;,cin,EOF,<=,COLON,let,-,+, }
  (14) E --> E .<= E   { ==,COLON,-,+,EOF,%,if,Var,/,else,;,cout,cin,let,(,lambda,!,&&,),OROR,Val,*,^,while,<,<=, }
  (6) E --> E .+ E   { cin,lambda,if,<,),COLON,EOF,==,/,&&,let,else,<=,while,OROR,!,(,Val,-,Var,%,+,*,;,^,cout, }
  (7) E --> E .- E   { -,COLON,while,==,lambda,;,&&,OROR,if,cin,EOF,!,/,(,),Var,+,^,else,<,<=,Val,%,cout,let,*, }
  (24) E --> E .; ES   { -,OROR,Var,+,Val,*,cin,!,%,;,),lambda,<=,let,==,<,^,COLON,/,(,&&,else,while,if,cout,EOF, }
  (17) E --> E .OROR E   { ^,else,COLON,Var,lambda,-,%,cin,&&,<,<=,while,;,OROR,cout,/,==,let,+,if,*,EOF,),(,!,Val, }
  (8) E --> E .* E   { (,while,Var,&&,-,if,/,*,==,!,^,cout,cin,),Val,EOF,OROR,+,lambda,<,<=,%,;,else,let,COLON, }
  (9) E --> E ./ E   { cin,(,-,/,&&,<=,%,<,),EOF,lambda,+,if,^,while,cout,OROR,let,==,;,Val,!,else,COLON,*,Var, }
  (10) E --> E .% E   { /,EOF,Var,%,while,<,^,COLON,&&,==,else,<=,lambda,),let,-,*,OROR,Val,if,+,(,cout,cin,!,;, }
  (16) E --> E .&& E   { OROR,&&,cout,<,COLON,lambda,%,let,Var,/,EOF,Val,==,cin,^,+,!,;,),while,else,*,(,-,if,<=, }
state 38:
  (8) E --> E .* E   { ),cin,cout,while,OROR,let,lambda,COLON,-,Val,*,/,&&,==,+,;,^,!,Var,<,EOF,else,%,(,<=,if, }
  (17) E --> E .OROR E   { while,EOF,*,&&,/,cout,cin,if,^,(,else,==,Val,let,;,Var,lambda,COLON,<=,!,OROR,+,-,%,<,), }
  (12) E --> E .== E   { /,*,%,<,if,let,cout,COLON,),==,+,Val,EOF,Var,-,lambda,&&,<=,^,!,while,;,else,(,cin,OROR, }
  (14) E --> E <= E .   { cout,%,Val,cin,lambda,OROR,<=,*,let,EOF,),-,^,else,&&,/,(,;,if,Var,+,==,while,<,COLON,!, }
  (11) E --> E .^ E   { COLON,),!,<,while,let,(,Val,EOF,/,cin,+,^,Var,%,<=,==,-,if,*,lambda,OROR,cout,&&,;,else, }
  (24) E --> E .; ES   { cout,Var,&&,*,cin,-,EOF,while,==,if,%,let,<=,COLON,+,;,OROR,/,<,!,^,),(,else,lambda,Val, }
  (13) E --> E .< E   { ),<=,;,OROR,(,let,Val,if,*,&&,/,+,!,^,COLON,<,EOF,%,while,-,cout,Var,else,cin,==,lambda, }
  (16) E --> E .&& E   { while,/,lambda,Var,<,),cout,^,OROR,(,&&,;,<=,cin,let,-,+,EOF,COLON,Val,*,if,else,==,%,!, }
  (10) E --> E .% E   { &&,*,-,OROR,+,cout,if,^,Val,==,else,%,EOF,),lambda,Var,COLON,!,cin,while,/,<=,(,;,<,let, }
  (7) E --> E .- E   { Val,if,Var,/,<,COLON,EOF,<=,else,cout,%,(,;,lambda,^,cin,*,!,while,OROR,let,+,&&,),-,==, }
  (9) E --> E ./ E   { %,&&,/,^,*,(,;,let,cin,EOF,),!,lambda,cout,==,Val,OROR,COLON,Var,<=,while,else,+,-,if,<, }
  (14) E --> E .<= E   { cout,%,;,*,else,if,COLON,cin,while,<=,==,Var,),!,Val,EOF,lambda,OROR,^,-,+,(,/,let,&&,<, }
  (6) E --> E .+ E   { cout,!,-,(,else,EOF,*,&&,while,Var,;,),<=,<,cin,^,COLON,Val,lambda,/,%,+,OROR,let,==,if, }
state 39:
  (9) E --> E ./ E   { (,EOF,cout,;,Var,%,let,while,cin,COLON,&&,-,),==,Val,*,lambda,+,<=,OROR,if,else,/,!,^,<, }
  (8) E --> E .* E   { ==,Val,*,<,;,),cin,Var,%,else,/,lambda,!,COLON,<=,EOF,OROR,^,while,&&,-,cout,let,+,if,(, }
  (24) E --> E .; ES   { cin,cout,+,(,let,else,!,^,EOF,<=,if,Var,;,-,==,OROR,Val,/,&&,),while,lambda,%,<,*,COLON, }
  (6) E --> E .+ E   { ==,+,(,EOF,^,-,cin,OROR,%,<=,;,*,/,let,lambda,),while,else,cout,&&,!,Val,if,COLON,<,Var, }
  (7) E --> E .- E   { *,Var,OROR,!,==,<=,Val,let,while,+,),%,&&,lambda,if,EOF,cin,-,<,(,^,COLON,cout,;,else,/, }
  (10) E --> E .% E   { while,EOF,%,else,COLON,^,Var,lambda,),;,/,(,cin,!,&&,Val,OROR,<,if,<=,cout,+,*,-,==,let, }
  (17) E --> E .OROR E   { ),while,COLON,%,+,<,cout,let,-,cin,EOF,!,==,OROR,if,Val,else,^,/,lambda,<=,Var,;,&&,(,*, }
  (7) E --> E - E .   { ;,==,!,if,cout,^,*,%,),COLON,let,Val,lambda,-,+,EOF,Var,cin,/,<,&&,(,while,<=,else,OROR, }
  (11) E --> E .^ E   { ^,),lambda,Var,if,else,<=,+,!,-,%,<,let,;,cout,(,/,&&,EOF,OROR,while,COLON,*,==,Val,cin, }
  (13) E --> E .< E   { Val,*,let,OROR,!,else,&&,;,COLON,if,+,^,==,while,<=,Var,lambda,%,cin,/,<,(,EOF,),cout,-, }
  (14) E --> E .<= E   { Val,(,Var,/,&&,EOF,cout,;,%,else,COLON,*,if,-,lambda,<,+,cin,),^,let,==,OROR,while,!,<=, }
  (16) E --> E .&& E   { %,),<,OROR,==,!,(,&&,/,-,*,cin,+,;,Val,cout,else,let,^,while,if,EOF,<=,Var,COLON,lambda, }
  (12) E --> E .== E   { +,&&,OROR,-,;,<=,!,else,%,^,<,if,==,EOF,Val,COLON,/,Var,cin,let,lambda,while,(,cout,),*, }
state 40:
  (6) E --> E .+ E   { cin,let,<,-,==,;,!,cout,+,*,(,EOF,COLON,lambda,if,Var,),else,OROR,^,&&,/,%,while,<=,Val, }
  (8) E --> E .* E   { +,==,else,Var,%,<=,<,),OROR,while,cin,COLON,!,*,(,lambda,&&,EOF,if,;,let,/,-,cout,^,Val, }
  (24) E --> E .; ES   { ),/,EOF,<=,cin,+,&&,==,OROR,cout,if,^,;,!,<,*,-,Var,COLON,Val,lambda,let,(,%,else,while, }
  (9) E --> E ./ E   { Val,*,let,lambda,else,(,!,while,cout,cin,if,==,+,%,-,^,<=,Var,EOF,&&,;,OROR,<,COLON,),/, }
  (11) E --> E .^ E   { ),else,cout,/,let,if,*,==,+,;,&&,lambda,(,OROR,cin,COLON,!,while,%,-,Val,Var,^,<=,<,EOF, }
  (12) E --> E .== E   { /,==,cin,%,^,<,-,Val,while,EOF,lambda,else,OROR,!,;,&&,+,let,COLON,Var,<=,cout,*,if,),(, }
  (10) E --> E .% E   { cout,),/,;,let,if,(,cin,-,while,else,==,Var,*,!,OROR,Val,%,^,EOF,COLON,<=,lambda,+,&&,<, }
  (13) E --> E < E .   { while,let,&&,cin,<,OROR,),(,*,^,else,Var,/,if,<=,+,lambda,Val,EOF,!,-,==,%,COLON,cout,;, }
  (7) E --> E .- E   { cout,OROR,<,while,let,EOF,%,^,COLON,Val,Var,+,==,),cin,lambda,&&,(,;,else,-,*,if,/,!,<=, }
  (13) E --> E .< E   { <=,if,else,),OROR,;,Var,COLON,*,EOF,let,&&,+,cin,lambda,<,/,!,-,^,==,(,cout,Val,%,while, }
  (16) E --> E .&& E   { *,lambda,EOF,-,else,let,==,(,cout,while,Var,<=,COLON,Val,^,%,OROR,cin,if,/,+,),<,&&,!,;, }
  (17) E --> E .OROR E   { (,-,OROR,Val,<,let,while,<=,+,^,!,lambda,EOF,cout,),*,&&,COLON,if,;,/,else,%,Var,==,cin, }
  (14) E --> E .<= E   { lambda,EOF,let,COLON,<=,^,cin,while,),+,if,Var,/,==,(,else,*,OROR,cout,Val,!,&&,<,-,;,%, }
state 41:
  (12) E --> E .== E   { if,!,==,-,/,while,;,%,cin,+,^,else,lambda,let,&&,Val,OROR,),COLON,(,cout,Var,<=,EOF,<,*, }
  (13) E --> E .< E   { COLON,OROR,cout,while,-,*,EOF,(,+,%,==,^,if,&&,lambda,cin,else,Var,Val,<,/,),;,<=,!,let, }
  (11) E --> E .^ E   { %,<=,),;,==,(,COLON,else,cout,*,let,if,<,cin,&&,EOF,!,lambda,Val,while,Var,/,-,+,OROR,^, }
  (17) E --> E .OROR E   { Val,%,COLON,-,if,cin,else,==,let,Var,),*,;,OROR,while,<=,^,cout,<,!,(,/,+,&&,lambda,EOF, }
  (7) E --> E .- E   { let,),<=,-,cout,EOF,if,cin,else,^,OROR,&&,(,COLON,;,Var,<,/,while,*,%,+,!,==,Val,lambda, }
  (10) E --> E .% E   { let,!,/,^,<=,-,&&,else,),lambda,EOF,%,+,COLON,Val,*,;,Var,<,OROR,(,cout,while,if,==,cin, }
  (8) E --> E .* E   { OROR,cin,COLON,Val,while,<=,^,else,if,&&,*,),+,Var,%,==,(,cout,-,;,!,let,EOF,/,<,lambda, }
  (6) E --> E .+ E   { ^,;,/,-,lambda,cout,+,while,!,(,<,cin,Var,COLON,&&,),else,Val,<=,*,let,%,EOF,if,OROR,==, }
  (16) E --> E .&& E   { else,%,if,COLON,EOF,;,Var,==,lambda,(,let,-,cout,!,Val,^,*,+,OROR,/,),<=,<,cin,while,&&, }
  (14) E --> E .<= E   { Var,while,COLON,OROR,if,),<=,&&,^,else,let,+,EOF,lambda,;,cin,<,/,!,-,(,*,Val,==,%,cout, }
  (24) E --> E .; ES   { <=,Var,),EOF,(,cin,^,OROR,<,while,-,let,Val,/,lambda,if,+,cout,==,else,COLON,&&,!,*,%,;, }
  (9) E --> E ./ E   { +,if,Var,<=,(,COLON,*,-,;,OROR,!,lambda,let,cin,while,<,Val,%,),/,else,^,EOF,&&,==,cout, }
  (16) E --> E && E .   { *,if,&&,while,!,(,let,<,else,),lambda,Var,<=,/,EOF,==,^,cin,+,-,;,OROR,Val,%,COLON,cout, }
state 42:
  (14) E --> E .<= E   { while,EOF,(,Val,Var,-,+,else,let,cout,%,!,if,<=,/,OROR,*,COLON,cin,<,&&,;,^,),==,lambda, }
  (9) E --> E ./ E   { EOF,lambda,<,Var,),+,*,==,while,(,<=,&&,if,^,/,Val,OROR,!,let,-,else,cout,cin,;,COLON,%, }
  (7) E --> E .- E   { let,EOF,!,if,+,Val,),-,lambda,COLON,<,while,&&,/,%,cout,*,==,;,Var,cin,^,(,<=,else,OROR, }
  (10) E --> E .% E   { COLON,(,EOF,;,),-,&&,<=,Var,==,%,^,+,cout,*,Val,<,if,lambda,else,let,while,OROR,/,!,cin, }
  (10) E --> E % E .   { -,OROR,),!,cout,let,(,EOF,+,==,COLON,Val,<,^,Var,%,lambda,if,;,while,else,/,<=,*,cin,&&, }
  (24) E --> E .; ES   { let,if,-,COLON,!,+,Val,/,^,Var,*,),else,&&,EOF,(,%,<=,<,;,cin,OROR,lambda,cout,while,==, }
  (8) E --> E .* E   { lambda,cin,;,),let,&&,==,-,*,<,!,(,+,while,OROR,<=,else,%,EOF,COLON,cout,Val,/,^,if,Var, }
  (6) E --> E .+ E   { COLON,%,(,Var,while,/,==,;,!,if,cin,let,Val,else,^,&&,lambda,<,*,OROR,+,<=,-,),cout,EOF, }
  (13) E --> E .< E   { let,^,(,%,Val,+,<,OROR,COLON,!,lambda,EOF,<=,cout,&&,-,cin,while,*,else,;,Var,),==,if,/, }
  (11) E --> E .^ E   { ),else,<=,lambda,cout,let,cin,/,%,COLON,(,-,;,+,while,Val,&&,!,==,if,^,<,OROR,*,EOF,Var, }
  (12) E --> E .== E   { +,let,/,while,lambda,OROR,cin,%,if,<,EOF,COLON,Var,cout,^,*,-,(,else,!,==,),<=,;,Val,&&, }
  (16) E --> E .&& E   { cout,else,-,OROR,*,^,lambda,<=,),while,let,==,<,!,&&,cin,if,/,+,;,(,COLON,Val,%,Var,EOF, }
  (17) E --> E .OROR E   { let,&&,==,if,Var,!,<,;,+,%,lambda,COLON,-,*,OROR,^,cout,while,cin,/,),EOF,<=,else,Val,(, }
state 43:
  (24) E --> E .; ES   { <=,+,OROR,==,&&,;,-,%,/,<,*,^, }
  (11) E --> E .^ E   { *,&&,==,%,;,/,<=,-,OROR,+,<,^, }
  (16) E --> E .&& E   { <=,-,%,OROR,^,*,/,&&,==,;,+,<, }
  (26) ES --> E .; ES   { lambda,&&,-,EOF,<,!,<=,(,==,else,;,OROR,cin,/,^,+,COLON,%,*,),if,while,let,Var,cout,Val, }
  (13) E --> E .< E   { <,^,-,;,%,&&,+,*,<=,OROR,==,/, }
  (9) E --> E ./ E   { &&,<=,;,<,+,%,OROR,==,/,^,*,-, }
  (7) E --> E .- E   { +,*,%,/,&&,;,<,OROR,<=,==,^,-, }
  (14) E --> E .<= E   { <,-,%,OROR,*,+,<=,&&,^,==,;,/, }
  (17) E --> E .OROR E   { <,*,OROR,^,<=,+,&&,-,;,/,==,%, }
  (12) E --> E .== E   { %,==,+,<=,<,/,&&,*,OROR,;,-,^, }
  (6) E --> E .+ E   { ^,<,&&,<=,%,+,*,==,/,;,-,OROR, }
  (8) E --> E .* E   { <=,^,<,OROR,+,*,;,%,&&,-,/,==, }
  (10) E --> E .% E   { <,-,^,&&,<=,OROR,==,;,*,/,+,%, }
state 44:
  (24) E --> E ; ES .   { if,*,!,let,lambda,==,Val,&&,cout,<=,^,<,-,else,cin,OROR,/,COLON,),EOF,%,Var,while,(,;,+, }
state 45:
  (10) E --> E .% E   { ==,*,^,+,COLON,else,cin,while,Var,<=,lambda,%,cout,Val,<,/,EOF,&&,(,),!,;,-,OROR,if,let, }
  (17) E --> E OROR E .   { ^,while,let,lambda,),OROR,cout,-,Val,%,+,==,<,!,COLON,EOF,/,Var,&&,if,(,else,*,cin,;,<=, }
  (12) E --> E .== E   { /,%,if,let,EOF,+,^,lambda,-,!,==,COLON,<=,),while,;,OROR,cin,else,*,Var,<,(,cout,Val,&&, }
  (14) E --> E .<= E   { Var,(,),while,+,if,Val,*,cin,OROR,cout,let,else,COLON,%,-,==,<,<=,!,lambda,;,&&,/,EOF,^, }
  (11) E --> E .^ E   { COLON,*,let,/,(,cout,EOF,;,if,^,OROR,else,!,<,+,&&,Val,Var,),while,-,<=,==,cin,%,lambda, }
  (17) E --> E .OROR E   { -,lambda,Var,cout,(,let,&&,cin,OROR,+,^,while,%,<,if,/,EOF,;,==,COLON,!,*,<=,else,),Val, }
  (9) E --> E ./ E   { while,<,&&,^,*,cout,COLON,Var,cin,==,OROR,EOF,/,!,(,+,if,Val,lambda,<=,%,let,else,-,;,), }
  (16) E --> E .&& E   { !,%,/,<,*,EOF,^,else,COLON,lambda,Val,if,-,+,<=,(,;,OROR,==,&&,cout,Var,let,cin,),while, }
  (7) E --> E .- E   { ^,),lambda,(,else,==,+,&&,;,OROR,cin,/,EOF,<=,if,while,<,%,COLON,!,Val,*,Var,cout,-,let, }
  (8) E --> E .* E   { ),cin,let,OROR,-,<,^,&&,cout,EOF,Val,+,else,lambda,==,(,;,COLON,*,<=,%,if,while,!,/,Var, }
  (24) E --> E .; ES   { -,<,&&,Var,/,+,OROR,==,if,EOF,cin,while,COLON,Val,lambda,!,cout,else,%,^,*,(,let,;,<=,), }
  (6) E --> E .+ E   { <=,-,if,==,else,OROR,while,^,cout,lambda,COLON,&&,<,cin,(,%,+,Val,!,EOF,let,/,;,),Var,*, }
  (13) E --> E .< E   { ;,cout,+,==,cin,let,while,(,&&,OROR,lambda,Var,),Val,else,EOF,if,^,%,/,*,!,-,COLON,<,<=, }
state 46:
  (8) E --> E .* E   { -,%,else,OROR,if,<,Var,(,lambda,let,COLON,+,^,*,Val,cin,),<=,==,while,&&,EOF,cout,;,!,/, }
  (6) E --> E .+ E   { *,+,==,OROR,),if,-,^,cout,%,<,!,lambda,Var,/,else,Val,cin,COLON,EOF,let,&&,(,<=,while,;, }
  (7) E --> E .- E   { -,^,!,+,while,EOF,Val,lambda,),Var,cout,;,==,cin,if,%,COLON,<=,/,let,else,OROR,*,<,&&,(, }
  (10) E --> E .% E   { Var,if,;,let,cout,<=,^,EOF,(,OROR,/,<,lambda,!,cin,else,&&,==,Val,*,+,),-,COLON,while,%, }
  (11) E --> E ^ E .   { Var,Val,cout,*,),==,if,;,/,OROR,let,else,(,while,%,!,EOF,lambda,-,&&,cin,<=,^,+,<,COLON, }
  (12) E --> E .== E   { cin,-,OROR,/,!,^,%,(,;,+,if,<,==,<=,cout,),Val,let,while,lambda,else,&&,EOF,Var,*,COLON, }
  (16) E --> E .&& E   { if,(,Val,!,cin,COLON,cout,%,else,<=,^,EOF,&&,*,/,-,),;,while,==,Var,lambda,let,<,OROR,+, }
  (17) E --> E .OROR E   { -,^,lambda,Var,if,),OROR,&&,COLON,==,%,cout,while,else,+,!,;,<,cin,/,let,*,EOF,Val,(,<=, }
  (14) E --> E .<= E   { cout,COLON,cin,^,while,(,==,!,else,<,+,EOF,%,lambda,Var,;,*,&&,/,OROR,),<=,-,if,Val,let, }
  (9) E --> E ./ E   { ),lambda,while,&&,COLON,==,!,OROR,*,Var,Val,-,<,cin,+,cout,let,<=,^,else,%,EOF,if,;,/,(, }
  (24) E --> E .; ES   { Var,;,while,),%,EOF,COLON,/,OROR,<,else,Val,let,&&,*,cout,==,-,<=,(,if,cin,^,+,lambda,!, }
  (11) E --> E .^ E   { ^,if,COLON,let,Val,==,-,%,&&,else,*,!,(,cout,EOF,Var,lambda,/,;,OROR,cin,<=,),+,while,<, }
  (13) E --> E .< E   { (,cout,Val,),while,/,&&,Var,^,else,-,OROR,cin,if,let,lambda,EOF,<=,COLON,*,<,+,;,==,!,%, }
state 47:
  (9) E --> E / E .   { if,cin,+,else,lambda,*,!,cout,),/,^,<=,OROR,COLON,-,EOF,%,==,while,Var,<,let,;,(,Val,&&, }
  (9) E --> E ./ E   { EOF,*,OROR,&&,if,<,-,),==,cout,Val,Var,lambda,+,;,/,cin,!,<=,%,else,while,COLON,^,(,let, }
  (17) E --> E .OROR E   { EOF,==,(,let,<,!,Val,^,if,else,COLON,cout,),;,Var,OROR,+,while,&&,*,<=,/,%,lambda,-,cin, }
  (6) E --> E .+ E   { *,COLON,Val,^,Var,EOF,%,),<=,!,while,+,-,OROR,else,cout,<,(,&&,/,cin,lambda,;,if,let,==, }
  (13) E --> E .< E   { OROR,if,<=,==,Var,EOF,(,+,cout,/,Val,-,^,else,while,cin,COLON,*,%,let,),<,!,;,lambda,&&, }
  (16) E --> E .&& E   { COLON,cout,EOF,-,Var,let,lambda,*,Val,else,),while,&&,^,<=,(,+,cin,if,<,==,OROR,/,;,%,!, }
  (11) E --> E .^ E   { EOF,==,^,<=,Val,),;,cout,OROR,if,lambda,<,while,%,let,*,!,&&,COLON,Var,cin,/,(,+,else,-, }
  (12) E --> E .== E   { !,*,else,(,==,if,while,cout,EOF,;,/,&&,-,+,^,<=,COLON,<,),cin,let,%,Val,Var,OROR,lambda, }
  (24) E --> E .; ES   { while,&&,cin,else,*,Val,OROR,let,%,),==,^,COLON,(,if,-,/,!,lambda,<=,+,Var,EOF,;,<,cout, }
  (10) E --> E .% E   { COLON,-,==,!,+,%,/,else,^,<,Val,EOF,OROR,lambda,<=,Var,*,if,while,;,(,&&,let,cout,),cin, }
  (7) E --> E .- E   { Var,while,%,(,*,lambda,OROR,&&,Val,^,<,if,cout,/,COLON,!,EOF,<=,else,let,),;,-,==,cin,+, }
  (14) E --> E .<= E   { cin,Var,+,;,while,%,COLON,*,<,EOF,cout,/,&&,(,-,else,let,!,Val,<=,lambda,),OROR,==,^,if, }
  (8) E --> E .* E   { let,if,while,*,&&,==,Var,else,<,),COLON,^,-,;,!,(,<=,lambda,%,+,Val,EOF,cin,OROR,cout,/, }
state 48:
  (8) E --> E .* E   { OROR,/,%,lambda,cin,*,let,==,if,(,Var,COLON,!,;,),EOF,&&,Val,cout,while,else,<=,+,^,<,-, }
  (12) E --> E .== E   { +,(,cin,COLON,;,if,&&,else,<=,let,lambda,EOF,!,==,OROR,^,while,-,Var,),Val,%,*,cout,<,/, }
  (7) E --> E .- E   { -,COLON,Var,else,^,cout,<,while,OROR,EOF,!,==,;,+,lambda,<=,Val,if,),&&,/,(,cin,%,*,let, }
  (14) E --> E .<= E   { ==,COLON,Val,-,let,OROR,%,cin,&&,;,/,else,!,if,while,^,cout,<,lambda,*,<=,EOF,+,(,),Var, }
  (16) E --> E .&& E   { /,+,if,EOF,<=,==,(,^,cout,while,let,<,cin,&&,Var,COLON,;,*,),lambda,!,-,OROR,%,Val,else, }
  (9) E --> E ./ E   { &&,),*,Var,if,lambda,%,COLON,cin,^,(,while,<,+,!,else,/,Val,;,EOF,<=,let,OROR,cout,-,==, }
  (24) E --> E .; ES   { <=,EOF,!,if,OROR,cout,),/,lambda,-,%,Var,<,&&,cin,*,+,let,Val,COLON,==,while,^,(,;,else, }
  (6) E --> E .+ E   { <=,),if,%,Var,;,else,==,*,<,-,^,cout,&&,lambda,COLON,(,Val,EOF,+,!,OROR,while,cin,/,let, }
  (6) E --> E + E .   { !,let,<=,if,+,(,;,%,while,^,lambda,Var,cout,else,==,COLON,Val,-,EOF,&&,<,OROR,*,cin,),/, }
  (17) E --> E .OROR E   { ),/,^,cout,<=,-,cin,<,let,OROR,EOF,&&,while,+,lambda,*,%,!,==,COLON,(,if,;,Var,else,Val, }
  (13) E --> E .< E   { Val,(,<=,/,*,lambda,!,<,while,),^,&&,cin,==,;,%,else,EOF,let,Var,if,cout,OROR,+,COLON,-, }
  (11) E --> E .^ E   { -,lambda,(,let,EOF,==,+,COLON,%,*,!,Val,else,;,<=,&&,Var,while,^,/,<,cin,cout,),if,OROR, }
  (10) E --> E .% E   { +,-,/,^,(,),<=,OROR,while,cin,let,==,Var,*,%,else,;,Val,cout,COLON,lambda,&&,!,<,EOF,if, }
state 49:
  (5) E --> .cout E   { -,else,==,/,let,;,Val,EOF,cout,^,Var,<,while,),+,COLON,<=,if,&&,(,%,OROR,!,*,cin,lambda, }
  (15) E --> .while ( E ) E   { COLON,cout,/,<=,lambda,Var,Val,if,),else,-,OROR,&&,!,while,==,+,EOF,let,%,^,;,cin,(,<,*, }
  (13) E --> .E < E   { -,while,let,*,+,lambda,if,<=,(,;,<,%,EOF,Var,&&,),cout,else,Val,/,cin,OROR,COLON,!,==,^, }
  (8) E --> .E * E   { (,!,else,Var,),OROR,while,<=,cin,cout,%,+,-,==,if,COLON,lambda,<,&&,/,*,let,EOF,^,;,Val, }
  (11) E --> .E ^ E   { ;,^,lambda,else,cin,*,if,%,COLON,let,/,Var,<=,EOF,cout,-,Val,+,),OROR,==,<,!,(,while,&&, }
  (20) E --> .let Var = E COLON E   { lambda,while,-,+,Val,else,COLON,Var,OROR,%,),cin,EOF,==,(,<,;,^,*,cout,&&,/,<=,!,let,if, }
  (1) E --> .( E )   { let,;,+,cin,(,lambda,),OROR,%,&&,^,*,else,if,==,<,EOF,while,cout,Val,<=,-,/,Var,COLON,!, }
  (6) E --> .E + E   { /,+,==,while,;,if,cout,!,%,EOF,),cin,^,-,let,&&,COLON,Var,OROR,(,<,else,lambda,*,Val,<=, }
  (19) E --> .! E   { else,&&,EOF,==,while,COLON,if,+,*,!,Var,cout,Val,lambda,OROR,<,cin,let,/,-,<=,^,%,),(,;, }
  (22) E --> lambda Var . .E   { ^,while,&&,-,!,lambda,+,Var,let,cout,<=,*,EOF,),(,/,cin,if,Val,OROR,<,==,COLON,;,%,else, }
  (2) E --> .( Var E )   { ==,COLON,^,),OROR,+,-,!,<=,%,cin,<,while,Var,Val,let,(,&&,if,lambda,cout,*,;,EOF,/,else, }
  (12) E --> .E == E   { ^,<=,(,!,Val,EOF,/,%,let,&&,cout,if,while,OROR,+,*,cin,;,else,COLON,-,<,==,lambda,Var,), }
  (17) E --> .E OROR E   { ==,EOF,lambda,;,cin,&&,+,cout,else,/,Val,<,Var,<=,COLON,let,),-,if,^,OROR,!,%,(,while,*, }
  (10) E --> .E % E   { ;,OROR,else,-,+,==,Var,cin,COLON,while,let,^,&&,<,if,(,EOF,cout,),/,Val,<=,%,lambda,*,!, }
  (3) E --> .cin   { cout,+,EOF,),Val,<,lambda,&&,^,if,;,let,while,/,(,*,cin,==,else,-,COLON,Var,!,OROR,<=,%, }
  (27) E --> .Var   { lambda,COLON,OROR,+,!,(,Var,else,^,&&,cout,-,Val,while,==,if,<=,;,*,),EOF,/,let,cin,<,%, }
  (9) E --> .E / E   { !,else,let,==,EOF,cout,while,<,*,+,if,;,/,<=,cin,Var,(,COLON,OROR,Val,&&,%,lambda,),-,^, }
  (24) E --> .E ; ES   { cout,==,(,/,&&,EOF,Var,;,Val,else,let,+,*,^,OROR,cin,COLON,while,),lambda,<,if,-,%,!,<=, }
  (18) E --> .- E   { EOF,;,<,OROR,*,),<=,if,^,COLON,-,lambda,while,else,/,cout,+,%,Var,&&,!,Val,cin,let,(,==, }
  (14) E --> .E <= E   { ==,*,<,Val,let,COLON,<=,OROR,EOF,if,Var,!,;,&&,while,),cin,%,(,^,/,cout,lambda,+,-,else, }
  (23) E --> .if E E else E   { <,/,let,while,%,Val,-,(,*,<=,cout,^,OROR,),if,&&,lambda,cin,+,==,;,COLON,EOF,Var,!,else, }
  (21) E --> .Var = E   { EOF,cin,Val,Var,;,(,lambda,COLON,*,<=,==,OROR,<,else,if,!,&&,^,/,),while,-,cout,+,let,%, }
  (0) E --> .Val   { <,-,lambda,<=,+,;,/,&&,OROR,cin,*,Var,let,EOF,),Val,if,^,cout,while,%,COLON,(,==,!,else, }
  (7) E --> .E - E   { else,<=,lambda,^,let,!,EOF,%,(,OROR,COLON,<,if,*,&&,;,-,while,Var,==,),cout,/,cin,Val,+, }
  (16) E --> .E && E   { while,/,),cout,%,==,<,Val,lambda,;,&&,cin,COLON,if,-,<=,let,EOF,!,^,else,OROR,(,*,+,Var, }
  (22) E --> .lambda Var . E   { let,^,else,*,+,COLON,/,EOF,&&,while,Var,cout,-,!,cin,(,lambda,OROR,==,%,),Val,<=,<,;,if, }
  (4) E --> .cout Str   { Val,OROR,lambda,),^,;,*,if,<=,+,Var,<,EOF,!,let,%,(,==,else,cin,-,COLON,&&,/,while,cout, }
state 50:
  (13) E --> E .< E   { <=,&&,+,<,else,-,/,%,*,^,;,==,OROR, }
  (16) E --> E .&& E   { +,*,^,/,;,<=,%,OROR,<,==,&&,else,-, }
  (9) E --> E ./ E   { <,+,-,*,<=,==,else,%,OROR,&&,^,/,;, }
  (6) E --> E .+ E   { *,;,<=,-,==,&&,+,%,^,<,else,OROR,/, }
  (23) E --> if E E .else E   { +,%,OROR,if,COLON,<,Val,;,while,Var,*,==,-,^,<=,/,),(,cout,cin,!,let,&&,lambda,EOF,else, }
  (8) E --> E .* E   { else,&&,==,+,^,;,/,<,*,OROR,<=,%,-, }
  (11) E --> E .^ E   { /,%,^,OROR,==,-,*,<,else,;,+,&&,<=, }
  (10) E --> E .% E   { *,;,/,OROR,else,+,&&,%,^,<,<=,-,==, }
  (17) E --> E .OROR E   { -,%,;,else,==,&&,<=,*,<,/,^,OROR,+, }
  (24) E --> E .; ES   { ==,/,;,^,<=,<,%,OROR,-,+,*,&&,else, }
  (14) E --> E .<= E   { /,*,<,==,-,;,else,^,&&,OROR,+,%,<=, }
  (7) E --> E .- E   { /,+,*,else,OROR,==,-,<=,<,^,;,%,&&, }
  (12) E --> E .== E   { ==,else,<,;,^,*,%,-,+,<=,/,&&,OROR, }
state 51:
  (8) E --> .E * E   { <=,==,if,^,%,;,&&,!,Val,let,lambda,(,<,+,while,*,OROR,cout,Var,else,cin,-,/, }
  (4) E --> .cout Str   { Val,==,<=,;,lambda,Var,&&,let,<,(,else,-,!,*,^,cout,OROR,%,cin,+,if,/,while, }
  (16) E --> .E && E   { (,!,%,else,/,lambda,while,if,+,let,<,==,cin,-,&&,cout,<=,Val,^,*,OROR,;,Var, }
  (19) E --> .! E   { if,while,-,*,<=,==,cout,^,lambda,Var,!,OROR,else,%,&&,;,/,Val,+,<,let,(,cin, }
  (12) E --> .E == E   { &&,(,%,if,<=,*,Val,<,cout,/,Var,;,cin,lambda,^,let,else,!,==,OROR,-,while,+, }
  (13) E --> .E < E   { Val,let,%,*,cout,<=,;,!,if,-,<,&&,cin,OROR,else,while,lambda,^,+,/,Var,==,(, }
  (27) E --> .Var   { else,(,^,Var,*,&&,<=,let,;,<,OROR,%,==,-,while,+,!,cin,Val,cout,if,lambda,/, }
  (1) E --> .( E )   { ^,while,%,==,(,else,+,!,&&,lambda,if,Val,*,Var,/,<=,<,;,OROR,cin,cout,-,let, }
  (24) E --> .E ; ES   { ;,OROR,let,^,cout,-,<,+,/,if,lambda,while,!,<=,cin,Var,*,else,%,&&,Val,(,==, }
  (7) E --> E - .E   { <=,+,&&,lambda,/,OROR,if,==,let,Var,!,while,cin,;,*,^,(,-,<,Val,cout,%, }
  (11) E --> .E ^ E   { Var,/,^,&&,let,*,-,!,while,cout,<,;,+,(,cin,OROR,lambda,if,<=,else,Val,%,==, }
  (22) E --> .lambda Var . E   { else,==,cin,*,<,cout,-,if,+,%,;,&&,Var,while,!,Val,OROR,<=,^,lambda,let,/,(, }
  (9) E --> .E / E   { cout,-,!,%,*,while,/,^,+,if,cin,;,lambda,(,else,OROR,==,<=,&&,<,let,Val,Var, }
  (21) E --> .Var = E   { %,while,==,cin,else,!,^,+,OROR,Var,if,<,lambda,let,-,&&,*,cout,;,(,/,Val,<=, }
  (10) E --> .E % E   { Var,cin,else,while,^,*,lambda,<=,/,-,OROR,;,+,if,let,%,Val,!,==,(,cout,&&,<, }
  (23) E --> .if E E else E   { while,+,cout,-,Val,%,lambda,/,if,^,<,;,!,OROR,Var,<=,let,(,cin,&&,else,*,==, }
  (18) E --> .- E   { %,<=,+,-,^,cin,Var,while,(,lambda,OROR,==,Val,if,<,*,/,else,;,cout,&&,let,!, }
  (18) E --> - .E   { *,==,<,-,&&,OROR,%,/,<=,;,+,else,^, }
  (5) E --> .cout E   { &&,/,==,if,lambda,<=,!,while,else,OROR,let,+,^,Val,-,*,;,<,(,%,cout,cin,Var, }
  (2) E --> .( Var E )   { lambda,cin,!,+,(,%,else,cout,/,Var,<=,-,*,^,let,<,&&,==,if,while,;,Val,OROR, }
  (6) E --> .E + E   { !,<=,Val,cout,-,<,if,+,Var,else,%,while,==,*,OROR,/,^,(,let,&&,;,lambda,cin, }
  (20) E --> .let Var = E COLON E   { /,Val,*,Var,<=,!,<,if,-,==,lambda,^,;,cin,let,&&,OROR,else,%,cout,(,+,while, }
  (15) E --> .while ( E ) E   { !,(,==,cin,-,else,<=,;,cout,Var,while,OROR,let,if,<,%,^,*,&&,lambda,Val,+,/, }
  (17) E --> .E OROR E   { else,OROR,*,+,<,-,(,&&,cin,<=,while,if,/,Val,Var,!,%,==,;,cout,lambda,let,^, }
  (7) E --> .E - E   { lambda,;,Var,if,<,+,%,==,*,OROR,cout,(,<=,Val,^,!,let,&&,while,-,cin,/,else, }
  (0) E --> .Val   { Val,^,cout,==,+,*,%,OROR,Var,&&,-,<=,let,!,(,else,if,cin,;,while,<,lambda,/, }
  (14) E --> .E <= E   { /,Val,OROR,Var,if,^,==,;,(,!,while,%,cin,&&,<=,-,cout,else,+,<,let,*,lambda, }
  (3) E --> .cin   { <=,!,(,let,-,+,while,Val,*,<,Var,lambda,OROR,/,cout,^,cin,else,if,%,&&,;,==, }
state 52:
  (17) E --> E .OROR E   { /,+,Var,Val,OROR,;,if,COLON,(,!,lambda,-,cin,while,EOF,<=,else,&&,^,let,<,==,),cout,*,%, }
  (24) E --> E .; ES   { (,+,;,/,-,COLON,OROR,<=,cout,*,!,Val,let,else,^,if,EOF,&&,lambda,%,cin,while,==,),Var,<, }
  (13) E --> E .< E   { <=,&&,EOF,cout,else,if,COLON,+,*,OROR,cin,let,<,lambda,(,while,Var,^,Val,-,/,),%,==,;,!, }
  (8) E --> E .* E   { (,<=,&&,%,Var,while,Val,+,;,cout,/,if,!,else,),COLON,OROR,-,cin,<,let,==,lambda,EOF,*,^, }
  (10) E --> E .% E   { !,;,*,if,let,(,COLON,<=,Val,==,lambda,^,),while,%,Var,EOF,-,&&,OROR,cout,<,+,/,cin,else, }
  (6) E --> E .+ E   { Val,%,!,(,cout,let,lambda,*,OROR,if,Var,^,while,),<,&&,COLON,EOF,cin,+,;,<=,-,/,==,else, }
  (7) E --> E .- E   { cin,<,let,),Val,COLON,+,-,lambda,/,else,*,if,!,EOF,while,Var,==,<=,;,%,cout,^,&&,OROR,(, }
  (16) E --> E .&& E   { let,else,&&,!,lambda,*,^,+,<,Val,;,cin,Var,<=,%,),(,COLON,==,EOF,cout,while,/,OROR,if,-, }
  (21) E --> Var = E .   { cout,!,==,*,-,%,&&,Val,COLON,<,+,lambda,cin,Var,),EOF,let,;,else,/,if,(,<=,OROR,while,^, }
  (11) E --> E .^ E   { while,EOF,<=,),cout,/,COLON,let,%,if,Val,!,cin,Var,else,&&,*,lambda,(,^,==,OROR,+,-,<,;, }
  (9) E --> E ./ E   { OROR,let,cout,+,Val,while,EOF,%,&&,<=,lambda,==,(,if,else,-,^,COLON,),cin,Var,/,!,<,*,;, }
  (14) E --> E .<= E   { Val,-,;,!,cin,(,OROR,COLON,while,<=,==,*,EOF,%,+,^,),Var,<,&&,else,let,cout,lambda,if,/, }
  (12) E --> E .== E   { ),OROR,lambda,&&,EOF,+,else,%,!,cin,COLON,if,Val,;,<=,/,==,Var,let,^,*,-,cout,(,while,<, }
state 53:
  (17) E --> E .OROR E   { *,;,/,^,),<=,<,==,-,%,+,&&,OROR, }
  (6) E --> E .+ E   { &&,^,==,+,<,/,OROR,;,),<=,*,%,-, }
  (12) E --> E .== E   { %,<=,+,;,*,OROR,==,&&,/,),<,-,^, }
  (15) E --> while ( E .) E   { /,let,COLON,(,cout,Val,EOF,*,&&,<,-,+,OROR,),%,cin,<=,if,while,^,==,!,Var,lambda,;,else, }
  (24) E --> E .; ES   { -,/,;,),+,&&,*,==,%,OROR,<=,<,^, }
  (13) E --> E .< E   { +,<,&&,/,<=,%,==,*,^,-,OROR,;,), }
  (11) E --> E .^ E   { ==,%,+,^,/,&&,),*,OROR,<=,;,-,<, }
  (7) E --> E .- E   { <,+,%,==,;,OROR,*,),&&,-,/,^,<=, }
  (14) E --> E .<= E   { ;,^,%,==,<=,&&,OROR,+,<,/,*,-,), }
  (10) E --> E .% E   { <=,OROR,&&,*,+,<,/,^,),-,%,;,==, }
  (16) E --> E .&& E   { <,%,/,==,+,),&&,OROR,^,<=,*,-,;, }
  (8) E --> E .* E   { OROR,<=,^,*,%,;,+,&&,/,),==,<,-, }
  (9) E --> E ./ E   { +,<=,;,-,OROR,),*,^,/,<,&&,%,==, }
state 54:
  (17) E --> E .OROR E   { -,^,&&,%,<=,<,==,),*,+,OROR,;,/, }
  (7) E --> E .- E   { -,*,<=,&&,^,<,==,+,OROR,/,;,),%, }
  (14) E --> E .<= E   { +,<=,*,/,^,&&,OROR,==,<,;,%,),-, }
  (24) E --> E .; ES   { OROR,-,<=,*,;,&&,==,<,^,),/,%,+, }
  (2) E --> ( Var E .)   { EOF,OROR,Var,lambda,<=,cin,if,==,;,Val,else,(,let,-,%,^,<,+,),COLON,!,cout,&&,*,while,/, }
  (11) E --> E .^ E   { -,+,OROR,&&,^,<=,),<,;,==,%,/,*, }
  (6) E --> E .+ E   { %,),&&,<=,==,<,*,+,OROR,;,/,^,-, }
  (12) E --> E .== E   { OROR,<,==,;,^,),%,+,/,&&,*,-,<=, }
  (13) E --> E .< E   { &&,-,==,;,/,*,+,%,^,),<,<=,OROR, }
  (9) E --> E ./ E   { -,==,/,),%,+,<,^,*,OROR,&&,<=,;, }
  (16) E --> E .&& E   { /,;,&&,*,),<=,-,OROR,==,+,%,<,^, }
  (8) E --> E .* E   { ),+,OROR,<,-,<=,^,&&,*,;,==,%,/, }
  (10) E --> E .% E   { ),&&,%,<=,;,+,*,-,==,OROR,<,/,^, }
state 55:
  (1) E --> ( E ) .   { <=,let,if,<,),+,!,;,else,*,cout,Val,^,Var,==,cin,COLON,/,while,EOF,lambda,-,(,OROR,%,&&, }
state 56:
  (17) E --> .E OROR E   { COLON,<,%,<=,+,*,&&,/,^,==,OROR,;,-, }
  (15) E --> .while ( E ) E   { &&,<=,OROR,==,-,/,^,+,<,;,%,COLON,*, }
  (19) E --> .! E   { %,/,COLON,OROR,-,&&,<=,==,;,^,*,+,<, }
  (20) E --> .let Var = E COLON E   { <=,<,OROR,;,==,&&,+,-,*,COLON,/,%,^, }
  (14) E --> .E <= E   { *,<,&&,<=,;,^,-,/,+,OROR,==,COLON,%, }
  (3) E --> .cin   { OROR,/,==,<,*,-,^,+,<=,;,%,&&,COLON, }
  (10) E --> .E % E   { COLON,*,;,+,/,&&,<,^,<=,%,==,-,OROR, }
  (5) E --> .cout E   { <,<=,==,+,;,OROR,^,*,&&,%,/,COLON,-, }
  (4) E --> .cout Str   { %,==,OROR,<=,-,^,/,<,;,+,&&,*,COLON, }
  (7) E --> .E - E   { <=,==,*,<,^,&&,COLON,-,+,OROR,/,;,%, }
  (8) E --> .E * E   { OROR,-,<,*,/,+,%,&&,;,^,COLON,<=,==, }
  (11) E --> .E ^ E   { -,/,==,COLON,<,^,;,+,%,*,<=,&&,OROR, }
  (9) E --> .E / E   { ==,<,&&,-,<=,*,OROR,^,;,COLON,/,+,%, }
  (21) E --> .Var = E   { OROR,;,<=,<,/,&&,-,==,%,*,COLON,^,+, }
  (18) E --> .- E   { -,<,COLON,OROR,<=,&&,*,==,^,%,;,/,+, }
  (1) E --> .( E )   { <=,^,OROR,<,+,COLON,==,%,*,;,-,/,&&, }
  (12) E --> .E == E   { <=,%,OROR,/,-,*,==,&&,^,<,;,+,COLON, }
  (27) E --> .Var   { %,&&,^,+,<=,==,/,OROR,<,-,COLON,*,;, }
  (6) E --> .E + E   { ^,COLON,;,/,+,%,<=,OROR,*,<,&&,-,==, }
  (16) E --> .E && E   { ;,&&,^,/,COLON,-,*,<=,OROR,<,==,%,+, }
  (22) E --> .lambda Var . E   { &&,<,+,COLON,==,-,OROR,^,<=,%,/,;,*, }
  (0) E --> .Val   { ^,%,&&,OROR,-,;,COLON,*,/,<=,<,+,==, }
  (23) E --> .if E E else E   { -,/,%,==,<,;,OROR,*,&&,^,<=,COLON,+, }
  (13) E --> .E < E   { OROR,==,COLON,<,*,/,%,<=,-,+,;,^,&&, }
  (2) E --> .( Var E )   { ^,-,+,<=,&&,OROR,<,;,COLON,==,%,*,/, }
  (24) E --> .E ; ES   { COLON,<=,;,-,==,/,&&,+,*,^,OROR,<,%, }
  (20) E --> let Var = .E COLON E   { while,<,if,^,EOF,/,OROR,lambda,!,),COLON,else,cin,cout,==,Var,(,&&,<=,+,-,*,;,%,Val,let, }
state 57:
  (21) E --> .Var = E   { ;,+,OROR,^,%,==,<,&&,<=,/,*,-, }
  (5) E --> .cout E   { &&,-,^,OROR,<=,%,==,;,*,/,<,+, }
  (25) ES --> .   { Val,;,<=,==,let,while,cout,!,else,COLON,*,(,&&,EOF,<,^,Var,%,),lambda,/,cin,-,+,OROR,if, }
  (8) E --> .E * E   { ;,%,^,OROR,-,&&,<=,/,<,*,==,+, }
  (7) E --> .E - E   { -,<,%,<=,*,+,&&,^,;,==,OROR,/, }
  (9) E --> .E / E   { OROR,*,<=,^,==,<,+,;,-,/,&&,%, }
  (12) E --> .E == E   { +,^,-,&&,*,==,;,<,/,OROR,<=,%, }
  (18) E --> .- E   { +,&&,<,;,*,^,-,%,/,<=,OROR,==, }
  (2) E --> .( Var E )   { OROR,^,+,/,<=,*,<,-,&&,;,==,%, }
  (20) E --> .let Var = E COLON E   { ;,==,&&,-,*,OROR,%,^,<=,+,<,/, }
  (6) E --> .E + E   { ^,/,<=,+,-,;,%,*,==,OROR,&&,<, }
  (26) ES --> E ; .ES   { <,<=,;,(,!,while,EOF,*,cout,Val,else,^,cin,COLON,/,Var,let,-,OROR,%,lambda,if,==,&&,+,), }
  (16) E --> .E && E   { %,<,==,^,<=,-,&&,OROR,+,/,;,*, }
  (27) E --> .Var   { +,%,OROR,==,^,;,&&,/,-,<,*,<=, }
  (4) E --> .cout Str   { <=,+,;,OROR,^,==,-,*,%,&&,/,<, }
  (17) E --> .E OROR E   { &&,<=,%,+,==,;,-,OROR,<,*,/,^, }
  (26) ES --> .E ; ES   { +,COLON,if,<=,/,lambda,(,==,&&,),cin,OROR,^,%,else,*,let,cout,;,!,EOF,while,-,Var,Val,<, }
  (15) E --> .while ( E ) E   { ^,/,%,;,-,<=,+,<,OROR,==,*,&&, }
  (19) E --> .! E   { %,==,OROR,*,&&,+,<,<=,-,^,/,;, }
  (1) E --> .( E )   { ^,<,%,+,;,-,==,*,<=,&&,/,OROR, }
  (11) E --> .E ^ E   { /,<,&&,==,%,OROR,-,^,*,<=,+,;, }
  (14) E --> .E <= E   { OROR,;,%,+,*,/,==,&&,-,<,^,<=, }
  (22) E --> .lambda Var . E   { +,*,%,<,&&,;,<=,OROR,-,^,==,/, }
  (13) E --> .E < E   { ;,OROR,+,<=,%,*,==,<,&&,/,^,-, }
  (23) E --> .if E E else E   { <=,+,<,==,%,-,;,OROR,^,/,&&,*, }
  (24) E --> E ; .ES   { <,/,;,-,*,==,OROR,^,&&,+,<=,%, }
  (3) E --> .cin   { *,&&,^,;,-,<=,/,%,OROR,+,<,==, }
  (10) E --> .E % E   { %,<,;,==,+,/,<=,OROR,^,-,*,&&, }
  (24) E --> .E ; ES   { ==,*,/,;,^,-,<,+,<=,&&,OROR,%, }
  (0) E --> .Val   { &&,<,*,%,;,<=,==,^,-,OROR,/,+, }
state 58:
  (10) E --> E .% E   { while,let,/,+,(,COLON,&&,!,^,if,;,==,Val,OROR,cout,Var,),cin,-,else,*,<=,lambda,<,EOF,%, }
  (22) E --> lambda Var . E .   { ^,Var,let,==,else,%,COLON,!,;,<=,-,cout,cin,Val,*,lambda,OROR,(,EOF,+,),<,while,/,if,&&, }
  (11) E --> E .^ E   { <=,else,cin,Var,+,&&,EOF,(,lambda,let,COLON,cout,-,==,OROR,/,<,if,Val,;,),%,!,while,^,*, }
  (14) E --> E .<= E   { ),let,-,+,^,while,%,lambda,<,cin,COLON,if,cout,&&,OROR,EOF,Val,else,;,Var,*,==,<=,!,/,(, }
  (9) E --> E ./ E   { *,lambda,;,&&,cin,<=,Val,==,),EOF,COLON,OROR,Var,^,%,else,let,while,if,-,cout,+,!,(,/,<, }
  (17) E --> E .OROR E   { *,cin,%,<,!,Var,cout,+,;,let,),&&,/,^,Val,(,-,if,else,OROR,EOF,==,while,COLON,<=,lambda, }
  (7) E --> E .- E   { ;,),cin,*,^,else,&&,!,(,let,cout,<=,+,/,Val,EOF,lambda,Var,while,<,if,==,-,OROR,%,COLON, }
  (16) E --> E .&& E   { Val,<,),(,COLON,==,Var,cout,&&,/,cin,lambda,*,^,<=,let,!,-,else,EOF,while,+,if,;,%,OROR, }
  (8) E --> E .* E   { *,^,!,(,),Var,%,let,;,while,<,lambda,cout,COLON,else,/,if,==,Val,-,&&,<=,OROR,+,EOF,cin, }
  (12) E --> E .== E   { COLON,<=,*,;,let,-,<,lambda,),EOF,else,%,cout,+,!,/,(,while,Val,==,^,if,OROR,&&,cin,Var, }
  (13) E --> E .< E   { /,!,==,^,+,COLON,%,if,<=,EOF,cin,<,Val,&&,Var,OROR,lambda,-,let,cout,),(,while,;,else,*, }
  (6) E --> E .+ E   { <=,while,OROR,!,;,),==,/,cout,COLON,-,(,EOF,Val,lambda,%,Var,^,else,if,*,<,let,&&,cin,+, }
  (24) E --> E .; ES   { ),cin,Val,-,%,while,OROR,!,EOF,<=,COLON,&&,let,cout,else,Var,<,^,*,+,;,(,if,/,lambda,==, }
state 59:
  (12) E --> .E == E   { ^,EOF,OROR,==,<,(,!,<=,;,COLON,-,%,),if,cin,let,Var,else,cout,while,Val,&&,/,+,*,lambda, }
  (6) E --> .E + E   { *,+,EOF,^,!,lambda,cout,else,Val,-,),&&,cin,let,<=,==,/,OROR,;,if,while,(,%,COLON,<,Var, }
  (8) E --> .E * E   { -,!,;,else,EOF,lambda,*,+,Val,cout,^,if,%,Var,<=,<,),/,COLON,while,==,OROR,cin,(,let,&&, }
  (0) E --> .Val   { else,OROR,EOF,/,),<=,+,let,lambda,;,-,if,%,cin,^,<,Val,Var,while,!,==,&&,cout,COLON,(,*, }
  (20) E --> .let Var = E COLON E   { Val,while,if,Var,let,lambda,+,OROR,else,*,EOF,<=,/,COLON,),^,==,cout,;,!,(,cin,<,%,&&,-, }
  (5) E --> .cout E   { EOF,Val,COLON,==,%,lambda,<,&&,^,let,if,cin,OROR,(,*,!,;,),while,cout,+,else,-,/,<=,Var, }
  (27) E --> .Var   { -,EOF,let,*,(,;,OROR,else,&&,+,%,!,lambda,<=,/,if,cin,cout,Val,COLON,^,while,==,<,Var,), }
  (15) E --> .while ( E ) E   { %,OROR,Var,let,EOF,==,else,<,cout,COLON,(,if,),^,/,<=,&&,cin,+,Val,lambda,;,!,while,*,-, }
  (9) E --> .E / E   { <,cin,while,!,==,else,if,OROR,;,),Var,-,let,cout,%,*,Val,/,EOF,^,(,&&,COLON,<=,+,lambda, }
  (16) E --> .E && E   { !,(,cin,else,-,+,),while,let,Var,/,<=,;,*,cout,%,OROR,if,lambda,EOF,Val,&&,COLON,==,<,^, }
  (2) E --> .( Var E )   { cout,;,%,let,*,Var,cin,if,OROR,&&,(,-,lambda,else,+,Val,!,==,),while,EOF,<,COLON,<=,/,^, }
  (22) E --> .lambda Var . E   { lambda,^,EOF,==,/,*,<=,if,cout,Val,%,else,Var,let,(,),<,while,!,COLON,OROR,&&,cin,-,+,;, }
  (14) E --> .E <= E   { ==,Val,else,^,lambda,&&,/,(,!,if,),<,OROR,while,COLON,;,*,cin,-,+,Var,let,cout,EOF,<=,%, }
  (11) E --> .E ^ E   { let,-,cout,+,EOF,while,OROR,==,Val,(,%,;,Var,!,<=,^,lambda,if,cin,/,&&,),<,*,else,COLON, }
  (18) E --> .- E   { if,^,&&,cout,(,Var,%,<,COLON,lambda,),<=,EOF,/,==,cin,-,*,while,!,let,else,OROR,+,Val,;, }
  (23) E --> if E E else .E   { Var,/,cin,EOF,+,OROR,Val,while,if,-,==,!,*,cout,COLON,lambda,;,(,<=,^,let,),&&,%,<,else, }
  (17) E --> .E OROR E   { cin,+,!,/,Var,*,%,cout,;,^,&&,-,(,COLON,==,OROR,lambda,EOF,<=,else,while,Val,let,if,<,), }
  (10) E --> .E % E   { ;,COLON,!,lambda,&&,*,/,else,<,while,^,let,Val,if,%,==,Var,cout,-,(,<=,),OROR,cin,+,EOF, }
  (24) E --> .E ; ES   { -,&&,while,COLON,+,(,<,EOF,Var,^,if,cout,else,cin,lambda,OROR,==,),let,/,<=,!,Val,*,;,%, }
  (13) E --> .E < E   { -,*,^,else,==,cin,Var,if,&&,/,),cout,let,+,COLON,!,%,Val,;,OROR,while,(,EOF,<=,<,lambda, }
  (19) E --> .! E   { while,if,Var,(,Val,<,cin,else,let,OROR,COLON,+,;,!,-,^,&&,),%,EOF,/,<=,lambda,==,cout,*, }
  (21) E --> .Var = E   { COLON,-,!,Val,<,;,cin,else,<=,if,==,let,+,cout,(,*,),while,OROR,^,lambda,/,%,Var,EOF,&&, }
  (1) E --> .( E )   { -,cout,COLON,else,!,(,<,),==,<=,/,Var,let,OROR,while,cin,^,;,%,&&,if,*,Val,lambda,+,EOF, }
  (3) E --> .cin   { &&,==,*,<=,^,Var,while,lambda,%,EOF,Val,-,(,if,let,cin,/,OROR,cout,+,else,COLON,),!,<,;, }
  (7) E --> .E - E   { -,else,Var,*,^,EOF,lambda,&&,Val,while,(,cout,==,<,%,OROR,+,/,),COLON,cin,let,;,<=,if,!, }
  (23) E --> .if E E else E   { ;,Var,/,&&,==,while,OROR,COLON,<=,else,-,lambda,(,*,let,+,!,^,if,<,cout,EOF,%,cin,Val,), }
  (4) E --> .cout Str   { +,-,let,if,cout,%,Val,while,(,else,<=,EOF,!,COLON,OROR,),<,&&,/,^,*,;,==,cin,lambda,Var, }
state 60:
  (6) E --> E .+ E   { /,(,&&,%,cout,<,-,lambda,while,else,<=,Val,!,;,if,^,+,Var,let,*,OROR,==,cin, }
  (11) E --> E .^ E   { ==,;,Val,if,^,OROR,%,cin,else,+,<=,<,&&,/,-,Var,!,(,cout,while,lambda,let,*, }
  (17) E --> E .OROR E   { ^,<,lambda,+,&&,==,-,while,let,OROR,cin,!,(,Var,;,else,if,<=,%,Val,cout,/,*, }
  (24) E --> E .; ES   { ^,Var,%,-,*,OROR,<=,while,==,let,/,cin,!,cout,lambda,&&,else,if,(,<,;,+,Val, }
  (18) E --> - E .   { -,OROR,==,^,else,+,;,*,%,/,&&,<=,<, }
  (7) E --> E - E .   { ;,&&,let,if,-,/,+,<,*,Val,cin,==,<=,%,lambda,OROR,^,!,(,cout,while,Var, }
  (13) E --> E .< E   { %,if,cout,-,let,+,/,else,cin,while,!,lambda,==,OROR,&&,<,*,Var,;,<=,^,(,Val, }
  (8) E --> E .* E   { &&,cin,/,(,*,<=,OROR,;,while,!,-,Val,if,let,cout,%,+,==,<,Var,^,lambda,else, }
  (9) E --> E ./ E   { -,<,Val,else,while,*,lambda,let,<=,if,^,+,/,;,==,&&,OROR,!,(,%,Var,cin,cout, }
  (14) E --> E .<= E   { %,let,if,/,Val,&&,lambda,!,<,OROR,*,+,else,-,;,cin,^,cout,Var,while,<=,==,(, }
  (10) E --> E .% E   { ;,<,-,(,else,^,Val,let,lambda,cout,cin,while,+,!,==,*,%,Var,<=,if,/,&&,OROR, }
  (16) E --> E .&& E   { OROR,Var,^,==,else,&&,<,Val,/,if,<=,let,cout,%,!,cin,(,*,while,+,;,-,lambda, }
  (7) E --> E .- E   { if,(,let,-,Var,/,lambda,%,<=,cin,while,else,^,<,;,==,+,&&,Val,!,cout,*,OROR, }
  (12) E --> E .== E   { else,if,==,lambda,;,cin,Val,while,Var,let,&&,!,+,cout,/,<=,OROR,(,%,-,*,<,^, }
state 61:
  (14) E --> .E <= E   { EOF,lambda,==,COLON,),<,<=,;,-,&&,while,^,let,Var,if,cout,!,Val,+,*,(,%,cin,else,OROR,/, }
  (11) E --> .E ^ E   { else,COLON,-,OROR,;,EOF,<,let,cin,/,==,<=,Val,cout,),&&,lambda,if,(,^,+,%,!,Var,*,while, }
  (24) E --> .E ; ES   { cout,(,%,if,==,lambda,let,+,Val,*,while,!,cin,-,/,OROR,;,else,^,),&&,<=,EOF,<,Var,COLON, }
  (4) E --> .cout Str   { lambda,COLON,+,<=,-,==,while,&&,cout,else,EOF,Var,^,let,;,OROR,cin,(,/,!,%,),*,<,Val,if, }
  (17) E --> .E OROR E   { cout,^,-,+,else,/,lambda,OROR,%,if,while,!,let,<=,EOF,;,cin,Var,),COLON,<,&&,*,Val,(,==, }
  (9) E --> .E / E   { <=,-,OROR,cin,cout,<,if,Var,lambda,EOF,+,(,&&,Val,;,while,/,^,==,),let,*,COLON,%,!,else, }
  (10) E --> .E % E   { OROR,cin,let,lambda,else,&&,!,Var,*,COLON,+,),cout,(,^,==,;,/,<,if,-,%,Val,while,EOF,<=, }
  (13) E --> .E < E   { cin,<=,else,-,let,),EOF,COLON,&&,OROR,Val,*,+,!,cout,/,;,lambda,while,Var,%,^,<,if,==,(, }
  (15) E --> while ( E ) .E   { cin,^,OROR,),;,-,Var,/,else,(,!,COLON,Val,let,lambda,%,EOF,<=,if,*,cout,==,&&,+,<,while, }
  (20) E --> .let Var = E COLON E   { Var,&&,==,cout,cin,<=,-,let,*,^,;,lambda,),OROR,EOF,while,<,if,(,/,+,Val,%,else,COLON,!, }
  (3) E --> .cin   { %,let,;,^,(,cout,!,EOF,/,OROR,lambda,&&,COLON,while,else,cin,<=,),Val,==,*,-,if,+,Var,<, }
  (12) E --> .E == E   { cout,),EOF,if,%,<,COLON,else,-,lambda,while,let,Val,+,cin,*,==,Var,/,&&,^,!,;,OROR,<=,(, }
  (0) E --> .Val   { (,while,*,EOF,),/,COLON,<,&&,OROR,%,-,+,;,==,lambda,<=,^,if,cin,else,let,!,Var,cout,Val, }
  (7) E --> .E - E   { *,;,cin,&&,else,Val,while,COLON,-,EOF,<,OROR,==,<=,/,let,%,!,Var,),cout,+,^,(,if,lambda, }
  (2) E --> .( Var E )   { ^,!,Var,<=,while,Val,cin,*,if,),cout,lambda,COLON,%,-,;,let,<,(,else,OROR,==,/,+,&&,EOF, }
  (15) E --> .while ( E ) E   { COLON,lambda,==,<=,),else,cout,+,(,OROR,&&,%,cin,let,Val,if,!,*,-,/,Var,;,while,^,<,EOF, }
  (8) E --> .E * E   { cout,/,;,%,),+,EOF,^,<,COLON,!,let,<=,else,-,Var,cin,==,(,while,&&,Val,OROR,if,lambda,*, }
  (21) E --> .Var = E   { let,<=,-,Var,COLON,/,if,EOF,;,==,lambda,&&,cout,(,!,<,),else,OROR,while,*,%,+,cin,^,Val, }
  (6) E --> .E + E   { lambda,==,let,+,<,cin,if,!,;,*,^,else,OROR,while,COLON,(,/,),%,cout,Val,&&,EOF,Var,<=,-, }
  (18) E --> .- E   { &&,-,let,),;,^,+,OROR,COLON,if,<,Var,cin,!,(,else,%,while,*,cout,Val,EOF,/,==,<=,lambda, }
  (1) E --> .( E )   { lambda,COLON,cin,cout,let,if,),%,&&,+,-,<=,EOF,;,*,Var,while,/,==,OROR,(,!,<,^,else,Val, }
  (22) E --> .lambda Var . E   { <,else,let,+,EOF,),cin,lambda,-,!,<=,Var,while,*,COLON,%,(,cout,if,Val,&&,;,/,==,OROR,^, }
  (16) E --> .E && E   { cout,^,;,Val,OROR,let,&&,==,COLON,Var,while,EOF,),!,if,+,lambda,%,(,*,else,cin,<,-,<=,/, }
  (23) E --> .if E E else E   { cout,%,),OROR,*,let,Var,^,lambda,EOF,+,<=,(,-,;,cin,/,&&,<,!,Val,COLON,while,if,else,==, }
  (5) E --> .cout E   { <,+,%,==,^,OROR,Var,while,if,cin,!,&&,/,Val,*,<=,;,let,-,EOF,(,cout,lambda,),else,COLON, }
  (19) E --> .! E   { Val,EOF,OROR,&&,==,+,*,(,<,%,<=,while,^,let,else,cin,-,lambda,COLON,!,),;,cout,/,Var,if, }
  (27) E --> .Var   { else,!,(,cout,EOF,<,<=,while,+,cin,COLON,-,&&,%,/,let,*,if,==,^,;,Var,),Val,OROR,lambda, }
state 62:
  (2) E --> ( Var E ) .   { while,*,(,let,COLON,%,),Var,Val,EOF,!,/,cout,<,^,&&,-,cin,OROR,==,<=,lambda,if,+,;,else, }
state 63:
  (6) E --> E .+ E   { <,+,/,;,<=,==,^,*,&&,-,COLON,OROR,%, }
  (8) E --> E .* E   { &&,<=,*,COLON,%,;,^,+,-,<,OROR,/,==, }
  (16) E --> E .&& E   { ^,&&,/,%,OROR,==,COLON,*,+,-,<=,<,;, }
  (11) E --> E .^ E   { OROR,%,/,*,==,COLON,<=,&&,^,;,+,<,-, }
  (17) E --> E .OROR E   { <=,&&,COLON,^,;,+,-,%,/,==,<,*,OROR, }
  (13) E --> E .< E   { *,/,OROR,+,<=,<,^,COLON,-,&&,;,%,==, }
  (24) E --> E .; ES   { &&,%,/,OROR,^,<=,-,<,*,;,COLON,==,+, }
  (10) E --> E .% E   { /,;,*,COLON,<,&&,OROR,<=,-,==,+,%,^, }
  (7) E --> E .- E   { /,OROR,%,+,<=,==,<,^,-,*,&&,;,COLON, }
  (20) E --> let Var = E .COLON E   { <,EOF,Var,*,!,OROR,==,cin,&&,+,%,),-,/,^,let,COLON,;,else,<=,Val,while,lambda,(,if,cout, }
  (14) E --> E .<= E   { *,<,OROR,-,==,;,%,+,/,&&,COLON,^,<=, }
  (9) E --> E ./ E   { OROR,*,;,+,==,COLON,<,<=,/,^,-,&&,%, }
  (12) E --> E .== E   { /,*,<,<=,==,+,;,%,OROR,^,-,COLON,&&, }
state 64:
  (24) E --> E ; ES .   { *,%,^,&&,<,OROR,+,/,;,<=,==,-, }
  (26) ES --> E ; ES .   { while,Val,/,^,else,cin,!,let,%,&&,Var,cout,(,;,<=,EOF,COLON,-,OROR,lambda,+,<,if,*,==,), }
state 65:
  (11) E --> E .^ E   { EOF,lambda,Var,(,),+,Val,*,COLON,==,cin,&&,^,/,!,let,cout,while,OROR,-,<=,%,else,if,;,<, }
  (24) E --> E .; ES   { ;,cin,/,OROR,COLON,&&,*,while,cout,),%,let,else,<=,^,Val,+,Var,-,if,<,EOF,lambda,(,==,!, }
  (8) E --> E .* E   { ;,!,lambda,cin,/,COLON,Var,(,OROR,%,cout,^,*,<=,EOF,if,+,else,Val,&&,),while,==,-,let,<, }
  (14) E --> E .<= E   { &&,Val,*,-,%,/,if,),;,let,<,while,COLON,cin,cout,==,<=,^,lambda,+,EOF,(,!,OROR,else,Var, }
  (13) E --> E .< E   { Var,lambda,/,<,let,^,),*,OROR,+,if,-,while,(,;,%,else,EOF,cout,Val,<=,&&,cin,!,COLON,==, }
  (12) E --> E .== E   { OROR,+,^,let,EOF,%,;,-,else,==,lambda,COLON,<=,cin,while,*,(,<,Var,&&,Val,if,),cout,/,!, }
  (9) E --> E ./ E   { ^,if,&&,EOF,!,<,==,else,cin,while,(,+,COLON,cout,/,-,Val,Var,),lambda,;,<=,OROR,let,%,*, }
  (16) E --> E .&& E   { <=,let,EOF,+,OROR,while,^,==,lambda,),if,&&,else,Val,(,cin,;,cout,Var,!,-,%,COLON,*,/,<, }
  (7) E --> E .- E   { else,==,if,<,^,Val,<=,lambda,*,%,Var,/,COLON,while,let,!,(,),&&,EOF,;,-,cin,+,OROR,cout, }
  (10) E --> E .% E   { ==,*,(,<=,cin,else,),OROR,;,/,lambda,!,let,%,<,if,while,Var,^,Val,EOF,-,&&,+,cout,COLON, }
  (17) E --> E .OROR E   { lambda,==,Var,;,if,else,*,cout,),while,<,OROR,/,<=,%,-,Val,(,COLON,cin,^,EOF,+,let,&&,!, }
  (6) E --> E .+ E   { cout,cin,while,lambda,(,Var,^,OROR,),Val,==,%,EOF,;,+,!,COLON,else,-,if,/,*,let,<,<=,&&, }
  (23) E --> if E E else E .   { let,!,Var,while,/,cout,;,),COLON,-,+,&&,<,OROR,%,Val,==,^,*,cin,(,lambda,else,<=,EOF,if, }
state 66:
  (7) E --> E .- E   { Var,!,+,&&,==,/,lambda,OROR,(,let,cout,-,^,Val,if,EOF,<,*,cin,%,),COLON,else,<=,;,while, }
  (24) E --> E .; ES   { ;,/,*,<,!,-,cin,(,let,cout,^,<=,==,OROR,&&,else,),Var,while,if,+,lambda,Val,COLON,%,EOF, }
  (11) E --> E .^ E   { cin,else,OROR,+,cout,%,if,lambda,/,let,COLON,),*,!,Var,<,&&,EOF,(,^,;,-,==,<=,while,Val, }
  (6) E --> E .+ E   { (,^,*,else,Var,+,lambda,<,!,OROR,&&,EOF,COLON,-,/,<=,cin,cout,Val,%,==,;,),let,while,if, }
  (8) E --> E .* E   { !,),<,*,cin,/,-,Var,^,Val,lambda,while,OROR,cout,%,let,;,else,if,(,<=,COLON,EOF,&&,+,==, }
  (9) E --> E ./ E   { if,let,COLON,cout,*,;,Val,!,while,^,/,EOF,-,(,OROR,<,),%,cin,Var,&&,<=,else,+,==,lambda, }
  (16) E --> E .&& E   { ),COLON,<,Val,==,let,!,Var,cout,%,&&,while,EOF,*,/,^,;,(,<=,-,if,lambda,else,cin,+,OROR, }
  (10) E --> E .% E   { (,;,*,else,Val,%,OROR,/,),!,let,==,&&,^,+,COLON,EOF,<=,if,lambda,Var,-,while,<,cin,cout, }
  (17) E --> E .OROR E   { (,<=,if,else,Val,),/,;,Var,==,*,OROR,cout,%,lambda,COLON,-,<,!,let,+,while,&&,cin,EOF,^, }
  (14) E --> E .<= E   { %,while,-,let,*,<=,Var,<,(,COLON,^,EOF,),cout,if,&&,cin,+,OROR,else,!,;,lambda,Val,/,==, }
  (12) E --> E .== E   { if,(,<,-,cout,^,),*,lambda,/,<=,else,;,==,OROR,Val,while,Var,%,cin,+,EOF,COLON,let,&&,!, }
  (13) E --> E .< E   { ==,else,EOF,OROR,let,;,<=,/,if,+,COLON,cin,(,),*,Val,cout,while,lambda,&&,%,-,Var,!,^,<, }
  (15) E --> while ( E ) E .   { else,cout,^,lambda,),(,EOF,OROR,*,cin,/,;,<=,Val,Var,<,-,COLON,+,&&,!,let,==,while,if,%, }
state 67:
  (20) E --> .let Var = E COLON E   { ),let,;,%,(,cout,Val,cin,/,+,OROR,<=,*,^,!,else,-,<,&&,lambda,Var,while,COLON,if,==,EOF, }
  (3) E --> .cin   { /,Var,%,&&,==,+,Val,(,*,let,while,COLON,!,EOF,<,^,else,cout,;,lambda,<=,if,-,cin,),OROR, }
  (2) E --> .( Var E )   { lambda,COLON,Var,-,OROR,EOF,&&,/,<=,(,*,else,;,+,let,cin,if,Val,),<,while,%,!,^,==,cout, }
  (18) E --> .- E   { else,(,let,;,/,-,lambda,!,&&,),if,cin,Val,+,%,<,EOF,while,OROR,Var,^,cout,==,COLON,<=,*, }
  (15) E --> .while ( E ) E   { <,<=,let,;,if,/,cout,Var,cin,else,==,while,^,&&,+,OROR,*,!,EOF,-,Val,lambda,%,),(,COLON, }
  (12) E --> .E == E   { &&,Var,if,<=,else,(,;,/,%,^,EOF,<,-,!,let,Val,OROR,COLON,lambda,==,),cin,+,cout,while,*, }
  (17) E --> .E OROR E   { ;,COLON,^,Val,/,EOF,let,<=,%,<,Var,-,&&,(,cout,if,lambda,+,*,else,OROR,!,==,),while,cin, }
  (7) E --> .E - E   { ==,Val,%,COLON,cout,!,if,*,-,;,let,lambda,Var,(,else,^,while,cin,<=,),&&,EOF,/,OROR,<,+, }
  (5) E --> .cout E   { %,<,lambda,<=,),(,+,let,!,cin,Var,EOF,&&,OROR,*,-,cout,if,while,;,COLON,else,/,^,==,Val, }
  (23) E --> .if E E else E   { else,),&&,OROR,EOF,-,*,while,;,cout,/,let,if,!,<=,Val,Var,cin,+,lambda,<,COLON,(,^,==,%, }
  (9) E --> .E / E   { if,lambda,OROR,%,<=,^,while,else,Val,+,==,/,(,&&,!,<,EOF,cout,COLON,),-,cin,Var,*,;,let, }
  (16) E --> .E && E   { ;,),==,cout,+,let,<,EOF,(,if,^,cin,COLON,!,while,<=,OROR,Val,&&,Var,lambda,/,-,else,%,*, }
  (11) E --> .E ^ E   { (,^,Var,if,-,cout,%,==,<=,lambda,&&,<,cin,OROR,+,COLON,EOF,else,),/,;,Val,let,!,*,while, }
  (0) E --> .Val   { OROR,let,/,!,==,<=,*,<,;,while,else,),^,COLON,&&,Var,lambda,Val,-,cin,%,cout,+,EOF,(,if, }
  (4) E --> .cout Str   { Val,EOF,;,COLON,let,!,),/,(,&&,cin,Var,while,else,<,OROR,*,if,<=,-,cout,^,==,lambda,+,%, }
  (24) E --> .E ; ES   { ),*,let,^,EOF,;,lambda,<=,while,Var,(,OROR,cout,-,&&,if,Val,<,+,%,/,cin,==,COLON,else,!, }
  (19) E --> .! E   { cin,COLON,!,OROR,lambda,Var,;,&&,+,if,cout,(,),Val,while,==,*,%,else,EOF,<,/,<=,-,let,^, }
  (8) E --> .E * E   { cin,else,;,&&,-,while,<=,(,let,/,OROR,Val,Var,+,%,cout,lambda,),EOF,^,<,COLON,!,if,==,*, }
  (6) E --> .E + E   { ==,Val,^,<,EOF,*,(,&&,%,;,cout,let,lambda,cin,+,else,-,!,COLON,while,Var,/,),<=,OROR,if, }
  (10) E --> .E % E   { OROR,(,==,else,<,;,EOF,while,/,-,COLON,%,!,<=,Val,Var,+,^,&&,if,*,),let,cout,cin,lambda, }
  (27) E --> .Var   { <,!,cout,else,),-,/,<=,COLON,cin,OROR,Var,let,*,lambda,Val,if,;,&&,(,==,while,^,+,EOF,%, }
  (22) E --> .lambda Var . E   { Var,<=,cin,cout,),while,let,Val,(,-,^,!,==,*,COLON,<,%,&&,OROR,else,+,/,EOF,lambda,if,;, }
  (21) E --> .Var = E   { &&,%,cin,else,cout,Var,COLON,(,==,while,if,+,lambda,!,OROR,<=,/,Val,<,EOF,*,^,),-,let,;, }
  (13) E --> .E < E   { (,/,==,OROR,EOF,+,lambda,-,let,),COLON,Var,if,cin,&&,else,*,!,cout,<=,while,^,Val,<,;,%, }
  (1) E --> .( E )   { if,while,&&,(,==,^,lambda,),else,<=,EOF,;,COLON,-,+,Val,cout,Var,%,let,*,!,<,/,cin,OROR, }
  (14) E --> .E <= E   { lambda,else,!,Val,/,if,%,<=,COLON,let,OROR,*,;,while,(,-,^,<,cin,+,cout,Var,),&&,==,EOF, }
  (20) E --> let Var = E COLON .E   { <=,let,lambda,cin,cout,/,),==,(,OROR,if,!,else,+,&&,while,<,EOF,-,%,^,;,Var,Val,COLON,*, }
state 68:
  (17) E --> E .OROR E   { (,+,^,%,OROR,<,Val,let,&&,*,-,EOF,cout,Var,COLON,!,<=,lambda,cin,else,;,),if,==,while,/, }
  (10) E --> E .% E   { Var,if,*,else,Val,cout,),cin,COLON,<,&&,let,!,lambda,-,^,%,EOF,<=,OROR,;,while,(,/,+,==, }
  (13) E --> E .< E   { let,Val,),lambda,EOF,-,%,COLON,<,+,&&,*,<=,(,==,OROR,Var,if,;,/,else,while,!,^,cout,cin, }
  (24) E --> E .; ES   { let,COLON,<=,while,else,OROR,Val,+,EOF,*,cin,^,<,&&,lambda,;,if,/,),-,Var,!,cout,%,==,(, }
  (12) E --> E .== E   { cin,<=,<,/,!,else,Val,while,cout,OROR,if,*,(,let,Var,^,%,&&,;,+,),==,EOF,COLON,-,lambda, }
  (11) E --> E .^ E   { ^,(,+,cout,lambda,EOF,;,%,!,),COLON,if,/,&&,Var,*,OROR,<=,Val,cin,while,let,else,<,-,==, }
  (7) E --> E .- E   { COLON,!,;,^,%,Val,&&,*,else,+,EOF,cin,<=,cout,while,-,==,let,lambda,Var,OROR,if,),(,<,/, }
  (8) E --> E .* E   { cin,/,if,cout,EOF,+,%,==,<,;,!,&&,),lambda,OROR,Val,Var,*,while,<=,-,let,else,COLON,(,^, }
  (16) E --> E .&& E   { +,COLON,%,OROR,cin,lambda,/,<,Val,else,if,&&,^,(,let,EOF,),Var,<=,!,;,cout,==,-,*,while, }
  (14) E --> E .<= E   { Var,COLON,-,cout,lambda,(,<,*,+,&&,else,while,==,/,!,Val,cin,if,EOF,^,OROR,),let,;,<=,%, }
  (6) E --> E .+ E   { <,<=,Val,cin,!,OROR,while,let,;,lambda,EOF,(,),Var,^,==,cout,+,%,if,&&,else,/,COLON,-,*, }
  (20) E --> let Var = E COLON E .   { &&,<,if,cin,Var,while,;,(,+,!,<=,COLON,cout,EOF,),%,Val,^,let,else,-,==,OROR,*,/,lambda, }
  (9) E --> E ./ E   { ),EOF,^,*,cout,if,;,-,while,<,<=,else,cin,/,let,Val,lambda,+,(,COLON,%,OROR,==,Var,&&,!, }
written parser to mgparser.rs