Useless nonterminals

   rest_of_simple_cond


Terminals which are not used

   P_NAME
   P_SEPARATOR
   P_CONST
   P_CAPTION_TEXT


Useless rules

  192 rest_of_simple_cond: comparator plus_p exprn


State 33 conflicts: 4 shift/reduce, 1 reduce/reduce
State 36 conflicts: 1 shift/reduce
State 82 conflicts: 1 shift/reduce
State 85 conflicts: 1 shift/reduce
State 112 conflicts: 1 shift/reduce
State 138 conflicts: 1 shift/reduce
State 145 conflicts: 1 shift/reduce
State 146 conflicts: 1 shift/reduce
State 171 conflicts: 1 shift/reduce
State 196 conflicts: 1 shift/reduce
State 271 conflicts: 1 shift/reduce
State 314 conflicts: 1 shift/reduce
State 338 conflicts: 1 shift/reduce


Grammar

    0 $accept: program $end

    1 program: statements

    2 statements: single_statement
    3           | statements single_statement

    4 flip_case1z: /* empty */

    5 flip_case1: /* empty */

    6 flip_case0: /* empty */

    7 machine_code_sequence: flip_case1z '*' machine_instrn flip_case0 separator
    8                      | flip_case1z '*' '?' '?' '?' '?' flip_case0 separator
    9                      | machine_code_sequence flip_case1 '*' machine_instrn flip_case0 separator
   10                      | machine_code_sequence COMMENT NEWLINE
   11                      | machine_code_sequence P_UNSIGNED_INTEGER ':'
   12                      | machine_code_sequence NEWLINE
   13                      | machine_code_sequence CAPTION

   14 single_statement: unconditional_instrn separator
   15                 | if_or_unless condition THEN unconditional_instrn separator
   16                 | unconditional_instrn if_or_unless condition separator
   17                 | CYCLE IDENTIFIER '=' plus_p exprn ',' plus_p exprn ',' plus_p exprn separator
   18                 | REPEAT separator
   19                 | type name_list separator
   20                 | type_p ARRAY array_list separator
   21                 | SWITCH switch_list separator
   22                 | rt SPEC IDENTIFIER formal_parameter_defn_p separator
   23                 | SPEC IDENTIFIER formal_parameter_defn_p separator
   24                 | rt IDENTIFIER formal_parameter_defn_p separator
   25                 | BEGIN separator
   26                 | END separator
   27                 | P_UNSIGNED_INTEGER ':'
   28                 | IDENTIFIER actual_parameters ':'
   29                 | COMPILE QUERIES separator
   30                 | IGNORE QUERIES separator
   31                 | COMMENT
   32                 | '!' P_COMMENT_TEXT separator
   33                 | LIST separator
   34                 | END OF LIST separator
   35                 | M CODE separator
   36                 | END OF M CODE separator
   37                 | machine_code_sequence
   38                 | COMPILE ARRAY BOUND CHECKS separator
   39                 | IGNORE ARRAY BOUND CHECKS separator
   40                 | END OF PERM separator
   41                 | FAULT fault_list separator
   42                 | separator
   43                 | END OF PROGRAM NEWLINE

   44 unconditional_instrn: IDENTIFIER actual_parameters '=' plus_p exprn query_p
   45                     | IDENTIFIER actual_parameters
   46                     | '-' '>' P_UNSIGNED_INTEGER
   47                     | '-' '>' IDENTIFIER '(' plus_p exprn ')'
   48                     | CAPTION
   49                     | LITERAL
   50                     | RETURN
   51                     | RESULT '=' plus_p exprn
   52                     | STOP
   53                     | MONITOR STOP
   54                     | MONITOR P_UNSIGNED_INTEGER
   55                     | MONITOR BEGIN
   56                     | MONITOR END

   57 plus_p: '+'
   58       | '-'
   59       | /* empty */

   60 exprn: operand rest_of_exprn
   61      | '|' operand '|'

   62 rest_of_exprn: operator operand rest_of_exprn
   63              | /* empty */

   64 operand: IDENTIFIER actual_parameters_p
   65        | constant
   66        | '(' plus_p exprn ')'

   67 operator: '+'
   68         | '-'
   69         | '*'
   70         | '/'
   71         | '*' '*'
   72         | /* empty */

   73 ap_start: '('

   74 act_param: plus_p exprn

   75 actual_parameters_p: ap_start list_of_actual_parameters ')'
   76                    | /* empty */

   77 list_of_actual_parameters: list_of_actual_parameters ',' act_param
   78                          | act_param
   79                          | /* empty */

   80 query_p: '?'
   81        | /* empty */

   82 comma_p: ','
   83        | /* empty */

   84 if_or_unless: IF
   85             | UNLESS

   86 type: INTEGER
   87     | REAL

   88 type_p: INTEGER
   89       | REAL
   90       | /* empty */

   91 name_list: IDENTIFIER
   92          | name_list ',' IDENTIFIER

   93 array_list: name_list '(' bound_pair_list ')' rest_of_array_list

   94 rest_of_array_list: ',' array_list
   95                   | /* empty */

   96 bound_pair_list: plus_p exprn ':' plus_p exprn rest_of_bp_list
   97                | plus_p P_UNSIGNED_INTEGER ':' plus_p exprn rest_of_bp_list
   98                | plus_p P_UNSIGNED_INTEGER ':' P_UNSIGNED_INTEGER

   99 rest_of_bp_list: ',' bound_pair_list
  100                | /* empty */

  101 switch_bounds: P_UNSIGNED_INTEGER ':' P_UNSIGNED_INTEGER
  102              | '-' P_UNSIGNED_INTEGER ':' P_UNSIGNED_INTEGER
  103              | plus_p constant ':' plus_p constant

  104 switch_list: name_list '(' switch_bounds ')' rest_of_switch_list

  105 rest_of_switch_list: ',' switch_list
  106                    | /* empty */

  107 rt: ROUTINE
  108   | REAL FN
  109   | INTEGER FN
  110   | REAL MAP
  111   | INTEGER MAP

  112 fp_start: '('

  113 formal_parameter_defn_p: fp_start fp_list ')'
  114                        | /* empty */

  115 fp_list_part: fp_delimiter name_list

  116 fp_list: fp_list_part rest_of_fp_list

  117 rest_of_fp_list: ';' fp_list
  118                | /* empty */

  119 fp_delimiter: comma_p rt
  120             | comma_p type NAME
  121             | comma_p type
  122             | comma_p type_p ARRAY NAME
  123             | ADDR

  124 condition: simple_cond AND and_cond
  125          | simple_cond OR or_cond
  126          | simple_cond

  127 and_cond: simple_cond rest_of_and_cond

  128 rest_of_and_cond: AND and_cond
  129                 | /* empty */

  130 or_cond: simple_cond rest_of_or_cond

  131 rest_of_or_cond: OR or_cond
  132                | /* empty */

  133 simple_cond: plus_p exprn comparator plus_p exprn
  134            | plus_p exprn comparator plus_p exprn comparator plus_p exprn
  135            | '(' or_cond ')'

  136 comparator: '='
  137           | '#'
  138           | '<' '='
  139           | '<'
  140           | '>' '='
  141           | '>'

  142 fault_list: P_UNSIGNED_INTEGER rest_of_N_list '-' '>' P_UNSIGNED_INTEGER rest_of_fault_list

  143 rest_of_N_list: ',' P_UNSIGNED_INTEGER
  144               | /* empty */

  145 rest_of_fault_list: ',' fault_list
  146                   | /* empty */

  147 separator: ';'
  148          | NEWLINE

  149 machine_instrn: IDENTIFIER ':'
  150               | IDENTIFIER P_UNSIGNED_INTEGER ':'
  151               | IDENTIFIER IDENTIFIER P_UNSIGNED_INTEGER
  152               | flip_case0 '*' '`' IDENTIFIER actual_parameters
  153               | flip_case0 '*' '@' IDENTIFIER actual_parameters
  154               | flip_case0 '*' operand
  155               | flip_case0 '*' '=' IDENTIFIER actual_parameters
  156               | IDENTIFIER
  157               | '=' IDENTIFIER
  158               | IDENTIFIER P_UNSIGNED_INTEGER
  159               | '=' IDENTIFIER P_UNSIGNED_INTEGER
  160               | '=' '+' IDENTIFIER P_UNSIGNED_INTEGER
  161               | IDENTIFIER P_UNSIGNED_INTEGER IDENTIFIER P_UNSIGNED_INTEGER
  162               | '=' IDENTIFIER P_UNSIGNED_INTEGER IDENTIFIER P_UNSIGNED_INTEGER
  163               | IDENTIFIER P_UNSIGNED_INTEGER IDENTIFIER P_UNSIGNED_INTEGER IDENTIFIER
  164               | '=' IDENTIFIER P_UNSIGNED_INTEGER IDENTIFIER P_UNSIGNED_INTEGER IDENTIFIER
  165               | IDENTIFIER P_UNSIGNED_INTEGER IDENTIFIER IDENTIFIER P_UNSIGNED_INTEGER
  166               | IDENTIFIER '-' P_UNSIGNED_INTEGER
  167               | IDENTIFIER '+' P_UNSIGNED_INTEGER
  168               | IDENTIFIER P_UNSIGNED_INTEGER '=' IDENTIFIER
  169               | IDENTIFIER P_UNSIGNED_INTEGER '>' IDENTIFIER
  170               | IDENTIFIER P_UNSIGNED_INTEGER '>' '=' IDENTIFIER
  171               | IDENTIFIER P_UNSIGNED_INTEGER '<' '=' IDENTIFIER
  172               | IDENTIFIER P_UNSIGNED_INTEGER '<' IDENTIFIER
  173               | IDENTIFIER P_UNSIGNED_INTEGER '#' IDENTIFIER
  174               | IDENTIFIER P_UNSIGNED_INTEGER '#'
  175               | IDENTIFIER P_UNSIGNED_INTEGER '='
  176               | IDENTIFIER P_UNSIGNED_INTEGER IDENTIFIER
  177               | '-'
  178               | '-' IDENTIFIER
  179               | '+'
  180               | '+' IDENTIFIER
  181               | '/'
  182               | '/' IDENTIFIER
  183               | IDENTIFIER '-' IDENTIFIER P_UNSIGNED_INTEGER
  184               | IDENTIFIER '+' IDENTIFIER P_UNSIGNED_INTEGER
  185               | IDENTIFIER P_UNSIGNED_INTEGER '=' '-' P_UNSIGNED_INTEGER
  186               | IDENTIFIER P_UNSIGNED_INTEGER '=' '+' P_UNSIGNED_INTEGER
  187               | IDENTIFIER P_UNSIGNED_INTEGER '=' P_UNSIGNED_INTEGER
  188               | P_UNSIGNED_INTEGER '/' P_UNSIGNED_INTEGER '/' P_UNSIGNED_INTEGER
  189               | /* empty */

  190 actual_parameters: actual_parameters_p

  191 constant: P_UNSIGNED_INTEGER


Terminals, with rules where they appear

$end (0) 0
'!' (33) 32
'#' (35) 137 173 174
'(' (40) 47 66 73 93 104 112 135
')' (41) 47 66 75 93 104 113 135
'*' (42) 7 8 9 69 71 152 153 154 155
'+' (43) 57 67 160 167 179 180 184 186
',' (44) 17 77 82 92 94 99 105 143 145
'-' (45) 46 47 58 68 102 142 166 177 178 183 185
'/' (47) 70 181 182 188
':' (58) 11 27 28 96 97 98 101 102 103 149 150
';' (59) 117 147
'<' (60) 138 139 171 172
'=' (61) 17 44 51 136 138 140 155 157 159 160 162 164 168 170 171 175
    185 186 187
'>' (62) 46 47 140 141 142 169 170
'?' (63) 8 80
'@' (64) 153
'`' (96) 152
'|' (124) 61
error (256)
P_NAME (258)
P_SEPARATOR (259)
P_CONST (260)
P_COMMENT_TEXT (261) 32
P_CAPTION_TEXT (262)
P_UNSIGNED_INTEGER (263) 11 27 46 54 97 98 101 102 142 143 150 151
    158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173
    174 175 176 183 184 185 186 187 188 191
ADDR (264) 123
AND (265) 124 128
ARRAY (266) 20 38 39 122
BEGIN (267) 25 55
BOUND (268) 38 39
CAPTION (269) 13 48
CHECKS (270) 38 39
CODE (271) 35 36
COMMENT (272) 10 31
COMPILE (273) 29 38
CYCLE (274) 17
END (275) 26 34 36 40 43 56
FAULT (276) 41
FN (277) 108 109
IF (278) 84
IGNORE (279) 30 39
INTEGER (280) 86 88 109 111
LIST (281) 33 34
LITERAL (282) 49
M (283) 35 36
MAP (284) 110 111
MONITOR (285) 53 54 55 56
NAME (286) 120 122
OF (287) 34 36 40 43
OR (288) 125 131
PERM (289) 40
PROGRAM (290) 43
QUERIES (291) 29 30
REAL (292) 87 89 108 110
REPEAT (293) 18
RESULT (294) 51
RETURN (295) 50
ROUTINE (296) 107
SPEC (297) 22 23
STOP (298) 52 53
SWITCH (299) 21
THEN (300) 15
UNLESS (301) 85
IDENTIFIER (302) 17 22 23 24 28 44 45 47 64 91 92 149 150 151 152 153
    155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
    171 172 173 174 175 176 178 180 182 183 184 185 186 187
NEWLINE (303) 10 12 43 148


Nonterminals, with rules where they appear

$accept (67)
    on left: 0
program (68)
    on left: 1, on right: 0
statements (69)
    on left: 2 3, on right: 1 3
flip_case1z (70)
    on left: 4, on right: 7 8
flip_case1 (71)
    on left: 5, on right: 9
flip_case0 (72)
    on left: 6, on right: 7 8 9 152 153 154 155
machine_code_sequence (73)
    on left: 7 8 9 10 11 12 13, on right: 9 10 11 12 13 37
single_statement (74)
    on left: 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
    32 33 34 35 36 37 38 39 40 41 42 43, on right: 2 3
unconditional_instrn (75)
    on left: 44 45 46 47 48 49 50 51 52 53 54 55 56,
    on right: 14 15 16
plus_p (76)
    on left: 57 58 59, on right: 17 44 47 51 66 74 96 97 98 103 133
    134
exprn (77)
    on left: 60 61, on right: 17 44 47 51 66 74 96 97 133 134
rest_of_exprn (78)
    on left: 62 63, on right: 60 62
operand (79)
    on left: 64 65 66, on right: 60 61 62 154
operator (80)
    on left: 67 68 69 70 71 72, on right: 62
ap_start (81)
    on left: 73, on right: 75
act_param (82)
    on left: 74, on right: 77 78
actual_parameters_p (83)
    on left: 75 76, on right: 64 190
list_of_actual_parameters (84)
    on left: 77 78 79, on right: 75 77
query_p (85)
    on left: 80 81, on right: 44
comma_p (86)
    on left: 82 83, on right: 119 120 121 122
if_or_unless (87)
    on left: 84 85, on right: 15 16
type (88)
    on left: 86 87, on right: 19 120 121
type_p (89)
    on left: 88 89 90, on right: 20 122
name_list (90)
    on left: 91 92, on right: 19 92 93 104 115
array_list (91)
    on left: 93, on right: 20 94
rest_of_array_list (92)
    on left: 94 95, on right: 93
bound_pair_list (93)
    on left: 96 97 98, on right: 93 99
rest_of_bp_list (94)
    on left: 99 100, on right: 96 97
switch_bounds (95)
    on left: 101 102 103, on right: 104
switch_list (96)
    on left: 104, on right: 21 105
rest_of_switch_list (97)
    on left: 105 106, on right: 104
rt (98)
    on left: 107 108 109 110 111, on right: 22 24 119
fp_start (99)
    on left: 112, on right: 113
formal_parameter_defn_p (100)
    on left: 113 114, on right: 22 23 24
fp_list_part (101)
    on left: 115, on right: 116
fp_list (102)
    on left: 116, on right: 113 117
rest_of_fp_list (103)
    on left: 117 118, on right: 116
fp_delimiter (104)
    on left: 119 120 121 122 123, on right: 115
condition (105)
    on left: 124 125 126, on right: 15 16
and_cond (106)
    on left: 127, on right: 124 128
rest_of_and_cond (107)
    on left: 128 129, on right: 127
or_cond (108)
    on left: 130, on right: 125 131 135
rest_of_or_cond (109)
    on left: 131 132, on right: 130
simple_cond (110)
    on left: 133 134 135, on right: 124 125 126 127 130
comparator (111)
    on left: 136 137 138 139 140 141, on right: 133 134
fault_list (112)
    on left: 142, on right: 41 145
rest_of_N_list (113)
    on left: 143 144, on right: 142
rest_of_fault_list (114)
    on left: 145 146, on right: 142
separator (115)
    on left: 147 148, on right: 7 8 9 14 15 16 17 18 19 20 21 22 23
    24 25 26 29 30 32 33 34 35 36 38 39 40 41 42
machine_instrn (116)
    on left: 149 150 151 152 153 154 155 156 157 158 159 160 161 162
    163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178
    179 180 181 182 183 184 185 186 187 188 189, on right: 7 9
actual_parameters (117)
    on left: 190, on right: 28 44 45 152 153 155
constant (118)
    on left: 191, on right: 65 103


state 0

    0 $accept:  program $end

    P_UNSIGNED_INTEGER  shift, and go to state 1
    BEGIN               shift, and go to state 2
    CAPTION             shift, and go to state 3
    COMMENT             shift, and go to state 4
    COMPILE             shift, and go to state 5
    CYCLE               shift, and go to state 6
    END                 shift, and go to state 7
    FAULT               shift, and go to state 8
    IF                  shift, and go to state 9
    IGNORE              shift, and go to state 10
    INTEGER             shift, and go to state 11
    LIST                shift, and go to state 12
    LITERAL             shift, and go to state 13
    M                   shift, and go to state 14
    MONITOR             shift, and go to state 15
    REAL                shift, and go to state 16
    REPEAT              shift, and go to state 17
    RESULT              shift, and go to state 18
    RETURN              shift, and go to state 19
    ROUTINE             shift, and go to state 20
    SPEC                shift, and go to state 21
    STOP                shift, and go to state 22
    SWITCH              shift, and go to state 23
    UNLESS              shift, and go to state 24
    IDENTIFIER          shift, and go to state 25
    NEWLINE             shift, and go to state 26
    '!'                 shift, and go to state 27
    '-'                 shift, and go to state 28
    ';'                 shift, and go to state 29

    ARRAY     reduce using rule 90 (type_p)
    $default  reduce using rule 4 (flip_case1z)

    program                go to state 30
    statements             go to state 31
    flip_case1z            go to state 32
    machine_code_sequence  go to state 33
    single_statement       go to state 34
    unconditional_instrn   go to state 35
    if_or_unless           go to state 36
    type                   go to state 37
    type_p                 go to state 38
    rt                     go to state 39
    separator              go to state 40


state 1

   27 single_statement: P_UNSIGNED_INTEGER  ':'

    ':'  shift, and go to state 41


state 2

   25 single_statement: BEGIN  separator

    NEWLINE  shift, and go to state 26
    ';'      shift, and go to state 29

    separator  go to state 42


state 3

   48 unconditional_instrn: CAPTION 

    $default  reduce using rule 48 (unconditional_instrn)


state 4

   31 single_statement: COMMENT 

    $default  reduce using rule 31 (single_statement)


state 5

   29 single_statement: COMPILE  QUERIES separator
   38                 | COMPILE  ARRAY BOUND CHECKS separator

    ARRAY    shift, and go to state 43
    QUERIES  shift, and go to state 44


state 6

   17 single_statement: CYCLE  IDENTIFIER '=' plus_p exprn ',' plus_p exprn ',' plus_p exprn separator

    IDENTIFIER  shift, and go to state 45


state 7

   26 single_statement: END  separator
   34                 | END  OF LIST separator
   36                 | END  OF M CODE separator
   40                 | END  OF PERM separator
   43                 | END  OF PROGRAM NEWLINE

    OF       shift, and go to state 46
    NEWLINE  shift, and go to state 26
    ';'      shift, and go to state 29

    separator  go to state 47


state 8

   41 single_statement: FAULT  fault_list separator

    P_UNSIGNED_INTEGER  shift, and go to state 48

    fault_list  go to state 49


state 9

   84 if_or_unless: IF 

    $default  reduce using rule 84 (if_or_unless)


state 10

   30 single_statement: IGNORE  QUERIES separator
   39                 | IGNORE  ARRAY BOUND CHECKS separator

    ARRAY    shift, and go to state 50
    QUERIES  shift, and go to state 51


state 11

   86 type: INTEGER 
   88 type_p: INTEGER 
  109 rt: INTEGER  FN
  111   | INTEGER  MAP

    FN   shift, and go to state 52
    MAP  shift, and go to state 53

    ARRAY     reduce using rule 88 (type_p)
    $default  reduce using rule 86 (type)


state 12

   33 single_statement: LIST  separator

    NEWLINE  shift, and go to state 26
    ';'      shift, and go to state 29

    separator  go to state 54


state 13

   49 unconditional_instrn: LITERAL 

    $default  reduce using rule 49 (unconditional_instrn)


state 14

   35 single_statement: M  CODE separator

    CODE  shift, and go to state 55


state 15

   53 unconditional_instrn: MONITOR  STOP
   54                     | MONITOR  P_UNSIGNED_INTEGER
   55                     | MONITOR  BEGIN
   56                     | MONITOR  END

    P_UNSIGNED_INTEGER  shift, and go to state 56
    BEGIN               shift, and go to state 57
    END                 shift, and go to state 58
    STOP                shift, and go to state 59


state 16

   87 type: REAL 
   89 type_p: REAL 
  108 rt: REAL  FN
  110   | REAL  MAP

    FN   shift, and go to state 60
    MAP  shift, and go to state 61

    ARRAY     reduce using rule 89 (type_p)
    $default  reduce using rule 87 (type)


state 17

   18 single_statement: REPEAT  separator

    NEWLINE  shift, and go to state 26
    ';'      shift, and go to state 29

    separator  go to state 62


state 18

   51 unconditional_instrn: RESULT  '=' plus_p exprn

    '='  shift, and go to state 63


state 19

   50 unconditional_instrn: RETURN 

    $default  reduce using rule 50 (unconditional_instrn)


state 20

  107 rt: ROUTINE 

    $default  reduce using rule 107 (rt)


state 21

   23 single_statement: SPEC  IDENTIFIER formal_parameter_defn_p separator

    IDENTIFIER  shift, and go to state 64


state 22

   52 unconditional_instrn: STOP 

    $default  reduce using rule 52 (unconditional_instrn)


state 23

   21 single_statement: SWITCH  switch_list separator

    IDENTIFIER  shift, and go to state 65

    name_list    go to state 66
    switch_list  go to state 67


state 24

   85 if_or_unless: UNLESS 

    $default  reduce using rule 85 (if_or_unless)


state 25

   28 single_statement: IDENTIFIER  actual_parameters ':'
   44 unconditional_instrn: IDENTIFIER  actual_parameters '=' plus_p exprn query_p
   45                     | IDENTIFIER  actual_parameters

    '('  shift, and go to state 68

    $default  reduce using rule 76 (actual_parameters_p)

    ap_start             go to state 69
    actual_parameters_p  go to state 70
    actual_parameters    go to state 71


state 26

  148 separator: NEWLINE 

    $default  reduce using rule 148 (separator)


state 27

   32 single_statement: '!'  P_COMMENT_TEXT separator

    P_COMMENT_TEXT  shift, and go to state 72


state 28

   46 unconditional_instrn: '-'  '>' P_UNSIGNED_INTEGER
   47                     | '-'  '>' IDENTIFIER '(' plus_p exprn ')'

    '>'  shift, and go to state 73


state 29

  147 separator: ';' 

    $default  reduce using rule 147 (separator)


state 30

    0 $accept: program  $end

    $end  shift, and go to state 74


state 31

    1 program: statements 
    3 statements: statements  single_statement

    P_UNSIGNED_INTEGER  shift, and go to state 1
    BEGIN               shift, and go to state 2
    CAPTION             shift, and go to state 3
    COMMENT             shift, and go to state 4
    COMPILE             shift, and go to state 5
    CYCLE               shift, and go to state 6
    END                 shift, and go to state 7
    FAULT               shift, and go to state 8
    IF                  shift, and go to state 9
    IGNORE              shift, and go to state 10
    INTEGER             shift, and go to state 11
    LIST                shift, and go to state 12
    LITERAL             shift, and go to state 13
    M                   shift, and go to state 14
    MONITOR             shift, and go to state 15
    REAL                shift, and go to state 16
    REPEAT              shift, and go to state 17
    RESULT              shift, and go to state 18
    RETURN              shift, and go to state 19
    ROUTINE             shift, and go to state 20
    SPEC                shift, and go to state 21
    STOP                shift, and go to state 22
    SWITCH              shift, and go to state 23
    UNLESS              shift, and go to state 24
    IDENTIFIER          shift, and go to state 25
    NEWLINE             shift, and go to state 26
    '!'                 shift, and go to state 27
    '-'                 shift, and go to state 28
    ';'                 shift, and go to state 29

    ARRAY     reduce using rule 90 (type_p)
    '*'       reduce using rule 4 (flip_case1z)
    $default  reduce using rule 1 (program)

    flip_case1z            go to state 32
    machine_code_sequence  go to state 33
    single_statement       go to state 75
    unconditional_instrn   go to state 35
    if_or_unless           go to state 36
    type                   go to state 37
    type_p                 go to state 38
    rt                     go to state 39
    separator              go to state 40


state 32

    7 machine_code_sequence: flip_case1z  '*' machine_instrn flip_case0 separator
    8                      | flip_case1z  '*' '?' '?' '?' '?' flip_case0 separator

    '*'  shift, and go to state 76


state 33

    9 machine_code_sequence: machine_code_sequence  flip_case1 '*' machine_instrn flip_case0 separator
   10                      | machine_code_sequence  COMMENT NEWLINE
   11                      | machine_code_sequence  P_UNSIGNED_INTEGER ':'
   12                      | machine_code_sequence  NEWLINE
   13                      | machine_code_sequence  CAPTION
   37 single_statement: machine_code_sequence 

    P_UNSIGNED_INTEGER  shift, and go to state 77
    CAPTION             shift, and go to state 78
    COMMENT             shift, and go to state 79
    NEWLINE             shift, and go to state 80

    P_UNSIGNED_INTEGER  [reduce using rule 37 (single_statement)]
    CAPTION             [reduce using rule 37 (single_statement)]
    COMMENT             [reduce using rule 37 (single_statement)]
    NEWLINE             [reduce using rule 37 (single_statement)]
    '*'                 reduce using rule 5 (flip_case1)
    '*'                 [reduce using rule 37 (single_statement)]
    $default            reduce using rule 37 (single_statement)

    flip_case1  go to state 81


state 34

    2 statements: single_statement 

    $default  reduce using rule 2 (statements)


state 35

   14 single_statement: unconditional_instrn  separator
   16                 | unconditional_instrn  if_or_unless condition separator

    IF       shift, and go to state 9
    UNLESS   shift, and go to state 24
    NEWLINE  shift, and go to state 26
    ';'      shift, and go to state 29

    if_or_unless  go to state 82
    separator     go to state 83


state 36

   15 single_statement: if_or_unless  condition THEN unconditional_instrn separator

    '-'  shift, and go to state 84
    '('  shift, and go to state 85
    '+'  shift, and go to state 86

    '('       [reduce using rule 59 (plus_p)]
    $default  reduce using rule 59 (plus_p)

    plus_p       go to state 87
    condition    go to state 88
    simple_cond  go to state 89


state 37

   19 single_statement: type  name_list separator

    IDENTIFIER  shift, and go to state 65

    name_list  go to state 90


state 38

   20 single_statement: type_p  ARRAY array_list separator

    ARRAY  shift, and go to state 91


state 39

   22 single_statement: rt  SPEC IDENTIFIER formal_parameter_defn_p separator
   24                 | rt  IDENTIFIER formal_parameter_defn_p separator

    SPEC        shift, and go to state 92
    IDENTIFIER  shift, and go to state 93


state 40

   42 single_statement: separator 

    $default  reduce using rule 42 (single_statement)


state 41

   27 single_statement: P_UNSIGNED_INTEGER ':' 

    $default  reduce using rule 27 (single_statement)


state 42

   25 single_statement: BEGIN separator 

    $default  reduce using rule 25 (single_statement)


state 43

   38 single_statement: COMPILE ARRAY  BOUND CHECKS separator

    BOUND  shift, and go to state 94


state 44

   29 single_statement: COMPILE QUERIES  separator

    NEWLINE  shift, and go to state 26
    ';'      shift, and go to state 29

    separator  go to state 95


state 45

   17 single_statement: CYCLE IDENTIFIER  '=' plus_p exprn ',' plus_p exprn ',' plus_p exprn separator

    '='  shift, and go to state 96


state 46

   34 single_statement: END OF  LIST separator
   36                 | END OF  M CODE separator
   40                 | END OF  PERM separator
   43                 | END OF  PROGRAM NEWLINE

    LIST     shift, and go to state 97
    M        shift, and go to state 98
    PERM     shift, and go to state 99
    PROGRAM  shift, and go to state 100


state 47

   26 single_statement: END separator 

    $default  reduce using rule 26 (single_statement)


state 48

  142 fault_list: P_UNSIGNED_INTEGER  rest_of_N_list '-' '>' P_UNSIGNED_INTEGER rest_of_fault_list

    ','  shift, and go to state 101

    $default  reduce using rule 144 (rest_of_N_list)

    rest_of_N_list  go to state 102


state 49

   41 single_statement: FAULT fault_list  separator

    NEWLINE  shift, and go to state 26
    ';'      shift, and go to state 29

    separator  go to state 103


state 50

   39 single_statement: IGNORE ARRAY  BOUND CHECKS separator

    BOUND  shift, and go to state 104


state 51

   30 single_statement: IGNORE QUERIES  separator

    NEWLINE  shift, and go to state 26
    ';'      shift, and go to state 29

    separator  go to state 105


state 52

  109 rt: INTEGER FN 

    $default  reduce using rule 109 (rt)


state 53

  111 rt: INTEGER MAP 

    $default  reduce using rule 111 (rt)


state 54

   33 single_statement: LIST separator 

    $default  reduce using rule 33 (single_statement)


state 55

   35 single_statement: M CODE  separator

    NEWLINE  shift, and go to state 26
    ';'      shift, and go to state 29

    separator  go to state 106


state 56

   54 unconditional_instrn: MONITOR P_UNSIGNED_INTEGER 

    $default  reduce using rule 54 (unconditional_instrn)


state 57

   55 unconditional_instrn: MONITOR BEGIN 

    $default  reduce using rule 55 (unconditional_instrn)


state 58

   56 unconditional_instrn: MONITOR END 

    $default  reduce using rule 56 (unconditional_instrn)


state 59

   53 unconditional_instrn: MONITOR STOP 

    $default  reduce using rule 53 (unconditional_instrn)


state 60

  108 rt: REAL FN 

    $default  reduce using rule 108 (rt)


state 61

  110 rt: REAL MAP 

    $default  reduce using rule 110 (rt)


state 62

   18 single_statement: REPEAT separator 

    $default  reduce using rule 18 (single_statement)


state 63

   51 unconditional_instrn: RESULT '='  plus_p exprn

    '-'  shift, and go to state 84
    '+'  shift, and go to state 86

    $default  reduce using rule 59 (plus_p)

    plus_p  go to state 107


state 64

   23 single_statement: SPEC IDENTIFIER  formal_parameter_defn_p separator

    '('  shift, and go to state 108

    $default  reduce using rule 114 (formal_parameter_defn_p)

    fp_start                 go to state 109
    formal_parameter_defn_p  go to state 110


state 65

   91 name_list: IDENTIFIER 

    $default  reduce using rule 91 (name_list)


state 66

   92 name_list: name_list  ',' IDENTIFIER
  104 switch_list: name_list  '(' switch_bounds ')' rest_of_switch_list

    ','  shift, and go to state 111
    '('  shift, and go to state 112


state 67

   21 single_statement: SWITCH switch_list  separator

    NEWLINE  shift, and go to state 26
    ';'      shift, and go to state 29

    separator  go to state 113


state 68

   73 ap_start: '(' 

    $default  reduce using rule 73 (ap_start)


state 69

   75 actual_parameters_p: ap_start  list_of_actual_parameters ')'

    '-'  shift, and go to state 84
    '+'  shift, and go to state 86

    ','       reduce using rule 79 (list_of_actual_parameters)
    ')'       reduce using rule 79 (list_of_actual_parameters)
    $default  reduce using rule 59 (plus_p)

    plus_p                     go to state 114
    act_param                  go to state 115
    list_of_actual_parameters  go to state 116


state 70

  190 actual_parameters: actual_parameters_p 

    $default  reduce using rule 190 (actual_parameters)


state 71

   28 single_statement: IDENTIFIER actual_parameters  ':'
   44 unconditional_instrn: IDENTIFIER actual_parameters  '=' plus_p exprn query_p
   45                     | IDENTIFIER actual_parameters 

    ':'  shift, and go to state 117
    '='  shift, and go to state 118

    $default  reduce using rule 45 (unconditional_instrn)


state 72

   32 single_statement: '!' P_COMMENT_TEXT  separator

    NEWLINE  shift, and go to state 26
    ';'      shift, and go to state 29

    separator  go to state 119


state 73

   46 unconditional_instrn: '-' '>'  P_UNSIGNED_INTEGER
   47                     | '-' '>'  IDENTIFIER '(' plus_p exprn ')'

    P_UNSIGNED_INTEGER  shift, and go to state 120
    IDENTIFIER          shift, and go to state 121


state 74

    0 $accept: program $end 

    $default  accept


state 75

    3 statements: statements single_statement 

    $default  reduce using rule 3 (statements)


state 76

    7 machine_code_sequence: flip_case1z '*'  machine_instrn flip_case0 separator
    8                      | flip_case1z '*'  '?' '?' '?' '?' flip_case0 separator

    P_UNSIGNED_INTEGER  shift, and go to state 122
    IDENTIFIER          shift, and go to state 123
    '?'                 shift, and go to state 124
    '='                 shift, and go to state 125
    '-'                 shift, and go to state 126
    '+'                 shift, and go to state 127
    '/'                 shift, and go to state 128

    '*'       reduce using rule 6 (flip_case0)
    $default  reduce using rule 189 (machine_instrn)

    flip_case0      go to state 129
    machine_instrn  go to state 130


state 77

   11 machine_code_sequence: machine_code_sequence P_UNSIGNED_INTEGER  ':'

    ':'  shift, and go to state 131


state 78

   13 machine_code_sequence: machine_code_sequence CAPTION 

    $default  reduce using rule 13 (machine_code_sequence)


state 79

   10 machine_code_sequence: machine_code_sequence COMMENT  NEWLINE

    NEWLINE  shift, and go to state 132


state 80

   12 machine_code_sequence: machine_code_sequence NEWLINE 

    $default  reduce using rule 12 (machine_code_sequence)


state 81

    9 machine_code_sequence: machine_code_sequence flip_case1  '*' machine_instrn flip_case0 separator

    '*'  shift, and go to state 133


state 82

   16 single_statement: unconditional_instrn if_or_unless  condition separator

    '-'  shift, and go to state 84
    '('  shift, and go to state 85
    '+'  shift, and go to state 86

    '('       [reduce using rule 59 (plus_p)]
    $default  reduce using rule 59 (plus_p)

    plus_p       go to state 87
    condition    go to state 134
    simple_cond  go to state 89


state 83

   14 single_statement: unconditional_instrn separator 

    $default  reduce using rule 14 (single_statement)


state 84

   58 plus_p: '-' 

    $default  reduce using rule 58 (plus_p)


state 85

  135 simple_cond: '('  or_cond ')'

    '-'  shift, and go to state 84
    '('  shift, and go to state 85
    '+'  shift, and go to state 86

    '('       [reduce using rule 59 (plus_p)]
    $default  reduce using rule 59 (plus_p)

    plus_p       go to state 87
    or_cond      go to state 135
    simple_cond  go to state 136


state 86

   57 plus_p: '+' 

    $default  reduce using rule 57 (plus_p)


state 87

  133 simple_cond: plus_p  exprn comparator plus_p exprn
  134            | plus_p  exprn comparator plus_p exprn comparator plus_p exprn

    P_UNSIGNED_INTEGER  shift, and go to state 137
    IDENTIFIER          shift, and go to state 138
    '('                 shift, and go to state 139
    '|'                 shift, and go to state 140

    exprn     go to state 141
    operand   go to state 142
    constant  go to state 143


state 88

   15 single_statement: if_or_unless condition  THEN unconditional_instrn separator

    THEN  shift, and go to state 144


state 89

  124 condition: simple_cond  AND and_cond
  125          | simple_cond  OR or_cond
  126          | simple_cond 

    AND  shift, and go to state 145
    OR   shift, and go to state 146

    $default  reduce using rule 126 (condition)


state 90

   19 single_statement: type name_list  separator
   92 name_list: name_list  ',' IDENTIFIER

    NEWLINE  shift, and go to state 26
    ','      shift, and go to state 111
    ';'      shift, and go to state 29

    separator  go to state 147


state 91

   20 single_statement: type_p ARRAY  array_list separator

    IDENTIFIER  shift, and go to state 65

    name_list   go to state 148
    array_list  go to state 149


state 92

   22 single_statement: rt SPEC  IDENTIFIER formal_parameter_defn_p separator

    IDENTIFIER  shift, and go to state 150


state 93

   24 single_statement: rt IDENTIFIER  formal_parameter_defn_p separator

    '('  shift, and go to state 108

    $default  reduce using rule 114 (formal_parameter_defn_p)

    fp_start                 go to state 109
    formal_parameter_defn_p  go to state 151


state 94

   38 single_statement: COMPILE ARRAY BOUND  CHECKS separator

    CHECKS  shift, and go to state 152


state 95

   29 single_statement: COMPILE QUERIES separator 

    $default  reduce using rule 29 (single_statement)


state 96

   17 single_statement: CYCLE IDENTIFIER '='  plus_p exprn ',' plus_p exprn ',' plus_p exprn separator

    '-'  shift, and go to state 84
    '+'  shift, and go to state 86

    $default  reduce using rule 59 (plus_p)

    plus_p  go to state 153


state 97

   34 single_statement: END OF LIST  separator

    NEWLINE  shift, and go to state 26
    ';'      shift, and go to state 29

    separator  go to state 154


state 98

   36 single_statement: END OF M  CODE separator

    CODE  shift, and go to state 155


state 99

   40 single_statement: END OF PERM  separator

    NEWLINE  shift, and go to state 26
    ';'      shift, and go to state 29

    separator  go to state 156


state 100

   43 single_statement: END OF PROGRAM  NEWLINE

    NEWLINE  shift, and go to state 157


state 101

  143 rest_of_N_list: ','  P_UNSIGNED_INTEGER

    P_UNSIGNED_INTEGER  shift, and go to state 158


state 102

  142 fault_list: P_UNSIGNED_INTEGER rest_of_N_list  '-' '>' P_UNSIGNED_INTEGER rest_of_fault_list

    '-'  shift, and go to state 159


state 103

   41 single_statement: FAULT fault_list separator 

    $default  reduce using rule 41 (single_statement)


state 104

   39 single_statement: IGNORE ARRAY BOUND  CHECKS separator

    CHECKS  shift, and go to state 160


state 105

   30 single_statement: IGNORE QUERIES separator 

    $default  reduce using rule 30 (single_statement)


state 106

   35 single_statement: M CODE separator 

    $default  reduce using rule 35 (single_statement)


state 107

   51 unconditional_instrn: RESULT '=' plus_p  exprn

    P_UNSIGNED_INTEGER  shift, and go to state 137
    IDENTIFIER          shift, and go to state 138
    '('                 shift, and go to state 139
    '|'                 shift, and go to state 140

    exprn     go to state 161
    operand   go to state 142
    constant  go to state 143


state 108

  112 fp_start: '(' 

    $default  reduce using rule 112 (fp_start)


state 109

  113 formal_parameter_defn_p: fp_start  fp_list ')'

    ADDR  shift, and go to state 162
    ','   shift, and go to state 163

    $default  reduce using rule 83 (comma_p)

    comma_p       go to state 164
    fp_list_part  go to state 165
    fp_list       go to state 166
    fp_delimiter  go to state 167


state 110

   23 single_statement: SPEC IDENTIFIER formal_parameter_defn_p  separator

    NEWLINE  shift, and go to state 26
    ';'      shift, and go to state 29

    separator  go to state 168


state 111

   92 name_list: name_list ','  IDENTIFIER

    IDENTIFIER  shift, and go to state 169


state 112

  104 switch_list: name_list '('  switch_bounds ')' rest_of_switch_list

    P_UNSIGNED_INTEGER  shift, and go to state 170
    '-'                 shift, and go to state 171
    '+'                 shift, and go to state 86

    P_UNSIGNED_INTEGER  [reduce using rule 59 (plus_p)]

    plus_p         go to state 172
    switch_bounds  go to state 173


state 113

   21 single_statement: SWITCH switch_list separator 

    $default  reduce using rule 21 (single_statement)


state 114

   74 act_param: plus_p  exprn

    P_UNSIGNED_INTEGER  shift, and go to state 137
    IDENTIFIER          shift, and go to state 138
    '('                 shift, and go to state 139
    '|'                 shift, and go to state 140

    exprn     go to state 174
    operand   go to state 142
    constant  go to state 143


state 115

   78 list_of_actual_parameters: act_param 

    $default  reduce using rule 78 (list_of_actual_parameters)


state 116

   75 actual_parameters_p: ap_start list_of_actual_parameters  ')'
   77 list_of_actual_parameters: list_of_actual_parameters  ',' act_param

    ','  shift, and go to state 175
    ')'  shift, and go to state 176


state 117

   28 single_statement: IDENTIFIER actual_parameters ':' 

    $default  reduce using rule 28 (single_statement)


state 118

   44 unconditional_instrn: IDENTIFIER actual_parameters '='  plus_p exprn query_p

    '-'  shift, and go to state 84
    '+'  shift, and go to state 86

    $default  reduce using rule 59 (plus_p)

    plus_p  go to state 177


state 119

   32 single_statement: '!' P_COMMENT_TEXT separator 

    $default  reduce using rule 32 (single_statement)


state 120

   46 unconditional_instrn: '-' '>' P_UNSIGNED_INTEGER 

    $default  reduce using rule 46 (unconditional_instrn)


state 121

   47 unconditional_instrn: '-' '>' IDENTIFIER  '(' plus_p exprn ')'

    '('  shift, and go to state 178


state 122

  188 machine_instrn: P_UNSIGNED_INTEGER  '/' P_UNSIGNED_INTEGER '/' P_UNSIGNED_INTEGER

    '/'  shift, and go to state 179


state 123

  149 machine_instrn: IDENTIFIER  ':'
  150               | IDENTIFIER  P_UNSIGNED_INTEGER ':'
  151               | IDENTIFIER  IDENTIFIER P_UNSIGNED_INTEGER
  156               | IDENTIFIER 
  158               | IDENTIFIER  P_UNSIGNED_INTEGER
  161               | IDENTIFIER  P_UNSIGNED_INTEGER IDENTIFIER P_UNSIGNED_INTEGER
  163               | IDENTIFIER  P_UNSIGNED_INTEGER IDENTIFIER P_UNSIGNED_INTEGER IDENTIFIER
  165               | IDENTIFIER  P_UNSIGNED_INTEGER IDENTIFIER IDENTIFIER P_UNSIGNED_INTEGER
  166               | IDENTIFIER  '-' P_UNSIGNED_INTEGER
  167               | IDENTIFIER  '+' P_UNSIGNED_INTEGER
  168               | IDENTIFIER  P_UNSIGNED_INTEGER '=' IDENTIFIER
  169               | IDENTIFIER  P_UNSIGNED_INTEGER '>' IDENTIFIER
  170               | IDENTIFIER  P_UNSIGNED_INTEGER '>' '=' IDENTIFIER
  171               | IDENTIFIER  P_UNSIGNED_INTEGER '<' '=' IDENTIFIER
  172               | IDENTIFIER  P_UNSIGNED_INTEGER '<' IDENTIFIER
  173               | IDENTIFIER  P_UNSIGNED_INTEGER '#' IDENTIFIER
  174               | IDENTIFIER  P_UNSIGNED_INTEGER '#'
  175               | IDENTIFIER  P_UNSIGNED_INTEGER '='
  176               | IDENTIFIER  P_UNSIGNED_INTEGER IDENTIFIER
  183               | IDENTIFIER  '-' IDENTIFIER P_UNSIGNED_INTEGER
  184               | IDENTIFIER  '+' IDENTIFIER P_UNSIGNED_INTEGER
  185               | IDENTIFIER  P_UNSIGNED_INTEGER '=' '-' P_UNSIGNED_INTEGER
  186               | IDENTIFIER  P_UNSIGNED_INTEGER '=' '+' P_UNSIGNED_INTEGER
  187               | IDENTIFIER  P_UNSIGNED_INTEGER '=' P_UNSIGNED_INTEGER

    P_UNSIGNED_INTEGER  shift, and go to state 180
    IDENTIFIER          shift, and go to state 181
    ':'                 shift, and go to state 182
    '-'                 shift, and go to state 183
    '+'                 shift, and go to state 184

    $default  reduce using rule 156 (machine_instrn)


state 124

    8 machine_code_sequence: flip_case1z '*' '?'  '?' '?' '?' flip_case0 separator

    '?'  shift, and go to state 185


state 125

  157 machine_instrn: '='  IDENTIFIER
  159               | '='  IDENTIFIER P_UNSIGNED_INTEGER
  160               | '='  '+' IDENTIFIER P_UNSIGNED_INTEGER
  162               | '='  IDENTIFIER P_UNSIGNED_INTEGER IDENTIFIER P_UNSIGNED_INTEGER
  164               | '='  IDENTIFIER P_UNSIGNED_INTEGER IDENTIFIER P_UNSIGNED_INTEGER IDENTIFIER

    IDENTIFIER  shift, and go to state 186
    '+'         shift, and go to state 187


state 126

  177 machine_instrn: '-' 
  178               | '-'  IDENTIFIER

    IDENTIFIER  shift, and go to state 188

    $default  reduce using rule 177 (machine_instrn)


state 127

  179 machine_instrn: '+' 
  180               | '+'  IDENTIFIER

    IDENTIFIER  shift, and go to state 189

    $default  reduce using rule 179 (machine_instrn)


state 128

  181 machine_instrn: '/' 
  182               | '/'  IDENTIFIER

    IDENTIFIER  shift, and go to state 190

    $default  reduce using rule 181 (machine_instrn)


state 129

  152 machine_instrn: flip_case0  '*' '`' IDENTIFIER actual_parameters
  153               | flip_case0  '*' '@' IDENTIFIER actual_parameters
  154               | flip_case0  '*' operand
  155               | flip_case0  '*' '=' IDENTIFIER actual_parameters

    '*'  shift, and go to state 191


state 130

    7 machine_code_sequence: flip_case1z '*' machine_instrn  flip_case0 separator

    $default  reduce using rule 6 (flip_case0)

    flip_case0  go to state 192


state 131

   11 machine_code_sequence: machine_code_sequence P_UNSIGNED_INTEGER ':' 

    $default  reduce using rule 11 (machine_code_sequence)


state 132

   10 machine_code_sequence: machine_code_sequence COMMENT NEWLINE 

    $default  reduce using rule 10 (machine_code_sequence)


state 133

    9 machine_code_sequence: machine_code_sequence flip_case1 '*'  machine_instrn flip_case0 separator

    P_UNSIGNED_INTEGER  shift, and go to state 122
    IDENTIFIER          shift, and go to state 123
    '='                 shift, and go to state 125
    '-'                 shift, and go to state 126
    '+'                 shift, and go to state 127
    '/'                 shift, and go to state 128

    '*'       reduce using rule 6 (flip_case0)
    $default  reduce using rule 189 (machine_instrn)

    flip_case0      go to state 129
    machine_instrn  go to state 193


state 134

   16 single_statement: unconditional_instrn if_or_unless condition  separator

    NEWLINE  shift, and go to state 26
    ';'      shift, and go to state 29

    separator  go to state 194


state 135

  135 simple_cond: '(' or_cond  ')'

    ')'  shift, and go to state 195


state 136

  130 or_cond: simple_cond  rest_of_or_cond

    OR  shift, and go to state 196

    $default  reduce using rule 132 (rest_of_or_cond)

    rest_of_or_cond  go to state 197


state 137

  191 constant: P_UNSIGNED_INTEGER 

    $default  reduce using rule 191 (constant)


state 138

   64 operand: IDENTIFIER  actual_parameters_p

    '('  shift, and go to state 68

    '('       [reduce using rule 76 (actual_parameters_p)]
    $default  reduce using rule 76 (actual_parameters_p)

    ap_start             go to state 69
    actual_parameters_p  go to state 198


state 139

   66 operand: '('  plus_p exprn ')'

    '-'  shift, and go to state 84
    '+'  shift, and go to state 86

    $default  reduce using rule 59 (plus_p)

    plus_p  go to state 199


state 140

   61 exprn: '|'  operand '|'

    P_UNSIGNED_INTEGER  shift, and go to state 137
    IDENTIFIER          shift, and go to state 138
    '('                 shift, and go to state 139

    operand   go to state 200
    constant  go to state 143


state 141

  133 simple_cond: plus_p exprn  comparator plus_p exprn
  134            | plus_p exprn  comparator plus_p exprn comparator plus_p exprn

    '='  shift, and go to state 201
    '>'  shift, and go to state 202
    '#'  shift, and go to state 203
    '<'  shift, and go to state 204

    comparator  go to state 205


state 142

   60 exprn: operand  rest_of_exprn

    '*'  shift, and go to state 206
    '-'  shift, and go to state 207
    '+'  shift, and go to state 208
    '/'  shift, and go to state 209

    P_UNSIGNED_INTEGER  reduce using rule 72 (operator)
    IDENTIFIER          reduce using rule 72 (operator)
    '('                 reduce using rule 72 (operator)
    $default            reduce using rule 63 (rest_of_exprn)

    rest_of_exprn  go to state 210
    operator       go to state 211


state 143

   65 operand: constant 

    $default  reduce using rule 65 (operand)


state 144

   15 single_statement: if_or_unless condition THEN  unconditional_instrn separator

    CAPTION     shift, and go to state 3
    LITERAL     shift, and go to state 13
    MONITOR     shift, and go to state 15
    RESULT      shift, and go to state 18
    RETURN      shift, and go to state 19
    STOP        shift, and go to state 22
    IDENTIFIER  shift, and go to state 212
    '-'         shift, and go to state 28

    unconditional_instrn  go to state 213


state 145

  124 condition: simple_cond AND  and_cond

    '-'  shift, and go to state 84
    '('  shift, and go to state 85
    '+'  shift, and go to state 86

    '('       [reduce using rule 59 (plus_p)]
    $default  reduce using rule 59 (plus_p)

    plus_p       go to state 87
    and_cond     go to state 214
    simple_cond  go to state 215


state 146

  125 condition: simple_cond OR  or_cond

    '-'  shift, and go to state 84
    '('  shift, and go to state 85
    '+'  shift, and go to state 86

    '('       [reduce using rule 59 (plus_p)]
    $default  reduce using rule 59 (plus_p)

    plus_p       go to state 87
    or_cond      go to state 216
    simple_cond  go to state 136


state 147

   19 single_statement: type name_list separator 

    $default  reduce using rule 19 (single_statement)


state 148

   92 name_list: name_list  ',' IDENTIFIER
   93 array_list: name_list  '(' bound_pair_list ')' rest_of_array_list

    ','  shift, and go to state 111
    '('  shift, and go to state 217


state 149

   20 single_statement: type_p ARRAY array_list  separator

    NEWLINE  shift, and go to state 26
    ';'      shift, and go to state 29

    separator  go to state 218


state 150

   22 single_statement: rt SPEC IDENTIFIER  formal_parameter_defn_p separator

    '('  shift, and go to state 108

    $default  reduce using rule 114 (formal_parameter_defn_p)

    fp_start                 go to state 109
    formal_parameter_defn_p  go to state 219


state 151

   24 single_statement: rt IDENTIFIER formal_parameter_defn_p  separator

    NEWLINE  shift, and go to state 26
    ';'      shift, and go to state 29

    separator  go to state 220


state 152

   38 single_statement: COMPILE ARRAY BOUND CHECKS  separator

    NEWLINE  shift, and go to state 26
    ';'      shift, and go to state 29

    separator  go to state 221


state 153

   17 single_statement: CYCLE IDENTIFIER '=' plus_p  exprn ',' plus_p exprn ',' plus_p exprn separator

    P_UNSIGNED_INTEGER  shift, and go to state 137
    IDENTIFIER          shift, and go to state 138
    '('                 shift, and go to state 139
    '|'                 shift, and go to state 140

    exprn     go to state 222
    operand   go to state 142
    constant  go to state 143


state 154

   34 single_statement: END OF LIST separator 

    $default  reduce using rule 34 (single_statement)


state 155

   36 single_statement: END OF M CODE  separator

    NEWLINE  shift, and go to state 26
    ';'      shift, and go to state 29

    separator  go to state 223


state 156

   40 single_statement: END OF PERM separator 

    $default  reduce using rule 40 (single_statement)


state 157

   43 single_statement: END OF PROGRAM NEWLINE 

    $default  reduce using rule 43 (single_statement)


state 158

  143 rest_of_N_list: ',' P_UNSIGNED_INTEGER 

    $default  reduce using rule 143 (rest_of_N_list)


state 159

  142 fault_list: P_UNSIGNED_INTEGER rest_of_N_list '-'  '>' P_UNSIGNED_INTEGER rest_of_fault_list

    '>'  shift, and go to state 224


state 160

   39 single_statement: IGNORE ARRAY BOUND CHECKS  separator

    NEWLINE  shift, and go to state 26
    ';'      shift, and go to state 29

    separator  go to state 225


state 161

   51 unconditional_instrn: RESULT '=' plus_p exprn 

    $default  reduce using rule 51 (unconditional_instrn)


state 162

  123 fp_delimiter: ADDR 

    $default  reduce using rule 123 (fp_delimiter)


state 163

   82 comma_p: ',' 

    $default  reduce using rule 82 (comma_p)


state 164

  119 fp_delimiter: comma_p  rt
  120             | comma_p  type NAME
  121             | comma_p  type
  122             | comma_p  type_p ARRAY NAME

    INTEGER  shift, and go to state 11
    REAL     shift, and go to state 16
    ROUTINE  shift, and go to state 20

    $default  reduce using rule 90 (type_p)

    type    go to state 226
    type_p  go to state 227
    rt      go to state 228


state 165

  116 fp_list: fp_list_part  rest_of_fp_list

    ';'  shift, and go to state 229

    $default  reduce using rule 118 (rest_of_fp_list)

    rest_of_fp_list  go to state 230


state 166

  113 formal_parameter_defn_p: fp_start fp_list  ')'

    ')'  shift, and go to state 231


state 167

  115 fp_list_part: fp_delimiter  name_list

    IDENTIFIER  shift, and go to state 65

    name_list  go to state 232


state 168

   23 single_statement: SPEC IDENTIFIER formal_parameter_defn_p separator 

    $default  reduce using rule 23 (single_statement)


state 169

   92 name_list: name_list ',' IDENTIFIER 

    $default  reduce using rule 92 (name_list)


state 170

  101 switch_bounds: P_UNSIGNED_INTEGER  ':' P_UNSIGNED_INTEGER

    ':'  shift, and go to state 233


state 171

   58 plus_p: '-' 
  102 switch_bounds: '-'  P_UNSIGNED_INTEGER ':' P_UNSIGNED_INTEGER

    P_UNSIGNED_INTEGER  shift, and go to state 234

    P_UNSIGNED_INTEGER  [reduce using rule 58 (plus_p)]


state 172

  103 switch_bounds: plus_p  constant ':' plus_p constant

    P_UNSIGNED_INTEGER  shift, and go to state 137

    constant  go to state 235


state 173

  104 switch_list: name_list '(' switch_bounds  ')' rest_of_switch_list

    ')'  shift, and go to state 236


state 174

   74 act_param: plus_p exprn 

    $default  reduce using rule 74 (act_param)


state 175

   77 list_of_actual_parameters: list_of_actual_parameters ','  act_param

    '-'  shift, and go to state 84
    '+'  shift, and go to state 86

    $default  reduce using rule 59 (plus_p)

    plus_p     go to state 114
    act_param  go to state 237


state 176

   75 actual_parameters_p: ap_start list_of_actual_parameters ')' 

    $default  reduce using rule 75 (actual_parameters_p)


state 177

   44 unconditional_instrn: IDENTIFIER actual_parameters '=' plus_p  exprn query_p

    P_UNSIGNED_INTEGER  shift, and go to state 137
    IDENTIFIER          shift, and go to state 138
    '('                 shift, and go to state 139
    '|'                 shift, and go to state 140

    exprn     go to state 238
    operand   go to state 142
    constant  go to state 143


state 178

   47 unconditional_instrn: '-' '>' IDENTIFIER '('  plus_p exprn ')'

    '-'  shift, and go to state 84
    '+'  shift, and go to state 86

    $default  reduce using rule 59 (plus_p)

    plus_p  go to state 239


state 179

  188 machine_instrn: P_UNSIGNED_INTEGER '/'  P_UNSIGNED_INTEGER '/' P_UNSIGNED_INTEGER

    P_UNSIGNED_INTEGER  shift, and go to state 240


state 180

  150 machine_instrn: IDENTIFIER P_UNSIGNED_INTEGER  ':'
  158               | IDENTIFIER P_UNSIGNED_INTEGER 
  161               | IDENTIFIER P_UNSIGNED_INTEGER  IDENTIFIER P_UNSIGNED_INTEGER
  163               | IDENTIFIER P_UNSIGNED_INTEGER  IDENTIFIER P_UNSIGNED_INTEGER IDENTIFIER
  165               | IDENTIFIER P_UNSIGNED_INTEGER  IDENTIFIER IDENTIFIER P_UNSIGNED_INTEGER
  168               | IDENTIFIER P_UNSIGNED_INTEGER  '=' IDENTIFIER
  169               | IDENTIFIER P_UNSIGNED_INTEGER  '>' IDENTIFIER
  170               | IDENTIFIER P_UNSIGNED_INTEGER  '>' '=' IDENTIFIER
  171               | IDENTIFIER P_UNSIGNED_INTEGER  '<' '=' IDENTIFIER
  172               | IDENTIFIER P_UNSIGNED_INTEGER  '<' IDENTIFIER
  173               | IDENTIFIER P_UNSIGNED_INTEGER  '#' IDENTIFIER
  174               | IDENTIFIER P_UNSIGNED_INTEGER  '#'
  175               | IDENTIFIER P_UNSIGNED_INTEGER  '='
  176               | IDENTIFIER P_UNSIGNED_INTEGER  IDENTIFIER
  185               | IDENTIFIER P_UNSIGNED_INTEGER  '=' '-' P_UNSIGNED_INTEGER
  186               | IDENTIFIER P_UNSIGNED_INTEGER  '=' '+' P_UNSIGNED_INTEGER
  187               | IDENTIFIER P_UNSIGNED_INTEGER  '=' P_UNSIGNED_INTEGER

    IDENTIFIER  shift, and go to state 241
    ':'         shift, and go to state 242
    '='         shift, and go to state 243
    '>'         shift, and go to state 244
    '#'         shift, and go to state 245
    '<'         shift, and go to state 246

    $default  reduce using rule 158 (machine_instrn)


state 181

  151 machine_instrn: IDENTIFIER IDENTIFIER  P_UNSIGNED_INTEGER

    P_UNSIGNED_INTEGER  shift, and go to state 247


state 182

  149 machine_instrn: IDENTIFIER ':' 

    $default  reduce using rule 149 (machine_instrn)


state 183

  166 machine_instrn: IDENTIFIER '-'  P_UNSIGNED_INTEGER
  183               | IDENTIFIER '-'  IDENTIFIER P_UNSIGNED_INTEGER

    P_UNSIGNED_INTEGER  shift, and go to state 248
    IDENTIFIER          shift, and go to state 249


state 184

  167 machine_instrn: IDENTIFIER '+'  P_UNSIGNED_INTEGER
  184               | IDENTIFIER '+'  IDENTIFIER P_UNSIGNED_INTEGER

    P_UNSIGNED_INTEGER  shift, and go to state 250
    IDENTIFIER          shift, and go to state 251


state 185

    8 machine_code_sequence: flip_case1z '*' '?' '?'  '?' '?' flip_case0 separator

    '?'  shift, and go to state 252


state 186

  157 machine_instrn: '=' IDENTIFIER 
  159               | '=' IDENTIFIER  P_UNSIGNED_INTEGER
  162               | '=' IDENTIFIER  P_UNSIGNED_INTEGER IDENTIFIER P_UNSIGNED_INTEGER
  164               | '=' IDENTIFIER  P_UNSIGNED_INTEGER IDENTIFIER P_UNSIGNED_INTEGER IDENTIFIER

    P_UNSIGNED_INTEGER  shift, and go to state 253

    $default  reduce using rule 157 (machine_instrn)


state 187

  160 machine_instrn: '=' '+'  IDENTIFIER P_UNSIGNED_INTEGER

    IDENTIFIER  shift, and go to state 254


state 188

  178 machine_instrn: '-' IDENTIFIER 

    $default  reduce using rule 178 (machine_instrn)


state 189

  180 machine_instrn: '+' IDENTIFIER 

    $default  reduce using rule 180 (machine_instrn)


state 190

  182 machine_instrn: '/' IDENTIFIER 

    $default  reduce using rule 182 (machine_instrn)


state 191

  152 machine_instrn: flip_case0 '*'  '`' IDENTIFIER actual_parameters
  153               | flip_case0 '*'  '@' IDENTIFIER actual_parameters
  154               | flip_case0 '*'  operand
  155               | flip_case0 '*'  '=' IDENTIFIER actual_parameters

    P_UNSIGNED_INTEGER  shift, and go to state 137
    IDENTIFIER          shift, and go to state 138
    '='                 shift, and go to state 255
    '('                 shift, and go to state 139
    '`'                 shift, and go to state 256
    '@'                 shift, and go to state 257

    operand   go to state 258
    constant  go to state 143


state 192

    7 machine_code_sequence: flip_case1z '*' machine_instrn flip_case0  separator

    NEWLINE  shift, and go to state 26
    ';'      shift, and go to state 29

    separator  go to state 259


state 193

    9 machine_code_sequence: machine_code_sequence flip_case1 '*' machine_instrn  flip_case0 separator

    $default  reduce using rule 6 (flip_case0)

    flip_case0  go to state 260


state 194

   16 single_statement: unconditional_instrn if_or_unless condition separator 

    $default  reduce using rule 16 (single_statement)


state 195

  135 simple_cond: '(' or_cond ')' 

    $default  reduce using rule 135 (simple_cond)


state 196

  131 rest_of_or_cond: OR  or_cond

    '-'  shift, and go to state 84
    '('  shift, and go to state 85
    '+'  shift, and go to state 86

    '('       [reduce using rule 59 (plus_p)]
    $default  reduce using rule 59 (plus_p)

    plus_p       go to state 87
    or_cond      go to state 261
    simple_cond  go to state 136


state 197

  130 or_cond: simple_cond rest_of_or_cond 

    $default  reduce using rule 130 (or_cond)


state 198

   64 operand: IDENTIFIER actual_parameters_p 

    $default  reduce using rule 64 (operand)


state 199

   66 operand: '(' plus_p  exprn ')'

    P_UNSIGNED_INTEGER  shift, and go to state 137
    IDENTIFIER          shift, and go to state 138
    '('                 shift, and go to state 139
    '|'                 shift, and go to state 140

    exprn     go to state 262
    operand   go to state 142
    constant  go to state 143


state 200

   61 exprn: '|' operand  '|'

    '|'  shift, and go to state 263


state 201

  136 comparator: '=' 

    $default  reduce using rule 136 (comparator)


state 202

  140 comparator: '>'  '='
  141           | '>' 

    '='  shift, and go to state 264

    $default  reduce using rule 141 (comparator)


state 203

  137 comparator: '#' 

    $default  reduce using rule 137 (comparator)


state 204

  138 comparator: '<'  '='
  139           | '<' 

    '='  shift, and go to state 265

    $default  reduce using rule 139 (comparator)


state 205

  133 simple_cond: plus_p exprn comparator  plus_p exprn
  134            | plus_p exprn comparator  plus_p exprn comparator plus_p exprn

    '-'  shift, and go to state 84
    '+'  shift, and go to state 86

    $default  reduce using rule 59 (plus_p)

    plus_p  go to state 266


state 206

   69 operator: '*' 
   71         | '*'  '*'

    '*'  shift, and go to state 267

    $default  reduce using rule 69 (operator)


state 207

   68 operator: '-' 

    $default  reduce using rule 68 (operator)


state 208

   67 operator: '+' 

    $default  reduce using rule 67 (operator)


state 209

   70 operator: '/' 

    $default  reduce using rule 70 (operator)


state 210

   60 exprn: operand rest_of_exprn 

    $default  reduce using rule 60 (exprn)


state 211

   62 rest_of_exprn: operator  operand rest_of_exprn

    P_UNSIGNED_INTEGER  shift, and go to state 137
    IDENTIFIER          shift, and go to state 138
    '('                 shift, and go to state 139

    operand   go to state 268
    constant  go to state 143


state 212

   44 unconditional_instrn: IDENTIFIER  actual_parameters '=' plus_p exprn query_p
   45                     | IDENTIFIER  actual_parameters

    '('  shift, and go to state 68

    $default  reduce using rule 76 (actual_parameters_p)

    ap_start             go to state 69
    actual_parameters_p  go to state 70
    actual_parameters    go to state 269


state 213

   15 single_statement: if_or_unless condition THEN unconditional_instrn  separator

    NEWLINE  shift, and go to state 26
    ';'      shift, and go to state 29

    separator  go to state 270


state 214

  124 condition: simple_cond AND and_cond 

    $default  reduce using rule 124 (condition)


state 215

  127 and_cond: simple_cond  rest_of_and_cond

    AND  shift, and go to state 271

    $default  reduce using rule 129 (rest_of_and_cond)

    rest_of_and_cond  go to state 272


state 216

  125 condition: simple_cond OR or_cond 

    $default  reduce using rule 125 (condition)


state 217

   93 array_list: name_list '('  bound_pair_list ')' rest_of_array_list

    '-'  shift, and go to state 84
    '+'  shift, and go to state 86

    $default  reduce using rule 59 (plus_p)

    plus_p           go to state 273
    bound_pair_list  go to state 274


state 218

   20 single_statement: type_p ARRAY array_list separator 

    $default  reduce using rule 20 (single_statement)


state 219

   22 single_statement: rt SPEC IDENTIFIER formal_parameter_defn_p  separator

    NEWLINE  shift, and go to state 26
    ';'      shift, and go to state 29

    separator  go to state 275


state 220

   24 single_statement: rt IDENTIFIER formal_parameter_defn_p separator 

    $default  reduce using rule 24 (single_statement)


state 221

   38 single_statement: COMPILE ARRAY BOUND CHECKS separator 

    $default  reduce using rule 38 (single_statement)


state 222

   17 single_statement: CYCLE IDENTIFIER '=' plus_p exprn  ',' plus_p exprn ',' plus_p exprn separator

    ','  shift, and go to state 276


state 223

   36 single_statement: END OF M CODE separator 

    $default  reduce using rule 36 (single_statement)


state 224

  142 fault_list: P_UNSIGNED_INTEGER rest_of_N_list '-' '>'  P_UNSIGNED_INTEGER rest_of_fault_list

    P_UNSIGNED_INTEGER  shift, and go to state 277


state 225

   39 single_statement: IGNORE ARRAY BOUND CHECKS separator 

    $default  reduce using rule 39 (single_statement)


state 226

  120 fp_delimiter: comma_p type  NAME
  121             | comma_p type 

    NAME  shift, and go to state 278

    $default  reduce using rule 121 (fp_delimiter)


state 227

  122 fp_delimiter: comma_p type_p  ARRAY NAME

    ARRAY  shift, and go to state 279


state 228

  119 fp_delimiter: comma_p rt 

    $default  reduce using rule 119 (fp_delimiter)


state 229

  117 rest_of_fp_list: ';'  fp_list

    ADDR  shift, and go to state 162
    ','   shift, and go to state 163

    $default  reduce using rule 83 (comma_p)

    comma_p       go to state 164
    fp_list_part  go to state 165
    fp_list       go to state 280
    fp_delimiter  go to state 167


state 230

  116 fp_list: fp_list_part rest_of_fp_list 

    $default  reduce using rule 116 (fp_list)


state 231

  113 formal_parameter_defn_p: fp_start fp_list ')' 

    $default  reduce using rule 113 (formal_parameter_defn_p)


state 232

   92 name_list: name_list  ',' IDENTIFIER
  115 fp_list_part: fp_delimiter name_list 

    ','  shift, and go to state 111

    $default  reduce using rule 115 (fp_list_part)


state 233

  101 switch_bounds: P_UNSIGNED_INTEGER ':'  P_UNSIGNED_INTEGER

    P_UNSIGNED_INTEGER  shift, and go to state 281


state 234

  102 switch_bounds: '-' P_UNSIGNED_INTEGER  ':' P_UNSIGNED_INTEGER

    ':'  shift, and go to state 282


state 235

  103 switch_bounds: plus_p constant  ':' plus_p constant

    ':'  shift, and go to state 283


state 236

  104 switch_list: name_list '(' switch_bounds ')'  rest_of_switch_list

    ','  shift, and go to state 284

    $default  reduce using rule 106 (rest_of_switch_list)

    rest_of_switch_list  go to state 285


state 237

   77 list_of_actual_parameters: list_of_actual_parameters ',' act_param 

    $default  reduce using rule 77 (list_of_actual_parameters)


state 238

   44 unconditional_instrn: IDENTIFIER actual_parameters '=' plus_p exprn  query_p

    '?'  shift, and go to state 286

    $default  reduce using rule 81 (query_p)

    query_p  go to state 287


state 239

   47 unconditional_instrn: '-' '>' IDENTIFIER '(' plus_p  exprn ')'

    P_UNSIGNED_INTEGER  shift, and go to state 137
    IDENTIFIER          shift, and go to state 138
    '('                 shift, and go to state 139
    '|'                 shift, and go to state 140

    exprn     go to state 288
    operand   go to state 142
    constant  go to state 143


state 240

  188 machine_instrn: P_UNSIGNED_INTEGER '/' P_UNSIGNED_INTEGER  '/' P_UNSIGNED_INTEGER

    '/'  shift, and go to state 289


state 241

  161 machine_instrn: IDENTIFIER P_UNSIGNED_INTEGER IDENTIFIER  P_UNSIGNED_INTEGER
  163               | IDENTIFIER P_UNSIGNED_INTEGER IDENTIFIER  P_UNSIGNED_INTEGER IDENTIFIER
  165               | IDENTIFIER P_UNSIGNED_INTEGER IDENTIFIER  IDENTIFIER P_UNSIGNED_INTEGER
  176               | IDENTIFIER P_UNSIGNED_INTEGER IDENTIFIER 

    P_UNSIGNED_INTEGER  shift, and go to state 290
    IDENTIFIER          shift, and go to state 291

    $default  reduce using rule 176 (machine_instrn)


state 242

  150 machine_instrn: IDENTIFIER P_UNSIGNED_INTEGER ':' 

    $default  reduce using rule 150 (machine_instrn)


state 243

  168 machine_instrn: IDENTIFIER P_UNSIGNED_INTEGER '='  IDENTIFIER
  175               | IDENTIFIER P_UNSIGNED_INTEGER '=' 
  185               | IDENTIFIER P_UNSIGNED_INTEGER '='  '-' P_UNSIGNED_INTEGER
  186               | IDENTIFIER P_UNSIGNED_INTEGER '='  '+' P_UNSIGNED_INTEGER
  187               | IDENTIFIER P_UNSIGNED_INTEGER '='  P_UNSIGNED_INTEGER

    P_UNSIGNED_INTEGER  shift, and go to state 292
    IDENTIFIER          shift, and go to state 293
    '-'                 shift, and go to state 294
    '+'                 shift, and go to state 295

    $default  reduce using rule 175 (machine_instrn)


state 244

  169 machine_instrn: IDENTIFIER P_UNSIGNED_INTEGER '>'  IDENTIFIER
  170               | IDENTIFIER P_UNSIGNED_INTEGER '>'  '=' IDENTIFIER

    IDENTIFIER  shift, and go to state 296
    '='         shift, and go to state 297


state 245

  173 machine_instrn: IDENTIFIER P_UNSIGNED_INTEGER '#'  IDENTIFIER
  174               | IDENTIFIER P_UNSIGNED_INTEGER '#' 

    IDENTIFIER  shift, and go to state 298

    $default  reduce using rule 174 (machine_instrn)


state 246

  171 machine_instrn: IDENTIFIER P_UNSIGNED_INTEGER '<'  '=' IDENTIFIER
  172               | IDENTIFIER P_UNSIGNED_INTEGER '<'  IDENTIFIER

    IDENTIFIER  shift, and go to state 299
    '='         shift, and go to state 300


state 247

  151 machine_instrn: IDENTIFIER IDENTIFIER P_UNSIGNED_INTEGER 

    $default  reduce using rule 151 (machine_instrn)


state 248

  166 machine_instrn: IDENTIFIER '-' P_UNSIGNED_INTEGER 

    $default  reduce using rule 166 (machine_instrn)


state 249

  183 machine_instrn: IDENTIFIER '-' IDENTIFIER  P_UNSIGNED_INTEGER

    P_UNSIGNED_INTEGER  shift, and go to state 301


state 250

  167 machine_instrn: IDENTIFIER '+' P_UNSIGNED_INTEGER 

    $default  reduce using rule 167 (machine_instrn)


state 251

  184 machine_instrn: IDENTIFIER '+' IDENTIFIER  P_UNSIGNED_INTEGER

    P_UNSIGNED_INTEGER  shift, and go to state 302


state 252

    8 machine_code_sequence: flip_case1z '*' '?' '?' '?'  '?' flip_case0 separator

    '?'  shift, and go to state 303


state 253

  159 machine_instrn: '=' IDENTIFIER P_UNSIGNED_INTEGER 
  162               | '=' IDENTIFIER P_UNSIGNED_INTEGER  IDENTIFIER P_UNSIGNED_INTEGER
  164               | '=' IDENTIFIER P_UNSIGNED_INTEGER  IDENTIFIER P_UNSIGNED_INTEGER IDENTIFIER

    IDENTIFIER  shift, and go to state 304

    $default  reduce using rule 159 (machine_instrn)


state 254

  160 machine_instrn: '=' '+' IDENTIFIER  P_UNSIGNED_INTEGER

    P_UNSIGNED_INTEGER  shift, and go to state 305


state 255

  155 machine_instrn: flip_case0 '*' '='  IDENTIFIER actual_parameters

    IDENTIFIER  shift, and go to state 306


state 256

  152 machine_instrn: flip_case0 '*' '`'  IDENTIFIER actual_parameters

    IDENTIFIER  shift, and go to state 307


state 257

  153 machine_instrn: flip_case0 '*' '@'  IDENTIFIER actual_parameters

    IDENTIFIER  shift, and go to state 308


state 258

  154 machine_instrn: flip_case0 '*' operand 

    $default  reduce using rule 154 (machine_instrn)


state 259

    7 machine_code_sequence: flip_case1z '*' machine_instrn flip_case0 separator 

    $default  reduce using rule 7 (machine_code_sequence)


state 260

    9 machine_code_sequence: machine_code_sequence flip_case1 '*' machine_instrn flip_case0  separator

    NEWLINE  shift, and go to state 26
    ';'      shift, and go to state 29

    separator  go to state 309


state 261

  131 rest_of_or_cond: OR or_cond 

    $default  reduce using rule 131 (rest_of_or_cond)


state 262

   66 operand: '(' plus_p exprn  ')'

    ')'  shift, and go to state 310


state 263

   61 exprn: '|' operand '|' 

    $default  reduce using rule 61 (exprn)


state 264

  140 comparator: '>' '=' 

    $default  reduce using rule 140 (comparator)


state 265

  138 comparator: '<' '=' 

    $default  reduce using rule 138 (comparator)


state 266

  133 simple_cond: plus_p exprn comparator plus_p  exprn
  134            | plus_p exprn comparator plus_p  exprn comparator plus_p exprn

    P_UNSIGNED_INTEGER  shift, and go to state 137
    IDENTIFIER          shift, and go to state 138
    '('                 shift, and go to state 139
    '|'                 shift, and go to state 140

    exprn     go to state 311
    operand   go to state 142
    constant  go to state 143


state 267

   71 operator: '*' '*' 

    $default  reduce using rule 71 (operator)


state 268

   62 rest_of_exprn: operator operand  rest_of_exprn

    '*'  shift, and go to state 206
    '-'  shift, and go to state 207
    '+'  shift, and go to state 208
    '/'  shift, and go to state 209

    P_UNSIGNED_INTEGER  reduce using rule 72 (operator)
    IDENTIFIER          reduce using rule 72 (operator)
    '('                 reduce using rule 72 (operator)
    $default            reduce using rule 63 (rest_of_exprn)

    rest_of_exprn  go to state 312
    operator       go to state 211


state 269

   44 unconditional_instrn: IDENTIFIER actual_parameters  '=' plus_p exprn query_p
   45                     | IDENTIFIER actual_parameters 

    '='  shift, and go to state 118

    $default  reduce using rule 45 (unconditional_instrn)


state 270

   15 single_statement: if_or_unless condition THEN unconditional_instrn separator 

    $default  reduce using rule 15 (single_statement)


state 271

  128 rest_of_and_cond: AND  and_cond

    '-'  shift, and go to state 84
    '('  shift, and go to state 85
    '+'  shift, and go to state 86

    '('       [reduce using rule 59 (plus_p)]
    $default  reduce using rule 59 (plus_p)

    plus_p       go to state 87
    and_cond     go to state 313
    simple_cond  go to state 215


state 272

  127 and_cond: simple_cond rest_of_and_cond 

    $default  reduce using rule 127 (and_cond)


state 273

   96 bound_pair_list: plus_p  exprn ':' plus_p exprn rest_of_bp_list
   97                | plus_p  P_UNSIGNED_INTEGER ':' plus_p exprn rest_of_bp_list
   98                | plus_p  P_UNSIGNED_INTEGER ':' P_UNSIGNED_INTEGER

    P_UNSIGNED_INTEGER  shift, and go to state 314
    IDENTIFIER          shift, and go to state 138
    '('                 shift, and go to state 139
    '|'                 shift, and go to state 140

    exprn     go to state 315
    operand   go to state 142
    constant  go to state 143


state 274

   93 array_list: name_list '(' bound_pair_list  ')' rest_of_array_list

    ')'  shift, and go to state 316


state 275

   22 single_statement: rt SPEC IDENTIFIER formal_parameter_defn_p separator 

    $default  reduce using rule 22 (single_statement)


state 276

   17 single_statement: CYCLE IDENTIFIER '=' plus_p exprn ','  plus_p exprn ',' plus_p exprn separator

    '-'  shift, and go to state 84
    '+'  shift, and go to state 86

    $default  reduce using rule 59 (plus_p)

    plus_p  go to state 317


state 277

  142 fault_list: P_UNSIGNED_INTEGER rest_of_N_list '-' '>' P_UNSIGNED_INTEGER  rest_of_fault_list

    ','  shift, and go to state 318

    $default  reduce using rule 146 (rest_of_fault_list)

    rest_of_fault_list  go to state 319


state 278

  120 fp_delimiter: comma_p type NAME 

    $default  reduce using rule 120 (fp_delimiter)


state 279

  122 fp_delimiter: comma_p type_p ARRAY  NAME

    NAME  shift, and go to state 320


state 280

  117 rest_of_fp_list: ';' fp_list 

    $default  reduce using rule 117 (rest_of_fp_list)


state 281

  101 switch_bounds: P_UNSIGNED_INTEGER ':' P_UNSIGNED_INTEGER 

    $default  reduce using rule 101 (switch_bounds)


state 282

  102 switch_bounds: '-' P_UNSIGNED_INTEGER ':'  P_UNSIGNED_INTEGER

    P_UNSIGNED_INTEGER  shift, and go to state 321


state 283

  103 switch_bounds: plus_p constant ':'  plus_p constant

    '-'  shift, and go to state 84
    '+'  shift, and go to state 86

    $default  reduce using rule 59 (plus_p)

    plus_p  go to state 322


state 284

  105 rest_of_switch_list: ','  switch_list

    IDENTIFIER  shift, and go to state 65

    name_list    go to state 66
    switch_list  go to state 323


state 285

  104 switch_list: name_list '(' switch_bounds ')' rest_of_switch_list 

    $default  reduce using rule 104 (switch_list)


state 286

   80 query_p: '?' 

    $default  reduce using rule 80 (query_p)


state 287

   44 unconditional_instrn: IDENTIFIER actual_parameters '=' plus_p exprn query_p 

    $default  reduce using rule 44 (unconditional_instrn)


state 288

   47 unconditional_instrn: '-' '>' IDENTIFIER '(' plus_p exprn  ')'

    ')'  shift, and go to state 324


state 289

  188 machine_instrn: P_UNSIGNED_INTEGER '/' P_UNSIGNED_INTEGER '/'  P_UNSIGNED_INTEGER

    P_UNSIGNED_INTEGER  shift, and go to state 325


state 290

  161 machine_instrn: IDENTIFIER P_UNSIGNED_INTEGER IDENTIFIER P_UNSIGNED_INTEGER 
  163               | IDENTIFIER P_UNSIGNED_INTEGER IDENTIFIER P_UNSIGNED_INTEGER  IDENTIFIER

    IDENTIFIER  shift, and go to state 326

    $default  reduce using rule 161 (machine_instrn)


state 291

  165 machine_instrn: IDENTIFIER P_UNSIGNED_INTEGER IDENTIFIER IDENTIFIER  P_UNSIGNED_INTEGER

    P_UNSIGNED_INTEGER  shift, and go to state 327


state 292

  187 machine_instrn: IDENTIFIER P_UNSIGNED_INTEGER '=' P_UNSIGNED_INTEGER 

    $default  reduce using rule 187 (machine_instrn)


state 293

  168 machine_instrn: IDENTIFIER P_UNSIGNED_INTEGER '=' IDENTIFIER 

    $default  reduce using rule 168 (machine_instrn)


state 294

  185 machine_instrn: IDENTIFIER P_UNSIGNED_INTEGER '=' '-'  P_UNSIGNED_INTEGER

    P_UNSIGNED_INTEGER  shift, and go to state 328


state 295

  186 machine_instrn: IDENTIFIER P_UNSIGNED_INTEGER '=' '+'  P_UNSIGNED_INTEGER

    P_UNSIGNED_INTEGER  shift, and go to state 329


state 296

  169 machine_instrn: IDENTIFIER P_UNSIGNED_INTEGER '>' IDENTIFIER 

    $default  reduce using rule 169 (machine_instrn)


state 297

  170 machine_instrn: IDENTIFIER P_UNSIGNED_INTEGER '>' '='  IDENTIFIER

    IDENTIFIER  shift, and go to state 330


state 298

  173 machine_instrn: IDENTIFIER P_UNSIGNED_INTEGER '#' IDENTIFIER 

    $default  reduce using rule 173 (machine_instrn)


state 299

  172 machine_instrn: IDENTIFIER P_UNSIGNED_INTEGER '<' IDENTIFIER 

    $default  reduce using rule 172 (machine_instrn)


state 300

  171 machine_instrn: IDENTIFIER P_UNSIGNED_INTEGER '<' '='  IDENTIFIER

    IDENTIFIER  shift, and go to state 331


state 301

  183 machine_instrn: IDENTIFIER '-' IDENTIFIER P_UNSIGNED_INTEGER 

    $default  reduce using rule 183 (machine_instrn)


state 302

  184 machine_instrn: IDENTIFIER '+' IDENTIFIER P_UNSIGNED_INTEGER 

    $default  reduce using rule 184 (machine_instrn)


state 303

    8 machine_code_sequence: flip_case1z '*' '?' '?' '?' '?'  flip_case0 separator

    $default  reduce using rule 6 (flip_case0)

    flip_case0  go to state 332


state 304

  162 machine_instrn: '=' IDENTIFIER P_UNSIGNED_INTEGER IDENTIFIER  P_UNSIGNED_INTEGER
  164               | '=' IDENTIFIER P_UNSIGNED_INTEGER IDENTIFIER  P_UNSIGNED_INTEGER IDENTIFIER

    P_UNSIGNED_INTEGER  shift, and go to state 333


state 305

  160 machine_instrn: '=' '+' IDENTIFIER P_UNSIGNED_INTEGER 

    $default  reduce using rule 160 (machine_instrn)


state 306

  155 machine_instrn: flip_case0 '*' '=' IDENTIFIER  actual_parameters

    '('  shift, and go to state 68

    $default  reduce using rule 76 (actual_parameters_p)

    ap_start             go to state 69
    actual_parameters_p  go to state 70
    actual_parameters    go to state 334


state 307

  152 machine_instrn: flip_case0 '*' '`' IDENTIFIER  actual_parameters

    '('  shift, and go to state 68

    $default  reduce using rule 76 (actual_parameters_p)

    ap_start             go to state 69
    actual_parameters_p  go to state 70
    actual_parameters    go to state 335


state 308

  153 machine_instrn: flip_case0 '*' '@' IDENTIFIER  actual_parameters

    '('  shift, and go to state 68

    $default  reduce using rule 76 (actual_parameters_p)

    ap_start             go to state 69
    actual_parameters_p  go to state 70
    actual_parameters    go to state 336


state 309

    9 machine_code_sequence: machine_code_sequence flip_case1 '*' machine_instrn flip_case0 separator 

    $default  reduce using rule 9 (machine_code_sequence)


state 310

   66 operand: '(' plus_p exprn ')' 

    $default  reduce using rule 66 (operand)


state 311

  133 simple_cond: plus_p exprn comparator plus_p exprn 
  134            | plus_p exprn comparator plus_p exprn  comparator plus_p exprn

    '='  shift, and go to state 201
    '>'  shift, and go to state 202
    '#'  shift, and go to state 203
    '<'  shift, and go to state 204

    $default  reduce using rule 133 (simple_cond)

    comparator  go to state 337


state 312

   62 rest_of_exprn: operator operand rest_of_exprn 

    $default  reduce using rule 62 (rest_of_exprn)


state 313

  128 rest_of_and_cond: AND and_cond 

    $default  reduce using rule 128 (rest_of_and_cond)


state 314

   97 bound_pair_list: plus_p P_UNSIGNED_INTEGER  ':' plus_p exprn rest_of_bp_list
   98                | plus_p P_UNSIGNED_INTEGER  ':' P_UNSIGNED_INTEGER
  191 constant: P_UNSIGNED_INTEGER 

    ':'  shift, and go to state 338

    ':'       [reduce using rule 191 (constant)]
    $default  reduce using rule 191 (constant)


state 315

   96 bound_pair_list: plus_p exprn  ':' plus_p exprn rest_of_bp_list

    ':'  shift, and go to state 339


state 316

   93 array_list: name_list '(' bound_pair_list ')'  rest_of_array_list

    ','  shift, and go to state 340

    $default  reduce using rule 95 (rest_of_array_list)

    rest_of_array_list  go to state 341


state 317

   17 single_statement: CYCLE IDENTIFIER '=' plus_p exprn ',' plus_p  exprn ',' plus_p exprn separator

    P_UNSIGNED_INTEGER  shift, and go to state 137
    IDENTIFIER          shift, and go to state 138
    '('                 shift, and go to state 139
    '|'                 shift, and go to state 140

    exprn     go to state 342
    operand   go to state 142
    constant  go to state 143


state 318

  145 rest_of_fault_list: ','  fault_list

    P_UNSIGNED_INTEGER  shift, and go to state 48

    fault_list  go to state 343


state 319

  142 fault_list: P_UNSIGNED_INTEGER rest_of_N_list '-' '>' P_UNSIGNED_INTEGER rest_of_fault_list 

    $default  reduce using rule 142 (fault_list)


state 320

  122 fp_delimiter: comma_p type_p ARRAY NAME 

    $default  reduce using rule 122 (fp_delimiter)


state 321

  102 switch_bounds: '-' P_UNSIGNED_INTEGER ':' P_UNSIGNED_INTEGER 

    $default  reduce using rule 102 (switch_bounds)


state 322

  103 switch_bounds: plus_p constant ':' plus_p  constant

    P_UNSIGNED_INTEGER  shift, and go to state 137

    constant  go to state 344


state 323

  105 rest_of_switch_list: ',' switch_list 

    $default  reduce using rule 105 (rest_of_switch_list)


state 324

   47 unconditional_instrn: '-' '>' IDENTIFIER '(' plus_p exprn ')' 

    $default  reduce using rule 47 (unconditional_instrn)


state 325

  188 machine_instrn: P_UNSIGNED_INTEGER '/' P_UNSIGNED_INTEGER '/' P_UNSIGNED_INTEGER 

    $default  reduce using rule 188 (machine_instrn)


state 326

  163 machine_instrn: IDENTIFIER P_UNSIGNED_INTEGER IDENTIFIER P_UNSIGNED_INTEGER IDENTIFIER 

    $default  reduce using rule 163 (machine_instrn)


state 327

  165 machine_instrn: IDENTIFIER P_UNSIGNED_INTEGER IDENTIFIER IDENTIFIER P_UNSIGNED_INTEGER 

    $default  reduce using rule 165 (machine_instrn)


state 328

  185 machine_instrn: IDENTIFIER P_UNSIGNED_INTEGER '=' '-' P_UNSIGNED_INTEGER 

    $default  reduce using rule 185 (machine_instrn)


state 329

  186 machine_instrn: IDENTIFIER P_UNSIGNED_INTEGER '=' '+' P_UNSIGNED_INTEGER 

    $default  reduce using rule 186 (machine_instrn)


state 330

  170 machine_instrn: IDENTIFIER P_UNSIGNED_INTEGER '>' '=' IDENTIFIER 

    $default  reduce using rule 170 (machine_instrn)


state 331

  171 machine_instrn: IDENTIFIER P_UNSIGNED_INTEGER '<' '=' IDENTIFIER 

    $default  reduce using rule 171 (machine_instrn)


state 332

    8 machine_code_sequence: flip_case1z '*' '?' '?' '?' '?' flip_case0  separator

    NEWLINE  shift, and go to state 26
    ';'      shift, and go to state 29

    separator  go to state 345


state 333

  162 machine_instrn: '=' IDENTIFIER P_UNSIGNED_INTEGER IDENTIFIER P_UNSIGNED_INTEGER 
  164               | '=' IDENTIFIER P_UNSIGNED_INTEGER IDENTIFIER P_UNSIGNED_INTEGER  IDENTIFIER

    IDENTIFIER  shift, and go to state 346

    $default  reduce using rule 162 (machine_instrn)


state 334

  155 machine_instrn: flip_case0 '*' '=' IDENTIFIER actual_parameters 

    $default  reduce using rule 155 (machine_instrn)


state 335

  152 machine_instrn: flip_case0 '*' '`' IDENTIFIER actual_parameters 

    $default  reduce using rule 152 (machine_instrn)


state 336

  153 machine_instrn: flip_case0 '*' '@' IDENTIFIER actual_parameters 

    $default  reduce using rule 153 (machine_instrn)


state 337

  134 simple_cond: plus_p exprn comparator plus_p exprn comparator  plus_p exprn

    '-'  shift, and go to state 84
    '+'  shift, and go to state 86

    $default  reduce using rule 59 (plus_p)

    plus_p  go to state 347


state 338

   97 bound_pair_list: plus_p P_UNSIGNED_INTEGER ':'  plus_p exprn rest_of_bp_list
   98                | plus_p P_UNSIGNED_INTEGER ':'  P_UNSIGNED_INTEGER

    P_UNSIGNED_INTEGER  shift, and go to state 348
    '-'                 shift, and go to state 84
    '+'                 shift, and go to state 86

    P_UNSIGNED_INTEGER  [reduce using rule 59 (plus_p)]
    $default            reduce using rule 59 (plus_p)

    plus_p  go to state 349


state 339

   96 bound_pair_list: plus_p exprn ':'  plus_p exprn rest_of_bp_list

    '-'  shift, and go to state 84
    '+'  shift, and go to state 86

    $default  reduce using rule 59 (plus_p)

    plus_p  go to state 350


state 340

   94 rest_of_array_list: ','  array_list

    IDENTIFIER  shift, and go to state 65

    name_list   go to state 148
    array_list  go to state 351


state 341

   93 array_list: name_list '(' bound_pair_list ')' rest_of_array_list 

    $default  reduce using rule 93 (array_list)


state 342

   17 single_statement: CYCLE IDENTIFIER '=' plus_p exprn ',' plus_p exprn  ',' plus_p exprn separator

    ','  shift, and go to state 352


state 343

  145 rest_of_fault_list: ',' fault_list 

    $default  reduce using rule 145 (rest_of_fault_list)


state 344

  103 switch_bounds: plus_p constant ':' plus_p constant 

    $default  reduce using rule 103 (switch_bounds)


state 345

    8 machine_code_sequence: flip_case1z '*' '?' '?' '?' '?' flip_case0 separator 

    $default  reduce using rule 8 (machine_code_sequence)


state 346

  164 machine_instrn: '=' IDENTIFIER P_UNSIGNED_INTEGER IDENTIFIER P_UNSIGNED_INTEGER IDENTIFIER 

    $default  reduce using rule 164 (machine_instrn)


state 347

  134 simple_cond: plus_p exprn comparator plus_p exprn comparator plus_p  exprn

    P_UNSIGNED_INTEGER  shift, and go to state 137
    IDENTIFIER          shift, and go to state 138
    '('                 shift, and go to state 139
    '|'                 shift, and go to state 140

    exprn     go to state 353
    operand   go to state 142
    constant  go to state 143


state 348

   98 bound_pair_list: plus_p P_UNSIGNED_INTEGER ':' P_UNSIGNED_INTEGER 

    $default  reduce using rule 98 (bound_pair_list)


state 349

   97 bound_pair_list: plus_p P_UNSIGNED_INTEGER ':' plus_p  exprn rest_of_bp_list

    P_UNSIGNED_INTEGER  shift, and go to state 137
    IDENTIFIER          shift, and go to state 138
    '('                 shift, and go to state 139
    '|'                 shift, and go to state 140

    exprn     go to state 354
    operand   go to state 142
    constant  go to state 143


state 350

   96 bound_pair_list: plus_p exprn ':' plus_p  exprn rest_of_bp_list

    P_UNSIGNED_INTEGER  shift, and go to state 137
    IDENTIFIER          shift, and go to state 138
    '('                 shift, and go to state 139
    '|'                 shift, and go to state 140

    exprn     go to state 355
    operand   go to state 142
    constant  go to state 143


state 351

   94 rest_of_array_list: ',' array_list 

    $default  reduce using rule 94 (rest_of_array_list)


state 352

   17 single_statement: CYCLE IDENTIFIER '=' plus_p exprn ',' plus_p exprn ','  plus_p exprn separator

    '-'  shift, and go to state 84
    '+'  shift, and go to state 86

    $default  reduce using rule 59 (plus_p)

    plus_p  go to state 356


state 353

  134 simple_cond: plus_p exprn comparator plus_p exprn comparator plus_p exprn 

    $default  reduce using rule 134 (simple_cond)


state 354

   97 bound_pair_list: plus_p P_UNSIGNED_INTEGER ':' plus_p exprn  rest_of_bp_list

    ','  shift, and go to state 357

    $default  reduce using rule 100 (rest_of_bp_list)

    rest_of_bp_list  go to state 358


state 355

   96 bound_pair_list: plus_p exprn ':' plus_p exprn  rest_of_bp_list

    ','  shift, and go to state 357

    $default  reduce using rule 100 (rest_of_bp_list)

    rest_of_bp_list  go to state 359


state 356

   17 single_statement: CYCLE IDENTIFIER '=' plus_p exprn ',' plus_p exprn ',' plus_p  exprn separator

    P_UNSIGNED_INTEGER  shift, and go to state 137
    IDENTIFIER          shift, and go to state 138
    '('                 shift, and go to state 139
    '|'                 shift, and go to state 140

    exprn     go to state 360
    operand   go to state 142
    constant  go to state 143


state 357

   99 rest_of_bp_list: ','  bound_pair_list

    '-'  shift, and go to state 84
    '+'  shift, and go to state 86

    $default  reduce using rule 59 (plus_p)

    plus_p           go to state 273
    bound_pair_list  go to state 361


state 358

   97 bound_pair_list: plus_p P_UNSIGNED_INTEGER ':' plus_p exprn rest_of_bp_list 

    $default  reduce using rule 97 (bound_pair_list)


state 359

   96 bound_pair_list: plus_p exprn ':' plus_p exprn rest_of_bp_list 

    $default  reduce using rule 96 (bound_pair_list)


state 360

   17 single_statement: CYCLE IDENTIFIER '=' plus_p exprn ',' plus_p exprn ',' plus_p exprn  separator

    NEWLINE  shift, and go to state 26
    ';'      shift, and go to state 29

    separator  go to state 362


state 361

   99 rest_of_bp_list: ',' bound_pair_list 

    $default  reduce using rule 99 (rest_of_bp_list)


state 362

   17 single_statement: CYCLE IDENTIFIER '=' plus_p exprn ',' plus_p exprn ',' plus_p exprn separator 

    $default  reduce using rule 17 (single_statement)