parser.out

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

Unused terminals:

    ABSOLUTE
    AND
    ASM
    BREAK
    CASE
    CONSTRUCTOR
    CONTINUE
    DESTRUCTOR
    DIV
    DOWNTO
    EXTERNAL
    FILE
    FORWARD
    GOTO
    IMPLEMENTATION
    IN
    INHERITED
    INLINE
    INTERFACE
    INTERRUPT
    LABEL
    MOD
    NIL
    NOT
    ON
    OPERATOR
    OR
    PACKED
    RECORD
    REPEAT
    SELF
    SET
    SHL
    SHR
    SINGLE_COMMENT
    UNIT
    UNTIL
    WHILE
    WITH
    XOR

Grammar

Rule 0     S' -> program
Rule 1     program -> PROGRAM ID SEMICOLON uses_clause declaration_sections compound_stmt DOT
Rule 2     uses_clause -> USES id_list SEMICOLON
Rule 3     uses_clause -> empty
Rule 4     id_list -> ID
Rule 5     id_list -> id_list COMMA ID
Rule 6     declaration_sections -> declaration_sections section
Rule 7     declaration_sections -> empty
Rule 8     section -> const_section
Rule 9     section -> type_section
Rule 10    section -> var_section
Rule 11    section -> procedure_declaration
Rule 12    section -> function_declaration
Rule 13    const_section -> CONST const_list
Rule 14    const_list -> const_list ID EQUALS expression SEMICOLON
Rule 15    const_list -> ID EQUALS expression SEMICOLON
Rule 16    type_section -> TYPE type_list
Rule 17    type_list -> type_list ID EQUALS type_specifier SEMICOLON
Rule 18    type_list -> ID EQUALS type_specifier SEMICOLON
Rule 19    var_section -> VAR var_list
Rule 20    var_list -> var_list id_list COLON type_specifier SEMICOLON
Rule 21    var_list -> id_list COLON type_specifier SEMICOLON
Rule 22    type_specifier -> type_base
Rule 23    type_specifier -> ARRAY LBRACKET range RBRACKET OF type_base
Rule 24    type_specifier -> STRING LBRACKET NUMBER RBRACKET
Rule 25    type_base -> INTEGER
Rule 26    type_base -> REAL
Rule 27    type_base -> CHAR
Rule 28    type_base -> BOOLEAN
Rule 29    range -> NUMBER DOT DOT NUMBER
Rule 30    procedure_declaration -> PROCEDURE ID LPAREN enter_args args RPAREN SEMICOLON compound_stmt SEMICOLON
Rule 31    function_declaration -> FUNCTION ID LPAREN enter_args args RPAREN COLON type_base SEMICOLON compound_stmt SEMICOLON
Rule 32    enter_args -> <empty>
Rule 33    compound_stmt -> BEGIN statement_list END
Rule 34    compound_stmt -> var_section BEGIN statement_list END
Rule 35    statement_list -> statement_list statement
Rule 36    statement_list -> statement
Rule 37    statement_list -> empty
Rule 38    statement -> call_stmt SEMICOLON
Rule 39    statement -> assignment_stmt SEMICOLON
Rule 40    statement -> compound_stmt
Rule 41    statement -> if_stmt
Rule 42    statement -> for_stmt
Rule 43    if_stmt -> IF LPAREN expression RPAREN THEN statement
Rule 44    if_stmt -> IF LPAREN expression RPAREN THEN statement ELSE statement
Rule 45    for_stmt -> FOR ID ASSIGN expression TO expression DO loop_guard statement
Rule 46    loop_guard -> <empty>
Rule 47    assignment_stmt -> ID ASSIGN expression
Rule 48    call_stmt -> ID LPAREN expression_list RPAREN
Rule 49    call_stmt -> ID
Rule 50    args -> arg_list
Rule 51    args -> empty
Rule 52    arg_list -> arg_spec
Rule 53    arg_list -> arg_list SEMICOLON arg_spec
Rule 54    arg_spec -> ID COLON type_base
Rule 55    arg_spec -> VAR ID COLON type_base
Rule 56    expression_list -> expression_list COMMA expression
Rule 57    expression_list -> expression
Rule 58    expression -> term
Rule 59    expression -> expression PLUS term
Rule 60    expression -> expression MINUS term
Rule 61    expression -> expression GREATER term
Rule 62    expression -> expression LESS term
Rule 63    expression -> expression GREATEREQUAL term
Rule 64    expression -> expression LESSEQUAL term
Rule 65    expression -> expression NOTEQUAL term
Rule 66    term -> factor
Rule 67    term -> term TIMES factor
Rule 68    term -> term DIVIDE factor
Rule 69    factor -> NUMBER
Rule 70    factor -> STRING
Rule 71    factor -> call_stmt
Rule 72    factor -> LPAREN expression RPAREN
Rule 73    empty -> <empty>

Terminals, with rules where they appear

ABSOLUTE             : 
AND                  : 
ARRAY                : 23
ASM                  : 
ASSIGN               : 45 47
BEGIN                : 33 34
BOOLEAN              : 28
BREAK                : 
CASE                 : 
CHAR                 : 27
COLON                : 20 21 31 54 55
COMMA                : 5 56
CONST                : 13
CONSTRUCTOR          : 
CONTINUE             : 
DESTRUCTOR           : 
DIV                  : 
DIVIDE               : 68
DO                   : 45
DOT                  : 1 29 29
DOWNTO               : 
ELSE                 : 44
END                  : 33 34
EQUALS               : 14 15 17 18
EXTERNAL             : 
FILE                 : 
FOR                  : 45
FORWARD              : 
FUNCTION             : 31
GOTO                 : 
GREATER              : 61
GREATEREQUAL         : 63
ID                   : 1 4 5 14 15 17 18 30 31 45 47 48 49 54 55
IF                   : 43 44
IMPLEMENTATION       : 
IN                   : 
INHERITED            : 
INLINE               : 
INTEGER              : 25
INTERFACE            : 
INTERRUPT            : 
LABEL                : 
LBRACKET             : 23 24
LESS                 : 62
LESSEQUAL            : 64
LPAREN               : 30 31 43 44 48 72
MINUS                : 60
MOD                  : 
NIL                  : 
NOT                  : 
NOTEQUAL             : 65
NUMBER               : 24 29 29 69
OF                   : 23
ON                   : 
OPERATOR             : 
OR                   : 
PACKED               : 
PLUS                 : 59
PROCEDURE            : 30
PROGRAM              : 1
RBRACKET             : 23 24
REAL                 : 26
RECORD               : 
REPEAT               : 
RPAREN               : 30 31 43 44 48 72
SELF                 : 
SEMICOLON            : 1 2 14 15 17 18 20 21 30 30 31 31 38 39 53
SET                  : 
SHL                  : 
SHR                  : 
SINGLE_COMMENT       : 
STRING               : 24 70
THEN                 : 43 44
TIMES                : 67
TO                   : 45
TYPE                 : 16
UNIT                 : 
UNTIL                : 
USES                 : 2
VAR                  : 19 55
WHILE                : 
WITH                 : 
XOR                  : 
error                : 

Nonterminals, with rules where they appear

arg_list             : 50 53
arg_spec             : 52 53
args                 : 30 31
assignment_stmt      : 39
call_stmt            : 38 71
compound_stmt        : 1 30 31 40
const_list           : 13 14
const_section        : 8
declaration_sections : 1 6
empty                : 3 7 37 51
enter_args           : 30 31
expression           : 14 15 43 44 45 45 47 56 57 59 60 61 62 63 64 65 72
expression_list      : 48 56
factor               : 66 67 68
for_stmt             : 42
function_declaration : 12
id_list              : 2 5 20 21
if_stmt              : 41
loop_guard           : 45
procedure_declaration : 11
program              : 0
range                : 23
section              : 6
statement            : 35 36 43 44 44 45
statement_list       : 33 34 35
term                 : 58 59 60 61 62 63 64 65 67 68
type_base            : 22 23 31 54 55
type_list            : 16 17
type_section         : 9
type_specifier       : 17 18 20 21
uses_clause          : 1
var_list             : 19 20
var_section          : 10 34

Parsing method: LALR

state 0

    (0) S' -> . program
    (1) program -> . PROGRAM ID SEMICOLON uses_clause declaration_sections compound_stmt DOT

    PROGRAM         shift and go to state 2

    program                        shift and go to state 1

state 1

    (0) S' -> program .



state 2

    (1) program -> PROGRAM . ID SEMICOLON uses_clause declaration_sections compound_stmt DOT

    ID              shift and go to state 3


state 3

    (1) program -> PROGRAM ID . SEMICOLON uses_clause declaration_sections compound_stmt DOT

    SEMICOLON       shift and go to state 4


state 4

    (1) program -> PROGRAM ID SEMICOLON . uses_clause declaration_sections compound_stmt DOT
    (2) uses_clause -> . USES id_list SEMICOLON
    (3) uses_clause -> . empty
    (73) empty -> .

    USES            shift and go to state 6
    BEGIN           reduce using rule 73 (empty -> .)
    VAR             reduce using rule 73 (empty -> .)
    CONST           reduce using rule 73 (empty -> .)
    TYPE            reduce using rule 73 (empty -> .)
    PROCEDURE       reduce using rule 73 (empty -> .)
    FUNCTION        reduce using rule 73 (empty -> .)

    uses_clause                    shift and go to state 5
    empty                          shift and go to state 7

state 5

    (1) program -> PROGRAM ID SEMICOLON uses_clause . declaration_sections compound_stmt DOT
    (6) declaration_sections -> . declaration_sections section
    (7) declaration_sections -> . empty
    (73) empty -> .

    BEGIN           reduce using rule 73 (empty -> .)
    VAR             reduce using rule 73 (empty -> .)
    CONST           reduce using rule 73 (empty -> .)
    TYPE            reduce using rule 73 (empty -> .)
    PROCEDURE       reduce using rule 73 (empty -> .)
    FUNCTION        reduce using rule 73 (empty -> .)

    declaration_sections           shift and go to state 8
    empty                          shift and go to state 9

state 6

    (2) uses_clause -> USES . id_list SEMICOLON
    (4) id_list -> . ID
    (5) id_list -> . id_list COMMA ID

    ID              shift and go to state 11

    id_list                        shift and go to state 10

state 7

    (3) uses_clause -> empty .

    BEGIN           reduce using rule 3 (uses_clause -> empty .)
    VAR             reduce using rule 3 (uses_clause -> empty .)
    CONST           reduce using rule 3 (uses_clause -> empty .)
    TYPE            reduce using rule 3 (uses_clause -> empty .)
    PROCEDURE       reduce using rule 3 (uses_clause -> empty .)
    FUNCTION        reduce using rule 3 (uses_clause -> empty .)


state 8

    (1) program -> PROGRAM ID SEMICOLON uses_clause declaration_sections . compound_stmt DOT
    (6) declaration_sections -> declaration_sections . section
    (33) compound_stmt -> . BEGIN statement_list END
    (34) compound_stmt -> . var_section BEGIN statement_list END
    (8) section -> . const_section
    (9) section -> . type_section
    (10) section -> . var_section
    (11) section -> . procedure_declaration
    (12) section -> . function_declaration
    (19) var_section -> . VAR var_list
    (13) const_section -> . CONST const_list
    (16) type_section -> . TYPE type_list
    (30) procedure_declaration -> . PROCEDURE ID LPAREN enter_args args RPAREN SEMICOLON compound_stmt SEMICOLON
    (31) function_declaration -> . FUNCTION ID LPAREN enter_args args RPAREN COLON type_base SEMICOLON compound_stmt SEMICOLON

    BEGIN           shift and go to state 14
    VAR             shift and go to state 20
    CONST           shift and go to state 21
    TYPE            shift and go to state 22
    PROCEDURE       shift and go to state 23
    FUNCTION        shift and go to state 24

    compound_stmt                  shift and go to state 12
    section                        shift and go to state 13
    var_section                    shift and go to state 15
    const_section                  shift and go to state 16
    type_section                   shift and go to state 17
    procedure_declaration          shift and go to state 18
    function_declaration           shift and go to state 19

state 9

    (7) declaration_sections -> empty .

    BEGIN           reduce using rule 7 (declaration_sections -> empty .)
    VAR             reduce using rule 7 (declaration_sections -> empty .)
    CONST           reduce using rule 7 (declaration_sections -> empty .)
    TYPE            reduce using rule 7 (declaration_sections -> empty .)
    PROCEDURE       reduce using rule 7 (declaration_sections -> empty .)
    FUNCTION        reduce using rule 7 (declaration_sections -> empty .)


state 10

    (2) uses_clause -> USES id_list . SEMICOLON
    (5) id_list -> id_list . COMMA ID

    SEMICOLON       shift and go to state 25
    COMMA           shift and go to state 26


state 11

    (4) id_list -> ID .

    SEMICOLON       reduce using rule 4 (id_list -> ID .)
    COMMA           reduce using rule 4 (id_list -> ID .)
    COLON           reduce using rule 4 (id_list -> ID .)


state 12

    (1) program -> PROGRAM ID SEMICOLON uses_clause declaration_sections compound_stmt . DOT

    DOT             shift and go to state 27


state 13

    (6) declaration_sections -> declaration_sections section .

    BEGIN           reduce using rule 6 (declaration_sections -> declaration_sections section .)
    VAR             reduce using rule 6 (declaration_sections -> declaration_sections section .)
    CONST           reduce using rule 6 (declaration_sections -> declaration_sections section .)
    TYPE            reduce using rule 6 (declaration_sections -> declaration_sections section .)
    PROCEDURE       reduce using rule 6 (declaration_sections -> declaration_sections section .)
    FUNCTION        reduce using rule 6 (declaration_sections -> declaration_sections section .)


state 14

    (33) compound_stmt -> BEGIN . statement_list END
    (35) statement_list -> . statement_list statement
    (36) statement_list -> . statement
    (37) statement_list -> . empty
    (38) statement -> . call_stmt SEMICOLON
    (39) statement -> . assignment_stmt SEMICOLON
    (40) statement -> . compound_stmt
    (41) statement -> . if_stmt
    (42) statement -> . for_stmt
    (73) empty -> .
    (48) call_stmt -> . ID LPAREN expression_list RPAREN
    (49) call_stmt -> . ID
    (47) assignment_stmt -> . ID ASSIGN expression
    (33) compound_stmt -> . BEGIN statement_list END
    (34) compound_stmt -> . var_section BEGIN statement_list END
    (43) if_stmt -> . IF LPAREN expression RPAREN THEN statement
    (44) if_stmt -> . IF LPAREN expression RPAREN THEN statement ELSE statement
    (45) for_stmt -> . FOR ID ASSIGN expression TO expression DO loop_guard statement
    (19) var_section -> . VAR var_list

  ! shift/reduce conflict for ID resolved as shift
  ! shift/reduce conflict for BEGIN resolved as shift
  ! shift/reduce conflict for IF resolved as shift
  ! shift/reduce conflict for FOR resolved as shift
  ! shift/reduce conflict for VAR resolved as shift
    END             reduce using rule 73 (empty -> .)
    ID              shift and go to state 36
    BEGIN           shift and go to state 14
    IF              shift and go to state 38
    FOR             shift and go to state 39
    VAR             shift and go to state 20

  ! ID              [ reduce using rule 73 (empty -> .) ]
  ! BEGIN           [ reduce using rule 73 (empty -> .) ]
  ! IF              [ reduce using rule 73 (empty -> .) ]
  ! FOR             [ reduce using rule 73 (empty -> .) ]
  ! VAR             [ reduce using rule 73 (empty -> .) ]

    statement_list                 shift and go to state 28
    statement                      shift and go to state 29
    empty                          shift and go to state 30
    call_stmt                      shift and go to state 31
    assignment_stmt                shift and go to state 32
    compound_stmt                  shift and go to state 33
    if_stmt                        shift and go to state 34
    for_stmt                       shift and go to state 35
    var_section                    shift and go to state 37

state 15

    (34) compound_stmt -> var_section . BEGIN statement_list END
    (10) section -> var_section .

  ! shift/reduce conflict for BEGIN resolved as shift
    BEGIN           shift and go to state 40
    VAR             reduce using rule 10 (section -> var_section .)
    CONST           reduce using rule 10 (section -> var_section .)
    TYPE            reduce using rule 10 (section -> var_section .)
    PROCEDURE       reduce using rule 10 (section -> var_section .)
    FUNCTION        reduce using rule 10 (section -> var_section .)

  ! BEGIN           [ reduce using rule 10 (section -> var_section .) ]


state 16

    (8) section -> const_section .

    BEGIN           reduce using rule 8 (section -> const_section .)
    VAR             reduce using rule 8 (section -> const_section .)
    CONST           reduce using rule 8 (section -> const_section .)
    TYPE            reduce using rule 8 (section -> const_section .)
    PROCEDURE       reduce using rule 8 (section -> const_section .)
    FUNCTION        reduce using rule 8 (section -> const_section .)


state 17

    (9) section -> type_section .

    BEGIN           reduce using rule 9 (section -> type_section .)
    VAR             reduce using rule 9 (section -> type_section .)
    CONST           reduce using rule 9 (section -> type_section .)
    TYPE            reduce using rule 9 (section -> type_section .)
    PROCEDURE       reduce using rule 9 (section -> type_section .)
    FUNCTION        reduce using rule 9 (section -> type_section .)


state 18

    (11) section -> procedure_declaration .

    BEGIN           reduce using rule 11 (section -> procedure_declaration .)
    VAR             reduce using rule 11 (section -> procedure_declaration .)
    CONST           reduce using rule 11 (section -> procedure_declaration .)
    TYPE            reduce using rule 11 (section -> procedure_declaration .)
    PROCEDURE       reduce using rule 11 (section -> procedure_declaration .)
    FUNCTION        reduce using rule 11 (section -> procedure_declaration .)


state 19

    (12) section -> function_declaration .

    BEGIN           reduce using rule 12 (section -> function_declaration .)
    VAR             reduce using rule 12 (section -> function_declaration .)
    CONST           reduce using rule 12 (section -> function_declaration .)
    TYPE            reduce using rule 12 (section -> function_declaration .)
    PROCEDURE       reduce using rule 12 (section -> function_declaration .)
    FUNCTION        reduce using rule 12 (section -> function_declaration .)


state 20

    (19) var_section -> VAR . var_list
    (20) var_list -> . var_list id_list COLON type_specifier SEMICOLON
    (21) var_list -> . id_list COLON type_specifier SEMICOLON
    (4) id_list -> . ID
    (5) id_list -> . id_list COMMA ID

    ID              shift and go to state 11

    var_list                       shift and go to state 41
    id_list                        shift and go to state 42

state 21

    (13) const_section -> CONST . const_list
    (14) const_list -> . const_list ID EQUALS expression SEMICOLON
    (15) const_list -> . ID EQUALS expression SEMICOLON

    ID              shift and go to state 44

    const_list                     shift and go to state 43

state 22

    (16) type_section -> TYPE . type_list
    (17) type_list -> . type_list ID EQUALS type_specifier SEMICOLON
    (18) type_list -> . ID EQUALS type_specifier SEMICOLON

    ID              shift and go to state 46

    type_list                      shift and go to state 45

state 23

    (30) procedure_declaration -> PROCEDURE . ID LPAREN enter_args args RPAREN SEMICOLON compound_stmt SEMICOLON

    ID              shift and go to state 47


state 24

    (31) function_declaration -> FUNCTION . ID LPAREN enter_args args RPAREN COLON type_base SEMICOLON compound_stmt SEMICOLON

    ID              shift and go to state 48


state 25

    (2) uses_clause -> USES id_list SEMICOLON .

    BEGIN           reduce using rule 2 (uses_clause -> USES id_list SEMICOLON .)
    VAR             reduce using rule 2 (uses_clause -> USES id_list SEMICOLON .)
    CONST           reduce using rule 2 (uses_clause -> USES id_list SEMICOLON .)
    TYPE            reduce using rule 2 (uses_clause -> USES id_list SEMICOLON .)
    PROCEDURE       reduce using rule 2 (uses_clause -> USES id_list SEMICOLON .)
    FUNCTION        reduce using rule 2 (uses_clause -> USES id_list SEMICOLON .)


state 26

    (5) id_list -> id_list COMMA . ID

    ID              shift and go to state 49


state 27

    (1) program -> PROGRAM ID SEMICOLON uses_clause declaration_sections compound_stmt DOT .

    $end            reduce using rule 1 (program -> PROGRAM ID SEMICOLON uses_clause declaration_sections compound_stmt DOT .)


state 28

    (33) compound_stmt -> BEGIN statement_list . END
    (35) statement_list -> statement_list . statement
    (38) statement -> . call_stmt SEMICOLON
    (39) statement -> . assignment_stmt SEMICOLON
    (40) statement -> . compound_stmt
    (41) statement -> . if_stmt
    (42) statement -> . for_stmt
    (48) call_stmt -> . ID LPAREN expression_list RPAREN
    (49) call_stmt -> . ID
    (47) assignment_stmt -> . ID ASSIGN expression
    (33) compound_stmt -> . BEGIN statement_list END
    (34) compound_stmt -> . var_section BEGIN statement_list END
    (43) if_stmt -> . IF LPAREN expression RPAREN THEN statement
    (44) if_stmt -> . IF LPAREN expression RPAREN THEN statement ELSE statement
    (45) for_stmt -> . FOR ID ASSIGN expression TO expression DO loop_guard statement
    (19) var_section -> . VAR var_list

    END             shift and go to state 50
    ID              shift and go to state 36
    BEGIN           shift and go to state 14
    IF              shift and go to state 38
    FOR             shift and go to state 39
    VAR             shift and go to state 20

    statement                      shift and go to state 51
    call_stmt                      shift and go to state 31
    assignment_stmt                shift and go to state 32
    compound_stmt                  shift and go to state 33
    if_stmt                        shift and go to state 34
    for_stmt                       shift and go to state 35
    var_section                    shift and go to state 37

state 29

    (36) statement_list -> statement .

    END             reduce using rule 36 (statement_list -> statement .)
    ID              reduce using rule 36 (statement_list -> statement .)
    BEGIN           reduce using rule 36 (statement_list -> statement .)
    IF              reduce using rule 36 (statement_list -> statement .)
    FOR             reduce using rule 36 (statement_list -> statement .)
    VAR             reduce using rule 36 (statement_list -> statement .)


state 30

    (37) statement_list -> empty .

    END             reduce using rule 37 (statement_list -> empty .)
    ID              reduce using rule 37 (statement_list -> empty .)
    BEGIN           reduce using rule 37 (statement_list -> empty .)
    IF              reduce using rule 37 (statement_list -> empty .)
    FOR             reduce using rule 37 (statement_list -> empty .)
    VAR             reduce using rule 37 (statement_list -> empty .)


state 31

    (38) statement -> call_stmt . SEMICOLON

    SEMICOLON       shift and go to state 52


state 32

    (39) statement -> assignment_stmt . SEMICOLON

    SEMICOLON       shift and go to state 53


state 33

    (40) statement -> compound_stmt .

    END             reduce using rule 40 (statement -> compound_stmt .)
    ID              reduce using rule 40 (statement -> compound_stmt .)
    BEGIN           reduce using rule 40 (statement -> compound_stmt .)
    IF              reduce using rule 40 (statement -> compound_stmt .)
    FOR             reduce using rule 40 (statement -> compound_stmt .)
    VAR             reduce using rule 40 (statement -> compound_stmt .)
    ELSE            reduce using rule 40 (statement -> compound_stmt .)


state 34

    (41) statement -> if_stmt .

    END             reduce using rule 41 (statement -> if_stmt .)
    ID              reduce using rule 41 (statement -> if_stmt .)
    BEGIN           reduce using rule 41 (statement -> if_stmt .)
    IF              reduce using rule 41 (statement -> if_stmt .)
    FOR             reduce using rule 41 (statement -> if_stmt .)
    VAR             reduce using rule 41 (statement -> if_stmt .)
    ELSE            reduce using rule 41 (statement -> if_stmt .)


state 35

    (42) statement -> for_stmt .

    END             reduce using rule 42 (statement -> for_stmt .)
    ID              reduce using rule 42 (statement -> for_stmt .)
    BEGIN           reduce using rule 42 (statement -> for_stmt .)
    IF              reduce using rule 42 (statement -> for_stmt .)
    FOR             reduce using rule 42 (statement -> for_stmt .)
    VAR             reduce using rule 42 (statement -> for_stmt .)
    ELSE            reduce using rule 42 (statement -> for_stmt .)


state 36

    (48) call_stmt -> ID . LPAREN expression_list RPAREN
    (49) call_stmt -> ID .
    (47) assignment_stmt -> ID . ASSIGN expression

    LPAREN          shift and go to state 54
    SEMICOLON       reduce using rule 49 (call_stmt -> ID .)
    ASSIGN          shift and go to state 55


state 37

    (34) compound_stmt -> var_section . BEGIN statement_list END

    BEGIN           shift and go to state 40


state 38

    (43) if_stmt -> IF . LPAREN expression RPAREN THEN statement
    (44) if_stmt -> IF . LPAREN expression RPAREN THEN statement ELSE statement

    LPAREN          shift and go to state 56


state 39

    (45) for_stmt -> FOR . ID ASSIGN expression TO expression DO loop_guard statement

    ID              shift and go to state 57


state 40

    (34) compound_stmt -> var_section BEGIN . statement_list END
    (35) statement_list -> . statement_list statement
    (36) statement_list -> . statement
    (37) statement_list -> . empty
    (38) statement -> . call_stmt SEMICOLON
    (39) statement -> . assignment_stmt SEMICOLON
    (40) statement -> . compound_stmt
    (41) statement -> . if_stmt
    (42) statement -> . for_stmt
    (73) empty -> .
    (48) call_stmt -> . ID LPAREN expression_list RPAREN
    (49) call_stmt -> . ID
    (47) assignment_stmt -> . ID ASSIGN expression
    (33) compound_stmt -> . BEGIN statement_list END
    (34) compound_stmt -> . var_section BEGIN statement_list END
    (43) if_stmt -> . IF LPAREN expression RPAREN THEN statement
    (44) if_stmt -> . IF LPAREN expression RPAREN THEN statement ELSE statement
    (45) for_stmt -> . FOR ID ASSIGN expression TO expression DO loop_guard statement
    (19) var_section -> . VAR var_list

  ! shift/reduce conflict for ID resolved as shift
  ! shift/reduce conflict for BEGIN resolved as shift
  ! shift/reduce conflict for IF resolved as shift
  ! shift/reduce conflict for FOR resolved as shift
  ! shift/reduce conflict for VAR resolved as shift
    END             reduce using rule 73 (empty -> .)
    ID              shift and go to state 36
    BEGIN           shift and go to state 14
    IF              shift and go to state 38
    FOR             shift and go to state 39
    VAR             shift and go to state 20

  ! ID              [ reduce using rule 73 (empty -> .) ]
  ! BEGIN           [ reduce using rule 73 (empty -> .) ]
  ! IF              [ reduce using rule 73 (empty -> .) ]
  ! FOR             [ reduce using rule 73 (empty -> .) ]
  ! VAR             [ reduce using rule 73 (empty -> .) ]

    var_section                    shift and go to state 37
    statement_list                 shift and go to state 58
    statement                      shift and go to state 29
    empty                          shift and go to state 30
    call_stmt                      shift and go to state 31
    assignment_stmt                shift and go to state 32
    compound_stmt                  shift and go to state 33
    if_stmt                        shift and go to state 34
    for_stmt                       shift and go to state 35

state 41

    (19) var_section -> VAR var_list .
    (20) var_list -> var_list . id_list COLON type_specifier SEMICOLON
    (4) id_list -> . ID
    (5) id_list -> . id_list COMMA ID

    BEGIN           reduce using rule 19 (var_section -> VAR var_list .)
    VAR             reduce using rule 19 (var_section -> VAR var_list .)
    CONST           reduce using rule 19 (var_section -> VAR var_list .)
    TYPE            reduce using rule 19 (var_section -> VAR var_list .)
    PROCEDURE       reduce using rule 19 (var_section -> VAR var_list .)
    FUNCTION        reduce using rule 19 (var_section -> VAR var_list .)
    ID              shift and go to state 11

    id_list                        shift and go to state 59

state 42

    (21) var_list -> id_list . COLON type_specifier SEMICOLON
    (5) id_list -> id_list . COMMA ID

    COLON           shift and go to state 60
    COMMA           shift and go to state 26


state 43

    (13) const_section -> CONST const_list .
    (14) const_list -> const_list . ID EQUALS expression SEMICOLON

    BEGIN           reduce using rule 13 (const_section -> CONST const_list .)
    VAR             reduce using rule 13 (const_section -> CONST const_list .)
    CONST           reduce using rule 13 (const_section -> CONST const_list .)
    TYPE            reduce using rule 13 (const_section -> CONST const_list .)
    PROCEDURE       reduce using rule 13 (const_section -> CONST const_list .)
    FUNCTION        reduce using rule 13 (const_section -> CONST const_list .)
    ID              shift and go to state 61


state 44

    (15) const_list -> ID . EQUALS expression SEMICOLON

    EQUALS          shift and go to state 62


state 45

    (16) type_section -> TYPE type_list .
    (17) type_list -> type_list . ID EQUALS type_specifier SEMICOLON

    BEGIN           reduce using rule 16 (type_section -> TYPE type_list .)
    VAR             reduce using rule 16 (type_section -> TYPE type_list .)
    CONST           reduce using rule 16 (type_section -> TYPE type_list .)
    TYPE            reduce using rule 16 (type_section -> TYPE type_list .)
    PROCEDURE       reduce using rule 16 (type_section -> TYPE type_list .)
    FUNCTION        reduce using rule 16 (type_section -> TYPE type_list .)
    ID              shift and go to state 63


state 46

    (18) type_list -> ID . EQUALS type_specifier SEMICOLON

    EQUALS          shift and go to state 64


state 47

    (30) procedure_declaration -> PROCEDURE ID . LPAREN enter_args args RPAREN SEMICOLON compound_stmt SEMICOLON

    LPAREN          shift and go to state 65


state 48

    (31) function_declaration -> FUNCTION ID . LPAREN enter_args args RPAREN COLON type_base SEMICOLON compound_stmt SEMICOLON

    LPAREN          shift and go to state 66


state 49

    (5) id_list -> id_list COMMA ID .

    SEMICOLON       reduce using rule 5 (id_list -> id_list COMMA ID .)
    COMMA           reduce using rule 5 (id_list -> id_list COMMA ID .)
    COLON           reduce using rule 5 (id_list -> id_list COMMA ID .)


state 50

    (33) compound_stmt -> BEGIN statement_list END .

    DOT             reduce using rule 33 (compound_stmt -> BEGIN statement_list END .)
    END             reduce using rule 33 (compound_stmt -> BEGIN statement_list END .)
    ID              reduce using rule 33 (compound_stmt -> BEGIN statement_list END .)
    BEGIN           reduce using rule 33 (compound_stmt -> BEGIN statement_list END .)
    IF              reduce using rule 33 (compound_stmt -> BEGIN statement_list END .)
    FOR             reduce using rule 33 (compound_stmt -> BEGIN statement_list END .)
    VAR             reduce using rule 33 (compound_stmt -> BEGIN statement_list END .)
    ELSE            reduce using rule 33 (compound_stmt -> BEGIN statement_list END .)
    SEMICOLON       reduce using rule 33 (compound_stmt -> BEGIN statement_list END .)


state 51

    (35) statement_list -> statement_list statement .

    END             reduce using rule 35 (statement_list -> statement_list statement .)
    ID              reduce using rule 35 (statement_list -> statement_list statement .)
    BEGIN           reduce using rule 35 (statement_list -> statement_list statement .)
    IF              reduce using rule 35 (statement_list -> statement_list statement .)
    FOR             reduce using rule 35 (statement_list -> statement_list statement .)
    VAR             reduce using rule 35 (statement_list -> statement_list statement .)


state 52

    (38) statement -> call_stmt SEMICOLON .

    END             reduce using rule 38 (statement -> call_stmt SEMICOLON .)
    ID              reduce using rule 38 (statement -> call_stmt SEMICOLON .)
    BEGIN           reduce using rule 38 (statement -> call_stmt SEMICOLON .)
    IF              reduce using rule 38 (statement -> call_stmt SEMICOLON .)
    FOR             reduce using rule 38 (statement -> call_stmt SEMICOLON .)
    VAR             reduce using rule 38 (statement -> call_stmt SEMICOLON .)
    ELSE            reduce using rule 38 (statement -> call_stmt SEMICOLON .)


state 53

    (39) statement -> assignment_stmt SEMICOLON .

    END             reduce using rule 39 (statement -> assignment_stmt SEMICOLON .)
    ID              reduce using rule 39 (statement -> assignment_stmt SEMICOLON .)
    BEGIN           reduce using rule 39 (statement -> assignment_stmt SEMICOLON .)
    IF              reduce using rule 39 (statement -> assignment_stmt SEMICOLON .)
    FOR             reduce using rule 39 (statement -> assignment_stmt SEMICOLON .)
    VAR             reduce using rule 39 (statement -> assignment_stmt SEMICOLON .)
    ELSE            reduce using rule 39 (statement -> assignment_stmt SEMICOLON .)


state 54

    (48) call_stmt -> ID LPAREN . expression_list RPAREN
    (56) expression_list -> . expression_list COMMA expression
    (57) expression_list -> . expression
    (58) expression -> . term
    (59) expression -> . expression PLUS term
    (60) expression -> . expression MINUS term
    (61) expression -> . expression GREATER term
    (62) expression -> . expression LESS term
    (63) expression -> . expression GREATEREQUAL term
    (64) expression -> . expression LESSEQUAL term
    (65) expression -> . expression NOTEQUAL term
    (66) term -> . factor
    (67) term -> . term TIMES factor
    (68) term -> . term DIVIDE factor
    (69) factor -> . NUMBER
    (70) factor -> . STRING
    (71) factor -> . call_stmt
    (72) factor -> . LPAREN expression RPAREN
    (48) call_stmt -> . ID LPAREN expression_list RPAREN
    (49) call_stmt -> . ID

    NUMBER          shift and go to state 73
    STRING          shift and go to state 74
    LPAREN          shift and go to state 68
    ID              shift and go to state 67

    expression_list                shift and go to state 69
    expression                     shift and go to state 70
    term                           shift and go to state 71
    factor                         shift and go to state 72
    call_stmt                      shift and go to state 75

state 55

    (47) assignment_stmt -> ID ASSIGN . expression
    (58) expression -> . term
    (59) expression -> . expression PLUS term
    (60) expression -> . expression MINUS term
    (61) expression -> . expression GREATER term
    (62) expression -> . expression LESS term
    (63) expression -> . expression GREATEREQUAL term
    (64) expression -> . expression LESSEQUAL term
    (65) expression -> . expression NOTEQUAL term
    (66) term -> . factor
    (67) term -> . term TIMES factor
    (68) term -> . term DIVIDE factor
    (69) factor -> . NUMBER
    (70) factor -> . STRING
    (71) factor -> . call_stmt
    (72) factor -> . LPAREN expression RPAREN
    (48) call_stmt -> . ID LPAREN expression_list RPAREN
    (49) call_stmt -> . ID

    NUMBER          shift and go to state 73
    STRING          shift and go to state 74
    LPAREN          shift and go to state 68
    ID              shift and go to state 67

    expression                     shift and go to state 76
    term                           shift and go to state 71
    factor                         shift and go to state 72
    call_stmt                      shift and go to state 75

state 56

    (43) if_stmt -> IF LPAREN . expression RPAREN THEN statement
    (44) if_stmt -> IF LPAREN . expression RPAREN THEN statement ELSE statement
    (58) expression -> . term
    (59) expression -> . expression PLUS term
    (60) expression -> . expression MINUS term
    (61) expression -> . expression GREATER term
    (62) expression -> . expression LESS term
    (63) expression -> . expression GREATEREQUAL term
    (64) expression -> . expression LESSEQUAL term
    (65) expression -> . expression NOTEQUAL term
    (66) term -> . factor
    (67) term -> . term TIMES factor
    (68) term -> . term DIVIDE factor
    (69) factor -> . NUMBER
    (70) factor -> . STRING
    (71) factor -> . call_stmt
    (72) factor -> . LPAREN expression RPAREN
    (48) call_stmt -> . ID LPAREN expression_list RPAREN
    (49) call_stmt -> . ID

    NUMBER          shift and go to state 73
    STRING          shift and go to state 74
    LPAREN          shift and go to state 68
    ID              shift and go to state 67

    expression                     shift and go to state 77
    term                           shift and go to state 71
    factor                         shift and go to state 72
    call_stmt                      shift and go to state 75

state 57

    (45) for_stmt -> FOR ID . ASSIGN expression TO expression DO loop_guard statement

    ASSIGN          shift and go to state 78


state 58

    (34) compound_stmt -> var_section BEGIN statement_list . END
    (35) statement_list -> statement_list . statement
    (38) statement -> . call_stmt SEMICOLON
    (39) statement -> . assignment_stmt SEMICOLON
    (40) statement -> . compound_stmt
    (41) statement -> . if_stmt
    (42) statement -> . for_stmt
    (48) call_stmt -> . ID LPAREN expression_list RPAREN
    (49) call_stmt -> . ID
    (47) assignment_stmt -> . ID ASSIGN expression
    (33) compound_stmt -> . BEGIN statement_list END
    (34) compound_stmt -> . var_section BEGIN statement_list END
    (43) if_stmt -> . IF LPAREN expression RPAREN THEN statement
    (44) if_stmt -> . IF LPAREN expression RPAREN THEN statement ELSE statement
    (45) for_stmt -> . FOR ID ASSIGN expression TO expression DO loop_guard statement
    (19) var_section -> . VAR var_list

    END             shift and go to state 79
    ID              shift and go to state 36
    BEGIN           shift and go to state 14
    IF              shift and go to state 38
    FOR             shift and go to state 39
    VAR             shift and go to state 20

    var_section                    shift and go to state 37
    statement                      shift and go to state 51
    call_stmt                      shift and go to state 31
    assignment_stmt                shift and go to state 32
    compound_stmt                  shift and go to state 33
    if_stmt                        shift and go to state 34
    for_stmt                       shift and go to state 35

state 59

    (20) var_list -> var_list id_list . COLON type_specifier SEMICOLON
    (5) id_list -> id_list . COMMA ID

    COLON           shift and go to state 80
    COMMA           shift and go to state 26


state 60

    (21) var_list -> id_list COLON . type_specifier SEMICOLON
    (22) type_specifier -> . type_base
    (23) type_specifier -> . ARRAY LBRACKET range RBRACKET OF type_base
    (24) type_specifier -> . STRING LBRACKET NUMBER RBRACKET
    (25) type_base -> . INTEGER
    (26) type_base -> . REAL
    (27) type_base -> . CHAR
    (28) type_base -> . BOOLEAN

    ARRAY           shift and go to state 83
    STRING          shift and go to state 84
    INTEGER         shift and go to state 85
    REAL            shift and go to state 86
    CHAR            shift and go to state 87
    BOOLEAN         shift and go to state 88

    type_specifier                 shift and go to state 81
    type_base                      shift and go to state 82

state 61

    (14) const_list -> const_list ID . EQUALS expression SEMICOLON

    EQUALS          shift and go to state 89


state 62

    (15) const_list -> ID EQUALS . expression SEMICOLON
    (58) expression -> . term
    (59) expression -> . expression PLUS term
    (60) expression -> . expression MINUS term
    (61) expression -> . expression GREATER term
    (62) expression -> . expression LESS term
    (63) expression -> . expression GREATEREQUAL term
    (64) expression -> . expression LESSEQUAL term
    (65) expression -> . expression NOTEQUAL term
    (66) term -> . factor
    (67) term -> . term TIMES factor
    (68) term -> . term DIVIDE factor
    (69) factor -> . NUMBER
    (70) factor -> . STRING
    (71) factor -> . call_stmt
    (72) factor -> . LPAREN expression RPAREN
    (48) call_stmt -> . ID LPAREN expression_list RPAREN
    (49) call_stmt -> . ID

    NUMBER          shift and go to state 73
    STRING          shift and go to state 74
    LPAREN          shift and go to state 68
    ID              shift and go to state 67

    expression                     shift and go to state 90
    term                           shift and go to state 71
    factor                         shift and go to state 72
    call_stmt                      shift and go to state 75

state 63

    (17) type_list -> type_list ID . EQUALS type_specifier SEMICOLON

    EQUALS          shift and go to state 91


state 64

    (18) type_list -> ID EQUALS . type_specifier SEMICOLON
    (22) type_specifier -> . type_base
    (23) type_specifier -> . ARRAY LBRACKET range RBRACKET OF type_base
    (24) type_specifier -> . STRING LBRACKET NUMBER RBRACKET
    (25) type_base -> . INTEGER
    (26) type_base -> . REAL
    (27) type_base -> . CHAR
    (28) type_base -> . BOOLEAN

    ARRAY           shift and go to state 83
    STRING          shift and go to state 84
    INTEGER         shift and go to state 85
    REAL            shift and go to state 86
    CHAR            shift and go to state 87
    BOOLEAN         shift and go to state 88

    type_specifier                 shift and go to state 92
    type_base                      shift and go to state 82

state 65

    (30) procedure_declaration -> PROCEDURE ID LPAREN . enter_args args RPAREN SEMICOLON compound_stmt SEMICOLON
    (32) enter_args -> .

    ID              reduce using rule 32 (enter_args -> .)
    VAR             reduce using rule 32 (enter_args -> .)
    RPAREN          reduce using rule 32 (enter_args -> .)

    enter_args                     shift and go to state 93

state 66

    (31) function_declaration -> FUNCTION ID LPAREN . enter_args args RPAREN COLON type_base SEMICOLON compound_stmt SEMICOLON
    (32) enter_args -> .

    ID              reduce using rule 32 (enter_args -> .)
    VAR             reduce using rule 32 (enter_args -> .)
    RPAREN          reduce using rule 32 (enter_args -> .)

    enter_args                     shift and go to state 94

state 67

    (48) call_stmt -> ID . LPAREN expression_list RPAREN
    (49) call_stmt -> ID .

    LPAREN          shift and go to state 54
    TIMES           reduce using rule 49 (call_stmt -> ID .)
    DIVIDE          reduce using rule 49 (call_stmt -> ID .)
    PLUS            reduce using rule 49 (call_stmt -> ID .)
    MINUS           reduce using rule 49 (call_stmt -> ID .)
    GREATER         reduce using rule 49 (call_stmt -> ID .)
    LESS            reduce using rule 49 (call_stmt -> ID .)
    GREATEREQUAL    reduce using rule 49 (call_stmt -> ID .)
    LESSEQUAL       reduce using rule 49 (call_stmt -> ID .)
    NOTEQUAL        reduce using rule 49 (call_stmt -> ID .)
    RPAREN          reduce using rule 49 (call_stmt -> ID .)
    COMMA           reduce using rule 49 (call_stmt -> ID .)
    SEMICOLON       reduce using rule 49 (call_stmt -> ID .)
    TO              reduce using rule 49 (call_stmt -> ID .)
    DO              reduce using rule 49 (call_stmt -> ID .)


state 68

    (72) factor -> LPAREN . expression RPAREN
    (58) expression -> . term
    (59) expression -> . expression PLUS term
    (60) expression -> . expression MINUS term
    (61) expression -> . expression GREATER term
    (62) expression -> . expression LESS term
    (63) expression -> . expression GREATEREQUAL term
    (64) expression -> . expression LESSEQUAL term
    (65) expression -> . expression NOTEQUAL term
    (66) term -> . factor
    (67) term -> . term TIMES factor
    (68) term -> . term DIVIDE factor
    (69) factor -> . NUMBER
    (70) factor -> . STRING
    (71) factor -> . call_stmt
    (72) factor -> . LPAREN expression RPAREN
    (48) call_stmt -> . ID LPAREN expression_list RPAREN
    (49) call_stmt -> . ID

    NUMBER          shift and go to state 73
    STRING          shift and go to state 74
    LPAREN          shift and go to state 68
    ID              shift and go to state 67

    expression                     shift and go to state 95
    term                           shift and go to state 71
    factor                         shift and go to state 72
    call_stmt                      shift and go to state 75

state 69

    (48) call_stmt -> ID LPAREN expression_list . RPAREN
    (56) expression_list -> expression_list . COMMA expression

    RPAREN          shift and go to state 96
    COMMA           shift and go to state 97


state 70

    (57) expression_list -> expression .
    (59) expression -> expression . PLUS term
    (60) expression -> expression . MINUS term
    (61) expression -> expression . GREATER term
    (62) expression -> expression . LESS term
    (63) expression -> expression . GREATEREQUAL term
    (64) expression -> expression . LESSEQUAL term
    (65) expression -> expression . NOTEQUAL term

    RPAREN          reduce using rule 57 (expression_list -> expression .)
    COMMA           reduce using rule 57 (expression_list -> expression .)
    PLUS            shift and go to state 98
    MINUS           shift and go to state 99
    GREATER         shift and go to state 100
    LESS            shift and go to state 101
    GREATEREQUAL    shift and go to state 102
    LESSEQUAL       shift and go to state 103
    NOTEQUAL        shift and go to state 104


state 71

    (58) expression -> term .
    (67) term -> term . TIMES factor
    (68) term -> term . DIVIDE factor

    PLUS            reduce using rule 58 (expression -> term .)
    MINUS           reduce using rule 58 (expression -> term .)
    GREATER         reduce using rule 58 (expression -> term .)
    LESS            reduce using rule 58 (expression -> term .)
    GREATEREQUAL    reduce using rule 58 (expression -> term .)
    LESSEQUAL       reduce using rule 58 (expression -> term .)
    NOTEQUAL        reduce using rule 58 (expression -> term .)
    RPAREN          reduce using rule 58 (expression -> term .)
    COMMA           reduce using rule 58 (expression -> term .)
    SEMICOLON       reduce using rule 58 (expression -> term .)
    TO              reduce using rule 58 (expression -> term .)
    DO              reduce using rule 58 (expression -> term .)
    TIMES           shift and go to state 105
    DIVIDE          shift and go to state 106


state 72

    (66) term -> factor .

    TIMES           reduce using rule 66 (term -> factor .)
    DIVIDE          reduce using rule 66 (term -> factor .)
    PLUS            reduce using rule 66 (term -> factor .)
    MINUS           reduce using rule 66 (term -> factor .)
    GREATER         reduce using rule 66 (term -> factor .)
    LESS            reduce using rule 66 (term -> factor .)
    GREATEREQUAL    reduce using rule 66 (term -> factor .)
    LESSEQUAL       reduce using rule 66 (term -> factor .)
    NOTEQUAL        reduce using rule 66 (term -> factor .)
    RPAREN          reduce using rule 66 (term -> factor .)
    COMMA           reduce using rule 66 (term -> factor .)
    SEMICOLON       reduce using rule 66 (term -> factor .)
    TO              reduce using rule 66 (term -> factor .)
    DO              reduce using rule 66 (term -> factor .)


state 73

    (69) factor -> NUMBER .

    TIMES           reduce using rule 69 (factor -> NUMBER .)
    DIVIDE          reduce using rule 69 (factor -> NUMBER .)
    PLUS            reduce using rule 69 (factor -> NUMBER .)
    MINUS           reduce using rule 69 (factor -> NUMBER .)
    GREATER         reduce using rule 69 (factor -> NUMBER .)
    LESS            reduce using rule 69 (factor -> NUMBER .)
    GREATEREQUAL    reduce using rule 69 (factor -> NUMBER .)
    LESSEQUAL       reduce using rule 69 (factor -> NUMBER .)
    NOTEQUAL        reduce using rule 69 (factor -> NUMBER .)
    RPAREN          reduce using rule 69 (factor -> NUMBER .)
    COMMA           reduce using rule 69 (factor -> NUMBER .)
    SEMICOLON       reduce using rule 69 (factor -> NUMBER .)
    TO              reduce using rule 69 (factor -> NUMBER .)
    DO              reduce using rule 69 (factor -> NUMBER .)


state 74

    (70) factor -> STRING .

    TIMES           reduce using rule 70 (factor -> STRING .)
    DIVIDE          reduce using rule 70 (factor -> STRING .)
    PLUS            reduce using rule 70 (factor -> STRING .)
    MINUS           reduce using rule 70 (factor -> STRING .)
    GREATER         reduce using rule 70 (factor -> STRING .)
    LESS            reduce using rule 70 (factor -> STRING .)
    GREATEREQUAL    reduce using rule 70 (factor -> STRING .)
    LESSEQUAL       reduce using rule 70 (factor -> STRING .)
    NOTEQUAL        reduce using rule 70 (factor -> STRING .)
    RPAREN          reduce using rule 70 (factor -> STRING .)
    COMMA           reduce using rule 70 (factor -> STRING .)
    SEMICOLON       reduce using rule 70 (factor -> STRING .)
    TO              reduce using rule 70 (factor -> STRING .)
    DO              reduce using rule 70 (factor -> STRING .)


state 75

    (71) factor -> call_stmt .

    TIMES           reduce using rule 71 (factor -> call_stmt .)
    DIVIDE          reduce using rule 71 (factor -> call_stmt .)
    PLUS            reduce using rule 71 (factor -> call_stmt .)
    MINUS           reduce using rule 71 (factor -> call_stmt .)
    GREATER         reduce using rule 71 (factor -> call_stmt .)
    LESS            reduce using rule 71 (factor -> call_stmt .)
    GREATEREQUAL    reduce using rule 71 (factor -> call_stmt .)
    LESSEQUAL       reduce using rule 71 (factor -> call_stmt .)
    NOTEQUAL        reduce using rule 71 (factor -> call_stmt .)
    RPAREN          reduce using rule 71 (factor -> call_stmt .)
    COMMA           reduce using rule 71 (factor -> call_stmt .)
    SEMICOLON       reduce using rule 71 (factor -> call_stmt .)
    TO              reduce using rule 71 (factor -> call_stmt .)
    DO              reduce using rule 71 (factor -> call_stmt .)


state 76

    (47) assignment_stmt -> ID ASSIGN expression .
    (59) expression -> expression . PLUS term
    (60) expression -> expression . MINUS term
    (61) expression -> expression . GREATER term
    (62) expression -> expression . LESS term
    (63) expression -> expression . GREATEREQUAL term
    (64) expression -> expression . LESSEQUAL term
    (65) expression -> expression . NOTEQUAL term

    SEMICOLON       reduce using rule 47 (assignment_stmt -> ID ASSIGN expression .)
    PLUS            shift and go to state 98
    MINUS           shift and go to state 99
    GREATER         shift and go to state 100
    LESS            shift and go to state 101
    GREATEREQUAL    shift and go to state 102
    LESSEQUAL       shift and go to state 103
    NOTEQUAL        shift and go to state 104


state 77

    (43) if_stmt -> IF LPAREN expression . RPAREN THEN statement
    (44) if_stmt -> IF LPAREN expression . RPAREN THEN statement ELSE statement
    (59) expression -> expression . PLUS term
    (60) expression -> expression . MINUS term
    (61) expression -> expression . GREATER term
    (62) expression -> expression . LESS term
    (63) expression -> expression . GREATEREQUAL term
    (64) expression -> expression . LESSEQUAL term
    (65) expression -> expression . NOTEQUAL term

    RPAREN          shift and go to state 107
    PLUS            shift and go to state 98
    MINUS           shift and go to state 99
    GREATER         shift and go to state 100
    LESS            shift and go to state 101
    GREATEREQUAL    shift and go to state 102
    LESSEQUAL       shift and go to state 103
    NOTEQUAL        shift and go to state 104


state 78

    (45) for_stmt -> FOR ID ASSIGN . expression TO expression DO loop_guard statement
    (58) expression -> . term
    (59) expression -> . expression PLUS term
    (60) expression -> . expression MINUS term
    (61) expression -> . expression GREATER term
    (62) expression -> . expression LESS term
    (63) expression -> . expression GREATEREQUAL term
    (64) expression -> . expression LESSEQUAL term
    (65) expression -> . expression NOTEQUAL term
    (66) term -> . factor
    (67) term -> . term TIMES factor
    (68) term -> . term DIVIDE factor
    (69) factor -> . NUMBER
    (70) factor -> . STRING
    (71) factor -> . call_stmt
    (72) factor -> . LPAREN expression RPAREN
    (48) call_stmt -> . ID LPAREN expression_list RPAREN
    (49) call_stmt -> . ID

    NUMBER          shift and go to state 73
    STRING          shift and go to state 74
    LPAREN          shift and go to state 68
    ID              shift and go to state 67

    expression                     shift and go to state 108
    term                           shift and go to state 71
    factor                         shift and go to state 72
    call_stmt                      shift and go to state 75

state 79

    (34) compound_stmt -> var_section BEGIN statement_list END .

    DOT             reduce using rule 34 (compound_stmt -> var_section BEGIN statement_list END .)
    END             reduce using rule 34 (compound_stmt -> var_section BEGIN statement_list END .)
    ID              reduce using rule 34 (compound_stmt -> var_section BEGIN statement_list END .)
    BEGIN           reduce using rule 34 (compound_stmt -> var_section BEGIN statement_list END .)
    IF              reduce using rule 34 (compound_stmt -> var_section BEGIN statement_list END .)
    FOR             reduce using rule 34 (compound_stmt -> var_section BEGIN statement_list END .)
    VAR             reduce using rule 34 (compound_stmt -> var_section BEGIN statement_list END .)
    ELSE            reduce using rule 34 (compound_stmt -> var_section BEGIN statement_list END .)
    SEMICOLON       reduce using rule 34 (compound_stmt -> var_section BEGIN statement_list END .)


state 80

    (20) var_list -> var_list id_list COLON . type_specifier SEMICOLON
    (22) type_specifier -> . type_base
    (23) type_specifier -> . ARRAY LBRACKET range RBRACKET OF type_base
    (24) type_specifier -> . STRING LBRACKET NUMBER RBRACKET
    (25) type_base -> . INTEGER
    (26) type_base -> . REAL
    (27) type_base -> . CHAR
    (28) type_base -> . BOOLEAN

    ARRAY           shift and go to state 83
    STRING          shift and go to state 84
    INTEGER         shift and go to state 85
    REAL            shift and go to state 86
    CHAR            shift and go to state 87
    BOOLEAN         shift and go to state 88

    type_specifier                 shift and go to state 109
    type_base                      shift and go to state 82

state 81

    (21) var_list -> id_list COLON type_specifier . SEMICOLON

    SEMICOLON       shift and go to state 110


state 82

    (22) type_specifier -> type_base .

    SEMICOLON       reduce using rule 22 (type_specifier -> type_base .)


state 83

    (23) type_specifier -> ARRAY . LBRACKET range RBRACKET OF type_base

    LBRACKET        shift and go to state 111


state 84

    (24) type_specifier -> STRING . LBRACKET NUMBER RBRACKET

    LBRACKET        shift and go to state 112


state 85

    (25) type_base -> INTEGER .

    SEMICOLON       reduce using rule 25 (type_base -> INTEGER .)
    RPAREN          reduce using rule 25 (type_base -> INTEGER .)


state 86

    (26) type_base -> REAL .

    SEMICOLON       reduce using rule 26 (type_base -> REAL .)
    RPAREN          reduce using rule 26 (type_base -> REAL .)


state 87

    (27) type_base -> CHAR .

    SEMICOLON       reduce using rule 27 (type_base -> CHAR .)
    RPAREN          reduce using rule 27 (type_base -> CHAR .)


state 88

    (28) type_base -> BOOLEAN .

    SEMICOLON       reduce using rule 28 (type_base -> BOOLEAN .)
    RPAREN          reduce using rule 28 (type_base -> BOOLEAN .)


state 89

    (14) const_list -> const_list ID EQUALS . expression SEMICOLON
    (58) expression -> . term
    (59) expression -> . expression PLUS term
    (60) expression -> . expression MINUS term
    (61) expression -> . expression GREATER term
    (62) expression -> . expression LESS term
    (63) expression -> . expression GREATEREQUAL term
    (64) expression -> . expression LESSEQUAL term
    (65) expression -> . expression NOTEQUAL term
    (66) term -> . factor
    (67) term -> . term TIMES factor
    (68) term -> . term DIVIDE factor
    (69) factor -> . NUMBER
    (70) factor -> . STRING
    (71) factor -> . call_stmt
    (72) factor -> . LPAREN expression RPAREN
    (48) call_stmt -> . ID LPAREN expression_list RPAREN
    (49) call_stmt -> . ID

    NUMBER          shift and go to state 73
    STRING          shift and go to state 74
    LPAREN          shift and go to state 68
    ID              shift and go to state 67

    expression                     shift and go to state 113
    term                           shift and go to state 71
    factor                         shift and go to state 72
    call_stmt                      shift and go to state 75

state 90

    (15) const_list -> ID EQUALS expression . SEMICOLON
    (59) expression -> expression . PLUS term
    (60) expression -> expression . MINUS term
    (61) expression -> expression . GREATER term
    (62) expression -> expression . LESS term
    (63) expression -> expression . GREATEREQUAL term
    (64) expression -> expression . LESSEQUAL term
    (65) expression -> expression . NOTEQUAL term

    SEMICOLON       shift and go to state 114
    PLUS            shift and go to state 98
    MINUS           shift and go to state 99
    GREATER         shift and go to state 100
    LESS            shift and go to state 101
    GREATEREQUAL    shift and go to state 102
    LESSEQUAL       shift and go to state 103
    NOTEQUAL        shift and go to state 104


state 91

    (17) type_list -> type_list ID EQUALS . type_specifier SEMICOLON
    (22) type_specifier -> . type_base
    (23) type_specifier -> . ARRAY LBRACKET range RBRACKET OF type_base
    (24) type_specifier -> . STRING LBRACKET NUMBER RBRACKET
    (25) type_base -> . INTEGER
    (26) type_base -> . REAL
    (27) type_base -> . CHAR
    (28) type_base -> . BOOLEAN

    ARRAY           shift and go to state 83
    STRING          shift and go to state 84
    INTEGER         shift and go to state 85
    REAL            shift and go to state 86
    CHAR            shift and go to state 87
    BOOLEAN         shift and go to state 88

    type_specifier                 shift and go to state 115
    type_base                      shift and go to state 82

state 92

    (18) type_list -> ID EQUALS type_specifier . SEMICOLON

    SEMICOLON       shift and go to state 116


state 93

    (30) procedure_declaration -> PROCEDURE ID LPAREN enter_args . args RPAREN SEMICOLON compound_stmt SEMICOLON
    (50) args -> . arg_list
    (51) args -> . empty
    (52) arg_list -> . arg_spec
    (53) arg_list -> . arg_list SEMICOLON arg_spec
    (73) empty -> .
    (54) arg_spec -> . ID COLON type_base
    (55) arg_spec -> . VAR ID COLON type_base

    RPAREN          reduce using rule 73 (empty -> .)
    ID              shift and go to state 117
    VAR             shift and go to state 122

    args                           shift and go to state 118
    arg_list                       shift and go to state 119
    empty                          shift and go to state 120
    arg_spec                       shift and go to state 121

state 94

    (31) function_declaration -> FUNCTION ID LPAREN enter_args . args RPAREN COLON type_base SEMICOLON compound_stmt SEMICOLON
    (50) args -> . arg_list
    (51) args -> . empty
    (52) arg_list -> . arg_spec
    (53) arg_list -> . arg_list SEMICOLON arg_spec
    (73) empty -> .
    (54) arg_spec -> . ID COLON type_base
    (55) arg_spec -> . VAR ID COLON type_base

    RPAREN          reduce using rule 73 (empty -> .)
    ID              shift and go to state 117
    VAR             shift and go to state 122

    args                           shift and go to state 123
    arg_list                       shift and go to state 119
    empty                          shift and go to state 120
    arg_spec                       shift and go to state 121

state 95

    (72) factor -> LPAREN expression . RPAREN
    (59) expression -> expression . PLUS term
    (60) expression -> expression . MINUS term
    (61) expression -> expression . GREATER term
    (62) expression -> expression . LESS term
    (63) expression -> expression . GREATEREQUAL term
    (64) expression -> expression . LESSEQUAL term
    (65) expression -> expression . NOTEQUAL term

    RPAREN          shift and go to state 124
    PLUS            shift and go to state 98
    MINUS           shift and go to state 99
    GREATER         shift and go to state 100
    LESS            shift and go to state 101
    GREATEREQUAL    shift and go to state 102
    LESSEQUAL       shift and go to state 103
    NOTEQUAL        shift and go to state 104


state 96

    (48) call_stmt -> ID LPAREN expression_list RPAREN .

    SEMICOLON       reduce using rule 48 (call_stmt -> ID LPAREN expression_list RPAREN .)
    TIMES           reduce using rule 48 (call_stmt -> ID LPAREN expression_list RPAREN .)
    DIVIDE          reduce using rule 48 (call_stmt -> ID LPAREN expression_list RPAREN .)
    PLUS            reduce using rule 48 (call_stmt -> ID LPAREN expression_list RPAREN .)
    MINUS           reduce using rule 48 (call_stmt -> ID LPAREN expression_list RPAREN .)
    GREATER         reduce using rule 48 (call_stmt -> ID LPAREN expression_list RPAREN .)
    LESS            reduce using rule 48 (call_stmt -> ID LPAREN expression_list RPAREN .)
    GREATEREQUAL    reduce using rule 48 (call_stmt -> ID LPAREN expression_list RPAREN .)
    LESSEQUAL       reduce using rule 48 (call_stmt -> ID LPAREN expression_list RPAREN .)
    NOTEQUAL        reduce using rule 48 (call_stmt -> ID LPAREN expression_list RPAREN .)
    RPAREN          reduce using rule 48 (call_stmt -> ID LPAREN expression_list RPAREN .)
    COMMA           reduce using rule 48 (call_stmt -> ID LPAREN expression_list RPAREN .)
    TO              reduce using rule 48 (call_stmt -> ID LPAREN expression_list RPAREN .)
    DO              reduce using rule 48 (call_stmt -> ID LPAREN expression_list RPAREN .)


state 97

    (56) expression_list -> expression_list COMMA . expression
    (58) expression -> . term
    (59) expression -> . expression PLUS term
    (60) expression -> . expression MINUS term
    (61) expression -> . expression GREATER term
    (62) expression -> . expression LESS term
    (63) expression -> . expression GREATEREQUAL term
    (64) expression -> . expression LESSEQUAL term
    (65) expression -> . expression NOTEQUAL term
    (66) term -> . factor
    (67) term -> . term TIMES factor
    (68) term -> . term DIVIDE factor
    (69) factor -> . NUMBER
    (70) factor -> . STRING
    (71) factor -> . call_stmt
    (72) factor -> . LPAREN expression RPAREN
    (48) call_stmt -> . ID LPAREN expression_list RPAREN
    (49) call_stmt -> . ID

    NUMBER          shift and go to state 73
    STRING          shift and go to state 74
    LPAREN          shift and go to state 68
    ID              shift and go to state 67

    expression                     shift and go to state 125
    term                           shift and go to state 71
    factor                         shift and go to state 72
    call_stmt                      shift and go to state 75

state 98

    (59) expression -> expression PLUS . term
    (66) term -> . factor
    (67) term -> . term TIMES factor
    (68) term -> . term DIVIDE factor
    (69) factor -> . NUMBER
    (70) factor -> . STRING
    (71) factor -> . call_stmt
    (72) factor -> . LPAREN expression RPAREN
    (48) call_stmt -> . ID LPAREN expression_list RPAREN
    (49) call_stmt -> . ID

    NUMBER          shift and go to state 73
    STRING          shift and go to state 74
    LPAREN          shift and go to state 68
    ID              shift and go to state 67

    term                           shift and go to state 126
    factor                         shift and go to state 72
    call_stmt                      shift and go to state 75

state 99

    (60) expression -> expression MINUS . term
    (66) term -> . factor
    (67) term -> . term TIMES factor
    (68) term -> . term DIVIDE factor
    (69) factor -> . NUMBER
    (70) factor -> . STRING
    (71) factor -> . call_stmt
    (72) factor -> . LPAREN expression RPAREN
    (48) call_stmt -> . ID LPAREN expression_list RPAREN
    (49) call_stmt -> . ID

    NUMBER          shift and go to state 73
    STRING          shift and go to state 74
    LPAREN          shift and go to state 68
    ID              shift and go to state 67

    term                           shift and go to state 127
    factor                         shift and go to state 72
    call_stmt                      shift and go to state 75

state 100

    (61) expression -> expression GREATER . term
    (66) term -> . factor
    (67) term -> . term TIMES factor
    (68) term -> . term DIVIDE factor
    (69) factor -> . NUMBER
    (70) factor -> . STRING
    (71) factor -> . call_stmt
    (72) factor -> . LPAREN expression RPAREN
    (48) call_stmt -> . ID LPAREN expression_list RPAREN
    (49) call_stmt -> . ID

    NUMBER          shift and go to state 73
    STRING          shift and go to state 74
    LPAREN          shift and go to state 68
    ID              shift and go to state 67

    term                           shift and go to state 128
    factor                         shift and go to state 72
    call_stmt                      shift and go to state 75

state 101

    (62) expression -> expression LESS . term
    (66) term -> . factor
    (67) term -> . term TIMES factor
    (68) term -> . term DIVIDE factor
    (69) factor -> . NUMBER
    (70) factor -> . STRING
    (71) factor -> . call_stmt
    (72) factor -> . LPAREN expression RPAREN
    (48) call_stmt -> . ID LPAREN expression_list RPAREN
    (49) call_stmt -> . ID

    NUMBER          shift and go to state 73
    STRING          shift and go to state 74
    LPAREN          shift and go to state 68
    ID              shift and go to state 67

    term                           shift and go to state 129
    factor                         shift and go to state 72
    call_stmt                      shift and go to state 75

state 102

    (63) expression -> expression GREATEREQUAL . term
    (66) term -> . factor
    (67) term -> . term TIMES factor
    (68) term -> . term DIVIDE factor
    (69) factor -> . NUMBER
    (70) factor -> . STRING
    (71) factor -> . call_stmt
    (72) factor -> . LPAREN expression RPAREN
    (48) call_stmt -> . ID LPAREN expression_list RPAREN
    (49) call_stmt -> . ID

    NUMBER          shift and go to state 73
    STRING          shift and go to state 74
    LPAREN          shift and go to state 68
    ID              shift and go to state 67

    term                           shift and go to state 130
    factor                         shift and go to state 72
    call_stmt                      shift and go to state 75

state 103

    (64) expression -> expression LESSEQUAL . term
    (66) term -> . factor
    (67) term -> . term TIMES factor
    (68) term -> . term DIVIDE factor
    (69) factor -> . NUMBER
    (70) factor -> . STRING
    (71) factor -> . call_stmt
    (72) factor -> . LPAREN expression RPAREN
    (48) call_stmt -> . ID LPAREN expression_list RPAREN
    (49) call_stmt -> . ID

    NUMBER          shift and go to state 73
    STRING          shift and go to state 74
    LPAREN          shift and go to state 68
    ID              shift and go to state 67

    term                           shift and go to state 131
    factor                         shift and go to state 72
    call_stmt                      shift and go to state 75

state 104

    (65) expression -> expression NOTEQUAL . term
    (66) term -> . factor
    (67) term -> . term TIMES factor
    (68) term -> . term DIVIDE factor
    (69) factor -> . NUMBER
    (70) factor -> . STRING
    (71) factor -> . call_stmt
    (72) factor -> . LPAREN expression RPAREN
    (48) call_stmt -> . ID LPAREN expression_list RPAREN
    (49) call_stmt -> . ID

    NUMBER          shift and go to state 73
    STRING          shift and go to state 74
    LPAREN          shift and go to state 68
    ID              shift and go to state 67

    term                           shift and go to state 132
    factor                         shift and go to state 72
    call_stmt                      shift and go to state 75

state 105

    (67) term -> term TIMES . factor
    (69) factor -> . NUMBER
    (70) factor -> . STRING
    (71) factor -> . call_stmt
    (72) factor -> . LPAREN expression RPAREN
    (48) call_stmt -> . ID LPAREN expression_list RPAREN
    (49) call_stmt -> . ID

    NUMBER          shift and go to state 73
    STRING          shift and go to state 74
    LPAREN          shift and go to state 68
    ID              shift and go to state 67

    factor                         shift and go to state 133
    call_stmt                      shift and go to state 75

state 106

    (68) term -> term DIVIDE . factor
    (69) factor -> . NUMBER
    (70) factor -> . STRING
    (71) factor -> . call_stmt
    (72) factor -> . LPAREN expression RPAREN
    (48) call_stmt -> . ID LPAREN expression_list RPAREN
    (49) call_stmt -> . ID

    NUMBER          shift and go to state 73
    STRING          shift and go to state 74
    LPAREN          shift and go to state 68
    ID              shift and go to state 67

    factor                         shift and go to state 134
    call_stmt                      shift and go to state 75

state 107

    (43) if_stmt -> IF LPAREN expression RPAREN . THEN statement
    (44) if_stmt -> IF LPAREN expression RPAREN . THEN statement ELSE statement

    THEN            shift and go to state 135


state 108

    (45) for_stmt -> FOR ID ASSIGN expression . TO expression DO loop_guard statement
    (59) expression -> expression . PLUS term
    (60) expression -> expression . MINUS term
    (61) expression -> expression . GREATER term
    (62) expression -> expression . LESS term
    (63) expression -> expression . GREATEREQUAL term
    (64) expression -> expression . LESSEQUAL term
    (65) expression -> expression . NOTEQUAL term

    TO              shift and go to state 136
    PLUS            shift and go to state 98
    MINUS           shift and go to state 99
    GREATER         shift and go to state 100
    LESS            shift and go to state 101
    GREATEREQUAL    shift and go to state 102
    LESSEQUAL       shift and go to state 103
    NOTEQUAL        shift and go to state 104


state 109

    (20) var_list -> var_list id_list COLON type_specifier . SEMICOLON

    SEMICOLON       shift and go to state 137


state 110

    (21) var_list -> id_list COLON type_specifier SEMICOLON .

    ID              reduce using rule 21 (var_list -> id_list COLON type_specifier SEMICOLON .)
    BEGIN           reduce using rule 21 (var_list -> id_list COLON type_specifier SEMICOLON .)
    VAR             reduce using rule 21 (var_list -> id_list COLON type_specifier SEMICOLON .)
    CONST           reduce using rule 21 (var_list -> id_list COLON type_specifier SEMICOLON .)
    TYPE            reduce using rule 21 (var_list -> id_list COLON type_specifier SEMICOLON .)
    PROCEDURE       reduce using rule 21 (var_list -> id_list COLON type_specifier SEMICOLON .)
    FUNCTION        reduce using rule 21 (var_list -> id_list COLON type_specifier SEMICOLON .)


state 111

    (23) type_specifier -> ARRAY LBRACKET . range RBRACKET OF type_base
    (29) range -> . NUMBER DOT DOT NUMBER

    NUMBER          shift and go to state 139

    range                          shift and go to state 138

state 112

    (24) type_specifier -> STRING LBRACKET . NUMBER RBRACKET

    NUMBER          shift and go to state 140


state 113

    (14) const_list -> const_list ID EQUALS expression . SEMICOLON
    (59) expression -> expression . PLUS term
    (60) expression -> expression . MINUS term
    (61) expression -> expression . GREATER term
    (62) expression -> expression . LESS term
    (63) expression -> expression . GREATEREQUAL term
    (64) expression -> expression . LESSEQUAL term
    (65) expression -> expression . NOTEQUAL term

    SEMICOLON       shift and go to state 141
    PLUS            shift and go to state 98
    MINUS           shift and go to state 99
    GREATER         shift and go to state 100
    LESS            shift and go to state 101
    GREATEREQUAL    shift and go to state 102
    LESSEQUAL       shift and go to state 103
    NOTEQUAL        shift and go to state 104


state 114

    (15) const_list -> ID EQUALS expression SEMICOLON .

    ID              reduce using rule 15 (const_list -> ID EQUALS expression SEMICOLON .)
    BEGIN           reduce using rule 15 (const_list -> ID EQUALS expression SEMICOLON .)
    VAR             reduce using rule 15 (const_list -> ID EQUALS expression SEMICOLON .)
    CONST           reduce using rule 15 (const_list -> ID EQUALS expression SEMICOLON .)
    TYPE            reduce using rule 15 (const_list -> ID EQUALS expression SEMICOLON .)
    PROCEDURE       reduce using rule 15 (const_list -> ID EQUALS expression SEMICOLON .)
    FUNCTION        reduce using rule 15 (const_list -> ID EQUALS expression SEMICOLON .)


state 115

    (17) type_list -> type_list ID EQUALS type_specifier . SEMICOLON

    SEMICOLON       shift and go to state 142


state 116

    (18) type_list -> ID EQUALS type_specifier SEMICOLON .

    ID              reduce using rule 18 (type_list -> ID EQUALS type_specifier SEMICOLON .)
    BEGIN           reduce using rule 18 (type_list -> ID EQUALS type_specifier SEMICOLON .)
    VAR             reduce using rule 18 (type_list -> ID EQUALS type_specifier SEMICOLON .)
    CONST           reduce using rule 18 (type_list -> ID EQUALS type_specifier SEMICOLON .)
    TYPE            reduce using rule 18 (type_list -> ID EQUALS type_specifier SEMICOLON .)
    PROCEDURE       reduce using rule 18 (type_list -> ID EQUALS type_specifier SEMICOLON .)
    FUNCTION        reduce using rule 18 (type_list -> ID EQUALS type_specifier SEMICOLON .)


state 117

    (54) arg_spec -> ID . COLON type_base

    COLON           shift and go to state 143


state 118

    (30) procedure_declaration -> PROCEDURE ID LPAREN enter_args args . RPAREN SEMICOLON compound_stmt SEMICOLON

    RPAREN          shift and go to state 144


state 119

    (50) args -> arg_list .
    (53) arg_list -> arg_list . SEMICOLON arg_spec

    RPAREN          reduce using rule 50 (args -> arg_list .)
    SEMICOLON       shift and go to state 145


state 120

    (51) args -> empty .

    RPAREN          reduce using rule 51 (args -> empty .)


state 121

    (52) arg_list -> arg_spec .

    SEMICOLON       reduce using rule 52 (arg_list -> arg_spec .)
    RPAREN          reduce using rule 52 (arg_list -> arg_spec .)


state 122

    (55) arg_spec -> VAR . ID COLON type_base

    ID              shift and go to state 146


state 123

    (31) function_declaration -> FUNCTION ID LPAREN enter_args args . RPAREN COLON type_base SEMICOLON compound_stmt SEMICOLON

    RPAREN          shift and go to state 147


state 124

    (72) factor -> LPAREN expression RPAREN .

    TIMES           reduce using rule 72 (factor -> LPAREN expression RPAREN .)
    DIVIDE          reduce using rule 72 (factor -> LPAREN expression RPAREN .)
    PLUS            reduce using rule 72 (factor -> LPAREN expression RPAREN .)
    MINUS           reduce using rule 72 (factor -> LPAREN expression RPAREN .)
    GREATER         reduce using rule 72 (factor -> LPAREN expression RPAREN .)
    LESS            reduce using rule 72 (factor -> LPAREN expression RPAREN .)
    GREATEREQUAL    reduce using rule 72 (factor -> LPAREN expression RPAREN .)
    LESSEQUAL       reduce using rule 72 (factor -> LPAREN expression RPAREN .)
    NOTEQUAL        reduce using rule 72 (factor -> LPAREN expression RPAREN .)
    RPAREN          reduce using rule 72 (factor -> LPAREN expression RPAREN .)
    COMMA           reduce using rule 72 (factor -> LPAREN expression RPAREN .)
    SEMICOLON       reduce using rule 72 (factor -> LPAREN expression RPAREN .)
    TO              reduce using rule 72 (factor -> LPAREN expression RPAREN .)
    DO              reduce using rule 72 (factor -> LPAREN expression RPAREN .)


state 125

    (56) expression_list -> expression_list COMMA expression .
    (59) expression -> expression . PLUS term
    (60) expression -> expression . MINUS term
    (61) expression -> expression . GREATER term
    (62) expression -> expression . LESS term
    (63) expression -> expression . GREATEREQUAL term
    (64) expression -> expression . LESSEQUAL term
    (65) expression -> expression . NOTEQUAL term

    RPAREN          reduce using rule 56 (expression_list -> expression_list COMMA expression .)
    COMMA           reduce using rule 56 (expression_list -> expression_list COMMA expression .)
    PLUS            shift and go to state 98
    MINUS           shift and go to state 99
    GREATER         shift and go to state 100
    LESS            shift and go to state 101
    GREATEREQUAL    shift and go to state 102
    LESSEQUAL       shift and go to state 103
    NOTEQUAL        shift and go to state 104


state 126

    (59) expression -> expression PLUS term .
    (67) term -> term . TIMES factor
    (68) term -> term . DIVIDE factor

    PLUS            reduce using rule 59 (expression -> expression PLUS term .)
    MINUS           reduce using rule 59 (expression -> expression PLUS term .)
    GREATER         reduce using rule 59 (expression -> expression PLUS term .)
    LESS            reduce using rule 59 (expression -> expression PLUS term .)
    GREATEREQUAL    reduce using rule 59 (expression -> expression PLUS term .)
    LESSEQUAL       reduce using rule 59 (expression -> expression PLUS term .)
    NOTEQUAL        reduce using rule 59 (expression -> expression PLUS term .)
    RPAREN          reduce using rule 59 (expression -> expression PLUS term .)
    COMMA           reduce using rule 59 (expression -> expression PLUS term .)
    SEMICOLON       reduce using rule 59 (expression -> expression PLUS term .)
    TO              reduce using rule 59 (expression -> expression PLUS term .)
    DO              reduce using rule 59 (expression -> expression PLUS term .)
    TIMES           shift and go to state 105
    DIVIDE          shift and go to state 106


state 127

    (60) expression -> expression MINUS term .
    (67) term -> term . TIMES factor
    (68) term -> term . DIVIDE factor

    PLUS            reduce using rule 60 (expression -> expression MINUS term .)
    MINUS           reduce using rule 60 (expression -> expression MINUS term .)
    GREATER         reduce using rule 60 (expression -> expression MINUS term .)
    LESS            reduce using rule 60 (expression -> expression MINUS term .)
    GREATEREQUAL    reduce using rule 60 (expression -> expression MINUS term .)
    LESSEQUAL       reduce using rule 60 (expression -> expression MINUS term .)
    NOTEQUAL        reduce using rule 60 (expression -> expression MINUS term .)
    RPAREN          reduce using rule 60 (expression -> expression MINUS term .)
    COMMA           reduce using rule 60 (expression -> expression MINUS term .)
    SEMICOLON       reduce using rule 60 (expression -> expression MINUS term .)
    TO              reduce using rule 60 (expression -> expression MINUS term .)
    DO              reduce using rule 60 (expression -> expression MINUS term .)
    TIMES           shift and go to state 105
    DIVIDE          shift and go to state 106


state 128

    (61) expression -> expression GREATER term .
    (67) term -> term . TIMES factor
    (68) term -> term . DIVIDE factor

    PLUS            reduce using rule 61 (expression -> expression GREATER term .)
    MINUS           reduce using rule 61 (expression -> expression GREATER term .)
    GREATER         reduce using rule 61 (expression -> expression GREATER term .)
    LESS            reduce using rule 61 (expression -> expression GREATER term .)
    GREATEREQUAL    reduce using rule 61 (expression -> expression GREATER term .)
    LESSEQUAL       reduce using rule 61 (expression -> expression GREATER term .)
    NOTEQUAL        reduce using rule 61 (expression -> expression GREATER term .)
    RPAREN          reduce using rule 61 (expression -> expression GREATER term .)
    COMMA           reduce using rule 61 (expression -> expression GREATER term .)
    SEMICOLON       reduce using rule 61 (expression -> expression GREATER term .)
    TO              reduce using rule 61 (expression -> expression GREATER term .)
    DO              reduce using rule 61 (expression -> expression GREATER term .)
    TIMES           shift and go to state 105
    DIVIDE          shift and go to state 106


state 129

    (62) expression -> expression LESS term .
    (67) term -> term . TIMES factor
    (68) term -> term . DIVIDE factor

    PLUS            reduce using rule 62 (expression -> expression LESS term .)
    MINUS           reduce using rule 62 (expression -> expression LESS term .)
    GREATER         reduce using rule 62 (expression -> expression LESS term .)
    LESS            reduce using rule 62 (expression -> expression LESS term .)
    GREATEREQUAL    reduce using rule 62 (expression -> expression LESS term .)
    LESSEQUAL       reduce using rule 62 (expression -> expression LESS term .)
    NOTEQUAL        reduce using rule 62 (expression -> expression LESS term .)
    RPAREN          reduce using rule 62 (expression -> expression LESS term .)
    COMMA           reduce using rule 62 (expression -> expression LESS term .)
    SEMICOLON       reduce using rule 62 (expression -> expression LESS term .)
    TO              reduce using rule 62 (expression -> expression LESS term .)
    DO              reduce using rule 62 (expression -> expression LESS term .)
    TIMES           shift and go to state 105
    DIVIDE          shift and go to state 106


state 130

    (63) expression -> expression GREATEREQUAL term .
    (67) term -> term . TIMES factor
    (68) term -> term . DIVIDE factor

    PLUS            reduce using rule 63 (expression -> expression GREATEREQUAL term .)
    MINUS           reduce using rule 63 (expression -> expression GREATEREQUAL term .)
    GREATER         reduce using rule 63 (expression -> expression GREATEREQUAL term .)
    LESS            reduce using rule 63 (expression -> expression GREATEREQUAL term .)
    GREATEREQUAL    reduce using rule 63 (expression -> expression GREATEREQUAL term .)
    LESSEQUAL       reduce using rule 63 (expression -> expression GREATEREQUAL term .)
    NOTEQUAL        reduce using rule 63 (expression -> expression GREATEREQUAL term .)
    RPAREN          reduce using rule 63 (expression -> expression GREATEREQUAL term .)
    COMMA           reduce using rule 63 (expression -> expression GREATEREQUAL term .)
    SEMICOLON       reduce using rule 63 (expression -> expression GREATEREQUAL term .)
    TO              reduce using rule 63 (expression -> expression GREATEREQUAL term .)
    DO              reduce using rule 63 (expression -> expression GREATEREQUAL term .)
    TIMES           shift and go to state 105
    DIVIDE          shift and go to state 106


state 131

    (64) expression -> expression LESSEQUAL term .
    (67) term -> term . TIMES factor
    (68) term -> term . DIVIDE factor

    PLUS            reduce using rule 64 (expression -> expression LESSEQUAL term .)
    MINUS           reduce using rule 64 (expression -> expression LESSEQUAL term .)
    GREATER         reduce using rule 64 (expression -> expression LESSEQUAL term .)
    LESS            reduce using rule 64 (expression -> expression LESSEQUAL term .)
    GREATEREQUAL    reduce using rule 64 (expression -> expression LESSEQUAL term .)
    LESSEQUAL       reduce using rule 64 (expression -> expression LESSEQUAL term .)
    NOTEQUAL        reduce using rule 64 (expression -> expression LESSEQUAL term .)
    RPAREN          reduce using rule 64 (expression -> expression LESSEQUAL term .)
    COMMA           reduce using rule 64 (expression -> expression LESSEQUAL term .)
    SEMICOLON       reduce using rule 64 (expression -> expression LESSEQUAL term .)
    TO              reduce using rule 64 (expression -> expression LESSEQUAL term .)
    DO              reduce using rule 64 (expression -> expression LESSEQUAL term .)
    TIMES           shift and go to state 105
    DIVIDE          shift and go to state 106


state 132

    (65) expression -> expression NOTEQUAL term .
    (67) term -> term . TIMES factor
    (68) term -> term . DIVIDE factor

    PLUS            reduce using rule 65 (expression -> expression NOTEQUAL term .)
    MINUS           reduce using rule 65 (expression -> expression NOTEQUAL term .)
    GREATER         reduce using rule 65 (expression -> expression NOTEQUAL term .)
    LESS            reduce using rule 65 (expression -> expression NOTEQUAL term .)
    GREATEREQUAL    reduce using rule 65 (expression -> expression NOTEQUAL term .)
    LESSEQUAL       reduce using rule 65 (expression -> expression NOTEQUAL term .)
    NOTEQUAL        reduce using rule 65 (expression -> expression NOTEQUAL term .)
    RPAREN          reduce using rule 65 (expression -> expression NOTEQUAL term .)
    COMMA           reduce using rule 65 (expression -> expression NOTEQUAL term .)
    SEMICOLON       reduce using rule 65 (expression -> expression NOTEQUAL term .)
    TO              reduce using rule 65 (expression -> expression NOTEQUAL term .)
    DO              reduce using rule 65 (expression -> expression NOTEQUAL term .)
    TIMES           shift and go to state 105
    DIVIDE          shift and go to state 106


state 133

    (67) term -> term TIMES factor .

    TIMES           reduce using rule 67 (term -> term TIMES factor .)
    DIVIDE          reduce using rule 67 (term -> term TIMES factor .)
    PLUS            reduce using rule 67 (term -> term TIMES factor .)
    MINUS           reduce using rule 67 (term -> term TIMES factor .)
    GREATER         reduce using rule 67 (term -> term TIMES factor .)
    LESS            reduce using rule 67 (term -> term TIMES factor .)
    GREATEREQUAL    reduce using rule 67 (term -> term TIMES factor .)
    LESSEQUAL       reduce using rule 67 (term -> term TIMES factor .)
    NOTEQUAL        reduce using rule 67 (term -> term TIMES factor .)
    RPAREN          reduce using rule 67 (term -> term TIMES factor .)
    COMMA           reduce using rule 67 (term -> term TIMES factor .)
    SEMICOLON       reduce using rule 67 (term -> term TIMES factor .)
    TO              reduce using rule 67 (term -> term TIMES factor .)
    DO              reduce using rule 67 (term -> term TIMES factor .)


state 134

    (68) term -> term DIVIDE factor .

    TIMES           reduce using rule 68 (term -> term DIVIDE factor .)
    DIVIDE          reduce using rule 68 (term -> term DIVIDE factor .)
    PLUS            reduce using rule 68 (term -> term DIVIDE factor .)
    MINUS           reduce using rule 68 (term -> term DIVIDE factor .)
    GREATER         reduce using rule 68 (term -> term DIVIDE factor .)
    LESS            reduce using rule 68 (term -> term DIVIDE factor .)
    GREATEREQUAL    reduce using rule 68 (term -> term DIVIDE factor .)
    LESSEQUAL       reduce using rule 68 (term -> term DIVIDE factor .)
    NOTEQUAL        reduce using rule 68 (term -> term DIVIDE factor .)
    RPAREN          reduce using rule 68 (term -> term DIVIDE factor .)
    COMMA           reduce using rule 68 (term -> term DIVIDE factor .)
    SEMICOLON       reduce using rule 68 (term -> term DIVIDE factor .)
    TO              reduce using rule 68 (term -> term DIVIDE factor .)
    DO              reduce using rule 68 (term -> term DIVIDE factor .)


state 135

    (43) if_stmt -> IF LPAREN expression RPAREN THEN . statement
    (44) if_stmt -> IF LPAREN expression RPAREN THEN . statement ELSE statement
    (38) statement -> . call_stmt SEMICOLON
    (39) statement -> . assignment_stmt SEMICOLON
    (40) statement -> . compound_stmt
    (41) statement -> . if_stmt
    (42) statement -> . for_stmt
    (48) call_stmt -> . ID LPAREN expression_list RPAREN
    (49) call_stmt -> . ID
    (47) assignment_stmt -> . ID ASSIGN expression
    (33) compound_stmt -> . BEGIN statement_list END
    (34) compound_stmt -> . var_section BEGIN statement_list END
    (43) if_stmt -> . IF LPAREN expression RPAREN THEN statement
    (44) if_stmt -> . IF LPAREN expression RPAREN THEN statement ELSE statement
    (45) for_stmt -> . FOR ID ASSIGN expression TO expression DO loop_guard statement
    (19) var_section -> . VAR var_list

    ID              shift and go to state 36
    BEGIN           shift and go to state 14
    IF              shift and go to state 38
    FOR             shift and go to state 39
    VAR             shift and go to state 20

    statement                      shift and go to state 148
    call_stmt                      shift and go to state 31
    assignment_stmt                shift and go to state 32
    compound_stmt                  shift and go to state 33
    if_stmt                        shift and go to state 34
    for_stmt                       shift and go to state 35
    var_section                    shift and go to state 37

state 136

    (45) for_stmt -> FOR ID ASSIGN expression TO . expression DO loop_guard statement
    (58) expression -> . term
    (59) expression -> . expression PLUS term
    (60) expression -> . expression MINUS term
    (61) expression -> . expression GREATER term
    (62) expression -> . expression LESS term
    (63) expression -> . expression GREATEREQUAL term
    (64) expression -> . expression LESSEQUAL term
    (65) expression -> . expression NOTEQUAL term
    (66) term -> . factor
    (67) term -> . term TIMES factor
    (68) term -> . term DIVIDE factor
    (69) factor -> . NUMBER
    (70) factor -> . STRING
    (71) factor -> . call_stmt
    (72) factor -> . LPAREN expression RPAREN
    (48) call_stmt -> . ID LPAREN expression_list RPAREN
    (49) call_stmt -> . ID

    NUMBER          shift and go to state 73
    STRING          shift and go to state 74
    LPAREN          shift and go to state 68
    ID              shift and go to state 67

    expression                     shift and go to state 149
    term                           shift and go to state 71
    factor                         shift and go to state 72
    call_stmt                      shift and go to state 75

state 137

    (20) var_list -> var_list id_list COLON type_specifier SEMICOLON .

    ID              reduce using rule 20 (var_list -> var_list id_list COLON type_specifier SEMICOLON .)
    BEGIN           reduce using rule 20 (var_list -> var_list id_list COLON type_specifier SEMICOLON .)
    VAR             reduce using rule 20 (var_list -> var_list id_list COLON type_specifier SEMICOLON .)
    CONST           reduce using rule 20 (var_list -> var_list id_list COLON type_specifier SEMICOLON .)
    TYPE            reduce using rule 20 (var_list -> var_list id_list COLON type_specifier SEMICOLON .)
    PROCEDURE       reduce using rule 20 (var_list -> var_list id_list COLON type_specifier SEMICOLON .)
    FUNCTION        reduce using rule 20 (var_list -> var_list id_list COLON type_specifier SEMICOLON .)


state 138

    (23) type_specifier -> ARRAY LBRACKET range . RBRACKET OF type_base

    RBRACKET        shift and go to state 150


state 139

    (29) range -> NUMBER . DOT DOT NUMBER

    DOT             shift and go to state 151


state 140

    (24) type_specifier -> STRING LBRACKET NUMBER . RBRACKET

    RBRACKET        shift and go to state 152


state 141

    (14) const_list -> const_list ID EQUALS expression SEMICOLON .

    ID              reduce using rule 14 (const_list -> const_list ID EQUALS expression SEMICOLON .)
    BEGIN           reduce using rule 14 (const_list -> const_list ID EQUALS expression SEMICOLON .)
    VAR             reduce using rule 14 (const_list -> const_list ID EQUALS expression SEMICOLON .)
    CONST           reduce using rule 14 (const_list -> const_list ID EQUALS expression SEMICOLON .)
    TYPE            reduce using rule 14 (const_list -> const_list ID EQUALS expression SEMICOLON .)
    PROCEDURE       reduce using rule 14 (const_list -> const_list ID EQUALS expression SEMICOLON .)
    FUNCTION        reduce using rule 14 (const_list -> const_list ID EQUALS expression SEMICOLON .)


state 142

    (17) type_list -> type_list ID EQUALS type_specifier SEMICOLON .

    ID              reduce using rule 17 (type_list -> type_list ID EQUALS type_specifier SEMICOLON .)
    BEGIN           reduce using rule 17 (type_list -> type_list ID EQUALS type_specifier SEMICOLON .)
    VAR             reduce using rule 17 (type_list -> type_list ID EQUALS type_specifier SEMICOLON .)
    CONST           reduce using rule 17 (type_list -> type_list ID EQUALS type_specifier SEMICOLON .)
    TYPE            reduce using rule 17 (type_list -> type_list ID EQUALS type_specifier SEMICOLON .)
    PROCEDURE       reduce using rule 17 (type_list -> type_list ID EQUALS type_specifier SEMICOLON .)
    FUNCTION        reduce using rule 17 (type_list -> type_list ID EQUALS type_specifier SEMICOLON .)


state 143

    (54) arg_spec -> ID COLON . type_base
    (25) type_base -> . INTEGER
    (26) type_base -> . REAL
    (27) type_base -> . CHAR
    (28) type_base -> . BOOLEAN

    INTEGER         shift and go to state 85
    REAL            shift and go to state 86
    CHAR            shift and go to state 87
    BOOLEAN         shift and go to state 88

    type_base                      shift and go to state 153

state 144

    (30) procedure_declaration -> PROCEDURE ID LPAREN enter_args args RPAREN . SEMICOLON compound_stmt SEMICOLON

    SEMICOLON       shift and go to state 154


state 145

    (53) arg_list -> arg_list SEMICOLON . arg_spec
    (54) arg_spec -> . ID COLON type_base
    (55) arg_spec -> . VAR ID COLON type_base

    ID              shift and go to state 117
    VAR             shift and go to state 122

    arg_spec                       shift and go to state 155

state 146

    (55) arg_spec -> VAR ID . COLON type_base

    COLON           shift and go to state 156


state 147

    (31) function_declaration -> FUNCTION ID LPAREN enter_args args RPAREN . COLON type_base SEMICOLON compound_stmt SEMICOLON

    COLON           shift and go to state 157


state 148

    (43) if_stmt -> IF LPAREN expression RPAREN THEN statement .
    (44) if_stmt -> IF LPAREN expression RPAREN THEN statement . ELSE statement

  ! shift/reduce conflict for ELSE resolved as shift
    END             reduce using rule 43 (if_stmt -> IF LPAREN expression RPAREN THEN statement .)
    ID              reduce using rule 43 (if_stmt -> IF LPAREN expression RPAREN THEN statement .)
    BEGIN           reduce using rule 43 (if_stmt -> IF LPAREN expression RPAREN THEN statement .)
    IF              reduce using rule 43 (if_stmt -> IF LPAREN expression RPAREN THEN statement .)
    FOR             reduce using rule 43 (if_stmt -> IF LPAREN expression RPAREN THEN statement .)
    VAR             reduce using rule 43 (if_stmt -> IF LPAREN expression RPAREN THEN statement .)
    ELSE            shift and go to state 158

  ! ELSE            [ reduce using rule 43 (if_stmt -> IF LPAREN expression RPAREN THEN statement .) ]


state 149

    (45) for_stmt -> FOR ID ASSIGN expression TO expression . DO loop_guard statement
    (59) expression -> expression . PLUS term
    (60) expression -> expression . MINUS term
    (61) expression -> expression . GREATER term
    (62) expression -> expression . LESS term
    (63) expression -> expression . GREATEREQUAL term
    (64) expression -> expression . LESSEQUAL term
    (65) expression -> expression . NOTEQUAL term

    DO              shift and go to state 159
    PLUS            shift and go to state 98
    MINUS           shift and go to state 99
    GREATER         shift and go to state 100
    LESS            shift and go to state 101
    GREATEREQUAL    shift and go to state 102
    LESSEQUAL       shift and go to state 103
    NOTEQUAL        shift and go to state 104


state 150

    (23) type_specifier -> ARRAY LBRACKET range RBRACKET . OF type_base

    OF              shift and go to state 160


state 151

    (29) range -> NUMBER DOT . DOT NUMBER

    DOT             shift and go to state 161


state 152

    (24) type_specifier -> STRING LBRACKET NUMBER RBRACKET .

    SEMICOLON       reduce using rule 24 (type_specifier -> STRING LBRACKET NUMBER RBRACKET .)


state 153

    (54) arg_spec -> ID COLON type_base .

    SEMICOLON       reduce using rule 54 (arg_spec -> ID COLON type_base .)
    RPAREN          reduce using rule 54 (arg_spec -> ID COLON type_base .)


state 154

    (30) procedure_declaration -> PROCEDURE ID LPAREN enter_args args RPAREN SEMICOLON . compound_stmt SEMICOLON
    (33) compound_stmt -> . BEGIN statement_list END
    (34) compound_stmt -> . var_section BEGIN statement_list END
    (19) var_section -> . VAR var_list

    BEGIN           shift and go to state 14
    VAR             shift and go to state 20

    compound_stmt                  shift and go to state 162
    var_section                    shift and go to state 37

state 155

    (53) arg_list -> arg_list SEMICOLON arg_spec .

    SEMICOLON       reduce using rule 53 (arg_list -> arg_list SEMICOLON arg_spec .)
    RPAREN          reduce using rule 53 (arg_list -> arg_list SEMICOLON arg_spec .)


state 156

    (55) arg_spec -> VAR ID COLON . type_base
    (25) type_base -> . INTEGER
    (26) type_base -> . REAL
    (27) type_base -> . CHAR
    (28) type_base -> . BOOLEAN

    INTEGER         shift and go to state 85
    REAL            shift and go to state 86
    CHAR            shift and go to state 87
    BOOLEAN         shift and go to state 88

    type_base                      shift and go to state 163

state 157

    (31) function_declaration -> FUNCTION ID LPAREN enter_args args RPAREN COLON . type_base SEMICOLON compound_stmt SEMICOLON
    (25) type_base -> . INTEGER
    (26) type_base -> . REAL
    (27) type_base -> . CHAR
    (28) type_base -> . BOOLEAN

    INTEGER         shift and go to state 85
    REAL            shift and go to state 86
    CHAR            shift and go to state 87
    BOOLEAN         shift and go to state 88

    type_base                      shift and go to state 164

state 158

    (44) if_stmt -> IF LPAREN expression RPAREN THEN statement ELSE . statement
    (38) statement -> . call_stmt SEMICOLON
    (39) statement -> . assignment_stmt SEMICOLON
    (40) statement -> . compound_stmt
    (41) statement -> . if_stmt
    (42) statement -> . for_stmt
    (48) call_stmt -> . ID LPAREN expression_list RPAREN
    (49) call_stmt -> . ID
    (47) assignment_stmt -> . ID ASSIGN expression
    (33) compound_stmt -> . BEGIN statement_list END
    (34) compound_stmt -> . var_section BEGIN statement_list END
    (43) if_stmt -> . IF LPAREN expression RPAREN THEN statement
    (44) if_stmt -> . IF LPAREN expression RPAREN THEN statement ELSE statement
    (45) for_stmt -> . FOR ID ASSIGN expression TO expression DO loop_guard statement
    (19) var_section -> . VAR var_list

    ID              shift and go to state 36
    BEGIN           shift and go to state 14
    IF              shift and go to state 38
    FOR             shift and go to state 39
    VAR             shift and go to state 20

    statement                      shift and go to state 165
    call_stmt                      shift and go to state 31
    assignment_stmt                shift and go to state 32
    compound_stmt                  shift and go to state 33
    if_stmt                        shift and go to state 34
    for_stmt                       shift and go to state 35
    var_section                    shift and go to state 37

state 159

    (45) for_stmt -> FOR ID ASSIGN expression TO expression DO . loop_guard statement
    (46) loop_guard -> .

    ID              reduce using rule 46 (loop_guard -> .)
    BEGIN           reduce using rule 46 (loop_guard -> .)
    IF              reduce using rule 46 (loop_guard -> .)
    FOR             reduce using rule 46 (loop_guard -> .)
    VAR             reduce using rule 46 (loop_guard -> .)

    loop_guard                     shift and go to state 166

state 160

    (23) type_specifier -> ARRAY LBRACKET range RBRACKET OF . type_base
    (25) type_base -> . INTEGER
    (26) type_base -> . REAL
    (27) type_base -> . CHAR
    (28) type_base -> . BOOLEAN

    INTEGER         shift and go to state 85
    REAL            shift and go to state 86
    CHAR            shift and go to state 87
    BOOLEAN         shift and go to state 88

    type_base                      shift and go to state 167

state 161

    (29) range -> NUMBER DOT DOT . NUMBER

    NUMBER          shift and go to state 168


state 162

    (30) procedure_declaration -> PROCEDURE ID LPAREN enter_args args RPAREN SEMICOLON compound_stmt . SEMICOLON

    SEMICOLON       shift and go to state 169


state 163

    (55) arg_spec -> VAR ID COLON type_base .

    SEMICOLON       reduce using rule 55 (arg_spec -> VAR ID COLON type_base .)
    RPAREN          reduce using rule 55 (arg_spec -> VAR ID COLON type_base .)


state 164

    (31) function_declaration -> FUNCTION ID LPAREN enter_args args RPAREN COLON type_base . SEMICOLON compound_stmt SEMICOLON

    SEMICOLON       shift and go to state 170


state 165

    (44) if_stmt -> IF LPAREN expression RPAREN THEN statement ELSE statement .

    END             reduce using rule 44 (if_stmt -> IF LPAREN expression RPAREN THEN statement ELSE statement .)
    ID              reduce using rule 44 (if_stmt -> IF LPAREN expression RPAREN THEN statement ELSE statement .)
    BEGIN           reduce using rule 44 (if_stmt -> IF LPAREN expression RPAREN THEN statement ELSE statement .)
    IF              reduce using rule 44 (if_stmt -> IF LPAREN expression RPAREN THEN statement ELSE statement .)
    FOR             reduce using rule 44 (if_stmt -> IF LPAREN expression RPAREN THEN statement ELSE statement .)
    VAR             reduce using rule 44 (if_stmt -> IF LPAREN expression RPAREN THEN statement ELSE statement .)
    ELSE            reduce using rule 44 (if_stmt -> IF LPAREN expression RPAREN THEN statement ELSE statement .)


state 166

    (45) for_stmt -> FOR ID ASSIGN expression TO expression DO loop_guard . statement
    (38) statement -> . call_stmt SEMICOLON
    (39) statement -> . assignment_stmt SEMICOLON
    (40) statement -> . compound_stmt
    (41) statement -> . if_stmt
    (42) statement -> . for_stmt
    (48) call_stmt -> . ID LPAREN expression_list RPAREN
    (49) call_stmt -> . ID
    (47) assignment_stmt -> . ID ASSIGN expression
    (33) compound_stmt -> . BEGIN statement_list END
    (34) compound_stmt -> . var_section BEGIN statement_list END
    (43) if_stmt -> . IF LPAREN expression RPAREN THEN statement
    (44) if_stmt -> . IF LPAREN expression RPAREN THEN statement ELSE statement
    (45) for_stmt -> . FOR ID ASSIGN expression TO expression DO loop_guard statement
    (19) var_section -> . VAR var_list

    ID              shift and go to state 36
    BEGIN           shift and go to state 14
    IF              shift and go to state 38
    FOR             shift and go to state 39
    VAR             shift and go to state 20

    statement                      shift and go to state 171
    call_stmt                      shift and go to state 31
    assignment_stmt                shift and go to state 32
    compound_stmt                  shift and go to state 33
    if_stmt                        shift and go to state 34
    for_stmt                       shift and go to state 35
    var_section                    shift and go to state 37

state 167

    (23) type_specifier -> ARRAY LBRACKET range RBRACKET OF type_base .

    SEMICOLON       reduce using rule 23 (type_specifier -> ARRAY LBRACKET range RBRACKET OF type_base .)


state 168

    (29) range -> NUMBER DOT DOT NUMBER .

    RBRACKET        reduce using rule 29 (range -> NUMBER DOT DOT NUMBER .)


state 169

    (30) procedure_declaration -> PROCEDURE ID LPAREN enter_args args RPAREN SEMICOLON compound_stmt SEMICOLON .

    BEGIN           reduce using rule 30 (procedure_declaration -> PROCEDURE ID LPAREN enter_args args RPAREN SEMICOLON compound_stmt SEMICOLON .)
    VAR             reduce using rule 30 (procedure_declaration -> PROCEDURE ID LPAREN enter_args args RPAREN SEMICOLON compound_stmt SEMICOLON .)
    CONST           reduce using rule 30 (procedure_declaration -> PROCEDURE ID LPAREN enter_args args RPAREN SEMICOLON compound_stmt SEMICOLON .)
    TYPE            reduce using rule 30 (procedure_declaration -> PROCEDURE ID LPAREN enter_args args RPAREN SEMICOLON compound_stmt SEMICOLON .)
    PROCEDURE       reduce using rule 30 (procedure_declaration -> PROCEDURE ID LPAREN enter_args args RPAREN SEMICOLON compound_stmt SEMICOLON .)
    FUNCTION        reduce using rule 30 (procedure_declaration -> PROCEDURE ID LPAREN enter_args args RPAREN SEMICOLON compound_stmt SEMICOLON .)


state 170

    (31) function_declaration -> FUNCTION ID LPAREN enter_args args RPAREN COLON type_base SEMICOLON . compound_stmt SEMICOLON
    (33) compound_stmt -> . BEGIN statement_list END
    (34) compound_stmt -> . var_section BEGIN statement_list END
    (19) var_section -> . VAR var_list

    BEGIN           shift and go to state 14
    VAR             shift and go to state 20

    compound_stmt                  shift and go to state 172
    var_section                    shift and go to state 37

state 171

    (45) for_stmt -> FOR ID ASSIGN expression TO expression DO loop_guard statement .

    END             reduce using rule 45 (for_stmt -> FOR ID ASSIGN expression TO expression DO loop_guard statement .)
    ID              reduce using rule 45 (for_stmt -> FOR ID ASSIGN expression TO expression DO loop_guard statement .)
    BEGIN           reduce using rule 45 (for_stmt -> FOR ID ASSIGN expression TO expression DO loop_guard statement .)
    IF              reduce using rule 45 (for_stmt -> FOR ID ASSIGN expression TO expression DO loop_guard statement .)
    FOR             reduce using rule 45 (for_stmt -> FOR ID ASSIGN expression TO expression DO loop_guard statement .)
    VAR             reduce using rule 45 (for_stmt -> FOR ID ASSIGN expression TO expression DO loop_guard statement .)
    ELSE            reduce using rule 45 (for_stmt -> FOR ID ASSIGN expression TO expression DO loop_guard statement .)


state 172

    (31) function_declaration -> FUNCTION ID LPAREN enter_args args RPAREN COLON type_base SEMICOLON compound_stmt . SEMICOLON

    SEMICOLON       shift and go to state 173


state 173

    (31) function_declaration -> FUNCTION ID LPAREN enter_args args RPAREN COLON type_base SEMICOLON compound_stmt SEMICOLON .

    BEGIN           reduce using rule 31 (function_declaration -> FUNCTION ID LPAREN enter_args args RPAREN COLON type_base SEMICOLON compound_stmt SEMICOLON .)
    VAR             reduce using rule 31 (function_declaration -> FUNCTION ID LPAREN enter_args args RPAREN COLON type_base SEMICOLON compound_stmt SEMICOLON .)
    CONST           reduce using rule 31 (function_declaration -> FUNCTION ID LPAREN enter_args args RPAREN COLON type_base SEMICOLON compound_stmt SEMICOLON .)
    TYPE            reduce using rule 31 (function_declaration -> FUNCTION ID LPAREN enter_args args RPAREN COLON type_base SEMICOLON compound_stmt SEMICOLON .)
    PROCEDURE       reduce using rule 31 (function_declaration -> FUNCTION ID LPAREN enter_args args RPAREN COLON type_base SEMICOLON compound_stmt SEMICOLON .)
    FUNCTION        reduce using rule 31 (function_declaration -> FUNCTION ID LPAREN enter_args args RPAREN COLON type_base SEMICOLON compound_stmt SEMICOLON .)

WARNING: 
WARNING: Conflicts:
WARNING: 
WARNING: shift/reduce conflict for ID in state 14 resolved as shift
WARNING: shift/reduce conflict for BEGIN in state 14 resolved as shift
WARNING: shift/reduce conflict for IF in state 14 resolved as shift
WARNING: shift/reduce conflict for FOR in state 14 resolved as shift
WARNING: shift/reduce conflict for VAR in state 14 resolved as shift
WARNING: shift/reduce conflict for BEGIN in state 15 resolved as shift
WARNING: shift/reduce conflict for ID in state 40 resolved as shift
WARNING: shift/reduce conflict for BEGIN in state 40 resolved as shift
WARNING: shift/reduce conflict for IF in state 40 resolved as shift
WARNING: shift/reduce conflict for FOR in state 40 resolved as shift
WARNING: shift/reduce conflict for VAR in state 40 resolved as shift
WARNING: shift/reduce conflict for ELSE in state 148 resolved as shift