parser.out

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

Unused terminals:

    COMMENT
    DOT
    SEMICOLON

Grammar

Rule 0     S' -> language
Rule 1     language -> mathpy
Rule 2     mathpy -> PROGRAM ID COLON declarations subroutines blocks END
Rule 3     mathpy -> PROGRAM ID COLON declarations subroutines blocks END PROGRAM
Rule 4     mathpy -> PROGRAM ID COLON declarations subroutines blocks END PROGRAM ID
Rule 5     declarations -> type COLON COLON variables declarations
Rule 6     declarations -> empty
Rule 7     type -> INTEGER
Rule 8     type -> REAL
Rule 9     variables -> variables COMMA ID
Rule 10    variables -> variables COMMA ID LPAREN INT RPAREN
Rule 11    variables -> variables COMMA ID LPAREN INT COMMA INT RPAREN
Rule 12    variables -> ID
Rule 13    variables -> ID LPAREN INT RPAREN
Rule 14    variables -> ID LPAREN INT COMMA INT RPAREN
Rule 15    matrix -> ID
Rule 16    matrix -> ID LPAREN INT RPAREN
Rule 17    matrix -> ID LPAREN INT COMMA INT RPAREN
Rule 18    matrix -> ID LPAREN ID RPAREN
Rule 19    matrix -> ID LPAREN ID COMMA ID RPAREN
Rule 20    index -> arithmetic COMMA arithmetic
Rule 21    index -> arithmetic
Rule 22    subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks END
Rule 23    subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks END SUBROUTINE
Rule 24    subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks END SUBROUTINE ID
Rule 25    subroutines -> empty
Rule 26    id_subroutine -> ID
Rule 27    blocks -> blocks assignment
Rule 28    blocks -> blocks if comparison then_if blocks conditionals END IF
Rule 29    blocks -> blocks do blocks IF comparison then_if blocks exit END IF blocks END DO
Rule 30    blocks -> blocks do assignment_do COMMA arithmetic colon blocks END DO
Rule 31    blocks -> blocks do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks END DO
Rule 32    blocks -> blocks ID LPAREN RPAREN
Rule 33    blocks -> blocks READ TIMES COMMA matrix
Rule 34    blocks -> blocks PRINT TIMES COMMA matrix
Rule 35    blocks -> blocks PRINT TIMES COMMA STRING
Rule 36    blocks -> empty
Rule 37    do -> DO
Rule 38    colon -> COLON
Rule 39    assignment_do -> ID ASSIGN arithmetic
Rule 40    exit -> EXIT
Rule 41    if -> IF
Rule 42    then_if -> THEN
Rule 43    conditionals -> else blocks
Rule 44    conditionals -> else IF comparison then_if blocks conditionals
Rule 45    conditionals -> else
Rule 46    else -> ELSE
Rule 47    else -> empty
Rule 48    assignment -> matrix ASSIGN arithmetic
Rule 49    arithmetic -> arithmetic PLUS term
Rule 50    arithmetic -> arithmetic MINUS term
Rule 51    arithmetic -> term
Rule 52    term -> term TIMES factor
Rule 53    term -> term DIVIDE factor
Rule 54    term -> factor
Rule 55    factor -> INT
Rule 56    factor -> FLOAT
Rule 57    factor -> matrix
Rule 58    factor -> LPAREN arithmetic RPAREN
Rule 59    comparison -> comparison OR comparisontwo
Rule 60    comparison -> comparisontwo
Rule 61    comparisontwo -> comparisontwo AND comparisonthree
Rule 62    comparisontwo -> comparisonthree
Rule 63    comparisonthree -> comparisonthree EQ comparisonfour
Rule 64    comparisonthree -> comparisonthree NEQ comparisonfour
Rule 65    comparisonthree -> comparisonthree LT comparisonfour
Rule 66    comparisonthree -> comparisonthree GT comparisonfour
Rule 67    comparisonthree -> comparisonthree LTE comparisonfour
Rule 68    comparisonthree -> comparisonthree GTE comparisonfour
Rule 69    comparisonthree -> comparisonfour
Rule 70    comparisonfour -> INT
Rule 71    comparisonfour -> FLOAT
Rule 72    comparisonfour -> matrix
Rule 73    comparisonfour -> LPAREN arithmetic RPAREN
Rule 74    comparisonfour -> LPAREN comparison RPAREN
Rule 75    empty -> <empty>

Terminals, with rules where they appear

AND                  : 61
ASSIGN               : 39 48
COLON                : 2 3 4 5 5 38
COMMA                : 9 10 11 11 14 17 19 20 30 31 33 34 35
COMMENT              : 
DIVIDE               : 53
DO                   : 29 30 31 37
DOT                  : 
ELSE                 : 46
END                  : 2 3 4 22 23 24 28 29 29 30 31 31
EQ                   : 63
EXIT                 : 40
FLOAT                : 56 71
GT                   : 66
GTE                  : 68
ID                   : 2 3 4 4 9 10 11 12 13 14 15 16 17 18 18 19 19 19 24 26 32 39
IF                   : 28 29 29 31 31 41 44
INT                  : 10 11 11 13 14 14 16 17 17 55 70
INTEGER              : 7
LPAREN               : 10 11 13 14 16 17 18 19 22 23 24 32 58 73 74
LT                   : 65
LTE                  : 67
MINUS                : 50
NEQ                  : 64
OR                   : 59
PLUS                 : 49
PRINT                : 34 35
PROGRAM              : 2 3 3 4 4
READ                 : 33
REAL                 : 8
RPAREN               : 10 11 13 14 16 17 18 19 22 23 24 32 58 73 74
SEMICOLON            : 
STRING               : 35
SUBROUTINE           : 22 23 23 24 24
THEN                 : 42
TIMES                : 33 34 35 52
error                : 

Nonterminals, with rules where they appear

arithmetic           : 20 20 21 30 31 39 48 49 50 58 73
assignment           : 27
assignment_do        : 30 31
blocks               : 2 3 4 22 23 24 27 28 28 29 29 29 29 30 30 31 31 31 32 33 34 35 43 44
colon                : 30 31
comparison           : 28 29 31 44 59 74
comparisonfour       : 63 64 65 66 67 68 69
comparisonthree      : 61 62 63 64 65 66 67 68
comparisontwo        : 59 60 61
conditionals         : 28 44
declarations         : 2 3 4 5
do                   : 29 30 31
else                 : 43 44 45
empty                : 6 25 36 47
exit                 : 29 31
factor               : 52 53 54
id_subroutine        : 22 23 24
if                   : 28
index                : 
language             : 0
mathpy               : 1
matrix               : 33 34 48 57 72
subroutines          : 2 3 4 22 23 24
term                 : 49 50 51 52 53
then_if              : 28 29 31 44
type                 : 5
variables            : 5 9 10 11

Parsing method: LALR

state 0

    (0) S' -> . language
    (1) language -> . mathpy
    (2) mathpy -> . PROGRAM ID COLON declarations subroutines blocks END
    (3) mathpy -> . PROGRAM ID COLON declarations subroutines blocks END PROGRAM
    (4) mathpy -> . PROGRAM ID COLON declarations subroutines blocks END PROGRAM ID

    PROGRAM         shift and go to state 3

    language                       shift and go to state 1
    mathpy                         shift and go to state 2

state 1

    (0) S' -> language .



state 2

    (1) language -> mathpy .

    $end            reduce using rule 1 (language -> mathpy .)


state 3

    (2) mathpy -> PROGRAM . ID COLON declarations subroutines blocks END
    (3) mathpy -> PROGRAM . ID COLON declarations subroutines blocks END PROGRAM
    (4) mathpy -> PROGRAM . ID COLON declarations subroutines blocks END PROGRAM ID

    ID              shift and go to state 4


state 4

    (2) mathpy -> PROGRAM ID . COLON declarations subroutines blocks END
    (3) mathpy -> PROGRAM ID . COLON declarations subroutines blocks END PROGRAM
    (4) mathpy -> PROGRAM ID . COLON declarations subroutines blocks END PROGRAM ID

    COLON           shift and go to state 5


state 5

    (2) mathpy -> PROGRAM ID COLON . declarations subroutines blocks END
    (3) mathpy -> PROGRAM ID COLON . declarations subroutines blocks END PROGRAM
    (4) mathpy -> PROGRAM ID COLON . declarations subroutines blocks END PROGRAM ID
    (5) declarations -> . type COLON COLON variables declarations
    (6) declarations -> . empty
    (7) type -> . INTEGER
    (8) type -> . REAL
    (75) empty -> .

    INTEGER         shift and go to state 9
    REAL            shift and go to state 10
    SUBROUTINE      reduce using rule 75 (empty -> .)
    END             reduce using rule 75 (empty -> .)
    ID              reduce using rule 75 (empty -> .)
    READ            reduce using rule 75 (empty -> .)
    PRINT           reduce using rule 75 (empty -> .)
    IF              reduce using rule 75 (empty -> .)
    DO              reduce using rule 75 (empty -> .)

    declarations                   shift and go to state 6
    type                           shift and go to state 7
    empty                          shift and go to state 8

state 6

    (2) mathpy -> PROGRAM ID COLON declarations . subroutines blocks END
    (3) mathpy -> PROGRAM ID COLON declarations . subroutines blocks END PROGRAM
    (4) mathpy -> PROGRAM ID COLON declarations . subroutines blocks END PROGRAM ID
    (22) subroutines -> . subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks END
    (23) subroutines -> . subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks END SUBROUTINE
    (24) subroutines -> . subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks END SUBROUTINE ID
    (25) subroutines -> . empty
    (75) empty -> .

    SUBROUTINE      reduce using rule 75 (empty -> .)
    END             reduce using rule 75 (empty -> .)
    ID              reduce using rule 75 (empty -> .)
    READ            reduce using rule 75 (empty -> .)
    PRINT           reduce using rule 75 (empty -> .)
    IF              reduce using rule 75 (empty -> .)
    DO              reduce using rule 75 (empty -> .)

    subroutines                    shift and go to state 11
    empty                          shift and go to state 12

state 7

    (5) declarations -> type . COLON COLON variables declarations

    COLON           shift and go to state 13


state 8

    (6) declarations -> empty .

    SUBROUTINE      reduce using rule 6 (declarations -> empty .)
    END             reduce using rule 6 (declarations -> empty .)
    ID              reduce using rule 6 (declarations -> empty .)
    READ            reduce using rule 6 (declarations -> empty .)
    PRINT           reduce using rule 6 (declarations -> empty .)
    IF              reduce using rule 6 (declarations -> empty .)
    DO              reduce using rule 6 (declarations -> empty .)


state 9

    (7) type -> INTEGER .

    COLON           reduce using rule 7 (type -> INTEGER .)


state 10

    (8) type -> REAL .

    COLON           reduce using rule 8 (type -> REAL .)


state 11

    (2) mathpy -> PROGRAM ID COLON declarations subroutines . blocks END
    (3) mathpy -> PROGRAM ID COLON declarations subroutines . blocks END PROGRAM
    (4) mathpy -> PROGRAM ID COLON declarations subroutines . blocks END PROGRAM ID
    (22) subroutines -> subroutines . SUBROUTINE id_subroutine LPAREN RPAREN blocks END
    (23) subroutines -> subroutines . SUBROUTINE id_subroutine LPAREN RPAREN blocks END SUBROUTINE
    (24) subroutines -> subroutines . SUBROUTINE id_subroutine LPAREN RPAREN blocks END SUBROUTINE ID
    (27) blocks -> . blocks assignment
    (28) blocks -> . blocks if comparison then_if blocks conditionals END IF
    (29) blocks -> . blocks do blocks IF comparison then_if blocks exit END IF blocks END DO
    (30) blocks -> . blocks do assignment_do COMMA arithmetic colon blocks END DO
    (31) blocks -> . blocks do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks END DO
    (32) blocks -> . blocks ID LPAREN RPAREN
    (33) blocks -> . blocks READ TIMES COMMA matrix
    (34) blocks -> . blocks PRINT TIMES COMMA matrix
    (35) blocks -> . blocks PRINT TIMES COMMA STRING
    (36) blocks -> . empty
    (75) empty -> .

    SUBROUTINE      shift and go to state 15
    END             reduce using rule 75 (empty -> .)
    ID              reduce using rule 75 (empty -> .)
    READ            reduce using rule 75 (empty -> .)
    PRINT           reduce using rule 75 (empty -> .)
    IF              reduce using rule 75 (empty -> .)
    DO              reduce using rule 75 (empty -> .)

    blocks                         shift and go to state 14
    empty                          shift and go to state 16

state 12

    (25) subroutines -> empty .

    SUBROUTINE      reduce using rule 25 (subroutines -> empty .)
    END             reduce using rule 25 (subroutines -> empty .)
    ID              reduce using rule 25 (subroutines -> empty .)
    READ            reduce using rule 25 (subroutines -> empty .)
    PRINT           reduce using rule 25 (subroutines -> empty .)
    IF              reduce using rule 25 (subroutines -> empty .)
    DO              reduce using rule 25 (subroutines -> empty .)


state 13

    (5) declarations -> type COLON . COLON variables declarations

    COLON           shift and go to state 17


state 14

    (2) mathpy -> PROGRAM ID COLON declarations subroutines blocks . END
    (3) mathpy -> PROGRAM ID COLON declarations subroutines blocks . END PROGRAM
    (4) mathpy -> PROGRAM ID COLON declarations subroutines blocks . END PROGRAM ID
    (27) blocks -> blocks . assignment
    (28) blocks -> blocks . if comparison then_if blocks conditionals END IF
    (29) blocks -> blocks . do blocks IF comparison then_if blocks exit END IF blocks END DO
    (30) blocks -> blocks . do assignment_do COMMA arithmetic colon blocks END DO
    (31) blocks -> blocks . do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks END DO
    (32) blocks -> blocks . ID LPAREN RPAREN
    (33) blocks -> blocks . READ TIMES COMMA matrix
    (34) blocks -> blocks . PRINT TIMES COMMA matrix
    (35) blocks -> blocks . PRINT TIMES COMMA STRING
    (48) assignment -> . matrix ASSIGN arithmetic
    (41) if -> . IF
    (37) do -> . DO
    (15) matrix -> . ID
    (16) matrix -> . ID LPAREN INT RPAREN
    (17) matrix -> . ID LPAREN INT COMMA INT RPAREN
    (18) matrix -> . ID LPAREN ID RPAREN
    (19) matrix -> . ID LPAREN ID COMMA ID RPAREN

    END             shift and go to state 19
    ID              shift and go to state 18
    READ            shift and go to state 25
    PRINT           shift and go to state 27
    IF              shift and go to state 22
    DO              shift and go to state 24

    assignment                     shift and go to state 20
    if                             shift and go to state 21
    do                             shift and go to state 23
    matrix                         shift and go to state 26

state 15

    (22) subroutines -> subroutines SUBROUTINE . id_subroutine LPAREN RPAREN blocks END
    (23) subroutines -> subroutines SUBROUTINE . id_subroutine LPAREN RPAREN blocks END SUBROUTINE
    (24) subroutines -> subroutines SUBROUTINE . id_subroutine LPAREN RPAREN blocks END SUBROUTINE ID
    (26) id_subroutine -> . ID

    ID              shift and go to state 29

    id_subroutine                  shift and go to state 28

state 16

    (36) blocks -> empty .

    END             reduce using rule 36 (blocks -> empty .)
    ID              reduce using rule 36 (blocks -> empty .)
    READ            reduce using rule 36 (blocks -> empty .)
    PRINT           reduce using rule 36 (blocks -> empty .)
    IF              reduce using rule 36 (blocks -> empty .)
    DO              reduce using rule 36 (blocks -> empty .)
    ELSE            reduce using rule 36 (blocks -> empty .)
    EXIT            reduce using rule 36 (blocks -> empty .)


state 17

    (5) declarations -> type COLON COLON . variables declarations
    (9) variables -> . variables COMMA ID
    (10) variables -> . variables COMMA ID LPAREN INT RPAREN
    (11) variables -> . variables COMMA ID LPAREN INT COMMA INT RPAREN
    (12) variables -> . ID
    (13) variables -> . ID LPAREN INT RPAREN
    (14) variables -> . ID LPAREN INT COMMA INT RPAREN

    ID              shift and go to state 31

    variables                      shift and go to state 30

state 18

    (32) blocks -> blocks ID . LPAREN RPAREN
    (15) matrix -> ID .
    (16) matrix -> ID . LPAREN INT RPAREN
    (17) matrix -> ID . LPAREN INT COMMA INT RPAREN
    (18) matrix -> ID . LPAREN ID RPAREN
    (19) matrix -> ID . LPAREN ID COMMA ID RPAREN

    LPAREN          shift and go to state 32
    ASSIGN          reduce using rule 15 (matrix -> ID .)


state 19

    (2) mathpy -> PROGRAM ID COLON declarations subroutines blocks END .
    (3) mathpy -> PROGRAM ID COLON declarations subroutines blocks END . PROGRAM
    (4) mathpy -> PROGRAM ID COLON declarations subroutines blocks END . PROGRAM ID

    $end            reduce using rule 2 (mathpy -> PROGRAM ID COLON declarations subroutines blocks END .)
    PROGRAM         shift and go to state 33


state 20

    (27) blocks -> blocks assignment .

    END             reduce using rule 27 (blocks -> blocks assignment .)
    ID              reduce using rule 27 (blocks -> blocks assignment .)
    READ            reduce using rule 27 (blocks -> blocks assignment .)
    PRINT           reduce using rule 27 (blocks -> blocks assignment .)
    IF              reduce using rule 27 (blocks -> blocks assignment .)
    DO              reduce using rule 27 (blocks -> blocks assignment .)
    ELSE            reduce using rule 27 (blocks -> blocks assignment .)
    EXIT            reduce using rule 27 (blocks -> blocks assignment .)


state 21

    (28) blocks -> blocks if . comparison then_if blocks conditionals END IF
    (59) comparison -> . comparison OR comparisontwo
    (60) comparison -> . comparisontwo
    (61) comparisontwo -> . comparisontwo AND comparisonthree
    (62) comparisontwo -> . comparisonthree
    (63) comparisonthree -> . comparisonthree EQ comparisonfour
    (64) comparisonthree -> . comparisonthree NEQ comparisonfour
    (65) comparisonthree -> . comparisonthree LT comparisonfour
    (66) comparisonthree -> . comparisonthree GT comparisonfour
    (67) comparisonthree -> . comparisonthree LTE comparisonfour
    (68) comparisonthree -> . comparisonthree GTE comparisonfour
    (69) comparisonthree -> . comparisonfour
    (70) comparisonfour -> . INT
    (71) comparisonfour -> . FLOAT
    (72) comparisonfour -> . matrix
    (73) comparisonfour -> . LPAREN arithmetic RPAREN
    (74) comparisonfour -> . LPAREN comparison RPAREN
    (15) matrix -> . ID
    (16) matrix -> . ID LPAREN INT RPAREN
    (17) matrix -> . ID LPAREN INT COMMA INT RPAREN
    (18) matrix -> . ID LPAREN ID RPAREN
    (19) matrix -> . ID LPAREN ID COMMA ID RPAREN

    INT             shift and go to state 38
    FLOAT           shift and go to state 39
    LPAREN          shift and go to state 41
    ID              shift and go to state 42

    comparison                     shift and go to state 34
    comparisontwo                  shift and go to state 35
    comparisonthree                shift and go to state 36
    comparisonfour                 shift and go to state 37
    matrix                         shift and go to state 40

state 22

    (41) if -> IF .

    INT             reduce using rule 41 (if -> IF .)
    FLOAT           reduce using rule 41 (if -> IF .)
    LPAREN          reduce using rule 41 (if -> IF .)
    ID              reduce using rule 41 (if -> IF .)


state 23

    (29) blocks -> blocks do . blocks IF comparison then_if blocks exit END IF blocks END DO
    (30) blocks -> blocks do . assignment_do COMMA arithmetic colon blocks END DO
    (31) blocks -> blocks do . assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks END DO
    (27) blocks -> . blocks assignment
    (28) blocks -> . blocks if comparison then_if blocks conditionals END IF
    (29) blocks -> . blocks do blocks IF comparison then_if blocks exit END IF blocks END DO
    (30) blocks -> . blocks do assignment_do COMMA arithmetic colon blocks END DO
    (31) blocks -> . blocks do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks END DO
    (32) blocks -> . blocks ID LPAREN RPAREN
    (33) blocks -> . blocks READ TIMES COMMA matrix
    (34) blocks -> . blocks PRINT TIMES COMMA matrix
    (35) blocks -> . blocks PRINT TIMES COMMA STRING
    (36) blocks -> . empty
    (39) assignment_do -> . ID ASSIGN arithmetic
    (75) empty -> .

  ! shift/reduce conflict for ID resolved as shift
    ID              shift and go to state 45
    IF              reduce using rule 75 (empty -> .)
    READ            reduce using rule 75 (empty -> .)
    PRINT           reduce using rule 75 (empty -> .)
    DO              reduce using rule 75 (empty -> .)

  ! ID              [ reduce using rule 75 (empty -> .) ]

    blocks                         shift and go to state 43
    assignment_do                  shift and go to state 44
    empty                          shift and go to state 16

state 24

    (37) do -> DO .

    ID              reduce using rule 37 (do -> DO .)
    IF              reduce using rule 37 (do -> DO .)
    READ            reduce using rule 37 (do -> DO .)
    PRINT           reduce using rule 37 (do -> DO .)
    DO              reduce using rule 37 (do -> DO .)


state 25

    (33) blocks -> blocks READ . TIMES COMMA matrix

    TIMES           shift and go to state 46


state 26

    (48) assignment -> matrix . ASSIGN arithmetic

    ASSIGN          shift and go to state 47


state 27

    (34) blocks -> blocks PRINT . TIMES COMMA matrix
    (35) blocks -> blocks PRINT . TIMES COMMA STRING

    TIMES           shift and go to state 48


state 28

    (22) subroutines -> subroutines SUBROUTINE id_subroutine . LPAREN RPAREN blocks END
    (23) subroutines -> subroutines SUBROUTINE id_subroutine . LPAREN RPAREN blocks END SUBROUTINE
    (24) subroutines -> subroutines SUBROUTINE id_subroutine . LPAREN RPAREN blocks END SUBROUTINE ID

    LPAREN          shift and go to state 49


state 29

    (26) id_subroutine -> ID .

    LPAREN          reduce using rule 26 (id_subroutine -> ID .)


state 30

    (5) declarations -> type COLON COLON variables . declarations
    (9) variables -> variables . COMMA ID
    (10) variables -> variables . COMMA ID LPAREN INT RPAREN
    (11) variables -> variables . COMMA ID LPAREN INT COMMA INT RPAREN
    (5) declarations -> . type COLON COLON variables declarations
    (6) declarations -> . empty
    (7) type -> . INTEGER
    (8) type -> . REAL
    (75) empty -> .

    COMMA           shift and go to state 51
    INTEGER         shift and go to state 9
    REAL            shift and go to state 10
    SUBROUTINE      reduce using rule 75 (empty -> .)
    END             reduce using rule 75 (empty -> .)
    ID              reduce using rule 75 (empty -> .)
    READ            reduce using rule 75 (empty -> .)
    PRINT           reduce using rule 75 (empty -> .)
    IF              reduce using rule 75 (empty -> .)
    DO              reduce using rule 75 (empty -> .)

    type                           shift and go to state 7
    declarations                   shift and go to state 50
    empty                          shift and go to state 8

state 31

    (12) variables -> ID .
    (13) variables -> ID . LPAREN INT RPAREN
    (14) variables -> ID . LPAREN INT COMMA INT RPAREN

    COMMA           reduce using rule 12 (variables -> ID .)
    INTEGER         reduce using rule 12 (variables -> ID .)
    REAL            reduce using rule 12 (variables -> ID .)
    SUBROUTINE      reduce using rule 12 (variables -> ID .)
    END             reduce using rule 12 (variables -> ID .)
    ID              reduce using rule 12 (variables -> ID .)
    READ            reduce using rule 12 (variables -> ID .)
    PRINT           reduce using rule 12 (variables -> ID .)
    IF              reduce using rule 12 (variables -> ID .)
    DO              reduce using rule 12 (variables -> ID .)
    LPAREN          shift and go to state 52


state 32

    (32) blocks -> blocks ID LPAREN . RPAREN
    (16) matrix -> ID LPAREN . INT RPAREN
    (17) matrix -> ID LPAREN . INT COMMA INT RPAREN
    (18) matrix -> ID LPAREN . ID RPAREN
    (19) matrix -> ID LPAREN . ID COMMA ID RPAREN

    RPAREN          shift and go to state 54
    INT             shift and go to state 55
    ID              shift and go to state 53


state 33

    (3) mathpy -> PROGRAM ID COLON declarations subroutines blocks END PROGRAM .
    (4) mathpy -> PROGRAM ID COLON declarations subroutines blocks END PROGRAM . ID

    $end            reduce using rule 3 (mathpy -> PROGRAM ID COLON declarations subroutines blocks END PROGRAM .)
    ID              shift and go to state 56


state 34

    (28) blocks -> blocks if comparison . then_if blocks conditionals END IF
    (59) comparison -> comparison . OR comparisontwo
    (42) then_if -> . THEN

    OR              shift and go to state 58
    THEN            shift and go to state 59

    then_if                        shift and go to state 57

state 35

    (60) comparison -> comparisontwo .
    (61) comparisontwo -> comparisontwo . AND comparisonthree

    OR              reduce using rule 60 (comparison -> comparisontwo .)
    THEN            reduce using rule 60 (comparison -> comparisontwo .)
    RPAREN          reduce using rule 60 (comparison -> comparisontwo .)
    AND             shift and go to state 60


state 36

    (62) comparisontwo -> comparisonthree .
    (63) comparisonthree -> comparisonthree . EQ comparisonfour
    (64) comparisonthree -> comparisonthree . NEQ comparisonfour
    (65) comparisonthree -> comparisonthree . LT comparisonfour
    (66) comparisonthree -> comparisonthree . GT comparisonfour
    (67) comparisonthree -> comparisonthree . LTE comparisonfour
    (68) comparisonthree -> comparisonthree . GTE comparisonfour

    AND             reduce using rule 62 (comparisontwo -> comparisonthree .)
    OR              reduce using rule 62 (comparisontwo -> comparisonthree .)
    THEN            reduce using rule 62 (comparisontwo -> comparisonthree .)
    RPAREN          reduce using rule 62 (comparisontwo -> comparisonthree .)
    EQ              shift and go to state 61
    NEQ             shift and go to state 62
    LT              shift and go to state 63
    GT              shift and go to state 64
    LTE             shift and go to state 65
    GTE             shift and go to state 66


state 37

    (69) comparisonthree -> comparisonfour .

    EQ              reduce using rule 69 (comparisonthree -> comparisonfour .)
    NEQ             reduce using rule 69 (comparisonthree -> comparisonfour .)
    LT              reduce using rule 69 (comparisonthree -> comparisonfour .)
    GT              reduce using rule 69 (comparisonthree -> comparisonfour .)
    LTE             reduce using rule 69 (comparisonthree -> comparisonfour .)
    GTE             reduce using rule 69 (comparisonthree -> comparisonfour .)
    AND             reduce using rule 69 (comparisonthree -> comparisonfour .)
    OR              reduce using rule 69 (comparisonthree -> comparisonfour .)
    THEN            reduce using rule 69 (comparisonthree -> comparisonfour .)
    RPAREN          reduce using rule 69 (comparisonthree -> comparisonfour .)


state 38

    (70) comparisonfour -> INT .

    EQ              reduce using rule 70 (comparisonfour -> INT .)
    NEQ             reduce using rule 70 (comparisonfour -> INT .)
    LT              reduce using rule 70 (comparisonfour -> INT .)
    GT              reduce using rule 70 (comparisonfour -> INT .)
    LTE             reduce using rule 70 (comparisonfour -> INT .)
    GTE             reduce using rule 70 (comparisonfour -> INT .)
    AND             reduce using rule 70 (comparisonfour -> INT .)
    OR              reduce using rule 70 (comparisonfour -> INT .)
    THEN            reduce using rule 70 (comparisonfour -> INT .)
    RPAREN          reduce using rule 70 (comparisonfour -> INT .)


state 39

    (71) comparisonfour -> FLOAT .

    EQ              reduce using rule 71 (comparisonfour -> FLOAT .)
    NEQ             reduce using rule 71 (comparisonfour -> FLOAT .)
    LT              reduce using rule 71 (comparisonfour -> FLOAT .)
    GT              reduce using rule 71 (comparisonfour -> FLOAT .)
    LTE             reduce using rule 71 (comparisonfour -> FLOAT .)
    GTE             reduce using rule 71 (comparisonfour -> FLOAT .)
    AND             reduce using rule 71 (comparisonfour -> FLOAT .)
    OR              reduce using rule 71 (comparisonfour -> FLOAT .)
    THEN            reduce using rule 71 (comparisonfour -> FLOAT .)
    RPAREN          reduce using rule 71 (comparisonfour -> FLOAT .)


state 40

    (72) comparisonfour -> matrix .

    EQ              reduce using rule 72 (comparisonfour -> matrix .)
    NEQ             reduce using rule 72 (comparisonfour -> matrix .)
    LT              reduce using rule 72 (comparisonfour -> matrix .)
    GT              reduce using rule 72 (comparisonfour -> matrix .)
    LTE             reduce using rule 72 (comparisonfour -> matrix .)
    GTE             reduce using rule 72 (comparisonfour -> matrix .)
    AND             reduce using rule 72 (comparisonfour -> matrix .)
    OR              reduce using rule 72 (comparisonfour -> matrix .)
    THEN            reduce using rule 72 (comparisonfour -> matrix .)
    RPAREN          reduce using rule 72 (comparisonfour -> matrix .)


state 41

    (73) comparisonfour -> LPAREN . arithmetic RPAREN
    (74) comparisonfour -> LPAREN . comparison RPAREN
    (49) arithmetic -> . arithmetic PLUS term
    (50) arithmetic -> . arithmetic MINUS term
    (51) arithmetic -> . term
    (59) comparison -> . comparison OR comparisontwo
    (60) comparison -> . comparisontwo
    (52) term -> . term TIMES factor
    (53) term -> . term DIVIDE factor
    (54) term -> . factor
    (61) comparisontwo -> . comparisontwo AND comparisonthree
    (62) comparisontwo -> . comparisonthree
    (55) factor -> . INT
    (56) factor -> . FLOAT
    (57) factor -> . matrix
    (58) factor -> . LPAREN arithmetic RPAREN
    (63) comparisonthree -> . comparisonthree EQ comparisonfour
    (64) comparisonthree -> . comparisonthree NEQ comparisonfour
    (65) comparisonthree -> . comparisonthree LT comparisonfour
    (66) comparisonthree -> . comparisonthree GT comparisonfour
    (67) comparisonthree -> . comparisonthree LTE comparisonfour
    (68) comparisonthree -> . comparisonthree GTE comparisonfour
    (69) comparisonthree -> . comparisonfour
    (15) matrix -> . ID
    (16) matrix -> . ID LPAREN INT RPAREN
    (17) matrix -> . ID LPAREN INT COMMA INT RPAREN
    (18) matrix -> . ID LPAREN ID RPAREN
    (19) matrix -> . ID LPAREN ID COMMA ID RPAREN
    (70) comparisonfour -> . INT
    (71) comparisonfour -> . FLOAT
    (72) comparisonfour -> . matrix
    (73) comparisonfour -> . LPAREN arithmetic RPAREN
    (74) comparisonfour -> . LPAREN comparison RPAREN

    INT             shift and go to state 72
    FLOAT           shift and go to state 73
    LPAREN          shift and go to state 67
    ID              shift and go to state 42

    arithmetic                     shift and go to state 68
    comparison                     shift and go to state 69
    term                           shift and go to state 70
    comparisontwo                  shift and go to state 35
    factor                         shift and go to state 71
    comparisonthree                shift and go to state 36
    matrix                         shift and go to state 74
    comparisonfour                 shift and go to state 37

state 42

    (15) matrix -> ID .
    (16) matrix -> ID . LPAREN INT RPAREN
    (17) matrix -> ID . LPAREN INT COMMA INT RPAREN
    (18) matrix -> ID . LPAREN ID RPAREN
    (19) matrix -> ID . LPAREN ID COMMA ID RPAREN

    EQ              reduce using rule 15 (matrix -> ID .)
    NEQ             reduce using rule 15 (matrix -> ID .)
    LT              reduce using rule 15 (matrix -> ID .)
    GT              reduce using rule 15 (matrix -> ID .)
    LTE             reduce using rule 15 (matrix -> ID .)
    GTE             reduce using rule 15 (matrix -> ID .)
    AND             reduce using rule 15 (matrix -> ID .)
    OR              reduce using rule 15 (matrix -> ID .)
    THEN            reduce using rule 15 (matrix -> ID .)
    TIMES           reduce using rule 15 (matrix -> ID .)
    DIVIDE          reduce using rule 15 (matrix -> ID .)
    RPAREN          reduce using rule 15 (matrix -> ID .)
    PLUS            reduce using rule 15 (matrix -> ID .)
    MINUS           reduce using rule 15 (matrix -> ID .)
    END             reduce using rule 15 (matrix -> ID .)
    ID              reduce using rule 15 (matrix -> ID .)
    READ            reduce using rule 15 (matrix -> ID .)
    PRINT           reduce using rule 15 (matrix -> ID .)
    IF              reduce using rule 15 (matrix -> ID .)
    DO              reduce using rule 15 (matrix -> ID .)
    ELSE            reduce using rule 15 (matrix -> ID .)
    EXIT            reduce using rule 15 (matrix -> ID .)
    COLON           reduce using rule 15 (matrix -> ID .)
    COMMA           reduce using rule 15 (matrix -> ID .)
    LPAREN          shift and go to state 75


state 43

    (29) blocks -> blocks do blocks . IF comparison then_if blocks exit END IF blocks END DO
    (27) blocks -> blocks . assignment
    (28) blocks -> blocks . if comparison then_if blocks conditionals END IF
    (29) blocks -> blocks . do blocks IF comparison then_if blocks exit END IF blocks END DO
    (30) blocks -> blocks . do assignment_do COMMA arithmetic colon blocks END DO
    (31) blocks -> blocks . do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks END DO
    (32) blocks -> blocks . ID LPAREN RPAREN
    (33) blocks -> blocks . READ TIMES COMMA matrix
    (34) blocks -> blocks . PRINT TIMES COMMA matrix
    (35) blocks -> blocks . PRINT TIMES COMMA STRING
    (48) assignment -> . matrix ASSIGN arithmetic
    (41) if -> . IF
    (37) do -> . DO
    (15) matrix -> . ID
    (16) matrix -> . ID LPAREN INT RPAREN
    (17) matrix -> . ID LPAREN INT COMMA INT RPAREN
    (18) matrix -> . ID LPAREN ID RPAREN
    (19) matrix -> . ID LPAREN ID COMMA ID RPAREN

    IF              shift and go to state 76
    ID              shift and go to state 18
    READ            shift and go to state 25
    PRINT           shift and go to state 27
    DO              shift and go to state 24

    do                             shift and go to state 23
    assignment                     shift and go to state 20
    if                             shift and go to state 21
    matrix                         shift and go to state 26

state 44

    (30) blocks -> blocks do assignment_do . COMMA arithmetic colon blocks END DO
    (31) blocks -> blocks do assignment_do . COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks END DO

    COMMA           shift and go to state 77


state 45

    (39) assignment_do -> ID . ASSIGN arithmetic

    ASSIGN          shift and go to state 78


state 46

    (33) blocks -> blocks READ TIMES . COMMA matrix

    COMMA           shift and go to state 79


state 47

    (48) assignment -> matrix ASSIGN . arithmetic
    (49) arithmetic -> . arithmetic PLUS term
    (50) arithmetic -> . arithmetic MINUS term
    (51) arithmetic -> . term
    (52) term -> . term TIMES factor
    (53) term -> . term DIVIDE factor
    (54) term -> . factor
    (55) factor -> . INT
    (56) factor -> . FLOAT
    (57) factor -> . matrix
    (58) factor -> . LPAREN arithmetic RPAREN
    (15) matrix -> . ID
    (16) matrix -> . ID LPAREN INT RPAREN
    (17) matrix -> . ID LPAREN INT COMMA INT RPAREN
    (18) matrix -> . ID LPAREN ID RPAREN
    (19) matrix -> . ID LPAREN ID COMMA ID RPAREN

    INT             shift and go to state 82
    FLOAT           shift and go to state 83
    LPAREN          shift and go to state 84
    ID              shift and go to state 42

    matrix                         shift and go to state 80
    arithmetic                     shift and go to state 81
    term                           shift and go to state 70
    factor                         shift and go to state 71

state 48

    (34) blocks -> blocks PRINT TIMES . COMMA matrix
    (35) blocks -> blocks PRINT TIMES . COMMA STRING

    COMMA           shift and go to state 85


state 49

    (22) subroutines -> subroutines SUBROUTINE id_subroutine LPAREN . RPAREN blocks END
    (23) subroutines -> subroutines SUBROUTINE id_subroutine LPAREN . RPAREN blocks END SUBROUTINE
    (24) subroutines -> subroutines SUBROUTINE id_subroutine LPAREN . RPAREN blocks END SUBROUTINE ID

    RPAREN          shift and go to state 86


state 50

    (5) declarations -> type COLON COLON variables declarations .

    SUBROUTINE      reduce using rule 5 (declarations -> type COLON COLON variables declarations .)
    END             reduce using rule 5 (declarations -> type COLON COLON variables declarations .)
    ID              reduce using rule 5 (declarations -> type COLON COLON variables declarations .)
    READ            reduce using rule 5 (declarations -> type COLON COLON variables declarations .)
    PRINT           reduce using rule 5 (declarations -> type COLON COLON variables declarations .)
    IF              reduce using rule 5 (declarations -> type COLON COLON variables declarations .)
    DO              reduce using rule 5 (declarations -> type COLON COLON variables declarations .)


state 51

    (9) variables -> variables COMMA . ID
    (10) variables -> variables COMMA . ID LPAREN INT RPAREN
    (11) variables -> variables COMMA . ID LPAREN INT COMMA INT RPAREN

    ID              shift and go to state 87


state 52

    (13) variables -> ID LPAREN . INT RPAREN
    (14) variables -> ID LPAREN . INT COMMA INT RPAREN

    INT             shift and go to state 88


state 53

    (18) matrix -> ID LPAREN ID . RPAREN
    (19) matrix -> ID LPAREN ID . COMMA ID RPAREN

    RPAREN          shift and go to state 89
    COMMA           shift and go to state 90


state 54

    (32) blocks -> blocks ID LPAREN RPAREN .

    END             reduce using rule 32 (blocks -> blocks ID LPAREN RPAREN .)
    ID              reduce using rule 32 (blocks -> blocks ID LPAREN RPAREN .)
    READ            reduce using rule 32 (blocks -> blocks ID LPAREN RPAREN .)
    PRINT           reduce using rule 32 (blocks -> blocks ID LPAREN RPAREN .)
    IF              reduce using rule 32 (blocks -> blocks ID LPAREN RPAREN .)
    DO              reduce using rule 32 (blocks -> blocks ID LPAREN RPAREN .)
    ELSE            reduce using rule 32 (blocks -> blocks ID LPAREN RPAREN .)
    EXIT            reduce using rule 32 (blocks -> blocks ID LPAREN RPAREN .)


state 55

    (16) matrix -> ID LPAREN INT . RPAREN
    (17) matrix -> ID LPAREN INT . COMMA INT RPAREN

    RPAREN          shift and go to state 91
    COMMA           shift and go to state 92


state 56

    (4) mathpy -> PROGRAM ID COLON declarations subroutines blocks END PROGRAM ID .

    $end            reduce using rule 4 (mathpy -> PROGRAM ID COLON declarations subroutines blocks END PROGRAM ID .)


state 57

    (28) blocks -> blocks if comparison then_if . blocks conditionals END IF
    (27) blocks -> . blocks assignment
    (28) blocks -> . blocks if comparison then_if blocks conditionals END IF
    (29) blocks -> . blocks do blocks IF comparison then_if blocks exit END IF blocks END DO
    (30) blocks -> . blocks do assignment_do COMMA arithmetic colon blocks END DO
    (31) blocks -> . blocks do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks END DO
    (32) blocks -> . blocks ID LPAREN RPAREN
    (33) blocks -> . blocks READ TIMES COMMA matrix
    (34) blocks -> . blocks PRINT TIMES COMMA matrix
    (35) blocks -> . blocks PRINT TIMES COMMA STRING
    (36) blocks -> . empty
    (75) empty -> .

    ID              reduce using rule 75 (empty -> .)
    READ            reduce using rule 75 (empty -> .)
    PRINT           reduce using rule 75 (empty -> .)
    IF              reduce using rule 75 (empty -> .)
    DO              reduce using rule 75 (empty -> .)
    ELSE            reduce using rule 75 (empty -> .)
    END             reduce using rule 75 (empty -> .)

    blocks                         shift and go to state 93
    empty                          shift and go to state 16

state 58

    (59) comparison -> comparison OR . comparisontwo
    (61) comparisontwo -> . comparisontwo AND comparisonthree
    (62) comparisontwo -> . comparisonthree
    (63) comparisonthree -> . comparisonthree EQ comparisonfour
    (64) comparisonthree -> . comparisonthree NEQ comparisonfour
    (65) comparisonthree -> . comparisonthree LT comparisonfour
    (66) comparisonthree -> . comparisonthree GT comparisonfour
    (67) comparisonthree -> . comparisonthree LTE comparisonfour
    (68) comparisonthree -> . comparisonthree GTE comparisonfour
    (69) comparisonthree -> . comparisonfour
    (70) comparisonfour -> . INT
    (71) comparisonfour -> . FLOAT
    (72) comparisonfour -> . matrix
    (73) comparisonfour -> . LPAREN arithmetic RPAREN
    (74) comparisonfour -> . LPAREN comparison RPAREN
    (15) matrix -> . ID
    (16) matrix -> . ID LPAREN INT RPAREN
    (17) matrix -> . ID LPAREN INT COMMA INT RPAREN
    (18) matrix -> . ID LPAREN ID RPAREN
    (19) matrix -> . ID LPAREN ID COMMA ID RPAREN

    INT             shift and go to state 38
    FLOAT           shift and go to state 39
    LPAREN          shift and go to state 41
    ID              shift and go to state 42

    comparisontwo                  shift and go to state 94
    comparisonthree                shift and go to state 36
    comparisonfour                 shift and go to state 37
    matrix                         shift and go to state 40

state 59

    (42) then_if -> THEN .

    ID              reduce using rule 42 (then_if -> THEN .)
    READ            reduce using rule 42 (then_if -> THEN .)
    PRINT           reduce using rule 42 (then_if -> THEN .)
    IF              reduce using rule 42 (then_if -> THEN .)
    DO              reduce using rule 42 (then_if -> THEN .)
    ELSE            reduce using rule 42 (then_if -> THEN .)
    END             reduce using rule 42 (then_if -> THEN .)
    EXIT            reduce using rule 42 (then_if -> THEN .)


state 60

    (61) comparisontwo -> comparisontwo AND . comparisonthree
    (63) comparisonthree -> . comparisonthree EQ comparisonfour
    (64) comparisonthree -> . comparisonthree NEQ comparisonfour
    (65) comparisonthree -> . comparisonthree LT comparisonfour
    (66) comparisonthree -> . comparisonthree GT comparisonfour
    (67) comparisonthree -> . comparisonthree LTE comparisonfour
    (68) comparisonthree -> . comparisonthree GTE comparisonfour
    (69) comparisonthree -> . comparisonfour
    (70) comparisonfour -> . INT
    (71) comparisonfour -> . FLOAT
    (72) comparisonfour -> . matrix
    (73) comparisonfour -> . LPAREN arithmetic RPAREN
    (74) comparisonfour -> . LPAREN comparison RPAREN
    (15) matrix -> . ID
    (16) matrix -> . ID LPAREN INT RPAREN
    (17) matrix -> . ID LPAREN INT COMMA INT RPAREN
    (18) matrix -> . ID LPAREN ID RPAREN
    (19) matrix -> . ID LPAREN ID COMMA ID RPAREN

    INT             shift and go to state 38
    FLOAT           shift and go to state 39
    LPAREN          shift and go to state 41
    ID              shift and go to state 42

    comparisonthree                shift and go to state 95
    comparisonfour                 shift and go to state 37
    matrix                         shift and go to state 40

state 61

    (63) comparisonthree -> comparisonthree EQ . comparisonfour
    (70) comparisonfour -> . INT
    (71) comparisonfour -> . FLOAT
    (72) comparisonfour -> . matrix
    (73) comparisonfour -> . LPAREN arithmetic RPAREN
    (74) comparisonfour -> . LPAREN comparison RPAREN
    (15) matrix -> . ID
    (16) matrix -> . ID LPAREN INT RPAREN
    (17) matrix -> . ID LPAREN INT COMMA INT RPAREN
    (18) matrix -> . ID LPAREN ID RPAREN
    (19) matrix -> . ID LPAREN ID COMMA ID RPAREN

    INT             shift and go to state 38
    FLOAT           shift and go to state 39
    LPAREN          shift and go to state 41
    ID              shift and go to state 42

    comparisonfour                 shift and go to state 96
    matrix                         shift and go to state 40

state 62

    (64) comparisonthree -> comparisonthree NEQ . comparisonfour
    (70) comparisonfour -> . INT
    (71) comparisonfour -> . FLOAT
    (72) comparisonfour -> . matrix
    (73) comparisonfour -> . LPAREN arithmetic RPAREN
    (74) comparisonfour -> . LPAREN comparison RPAREN
    (15) matrix -> . ID
    (16) matrix -> . ID LPAREN INT RPAREN
    (17) matrix -> . ID LPAREN INT COMMA INT RPAREN
    (18) matrix -> . ID LPAREN ID RPAREN
    (19) matrix -> . ID LPAREN ID COMMA ID RPAREN

    INT             shift and go to state 38
    FLOAT           shift and go to state 39
    LPAREN          shift and go to state 41
    ID              shift and go to state 42

    comparisonfour                 shift and go to state 97
    matrix                         shift and go to state 40

state 63

    (65) comparisonthree -> comparisonthree LT . comparisonfour
    (70) comparisonfour -> . INT
    (71) comparisonfour -> . FLOAT
    (72) comparisonfour -> . matrix
    (73) comparisonfour -> . LPAREN arithmetic RPAREN
    (74) comparisonfour -> . LPAREN comparison RPAREN
    (15) matrix -> . ID
    (16) matrix -> . ID LPAREN INT RPAREN
    (17) matrix -> . ID LPAREN INT COMMA INT RPAREN
    (18) matrix -> . ID LPAREN ID RPAREN
    (19) matrix -> . ID LPAREN ID COMMA ID RPAREN

    INT             shift and go to state 38
    FLOAT           shift and go to state 39
    LPAREN          shift and go to state 41
    ID              shift and go to state 42

    comparisonfour                 shift and go to state 98
    matrix                         shift and go to state 40

state 64

    (66) comparisonthree -> comparisonthree GT . comparisonfour
    (70) comparisonfour -> . INT
    (71) comparisonfour -> . FLOAT
    (72) comparisonfour -> . matrix
    (73) comparisonfour -> . LPAREN arithmetic RPAREN
    (74) comparisonfour -> . LPAREN comparison RPAREN
    (15) matrix -> . ID
    (16) matrix -> . ID LPAREN INT RPAREN
    (17) matrix -> . ID LPAREN INT COMMA INT RPAREN
    (18) matrix -> . ID LPAREN ID RPAREN
    (19) matrix -> . ID LPAREN ID COMMA ID RPAREN

    INT             shift and go to state 38
    FLOAT           shift and go to state 39
    LPAREN          shift and go to state 41
    ID              shift and go to state 42

    comparisonfour                 shift and go to state 99
    matrix                         shift and go to state 40

state 65

    (67) comparisonthree -> comparisonthree LTE . comparisonfour
    (70) comparisonfour -> . INT
    (71) comparisonfour -> . FLOAT
    (72) comparisonfour -> . matrix
    (73) comparisonfour -> . LPAREN arithmetic RPAREN
    (74) comparisonfour -> . LPAREN comparison RPAREN
    (15) matrix -> . ID
    (16) matrix -> . ID LPAREN INT RPAREN
    (17) matrix -> . ID LPAREN INT COMMA INT RPAREN
    (18) matrix -> . ID LPAREN ID RPAREN
    (19) matrix -> . ID LPAREN ID COMMA ID RPAREN

    INT             shift and go to state 38
    FLOAT           shift and go to state 39
    LPAREN          shift and go to state 41
    ID              shift and go to state 42

    comparisonfour                 shift and go to state 100
    matrix                         shift and go to state 40

state 66

    (68) comparisonthree -> comparisonthree GTE . comparisonfour
    (70) comparisonfour -> . INT
    (71) comparisonfour -> . FLOAT
    (72) comparisonfour -> . matrix
    (73) comparisonfour -> . LPAREN arithmetic RPAREN
    (74) comparisonfour -> . LPAREN comparison RPAREN
    (15) matrix -> . ID
    (16) matrix -> . ID LPAREN INT RPAREN
    (17) matrix -> . ID LPAREN INT COMMA INT RPAREN
    (18) matrix -> . ID LPAREN ID RPAREN
    (19) matrix -> . ID LPAREN ID COMMA ID RPAREN

    INT             shift and go to state 38
    FLOAT           shift and go to state 39
    LPAREN          shift and go to state 41
    ID              shift and go to state 42

    comparisonfour                 shift and go to state 101
    matrix                         shift and go to state 40

state 67

    (58) factor -> LPAREN . arithmetic RPAREN
    (73) comparisonfour -> LPAREN . arithmetic RPAREN
    (74) comparisonfour -> LPAREN . comparison RPAREN
    (49) arithmetic -> . arithmetic PLUS term
    (50) arithmetic -> . arithmetic MINUS term
    (51) arithmetic -> . term
    (59) comparison -> . comparison OR comparisontwo
    (60) comparison -> . comparisontwo
    (52) term -> . term TIMES factor
    (53) term -> . term DIVIDE factor
    (54) term -> . factor
    (61) comparisontwo -> . comparisontwo AND comparisonthree
    (62) comparisontwo -> . comparisonthree
    (55) factor -> . INT
    (56) factor -> . FLOAT
    (57) factor -> . matrix
    (58) factor -> . LPAREN arithmetic RPAREN
    (63) comparisonthree -> . comparisonthree EQ comparisonfour
    (64) comparisonthree -> . comparisonthree NEQ comparisonfour
    (65) comparisonthree -> . comparisonthree LT comparisonfour
    (66) comparisonthree -> . comparisonthree GT comparisonfour
    (67) comparisonthree -> . comparisonthree LTE comparisonfour
    (68) comparisonthree -> . comparisonthree GTE comparisonfour
    (69) comparisonthree -> . comparisonfour
    (15) matrix -> . ID
    (16) matrix -> . ID LPAREN INT RPAREN
    (17) matrix -> . ID LPAREN INT COMMA INT RPAREN
    (18) matrix -> . ID LPAREN ID RPAREN
    (19) matrix -> . ID LPAREN ID COMMA ID RPAREN
    (70) comparisonfour -> . INT
    (71) comparisonfour -> . FLOAT
    (72) comparisonfour -> . matrix
    (73) comparisonfour -> . LPAREN arithmetic RPAREN
    (74) comparisonfour -> . LPAREN comparison RPAREN

    INT             shift and go to state 72
    FLOAT           shift and go to state 73
    LPAREN          shift and go to state 67
    ID              shift and go to state 42

    arithmetic                     shift and go to state 102
    comparison                     shift and go to state 69
    term                           shift and go to state 70
    comparisontwo                  shift and go to state 35
    factor                         shift and go to state 71
    comparisonthree                shift and go to state 36
    matrix                         shift and go to state 74
    comparisonfour                 shift and go to state 37

state 68

    (73) comparisonfour -> LPAREN arithmetic . RPAREN
    (49) arithmetic -> arithmetic . PLUS term
    (50) arithmetic -> arithmetic . MINUS term

    RPAREN          shift and go to state 103
    PLUS            shift and go to state 104
    MINUS           shift and go to state 105


state 69

    (74) comparisonfour -> LPAREN comparison . RPAREN
    (59) comparison -> comparison . OR comparisontwo

    RPAREN          shift and go to state 106
    OR              shift and go to state 58


state 70

    (51) arithmetic -> term .
    (52) term -> term . TIMES factor
    (53) term -> term . DIVIDE factor

    RPAREN          reduce using rule 51 (arithmetic -> term .)
    PLUS            reduce using rule 51 (arithmetic -> term .)
    MINUS           reduce using rule 51 (arithmetic -> term .)
    END             reduce using rule 51 (arithmetic -> term .)
    ID              reduce using rule 51 (arithmetic -> term .)
    READ            reduce using rule 51 (arithmetic -> term .)
    PRINT           reduce using rule 51 (arithmetic -> term .)
    IF              reduce using rule 51 (arithmetic -> term .)
    DO              reduce using rule 51 (arithmetic -> term .)
    ELSE            reduce using rule 51 (arithmetic -> term .)
    EXIT            reduce using rule 51 (arithmetic -> term .)
    COLON           reduce using rule 51 (arithmetic -> term .)
    COMMA           reduce using rule 51 (arithmetic -> term .)
    TIMES           shift and go to state 107
    DIVIDE          shift and go to state 108


state 71

    (54) term -> factor .

    TIMES           reduce using rule 54 (term -> factor .)
    DIVIDE          reduce using rule 54 (term -> factor .)
    RPAREN          reduce using rule 54 (term -> factor .)
    PLUS            reduce using rule 54 (term -> factor .)
    MINUS           reduce using rule 54 (term -> factor .)
    END             reduce using rule 54 (term -> factor .)
    ID              reduce using rule 54 (term -> factor .)
    READ            reduce using rule 54 (term -> factor .)
    PRINT           reduce using rule 54 (term -> factor .)
    IF              reduce using rule 54 (term -> factor .)
    DO              reduce using rule 54 (term -> factor .)
    ELSE            reduce using rule 54 (term -> factor .)
    EXIT            reduce using rule 54 (term -> factor .)
    COLON           reduce using rule 54 (term -> factor .)
    COMMA           reduce using rule 54 (term -> factor .)


state 72

    (55) factor -> INT .
    (70) comparisonfour -> INT .

  ! reduce/reduce conflict for RPAREN resolved using rule 55 (factor -> INT .)
    TIMES           reduce using rule 55 (factor -> INT .)
    DIVIDE          reduce using rule 55 (factor -> INT .)
    RPAREN          reduce using rule 55 (factor -> INT .)
    PLUS            reduce using rule 55 (factor -> INT .)
    MINUS           reduce using rule 55 (factor -> INT .)
    EQ              reduce using rule 70 (comparisonfour -> INT .)
    NEQ             reduce using rule 70 (comparisonfour -> INT .)
    LT              reduce using rule 70 (comparisonfour -> INT .)
    GT              reduce using rule 70 (comparisonfour -> INT .)
    LTE             reduce using rule 70 (comparisonfour -> INT .)
    GTE             reduce using rule 70 (comparisonfour -> INT .)
    AND             reduce using rule 70 (comparisonfour -> INT .)
    OR              reduce using rule 70 (comparisonfour -> INT .)

  ! RPAREN          [ reduce using rule 70 (comparisonfour -> INT .) ]


state 73

    (56) factor -> FLOAT .
    (71) comparisonfour -> FLOAT .

  ! reduce/reduce conflict for RPAREN resolved using rule 56 (factor -> FLOAT .)
    TIMES           reduce using rule 56 (factor -> FLOAT .)
    DIVIDE          reduce using rule 56 (factor -> FLOAT .)
    RPAREN          reduce using rule 56 (factor -> FLOAT .)
    PLUS            reduce using rule 56 (factor -> FLOAT .)
    MINUS           reduce using rule 56 (factor -> FLOAT .)
    EQ              reduce using rule 71 (comparisonfour -> FLOAT .)
    NEQ             reduce using rule 71 (comparisonfour -> FLOAT .)
    LT              reduce using rule 71 (comparisonfour -> FLOAT .)
    GT              reduce using rule 71 (comparisonfour -> FLOAT .)
    LTE             reduce using rule 71 (comparisonfour -> FLOAT .)
    GTE             reduce using rule 71 (comparisonfour -> FLOAT .)
    AND             reduce using rule 71 (comparisonfour -> FLOAT .)
    OR              reduce using rule 71 (comparisonfour -> FLOAT .)

  ! RPAREN          [ reduce using rule 71 (comparisonfour -> FLOAT .) ]


state 74

    (57) factor -> matrix .
    (72) comparisonfour -> matrix .

  ! reduce/reduce conflict for RPAREN resolved using rule 57 (factor -> matrix .)
    TIMES           reduce using rule 57 (factor -> matrix .)
    DIVIDE          reduce using rule 57 (factor -> matrix .)
    RPAREN          reduce using rule 57 (factor -> matrix .)
    PLUS            reduce using rule 57 (factor -> matrix .)
    MINUS           reduce using rule 57 (factor -> matrix .)
    EQ              reduce using rule 72 (comparisonfour -> matrix .)
    NEQ             reduce using rule 72 (comparisonfour -> matrix .)
    LT              reduce using rule 72 (comparisonfour -> matrix .)
    GT              reduce using rule 72 (comparisonfour -> matrix .)
    LTE             reduce using rule 72 (comparisonfour -> matrix .)
    GTE             reduce using rule 72 (comparisonfour -> matrix .)
    AND             reduce using rule 72 (comparisonfour -> matrix .)
    OR              reduce using rule 72 (comparisonfour -> matrix .)

  ! RPAREN          [ reduce using rule 72 (comparisonfour -> matrix .) ]


state 75

    (16) matrix -> ID LPAREN . INT RPAREN
    (17) matrix -> ID LPAREN . INT COMMA INT RPAREN
    (18) matrix -> ID LPAREN . ID RPAREN
    (19) matrix -> ID LPAREN . ID COMMA ID RPAREN

    INT             shift and go to state 55
    ID              shift and go to state 53


state 76

    (29) blocks -> blocks do blocks IF . comparison then_if blocks exit END IF blocks END DO
    (41) if -> IF .
    (59) comparison -> . comparison OR comparisontwo
    (60) comparison -> . comparisontwo
    (61) comparisontwo -> . comparisontwo AND comparisonthree
    (62) comparisontwo -> . comparisonthree
    (63) comparisonthree -> . comparisonthree EQ comparisonfour
    (64) comparisonthree -> . comparisonthree NEQ comparisonfour
    (65) comparisonthree -> . comparisonthree LT comparisonfour
    (66) comparisonthree -> . comparisonthree GT comparisonfour
    (67) comparisonthree -> . comparisonthree LTE comparisonfour
    (68) comparisonthree -> . comparisonthree GTE comparisonfour
    (69) comparisonthree -> . comparisonfour
    (70) comparisonfour -> . INT
    (71) comparisonfour -> . FLOAT
    (72) comparisonfour -> . matrix
    (73) comparisonfour -> . LPAREN arithmetic RPAREN
    (74) comparisonfour -> . LPAREN comparison RPAREN
    (15) matrix -> . ID
    (16) matrix -> . ID LPAREN INT RPAREN
    (17) matrix -> . ID LPAREN INT COMMA INT RPAREN
    (18) matrix -> . ID LPAREN ID RPAREN
    (19) matrix -> . ID LPAREN ID COMMA ID RPAREN

  ! shift/reduce conflict for INT resolved as shift
  ! shift/reduce conflict for FLOAT resolved as shift
  ! shift/reduce conflict for LPAREN resolved as shift
  ! shift/reduce conflict for ID resolved as shift
    INT             shift and go to state 38
    FLOAT           shift and go to state 39
    LPAREN          shift and go to state 41
    ID              shift and go to state 42

  ! INT             [ reduce using rule 41 (if -> IF .) ]
  ! FLOAT           [ reduce using rule 41 (if -> IF .) ]
  ! LPAREN          [ reduce using rule 41 (if -> IF .) ]
  ! ID              [ reduce using rule 41 (if -> IF .) ]

    comparison                     shift and go to state 109
    comparisontwo                  shift and go to state 35
    comparisonthree                shift and go to state 36
    comparisonfour                 shift and go to state 37
    matrix                         shift and go to state 40

state 77

    (30) blocks -> blocks do assignment_do COMMA . arithmetic colon blocks END DO
    (31) blocks -> blocks do assignment_do COMMA . arithmetic colon IF comparison then_if blocks exit END IF blocks END DO
    (49) arithmetic -> . arithmetic PLUS term
    (50) arithmetic -> . arithmetic MINUS term
    (51) arithmetic -> . term
    (52) term -> . term TIMES factor
    (53) term -> . term DIVIDE factor
    (54) term -> . factor
    (55) factor -> . INT
    (56) factor -> . FLOAT
    (57) factor -> . matrix
    (58) factor -> . LPAREN arithmetic RPAREN
    (15) matrix -> . ID
    (16) matrix -> . ID LPAREN INT RPAREN
    (17) matrix -> . ID LPAREN INT COMMA INT RPAREN
    (18) matrix -> . ID LPAREN ID RPAREN
    (19) matrix -> . ID LPAREN ID COMMA ID RPAREN

    INT             shift and go to state 82
    FLOAT           shift and go to state 83
    LPAREN          shift and go to state 84
    ID              shift and go to state 42

    arithmetic                     shift and go to state 110
    term                           shift and go to state 70
    factor                         shift and go to state 71
    matrix                         shift and go to state 80

state 78

    (39) assignment_do -> ID ASSIGN . arithmetic
    (49) arithmetic -> . arithmetic PLUS term
    (50) arithmetic -> . arithmetic MINUS term
    (51) arithmetic -> . term
    (52) term -> . term TIMES factor
    (53) term -> . term DIVIDE factor
    (54) term -> . factor
    (55) factor -> . INT
    (56) factor -> . FLOAT
    (57) factor -> . matrix
    (58) factor -> . LPAREN arithmetic RPAREN
    (15) matrix -> . ID
    (16) matrix -> . ID LPAREN INT RPAREN
    (17) matrix -> . ID LPAREN INT COMMA INT RPAREN
    (18) matrix -> . ID LPAREN ID RPAREN
    (19) matrix -> . ID LPAREN ID COMMA ID RPAREN

    INT             shift and go to state 82
    FLOAT           shift and go to state 83
    LPAREN          shift and go to state 84
    ID              shift and go to state 42

    arithmetic                     shift and go to state 111
    term                           shift and go to state 70
    factor                         shift and go to state 71
    matrix                         shift and go to state 80

state 79

    (33) blocks -> blocks READ TIMES COMMA . matrix
    (15) matrix -> . ID
    (16) matrix -> . ID LPAREN INT RPAREN
    (17) matrix -> . ID LPAREN INT COMMA INT RPAREN
    (18) matrix -> . ID LPAREN ID RPAREN
    (19) matrix -> . ID LPAREN ID COMMA ID RPAREN

    ID              shift and go to state 42

    matrix                         shift and go to state 112

state 80

    (57) factor -> matrix .

    TIMES           reduce using rule 57 (factor -> matrix .)
    DIVIDE          reduce using rule 57 (factor -> matrix .)
    PLUS            reduce using rule 57 (factor -> matrix .)
    MINUS           reduce using rule 57 (factor -> matrix .)
    END             reduce using rule 57 (factor -> matrix .)
    ID              reduce using rule 57 (factor -> matrix .)
    READ            reduce using rule 57 (factor -> matrix .)
    PRINT           reduce using rule 57 (factor -> matrix .)
    IF              reduce using rule 57 (factor -> matrix .)
    DO              reduce using rule 57 (factor -> matrix .)
    ELSE            reduce using rule 57 (factor -> matrix .)
    EXIT            reduce using rule 57 (factor -> matrix .)
    COLON           reduce using rule 57 (factor -> matrix .)
    COMMA           reduce using rule 57 (factor -> matrix .)
    RPAREN          reduce using rule 57 (factor -> matrix .)


state 81

    (48) assignment -> matrix ASSIGN arithmetic .
    (49) arithmetic -> arithmetic . PLUS term
    (50) arithmetic -> arithmetic . MINUS term

    END             reduce using rule 48 (assignment -> matrix ASSIGN arithmetic .)
    ID              reduce using rule 48 (assignment -> matrix ASSIGN arithmetic .)
    READ            reduce using rule 48 (assignment -> matrix ASSIGN arithmetic .)
    PRINT           reduce using rule 48 (assignment -> matrix ASSIGN arithmetic .)
    IF              reduce using rule 48 (assignment -> matrix ASSIGN arithmetic .)
    DO              reduce using rule 48 (assignment -> matrix ASSIGN arithmetic .)
    ELSE            reduce using rule 48 (assignment -> matrix ASSIGN arithmetic .)
    EXIT            reduce using rule 48 (assignment -> matrix ASSIGN arithmetic .)
    PLUS            shift and go to state 104
    MINUS           shift and go to state 105


state 82

    (55) factor -> INT .

    TIMES           reduce using rule 55 (factor -> INT .)
    DIVIDE          reduce using rule 55 (factor -> INT .)
    PLUS            reduce using rule 55 (factor -> INT .)
    MINUS           reduce using rule 55 (factor -> INT .)
    END             reduce using rule 55 (factor -> INT .)
    ID              reduce using rule 55 (factor -> INT .)
    READ            reduce using rule 55 (factor -> INT .)
    PRINT           reduce using rule 55 (factor -> INT .)
    IF              reduce using rule 55 (factor -> INT .)
    DO              reduce using rule 55 (factor -> INT .)
    ELSE            reduce using rule 55 (factor -> INT .)
    EXIT            reduce using rule 55 (factor -> INT .)
    COLON           reduce using rule 55 (factor -> INT .)
    COMMA           reduce using rule 55 (factor -> INT .)
    RPAREN          reduce using rule 55 (factor -> INT .)


state 83

    (56) factor -> FLOAT .

    TIMES           reduce using rule 56 (factor -> FLOAT .)
    DIVIDE          reduce using rule 56 (factor -> FLOAT .)
    PLUS            reduce using rule 56 (factor -> FLOAT .)
    MINUS           reduce using rule 56 (factor -> FLOAT .)
    END             reduce using rule 56 (factor -> FLOAT .)
    ID              reduce using rule 56 (factor -> FLOAT .)
    READ            reduce using rule 56 (factor -> FLOAT .)
    PRINT           reduce using rule 56 (factor -> FLOAT .)
    IF              reduce using rule 56 (factor -> FLOAT .)
    DO              reduce using rule 56 (factor -> FLOAT .)
    ELSE            reduce using rule 56 (factor -> FLOAT .)
    EXIT            reduce using rule 56 (factor -> FLOAT .)
    COLON           reduce using rule 56 (factor -> FLOAT .)
    COMMA           reduce using rule 56 (factor -> FLOAT .)
    RPAREN          reduce using rule 56 (factor -> FLOAT .)


state 84

    (58) factor -> LPAREN . arithmetic RPAREN
    (49) arithmetic -> . arithmetic PLUS term
    (50) arithmetic -> . arithmetic MINUS term
    (51) arithmetic -> . term
    (52) term -> . term TIMES factor
    (53) term -> . term DIVIDE factor
    (54) term -> . factor
    (55) factor -> . INT
    (56) factor -> . FLOAT
    (57) factor -> . matrix
    (58) factor -> . LPAREN arithmetic RPAREN
    (15) matrix -> . ID
    (16) matrix -> . ID LPAREN INT RPAREN
    (17) matrix -> . ID LPAREN INT COMMA INT RPAREN
    (18) matrix -> . ID LPAREN ID RPAREN
    (19) matrix -> . ID LPAREN ID COMMA ID RPAREN

    INT             shift and go to state 82
    FLOAT           shift and go to state 83
    LPAREN          shift and go to state 84
    ID              shift and go to state 42

    arithmetic                     shift and go to state 113
    term                           shift and go to state 70
    factor                         shift and go to state 71
    matrix                         shift and go to state 80

state 85

    (34) blocks -> blocks PRINT TIMES COMMA . matrix
    (35) blocks -> blocks PRINT TIMES COMMA . STRING
    (15) matrix -> . ID
    (16) matrix -> . ID LPAREN INT RPAREN
    (17) matrix -> . ID LPAREN INT COMMA INT RPAREN
    (18) matrix -> . ID LPAREN ID RPAREN
    (19) matrix -> . ID LPAREN ID COMMA ID RPAREN

    STRING          shift and go to state 115
    ID              shift and go to state 42

    matrix                         shift and go to state 114

state 86

    (22) subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN . blocks END
    (23) subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN . blocks END SUBROUTINE
    (24) subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN . blocks END SUBROUTINE ID
    (27) blocks -> . blocks assignment
    (28) blocks -> . blocks if comparison then_if blocks conditionals END IF
    (29) blocks -> . blocks do blocks IF comparison then_if blocks exit END IF blocks END DO
    (30) blocks -> . blocks do assignment_do COMMA arithmetic colon blocks END DO
    (31) blocks -> . blocks do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks END DO
    (32) blocks -> . blocks ID LPAREN RPAREN
    (33) blocks -> . blocks READ TIMES COMMA matrix
    (34) blocks -> . blocks PRINT TIMES COMMA matrix
    (35) blocks -> . blocks PRINT TIMES COMMA STRING
    (36) blocks -> . empty
    (75) empty -> .

    END             reduce using rule 75 (empty -> .)
    ID              reduce using rule 75 (empty -> .)
    READ            reduce using rule 75 (empty -> .)
    PRINT           reduce using rule 75 (empty -> .)
    IF              reduce using rule 75 (empty -> .)
    DO              reduce using rule 75 (empty -> .)

    blocks                         shift and go to state 116
    empty                          shift and go to state 16

state 87

    (9) variables -> variables COMMA ID .
    (10) variables -> variables COMMA ID . LPAREN INT RPAREN
    (11) variables -> variables COMMA ID . LPAREN INT COMMA INT RPAREN

    COMMA           reduce using rule 9 (variables -> variables COMMA ID .)
    INTEGER         reduce using rule 9 (variables -> variables COMMA ID .)
    REAL            reduce using rule 9 (variables -> variables COMMA ID .)
    SUBROUTINE      reduce using rule 9 (variables -> variables COMMA ID .)
    END             reduce using rule 9 (variables -> variables COMMA ID .)
    ID              reduce using rule 9 (variables -> variables COMMA ID .)
    READ            reduce using rule 9 (variables -> variables COMMA ID .)
    PRINT           reduce using rule 9 (variables -> variables COMMA ID .)
    IF              reduce using rule 9 (variables -> variables COMMA ID .)
    DO              reduce using rule 9 (variables -> variables COMMA ID .)
    LPAREN          shift and go to state 117


state 88

    (13) variables -> ID LPAREN INT . RPAREN
    (14) variables -> ID LPAREN INT . COMMA INT RPAREN

    RPAREN          shift and go to state 118
    COMMA           shift and go to state 119


state 89

    (18) matrix -> ID LPAREN ID RPAREN .

    ASSIGN          reduce using rule 18 (matrix -> ID LPAREN ID RPAREN .)
    EQ              reduce using rule 18 (matrix -> ID LPAREN ID RPAREN .)
    NEQ             reduce using rule 18 (matrix -> ID LPAREN ID RPAREN .)
    LT              reduce using rule 18 (matrix -> ID LPAREN ID RPAREN .)
    GT              reduce using rule 18 (matrix -> ID LPAREN ID RPAREN .)
    LTE             reduce using rule 18 (matrix -> ID LPAREN ID RPAREN .)
    GTE             reduce using rule 18 (matrix -> ID LPAREN ID RPAREN .)
    AND             reduce using rule 18 (matrix -> ID LPAREN ID RPAREN .)
    OR              reduce using rule 18 (matrix -> ID LPAREN ID RPAREN .)
    THEN            reduce using rule 18 (matrix -> ID LPAREN ID RPAREN .)
    TIMES           reduce using rule 18 (matrix -> ID LPAREN ID RPAREN .)
    DIVIDE          reduce using rule 18 (matrix -> ID LPAREN ID RPAREN .)
    RPAREN          reduce using rule 18 (matrix -> ID LPAREN ID RPAREN .)
    PLUS            reduce using rule 18 (matrix -> ID LPAREN ID RPAREN .)
    MINUS           reduce using rule 18 (matrix -> ID LPAREN ID RPAREN .)
    END             reduce using rule 18 (matrix -> ID LPAREN ID RPAREN .)
    ID              reduce using rule 18 (matrix -> ID LPAREN ID RPAREN .)
    READ            reduce using rule 18 (matrix -> ID LPAREN ID RPAREN .)
    PRINT           reduce using rule 18 (matrix -> ID LPAREN ID RPAREN .)
    IF              reduce using rule 18 (matrix -> ID LPAREN ID RPAREN .)
    DO              reduce using rule 18 (matrix -> ID LPAREN ID RPAREN .)
    ELSE            reduce using rule 18 (matrix -> ID LPAREN ID RPAREN .)
    EXIT            reduce using rule 18 (matrix -> ID LPAREN ID RPAREN .)
    COLON           reduce using rule 18 (matrix -> ID LPAREN ID RPAREN .)
    COMMA           reduce using rule 18 (matrix -> ID LPAREN ID RPAREN .)


state 90

    (19) matrix -> ID LPAREN ID COMMA . ID RPAREN

    ID              shift and go to state 120


state 91

    (16) matrix -> ID LPAREN INT RPAREN .

    ASSIGN          reduce using rule 16 (matrix -> ID LPAREN INT RPAREN .)
    EQ              reduce using rule 16 (matrix -> ID LPAREN INT RPAREN .)
    NEQ             reduce using rule 16 (matrix -> ID LPAREN INT RPAREN .)
    LT              reduce using rule 16 (matrix -> ID LPAREN INT RPAREN .)
    GT              reduce using rule 16 (matrix -> ID LPAREN INT RPAREN .)
    LTE             reduce using rule 16 (matrix -> ID LPAREN INT RPAREN .)
    GTE             reduce using rule 16 (matrix -> ID LPAREN INT RPAREN .)
    AND             reduce using rule 16 (matrix -> ID LPAREN INT RPAREN .)
    OR              reduce using rule 16 (matrix -> ID LPAREN INT RPAREN .)
    THEN            reduce using rule 16 (matrix -> ID LPAREN INT RPAREN .)
    TIMES           reduce using rule 16 (matrix -> ID LPAREN INT RPAREN .)
    DIVIDE          reduce using rule 16 (matrix -> ID LPAREN INT RPAREN .)
    RPAREN          reduce using rule 16 (matrix -> ID LPAREN INT RPAREN .)
    PLUS            reduce using rule 16 (matrix -> ID LPAREN INT RPAREN .)
    MINUS           reduce using rule 16 (matrix -> ID LPAREN INT RPAREN .)
    END             reduce using rule 16 (matrix -> ID LPAREN INT RPAREN .)
    ID              reduce using rule 16 (matrix -> ID LPAREN INT RPAREN .)
    READ            reduce using rule 16 (matrix -> ID LPAREN INT RPAREN .)
    PRINT           reduce using rule 16 (matrix -> ID LPAREN INT RPAREN .)
    IF              reduce using rule 16 (matrix -> ID LPAREN INT RPAREN .)
    DO              reduce using rule 16 (matrix -> ID LPAREN INT RPAREN .)
    ELSE            reduce using rule 16 (matrix -> ID LPAREN INT RPAREN .)
    EXIT            reduce using rule 16 (matrix -> ID LPAREN INT RPAREN .)
    COLON           reduce using rule 16 (matrix -> ID LPAREN INT RPAREN .)
    COMMA           reduce using rule 16 (matrix -> ID LPAREN INT RPAREN .)


state 92

    (17) matrix -> ID LPAREN INT COMMA . INT RPAREN

    INT             shift and go to state 121


state 93

    (28) blocks -> blocks if comparison then_if blocks . conditionals END IF
    (27) blocks -> blocks . assignment
    (28) blocks -> blocks . if comparison then_if blocks conditionals END IF
    (29) blocks -> blocks . do blocks IF comparison then_if blocks exit END IF blocks END DO
    (30) blocks -> blocks . do assignment_do COMMA arithmetic colon blocks END DO
    (31) blocks -> blocks . do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks END DO
    (32) blocks -> blocks . ID LPAREN RPAREN
    (33) blocks -> blocks . READ TIMES COMMA matrix
    (34) blocks -> blocks . PRINT TIMES COMMA matrix
    (35) blocks -> blocks . PRINT TIMES COMMA STRING
    (43) conditionals -> . else blocks
    (44) conditionals -> . else IF comparison then_if blocks conditionals
    (45) conditionals -> . else
    (48) assignment -> . matrix ASSIGN arithmetic
    (41) if -> . IF
    (37) do -> . DO
    (46) else -> . ELSE
    (47) else -> . empty
    (15) matrix -> . ID
    (16) matrix -> . ID LPAREN INT RPAREN
    (17) matrix -> . ID LPAREN INT COMMA INT RPAREN
    (18) matrix -> . ID LPAREN ID RPAREN
    (19) matrix -> . ID LPAREN ID COMMA ID RPAREN
    (75) empty -> .

  ! shift/reduce conflict for IF resolved as shift
  ! shift/reduce conflict for ID resolved as shift
  ! shift/reduce conflict for READ resolved as shift
  ! shift/reduce conflict for PRINT resolved as shift
  ! shift/reduce conflict for DO resolved as shift
    ID              shift and go to state 18
    READ            shift and go to state 25
    PRINT           shift and go to state 27
    IF              shift and go to state 22
    DO              shift and go to state 24
    ELSE            shift and go to state 124
    END             reduce using rule 75 (empty -> .)

  ! IF              [ reduce using rule 75 (empty -> .) ]
  ! ID              [ reduce using rule 75 (empty -> .) ]
  ! READ            [ reduce using rule 75 (empty -> .) ]
  ! PRINT           [ reduce using rule 75 (empty -> .) ]
  ! DO              [ reduce using rule 75 (empty -> .) ]

    if                             shift and go to state 21
    conditionals                   shift and go to state 122
    assignment                     shift and go to state 20
    do                             shift and go to state 23
    matrix                         shift and go to state 26
    else                           shift and go to state 123
    empty                          shift and go to state 125

state 94

    (59) comparison -> comparison OR comparisontwo .
    (61) comparisontwo -> comparisontwo . AND comparisonthree

    OR              reduce using rule 59 (comparison -> comparison OR comparisontwo .)
    THEN            reduce using rule 59 (comparison -> comparison OR comparisontwo .)
    RPAREN          reduce using rule 59 (comparison -> comparison OR comparisontwo .)
    AND             shift and go to state 60


state 95

    (61) comparisontwo -> comparisontwo AND comparisonthree .
    (63) comparisonthree -> comparisonthree . EQ comparisonfour
    (64) comparisonthree -> comparisonthree . NEQ comparisonfour
    (65) comparisonthree -> comparisonthree . LT comparisonfour
    (66) comparisonthree -> comparisonthree . GT comparisonfour
    (67) comparisonthree -> comparisonthree . LTE comparisonfour
    (68) comparisonthree -> comparisonthree . GTE comparisonfour

    AND             reduce using rule 61 (comparisontwo -> comparisontwo AND comparisonthree .)
    OR              reduce using rule 61 (comparisontwo -> comparisontwo AND comparisonthree .)
    THEN            reduce using rule 61 (comparisontwo -> comparisontwo AND comparisonthree .)
    RPAREN          reduce using rule 61 (comparisontwo -> comparisontwo AND comparisonthree .)
    EQ              shift and go to state 61
    NEQ             shift and go to state 62
    LT              shift and go to state 63
    GT              shift and go to state 64
    LTE             shift and go to state 65
    GTE             shift and go to state 66


state 96

    (63) comparisonthree -> comparisonthree EQ comparisonfour .

    EQ              reduce using rule 63 (comparisonthree -> comparisonthree EQ comparisonfour .)
    NEQ             reduce using rule 63 (comparisonthree -> comparisonthree EQ comparisonfour .)
    LT              reduce using rule 63 (comparisonthree -> comparisonthree EQ comparisonfour .)
    GT              reduce using rule 63 (comparisonthree -> comparisonthree EQ comparisonfour .)
    LTE             reduce using rule 63 (comparisonthree -> comparisonthree EQ comparisonfour .)
    GTE             reduce using rule 63 (comparisonthree -> comparisonthree EQ comparisonfour .)
    AND             reduce using rule 63 (comparisonthree -> comparisonthree EQ comparisonfour .)
    OR              reduce using rule 63 (comparisonthree -> comparisonthree EQ comparisonfour .)
    THEN            reduce using rule 63 (comparisonthree -> comparisonthree EQ comparisonfour .)
    RPAREN          reduce using rule 63 (comparisonthree -> comparisonthree EQ comparisonfour .)


state 97

    (64) comparisonthree -> comparisonthree NEQ comparisonfour .

    EQ              reduce using rule 64 (comparisonthree -> comparisonthree NEQ comparisonfour .)
    NEQ             reduce using rule 64 (comparisonthree -> comparisonthree NEQ comparisonfour .)
    LT              reduce using rule 64 (comparisonthree -> comparisonthree NEQ comparisonfour .)
    GT              reduce using rule 64 (comparisonthree -> comparisonthree NEQ comparisonfour .)
    LTE             reduce using rule 64 (comparisonthree -> comparisonthree NEQ comparisonfour .)
    GTE             reduce using rule 64 (comparisonthree -> comparisonthree NEQ comparisonfour .)
    AND             reduce using rule 64 (comparisonthree -> comparisonthree NEQ comparisonfour .)
    OR              reduce using rule 64 (comparisonthree -> comparisonthree NEQ comparisonfour .)
    THEN            reduce using rule 64 (comparisonthree -> comparisonthree NEQ comparisonfour .)
    RPAREN          reduce using rule 64 (comparisonthree -> comparisonthree NEQ comparisonfour .)


state 98

    (65) comparisonthree -> comparisonthree LT comparisonfour .

    EQ              reduce using rule 65 (comparisonthree -> comparisonthree LT comparisonfour .)
    NEQ             reduce using rule 65 (comparisonthree -> comparisonthree LT comparisonfour .)
    LT              reduce using rule 65 (comparisonthree -> comparisonthree LT comparisonfour .)
    GT              reduce using rule 65 (comparisonthree -> comparisonthree LT comparisonfour .)
    LTE             reduce using rule 65 (comparisonthree -> comparisonthree LT comparisonfour .)
    GTE             reduce using rule 65 (comparisonthree -> comparisonthree LT comparisonfour .)
    AND             reduce using rule 65 (comparisonthree -> comparisonthree LT comparisonfour .)
    OR              reduce using rule 65 (comparisonthree -> comparisonthree LT comparisonfour .)
    THEN            reduce using rule 65 (comparisonthree -> comparisonthree LT comparisonfour .)
    RPAREN          reduce using rule 65 (comparisonthree -> comparisonthree LT comparisonfour .)


state 99

    (66) comparisonthree -> comparisonthree GT comparisonfour .

    EQ              reduce using rule 66 (comparisonthree -> comparisonthree GT comparisonfour .)
    NEQ             reduce using rule 66 (comparisonthree -> comparisonthree GT comparisonfour .)
    LT              reduce using rule 66 (comparisonthree -> comparisonthree GT comparisonfour .)
    GT              reduce using rule 66 (comparisonthree -> comparisonthree GT comparisonfour .)
    LTE             reduce using rule 66 (comparisonthree -> comparisonthree GT comparisonfour .)
    GTE             reduce using rule 66 (comparisonthree -> comparisonthree GT comparisonfour .)
    AND             reduce using rule 66 (comparisonthree -> comparisonthree GT comparisonfour .)
    OR              reduce using rule 66 (comparisonthree -> comparisonthree GT comparisonfour .)
    THEN            reduce using rule 66 (comparisonthree -> comparisonthree GT comparisonfour .)
    RPAREN          reduce using rule 66 (comparisonthree -> comparisonthree GT comparisonfour .)


state 100

    (67) comparisonthree -> comparisonthree LTE comparisonfour .

    EQ              reduce using rule 67 (comparisonthree -> comparisonthree LTE comparisonfour .)
    NEQ             reduce using rule 67 (comparisonthree -> comparisonthree LTE comparisonfour .)
    LT              reduce using rule 67 (comparisonthree -> comparisonthree LTE comparisonfour .)
    GT              reduce using rule 67 (comparisonthree -> comparisonthree LTE comparisonfour .)
    LTE             reduce using rule 67 (comparisonthree -> comparisonthree LTE comparisonfour .)
    GTE             reduce using rule 67 (comparisonthree -> comparisonthree LTE comparisonfour .)
    AND             reduce using rule 67 (comparisonthree -> comparisonthree LTE comparisonfour .)
    OR              reduce using rule 67 (comparisonthree -> comparisonthree LTE comparisonfour .)
    THEN            reduce using rule 67 (comparisonthree -> comparisonthree LTE comparisonfour .)
    RPAREN          reduce using rule 67 (comparisonthree -> comparisonthree LTE comparisonfour .)


state 101

    (68) comparisonthree -> comparisonthree GTE comparisonfour .

    EQ              reduce using rule 68 (comparisonthree -> comparisonthree GTE comparisonfour .)
    NEQ             reduce using rule 68 (comparisonthree -> comparisonthree GTE comparisonfour .)
    LT              reduce using rule 68 (comparisonthree -> comparisonthree GTE comparisonfour .)
    GT              reduce using rule 68 (comparisonthree -> comparisonthree GTE comparisonfour .)
    LTE             reduce using rule 68 (comparisonthree -> comparisonthree GTE comparisonfour .)
    GTE             reduce using rule 68 (comparisonthree -> comparisonthree GTE comparisonfour .)
    AND             reduce using rule 68 (comparisonthree -> comparisonthree GTE comparisonfour .)
    OR              reduce using rule 68 (comparisonthree -> comparisonthree GTE comparisonfour .)
    THEN            reduce using rule 68 (comparisonthree -> comparisonthree GTE comparisonfour .)
    RPAREN          reduce using rule 68 (comparisonthree -> comparisonthree GTE comparisonfour .)


state 102

    (58) factor -> LPAREN arithmetic . RPAREN
    (73) comparisonfour -> LPAREN arithmetic . RPAREN
    (49) arithmetic -> arithmetic . PLUS term
    (50) arithmetic -> arithmetic . MINUS term

    RPAREN          shift and go to state 126
    PLUS            shift and go to state 104
    MINUS           shift and go to state 105


state 103

    (73) comparisonfour -> LPAREN arithmetic RPAREN .

    EQ              reduce using rule 73 (comparisonfour -> LPAREN arithmetic RPAREN .)
    NEQ             reduce using rule 73 (comparisonfour -> LPAREN arithmetic RPAREN .)
    LT              reduce using rule 73 (comparisonfour -> LPAREN arithmetic RPAREN .)
    GT              reduce using rule 73 (comparisonfour -> LPAREN arithmetic RPAREN .)
    LTE             reduce using rule 73 (comparisonfour -> LPAREN arithmetic RPAREN .)
    GTE             reduce using rule 73 (comparisonfour -> LPAREN arithmetic RPAREN .)
    AND             reduce using rule 73 (comparisonfour -> LPAREN arithmetic RPAREN .)
    OR              reduce using rule 73 (comparisonfour -> LPAREN arithmetic RPAREN .)
    THEN            reduce using rule 73 (comparisonfour -> LPAREN arithmetic RPAREN .)
    RPAREN          reduce using rule 73 (comparisonfour -> LPAREN arithmetic RPAREN .)


state 104

    (49) arithmetic -> arithmetic PLUS . term
    (52) term -> . term TIMES factor
    (53) term -> . term DIVIDE factor
    (54) term -> . factor
    (55) factor -> . INT
    (56) factor -> . FLOAT
    (57) factor -> . matrix
    (58) factor -> . LPAREN arithmetic RPAREN
    (15) matrix -> . ID
    (16) matrix -> . ID LPAREN INT RPAREN
    (17) matrix -> . ID LPAREN INT COMMA INT RPAREN
    (18) matrix -> . ID LPAREN ID RPAREN
    (19) matrix -> . ID LPAREN ID COMMA ID RPAREN

    INT             shift and go to state 82
    FLOAT           shift and go to state 83
    LPAREN          shift and go to state 84
    ID              shift and go to state 42

    term                           shift and go to state 127
    factor                         shift and go to state 71
    matrix                         shift and go to state 80

state 105

    (50) arithmetic -> arithmetic MINUS . term
    (52) term -> . term TIMES factor
    (53) term -> . term DIVIDE factor
    (54) term -> . factor
    (55) factor -> . INT
    (56) factor -> . FLOAT
    (57) factor -> . matrix
    (58) factor -> . LPAREN arithmetic RPAREN
    (15) matrix -> . ID
    (16) matrix -> . ID LPAREN INT RPAREN
    (17) matrix -> . ID LPAREN INT COMMA INT RPAREN
    (18) matrix -> . ID LPAREN ID RPAREN
    (19) matrix -> . ID LPAREN ID COMMA ID RPAREN

    INT             shift and go to state 82
    FLOAT           shift and go to state 83
    LPAREN          shift and go to state 84
    ID              shift and go to state 42

    term                           shift and go to state 128
    factor                         shift and go to state 71
    matrix                         shift and go to state 80

state 106

    (74) comparisonfour -> LPAREN comparison RPAREN .

    EQ              reduce using rule 74 (comparisonfour -> LPAREN comparison RPAREN .)
    NEQ             reduce using rule 74 (comparisonfour -> LPAREN comparison RPAREN .)
    LT              reduce using rule 74 (comparisonfour -> LPAREN comparison RPAREN .)
    GT              reduce using rule 74 (comparisonfour -> LPAREN comparison RPAREN .)
    LTE             reduce using rule 74 (comparisonfour -> LPAREN comparison RPAREN .)
    GTE             reduce using rule 74 (comparisonfour -> LPAREN comparison RPAREN .)
    AND             reduce using rule 74 (comparisonfour -> LPAREN comparison RPAREN .)
    OR              reduce using rule 74 (comparisonfour -> LPAREN comparison RPAREN .)
    THEN            reduce using rule 74 (comparisonfour -> LPAREN comparison RPAREN .)
    RPAREN          reduce using rule 74 (comparisonfour -> LPAREN comparison RPAREN .)


state 107

    (52) term -> term TIMES . factor
    (55) factor -> . INT
    (56) factor -> . FLOAT
    (57) factor -> . matrix
    (58) factor -> . LPAREN arithmetic RPAREN
    (15) matrix -> . ID
    (16) matrix -> . ID LPAREN INT RPAREN
    (17) matrix -> . ID LPAREN INT COMMA INT RPAREN
    (18) matrix -> . ID LPAREN ID RPAREN
    (19) matrix -> . ID LPAREN ID COMMA ID RPAREN

    INT             shift and go to state 82
    FLOAT           shift and go to state 83
    LPAREN          shift and go to state 84
    ID              shift and go to state 42

    factor                         shift and go to state 129
    matrix                         shift and go to state 80

state 108

    (53) term -> term DIVIDE . factor
    (55) factor -> . INT
    (56) factor -> . FLOAT
    (57) factor -> . matrix
    (58) factor -> . LPAREN arithmetic RPAREN
    (15) matrix -> . ID
    (16) matrix -> . ID LPAREN INT RPAREN
    (17) matrix -> . ID LPAREN INT COMMA INT RPAREN
    (18) matrix -> . ID LPAREN ID RPAREN
    (19) matrix -> . ID LPAREN ID COMMA ID RPAREN

    INT             shift and go to state 82
    FLOAT           shift and go to state 83
    LPAREN          shift and go to state 84
    ID              shift and go to state 42

    factor                         shift and go to state 130
    matrix                         shift and go to state 80

state 109

    (29) blocks -> blocks do blocks IF comparison . then_if blocks exit END IF blocks END DO
    (59) comparison -> comparison . OR comparisontwo
    (42) then_if -> . THEN

    OR              shift and go to state 58
    THEN            shift and go to state 59

    then_if                        shift and go to state 131

state 110

    (30) blocks -> blocks do assignment_do COMMA arithmetic . colon blocks END DO
    (31) blocks -> blocks do assignment_do COMMA arithmetic . colon IF comparison then_if blocks exit END IF blocks END DO
    (49) arithmetic -> arithmetic . PLUS term
    (50) arithmetic -> arithmetic . MINUS term
    (38) colon -> . COLON

    PLUS            shift and go to state 104
    MINUS           shift and go to state 105
    COLON           shift and go to state 133

    colon                          shift and go to state 132

state 111

    (39) assignment_do -> ID ASSIGN arithmetic .
    (49) arithmetic -> arithmetic . PLUS term
    (50) arithmetic -> arithmetic . MINUS term

    COMMA           reduce using rule 39 (assignment_do -> ID ASSIGN arithmetic .)
    PLUS            shift and go to state 104
    MINUS           shift and go to state 105


state 112

    (33) blocks -> blocks READ TIMES COMMA matrix .

    END             reduce using rule 33 (blocks -> blocks READ TIMES COMMA matrix .)
    ID              reduce using rule 33 (blocks -> blocks READ TIMES COMMA matrix .)
    READ            reduce using rule 33 (blocks -> blocks READ TIMES COMMA matrix .)
    PRINT           reduce using rule 33 (blocks -> blocks READ TIMES COMMA matrix .)
    IF              reduce using rule 33 (blocks -> blocks READ TIMES COMMA matrix .)
    DO              reduce using rule 33 (blocks -> blocks READ TIMES COMMA matrix .)
    ELSE            reduce using rule 33 (blocks -> blocks READ TIMES COMMA matrix .)
    EXIT            reduce using rule 33 (blocks -> blocks READ TIMES COMMA matrix .)


state 113

    (58) factor -> LPAREN arithmetic . RPAREN
    (49) arithmetic -> arithmetic . PLUS term
    (50) arithmetic -> arithmetic . MINUS term

    RPAREN          shift and go to state 134
    PLUS            shift and go to state 104
    MINUS           shift and go to state 105


state 114

    (34) blocks -> blocks PRINT TIMES COMMA matrix .

    END             reduce using rule 34 (blocks -> blocks PRINT TIMES COMMA matrix .)
    ID              reduce using rule 34 (blocks -> blocks PRINT TIMES COMMA matrix .)
    READ            reduce using rule 34 (blocks -> blocks PRINT TIMES COMMA matrix .)
    PRINT           reduce using rule 34 (blocks -> blocks PRINT TIMES COMMA matrix .)
    IF              reduce using rule 34 (blocks -> blocks PRINT TIMES COMMA matrix .)
    DO              reduce using rule 34 (blocks -> blocks PRINT TIMES COMMA matrix .)
    ELSE            reduce using rule 34 (blocks -> blocks PRINT TIMES COMMA matrix .)
    EXIT            reduce using rule 34 (blocks -> blocks PRINT TIMES COMMA matrix .)


state 115

    (35) blocks -> blocks PRINT TIMES COMMA STRING .

    END             reduce using rule 35 (blocks -> blocks PRINT TIMES COMMA STRING .)
    ID              reduce using rule 35 (blocks -> blocks PRINT TIMES COMMA STRING .)
    READ            reduce using rule 35 (blocks -> blocks PRINT TIMES COMMA STRING .)
    PRINT           reduce using rule 35 (blocks -> blocks PRINT TIMES COMMA STRING .)
    IF              reduce using rule 35 (blocks -> blocks PRINT TIMES COMMA STRING .)
    DO              reduce using rule 35 (blocks -> blocks PRINT TIMES COMMA STRING .)
    ELSE            reduce using rule 35 (blocks -> blocks PRINT TIMES COMMA STRING .)
    EXIT            reduce using rule 35 (blocks -> blocks PRINT TIMES COMMA STRING .)


state 116

    (22) subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks . END
    (23) subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks . END SUBROUTINE
    (24) subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks . END SUBROUTINE ID
    (27) blocks -> blocks . assignment
    (28) blocks -> blocks . if comparison then_if blocks conditionals END IF
    (29) blocks -> blocks . do blocks IF comparison then_if blocks exit END IF blocks END DO
    (30) blocks -> blocks . do assignment_do COMMA arithmetic colon blocks END DO
    (31) blocks -> blocks . do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks END DO
    (32) blocks -> blocks . ID LPAREN RPAREN
    (33) blocks -> blocks . READ TIMES COMMA matrix
    (34) blocks -> blocks . PRINT TIMES COMMA matrix
    (35) blocks -> blocks . PRINT TIMES COMMA STRING
    (48) assignment -> . matrix ASSIGN arithmetic
    (41) if -> . IF
    (37) do -> . DO
    (15) matrix -> . ID
    (16) matrix -> . ID LPAREN INT RPAREN
    (17) matrix -> . ID LPAREN INT COMMA INT RPAREN
    (18) matrix -> . ID LPAREN ID RPAREN
    (19) matrix -> . ID LPAREN ID COMMA ID RPAREN

    END             shift and go to state 135
    ID              shift and go to state 18
    READ            shift and go to state 25
    PRINT           shift and go to state 27
    IF              shift and go to state 22
    DO              shift and go to state 24

    assignment                     shift and go to state 20
    if                             shift and go to state 21
    do                             shift and go to state 23
    matrix                         shift and go to state 26

state 117

    (10) variables -> variables COMMA ID LPAREN . INT RPAREN
    (11) variables -> variables COMMA ID LPAREN . INT COMMA INT RPAREN

    INT             shift and go to state 136


state 118

    (13) variables -> ID LPAREN INT RPAREN .

    COMMA           reduce using rule 13 (variables -> ID LPAREN INT RPAREN .)
    INTEGER         reduce using rule 13 (variables -> ID LPAREN INT RPAREN .)
    REAL            reduce using rule 13 (variables -> ID LPAREN INT RPAREN .)
    SUBROUTINE      reduce using rule 13 (variables -> ID LPAREN INT RPAREN .)
    END             reduce using rule 13 (variables -> ID LPAREN INT RPAREN .)
    ID              reduce using rule 13 (variables -> ID LPAREN INT RPAREN .)
    READ            reduce using rule 13 (variables -> ID LPAREN INT RPAREN .)
    PRINT           reduce using rule 13 (variables -> ID LPAREN INT RPAREN .)
    IF              reduce using rule 13 (variables -> ID LPAREN INT RPAREN .)
    DO              reduce using rule 13 (variables -> ID LPAREN INT RPAREN .)


state 119

    (14) variables -> ID LPAREN INT COMMA . INT RPAREN

    INT             shift and go to state 137


state 120

    (19) matrix -> ID LPAREN ID COMMA ID . RPAREN

    RPAREN          shift and go to state 138


state 121

    (17) matrix -> ID LPAREN INT COMMA INT . RPAREN

    RPAREN          shift and go to state 139


state 122

    (28) blocks -> blocks if comparison then_if blocks conditionals . END IF

    END             shift and go to state 140


state 123

    (43) conditionals -> else . blocks
    (44) conditionals -> else . IF comparison then_if blocks conditionals
    (45) conditionals -> else .
    (27) blocks -> . blocks assignment
    (28) blocks -> . blocks if comparison then_if blocks conditionals END IF
    (29) blocks -> . blocks do blocks IF comparison then_if blocks exit END IF blocks END DO
    (30) blocks -> . blocks do assignment_do COMMA arithmetic colon blocks END DO
    (31) blocks -> . blocks do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks END DO
    (32) blocks -> . blocks ID LPAREN RPAREN
    (33) blocks -> . blocks READ TIMES COMMA matrix
    (34) blocks -> . blocks PRINT TIMES COMMA matrix
    (35) blocks -> . blocks PRINT TIMES COMMA STRING
    (36) blocks -> . empty
    (75) empty -> .

  ! shift/reduce conflict for IF resolved as shift
  ! reduce/reduce conflict for END resolved using rule 45 (conditionals -> else .)
    IF              shift and go to state 142
    END             reduce using rule 45 (conditionals -> else .)
    ID              reduce using rule 75 (empty -> .)
    READ            reduce using rule 75 (empty -> .)
    PRINT           reduce using rule 75 (empty -> .)
    DO              reduce using rule 75 (empty -> .)

  ! IF              [ reduce using rule 75 (empty -> .) ]
  ! END             [ reduce using rule 75 (empty -> .) ]

    blocks                         shift and go to state 141
    empty                          shift and go to state 16

state 124

    (46) else -> ELSE .

    IF              reduce using rule 46 (else -> ELSE .)
    ID              reduce using rule 46 (else -> ELSE .)
    READ            reduce using rule 46 (else -> ELSE .)
    PRINT           reduce using rule 46 (else -> ELSE .)
    DO              reduce using rule 46 (else -> ELSE .)
    END             reduce using rule 46 (else -> ELSE .)


state 125

    (47) else -> empty .

    IF              reduce using rule 47 (else -> empty .)
    ID              reduce using rule 47 (else -> empty .)
    READ            reduce using rule 47 (else -> empty .)
    PRINT           reduce using rule 47 (else -> empty .)
    DO              reduce using rule 47 (else -> empty .)
    END             reduce using rule 47 (else -> empty .)


state 126

    (58) factor -> LPAREN arithmetic RPAREN .
    (73) comparisonfour -> LPAREN arithmetic RPAREN .

  ! reduce/reduce conflict for RPAREN resolved using rule 58 (factor -> LPAREN arithmetic RPAREN .)
    TIMES           reduce using rule 58 (factor -> LPAREN arithmetic RPAREN .)
    DIVIDE          reduce using rule 58 (factor -> LPAREN arithmetic RPAREN .)
    RPAREN          reduce using rule 58 (factor -> LPAREN arithmetic RPAREN .)
    PLUS            reduce using rule 58 (factor -> LPAREN arithmetic RPAREN .)
    MINUS           reduce using rule 58 (factor -> LPAREN arithmetic RPAREN .)
    EQ              reduce using rule 73 (comparisonfour -> LPAREN arithmetic RPAREN .)
    NEQ             reduce using rule 73 (comparisonfour -> LPAREN arithmetic RPAREN .)
    LT              reduce using rule 73 (comparisonfour -> LPAREN arithmetic RPAREN .)
    GT              reduce using rule 73 (comparisonfour -> LPAREN arithmetic RPAREN .)
    LTE             reduce using rule 73 (comparisonfour -> LPAREN arithmetic RPAREN .)
    GTE             reduce using rule 73 (comparisonfour -> LPAREN arithmetic RPAREN .)
    AND             reduce using rule 73 (comparisonfour -> LPAREN arithmetic RPAREN .)
    OR              reduce using rule 73 (comparisonfour -> LPAREN arithmetic RPAREN .)

  ! RPAREN          [ reduce using rule 73 (comparisonfour -> LPAREN arithmetic RPAREN .) ]


state 127

    (49) arithmetic -> arithmetic PLUS term .
    (52) term -> term . TIMES factor
    (53) term -> term . DIVIDE factor

    RPAREN          reduce using rule 49 (arithmetic -> arithmetic PLUS term .)
    PLUS            reduce using rule 49 (arithmetic -> arithmetic PLUS term .)
    MINUS           reduce using rule 49 (arithmetic -> arithmetic PLUS term .)
    END             reduce using rule 49 (arithmetic -> arithmetic PLUS term .)
    ID              reduce using rule 49 (arithmetic -> arithmetic PLUS term .)
    READ            reduce using rule 49 (arithmetic -> arithmetic PLUS term .)
    PRINT           reduce using rule 49 (arithmetic -> arithmetic PLUS term .)
    IF              reduce using rule 49 (arithmetic -> arithmetic PLUS term .)
    DO              reduce using rule 49 (arithmetic -> arithmetic PLUS term .)
    ELSE            reduce using rule 49 (arithmetic -> arithmetic PLUS term .)
    EXIT            reduce using rule 49 (arithmetic -> arithmetic PLUS term .)
    COLON           reduce using rule 49 (arithmetic -> arithmetic PLUS term .)
    COMMA           reduce using rule 49 (arithmetic -> arithmetic PLUS term .)
    TIMES           shift and go to state 107
    DIVIDE          shift and go to state 108


state 128

    (50) arithmetic -> arithmetic MINUS term .
    (52) term -> term . TIMES factor
    (53) term -> term . DIVIDE factor

    RPAREN          reduce using rule 50 (arithmetic -> arithmetic MINUS term .)
    PLUS            reduce using rule 50 (arithmetic -> arithmetic MINUS term .)
    MINUS           reduce using rule 50 (arithmetic -> arithmetic MINUS term .)
    END             reduce using rule 50 (arithmetic -> arithmetic MINUS term .)
    ID              reduce using rule 50 (arithmetic -> arithmetic MINUS term .)
    READ            reduce using rule 50 (arithmetic -> arithmetic MINUS term .)
    PRINT           reduce using rule 50 (arithmetic -> arithmetic MINUS term .)
    IF              reduce using rule 50 (arithmetic -> arithmetic MINUS term .)
    DO              reduce using rule 50 (arithmetic -> arithmetic MINUS term .)
    ELSE            reduce using rule 50 (arithmetic -> arithmetic MINUS term .)
    EXIT            reduce using rule 50 (arithmetic -> arithmetic MINUS term .)
    COLON           reduce using rule 50 (arithmetic -> arithmetic MINUS term .)
    COMMA           reduce using rule 50 (arithmetic -> arithmetic MINUS term .)
    TIMES           shift and go to state 107
    DIVIDE          shift and go to state 108


state 129

    (52) term -> term TIMES factor .

    TIMES           reduce using rule 52 (term -> term TIMES factor .)
    DIVIDE          reduce using rule 52 (term -> term TIMES factor .)
    RPAREN          reduce using rule 52 (term -> term TIMES factor .)
    PLUS            reduce using rule 52 (term -> term TIMES factor .)
    MINUS           reduce using rule 52 (term -> term TIMES factor .)
    END             reduce using rule 52 (term -> term TIMES factor .)
    ID              reduce using rule 52 (term -> term TIMES factor .)
    READ            reduce using rule 52 (term -> term TIMES factor .)
    PRINT           reduce using rule 52 (term -> term TIMES factor .)
    IF              reduce using rule 52 (term -> term TIMES factor .)
    DO              reduce using rule 52 (term -> term TIMES factor .)
    ELSE            reduce using rule 52 (term -> term TIMES factor .)
    EXIT            reduce using rule 52 (term -> term TIMES factor .)
    COLON           reduce using rule 52 (term -> term TIMES factor .)
    COMMA           reduce using rule 52 (term -> term TIMES factor .)


state 130

    (53) term -> term DIVIDE factor .

    TIMES           reduce using rule 53 (term -> term DIVIDE factor .)
    DIVIDE          reduce using rule 53 (term -> term DIVIDE factor .)
    RPAREN          reduce using rule 53 (term -> term DIVIDE factor .)
    PLUS            reduce using rule 53 (term -> term DIVIDE factor .)
    MINUS           reduce using rule 53 (term -> term DIVIDE factor .)
    END             reduce using rule 53 (term -> term DIVIDE factor .)
    ID              reduce using rule 53 (term -> term DIVIDE factor .)
    READ            reduce using rule 53 (term -> term DIVIDE factor .)
    PRINT           reduce using rule 53 (term -> term DIVIDE factor .)
    IF              reduce using rule 53 (term -> term DIVIDE factor .)
    DO              reduce using rule 53 (term -> term DIVIDE factor .)
    ELSE            reduce using rule 53 (term -> term DIVIDE factor .)
    EXIT            reduce using rule 53 (term -> term DIVIDE factor .)
    COLON           reduce using rule 53 (term -> term DIVIDE factor .)
    COMMA           reduce using rule 53 (term -> term DIVIDE factor .)


state 131

    (29) blocks -> blocks do blocks IF comparison then_if . blocks exit END IF blocks END DO
    (27) blocks -> . blocks assignment
    (28) blocks -> . blocks if comparison then_if blocks conditionals END IF
    (29) blocks -> . blocks do blocks IF comparison then_if blocks exit END IF blocks END DO
    (30) blocks -> . blocks do assignment_do COMMA arithmetic colon blocks END DO
    (31) blocks -> . blocks do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks END DO
    (32) blocks -> . blocks ID LPAREN RPAREN
    (33) blocks -> . blocks READ TIMES COMMA matrix
    (34) blocks -> . blocks PRINT TIMES COMMA matrix
    (35) blocks -> . blocks PRINT TIMES COMMA STRING
    (36) blocks -> . empty
    (75) empty -> .

    ID              reduce using rule 75 (empty -> .)
    READ            reduce using rule 75 (empty -> .)
    PRINT           reduce using rule 75 (empty -> .)
    EXIT            reduce using rule 75 (empty -> .)
    IF              reduce using rule 75 (empty -> .)
    DO              reduce using rule 75 (empty -> .)

    blocks                         shift and go to state 143
    empty                          shift and go to state 16

state 132

    (30) blocks -> blocks do assignment_do COMMA arithmetic colon . blocks END DO
    (31) blocks -> blocks do assignment_do COMMA arithmetic colon . IF comparison then_if blocks exit END IF blocks END DO
    (27) blocks -> . blocks assignment
    (28) blocks -> . blocks if comparison then_if blocks conditionals END IF
    (29) blocks -> . blocks do blocks IF comparison then_if blocks exit END IF blocks END DO
    (30) blocks -> . blocks do assignment_do COMMA arithmetic colon blocks END DO
    (31) blocks -> . blocks do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks END DO
    (32) blocks -> . blocks ID LPAREN RPAREN
    (33) blocks -> . blocks READ TIMES COMMA matrix
    (34) blocks -> . blocks PRINT TIMES COMMA matrix
    (35) blocks -> . blocks PRINT TIMES COMMA STRING
    (36) blocks -> . empty
    (75) empty -> .

  ! shift/reduce conflict for IF resolved as shift
    IF              shift and go to state 145
    END             reduce using rule 75 (empty -> .)
    ID              reduce using rule 75 (empty -> .)
    READ            reduce using rule 75 (empty -> .)
    PRINT           reduce using rule 75 (empty -> .)
    DO              reduce using rule 75 (empty -> .)

  ! IF              [ reduce using rule 75 (empty -> .) ]

    blocks                         shift and go to state 144
    empty                          shift and go to state 16

state 133

    (38) colon -> COLON .

    IF              reduce using rule 38 (colon -> COLON .)
    END             reduce using rule 38 (colon -> COLON .)
    ID              reduce using rule 38 (colon -> COLON .)
    READ            reduce using rule 38 (colon -> COLON .)
    PRINT           reduce using rule 38 (colon -> COLON .)
    DO              reduce using rule 38 (colon -> COLON .)


state 134

    (58) factor -> LPAREN arithmetic RPAREN .

    TIMES           reduce using rule 58 (factor -> LPAREN arithmetic RPAREN .)
    DIVIDE          reduce using rule 58 (factor -> LPAREN arithmetic RPAREN .)
    PLUS            reduce using rule 58 (factor -> LPAREN arithmetic RPAREN .)
    MINUS           reduce using rule 58 (factor -> LPAREN arithmetic RPAREN .)
    END             reduce using rule 58 (factor -> LPAREN arithmetic RPAREN .)
    ID              reduce using rule 58 (factor -> LPAREN arithmetic RPAREN .)
    READ            reduce using rule 58 (factor -> LPAREN arithmetic RPAREN .)
    PRINT           reduce using rule 58 (factor -> LPAREN arithmetic RPAREN .)
    IF              reduce using rule 58 (factor -> LPAREN arithmetic RPAREN .)
    DO              reduce using rule 58 (factor -> LPAREN arithmetic RPAREN .)
    ELSE            reduce using rule 58 (factor -> LPAREN arithmetic RPAREN .)
    EXIT            reduce using rule 58 (factor -> LPAREN arithmetic RPAREN .)
    COLON           reduce using rule 58 (factor -> LPAREN arithmetic RPAREN .)
    COMMA           reduce using rule 58 (factor -> LPAREN arithmetic RPAREN .)
    RPAREN          reduce using rule 58 (factor -> LPAREN arithmetic RPAREN .)


state 135

    (22) subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks END .
    (23) subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks END . SUBROUTINE
    (24) subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks END . SUBROUTINE ID

  ! shift/reduce conflict for SUBROUTINE resolved as shift
    END             reduce using rule 22 (subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks END .)
    ID              reduce using rule 22 (subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks END .)
    READ            reduce using rule 22 (subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks END .)
    PRINT           reduce using rule 22 (subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks END .)
    IF              reduce using rule 22 (subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks END .)
    DO              reduce using rule 22 (subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks END .)
    SUBROUTINE      shift and go to state 146

  ! SUBROUTINE      [ reduce using rule 22 (subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks END .) ]


state 136

    (10) variables -> variables COMMA ID LPAREN INT . RPAREN
    (11) variables -> variables COMMA ID LPAREN INT . COMMA INT RPAREN

    RPAREN          shift and go to state 148
    COMMA           shift and go to state 147


state 137

    (14) variables -> ID LPAREN INT COMMA INT . RPAREN

    RPAREN          shift and go to state 149


state 138

    (19) matrix -> ID LPAREN ID COMMA ID RPAREN .

    ASSIGN          reduce using rule 19 (matrix -> ID LPAREN ID COMMA ID RPAREN .)
    EQ              reduce using rule 19 (matrix -> ID LPAREN ID COMMA ID RPAREN .)
    NEQ             reduce using rule 19 (matrix -> ID LPAREN ID COMMA ID RPAREN .)
    LT              reduce using rule 19 (matrix -> ID LPAREN ID COMMA ID RPAREN .)
    GT              reduce using rule 19 (matrix -> ID LPAREN ID COMMA ID RPAREN .)
    LTE             reduce using rule 19 (matrix -> ID LPAREN ID COMMA ID RPAREN .)
    GTE             reduce using rule 19 (matrix -> ID LPAREN ID COMMA ID RPAREN .)
    AND             reduce using rule 19 (matrix -> ID LPAREN ID COMMA ID RPAREN .)
    OR              reduce using rule 19 (matrix -> ID LPAREN ID COMMA ID RPAREN .)
    THEN            reduce using rule 19 (matrix -> ID LPAREN ID COMMA ID RPAREN .)
    TIMES           reduce using rule 19 (matrix -> ID LPAREN ID COMMA ID RPAREN .)
    DIVIDE          reduce using rule 19 (matrix -> ID LPAREN ID COMMA ID RPAREN .)
    RPAREN          reduce using rule 19 (matrix -> ID LPAREN ID COMMA ID RPAREN .)
    PLUS            reduce using rule 19 (matrix -> ID LPAREN ID COMMA ID RPAREN .)
    MINUS           reduce using rule 19 (matrix -> ID LPAREN ID COMMA ID RPAREN .)
    END             reduce using rule 19 (matrix -> ID LPAREN ID COMMA ID RPAREN .)
    ID              reduce using rule 19 (matrix -> ID LPAREN ID COMMA ID RPAREN .)
    READ            reduce using rule 19 (matrix -> ID LPAREN ID COMMA ID RPAREN .)
    PRINT           reduce using rule 19 (matrix -> ID LPAREN ID COMMA ID RPAREN .)
    IF              reduce using rule 19 (matrix -> ID LPAREN ID COMMA ID RPAREN .)
    DO              reduce using rule 19 (matrix -> ID LPAREN ID COMMA ID RPAREN .)
    ELSE            reduce using rule 19 (matrix -> ID LPAREN ID COMMA ID RPAREN .)
    EXIT            reduce using rule 19 (matrix -> ID LPAREN ID COMMA ID RPAREN .)
    COLON           reduce using rule 19 (matrix -> ID LPAREN ID COMMA ID RPAREN .)
    COMMA           reduce using rule 19 (matrix -> ID LPAREN ID COMMA ID RPAREN .)


state 139

    (17) matrix -> ID LPAREN INT COMMA INT RPAREN .

    ASSIGN          reduce using rule 17 (matrix -> ID LPAREN INT COMMA INT RPAREN .)
    EQ              reduce using rule 17 (matrix -> ID LPAREN INT COMMA INT RPAREN .)
    NEQ             reduce using rule 17 (matrix -> ID LPAREN INT COMMA INT RPAREN .)
    LT              reduce using rule 17 (matrix -> ID LPAREN INT COMMA INT RPAREN .)
    GT              reduce using rule 17 (matrix -> ID LPAREN INT COMMA INT RPAREN .)
    LTE             reduce using rule 17 (matrix -> ID LPAREN INT COMMA INT RPAREN .)
    GTE             reduce using rule 17 (matrix -> ID LPAREN INT COMMA INT RPAREN .)
    AND             reduce using rule 17 (matrix -> ID LPAREN INT COMMA INT RPAREN .)
    OR              reduce using rule 17 (matrix -> ID LPAREN INT COMMA INT RPAREN .)
    THEN            reduce using rule 17 (matrix -> ID LPAREN INT COMMA INT RPAREN .)
    TIMES           reduce using rule 17 (matrix -> ID LPAREN INT COMMA INT RPAREN .)
    DIVIDE          reduce using rule 17 (matrix -> ID LPAREN INT COMMA INT RPAREN .)
    RPAREN          reduce using rule 17 (matrix -> ID LPAREN INT COMMA INT RPAREN .)
    PLUS            reduce using rule 17 (matrix -> ID LPAREN INT COMMA INT RPAREN .)
    MINUS           reduce using rule 17 (matrix -> ID LPAREN INT COMMA INT RPAREN .)
    END             reduce using rule 17 (matrix -> ID LPAREN INT COMMA INT RPAREN .)
    ID              reduce using rule 17 (matrix -> ID LPAREN INT COMMA INT RPAREN .)
    READ            reduce using rule 17 (matrix -> ID LPAREN INT COMMA INT RPAREN .)
    PRINT           reduce using rule 17 (matrix -> ID LPAREN INT COMMA INT RPAREN .)
    IF              reduce using rule 17 (matrix -> ID LPAREN INT COMMA INT RPAREN .)
    DO              reduce using rule 17 (matrix -> ID LPAREN INT COMMA INT RPAREN .)
    ELSE            reduce using rule 17 (matrix -> ID LPAREN INT COMMA INT RPAREN .)
    EXIT            reduce using rule 17 (matrix -> ID LPAREN INT COMMA INT RPAREN .)
    COLON           reduce using rule 17 (matrix -> ID LPAREN INT COMMA INT RPAREN .)
    COMMA           reduce using rule 17 (matrix -> ID LPAREN INT COMMA INT RPAREN .)


state 140

    (28) blocks -> blocks if comparison then_if blocks conditionals END . IF

    IF              shift and go to state 150


state 141

    (43) conditionals -> else blocks .
    (27) blocks -> blocks . assignment
    (28) blocks -> blocks . if comparison then_if blocks conditionals END IF
    (29) blocks -> blocks . do blocks IF comparison then_if blocks exit END IF blocks END DO
    (30) blocks -> blocks . do assignment_do COMMA arithmetic colon blocks END DO
    (31) blocks -> blocks . do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks END DO
    (32) blocks -> blocks . ID LPAREN RPAREN
    (33) blocks -> blocks . READ TIMES COMMA matrix
    (34) blocks -> blocks . PRINT TIMES COMMA matrix
    (35) blocks -> blocks . PRINT TIMES COMMA STRING
    (48) assignment -> . matrix ASSIGN arithmetic
    (41) if -> . IF
    (37) do -> . DO
    (15) matrix -> . ID
    (16) matrix -> . ID LPAREN INT RPAREN
    (17) matrix -> . ID LPAREN INT COMMA INT RPAREN
    (18) matrix -> . ID LPAREN ID RPAREN
    (19) matrix -> . ID LPAREN ID COMMA ID RPAREN

    END             reduce using rule 43 (conditionals -> else blocks .)
    ID              shift and go to state 18
    READ            shift and go to state 25
    PRINT           shift and go to state 27
    IF              shift and go to state 22
    DO              shift and go to state 24

    assignment                     shift and go to state 20
    if                             shift and go to state 21
    do                             shift and go to state 23
    matrix                         shift and go to state 26

state 142

    (44) conditionals -> else IF . comparison then_if blocks conditionals
    (59) comparison -> . comparison OR comparisontwo
    (60) comparison -> . comparisontwo
    (61) comparisontwo -> . comparisontwo AND comparisonthree
    (62) comparisontwo -> . comparisonthree
    (63) comparisonthree -> . comparisonthree EQ comparisonfour
    (64) comparisonthree -> . comparisonthree NEQ comparisonfour
    (65) comparisonthree -> . comparisonthree LT comparisonfour
    (66) comparisonthree -> . comparisonthree GT comparisonfour
    (67) comparisonthree -> . comparisonthree LTE comparisonfour
    (68) comparisonthree -> . comparisonthree GTE comparisonfour
    (69) comparisonthree -> . comparisonfour
    (70) comparisonfour -> . INT
    (71) comparisonfour -> . FLOAT
    (72) comparisonfour -> . matrix
    (73) comparisonfour -> . LPAREN arithmetic RPAREN
    (74) comparisonfour -> . LPAREN comparison RPAREN
    (15) matrix -> . ID
    (16) matrix -> . ID LPAREN INT RPAREN
    (17) matrix -> . ID LPAREN INT COMMA INT RPAREN
    (18) matrix -> . ID LPAREN ID RPAREN
    (19) matrix -> . ID LPAREN ID COMMA ID RPAREN

    INT             shift and go to state 38
    FLOAT           shift and go to state 39
    LPAREN          shift and go to state 41
    ID              shift and go to state 42

    comparison                     shift and go to state 151
    comparisontwo                  shift and go to state 35
    comparisonthree                shift and go to state 36
    comparisonfour                 shift and go to state 37
    matrix                         shift and go to state 40

state 143

    (29) blocks -> blocks do blocks IF comparison then_if blocks . exit END IF blocks END DO
    (27) blocks -> blocks . assignment
    (28) blocks -> blocks . if comparison then_if blocks conditionals END IF
    (29) blocks -> blocks . do blocks IF comparison then_if blocks exit END IF blocks END DO
    (30) blocks -> blocks . do assignment_do COMMA arithmetic colon blocks END DO
    (31) blocks -> blocks . do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks END DO
    (32) blocks -> blocks . ID LPAREN RPAREN
    (33) blocks -> blocks . READ TIMES COMMA matrix
    (34) blocks -> blocks . PRINT TIMES COMMA matrix
    (35) blocks -> blocks . PRINT TIMES COMMA STRING
    (40) exit -> . EXIT
    (48) assignment -> . matrix ASSIGN arithmetic
    (41) if -> . IF
    (37) do -> . DO
    (15) matrix -> . ID
    (16) matrix -> . ID LPAREN INT RPAREN
    (17) matrix -> . ID LPAREN INT COMMA INT RPAREN
    (18) matrix -> . ID LPAREN ID RPAREN
    (19) matrix -> . ID LPAREN ID COMMA ID RPAREN

    ID              shift and go to state 18
    READ            shift and go to state 25
    PRINT           shift and go to state 27
    EXIT            shift and go to state 153
    IF              shift and go to state 22
    DO              shift and go to state 24

    do                             shift and go to state 23
    exit                           shift and go to state 152
    assignment                     shift and go to state 20
    if                             shift and go to state 21
    matrix                         shift and go to state 26

state 144

    (30) blocks -> blocks do assignment_do COMMA arithmetic colon blocks . END DO
    (27) blocks -> blocks . assignment
    (28) blocks -> blocks . if comparison then_if blocks conditionals END IF
    (29) blocks -> blocks . do blocks IF comparison then_if blocks exit END IF blocks END DO
    (30) blocks -> blocks . do assignment_do COMMA arithmetic colon blocks END DO
    (31) blocks -> blocks . do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks END DO
    (32) blocks -> blocks . ID LPAREN RPAREN
    (33) blocks -> blocks . READ TIMES COMMA matrix
    (34) blocks -> blocks . PRINT TIMES COMMA matrix
    (35) blocks -> blocks . PRINT TIMES COMMA STRING
    (48) assignment -> . matrix ASSIGN arithmetic
    (41) if -> . IF
    (37) do -> . DO
    (15) matrix -> . ID
    (16) matrix -> . ID LPAREN INT RPAREN
    (17) matrix -> . ID LPAREN INT COMMA INT RPAREN
    (18) matrix -> . ID LPAREN ID RPAREN
    (19) matrix -> . ID LPAREN ID COMMA ID RPAREN

    END             shift and go to state 154
    ID              shift and go to state 18
    READ            shift and go to state 25
    PRINT           shift and go to state 27
    IF              shift and go to state 22
    DO              shift and go to state 24

    do                             shift and go to state 23
    assignment                     shift and go to state 20
    if                             shift and go to state 21
    matrix                         shift and go to state 26

state 145

    (31) blocks -> blocks do assignment_do COMMA arithmetic colon IF . comparison then_if blocks exit END IF blocks END DO
    (59) comparison -> . comparison OR comparisontwo
    (60) comparison -> . comparisontwo
    (61) comparisontwo -> . comparisontwo AND comparisonthree
    (62) comparisontwo -> . comparisonthree
    (63) comparisonthree -> . comparisonthree EQ comparisonfour
    (64) comparisonthree -> . comparisonthree NEQ comparisonfour
    (65) comparisonthree -> . comparisonthree LT comparisonfour
    (66) comparisonthree -> . comparisonthree GT comparisonfour
    (67) comparisonthree -> . comparisonthree LTE comparisonfour
    (68) comparisonthree -> . comparisonthree GTE comparisonfour
    (69) comparisonthree -> . comparisonfour
    (70) comparisonfour -> . INT
    (71) comparisonfour -> . FLOAT
    (72) comparisonfour -> . matrix
    (73) comparisonfour -> . LPAREN arithmetic RPAREN
    (74) comparisonfour -> . LPAREN comparison RPAREN
    (15) matrix -> . ID
    (16) matrix -> . ID LPAREN INT RPAREN
    (17) matrix -> . ID LPAREN INT COMMA INT RPAREN
    (18) matrix -> . ID LPAREN ID RPAREN
    (19) matrix -> . ID LPAREN ID COMMA ID RPAREN

    INT             shift and go to state 38
    FLOAT           shift and go to state 39
    LPAREN          shift and go to state 41
    ID              shift and go to state 42

    comparison                     shift and go to state 155
    comparisontwo                  shift and go to state 35
    comparisonthree                shift and go to state 36
    comparisonfour                 shift and go to state 37
    matrix                         shift and go to state 40

state 146

    (23) subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks END SUBROUTINE .
    (24) subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks END SUBROUTINE . ID

  ! shift/reduce conflict for ID resolved as shift
    SUBROUTINE      reduce using rule 23 (subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks END SUBROUTINE .)
    END             reduce using rule 23 (subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks END SUBROUTINE .)
    READ            reduce using rule 23 (subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks END SUBROUTINE .)
    PRINT           reduce using rule 23 (subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks END SUBROUTINE .)
    IF              reduce using rule 23 (subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks END SUBROUTINE .)
    DO              reduce using rule 23 (subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks END SUBROUTINE .)
    ID              shift and go to state 156

  ! ID              [ reduce using rule 23 (subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks END SUBROUTINE .) ]


state 147

    (11) variables -> variables COMMA ID LPAREN INT COMMA . INT RPAREN

    INT             shift and go to state 157


state 148

    (10) variables -> variables COMMA ID LPAREN INT RPAREN .

    COMMA           reduce using rule 10 (variables -> variables COMMA ID LPAREN INT RPAREN .)
    INTEGER         reduce using rule 10 (variables -> variables COMMA ID LPAREN INT RPAREN .)
    REAL            reduce using rule 10 (variables -> variables COMMA ID LPAREN INT RPAREN .)
    SUBROUTINE      reduce using rule 10 (variables -> variables COMMA ID LPAREN INT RPAREN .)
    END             reduce using rule 10 (variables -> variables COMMA ID LPAREN INT RPAREN .)
    ID              reduce using rule 10 (variables -> variables COMMA ID LPAREN INT RPAREN .)
    READ            reduce using rule 10 (variables -> variables COMMA ID LPAREN INT RPAREN .)
    PRINT           reduce using rule 10 (variables -> variables COMMA ID LPAREN INT RPAREN .)
    IF              reduce using rule 10 (variables -> variables COMMA ID LPAREN INT RPAREN .)
    DO              reduce using rule 10 (variables -> variables COMMA ID LPAREN INT RPAREN .)


state 149

    (14) variables -> ID LPAREN INT COMMA INT RPAREN .

    COMMA           reduce using rule 14 (variables -> ID LPAREN INT COMMA INT RPAREN .)
    INTEGER         reduce using rule 14 (variables -> ID LPAREN INT COMMA INT RPAREN .)
    REAL            reduce using rule 14 (variables -> ID LPAREN INT COMMA INT RPAREN .)
    SUBROUTINE      reduce using rule 14 (variables -> ID LPAREN INT COMMA INT RPAREN .)
    END             reduce using rule 14 (variables -> ID LPAREN INT COMMA INT RPAREN .)
    ID              reduce using rule 14 (variables -> ID LPAREN INT COMMA INT RPAREN .)
    READ            reduce using rule 14 (variables -> ID LPAREN INT COMMA INT RPAREN .)
    PRINT           reduce using rule 14 (variables -> ID LPAREN INT COMMA INT RPAREN .)
    IF              reduce using rule 14 (variables -> ID LPAREN INT COMMA INT RPAREN .)
    DO              reduce using rule 14 (variables -> ID LPAREN INT COMMA INT RPAREN .)


state 150

    (28) blocks -> blocks if comparison then_if blocks conditionals END IF .

    END             reduce using rule 28 (blocks -> blocks if comparison then_if blocks conditionals END IF .)
    ID              reduce using rule 28 (blocks -> blocks if comparison then_if blocks conditionals END IF .)
    READ            reduce using rule 28 (blocks -> blocks if comparison then_if blocks conditionals END IF .)
    PRINT           reduce using rule 28 (blocks -> blocks if comparison then_if blocks conditionals END IF .)
    IF              reduce using rule 28 (blocks -> blocks if comparison then_if blocks conditionals END IF .)
    DO              reduce using rule 28 (blocks -> blocks if comparison then_if blocks conditionals END IF .)
    ELSE            reduce using rule 28 (blocks -> blocks if comparison then_if blocks conditionals END IF .)
    EXIT            reduce using rule 28 (blocks -> blocks if comparison then_if blocks conditionals END IF .)


state 151

    (44) conditionals -> else IF comparison . then_if blocks conditionals
    (59) comparison -> comparison . OR comparisontwo
    (42) then_if -> . THEN

    OR              shift and go to state 58
    THEN            shift and go to state 59

    then_if                        shift and go to state 158

state 152

    (29) blocks -> blocks do blocks IF comparison then_if blocks exit . END IF blocks END DO

    END             shift and go to state 159


state 153

    (40) exit -> EXIT .

    END             reduce using rule 40 (exit -> EXIT .)


state 154

    (30) blocks -> blocks do assignment_do COMMA arithmetic colon blocks END . DO

    DO              shift and go to state 160


state 155

    (31) blocks -> blocks do assignment_do COMMA arithmetic colon IF comparison . then_if blocks exit END IF blocks END DO
    (59) comparison -> comparison . OR comparisontwo
    (42) then_if -> . THEN

    OR              shift and go to state 58
    THEN            shift and go to state 59

    then_if                        shift and go to state 161

state 156

    (24) subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks END SUBROUTINE ID .

    SUBROUTINE      reduce using rule 24 (subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks END SUBROUTINE ID .)
    END             reduce using rule 24 (subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks END SUBROUTINE ID .)
    ID              reduce using rule 24 (subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks END SUBROUTINE ID .)
    READ            reduce using rule 24 (subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks END SUBROUTINE ID .)
    PRINT           reduce using rule 24 (subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks END SUBROUTINE ID .)
    IF              reduce using rule 24 (subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks END SUBROUTINE ID .)
    DO              reduce using rule 24 (subroutines -> subroutines SUBROUTINE id_subroutine LPAREN RPAREN blocks END SUBROUTINE ID .)


state 157

    (11) variables -> variables COMMA ID LPAREN INT COMMA INT . RPAREN

    RPAREN          shift and go to state 162


state 158

    (44) conditionals -> else IF comparison then_if . blocks conditionals
    (27) blocks -> . blocks assignment
    (28) blocks -> . blocks if comparison then_if blocks conditionals END IF
    (29) blocks -> . blocks do blocks IF comparison then_if blocks exit END IF blocks END DO
    (30) blocks -> . blocks do assignment_do COMMA arithmetic colon blocks END DO
    (31) blocks -> . blocks do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks END DO
    (32) blocks -> . blocks ID LPAREN RPAREN
    (33) blocks -> . blocks READ TIMES COMMA matrix
    (34) blocks -> . blocks PRINT TIMES COMMA matrix
    (35) blocks -> . blocks PRINT TIMES COMMA STRING
    (36) blocks -> . empty
    (75) empty -> .

    ID              reduce using rule 75 (empty -> .)
    READ            reduce using rule 75 (empty -> .)
    PRINT           reduce using rule 75 (empty -> .)
    IF              reduce using rule 75 (empty -> .)
    DO              reduce using rule 75 (empty -> .)
    ELSE            reduce using rule 75 (empty -> .)
    END             reduce using rule 75 (empty -> .)

    blocks                         shift and go to state 163
    empty                          shift and go to state 16

state 159

    (29) blocks -> blocks do blocks IF comparison then_if blocks exit END . IF blocks END DO

    IF              shift and go to state 164


state 160

    (30) blocks -> blocks do assignment_do COMMA arithmetic colon blocks END DO .

    END             reduce using rule 30 (blocks -> blocks do assignment_do COMMA arithmetic colon blocks END DO .)
    ID              reduce using rule 30 (blocks -> blocks do assignment_do COMMA arithmetic colon blocks END DO .)
    READ            reduce using rule 30 (blocks -> blocks do assignment_do COMMA arithmetic colon blocks END DO .)
    PRINT           reduce using rule 30 (blocks -> blocks do assignment_do COMMA arithmetic colon blocks END DO .)
    IF              reduce using rule 30 (blocks -> blocks do assignment_do COMMA arithmetic colon blocks END DO .)
    DO              reduce using rule 30 (blocks -> blocks do assignment_do COMMA arithmetic colon blocks END DO .)
    ELSE            reduce using rule 30 (blocks -> blocks do assignment_do COMMA arithmetic colon blocks END DO .)
    EXIT            reduce using rule 30 (blocks -> blocks do assignment_do COMMA arithmetic colon blocks END DO .)


state 161

    (31) blocks -> blocks do assignment_do COMMA arithmetic colon IF comparison then_if . blocks exit END IF blocks END DO
    (27) blocks -> . blocks assignment
    (28) blocks -> . blocks if comparison then_if blocks conditionals END IF
    (29) blocks -> . blocks do blocks IF comparison then_if blocks exit END IF blocks END DO
    (30) blocks -> . blocks do assignment_do COMMA arithmetic colon blocks END DO
    (31) blocks -> . blocks do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks END DO
    (32) blocks -> . blocks ID LPAREN RPAREN
    (33) blocks -> . blocks READ TIMES COMMA matrix
    (34) blocks -> . blocks PRINT TIMES COMMA matrix
    (35) blocks -> . blocks PRINT TIMES COMMA STRING
    (36) blocks -> . empty
    (75) empty -> .

    ID              reduce using rule 75 (empty -> .)
    READ            reduce using rule 75 (empty -> .)
    PRINT           reduce using rule 75 (empty -> .)
    EXIT            reduce using rule 75 (empty -> .)
    IF              reduce using rule 75 (empty -> .)
    DO              reduce using rule 75 (empty -> .)

    blocks                         shift and go to state 165
    empty                          shift and go to state 16

state 162

    (11) variables -> variables COMMA ID LPAREN INT COMMA INT RPAREN .

    COMMA           reduce using rule 11 (variables -> variables COMMA ID LPAREN INT COMMA INT RPAREN .)
    INTEGER         reduce using rule 11 (variables -> variables COMMA ID LPAREN INT COMMA INT RPAREN .)
    REAL            reduce using rule 11 (variables -> variables COMMA ID LPAREN INT COMMA INT RPAREN .)
    SUBROUTINE      reduce using rule 11 (variables -> variables COMMA ID LPAREN INT COMMA INT RPAREN .)
    END             reduce using rule 11 (variables -> variables COMMA ID LPAREN INT COMMA INT RPAREN .)
    ID              reduce using rule 11 (variables -> variables COMMA ID LPAREN INT COMMA INT RPAREN .)
    READ            reduce using rule 11 (variables -> variables COMMA ID LPAREN INT COMMA INT RPAREN .)
    PRINT           reduce using rule 11 (variables -> variables COMMA ID LPAREN INT COMMA INT RPAREN .)
    IF              reduce using rule 11 (variables -> variables COMMA ID LPAREN INT COMMA INT RPAREN .)
    DO              reduce using rule 11 (variables -> variables COMMA ID LPAREN INT COMMA INT RPAREN .)


state 163

    (44) conditionals -> else IF comparison then_if blocks . conditionals
    (27) blocks -> blocks . assignment
    (28) blocks -> blocks . if comparison then_if blocks conditionals END IF
    (29) blocks -> blocks . do blocks IF comparison then_if blocks exit END IF blocks END DO
    (30) blocks -> blocks . do assignment_do COMMA arithmetic colon blocks END DO
    (31) blocks -> blocks . do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks END DO
    (32) blocks -> blocks . ID LPAREN RPAREN
    (33) blocks -> blocks . READ TIMES COMMA matrix
    (34) blocks -> blocks . PRINT TIMES COMMA matrix
    (35) blocks -> blocks . PRINT TIMES COMMA STRING
    (43) conditionals -> . else blocks
    (44) conditionals -> . else IF comparison then_if blocks conditionals
    (45) conditionals -> . else
    (48) assignment -> . matrix ASSIGN arithmetic
    (41) if -> . IF
    (37) do -> . DO
    (46) else -> . ELSE
    (47) else -> . empty
    (15) matrix -> . ID
    (16) matrix -> . ID LPAREN INT RPAREN
    (17) matrix -> . ID LPAREN INT COMMA INT RPAREN
    (18) matrix -> . ID LPAREN ID RPAREN
    (19) matrix -> . ID LPAREN ID COMMA ID RPAREN
    (75) empty -> .

  ! shift/reduce conflict for IF resolved as shift
  ! shift/reduce conflict for ID resolved as shift
  ! shift/reduce conflict for READ resolved as shift
  ! shift/reduce conflict for PRINT resolved as shift
  ! shift/reduce conflict for DO resolved as shift
    ID              shift and go to state 18
    READ            shift and go to state 25
    PRINT           shift and go to state 27
    IF              shift and go to state 22
    DO              shift and go to state 24
    ELSE            shift and go to state 124
    END             reduce using rule 75 (empty -> .)

  ! IF              [ reduce using rule 75 (empty -> .) ]
  ! ID              [ reduce using rule 75 (empty -> .) ]
  ! READ            [ reduce using rule 75 (empty -> .) ]
  ! PRINT           [ reduce using rule 75 (empty -> .) ]
  ! DO              [ reduce using rule 75 (empty -> .) ]

    else                           shift and go to state 123
    conditionals                   shift and go to state 166
    assignment                     shift and go to state 20
    if                             shift and go to state 21
    do                             shift and go to state 23
    matrix                         shift and go to state 26
    empty                          shift and go to state 125

state 164

    (29) blocks -> blocks do blocks IF comparison then_if blocks exit END IF . blocks END DO
    (27) blocks -> . blocks assignment
    (28) blocks -> . blocks if comparison then_if blocks conditionals END IF
    (29) blocks -> . blocks do blocks IF comparison then_if blocks exit END IF blocks END DO
    (30) blocks -> . blocks do assignment_do COMMA arithmetic colon blocks END DO
    (31) blocks -> . blocks do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks END DO
    (32) blocks -> . blocks ID LPAREN RPAREN
    (33) blocks -> . blocks READ TIMES COMMA matrix
    (34) blocks -> . blocks PRINT TIMES COMMA matrix
    (35) blocks -> . blocks PRINT TIMES COMMA STRING
    (36) blocks -> . empty
    (75) empty -> .

    END             reduce using rule 75 (empty -> .)
    ID              reduce using rule 75 (empty -> .)
    READ            reduce using rule 75 (empty -> .)
    PRINT           reduce using rule 75 (empty -> .)
    IF              reduce using rule 75 (empty -> .)
    DO              reduce using rule 75 (empty -> .)

    blocks                         shift and go to state 167
    empty                          shift and go to state 16

state 165

    (31) blocks -> blocks do assignment_do COMMA arithmetic colon IF comparison then_if blocks . exit END IF blocks END DO
    (27) blocks -> blocks . assignment
    (28) blocks -> blocks . if comparison then_if blocks conditionals END IF
    (29) blocks -> blocks . do blocks IF comparison then_if blocks exit END IF blocks END DO
    (30) blocks -> blocks . do assignment_do COMMA arithmetic colon blocks END DO
    (31) blocks -> blocks . do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks END DO
    (32) blocks -> blocks . ID LPAREN RPAREN
    (33) blocks -> blocks . READ TIMES COMMA matrix
    (34) blocks -> blocks . PRINT TIMES COMMA matrix
    (35) blocks -> blocks . PRINT TIMES COMMA STRING
    (40) exit -> . EXIT
    (48) assignment -> . matrix ASSIGN arithmetic
    (41) if -> . IF
    (37) do -> . DO
    (15) matrix -> . ID
    (16) matrix -> . ID LPAREN INT RPAREN
    (17) matrix -> . ID LPAREN INT COMMA INT RPAREN
    (18) matrix -> . ID LPAREN ID RPAREN
    (19) matrix -> . ID LPAREN ID COMMA ID RPAREN

    ID              shift and go to state 18
    READ            shift and go to state 25
    PRINT           shift and go to state 27
    EXIT            shift and go to state 153
    IF              shift and go to state 22
    DO              shift and go to state 24

    do                             shift and go to state 23
    exit                           shift and go to state 168
    assignment                     shift and go to state 20
    if                             shift and go to state 21
    matrix                         shift and go to state 26

state 166

    (44) conditionals -> else IF comparison then_if blocks conditionals .

    END             reduce using rule 44 (conditionals -> else IF comparison then_if blocks conditionals .)


state 167

    (29) blocks -> blocks do blocks IF comparison then_if blocks exit END IF blocks . END DO
    (27) blocks -> blocks . assignment
    (28) blocks -> blocks . if comparison then_if blocks conditionals END IF
    (29) blocks -> blocks . do blocks IF comparison then_if blocks exit END IF blocks END DO
    (30) blocks -> blocks . do assignment_do COMMA arithmetic colon blocks END DO
    (31) blocks -> blocks . do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks END DO
    (32) blocks -> blocks . ID LPAREN RPAREN
    (33) blocks -> blocks . READ TIMES COMMA matrix
    (34) blocks -> blocks . PRINT TIMES COMMA matrix
    (35) blocks -> blocks . PRINT TIMES COMMA STRING
    (48) assignment -> . matrix ASSIGN arithmetic
    (41) if -> . IF
    (37) do -> . DO
    (15) matrix -> . ID
    (16) matrix -> . ID LPAREN INT RPAREN
    (17) matrix -> . ID LPAREN INT COMMA INT RPAREN
    (18) matrix -> . ID LPAREN ID RPAREN
    (19) matrix -> . ID LPAREN ID COMMA ID RPAREN

    END             shift and go to state 169
    ID              shift and go to state 18
    READ            shift and go to state 25
    PRINT           shift and go to state 27
    IF              shift and go to state 22
    DO              shift and go to state 24

    do                             shift and go to state 23
    assignment                     shift and go to state 20
    if                             shift and go to state 21
    matrix                         shift and go to state 26

state 168

    (31) blocks -> blocks do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit . END IF blocks END DO

    END             shift and go to state 170


state 169

    (29) blocks -> blocks do blocks IF comparison then_if blocks exit END IF blocks END . DO

    DO              shift and go to state 171


state 170

    (31) blocks -> blocks do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END . IF blocks END DO

    IF              shift and go to state 172


state 171

    (29) blocks -> blocks do blocks IF comparison then_if blocks exit END IF blocks END DO .

    END             reduce using rule 29 (blocks -> blocks do blocks IF comparison then_if blocks exit END IF blocks END DO .)
    ID              reduce using rule 29 (blocks -> blocks do blocks IF comparison then_if blocks exit END IF blocks END DO .)
    READ            reduce using rule 29 (blocks -> blocks do blocks IF comparison then_if blocks exit END IF blocks END DO .)
    PRINT           reduce using rule 29 (blocks -> blocks do blocks IF comparison then_if blocks exit END IF blocks END DO .)
    IF              reduce using rule 29 (blocks -> blocks do blocks IF comparison then_if blocks exit END IF blocks END DO .)
    DO              reduce using rule 29 (blocks -> blocks do blocks IF comparison then_if blocks exit END IF blocks END DO .)
    ELSE            reduce using rule 29 (blocks -> blocks do blocks IF comparison then_if blocks exit END IF blocks END DO .)
    EXIT            reduce using rule 29 (blocks -> blocks do blocks IF comparison then_if blocks exit END IF blocks END DO .)


state 172

    (31) blocks -> blocks do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF . blocks END DO
    (27) blocks -> . blocks assignment
    (28) blocks -> . blocks if comparison then_if blocks conditionals END IF
    (29) blocks -> . blocks do blocks IF comparison then_if blocks exit END IF blocks END DO
    (30) blocks -> . blocks do assignment_do COMMA arithmetic colon blocks END DO
    (31) blocks -> . blocks do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks END DO
    (32) blocks -> . blocks ID LPAREN RPAREN
    (33) blocks -> . blocks READ TIMES COMMA matrix
    (34) blocks -> . blocks PRINT TIMES COMMA matrix
    (35) blocks -> . blocks PRINT TIMES COMMA STRING
    (36) blocks -> . empty
    (75) empty -> .

    END             reduce using rule 75 (empty -> .)
    ID              reduce using rule 75 (empty -> .)
    READ            reduce using rule 75 (empty -> .)
    PRINT           reduce using rule 75 (empty -> .)
    IF              reduce using rule 75 (empty -> .)
    DO              reduce using rule 75 (empty -> .)

    blocks                         shift and go to state 173
    empty                          shift and go to state 16

state 173

    (31) blocks -> blocks do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks . END DO
    (27) blocks -> blocks . assignment
    (28) blocks -> blocks . if comparison then_if blocks conditionals END IF
    (29) blocks -> blocks . do blocks IF comparison then_if blocks exit END IF blocks END DO
    (30) blocks -> blocks . do assignment_do COMMA arithmetic colon blocks END DO
    (31) blocks -> blocks . do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks END DO
    (32) blocks -> blocks . ID LPAREN RPAREN
    (33) blocks -> blocks . READ TIMES COMMA matrix
    (34) blocks -> blocks . PRINT TIMES COMMA matrix
    (35) blocks -> blocks . PRINT TIMES COMMA STRING
    (48) assignment -> . matrix ASSIGN arithmetic
    (41) if -> . IF
    (37) do -> . DO
    (15) matrix -> . ID
    (16) matrix -> . ID LPAREN INT RPAREN
    (17) matrix -> . ID LPAREN INT COMMA INT RPAREN
    (18) matrix -> . ID LPAREN ID RPAREN
    (19) matrix -> . ID LPAREN ID COMMA ID RPAREN

    END             shift and go to state 174
    ID              shift and go to state 18
    READ            shift and go to state 25
    PRINT           shift and go to state 27
    IF              shift and go to state 22
    DO              shift and go to state 24

    do                             shift and go to state 23
    assignment                     shift and go to state 20
    if                             shift and go to state 21
    matrix                         shift and go to state 26

state 174

    (31) blocks -> blocks do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks END . DO

    DO              shift and go to state 175


state 175

    (31) blocks -> blocks do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks END DO .

    END             reduce using rule 31 (blocks -> blocks do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks END DO .)
    ID              reduce using rule 31 (blocks -> blocks do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks END DO .)
    READ            reduce using rule 31 (blocks -> blocks do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks END DO .)
    PRINT           reduce using rule 31 (blocks -> blocks do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks END DO .)
    IF              reduce using rule 31 (blocks -> blocks do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks END DO .)
    DO              reduce using rule 31 (blocks -> blocks do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks END DO .)
    ELSE            reduce using rule 31 (blocks -> blocks do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks END DO .)
    EXIT            reduce using rule 31 (blocks -> blocks do assignment_do COMMA arithmetic colon IF comparison then_if blocks exit END IF blocks END DO .)

WARNING: 
WARNING: Conflicts:
WARNING: 
WARNING: shift/reduce conflict for ID in state 23 resolved as shift
WARNING: shift/reduce conflict for INT in state 76 resolved as shift
WARNING: shift/reduce conflict for FLOAT in state 76 resolved as shift
WARNING: shift/reduce conflict for LPAREN in state 76 resolved as shift
WARNING: shift/reduce conflict for ID in state 76 resolved as shift
WARNING: shift/reduce conflict for IF in state 93 resolved as shift
WARNING: shift/reduce conflict for ID in state 93 resolved as shift
WARNING: shift/reduce conflict for READ in state 93 resolved as shift
WARNING: shift/reduce conflict for PRINT in state 93 resolved as shift
WARNING: shift/reduce conflict for DO in state 93 resolved as shift
WARNING: shift/reduce conflict for IF in state 123 resolved as shift
WARNING: shift/reduce conflict for IF in state 132 resolved as shift
WARNING: shift/reduce conflict for SUBROUTINE in state 135 resolved as shift
WARNING: shift/reduce conflict for ID in state 146 resolved as shift
WARNING: shift/reduce conflict for IF in state 163 resolved as shift
WARNING: shift/reduce conflict for ID in state 163 resolved as shift
WARNING: shift/reduce conflict for READ in state 163 resolved as shift
WARNING: shift/reduce conflict for PRINT in state 163 resolved as shift
WARNING: shift/reduce conflict for DO in state 163 resolved as shift
WARNING: reduce/reduce conflict in state 72 resolved using rule (factor -> INT)
WARNING: rejected rule (comparisonfour -> INT) in state 72
WARNING: reduce/reduce conflict in state 73 resolved using rule (factor -> FLOAT)
WARNING: rejected rule (comparisonfour -> FLOAT) in state 73
WARNING: reduce/reduce conflict in state 74 resolved using rule (factor -> matrix)
WARNING: rejected rule (comparisonfour -> matrix) in state 74
WARNING: reduce/reduce conflict in state 123 resolved using rule (conditionals -> else)
WARNING: rejected rule (empty -> <empty>) in state 123
WARNING: reduce/reduce conflict in state 126 resolved using rule (factor -> LPAREN arithmetic RPAREN)
WARNING: rejected rule (comparisonfour -> LPAREN arithmetic RPAREN) in state 126