d

-----------------------------------------------------------------------------
Info file generated by Happy Version 1.18.9 from Main.y
-----------------------------------------------------------------------------

state 96 contains 1 shift/reduce conflicts.
state 114 contains 2 shift/reduce conflicts.
state 146 contains 1 shift/reduce conflicts.

-----------------------------------------------------------------------------
Grammar
-----------------------------------------------------------------------------
	%start_parseProgram -> Program                     (0)
	Program -> PACKAGE IDENT END ImportList GVar Funz   (1)
	ImportList ->                                      (2)
	ImportList -> IMPORT STRINGA END ImportList        (3)
	ImportList -> IMPORT OPENR END Imp CLOSER END      (4)
	Imp -> STRINGA END Imp2                            (5)
	Imp2 ->                                            (6)
	Imp2 -> STRINGA END Imp2                           (7)
	OptEnd ->                                          (8)
	OptEnd -> OptEnd END                               (9)
	GVar ->                                            (10)
	GVar -> VAR IDENT Tipo END GVar                    (11)
	GVar -> VAR IDENT Tipo UGUALE Valori END GVar      (12)
	GVar -> VAR OPENR END VarLine CLOSER END GVar      (13)
	VarLine ->                                         (14)
	VarLine -> IDENT Tipo UGUALE Valori END VarLine    (15)
	VarLine -> IDENT Tipo END VarLine                  (16)
	Valori -> INTERO                                   (17)
	Valori -> FLOAT                                    (18)
	Valori -> BOOLEANO                                 (19)
	Valori -> STRINGA                                  (20)
	Valori -> CHAR                                     (21)
	Tipo ->                                            (22)
	Tipo -> RUNE                                       (23)
	Tipo -> BOOL                                       (24)
	Tipo -> STR                                        (25)
	Tipo -> INT                                        (26)
	Tipo -> AST Tipo                                   (27)
	Tipo -> FLOAT32                                    (28)
	Tipo -> FLOAT64                                    (29)
	Tipo -> OPENQ INTERO CLOSEQ Tipo                   (30)
	Funz ->                                            (31)
	Funz -> Funz FUNC IDENT OPENR ParList CLOSER Tipo Blocco OptEnd   (32)
	ParList ->                                         (33)
	ParList -> ParListNE                               (34)
	ParListNE -> IDENT Tipo Modo                       (35)
	ParListNE -> ParListNE COMMA IDENT Tipo Modo       (36)
	Modo -> VALRES                                     (37)
	Modo -> CNST                                       (38)
	Modo ->                                            (39)
	Modo -> VAL                                        (40)
	Blocco -> OPENG END GVar Lstm OptEnd CLOSEG END    (41)
	BloccoNE -> OPENG END GVar Lstm OptEnd CLOSEG      (42)
	BloccoSw -> OPENG END Lcase CLOSEG END             (43)
	Lstm ->                                            (44)
	Lstm -> Stm Lstm                                   (45)
	Stm -> FOR RE SEMICOL RE SEMICOL RE Blocco         (46)
	Stm -> FOR RE Blocco                               (47)
	Stm -> FOR Blocco                                  (48)
	Stm -> IF RE Blocco                                (49)
	Stm -> IF RE BloccoNE ELSE Blocco                  (50)
	Stm -> SWITCH IDENT BloccoSw                       (51)
	Stm -> Blocco                                      (52)
	Stm -> TRY BloccoNE CATCH Blocco                   (53)
	Stm -> RE END                                      (54)
	Stm -> RETURN END                                  (55)
	Stm -> RETURN RE OptEnd                            (56)
	Lcase ->                                           (57)
	Lcase -> CASE Valori COL Lstm OptEnd Lcase         (58)
	Lcase -> DEFAULT COL Lstm OptEnd                   (59)
	RE -> RE PLUS RE                                   (60)
	RE -> RE MINUS RE                                  (61)
	RE -> RE OPEQ RE                                   (62)
	RE -> RE OPDISEQ RE                                (63)
	RE -> RE OR RE                                     (64)
	RE -> RE AND RE                                    (65)
	RE -> RE AST RE                                    (66)
	RE -> RE DIV RE                                    (67)
	RE -> RE POW RE                                    (68)
	RE -> OPENR RE CLOSER                              (69)
	RE -> MINUS RE                                     (70)
	RE -> NOT RE                                       (71)
	RE -> LE                                           (72)
	RE -> IDENT OPENR ListParAtt CLOSER                (73)
	RE -> DEPUNT IDENT                                 (74)
	RE -> Valori                                       (75)
	RE -> LE UGUALE RE                                 (76)
	ListParAtt ->                                      (77)
	ListParAtt -> ListParAttNE                         (78)
	ListParAttNE -> RE                                 (79)
	ListParAttNE -> ListParAttNE COMMA RE              (80)
	LE -> IDENT                                        (81)
	LE -> AST IDENT                                    (82)
	LE -> IDENT OPENQ RE CLOSEQ                        (83)

-----------------------------------------------------------------------------
Terminals
-----------------------------------------------------------------------------
	PACKAGE        { (a, Package) }
	IMPORT         { (a, Import) }
	VAR            { (a, DVar) }
	FUNC           { (a, Func) }
	END            { (a, End) }
	OPENR          { (a, OpenR) }
	CLOSER         { (a, CloseR) }
	OPENQ          { (a, OpenQ) }
	CLOSEQ         { (a, CloseQ) }
	OPENG          { (a, OpenG) }
	CLOSEG         { (a, CloseG) }
	COMMA          { (a, Comma) }
	SEMICOL        { (a, Semicol) }
	COL            { (a, Col) }
	TRY            { (a, Try) }
	CATCH          { (a, Catch) }
	RETURN         { (a, Return) }
	UGUALE         { (a, Uguale) }
	IDENT          { (a, Ident $$) }
	BOOLEANO       { (a, Booleano $$) }
	INTERO         { (a, Intero $$) }
	FLOAT          { (a, Reale $$) }
	STRINGA        { (a, Stringa $$) }
	CHAR           { (a, Char $$) }
	RUNE           { (a, TRune) }
	BOOL           { (a, TBool) }
	INT            { (a, TInt) }
	STR            { (a, TStr) }
	AST            { (a, Ast) }
	FLOAT32        { (a, TFloat32) }
	FLOAT64        { (a, TFloat64) }
	VAL            { (a, Val) }
	VALRES         { (a, Valres) }
	CNST           { (a, Cnst) }
	FOR            { (a, For) }
	IF             { (a, If) }
	ELSE           { (a, Else) }
	SWITCH         { (a, Switch) }
	CASE           { (a, Case) }
	DEFAULT        { (a, Default) }
	PLUS           { (a, Plus) }
	MINUS          { (a, Minus) }
	DIV            { (a, Div) }
	POW            { (a, Pow) }
	OPEQ           { (a, OpEq $$) }
	OPDISEQ        { (a, OpDiseq $$) }
	AND            { (a, And) }
	OR             { (a, Or) }
	NOT            { (a, Not) }
	DEPUNT         { (a, DePunt) }

-----------------------------------------------------------------------------
Non-terminals
-----------------------------------------------------------------------------
	%start_parseProgram rule  0
	Program         rule  1
	ImportList      rules 2, 3, 4
	Imp             rule  5
	Imp2            rules 6, 7
	OptEnd          rules 8, 9
	GVar            rules 10, 11, 12, 13
	VarLine         rules 14, 15, 16
	Valori          rules 17, 18, 19, 20, 21
	Tipo            rules 22, 23, 24, 25, 26, 27, 28, 29, 30
	Funz            rules 31, 32
	ParList         rules 33, 34
	ParListNE       rules 35, 36
	Modo            rules 37, 38, 39, 40
	Blocco          rule  41
	BloccoNE        rule  42
	BloccoSw        rule  43
	Lstm            rules 44, 45
	Stm             rules 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56
	Lcase           rules 57, 58, 59
	RE              rules 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76
	ListParAtt      rules 77, 78
	ListParAttNE    rules 79, 80
	LE              rules 81, 82, 83

-----------------------------------------------------------------------------
States
-----------------------------------------------------------------------------
State 0


	PACKAGE        shift, and enter state 2

	Program        goto state 3

State 1


	PACKAGE        shift, and enter state 2


State 2

	Program -> PACKAGE . IDENT END ImportList GVar Funz    (rule 1)

	IDENT          shift, and enter state 4


State 3

	%start_parseProgram -> Program .                    (rule 0)

	%eof           accept


State 4

	Program -> PACKAGE IDENT . END ImportList GVar Funz    (rule 1)

	END            shift, and enter state 5


State 5

	Program -> PACKAGE IDENT END . ImportList GVar Funz    (rule 1)

	IMPORT         shift, and enter state 7
	VAR            reduce using rule 2
	FUNC           reduce using rule 2
	%eof           reduce using rule 2

	ImportList     goto state 6

State 6

	Program -> PACKAGE IDENT END ImportList . GVar Funz    (rule 1)

	VAR            shift, and enter state 11
	FUNC           reduce using rule 10
	%eof           reduce using rule 10

	GVar           goto state 10

State 7

	ImportList -> IMPORT . STRINGA END ImportList       (rule 3)
	ImportList -> IMPORT . OPENR END Imp CLOSER END     (rule 4)

	OPENR          shift, and enter state 8
	STRINGA        shift, and enter state 9


State 8

	ImportList -> IMPORT OPENR . END Imp CLOSER END     (rule 4)

	END            shift, and enter state 16


State 9

	ImportList -> IMPORT STRINGA . END ImportList       (rule 3)

	END            shift, and enter state 15


State 10

	Program -> PACKAGE IDENT END ImportList GVar . Funz    (rule 1)

	FUNC           reduce using rule 31
	%eof           reduce using rule 31

	Funz           goto state 14

State 11

	GVar -> VAR . IDENT Tipo END GVar                   (rule 11)
	GVar -> VAR . IDENT Tipo UGUALE Valori END GVar     (rule 12)
	GVar -> VAR . OPENR END VarLine CLOSER END GVar     (rule 13)

	OPENR          shift, and enter state 12
	IDENT          shift, and enter state 13


State 12

	GVar -> VAR OPENR . END VarLine CLOSER END GVar     (rule 13)

	END            shift, and enter state 30


State 13

	GVar -> VAR IDENT . Tipo END GVar                   (rule 11)
	GVar -> VAR IDENT . Tipo UGUALE Valori END GVar     (rule 12)

	END            reduce using rule 22
	OPENQ          shift, and enter state 22
	UGUALE         reduce using rule 22
	RUNE           shift, and enter state 23
	BOOL           shift, and enter state 24
	INT            shift, and enter state 25
	STR            shift, and enter state 26
	AST            shift, and enter state 27
	FLOAT32        shift, and enter state 28
	FLOAT64        shift, and enter state 29

	Tipo           goto state 21

State 14

	Program -> PACKAGE IDENT END ImportList GVar Funz .    (rule 1)
	Funz -> Funz . FUNC IDENT OPENR ParList CLOSER Tipo Blocco OptEnd    (rule 32)

	FUNC           shift, and enter state 20
	%eof           reduce using rule 1


State 15

	ImportList -> IMPORT STRINGA END . ImportList       (rule 3)

	IMPORT         shift, and enter state 7
	VAR            reduce using rule 2
	FUNC           reduce using rule 2
	%eof           reduce using rule 2

	ImportList     goto state 19

State 16

	ImportList -> IMPORT OPENR END . Imp CLOSER END     (rule 4)

	STRINGA        shift, and enter state 18

	Imp            goto state 17

State 17

	ImportList -> IMPORT OPENR END Imp . CLOSER END     (rule 4)

	CLOSER         shift, and enter state 39


State 18

	Imp -> STRINGA . END Imp2                           (rule 5)

	END            shift, and enter state 38


State 19

	ImportList -> IMPORT STRINGA END ImportList .       (rule 3)

	VAR            reduce using rule 3
	FUNC           reduce using rule 3
	%eof           reduce using rule 3


State 20

	Funz -> Funz FUNC . IDENT OPENR ParList CLOSER Tipo Blocco OptEnd    (rule 32)

	IDENT          shift, and enter state 37


State 21

	GVar -> VAR IDENT Tipo . END GVar                   (rule 11)
	GVar -> VAR IDENT Tipo . UGUALE Valori END GVar     (rule 12)

	END            shift, and enter state 35
	UGUALE         shift, and enter state 36


State 22

	Tipo -> OPENQ . INTERO CLOSEQ Tipo                  (rule 30)

	INTERO         shift, and enter state 34


State 23

	Tipo -> RUNE .                                      (rule 23)

	END            reduce using rule 23
	CLOSER         reduce using rule 23
	OPENG          reduce using rule 23
	COMMA          reduce using rule 23
	UGUALE         reduce using rule 23
	VAL            reduce using rule 23
	VALRES         reduce using rule 23
	CNST           reduce using rule 23


State 24

	Tipo -> BOOL .                                      (rule 24)

	END            reduce using rule 24
	CLOSER         reduce using rule 24
	OPENG          reduce using rule 24
	COMMA          reduce using rule 24
	UGUALE         reduce using rule 24
	VAL            reduce using rule 24
	VALRES         reduce using rule 24
	CNST           reduce using rule 24


State 25

	Tipo -> INT .                                       (rule 26)

	END            reduce using rule 26
	CLOSER         reduce using rule 26
	OPENG          reduce using rule 26
	COMMA          reduce using rule 26
	UGUALE         reduce using rule 26
	VAL            reduce using rule 26
	VALRES         reduce using rule 26
	CNST           reduce using rule 26


State 26

	Tipo -> STR .                                       (rule 25)

	END            reduce using rule 25
	CLOSER         reduce using rule 25
	OPENG          reduce using rule 25
	COMMA          reduce using rule 25
	UGUALE         reduce using rule 25
	VAL            reduce using rule 25
	VALRES         reduce using rule 25
	CNST           reduce using rule 25


State 27

	Tipo -> AST . Tipo                                  (rule 27)

	END            reduce using rule 22
	CLOSER         reduce using rule 22
	OPENQ          shift, and enter state 22
	OPENG          reduce using rule 22
	COMMA          reduce using rule 22
	UGUALE         reduce using rule 22
	RUNE           shift, and enter state 23
	BOOL           shift, and enter state 24
	INT            shift, and enter state 25
	STR            shift, and enter state 26
	AST            shift, and enter state 27
	FLOAT32        shift, and enter state 28
	FLOAT64        shift, and enter state 29
	VAL            reduce using rule 22
	VALRES         reduce using rule 22
	CNST           reduce using rule 22

	Tipo           goto state 33

State 28

	Tipo -> FLOAT32 .                                   (rule 28)

	END            reduce using rule 28
	CLOSER         reduce using rule 28
	OPENG          reduce using rule 28
	COMMA          reduce using rule 28
	UGUALE         reduce using rule 28
	VAL            reduce using rule 28
	VALRES         reduce using rule 28
	CNST           reduce using rule 28


State 29

	Tipo -> FLOAT64 .                                   (rule 29)

	END            reduce using rule 29
	CLOSER         reduce using rule 29
	OPENG          reduce using rule 29
	COMMA          reduce using rule 29
	UGUALE         reduce using rule 29
	VAL            reduce using rule 29
	VALRES         reduce using rule 29
	CNST           reduce using rule 29


State 30

	GVar -> VAR OPENR END . VarLine CLOSER END GVar     (rule 13)

	CLOSER         reduce using rule 14
	IDENT          shift, and enter state 32

	VarLine        goto state 31

State 31

	GVar -> VAR OPENR END VarLine . CLOSER END GVar     (rule 13)

	CLOSER         shift, and enter state 53


State 32

	VarLine -> IDENT . Tipo UGUALE Valori END VarLine    (rule 15)
	VarLine -> IDENT . Tipo END VarLine                 (rule 16)

	END            reduce using rule 22
	OPENQ          shift, and enter state 22
	UGUALE         reduce using rule 22
	RUNE           shift, and enter state 23
	BOOL           shift, and enter state 24
	INT            shift, and enter state 25
	STR            shift, and enter state 26
	AST            shift, and enter state 27
	FLOAT32        shift, and enter state 28
	FLOAT64        shift, and enter state 29

	Tipo           goto state 52

State 33

	Tipo -> AST Tipo .                                  (rule 27)

	END            reduce using rule 27
	CLOSER         reduce using rule 27
	OPENG          reduce using rule 27
	COMMA          reduce using rule 27
	UGUALE         reduce using rule 27
	VAL            reduce using rule 27
	VALRES         reduce using rule 27
	CNST           reduce using rule 27


State 34

	Tipo -> OPENQ INTERO . CLOSEQ Tipo                  (rule 30)

	CLOSEQ         shift, and enter state 51


State 35

	GVar -> VAR IDENT Tipo END . GVar                   (rule 11)

	VAR            shift, and enter state 11
	FUNC           reduce using rule 10
	END            reduce using rule 10
	OPENR          reduce using rule 10
	OPENG          reduce using rule 10
	CLOSEG         reduce using rule 10
	TRY            reduce using rule 10
	RETURN         reduce using rule 10
	IDENT          reduce using rule 10
	BOOLEANO       reduce using rule 10
	INTERO         reduce using rule 10
	FLOAT          reduce using rule 10
	STRINGA        reduce using rule 10
	CHAR           reduce using rule 10
	AST            reduce using rule 10
	FOR            reduce using rule 10
	IF             reduce using rule 10
	SWITCH         reduce using rule 10
	MINUS          reduce using rule 10
	NOT            reduce using rule 10
	DEPUNT         reduce using rule 10
	%eof           reduce using rule 10

	GVar           goto state 50

State 36

	GVar -> VAR IDENT Tipo UGUALE . Valori END GVar     (rule 12)

	BOOLEANO       shift, and enter state 45
	INTERO         shift, and enter state 46
	FLOAT          shift, and enter state 47
	STRINGA        shift, and enter state 48
	CHAR           shift, and enter state 49

	Valori         goto state 44

State 37

	Funz -> Funz FUNC IDENT . OPENR ParList CLOSER Tipo Blocco OptEnd    (rule 32)

	OPENR          shift, and enter state 43


State 38

	Imp -> STRINGA END . Imp2                           (rule 5)

	CLOSER         reduce using rule 6
	STRINGA        shift, and enter state 42

	Imp2           goto state 41

State 39

	ImportList -> IMPORT OPENR END Imp CLOSER . END     (rule 4)

	END            shift, and enter state 40


State 40

	ImportList -> IMPORT OPENR END Imp CLOSER END .     (rule 4)

	VAR            reduce using rule 4
	FUNC           reduce using rule 4
	%eof           reduce using rule 4


State 41

	Imp -> STRINGA END Imp2 .                           (rule 5)

	CLOSER         reduce using rule 5


State 42

	Imp2 -> STRINGA . END Imp2                          (rule 7)

	END            shift, and enter state 62


State 43

	Funz -> Funz FUNC IDENT OPENR . ParList CLOSER Tipo Blocco OptEnd    (rule 32)

	CLOSER         reduce using rule 33
	IDENT          shift, and enter state 61

	ParList        goto state 59
	ParListNE      goto state 60

State 44

	GVar -> VAR IDENT Tipo UGUALE Valori . END GVar     (rule 12)

	END            shift, and enter state 58


State 45

	Valori -> BOOLEANO .                                (rule 19)

	END            reduce using rule 19
	OPENR          reduce using rule 19
	CLOSER         reduce using rule 19
	CLOSEQ         reduce using rule 19
	OPENG          reduce using rule 19
	CLOSEG         reduce using rule 19
	COMMA          reduce using rule 19
	SEMICOL        reduce using rule 19
	COL            reduce using rule 19
	TRY            reduce using rule 19
	RETURN         reduce using rule 19
	IDENT          reduce using rule 19
	BOOLEANO       reduce using rule 19
	INTERO         reduce using rule 19
	FLOAT          reduce using rule 19
	STRINGA        reduce using rule 19
	CHAR           reduce using rule 19
	AST            reduce using rule 19
	FOR            reduce using rule 19
	IF             reduce using rule 19
	SWITCH         reduce using rule 19
	CASE           reduce using rule 19
	DEFAULT        reduce using rule 19
	PLUS           reduce using rule 19
	MINUS          reduce using rule 19
	DIV            reduce using rule 19
	POW            reduce using rule 19
	OPEQ           reduce using rule 19
	OPDISEQ        reduce using rule 19
	AND            reduce using rule 19
	OR             reduce using rule 19
	NOT            reduce using rule 19
	DEPUNT         reduce using rule 19


State 46

	Valori -> INTERO .                                  (rule 17)

	END            reduce using rule 17
	OPENR          reduce using rule 17
	CLOSER         reduce using rule 17
	CLOSEQ         reduce using rule 17
	OPENG          reduce using rule 17
	CLOSEG         reduce using rule 17
	COMMA          reduce using rule 17
	SEMICOL        reduce using rule 17
	COL            reduce using rule 17
	TRY            reduce using rule 17
	RETURN         reduce using rule 17
	IDENT          reduce using rule 17
	BOOLEANO       reduce using rule 17
	INTERO         reduce using rule 17
	FLOAT          reduce using rule 17
	STRINGA        reduce using rule 17
	CHAR           reduce using rule 17
	AST            reduce using rule 17
	FOR            reduce using rule 17
	IF             reduce using rule 17
	SWITCH         reduce using rule 17
	CASE           reduce using rule 17
	DEFAULT        reduce using rule 17
	PLUS           reduce using rule 17
	MINUS          reduce using rule 17
	DIV            reduce using rule 17
	POW            reduce using rule 17
	OPEQ           reduce using rule 17
	OPDISEQ        reduce using rule 17
	AND            reduce using rule 17
	OR             reduce using rule 17
	NOT            reduce using rule 17
	DEPUNT         reduce using rule 17


State 47

	Valori -> FLOAT .                                   (rule 18)

	END            reduce using rule 18
	OPENR          reduce using rule 18
	CLOSER         reduce using rule 18
	CLOSEQ         reduce using rule 18
	OPENG          reduce using rule 18
	CLOSEG         reduce using rule 18
	COMMA          reduce using rule 18
	SEMICOL        reduce using rule 18
	COL            reduce using rule 18
	TRY            reduce using rule 18
	RETURN         reduce using rule 18
	IDENT          reduce using rule 18
	BOOLEANO       reduce using rule 18
	INTERO         reduce using rule 18
	FLOAT          reduce using rule 18
	STRINGA        reduce using rule 18
	CHAR           reduce using rule 18
	AST            reduce using rule 18
	FOR            reduce using rule 18
	IF             reduce using rule 18
	SWITCH         reduce using rule 18
	CASE           reduce using rule 18
	DEFAULT        reduce using rule 18
	PLUS           reduce using rule 18
	MINUS          reduce using rule 18
	DIV            reduce using rule 18
	POW            reduce using rule 18
	OPEQ           reduce using rule 18
	OPDISEQ        reduce using rule 18
	AND            reduce using rule 18
	OR             reduce using rule 18
	NOT            reduce using rule 18
	DEPUNT         reduce using rule 18


State 48

	Valori -> STRINGA .                                 (rule 20)

	END            reduce using rule 20
	OPENR          reduce using rule 20
	CLOSER         reduce using rule 20
	CLOSEQ         reduce using rule 20
	OPENG          reduce using rule 20
	CLOSEG         reduce using rule 20
	COMMA          reduce using rule 20
	SEMICOL        reduce using rule 20
	COL            reduce using rule 20
	TRY            reduce using rule 20
	RETURN         reduce using rule 20
	IDENT          reduce using rule 20
	BOOLEANO       reduce using rule 20
	INTERO         reduce using rule 20
	FLOAT          reduce using rule 20
	STRINGA        reduce using rule 20
	CHAR           reduce using rule 20
	AST            reduce using rule 20
	FOR            reduce using rule 20
	IF             reduce using rule 20
	SWITCH         reduce using rule 20
	CASE           reduce using rule 20
	DEFAULT        reduce using rule 20
	PLUS           reduce using rule 20
	MINUS          reduce using rule 20
	DIV            reduce using rule 20
	POW            reduce using rule 20
	OPEQ           reduce using rule 20
	OPDISEQ        reduce using rule 20
	AND            reduce using rule 20
	OR             reduce using rule 20
	NOT            reduce using rule 20
	DEPUNT         reduce using rule 20


State 49

	Valori -> CHAR .                                    (rule 21)

	END            reduce using rule 21
	OPENR          reduce using rule 21
	CLOSER         reduce using rule 21
	CLOSEQ         reduce using rule 21
	OPENG          reduce using rule 21
	CLOSEG         reduce using rule 21
	COMMA          reduce using rule 21
	SEMICOL        reduce using rule 21
	COL            reduce using rule 21
	TRY            reduce using rule 21
	RETURN         reduce using rule 21
	IDENT          reduce using rule 21
	BOOLEANO       reduce using rule 21
	INTERO         reduce using rule 21
	FLOAT          reduce using rule 21
	STRINGA        reduce using rule 21
	CHAR           reduce using rule 21
	AST            reduce using rule 21
	FOR            reduce using rule 21
	IF             reduce using rule 21
	SWITCH         reduce using rule 21
	CASE           reduce using rule 21
	DEFAULT        reduce using rule 21
	PLUS           reduce using rule 21
	MINUS          reduce using rule 21
	DIV            reduce using rule 21
	POW            reduce using rule 21
	OPEQ           reduce using rule 21
	OPDISEQ        reduce using rule 21
	AND            reduce using rule 21
	OR             reduce using rule 21
	NOT            reduce using rule 21
	DEPUNT         reduce using rule 21


State 50

	GVar -> VAR IDENT Tipo END GVar .                   (rule 11)

	FUNC           reduce using rule 11
	END            reduce using rule 11
	OPENR          reduce using rule 11
	OPENG          reduce using rule 11
	CLOSEG         reduce using rule 11
	TRY            reduce using rule 11
	RETURN         reduce using rule 11
	IDENT          reduce using rule 11
	BOOLEANO       reduce using rule 11
	INTERO         reduce using rule 11
	FLOAT          reduce using rule 11
	STRINGA        reduce using rule 11
	CHAR           reduce using rule 11
	AST            reduce using rule 11
	FOR            reduce using rule 11
	IF             reduce using rule 11
	SWITCH         reduce using rule 11
	MINUS          reduce using rule 11
	NOT            reduce using rule 11
	DEPUNT         reduce using rule 11
	%eof           reduce using rule 11


State 51

	Tipo -> OPENQ INTERO CLOSEQ . Tipo                  (rule 30)

	END            reduce using rule 22
	CLOSER         reduce using rule 22
	OPENQ          shift, and enter state 22
	OPENG          reduce using rule 22
	COMMA          reduce using rule 22
	UGUALE         reduce using rule 22
	RUNE           shift, and enter state 23
	BOOL           shift, and enter state 24
	INT            shift, and enter state 25
	STR            shift, and enter state 26
	AST            shift, and enter state 27
	FLOAT32        shift, and enter state 28
	FLOAT64        shift, and enter state 29
	VAL            reduce using rule 22
	VALRES         reduce using rule 22
	CNST           reduce using rule 22

	Tipo           goto state 57

State 52

	VarLine -> IDENT Tipo . UGUALE Valori END VarLine    (rule 15)
	VarLine -> IDENT Tipo . END VarLine                 (rule 16)

	END            shift, and enter state 55
	UGUALE         shift, and enter state 56


State 53

	GVar -> VAR OPENR END VarLine CLOSER . END GVar     (rule 13)

	END            shift, and enter state 54


State 54

	GVar -> VAR OPENR END VarLine CLOSER END . GVar     (rule 13)

	VAR            shift, and enter state 11
	FUNC           reduce using rule 10
	END            reduce using rule 10
	OPENR          reduce using rule 10
	OPENG          reduce using rule 10
	CLOSEG         reduce using rule 10
	TRY            reduce using rule 10
	RETURN         reduce using rule 10
	IDENT          reduce using rule 10
	BOOLEANO       reduce using rule 10
	INTERO         reduce using rule 10
	FLOAT          reduce using rule 10
	STRINGA        reduce using rule 10
	CHAR           reduce using rule 10
	AST            reduce using rule 10
	FOR            reduce using rule 10
	IF             reduce using rule 10
	SWITCH         reduce using rule 10
	MINUS          reduce using rule 10
	NOT            reduce using rule 10
	DEPUNT         reduce using rule 10
	%eof           reduce using rule 10

	GVar           goto state 70

State 55

	VarLine -> IDENT Tipo END . VarLine                 (rule 16)

	CLOSER         reduce using rule 14
	IDENT          shift, and enter state 32

	VarLine        goto state 69

State 56

	VarLine -> IDENT Tipo UGUALE . Valori END VarLine    (rule 15)

	BOOLEANO       shift, and enter state 45
	INTERO         shift, and enter state 46
	FLOAT          shift, and enter state 47
	STRINGA        shift, and enter state 48
	CHAR           shift, and enter state 49

	Valori         goto state 68

State 57

	Tipo -> OPENQ INTERO CLOSEQ Tipo .                  (rule 30)

	END            reduce using rule 30
	CLOSER         reduce using rule 30
	OPENG          reduce using rule 30
	COMMA          reduce using rule 30
	UGUALE         reduce using rule 30
	VAL            reduce using rule 30
	VALRES         reduce using rule 30
	CNST           reduce using rule 30


State 58

	GVar -> VAR IDENT Tipo UGUALE Valori END . GVar     (rule 12)

	VAR            shift, and enter state 11
	FUNC           reduce using rule 10
	END            reduce using rule 10
	OPENR          reduce using rule 10
	OPENG          reduce using rule 10
	CLOSEG         reduce using rule 10
	TRY            reduce using rule 10
	RETURN         reduce using rule 10
	IDENT          reduce using rule 10
	BOOLEANO       reduce using rule 10
	INTERO         reduce using rule 10
	FLOAT          reduce using rule 10
	STRINGA        reduce using rule 10
	CHAR           reduce using rule 10
	AST            reduce using rule 10
	FOR            reduce using rule 10
	IF             reduce using rule 10
	SWITCH         reduce using rule 10
	MINUS          reduce using rule 10
	NOT            reduce using rule 10
	DEPUNT         reduce using rule 10
	%eof           reduce using rule 10

	GVar           goto state 67

State 59

	Funz -> Funz FUNC IDENT OPENR ParList . CLOSER Tipo Blocco OptEnd    (rule 32)

	CLOSER         shift, and enter state 66


State 60

	ParList -> ParListNE .                              (rule 34)
	ParListNE -> ParListNE . COMMA IDENT Tipo Modo      (rule 36)

	CLOSER         reduce using rule 34
	COMMA          shift, and enter state 65


State 61

	ParListNE -> IDENT . Tipo Modo                      (rule 35)

	CLOSER         reduce using rule 22
	OPENQ          shift, and enter state 22
	COMMA          reduce using rule 22
	RUNE           shift, and enter state 23
	BOOL           shift, and enter state 24
	INT            shift, and enter state 25
	STR            shift, and enter state 26
	AST            shift, and enter state 27
	FLOAT32        shift, and enter state 28
	FLOAT64        shift, and enter state 29
	VAL            reduce using rule 22
	VALRES         reduce using rule 22
	CNST           reduce using rule 22

	Tipo           goto state 64

State 62

	Imp2 -> STRINGA END . Imp2                          (rule 7)

	CLOSER         reduce using rule 6
	STRINGA        shift, and enter state 42

	Imp2           goto state 63

State 63

	Imp2 -> STRINGA END Imp2 .                          (rule 7)

	CLOSER         reduce using rule 7


State 64

	ParListNE -> IDENT Tipo . Modo                      (rule 35)

	CLOSER         reduce using rule 39
	COMMA          reduce using rule 39
	VAL            shift, and enter state 75
	VALRES         shift, and enter state 76
	CNST           shift, and enter state 77

	Modo           goto state 74

State 65

	ParListNE -> ParListNE COMMA . IDENT Tipo Modo      (rule 36)

	IDENT          shift, and enter state 73


State 66

	Funz -> Funz FUNC IDENT OPENR ParList CLOSER . Tipo Blocco OptEnd    (rule 32)

	OPENQ          shift, and enter state 22
	OPENG          reduce using rule 22
	RUNE           shift, and enter state 23
	BOOL           shift, and enter state 24
	INT            shift, and enter state 25
	STR            shift, and enter state 26
	AST            shift, and enter state 27
	FLOAT32        shift, and enter state 28
	FLOAT64        shift, and enter state 29

	Tipo           goto state 72

State 67

	GVar -> VAR IDENT Tipo UGUALE Valori END GVar .     (rule 12)

	FUNC           reduce using rule 12
	END            reduce using rule 12
	OPENR          reduce using rule 12
	OPENG          reduce using rule 12
	CLOSEG         reduce using rule 12
	TRY            reduce using rule 12
	RETURN         reduce using rule 12
	IDENT          reduce using rule 12
	BOOLEANO       reduce using rule 12
	INTERO         reduce using rule 12
	FLOAT          reduce using rule 12
	STRINGA        reduce using rule 12
	CHAR           reduce using rule 12
	AST            reduce using rule 12
	FOR            reduce using rule 12
	IF             reduce using rule 12
	SWITCH         reduce using rule 12
	MINUS          reduce using rule 12
	NOT            reduce using rule 12
	DEPUNT         reduce using rule 12
	%eof           reduce using rule 12


State 68

	VarLine -> IDENT Tipo UGUALE Valori . END VarLine    (rule 15)

	END            shift, and enter state 71


State 69

	VarLine -> IDENT Tipo END VarLine .                 (rule 16)

	CLOSER         reduce using rule 16


State 70

	GVar -> VAR OPENR END VarLine CLOSER END GVar .     (rule 13)

	FUNC           reduce using rule 13
	END            reduce using rule 13
	OPENR          reduce using rule 13
	OPENG          reduce using rule 13
	CLOSEG         reduce using rule 13
	TRY            reduce using rule 13
	RETURN         reduce using rule 13
	IDENT          reduce using rule 13
	BOOLEANO       reduce using rule 13
	INTERO         reduce using rule 13
	FLOAT          reduce using rule 13
	STRINGA        reduce using rule 13
	CHAR           reduce using rule 13
	AST            reduce using rule 13
	FOR            reduce using rule 13
	IF             reduce using rule 13
	SWITCH         reduce using rule 13
	MINUS          reduce using rule 13
	NOT            reduce using rule 13
	DEPUNT         reduce using rule 13
	%eof           reduce using rule 13


State 71

	VarLine -> IDENT Tipo UGUALE Valori END . VarLine    (rule 15)

	CLOSER         reduce using rule 14
	IDENT          shift, and enter state 32

	VarLine        goto state 81

State 72

	Funz -> Funz FUNC IDENT OPENR ParList CLOSER Tipo . Blocco OptEnd    (rule 32)

	OPENG          shift, and enter state 80

	Blocco         goto state 79

State 73

	ParListNE -> ParListNE COMMA IDENT . Tipo Modo      (rule 36)

	CLOSER         reduce using rule 22
	OPENQ          shift, and enter state 22
	COMMA          reduce using rule 22
	RUNE           shift, and enter state 23
	BOOL           shift, and enter state 24
	INT            shift, and enter state 25
	STR            shift, and enter state 26
	AST            shift, and enter state 27
	FLOAT32        shift, and enter state 28
	FLOAT64        shift, and enter state 29
	VAL            reduce using rule 22
	VALRES         reduce using rule 22
	CNST           reduce using rule 22

	Tipo           goto state 78

State 74

	ParListNE -> IDENT Tipo Modo .                      (rule 35)

	CLOSER         reduce using rule 35
	COMMA          reduce using rule 35


State 75

	Modo -> VAL .                                       (rule 40)

	CLOSER         reduce using rule 40
	COMMA          reduce using rule 40


State 76

	Modo -> VALRES .                                    (rule 37)

	CLOSER         reduce using rule 37
	COMMA          reduce using rule 37


State 77

	Modo -> CNST .                                      (rule 38)

	CLOSER         reduce using rule 38
	COMMA          reduce using rule 38


State 78

	ParListNE -> ParListNE COMMA IDENT Tipo . Modo      (rule 36)

	CLOSER         reduce using rule 39
	COMMA          reduce using rule 39
	VAL            shift, and enter state 75
	VALRES         shift, and enter state 76
	CNST           shift, and enter state 77

	Modo           goto state 84

State 79

	Funz -> Funz FUNC IDENT OPENR ParList CLOSER Tipo Blocco . OptEnd    (rule 32)

	FUNC           reduce using rule 8
	END            reduce using rule 8
	%eof           reduce using rule 8

	OptEnd         goto state 83

State 80

	Blocco -> OPENG . END GVar Lstm OptEnd CLOSEG END    (rule 41)

	END            shift, and enter state 82


State 81

	VarLine -> IDENT Tipo UGUALE Valori END VarLine .    (rule 15)

	CLOSER         reduce using rule 15


State 82

	Blocco -> OPENG END . GVar Lstm OptEnd CLOSEG END    (rule 41)

	VAR            shift, and enter state 11
	END            reduce using rule 10
	OPENR          reduce using rule 10
	OPENG          reduce using rule 10
	CLOSEG         reduce using rule 10
	TRY            reduce using rule 10
	RETURN         reduce using rule 10
	IDENT          reduce using rule 10
	BOOLEANO       reduce using rule 10
	INTERO         reduce using rule 10
	FLOAT          reduce using rule 10
	STRINGA        reduce using rule 10
	CHAR           reduce using rule 10
	AST            reduce using rule 10
	FOR            reduce using rule 10
	IF             reduce using rule 10
	SWITCH         reduce using rule 10
	MINUS          reduce using rule 10
	NOT            reduce using rule 10
	DEPUNT         reduce using rule 10

	GVar           goto state 86

State 83

	OptEnd -> OptEnd . END                              (rule 9)
	Funz -> Funz FUNC IDENT OPENR ParList CLOSER Tipo Blocco OptEnd .    (rule 32)

	FUNC           reduce using rule 32
	END            shift, and enter state 85
	%eof           reduce using rule 32


State 84

	ParListNE -> ParListNE COMMA IDENT Tipo Modo .      (rule 36)

	CLOSER         reduce using rule 36
	COMMA          reduce using rule 36


State 85

	OptEnd -> OptEnd END .                              (rule 9)

	FUNC           reduce using rule 9
	END            reduce using rule 9
	OPENR          reduce using rule 9
	OPENG          reduce using rule 9
	CLOSEG         reduce using rule 9
	TRY            reduce using rule 9
	RETURN         reduce using rule 9
	IDENT          reduce using rule 9
	BOOLEANO       reduce using rule 9
	INTERO         reduce using rule 9
	FLOAT          reduce using rule 9
	STRINGA        reduce using rule 9
	CHAR           reduce using rule 9
	AST            reduce using rule 9
	FOR            reduce using rule 9
	IF             reduce using rule 9
	SWITCH         reduce using rule 9
	CASE           reduce using rule 9
	DEFAULT        reduce using rule 9
	MINUS          reduce using rule 9
	NOT            reduce using rule 9
	DEPUNT         reduce using rule 9
	%eof           reduce using rule 9


State 86

	Blocco -> OPENG END GVar . Lstm OptEnd CLOSEG END    (rule 41)

	END            reduce using rule 44
	OPENR          shift, and enter state 93
	OPENG          shift, and enter state 80
	CLOSEG         reduce using rule 44
	TRY            shift, and enter state 94
	RETURN         shift, and enter state 95
	IDENT          shift, and enter state 96
	BOOLEANO       shift, and enter state 45
	INTERO         shift, and enter state 46
	FLOAT          shift, and enter state 47
	STRINGA        shift, and enter state 48
	CHAR           shift, and enter state 49
	AST            shift, and enter state 97
	FOR            shift, and enter state 98
	IF             shift, and enter state 99
	SWITCH         shift, and enter state 100
	MINUS          shift, and enter state 101
	NOT            shift, and enter state 102
	DEPUNT         shift, and enter state 103

	Valori         goto state 87
	Blocco         goto state 88
	Lstm           goto state 89
	Stm            goto state 90
	RE             goto state 91
	LE             goto state 92

State 87

	RE -> Valori .                                      (rule 75)

	END            reduce using rule 75
	OPENR          reduce using rule 75
	CLOSER         reduce using rule 75
	CLOSEQ         reduce using rule 75
	OPENG          reduce using rule 75
	CLOSEG         reduce using rule 75
	COMMA          reduce using rule 75
	SEMICOL        reduce using rule 75
	TRY            reduce using rule 75
	RETURN         reduce using rule 75
	IDENT          reduce using rule 75
	BOOLEANO       reduce using rule 75
	INTERO         reduce using rule 75
	FLOAT          reduce using rule 75
	STRINGA        reduce using rule 75
	CHAR           reduce using rule 75
	AST            reduce using rule 75
	FOR            reduce using rule 75
	IF             reduce using rule 75
	SWITCH         reduce using rule 75
	CASE           reduce using rule 75
	DEFAULT        reduce using rule 75
	PLUS           reduce using rule 75
	MINUS          reduce using rule 75
	DIV            reduce using rule 75
	POW            reduce using rule 75
	OPEQ           reduce using rule 75
	OPDISEQ        reduce using rule 75
	AND            reduce using rule 75
	OR             reduce using rule 75
	NOT            reduce using rule 75
	DEPUNT         reduce using rule 75


State 88

	Stm -> Blocco .                                     (rule 52)

	END            reduce using rule 52
	OPENR          reduce using rule 52
	OPENG          reduce using rule 52
	CLOSEG         reduce using rule 52
	TRY            reduce using rule 52
	RETURN         reduce using rule 52
	IDENT          reduce using rule 52
	BOOLEANO       reduce using rule 52
	INTERO         reduce using rule 52
	FLOAT          reduce using rule 52
	STRINGA        reduce using rule 52
	CHAR           reduce using rule 52
	AST            reduce using rule 52
	FOR            reduce using rule 52
	IF             reduce using rule 52
	SWITCH         reduce using rule 52
	CASE           reduce using rule 52
	DEFAULT        reduce using rule 52
	MINUS          reduce using rule 52
	NOT            reduce using rule 52
	DEPUNT         reduce using rule 52


State 89

	Blocco -> OPENG END GVar Lstm . OptEnd CLOSEG END    (rule 41)

	END            reduce using rule 8
	CLOSEG         reduce using rule 8

	OptEnd         goto state 131

State 90

	Lstm -> Stm . Lstm                                  (rule 45)

	END            reduce using rule 44
	OPENR          shift, and enter state 93
	OPENG          shift, and enter state 80
	CLOSEG         reduce using rule 44
	TRY            shift, and enter state 94
	RETURN         shift, and enter state 95
	IDENT          shift, and enter state 96
	BOOLEANO       shift, and enter state 45
	INTERO         shift, and enter state 46
	FLOAT          shift, and enter state 47
	STRINGA        shift, and enter state 48
	CHAR           shift, and enter state 49
	AST            shift, and enter state 97
	FOR            shift, and enter state 98
	IF             shift, and enter state 99
	SWITCH         shift, and enter state 100
	CASE           reduce using rule 44
	DEFAULT        reduce using rule 44
	MINUS          shift, and enter state 101
	NOT            shift, and enter state 102
	DEPUNT         shift, and enter state 103

	Valori         goto state 87
	Blocco         goto state 88
	Lstm           goto state 130
	Stm            goto state 90
	RE             goto state 91
	LE             goto state 92

State 91

	Stm -> RE . END                                     (rule 54)
	RE -> RE . PLUS RE                                  (rule 60)
	RE -> RE . MINUS RE                                 (rule 61)
	RE -> RE . OPEQ RE                                  (rule 62)
	RE -> RE . OPDISEQ RE                               (rule 63)
	RE -> RE . OR RE                                    (rule 64)
	RE -> RE . AND RE                                   (rule 65)
	RE -> RE . AST RE                                   (rule 66)
	RE -> RE . DIV RE                                   (rule 67)
	RE -> RE . POW RE                                   (rule 68)

	END            shift, and enter state 120
	AST            shift, and enter state 121
	PLUS           shift, and enter state 122
	MINUS          shift, and enter state 123
	DIV            shift, and enter state 124
	POW            shift, and enter state 125
	OPEQ           shift, and enter state 126
	OPDISEQ        shift, and enter state 127
	AND            shift, and enter state 128
	OR             shift, and enter state 129


State 92

	RE -> LE .                                          (rule 72)
	RE -> LE . UGUALE RE                                (rule 76)

	END            reduce using rule 72
	OPENR          reduce using rule 72
	CLOSER         reduce using rule 72
	CLOSEQ         reduce using rule 72
	OPENG          reduce using rule 72
	CLOSEG         reduce using rule 72
	COMMA          reduce using rule 72
	SEMICOL        reduce using rule 72
	TRY            reduce using rule 72
	RETURN         reduce using rule 72
	UGUALE         shift, and enter state 119
	IDENT          reduce using rule 72
	BOOLEANO       reduce using rule 72
	INTERO         reduce using rule 72
	FLOAT          reduce using rule 72
	STRINGA        reduce using rule 72
	CHAR           reduce using rule 72
	AST            reduce using rule 72
	FOR            reduce using rule 72
	IF             reduce using rule 72
	SWITCH         reduce using rule 72
	CASE           reduce using rule 72
	DEFAULT        reduce using rule 72
	PLUS           reduce using rule 72
	MINUS          reduce using rule 72
	DIV            reduce using rule 72
	POW            reduce using rule 72
	OPEQ           reduce using rule 72
	OPDISEQ        reduce using rule 72
	AND            reduce using rule 72
	OR             reduce using rule 72
	NOT            reduce using rule 72
	DEPUNT         reduce using rule 72


State 93

	RE -> OPENR . RE CLOSER                             (rule 69)

	OPENR          shift, and enter state 93
	IDENT          shift, and enter state 96
	BOOLEANO       shift, and enter state 45
	INTERO         shift, and enter state 46
	FLOAT          shift, and enter state 47
	STRINGA        shift, and enter state 48
	CHAR           shift, and enter state 49
	AST            shift, and enter state 97
	MINUS          shift, and enter state 101
	NOT            shift, and enter state 102
	DEPUNT         shift, and enter state 103

	Valori         goto state 87
	RE             goto state 118
	LE             goto state 92

State 94

	Stm -> TRY . BloccoNE CATCH Blocco                  (rule 53)

	OPENG          shift, and enter state 117

	BloccoNE       goto state 116

State 95

	Stm -> RETURN . END                                 (rule 55)
	Stm -> RETURN . RE OptEnd                           (rule 56)

	END            shift, and enter state 115
	OPENR          shift, and enter state 93
	IDENT          shift, and enter state 96
	BOOLEANO       shift, and enter state 45
	INTERO         shift, and enter state 46
	FLOAT          shift, and enter state 47
	STRINGA        shift, and enter state 48
	CHAR           shift, and enter state 49
	AST            shift, and enter state 97
	MINUS          shift, and enter state 101
	NOT            shift, and enter state 102
	DEPUNT         shift, and enter state 103

	Valori         goto state 87
	RE             goto state 114
	LE             goto state 92

State 96

	RE -> IDENT . OPENR ListParAtt CLOSER               (rule 73)
	LE -> IDENT .                                       (rule 81)
	LE -> IDENT . OPENQ RE CLOSEQ                       (rule 83)

	END            reduce using rule 81
	OPENR          shift, and enter state 112
			(reduce using rule 81)

	CLOSER         reduce using rule 81
	OPENQ          shift, and enter state 113
	CLOSEQ         reduce using rule 81
	OPENG          reduce using rule 81
	CLOSEG         reduce using rule 81
	COMMA          reduce using rule 81
	SEMICOL        reduce using rule 81
	TRY            reduce using rule 81
	RETURN         reduce using rule 81
	UGUALE         reduce using rule 81
	IDENT          reduce using rule 81
	BOOLEANO       reduce using rule 81
	INTERO         reduce using rule 81
	FLOAT          reduce using rule 81
	STRINGA        reduce using rule 81
	CHAR           reduce using rule 81
	AST            reduce using rule 81
	FOR            reduce using rule 81
	IF             reduce using rule 81
	SWITCH         reduce using rule 81
	CASE           reduce using rule 81
	DEFAULT        reduce using rule 81
	PLUS           reduce using rule 81
	MINUS          reduce using rule 81
	DIV            reduce using rule 81
	POW            reduce using rule 81
	OPEQ           reduce using rule 81
	OPDISEQ        reduce using rule 81
	AND            reduce using rule 81
	OR             reduce using rule 81
	NOT            reduce using rule 81
	DEPUNT         reduce using rule 81


State 97

	LE -> AST . IDENT                                   (rule 82)

	IDENT          shift, and enter state 111


State 98

	Stm -> FOR . RE SEMICOL RE SEMICOL RE Blocco        (rule 46)
	Stm -> FOR . RE Blocco                              (rule 47)
	Stm -> FOR . Blocco                                 (rule 48)

	OPENR          shift, and enter state 93
	OPENG          shift, and enter state 80
	IDENT          shift, and enter state 96
	BOOLEANO       shift, and enter state 45
	INTERO         shift, and enter state 46
	FLOAT          shift, and enter state 47
	STRINGA        shift, and enter state 48
	CHAR           shift, and enter state 49
	AST            shift, and enter state 97
	MINUS          shift, and enter state 101
	NOT            shift, and enter state 102
	DEPUNT         shift, and enter state 103

	Valori         goto state 87
	Blocco         goto state 109
	RE             goto state 110
	LE             goto state 92

State 99

	Stm -> IF . RE Blocco                               (rule 49)
	Stm -> IF . RE BloccoNE ELSE Blocco                 (rule 50)

	OPENR          shift, and enter state 93
	IDENT          shift, and enter state 96
	BOOLEANO       shift, and enter state 45
	INTERO         shift, and enter state 46
	FLOAT          shift, and enter state 47
	STRINGA        shift, and enter state 48
	CHAR           shift, and enter state 49
	AST            shift, and enter state 97
	MINUS          shift, and enter state 101
	NOT            shift, and enter state 102
	DEPUNT         shift, and enter state 103

	Valori         goto state 87
	RE             goto state 108
	LE             goto state 92

State 100

	Stm -> SWITCH . IDENT BloccoSw                      (rule 51)

	IDENT          shift, and enter state 107


State 101

	RE -> MINUS . RE                                    (rule 70)

	OPENR          shift, and enter state 93
	IDENT          shift, and enter state 96
	BOOLEANO       shift, and enter state 45
	INTERO         shift, and enter state 46
	FLOAT          shift, and enter state 47
	STRINGA        shift, and enter state 48
	CHAR           shift, and enter state 49
	AST            shift, and enter state 97
	MINUS          shift, and enter state 101
	NOT            shift, and enter state 102
	DEPUNT         shift, and enter state 103

	Valori         goto state 87
	RE             goto state 106
	LE             goto state 92

State 102

	RE -> NOT . RE                                      (rule 71)

	OPENR          shift, and enter state 93
	IDENT          shift, and enter state 96
	BOOLEANO       shift, and enter state 45
	INTERO         shift, and enter state 46
	FLOAT          shift, and enter state 47
	STRINGA        shift, and enter state 48
	CHAR           shift, and enter state 49
	AST            shift, and enter state 97
	MINUS          shift, and enter state 101
	NOT            shift, and enter state 102
	DEPUNT         shift, and enter state 103

	Valori         goto state 87
	RE             goto state 105
	LE             goto state 92

State 103

	RE -> DEPUNT . IDENT                                (rule 74)

	IDENT          shift, and enter state 104


State 104

	RE -> DEPUNT IDENT .                                (rule 74)

	END            reduce using rule 74
	OPENR          reduce using rule 74
	CLOSER         reduce using rule 74
	CLOSEQ         reduce using rule 74
	OPENG          reduce using rule 74
	CLOSEG         reduce using rule 74
	COMMA          reduce using rule 74
	SEMICOL        reduce using rule 74
	TRY            reduce using rule 74
	RETURN         reduce using rule 74
	IDENT          reduce using rule 74
	BOOLEANO       reduce using rule 74
	INTERO         reduce using rule 74
	FLOAT          reduce using rule 74
	STRINGA        reduce using rule 74
	CHAR           reduce using rule 74
	AST            reduce using rule 74
	FOR            reduce using rule 74
	IF             reduce using rule 74
	SWITCH         reduce using rule 74
	CASE           reduce using rule 74
	DEFAULT        reduce using rule 74
	PLUS           reduce using rule 74
	MINUS          reduce using rule 74
	DIV            reduce using rule 74
	POW            reduce using rule 74
	OPEQ           reduce using rule 74
	OPDISEQ        reduce using rule 74
	AND            reduce using rule 74
	OR             reduce using rule 74
	NOT            reduce using rule 74
	DEPUNT         reduce using rule 74


State 105

	RE -> RE . PLUS RE                                  (rule 60)
	RE -> RE . MINUS RE                                 (rule 61)
	RE -> RE . OPEQ RE                                  (rule 62)
	RE -> RE . OPDISEQ RE                               (rule 63)
	RE -> RE . OR RE                                    (rule 64)
	RE -> RE . AND RE                                   (rule 65)
	RE -> RE . AST RE                                   (rule 66)
	RE -> RE . DIV RE                                   (rule 67)
	RE -> RE . POW RE                                   (rule 68)
	RE -> NOT RE .                                      (rule 71)

	END            reduce using rule 71
	OPENR          reduce using rule 71
	CLOSER         reduce using rule 71
	CLOSEQ         reduce using rule 71
	OPENG          reduce using rule 71
	CLOSEG         reduce using rule 71
	COMMA          reduce using rule 71
	SEMICOL        reduce using rule 71
	TRY            reduce using rule 71
	RETURN         reduce using rule 71
	IDENT          reduce using rule 71
	BOOLEANO       reduce using rule 71
	INTERO         reduce using rule 71
	FLOAT          reduce using rule 71
	STRINGA        reduce using rule 71
	CHAR           reduce using rule 71
	AST            reduce using rule 71
	FOR            reduce using rule 71
	IF             reduce using rule 71
	SWITCH         reduce using rule 71
	CASE           reduce using rule 71
	DEFAULT        reduce using rule 71
	PLUS           reduce using rule 71
	MINUS          reduce using rule 71
	DIV            reduce using rule 71
	POW            reduce using rule 71
	OPEQ           reduce using rule 71
	OPDISEQ        reduce using rule 71
	AND            reduce using rule 71
	OR             reduce using rule 71
	NOT            reduce using rule 71
	DEPUNT         reduce using rule 71


State 106

	RE -> RE . PLUS RE                                  (rule 60)
	RE -> RE . MINUS RE                                 (rule 61)
	RE -> RE . OPEQ RE                                  (rule 62)
	RE -> RE . OPDISEQ RE                               (rule 63)
	RE -> RE . OR RE                                    (rule 64)
	RE -> RE . AND RE                                   (rule 65)
	RE -> RE . AST RE                                   (rule 66)
	RE -> RE . DIV RE                                   (rule 67)
	RE -> RE . POW RE                                   (rule 68)
	RE -> MINUS RE .                                    (rule 70)

	END            reduce using rule 70
	OPENR          reduce using rule 70
	CLOSER         reduce using rule 70
	CLOSEQ         reduce using rule 70
	OPENG          reduce using rule 70
	CLOSEG         reduce using rule 70
	COMMA          reduce using rule 70
	SEMICOL        reduce using rule 70
	TRY            reduce using rule 70
	RETURN         reduce using rule 70
	IDENT          reduce using rule 70
	BOOLEANO       reduce using rule 70
	INTERO         reduce using rule 70
	FLOAT          reduce using rule 70
	STRINGA        reduce using rule 70
	CHAR           reduce using rule 70
	AST            shift, and enter state 121
	FOR            reduce using rule 70
	IF             reduce using rule 70
	SWITCH         reduce using rule 70
	CASE           reduce using rule 70
	DEFAULT        reduce using rule 70
	PLUS           reduce using rule 70
	MINUS          reduce using rule 70
	DIV            shift, and enter state 124
	POW            shift, and enter state 125
	OPEQ           reduce using rule 70
	OPDISEQ        reduce using rule 70
	AND            reduce using rule 70
	OR             reduce using rule 70
	NOT            reduce using rule 70
	DEPUNT         reduce using rule 70


State 107

	Stm -> SWITCH IDENT . BloccoSw                      (rule 51)

	OPENG          shift, and enter state 157

	BloccoSw       goto state 156

State 108

	Stm -> IF RE . Blocco                               (rule 49)
	Stm -> IF RE . BloccoNE ELSE Blocco                 (rule 50)
	RE -> RE . PLUS RE                                  (rule 60)
	RE -> RE . MINUS RE                                 (rule 61)
	RE -> RE . OPEQ RE                                  (rule 62)
	RE -> RE . OPDISEQ RE                               (rule 63)
	RE -> RE . OR RE                                    (rule 64)
	RE -> RE . AND RE                                   (rule 65)
	RE -> RE . AST RE                                   (rule 66)
	RE -> RE . DIV RE                                   (rule 67)
	RE -> RE . POW RE                                   (rule 68)

	OPENG          shift, and enter state 155
	AST            shift, and enter state 121
	PLUS           shift, and enter state 122
	MINUS          shift, and enter state 123
	DIV            shift, and enter state 124
	POW            shift, and enter state 125
	OPEQ           shift, and enter state 126
	OPDISEQ        shift, and enter state 127
	AND            shift, and enter state 128
	OR             shift, and enter state 129

	Blocco         goto state 153
	BloccoNE       goto state 154

State 109

	Stm -> FOR Blocco .                                 (rule 48)

	END            reduce using rule 48
	OPENR          reduce using rule 48
	OPENG          reduce using rule 48
	CLOSEG         reduce using rule 48
	TRY            reduce using rule 48
	RETURN         reduce using rule 48
	IDENT          reduce using rule 48
	BOOLEANO       reduce using rule 48
	INTERO         reduce using rule 48
	FLOAT          reduce using rule 48
	STRINGA        reduce using rule 48
	CHAR           reduce using rule 48
	AST            reduce using rule 48
	FOR            reduce using rule 48
	IF             reduce using rule 48
	SWITCH         reduce using rule 48
	CASE           reduce using rule 48
	DEFAULT        reduce using rule 48
	MINUS          reduce using rule 48
	NOT            reduce using rule 48
	DEPUNT         reduce using rule 48


State 110

	Stm -> FOR RE . SEMICOL RE SEMICOL RE Blocco        (rule 46)
	Stm -> FOR RE . Blocco                              (rule 47)
	RE -> RE . PLUS RE                                  (rule 60)
	RE -> RE . MINUS RE                                 (rule 61)
	RE -> RE . OPEQ RE                                  (rule 62)
	RE -> RE . OPDISEQ RE                               (rule 63)
	RE -> RE . OR RE                                    (rule 64)
	RE -> RE . AND RE                                   (rule 65)
	RE -> RE . AST RE                                   (rule 66)
	RE -> RE . DIV RE                                   (rule 67)
	RE -> RE . POW RE                                   (rule 68)

	OPENG          shift, and enter state 80
	SEMICOL        shift, and enter state 152
	AST            shift, and enter state 121
	PLUS           shift, and enter state 122
	MINUS          shift, and enter state 123
	DIV            shift, and enter state 124
	POW            shift, and enter state 125
	OPEQ           shift, and enter state 126
	OPDISEQ        shift, and enter state 127
	AND            shift, and enter state 128
	OR             shift, and enter state 129

	Blocco         goto state 151

State 111

	LE -> AST IDENT .                                   (rule 82)

	END            reduce using rule 82
	OPENR          reduce using rule 82
	CLOSER         reduce using rule 82
	CLOSEQ         reduce using rule 82
	OPENG          reduce using rule 82
	CLOSEG         reduce using rule 82
	COMMA          reduce using rule 82
	SEMICOL        reduce using rule 82
	TRY            reduce using rule 82
	RETURN         reduce using rule 82
	UGUALE         reduce using rule 82
	IDENT          reduce using rule 82
	BOOLEANO       reduce using rule 82
	INTERO         reduce using rule 82
	FLOAT          reduce using rule 82
	STRINGA        reduce using rule 82
	CHAR           reduce using rule 82
	AST            reduce using rule 82
	FOR            reduce using rule 82
	IF             reduce using rule 82
	SWITCH         reduce using rule 82
	CASE           reduce using rule 82
	DEFAULT        reduce using rule 82
	PLUS           reduce using rule 82
	MINUS          reduce using rule 82
	DIV            reduce using rule 82
	POW            reduce using rule 82
	OPEQ           reduce using rule 82
	OPDISEQ        reduce using rule 82
	AND            reduce using rule 82
	OR             reduce using rule 82
	NOT            reduce using rule 82
	DEPUNT         reduce using rule 82


State 112

	RE -> IDENT OPENR . ListParAtt CLOSER               (rule 73)

	OPENR          shift, and enter state 93
	CLOSER         reduce using rule 77
	IDENT          shift, and enter state 96
	BOOLEANO       shift, and enter state 45
	INTERO         shift, and enter state 46
	FLOAT          shift, and enter state 47
	STRINGA        shift, and enter state 48
	CHAR           shift, and enter state 49
	AST            shift, and enter state 97
	MINUS          shift, and enter state 101
	NOT            shift, and enter state 102
	DEPUNT         shift, and enter state 103

	Valori         goto state 87
	RE             goto state 148
	ListParAtt     goto state 149
	ListParAttNE   goto state 150
	LE             goto state 92

State 113

	LE -> IDENT OPENQ . RE CLOSEQ                       (rule 83)

	OPENR          shift, and enter state 93
	IDENT          shift, and enter state 96
	BOOLEANO       shift, and enter state 45
	INTERO         shift, and enter state 46
	FLOAT          shift, and enter state 47
	STRINGA        shift, and enter state 48
	CHAR           shift, and enter state 49
	AST            shift, and enter state 97
	MINUS          shift, and enter state 101
	NOT            shift, and enter state 102
	DEPUNT         shift, and enter state 103

	Valori         goto state 87
	RE             goto state 147
	LE             goto state 92

State 114

	Stm -> RETURN RE . OptEnd                           (rule 56)
	RE -> RE . PLUS RE                                  (rule 60)
	RE -> RE . MINUS RE                                 (rule 61)
	RE -> RE . OPEQ RE                                  (rule 62)
	RE -> RE . OPDISEQ RE                               (rule 63)
	RE -> RE . OR RE                                    (rule 64)
	RE -> RE . AND RE                                   (rule 65)
	RE -> RE . AST RE                                   (rule 66)
	RE -> RE . DIV RE                                   (rule 67)
	RE -> RE . POW RE                                   (rule 68)

	END            reduce using rule 8
	OPENR          reduce using rule 8
	OPENG          reduce using rule 8
	CLOSEG         reduce using rule 8
	TRY            reduce using rule 8
	RETURN         reduce using rule 8
	IDENT          reduce using rule 8
	BOOLEANO       reduce using rule 8
	INTERO         reduce using rule 8
	FLOAT          reduce using rule 8
	STRINGA        reduce using rule 8
	CHAR           reduce using rule 8
	AST            shift, and enter state 121
			(reduce using rule 8)

	FOR            reduce using rule 8
	IF             reduce using rule 8
	SWITCH         reduce using rule 8
	CASE           reduce using rule 8
	DEFAULT        reduce using rule 8
	PLUS           shift, and enter state 122
	MINUS          shift, and enter state 123
			(reduce using rule 8)

	DIV            shift, and enter state 124
	POW            shift, and enter state 125
	OPEQ           shift, and enter state 126
	OPDISEQ        shift, and enter state 127
	AND            shift, and enter state 128
	OR             shift, and enter state 129
	NOT            reduce using rule 8
	DEPUNT         reduce using rule 8

	OptEnd         goto state 146

State 115

	Stm -> RETURN END .                                 (rule 55)

	END            reduce using rule 55
	OPENR          reduce using rule 55
	OPENG          reduce using rule 55
	CLOSEG         reduce using rule 55
	TRY            reduce using rule 55
	RETURN         reduce using rule 55
	IDENT          reduce using rule 55
	BOOLEANO       reduce using rule 55
	INTERO         reduce using rule 55
	FLOAT          reduce using rule 55
	STRINGA        reduce using rule 55
	CHAR           reduce using rule 55
	AST            reduce using rule 55
	FOR            reduce using rule 55
	IF             reduce using rule 55
	SWITCH         reduce using rule 55
	CASE           reduce using rule 55
	DEFAULT        reduce using rule 55
	MINUS          reduce using rule 55
	NOT            reduce using rule 55
	DEPUNT         reduce using rule 55


State 116

	Stm -> TRY BloccoNE . CATCH Blocco                  (rule 53)

	CATCH          shift, and enter state 145


State 117

	BloccoNE -> OPENG . END GVar Lstm OptEnd CLOSEG     (rule 42)

	END            shift, and enter state 144


State 118

	RE -> RE . PLUS RE                                  (rule 60)
	RE -> RE . MINUS RE                                 (rule 61)
	RE -> RE . OPEQ RE                                  (rule 62)
	RE -> RE . OPDISEQ RE                               (rule 63)
	RE -> RE . OR RE                                    (rule 64)
	RE -> RE . AND RE                                   (rule 65)
	RE -> RE . AST RE                                   (rule 66)
	RE -> RE . DIV RE                                   (rule 67)
	RE -> RE . POW RE                                   (rule 68)
	RE -> OPENR RE . CLOSER                             (rule 69)

	CLOSER         shift, and enter state 143
	AST            shift, and enter state 121
	PLUS           shift, and enter state 122
	MINUS          shift, and enter state 123
	DIV            shift, and enter state 124
	POW            shift, and enter state 125
	OPEQ           shift, and enter state 126
	OPDISEQ        shift, and enter state 127
	AND            shift, and enter state 128
	OR             shift, and enter state 129


State 119

	RE -> LE UGUALE . RE                                (rule 76)

	OPENR          shift, and enter state 93
	IDENT          shift, and enter state 96
	BOOLEANO       shift, and enter state 45
	INTERO         shift, and enter state 46
	FLOAT          shift, and enter state 47
	STRINGA        shift, and enter state 48
	CHAR           shift, and enter state 49
	AST            shift, and enter state 97
	MINUS          shift, and enter state 101
	NOT            shift, and enter state 102
	DEPUNT         shift, and enter state 103

	Valori         goto state 87
	RE             goto state 142
	LE             goto state 92

State 120

	Stm -> RE END .                                     (rule 54)

	END            reduce using rule 54
	OPENR          reduce using rule 54
	OPENG          reduce using rule 54
	CLOSEG         reduce using rule 54
	TRY            reduce using rule 54
	RETURN         reduce using rule 54
	IDENT          reduce using rule 54
	BOOLEANO       reduce using rule 54
	INTERO         reduce using rule 54
	FLOAT          reduce using rule 54
	STRINGA        reduce using rule 54
	CHAR           reduce using rule 54
	AST            reduce using rule 54
	FOR            reduce using rule 54
	IF             reduce using rule 54
	SWITCH         reduce using rule 54
	CASE           reduce using rule 54
	DEFAULT        reduce using rule 54
	MINUS          reduce using rule 54
	NOT            reduce using rule 54
	DEPUNT         reduce using rule 54


State 121

	RE -> RE AST . RE                                   (rule 66)

	OPENR          shift, and enter state 93
	IDENT          shift, and enter state 96
	BOOLEANO       shift, and enter state 45
	INTERO         shift, and enter state 46
	FLOAT          shift, and enter state 47
	STRINGA        shift, and enter state 48
	CHAR           shift, and enter state 49
	AST            shift, and enter state 97
	MINUS          shift, and enter state 101
	NOT            shift, and enter state 102
	DEPUNT         shift, and enter state 103

	Valori         goto state 87
	RE             goto state 141
	LE             goto state 92

State 122

	RE -> RE PLUS . RE                                  (rule 60)

	OPENR          shift, and enter state 93
	IDENT          shift, and enter state 96
	BOOLEANO       shift, and enter state 45
	INTERO         shift, and enter state 46
	FLOAT          shift, and enter state 47
	STRINGA        shift, and enter state 48
	CHAR           shift, and enter state 49
	AST            shift, and enter state 97
	MINUS          shift, and enter state 101
	NOT            shift, and enter state 102
	DEPUNT         shift, and enter state 103

	Valori         goto state 87
	RE             goto state 140
	LE             goto state 92

State 123

	RE -> RE MINUS . RE                                 (rule 61)

	OPENR          shift, and enter state 93
	IDENT          shift, and enter state 96
	BOOLEANO       shift, and enter state 45
	INTERO         shift, and enter state 46
	FLOAT          shift, and enter state 47
	STRINGA        shift, and enter state 48
	CHAR           shift, and enter state 49
	AST            shift, and enter state 97
	MINUS          shift, and enter state 101
	NOT            shift, and enter state 102
	DEPUNT         shift, and enter state 103

	Valori         goto state 87
	RE             goto state 139
	LE             goto state 92

State 124

	RE -> RE DIV . RE                                   (rule 67)

	OPENR          shift, and enter state 93
	IDENT          shift, and enter state 96
	BOOLEANO       shift, and enter state 45
	INTERO         shift, and enter state 46
	FLOAT          shift, and enter state 47
	STRINGA        shift, and enter state 48
	CHAR           shift, and enter state 49
	AST            shift, and enter state 97
	MINUS          shift, and enter state 101
	NOT            shift, and enter state 102
	DEPUNT         shift, and enter state 103

	Valori         goto state 87
	RE             goto state 138
	LE             goto state 92

State 125

	RE -> RE POW . RE                                   (rule 68)

	OPENR          shift, and enter state 93
	IDENT          shift, and enter state 96
	BOOLEANO       shift, and enter state 45
	INTERO         shift, and enter state 46
	FLOAT          shift, and enter state 47
	STRINGA        shift, and enter state 48
	CHAR           shift, and enter state 49
	AST            shift, and enter state 97
	MINUS          shift, and enter state 101
	NOT            shift, and enter state 102
	DEPUNT         shift, and enter state 103

	Valori         goto state 87
	RE             goto state 137
	LE             goto state 92

State 126

	RE -> RE OPEQ . RE                                  (rule 62)

	OPENR          shift, and enter state 93
	IDENT          shift, and enter state 96
	BOOLEANO       shift, and enter state 45
	INTERO         shift, and enter state 46
	FLOAT          shift, and enter state 47
	STRINGA        shift, and enter state 48
	CHAR           shift, and enter state 49
	AST            shift, and enter state 97
	MINUS          shift, and enter state 101
	NOT            shift, and enter state 102
	DEPUNT         shift, and enter state 103

	Valori         goto state 87
	RE             goto state 136
	LE             goto state 92

State 127

	RE -> RE OPDISEQ . RE                               (rule 63)

	OPENR          shift, and enter state 93
	IDENT          shift, and enter state 96
	BOOLEANO       shift, and enter state 45
	INTERO         shift, and enter state 46
	FLOAT          shift, and enter state 47
	STRINGA        shift, and enter state 48
	CHAR           shift, and enter state 49
	AST            shift, and enter state 97
	MINUS          shift, and enter state 101
	NOT            shift, and enter state 102
	DEPUNT         shift, and enter state 103

	Valori         goto state 87
	RE             goto state 135
	LE             goto state 92

State 128

	RE -> RE AND . RE                                   (rule 65)

	OPENR          shift, and enter state 93
	IDENT          shift, and enter state 96
	BOOLEANO       shift, and enter state 45
	INTERO         shift, and enter state 46
	FLOAT          shift, and enter state 47
	STRINGA        shift, and enter state 48
	CHAR           shift, and enter state 49
	AST            shift, and enter state 97
	MINUS          shift, and enter state 101
	NOT            shift, and enter state 102
	DEPUNT         shift, and enter state 103

	Valori         goto state 87
	RE             goto state 134
	LE             goto state 92

State 129

	RE -> RE OR . RE                                    (rule 64)

	OPENR          shift, and enter state 93
	IDENT          shift, and enter state 96
	BOOLEANO       shift, and enter state 45
	INTERO         shift, and enter state 46
	FLOAT          shift, and enter state 47
	STRINGA        shift, and enter state 48
	CHAR           shift, and enter state 49
	AST            shift, and enter state 97
	MINUS          shift, and enter state 101
	NOT            shift, and enter state 102
	DEPUNT         shift, and enter state 103

	Valori         goto state 87
	RE             goto state 133
	LE             goto state 92

State 130

	Lstm -> Stm Lstm .                                  (rule 45)

	END            reduce using rule 45
	CLOSEG         reduce using rule 45
	CASE           reduce using rule 45
	DEFAULT        reduce using rule 45


State 131

	OptEnd -> OptEnd . END                              (rule 9)
	Blocco -> OPENG END GVar Lstm OptEnd . CLOSEG END    (rule 41)

	END            shift, and enter state 85
	CLOSEG         shift, and enter state 132


State 132

	Blocco -> OPENG END GVar Lstm OptEnd CLOSEG . END    (rule 41)

	END            shift, and enter state 167


State 133

	RE -> RE . PLUS RE                                  (rule 60)
	RE -> RE . MINUS RE                                 (rule 61)
	RE -> RE . OPEQ RE                                  (rule 62)
	RE -> RE . OPDISEQ RE                               (rule 63)
	RE -> RE . OR RE                                    (rule 64)
	RE -> RE OR RE .                                    (rule 64)
	RE -> RE . AND RE                                   (rule 65)
	RE -> RE . AST RE                                   (rule 66)
	RE -> RE . DIV RE                                   (rule 67)
	RE -> RE . POW RE                                   (rule 68)

	END            reduce using rule 64
	OPENR          reduce using rule 64
	CLOSER         reduce using rule 64
	CLOSEQ         reduce using rule 64
	OPENG          reduce using rule 64
	CLOSEG         reduce using rule 64
	COMMA          reduce using rule 64
	SEMICOL        reduce using rule 64
	TRY            reduce using rule 64
	RETURN         reduce using rule 64
	IDENT          reduce using rule 64
	BOOLEANO       reduce using rule 64
	INTERO         reduce using rule 64
	FLOAT          reduce using rule 64
	STRINGA        reduce using rule 64
	CHAR           reduce using rule 64
	AST            shift, and enter state 121
	FOR            reduce using rule 64
	IF             reduce using rule 64
	SWITCH         reduce using rule 64
	CASE           reduce using rule 64
	DEFAULT        reduce using rule 64
	PLUS           shift, and enter state 122
	MINUS          shift, and enter state 123
	DIV            shift, and enter state 124
	POW            shift, and enter state 125
	OPEQ           shift, and enter state 126
	OPDISEQ        shift, and enter state 127
	AND            shift, and enter state 128
	OR             reduce using rule 64
	NOT            reduce using rule 64
	DEPUNT         reduce using rule 64


State 134

	RE -> RE . PLUS RE                                  (rule 60)
	RE -> RE . MINUS RE                                 (rule 61)
	RE -> RE . OPEQ RE                                  (rule 62)
	RE -> RE . OPDISEQ RE                               (rule 63)
	RE -> RE . OR RE                                    (rule 64)
	RE -> RE . AND RE                                   (rule 65)
	RE -> RE AND RE .                                   (rule 65)
	RE -> RE . AST RE                                   (rule 66)
	RE -> RE . DIV RE                                   (rule 67)
	RE -> RE . POW RE                                   (rule 68)

	END            reduce using rule 65
	OPENR          reduce using rule 65
	CLOSER         reduce using rule 65
	CLOSEQ         reduce using rule 65
	OPENG          reduce using rule 65
	CLOSEG         reduce using rule 65
	COMMA          reduce using rule 65
	SEMICOL        reduce using rule 65
	TRY            reduce using rule 65
	RETURN         reduce using rule 65
	IDENT          reduce using rule 65
	BOOLEANO       reduce using rule 65
	INTERO         reduce using rule 65
	FLOAT          reduce using rule 65
	STRINGA        reduce using rule 65
	CHAR           reduce using rule 65
	AST            shift, and enter state 121
	FOR            reduce using rule 65
	IF             reduce using rule 65
	SWITCH         reduce using rule 65
	CASE           reduce using rule 65
	DEFAULT        reduce using rule 65
	PLUS           shift, and enter state 122
	MINUS          shift, and enter state 123
	DIV            shift, and enter state 124
	POW            shift, and enter state 125
	OPEQ           shift, and enter state 126
	OPDISEQ        shift, and enter state 127
	AND            reduce using rule 65
	OR             reduce using rule 65
	NOT            reduce using rule 65
	DEPUNT         reduce using rule 65


State 135

	RE -> RE . PLUS RE                                  (rule 60)
	RE -> RE . MINUS RE                                 (rule 61)
	RE -> RE . OPEQ RE                                  (rule 62)
	RE -> RE . OPDISEQ RE                               (rule 63)
	RE -> RE OPDISEQ RE .                               (rule 63)
	RE -> RE . OR RE                                    (rule 64)
	RE -> RE . AND RE                                   (rule 65)
	RE -> RE . AST RE                                   (rule 66)
	RE -> RE . DIV RE                                   (rule 67)
	RE -> RE . POW RE                                   (rule 68)

	END            reduce using rule 63
	OPENR          reduce using rule 63
	CLOSER         reduce using rule 63
	CLOSEQ         reduce using rule 63
	OPENG          reduce using rule 63
	CLOSEG         reduce using rule 63
	COMMA          reduce using rule 63
	SEMICOL        reduce using rule 63
	TRY            reduce using rule 63
	RETURN         reduce using rule 63
	IDENT          reduce using rule 63
	BOOLEANO       reduce using rule 63
	INTERO         reduce using rule 63
	FLOAT          reduce using rule 63
	STRINGA        reduce using rule 63
	CHAR           reduce using rule 63
	AST            shift, and enter state 121
	FOR            reduce using rule 63
	IF             reduce using rule 63
	SWITCH         reduce using rule 63
	CASE           reduce using rule 63
	DEFAULT        reduce using rule 63
	PLUS           shift, and enter state 122
	MINUS          shift, and enter state 123
	DIV            shift, and enter state 124
	POW            shift, and enter state 125
	OPEQ           reduce using rule 63
	OPDISEQ        reduce using rule 63
	AND            reduce using rule 63
	OR             reduce using rule 63
	NOT            reduce using rule 63
	DEPUNT         reduce using rule 63


State 136

	RE -> RE . PLUS RE                                  (rule 60)
	RE -> RE . MINUS RE                                 (rule 61)
	RE -> RE . OPEQ RE                                  (rule 62)
	RE -> RE OPEQ RE .                                  (rule 62)
	RE -> RE . OPDISEQ RE                               (rule 63)
	RE -> RE . OR RE                                    (rule 64)
	RE -> RE . AND RE                                   (rule 65)
	RE -> RE . AST RE                                   (rule 66)
	RE -> RE . DIV RE                                   (rule 67)
	RE -> RE . POW RE                                   (rule 68)

	END            reduce using rule 62
	OPENR          reduce using rule 62
	CLOSER         reduce using rule 62
	CLOSEQ         reduce using rule 62
	OPENG          reduce using rule 62
	CLOSEG         reduce using rule 62
	COMMA          reduce using rule 62
	SEMICOL        reduce using rule 62
	TRY            reduce using rule 62
	RETURN         reduce using rule 62
	IDENT          reduce using rule 62
	BOOLEANO       reduce using rule 62
	INTERO         reduce using rule 62
	FLOAT          reduce using rule 62
	STRINGA        reduce using rule 62
	CHAR           reduce using rule 62
	AST            shift, and enter state 121
	FOR            reduce using rule 62
	IF             reduce using rule 62
	SWITCH         reduce using rule 62
	CASE           reduce using rule 62
	DEFAULT        reduce using rule 62
	PLUS           shift, and enter state 122
	MINUS          shift, and enter state 123
	DIV            shift, and enter state 124
	POW            shift, and enter state 125
	OPEQ           reduce using rule 62
	OPDISEQ        shift, and enter state 127
	AND            reduce using rule 62
	OR             reduce using rule 62
	NOT            reduce using rule 62
	DEPUNT         reduce using rule 62


State 137

	RE -> RE . PLUS RE                                  (rule 60)
	RE -> RE . MINUS RE                                 (rule 61)
	RE -> RE . OPEQ RE                                  (rule 62)
	RE -> RE . OPDISEQ RE                               (rule 63)
	RE -> RE . OR RE                                    (rule 64)
	RE -> RE . AND RE                                   (rule 65)
	RE -> RE . AST RE                                   (rule 66)
	RE -> RE . DIV RE                                   (rule 67)
	RE -> RE . POW RE                                   (rule 68)
	RE -> RE POW RE .                                   (rule 68)

	END            reduce using rule 68
	OPENR          reduce using rule 68
	CLOSER         reduce using rule 68
	CLOSEQ         reduce using rule 68
	OPENG          reduce using rule 68
	CLOSEG         reduce using rule 68
	COMMA          reduce using rule 68
	SEMICOL        reduce using rule 68
	TRY            reduce using rule 68
	RETURN         reduce using rule 68
	IDENT          reduce using rule 68
	BOOLEANO       reduce using rule 68
	INTERO         reduce using rule 68
	FLOAT          reduce using rule 68
	STRINGA        reduce using rule 68
	CHAR           reduce using rule 68
	AST            reduce using rule 68
	FOR            reduce using rule 68
	IF             reduce using rule 68
	SWITCH         reduce using rule 68
	CASE           reduce using rule 68
	DEFAULT        reduce using rule 68
	PLUS           reduce using rule 68
	MINUS          reduce using rule 68
	DIV            reduce using rule 68
	POW            reduce using rule 68
	OPEQ           reduce using rule 68
	OPDISEQ        reduce using rule 68
	AND            reduce using rule 68
	OR             reduce using rule 68
	NOT            reduce using rule 68
	DEPUNT         reduce using rule 68


State 138

	RE -> RE . PLUS RE                                  (rule 60)
	RE -> RE . MINUS RE                                 (rule 61)
	RE -> RE . OPEQ RE                                  (rule 62)
	RE -> RE . OPDISEQ RE                               (rule 63)
	RE -> RE . OR RE                                    (rule 64)
	RE -> RE . AND RE                                   (rule 65)
	RE -> RE . AST RE                                   (rule 66)
	RE -> RE . DIV RE                                   (rule 67)
	RE -> RE DIV RE .                                   (rule 67)
	RE -> RE . POW RE                                   (rule 68)

	END            reduce using rule 67
	OPENR          reduce using rule 67
	CLOSER         reduce using rule 67
	CLOSEQ         reduce using rule 67
	OPENG          reduce using rule 67
	CLOSEG         reduce using rule 67
	COMMA          reduce using rule 67
	SEMICOL        reduce using rule 67
	TRY            reduce using rule 67
	RETURN         reduce using rule 67
	IDENT          reduce using rule 67
	BOOLEANO       reduce using rule 67
	INTERO         reduce using rule 67
	FLOAT          reduce using rule 67
	STRINGA        reduce using rule 67
	CHAR           reduce using rule 67
	AST            reduce using rule 67
	FOR            reduce using rule 67
	IF             reduce using rule 67
	SWITCH         reduce using rule 67
	CASE           reduce using rule 67
	DEFAULT        reduce using rule 67
	PLUS           reduce using rule 67
	MINUS          reduce using rule 67
	DIV            reduce using rule 67
	POW            shift, and enter state 125
	OPEQ           reduce using rule 67
	OPDISEQ        reduce using rule 67
	AND            reduce using rule 67
	OR             reduce using rule 67
	NOT            reduce using rule 67
	DEPUNT         reduce using rule 67


State 139

	RE -> RE . PLUS RE                                  (rule 60)
	RE -> RE . MINUS RE                                 (rule 61)
	RE -> RE MINUS RE .                                 (rule 61)
	RE -> RE . OPEQ RE                                  (rule 62)
	RE -> RE . OPDISEQ RE                               (rule 63)
	RE -> RE . OR RE                                    (rule 64)
	RE -> RE . AND RE                                   (rule 65)
	RE -> RE . AST RE                                   (rule 66)
	RE -> RE . DIV RE                                   (rule 67)
	RE -> RE . POW RE                                   (rule 68)

	END            reduce using rule 61
	OPENR          reduce using rule 61
	CLOSER         reduce using rule 61
	CLOSEQ         reduce using rule 61
	OPENG          reduce using rule 61
	CLOSEG         reduce using rule 61
	COMMA          reduce using rule 61
	SEMICOL        reduce using rule 61
	TRY            reduce using rule 61
	RETURN         reduce using rule 61
	IDENT          reduce using rule 61
	BOOLEANO       reduce using rule 61
	INTERO         reduce using rule 61
	FLOAT          reduce using rule 61
	STRINGA        reduce using rule 61
	CHAR           reduce using rule 61
	AST            shift, and enter state 121
	FOR            reduce using rule 61
	IF             reduce using rule 61
	SWITCH         reduce using rule 61
	CASE           reduce using rule 61
	DEFAULT        reduce using rule 61
	PLUS           reduce using rule 61
	MINUS          reduce using rule 61
	DIV            shift, and enter state 124
	POW            shift, and enter state 125
	OPEQ           reduce using rule 61
	OPDISEQ        reduce using rule 61
	AND            reduce using rule 61
	OR             reduce using rule 61
	NOT            reduce using rule 61
	DEPUNT         reduce using rule 61


State 140

	RE -> RE . PLUS RE                                  (rule 60)
	RE -> RE PLUS RE .                                  (rule 60)
	RE -> RE . MINUS RE                                 (rule 61)
	RE -> RE . OPEQ RE                                  (rule 62)
	RE -> RE . OPDISEQ RE                               (rule 63)
	RE -> RE . OR RE                                    (rule 64)
	RE -> RE . AND RE                                   (rule 65)
	RE -> RE . AST RE                                   (rule 66)
	RE -> RE . DIV RE                                   (rule 67)
	RE -> RE . POW RE                                   (rule 68)

	END            reduce using rule 60
	OPENR          reduce using rule 60
	CLOSER         reduce using rule 60
	CLOSEQ         reduce using rule 60
	OPENG          reduce using rule 60
	CLOSEG         reduce using rule 60
	COMMA          reduce using rule 60
	SEMICOL        reduce using rule 60
	TRY            reduce using rule 60
	RETURN         reduce using rule 60
	IDENT          reduce using rule 60
	BOOLEANO       reduce using rule 60
	INTERO         reduce using rule 60
	FLOAT          reduce using rule 60
	STRINGA        reduce using rule 60
	CHAR           reduce using rule 60
	AST            shift, and enter state 121
	FOR            reduce using rule 60
	IF             reduce using rule 60
	SWITCH         reduce using rule 60
	CASE           reduce using rule 60
	DEFAULT        reduce using rule 60
	PLUS           reduce using rule 60
	MINUS          shift, and enter state 123
	DIV            shift, and enter state 124
	POW            shift, and enter state 125
	OPEQ           reduce using rule 60
	OPDISEQ        reduce using rule 60
	AND            reduce using rule 60
	OR             reduce using rule 60
	NOT            reduce using rule 60
	DEPUNT         reduce using rule 60


State 141

	RE -> RE . PLUS RE                                  (rule 60)
	RE -> RE . MINUS RE                                 (rule 61)
	RE -> RE . OPEQ RE                                  (rule 62)
	RE -> RE . OPDISEQ RE                               (rule 63)
	RE -> RE . OR RE                                    (rule 64)
	RE -> RE . AND RE                                   (rule 65)
	RE -> RE . AST RE                                   (rule 66)
	RE -> RE AST RE .                                   (rule 66)
	RE -> RE . DIV RE                                   (rule 67)
	RE -> RE . POW RE                                   (rule 68)

	END            reduce using rule 66
	OPENR          reduce using rule 66
	CLOSER         reduce using rule 66
	CLOSEQ         reduce using rule 66
	OPENG          reduce using rule 66
	CLOSEG         reduce using rule 66
	COMMA          reduce using rule 66
	SEMICOL        reduce using rule 66
	TRY            reduce using rule 66
	RETURN         reduce using rule 66
	IDENT          reduce using rule 66
	BOOLEANO       reduce using rule 66
	INTERO         reduce using rule 66
	FLOAT          reduce using rule 66
	STRINGA        reduce using rule 66
	CHAR           reduce using rule 66
	AST            reduce using rule 66
	FOR            reduce using rule 66
	IF             reduce using rule 66
	SWITCH         reduce using rule 66
	CASE           reduce using rule 66
	DEFAULT        reduce using rule 66
	PLUS           reduce using rule 66
	MINUS          reduce using rule 66
	DIV            shift, and enter state 124
	POW            shift, and enter state 125
	OPEQ           reduce using rule 66
	OPDISEQ        reduce using rule 66
	AND            reduce using rule 66
	OR             reduce using rule 66
	NOT            reduce using rule 66
	DEPUNT         reduce using rule 66


State 142

	RE -> RE . PLUS RE                                  (rule 60)
	RE -> RE . MINUS RE                                 (rule 61)
	RE -> RE . OPEQ RE                                  (rule 62)
	RE -> RE . OPDISEQ RE                               (rule 63)
	RE -> RE . OR RE                                    (rule 64)
	RE -> RE . AND RE                                   (rule 65)
	RE -> RE . AST RE                                   (rule 66)
	RE -> RE . DIV RE                                   (rule 67)
	RE -> RE . POW RE                                   (rule 68)
	RE -> LE UGUALE RE .                                (rule 76)

	END            reduce using rule 76
	OPENR          reduce using rule 76
	CLOSER         reduce using rule 76
	CLOSEQ         reduce using rule 76
	OPENG          reduce using rule 76
	CLOSEG         reduce using rule 76
	COMMA          reduce using rule 76
	SEMICOL        reduce using rule 76
	TRY            reduce using rule 76
	RETURN         reduce using rule 76
	IDENT          reduce using rule 76
	BOOLEANO       reduce using rule 76
	INTERO         reduce using rule 76
	FLOAT          reduce using rule 76
	STRINGA        reduce using rule 76
	CHAR           reduce using rule 76
	AST            shift, and enter state 121
	FOR            reduce using rule 76
	IF             reduce using rule 76
	SWITCH         reduce using rule 76
	CASE           reduce using rule 76
	DEFAULT        reduce using rule 76
	PLUS           shift, and enter state 122
	MINUS          shift, and enter state 123
	DIV            shift, and enter state 124
	POW            shift, and enter state 125
	OPEQ           shift, and enter state 126
	OPDISEQ        shift, and enter state 127
	AND            shift, and enter state 128
	OR             shift, and enter state 129
	NOT            reduce using rule 76
	DEPUNT         reduce using rule 76


State 143

	RE -> OPENR RE CLOSER .                             (rule 69)

	END            reduce using rule 69
	OPENR          reduce using rule 69
	CLOSER         reduce using rule 69
	CLOSEQ         reduce using rule 69
	OPENG          reduce using rule 69
	CLOSEG         reduce using rule 69
	COMMA          reduce using rule 69
	SEMICOL        reduce using rule 69
	TRY            reduce using rule 69
	RETURN         reduce using rule 69
	IDENT          reduce using rule 69
	BOOLEANO       reduce using rule 69
	INTERO         reduce using rule 69
	FLOAT          reduce using rule 69
	STRINGA        reduce using rule 69
	CHAR           reduce using rule 69
	AST            reduce using rule 69
	FOR            reduce using rule 69
	IF             reduce using rule 69
	SWITCH         reduce using rule 69
	CASE           reduce using rule 69
	DEFAULT        reduce using rule 69
	PLUS           reduce using rule 69
	MINUS          reduce using rule 69
	DIV            reduce using rule 69
	POW            reduce using rule 69
	OPEQ           reduce using rule 69
	OPDISEQ        reduce using rule 69
	AND            reduce using rule 69
	OR             reduce using rule 69
	NOT            reduce using rule 69
	DEPUNT         reduce using rule 69


State 144

	BloccoNE -> OPENG END . GVar Lstm OptEnd CLOSEG     (rule 42)

	VAR            shift, and enter state 11
	END            reduce using rule 10
	OPENR          reduce using rule 10
	OPENG          reduce using rule 10
	CLOSEG         reduce using rule 10
	TRY            reduce using rule 10
	RETURN         reduce using rule 10
	IDENT          reduce using rule 10
	BOOLEANO       reduce using rule 10
	INTERO         reduce using rule 10
	FLOAT          reduce using rule 10
	STRINGA        reduce using rule 10
	CHAR           reduce using rule 10
	AST            reduce using rule 10
	FOR            reduce using rule 10
	IF             reduce using rule 10
	SWITCH         reduce using rule 10
	MINUS          reduce using rule 10
	NOT            reduce using rule 10
	DEPUNT         reduce using rule 10

	GVar           goto state 166

State 145

	Stm -> TRY BloccoNE CATCH . Blocco                  (rule 53)

	OPENG          shift, and enter state 80

	Blocco         goto state 165

State 146

	OptEnd -> OptEnd . END                              (rule 9)
	Stm -> RETURN RE OptEnd .                           (rule 56)

	END            shift, and enter state 85
			(reduce using rule 56)

	OPENR          reduce using rule 56
	OPENG          reduce using rule 56
	CLOSEG         reduce using rule 56
	TRY            reduce using rule 56
	RETURN         reduce using rule 56
	IDENT          reduce using rule 56
	BOOLEANO       reduce using rule 56
	INTERO         reduce using rule 56
	FLOAT          reduce using rule 56
	STRINGA        reduce using rule 56
	CHAR           reduce using rule 56
	AST            reduce using rule 56
	FOR            reduce using rule 56
	IF             reduce using rule 56
	SWITCH         reduce using rule 56
	CASE           reduce using rule 56
	DEFAULT        reduce using rule 56
	MINUS          reduce using rule 56
	NOT            reduce using rule 56
	DEPUNT         reduce using rule 56


State 147

	RE -> RE . PLUS RE                                  (rule 60)
	RE -> RE . MINUS RE                                 (rule 61)
	RE -> RE . OPEQ RE                                  (rule 62)
	RE -> RE . OPDISEQ RE                               (rule 63)
	RE -> RE . OR RE                                    (rule 64)
	RE -> RE . AND RE                                   (rule 65)
	RE -> RE . AST RE                                   (rule 66)
	RE -> RE . DIV RE                                   (rule 67)
	RE -> RE . POW RE                                   (rule 68)
	LE -> IDENT OPENQ RE . CLOSEQ                       (rule 83)

	CLOSEQ         shift, and enter state 164
	AST            shift, and enter state 121
	PLUS           shift, and enter state 122
	MINUS          shift, and enter state 123
	DIV            shift, and enter state 124
	POW            shift, and enter state 125
	OPEQ           shift, and enter state 126
	OPDISEQ        shift, and enter state 127
	AND            shift, and enter state 128
	OR             shift, and enter state 129


State 148

	RE -> RE . PLUS RE                                  (rule 60)
	RE -> RE . MINUS RE                                 (rule 61)
	RE -> RE . OPEQ RE                                  (rule 62)
	RE -> RE . OPDISEQ RE                               (rule 63)
	RE -> RE . OR RE                                    (rule 64)
	RE -> RE . AND RE                                   (rule 65)
	RE -> RE . AST RE                                   (rule 66)
	RE -> RE . DIV RE                                   (rule 67)
	RE -> RE . POW RE                                   (rule 68)
	ListParAttNE -> RE .                                (rule 79)

	CLOSER         reduce using rule 79
	COMMA          reduce using rule 79
	AST            shift, and enter state 121
	PLUS           shift, and enter state 122
	MINUS          shift, and enter state 123
	DIV            shift, and enter state 124
	POW            shift, and enter state 125
	OPEQ           shift, and enter state 126
	OPDISEQ        shift, and enter state 127
	AND            shift, and enter state 128
	OR             shift, and enter state 129


State 149

	RE -> IDENT OPENR ListParAtt . CLOSER               (rule 73)

	CLOSER         shift, and enter state 163


State 150

	ListParAtt -> ListParAttNE .                        (rule 78)
	ListParAttNE -> ListParAttNE . COMMA RE             (rule 80)

	CLOSER         reduce using rule 78
	COMMA          shift, and enter state 162


State 151

	Stm -> FOR RE Blocco .                              (rule 47)

	END            reduce using rule 47
	OPENR          reduce using rule 47
	OPENG          reduce using rule 47
	CLOSEG         reduce using rule 47
	TRY            reduce using rule 47
	RETURN         reduce using rule 47
	IDENT          reduce using rule 47
	BOOLEANO       reduce using rule 47
	INTERO         reduce using rule 47
	FLOAT          reduce using rule 47
	STRINGA        reduce using rule 47
	CHAR           reduce using rule 47
	AST            reduce using rule 47
	FOR            reduce using rule 47
	IF             reduce using rule 47
	SWITCH         reduce using rule 47
	CASE           reduce using rule 47
	DEFAULT        reduce using rule 47
	MINUS          reduce using rule 47
	NOT            reduce using rule 47
	DEPUNT         reduce using rule 47


State 152

	Stm -> FOR RE SEMICOL . RE SEMICOL RE Blocco        (rule 46)

	OPENR          shift, and enter state 93
	IDENT          shift, and enter state 96
	BOOLEANO       shift, and enter state 45
	INTERO         shift, and enter state 46
	FLOAT          shift, and enter state 47
	STRINGA        shift, and enter state 48
	CHAR           shift, and enter state 49
	AST            shift, and enter state 97
	MINUS          shift, and enter state 101
	NOT            shift, and enter state 102
	DEPUNT         shift, and enter state 103

	Valori         goto state 87
	RE             goto state 161
	LE             goto state 92

State 153

	Stm -> IF RE Blocco .                               (rule 49)

	END            reduce using rule 49
	OPENR          reduce using rule 49
	OPENG          reduce using rule 49
	CLOSEG         reduce using rule 49
	TRY            reduce using rule 49
	RETURN         reduce using rule 49
	IDENT          reduce using rule 49
	BOOLEANO       reduce using rule 49
	INTERO         reduce using rule 49
	FLOAT          reduce using rule 49
	STRINGA        reduce using rule 49
	CHAR           reduce using rule 49
	AST            reduce using rule 49
	FOR            reduce using rule 49
	IF             reduce using rule 49
	SWITCH         reduce using rule 49
	CASE           reduce using rule 49
	DEFAULT        reduce using rule 49
	MINUS          reduce using rule 49
	NOT            reduce using rule 49
	DEPUNT         reduce using rule 49


State 154

	Stm -> IF RE BloccoNE . ELSE Blocco                 (rule 50)

	ELSE           shift, and enter state 160


State 155

	Blocco -> OPENG . END GVar Lstm OptEnd CLOSEG END    (rule 41)
	BloccoNE -> OPENG . END GVar Lstm OptEnd CLOSEG     (rule 42)

	END            shift, and enter state 159


State 156

	Stm -> SWITCH IDENT BloccoSw .                      (rule 51)

	END            reduce using rule 51
	OPENR          reduce using rule 51
	OPENG          reduce using rule 51
	CLOSEG         reduce using rule 51
	TRY            reduce using rule 51
	RETURN         reduce using rule 51
	IDENT          reduce using rule 51
	BOOLEANO       reduce using rule 51
	INTERO         reduce using rule 51
	FLOAT          reduce using rule 51
	STRINGA        reduce using rule 51
	CHAR           reduce using rule 51
	AST            reduce using rule 51
	FOR            reduce using rule 51
	IF             reduce using rule 51
	SWITCH         reduce using rule 51
	CASE           reduce using rule 51
	DEFAULT        reduce using rule 51
	MINUS          reduce using rule 51
	NOT            reduce using rule 51
	DEPUNT         reduce using rule 51


State 157

	BloccoSw -> OPENG . END Lcase CLOSEG END            (rule 43)

	END            shift, and enter state 158


State 158

	BloccoSw -> OPENG END . Lcase CLOSEG END            (rule 43)

	CLOSEG         reduce using rule 57
	CASE           shift, and enter state 174
	DEFAULT        shift, and enter state 175

	Lcase          goto state 173

State 159

	Blocco -> OPENG END . GVar Lstm OptEnd CLOSEG END    (rule 41)
	BloccoNE -> OPENG END . GVar Lstm OptEnd CLOSEG     (rule 42)

	VAR            shift, and enter state 11
	END            reduce using rule 10
	OPENR          reduce using rule 10
	OPENG          reduce using rule 10
	CLOSEG         reduce using rule 10
	TRY            reduce using rule 10
	RETURN         reduce using rule 10
	IDENT          reduce using rule 10
	BOOLEANO       reduce using rule 10
	INTERO         reduce using rule 10
	FLOAT          reduce using rule 10
	STRINGA        reduce using rule 10
	CHAR           reduce using rule 10
	AST            reduce using rule 10
	FOR            reduce using rule 10
	IF             reduce using rule 10
	SWITCH         reduce using rule 10
	MINUS          reduce using rule 10
	NOT            reduce using rule 10
	DEPUNT         reduce using rule 10

	GVar           goto state 172

State 160

	Stm -> IF RE BloccoNE ELSE . Blocco                 (rule 50)

	OPENG          shift, and enter state 80

	Blocco         goto state 171

State 161

	Stm -> FOR RE SEMICOL RE . SEMICOL RE Blocco        (rule 46)
	RE -> RE . PLUS RE                                  (rule 60)
	RE -> RE . MINUS RE                                 (rule 61)
	RE -> RE . OPEQ RE                                  (rule 62)
	RE -> RE . OPDISEQ RE                               (rule 63)
	RE -> RE . OR RE                                    (rule 64)
	RE -> RE . AND RE                                   (rule 65)
	RE -> RE . AST RE                                   (rule 66)
	RE -> RE . DIV RE                                   (rule 67)
	RE -> RE . POW RE                                   (rule 68)

	SEMICOL        shift, and enter state 170
	AST            shift, and enter state 121
	PLUS           shift, and enter state 122
	MINUS          shift, and enter state 123
	DIV            shift, and enter state 124
	POW            shift, and enter state 125
	OPEQ           shift, and enter state 126
	OPDISEQ        shift, and enter state 127
	AND            shift, and enter state 128
	OR             shift, and enter state 129


State 162

	ListParAttNE -> ListParAttNE COMMA . RE             (rule 80)

	OPENR          shift, and enter state 93
	IDENT          shift, and enter state 96
	BOOLEANO       shift, and enter state 45
	INTERO         shift, and enter state 46
	FLOAT          shift, and enter state 47
	STRINGA        shift, and enter state 48
	CHAR           shift, and enter state 49
	AST            shift, and enter state 97
	MINUS          shift, and enter state 101
	NOT            shift, and enter state 102
	DEPUNT         shift, and enter state 103

	Valori         goto state 87
	RE             goto state 169
	LE             goto state 92

State 163

	RE -> IDENT OPENR ListParAtt CLOSER .               (rule 73)

	END            reduce using rule 73
	OPENR          reduce using rule 73
	CLOSER         reduce using rule 73
	CLOSEQ         reduce using rule 73
	OPENG          reduce using rule 73
	CLOSEG         reduce using rule 73
	COMMA          reduce using rule 73
	SEMICOL        reduce using rule 73
	TRY            reduce using rule 73
	RETURN         reduce using rule 73
	IDENT          reduce using rule 73
	BOOLEANO       reduce using rule 73
	INTERO         reduce using rule 73
	FLOAT          reduce using rule 73
	STRINGA        reduce using rule 73
	CHAR           reduce using rule 73
	AST            reduce using rule 73
	FOR            reduce using rule 73
	IF             reduce using rule 73
	SWITCH         reduce using rule 73
	CASE           reduce using rule 73
	DEFAULT        reduce using rule 73
	PLUS           reduce using rule 73
	MINUS          reduce using rule 73
	DIV            reduce using rule 73
	POW            reduce using rule 73
	OPEQ           reduce using rule 73
	OPDISEQ        reduce using rule 73
	AND            reduce using rule 73
	OR             reduce using rule 73
	NOT            reduce using rule 73
	DEPUNT         reduce using rule 73


State 164

	LE -> IDENT OPENQ RE CLOSEQ .                       (rule 83)

	END            reduce using rule 83
	OPENR          reduce using rule 83
	CLOSER         reduce using rule 83
	CLOSEQ         reduce using rule 83
	OPENG          reduce using rule 83
	CLOSEG         reduce using rule 83
	COMMA          reduce using rule 83
	SEMICOL        reduce using rule 83
	TRY            reduce using rule 83
	RETURN         reduce using rule 83
	UGUALE         reduce using rule 83
	IDENT          reduce using rule 83
	BOOLEANO       reduce using rule 83
	INTERO         reduce using rule 83
	FLOAT          reduce using rule 83
	STRINGA        reduce using rule 83
	CHAR           reduce using rule 83
	AST            reduce using rule 83
	FOR            reduce using rule 83
	IF             reduce using rule 83
	SWITCH         reduce using rule 83
	CASE           reduce using rule 83
	DEFAULT        reduce using rule 83
	PLUS           reduce using rule 83
	MINUS          reduce using rule 83
	DIV            reduce using rule 83
	POW            reduce using rule 83
	OPEQ           reduce using rule 83
	OPDISEQ        reduce using rule 83
	AND            reduce using rule 83
	OR             reduce using rule 83
	NOT            reduce using rule 83
	DEPUNT         reduce using rule 83


State 165

	Stm -> TRY BloccoNE CATCH Blocco .                  (rule 53)

	END            reduce using rule 53
	OPENR          reduce using rule 53
	OPENG          reduce using rule 53
	CLOSEG         reduce using rule 53
	TRY            reduce using rule 53
	RETURN         reduce using rule 53
	IDENT          reduce using rule 53
	BOOLEANO       reduce using rule 53
	INTERO         reduce using rule 53
	FLOAT          reduce using rule 53
	STRINGA        reduce using rule 53
	CHAR           reduce using rule 53
	AST            reduce using rule 53
	FOR            reduce using rule 53
	IF             reduce using rule 53
	SWITCH         reduce using rule 53
	CASE           reduce using rule 53
	DEFAULT        reduce using rule 53
	MINUS          reduce using rule 53
	NOT            reduce using rule 53
	DEPUNT         reduce using rule 53


State 166

	BloccoNE -> OPENG END GVar . Lstm OptEnd CLOSEG     (rule 42)

	END            reduce using rule 44
	OPENR          shift, and enter state 93
	OPENG          shift, and enter state 80
	CLOSEG         reduce using rule 44
	TRY            shift, and enter state 94
	RETURN         shift, and enter state 95
	IDENT          shift, and enter state 96
	BOOLEANO       shift, and enter state 45
	INTERO         shift, and enter state 46
	FLOAT          shift, and enter state 47
	STRINGA        shift, and enter state 48
	CHAR           shift, and enter state 49
	AST            shift, and enter state 97
	FOR            shift, and enter state 98
	IF             shift, and enter state 99
	SWITCH         shift, and enter state 100
	MINUS          shift, and enter state 101
	NOT            shift, and enter state 102
	DEPUNT         shift, and enter state 103

	Valori         goto state 87
	Blocco         goto state 88
	Lstm           goto state 168
	Stm            goto state 90
	RE             goto state 91
	LE             goto state 92

State 167

	Blocco -> OPENG END GVar Lstm OptEnd CLOSEG END .    (rule 41)

	FUNC           reduce using rule 41
	END            reduce using rule 41
	OPENR          reduce using rule 41
	OPENG          reduce using rule 41
	CLOSEG         reduce using rule 41
	TRY            reduce using rule 41
	RETURN         reduce using rule 41
	IDENT          reduce using rule 41
	BOOLEANO       reduce using rule 41
	INTERO         reduce using rule 41
	FLOAT          reduce using rule 41
	STRINGA        reduce using rule 41
	CHAR           reduce using rule 41
	AST            reduce using rule 41
	FOR            reduce using rule 41
	IF             reduce using rule 41
	SWITCH         reduce using rule 41
	CASE           reduce using rule 41
	DEFAULT        reduce using rule 41
	MINUS          reduce using rule 41
	NOT            reduce using rule 41
	DEPUNT         reduce using rule 41
	%eof           reduce using rule 41


State 168

	BloccoNE -> OPENG END GVar Lstm . OptEnd CLOSEG     (rule 42)

	END            reduce using rule 8
	CLOSEG         reduce using rule 8

	OptEnd         goto state 181

State 169

	RE -> RE . PLUS RE                                  (rule 60)
	RE -> RE . MINUS RE                                 (rule 61)
	RE -> RE . OPEQ RE                                  (rule 62)
	RE -> RE . OPDISEQ RE                               (rule 63)
	RE -> RE . OR RE                                    (rule 64)
	RE -> RE . AND RE                                   (rule 65)
	RE -> RE . AST RE                                   (rule 66)
	RE -> RE . DIV RE                                   (rule 67)
	RE -> RE . POW RE                                   (rule 68)
	ListParAttNE -> ListParAttNE COMMA RE .             (rule 80)

	CLOSER         reduce using rule 80
	COMMA          reduce using rule 80
	AST            shift, and enter state 121
	PLUS           shift, and enter state 122
	MINUS          shift, and enter state 123
	DIV            shift, and enter state 124
	POW            shift, and enter state 125
	OPEQ           shift, and enter state 126
	OPDISEQ        shift, and enter state 127
	AND            shift, and enter state 128
	OR             shift, and enter state 129


State 170

	Stm -> FOR RE SEMICOL RE SEMICOL . RE Blocco        (rule 46)

	OPENR          shift, and enter state 93
	IDENT          shift, and enter state 96
	BOOLEANO       shift, and enter state 45
	INTERO         shift, and enter state 46
	FLOAT          shift, and enter state 47
	STRINGA        shift, and enter state 48
	CHAR           shift, and enter state 49
	AST            shift, and enter state 97
	MINUS          shift, and enter state 101
	NOT            shift, and enter state 102
	DEPUNT         shift, and enter state 103

	Valori         goto state 87
	RE             goto state 180
	LE             goto state 92

State 171

	Stm -> IF RE BloccoNE ELSE Blocco .                 (rule 50)

	END            reduce using rule 50
	OPENR          reduce using rule 50
	OPENG          reduce using rule 50
	CLOSEG         reduce using rule 50
	TRY            reduce using rule 50
	RETURN         reduce using rule 50
	IDENT          reduce using rule 50
	BOOLEANO       reduce using rule 50
	INTERO         reduce using rule 50
	FLOAT          reduce using rule 50
	STRINGA        reduce using rule 50
	CHAR           reduce using rule 50
	AST            reduce using rule 50
	FOR            reduce using rule 50
	IF             reduce using rule 50
	SWITCH         reduce using rule 50
	CASE           reduce using rule 50
	DEFAULT        reduce using rule 50
	MINUS          reduce using rule 50
	NOT            reduce using rule 50
	DEPUNT         reduce using rule 50


State 172

	Blocco -> OPENG END GVar . Lstm OptEnd CLOSEG END    (rule 41)
	BloccoNE -> OPENG END GVar . Lstm OptEnd CLOSEG     (rule 42)

	END            reduce using rule 44
	OPENR          shift, and enter state 93
	OPENG          shift, and enter state 80
	CLOSEG         reduce using rule 44
	TRY            shift, and enter state 94
	RETURN         shift, and enter state 95
	IDENT          shift, and enter state 96
	BOOLEANO       shift, and enter state 45
	INTERO         shift, and enter state 46
	FLOAT          shift, and enter state 47
	STRINGA        shift, and enter state 48
	CHAR           shift, and enter state 49
	AST            shift, and enter state 97
	FOR            shift, and enter state 98
	IF             shift, and enter state 99
	SWITCH         shift, and enter state 100
	MINUS          shift, and enter state 101
	NOT            shift, and enter state 102
	DEPUNT         shift, and enter state 103

	Valori         goto state 87
	Blocco         goto state 88
	Lstm           goto state 179
	Stm            goto state 90
	RE             goto state 91
	LE             goto state 92

State 173

	BloccoSw -> OPENG END Lcase . CLOSEG END            (rule 43)

	CLOSEG         shift, and enter state 178


State 174

	Lcase -> CASE . Valori COL Lstm OptEnd Lcase        (rule 58)

	BOOLEANO       shift, and enter state 45
	INTERO         shift, and enter state 46
	FLOAT          shift, and enter state 47
	STRINGA        shift, and enter state 48
	CHAR           shift, and enter state 49

	Valori         goto state 177

State 175

	Lcase -> DEFAULT . COL Lstm OptEnd                  (rule 59)

	COL            shift, and enter state 176


State 176

	Lcase -> DEFAULT COL . Lstm OptEnd                  (rule 59)

	END            reduce using rule 44
	OPENR          shift, and enter state 93
	OPENG          shift, and enter state 80
	CLOSEG         reduce using rule 44
	TRY            shift, and enter state 94
	RETURN         shift, and enter state 95
	IDENT          shift, and enter state 96
	BOOLEANO       shift, and enter state 45
	INTERO         shift, and enter state 46
	FLOAT          shift, and enter state 47
	STRINGA        shift, and enter state 48
	CHAR           shift, and enter state 49
	AST            shift, and enter state 97
	FOR            shift, and enter state 98
	IF             shift, and enter state 99
	SWITCH         shift, and enter state 100
	MINUS          shift, and enter state 101
	NOT            shift, and enter state 102
	DEPUNT         shift, and enter state 103

	Valori         goto state 87
	Blocco         goto state 88
	Lstm           goto state 187
	Stm            goto state 90
	RE             goto state 91
	LE             goto state 92

State 177

	Lcase -> CASE Valori . COL Lstm OptEnd Lcase        (rule 58)

	COL            shift, and enter state 186


State 178

	BloccoSw -> OPENG END Lcase CLOSEG . END            (rule 43)

	END            shift, and enter state 185


State 179

	Blocco -> OPENG END GVar Lstm . OptEnd CLOSEG END    (rule 41)
	BloccoNE -> OPENG END GVar Lstm . OptEnd CLOSEG     (rule 42)

	END            reduce using rule 8
	CLOSEG         reduce using rule 8

	OptEnd         goto state 184

State 180

	Stm -> FOR RE SEMICOL RE SEMICOL RE . Blocco        (rule 46)
	RE -> RE . PLUS RE                                  (rule 60)
	RE -> RE . MINUS RE                                 (rule 61)
	RE -> RE . OPEQ RE                                  (rule 62)
	RE -> RE . OPDISEQ RE                               (rule 63)
	RE -> RE . OR RE                                    (rule 64)
	RE -> RE . AND RE                                   (rule 65)
	RE -> RE . AST RE                                   (rule 66)
	RE -> RE . DIV RE                                   (rule 67)
	RE -> RE . POW RE                                   (rule 68)

	OPENG          shift, and enter state 80
	AST            shift, and enter state 121
	PLUS           shift, and enter state 122
	MINUS          shift, and enter state 123
	DIV            shift, and enter state 124
	POW            shift, and enter state 125
	OPEQ           shift, and enter state 126
	OPDISEQ        shift, and enter state 127
	AND            shift, and enter state 128
	OR             shift, and enter state 129

	Blocco         goto state 183

State 181

	OptEnd -> OptEnd . END                              (rule 9)
	BloccoNE -> OPENG END GVar Lstm OptEnd . CLOSEG     (rule 42)

	END            shift, and enter state 85
	CLOSEG         shift, and enter state 182


State 182

	BloccoNE -> OPENG END GVar Lstm OptEnd CLOSEG .     (rule 42)

	CATCH          reduce using rule 42


State 183

	Stm -> FOR RE SEMICOL RE SEMICOL RE Blocco .        (rule 46)

	END            reduce using rule 46
	OPENR          reduce using rule 46
	OPENG          reduce using rule 46
	CLOSEG         reduce using rule 46
	TRY            reduce using rule 46
	RETURN         reduce using rule 46
	IDENT          reduce using rule 46
	BOOLEANO       reduce using rule 46
	INTERO         reduce using rule 46
	FLOAT          reduce using rule 46
	STRINGA        reduce using rule 46
	CHAR           reduce using rule 46
	AST            reduce using rule 46
	FOR            reduce using rule 46
	IF             reduce using rule 46
	SWITCH         reduce using rule 46
	CASE           reduce using rule 46
	DEFAULT        reduce using rule 46
	MINUS          reduce using rule 46
	NOT            reduce using rule 46
	DEPUNT         reduce using rule 46


State 184

	OptEnd -> OptEnd . END                              (rule 9)
	Blocco -> OPENG END GVar Lstm OptEnd . CLOSEG END    (rule 41)
	BloccoNE -> OPENG END GVar Lstm OptEnd . CLOSEG     (rule 42)

	END            shift, and enter state 85
	CLOSEG         shift, and enter state 190


State 185

	BloccoSw -> OPENG END Lcase CLOSEG END .            (rule 43)

	END            reduce using rule 43
	OPENR          reduce using rule 43
	OPENG          reduce using rule 43
	CLOSEG         reduce using rule 43
	TRY            reduce using rule 43
	RETURN         reduce using rule 43
	IDENT          reduce using rule 43
	BOOLEANO       reduce using rule 43
	INTERO         reduce using rule 43
	FLOAT          reduce using rule 43
	STRINGA        reduce using rule 43
	CHAR           reduce using rule 43
	AST            reduce using rule 43
	FOR            reduce using rule 43
	IF             reduce using rule 43
	SWITCH         reduce using rule 43
	CASE           reduce using rule 43
	DEFAULT        reduce using rule 43
	MINUS          reduce using rule 43
	NOT            reduce using rule 43
	DEPUNT         reduce using rule 43


State 186

	Lcase -> CASE Valori COL . Lstm OptEnd Lcase        (rule 58)

	END            reduce using rule 44
	OPENR          shift, and enter state 93
	OPENG          shift, and enter state 80
	CLOSEG         reduce using rule 44
	TRY            shift, and enter state 94
	RETURN         shift, and enter state 95
	IDENT          shift, and enter state 96
	BOOLEANO       shift, and enter state 45
	INTERO         shift, and enter state 46
	FLOAT          shift, and enter state 47
	STRINGA        shift, and enter state 48
	CHAR           shift, and enter state 49
	AST            shift, and enter state 97
	FOR            shift, and enter state 98
	IF             shift, and enter state 99
	SWITCH         shift, and enter state 100
	CASE           reduce using rule 44
	DEFAULT        reduce using rule 44
	MINUS          shift, and enter state 101
	NOT            shift, and enter state 102
	DEPUNT         shift, and enter state 103

	Valori         goto state 87
	Blocco         goto state 88
	Lstm           goto state 189
	Stm            goto state 90
	RE             goto state 91
	LE             goto state 92

State 187

	Lcase -> DEFAULT COL Lstm . OptEnd                  (rule 59)

	END            reduce using rule 8
	CLOSEG         reduce using rule 8

	OptEnd         goto state 188

State 188

	OptEnd -> OptEnd . END                              (rule 9)
	Lcase -> DEFAULT COL Lstm OptEnd .                  (rule 59)

	END            shift, and enter state 85
	CLOSEG         reduce using rule 59


State 189

	Lcase -> CASE Valori COL Lstm . OptEnd Lcase        (rule 58)

	END            reduce using rule 8
	CLOSEG         reduce using rule 8
	CASE           reduce using rule 8
	DEFAULT        reduce using rule 8

	OptEnd         goto state 191

State 190

	Blocco -> OPENG END GVar Lstm OptEnd CLOSEG . END    (rule 41)
	BloccoNE -> OPENG END GVar Lstm OptEnd CLOSEG .     (rule 42)

	END            shift, and enter state 167
	ELSE           reduce using rule 42


State 191

	OptEnd -> OptEnd . END                              (rule 9)
	Lcase -> CASE Valori COL Lstm OptEnd . Lcase        (rule 58)

	END            shift, and enter state 85
	CLOSEG         reduce using rule 57
	CASE           shift, and enter state 174
	DEFAULT        shift, and enter state 175

	Lcase          goto state 192

State 192

	Lcase -> CASE Valori COL Lstm OptEnd Lcase .        (rule 58)

	CLOSEG         reduce using rule 58


-----------------------------------------------------------------------------
Grammar Totals
-----------------------------------------------------------------------------
Number of rules: 84
Number of terminals: 50
Number of non-terminals: 24
Number of states: 193