Main.info

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

state 93 contains 2 shift/reduce conflicts.
state 108 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 -> END OptEnd                               (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 -> FUNC IDENT OPENR ParList CLOSER Tipo Blocco OptEnd Funz   (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 Lstm OptEnd CLOSEG END         (41)
	BloccoNE -> OPENG END 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 Blocco ELSE Blocco                    (50)
	Stm -> IF RE BloccoNE ELSE Blocco                  (51)
	Stm -> SWITCH IDENT BloccoSw                       (52)
	Stm -> Blocco                                      (53)
	Stm -> TRY Blocco CATCH Blocco                     (54)
	Stm -> RE END                                      (55)
	Stm -> RETURN END                                  (56)
	Stm -> RETURN RE END                               (57)
	Stm -> CONTINUE END                                (58)
	Stm -> BREAK END                                   (59)
	Stm -> VAR IDENT Tipo END                          (60)
	Stm -> VAR IDENT Tipo UGUALE Valori END            (61)
	Stm -> VAR OPENR END VarLine CLOSER END            (62)
	Lcase ->                                           (63)
	Lcase -> CASE Valori COL Lstm OptEnd Lcase         (64)
	Lcase -> DEFAULT COL Lstm OptEnd                   (65)
	RE -> RE PLUS RE                                   (66)
	RE -> RE MINUS RE                                  (67)
	RE -> RE AST RE                                    (68)
	RE -> RE DIV RE                                    (69)
	RE -> RE POW RE                                    (70)
	RE -> RE OPDISEQL RE                               (71)
	RE -> RE OPDISEQLE RE                              (72)
	RE -> RE OPDISEQG RE                               (73)
	RE -> RE OPDISEQGE RE                              (74)
	RE -> RE OPEQ RE                                   (75)
	RE -> RE OPNEQ RE                                  (76)
	RE -> RE OR RE                                     (77)
	RE -> RE AND RE                                    (78)
	RE -> RE XOR RE                                    (79)
	RE -> OPENR RE CLOSER                              (80)
	RE -> MINUS RE                                     (81)
	RE -> NOT RE                                       (82)
	RE -> LE                                           (83)
	RE -> LE UGUALE RE                                 (84)
	RE -> IDENT OPENR ListParAtt CLOSER                (85)
	RE -> DEPUNT LE                                    (86)
	RE -> Valori                                       (87)
	ListParAtt ->                                      (88)
	ListParAtt -> ListParAttNE                         (89)
	ListParAttNE -> RE                                 (90)
	ListParAttNE -> ListParAttNE COMMA RE              (91)
	LE -> IDENT                                        (92)
	LE -> AST RE                                       (93)
	LE -> LE OPENQ RE CLOSEQ                           (94)

-----------------------------------------------------------------------------
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) }
	CONTINUE       { (a, Continue) }
	BREAK          { (a, Break) }
	PLUS           { (a, Plus) }
	MINUS          { (a, Minus) }
	DIV            { (a, Div) }
	POW            { (a, Pow) }
	OPEQ           { (a, OpEq) }
	OPNEQ          { (a, OpNEq) }
	OPDISEQL       { (a, OpDiseqL) }
	OPDISEQLE      { (a, OpDiseqLE) }
	OPDISEQG       { (a, OpDiseqG) }
	OPDISEQGE      { (a, OpDiseqGE) }
	AND            { (a, And) }
	OR             { (a, Or) }
	XOR            { (a, Xor) }
	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, 57, 58, 59, 60, 61, 62
	Lcase           rules 63, 64, 65
	RE              rules 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87
	ListParAtt      rules 88, 89
	ListParAttNE    rules 90, 91
	LE              rules 92, 93, 94

-----------------------------------------------------------------------------
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 17


State 9

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

	END            shift, and enter state 16


State 10

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

	FUNC           shift, and enter state 15
	%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 31


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 23
	UGUALE         reduce using rule 22
	RUNE           shift, and enter state 24
	BOOL           shift, and enter state 25
	INT            shift, and enter state 26
	STR            shift, and enter state 27
	AST            shift, and enter state 28
	FLOAT32        shift, and enter state 29
	FLOAT64        shift, and enter state 30

	Tipo           goto state 22

State 14

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

	%eof           reduce using rule 1


State 15

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

	IDENT          shift, and enter state 21


State 16

	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 20

State 17

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

	STRINGA        shift, and enter state 19

	Imp            goto state 18

State 18

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

	CLOSER         shift, and enter state 40


State 19

	Imp -> STRINGA . END Imp2                           (rule 5)

	END            shift, and enter state 39


State 20

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

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


State 21

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

	OPENR          shift, and enter state 38


State 22

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

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


State 23

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

	INTERO         shift, and enter state 35


State 24

	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 25

	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 26

	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 27

	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 28

	Tipo -> AST . Tipo                                  (rule 27)

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

	Tipo           goto state 34

State 29

	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 30

	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 31

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

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

	VarLine        goto state 32

State 32

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

	CLOSER         shift, and enter state 56


State 33

	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 23
	UGUALE         reduce using rule 22
	RUNE           shift, and enter state 24
	BOOL           shift, and enter state 25
	INT            shift, and enter state 26
	STR            shift, and enter state 27
	AST            shift, and enter state 28
	FLOAT32        shift, and enter state 29
	FLOAT64        shift, and enter state 30

	Tipo           goto state 55

State 34

	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 35

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

	CLOSEQ         shift, and enter state 54


State 36

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

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

	GVar           goto state 53

State 37

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

	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52

	Valori         goto state 47

State 38

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

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

	ParList        goto state 44
	ParListNE      goto state 45

State 39

	Imp -> STRINGA END . Imp2                           (rule 5)

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

	Imp2           goto state 42

State 40

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

	END            shift, and enter state 41


State 41

	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 42

	Imp -> STRINGA END Imp2 .                           (rule 5)

	CLOSER         reduce using rule 5


State 43

	Imp2 -> STRINGA . END Imp2                          (rule 7)

	END            shift, and enter state 65


State 44

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

	CLOSER         shift, and enter state 64


State 45

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

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


State 46

	ParListNE -> IDENT . Tipo Modo                      (rule 35)

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

	Tipo           goto state 62

State 47

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

	END            shift, and enter state 61


State 48

	Valori -> BOOLEANO .                                (rule 19)

	END            reduce using rule 19
	CLOSER         reduce using rule 19
	OPENQ          reduce using rule 19
	CLOSEQ         reduce using rule 19
	OPENG          reduce using rule 19
	COMMA          reduce using rule 19
	SEMICOL        reduce using rule 19
	COL            reduce using rule 19
	UGUALE         reduce using rule 19
	AST            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
	OPNEQ          reduce using rule 19
	OPDISEQL       reduce using rule 19
	OPDISEQLE      reduce using rule 19
	OPDISEQG       reduce using rule 19
	OPDISEQGE      reduce using rule 19
	AND            reduce using rule 19
	OR             reduce using rule 19
	XOR            reduce using rule 19


State 49

	Valori -> INTERO .                                  (rule 17)

	END            reduce using rule 17
	CLOSER         reduce using rule 17
	OPENQ          reduce using rule 17
	CLOSEQ         reduce using rule 17
	OPENG          reduce using rule 17
	COMMA          reduce using rule 17
	SEMICOL        reduce using rule 17
	COL            reduce using rule 17
	UGUALE         reduce using rule 17
	AST            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
	OPNEQ          reduce using rule 17
	OPDISEQL       reduce using rule 17
	OPDISEQLE      reduce using rule 17
	OPDISEQG       reduce using rule 17
	OPDISEQGE      reduce using rule 17
	AND            reduce using rule 17
	OR             reduce using rule 17
	XOR            reduce using rule 17


State 50

	Valori -> FLOAT .                                   (rule 18)

	END            reduce using rule 18
	CLOSER         reduce using rule 18
	OPENQ          reduce using rule 18
	CLOSEQ         reduce using rule 18
	OPENG          reduce using rule 18
	COMMA          reduce using rule 18
	SEMICOL        reduce using rule 18
	COL            reduce using rule 18
	UGUALE         reduce using rule 18
	AST            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
	OPNEQ          reduce using rule 18
	OPDISEQL       reduce using rule 18
	OPDISEQLE      reduce using rule 18
	OPDISEQG       reduce using rule 18
	OPDISEQGE      reduce using rule 18
	AND            reduce using rule 18
	OR             reduce using rule 18
	XOR            reduce using rule 18


State 51

	Valori -> STRINGA .                                 (rule 20)

	END            reduce using rule 20
	CLOSER         reduce using rule 20
	OPENQ          reduce using rule 20
	CLOSEQ         reduce using rule 20
	OPENG          reduce using rule 20
	COMMA          reduce using rule 20
	SEMICOL        reduce using rule 20
	COL            reduce using rule 20
	UGUALE         reduce using rule 20
	AST            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
	OPNEQ          reduce using rule 20
	OPDISEQL       reduce using rule 20
	OPDISEQLE      reduce using rule 20
	OPDISEQG       reduce using rule 20
	OPDISEQGE      reduce using rule 20
	AND            reduce using rule 20
	OR             reduce using rule 20
	XOR            reduce using rule 20


State 52

	Valori -> CHAR .                                    (rule 21)

	END            reduce using rule 21
	CLOSER         reduce using rule 21
	OPENQ          reduce using rule 21
	CLOSEQ         reduce using rule 21
	OPENG          reduce using rule 21
	COMMA          reduce using rule 21
	SEMICOL        reduce using rule 21
	COL            reduce using rule 21
	UGUALE         reduce using rule 21
	AST            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
	OPNEQ          reduce using rule 21
	OPDISEQL       reduce using rule 21
	OPDISEQLE      reduce using rule 21
	OPDISEQG       reduce using rule 21
	OPDISEQGE      reduce using rule 21
	AND            reduce using rule 21
	OR             reduce using rule 21
	XOR            reduce using rule 21


State 53

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

	FUNC           reduce using rule 11
	%eof           reduce using rule 11


State 54

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

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

	Tipo           goto state 60

State 55

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

	END            shift, and enter state 58
	UGUALE         shift, and enter state 59


State 56

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

	END            shift, and enter state 57


State 57

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

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

	GVar           goto state 76

State 58

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

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

	VarLine        goto state 75

State 59

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

	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52

	Valori         goto state 74

State 60

	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 61

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

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

	GVar           goto state 73

State 62

	ParListNE -> IDENT Tipo . Modo                      (rule 35)

	CLOSER         reduce using rule 39
	COMMA          reduce using rule 39
	VAL            shift, and enter state 70
	VALRES         shift, and enter state 71
	CNST           shift, and enter state 72

	Modo           goto state 69

State 63

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

	IDENT          shift, and enter state 68


State 64

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

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

	Tipo           goto state 67

State 65

	Imp2 -> STRINGA END . Imp2                          (rule 7)

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

	Imp2           goto state 66

State 66

	Imp2 -> STRINGA END Imp2 .                          (rule 7)

	CLOSER         reduce using rule 7


State 67

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

	OPENG          shift, and enter state 80

	Blocco         goto state 79

State 68

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

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

	Tipo           goto state 78

State 69

	ParListNE -> IDENT Tipo Modo .                      (rule 35)

	CLOSER         reduce using rule 35
	COMMA          reduce using rule 35


State 70

	Modo -> VAL .                                       (rule 40)

	CLOSER         reduce using rule 40
	COMMA          reduce using rule 40


State 71

	Modo -> VALRES .                                    (rule 37)

	CLOSER         reduce using rule 37
	COMMA          reduce using rule 37


State 72

	Modo -> CNST .                                      (rule 38)

	CLOSER         reduce using rule 38
	COMMA          reduce using rule 38


State 73

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

	FUNC           reduce using rule 12
	%eof           reduce using rule 12


State 74

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

	END            shift, and enter state 77


State 75

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

	CLOSER         reduce using rule 16


State 76

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

	FUNC           reduce using rule 13
	%eof           reduce using rule 13


State 77

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

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

	VarLine        goto state 85

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 70
	VALRES         shift, and enter state 71
	CNST           shift, and enter state 72

	Modo           goto state 84

State 79

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

	FUNC           reduce using rule 8
	END            shift, and enter state 83
	%eof           reduce using rule 8

	OptEnd         goto state 82

State 80

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

	END            shift, and enter state 81


State 81

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

	VAR            shift, and enter state 94
	END            reduce using rule 44
	OPENR          shift, and enter state 95
	OPENG          shift, and enter state 80
	CLOSEG         reduce using rule 44
	TRY            shift, and enter state 96
	RETURN         shift, and enter state 97
	IDENT          shift, and enter state 98
	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52
	AST            shift, and enter state 99
	FOR            shift, and enter state 100
	IF             shift, and enter state 101
	SWITCH         shift, and enter state 102
	CONTINUE       shift, and enter state 103
	BREAK          shift, and enter state 104
	MINUS          shift, and enter state 105
	NOT            shift, and enter state 106
	DEPUNT         shift, and enter state 107

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

State 82

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

	FUNC           shift, and enter state 15
	%eof           reduce using rule 31

	Funz           goto state 87

State 83

	OptEnd -> END . OptEnd                              (rule 9)

	FUNC           reduce using rule 8
	END            shift, and enter state 83
	CLOSEG         reduce using rule 8
	CASE           reduce using rule 8
	DEFAULT        reduce using rule 8
	%eof           reduce using rule 8

	OptEnd         goto state 86

State 84

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

	CLOSER         reduce using rule 36
	COMMA          reduce using rule 36


State 85

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

	CLOSER         reduce using rule 15


State 86

	OptEnd -> END OptEnd .                              (rule 9)

	FUNC           reduce using rule 9
	CLOSEG         reduce using rule 9
	CASE           reduce using rule 9
	DEFAULT        reduce using rule 9
	%eof           reduce using rule 9


State 87

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

	%eof           reduce using rule 32


State 88

	RE -> Valori .                                      (rule 87)

	END            reduce using rule 87
	CLOSER         reduce using rule 87
	OPENQ          reduce using rule 87
	CLOSEQ         reduce using rule 87
	OPENG          reduce using rule 87
	COMMA          reduce using rule 87
	SEMICOL        reduce using rule 87
	UGUALE         reduce using rule 87
	AST            reduce using rule 87
	PLUS           reduce using rule 87
	MINUS          reduce using rule 87
	DIV            reduce using rule 87
	POW            reduce using rule 87
	OPEQ           reduce using rule 87
	OPNEQ          reduce using rule 87
	OPDISEQL       reduce using rule 87
	OPDISEQLE      reduce using rule 87
	OPDISEQG       reduce using rule 87
	OPDISEQGE      reduce using rule 87
	AND            reduce using rule 87
	OR             reduce using rule 87
	XOR            reduce using rule 87


State 89

	Stm -> Blocco .                                     (rule 53)

	VAR            reduce using 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
	CONTINUE       reduce using rule 53
	BREAK          reduce using rule 53
	MINUS          reduce using rule 53
	NOT            reduce using rule 53
	DEPUNT         reduce using rule 53


State 90

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

	END            shift, and enter state 83
	CLOSEG         reduce using rule 8

	OptEnd         goto state 144

State 91

	Lstm -> Stm . Lstm                                  (rule 45)

	VAR            shift, and enter state 94
	END            reduce using rule 44
	OPENR          shift, and enter state 95
	OPENG          shift, and enter state 80
	CLOSEG         reduce using rule 44
	TRY            shift, and enter state 96
	RETURN         shift, and enter state 97
	IDENT          shift, and enter state 98
	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52
	AST            shift, and enter state 99
	FOR            shift, and enter state 100
	IF             shift, and enter state 101
	SWITCH         shift, and enter state 102
	CASE           reduce using rule 44
	DEFAULT        reduce using rule 44
	CONTINUE       shift, and enter state 103
	BREAK          shift, and enter state 104
	MINUS          shift, and enter state 105
	NOT            shift, and enter state 106
	DEPUNT         shift, and enter state 107

	Valori         goto state 88
	Blocco         goto state 89
	Lstm           goto state 143
	Stm            goto state 91
	RE             goto state 92
	LE             goto state 93

State 92

	Stm -> RE . END                                     (rule 55)
	RE -> RE . PLUS RE                                  (rule 66)
	RE -> RE . MINUS RE                                 (rule 67)
	RE -> RE . AST RE                                   (rule 68)
	RE -> RE . DIV RE                                   (rule 69)
	RE -> RE . POW RE                                   (rule 70)
	RE -> RE . OPDISEQL RE                              (rule 71)
	RE -> RE . OPDISEQLE RE                             (rule 72)
	RE -> RE . OPDISEQG RE                              (rule 73)
	RE -> RE . OPDISEQGE RE                             (rule 74)
	RE -> RE . OPEQ RE                                  (rule 75)
	RE -> RE . OPNEQ RE                                 (rule 76)
	RE -> RE . OR RE                                    (rule 77)
	RE -> RE . AND RE                                   (rule 78)
	RE -> RE . XOR RE                                   (rule 79)

	END            shift, and enter state 128
	AST            shift, and enter state 129
	PLUS           shift, and enter state 130
	MINUS          shift, and enter state 131
	DIV            shift, and enter state 132
	POW            shift, and enter state 133
	OPEQ           shift, and enter state 134
	OPNEQ          shift, and enter state 135
	OPDISEQL       shift, and enter state 136
	OPDISEQLE      shift, and enter state 137
	OPDISEQG       shift, and enter state 138
	OPDISEQGE      shift, and enter state 139
	AND            shift, and enter state 140
	OR             shift, and enter state 141
	XOR            shift, and enter state 142


State 93

	RE -> LE .                                          (rule 83)
	RE -> LE . UGUALE RE                                (rule 84)
	LE -> LE . OPENQ RE CLOSEQ                          (rule 94)

	END            reduce using rule 83
	CLOSER         reduce using rule 83
	OPENQ          shift, and enter state 126
			(reduce using rule 83)

	CLOSEQ         reduce using rule 83
	OPENG          reduce using rule 83
	COMMA          reduce using rule 83
	SEMICOL        reduce using rule 83
	UGUALE         shift, and enter state 127
			(reduce using rule 83)

	AST            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
	OPNEQ          reduce using rule 83
	OPDISEQL       reduce using rule 83
	OPDISEQLE      reduce using rule 83
	OPDISEQG       reduce using rule 83
	OPDISEQGE      reduce using rule 83
	AND            reduce using rule 83
	OR             reduce using rule 83
	XOR            reduce using rule 83


State 94

	Stm -> VAR . IDENT Tipo END                         (rule 60)
	Stm -> VAR . IDENT Tipo UGUALE Valori END           (rule 61)
	Stm -> VAR . OPENR END VarLine CLOSER END           (rule 62)

	OPENR          shift, and enter state 124
	IDENT          shift, and enter state 125


State 95

	RE -> OPENR . RE CLOSER                             (rule 80)

	OPENR          shift, and enter state 95
	IDENT          shift, and enter state 98
	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52
	AST            shift, and enter state 99
	MINUS          shift, and enter state 105
	NOT            shift, and enter state 106
	DEPUNT         shift, and enter state 107

	Valori         goto state 88
	RE             goto state 123
	LE             goto state 93

State 96

	Stm -> TRY . Blocco CATCH Blocco                    (rule 54)

	OPENG          shift, and enter state 80

	Blocco         goto state 122

State 97

	Stm -> RETURN . END                                 (rule 56)
	Stm -> RETURN . RE END                              (rule 57)

	END            shift, and enter state 121
	OPENR          shift, and enter state 95
	IDENT          shift, and enter state 98
	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52
	AST            shift, and enter state 99
	MINUS          shift, and enter state 105
	NOT            shift, and enter state 106
	DEPUNT         shift, and enter state 107

	Valori         goto state 88
	RE             goto state 120
	LE             goto state 93

State 98

	RE -> IDENT . OPENR ListParAtt CLOSER               (rule 85)
	LE -> IDENT .                                       (rule 92)

	END            reduce using rule 92
	OPENR          shift, and enter state 119
	CLOSER         reduce using rule 92
	OPENQ          reduce using rule 92
	CLOSEQ         reduce using rule 92
	OPENG          reduce using rule 92
	COMMA          reduce using rule 92
	SEMICOL        reduce using rule 92
	UGUALE         reduce using rule 92
	AST            reduce using rule 92
	PLUS           reduce using rule 92
	MINUS          reduce using rule 92
	DIV            reduce using rule 92
	POW            reduce using rule 92
	OPEQ           reduce using rule 92
	OPNEQ          reduce using rule 92
	OPDISEQL       reduce using rule 92
	OPDISEQLE      reduce using rule 92
	OPDISEQG       reduce using rule 92
	OPDISEQGE      reduce using rule 92
	AND            reduce using rule 92
	OR             reduce using rule 92
	XOR            reduce using rule 92


State 99

	LE -> AST . RE                                      (rule 93)

	OPENR          shift, and enter state 95
	IDENT          shift, and enter state 98
	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52
	AST            shift, and enter state 99
	MINUS          shift, and enter state 105
	NOT            shift, and enter state 106
	DEPUNT         shift, and enter state 107

	Valori         goto state 88
	RE             goto state 118
	LE             goto state 93

State 100

	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 95
	OPENG          shift, and enter state 80
	IDENT          shift, and enter state 98
	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52
	AST            shift, and enter state 99
	MINUS          shift, and enter state 105
	NOT            shift, and enter state 106
	DEPUNT         shift, and enter state 107

	Valori         goto state 88
	Blocco         goto state 116
	RE             goto state 117
	LE             goto state 93

State 101

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

	OPENR          shift, and enter state 95
	IDENT          shift, and enter state 98
	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52
	AST            shift, and enter state 99
	MINUS          shift, and enter state 105
	NOT            shift, and enter state 106
	DEPUNT         shift, and enter state 107

	Valori         goto state 88
	RE             goto state 115
	LE             goto state 93

State 102

	Stm -> SWITCH . IDENT BloccoSw                      (rule 52)

	IDENT          shift, and enter state 114


State 103

	Stm -> CONTINUE . END                               (rule 58)

	END            shift, and enter state 113


State 104

	Stm -> BREAK . END                                  (rule 59)

	END            shift, and enter state 112


State 105

	RE -> MINUS . RE                                    (rule 81)

	OPENR          shift, and enter state 95
	IDENT          shift, and enter state 98
	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52
	AST            shift, and enter state 99
	MINUS          shift, and enter state 105
	NOT            shift, and enter state 106
	DEPUNT         shift, and enter state 107

	Valori         goto state 88
	RE             goto state 111
	LE             goto state 93

State 106

	RE -> NOT . RE                                      (rule 82)

	OPENR          shift, and enter state 95
	IDENT          shift, and enter state 98
	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52
	AST            shift, and enter state 99
	MINUS          shift, and enter state 105
	NOT            shift, and enter state 106
	DEPUNT         shift, and enter state 107

	Valori         goto state 88
	RE             goto state 110
	LE             goto state 93

State 107

	RE -> DEPUNT . LE                                   (rule 86)

	IDENT          shift, and enter state 109
	AST            shift, and enter state 99

	LE             goto state 108

State 108

	RE -> DEPUNT LE .                                   (rule 86)
	LE -> LE . OPENQ RE CLOSEQ                          (rule 94)

	END            reduce using rule 86
	CLOSER         reduce using rule 86
	OPENQ          shift, and enter state 126
			(reduce using rule 86)

	CLOSEQ         reduce using rule 86
	OPENG          reduce using rule 86
	COMMA          reduce using rule 86
	SEMICOL        reduce using rule 86
	UGUALE         reduce using rule 86
	AST            reduce using rule 86
	PLUS           reduce using rule 86
	MINUS          reduce using rule 86
	DIV            reduce using rule 86
	POW            reduce using rule 86
	OPEQ           reduce using rule 86
	OPNEQ          reduce using rule 86
	OPDISEQL       reduce using rule 86
	OPDISEQLE      reduce using rule 86
	OPDISEQG       reduce using rule 86
	OPDISEQGE      reduce using rule 86
	AND            reduce using rule 86
	OR             reduce using rule 86
	XOR            reduce using rule 86


State 109

	LE -> IDENT .                                       (rule 92)

	END            reduce using rule 92
	CLOSER         reduce using rule 92
	OPENQ          reduce using rule 92
	CLOSEQ         reduce using rule 92
	OPENG          reduce using rule 92
	COMMA          reduce using rule 92
	SEMICOL        reduce using rule 92
	UGUALE         reduce using rule 92
	AST            reduce using rule 92
	PLUS           reduce using rule 92
	MINUS          reduce using rule 92
	DIV            reduce using rule 92
	POW            reduce using rule 92
	OPEQ           reduce using rule 92
	OPNEQ          reduce using rule 92
	OPDISEQL       reduce using rule 92
	OPDISEQLE      reduce using rule 92
	OPDISEQG       reduce using rule 92
	OPDISEQGE      reduce using rule 92
	AND            reduce using rule 92
	OR             reduce using rule 92
	XOR            reduce using rule 92


State 110

	RE -> RE . PLUS RE                                  (rule 66)
	RE -> RE . MINUS RE                                 (rule 67)
	RE -> RE . AST RE                                   (rule 68)
	RE -> RE . DIV RE                                   (rule 69)
	RE -> RE . POW RE                                   (rule 70)
	RE -> RE . OPDISEQL RE                              (rule 71)
	RE -> RE . OPDISEQLE RE                             (rule 72)
	RE -> RE . OPDISEQG RE                              (rule 73)
	RE -> RE . OPDISEQGE RE                             (rule 74)
	RE -> RE . OPEQ RE                                  (rule 75)
	RE -> RE . OPNEQ RE                                 (rule 76)
	RE -> RE . OR RE                                    (rule 77)
	RE -> RE . AND RE                                   (rule 78)
	RE -> RE . XOR RE                                   (rule 79)
	RE -> NOT RE .                                      (rule 82)

	END            reduce using rule 82
	CLOSER         reduce using rule 82
	OPENQ          reduce using rule 82
	CLOSEQ         reduce using rule 82
	OPENG          reduce using rule 82
	COMMA          reduce using rule 82
	SEMICOL        reduce using rule 82
	UGUALE         reduce using rule 82
	AST            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
	OPNEQ          reduce using rule 82
	OPDISEQL       reduce using rule 82
	OPDISEQLE      reduce using rule 82
	OPDISEQG       reduce using rule 82
	OPDISEQGE      reduce using rule 82
	AND            reduce using rule 82
	OR             reduce using rule 82
	XOR            reduce using rule 82


State 111

	RE -> RE . PLUS RE                                  (rule 66)
	RE -> RE . MINUS RE                                 (rule 67)
	RE -> RE . AST RE                                   (rule 68)
	RE -> RE . DIV RE                                   (rule 69)
	RE -> RE . POW RE                                   (rule 70)
	RE -> RE . OPDISEQL RE                              (rule 71)
	RE -> RE . OPDISEQLE RE                             (rule 72)
	RE -> RE . OPDISEQG RE                              (rule 73)
	RE -> RE . OPDISEQGE RE                             (rule 74)
	RE -> RE . OPEQ RE                                  (rule 75)
	RE -> RE . OPNEQ RE                                 (rule 76)
	RE -> RE . OR RE                                    (rule 77)
	RE -> RE . AND RE                                   (rule 78)
	RE -> RE . XOR RE                                   (rule 79)
	RE -> MINUS RE .                                    (rule 81)

	END            reduce using rule 81
	CLOSER         reduce using rule 81
	OPENQ          reduce using rule 81
	CLOSEQ         reduce using rule 81
	OPENG          reduce using rule 81
	COMMA          reduce using rule 81
	SEMICOL        reduce using rule 81
	UGUALE         reduce using rule 81
	AST            shift, and enter state 129
	PLUS           reduce using rule 81
	MINUS          reduce using rule 81
	DIV            shift, and enter state 132
	POW            shift, and enter state 133
	OPEQ           reduce using rule 81
	OPNEQ          reduce using rule 81
	OPDISEQL       reduce using rule 81
	OPDISEQLE      reduce using rule 81
	OPDISEQG       reduce using rule 81
	OPDISEQGE      reduce using rule 81
	AND            reduce using rule 81
	OR             reduce using rule 81
	XOR            reduce using rule 81


State 112

	Stm -> BREAK END .                                  (rule 59)

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


State 113

	Stm -> CONTINUE END .                               (rule 58)

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


State 114

	Stm -> SWITCH IDENT . BloccoSw                      (rule 52)

	OPENG          shift, and enter state 176

	BloccoSw       goto state 175

State 115

	Stm -> IF RE . Blocco                               (rule 49)
	Stm -> IF RE . Blocco ELSE Blocco                   (rule 50)
	Stm -> IF RE . BloccoNE ELSE Blocco                 (rule 51)
	RE -> RE . PLUS RE                                  (rule 66)
	RE -> RE . MINUS RE                                 (rule 67)
	RE -> RE . AST RE                                   (rule 68)
	RE -> RE . DIV RE                                   (rule 69)
	RE -> RE . POW RE                                   (rule 70)
	RE -> RE . OPDISEQL RE                              (rule 71)
	RE -> RE . OPDISEQLE RE                             (rule 72)
	RE -> RE . OPDISEQG RE                              (rule 73)
	RE -> RE . OPDISEQGE RE                             (rule 74)
	RE -> RE . OPEQ RE                                  (rule 75)
	RE -> RE . OPNEQ RE                                 (rule 76)
	RE -> RE . OR RE                                    (rule 77)
	RE -> RE . AND RE                                   (rule 78)
	RE -> RE . XOR RE                                   (rule 79)

	OPENG          shift, and enter state 174
	AST            shift, and enter state 129
	PLUS           shift, and enter state 130
	MINUS          shift, and enter state 131
	DIV            shift, and enter state 132
	POW            shift, and enter state 133
	OPEQ           shift, and enter state 134
	OPNEQ          shift, and enter state 135
	OPDISEQL       shift, and enter state 136
	OPDISEQLE      shift, and enter state 137
	OPDISEQG       shift, and enter state 138
	OPDISEQGE      shift, and enter state 139
	AND            shift, and enter state 140
	OR             shift, and enter state 141
	XOR            shift, and enter state 142

	Blocco         goto state 172
	BloccoNE       goto state 173

State 116

	Stm -> FOR Blocco .                                 (rule 48)

	VAR            reduce using 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
	CONTINUE       reduce using rule 48
	BREAK          reduce using rule 48
	MINUS          reduce using rule 48
	NOT            reduce using rule 48
	DEPUNT         reduce using rule 48


State 117

	Stm -> FOR RE . SEMICOL RE SEMICOL RE Blocco        (rule 46)
	Stm -> FOR RE . Blocco                              (rule 47)
	RE -> RE . PLUS RE                                  (rule 66)
	RE -> RE . MINUS RE                                 (rule 67)
	RE -> RE . AST RE                                   (rule 68)
	RE -> RE . DIV RE                                   (rule 69)
	RE -> RE . POW RE                                   (rule 70)
	RE -> RE . OPDISEQL RE                              (rule 71)
	RE -> RE . OPDISEQLE RE                             (rule 72)
	RE -> RE . OPDISEQG RE                              (rule 73)
	RE -> RE . OPDISEQGE RE                             (rule 74)
	RE -> RE . OPEQ RE                                  (rule 75)
	RE -> RE . OPNEQ RE                                 (rule 76)
	RE -> RE . OR RE                                    (rule 77)
	RE -> RE . AND RE                                   (rule 78)
	RE -> RE . XOR RE                                   (rule 79)

	OPENG          shift, and enter state 80
	SEMICOL        shift, and enter state 171
	AST            shift, and enter state 129
	PLUS           shift, and enter state 130
	MINUS          shift, and enter state 131
	DIV            shift, and enter state 132
	POW            shift, and enter state 133
	OPEQ           shift, and enter state 134
	OPNEQ          shift, and enter state 135
	OPDISEQL       shift, and enter state 136
	OPDISEQLE      shift, and enter state 137
	OPDISEQG       shift, and enter state 138
	OPDISEQGE      shift, and enter state 139
	AND            shift, and enter state 140
	OR             shift, and enter state 141
	XOR            shift, and enter state 142

	Blocco         goto state 170

State 118

	RE -> RE . PLUS RE                                  (rule 66)
	RE -> RE . MINUS RE                                 (rule 67)
	RE -> RE . AST RE                                   (rule 68)
	RE -> RE . DIV RE                                   (rule 69)
	RE -> RE . POW RE                                   (rule 70)
	RE -> RE . OPDISEQL RE                              (rule 71)
	RE -> RE . OPDISEQLE RE                             (rule 72)
	RE -> RE . OPDISEQG RE                              (rule 73)
	RE -> RE . OPDISEQGE RE                             (rule 74)
	RE -> RE . OPEQ RE                                  (rule 75)
	RE -> RE . OPNEQ RE                                 (rule 76)
	RE -> RE . OR RE                                    (rule 77)
	RE -> RE . AND RE                                   (rule 78)
	RE -> RE . XOR RE                                   (rule 79)
	LE -> AST RE .                                      (rule 93)

	END            reduce using rule 93
	CLOSER         reduce using rule 93
	OPENQ          reduce using rule 93
	CLOSEQ         reduce using rule 93
	OPENG          reduce using rule 93
	COMMA          reduce using rule 93
	SEMICOL        reduce using rule 93
	UGUALE         reduce using rule 93
	AST            reduce using rule 93
	PLUS           reduce using rule 93
	MINUS          reduce using rule 93
	DIV            shift, and enter state 132
	POW            shift, and enter state 133
	OPEQ           reduce using rule 93
	OPNEQ          reduce using rule 93
	OPDISEQL       reduce using rule 93
	OPDISEQLE      reduce using rule 93
	OPDISEQG       reduce using rule 93
	OPDISEQGE      reduce using rule 93
	AND            reduce using rule 93
	OR             reduce using rule 93
	XOR            reduce using rule 93


State 119

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

	OPENR          shift, and enter state 95
	CLOSER         reduce using rule 88
	IDENT          shift, and enter state 98
	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52
	AST            shift, and enter state 99
	MINUS          shift, and enter state 105
	NOT            shift, and enter state 106
	DEPUNT         shift, and enter state 107

	Valori         goto state 88
	RE             goto state 167
	ListParAtt     goto state 168
	ListParAttNE   goto state 169
	LE             goto state 93

State 120

	Stm -> RETURN RE . END                              (rule 57)
	RE -> RE . PLUS RE                                  (rule 66)
	RE -> RE . MINUS RE                                 (rule 67)
	RE -> RE . AST RE                                   (rule 68)
	RE -> RE . DIV RE                                   (rule 69)
	RE -> RE . POW RE                                   (rule 70)
	RE -> RE . OPDISEQL RE                              (rule 71)
	RE -> RE . OPDISEQLE RE                             (rule 72)
	RE -> RE . OPDISEQG RE                              (rule 73)
	RE -> RE . OPDISEQGE RE                             (rule 74)
	RE -> RE . OPEQ RE                                  (rule 75)
	RE -> RE . OPNEQ RE                                 (rule 76)
	RE -> RE . OR RE                                    (rule 77)
	RE -> RE . AND RE                                   (rule 78)
	RE -> RE . XOR RE                                   (rule 79)

	END            shift, and enter state 166
	AST            shift, and enter state 129
	PLUS           shift, and enter state 130
	MINUS          shift, and enter state 131
	DIV            shift, and enter state 132
	POW            shift, and enter state 133
	OPEQ           shift, and enter state 134
	OPNEQ          shift, and enter state 135
	OPDISEQL       shift, and enter state 136
	OPDISEQLE      shift, and enter state 137
	OPDISEQG       shift, and enter state 138
	OPDISEQGE      shift, and enter state 139
	AND            shift, and enter state 140
	OR             shift, and enter state 141
	XOR            shift, and enter state 142


State 121

	Stm -> RETURN END .                                 (rule 56)

	VAR            reduce using rule 56
	END            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
	CONTINUE       reduce using rule 56
	BREAK          reduce using rule 56
	MINUS          reduce using rule 56
	NOT            reduce using rule 56
	DEPUNT         reduce using rule 56


State 122

	Stm -> TRY Blocco . CATCH Blocco                    (rule 54)

	CATCH          shift, and enter state 165


State 123

	RE -> RE . PLUS RE                                  (rule 66)
	RE -> RE . MINUS RE                                 (rule 67)
	RE -> RE . AST RE                                   (rule 68)
	RE -> RE . DIV RE                                   (rule 69)
	RE -> RE . POW RE                                   (rule 70)
	RE -> RE . OPDISEQL RE                              (rule 71)
	RE -> RE . OPDISEQLE RE                             (rule 72)
	RE -> RE . OPDISEQG RE                              (rule 73)
	RE -> RE . OPDISEQGE RE                             (rule 74)
	RE -> RE . OPEQ RE                                  (rule 75)
	RE -> RE . OPNEQ RE                                 (rule 76)
	RE -> RE . OR RE                                    (rule 77)
	RE -> RE . AND RE                                   (rule 78)
	RE -> RE . XOR RE                                   (rule 79)
	RE -> OPENR RE . CLOSER                             (rule 80)

	CLOSER         shift, and enter state 164
	AST            shift, and enter state 129
	PLUS           shift, and enter state 130
	MINUS          shift, and enter state 131
	DIV            shift, and enter state 132
	POW            shift, and enter state 133
	OPEQ           shift, and enter state 134
	OPNEQ          shift, and enter state 135
	OPDISEQL       shift, and enter state 136
	OPDISEQLE      shift, and enter state 137
	OPDISEQG       shift, and enter state 138
	OPDISEQGE      shift, and enter state 139
	AND            shift, and enter state 140
	OR             shift, and enter state 141
	XOR            shift, and enter state 142


State 124

	Stm -> VAR OPENR . END VarLine CLOSER END           (rule 62)

	END            shift, and enter state 163


State 125

	Stm -> VAR IDENT . Tipo END                         (rule 60)
	Stm -> VAR IDENT . Tipo UGUALE Valori END           (rule 61)

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

	Tipo           goto state 162

State 126

	LE -> LE OPENQ . RE CLOSEQ                          (rule 94)

	OPENR          shift, and enter state 95
	IDENT          shift, and enter state 98
	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52
	AST            shift, and enter state 99
	MINUS          shift, and enter state 105
	NOT            shift, and enter state 106
	DEPUNT         shift, and enter state 107

	Valori         goto state 88
	RE             goto state 161
	LE             goto state 93

State 127

	RE -> LE UGUALE . RE                                (rule 84)

	OPENR          shift, and enter state 95
	IDENT          shift, and enter state 98
	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52
	AST            shift, and enter state 99
	MINUS          shift, and enter state 105
	NOT            shift, and enter state 106
	DEPUNT         shift, and enter state 107

	Valori         goto state 88
	RE             goto state 160
	LE             goto state 93

State 128

	Stm -> RE END .                                     (rule 55)

	VAR            reduce using 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
	CONTINUE       reduce using rule 55
	BREAK          reduce using rule 55
	MINUS          reduce using rule 55
	NOT            reduce using rule 55
	DEPUNT         reduce using rule 55


State 129

	RE -> RE AST . RE                                   (rule 68)

	OPENR          shift, and enter state 95
	IDENT          shift, and enter state 98
	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52
	AST            shift, and enter state 99
	MINUS          shift, and enter state 105
	NOT            shift, and enter state 106
	DEPUNT         shift, and enter state 107

	Valori         goto state 88
	RE             goto state 159
	LE             goto state 93

State 130

	RE -> RE PLUS . RE                                  (rule 66)

	OPENR          shift, and enter state 95
	IDENT          shift, and enter state 98
	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52
	AST            shift, and enter state 99
	MINUS          shift, and enter state 105
	NOT            shift, and enter state 106
	DEPUNT         shift, and enter state 107

	Valori         goto state 88
	RE             goto state 158
	LE             goto state 93

State 131

	RE -> RE MINUS . RE                                 (rule 67)

	OPENR          shift, and enter state 95
	IDENT          shift, and enter state 98
	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52
	AST            shift, and enter state 99
	MINUS          shift, and enter state 105
	NOT            shift, and enter state 106
	DEPUNT         shift, and enter state 107

	Valori         goto state 88
	RE             goto state 157
	LE             goto state 93

State 132

	RE -> RE DIV . RE                                   (rule 69)

	OPENR          shift, and enter state 95
	IDENT          shift, and enter state 98
	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52
	AST            shift, and enter state 99
	MINUS          shift, and enter state 105
	NOT            shift, and enter state 106
	DEPUNT         shift, and enter state 107

	Valori         goto state 88
	RE             goto state 156
	LE             goto state 93

State 133

	RE -> RE POW . RE                                   (rule 70)

	OPENR          shift, and enter state 95
	IDENT          shift, and enter state 98
	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52
	AST            shift, and enter state 99
	MINUS          shift, and enter state 105
	NOT            shift, and enter state 106
	DEPUNT         shift, and enter state 107

	Valori         goto state 88
	RE             goto state 155
	LE             goto state 93

State 134

	RE -> RE OPEQ . RE                                  (rule 75)

	OPENR          shift, and enter state 95
	IDENT          shift, and enter state 98
	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52
	AST            shift, and enter state 99
	MINUS          shift, and enter state 105
	NOT            shift, and enter state 106
	DEPUNT         shift, and enter state 107

	Valori         goto state 88
	RE             goto state 154
	LE             goto state 93

State 135

	RE -> RE OPNEQ . RE                                 (rule 76)

	OPENR          shift, and enter state 95
	IDENT          shift, and enter state 98
	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52
	AST            shift, and enter state 99
	MINUS          shift, and enter state 105
	NOT            shift, and enter state 106
	DEPUNT         shift, and enter state 107

	Valori         goto state 88
	RE             goto state 153
	LE             goto state 93

State 136

	RE -> RE OPDISEQL . RE                              (rule 71)

	OPENR          shift, and enter state 95
	IDENT          shift, and enter state 98
	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52
	AST            shift, and enter state 99
	MINUS          shift, and enter state 105
	NOT            shift, and enter state 106
	DEPUNT         shift, and enter state 107

	Valori         goto state 88
	RE             goto state 152
	LE             goto state 93

State 137

	RE -> RE OPDISEQLE . RE                             (rule 72)

	OPENR          shift, and enter state 95
	IDENT          shift, and enter state 98
	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52
	AST            shift, and enter state 99
	MINUS          shift, and enter state 105
	NOT            shift, and enter state 106
	DEPUNT         shift, and enter state 107

	Valori         goto state 88
	RE             goto state 151
	LE             goto state 93

State 138

	RE -> RE OPDISEQG . RE                              (rule 73)

	OPENR          shift, and enter state 95
	IDENT          shift, and enter state 98
	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52
	AST            shift, and enter state 99
	MINUS          shift, and enter state 105
	NOT            shift, and enter state 106
	DEPUNT         shift, and enter state 107

	Valori         goto state 88
	RE             goto state 150
	LE             goto state 93

State 139

	RE -> RE OPDISEQGE . RE                             (rule 74)

	OPENR          shift, and enter state 95
	IDENT          shift, and enter state 98
	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52
	AST            shift, and enter state 99
	MINUS          shift, and enter state 105
	NOT            shift, and enter state 106
	DEPUNT         shift, and enter state 107

	Valori         goto state 88
	RE             goto state 149
	LE             goto state 93

State 140

	RE -> RE AND . RE                                   (rule 78)

	OPENR          shift, and enter state 95
	IDENT          shift, and enter state 98
	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52
	AST            shift, and enter state 99
	MINUS          shift, and enter state 105
	NOT            shift, and enter state 106
	DEPUNT         shift, and enter state 107

	Valori         goto state 88
	RE             goto state 148
	LE             goto state 93

State 141

	RE -> RE OR . RE                                    (rule 77)

	OPENR          shift, and enter state 95
	IDENT          shift, and enter state 98
	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52
	AST            shift, and enter state 99
	MINUS          shift, and enter state 105
	NOT            shift, and enter state 106
	DEPUNT         shift, and enter state 107

	Valori         goto state 88
	RE             goto state 147
	LE             goto state 93

State 142

	RE -> RE XOR . RE                                   (rule 79)

	OPENR          shift, and enter state 95
	IDENT          shift, and enter state 98
	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52
	AST            shift, and enter state 99
	MINUS          shift, and enter state 105
	NOT            shift, and enter state 106
	DEPUNT         shift, and enter state 107

	Valori         goto state 88
	RE             goto state 146
	LE             goto state 93

State 143

	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 144

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

	CLOSEG         shift, and enter state 145


State 145

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

	END            shift, and enter state 189


State 146

	RE -> RE . PLUS RE                                  (rule 66)
	RE -> RE . MINUS RE                                 (rule 67)
	RE -> RE . AST RE                                   (rule 68)
	RE -> RE . DIV RE                                   (rule 69)
	RE -> RE . POW RE                                   (rule 70)
	RE -> RE . OPDISEQL RE                              (rule 71)
	RE -> RE . OPDISEQLE RE                             (rule 72)
	RE -> RE . OPDISEQG RE                              (rule 73)
	RE -> RE . OPDISEQGE RE                             (rule 74)
	RE -> RE . OPEQ RE                                  (rule 75)
	RE -> RE . OPNEQ RE                                 (rule 76)
	RE -> RE . OR RE                                    (rule 77)
	RE -> RE . AND RE                                   (rule 78)
	RE -> RE . XOR RE                                   (rule 79)
	RE -> RE XOR RE .                                   (rule 79)

	END            reduce using rule 79
	CLOSER         reduce using rule 79
	OPENQ          reduce using rule 79
	CLOSEQ         reduce using rule 79
	OPENG          reduce using rule 79
	COMMA          reduce using rule 79
	SEMICOL        reduce using rule 79
	UGUALE         reduce using rule 79
	AST            shift, and enter state 129
	PLUS           shift, and enter state 130
	MINUS          shift, and enter state 131
	DIV            shift, and enter state 132
	POW            shift, and enter state 133
	OPEQ           shift, and enter state 134
	OPNEQ          shift, and enter state 135
	OPDISEQL       shift, and enter state 136
	OPDISEQLE      shift, and enter state 137
	OPDISEQG       shift, and enter state 138
	OPDISEQGE      shift, and enter state 139
	AND            reduce using rule 79
	OR             reduce using rule 79
	XOR            reduce using rule 79


State 147

	RE -> RE . PLUS RE                                  (rule 66)
	RE -> RE . MINUS RE                                 (rule 67)
	RE -> RE . AST RE                                   (rule 68)
	RE -> RE . DIV RE                                   (rule 69)
	RE -> RE . POW RE                                   (rule 70)
	RE -> RE . OPDISEQL RE                              (rule 71)
	RE -> RE . OPDISEQLE RE                             (rule 72)
	RE -> RE . OPDISEQG RE                              (rule 73)
	RE -> RE . OPDISEQGE RE                             (rule 74)
	RE -> RE . OPEQ RE                                  (rule 75)
	RE -> RE . OPNEQ RE                                 (rule 76)
	RE -> RE . OR RE                                    (rule 77)
	RE -> RE OR RE .                                    (rule 77)
	RE -> RE . AND RE                                   (rule 78)
	RE -> RE . XOR RE                                   (rule 79)

	END            reduce using rule 77
	CLOSER         reduce using rule 77
	OPENQ          reduce using rule 77
	CLOSEQ         reduce using rule 77
	OPENG          reduce using rule 77
	COMMA          reduce using rule 77
	SEMICOL        reduce using rule 77
	UGUALE         reduce using rule 77
	AST            shift, and enter state 129
	PLUS           shift, and enter state 130
	MINUS          shift, and enter state 131
	DIV            shift, and enter state 132
	POW            shift, and enter state 133
	OPEQ           shift, and enter state 134
	OPNEQ          shift, and enter state 135
	OPDISEQL       shift, and enter state 136
	OPDISEQLE      shift, and enter state 137
	OPDISEQG       shift, and enter state 138
	OPDISEQGE      shift, and enter state 139
	AND            shift, and enter state 140
	OR             reduce using rule 77
	XOR            shift, and enter state 142


State 148

	RE -> RE . PLUS RE                                  (rule 66)
	RE -> RE . MINUS RE                                 (rule 67)
	RE -> RE . AST RE                                   (rule 68)
	RE -> RE . DIV RE                                   (rule 69)
	RE -> RE . POW RE                                   (rule 70)
	RE -> RE . OPDISEQL RE                              (rule 71)
	RE -> RE . OPDISEQLE RE                             (rule 72)
	RE -> RE . OPDISEQG RE                              (rule 73)
	RE -> RE . OPDISEQGE RE                             (rule 74)
	RE -> RE . OPEQ RE                                  (rule 75)
	RE -> RE . OPNEQ RE                                 (rule 76)
	RE -> RE . OR RE                                    (rule 77)
	RE -> RE . AND RE                                   (rule 78)
	RE -> RE AND RE .                                   (rule 78)
	RE -> RE . XOR RE                                   (rule 79)

	END            reduce using rule 78
	CLOSER         reduce using rule 78
	OPENQ          reduce using rule 78
	CLOSEQ         reduce using rule 78
	OPENG          reduce using rule 78
	COMMA          reduce using rule 78
	SEMICOL        reduce using rule 78
	UGUALE         reduce using rule 78
	AST            shift, and enter state 129
	PLUS           shift, and enter state 130
	MINUS          shift, and enter state 131
	DIV            shift, and enter state 132
	POW            shift, and enter state 133
	OPEQ           shift, and enter state 134
	OPNEQ          shift, and enter state 135
	OPDISEQL       shift, and enter state 136
	OPDISEQLE      shift, and enter state 137
	OPDISEQG       shift, and enter state 138
	OPDISEQGE      shift, and enter state 139
	AND            reduce using rule 78
	OR             reduce using rule 78
	XOR            shift, and enter state 142


State 149

	RE -> RE . PLUS RE                                  (rule 66)
	RE -> RE . MINUS RE                                 (rule 67)
	RE -> RE . AST RE                                   (rule 68)
	RE -> RE . DIV RE                                   (rule 69)
	RE -> RE . POW RE                                   (rule 70)
	RE -> RE . OPDISEQL RE                              (rule 71)
	RE -> RE . OPDISEQLE RE                             (rule 72)
	RE -> RE . OPDISEQG RE                              (rule 73)
	RE -> RE . OPDISEQGE RE                             (rule 74)
	RE -> RE OPDISEQGE RE .                             (rule 74)
	RE -> RE . OPEQ RE                                  (rule 75)
	RE -> RE . OPNEQ RE                                 (rule 76)
	RE -> RE . OR RE                                    (rule 77)
	RE -> RE . AND RE                                   (rule 78)
	RE -> RE . XOR RE                                   (rule 79)

	END            reduce using rule 74
	CLOSER         reduce using rule 74
	OPENQ          reduce using rule 74
	CLOSEQ         reduce using rule 74
	OPENG          reduce using rule 74
	COMMA          reduce using rule 74
	SEMICOL        reduce using rule 74
	UGUALE         reduce using rule 74
	AST            shift, and enter state 129
	PLUS           shift, and enter state 130
	MINUS          shift, and enter state 131
	DIV            shift, and enter state 132
	POW            shift, and enter state 133
	OPEQ           reduce using rule 74
	OPNEQ          reduce using rule 74
	OPDISEQL       reduce using rule 74
	OPDISEQLE      reduce using rule 74
	OPDISEQG       reduce using rule 74
	OPDISEQGE      reduce using rule 74
	AND            reduce using rule 74
	OR             reduce using rule 74
	XOR            reduce using rule 74


State 150

	RE -> RE . PLUS RE                                  (rule 66)
	RE -> RE . MINUS RE                                 (rule 67)
	RE -> RE . AST RE                                   (rule 68)
	RE -> RE . DIV RE                                   (rule 69)
	RE -> RE . POW RE                                   (rule 70)
	RE -> RE . OPDISEQL RE                              (rule 71)
	RE -> RE . OPDISEQLE RE                             (rule 72)
	RE -> RE . OPDISEQG RE                              (rule 73)
	RE -> RE OPDISEQG RE .                              (rule 73)
	RE -> RE . OPDISEQGE RE                             (rule 74)
	RE -> RE . OPEQ RE                                  (rule 75)
	RE -> RE . OPNEQ RE                                 (rule 76)
	RE -> RE . OR RE                                    (rule 77)
	RE -> RE . AND RE                                   (rule 78)
	RE -> RE . XOR RE                                   (rule 79)

	END            reduce using rule 73
	CLOSER         reduce using rule 73
	OPENQ          reduce using rule 73
	CLOSEQ         reduce using rule 73
	OPENG          reduce using rule 73
	COMMA          reduce using rule 73
	SEMICOL        reduce using rule 73
	UGUALE         reduce using rule 73
	AST            shift, and enter state 129
	PLUS           shift, and enter state 130
	MINUS          shift, and enter state 131
	DIV            shift, and enter state 132
	POW            shift, and enter state 133
	OPEQ           reduce using rule 73
	OPNEQ          reduce using rule 73
	OPDISEQL       reduce using rule 73
	OPDISEQLE      reduce using rule 73
	OPDISEQG       reduce using rule 73
	OPDISEQGE      shift, and enter state 139
	AND            reduce using rule 73
	OR             reduce using rule 73
	XOR            reduce using rule 73


State 151

	RE -> RE . PLUS RE                                  (rule 66)
	RE -> RE . MINUS RE                                 (rule 67)
	RE -> RE . AST RE                                   (rule 68)
	RE -> RE . DIV RE                                   (rule 69)
	RE -> RE . POW RE                                   (rule 70)
	RE -> RE . OPDISEQL RE                              (rule 71)
	RE -> RE . OPDISEQLE RE                             (rule 72)
	RE -> RE OPDISEQLE RE .                             (rule 72)
	RE -> RE . OPDISEQG RE                              (rule 73)
	RE -> RE . OPDISEQGE RE                             (rule 74)
	RE -> RE . OPEQ RE                                  (rule 75)
	RE -> RE . OPNEQ RE                                 (rule 76)
	RE -> RE . OR RE                                    (rule 77)
	RE -> RE . AND RE                                   (rule 78)
	RE -> RE . XOR RE                                   (rule 79)

	END            reduce using rule 72
	CLOSER         reduce using rule 72
	OPENQ          reduce using rule 72
	CLOSEQ         reduce using rule 72
	OPENG          reduce using rule 72
	COMMA          reduce using rule 72
	SEMICOL        reduce using rule 72
	UGUALE         reduce using rule 72
	AST            shift, and enter state 129
	PLUS           shift, and enter state 130
	MINUS          shift, and enter state 131
	DIV            shift, and enter state 132
	POW            shift, and enter state 133
	OPEQ           reduce using rule 72
	OPNEQ          reduce using rule 72
	OPDISEQL       reduce using rule 72
	OPDISEQLE      reduce using rule 72
	OPDISEQG       shift, and enter state 138
	OPDISEQGE      shift, and enter state 139
	AND            reduce using rule 72
	OR             reduce using rule 72
	XOR            reduce using rule 72


State 152

	RE -> RE . PLUS RE                                  (rule 66)
	RE -> RE . MINUS RE                                 (rule 67)
	RE -> RE . AST RE                                   (rule 68)
	RE -> RE . DIV RE                                   (rule 69)
	RE -> RE . POW RE                                   (rule 70)
	RE -> RE . OPDISEQL RE                              (rule 71)
	RE -> RE OPDISEQL RE .                              (rule 71)
	RE -> RE . OPDISEQLE RE                             (rule 72)
	RE -> RE . OPDISEQG RE                              (rule 73)
	RE -> RE . OPDISEQGE RE                             (rule 74)
	RE -> RE . OPEQ RE                                  (rule 75)
	RE -> RE . OPNEQ RE                                 (rule 76)
	RE -> RE . OR RE                                    (rule 77)
	RE -> RE . AND RE                                   (rule 78)
	RE -> RE . XOR RE                                   (rule 79)

	END            reduce using rule 71
	CLOSER         reduce using rule 71
	OPENQ          reduce using rule 71
	CLOSEQ         reduce using rule 71
	OPENG          reduce using rule 71
	COMMA          reduce using rule 71
	SEMICOL        reduce using rule 71
	UGUALE         reduce using rule 71
	AST            shift, and enter state 129
	PLUS           shift, and enter state 130
	MINUS          shift, and enter state 131
	DIV            shift, and enter state 132
	POW            shift, and enter state 133
	OPEQ           reduce using rule 71
	OPNEQ          reduce using rule 71
	OPDISEQL       reduce using rule 71
	OPDISEQLE      shift, and enter state 137
	OPDISEQG       shift, and enter state 138
	OPDISEQGE      shift, and enter state 139
	AND            reduce using rule 71
	OR             reduce using rule 71
	XOR            reduce using rule 71


State 153

	RE -> RE . PLUS RE                                  (rule 66)
	RE -> RE . MINUS RE                                 (rule 67)
	RE -> RE . AST RE                                   (rule 68)
	RE -> RE . DIV RE                                   (rule 69)
	RE -> RE . POW RE                                   (rule 70)
	RE -> RE . OPDISEQL RE                              (rule 71)
	RE -> RE . OPDISEQLE RE                             (rule 72)
	RE -> RE . OPDISEQG RE                              (rule 73)
	RE -> RE . OPDISEQGE RE                             (rule 74)
	RE -> RE . OPEQ RE                                  (rule 75)
	RE -> RE . OPNEQ RE                                 (rule 76)
	RE -> RE OPNEQ RE .                                 (rule 76)
	RE -> RE . OR RE                                    (rule 77)
	RE -> RE . AND RE                                   (rule 78)
	RE -> RE . XOR RE                                   (rule 79)

	END            reduce using rule 76
	CLOSER         reduce using rule 76
	OPENQ          reduce using rule 76
	CLOSEQ         reduce using rule 76
	OPENG          reduce using rule 76
	COMMA          reduce using rule 76
	SEMICOL        reduce using rule 76
	UGUALE         reduce using rule 76
	AST            shift, and enter state 129
	PLUS           shift, and enter state 130
	MINUS          shift, and enter state 131
	DIV            shift, and enter state 132
	POW            shift, and enter state 133
	OPEQ           reduce using rule 76
	OPNEQ          reduce using rule 76
	OPDISEQL       shift, and enter state 136
	OPDISEQLE      shift, and enter state 137
	OPDISEQG       shift, and enter state 138
	OPDISEQGE      shift, and enter state 139
	AND            reduce using rule 76
	OR             reduce using rule 76
	XOR            reduce using rule 76


State 154

	RE -> RE . PLUS RE                                  (rule 66)
	RE -> RE . MINUS RE                                 (rule 67)
	RE -> RE . AST RE                                   (rule 68)
	RE -> RE . DIV RE                                   (rule 69)
	RE -> RE . POW RE                                   (rule 70)
	RE -> RE . OPDISEQL RE                              (rule 71)
	RE -> RE . OPDISEQLE RE                             (rule 72)
	RE -> RE . OPDISEQG RE                              (rule 73)
	RE -> RE . OPDISEQGE RE                             (rule 74)
	RE -> RE . OPEQ RE                                  (rule 75)
	RE -> RE OPEQ RE .                                  (rule 75)
	RE -> RE . OPNEQ RE                                 (rule 76)
	RE -> RE . OR RE                                    (rule 77)
	RE -> RE . AND RE                                   (rule 78)
	RE -> RE . XOR RE                                   (rule 79)

	END            reduce using rule 75
	CLOSER         reduce using rule 75
	OPENQ          reduce using rule 75
	CLOSEQ         reduce using rule 75
	OPENG          reduce using rule 75
	COMMA          reduce using rule 75
	SEMICOL        reduce using rule 75
	UGUALE         reduce using rule 75
	AST            shift, and enter state 129
	PLUS           shift, and enter state 130
	MINUS          shift, and enter state 131
	DIV            shift, and enter state 132
	POW            shift, and enter state 133
	OPEQ           reduce using rule 75
	OPNEQ          shift, and enter state 135
	OPDISEQL       shift, and enter state 136
	OPDISEQLE      shift, and enter state 137
	OPDISEQG       shift, and enter state 138
	OPDISEQGE      shift, and enter state 139
	AND            reduce using rule 75
	OR             reduce using rule 75
	XOR            reduce using rule 75


State 155

	RE -> RE . PLUS RE                                  (rule 66)
	RE -> RE . MINUS RE                                 (rule 67)
	RE -> RE . AST RE                                   (rule 68)
	RE -> RE . DIV RE                                   (rule 69)
	RE -> RE . POW RE                                   (rule 70)
	RE -> RE POW RE .                                   (rule 70)
	RE -> RE . OPDISEQL RE                              (rule 71)
	RE -> RE . OPDISEQLE RE                             (rule 72)
	RE -> RE . OPDISEQG RE                              (rule 73)
	RE -> RE . OPDISEQGE RE                             (rule 74)
	RE -> RE . OPEQ RE                                  (rule 75)
	RE -> RE . OPNEQ RE                                 (rule 76)
	RE -> RE . OR RE                                    (rule 77)
	RE -> RE . AND RE                                   (rule 78)
	RE -> RE . XOR RE                                   (rule 79)

	END            reduce using rule 70
	CLOSER         reduce using rule 70
	OPENQ          reduce using rule 70
	CLOSEQ         reduce using rule 70
	OPENG          reduce using rule 70
	COMMA          reduce using rule 70
	SEMICOL        reduce using rule 70
	UGUALE         reduce using rule 70
	AST            reduce using rule 70
	PLUS           reduce using rule 70
	MINUS          reduce using rule 70
	DIV            reduce using rule 70
	POW            reduce using rule 70
	OPEQ           reduce using rule 70
	OPNEQ          reduce using rule 70
	OPDISEQL       reduce using rule 70
	OPDISEQLE      reduce using rule 70
	OPDISEQG       reduce using rule 70
	OPDISEQGE      reduce using rule 70
	AND            reduce using rule 70
	OR             reduce using rule 70
	XOR            reduce using rule 70


State 156

	RE -> RE . PLUS RE                                  (rule 66)
	RE -> RE . MINUS RE                                 (rule 67)
	RE -> RE . AST RE                                   (rule 68)
	RE -> RE . DIV RE                                   (rule 69)
	RE -> RE DIV RE .                                   (rule 69)
	RE -> RE . POW RE                                   (rule 70)
	RE -> RE . OPDISEQL RE                              (rule 71)
	RE -> RE . OPDISEQLE RE                             (rule 72)
	RE -> RE . OPDISEQG RE                              (rule 73)
	RE -> RE . OPDISEQGE RE                             (rule 74)
	RE -> RE . OPEQ RE                                  (rule 75)
	RE -> RE . OPNEQ RE                                 (rule 76)
	RE -> RE . OR RE                                    (rule 77)
	RE -> RE . AND RE                                   (rule 78)
	RE -> RE . XOR RE                                   (rule 79)

	END            reduce using rule 69
	CLOSER         reduce using rule 69
	OPENQ          reduce using rule 69
	CLOSEQ         reduce using rule 69
	OPENG          reduce using rule 69
	COMMA          reduce using rule 69
	SEMICOL        reduce using rule 69
	UGUALE         reduce using rule 69
	AST            reduce using rule 69
	PLUS           reduce using rule 69
	MINUS          reduce using rule 69
	DIV            reduce using rule 69
	POW            shift, and enter state 133
	OPEQ           reduce using rule 69
	OPNEQ          reduce using rule 69
	OPDISEQL       reduce using rule 69
	OPDISEQLE      reduce using rule 69
	OPDISEQG       reduce using rule 69
	OPDISEQGE      reduce using rule 69
	AND            reduce using rule 69
	OR             reduce using rule 69
	XOR            reduce using rule 69


State 157

	RE -> RE . PLUS RE                                  (rule 66)
	RE -> RE . MINUS RE                                 (rule 67)
	RE -> RE MINUS RE .                                 (rule 67)
	RE -> RE . AST RE                                   (rule 68)
	RE -> RE . DIV RE                                   (rule 69)
	RE -> RE . POW RE                                   (rule 70)
	RE -> RE . OPDISEQL RE                              (rule 71)
	RE -> RE . OPDISEQLE RE                             (rule 72)
	RE -> RE . OPDISEQG RE                              (rule 73)
	RE -> RE . OPDISEQGE RE                             (rule 74)
	RE -> RE . OPEQ RE                                  (rule 75)
	RE -> RE . OPNEQ RE                                 (rule 76)
	RE -> RE . OR RE                                    (rule 77)
	RE -> RE . AND RE                                   (rule 78)
	RE -> RE . XOR RE                                   (rule 79)

	END            reduce using rule 67
	CLOSER         reduce using rule 67
	OPENQ          reduce using rule 67
	CLOSEQ         reduce using rule 67
	OPENG          reduce using rule 67
	COMMA          reduce using rule 67
	SEMICOL        reduce using rule 67
	UGUALE         reduce using rule 67
	AST            shift, and enter state 129
	PLUS           reduce using rule 67
	MINUS          reduce using rule 67
	DIV            shift, and enter state 132
	POW            shift, and enter state 133
	OPEQ           reduce using rule 67
	OPNEQ          reduce using rule 67
	OPDISEQL       reduce using rule 67
	OPDISEQLE      reduce using rule 67
	OPDISEQG       reduce using rule 67
	OPDISEQGE      reduce using rule 67
	AND            reduce using rule 67
	OR             reduce using rule 67
	XOR            reduce using rule 67


State 158

	RE -> RE . PLUS RE                                  (rule 66)
	RE -> RE PLUS RE .                                  (rule 66)
	RE -> RE . MINUS RE                                 (rule 67)
	RE -> RE . AST RE                                   (rule 68)
	RE -> RE . DIV RE                                   (rule 69)
	RE -> RE . POW RE                                   (rule 70)
	RE -> RE . OPDISEQL RE                              (rule 71)
	RE -> RE . OPDISEQLE RE                             (rule 72)
	RE -> RE . OPDISEQG RE                              (rule 73)
	RE -> RE . OPDISEQGE RE                             (rule 74)
	RE -> RE . OPEQ RE                                  (rule 75)
	RE -> RE . OPNEQ RE                                 (rule 76)
	RE -> RE . OR RE                                    (rule 77)
	RE -> RE . AND RE                                   (rule 78)
	RE -> RE . XOR RE                                   (rule 79)

	END            reduce using rule 66
	CLOSER         reduce using rule 66
	OPENQ          reduce using rule 66
	CLOSEQ         reduce using rule 66
	OPENG          reduce using rule 66
	COMMA          reduce using rule 66
	SEMICOL        reduce using rule 66
	UGUALE         reduce using rule 66
	AST            shift, and enter state 129
	PLUS           reduce using rule 66
	MINUS          shift, and enter state 131
	DIV            shift, and enter state 132
	POW            shift, and enter state 133
	OPEQ           reduce using rule 66
	OPNEQ          reduce using rule 66
	OPDISEQL       reduce using rule 66
	OPDISEQLE      reduce using rule 66
	OPDISEQG       reduce using rule 66
	OPDISEQGE      reduce using rule 66
	AND            reduce using rule 66
	OR             reduce using rule 66
	XOR            reduce using rule 66


State 159

	RE -> RE . PLUS RE                                  (rule 66)
	RE -> RE . MINUS RE                                 (rule 67)
	RE -> RE . AST RE                                   (rule 68)
	RE -> RE AST RE .                                   (rule 68)
	RE -> RE . DIV RE                                   (rule 69)
	RE -> RE . POW RE                                   (rule 70)
	RE -> RE . OPDISEQL RE                              (rule 71)
	RE -> RE . OPDISEQLE RE                             (rule 72)
	RE -> RE . OPDISEQG RE                              (rule 73)
	RE -> RE . OPDISEQGE RE                             (rule 74)
	RE -> RE . OPEQ RE                                  (rule 75)
	RE -> RE . OPNEQ RE                                 (rule 76)
	RE -> RE . OR RE                                    (rule 77)
	RE -> RE . AND RE                                   (rule 78)
	RE -> RE . XOR RE                                   (rule 79)

	END            reduce using rule 68
	CLOSER         reduce using rule 68
	OPENQ          reduce using rule 68
	CLOSEQ         reduce using rule 68
	OPENG          reduce using rule 68
	COMMA          reduce using rule 68
	SEMICOL        reduce using rule 68
	UGUALE         reduce using rule 68
	AST            reduce using rule 68
	PLUS           reduce using rule 68
	MINUS          reduce using rule 68
	DIV            shift, and enter state 132
	POW            shift, and enter state 133
	OPEQ           reduce using rule 68
	OPNEQ          reduce using rule 68
	OPDISEQL       reduce using rule 68
	OPDISEQLE      reduce using rule 68
	OPDISEQG       reduce using rule 68
	OPDISEQGE      reduce using rule 68
	AND            reduce using rule 68
	OR             reduce using rule 68
	XOR            reduce using rule 68


State 160

	RE -> RE . PLUS RE                                  (rule 66)
	RE -> RE . MINUS RE                                 (rule 67)
	RE -> RE . AST RE                                   (rule 68)
	RE -> RE . DIV RE                                   (rule 69)
	RE -> RE . POW RE                                   (rule 70)
	RE -> RE . OPDISEQL RE                              (rule 71)
	RE -> RE . OPDISEQLE RE                             (rule 72)
	RE -> RE . OPDISEQG RE                              (rule 73)
	RE -> RE . OPDISEQGE RE                             (rule 74)
	RE -> RE . OPEQ RE                                  (rule 75)
	RE -> RE . OPNEQ RE                                 (rule 76)
	RE -> RE . OR RE                                    (rule 77)
	RE -> RE . AND RE                                   (rule 78)
	RE -> RE . XOR RE                                   (rule 79)
	RE -> LE UGUALE RE .                                (rule 84)

	END            reduce using rule 84
	CLOSER         reduce using rule 84
	OPENQ          reduce using rule 84
	CLOSEQ         reduce using rule 84
	OPENG          reduce using rule 84
	COMMA          reduce using rule 84
	SEMICOL        reduce using rule 84
	UGUALE         reduce using rule 84
	AST            shift, and enter state 129
	PLUS           shift, and enter state 130
	MINUS          shift, and enter state 131
	DIV            shift, and enter state 132
	POW            shift, and enter state 133
	OPEQ           shift, and enter state 134
	OPNEQ          shift, and enter state 135
	OPDISEQL       shift, and enter state 136
	OPDISEQLE      shift, and enter state 137
	OPDISEQG       shift, and enter state 138
	OPDISEQGE      shift, and enter state 139
	AND            shift, and enter state 140
	OR             shift, and enter state 141
	XOR            shift, and enter state 142


State 161

	RE -> RE . PLUS RE                                  (rule 66)
	RE -> RE . MINUS RE                                 (rule 67)
	RE -> RE . AST RE                                   (rule 68)
	RE -> RE . DIV RE                                   (rule 69)
	RE -> RE . POW RE                                   (rule 70)
	RE -> RE . OPDISEQL RE                              (rule 71)
	RE -> RE . OPDISEQLE RE                             (rule 72)
	RE -> RE . OPDISEQG RE                              (rule 73)
	RE -> RE . OPDISEQGE RE                             (rule 74)
	RE -> RE . OPEQ RE                                  (rule 75)
	RE -> RE . OPNEQ RE                                 (rule 76)
	RE -> RE . OR RE                                    (rule 77)
	RE -> RE . AND RE                                   (rule 78)
	RE -> RE . XOR RE                                   (rule 79)
	LE -> LE OPENQ RE . CLOSEQ                          (rule 94)

	CLOSEQ         shift, and enter state 188
	AST            shift, and enter state 129
	PLUS           shift, and enter state 130
	MINUS          shift, and enter state 131
	DIV            shift, and enter state 132
	POW            shift, and enter state 133
	OPEQ           shift, and enter state 134
	OPNEQ          shift, and enter state 135
	OPDISEQL       shift, and enter state 136
	OPDISEQLE      shift, and enter state 137
	OPDISEQG       shift, and enter state 138
	OPDISEQGE      shift, and enter state 139
	AND            shift, and enter state 140
	OR             shift, and enter state 141
	XOR            shift, and enter state 142


State 162

	Stm -> VAR IDENT Tipo . END                         (rule 60)
	Stm -> VAR IDENT Tipo . UGUALE Valori END           (rule 61)

	END            shift, and enter state 186
	UGUALE         shift, and enter state 187


State 163

	Stm -> VAR OPENR END . VarLine CLOSER END           (rule 62)

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

	VarLine        goto state 185

State 164

	RE -> OPENR RE CLOSER .                             (rule 80)

	END            reduce using rule 80
	CLOSER         reduce using rule 80
	OPENQ          reduce using rule 80
	CLOSEQ         reduce using rule 80
	OPENG          reduce using rule 80
	COMMA          reduce using rule 80
	SEMICOL        reduce using rule 80
	UGUALE         reduce using rule 80
	AST            reduce using rule 80
	PLUS           reduce using rule 80
	MINUS          reduce using rule 80
	DIV            reduce using rule 80
	POW            reduce using rule 80
	OPEQ           reduce using rule 80
	OPNEQ          reduce using rule 80
	OPDISEQL       reduce using rule 80
	OPDISEQLE      reduce using rule 80
	OPDISEQG       reduce using rule 80
	OPDISEQGE      reduce using rule 80
	AND            reduce using rule 80
	OR             reduce using rule 80
	XOR            reduce using rule 80


State 165

	Stm -> TRY Blocco CATCH . Blocco                    (rule 54)

	OPENG          shift, and enter state 80

	Blocco         goto state 184

State 166

	Stm -> RETURN RE END .                              (rule 57)

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


State 167

	RE -> RE . PLUS RE                                  (rule 66)
	RE -> RE . MINUS RE                                 (rule 67)
	RE -> RE . AST RE                                   (rule 68)
	RE -> RE . DIV RE                                   (rule 69)
	RE -> RE . POW RE                                   (rule 70)
	RE -> RE . OPDISEQL RE                              (rule 71)
	RE -> RE . OPDISEQLE RE                             (rule 72)
	RE -> RE . OPDISEQG RE                              (rule 73)
	RE -> RE . OPDISEQGE RE                             (rule 74)
	RE -> RE . OPEQ RE                                  (rule 75)
	RE -> RE . OPNEQ RE                                 (rule 76)
	RE -> RE . OR RE                                    (rule 77)
	RE -> RE . AND RE                                   (rule 78)
	RE -> RE . XOR RE                                   (rule 79)
	ListParAttNE -> RE .                                (rule 90)

	CLOSER         reduce using rule 90
	COMMA          reduce using rule 90
	AST            shift, and enter state 129
	PLUS           shift, and enter state 130
	MINUS          shift, and enter state 131
	DIV            shift, and enter state 132
	POW            shift, and enter state 133
	OPEQ           shift, and enter state 134
	OPNEQ          shift, and enter state 135
	OPDISEQL       shift, and enter state 136
	OPDISEQLE      shift, and enter state 137
	OPDISEQG       shift, and enter state 138
	OPDISEQGE      shift, and enter state 139
	AND            shift, and enter state 140
	OR             shift, and enter state 141
	XOR            shift, and enter state 142


State 168

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

	CLOSER         shift, and enter state 183


State 169

	ListParAtt -> ListParAttNE .                        (rule 89)
	ListParAttNE -> ListParAttNE . COMMA RE             (rule 91)

	CLOSER         reduce using rule 89
	COMMA          shift, and enter state 182


State 170

	Stm -> FOR RE Blocco .                              (rule 47)

	VAR            reduce using 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
	CONTINUE       reduce using rule 47
	BREAK          reduce using rule 47
	MINUS          reduce using rule 47
	NOT            reduce using rule 47
	DEPUNT         reduce using rule 47


State 171

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

	OPENR          shift, and enter state 95
	IDENT          shift, and enter state 98
	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52
	AST            shift, and enter state 99
	MINUS          shift, and enter state 105
	NOT            shift, and enter state 106
	DEPUNT         shift, and enter state 107

	Valori         goto state 88
	RE             goto state 181
	LE             goto state 93

State 172

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

	VAR            reduce using 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
	ELSE           shift, and enter state 180
	SWITCH         reduce using rule 49
	CASE           reduce using rule 49
	DEFAULT        reduce using rule 49
	CONTINUE       reduce using rule 49
	BREAK          reduce using rule 49
	MINUS          reduce using rule 49
	NOT            reduce using rule 49
	DEPUNT         reduce using rule 49


State 173

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

	ELSE           shift, and enter state 179


State 174

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

	END            shift, and enter state 178


State 175

	Stm -> SWITCH IDENT BloccoSw .                      (rule 52)

	VAR            reduce using 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
	CONTINUE       reduce using rule 52
	BREAK          reduce using rule 52
	MINUS          reduce using rule 52
	NOT            reduce using rule 52
	DEPUNT         reduce using rule 52


State 176

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

	END            shift, and enter state 177


State 177

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

	CLOSEG         reduce using rule 63
	CASE           shift, and enter state 198
	DEFAULT        shift, and enter state 199

	Lcase          goto state 197

State 178

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

	VAR            shift, and enter state 94
	END            reduce using rule 44
	OPENR          shift, and enter state 95
	OPENG          shift, and enter state 80
	CLOSEG         reduce using rule 44
	TRY            shift, and enter state 96
	RETURN         shift, and enter state 97
	IDENT          shift, and enter state 98
	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52
	AST            shift, and enter state 99
	FOR            shift, and enter state 100
	IF             shift, and enter state 101
	SWITCH         shift, and enter state 102
	CONTINUE       shift, and enter state 103
	BREAK          shift, and enter state 104
	MINUS          shift, and enter state 105
	NOT            shift, and enter state 106
	DEPUNT         shift, and enter state 107

	Valori         goto state 88
	Blocco         goto state 89
	Lstm           goto state 196
	Stm            goto state 91
	RE             goto state 92
	LE             goto state 93

State 179

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

	OPENG          shift, and enter state 80

	Blocco         goto state 195

State 180

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

	OPENG          shift, and enter state 80

	Blocco         goto state 194

State 181

	Stm -> FOR RE SEMICOL RE . SEMICOL RE Blocco        (rule 46)
	RE -> RE . PLUS RE                                  (rule 66)
	RE -> RE . MINUS RE                                 (rule 67)
	RE -> RE . AST RE                                   (rule 68)
	RE -> RE . DIV RE                                   (rule 69)
	RE -> RE . POW RE                                   (rule 70)
	RE -> RE . OPDISEQL RE                              (rule 71)
	RE -> RE . OPDISEQLE RE                             (rule 72)
	RE -> RE . OPDISEQG RE                              (rule 73)
	RE -> RE . OPDISEQGE RE                             (rule 74)
	RE -> RE . OPEQ RE                                  (rule 75)
	RE -> RE . OPNEQ RE                                 (rule 76)
	RE -> RE . OR RE                                    (rule 77)
	RE -> RE . AND RE                                   (rule 78)
	RE -> RE . XOR RE                                   (rule 79)

	SEMICOL        shift, and enter state 193
	AST            shift, and enter state 129
	PLUS           shift, and enter state 130
	MINUS          shift, and enter state 131
	DIV            shift, and enter state 132
	POW            shift, and enter state 133
	OPEQ           shift, and enter state 134
	OPNEQ          shift, and enter state 135
	OPDISEQL       shift, and enter state 136
	OPDISEQLE      shift, and enter state 137
	OPDISEQG       shift, and enter state 138
	OPDISEQGE      shift, and enter state 139
	AND            shift, and enter state 140
	OR             shift, and enter state 141
	XOR            shift, and enter state 142


State 182

	ListParAttNE -> ListParAttNE COMMA . RE             (rule 91)

	OPENR          shift, and enter state 95
	IDENT          shift, and enter state 98
	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52
	AST            shift, and enter state 99
	MINUS          shift, and enter state 105
	NOT            shift, and enter state 106
	DEPUNT         shift, and enter state 107

	Valori         goto state 88
	RE             goto state 192
	LE             goto state 93

State 183

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

	END            reduce using rule 85
	CLOSER         reduce using rule 85
	OPENQ          reduce using rule 85
	CLOSEQ         reduce using rule 85
	OPENG          reduce using rule 85
	COMMA          reduce using rule 85
	SEMICOL        reduce using rule 85
	UGUALE         reduce using rule 85
	AST            reduce using rule 85
	PLUS           reduce using rule 85
	MINUS          reduce using rule 85
	DIV            reduce using rule 85
	POW            reduce using rule 85
	OPEQ           reduce using rule 85
	OPNEQ          reduce using rule 85
	OPDISEQL       reduce using rule 85
	OPDISEQLE      reduce using rule 85
	OPDISEQG       reduce using rule 85
	OPDISEQGE      reduce using rule 85
	AND            reduce using rule 85
	OR             reduce using rule 85
	XOR            reduce using rule 85


State 184

	Stm -> TRY Blocco CATCH Blocco .                    (rule 54)

	VAR            reduce using 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
	CONTINUE       reduce using rule 54
	BREAK          reduce using rule 54
	MINUS          reduce using rule 54
	NOT            reduce using rule 54
	DEPUNT         reduce using rule 54


State 185

	Stm -> VAR OPENR END VarLine . CLOSER END           (rule 62)

	CLOSER         shift, and enter state 191


State 186

	Stm -> VAR IDENT Tipo END .                         (rule 60)

	VAR            reduce using rule 60
	END            reduce using rule 60
	OPENR          reduce using rule 60
	OPENG          reduce using rule 60
	CLOSEG         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            reduce using rule 60
	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
	CONTINUE       reduce using rule 60
	BREAK          reduce using rule 60
	MINUS          reduce using rule 60
	NOT            reduce using rule 60
	DEPUNT         reduce using rule 60


State 187

	Stm -> VAR IDENT Tipo UGUALE . Valori END           (rule 61)

	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52

	Valori         goto state 190

State 188

	LE -> LE OPENQ RE CLOSEQ .                          (rule 94)

	END            reduce using rule 94
	CLOSER         reduce using rule 94
	OPENQ          reduce using rule 94
	CLOSEQ         reduce using rule 94
	OPENG          reduce using rule 94
	COMMA          reduce using rule 94
	SEMICOL        reduce using rule 94
	UGUALE         reduce using rule 94
	AST            reduce using rule 94
	PLUS           reduce using rule 94
	MINUS          reduce using rule 94
	DIV            reduce using rule 94
	POW            reduce using rule 94
	OPEQ           reduce using rule 94
	OPNEQ          reduce using rule 94
	OPDISEQL       reduce using rule 94
	OPDISEQLE      reduce using rule 94
	OPDISEQG       reduce using rule 94
	OPDISEQGE      reduce using rule 94
	AND            reduce using rule 94
	OR             reduce using rule 94
	XOR            reduce using rule 94


State 189

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

	VAR            reduce using 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
	CATCH          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
	ELSE           reduce using rule 41
	SWITCH         reduce using rule 41
	CASE           reduce using rule 41
	DEFAULT        reduce using rule 41
	CONTINUE       reduce using rule 41
	BREAK          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 190

	Stm -> VAR IDENT Tipo UGUALE Valori . END           (rule 61)

	END            shift, and enter state 206


State 191

	Stm -> VAR OPENR END VarLine CLOSER . END           (rule 62)

	END            shift, and enter state 205


State 192

	RE -> RE . PLUS RE                                  (rule 66)
	RE -> RE . MINUS RE                                 (rule 67)
	RE -> RE . AST RE                                   (rule 68)
	RE -> RE . DIV RE                                   (rule 69)
	RE -> RE . POW RE                                   (rule 70)
	RE -> RE . OPDISEQL RE                              (rule 71)
	RE -> RE . OPDISEQLE RE                             (rule 72)
	RE -> RE . OPDISEQG RE                              (rule 73)
	RE -> RE . OPDISEQGE RE                             (rule 74)
	RE -> RE . OPEQ RE                                  (rule 75)
	RE -> RE . OPNEQ RE                                 (rule 76)
	RE -> RE . OR RE                                    (rule 77)
	RE -> RE . AND RE                                   (rule 78)
	RE -> RE . XOR RE                                   (rule 79)
	ListParAttNE -> ListParAttNE COMMA RE .             (rule 91)

	CLOSER         reduce using rule 91
	COMMA          reduce using rule 91
	AST            shift, and enter state 129
	PLUS           shift, and enter state 130
	MINUS          shift, and enter state 131
	DIV            shift, and enter state 132
	POW            shift, and enter state 133
	OPEQ           shift, and enter state 134
	OPNEQ          shift, and enter state 135
	OPDISEQL       shift, and enter state 136
	OPDISEQLE      shift, and enter state 137
	OPDISEQG       shift, and enter state 138
	OPDISEQGE      shift, and enter state 139
	AND            shift, and enter state 140
	OR             shift, and enter state 141
	XOR            shift, and enter state 142


State 193

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

	OPENR          shift, and enter state 95
	IDENT          shift, and enter state 98
	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52
	AST            shift, and enter state 99
	MINUS          shift, and enter state 105
	NOT            shift, and enter state 106
	DEPUNT         shift, and enter state 107

	Valori         goto state 88
	RE             goto state 204
	LE             goto state 93

State 194

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

	VAR            reduce using 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
	CONTINUE       reduce using rule 50
	BREAK          reduce using rule 50
	MINUS          reduce using rule 50
	NOT            reduce using rule 50
	DEPUNT         reduce using rule 50


State 195

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

	VAR            reduce using 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
	CONTINUE       reduce using rule 51
	BREAK          reduce using rule 51
	MINUS          reduce using rule 51
	NOT            reduce using rule 51
	DEPUNT         reduce using rule 51


State 196

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

	END            shift, and enter state 83
	CLOSEG         reduce using rule 8

	OptEnd         goto state 203

State 197

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

	CLOSEG         shift, and enter state 202


State 198

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

	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52

	Valori         goto state 201

State 199

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

	COL            shift, and enter state 200


State 200

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

	VAR            shift, and enter state 94
	END            reduce using rule 44
	OPENR          shift, and enter state 95
	OPENG          shift, and enter state 80
	CLOSEG         reduce using rule 44
	TRY            shift, and enter state 96
	RETURN         shift, and enter state 97
	IDENT          shift, and enter state 98
	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52
	AST            shift, and enter state 99
	FOR            shift, and enter state 100
	IF             shift, and enter state 101
	SWITCH         shift, and enter state 102
	CONTINUE       shift, and enter state 103
	BREAK          shift, and enter state 104
	MINUS          shift, and enter state 105
	NOT            shift, and enter state 106
	DEPUNT         shift, and enter state 107

	Valori         goto state 88
	Blocco         goto state 89
	Lstm           goto state 211
	Stm            goto state 91
	RE             goto state 92
	LE             goto state 93

State 201

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

	COL            shift, and enter state 210


State 202

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

	END            shift, and enter state 209


State 203

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

	CLOSEG         shift, and enter state 208


State 204

	Stm -> FOR RE SEMICOL RE SEMICOL RE . Blocco        (rule 46)
	RE -> RE . PLUS RE                                  (rule 66)
	RE -> RE . MINUS RE                                 (rule 67)
	RE -> RE . AST RE                                   (rule 68)
	RE -> RE . DIV RE                                   (rule 69)
	RE -> RE . POW RE                                   (rule 70)
	RE -> RE . OPDISEQL RE                              (rule 71)
	RE -> RE . OPDISEQLE RE                             (rule 72)
	RE -> RE . OPDISEQG RE                              (rule 73)
	RE -> RE . OPDISEQGE RE                             (rule 74)
	RE -> RE . OPEQ RE                                  (rule 75)
	RE -> RE . OPNEQ RE                                 (rule 76)
	RE -> RE . OR RE                                    (rule 77)
	RE -> RE . AND RE                                   (rule 78)
	RE -> RE . XOR RE                                   (rule 79)

	OPENG          shift, and enter state 80
	AST            shift, and enter state 129
	PLUS           shift, and enter state 130
	MINUS          shift, and enter state 131
	DIV            shift, and enter state 132
	POW            shift, and enter state 133
	OPEQ           shift, and enter state 134
	OPNEQ          shift, and enter state 135
	OPDISEQL       shift, and enter state 136
	OPDISEQLE      shift, and enter state 137
	OPDISEQG       shift, and enter state 138
	OPDISEQGE      shift, and enter state 139
	AND            shift, and enter state 140
	OR             shift, and enter state 141
	XOR            shift, and enter state 142

	Blocco         goto state 207

State 205

	Stm -> VAR OPENR END VarLine CLOSER END .           (rule 62)

	VAR            reduce using rule 62
	END            reduce using rule 62
	OPENR          reduce using rule 62
	OPENG          reduce using rule 62
	CLOSEG         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            reduce using rule 62
	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
	CONTINUE       reduce using rule 62
	BREAK          reduce using rule 62
	MINUS          reduce using rule 62
	NOT            reduce using rule 62
	DEPUNT         reduce using rule 62


State 206

	Stm -> VAR IDENT Tipo UGUALE Valori END .           (rule 61)

	VAR            reduce using rule 61
	END            reduce using rule 61
	OPENR          reduce using rule 61
	OPENG          reduce using rule 61
	CLOSEG         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            reduce using rule 61
	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
	CONTINUE       reduce using rule 61
	BREAK          reduce using rule 61
	MINUS          reduce using rule 61
	NOT            reduce using rule 61
	DEPUNT         reduce using rule 61


State 207

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

	VAR            reduce using 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
	CONTINUE       reduce using rule 46
	BREAK          reduce using rule 46
	MINUS          reduce using rule 46
	NOT            reduce using rule 46
	DEPUNT         reduce using rule 46


State 208

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

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


State 209

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

	VAR            reduce using 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
	CONTINUE       reduce using rule 43
	BREAK          reduce using rule 43
	MINUS          reduce using rule 43
	NOT            reduce using rule 43
	DEPUNT         reduce using rule 43


State 210

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

	VAR            shift, and enter state 94
	END            reduce using rule 44
	OPENR          shift, and enter state 95
	OPENG          shift, and enter state 80
	CLOSEG         reduce using rule 44
	TRY            shift, and enter state 96
	RETURN         shift, and enter state 97
	IDENT          shift, and enter state 98
	BOOLEANO       shift, and enter state 48
	INTERO         shift, and enter state 49
	FLOAT          shift, and enter state 50
	STRINGA        shift, and enter state 51
	CHAR           shift, and enter state 52
	AST            shift, and enter state 99
	FOR            shift, and enter state 100
	IF             shift, and enter state 101
	SWITCH         shift, and enter state 102
	CASE           reduce using rule 44
	DEFAULT        reduce using rule 44
	CONTINUE       shift, and enter state 103
	BREAK          shift, and enter state 104
	MINUS          shift, and enter state 105
	NOT            shift, and enter state 106
	DEPUNT         shift, and enter state 107

	Valori         goto state 88
	Blocco         goto state 89
	Lstm           goto state 213
	Stm            goto state 91
	RE             goto state 92
	LE             goto state 93

State 211

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

	END            shift, and enter state 83
	CLOSEG         reduce using rule 8

	OptEnd         goto state 212

State 212

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

	CLOSEG         reduce using rule 65


State 213

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

	END            shift, and enter state 83
	CLOSEG         reduce using rule 8
	CASE           reduce using rule 8
	DEFAULT        reduce using rule 8

	OptEnd         goto state 214

State 214

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

	CLOSEG         reduce using rule 63
	CASE           shift, and enter state 198
	DEFAULT        shift, and enter state 199

	Lcase          goto state 215

State 215

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

	CLOSEG         reduce using rule 64


-----------------------------------------------------------------------------
Grammar Totals
-----------------------------------------------------------------------------
Number of rules: 95
Number of terminals: 57
Number of non-terminals: 24
Number of states: 216