rustlr 0.3.7

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