parser.out

Created by PLY version 3.4 (http://www.dabeaz.com/ply)

Grammar

Rule 0     S' -> program
Rule 1     program -> declaration program
Rule 2     program -> declaration
Rule 3     declaration -> fun_declaration
Rule 4     declaration -> var_declaration
Rule 5     fun_declaration -> fun_type NAME LPAR formal_pars RPAR block SEMICOLON
Rule 6     fun_declaration -> fun_type NAME LPAR RPAR block SEMICOLON
Rule 7     fun_type -> VOID
Rule 8     fun_type -> INT
Rule 9     fun_type -> CHAR
Rule 10    fun_type -> BOOLEAN
Rule 11    type -> INT
Rule 12    type -> CHAR
Rule 13    type -> BOOLEAN
Rule 14    type -> type LBRACK exp RBRACK
Rule 15    formal_pars -> formal_pars COMMA formal_par
Rule 16    formal_pars -> formal_par
Rule 17    formal_par -> type NAME
Rule 18    block -> LBRACE var_declarations statements RBRACE
Rule 19    block -> LBRACE var_declarations RBRACE
Rule 20    var_declarations -> var_declaration var_declarations
Rule 21    var_declarations -> empty
Rule 22    var_declaration -> type NAME SEMICOLON
Rule 23    statements -> statements SEMICOLON statement
Rule 24    statements -> statement
Rule 25    statement -> block
Rule 26    statement -> RETURN exp
Rule 27    statement -> WRITE exp
Rule 28    statement -> READ lexp
Rule 29    statement -> NAME LPAR RPAR
Rule 30    statement -> NAME LPAR pars RPAR
Rule 31    statement -> WHILE LPAR exp RPAR statement
Rule 32    statement -> IF LPAR exp RPAR statement
Rule 33    statement -> IF LPAR exp RPAR statement ELSE statement
Rule 34    statement -> lexp ASSIGN exp
Rule 35    lexp -> var
Rule 36    lexp -> lexp LBRACK exp RBRACK
Rule 37    exp -> lexp
Rule 38    exp -> LENGTH lexp
Rule 39    exp -> unop exp
Rule 40    exp -> LPAR exp RPAR
Rule 41    exp -> exp AND exp
Rule 42    exp -> exp OR exp
Rule 43    exp -> NAME LPAR RPAR
Rule 44    exp -> NAME LPAR pars RPAR
Rule 45    exp -> NUMBER
Rule 46    exp -> QCHAR
Rule 47    exp -> exp MINUS exp
Rule 48    exp -> exp PLUS exp
Rule 49    exp -> exp TIMES exp
Rule 50    exp -> exp DIVIDE exp
Rule 51    exp -> exp EQUAL exp
Rule 52    exp -> exp NEQUAL exp
Rule 53    exp -> exp GREATER exp
Rule 54    exp -> exp LESS exp
Rule 55    exp -> exp GREATEREQ exp
Rule 56    exp -> exp LESSEQ exp
Rule 57    unop -> MINUS
Rule 58    unop -> NOT
Rule 59    pars -> pars COMMA exp
Rule 60    pars -> exp
Rule 61    var -> NAME
Rule 62    exp -> TRUE
Rule 63    exp -> FALSE
Rule 64    empty -> <empty>

Terminals, with rules where they appear

AND                  : 41
ASSIGN               : 34
BOOLEAN              : 10 13
CHAR                 : 9 12
COMMA                : 15 59
DIVIDE               : 50
ELSE                 : 33
EQUAL                : 51
FALSE                : 63
GREATER              : 53
GREATEREQ            : 55
IF                   : 32 33
INT                  : 8 11
LBRACE               : 18 19
LBRACK               : 14 36
LENGTH               : 38
LESS                 : 54
LESSEQ               : 56
LPAR                 : 5 6 29 30 31 32 33 40 43 44
MINUS                : 47 57
NAME                 : 5 6 17 22 29 30 43 44 61
NEQUAL               : 52
NOT                  : 58
NUMBER               : 45
OR                   : 42
PLUS                 : 48
QCHAR                : 46
RBRACE               : 18 19
RBRACK               : 14 36
READ                 : 28
RETURN               : 26
RPAR                 : 5 6 29 30 31 32 33 40 43 44
SEMICOLON            : 5 6 22 23
TIMES                : 49
TRUE                 : 62
VOID                 : 7
WHILE                : 31
WRITE                : 27
error                : 

Nonterminals, with rules where they appear

block                : 5 6 25
declaration          : 1 2
empty                : 21
exp                  : 14 26 27 31 32 33 34 36 39 40 41 41 42 42 47 47 48 48 49 49 50 50 51 51 52 52 53 53 54 54 55 55 56 56 59 60
formal_par           : 15 16
formal_pars          : 5 15
fun_declaration      : 3
fun_type             : 5 6
lexp                 : 28 34 36 37 38
pars                 : 30 44 59
program              : 1 0
statement            : 23 24 31 32 33 33
statements           : 18 23
type                 : 14 17 22
unop                 : 39
var                  : 35
var_declaration      : 4 20
var_declarations     : 18 19 20

Parsing method: LALR

state 0

    (0) S' -> . program
    (1) program -> . declaration program
    (2) program -> . declaration
    (3) declaration -> . fun_declaration
    (4) declaration -> . var_declaration
    (5) fun_declaration -> . fun_type NAME LPAR formal_pars RPAR block SEMICOLON
    (6) fun_declaration -> . fun_type NAME LPAR RPAR block SEMICOLON
    (22) var_declaration -> . type NAME SEMICOLON
    (7) fun_type -> . VOID
    (8) fun_type -> . INT
    (9) fun_type -> . CHAR
    (10) fun_type -> . BOOLEAN
    (11) type -> . INT
    (12) type -> . CHAR
    (13) type -> . BOOLEAN
    (14) type -> . type LBRACK exp RBRACK

    VOID            shift and go to state 5
    INT             shift and go to state 4
    CHAR            shift and go to state 6
    BOOLEAN         shift and go to state 1

    fun_type                       shift and go to state 2
    var_declaration                shift and go to state 3
    fun_declaration                shift and go to state 7
    program                        shift and go to state 8
    declaration                    shift and go to state 9
    type                           shift and go to state 10

state 1

    (10) fun_type -> BOOLEAN .
    (13) type -> BOOLEAN .

  ! reduce/reduce conflict for NAME resolved using rule 10 (fun_type -> BOOLEAN .)
    NAME            reduce using rule 10 (fun_type -> BOOLEAN .)
    LBRACK          reduce using rule 13 (type -> BOOLEAN .)

  ! NAME            [ reduce using rule 13 (type -> BOOLEAN .) ]


state 2

    (5) fun_declaration -> fun_type . NAME LPAR formal_pars RPAR block SEMICOLON
    (6) fun_declaration -> fun_type . NAME LPAR RPAR block SEMICOLON

    NAME            shift and go to state 11


state 3

    (4) declaration -> var_declaration .

    VOID            reduce using rule 4 (declaration -> var_declaration .)
    INT             reduce using rule 4 (declaration -> var_declaration .)
    CHAR            reduce using rule 4 (declaration -> var_declaration .)
    BOOLEAN         reduce using rule 4 (declaration -> var_declaration .)
    $end            reduce using rule 4 (declaration -> var_declaration .)


state 4

    (8) fun_type -> INT .
    (11) type -> INT .

  ! reduce/reduce conflict for NAME resolved using rule 8 (fun_type -> INT .)
    NAME            reduce using rule 8 (fun_type -> INT .)
    LBRACK          reduce using rule 11 (type -> INT .)

  ! NAME            [ reduce using rule 11 (type -> INT .) ]


state 5

    (7) fun_type -> VOID .

    NAME            reduce using rule 7 (fun_type -> VOID .)


state 6

    (9) fun_type -> CHAR .
    (12) type -> CHAR .

  ! reduce/reduce conflict for NAME resolved using rule 9 (fun_type -> CHAR .)
    NAME            reduce using rule 9 (fun_type -> CHAR .)
    LBRACK          reduce using rule 12 (type -> CHAR .)

  ! NAME            [ reduce using rule 12 (type -> CHAR .) ]


state 7

    (3) declaration -> fun_declaration .

    VOID            reduce using rule 3 (declaration -> fun_declaration .)
    INT             reduce using rule 3 (declaration -> fun_declaration .)
    CHAR            reduce using rule 3 (declaration -> fun_declaration .)
    BOOLEAN         reduce using rule 3 (declaration -> fun_declaration .)
    $end            reduce using rule 3 (declaration -> fun_declaration .)


state 8

    (0) S' -> program .



state 9

    (1) program -> declaration . program
    (2) program -> declaration .
    (1) program -> . declaration program
    (2) program -> . declaration
    (3) declaration -> . fun_declaration
    (4) declaration -> . var_declaration
    (5) fun_declaration -> . fun_type NAME LPAR formal_pars RPAR block SEMICOLON
    (6) fun_declaration -> . fun_type NAME LPAR RPAR block SEMICOLON
    (22) var_declaration -> . type NAME SEMICOLON
    (7) fun_type -> . VOID
    (8) fun_type -> . INT
    (9) fun_type -> . CHAR
    (10) fun_type -> . BOOLEAN
    (11) type -> . INT
    (12) type -> . CHAR
    (13) type -> . BOOLEAN
    (14) type -> . type LBRACK exp RBRACK

    $end            reduce using rule 2 (program -> declaration .)
    VOID            shift and go to state 5
    INT             shift and go to state 4
    CHAR            shift and go to state 6
    BOOLEAN         shift and go to state 1

    fun_type                       shift and go to state 2
    var_declaration                shift and go to state 3
    fun_declaration                shift and go to state 7
    program                        shift and go to state 12
    declaration                    shift and go to state 9
    type                           shift and go to state 10

state 10

    (22) var_declaration -> type . NAME SEMICOLON
    (14) type -> type . LBRACK exp RBRACK

    NAME            shift and go to state 13
    LBRACK          shift and go to state 14


state 11

    (5) fun_declaration -> fun_type NAME . LPAR formal_pars RPAR block SEMICOLON
    (6) fun_declaration -> fun_type NAME . LPAR RPAR block SEMICOLON

    LPAR            shift and go to state 15


state 12

    (1) program -> declaration program .

    $end            reduce using rule 1 (program -> declaration program .)


state 13

    (22) var_declaration -> type NAME . SEMICOLON

    SEMICOLON       shift and go to state 16


state 14

    (14) type -> type LBRACK . exp RBRACK
    (37) exp -> . lexp
    (38) exp -> . LENGTH lexp
    (39) exp -> . unop exp
    (40) exp -> . LPAR exp RPAR
    (41) exp -> . exp AND exp
    (42) exp -> . exp OR exp
    (43) exp -> . NAME LPAR RPAR
    (44) exp -> . NAME LPAR pars RPAR
    (45) exp -> . NUMBER
    (46) exp -> . QCHAR
    (47) exp -> . exp MINUS exp
    (48) exp -> . exp PLUS exp
    (49) exp -> . exp TIMES exp
    (50) exp -> . exp DIVIDE exp
    (51) exp -> . exp EQUAL exp
    (52) exp -> . exp NEQUAL exp
    (53) exp -> . exp GREATER exp
    (54) exp -> . exp LESS exp
    (55) exp -> . exp GREATEREQ exp
    (56) exp -> . exp LESSEQ exp
    (62) exp -> . TRUE
    (63) exp -> . FALSE
    (35) lexp -> . var
    (36) lexp -> . lexp LBRACK exp RBRACK
    (57) unop -> . MINUS
    (58) unop -> . NOT
    (61) var -> . NAME

    LENGTH          shift and go to state 27
    LPAR            shift and go to state 18
    NAME            shift and go to state 26
    NUMBER          shift and go to state 24
    QCHAR           shift and go to state 19
    TRUE            shift and go to state 20
    FALSE           shift and go to state 25
    MINUS           shift and go to state 21
    NOT             shift and go to state 29

    unop                           shift and go to state 17
    lexp                           shift and go to state 22
    exp                            shift and go to state 28
    var                            shift and go to state 23

state 15

    (5) fun_declaration -> fun_type NAME LPAR . formal_pars RPAR block SEMICOLON
    (6) fun_declaration -> fun_type NAME LPAR . RPAR block SEMICOLON
    (15) formal_pars -> . formal_pars COMMA formal_par
    (16) formal_pars -> . formal_par
    (17) formal_par -> . type NAME
    (11) type -> . INT
    (12) type -> . CHAR
    (13) type -> . BOOLEAN
    (14) type -> . type LBRACK exp RBRACK

    RPAR            shift and go to state 31
    INT             shift and go to state 30
    CHAR            shift and go to state 32
    BOOLEAN         shift and go to state 33

    formal_pars                    shift and go to state 35
    formal_par                     shift and go to state 34
    type                           shift and go to state 36

state 16

    (22) var_declaration -> type NAME SEMICOLON .

    VOID            reduce using rule 22 (var_declaration -> type NAME SEMICOLON .)
    INT             reduce using rule 22 (var_declaration -> type NAME SEMICOLON .)
    CHAR            reduce using rule 22 (var_declaration -> type NAME SEMICOLON .)
    BOOLEAN         reduce using rule 22 (var_declaration -> type NAME SEMICOLON .)
    $end            reduce using rule 22 (var_declaration -> type NAME SEMICOLON .)
    RBRACE          reduce using rule 22 (var_declaration -> type NAME SEMICOLON .)
    RETURN          reduce using rule 22 (var_declaration -> type NAME SEMICOLON .)
    WRITE           reduce using rule 22 (var_declaration -> type NAME SEMICOLON .)
    READ            reduce using rule 22 (var_declaration -> type NAME SEMICOLON .)
    NAME            reduce using rule 22 (var_declaration -> type NAME SEMICOLON .)
    WHILE           reduce using rule 22 (var_declaration -> type NAME SEMICOLON .)
    IF              reduce using rule 22 (var_declaration -> type NAME SEMICOLON .)
    LBRACE          reduce using rule 22 (var_declaration -> type NAME SEMICOLON .)


state 17

    (39) exp -> unop . exp
    (37) exp -> . lexp
    (38) exp -> . LENGTH lexp
    (39) exp -> . unop exp
    (40) exp -> . LPAR exp RPAR
    (41) exp -> . exp AND exp
    (42) exp -> . exp OR exp
    (43) exp -> . NAME LPAR RPAR
    (44) exp -> . NAME LPAR pars RPAR
    (45) exp -> . NUMBER
    (46) exp -> . QCHAR
    (47) exp -> . exp MINUS exp
    (48) exp -> . exp PLUS exp
    (49) exp -> . exp TIMES exp
    (50) exp -> . exp DIVIDE exp
    (51) exp -> . exp EQUAL exp
    (52) exp -> . exp NEQUAL exp
    (53) exp -> . exp GREATER exp
    (54) exp -> . exp LESS exp
    (55) exp -> . exp GREATEREQ exp
    (56) exp -> . exp LESSEQ exp
    (62) exp -> . TRUE
    (63) exp -> . FALSE
    (35) lexp -> . var
    (36) lexp -> . lexp LBRACK exp RBRACK
    (57) unop -> . MINUS
    (58) unop -> . NOT
    (61) var -> . NAME

    LENGTH          shift and go to state 27
    LPAR            shift and go to state 18
    NAME            shift and go to state 26
    NUMBER          shift and go to state 24
    QCHAR           shift and go to state 19
    TRUE            shift and go to state 20
    FALSE           shift and go to state 25
    MINUS           shift and go to state 21
    NOT             shift and go to state 29

    unop                           shift and go to state 17
    var                            shift and go to state 23
    lexp                           shift and go to state 22
    exp                            shift and go to state 37

state 18

    (40) exp -> LPAR . exp RPAR
    (37) exp -> . lexp
    (38) exp -> . LENGTH lexp
    (39) exp -> . unop exp
    (40) exp -> . LPAR exp RPAR
    (41) exp -> . exp AND exp
    (42) exp -> . exp OR exp
    (43) exp -> . NAME LPAR RPAR
    (44) exp -> . NAME LPAR pars RPAR
    (45) exp -> . NUMBER
    (46) exp -> . QCHAR
    (47) exp -> . exp MINUS exp
    (48) exp -> . exp PLUS exp
    (49) exp -> . exp TIMES exp
    (50) exp -> . exp DIVIDE exp
    (51) exp -> . exp EQUAL exp
    (52) exp -> . exp NEQUAL exp
    (53) exp -> . exp GREATER exp
    (54) exp -> . exp LESS exp
    (55) exp -> . exp GREATEREQ exp
    (56) exp -> . exp LESSEQ exp
    (62) exp -> . TRUE
    (63) exp -> . FALSE
    (35) lexp -> . var
    (36) lexp -> . lexp LBRACK exp RBRACK
    (57) unop -> . MINUS
    (58) unop -> . NOT
    (61) var -> . NAME

    LENGTH          shift and go to state 27
    LPAR            shift and go to state 18
    NAME            shift and go to state 26
    NUMBER          shift and go to state 24
    QCHAR           shift and go to state 19
    TRUE            shift and go to state 20
    FALSE           shift and go to state 25
    MINUS           shift and go to state 21
    NOT             shift and go to state 29

    unop                           shift and go to state 17
    var                            shift and go to state 23
    lexp                           shift and go to state 22
    exp                            shift and go to state 38

state 19

    (46) exp -> QCHAR .

    AND             reduce using rule 46 (exp -> QCHAR .)
    OR              reduce using rule 46 (exp -> QCHAR .)
    MINUS           reduce using rule 46 (exp -> QCHAR .)
    PLUS            reduce using rule 46 (exp -> QCHAR .)
    TIMES           reduce using rule 46 (exp -> QCHAR .)
    DIVIDE          reduce using rule 46 (exp -> QCHAR .)
    EQUAL           reduce using rule 46 (exp -> QCHAR .)
    NEQUAL          reduce using rule 46 (exp -> QCHAR .)
    GREATER         reduce using rule 46 (exp -> QCHAR .)
    LESS            reduce using rule 46 (exp -> QCHAR .)
    GREATEREQ       reduce using rule 46 (exp -> QCHAR .)
    LESSEQ          reduce using rule 46 (exp -> QCHAR .)
    RBRACK          reduce using rule 46 (exp -> QCHAR .)
    RPAR            reduce using rule 46 (exp -> QCHAR .)
    COMMA           reduce using rule 46 (exp -> QCHAR .)
    RBRACE          reduce using rule 46 (exp -> QCHAR .)
    SEMICOLON       reduce using rule 46 (exp -> QCHAR .)
    ELSE            reduce using rule 46 (exp -> QCHAR .)


state 20

    (62) exp -> TRUE .

    AND             reduce using rule 62 (exp -> TRUE .)
    OR              reduce using rule 62 (exp -> TRUE .)
    MINUS           reduce using rule 62 (exp -> TRUE .)
    PLUS            reduce using rule 62 (exp -> TRUE .)
    TIMES           reduce using rule 62 (exp -> TRUE .)
    DIVIDE          reduce using rule 62 (exp -> TRUE .)
    EQUAL           reduce using rule 62 (exp -> TRUE .)
    NEQUAL          reduce using rule 62 (exp -> TRUE .)
    GREATER         reduce using rule 62 (exp -> TRUE .)
    LESS            reduce using rule 62 (exp -> TRUE .)
    GREATEREQ       reduce using rule 62 (exp -> TRUE .)
    LESSEQ          reduce using rule 62 (exp -> TRUE .)
    RBRACK          reduce using rule 62 (exp -> TRUE .)
    RPAR            reduce using rule 62 (exp -> TRUE .)
    COMMA           reduce using rule 62 (exp -> TRUE .)
    RBRACE          reduce using rule 62 (exp -> TRUE .)
    SEMICOLON       reduce using rule 62 (exp -> TRUE .)
    ELSE            reduce using rule 62 (exp -> TRUE .)


state 21

    (57) unop -> MINUS .

    LENGTH          reduce using rule 57 (unop -> MINUS .)
    LPAR            reduce using rule 57 (unop -> MINUS .)
    NAME            reduce using rule 57 (unop -> MINUS .)
    NUMBER          reduce using rule 57 (unop -> MINUS .)
    QCHAR           reduce using rule 57 (unop -> MINUS .)
    TRUE            reduce using rule 57 (unop -> MINUS .)
    FALSE           reduce using rule 57 (unop -> MINUS .)
    MINUS           reduce using rule 57 (unop -> MINUS .)
    NOT             reduce using rule 57 (unop -> MINUS .)


state 22

    (37) exp -> lexp .
    (36) lexp -> lexp . LBRACK exp RBRACK

    AND             reduce using rule 37 (exp -> lexp .)
    OR              reduce using rule 37 (exp -> lexp .)
    MINUS           reduce using rule 37 (exp -> lexp .)
    PLUS            reduce using rule 37 (exp -> lexp .)
    TIMES           reduce using rule 37 (exp -> lexp .)
    DIVIDE          reduce using rule 37 (exp -> lexp .)
    EQUAL           reduce using rule 37 (exp -> lexp .)
    NEQUAL          reduce using rule 37 (exp -> lexp .)
    GREATER         reduce using rule 37 (exp -> lexp .)
    LESS            reduce using rule 37 (exp -> lexp .)
    GREATEREQ       reduce using rule 37 (exp -> lexp .)
    LESSEQ          reduce using rule 37 (exp -> lexp .)
    RBRACK          reduce using rule 37 (exp -> lexp .)
    RPAR            reduce using rule 37 (exp -> lexp .)
    COMMA           reduce using rule 37 (exp -> lexp .)
    RBRACE          reduce using rule 37 (exp -> lexp .)
    SEMICOLON       reduce using rule 37 (exp -> lexp .)
    ELSE            reduce using rule 37 (exp -> lexp .)
    LBRACK          shift and go to state 39


state 23

    (35) lexp -> var .

    LBRACK          reduce using rule 35 (lexp -> var .)
    RBRACK          reduce using rule 35 (lexp -> var .)
    AND             reduce using rule 35 (lexp -> var .)
    OR              reduce using rule 35 (lexp -> var .)
    MINUS           reduce using rule 35 (lexp -> var .)
    PLUS            reduce using rule 35 (lexp -> var .)
    TIMES           reduce using rule 35 (lexp -> var .)
    DIVIDE          reduce using rule 35 (lexp -> var .)
    EQUAL           reduce using rule 35 (lexp -> var .)
    NEQUAL          reduce using rule 35 (lexp -> var .)
    GREATER         reduce using rule 35 (lexp -> var .)
    LESS            reduce using rule 35 (lexp -> var .)
    GREATEREQ       reduce using rule 35 (lexp -> var .)
    LESSEQ          reduce using rule 35 (lexp -> var .)
    RPAR            reduce using rule 35 (lexp -> var .)
    COMMA           reduce using rule 35 (lexp -> var .)
    RBRACE          reduce using rule 35 (lexp -> var .)
    SEMICOLON       reduce using rule 35 (lexp -> var .)
    ELSE            reduce using rule 35 (lexp -> var .)
    ASSIGN          reduce using rule 35 (lexp -> var .)


state 24

    (45) exp -> NUMBER .

    AND             reduce using rule 45 (exp -> NUMBER .)
    OR              reduce using rule 45 (exp -> NUMBER .)
    MINUS           reduce using rule 45 (exp -> NUMBER .)
    PLUS            reduce using rule 45 (exp -> NUMBER .)
    TIMES           reduce using rule 45 (exp -> NUMBER .)
    DIVIDE          reduce using rule 45 (exp -> NUMBER .)
    EQUAL           reduce using rule 45 (exp -> NUMBER .)
    NEQUAL          reduce using rule 45 (exp -> NUMBER .)
    GREATER         reduce using rule 45 (exp -> NUMBER .)
    LESS            reduce using rule 45 (exp -> NUMBER .)
    GREATEREQ       reduce using rule 45 (exp -> NUMBER .)
    LESSEQ          reduce using rule 45 (exp -> NUMBER .)
    RBRACK          reduce using rule 45 (exp -> NUMBER .)
    RPAR            reduce using rule 45 (exp -> NUMBER .)
    COMMA           reduce using rule 45 (exp -> NUMBER .)
    RBRACE          reduce using rule 45 (exp -> NUMBER .)
    SEMICOLON       reduce using rule 45 (exp -> NUMBER .)
    ELSE            reduce using rule 45 (exp -> NUMBER .)


state 25

    (63) exp -> FALSE .

    AND             reduce using rule 63 (exp -> FALSE .)
    OR              reduce using rule 63 (exp -> FALSE .)
    MINUS           reduce using rule 63 (exp -> FALSE .)
    PLUS            reduce using rule 63 (exp -> FALSE .)
    TIMES           reduce using rule 63 (exp -> FALSE .)
    DIVIDE          reduce using rule 63 (exp -> FALSE .)
    EQUAL           reduce using rule 63 (exp -> FALSE .)
    NEQUAL          reduce using rule 63 (exp -> FALSE .)
    GREATER         reduce using rule 63 (exp -> FALSE .)
    LESS            reduce using rule 63 (exp -> FALSE .)
    GREATEREQ       reduce using rule 63 (exp -> FALSE .)
    LESSEQ          reduce using rule 63 (exp -> FALSE .)
    RBRACK          reduce using rule 63 (exp -> FALSE .)
    RPAR            reduce using rule 63 (exp -> FALSE .)
    COMMA           reduce using rule 63 (exp -> FALSE .)
    RBRACE          reduce using rule 63 (exp -> FALSE .)
    SEMICOLON       reduce using rule 63 (exp -> FALSE .)
    ELSE            reduce using rule 63 (exp -> FALSE .)


state 26

    (43) exp -> NAME . LPAR RPAR
    (44) exp -> NAME . LPAR pars RPAR
    (61) var -> NAME .

    LPAR            shift and go to state 40
    LBRACK          reduce using rule 61 (var -> NAME .)
    AND             reduce using rule 61 (var -> NAME .)
    OR              reduce using rule 61 (var -> NAME .)
    MINUS           reduce using rule 61 (var -> NAME .)
    PLUS            reduce using rule 61 (var -> NAME .)
    TIMES           reduce using rule 61 (var -> NAME .)
    DIVIDE          reduce using rule 61 (var -> NAME .)
    EQUAL           reduce using rule 61 (var -> NAME .)
    NEQUAL          reduce using rule 61 (var -> NAME .)
    GREATER         reduce using rule 61 (var -> NAME .)
    LESS            reduce using rule 61 (var -> NAME .)
    GREATEREQ       reduce using rule 61 (var -> NAME .)
    LESSEQ          reduce using rule 61 (var -> NAME .)
    RBRACK          reduce using rule 61 (var -> NAME .)
    RPAR            reduce using rule 61 (var -> NAME .)
    COMMA           reduce using rule 61 (var -> NAME .)
    RBRACE          reduce using rule 61 (var -> NAME .)
    SEMICOLON       reduce using rule 61 (var -> NAME .)
    ELSE            reduce using rule 61 (var -> NAME .)


state 27

    (38) exp -> LENGTH . lexp
    (35) lexp -> . var
    (36) lexp -> . lexp LBRACK exp RBRACK
    (61) var -> . NAME

    NAME            shift and go to state 42

    var                            shift and go to state 23
    lexp                           shift and go to state 41

state 28

    (14) type -> type LBRACK exp . RBRACK
    (41) exp -> exp . AND exp
    (42) exp -> exp . OR exp
    (47) exp -> exp . MINUS exp
    (48) exp -> exp . PLUS exp
    (49) exp -> exp . TIMES exp
    (50) exp -> exp . DIVIDE exp
    (51) exp -> exp . EQUAL exp
    (52) exp -> exp . NEQUAL exp
    (53) exp -> exp . GREATER exp
    (54) exp -> exp . LESS exp
    (55) exp -> exp . GREATEREQ exp
    (56) exp -> exp . LESSEQ exp

    RBRACK          shift and go to state 47
    AND             shift and go to state 43
    OR              shift and go to state 54
    MINUS           shift and go to state 49
    PLUS            shift and go to state 52
    TIMES           shift and go to state 53
    DIVIDE          shift and go to state 44
    EQUAL           shift and go to state 46
    NEQUAL          shift and go to state 48
    GREATER         shift and go to state 55
    LESS            shift and go to state 45
    GREATEREQ       shift and go to state 50
    LESSEQ          shift and go to state 51


state 29

    (58) unop -> NOT .

    LENGTH          reduce using rule 58 (unop -> NOT .)
    LPAR            reduce using rule 58 (unop -> NOT .)
    NAME            reduce using rule 58 (unop -> NOT .)
    NUMBER          reduce using rule 58 (unop -> NOT .)
    QCHAR           reduce using rule 58 (unop -> NOT .)
    TRUE            reduce using rule 58 (unop -> NOT .)
    FALSE           reduce using rule 58 (unop -> NOT .)
    MINUS           reduce using rule 58 (unop -> NOT .)
    NOT             reduce using rule 58 (unop -> NOT .)


state 30

    (11) type -> INT .

    NAME            reduce using rule 11 (type -> INT .)
    LBRACK          reduce using rule 11 (type -> INT .)


state 31

    (6) fun_declaration -> fun_type NAME LPAR RPAR . block SEMICOLON
    (18) block -> . LBRACE var_declarations statements RBRACE
    (19) block -> . LBRACE var_declarations RBRACE

    LBRACE          shift and go to state 56

    block                          shift and go to state 57

state 32

    (12) type -> CHAR .

    NAME            reduce using rule 12 (type -> CHAR .)
    LBRACK          reduce using rule 12 (type -> CHAR .)


state 33

    (13) type -> BOOLEAN .

    NAME            reduce using rule 13 (type -> BOOLEAN .)
    LBRACK          reduce using rule 13 (type -> BOOLEAN .)


state 34

    (16) formal_pars -> formal_par .

    RPAR            reduce using rule 16 (formal_pars -> formal_par .)
    COMMA           reduce using rule 16 (formal_pars -> formal_par .)


state 35

    (5) fun_declaration -> fun_type NAME LPAR formal_pars . RPAR block SEMICOLON
    (15) formal_pars -> formal_pars . COMMA formal_par

    RPAR            shift and go to state 58
    COMMA           shift and go to state 59


state 36

    (17) formal_par -> type . NAME
    (14) type -> type . LBRACK exp RBRACK

    NAME            shift and go to state 60
    LBRACK          shift and go to state 14


state 37

    (39) exp -> unop exp .
    (41) exp -> exp . AND exp
    (42) exp -> exp . OR exp
    (47) exp -> exp . MINUS exp
    (48) exp -> exp . PLUS exp
    (49) exp -> exp . TIMES exp
    (50) exp -> exp . DIVIDE exp
    (51) exp -> exp . EQUAL exp
    (52) exp -> exp . NEQUAL exp
    (53) exp -> exp . GREATER exp
    (54) exp -> exp . LESS exp
    (55) exp -> exp . GREATEREQ exp
    (56) exp -> exp . LESSEQ exp

  ! shift/reduce conflict for AND resolved as shift
  ! shift/reduce conflict for OR resolved as shift
  ! shift/reduce conflict for MINUS resolved as shift
  ! shift/reduce conflict for PLUS resolved as shift
  ! shift/reduce conflict for TIMES resolved as shift
  ! shift/reduce conflict for DIVIDE resolved as shift
  ! shift/reduce conflict for EQUAL resolved as shift
  ! shift/reduce conflict for NEQUAL resolved as shift
  ! shift/reduce conflict for GREATER resolved as shift
  ! shift/reduce conflict for LESS resolved as shift
  ! shift/reduce conflict for GREATEREQ resolved as shift
  ! shift/reduce conflict for LESSEQ resolved as shift
    RBRACK          reduce using rule 39 (exp -> unop exp .)
    RPAR            reduce using rule 39 (exp -> unop exp .)
    COMMA           reduce using rule 39 (exp -> unop exp .)
    RBRACE          reduce using rule 39 (exp -> unop exp .)
    SEMICOLON       reduce using rule 39 (exp -> unop exp .)
    ELSE            reduce using rule 39 (exp -> unop exp .)
    AND             shift and go to state 43
    OR              shift and go to state 54
    MINUS           shift and go to state 49
    PLUS            shift and go to state 52
    TIMES           shift and go to state 53
    DIVIDE          shift and go to state 44
    EQUAL           shift and go to state 46
    NEQUAL          shift and go to state 48
    GREATER         shift and go to state 55
    LESS            shift and go to state 45
    GREATEREQ       shift and go to state 50
    LESSEQ          shift and go to state 51

  ! AND             [ reduce using rule 39 (exp -> unop exp .) ]
  ! OR              [ reduce using rule 39 (exp -> unop exp .) ]
  ! MINUS           [ reduce using rule 39 (exp -> unop exp .) ]
  ! PLUS            [ reduce using rule 39 (exp -> unop exp .) ]
  ! TIMES           [ reduce using rule 39 (exp -> unop exp .) ]
  ! DIVIDE          [ reduce using rule 39 (exp -> unop exp .) ]
  ! EQUAL           [ reduce using rule 39 (exp -> unop exp .) ]
  ! NEQUAL          [ reduce using rule 39 (exp -> unop exp .) ]
  ! GREATER         [ reduce using rule 39 (exp -> unop exp .) ]
  ! LESS            [ reduce using rule 39 (exp -> unop exp .) ]
  ! GREATEREQ       [ reduce using rule 39 (exp -> unop exp .) ]
  ! LESSEQ          [ reduce using rule 39 (exp -> unop exp .) ]


state 38

    (40) exp -> LPAR exp . RPAR
    (41) exp -> exp . AND exp
    (42) exp -> exp . OR exp
    (47) exp -> exp . MINUS exp
    (48) exp -> exp . PLUS exp
    (49) exp -> exp . TIMES exp
    (50) exp -> exp . DIVIDE exp
    (51) exp -> exp . EQUAL exp
    (52) exp -> exp . NEQUAL exp
    (53) exp -> exp . GREATER exp
    (54) exp -> exp . LESS exp
    (55) exp -> exp . GREATEREQ exp
    (56) exp -> exp . LESSEQ exp

    RPAR            shift and go to state 61
    AND             shift and go to state 43
    OR              shift and go to state 54
    MINUS           shift and go to state 49
    PLUS            shift and go to state 52
    TIMES           shift and go to state 53
    DIVIDE          shift and go to state 44
    EQUAL           shift and go to state 46
    NEQUAL          shift and go to state 48
    GREATER         shift and go to state 55
    LESS            shift and go to state 45
    GREATEREQ       shift and go to state 50
    LESSEQ          shift and go to state 51


state 39

    (36) lexp -> lexp LBRACK . exp RBRACK
    (37) exp -> . lexp
    (38) exp -> . LENGTH lexp
    (39) exp -> . unop exp
    (40) exp -> . LPAR exp RPAR
    (41) exp -> . exp AND exp
    (42) exp -> . exp OR exp
    (43) exp -> . NAME LPAR RPAR
    (44) exp -> . NAME LPAR pars RPAR
    (45) exp -> . NUMBER
    (46) exp -> . QCHAR
    (47) exp -> . exp MINUS exp
    (48) exp -> . exp PLUS exp
    (49) exp -> . exp TIMES exp
    (50) exp -> . exp DIVIDE exp
    (51) exp -> . exp EQUAL exp
    (52) exp -> . exp NEQUAL exp
    (53) exp -> . exp GREATER exp
    (54) exp -> . exp LESS exp
    (55) exp -> . exp GREATEREQ exp
    (56) exp -> . exp LESSEQ exp
    (62) exp -> . TRUE
    (63) exp -> . FALSE
    (35) lexp -> . var
    (36) lexp -> . lexp LBRACK exp RBRACK
    (57) unop -> . MINUS
    (58) unop -> . NOT
    (61) var -> . NAME

    LENGTH          shift and go to state 27
    LPAR            shift and go to state 18
    NAME            shift and go to state 26
    NUMBER          shift and go to state 24
    QCHAR           shift and go to state 19
    TRUE            shift and go to state 20
    FALSE           shift and go to state 25
    MINUS           shift and go to state 21
    NOT             shift and go to state 29

    unop                           shift and go to state 17
    var                            shift and go to state 23
    lexp                           shift and go to state 22
    exp                            shift and go to state 62

state 40

    (43) exp -> NAME LPAR . RPAR
    (44) exp -> NAME LPAR . pars RPAR
    (59) pars -> . pars COMMA exp
    (60) pars -> . exp
    (37) exp -> . lexp
    (38) exp -> . LENGTH lexp
    (39) exp -> . unop exp
    (40) exp -> . LPAR exp RPAR
    (41) exp -> . exp AND exp
    (42) exp -> . exp OR exp
    (43) exp -> . NAME LPAR RPAR
    (44) exp -> . NAME LPAR pars RPAR
    (45) exp -> . NUMBER
    (46) exp -> . QCHAR
    (47) exp -> . exp MINUS exp
    (48) exp -> . exp PLUS exp
    (49) exp -> . exp TIMES exp
    (50) exp -> . exp DIVIDE exp
    (51) exp -> . exp EQUAL exp
    (52) exp -> . exp NEQUAL exp
    (53) exp -> . exp GREATER exp
    (54) exp -> . exp LESS exp
    (55) exp -> . exp GREATEREQ exp
    (56) exp -> . exp LESSEQ exp
    (62) exp -> . TRUE
    (63) exp -> . FALSE
    (35) lexp -> . var
    (36) lexp -> . lexp LBRACK exp RBRACK
    (57) unop -> . MINUS
    (58) unop -> . NOT
    (61) var -> . NAME

    RPAR            shift and go to state 63
    LENGTH          shift and go to state 27
    LPAR            shift and go to state 18
    NAME            shift and go to state 26
    NUMBER          shift and go to state 24
    QCHAR           shift and go to state 19
    TRUE            shift and go to state 20
    FALSE           shift and go to state 25
    MINUS           shift and go to state 21
    NOT             shift and go to state 29

    unop                           shift and go to state 17
    var                            shift and go to state 23
    pars                           shift and go to state 64
    lexp                           shift and go to state 22
    exp                            shift and go to state 65

state 41

    (38) exp -> LENGTH lexp .
    (36) lexp -> lexp . LBRACK exp RBRACK

    AND             reduce using rule 38 (exp -> LENGTH lexp .)
    OR              reduce using rule 38 (exp -> LENGTH lexp .)
    MINUS           reduce using rule 38 (exp -> LENGTH lexp .)
    PLUS            reduce using rule 38 (exp -> LENGTH lexp .)
    TIMES           reduce using rule 38 (exp -> LENGTH lexp .)
    DIVIDE          reduce using rule 38 (exp -> LENGTH lexp .)
    EQUAL           reduce using rule 38 (exp -> LENGTH lexp .)
    NEQUAL          reduce using rule 38 (exp -> LENGTH lexp .)
    GREATER         reduce using rule 38 (exp -> LENGTH lexp .)
    LESS            reduce using rule 38 (exp -> LENGTH lexp .)
    GREATEREQ       reduce using rule 38 (exp -> LENGTH lexp .)
    LESSEQ          reduce using rule 38 (exp -> LENGTH lexp .)
    RBRACK          reduce using rule 38 (exp -> LENGTH lexp .)
    RPAR            reduce using rule 38 (exp -> LENGTH lexp .)
    COMMA           reduce using rule 38 (exp -> LENGTH lexp .)
    RBRACE          reduce using rule 38 (exp -> LENGTH lexp .)
    SEMICOLON       reduce using rule 38 (exp -> LENGTH lexp .)
    ELSE            reduce using rule 38 (exp -> LENGTH lexp .)
    LBRACK          shift and go to state 39


state 42

    (61) var -> NAME .

    LBRACK          reduce using rule 61 (var -> NAME .)
    RBRACE          reduce using rule 61 (var -> NAME .)
    SEMICOLON       reduce using rule 61 (var -> NAME .)
    ELSE            reduce using rule 61 (var -> NAME .)
    RBRACK          reduce using rule 61 (var -> NAME .)
    AND             reduce using rule 61 (var -> NAME .)
    OR              reduce using rule 61 (var -> NAME .)
    MINUS           reduce using rule 61 (var -> NAME .)
    PLUS            reduce using rule 61 (var -> NAME .)
    TIMES           reduce using rule 61 (var -> NAME .)
    DIVIDE          reduce using rule 61 (var -> NAME .)
    EQUAL           reduce using rule 61 (var -> NAME .)
    NEQUAL          reduce using rule 61 (var -> NAME .)
    GREATER         reduce using rule 61 (var -> NAME .)
    LESS            reduce using rule 61 (var -> NAME .)
    GREATEREQ       reduce using rule 61 (var -> NAME .)
    LESSEQ          reduce using rule 61 (var -> NAME .)
    RPAR            reduce using rule 61 (var -> NAME .)
    COMMA           reduce using rule 61 (var -> NAME .)


state 43

    (41) exp -> exp AND . exp
    (37) exp -> . lexp
    (38) exp -> . LENGTH lexp
    (39) exp -> . unop exp
    (40) exp -> . LPAR exp RPAR
    (41) exp -> . exp AND exp
    (42) exp -> . exp OR exp
    (43) exp -> . NAME LPAR RPAR
    (44) exp -> . NAME LPAR pars RPAR
    (45) exp -> . NUMBER
    (46) exp -> . QCHAR
    (47) exp -> . exp MINUS exp
    (48) exp -> . exp PLUS exp
    (49) exp -> . exp TIMES exp
    (50) exp -> . exp DIVIDE exp
    (51) exp -> . exp EQUAL exp
    (52) exp -> . exp NEQUAL exp
    (53) exp -> . exp GREATER exp
    (54) exp -> . exp LESS exp
    (55) exp -> . exp GREATEREQ exp
    (56) exp -> . exp LESSEQ exp
    (62) exp -> . TRUE
    (63) exp -> . FALSE
    (35) lexp -> . var
    (36) lexp -> . lexp LBRACK exp RBRACK
    (57) unop -> . MINUS
    (58) unop -> . NOT
    (61) var -> . NAME

    LENGTH          shift and go to state 27
    LPAR            shift and go to state 18
    NAME            shift and go to state 26
    NUMBER          shift and go to state 24
    QCHAR           shift and go to state 19
    TRUE            shift and go to state 20
    FALSE           shift and go to state 25
    MINUS           shift and go to state 21
    NOT             shift and go to state 29

    unop                           shift and go to state 17
    var                            shift and go to state 23
    lexp                           shift and go to state 22
    exp                            shift and go to state 66

state 44

    (50) exp -> exp DIVIDE . exp
    (37) exp -> . lexp
    (38) exp -> . LENGTH lexp
    (39) exp -> . unop exp
    (40) exp -> . LPAR exp RPAR
    (41) exp -> . exp AND exp
    (42) exp -> . exp OR exp
    (43) exp -> . NAME LPAR RPAR
    (44) exp -> . NAME LPAR pars RPAR
    (45) exp -> . NUMBER
    (46) exp -> . QCHAR
    (47) exp -> . exp MINUS exp
    (48) exp -> . exp PLUS exp
    (49) exp -> . exp TIMES exp
    (50) exp -> . exp DIVIDE exp
    (51) exp -> . exp EQUAL exp
    (52) exp -> . exp NEQUAL exp
    (53) exp -> . exp GREATER exp
    (54) exp -> . exp LESS exp
    (55) exp -> . exp GREATEREQ exp
    (56) exp -> . exp LESSEQ exp
    (62) exp -> . TRUE
    (63) exp -> . FALSE
    (35) lexp -> . var
    (36) lexp -> . lexp LBRACK exp RBRACK
    (57) unop -> . MINUS
    (58) unop -> . NOT
    (61) var -> . NAME

    LENGTH          shift and go to state 27
    LPAR            shift and go to state 18
    NAME            shift and go to state 26
    NUMBER          shift and go to state 24
    QCHAR           shift and go to state 19
    TRUE            shift and go to state 20
    FALSE           shift and go to state 25
    MINUS           shift and go to state 21
    NOT             shift and go to state 29

    unop                           shift and go to state 17
    var                            shift and go to state 23
    lexp                           shift and go to state 22
    exp                            shift and go to state 67

state 45

    (54) exp -> exp LESS . exp
    (37) exp -> . lexp
    (38) exp -> . LENGTH lexp
    (39) exp -> . unop exp
    (40) exp -> . LPAR exp RPAR
    (41) exp -> . exp AND exp
    (42) exp -> . exp OR exp
    (43) exp -> . NAME LPAR RPAR
    (44) exp -> . NAME LPAR pars RPAR
    (45) exp -> . NUMBER
    (46) exp -> . QCHAR
    (47) exp -> . exp MINUS exp
    (48) exp -> . exp PLUS exp
    (49) exp -> . exp TIMES exp
    (50) exp -> . exp DIVIDE exp
    (51) exp -> . exp EQUAL exp
    (52) exp -> . exp NEQUAL exp
    (53) exp -> . exp GREATER exp
    (54) exp -> . exp LESS exp
    (55) exp -> . exp GREATEREQ exp
    (56) exp -> . exp LESSEQ exp
    (62) exp -> . TRUE
    (63) exp -> . FALSE
    (35) lexp -> . var
    (36) lexp -> . lexp LBRACK exp RBRACK
    (57) unop -> . MINUS
    (58) unop -> . NOT
    (61) var -> . NAME

    LENGTH          shift and go to state 27
    LPAR            shift and go to state 18
    NAME            shift and go to state 26
    NUMBER          shift and go to state 24
    QCHAR           shift and go to state 19
    TRUE            shift and go to state 20
    FALSE           shift and go to state 25
    MINUS           shift and go to state 21
    NOT             shift and go to state 29

    unop                           shift and go to state 17
    var                            shift and go to state 23
    lexp                           shift and go to state 22
    exp                            shift and go to state 68

state 46

    (51) exp -> exp EQUAL . exp
    (37) exp -> . lexp
    (38) exp -> . LENGTH lexp
    (39) exp -> . unop exp
    (40) exp -> . LPAR exp RPAR
    (41) exp -> . exp AND exp
    (42) exp -> . exp OR exp
    (43) exp -> . NAME LPAR RPAR
    (44) exp -> . NAME LPAR pars RPAR
    (45) exp -> . NUMBER
    (46) exp -> . QCHAR
    (47) exp -> . exp MINUS exp
    (48) exp -> . exp PLUS exp
    (49) exp -> . exp TIMES exp
    (50) exp -> . exp DIVIDE exp
    (51) exp -> . exp EQUAL exp
    (52) exp -> . exp NEQUAL exp
    (53) exp -> . exp GREATER exp
    (54) exp -> . exp LESS exp
    (55) exp -> . exp GREATEREQ exp
    (56) exp -> . exp LESSEQ exp
    (62) exp -> . TRUE
    (63) exp -> . FALSE
    (35) lexp -> . var
    (36) lexp -> . lexp LBRACK exp RBRACK
    (57) unop -> . MINUS
    (58) unop -> . NOT
    (61) var -> . NAME

    LENGTH          shift and go to state 27
    LPAR            shift and go to state 18
    NAME            shift and go to state 26
    NUMBER          shift and go to state 24
    QCHAR           shift and go to state 19
    TRUE            shift and go to state 20
    FALSE           shift and go to state 25
    MINUS           shift and go to state 21
    NOT             shift and go to state 29

    unop                           shift and go to state 17
    var                            shift and go to state 23
    lexp                           shift and go to state 22
    exp                            shift and go to state 69

state 47

    (14) type -> type LBRACK exp RBRACK .

    NAME            reduce using rule 14 (type -> type LBRACK exp RBRACK .)
    LBRACK          reduce using rule 14 (type -> type LBRACK exp RBRACK .)


state 48

    (52) exp -> exp NEQUAL . exp
    (37) exp -> . lexp
    (38) exp -> . LENGTH lexp
    (39) exp -> . unop exp
    (40) exp -> . LPAR exp RPAR
    (41) exp -> . exp AND exp
    (42) exp -> . exp OR exp
    (43) exp -> . NAME LPAR RPAR
    (44) exp -> . NAME LPAR pars RPAR
    (45) exp -> . NUMBER
    (46) exp -> . QCHAR
    (47) exp -> . exp MINUS exp
    (48) exp -> . exp PLUS exp
    (49) exp -> . exp TIMES exp
    (50) exp -> . exp DIVIDE exp
    (51) exp -> . exp EQUAL exp
    (52) exp -> . exp NEQUAL exp
    (53) exp -> . exp GREATER exp
    (54) exp -> . exp LESS exp
    (55) exp -> . exp GREATEREQ exp
    (56) exp -> . exp LESSEQ exp
    (62) exp -> . TRUE
    (63) exp -> . FALSE
    (35) lexp -> . var
    (36) lexp -> . lexp LBRACK exp RBRACK
    (57) unop -> . MINUS
    (58) unop -> . NOT
    (61) var -> . NAME

    LENGTH          shift and go to state 27
    LPAR            shift and go to state 18
    NAME            shift and go to state 26
    NUMBER          shift and go to state 24
    QCHAR           shift and go to state 19
    TRUE            shift and go to state 20
    FALSE           shift and go to state 25
    MINUS           shift and go to state 21
    NOT             shift and go to state 29

    unop                           shift and go to state 17
    var                            shift and go to state 23
    lexp                           shift and go to state 22
    exp                            shift and go to state 70

state 49

    (47) exp -> exp MINUS . exp
    (37) exp -> . lexp
    (38) exp -> . LENGTH lexp
    (39) exp -> . unop exp
    (40) exp -> . LPAR exp RPAR
    (41) exp -> . exp AND exp
    (42) exp -> . exp OR exp
    (43) exp -> . NAME LPAR RPAR
    (44) exp -> . NAME LPAR pars RPAR
    (45) exp -> . NUMBER
    (46) exp -> . QCHAR
    (47) exp -> . exp MINUS exp
    (48) exp -> . exp PLUS exp
    (49) exp -> . exp TIMES exp
    (50) exp -> . exp DIVIDE exp
    (51) exp -> . exp EQUAL exp
    (52) exp -> . exp NEQUAL exp
    (53) exp -> . exp GREATER exp
    (54) exp -> . exp LESS exp
    (55) exp -> . exp GREATEREQ exp
    (56) exp -> . exp LESSEQ exp
    (62) exp -> . TRUE
    (63) exp -> . FALSE
    (35) lexp -> . var
    (36) lexp -> . lexp LBRACK exp RBRACK
    (57) unop -> . MINUS
    (58) unop -> . NOT
    (61) var -> . NAME

    LENGTH          shift and go to state 27
    LPAR            shift and go to state 18
    NAME            shift and go to state 26
    NUMBER          shift and go to state 24
    QCHAR           shift and go to state 19
    TRUE            shift and go to state 20
    FALSE           shift and go to state 25
    MINUS           shift and go to state 21
    NOT             shift and go to state 29

    unop                           shift and go to state 17
    var                            shift and go to state 23
    lexp                           shift and go to state 22
    exp                            shift and go to state 71

state 50

    (55) exp -> exp GREATEREQ . exp
    (37) exp -> . lexp
    (38) exp -> . LENGTH lexp
    (39) exp -> . unop exp
    (40) exp -> . LPAR exp RPAR
    (41) exp -> . exp AND exp
    (42) exp -> . exp OR exp
    (43) exp -> . NAME LPAR RPAR
    (44) exp -> . NAME LPAR pars RPAR
    (45) exp -> . NUMBER
    (46) exp -> . QCHAR
    (47) exp -> . exp MINUS exp
    (48) exp -> . exp PLUS exp
    (49) exp -> . exp TIMES exp
    (50) exp -> . exp DIVIDE exp
    (51) exp -> . exp EQUAL exp
    (52) exp -> . exp NEQUAL exp
    (53) exp -> . exp GREATER exp
    (54) exp -> . exp LESS exp
    (55) exp -> . exp GREATEREQ exp
    (56) exp -> . exp LESSEQ exp
    (62) exp -> . TRUE
    (63) exp -> . FALSE
    (35) lexp -> . var
    (36) lexp -> . lexp LBRACK exp RBRACK
    (57) unop -> . MINUS
    (58) unop -> . NOT
    (61) var -> . NAME

    LENGTH          shift and go to state 27
    LPAR            shift and go to state 18
    NAME            shift and go to state 26
    NUMBER          shift and go to state 24
    QCHAR           shift and go to state 19
    TRUE            shift and go to state 20
    FALSE           shift and go to state 25
    MINUS           shift and go to state 21
    NOT             shift and go to state 29

    unop                           shift and go to state 17
    var                            shift and go to state 23
    lexp                           shift and go to state 22
    exp                            shift and go to state 72

state 51

    (56) exp -> exp LESSEQ . exp
    (37) exp -> . lexp
    (38) exp -> . LENGTH lexp
    (39) exp -> . unop exp
    (40) exp -> . LPAR exp RPAR
    (41) exp -> . exp AND exp
    (42) exp -> . exp OR exp
    (43) exp -> . NAME LPAR RPAR
    (44) exp -> . NAME LPAR pars RPAR
    (45) exp -> . NUMBER
    (46) exp -> . QCHAR
    (47) exp -> . exp MINUS exp
    (48) exp -> . exp PLUS exp
    (49) exp -> . exp TIMES exp
    (50) exp -> . exp DIVIDE exp
    (51) exp -> . exp EQUAL exp
    (52) exp -> . exp NEQUAL exp
    (53) exp -> . exp GREATER exp
    (54) exp -> . exp LESS exp
    (55) exp -> . exp GREATEREQ exp
    (56) exp -> . exp LESSEQ exp
    (62) exp -> . TRUE
    (63) exp -> . FALSE
    (35) lexp -> . var
    (36) lexp -> . lexp LBRACK exp RBRACK
    (57) unop -> . MINUS
    (58) unop -> . NOT
    (61) var -> . NAME

    LENGTH          shift and go to state 27
    LPAR            shift and go to state 18
    NAME            shift and go to state 26
    NUMBER          shift and go to state 24
    QCHAR           shift and go to state 19
    TRUE            shift and go to state 20
    FALSE           shift and go to state 25
    MINUS           shift and go to state 21
    NOT             shift and go to state 29

    unop                           shift and go to state 17
    var                            shift and go to state 23
    lexp                           shift and go to state 22
    exp                            shift and go to state 73

state 52

    (48) exp -> exp PLUS . exp
    (37) exp -> . lexp
    (38) exp -> . LENGTH lexp
    (39) exp -> . unop exp
    (40) exp -> . LPAR exp RPAR
    (41) exp -> . exp AND exp
    (42) exp -> . exp OR exp
    (43) exp -> . NAME LPAR RPAR
    (44) exp -> . NAME LPAR pars RPAR
    (45) exp -> . NUMBER
    (46) exp -> . QCHAR
    (47) exp -> . exp MINUS exp
    (48) exp -> . exp PLUS exp
    (49) exp -> . exp TIMES exp
    (50) exp -> . exp DIVIDE exp
    (51) exp -> . exp EQUAL exp
    (52) exp -> . exp NEQUAL exp
    (53) exp -> . exp GREATER exp
    (54) exp -> . exp LESS exp
    (55) exp -> . exp GREATEREQ exp
    (56) exp -> . exp LESSEQ exp
    (62) exp -> . TRUE
    (63) exp -> . FALSE
    (35) lexp -> . var
    (36) lexp -> . lexp LBRACK exp RBRACK
    (57) unop -> . MINUS
    (58) unop -> . NOT
    (61) var -> . NAME

    LENGTH          shift and go to state 27
    LPAR            shift and go to state 18
    NAME            shift and go to state 26
    NUMBER          shift and go to state 24
    QCHAR           shift and go to state 19
    TRUE            shift and go to state 20
    FALSE           shift and go to state 25
    MINUS           shift and go to state 21
    NOT             shift and go to state 29

    unop                           shift and go to state 17
    var                            shift and go to state 23
    lexp                           shift and go to state 22
    exp                            shift and go to state 74

state 53

    (49) exp -> exp TIMES . exp
    (37) exp -> . lexp
    (38) exp -> . LENGTH lexp
    (39) exp -> . unop exp
    (40) exp -> . LPAR exp RPAR
    (41) exp -> . exp AND exp
    (42) exp -> . exp OR exp
    (43) exp -> . NAME LPAR RPAR
    (44) exp -> . NAME LPAR pars RPAR
    (45) exp -> . NUMBER
    (46) exp -> . QCHAR
    (47) exp -> . exp MINUS exp
    (48) exp -> . exp PLUS exp
    (49) exp -> . exp TIMES exp
    (50) exp -> . exp DIVIDE exp
    (51) exp -> . exp EQUAL exp
    (52) exp -> . exp NEQUAL exp
    (53) exp -> . exp GREATER exp
    (54) exp -> . exp LESS exp
    (55) exp -> . exp GREATEREQ exp
    (56) exp -> . exp LESSEQ exp
    (62) exp -> . TRUE
    (63) exp -> . FALSE
    (35) lexp -> . var
    (36) lexp -> . lexp LBRACK exp RBRACK
    (57) unop -> . MINUS
    (58) unop -> . NOT
    (61) var -> . NAME

    LENGTH          shift and go to state 27
    LPAR            shift and go to state 18
    NAME            shift and go to state 26
    NUMBER          shift and go to state 24
    QCHAR           shift and go to state 19
    TRUE            shift and go to state 20
    FALSE           shift and go to state 25
    MINUS           shift and go to state 21
    NOT             shift and go to state 29

    unop                           shift and go to state 17
    var                            shift and go to state 23
    lexp                           shift and go to state 22
    exp                            shift and go to state 75

state 54

    (42) exp -> exp OR . exp
    (37) exp -> . lexp
    (38) exp -> . LENGTH lexp
    (39) exp -> . unop exp
    (40) exp -> . LPAR exp RPAR
    (41) exp -> . exp AND exp
    (42) exp -> . exp OR exp
    (43) exp -> . NAME LPAR RPAR
    (44) exp -> . NAME LPAR pars RPAR
    (45) exp -> . NUMBER
    (46) exp -> . QCHAR
    (47) exp -> . exp MINUS exp
    (48) exp -> . exp PLUS exp
    (49) exp -> . exp TIMES exp
    (50) exp -> . exp DIVIDE exp
    (51) exp -> . exp EQUAL exp
    (52) exp -> . exp NEQUAL exp
    (53) exp -> . exp GREATER exp
    (54) exp -> . exp LESS exp
    (55) exp -> . exp GREATEREQ exp
    (56) exp -> . exp LESSEQ exp
    (62) exp -> . TRUE
    (63) exp -> . FALSE
    (35) lexp -> . var
    (36) lexp -> . lexp LBRACK exp RBRACK
    (57) unop -> . MINUS
    (58) unop -> . NOT
    (61) var -> . NAME

    LENGTH          shift and go to state 27
    LPAR            shift and go to state 18
    NAME            shift and go to state 26
    NUMBER          shift and go to state 24
    QCHAR           shift and go to state 19
    TRUE            shift and go to state 20
    FALSE           shift and go to state 25
    MINUS           shift and go to state 21
    NOT             shift and go to state 29

    unop                           shift and go to state 17
    var                            shift and go to state 23
    lexp                           shift and go to state 22
    exp                            shift and go to state 76

state 55

    (53) exp -> exp GREATER . exp
    (37) exp -> . lexp
    (38) exp -> . LENGTH lexp
    (39) exp -> . unop exp
    (40) exp -> . LPAR exp RPAR
    (41) exp -> . exp AND exp
    (42) exp -> . exp OR exp
    (43) exp -> . NAME LPAR RPAR
    (44) exp -> . NAME LPAR pars RPAR
    (45) exp -> . NUMBER
    (46) exp -> . QCHAR
    (47) exp -> . exp MINUS exp
    (48) exp -> . exp PLUS exp
    (49) exp -> . exp TIMES exp
    (50) exp -> . exp DIVIDE exp
    (51) exp -> . exp EQUAL exp
    (52) exp -> . exp NEQUAL exp
    (53) exp -> . exp GREATER exp
    (54) exp -> . exp LESS exp
    (55) exp -> . exp GREATEREQ exp
    (56) exp -> . exp LESSEQ exp
    (62) exp -> . TRUE
    (63) exp -> . FALSE
    (35) lexp -> . var
    (36) lexp -> . lexp LBRACK exp RBRACK
    (57) unop -> . MINUS
    (58) unop -> . NOT
    (61) var -> . NAME

    LENGTH          shift and go to state 27
    LPAR            shift and go to state 18
    NAME            shift and go to state 26
    NUMBER          shift and go to state 24
    QCHAR           shift and go to state 19
    TRUE            shift and go to state 20
    FALSE           shift and go to state 25
    MINUS           shift and go to state 21
    NOT             shift and go to state 29

    unop                           shift and go to state 17
    var                            shift and go to state 23
    lexp                           shift and go to state 22
    exp                            shift and go to state 77

state 56

    (18) block -> LBRACE . var_declarations statements RBRACE
    (19) block -> LBRACE . var_declarations RBRACE
    (20) var_declarations -> . var_declaration var_declarations
    (21) var_declarations -> . empty
    (22) var_declaration -> . type NAME SEMICOLON
    (64) empty -> .
    (11) type -> . INT
    (12) type -> . CHAR
    (13) type -> . BOOLEAN
    (14) type -> . type LBRACK exp RBRACK

    RBRACE          reduce using rule 64 (empty -> .)
    RETURN          reduce using rule 64 (empty -> .)
    WRITE           reduce using rule 64 (empty -> .)
    READ            reduce using rule 64 (empty -> .)
    NAME            reduce using rule 64 (empty -> .)
    WHILE           reduce using rule 64 (empty -> .)
    IF              reduce using rule 64 (empty -> .)
    LBRACE          reduce using rule 64 (empty -> .)
    INT             shift and go to state 30
    CHAR            shift and go to state 32
    BOOLEAN         shift and go to state 33

    var_declaration                shift and go to state 78
    var_declarations               shift and go to state 79
    type                           shift and go to state 10
    empty                          shift and go to state 80

state 57

    (6) fun_declaration -> fun_type NAME LPAR RPAR block . SEMICOLON

    SEMICOLON       shift and go to state 81


state 58

    (5) fun_declaration -> fun_type NAME LPAR formal_pars RPAR . block SEMICOLON
    (18) block -> . LBRACE var_declarations statements RBRACE
    (19) block -> . LBRACE var_declarations RBRACE

    LBRACE          shift and go to state 56

    block                          shift and go to state 82

state 59

    (15) formal_pars -> formal_pars COMMA . formal_par
    (17) formal_par -> . type NAME
    (11) type -> . INT
    (12) type -> . CHAR
    (13) type -> . BOOLEAN
    (14) type -> . type LBRACK exp RBRACK

    INT             shift and go to state 30
    CHAR            shift and go to state 32
    BOOLEAN         shift and go to state 33

    formal_par                     shift and go to state 83
    type                           shift and go to state 36

state 60

    (17) formal_par -> type NAME .

    RPAR            reduce using rule 17 (formal_par -> type NAME .)
    COMMA           reduce using rule 17 (formal_par -> type NAME .)


state 61

    (40) exp -> LPAR exp RPAR .

    AND             reduce using rule 40 (exp -> LPAR exp RPAR .)
    OR              reduce using rule 40 (exp -> LPAR exp RPAR .)
    MINUS           reduce using rule 40 (exp -> LPAR exp RPAR .)
    PLUS            reduce using rule 40 (exp -> LPAR exp RPAR .)
    TIMES           reduce using rule 40 (exp -> LPAR exp RPAR .)
    DIVIDE          reduce using rule 40 (exp -> LPAR exp RPAR .)
    EQUAL           reduce using rule 40 (exp -> LPAR exp RPAR .)
    NEQUAL          reduce using rule 40 (exp -> LPAR exp RPAR .)
    GREATER         reduce using rule 40 (exp -> LPAR exp RPAR .)
    LESS            reduce using rule 40 (exp -> LPAR exp RPAR .)
    GREATEREQ       reduce using rule 40 (exp -> LPAR exp RPAR .)
    LESSEQ          reduce using rule 40 (exp -> LPAR exp RPAR .)
    RBRACK          reduce using rule 40 (exp -> LPAR exp RPAR .)
    RPAR            reduce using rule 40 (exp -> LPAR exp RPAR .)
    COMMA           reduce using rule 40 (exp -> LPAR exp RPAR .)
    RBRACE          reduce using rule 40 (exp -> LPAR exp RPAR .)
    SEMICOLON       reduce using rule 40 (exp -> LPAR exp RPAR .)
    ELSE            reduce using rule 40 (exp -> LPAR exp RPAR .)


state 62

    (36) lexp -> lexp LBRACK exp . RBRACK
    (41) exp -> exp . AND exp
    (42) exp -> exp . OR exp
    (47) exp -> exp . MINUS exp
    (48) exp -> exp . PLUS exp
    (49) exp -> exp . TIMES exp
    (50) exp -> exp . DIVIDE exp
    (51) exp -> exp . EQUAL exp
    (52) exp -> exp . NEQUAL exp
    (53) exp -> exp . GREATER exp
    (54) exp -> exp . LESS exp
    (55) exp -> exp . GREATEREQ exp
    (56) exp -> exp . LESSEQ exp

    RBRACK          shift and go to state 84
    AND             shift and go to state 43
    OR              shift and go to state 54
    MINUS           shift and go to state 49
    PLUS            shift and go to state 52
    TIMES           shift and go to state 53
    DIVIDE          shift and go to state 44
    EQUAL           shift and go to state 46
    NEQUAL          shift and go to state 48
    GREATER         shift and go to state 55
    LESS            shift and go to state 45
    GREATEREQ       shift and go to state 50
    LESSEQ          shift and go to state 51


state 63

    (43) exp -> NAME LPAR RPAR .

    AND             reduce using rule 43 (exp -> NAME LPAR RPAR .)
    OR              reduce using rule 43 (exp -> NAME LPAR RPAR .)
    MINUS           reduce using rule 43 (exp -> NAME LPAR RPAR .)
    PLUS            reduce using rule 43 (exp -> NAME LPAR RPAR .)
    TIMES           reduce using rule 43 (exp -> NAME LPAR RPAR .)
    DIVIDE          reduce using rule 43 (exp -> NAME LPAR RPAR .)
    EQUAL           reduce using rule 43 (exp -> NAME LPAR RPAR .)
    NEQUAL          reduce using rule 43 (exp -> NAME LPAR RPAR .)
    GREATER         reduce using rule 43 (exp -> NAME LPAR RPAR .)
    LESS            reduce using rule 43 (exp -> NAME LPAR RPAR .)
    GREATEREQ       reduce using rule 43 (exp -> NAME LPAR RPAR .)
    LESSEQ          reduce using rule 43 (exp -> NAME LPAR RPAR .)
    RBRACK          reduce using rule 43 (exp -> NAME LPAR RPAR .)
    RPAR            reduce using rule 43 (exp -> NAME LPAR RPAR .)
    COMMA           reduce using rule 43 (exp -> NAME LPAR RPAR .)
    RBRACE          reduce using rule 43 (exp -> NAME LPAR RPAR .)
    SEMICOLON       reduce using rule 43 (exp -> NAME LPAR RPAR .)
    ELSE            reduce using rule 43 (exp -> NAME LPAR RPAR .)


state 64

    (44) exp -> NAME LPAR pars . RPAR
    (59) pars -> pars . COMMA exp

    RPAR            shift and go to state 85
    COMMA           shift and go to state 86


state 65

    (60) pars -> exp .
    (41) exp -> exp . AND exp
    (42) exp -> exp . OR exp
    (47) exp -> exp . MINUS exp
    (48) exp -> exp . PLUS exp
    (49) exp -> exp . TIMES exp
    (50) exp -> exp . DIVIDE exp
    (51) exp -> exp . EQUAL exp
    (52) exp -> exp . NEQUAL exp
    (53) exp -> exp . GREATER exp
    (54) exp -> exp . LESS exp
    (55) exp -> exp . GREATEREQ exp
    (56) exp -> exp . LESSEQ exp

    RPAR            reduce using rule 60 (pars -> exp .)
    COMMA           reduce using rule 60 (pars -> exp .)
    AND             shift and go to state 43
    OR              shift and go to state 54
    MINUS           shift and go to state 49
    PLUS            shift and go to state 52
    TIMES           shift and go to state 53
    DIVIDE          shift and go to state 44
    EQUAL           shift and go to state 46
    NEQUAL          shift and go to state 48
    GREATER         shift and go to state 55
    LESS            shift and go to state 45
    GREATEREQ       shift and go to state 50
    LESSEQ          shift and go to state 51


state 66

    (41) exp -> exp AND exp .
    (41) exp -> exp . AND exp
    (42) exp -> exp . OR exp
    (47) exp -> exp . MINUS exp
    (48) exp -> exp . PLUS exp
    (49) exp -> exp . TIMES exp
    (50) exp -> exp . DIVIDE exp
    (51) exp -> exp . EQUAL exp
    (52) exp -> exp . NEQUAL exp
    (53) exp -> exp . GREATER exp
    (54) exp -> exp . LESS exp
    (55) exp -> exp . GREATEREQ exp
    (56) exp -> exp . LESSEQ exp

    AND             reduce using rule 41 (exp -> exp AND exp .)
    OR              reduce using rule 41 (exp -> exp AND exp .)
    GREATEREQ       reduce using rule 41 (exp -> exp AND exp .)
    LESSEQ          reduce using rule 41 (exp -> exp AND exp .)
    RBRACK          reduce using rule 41 (exp -> exp AND exp .)
    RPAR            reduce using rule 41 (exp -> exp AND exp .)
    COMMA           reduce using rule 41 (exp -> exp AND exp .)
    RBRACE          reduce using rule 41 (exp -> exp AND exp .)
    SEMICOLON       reduce using rule 41 (exp -> exp AND exp .)
    ELSE            reduce using rule 41 (exp -> exp AND exp .)
    MINUS           shift and go to state 49
    PLUS            shift and go to state 52
    TIMES           shift and go to state 53
    DIVIDE          shift and go to state 44
    EQUAL           shift and go to state 46
    NEQUAL          shift and go to state 48
    GREATER         shift and go to state 55
    LESS            shift and go to state 45

  ! MINUS           [ reduce using rule 41 (exp -> exp AND exp .) ]
  ! PLUS            [ reduce using rule 41 (exp -> exp AND exp .) ]
  ! TIMES           [ reduce using rule 41 (exp -> exp AND exp .) ]
  ! DIVIDE          [ reduce using rule 41 (exp -> exp AND exp .) ]
  ! EQUAL           [ reduce using rule 41 (exp -> exp AND exp .) ]
  ! NEQUAL          [ reduce using rule 41 (exp -> exp AND exp .) ]
  ! GREATER         [ reduce using rule 41 (exp -> exp AND exp .) ]
  ! LESS            [ reduce using rule 41 (exp -> exp AND exp .) ]
  ! AND             [ shift and go to state 43 ]
  ! OR              [ shift and go to state 54 ]
  ! GREATEREQ       [ shift and go to state 50 ]
  ! LESSEQ          [ shift and go to state 51 ]


state 67

    (50) exp -> exp DIVIDE exp .
    (41) exp -> exp . AND exp
    (42) exp -> exp . OR exp
    (47) exp -> exp . MINUS exp
    (48) exp -> exp . PLUS exp
    (49) exp -> exp . TIMES exp
    (50) exp -> exp . DIVIDE exp
    (51) exp -> exp . EQUAL exp
    (52) exp -> exp . NEQUAL exp
    (53) exp -> exp . GREATER exp
    (54) exp -> exp . LESS exp
    (55) exp -> exp . GREATEREQ exp
    (56) exp -> exp . LESSEQ exp

    AND             reduce using rule 50 (exp -> exp DIVIDE exp .)
    OR              reduce using rule 50 (exp -> exp DIVIDE exp .)
    MINUS           reduce using rule 50 (exp -> exp DIVIDE exp .)
    PLUS            reduce using rule 50 (exp -> exp DIVIDE exp .)
    TIMES           reduce using rule 50 (exp -> exp DIVIDE exp .)
    DIVIDE          reduce using rule 50 (exp -> exp DIVIDE exp .)
    EQUAL           reduce using rule 50 (exp -> exp DIVIDE exp .)
    NEQUAL          reduce using rule 50 (exp -> exp DIVIDE exp .)
    GREATER         reduce using rule 50 (exp -> exp DIVIDE exp .)
    LESS            reduce using rule 50 (exp -> exp DIVIDE exp .)
    GREATEREQ       reduce using rule 50 (exp -> exp DIVIDE exp .)
    LESSEQ          reduce using rule 50 (exp -> exp DIVIDE exp .)
    RBRACK          reduce using rule 50 (exp -> exp DIVIDE exp .)
    RPAR            reduce using rule 50 (exp -> exp DIVIDE exp .)
    COMMA           reduce using rule 50 (exp -> exp DIVIDE exp .)
    RBRACE          reduce using rule 50 (exp -> exp DIVIDE exp .)
    SEMICOLON       reduce using rule 50 (exp -> exp DIVIDE exp .)
    ELSE            reduce using rule 50 (exp -> exp DIVIDE exp .)

  ! AND             [ shift and go to state 43 ]
  ! OR              [ shift and go to state 54 ]
  ! MINUS           [ shift and go to state 49 ]
  ! PLUS            [ shift and go to state 52 ]
  ! TIMES           [ shift and go to state 53 ]
  ! DIVIDE          [ shift and go to state 44 ]
  ! EQUAL           [ shift and go to state 46 ]
  ! NEQUAL          [ shift and go to state 48 ]
  ! GREATER         [ shift and go to state 55 ]
  ! LESS            [ shift and go to state 45 ]
  ! GREATEREQ       [ shift and go to state 50 ]
  ! LESSEQ          [ shift and go to state 51 ]


state 68

    (54) exp -> exp LESS exp .
    (41) exp -> exp . AND exp
    (42) exp -> exp . OR exp
    (47) exp -> exp . MINUS exp
    (48) exp -> exp . PLUS exp
    (49) exp -> exp . TIMES exp
    (50) exp -> exp . DIVIDE exp
    (51) exp -> exp . EQUAL exp
    (52) exp -> exp . NEQUAL exp
    (53) exp -> exp . GREATER exp
    (54) exp -> exp . LESS exp
    (55) exp -> exp . GREATEREQ exp
    (56) exp -> exp . LESSEQ exp

    AND             reduce using rule 54 (exp -> exp LESS exp .)
    OR              reduce using rule 54 (exp -> exp LESS exp .)
    EQUAL           reduce using rule 54 (exp -> exp LESS exp .)
    NEQUAL          reduce using rule 54 (exp -> exp LESS exp .)
    GREATER         reduce using rule 54 (exp -> exp LESS exp .)
    LESS            reduce using rule 54 (exp -> exp LESS exp .)
    GREATEREQ       reduce using rule 54 (exp -> exp LESS exp .)
    LESSEQ          reduce using rule 54 (exp -> exp LESS exp .)
    RBRACK          reduce using rule 54 (exp -> exp LESS exp .)
    RPAR            reduce using rule 54 (exp -> exp LESS exp .)
    COMMA           reduce using rule 54 (exp -> exp LESS exp .)
    RBRACE          reduce using rule 54 (exp -> exp LESS exp .)
    SEMICOLON       reduce using rule 54 (exp -> exp LESS exp .)
    ELSE            reduce using rule 54 (exp -> exp LESS exp .)
    MINUS           shift and go to state 49
    PLUS            shift and go to state 52
    TIMES           shift and go to state 53
    DIVIDE          shift and go to state 44

  ! MINUS           [ reduce using rule 54 (exp -> exp LESS exp .) ]
  ! PLUS            [ reduce using rule 54 (exp -> exp LESS exp .) ]
  ! TIMES           [ reduce using rule 54 (exp -> exp LESS exp .) ]
  ! DIVIDE          [ reduce using rule 54 (exp -> exp LESS exp .) ]
  ! AND             [ shift and go to state 43 ]
  ! OR              [ shift and go to state 54 ]
  ! EQUAL           [ shift and go to state 46 ]
  ! NEQUAL          [ shift and go to state 48 ]
  ! GREATER         [ shift and go to state 55 ]
  ! LESS            [ shift and go to state 45 ]
  ! GREATEREQ       [ shift and go to state 50 ]
  ! LESSEQ          [ shift and go to state 51 ]


state 69

    (51) exp -> exp EQUAL exp .
    (41) exp -> exp . AND exp
    (42) exp -> exp . OR exp
    (47) exp -> exp . MINUS exp
    (48) exp -> exp . PLUS exp
    (49) exp -> exp . TIMES exp
    (50) exp -> exp . DIVIDE exp
    (51) exp -> exp . EQUAL exp
    (52) exp -> exp . NEQUAL exp
    (53) exp -> exp . GREATER exp
    (54) exp -> exp . LESS exp
    (55) exp -> exp . GREATEREQ exp
    (56) exp -> exp . LESSEQ exp

    AND             reduce using rule 51 (exp -> exp EQUAL exp .)
    OR              reduce using rule 51 (exp -> exp EQUAL exp .)
    EQUAL           reduce using rule 51 (exp -> exp EQUAL exp .)
    NEQUAL          reduce using rule 51 (exp -> exp EQUAL exp .)
    GREATEREQ       reduce using rule 51 (exp -> exp EQUAL exp .)
    LESSEQ          reduce using rule 51 (exp -> exp EQUAL exp .)
    RBRACK          reduce using rule 51 (exp -> exp EQUAL exp .)
    RPAR            reduce using rule 51 (exp -> exp EQUAL exp .)
    COMMA           reduce using rule 51 (exp -> exp EQUAL exp .)
    RBRACE          reduce using rule 51 (exp -> exp EQUAL exp .)
    SEMICOLON       reduce using rule 51 (exp -> exp EQUAL exp .)
    ELSE            reduce using rule 51 (exp -> exp EQUAL exp .)
    MINUS           shift and go to state 49
    PLUS            shift and go to state 52
    TIMES           shift and go to state 53
    DIVIDE          shift and go to state 44
    GREATER         shift and go to state 55
    LESS            shift and go to state 45

  ! MINUS           [ reduce using rule 51 (exp -> exp EQUAL exp .) ]
  ! PLUS            [ reduce using rule 51 (exp -> exp EQUAL exp .) ]
  ! TIMES           [ reduce using rule 51 (exp -> exp EQUAL exp .) ]
  ! DIVIDE          [ reduce using rule 51 (exp -> exp EQUAL exp .) ]
  ! GREATER         [ reduce using rule 51 (exp -> exp EQUAL exp .) ]
  ! LESS            [ reduce using rule 51 (exp -> exp EQUAL exp .) ]
  ! AND             [ shift and go to state 43 ]
  ! OR              [ shift and go to state 54 ]
  ! EQUAL           [ shift and go to state 46 ]
  ! NEQUAL          [ shift and go to state 48 ]
  ! GREATEREQ       [ shift and go to state 50 ]
  ! LESSEQ          [ shift and go to state 51 ]


state 70

    (52) exp -> exp NEQUAL exp .
    (41) exp -> exp . AND exp
    (42) exp -> exp . OR exp
    (47) exp -> exp . MINUS exp
    (48) exp -> exp . PLUS exp
    (49) exp -> exp . TIMES exp
    (50) exp -> exp . DIVIDE exp
    (51) exp -> exp . EQUAL exp
    (52) exp -> exp . NEQUAL exp
    (53) exp -> exp . GREATER exp
    (54) exp -> exp . LESS exp
    (55) exp -> exp . GREATEREQ exp
    (56) exp -> exp . LESSEQ exp

    AND             reduce using rule 52 (exp -> exp NEQUAL exp .)
    OR              reduce using rule 52 (exp -> exp NEQUAL exp .)
    EQUAL           reduce using rule 52 (exp -> exp NEQUAL exp .)
    NEQUAL          reduce using rule 52 (exp -> exp NEQUAL exp .)
    GREATEREQ       reduce using rule 52 (exp -> exp NEQUAL exp .)
    LESSEQ          reduce using rule 52 (exp -> exp NEQUAL exp .)
    RBRACK          reduce using rule 52 (exp -> exp NEQUAL exp .)
    RPAR            reduce using rule 52 (exp -> exp NEQUAL exp .)
    COMMA           reduce using rule 52 (exp -> exp NEQUAL exp .)
    RBRACE          reduce using rule 52 (exp -> exp NEQUAL exp .)
    SEMICOLON       reduce using rule 52 (exp -> exp NEQUAL exp .)
    ELSE            reduce using rule 52 (exp -> exp NEQUAL exp .)
    MINUS           shift and go to state 49
    PLUS            shift and go to state 52
    TIMES           shift and go to state 53
    DIVIDE          shift and go to state 44
    GREATER         shift and go to state 55
    LESS            shift and go to state 45

  ! MINUS           [ reduce using rule 52 (exp -> exp NEQUAL exp .) ]
  ! PLUS            [ reduce using rule 52 (exp -> exp NEQUAL exp .) ]
  ! TIMES           [ reduce using rule 52 (exp -> exp NEQUAL exp .) ]
  ! DIVIDE          [ reduce using rule 52 (exp -> exp NEQUAL exp .) ]
  ! GREATER         [ reduce using rule 52 (exp -> exp NEQUAL exp .) ]
  ! LESS            [ reduce using rule 52 (exp -> exp NEQUAL exp .) ]
  ! AND             [ shift and go to state 43 ]
  ! OR              [ shift and go to state 54 ]
  ! EQUAL           [ shift and go to state 46 ]
  ! NEQUAL          [ shift and go to state 48 ]
  ! GREATEREQ       [ shift and go to state 50 ]
  ! LESSEQ          [ shift and go to state 51 ]


state 71

    (47) exp -> exp MINUS exp .
    (41) exp -> exp . AND exp
    (42) exp -> exp . OR exp
    (47) exp -> exp . MINUS exp
    (48) exp -> exp . PLUS exp
    (49) exp -> exp . TIMES exp
    (50) exp -> exp . DIVIDE exp
    (51) exp -> exp . EQUAL exp
    (52) exp -> exp . NEQUAL exp
    (53) exp -> exp . GREATER exp
    (54) exp -> exp . LESS exp
    (55) exp -> exp . GREATEREQ exp
    (56) exp -> exp . LESSEQ exp

    AND             reduce using rule 47 (exp -> exp MINUS exp .)
    OR              reduce using rule 47 (exp -> exp MINUS exp .)
    MINUS           reduce using rule 47 (exp -> exp MINUS exp .)
    PLUS            reduce using rule 47 (exp -> exp MINUS exp .)
    EQUAL           reduce using rule 47 (exp -> exp MINUS exp .)
    NEQUAL          reduce using rule 47 (exp -> exp MINUS exp .)
    GREATER         reduce using rule 47 (exp -> exp MINUS exp .)
    LESS            reduce using rule 47 (exp -> exp MINUS exp .)
    GREATEREQ       reduce using rule 47 (exp -> exp MINUS exp .)
    LESSEQ          reduce using rule 47 (exp -> exp MINUS exp .)
    RBRACK          reduce using rule 47 (exp -> exp MINUS exp .)
    RPAR            reduce using rule 47 (exp -> exp MINUS exp .)
    COMMA           reduce using rule 47 (exp -> exp MINUS exp .)
    RBRACE          reduce using rule 47 (exp -> exp MINUS exp .)
    SEMICOLON       reduce using rule 47 (exp -> exp MINUS exp .)
    ELSE            reduce using rule 47 (exp -> exp MINUS exp .)
    TIMES           shift and go to state 53
    DIVIDE          shift and go to state 44

  ! TIMES           [ reduce using rule 47 (exp -> exp MINUS exp .) ]
  ! DIVIDE          [ reduce using rule 47 (exp -> exp MINUS exp .) ]
  ! AND             [ shift and go to state 43 ]
  ! OR              [ shift and go to state 54 ]
  ! MINUS           [ shift and go to state 49 ]
  ! PLUS            [ shift and go to state 52 ]
  ! EQUAL           [ shift and go to state 46 ]
  ! NEQUAL          [ shift and go to state 48 ]
  ! GREATER         [ shift and go to state 55 ]
  ! LESS            [ shift and go to state 45 ]
  ! GREATEREQ       [ shift and go to state 50 ]
  ! LESSEQ          [ shift and go to state 51 ]


state 72

    (55) exp -> exp GREATEREQ exp .
    (41) exp -> exp . AND exp
    (42) exp -> exp . OR exp
    (47) exp -> exp . MINUS exp
    (48) exp -> exp . PLUS exp
    (49) exp -> exp . TIMES exp
    (50) exp -> exp . DIVIDE exp
    (51) exp -> exp . EQUAL exp
    (52) exp -> exp . NEQUAL exp
    (53) exp -> exp . GREATER exp
    (54) exp -> exp . LESS exp
    (55) exp -> exp . GREATEREQ exp
    (56) exp -> exp . LESSEQ exp

  ! shift/reduce conflict for AND resolved as shift
  ! shift/reduce conflict for OR resolved as shift
  ! shift/reduce conflict for MINUS resolved as shift
  ! shift/reduce conflict for PLUS resolved as shift
  ! shift/reduce conflict for TIMES resolved as shift
  ! shift/reduce conflict for DIVIDE resolved as shift
  ! shift/reduce conflict for EQUAL resolved as shift
  ! shift/reduce conflict for NEQUAL resolved as shift
  ! shift/reduce conflict for GREATER resolved as shift
  ! shift/reduce conflict for LESS resolved as shift
  ! shift/reduce conflict for GREATEREQ resolved as shift
  ! shift/reduce conflict for LESSEQ resolved as shift
    RBRACK          reduce using rule 55 (exp -> exp GREATEREQ exp .)
    RPAR            reduce using rule 55 (exp -> exp GREATEREQ exp .)
    COMMA           reduce using rule 55 (exp -> exp GREATEREQ exp .)
    RBRACE          reduce using rule 55 (exp -> exp GREATEREQ exp .)
    SEMICOLON       reduce using rule 55 (exp -> exp GREATEREQ exp .)
    ELSE            reduce using rule 55 (exp -> exp GREATEREQ exp .)
    AND             shift and go to state 43
    OR              shift and go to state 54
    MINUS           shift and go to state 49
    PLUS            shift and go to state 52
    TIMES           shift and go to state 53
    DIVIDE          shift and go to state 44
    EQUAL           shift and go to state 46
    NEQUAL          shift and go to state 48
    GREATER         shift and go to state 55
    LESS            shift and go to state 45
    GREATEREQ       shift and go to state 50
    LESSEQ          shift and go to state 51

  ! AND             [ reduce using rule 55 (exp -> exp GREATEREQ exp .) ]
  ! OR              [ reduce using rule 55 (exp -> exp GREATEREQ exp .) ]
  ! MINUS           [ reduce using rule 55 (exp -> exp GREATEREQ exp .) ]
  ! PLUS            [ reduce using rule 55 (exp -> exp GREATEREQ exp .) ]
  ! TIMES           [ reduce using rule 55 (exp -> exp GREATEREQ exp .) ]
  ! DIVIDE          [ reduce using rule 55 (exp -> exp GREATEREQ exp .) ]
  ! EQUAL           [ reduce using rule 55 (exp -> exp GREATEREQ exp .) ]
  ! NEQUAL          [ reduce using rule 55 (exp -> exp GREATEREQ exp .) ]
  ! GREATER         [ reduce using rule 55 (exp -> exp GREATEREQ exp .) ]
  ! LESS            [ reduce using rule 55 (exp -> exp GREATEREQ exp .) ]
  ! GREATEREQ       [ reduce using rule 55 (exp -> exp GREATEREQ exp .) ]
  ! LESSEQ          [ reduce using rule 55 (exp -> exp GREATEREQ exp .) ]


state 73

    (56) exp -> exp LESSEQ exp .
    (41) exp -> exp . AND exp
    (42) exp -> exp . OR exp
    (47) exp -> exp . MINUS exp
    (48) exp -> exp . PLUS exp
    (49) exp -> exp . TIMES exp
    (50) exp -> exp . DIVIDE exp
    (51) exp -> exp . EQUAL exp
    (52) exp -> exp . NEQUAL exp
    (53) exp -> exp . GREATER exp
    (54) exp -> exp . LESS exp
    (55) exp -> exp . GREATEREQ exp
    (56) exp -> exp . LESSEQ exp

  ! shift/reduce conflict for AND resolved as shift
  ! shift/reduce conflict for OR resolved as shift
  ! shift/reduce conflict for MINUS resolved as shift
  ! shift/reduce conflict for PLUS resolved as shift
  ! shift/reduce conflict for TIMES resolved as shift
  ! shift/reduce conflict for DIVIDE resolved as shift
  ! shift/reduce conflict for EQUAL resolved as shift
  ! shift/reduce conflict for NEQUAL resolved as shift
  ! shift/reduce conflict for GREATER resolved as shift
  ! shift/reduce conflict for LESS resolved as shift
  ! shift/reduce conflict for GREATEREQ resolved as shift
  ! shift/reduce conflict for LESSEQ resolved as shift
    RBRACK          reduce using rule 56 (exp -> exp LESSEQ exp .)
    RPAR            reduce using rule 56 (exp -> exp LESSEQ exp .)
    COMMA           reduce using rule 56 (exp -> exp LESSEQ exp .)
    RBRACE          reduce using rule 56 (exp -> exp LESSEQ exp .)
    SEMICOLON       reduce using rule 56 (exp -> exp LESSEQ exp .)
    ELSE            reduce using rule 56 (exp -> exp LESSEQ exp .)
    AND             shift and go to state 43
    OR              shift and go to state 54
    MINUS           shift and go to state 49
    PLUS            shift and go to state 52
    TIMES           shift and go to state 53
    DIVIDE          shift and go to state 44
    EQUAL           shift and go to state 46
    NEQUAL          shift and go to state 48
    GREATER         shift and go to state 55
    LESS            shift and go to state 45
    GREATEREQ       shift and go to state 50
    LESSEQ          shift and go to state 51

  ! AND             [ reduce using rule 56 (exp -> exp LESSEQ exp .) ]
  ! OR              [ reduce using rule 56 (exp -> exp LESSEQ exp .) ]
  ! MINUS           [ reduce using rule 56 (exp -> exp LESSEQ exp .) ]
  ! PLUS            [ reduce using rule 56 (exp -> exp LESSEQ exp .) ]
  ! TIMES           [ reduce using rule 56 (exp -> exp LESSEQ exp .) ]
  ! DIVIDE          [ reduce using rule 56 (exp -> exp LESSEQ exp .) ]
  ! EQUAL           [ reduce using rule 56 (exp -> exp LESSEQ exp .) ]
  ! NEQUAL          [ reduce using rule 56 (exp -> exp LESSEQ exp .) ]
  ! GREATER         [ reduce using rule 56 (exp -> exp LESSEQ exp .) ]
  ! LESS            [ reduce using rule 56 (exp -> exp LESSEQ exp .) ]
  ! GREATEREQ       [ reduce using rule 56 (exp -> exp LESSEQ exp .) ]
  ! LESSEQ          [ reduce using rule 56 (exp -> exp LESSEQ exp .) ]


state 74

    (48) exp -> exp PLUS exp .
    (41) exp -> exp . AND exp
    (42) exp -> exp . OR exp
    (47) exp -> exp . MINUS exp
    (48) exp -> exp . PLUS exp
    (49) exp -> exp . TIMES exp
    (50) exp -> exp . DIVIDE exp
    (51) exp -> exp . EQUAL exp
    (52) exp -> exp . NEQUAL exp
    (53) exp -> exp . GREATER exp
    (54) exp -> exp . LESS exp
    (55) exp -> exp . GREATEREQ exp
    (56) exp -> exp . LESSEQ exp

    AND             reduce using rule 48 (exp -> exp PLUS exp .)
    OR              reduce using rule 48 (exp -> exp PLUS exp .)
    MINUS           reduce using rule 48 (exp -> exp PLUS exp .)
    PLUS            reduce using rule 48 (exp -> exp PLUS exp .)
    EQUAL           reduce using rule 48 (exp -> exp PLUS exp .)
    NEQUAL          reduce using rule 48 (exp -> exp PLUS exp .)
    GREATER         reduce using rule 48 (exp -> exp PLUS exp .)
    LESS            reduce using rule 48 (exp -> exp PLUS exp .)
    GREATEREQ       reduce using rule 48 (exp -> exp PLUS exp .)
    LESSEQ          reduce using rule 48 (exp -> exp PLUS exp .)
    RBRACK          reduce using rule 48 (exp -> exp PLUS exp .)
    RPAR            reduce using rule 48 (exp -> exp PLUS exp .)
    COMMA           reduce using rule 48 (exp -> exp PLUS exp .)
    RBRACE          reduce using rule 48 (exp -> exp PLUS exp .)
    SEMICOLON       reduce using rule 48 (exp -> exp PLUS exp .)
    ELSE            reduce using rule 48 (exp -> exp PLUS exp .)
    TIMES           shift and go to state 53
    DIVIDE          shift and go to state 44

  ! TIMES           [ reduce using rule 48 (exp -> exp PLUS exp .) ]
  ! DIVIDE          [ reduce using rule 48 (exp -> exp PLUS exp .) ]
  ! AND             [ shift and go to state 43 ]
  ! OR              [ shift and go to state 54 ]
  ! MINUS           [ shift and go to state 49 ]
  ! PLUS            [ shift and go to state 52 ]
  ! EQUAL           [ shift and go to state 46 ]
  ! NEQUAL          [ shift and go to state 48 ]
  ! GREATER         [ shift and go to state 55 ]
  ! LESS            [ shift and go to state 45 ]
  ! GREATEREQ       [ shift and go to state 50 ]
  ! LESSEQ          [ shift and go to state 51 ]


state 75

    (49) exp -> exp TIMES exp .
    (41) exp -> exp . AND exp
    (42) exp -> exp . OR exp
    (47) exp -> exp . MINUS exp
    (48) exp -> exp . PLUS exp
    (49) exp -> exp . TIMES exp
    (50) exp -> exp . DIVIDE exp
    (51) exp -> exp . EQUAL exp
    (52) exp -> exp . NEQUAL exp
    (53) exp -> exp . GREATER exp
    (54) exp -> exp . LESS exp
    (55) exp -> exp . GREATEREQ exp
    (56) exp -> exp . LESSEQ exp

    AND             reduce using rule 49 (exp -> exp TIMES exp .)
    OR              reduce using rule 49 (exp -> exp TIMES exp .)
    MINUS           reduce using rule 49 (exp -> exp TIMES exp .)
    PLUS            reduce using rule 49 (exp -> exp TIMES exp .)
    TIMES           reduce using rule 49 (exp -> exp TIMES exp .)
    DIVIDE          reduce using rule 49 (exp -> exp TIMES exp .)
    EQUAL           reduce using rule 49 (exp -> exp TIMES exp .)
    NEQUAL          reduce using rule 49 (exp -> exp TIMES exp .)
    GREATER         reduce using rule 49 (exp -> exp TIMES exp .)
    LESS            reduce using rule 49 (exp -> exp TIMES exp .)
    GREATEREQ       reduce using rule 49 (exp -> exp TIMES exp .)
    LESSEQ          reduce using rule 49 (exp -> exp TIMES exp .)
    RBRACK          reduce using rule 49 (exp -> exp TIMES exp .)
    RPAR            reduce using rule 49 (exp -> exp TIMES exp .)
    COMMA           reduce using rule 49 (exp -> exp TIMES exp .)
    RBRACE          reduce using rule 49 (exp -> exp TIMES exp .)
    SEMICOLON       reduce using rule 49 (exp -> exp TIMES exp .)
    ELSE            reduce using rule 49 (exp -> exp TIMES exp .)

  ! AND             [ shift and go to state 43 ]
  ! OR              [ shift and go to state 54 ]
  ! MINUS           [ shift and go to state 49 ]
  ! PLUS            [ shift and go to state 52 ]
  ! TIMES           [ shift and go to state 53 ]
  ! DIVIDE          [ shift and go to state 44 ]
  ! EQUAL           [ shift and go to state 46 ]
  ! NEQUAL          [ shift and go to state 48 ]
  ! GREATER         [ shift and go to state 55 ]
  ! LESS            [ shift and go to state 45 ]
  ! GREATEREQ       [ shift and go to state 50 ]
  ! LESSEQ          [ shift and go to state 51 ]


state 76

    (42) exp -> exp OR exp .
    (41) exp -> exp . AND exp
    (42) exp -> exp . OR exp
    (47) exp -> exp . MINUS exp
    (48) exp -> exp . PLUS exp
    (49) exp -> exp . TIMES exp
    (50) exp -> exp . DIVIDE exp
    (51) exp -> exp . EQUAL exp
    (52) exp -> exp . NEQUAL exp
    (53) exp -> exp . GREATER exp
    (54) exp -> exp . LESS exp
    (55) exp -> exp . GREATEREQ exp
    (56) exp -> exp . LESSEQ exp

    AND             reduce using rule 42 (exp -> exp OR exp .)
    OR              reduce using rule 42 (exp -> exp OR exp .)
    GREATEREQ       reduce using rule 42 (exp -> exp OR exp .)
    LESSEQ          reduce using rule 42 (exp -> exp OR exp .)
    RBRACK          reduce using rule 42 (exp -> exp OR exp .)
    RPAR            reduce using rule 42 (exp -> exp OR exp .)
    COMMA           reduce using rule 42 (exp -> exp OR exp .)
    RBRACE          reduce using rule 42 (exp -> exp OR exp .)
    SEMICOLON       reduce using rule 42 (exp -> exp OR exp .)
    ELSE            reduce using rule 42 (exp -> exp OR exp .)
    MINUS           shift and go to state 49
    PLUS            shift and go to state 52
    TIMES           shift and go to state 53
    DIVIDE          shift and go to state 44
    EQUAL           shift and go to state 46
    NEQUAL          shift and go to state 48
    GREATER         shift and go to state 55
    LESS            shift and go to state 45

  ! MINUS           [ reduce using rule 42 (exp -> exp OR exp .) ]
  ! PLUS            [ reduce using rule 42 (exp -> exp OR exp .) ]
  ! TIMES           [ reduce using rule 42 (exp -> exp OR exp .) ]
  ! DIVIDE          [ reduce using rule 42 (exp -> exp OR exp .) ]
  ! EQUAL           [ reduce using rule 42 (exp -> exp OR exp .) ]
  ! NEQUAL          [ reduce using rule 42 (exp -> exp OR exp .) ]
  ! GREATER         [ reduce using rule 42 (exp -> exp OR exp .) ]
  ! LESS            [ reduce using rule 42 (exp -> exp OR exp .) ]
  ! AND             [ shift and go to state 43 ]
  ! OR              [ shift and go to state 54 ]
  ! GREATEREQ       [ shift and go to state 50 ]
  ! LESSEQ          [ shift and go to state 51 ]


state 77

    (53) exp -> exp GREATER exp .
    (41) exp -> exp . AND exp
    (42) exp -> exp . OR exp
    (47) exp -> exp . MINUS exp
    (48) exp -> exp . PLUS exp
    (49) exp -> exp . TIMES exp
    (50) exp -> exp . DIVIDE exp
    (51) exp -> exp . EQUAL exp
    (52) exp -> exp . NEQUAL exp
    (53) exp -> exp . GREATER exp
    (54) exp -> exp . LESS exp
    (55) exp -> exp . GREATEREQ exp
    (56) exp -> exp . LESSEQ exp

    AND             reduce using rule 53 (exp -> exp GREATER exp .)
    OR              reduce using rule 53 (exp -> exp GREATER exp .)
    EQUAL           reduce using rule 53 (exp -> exp GREATER exp .)
    NEQUAL          reduce using rule 53 (exp -> exp GREATER exp .)
    GREATER         reduce using rule 53 (exp -> exp GREATER exp .)
    LESS            reduce using rule 53 (exp -> exp GREATER exp .)
    GREATEREQ       reduce using rule 53 (exp -> exp GREATER exp .)
    LESSEQ          reduce using rule 53 (exp -> exp GREATER exp .)
    RBRACK          reduce using rule 53 (exp -> exp GREATER exp .)
    RPAR            reduce using rule 53 (exp -> exp GREATER exp .)
    COMMA           reduce using rule 53 (exp -> exp GREATER exp .)
    RBRACE          reduce using rule 53 (exp -> exp GREATER exp .)
    SEMICOLON       reduce using rule 53 (exp -> exp GREATER exp .)
    ELSE            reduce using rule 53 (exp -> exp GREATER exp .)
    MINUS           shift and go to state 49
    PLUS            shift and go to state 52
    TIMES           shift and go to state 53
    DIVIDE          shift and go to state 44

  ! MINUS           [ reduce using rule 53 (exp -> exp GREATER exp .) ]
  ! PLUS            [ reduce using rule 53 (exp -> exp GREATER exp .) ]
  ! TIMES           [ reduce using rule 53 (exp -> exp GREATER exp .) ]
  ! DIVIDE          [ reduce using rule 53 (exp -> exp GREATER exp .) ]
  ! AND             [ shift and go to state 43 ]
  ! OR              [ shift and go to state 54 ]
  ! EQUAL           [ shift and go to state 46 ]
  ! NEQUAL          [ shift and go to state 48 ]
  ! GREATER         [ shift and go to state 55 ]
  ! LESS            [ shift and go to state 45 ]
  ! GREATEREQ       [ shift and go to state 50 ]
  ! LESSEQ          [ shift and go to state 51 ]


state 78

    (20) var_declarations -> var_declaration . var_declarations
    (20) var_declarations -> . var_declaration var_declarations
    (21) var_declarations -> . empty
    (22) var_declaration -> . type NAME SEMICOLON
    (64) empty -> .
    (11) type -> . INT
    (12) type -> . CHAR
    (13) type -> . BOOLEAN
    (14) type -> . type LBRACK exp RBRACK

    RBRACE          reduce using rule 64 (empty -> .)
    RETURN          reduce using rule 64 (empty -> .)
    WRITE           reduce using rule 64 (empty -> .)
    READ            reduce using rule 64 (empty -> .)
    NAME            reduce using rule 64 (empty -> .)
    WHILE           reduce using rule 64 (empty -> .)
    IF              reduce using rule 64 (empty -> .)
    LBRACE          reduce using rule 64 (empty -> .)
    INT             shift and go to state 30
    CHAR            shift and go to state 32
    BOOLEAN         shift and go to state 33

    var_declaration                shift and go to state 78
    type                           shift and go to state 10
    empty                          shift and go to state 80
    var_declarations               shift and go to state 87

state 79

    (18) block -> LBRACE var_declarations . statements RBRACE
    (19) block -> LBRACE var_declarations . RBRACE
    (23) statements -> . statements SEMICOLON statement
    (24) statements -> . statement
    (25) statement -> . block
    (26) statement -> . RETURN exp
    (27) statement -> . WRITE exp
    (28) statement -> . READ lexp
    (29) statement -> . NAME LPAR RPAR
    (30) statement -> . NAME LPAR pars RPAR
    (31) statement -> . WHILE LPAR exp RPAR statement
    (32) statement -> . IF LPAR exp RPAR statement
    (33) statement -> . IF LPAR exp RPAR statement ELSE statement
    (34) statement -> . lexp ASSIGN exp
    (18) block -> . LBRACE var_declarations statements RBRACE
    (19) block -> . LBRACE var_declarations RBRACE
    (35) lexp -> . var
    (36) lexp -> . lexp LBRACK exp RBRACK
    (61) var -> . NAME

    RBRACE          shift and go to state 94
    RETURN          shift and go to state 88
    WRITE           shift and go to state 95
    READ            shift and go to state 89
    NAME            shift and go to state 97
    WHILE           shift and go to state 90
    IF              shift and go to state 96
    LBRACE          shift and go to state 56

    statements                     shift and go to state 91
    statement                      shift and go to state 93
    var                            shift and go to state 23
    block                          shift and go to state 98
    lexp                           shift and go to state 92

state 80

    (21) var_declarations -> empty .

    RBRACE          reduce using rule 21 (var_declarations -> empty .)
    RETURN          reduce using rule 21 (var_declarations -> empty .)
    WRITE           reduce using rule 21 (var_declarations -> empty .)
    READ            reduce using rule 21 (var_declarations -> empty .)
    NAME            reduce using rule 21 (var_declarations -> empty .)
    WHILE           reduce using rule 21 (var_declarations -> empty .)
    IF              reduce using rule 21 (var_declarations -> empty .)
    LBRACE          reduce using rule 21 (var_declarations -> empty .)


state 81

    (6) fun_declaration -> fun_type NAME LPAR RPAR block SEMICOLON .

    VOID            reduce using rule 6 (fun_declaration -> fun_type NAME LPAR RPAR block SEMICOLON .)
    INT             reduce using rule 6 (fun_declaration -> fun_type NAME LPAR RPAR block SEMICOLON .)
    CHAR            reduce using rule 6 (fun_declaration -> fun_type NAME LPAR RPAR block SEMICOLON .)
    BOOLEAN         reduce using rule 6 (fun_declaration -> fun_type NAME LPAR RPAR block SEMICOLON .)
    $end            reduce using rule 6 (fun_declaration -> fun_type NAME LPAR RPAR block SEMICOLON .)


state 82

    (5) fun_declaration -> fun_type NAME LPAR formal_pars RPAR block . SEMICOLON

    SEMICOLON       shift and go to state 99


state 83

    (15) formal_pars -> formal_pars COMMA formal_par .

    RPAR            reduce using rule 15 (formal_pars -> formal_pars COMMA formal_par .)
    COMMA           reduce using rule 15 (formal_pars -> formal_pars COMMA formal_par .)


state 84

    (36) lexp -> lexp LBRACK exp RBRACK .

    LBRACK          reduce using rule 36 (lexp -> lexp LBRACK exp RBRACK .)
    RBRACK          reduce using rule 36 (lexp -> lexp LBRACK exp RBRACK .)
    AND             reduce using rule 36 (lexp -> lexp LBRACK exp RBRACK .)
    OR              reduce using rule 36 (lexp -> lexp LBRACK exp RBRACK .)
    MINUS           reduce using rule 36 (lexp -> lexp LBRACK exp RBRACK .)
    PLUS            reduce using rule 36 (lexp -> lexp LBRACK exp RBRACK .)
    TIMES           reduce using rule 36 (lexp -> lexp LBRACK exp RBRACK .)
    DIVIDE          reduce using rule 36 (lexp -> lexp LBRACK exp RBRACK .)
    EQUAL           reduce using rule 36 (lexp -> lexp LBRACK exp RBRACK .)
    NEQUAL          reduce using rule 36 (lexp -> lexp LBRACK exp RBRACK .)
    GREATER         reduce using rule 36 (lexp -> lexp LBRACK exp RBRACK .)
    LESS            reduce using rule 36 (lexp -> lexp LBRACK exp RBRACK .)
    GREATEREQ       reduce using rule 36 (lexp -> lexp LBRACK exp RBRACK .)
    LESSEQ          reduce using rule 36 (lexp -> lexp LBRACK exp RBRACK .)
    RPAR            reduce using rule 36 (lexp -> lexp LBRACK exp RBRACK .)
    COMMA           reduce using rule 36 (lexp -> lexp LBRACK exp RBRACK .)
    RBRACE          reduce using rule 36 (lexp -> lexp LBRACK exp RBRACK .)
    SEMICOLON       reduce using rule 36 (lexp -> lexp LBRACK exp RBRACK .)
    ELSE            reduce using rule 36 (lexp -> lexp LBRACK exp RBRACK .)
    ASSIGN          reduce using rule 36 (lexp -> lexp LBRACK exp RBRACK .)


state 85

    (44) exp -> NAME LPAR pars RPAR .

    AND             reduce using rule 44 (exp -> NAME LPAR pars RPAR .)
    OR              reduce using rule 44 (exp -> NAME LPAR pars RPAR .)
    MINUS           reduce using rule 44 (exp -> NAME LPAR pars RPAR .)
    PLUS            reduce using rule 44 (exp -> NAME LPAR pars RPAR .)
    TIMES           reduce using rule 44 (exp -> NAME LPAR pars RPAR .)
    DIVIDE          reduce using rule 44 (exp -> NAME LPAR pars RPAR .)
    EQUAL           reduce using rule 44 (exp -> NAME LPAR pars RPAR .)
    NEQUAL          reduce using rule 44 (exp -> NAME LPAR pars RPAR .)
    GREATER         reduce using rule 44 (exp -> NAME LPAR pars RPAR .)
    LESS            reduce using rule 44 (exp -> NAME LPAR pars RPAR .)
    GREATEREQ       reduce using rule 44 (exp -> NAME LPAR pars RPAR .)
    LESSEQ          reduce using rule 44 (exp -> NAME LPAR pars RPAR .)
    RBRACK          reduce using rule 44 (exp -> NAME LPAR pars RPAR .)
    RPAR            reduce using rule 44 (exp -> NAME LPAR pars RPAR .)
    COMMA           reduce using rule 44 (exp -> NAME LPAR pars RPAR .)
    RBRACE          reduce using rule 44 (exp -> NAME LPAR pars RPAR .)
    SEMICOLON       reduce using rule 44 (exp -> NAME LPAR pars RPAR .)
    ELSE            reduce using rule 44 (exp -> NAME LPAR pars RPAR .)


state 86

    (59) pars -> pars COMMA . exp
    (37) exp -> . lexp
    (38) exp -> . LENGTH lexp
    (39) exp -> . unop exp
    (40) exp -> . LPAR exp RPAR
    (41) exp -> . exp AND exp
    (42) exp -> . exp OR exp
    (43) exp -> . NAME LPAR RPAR
    (44) exp -> . NAME LPAR pars RPAR
    (45) exp -> . NUMBER
    (46) exp -> . QCHAR
    (47) exp -> . exp MINUS exp
    (48) exp -> . exp PLUS exp
    (49) exp -> . exp TIMES exp
    (50) exp -> . exp DIVIDE exp
    (51) exp -> . exp EQUAL exp
    (52) exp -> . exp NEQUAL exp
    (53) exp -> . exp GREATER exp
    (54) exp -> . exp LESS exp
    (55) exp -> . exp GREATEREQ exp
    (56) exp -> . exp LESSEQ exp
    (62) exp -> . TRUE
    (63) exp -> . FALSE
    (35) lexp -> . var
    (36) lexp -> . lexp LBRACK exp RBRACK
    (57) unop -> . MINUS
    (58) unop -> . NOT
    (61) var -> . NAME

    LENGTH          shift and go to state 27
    LPAR            shift and go to state 18
    NAME            shift and go to state 26
    NUMBER          shift and go to state 24
    QCHAR           shift and go to state 19
    TRUE            shift and go to state 20
    FALSE           shift and go to state 25
    MINUS           shift and go to state 21
    NOT             shift and go to state 29

    unop                           shift and go to state 17
    var                            shift and go to state 23
    lexp                           shift and go to state 22
    exp                            shift and go to state 100

state 87

    (20) var_declarations -> var_declaration var_declarations .

    RBRACE          reduce using rule 20 (var_declarations -> var_declaration var_declarations .)
    RETURN          reduce using rule 20 (var_declarations -> var_declaration var_declarations .)
    WRITE           reduce using rule 20 (var_declarations -> var_declaration var_declarations .)
    READ            reduce using rule 20 (var_declarations -> var_declaration var_declarations .)
    NAME            reduce using rule 20 (var_declarations -> var_declaration var_declarations .)
    WHILE           reduce using rule 20 (var_declarations -> var_declaration var_declarations .)
    IF              reduce using rule 20 (var_declarations -> var_declaration var_declarations .)
    LBRACE          reduce using rule 20 (var_declarations -> var_declaration var_declarations .)


state 88

    (26) statement -> RETURN . exp
    (37) exp -> . lexp
    (38) exp -> . LENGTH lexp
    (39) exp -> . unop exp
    (40) exp -> . LPAR exp RPAR
    (41) exp -> . exp AND exp
    (42) exp -> . exp OR exp
    (43) exp -> . NAME LPAR RPAR
    (44) exp -> . NAME LPAR pars RPAR
    (45) exp -> . NUMBER
    (46) exp -> . QCHAR
    (47) exp -> . exp MINUS exp
    (48) exp -> . exp PLUS exp
    (49) exp -> . exp TIMES exp
    (50) exp -> . exp DIVIDE exp
    (51) exp -> . exp EQUAL exp
    (52) exp -> . exp NEQUAL exp
    (53) exp -> . exp GREATER exp
    (54) exp -> . exp LESS exp
    (55) exp -> . exp GREATEREQ exp
    (56) exp -> . exp LESSEQ exp
    (62) exp -> . TRUE
    (63) exp -> . FALSE
    (35) lexp -> . var
    (36) lexp -> . lexp LBRACK exp RBRACK
    (57) unop -> . MINUS
    (58) unop -> . NOT
    (61) var -> . NAME

    LENGTH          shift and go to state 27
    LPAR            shift and go to state 18
    NAME            shift and go to state 26
    NUMBER          shift and go to state 24
    QCHAR           shift and go to state 19
    TRUE            shift and go to state 20
    FALSE           shift and go to state 25
    MINUS           shift and go to state 21
    NOT             shift and go to state 29

    unop                           shift and go to state 17
    var                            shift and go to state 23
    lexp                           shift and go to state 22
    exp                            shift and go to state 101

state 89

    (28) statement -> READ . lexp
    (35) lexp -> . var
    (36) lexp -> . lexp LBRACK exp RBRACK
    (61) var -> . NAME

    NAME            shift and go to state 42

    var                            shift and go to state 23
    lexp                           shift and go to state 102

state 90

    (31) statement -> WHILE . LPAR exp RPAR statement

    LPAR            shift and go to state 103


state 91

    (18) block -> LBRACE var_declarations statements . RBRACE
    (23) statements -> statements . SEMICOLON statement

    RBRACE          shift and go to state 104
    SEMICOLON       shift and go to state 105


state 92

    (34) statement -> lexp . ASSIGN exp
    (36) lexp -> lexp . LBRACK exp RBRACK

    ASSIGN          shift and go to state 106
    LBRACK          shift and go to state 39


state 93

    (24) statements -> statement .

    RBRACE          reduce using rule 24 (statements -> statement .)
    SEMICOLON       reduce using rule 24 (statements -> statement .)


state 94

    (19) block -> LBRACE var_declarations RBRACE .

    RBRACE          reduce using rule 19 (block -> LBRACE var_declarations RBRACE .)
    SEMICOLON       reduce using rule 19 (block -> LBRACE var_declarations RBRACE .)
    ELSE            reduce using rule 19 (block -> LBRACE var_declarations RBRACE .)


state 95

    (27) statement -> WRITE . exp
    (37) exp -> . lexp
    (38) exp -> . LENGTH lexp
    (39) exp -> . unop exp
    (40) exp -> . LPAR exp RPAR
    (41) exp -> . exp AND exp
    (42) exp -> . exp OR exp
    (43) exp -> . NAME LPAR RPAR
    (44) exp -> . NAME LPAR pars RPAR
    (45) exp -> . NUMBER
    (46) exp -> . QCHAR
    (47) exp -> . exp MINUS exp
    (48) exp -> . exp PLUS exp
    (49) exp -> . exp TIMES exp
    (50) exp -> . exp DIVIDE exp
    (51) exp -> . exp EQUAL exp
    (52) exp -> . exp NEQUAL exp
    (53) exp -> . exp GREATER exp
    (54) exp -> . exp LESS exp
    (55) exp -> . exp GREATEREQ exp
    (56) exp -> . exp LESSEQ exp
    (62) exp -> . TRUE
    (63) exp -> . FALSE
    (35) lexp -> . var
    (36) lexp -> . lexp LBRACK exp RBRACK
    (57) unop -> . MINUS
    (58) unop -> . NOT
    (61) var -> . NAME

    LENGTH          shift and go to state 27
    LPAR            shift and go to state 18
    NAME            shift and go to state 26
    NUMBER          shift and go to state 24
    QCHAR           shift and go to state 19
    TRUE            shift and go to state 20
    FALSE           shift and go to state 25
    MINUS           shift and go to state 21
    NOT             shift and go to state 29

    unop                           shift and go to state 17
    var                            shift and go to state 23
    lexp                           shift and go to state 22
    exp                            shift and go to state 107

state 96

    (32) statement -> IF . LPAR exp RPAR statement
    (33) statement -> IF . LPAR exp RPAR statement ELSE statement

    LPAR            shift and go to state 108


state 97

    (29) statement -> NAME . LPAR RPAR
    (30) statement -> NAME . LPAR pars RPAR
    (61) var -> NAME .

    LPAR            shift and go to state 109
    ASSIGN          reduce using rule 61 (var -> NAME .)
    LBRACK          reduce using rule 61 (var -> NAME .)


state 98

    (25) statement -> block .

    RBRACE          reduce using rule 25 (statement -> block .)
    SEMICOLON       reduce using rule 25 (statement -> block .)
    ELSE            reduce using rule 25 (statement -> block .)


state 99

    (5) fun_declaration -> fun_type NAME LPAR formal_pars RPAR block SEMICOLON .

    VOID            reduce using rule 5 (fun_declaration -> fun_type NAME LPAR formal_pars RPAR block SEMICOLON .)
    INT             reduce using rule 5 (fun_declaration -> fun_type NAME LPAR formal_pars RPAR block SEMICOLON .)
    CHAR            reduce using rule 5 (fun_declaration -> fun_type NAME LPAR formal_pars RPAR block SEMICOLON .)
    BOOLEAN         reduce using rule 5 (fun_declaration -> fun_type NAME LPAR formal_pars RPAR block SEMICOLON .)
    $end            reduce using rule 5 (fun_declaration -> fun_type NAME LPAR formal_pars RPAR block SEMICOLON .)


state 100

    (59) pars -> pars COMMA exp .
    (41) exp -> exp . AND exp
    (42) exp -> exp . OR exp
    (47) exp -> exp . MINUS exp
    (48) exp -> exp . PLUS exp
    (49) exp -> exp . TIMES exp
    (50) exp -> exp . DIVIDE exp
    (51) exp -> exp . EQUAL exp
    (52) exp -> exp . NEQUAL exp
    (53) exp -> exp . GREATER exp
    (54) exp -> exp . LESS exp
    (55) exp -> exp . GREATEREQ exp
    (56) exp -> exp . LESSEQ exp

    RPAR            reduce using rule 59 (pars -> pars COMMA exp .)
    COMMA           reduce using rule 59 (pars -> pars COMMA exp .)
    AND             shift and go to state 43
    OR              shift and go to state 54
    MINUS           shift and go to state 49
    PLUS            shift and go to state 52
    TIMES           shift and go to state 53
    DIVIDE          shift and go to state 44
    EQUAL           shift and go to state 46
    NEQUAL          shift and go to state 48
    GREATER         shift and go to state 55
    LESS            shift and go to state 45
    GREATEREQ       shift and go to state 50
    LESSEQ          shift and go to state 51


state 101

    (26) statement -> RETURN exp .
    (41) exp -> exp . AND exp
    (42) exp -> exp . OR exp
    (47) exp -> exp . MINUS exp
    (48) exp -> exp . PLUS exp
    (49) exp -> exp . TIMES exp
    (50) exp -> exp . DIVIDE exp
    (51) exp -> exp . EQUAL exp
    (52) exp -> exp . NEQUAL exp
    (53) exp -> exp . GREATER exp
    (54) exp -> exp . LESS exp
    (55) exp -> exp . GREATEREQ exp
    (56) exp -> exp . LESSEQ exp

    RBRACE          reduce using rule 26 (statement -> RETURN exp .)
    SEMICOLON       reduce using rule 26 (statement -> RETURN exp .)
    ELSE            reduce using rule 26 (statement -> RETURN exp .)
    AND             shift and go to state 43
    OR              shift and go to state 54
    MINUS           shift and go to state 49
    PLUS            shift and go to state 52
    TIMES           shift and go to state 53
    DIVIDE          shift and go to state 44
    EQUAL           shift and go to state 46
    NEQUAL          shift and go to state 48
    GREATER         shift and go to state 55
    LESS            shift and go to state 45
    GREATEREQ       shift and go to state 50
    LESSEQ          shift and go to state 51


state 102

    (28) statement -> READ lexp .
    (36) lexp -> lexp . LBRACK exp RBRACK

    RBRACE          reduce using rule 28 (statement -> READ lexp .)
    SEMICOLON       reduce using rule 28 (statement -> READ lexp .)
    ELSE            reduce using rule 28 (statement -> READ lexp .)
    LBRACK          shift and go to state 39


state 103

    (31) statement -> WHILE LPAR . exp RPAR statement
    (37) exp -> . lexp
    (38) exp -> . LENGTH lexp
    (39) exp -> . unop exp
    (40) exp -> . LPAR exp RPAR
    (41) exp -> . exp AND exp
    (42) exp -> . exp OR exp
    (43) exp -> . NAME LPAR RPAR
    (44) exp -> . NAME LPAR pars RPAR
    (45) exp -> . NUMBER
    (46) exp -> . QCHAR
    (47) exp -> . exp MINUS exp
    (48) exp -> . exp PLUS exp
    (49) exp -> . exp TIMES exp
    (50) exp -> . exp DIVIDE exp
    (51) exp -> . exp EQUAL exp
    (52) exp -> . exp NEQUAL exp
    (53) exp -> . exp GREATER exp
    (54) exp -> . exp LESS exp
    (55) exp -> . exp GREATEREQ exp
    (56) exp -> . exp LESSEQ exp
    (62) exp -> . TRUE
    (63) exp -> . FALSE
    (35) lexp -> . var
    (36) lexp -> . lexp LBRACK exp RBRACK
    (57) unop -> . MINUS
    (58) unop -> . NOT
    (61) var -> . NAME

    LENGTH          shift and go to state 27
    LPAR            shift and go to state 18
    NAME            shift and go to state 26
    NUMBER          shift and go to state 24
    QCHAR           shift and go to state 19
    TRUE            shift and go to state 20
    FALSE           shift and go to state 25
    MINUS           shift and go to state 21
    NOT             shift and go to state 29

    unop                           shift and go to state 17
    exp                            shift and go to state 110
    var                            shift and go to state 23
    lexp                           shift and go to state 22

state 104

    (18) block -> LBRACE var_declarations statements RBRACE .

    RBRACE          reduce using rule 18 (block -> LBRACE var_declarations statements RBRACE .)
    SEMICOLON       reduce using rule 18 (block -> LBRACE var_declarations statements RBRACE .)
    ELSE            reduce using rule 18 (block -> LBRACE var_declarations statements RBRACE .)


state 105

    (23) statements -> statements SEMICOLON . statement
    (25) statement -> . block
    (26) statement -> . RETURN exp
    (27) statement -> . WRITE exp
    (28) statement -> . READ lexp
    (29) statement -> . NAME LPAR RPAR
    (30) statement -> . NAME LPAR pars RPAR
    (31) statement -> . WHILE LPAR exp RPAR statement
    (32) statement -> . IF LPAR exp RPAR statement
    (33) statement -> . IF LPAR exp RPAR statement ELSE statement
    (34) statement -> . lexp ASSIGN exp
    (18) block -> . LBRACE var_declarations statements RBRACE
    (19) block -> . LBRACE var_declarations RBRACE
    (35) lexp -> . var
    (36) lexp -> . lexp LBRACK exp RBRACK
    (61) var -> . NAME

    RETURN          shift and go to state 88
    WRITE           shift and go to state 95
    READ            shift and go to state 89
    NAME            shift and go to state 97
    WHILE           shift and go to state 90
    IF              shift and go to state 96
    LBRACE          shift and go to state 56

    statement                      shift and go to state 111
    var                            shift and go to state 23
    block                          shift and go to state 98
    lexp                           shift and go to state 92

state 106

    (34) statement -> lexp ASSIGN . exp
    (37) exp -> . lexp
    (38) exp -> . LENGTH lexp
    (39) exp -> . unop exp
    (40) exp -> . LPAR exp RPAR
    (41) exp -> . exp AND exp
    (42) exp -> . exp OR exp
    (43) exp -> . NAME LPAR RPAR
    (44) exp -> . NAME LPAR pars RPAR
    (45) exp -> . NUMBER
    (46) exp -> . QCHAR
    (47) exp -> . exp MINUS exp
    (48) exp -> . exp PLUS exp
    (49) exp -> . exp TIMES exp
    (50) exp -> . exp DIVIDE exp
    (51) exp -> . exp EQUAL exp
    (52) exp -> . exp NEQUAL exp
    (53) exp -> . exp GREATER exp
    (54) exp -> . exp LESS exp
    (55) exp -> . exp GREATEREQ exp
    (56) exp -> . exp LESSEQ exp
    (62) exp -> . TRUE
    (63) exp -> . FALSE
    (35) lexp -> . var
    (36) lexp -> . lexp LBRACK exp RBRACK
    (57) unop -> . MINUS
    (58) unop -> . NOT
    (61) var -> . NAME

    LENGTH          shift and go to state 27
    LPAR            shift and go to state 18
    NAME            shift and go to state 26
    NUMBER          shift and go to state 24
    QCHAR           shift and go to state 19
    TRUE            shift and go to state 20
    FALSE           shift and go to state 25
    MINUS           shift and go to state 21
    NOT             shift and go to state 29

    unop                           shift and go to state 17
    var                            shift and go to state 23
    lexp                           shift and go to state 22
    exp                            shift and go to state 112

state 107

    (27) statement -> WRITE exp .
    (41) exp -> exp . AND exp
    (42) exp -> exp . OR exp
    (47) exp -> exp . MINUS exp
    (48) exp -> exp . PLUS exp
    (49) exp -> exp . TIMES exp
    (50) exp -> exp . DIVIDE exp
    (51) exp -> exp . EQUAL exp
    (52) exp -> exp . NEQUAL exp
    (53) exp -> exp . GREATER exp
    (54) exp -> exp . LESS exp
    (55) exp -> exp . GREATEREQ exp
    (56) exp -> exp . LESSEQ exp

    RBRACE          reduce using rule 27 (statement -> WRITE exp .)
    SEMICOLON       reduce using rule 27 (statement -> WRITE exp .)
    ELSE            reduce using rule 27 (statement -> WRITE exp .)
    AND             shift and go to state 43
    OR              shift and go to state 54
    MINUS           shift and go to state 49
    PLUS            shift and go to state 52
    TIMES           shift and go to state 53
    DIVIDE          shift and go to state 44
    EQUAL           shift and go to state 46
    NEQUAL          shift and go to state 48
    GREATER         shift and go to state 55
    LESS            shift and go to state 45
    GREATEREQ       shift and go to state 50
    LESSEQ          shift and go to state 51


state 108

    (32) statement -> IF LPAR . exp RPAR statement
    (33) statement -> IF LPAR . exp RPAR statement ELSE statement
    (37) exp -> . lexp
    (38) exp -> . LENGTH lexp
    (39) exp -> . unop exp
    (40) exp -> . LPAR exp RPAR
    (41) exp -> . exp AND exp
    (42) exp -> . exp OR exp
    (43) exp -> . NAME LPAR RPAR
    (44) exp -> . NAME LPAR pars RPAR
    (45) exp -> . NUMBER
    (46) exp -> . QCHAR
    (47) exp -> . exp MINUS exp
    (48) exp -> . exp PLUS exp
    (49) exp -> . exp TIMES exp
    (50) exp -> . exp DIVIDE exp
    (51) exp -> . exp EQUAL exp
    (52) exp -> . exp NEQUAL exp
    (53) exp -> . exp GREATER exp
    (54) exp -> . exp LESS exp
    (55) exp -> . exp GREATEREQ exp
    (56) exp -> . exp LESSEQ exp
    (62) exp -> . TRUE
    (63) exp -> . FALSE
    (35) lexp -> . var
    (36) lexp -> . lexp LBRACK exp RBRACK
    (57) unop -> . MINUS
    (58) unop -> . NOT
    (61) var -> . NAME

    LENGTH          shift and go to state 27
    LPAR            shift and go to state 18
    NAME            shift and go to state 26
    NUMBER          shift and go to state 24
    QCHAR           shift and go to state 19
    TRUE            shift and go to state 20
    FALSE           shift and go to state 25
    MINUS           shift and go to state 21
    NOT             shift and go to state 29

    unop                           shift and go to state 17
    exp                            shift and go to state 113
    var                            shift and go to state 23
    lexp                           shift and go to state 22

state 109

    (29) statement -> NAME LPAR . RPAR
    (30) statement -> NAME LPAR . pars RPAR
    (59) pars -> . pars COMMA exp
    (60) pars -> . exp
    (37) exp -> . lexp
    (38) exp -> . LENGTH lexp
    (39) exp -> . unop exp
    (40) exp -> . LPAR exp RPAR
    (41) exp -> . exp AND exp
    (42) exp -> . exp OR exp
    (43) exp -> . NAME LPAR RPAR
    (44) exp -> . NAME LPAR pars RPAR
    (45) exp -> . NUMBER
    (46) exp -> . QCHAR
    (47) exp -> . exp MINUS exp
    (48) exp -> . exp PLUS exp
    (49) exp -> . exp TIMES exp
    (50) exp -> . exp DIVIDE exp
    (51) exp -> . exp EQUAL exp
    (52) exp -> . exp NEQUAL exp
    (53) exp -> . exp GREATER exp
    (54) exp -> . exp LESS exp
    (55) exp -> . exp GREATEREQ exp
    (56) exp -> . exp LESSEQ exp
    (62) exp -> . TRUE
    (63) exp -> . FALSE
    (35) lexp -> . var
    (36) lexp -> . lexp LBRACK exp RBRACK
    (57) unop -> . MINUS
    (58) unop -> . NOT
    (61) var -> . NAME

    RPAR            shift and go to state 114
    LENGTH          shift and go to state 27
    LPAR            shift and go to state 18
    NAME            shift and go to state 26
    NUMBER          shift and go to state 24
    QCHAR           shift and go to state 19
    TRUE            shift and go to state 20
    FALSE           shift and go to state 25
    MINUS           shift and go to state 21
    NOT             shift and go to state 29

    unop                           shift and go to state 17
    var                            shift and go to state 23
    pars                           shift and go to state 115
    lexp                           shift and go to state 22
    exp                            shift and go to state 65

state 110

    (31) statement -> WHILE LPAR exp . RPAR statement
    (41) exp -> exp . AND exp
    (42) exp -> exp . OR exp
    (47) exp -> exp . MINUS exp
    (48) exp -> exp . PLUS exp
    (49) exp -> exp . TIMES exp
    (50) exp -> exp . DIVIDE exp
    (51) exp -> exp . EQUAL exp
    (52) exp -> exp . NEQUAL exp
    (53) exp -> exp . GREATER exp
    (54) exp -> exp . LESS exp
    (55) exp -> exp . GREATEREQ exp
    (56) exp -> exp . LESSEQ exp

    RPAR            shift and go to state 116
    AND             shift and go to state 43
    OR              shift and go to state 54
    MINUS           shift and go to state 49
    PLUS            shift and go to state 52
    TIMES           shift and go to state 53
    DIVIDE          shift and go to state 44
    EQUAL           shift and go to state 46
    NEQUAL          shift and go to state 48
    GREATER         shift and go to state 55
    LESS            shift and go to state 45
    GREATEREQ       shift and go to state 50
    LESSEQ          shift and go to state 51


state 111

    (23) statements -> statements SEMICOLON statement .

    RBRACE          reduce using rule 23 (statements -> statements SEMICOLON statement .)
    SEMICOLON       reduce using rule 23 (statements -> statements SEMICOLON statement .)


state 112

    (34) statement -> lexp ASSIGN exp .
    (41) exp -> exp . AND exp
    (42) exp -> exp . OR exp
    (47) exp -> exp . MINUS exp
    (48) exp -> exp . PLUS exp
    (49) exp -> exp . TIMES exp
    (50) exp -> exp . DIVIDE exp
    (51) exp -> exp . EQUAL exp
    (52) exp -> exp . NEQUAL exp
    (53) exp -> exp . GREATER exp
    (54) exp -> exp . LESS exp
    (55) exp -> exp . GREATEREQ exp
    (56) exp -> exp . LESSEQ exp

    RBRACE          reduce using rule 34 (statement -> lexp ASSIGN exp .)
    SEMICOLON       reduce using rule 34 (statement -> lexp ASSIGN exp .)
    ELSE            reduce using rule 34 (statement -> lexp ASSIGN exp .)
    AND             shift and go to state 43
    OR              shift and go to state 54
    MINUS           shift and go to state 49
    PLUS            shift and go to state 52
    TIMES           shift and go to state 53
    DIVIDE          shift and go to state 44
    EQUAL           shift and go to state 46
    NEQUAL          shift and go to state 48
    GREATER         shift and go to state 55
    LESS            shift and go to state 45
    GREATEREQ       shift and go to state 50
    LESSEQ          shift and go to state 51


state 113

    (32) statement -> IF LPAR exp . RPAR statement
    (33) statement -> IF LPAR exp . RPAR statement ELSE statement
    (41) exp -> exp . AND exp
    (42) exp -> exp . OR exp
    (47) exp -> exp . MINUS exp
    (48) exp -> exp . PLUS exp
    (49) exp -> exp . TIMES exp
    (50) exp -> exp . DIVIDE exp
    (51) exp -> exp . EQUAL exp
    (52) exp -> exp . NEQUAL exp
    (53) exp -> exp . GREATER exp
    (54) exp -> exp . LESS exp
    (55) exp -> exp . GREATEREQ exp
    (56) exp -> exp . LESSEQ exp

    RPAR            shift and go to state 117
    AND             shift and go to state 43
    OR              shift and go to state 54
    MINUS           shift and go to state 49
    PLUS            shift and go to state 52
    TIMES           shift and go to state 53
    DIVIDE          shift and go to state 44
    EQUAL           shift and go to state 46
    NEQUAL          shift and go to state 48
    GREATER         shift and go to state 55
    LESS            shift and go to state 45
    GREATEREQ       shift and go to state 50
    LESSEQ          shift and go to state 51


state 114

    (29) statement -> NAME LPAR RPAR .

    RBRACE          reduce using rule 29 (statement -> NAME LPAR RPAR .)
    SEMICOLON       reduce using rule 29 (statement -> NAME LPAR RPAR .)
    ELSE            reduce using rule 29 (statement -> NAME LPAR RPAR .)


state 115

    (30) statement -> NAME LPAR pars . RPAR
    (59) pars -> pars . COMMA exp

    RPAR            shift and go to state 118
    COMMA           shift and go to state 86


state 116

    (31) statement -> WHILE LPAR exp RPAR . statement
    (25) statement -> . block
    (26) statement -> . RETURN exp
    (27) statement -> . WRITE exp
    (28) statement -> . READ lexp
    (29) statement -> . NAME LPAR RPAR
    (30) statement -> . NAME LPAR pars RPAR
    (31) statement -> . WHILE LPAR exp RPAR statement
    (32) statement -> . IF LPAR exp RPAR statement
    (33) statement -> . IF LPAR exp RPAR statement ELSE statement
    (34) statement -> . lexp ASSIGN exp
    (18) block -> . LBRACE var_declarations statements RBRACE
    (19) block -> . LBRACE var_declarations RBRACE
    (35) lexp -> . var
    (36) lexp -> . lexp LBRACK exp RBRACK
    (61) var -> . NAME

    RETURN          shift and go to state 88
    WRITE           shift and go to state 95
    READ            shift and go to state 89
    NAME            shift and go to state 97
    WHILE           shift and go to state 90
    IF              shift and go to state 96
    LBRACE          shift and go to state 56

    statement                      shift and go to state 119
    var                            shift and go to state 23
    block                          shift and go to state 98
    lexp                           shift and go to state 92

state 117

    (32) statement -> IF LPAR exp RPAR . statement
    (33) statement -> IF LPAR exp RPAR . statement ELSE statement
    (25) statement -> . block
    (26) statement -> . RETURN exp
    (27) statement -> . WRITE exp
    (28) statement -> . READ lexp
    (29) statement -> . NAME LPAR RPAR
    (30) statement -> . NAME LPAR pars RPAR
    (31) statement -> . WHILE LPAR exp RPAR statement
    (32) statement -> . IF LPAR exp RPAR statement
    (33) statement -> . IF LPAR exp RPAR statement ELSE statement
    (34) statement -> . lexp ASSIGN exp
    (18) block -> . LBRACE var_declarations statements RBRACE
    (19) block -> . LBRACE var_declarations RBRACE
    (35) lexp -> . var
    (36) lexp -> . lexp LBRACK exp RBRACK
    (61) var -> . NAME

    RETURN          shift and go to state 88
    WRITE           shift and go to state 95
    READ            shift and go to state 89
    NAME            shift and go to state 97
    WHILE           shift and go to state 90
    IF              shift and go to state 96
    LBRACE          shift and go to state 56

    statement                      shift and go to state 120
    var                            shift and go to state 23
    block                          shift and go to state 98
    lexp                           shift and go to state 92

state 118

    (30) statement -> NAME LPAR pars RPAR .

    RBRACE          reduce using rule 30 (statement -> NAME LPAR pars RPAR .)
    SEMICOLON       reduce using rule 30 (statement -> NAME LPAR pars RPAR .)
    ELSE            reduce using rule 30 (statement -> NAME LPAR pars RPAR .)


state 119

    (31) statement -> WHILE LPAR exp RPAR statement .

    RBRACE          reduce using rule 31 (statement -> WHILE LPAR exp RPAR statement .)
    SEMICOLON       reduce using rule 31 (statement -> WHILE LPAR exp RPAR statement .)
    ELSE            reduce using rule 31 (statement -> WHILE LPAR exp RPAR statement .)


state 120

    (32) statement -> IF LPAR exp RPAR statement .
    (33) statement -> IF LPAR exp RPAR statement . ELSE statement

  ! shift/reduce conflict for ELSE resolved as shift
    RBRACE          reduce using rule 32 (statement -> IF LPAR exp RPAR statement .)
    SEMICOLON       reduce using rule 32 (statement -> IF LPAR exp RPAR statement .)
    ELSE            shift and go to state 121

  ! ELSE            [ reduce using rule 32 (statement -> IF LPAR exp RPAR statement .) ]


state 121

    (33) statement -> IF LPAR exp RPAR statement ELSE . statement
    (25) statement -> . block
    (26) statement -> . RETURN exp
    (27) statement -> . WRITE exp
    (28) statement -> . READ lexp
    (29) statement -> . NAME LPAR RPAR
    (30) statement -> . NAME LPAR pars RPAR
    (31) statement -> . WHILE LPAR exp RPAR statement
    (32) statement -> . IF LPAR exp RPAR statement
    (33) statement -> . IF LPAR exp RPAR statement ELSE statement
    (34) statement -> . lexp ASSIGN exp
    (18) block -> . LBRACE var_declarations statements RBRACE
    (19) block -> . LBRACE var_declarations RBRACE
    (35) lexp -> . var
    (36) lexp -> . lexp LBRACK exp RBRACK
    (61) var -> . NAME

    RETURN          shift and go to state 88
    WRITE           shift and go to state 95
    READ            shift and go to state 89
    NAME            shift and go to state 97
    WHILE           shift and go to state 90
    IF              shift and go to state 96
    LBRACE          shift and go to state 56

    statement                      shift and go to state 122
    var                            shift and go to state 23
    block                          shift and go to state 98
    lexp                           shift and go to state 92

state 122

    (33) statement -> IF LPAR exp RPAR statement ELSE statement .

    RBRACE          reduce using rule 33 (statement -> IF LPAR exp RPAR statement ELSE statement .)
    SEMICOLON       reduce using rule 33 (statement -> IF LPAR exp RPAR statement ELSE statement .)
    ELSE            reduce using rule 33 (statement -> IF LPAR exp RPAR statement ELSE statement .)

WARNING: 
WARNING: Conflicts:
WARNING: 
WARNING: shift/reduce conflict for AND in state 37 resolved as shift
WARNING: shift/reduce conflict for OR in state 37 resolved as shift
WARNING: shift/reduce conflict for MINUS in state 37 resolved as shift
WARNING: shift/reduce conflict for PLUS in state 37 resolved as shift
WARNING: shift/reduce conflict for TIMES in state 37 resolved as shift
WARNING: shift/reduce conflict for DIVIDE in state 37 resolved as shift
WARNING: shift/reduce conflict for EQUAL in state 37 resolved as shift
WARNING: shift/reduce conflict for NEQUAL in state 37 resolved as shift
WARNING: shift/reduce conflict for GREATER in state 37 resolved as shift
WARNING: shift/reduce conflict for LESS in state 37 resolved as shift
WARNING: shift/reduce conflict for GREATEREQ in state 37 resolved as shift
WARNING: shift/reduce conflict for LESSEQ in state 37 resolved as shift
WARNING: shift/reduce conflict for AND in state 72 resolved as shift
WARNING: shift/reduce conflict for OR in state 72 resolved as shift
WARNING: shift/reduce conflict for MINUS in state 72 resolved as shift
WARNING: shift/reduce conflict for PLUS in state 72 resolved as shift
WARNING: shift/reduce conflict for TIMES in state 72 resolved as shift
WARNING: shift/reduce conflict for DIVIDE in state 72 resolved as shift
WARNING: shift/reduce conflict for EQUAL in state 72 resolved as shift
WARNING: shift/reduce conflict for NEQUAL in state 72 resolved as shift
WARNING: shift/reduce conflict for GREATER in state 72 resolved as shift
WARNING: shift/reduce conflict for LESS in state 72 resolved as shift
WARNING: shift/reduce conflict for GREATEREQ in state 72 resolved as shift
WARNING: shift/reduce conflict for LESSEQ in state 72 resolved as shift
WARNING: shift/reduce conflict for AND in state 73 resolved as shift
WARNING: shift/reduce conflict for OR in state 73 resolved as shift
WARNING: shift/reduce conflict for MINUS in state 73 resolved as shift
WARNING: shift/reduce conflict for PLUS in state 73 resolved as shift
WARNING: shift/reduce conflict for TIMES in state 73 resolved as shift
WARNING: shift/reduce conflict for DIVIDE in state 73 resolved as shift
WARNING: shift/reduce conflict for EQUAL in state 73 resolved as shift
WARNING: shift/reduce conflict for NEQUAL in state 73 resolved as shift
WARNING: shift/reduce conflict for GREATER in state 73 resolved as shift
WARNING: shift/reduce conflict for LESS in state 73 resolved as shift
WARNING: shift/reduce conflict for GREATEREQ in state 73 resolved as shift
WARNING: shift/reduce conflict for LESSEQ in state 73 resolved as shift
WARNING: shift/reduce conflict for ELSE in state 120 resolved as shift
WARNING: reduce/reduce conflict in state 1 resolved using rule (fun_type -> BOOLEAN)
WARNING: rejected rule (type -> BOOLEAN) in state 1
WARNING: reduce/reduce conflict in state 4 resolved using rule (fun_type -> INT)
WARNING: rejected rule (type -> INT) in state 4
WARNING: reduce/reduce conflict in state 6 resolved using rule (fun_type -> CHAR)
WARNING: rejected rule (type -> CHAR) in state 6